@arkade-os/sdk 0.1.4 → 0.2.0

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

@@ -1,11 +1,14 @@
 import type { NetworkName } from "../networks";
 import { Coin } from "../wallet";
+/**
+ * The default base URLs for esplora API providers.
+ */
 export declare const ESPLORA_URL: Record<NetworkName, string>;
 export type ExplorerTransaction = {
     txid: string;
     vout: {
         scriptpubkey_address: string;
-        value: bigint;
+        value: string;
     }[];
     status: {
         confirmed: boolean;
@@ -14,33 +17,60 @@ export type ExplorerTransaction = {
 };
 export interface OnchainProvider {
     getCoins(address: string): Promise<Coin[]>;
-    getFeeRate(): Promise<number>;
-    broadcastTransaction(txHex: string): Promise<string>;
+    getFeeRate(): Promise<number | undefined>;
+    broadcastTransaction(...txs: string[]): Promise<string>;
     getTxOutspends(txid: string): Promise<{
         spent: boolean;
         txid: string;
     }[]>;
     getTransactions(address: string): Promise<ExplorerTransaction[]>;
     getTxStatus(txid: string): Promise<{
-        confirmed: boolean;
-        blockTime?: number;
-        blockHeight?: number;
+        confirmed: false;
+    } | {
+        confirmed: true;
+        blockTime: number;
+        blockHeight: number;
+    }>;
+    getChainTip(): Promise<{
+        height: number;
+        time: number;
+        hash: string;
     }>;
+    watchAddresses(addresses: string[], eventCallback: (txs: ExplorerTransaction[]) => void): Promise<() => void>;
 }
+/**
+ * Implementation of the onchain provider interface for esplora REST API.
+ * @see https://mempool.space/docs/api/rest
+ * @example
+ * ```typescript
+ * const provider = new EsploraProvider("https://mempool.space/api");
+ * const utxos = await provider.getCoins("bcrt1q679zsd45msawvr7782r0twvmukns3drlstjt77");
+ * ```
+ */
 export declare class EsploraProvider implements OnchainProvider {
     private baseUrl;
     constructor(baseUrl: string);
     getCoins(address: string): Promise<Coin[]>;
-    getFeeRate(): Promise<number>;
-    broadcastTransaction(txHex: string): Promise<string>;
+    getFeeRate(): Promise<number | undefined>;
+    broadcastTransaction(...txs: string[]): Promise<string>;
     getTxOutspends(txid: string): Promise<{
         spent: boolean;
         txid: string;
     }[]>;
     getTransactions(address: string): Promise<ExplorerTransaction[]>;
     getTxStatus(txid: string): Promise<{
-        confirmed: boolean;
-        blockTime?: number;
-        blockHeight?: number;
+        confirmed: false;
+    } | {
+        confirmed: true;
+        blockTime: number;
+        blockHeight: number;
+    }>;
+    watchAddresses(addresses: string[], callback: (txs: ExplorerTransaction[]) => void): Promise<() => void>;
+    getChainTip(): Promise<{
+        height: number;
+        time: number;
+        hash: string;
     }>;
+    private broadcastPackage;
+    private broadcastTx;
 }

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

@@ -1,10 +1,34 @@
 import { Bytes } from "@scure/btc-signer/utils";
+/**
+ * ArkAddress allows to create and decode bech32m encoded ark address.
+ * An ark 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)
+ *
+ * @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 tweakedPubKey: Bytes;
+    readonly vtxoTaprootKey: Bytes;
     readonly hrp: string;
-    constructor(serverPubKey: Bytes, tweakedPubKey: Bytes, hrp: string);
+    readonly version: number;
+    constructor(serverPubKey: Bytes, vtxoTaprootKey: Bytes, hrp: string, version?: number);
     static decode(address: string): ArkAddress;
     encode(): string;
     get pkScript(): Bytes;
+    get subdustPkScript(): Bytes;
 }

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

@@ -1,5 +1,6 @@
 import { BTC_NETWORK, Bytes } from "@scure/btc-signer/utils";
 import { ArkAddress } from "./address";
+import { ConditionCSVMultisigTapscript, CSVMultisigTapscript } from "./tapscript";
 export type TapLeafScript = [
     {
         version: number;
@@ -9,18 +10,27 @@ export type TapLeafScript = [
     Bytes
 ];
 export declare function scriptFromTapLeafScript(leaf: TapLeafScript): Bytes;
+/**
+ * VtxoScript is a script that contains a list of tapleaf scripts.
+ * It is used to create vtxo scripts.
+ *
+ * @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;
-    static decode(scripts: string[]): VtxoScript;
+    static decode(tapTree: Bytes): VtxoScript;
     constructor(scripts: Bytes[]);
-    encode(): string[];
+    encode(): Bytes;
     address(prefix: string, serverPubKey: Bytes): ArkAddress;
     get pkScript(): Bytes;
     onchainAddress(network: BTC_NETWORK): string;
     findLeaf(scriptHex: string): TapLeafScript;
+    exitPaths(): Array<CSVMultisigTapscript.Type | ConditionCSVMultisigTapscript.Type>;
 }
 export type EncodedVtxoScript = {
-    scripts: ReturnType<VtxoScript["encode"]>;
+    tapTree: Bytes;
 };

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

@@ -1,12 +1,34 @@
 import { Bytes } from "@scure/btc-signer/utils";
 import { TapLeafScript, VtxoScript } from "./base";
 import { RelativeTimelock } from "./tapscript";
+/**
+ * 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;

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

@@ -1,4 +1,13 @@
 import { Bytes } from "@scure/btc-signer/utils";
+/**
+ * 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";
@@ -10,16 +19,35 @@ export declare enum TapscriptType {
     ConditionMultisig = "condition-multisig",
     CLTVMultisig = "cltv-multisig"
 }
-export interface ArkTapscript<T extends TapscriptType, Params, SizeArgs = never> {
+/**
+ * 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;
-    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.
+ * decodeTapscript is a function that decodes an ark tapsript from a raw script.
+ *
+ * @throws {Error} if the script is not a valid ark 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>;
@@ -40,6 +68,13 @@ export declare namespace MultisigTapscript {
  * 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>;
@@ -54,6 +89,13 @@ export declare namespace CSVMultisigTapscript {
  * 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>;
@@ -68,6 +110,13 @@ export declare namespace ConditionCSVMultisigTapscript {
  * 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>;
@@ -82,6 +131,13 @@ export declare namespace ConditionMultisigTapscript {
  * 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>;

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

@@ -1,6 +1,33 @@
 import { Bytes } from "@scure/btc-signer/utils";
 import { RelativeTimelock } from "./tapscript";
 import { TapLeafScript, VtxoScript } from "./base";
+/**
+ * Virtual Hash Time Lock Contract (VHTLC) implementation.
+ *
+ * VHTLC is a contract that enables atomic swaps and conditional payments
+ * in the Ark 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 }
+ * });
+ * ```
+ */
 export declare namespace VHTLC {
     interface Options {
         sender: Bytes;

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

@@ -1,9 +1,9 @@
 import * as musig2 from "../musig2";
-import { TxTree } from "./vtxoTree";
-export declare const ErrMissingVtxoTree: Error;
+import { TxTree } from "./txTree";
+export declare const ErrMissingVtxoGraph: Error;
 export declare const ErrMissingAggregateKey: Error;
-export type TreeNonces = (Pick<musig2.Nonces, "pubNonce"> | null)[][];
-export type TreePartialSigs = (musig2.PartialSig | null)[][];
+export type TreeNonces = Map<string, Pick<musig2.Nonces, "pubNonce">>;
+export type TreePartialSigs = Map<string, musig2.PartialSig>;
 export interface SignerSession {
     getPublicKey(): Uint8Array;
     init(tree: TxTree, scriptRoot: Uint8Array, rootInputAmount: bigint): void;
@@ -16,7 +16,7 @@ export declare class TreeSignerSession implements SignerSession {
     static NOT_INITIALIZED: Error;
     private myNonces;
     private aggregateNonces;
-    private tree;
+    private graph;
     private scriptRoot;
     private rootSharedOutputAmount;
     constructor(secretKey: Uint8Array);

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

@@ -0,0 +1,28 @@
+import { Transaction } from "@scure/btc-signer";
+/**
+ * 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 implements Iterable<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;
+    [Symbol.iterator](): IterableIterator<TxTree>;
+}

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

@@ -1,22 +1,15 @@
-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;
+import { Transaction } from "@scure/btc-signer";
+import { TxTree } from "./txTree";
+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

@@ -0,0 +1,19 @@
+import { Transaction } from "@scure/btc-signer";
+import { TransactionInputUpdate } from "@scure/btc-signer/psbt";
+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

@@ -0,0 +1,27 @@
+import { Transaction } from "@scure/btc-signer";
+import { VirtualCoin } from "../wallet";
+import { EncodedVtxoScript, TapLeafScript } from "../script/base";
+import { CSVMultisigTapscript } from "../script/tapscript";
+import { TransactionOutput } from "@scure/btc-signer/psbt";
+import { Bytes } from "@scure/btc-signer/utils";
+export type ArkTxInput = {
+    tapLeafScript: TapLeafScript;
+    checkpointTapLeafScript?: Bytes;
+} & 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 Ark 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;

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

@@ -1,2 +1,8 @@
 import { ArkTransaction, VirtualCoin } from "../wallet";
-export declare function vtxosToTxs(spendable: VirtualCoin[], spent: VirtualCoin[], boardingRounds: Set<string>): ArkTransaction[];
+/**
+ * @param spendable - Vtxos that are spendable
+ * @param spent - Vtxos that are spent
+ * @param boardingBatchTxids - Set of boarding batch txids
+ * @returns Ark transactions
+ */
+export declare function vtxosToTxs(spendable: VirtualCoin[], spent: VirtualCoin[], boardingBatchTxids: Set<string>): ArkTransaction[];

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

@@ -11,6 +11,7 @@ export declare class TxWeightEstimator {
     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;
@@ -19,9 +20,11 @@ export declare class TxWeightEstimator {
     outputSize: number;
     private constructor();
     static create(): TxWeightEstimator;
+    addP2AInput(): TxWeightEstimator;
     addKeySpendInput(isDefault?: boolean): TxWeightEstimator;
     addP2PKHInput(): TxWeightEstimator;
     addTapscriptInput(leafWitnessSize: number, leafScriptSize: number, leafControlBlockSize: number): TxWeightEstimator;
     addP2WKHOutput(): TxWeightEstimator;
+    addP2TROutput(): TxWeightEstimator;
     vsize(): VSize;
 }

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

@@ -0,0 +1,83 @@
+import { Transaction } from "@scure/btc-signer";
+import { TransactionInputUpdate } from "@scure/btc-signer/psbt";
+/**
+ * ArkPsbtFieldKey is the key values for ark psbt fields.
+ */
+export declare enum ArkPsbtFieldKey {
+    VtxoTaprootTree = "taptree",
+    VtxoTreeExpiry = "expiry",
+    Cosigner = "cosigner",
+    ConditionWitness = "condition"
+}
+/**
+ * ArkPsbtFieldKeyType is the type of the ark psbt field key.
+ * Every ark psbt field has key type 255.
+ */
+export declare const ArkPsbtFieldKeyType = 255;
+/**
+ * ArkPsbtFieldCoder is the coder for the ark psbt fields.
+ * each type has its own coder.
+ */
+export interface ArkPsbtFieldCoder<T> {
+    key: ArkPsbtFieldKey;
+    encode: (value: T) => NonNullable<TransactionInputUpdate["unknown"]>[number];
+    decode: (value: NonNullable<TransactionInputUpdate["unknown"]>[number]) => T | null;
+}
+/**
+ * setArkPsbtField appends a new unknown field to the input at inputIndex
+ *
+ * @example
+ * ```typescript
+ * setArkPsbtField(tx, 0, VtxoTaprootTree, myTaprootTree);
+ * setArkPsbtField(tx, 0, VtxoTreeExpiry, myVtxoTreeExpiry);
+ * ```
+ */
+export declare function setArkPsbtField<T>(tx: Transaction, inputIndex: number, coder: ArkPsbtFieldCoder<T>, value: T): void;
+/**
+ * getArkPsbtFields returns all the values of the given coder for the input at inputIndex
+ * Multiple fields of the same type can exist in a single input.
+ *
+ * @example
+ * ```typescript
+ * const vtxoTaprootTreeFields = getArkPsbtFields(tx, 0, VtxoTaprootTree);
+ * console.log(`input has ${vtxoTaprootTreeFields.length} vtxoTaprootTree fields`);
+ */
+export declare function getArkPsbtFields<T>(tx: Transaction, inputIndex: number, coder: ArkPsbtFieldCoder<T>): T[];
+/**
+ * VtxoTaprootTree is set to pass all spending leaves of the vtxo input
+ *
+ * @example
+ * ```typescript
+ * const vtxoTaprootTree = VtxoTaprootTree.encode(myTaprootTree);
+ */
+export declare const VtxoTaprootTree: ArkPsbtFieldCoder<Uint8Array>;
+/**
+ * ConditionWitness is set to pass the witness data used to finalize the conditionMultisigClosure
+ *
+ * @example
+ * ```typescript
+ * const conditionWitness = ConditionWitness.encode(myConditionWitness);
+ */
+export declare const ConditionWitness: ArkPsbtFieldCoder<Uint8Array[]>;
+/**
+ * CosignerPublicKey is set on every TxGraph transactions to identify the musig2 public keys
+ *
+ * @example
+ * ```typescript
+ * const cosignerPublicKey = CosignerPublicKey.encode(myCosignerPublicKey);
+ */
+export declare const CosignerPublicKey: ArkPsbtFieldCoder<{
+    index: number;
+    key: Uint8Array;
+}>;
+/**
+ * VtxoTreeExpiry is set to pass the expiry time of the input
+ *
+ * @example
+ * ```typescript
+ * const vtxoTreeExpiry = VtxoTreeExpiry.encode(myVtxoTreeExpiry);
+ */
+export declare const VtxoTreeExpiry: ArkPsbtFieldCoder<{
+    type: "blocks" | "seconds";
+    value: bigint;
+}>;