@evvm/testnet-contracts 1.0.0

package/src/contracts/treasuryTwoChains/TreasuryHostChainStation.sol

@@ -0,0 +1,512 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+/*  
+888b     d888                   888            .d8888b.                    888                             888    
+8888b   d8888                   888           d88P  Y88b                   888                             888    
+88888b.d88888                   888           888    888                   888                             888    
+888Y88888P888  .d88b.   .d8888b 888  888      888         .d88b.  88888b.  888888 888d888 8888b.   .d8888b 888888 
+888 Y888P 888 d88""88b d88P"    888 .88P      888        d88""88b 888 "88b 888    888P"      "88b d88P"    888    
+888  Y8P  888 888  888 888      888888K       888    888 888  888 888  888 888    888    .d888888 888      888    
+888   "   888 Y88..88P Y88b.    888 "88b      Y88b  d88P Y88..88P 888  888 Y88b.  888    888  888 Y88b.    Y88b.  
+888       888  "Y88P"   "Y8888P 888  888       "Y8888P"   "Y88P"  888  888  "Y888 888    "Y888888  "Y8888P  "Y888                                                                                                          
+ */
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Evvm} from "@evvm/testnet-contracts/contracts/evvm/Evvm.sol";
+import {ErrorsLib} from "@evvm/testnet-contracts/contracts/treasuryTwoChains/lib/ErrorsLib.sol";
+import {HostChainStationStructs} from "@evvm/testnet-contracts/contracts/treasuryTwoChains/lib/HostChainStationStructs.sol";
+
+import {SignatureUtils} from "@evvm/testnet-contracts/contracts/treasuryTwoChains/lib/SignatureUtils.sol";
+
+import {IMailbox} from "@hyperlane-xyz/core/contracts/interfaces/IMailbox.sol";
+
+import {OApp, Origin, MessagingFee} from "@layerzerolabs/oapp-evm/contracts/oapp/OApp.sol";
+import {OAppOptionsType3} from "@layerzerolabs/oapp-evm/contracts/oapp/libs/OAppOptionsType3.sol";
+import {OptionsBuilder} from "@layerzerolabs/oapp-evm/contracts/oapp/libs/OptionsBuilder.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+import {AxelarExecutable} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutable.sol";
+import {IAxelarGasService} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol";
+import {IInterchainGasEstimation} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IInterchainGasEstimation.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+
+contract TreasuryHostChainStation is
+    HostChainStationStructs,
+    OApp,
+    OAppOptionsType3,
+    AxelarExecutable
+{
+    /// @notice Address of the EVVM core contract
+    address evvmAddress;
+
+    AddressTypeProposal admin;
+
+    AddressTypeProposal fisherExecutor;
+
+    HyperlaneConfig hyperlane;
+
+    LayerZeroConfig layerZero;
+
+    AxelarConfig axelar;
+
+    mapping(address => uint256) nextFisherExecutionNonce;
+
+    bytes _options =
+        OptionsBuilder.addExecutorLzReceiveOption(
+            OptionsBuilder.newOptions(),
+            50000,
+            0
+        );
+
+    event FisherBridgeSend(
+        address indexed from,
+        address indexed addressToReceive,
+        address indexed tokenAddress,
+        uint256 priorityFee,
+        uint256 amount,
+        uint256 nonce
+    );
+
+    modifier onlyAdmin() {
+        if (msg.sender != admin.current) {
+            revert();
+        }
+        _;
+    }
+
+    modifier onlyFisherExecutor() {
+        if (msg.sender != fisherExecutor.current) {
+            revert();
+        }
+        _;
+    }
+
+    /**
+     * @notice Initialize Treasury with EVVM contract address
+     * @param _evvmAddress Address of the EVVM core contract
+     */
+    constructor(
+        address _evvmAddress,
+        address _admin,
+        CrosschainConfig memory _crosschainConfig
+    )
+        OApp(_crosschainConfig.endpointAddress, _admin)
+        Ownable(_admin)
+        AxelarExecutable(_crosschainConfig.gatewayAddress)
+    {
+        evvmAddress = _evvmAddress;
+        admin = AddressTypeProposal({
+            current: _admin,
+            proposal: address(0),
+            timeToAccept: 0
+        });
+        hyperlane = HyperlaneConfig({
+            externalChainStationDomainId: _crosschainConfig
+                .externalChainStationDomainId,
+            externalChainStationAddress: "",
+            mailboxAddress: _crosschainConfig.mailboxAddress
+        });
+        layerZero = LayerZeroConfig({
+            externalChainStationEid: _crosschainConfig.externalChainStationEid,
+            externalChainStationAddress: "",
+            endpointAddress: _crosschainConfig.endpointAddress
+        });
+        axelar = AxelarConfig({
+            externalChainStationChainName: _crosschainConfig
+                .externalChainStationChainName,
+            externalChainStationAddress: "",
+            gasServiceAddress: _crosschainConfig.gasServiceAddress,
+            gatewayAddress: _crosschainConfig.gatewayAddress
+        });
+    }
+
+    function setExternalChainAddress(
+        address externalChainStationAddress,
+        string memory externalChainStationAddressString
+    ) external onlyAdmin {
+        hyperlane.externalChainStationAddress = bytes32(
+            uint256(uint160(externalChainStationAddress))
+        );
+        layerZero.externalChainStationAddress = bytes32(
+            uint256(uint160(externalChainStationAddress))
+        );
+        axelar.externalChainStationAddress = externalChainStationAddressString;
+        _setPeer(
+            layerZero.externalChainStationEid,
+            layerZero.externalChainStationAddress
+        );
+    }
+
+    /**
+     * @notice Withdraw ETH or ERC20 tokens
+     * @param token Token address (address(0) for ETH)
+     * @param amount Amount to withdraw
+     */
+    function withdraw(
+        address toAddress,
+        address token,
+        uint256 amount,
+        bytes1 protocolToExecute
+    ) external payable {
+        if (token == Evvm(evvmAddress).getEvvmMetadata().principalTokenAddress)
+            revert ErrorsLib.PrincipalTokenIsNotWithdrawable();
+
+        if (Evvm(evvmAddress).getBalance(msg.sender, token) < amount)
+            revert ErrorsLib.InsufficientBalance();
+
+        executerEVVM(false, msg.sender, token, amount);
+
+        bytes memory payload = encodePayload(token, toAddress, amount);
+
+        if (protocolToExecute == 0x01) {
+            // 0x01 = Hyperlane
+            uint256 quote = getQuoteHyperlane(toAddress, token, amount);
+            /*messageId = */ IMailbox(hyperlane.mailboxAddress).dispatch{
+                value: quote
+            }(
+                hyperlane.externalChainStationDomainId,
+                hyperlane.externalChainStationAddress,
+                payload
+            );
+        } else if (protocolToExecute == 0x02) {
+            // 0x02 = LayerZero
+            uint256 fee = quoteLayerZero(toAddress, token, amount);
+            _lzSend(
+                layerZero.externalChainStationEid,
+                payload,
+                _options,
+                MessagingFee(fee, 0),
+                msg.sender // Refund any excess fees to the sender.
+            );
+        } else if (protocolToExecute == 0x03) {
+            // 0x03 = Axelar
+            IAxelarGasService(axelar.gasServiceAddress)
+                .payNativeGasForContractCall{value: msg.value}(
+                address(this),
+                axelar.externalChainStationChainName,
+                axelar.externalChainStationAddress,
+                payload,
+                msg.sender
+            );
+            gateway().callContract(
+                axelar.externalChainStationChainName,
+                axelar.externalChainStationAddress,
+                payload
+            );
+        } else {
+            revert();
+        }
+    }
+
+    function fisherBridgeReceive(
+        address from,
+        address addressToReceive,
+        address tokenAddress,
+        uint256 priorityFee,
+        uint256 amount,
+        bytes memory signature
+    ) external onlyFisherExecutor {
+        if (
+            !SignatureUtils.verifyMessageSignedForFisherBridge(
+                Evvm(evvmAddress).getEvvmID(),
+                from,
+                addressToReceive,
+                nextFisherExecutionNonce[from],
+                tokenAddress,
+                priorityFee,
+                amount,
+                signature
+            )
+        ) revert ErrorsLib.InvalidSignature();
+
+        nextFisherExecutionNonce[from]++;
+
+        executerEVVM(true, addressToReceive, tokenAddress, amount);
+
+        if (priorityFee > 0)
+            executerEVVM(true, msg.sender, tokenAddress, priorityFee);
+    }
+
+    function fisherBridgeSend(
+        address from,
+        address addressToReceive,
+        address tokenAddress,
+        uint256 priorityFee,
+        uint256 amount,
+        bytes memory signature
+    ) external onlyFisherExecutor {
+        if (
+            tokenAddress ==
+            Evvm(evvmAddress).getEvvmMetadata().principalTokenAddress
+        ) revert ErrorsLib.PrincipalTokenIsNotWithdrawable();
+
+        if (Evvm(evvmAddress).getBalance(from, tokenAddress) < amount)
+            revert ErrorsLib.InsufficientBalance();
+
+        if (
+            !SignatureUtils.verifyMessageSignedForFisherBridge(
+                Evvm(evvmAddress).getEvvmID(),
+                from,
+                addressToReceive,
+                nextFisherExecutionNonce[from],
+                tokenAddress,
+                priorityFee,
+                amount,
+                signature
+            )
+        ) revert ErrorsLib.InvalidSignature();
+
+        nextFisherExecutionNonce[from]++;
+
+        executerEVVM(false, from, tokenAddress, amount + priorityFee);
+
+        if (priorityFee > 0)
+            executerEVVM(true, msg.sender, tokenAddress, priorityFee);
+
+        emit FisherBridgeSend(
+            from,
+            addressToReceive,
+            tokenAddress,
+            priorityFee,
+            amount,
+            nextFisherExecutionNonce[from] - 1
+        );
+    }
+
+    // Hyperlane Specific Functions //
+    function getQuoteHyperlane(
+        address toAddress,
+        address token,
+        uint256 amount
+    ) public view returns (uint256) {
+        return
+            IMailbox(hyperlane.mailboxAddress).quoteDispatch(
+                hyperlane.externalChainStationDomainId,
+                hyperlane.externalChainStationAddress,
+                encodePayload(token, toAddress, amount)
+            );
+    }
+
+    function handle(
+        uint32 _origin,
+        bytes32 _sender,
+        bytes calldata _data
+    ) external payable virtual {
+        if (msg.sender != hyperlane.mailboxAddress)
+            revert ErrorsLib.MailboxNotAuthorized();
+
+        if (_sender != hyperlane.externalChainStationAddress)
+            revert ErrorsLib.SenderNotAuthorized();
+
+        if (_origin != hyperlane.externalChainStationDomainId)
+            revert ErrorsLib.ChainIdNotAuthorized();
+
+        decodeAndDeposit(_data);
+    }
+
+    // LayerZero Specific Functions //
+
+    function quoteLayerZero(
+        address toAddress,
+        address token,
+        uint256 amount
+    ) public view returns (uint256) {
+        MessagingFee memory fee = _quote(
+            layerZero.externalChainStationEid,
+            encodePayload(token, toAddress, amount),
+            _options,
+            false
+        );
+        return fee.nativeFee;
+    }
+
+    function _lzReceive(
+        Origin calldata _origin,
+        bytes32 /*_guid*/,
+        bytes calldata message,
+        address /*executor*/, // Executor address as specified by the OApp.
+        bytes calldata /*_extraData*/ // Any extra data or options to trigger on receipt.
+    ) internal override {
+        // Decode the payload to get the message
+        if (_origin.srcEid != layerZero.externalChainStationEid)
+            revert ErrorsLib.ChainIdNotAuthorized();
+
+        if (_origin.sender != layerZero.externalChainStationAddress)
+            revert ErrorsLib.SenderNotAuthorized();
+
+        decodeAndDeposit(message);
+    }
+
+    // Axelar Specific Functions //
+
+    function _execute(
+        bytes32 /*commandId*/,
+        string calldata _sourceChain,
+        string calldata _sourceAddress,
+        bytes calldata _payload
+    ) internal override {
+        if (!Strings.equal(_sourceChain, axelar.externalChainStationChainName))
+            revert ErrorsLib.ChainIdNotAuthorized();
+
+        if (!Strings.equal(_sourceAddress, axelar.externalChainStationAddress))
+            revert ErrorsLib.SenderNotAuthorized();
+
+        decodeAndDeposit(_payload);
+    }
+
+    /**
+     * @notice Proposes a new admin address with 1-day time delay
+     * @dev Part of the time-delayed governance system for admin changes
+     * @param _newOwner Address of the proposed new admin
+     */
+    function proposeAdmin(address _newOwner) external onlyAdmin {
+        if (_newOwner == address(0) || _newOwner == admin.current) revert();
+
+        admin.proposal = _newOwner;
+        admin.timeToAccept = block.timestamp + 1 days;
+    }
+
+    /**
+     * @notice Cancels a pending admin change proposal
+     * @dev Allows current admin to reject proposed admin changes
+     */
+    function rejectProposalAdmin() external onlyAdmin {
+        admin.proposal = address(0);
+        admin.timeToAccept = 0;
+    }
+
+    /**
+     * @notice Accepts a pending admin proposal and becomes the new admin
+     * @dev Can only be called by the proposed admin after the time delay
+     */
+    function acceptAdmin() external {
+        if (block.timestamp < admin.timeToAccept) revert();
+
+        if (msg.sender != admin.proposal) revert();
+
+        admin.current = admin.proposal;
+
+        admin.proposal = address(0);
+        admin.timeToAccept = 0;
+    }
+
+    function proposeFisherExecutor(
+        address _newFisherExecutor
+    ) external onlyAdmin {
+        if (
+            _newFisherExecutor == address(0) ||
+            _newFisherExecutor == fisherExecutor.current
+        ) revert();
+
+        fisherExecutor.proposal = _newFisherExecutor;
+        fisherExecutor.timeToAccept = block.timestamp + 1 days;
+    }
+
+    function rejectProposalFisherExecutor() external onlyAdmin {
+        fisherExecutor.proposal = address(0);
+        fisherExecutor.timeToAccept = 0;
+    }
+
+    function acceptFisherExecutor() external {
+        if (block.timestamp < fisherExecutor.timeToAccept) revert();
+
+        if (msg.sender != fisherExecutor.proposal) revert();
+
+        fisherExecutor.current = fisherExecutor.proposal;
+
+        fisherExecutor.proposal = address(0);
+        fisherExecutor.timeToAccept = 0;
+    }
+
+    // Getter functions //
+    function getAdmin() external view returns (AddressTypeProposal memory) {
+        return admin;
+    }
+
+    function getFisherExecutor()
+        external
+        view
+        returns (AddressTypeProposal memory)
+    {
+        return fisherExecutor;
+    }
+
+    function getNextFisherExecutionNonce(
+        address user
+    ) external view returns (uint256) {
+        return nextFisherExecutionNonce[user];
+    }
+
+    function getEvvmAddress() external view returns (address) {
+        return evvmAddress;
+    }
+
+    function getHyperlaneConfig()
+        external
+        view
+        returns (HyperlaneConfig memory)
+    {
+        return hyperlane;
+    }
+
+    function getLayerZeroConfig()
+        external
+        view
+        returns (LayerZeroConfig memory)
+    {
+        return layerZero;
+    }
+
+    function getAxelarConfig() external view returns (AxelarConfig memory) {
+        return axelar;
+    }
+
+    function getOptions() external view returns (bytes memory) {
+        return _options;
+    }
+
+    // Internal Functions //
+
+    function decodeAndDeposit(bytes memory payload) internal {
+        (address token, address from, uint256 amount) = decodePayload(payload);
+        executerEVVM(true, from, token, amount);
+    }
+
+    function encodePayload(
+        address token,
+        address toAddress,
+        uint256 amount
+    ) internal pure returns (bytes memory payload) {
+        payload = abi.encode(token, toAddress, amount);
+    }
+
+    function decodePayload(
+        bytes memory payload
+    ) internal pure returns (address token, address toAddress, uint256 amount) {
+        (token, toAddress, amount) = abi.decode(
+            payload,
+            (address, address, uint256)
+        );
+    }
+
+    function executerEVVM(
+        bool typeOfExecution,
+        address userToExecute,
+        address token,
+        uint256 amount
+    ) internal {
+        if (typeOfExecution) {
+            // true = add
+            Evvm(evvmAddress).addAmountToUser(userToExecute, token, amount);
+        } else {
+            // false = remove
+            Evvm(evvmAddress).removeAmountFromUser(
+                userToExecute,
+                token,
+                amount
+            );
+        }
+    }
+}

package/src/contracts/treasuryTwoChains/lib/ErrorsLib.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+library ErrorsLib {
+    error InsufficientBalance();
+    error PrincipalTokenIsNotWithdrawable();
+    error InvalidDepositAmount();
+    error DepositAmountMustBeGreaterThanZero();
+    error MailboxNotAuthorized();
+    error SenderNotAuthorized();
+    error ChainIdNotAuthorized();
+    error InvalidSignature();
+}

package/src/contracts/treasuryTwoChains/lib/ExternalChainStationStructs.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+abstract contract ExternalChainStationStructs {
+    struct AddressTypeProposal {
+        address current;
+        address proposal;
+        uint256 timeToAccept;
+    }
+
+    struct HyperlaneConfig {
+        uint32 hostChainStationDomainId;
+        bytes32 hostChainStationAddress;
+        address mailboxAddress;
+    }
+
+    struct LayerZeroConfig {
+        uint32 hostChainStationEid;
+        bytes32 hostChainStationAddress;
+        address endpointAddress;
+    }
+
+    struct AxelarConfig {
+        string hostChainStationChainName;
+        string hostChainStationAddress;
+        address gasServiceAddress;
+        address gatewayAddress;
+    }
+
+    struct CrosschainConfig {
+        uint32 hostChainStationDomainId;
+        address mailboxAddress;
+        uint32 hostChainStationEid;
+        address endpointAddress;
+        string hostChainStationChainName;
+        address gasServiceAddress;
+        address gatewayAddress;
+    }
+}

package/src/contracts/treasuryTwoChains/lib/HostChainStationStructs.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title TreasuryStructs
+ * @dev Library of common structures used across TreasuryTwoChains.
+ *      This contract serves as a shared type system for the entire ecosystem,
+ *      ensuring consistency in data structures between the core TreasuryTwoChains and
+ *      external service contracts.
+ *
+ * @notice This contract should be inherited by both TreasuryTwoChains contracts
+ *         that need to interact with these data structures.
+ */
+
+abstract contract HostChainStationStructs {
+    struct AddressTypeProposal {
+        address current;
+        address proposal;
+        uint256 timeToAccept;
+    }
+
+    struct HyperlaneConfig {
+        uint32 externalChainStationDomainId;
+        bytes32 externalChainStationAddress;
+        address mailboxAddress;
+    }
+
+    struct LayerZeroConfig {
+        uint32 externalChainStationEid;
+        bytes32 externalChainStationAddress;
+        address endpointAddress;
+    }
+
+    struct AxelarConfig {
+        string externalChainStationChainName;
+        string externalChainStationAddress;
+        address gasServiceAddress;
+        address gatewayAddress;
+    }
+
+    struct CrosschainConfig {
+        uint32 externalChainStationDomainId;
+        address mailboxAddress;
+        uint32 externalChainStationEid;
+        address endpointAddress;
+        string externalChainStationChainName;
+        address gasServiceAddress;
+        address gatewayAddress;
+    }
+}

package/src/contracts/treasuryTwoChains/lib/SignatureUtils.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+import {SignatureRecover} from "@evvm/testnet-contracts/lib/SignatureRecover.sol";
+import {AdvancedStrings} from "@evvm/testnet-contracts/lib/AdvancedStrings.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+
+pragma solidity ^0.8.0;
+
+library SignatureUtils {
+    /**
+     *  @dev using EIP-191 (https://eips.ethereum.org/EIPS/eip-191) can be used to sign and
+     *       verify messages, the next functions are used to verify the messages signed
+     *       by the users
+     */
+
+
+    function verifyMessageSignedForFisherBridge(
+        uint256 evvmID,
+        address signer,
+        address addressToReceive,
+        uint256 nonce,
+        address tokenAddress,
+        uint256 priorityFee,
+        uint256 amount,
+        bytes memory signature
+    ) internal pure returns (bool) {
+        return
+            SignatureRecover.signatureVerification(
+                Strings.toString(evvmID),
+                "fisherBridge",
+                string.concat(
+                    AdvancedStrings.addressToString(addressToReceive),
+                    ",",
+                    Strings.toString(nonce),
+                    ",",
+                    AdvancedStrings.addressToString(tokenAddress),
+                    ",",
+                    Strings.toString(priorityFee),
+                    ",",
+                    Strings.toString(amount)
+                ),
+                signature,
+                signer
+            );
+    }
+}