@opcat-labs/opcat 1.0.0

package/lib/script/stack.js

@@ -0,0 +1,109 @@
+'use strict';
+
+var Stack = function Stack(rawstack, varStack) {
+  this.stack = rawstack;
+  this.varStack = varStack || [];
+};
+
+module.exports = Stack;
+
+Stack.prototype.pushVar = function (varName) {
+  this.varStack.push(varName || '$tmp');
+};
+
+Stack.prototype.popVar = function () {
+  this.varStack.pop();
+};
+
+Stack.prototype.push = function (n, varName) {
+  this.pushVar(varName);
+  this.stack.push(n);
+  this.checkConsistency();
+};
+
+Stack.prototype.pop = function () {
+  this.popVar();
+  let top = this.stack.pop();
+  this.checkConsistency();
+  return top;
+};
+
+Stack.prototype.updateTopVars = function (vars) {
+  if (vars.length > this.varStack.length) {
+    throw new Error(
+      `updateTopVars fail, stack: ${this.stack.length},  varStack: ${this.varStack.length}, vars:${vars.length}`,
+    );
+  }
+  vars = vars.reverse();
+  this.varStack.splice(this.varStack.length - vars.length, vars.length, ...vars);
+};
+
+Stack.prototype.stacktop = function (i) {
+  return this.stack[this.stack.length + i];
+};
+
+Stack.prototype.vartop = function (i) {
+  return this.varStack[this.varStack.length + i];
+};
+
+Stack.prototype.slice = function (start, end) {
+  return this.stack.slice(start, end);
+};
+
+Stack.prototype.splice = function (start, deleteCount, ...items) {
+  this.varStack.splice(start, deleteCount, ...items);
+  return this.stack.splice(start, deleteCount, ...items);
+};
+
+Stack.prototype.write = function (i, value) {
+  this.stack[this.stack.length + i] = value;
+};
+
+Stack.prototype.copy = function () {
+  return new Stack(this.stack.slice() || [], this.varStack.slice() || []);
+};
+
+function bytesToHexString(bytearray) {
+  return bytearray.reduce(function (o, c) {
+    o += ('0' + (c & 0xff).toString(16)).slice(-2);
+    return o;
+  }, '');
+}
+
+Stack.prototype.printVarStack = function () {
+  let array = this.varStack.map((v, i) => ({
+    name: v,
+    value: bytesToHexString(this.rawstack[i].data),
+  }));
+  console.log(JSON.stringify(array, null, 4));
+};
+
+Stack.prototype.checkConsistency = function () {
+  if (this.stack.length !== this.varStack.length) {
+    this.printVarStack();
+    throw new Error(
+      `checkConsistency fail, stack: ${this.stack.length}, varStack:${this.varStack.length}`,
+    );
+  }
+};
+
+Stack.prototype.checkConsistencyWithVars = function (varStack) {
+  if (this.stack.length < varStack.length) {
+    this.printVarStack();
+    throw new Error(
+      `checkConsistencyWithVars fail, stack: ${this.stack.length}, varStack:${varStack.length}`,
+    );
+  }
+};
+
+Object.defineProperty(Stack.prototype, 'length', {
+  get: function () {
+    return this.stack.length;
+  },
+});
+
+Object.defineProperty(Stack.prototype, 'rawstack', {
+  get: function () {
+    return this.stack;
+  },
+});

package/lib/script/write-i32-le.js

@@ -0,0 +1,17 @@
+function writeI32LE(writer, n) {
+  if (n < -2147483648 || n > 2147483647)
+    throw new Error('Out of range. It must be >= -2147483648 and <= 2147483647.');
+
+  const buffer = new Uint8Array(4);
+  buffer[0] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[1] = n % 256;
+  n = n >> 8;
+  buffer[2] = n % 256;
+  n = n >> 8;
+  buffer[3] = n;
+
+  return writer.write(buffer);
+}
+
+module.exports = writeI32LE;

package/lib/script/write-push-data.js

@@ -0,0 +1,35 @@
+function writePushData(writer, buffer) {
+  // It is possible to optimize buffers that only store numbers 1-16, or -1, by using the OP_N opcodes.
+  // But we say "push data" is always stored using OP_0 or OP_PUSH(N) so that it's easy to identify and
+  // extract, and also because there is some ambiguity around OP_0 if we don't do this.
+  if (buffer.length === 0) {
+    writer.write([0]);
+  } else if (buffer.length <= 75) {
+    writer.write([buffer.length]); // OP_PUSH(buffer.length)
+    writer.write(buffer);
+  } else if (buffer.length <= 0xff) {
+    writer.write([76, buffer.length]); // OP_PUSHDATA1
+    writer.write(buffer);
+  } else if (buffer.length <= 0xffff) {
+    writer.write([77, buffer.length % 256, buffer.length >> 8]); // OP_PUSHDATA2
+    writer.write(buffer);
+  } else if (buffer.length <= 0xffffffff) {
+    const prefix = new Uint8Array(5);
+    prefix[0] = 78; // OP_PUSHDATA4
+    let n = buffer.length;
+    prefix[1] = n % 256;
+    n = Math.floor(n / 256);
+    prefix[2] = n % 256;
+    n = Math.floor(n / 256);
+    prefix[3] = n % 256;
+    n = Math.floor(n / 256);
+    prefix[4] = n;
+    writer.write(prefix);
+    writer.write(buffer);
+  } else {
+    throw new Error('data too large');
+  }
+  return writer;
+}
+
+module.exports = writePushData;

package/lib/script/write-u16-le.js

@@ -0,0 +1,12 @@
+function writeU16LE(writer, n) {
+  if (n > 0xffff) throw new Error('number too large');
+
+  const buffer = new Uint8Array(2);
+  buffer[0] = n % 256;
+  n = n >> 8;
+  buffer[1] = n % 256;
+
+  return writer.write(buffer);
+}
+
+module.exports = writeU16LE;

package/lib/script/write-u32-le.js

@@ -0,0 +1,16 @@
+function writeU32LE(writer, n) {
+  if (n > 0xffffffff) throw new Error('number too large');
+
+  const buffer = new Uint8Array(4);
+  buffer[0] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[1] = n % 256;
+  n = n >> 8;
+  buffer[2] = n % 256;
+  n = n >> 8;
+  buffer[3] = n;
+
+  return writer.write(buffer);
+}
+
+module.exports = writeU32LE;

package/lib/script/write-u64-le.js

@@ -0,0 +1,24 @@
+function writeU64LE(writer, n) {
+  if (n > Number.MAX_SAFE_INTEGER) throw new Error('number too large');
+
+  const buffer = new Uint8Array(8);
+  buffer[0] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[1] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[2] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[3] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[4] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[5] = n % 256;
+  n = n >> 8;
+  buffer[6] = n % 256;
+  n = n >> 8;
+  buffer[7] = n;
+
+  return writer.write(buffer);
+}
+
+module.exports = writeU64LE;

package/lib/script/write-u8-le.js

@@ -0,0 +1,8 @@
+function writeU8LE(writer, n) {
+  if (n > 0xff) throw new Error('number too large');
+  const buffer = new Uint8Array(1);
+  buffer[0] = n;
+  return writer.write(buffer);
+}
+
+module.exports = writeU8LE;

package/lib/script/write-varint.js

@@ -0,0 +1,46 @@
+function writeVarint(writer, n) {
+  if (n > Number.MAX_SAFE_INTEGER) throw new Error('varint too large');
+
+  if (n <= 0xfc) {
+    return writer.write([n]);
+  }
+
+  if (n <= 0xffff) {
+    return writer.write([0xfd, n % 256, Math.floor(n / 256)]);
+  }
+
+  if (n <= 0xffffffff) {
+    const buffer = new Uint8Array(5);
+    buffer[0] = 0xfe;
+    buffer[1] = n % 256;
+    n = Math.floor(n / 256);
+    buffer[2] = n % 256;
+    n = Math.floor(n / 256);
+    buffer[3] = n % 256;
+    n = Math.floor(n / 256);
+    buffer[4] = n;
+    return writer.write(buffer);
+  }
+
+  // n <= 0xffffffffffffffff
+  const buffer = new Uint8Array(9);
+  buffer[0] = 0xff;
+  buffer[1] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[2] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[3] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[4] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[5] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[6] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[7] = n % 256;
+  n = Math.floor(n / 256);
+  buffer[8] = n;
+  return writer.write(buffer);
+}
+
+module.exports = writeVarint;

package/lib/transaction/index.js

@@ -0,0 +1,7 @@
+module.exports = require('./transaction');
+
+module.exports.Input = require('./input');
+module.exports.Output = require('./output');
+module.exports.UnspentOutput = require('./unspentoutput');
+module.exports.Signature = require('./signature');
+module.exports.Sighash = require('./sighash');

package/lib/transaction/input/index.js

@@ -0,0 +1,5 @@
+module.exports = require('./input.js');
+
+module.exports.PublicKey = require('./publickey.js');
+module.exports.PublicKeyHash = require('./publickeyhash.js');
+module.exports.MultiSig = require('./multisig.js');

package/lib/transaction/input/input.js

@@ -0,0 +1,354 @@
+'use strict';
+
+var _ = require('../../util/_');
+var $ = require('../../util/preconditions');
+var errors = require('../../errors');
+var BufferWriter = require('../../encoding/bufferwriter');
+var JSUtil = require('../../util/js');
+var Script = require('../../script');
+var Sighash = require('../sighash');
+var Output = require('../output');
+var Signature = require('../../crypto/signature');
+var TransactionSignature = require('../signature');
+var Hash = require('../../crypto/hash');
+var Interpreter = require('../../script/interpreter');
+var Opcode = require('../../opcode');
+const PrivateKey = require('../../privatekey');
+
+var MAXINT = 0xffffffff; // Math.pow(2, 32) - 1;
+var DEFAULT_RBF_SEQNUMBER = MAXINT - 2;
+var DEFAULT_SEQNUMBER = MAXINT;
+var DEFAULT_LOCKTIME_SEQNUMBER = MAXINT - 1;
+
+function getLowSPreimage(tx, sigtype, inputIndex, subscript, inputAmount) {
+  var i = 0;
+  do {
+    var preimage = Sighash.sighashPreimage(tx, sigtype, inputIndex, subscript, inputAmount);
+
+    var sighash = Hash.sha256sha256(preimage);
+
+    if (_.isPositiveNumber(sighash.readUInt8()) && _.isPositiveNumber(sighash.readUInt8(31))) {
+      return preimage;
+    }
+
+    tx.nLockTime++;
+  } while (i < Number.MAX_SAFE_INTEGER);
+}
+
+function Input(params) {
+  if (!(this instanceof Input)) {
+    return new Input(params);
+  }
+  if (params) {
+    return this._fromObject(params);
+  }
+}
+
+Input.MAXINT = MAXINT;
+Input.DEFAULT_SEQNUMBER = DEFAULT_SEQNUMBER;
+Input.DEFAULT_LOCKTIME_SEQNUMBER = DEFAULT_LOCKTIME_SEQNUMBER;
+Input.DEFAULT_RBF_SEQNUMBER = DEFAULT_RBF_SEQNUMBER;
+// txid + output index + sequence number
+Input.BASE_SIZE = 32 + 4 + 4;
+
+Object.defineProperty(Input.prototype, 'script', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    if (this.isNull()) {
+      return null;
+    }
+    if (!this._script) {
+      this._script = new Script(this._scriptBuffer);
+      this._script._isInput = true;
+    }
+    return this._script;
+  },
+});
+
+Input.fromObject = function (obj) {
+  $.checkArgument(_.isObject(obj));
+  var input = new Input();
+  return input._fromObject(obj);
+};
+
+Input.prototype._fromObject = function (params) {
+
+  if(_.isUndefined(params.prevTxId) 
+    || _.isUndefined(params.outputIndex)) {
+     throw new errors.Transaction.Input.InvalidParams('require prevTxId and outputIndex');
+  }
+  var prevTxId;
+  if (_.isString(params.prevTxId) && JSUtil.isHexa(params.prevTxId)) {
+    prevTxId = Buffer.from(params.prevTxId, 'hex');
+  } else {
+    prevTxId = params.prevTxId;
+  }
+  this.output = params.output
+    ? params.output instanceof Output
+      ? params.output
+      : new Output(params.output)
+    : undefined;
+  this.prevTxId = prevTxId || params.txidbuf;
+  this.outputIndex = _.isUndefined(params.outputIndex) ? params.txoutnum : params.outputIndex;
+  this.sequenceNumber = _.isUndefined(params.sequenceNumber)
+    ? _.isUndefined(params.seqnum)
+      ? DEFAULT_SEQNUMBER
+      : params.seqnum
+    : params.sequenceNumber;
+  this.setScript(params.scriptBuffer || params.script || Script.empty());
+  return this;
+};
+
+Input.prototype.toObject = Input.prototype.toJSON = function toObject() {
+  var obj = {
+    prevTxId: this.prevTxId.toString('hex'),
+    outputIndex: this.outputIndex,
+    sequenceNumber: this.sequenceNumber,
+    script: this._scriptBuffer.toString('hex'),
+  };
+  // add human readable form if input contains valid script
+  if (this.script) {
+    obj.scriptString = this.script.toString();
+  }
+  if (this.output) {
+    obj.output = this.output.toObject();
+  }
+  return obj;
+};
+
+Input.fromBufferReader = function (br) {
+  var input = new Input();
+  input.prevTxId = br.readReverse(32);
+  input.outputIndex = br.readUInt32LE();
+  input._scriptBuffer = br.readVarLengthBuffer();
+  input.sequenceNumber = br.readUInt32LE();
+  // TODO: return different classes according to which input it is
+  // e.g: CoinbaseInput, PublicKeyHashInput, etc.
+  return input;
+};
+
+Input.prototype.toBufferWriter = function (hashScriptSig, writer) {
+  $.checkArgument(typeof hashScriptSig === 'boolean', 'hashScriptSig should be boolean')
+  if (!writer) {
+    writer = new BufferWriter()
+  }
+  writer.writeReverse(this.prevTxId)
+  writer.writeUInt32LE(this.outputIndex)
+  var script = this._scriptBuffer
+  if(hashScriptSig) {
+    writer.write(Hash.sha256(script))
+  } else {
+    writer.writeVarintNum(script.length)
+    writer.write(script)
+  }
+  writer.writeUInt32LE(this.sequenceNumber)
+  return writer
+}
+
+
+Input.prototype.toPrevout = function () {
+  let writer = new BufferWriter()
+  writer.writeReverse(this.prevTxId)
+  writer.writeUInt32LE(this.outputIndex)
+  return writer.toBuffer()
+}
+
+
+Input.prototype.setScript = function (script) {
+  this._script = null;
+  if (script instanceof Script) {
+    this._script = script;
+    this._script._isInput = true;
+    this._scriptBuffer = script.toBuffer();
+  } else if (script === null) {
+    this._script = Script.empty();
+    this._script._isInput = true;
+    this._scriptBuffer = this._script.toBuffer();
+  } else if (JSUtil.isHexa(script)) {
+    // hex string script
+    this._scriptBuffer = Buffer.from(script, 'hex');
+  } else if (_.isString(script)) {
+    // human readable string script
+    this._script = new Script(script);
+    this._script._isInput = true;
+    this._scriptBuffer = this._script.toBuffer();
+  } else if (Buffer.isBuffer(script)) {
+    // buffer script
+    this._scriptBuffer = Buffer.from(script);
+  } else {
+    throw new TypeError('Invalid argument type: script');
+  }
+  return this;
+};
+
+/**
+ * Retrieve signatures for the provided PrivateKey.
+ *
+ * @param {Transaction} transaction - the transaction to be signed
+ * @param {PrivateKey | Array} privateKeys - the private key to use when signing
+ * @param {number} inputIndex - the index of this input in the provided transaction
+ * @param {number} sigType - defaults to Signature.SIGHASH_ALL
+ * @abstract
+ */
+Input.prototype.getSignatures = function (transaction, privateKeys, inputIndex, sigtype) {
+  $.checkState(this.output instanceof Output);
+  sigtype = sigtype || Signature.SIGHASH_ALL;
+  var results = [];
+  if (privateKeys instanceof PrivateKey) {
+    results.push(
+      new TransactionSignature({
+        publicKey: privateKeys.publicKey,
+        prevTxId: this.prevTxId,
+        outputIndex: this.outputIndex,
+        inputIndex: inputIndex,
+        signature: Sighash.sign(
+          transaction,
+          privateKeys,
+          sigtype,
+          inputIndex,
+        ),
+        sigtype: sigtype,
+      }),
+    );
+  } else if (_.isArray(privateKeys)) {
+    var self = this;
+
+    _.each(privateKeys, function (privateKey, index) {
+      var sigtype_ = sigtype;
+      if (_.isArray(sigtype)) {
+        sigtype_ = sigtype[index] || Signature.SIGHASH_ALL;
+      }
+      results.push(
+        new TransactionSignature({
+          publicKey: privateKey.publicKey,
+          prevTxId: self.prevTxId,
+          outputIndex: self.outputIndex,
+          inputIndex: inputIndex,
+          signature: Sighash.sign(
+            transaction,
+            privateKey,
+            sigtype_,
+            inputIndex,
+          ),
+          sigtype: sigtype_,
+        }),
+      );
+    });
+  }
+  return results;
+};
+
+/**
+ * Retrieve preimage for the Input.
+ *
+ * @param {Transaction} transaction - the transaction to be signed
+ * @param {number} inputIndex - the index of this input in the provided transaction
+ * @param {number} sigType - defaults to Signature.SIGHASH_ALL
+ * @param {boolean} isLowS - true if the sig hash is safe for low s.
+ * @abstract
+ */
+Input.prototype.getPreimage = function (transaction, inputIndex, sigtype, isLowS) {
+  $.checkState(this.output instanceof Output);
+  sigtype = sigtype || Signature.SIGHASH_ALL;
+  isLowS = isLowS || false;
+  return isLowS
+    ? getLowSPreimage(transaction, sigtype, inputIndex)
+    : Sighash.sighashPreimage(transaction, sigtype, inputIndex);
+};
+
+Input.prototype.isFullySigned = function () {
+  throw new errors.AbstractMethodInvoked('Input#isFullySigned');
+};
+
+Input.prototype.isFinal = function () {
+  return this.sequenceNumber === Input.MAXINT;
+};
+
+Input.prototype.addSignature = function (transaction, signature) {
+  const s = Script.buildPublicKeyIn(signature.signature.toDER(), signature.sigtype)
+  console.log("s:", s.toHex())
+  // throw new errors.AbstractMethodInvoked('Input#addSignature')
+};
+
+Input.prototype.clearSignatures = function () {
+  // throw new errors.AbstractMethodInvoked('Input#clearSignatures')
+};
+
+Input.prototype.isValidSignature = function (transaction, signature) {
+  // FIXME: Refactor signature so this is not necessary
+  signature.signature.nhashtype = signature.sigtype;
+  return Sighash.verify(
+    transaction,
+    signature.signature,
+    signature.publicKey,
+    signature.inputIndex,
+    this.output.script,
+    this.output.satoshisBN,
+  );
+};
+
+/**
+ * @returns true if this is a coinbase input (represents no input)
+ */
+Input.prototype.isNull = function () {
+  return (
+    this.prevTxId.toString('hex') ===
+      '0000000000000000000000000000000000000000000000000000000000000000' &&
+    this.outputIndex === 0xffffffff
+  );
+};
+
+Input.prototype._estimateSize = function () {
+  return this.toBufferWriter(false).toBuffer().length;
+};
+
+Input.prototype.verify = function (transaction, inputIndex) {
+  $.checkState(this.output instanceof Output);
+  $.checkState(this.script instanceof Script);
+  $.checkState(this.output.script instanceof Script);
+
+  var us = this.script;
+  var ls = this.output.script;
+  var inputSatoshis = this.output.satoshisBN;
+
+  Interpreter.MAX_SCRIPT_ELEMENT_SIZE = Number.MAX_SAFE_INTEGER;
+  Interpreter.MAXIMUM_ELEMENT_SIZE = Number.MAX_SAFE_INTEGER;
+
+  const bsi = new Interpreter();
+
+  let failedAt = {};
+
+  bsi.stepListener = function (step) {
+    if (
+      step.fExec ||
+      (Opcode.OP_IF <= step.opcode.toNumber() && step.opcode.toNumber() <= Opcode.OP_ENDIF)
+    ) {
+      if (
+        (Opcode.OP_IF <= step.opcode.toNumber() && step.opcode.toNumber() <= Opcode.OP_ENDIF) ||
+        step.opcode.toNumber() === Opcode.OP_RETURN
+      ) {
+        /** Opreturn */ failedAt.opcode = step.opcode;
+      } else {
+        failedAt = step;
+      }
+    }
+  };
+
+  var success = bsi.verify(
+    us,
+    ls,
+    transaction,
+    inputIndex,
+    Interpreter.DEFAULT_FLAGS,
+    inputSatoshis,
+  );
+
+  if (failedAt.opcode) {
+    failedAt.opcode = failedAt.opcode.toNumber();
+  }
+
+  return { success, error: bsi.errstr, failedAt: success ? {} : failedAt };
+};
+
+module.exports = Input;