@btc-vision/bitcoin 6.5.1 → 6.5.2

package/src/payments/lazy.ts

@@ -1,10 +1,10 @@
-export function prop<T extends {}>(object: T, name: string, f: () => T[keyof T]): void {
+export function prop<T extends object>(object: T, name: string, f: () => T[keyof T]): void {
     Object.defineProperty(object, name, {
         configurable: true,
         enumerable: true,
         get(): unknown {
-            const _value = f.call(this);
-            this[name] = _value;
+            const _value = f.call(this as T);
+            (this as Record<string, unknown>)[name] = _value;
             return _value;
         },
         set(_value: unknown): void {

package/src/payments/p2op.ts

@@ -115,7 +115,7 @@ export function p2op(a: Omit<P2OPPaymentParams, 'name'>, opts?: PaymentOpts): P2
             } 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) {
@@ -131,7 +131,7 @@ export function p2op(a: Omit<P2OPPaymentParams, 'name'>, opts?: PaymentOpts): P2
 
     lazy.prop(o, 'hash160', () => {
         if (!o.program) return;
-        return o.program.slice(1);
+        return o.program.subarray(1);
     });
 
     lazy.prop(o, 'output', () => {
@@ -188,7 +188,8 @@ export function p2op(a: Omit<P2OPPaymentParams, 'name'>, opts?: PaymentOpts): P2
         if (a.deploymentVersion !== undefined && a.deploymentVersion !== prog[0])
             throw new TypeError('deploymentVersion mismatch');
 
-        if (a.hash160 && !a.hash160.equals(prog.slice(1))) throw new TypeError('hash160 mismatch');
+        if (a.hash160 && !a.hash160.equals(prog.subarray(1)))
+            throw new TypeError('hash160 mismatch');
     }
 
     return Object.assign(o, a);

package/src/payments/p2pk.ts

@@ -51,7 +51,7 @@ export function p2pk(a: Omit<P2PKPayment, 'name'>, opts?: PaymentOpts): P2PKPaym
 
     lazy.prop(o, 'pubkey', () => {
         if (!a.output) return;
-        return a.output.slice(1, -1);
+        return a.output.subarray(1, -1);
     });
 
     lazy.prop(o, 'signature', () => {

package/src/payments/p2pkh.ts

@@ -43,7 +43,7 @@ export function p2pkh(a: Omit<P2PKHPayment, 'name'>, opts?: PaymentOpts): P2PKHP
     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 };
     });
 
@@ -68,7 +68,7 @@ export function p2pkh(a: Omit<P2PKHPayment, 'name'>, opts?: PaymentOpts): P2PKHP
     });
 
     lazy.prop(o, 'hash', () => {
-        if (a.output) return a.output.slice(3, 23);
+        if (a.output) return a.output.subarray(3, 23);
         if (a.address) return _address().hash;
         if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey! || o.pubkey!);
     });
@@ -153,7 +153,7 @@ export function p2pkh(a: Omit<P2PKHPayment, 'name'>, opts?: PaymentOpts): P2PKHP
                 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 hash = hash2;
         }

package/src/payments/p2sh.ts

@@ -3,7 +3,15 @@ import * as bcrypto from '../crypto.js';
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { stacksEqual, typeforce as typef } from '../types.js';
-import { P2SHPayment, Payment, PaymentOpts, PaymentType, ScriptRedeem, Stack, StackFunction, } from './index.js';
+import {
+    P2SHPayment,
+    Payment,
+    PaymentOpts,
+    PaymentType,
+    ScriptRedeem,
+    Stack,
+    StackFunction,
+} from './index.js';
 import * as lazy from './lazy.js';
 
 const OPS = bscript.opcodes;
@@ -58,7 +66,7 @@ export function p2sh(a: Omit<P2SHPayment, 'name'>, opts?: PaymentOpts): P2SHPaym
     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(() => {
@@ -87,7 +95,7 @@ export function p2sh(a: Omit<P2SHPayment, 'name'>, opts?: PaymentOpts): P2SHPaym
     });
     lazy.prop(o, 'hash', () => {
         // in order of least effort
-        if (a.output) return a.output.slice(2, 22);
+        if (a.output) return a.output.subarray(2, 22);
         if (a.address) return _address().hash;
         if (o.redeem && o.redeem.output) return bcrypto.hash160(o.redeem.output);
     });
@@ -113,7 +121,7 @@ export function p2sh(a: Omit<P2SHPayment, 'name'>, opts?: PaymentOpts): P2SHPaym
     });
     lazy.prop(o, 'name', () => {
         const nameParts = ['p2sh'];
-        if (o.redeem !== undefined && o.redeem.name !== undefined) nameParts.push(o.redeem.name!);
+        if (o.redeem !== undefined && o.redeem.name !== undefined) nameParts.push(o.redeem.name);
         return nameParts.join('-');
     });
 
@@ -140,7 +148,7 @@ export function p2sh(a: Omit<P2SHPayment, 'name'>, opts?: PaymentOpts): P2SHPaym
             )
                 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 hash = hash2;
         }

package/src/payments/p2tr.ts

@@ -137,7 +137,7 @@ export function p2tr(a: Omit<P2TRPayment, 'name'>, opts?: PaymentOpts): P2TRPaym
     });
     lazy.prop(o, 'pubkey', () => {
         if (a.pubkey) return a.pubkey;
-        if (a.output) return a.output.slice(2);
+        if (a.output) return a.output.subarray(2);
         if (a.address) return _address().data;
         if (o.internalPubkey) {
             const tweakedKey = tweakKey(o.internalPubkey, o.hash);
@@ -147,7 +147,7 @@ export function p2tr(a: Omit<P2TRPayment, 'name'>, opts?: PaymentOpts): P2TRPaym
     lazy.prop(o, 'internalPubkey', () => {
         if (a.internalPubkey) return a.internalPubkey;
         const witness = _witness();
-        if (witness && witness.length > 1) return witness[witness.length - 1].slice(1, 33);
+        if (witness && witness.length > 1) return witness[witness.length - 1].subarray(1, 33);
     });
     lazy.prop(o, 'signature', () => {
         if (a.signature) return a.signature;
@@ -199,9 +199,9 @@ export function p2tr(a: Omit<P2TRPayment, 'name'>, opts?: PaymentOpts): P2TRPaym
         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);
+            else pubkey = a.output.subarray(2);
         }
 
         if (a.internalPubkey) {
@@ -211,10 +211,9 @@ export function p2tr(a: Omit<P2TRPayment, 'name'>, opts?: PaymentOpts): P2TRPaym
             else pubkey = tweakedKey!.x;
         }
 
-        /*if (pubkey && pubkey.length) {
-            if (!getEccLib().isXOnlyPoint(pubkey))
-                throw new TypeError('Invalid pubkey for p2tr');
-        }*/
+        if (pubkey && pubkey.length) {
+            if (!getEccLib().isXOnlyPoint(pubkey)) throw new TypeError('Invalid pubkey for p2tr');
+        }
 
         const hashTree = _hashTree();
 
@@ -276,7 +275,7 @@ export function p2tr(a: Omit<P2TRPayment, 'name'>, opts?: PaymentOpts): P2TRPaym
                 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');
 

package/src/payments/p2wpkh.ts

@@ -65,7 +65,7 @@ export function p2wpkh(a: Omit<P2WPKHPayment, 'name'>, opts?: PaymentOpts): P2WP
         return bech32.encode(network.bech32, words);
     });
     lazy.prop(o, 'hash', () => {
-        if (a.output) return a.output.slice(2, 22);
+        if (a.output) return a.output.subarray(2, 22);
         if (a.address) return _address().data;
         if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey! || o.pubkey!);
     });
@@ -111,9 +111,9 @@ export function p2wpkh(a: Omit<P2WPKHPayment, 'name'>, opts?: PaymentOpts): P2WP
         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);
+            else hash = a.output.subarray(2);
         }
 
         if (a.pubkey) {

package/src/payments/p2wsh.ts

@@ -82,10 +82,10 @@ export function p2wsh(a: Omit<P2WSHPayment, 'name'>, opts?: PaymentOpts): P2WSHP
         if (!o.hash) return;
         const words = bech32.toWords(o.hash);
         words.unshift(0x00);
-        return bech32.encode(network!.bech32, words);
+        return bech32.encode(network.bech32, words);
     });
     lazy.prop(o, 'hash', () => {
-        if (a.output) return a.output.slice(2);
+        if (a.output) return a.output.subarray(2);
         if (a.address) return _address().data;
         if (o.redeem && o.redeem.output) return bcrypto.sha256(o.redeem.output);
     });
@@ -129,7 +129,7 @@ export function p2wsh(a: Omit<P2WSHPayment, 'name'>, opts?: PaymentOpts): P2WSHP
     });
     lazy.prop(o, 'name', () => {
         const nameParts = ['p2wsh'];
-        if (o.redeem !== undefined && o.redeem.name !== undefined) nameParts.push(o.redeem.name!);
+        if (o.redeem !== undefined && o.redeem.name !== undefined) nameParts.push(o.redeem.name);
         return nameParts.join('-');
     });
 
@@ -152,7 +152,7 @@ export function p2wsh(a: Omit<P2WSHPayment, 'name'>, opts?: PaymentOpts): P2WSHP
         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 hash = hash2;
         }

package/src/psbt/bip371.ts

@@ -9,6 +9,10 @@ import {
 } from 'bip174/src/lib/interfaces.js';
 import { isTapleaf, isTaptree, Tapleaf, Taptree } from '../types.js';
 
+interface PsbtOutputWithScript extends PsbtOutput {
+    script?: Buffer;
+}
+
 import { Transaction } from '../transaction.js';
 
 import {
@@ -27,7 +31,7 @@ import {
 } from './psbtutils.js';
 
 export const toXOnly = (pubKey: Buffer | Uint8Array): Buffer => {
-    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);
 };
@@ -60,7 +64,7 @@ export function tapScriptFinalizer(
 }
 
 export function serializeTaprootSignature(sig: Buffer, sighashType?: number): Buffer {
-    const sighashTypeByte = sighashType ? Buffer.from([sighashType!]) : Buffer.from([]);
+    const sighashTypeByte = sighashType ? Buffer.from([sighashType]) : Buffer.from([]);
 
     return Buffer.concat([sig, sighashTypeByte]);
 }
@@ -100,7 +104,7 @@ export function checkTaprootInputFields(
 }
 
 export function checkTaprootOutputFields(
-    outputData: PsbtOutput,
+    outputData: PsbtOutputWithScript,
     newOutputData: PsbtOutput,
     action: string,
 ): void {
@@ -108,14 +112,17 @@ export function checkTaprootOutputFields(
     checkTaprootScriptPubkey(outputData, newOutputData);
 }
 
-function checkTaprootScriptPubkey(outputData: PsbtOutput, newOutputData: PsbtOutput): void {
+function checkTaprootScriptPubkey(
+    outputData: PsbtOutputWithScript,
+    newOutputData: PsbtOutput,
+): void {
     if (!newOutputData.tapTree && !newOutputData.tapInternalKey) return;
 
     const tapInternalKey = newOutputData.tapInternalKey || outputData.tapInternalKey;
     const tapTree = newOutputData.tapTree || outputData.tapTree;
 
     if (tapInternalKey) {
-        const { script: scriptPubkey } = outputData as any;
+        const scriptPubkey = outputData.script;
         const script = getTaprootScripPubkey(tapInternalKey, tapTree);
         if (scriptPubkey && !scriptPubkey.equals(script))
             throw new Error('Error adding output. Script or address missmatch.');
@@ -128,7 +135,8 @@ function getTaprootScripPubkey(tapInternalKey: TapInternalKey, tapTree?: TapTree
         internalPubkey: tapInternalKey,
         scriptTree,
     });
-    return output!;
+    if (!output) throw new Error('Failed to generate taproot script pubkey');
+    return output;
 }
 
 export function tweakInternalPubKey(inputIndex: number, input: PsbtInput): Buffer {
@@ -186,8 +194,8 @@ function decodeSchnorrSignature(signature: Buffer): {
     hashType: number;
 } {
     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,
     };
 }
 
@@ -205,7 +213,7 @@ function extractTaprootSigs(input: PsbtInput): Buffer[] {
 
 export function getTapKeySigFromWitness(finalScriptWitness?: Buffer): Buffer | undefined {
     if (!finalScriptWitness) return;
-    const witness = finalScriptWitness.slice(2);
+    const witness = finalScriptWitness.subarray(2);
     // todo: add schnorr signature validation
     if (witness.length === 64 || witness.length === 65) return witness;
 }
@@ -358,7 +366,7 @@ function sortSignatures(input: PsbtInput, tapLeaf: TapLeafScript): Buffer[] {
         .filter((tss) => tss.leafHash.equals(leafHash))
         .map((tss) => addPubkeyPositionInScript(tapLeaf.script, tss))
         .sort((t1, t2) => t2.positionInScript - t1.positionInScript)
-        .map((t) => t.signature) as Buffer[];
+        .map((t) => t.signature);
 }
 
 /**
@@ -384,13 +392,14 @@ function findTapLeafToFinalize(
     inputIndex: number,
     leafHashToFinalize?: Buffer,
 ): TapLeafScript {
-    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(
@@ -419,7 +428,7 @@ function canFinalizeLeaf(
     });
     const whiteListedHash = !hash || hash.equals(leafHash);
     return (
-        whiteListedHash && tapScriptSig!.find((tss) => tss.leafHash.equals(leafHash)) !== undefined
+        whiteListedHash && tapScriptSig.find((tss) => tss.leafHash.equals(leafHash)) !== undefined
     );
 }
 

package/src/psbt/psbtutils.ts

@@ -14,12 +14,14 @@ import { Transaction } from '../transaction.js';
 import { toXOnly } from './bip371.js';
 import { p2op } from '../payments/p2op.js';
 
-function isPaymentFactory(payment: any): (script: Buffer) => boolean {
+type PaymentFunction = (opts: { output: Buffer }) => unknown;
+
+function isPaymentFactory(payment: PaymentFunction): (script: Buffer) => boolean {
     return (script: Buffer): boolean => {
         try {
             payment({ output: script });
             return true;
-        } catch (err) {
+        } catch {
             return false;
         }
     };
@@ -299,12 +301,13 @@ export function signatureBlocksAction(
  * @returns An array of signatures extracted from the PsbtInput object.
  */
 function extractPartialSigs(input: PsbtInput): Buffer[] {
-    let pSigs: PartialSig[] = [];
-    if ((input.partialSig || []).length === 0) {
+    const { partialSig } = input;
+    let pSigs: PartialSig[];
+    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);
 }