@arkade-os/sdk 0.0.16

package/dist/types/arknote/index.d.ts

@@ -0,0 +1,17 @@
+export declare class ArkNoteData {
+    id: bigint;
+    value: number;
+    constructor(id: bigint, value: number);
+    encode(): Uint8Array;
+    static decode(data: Uint8Array): ArkNoteData;
+}
+export declare class ArkNote {
+    data: ArkNoteData;
+    signature: Uint8Array;
+    static readonly HRP = "arknote";
+    constructor(data: ArkNoteData, signature: Uint8Array);
+    encode(): Uint8Array;
+    static decode(data: Uint8Array): ArkNote;
+    static fromString(noteStr: string): ArkNote;
+    toString(): string;
+}

package/dist/types/forfeit.d.ts

@@ -0,0 +1,15 @@
+import { Transaction } from "@scure/btc-signer";
+import { Outpoint } from "./wallet";
+interface ForfeitTxParams {
+    connectorInput: Outpoint;
+    vtxoInput: Outpoint;
+    vtxoAmount: bigint;
+    connectorAmount: bigint;
+    feeAmount: bigint;
+    vtxoPkScript: Uint8Array;
+    connectorPkScript: Uint8Array;
+    serverPkScript: Uint8Array;
+    txLocktime?: number;
+}
+export declare function buildForfeitTx({ connectorInput, vtxoInput, vtxoAmount, connectorAmount, feeAmount, vtxoPkScript, connectorPkScript, serverPkScript, txLocktime, }: ForfeitTxParams): Transaction;
+export {};

package/dist/types/identity/inMemoryKey.d.ts

@@ -0,0 +1,12 @@
+import { Transaction } from "@scure/btc-signer";
+import { Identity } from ".";
+import { SignerSession } from "../tree/signingSession";
+export declare class InMemoryKey implements Identity {
+    private key;
+    private constructor();
+    static fromPrivateKey(privateKey: Uint8Array): InMemoryKey;
+    static fromHex(privateKeyHex: string): InMemoryKey;
+    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
+    xOnlyPublicKey(): Uint8Array;
+    signerSession(): SignerSession;
+}

package/dist/types/identity/index.d.ts

@@ -0,0 +1,7 @@
+import { Transaction } from "@scure/btc-signer";
+import { SignerSession } from "../tree/signingSession";
+export interface Identity {
+    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
+    xOnlyPublicKey(): Uint8Array;
+    signerSession(): SignerSession;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,22 @@
+import { InMemoryKey } from "./identity/inMemoryKey";
+import { Identity } from "./identity";
+import { ArkAddress } from "./script/address";
+import { VHTLC } from "./script/vhtlc";
+import { DefaultVtxo } from "./script/default";
+import { VtxoScript } from "./script/base";
+import { TxType, IWallet, WalletConfig, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, VtxoTaprootAddress, AddressInfo, TapscriptInfo, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, Addresses } from "./wallet/index";
+import { Wallet } from "./wallet/wallet";
+import { ServiceWorkerWallet } from "./wallet/serviceWorker/wallet";
+import { Worker } from "./wallet/serviceWorker/worker";
+import { Request } from "./wallet/serviceWorker/request";
+import { Response } from "./wallet/serviceWorker/response";
+import { ESPLORA_URL, EsploraProvider } from "./providers/onchain";
+import { RestArkProvider } from "./providers/ark";
+import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, TapscriptType } from "./script/tapscript";
+import { addConditionWitness, CONDITION_WITNESS_KEY_PREFIX, createVirtualTx } from "./utils/psbt";
+import { ArkNote, ArkNoteData } from "./arknote";
+import { IndexedDBVtxoRepository } from "./wallet/serviceWorker/db/vtxo/idb";
+import { VtxoRepository } from "./wallet/serviceWorker/db/vtxo";
+import { networks } from "./networks";
+export { Wallet, ServiceWorkerWallet, InMemoryKey, ESPLORA_URL, EsploraProvider, RestArkProvider, ArkAddress, DefaultVtxo, VtxoScript, VHTLC, TxType, Worker, Request, Response, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, addConditionWitness, CONDITION_WITNESS_KEY_PREFIX, createVirtualTx, ArkNote, ArkNoteData, networks, IndexedDBVtxoRepository, };
+export type { Identity, IWallet, WalletConfig, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, VtxoTaprootAddress, AddressInfo, Addresses, TapscriptInfo, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, VtxoRepository, };

package/dist/types/musig2/index.d.ts

@@ -0,0 +1,4 @@
+export type { Nonces } from "./nonces";
+export { generateNonces } from "./nonces";
+export { PartialSig, sign } from "./sign";
+export { aggregateKeys } from "./keys";

package/dist/types/musig2/keys.d.ts

@@ -0,0 +1,9 @@
+interface KeyAggOptions {
+    taprootTweak?: Uint8Array;
+}
+export interface AggregateKey {
+    preTweakedKey: Uint8Array;
+    finalKey: Uint8Array;
+}
+export declare function aggregateKeys(publicKeys: Uint8Array[], sort: boolean, options?: Partial<KeyAggOptions>): AggregateKey;
+export {};

package/dist/types/musig2/nonces.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MuSig2 nonce pair containing public and secret values.
+ * Public nonces are two compressed points (33 bytes each).
+ * Secret nonces are the corresponding private scalars plus pubkey.
+ */
+export type Nonces = {
+    pubNonce: Uint8Array;
+    secNonce: Uint8Array;
+};
+/**
+ * Generates a pair of public and secret nonces for MuSig2 signing
+ */
+export declare function generateNonces(publicKey: Uint8Array): Nonces;

package/dist/types/musig2/sign.d.ts

@@ -0,0 +1,27 @@
+export declare class PartialSignatureError extends Error {
+    constructor(message: string);
+}
+interface SignOptions {
+    sortKeys?: boolean;
+    taprootTweak?: Uint8Array;
+}
+export declare class PartialSig {
+    s: Uint8Array;
+    R: Uint8Array;
+    constructor(s: Uint8Array, R: Uint8Array);
+    /**
+     * Encodes the partial signature into bytes
+     * Returns a 32-byte array containing just the s value
+     */
+    encode(): Uint8Array;
+    /**
+     * Decodes a partial signature from bytes
+     * @param bytes - 32-byte array containing s value
+     */
+    static decode(bytes: Uint8Array): PartialSig;
+}
+/**
+ * Generates a MuSig2 partial signature
+ */
+export declare function sign(secNonce: Uint8Array, privateKey: Uint8Array, combinedNonce: Uint8Array, publicKeys: Uint8Array[], message: Uint8Array, options?: SignOptions): PartialSig;
+export {};

package/dist/types/networks.d.ts

@@ -0,0 +1,16 @@
+export type NetworkName = "bitcoin" | "testnet" | "signet" | "mutinynet" | "regtest";
+export interface Network {
+    hrp: string;
+    bech32: string;
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+}
+export declare const getNetwork: (network: NetworkName) => Network;
+export declare const networks: {
+    bitcoin: Network;
+    testnet: Network;
+    signet: Network;
+    mutinynet: Network;
+    regtest: Network;
+};

package/dist/types/providers/ark.d.ts

@@ -0,0 +1,126 @@
+import { TxTree } from "../tree/vtxoTree";
+import { Outpoint, VirtualCoin } from "../wallet";
+import { TreeNonces, TreePartialSigs } from "../tree/signingSession";
+export interface ArkEvent {
+    type: "vtxo_created" | "vtxo_spent" | "vtxo_swept" | "vtxo_expired";
+    data: {
+        txid?: string;
+        address?: string;
+        amount?: number;
+        roundTxid?: string;
+        expireAt?: number;
+    };
+}
+export type NoteInput = string;
+export type VtxoInput = {
+    outpoint: Outpoint;
+    tapscripts: string[];
+};
+export type Input = NoteInput | VtxoInput;
+export type Output = {
+    address: string;
+    amount: bigint;
+};
+export declare enum SettlementEventType {
+    Finalization = "finalization",
+    Finalized = "finalized",
+    Failed = "failed",
+    SigningStart = "signing_start",
+    SigningNoncesGenerated = "signing_nonces_generated"
+}
+export type FinalizationEvent = {
+    type: SettlementEventType.Finalization;
+    id: string;
+    roundTx: string;
+    vtxoTree: TxTree;
+    connectors: TxTree;
+    minRelayFeeRate: bigint;
+    connectorsIndex: Map<string, Outpoint>;
+};
+export type FinalizedEvent = {
+    type: SettlementEventType.Finalized;
+    id: string;
+    roundTxid: string;
+};
+export type FailedEvent = {
+    type: SettlementEventType.Failed;
+    id: string;
+    reason: string;
+};
+export type SigningStartEvent = {
+    type: SettlementEventType.SigningStart;
+    id: string;
+    cosignersPublicKeys: string[];
+    unsignedVtxoTree: TxTree;
+    unsignedSettlementTx: string;
+};
+export type SigningNoncesGeneratedEvent = {
+    type: SettlementEventType.SigningNoncesGenerated;
+    id: string;
+    treeNonces: TreeNonces;
+};
+export type SettlementEvent = FinalizationEvent | FinalizedEvent | FailedEvent | SigningStartEvent | SigningNoncesGeneratedEvent;
+export interface ArkInfo {
+    pubkey: string;
+    batchExpiry: bigint;
+    unilateralExitDelay: bigint;
+    roundInterval: bigint;
+    network: string;
+    dust: bigint;
+    boardingDescriptorTemplate: string;
+    vtxoDescriptorTemplates: string[];
+    forfeitAddress: string;
+    marketHour?: {
+        start: number;
+        end: number;
+    };
+}
+export interface ArkProvider {
+    getInfo(): Promise<ArkInfo>;
+    getVirtualCoins(address: string): Promise<{
+        spendableVtxos: VirtualCoin[];
+        spentVtxos: VirtualCoin[];
+    }>;
+    submitVirtualTx(psbtBase64: string): Promise<string>;
+    subscribeToEvents(callback: (event: ArkEvent) => void): Promise<() => void>;
+    registerInputsForNextRound(inputs: Input[]): Promise<{
+        requestId: string;
+    }>;
+    registerOutputsForNextRound(requestId: string, outputs: Output[], vtxoTreeSigningPublicKeys: string[], signAll?: boolean): Promise<void>;
+    submitTreeNonces(settlementID: string, pubkey: string, nonces: TreeNonces): Promise<void>;
+    submitTreeSignatures(settlementID: string, pubkey: string, signatures: TreePartialSigs): Promise<void>;
+    submitSignedForfeitTxs(signedForfeitTxs: string[], signedRoundTx?: string): Promise<void>;
+    ping(paymentID: string): Promise<void>;
+    getEventStream(signal: AbortSignal): AsyncIterableIterator<SettlementEvent>;
+    subscribeForAddress(address: string, abortSignal: AbortSignal): AsyncIterableIterator<{
+        newVtxos: VirtualCoin[];
+        spentVtxos: VirtualCoin[];
+    }>;
+}
+export declare class RestArkProvider implements ArkProvider {
+    serverUrl: string;
+    constructor(serverUrl: string);
+    getInfo(): Promise<ArkInfo>;
+    getVirtualCoins(address: string): Promise<{
+        spendableVtxos: VirtualCoin[];
+        spentVtxos: VirtualCoin[];
+    }>;
+    submitVirtualTx(psbtBase64: string): Promise<string>;
+    subscribeToEvents(callback: (event: ArkEvent) => void): Promise<() => void>;
+    registerInputsForNextRound(inputs: Input[]): Promise<{
+        requestId: string;
+    }>;
+    registerOutputsForNextRound(requestId: string, outputs: Output[], cosignersPublicKeys: string[], signingAll?: boolean): Promise<void>;
+    submitTreeNonces(settlementID: string, pubkey: string, nonces: TreeNonces): Promise<void>;
+    submitTreeSignatures(settlementID: string, pubkey: string, signatures: TreePartialSigs): Promise<void>;
+    submitSignedForfeitTxs(signedForfeitTxs: string[], signedRoundTx?: string): Promise<void>;
+    ping(requestId: string): Promise<void>;
+    getEventStream(signal: AbortSignal): AsyncIterableIterator<SettlementEvent>;
+    subscribeForAddress(address: string, abortSignal: AbortSignal): AsyncIterableIterator<{
+        newVtxos: VirtualCoin[];
+        spentVtxos: VirtualCoin[];
+    }>;
+    private toConnectorsIndex;
+    private toTxTree;
+    private parseSettlementEvent;
+}

package/dist/types/providers/onchain.d.ts

@@ -0,0 +1,36 @@
+import type { NetworkName } from "../networks";
+import { Coin } from "../wallet";
+export declare const ESPLORA_URL: Record<NetworkName, string>;
+export type ExplorerTransaction = {
+    txid: string;
+    vout: {
+        scriptpubkey_address: string;
+        value: bigint;
+    }[];
+    status: {
+        confirmed: boolean;
+        block_time: number;
+    };
+};
+export interface OnchainProvider {
+    getCoins(address: string): Promise<Coin[]>;
+    getFeeRate(): Promise<number>;
+    broadcastTransaction(txHex: string): Promise<string>;
+    getTxOutspends(txid: string): Promise<{
+        spent: boolean;
+        txid: string;
+    }[]>;
+    getTransactions(address: string): Promise<ExplorerTransaction[]>;
+}
+export declare class EsploraProvider implements OnchainProvider {
+    private baseUrl;
+    constructor(baseUrl: string);
+    getCoins(address: string): Promise<Coin[]>;
+    getFeeRate(): Promise<number>;
+    broadcastTransaction(txHex: string): Promise<string>;
+    getTxOutspends(txid: string): Promise<{
+        spent: boolean;
+        txid: string;
+    }[]>;
+    getTransactions(address: string): Promise<ExplorerTransaction[]>;
+}

package/dist/types/script/address.d.ts

@@ -0,0 +1,10 @@
+import { Bytes } from "@scure/btc-signer/utils";
+export declare class ArkAddress {
+    readonly serverPubKey: Bytes;
+    readonly tweakedPubKey: Bytes;
+    readonly hrp: string;
+    constructor(serverPubKey: Bytes, tweakedPubKey: Bytes, hrp: string);
+    static decode(address: string): ArkAddress;
+    encode(): string;
+    get pkScript(): Bytes;
+}

package/dist/types/script/base.d.ts

@@ -0,0 +1,26 @@
+import { BTC_NETWORK, Bytes } from "@scure/btc-signer/utils";
+import { ArkAddress } from "./address";
+export type TapLeafScript = [
+    {
+        version: number;
+        internalKey: Bytes;
+        merklePath: Bytes[];
+    },
+    Bytes
+];
+export declare function scriptFromTapLeafScript(leaf: TapLeafScript): Bytes;
+export declare class VtxoScript {
+    readonly scripts: Bytes[];
+    readonly leaves: TapLeafScript[];
+    readonly tweakedPublicKey: Bytes;
+    static decode(scripts: string[]): VtxoScript;
+    constructor(scripts: Bytes[]);
+    encode(): string[];
+    address(prefix: string, serverPubKey: Bytes): ArkAddress;
+    get pkScript(): Bytes;
+    onchainAddress(network: BTC_NETWORK): string;
+    findLeaf(scriptHex: string): TapLeafScript;
+}
+export type EncodedVtxoScript = {
+    scripts: ReturnType<VtxoScript["encode"]>;
+};

package/dist/types/script/default.d.ts

@@ -0,0 +1,19 @@
+import { Bytes } from "@scure/btc-signer/utils";
+import { TapLeafScript, VtxoScript } from "./base";
+import { RelativeTimelock } from "./tapscript";
+export declare namespace DefaultVtxo {
+    interface Options {
+        pubKey: Bytes;
+        serverPubKey: Bytes;
+        csvTimelock?: RelativeTimelock;
+    }
+    class Script extends VtxoScript {
+        readonly options: Options;
+        static readonly DEFAULT_TIMELOCK: RelativeTimelock;
+        readonly forfeitScript: string;
+        readonly exitScript: string;
+        constructor(options: Options);
+        forfeit(): TapLeafScript;
+        exit(): TapLeafScript;
+    }
+}

package/dist/types/script/tapscript.d.ts

@@ -0,0 +1,94 @@
+import { Bytes } from "@scure/btc-signer/utils";
+export type RelativeTimelock = {
+    value: bigint;
+    type: "seconds" | "blocks";
+};
+export declare enum TapscriptType {
+    Multisig = "multisig",
+    CSVMultisig = "csv-multisig",
+    ConditionCSVMultisig = "condition-csv-multisig",
+    ConditionMultisig = "condition-multisig",
+    CLTVMultisig = "cltv-multisig"
+}
+export interface ArkTapscript<T extends TapscriptType, Params, SizeArgs = never> {
+    type: T;
+    params: Params;
+    script: Uint8Array;
+    witnessSize(args: SizeArgs): number;
+}
+export declare function decodeTapscript(script: Uint8Array): ArkTapscript<TapscriptType, any, any | undefined>;
+/**
+ * Implements a multi-signature script that requires a threshold of signatures
+ * from the specified pubkeys.
+ */
+export declare namespace MultisigTapscript {
+    type Type = ArkTapscript<TapscriptType.Multisig, Params>;
+    enum MultisigType {
+        CHECKSIG = 0,
+        CHECKSIGADD = 1
+    }
+    type Params = {
+        pubkeys: Bytes[];
+        type?: MultisigType;
+    };
+    function encode(params: Params): Type;
+    function decode(script: Uint8Array): Type;
+    function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
+}
+/**
+ * Implements a relative timelock script that requires all specified pubkeys to sign
+ * after the relative timelock has expired. The timelock can be specified in blocks or seconds.
+ *
+ * This is the standard exit closure and it is also used for the sweep closure in vtxo trees.
+ */
+export declare namespace CSVMultisigTapscript {
+    type Type = ArkTapscript<TapscriptType.CSVMultisig, Params>;
+    type Params = {
+        timelock: RelativeTimelock;
+    } & MultisigTapscript.Params;
+    function encode(params: Params): Type;
+    function decode(script: Uint8Array): Type;
+    function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
+}
+/**
+ * Combines a condition script with an exit closure. The resulting script requires
+ * the condition to be met, followed by the standard exit closure requirements
+ * (timelock and signatures).
+ */
+export declare namespace ConditionCSVMultisigTapscript {
+    type Type = ArkTapscript<TapscriptType.ConditionCSVMultisig, Params>;
+    type Params = {
+        conditionScript: Bytes;
+    } & CSVMultisigTapscript.Params;
+    function encode(params: Params): Type;
+    function decode(script: Uint8Array): Type;
+    function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
+}
+/**
+ * Combines a condition script with a forfeit closure. The resulting script requires
+ * the condition to be met, followed by the standard forfeit closure requirements
+ * (multi-signature).
+ */
+export declare namespace ConditionMultisigTapscript {
+    type Type = ArkTapscript<TapscriptType.ConditionMultisig, Params>;
+    type Params = {
+        conditionScript: Bytes;
+    } & MultisigTapscript.Params;
+    function encode(params: Params): Type;
+    function decode(script: Uint8Array): Type;
+    function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
+}
+/**
+ * Implements an absolute timelock (CLTV) script combined with a forfeit closure.
+ * The script requires waiting until a specific block height/timestamp before the
+ * forfeit closure conditions can be met.
+ */
+export declare namespace CLTVMultisigTapscript {
+    type Type = ArkTapscript<TapscriptType.CLTVMultisig, Params>;
+    type Params = {
+        absoluteTimelock: bigint;
+    } & MultisigTapscript.Params;
+    function encode(params: Params): Type;
+    function decode(script: Uint8Array): Type;
+    function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
+}

package/dist/types/script/vhtlc.d.ts

@@ -0,0 +1,31 @@
+import { Bytes } from "@scure/btc-signer/utils";
+import { RelativeTimelock } from "./tapscript";
+import { TapLeafScript, VtxoScript } from "./base";
+export declare namespace VHTLC {
+    interface Options {
+        sender: Bytes;
+        receiver: Bytes;
+        server: Bytes;
+        preimageHash: Bytes;
+        refundLocktime: bigint;
+        unilateralClaimDelay: RelativeTimelock;
+        unilateralRefundDelay: RelativeTimelock;
+        unilateralRefundWithoutReceiverDelay: RelativeTimelock;
+    }
+    class Script extends VtxoScript {
+        readonly options: Options;
+        readonly claimScript: string;
+        readonly refundScript: string;
+        readonly refundWithoutReceiverScript: string;
+        readonly unilateralClaimScript: string;
+        readonly unilateralRefundScript: string;
+        readonly unilateralRefundWithoutReceiverScript: string;
+        constructor(options: Options);
+        claim(): TapLeafScript;
+        refund(): TapLeafScript;
+        refundWithoutReceiver(): TapLeafScript;
+        unilateralClaim(): TapLeafScript;
+        unilateralRefund(): TapLeafScript;
+        unilateralRefundWithoutReceiver(): TapLeafScript;
+    }
+}

package/dist/types/tree/signingSession.d.ts

@@ -0,0 +1,32 @@
+import * as musig2 from "../musig2";
+import { TxTree } from "./vtxoTree";
+export declare const ErrMissingVtxoTree: Error;
+export declare const ErrMissingAggregateKey: Error;
+export type TreeNonces = (Pick<musig2.Nonces, "pubNonce"> | null)[][];
+export type TreePartialSigs = (musig2.PartialSig | null)[][];
+export interface SignerSession {
+    getPublicKey(): Uint8Array;
+    init(tree: TxTree, scriptRoot: Uint8Array, rootInputAmount: bigint): void;
+    getNonces(): TreeNonces;
+    setAggregatedNonces(nonces: TreeNonces): void;
+    sign(): TreePartialSigs;
+}
+export declare class TreeSignerSession implements SignerSession {
+    private secretKey;
+    static NOT_INITIALIZED: Error;
+    private myNonces;
+    private aggregateNonces;
+    private tree;
+    private scriptRoot;
+    private rootSharedOutputAmount;
+    constructor(secretKey: Uint8Array);
+    static random(): TreeSignerSession;
+    init(tree: TxTree, scriptRoot: Uint8Array, rootInputAmount: bigint): void;
+    getPublicKey(): Uint8Array;
+    getNonces(): TreeNonces;
+    setAggregatedNonces(nonces: TreeNonces): void;
+    sign(): TreePartialSigs;
+    private generateNonces;
+    private signPartial;
+}
+export declare function validateTreeSigs(finalAggregatedKey: Uint8Array, sharedOutputAmount: bigint, vtxoTree: TxTree): Promise<void>;

package/dist/types/tree/validation.d.ts

@@ -0,0 +1,22 @@
+import { TxTree, TxTreeError } from "./vtxoTree";
+export declare const ErrInvalidSettlementTx: TxTreeError;
+export declare const ErrInvalidSettlementTxOutputs: TxTreeError;
+export declare const ErrEmptyTree: TxTreeError;
+export declare const ErrInvalidRootLevel: TxTreeError;
+export declare const ErrNumberOfInputs: TxTreeError;
+export declare const ErrWrongSettlementTxid: TxTreeError;
+export declare const ErrInvalidAmount: TxTreeError;
+export declare const ErrNoLeaves: TxTreeError;
+export declare const ErrNodeTxEmpty: TxTreeError;
+export declare const ErrNodeTxidEmpty: TxTreeError;
+export declare const ErrNodeParentTxidEmpty: TxTreeError;
+export declare const ErrNodeTxidDifferent: TxTreeError;
+export declare const ErrParentTxidInput: TxTreeError;
+export declare const ErrLeafChildren: TxTreeError;
+export declare const ErrInvalidTaprootScript: TxTreeError;
+export declare const ErrInternalKey: TxTreeError;
+export declare const ErrInvalidControlBlock: TxTreeError;
+export declare const ErrInvalidRootTransaction: TxTreeError;
+export declare const ErrInvalidNodeTransaction: TxTreeError;
+export declare function validateConnectorsTree(settlementTxB64: string, connectorsTree: TxTree): void;
+export declare function validateVtxoTree(settlementTx: string, vtxoTree: TxTree, sweepTapTreeRoot: Uint8Array): void;

package/dist/types/tree/vtxoTree.d.ts

@@ -0,0 +1,32 @@
+import { Transaction } from "@scure/btc-signer";
+import { RelativeTimelock } from "../script/tapscript";
+export interface TreeNode {
+    txid: string;
+    tx: string;
+    parentTxid: string;
+    leaf: boolean;
+}
+export declare class TxTreeError extends Error {
+    constructor(message: string);
+}
+export declare const ErrLeafNotFound: TxTreeError;
+export declare const ErrParentNotFound: TxTreeError;
+export declare class TxTree {
+    private tree;
+    constructor(tree: TreeNode[][]);
+    get levels(): TreeNode[][];
+    root(): TreeNode;
+    leaves(): TreeNode[];
+    children(nodeTxid: string): TreeNode[];
+    numberOfNodes(): number;
+    branch(vtxoTxid: string): TreeNode[];
+    private findParent;
+    validate(): void;
+}
+export declare function getVtxoTreeExpiry(input: {
+    unknown?: {
+        key: Uint8Array;
+        value: Uint8Array;
+    }[];
+}): RelativeTimelock | null;
+export declare function getCosignerKeys(tx: Transaction): Uint8Array[];

package/dist/types/utils/bip21.d.ts

@@ -0,0 +1,21 @@
+export interface BIP21Params {
+    address?: string;
+    amount?: number;
+    label?: string;
+    message?: string;
+    ark?: string;
+    sp?: string;
+    [key: string]: string | number | undefined;
+}
+export interface BIP21ParseResult {
+    originalString: string;
+    params: BIP21Params;
+}
+export declare enum BIP21Error {
+    INVALID_URI = "Invalid BIP21 URI",
+    INVALID_ADDRESS = "Invalid address"
+}
+export declare class BIP21 {
+    static create(params: BIP21Params): string;
+    static parse(uri: string): BIP21ParseResult;
+}

package/dist/types/utils/coinselect.d.ts

@@ -0,0 +1,21 @@
+import type { Coin, VirtualCoin } from "../wallet";
+/**
+ * Select coins to reach a target amount, prioritizing those closer to expiry
+ * @param coins List of coins to select from
+ * @param targetAmount Target amount to reach in satoshis
+ * @returns Selected coins and change amount, or null if insufficient funds
+ */
+export declare function selectCoins(coins: Coin[], targetAmount: number): {
+    inputs: Coin[] | null;
+    changeAmount: number;
+};
+/**
+ * Select virtual coins to reach a target amount, prioritizing those closer to expiry
+ * @param coins List of virtual coins to select from
+ * @param targetAmount Target amount to reach in satoshis
+ * @returns Selected coins and change amount, or null if insufficient funds
+ */
+export declare function selectVirtualCoins(coins: VirtualCoin[], targetAmount: number): {
+    inputs: VirtualCoin[] | null;
+    changeAmount: number;
+};

package/dist/types/utils/psbt.d.ts

@@ -0,0 +1,11 @@
+import { Transaction } from "@scure/btc-signer";
+import { VirtualCoin } from "../wallet";
+import { Output } from "../providers/ark";
+import { EncodedVtxoScript, TapLeafScript } from "../script/base";
+export declare const CONDITION_WITNESS_KEY_PREFIX: Uint8Array<ArrayBufferLike>;
+export declare const VTXO_TAPROOT_TREE_KEY_PREFIX: Uint8Array<ArrayBufferLike>;
+export declare function addVtxoTaprootTree(inIndex: number, tx: Transaction, scripts: Uint8Array[]): void;
+export declare function addConditionWitness(inIndex: number, tx: Transaction, witness: Uint8Array[]): void;
+export declare function createVirtualTx(inputs: ({
+    tapLeafScript: TapLeafScript;
+} & EncodedVtxoScript & Pick<VirtualCoin, "txid" | "vout" | "value">)[], outputs: Output[]): Transaction;

package/dist/types/utils/transactionHistory.d.ts

@@ -0,0 +1,2 @@
+import { ArkTransaction, VirtualCoin } from "../wallet";
+export declare function vtxosToTxs(spendable: VirtualCoin[], spent: VirtualCoin[], boardingRounds: Set<string>): ArkTransaction[];