Developer Preview

import {
  InMemoryContractRepository,
  InMemoryWalletRepository,
  MnemonicIdentity,
  RestArkProvider,
  Wallet,
} from "@arkade-os/sdk";

const OPERATOR_URL = "https://arkade.computer" as const;

const wallet = await Wallet.create({
  identity: MnemonicIdentity.fromMnemonic(process.env.ARKADE_SEED!),
  arkProvider: new RestArkProvider(OPERATOR_URL),
  settlementConfig: false,
  walletMode: "static",
  storage: {
    walletRepository: new InMemoryWalletRepository(),
    contractRepository: new InMemoryContractRepository(),
  },
});

console.log(await wallet.getAddress()); // fund this with BTC

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

/** The solver's rendezvous, taken from its published card. */
const transport = nostrRfqTransport({
  relays: ["wss://nostr.arkade.sh"],
  solverPubkey: "66422c952f8dcb96e4d0c3f049cd1e265b8461b916d9913c65c2494b64b4e3ce",
});

const invoice: InvoiceFacts = {
  raw: "lnbc...",
  paymentHash: "…64 hex…",
  amountSats: 10_000, // within the card's bounds — currently 500 to 50,000
  expiresAt: 1_800_000_900,
};

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

/** Funding is the acceptance. Fund your own derivation, never a quoted address. */
await wallet.send({ address: payment.address, amount: payment.fundAmount });

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

// The same Nostr transport as the send flow above.
const receive = await requestLightningReceive(wallet, OPERATOR_URL, transport, {
  amount: 1_000,
  amountSide: "to", // "to" is the amount you receive on Arkade
  // Claiming from this same wallet: nobody needs to read the claim packet,
  // so seal it to a throwaway key.
  covclaimdPubkey: secp256k1.getPublicKey(secp256k1.utils.randomSecretKey(), true),
  // Your BOLT11 decoder — the same InvoiceFacts shape as the send flow.
  decodeInvoice,
});

console.log(receive.invoice); // paying this invoice arms the swap

import {
  BTC_ASSET_ID,
  InMemoryAssetSwapRepository,
  createOffer,
  discoverMarkets,
  findMarket,
  makeCachedFeedFetch,
  validatePlan,
  QUOTE_OPTIONS,
} from "@arkade-os/swap";
import { quoteOffer } from "@arkade-os/solver-discovery";
import { asset } from "@arkade-os/sdk";

const swapRepository = new InMemoryAssetSwapRepository(); // use IndexedDb in browsers

const markets = await discoverMarkets({
  network: "bitcoin",
  registryUrl: "https://arkade-os.github.io/solver-registry/bitcoin.json",
  repository: swapRepository,
});

// usdAssetId is the asset id you are buying, from the market index;
// giveBalance is your settled balance and dustAmount the server's dust
// floor — both bigint.
const selected = findMarket(markets, BTC_ASSET_ID, usdAssetId);
if (!selected?.market) throw new Error("No market for this pair");

/** Priced from the solver's own feed and fee: a quote resolved client-side. */
const plan = await quoteOffer(selected.market, {
  give: selected.give,
  giveAmount: "0.001", // display units; only bigint is atomic
  ...QUOTE_OPTIONS,
  fetchImpl: makeCachedFeedFetch(),
});
if (validatePlan(plan, giveBalance, dustAmount)) throw new Error("Cannot fund");

const offer = await createOffer(wallet, OPERATOR_URL, {
  wantAmount: plan.receive.atomic,
  wantAsset: asset.AssetId.fromString(usdAssetId),
});

/** The extension is what makes the funded offer discoverable to solvers. */
await wallet.send({
  address: offer.address,
  amount: Number(plan.deposit.atomic),
  extensions: [offer.extension],
});