Swap Contract

The non-interactive swap contract settles every route whose endpoints both use arkade (Asset Swaps). The user funds it, and any solver fills it by paying the terms on output 0. It comes in two programs, one for each thing a fill can deliver:

Program	Fill must deliver	Source below
want-asset	A named asset, at least `wantAmount` units	`swap_want_asset.ark`
want-BTC	At least `wantAmount` sats	`swap_want_btc.ark`

@arkade-os/swap ships the two programs as compiled JSON, swap-want-asset.program.json and swap-want-btc.program.json. The want-asset source is the one the SDK’s golden test compiles with arkadec and checks against the shipped program byte for byte (offer.test.ts in arkade-os/ts-sdk at 0ee3161). Both files below add exit, the third leaf the SDK appends in code. Copy the contract without changes. A change to the code, or to the order of the functions, changes the address.

Source

swap_want_asset.ark

pragma arkade ^0.1.0;

contract SwapWantAsset(
  // 32-byte taproot program of the user's script. The fill pays it on output 0.
  pubkey  makerWP,
  // Asset units. Output 0 must carry at least this much of the wanted asset.
  int     wantAmount,
  // The wanted asset's genesis txid, in internal byte order.
  bytes32 wantAssetTxid,
  // The wanted asset's group index.
  int     wantAssetGroupIndex,
  // 32-byte x-only key of the user who funds the swap.
  pubkey  user,
  // BIP68 sequence of the exit path. older() pushes it raw.
  int     exitDelay
) {
  function fulfill() {
    require(tx.outputs[0].assets.lookup(wantAssetTxid, wantAssetGroupIndex) >= wantAmount);
    let recipient = tx.outputs[0].script;
    require(recipient.version == 1);
    require(recipient.program == makerWP);
  }

  function cancel(signature userSig, signature serverSig) tapscript {
    require(checkMultisig([user, server], [userSig, serverSig], 2));
  }

  function exit(signature userSig) tapscript {
    require(older(exitDelay));
    require(checkSig(userSig, user));
  }
}

swap_want_btc.ark

pragma arkade ^0.1.0;

contract SwapWantBtc(
  // 32-byte taproot program of the user's script. The fill pays it on output 0.
  pubkey makerWP,
  // Sats. Output 0 must carry at least this much.
  int    wantAmount,
  // 32-byte x-only key of the user who funds the swap.
  pubkey user,
  // BIP68 sequence of the exit path. older() pushes it raw.
  int    exitDelay
) {
  function fulfill() {
    require(tx.outputs[0].value >= wantAmount);
    let recipient = tx.outputs[0].script;
    require(recipient.version == 1);
    require(recipient.program == makerWP);
  }

  function cancel(signature userSig, signature serverSig) tapscript {
    require(checkMultisig([user, server], [userSig, serverSig], 2));
  }

  function exit(signature userSig) tapscript {
    require(older(exitDelay));
    require(checkSig(userSig, user));
  }
}

arkadec swap_want_asset.ark -o swap_want_asset.json
arkadec swap_want_btc.ark -o swap_want_btc.json

An offer published with noExit: true has no exit leaf. Delete the exit function and the exitDelay parameter to compile that two-leaf contract. It derives a different address.

Constructor

Parameter	Bound as
`makerWP`	The 32-byte taproot program of the user’s receive script: the offer’s `makerPkScript` without its `5120` prefix.
`wantAmount`	Asset units in want-asset, sats in want-BTC.
`wantAssetTxid`	The wanted asset’s genesis txid, reversed from its display order. A txid in display order derives an address that nothing fills.
`wantAssetGroupIndex`	The wanted asset’s group index.
`user`	The user’s 32-byte x-only key, the offer’s `makerPublicKey`.
`exitDelay`	The operator’s `unilateralExitDelay` by default, as a BIP68 sequence: blocks below 512, seconds from 512 up. Encode it with `timelockToSequence`.

server is not a parameter. The client binds it to the operator key. The emulator key that cosigns fulfill is the per-network key pinned in @arkade-os/sdk, or the swap client’s emulatorPubkey override. The deposit side is not a parameter. The contract never inspects what it holds, so either program carries BTC, an asset, or an asset for an asset. The maker names are contract positions, not roles. They name the user who funds the swap (The maker Fields).

Functions

fulfill is a covenant. The operator and the emulator cosign it when every require passes, so it needs no signature from the user or the solver. Output 0 must pay makerWP as a version 1 taproot output, with at least wantAmount of the wanted asset or sats. Nothing else in the transaction is checked. cancel needs the user’s signature and no solver signature. It has no covenant and no timelock, so the deposit goes wherever the spend says. exit is the path if the operator is unavailable. After the deposit is unrolled onchain and exitDelay passes, the user alone signs. Neither fulfill nor cancel has a timelock, so the contract sets no fill deadline.

Fund the Swap

client.accept derives the contract and funds its address. The funding transaction carries the encoded offer in an extension packet of type 0x03, which is how solvers learn the terms.

in 0…  user's coins                 out 0  swap contract: the deposit (BTC, or a 330-sat carrier with the asset)
                                    out 1  user's change, when there is any
                                    out 2  extension: asset packet (when assets move), offer packet 0x03
                                    out 3  anchor

Fill

A solver spends the deposit with fulfill and brings its own coins in the same transaction. The deposit is input 0. The emulator packet carries one entry, for input 0.

in 0  swap contract  (fulfill)      out 0  makerWP: wantAmount sats (want-BTC), or 330 sats with wantAmount units (want-asset)
in 1… solver's coins                out 1  solver payout: the deposit, the solver's change, any surplus of the wanted asset
                                    out 2  extension: asset packet (when assets move), emulator packet (vin 0)
                                    out 3  anchor

With a sponsor, the sponsor’s coins follow the solver’s on the input side. The sponsor’s fare and change outputs sit between output 0 and the solver payout.

Cancel

The user spends the deposit with cancel and pays it back to the wallet’s own address. Any asset on the deposit moves to output 0 with it.

in 0  swap contract  (cancel)       out 0  user's address: the whole deposit, with its asset
                                    out 1  extension: asset packet (asset deposit only)
                                    out 2  anchor

A BTC deposit moves no asset and carries no extension, so the anchor is output 1.

Exit

exit is spendable only onchain, after a unilateral exit has published the deposit’s virtual output. It has no server key and no covenant.

in 0  swap contract  (exit, after exitDelay)   out 0  anywhere the user signs for

Witness: [userSig, script, controlBlock].

Sources

Asset Swaps: the lifecycle and the guarantees of this contract
offer.test.ts: the golden addresses and the artifact with exit

Understand Intents

Build with Intents

Earn Fees

Reference

Source

Constructor

Functions

Fund the Swap

Fill

Cancel

Exit

Sources

​Source

​Constructor

​Functions

​Fund the Swap

​Fill

​Cancel

​Exit

​Sources

Source

Constructor

Functions

Fund the Swap

Fill

Cancel

Exit

Sources