@btc-vision/bitcoin 6.4.9 → 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;

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/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;

package/build/script.js

@@ -1,17 +1,17 @@
 import * as bip66 from './bip66.js';
-import { OPS, REVERSE_OPS } from './ops.js';
+import { opcodes, REVERSE_OPS } from './opcodes.js';
 import * as pushdata from './push_data.js';
 import * as scriptNumber from './script_number.js';
 import * as scriptSignature from './script_signature.js';
 import * as types from './types.js';
 const { typeforce } = types;
-const OP_INT_BASE = OPS.OP_RESERVED;
-export { OPS };
+const OP_INT_BASE = opcodes.OP_RESERVED;
+export { opcodes };
 function isOPInt(value) {
     return (types.Number(value) &&
-        (value === OPS.OP_0 ||
-            (value >= OPS.OP_1 && value <= OPS.OP_16) ||
-            value === OPS.OP_1NEGATE));
+        (value === opcodes.OP_0 ||
+            (value >= opcodes.OP_1 && value <= opcodes.OP_16) ||
+            value === opcodes.OP_1NEGATE));
 }
 function isPushOnlyChunk(value) {
     return types.Buffer(value) || isOPInt(value);
@@ -24,13 +24,13 @@ export function countNonPushOnlyOPs(value) {
 }
 function asMinimalOP(buffer) {
     if (buffer.length === 0)
-        return OPS.OP_0;
+        return opcodes.OP_0;
     if (buffer.length !== 1)
         return;
     if (buffer[0] >= 1 && buffer[0] <= 16)
         return OP_INT_BASE + buffer[0];
     if (buffer[0] === 0x81)
-        return OPS.OP_1NEGATE;
+        return opcodes.OP_1NEGATE;
 }
 function chunksIsBuffer(buf) {
     return Buffer.isBuffer(buf);
@@ -85,7 +85,7 @@ export function decompile(buffer) {
     let i = 0;
     while (i < buffer.length) {
         const opcode = buffer[i];
-        if (opcode > OPS.OP_0 && opcode <= OPS.OP_PUSHDATA4) {
+        if (opcode > opcodes.OP_0 && opcode <= opcodes.OP_PUSHDATA4) {
             const d = pushdata.decode(buffer, i);
             if (d === null)
                 return null;
@@ -131,8 +131,8 @@ export function toASM(chunks) {
 export function fromASM(asm) {
     typeforce(types.String, asm);
     return compile(asm.split(' ').map((chunkStr) => {
-        if (OPS[chunkStr] !== undefined) {
-            return OPS[chunkStr];
+        if (opcodes[chunkStr] !== undefined) {
+            return opcodes[chunkStr];
         }
         typeforce(types.Hex, chunkStr);
         return Buffer.from(chunkStr, 'hex');
@@ -144,7 +144,7 @@ export function toStack(chunks) {
     return chunks.map((op) => {
         if (singleChunkIsBuffer(op))
             return op;
-        if (op === OPS.OP_0)
+        if (op === opcodes.OP_0)
             return Buffer.allocUnsafe(0);
         return scriptNumber.encode(op - OP_INT_BASE);
     });

package/build/transaction.js

@@ -1,7 +1,7 @@
 import { BufferReader, BufferWriter, reverseBuffer, varuint } from './bufferutils.js';
 import * as bcrypto from './crypto.js';
 import * as bscript from './script.js';
-import { OPS as opcodes } from './script.js';
+import { opcodes } from './script.js';
 import * as types from './types.js';
 const { typeforce } = types;
 function varSliceSize(someScript) {