@scure/btc-signer 2.0.0 → 2.2.0

package/utxo.d.ts

@@ -1,7 +1,8 @@
 import * as P from 'micro-packed';
 import * as psbt from './psbt.ts';
 import { Transaction, type TxOpts } from './transaction.ts';
-import { type Bytes, NETWORK } from './utils.ts';
+import { type Bytes, NETWORK, type TArg } from './utils.ts';
+/** Minimal output target accepted by the UTXO selector. */
 export type Output = {
     address: string;
     amount: bigint;
@@ -9,6 +10,7 @@ export type Output = {
     script: Uint8Array;
     amount: bigint;
 };
+/** Intermediate accumulation result returned by selection heuristics. */
 export type Accumulated = {
     indices: number[];
     fee: bigint | undefined;
@@ -16,13 +18,14 @@ export type Accumulated = {
     total: bigint;
 } | undefined;
 export declare const _cmpBig: (a: bigint, b: bigint) => 0 | 1 | -1;
+/** Options for fee estimation and UTXO selection. */
 export type EstimatorOpts = TxOpts & {
     feePerByte: bigint;
     changeAddress: string;
     alwaysChange?: boolean;
     bip69?: boolean;
     network?: typeof NETWORK;
-    dust?: number;
+    dust?: bigint;
     dustRelayFeeRate?: bigint;
     createTx?: boolean;
     requiredInputs?: psbt.TransactionInputUpdate[];
@@ -31,6 +34,7 @@ export type EstimatorOpts = TxOpts & {
 type SortStrategy = 'Newest' | 'Oldest' | 'Smallest' | 'Biggest';
 type ExactStrategy = `exact${SortStrategy}`;
 type AccumStrategy = `accum${SortStrategy}`;
+/** Supported UTXO selection strategies. */
 export type SelectionStrategy = 'all' | 'default' | AccumStrategy | `${ExactStrategy}/${AccumStrategy}`;
 export declare class _Estimator {
     private baseWeight;
@@ -54,8 +58,8 @@ export declare class _Estimator {
     default(): Accumulated;
     private select;
     result(strategy: SelectionStrategy): ({
-        inputs: psbt.PSBTKeyMapKeys<{
-            readonly nonWitnessUtxo: readonly [0, false, P.CoderType<P.StructInput<{
+        inputs: ({
+            nonWitnessUtxo?: P.StructInput<{
                 version: number;
                 segwitFlag: boolean | undefined;
                 inputs: P.StructInput<{
@@ -68,54 +72,219 @@ export declare class _Estimator {
                     amount: /*elided*/ any;
                     script: /*elided*/ any;
                 }>[];
-                witnesses: P.Option<Bytes[][]>;
+                witnesses: P.Option<P.Bytes[][]>;
                 lockTime: number;
-            }>>, readonly [], readonly [0, 2], false];
-            readonly witnessUtxo: readonly [1, false, P.CoderType<P.StructInput<{
+            }> | undefined;
+            witnessUtxo?: P.StructInput<{
                 amount: bigint;
-                script: Bytes;
-            }>>, readonly [], readonly [0, 2], false];
-            readonly partialSig: readonly [2, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly sighashType: readonly [3, false, P.CoderType<number>, readonly [], readonly [0, 2], false];
-            readonly redeemScript: readonly [4, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly witnessScript: readonly [5, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly bip32Derivation: readonly [6, P.CoderType<Bytes>, P.CoderType<P.StructInput<{
+                script: P.Bytes;
+            }> | undefined;
+            partialSig?: [Bytes, Bytes][] | undefined;
+            sighashType?: number | undefined;
+            redeemScript?: Bytes | undefined;
+            witnessScript?: Bytes | undefined;
+            bip32Derivation?: [Bytes, P.StructInput<{
                 fingerprint: number;
                 path: number[];
-            }>>, readonly [], readonly [0, 2], false];
-            readonly finalScriptSig: readonly [7, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly finalScriptWitness: readonly [8, false, P.CoderType<Bytes[]>, readonly [], readonly [0, 2], false];
-            readonly porCommitment: readonly [9, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly ripemd160: readonly [10, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly sha256: readonly [11, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly hash160: readonly [12, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly hash256: readonly [13, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly txid: readonly [14, false, P.CoderType<Bytes>, readonly [2], readonly [2], true];
-            readonly index: readonly [15, false, P.CoderType<number>, readonly [2], readonly [2], true];
-            readonly sequence: readonly [16, false, P.CoderType<number>, readonly [], readonly [2], true];
-            readonly requiredTimeLocktime: readonly [17, false, P.CoderType<number>, readonly [], readonly [2], false];
-            readonly requiredHeightLocktime: readonly [18, false, P.CoderType<number>, readonly [], readonly [2], false];
-            readonly tapKeySig: readonly [19, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly tapScriptSig: readonly [20, P.CoderType<P.StructInput<{
+            }>][] | undefined;
+            finalScriptSig?: Bytes | undefined;
+            finalScriptWitness?: Bytes[] | undefined;
+            porCommitment?: Bytes | undefined;
+            ripemd160?: [Bytes, Bytes][] | undefined;
+            sha256?: [Bytes, Bytes][] | undefined;
+            hash160?: [Bytes, Bytes][] | undefined;
+            hash256?: [Bytes, Bytes][] | undefined;
+            txid?: P.Bytes | undefined;
+            index?: number | undefined;
+            sequence?: number | undefined;
+            requiredTimeLocktime?: number | undefined;
+            requiredHeightLocktime?: number | undefined;
+            tapKeySig?: Bytes | undefined;
+            tapScriptSig?: [P.StructInput<{
                 pubKey: Bytes;
                 leafHash: P.Bytes;
-            }>>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly tapLeafScript: readonly [21, P.CoderType<P.StructInput<{
+            }>, Bytes][] | undefined;
+            tapLeafScript?: [P.StructInput<{
                 version: number;
                 internalKey: P.Bytes;
                 merklePath: P.Bytes[];
-            }>>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly tapBip32Derivation: readonly [22, P.CoderType<Bytes>, P.CoderType<P.StructInput<{
+            }>, Bytes][] | undefined;
+            tapBip32Derivation?: [Bytes, P.StructInput<{
                 hashes: P.Bytes[];
                 der: P.StructInput<{
                     fingerprint: /*elided*/ any;
                     path: /*elided*/ any;
                 }>;
-            }>>, readonly [], readonly [0, 2], false];
-            readonly tapInternalKey: readonly [23, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly tapMerkleRoot: readonly [24, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-            readonly proprietary: readonly [252, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        }>[];
+            }>][] | undefined;
+            tapInternalKey?: Bytes | undefined;
+            tapMerkleRoot?: Bytes | undefined;
+            proprietary?: [Bytes, Bytes][] | undefined;
+        } & {
+            unknown?: [P.UnwrapCoder<P.CoderType<P.StructInput<{
+                type: number;
+                key: Bytes;
+            }>>>, Bytes][];
+        } & {
+            nonWitnessUtxo?: ({
+                version: number;
+                inputs: P.StructInput<{
+                    txid: P.Bytes;
+                    index: number;
+                    finalScriptSig: P.Bytes;
+                    sequence: number;
+                }>[];
+                outputs: P.StructInput<{
+                    amount: bigint;
+                    script: P.Bytes;
+                }>[];
+                lockTime: number;
+            } & {
+                segwitFlag?: boolean | undefined;
+                witnesses?: P.Option<P.Bytes[][]>;
+            } & {
+                version: number;
+                inputs: P.StructInput<{
+                    txid: P.Bytes;
+                    index: number;
+                    finalScriptSig: P.Bytes;
+                    sequence: number;
+                }>[] & ({
+                    index: number;
+                    sequence: number;
+                    txid: P.Bytes;
+                    finalScriptSig: P.Bytes;
+                } & {} & {
+                    index: number;
+                    sequence: number;
+                    txid: P.Bytes & Uint8Array<ArrayBuffer>;
+                    finalScriptSig: P.Bytes & Uint8Array<ArrayBuffer>;
+                })[];
+                outputs: P.StructInput<{
+                    amount: bigint;
+                    script: P.Bytes;
+                }>[] & ({
+                    script: P.Bytes;
+                    amount: bigint;
+                } & {} & {
+                    script: P.Bytes & Uint8Array<ArrayBuffer>;
+                    amount: bigint;
+                })[];
+                lockTime: number;
+                segwitFlag?: boolean | undefined;
+                witnesses?: (P.Bytes[][] & (P.Bytes[] & (P.Bytes & Uint8Array<ArrayBuffer>)[])[]) | undefined;
+            }) | undefined;
+            witnessUtxo?: ({
+                script: P.Bytes;
+                amount: bigint;
+            } & {} & {
+                script: P.Bytes & Uint8Array<ArrayBuffer>;
+                amount: bigint;
+            }) | undefined;
+            partialSig?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+            sighashType?: number | undefined;
+            redeemScript?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+            witnessScript?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+            bip32Derivation?: ([Bytes, P.StructInput<{
+                fingerprint: number;
+                path: number[];
+            }>][] & ([Bytes, P.StructInput<{
+                fingerprint: number;
+                path: number[];
+            }>] & [Bytes & Uint8Array<ArrayBuffer>, {
+                path: number[];
+                fingerprint: number;
+            } & {} & {
+                path: number[] & number[];
+                fingerprint: number;
+            }])[]) | undefined;
+            finalScriptSig?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+            finalScriptWitness?: (Bytes[] & (Bytes & Uint8Array<ArrayBuffer>)[]) | undefined;
+            porCommitment?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+            ripemd160?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+            sha256?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+            hash160?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+            hash256?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+            txid?: (P.Bytes & Uint8Array<ArrayBuffer>) | undefined;
+            index?: number | undefined;
+            sequence?: number | undefined;
+            requiredTimeLocktime?: number | undefined;
+            requiredHeightLocktime?: number | undefined;
+            tapKeySig?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+            tapScriptSig?: ([P.StructInput<{
+                pubKey: Bytes;
+                leafHash: P.Bytes;
+            }>, Bytes][] & ([P.StructInput<{
+                pubKey: Bytes;
+                leafHash: P.Bytes;
+            }>, Bytes] & [{
+                pubKey: Bytes;
+                leafHash: P.Bytes;
+            } & {} & {
+                pubKey: Bytes & Uint8Array<ArrayBuffer>;
+                leafHash: P.Bytes & Uint8Array<ArrayBuffer>;
+            }, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+            tapLeafScript?: ([P.StructInput<{
+                version: number;
+                internalKey: P.Bytes;
+                merklePath: P.Bytes[];
+            }>, Bytes][] & ([P.StructInput<{
+                version: number;
+                internalKey: P.Bytes;
+                merklePath: P.Bytes[];
+            }>, Bytes] & [{
+                version: number;
+                internalKey: P.Bytes;
+                merklePath: P.Bytes[];
+            } & {} & {
+                version: number;
+                internalKey: P.Bytes & Uint8Array<ArrayBuffer>;
+                merklePath: P.Bytes[] & (P.Bytes & Uint8Array<ArrayBuffer>)[];
+            }, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+            tapBip32Derivation?: ([Bytes, P.StructInput<{
+                hashes: P.Bytes[];
+                der: P.StructInput<{
+                    fingerprint: /*elided*/ any;
+                    path: /*elided*/ any;
+                }>;
+            }>][] & ([Bytes, P.StructInput<{
+                hashes: P.Bytes[];
+                der: P.StructInput<{
+                    fingerprint: /*elided*/ any;
+                    path: /*elided*/ any;
+                }>;
+            }>] & [Bytes & Uint8Array<ArrayBuffer>, {
+                der: P.StructInput<{
+                    fingerprint: number;
+                    path: number[];
+                }>;
+                hashes: P.Bytes[];
+            } & {} & {
+                der: {
+                    path: number[];
+                    fingerprint: number;
+                } & {} & {
+                    path: number[] & number[];
+                    fingerprint: number;
+                };
+                hashes: P.Bytes[] & (P.Bytes & Uint8Array<ArrayBuffer>)[];
+            }])[]) | undefined;
+            tapInternalKey?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+            tapMerkleRoot?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+            proprietary?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+            unknown?: ([P.StructInput<{
+                type: number;
+                key: Bytes;
+            }>, Bytes][] & ([P.StructInput<{
+                type: number;
+                key: Bytes;
+            }>, Bytes] & [{
+                type: number;
+                key: Bytes;
+            } & {} & {
+                type: number;
+                key: Bytes & Uint8Array<ArrayBuffer>;
+            }, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+        })[];
         outputs: Output[];
         fee: bigint | undefined;
         weight: number;
@@ -124,9 +293,38 @@ export declare class _Estimator {
         tx: Transaction | undefined;
     }) | undefined;
 }
-export declare function selectUTXO(inputs: psbt.TransactionInputUpdate[], outputs: Output[], strategy: SelectionStrategy, opts: EstimatorOpts): ({
-    inputs: psbt.PSBTKeyMapKeys<{
-        readonly nonWitnessUtxo: readonly [0, false, P.CoderType<P.StructInput<{
+/**
+ * Selects inputs for the requested outputs using the configured strategy.
+ * @param inputs - candidate inputs that may be selected
+ * @param outputs - desired transaction outputs
+ * @param strategy - selection heuristic to use
+ * @param opts - Fee-estimation and transaction-construction options. See {@link EstimatorOpts}.
+ * @returns Selection result, optionally including a constructed transaction.
+ * @throws If the UTXO set, outputs, or estimator options are invalid. {@link Error}
+ * @example
+ * Estimate fees, pick inputs, and build a transaction for the selected set.
+ * ```ts
+ * import { p2wpkh } from '@scure/btc-signer/payment.js';
+ * import { pubECDSA, randomPrivateKeyBytes } from '@scure/btc-signer/utils.js';
+ * import { selectUTXO } from '@scure/btc-signer/utxo.js';
+ * import { hex } from '@scure/base';
+ * const spend = p2wpkh(pubECDSA(randomPrivateKeyBytes()));
+ * const change = p2wpkh(pubECDSA(randomPrivateKeyBytes()));
+ * selectUTXO(
+ *   [{
+ *     txid: hex.decode('0000000000000000000000000000000000000000000000000000000000000001'),
+ *     index: 0,
+ *     witnessUtxo: { amount: 50_000n, script: spend.script },
+ *   }],
+ *   [{ address: spend.address!, amount: 10_000n }],
+ *   'default',
+ *   { feePerByte: 1n, changeAddress: change.address! }
+ * );
+ * ```
+ */
+export declare function selectUTXO(inputs: TArg<psbt.TransactionInputUpdate[]>, outputs: TArg<Output[]>, strategy: SelectionStrategy, opts: TArg<EstimatorOpts>): ({
+    inputs: ({
+        nonWitnessUtxo?: P.StructInput<{
             version: number;
             segwitFlag: boolean | undefined;
             inputs: P.StructInput<{
@@ -139,54 +337,219 @@ export declare function selectUTXO(inputs: psbt.TransactionInputUpdate[], output
                 amount: /*elided*/ any;
                 script: /*elided*/ any;
             }>[];
-            witnesses: P.Option<Bytes[][]>;
+            witnesses: P.Option<P.Bytes[][]>;
             lockTime: number;
-        }>>, readonly [], readonly [0, 2], false];
-        readonly witnessUtxo: readonly [1, false, P.CoderType<P.StructInput<{
+        }> | undefined;
+        witnessUtxo?: P.StructInput<{
             amount: bigint;
-            script: Bytes;
-        }>>, readonly [], readonly [0, 2], false];
-        readonly partialSig: readonly [2, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly sighashType: readonly [3, false, P.CoderType<number>, readonly [], readonly [0, 2], false];
-        readonly redeemScript: readonly [4, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly witnessScript: readonly [5, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly bip32Derivation: readonly [6, P.CoderType<Bytes>, P.CoderType<P.StructInput<{
+            script: P.Bytes;
+        }> | undefined;
+        partialSig?: [Bytes, Bytes][] | undefined;
+        sighashType?: number | undefined;
+        redeemScript?: Bytes | undefined;
+        witnessScript?: Bytes | undefined;
+        bip32Derivation?: [Bytes, P.StructInput<{
             fingerprint: number;
             path: number[];
-        }>>, readonly [], readonly [0, 2], false];
-        readonly finalScriptSig: readonly [7, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly finalScriptWitness: readonly [8, false, P.CoderType<Bytes[]>, readonly [], readonly [0, 2], false];
-        readonly porCommitment: readonly [9, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly ripemd160: readonly [10, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly sha256: readonly [11, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly hash160: readonly [12, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly hash256: readonly [13, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly txid: readonly [14, false, P.CoderType<Bytes>, readonly [2], readonly [2], true];
-        readonly index: readonly [15, false, P.CoderType<number>, readonly [2], readonly [2], true];
-        readonly sequence: readonly [16, false, P.CoderType<number>, readonly [], readonly [2], true];
-        readonly requiredTimeLocktime: readonly [17, false, P.CoderType<number>, readonly [], readonly [2], false];
-        readonly requiredHeightLocktime: readonly [18, false, P.CoderType<number>, readonly [], readonly [2], false];
-        readonly tapKeySig: readonly [19, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly tapScriptSig: readonly [20, P.CoderType<P.StructInput<{
+        }>][] | undefined;
+        finalScriptSig?: Bytes | undefined;
+        finalScriptWitness?: Bytes[] | undefined;
+        porCommitment?: Bytes | undefined;
+        ripemd160?: [Bytes, Bytes][] | undefined;
+        sha256?: [Bytes, Bytes][] | undefined;
+        hash160?: [Bytes, Bytes][] | undefined;
+        hash256?: [Bytes, Bytes][] | undefined;
+        txid?: P.Bytes | undefined;
+        index?: number | undefined;
+        sequence?: number | undefined;
+        requiredTimeLocktime?: number | undefined;
+        requiredHeightLocktime?: number | undefined;
+        tapKeySig?: Bytes | undefined;
+        tapScriptSig?: [P.StructInput<{
             pubKey: Bytes;
             leafHash: P.Bytes;
-        }>>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly tapLeafScript: readonly [21, P.CoderType<P.StructInput<{
+        }>, Bytes][] | undefined;
+        tapLeafScript?: [P.StructInput<{
             version: number;
             internalKey: P.Bytes;
             merklePath: P.Bytes[];
-        }>>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly tapBip32Derivation: readonly [22, P.CoderType<Bytes>, P.CoderType<P.StructInput<{
+        }>, Bytes][] | undefined;
+        tapBip32Derivation?: [Bytes, P.StructInput<{
             hashes: P.Bytes[];
             der: P.StructInput<{
                 fingerprint: /*elided*/ any;
                 path: /*elided*/ any;
             }>;
-        }>>, readonly [], readonly [0, 2], false];
-        readonly tapInternalKey: readonly [23, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly tapMerkleRoot: readonly [24, false, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-        readonly proprietary: readonly [252, P.CoderType<Bytes>, P.CoderType<Bytes>, readonly [], readonly [0, 2], false];
-    }>[];
+        }>][] | undefined;
+        tapInternalKey?: Bytes | undefined;
+        tapMerkleRoot?: Bytes | undefined;
+        proprietary?: [Bytes, Bytes][] | undefined;
+    } & {
+        unknown?: [P.UnwrapCoder<P.CoderType<P.StructInput<{
+            type: number;
+            key: Bytes;
+        }>>>, Bytes][];
+    } & {
+        nonWitnessUtxo?: ({
+            version: number;
+            inputs: P.StructInput<{
+                txid: P.Bytes;
+                index: number;
+                finalScriptSig: P.Bytes;
+                sequence: number;
+            }>[];
+            outputs: P.StructInput<{
+                amount: bigint;
+                script: P.Bytes;
+            }>[];
+            lockTime: number;
+        } & {
+            segwitFlag?: boolean | undefined;
+            witnesses?: P.Option<P.Bytes[][]>;
+        } & {
+            version: number;
+            inputs: P.StructInput<{
+                txid: P.Bytes;
+                index: number;
+                finalScriptSig: P.Bytes;
+                sequence: number;
+            }>[] & ({
+                index: number;
+                sequence: number;
+                txid: P.Bytes;
+                finalScriptSig: P.Bytes;
+            } & {} & {
+                index: number;
+                sequence: number;
+                txid: P.Bytes & Uint8Array<ArrayBuffer>;
+                finalScriptSig: P.Bytes & Uint8Array<ArrayBuffer>;
+            })[];
+            outputs: P.StructInput<{
+                amount: bigint;
+                script: P.Bytes;
+            }>[] & ({
+                script: P.Bytes;
+                amount: bigint;
+            } & {} & {
+                script: P.Bytes & Uint8Array<ArrayBuffer>;
+                amount: bigint;
+            })[];
+            lockTime: number;
+            segwitFlag?: boolean | undefined;
+            witnesses?: (P.Bytes[][] & (P.Bytes[] & (P.Bytes & Uint8Array<ArrayBuffer>)[])[]) | undefined;
+        }) | undefined;
+        witnessUtxo?: ({
+            script: P.Bytes;
+            amount: bigint;
+        } & {} & {
+            script: P.Bytes & Uint8Array<ArrayBuffer>;
+            amount: bigint;
+        }) | undefined;
+        partialSig?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+        sighashType?: number | undefined;
+        redeemScript?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+        witnessScript?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+        bip32Derivation?: ([Bytes, P.StructInput<{
+            fingerprint: number;
+            path: number[];
+        }>][] & ([Bytes, P.StructInput<{
+            fingerprint: number;
+            path: number[];
+        }>] & [Bytes & Uint8Array<ArrayBuffer>, {
+            path: number[];
+            fingerprint: number;
+        } & {} & {
+            path: number[] & number[];
+            fingerprint: number;
+        }])[]) | undefined;
+        finalScriptSig?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+        finalScriptWitness?: (Bytes[] & (Bytes & Uint8Array<ArrayBuffer>)[]) | undefined;
+        porCommitment?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+        ripemd160?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+        sha256?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+        hash160?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+        hash256?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+        txid?: (P.Bytes & Uint8Array<ArrayBuffer>) | undefined;
+        index?: number | undefined;
+        sequence?: number | undefined;
+        requiredTimeLocktime?: number | undefined;
+        requiredHeightLocktime?: number | undefined;
+        tapKeySig?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+        tapScriptSig?: ([P.StructInput<{
+            pubKey: Bytes;
+            leafHash: P.Bytes;
+        }>, Bytes][] & ([P.StructInput<{
+            pubKey: Bytes;
+            leafHash: P.Bytes;
+        }>, Bytes] & [{
+            pubKey: Bytes;
+            leafHash: P.Bytes;
+        } & {} & {
+            pubKey: Bytes & Uint8Array<ArrayBuffer>;
+            leafHash: P.Bytes & Uint8Array<ArrayBuffer>;
+        }, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+        tapLeafScript?: ([P.StructInput<{
+            version: number;
+            internalKey: P.Bytes;
+            merklePath: P.Bytes[];
+        }>, Bytes][] & ([P.StructInput<{
+            version: number;
+            internalKey: P.Bytes;
+            merklePath: P.Bytes[];
+        }>, Bytes] & [{
+            version: number;
+            internalKey: P.Bytes;
+            merklePath: P.Bytes[];
+        } & {} & {
+            version: number;
+            internalKey: P.Bytes & Uint8Array<ArrayBuffer>;
+            merklePath: P.Bytes[] & (P.Bytes & Uint8Array<ArrayBuffer>)[];
+        }, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+        tapBip32Derivation?: ([Bytes, P.StructInput<{
+            hashes: P.Bytes[];
+            der: P.StructInput<{
+                fingerprint: /*elided*/ any;
+                path: /*elided*/ any;
+            }>;
+        }>][] & ([Bytes, P.StructInput<{
+            hashes: P.Bytes[];
+            der: P.StructInput<{
+                fingerprint: /*elided*/ any;
+                path: /*elided*/ any;
+            }>;
+        }>] & [Bytes & Uint8Array<ArrayBuffer>, {
+            der: P.StructInput<{
+                fingerprint: number;
+                path: number[];
+            }>;
+            hashes: P.Bytes[];
+        } & {} & {
+            der: {
+                path: number[];
+                fingerprint: number;
+            } & {} & {
+                path: number[] & number[];
+                fingerprint: number;
+            };
+            hashes: P.Bytes[] & (P.Bytes & Uint8Array<ArrayBuffer>)[];
+        }])[]) | undefined;
+        tapInternalKey?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+        tapMerkleRoot?: (Bytes & Uint8Array<ArrayBuffer>) | undefined;
+        proprietary?: ([Bytes, Bytes][] & ([Bytes, Bytes] & [Bytes & Uint8Array<ArrayBuffer>, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+        unknown?: ([P.StructInput<{
+            type: number;
+            key: Bytes;
+        }>, Bytes][] & ([P.StructInput<{
+            type: number;
+            key: Bytes;
+        }>, Bytes] & [{
+            type: number;
+            key: Bytes;
+        } & {} & {
+            type: number;
+            key: Bytes & Uint8Array<ArrayBuffer>;
+        }, Bytes & Uint8Array<ArrayBuffer>])[]) | undefined;
+    })[];
     outputs: Output[];
     fee: bigint | undefined;
     weight: number;

package/utxo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utxo.d.ts","sourceRoot":"","sources":["src/utxo.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"utxo.d.ts","sourceRoot":"","sources":["src/utxo.ts"],"names":[],"mappings":"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"}