Developer Preview

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

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";

/** Relay and solver key from the published solver card. */
const transport = nostrRfqTransport({
  relays: ["wss://nostr.arkade.sh"],
  solverPubkey: "66422c952f8dcb96e4d0c3f049cd1e265b8461b916d9913c65c2494b64b4e3ce",
});

const invoice: InvoiceFacts = {
  raw: "lnbc...",
  paymentHash: "…64 hex…",
  amountSats: 10_000, // inside the current card bounds
  expiresAt: 1_800_000_900,
};

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

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

/** Funding accepts the quote. Fund the locally derived address. */
await wallet.send({ address: payment.address, amount: payment.fundAmount });

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 values are bigint.
const selected = findMarket(markets, BTC_ASSET_ID, usdAssetId);
if (!selected?.market) throw new Error("No market for this pair");

/** The solver card's feed and fee determine the client-calculated quote. */
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),
});

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