@airgap/coinlib-core 0.13.11-beta.1 → 0.13.11-beta.3

package/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src/block.js

@@ -0,0 +1,234 @@
+var Buffer = require('../../safe-buffer-5.2.0/index').Buffer
+var bcrypto = require('./crypto')
+var fastMerkleRoot = require('../../merkle-lib-2.0.10/fastRoot')
+var typeforce = require('../../typeforce-1.18.0/index')
+var types = require('./types')
+var varuint = require('../../varuint-bitcoin-1.1.2/index')
+var networks = require('./networks')
+var coins = require('./coins')
+
+var Transaction = require('./transaction')
+
+function Block (network) {
+  typeforce(types.maybe(types.Network), network)
+  network = network || networks.bitcoin
+  this.version = 1
+  this.prevHash = null
+  this.merkleRoot = null
+  this.timestamp = 0
+  this.bits = 0
+  this.nonce = 0
+  this.network = network
+  if (coins.isZcash(network)) {
+    this.finalSaplingRoot = null
+    this.solutionSize = 0
+    this.solution = null
+  }
+}
+
+Block.HEADER_BYTE_SIZE = 80
+Block.ZCASH_HEADER_BYTE_SIZE = 1487
+
+Block.fromBuffer = function (buffer, network) {
+  if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)')
+  network = network || networks.bitcoin
+
+  var offset = 0
+  function readSlice (n) {
+    offset += n
+    return buffer.slice(offset - n, offset)
+  }
+
+  function readUInt32 () {
+    var i = buffer.readUInt32LE(offset)
+    offset += 4
+    return i
+  }
+
+  function readInt32 () {
+    var i = buffer.readInt32LE(offset)
+    offset += 4
+    return i
+  }
+
+  function readVarInt () {
+    var vi = varuint.decode(buffer, offset)
+    offset += varuint.decode.bytes
+    return vi
+  }
+
+  var block = new Block(network)
+  block.version = readInt32()
+  block.prevHash = readSlice(32)
+  block.merkleRoot = readSlice(32)
+  if (coins.isZcash(network)) {
+    block.finalSaplingRoot = readSlice(32)
+  }
+  block.timestamp = readUInt32()
+  block.bits = readUInt32()
+  if (coins.isZcash(network)) {
+    block.nonce = readSlice(32)
+    block.solutionSize = readVarInt()
+    block.solution = readSlice(1344)
+  } else {
+    // Not sure sure why the nonce is read as UInt 32 and not as a slice
+    block.nonce = readUInt32()
+  }
+
+  if (buffer.length === 80) return block
+
+  function readTransaction () {
+    var tx = Transaction.fromBuffer(buffer.slice(offset), network, true)
+    offset += tx.byteLength()
+    return tx
+  }
+
+  var nTransactions = readVarInt()
+  block.transactions = []
+
+  for (var i = 0; i < nTransactions; ++i) {
+    var tx = readTransaction()
+    block.transactions.push(tx)
+  }
+
+  return block
+}
+
+Block.prototype.byteLength = function (headersOnly) {
+  if (coins.isZcash(this.network)) {
+    if (headersOnly) {
+      return Block.ZCASH_HEADER_BYTE_SIZE
+    }
+    return Block.ZCASH_HEADER_BYTE_SIZE +
+      varuint.encodingLength(this.transactions.length) + this.transactions.reduce(function (a, x) {
+        return a + x.byteLength()
+      }, 0)
+  }
+
+  if (headersOnly || !this.transactions) return Block.HEADER_BYTE_SIZE
+
+  return Block.HEADER_BYTE_SIZE +
+    varuint.encodingLength(this.transactions.length) + this.transactions.reduce(function (a, x) {
+      return a + x.byteLength()
+    }, 0)
+}
+
+Block.fromHex = function (hex, network) {
+  return Block.fromBuffer(Buffer.from(hex, 'hex'), network)
+}
+
+Block.prototype.getHash = function () {
+  return bcrypto.hash256(this.toBuffer(true))
+}
+
+Block.prototype.getId = function () {
+  return this.getHash().reverse().toString('hex')
+}
+
+Block.prototype.getUTCDate = function () {
+  var date = new Date(0) // epoch
+  date.setUTCSeconds(this.timestamp)
+
+  return date
+}
+
+// TODO: buffer, offset compatibility
+Block.prototype.toBuffer = function (headersOnly) {
+  var buffer = Buffer.allocUnsafe(this.byteLength(headersOnly))
+
+  var offset = 0
+  function writeSlice (slice) {
+    slice.copy(buffer, offset)
+    offset += slice.length
+  }
+
+  function writeInt32 (i) {
+    buffer.writeInt32LE(i, offset)
+    offset += 4
+  }
+  function writeUInt32 (i) {
+    buffer.writeUInt32LE(i, offset)
+    offset += 4
+  }
+
+  writeInt32(this.version)
+  writeSlice(this.prevHash)
+  writeSlice(this.merkleRoot)
+  if (coins.isZcash(this.network)) {
+    writeSlice(this.finalSaplingRoot)
+  }
+  writeUInt32(this.timestamp)
+  writeUInt32(this.bits)
+  if (coins.isZcash(this.network)) {
+    writeSlice(this.nonce)
+    varuint.encode(this.solutionSize, buffer, offset)
+    offset += varuint.encode.bytes
+    writeSlice(this.solution)
+  } else {
+    // Not sure sure why the nonce is interpreted as UInt 32 and not a slice in bitcoin
+    writeUInt32(this.nonce)
+  }
+
+  if (headersOnly || !this.transactions) return buffer
+
+  varuint.encode(this.transactions.length, buffer, offset)
+  offset += varuint.encode.bytes
+
+  this.transactions.forEach(function (tx) {
+    var txSize = tx.byteLength() // TODO: extract from toBuffer?
+    tx.toBuffer(buffer, offset)
+    offset += txSize
+  })
+
+  return buffer
+}
+
+Block.prototype.toHex = function (headersOnly) {
+  return this.toBuffer(headersOnly).toString('hex')
+}
+
+Block.calculateTarget = function (bits) {
+  var exponent = ((bits & 0xff000000) >> 24) - 3
+  var mantissa = bits & 0x007fffff
+  var target = Buffer.alloc(32, 0)
+  if (exponent < 0) {
+    // If it is negative, we will overflow the target buffer so we have to slice the mantissa to fit
+    mantissa = mantissa >> (8 * Math.abs(exponent))
+    target.writeUInt32BE(mantissa, 28)
+  } else if (exponent > 28) {
+    // If it is greater than 28, we need to shift the mantissa since the offset cannot be greater than 32 - 4
+    // (safe-buffer restriction)
+    mantissa <<= 8 * (exponent - 28)
+    target.writeUInt32BE(mantissa, 0)
+  } else {
+    target.writeUInt32BE(mantissa, 28 - exponent)
+  }
+  return target
+}
+
+Block.calculateMerkleRoot = function (transactions) {
+  typeforce([{ getHash: types.Function }], transactions)
+  if (transactions.length === 0) throw TypeError('Cannot compute merkle root for zero transactions')
+
+  var hashes = transactions.map(function (transaction) {
+    return transaction.getHash()
+  })
+
+  return fastMerkleRoot(hashes, bcrypto.hash256)
+}
+
+Block.prototype.checkMerkleRoot = function () {
+  if (!this.transactions) return false
+
+  var actualMerkleRoot = Block.calculateMerkleRoot(this.transactions)
+  return this.merkleRoot.compare(actualMerkleRoot) === 0
+}
+
+Block.prototype.checkProofOfWork = function () {
+  var hash = this.getHash().reverse()
+  var target = Block.calculateTarget(this.bits)
+
+  return hash.compare(target) <= 0
+}
+
+module.exports = Block

package/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src/bufferWriter.js

@@ -0,0 +1,40 @@
+var Buffer = require('../../safe-buffer-5.2.0/index').Buffer
+var bufferutils = require('./bufferutils')
+var varuint = require('../../varuint-bitcoin-1.1.2/index')
+
+function BufferWriter (bufferSize) {
+  this.buffer = Buffer.allocUnsafe(bufferSize)
+  this.offset = 0
+}
+
+BufferWriter.prototype.getBuffer = function () {
+  return this.buffer
+}
+
+BufferWriter.prototype.writeSlice = function (slice) {
+  this.offset += slice.copy(this.buffer, this.offset)
+}
+
+BufferWriter.prototype.writeInt32 = function (input) {
+  this.offset = this.buffer.writeInt32LE(input, this.offset)
+}
+
+BufferWriter.prototype.writeUInt32 = function (input) {
+  this.offset = this.buffer.writeUInt32LE(input, this.offset)
+}
+
+BufferWriter.prototype.writeUInt64 = function (input) {
+  this.offset = bufferutils.writeUInt64LE(this.buffer, input, this.offset)
+}
+
+BufferWriter.prototype.writeVarInt = function (input) {
+  varuint.encode(input, this.buffer, this.offset)
+  this.offset += varuint.encode.bytes
+}
+
+BufferWriter.prototype.writeVarSlice = function (slice) {
+  this.writeVarInt(slice.length)
+  this.writeSlice(slice)
+}
+
+module.exports = BufferWriter

package/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src/bufferutils.js

@@ -0,0 +1,65 @@
+var pushdata = require('../../pushdata-bitcoin-1.0.1/index')
+var varuint = require('../../varuint-bitcoin-1.1.2/index')
+
+// https://github.com/feross/buffer/blob/master/index.js#L1127
+function verifuint (value, max) {
+  if (typeof value !== 'number') throw new Error('cannot write a non-number as a number')
+  if (value < 0) throw new Error('specified a negative value for writing an unsigned value')
+  if (value > max) throw new Error('RangeError: value out of range')
+  if (Math.floor(value) !== value) throw new Error('value has a fractional component')
+}
+
+function readUInt64LE (buffer, offset) {
+  var a = buffer.readUInt32LE(offset)
+  var b = buffer.readUInt32LE(offset + 4)
+  b *= 0x100000000
+
+  verifuint(b + a, 0x001fffffffffffff)
+
+  return b + a
+}
+
+function readInt64LE (buffer, offset) {
+  var a = buffer.readUInt32LE(offset)
+  var b = buffer.readInt32LE(offset + 4)
+  b *= 0x100000000
+
+  return b + a
+}
+
+function writeUInt64LE (buffer, value, offset) {
+  verifuint(value, 0x001fffffffffffff)
+
+  buffer.writeInt32LE(value & -1, offset)
+  buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4)
+  return offset + 8
+}
+
+// TODO: remove in 4.0.0?
+function readVarInt (buffer, offset) {
+  var result = varuint.decode(buffer, offset)
+
+  return {
+    number: result,
+    size: varuint.decode.bytes
+  }
+}
+
+// TODO: remove in 4.0.0?
+function writeVarInt (buffer, number, offset) {
+  varuint.encode(number, buffer, offset)
+  return varuint.encode.bytes
+}
+
+module.exports = {
+  pushDataSize: pushdata.encodingLength,
+  readPushDataInt: pushdata.decode,
+  readUInt64LE: readUInt64LE,
+  readInt64LE: readInt64LE,
+  readVarInt: readVarInt,
+  varIntBuffer: varuint.encode,
+  varIntSize: varuint.encodingLength,
+  writePushDataInt: pushdata.encode,
+  writeUInt64LE: writeUInt64LE,
+  writeVarInt: writeVarInt
+}

package/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src/coins.js

@@ -0,0 +1,53 @@
+// Coins supported by bitgo-bitcoinjs-lib
+const typeforce = require('../../typeforce-1.18.0/index')
+
+const coins = {
+  BCH: 'bch',
+  BSV: 'bsv',
+  BTC: 'btc',
+  BTG: 'btg',
+  LTC: 'ltc',
+  ZEC: 'zec',
+  DASH: 'dash',
+  GRS: 'grs'
+}
+
+coins.isBitcoin = function (network) {
+  return typeforce.value(coins.BTC)(network.coin)
+}
+
+coins.isBitcoinCash = function (network) {
+  return typeforce.value(coins.BCH)(network.coin)
+}
+
+coins.isBitcoinSV = function (network) {
+  return typeforce.value(coins.BSV)(network.coin)
+}
+
+coins.isBitcoinGold = function (network) {
+  return typeforce.value(coins.BTG)(network.coin)
+}
+
+coins.isLitecoin = function (network) {
+  return typeforce.value(coins.LTC)(network.coin)
+}
+
+coins.isZcash = function (network) {
+  return typeforce.value(coins.ZEC)(network.coin)
+}
+
+coins.isGroestlcoin = function (network) {
+  return typeforce.value(coins.GRS)(network.coin)
+}
+
+coins.isValidCoin = typeforce.oneOf(
+  coins.isBitcoin,
+  coins.isBitcoinCash,
+  coins.isBitcoinSV,
+  coins.isBitcoinGold,
+  coins.isLitecoin,
+  coins.isZcash,
+  coins.isGroestlcoin
+)
+
+module.exports = coins

package/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src/crypto.js

@@ -0,0 +1,43 @@
+var createHash = require('../../create-hash-1.2.0/browser')
+var groestlhash = require('../../groestl-hash-js-ef6a04f1c4d2f0448f0882b5f213ef7a0659baee/index')
+var crypto = require('crypto')
+
+function ripemd160 (buffer) {
+  var hash = 'rmd160'
+  var supportedHashes = crypto.getHashes()
+  // some environments (electron) only support the long alias
+  if (supportedHashes.indexOf(hash) === -1 && supportedHashes.indexOf('ripemd160') !== -1) {
+    hash = 'ripemd160'
+  }
+
+  return createHash(hash).update(buffer).digest()
+}
+
+function sha1 (buffer) {
+  return createHash('sha1').update(buffer).digest()
+}
+
+function sha256 (buffer) {
+  return createHash('sha256').update(buffer).digest()
+}
+
+function hash160 (buffer) {
+  return ripemd160(sha256(buffer))
+}
+
+function hash256 (buffer) {
+  return sha256(sha256(buffer))
+}
+
+function groestl (buffer) {
+  return Buffer(groestlhash.groestl_2(buffer, 1, 1))
+}
+
+module.exports = {
+  hash160: hash160,
+  hash256: hash256,
+  ripemd160: ripemd160,
+  sha1: sha1,
+  sha256: sha256,
+  groestl: groestl
+}

package/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src/ecdsa.js

@@ -0,0 +1,161 @@
+var Buffer = require('../../safe-buffer-5.2.0/index').Buffer
+var createHmac = require('../../create-hmac-1.1.4/browser')
+var typeforce = require('../../typeforce-1.18.0/index')
+var types = require('./types')
+
+var BigInteger = require('../../bigi-1.4.2/lib/index')
+var ECSignature = require('./ecsignature')
+
+var ZERO = Buffer.alloc(1, 0)
+var ONE = Buffer.alloc(1, 1)
+
+var ecurve = require('../../ecurve-1.0.6/lib/index')
+var secp256k1 = ecurve.getCurveByName('secp256k1')
+
+// https://tools.ietf.org/html/rfc6979#section-3.2
+function deterministicGenerateK (hash, x, checkSig) {
+  typeforce(types.tuple(
+    types.Hash256bit,
+    types.Buffer256bit,
+    types.Function
+  ), arguments)
+
+  // Step A, ignored as hash already provided
+  // Step B
+  // Step C
+  var k = Buffer.alloc(32, 0)
+  var v = Buffer.alloc(32, 1)
+
+  // Step D
+  k = createHmac('sha256', k)
+    .update(v)
+    .update(ZERO)
+    .update(x)
+    .update(hash)
+    .digest()
+
+  // Step E
+  v = createHmac('sha256', k).update(v).digest()
+
+  // Step F
+  k = createHmac('sha256', k)
+    .update(v)
+    .update(ONE)
+    .update(x)
+    .update(hash)
+    .digest()
+
+  // Step G
+  v = createHmac('sha256', k).update(v).digest()
+
+  // Step H1/H2a, ignored as tlen === qlen (256 bit)
+  // Step H2b
+  v = createHmac('sha256', k).update(v).digest()
+
+  var T = BigInteger.fromBuffer(v)
+
+  // Step H3, repeat until T is within the interval [1, n - 1] and is suitable for ECDSA
+  while (T.signum() <= 0 || T.compareTo(secp256k1.n) >= 0 || !checkSig(T)) {
+    k = createHmac('sha256', k)
+      .update(v)
+      .update(ZERO)
+      .digest()
+
+    v = createHmac('sha256', k).update(v).digest()
+
+    // Step H1/H2a, again, ignored as tlen === qlen (256 bit)
+    // Step H2b again
+    v = createHmac('sha256', k).update(v).digest()
+    T = BigInteger.fromBuffer(v)
+  }
+
+  return T
+}
+
+var N_OVER_TWO = secp256k1.n.shiftRight(1)
+
+function sign (hash, d) {
+  typeforce(types.tuple(types.Hash256bit, types.BigInt), arguments)
+
+  var x = d.toBuffer(32)
+  var e = BigInteger.fromBuffer(hash)
+  var n = secp256k1.n
+  var G = secp256k1.G
+
+  var r, s
+  deterministicGenerateK(hash, x, function (k) {
+    var Q = G.multiply(k)
+
+    if (secp256k1.isInfinity(Q)) return false
+
+    r = Q.affineX.mod(n)
+    if (r.signum() === 0) return false
+
+    s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n)
+    if (s.signum() === 0) return false
+
+    return true
+  })
+
+  // enforce low S values, see bip62: 'low s values in signatures'
+  if (s.compareTo(N_OVER_TWO) > 0) {
+    s = n.subtract(s)
+  }
+
+  return new ECSignature(r, s)
+}
+
+function verify (hash, signature, Q) {
+  typeforce(types.tuple(
+    types.Hash256bit,
+    types.ECSignature,
+    types.ECPoint
+  ), arguments)
+
+  var n = secp256k1.n
+  var G = secp256k1.G
+
+  var r = signature.r
+  var s = signature.s
+
+  // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1]
+  if (r.signum() <= 0 || r.compareTo(n) >= 0) return false
+  if (s.signum() <= 0 || s.compareTo(n) >= 0) return false
+
+  // 1.4.2 H = Hash(M), already done by the user
+  // 1.4.3 e = H
+  var e = BigInteger.fromBuffer(hash)
+
+  // Compute s^-1
+  var sInv = s.modInverse(n)
+
+  // 1.4.4 Compute u1 = es^−1 mod n
+  //               u2 = rs^−1 mod n
+  var u1 = e.multiply(sInv).mod(n)
+  var u2 = r.multiply(sInv).mod(n)
+
+  // 1.4.5 Compute R = (xR, yR)
+  //               R = u1G + u2Q
+  var R = G.multiplyTwo(u1, Q, u2)
+
+  // 1.4.5 (cont.) Enforce R is not at infinity
+  if (secp256k1.isInfinity(R)) return false
+
+  // 1.4.6 Convert the field element R.x to an integer
+  var xR = R.affineX
+
+  // 1.4.7 Set v = xR mod n
+  var v = xR.mod(n)
+
+  // 1.4.8 If v = r, output "valid", and if v != r, output "invalid"
+  return v.equals(r)
+}
+
+module.exports = {
+  deterministicGenerateK: deterministicGenerateK,
+  sign: sign,
+  verify: verify,
+
+  // TODO: remove
+  __curve: secp256k1
+}