Contract Pipeline Scripts

protocol-units/settlement/mcr/contracts/foundry.toml

@@ -10,5 +10,8 @@ extra_output = ["storageLayout"]
 solc = "0.8.26"
 evm_version = "cancun"
 
+fs_permissions = [{ access = "read-write", path = "./script/"}]
+
 [profile.dependencies]
 openzeppelin = { git = "https://github.com/OpenZeppelin/openzeppelin-contracts", tag = "v4.7.0" }
+

protocol-units/settlement/mcr/contracts/script/DeployMCRStaking.s.sol

@@ -86,4 +86,4 @@ contract DeployMCRStaking is Script {
         // time.lock.execute(to, value, payload, predecessor, salt);
         // gnosis safe has a UI for this
     }
-}
+}

protocol-units/settlement/mcr/contracts/script/MovementDeployer.s.sol

@@ -0,0 +1,269 @@
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+import {MOVEToken} from "../src/token/MOVEToken.sol";
+import {stlMoveToken} from "../src/token/stlMoveToken.sol";
+import {MovementStaking} from "../src/staking/MovementStaking.sol";
+import {MCR} from "../src/settlement/MCR.sol";
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {TimelockController} from "@openzeppelin/contracts/governance/TimelockController.sol";
+import { Helper } from "./helpers/Helper.sol";
+import { Vm } from "forge-std/Vm.sol";
+import { stdJson } from "forge-std/StdJson.sol";
+
+contract MovementDeployer is Script {
+
+    using stdJson for string;
+
+    TransparentUpgradeableProxy public mcrProxy;
+    TransparentUpgradeableProxy public stakingProxy;
+    TransparentUpgradeableProxy public stlMoveProxy;
+    TransparentUpgradeableProxy public moveProxy;
+    ProxyAdmin public admin;
+    TimelockController public timelock;
+    Deployment public deployment;
+    Helper helper = new Helper();
+    bool public record = true;
+
+    string public mcrSignature = "initialize(address,uint256,uint256,uint256,address[])";
+    string public stakingSignature = "initialize(address)";
+    string public stlMoveSignature = "initialize(string,string,address)";
+    string public moveSignature = "initialize()";
+    address public ZERO = address(0x0);
+
+    struct Deployment {
+        address mcr;
+        address mcrAdmin;
+        address staking;
+        address stakingAdmin;
+        address move;
+        address moveAdmin;
+        address stlMove;
+        address stlMoveAdmin;
+        address timelock;
+        address multisig;
+    }
+
+    function run() external {
+        uint256 minDelay = 1 days;
+        address[] memory proposers = new address[](5);
+        address[] memory executors = new address[](1);
+        proposers[0] = helper.s2a("Andy");
+        proposers[1] = helper.s2a("Bob");
+        proposers[2] = helper.s2a("Charlie");
+        proposers[3] = helper.s2a("David");
+        proposers[4] = helper.s2a("Eve");
+        executors[0] = helper.s2a("MultisigAddress");
+        address adminAddress = ZERO;
+
+        _loadDeployments();
+
+        uint256 signer = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(signer);
+
+        if (deployment.timelock == ZERO) {
+            timelock = new TimelockController(minDelay, proposers, executors, adminAddress);
+            deployment.timelock = address(timelock);
+        }
+
+        deployment.moveAdmin == ZERO && deployment.move == ZERO ?
+            _deployMove() : deployment.moveAdmin != ZERO && deployment.move != ZERO ?
+                _upgradeMove() : revert("MOVE: both admin and proxy should be registered");
+
+        deployment.stakingAdmin == ZERO && deployment.staking == ZERO && deployment.move != ZERO ?
+            _deployStaking() : deployment.stakingAdmin != ZERO && deployment.staking != ZERO ?
+                _upgradeStaking() : revert("STAKING: both admin and proxy should be registered");
+
+        deployment.stlMoveAdmin == ZERO && deployment.stlMove == ZERO && deployment.move != ZERO ?
+            _deployStlMove() : deployment.stlMoveAdmin != ZERO && deployment.stlMove != ZERO ?
+                _upgradeStlMove() : revert("STL: both admin and proxy should be registered");
+
+        deployment.mcrAdmin == ZERO && deployment.mcr == ZERO && deployment.move != ZERO && deployment.staking != ZERO ?
+            _deployMCR(proposers) : deployment.mcrAdmin != ZERO && deployment.mcr != ZERO ?
+                _upgradeMCR() : revert("MCR: both admin and proxy should be registered");
+
+        vm.stopBroadcast();
+
+        if (record) {
+            _writeDeployments();
+        }
+    }
+
+    function _loadDeployments() internal{
+        // load deployments
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/script/helpers/deployments.json");
+        string memory json = vm.readFile(path);
+        bytes memory rawDeploymentData = json.parseRaw(string(abi.encodePacked(".", "mainnet")));
+        deployment = abi.decode(rawDeploymentData, (Deployment));
+    }
+
+    function _writeDeployments() internal {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/script/helpers/test.json");
+        string memory json = "json";
+        string memory a = json.serialize("move", deployment.move);
+        string memory b = json.serialize("moveAdmin", deployment.moveAdmin);
+        string memory c = json.serialize("staking", deployment.staking);
+        string memory d = json.serialize("stakingAdmin", deployment.stakingAdmin);
+        string memory e = json.serialize("stlMove", deployment.stlMove);
+        string memory f = json.serialize("stlMoveAdmin", deployment.stlMoveAdmin);
+        string memory g = json.serialize("mcr", deployment.mcr);
+        string memory h = json.serialize("mcrAdmin", deployment.mcrAdmin);
+        string memory i = json.serialize("timelock", deployment.timelock);
+        string memory j = json.serialize("multisig", deployment.multisig);
+        vm.writeFile(path, j);
+    }
+
+    function _storeAdminDeployment() internal returns (address admin) {
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+        admin = logs[logs.length-2].emitter;
+        console.log("admin", admin);
+    }   
+
+    function _deployMove() internal {
+        console.log("MOVE: deploying");
+        MOVEToken moveImplementation = new MOVEToken();
+        vm.recordLogs();
+        moveProxy = new TransparentUpgradeableProxy(
+            address(moveImplementation),
+            address(timelock),
+            abi.encodeWithSignature(moveSignature)
+        );
+        console.log("MOVE deployment records:");
+        console.log("proxy", address(moveProxy));
+        deployment.move = address(moveProxy);
+        deployment.moveAdmin = _storeAdminDeployment();
+
+    }
+
+    function _upgradeMove() internal {
+        console.log("MOVE: upgrading");
+        MOVEToken newMoveImplementation = new MOVEToken();
+        timelock.schedule(
+            address(deployment.moveAdmin),
+            0,
+            abi.encodeWithSignature(
+                "upgradeAndCall(address,address,bytes)",
+                address(moveProxy),
+                address(newMoveImplementation),
+                ""
+            ),
+            bytes32(0),
+            bytes32(0),
+            block.timestamp + 1 days
+        );
+        console.log("MOVE: upgrade scheduled");
+    }
+
+    function _deployStaking() internal {
+        console.log("STAKING: deploying");
+        MovementStaking stakingImplementation = new MovementStaking();
+        vm.recordLogs();
+        stakingProxy = new TransparentUpgradeableProxy(
+            address(stakingImplementation),
+            address(timelock),
+            abi.encodeWithSignature(stakingSignature, address(moveProxy))
+        );
+        console.log("STAKING deployment records:");
+        console.log("proxy", address(stakingProxy));
+        deployment.staking = address(stakingProxy);
+        deployment.stakingAdmin = _storeAdminDeployment();
+    }
+
+    function _upgradeStaking() internal {
+        console.log("STAKING: upgrading");
+        MovementStaking newStakingImplementation = new MovementStaking();
+        timelock.schedule(
+            address(deployment.stakingAdmin),
+            0,
+            abi.encodeWithSignature(
+                "upgradeAndCall(address,address,bytes)",
+                address(stakingProxy),
+                address(newStakingImplementation),
+                ""
+            ),
+            bytes32(0),
+            bytes32(0),
+            block.timestamp + 1 days
+        );
+        console.log("STAKING: upgrade scheduled");
+    }
+
+    function _deployStlMove() internal {
+        console.log("STL: deploying");
+        stlMoveToken stlMoveImplementation = new stlMoveToken();
+        vm.recordLogs();
+        stlMoveProxy = new TransparentUpgradeableProxy(
+            address(stlMoveImplementation),
+            address(timelock),
+            abi.encodeWithSignature(stlMoveSignature, "STL Move Token", "STL", address(moveProxy))
+        );
+        console.log("STL deployment records:");
+        console.log("proxy", address(stlMoveProxy));
+        deployment.stlMove = address(stlMoveProxy);
+        deployment.stlMoveAdmin = _storeAdminDeployment();
+    }
+
+    function _upgradeStlMove() internal {
+        console.log("STL: upgrading");
+        stlMoveToken newStlMoveImplementation = new stlMoveToken();
+        timelock.schedule(
+            address(deployment.stlMoveAdmin),
+            0,
+            abi.encodeWithSignature(
+                "upgradeAndCall(address,address,bytes)",
+                address(stlMoveProxy),
+                address(newStlMoveImplementation),
+                ""
+            ),
+            bytes32(0),
+            bytes32(0),
+            block.timestamp + 1 days
+        );
+        console.log("STL: upgrade scheduled");
+    }
+
+    function _deployMCR(address[] memory proposers) internal {
+        console.log("MCR: deploying");
+        MCR mcrImplementation = new MCR();
+        vm.recordLogs();
+        mcrProxy = new TransparentUpgradeableProxy(
+            address(mcrImplementation),
+            address(timelock),
+            abi.encodeWithSignature(
+                mcrSignature,
+                address(stakingProxy),
+                128,
+                100 ether,
+                100 ether, 
+                proposers
+            )
+        );
+        console.log("MCR deployment records:");
+        console.log("proxy", address(mcrProxy));
+        deployment.mcr = address(mcrProxy);
+        deployment.mcrAdmin = _storeAdminDeployment();
+    }
+
+    function _upgradeMCR() internal {
+        console.log("MCR: upgrading");
+        MCR newMCRImplementation = new MCR();
+        timelock.schedule(
+            address(deployment.mcrAdmin),
+            0,
+            abi.encodeWithSignature(
+                "upgradeAndCall(address,address,bytes)",
+                address(mcrProxy),
+                address(newMCRImplementation),
+                ""
+            ),
+            bytes32(0),
+            bytes32(0),
+            block.timestamp + 1 days
+        );
+        console.log("MCR: upgrade scheduled");
+    }
+
+}

protocol-units/settlement/mcr/contracts/script/helpers/Helper.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+contract Helper {
+    // string to address
+    function s2a(bytes memory str) public returns (address addr) {
+        bytes32 data = keccak256(str);
+        assembly {
+            mstore(0, data)
+            addr := mload(0)
+        }
+    }
+}

protocol-units/settlement/mcr/contracts/script/helpers/deployments.json

@@ -0,0 +1,14 @@
+{
+    "mainnet": {
+        "mcr": "0x0000000000000000000000000000000000000000",
+        "mcrAdmin": "0x0000000000000000000000000000000000000000",
+        "staking": "0x0000000000000000000000000000000000000000",
+        "stakingAdmin": "0x0000000000000000000000000000000000000000",
+        "stlmove": "0x0000000000000000000000000000000000000000",
+        "stlmoveAdmin": "0x0000000000000000000000000000000000000000",
+        "move": "0x0000000000000000000000000000000000000000",
+        "moveAdmin": "0x0000000000000000000000000000000000000000",
+        "timelock": "0x0000000000000000000000000000000000000000",
+        "multisig": "0x0000000000000000000000000000000000000000"
+    }
+}

protocol-units/settlement/mcr/contracts/script/helpers/test.json

@@ -0,0 +1 @@
+{"mcr":"0xe0d1C060c7fCd0B8024a6486a83f35d3262e4301","mcrAdmin":"0x1d2FBD705240D438F00BC225643C0b342ed0EE35","move":"0x2e6228bC325b29d6EBF22E12c6613c9600ff8AE2","moveAdmin":"0xc6C21729535E83a98061A57Ebf6fa7ccb0D9b349","multisig":"0x0000000000000000000000000000000000000000","staking":"0x21283484Fb059D9E849FCed7B87d3E63Aee5Ff9b","stakingAdmin":"0xbCc31cBb010f6AB27a1B1963C010D1cB4BbbfC33","stlMove":"0x3D48d2B2b176c164C5DE27dB2A7EBea92F7acd5a","stlMoveAdmin":"0x678D8edF4b8D2AC21fAf7eC3314252f56c14819f","timelock":"0xF927E1Ab4b4Eb8D8811e4Ad224bF0eea7004F87c"}