@exodus/bitcoin-api 2.6.6 → 2.6.8-hiro.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.6.6",
+  "version": "2.6.8-hiro.0",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -42,6 +42,5 @@
     "@scure/base": "^1.1.3",
     "@scure/btc-signer": "^1.1.0",
     "jest-when": "^3.5.1"
-  },
-  "gitHead": "b2ed2bffe712facdd412df1a0ebc6a8ac92c4d1c"
+  }
 }

package/src/ordinals-utils.js

@@ -1,6 +1,6 @@
 import assert from 'minimalistic-assert'
 
-export function getOrdinalAddress({
+export async function getOrdinalAddress({
   asset,
   assetClientInterface,
   walletAccount,
@@ -12,10 +12,22 @@ export function getOrdinalAddress({
   if (ordinalChainIndex === undefined) {
     return undefined
   }
+
+  const purposes = await assetClientInterface.getSupportedPurposes({
+    assetName: asset.name,
+    walletAccount,
+  })
+
+  const purpose = 86
+
+  if (!purposes.includes(purpose)) {
+    return undefined
+  }
+
   return assetClientInterface.getAddress({
     assetName: asset.name,
     walletAccount,
-    purpose: 86,
+    purpose,
     chainIndex: ordinalChainIndex,
     addressIndex: 0,
   })

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

@@ -67,7 +67,6 @@ export class BitcoinMonitorScanner {
 
     const storedUtxos = getUtxos({ asset, accountState })
     const storedOrdinalUtxos = getOrdinalsUtxos({ asset, accountState })
-    const ordinalAddress = await this.getOrdinalAddress({ walletAccount })
 
     const currentStoredUtxos = storedUtxos.union(storedOrdinalUtxos)
 
@@ -90,7 +89,9 @@ export class BitcoinMonitorScanner {
       : (txs) =>
           txs.filter((tx) => {
             const txItem = currentTxs.get(tx.txid)
-            return txItem && txItem.confirmed
+            const confirmed = txItem && txItem.confirmed
+            const inscriptionsIndexed = txItem?.data?.inscriptionsIndexed
+            return confirmed && (!this.#ordinalsEnabled || inscriptionsIndexed)
           }).length >= txs.length
 
     const unusedAddressIndexes = await assetClientInterface.getUnusedAddressIndexes({
@@ -344,6 +345,15 @@ export class BitcoinMonitorScanner {
         currencies: { [assetName]: currency },
       }
 
+      if (this.#ordinalsEnabled) {
+        txLogItem.data = {
+          ...txLogItem.data,
+          inscriptionsIndexed: txItem.inscriptionsIndexed,
+          sentInscriptions: [],
+          receivedInscriptions: [],
+        }
+      }
+
       let from = []
 
       // if txItem.vin has an address that matches ours, means we've spent this tx
@@ -361,8 +371,13 @@ export class BitcoinMonitorScanner {
         txLogItem.coinAmount = txLogItem.coinAmount.sub(currency.defaultUnit(vin.value))
         isSent = true
         txLogItem.data.sent = []
-        if (ordinalAddress && address.toString() === ordinalAddress.toString()) {
-          txLogItem.data.isInscriptionSent = true
+        if (this.#ordinalsEnabled && vin.inscriptions) {
+          txLogItem.data.sentInscriptions.push(
+            ...vin.inscriptions.map((i) => ({
+              ...i,
+              value: currency.defaultUnit(vin.value).toBaseNumber(),
+            }))
+          )
         }
 
         // this is only used to exclude the utxos in the reducer which is why we don't care about the other fields
@@ -432,8 +447,13 @@ export class BitcoinMonitorScanner {
           txLogItem.data.changeAddress = address
         }
 
-        if (ordinalAddress && address.toString() === ordinalAddress.toString()) {
-          txLogItem.data.isInscriptionReceived = true
+        if (this.#ordinalsEnabled && vout.inscriptions) {
+          txLogItem.data.receivedInscriptions.push(
+            ...vout.inscriptions.map((i) => ({
+              ...i,
+              value: currency.defaultUnit(vout.value).toBaseNumber(),
+            }))
+          )
         }
 
         // it was sent to us...
@@ -450,6 +470,11 @@ export class BitcoinMonitorScanner {
           rbfEnabled: txItem.rbf,
         }
 
+        if (this.#ordinalsEnabled) {
+          output.inscriptionsIndexed = txItem.inscriptionsIndexed
+          output.inscriptions = vout.inscriptions || []
+        }
+
         if (this.#shouldExcludeVoutUtxo({ asset, output, txItem, vout })) {
           return
         }
@@ -508,6 +533,16 @@ export class BitcoinMonitorScanner {
     // Keep new utxos when they intersect with the stored utxos.
     utxoCol = utxoCol.union(currentStoredUtxos).difference(utxosToRemoveCol)
 
+    if (this.#ordinalsEnabled) {
+      // copy ordinalsChange over
+      utxoCol.toArray().forEach((utxo) => {
+        const storedUtxo = currentStoredUtxos
+          .toArray()
+          .find((u2) => u2.txid === utxos.txid && u2.vout === utxo.vout)
+        utxo.ordinalsChange = storedUtxo?.ordinalsChange
+      })
+    }
+
     for (let tx of Object.values(unconfirmedTxsToCheck)) {
       existingTxs.push({ ...tx, dropped: true }) // TODO: this will decrease the chain index, it shouldn't be an issue considering the gap limit
       utxoCol = utxoCol.difference(utxoCol.getTxIdUtxos(tx.txId))
@@ -540,9 +575,11 @@ export class BitcoinMonitorScanner {
       return !isEqual(chain, originalChain.chain)
     })
 
+    const ordinalAddress = await this.getOrdinalAddress({ walletAccount })
     const utxosData = utxoCol
       ? partitionUtxos({
           allUtxos: utxoCol,
+          ordinalsEnabled: this.#ordinalsEnabled,
           ordinalAddress,
         })
       : {}
@@ -603,6 +640,7 @@ export class BitcoinMonitorScanner {
 
     const { utxos, ordinalsUtxos } = partitionUtxos({
       allUtxos: txConfirmedUtxos,
+      ordinalsEnabled: this.#ordinalsEnabled,
       ordinalAddress: await this.getOrdinalAddress({ walletAccount }),
     })
 

package/src/tx-send/index.js

@@ -14,7 +14,12 @@ import {
   createOutput as dogecoinCreateOutput,
 } from './dogecoin'
 import { findUnconfirmedSentRbfTxs } from '../tx-utils'
-import { getOrdinalsUtxos, getUsableUtxos, getUtxos } from '../utxos-utils'
+import {
+  getOrdinalsUtxos,
+  getTransferOrdinalsUtxos,
+  getUsableUtxos,
+  getUtxos,
+} from '../utxos-utils'
 
 import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
 
@@ -132,6 +137,7 @@ export const createAndBroadcastTXFactory = ({
   getFeeEstimator,
   getSizeAndChangeScript = getSizeAndChangeScriptFactory(), // for decred customizations
   allowUnconfirmedRbfEnabledUtxos,
+  ordinalsEnabled = false,
 }) => async (
   { asset: maybeToken, walletAccount, address, amount: tokenAmount, options },
   { assetClientInterface }
@@ -167,6 +173,11 @@ export const createAndBroadcastTXFactory = ({
 
   const inscriptionIds = nft?.tokenId ? [nft?.tokenId] : brc20 ? brc20.inscriptionIds : undefined
 
+  assert(
+    ordinalsEnabled || !inscriptionIds,
+    'inscriptions cannot be sent when ordinalsEnabled=false '
+  )
+
   const shuffle = (list) => {
     return inscriptionIds ? list : doShuffle(list) // don't shuffle when sending ordinal!!!!
   }
@@ -192,26 +203,9 @@ export const createAndBroadcastTXFactory = ({
 
   const currentOrdinalsUtxos = getOrdinalsUtxos({ accountState, asset })
   const transferOrdinalsUtxos = inscriptionIds
-    ? currentOrdinalsUtxos.filter((utxo) => inscriptionIds.includes(utxo.inscriptionId)) /// this could be bulk transfer if multiple inscription ids are provided
+    ? getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos: currentOrdinalsUtxos })
     : undefined
 
-  if (inscriptionIds) {
-    assert(
-      transferOrdinalsUtxos?.size === inscriptionIds.length,
-      `Expected ordinal utxos ${inscriptionIds.length}. Found: ${transferOrdinalsUtxos?.size || 0}`
-    )
-
-    // const unconfirmedOrdinalUtxos = transferOrdinalsUtxos
-    //   .toArray()
-    //   .filter((ordinalUtxo) => !(ordinalUtxo.confirmations > 0))
-    // assert(
-    //   !unconfirmedOrdinalUtxos.length,
-    //   `OrdinalUtxo with inscription ids ${unconfirmedOrdinalUtxos
-    //     .map((utxo) => utxo.inscriptionId)
-    //     .join(', ')} have not confirmed yet`
-    // )
-  }
-
   const insightClient = asset.baseAsset.insightClient
   const currency = asset.currency
   const feeData = await assetClientInterface.getFeeConfig({ assetName })
@@ -293,6 +287,7 @@ export const createAndBroadcastTXFactory = ({
       UtxoCollection.fromJSON(replaceTx.data.inputs, { currency: asset.currency })
     )
   }
+  const addressPathsMap = selectedUtxos.getAddressPathsMap()
 
   // transform UTXO object to raw
   const inputs = shuffle(createInputs(assetName, selectedUtxos.toArray(), rbfEnabled))
@@ -341,6 +336,9 @@ export const createAndBroadcastTXFactory = ({
       ourAddress.address ? ourAddress.address : ourAddress.toString(),
       change
     )
+    // Add the keypath of change address to support Trezor detect the change output.
+    // Output is change and does not need approval from user which shows the strange address that user never seen.
+    addressPathsMap[changeAddress] = ourAddress.meta.path
     outputs.push(changeOutput)
   } else {
     // If we don't have enough for a change output, then all remaining dust is just added to fee
@@ -360,7 +358,7 @@ export const createAndBroadcastTXFactory = ({
     },
     txMeta: {
       useCashAddress, // for trezor to show the receiver cash address
-      addressPathsMap: selectedUtxos.getAddressPathsMap(),
+      addressPathsMap,
       blockHeight,
     },
   }
@@ -441,6 +439,7 @@ export const createAndBroadcastTXFactory = ({
       value: change,
       confirmations: 0,
       rbfEnabled,
+      ordinalsChange: ordinalsEnabled ? true : undefined,
     }
     remainingUtxos = remainingUtxos.addUtxo(changeUtxo)
   }
@@ -518,7 +517,16 @@ export const createAndBroadcastTXFactory = ({
           inputs: selectedUtxos.toJSON(),
           replacedTxId: replaceTx ? replaceTx.txId : undefined,
           nftId: nft ? `${assetName}:${nft.tokenId}` : undefined, // it allows BE to load the nft info while the nft is in transit
-          inscriptionIds: inscriptionIds,
+          inscriptionsIndexed: ordinalsEnabled ? true : undefined,
+          sentInscriptions: inscriptionIds
+            ? inscriptionIds.map((inscriptionId) => {
+                return {
+                  inscriptionId,
+                  offset: 0,
+                  value: 0,
+                }
+              })
+            : undefined,
         },
       },
     ],

package/src/utxos-utils.js

@@ -5,6 +5,46 @@ import assert from 'minimalistic-assert'
 
 const MAX_ORDINAL_VALUE_POSTAGE = 10000
 
+export function getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos }) {
+  const transferOrdinalsUtxos = ordinalsUtxos.filter((utxo) =>
+    utxo.inscriptions?.some((i) => inscriptionIds.includes(i.inscriptionId))
+  )
+  const unsafeInscriptions = transferOrdinalsUtxos.toArray().flatMap(
+    (utxo) =>
+      utxo.inscriptions?.filter((i) => {
+        const validInscription = isValidInscription({
+          value: utxo.value.toBaseNumber(),
+          offset: i.offset,
+        })
+        return validInscription && !inscriptionIds.includes(i.inscriptionId)
+      }) || []
+  )
+  assert(
+    !unsafeInscriptions.length,
+    `The following inscriptions are unsafe ${unsafeInscriptions.map(
+      (i) => i.inscriptionId
+    )} when ${inscriptionIds} should be spent`
+  )
+
+  const transferInscriptionIds = transferOrdinalsUtxos
+    .toArray()
+    .flatMap((utxo) => utxo.inscriptions)
+    .filter(({ inscriptionId }) => inscriptionIds.includes(inscriptionId))
+
+  assert(
+    transferInscriptionIds.length === inscriptionIds.length,
+    `Expected inscriptions ${inscriptionIds.length}. Found: ${transferInscriptionIds.length}`
+  )
+  return transferOrdinalsUtxos
+}
+
+export function isValidInscription({ value, offset }) {
+  assert(typeof value === 'number', 'value must be a number')
+  assert(typeof offset === 'number', 'offset must be a number')
+  // value >= 0 in case offset, alternatively convert to string/ln
+  return (value >= 0 && value <= MAX_ORDINAL_VALUE_POSTAGE) || offset === 0
+}
+
 export function getUtxos({ accountState, asset }) {
   return (
     accountState?.utxos ||
@@ -23,31 +63,36 @@ export function getOrdinalsUtxos({ accountState, asset }) {
   )
 }
 
-function isOrdinalUtxo({ utxo, ordinalAddress }) {
-  if (utxo.inscriptionId) {
-    return true
-  }
-  if (!ordinalAddress) {
-    // exclude utxos splitting
+export function getValidInscriptions({ utxo }) {
+  return (utxo.inscriptions || []).filter((i) =>
+    isValidInscription({ value: utxo.value.toBaseNumber(), offset: i.offset })
+  )
+}
+
+function isOrdinalUtxo({ utxo, ordinalsEnabled }) {
+  if (!ordinalsEnabled) {
     return false
   }
 
-  if (utxo.address.toString() === ordinalAddress.toString()) {
-    return true // we assume any utxo to the ordinal address is a ordinal utxos just in case
+  if (utxo.ordinalsChange && !utxo.inscriptionsIndexed) {
+    return false // this allows users see and spend change balance after sending before hiro confirmation
   }
 
-  if (utxo.confirmations) {
-    return false
+  if (!utxo.inscriptionsIndexed) {
+    return true
   }
 
-  return utxo.value.toBaseNumber() <= MAX_ORDINAL_VALUE_POSTAGE // while unconfirmed, put  < 10000- sats in the ordinal utxos box just in case
+  const validInscriptions = getValidInscriptions({ utxo })
+  return validInscriptions.length > 0
 }
 
-export function partitionUtxos({ allUtxos, ordinalAddress }) {
+export function partitionUtxos({ allUtxos, ordinalsEnabled }) {
+  assert(allUtxos, 'allUtxos is required')
   assert(allUtxos, 'allUtxos is required')
+  // assert(ordinalAddress, 'ordinalAddress is required') // not used atm we may need to tune by ordinalAddress when unconfirmed or rubbish inscriptions
   return {
-    utxos: allUtxos.filter((utxo) => !isOrdinalUtxo({ utxo, ordinalAddress })),
-    ordinalsUtxos: allUtxos.filter((utxo) => isOrdinalUtxo({ utxo, ordinalAddress })),
+    utxos: allUtxos.filter((utxo) => !isOrdinalUtxo({ utxo, ordinalsEnabled })),
+    ordinalsUtxos: allUtxos.filter((utxo) => isOrdinalUtxo({ utxo, ordinalsEnabled })),
   }
 }