@evvm/testnet-contracts 2.2.0 → 2.2.2

package/interfaces/ITreasuryExternalChainStation.sol

@@ -1,5 +1,6 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.4;
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+pragma solidity ^0.8.0;
 
 library ExternalChainStationStructs {
     struct AddressTypeProposal {
@@ -16,13 +17,9 @@ library ExternalChainStationStructs {
     }
 
     struct CrosschainConfig {
-        uint32 hostChainStationDomainId;
-        address mailboxAddress;
-        uint32 hostChainStationEid;
-        address endpointAddress;
-        string hostChainStationChainName;
-        address gasServiceAddress;
-        address gatewayAddress;
+        HyperlaneConfig hyperlane;
+        LayerZeroConfig layerZero;
+        AxelarConfig axelar;
     }
 
     struct HyperlaneConfig {
@@ -38,7 +35,7 @@ library ExternalChainStationStructs {
     }
 }
 
-interface TreasuryExternalChainStation {
+interface ITreasuryExternalChainStation {
     struct EnforcedOptionParam {
         uint32 eid;
         uint16 msgType;
@@ -74,6 +71,7 @@ interface TreasuryExternalChainStation {
     error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
     error SafeERC20FailedOperation(address token);
     error SenderNotAuthorized();
+    error WindowToChangeEvvmIDExpired();
 
     event EnforcedOptionSet(EnforcedOptionParam[] _enforcedOptions);
     event FisherBridgeSend(
@@ -87,8 +85,7 @@ interface TreasuryExternalChainStation {
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
     event PeerSet(uint32 eid, bytes32 peer);
 
-    function _setHostChainAddress(address hostChainStationAddress, string memory hostChainStationAddressString)
-        external;
+    function _setHostChainAddress(address hostChainStationAddress, string memory hostChainStationAddressString) external;
     function acceptAdmin() external;
     function acceptFisherExecutor() external;
     function acceptHostChainAddress() external;
@@ -98,9 +95,7 @@ interface TreasuryExternalChainStation {
         view
         returns (bytes memory);
     function depositCoin(address toAddress, uint256 amount, bytes1 protocolToExecute) external payable;
-    function depositERC20(address toAddress, address token, uint256 amount, bytes1 protocolToExecute)
-        external
-        payable;
+    function depositERC20(address toAddress, address token, uint256 amount, bytes1 protocolToExecute) external payable;
     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)
@@ -161,6 +156,7 @@ interface TreasuryExternalChainStation {
     function renounceOwnership() external;
     function setDelegate(address _delegate) external;
     function setEnforcedOptions(EnforcedOptionParam[] memory _enforcedOptions) external;
+    function setEvvmID(uint256 newEvvmID) external;
     function setPeer(uint32 _eid, bytes32 _peer) external;
     function transferOwnership(address newOwner) external;
 }

package/interfaces/ITreasuryHostChainStation.sol

@@ -1,5 +1,6 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.4;
+// 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 {
@@ -16,13 +17,9 @@ library HostChainStationStructs {
     }
 
     struct CrosschainConfig {
-        uint32 externalChainStationDomainId;
-        address mailboxAddress;
-        uint32 externalChainStationEid;
-        address endpointAddress;
-        string externalChainStationChainName;
-        address gasServiceAddress;
-        address gatewayAddress;
+        HyperlaneConfig hyperlane;
+        LayerZeroConfig layerZero;
+        AxelarConfig axelar;
     }
 
     struct HyperlaneConfig {
@@ -38,7 +35,7 @@ library HostChainStationStructs {
     }
 }
 
-interface TreasuryHostChainStation {
+interface ITreasuryHostChainStation {
     struct EnforcedOptionParam {
         uint32 eid;
         uint16 msgType;

package/library/Erc191TestBuilder.sol

@@ -11,7 +11,6 @@ pragma solidity ^0.8.0;
  *         https://book.getfoundry.sh/cheatcodes/sign
  */
 
-
 import {AdvancedStrings} from "@evvm/testnet-contracts/library/utils/AdvancedStrings.sol";
 
 library Erc191TestBuilder {

package/library/EvvmService.sol

@@ -3,21 +3,23 @@
 
 pragma solidity ^0.8.0;
 
-import {IEvvm} from "@evvm/testnet-contracts/interfaces/IEvvm.sol";
-import {IStaking} from "@evvm/testnet-contracts/interfaces/IStaking.sol";
+import {EvvmStructs} from "@evvm/testnet-contracts/interfaces/IEvvm.sol";
 import {SignatureUtil} from "@evvm/testnet-contracts/library/utils/SignatureUtil.sol";
-import {AsyncNonceService} from "@evvm/testnet-contracts/library/utils/service/AsyncNonceService.sol";
-
-abstract contract EvvmService is AsyncNonceService {
+import {AsyncNonce} from "@evvm/testnet-contracts/library/utils/nonces/AsyncNonce.sol";
+import {StakingServiceUtils} from "@evvm/testnet-contracts/library/utils/service/StakingServiceUtils.sol";
+import {EvvmPayments} from "@evvm/testnet-contracts/library/utils/service/EvvmPayments.sol";
+
+abstract contract EvvmService is
+    AsyncNonce,
+    StakingServiceUtils,
+    EvvmPayments
+{
     error InvalidServiceSignature();
 
-    IEvvm evvm;
-    IStaking staking;
-
-    constructor(address evvmAddress, address stakingAddress) {
-        evvm = IEvvm(evvmAddress);
-        staking = IStaking(stakingAddress);
-    }
+    constructor(
+        address evvmAddress,
+        address stakingAddress
+    ) StakingServiceUtils(stakingAddress) EvvmPayments(evvmAddress) {}
 
     function validateServiceSignature(
         string memory functionName,
@@ -35,70 +37,4 @@ abstract contract EvvmService is AsyncNonceService {
             )
         ) revert InvalidServiceSignature();
     }
-
-    function requestPay(
-        address from,
-        address token,
-        uint256 amount,
-        uint256 priorityFee,
-        uint256 nonce,
-        bool priorityFlag,
-        bytes memory signature
-    ) internal virtual {
-        evvm.pay(
-            from,
-            address(this),
-            "",
-            token,
-            amount,
-            priorityFee,
-            nonce,
-            priorityFlag,
-            address(this),
-            signature
-        );
-    }
-
-    function makeCaPay(
-        address to,
-        address token,
-        uint256 amount
-    ) internal virtual {
-        evvm.caPay(to, token, amount);
-    }
-
-    function _makeStakeService(uint256 amountToStake) internal {
-        staking.prepareServiceStaking(amountToStake);
-        evvm.caPay(
-            address(staking),
-            getPrincipalTokenAddress(),
-            staking.priceOfStaking() * amountToStake
-        );
-        staking.confirmServiceStaking();
-    }
-
-    function _makeUnstakeService(uint256 amountToUnstake) internal {
-        staking.serviceUnstaking(amountToUnstake);
-    }
-
-    function _changeEvvmAddress(address newEvvmAddress) internal {
-        evvm = IEvvm(newEvvmAddress);
-    }
-
-    function _changeStakingAddress(address newStakingAddress) internal {
-        staking = IStaking(newStakingAddress);
-    }
-
-    function getPrincipalTokenAddress()
-        internal
-        pure
-        virtual
-        returns (address)
-    {
-        return address(1);
-    }
-
-    function getEtherAddress() internal pure virtual returns (address) {
-        return address(0);
-    }
 }

package/library/primitives/IERC20.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
+
+pragma solidity ^0.8.20;
+
+/**
+ * @dev Interface of the ERC20 standard as defined in the EIP.
+ */
+interface IERC20 {
+    /**
+     * @dev Emitted when `value` tokens are moved from one account (`from`) to
+     * another (`to`).
+     *
+     * Note that `value` may be zero.
+     */
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    /**
+     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
+     * a call to {approve}. `value` is the new allowance.
+     */
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+
+    /**
+     * @dev Returns the value of tokens in existence.
+     */
+    function totalSupply() external view returns (uint256);
+
+    /**
+     * @dev Returns the value of tokens owned by `account`.
+     */
+    function balanceOf(address account) external view returns (uint256);
+
+    /**
+     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transfer(address to, uint256 value) external returns (bool);
+
+    /**
+     * @dev Returns the remaining number of tokens that `spender` will be
+     * allowed to spend on behalf of `owner` through {transferFrom}. This is
+     * zero by default.
+     *
+     * This value changes when {approve} or {transferFrom} are called.
+     */
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    /**
+     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
+     * caller's tokens.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * IMPORTANT: Beware that changing an allowance with this method brings the risk
+     * that someone may use both the old and the new allowance by unfortunate
+     * transaction ordering. One possible solution to mitigate this race
+     * condition is to first reduce the spender's allowance to 0 and set the
+     * desired value afterwards:
+     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+     *
+     * Emits an {Approval} event.
+     */
+    function approve(address spender, uint256 value) external returns (bool);
+
+    /**
+     * @dev Moves a `value` amount of tokens from `from` to `to` using the
+     * allowance mechanism. `value` is then deducted from the caller's
+     * allowance.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
+}

package/library/utils/GovernanceUtils.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+library ProposalStructs {
+    /**
+     * @dev Struct for managing address change proposals with time delay
+     * @param current Currently active address
+     * @param proposal Proposed new address waiting for approval
+     * @param timeToAccept Timestamp when the proposal can be accepted
+     */
+    struct AddressTypeProposal {
+        address current;
+        address proposal;
+        uint256 timeToAccept;
+    }
+
+    /**
+     * @dev Struct for managing uint256 value proposals with time delay
+     * @param current Currently active value
+     * @param proposal Proposed new value waiting for approval
+     * @param timeToAccept Timestamp when the proposal can be accepted
+     */
+    struct UintTypeProposal {
+        uint256 current;
+        uint256 proposal;
+        uint256 timeToAccept;
+    }
+
+    /**
+     * @dev Struct for managing boolean flag changes with time delay
+     * @param flag Current boolean state
+     * @param timeToAcceptChange Timestamp when the flag change can be executed
+     */
+    struct BoolTypeProposal {
+        bool flag;
+        uint256 timeToAcceptChange;
+    }
+}
+
+/**
+ * @title AdminControlled
+ * @notice Base contract for admin-controlled contracts with time-delayed governance
+ */
+abstract contract AdminControlled {
+    ProposalStructs.AddressTypeProposal public admin;
+
+    event AdminProposed(address indexed newAdmin, uint256 timeToAccept);
+    event AdminAccepted(address indexed newAdmin);
+
+    error SenderIsNotAdmin();
+    error ProposalNotReady();
+
+    modifier onlyAdmin() {
+        if (msg.sender != admin.current) revert SenderIsNotAdmin();
+        _;
+    }
+
+    /**
+     * @notice Proposes a new admin with time delay
+     * @param newAdmin Address of proposed admin
+     * @param delay Time delay before proposal can be accepted
+     */
+    function proposeAdmin(address newAdmin, uint256 delay) external onlyAdmin {
+        admin.proposal = newAdmin;
+        admin.timeToAccept = block.timestamp + delay;
+        emit AdminProposed(newAdmin, admin.timeToAccept);
+    }
+
+    /**
+     * @notice Accepts the admin proposal after time delay
+     */
+    function acceptAdminProposal() external onlyAdmin {
+        if (block.timestamp < admin.timeToAccept) revert ProposalNotReady();
+        admin.current = admin.proposal;
+        admin.proposal = address(0);
+        admin.timeToAccept = 0;
+        emit AdminAccepted(admin.current);
+    }
+}

package/library/utils/{service/AsyncNonceService.sol → nonces/AsyncNonce.sol}

@@ -3,32 +3,30 @@
 
 pragma solidity ^0.8.0;
 
-abstract contract AsyncNonceService {
-
-    error ServiceAsyncNonceAlreadyUsed();
+abstract contract AsyncNonce {
+    error AsyncNonceAlreadyUsed();
 
     mapping(address user => mapping(uint256 nonce => bool availability))
-        private asyncServiceNonce;
+        private asyncNonce;
 
-    function markAsyncServiceNonceAsUsed(
+    function markAsyncNonceAsUsed(
         address user,
         uint256 nonce
     ) internal virtual {
-        asyncServiceNonce[user][nonce] = true;
+        asyncNonce[user][nonce] = true;
     }
 
-    function verifyAsyncServiceNonce(
+    function verifyAsyncNonce(
         address user,
         uint256 nonce
     ) internal view virtual {
-        if (asyncServiceNonce[user][nonce])
-            revert ServiceAsyncNonceAlreadyUsed();
+        if (asyncNonce[user][nonce]) revert AsyncNonceAlreadyUsed();
     }
 
-    function isAsyncServiceNonceAvailable(
+    function getIfUsedAsyncNonce(
         address user,
         uint256 nonce
     ) public view virtual returns (bool) {
-        return asyncServiceNonce[user][nonce];
+        return asyncNonce[user][nonce];
     }
 }

package/library/utils/nonces/SyncNonce.sol

@@ -0,0 +1,27 @@
+// 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 SyncNonce {
+    error SyncNonceMismatch();
+
+    mapping(address user => uint256 nonce) private syncNonce;
+
+    function incrementSyncNonce(address user) internal virtual {
+        syncNonce[user]++;
+    }
+
+    function verifySyncNonce(
+        address user,
+        uint256 nonce
+    ) internal view virtual {
+        if (syncNonce[user] != nonce) revert SyncNonceMismatch();
+    }
+
+    function getNextCurrentSyncNonce(
+        address user
+    ) public view virtual returns (uint256) {
+        return syncNonce[user];
+    }
+}

package/library/utils/service/EvvmPayments.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 {IEvvm, EvvmStructs} from "@evvm/testnet-contracts/interfaces/IEvvm.sol";
+
+abstract contract EvvmPayments {
+    IEvvm internal evvm;
+
+    constructor(address evvmAddress) {}
+
+    function requestPay(
+        address from,
+        address token,
+        uint256 amount,
+        uint256 priorityFee,
+        uint256 nonce,
+        bool priorityFlag,
+        bytes memory signature
+    ) internal virtual {
+        evvm.pay(
+            from,
+            address(this),
+            "",
+            token,
+            amount,
+            priorityFee,
+            nonce,
+            priorityFlag,
+            address(this),
+            signature
+        );
+    }
+
+    function requestDispersePay(
+        EvvmStructs.DispersePayMetadata[] memory toData,
+        address token,
+        uint256 amount,
+        uint256 priorityFee,
+        uint256 nonce,
+        bool priorityFlag,
+        bytes memory signature
+    ) internal virtual {
+        evvm.dispersePay(
+            address(this),
+            toData,
+            token,
+            amount,
+            priorityFee,
+            nonce,
+            priorityFlag,
+            address(this),
+            signature
+        );
+    }
+
+    function makeCaPay(
+        address to,
+        address token,
+        uint256 amount
+    ) internal virtual {
+        evvm.caPay(to, token, amount);
+    }
+
+    function makeDisperseCaPay(
+        EvvmStructs.DisperseCaPayMetadata[] memory toData,
+        address token,
+        uint256 amount
+    ) internal virtual {
+        evvm.disperseCaPay(toData, token, amount);
+    }
+
+    function _changeEvvmAddress(address newEvvmAddress) internal virtual {
+        evvm = IEvvm(newEvvmAddress);
+    }
+}

package/library/utils/service/StakingServiceUtils.sol

@@ -2,36 +2,31 @@
 // Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
 pragma solidity ^0.8.0;
 
-import {IEvvm} from "@evvm/testnet-contracts/interfaces/IEvvm.sol";
 import {IStaking} from "@evvm/testnet-contracts/interfaces/IStaking.sol";
+import {IEvvm} from "@evvm/testnet-contracts/interfaces/IEvvm.sol";
 
 abstract contract StakingServiceUtils {
-    address stakingHookAddress;
-    address evvmHookAddress;
-    constructor(address _stakingAddress) {
-        stakingHookAddress = _stakingAddress;
-        evvmHookAddress = IStaking(stakingHookAddress).getEvvmAddress();
+    IStaking internal staking;
+
+    constructor(address stakingAddress) {
+        staking = IStaking(stakingAddress);
     }
+
     function _makeStakeService(uint256 amountToStake) internal {
-        IStaking(stakingHookAddress).prepareServiceStaking(amountToStake);
-        IEvvm(evvmHookAddress).caPay(
-            address(stakingHookAddress),
-            0x0000000000000000000000000000000000000001,
-            IStaking(stakingHookAddress).priceOfStaking() * amountToStake
+        staking.prepareServiceStaking(amountToStake);
+        IEvvm(staking.getEvvmAddress()).caPay(
+            address(staking),
+            IEvvm(staking.getEvvmAddress()).getPrincipalTokenAddress(),
+            staking.priceOfStaking() * amountToStake
         );
-        IStaking(stakingHookAddress).confirmServiceStaking();
+        staking.confirmServiceStaking();
     }
 
     function _makeUnstakeService(uint256 amountToUnstake) internal {
-        IStaking(stakingHookAddress).serviceUnstaking(amountToUnstake);
-    }
-
-    function _changeStakingAddress(address newStakingAddress) internal {
-        stakingHookAddress = newStakingAddress;
-        evvmHookAddress = IStaking(stakingHookAddress).getEvvmAddress();
+        staking.serviceUnstaking(amountToUnstake);
     }
 
-    function _changeEvvmHookAddress(address newEvvmAddress) internal {
-        evvmHookAddress = newEvvmAddress;
+    function _changeStakingAddress(address newStakingAddress) internal virtual {
+        staking = IStaking(newStakingAddress);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evvm/testnet-contracts",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "type": "module",
   "description": "EVVM Testnet Contracts - Smart contracts and tools for scalable, modular, and cross-chain EVM virtualization",
   "files": [
@@ -36,18 +36,17 @@
     "access": "public"
   },
   "scripts": {
-    "build": "npm run copy-files",
+    "publish-package": "bun run copy-files && bun publish && bun run clean",
+    "prepare-publish": "bun run copy-files && bun run pack",
+    "build": "bun run copy-files",
     "copy-files": "cp -r src/contracts . && cp -r src/interfaces . && cp -r src/library .",
     "clean": "rm -rf contracts interfaces library",
-    "prepare-publish": "npm run copy-files && npm pack",
-    "publish-package": "npm run copy-files && npm publish && npm run clean",
-    "compile": "forge build",
-    "test": "forge test",
-    "deploy:anvil": "make deployLocalTestnet",
-    "deploy:sepolia": "make deployTestnet NETWORK=eth",
-    "deploy:arbitrum": "make deployTestnet NETWORK=arb",
-    "wizard": "tsx scripts/evvm-init.ts",
-    "wizard:deploy": "tsx scripts/evvm-init.ts --deploy"
+    "evvm": "bun run cli/index.ts",
+    "buildCli": "bun build cli/index.ts --compile --outfile evvm",
+    "build-all": "bun run build-linux && bun run build-windows && bun run build-macos",
+    "build-linux": "bun build cli/index.ts --compile --outfile .executables/evvm-linux-x64 && bun build cli/index.ts --compile --outfile .executables/evvm-linux-arm64 && bun build cli/index.ts --compile --outfile .executables/evvm-linux-x64-musl && bun build cli/index.ts --compile --outfile .executables/evvm-linux-arm64-musl",
+    "build-windows": "bun build cli/index.ts --compile --outfile .executables/evvm-windows-x64.exe",
+    "build-macos": "bun build cli/index.ts --compile --outfile .executables/evvm-darwin-x64 && bun build cli/index.ts --compile --outfile .executables/evvm-darwin-arm64"
   },
   "peerDependencies": {
     "@openzeppelin/contracts": "^5.0.0"
@@ -58,13 +57,12 @@
     "dotenv": "^16.4.5",
     "execa": "^8.0.1",
     "prompts": "^2.4.2",
-    "viem": "^2.39.0"
+    "viem": "^2.43.3"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",
     "@types/prompts": "^2.4.9",
     "forge-std": "^1.0.0",
-    "tsx": "^4.7.0",
     "typescript": "^5.3.0"
   }
 }

package/library/utils/service/MakeServicePaymentOnEvvm.sol

@@ -1,49 +0,0 @@
-// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
-// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
-
-pragma solidity ^0.8.0;
-
-import {IEvvm} from "@evvm/testnet-contracts/interfaces/IEvvm.sol";
-
-abstract contract MakeServicePaymentOnEvvm {
-    IEvvm public evvm;
-
-    constructor(address evvmAddress) {
-        evvm = IEvvm(evvmAddress);
-    }
-
-    function makePay(
-        address from,
-        address token,
-        uint256 amount,
-        uint256 priorityFee,
-        uint256 nonce,
-        bool priorityFlag,
-        bytes memory signature
-    ) internal virtual {
-        evvm.pay(
-            from,
-            address(this),
-            "",
-            token,
-            amount,
-            priorityFee,
-            nonce,
-            priorityFlag,
-            address(this),
-            signature
-        );
-    }
-
-    function makeCaPay(
-        address to,
-        address token,
-        uint256 amount
-    ) internal virtual {
-        evvm.caPay(to, token, amount);
-    }
-
-    function _changeEvvmAddress(address newEvvmAddress) internal {
-        evvm = IEvvm(newEvvmAddress);
-    }
-}