@exodus/bitcoin-api 1.0.4 → 2.0.0

package/package.json

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

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/index.js

@@ -6,7 +6,6 @@ export * from './bitcoinjs-lib'
 export { default as InsightAPIClient } from './insight-api-client'
 export { default as InsightWSClient } from './insight-api-client/ws'
 export { default as bip44Constants } from './constants/bip44'
-export { default as createGetKeyIdentifier } from './key-identifier'
 export * from './tx-send'
 export * from './tx-sign'
 export * from './fee'

package/src/key-identifier.js

@@ -1,21 +0,0 @@
-import { buildBip32Path } from '@exodus/keychain'
-import assert from 'minimalistic-assert'
-
-export default ({ bip44 }) => ({ purpose, accountIndex, chainIndex, addressIndex }) => {
-  assert(typeof bip44 === 'number', 'bip44 must be a number')
-  // TODO, move key-utils.js hydra/keychain to asset libs.
-  // https://github.com/ExodusMovement/assets/pull/410#discussion_r1026331735
-  const derivationPath = buildBip32Path({
-    asset: { bip44 }, // buildBip32Path only requires bip44. Change asset with bip44 and validate!
-    purpose,
-    accountIndex,
-    chainIndex,
-    addressIndex,
-  })
-
-  return {
-    derivationAlgorithm: 'BIP32',
-    derivationPath,
-    keyType: 'secp256k1',
-  }
-}