edge-currency-plugins 1.0.0-rc.1

package/lib/common/utxobased/keymanager/bitcoincashUtils/bn.js

@@ -0,0 +1,210 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }'use strict'
+
+var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
+var _buffer = require('buffer');
+
+
+
+
+
+
+const reversebuf = function (buf) {
+  const buf2 = _buffer.Buffer.alloc(buf.length)
+  for (let i = 0; i < buf.length; i++) {
+    buf2[i] = buf[buf.length - 1 - i]
+  }
+  return buf2
+}
+
+_bnjs2.default.Zero = new (0, _bnjs2.default)(0)
+_bnjs2.default.One = new (0, _bnjs2.default)(1)
+_bnjs2.default.Minus1 = new (0, _bnjs2.default)(-1)
+
+_bnjs2.default.fromNumber = function (n) {
+  if (typeof n !== 'number') {
+    throw new Error(`InvalidArgument: ${JSON.stringify(n)} not a number`)
+  }
+  return new (0, _bnjs2.default)(n)
+}
+
+_bnjs2.default.fromString = function (str, base) {
+  if (typeof str !== 'string') {
+    throw new Error(`InvalidArgument: ${JSON.stringify(str)} not a string`)
+  }
+  return new (0, _bnjs2.default)(str, base)
+}
+
+_bnjs2.default.fromBuffer = function (buf, opts) {
+  if (opts.endian === 'little') {
+    buf = reversebuf(buf)
+  }
+  const hex = buf.toString('hex')
+  const bn = new (0, _bnjs2.default)(hex, 16)
+  return bn
+}
+
+/**
+ * Instantiate a BigNumber from a "signed magnitude buffer"
+ * (a buffer where the most significant bit represents the sign (0 = positive, -1 = negative))
+ */
+_bnjs2.default.fromSM = function (buf, opts) {
+  let ret
+  if (buf.length === 0) {
+    return _bnjs2.default.fromBuffer(_buffer.Buffer.from([0]))
+  }
+
+  const endian = _nullishCoalesce(opts.endian, () => ( 'big'))
+  if (endian === 'little') {
+    buf = reversebuf(buf)
+  }
+
+  if ((buf[0] & 0x80) !== 0) {
+    buf[0] = buf[0] & 0x7f
+    ret = _bnjs2.default.fromBuffer(buf)
+    ret.neg().copy(ret)
+  } else {
+    ret = _bnjs2.default.fromBuffer(buf)
+  }
+  return ret
+}
+
+_bnjs2.default.prototype.toNumber = function () {
+  return parseInt(this.toString(10), 10)
+}
+
+_bnjs2.default.prototype.toBuffer = function (opts) {
+  let buf, hex
+  if (opts.size != null && opts.size > 0) {
+    hex = this.toString(16, 2)
+    const natlen = hex.length / 2
+    buf = _buffer.Buffer.from(hex, 'hex')
+
+    if (natlen > opts.size) {
+      buf = _bnjs2.default.trim(buf, natlen)
+    } else if (natlen < opts.size) {
+      buf = _bnjs2.default.pad(buf, natlen, opts.size)
+    }
+  } else {
+    hex = this.toString(16, 2)
+    buf = _buffer.Buffer.from(hex, 'hex')
+  }
+
+  if (opts.endian === 'little') {
+    buf = reversebuf(buf)
+  }
+
+  return buf
+}
+
+_bnjs2.default.prototype.toSMBigEndian = function () {
+  let buf
+  if (this.cmp(_bnjs2.default.Zero) === -1) {
+    buf = this.neg().toBuffer()
+    if ((buf[0] & 0x80) !== 0) {
+      buf = _buffer.Buffer.concat([_buffer.Buffer.from([0x80]), buf])
+    } else {
+      buf[0] = buf[0] | 0x80
+    }
+  } else {
+    buf = this.toBuffer()
+    if ((buf[0] & 0x80) !== 0) {
+      buf = _buffer.Buffer.concat([_buffer.Buffer.from([0x00]), buf])
+    }
+  }
+
+  if (buf.length === 1 && buf[0] === 0) {
+    buf = _buffer.Buffer.from([])
+  }
+  return buf
+}
+
+_bnjs2.default.prototype.toSM = function (opts) {
+  const endian = _nullishCoalesce(opts.endian, () => ( 'big'))
+  let buf = this.toSMBigEndian()
+
+  if (endian === 'little') {
+    buf = reversebuf(buf)
+  }
+  return buf
+}
+
+/**
+ * Create a BN from a "ScriptNum":
+ * This is analogous to the constructor for CScriptNum in bitcoind. Many ops in
+ * bitcoind's script interpreter use CScriptNum, which is not really a proper
+ * bignum. Instead, an error is thrown if trying to input a number bigger than
+ * 4 bytes. We copy that behavior here. A third argument, `size`, is provided to
+ * extend the hard limit of 4 bytes, as some usages require more than 4 bytes.
+ */
+_bnjs2.default.fromScriptNumBuffer = function (
+  buf,
+  fRequireMinimal,
+  size
+) {
+  const nMaxNumSize = _nullishCoalesce(size, () => ( 4))
+  if (buf.length > nMaxNumSize) {
+    throw new Error('InvalidArgument: script number overflow')
+  }
+  if (fRequireMinimal && buf.length > 0) {
+    // Check that the number is encoded with the minimum possible
+    // number of bytes.
+    //
+    // If the most-significant-byte - excluding the sign bit - is zero
+    // then we're not minimal. Note how this test also rejects the
+    // negative-zero encoding, 0x80.
+    if ((buf[buf.length - 1] & 0x7f) === 0) {
+      // One exception: if there's more than one byte and the most
+      // significant bit of the second-most-significant-byte is set
+      // it would conflict with the sign bit. An example of this case
+      // is +-255, which encode to 0xff00 and 0xff80 respectively.
+      // (big-endian).
+      if (buf.length <= 1 || (buf[buf.length - 2] & 0x80) === 0) {
+        throw new Error('non-minimally encoded script number')
+      }
+    }
+  }
+  return _bnjs2.default.fromSM(buf, {
+    endian: 'little'
+  })
+}
+
+/**
+ * The corollary to the above, with the notable exception that we do not throw
+ * an error if the output is larger than four bytes. (Which can happen if
+ * performing a numerical operation that results in an overflow to more than 4
+ * bytes).
+ */
+_bnjs2.default.prototype.toScriptNumBuffer = function () {
+  return this.toSM({
+    endian: 'little'
+  })
+}
+
+_bnjs2.default.prototype.gt = function (b) {
+  return this.cmp(b) > 0
+}
+
+_bnjs2.default.prototype.gte = function (b) {
+  return this.cmp(b) >= 0
+}
+
+_bnjs2.default.prototype.lt = function (b) {
+  return this.cmp(b) < 0
+}
+
+_bnjs2.default.trim = function (buf, natlen) {
+  return buf.slice(natlen - buf.length, buf.length)
+}
+
+_bnjs2.default.pad = function (buf, natlen, size) {
+  const rbuf = _buffer.Buffer.alloc(size)
+  for (let i = 0; i < buf.length; i++) {
+    rbuf[rbuf.length - 1 - i] = buf[buf.length - 1 - i]
+  }
+  for (let i = 0; i < size - natlen; i++) {
+    rbuf[i] = 0
+  }
+  return rbuf
+}
+
+exports. default = _bnjs2.default

package/lib/common/utxobased/keymanager/bitcoincashUtils/cashAddress.js

@@ -0,0 +1,282 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// @flow
+
+// import bcoin from 'bcoin'
+var _buffer = require('buffer');
+
+var _base32 = require('./base32');
+var _bn = require('./bn'); var _bn2 = _interopRequireDefault(_bn);
+
+var CashaddrTypeEnum; (function (CashaddrTypeEnum) {
+  const pubkeyhash = 'pubkeyhash'; CashaddrTypeEnum["pubkeyhash"] = pubkeyhash;
+  const scripthash = 'scripthash'; CashaddrTypeEnum["scripthash"] = scripthash;
+})(CashaddrTypeEnum || (exports.CashaddrTypeEnum = CashaddrTypeEnum = {}));
+
+
+
+
+
+
+const GENERATOR = [
+  0x98f2bc8e61,
+  0x79b76d99e2,
+  0xf33e5fb3c4,
+  0xae2eabe2a8,
+  0x1e4f43e470
+].map(x => new (0, _bn2.default)(x))
+
+// returns a BN object, which is not typed yet. Logs as <BN: dc0f07f285>
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const polymod = (data) => {
+  let checksum = new (0, _bn2.default)(1)
+  const C = new (0, _bn2.default)(0x07ffffffff)
+  for (let j = 0; j < data.length; j++) {
+    const value = data[j]
+    const topBits = checksum.shrn(35)
+    checksum = checksum.and(C)
+    checksum = checksum.shln(5).xor(new (0, _bn2.default)(value))
+    for (let i = 0; i < GENERATOR.length; ++i) {
+      const D = topBits.shrn(i).and(_bn2.default.One)
+      if (D.eqn(1) === true) {
+        checksum = checksum.xor(GENERATOR[i])
+      }
+    }
+  }
+  return checksum.xor(_bn2.default.One)
+}
+
+const convertBits = (
+  data,
+  from,
+  to,
+  strict
+) => {
+  if (strict == null) {
+    strict = false
+  }
+  let accumulator = 0
+  let bits = 0
+  const result = []
+  const mask = (1 << to) - 1
+  for (let i = 0; i < data.length; i++) {
+    const value = data[i]
+    if (value < 0 || value >> from !== 0) {
+      throw new Error(
+        `InvalidArgument in function convertBits: ${JSON.stringify(value)}`
+      )
+    }
+
+    accumulator = (accumulator << from) | value
+    bits += from
+    while (bits >= to) {
+      bits -= to
+      result.push((accumulator >> bits) & mask)
+    }
+  }
+  if (
+    isNaN(to) ||
+    to == null ||
+    isNaN(accumulator) ||
+    isNaN(bits) ||
+    isNaN(mask) ||
+    mask == null
+  ) {
+    throw Error(`InvalidArgument in function convertBits: ${to}`)
+  }
+  if (!strict) {
+    if (bits > 0) {
+      result.push((accumulator << (to - bits)) & mask)
+    }
+  } else if (bits >= from || ((accumulator << (to - bits)) & mask) !== 0) {
+    throw new Error(
+      'InvalidState: Conversion requires padding but strict mode was used'
+    )
+  }
+  return result
+}
+
+const prefixToArray = (prefix) => {
+  const result = []
+  for (let i = 0; i < prefix.length; i++) {
+    result.push(prefix.charCodeAt(i) & 31)
+  }
+  return result
+}
+
+ const hashToCashAddress = (
+  scriptHash,
+  type,
+  cashAddrPrefix,
+  includePrefix = false
+) => {
+  // Not any, but a BN object
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function checksumToArray(checksum) {
+    const result = []
+    const N31 = new (0, _bn2.default)(31)
+    for (let i = 0; i < 8; ++i) {
+      result.push(checksum.and(N31).toNumber())
+      checksum = checksum.shrn(5)
+    }
+    return result.reverse()
+  }
+
+  function getTypeBits(type) {
+    switch (type) {
+      case CashaddrTypeEnum.pubkeyhash:
+        return 0
+      case CashaddrTypeEnum.scripthash:
+        return 8
+      default:
+        throw new Error('Invalid type:' + type)
+    }
+  }
+
+  function getHashSizeBits(hash) {
+    switch (hash.length * 8) {
+      case 160:
+        return 0
+      case 192:
+        return 1
+      case 224:
+        return 2
+      case 256:
+        return 3
+      case 320:
+        return 4
+      case 384:
+        return 5
+      case 448:
+        return 6
+      case 512:
+        return 7
+      default:
+        throw new Error('Invalid hash size:' + hash.length.toString())
+    }
+  }
+
+  const hashBuffer = _buffer.Buffer.from(scriptHash, 'hex')
+  const eight0 = [0, 0, 0, 0, 0, 0, 0, 0]
+  const prefixData = prefixToArray(cashAddrPrefix).concat([0])
+  const versionByte = getTypeBits(type) + getHashSizeBits(hashBuffer)
+  const arr = Array.prototype.slice.call(hashBuffer, 0)
+  const payloadData = convertBits([versionByte].concat(arr), 8, 5)
+  const checksumData = prefixData.concat(payloadData).concat(eight0)
+  const payload = payloadData.concat(checksumToArray(polymod(checksumData)))
+  return includePrefix
+    ? cashAddrPrefix + ':' + _base32.encode.call(void 0, payload)
+    : _base32.encode.call(void 0, payload)
+}; exports.hashToCashAddress = hashToCashAddress
+
+ const cashAddressToHash = (
+  address,
+  cashAddrPrefixes
+) => {
+  function getHashSize(versionByte) {
+    switch (versionByte & 7) {
+      case 0:
+        return 160
+      case 1:
+        return 192
+      case 2:
+        return 224
+      case 3:
+        return 256
+      case 4:
+        return 320
+      case 5:
+        return 384
+      case 6:
+        return 448
+      case 7:
+        return 512
+      default:
+        return 0
+    }
+  }
+
+  function hasSingleCase(string) {
+    const lowerCase = string.toLowerCase()
+    const upperCase = string.toUpperCase()
+    const hasSingleCase = string === lowerCase || string === upperCase
+    return hasSingleCase
+  }
+
+  // not any, but a bignum payload
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function validChecksum(prefix, payload) {
+    const prefixData = prefixToArray(prefix).concat([0])
+    return polymod(prefixData.concat(payload)).eqn(0)
+  }
+
+  if (!hasSingleCase(address)) {
+    throw new Error(`InvalidArgument: ${address} has Mixed case`)
+  }
+  address = address.toLowerCase()
+
+  const pieces = address.split(':')
+  if (pieces.length > 2) {
+    throw new Error(`InvalidArgument: ${address} has invalid format`)
+  }
+
+  let prefix, encodedPayload
+
+  if (pieces.length === 2) {
+    prefix = pieces[0]
+    encodedPayload = pieces[1]
+  } else {
+    prefix = null
+    encodedPayload = pieces[0]
+  }
+  const payload = _base32.decode.call(void 0, encodedPayload.toLowerCase())
+  if (prefix != null) {
+    if (!validChecksum(prefix, payload)) {
+      throw new Error(`InvalidArgument: ${address} has invalid checksum`)
+    }
+  } else {
+    // Loop over all of the currency's cashaddr prefixes to see if any of them
+    // validate the checksum for the payload. If we find one, then we'll use
+    // it as the selected prefix. Otherwise, we'll throw an error.
+    for (let i = 0; i < cashAddrPrefixes.length; ++i) {
+      const candidatePrefix = cashAddrPrefixes[i]
+      if (validChecksum(candidatePrefix, payload)) {
+        prefix = candidatePrefix
+        break
+      }
+    }
+    if (prefix == null) {
+      throw new Error(`InvalidArgument: ${address} has invalid checksum`)
+    }
+  }
+
+  const convertedBits = convertBits(payload.slice(0, -8), 5, 8, true)
+  const versionByte = convertedBits.shift()
+  const hash = convertedBits
+
+  if (versionByte == null) {
+    throw new Error('cashaddress converter produced bad version byte')
+  }
+
+  if (getHashSize(versionByte) !== hash.length * 8) {
+    throw new Error(`InvalidArgument: ${address} has invalid hash size`)
+  }
+
+  function getType(versionByte) {
+    switch (versionByte & 120) {
+      case 0:
+        return CashaddrTypeEnum.pubkeyhash
+      case 8:
+        return CashaddrTypeEnum.scripthash
+      default:
+        throw new Error(
+          'Invalid address type in version byte: ' + versionByte.toString()
+        )
+    }
+  }
+
+  const type = getType(versionByte)
+  const info = {
+    scriptHash: _buffer.Buffer.from(hash),
+    type: type
+  }
+  return info
+}; exports.cashAddressToHash = cashAddressToHash

package/lib/common/utxobased/keymanager/cleaners.js

@@ -0,0 +1,198 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+
+
+
+
+
+var _cleaners = require('cleaners');
+
+
+
+
+
+
+var _types3 = require('../../plugin/types');
+var _utils = require('../engine/utils');
+
+// Private key format are a strict subset of all currency formats
+const asPrivateKeyFormat = _cleaners.asValue.call(void 0, 'bip32', 'bip44', 'bip49')
+// Default to bip32 always for legacy reasons
+const asOptionalPrivateKeyFormat = _cleaners.asOptional.call(void 0, asPrivateKeyFormat, 'bip32')
+
+/**
+ * A cleaner for the private key format following the key-formats specification.
+ *
+ * (spec: https://github.com/EdgeApp/edge-core-js/blob/master/docs/key-formats.md)
+ */
+
+
+
+
+
+
+ function asPrivateKey(
+  coinName,
+  coinType = 0
+) {
+  return _cleaners.asCodec.call(void 0, 
+    raw => {
+      if (raw == null || typeof raw !== 'object') {
+        throw new TypeError('Private keys must be objects')
+      }
+      return _cleaners.asObject.call(void 0, {
+        coinType: _cleaners.asOptional.call(void 0, _cleaners.asNumber, coinType),
+        format: asOptionalPrivateKeyFormat,
+        imported: _cleaners.asOptional.call(void 0, _cleaners.asBoolean),
+        seed: _cleaners.asString
+      })({ ...raw, seed: raw[`${coinName}Key`] })
+    },
+    clean => {
+      const { coinType, format, imported, seed } = clean
+      return {
+        coinType,
+        format,
+        imported,
+        [`${coinName}Key`]: seed
+      }
+    }
+  )
+} exports.asPrivateKey = asPrivateKey;
+
+/**
+ * A cleaner for the public key format following the key-formats specification.
+ *
+ * (spec: https://github.com/EdgeApp/edge-core-js/blob/master/docs/key-formats.md)
+ */
+
+
+
+
+
+ const asPublicKey = _cleaners.asObject.call(void 0, {
+  publicKeys: _cleaners.asObject.call(void 0, {
+    bip32: _cleaners.asOptional.call(void 0, _cleaners.asString),
+    bip44: _cleaners.asOptional.call(void 0, _cleaners.asString),
+    bip49: _cleaners.asOptional.call(void 0, _cleaners.asString),
+    bip84: _cleaners.asOptional.call(void 0, _cleaners.asString)
+  })
+}); exports.asPublicKey = asPublicKey
+
+/**
+ * This utility returns a wallet's supported formats as specified in the
+ * key-formats specification.
+ */
+ const getSupportedFormats = (
+  format
+) => {
+  switch (format) {
+    case 'bip32':
+      return ['bip32']
+    case 'bip44':
+      return ['bip44']
+    case 'bip49':
+      return ['bip49']
+    case 'bip84':
+      return ['bip84']
+    default:
+      throw new Error(`Unsupported format ${format}`)
+  }
+}; exports.getSupportedFormats = getSupportedFormats
+
+/**
+ * A cleaner that desensitizes the walletInfo object, excluding sensitive
+ * keys (seed/mnemonic, sync key, data key, etc). By using this object type
+ * internally within the plugin, we can minimize risk of leaking sensitive data.
+ *
+ * It also includes internal derived data (publicKey, format, walletFormats, etc).
+ * This derived data is to be used internally within the plugin and saved to disk (publicKey).
+ *
+ * The `walletFormats` field is a list of formats from which to derive
+ * extended-keys for the wallet.
+ *
+ * The `primaryFormat` field is the default format from which to derive
+ * addresses from.
+ */
+
+
+
+
+
+
+
+
+
+
+ const asNumbWalletInfo = (
+  pluginInfo
+) => {
+  return (walletInfo) => {
+    const { engineInfo, coinInfo } = pluginInfo
+    const { id, type } = walletInfo
+
+    const asCurrencyPrivateKey = asPrivateKey(coinInfo.name, coinInfo.coinType)
+
+    const publicKey = _cleaners.asMaybe.call(void 0, (0, exports.asPublicKey))(walletInfo.keys)
+    if (publicKey != null) {
+      const walletFormats = Object.entries(publicKey.publicKeys)
+        // Filter out undefined values in the entries because cleaners allow
+        // undefined values for optional fields.
+        .filter(([, value]) => value != null)
+        // Map to the entry's key as a currency format
+        .map(([format]) => _cleaners.asMaybe.call(void 0, (0, _types3.asCurrencyFormat))(format))
+        // Filter out any formats that didn't pass the cleaner assertion
+        .filter(
+          (format) => format != null
+        )
+
+      if (walletFormats.length === 0) {
+        throw new Error('Missing wallet public keys')
+      }
+
+      // Search the engineInfo's formats array for the first format that exists
+      // in the publicKey data.
+      // If there are no defined formats in the engineInfo, then fallback to the
+      // first format in the publicKey after sorting alphabetically.
+      const primaryFormat =
+        _nullishCoalesce((engineInfo.formats != null && engineInfo.formats.length > 0
+          ? engineInfo.formats.find(format => walletFormats.includes(format))
+          : undefined), () => (
+        walletFormats.sort((a, b) => (a === b ? 0 : a > b ? 1 : -1))[0]))
+
+      return {
+        id,
+        type,
+        keys: {
+          primaryFormat,
+          walletFormats,
+          publicKey
+        }
+      }
+    }
+
+    const privateKey = _cleaners.asMaybe.call(void 0, asCurrencyPrivateKey)(walletInfo.keys)
+    if (privateKey != null) {
+      const publicKey = _utils.deriveXpubsFromKeys.call(void 0, {
+        privateKey,
+        coin: coinInfo.name
+      })
+      const walletFormats = exports.getSupportedFormats.call(void 0, privateKey.format)
+
+      return {
+        id,
+        type,
+        keys: {
+          primaryFormat: privateKey.format,
+          walletFormats,
+          publicKey: { publicKeys: publicKey }
+        }
+      }
+    }
+
+    // If we get here, nothing matched:
+    throw new Error('Either a public or private key are required')
+  }
+}; exports.asNumbWalletInfo = asNumbWalletInfo

package/lib/common/utxobased/keymanager/coinmapper.js

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _all = require('../info/all');
+
+
+ function getCoinFromString(coinName) {
+  const pluginInfo = _all.all.find(
+    pluginInfo => pluginInfo.coinInfo.name === coinName
+  )
+  if (pluginInfo == null) {
+    throw new Error('Could not find coin info ' + coinName)
+  }
+  return pluginInfo.coinInfo
+} exports.getCoinFromString = getCoinFromString;

package/lib/common/utxobased/keymanager/declarations/base58grscheck.d.js

@@ -0,0 +1 @@
+"use strict";

package/lib/common/utxobased/keymanager/declarations/blake-hash.d.js

@@ -0,0 +1 @@
+"use strict";

package/lib/common/utxobased/keymanager/declarations/bn.d.js

@@ -0,0 +1 @@
+"use strict";

package/lib/common/utxobased/keymanager/declarations/bs58smartcheck.d.js

@@ -0,0 +1 @@
+"use strict";