@secondts/bark 0.6.3

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 The Bark Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+![bark: Ark on bitcoin](https://gitlab.com/ark-bitcoin/bark-ffi-bindings/-/raw/master/wasm/assets/bark-header-white.jpg)
+
+<div align="center">
+  <h1>bark</h1>
+  <p>WebAssembly bindings for Bark</p>
+</div>
+
+<br />
+
+Bark is an implementation of the Ark protocol on bitcoin, led by [Second](https://second.tech). The Ark protocol is a bitcoin layer 2 for making fast, low-cost, self-custodial payments at scale. Ark uses a client-server model to enable users to transact off-chain while still being able to "exit" their balances on-chain at any time.
+
+Runs in the browser via WebAssembly with IndexedDB persistence.
+
+## Installation
+
+```bash
+npm install @secondts/bark
+```
+
+### Bundlers (webpack, Rollup, Vite, Next.js, React, Vue, Svelte)
+
+The default entrypoint is the wasm-bindgen `bundler` target. Your bundler discovers the `.wasm` file via `new URL(..., import.meta.url)` and bundles it.
+
+```js
+import init, { Wallet, generateMnemonic } from "@secondts/bark";
+
+await init?.();
+
+const mnemonic = generateMnemonic();
+const wallet = await Wallet.create(mnemonic, config, "wallet-db");
+```
+
+### Vanilla browser (`<script type="module">`)
+
+Use the `./web` subpath. Pass the `.wasm` URL to `init()` explicitly (or let it auto-resolve via `import.meta.url`).
+
+```html
+<script type="module">
+  import init, { Wallet, generateMnemonic } from "https://unpkg.com/@secondts/bark/web/bark_ffi_wasm.js";
+  await init();
+
+  const mnemonic = generateMnemonic();
+</script>
+```
+
+## Notes
+
+- Persistence uses IndexedDB; the wallet is keyed by the name passed to `Wallet.create(..., dbName)`.
+- WASM runs in the main thread by default. For heavy operations consider running it inside a Web Worker.
+- Crypto requires the page to be served over HTTPS (or `localhost`); `crypto.subtle` is only available in secure contexts.
+
+## License
+
+Released under the **MIT** license.

package/bundler/bark_ffi_wasm.d.ts

@@ -0,0 +1,481 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * The `ReadableStreamType` enum.
+ *
+ * *This API requires the following crate features to be activated: `ReadableStreamType`*
+ */
+
+export type ReadableStreamType = "bytes";
+/**
+ * A Bitcoin transaction outpoint (reference to a previous output)
+ */
+export interface OutPoint {
+    txid: string;
+    vout: number;
+}
+
+/**
+ * A Bitcoin transaction output destination
+ */
+export interface Destination {
+    address: string;
+    amountSats: number;
+}
+
+/**
+ * A VTXO that is being unilaterally exited
+ */
+export interface ExitVtxo {
+    vtxoId: string;
+    amountSats: number;
+    state: string;
+    isClaimable: boolean;
+}
+
+/**
+ * A notification event from the wallet
+ */
+export type WalletNotification = { type: "MovementCreated"; movement: Movement } | { type: "MovementUpdated"; movement: Movement } | { type: "ChannelLagging" };
+
+/**
+ * A pending round state
+ */
+export interface RoundState {
+    id: number;
+    /**
+     * Whether the round is ongoing
+     */
+    ongoing: boolean;
+}
+
+/**
+ * Claim transaction for exited funds
+ */
+export interface ExitClaimTransaction {
+    psbtBase64: string;
+    feeSats: number;
+}
+
+/**
+ * Detailed status of an exit transaction
+ */
+export interface ExitTransactionStatus {
+    vtxoId: string;
+    state: string;
+    history: string[] | undefined;
+    transactionCount: number;
+}
+
+/**
+ * Parameters for creating a CPFP (Child Pays For Parent) transaction
+ */
+export interface CpfpParams {
+    txHex: string;
+    feesType: string;
+    effectiveFeeRateSatPerVb: number;
+    currentPackageFeeSats: number | undefined;
+}
+
+/**
+ * Reference to a block in the blockchain
+ */
+export interface BlockRef {
+    height: number;
+    hash: string;
+}
+
+/**
+ * Status of an exit progression
+ */
+export interface ExitProgressStatus {
+    vtxoId: string;
+    state: string;
+    error: string | undefined;
+}
+
+export interface AddressWithIndex {
+    address: string;
+    index: number;
+}
+
+export interface ArkInfo {
+    network: Network;
+    serverPubkey: string;
+    roundIntervalSecs: number;
+    nbRoundNonces: number;
+    vtxoExitDelta: number;
+    vtxoExpiryDelta: number;
+    htlcSendExpiryDelta: number;
+    htlcExpiryDelta: number;
+    maxVtxoAmountSats: number | undefined;
+    requiredBoardConfirmations: number;
+    maxUserInvoiceCltvDelta: number;
+    minBoardAmountSats: number;
+    lnReceiveAntiDosRequired: boolean;
+    /**
+     * Fee schedule as JSON string (contains board, offboard, refresh, lightning fees)
+     */
+    feeScheduleJson: string;
+    /**
+     * Maximum exit depth (genesis chain length) allowed for a VTXO before the
+     * server refuses to cosign further OOR transactions spending it.
+     */
+    maxVtxoExitDepth: number;
+}
+
+export interface Balance {
+    spendableSats: number;
+    pendingInRoundSats: number;
+    pendingExitSats: number;
+    pendingLightningSendSats: number;
+    claimableLightningReceiveSats: number;
+    pendingBoardSats: number;
+}
+
+export interface Bolt11InvoiceArgs {
+    amountSats: number;
+    description?: string;
+}
+
+export interface CheckLightningPaymentArgs {
+    paymentHash: string;
+    wait: boolean;
+}
+
+export interface Config {
+    serverAddress: string;
+    serverAccessToken?: string;
+    esploraAddress?: string;
+    bitcoindAddress?: string;
+    bitcoindCookiefile?: string;
+    bitcoindUser?: string;
+    bitcoindPass?: string;
+    network: Network;
+    vtxoRefreshExpiryThreshold?: number;
+    vtxoExitMargin?: number;
+    htlcRecvClaimDelta?: number;
+    fallbackFeeRate?: number;
+    roundTxRequiredConfirmations?: number;
+    daemonSyncIntervalSecs?: number;
+    offboardRequiredConfirmations?: number;
+    daemonManualSync?: boolean;
+    lightningReceiveClaimRetries?: number;
+}
+
+export interface DrainExitsArgs {
+    vtxoIds: string[];
+    address: string;
+    feeRateSatPerVb?: number;
+}
+
+export interface FeeEstimate {
+    grossAmountSats: number;
+    feeSats: number;
+    netAmountSats: number;
+    vtxosSpent: string[];
+}
+
+export interface GetExitStatusArgs {
+    vtxoId: string;
+    includeHistory: boolean;
+    includeTransactions: boolean;
+}
+
+export interface LightningInvoice {
+    invoice: string;
+    paymentHash: string;
+    amountSats: number;
+}
+
+export interface LightningReceive {
+    paymentHash: string;
+    paymentPreimage: string;
+    invoice: string;
+    amountSats: number;
+    hasHtlcVtxos: boolean;
+    preimageRevealed: boolean;
+}
+
+export interface LightningSend {
+    invoice: string;
+    amountSats: number;
+    htlcVtxoCount: number;
+    preimage: string | undefined;
+}
+
+export interface Movement {
+    id: number;
+    status: string;
+    subsystemName: string;
+    subsystemKind: string;
+    metadataJson: string;
+    intendedBalanceSats: number;
+    effectiveBalanceSats: number;
+    offchainFeeSats: number;
+    sentToAddresses: string[];
+    receivedOnAddresses: string[];
+    inputVtxoIds: string[];
+    outputVtxoIds: string[];
+    exitedVtxoIds: string[];
+    createdAt: string;
+    updatedAt: string;
+    completedAt: string | undefined;
+}
+
+export interface OffboardResult {
+    roundId: string;
+}
+
+export interface OnchainBalance {
+    confirmedSats: number;
+    pendingSats: number;
+    totalSats: number;
+}
+
+export interface OnchainWalletDefaultArgs {
+    mnemonic: string;
+    config: Config;
+    dbName: string;
+}
+
+export interface PayLightningInvoiceArgs {
+    invoice: string;
+    amountSats?: number;
+}
+
+export interface PayLightningOfferArgs {
+    offer: string;
+    amountSats?: number;
+}
+
+export interface PendingBoard {
+    vtxoId: string;
+    amountSats: number;
+    txid: string;
+}
+
+export interface ProgressExitsArgs {
+    feeRateSatPerVb?: number;
+}
+
+export interface TryClaimAllLightningReceivesArgs {
+    wait: boolean;
+}
+
+export interface TryClaimLightningReceiveArgs {
+    paymentHash: string;
+    wait: boolean;
+}
+
+export interface Vtxo {
+    id: string;
+    amountSats: number;
+    expiryHeight: number;
+    kind: string;
+    state: string;
+    /**
+     * Genesis chain length. Compare against `ArkInfo.max_vtxo_exit_depth` to
+     * detect VTXOs nearing the server\'s OOR-cosign refusal threshold.
+     */
+    exitDepth: number;
+    /**
+     * Weight units of the unilateral exit transaction chain. Lets clients
+     * estimate exit cost without loading the full genesis.
+     */
+    exitTxWeightWu: number;
+}
+
+export interface WalletCreateArgs {
+    mnemonic: string;
+    config: Config;
+    dbName: string;
+    forceRescan: boolean;
+}
+
+export interface WalletOpenArgs {
+    mnemonic: string;
+    config: Config;
+    dbName: string;
+}
+
+export interface WalletProperties {
+    network: Network;
+    fingerprint: string;
+}
+
+export type Network = "Bitcoin" | "Testnet" | "Signet" | "Regtest";
+
+
+export class IntoUnderlyingByteSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableByteStreamController): Promise<any>;
+    start(controller: ReadableByteStreamController): void;
+    readonly autoAllocateChunkSize: number;
+    readonly type: ReadableStreamType;
+}
+
+export class IntoUnderlyingSink {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    abort(reason: any): Promise<any>;
+    close(): Promise<any>;
+    write(chunk: any): Promise<any>;
+}
+
+export class IntoUnderlyingSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableStreamDefaultController): Promise<any>;
+}
+
+/**
+ * Pull-based notification handle exposed to JS.
+ *
+ * Obtain via `wallet.notifications()`. Loop on `await notif.nextNotification()`.
+ * Each call to `wallet.notifications()` creates an independent stream — existing
+ * holders are unaffected.
+ *
+ * Single-consumer per holder: concurrent `nextNotification()` calls reject with
+ * an `Internal` error.
+ */
+export class NotificationHolder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Cancel the currently pending `nextNotification()` wait.
+     *
+     * Causes a blocked `nextNotification()` to resolve to `null`. Does NOT
+     * destroy the underlying stream — a subsequent call resumes normally.
+     */
+    cancelNextNotificationWait(): void;
+    /**
+     * Wait for the next wallet notification.
+     *
+     * Resolves to a `WalletNotification` object, or `null` if:
+     * - `cancelNextNotificationWait()` was called while pending, or
+     * - the wallet's notification source was shut down.
+     */
+    nextNotification(): Promise<WalletNotification | undefined>;
+}
+
+export class OnchainWallet {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    balance(): Promise<OnchainBalance>;
+    /**
+     * Open (or create) the onchain wallet against an IndexedDB-backed persister.
+     */
+    static default(args: OnchainWalletDefaultArgs): Promise<OnchainWallet>;
+    newAddress(): Promise<string>;
+    send(address: string, amountSats: number, feeRateSatPerVb: number): Promise<string>;
+    sync(): Promise<number>;
+}
+
+export class Wallet {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    allExitsClaimableAtHeight(): Promise<number | undefined>;
+    allVtxos(): Promise<Vtxo[]>;
+    arkInfo(): Promise<ArkInfo | undefined>;
+    balance(): Promise<Balance>;
+    boardAll(onchainWallet: OnchainWallet): Promise<PendingBoard>;
+    boardAmount(onchainWallet: OnchainWallet, amountSats: number): Promise<PendingBoard>;
+    bolt11Invoice(args: Bolt11InvoiceArgs): Promise<LightningInvoice>;
+    broadcastTx(txHex: string): Promise<string>;
+    cancelAllPendingRounds(): Promise<void>;
+    cancelLightningReceive(paymentHash: string): Promise<void>;
+    cancelPendingRound(roundId: number): Promise<void>;
+    checkLightningPayment(args: CheckLightningPaymentArgs): Promise<string | undefined>;
+    claimableLightningReceiveBalanceSats(): Promise<number>;
+    config(): Promise<Config>;
+    static create(args: WalletCreateArgs): Promise<Wallet>;
+    static createWithOnchain(onchainWallet: OnchainWallet, args: WalletCreateArgs): Promise<Wallet>;
+    drainExits(args: DrainExitsArgs): Promise<ExitClaimTransaction>;
+    estimateArkoorPaymentFee(amountSats: number): Promise<FeeEstimate>;
+    estimateBoardFee(amountSats: number): Promise<FeeEstimate>;
+    estimateLightningReceiveFee(amountSats: number): Promise<FeeEstimate>;
+    estimateLightningSendFee(amountSats: number): Promise<FeeEstimate>;
+    estimateOffboardAllFee(address: string): Promise<FeeEstimate>;
+    estimateOffboardFee(address: string, vtxoIds: string[]): Promise<FeeEstimate>;
+    estimateRefreshFee(vtxoIds: string[]): Promise<FeeEstimate>;
+    estimateSendOnchainFee(address: string, amountSats: number): Promise<FeeEstimate>;
+    fingerprint(): string;
+    getExitStatus(args: GetExitStatusArgs): Promise<ExitTransactionStatus | undefined>;
+    getExitVtxos(): Promise<ExitVtxo[]>;
+    getExpiringVtxos(thresholdBlocks: number): Promise<Vtxo[]>;
+    getFirstExpiringVtxoBlockheight(): Promise<number | undefined>;
+    getNextRequiredRefreshBlockheight(): Promise<number | undefined>;
+    getVtxoById(vtxoId: string): Promise<Vtxo>;
+    getVtxosToRefresh(): Promise<Vtxo[]>;
+    hasPendingExits(): Promise<boolean>;
+    history(): Promise<Movement[]>;
+    historyByPaymentMethod(paymentMethodType: string, paymentMethodValue: string): Promise<Movement[]>;
+    importVtxo(vtxoBase64: string): Promise<void>;
+    lightningReceiveStatus(paymentHash: string): Promise<LightningReceive | undefined>;
+    listClaimableExits(): Promise<ExitVtxo[]>;
+    mailboxAuthorization(): string;
+    mailboxIdentifier(): string;
+    maintenance(): Promise<void>;
+    maintenanceDelegated(): Promise<void>;
+    maintenanceRefresh(): Promise<string | undefined>;
+    maintenanceWithOnchain(onchainWallet: OnchainWallet): Promise<void>;
+    maintenanceWithOnchainDelegated(onchainWallet: OnchainWallet): Promise<void>;
+    maybeScheduleMaintenanceRefresh(): Promise<number | undefined>;
+    network(): Promise<Network>;
+    newAddress(): Promise<string>;
+    newAddressWithIndex(): Promise<AddressWithIndex>;
+    nextRoundStartTime(): Promise<number>;
+    notifications(): NotificationHolder;
+    offboardAll(bitcoinAddress: string): Promise<OffboardResult>;
+    offboardVtxos(vtxoIds: string[], bitcoinAddress: string): Promise<string>;
+    static open(args: WalletOpenArgs): Promise<Wallet>;
+    static openWithOnchain(onchainWallet: OnchainWallet, args: WalletOpenArgs): Promise<Wallet>;
+    payLightningInvoice(args: PayLightningInvoiceArgs): Promise<LightningSend>;
+    payLightningOffer(args: PayLightningOfferArgs): Promise<LightningSend>;
+    peekAddress(index: number): Promise<string>;
+    pendingBoardVtxos(): Promise<Vtxo[]>;
+    pendingBoards(): Promise<PendingBoard[]>;
+    pendingExitsTotalSats(): Promise<number>;
+    pendingLightningReceives(): Promise<LightningReceive[]>;
+    pendingLightningSendVtxos(): Promise<Vtxo[]>;
+    pendingLightningSends(): Promise<LightningSend[]>;
+    pendingRoundInputVtxos(): Promise<Vtxo[]>;
+    pendingRoundStates(): Promise<RoundState[]>;
+    progressExits(onchainWallet: OnchainWallet, args: ProgressExitsArgs): Promise<ExitProgressStatus[]>;
+    progressPendingRounds(): Promise<void>;
+    properties(): Promise<WalletProperties>;
+    refreshServer(): Promise<void>;
+    refreshVtxos(vtxoIds: string[]): Promise<string | undefined>;
+    refreshVtxosDelegated(vtxoIds: string[]): Promise<RoundState | undefined>;
+    sendArkoorPayment(arkAddress: string, amountSats: number): Promise<string>;
+    sendOnchain(address: string, amountSats: number): Promise<string>;
+    signExitClaimInputs(psbtBase64: string): Promise<string>;
+    spendableVtxos(): Promise<Vtxo[]>;
+    startExitForEntireWallet(): Promise<void>;
+    startExitForVtxos(vtxoIds: string[]): Promise<void>;
+    sync(): Promise<void>;
+    syncExits(onchainWallet: OnchainWallet): Promise<void>;
+    syncPendingBoards(): Promise<void>;
+    tryClaimAllLightningReceives(args: TryClaimAllLightningReceivesArgs): Promise<LightningReceive[]>;
+    tryClaimLightningReceive(args: TryClaimLightningReceiveArgs): Promise<void>;
+    validateArkoorAddress(address: string): Promise<boolean>;
+    vtxos(): Promise<Vtxo[]>;
+}
+
+export function extractTxFromPsbt(psbtBase64: string): string;
+
+export function generateMnemonic(): string;
+
+export function validateArkAddress(address: string): boolean;
+
+export function validateMnemonic(mnemonic: string): boolean;

package/bundler/bark_ffi_wasm.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./bark_ffi_wasm.d.ts" */
+import * as wasm from "./bark_ffi_wasm_bg.wasm";
+import { __wbg_set_wasm } from "./bark_ffi_wasm_bg.js";
+
+__wbg_set_wasm(wasm);
+
+export {
+    IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, NotificationHolder, OnchainWallet, Wallet, extractTxFromPsbt, generateMnemonic, validateArkAddress, validateMnemonic
+} from "./bark_ffi_wasm_bg.js";