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

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

@@ -1,234 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,53 +0,0 @@
-// 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

@@ -1,43 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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
-}