@opcat-labs/opcat 1.0.0

package/lib/encoding/bufferreader.js

@@ -0,0 +1,212 @@
+'use strict';
+
+var _ = require('../util/_');
+var $ = require('../util/preconditions');
+var BN = require('../crypto/bn');
+
+var BufferReader = function BufferReader(buf) {
+  if (!(this instanceof BufferReader)) {
+    return new BufferReader(buf);
+  }
+  if (_.isUndefined(buf)) {
+    return;
+  }
+  if (Buffer.isBuffer(buf)) {
+    this.set({
+      buf: buf,
+    });
+  } else if (_.isString(buf)) {
+    var b = Buffer.from(buf, 'hex');
+    if (b.length * 2 !== buf.length) {
+      throw new TypeError('Invalid hex string');
+    }
+
+    this.set({
+      buf: b,
+    });
+  } else if (_.isObject(buf)) {
+    var obj = buf;
+    this.set(obj);
+  } else {
+    throw new TypeError('Unrecognized argument for BufferReader');
+  }
+};
+
+BufferReader.prototype.set = function (obj) {
+  this.buf = obj.buf || this.buf || undefined;
+  this.pos = obj.pos || this.pos || 0;
+  return this;
+};
+
+BufferReader.prototype.eof = function () {
+  return this.pos >= this.buf.length;
+};
+
+BufferReader.prototype.finished = BufferReader.prototype.eof;
+
+BufferReader.prototype.read = function (len) {
+  $.checkArgument(!_.isUndefined(len), 'Must specify a length');
+  var buf = this.buf.slice(this.pos, this.pos + len);
+  this.pos = this.pos + len;
+  return buf;
+};
+
+BufferReader.prototype.readAll = function () {
+  var buf = this.buf.slice(this.pos, this.buf.length);
+  this.pos = this.buf.length;
+  return buf;
+};
+
+BufferReader.prototype.readUInt8 = function () {
+  var val = this.buf.readUInt8(this.pos);
+  this.pos = this.pos + 1;
+  return val;
+};
+
+BufferReader.prototype.readUInt16BE = function () {
+  var val = this.buf.readUInt16BE(this.pos);
+  this.pos = this.pos + 2;
+  return val;
+};
+
+BufferReader.prototype.readUInt16LE = function () {
+  var val = this.buf.readUInt16LE(this.pos);
+  this.pos = this.pos + 2;
+  return val;
+};
+
+BufferReader.prototype.readUInt32BE = function () {
+  var val = this.buf.readUInt32BE(this.pos);
+  this.pos = this.pos + 4;
+  return val;
+};
+
+BufferReader.prototype.readUInt32LE = function () {
+  var val = this.buf.readUInt32LE(this.pos);
+  this.pos = this.pos + 4;
+  return val;
+};
+
+BufferReader.prototype.readInt32LE = function () {
+  var val = this.buf.readInt32LE(this.pos);
+  this.pos = this.pos + 4;
+  return val;
+};
+
+BufferReader.prototype.readUInt64BEBN = function () {
+  var buf = this.buf.slice(this.pos, this.pos + 8);
+  var bn = BN.fromBuffer(buf);
+  this.pos = this.pos + 8;
+  return bn;
+};
+
+BufferReader.prototype.readUInt64LEBN = function () {
+  var second = this.buf.readUInt32LE(this.pos);
+  var first = this.buf.readUInt32LE(this.pos + 4);
+  var combined = first * 0x100000000 + second;
+  // Instantiating an instance of BN with a number is faster than with an
+  // array or string. However, the maximum safe number for a double precision
+  // floating point is 2 ^ 52 - 1 (0x1fffffffffffff), thus we can safely use
+  // non-floating point numbers less than this amount (52 bits). And in the case
+  // that the number is larger, we can instatiate an instance of BN by passing
+  // an array from the buffer (slower) and specifying the endianness.
+  var bn;
+  if (combined <= 0x1fffffffffffff) {
+    bn = new BN(combined);
+  } else {
+    var data = Array.prototype.slice.call(this.buf, this.pos, this.pos + 8);
+    bn = new BN(data, 10, 'le');
+  }
+  this.pos = this.pos + 8;
+  return bn;
+};
+
+BufferReader.prototype.readVarintNum = function () {
+  var first = this.readUInt8();
+  switch (first) {
+    case 0xfd:
+      return this.readUInt16LE();
+    case 0xfe:
+      return this.readUInt32LE();
+    case 0xff:
+      var bn = this.readUInt64LEBN();
+      var n = bn.toNumber();
+      if (n <= Math.pow(2, 53)) {
+        return n;
+      } else {
+        throw new Error('number too large to retain precision - use readVarintBN');
+      }
+    // break // unreachable
+    default:
+      return first;
+  }
+};
+
+/**
+ * reads a length prepended buffer
+ */
+BufferReader.prototype.readVarLengthBuffer = function () {
+  var len = this.readVarintNum();
+  var buf = this.read(len);
+  $.checkState(
+    buf.length === len,
+    'Invalid length while reading varlength buffer. ' +
+      'Expected to read: ' +
+      len +
+      ' and read ' +
+      buf.length,
+  );
+  return buf;
+};
+
+BufferReader.prototype.readVarintBuf = function () {
+  var first = this.buf.readUInt8(this.pos);
+  switch (first) {
+    case 0xfd:
+      return this.read(1 + 2);
+    case 0xfe:
+      return this.read(1 + 4);
+    case 0xff:
+      return this.read(1 + 8);
+    default:
+      return this.read(1);
+  }
+};
+
+BufferReader.prototype.readVarintBN = function () {
+  var first = this.readUInt8();
+  switch (first) {
+    case 0xfd:
+      return new BN(this.readUInt16LE());
+    case 0xfe:
+      return new BN(this.readUInt32LE());
+    case 0xff:
+      return this.readUInt64LEBN();
+    default:
+      return new BN(first);
+  }
+};
+
+BufferReader.prototype.reverse = function () {
+  var buf = Buffer.alloc(this.buf.length);
+  for (var i = 0; i < buf.length; i++) {
+    buf[i] = this.buf[this.buf.length - 1 - i];
+  }
+  this.buf = buf;
+  return this;
+};
+
+BufferReader.prototype.readReverse = function (len) {
+  if (_.isUndefined(len)) {
+    len = this.buf.length;
+  }
+  var buf = this.buf.slice(this.pos, this.pos + len);
+  this.pos = this.pos + len;
+  return Buffer.from(buf).reverse();
+};
+
+BufferReader.prototype.remaining = function () {
+  return this.buf.length - this.pos;
+};
+
+module.exports = BufferReader;

package/lib/encoding/bufferwriter.js

@@ -0,0 +1,140 @@
+'use strict';
+
+var assert = require('assert');
+
+const writeU8LE = require('../script/write-u8-le');
+const writeU16LE = require('../script/write-u16-le');
+const writeU32LE = require('../script/write-u32-le');
+const writeI32LE = require('../script/write-i32-le');
+const writeVarint = require('../script/write-varint');
+
+class BufferWriter {
+  constructor(obj) {
+    if (obj) {
+      this.set(obj);
+    } else {
+      this.buffers = [];
+      this.length = 0;
+    }
+  }
+
+  write(buffer) {
+    this.buffers.push(buffer);
+    this.length += buffer.length;
+    return this;
+  }
+
+  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;
+  }
+
+  concat() {
+    return this.toBuffer();
+  }
+
+  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);
+  }
+
+  writeReverse(buf) {
+    assert(Buffer.isBuffer(buf));
+    this.write(Buffer.from(buf).reverse());
+    return this;
+  }
+
+  writeUInt16LE(n) {
+    writeU16LE(this, n);
+    return this;
+  }
+
+  writeUInt16BE(n) {
+    var bw = new BufferWriter();
+    bw.writeUInt16LE(n);
+    this.writeReverse(bw.toBuffer());
+    return this;
+  }
+
+  writeUInt32LE(n) {
+    writeU32LE(this, n);
+    return this;
+  }
+
+  writeUInt32BE(n) {
+    var bw = new BufferWriter();
+    bw.writeUInt32LE(n);
+    this.writeReverse(bw.toBuffer());
+    return this;
+  }
+
+  writeUInt8(n) {
+    writeU8LE(this, n);
+    return this;
+  }
+
+  writeUInt64LEBN(bn) {
+    var buf = bn.toBuffer({ size: 8 });
+    this.writeReverse(buf);
+    return this;
+  }
+
+  writeUInt64BEBN(bn) {
+    var bw = new BufferWriter();
+    bw.writeUInt64LEBN(bn);
+    this.writeReverse(bw.toBuffer());
+    return this;
+  }
+
+  writeVarintNum(n) {
+    writeVarint(this, n);
+    return this;
+  }
+
+  writeInt32LE(n) {
+    writeI32LE(this, n);
+    return this;
+  }
+
+  static varintBufNum(n) {
+    var bw = new BufferWriter();
+    bw.writeVarintNum(n);
+    return bw.toBuffer();
+  }
+
+  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;
+  }
+}
+
+module.exports = BufferWriter;

package/lib/encoding/decode-asm.js

@@ -0,0 +1,24 @@
+const decodeHex = require('./decode-hex');
+const opcodes = require('../opcode');
+const BufferWriter = require('./bufferwriter');
+const writePushData = require('../script/write-push-data');
+
+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();
+}
+
+module.exports = decodeASM;

package/lib/encoding/decode-hex.js

@@ -0,0 +1,32 @@
+/* global VARIANT */
+
+const isHex = require('./is-hex');
+
+// 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');
+  }
+}
+
+module.exports = decodeHex;

package/lib/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;
+}
+
+module.exports = decodeScriptChunks;