@btc-vision/bitcoin 6.5.1 → 6.5.3

package/src/psbt.ts

@@ -1,5 +1,11 @@
 import { Psbt as PsbtBase } from 'bip174';
 import * as varuint from 'bip174/src/lib/converter/varint.js';
+
+interface VaruintDecode {
+    (buffer: Buffer, offset?: number): number;
+    bytes: number;
+}
+const varuintDecode = varuint.decode as VaruintDecode;
 import {
     Bip32Derivation,
     KeyValue,
@@ -16,7 +22,7 @@ import {
     TransactionFromBuffer,
 } from 'bip174/src/lib/interfaces.js';
 import { checkForInput, checkForOutput } from 'bip174/src/lib/utils.js';
-import { BIP32Interface } from 'bip32';
+import { BIP32Interface } from '@btc-vision/bip32';
 import { ECPairInterface } from 'ecpair';
 import { fromOutputScript, isUnknownSegwitVersion, toOutputScript } from './address.js';
 import { cloneBuffer, reverseBuffer } from './bufferutils.js';
@@ -146,8 +152,8 @@ export class Psbt {
             __NON_WITNESS_UTXO_TX_CACHE: [],
             __NON_WITNESS_UTXO_BUF_CACHE: [],
             __TX_IN_CACHE: {},
-            // @ts-expect-error no.
-            __TX: this.data.globalMap.unsignedTx.tx, // Now TypeScript knows unsignedTx is a PsbtTransaction
+            // unsignedTx.tx property is dynamically added by PsbtBase
+            __TX: (this.data.globalMap.unsignedTx as PsbtTransaction).tx,
             __UNSAFE_SIGN_NONSEGWIT: false,
         };
 
@@ -232,7 +238,8 @@ export class Psbt {
 
     clone(): Psbt {
         // TODO: more efficient cloning
-        return Psbt.fromBuffer(this.data.toBuffer(), JSON.parse(JSON.stringify(this.opts)));
+        const clonedOpts = JSON.parse(JSON.stringify(this.opts)) as PsbtOptsOptional;
+        return Psbt.fromBuffer(this.data.toBuffer(), clonedOpts);
     }
 
     setMaximumFeeRate(satoshiPerByte: number): void {
@@ -316,11 +323,13 @@ export class Psbt {
     }
 
     addOutput(outputData: PsbtOutputExtended): this {
+        const hasAddress = 'address' in outputData;
+        const hasScript = 'script' in outputData;
         if (
             arguments.length > 1 ||
             !outputData ||
             outputData.value === undefined ||
-            ((outputData as any).address === undefined && (outputData as any).script === undefined)
+            (!hasAddress && !hasScript)
         ) {
             throw new Error(
                 `Invalid arguments for Psbt.addOutput. ` +
@@ -328,8 +337,8 @@ export class Psbt {
             );
         }
         checkInputsForPartialSig(this.data.inputs, 'addOutput');
-        const { address } = outputData as any;
-        if (typeof address === 'string') {
+        if (hasAddress) {
+            const { address } = outputData as PsbtOutputExtendedAddress;
             const { network } = this.opts;
             const script = toOutputScript(address, network);
             outputData = Object.assign({}, outputData, { script });
@@ -367,17 +376,11 @@ export class Psbt {
             this.data.inputs,
             this.__CACHE,
             disableOutputChecks,
-        )!;
+        );
     }
 
     getFee(disableOutputChecks: boolean = false): number {
-        return getTxCacheValue(
-            '__FEE',
-            'fee',
-            this.data.inputs,
-            this.__CACHE,
-            disableOutputChecks,
-        )!;
+        return getTxCacheValue('__FEE', 'fee', this.data.inputs, this.__CACHE, disableOutputChecks);
     }
 
     finalizeAllInputs(): this {
@@ -466,7 +469,7 @@ export class Psbt {
         const results = range(this.data.inputs.length).map((idx) =>
             this.validateSignaturesOfInput(idx, validator),
         );
-        return results.reduce((final, res) => res === true && final, true);
+        return results.reduce((final, res) => res && final, true);
     }
 
     validateSignaturesOfInput(
@@ -495,7 +498,7 @@ export class Psbt {
                 results.push(false);
             }
         }
-        if (results.every((v) => v === false)) {
+        if (results.every((v) => !v)) {
             throw new Error('No inputs were signed');
         }
         return this;
@@ -505,7 +508,7 @@ export class Psbt {
         hdKeyPair: HDSigner | HDSignerAsync,
         sighashTypes: number[] = [Transaction.SIGHASH_ALL],
     ): Promise<void> {
-        return new Promise((resolve, reject): any => {
+        return new Promise((resolve, reject) => {
             if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
                 return reject(new Error('Need HDSigner to sign input'));
             }
@@ -525,7 +528,7 @@ export class Psbt {
                 );
             }
             return Promise.all(promises).then(() => {
-                if (results.every((v) => v === false)) {
+                if (results.every((v) => !v)) {
                     return reject(new Error('No inputs were signed'));
                 }
                 resolve();
@@ -551,7 +554,7 @@ export class Psbt {
         hdKeyPair: HDSigner | HDSignerAsync,
         sighashTypes: number[] = [Transaction.SIGHASH_ALL],
     ): Promise<void> {
-        return new Promise((resolve, reject): any => {
+        return new Promise((resolve, reject) => {
             if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
                 return reject(new Error('Need HDSigner to sign input'));
             }
@@ -585,7 +588,7 @@ export class Psbt {
                 results.push(false);
             }
         }
-        if (results.every((v) => v === false)) {
+        if (results.every((v) => !v)) {
             throw new Error('No inputs were signed');
         }
         return this;
@@ -595,7 +598,7 @@ export class Psbt {
         keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface,
         sighashTypes?: number[],
     ): Promise<void> {
-        return new Promise((resolve, reject): any => {
+        return new Promise((resolve, reject) => {
             if (!keyPair || !keyPair.publicKey)
                 return reject(new Error('Need Signer to sign input'));
 
@@ -617,7 +620,7 @@ export class Psbt {
                 );
             }
             return Promise.all(promises).then(() => {
-                if (results.every((v) => v === false)) {
+                if (results.every((v) => !v)) {
                     return reject(new Error('No inputs were signed'));
                 }
                 resolve();
@@ -779,11 +782,15 @@ export class Psbt {
         if (typeof keyPair.signSchnorr !== 'function')
             throw new Error(`Need Schnorr Signer to sign taproot input #${inputIndex}.`);
 
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
+
         const hashesForSig = getTaprootHashesForSig(
             inputIndex,
             input,
             this.data.inputs,
-            keyPair.publicKey,
+            pubkey,
             this.__CACHE,
             tapLeafHashToSign,
             allowedSighashTypes,
@@ -791,9 +798,7 @@ export class Psbt {
 
         if (!hashesForSig || !hashesForSig.length)
             throw new Error(
-                `Can not sign for input #${inputIndex} with the key ${keyPair.publicKey.toString(
-                    'hex',
-                )}`,
+                `Can not sign for input #${inputIndex} with the key ${pubkey.toString('hex')}`,
             );
 
         return hashesForSig;
@@ -848,7 +853,8 @@ export class Psbt {
                 output: input.witnessUtxo.script,
                 signature: input.tapKeySig,
             });
-            const finalScriptWitness = witnessStackToScriptWitness(payment.witness!);
+            if (!payment.witness) throw new Error('Cannot finalize taproot key spend');
+            const finalScriptWitness = witnessStackToScriptWitness(payment.witness);
             this.data.updateInput(inputIndex, { finalScriptWitness });
         } else {
             const { finalScriptWitness } = finalScriptsFunc(
@@ -878,13 +884,13 @@ export class Psbt {
         const mySigs = pubkey ? partialSig.filter((sig) => sig.pubkey.equals(pubkey)) : partialSig;
         if (mySigs.length < 1) throw new Error('No signatures for this pubkey');
         const results: boolean[] = [];
-        let hashCache: Buffer;
-        let scriptCache: Buffer;
-        let sighashCache: number;
+        let hashCache: Buffer | undefined;
+        let scriptCache: Buffer | undefined;
+        let sighashCache: number | undefined;
         for (const pSig of mySigs) {
             const sig = bscript.signature.decode(pSig.signature);
             const { hash, script } =
-                sighashCache! !== sig.hashType
+                sighashCache !== sig.hashType || !hashCache || !scriptCache
                     ? getHashForSig(
                           inputIndex,
                           Object.assign({}, input, {
@@ -893,14 +899,14 @@ export class Psbt {
                           this.__CACHE,
                           true,
                       )
-                    : { hash: hashCache!, script: scriptCache! };
+                    : { hash: hashCache, script: scriptCache };
             sighashCache = sig.hashType;
             hashCache = hash;
             scriptCache = script;
             checkScriptForPubkey(pSig.pubkey, script, 'verify');
             results.push(validator(pSig.pubkey, hash, sig.signature));
         }
-        return results.every((res) => res === true);
+        return results.every((res) => res);
     }
 
     private validateSignaturesOfTaprootInput(
@@ -960,18 +966,26 @@ export class Psbt {
     ): this {
         //hookSigner(keyPair);
 
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
+
         const { hash, sighashType } = getHashAndSighashType(
             this.data.inputs,
             inputIndex,
-            keyPair.publicKey,
+            pubkey,
             this.__CACHE,
             sighashTypes,
         );
 
+        const sig = keyPair.sign(hash);
         const partialSig = [
             {
-                pubkey: keyPair.publicKey,
-                signature: bscript.signature.encode(keyPair.sign(hash), sighashType),
+                pubkey,
+                signature: bscript.signature.encode(
+                    Buffer.isBuffer(sig) ? sig : Buffer.from(sig),
+                    sighashType,
+                ),
             },
         ];
 
@@ -988,6 +1002,11 @@ export class Psbt {
     ): this {
         //hookSigner(keyPair);
 
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
+
+        // checkTaprootHashesForSig validates signSchnorr exists
         const hashesForSig = this.checkTaprootHashesForSig(
             inputIndex,
             input,
@@ -995,11 +1014,15 @@ export class Psbt {
             tapLeafHashToSign,
             allowedSighashTypes,
         );
+        const signSchnorr = (keyPair.signSchnorr as (h: Buffer) => Uint8Array).bind(keyPair);
+
+        const toBuffer = (data: Uint8Array | Buffer): Buffer =>
+            Buffer.isBuffer(data) ? data : Buffer.from(data);
 
         const tapKeySig: TapKeySig = hashesForSig
             .filter((h) => !h.leafHash)
             .map((h) =>
-                serializeTaprootSignature(keyPair.signSchnorr!(h.hash), input.sighashType),
+                serializeTaprootSignature(toBuffer(signSchnorr(h.hash)), input.sighashType),
             )[0];
 
         const tapScriptSig: TapScriptSig[] = hashesForSig
@@ -1007,9 +1030,9 @@ export class Psbt {
             .map(
                 (h) =>
                     ({
-                        pubkey: toXOnly(keyPair.publicKey),
+                        pubkey: toXOnly(pubkey),
                         signature: serializeTaprootSignature(
-                            keyPair.signSchnorr!(h.hash),
+                            toBuffer(signSchnorr(h.hash)),
                             input.sighashType,
                         ),
                         leafHash: h.leafHash,
@@ -1034,19 +1057,24 @@ export class Psbt {
     ): Promise<void> {
         //hookSigner(keyPair);
 
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
+
         const { hash, sighashType } = getHashAndSighashType(
             this.data.inputs,
             inputIndex,
-            keyPair.publicKey,
+            pubkey,
             this.__CACHE,
             sighashTypes,
         );
 
         return Promise.resolve(keyPair.sign(hash)).then((signature) => {
+            const sig = Buffer.isBuffer(signature) ? signature : Buffer.from(signature);
             const partialSig = [
                 {
-                    pubkey: keyPair.publicKey,
-                    signature: bscript.signature.encode(signature, sighashType),
+                    pubkey,
+                    signature: bscript.signature.encode(sig, sighashType),
                 },
             ];
 
@@ -1063,6 +1091,11 @@ export class Psbt {
     ): Promise<void> {
         //hookSigner(keyPair);
 
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
+
+        // checkTaprootHashesForSig validates signSchnorr exists
         const hashesForSig = this.checkTaprootHashesForSig(
             inputIndex,
             input,
@@ -1070,6 +1103,12 @@ export class Psbt {
             tapLeafHash,
             sighashTypes,
         );
+        const signSchnorr = (
+            keyPair.signSchnorr as (hash: Buffer) => Uint8Array | Promise<Uint8Array>
+        ).bind(keyPair);
+
+        const toBuffer = (data: Uint8Array | Buffer): Buffer =>
+            Buffer.isBuffer(data) ? data : Buffer.from(data);
 
         const signaturePromises: Promise<
             { tapKeySig: Buffer } | { tapScriptSig: TapScriptSig[] }
@@ -1077,25 +1116,26 @@ export class Psbt {
 
         const tapKeyHash = hashesForSig.filter((h) => !h.leafHash)[0];
         if (tapKeyHash) {
-            const tapKeySigPromise = Promise.resolve(keyPair.signSchnorr!(tapKeyHash.hash)).then(
-                (sig) => {
-                    return {
-                        tapKeySig: serializeTaprootSignature(sig, input.sighashType),
-                    };
-                },
-            );
+            const tapKeySigPromise = Promise.resolve(signSchnorr(tapKeyHash.hash)).then((sig) => {
+                return {
+                    tapKeySig: serializeTaprootSignature(toBuffer(sig), input.sighashType),
+                };
+            });
             signaturePromises.push(tapKeySigPromise);
         }
 
         const tapScriptHashes = hashesForSig.filter((h) => !!h.leafHash);
         if (tapScriptHashes.length) {
             const tapScriptSigPromises = tapScriptHashes.map(async (tsh) => {
-                const signature = await keyPair.signSchnorr!(tsh.hash);
+                const signature = await signSchnorr(tsh.hash);
 
                 const tapScriptSig = [
                     {
-                        pubkey: toXOnly(keyPair.publicKey),
-                        signature: serializeTaprootSignature(signature, input.sighashType),
+                        pubkey: toXOnly(pubkey),
+                        signature: serializeTaprootSignature(
+                            toBuffer(signature),
+                            input.sighashType,
+                        ),
                         leafHash: tsh.leafHash,
                     } as TapScriptSig,
                 ];
@@ -1293,11 +1333,12 @@ function canFinalize(input: PsbtInput, script: Buffer, scriptType: string): bool
         case 'pubkeyhash':
         case 'witnesspubkeyhash':
             return hasSigs(1, input.partialSig);
-        case 'multisig':
+        case 'multisig': {
             const p2ms = payments.p2ms({
                 output: script,
             });
             return hasSigs(p2ms.m!, input.partialSig, p2ms.pubkeys);
+        }
         case 'nonstandard':
             return true;
         default:
@@ -1306,21 +1347,21 @@ function canFinalize(input: PsbtInput, script: Buffer, scriptType: string): bool
 }
 
 function checkCache(cache: PsbtCache): void {
-    if (cache.__UNSAFE_SIGN_NONSEGWIT !== false) {
+    if (cache.__UNSAFE_SIGN_NONSEGWIT) {
         throw new Error('Not BIP174 compliant, can not export');
     }
 }
 
-function hasSigs(neededSigs: number, partialSig?: any[], pubkeys?: Buffer[]): boolean {
+function hasSigs(neededSigs: number, partialSig?: PartialSig[], pubkeys?: Buffer[]): boolean {
     if (!partialSig) return false;
-    let sigs: any;
+    let sigs: PartialSig[];
     if (pubkeys) {
         sigs = pubkeys
             .map((pkey) => {
                 const pubkey = compressPubkey(pkey);
                 return partialSig.find((pSig) => pSig.pubkey.equals(pubkey));
             })
-            .filter((v) => !!v);
+            .filter((v): v is PartialSig => !!v);
     } else {
         sigs = partialSig;
     }
@@ -1334,8 +1375,13 @@ function isFinalized(input: PsbtInput): boolean {
 
 function bip32DerivationIsMine(root: HDSigner): (d: Bip32Derivation) => boolean {
     return (d: Bip32Derivation): boolean => {
-        if (!d.masterFingerprint.equals(root.fingerprint)) return false;
-        if (!root.derivePath(d.path).publicKey.equals(d.pubkey)) return false;
+        const fingerprint = Buffer.isBuffer(root.fingerprint)
+            ? root.fingerprint
+            : Buffer.from(root.fingerprint);
+        if (!d.masterFingerprint.equals(fingerprint)) return false;
+        const derivedPubkey = root.derivePath(d.path).publicKey;
+        const pubkey = Buffer.isBuffer(derivedPubkey) ? derivedPubkey : Buffer.from(derivedPubkey);
+        if (!pubkey.equals(d.pubkey)) return false;
         return true;
     };
 }
@@ -1407,7 +1453,7 @@ function checkTxForDupeIns(tx: Transaction, cache: PsbtCache): void {
 }
 
 function checkTxInputCache(cache: PsbtCache, input: { hash: Buffer; index: number }): void {
-    const key = reverseBuffer(Buffer.from(input.hash)).toString('hex') + ':' + input.index;
+    const key = `${reverseBuffer(Buffer.from(input.hash)).toString('hex')}:${input.index}`;
     if (cache.__TX_IN_CACHE[key]) throw new Error('Duplicate input detected.');
     cache.__TX_IN_CACHE[key] = 1;
 }
@@ -1445,7 +1491,7 @@ function getTxCacheValue(
     inputs: PsbtInput[],
     c: PsbtCache,
     disableOutputChecks: boolean = false,
-): number | undefined {
+): number {
     if (!inputs.every(isFinalized)) throw new Error(`PSBT must be finalized to calculate ${name}`);
     if (key === '__FEE_RATE' && c.__FEE_RATE) return c.__FEE_RATE;
     if (key === '__FEE' && c.__FEE) return c.__FEE;
@@ -1458,8 +1504,9 @@ function getTxCacheValue(
         tx = c.__TX.clone();
     }
     inputFinalizeGetAmts(inputs, tx, c, mustFinalize, disableOutputChecks);
-    if (key === '__FEE_RATE') return c.__FEE_RATE!;
-    else if (key === '__FEE') return c.__FEE!;
+    const value = key === '__FEE_RATE' ? c.__FEE_RATE : c.__FEE;
+    if (value === undefined) throw new Error(`Failed to calculate ${name}`);
+    return value;
 }
 
 /**
@@ -1625,7 +1672,7 @@ function getHashForSig(
         }
 
         const prevoutIndex = unsignedTx.ins[inputIndex].index;
-        prevout = nonWitnessUtxoTx.outs[prevoutIndex] as Output;
+        prevout = nonWitnessUtxoTx.outs[prevoutIndex];
     } else if (input.witnessUtxo) {
         prevout = input.witnessUtxo;
     } else {
@@ -1650,17 +1697,17 @@ function getHashForSig(
     } else if (isP2WPKH(meaningfulScript)) {
         // P2WPKH uses the P2PKH template for prevoutScript when signing
         const signingScript = payments.p2pkh({
-            hash: meaningfulScript.slice(2),
+            hash: meaningfulScript.subarray(2),
         }).output!;
         hash = unsignedTx.hashForWitnessV0(inputIndex, signingScript, prevout.value, sighashType);
     } else {
         // non-segwit
-        if (input.nonWitnessUtxo === undefined && cache.__UNSAFE_SIGN_NONSEGWIT === false)
+        if (input.nonWitnessUtxo === undefined && !cache.__UNSAFE_SIGN_NONSEGWIT)
             throw new Error(
                 `Input #${inputIndex} has witnessUtxo but non-segwit script: ` +
-                    `${meaningfulScript.toString('hex')}`,
+                    meaningfulScript.toString('hex'),
             );
-        if (!forValidate && cache.__UNSAFE_SIGN_NONSEGWIT !== false)
+        if (!forValidate && cache.__UNSAFE_SIGN_NONSEGWIT)
             console.warn(
                 'Warning: Signing non-segwit inputs without the full parent transaction ' +
                     'means there is a chance that a miner could feed you incorrect information ' +
@@ -1905,8 +1952,8 @@ function getSignersFromHD(
     }
 
     return myDerivations.map((bipDv) => {
-        const node = hdKeyPair.derivePath(bipDv!.path);
-        if (!bipDv!.pubkey.equals(node.publicKey)) {
+        const node = hdKeyPair.derivePath(bipDv.path);
+        if (!bipDv.pubkey.equals(node.publicKey)) {
             throw new Error('pubkey did not match bip32Derivation');
         }
         return node;
@@ -1935,12 +1982,12 @@ function scriptWitnessToWitnessStack(buffer: Buffer): Buffer[] {
 
     function readSlice(n: number): Buffer {
         offset += n;
-        return buffer.slice(offset - n, offset);
+        return buffer.subarray(offset - n, offset);
     }
 
     function readVarInt(): number {
-        const vi = varuint.decode(buffer, offset);
-        offset += (varuint.decode as any).bytes;
+        const vi = varuintDecode(buffer, offset);
+        offset += varuintDecode.bytes;
         return vi;
     }
 
@@ -2019,11 +2066,11 @@ function inputFinalizeGetAmts(
         } else if (input.nonWitnessUtxo) {
             const nwTx = nonWitnessUtxoTxFromCache(cache, input, idx);
             const vout = tx.ins[idx].index;
-            const out = nwTx.outs[vout] as Output;
+            const out = nwTx.outs[vout];
             inputAmount += out.value;
         }
     });
-    const outputAmount = (tx.outs as Output[]).reduce((total, o) => total + o.value, 0);
+    const outputAmount = tx.outs.reduce((total, o) => total + o.value, 0);
     const fee = inputAmount - outputAmount;
     if (!disableOutputChecks) {
         if (fee < 0) {
@@ -2132,11 +2179,11 @@ function redeemFromFinalWitnessScript(finalScript: Buffer | undefined): Buffer |
 function compressPubkey(pubkey: Buffer): Buffer {
     if (pubkey.length === 65) {
         const parity = pubkey[64] & 1;
-        const newKey = pubkey.slice(0, 33);
+        const newKey = Buffer.from(pubkey.subarray(0, 33));
         newKey[0] = 2 | parity;
         return newKey;
     }
-    return pubkey.slice();
+    return Buffer.from(pubkey);
 }
 
 function isPubkeyLike(buf: Buffer): boolean {
@@ -2170,8 +2217,8 @@ function getMeaningfulScript(
 
     if (isP2SHP2WSH) {
         meaningfulScript = witnessScript!;
-        checkRedeemScript(index, script, redeemScript!, ioType);
-        checkWitnessScript(index, redeemScript!, witnessScript!, ioType);
+        checkRedeemScript(index, script, redeemScript, ioType);
+        checkWitnessScript(index, redeemScript, witnessScript!, ioType);
         checkInvalidP2WSH(meaningfulScript);
     } else if (isP2WSH) {
         meaningfulScript = witnessScript!;

package/src/script.ts

@@ -36,7 +36,7 @@ export function countNonPushOnlyOPs(value: Stack): number {
     return value.length - value.filter(isPushOnlyChunk).length;
 }
 
-function asMinimalOP(buffer: Buffer): number | void {
+function asMinimalOP(buffer: Buffer): number | undefined {
     if (buffer.length === 0) return opcodes.OP_0;
     if (buffer.length !== 1) return;
     if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE + buffer[0];
@@ -135,7 +135,7 @@ export function decompile(buffer: Buffer | Array<number | Buffer>): Array<number
             // attempt to read too much data?
             if (i + d.number > buffer.length) return null;
 
-            const data = buffer.slice(i, i + d.number);
+            const data = buffer.subarray(i, i + d.number);
             i += d.number;
 
             // decompile minimally
@@ -176,7 +176,7 @@ export function toASM(chunks: Buffer | Array<number | Buffer>): string {
             if (singleChunkIsBuffer(chunk)) {
                 const op = asMinimalOP(chunk);
                 if (op === undefined) return chunk.toString('hex');
-                chunk = op as number;
+                chunk = op;
             }
 
             // opcode!
@@ -240,7 +240,7 @@ export function isCanonicalScriptSignature(buffer: Buffer): boolean {
     if (!Buffer.isBuffer(buffer)) return false;
     if (!isDefinedHashType(buffer[buffer.length - 1])) return false;
 
-    return bip66.check(buffer.slice(0, -1));
+    return bip66.check(buffer.subarray(0, -1));
 }
 
 export const number = scriptNumber;

package/src/script_signature.ts

@@ -15,7 +15,7 @@ function toDER(x: Buffer): Buffer {
     let i = 0;
     while (x[i] === 0) ++i;
     if (i === x.length) return ZERO;
-    x = x.slice(i);
+    x = x.subarray(i);
     if (x[0] & 0x80) return Buffer.concat([ZERO, x], 1 + x.length);
     return x;
 }
@@ -28,7 +28,7 @@ function toDER(x: Buffer): Buffer {
  * @returns The converted buffer.
  */
 function fromDER(x: Buffer): Buffer {
-    if (x[0] === 0x00) x = x.slice(1);
+    if (x[0] === 0x00) x = x.subarray(1);
     const buffer = Buffer.alloc(32, 0);
     const bstart = Math.max(0, 32 - x.length);
     x.copy(buffer, bstart);
@@ -50,10 +50,10 @@ interface ScriptSignature {
 export function decode(buffer: Buffer): ScriptSignature {
     const hashType = buffer.readUInt8(buffer.length - 1);
     if (!isDefinedHashType(hashType)) {
-        throw new Error('Invalid hashType ' + hashType);
+        throw new Error(`Invalid hashType ${hashType}`);
     }
 
-    const decoded = bip66.decode(buffer.slice(0, -1));
+    const decoded = bip66.decode(buffer.subarray(0, -1));
     const r = fromDER(decoded.r);
     const s = fromDER(decoded.s);
     const signature = Buffer.concat([r, s], 64);
@@ -78,14 +78,14 @@ export function encode(signature: Buffer, hashType: number): Buffer {
     );
 
     if (!isDefinedHashType(hashType)) {
-        throw new Error('Invalid hashType ' + hashType);
+        throw new Error(`Invalid hashType ${hashType}`);
     }
 
     const hashTypeBuffer = Buffer.allocUnsafe(1);
     hashTypeBuffer.writeUInt8(hashType, 0);
 
-    const r = toDER(signature.slice(0, 32));
-    const s = toDER(signature.slice(32, 64));
+    const r = toDER(signature.subarray(0, 32));
+    const s = toDER(signature.subarray(32, 64));
 
     return Buffer.concat([bip66.encode(r, s), hashTypeBuffer]);
 }