@btc-vision/bitcoin 6.4.11 → 6.5.2

package/browser/payments/index.d.ts

@@ -1,5 +1,5 @@
-import { Network } from '../networks';
-import { Taptree } from '../types';
+import { Network } from '../networks.js';
+import { Taptree } from '../types.js';
 export * from './bip341.js';
 export * from './embed.js';
 export * from './lazy.js';

package/browser/payments/lazy.d.ts

@@ -1,2 +1,2 @@
-export declare function prop<T extends {}>(object: T, name: string, f: () => T[keyof T]): void;
+export declare function prop<T extends object>(object: T, name: string, f: () => T[keyof T]): void;
 export declare function value<T>(f: () => T): () => T;

package/browser/psbt/bip371.d.ts

@@ -1,5 +1,8 @@
 import { PsbtInput, PsbtOutput, TapLeaf } from 'bip174/src/lib/interfaces.js';
 import { Taptree } from '../types.js';
+interface PsbtOutputWithScript extends PsbtOutput {
+    script?: Buffer;
+}
 export declare const toXOnly: (pubKey: Buffer | Uint8Array) => Buffer;
 export declare function tapScriptFinalizer(inputIndex: number, input: PsbtInput, tapLeafHashToFinalize?: Buffer): {
     finalScriptWitness: Buffer | undefined;
@@ -8,9 +11,10 @@ export declare function serializeTaprootSignature(sig: Buffer, sighashType?: num
 export declare function isTaprootInput(input: PsbtInput): boolean;
 export declare function isTaprootOutput(output: PsbtOutput, script?: Buffer): boolean;
 export declare function checkTaprootInputFields(inputData: PsbtInput, newInputData: PsbtInput, action: string): void;
-export declare function checkTaprootOutputFields(outputData: PsbtOutput, newOutputData: PsbtOutput, action: string): void;
+export declare function checkTaprootOutputFields(outputData: PsbtOutputWithScript, newOutputData: PsbtOutput, action: string): void;
 export declare function tweakInternalPubKey(inputIndex: number, input: PsbtInput): Buffer;
 export declare function tapTreeToList(tree: Taptree): TapLeaf[];
 export declare function tapTreeFromList(leaves?: TapLeaf[]): Taptree;
 export declare function checkTaprootInputForSigs(input: PsbtInput, action: string): boolean;
 export declare function getTapKeySigFromWitness(finalScriptWitness?: Buffer): Buffer | undefined;
+export {};

package/browser/psbt.d.ts

@@ -1,6 +1,6 @@
 import { Psbt as PsbtBase } from 'bip174';
 import { KeyValue, PartialSig, PsbtGlobal, PsbtGlobalUpdate, PsbtInput, PsbtInputUpdate, PsbtOutput, PsbtOutputUpdate } from 'bip174/src/lib/interfaces.js';
-import { BIP32Interface } from 'bip32';
+import { BIP32Interface } from '@btc-vision/bip32';
 import { ECPairInterface } from 'ecpair';
 import { Network } from './networks.js';
 import { Transaction } from './transaction.js';

package/browser/typeforce.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Type definitions for typeforce library
+ */
+
+/**
+ * Typeforce type validator - validates that a value matches a given type.
+ */
+type TypeforceValidator = (value: unknown) => boolean;
+
+/**
+ * Interface representing the typeforce library's API.
+ */
+interface TypeforceLib {
+    (type: unknown, value: unknown): void;
+    Number: TypeforceValidator;
+    Array: TypeforceValidator;
+    Boolean: TypeforceValidator;
+    String: TypeforceValidator;
+    Buffer: TypeforceValidator;
+    Hex: TypeforceValidator;
+    Null: TypeforceValidator;
+    Function: TypeforceValidator;
+    UInt8: TypeforceValidator;
+    UInt32: TypeforceValidator;
+    UInt53: TypeforceValidator;
+    BufferN: (n: number) => TypeforceValidator;
+    maybe: (type: unknown) => TypeforceValidator;
+    tuple: (...types: unknown[]) => TypeforceValidator;
+    oneOf: (...types: unknown[]) => TypeforceValidator;
+    arrayOf: (type: unknown) => TypeforceValidator;
+    Object: TypeforceValidator;
+    anyOf: (...types: unknown[]) => TypeforceValidator;
+}
+
+declare module 'typeforce' {
+    const typeforce: TypeforceLib;
+    export = typeforce;
+}

package/browser/types.d.ts

@@ -1,4 +1,6 @@
-export declare const typeforce: any;
+import { default as typeforce } from 'typeforce';
+export { typeforce };
+export type TypeforceValidator = (value: unknown) => boolean;
 export declare function stacksEqual(a: Buffer[], b: Buffer[]): boolean;
 export declare function isPoint(p: Buffer | number | undefined | null): boolean;
 export declare function Satoshi(value: number): boolean;
@@ -11,27 +13,27 @@ export interface Tapleaf {
     version?: number;
 }
 export declare const TAPLEAF_VERSION_MASK = 254;
-export declare function isTapleaf(o: any): o is Tapleaf;
+export declare function isTapleaf(o: unknown): o is Tapleaf;
 export type Taptree = [Taptree | Tapleaf, Taptree | Tapleaf] | Tapleaf;
-export declare function isTaptree(scriptTree: any): scriptTree is Taptree;
+export declare function isTaptree(scriptTree: unknown): scriptTree is Taptree;
 export interface TinySecp256k1Interface {
     isXOnlyPoint(p: Uint8Array): boolean;
     xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;
 }
-export declare const Buffer256bit: any;
-export declare const Hash160bit: any;
-export declare const Hash256bit: any;
-export declare const Number: any;
-export declare const Array: any;
-export declare const Boolean: any;
-export declare const String: any;
-export declare const Buffer: any;
-export declare const Hex: any;
-export declare const maybe: any;
-export declare const tuple: any;
-export declare const UInt8: any;
-export declare const UInt32: any;
-export declare const Function: any;
-export declare const BufferN: any;
-export declare const Null: any;
-export declare const oneOf: any;
+export declare const Buffer256bit: TypeforceValidator;
+export declare const Hash160bit: TypeforceValidator;
+export declare const Hash256bit: TypeforceValidator;
+export declare const Number: TypeforceValidator;
+export declare const Array: TypeforceValidator;
+export declare const Boolean: TypeforceValidator;
+export declare const String: TypeforceValidator;
+export declare const Buffer: TypeforceValidator;
+export declare const Hex: TypeforceValidator;
+export declare const maybe: (type: unknown) => TypeforceValidator;
+export declare const tuple: (...types: unknown[]) => TypeforceValidator;
+export declare const UInt8: TypeforceValidator;
+export declare const UInt32: TypeforceValidator;
+export declare const Function: TypeforceValidator;
+export declare const BufferN: (n: number) => TypeforceValidator;
+export declare const Null: TypeforceValidator;
+export declare const oneOf: (...types: unknown[]) => TypeforceValidator;

package/build/address.js

@@ -114,7 +114,7 @@ export function fromBech32(address) {
     };
 }
 export function toBase58Check(hash, version) {
-    typeforce(tuple(Hash160bit, UInt8), arguments);
+    typeforce(tuple(Hash160bit, UInt8), [hash, version]);
     const payload = Buffer.allocUnsafe(21);
     payload.writeUInt8(version, 0);
     hash.copy(payload, 1);
@@ -216,5 +216,5 @@ export function toOutputScript(address, network) {
             }
         }
     }
-    return Buffer.from(address, 'hex');
+    throw new TypeError(address + ' has no matching Script');
 }

package/build/bip66.js

@@ -63,8 +63,8 @@ export function decode(buffer) {
     if (lenS > 1 && buffer[lenR + 6] === 0x00 && !(buffer[lenR + 7] & 0x80))
         throw new Error('S value excessively padded');
     return {
-        r: buffer.slice(4, 4 + lenR),
-        s: buffer.slice(6 + lenR),
+        r: buffer.subarray(4, 4 + lenR),
+        s: buffer.subarray(6 + lenR),
     };
 }
 export function encode(r, s) {

package/build/block.js

@@ -31,7 +31,7 @@ export class Block {
         if (buffer.length === 80)
             return block;
         const readTransaction = () => {
-            const tx = Transaction.fromBuffer(bufferReader.buffer.slice(bufferReader.offset), true);
+            const tx = Transaction.fromBuffer(bufferReader.buffer.subarray(bufferReader.offset), true);
             bufferReader.offset += tx.byteLength();
             return tx;
         };
@@ -71,7 +71,7 @@ export class Block {
     getWitnessCommit() {
         if (!txesHaveWitnessCommit(this.transactions))
             return null;
-        const witnessCommits = this.transactions[0].outs.filter((out) => out.script.slice(0, 6).equals(Buffer.from('6a24aa21a9ed', 'hex'))).map((out) => out.script.slice(6, 38));
+        const witnessCommits = this.transactions[0].outs.filter((out) => out.script.subarray(0, 6).equals(Buffer.from('6a24aa21a9ed', 'hex'))).map((out) => out.script.subarray(6, 38));
         if (witnessCommits.length === 0)
             return null;
         const result = witnessCommits[witnessCommits.length - 1];

package/build/crypto.d.ts

@@ -4,7 +4,7 @@ export declare function sha256(buffer: Buffer): Buffer;
 export declare function hash160(buffer: Buffer): Buffer;
 export declare function hash256(buffer: Buffer): Buffer;
 export declare const TAGS: readonly ["BIP0340/challenge", "BIP0340/aux", "BIP0340/nonce", "TapLeaf", "TapBranch", "TapSighash", "TapTweak", "KeyAgg list", "KeyAgg coefficient"];
-export type TaggedHashPrefix = typeof TAGS[number];
+export type TaggedHashPrefix = (typeof TAGS)[number];
 type TaggedHashPrefixes = {
     [key in TaggedHashPrefix]: Buffer;
 };

package/build/crypto.js

@@ -1,6 +1,5 @@
-import { ripemd160 as _ripemd160 } from '@noble/hashes/ripemd160';
-import { sha1 as _sha1 } from '@noble/hashes/sha1';
-import { sha256 as _sha256 } from '@noble/hashes/sha256';
+import { ripemd160 as _ripemd160, sha1 as _sha1 } from '@noble/hashes/legacy.js';
+import { sha256 as _sha256 } from '@noble/hashes/sha2.js';
 export function ripemd160(buffer) {
     return Buffer.from(_ripemd160(Uint8Array.from(buffer)));
 }

package/build/hooks/HookedSigner.d.ts

@@ -1,4 +1,4 @@
-import { BIP32Interface } from 'bip32';
+import { BIP32Interface } from '@btc-vision/bip32';
 import { ECPairInterface } from 'ecpair';
 import { Signer, SignerAlternative, SignerAsync } from '../psbt.js';
 export declare function hookSigner(keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface): void;

package/build/index.d.ts

@@ -15,10 +15,11 @@ export * from './crypto.js';
 export * from './psbt.js';
 export { opcodes } from './opcodes.js';
 export { Transaction } from './transaction.js';
-export { Network } from './networks.js';
+export type { Network } from './networks.js';
 export { initEccLib } from './ecc_lib.js';
-export { Payment, PaymentCreator, PaymentOpts, Stack, StackElement, P2WSHPayment, P2PKPayment, BasePayment, P2SHPayment, P2TRPayment, P2WPKHPayment, P2PKHPayment, P2MSPayment, EmbedPayment, P2OPPayment, P2OPPaymentParams, StackFunction, PaymentType, } from './payments/index.js';
-export { Input as TxInput, Output as TxOutput } from './transaction.js';
+export { PaymentType } from './payments/index.js';
+export type { Payment, PaymentCreator, PaymentOpts, Stack, StackElement, P2WSHPayment, P2PKPayment, BasePayment, P2SHPayment, P2TRPayment, P2WPKHPayment, P2PKHPayment, P2MSPayment, EmbedPayment, P2OPPayment, P2OPPaymentParams, StackFunction, } from './payments/index.js';
+export type { Input as TxInput, Output as TxOutput } from './transaction.js';
 export interface PsbtInput extends _PsbtInput {
 }
 export interface PsbtOutput extends _PsbtOutput {
@@ -46,7 +47,8 @@ export * from './address.js';
 export * from './bufferutils.js';
 export * from './payments/bip341.js';
 export * from './psbt/psbtutils.js';
-export { Taptree, XOnlyPointAddTweakResult, Tapleaf, TinySecp256k1Interface, TAPLEAF_VERSION_MASK, } from './types.js';
+export { TAPLEAF_VERSION_MASK } from './types.js';
+export type { Taptree, XOnlyPointAddTweakResult, Tapleaf, TinySecp256k1Interface, } from './types.js';
 declare const bitcoin: {
     networks: typeof networks;
     address: typeof address;

package/build/index.js

@@ -15,13 +15,13 @@ export * from './psbt.js';
 export { opcodes } from './opcodes.js';
 export { Transaction } from './transaction.js';
 export { initEccLib } from './ecc_lib.js';
-export { PaymentType, } from './payments/index.js';
+export { PaymentType } from './payments/index.js';
 export * from './psbt/bip371.js';
 export * from './address.js';
 export * from './bufferutils.js';
 export * from './payments/bip341.js';
 export * from './psbt/psbtutils.js';
-export { TAPLEAF_VERSION_MASK, } from './types.js';
+export { TAPLEAF_VERSION_MASK } from './types.js';
 const bitcoin = {
     networks,
     address,

package/build/payments/bip341.js

@@ -12,7 +12,7 @@ export function rootHashFromPath(controlBlock, leafHash) {
     const m = (controlBlock.length - 33) / 32;
     let kj = leafHash;
     for (let j = 0; j < m; j++) {
-        const ej = controlBlock.slice(33 + 32 * j, 65 + 32 * j);
+        const ej = controlBlock.subarray(33 + 32 * j, 65 + 32 * j);
         if (kj.compare(ej) < 0) {
             kj = tapBranchHash(kj, ej);
         }

package/build/payments/index.d.ts

@@ -1,5 +1,5 @@
-import { Network } from '../networks';
-import { Taptree } from '../types';
+import type { Network } from '../networks.js';
+import type { Taptree } from '../types.js';
 export * from './bip341.js';
 export * from './embed.js';
 export * from './lazy.js';

package/build/payments/lazy.d.ts

@@ -1,2 +1,2 @@
-export declare function prop<T extends {}>(object: T, name: string, f: () => T[keyof T]): void;
+export declare function prop<T extends object>(object: T, name: string, f: () => T[keyof T]): void;
 export declare function value<T>(f: () => T): () => T;

package/build/payments/p2op.js

@@ -64,7 +64,7 @@ export function p2op(a, opts) {
             else {
                 throw new TypeError('Unsupported push opcode in P2OP script');
             }
-            return a.output.slice(pushPos, pushPos + progLen);
+            return a.output.subarray(pushPos, pushPos + progLen);
         }
         if (a.address) {
             const dec = _address();
@@ -79,7 +79,7 @@ export function p2op(a, opts) {
     lazy.prop(o, 'hash160', () => {
         if (!o.program)
             return;
-        return o.program.slice(1);
+        return o.program.subarray(1);
     });
     lazy.prop(o, 'output', () => {
         if (!o.program)
@@ -126,7 +126,7 @@ export function p2op(a, opts) {
             throw new TypeError(`Witness program must be 2–40 bytes. Was ${prog.length} bytes`);
         if (a.deploymentVersion !== undefined && a.deploymentVersion !== prog[0])
             throw new TypeError('deploymentVersion mismatch');
-        if (a.hash160 && !a.hash160.equals(prog.slice(1)))
+        if (a.hash160 && !a.hash160.equals(prog.subarray(1)))
             throw new TypeError('hash160 mismatch');
     }
     return Object.assign(o, a);

package/build/payments/p2pk.js

@@ -32,7 +32,7 @@ export function p2pk(a, opts) {
     lazy.prop(o, 'pubkey', () => {
         if (!a.output)
             return;
-        return a.output.slice(1, -1);
+        return a.output.subarray(1, -1);
     });
     lazy.prop(o, 'signature', () => {
         if (!a.input)

package/build/payments/p2pkh.js

@@ -24,7 +24,7 @@ export function p2pkh(a, opts) {
     const _address = lazy.value(() => {
         const payload = Buffer.from(bs58check.default.decode(a.address));
         const version = payload.readUInt8(0);
-        const hash = payload.slice(1);
+        const hash = payload.subarray(1);
         return { version, hash };
     });
     const _chunks = lazy.value(() => {
@@ -46,7 +46,7 @@ export function p2pkh(a, opts) {
     });
     lazy.prop(o, 'hash', () => {
         if (a.output)
-            return a.output.slice(3, 23);
+            return a.output.subarray(3, 23);
         if (a.address)
             return _address().hash;
         if (a.pubkey || o.pubkey)
@@ -125,7 +125,7 @@ export function p2pkh(a, opts) {
                 a.output[24] !== OPS.OP_CHECKSIG) {
                 throw new TypeError('Output is invalid');
             }
-            const hash2 = a.output.slice(3, 23);
+            const hash2 = a.output.subarray(3, 23);
             if (hash.length > 0 && !hash.equals(hash2))
                 throw new TypeError('Hash mismatch');
             else

package/build/payments/p2sh.js

@@ -36,7 +36,7 @@ export function p2sh(a, opts) {
     const _address = lazy.value(() => {
         const payload = Buffer.from(bs58check.default.decode(a.address));
         const version = payload.readUInt8(0);
-        const hash = payload.slice(1);
+        const hash = payload.subarray(1);
         return { version, hash };
     });
     const _chunks = lazy.value(() => {
@@ -62,7 +62,7 @@ export function p2sh(a, opts) {
     });
     lazy.prop(o, 'hash', () => {
         if (a.output)
-            return a.output.slice(2, 22);
+            return a.output.subarray(2, 22);
         if (a.address)
             return _address().hash;
         if (o.redeem && o.redeem.output)
@@ -116,7 +116,7 @@ export function p2sh(a, opts) {
                 a.output[1] !== 0x14 ||
                 a.output[22] !== OPS.OP_EQUAL)
                 throw new TypeError('Output is invalid');
-            const hash2 = a.output.slice(2, 22);
+            const hash2 = a.output.subarray(2, 22);
             if (hash.length > 0 && !hash.equals(hash2))
                 throw new TypeError('Hash mismatch');
             else

package/build/payments/p2tr.js

@@ -111,7 +111,7 @@ export function p2tr(a, opts) {
         if (a.pubkey)
             return a.pubkey;
         if (a.output)
-            return a.output.slice(2);
+            return a.output.subarray(2);
         if (a.address)
             return _address().data;
         if (o.internalPubkey) {
@@ -125,7 +125,7 @@ export function p2tr(a, opts) {
             return a.internalPubkey;
         const witness = _witness();
         if (witness && witness.length > 1)
-            return witness[witness.length - 1].slice(1, 33);
+            return witness[witness.length - 1].subarray(1, 33);
     });
     lazy.prop(o, 'signature', () => {
         if (a.signature)
@@ -176,10 +176,10 @@ export function p2tr(a, opts) {
         if (a.output) {
             if (a.output.length !== 34 || a.output[0] !== OPS.OP_1 || a.output[1] !== 0x20)
                 throw new TypeError('Output is invalid');
-            if (pubkey.length > 0 && !pubkey.equals(a.output.slice(2)))
+            if (pubkey.length > 0 && !pubkey.equals(a.output.subarray(2)))
                 throw new TypeError('Pubkey mismatch');
             else
-                pubkey = a.output.slice(2);
+                pubkey = a.output.subarray(2);
         }
         if (a.internalPubkey) {
             const tweakedKey = tweakKey(a.internalPubkey, o.hash);
@@ -188,6 +188,10 @@ export function p2tr(a, opts) {
             else
                 pubkey = tweakedKey.x;
         }
+        if (pubkey && pubkey.length) {
+            if (!getEccLib().isXOnlyPoint(pubkey))
+                throw new TypeError('Invalid pubkey for p2tr');
+        }
         const hashTree = _hashTree();
         if (a.hash && hashTree) {
             if (!a.hash.equals(hashTree.hash))
@@ -232,7 +236,7 @@ export function p2tr(a, opts) {
                 const m = (controlBlock.length - 33) / 32;
                 if (m > 128)
                     throw new TypeError(`The script path is too long. Got ${m}, expected max 128.`);
-                const internalPubkey = controlBlock.slice(1, 33);
+                const internalPubkey = controlBlock.subarray(1, 33);
                 if (a.internalPubkey && !a.internalPubkey.equals(internalPubkey))
                     throw new TypeError('Internal pubkey mismatch');
                 if (!getEccLib().isXOnlyPoint(internalPubkey))

package/build/payments/p2wpkh.js

@@ -45,7 +45,7 @@ export function p2wpkh(a, opts) {
     });
     lazy.prop(o, 'hash', () => {
         if (a.output)
-            return a.output.slice(2, 22);
+            return a.output.subarray(2, 22);
         if (a.address)
             return _address().data;
         if (a.pubkey || o.pubkey)
@@ -100,10 +100,10 @@ export function p2wpkh(a, opts) {
         if (a.output) {
             if (a.output.length !== 22 || a.output[0] !== OPS.OP_0 || a.output[1] !== 0x14)
                 throw new TypeError('Output is invalid');
-            if (hash.length > 0 && !hash.equals(a.output.slice(2)))
+            if (hash.length > 0 && !hash.equals(a.output.subarray(2)))
                 throw new TypeError('Hash mismatch');
             else
-                hash = a.output.slice(2);
+                hash = a.output.subarray(2);
         }
         if (a.pubkey) {
             const pkh = bcrypto.hash160(a.pubkey);

package/build/payments/p2wsh.js

@@ -63,7 +63,7 @@ export function p2wsh(a, opts) {
     });
     lazy.prop(o, 'hash', () => {
         if (a.output)
-            return a.output.slice(2);
+            return a.output.subarray(2);
         if (a.address)
             return _address().data;
         if (o.redeem && o.redeem.output)
@@ -133,7 +133,7 @@ export function p2wsh(a, opts) {
         if (a.output) {
             if (a.output.length !== 34 || a.output[0] !== OPS.OP_0 || a.output[1] !== 0x20)
                 throw new TypeError('Output is invalid');
-            const hash2 = a.output.slice(2);
+            const hash2 = a.output.subarray(2);
             if (hash.length > 0 && !hash.equals(hash2))
                 throw new TypeError('Hash mismatch');
             else

package/build/psbt/bip371.d.ts

@@ -1,5 +1,8 @@
 import { PsbtInput, PsbtOutput, TapLeaf } from 'bip174/src/lib/interfaces.js';
 import { Taptree } from '../types.js';
+interface PsbtOutputWithScript extends PsbtOutput {
+    script?: Buffer;
+}
 export declare const toXOnly: (pubKey: Buffer | Uint8Array) => Buffer;
 export declare function tapScriptFinalizer(inputIndex: number, input: PsbtInput, tapLeafHashToFinalize?: Buffer): {
     finalScriptWitness: Buffer | undefined;
@@ -8,9 +11,10 @@ export declare function serializeTaprootSignature(sig: Buffer, sighashType?: num
 export declare function isTaprootInput(input: PsbtInput): boolean;
 export declare function isTaprootOutput(output: PsbtOutput, script?: Buffer): boolean;
 export declare function checkTaprootInputFields(inputData: PsbtInput, newInputData: PsbtInput, action: string): void;
-export declare function checkTaprootOutputFields(outputData: PsbtOutput, newOutputData: PsbtOutput, action: string): void;
+export declare function checkTaprootOutputFields(outputData: PsbtOutputWithScript, newOutputData: PsbtOutput, action: string): void;
 export declare function tweakInternalPubKey(inputIndex: number, input: PsbtInput): Buffer;
 export declare function tapTreeToList(tree: Taptree): TapLeaf[];
 export declare function tapTreeFromList(leaves?: TapLeaf[]): Taptree;
 export declare function checkTaprootInputForSigs(input: PsbtInput, action: string): boolean;
 export declare function getTapKeySigFromWitness(finalScriptWitness?: Buffer): Buffer | undefined;
+export {};

package/build/psbt/bip371.js

@@ -4,7 +4,7 @@ import { LEAF_VERSION_TAPSCRIPT, MAX_TAPTREE_DEPTH, rootHashFromPath, tapleafHas
 import { p2tr } from '../payments/p2tr.js';
 import { isP2TR, pubkeyPositionInScript, signatureBlocksAction, witnessStackToScriptWitness, } from './psbtutils.js';
 export const toXOnly = (pubKey) => {
-    const buffer = pubKey.length === 32 ? pubKey : pubKey.slice(1, 33);
+    const buffer = pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33);
     return Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
 };
 export function tapScriptFinalizer(inputIndex, input, tapLeafHashToFinalize) {
@@ -51,7 +51,7 @@ function checkTaprootScriptPubkey(outputData, newOutputData) {
     const tapInternalKey = newOutputData.tapInternalKey || outputData.tapInternalKey;
     const tapTree = newOutputData.tapTree || outputData.tapTree;
     if (tapInternalKey) {
-        const { script: scriptPubkey } = outputData;
+        const scriptPubkey = outputData.script;
         const script = getTaprootScripPubkey(tapInternalKey, tapTree);
         if (scriptPubkey && !scriptPubkey.equals(script))
             throw new Error('Error adding output. Script or address missmatch.');
@@ -63,6 +63,8 @@ function getTaprootScripPubkey(tapInternalKey, tapTree) {
         internalPubkey: tapInternalKey,
         scriptTree,
     });
+    if (!output)
+        throw new Error('Failed to generate taproot script pubkey');
     return output;
 }
 export function tweakInternalPubKey(inputIndex, input) {
@@ -91,8 +93,8 @@ export function checkTaprootInputForSigs(input, action) {
 }
 function decodeSchnorrSignature(signature) {
     return {
-        signature: signature.slice(0, 64),
-        hashType: signature.slice(64)[0] || Transaction.SIGHASH_DEFAULT,
+        signature: signature.subarray(0, 64),
+        hashType: signature.subarray(64)[0] || Transaction.SIGHASH_DEFAULT,
     };
 }
 function extractTaprootSigs(input) {
@@ -111,7 +113,7 @@ function extractTaprootSigs(input) {
 export function getTapKeySigFromWitness(finalScriptWitness) {
     if (!finalScriptWitness)
         return;
-    const witness = finalScriptWitness.slice(2);
+    const witness = finalScriptWitness.subarray(2);
     if (witness.length === 64 || witness.length === 65)
         return witness;
 }
@@ -223,11 +225,12 @@ function addPubkeyPositionInScript(script, tss) {
     }, tss);
 }
 function findTapLeafToFinalize(input, inputIndex, leafHashToFinalize) {
-    if (!input.tapScriptSig || !input.tapScriptSig.length)
+    const { tapScriptSig } = input;
+    if (!tapScriptSig || !tapScriptSig.length)
         throw new Error(`Can not finalize taproot input #${inputIndex}. No tapleaf script signature provided.`);
     const tapLeaf = (input.tapLeafScript || [])
         .sort((a, b) => a.controlBlock.length - b.controlBlock.length)
-        .find((leaf) => canFinalizeLeaf(leaf, input.tapScriptSig, leafHashToFinalize));
+        .find((leaf) => canFinalizeLeaf(leaf, tapScriptSig, leafHashToFinalize));
     if (!tapLeaf)
         throw new Error(`Can not finalize taproot input #${inputIndex}. Signature for tapleaf script not found.`);
     return tapLeaf;

package/build/psbt/psbtutils.js

@@ -18,7 +18,7 @@ function isPaymentFactory(payment) {
             payment({ output: script });
             return true;
         }
-        catch (err) {
+        catch {
             return false;
         }
     };
@@ -170,14 +170,15 @@ export function signatureBlocksAction(signature, signatureDecodeFn, action) {
     return whitelist.indexOf(action) === -1;
 }
 function extractPartialSigs(input) {
-    let pSigs = [];
-    if ((input.partialSig || []).length === 0) {
+    const { partialSig } = input;
+    let pSigs;
+    if (!partialSig || partialSig.length === 0) {
         if (!input.finalScriptSig && !input.finalScriptWitness)
             return [];
         pSigs = getPsigsFromInputFinalScripts(input);
     }
     else {
-        pSigs = input.partialSig;
+        pSigs = partialSig;
     }
     return pSigs.map((p) => p.signature);
 }

package/build/psbt.d.ts

@@ -1,6 +1,6 @@
 import { Psbt as PsbtBase } from 'bip174';
 import { KeyValue, PartialSig, PsbtGlobal, PsbtGlobalUpdate, PsbtInput, PsbtInputUpdate, PsbtOutput, PsbtOutputUpdate } from 'bip174/src/lib/interfaces.js';
-import { BIP32Interface } from 'bip32';
+import { BIP32Interface } from '@btc-vision/bip32';
 import { ECPairInterface } from 'ecpair';
 import { Network } from './networks.js';
 import { Transaction } from './transaction.js';