Contract Pipeline Scripts

.gitmodules

@@ -34,3 +34,6 @@
 [submodule "protocol-units/settlement/mcr/contracts/lib/murky"]
 	path = protocol-units/settlement/mcr/contracts/lib/murky
 	url = https://github.com/dmfxyz/murky
+[submodule "protocol-units/settlement/mcr/contracts/protocol-units/settlement/mcr/contracts/lib/safe-smart-account"]
+	path = protocol-units/settlement/mcr/contracts/protocol-units/settlement/mcr/contracts/lib/safe-smart-account
+	url = https://github.com/safe-global/safe-smart-account

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/CoreDeployer.s.sol

@@ -0,0 +1,90 @@
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+import {MOVEToken} from "../src/token/MOVEToken.sol";
+import { Helper } from "./helpers/Helper.sol";
+import { MCRDeployer } from "./MCRDeployer.s.sol";
+import { StakingDeployer } from "./StakingDeployer.s.sol";
+import { StlMoveDeployer } from "./StlMoveDeployer.s.sol";
+import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {TimelockController} from "@openzeppelin/contracts/governance/TimelockController.sol";
+
+contract CoreDeployer is MCRDeployer, StakingDeployer, StlMoveDeployer {
+
+    function run() external override(MCRDeployer, StakingDeployer, StlMoveDeployer) {
+
+        // load config data
+        _loadConfig();
+
+        // Load deployment data
+        _loadDeployments();
+
+        uint256 signer = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(signer);
+
+        // timelock is required for all deployments
+        if (deployment.timelock == ZERO) {
+            timelock = new TimelockController(config.minDelay, config.proposers, config.executors, config.admin);
+            deployment.timelock = address(timelock);
+        }
+
+        // Deploy or upgrade contracts conditionally
+        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() : deployment.mcrAdmin != ZERO && deployment.mcr != ZERO ?
+                _upgradeMCR() : revert("MCR: both admin and proxy should be registered");
+
+        vm.stopBroadcast();
+
+        // Only write to file if chainid is not running a foundry local chain
+        if (block.chainid != foundryChainId) {
+            _writeDeployments();
+        }
+    }
+
+    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");
+    }
+
+}

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/MCRDeployer.s.sol

@@ -0,0 +1,79 @@
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+import {MCR} from "../src/settlement/MCR.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";
+
+contract MCRDeployer is Helper {
+
+    function run() external virtual {
+
+        // Load deployment data
+        _loadDeployments();
+
+        uint256 signer = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(signer);
+
+        // timelock is required for all deployments
+        if (deployment.timelock == ZERO) {
+            timelock = new TimelockController(config.minDelay, config.proposers, config.executors, config.admin);
+            deployment.timelock = address(timelock);
+        }
+
+        deployment.mcrAdmin == ZERO && deployment.mcr == ZERO && deployment.move != ZERO && deployment.staking != ZERO ?
+            _deployMCR() : deployment.mcrAdmin != ZERO && deployment.mcr != ZERO ?
+                _upgradeMCR() : revert("MCR: both admin and proxy should be registered");
+
+        vm.stopBroadcast();
+
+        // Only write to file if chainid is not running a foundry local chain
+        if (block.chainid != foundryChainId) {
+            _writeDeployments();
+        }
+    }
+
+    function _deployMCR() 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, 
+                config.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/StakingDeployer.s.sol

@@ -0,0 +1,75 @@
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+import {MovementStaking} from "../src/staking/MovementStaking.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";
+
+contract StakingDeployer is Helper {
+
+    function run() external virtual {
+
+         // load config data
+        _loadConfig();
+
+        // Load deployment data
+        _loadDeployments();
+
+        uint256 signer = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(signer);
+
+        // timelock is required for all deployments
+        if (deployment.timelock == ZERO) {
+            timelock = new TimelockController(config.minDelay, config.proposers, config.executors, config.admin);
+            deployment.timelock = address(timelock);
+        }
+
+        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");
+
+        vm.stopBroadcast();
+
+        // Only write to file if chainid is not running a foundry local chain
+        if (block.chainid != foundryChainId) {
+            _writeDeployments();
+        }
+    }
+
+    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");
+    }
+
+}

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

@@ -0,0 +1,75 @@
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+import {stlMoveToken} from "../src/token/stlMoveToken.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";
+
+contract StlMoveDeployer is Helper {
+
+    function run() external virtual {
+
+         // load config data
+        _loadConfig();
+
+        // Load deployment data
+        _loadDeployments();
+
+        uint256 signer = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(signer);
+
+        // timelock is required for all deployments
+        if (deployment.timelock == ZERO) {
+            timelock = new TimelockController(config.minDelay, config.proposers, config.executors, config.admin);
+            deployment.timelock = address(timelock);
+        }
+
+        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");
+
+        vm.stopBroadcast();
+
+        // Only write to file if chainid is not running a foundry local chain
+        if (block.chainid != foundryChainId) {
+            _writeDeployments();
+        }
+    }
+
+    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");
+    }
+
+}