@across-protocol/contracts 5.0.6-alpha.0 → 5.0.6-alpha.1

package/contracts/test/MockCaller.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "../interfaces/SpokePoolInterface.sol";
+
+// Used for calling SpokePool.sol functions from a contract instead of an EOA. Can be used to simulate aggregator
+// or pooled relayer behavior. Makes all calls from constructor to make sure SpokePool is not relying on checking the
+// caller's code size which is 0 at construction time.
+
+contract MockCaller {
+    constructor(
+        address _spokePool,
+        uint32 rootBundleId,
+        SpokePoolInterface.RelayerRefundLeaf memory relayerRefundLeaf,
+        bytes32[] memory proof
+    ) {
+        require(_spokePool != address(this), "spokePool not external");
+        SpokePoolInterface(_spokePool).executeRelayerRefundLeaf(rootBundleId, relayerRefundLeaf, proof);
+    }
+}

package/contracts/test/MockERC1271.sol

@@ -0,0 +1,21 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts-v4/interfaces/IERC1271.sol";
+
+import "@openzeppelin/contracts-v4/utils/cryptography/ECDSA.sol";
+import "@openzeppelin/contracts-v4/access/Ownable.sol";
+
+/**
+ * @title MockERC1271
+ * @notice Implements mocked ERC1271 contract for testing.
+ */
+contract MockERC1271 is IERC1271, Ownable {
+    constructor(address originalOwner) {
+        transferOwnership(originalOwner);
+    }
+
+    function isValidSignature(bytes32 hash, bytes memory signature) public view override returns (bytes4 magicValue) {
+        return ECDSA.recover(hash, signature) == owner() ? this.isValidSignature.selector : bytes4(0);
+    }
+}

package/contracts/test/MockERC20.sol

@@ -0,0 +1,87 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8.0;
+
+import { IERC20Auth } from "../external/interfaces/IERC20Auth.sol";
+import { ERC20Permit } from "@openzeppelin/contracts-v4/token/ERC20/extensions/ERC20Permit.sol";
+import { ERC20 } from "@openzeppelin/contracts-v4/token/ERC20/ERC20.sol";
+import { SignatureChecker } from "@openzeppelin/contracts-v4/utils/cryptography/SignatureChecker.sol";
+
+/**
+ * @title MintableERC20
+ * @notice Simple mintable ERC20 with configurable decimals for testing.
+ */
+contract MintableERC20 is ERC20 {
+    uint8 private _decimals;
+
+    constructor(string memory name, string memory symbol, uint8 decimals_) ERC20(name, symbol) {
+        _decimals = decimals_;
+    }
+
+    function mint(address to, uint256 amount) external returns (bool) {
+        _mint(to, amount);
+        return true;
+    }
+
+    function burn(uint256 amount) external {
+        _burn(msg.sender, amount);
+    }
+
+    function burnFrom(address from, uint256 amount) external returns (bool) {
+        _spendAllowance(from, msg.sender, amount);
+        _burn(from, amount);
+        return true;
+    }
+
+    // ExpandedIERC20 compatibility
+    function addMinter(address) external {}
+    function addBurner(address) external {}
+    function resetOwner(address) external {}
+
+    function decimals() public view override returns (uint8) {
+        return _decimals;
+    }
+}
+
+/**
+ * @title MockERC20
+ * @notice Implements mocked ERC20 contract with various features.
+ */
+contract MockERC20 is IERC20Auth, ERC20Permit {
+    bytes32 public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH =
+        keccak256(
+            "ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)"
+        );
+    // Expose the typehash in ERC20Permit.
+    bytes32 public constant PERMIT_TYPEHASH_EXTERNAL =
+        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+
+    constructor() ERC20Permit("MockERC20") ERC20("MockERC20", "ERC20") {}
+
+    // This does no nonce checking.
+    function receiveWithAuthorization(
+        address from,
+        address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external {
+        require(validAfter <= block.timestamp && validBefore >= block.timestamp, "Invalid time bounds");
+        require(msg.sender == to, "Receiver not caller");
+        bytes memory signature = bytes.concat(r, s, bytes1(v));
+
+        bytes32 structHash = keccak256(
+            abi.encode(RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce)
+        );
+        bytes32 sigHash = _hashTypedDataV4(structHash);
+        require(SignatureChecker.isValidSignatureNow(from, sigHash, signature), "Invalid signature");
+        _transfer(from, to, value);
+    }
+
+    function hashTypedData(bytes32 typedData) external view returns (bytes32) {
+        return _hashTypedDataV4(typedData);
+    }
+}

package/contracts/test/MockEndpoint.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import { IEndpoint } from "../interfaces/IOFT.sol";
+
+contract MockEndpoint is IEndpoint {
+    uint32 internal _eid;
+
+    constructor(uint32 eid_) {
+        _eid = eid_;
+    }
+
+    function eid() external view override returns (uint32) {
+        return _eid;
+    }
+}

package/contracts/test/MockHubPool.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { HubPoolInterface } from "../interfaces/HubPoolInterface.sol";
+
+/// @title MockHubPool for Token Relay between Layer 1 and Layer 2
+/// @dev This contract acts as a mock implementation for testing purposes,
+///      simulating the behavior of a hub pool that can relay tokens and messages
+///      between Ethereum (Layer 1) and a Layer 2 solution like Optimism.
+///      It delegates calls to an external chain adapter contract for actual execution.
+contract MockHubPool {
+    /// @notice Emitted when the adapter contract address is changed.
+    event AdapterChanged(address indexed oldAdapter, address indexed newAdapter);
+
+    /// @notice The address of the contract owner, set to the deployer of the contract.
+    address public immutable owner;
+    /// @notice The address of the adapter contract responsible for handling
+    ///         token relay and message passing to Layer 2.
+    address public adapter;
+
+    HubPoolInterface.RootBundle public rootBundleProposal;
+
+    /// @notice Creates a new MockHubPool and sets the owner and initial adapter.
+    /// @param _adapter The address of the initial adapter contract.
+    constructor(address _adapter) {
+        adapter = _adapter;
+        owner = msg.sender; // Set the contract deployer as the owner
+    }
+
+    /// @notice Ensures that a function is callable only by the contract owner.
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Caller is not the owner");
+        _;
+    }
+
+    /// @notice Fallback function to receive ETH.
+    fallback() external payable {} // solhint-disable-line no-empty-blocks
+
+    /// @notice Receive function to handle direct ETH transfers.
+    receive() external payable {} // solhint-disable-line no-empty-blocks
+
+    /// @notice Changes the adapter contract address.
+    /// @dev This function can only be called by the contract owner.
+    /// @param _adapter The new adapter contract address.
+    function changeAdapter(address _adapter) public onlyOwner {
+        require(_adapter != address(0), "NO_ZERO_ADDRESS");
+        address _oldAdapter = adapter;
+        adapter = _adapter;
+        emit AdapterChanged(_oldAdapter, _adapter);
+    }
+
+    function setPendingRootBundle(HubPoolInterface.RootBundle memory _rootBundleProposal) external {
+        rootBundleProposal = _rootBundleProposal;
+    }
+
+    /// @notice Relays tokens from L1 to L2 using the adapter contract.
+    /// @dev This function delegates the call to the adapter contract.
+    /// @param l1Token The address of the L1 token to relay.
+    /// @param l2Token The address of the L2 token to receive.
+    /// @param amount The amount of tokens to relay.
+    /// @param to The address on L2 to receive the tokens.
+    function relayTokens(address l1Token, address l2Token, uint256 amount, address to) external {
+        (bool success, ) = adapter.delegatecall(
+            abi.encodeWithSignature(
+                "relayTokens(address,address,uint256,address)",
+                l1Token, // l1Token.
+                l2Token, // l2Token.
+                amount, // amount.
+                to // to. This should be the spokePool.
+            )
+        );
+        require(success, "delegatecall failed");
+    }
+
+    /// @notice Queries the balance of a user for a specific L2 token using the adapter contract.
+    /// @dev This function delegates the call to the adapter contract to execute the balance check.
+    /// @param l2Token The address of the L2 token.
+    /// @param user The user address whose balance is being queried.
+    function balanceOf(address l2Token, address user) external {
+        (bool success, ) = adapter.delegatecall(
+            abi.encodeWithSignature(
+                "relayMessage(address,bytes)",
+                l2Token,
+                abi.encodeWithSignature("balanceOf(address)", user) // message
+            )
+        );
+        require(success, "delegatecall failed");
+    }
+
+    /// @notice Relays an arbitrary message to the L2 chain via the adapter contract.
+    /// @dev This function delegates the call to the adapter contract to execute the message relay.
+    /// @param target The address of the target contract on L2.
+    /// @param l2CallData The calldata to send to the target contract on L2. (must be abi encoded)
+    function arbitraryMessage(address target, bytes memory l2CallData) external {
+        (bool success, ) = adapter.delegatecall(
+            abi.encodeWithSignature("relayMessage(address,bytes)", target, l2CallData)
+        );
+        require(success, "delegatecall failed");
+    }
+}

package/contracts/test/MockOFTMessenger.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "../interfaces/IOFT.sol";
+
+/**
+ * @notice Facilitate bridging tokens via LayerZero's OFT.
+ * @dev This contract is intended to be inherited by other chain-specific adapters and spoke pools.
+ * @custom:security-contact bugs@across.to
+ */
+contract MockOFTMessenger is IOFT, IOAppCore {
+    address public token;
+    uint256 public nativeFee;
+    uint256 public lzFee;
+    uint256 public amountSentLDToReturn;
+    uint256 public amountReceivedLDToReturn;
+    bool public useCustomReceipt;
+
+    // IOAppCore endpoint for tests that require endpoint().eid()
+    IEndpoint public endpoint_;
+
+    // Captured call data for assertions in tests
+    SendParam public lastSendParam;
+    MessagingFee public lastFee;
+    address public lastRefundAddress;
+    uint256 public lastMsgValue;
+    uint256 public sendCallCount;
+
+    constructor(address _token) {
+        token = _token;
+    }
+
+    // Test helper to set the endpoint used by IOAppCore
+    function setEndpoint(address endpointAddr) external {
+        endpoint_ = IEndpoint(endpointAddr);
+    }
+
+    // IOAppCore
+    function endpoint() external view returns (IEndpoint iEndpoint) {
+        return endpoint_;
+    }
+
+    function sharedDecimals() external pure returns (uint8) {
+        return 6;
+    }
+
+    // IOFT
+    function quoteSend(
+        SendParam calldata /*_sendParam*/,
+        bool /*_payInLzToken*/
+    ) external view returns (MessagingFee memory) {
+        return MessagingFee(nativeFee, lzFee);
+    }
+
+    function send(
+        SendParam calldata _sendParam,
+        MessagingFee calldata _fee,
+        address _refundAddress
+    ) external payable returns (MessagingReceipt memory, OFTReceipt memory) {
+        lastSendParam = _sendParam;
+        lastFee = _fee;
+        lastRefundAddress = _refundAddress;
+        lastMsgValue = msg.value;
+        sendCallCount++;
+        if (useCustomReceipt) {
+            return (
+                MessagingReceipt(0, 0, MessagingFee(0, 0)),
+                OFTReceipt(amountSentLDToReturn, amountReceivedLDToReturn)
+            );
+        }
+        return (MessagingReceipt(0, 0, MessagingFee(0, 0)), OFTReceipt(_sendParam.amountLD, _sendParam.amountLD));
+    }
+
+    function setLDAmountsToReturn(uint256 _amountSentLD, uint256 _amountReceivedLD) external {
+        amountSentLDToReturn = _amountSentLD;
+        amountReceivedLDToReturn = _amountReceivedLD;
+        useCustomReceipt = true;
+    }
+
+    function resetReceipt() external {
+        useCustomReceipt = false;
+    }
+
+    function setFeesToReturn(uint256 _nativeFee, uint256 _lzFee) external {
+        nativeFee = _nativeFee;
+        lzFee = _lzFee;
+    }
+}

package/contracts/test/MockOptimism_SpokePool.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+import "../spoke-pools/Ovm_SpokePool.sol";
+
+/**
+ * @notice Mock Optimism Spoke pool allowing deployer to override constructor params.
+ */
+contract MockOptimism_SpokePool is Ovm_SpokePool {
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor(
+        address _wrappedNativeTokenAddress
+    ) Ovm_SpokePool(_wrappedNativeTokenAddress, 1 hours, 9 hours, IERC20(address(0)), ITokenMessenger(address(0))) {} // solhint-disable-line no-empty-blocks
+
+    function initialize(
+        address l2Eth,
+        uint32 _initialDepositId,
+        address _crossDomainAdmin,
+        address _hubPool
+    ) public initializer {
+        __OvmSpokePool_init(_initialDepositId, _crossDomainAdmin, _hubPool, l2Eth);
+    }
+}

package/contracts/test/MockPermit2.sol

@@ -0,0 +1,188 @@
+pragma solidity ^0.8.0;
+
+import { IPermit2 } from "../external/interfaces/IPermit2.sol";
+import { IERC20 } from "@openzeppelin/contracts-v4/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/contracts-v4/token/ERC20/utils/SafeERC20.sol";
+import { IERC1271 } from "@openzeppelin/contracts-v4/interfaces/IERC1271.sol";
+import { EIP712 } from "@openzeppelin/contracts-v4/utils/cryptography/EIP712.sol";
+
+// Taken from https://github.com/Uniswap/permit2/blob/main/src/EIP712.sol
+contract Permit2EIP712 {
+    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
+    uint256 private immutable _CACHED_CHAIN_ID;
+
+    bytes32 private constant _HASHED_NAME = keccak256("Permit2");
+    bytes32 private constant _TYPE_HASH =
+        keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
+
+    constructor() {
+        _CACHED_CHAIN_ID = block.chainid;
+        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME);
+    }
+
+    function DOMAIN_SEPARATOR() public view returns (bytes32) {
+        return
+            block.chainid == _CACHED_CHAIN_ID
+                ? _CACHED_DOMAIN_SEPARATOR
+                : _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME);
+    }
+
+    function _buildDomainSeparator(bytes32 typeHash, bytes32 nameHash) private view returns (bytes32) {
+        return keccak256(abi.encode(typeHash, nameHash, block.chainid, address(this)));
+    }
+
+    function _hashTypedData(bytes32 dataHash) internal view returns (bytes32) {
+        return keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR(), dataHash));
+    }
+}
+
+contract MockPermit2 is IPermit2, Permit2EIP712 {
+    using SafeERC20 for IERC20;
+
+    mapping(address => mapping(uint256 => uint256)) public nonceBitmap;
+    mapping(address => mapping(address => mapping(address => uint256))) public allowance;
+
+    bytes32 public constant _TOKEN_PERMISSIONS_TYPEHASH = keccak256("TokenPermissions(address token,uint256 amount)");
+    string public constant _PERMIT_TRANSFER_FROM_WITNESS_TYPEHASH_STUB =
+        "PermitWitnessTransferFrom(TokenPermissions permitted,address spender,uint256 nonce,uint256 deadline,";
+
+    error SignatureExpired();
+    error InvalidAmount();
+    error InvalidNonce();
+    error AllowanceExpired();
+    error InsufficientAllowance();
+
+    function permitWitnessTransferFrom(
+        PermitTransferFrom memory _permit,
+        SignatureTransferDetails calldata transferDetails,
+        address owner,
+        bytes32 witness,
+        string calldata witnessTypeString,
+        bytes calldata signature
+    ) external override {
+        _permitTransferFrom(
+            _permit,
+            transferDetails,
+            owner,
+            hashWithWitness(_permit, witness, witnessTypeString),
+            signature
+        );
+    }
+
+    function transferFrom(address from, address to, uint160 amount, address token) external {
+        _transfer(from, to, amount, token);
+    }
+
+    // This is not a copy of permit2's permit.
+    function permit(address owner, PermitSingle memory permitSingle, bytes calldata signature) external {
+        if (block.timestamp > permitSingle.sigDeadline) revert SignatureExpired();
+
+        // Verify the signer address from the signature.
+        SignatureVerification.verify(signature, _hashTypedData(keccak256(abi.encode(permitSingle))), owner);
+
+        allowance[owner][permitSingle.details.token][permitSingle.spender] = permitSingle.details.amount;
+    }
+
+    // This is not a copy of permit2's permit.
+    function _transfer(address from, address to, uint160 amount, address token) private {
+        uint256 allowed = allowance[from][token][msg.sender];
+
+        if (allowed != type(uint160).max) {
+            if (amount > allowed) {
+                revert InsufficientAllowance();
+            } else {
+                unchecked {
+                    allowance[from][token][msg.sender] = uint160(allowed) - amount;
+                }
+            }
+        }
+
+        // Transfer the tokens from the from address to the recipient.
+        IERC20(token).safeTransferFrom(from, to, amount);
+    }
+
+    function _permitTransferFrom(
+        PermitTransferFrom memory _permit,
+        SignatureTransferDetails calldata transferDetails,
+        address owner,
+        bytes32 dataHash,
+        bytes calldata signature
+    ) private {
+        uint256 requestedAmount = transferDetails.requestedAmount;
+
+        if (block.timestamp > _permit.deadline) revert SignatureExpired();
+        if (requestedAmount > _permit.permitted.amount) revert InvalidAmount();
+
+        _useUnorderedNonce(owner, _permit.nonce);
+
+        SignatureVerification.verify(signature, _hashTypedData(dataHash), owner);
+
+        IERC20(_permit.permitted.token).safeTransferFrom(owner, transferDetails.to, requestedAmount);
+    }
+
+    function bitmapPositions(uint256 nonce) private pure returns (uint256 wordPos, uint256 bitPos) {
+        wordPos = uint248(nonce >> 8);
+        bitPos = uint8(nonce);
+    }
+
+    function _useUnorderedNonce(address from, uint256 nonce) internal {
+        (uint256 wordPos, uint256 bitPos) = bitmapPositions(nonce);
+        uint256 bit = 1 << bitPos;
+        uint256 flipped = nonceBitmap[from][wordPos] ^= bit;
+
+        if (flipped & bit == 0) revert InvalidNonce();
+    }
+
+    function hashWithWitness(
+        PermitTransferFrom memory _permit,
+        bytes32 witness,
+        string calldata witnessTypeString
+    ) internal view returns (bytes32) {
+        bytes32 typeHash = keccak256(abi.encodePacked(_PERMIT_TRANSFER_FROM_WITNESS_TYPEHASH_STUB, witnessTypeString));
+
+        bytes32 tokenPermissionsHash = _hashTokenPermissions(_permit.permitted);
+        return
+            keccak256(abi.encode(typeHash, tokenPermissionsHash, msg.sender, _permit.nonce, _permit.deadline, witness));
+    }
+
+    function _hashTokenPermissions(TokenPermissions memory permitted) private pure returns (bytes32) {
+        return keccak256(abi.encode(_TOKEN_PERMISSIONS_TYPEHASH, permitted));
+    }
+}
+
+// Taken from https://github.com/Uniswap/permit2/blob/main/src/libraries/SignatureVerification.sol
+library SignatureVerification {
+    error InvalidSignatureLength();
+    error InvalidSignature();
+    error InvalidSigner();
+    error InvalidContractSignature();
+
+    bytes32 constant UPPER_BIT_MASK = (0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+
+    function verify(bytes calldata signature, bytes32 hash, address claimedSigner) internal view {
+        bytes32 r;
+        bytes32 s;
+        uint8 v;
+
+        if (claimedSigner.code.length == 0) {
+            if (signature.length == 65) {
+                (r, s) = abi.decode(signature, (bytes32, bytes32));
+                v = uint8(signature[64]);
+            } else if (signature.length == 64) {
+                // EIP-2098
+                bytes32 vs;
+                (r, vs) = abi.decode(signature, (bytes32, bytes32));
+                s = vs & UPPER_BIT_MASK;
+                v = uint8(uint256(vs >> 255)) + 27;
+            } else {
+                revert InvalidSignatureLength();
+            }
+            address signer = ecrecover(hash, v, r, s);
+            if (signer == address(0)) revert InvalidSignature();
+            if (signer != claimedSigner) revert InvalidSigner();
+        } else {
+            bytes4 magicValue = IERC1271(claimedSigner).isValidSignature(hash, signature);
+            if (magicValue != IERC1271.isValidSignature.selector) revert InvalidContractSignature();
+        }
+    }
+}