Feat/script migration

foundry.toml

@@ -12,6 +12,7 @@ optimizer = true
 optimizer_runs = 1000
 solc_version = "0.8.22"
 ffi = true
+fs_permissions = [{ access = "read-write", path = "./scripts/vanity.json"}]
 
 [fuzz]
 runs = 10000

scripts/DeployAgTokenSideChainMultiBridge.s.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.12;
+
+import "forge-std/Script.sol";
+import "utils/src/CommonUtils.sol";
+import { AgTokenSideChainMultiBridge } from "contracts/agToken/AgTokenSideChainMultiBridge.sol";
+import { LayerZeroBridgeToken } from "contracts/agToken/layerZero/LayerZeroBridgeToken.sol";
+import { ICoreBorrow } from "contracts/interfaces/ICoreBorrow.sol";
+import { Treasury } from "contracts/treasury/Treasury.sol";
+import { ImmutableCreate2Factory } from "contracts/interfaces/external/create2/ImmutableCreate2Factory.sol";
+
+contract DeployAgTokenSideChainMultiBridge is Script, CommonUtils {
+    using stdJson for string;
+
+    string constant JSON_VANITY_PATH = "./scripts/vanity.json";
+
+    function run() external {
+        /** TODO  complete */
+        string memory stableName = vm.envString("STABLE_NAME");
+        /** END  complete */
+
+        uint256 deployerPrivateKey = vm.deriveKey(vm.envString("MNEMONIC_MAINNET"), "m/44'/60'/0'/0/", 0);
+        address deployer = vm.addr(deployerPrivateKey);
+        string memory json = vm.readFile(JSON_VANITY_PATH);
+        bytes32 salt = bytes32(abi.encodePacked(deployer, abi.encodePacked(uint96(json.readUint("$.init")))));
+        uint256 chainId = vm.envUint("CHAIN_ID");
+
+        address proxyAdmin = _chainToContract(chainId, ContractType.ProxyAdmin);
+        address coreBorrow = _chainToContract(chainId, ContractType.CoreBorrow);
+        ILayerZeroEndpoint lzEndpoint = _lzEndPoint(chainId);
+
+        vm.startBroadcast(deployerPrivateKey);
+
+        Treasury treasuryImpl = new Treasury();
+        console.log("Treasury Implementation deployed at", address(treasuryImpl));
+
+        Treasury treasuryProxy = Treasury(
+            address(
+                _deployUpgradeable(
+                    proxyAdmin,
+                    address(treasuryImpl),
+                    abi.encodeWithSelector(
+                        Treasury.initialize.selector,
+                        coreBorrow,
+                        ImmutableCreate2Factory(IMMUTABLE_CREATE2_FACTORY_ADDRESS).findCreate2Address(
+                            salt,
+                            type(AgTokenSideChainMultiBridge).creationCode
+                        )
+                    )
+                )
+            )
+        );
+        console.log("Treasury Proxy deployed at", address(treasuryProxy));
+
+        AgTokenSideChainMultiBridge angleImpl = new AgTokenSideChainMultiBridge();
+        console.log("AgTokenSideChainMultiBridge Implementation deployed at", address(angleImpl));
+
+        AgTokenSideChainMultiBridge angleProxy = AgTokenSideChainMultiBridge(
+            ImmutableCreate2Factory(IMMUTABLE_CREATE2_FACTORY_ADDRESS).safeCreate2(
+                salt,
+                type(AgTokenSideChainMultiBridge).creationCode
+            )
+        );
+        console.log("AgTokenSideChainMultiBridge Proxy deployed at", address(angleProxy));
+
+        angleProxy.initialize(
+            string.concat("Angle ag", stableName),
+            string.concat("ag", stableName),
+            address(treasuryProxy)
+        );
+
+        LayerZeroBridgeToken lzImpl = new LayerZeroBridgeToken();
+        console.log("LayerZeroBridgeToken Implementation deployed at", address(lzImpl));
+        LayerZeroBridgeToken lzProxy = LayerZeroBridgeToken(
+            address(
+                _deployUpgradeable(
+                    proxyAdmin,
+                    address(lzImpl),
+                    abi.encodeWithSelector(
+                        LayerZeroBridgeToken.initialize.selector,
+                        string.concat("LayerZero Bridge ag", stableName),
+                        string.concat("LZ-ag", stableName),
+                        address(lzEndpoint),
+                        address(treasuryProxy),
+                        0
+                    )
+                )
+            )
+        );
+        console.log("LayerZeroBridgeToken Proxy deployed at", address(lzProxy));
+
+        vm.stopBroadcast();
+    }
+}

scripts/DeployChain.s.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.12;
+
+import "forge-std/Script.sol";
+import "utils/src/CommonUtils.sol";
+import { ProxyAdmin } from "contracts/external/ProxyAdmin.sol";
+import { CoreBorrow } from "contracts/coreBorrow/CoreBorrow.sol";
+
+contract DeployChain is Script, CommonUtils {
+    function run() external {
+        uint256 chainId = vm.envUint("CHAIN_ID");
+
+        address governor = _chainToContract(chainId, ContractType.GovernorMultisig);
+        address guardian = _chainToContract(chainId, ContractType.GuardianMultisig);
+
+        uint256 deployerPrivateKey = vm.deriveKey(vm.envString("MNEMONIC_MAINNET"), "m/44'/60'/0'/0/", 0);
+        vm.startBroadcast(deployerPrivateKey);
+
+        ProxyAdmin proxyAdmin = new ProxyAdmin();
+        console.log("ProxyAdmin deployed at", address(proxyAdmin));
+
+        ProxyAdmin proxyAdminGuadian = new ProxyAdmin();
+        console.log("ProxyAdminGuadian deployed at", address(proxyAdminGuadian));
+
+        CoreBorrow coreBorrowImpl = new CoreBorrow();
+        console.log("CoreBorrow Implementation deployed at", address(coreBorrowImpl));
+
+        CoreBorrow coreBorrowProxy = CoreBorrow(
+            address(
+                _deployUpgradeable(
+                    address(proxyAdmin),
+                    address(coreBorrowImpl),
+                    abi.encodeWithSelector(CoreBorrow.initialize.selector, governor, guardian)
+                )
+            )
+        );
+        console.log("CoreBorrow Proxy deployed at", address(coreBorrowProxy));
+
+        vm.stopBroadcast();
+    }
+}

scripts/DeployTokenSideChainMultiBridge.s.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.12;
+
+import "forge-std/Script.sol";
+import "utils/src/CommonUtils.sol";
+import { TokenSideChainMultiBridge } from "contracts/agToken/TokenSideChainMultiBridge.sol";
+import { LayerZeroBridgeToken } from "contracts/agToken/layerZero/LayerZeroBridgeToken.sol";
+import { ICoreBorrow } from "contracts/interfaces/ICoreBorrow.sol";
+
+contract DeployTokenSideChainMultiBridge is Script, CommonUtils {
+    function run() external {
+        /** TODO  complete */
+        string memory chainName = vm.envString("CHAIN_NAME");
+        string memory symbol = vm.envString("SYMBOL");
+        uint256 totalLimit = vm.envUint("TOTAL_LIMIT");
+        uint256 hourlyLimit = vm.envUint("HOURLY_LIMIT");
+        uint256 chainTotalHourlyLimit = vm.envUint("CHAIN_TOTAL_HOURLY_LIMIT");
+        /** END  complete */
+
+        uint256 chainId = vm.envUint("CHAIN_ID");
+        uint256 deployerPrivateKey = vm.deriveKey(vm.envString("MNEMONIC_MAINNET"), "m/44'/60'/0'/0/", 0);
+        vm.startBroadcast(deployerPrivateKey);
+
+        address proxyAdmin = _chainToContract(chainId, ContractType.ProxyAdmin);
+        address coreBorrow = _chainToContract(chainId, ContractType.CoreBorrow);
+        ILayerZeroEndpoint lzEndpoint = _lzEndPoint(chainId);
+
+        TokenSideChainMultiBridge angleImpl = new TokenSideChainMultiBridge();
+        console.log("TokenSideChainMultiBridge Implementation deployed at", address(angleImpl));
+        TokenSideChainMultiBridge angleProxy = TokenSideChainMultiBridge(
+            address(_deployUpgradeable(proxyAdmin, address(angleImpl), ""))
+        );
+        console.log("TokenSideChainMultiBridge Proxy deployed at", address(angleProxy));
+
+        LayerZeroBridgeToken lzImpl = new LayerZeroBridgeToken();
+        console.log("LayerZeroBridgeToken Implementation deployed at", address(lzImpl));
+        LayerZeroBridgeToken lzProxy = LayerZeroBridgeToken(
+            address(
+                _deployUpgradeable(
+                    proxyAdmin,
+                    address(lzImpl),
+                    abi.encodeWithSelector(
+                        LayerZeroBridgeToken.initialize.selector,
+                        string.concat("LayerZero Bridge ", symbol),
+                        string.concat("LZ-", symbol),
+                        lzEndpoint,
+                        coreBorrow,
+                        address(angleProxy)
+                    )
+                )
+            )
+        );
+        console.log("LayerZeroBridgeToken Proxy deployed at", address(lzProxy));
+
+        angleProxy.initialize(
+            string.concat(symbol, "_", chainName),
+            symbol,
+            ICoreBorrow(coreBorrow),
+            address(lzProxy),
+            totalLimit,
+            hourlyLimit,
+            0,
+            false,
+            chainTotalHourlyLimit
+        );
+
+        vm.stopBroadcast();
+    }
+}