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

package/dependencies/src/bip66-1.1.5/index.js

@@ -0,0 +1,113 @@
+// Reference https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
+// Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
+// NOTE: SIGHASH byte ignored AND restricted, truncate before use
+
+var Buffer = require('../safe-buffer-5.2.0/index').Buffer
+
+function check (buffer) {
+  if (buffer.length < 8) return false
+  if (buffer.length > 72) return false
+  if (buffer[0] !== 0x30) return false
+  if (buffer[1] !== buffer.length - 2) return false
+  if (buffer[2] !== 0x02) return false
+
+  var lenR = buffer[3]
+  if (lenR === 0) return false
+  if (5 + lenR >= buffer.length) return false
+  if (buffer[4 + lenR] !== 0x02) return false
+
+  var lenS = buffer[5 + lenR]
+  if (lenS === 0) return false
+  if ((6 + lenR + lenS) !== buffer.length) return false
+
+  if (buffer[4] & 0x80) return false
+  if (lenR > 1 && (buffer[4] === 0x00) && !(buffer[5] & 0x80)) return false
+
+  if (buffer[lenR + 6] & 0x80) return false
+  if (lenS > 1 && (buffer[lenR + 6] === 0x00) && !(buffer[lenR + 7] & 0x80)) return false
+  return true
+}
+
+function decode (buffer) {
+  if (buffer.length < 8) throw new Error('DER sequence length is too short')
+  if (buffer.length > 72) throw new Error('DER sequence length is too long')
+  if (buffer[0] !== 0x30) throw new Error('Expected DER sequence')
+  if (buffer[1] !== buffer.length - 2) throw new Error('DER sequence length is invalid')
+  if (buffer[2] !== 0x02) throw new Error('Expected DER integer')
+
+  var lenR = buffer[3]
+  if (lenR === 0) throw new Error('R length is zero')
+  if (5 + lenR >= buffer.length) throw new Error('R length is too long')
+  if (buffer[4 + lenR] !== 0x02) throw new Error('Expected DER integer (2)')
+
+  var lenS = buffer[5 + lenR]
+  if (lenS === 0) throw new Error('S length is zero')
+  if ((6 + lenR + lenS) !== buffer.length) throw new Error('S length is invalid')
+
+  if (buffer[4] & 0x80) throw new Error('R value is negative')
+  if (lenR > 1 && (buffer[4] === 0x00) && !(buffer[5] & 0x80)) throw new Error('R value excessively padded')
+
+  if (buffer[lenR + 6] & 0x80) throw new Error('S value is negative')
+  if (lenS > 1 && (buffer[lenR + 6] === 0x00) && !(buffer[lenR + 7] & 0x80)) throw new Error('S value excessively padded')
+
+  // non-BIP66 - extract R, S values
+  return {
+    r: buffer.slice(4, 4 + lenR),
+    s: buffer.slice(6 + lenR)
+  }
+}
+
+/*
+ * Expects r and s to be positive DER integers.
+ *
+ * The DER format uses the most significant bit as a sign bit (& 0x80).
+ * If the significant bit is set AND the integer is positive, a 0x00 is prepended.
+ *
+ * Examples:
+ *
+ *      0 =>     0x00
+ *      1 =>     0x01
+ *     -1 =>     0xff
+ *    127 =>     0x7f
+ *   -127 =>     0x81
+ *    128 =>   0x0080
+ *   -128 =>     0x80
+ *    255 =>   0x00ff
+ *   -255 =>   0xff01
+ *  16300 =>   0x3fac
+ * -16300 =>   0xc054
+ *  62300 => 0x00f35c
+ * -62300 => 0xff0ca4
+*/
+function encode (r, s) {
+  var lenR = r.length
+  var lenS = s.length
+  if (lenR === 0) throw new Error('R length is zero')
+  if (lenS === 0) throw new Error('S length is zero')
+  if (lenR > 33) throw new Error('R length is too long')
+  if (lenS > 33) throw new Error('S length is too long')
+  if (r[0] & 0x80) throw new Error('R value is negative')
+  if (s[0] & 0x80) throw new Error('S value is negative')
+  if (lenR > 1 && (r[0] === 0x00) && !(r[1] & 0x80)) throw new Error('R value excessively padded')
+  if (lenS > 1 && (s[0] === 0x00) && !(s[1] & 0x80)) throw new Error('S value excessively padded')
+
+  var signature = Buffer.allocUnsafe(6 + lenR + lenS)
+
+  // 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
+  signature[0] = 0x30
+  signature[1] = signature.length - 2
+  signature[2] = 0x02
+  signature[3] = r.length
+  r.copy(signature, 4)
+  signature[4 + lenR] = 0x02
+  signature[5 + lenR] = s.length
+  s.copy(signature, 6 + lenR)
+
+  return signature
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

package/dependencies/src/bitcoin-ops-1.4.1/index.json

@@ -0,0 +1,120 @@
+{
+    "OP_FALSE": 0,
+    "OP_0": 0,
+    "OP_PUSHDATA1": 76,
+    "OP_PUSHDATA2": 77,
+    "OP_PUSHDATA4": 78,
+    "OP_1NEGATE": 79,
+    "OP_RESERVED": 80,
+    "OP_TRUE": 81,
+    "OP_1": 81,
+    "OP_2": 82,
+    "OP_3": 83,
+    "OP_4": 84,
+    "OP_5": 85,
+    "OP_6": 86,
+    "OP_7": 87,
+    "OP_8": 88,
+    "OP_9": 89,
+    "OP_10": 90,
+    "OP_11": 91,
+    "OP_12": 92,
+    "OP_13": 93,
+    "OP_14": 94,
+    "OP_15": 95,
+    "OP_16": 96,
+    "OP_NOP": 97,
+    "OP_VER": 98,
+    "OP_IF": 99,
+    "OP_NOTIF": 100,
+    "OP_VERIF": 101,
+    "OP_VERNOTIF": 102,
+    "OP_ELSE": 103,
+    "OP_ENDIF": 104,
+    "OP_VERIFY": 105,
+    "OP_RETURN": 106,
+    "OP_TOALTSTACK": 107,
+    "OP_FROMALTSTACK": 108,
+    "OP_2DROP": 109,
+    "OP_2DUP": 110,
+    "OP_3DUP": 111,
+    "OP_2OVER": 112,
+    "OP_2ROT": 113,
+    "OP_2SWAP": 114,
+    "OP_IFDUP": 115,
+    "OP_DEPTH": 116,
+    "OP_DROP": 117,
+    "OP_DUP": 118,
+    "OP_NIP": 119,
+    "OP_OVER": 120,
+    "OP_PICK": 121,
+    "OP_ROLL": 122,
+    "OP_ROT": 123,
+    "OP_SWAP": 124,
+    "OP_TUCK": 125,
+    "OP_CAT": 126,
+    "OP_SUBSTR": 127,
+    "OP_LEFT": 128,
+    "OP_RIGHT": 129,
+    "OP_SIZE": 130,
+    "OP_INVERT": 131,
+    "OP_AND": 132,
+    "OP_OR": 133,
+    "OP_XOR": 134,
+    "OP_EQUAL": 135,
+    "OP_EQUALVERIFY": 136,
+    "OP_RESERVED1": 137,
+    "OP_RESERVED2": 138,
+    "OP_1ADD": 139,
+    "OP_1SUB": 140,
+    "OP_2MUL": 141,
+    "OP_2DIV": 142,
+    "OP_NEGATE": 143,
+    "OP_ABS": 144,
+    "OP_NOT": 145,
+    "OP_0NOTEQUAL": 146,
+    "OP_ADD": 147,
+    "OP_SUB": 148,
+    "OP_MUL": 149,
+    "OP_DIV": 150,
+    "OP_MOD": 151,
+    "OP_LSHIFT": 152,
+    "OP_RSHIFT": 153,
+    "OP_BOOLAND": 154,
+    "OP_BOOLOR": 155,
+    "OP_NUMEQUAL": 156,
+    "OP_NUMEQUALVERIFY": 157,
+    "OP_NUMNOTEQUAL": 158,
+    "OP_LESSTHAN": 159,
+    "OP_GREATERTHAN": 160,
+    "OP_LESSTHANOREQUAL": 161,
+    "OP_GREATERTHANOREQUAL": 162,
+    "OP_MIN": 163,
+    "OP_MAX": 164,
+    "OP_WITHIN": 165,
+    "OP_RIPEMD160": 166,
+    "OP_SHA1": 167,
+    "OP_SHA256": 168,
+    "OP_HASH160": 169,
+    "OP_HASH256": 170,
+    "OP_CODESEPARATOR": 171,
+    "OP_CHECKSIG": 172,
+    "OP_CHECKSIGVERIFY": 173,
+    "OP_CHECKMULTISIG": 174,
+    "OP_CHECKMULTISIGVERIFY": 175,
+    "OP_NOP1": 176,
+    "OP_NOP2": 177,
+    "OP_CHECKLOCKTIMEVERIFY": 177,
+    "OP_NOP3": 178,
+    "OP_CHECKSEQUENCEVERIFY": 178,
+    "OP_NOP4": 179,
+    "OP_NOP5": 180,
+    "OP_NOP6": 181,
+    "OP_NOP7": 182,
+    "OP_NOP8": 183,
+    "OP_NOP9": 184,
+    "OP_NOP10": 185,
+    "OP_PUBKEYHASH": 253,
+    "OP_PUBKEY": 254,
+    "OP_INVALIDOPCODE": 255
+}

package/dependencies/src/bitcoin-ops-1.4.1/map.js

@@ -0,0 +1,9 @@
+var OPS = require('./index.json')
+
+var map = {}
+for (var op in OPS) {
+  var code = OPS[op]
+  map[code] = op
+}
+
+module.exports = map

package/dependencies/src/bitcoinjs-message-2.1.1/index.js

@@ -0,0 +1,157 @@
+const bs58check = require('../bs58check-2.1.2/index')
+const bech32 = require('../bech32-1.1.3/index')
+const bufferEquals = require('../buffer-equals-1.0.4/index')
+const createHash = require('../create-hash-1.2.0/browser')
+const secp256k1 = require('../secp256k1-3.7.1/elliptic')
+const varuint = require('../varuint-bitcoin-1.1.2/index')
+
+const SEGWIT_TYPES = {
+  P2WPKH: 'p2wpkh',
+  P2SH_P2WPKH: 'p2sh(p2wpkh)'
+}
+
+function sha256 (b) {
+  return createHash('sha256')
+    .update(b)
+    .digest()
+}
+function hash256 (buffer) {
+  return sha256(sha256(buffer))
+}
+function hash160 (buffer) {
+  return createHash('ripemd160')
+    .update(sha256(buffer))
+    .digest()
+}
+
+function encodeSignature (signature, recovery, compressed, segwitType) {
+  if (segwitType !== undefined) {
+    recovery += 8
+    if (segwitType === SEGWIT_TYPES.P2WPKH) recovery += 4
+  } else {
+    if (compressed) recovery += 4
+  }
+  return Buffer.concat([Buffer.alloc(1, recovery + 27), signature])
+}
+
+function decodeSignature (buffer) {
+  if (buffer.length !== 65) throw new Error('Invalid signature length')
+
+  const flagByte = buffer.readUInt8(0) - 27
+  if (flagByte > 15 || flagByte < 0) {
+    throw new Error('Invalid signature parameter')
+  }
+
+  return {
+    compressed: !!(flagByte & 12),
+    segwitType: !(flagByte & 8)
+      ? null
+      : !(flagByte & 4)
+        ? SEGWIT_TYPES.P2SH_P2WPKH
+        : SEGWIT_TYPES.P2WPKH,
+    recovery: flagByte & 3,
+    signature: buffer.slice(1)
+  }
+}
+
+function magicHash (message, messagePrefix) {
+  messagePrefix = messagePrefix || '\u0018Bitcoin Signed Message:\n'
+  if (!Buffer.isBuffer(messagePrefix)) {
+    messagePrefix = Buffer.from(messagePrefix, 'utf8')
+  }
+  if (!Buffer.isBuffer(message)) {
+    message = Buffer.from(message, 'utf8')
+  }
+  const messageVISize = varuint.encodingLength(message.length)
+  const buffer = Buffer.allocUnsafe(
+    messagePrefix.length + messageVISize + message.length
+  )
+  messagePrefix.copy(buffer, 0)
+  varuint.encode(message.length, buffer, messagePrefix.length)
+  message.copy(buffer, messagePrefix.length + messageVISize)
+  return hash256(buffer)
+}
+
+function sign (
+  message,
+  privateKey,
+  compressed,
+  messagePrefix,
+  sigOptions
+) {
+  if (typeof messagePrefix === 'object' && sigOptions === undefined) {
+    sigOptions = messagePrefix
+    messagePrefix = undefined
+  }
+  let { segwitType, extraEntropy } = sigOptions || {}
+  if (
+    segwitType &&
+    (typeof segwitType === 'string' || segwitType instanceof String)
+  ) {
+    segwitType = segwitType.toLowerCase()
+  }
+  if (
+    segwitType &&
+    segwitType !== SEGWIT_TYPES.P2SH_P2WPKH &&
+    segwitType !== SEGWIT_TYPES.P2WPKH
+  ) {
+    throw new Error(
+      'Unrecognized segwitType: use "' +
+        SEGWIT_TYPES.P2SH_P2WPKH +
+        '" or "' +
+        SEGWIT_TYPES.P2WPKH +
+        '"'
+    )
+  }
+  const hash = magicHash(message, messagePrefix)
+  const sigObj = secp256k1.sign(hash, privateKey, { data: extraEntropy })
+  return encodeSignature(
+    sigObj.signature,
+    sigObj.recovery,
+    compressed,
+    segwitType
+  )
+}
+
+function verify (message, address, signature, messagePrefix) {
+  if (!Buffer.isBuffer(signature)) signature = Buffer.from(signature, 'base64')
+
+  const parsed = decodeSignature(signature)
+  const hash = magicHash(message, messagePrefix)
+  const publicKey = secp256k1.recover(
+    hash,
+    parsed.signature,
+    parsed.recovery,
+    parsed.compressed
+  )
+  const publicKeyHash = hash160(publicKey)
+  let actual, expected
+
+  if (parsed.segwitType) {
+    if (parsed.segwitType === SEGWIT_TYPES.P2SH_P2WPKH) {
+      const redeemScript = Buffer.concat([
+        Buffer.from('0014', 'hex'),
+        publicKeyHash
+      ])
+      const redeemScriptHash = hash160(redeemScript)
+      actual = redeemScriptHash
+      expected = bs58check.decode(address).slice(1)
+    } else if (parsed.segwitType === SEGWIT_TYPES.P2WPKH) {
+      const result = bech32.decode(address)
+      const data = bech32.fromWords(result.words.slice(1))
+      actual = publicKeyHash
+      expected = Buffer.from(data)
+    }
+  } else {
+    actual = publicKeyHash
+    expected = bs58check.decode(address).slice(1)
+  }
+
+  return bufferEquals(actual, expected)
+}
+
+module.exports = {
+  magicHash: magicHash,
+  sign: sign,
+  verify: verify
+}

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

@@ -0,0 +1,109 @@
+var Buffer = require('../../safe-buffer-5.2.0/index').Buffer
+var bech32 = require('../../bech32-0.0.3/index')
+var bs58check = require('../../bs58check-2.1.2/index')
+var bscript = require('./script')
+var btemplates = require('./templates')
+var networks = require('./networks')
+var typeforce = require('../../typeforce-1.18.0/index')
+var types = require('./types')
+var bs58checkBase = require('../../bs58check-2.1.2/base')
+
+function fromBase58Check (address, network) {
+  network = network || networks.bitcoin
+  var payload = bs58checkBase(network.hashFunctions.address).decode(address)
+
+  // TODO: 4.0.0, move to "toOutputScript"
+  if (payload.length < 21) throw new TypeError(address + ' is too short')
+  if (payload.length > 22) throw new TypeError(address + ' is too long')
+
+  var multibyte = payload.length === 22
+  var offset = multibyte ? 2 : 1
+
+  var version = multibyte ? payload.readUInt16BE(0) : payload[0]
+  var hash = payload.slice(offset)
+
+  return { version: version, hash: hash }
+}
+
+function fromBech32 (address) {
+  var result = bech32.decode(address)
+  var data = bech32.fromWords(result.words.slice(1))
+
+  return {
+    version: result.words[0],
+    prefix: result.prefix,
+    data: Buffer.from(data)
+  }
+}
+
+function toBase58Check (hash, version, network) {
+  network = network || networks.bitcoin
+  typeforce(types.tuple(types.Hash160bit, types.UInt16), arguments)
+
+  // Zcash adds an extra prefix resulting in a bigger (22 bytes) payload. We identify them Zcash by checking if the
+  // version is multibyte (2 bytes instead of 1)
+  var multibyte = version > 0xff
+  var size = multibyte ? 22 : 21
+  var offset = multibyte ? 2 : 1
+
+  var payload = Buffer.allocUnsafe(size)
+  multibyte ? payload.writeUInt16BE(version, 0) : payload.writeUInt8(version, 0)
+  hash.copy(payload, offset)
+
+  return bs58checkBase(network.hashFunctions.address).encode(payload)
+}
+
+function toBech32 (data, version, prefix) {
+  var words = bech32.toWords(data)
+  words.unshift(version)
+
+  return bech32.encode(prefix, words)
+}
+
+function fromOutputScript (outputScript, network) {
+  network = network || networks.bitcoin
+
+  if (btemplates.pubKeyHash.output.check(outputScript)) return toBase58Check(bscript.compile(outputScript).slice(3, 23), network.pubKeyHash, network)
+  if (btemplates.scriptHash.output.check(outputScript)) return toBase58Check(bscript.compile(outputScript).slice(2, 22), network.scriptHash, network)
+  if (btemplates.witnessPubKeyHash.output.check(outputScript)) return toBech32(bscript.compile(outputScript).slice(2, 22), 0, network.bech32)
+  if (btemplates.witnessScriptHash.output.check(outputScript)) return toBech32(bscript.compile(outputScript).slice(2, 34), 0, network.bech32)
+
+  throw new Error(bscript.toASM(outputScript) + ' has no matching Address')
+}
+
+function toOutputScript (address, network) {
+  network = network || networks.bitcoin
+
+  var decode
+  try {
+    decode = fromBase58Check(address, network)
+  } catch (e) {}
+
+  if (decode) {
+    if (decode.version === network.pubKeyHash) return btemplates.pubKeyHash.output.encode(decode.hash)
+    if (decode.version === network.scriptHash) return btemplates.scriptHash.output.encode(decode.hash)
+  } else {
+    try {
+      decode = fromBech32(address)
+    } catch (e) {}
+
+    if (decode) {
+      if (decode.prefix !== network.bech32) throw new Error(address + ' has an invalid prefix')
+      if (decode.version === 0) {
+        if (decode.data.length === 20) return btemplates.witnessPubKeyHash.output.encode(decode.data)
+        if (decode.data.length === 32) return btemplates.witnessScriptHash.output.encode(decode.data)
+      }
+    }
+  }
+
+  throw new Error(address + ' has no matching Script')
+}
+
+module.exports = {
+  fromBase58Check: fromBase58Check,
+  fromBech32: fromBech32,
+  fromOutputScript: fromOutputScript,
+  toBase58Check: toBase58Check,
+  toBech32: toBech32,
+  toOutputScript: toOutputScript
+}