Non-Interactive Swaps

Experimental TechnologyNon-interactive swaps on Arkade are experimental technology in active development. All code and examples presented here are for exploration and proof of concept purposes only. Do not use in production environments.

Non-interactive swaps allow users to exchange assets without requiring both parties to be online simultaneously. This pattern leverages Arkade Script’s advanced capabilities to create secure, trustless swap mechanisms. Routes with both sides settling through Arkade fund swaps against this contract, which acts as their settlement primitive. Cross-corridor routes establish terms through RFQ and settle with a profile-specific HTLC.

Overview

Unlike traditional atomic swaps that require coordination between parties, non-interactive swaps allow:

One party to fund a swap offer that anyone can fill
A solver to complete the swap without the user who funded it being online
Automatic verification of swap conditions without trusted third parties

In the contract code below, maker and taker are script parameters — the funding side and the filling side. See Asset Swaps for the participant terminology used by Arkade Intents.

Contract Architecture

The non-interactive swap contract uses a combination of:

Hash Preimage Verification - To ensure the correct asset is being swapped
Transaction Introspection - To verify output amounts and destinations
Timelock Mechanisms - Expiry-based reclaim

Example Implementation

This example illustrates an expiry-based contract variant. The current reference Intents swap has no automatic expiry; it stays open until a solver fills it or the user cancels it.

// Contract configuration options
options {
  server = server;
  exit = 144;
}

contract NonInteractiveSwap(
  pubkey maker,
  pubkey server,
  bytes32 assetIdHash,
  int amount,
  int expiryTime
) {
  // Maker can cancel the swap after expiry
  function cancel(signature makerSig) {
    require(tx.time >= expiryTime, "Swap has not expired yet");
    require(checkSig(makerSig, maker), "Invalid maker signature");
  }
  
  // Anyone can complete the swap by providing the correct asset
  function swap(bytes32 assetId, signature takerSig, pubkey taker) {
    // Verify the asset being provided matches what the maker requested
    require(sha256(assetId) == assetIdHash, "Asset ID doesn't match requested asset");
    
    // Verify the output contains the correct amount going to the maker
    require(tx.outputs[0].value >= amount, "Output amount too small");
    require(tx.outputs[0].asset == assetId, "Output asset incorrect");
    
    // Verify the output is spendable by the maker
    bytes makerScript = new P2PKH(maker);
    require(tx.outputs[0].scriptPubKey == makerScript, "Output not spendable by maker");
    
    // Verify the taker signature
    require(checkSig(takerSig, taker), "Invalid taker signature");
  }
}

Advanced Features

Partial Fills

Non-interactive swaps can be extended to support partial fills, allowing multiple takers to each fulfill a portion of the swap:

function partialSwap(bytes32 assetId, int partialAmount, signature takerSig, pubkey taker) {
  // Verify the asset being provided matches what the maker requested
  require(sha256(assetId) == assetIdHash, "Asset ID doesn't match requested asset");
  
  // Verify the partial amount is reasonable
  require(partialAmount > 0, "Partial amount must be positive");
  require(partialAmount <= amount, "Partial amount too large");
  
  // Calculate the proportional output based on the partial amount
  int proportionalOutput = (partialAmount * totalOutput) / amount;
  
  // Verify the output contains the correct amount going to the maker
  require(tx.outputs[0].value >= proportionalOutput, "Output amount too small");
  require(tx.outputs[0].asset == assetId, "Output asset incorrect");
  
  // Verify the output is spendable by the maker
  bytes makerScript = new P2PKH(maker);
  require(tx.outputs[0].scriptPubKey == makerScript, "Output not spendable by maker");
  
  // Verify the change output returns to a new swap contract with updated amount
  int remainingAmount = amount - partialAmount;
  if (remainingAmount > 0) {
    // Verify there's a change output with the remaining swap contract
    // Implementation details omitted for brevity
  }
  
  // Verify the taker signature
  require(checkSig(takerSig, taker), "Invalid taker signature");
}

Price Oracles

For swaps that need to execute at market price rather than a fixed rate, oracle integration can be added:

function marketSwap(bytes32 assetId, int price, signature oracleSig, pubkey oracle, signature takerSig, pubkey taker) {
  // Verify the asset being provided matches what the maker requested
  require(sha256(assetId) == assetIdHash, "Asset ID doesn't match requested asset");
  
  // Verify the oracle signature on the price data
  bytes message = sha256(assetId + int2bytes(tx.time));
  require(checkSigFromStack(oracleSig, oracle, message), "Invalid oracle signature");
  
  // Calculate the expected amount based on the oracle price
  int expectedAmount = amount * price / 10000; // Assuming price is in basis points
  
  // Verify the output contains the correct amount going to the maker
  require(tx.outputs[0].value >= expectedAmount, "Output amount too small");
  require(tx.outputs[0].asset == assetId, "Output asset incorrect");
  
  // Verify the output is spendable by the maker
  bytes makerScript = new P2PKH(maker);
  require(tx.outputs[0].scriptPubKey == makerScript, "Output not spendable by maker");
  
  // Verify the taker signature
  require(checkSig(takerSig, taker), "Invalid taker signature");
}

Using it

The contract described here settles the arkade:<asset> → arkade:<asset> route. Exchange Assets documents the working integration against it — discovering a market, funding the derived contract, tracking the fill, and cancelling an unfilled swap.

Security Considerations

When implementing non-interactive swaps, consider these security aspects:

Frontrunning Protection - Consider mechanisms to prevent frontrunning of attractive swap offers
Fee Management - Ensure the contract accounts for transaction fees to avoid dust outputs
Replay Protection - Implement nonces or other mechanisms to prevent replay attacks
Timelock Selection - Choose appropriate timelocks that balance security with capital efficiency

Future Directions

The Arkade ecosystem is exploring several enhancements to non-interactive swaps:

Multi-asset Swaps - Supporting swaps involving more than two assets
Conditional Swaps - Swaps that execute only when certain external conditions are met
Privacy Enhancements - Techniques to improve the privacy of swap participants

Working with Tapscript

Use Cases

Experimental

Overview

Contract Architecture

Example Implementation

Advanced Features

Partial Fills

Price Oracles

Using it

Security Considerations

Future Directions

​Overview

​Contract Architecture

​Example Implementation

​Advanced Features

​Partial Fills

​Price Oracles

​Using it

​Security Considerations

​Future Directions

Overview

Contract Architecture

Example Implementation

Advanced Features

Partial Fills

Price Oracles

Using it

Security Considerations

Future Directions