@evvm/testnet-contracts 1.0.0

package/src/interfaces/ITreasuryHostChainStation.sol

@@ -0,0 +1,251 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+library HostChainStationStructs {
+    struct AddressTypeProposal {
+        address current;
+        address proposal;
+        uint256 timeToAccept;
+    }
+
+    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;
+    }
+
+    struct HyperlaneConfig {
+        uint32 externalChainStationDomainId;
+        bytes32 externalChainStationAddress;
+        address mailboxAddress;
+    }
+
+    struct LayerZeroConfig {
+        uint32 externalChainStationEid;
+        bytes32 externalChainStationAddress;
+        address endpointAddress;
+    }
+}
+
+interface ITreasuryHostChainStation {
+    struct EnforcedOptionParam {
+        uint32 eid;
+        uint16 msgType;
+        bytes options;
+    }
+
+    struct Origin {
+        uint32 srcEid;
+        bytes32 sender;
+        uint64 nonce;
+    }
+
+    error AddressEmptyCode(address target);
+    error AddressInsufficientBalance(address account);
+    error ChainIdNotAuthorized();
+    error FailedInnerCall();
+    error InsufficientBalance();
+    error InvalidAddress();
+    error InvalidDelegate();
+    error InvalidEndpointCall();
+    error InvalidOptionType(uint16 optionType);
+    error InvalidOptions(bytes options);
+    error InvalidSignature();
+    error LzTokenUnavailable();
+    error MailboxNotAuthorized();
+    error NoPeer(uint32 eid);
+    error NotApprovedByGateway();
+    error NotEnoughNative(uint256 msgValue);
+    error OnlyEndpoint(address addr);
+    error OnlyPeer(uint32 eid, bytes32 sender);
+    error OwnableInvalidOwner(address owner);
+    error OwnableUnauthorizedAccount(address account);
+    error PrincipalTokenIsNotWithdrawable();
+    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
+    error SafeERC20FailedOperation(address token);
+    error SenderNotAuthorized();
+
+    event EnforcedOptionSet(EnforcedOptionParam[] _enforcedOptions);
+    event FisherBridgeSend(
+        address indexed from,
+        address indexed addressToReceive,
+        address indexed tokenAddress,
+        uint256 priorityFee,
+        uint256 amount,
+        uint256 nonce
+    );
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+    event PeerSet(uint32 eid, bytes32 peer);
+
+    function acceptAdmin() external;
+
+    function acceptFisherExecutor() external;
+
+    function allowInitializePath(
+        Origin memory origin
+    ) external view returns (bool);
+
+    function combineOptions(
+        uint32 _eid,
+        uint16 _msgType,
+        bytes memory _extraOptions
+    ) external view returns (bytes memory);
+
+    function endpoint() external view returns (address);
+
+    function enforcedOptions(
+        uint32 eid,
+        uint16 msgType
+    ) external view returns (bytes memory enforcedOption);
+
+    function execute(
+        bytes32 commandId,
+        string memory sourceChain,
+        string memory sourceAddress,
+        bytes memory payload
+    ) external;
+
+    function fisherBridgeReceive(
+        address from,
+        address addressToReceive,
+        address tokenAddress,
+        uint256 priorityFee,
+        uint256 amount,
+        bytes memory signature
+    ) external;
+
+    function fisherBridgeSend(
+        address from,
+        address addressToReceive,
+        address tokenAddress,
+        uint256 priorityFee,
+        uint256 amount,
+        bytes memory signature
+    ) external;
+
+    function gateway() external view returns (address);
+
+    function getAdmin()
+        external
+        view
+        returns (HostChainStationStructs.AddressTypeProposal memory);
+
+    function getAxelarConfig()
+        external
+        view
+        returns (HostChainStationStructs.AxelarConfig memory);
+
+    function getEvvmAddress() external view returns (address);
+
+    function getFisherExecutor()
+        external
+        view
+        returns (HostChainStationStructs.AddressTypeProposal memory);
+
+    function getHyperlaneConfig()
+        external
+        view
+        returns (HostChainStationStructs.HyperlaneConfig memory);
+
+    function getLayerZeroConfig()
+        external
+        view
+        returns (HostChainStationStructs.LayerZeroConfig memory);
+
+    function getNextFisherExecutionNonce(
+        address user
+    ) external view returns (uint256);
+
+    function getOptions() external view returns (bytes memory);
+
+    function getQuoteHyperlane(
+        address toAddress,
+        address token,
+        uint256 amount
+    ) external view returns (uint256);
+
+    function handle(
+        uint32 _origin,
+        bytes32 _sender,
+        bytes memory _data
+    ) external payable;
+
+    function isComposeMsgSender(
+        Origin memory,
+        bytes memory,
+        address _sender
+    ) external view returns (bool);
+
+    function lzReceive(
+        Origin memory _origin,
+        bytes32 _guid,
+        bytes memory _message,
+        address _executor,
+        bytes memory _extraData
+    ) external payable;
+
+    function nextNonce(uint32, bytes32) external view returns (uint64 nonce);
+
+    function oAppVersion()
+        external
+        pure
+        returns (uint64 senderVersion, uint64 receiverVersion);
+
+    function owner() external view returns (address);
+
+    function peers(uint32 eid) external view returns (bytes32 peer);
+
+    function proposeAdmin(address _newOwner) external;
+
+    function proposeFisherExecutor(address _newFisherExecutor) external;
+
+    function quoteLayerZero(
+        address toAddress,
+        address token,
+        uint256 amount
+    ) external view returns (uint256);
+
+    function rejectProposalAdmin() external;
+
+    function rejectProposalFisherExecutor() external;
+
+    function renounceOwnership() external;
+
+    function setDelegate(address _delegate) external;
+
+    function setEnforcedOptions(
+        EnforcedOptionParam[] memory _enforcedOptions
+    ) external;
+
+    function setExternalChainAddress(
+        address externalChainStationAddress,
+        string memory externalChainStationAddressString
+    ) external;
+
+    function setPeer(uint32 _eid, bytes32 _peer) external;
+
+    function transferOwnership(address newOwner) external;
+
+    function withdraw(
+        address toAddress,
+        address token,
+        uint256 amount,
+        bytes1 protocolToExecute
+    ) external payable;
+}

package/src/lib/AdvancedStrings.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+
+library AdvancedStrings {
+    function addressToString(
+        address _address
+    ) internal pure returns (string memory) {
+        bytes32 _bytes = bytes32(uint256(uint160(_address)));
+        bytes memory HEX = "0123456789abcdef";
+        bytes memory _string = new bytes(42);
+        _string[0] = "0";
+        _string[1] = "x";
+        for (uint256 i = 0; i < 20; i++) {
+            _string[2 + i * 2] = HEX[uint8(_bytes[i + 12] >> 4)];
+            _string[3 + i * 2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
+        }
+        return string(_string);
+    }
+
+    function toHex16(bytes16 data) internal pure returns (bytes32 result) {
+        result =
+            (bytes32(data) &
+                0xFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000) |
+            ((bytes32(data) &
+                0x0000000000000000FFFFFFFFFFFFFFFF00000000000000000000000000000000) >>
+                64);
+        result =
+            (result &
+                0xFFFFFFFF000000000000000000000000FFFFFFFF000000000000000000000000) |
+            ((result &
+                0x00000000FFFFFFFF000000000000000000000000FFFFFFFF0000000000000000) >>
+                32);
+        result =
+            (result &
+                0xFFFF000000000000FFFF000000000000FFFF000000000000FFFF000000000000) |
+            ((result &
+                0x0000FFFF000000000000FFFF000000000000FFFF000000000000FFFF00000000) >>
+                16);
+        result =
+            (result &
+                0xFF000000FF000000FF000000FF000000FF000000FF000000FF000000FF000000) |
+            ((result &
+                0x00FF000000FF000000FF000000FF000000FF000000FF000000FF000000FF0000) >>
+                8);
+        result =
+            ((result &
+                0xF000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000) >>
+                4) |
+            ((result &
+                0x0F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F00) >>
+                8);
+        result = bytes32(
+            0x3030303030303030303030303030303030303030303030303030303030303030 +
+                uint256(result) +
+                (((uint256(result) +
+                    0x0606060606060606060606060606060606060606060606060606060606060606) >>
+                    4) &
+                    0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F) *
+                7
+        );
+    }
+
+    function bytes32ToString(bytes32 data) public pure returns (string memory) {
+        return
+            string(
+                abi.encodePacked(
+                    "0x",
+                    toHex16(bytes16(data)),
+                    toHex16(bytes16(data << 128))
+                )
+            );
+    }
+}