@exodus/bitcoin-api 2.7.0 → 2.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.7.0",
+  "version": "2.7.2",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -43,5 +43,5 @@
     "@scure/btc-signer": "^1.1.0",
     "jest-when": "^3.5.1"
   },
-  "gitHead": "5c306496cb4086ff823640e8eadb0d9750ac3683"
+  "gitHead": "fc4a81292bf22690343a09522c159773a1606b7f"
 }

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

@@ -2,6 +2,7 @@
 import urlJoin from 'url-join'
 import qs from 'querystring'
 import delay from 'delay'
+import { isEmpty } from 'lodash'
 
 const getTextFromResponse = async (response) => {
   try {
@@ -105,13 +106,22 @@ export default class InsightAPIClient {
     const url = urlJoin(this._baseURL, `/tx/${encodedTxId}`)
     const response = await fetch(url)
 
-    // change in https://github.com/jprichardson/exodus-rn/pull/4336 may break Insight compatibility
-    // we're probably past the point of just spinning up an Insight server and have it plug n' play for Magnifier
-
     if (response.status === 404) return null
     return response.json()
   }
 
+  async fetchTxObject(txId) {
+    const url = urlJoin(this._baseURL, `/fulltx?${new URLSearchParams({ hash: txId })}`)
+    const response = await fetch(url)
+
+    if (response.status === 404) return null
+    const object = await response.json()
+    if (isEmpty(object)) {
+      return null
+    }
+    return object
+  }
+
   async fetchRawTx(txId) {
     const encodedTxId = encodeURIComponent(txId)
     const url = urlJoin(this._baseURL, `/rawtx/${encodedTxId}`)

package/src/tx-log/bitcoin-monitor-scanner.js

@@ -1,11 +1,12 @@
 import { orderTxs } from '../insight-api-client/util'
 import { Address, UtxoCollection } from '@exodus/models'
-import { isEqual, compact, uniq } from 'lodash'
+import { compact, isEqual, uniq } from 'lodash'
 import ms from 'ms'
 import assert from 'minimalistic-assert'
 import { isChangeAddress, isReceiveAddress } from '../address-utils'
 import { getOrdinalsUtxos, getUtxos, partitionUtxos } from '../utxos-utils'
 import { getOrdinalAddress } from '../ordinals-utils'
+import { indexOrdinalUnconfirmedTx } from './ordinals-indexer-utils'
 
 // Time to check whether to drop a sent tx
 const SENT_TIME_TO_DROP = ms('2m')
@@ -191,8 +192,30 @@ export class BitcoinMonitorScanner {
         promises.push(promise)
       }
 
-      const txArrays = await Promise.all(promises)
-      return txArrays.reduce((total, some) => total.concat(some), [])
+      const insightTxs = (await Promise.all(promises)).reduce(
+        (total, some) => total.concat(some),
+        []
+      )
+      if (!this.#ordinalsEnabled) {
+        return insightTxs
+      }
+      return Promise.all(
+        insightTxs.map((tx) => {
+          try {
+            return indexOrdinalUnconfirmedTx({
+              tx,
+              currency: this.#asset.currency,
+              insightClient,
+            })
+          } catch (e) {
+            console.warn(
+              `Could not index ${asset.name} ordinal tx ${tx.txid} for wallet account ${walletAccount}. message: ${e.message}`,
+              e
+            )
+            return tx
+          }
+        })
+      )
     }
 
     const gapSearchParameters = newChains.map(({ purpose, chain }) => {
@@ -244,6 +267,7 @@ export class BitcoinMonitorScanner {
         const receiveAddress = await this.#assetClientInterface.getReceiveAddressObject({
           assetName,
           walletAccount,
+          useCache: true,
         })
         if (!addresses.includes(receiveAddress.toString())) {
           addresses.push(receiveAddress.toString())

package/src/tx-log/bitcoin-monitor.js

@@ -86,6 +86,7 @@ export class Monitor extends BaseMonitor {
               multiAddressMode: true,
               assetName: this.asset.name,
               walletAccount,
+              useCache: true,
             }),
           ])
         )

package/src/tx-log/ordinals-indexer-utils.js

@@ -0,0 +1,53 @@
+import { memoizeLruCache } from '@exodus/asset-lib'
+import { cloneDeep } from 'lodash'
+
+export const indexOutputs = ({ tx, currency }) => {
+  const inscriptions = []
+
+  let inputOffset = 0
+  for (let i = 0; i < tx.vin.length; i++) {
+    const vin = tx.vin[i]
+    const value = currency.defaultUnit(vin.value).toBaseNumber()
+    inscriptions.push(
+      ...(vin.inscriptions || []).map((i) => ({ ...i, offset: i.offset + inputOffset }))
+    )
+    inputOffset = value
+  }
+
+  let outputOffset = 0
+  for (let i = 0; i < tx.vout.length; i++) {
+    const vout = tx.vout[i]
+    const value = currency.defaultUnit(vout.value).toBaseNumber()
+    vout.inscriptions = inscriptions
+      .map((i) => ({ ...i, offset: i.offset - outputOffset }))
+      .filter((i) => i.offset >= 0 && i.offset < value)
+    outputOffset = value
+  }
+  tx.inscriptionsMemoryIndexed = true // avoids btc being spent even when the mempool index was done in memory
+  return tx
+}
+
+export const indexOrdinalUnconfirmedTx = memoizeLruCache(
+  async ({ insightClient, currency, tx }) => {
+    if (tx.inscriptionsIndexed || tx.inscriptionsMemoryIndexed) {
+      return tx
+    }
+    const copyTx = cloneDeep(tx)
+    await Promise.all(
+      copyTx.vin.map(async (vin) => {
+        const outputTx = await indexOrdinalUnconfirmedTx({
+          insightClient,
+          currency,
+          tx: await insightClient.fetchTxObject(vin.txid),
+        })
+        if (!outputTx.inscriptionsIndexed && !outputTx.inscriptionsMemoryIndexed) {
+          throw new Error(`Cannot index ${tx.txid}. Input tx ${outputTx.txid} is not indexed. `)
+        }
+        vin.inscriptions = outputTx.vout[vin.vout].inscriptions
+      })
+    )
+    return indexOutputs({ tx: copyTx, currency })
+  },
+  ({ tx }) => tx.txid,
+  100
+)

package/src/tx-sign/common.js

@@ -1,20 +1,16 @@
-export function extractTransaction({ psbt, skipFinalize }) {
-  // If a dapp authored the TX, it expects a serialized PSBT response.
-  // Note: we wouldn't be able to finalise inputs in some cases that's why we serialize before finalizing inputs.
-
-  if (skipFinalize) {
-    const rawPSBT = psbt.toBuffer()
-
-    return { plainTx: { rawPSBT } }
-  } else {
+export function extractTransaction({ psbt, extract }) {
+  if (extract) {
     // Serialize tx
-    psbt.finalizeAllInputs()
-    const tx = psbt.extractTransaction()
-    const rawTx = tx.toBuffer()
-    const txId = tx.getId()
-
     // tx needs to be serializable for desktop RPC send => sign communication
-    return { rawTx, txId, tx: serializeTx({ tx }) }
+    const extractedTx = psbt.extractTransaction()
+    return {
+      rawTx: extractedTx.toBuffer(),
+      txId: extractedTx.getId(),
+      tx: serializeTx({ tx: extractedTx }),
+    }
+  } else {
+    // Web3 transactions can't be expected to be extractable.
+    return { plainTx: { rawPSBT: psbt.toBuffer() } }
   }
 }
 

package/src/tx-sign/create-sign-with-wallet.js

@@ -65,6 +65,7 @@ export function createSignWithWallet({
       // desktop / BE / mobile with bip-schnorr signing
       const signingKey = isTaprootAddress ? tweakSigner({ signer: key, ECPair, network }) : key
       await psbt.signInputAsync(index, toAsyncSigner({ keyPair: signingKey }), sigHashTypes)
+      psbt.finalizeInput(index)
     }
   }
 }

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

@@ -37,7 +37,6 @@ export const signTxFactory = ({ assetName, resolvePurpose, keys, coinInfo, netwo
 
     await signWithWallet(psbt, inputsToSign)
 
-    const skipFinalize = !!unsignedTx.txData.psbtBuffer
-    return extractTransaction({ psbt, skipFinalize })
+    return extractTransaction({ psbt, extract: !unsignedTx.txData.psbtBuffer })
   }
 }

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

@@ -39,8 +39,7 @@ export const signHardwareFactory = ({ assetName, resolvePurpose, keys, coinInfo
       accountIndex,
     })
 
-    const skipFinalize = !!unsignedTx.txData.psbtBuffer
-    return extractTransaction({ psbt, skipFinalize })
+    return extractTransaction({ psbt, extract: !unsignedTx.txData.psbtBuffer })
   }
 }
 
@@ -88,6 +87,8 @@ export function applySignatures(psbt, signatures, inputsToSign) {
             ],
           })
         }
+
+        psbt.finalizeInput(inputIndex)
       } else {
         throw new Error(
           `expected to sign for inputIndex ${inputIndex} but no signature was produced`