@exodus/bitcoin-api 2.7.0 → 2.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "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": "9c993eed3a3bcfc1c49d86377fdc5c7cb731d632"
 }

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 }) => {

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
+)