Non-Interactive Swaps

You’re viewing an old version of the Arkade contracts documentation. Go to Your first contract for the current version.

This contract is an experimental compiler example. Do not fund it with real funds.

A non-interactive swap lets a user lock one asset in a contract that pays out to anyone who delivers another asset in return. The user who funds the offer does not need to be online when someone fills it. Transaction introspection makes this safe: the contract checks the outputs of the spending transaction, so a filler cannot take the locked asset without paying. Arkade Intents settles routes whose endpoints both use arkade with a contract of this kind. Asset Swaps documents that contract. It has no expiry: the user cancels it at any time.

The contract

This is non_interactive_swap.ark from the compiler examples. makerPk is the user who funds the offer, and takerPk is whoever fills it. These are contract positions, not roles.

non_interactive_swap.ark

pragma arkade ^0.1.0;

import "../single_sig/single_sig.ark";

contract NonInteractiveSwap(
  pubkey makerPk,
  bytes32 offerAssetIdTxid,
  int offerAssetIdGidx,
  int offerAmount,
  bytes32 wantAssetIdTxid,
  int wantAssetIdGidx,
  int wantAmount,
  int expirationTime
) {
  function swap(pubkey takerPk, signature takerSig, bytes takerScriptPubKey) {
    require(checkSig(takerSig, takerPk), "invalid taker signature");

    // Output 0 pays the wanted asset to the maker
    require(
      tx.outputs[0].assets.lookup(wantAssetIdTxid, wantAssetIdGidx) >= wantAmount,
      "insufficient want asset for maker"
    );
    require(
      tx.outputs[0].scriptPubKey == new SingleSig(makerPk),
      "output 0 not spendable by maker"
    );

    // Output 1 pays the offered asset to the taker
    require(
      tx.outputs[1].assets.lookup(offerAssetIdTxid, offerAssetIdGidx) >= offerAmount,
      "insufficient offer asset for taker"
    );
    require(
      tx.outputs[1].scriptPubKey == takerScriptPubKey,
      "output 1 not spendable by taker"
    );
  }

  function cancel(signature makerSig) {
    require(checkTime(expirationTime), "swap not expired");
    require(checkSig(makerSig, makerPk), "invalid maker signature");
  }

  function unilateral(signature makerSig) tapscript {
    require(older(serverExitDelay));
    require(checkSig(makerSig, makerPk));
  }
}

Function	Kind	Who can spend
`swap`	Covenant	Anyone whose transaction pays `wantAmount` of the wanted asset to the maker in output 0
`cancel`	Covenant	The maker, after `expirationTime` by the emulator’s clock
`unilateral`	Exit path	The maker, after the operator’s exit delay, if the operator is unavailable

new SingleSig(makerPk) is the output script of a SingleSig contract for the maker’s key. Requiring it in output 0 makes sure the maker can spend what they receive. The contract checks only those two outputs. Fund it with exactly offerAmount of the offered asset: the filler decides where any extra value goes. The emulator runs swap and cancel before it cosigns, together with the operator. Arkade Compiler explains how covenants become paths.

Overview

Working with Tapscript

Experimental

The contract

​The contract

The contract