From 0240714b0c7bcaca40574c430239ea3e1b7927f7 Mon Sep 17 00:00:00 2001 From: parodime Date: Fri, 27 Sep 2024 19:47:50 -0400 Subject: [PATCH] status/proof mapping packing [SLT-186] (#3173) * status/proof mapping packing [SLT-186] * fix BridgeProofs def to use struct * WIP - evaluating ProofDetail struct approach * fix: overflow in parity tests * refactor BridgeTxDetails w/o addtl ProofDetail struct * master merge conflicts * restore bad lint warning * switch to fully qualified bridgeTxDetails instead of storage refs * rearrange for lint (120 char line) * test fixes * code cleanup --------- Co-authored-by: ChiTimesChi <88190723+ChiTimesChi@users.noreply.github.com> Co-authored-by: jw --- .../contracts-rfq/contracts/FastBridgeV2.sol | 85 ++++++++++--------- .../contracts/interfaces/IFastBridgeV2.sol | 26 ++++++ packages/contracts-rfq/test/FastBridge.t.sol | 34 ++++---- .../test/FastBridgeV2.GasBench.Src.t.sol | 47 +++++----- .../test/FastBridgeV2.Parity.t.sol | 15 ++++ .../contracts-rfq/test/FastBridgeV2.Src.t.sol | 57 +++++++------ .../contracts-rfq/test/FastBridgeV2.t.sol | 2 + 7 files changed, 159 insertions(+), 107 deletions(-) diff --git a/packages/contracts-rfq/contracts/FastBridgeV2.sol b/packages/contracts-rfq/contracts/FastBridgeV2.sol index a92c0746f0..e649ab0ec0 100644 --- a/packages/contracts-rfq/contracts/FastBridgeV2.sol +++ b/packages/contracts-rfq/contracts/FastBridgeV2.sol @@ -24,18 +24,8 @@ contract FastBridgeV2 is Admin, IFastBridgeV2, IFastBridgeV2Errors { /// @notice Minimum deadline period to relay a requested bridge transaction uint256 public constant MIN_DEADLINE_PERIOD = 30 minutes; - enum BridgeStatus { - NULL, // doesn't exist yet - REQUESTED, - RELAYER_PROVED, - RELAYER_CLAIMED, - REFUNDED - } - /// @notice Status of the bridge tx on origin chain - mapping(bytes32 => BridgeStatus) public bridgeStatuses; - /// @notice Proof of relayed bridge tx on origin chain - mapping(bytes32 => BridgeProof) public bridgeProofs; + mapping(bytes32 => BridgeTxDetails) public bridgeTxDetails; /// @notice Relay details on destination chain mapping(bytes32 => BridgeRelay) public bridgeRelayDetails; @@ -44,6 +34,15 @@ contract FastBridgeV2 is Admin, IFastBridgeV2, IFastBridgeV2Errors { // @dev the block the contract was deployed at uint256 public immutable deployBlock; + function bridgeStatuses(bytes32 transactionId) public view returns (BridgeStatus status) { + return bridgeTxDetails[transactionId].status; + } + + function bridgeProofs(bytes32 transactionId) public view returns (uint96 timestamp, address relayer) { + timestamp = bridgeTxDetails[transactionId].proofBlockTimestamp; + relayer = bridgeTxDetails[transactionId].proofRelayer; + } + constructor(address _owner) Admin(_owner) { deployBlock = block.number; } @@ -111,7 +110,7 @@ contract FastBridgeV2 is Admin, IFastBridgeV2, IFastBridgeV2Errors { }) ); bytes32 transactionId = keccak256(request); - bridgeStatuses[transactionId] = BridgeStatus.REQUESTED; + bridgeTxDetails[transactionId].status = BridgeStatus.REQUESTED; emit BridgeRequested( transactionId, @@ -194,32 +193,32 @@ contract FastBridgeV2 is Admin, IFastBridgeV2, IFastBridgeV2Errors { /// @inheritdoc IFastBridgeV2 function prove(bytes32 transactionId, bytes32 destTxHash, address relayer) public onlyRole(RELAYER_ROLE) { // update bridge tx status given proof provided - if (bridgeStatuses[transactionId] != BridgeStatus.REQUESTED) revert StatusIncorrect(); - bridgeStatuses[transactionId] = BridgeStatus.RELAYER_PROVED; - // overflow ok - bridgeProofs[transactionId] = BridgeProof({timestamp: uint96(block.timestamp), relayer: relayer}); + if (bridgeTxDetails[transactionId].status != BridgeStatus.REQUESTED) revert StatusIncorrect(); + bridgeTxDetails[transactionId].status = BridgeStatus.RELAYER_PROVED; + bridgeTxDetails[transactionId].proofBlockTimestamp = uint40(block.timestamp); + bridgeTxDetails[transactionId].proofBlockNumber = uint48(block.number); + bridgeTxDetails[transactionId].proofRelayer = relayer; emit BridgeProofProvided(transactionId, relayer, destTxHash); } /// @notice Calculates time since proof submitted - /// @dev proof.timestamp stores casted uint96(block.timestamp) block timestamps for gas optimization - /// _timeSince(proof) can accomodate rollover case when block.timestamp > type(uint96).max but - /// proof.timestamp < type(uint96).max via unchecked statement - /// @param proof The bridge proof + /// @dev proof.timestamp stores casted uint40(block.timestamp) block timestamps for gas optimization + /// _timeSince(proof) can accomodate rollover case when block.timestamp > type(uint40).max but + /// proof.timestamp < type(uint40).max via unchecked statement + /// @param proofBlockTimestamp The bridge proof block timestamp /// @return delta Time delta since proof submitted - function _timeSince(BridgeProof memory proof) internal view returns (uint256 delta) { + function _timeSince(uint40 proofBlockTimestamp) internal view returns (uint256 delta) { unchecked { - delta = uint96(block.timestamp) - proof.timestamp; + delta = uint40(block.timestamp) - proofBlockTimestamp; } } /// @inheritdoc IFastBridge function canClaim(bytes32 transactionId, address relayer) external view returns (bool) { - if (bridgeStatuses[transactionId] != BridgeStatus.RELAYER_PROVED) revert StatusIncorrect(); - BridgeProof memory proof = bridgeProofs[transactionId]; - if (proof.relayer != relayer) revert SenderIncorrect(); - return _timeSince(proof) > DISPUTE_PERIOD; + if (bridgeTxDetails[transactionId].status != BridgeStatus.RELAYER_PROVED) revert StatusIncorrect(); + if (bridgeTxDetails[transactionId].proofRelayer != relayer) revert SenderIncorrect(); + return _timeSince(bridgeTxDetails[transactionId].proofBlockTimestamp) > DISPUTE_PERIOD; } /// @inheritdoc IFastBridgeV2 @@ -233,20 +232,20 @@ contract FastBridgeV2 is Admin, IFastBridgeV2, IFastBridgeV2Errors { BridgeTransaction memory transaction = getBridgeTransaction(request); // update bridge tx status if able to claim origin collateral - if (bridgeStatuses[transactionId] != BridgeStatus.RELAYER_PROVED) revert StatusIncorrect(); - - BridgeProof memory proof = bridgeProofs[transactionId]; + if (bridgeTxDetails[transactionId].status != BridgeStatus.RELAYER_PROVED) revert StatusIncorrect(); // if "to" is zero addr, permissionlessly send funds to proven relayer if (to == address(0)) { - to = proof.relayer; - } else if (proof.relayer != msg.sender) { + to = bridgeTxDetails[transactionId].proofRelayer; + } else if (bridgeTxDetails[transactionId].proofRelayer != msg.sender) { revert SenderIncorrect(); } - if (_timeSince(proof) <= DISPUTE_PERIOD) revert DisputePeriodNotPassed(); + if (_timeSince(bridgeTxDetails[transactionId].proofBlockTimestamp) <= DISPUTE_PERIOD) { + revert DisputePeriodNotPassed(); + } - bridgeStatuses[transactionId] = BridgeStatus.RELAYER_CLAIMED; + bridgeTxDetails[transactionId].status = BridgeStatus.RELAYER_CLAIMED; // update protocol fees if origin fee amount exists if (transaction.originFeeAmount > 0) protocolFees[transaction.originToken] += transaction.originFeeAmount; @@ -256,17 +255,21 @@ contract FastBridgeV2 is Admin, IFastBridgeV2, IFastBridgeV2Errors { uint256 amount = transaction.originAmount; token.universalTransfer(to, amount); - emit BridgeDepositClaimed(transactionId, proof.relayer, to, token, amount); + emit BridgeDepositClaimed(transactionId, bridgeTxDetails[transactionId].proofRelayer, to, token, amount); } /// @inheritdoc IFastBridge function dispute(bytes32 transactionId) external onlyRole(GUARD_ROLE) { - if (bridgeStatuses[transactionId] != BridgeStatus.RELAYER_PROVED) revert StatusIncorrect(); - if (_timeSince(bridgeProofs[transactionId]) > DISPUTE_PERIOD) revert DisputePeriodPassed(); + if (bridgeTxDetails[transactionId].status != BridgeStatus.RELAYER_PROVED) revert StatusIncorrect(); + if (_timeSince(bridgeTxDetails[transactionId].proofBlockTimestamp) > DISPUTE_PERIOD) { + revert DisputePeriodPassed(); + } // @dev relayer gets slashed effectively if dest relay has gone thru - bridgeStatuses[transactionId] = BridgeStatus.REQUESTED; - delete bridgeProofs[transactionId]; + bridgeTxDetails[transactionId].status = BridgeStatus.REQUESTED; + bridgeTxDetails[transactionId].proofRelayer = address(0); + bridgeTxDetails[transactionId].proofBlockTimestamp = 0; + bridgeTxDetails[transactionId].proofBlockNumber = 0; emit BridgeProofDisputed(transactionId, msg.sender); } @@ -275,10 +278,10 @@ contract FastBridgeV2 is Admin, IFastBridgeV2, IFastBridgeV2Errors { function refund(bytes memory request) external { bytes32 transactionId = keccak256(request); - if (bridgeStatuses[transactionId] != BridgeStatus.REQUESTED) revert StatusIncorrect(); - BridgeTransaction memory transaction = getBridgeTransaction(request); + if (bridgeTxDetails[transactionId].status != BridgeStatus.REQUESTED) revert StatusIncorrect(); + if (hasRole(REFUNDER_ROLE, msg.sender)) { // Refunder can refund if deadline has passed if (block.timestamp <= transaction.deadline) revert DeadlineNotExceeded(); @@ -288,7 +291,7 @@ contract FastBridgeV2 is Admin, IFastBridgeV2, IFastBridgeV2Errors { } // if all checks passed, set to REFUNDED status - bridgeStatuses[transactionId] = BridgeStatus.REFUNDED; + bridgeTxDetails[transactionId].status = BridgeStatus.REFUNDED; // transfer origin collateral back to original sender address to = transaction.originSender; diff --git a/packages/contracts-rfq/contracts/interfaces/IFastBridgeV2.sol b/packages/contracts-rfq/contracts/interfaces/IFastBridgeV2.sol index cec58048f8..35c6173224 100644 --- a/packages/contracts-rfq/contracts/interfaces/IFastBridgeV2.sol +++ b/packages/contracts-rfq/contracts/interfaces/IFastBridgeV2.sol @@ -4,6 +4,21 @@ pragma solidity ^0.8.20; import {IFastBridge} from "./IFastBridge.sol"; interface IFastBridgeV2 is IFastBridge { + enum BridgeStatus { + NULL, // doesn't exist yet + REQUESTED, + RELAYER_PROVED, + RELAYER_CLAIMED, + REFUNDED + } + + struct BridgeTxDetails { + BridgeStatus status; + uint40 proofBlockTimestamp; + uint48 proofBlockNumber; + address proofRelayer; + } + struct BridgeRelay { uint48 blockNumber; uint48 blockTimestamp; @@ -29,4 +44,15 @@ interface IFastBridgeV2 is IFastBridge { /// @param transactionId The ID of the transaction to check /// @return True if the transaction has been relayed, false otherwise function bridgeRelays(bytes32 transactionId) external view returns (bool); + + /// @notice Returns the status of a bridge transaction + /// @param transactionId The ID of the bridge transaction + /// @return BridgeStatus Status of the bridge transaction + function bridgeStatuses(bytes32 transactionId) external view returns (BridgeStatus); + + /// @notice Returns the timestamp and relayer of a bridge proof + /// @param transactionId The ID of the bridge transaction + /// @return timestamp The timestamp of the bridge proof + /// @return relayer The relayer address of the bridge proof + function bridgeProofs(bytes32 transactionId) external view returns (uint96 timestamp, address relayer); } diff --git a/packages/contracts-rfq/test/FastBridge.t.sol b/packages/contracts-rfq/test/FastBridge.t.sol index 2d90779c96..a571f50b40 100644 --- a/packages/contracts-rfq/test/FastBridge.t.sol +++ b/packages/contracts-rfq/test/FastBridge.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.13; +// solhint-disable import "forge-std/Test.sol"; import "forge-std/console2.sol"; @@ -51,6 +52,19 @@ contract FastBridgeTest is Test { ethUSDC.mint(dstUser, 100 * 10 ** 6); } + function assertCorrectProof( + bytes32 transactionId, + uint256 expectedTimestamp, + address expectedRelayer + ) + internal + virtual + { + (uint96 timestamp, address relayer) = fastBridge.bridgeProofs(transactionId); + assertEq(timestamp, uint96(expectedTimestamp)); + assertEq(relayer, expectedRelayer); + } + function _getBridgeRequestAndId( uint256 chainId, uint256 currentNonce, @@ -1349,9 +1363,7 @@ contract FastBridgeTest is Test { fastBridge.prove(request, fakeTxnHash); // We check if the bridge transaction proof timestamp is set to the timestamp at which the proof was provided - (uint96 _timestamp, address _oldRelayer) = fastBridge.bridgeProofs(transactionId); - assertEq(_timestamp, uint96(block.timestamp)); - assertEq(_oldRelayer, relayer); + assertCorrectProof(transactionId, block.timestamp, relayer); // We check if the bridge status is RELAYER_PROVED assertEq(uint256(fastBridge.bridgeStatuses(transactionId)), uint256(FastBridge.BridgeStatus.RELAYER_PROVED)); @@ -1383,9 +1395,7 @@ contract FastBridgeTest is Test { fastBridge.prove(request, fakeTxnHash); // We check if the bridge transaction proof timestamp is set to the timestamp at which the proof was provided - (uint96 _timestamp, address _oldRelayer) = fastBridge.bridgeProofs(transactionId); - assertEq(_timestamp, uint96(block.timestamp)); - assertEq(_oldRelayer, relayer); + assertCorrectProof(transactionId, block.timestamp, relayer); // We stop a prank to contain within test vm.stopPrank(); @@ -1414,9 +1424,7 @@ contract FastBridgeTest is Test { fastBridge.prove(request, fakeTxnHash); // We check if the bridge transaction proof timestamp is set to the timestamp at which the proof was provided - (uint96 _timestamp, address _oldRelayer) = fastBridge.bridgeProofs(transactionId); - assertEq(_timestamp, uint96(block.timestamp)); - assertEq(_oldRelayer, relayer); + assertCorrectProof(transactionId, block.timestamp, relayer); // We stop a prank to contain within test vm.stopPrank(); @@ -1713,10 +1721,8 @@ contract FastBridgeTest is Test { fastBridge.dispute(transactionId); // check status and proofs updated - (uint96 _timestamp, address _oldRelayer) = fastBridge.bridgeProofs(transactionId); assertEq(uint256(fastBridge.bridgeStatuses(transactionId)), uint256(FastBridge.BridgeStatus.REQUESTED)); - assertEq(_timestamp, 0); - assertEq(_oldRelayer, address(0)); + assertCorrectProof(transactionId, 0, address(0)); // We stop a prank to contain within test vm.stopPrank(); @@ -1739,10 +1745,8 @@ contract FastBridgeTest is Test { fastBridge.dispute(transactionId); // check status and proofs updated - (uint96 _timestamp, address _oldRelayer) = fastBridge.bridgeProofs(transactionId); assertEq(uint256(fastBridge.bridgeStatuses(transactionId)), uint256(FastBridge.BridgeStatus.REQUESTED)); - assertEq(_timestamp, 0); - assertEq(_oldRelayer, address(0)); + assertCorrectProof(transactionId, 0, address(0)); // We stop a prank to contain within test vm.stopPrank(); diff --git a/packages/contracts-rfq/test/FastBridgeV2.GasBench.Src.t.sol b/packages/contracts-rfq/test/FastBridgeV2.GasBench.Src.t.sol index 424fdd5e2e..42c0cbf7e2 100644 --- a/packages/contracts-rfq/test/FastBridgeV2.GasBench.Src.t.sol +++ b/packages/contracts-rfq/test/FastBridgeV2.GasBench.Src.t.sol @@ -1,7 +1,8 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; -import {FastBridgeV2, FastBridgeV2SrcBaseTest, IFastBridge} from "./FastBridgeV2.Src.Base.t.sol"; +import {FastBridgeV2SrcBaseTest, IFastBridge} from "./FastBridgeV2.Src.Base.t.sol"; +import {IFastBridgeV2} from "../contracts/interfaces/IFastBridgeV2.sol"; // solhint-disable func-name-mixedcase, ordering /// @notice This test is used to estimate the gas cost of FastBridgeV2 source chain functions. @@ -63,12 +64,12 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { prove({caller: relayerA, bridgeTx: provenTokenTx, destTxHash: hex"01"}); prove({caller: relayerB, transactionId: getTxId(provenEthTx), destTxHash: hex"02", relayer: relayerA}); // Status checks - assertEq(fastBridge.bridgeStatuses(getTxId(bridgedTokenTx)), FastBridgeV2.BridgeStatus.REQUESTED); - assertEq(fastBridge.bridgeStatuses(getTxId(bridgedEthTx)), FastBridgeV2.BridgeStatus.REQUESTED); - assertEq(fastBridge.bridgeStatuses(getTxId(provenTokenTx)), FastBridgeV2.BridgeStatus.RELAYER_PROVED); - assertEq(fastBridge.bridgeStatuses(getTxId(provenEthTx)), FastBridgeV2.BridgeStatus.RELAYER_PROVED); - assertEq(fastBridge.bridgeStatuses(getTxId(tokenTx)), FastBridgeV2.BridgeStatus.NULL); - assertEq(fastBridge.bridgeStatuses(getTxId(ethTx)), FastBridgeV2.BridgeStatus.NULL); + assertEq(fastBridge.bridgeStatuses(getTxId(bridgedTokenTx)), IFastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(getTxId(bridgedEthTx)), IFastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(getTxId(provenTokenTx)), IFastBridgeV2.BridgeStatus.RELAYER_PROVED); + assertEq(fastBridge.bridgeStatuses(getTxId(provenEthTx)), IFastBridgeV2.BridgeStatus.RELAYER_PROVED); + assertEq(fastBridge.bridgeStatuses(getTxId(tokenTx)), IFastBridgeV2.BridgeStatus.NULL); + assertEq(fastBridge.bridgeStatuses(getTxId(ethTx)), IFastBridgeV2.BridgeStatus.NULL); } function skipBlocksExactly(uint256 blocks) public { @@ -86,7 +87,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_bridge_token() public { bridge({caller: userA, msgValue: 0, params: tokenParams}); - assertEq(fastBridge.bridgeStatuses(getTxId(tokenTx)), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(getTxId(tokenTx)), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(srcToken.balanceOf(userA), initialUserBalanceToken - tokenParams.originAmount); assertEq(srcToken.balanceOf(address(fastBridge)), initialFastBridgeBalanceToken + tokenParams.originAmount); } @@ -94,7 +95,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_prove_token() public { bytes32 txId = getTxId(bridgedTokenTx); prove({caller: relayerA, bridgeTx: bridgedTokenTx, destTxHash: hex"03"}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_PROVED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_PROVED); (uint96 timestamp, address relayer) = fastBridge.bridgeProofs(txId); assertEq(timestamp, block.timestamp); assertEq(relayer, relayerA); @@ -104,7 +105,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_proveWithAddress_token() public { bytes32 txId = getTxId(bridgedTokenTx); prove({caller: relayerB, transactionId: txId, destTxHash: hex"03", relayer: relayerA}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_PROVED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_PROVED); (uint96 timestamp, address relayer) = fastBridge.bridgeProofs(txId); assertEq(timestamp, block.timestamp); assertEq(relayer, relayerA); @@ -113,7 +114,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_claim_token() public { skipTimeAtLeast({time: CLAIM_DELAY + 1}); claim({caller: relayerA, bridgeTx: provenTokenTx}); - assertEq(fastBridge.bridgeStatuses(getTxId(provenTokenTx)), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(getTxId(provenTokenTx)), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); assertEq(srcToken.balanceOf(relayerA), INITIAL_RELAYER_BALANCE + tokenTx.originAmount); assertEq(srcToken.balanceOf(address(fastBridge)), initialFastBridgeBalanceToken - tokenTx.originAmount); } @@ -121,7 +122,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_claimWithAddress_token() public { skipTimeAtLeast({time: CLAIM_DELAY + 1}); claim({caller: relayerA, bridgeTx: provenTokenTx, to: relayerB}); - assertEq(fastBridge.bridgeStatuses(getTxId(provenTokenTx)), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(getTxId(provenTokenTx)), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); assertEq(srcToken.balanceOf(relayerB), INITIAL_RELAYER_BALANCE + tokenTx.originAmount); assertEq(srcToken.balanceOf(address(fastBridge)), initialFastBridgeBalanceToken - tokenTx.originAmount); } @@ -129,7 +130,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_dispute_token() public { bytes32 txId = getTxId(provenTokenTx); dispute({caller: guard, txId: txId}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(srcToken.balanceOf(address(fastBridge)), initialFastBridgeBalanceToken); } @@ -137,7 +138,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { bytes32 txId = getTxId(bridgedTokenTx); skipTimeAtLeast({time: DEADLINE}); refund({caller: refunder, bridgeTx: bridgedTokenTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(srcToken.balanceOf(userA), initialUserBalanceToken + tokenParams.originAmount); assertEq(srcToken.balanceOf(address(fastBridge)), initialFastBridgeBalanceToken - tokenParams.originAmount); } @@ -146,7 +147,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { bytes32 txId = getTxId(bridgedTokenTx); skipTimeAtLeast({time: DEADLINE + PERMISSIONLESS_REFUND_DELAY}); refund({caller: userB, bridgeTx: bridgedTokenTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(srcToken.balanceOf(userA), initialUserBalanceToken + tokenParams.originAmount); assertEq(srcToken.balanceOf(address(fastBridge)), initialFastBridgeBalanceToken - tokenParams.originAmount); } @@ -155,7 +156,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_bridge_eth() public { bridge({caller: userA, msgValue: ethParams.originAmount, params: ethParams}); - assertEq(fastBridge.bridgeStatuses(getTxId(ethTx)), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(getTxId(ethTx)), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(userA.balance, initialUserBalanceEth - ethParams.originAmount); assertEq(address(fastBridge).balance, initialFastBridgeBalanceEth + ethParams.originAmount); } @@ -163,7 +164,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_prove_eth() public { bytes32 txId = getTxId(bridgedEthTx); prove({caller: relayerA, bridgeTx: bridgedEthTx, destTxHash: hex"03"}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_PROVED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_PROVED); (uint96 timestamp, address relayer) = fastBridge.bridgeProofs(txId); assertEq(timestamp, block.timestamp); assertEq(relayer, relayerA); @@ -173,7 +174,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_proveWithAddress_eth() public { bytes32 txId = getTxId(bridgedEthTx); prove({caller: relayerB, transactionId: txId, destTxHash: hex"03", relayer: relayerA}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_PROVED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_PROVED); (uint96 timestamp, address relayer) = fastBridge.bridgeProofs(txId); assertEq(timestamp, block.timestamp); assertEq(relayer, relayerA); @@ -183,7 +184,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_claim_eth() public { skipTimeAtLeast({time: CLAIM_DELAY + 1}); claim({caller: relayerA, bridgeTx: provenEthTx}); - assertEq(fastBridge.bridgeStatuses(getTxId(provenEthTx)), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(getTxId(provenEthTx)), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); assertEq(relayerA.balance, INITIAL_RELAYER_BALANCE + ethTx.originAmount); assertEq(address(fastBridge).balance, initialFastBridgeBalanceEth - ethTx.originAmount); } @@ -191,7 +192,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_claimWithAddress_eth() public { skipTimeAtLeast({time: CLAIM_DELAY + 1}); claim({caller: relayerA, bridgeTx: provenEthTx, to: relayerB}); - assertEq(fastBridge.bridgeStatuses(getTxId(provenEthTx)), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(getTxId(provenEthTx)), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); assertEq(relayerB.balance, INITIAL_RELAYER_BALANCE + ethTx.originAmount); assertEq(address(fastBridge).balance, initialFastBridgeBalanceEth - ethTx.originAmount); } @@ -199,7 +200,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { function test_dispute_eth() public { bytes32 txId = getTxId(provenEthTx); dispute({caller: guard, txId: txId}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(address(fastBridge).balance, initialFastBridgeBalanceEth); } @@ -207,7 +208,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { bytes32 txId = getTxId(bridgedEthTx); skipTimeAtLeast({time: DEADLINE}); refund({caller: refunder, bridgeTx: bridgedEthTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(userA.balance, initialUserBalanceEth + ethParams.originAmount); assertEq(address(fastBridge).balance, initialFastBridgeBalanceEth - ethParams.originAmount); } @@ -216,7 +217,7 @@ contract FastBridgeV2GasBenchmarkSrcTest is FastBridgeV2SrcBaseTest { bytes32 txId = getTxId(bridgedEthTx); skipTimeAtLeast({time: DEADLINE + PERMISSIONLESS_REFUND_DELAY}); refund({caller: userB, bridgeTx: bridgedEthTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(userA.balance, initialUserBalanceEth + ethParams.originAmount); assertEq(address(fastBridge).balance, initialFastBridgeBalanceEth - ethParams.originAmount); } diff --git a/packages/contracts-rfq/test/FastBridgeV2.Parity.t.sol b/packages/contracts-rfq/test/FastBridgeV2.Parity.t.sol index dd4b3a4fa2..9990c371d5 100644 --- a/packages/contracts-rfq/test/FastBridgeV2.Parity.t.sol +++ b/packages/contracts-rfq/test/FastBridgeV2.Parity.t.sol @@ -14,6 +14,21 @@ contract FastBridgeV2ParityTest is FastBridgeTest, IFastBridgeV2Errors { return deployCode({what: "FastBridgeV2", args: abi.encode(owner)}); } + /// @notice We use uint40 for the timestamps in FastBridgeV2 + function assertCorrectProof( + bytes32 transactionId, + uint256 expectedTimestamp, + address expectedRelayer + ) + internal + virtual + override + { + (uint96 timestamp, address relayer) = fastBridge.bridgeProofs(transactionId); + assertEq(timestamp, uint40(expectedTimestamp)); + assertEq(relayer, expectedRelayer); + } + /// @notice Relay function is no longer permissioned, so we skip this test function test_failedRelayNotRelayer() public virtual override { vm.skip(true); diff --git a/packages/contracts-rfq/test/FastBridgeV2.Src.t.sol b/packages/contracts-rfq/test/FastBridgeV2.Src.t.sol index 593722ab1d..e0eb6d6ca3 100644 --- a/packages/contracts-rfq/test/FastBridgeV2.Src.t.sol +++ b/packages/contracts-rfq/test/FastBridgeV2.Src.t.sol @@ -1,7 +1,8 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; -import {FastBridgeV2, FastBridgeV2SrcBaseTest, IFastBridge} from "./FastBridgeV2.Src.Base.t.sol"; +import {FastBridgeV2SrcBaseTest} from "./FastBridgeV2.Src.Base.t.sol"; +import {IFastBridge, IFastBridgeV2} from "./FastBridgeV2.t.sol"; // solhint-disable func-name-mixedcase, ordering contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { @@ -95,7 +96,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { bytes32 txId = getTxId(tokenTx); expectBridgeRequested(tokenTx, txId); bridge({caller: userA, msgValue: 0, params: tokenParams}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); checkTokenBalancesAfterBridge(userA); } @@ -103,7 +104,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { bytes32 txId = getTxId(tokenTx); expectBridgeRequested(tokenTx, txId); bridge({caller: userB, msgValue: 0, params: tokenParams}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(srcToken.balanceOf(userA), LEFTOVER_BALANCE + tokenParams.originAmount); checkTokenBalancesAfterBridge(userB); } @@ -120,7 +121,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { bytes32 txId = getTxId(ethTx); expectBridgeRequested(ethTx, txId); bridge({caller: userA, msgValue: ethParams.originAmount, params: ethParams}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); checkEthBalancesAfterBridge(userA); } @@ -130,7 +131,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { bytes32 txId = getTxId(ethTx); expectBridgeRequested(ethTx, txId); bridge({caller: userB, msgValue: ethParams.originAmount, params: ethParams}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(userA.balance, LEFTOVER_BALANCE + ethParams.originAmount); checkEthBalancesAfterBridge(userB); } @@ -145,7 +146,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { bytes32 txId = getTxId(ethTx); expectBridgeRequested(ethTx, txId); bridge({caller: userB, msgValue: ethParams.originAmount, params: ethParams}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); checkEthBalancesAfterBridge(userB); } @@ -417,7 +418,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { assertTrue(fastBridge.canClaim(txId, relayerA)); expectBridgeDepositClaimed({bridgeTx: tokenTx, txId: txId, relayer: relayerA, to: relayerA}); claim({caller: relayerA, bridgeTx: tokenTx, to: relayerA}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); checkTokenBalancesAfterClaim(relayerA); } @@ -429,7 +430,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY + 1); expectBridgeDepositClaimed({bridgeTx: tokenTx, txId: txId, relayer: relayerA, to: relayerA}); claim({caller: caller, bridgeTx: tokenTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); checkTokenBalancesAfterClaim(relayerA); } @@ -441,7 +442,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY + 1); expectBridgeDepositClaimed({bridgeTx: tokenTx, txId: txId, relayer: relayerA, to: relayerA}); claim({caller: caller, bridgeTx: tokenTx, to: address(0)}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); checkTokenBalancesAfterClaim(relayerA); } @@ -452,7 +453,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY + 1); expectBridgeDepositClaimed({bridgeTx: tokenTx, txId: txId, relayer: relayerA, to: claimTo}); claim({caller: relayerA, bridgeTx: tokenTx, to: claimTo}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); assertEq(srcToken.balanceOf(relayerA), 0); checkTokenBalancesAfterClaim(claimTo); } @@ -464,7 +465,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY + 30 days); expectBridgeDepositClaimed({bridgeTx: tokenTx, txId: txId, relayer: relayerA, to: relayerA}); claim({caller: relayerA, bridgeTx: tokenTx, to: relayerA}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); checkTokenBalancesAfterClaim(relayerA); } @@ -483,7 +484,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { assertTrue(fastBridge.canClaim(txId, relayerA)); expectBridgeDepositClaimed({bridgeTx: ethTx, txId: txId, relayer: relayerA, to: relayerA}); claim({caller: relayerA, bridgeTx: ethTx, to: relayerA}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); checkEthBalancesAfterClaim(relayerA); } @@ -496,7 +497,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY + 1); expectBridgeDepositClaimed({bridgeTx: ethTx, txId: txId, relayer: relayerA, to: relayerA}); claim({caller: caller, bridgeTx: ethTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); checkEthBalancesAfterClaim(relayerA); } @@ -509,7 +510,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY + 1); expectBridgeDepositClaimed({bridgeTx: ethTx, txId: txId, relayer: relayerA, to: relayerA}); claim({caller: caller, bridgeTx: ethTx, to: address(0)}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); checkEthBalancesAfterClaim(relayerA); } @@ -521,7 +522,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY + 1); expectBridgeDepositClaimed({bridgeTx: ethTx, txId: txId, relayer: relayerA, to: claimTo}); claim({caller: relayerA, bridgeTx: ethTx, to: claimTo}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); checkEthBalancesAfterClaim(claimTo); } @@ -533,7 +534,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY + 30 days); expectBridgeDepositClaimed({bridgeTx: ethTx, txId: txId, relayer: relayerA, to: relayerA}); claim({caller: relayerA, bridgeTx: ethTx, to: relayerA}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.RELAYER_CLAIMED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.RELAYER_CLAIMED); checkEthBalancesAfterClaim(relayerA); } @@ -613,7 +614,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { prove({caller: relayerA, bridgeTx: tokenTx, destTxHash: hex"01"}); expectBridgeProofDisputed({txId: txId, guard: guard}); dispute({caller: guard, txId: txId}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(fastBridge.protocolFees(address(srcToken)), INITIAL_PROTOCOL_FEES_TOKEN); assertEq(srcToken.balanceOf(address(fastBridge)), INITIAL_PROTOCOL_FEES_TOKEN + tokenParams.originAmount); } @@ -625,7 +626,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY); expectBridgeProofDisputed({txId: txId, guard: guard}); dispute({caller: guard, txId: txId}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(fastBridge.protocolFees(address(srcToken)), INITIAL_PROTOCOL_FEES_TOKEN); assertEq(srcToken.balanceOf(address(fastBridge)), INITIAL_PROTOCOL_FEES_TOKEN + tokenParams.originAmount); } @@ -637,7 +638,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { prove({caller: relayerA, bridgeTx: ethTx, destTxHash: hex"01"}); expectBridgeProofDisputed({txId: txId, guard: guard}); dispute({caller: guard, txId: txId}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(fastBridge.protocolFees(ETH_ADDRESS), INITIAL_PROTOCOL_FEES_ETH); assertEq(address(fastBridge).balance, INITIAL_PROTOCOL_FEES_ETH + ethParams.originAmount); } @@ -650,7 +651,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(CLAIM_DELAY); expectBridgeProofDisputed({txId: txId, guard: guard}); dispute({caller: guard, txId: txId}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REQUESTED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REQUESTED); assertEq(fastBridge.protocolFees(ETH_ADDRESS), INITIAL_PROTOCOL_FEES_ETH); assertEq(address(fastBridge).balance, INITIAL_PROTOCOL_FEES_ETH + ethParams.originAmount); } @@ -713,7 +714,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(DEADLINE + 1); expectBridgeDepositRefunded({bridgeParams: tokenParams, txId: txId}); refund({caller: refunder, bridgeTx: tokenTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(fastBridge.protocolFees(address(srcToken)), INITIAL_PROTOCOL_FEES_TOKEN); assertEq(srcToken.balanceOf(userA), LEFTOVER_BALANCE + tokenParams.originAmount); assertEq(srcToken.balanceOf(address(fastBridge)), INITIAL_PROTOCOL_FEES_TOKEN); @@ -726,7 +727,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(DEADLINE + 1); expectBridgeDepositRefunded({bridgeParams: tokenParams, txId: txId}); refund({caller: refunder, bridgeTx: tokenTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(fastBridge.protocolFees(address(srcToken)), INITIAL_PROTOCOL_FEES_TOKEN); assertEq(srcToken.balanceOf(userA), LEFTOVER_BALANCE + 2 * tokenParams.originAmount); assertEq(srcToken.balanceOf(userB), LEFTOVER_BALANCE); @@ -739,7 +740,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(DEADLINE + 30 days); expectBridgeDepositRefunded({bridgeParams: tokenParams, txId: txId}); refund({caller: refunder, bridgeTx: tokenTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(fastBridge.protocolFees(address(srcToken)), INITIAL_PROTOCOL_FEES_TOKEN); assertEq(srcToken.balanceOf(userA), LEFTOVER_BALANCE + tokenParams.originAmount); assertEq(srcToken.balanceOf(address(fastBridge)), INITIAL_PROTOCOL_FEES_TOKEN); @@ -752,7 +753,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(DEADLINE + PERMISSIONLESS_REFUND_DELAY + 1); expectBridgeDepositRefunded({bridgeParams: tokenParams, txId: txId}); refund({caller: caller, bridgeTx: tokenTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(fastBridge.protocolFees(address(srcToken)), INITIAL_PROTOCOL_FEES_TOKEN); assertEq(srcToken.balanceOf(userA), LEFTOVER_BALANCE + tokenParams.originAmount); assertEq(srcToken.balanceOf(address(fastBridge)), INITIAL_PROTOCOL_FEES_TOKEN); @@ -765,7 +766,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(DEADLINE + 1); expectBridgeDepositRefunded({bridgeParams: ethParams, txId: txId}); refund({caller: refunder, bridgeTx: ethTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(fastBridge.protocolFees(ETH_ADDRESS), INITIAL_PROTOCOL_FEES_ETH); assertEq(address(userA).balance, LEFTOVER_BALANCE + ethParams.originAmount); assertEq(address(fastBridge).balance, INITIAL_PROTOCOL_FEES_ETH); @@ -779,7 +780,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(DEADLINE + 1); expectBridgeDepositRefunded({bridgeParams: ethParams, txId: txId}); refund({caller: refunder, bridgeTx: ethTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(fastBridge.protocolFees(ETH_ADDRESS), INITIAL_PROTOCOL_FEES_ETH); assertEq(address(userA).balance, LEFTOVER_BALANCE + 2 * ethParams.originAmount); assertEq(address(userB).balance, LEFTOVER_BALANCE); @@ -793,7 +794,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(DEADLINE + 30 days); expectBridgeDepositRefunded({bridgeParams: ethParams, txId: txId}); refund({caller: refunder, bridgeTx: ethTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(fastBridge.protocolFees(ETH_ADDRESS), INITIAL_PROTOCOL_FEES_ETH); assertEq(address(userA).balance, LEFTOVER_BALANCE + ethParams.originAmount); assertEq(address(fastBridge).balance, INITIAL_PROTOCOL_FEES_ETH); @@ -807,7 +808,7 @@ contract FastBridgeV2SrcTest is FastBridgeV2SrcBaseTest { skip(DEADLINE + PERMISSIONLESS_REFUND_DELAY + 1); expectBridgeDepositRefunded({bridgeParams: ethParams, txId: txId}); refund({caller: caller, bridgeTx: ethTx}); - assertEq(fastBridge.bridgeStatuses(txId), FastBridgeV2.BridgeStatus.REFUNDED); + assertEq(fastBridge.bridgeStatuses(txId), IFastBridgeV2.BridgeStatus.REFUNDED); assertEq(fastBridge.protocolFees(ETH_ADDRESS), INITIAL_PROTOCOL_FEES_ETH); assertEq(address(userA).balance, LEFTOVER_BALANCE + ethParams.originAmount); assertEq(address(fastBridge).balance, INITIAL_PROTOCOL_FEES_ETH); diff --git a/packages/contracts-rfq/test/FastBridgeV2.t.sol b/packages/contracts-rfq/test/FastBridgeV2.t.sol index 8517a2dbf8..80c1354fa8 100644 --- a/packages/contracts-rfq/test/FastBridgeV2.t.sol +++ b/packages/contracts-rfq/test/FastBridgeV2.t.sol @@ -2,6 +2,8 @@ pragma solidity ^0.8.20; import {IFastBridge} from "../contracts/interfaces/IFastBridge.sol"; +import {IFastBridgeV2} from "../contracts/interfaces/IFastBridgeV2.sol"; + import {IFastBridgeV2Errors} from "../contracts/interfaces/IFastBridgeV2Errors.sol"; import {FastBridgeV2} from "../contracts/FastBridgeV2.sol";