Supports Arkade-to-EVM, Lightning and Bitcoin-to-EVM swaps. The server submits coordinator.redeemAndExecute on the client’s behalf, using the client’s EIP-712 signature and secret.

Prerequisites — what the client must do before calling this endpoint

1. Create a swap via one of the swap endpoints (e.g. POST /swap/arkade/evm). Wait for the swap status to reach ServerFunded.

2. Fetch calldata via GET /swap/{id}/redeem-and-swap-calldata. This returns:

   • dex_calldata — DEX swap calldata (only for non-WBTC targets)
   • gasless_fee_sats — the fee deducted from the HTLC amount
   • calls_hash — keccak256(abi.encode(calls)), must be included in the signature

3. Construct the EIP-712 signature over the Redeem struct:

   Domain:

   EIP712Domain(string name, string version, uint256 chainId, address verifyingContract)
   name            = "HTLCErc20"
   version         = "4"
   chainId         = <target EVM chain ID>
   verifyingContract = <HTLCErc20 contract address (swap.evm_htlc_address)>
   

   Struct:

   Redeem(
       bytes32 preimage,       // the swap secret
       uint256 amount,         // WBTC amount in the HTLC (in sats)
       address token,          // WBTC token address
       address sender,         // server's EVM address
       uint256 timelock,       // HTLC refund locktime
       address caller,         // HTLCCoordinator contract address
       address destination,    // where output tokens go
       address sweepToken,     // target token (or WBTC if direct)
       uint256 minAmountOut,   // slippage protection from step 2
       bytes32 callsHash       // from step 2
   )
   

   The final digest is: keccak256(\x19\x01 || domainSeparator || structHash)

   Sign this digest with the client’s EVM private key (secp256k1) to obtain v, r, s.

   JavaScript example (using ethers v6):

   import { ethers } from "ethers";
   
   // 1. Fetch calldata (returns calls_hash + optional dex_calldata)
   const { calls_hash, dex_calldata, gasless_fee_sats, min_amount_out } = await fetch(
     `${baseUrl}/swap/${swapId}/redeem-and-swap-calldata?destination=${destination}`
   ).then(r => r.json());
   
   // 2. Determine sweepToken
   const needsDexSwap = targetTokenAddress.toLowerCase() !== wbtcAddress.toLowerCase();
   const sweepToken = needsDexSwap ? targetTokenAddress : wbtcAddress;
   
   // 3. Build EIP-712 typed data and sign
   const wallet = new ethers.Wallet(privateKey);
   
   const domain = {
     name: "HTLCErc20",
     version: "4",
     chainId: swap.evm_chain_id,               // e.g. 42161 for Arbitrum
     verifyingContract: swap.evm_htlc_address,  // HTLCErc20 contract
   };
   
   const types = {
     Redeem: [
       { name: "preimage",     type: "bytes32" },
       { name: "amount",       type: "uint256" },
       { name: "token",        type: "address" },
       { name: "sender",       type: "address" },
       { name: "timelock",     type: "uint256" },
       { name: "caller",       type: "address" },
       { name: "destination",  type: "address" },
       { name: "sweepToken",   type: "address" },
       { name: "minAmountOut", type: "uint256" },
       { name: "callsHash",   type: "bytes32" },
     ],
   };
   
   const message = {
     preimage:     secret,                        // 0x-prefixed 32-byte hex
     amount:       swap.evm_expected_sats,        // WBTC sats locked in HTLC
     token:        wbtcAddress,                   // WBTC on the target chain
     sender:       swap.server_evm_address,       // server (HTLC creator)
     timelock:     swap.evm_refund_locktime,      // HTLC expiry timestamp
     caller:       swap.evm_coordinator_address,  // HTLCCoordinator contract
     destination:  destination,                   // where output tokens go
     sweepToken:   sweepToken,
     minAmountOut: min_amount_out,                // from step 1
     callsHash:    calls_hash,                    // from step 1
   };
   
   const sig = await wallet.signTypedData(domain, types, message);
   const { v, r, s } = ethers.Signature.from(sig);
   
   // 4. POST to claim-gasless
   await fetch(`${baseUrl}/swap/${swapId}/claim-gasless`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
       secret, destination, v, r, s,
       dex_calldata: needsDexSwap ? dex_calldata : undefined,
     }),
   });
   

4. POST the request to this endpoint with the secret, destination, signature, and optionally the dex_calldata from step 2.

Idempotency

Repeating the request is safe. A swap whose claim has already been relayed or observed (client_redeeming, client_redeemed, server_redeemed) answers 200 with that status and the claim transaction hash, and a request that arrives while the relay is being broadcast answers 200 with client_redeeming and no hash yet. Nothing is relayed twice.

On a native-coin target (Rootstock) the response is sent as soon as the node has accepted the claim transaction: the swap is client_redeeming with the hash recorded, and the server keeps following the transaction until it is mined. A relay that reverts or is dropped by the node returns the swap to server_funded, so a later request claims again.