fix solver-first swaps; support solver-led HTLC init; extend native tests with solver-first coverage

Author: nerses-asaturyan

.github/workflows/evm_erc20_tests.yml

@@ -1,36 +1,36 @@
-name: EVM ERC20 Contract Tests
+# name: EVM ERC20 Contract Tests
 
-on:
-  push:
-    branches: [main-add-evm]
-    paths:
-      - 'chains/evm/solidity/contracts/TrainERC20.sol'
-      - 'chains/evm/solidity/test/erc20.js'
+# on:
+#   push:
+#     branches: [main-add-evm]
+#     paths:
+#       - 'chains/evm/solidity/contracts/TrainERC20.sol'
+#       - 'chains/evm/solidity/test/erc20.js'
 
-  pull_request:
-    branches: [main-add-evm]
-    paths:
-      - 'chains/evm/solidity/contracts/TrainERC20.sol'
-      - 'chains/evm/solidity/test/erc20.js'
-  workflow_dispatch:
+#   pull_request:
+#     branches: [main-add-evm]
+#     paths:
+#       - 'chains/evm/solidity/contracts/TrainERC20.sol'
+#       - 'chains/evm/solidity/test/erc20.js'
+#   workflow_dispatch:
 
-jobs:
-  erc20-test:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+# jobs:
+#   erc20-test:
+#     runs-on: ubuntu-latest
+#     steps:
+#       - name: Checkout repository
+#         uses: actions/checkout@v4
 
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: npm
+#       - name: Setup Node.js
+#         uses: actions/setup-node@v4
+#         with:
+#           node-version: 20
+#           cache: npm
 
-      - name: Install dependencies
-        working-directory: chains/evm/solidity
-        run: npm ci
+#       - name: Install dependencies
+#         working-directory: chains/evm/solidity
+#         run: npm ci
 
-      - name: Run ERC20 tests
-        working-directory: chains/evm/solidity
-        run: npx hardhat test test/erc20.js --bail --parallel
+#       - name: Run ERC20 tests
+#         working-directory: chains/evm/solidity
+#         run: npx hardhat test test/erc20.js --bail --parallel

chains/evm/solidity/contracts/Train.sol

@@ -26,9 +26,8 @@ contract Train is ReentrancyGuard {
   error HashlockNotMatch();
   error AlreadyClaimed();
   error InvalidTimelock();
-  error InvaliRewardData();
+  error InvalidRewardTimelock();
   error SwapAlreadyInitialized();
-  error SwapNotInitialized();
   error InvalidSwapOwner();
   error TransferFailed();
 
@@ -109,7 +108,7 @@ contract Train is ReentrancyGuard {
   mapping(address => bytes32[]) private userSwaps;
 
   /// @notice Locks funds in a new hashed time-locked contract (HTLC).
-  /// @dev Creates an HTLC with the specified details and emits a `TokenLocked` event. The htlcId is automatically generated.
+  /// @dev Creates an HTLC with the specified details and emits a `UserLocked` or `SolverLocked` event. The htlcId is automatically generated.
   /// @param swapId The identifier for the swap (can have multiple HTLCs).
   /// @param hashlock The hash of the secret required for redeeming the HTLC.
   /// @param reward The reward amount in wei granted to the caller of redeem.
@@ -120,7 +119,7 @@ contract Train is ReentrancyGuard {
   /// @param dstChain The destination blockchain for the swap.
   /// @param dstAddress The recipient address on the destination chain.
   /// @param dstAsset The asset on the destination chain.
-  /// @return uint256 The unique identifier of the created HTLC.
+  /// @return (bytes32, uint256) Returns the swapId and the unique htlcId of the created HTLC.
   function lock(
     bytes32 swapId,
     bytes32 hashlock,
@@ -137,25 +136,27 @@ contract Train is ReentrancyGuard {
     if (block.timestamp + 900 > timelock) revert InvalidTimelock();
     bool isSolver = reward > 0;
     if (isSolver) {
-      if (rewardTimelock > timelock || rewardTimelock <= block.timestamp) revert InvaliRewardData();
+      if (rewardTimelock > timelock || rewardTimelock <= block.timestamp) revert InvalidRewardTimelock();
     }
 
-    HTLC storage meta = contracts[swapId][0];
+    uint256 htlcId;
+    bool isNewSwap = (contracts[swapId][0].sender == address(0)); // true when swapId does not exist yet
 
-    bool isNewSwap = (meta.sender == address(0));
-    uint256 htlcId = 0;
-
-    if (isNewSwap && !isSolver) {
+    if (!isSolver) {
+      // User can only initialize a swap once and always maps to slot 0
+      if (!isNewSwap) revert SwapAlreadyInitialized();
       userSwaps[msg.sender].push(swapId);
-    }
-
-    if (!isNewSwap && !isSolver) {
-      revert SwapAlreadyInitialized();
-    } else if (!isNewSwap && isSolver) {
-      htlcId = 1;
-      while (contracts[swapId][htlcId].sender != address(0)) {
-        unchecked {
-          htlcId++;
+      htlcId = 0;
+    } else {
+      // Solvers can either initialize the swap (take slot 0) or append additional offers
+      if (isNewSwap) {
+        htlcId = 0; // solver is first to open the swap so they occupy slot 0
+      } else {
+        htlcId = 1;
+        while (contracts[swapId][htlcId].sender != address(0)) {
+          unchecked {
+            htlcId++; // find next free slot for additional solver HTLCs
+          }
         }
       }
     }
@@ -213,7 +214,7 @@ contract Train is ReentrancyGuard {
   /// @return bool Returns `true` if the refund is successful.
   function refund(bytes32 swapId, uint256 htlcId) external _exists(swapId, htlcId) nonReentrant returns (bool) {
     HTLC storage htlc = contracts[swapId][htlcId];
-    if (htlc.claimed == 2 || htlc.claimed == 3) revert AlreadyClaimed();
+    if (htlc.claimed != 1) revert AlreadyClaimed();
     if (htlc.timelock > block.timestamp) revert NotPassedTimelock();
 
     htlc.claimed = 2;
@@ -240,7 +241,7 @@ contract Train is ReentrancyGuard {
     HTLC storage htlc = contracts[swapId][htlcId];
 
     if (htlc.hashlock != sha256(abi.encodePacked(secret))) revert HashlockNotMatch();
-    if (htlc.claimed == 3 || htlc.claimed == 2) revert AlreadyClaimed();
+    if (htlc.claimed != 1) revert AlreadyClaimed();
 
     htlc.claimed = 3;
     htlc.secret = secret;

chains/evm/solidity/test/native.js

@@ -242,6 +242,100 @@ describe('Train', function () {
       expect(solverHTLC.reward).to.equal(reward);
     });
 
+    it('permits a solver-first swap and blocks later user initialization', async function () {
+      const { train, initiator, solverA, solverB, receiver } = await loadFixture(deployTrainFixture);
+      const swapId = ethers.id('solver-first');
+      const solverAmount = ethers.parseEther('0.8');
+      const solverReward = ethers.parseEther('0.15');
+      const timelock = await futureTimestamp(4200);
+      const rewardTimelock = timelock - 30;
+      const hashlock = hashSecret(901n);
+
+      await expect(
+        train
+          .connect(solverA)
+          .lock(
+            swapId,
+            hashlock,
+            solverReward,
+            rewardTimelock,
+            timelock,
+            receiver.address,
+            DEFAULT_META.srcAsset,
+            DEFAULT_META.dstChain,
+            DEFAULT_META.dstAddress,
+            DEFAULT_META.dstAsset,
+            { value: solverAmount + solverReward }
+          )
+      )
+        .to.emit(train, 'SolverLocked')
+        .withArgs(
+          swapId,
+          0,
+          hashlock,
+          DEFAULT_META.dstChain,
+          DEFAULT_META.dstAddress,
+          DEFAULT_META.dstAsset,
+          solverA.address,
+          receiver.address,
+          DEFAULT_META.srcAsset,
+          solverAmount,
+          solverReward,
+          rewardTimelock,
+          timelock
+        );
+
+      const solverDetails = await train.getHTLCDetails(swapId, 0);
+      expect(solverDetails.sender).to.equal(solverA.address);
+      expect(solverDetails.amount).to.equal(solverAmount);
+      expect(solverDetails.reward).to.equal(solverReward);
+
+      await expect(lockUserHTLC(train, initiator, receiver, { swapId })).to.be.revertedWithCustomError(
+        train,
+        'SwapAlreadyInitialized'
+      );
+
+      const secondHashlock = hashSecret(902n);
+      const secondTimelock = await futureTimestamp(5200);
+      const secondRewardTimelock = secondTimelock - 60;
+      await expect(
+        train
+          .connect(solverB)
+          .lock(
+            swapId,
+            secondHashlock,
+            solverReward,
+            secondRewardTimelock,
+            secondTimelock,
+            receiver.address,
+            DEFAULT_META.srcAsset,
+            DEFAULT_META.dstChain,
+            DEFAULT_META.dstAddress,
+            DEFAULT_META.dstAsset,
+            { value: solverAmount + solverReward }
+          )
+      )
+        .to.emit(train, 'SolverLocked')
+        .withArgs(
+          swapId,
+          1,
+          secondHashlock,
+          DEFAULT_META.dstChain,
+          DEFAULT_META.dstAddress,
+          DEFAULT_META.dstAsset,
+          solverB.address,
+          receiver.address,
+          DEFAULT_META.srcAsset,
+          solverAmount,
+          solverReward,
+          secondRewardTimelock,
+          secondTimelock
+        );
+
+      const userSwaps = await train.getUserSwaps(initiator.address);
+      expect(userSwaps.length).to.equal(0);
+    });
+
     it('reverts when the timelock is sooner than 15 minutes', async function () {
       const { train, initiator, receiver } = await loadFixture(deployTrainFixture);
       const soon = (await time.latest()) + 899;
@@ -313,7 +407,7 @@ describe('Train', function () {
             DEFAULT_META.dstAsset,
             { value: reward + ethers.parseEther('1') }
           )
-      ).to.be.revertedWithCustomError(train, 'InvaliRewardData');
+      ).to.be.revertedWithCustomError(train, 'InvalidRewardTimelock');
 
       const now = await time.latest();
       await expect(
@@ -332,7 +426,7 @@ describe('Train', function () {
             DEFAULT_META.dstAsset,
             { value: reward + ethers.parseEther('1') }
           )
-      ).to.be.revertedWithCustomError(train, 'InvaliRewardData');
+      ).to.be.revertedWithCustomError(train, 'InvalidRewardTimelock');
     });
   });