@opcat-labs/opcat 1.0.1 → 1.0.3

package/esm/encoding/bufferwriter.js

@@ -0,0 +1,243 @@
+'use strict';
+
+import assert from 'assert';
+import writeU8LE from '../script/write-u8-le.js';
+import writeU16LE from '../script/write-u16-le.js';
+import writeU32LE from '../script/write-u32-le.js';
+import writeI32LE from '../script/write-i32-le.js';
+import writeVarint from '../script/write-varint.js';
+
+/**
+ * BufferWriter is a utility class for efficiently writing and concatenating buffers.
+ * It provides methods for writing various numeric types in both little-endian and big-endian formats,
+ * as well as variable-length integers (varints). The class maintains an internal array of buffers
+ * and can efficiently concatenate them into a single buffer when needed.
+ * 
+ * @class
+ * @example
+ * const writer = new BufferWriter();
+ * writer.writeUInt32LE(1234).writeUInt16BE(5678);
+ * const result = writer.toBuffer();
+ */
+class BufferWriter {
+  /**
+   * Initializes a new BufferWriter instance.
+   * @param {Object} [obj] - Optional object to set initial buffer content. If not provided,
+   *                         creates an empty buffer writer with empty buffers array and length 0.
+   */
+  constructor(obj) {
+    if (obj) {
+      this.set(obj);
+    } else {
+      this.buffers = [];
+      this.length = 0;
+    }
+  }
+
+  /**
+   * Appends a buffer to the internal buffers array and updates the total length.
+   * @param {Buffer} buffer - The buffer to append.
+   * @returns {this} Returns the instance for chaining.
+   */
+  write(buffer) {
+    this.buffers.push(buffer);
+    this.length += buffer.length;
+    return this;
+  }
+
+  /**
+   * Sets the internal buffers and calculates total length.
+   * @param {Object} obj - Object containing buffers (either `buffers` or `bufs` property)
+   * @returns {Object} Returns the instance for chaining
+   */
+  set(obj) {
+    this.buffers = obj.buffers || obj.bufs || this.buffers || [];
+    this.length = this.buffers.reduce(function (prev, buf) {
+      return prev + buf.length;
+    }, 0);
+    return this;
+  }
+
+  /**
+   * Returns the buffer by concatenating all written data.
+   * @returns {Buffer} The concatenated buffer.
+   */
+  concat() {
+    return this.toBuffer();
+  }
+
+  /**
+   * Converts the internal buffer chunks into a single Buffer.
+   * If there's only one chunk, returns it directly. Otherwise,
+   * concatenates all chunks into a new Buffer.
+   * @returns {Buffer} The combined buffer
+   */
+  toBuffer() {
+    if (this.buffers.length === 1) {
+      return Buffer.from(this.buffers[0]);
+    }
+
+    const whole = new Uint8Array(this.length);
+
+    let offset = 0;
+    this.buffers.forEach((part) => {
+      whole.set(part, offset);
+      offset += part.length;
+    });
+
+    return Buffer.from(whole);
+  }
+
+  /**
+   * Writes a buffer in reverse order to the current buffer.
+   * @param {Buffer} buf - The buffer to be written in reverse.
+   * @returns {this} Returns the instance for chaining.
+   */
+  writeReverse(buf) {
+    assert(Buffer.isBuffer(buf));
+    this.write(Buffer.from(buf).reverse());
+    return this;
+  }
+
+  /**
+   * Writes a 16-bit unsigned integer in little-endian format.
+   * @param {number} n - The number to write.
+   * @returns {this} Returns the instance for chaining.
+   */
+  writeUInt16LE(n) {
+    writeU16LE(this, n);
+    return this;
+  }
+
+  /**
+   * Writes a 16-bit unsigned integer in big-endian byte order.
+   * Internally converts the value to little-endian and reverses the bytes.
+   * @param {number} n - The number to write (0-65535).
+   * @returns {BufferWriter} Returns the BufferWriter instance for chaining.
+   */
+  writeUInt16BE(n) {
+    var bw = new BufferWriter();
+    bw.writeUInt16LE(n);
+    this.writeReverse(bw.toBuffer());
+    return this;
+  }
+
+  /**
+   * Writes a 32-bit unsigned integer in little-endian format.
+   * @param {number} n - The number to write.
+   * @returns {this} Returns the instance for chaining.
+   */
+  writeUInt32LE(n) {
+    writeU32LE(this, n);
+    return this;
+  }
+
+  /**
+   * Writes a 32-bit unsigned integer in big-endian format.
+   * @param {number} n - The number to write.
+   * @returns {BufferWriter} Returns the BufferWriter instance for chaining.
+   */
+  writeUInt32BE(n) {
+    var bw = new BufferWriter();
+    bw.writeUInt32LE(n);
+    this.writeReverse(bw.toBuffer());
+    return this;
+  }
+
+  /**
+   * Writes an unsigned 8-bit integer to the buffer in little-endian format.
+   * @param {number} n - The number to write (0-255)
+   * @returns {this} Returns the BufferWriter instance for chaining
+   */
+  writeUInt8(n) {
+    writeU8LE(this, n);
+    return this;
+  }
+
+  /**
+   * Writes a 64-bit unsigned integer in little-endian byte order from a BigNumber.
+   * @param {Object} bn - The BigNumber to write.
+   * @returns {this} Returns the BufferWriter instance for chaining.
+   */
+  writeUInt64LEBN(bn) {
+    var buf = bn.toBuffer({ size: 8 });
+    this.writeReverse(buf);
+    return this;
+  }
+
+  /**
+   * Writes a 64-bit unsigned integer in big-endian byte order (as BN.js instance).
+   * Internally converts to little-endian and writes reversed for big-endian output.
+   * @param {BN} bn - The BigNumber to write as 64-bit big-endian
+   * @returns {BufferWriter} Returns this instance for chaining
+   */
+  writeUInt64BEBN(bn) {
+    var bw = new BufferWriter();
+    bw.writeUInt64LEBN(bn);
+    this.writeReverse(bw.toBuffer());
+    return this;
+  }
+
+  /**
+   * Writes a variable-length integer (varint) to the buffer.
+   * @param {number} n - The number to write as varint
+   * @returns {this} Returns the BufferWriter instance for chaining
+   */
+  writeVarintNum(n) {
+    writeVarint(this, n);
+    return this;
+  }
+
+  /**
+   * Writes a 32-bit signed integer in little-endian format to the buffer.
+   * @param {number} n - The integer to write.
+   * @returns {this} Returns the BufferWriter instance for chaining.
+   */
+  writeInt32LE(n) {
+    writeI32LE(this, n);
+    return this;
+  }
+
+  /**
+   * Converts a number to a varint-encoded Buffer.
+   * @param {number} n - The number to encode.
+   * @returns {Buffer} The varint-encoded Buffer.
+   */
+  static varintBufNum(n) {
+    var bw = new BufferWriter();
+    bw.writeVarintNum(n);
+    return bw.toBuffer();
+  }
+
+  /**
+   * Writes a variable-length integer (varint) to the buffer using BigNumber.
+   * Handles numbers of different sizes with appropriate encoding:
+   * - Numbers < 253: 1 byte
+   * - Numbers < 0x10000: 1 byte prefix (253) + 2 bytes
+   * - Numbers < 0x100000000: 1 byte prefix (254) + 4 bytes
+   * - Larger numbers: 1 byte prefix (255) + 8 bytes
+   * @param {BN} bn - BigNumber to write as varint
+   * @returns {BufferWriter} Returns this for chaining
+   */
+  writeVarintBN(bn) {
+    var n = bn.toNumber();
+    if (n < 253) {
+      writeU8LE(this, n);
+    } else if (n < 0x10000) {
+      writeU8LE(this, 253);
+      writeU16LE(this, n);
+    } else if (n < 0x100000000) {
+      writeU8LE(this, 254);
+      writeU32LE(this, n);
+    } else {
+      var bw = new BufferWriter();
+      bw.writeUInt8(255);
+      bw.writeUInt64LEBN(bn);
+      var buf = bw.toBuffer();
+      this.write(buf);
+    }
+    return this;
+  }
+}
+
+export default BufferWriter;

package/esm/encoding/decode-asm.js

@@ -0,0 +1,24 @@
+import decodeHex from './decode-hex.js';
+import opcodes from '../opcode.js';
+import BufferWriter from './bufferwriter.js';
+import writePushData from '../script/write-push-data.js';
+
+function decodeASM(script) {
+  const parts = script.split(' ');
+  const writer = new BufferWriter();
+  parts.forEach((part) => {
+    if (part in opcodes) {
+      writer.write([opcodes[part]]);
+    } else if (part === '0') {
+      writer.write([opcodes.OP_0]);
+    } else if (part === '-1') {
+      writer.write([opcodes.OP_1NEGATE]);
+    } else {
+      const buf = decodeHex(part);
+      writePushData(writer, buf);
+    }
+  });
+  return writer.toBuffer();
+}
+
+export default decodeASM;

package/esm/encoding/decode-hex.js

@@ -0,0 +1,32 @@
+/* global VARIANT */
+
+import isHex from './is-hex.js';
+
+// Prefer our implementation of decodeHex over Buffer when we don't know the VARIANT
+// to avoid accidentally importing the Buffer shim in the browser.
+
+function decodeHex(hex) {
+  if (typeof hex !== 'string') throw new Error('not a string');
+
+  if (hex.startsWith('0x')) hex = hex.slice(2);
+
+  if (hex.length % 2 === 1) hex = '0' + hex;
+
+  if (!isHex(hex)) throw new Error('invalid hex string in script');
+
+  if (typeof VARIANT === 'undefined' || VARIANT === 'browser') {
+    const length = hex.length / 2;
+    const arr = new Uint8Array(length);
+    const isNaN = (x) => x !== x;
+    for (let i = 0; i < length; ++i) {
+      const byte = parseInt(hex.substr(i * 2, 2), 16);
+      if (isNaN(byte)) throw new Error('bad hex char');
+      arr[i] = byte;
+    }
+    return arr;
+  } else {
+    return Buffer.from(hex, 'hex');
+  }
+}
+
+export default decodeHex;

package/esm/encoding/decode-script-chunks.js

@@ -0,0 +1,43 @@
+function decodeScriptChunks(script) {
+  const chunks = [];
+  let i = 0;
+  let len = 0;
+  while (i < script.length) {
+    const opcodenum = script[i];
+    i += 1;
+    if (opcodenum === 0) {
+      len = opcodenum;
+      chunks.push({ opcodenum: opcodenum, len });
+    } else if (opcodenum < 76) {
+      // OP_PUSHDATA1
+      len = opcodenum;
+      chunks.push({ opcodenum: opcodenum, buf: script.slice(i, i + opcodenum), len });
+      i += opcodenum;
+    } else if (opcodenum === 76) {
+      // OP_PUSHDATA1
+      len = script[i];
+      i += 1;
+      chunks.push({ opcodenum: opcodenum, buf: script.slice(i, i + len), len });
+      i += len;
+    } else if (opcodenum === 77) {
+      // OP_PUSHDATA2
+      len = script[i] | (script[i + 1] << 8);
+      i += 2;
+      chunks.push({ opcodenum: opcodenum, buf: script.slice(i, i + len), len });
+      i += len;
+    } else if (opcodenum === 78) {
+      // OP_PUSHDATA4
+      len =
+        script[i] + script[i + 1] * 0x0100 + script[i + 2] * 0x010000 + script[i + 3] * 0x01000000;
+      i += 4;
+      chunks.push({ opcodenum: opcodenum, buf: script.slice(i, i + len), len });
+      i += len;
+    } else {
+      chunks.push({ opcodenum: opcodenum });
+    }
+  }
+  // if (i !== script.length) throw new Error('bad script')
+  return chunks;
+}
+
+export default decodeScriptChunks;

package/esm/encoding/encode-hex.js

@@ -0,0 +1,284 @@
+/* global VARIANT */
+
+let encodeHex = null;
+
+// Prefer our implementation of encodeHex over Buffer when we don't know the VARIANT
+// to avoid accidentally importing the Buffer shim in the browser.
+
+if (typeof VARIANT === 'undefined' || VARIANT === 'browser') {
+  // In the browser, a lookup table is fastest, and faster than the Buffer toString shim.
+  const HEX = [
+    '00',
+    '01',
+    '02',
+    '03',
+    '04',
+    '05',
+    '06',
+    '07',
+    '08',
+    '09',
+    '0a',
+    '0b',
+    '0c',
+    '0d',
+    '0e',
+    '0f',
+    '10',
+    '11',
+    '12',
+    '13',
+    '14',
+    '15',
+    '16',
+    '17',
+    '18',
+    '19',
+    '1a',
+    '1b',
+    '1c',
+    '1d',
+    '1e',
+    '1f',
+    '20',
+    '21',
+    '22',
+    '23',
+    '24',
+    '25',
+    '26',
+    '27',
+    '28',
+    '29',
+    '2a',
+    '2b',
+    '2c',
+    '2d',
+    '2e',
+    '2f',
+    '30',
+    '31',
+    '32',
+    '33',
+    '34',
+    '35',
+    '36',
+    '37',
+    '38',
+    '39',
+    '3a',
+    '3b',
+    '3c',
+    '3d',
+    '3e',
+    '3f',
+    '40',
+    '41',
+    '42',
+    '43',
+    '44',
+    '45',
+    '46',
+    '47',
+    '48',
+    '49',
+    '4a',
+    '4b',
+    '4c',
+    '4d',
+    '4e',
+    '4f',
+    '50',
+    '51',
+    '52',
+    '53',
+    '54',
+    '55',
+    '56',
+    '57',
+    '58',
+    '59',
+    '5a',
+    '5b',
+    '5c',
+    '5d',
+    '5e',
+    '5f',
+    '60',
+    '61',
+    '62',
+    '63',
+    '64',
+    '65',
+    '66',
+    '67',
+    '68',
+    '69',
+    '6a',
+    '6b',
+    '6c',
+    '6d',
+    '6e',
+    '6f',
+    '70',
+    '71',
+    '72',
+    '73',
+    '74',
+    '75',
+    '76',
+    '77',
+    '78',
+    '79',
+    '7a',
+    '7b',
+    '7c',
+    '7d',
+    '7e',
+    '7f',
+    '80',
+    '81',
+    '82',
+    '83',
+    '84',
+    '85',
+    '86',
+    '87',
+    '88',
+    '89',
+    '8a',
+    '8b',
+    '8c',
+    '8d',
+    '8e',
+    '8f',
+    '90',
+    '91',
+    '92',
+    '93',
+    '94',
+    '95',
+    '96',
+    '97',
+    '98',
+    '99',
+    '9a',
+    '9b',
+    '9c',
+    '9d',
+    '9e',
+    '9f',
+    'a0',
+    'a1',
+    'a2',
+    'a3',
+    'a4',
+    'a5',
+    'a6',
+    'a7',
+    'a8',
+    'a9',
+    'aa',
+    'ab',
+    'ac',
+    'ad',
+    'ae',
+    'af',
+    'b0',
+    'b1',
+    'b2',
+    'b3',
+    'b4',
+    'b5',
+    'b6',
+    'b7',
+    'b8',
+    'b9',
+    'ba',
+    'bb',
+    'bc',
+    'bd',
+    'be',
+    'bf',
+    'c0',
+    'c1',
+    'c2',
+    'c3',
+    'c4',
+    'c5',
+    'c6',
+    'c7',
+    'c8',
+    'c9',
+    'ca',
+    'cb',
+    'cc',
+    'cd',
+    'ce',
+    'cf',
+    'd0',
+    'd1',
+    'd2',
+    'd3',
+    'd4',
+    'd5',
+    'd6',
+    'd7',
+    'd8',
+    'd9',
+    'da',
+    'db',
+    'dc',
+    'dd',
+    'de',
+    'df',
+    'e0',
+    'e1',
+    'e2',
+    'e3',
+    'e4',
+    'e5',
+    'e6',
+    'e7',
+    'e8',
+    'e9',
+    'ea',
+    'eb',
+    'ec',
+    'ed',
+    'ee',
+    'ef',
+    'f0',
+    'f1',
+    'f2',
+    'f3',
+    'f4',
+    'f5',
+    'f6',
+    'f7',
+    'f8',
+    'f9',
+    'fa',
+    'fb',
+    'fc',
+    'fd',
+    'fe',
+    'ff',
+  ];
+
+  encodeHex = function (buffer) {
+    const len = buffer.length;
+    const out = new Array(len);
+    for (let i = 0; i < len; ++i) {
+      out[i] = HEX[buffer[i]];
+    }
+    return out.join('');
+  };
+} else {
+  // Buffer toString('hex') in Node is faster than any JavaScript we could write
+  encodeHex = function (buffer) {
+    return buffer instanceof Buffer ? buffer.toString('hex') : Buffer.from(buffer).toString('hex');
+  };
+}
+
+export default encodeHex;

package/esm/encoding/index.js

@@ -0,0 +1,14 @@
+import Base58 from './base58.js';
+import Base58Check from './base58check.js';
+import BufferReader from './bufferreader.js';
+import BufferWriter from './bufferwriter.js';
+import Varint from './varint.js';
+
+
+export default {
+    Base58,
+    Base58Check,
+    BufferReader,
+    BufferWriter,
+    Varint,
+};

package/esm/encoding/is-hex.js

@@ -0,0 +1,7 @@
+const HEX_REGEX = /^(?:[a-fA-F0-9][a-fA-F0-9])*$/;
+
+function isHex(s) {
+  return HEX_REGEX.test(s);
+}
+
+export default isHex;