@bsv/wallet-toolbox 1.2.28 → 1.2.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.2.28",
+  "version": "1.2.31",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",
@@ -30,9 +30,9 @@
   },
   "homepage": "https://github.com/bitcoin-sv/wallet-toolbox#readme",
   "dependencies": {
-    "@bsv/auth-express-middleware": "^1.0.13",
-    "@bsv/payment-express-middleware": "^1.0.3",
-    "@bsv/sdk": "^1.4.9",
+    "@bsv/auth-express-middleware": "^1.1.2",
+    "@bsv/payment-express-middleware": "^1.0.4",
+    "@bsv/sdk": "^1.4.15",
     "express": "^4.21.2",
     "knex": "^3.1.0",
     "mysql2": "^3.12.0",

package/src/WalletPermissionsManager.ts

@@ -1,4 +1,4 @@
-import { WalletInterface, Utils, PushDrop, LockingScript, Transaction, WalletProtocol } from '@bsv/sdk'
+import { WalletInterface, Utils, PushDrop, LockingScript, Transaction, WalletProtocol, Base64String } from '@bsv/sdk'
 import { validateCreateActionArgs } from './sdk'
 
 ////// TODO: ADD SUPPORT FOR ADMIN COUNTERPARTIES BASED ON WALLET STORAGE
@@ -939,7 +939,7 @@ export class WalletPermissionsManager implements WalletInterface {
    * @param plaintext The metadata to encrypt if configured to do so
    * @returns The encrypted metadata, or the original value if encryption was disabled.
    */
-  private async maybeEncryptMetadata(plaintext: string): Promise<string> {
+  private async maybeEncryptMetadata(plaintext: string): Promise<Base64String> {
     if (!this.config.encryptWalletMetadata) {
       return plaintext
     }
@@ -951,7 +951,7 @@ export class WalletPermissionsManager implements WalletInterface {
       },
       this.adminOriginator
     )
-    return Utils.toUTF8(ciphertext) // Still a string, but scrambled.
+    return Utils.toBase64(ciphertext)
   }
 
   /**
@@ -959,11 +959,11 @@ export class WalletPermissionsManager implements WalletInterface {
    * @param ciphertext The metadata to attempt decryption for.
    * @returns The decrypted metadata. If decryption fails, returns the original value instead.
    */
-  private async maybeDecryptMetadata(ciphertext: string): Promise<string> {
+  private async maybeDecryptMetadata(ciphertext: Base64String): Promise<string> {
     try {
       const { plaintext } = await this.underlying.decrypt(
         {
-          ciphertext: Utils.toArray(ciphertext, 'utf8'),
+          ciphertext: Utils.toArray(ciphertext, 'base64'),
           protocolID: WalletPermissionsManager.METADATA_ENCRYPTION_PROTOCOL,
           keyID: '1'
         },

package/src/__tests/WalletPermissionsManager.encryption.test.ts

@@ -1,6 +1,7 @@
 import { mockUnderlyingWallet, MockedBSV_SDK } from './WalletPermissionsManager.fixtures'
 import { WalletPermissionsManager } from '../WalletPermissionsManager'
 import { jest } from '@jest/globals'
+import { Utils } from '@bsv/sdk'
 
 jest.mock('@bsv/sdk', () => MockedBSV_SDK)
 
@@ -62,7 +63,7 @@ describe('WalletPermissionsManager - Metadata Encryption & Decryption', () => {
         plaintext: [72, 105] // 'Hi'
       })
 
-      const ciphertext = 'random-string-representing-ciphertext'
+      const ciphertext = Utils.toBase64(Utils.toArray('random-string-representing-ciphertext'))
       const result = await manager['maybeDecryptMetadata'](ciphertext)
 
       // We expect underlying.decrypt() to have been called
@@ -153,19 +154,19 @@ describe('WalletPermissionsManager - Metadata Encryption & Decryption', () => {
         totalActions: 1,
         actions: [
           {
-            description: 'fake-encrypted-string-for-description',
+            description: Utils.toBase64(Utils.toArray('fake-encrypted-string-for-description')),
             inputs: [
               {
                 outpoint: 'txid1.0',
-                inputDescription: 'fake-encrypted-string-for-inputDesc'
+                inputDescription: Utils.toBase64(Utils.toArray('fake-encrypted-string-for-inputDesc'))
               }
             ],
             outputs: [
               {
                 lockingScript: 'OP_RETURN 1234',
                 satoshis: 500,
-                outputDescription: 'fake-encrypted-string-for-outputDesc',
-                customInstructions: 'fake-encrypted-string-for-customInstr'
+                outputDescription: Utils.toBase64(Utils.toArray('fake-encrypted-string-for-outputDesc')),
+                customInstructions: Utils.toBase64(Utils.toArray('fake-encrypted-string-for-customInstr'))
               }
             ]
           }
@@ -268,7 +269,7 @@ describe('WalletPermissionsManager - Metadata Encryption & Decryption', () => {
       // To simulate, we make decryption pass through.
       underlying.decrypt.mockImplementation(x => x)
       const listResult = await (manager as any).listActions({}, 'nonadmin.com')
-      expect(underlying.decrypt).toHaveBeenCalledTimes(4)
+      expect(underlying.decrypt).toHaveBeenCalledTimes(3)
 
       // Confirm the returned data is the same as originally provided (plaintext)
       const [first] = listResult.actions
@@ -297,7 +298,7 @@ describe('WalletPermissionsManager - Metadata Encryption & Decryption', () => {
             satoshis: 999,
             lockingScript: 'OP_RETURN something',
             basket: 'some-basket',
-            customInstructions: 'fake-encrypted-instructions-string'
+            customInstructions: Utils.toBase64(Utils.toArray('fake-encrypted-instructions-string'))
           }
         ]
       })

package/src/__tests/WalletPermissionsManager.fixtures.ts

@@ -153,6 +153,12 @@ export const MockUtils = {
   toUTF8: (arr: number[]) => {
     // Converts an array of numbers to a UTF-8 string.
     return String.fromCharCode(...arr)
+  },
+
+  toBase64: (arr: number[]) => {
+    // Converts an array of numbers to a Base64 string.
+    const binaryStr = String.fromCharCode(...arr)
+    return btoa(binaryStr)
   }
 }
 

package/src/sdk/WalletServices.interfaces.ts

@@ -97,6 +97,18 @@ export interface WalletServices {
    */
   hashOutputScript(script: string): string
 
+  /**
+   * For an array of one or more txids, returns for each wether it is a 'known', 'mined', or 'unknown' transaction.
+   *
+   * Primarily useful for determining if a recently broadcast transaction is known to the processing network.
+   *
+   * Also returns the current depth from chain tip if 'mined'.
+   *
+   * @param txids
+   * @param useNext
+   */
+  getStatusForTxids(txids: string[], useNext?: boolean): Promise<sdk.GetStatusForTxidsResult>
+
   /**
    * Attempts to determine the UTXO status of a transaction output.
    *
@@ -166,6 +178,33 @@ export interface WalletServicesOptions {
   arcConfig: ArcConfig
 }
 
+export interface GetStatusForTxidsResult {
+  /**
+   * The name of the service returning these results.
+   */
+  name: string
+  status: 'success' | 'error'
+  /**
+   * The first exception error that occurred during processing, if any.
+   */
+  error?: sdk.WalletError
+  results: sdk.StatusForTxidResult[]
+}
+
+export interface StatusForTxidResult {
+  txid: string
+  /**
+   * roughly depth of block containing txid from chain tip.
+   */
+  depth: number | undefined
+  /**
+   * 'mined' if depth > 0
+   * 'known' if depth === 0
+   * 'unknown' if depth === undefined, txid may be old an purged or never processed.
+   */
+  status: 'mined' | 'known' | 'unknown'
+}
+
 /**
  * Properties on result returned from `WalletServices` function `getRawTx`.
  */
@@ -416,6 +455,8 @@ export type GetUtxoStatusService = (
   outpoint?: string
 ) => Promise<GetUtxoStatusResult>
 
+export type GetStatusForTxidsService = (txids: string[]) => Promise<sdk.GetStatusForTxidsResult>
+
 export type GetScriptHashHistoryService = (hash: string) => Promise<GetScriptHashHistoryResult>
 
 export type GetMerklePathService = (txid: string, services: WalletServices) => Promise<GetMerklePathResult>

package/src/sdk/WalletStorage.interfaces.ts

@@ -264,10 +264,6 @@ export interface ReviewActionResult {
    * Merged beef of competingTxs, valid when status is 'doubleSpend'.
    */
   competingBeef?: number[]
-  /**
-   * Transaction input indices that have been spent, valid when status is 'doubleSpend'.
-   */
-  spentInputs?: { vin: number; scriptHash: string }[]
 }
 
 export interface StorageProcessActionResults {

package/src/services/Services.ts

@@ -22,6 +22,7 @@ export class Services implements sdk.WalletServices {
   getRawTxServices: ServiceCollection<sdk.GetRawTxService>
   postBeefServices: ServiceCollection<sdk.PostBeefService>
   getUtxoStatusServices: ServiceCollection<sdk.GetUtxoStatusService>
+  getStatusForTxidsServices: ServiceCollection<sdk.GetStatusForTxidsService>
   getScriptHashHistoryServices: ServiceCollection<sdk.GetScriptHashHistoryService>
   updateFiatExchangeRateServices: ServiceCollection<sdk.UpdateFiatExchangeRateService>
 
@@ -57,6 +58,10 @@ export class Services implements sdk.WalletServices {
     this.getUtxoStatusServices = new ServiceCollection<sdk.GetUtxoStatusService>()
       .add({ name: 'WhatsOnChain', service: this.whatsonchain.getUtxoStatus.bind(this.whatsonchain) })
 
+    //prettier-ignore
+    this.getStatusForTxidsServices = new ServiceCollection<sdk.GetStatusForTxidsService>()
+      .add({ name: 'WhatsOnChain', service: this.whatsonchain.getStatusForTxids.bind(this.whatsonchain) })
+
     //prettier-ignore
     this.getScriptHashHistoryServices = new ServiceCollection<sdk.GetScriptHashHistoryService>()
       .add({ name: 'WhatsOnChain', service: this.whatsonchain.getScriptHashHistory.bind(this.whatsonchain) })
@@ -105,6 +110,30 @@ export class Services implements sdk.WalletServices {
     return this.getUtxoStatusServices.count
   }
 
+  async getStatusForTxids(txids: string[], useNext?: boolean): Promise<sdk.GetStatusForTxidsResult> {
+    const services = this.getStatusForTxidsServices
+    if (useNext) services.next()
+
+    let r0: sdk.GetStatusForTxidsResult = {
+      name: '<noservices>',
+      status: 'error',
+      error: new sdk.WERR_INTERNAL('No services available.'),
+      results: []
+    }
+
+    for (let tries = 0; tries < services.count; tries++) {
+      const service = services.service
+      const r = await service(txids)
+      if (r.status === 'success') {
+        r0 = r
+        break
+      }
+      services.next()
+    }
+
+    return r0
+  }
+
   /**
    * @param script Output script to be hashed for `getUtxoStatus` default `outputFormat`
    * @returns script hash in 'hashLE' format, which is the default.

package/src/services/providers/WhatsOnChain.ts

@@ -15,6 +15,68 @@ export class WhatsOnChain extends SdkWhatsOnChain {
     this.services = services || new Services(chain)
   }
 
+  /**
+   * POST
+   * https://api.whatsonchain.com/v1/bsv/main/txs/status
+   * Content-Type: application/json
+   * data: "{\"txids\":[\"6815f8014db74eab8b7f75925c68929597f1d97efa970109d990824c25e5e62b\"]}"
+   *
+   * result for a mined txid:
+   *     [{
+   *        "txid":"294cd1ebd5689fdee03509f92c32184c0f52f037d4046af250229b97e0c8f1aa",
+   *        "blockhash":"000000000000000004b5ce6670f2ff27354a1e87d0a01bf61f3307f4ccd358b5",
+   *        "blockheight":612251,
+   *        "blocktime":1575841517,
+   *        "confirmations":278272
+   *      }]
+   *
+   * result for a valid recent txid:
+   *     [{"txid":"6815f8014db74eab8b7f75925c68929597f1d97efa970109d990824c25e5e62b"}]
+   *
+   * result for an unknown txid:
+   *     [{"txid":"6815f8014db74eab8b7f75925c68929597f1d97efa970109d990824c25e5e62c","error":"unknown"}]
+   */
+  async getStatusForTxids(txids: string[]): Promise<sdk.GetStatusForTxidsResult> {
+    const r: sdk.GetStatusForTxidsResult = {
+      name: 'WoC',
+      status: 'error',
+      error: undefined,
+      results: []
+    }
+
+    const requestOptions = {
+      method: 'POST',
+      headers: this.getHttpHeaders(),
+      data: { txids }
+    }
+
+    const url = `${this.URL}/txs/status`
+
+    try {
+      const response = await this.httpClient.request<WhatsOnChainTxsStatusData[]>(url, requestOptions)
+
+      if (!response.data || !response.ok || response.status !== 200)
+        throw new sdk.WERR_INVALID_OPERATION(`Unable to get status for txids at this timei.`)
+
+      const data = response.data
+      for (const txid of txids) {
+        const d = data.find(d => d.txid === txid)
+        if (!d || d.error === 'unknown') r.results.push({ txid, status: 'unknown', depth: undefined })
+        else if (d.error !== undefined) {
+          console.log(`WhatsOnChain getStatusForTxids unexpected error ${d.error} ${txid}`)
+          r.results.push({ txid, status: 'unknown', depth: undefined })
+        } else if (d.confirmations === undefined) r.results.push({ txid, status: 'known', depth: 0 })
+        else r.results.push({ txid, status: 'mined', depth: d.confirmations })
+      }
+      r.status = 'success'
+    } catch (eu: unknown) {
+      const e = sdk.WalletError.fromUnknown(eu)
+      r.error = e
+    }
+
+    return r
+  }
+
   /**
    * 2025-02-16 throwing internal server error 500.
    * @param txid
@@ -617,3 +679,15 @@ interface WhatsOnChainScriptHashHistoryData {
   error?: string
   nextPageToken?: string
 }
+
+interface WhatsOnChainTxsStatusData {
+  txid: string
+  blockhash?: string
+  blockheight?: number
+  blocktime?: number
+  confirmations?: number
+  /**
+   * 'unknown' if txid isn't known
+   */
+  error?: string
+}

package/src/storage/methods/attemptToPostReqsToNetwork.ts

@@ -1,7 +1,7 @@
 import { Beef, Transaction } from '@bsv/sdk'
 import { StorageProvider } from '../StorageProvider'
 import { EntityProvenTxReq } from '../schema/entities'
-import { sdk } from '../../index.client'
+import { sdk, wait } from '../../index.client'
 import { ReqHistoryNote } from '../../sdk'
 
 /**
@@ -136,8 +136,7 @@ function aggregatePostBeefResultsByTxid(
       doubleSpendCount: 0,
       statusErrorCount: 0,
       serviceErrorCount: 0,
-      competingTxs: [],
-      spentInputs: []
+      competingTxs: []
     }
     r[txid] = ar
     for (const pbr of pbrs) {
@@ -263,7 +262,6 @@ async function updateReqsFromAggregateResults(
     const details = r.details.find(d => d.txid === txid)!
     details.status = ar.status
     details.competingTxs = ar.competingTxs
-    details.spentInputs = ar.spentInputs
   }
 }
 
@@ -286,43 +284,42 @@ async function confirmDoubleSpend(
 ): Promise<void> {
   const req = ar.vreq.req
   const note: ReqHistoryNote = { when: new Date().toISOString(), what: 'confirmDoubleSpend' }
-  const tx = Transaction.fromBinary(req.rawTx)
-  ar.spentInputs = []
-  let vin = -1
-  for (const input of tx.inputs) {
-    vin++
-    const sourceTx = beef.findTxid(input.sourceTXID!)?.tx
-    if (!sourceTx) throw new sdk.WERR_INTERNAL(`beef lacks tx for ${input.sourceTXID}`)
-    const lockingScript = sourceTx.outputs[input.sourceOutputIndex].lockingScript.toHex()
-    const hash = services.hashOutputScript(lockingScript)
-    const usr = await services.getUtxoStatus(hash, undefined, `${input.sourceTXID}.${input.sourceOutputIndex}`)
-    if (usr.isUtxo === false) {
-      ar.spentInputs.push({
-        vin,
-        scriptHash: hash,
-        sourceTXID: input.sourceTXID!,
-        sourceIndex: input.sourceOutputIndex
-      })
+
+  let known = false
+
+  for (let retry = 0; retry < 3; retry++) {
+    const gsr = await services.getStatusForTxids([req.txid])
+    note[`getStatus${retry}`] = `${gsr.status}${gsr.error ? `${gsr.error.code}` : ''},${gsr.results[0]?.status}`
+    if (gsr.status === 'success' && gsr.results[0].status !== 'unknown') {
+      known = true
+      break
+    } else {
+      await wait(1000)
     }
   }
-  note.vins = ar.spentInputs.map(si => si.vin.toString()).join(',')
-  if (ar.spentInputs.length === 0) {
-    // Possibly NOT a double spend...
-    if (ar.successCount > 0) ar.status = 'success'
-    else ar.status = 'serviceError'
+
+  if (known) {
+    // doubleSpend -> success
+    ar.status = 'success'
     note.newStatus = ar.status
   } else {
-    // Confirmed double spend.
+    // Confirmed double spend, get txids of possible competing transactions.
+    const tx = Transaction.fromBinary(req.rawTx)
     const competingTxids = new Set(ar.competingTxs)
-    for (const si of ar.spentInputs) {
-      const shhrs = await services.getScriptHashHistory(si.scriptHash)
+    for (const input of tx.inputs) {
+      const sourceTx = beef.findTxid(input.sourceTXID!)?.tx
+      if (!sourceTx) throw new sdk.WERR_INTERNAL(`beef lacks tx for ${input.sourceTXID}`)
+      const lockingScript = sourceTx.outputs[input.sourceOutputIndex].lockingScript.toHex()
+      const hash = services.hashOutputScript(lockingScript)
+      const shhrs = await services.getScriptHashHistory(hash)
       if (shhrs.status === 'success') {
         for (const h of shhrs.history) {
-          if (h.txid !== si.sourceTXID) competingTxids.add(h.txid)
+          // Neither the source of the input nor the current transaction are competition.
+          if (h.txid !== input.sourceTXID && h.txid !== ar.txid) competingTxids.add(h.txid)
         }
       }
     }
-    ar.competingTxs = [...competingTxids].slice(0, 24) // keep at most 24, if they were sorted by time, keep oldest
+    ar.competingTxs = [...competingTxids].slice(-1, 24) // keep at most 24, if they were sorted by time, keep newest
     note.competingTxs = ar.competingTxs.join(',')
   }
   req.addHistoryNote(note)
@@ -343,10 +340,6 @@ interface AggregatePostBeefTxResult {
    * Any competing double spend txids reported for this txid
    */
   competingTxs: string[]
-  /**
-   * Input indices that have been spent, valid when status is 'doubleSpend'
-   */
-  spentInputs: { vin: number; scriptHash: string; sourceTXID: string; sourceIndex: number }[]
 }
 
 /**
@@ -378,10 +371,6 @@ export interface PostReqsToNetworkDetails {
    * Any competing double spend txids reported for this txid
    */
   competingTxs?: string[]
-  /**
-   * Input indices that have been spent, valid when status is 'doubleSpend'
-   */
-  spentInputs?: { vin: number; scriptHash: string }[]
 }
 
 export interface PostReqsToNetworkResult {

package/src/storage/methods/processAction.ts

@@ -191,7 +191,7 @@ async function shareReqsWithWorld(
     const txid = ar.txid
     const d = prtn.details.find(d => d.txid === txid)
     if (!d) throw new sdk.WERR_INTERNAL(`missing details for ${txid}`)
-    ar.ndr = { txid: d.txid, status: 'success', competingTxs: d.competingTxs, spentInputs: d.spentInputs }
+    ar.ndr = { txid: d.txid, status: 'success', competingTxs: d.competingTxs }
     switch (d.status) {
       case 'success':
         // processing network has accepted this transaction

package/src/storage/schema/entities/__tests/ProvenTxTests.test.ts

@@ -103,6 +103,12 @@ describe('ProvenTx class method tests', () => {
       getFiatExchangeRate: async () => 1,
       postBeef: async () => [],
 
+      getStatusForTxids: async () => ({
+        name: 'mock-service',
+        status: 'success',
+        results: []
+      }),
+
       getUtxoStatus: async () => ({
         name: 'mock-service',
         status: 'success',

package/test/Wallet/local/localWallet2.man.test.ts

@@ -77,7 +77,6 @@ describe('localWallet2 tests', () => {
       const rar = e.reviewActionResults![0]!
       expect(rar.status).toBe('doubleSpend')
       expect(rar.competingTxs?.length).toBe(1)
-      expect(rar.spentInputs?.length).toBe(1)
     }
     await setup.wallet.destroy()
   })

package/test/services/Services.test.ts

@@ -233,4 +233,25 @@ describe('Wallet services tests', () => {
       }
     }
   })
+
+  test('7 getStatusForTxids', async () => {
+    for (const { chain, services } of ctxs) {
+      {
+        const txids = ['32c691a077b0ce46051aa7a45fa3b131c71ff85950264575a32171086b02ad98']
+        const r = await services.getStatusForTxids(txids)
+        expect(r.results.length).toBe(1)
+        expect(r.results[0].txid).toBe(txids[0])
+        expect(r.name).toBeTruthy()
+        expect(r.status).toBe('success')
+        expect(r.error).toBe(undefined)
+        if (chain === 'main') {
+          expect(r.results[0].status).toBe('mined')
+          expect(r.results[0].depth).toBeGreaterThan(146)
+        } else {
+          expect(r.results[0].status).toBe('unknown')
+          expect(r.results[0].depth).toBe(undefined)
+        }
+      }
+    }
+  })
 })