store relayer on relay [SLT-182]

packages/contracts-rfq/contracts/FastBridgeV2.sol

@@ -35,8 +35,8 @@
     mapping(bytes32 => BridgeStatus) public bridgeStatuses;
     /// @notice Proof of relayed bridge tx on origin chain
     mapping(bytes32 => BridgeProof) public bridgeProofs;
-    /// @notice Whether bridge has been relayed on destination chain
-    mapping(bytes32 => bool) public bridgeRelays;
+    /// @notice Relay details on destination chain
+    mapping(bytes32 => BridgeRelay) public bridgeRelayDetails;
 
     /// @dev to prevent replays
     uint256 public nonce;
@@ -131,16 +131,19 @@
 
     /// @inheritdoc IFastBridgeV2
     function relay(bytes memory request, address relayer) public payable {
+        if (relayer == address(0)) revert ZeroAddress();
         bytes32 transactionId = keccak256(request);
         BridgeTransaction memory transaction = getBridgeTransaction(request);
         if (transaction.destChainId != uint32(block.chainid)) revert ChainIncorrect();
 
         // check haven't exceeded deadline for relay to happen
         if (block.timestamp > transaction.deadline) revert DeadlineExceeded();
 
+        if (bridgeRelayDetails[transactionId].relayer != address(0)) revert TransactionRelayed();
+
         // mark bridge transaction as relayed
-        if (bridgeRelays[transactionId]) revert TransactionRelayed();
-        bridgeRelays[transactionId] = true;
+        bridgeRelayDetails[transactionId] =
+            BridgeRelay({blockNumber: uint48(block.number), blockTimestamp: uint48(block.timestamp), relayer: relayer});
 
         // transfer tokens to recipient on destination chain and gas rebate if requested
         address to = transaction.destRecipient;
@@ -174,6 +177,12 @@
         );
     }
 
+    /// @inheritdoc IFastBridgeV2
+    function bridgeRelays(bytes32 transactionId) public view returns (bool) {
+        // has this transactionId been relayed?
+        return bridgeRelayDetails[transactionId].relayer != address(0);
+    }
+
     /// @inheritdoc IFastBridge
     function prove(bytes memory request, bytes32 destTxHash) external {
         prove(request, destTxHash, msg.sender);

packages/contracts-rfq/contracts/interfaces/IFastBridgeV2.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.20;
 import {IFastBridge} from "./IFastBridge.sol";
 
 interface IFastBridgeV2 is IFastBridge {
-
     /// @notice Relays destination side of bridge transaction by off-chain relayer
     /// @param request The encoded bridge transaction to relay on destination chain
     /// @param relayer The address of the relaying entity which should have control of the origin funds when claimed
@@ -20,4 +19,14 @@ interface IFastBridgeV2 is IFastBridge {
     /// @param request The encoded bridge transaction to claim on origin chain
     function claim(bytes memory request) external;
 
+    /// @notice Checks if a transaction has been relayed
+    /// @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);
+
+    struct BridgeRelay {
+        uint48 blockNumber;
+        uint48 blockTimestamp;
+        address relayer;
+    }
 }

packages/contracts-rfq/test/FastBridgeV2.Dst.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.20;
 
-import {ChainIncorrect, DeadlineExceeded, TransactionRelayed} from "../contracts/libs/Errors.sol";
+import {ChainIncorrect, DeadlineExceeded, TransactionRelayed, ZeroAddress} from "../contracts/libs/Errors.sol";
 
 import {FastBridgeV2, FastBridgeV2Test, IFastBridge} from "./FastBridgeV2.t.sol";
 
@@ -115,6 +115,21 @@ contract FastBridgeV2DstTest is FastBridgeV2Test {
         assertEq(address(fastBridge).balance, 0);
     }
 
+    /// @notice RelayerB completes the ETH bridge request, using relayerA's address
+    function test_relay_eth_withRelayerAddress_checkBlockData() public {
+        vm.roll(987_654_321);
+        vm.warp(123_456_789);
+        bytes32 txId = getTxId(ethTx);
+        expectBridgeRelayed(ethTx, txId, address(relayerA));
+        relayWithAddress({caller: relayerB, relayer: relayerA, msgValue: ethParams.destAmount, bridgeTx: ethTx});
+        assertTrue(fastBridge.bridgeRelays(txId));
+        (uint48 recordedBlockNumber, uint48 recordedblockTimestamp,) = fastBridge.bridgeRelayDetails(txId);
+        assertEq(recordedBlockNumber, 987_654_321);
+        assertEq(recordedblockTimestamp, 123_456_789);
+        assertEq(address(userB).balance, ethParams.destAmount);
+        assertEq(address(relayerB).balance, LEFTOVER_BALANCE);
+        assertEq(address(fastBridge).balance, 0);
+    }
     // ══════════════════════════════════════════════════ REVERTS ══════════════════════════════════════════════════════
 
     function test_relay_revert_chainIncorrect() public {
@@ -152,4 +167,9 @@ contract FastBridgeV2DstTest is FastBridgeV2Test {
         vm.expectRevert(DeadlineExceeded.selector);
         relayWithAddress({caller: relayerA, relayer: relayerB, msgValue: 0, bridgeTx: tokenTx});
     }
+
+    function test_relay_withRelayerAddress_revert_zeroAddr() public {
+        vm.expectRevert(ZeroAddress.selector);
+        relayWithAddress({caller: relayerA, relayer: address(0), msgValue: 0, bridgeTx: tokenTx});
+    }
 }