Lightning

pnpm add @arkade-os/sdk @arkade-os/swap @noble/curves nostr-tools

import { nostrRfqTransport } from "@arkade-os/swap/nostr";

// The developer-preview solver
const relays = ["wss://nostr.arkade.sh"];
const solverPubkey =
  "66422c952f8dcb96e4d0c3f049cd1e265b8461b916d9913c65c2494b64b4e3ce";

const transport = nostrRfqTransport({ relays, solverPubkey });

import { requestLightningSend, type InvoiceFacts } from "@arkade-os/swap";

const invoice: InvoiceFacts = {
  raw: bolt11,
  paymentHash: decoded.paymentHash,
  amountSats: decoded.amountSats,
  expiresAt: decoded.expiresAt,
};

const payment = await requestLightningSend(
  wallet,
  arkadeServerUrl,
  transport,
  { invoice },
);

if (payment.quote.pair !== "arkade:BTC->lightning:BTC") {
  throw new Error("quote pair mismatch");
}

const fundingTxid = await wallet.send({
  address: payment.address,
  // fundAmount is the quote's from_amount, and NOT the invoice amount —
  // the spread is the fee. Read the field, not the number.
  amount: payment.fundAmount,
});

import { contractSigner } from "@arkade-os/sdk";
import { refundIfUnresolved } from "@arkade-os/swap";

const outcome = await refundIfUnresolved(
  transport,
  wallet.arkProvider,
  wallet.indexerProvider,
  {
    rfqId: payment.rfqId,
    script: payment.script,
    sender: await contractSigner(wallet, payment.secrets.descriptor),
    // Optional on the quote type (absent when both endpoints use `arkade`);
    // always present on corridor quotes like this one.
    refundLocktime: payment.quote.refund_locktime!,
  },
);

import { requestLightningReceive } from "@arkade-os/swap";
import { secp256k1 } from "@noble/curves/secp256k1.js";

/** Discarded immediately: this wallet claims for itself, below. */
const sealingKey = secp256k1.getPublicKey(secp256k1.utils.randomSecretKey(), true);

const receive = await requestLightningReceive(wallet, arkadeServerUrl, transport, {
  amount: amountSats,
  amountSide: "to", // amountSats is what you receive; the payer is asked for more
  covclaimdPubkey: sealingKey,
  // Your BOLT11 decoder, applied to the solver's hold invoice — return the
  // same InvoiceFacts shape the send flow builds (raw, paymentHash,
  // amountSats, expiresAt). It rejects a wrong-network or expired invoice
  // before you show it to anyone.
  decodeInvoice,
});

import { ArkAddress, contractPreimage, contractSigner } from "@arkade-os/sdk";
import { awaitLockupFunding, pushClaim } from "@arkade-os/swap";

// The deadline gates the WAIT only. Once the lockup exists the claim races
// refund_locktime, and nothing here should shorten that.
const vtxos = await awaitLockupFunding(wallet.indexerProvider, receive.swapPkScript, {
  // Unix seconds — refund_locktime is a timestamp, not a block height.
  // Optional on the quote type; always present on corridor quotes.
  deadline: receive.quote.refund_locktime!,
});

const receiver = await contractSigner(wallet, receive.secrets.descriptor);
const preimage = await contractPreimage(wallet, receive.secrets.descriptor, {
  stored: receive.secrets.mustPersistPreimage ? receive.secrets.preimage : undefined,
  salt: receive.secrets.preimageSalt,
});

const { arkTxid } = await pushClaim(wallet.arkProvider, {
  script: receive.script,
  receiver,
  preimage,
  vtxos,
  destinationPkScript: ArkAddress.decode(receive.payoutAddress).pkScript,
  // The quote's to_amount, captured at request time. The claim refuses a
  // short-funded lockup rather than publish the preimage for less than the
  // swap owes — leaving it to refund the payer instead, which is correct.
  expectedAmount: receive.quote.to_amount,
});