@btc-vision/bitcoin 6.3.1 → 6.3.2

package/src/{push_data.js → push_data.ts}

@@ -1,16 +1,14 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.decode = exports.encode = exports.encodingLength = void 0;
-const ops_1 = require('./ops');
+import { OPS } from './ops.js';
+
 /**
  * Calculates the encoding length of a number used for push data in Bitcoin transactions.
  * @param i The number to calculate the encoding length for.
  * @returns The encoding length of the number.
  */
-function encodingLength(i) {
-    return i < ops_1.OPS.OP_PUSHDATA1 ? 1 : i <= 0xff ? 2 : i <= 0xffff ? 3 : 5;
+export function encodingLength(i: number): number {
+    return i < OPS.OP_PUSHDATA1 ? 1 : i <= 0xff ? 2 : i <= 0xffff ? 3 : 5;
 }
-exports.encodingLength = encodingLength;
+
 /**
  * Encodes a number into a buffer using a variable-length encoding scheme.
  * The encoded buffer is written starting at the specified offset.
@@ -21,63 +19,79 @@ exports.encodingLength = encodingLength;
  * @param offset - The offset at which to start writing the encoded buffer.
  * @returns The size of the encoded buffer.
  */
-function encode(buffer, num, offset) {
+export function encode(buffer: Buffer, num: number, offset: number): number {
     const size = encodingLength(num);
+
     // ~6 bit
     if (size === 1) {
         buffer.writeUInt8(num, offset);
+
         // 8 bit
     } else if (size === 2) {
-        buffer.writeUInt8(ops_1.OPS.OP_PUSHDATA1, offset);
+        buffer.writeUInt8(OPS.OP_PUSHDATA1, offset);
         buffer.writeUInt8(num, offset + 1);
+
         // 16 bit
     } else if (size === 3) {
-        buffer.writeUInt8(ops_1.OPS.OP_PUSHDATA2, offset);
+        buffer.writeUInt8(OPS.OP_PUSHDATA2, offset);
         buffer.writeUInt16LE(num, offset + 1);
+
         // 32 bit
     } else {
-        buffer.writeUInt8(ops_1.OPS.OP_PUSHDATA4, offset);
+        buffer.writeUInt8(OPS.OP_PUSHDATA4, offset);
         buffer.writeUInt32LE(num, offset + 1);
     }
+
     return size;
 }
-exports.encode = encode;
+
 /**
  * Decodes a buffer and returns information about the opcode, number, and size.
  * @param buffer - The buffer to decode.
  * @param offset - The offset within the buffer to start decoding.
  * @returns An object containing the opcode, number, and size, or null if decoding fails.
  */
-function decode(buffer, offset) {
+export function decode(
+    buffer: Buffer,
+    offset: number,
+): {
+    opcode: number;
+    number: number;
+    size: number;
+} | null {
     const opcode = buffer.readUInt8(offset);
-    let num;
-    let size;
+    let num: number;
+    let size: number;
+
     // ~6 bit
-    if (opcode < ops_1.OPS.OP_PUSHDATA1) {
+    if (opcode < OPS.OP_PUSHDATA1) {
         num = opcode;
         size = 1;
+
         // 8 bit
-    } else if (opcode === ops_1.OPS.OP_PUSHDATA1) {
+    } else if (opcode === OPS.OP_PUSHDATA1) {
         if (offset + 2 > buffer.length) return null;
         num = buffer.readUInt8(offset + 1);
         size = 2;
+
         // 16 bit
-    } else if (opcode === ops_1.OPS.OP_PUSHDATA2) {
+    } else if (opcode === OPS.OP_PUSHDATA2) {
         if (offset + 3 > buffer.length) return null;
         num = buffer.readUInt16LE(offset + 1);
         size = 3;
+
         // 32 bit
     } else {
         if (offset + 5 > buffer.length) return null;
-        if (opcode !== ops_1.OPS.OP_PUSHDATA4)
-            throw new Error('Unexpected opcode');
+        if (opcode !== OPS.OP_PUSHDATA4) throw new Error('Unexpected opcode');
+
         num = buffer.readUInt32LE(offset + 1);
         size = 5;
     }
+
     return {
         opcode,
         number: num,
         size,
     };
 }
-exports.decode = decode;

package/src/{script.js → script.ts}

@@ -1,71 +1,60 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.signature =
-    exports.number =
-    exports.isCanonicalScriptSignature =
-    exports.isDefinedHashType =
-    exports.isCanonicalPubKey =
-    exports.toStack =
-    exports.fromASM =
-    exports.toASM =
-    exports.decompile =
-    exports.compile =
-    exports.countNonPushOnlyOPs =
-    exports.isPushOnly =
-    exports.OPS =
-        void 0;
 /**
  * Script tools, including decompile, compile, toASM, fromASM, toStack, isCanonicalPubKey, isCanonicalScriptSignature
  * @packageDocumentation
  */
-const bip66 = require('./bip66');
-const ops_1 = require('./ops');
-Object.defineProperty(exports, 'OPS', {
-    enumerable: true,
-    get: function () {
-        return ops_1.OPS;
-    },
-});
-const pushdata = require('./push_data');
-const scriptNumber = require('./script_number');
-const scriptSignature = require('./script_signature');
-const types = require('./types');
+import * as bip66 from './bip66.js';
+import { Opcodes, OPS, REVERSE_OPS } from './ops.js';
+import { Stack } from './payments/index.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_1.OPS.OP_RESERVED; // OP_1 - 1
-function isOPInt(value) {
+
+const OP_INT_BASE = OPS.OP_RESERVED; // OP_1 - 1
+export { OPS };
+
+function isOPInt(value: number): boolean {
     return (
         types.Number(value) &&
-        (value === ops_1.OPS.OP_0 ||
-            (value >= ops_1.OPS.OP_1 && value <= ops_1.OPS.OP_16) ||
-            value === ops_1.OPS.OP_1NEGATE)
+        (value === OPS.OP_0 ||
+            (value >= OPS.OP_1 && value <= OPS.OP_16) ||
+            value === OPS.OP_1NEGATE)
     );
 }
-function isPushOnlyChunk(value) {
-    return types.Buffer(value) || isOPInt(value);
+
+function isPushOnlyChunk(value: number | Buffer): boolean {
+    return types.Buffer(value) || isOPInt(value as number);
 }
-function isPushOnly(value) {
+
+export function isPushOnly(value: Stack): boolean {
     return types.Array(value) && value.every(isPushOnlyChunk);
 }
-exports.isPushOnly = isPushOnly;
-function countNonPushOnlyOPs(value) {
+
+export function countNonPushOnlyOPs(value: Stack): number {
     return value.length - value.filter(isPushOnlyChunk).length;
 }
-exports.countNonPushOnlyOPs = countNonPushOnlyOPs;
-function asMinimalOP(buffer) {
-    if (buffer.length === 0) return ops_1.OPS.OP_0;
+
+function asMinimalOP(buffer: Buffer): number | void {
+    if (buffer.length === 0) return OPS.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_1.OPS.OP_1NEGATE;
+    if (buffer[0] === 0x81) return OPS.OP_1NEGATE;
 }
-function chunksIsBuffer(buf) {
+
+function chunksIsBuffer(buf: Buffer | Stack): buf is Buffer {
     return Buffer.isBuffer(buf);
 }
-function chunksIsArray(buf) {
+
+function chunksIsArray(buf: Buffer | Stack): buf is Stack {
     return types.Array(buf);
 }
-function singleChunkIsBuffer(buf) {
+
+function singleChunkIsBuffer(buf: number | Buffer): buf is Buffer {
     return Buffer.isBuffer(buf);
 }
+
 /**
  * Compiles an array of chunks into a Buffer.
  *
@@ -73,25 +62,31 @@ function singleChunkIsBuffer(buf) {
  * @returns The compiled Buffer.
  * @throws Error if the compilation fails.
  */
-function compile(chunks) {
+export function compile(chunks: Buffer | Stack): Buffer {
     // TODO: remove me
     if (chunksIsBuffer(chunks)) return chunks;
+
     typeforce(types.Array, chunks);
-    const bufferSize = chunks.reduce((accum, chunk) => {
+
+    const bufferSize = chunks.reduce((accum: number, chunk) => {
         // data chunk
         if (singleChunkIsBuffer(chunk)) {
             // adhere to BIP62.3, minimal push policy
             if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) {
                 return accum + 1;
             }
+
             return accum + pushdata.encodingLength(chunk.length) + chunk.length;
         }
+
         // opcode
         return accum + 1;
     }, 0.0);
+
     const buffer = Buffer.allocUnsafe(bufferSize);
     let offset = 0;
-    chunks.forEach(chunk => {
+
+    chunks.forEach((chunk) => {
         // data chunk
         if (singleChunkIsBuffer(chunk)) {
             // adhere to BIP62.3, minimal push policy
@@ -101,37 +96,48 @@ function compile(chunks) {
                 offset += 1;
                 return;
             }
+
             offset += pushdata.encode(buffer, chunk.length, offset);
             chunk.copy(buffer, offset);
             offset += chunk.length;
+
             // opcode
         } else {
             buffer.writeUInt8(chunk, offset);
             offset += 1;
         }
     });
+
     if (offset !== buffer.length) throw new Error('Could not decode chunks');
     return buffer;
 }
-exports.compile = compile;
-function decompile(buffer) {
+
+export function decompile(buffer: Buffer | Array<number | Buffer>): Array<number | Buffer> | null {
     // TODO: remove me
     if (chunksIsArray(buffer)) return buffer;
+
     typeforce(types.Buffer, buffer);
-    const chunks = [];
+
+    const chunks: Array<number | Buffer> = [];
     let i = 0;
+
     while (i < buffer.length) {
         const opcode = buffer[i];
+
         // data chunk
-        if (opcode > ops_1.OPS.OP_0 && opcode <= ops_1.OPS.OP_PUSHDATA4) {
+        if (opcode > OPS.OP_0 && opcode <= OPS.OP_PUSHDATA4) {
             const d = pushdata.decode(buffer, i);
+
             // did reading a pushDataInt fail?
             if (d === null) return null;
             i += d.size;
+
             // attempt to read too much data?
             if (i + d.number > buffer.length) return null;
+
             const data = buffer.slice(i, i + d.number);
             i += d.number;
+
             // decompile minimally
             const op = asMinimalOP(data);
             if (op !== undefined) {
@@ -139,93 +145,103 @@ function decompile(buffer) {
             } else {
                 chunks.push(data);
             }
+
             // opcode
         } else {
             chunks.push(opcode);
+
             i += 1;
         }
     }
+
     return chunks;
 }
-exports.decompile = decompile;
+
 /**
  * Converts the given chunks into an ASM (Assembly) string representation.
  * If the chunks parameter is a Buffer, it will be decompiled into a Stack before conversion.
  * @param chunks - The chunks to convert into ASM.
  * @returns The ASM string representation of the chunks.
  */
-function toASM(chunks) {
+export function toASM(chunks: Buffer | Array<number | Buffer>): string {
     if (chunksIsBuffer(chunks)) {
-        chunks = decompile(chunks);
+        chunks = decompile(chunks) as Stack;
     }
     if (!chunks) {
         throw new Error('Could not convert invalid chunks to ASM');
     }
     return chunks
-        .map(chunk => {
+        .map((chunk) => {
             // data?
             if (singleChunkIsBuffer(chunk)) {
                 const op = asMinimalOP(chunk);
                 if (op === undefined) return chunk.toString('hex');
-                chunk = op;
+                chunk = op as number;
             }
+
             // opcode!
-            return ops_1.REVERSE_OPS[chunk];
+            return REVERSE_OPS[chunk];
         })
         .join(' ');
 }
-exports.toASM = toASM;
+
 /**
  * Converts an ASM string to a Buffer.
  * @param asm The ASM string to convert.
  * @returns The converted Buffer.
  */
-function fromASM(asm) {
+export function fromASM(asm: string): Buffer {
     typeforce(types.String, asm);
+
     return compile(
-        asm.split(' ').map(chunkStr => {
+        asm.split(' ').map((chunkStr) => {
             // opcode?
-            if (ops_1.OPS[chunkStr] !== undefined) {
-                return ops_1.OPS[chunkStr];
+            if (OPS[chunkStr as keyof Opcodes] !== undefined) {
+                return OPS[chunkStr as keyof Opcodes];
             }
             typeforce(types.Hex, chunkStr);
+
             // data!
             return Buffer.from(chunkStr, 'hex');
         }),
     );
 }
-exports.fromASM = fromASM;
+
 /**
  * Converts the given chunks into a stack of buffers.
  *
  * @param chunks - The chunks to convert.
  * @returns The stack of buffers.
  */
-function toStack(chunks) {
-    chunks = decompile(chunks);
+export function toStack(chunks: Buffer | Array<number | Buffer>): Buffer[] {
+    chunks = decompile(chunks) as Stack;
     typeforce(isPushOnly, chunks);
-    return chunks.map(op => {
+
+    return chunks.map((op) => {
         if (singleChunkIsBuffer(op)) return op;
-        if (op === ops_1.OPS.OP_0) return Buffer.allocUnsafe(0);
+        if (op === OPS.OP_0) return Buffer.allocUnsafe(0);
+
         return scriptNumber.encode(op - OP_INT_BASE);
     });
 }
-exports.toStack = toStack;
-function isCanonicalPubKey(buffer) {
+
+export function isCanonicalPubKey(buffer: Buffer): boolean {
     return types.isPoint(buffer);
 }
-exports.isCanonicalPubKey = isCanonicalPubKey;
-function isDefinedHashType(hashType) {
+
+export function isDefinedHashType(hashType: number): boolean {
     const hashTypeMod = hashType & ~0x80;
+
     // return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE
     return hashTypeMod > 0x00 && hashTypeMod < 0x04;
 }
-exports.isDefinedHashType = isDefinedHashType;
-function isCanonicalScriptSignature(buffer) {
+
+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));
 }
-exports.isCanonicalScriptSignature = isCanonicalScriptSignature;
-exports.number = scriptNumber;
-exports.signature = scriptSignature;
+
+export const number = scriptNumber;
+export const signature = scriptSignature;

package/src/{script_number.js → script_number.ts}

@@ -1,6 +1,3 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.encode = exports.decode = void 0;
 /**
  * Decodes a script number from a buffer.
  *
@@ -11,9 +8,10 @@ exports.encode = exports.decode = void 0;
  * @throws {TypeError} If the script number overflows the maximum length.
  * @throws {Error} If the script number is not minimally encoded when minimal is true.
  */
-function decode(buffer, maxLength, minimal) {
+export function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): number {
     maxLength = maxLength || 4;
     minimal = minimal === undefined ? true : minimal;
+
     const length = buffer.length;
     if (length === 0) return 0;
     if (length > maxLength) throw new TypeError('Script number overflow');
@@ -23,56 +21,52 @@ function decode(buffer, maxLength, minimal) {
                 throw new Error('Non-minimally encoded script number');
         }
     }
+
     // 40-bit
     if (length === 5) {
         const a = buffer.readUInt32LE(0);
         const b = buffer.readUInt8(4);
+
         if (b & 0x80) return -((b & ~0x80) * 0x100000000 + a);
         return b * 0x100000000 + a;
     }
+
     // 32-bit / 24-bit / 16-bit / 8-bit
     let result = 0;
     for (let i = 0; i < length; ++i) {
         result |= buffer[i] << (8 * i);
     }
-    if (buffer[length - 1] & 0x80)
-        return -(result & ~(0x80 << (8 * (length - 1))));
+
+    if (buffer[length - 1] & 0x80) return -(result & ~(0x80 << (8 * (length - 1))));
     return result;
 }
-exports.decode = decode;
-function scriptNumSize(i) {
-    return i > 0x7fffffff
-        ? 5
-        : i > 0x7fffff
-        ? 4
-        : i > 0x7fff
-        ? 3
-        : i > 0x7f
-        ? 2
-        : i > 0x00
-        ? 1
-        : 0;
+
+function scriptNumSize(i: number): number {
+    return i > 0x7fffffff ? 5 : i > 0x7fffff ? 4 : i > 0x7fff ? 3 : i > 0x7f ? 2 : i > 0x00 ? 1 : 0;
 }
+
 /**
  * Encodes a number into a Buffer using a specific format.
  *
  * @param _number - The number to encode.
  * @returns The encoded number as a Buffer.
  */
-function encode(_number) {
+export function encode(_number: number): Buffer {
     let value = Math.abs(_number);
     const size = scriptNumSize(value);
     const buffer = Buffer.allocUnsafe(size);
     const negative = _number < 0;
+
     for (let i = 0; i < size; ++i) {
         buffer.writeUInt8(value & 0xff, i);
         value >>= 8;
     }
+
     if (buffer[size - 1] & 0x80) {
         buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1);
     } else if (negative) {
         buffer[size - 1] |= 0x80;
     }
+
     return buffer;
 }
-exports.encode = encode;

package/src/{script_signature.js → script_signature.ts}

@@ -1,17 +1,17 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.encode = exports.decode = void 0;
-const bip66 = require('./bip66');
-const script_1 = require('./script');
-const types = require('./types');
+import * as bip66 from './bip66.js';
+import { isDefinedHashType } from './script.js';
+import * as types from './types.js';
+
 const { typeforce } = types;
+
 const ZERO = Buffer.alloc(1, 0);
+
 /**
  * Converts a buffer to a DER-encoded buffer.
  * @param x - The buffer to be converted.
  * @returns The DER-encoded buffer.
  */
-function toDER(x) {
+function toDER(x: Buffer): Buffer {
     let i = 0;
     while (x[i] === 0) ++i;
     if (i === x.length) return ZERO;
@@ -19,6 +19,7 @@ function toDER(x) {
     if (x[0] & 0x80) return Buffer.concat([ZERO, x], 1 + x.length);
     return x;
 }
+
 /**
  * Converts a DER-encoded signature to a buffer.
  * If the first byte of the input buffer is 0x00, it is skipped.
@@ -26,13 +27,19 @@ function toDER(x) {
  * @param x - The DER-encoded signature.
  * @returns The converted buffer.
  */
-function fromDER(x) {
+function fromDER(x: Buffer): Buffer {
     if (x[0] === 0x00) x = x.slice(1);
     const buffer = Buffer.alloc(32, 0);
     const bstart = Math.max(0, 32 - x.length);
     x.copy(buffer, bstart);
     return buffer;
 }
+
+interface ScriptSignature {
+    signature: Buffer;
+    hashType: number;
+}
+
 // BIP62: 1 byte hashType flag (only 0x01, 0x02, 0x03, 0x81, 0x82 and 0x83 are allowed)
 /**
  * Decodes a buffer into a ScriptSignature object.
@@ -40,18 +47,20 @@ function fromDER(x) {
  * @returns The decoded ScriptSignature object.
  * @throws Error if the hashType is invalid.
  */
-function decode(buffer) {
+export function decode(buffer: Buffer): ScriptSignature {
     const hashType = buffer.readUInt8(buffer.length - 1);
-    if (!(0, script_1.isDefinedHashType)(hashType)) {
+    if (!isDefinedHashType(hashType)) {
         throw new Error('Invalid hashType ' + hashType);
     }
+
     const decoded = bip66.decode(buffer.slice(0, -1));
     const r = fromDER(decoded.r);
     const s = fromDER(decoded.s);
     const signature = Buffer.concat([r, s], 64);
+
     return { signature, hashType };
 }
-exports.decode = decode;
+
 /**
  * Encodes a signature and hash type into a buffer.
  * @param signature - The signature to encode.
@@ -59,7 +68,7 @@ exports.decode = decode;
  * @returns The encoded buffer.
  * @throws Error if the hashType is invalid.
  */
-function encode(signature, hashType) {
+export function encode(signature: Buffer, hashType: number): Buffer {
     typeforce(
         {
             signature: types.BufferN(64),
@@ -67,13 +76,16 @@ function encode(signature, hashType) {
         },
         { signature, hashType },
     );
-    if (!(0, script_1.isDefinedHashType)(hashType)) {
+
+    if (!isDefinedHashType(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));
+
     return Buffer.concat([bip66.encode(r, s), hashTypeBuffer]);
 }
-exports.encode = encode;