fix(nft): fix s2 badges remigration

packages/nfts/contracts/trailblazers-season-2/BadgeRecruitmentV2.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import "./BadgeRecruitment.sol";
+
+contract BadgeRecruitmentV2 is BadgeRecruitment {
+    /// @notice Events
+    event RecruitmentReset(address indexed user, uint256 indexed s1TokenId, uint256 s1BadgeId);
+
+    /// @notice Errors
+    error RECRUITMENT_ALREADY_COMPLETED();
+
+    /// @notice Updated version function
+    function version() external pure virtual returns (string memory) {
+        return "V2";
+    }
+
+    /// @notice Start a recruitment for a badge
+    /// @param _s1BadgeId The badge ID (s1)
+    /// @dev Not all badges are eligible for recruitment at the same time
+    /// @dev Defines a cooldown for the recruitment to be complete
+    /// @dev the cooldown is lesser the higher the Pass Tier
+    /// @dev Must be called from the s1 badges contract
+    function startRecruitment(
+        address _user,
+        uint256 _s1BadgeId,
+        uint256 _s1TokenId
+    )
+        external
+        virtual
+        onlyRole(S1_BADGES_ROLE)
+        recruitmentOpen(_s1BadgeId)
+        isNotMigrating(_user)
+        hasntMigratedInCycle(_s1BadgeId, _user, RecruitmentType.Migration)
+    {
+        if (s1Badges.ownerOf(_s1TokenId) != _user) {
+            revert TOKEN_NOT_OWNED();
+        }
+        _startRecruitment(_user, _s1BadgeId, _s1TokenId, RecruitmentType.Migration);
+    }
+
+    /// @notice Disable all current recruitments
+    /// @dev Bypasses the default date checks
+    function forceDisableAllRecruitments() external virtual onlyRole(DEFAULT_ADMIN_ROLE) {
+        forceDisableRecruitments();
+    }
+
+    /// @notice Get the active recruitment for a user
+    /// @param _user The user address
+    /// @return The active recruitment
+    function getActiveRecruitmentsFor(address _user) public view returns (Recruitment[] memory) {
+        if (recruitments[_user].length == 0) {
+            revert RECRUITMENT_NOT_STARTED();
+        }
+        return recruitments[_user];
+    }
+
+    /// @notice Reset a recruitment that hasn't been completed
+    /// @param _user The user address
+    /// @param _recruitmentIdx The recruitment index
+    /// @param _s1TokenId The s1 token ID
+    /// @dev Must be called from the s1 badges contract
+    function resetRecruitment(
+        address _user,
+        uint256 _recruitmentIdx,
+        uint256 _s1TokenId
+    )
+        public
+        virtual
+        onlyRole(S1_BADGES_ROLE)
+    {
+        Recruitment memory recruitment_ = recruitments[_user][_recruitmentIdx];
+        if (recruitment_.s1TokenId != _s1TokenId) {
+            revert RECRUITMENT_NOT_STARTED();
+        }
+
+        if (recruitment_.s2TokenId != 0) {
+            revert RECRUITMENT_ALREADY_COMPLETED();
+        }
+
+        // reset
+        uint256 s1BadgeId_ = recruitment_.s1BadgeId;
+
+        //delete
+        delete recruitments[_user][_recruitmentIdx];
+        recruitmentCycleUniqueMints[recruitmentCycleId][_user][s1BadgeId_][RecruitmentType.Undefined]
+        = false;
+        recruitmentCycleUniqueMints[recruitmentCycleId][_user][s1BadgeId_][RecruitmentType.Claim] =
+            false;
+        recruitmentCycleUniqueMints[recruitmentCycleId][_user][s1BadgeId_][RecruitmentType.Migration]
+        = false;
+
+        emit RecruitmentReset(_user, _s1TokenId, s1BadgeId_);
+    }
+}

packages/nfts/contracts/trailblazers-season-2/TrailblazersS1BadgesV4.sol

@@ -59,7 +59,7 @@ contract TrailblazersBadgesV4 is TrailblazersBadgesV3 {
 
     /// @notice Start recruitment for a badge
     /// @param _badgeId Badge id
-    function startRecruitment(uint256 _badgeId) public {
+    function startRecruitment(uint256 _badgeId) public virtual {
         if (recruitmentLockDuration == 0) {
             revert RECRUITMENT_LOCK_DURATION_NOT_SET();
         }

packages/nfts/contracts/trailblazers-season-2/TrailblazersS1BadgesV5.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import "./TrailblazersS1BadgesV4.sol";
+import "./BadgeRecruitment.sol";
+import "./BadgeRecruitmentV2.sol";
+
+contract TrailblazersBadgesV5 is TrailblazersBadgesV4 {
+    /// @notice Errors
+    error RECRUITMENT_ALREADY_COMPLETED();
+    error NOT_OWNER();
+    error NOT_IMPLEMENTED();
+    /// @notice Updated version function
+    /// @return Version string
+
+    function version() external pure virtual override returns (string memory) {
+        return "V5";
+    }
+
+    BadgeRecruitmentV2 public recruitmentContractV2;
+
+    function setRecruitmentContractV2(address _recruitmentContractV2) public onlyOwner {
+        recruitmentContractV2 = BadgeRecruitmentV2(_recruitmentContractV2);
+    }
+
+    /// @notice Start recruitment for a badge
+    /// @param _tokenId Token ID
+    function startRecruitment(uint256 _badgeId, uint256 _tokenId) public {
+        if (recruitmentLockDuration == 0) {
+            revert RECRUITMENT_LOCK_DURATION_NOT_SET();
+        }
+        if (ownerOf(_tokenId) != _msgSender()) {
+            revert NOT_OWNER();
+        }
+
+        if (unlockTimestamps[_tokenId] > block.timestamp) {
+            revert BADGE_LOCKED();
+        }
+
+        unlockTimestamps[_tokenId] = block.timestamp + recruitmentLockDuration;
+        recruitmentContractV2.startRecruitment(_msgSender(), _badgeId, _tokenId);
+    }
+
+    /// @notice Deprecated of legacy function
+    function startRecruitment(uint256 /*_badgeId*/ ) public virtual override {
+        revert NOT_IMPLEMENTED();
+    }
+
+    /// @notice Reset an ongoing migration
+    /// @param _tokenId Token ID
+    function resetMigration(uint256 _tokenId) public virtual {
+        if (ownerOf(_tokenId) != _msgSender()) {
+            revert NOT_OWNER();
+        }
+
+        BadgeRecruitment.Recruitment[] memory recruitments_ =
+            recruitmentContractV2.getActiveRecruitmentsFor(_msgSender());
+
+        for (uint256 i = 0; i < recruitments_.length; i++) {
+            // check if the recruitment is ongoing
+            // AND if it isn't finished (s2TokenId == 0)
+            if (recruitments_[i].s1TokenId == _tokenId && recruitments_[i].s2TokenId == 0) {
+                unlockTimestamps[_tokenId] = 0;
+                recruitmentContractV2.resetRecruitment(_msgSender(), i, _tokenId);
+                return;
+            }
+        }
+
+        revert RECRUITMENT_ALREADY_COMPLETED();
+    }
+}

packages/nfts/package.json

@@ -41,7 +41,8 @@
     "tbz:upgradeV3:hekla": "forge clean && pnpm compile && forge script script/trailblazers-badges/sol/UpgradeV3.s.sol --rpc-url https://rpc.hekla.taiko.xyz --broadcast   --gas-estimate-multiplier 200",
     "tbz:upgradeV3:mainnet": "forge clean && pnpm compile && forge script script/trailblazers-badges/sol/UpgradeV3.s.sol --rpc-url https://rpc.mainnet.taiko.xyz --broadcast   --gas-estimate-multiplier 100",
     "tbz:upgradeV4:mainnet": "forge clean && pnpm compile && forge script script/trailblazers-badges/UpgradeV4.s.sol --rpc-url https://rpc.mainnet.taiko.xyz --broadcast   --gas-estimate-multiplier 100",
-    "tbz-s2:upgradeV2:mainnet": "forge clean && pnpm compile && forge script script/trailblazers-season-2/UpgradeV2.s.sol --rpc-url https://rpc.mainnet.taiko.xyz --broadcast   --gas-estimate-multiplier 100"
+    "tbz-s2:upgradeV2:mainnet": "forge clean && pnpm compile && forge script script/trailblazers-season-2/UpgradeV2.s.sol --rpc-url https://rpc.mainnet.taiko.xyz --broadcast   --gas-estimate-multiplier 100",
+    "tbz-s2:upgradeRecruitmentV2:hekla": "forge clean && pnpm compile && forge script script/trailblazers-season-2/RecruitmentUpgradeV2.s.sol --rpc-url https://rpc.hekla.taiko.xyz --broadcast   --gas-estimate-multiplier 200"
   },
   "devDependencies": {
     "@types/node": "^20.11.30",

packages/nfts/script/trailblazers-season-2/RecruitmentUpgradeV2.s.sol

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import { UtilsScript, MockBlacklist } from "./Utils.s.sol";
+import { Script, console } from "forge-std/src/Script.sol";
+import { Merkle } from "murky/Merkle.sol";
+import { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import { TrailblazersBadges } from "../../contracts/trailblazers-badges/TrailblazersBadges.sol";
+import { IMinimalBlacklist } from "@taiko/blacklist/IMinimalBlacklist.sol";
+
+import "../../contracts/trailblazers-season-2/TrailblazersBadgesS2.sol";
+
+import "../../contracts/trailblazers-season-2/TrailblazersS1BadgesV5.sol";
+
+contract UpgradeV2 is Script {
+    // setup
+    UtilsScript public utils;
+    string public jsonLocation;
+    uint256 public deployerPrivateKey;
+    address public deployerAddress;
+
+    // deployment vars
+    TrailblazersBadgesV5 public tokenV5;
+    BadgeRecruitmentV2 public badgeRecruitmentV2;
+
+    // mainnet config
+    address public s1TokenAddress = 0xa20a8856e00F5ad024a55A663F06DCc419FFc4d5;
+    address public badgeRecruitmentAddress = 0xa9Ceb04F3aF71fF123409d426A92BABb5124970C;
+
+    // hekla config
+    string baseURI =
+        "https://taikonfts.4everland.link/ipfs/bafybeiatuzeeeznd3hi5qiulslxcjd22ebu45t4fra2jvi3smhocr2c66a";
+
+    IMinimalBlacklist blacklist = IMinimalBlacklist(0xe61E9034b5633977eC98E302b33e321e8140F105);
+    address claimMintSigner = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
+    address recruitmentSigner = 0x3cda4F2EaC3fc2FdE78B3DFFe1A1A1Eff88c68c5;
+
+    uint256 public MAX_INFLUENCES = 5;
+    uint256 public COOLDOWN_RECRUITMENT = 10 minutes;
+    uint256 public COOLDOWN_INFLUENCE = 5 minutes;
+    uint256 public INFLUENCE_WEIGHT_PERCENT = 9;
+    uint256 public MAX_INFLUENCES_DIVIDER = 100;
+    uint256 public DEFAULT_CYCLE_DURATION = 7 days;
+    uint256 public s1EndDate = 1_734_350_400; // Dec 16th 2024, noon UTC
+    uint256 public S1_LOCK_DURATION = (s1EndDate - block.timestamp);
+
+    function setUp() public {
+        utils = new UtilsScript();
+        utils.setUp();
+
+        jsonLocation = utils.getContractJsonLocation();
+        deployerPrivateKey = utils.getPrivateKey();
+        deployerAddress = utils.getAddress();
+    }
+
+    function run() public {
+        vm.startBroadcast(deployerPrivateKey);
+
+        address impl;
+        address proxy;
+        TrailblazersBadgesV4 s1Token;
+        TrailblazersBadgesS2 s2Token;
+        BadgeRecruitment badgeRecruitment;
+
+        if (block.chainid == 167_000) {
+            // mainnet, use existing contract
+            s1Token = TrailblazersBadgesV4(s1TokenAddress);
+            badgeRecruitment = BadgeRecruitment(badgeRecruitmentAddress);
+        } else {
+            // non-mainnet, deploy contract chain
+            impl = address(new TrailblazersBadges());
+            blacklist = new MockBlacklist();
+            proxy = address(
+                new ERC1967Proxy(
+                    impl,
+                    abi.encodeCall(
+                        TrailblazersBadges.initialize,
+                        (deployerAddress, baseURI, claimMintSigner, blacklist)
+                    )
+                )
+            );
+
+            TrailblazersBadges s1TokenV2 = TrailblazersBadges(proxy);
+
+            // upgrade s1 contract to v4
+            s1TokenV2.upgradeToAndCall(
+                address(new TrailblazersBadgesV4()),
+                abi.encodeCall(TrailblazersBadgesV4.version, ())
+            );
+
+            s1Token = TrailblazersBadgesV4(address(s1TokenV2));
+
+            // deploy recruitment contract
+            BadgeRecruitment.Config memory config = BadgeRecruitment.Config(
+                COOLDOWN_RECRUITMENT,
+                COOLDOWN_INFLUENCE,
+                INFLUENCE_WEIGHT_PERCENT,
+                MAX_INFLUENCES,
+                MAX_INFLUENCES_DIVIDER,
+                DEFAULT_CYCLE_DURATION
+            );
+            impl = address(new BadgeRecruitment());
+            proxy = address(
+                new ERC1967Proxy(
+                    impl,
+                    abi.encodeCall(
+                        BadgeRecruitment.initialize,
+                        (address(s1Token), address(s2Token), recruitmentSigner, config)
+                    )
+                )
+            );
+
+            badgeRecruitment = BadgeRecruitment(proxy);
+        }
+
+        // upgrade token contract
+        s1Token.upgradeToAndCall(
+            address(new TrailblazersBadgesV5()), abi.encodeCall(TrailblazersBadgesV5.version, ())
+        );
+
+        tokenV5 = TrailblazersBadgesV5(address(s1Token));
+        console.log("Upgraded TrailblazersBadgesV4 to:", address(tokenV5));
+
+        // upgrade recruitment contract
+        badgeRecruitment.upgradeToAndCall(
+            address(new BadgeRecruitmentV2()), abi.encodeCall(BadgeRecruitmentV2.version, ())
+        );
+
+        badgeRecruitmentV2 = BadgeRecruitmentV2(address(badgeRecruitment));
+        console.log("Upgraded BadgeRecruitment to:", address(badgeRecruitmentV2));
+
+        // set upgraded recruitment contract
+        tokenV5.setRecruitmentContractV2(address(badgeRecruitmentV2));
+        console.log("Set recruitment contract to:", address(badgeRecruitmentV2));
+
+        /*
+        token.upgradeToAndCall(
+        address(new TrailblazersBadgesS2()), abi.encodeCall(TrailblazersBadgesS2.version, ())
+        );
+
+        token = TrailblazersBadgesS2(address(token));
+
+        console.log("Upgraded TrailblazersBadgesV3 to:", address(token));
+
+        // update uri
+        token.setUri(
+        "https://taikonfts.4everland.link/ipfs/bafybeief7o4u6f676e6uz4yt4cv34ai4mesd7motoq6y4xxaoyjfbna5de"
+        );
+        console.log("Updated token URI");*/
+    }
+}

packages/nfts/test/trailblazers-season-2/BadgeRecruitment.t.sol

@@ -16,7 +16,7 @@ import { TrailblazersBadgesV4 } from
     "../../contracts/trailblazers-season-2/TrailblazersS1BadgesV4.sol";
 import { BadgeRecruitment } from "../../contracts/trailblazers-season-2/BadgeRecruitment.sol";
 
-contract TrailblazersBadgesS2Test is Test {
+contract BadgeRecruitmentTest is Test {
     UtilsScript public utils;
 
     TrailblazersBadgesV4 public s1BadgesV4;