@btc-vision/bitcoin 6.4.8 → 6.4.10

package/browser/opcodes.d.ts

@@ -0,0 +1,125 @@
+export interface Opcodes {
+    OP_FALSE: number;
+    OP_0: number;
+    OP_PUSHDATA1: number;
+    OP_PUSHDATA2: number;
+    OP_PUSHDATA4: number;
+    OP_1NEGATE: number;
+    OP_RESERVED: number;
+    OP_TRUE: number;
+    OP_1: number;
+    OP_2: number;
+    OP_3: number;
+    OP_4: number;
+    OP_5: number;
+    OP_6: number;
+    OP_7: number;
+    OP_8: number;
+    OP_9: number;
+    OP_10: number;
+    OP_11: number;
+    OP_12: number;
+    OP_13: number;
+    OP_14: number;
+    OP_15: number;
+    OP_16: number;
+    OP_NOP: number;
+    OP_VER: number;
+    OP_IF: number;
+    OP_NOTIF: number;
+    OP_VERIF: number;
+    OP_VERNOTIF: number;
+    OP_ELSE: number;
+    OP_ENDIF: number;
+    OP_VERIFY: number;
+    OP_RETURN: number;
+    OP_TOALTSTACK: number;
+    OP_FROMALTSTACK: number;
+    OP_2DROP: number;
+    OP_2DUP: number;
+    OP_3DUP: number;
+    OP_2OVER: number;
+    OP_2ROT: number;
+    OP_2SWAP: number;
+    OP_IFDUP: number;
+    OP_DEPTH: number;
+    OP_DROP: number;
+    OP_DUP: number;
+    OP_NIP: number;
+    OP_OVER: number;
+    OP_PICK: number;
+    OP_ROLL: number;
+    OP_ROT: number;
+    OP_SWAP: number;
+    OP_TUCK: number;
+    OP_CAT: number;
+    OP_SUBSTR: number;
+    OP_LEFT: number;
+    OP_RIGHT: number;
+    OP_SIZE: number;
+    OP_INVERT: number;
+    OP_AND: number;
+    OP_OR: number;
+    OP_XOR: number;
+    OP_EQUAL: number;
+    OP_EQUALVERIFY: number;
+    OP_RESERVED1: number;
+    OP_RESERVED2: number;
+    OP_1ADD: number;
+    OP_1SUB: number;
+    OP_2MUL: number;
+    OP_2DIV: number;
+    OP_NEGATE: number;
+    OP_ABS: number;
+    OP_NOT: number;
+    OP_0NOTEQUAL: number;
+    OP_ADD: number;
+    OP_SUB: number;
+    OP_MUL: number;
+    OP_DIV: number;
+    OP_MOD: number;
+    OP_LSHIFT: number;
+    OP_RSHIFT: number;
+    OP_BOOLAND: number;
+    OP_BOOLOR: number;
+    OP_NUMEQUAL: number;
+    OP_NUMEQUALVERIFY: number;
+    OP_NUMNOTEQUAL: number;
+    OP_LESSTHAN: number;
+    OP_GREATERTHAN: number;
+    OP_LESSTHANOREQUAL: number;
+    OP_GREATERTHANOREQUAL: number;
+    OP_MIN: number;
+    OP_MAX: number;
+    OP_WITHIN: number;
+    OP_RIPEMD160: number;
+    OP_SHA1: number;
+    OP_SHA256: number;
+    OP_HASH160: number;
+    OP_HASH256: number;
+    OP_CODESEPARATOR: number;
+    OP_CHECKSIG: number;
+    OP_CHECKSIGVERIFY: number;
+    OP_CHECKMULTISIG: number;
+    OP_CHECKMULTISIGVERIFY: number;
+    OP_CHECKLOCKTIMEVERIFY: number;
+    OP_CHECKSEQUENCEVERIFY: number;
+    OP_CHECKSIGADD: number;
+    OP_NOP1: number;
+    OP_NOP2: number;
+    OP_NOP3: number;
+    OP_NOP4: number;
+    OP_NOP5: number;
+    OP_NOP6: number;
+    OP_NOP7: number;
+    OP_NOP8: number;
+    OP_NOP9: number;
+    OP_NOP10: number;
+    OP_PUBKEYHASH: number;
+    OP_PUBKEY: number;
+    OP_INVALIDOPCODE: number;
+}
+export declare const opcodes: Opcodes;
+export declare const REVERSE_OPS: {
+    [key: number]: string;
+};

package/browser/script.d.ts

@@ -1,8 +1,8 @@
-import { OPS } from './ops.js';
+import { opcodes } from './opcodes.js';
 import { Stack } from './payments/index.js';
 import * as scriptNumber from './script_number.js';
 import * as scriptSignature from './script_signature.js';
-export { OPS };
+export { opcodes };
 export declare function isPushOnly(value: Stack): boolean;
 export declare function countNonPushOnlyOPs(value: Stack): number;
 export declare function compile(chunks: Buffer | Stack): Buffer;

package/build/address.js

@@ -1,9 +1,10 @@
 import { bech32, bech32m } from 'bech32';
 import * as bs58check from 'bs58check';
-import { opcodes, payments } from './index.js';
 import * as networks from './networks.js';
 import * as bscript from './script.js';
+import { opcodes } from './script.js';
 import { Hash160bit, tuple, typeforce, UInt8 } from './types.js';
+import { payments } from './index.js';
 export const FUTURE_SEGWIT_MAX_SIZE = 40;
 export const FUTURE_SEGWIT_MIN_SIZE = 2;
 export const FUTURE_SEGWIT_MAX_VERSION = 15;
@@ -17,7 +18,7 @@ const FUTURE_SEGWIT_VERSION_WARNING = 'WARNING: Sending to a future segwit versi
     'then decide when it is safe to use which version of segwit.';
 export const isUnknownSegwitVersion = (output) => {
     try {
-        const data = output.subarray(2);
+        const data = Buffer.from(output.subarray(2));
         if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE) {
             throw new TypeError('Invalid program length for segwit address');
         }
@@ -50,7 +51,7 @@ export function toFutureOPNetAddress(output, network) {
     else {
         throw new TypeError('Unsupported push opcode in script');
     }
-    const program = output.subarray(pushPos, pushPos + progLen);
+    const program = Buffer.from(output.subarray(pushPos, pushPos + progLen));
     if (program.length < FUTURE_SEGWIT_MIN_SIZE || program.length > FUTURE_SEGWIT_MAX_SIZE)
         throw new TypeError('Invalid program length for segwit address');
     const version = opcode === opcodes.OP_0
@@ -64,7 +65,7 @@ export function toFutureOPNetAddress(output, network) {
     return bech32m.encode(network.bech32Opnet, words);
 }
 export function _toFutureSegwitAddress(output, network) {
-    const data = output.subarray(2);
+    const data = Buffer.from(output.subarray(2));
     if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE) {
         throw new TypeError('Invalid program length for segwit address');
     }
@@ -84,7 +85,7 @@ export function fromBase58Check(address) {
     if (payload.length > 21)
         throw new TypeError(address + ' is too long');
     const version = payload.readUInt8(0);
-    const hash = payload.subarray(1);
+    const hash = Buffer.from(payload.subarray(1));
     return { version, hash };
 }
 export function fromBech32(address) {

package/build/bufferutils.js

@@ -124,7 +124,7 @@ export class BufferReader {
         if (this.buffer.length < this.offset + n) {
             throw new Error('Cannot read slice out of bounds');
         }
-        const result = this.buffer.subarray(this.offset, this.offset + n);
+        const result = Buffer.from(this.buffer.subarray(this.offset, this.offset + n));
         this.offset += n;
         return result;
     }

package/build/index.d.ts

@@ -13,7 +13,7 @@ export * as script from './script.js';
 export { Block } from './block.js';
 export * from './crypto.js';
 export * from './psbt.js';
-export { OPS as opcodes } from './ops.js';
+export { opcodes } from './opcodes.js';
 export { Transaction } from './transaction.js';
 export { Network } from './networks.js';
 export { initEccLib } from './ecc_lib.js';

package/build/index.js

@@ -12,7 +12,7 @@ export * as script from './script.js';
 export { Block } from './block.js';
 export * from './crypto.js';
 export * from './psbt.js';
-export { OPS as opcodes } from './ops.js';
+export { opcodes } from './opcodes.js';
 export { Transaction } from './transaction.js';
 export { initEccLib } from './ecc_lib.js';
 export { PaymentType, } from './payments/index.js';

package/build/opcodes.d.ts

@@ -0,0 +1,125 @@
+export interface Opcodes {
+    OP_FALSE: number;
+    OP_0: number;
+    OP_PUSHDATA1: number;
+    OP_PUSHDATA2: number;
+    OP_PUSHDATA4: number;
+    OP_1NEGATE: number;
+    OP_RESERVED: number;
+    OP_TRUE: number;
+    OP_1: number;
+    OP_2: number;
+    OP_3: number;
+    OP_4: number;
+    OP_5: number;
+    OP_6: number;
+    OP_7: number;
+    OP_8: number;
+    OP_9: number;
+    OP_10: number;
+    OP_11: number;
+    OP_12: number;
+    OP_13: number;
+    OP_14: number;
+    OP_15: number;
+    OP_16: number;
+    OP_NOP: number;
+    OP_VER: number;
+    OP_IF: number;
+    OP_NOTIF: number;
+    OP_VERIF: number;
+    OP_VERNOTIF: number;
+    OP_ELSE: number;
+    OP_ENDIF: number;
+    OP_VERIFY: number;
+    OP_RETURN: number;
+    OP_TOALTSTACK: number;
+    OP_FROMALTSTACK: number;
+    OP_2DROP: number;
+    OP_2DUP: number;
+    OP_3DUP: number;
+    OP_2OVER: number;
+    OP_2ROT: number;
+    OP_2SWAP: number;
+    OP_IFDUP: number;
+    OP_DEPTH: number;
+    OP_DROP: number;
+    OP_DUP: number;
+    OP_NIP: number;
+    OP_OVER: number;
+    OP_PICK: number;
+    OP_ROLL: number;
+    OP_ROT: number;
+    OP_SWAP: number;
+    OP_TUCK: number;
+    OP_CAT: number;
+    OP_SUBSTR: number;
+    OP_LEFT: number;
+    OP_RIGHT: number;
+    OP_SIZE: number;
+    OP_INVERT: number;
+    OP_AND: number;
+    OP_OR: number;
+    OP_XOR: number;
+    OP_EQUAL: number;
+    OP_EQUALVERIFY: number;
+    OP_RESERVED1: number;
+    OP_RESERVED2: number;
+    OP_1ADD: number;
+    OP_1SUB: number;
+    OP_2MUL: number;
+    OP_2DIV: number;
+    OP_NEGATE: number;
+    OP_ABS: number;
+    OP_NOT: number;
+    OP_0NOTEQUAL: number;
+    OP_ADD: number;
+    OP_SUB: number;
+    OP_MUL: number;
+    OP_DIV: number;
+    OP_MOD: number;
+    OP_LSHIFT: number;
+    OP_RSHIFT: number;
+    OP_BOOLAND: number;
+    OP_BOOLOR: number;
+    OP_NUMEQUAL: number;
+    OP_NUMEQUALVERIFY: number;
+    OP_NUMNOTEQUAL: number;
+    OP_LESSTHAN: number;
+    OP_GREATERTHAN: number;
+    OP_LESSTHANOREQUAL: number;
+    OP_GREATERTHANOREQUAL: number;
+    OP_MIN: number;
+    OP_MAX: number;
+    OP_WITHIN: number;
+    OP_RIPEMD160: number;
+    OP_SHA1: number;
+    OP_SHA256: number;
+    OP_HASH160: number;
+    OP_HASH256: number;
+    OP_CODESEPARATOR: number;
+    OP_CHECKSIG: number;
+    OP_CHECKSIGVERIFY: number;
+    OP_CHECKMULTISIG: number;
+    OP_CHECKMULTISIGVERIFY: number;
+    OP_CHECKLOCKTIMEVERIFY: number;
+    OP_CHECKSEQUENCEVERIFY: number;
+    OP_CHECKSIGADD: number;
+    OP_NOP1: number;
+    OP_NOP2: number;
+    OP_NOP3: number;
+    OP_NOP4: number;
+    OP_NOP5: number;
+    OP_NOP6: number;
+    OP_NOP7: number;
+    OP_NOP8: number;
+    OP_NOP9: number;
+    OP_NOP10: number;
+    OP_PUBKEYHASH: number;
+    OP_PUBKEY: number;
+    OP_INVALIDOPCODE: number;
+}
+export declare const opcodes: Opcodes;
+export declare const REVERSE_OPS: {
+    [key: number]: string;
+};

package/build/opcodes.js

@@ -0,0 +1,126 @@
+export const opcodes = {
+    OP_FALSE: 0,
+    OP_0: 0,
+    OP_PUSHDATA1: 76,
+    OP_PUSHDATA2: 77,
+    OP_PUSHDATA4: 78,
+    OP_1NEGATE: 79,
+    OP_RESERVED: 80,
+    OP_TRUE: 81,
+    OP_1: 81,
+    OP_2: 82,
+    OP_3: 83,
+    OP_4: 84,
+    OP_5: 85,
+    OP_6: 86,
+    OP_7: 87,
+    OP_8: 88,
+    OP_9: 89,
+    OP_10: 90,
+    OP_11: 91,
+    OP_12: 92,
+    OP_13: 93,
+    OP_14: 94,
+    OP_15: 95,
+    OP_16: 96,
+    OP_NOP: 97,
+    OP_VER: 98,
+    OP_IF: 99,
+    OP_NOTIF: 100,
+    OP_VERIF: 101,
+    OP_VERNOTIF: 102,
+    OP_ELSE: 103,
+    OP_ENDIF: 104,
+    OP_VERIFY: 105,
+    OP_RETURN: 106,
+    OP_TOALTSTACK: 107,
+    OP_FROMALTSTACK: 108,
+    OP_2DROP: 109,
+    OP_2DUP: 110,
+    OP_3DUP: 111,
+    OP_2OVER: 112,
+    OP_2ROT: 113,
+    OP_2SWAP: 114,
+    OP_IFDUP: 115,
+    OP_DEPTH: 116,
+    OP_DROP: 117,
+    OP_DUP: 118,
+    OP_NIP: 119,
+    OP_OVER: 120,
+    OP_PICK: 121,
+    OP_ROLL: 122,
+    OP_ROT: 123,
+    OP_SWAP: 124,
+    OP_TUCK: 125,
+    OP_CAT: 126,
+    OP_SUBSTR: 127,
+    OP_LEFT: 128,
+    OP_RIGHT: 129,
+    OP_SIZE: 130,
+    OP_INVERT: 131,
+    OP_AND: 132,
+    OP_OR: 133,
+    OP_XOR: 134,
+    OP_EQUAL: 135,
+    OP_EQUALVERIFY: 136,
+    OP_RESERVED1: 137,
+    OP_RESERVED2: 138,
+    OP_1ADD: 139,
+    OP_1SUB: 140,
+    OP_2MUL: 141,
+    OP_2DIV: 142,
+    OP_NEGATE: 143,
+    OP_ABS: 144,
+    OP_NOT: 145,
+    OP_0NOTEQUAL: 146,
+    OP_ADD: 147,
+    OP_SUB: 148,
+    OP_MUL: 149,
+    OP_DIV: 150,
+    OP_MOD: 151,
+    OP_LSHIFT: 152,
+    OP_RSHIFT: 153,
+    OP_BOOLAND: 154,
+    OP_BOOLOR: 155,
+    OP_NUMEQUAL: 156,
+    OP_NUMEQUALVERIFY: 157,
+    OP_NUMNOTEQUAL: 158,
+    OP_LESSTHAN: 159,
+    OP_GREATERTHAN: 160,
+    OP_LESSTHANOREQUAL: 161,
+    OP_GREATERTHANOREQUAL: 162,
+    OP_MIN: 163,
+    OP_MAX: 164,
+    OP_WITHIN: 165,
+    OP_RIPEMD160: 166,
+    OP_SHA1: 167,
+    OP_SHA256: 168,
+    OP_HASH160: 169,
+    OP_HASH256: 170,
+    OP_CODESEPARATOR: 171,
+    OP_CHECKSIG: 172,
+    OP_CHECKSIGVERIFY: 173,
+    OP_CHECKMULTISIG: 174,
+    OP_CHECKMULTISIGVERIFY: 175,
+    OP_NOP1: 176,
+    OP_NOP2: 177,
+    OP_CHECKLOCKTIMEVERIFY: 177,
+    OP_NOP3: 178,
+    OP_CHECKSEQUENCEVERIFY: 178,
+    OP_NOP4: 179,
+    OP_NOP5: 180,
+    OP_NOP6: 181,
+    OP_NOP7: 182,
+    OP_NOP8: 183,
+    OP_NOP9: 184,
+    OP_NOP10: 185,
+    OP_CHECKSIGADD: 186,
+    OP_PUBKEYHASH: 253,
+    OP_PUBKEY: 254,
+    OP_INVALIDOPCODE: 255,
+};
+export const REVERSE_OPS = {};
+for (const op of Object.keys(opcodes)) {
+    const code = opcodes[op];
+    REVERSE_OPS[code] = op;
+}

package/build/payments/embed.js

@@ -3,7 +3,7 @@ import * as bscript from '../script.js';
 import { stacksEqual, typeforce as typef } from '../types.js';
 import { PaymentType } from './index.js';
 import * as lazy from './lazy.js';
-const OPS = bscript.OPS;
+const OPS = bscript.opcodes;
 export function p2data(a, opts) {
     if (!a.data && !a.output)
         throw new TypeError('Not enough data');

package/build/payments/p2ms.js

@@ -3,7 +3,7 @@ import * as bscript from '../script.js';
 import { isPoint, stacksEqual, typeforce as typef } from '../types.js';
 import { PaymentType } from './index.js';
 import * as lazy from './lazy.js';
-const OPS = bscript.OPS;
+const OPS = bscript.opcodes;
 const OP_INT_BASE = OPS.OP_RESERVED;
 export function p2ms(a, opts) {
     if (!a.input && !a.output && !(a.pubkeys && a.m !== undefined) && !a.signatures)

package/build/payments/p2op.js

@@ -6,7 +6,7 @@ import * as bscript from '../script.js';
 import { typeforce as typef } from '../types.js';
 import * as lazy from './lazy.js';
 import { PaymentType } from './index.js';
-const OPS = bscript.OPS;
+const OPS = bscript.opcodes;
 const P2OP_WITNESS_VERSION = 0x10;
 const MIN_SIZE = 2;
 const MAX_SIZE = 40;

package/build/payments/p2pk.js

@@ -3,7 +3,7 @@ import * as bscript from '../script.js';
 import { isPoint, typeforce as typef } from '../types.js';
 import { PaymentType } from './index.js';
 import * as lazy from './lazy.js';
-const OPS = bscript.OPS;
+const OPS = bscript.opcodes;
 export function p2pk(a, opts) {
     if (!a.input && !a.output && !a.pubkey && !a.input && !a.signature)
         throw new TypeError('Not enough data');

package/build/payments/p2pkh.js

@@ -6,7 +6,7 @@ import { isPoint, typeforce as typef } from '../types.js';
 import { PaymentType } from './index.js';
 import * as lazy from './lazy.js';
 import { decompressPublicKey } from '../psbt/psbtutils.js';
-const OPS = bscript.OPS;
+const OPS = bscript.opcodes;
 export function p2pkh(a, opts) {
     if (!a.address && !a.hash && !a.output && !a.pubkey && !a.input) {
         throw new TypeError('Not enough data');

package/build/payments/p2sh.js

@@ -3,9 +3,9 @@ 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 { PaymentType } from './index.js';
+import { PaymentType, } from './index.js';
 import * as lazy from './lazy.js';
-const OPS = bscript.OPS;
+const OPS = bscript.opcodes;
 export function p2sh(a, opts) {
     if (!a.address && !a.hash && !a.output && !a.redeem && !a.input) {
         throw new TypeError('Not enough data');
@@ -31,7 +31,7 @@ export function p2sh(a, opts) {
     }
     const o = {
         network,
-        name: PaymentType.P2SH
+        name: PaymentType.P2SH,
     };
     const _address = lazy.value(() => {
         const payload = Buffer.from(bs58check.default.decode(a.address));

package/build/payments/p2tr.js

@@ -8,7 +8,7 @@ import { isTaptree, stacksEqual, TAPLEAF_VERSION_MASK, typeforce as typef } from
 import { findScriptPath, LEAF_VERSION_TAPSCRIPT, rootHashFromPath, tapleafHash, toHashTree, tweakKey, } from './bip341.js';
 import { PaymentType } from './index.js';
 import * as lazy from './lazy.js';
-const OPS = bscript.OPS;
+const OPS = bscript.opcodes;
 const TAPROOT_WITNESS_VERSION = 0x01;
 const ANNEX_PREFIX = 0x50;
 export function p2tr(a, opts) {

package/build/payments/p2wpkh.js

@@ -5,7 +5,7 @@ import * as bscript from '../script.js';
 import { isPoint, typeforce as typef } from '../types.js';
 import { PaymentType } from './index.js';
 import * as lazy from './lazy.js';
-const OPS = bscript.OPS;
+const OPS = bscript.opcodes;
 const EMPTY_BUFFER = Buffer.alloc(0);
 export function p2wpkh(a, opts) {
     if (!a.address && !a.hash && !a.output && !a.pubkey && !a.witness)
@@ -34,7 +34,7 @@ export function p2wpkh(a, opts) {
     const network = a.network || BITCOIN_NETWORK;
     const o = {
         name: PaymentType.P2WPKH,
-        network
+        network,
     };
     lazy.prop(o, 'address', () => {
         if (!o.hash)

package/build/payments/p2wsh.js

@@ -5,7 +5,7 @@ import * as bscript from '../script.js';
 import { isPoint, stacksEqual, typeforce as typef } from '../types.js';
 import { PaymentType } from './index.js';
 import * as lazy from './lazy.js';
-const OPS = bscript.OPS;
+const OPS = bscript.opcodes;
 const EMPTY_BUFFER = Buffer.alloc(0);
 function chunkHasUncompressedPubkey(chunk) {
     if (Buffer.isBuffer(chunk) && chunk.length === 65 && chunk[0] === 0x04 && isPoint(chunk)) {
@@ -52,7 +52,7 @@ export function p2wsh(a, opts) {
     }
     const o = {
         network,
-        name: PaymentType.P2WSH
+        name: PaymentType.P2WSH,
     };
     lazy.prop(o, 'address', () => {
         if (!o.hash)

package/build/psbt.js

@@ -948,10 +948,10 @@ function getAllTaprootHashesForSig(inputIndex, input, inputs, cache) {
 }
 function getPrevoutTaprootKey(inputIndex, input, cache) {
     const { script } = getScriptAndAmountFromUtxo(inputIndex, input, cache);
-    return isP2TR(script) ? script.subarray(2, 34) : null;
+    return isP2TR(script) ? Buffer.from(script.subarray(2, 34)) : null;
 }
 function trimTaprootSig(signature) {
-    return signature.length === 64 ? signature : signature.subarray(0, 64);
+    return signature.length === 64 ? signature : Buffer.from(signature.subarray(0, 64));
 }
 function getTaprootHashesForSig(inputIndex, input, inputs, pubkey, cache, tapLeafHashToSign, allowedSighashTypes) {
     const unsignedTx = cache.__TX;

package/build/push_data.js

@@ -1,6 +1,6 @@
-import { OPS } from './ops.js';
+import { opcodes } from './opcodes.js';
 export function encodingLength(i) {
-    return i < OPS.OP_PUSHDATA1 ? 1 : i <= 0xff ? 2 : i <= 0xffff ? 3 : 5;
+    return i < opcodes.OP_PUSHDATA1 ? 1 : i <= 0xff ? 2 : i <= 0xffff ? 3 : 5;
 }
 export function encode(buffer, num, offset) {
     const size = encodingLength(num);
@@ -8,15 +8,15 @@ export function encode(buffer, num, offset) {
         buffer.writeUInt8(num, offset);
     }
     else if (size === 2) {
-        buffer.writeUInt8(OPS.OP_PUSHDATA1, offset);
+        buffer.writeUInt8(opcodes.OP_PUSHDATA1, offset);
         buffer.writeUInt8(num, offset + 1);
     }
     else if (size === 3) {
-        buffer.writeUInt8(OPS.OP_PUSHDATA2, offset);
+        buffer.writeUInt8(opcodes.OP_PUSHDATA2, offset);
         buffer.writeUInt16LE(num, offset + 1);
     }
     else {
-        buffer.writeUInt8(OPS.OP_PUSHDATA4, offset);
+        buffer.writeUInt8(opcodes.OP_PUSHDATA4, offset);
         buffer.writeUInt32LE(num, offset + 1);
     }
     return size;
@@ -25,17 +25,17 @@ export function decode(buffer, offset) {
     const opcode = buffer.readUInt8(offset);
     let num;
     let size;
-    if (opcode < OPS.OP_PUSHDATA1) {
+    if (opcode < opcodes.OP_PUSHDATA1) {
         num = opcode;
         size = 1;
     }
-    else if (opcode === OPS.OP_PUSHDATA1) {
+    else if (opcode === opcodes.OP_PUSHDATA1) {
         if (offset + 2 > buffer.length)
             return null;
         num = buffer.readUInt8(offset + 1);
         size = 2;
     }
-    else if (opcode === OPS.OP_PUSHDATA2) {
+    else if (opcode === opcodes.OP_PUSHDATA2) {
         if (offset + 3 > buffer.length)
             return null;
         num = buffer.readUInt16LE(offset + 1);
@@ -44,7 +44,7 @@ export function decode(buffer, offset) {
     else {
         if (offset + 5 > buffer.length)
             return null;
-        if (opcode !== OPS.OP_PUSHDATA4)
+        if (opcode !== opcodes.OP_PUSHDATA4)
             throw new Error('Unexpected opcode');
         num = buffer.readUInt32LE(offset + 1);
         size = 5;

package/build/script.d.ts

@@ -1,8 +1,8 @@
-import { OPS } from './ops.js';
+import { opcodes } from './opcodes.js';
 import { Stack } from './payments/index.js';
 import * as scriptNumber from './script_number.js';
 import * as scriptSignature from './script_signature.js';
-export { OPS };
+export { opcodes };
 export declare function isPushOnly(value: Stack): boolean;
 export declare function countNonPushOnlyOPs(value: Stack): number;
 export declare function compile(chunks: Buffer | Stack): Buffer;