Fixed-party

A fixed-party vault names its parties when you create it, so they are fixed in its address. This page builds an escrow on Mutinynet: a buyer funds it, and an oracle’s signature releases the funds to the seller, or a timeout returns them to the buyer. The contract is Escrow. For the one-owner case, a savings vault, see Your first contract.

Install

You need Rust 1.85 or newer and Node.js 22.13 or newer (below 27). Set type to module in package.json.

cargo install arkade-compiler --locked
pnpm add @arkade-os/sdk@^0.5.0

Why the escrow needs no signatures

complete and cancel are covenants: the operator and the emulator cosign them when every require passes. Anyone who can build a passing transaction can submit one. That is safe because the address pins each outcome’s outputs: complete must pay the seller’s script and cancel must pay the buyer’s. The submitter picks the moment, never the destination. The seller never signs, and the buyer signs once, when funding the address.

Compile the contract

Save Escrow as escrow.ark and compile it:

arkadec escrow.ark -o escrow.json

Before you run the scripts below:

Replace the three keys before you fund the escrow. The scripts use well-known test keys.
exit is the operator’s unilateralExitDelay, encoded in seconds with timelockToSequence. A raw delay binds as blocks, and the operator rejects a block-based exit leaf. It also rejects an exit delay below its minimum.
The scripts read unilateralExitDelay on each run, and the escrow address depends on it. If the operator changes its delay after you fund, the scripts derive another address and find no output. Pass the delay you funded with instead.
partyAScript and partyBScript are 32-byte witness programs (tweakedPublicKey). Spend outputs use the full pkScript.
timeoutAt is 1700000000, already past, so cancel works as soon as an output arrives.

Each spend path below has its own file.

Complete

complete pays the seller when the oracle signs. Fund the printed address with 12000 sats, then run the same file again. The seller receives 10000 sats. The buyer receives the rest.

complete.ts

import fs from "node:fs";
import { Arkade, arkade, DefaultVtxo, SingleKey, timelockToSequence } from "@arkade-os/sdk";

// MUTINYNET ONLY — these well-known keys are public secrets; replace them with real keys on mainnet.
const buyerKey = SingleKey.fromHex("0000000000000000000000000000000000000000000000000000000000000001");
const sellerKey = SingleKey.fromHex("0000000000000000000000000000000000000000000000000000000000000002");
const oracleKey = SingleKey.fromHex("0000000000000000000000000000000000000000000000000000000000000003");
const amount = 10_000n;
const timeoutAt = 1700000000n;

const client = await Arkade.connect({
  service: {
    serverUrl: "https://mutinynet.arkade.sh",
    emulatorUrl: "https://emulator.mutinynet.arkade.sh",
  },
  identity: buyerKey,
});
const { unilateralExitDelay } = await client.arkProvider.getInfo();
const exit = BigInt(timelockToSequence({ type: "seconds", value: unilateralExitDelay }));
const message = await sha256(new TextEncoder().encode("release-to-seller"));
const buyerVtxo = new DefaultVtxo.Script({
  pubKey: await buyerKey.xOnlyPublicKey(),
  serverPubKey: client.serverKey,
  csvTimelock: { type: "seconds", value: unilateralExitDelay },
});
const sellerVtxo = new DefaultVtxo.Script({
  pubKey: await sellerKey.xOnlyPublicKey(),
  serverPubKey: client.serverKey,
  csvTimelock: { type: "seconds", value: unilateralExitDelay },
});
const buyerAddress = buyerVtxo.address(client.network.hrp, client.serverKey);
const sellerAddress = sellerVtxo.address(client.network.hrp, client.serverKey);
const program = arkade.programFromArtifact(JSON.parse(fs.readFileSync("escrow.json", "utf8")));
const contract = client.contract(program, {
  partyAPk: await buyerKey.xOnlyPublicKey(),
  partyBPk: await sellerKey.xOnlyPublicKey(),
  oraclePk: await oracleKey.xOnlyPublicKey(),
  oracleMessageHash: await sha256(message),
  partyAScript: buyerVtxo.tweakedPublicKey,
  partyBScript: sellerVtxo.tweakedPublicKey,
  amount,
  timeoutAt,
  exit,
});

const [output] = await contract.getUtxos();
if (!output) {
  console.log(contract.address);
} else {
  const signature = await oracleKey.signMessage(message, "schnorr");
  const released = await contract.functions
    .complete(message, signature)
    .from(output)
    .to([
      { script: sellerAddress.pkScript, amount },
      { script: buyerAddress.pkScript, amount: BigInt(output.value) - amount },
    ])
    .send();
  console.log(released.txid);
}

async function sha256(bytes: Uint8Array): Promise<Uint8Array> {
  const copy = new ArrayBuffer(bytes.byteLength);
  new Uint8Array(copy).set(bytes);
  return new Uint8Array(await crypto.subtle.digest("SHA-256", copy));
}

node --experimental-strip-types complete.ts

Cancel

cancel returns the output to the buyer. Fund the printed address, then run the same file again.

cancel.ts

import fs from "node:fs";
import { Arkade, arkade, DefaultVtxo, SingleKey, timelockToSequence } from "@arkade-os/sdk";

// MUTINYNET ONLY — these well-known keys are public secrets; replace them with real keys on mainnet.
const buyerKey = SingleKey.fromHex("0000000000000000000000000000000000000000000000000000000000000001");
const sellerKey = SingleKey.fromHex("0000000000000000000000000000000000000000000000000000000000000002");
const oracleKey = SingleKey.fromHex("0000000000000000000000000000000000000000000000000000000000000003");
const amount = 10_000n;
const timeoutAt = 1700000000n;

const client = await Arkade.connect({
  service: {
    serverUrl: "https://mutinynet.arkade.sh",
    emulatorUrl: "https://emulator.mutinynet.arkade.sh",
  },
  identity: buyerKey,
});
const { unilateralExitDelay } = await client.arkProvider.getInfo();
const exit = BigInt(timelockToSequence({ type: "seconds", value: unilateralExitDelay }));
const message = await sha256(new TextEncoder().encode("release-to-seller"));
const buyerVtxo = new DefaultVtxo.Script({
  pubKey: await buyerKey.xOnlyPublicKey(),
  serverPubKey: client.serverKey,
  csvTimelock: { type: "seconds", value: unilateralExitDelay },
});
const sellerVtxo = new DefaultVtxo.Script({
  pubKey: await sellerKey.xOnlyPublicKey(),
  serverPubKey: client.serverKey,
  csvTimelock: { type: "seconds", value: unilateralExitDelay },
});
const buyerAddress = buyerVtxo.address(client.network.hrp, client.serverKey);
const program = arkade.programFromArtifact(JSON.parse(fs.readFileSync("escrow.json", "utf8")));
const contract = client.contract(program, {
  partyAPk: await buyerKey.xOnlyPublicKey(),
  partyBPk: await sellerKey.xOnlyPublicKey(),
  oraclePk: await oracleKey.xOnlyPublicKey(),
  oracleMessageHash: await sha256(message),
  partyAScript: buyerVtxo.tweakedPublicKey,
  partyBScript: sellerVtxo.tweakedPublicKey,
  amount,
  timeoutAt,
  exit,
});

const [output] = await contract.getUtxos();
if (!output) {
  console.log(contract.address);
} else {
  const refunded = await contract.functions
    .cancel()
    .from(output)
    .to(buyerAddress.pkScript, BigInt(output.value))
    .send();
  console.log(refunded.txid);
}

async function sha256(bytes: Uint8Array): Promise<Uint8Array> {
  const copy = new ArrayBuffer(bytes.byteLength);
  new Uint8Array(copy).set(bytes);
  return new Uint8Array(await crypto.subtle.digest("SHA-256", copy));
}

node --experimental-strip-types cancel.ts

Exit if the operator is unavailable

If the operator is unavailable, the parties can still claim the output onchain with unilateral. First unroll it: broadcast the virtual transactions that lead to it. After the output confirms and the exit delay passes, Bitcoin checks the leaf. Both parties sign, and the leaf does not check the outputs. This file pays a Bitcoin address with a 1000-sat fee. Set UNROLLED_TXID, UNROLLED_VOUT, UNROLLED_VALUE, and BITCOIN_ADDRESS to the unrolled output and the destination.

unilateral.ts

import fs from "node:fs";
import {
  Arkade,
  arkade,
  DefaultVtxo,
  EsploraProvider,
  SingleKey,
  Transaction,
  getSequence,
  timelockToSequence,
} from "@arkade-os/sdk";

// MUTINYNET ONLY — these well-known keys are public secrets; replace them with real keys on mainnet.
const buyerKey = SingleKey.fromHex("0000000000000000000000000000000000000000000000000000000000000001");
const sellerKey = SingleKey.fromHex("0000000000000000000000000000000000000000000000000000000000000002");
const oracleKey = SingleKey.fromHex("0000000000000000000000000000000000000000000000000000000000000003");
const amount = 10_000n;
const timeoutAt = 1700000000n;
const txid = process.env.UNROLLED_TXID;
const vout = process.env.UNROLLED_VOUT;
const value = process.env.UNROLLED_VALUE;
const address = process.env.BITCOIN_ADDRESS;
if (!txid || vout === undefined || !value || !address) {
  throw new Error("set UNROLLED_TXID, UNROLLED_VOUT, UNROLLED_VALUE, and BITCOIN_ADDRESS");
}

const client = await Arkade.connect({
  service: {
    serverUrl: "https://mutinynet.arkade.sh",
    emulatorUrl: "https://emulator.mutinynet.arkade.sh",
  },
  identity: buyerKey,
});
const { unilateralExitDelay } = await client.arkProvider.getInfo();
const exit = BigInt(timelockToSequence({ type: "seconds", value: unilateralExitDelay }));
const message = await sha256(new TextEncoder().encode("release-to-seller"));
const buyerVtxo = new DefaultVtxo.Script({
  pubKey: await buyerKey.xOnlyPublicKey(),
  serverPubKey: client.serverKey,
  csvTimelock: { type: "seconds", value: unilateralExitDelay },
});
const sellerVtxo = new DefaultVtxo.Script({
  pubKey: await sellerKey.xOnlyPublicKey(),
  serverPubKey: client.serverKey,
  csvTimelock: { type: "seconds", value: unilateralExitDelay },
});
const program = arkade.programFromArtifact(JSON.parse(fs.readFileSync("escrow.json", "utf8")));
const contract = client.contract(program, {
  partyAPk: await buyerKey.xOnlyPublicKey(),
  partyBPk: await sellerKey.xOnlyPublicKey(),
  oraclePk: await oracleKey.xOnlyPublicKey(),
  oracleMessageHash: await sha256(message),
  partyAScript: buyerVtxo.tweakedPublicKey,
  partyBScript: sellerVtxo.tweakedPublicKey,
  amount,
  timeoutAt,
  exit,
});

const names = Object.keys(contract.program.functions);
const leaf = contract.leafScript(names.indexOf("unilateral"));
const sequence = getSequence(leaf);
if (sequence === undefined) throw new Error("unilateral leaf has no CSV");
const sats = BigInt(value);
const tx = new Transaction({ version: 2 });
tx.addInput({
  txid,
  index: Number(vout),
  sequence,
  tapLeafScript: [leaf],
  witnessUtxo: { amount: sats, script: contract.pkScript },
});
tx.addOutputAddress(address, sats - 1000n, client.network);
let signed = tx;
for (const key of [buyerKey, sellerKey]) signed = await key.sign(signed, [0]);
signed.finalize();
const explorer = new EsploraProvider("https://mempool.mutinynet.arkade.sh/api");
console.log(await explorer.broadcastTransaction(signed.hex));

async function sha256(bytes: Uint8Array): Promise<Uint8Array> {
  const copy = new ArrayBuffer(bytes.byteLength);
  new Uint8Array(copy).set(bytes);
  return new Uint8Array(await crypto.subtle.digest("SHA-256", copy));
}

UNROLLED_TXID=<txid> UNROLLED_VOUT=<n> UNROLLED_VALUE=<sats> BITCOIN_ADDRESS=<bc1…> node --experimental-strip-types unilateral.ts

Understand

Reference

Install

Why the escrow needs no signatures

Compile the contract

Complete

Cancel

Exit if the operator is unavailable

​Install

​Why the escrow needs no signatures

​Compile the contract

​Complete

​Cancel

​Exit if the operator is unavailable

Install

Why the escrow needs no signatures

Compile the contract

Complete

Cancel

Exit if the operator is unavailable