@exodus/bitcoin-api 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -19,13 +19,15 @@
     "lint:fix": "yarn lint --fix"
   },
   "dependencies": {
-    "@exodus/asset-lib": "^3.7.1",
+    "@exodus/asset-lib": "^3.7.2",
+    "@exodus/bip44-constants": "^195.0.0",
     "@exodus/bitcoinjs-lib": "6.0.2-beta.4",
     "@exodus/keychain": "^3.0.0",
     "@exodus/models": "^8.10.4",
     "@exodus/secp256k1": "4.0.2-exodus.0",
     "@exodus/simple-retry": "0.0.6",
-    "bip44-constants": "55.0.0",
+    "@exodus/timer": "^1.0.0",
+    "bech32": "^1.1.3",
     "coininfo": "5.1.0",
     "delay": "4.0.1",
     "ecpair": "2.0.1",
@@ -38,5 +40,5 @@
     "@exodus/bip-schnorr": "0.6.6-fork-1",
     "@noble/secp256k1": "~1.5.3"
   },
-  "gitHead": "6da3cc2b9aaba76c1e3523d9598e465c4b4f45eb"
+  "gitHead": "0be2bccacf297e2b4fcb65cf758f415f1b2df50e"
 }

package/src/btc-like-address.js

@@ -21,7 +21,7 @@ export const createBtcLikeAddress = ({
       ? undefined
       : (string) => {
           const payload = bs58check.decodeUnsafe(string)
-          return payload && payload.length === 21 && payload[0] === version
+          return !!payload && payload.length === 21 && payload[0] === version
         }
 
   const bech32ValidateFactory = (version, length) =>

package/src/constants/bip44.js

@@ -1,27 +1,3 @@
-import bip44Constants from 'bip44-constants'
-
-// MOVE TO SHARED LIB!!!
-
-// Translate from
-//   array of [bip44, symbol, coin]
-// to
-//   map of symbol ---> bip44
-//
-// Careful: for duplicate symbols only the first definition gets stored.
-// Duplicate symbols: LTBC, DST, SAFE, BCO, RYO, XRD
-// Run tests to find all differences between existing and new constants.
-
-const _bip44Constants = {}
-for (let [c, t] of bip44Constants) {
-  if (!(t in _bip44Constants)) {
-    _bip44Constants[t] = c
-  }
-}
-
-// force NANO to 'Bitcoin Nano'
-_bip44Constants['NANO'] = 0x80000100
-_bip44Constants['HBAR'] = _bip44Constants['XHB']
-_bip44Constants['FLR'] = 0x8000022a
-_bip44Constants['EGLD'] = 0x800001fc
-
-export default _bip44Constants
+// back compatibility. Use @exodus/bip44-constants/by-ticker instead
+import bip44Constants from '@exodus/bip44-constants/by-ticker'
+export default bip44Constants

package/src/fee/fee-estimator.js

@@ -2,9 +2,10 @@
 import assert from 'minimalistic-assert'
 import * as varuint from 'varuint-bitcoin'
 import { UtxoCollection } from '@exodus/models'
-
 import { scriptClassify } from '../bitcoinjs-lib'
 
+import { scriptClassifierFactory } from './script-classifier'
+
 import createDefaultFeeEstimator, { isHex } from './fee-utils'
 
 const { P2PKH, P2SH, P2WPKH, P2WSH, P2TR } = scriptClassify.types
@@ -52,116 +53,117 @@ const scriptPubKeyLengths = {
 // 10 = version: 4, locktime: 4, inputs and outputs count: 1
 // 148 = txId: 32, vout: 4, count: 1, script: 107 (max), sequence: 4
 // 34 = value: 8, count: 1, scriptPubKey: 25 (P2PKH) and 23 (P2SH)
-export const getSizeFactory = ({ ecc, defaultOutputType, addressApi }) => (
-  asset: Object,
-  inputs: Array | UtxoCollection,
-  outputs: Array,
-  { compressed = true } = {}
-) => {
+export const getSizeFactory = ({ ecc, defaultOutputType, addressApi }) => {
   assert(ecc, 'ecc is required')
   assert(defaultOutputType, 'defaultOutputType is required')
   assert(addressApi, 'addressApi is required')
-  const assetName = asset.name
-  if (inputs instanceof UtxoCollection) {
-    inputs = Array.from(inputs).map((utxo) => utxo.script || null)
-  }
 
-  // other bitcoin-like assets
-  const classifyOutput = scriptClassify.outputFactory({ ecc })
-  const baseSize =
-    4 + // n_version
-    4 + // n_locktime
-    varuint.encodingLength(inputs.length) + // inputs_len
-    // input[]
-    inputs.reduce((t, script) => {
-      if (script === null) script = '76a914000000000000000000000000000000000000000088ac' // P2PKH
-      assert(isHex(script), 'script must be hex string')
-
-      const scriptBuffer = Buffer.from(script, 'hex')
-      const scriptType = classifyOutput(scriptBuffer)
-
-      const supportedTypes = supportedInputTypes[assetName] || supportedInputTypes.default
-      assert(
-        supportedTypes.includes(scriptType),
-        `Only ${supportedTypes.join(', ')} inputs supported right now`
-      )
-
-      const scriptSigLengths = compressed
-        ? scriptSigCompressedLengths
-        : scriptSigUncompressedLengths
-      const scriptSigLength = scriptSigLengths[scriptType]
-      return t + 32 + 4 + varuint.encodingLength(scriptSigLength) + scriptSigLength + 4
-    }, 0) +
-    varuint.encodingLength(outputs.length) + // outputs_len
-    // output[]
-    outputs.reduce((t, output) => {
-      // if (output === null) output = get(asset, 'address.versions.bech32') ? 'P2WSH' : 'P2PKH'
-
-      if (output === null) output = defaultOutputType
-
-      let scriptType = scriptClassify.types[output]
-      const supportedTypes = supportedOutputTypes[assetName] || supportedOutputTypes.default
-
-      if (!supportedTypes.includes(scriptType)) {
-        if (addressApi.isP2PKH(output)) scriptType = P2PKH
-        else if (addressApi.isP2SH(output)) scriptType = P2SH
-        else if (addressApi.isP2WPKH && addressApi.isP2WPKH(output)) scriptType = P2WPKH
-        else if (addressApi.isP2TR && addressApi.isP2TR(output)) scriptType = P2TR
-        else if (addressApi.isP2WSH && addressApi.isP2WSH(output)) scriptType = P2WSH
-        else {
-          scriptType = classifyOutput(addressApi.toScriptPubKey(output))
-        }
-      }
-      assert(
-        supportedTypes.includes(scriptType),
-        `Only ${supportedTypes.join(', ')} outputs supported right now`
-      )
-
-      const scriptPubKeyLength = scriptPubKeyLengths[scriptType]
-      return t + 8 + varuint.encodingLength(scriptPubKeyLength) + scriptPubKeyLength
-    }, 0)
-
-  const witnessSize =
-    1 + // marker
-    1 + // flag
-    // witnesses
-    inputs.reduce((t, script) => {
-      if (!script) return t + 1
-      const utxoScriptType = classifyOutput(Buffer.from(script, 'hex'))
-      if ([P2SH, P2WPKH].includes(utxoScriptType)) {
-        const pubKeyLength = 33
-        const signatureLength = 73 // maximum possible length
-        // Need to encode the witness item count, which is 2 for for P2WPKH as a var_int
-        return (
-          t +
-          varuint.encodingLength(2) +
-          varuint.encodingLength(pubKeyLength) +
-          pubKeyLength +
-          varuint.encodingLength(signatureLength) +
-          signatureLength
+  const scriptClassifier = scriptClassifierFactory({ ecc, addressApi })
+
+  return (
+    asset: Object,
+    inputs: Array | UtxoCollection,
+    outputs: Array,
+    { compressed = true } = {}
+  ) => {
+    if (inputs instanceof UtxoCollection) {
+      inputs = Array.from(inputs).map((utxo) => utxo.script || null)
+    }
+    const assetName = asset.name
+    // other bitcoin-like assets
+    const baseSize =
+      4 + // n_version
+      4 + // n_locktime
+      varuint.encodingLength(inputs.length) + // inputs_len
+      // input[]
+      inputs.reduce((t, script) => {
+        if (script === null) script = '76a914000000000000000000000000000000000000000088ac' // P2PKH
+        assert(isHex(script), 'script must be hex string')
+
+        const scriptType = scriptClassifier.classifyScriptHex({ assetName, script })
+
+        const supportedTypes = supportedInputTypes[assetName] || supportedInputTypes.default
+        assert(
+          supportedTypes.includes(scriptType),
+          `Only ${supportedTypes.join(', ')} inputs supported right now`
         )
-      }
-      if ([P2TR].includes(utxoScriptType)) {
-        // Only the 64 byte Schnorr signature is present for Taproot Key-Path spend
-        const signatureLength = 64
-        return (
-          t + varuint.encodingLength(1) + varuint.encodingLength(signatureLength) + signatureLength
+
+        const scriptSigLengths = compressed
+          ? scriptSigCompressedLengths
+          : scriptSigUncompressedLengths
+        const scriptSigLength = scriptSigLengths[scriptType]
+        return t + 32 + 4 + varuint.encodingLength(scriptSigLength) + scriptSigLength + 4
+      }, 0) +
+      varuint.encodingLength(outputs.length) + // outputs_len
+      // output[]
+      outputs.reduce((t, output) => {
+        // if (output === null) output = get(asset, 'address.versions.bech32') ? 'P2WSH' : 'P2PKH'
+
+        if (output === null) output = defaultOutputType
+
+        let scriptType = scriptClassify.types[output]
+        const supportedTypes = supportedOutputTypes[assetName] || supportedOutputTypes.default
+
+        if (!supportedTypes.includes(scriptType)) {
+          scriptType = scriptClassifier.classifyAddress({
+            assetName,
+            address: output,
+          })
+        }
+        assert(
+          supportedTypes.includes(scriptType),
+          `Only ${supportedTypes.join(', ')} outputs supported right now`
         )
-      }
 
-      // Non-witness inputs get a placeholder zero byte
-      return t + 1
-    }, 0)
+        const scriptPubKeyLength = scriptPubKeyLengths[scriptType]
+        return t + 8 + varuint.encodingLength(scriptPubKeyLength) + scriptPubKeyLength
+      }, 0)
+
+    const witnessSize =
+      1 + // marker
+      1 + // flag
+      // witnesses
+      inputs.reduce((t, script) => {
+        if (!script) return t + 1
+        const utxoScriptType = scriptClassifier.classifyScriptHex({ assetName, script })
+        if ([P2SH, P2WPKH].includes(utxoScriptType)) {
+          const pubKeyLength = 33
+          const signatureLength = 73 // maximum possible length
+          // Need to encode the witness item count, which is 2 for for P2WPKH as a var_int
+          return (
+            t +
+            varuint.encodingLength(2) +
+            varuint.encodingLength(pubKeyLength) +
+            pubKeyLength +
+            varuint.encodingLength(signatureLength) +
+            signatureLength
+          )
+        }
+        if ([P2TR].includes(utxoScriptType)) {
+          // Only the 64 byte Schnorr signature is present for Taproot Key-Path spend
+          const signatureLength = 64
+          return (
+            t +
+            varuint.encodingLength(1) +
+            varuint.encodingLength(signatureLength) +
+            signatureLength
+          )
+        }
 
-  // If witness is all placeholder bytes, that means we have no witness inputs
-  // In that case, we're going to use the legacy serialization format, so just
-  // return baseSize
-  if (witnessSize === 1 + 1 + inputs.length) return baseSize
+        // Non-witness inputs get a placeholder zero byte
+        return t + 1
+      }, 0)
 
-  const totalSize = baseSize + witnessSize
-  const weight = baseSize * 3 + totalSize
-  // Return vbytes
-  return Math.ceil(weight / 4)
+    // If witness is all placeholder bytes, that means we have no witness inputs
+    // In that case, we're going to use the legacy serialization format, so just
+    // return baseSize
+    if (witnessSize === 1 + 1 + inputs.length) return baseSize
+
+    const totalSize = baseSize + witnessSize
+    const weight = baseSize * 3 + totalSize
+    // Return vbytes
+    return Math.ceil(weight / 4)
+  }
 }
 
 const getFeeEstimatorFactory = ({ ecc, defaultOutputType, addressApi }) => {

package/src/fee/script-classifier.js

@@ -0,0 +1,53 @@
+import { scriptClassify } from '../bitcoinjs-lib'
+import createHash from 'create-hash'
+
+import { memoizeLruCache } from '@exodus/asset-lib'
+import assert from 'minimalistic-assert'
+
+const { P2PKH, P2SH, P2WPKH, P2WSH, P2TR } = scriptClassify.types
+
+const cacheSize = 1000
+const maxSize = 30
+const hashStringIfTooBig = (str) =>
+  str.length > maxSize
+    ? createHash('sha256')
+        .update(str)
+        .digest('hex')
+        .slice(0, maxSize)
+    : str
+
+export const scriptClassifierFactory = ({ addressApi, ecc }) => {
+  assert(ecc, 'ecc is required')
+  assert(addressApi, 'addressApi is required')
+
+  const classifyOutput = scriptClassify.outputFactory({ ecc })
+
+  const classifyScriptHex = memoizeLruCache(
+    ({ assetName, script }) => {
+      assert(assetName, 'assetName is required')
+      assert(script, 'script is required')
+      return classifyOutput(Buffer.from(script, 'hex'))
+    },
+    ({ assetName, script }) => `${assetName}_${hashStringIfTooBig(script)}`, // hashing the script in case the script is really long
+    cacheSize
+  )
+
+  const classifyAddress = memoizeLruCache(
+    ({ assetName, address }) => {
+      assert(assetName, 'assetName is required')
+      assert(assetName, address, 'address is required')
+      if (addressApi.isP2PKH(address)) return P2PKH
+      else if (addressApi.isP2SH(address)) return P2SH
+      else if (addressApi.isP2WPKH && addressApi.isP2WPKH(address)) return P2WPKH
+      else if (addressApi.isP2TR && addressApi.isP2TR(address)) return P2TR
+      else if (addressApi.isP2WSH && addressApi.isP2WSH(address)) return P2WSH
+      return classifyScriptHex({
+        classifyOutput,
+        script: addressApi.toScriptPubKey(address).toString('hex'),
+      })
+    },
+    ({ assetName, address }) => `${assetName}_${address}`,
+    cacheSize
+  )
+  return { classifyScriptHex, classifyAddress }
+}

package/src/insight-api-client/index.js

@@ -4,6 +4,25 @@ import urlJoin from 'url-join'
 import qs from 'querystring'
 import delay from 'delay'
 
+const getTextFromResponse = async (response) => {
+  try {
+    const responseBody = await response.text()
+    return responseBody.substring(0, 100)
+  } catch (e) {
+    return ''
+  }
+}
+
+const fetchJson = async (url, fetchOptions) => {
+  const response = await fetch(url, fetchOptions)
+  if (!response.ok)
+    throw new Error(
+      `${url} returned ${response.status}: ${response.statusText ||
+        'Unknown Status Text'}. Body: ${await getTextFromResponse(response)}`
+    )
+  return response.json()
+}
+
 // TODO: use p-retry
 async function fetchJsonRetry(url, fetchOptions) {
   const waitTimes = [5, 10, 20, 30].map((t) => t * 1000)
@@ -22,12 +41,6 @@ async function fetchJsonRetry(url, fetchOptions) {
       }
     }
   }
-
-  async function fetchJson(url, fetchOptions) {
-    const response = await fetch(url, fetchOptions)
-    if (!response.ok) throw new Error(`${url} returned ${response.status}: ${response.statusText}`)
-    return response.json()
-  }
 }
 
 export default class InsightAPIClient {
@@ -41,9 +54,7 @@ export default class InsightAPIClient {
 
   async isNetworkConnected() {
     const url = urlJoin(this._baseURL, '/peer')
-    const resp = await fetch(url, { timeout: 10000 })
-    const peerStatus = await resp.json()
-
+    const peerStatus = await fetchJson(url, { timeout: 10000 })
     return !!peerStatus.connected
   }
 
@@ -56,9 +67,7 @@ export default class InsightAPIClient {
 
   async fetchBlockHeight() {
     const url = urlJoin(this._baseURL, '/status')
-    const resp = await fetch(url, { timeout: 10000 })
-    const status = await resp.json()
-
+    const status = await fetchJson(url, { timeout: 10000 })
     return status.info.blocks
   }
 
@@ -68,9 +77,7 @@ export default class InsightAPIClient {
       this._baseURL,
       opts.includeTxs ? `/addr/${encodedAddress}` : `/addr/${encodedAddress}?noTxList=1`
     )
-    const response = await fetch(url)
-
-    return response.json()
+    return fetchJson(url)
   }
 
   async fetchUTXOs(addresses, { assetNames = [] } = {}) {
@@ -81,8 +88,7 @@ export default class InsightAPIClient {
     }
     const encodedAddresses = encodeURIComponent(addresses)
     const url = urlJoin(this._baseURL, `/addrs/${encodedAddresses}/utxo?${query}`)
-    const response = await fetch(url)
-    const utxos = await response.json()
+    const utxos = await fetchJson(url)
 
     return utxos.map((utxo) => ({
       address: utxo.address,
@@ -111,8 +117,7 @@ export default class InsightAPIClient {
   async fetchRawTx(txId: string) {
     const encodedTxId = encodeURIComponent(txId)
     const url = urlJoin(this._baseURL, `/rawtx/${encodedTxId}`)
-    const response = await fetch(url)
-    const { rawtx } = await response.json()
+    const { rawtx } = await fetchJson(url)
     return rawtx
   }
 
@@ -155,14 +160,12 @@ export default class InsightAPIClient {
   async fetchUnconfirmedAncestorData(txId: string) {
     const encodedTxId = encodeURIComponent(txId)
     const url = urlJoin(this._baseURL, `/unconfirmed_ancestor/${encodedTxId}`)
-    const response = await fetch(url)
-    return response.json()
+    return fetchJson(url)
   }
 
   async fetchFeeRate() {
     const url = urlJoin(this._baseURL, '/v2/fees')
-    const response = await fetch(url)
-    return response.json()
+    return fetchJson(url)
   }
 
   async broadcastTx(rawTx) {
@@ -200,16 +203,12 @@ export default class InsightAPIClient {
   async getClaimable(address) {
     const encodedAddress = encodeURIComponent(address)
     const url = urlJoin(this._baseURL, `/addr/${encodedAddress}/claimable`)
-    const response = await fetch(url)
-    if (!response.ok) throw new Error(`${url} returned ${response.status}: ${response.statusText}`)
-    return response.json()
+    return fetchJson(url)
   }
 
   async getUnclaimed(address) {
     const encodedAddress = encodeURIComponent(address)
     const url = urlJoin(this._baseURL, `/addr/${encodedAddress}/unclaimed`)
-    const response = await fetch(url)
-    if (!response.ok) throw new Error(`${url} returned ${response.status}: ${response.statusText}`)
-    return response.json()
+    return fetchJson(url)
   }
 }

package/src/tx-sign/default-create-tx.js

@@ -1,7 +1,7 @@
 import assert from 'minimalistic-assert'
 import lodash from 'lodash'
 import ECPairFactory from 'ecpair'
-import { Psbt } from '@exodus/bitcoinjs-lib'
+import { Psbt, Transaction } from '@exodus/bitcoinjs-lib'
 
 import { toAsyncSigner, tweakSigner } from './taproot'
 
@@ -12,6 +12,15 @@ const _MAXIMUM_FEE_RATES = {
   ravencoin: 1000000,
 }
 
+const canParseTx = (rawTxBuffer) => {
+  try {
+    Transaction.fromBuffer(rawTxBuffer)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
 export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, network, ecc }) => {
   assert(assetName, 'assetName is required')
   assert(resolvePurpose, 'resolvePurpose is required')
@@ -62,10 +71,18 @@ export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, netwo
         // witness outputs only require the value and the script, not the full transaction
         txIn.witnessUtxo = { value, script: Buffer.from(script, 'hex') }
       } else {
-        // non-witness outptus require the full transaction
         const rawTx = (rawTxs || []).find((t) => t.txId === txId)
+        // non-witness outptus require the full transaction
         assert(!!rawTx, 'Non-witness outputs require the full previous transaction.')
-        txIn.nonWitnessUtxo = Buffer.from(rawTx.rawData, 'hex')
+        const rawTxBuffer = Buffer.from(rawTx.rawData, 'hex')
+        if (canParseTx(rawTxBuffer)) {
+          txIn.nonWitnessUtxo = rawTxBuffer
+        } else {
+          // temp fix for https://exodusio.slack.com/archives/CP202D90Q/p1671014704829939 until bitcoinjs could parse a mweb tx without failing
+          console.warn(`Setting psbt.__CACHE.__UNSAFE_SIGN_NONSEGWIT = true for asset ${assetName}`)
+          psbt.__CACHE.__UNSAFE_SIGN_NONSEGWIT = true
+          txIn.witnessUtxo = { value, script: Buffer.from(script, 'hex') }
+        }
       }
       psbt.addInput(txIn)
     }