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

package/contracts/test/MockSpokePool.sol

@@ -0,0 +1,263 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts-upgradeable-v4/access/OwnableUpgradeable.sol";
+import "../spoke-pools/SpokePool.sol";
+import "./interfaces/MockV2SpokePoolInterface.sol";
+import "./V2MerkleLib.sol";
+import { AddressToBytes32, Bytes32ToAddress } from "../libraries/AddressConverters.sol";
+
+/**
+ * @title MockSpokePool
+ * @notice Implements abstract contract for testing.
+ */
+contract MockSpokePool is SpokePool, MockV2SpokePoolInterface, OwnableUpgradeable {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+    using AddressToBytes32 for address;
+    using Bytes32ToAddress for bytes32;
+
+    uint256 private chainId_;
+    uint256 private currentTime;
+    mapping(bytes32 => uint256) private relayFills;
+
+    uint256 public constant SLOW_FILL_MAX_TOKENS_TO_SEND = 1e40;
+
+    bytes32 public constant UPDATE_DEPOSIT_DETAILS_HASH =
+        keccak256(
+            "UpdateDepositDetails(uint256 depositId,uint256 originChainId,int64 updatedRelayerFeePct,address updatedRecipient,bytes updatedMessage)"
+        );
+
+    event BridgedToHubPool(uint256 amount, address token);
+    event PreLeafExecuteHook(bytes32 token);
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor(address _wrappedNativeTokenAddress) SpokePool(_wrappedNativeTokenAddress, 1 hours, 9 hours, 0, 0) {} // solhint-disable-line no-empty-blocks
+
+    function initialize(uint32 _initialDepositId, address _crossDomainAdmin, address _hubPool) public initializer {
+        __Ownable_init();
+        __SpokePool_init(_initialDepositId, _crossDomainAdmin, _hubPool);
+        currentTime = block.timestamp; // solhint-disable-line not-rely-on-time
+    }
+
+    function setCurrentTime(uint256 time) external {
+        currentTime = time;
+    }
+
+    function distributeRelayerRefunds(
+        uint256 _chainId,
+        uint256 amountToReturn,
+        uint256[] memory refundAmounts,
+        uint32 leafId,
+        address l2TokenAddress,
+        address[] memory refundAddresses
+    ) external {
+        _distributeRelayerRefunds(_chainId, amountToReturn, refundAmounts, leafId, l2TokenAddress, refundAddresses);
+    }
+
+    function _verifyUpdateDepositMessage(
+        address depositor,
+        uint256 depositId,
+        uint256 originChainId,
+        int64 updatedRelayerFeePct,
+        bytes32 updatedRecipient,
+        bytes memory updatedMessage,
+        bytes memory depositorSignature
+    ) internal view {
+        bytes32 expectedTypedDataV4Hash = _hashTypedDataV4(
+            // EIP-712 compliant hash struct: https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct
+            keccak256(
+                abi.encode(
+                    UPDATE_DEPOSIT_DETAILS_HASH,
+                    depositId,
+                    originChainId,
+                    updatedRelayerFeePct,
+                    updatedRecipient,
+                    keccak256(updatedMessage)
+                )
+            ),
+            // By passing in the origin chain id, we enable the verification of the signature on a different chain
+            originChainId
+        );
+        _verifyDepositorSignature(depositor, expectedTypedDataV4Hash, depositorSignature);
+    }
+
+    function verifyUpdateV3DepositMessageBytes32(
+        bytes32 depositor,
+        uint256 depositId,
+        uint256 originChainId,
+        uint256 updatedOutputAmount,
+        bytes32 updatedRecipient,
+        bytes memory updatedMessage,
+        bytes memory depositorSignature
+    ) public view {
+        return
+            _verifyUpdateV3DepositMessage(
+                depositor.toAddress(),
+                depositId,
+                originChainId,
+                updatedOutputAmount,
+                updatedRecipient,
+                updatedMessage,
+                depositorSignature,
+                UPDATE_BYTES32_DEPOSIT_DETAILS_HASH
+            );
+    }
+
+    function verifyUpdateV3DepositMessage(
+        address depositor,
+        uint256 depositId,
+        uint256 originChainId,
+        uint256 updatedOutputAmount,
+        address updatedRecipient,
+        bytes memory updatedMessage,
+        bytes memory depositorSignature
+    ) public view {
+        return
+            _verifyUpdateV3DepositMessage(
+                depositor,
+                depositId,
+                originChainId,
+                updatedOutputAmount,
+                updatedRecipient.toBytes32(),
+                updatedMessage,
+                depositorSignature,
+                UPDATE_BYTES32_DEPOSIT_DETAILS_HASH
+            );
+    }
+
+    function fillRelayV3Internal(
+        V3RelayExecutionParams memory relayExecution,
+        bytes32 relayer,
+        bool isSlowFill
+    ) external {
+        _fillRelayV3(relayExecution, relayer, isSlowFill);
+    }
+
+    // This function is nonReentrant in order to allow caller to test whether a different function
+    // is reentrancy protected or not.
+    function callback(bytes memory data) external payable nonReentrant {
+        (bool success, bytes memory result) = address(this).call{ value: msg.value }(data);
+        require(success, string(result));
+    }
+
+    function setFillStatus(bytes32 relayHash, FillType fillType) external {
+        fillStatuses[relayHash] = uint256(fillType);
+    }
+
+    function getCurrentTime() public view override returns (uint256) {
+        return currentTime;
+    }
+
+    function _preExecuteLeafHook(address token) internal override {
+        emit PreLeafExecuteHook(token.toBytes32());
+    }
+
+    function _bridgeTokensToHubPool(uint256 amount, address token) internal override {
+        emit BridgedToHubPool(amount, token);
+    }
+
+    function _requireAdminSender() internal override onlyOwner {} // solhint-disable-line no-empty-blocks
+
+    function chainId() public view override(SpokePool) returns (uint256) {
+        // If chainId_ is set then return it, else do nothing and return the parent chainId().
+        return chainId_ == 0 ? super.chainId() : chainId_;
+    }
+
+    function setChainId(uint256 _chainId) public {
+        chainId_ = _chainId;
+    }
+
+    function _computeAmountPreFees(uint256 amount, int64 feesPct) private pure returns (uint256) {
+        return (1e18 * amount) / uint256((int256(1e18) - feesPct));
+    }
+
+    function __computeAmountPostFees(uint256 amount, int256 feesPct) private pure returns (uint256) {
+        return (amount * uint256(int256(1e18) - feesPct)) / 1e18;
+    }
+
+    function _getRelayHash(MockV2SpokePoolInterface.RelayData memory relayData) private pure returns (bytes32) {
+        return keccak256(abi.encode(relayData));
+    }
+
+    function _fillRelay(RelayExecution memory relayExecution) internal returns (uint256 fillAmountPreFees) {
+        MockV2SpokePoolInterface.RelayData memory relayData = relayExecution.relay;
+
+        require(relayFills[relayExecution.relayHash] < relayData.amount, "relay filled");
+
+        fillAmountPreFees = _computeAmountPreFees(
+            relayExecution.maxTokensToSend,
+            (relayData.realizedLpFeePct + relayExecution.updatedRelayerFeePct)
+        );
+        require(fillAmountPreFees > 0, "fill amount pre fees is 0");
+
+        uint256 amountRemainingInRelay = relayData.amount - relayFills[relayExecution.relayHash];
+        if (amountRemainingInRelay < fillAmountPreFees) {
+            fillAmountPreFees = amountRemainingInRelay;
+        }
+
+        uint256 amountToSend = __computeAmountPostFees(
+            fillAmountPreFees,
+            relayData.realizedLpFeePct + relayExecution.updatedRelayerFeePct
+        );
+
+        if (relayExecution.payoutAdjustmentPct != 0) {
+            require(relayExecution.payoutAdjustmentPct >= -1e18, "payoutAdjustmentPct too small");
+            require(relayExecution.payoutAdjustmentPct <= 100e18, "payoutAdjustmentPct too large");
+
+            amountToSend = __computeAmountPostFees(amountToSend, -relayExecution.payoutAdjustmentPct);
+            require(amountToSend <= relayExecution.maxTokensToSend, "Somehow hit maxTokensToSend!");
+        }
+
+        bool localRepayment = relayExecution.repaymentChainId == relayExecution.relay.destinationChainId;
+        require(
+            localRepayment || relayExecution.relay.amount == fillAmountPreFees || relayExecution.slowFill,
+            "invalid repayment chain"
+        );
+
+        relayFills[relayExecution.relayHash] += fillAmountPreFees;
+
+        if (msg.sender.toBytes32() == relayExecution.updatedRecipient && !relayExecution.slowFill) {
+            return fillAmountPreFees;
+        }
+
+        if (relayData.destinationToken == address(wrappedNativeToken).toBytes32()) {
+            if (!relayExecution.slowFill) {
+                IERC20Upgradeable(relayData.destinationToken.toAddress()).safeTransferFrom(
+                    msg.sender,
+                    address(this),
+                    amountToSend
+                );
+            }
+            _unwrapwrappedNativeTokenTo(payable(relayExecution.updatedRecipient.toAddress()), amountToSend);
+        } else {
+            if (!relayExecution.slowFill) {
+                IERC20Upgradeable(relayData.destinationToken.toAddress()).safeTransferFrom(
+                    msg.sender,
+                    relayExecution.updatedRecipient.toAddress(),
+                    amountToSend
+                );
+            } else {
+                IERC20Upgradeable(relayData.destinationToken.toAddress()).safeTransfer(
+                    relayExecution.updatedRecipient.toAddress(),
+                    amountToSend
+                );
+            }
+        }
+    }
+
+    function _verifySlowFill(
+        RelayExecution memory relayExecution,
+        uint32 rootBundleId,
+        bytes32[] memory proof
+    ) internal view {
+        SlowFill memory slowFill = SlowFill({
+            relayData: relayExecution.relay,
+            payoutAdjustmentPct: relayExecution.payoutAdjustmentPct
+        });
+
+        require(
+            V2MerkleLib.verifySlowRelayFulfillment(rootBundles[rootBundleId].slowRelayRoot, slowFill, proof),
+            "Invalid slow relay proof"
+        );
+    }
+}

package/contracts/test/MockSpokePoolV2.sol

@@ -0,0 +1,27 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8.0;
+
+import "./MockSpokePool.sol";
+
+/**
+ * @title MockSpokePoolV2
+ * @notice Upgrades MockSpokePool for no practical reason other than to demonstrate
+ * upgradeability options
+ */
+contract MockSpokePoolV2 is MockSpokePool {
+    event NewEvent(bool value);
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor(address _wrappedNativeTokenAddress) MockSpokePool(_wrappedNativeTokenAddress) {} // solhint-disable-line no-empty-blocks
+
+    // Demonstrative of how we could reset state variables in a V2 contract conveniently while initializing new
+    // modules. The `reinitializer` modifier is required to create new Initializable contracts.
+    function reinitialize(address _hubPool) public reinitializer(2) {
+        _setWithdrawalRecipient(_hubPool);
+    }
+
+    // Demonstrative new function we could add in a V2 contract.
+    function emitEvent() external {
+        emit NewEvent(true);
+    }
+}

package/contracts/test/MockZkStackBridgeHub.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import { BridgeHubInterface } from "../interfaces/ZkStackBridgeHub.sol";
+
+contract MockBridgeHub is BridgeHubInterface {
+    address public immutable sharedBridge;
+
+    constructor(address _sharedBridge) {
+        sharedBridge = _sharedBridge;
+    }
+
+    mapping(uint256 => address) baseTokens;
+
+    function setBaseToken(uint256 _chainId, address _baseToken) external {
+        baseTokens[_chainId] = _baseToken;
+    }
+
+    function requestL2TransactionDirect(
+        L2TransactionRequestDirect calldata _request
+    ) external payable returns (bytes32 canonicalTxHash) {
+        canonicalTxHash = keccak256(abi.encode(_request));
+    }
+
+    function requestL2TransactionTwoBridges(
+        L2TransactionRequestTwoBridgesOuter calldata _request
+    ) external payable returns (bytes32 canonicalTxHash) {
+        canonicalTxHash = keccak256(abi.encode(_request));
+    }
+
+    function baseToken(uint256 _chainId) external view returns (address) {
+        return baseTokens[_chainId] == address(0) ? address(1) : baseTokens[_chainId];
+    }
+
+    function l2TransactionBaseCost(
+        uint256,
+        uint256 _gasPrice,
+        uint256 _l2GasLimit,
+        uint256 _l2GasPerPubdataByteLimit
+    ) external view returns (uint256) {
+        return _gasPrice + _l2GasLimit * _l2GasPerPubdataByteLimit;
+    }
+}

package/contracts/test/PolygonERC20Test.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "../external/uma/core/contracts/common/implementation/ExpandedERC20.sol";
+import "../spoke-pools/PolygonTokenBridger.sol";
+
+/**
+ * @notice Simulated Polygon ERC20 for use in testing PolygonTokenBridger.
+ */
+contract PolygonERC20Test is ExpandedERC20 {
+    constructor() ExpandedERC20("Polygon Test", "POLY_TEST", 18) {} // solhint-disable-line no-empty-blocks
+
+    function withdraw(uint256 amount) public {
+        _burn(msg.sender, amount);
+    }
+}

package/contracts/test/PolygonMocks.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts-v4/token/ERC20/ERC20.sol";
+
+contract RootChainManagerMock {
+    // Call tracking for depositEtherFor
+    uint256 public depositEtherForCallCount;
+    struct DepositEtherForCall {
+        address user;
+        uint256 value;
+    }
+    DepositEtherForCall public lastDepositEtherForCall;
+
+    // Call tracking for depositFor
+    uint256 public depositForCallCount;
+    struct DepositForCall {
+        address user;
+        address rootToken;
+        bytes depositData;
+    }
+    DepositForCall public lastDepositForCall;
+
+    function depositEtherFor(address user) external payable {
+        depositEtherForCallCount++;
+        lastDepositEtherForCall = DepositEtherForCall(user, msg.value);
+    }
+
+    function depositFor(address user, address rootToken, bytes calldata depositData) external {
+        depositForCallCount++;
+        lastDepositForCall = DepositForCall(user, rootToken, depositData);
+    }
+}
+
+contract FxStateSenderMock {
+    // Call tracking for sendMessageToChild
+    uint256 public sendMessageToChildCallCount;
+    struct SendMessageToChildCall {
+        address receiver;
+        bytes data;
+    }
+    SendMessageToChildCall public lastSendMessageToChildCall;
+
+    function sendMessageToChild(address _receiver, bytes calldata _data) external {
+        sendMessageToChildCallCount++;
+        lastSendMessageToChildCall = SendMessageToChildCall(_receiver, _data);
+    }
+}
+
+contract DepositManagerMock {
+    // Call tracking for depositERC20ForUser
+    uint256 public depositERC20ForUserCallCount;
+    struct DepositERC20ForUserCall {
+        address token;
+        address user;
+        uint256 amount;
+    }
+    DepositERC20ForUserCall public lastDepositERC20ForUserCall;
+
+    function depositERC20ForUser(address token, address user, uint256 amount) external {
+        depositERC20ForUserCallCount++;
+        lastDepositERC20ForUserCall = DepositERC20ForUserCall(token, user, amount);
+    }
+}
+
+contract PolygonRegistryMock {
+    // solhint-disable-next-line no-empty-blocks
+    function erc20Predicate() external returns (address predicate) {}
+}
+
+contract PolygonERC20PredicateMock {
+    // solhint-disable-next-line no-empty-blocks
+    function startExitWithBurntTokens(bytes calldata data) external {}
+}
+
+contract PolygonERC20Mock is ERC20 {
+    // solhint-disable-next-line no-empty-blocks
+    constructor() ERC20("Test ERC20", "TEST") {}
+
+    // solhint-disable-next-line no-empty-blocks
+    function withdraw(uint256 amount) external {}
+}

package/contracts/test/PolygonZkEVMMocks.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import { IPolygonZkEVMBridge } from "../external/interfaces/IPolygonZkEVMBridge.sol";
+
+/**
+ * @notice Mock implementation of Polygon zkEVM's Bridge.
+ * @dev Used for testing PolygonZkEVM_SpokePool functionality.
+ */
+contract MockPolygonZkEVMBridge is IPolygonZkEVMBridge {
+    uint256 public bridgeAssetCallCount;
+
+    event BridgeAssetCalled(
+        uint32 indexed destinationNetwork,
+        address indexed destinationAddress,
+        uint256 amount,
+        address token,
+        bool forceUpdateGlobalExitRoot,
+        bytes permitData
+    );
+
+    struct BridgeAssetCall {
+        uint32 destinationNetwork;
+        address destinationAddress;
+        uint256 amount;
+        address token;
+        bool forceUpdateGlobalExitRoot;
+        bytes permitData;
+        uint256 value;
+    }
+    BridgeAssetCall public lastBridgeAssetCall;
+
+    function bridgeAsset(
+        uint32 destinationNetwork,
+        address destinationAddress,
+        uint256 amount,
+        address token,
+        bool forceUpdateGlobalExitRoot,
+        bytes calldata permitData
+    ) external payable override {
+        bridgeAssetCallCount++;
+        lastBridgeAssetCall = BridgeAssetCall({
+            destinationNetwork: destinationNetwork,
+            destinationAddress: destinationAddress,
+            amount: amount,
+            token: token,
+            forceUpdateGlobalExitRoot: forceUpdateGlobalExitRoot,
+            permitData: permitData,
+            value: msg.value
+        });
+        emit BridgeAssetCalled(
+            destinationNetwork,
+            destinationAddress,
+            amount,
+            token,
+            forceUpdateGlobalExitRoot,
+            permitData
+        );
+    }
+
+    function bridgeMessage(
+        uint32 destinationNetwork,
+        address destinationAddress,
+        bool forceUpdateGlobalExitRoot,
+        bytes calldata metadata
+    ) external payable override {
+        // Not needed for SpokePool tests
+    }
+
+    // Allow receiving ETH
+    receive() external payable {}
+}

package/contracts/test/ScrollMocks.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "@scroll-tech/contracts/libraries/IScrollMessenger.sol";
+
+/**
+ * @title MockScrollMessenger
+ * @notice Mock implementation of IScrollMessenger for testing Scroll_SpokePool
+ */
+contract MockScrollMessenger is IScrollMessenger {
+    address private _xDomainMessageSender;
+
+    /**
+     * @notice Sets the xDomainMessageSender that will be returned by subsequent calls
+     * @param sender The address to set as the cross-domain sender
+     */
+    function setXDomainMessageSender(address sender) external {
+        _xDomainMessageSender = sender;
+    }
+
+    /**
+     * @notice Returns the sender of a cross domain message
+     */
+    function xDomainMessageSender() external view override returns (address) {
+        return _xDomainMessageSender;
+    }
+
+    /**
+     * @notice Impersonates a cross-domain call by setting the xDomainMessageSender
+     *         and calling the target with the provided data
+     * @param target The target contract to call
+     * @param data The calldata to pass to the target
+     */
+    function impersonateCall(address target, bytes memory data) external {
+        _xDomainMessageSender = msg.sender;
+        (bool success, bytes memory returnData) = target.call(data);
+        if (!success) {
+            // Forward the revert reason
+            assembly {
+                revert(add(returnData, 32), mload(returnData))
+            }
+        }
+        _xDomainMessageSender = address(0);
+    }
+
+    /**
+     * @notice Mock implementation - does nothing
+     */
+    function sendMessage(address, uint256, bytes calldata, uint256) external payable override {}
+
+    /**
+     * @notice Mock implementation - does nothing
+     */
+    function sendMessage(address, uint256, bytes calldata, uint256, address) external payable override {}
+}
+
+/**
+ * @title MockScrollL2GatewayRouter
+ * @notice Mock implementation of IL2GatewayRouterExtended for testing Scroll_SpokePool
+ */
+contract MockScrollL2GatewayRouter {
+    address public defaultERC20Gateway;
+    mapping(address => address) public erc20Gateways;
+
+    // Track last withdrawERC20 call for verification
+    address public lastWithdrawToken;
+    address public lastWithdrawTo;
+    uint256 public lastWithdrawAmount;
+    uint256 public lastWithdrawGasLimit;
+
+    event WithdrawERC20Called(address indexed token, address indexed to, uint256 amount, uint256 gasLimit);
+
+    constructor() {
+        defaultERC20Gateway = address(this);
+    }
+
+    /**
+     * @notice Sets the default ERC20 gateway address
+     */
+    function setDefaultERC20Gateway(address gateway) external {
+        defaultERC20Gateway = gateway;
+    }
+
+    /**
+     * @notice Sets a custom gateway for a specific token
+     */
+    function setERC20Gateway(address token, address gateway) external {
+        erc20Gateways[token] = gateway;
+    }
+
+    /**
+     * @notice Returns the gateway for a specific token, or the default gateway if not set
+     */
+    function getERC20Gateway(address token) external view returns (address) {
+        address gateway = erc20Gateways[token];
+        return gateway != address(0) ? gateway : defaultERC20Gateway;
+    }
+
+    /**
+     * @notice Mock withdrawERC20 - records the call parameters
+     */
+    function withdrawERC20(address token, address to, uint256 amount, uint256 gasLimit) external payable {
+        lastWithdrawToken = token;
+        lastWithdrawTo = to;
+        lastWithdrawAmount = amount;
+        lastWithdrawGasLimit = gasLimit;
+        emit WithdrawERC20Called(token, to, amount, gasLimit);
+    }
+}

package/contracts/test/V2MerkleLib.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts-v4/utils/cryptography/MerkleProof.sol";
+import "./interfaces/MockV2SpokePoolInterface.sol";
+
+/**
+ * @notice Library to help with merkle roots, proofs, and claims.
+ */
+library V2MerkleLib {
+    function verifySlowRelayFulfillment(
+        bytes32 root,
+        MockV2SpokePoolInterface.SlowFill memory slowRelayFulfillment,
+        bytes32[] memory proof
+    ) internal pure returns (bool) {
+        return MerkleProof.verify(proof, root, keccak256(abi.encode(slowRelayFulfillment)));
+    }
+}