edge-currency-plugins 1.0.0-rc.1

package/lib/common/utxobased/engine/makeUtxoWalletTools.js

@@ -0,0 +1,216 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+
+
+
+
+
+
+
+
+var _keymanager = require('../keymanager/keymanager');
+
+
+
+
+
+var _utils = require('./utils');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ function makeUtxoWalletTools(
+  config
+) {
+  const { coin, publicKey } = config
+
+  const xpubKeys = publicKey.publicKeys
+
+  const fns = {
+    getPubkey(args) {
+      if (xpubKeys[args.format] == null) {
+        throw new Error(
+          `wallet tools: xpub with format ${args.format} does not exist`
+        )
+      }
+      return _keymanager.xpubToPubkey.call(void 0, {
+        xpub: _nullishCoalesce(xpubKeys[args.format], () => ( '')),
+        coin,
+        type: _utils.currencyFormatToPurposeType.call(void 0, args.format),
+        bip44ChangeIndex: args.changeIndex,
+        bip44AddressIndex: args.addressIndex
+      })
+    },
+
+    getScriptPubkey(args) {
+      const purposeType = _utils.currencyFormatToPurposeType.call(void 0, args.format)
+      const scriptType = _utils.getScriptTypeFromPurposeType.call(void 0, purposeType)
+      return _keymanager.pubkeyToScriptPubkey.call(void 0, {
+        pubkey: fns.getPubkey(args),
+        scriptType
+      })
+    },
+
+    // Used specifically for sweeping private keys (WIFs)
+    getScriptPubkeyFromWif(
+      wifKey,
+      format
+    ) {
+      const purposeType = _utils.currencyFormatToPurposeType.call(void 0, format)
+      const scriptType = _utils.getScriptTypeFromPurposeType.call(void 0, purposeType)
+      const pubkey = _keymanager.privateKeyToPubkey.call(void 0, 
+        _keymanager.wifToPrivateKey.call(void 0, {
+          wifKey,
+          coin
+        })
+      )
+      return _keymanager.pubkeyToScriptPubkey.call(void 0, {
+        pubkey: pubkey,
+        scriptType
+      })
+    },
+
+    getAddress(args) {
+      const purposeType = _utils.currencyFormatToPurposeType.call(void 0, args.format)
+      const { scriptPubkey } = fns.getScriptPubkey(args)
+      const addressType = _utils.getAddressTypeFromPurposeType.call(void 0, purposeType)
+      return _keymanager.scriptPubkeyToAddress.call(void 0, {
+        scriptPubkey,
+        addressType,
+        coin
+      })
+    },
+
+    addressToScriptPubkey(address) {
+      return _keymanager.addressToScriptPubkey.call(void 0, { address, coin })
+    },
+
+    scriptPubkeyToAddress(args) {
+      const purposeType = _utils.currencyFormatToPurposeType.call(void 0, args.format)
+      const addressType = _utils.getAddressTypeFromPurposeType.call(void 0, purposeType)
+      return _keymanager.scriptPubkeyToAddress.call(void 0, {
+        scriptPubkey: args.scriptPubkey,
+        addressType,
+        coin
+      })
+    },
+
+    getPrivateKey(args) {
+      const { path, xprivKeys } = args
+      const xpriv = xprivKeys[path.format]
+      if (xpriv == null) {
+        throw new Error(
+          `wallet tools: xpriv with format ${path.format} does not exist`
+        )
+      }
+      return _keymanager.xprivToPrivateKey.call(void 0, {
+        xpriv: xpriv,
+        type: _utils.currencyFormatToPurposeType.call(void 0, path.format),
+        coin,
+        bip44ChangeIndex: path.changeIndex,
+        bip44AddressIndex: path.addressIndex
+      })
+    },
+
+    getPrivateKeyFromWif(wifKey) {
+      return _keymanager.wifToPrivateKey.call(void 0, {
+        wifKey,
+        coin
+      })
+    },
+
+    getScriptAddress({
+      path,
+      scriptTemplate
+    }) {
+      // get the replay protection script from the templates and wrap it in p2sh
+      const publicKey = fns.getPubkey(path)
+      const script = scriptTemplate(publicKey)
+      const { address, scriptPubkey, redeemScript } = _keymanager.scriptPubkeyToP2SH.call(void 0, {
+        coin,
+        scriptPubkey: script
+      })
+      if (address == null) {
+        throw new Error('Failed to derive address for script')
+      }
+      return { address, scriptPubkey, redeemScript }
+    },
+
+    signMessageBase64({ path, message, xprivKeys }) {
+      const privKey = fns.getPrivateKey({
+        path,
+        xprivKeys
+      })
+      return _keymanager.signMessageBase64.call(void 0, message, privKey)
+    }
+  }
+
+  return fns
+} exports.makeUtxoWalletTools = makeUtxoWalletTools;

package/lib/common/utxobased/engine/paymentRequest.js

@@ -0,0 +1,102 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+
+
+var _urlparse = require('url-parse'); var _urlparse2 = _interopRequireDefault(_urlparse);
+
+
+
+
+
+
+
+
+
+
+
+ function getSpendTargets(
+  outputs
+) {
+  let nativeAmount = 0
+  const spendTargets = []
+  for (const output of outputs) {
+    nativeAmount += output.amount
+    spendTargets.push({
+      publicAddress: output.address,
+      nativeAmount: `${output.amount}`
+    })
+  }
+  return { nativeAmount, spendTargets }
+} exports.getSpendTargets = getSpendTargets;
+
+ async function getPaymentDetails(
+  paymentProtocolURL,
+  currencyCode,
+  fetch
+) {
+  const headers = {
+    Accept: 'application/payment-request',
+    'x-currency': currencyCode
+  }
+  const result = await fetch(paymentProtocolURL, { headers })
+  if (result.status !== 200) {
+    const error = await result.text()
+    throw new Error(error)
+  }
+  const paymentRequest = await result.json()
+  const {
+    outputs,
+    memo,
+    paymentUrl,
+    paymentId,
+    requiredFeeRate
+  } = paymentRequest
+
+  const { nativeAmount, spendTargets } = getSpendTargets(outputs)
+  const domain = _urlparse2.default.call(void 0, paymentUrl, {}).hostname
+
+  const edgePaymentProtocolInfo = {
+    nativeAmount: `${nativeAmount}`,
+    merchant: `{ ${JSON.stringify(paymentId)}, ${JSON.stringify(
+      requiredFeeRate
+    )} }`,
+    memo,
+    domain,
+    spendTargets
+  }
+
+  return edgePaymentProtocolInfo
+} exports.getPaymentDetails = getPaymentDetails;
+
+
+
+
+
+
+ function createPayment(
+  tx,
+  currencyCode
+) {
+  return { currency: currencyCode, transactions: [tx] }
+} exports.createPayment = createPayment;
+
+ async function sendPayment(
+  fetch,
+  paymentUrl,
+  payment
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+  const headers = { 'Content-Type': 'application/payment' }
+  const result = await fetch(paymentUrl, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(payment)
+  })
+  if (result.status !== 200) {
+    const error = await result.text()
+    throw new Error(error)
+  }
+  const paymentACK = await result.json()
+  return paymentACK
+} exports.sendPayment = sendPayment;

package/lib/common/utxobased/engine/types.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _cleaners = require('cleaners');
+
+
+
+
+ const asUtxoUserSettings = _cleaners.asObject.call(void 0, {
+  blockbookServers: _cleaners.asMaybe.call(void 0, _cleaners.asArray.call(void 0, _cleaners.asString), []),
+  enableCustomServers: _cleaners.asMaybe.call(void 0, _cleaners.asBoolean, false)
+}); exports.asUtxoUserSettings = asUtxoUserSettings
+
+
+
+
+
+
+
+
+
+
+
+

package/lib/common/utxobased/engine/util/defaultValidateConfirmations.js

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+ const defaultValidateConfirmations = (
+  tx,
+  blockHeight,
+  requiredConfirmations = 1
+) => {
+  const blockConfirmations =
+    tx.blockHeight === 0 ? 0 : 1 + blockHeight - tx.blockHeight
+  const confirmations =
+    blockConfirmations >= requiredConfirmations
+      ? 'confirmed'
+      : blockConfirmations <= 0
+      ? 'unconfirmed'
+      : blockConfirmations
+  return confirmations
+}; exports.defaultValidateConfirmations = defaultValidateConfirmations

package/lib/common/utxobased/engine/util/getOwnUtxosFromTx.js

@@ -0,0 +1,54 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _keymanager = require('../../keymanager/keymanager');
+
+
+
+var _utils = require('../utils');
+
+ const getOwnUtxosFromTx = async (
+  engineInfo,
+  processor,
+  tx
+) => {
+  const utxos = []
+  for (const output of tx.outputs) {
+    const scriptPubkey = output.scriptPubkey
+    const address = await processor.fetchAddress(scriptPubkey)
+    if (address != null) {
+      const id = `${tx.txid}_${output.n}`
+      const path = address.path
+      if (path != null) {
+        const redeemScript = address.redeemScript
+        const purposeType = _utils.currencyFormatToPurposeType.call(void 0, path.format)
+
+        const isAirbitzOrLegacy = [
+          _keymanager.BIP43PurposeTypeEnum.Airbitz,
+          _keymanager.BIP43PurposeTypeEnum.Legacy
+        ].includes(purposeType)
+
+        const scriptType = _utils.getScriptTypeFromPurposeType.call(void 0, 
+          purposeType,
+          redeemScript,
+          engineInfo.scriptTemplates
+        )
+        const script = isAirbitzOrLegacy ? tx.hex : address.scriptPubkey
+        const utxo = {
+          id,
+          txid: tx.txid,
+          vout: output.n,
+          value: output.amount,
+          scriptPubkey,
+          script,
+          redeemScript,
+          scriptType,
+          blockHeight: tx.blockHeight,
+          spent: false
+        }
+        utxos.push(utxo)
+      }
+    }
+  }
+  return utxos
+}; exports.getOwnUtxosFromTx = getOwnUtxosFromTx

package/lib/common/utxobased/engine/utils.js

@@ -0,0 +1,239 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
+
+
+
+
+
+
+var _cleaners = require('../keymanager/cleaners');
+
+
+
+
+
+
+
+
+
+
+
+
+var _keymanager = require('../keymanager/keymanager');
+
+ const getCurrencyFormatFromPurposeType = (
+  purpose
+) => {
+  switch (purpose) {
+    case _keymanager.BIP43PurposeTypeEnum.Airbitz:
+      return 'bip32'
+    case _keymanager.BIP43PurposeTypeEnum.Legacy:
+      return 'bip44'
+    case _keymanager.BIP43PurposeTypeEnum.WrappedSegwit:
+      return 'bip49'
+    case _keymanager.BIP43PurposeTypeEnum.Segwit:
+      return 'bip84'
+  }
+}; exports.getCurrencyFormatFromPurposeType = getCurrencyFormatFromPurposeType
+
+ const getAddressTypeFromKeys = (
+  privateKey
+) => {
+  return exports.getAddressTypeFromPurposeType.call(void 0, 
+    exports.currencyFormatToPurposeType.call(void 0, privateKey.format)
+  )
+}; exports.getAddressTypeFromKeys = getAddressTypeFromKeys
+
+ const getAddressTypeFromPurposeType = (
+  purpose
+) => {
+  switch (purpose) {
+    case _keymanager.BIP43PurposeTypeEnum.Airbitz:
+    case _keymanager.BIP43PurposeTypeEnum.Legacy:
+      return _keymanager.AddressTypeEnum.p2pkh
+
+    case _keymanager.BIP43PurposeTypeEnum.WrappedSegwit:
+      return _keymanager.AddressTypeEnum.p2sh
+
+    case _keymanager.BIP43PurposeTypeEnum.Segwit:
+      return _keymanager.AddressTypeEnum.p2wpkh
+  }
+}; exports.getAddressTypeFromPurposeType = getAddressTypeFromPurposeType
+
+ const getScriptTypeFromPurposeType = (
+  purpose,
+  redeemScript,
+  scriptTemplates
+) => {
+  switch (purpose) {
+    case _keymanager.BIP43PurposeTypeEnum.Airbitz:
+    case _keymanager.BIP43PurposeTypeEnum.Legacy:
+      if (redeemScript != null) {
+        if (_optionalChain([scriptTemplates, 'optionalAccess', _ => _.replayProtection]) != null) {
+          const replayProtectionPartialScript = scriptTemplates
+            .replayProtection('')
+            .slice(0, -4)
+          if (redeemScript.indexOf(replayProtectionPartialScript) === 0) {
+            return _keymanager.ScriptTypeEnum.replayProtection
+          }
+        }
+      }
+      return _keymanager.ScriptTypeEnum.p2pkh
+
+    case _keymanager.BIP43PurposeTypeEnum.WrappedSegwit:
+      return _keymanager.ScriptTypeEnum.p2wpkhp2sh
+
+    case _keymanager.BIP43PurposeTypeEnum.Segwit:
+      return _keymanager.ScriptTypeEnum.p2wpkh
+  }
+}; exports.getScriptTypeFromPurposeType = getScriptTypeFromPurposeType
+
+ const validScriptPubkeyFromAddress = (args
+
+
+) =>
+  _keymanager.addressToScriptPubkey.call(void 0, {
+    ...args
+  }); exports.validScriptPubkeyFromAddress = validScriptPubkeyFromAddress
+
+ const getFormatSupportedBranches = (
+  format
+) => {
+  const branches = [0]
+  if (exports.currencyFormatToPurposeType.call(void 0, format) !== _keymanager.BIP43PurposeTypeEnum.Airbitz) {
+    branches.push(1)
+  }
+  return branches
+}; exports.getFormatSupportedBranches = getFormatSupportedBranches
+
+ const currencyFormatToPurposeType = (
+  format
+) =>
+  _keymanager.bip43PurposeNumberToTypeEnum.call(void 0, parseInt(format.replace('bip', ''))); exports.currencyFormatToPurposeType = currencyFormatToPurposeType
+
+
+
+
+
+ const fetchOrDeriveXprivFromKeys = async (args
+
+
+
+) => {
+  const filename = 'walletKeys.json'
+  let keys
+  try {
+    const data = await args.walletLocalEncryptedDisklet.getText(filename)
+    keys = JSON.parse(data)
+  } catch (e) {
+    keys = exports.deriveXprivFromKeys.call(void 0, args)
+    await args.walletLocalEncryptedDisklet.setText(
+      filename,
+      JSON.stringify(keys)
+    )
+  }
+  return keys
+}; exports.fetchOrDeriveXprivFromKeys = fetchOrDeriveXprivFromKeys
+
+ const deriveXprivFromKeys = (args
+
+
+) => {
+  const keys = {}
+  const xprivArgs = {
+    seed: args.privateKey.seed,
+    coinType: args.privateKey.coinType,
+    coin: args.coin
+  }
+  const walletPurpose = exports.currencyFormatToPurposeType.call(void 0, args.privateKey.format)
+  if (
+    walletPurpose === _keymanager.BIP43PurposeTypeEnum.Segwit ||
+    walletPurpose === _keymanager.BIP43PurposeTypeEnum.WrappedSegwit
+  ) {
+    keys[
+      exports.getCurrencyFormatFromPurposeType.call(void 0, _keymanager.BIP43PurposeTypeEnum.Segwit)
+    ] = _keymanager.seedOrMnemonicToXPriv.call(void 0, {
+      ...xprivArgs,
+      type: _keymanager.BIP43PurposeTypeEnum.Segwit
+    })
+    keys[
+      exports.getCurrencyFormatFromPurposeType.call(void 0, _keymanager.BIP43PurposeTypeEnum.WrappedSegwit)
+    ] = _keymanager.seedOrMnemonicToXPriv.call(void 0, {
+      ...xprivArgs,
+      type: _keymanager.BIP43PurposeTypeEnum.WrappedSegwit
+    })
+  } else {
+    keys[
+      exports.getCurrencyFormatFromPurposeType.call(void 0, walletPurpose)
+    ] = _keymanager.seedOrMnemonicToXPriv.call(void 0, {
+      ...xprivArgs,
+      type: walletPurpose
+    })
+  }
+
+  return keys
+}; exports.deriveXprivFromKeys = deriveXprivFromKeys
+
+ const deriveXpubsFromKeys = (args
+
+
+) => {
+  const xpubs = {}
+  for (const format of _cleaners.getSupportedFormats.call(void 0, args.privateKey.format)) {
+    xpubs[format] = exports.deriveXpub.call(void 0, {
+      ...args,
+      type: exports.currencyFormatToPurposeType.call(void 0, format)
+    })
+  }
+  return xpubs
+}; exports.deriveXpubsFromKeys = deriveXpubsFromKeys
+
+ const deriveXpub = (args
+
+
+
+) => {
+  const xpriv = exports.deriveXprivFromKeys.call(void 0, args)[
+    exports.getCurrencyFormatFromPurposeType.call(void 0, args.type)
+  ]
+  if (xpriv == null)
+    throw new Error('Cannot derive xpub: no private key exists')
+  return _keymanager.xprivToXPub.call(void 0, { ...args, xpriv })
+}; exports.deriveXpub = deriveXpub
+
+ const parsePathname = (args
+
+
+) => {
+  const edgeParsedUri = {}
+
+  // Check if the pathname type is a wif
+  try {
+    _keymanager.wifToPrivateKey.call(void 0, {
+      wifKey: args.pathname,
+      coin: args.coin
+    })
+    edgeParsedUri.privateKeys = [args.pathname]
+  } catch (e) {
+    // If the pathname is non of the above, then assume it's an address and check for validity
+    const addressFormat = _keymanager.verifyAddress.call(void 0, {
+      address: args.pathname,
+      coin: args.coin
+    })
+
+    // Throw if address format failed
+    if (addressFormat === _keymanager.VerifyAddressEnum.bad)
+      throw new Error('InvalidPublicAddressError')
+
+    // Format publicAddress to the latest format from the provided address
+    edgeParsedUri.publicAddress = _keymanager.toNewFormat.call(void 0, args.pathname, args.coin)
+
+    // Include a legacyAddress if the provided format is a legacy format
+    if (addressFormat === _keymanager.VerifyAddressEnum.legacy)
+      edgeParsedUri.legacyAddress = args.pathname
+  }
+
+  return edgeParsedUri
+}; exports.parsePathname = parsePathname
+
+ const sumUtxos = (utxos) =>
+  utxos.reduce((sum, { value }) => bs.add(sum, value), '0'); exports.sumUtxos = sumUtxos