@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/types/repositories/sqlite/contractRepository.d.ts

@@ -1,33 +0,0 @@
-import { Contract } from "../../contracts/types.js";
-import { ContractFilter, ContractRepository } from "../contractRepository.js";
-import { SQLExecutor } from "./types.js";
-interface SQLiteContractRepositoryOptions {
-    /** Table name prefix (default: "ark_") */
-    prefix?: string;
-}
-/**
- * SQLite-based implementation of ContractRepository.
- *
- * Uses the SQLExecutor interface so consumers can plug in any SQLite driver
- * (expo-sqlite, better-sqlite3, etc.).
- *
- * Tables are created lazily on first operation via `ensureInit()`.
- * The consumer owns the SQLExecutor lifecycle — `[Symbol.asyncDispose]` is a no-op.
- */
-export declare class SQLiteContractRepository implements ContractRepository {
-    private readonly db;
-    readonly version: 1;
-    private initPromise;
-    private readonly prefix;
-    private readonly table;
-    constructor(db: SQLExecutor, options?: SQLiteContractRepositoryOptions);
-    private ensureInit;
-    private init;
-    [Symbol.asyncDispose](): Promise<void>;
-    clear(): Promise<void>;
-    getContracts(filter?: ContractFilter): Promise<Contract[]>;
-    saveContract(contract: Contract): Promise<void>;
-    deleteContract(script: string): Promise<void>;
-    private addFilterCondition;
-}
-export {};

package/dist/types/repositories/sqlite/index.d.ts

@@ -1,3 +0,0 @@
-export { SQLiteWalletRepository } from "./walletRepository.js";
-export { SQLiteContractRepository } from "./contractRepository.js";
-export type { SQLExecutor } from "./types.js";

package/dist/types/repositories/sqlite/types.d.ts

@@ -1,18 +0,0 @@
-/**
- * Minimal SQL execution interface that consumers implement
- * to connect their SQLite (or any SQL) database to the SDK.
- *
- * Example for expo-sqlite:
- * ```
- * const executor: SQLExecutor = {
- *   run: (sql, params) => db.runAsync(sql, params ?? []),
- *   get: (sql, params) => db.getFirstAsync(sql, params ?? []),
- *   all: (sql, params) => db.getAllAsync(sql, params ?? []),
- * };
- * ```
- */
-export interface SQLExecutor {
-    run(sql: string, params?: unknown[]): Promise<void>;
-    get<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T | undefined>;
-    all<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
-}

package/dist/types/repositories/walletRepository.d.ts

@@ -1,72 +0,0 @@
-import { ArkTransaction, ExtendedCoin, ExtendedVirtualCoin } from "../wallet/index.js";
-export interface WalletState {
-    /** Arbitrary stored wallet settings. */
-    settings?: Record<string, any>;
-    /**
-     * High-water mark for VTXO indexer syncs, in milliseconds.
-     *
-     * Reused the legacy `lastSyncTime` column name to avoid an
-     * `ALTER TABLE` migration; the value is interpreted as the new
-     * "max indexer `updatedAt`" cursor only after `settings.vtxoCursorMigrated`
-     * is set, so pre-existing values written by the buggy pre-PR sync
-     * are ignored and force a one-shot re-bootstrap on upgrade.
-     */
-    lastSyncTime?: number;
-}
-/** Stored commitment transaction metadata. */
-export type CommitmentTxRecord = {
-    /** Commitment transaction id. */
-    txid: string;
-    /** Creation timestamp in milliseconds. */
-    createdAt: number;
-};
-export interface VtxoRepositoryKey {
-    /** Authoritative ownership key. */
-    script: string;
-    /** Legacy storage bucket. Required by all current backends; throw if absent. */
-    address?: string;
-}
-export interface WalletRepository extends AsyncDisposable {
-    readonly version: 1;
-    /**
-     * Clear all data from storage.
-     */
-    clear(): Promise<void>;
-    /** Fetch stored virtual outputs for an address. */
-    getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
-    /** Save virtual outputs for an address. */
-    saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
-    /** Delete stored virtual outputs for an address. */
-    deleteVtxos(address: string): Promise<void>;
-    /**
-     * Fetch stored virtual outputs for a script.
-     * @optional SDK backends implement this; custom backends fall back to Tier 1.
-     */
-    getVtxosForScript?(script: string): Promise<ExtendedVirtualCoin[]>;
-    /**
-     * Save virtual outputs for a script.
-     * @optional SDK backends implement this; custom backends fall back to Tier 1.
-     */
-    saveVtxosForScript?(key: VtxoRepositoryKey, vtxos: ExtendedVirtualCoin[]): Promise<void>;
-    /**
-     * Delete stored virtual outputs for a script.
-     * @optional SDK backends implement this; custom backends fall back to Tier 1.
-     */
-    deleteVtxosForScript?(script: string): Promise<void>;
-    /** Fetch stored boarding inputs for an address. */
-    getUtxos(address: string): Promise<ExtendedCoin[]>;
-    /** Save boarding inputs for an address. */
-    saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
-    /** Delete stored boarding inputs for an address. */
-    deleteUtxos(address: string): Promise<void>;
-    /** Fetch stored transaction history for an address. */
-    getTransactionHistory(address: string): Promise<ArkTransaction[]>;
-    /** Save transaction history for an address. */
-    saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
-    /** Delete stored transaction history for an address. */
-    deleteTransactions(address: string): Promise<void>;
-    /** Fetch stored wallet state. */
-    getWalletState(): Promise<WalletState | null>;
-    /** Save wallet state. */
-    saveWalletState(state: WalletState): Promise<void>;
-}

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

@@ -1,67 +0,0 @@
-import { Bytes } from "@scure/btc-signer/utils.js";
-/**
- * ArkAddress allows creating and decoding bech32m-encoded Arkade addresses.
- *
- * An Arkade address is composed of:
- * - a human readable prefix (hrp)
- * - a version byte (1 byte)
- * - a server public key (32 bytes)
- * - a vtxo taproot public key (32 bytes)
- *
- * @remarks
- * This is an Arkade-specific address format.
- * It is distinct from the Taproot onchain address returned by `VtxoScript.onchainAddress`.
- *
- * @see VtxoScript
- *
- * @example
- * ```typescript
- * const address = new ArkAddress(
- *     new Uint8Array(32), // server public key
- *     new Uint8Array(32), // vtxo taproot public key
- *     "ark"
- * );
- *
- * const encoded = address.encode();
- * console.log("address: ", encoded);
- *
- * const decoded = ArkAddress.decode(encoded);
- * ```
- */
-export declare class ArkAddress {
-    readonly serverPubKey: Bytes;
-    readonly vtxoTaprootKey: Bytes;
-    readonly hrp: string;
-    readonly version: number;
-    /**
-     * Create an Arkade address from its server public key, Taproot output key, and prefix.
-     *
-     * @param serverPubKey - 32-byte Arkade server public key
-     * @param vtxoTaprootKey - 32-byte Taproot output key (a.k.a. tweaked public key)
-     * @param hrp - Bech32 human-readable prefix
-     * @param version - Address version byte
-     * @defaultValue `version = 0`
-     * @throws Error if either public key is not 32 bytes long
-     */
-    constructor(serverPubKey: Bytes, vtxoTaprootKey: Bytes, hrp?: string, version?: number);
-    /**
-     * Decode an Arkade address from its bech32m string form.
-     *
-     * @param address - Bech32m-encoded Arkade address
-     * @returns Decoded Arkade address
-     * @throws Error if the address is malformed or has an invalid payload length
-     * @see encode
-     */
-    static decode(address: string): ArkAddress;
-    /**
-     * Encode the address to its bech32m string form.
-     *
-     * @returns Bech32m-encoded Arkade address
-     * @see decode
-     */
-    encode(): string;
-    /** ScriptPubKey used to send non-dust funds to the address. */
-    get pkScript(): Bytes;
-    /** ScriptPubKey used to send sub-dust funds to the address. */
-    get subdustPkScript(): Bytes;
-}

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

@@ -1,105 +0,0 @@
-import { NETWORK } from "@scure/btc-signer";
-import { PSBTOutput } from "@scure/btc-signer/psbt.js";
-import { Bytes } from "@scure/btc-signer/utils.js";
-import { ArkAddress } from "./address.js";
-import { ConditionCSVMultisigTapscript, CSVMultisigTapscript } from "./tapscript.js";
-export type TapLeafScript = [
-    {
-        version: number;
-        internalKey: Bytes;
-        merklePath: Bytes[];
-    },
-    Bytes
-];
-export declare const TapTreeCoder: (typeof PSBTOutput.tapTree)[2];
-export declare function scriptFromTapLeafScript(leaf: TapLeafScript): Bytes;
-/**
- * VtxoScript is a script that contains a list of tapleaf scripts.
- * It is used to create virtual output scripts.
- *
- * @see ArkAddress
- *
- * @example
- * ```typescript
- * const vtxoScript = new VtxoScript([new Uint8Array(32), new Uint8Array(32)]);
- * ```
- */
-export declare class VtxoScript {
-    readonly scripts: Bytes[];
-    readonly leaves: TapLeafScript[];
-    readonly tweakedPublicKey: Bytes;
-    /**
-     * Decode a virtual output script from an encoded TapTree.
-     *
-     * @param tapTree - Encoded TapTree bytes
-     * @returns Decoded virtual output script
-     * @throws Error if the TapTree cannot be decoded into a valid script set
-     * @see encode
-     */
-    static decode(tapTree: Bytes): VtxoScript;
-    /**
-     * Create a virtual output script from its tapleaf scripts.
-     *
-     * @param scripts - Raw tapscript bytes for each leaf
-     * @throws Error if the provided leaves cannot produce a valid Taproot tree
-     */
-    constructor(scripts: Bytes[]);
-    /**
-     * Encode the virtual output script to a TapTree byte representation.
-     *
-     * @returns Encoded TapTree bytes
-     * @see decode
-     */
-    encode(): Bytes;
-    /**
-     * Build the Arkade address corresponding to this virtual output script.
-     *
-     * @param prefix - Bech32 human-readable prefix
-     * @param serverPubKey - 32-byte Arkade server public key
-     * @returns Arkade address for this script
-     * @see ArkAddress
-     */
-    address(prefix: string, serverPubKey: Bytes): ArkAddress;
-    get pkScript(): Bytes;
-    /**
-     * Build the Taproot onchain address corresponding to this virtual output script.
-     *
-     * @param network - Bitcoin network descriptor
-     * @returns Taproot onchain address
-     * @see address
-     */
-    onchainAddress(network: typeof NETWORK): string;
-    /**
-     * Look up a tapleaf script by its hex-encoded tapscript body.
-     *
-     * @param scriptHex - Hex-encoded tapscript body without the leaf version byte
-     * @returns Matching tapleaf script
-     * @throws Error if no matching leaf exists
-     */
-    findLeaf(scriptHex: string): TapLeafScript;
-    /**
-     * Return all unilateral exit paths embedded in the virtual output script.
-     *
-     * @returns CSV-based exit paths found in the leaves
-     * @see getSequence
-     */
-    exitPaths(): Array<CSVMultisigTapscript.Type | ConditionCSVMultisigTapscript.Type>;
-}
-export type EncodedVtxoScript = {
-    tapTree: Bytes;
-};
-/**
- * Extract the timelock value encoded in a timelocked tapleaf, if any.
- *
- * The return value is unit-ambiguous: for a CSV leaf it is a BIP-68
- * nSequence (relative timelock); for a CLTV leaf it is an absolute
- * nLockTime. Callers must know which leaf shape they are inspecting to
- * interpret the number correctly, and must not copy a CSV result into
- * `Transaction.lockTime` (or vice versa).
- *
- * @param tapLeafScript - Tapleaf script to inspect
- * @returns The encoded timelock value, or `undefined` when neither a CSV
- *          nor CLTV path is present
- * @see VtxoScript.exitPaths
- */
-export declare function getSequence(tapLeafScript: TapLeafScript): number | undefined;

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

@@ -1,44 +0,0 @@
-import { Bytes } from "@scure/btc-signer/utils.js";
-import { TapLeafScript, VtxoScript } from "./base.js";
-import { RelativeTimelock } from "./tapscript.js";
-/**
- * DefaultVtxo is the default implementation of a VtxoScript.
- * It contains 1 forfeit path and 1 exit path.
- * - forfeit = (Alice + Server)
- * - exit = (Alice) after csvTimelock
- */
-export declare namespace DefaultVtxo {
-    /**
-     * Options is the options for the DefaultVtxo.Script class.
-     * csvTimelock is the exit path timelock, default is 144 blocks (1 day).
-     */
-    interface Options {
-        pubKey: Bytes;
-        serverPubKey: Bytes;
-        csvTimelock?: RelativeTimelock;
-    }
-    /**
-     * DefaultVtxo.Script is the class letting to create the vtxo script.
-     * @example
-     * ```typescript
-     * const vtxoScript = new DefaultVtxo.Script({
-     *     pubKey: new Uint8Array(32),
-     *     serverPubKey: new Uint8Array(32),
-     * });
-     *
-     * console.log("script pub key:", vtxoScript.pkScript)
-     * ```
-     */
-    class Script extends VtxoScript {
-        readonly options: Options;
-        static readonly DEFAULT_TIMELOCK: RelativeTimelock;
-        readonly forfeitScript: string;
-        readonly exitScript: string;
-        /** Create the default virtual output script with one forfeit path and one exit path. */
-        constructor(options: Options);
-        /** Return the forfeit tapleaf script. */
-        forfeit(): TapLeafScript;
-        /** Return the unilateral exit tapleaf script. */
-        exit(): TapLeafScript;
-    }
-}

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

@@ -1,40 +0,0 @@
-import { Bytes } from "@scure/btc-signer/utils.js";
-import { DefaultVtxo } from "./default.js";
-import { TapLeafScript, VtxoScript } from "./base.js";
-/**
- * DelegateVtxo extends DefaultVtxo with an extra delegator path
- */
-export declare namespace DelegateVtxo {
-    /**
-     * Options extends DefaultVtxo.Options and adds a delegatePubKey
-     */
-    interface Options extends DefaultVtxo.Options {
-        delegatePubKey: Bytes;
-    }
-    /**
-     * DelegateVtxo.Script extends DefaultVtxo.Script and adds a delegate path.
-     * @example
-     * ```typescript
-     * const vtxoScript = new DelegateVtxo.Script({
-     *     pubKey: new Uint8Array(32),
-     *     serverPubKey: new Uint8Array(32),
-     *     delegatePubKey: new Uint8Array(32),
-     * });
-     *
-     * console.log("script pub key:", vtxoScript.pkScript)
-     * ```
-     */
-    class Script extends VtxoScript {
-        readonly options: Options;
-        readonly defaultVtxo: DefaultVtxo.Script;
-        readonly delegateScript: string;
-        /** Create a delegated virtual output script with forfeit, exit, and delegate paths. */
-        constructor(options: Options);
-        /** Return the forfeit tapleaf script. */
-        forfeit(): TapLeafScript;
-        /** Return the unilateral exit tapleaf script. */
-        exit(): TapLeafScript;
-        /** Return the delegate tapleaf script. */
-        delegate(): TapLeafScript;
-    }
-}

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

@@ -1,169 +0,0 @@
-import { Bytes } from "@scure/btc-signer/utils.js";
-/**
- * RelativeTimelock lets to create timelocked with CHECKSEQUENCEVERIFY script.
- *
- * @example
- * ```typescript
- * const timelock = { value: 144n, type: "blocks" }; // 1 day in blocks
- * const timelock = { value: 512n, type: "seconds" }; // 8 minutes in seconds
- * ```
- */
-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"
-}
-/**
- * ArkTapscript is the base element of vtxo scripts.
- * It is used to encode and decode the different types of vtxo scripts.
- */
-export interface ArkTapscript<T extends TapscriptType, Params> {
-    type: T;
-    params: Params;
-    script: Uint8Array;
-}
-/**
- * decodeTapscript is a function that decodes an Arkade tapscript from a raw script.
- *
- * @throws {Error} if the script is not a valid Arkade tapscript
- * @example
- * ```typescript
- * const arkTapscript = decodeTapscript(new Uint8Array(32));
- * console.log("type:", arkTapscript.type);
- * ```
- */
-export declare function decodeTapscript(script: Uint8Array): ArkTapscript<TapscriptType, any>;
-/**
- * Implements a multi-signature tapscript.
- *
- * <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
- *
- * @example
- * ```typescript
- * const multisigTapscript = MultisigTapscript.encode({ pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
- * ```
- */
-export declare namespace MultisigTapscript {
-    type Type = ArkTapscript<TapscriptType.Multisig, Params>;
-    enum MultisigType {
-        CHECKSIG = 0,
-        CHECKSIGADD = 1
-    }
-    type Params = {
-        pubkeys: Bytes[];
-        type?: MultisigType;
-    };
-    /** Encode a plain multisig tapscript. */
-    function encode(params: Params): Type;
-    /** Decode a plain multisig tapscript from raw script bytes. */
-    function decode(script: Uint8Array): Type;
-    /** Return true when the tapscript is a plain multisig tapscript. */
-    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.
- *
- * <sequence> CHECKSEQUENCEVERIFY DROP <pubkey> CHECKSIG
- *
- * @example
- * ```typescript
- * const csvMultisigTapscript = CSVMultisigTapscript.encode({ timelock: { type: "blocks", value: 144 }, pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
- * ```
- */
-export declare namespace CSVMultisigTapscript {
-    type Type = ArkTapscript<TapscriptType.CSVMultisig, Params>;
-    type Params = {
-        timelock: RelativeTimelock;
-    } & MultisigTapscript.Params;
-    /** Encode a CSV multisig tapscript. */
-    function encode(params: Params): Type;
-    /** Decode a CSV multisig tapscript from raw script bytes. */
-    function decode(script: Uint8Array): Type;
-    /** Return true when the tapscript is a CSV multisig tapscript. */
-    function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
-    function isScriptValid(script: Uint8Array): true | Error;
-}
-/**
- * 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).
- *
- * <conditionScript> VERIFY <sequence> CHECKSEQUENCEVERIFY DROP <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
- *
- * @example
- * ```typescript
- * const conditionCSVMultisigTapscript = ConditionCSVMultisigTapscript.encode({ conditionScript: new Uint8Array(32), pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
- * ```
- */
-export declare namespace ConditionCSVMultisigTapscript {
-    type Type = ArkTapscript<TapscriptType.ConditionCSVMultisig, Params>;
-    type Params = {
-        conditionScript: Bytes;
-    } & CSVMultisigTapscript.Params;
-    /** Encode a condition + CSV multisig tapscript. */
-    function encode(params: Params): Type;
-    /** Decode a condition + CSV multisig tapscript from raw script bytes. */
-    function decode(script: Uint8Array): Type;
-    /** Return true when the tapscript is a condition + CSV multisig tapscript. */
-    function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
-    function isScriptValid(script: Uint8Array): true | Error;
-}
-/**
- * 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).
- *
- * <conditionScript> VERIFY <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
- *
- * @example
- * ```typescript
- * const conditionMultisigTapscript = ConditionMultisigTapscript.encode({ conditionScript: new Uint8Array(32), pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
- * ```
- */
-export declare namespace ConditionMultisigTapscript {
-    type Type = ArkTapscript<TapscriptType.ConditionMultisig, Params>;
-    type Params = {
-        conditionScript: Bytes;
-    } & MultisigTapscript.Params;
-    /** Encode a condition + multisig tapscript. */
-    function encode(params: Params): Type;
-    /** Decode a condition + multisig tapscript from raw script bytes. */
-    function decode(script: Uint8Array): Type;
-    /** Return true when the tapscript is a condition + multisig tapscript. */
-    function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
-    function isScriptValid(script: Uint8Array): true | Error;
-}
-/**
- * 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.
- *
- * <locktime> CHECKLOCKTIMEVERIFY DROP <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
- *
- * @example
- * ```typescript
- * const cltvMultisigTapscript = CLTVMultisigTapscript.encode({ absoluteTimelock: 144, pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
- * ```
- */
-export declare namespace CLTVMultisigTapscript {
-    type Type = ArkTapscript<TapscriptType.CLTVMultisig, Params>;
-    type Params = {
-        absoluteTimelock: bigint;
-    } & MultisigTapscript.Params;
-    /** Encode a CLTV multisig tapscript. */
-    function encode(params: Params): Type;
-    /** Decode a CLTV multisig tapscript from raw script bytes. */
-    function decode(script: Uint8Array): Type;
-    /** Return true when the tapscript is a CLTV multisig tapscript. */
-    function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
-    function isScriptValid(script: Uint8Array): true | Error;
-}

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

@@ -1,66 +0,0 @@
-import { Bytes } from "@scure/btc-signer/utils.js";
-import { RelativeTimelock } from "./tapscript.js";
-import { TapLeafScript, VtxoScript } from "./base.js";
-/** Virtual Hash Time Lock Contract (VHTLC) namespace. */
-export declare namespace VHTLC {
-    interface Options {
-        sender: Bytes;
-        receiver: Bytes;
-        server: Bytes;
-        preimageHash: Bytes;
-        refundLocktime: bigint;
-        unilateralClaimDelay: RelativeTimelock;
-        unilateralRefundDelay: RelativeTimelock;
-        unilateralRefundWithoutReceiverDelay: RelativeTimelock;
-    }
-    /**
-     * Virtual Hash Time Lock Contract (VHTLC) script implementation.
-     *
-     * VHTLC enables atomic swaps and conditional payments in the Arkade protocol.
-     * It provides multiple spending paths:
-     *
-     * - **claim**: Receiver can claim funds by revealing the preimage
-     * - **refund**: Sender and receiver can collaboratively refund
-     * - **refundWithoutReceiver**: Sender can refund after locktime expires
-     * - **unilateralClaim**: Receiver can claim unilaterally after delay
-     * - **unilateralRefund**: Sender and receiver can refund unilaterally after delay
-     * - **unilateralRefundWithoutReceiver**: Sender can refund unilaterally after delay
-     *
-     * @example
-     * ```typescript
-     * const vhtlc = new VHTLC.Script({
-     *   sender: alicePubKey,
-     *   receiver: bobPubKey,
-     *   server: serverPubKey,
-     *   preimageHash: hash160(secret),
-     *   refundLocktime: BigInt(chainTip + 10),
-     *   unilateralClaimDelay: { type: 'blocks', value: 100n },
-     *   unilateralRefundDelay: { type: 'blocks', value: 102n },
-     *   unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 103n }
-     * });
-     * ```
-     */
-    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;
-        /** Create a VHTLC script from the supplied participant keys, hash, and timelocks. */
-        constructor(options: Options);
-        /** Return the collaborative claim tapleaf script. */
-        claim(): TapLeafScript;
-        /** Return the collaborative refund tapleaf script. */
-        refund(): TapLeafScript;
-        /** Return the refund-without-receiver tapleaf script. */
-        refundWithoutReceiver(): TapLeafScript;
-        /** Return the unilateral claim tapleaf script. */
-        unilateralClaim(): TapLeafScript;
-        /** Return the unilateral refund tapleaf script. */
-        unilateralRefund(): TapLeafScript;
-        /** Return the unilateral refund-without-receiver tapleaf script. */
-        unilateralRefundWithoutReceiver(): TapLeafScript;
-    }
-}

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

@@ -1,37 +0,0 @@
-import * as musig2 from "../musig2/index.js";
-import { TxTree } from "./txTree.js";
-export declare const ErrMissingVtxoGraph: Error;
-export declare const ErrMissingAggregateKey: Error;
-export type Musig2PublicNonce = Pick<musig2.Nonces, "pubNonce">;
-export type TreeNonces = Map<string, Musig2PublicNonce>;
-export type TreePartialSigs = Map<string, musig2.PartialSig>;
-export interface SignerSession {
-    getPublicKey(): Promise<Uint8Array>;
-    init(tree: TxTree, scriptRoot: Uint8Array, rootInputAmount: bigint): Promise<void>;
-    getNonces(): Promise<TreeNonces>;
-    aggregatedNonces(txid: string, noncesByPubkey: TreeNonces): Promise<{
-        hasAllNonces: boolean;
-    }>;
-    sign(): Promise<TreePartialSigs>;
-}
-export declare class TreeSignerSession implements SignerSession {
-    private secretKey;
-    static NOT_INITIALIZED: Error;
-    private myNonces;
-    private aggregateNonces;
-    private graph;
-    private scriptRoot;
-    private rootSharedOutputAmount;
-    constructor(secretKey: Uint8Array);
-    static random(): TreeSignerSession;
-    init(tree: TxTree, scriptRoot: Uint8Array, rootInputAmount: bigint): Promise<void>;
-    getPublicKey(): Promise<Uint8Array>;
-    getNonces(): Promise<TreeNonces>;
-    aggregatedNonces(txid: string, noncesByPubkey: TreeNonces): Promise<{
-        hasAllNonces: boolean;
-    }>;
-    sign(): Promise<TreePartialSigs>;
-    private generateNonces;
-    private signPartial;
-}
-export declare function validateTreeSigs(finalAggregatedKey: Uint8Array, sharedOutputAmount: bigint, vtxoTree: TxTree): Promise<void>;