@btc-vision/bitcoin 6.4.11 → 6.5.2

package/build/types.d.ts

@@ -1,4 +1,6 @@
-export declare const typeforce: any;
+import 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/types.js

@@ -1,6 +1,6 @@
 import { Buffer as NBuffer } from 'buffer';
-import * as _typeforce from 'typeforce';
-export const typeforce = _typeforce.default;
+import typeforce from 'typeforce';
+export { typeforce };
 const ZERO32 = NBuffer.alloc(32, 0);
 const EC_P = NBuffer.from('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f', 'hex');
 export function stacksEqual(a, b) {
@@ -16,7 +16,7 @@ export function isPoint(p) {
     if (p.length < 33)
         return false;
     const t = p[0];
-    const x = p.slice(1, 33);
+    const x = p.subarray(1, 33);
     if (x.compare(ZERO32) === 0)
         return false;
     if (x.compare(EC_P) >= 0)
@@ -26,7 +26,7 @@ export function isPoint(p) {
     }
     if (p.length !== 65)
         return false;
-    const y = p.slice(33);
+    const y = p.subarray(33);
     if (y.compare(ZERO32) === 0)
         return false;
     if (y.compare(EC_P) >= 0)
@@ -39,16 +39,17 @@ export function Satoshi(value) {
 }
 export const TAPLEAF_VERSION_MASK = 0xfe;
 export function isTapleaf(o) {
-    if (!o || !('output' in o))
+    if (!o || typeof o !== 'object' || !('output' in o))
         return false;
-    if (!NBuffer.isBuffer(o.output))
+    const obj = o;
+    if (!NBuffer.isBuffer(obj.output))
         return false;
-    if (o.version !== undefined)
-        return (o.version & TAPLEAF_VERSION_MASK) === o.version;
+    if (obj.version !== undefined)
+        return (obj.version & TAPLEAF_VERSION_MASK) === obj.version;
     return true;
 }
 export function isTaptree(scriptTree) {
-    if (!Array(scriptTree))
+    if (!globalThis.Array.isArray(scriptTree))
         return isTapleaf(scriptTree);
     if (scriptTree.length !== 2)
         return false;

package/package.json

@@ -1,22 +1,27 @@
 {
     "name": "@btc-vision/bitcoin",
     "type": "module",
-    "version": "6.4.11",
+    "version": "6.5.2",
     "description": "Client-side Bitcoin JavaScript library",
     "engines": {
-        "node": ">=16.0.0"
+        "node": ">=24.0.0"
     },
     "exports": {
         ".": {
-            "browser": "./browser/index.js",
-            "import": "./build/index.js",
-            "require": "./build/index.js",
-            "types": "./build/index.d.ts"
+            "browser": {
+                "types": "./browser/index.d.ts",
+                "import": "./browser/index.js"
+            },
+            "node": {
+                "types": "./build/index.d.ts",
+                "import": "./build/index.js"
+            },
+            "types": "./build/index.d.ts",
+            "import": "./build/index.js"
         },
         "./browser": {
-            "import": "./browser/index.js",
-            "require": "./browser/index.js",
-            "types": "./browser/index.d.ts"
+            "types": "./browser/index.d.ts",
+            "import": "./browser/index.js"
         }
     },
     "browser": {
@@ -48,101 +53,70 @@
         "url": "https://github.com/btc-vision/bitcoin.git"
     },
     "scripts": {
-        "watch": "gulp watch",
-        "build": "gulp build",
+        "watch": "tsc --watch",
+        "build": "eslint src && tsc",
         "setup": "npm i && npm run build",
-        "browserBuild": "webpack --mode production",
+        "browserBuild": "vite build --config vite.config.browser.ts",
         "audit": "better-npm-audit audit -l high",
-        "build:tests": "npm run clean:jstests && tsc -p ./test/tsconfig.json",
         "clean": "rimraf build",
-        "clean:jstests": "rimraf --glob \"test/**/!(ts-node-register).js\"",
-        "coverage-report": "npm run build && npm run nobuild:coverage-report",
-        "coverage-html": "npm run build && npm run nobuild:coverage-html",
-        "coverage": "npm run build && npm run nobuild:coverage",
+        "coverage": "vitest run --coverage",
         "doc": "typedoc",
         "format": "npm run prettier -- --write",
-        "formatjs": "npm run prettierjs -- --write",
-        "format:ci": "npm run prettier -- --check && npm run prettierjs -- --check",
+        "formatjs": "npm run prettier -- --write",
+        "format:ci": "npm run prettier -- --check && npm run prettier -- --check",
         "gitdiff:ci": "npm run build && git diff --exit-code",
-        "integration": "npm run build && npm run nobuild:integration",
+        "integration": "vitest run --config vitest.config.integration.ts",
         "lint": "eslint src/**",
         "lint:tests": "eslint test/**/*.spec.ts",
-        "mocha:ts": "cross-env TS_NODE_PROJECT=test/tsconfig.json mocha -n loader=ts-node/esm -n experimental-specifier-resolution=node --extension ts --timeout 10000 --recursive \"test/**/*.spec.ts\"",
-        "nobuild:coverage-report": "nyc report --reporter=lcov",
-        "nobuild:coverage-html": "nyc report --reporter=html",
-        "nobuild:coverage": "npm run build:tests && nyc --check-coverage --branches 85 --functions 90 --lines 90 mocha && npm run clean:jstests",
-        "nobuild:integration": "npm run mocha:ts -- --timeout 50000 'test/integration/*.ts'",
-        "nobuild:unit": "npm run mocha:ts -- 'test/*.ts'",
         "prettier": "prettier \"src/**/*.ts\" \"test/**/*.ts\" --ignore-path ./.prettierignore",
-        "test": "npm run build && npm run format:ci && npm run lint && npm run nobuild:coverage",
-        "unit": "npm run build && npm run nobuild:unit"
+        "test": "npm run build && npm run format:ci && npm run lint && vitest run",
+        "test:watch": "vitest",
+        "unit": "vitest run"
     },
     "devDependencies": {
-        "@babel/core": "^7.27.1",
-        "@babel/plugin-proposal-class-properties": "^7.18.6",
-        "@babel/plugin-transform-runtime": "^7.27.1",
-        "@babel/preset-env": "^7.27.2",
-        "@babel/preset-flow": "^7.27.1",
-        "@babel/preset-react": "^7.27.1",
-        "@babel/preset-typescript": "^7.27.1",
+        "@eslint/js": "^9.39.2",
         "@types/bs58check": "^2.1.2",
-        "@types/mocha": "^10.0.10",
-        "@types/node": "^22.15.21",
-        "@types/proxyquire": "^1.3.31",
+        "@types/node": "^22.19.3",
         "@types/randombytes": "^2.0.3",
+        "@vitest/coverage-v8": "^4.0.16",
         "better-npm-audit": "^3.11.0",
         "bip39": "^3.1.0",
         "bip65": "^1.0.3",
         "bip68": "^1.0.4",
         "bs58": "^6.0.0",
         "dhttp": "^3.0.3",
-        "ecpair": "^2.0.1",
-        "eslint": "9.38.0",
-        "gulp": "^5.0.0",
-        "gulp-cached": "^1.1.1",
-        "gulp-typescript": "^6.0.0-alpha.1",
-        "hoodwink": "^2.0.0",
+        "ecpair": "^2.1.0",
+        "eslint": "^9.39.1",
         "https-browserify": "^1.0.0",
         "minimaldata": "^1.0.2",
-        "mocha": "^11.5.0",
-        "nyc": "^17.1.0",
         "os-browserify": "^0.3.0",
         "prettier": "^3.5.3",
-        "proxyquire": "^2.1.3",
         "randombytes": "^2.1.0",
         "regtest-client": "0.2.1",
         "rimraf": "^6.0.1",
         "stream-browserify": "^3.0.0",
         "stream-http": "^3.2.0",
         "tiny-secp256k1": "^2.2.3",
-        "ts-loader": "^9.5.2",
         "ts-node": "^10.9.2",
         "typedoc": "^0.28.5",
         "typescript": "^5.8.3",
         "typescript-eslint": "^8.32.1",
-        "webpack": "^5.99.9",
-        "webpack-cli": "^6.0.1"
+        "vite": "^7.3.0",
+        "vite-plugin-dts": "^4.5.4",
+        "vite-plugin-node-polyfills": "^0.24.0",
+        "vitest": "^4.0.16"
     },
     "dependencies": {
-        "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
-        "@btc-vision/logger": "^1.0.7",
-        "@eslint/js": "9.38.0",
-        "@noble/hashes": "^1.8.0",
-        "@noble/secp256k1": "^2.2.3",
+        "@btc-vision/bip32": "^6.0.3",
+        "@btc-vision/logger": "^1.0.8",
+        "@noble/hashes": "^2.0.1",
+        "@noble/secp256k1": "^2.3.0",
         "assert": "^2.1.0",
-        "babel-loader": "^10.0.0",
-        "babel-plugin-transform-import-meta": "^2.3.2",
-        "babel-preset-react": "^6.24.1",
-        "babelify": "^10.0.0",
-        "bip32": "^4.0.0",
         "bech32": "^2.0.0",
         "bip174": "^2.1.1",
         "browserify-zlib": "^0.2.0",
         "bs58check": "^4.0.0",
         "buffer": "^6.0.3",
-        "gulp-clean": "^0.4.0",
-        "gulp-eslint-new": "^2.4.0",
-        "gulp-logger-new": "^1.0.1",
         "process": "^0.11.10",
         "typeforce": "^1.18.0",
         "varuint-bitcoin": "^2.0.0"

package/src/address.ts

@@ -179,7 +179,7 @@ export function fromBech32(address: string): Bech32Result {
  * encode address hash to base58 address with version
  */
 export function toBase58Check(hash: Buffer, version: number): string {
-    typeforce(tuple(Hash160bit, UInt8), arguments);
+    typeforce(tuple(Hash160bit, UInt8), [hash, version]);
 
     const payload = Buffer.allocUnsafe(21);
     payload.writeUInt8(version, 0);
@@ -300,5 +300,5 @@ export function toOutputScript(address: string, network?: Network): Buffer {
         }
     }
 
-    return Buffer.from(address, 'hex');
+    throw new TypeError(address + ' has no matching Script');
 }

package/src/bip66.ts

@@ -52,8 +52,8 @@ export function decode(buffer: Buffer): { r: Buffer; s: Buffer } {
 
     // non-BIP66 - extract R, S values
     return {
-        r: buffer.slice(4, 4 + lenR),
-        s: buffer.slice(6 + lenR),
+        r: buffer.subarray(4, 4 + lenR),
+        s: buffer.subarray(6 + lenR),
     };
 }
 

package/src/block.ts

@@ -34,8 +34,11 @@ export class Block {
 
         if (buffer.length === 80) return block;
 
-        const readTransaction = (): any => {
-            const tx = Transaction.fromBuffer(bufferReader.buffer.slice(bufferReader.offset), true);
+        const readTransaction = (): Transaction => {
+            const tx = Transaction.fromBuffer(
+                bufferReader.buffer.subarray(bufferReader.offset),
+                true,
+            );
             bufferReader.offset += tx.byteLength();
             return tx;
         };
@@ -72,7 +75,7 @@ export class Block {
         if (transactions.length === 0) throw errorMerkleNoTxes;
         if (forWitness && !txesHaveWitnessCommit(transactions)) throw errorWitnessNotSegwit;
 
-        const hashes = transactions.map((transaction) => transaction.getHash(forWitness!));
+        const hashes = transactions.map((transaction) => transaction.getHash(forWitness));
 
         const rootHash = fastMerkleRoot(hashes, bcrypto.hash256);
 
@@ -89,8 +92,8 @@ export class Block {
         // The root is prepended with 0xaa21a9ed so check for 0x6a24aa21a9ed
         // If multiple commits are found, the output with highest index is assumed.
         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));
+            out.script.subarray(0, 6).equals(Buffer.from('6a24aa21a9ed', 'hex')),
+        ).map((out) => out.script.subarray(6, 38));
         if (witnessCommits.length === 0) return null;
         // Use the commit with the highest output (should only be one though)
         const result = witnessCommits[witnessCommits.length - 1];

package/src/crypto.ts

@@ -4,9 +4,8 @@
  *
  * @packageDocumentation
  */
-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: Buffer): Buffer {
     return Buffer.from(_ripemd160(Uint8Array.from(buffer)));
@@ -39,7 +38,7 @@ export const TAGS = [
     'KeyAgg list',
     'KeyAgg coefficient',
 ] as const;
-export type TaggedHashPrefix = typeof TAGS[number];
+export type TaggedHashPrefix = (typeof TAGS)[number];
 type TaggedHashPrefixes = {
     [key in TaggedHashPrefix]: Buffer;
 };

package/src/ecc_lib.ts

@@ -15,7 +15,7 @@ export function initEccLib(eccLib: TinySecp256k1Interface | undefined): void {
         _ECCLIB_CACHE.eccLib = eccLib;
     } else if (eccLib !== _ECCLIB_CACHE.eccLib) {
         // new instance, verify it
-        verifyEcc(eccLib!);
+        verifyEcc(eccLib);
         _ECCLIB_CACHE.eccLib = eccLib;
     }
 }

package/src/hooks/HookedSigner.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';
 

package/src/index.ts

@@ -32,10 +32,11 @@ export * from './psbt.js';
 export { opcodes } from './opcodes.js';
 export { Transaction } from './transaction.js';
 /** @hidden */
-export { Network } from './networks.js';
+export type { Network } from './networks.js';
 /** @hidden */
 export { initEccLib } from './ecc_lib.js';
-export {
+export { PaymentType } from './payments/index.js';
+export type {
     Payment,
     PaymentCreator,
     PaymentOpts,
@@ -53,9 +54,8 @@ export {
     P2OPPayment,
     P2OPPaymentParams,
     StackFunction,
-    PaymentType,
 } from './payments/index.js';
-export { Input as TxInput, Output as TxOutput } from './transaction.js';
+export type { Input as TxInput, Output as TxOutput } from './transaction.js';
 
 export interface PsbtInput extends _PsbtInput {}
 
@@ -85,12 +85,12 @@ export * from './bufferutils.js';
 export * from './payments/bip341.js';
 export * from './psbt/psbtutils.js';
 
-export {
+export { TAPLEAF_VERSION_MASK } from './types.js';
+export type {
     Taptree,
     XOnlyPointAddTweakResult,
     Tapleaf,
     TinySecp256k1Interface,
-    TAPLEAF_VERSION_MASK,
 } from './types.js';
 
 const bitcoin = {

package/src/payments/bip341.ts

@@ -49,7 +49,7 @@ export function rootHashFromPath(controlBlock: Buffer, leafHash: Buffer): Buffer
 
     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);
         } else {

package/src/payments/embed.ts

@@ -52,8 +52,7 @@ export function p2data(a: Omit<EmbedPayment, 'name'>, opts?: PaymentOpts): Embed
             if (chunks![0] !== OPS.OP_RETURN) throw new TypeError('Output is invalid');
             if (!chunks!.slice(1).every(typef.Buffer)) throw new TypeError('Output is invalid');
 
-            if (a.data && !stacksEqual(a.data, o.data as Buffer[]))
-                throw new TypeError('Data mismatch');
+            if (a.data && !stacksEqual(a.data, o.data)) throw new TypeError('Data mismatch');
         }
     }
 

package/src/payments/index.ts

@@ -6,8 +6,8 @@
  * @packageDocumentation
  */
 
-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';
@@ -58,8 +58,8 @@ export interface BasePayment {
 
 /** Helper used by redeeming script-template outputs (P2SH, P2WSH). */
 export interface ScriptRedeem extends BasePayment {
-    output?: Buffer;               // script template
-    redeemVersion?: number;       // tapscript leaves etc.
+    output?: Buffer; // script template
+    redeemVersion?: number; // tapscript leaves etc.
     network?: Network; // network parameters (mainnet if omitted)
 }
 

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');