@arkade-os/sdk 0.4.27 → 0.4.28

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

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

@@ -1,28 +0,0 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
-/**
- * TxTreeNode is a node of the tree.
- * It contains the transaction id, the transaction and the children.
- * any TxTree can be serialized as a list of TxTreeNode.
- */
-export type TxTreeNode = {
-    txid: string;
-    tx: string;
-    children: Record<number, string>;
-};
-/**
- * TxTree is a graph of bitcoin transactions.
- * It is used to represent batch tree created during settlement session
- */
-export declare class TxTree {
-    readonly root: Transaction;
-    readonly children: Map<number, TxTree>;
-    constructor(root: Transaction, children?: Map<number, TxTree>);
-    static create(chunks: TxTreeNode[]): TxTree;
-    nbOfNodes(): number;
-    validate(): void;
-    leaves(): Transaction[];
-    get txid(): string;
-    find(txid: string): TxTree | null;
-    update(txid: string, fn: (tx: Transaction) => void): void;
-    iterator(): Generator<TxTree, void, unknown>;
-}

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

@@ -1,15 +0,0 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
-import { TxTree } from "./txTree.js";
-export declare const ErrInvalidSettlementTx: (tx: string) => Error;
-export declare const ErrInvalidSettlementTxOutputs: Error;
-export declare const ErrEmptyTree: Error;
-export declare const ErrNumberOfInputs: Error;
-export declare const ErrWrongSettlementTxid: Error;
-export declare const ErrInvalidAmount: Error;
-export declare const ErrNoLeaves: Error;
-export declare const ErrInvalidTaprootScript: Error;
-export declare const ErrInvalidRoundTxOutputs: Error;
-export declare const ErrWrongCommitmentTxid: Error;
-export declare const ErrMissingCosignersPublicKeys: Error;
-export declare function validateConnectorsTxGraph(settlementTxB64: string, connectorsGraph: TxTree): void;
-export declare function validateVtxoTxGraph(graph: TxTree, roundTransaction: Transaction, sweepTapTreeRoot: Uint8Array): void;

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

@@ -1,19 +0,0 @@
-import { Transaction } from "@scure/btc-signer";
-import { TransactionInputUpdate } from "@scure/btc-signer/psbt.js";
-export declare const ANCHOR_VALUE = 0n;
-export declare const ANCHOR_PKSCRIPT: Uint8Array<ArrayBuffer>;
-/**
- * A zero-value anchor output.
- */
-export declare const P2A: {
-    script: Uint8Array<ArrayBuffer>;
-    amount: bigint;
-};
-/**
- * search for anchor in the given transaction.
- * @throws {Error} if the anchor is not found or has the wrong amount
- */
-export declare function findP2AOutput(tx: Transaction): TransactionInputUpdate;
-export interface AnchorBumper {
-    bumpP2A(parent: Transaction): Promise<[string, string]>;
-}

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

@@ -1,49 +0,0 @@
-import { TransactionOutput } from "@scure/btc-signer/psbt.js";
-import { ExtendedCoin, VirtualCoin } from "../wallet/index.js";
-import { RelativeTimelock } from "../script/tapscript.js";
-import { EncodedVtxoScript, TapLeafScript } from "../script/base.js";
-import { CSVMultisigTapscript } from "../script/tapscript.js";
-import { Transaction } from "./transaction.js";
-export type ArkTxInput = {
-    tapLeafScript: TapLeafScript;
-} & EncodedVtxoScript & Pick<VirtualCoin, "txid" | "vout" | "value">;
-export type OffchainTx = {
-    arkTx: Transaction;
-    checkpoints: Transaction[];
-};
-/**
- * Builds an offchain transaction with checkpoint transactions.
- *
- * Creates one checkpoint transaction per input and a virtual transaction that
- * combines all the checkpoints, sending to the specified outputs. This is the
- * core function for creating Arkade transactions.
- *
- * @param inputs - Array of virtual transaction inputs
- * @param outputs - Array of transaction outputs
- * @param serverUnrollScript - Server unroll script for checkpoint transactions
- * @returns Object containing the virtual transaction and checkpoint transactions
- */
-export declare function buildOffchainTx(inputs: ArkTxInput[], outputs: TransactionOutput[], serverUnrollScript: CSVMultisigTapscript.Type): OffchainTx;
-export declare function hasBoardingTxExpired(coin: ExtendedCoin, boardingTimelock: RelativeTimelock, chainTipHeight?: number): boolean;
-/**
- * Verify tapscript signatures on a transaction input
- * @param tx Transaction to verify
- * @param inputIndex Index of the input to verify
- * @param requiredSigners List of required signer pubkeys (hex encoded)
- * @param excludePubkeys List of pubkeys to exclude from verification (hex encoded, e.g., server key not yet signed)
- * @param allowedSighashTypes List of allowed sighash types (defaults to [SigHash.DEFAULT])
- * @throws Error if verification fails
- */
-export declare function verifyTapscriptSignatures(tx: Transaction, inputIndex: number, requiredSigners: string[], excludePubkeys?: string[], allowedSighashTypes?: number[]): void;
-/**
- * Merges the signed transaction with the original transaction
- * @param signedTx signed transaction
- * @param originalTx original transaction
- */
-export declare function combineTapscriptSigs(signedTx: Transaction, originalTx: Transaction): Transaction;
-/**
- * Validates if a given string is a valid Arkade address by attempting to decode it.
- * @param address The Arkade address to validate.
- * @returns True if the address is valid, false otherwise.
- */
-export declare function isValidArkAddress(address: string): boolean;

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

@@ -1,38 +0,0 @@
-/** Known BIP21 parameters including Arkade-specific extensions. */
-export interface BIP21Params {
-    address?: string;
-    amount?: number;
-    label?: string;
-    message?: string;
-    /** Optional Arkade address parameter. */
-    ark?: string;
-    /** Optional Silent Payment address parameter. */
-    sp?: string;
-    [key: string]: string | number | undefined;
-}
-/** Result returned by `BIP21.parse`. */
-export interface BIP21ParseResult {
-    originalString: string;
-    params: BIP21Params;
-}
-export declare enum BIP21Error {
-    INVALID_URI = "Invalid BIP21 URI",
-    INVALID_ADDRESS = "Invalid address"
-}
-export declare class BIP21 {
-    /**
-     * Create a BIP21 URI from the provided parameters.
-     *
-     * @param params - BIP21 parameters to encode
-     * @returns Encoded BIP21 URI
-     */
-    static create(params: BIP21Params): string;
-    /**
-     * Parse a BIP21 URI and return its decoded parameters.
-     *
-     * @param uri - BIP21 URI to parse
-     * @returns Parsed BIP21 URI data
-     * @throws Error if the URI does not start with the `bitcoin:` scheme
-     */
-    static parse(uri: string): BIP21ParseResult;
-}

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

@@ -1,60 +0,0 @@
-import { WalletRepository, WalletState } from "../repositories/walletRepository.js";
-/** Lag behind real-time to avoid racing with indexer writes. */
-export declare const SAFETY_LAG_MS = 30000;
-/** Overlap window so boundary virtual outputs are never missed. */
-export declare const OVERLAP_MS: number;
-/**
- * Atomically read, mutate, and persist wallet state.
- * All callers that modify wallet state should go through this helper
- * to avoid lost-update races between interleaved async operations.
- */
-export declare function updateWalletState(repo: WalletRepository, updater: (state: WalletState) => WalletState): Promise<void>;
-/**
- * Read the global high-water mark for VTXO indexer syncs.
- *
- * Returns `0` when:
- *  - the wallet has never been synced (bootstrap case), or
- *  - the stored `lastSyncTime` was written by pre-PR code and is not
- *    safe to reuse under the new semantics (see {@link CURSOR_MIGRATED_KEY}).
- */
-export declare function getSyncCursor(repo: WalletRepository): Promise<number>;
-/**
- * Advance the global cursor after a successful full-scope delta sync.
- *
- * Clamped with `Math.max` against the current value so concurrent syncs
- * that finish out of order can't rewind the cursor: `lastUpdatedAt` is
- * captured before each sync enters the `updateWalletState` mutex, and
- * the later-started sync would otherwise overwrite the earlier-captured
- * one with a smaller value. The legacy value is discarded on the first
- * advance if the migration marker is absent so pre-PR data doesn't
- * survive the upgrade.
- */
-export declare function advanceSyncCursor(repo: WalletRepository, lastUpdatedAt: number): Promise<void>;
-/**
- * Remove the sync cursor, forcing a full re-bootstrap on next sync.
- *
- * Also clears the migration marker so any stored `lastSyncTime` is
- * treated as untrusted on the next read.
- */
-export declare function clearSyncCursor(repo: WalletRepository): Promise<void>;
-/**
- * Compute the `after` lower-bound for a delta sync query.
- *
- * No upper bound (`before`) is applied to the query so that freshly
- * created virtual outputs are never excluded. The safety lag is applied only
- * when advancing the cursor (see @see cursorCutoff).
- */
-export declare function computeSyncWindow(cursor: number): {
-    after: number;
-};
-/**
- * The safe high-water mark for cursor advancement.
- * Lags behind real-time by @see SAFETY_LAG_MS so that virtual outputs still
- * being indexed are re-queried on the next sync.
- *
- * When `requestStartedAt` is provided the cutoff is frozen to the
- * request start rather than wall-clock at commit time, preventing
- * long-running paginated fetches from advancing the cursor past the
- * data they actually observed.
- */
-export declare function cursorCutoff(requestStartedAt?: number): number;

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

@@ -1,9 +0,0 @@
-import type { RelativeTimelock } from "../script/tapscript.js";
-/**
- * Convert RelativeTimelock to BIP68 sequence number.
- */
-export declare function timelockToSequence(timelock: RelativeTimelock): number;
-/**
- * Convert BIP68 sequence number back to RelativeTimelock.
- */
-export declare function sequenceToTimelock(sequence: number): RelativeTimelock;

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

@@ -1,13 +0,0 @@
-import { Transaction as BtcSignerTransaction } from "@scure/btc-signer";
-import { TxOpts } from "@scure/btc-signer/transaction.js";
-import { Bytes } from "@scure/btc-signer/utils.js";
-/**
- * Transaction is a wrapper around the @scure/btc-signer Transaction class.
- * It adds the Arkade protocol specific options to the transaction.
- */
-export declare class Transaction extends BtcSignerTransaction {
-    static ARK_TX_OPTS: TxOpts;
-    constructor(opts?: TxOpts);
-    static fromPSBT(psbt_: Bytes, opts?: TxOpts): Transaction;
-    static fromRaw(raw: Bytes, opts?: TxOpts): Transaction;
-}

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

@@ -1,15 +0,0 @@
-import { ArkTransaction, VirtualCoin } from "../wallet/index.js";
-type ExtendedArkTransaction = ArkTransaction & {
-    tag: "offchain" | "boarding" | "exit" | "batch";
-};
-/**
- * Builds the transaction history by analyzing virtual outputs, boarding transactions, and ignored commitments.
- * History is sorted from newest to oldest and is composed only of SENT and RECEIVED transactions.
- *
- * @param {VirtualCoin[]} vtxos - An array of virtual outputs representing the user's transactions and balances.
- * @param {ArkTransaction[]} allBoardingTxs - An array of boarding transactions to include in the history.
- * @param {Set<string>} commitmentsToIgnore - A set of commitment IDs that should be excluded from processing.
- * @return {ExtendedArkTransaction[]} A sorted array of extended Arkade transactions, representing the transaction history.
- */
-export declare function buildTransactionHistory(vtxos: VirtualCoin[], allBoardingTxs: ArkTransaction[], commitmentsToIgnore: Set<string>, getTxCreatedAt?: (txid: string) => Promise<number | undefined>): Promise<ExtendedArkTransaction[]>;
-export {};

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

@@ -1,40 +0,0 @@
-import { Network } from "../networks.js";
-export type VSize = {
-    value: bigint;
-    fee(feeRate: bigint): bigint;
-};
-export declare class TxWeightEstimator {
-    static readonly P2PKH_SCRIPT_SIG_SIZE: number;
-    static readonly INPUT_SIZE: number;
-    static readonly BASE_CONTROL_BLOCK_SIZE: number;
-    static readonly OUTPUT_SIZE: number;
-    static readonly P2WPKH_OUTPUT_SIZE: number;
-    static readonly BASE_TX_SIZE: number;
-    static readonly WITNESS_HEADER_SIZE = 2;
-    static readonly WITNESS_SCALE_FACTOR = 4;
-    static readonly P2TR_OUTPUT_SIZE: number;
-    hasWitness: boolean;
-    inputCount: number;
-    outputCount: number;
-    inputSize: number;
-    inputWitnessSize: number;
-    outputSize: number;
-    private constructor();
-    static create(): TxWeightEstimator;
-    addP2AInput(): TxWeightEstimator;
-    addKeySpendInput(isDefault?: boolean): TxWeightEstimator;
-    addP2PKHInput(): TxWeightEstimator;
-    addTapscriptInput(leafWitnessSize: number, leafScriptSize: number, leafControlBlockSize: number): TxWeightEstimator;
-    addP2WPKHOutput(): TxWeightEstimator;
-    addP2TROutput(): TxWeightEstimator;
-    /**
-     * Adds an output given a raw script.
-     * Cost = 8 bytes (amount) + varint(scriptLen) + scriptLen
-     */
-    addOutputScript(script: Uint8Array): TxWeightEstimator;
-    /**
-     * Adds an output by decoding the address to get the exact script size.
-     */
-    addOutputAddress(address: string, network: Network): TxWeightEstimator;
-    vsize(): VSize;
-}