Feat/script migration

contracts/agToken/layerZero/LayerZeroBridgeTokenERC20.sol

@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity ^0.8.12;
+
+import "./utils/OFTCore.sol";
+import "../../interfaces/IAgTokenSideChainMultiBridge.sol";
+import "oz-upgradeable/security/PausableUpgradeable.sol";
+import "oz-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+
+/// @title LayerZeroBridgeTokenERC20
+/// @author Angle Core Team, forked from https://github.com/LayerZero-Labs/solidity-examples/blob/main/contracts/token/oft/OFT.sol
+/// @notice Contract to be deployed on a L2/sidechain for bridging a token (ANGLE for instance) using
+/// a bridge intermediate token and LayerZero
+contract LayerZeroBridgeTokenERC20 is OFTCore, ERC20Upgradeable, PausableUpgradeable {
+    /// @notice Address of the bridgeable token
+    IAgTokenSideChainMultiBridge public canonicalToken;
+
+    // =================================== ERRORS ==================================
+
+    error InvalidAllowance();
+
+    // ================================ CONSTRUCTOR ================================
+
+    /// @notice Initializes the contract
+    /// @param _name Name of the token corresponding to this contract
+    /// @param _symbol Symbol of the token corresponding to this contract
+    /// @param _lzEndpoint Layer zero endpoint to pass messages
+    /// @param _coreBorrow Address of the `CoreBorrow` contract used for access control
+    /// @param _canonicalToken Address of the bridgeable token
+    function initialize(
+        string memory _name,
+        string memory _symbol,
+        address _lzEndpoint,
+        address _coreBorrow,
+        address _canonicalToken
+    ) external initializer {
+        if (_canonicalToken == address(0)) revert ZeroAddress();
+        __ERC20_init_unchained(_name, _symbol);
+        __LzAppUpgradeable_init(_lzEndpoint, _coreBorrow);
+
+        canonicalToken = IAgTokenSideChainMultiBridge(_canonicalToken);
+        _approve(address(this), _canonicalToken, type(uint256).max);
+    }
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() initializer {}
+
+    // ===================== EXTERNAL PERMISSIONLESS FUNCTIONS =====================
+
+    /// @inheritdoc OFTCore
+    function sendWithPermit(
+        uint16 _dstChainId,
+        bytes memory _toAddress,
+        uint256 _amount,
+        address payable _refundAddress,
+        address _zroPaymentAddress,
+        bytes memory _adapterParams,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) public payable override {
+        canonicalToken.permit(msg.sender, address(this), _amount, deadline, v, r, s);
+        send(_dstChainId, _toAddress, _amount, _refundAddress, _zroPaymentAddress, _adapterParams);
+    }
+
+    /// @inheritdoc OFTCore
+    function withdraw(uint256 amount, address recipient) external override returns (uint256 amountMinted) {
+        // Does not check allowances as transfers from `msg.sender`
+        _transfer(msg.sender, address(this), amount);
+        amountMinted = canonicalToken.swapIn(address(this), amount, recipient);
+        uint256 leftover = balanceOf(address(this));
+        if (leftover > 0) {
+            _transfer(address(this), msg.sender, leftover);
+        }
+    }
+
+    // ============================= INTERNAL FUNCTIONS ============================
+
+    /// @inheritdoc OFTCore
+    function _debitFrom(
+        uint16,
+        bytes memory,
+        uint256 _amount
+    ) internal override whenNotPaused returns (uint256 amountSwapped) {
+        // No need to use safeTransferFrom as we know this implementation reverts on failure
+        canonicalToken.transferFrom(msg.sender, address(this), _amount);
+
+        // Swap canonical for this bridge token. There may be some fees
+        amountSwapped = canonicalToken.swapOut(address(this), _amount, address(this));
+        _burn(address(this), amountSwapped);
+    }
+
+    /// @inheritdoc OFTCore
+    function _debitCreditFrom(uint16, bytes memory, uint256 _amount) internal override whenNotPaused returns (uint256) {
+        _burn(msg.sender, _amount);
+        return _amount;
+    }
+
+    /// @inheritdoc OFTCore
+    function _creditTo(
+        uint16,
+        address _toAddress,
+        uint256 _amount
+    ) internal override whenNotPaused returns (uint256 amountMinted) {
+        _mint(address(this), _amount);
+        amountMinted = canonicalToken.swapIn(address(this), _amount, _toAddress);
+        uint256 leftover = balanceOf(address(this));
+        if (leftover > 0) {
+            _transfer(address(this), _toAddress, leftover);
+        }
+    }
+
+    // =============================== VIEW FUNCTIONS ==============================
+
+    /// @inheritdoc ERC165Upgradeable
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return
+            interfaceId == type(IOFT).interfaceId ||
+            interfaceId == type(IERC20).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+
+    // ============================ GOVERNANCE FUNCTIONS ===========================
+
+    /// @notice Mints the intermediate contract to the `canonicalToken`
+    /// @dev Used to increase the bridging capacity
+    function mint(uint256 amount) external onlyGovernorOrGuardian {
+        _mint(address(canonicalToken), amount);
+    }
+
+    /// @notice Burns the intermediate contract from the `canonicalToken`
+    /// @dev Used to decrease the bridging capacity
+    function burn(uint256 amount) external onlyGovernorOrGuardian {
+        _burn(address(canonicalToken), amount);
+    }
+
+    /// @notice Increases allowance of the `canonicalToken`
+    function setupAllowance() public onlyGovernorOrGuardian {
+        _approve(address(this), address(canonicalToken), type(uint256).max);
+    }
+
+    /// @notice Pauses bridging through the contract
+    /// @param pause Future pause status
+    function pauseSendTokens(bool pause) external onlyGovernorOrGuardian {
+        pause ? _pause() : _unpause();
+    }
+
+    uint256[49] private __gap;
+}

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"}, { access = "read-write", path = "./scripts/addresses.json"}]
 
 [fuzz]
 runs = 10000
@@ -60,6 +61,7 @@ depth = 1
 fail_on_revert = false
 
 [profile.ci]
+optimizer = true
 src = "test"
 via_ir = false
 gas_reports = ["*"]

scripts/DeployAgTokenSideChainMultiBridge.s.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.12;
+
+import "forge-std/Script.sol";
+import "./utils/Constants.s.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;
+
+    function run() external {
+        /** TODO  complete */
+        string memory stableName = vm.envString("STABLE_NAME");
+        address expectedAddress = vm.envAddress("EXPECTED_ADDRESS");
+        uint256 totalLimit = vm.envUint("TOTAL_LIMIT");
+        uint256 hourlyLimit = vm.envUint("HOURLY_LIMIT");
+        uint256 chainTotalHourlyLimit = vm.envUint("CHAIN_TOTAL_HOURLY_LIMIT");
+        bool mock = vm.envOr("MOCK", false);
+        /** END  complete */
+
+        uint256 deployerPrivateKey = vm.deriveKey(vm.envString("MNEMONIC_MAINNET"), "m/44'/60'/0'/0/", 0);
+        address deployer = vm.addr(deployerPrivateKey);
+        string memory jsonVanity = vm.readFile(JSON_VANITY_PATH);
+        bytes32 salt = bytes32(abi.encodePacked(deployer, abi.encodePacked(uint96(jsonVanity.readUint("$.init")))));
+        uint256 chainId = vm.envUint("CHAIN_ID");
+
+        string memory json = vm.readFile(JSON_ADDRESSES_PATH);
+        address proxyAdmin;
+        address coreBorrow;
+        if (vm.keyExistsJson(json, ".proxyAdmin")) {
+            proxyAdmin = vm.parseJsonAddress(json, ".proxyAdmin");
+        } else {
+            proxyAdmin = _chainToContract(chainId, ContractType.ProxyAdmin);
+        }
+        if (vm.keyExistsJson(json, ".coreBorrow")) {
+            coreBorrow = vm.parseJsonAddress(json, ".coreBorrow");
+        } else {
+            coreBorrow = _chainToContract(chainId, ContractType.CoreBorrow);
+        }
+        ILayerZeroEndpoint lzEndpoint = _lzEndPoint(chainId);
+
+        vm.startBroadcast(deployerPrivateKey);
+
+        AgTokenSideChainMultiBridge agTokenImpl = new AgTokenSideChainMultiBridge();
+        console.log("AgTokenSideChainMultiBridge Implementation deployed at", address(agTokenImpl));
+
+        ImmutableCreate2Factory create2Factory = ImmutableCreate2Factory(IMMUTABLE_CREATE2_FACTORY_ADDRESS);
+        bytes memory initCode = abi.encodePacked(
+            type(TransparentUpgradeableProxy).creationCode,
+            abi.encode(IMMUTABLE_CREATE2_FACTORY_ADDRESS, deployer, "")
+        );
+        address computedAddress = create2Factory.findCreate2Address(salt, initCode);
+        console.log("AgTokenSideChainMultiBridge Proxy Supposed to deploy: %s", computedAddress);
+
+        // require(computedAddress == expectedAddress, "Computed address does not match expected address");
+
+        AgTokenSideChainMultiBridge agToken = AgTokenSideChainMultiBridge(create2Factory.safeCreate2(salt, initCode));
+        TransparentUpgradeableProxy(payable(address(agToken))).upgradeTo(address(agTokenImpl));
+        TransparentUpgradeableProxy(payable(address(agToken))).changeAdmin(proxyAdmin);
+        console.log("AgTokenSideChainMultiBridge Proxy deployed at", address(agToken));
+
+        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, address(agToken))
+                )
+            )
+        );
+        console.log("Treasury Proxy deployed at", address(treasuryProxy));
+
+        agToken.initialize(string.concat(stableName, "A"), string.concat(stableName, "A"), 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 ", stableName, "A"),
+                        string.concat("LZ-", stableName, "A"),
+                        address(lzEndpoint),
+                        address(treasuryProxy),
+                        0
+                    )
+                )
+            )
+        );
+        console.log("LayerZeroBridgeToken Proxy deployed at", address(lzProxy));
+
+        if (mock) {
+            agToken.addBridgeToken(address(lzProxy), totalLimit, hourlyLimit, 0, false);
+            agToken.setChainTotalHourlyLimit(chainTotalHourlyLimit);
+            LayerZeroBridgeToken(address(lzProxy)).setUseCustomAdapterParams(1);
+
+            (uint256[] memory chainIds, address[] memory contracts) = _getConnectedChains(stableName);
+
+            // Set trusted remote from current chain
+            for (uint256 i = 0; i < contracts.length; i++) {
+                if (chainIds[i] == chainId) {
+                    continue;
+                }
+
+                lzProxy.setTrustedRemote(_getLZChainId(chainIds[i]), abi.encodePacked(contracts[i], address(lzProxy)));
+            }
+
+            // add real governor
+            address realGovernor = vm.envOr("REAL_GOVERNOR", _chainToContract(chainId, ContractType.GovernorMultisig));
+            coreBorrow.addGovernor(realGovernor);
+            coreBorrow.removeGovernor(deployer);
+        }
+
+        string memory json2 = "output";
+        string[] memory keys = vm.parseJsonKeys(json, "");
+        for (uint256 i = 0; i < keys.length; i++) {
+            json2.serialize(keys[i], json.readAddress(string.concat(".", keys[i])));
+        }
+        json2.serialize("agToken", address(agToken));
+        json2 = json2.serialize("lzAgToken", address(lzProxy));
+        json2.write(JSON_ADDRESSES_PATH);
+
+        vm.stopBroadcast();
+    }
+}