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

package/contracts/test/AcrossMessageHandlerMock.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "../spoke-pools/SpokePool.sol";
+import "../interfaces/V3SpokePoolInterface.sol";
+
+contract AcrossMessageHandlerMock is AcrossMessageHandler {
+    function handleV3AcrossMessage(
+        address tokenSent,
+        uint256 amount,
+        address relayer,
+        bytes memory message
+    ) external override {}
+}

package/contracts/test/ArbitrumMocks.sol

@@ -0,0 +1,169 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+contract ArbitrumMockErc20GatewayRouter {
+    address public gateway;
+
+    event OutboundTransferCalled(
+        address l1Token,
+        address to,
+        uint256 amount,
+        uint256 maxGas,
+        uint256 gasPriceBid,
+        bytes data
+    );
+
+    event OutboundTransferCustomRefundCalled(
+        address l1Token,
+        address refundTo,
+        address to,
+        uint256 amount,
+        uint256 maxGas,
+        uint256 gasPriceBid,
+        bytes data
+    );
+
+    // Call tracking for test assertions (smock-like behavior)
+    uint256 public outboundTransferCustomRefundCallCount;
+
+    struct OutboundTransferCustomRefundCall {
+        address l1Token;
+        address refundTo;
+        address to;
+        uint256 amount;
+        uint256 maxGas;
+        uint256 gasPriceBid;
+        bytes data;
+    }
+    OutboundTransferCustomRefundCall public lastOutboundTransferCustomRefundCall;
+
+    function setGateway(address _gateway) external {
+        gateway = _gateway;
+    }
+
+    function outboundTransferCustomRefund(
+        address _l1Token,
+        address _refundTo,
+        address _to,
+        uint256 _amount,
+        uint256 _maxGas,
+        uint256 _gasPriceBid,
+        bytes calldata _data
+    ) external payable returns (bytes memory) {
+        outboundTransferCustomRefundCallCount++;
+        lastOutboundTransferCustomRefundCall = OutboundTransferCustomRefundCall(
+            _l1Token,
+            _refundTo,
+            _to,
+            _amount,
+            _maxGas,
+            _gasPriceBid,
+            _data
+        );
+        emit OutboundTransferCustomRefundCalled(_l1Token, _refundTo, _to, _amount, _maxGas, _gasPriceBid, _data);
+        return _data;
+    }
+
+    function outboundTransfer(
+        address _l1Token,
+        address _to,
+        uint256 _amount,
+        uint256 _maxGas,
+        uint256 _gasPriceBid,
+        bytes calldata _data
+    ) external payable returns (bytes memory) {
+        emit OutboundTransferCalled(_l1Token, _to, _amount, _maxGas, _gasPriceBid, _data);
+        return _data;
+    }
+
+    function getGateway(address) external view returns (address) {
+        // Return custom gateway if set, otherwise return self (original behavior)
+        return gateway != address(0) ? gateway : address(this);
+    }
+}
+
+contract Inbox {
+    event RetryableTicketCreated(
+        address destAddr,
+        uint256 l2CallValue,
+        uint256 maxSubmissionCost,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
+        uint256 maxGas,
+        uint256 gasPriceBid,
+        bytes data
+    );
+
+    // Call tracking for test assertions (smock-like behavior)
+    uint256 public createRetryableTicketCallCount;
+
+    struct CreateRetryableTicketCall {
+        address destAddr;
+        uint256 l2CallValue;
+        uint256 maxSubmissionCost;
+        address excessFeeRefundAddress;
+        address callValueRefundAddress;
+        uint256 maxGas;
+        uint256 gasPriceBid;
+        bytes data;
+    }
+    CreateRetryableTicketCall public lastCreateRetryableTicketCall;
+
+    function createRetryableTicket(
+        address _destAddr,
+        uint256 _l2CallValue,
+        uint256 _maxSubmissionCost,
+        address _excessFeeRefundAddress,
+        address _callValueRefundAddress,
+        uint256 _maxGas,
+        uint256 _gasPriceBid,
+        bytes memory _data
+    ) external payable returns (uint256) {
+        createRetryableTicketCallCount++;
+        lastCreateRetryableTicketCall = CreateRetryableTicketCall(
+            _destAddr,
+            _l2CallValue,
+            _maxSubmissionCost,
+            _excessFeeRefundAddress,
+            _callValueRefundAddress,
+            _maxGas,
+            _gasPriceBid,
+            _data
+        );
+        emit RetryableTicketCreated(
+            _destAddr,
+            _l2CallValue,
+            _maxSubmissionCost,
+            _excessFeeRefundAddress,
+            _callValueRefundAddress,
+            _maxGas,
+            _gasPriceBid,
+            _data
+        );
+        return 0;
+    }
+}
+
+contract L2GatewayRouter {
+    mapping(address => address) l2Tokens;
+
+    event OutboundTransfer(address indexed l1Token, address indexed to, uint256 amount);
+
+    function outboundTransfer(
+        address l1Token,
+        address to,
+        uint256 amount,
+        bytes memory
+    ) public payable returns (bytes memory) {
+        emit OutboundTransfer(l1Token, to, amount);
+        return "";
+    }
+
+    function calculateL2TokenAddress(address l1Token) external view returns (address) {
+        return l2Tokens[l1Token];
+    }
+
+    function setL2TokenAddress(address l1Token, address l2Token) external {
+        l2Tokens[l1Token] = l2Token;
+    }
+}

package/contracts/test/ExpandedERC20WithBlacklist.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "../external/uma/core/contracts/common/implementation/ExpandedERC20.sol";
+
+contract ExpandedERC20WithBlacklist is ExpandedERC20 {
+    mapping(address => bool) public isBlackListed;
+
+    constructor(string memory name, string memory symbol, uint8 decimals) ExpandedERC20(name, symbol, decimals) {}
+
+    function setBlacklistStatus(address account, bool status) external {
+        isBlackListed[account] = status;
+    }
+
+    function _beforeTokenTransfer(address from, address to, uint256 amount) internal override {
+        require(!isBlackListed[to], "Recipient is blacklisted");
+        super._beforeTokenTransfer(from, to, amount);
+    }
+}

package/contracts/test/LineaMocks.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import { IMessageService, ITokenBridge } from "../external/interfaces/LineaInterfaces.sol";
+
+/**
+ * @notice Mock implementation of Linea's L2 Message Service.
+ * @dev Used for testing Linea_SpokePool functionality.
+ */
+contract MockL2MessageService is IMessageService {
+    address private _sender;
+    uint256 private _minimumFeeInWei;
+
+    // Track sendMessage calls
+    uint256 public sendMessageCallCount;
+
+    event SendMessageCalled(address indexed to, uint256 fee, bytes calldata_);
+
+    struct SendMessageCall {
+        address to;
+        uint256 fee;
+        bytes calldata_;
+        uint256 value;
+    }
+    SendMessageCall public lastSendMessageCall;
+
+    function setSender(address sender_) external {
+        _sender = sender_;
+    }
+
+    function setMinimumFeeInWei(uint256 fee) external {
+        _minimumFeeInWei = fee;
+    }
+
+    function sendMessage(address _to, uint256 _fee, bytes calldata _calldata) external payable override {
+        sendMessageCallCount++;
+        lastSendMessageCall = SendMessageCall({ to: _to, fee: _fee, calldata_: _calldata, value: msg.value });
+        emit SendMessageCalled(_to, _fee, _calldata);
+    }
+
+    function sender() external view override returns (address) {
+        return _sender;
+    }
+
+    function minimumFeeInWei() external view override returns (uint256) {
+        return _minimumFeeInWei;
+    }
+
+    // Allow receiving ETH
+    receive() external payable {}
+}
+
+/**
+ * @notice Mock implementation of Linea's L2 Token Bridge.
+ * @dev Used for testing Linea_SpokePool functionality.
+ */
+contract MockL2TokenBridge is ITokenBridge {
+    uint256 public bridgeTokenCallCount;
+
+    event BridgeTokenCalled(address indexed token, uint256 amount, address indexed recipient, uint256 value);
+
+    struct BridgeTokenCall {
+        address token;
+        uint256 amount;
+        address recipient;
+        uint256 value;
+    }
+    BridgeTokenCall public lastBridgeTokenCall;
+
+    function bridgeToken(address _token, uint256 _amount, address _recipient) external payable override {
+        bridgeTokenCallCount++;
+        lastBridgeTokenCall = BridgeTokenCall({
+            token: _token,
+            amount: _amount,
+            recipient: _recipient,
+            value: msg.value
+        });
+        emit BridgeTokenCalled(_token, _amount, _recipient, msg.value);
+    }
+
+    // Allow receiving ETH
+    receive() external payable {}
+}

package/contracts/test/MerkleLibTest.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "../libraries/MerkleLib.sol";
+import "../interfaces/HubPoolInterface.sol";
+import "../interfaces/SpokePoolInterface.sol";
+import "./interfaces/MockV2SpokePoolInterface.sol";
+import "./V2MerkleLib.sol";
+
+/**
+ * @notice Contract to test the MerkleLib.
+ */
+contract MerkleLibTest {
+    mapping(uint256 => uint256) public claimedBitMap;
+
+    uint256 public claimedBitMap1D;
+
+    function verifyPoolRebalance(
+        bytes32 root,
+        HubPoolInterface.PoolRebalanceLeaf memory rebalance,
+        bytes32[] memory proof
+    ) public pure returns (bool) {
+        return MerkleLib.verifyPoolRebalance(root, rebalance, proof);
+    }
+
+    function verifyRelayerRefund(
+        bytes32 root,
+        SpokePoolInterface.RelayerRefundLeaf memory refund,
+        bytes32[] memory proof
+    ) public pure returns (bool) {
+        return MerkleLib.verifyRelayerRefund(root, refund, proof);
+    }
+
+    function verifySlowRelayFulfillment(
+        bytes32 root,
+        MockV2SpokePoolInterface.SlowFill memory slowFill,
+        bytes32[] memory proof
+    ) public pure returns (bool) {
+        return V2MerkleLib.verifySlowRelayFulfillment(root, slowFill, proof);
+    }
+
+    function verifyV3SlowRelayFulfillment(
+        bytes32 root,
+        V3SpokePoolInterface.V3SlowFill memory slowFill,
+        bytes32[] memory proof
+    ) public pure returns (bool) {
+        return MerkleLib.verifyV3SlowRelayFulfillment(root, slowFill, proof);
+    }
+
+    function isClaimed(uint256 index) public view returns (bool) {
+        return MerkleLib.isClaimed(claimedBitMap, index);
+    }
+
+    function setClaimed(uint256 index) public {
+        MerkleLib.setClaimed(claimedBitMap, index);
+    }
+
+    function isClaimed1D(uint8 index) public view returns (bool) {
+        return MerkleLib.isClaimed1D(claimedBitMap1D, index);
+    }
+
+    function setClaimed1D(uint8 index) public {
+        claimedBitMap1D = MerkleLib.setClaimed1D(claimedBitMap1D, index);
+    }
+}

package/contracts/test/MockBedrockStandardBridge.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "../spoke-pools/Ovm_SpokePool.sol";
+
+// Provides payable withdrawTo interface introduced on Bedrock
+contract MockBedrockL2StandardBridge is IL2ERC20Bridge {
+    event ERC20WithdrawalInitiated(address indexed l2Token, address indexed to, uint256 amount);
+
+    function withdrawTo(address _l2Token, address _to, uint256 _amount, uint32, bytes calldata) external payable {
+        emit ERC20WithdrawalInitiated(_l2Token, _to, _amount);
+    }
+
+    function bridgeERC20To(
+        address _localToken,
+        address _remoteToken,
+        address _to,
+        uint256 _amount,
+        uint32,
+        bytes calldata
+    ) external {
+        // Check that caller has approved this contract to pull funds, mirroring mainnet's behavior
+        IERC20(_localToken).transferFrom(msg.sender, address(this), _amount);
+        IERC20(_remoteToken).transfer(_to, _amount);
+    }
+}
+
+contract MockBedrockL1StandardBridge {
+    event ETHDepositInitiated(address indexed to, uint256 amount);
+    event ERC20DepositInitiated(address indexed to, address l1Token, address l2Token, uint256 amount);
+
+    // Call counters for test assertions
+    uint256 public depositERC20ToCallCount;
+    uint256 public depositETHToCallCount;
+
+    // Last call parameters (similar to smock's calledWith behavior)
+    struct DepositERC20ToCall {
+        address l1Token;
+        address l2Token;
+        address to;
+        uint256 amount;
+        uint32 l2Gas;
+        bytes data;
+    }
+    DepositERC20ToCall public lastDepositERC20ToCall;
+
+    struct DepositETHToCall {
+        address to;
+        uint256 value;
+        uint32 l2Gas;
+        bytes data;
+    }
+    DepositETHToCall public lastDepositETHToCall;
+
+    function depositERC20To(
+        address l1Token,
+        address l2Token,
+        address to,
+        uint256 amount,
+        uint32 l2Gas,
+        bytes calldata data
+    ) external {
+        depositERC20ToCallCount++;
+        lastDepositERC20ToCall = DepositERC20ToCall(l1Token, l2Token, to, amount, l2Gas, data);
+        IERC20(l1Token).transferFrom(msg.sender, address(this), amount);
+        emit ERC20DepositInitiated(to, l1Token, l2Token, amount);
+    }
+
+    function depositETHTo(address to, uint32 l2Gas, bytes calldata data) external payable {
+        depositETHToCallCount++;
+        lastDepositETHToCall = DepositETHToCall(to, msg.value, l2Gas, data);
+        emit ETHDepositInitiated(to, msg.value);
+    }
+}
+
+contract MockBedrockCrossDomainMessenger {
+    event MessageSent(address indexed target);
+
+    // Call counter for test assertions
+    uint256 public sendMessageCallCount;
+
+    // Last call parameters (similar to smock's calledWith behavior)
+    struct SendMessageCall {
+        address target;
+        bytes message;
+        uint32 l2Gas;
+    }
+    SendMessageCall public lastSendMessageCall;
+
+    address private msgSender;
+
+    function sendMessage(address target, bytes calldata message, uint32 l2Gas) external {
+        sendMessageCallCount++;
+        lastSendMessageCall = SendMessageCall(target, message, l2Gas);
+        emit MessageSent(target);
+    }
+
+    // Impersonates making a call on L2 from L1.
+    function impersonateCall(address target, bytes memory data) external payable returns (bytes memory) {
+        msgSender = msg.sender;
+        (bool success, bytes memory returnData) = target.call{ value: msg.value }(data);
+
+        // Revert if call reverted.
+        if (!success) {
+            assembly {
+                revert(add(32, returnData), mload(returnData))
+            }
+        }
+        return returnData;
+    }
+
+    function xDomainMessageSender() external view returns (address) {
+        return msgSender;
+    }
+}

package/contracts/test/MockBlastUsdYieldManager.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import { USDYieldManager } from "../hub-pool/Blast_DaiRetriever.sol";
+
+contract MockBlastUsdYieldManager is USDYieldManager {
+    bool public shouldFail;
+
+    constructor() {
+        shouldFail = false;
+    }
+
+    function setShouldFail(bool _shouldFail) external {
+        shouldFail = _shouldFail;
+    }
+
+    function claimWithdrawal(uint256 _requestId, uint256 _hintId) external returns (bool success) {
+        success = !shouldFail;
+    }
+}

package/contracts/test/MockCCTP.sol

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "../libraries/CircleCCTPAdapter.sol";
+import { IMessageTransmitter } from "../external/interfaces/CCTPInterfaces.sol";
+
+contract MockCCTPMinter is ITokenMinter {
+    uint256 private _burnLimit = type(uint256).max;
+
+    function setBurnLimit(uint256 limit) external {
+        _burnLimit = limit;
+    }
+
+    function burnLimitsPerMessage(address) external view returns (uint256) {
+        return _burnLimit;
+    }
+}
+
+contract MockCCTPMessenger is ITokenMessenger {
+    ITokenMinter private minter;
+    uint256 public depositForBurnCallCount;
+
+    // Event for vm.expectEmit compatibility
+    event DepositForBurnCalled(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken);
+
+    // Last call parameters (similar to smock's calledWith behavior)
+    struct DepositForBurnCall {
+        uint256 amount;
+        uint32 destinationDomain;
+        bytes32 mintRecipient;
+        address burnToken;
+    }
+    DepositForBurnCall public lastDepositForBurnCall;
+
+    // Store all calls for multi-call verification (smock's atCall behavior)
+    DepositForBurnCall[] public depositForBurnCalls;
+
+    constructor(ITokenMinter _minter) {
+        minter = _minter;
+    }
+
+    function depositForBurn(
+        uint256 _amount,
+        uint32 _destinationDomain,
+        bytes32 _mintRecipient,
+        address _burnToken
+    ) external returns (uint64 _nonce) {
+        depositForBurnCallCount++;
+        lastDepositForBurnCall = DepositForBurnCall(_amount, _destinationDomain, _mintRecipient, _burnToken);
+        depositForBurnCalls.push(lastDepositForBurnCall);
+        emit DepositForBurnCalled(_amount, _destinationDomain, _mintRecipient, _burnToken);
+        return 0;
+    }
+
+    function localMinter() external view returns (ITokenMinter) {
+        return minter;
+    }
+
+    /**
+     * @notice Get a specific depositForBurn call by index (smock's atCall behavior).
+     */
+    function getDepositForBurnCall(
+        uint256 index
+    ) external view returns (uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken) {
+        DepositForBurnCall memory call = depositForBurnCalls[index];
+        return (call.amount, call.destinationDomain, call.mintRecipient, call.burnToken);
+    }
+}
+
+contract MockCCTPMessageTransmitter is IMessageTransmitter {
+    uint256 public sendMessageCallCount;
+
+    // Event for vm.expectEmit compatibility
+    event SendMessageCalled(uint32 destinationDomain, bytes32 recipient, bytes messageBody);
+
+    // Last call parameters (similar to smock's calledWith behavior)
+    struct SendMessageCall {
+        uint32 destinationDomain;
+        bytes32 recipient;
+        bytes messageBody;
+    }
+    SendMessageCall public lastSendMessageCall;
+
+    function sendMessage(
+        uint32 _destinationDomain,
+        bytes32 _recipient,
+        bytes calldata _messageBody
+    ) external returns (uint64) {
+        sendMessageCallCount++;
+        lastSendMessageCall = SendMessageCall(_destinationDomain, _recipient, _messageBody);
+        emit SendMessageCalled(_destinationDomain, _recipient, _messageBody);
+        return 0;
+    }
+}
+
+/**
+ * @notice Mock CCTP V2 TokenMessenger that implements the V2 depositForBurn interface.
+ * @dev V2 has a different depositForBurn signature with additional parameters (destinationCaller, maxFee, minFinalityThreshold).
+ *      The V2 contract is detected by the CircleCCTPAdapter via the feeRecipient() function.
+ */
+contract MockCCTPMessengerV2 {
+    ITokenMinter private minter;
+    address private _feeRecipient;
+    uint256 public depositForBurnCallCount;
+
+    // Event for vm.expectEmit compatibility
+    event DepositForBurnCalled(
+        uint256 amount,
+        uint32 destinationDomain,
+        bytes32 mintRecipient,
+        address burnToken,
+        bytes32 destinationCaller,
+        uint256 maxFee,
+        uint32 minFinalityThreshold
+    );
+
+    // Last call parameters (similar to smock's calledWith behavior)
+    struct DepositForBurnV2Call {
+        uint256 amount;
+        uint32 destinationDomain;
+        bytes32 mintRecipient;
+        address burnToken;
+        bytes32 destinationCaller;
+        uint256 maxFee;
+        uint32 minFinalityThreshold;
+    }
+    DepositForBurnV2Call public lastDepositForBurnCall;
+
+    // Store all calls for multi-call verification
+    DepositForBurnV2Call[] public depositForBurnCalls;
+
+    constructor(ITokenMinter _minter, address feeRecipient_) {
+        minter = _minter;
+        _feeRecipient = feeRecipient_;
+    }
+
+    /**
+     * @notice CCTP V2 depositForBurn function.
+     */
+    function depositForBurn(
+        uint256 _amount,
+        uint32 _destinationDomain,
+        bytes32 _mintRecipient,
+        address _burnToken,
+        bytes32 _destinationCaller,
+        uint256 _maxFee,
+        uint32 _minFinalityThreshold
+    ) external {
+        depositForBurnCallCount++;
+        lastDepositForBurnCall = DepositForBurnV2Call(
+            _amount,
+            _destinationDomain,
+            _mintRecipient,
+            _burnToken,
+            _destinationCaller,
+            _maxFee,
+            _minFinalityThreshold
+        );
+        depositForBurnCalls.push(lastDepositForBurnCall);
+        emit DepositForBurnCalled(
+            _amount,
+            _destinationDomain,
+            _mintRecipient,
+            _burnToken,
+            _destinationCaller,
+            _maxFee,
+            _minFinalityThreshold
+        );
+    }
+
+    /**
+     * @notice Returns the fee recipient address - used by CircleCCTPAdapter to detect V2.
+     * @dev Must return a non-zero address for V2 detection to work.
+     */
+    function feeRecipient() external view returns (address) {
+        return _feeRecipient;
+    }
+
+    function localMinter() external view returns (ITokenMinter) {
+        return minter;
+    }
+
+    /**
+     * @notice Get a specific depositForBurn call by index.
+     */
+    function getDepositForBurnCall(
+        uint256 index
+    )
+        external
+        view
+        returns (
+            uint256 amount,
+            uint32 destinationDomain,
+            bytes32 mintRecipient,
+            address burnToken,
+            bytes32 destinationCaller,
+            uint256 maxFee,
+            uint32 minFinalityThreshold
+        )
+    {
+        DepositForBurnV2Call memory call = depositForBurnCalls[index];
+        return (
+            call.amount,
+            call.destinationDomain,
+            call.mintRecipient,
+            call.burnToken,
+            call.destinationCaller,
+            call.maxFee,
+            call.minFinalityThreshold
+        );
+    }
+}