@bsv/wallet-toolbox 1.6.32 → 1.6.34

package/src/sdk/__test/WalletError.test.ts

@@ -0,0 +1,318 @@
+import { WalletError } from '../WalletError'
+import { WalletErrorFromJson } from '../WalletErrorFromJson'
+import {
+  WERR_NOT_IMPLEMENTED,
+  WERR_INTERNAL,
+  WERR_INVALID_PARAMETER,
+  WERR_REVIEW_ACTIONS,
+  WERR_INSUFFICIENT_FUNDS,
+  WERR_BROADCAST_UNAVAILABLE,
+  WERR_NETWORK_CHAIN,
+  WERR_INVALID_OPERATION,
+  WERR_MISSING_PARAMETER,
+  WERR_BAD_REQUEST,
+  WERR_UNAUTHORIZED,
+  WERR_NOT_ACTIVE,
+  WERR_INVALID_PUBLIC_KEY
+} from '../WERR_errors'
+
+// Mock WalletStorage interface
+const mockWalletStorage = {
+  createAction: jest.fn().mockImplementation((args: any) => {
+    throw new WERR_REVIEW_ACTIONS(
+      [{ txid: 'txid123', status: 'doubleSpend', competingTxs: ['txid456'], competingBeef: [0, 1, 2, 3] }],
+      [{ txid: 'txid123', status: 'failed' }],
+      'txid123',
+      [5, 6, 7, 8],
+      ['00'.repeat(32) + '.0']
+    )
+  })
+}
+
+describe('WalletError tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 - WERR_REVIEW_ACTIONS from createAction failure', async () => {
+    try {
+      await mockWalletStorage.createAction({ someArgs: 'test' })
+    } catch (err) {
+      const werr = WalletError.fromUnknown(err)
+      expect(werr.name).toBe('WERR_REVIEW_ACTIONS')
+      expect(werr.message).toBe('Undelayed createAction or signAction results require review.')
+
+      const json = WalletError.unknownToJson(werr)
+      const werr2 = WalletErrorFromJson(JSON.parse(json))
+      expect(werr2 instanceof WERR_REVIEW_ACTIONS).toBe(true)
+      const werr3 = werr2 as WERR_REVIEW_ACTIONS
+      expect(werr3.txid).toBe('txid123')
+      expect(werr3.reviewActionResults).toEqual([
+        { txid: 'txid123', status: 'doubleSpend', competingTxs: ['txid456'], competingBeef: [0, 1, 2, 3] }
+      ])
+      expect(werr3.sendWithResults).toEqual([{ txid: 'txid123', status: 'failed' }])
+      expect(werr3.noSendChange).toEqual(['00'.repeat(32) + '.0'])
+    }
+  })
+
+  test('1 - WERR_NOT_IMPLEMENTED basic test', async () => {
+    const werr = new WERR_NOT_IMPLEMENTED('Custom not implemented message')
+    expect(werr.name).toBe('WERR_NOT_IMPLEMENTED')
+    expect(werr.message).toBe('Custom not implemented message')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_NOT_IMPLEMENTED')
+    expect(werr2.message).toBe('Custom not implemented message')
+  })
+
+  test('2 - WERR_INTERNAL with default message', async () => {
+    const werr = new WERR_INTERNAL()
+    expect(werr.name).toBe('WERR_INTERNAL')
+    expect(werr.message).toBe('An internal error has occurred.')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_INTERNAL')
+    expect(werr2.message).toBe('An internal error has occurred.')
+  })
+
+  test('3 - WERR_INVALID_PARAMETER with custom parameter', async () => {
+    const werr = new WERR_INVALID_PARAMETER('amount', 'positive')
+    expect(werr.name).toBe('WERR_INVALID_PARAMETER')
+    expect(werr.message).toBe('The amount parameter must be positive')
+    expect(werr.parameter).toBe('amount')
+
+    const json = werr.toJson()
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_INVALID_PARAMETER')
+    expect(werr2.message).toBe('The amount parameter must be positive')
+    expect((werr2 as WERR_INVALID_PARAMETER).parameter).toBe('amount')
+  })
+
+  test('4 - WERR_INSUFFICIENT_FUNDS with numeric values', async () => {
+    const werr = new WERR_INSUFFICIENT_FUNDS(1000, 500)
+    expect(werr.name).toBe('WERR_INSUFFICIENT_FUNDS')
+    expect(werr.message).toContain('500 more satoshis are needed')
+    expect(werr.message).toContain('for a total of 1000')
+    expect(werr.totalSatoshisNeeded).toBe(1000)
+    expect(werr.moreSatoshisNeeded).toBe(500)
+
+    const json = werr.toJson()
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_INSUFFICIENT_FUNDS')
+    expect((werr2 as WERR_INSUFFICIENT_FUNDS).totalSatoshisNeeded).toBe(1000)
+    expect((werr2 as WERR_INSUFFICIENT_FUNDS).moreSatoshisNeeded).toBe(500)
+  })
+
+  test('5 - WERR_BROADCAST_UNAVAILABLE test', async () => {
+    const werr = new WERR_BROADCAST_UNAVAILABLE('Network issue')
+    expect(werr.name).toBe('WERR_BROADCAST_UNAVAILABLE')
+    expect(werr.message).toBe('Unable to broadcast transaction at this time.')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_BROADCAST_UNAVAILABLE')
+    expect(werr2.message).toBe('Unable to broadcast transaction at this time.')
+  })
+
+  test('6 - WERR_NETWORK_CHAIN test', async () => {
+    const werr = new WERR_NETWORK_CHAIN('Chain mismatch')
+    expect(werr.name).toBe('WERR_NETWORK_CHAIN')
+    expect(werr.message).toBe('Chain mismatch')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_NETWORK_CHAIN')
+    expect(werr2.message).toBe('Chain mismatch')
+  })
+
+  test('7 - WalletError.fromUnknown with plain Error', async () => {
+    const err = new Error('Test error')
+    const werr = WalletError.fromUnknown(err)
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('Test error')
+  })
+
+  test('8 - WalletError.unknownToJson with unknown object', async () => {
+    const obj = { custom: 'data', code: 404 }
+    const json = WalletError.unknownToJson(obj)
+    const werr = WalletErrorFromJson(JSON.parse(json))
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('[object Object]')
+  })
+
+  test('9 - WERR_INVALID_OPERATION basic test', async () => {
+    const werr = new WERR_INVALID_OPERATION('Custom invalid operation message')
+    expect(werr.name).toBe('WERR_INVALID_OPERATION')
+    expect(werr.message).toBe('Custom invalid operation message')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_INVALID_OPERATION')
+    expect(werr2.message).toBe('Custom invalid operation message')
+  })
+
+  test('10 - WERR_MISSING_PARAMETER with parameter', async () => {
+    const werr = new WERR_MISSING_PARAMETER('requiredField')
+    expect(werr.name).toBe('WERR_MISSING_PARAMETER')
+    expect(werr.message).toBe('The required requiredField parameter is missing.')
+    expect(werr.parameter).toBe('requiredField')
+
+    const json = werr.toJson()
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_MISSING_PARAMETER')
+    expect(werr2.message).toBe('The required requiredField parameter is missing.')
+    expect((werr2 as WERR_MISSING_PARAMETER).parameter).toBe('requiredField')
+  })
+
+  test('11 - WERR_BAD_REQUEST with custom message', async () => {
+    const werr = new WERR_BAD_REQUEST('Invalid request data')
+    expect(werr.name).toBe('WERR_BAD_REQUEST')
+    expect(werr.message).toBe('Invalid request data')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_BAD_REQUEST')
+    expect(werr2.message).toBe('Invalid request data')
+  })
+
+  test('12 - WERR_UNAUTHORIZED with default message', async () => {
+    const werr = new WERR_UNAUTHORIZED()
+    expect(werr.name).toBe('WERR_UNAUTHORIZED')
+    expect(werr.message).toBe('Access is denied due to an authorization error.')
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_UNAUTHORIZED')
+    expect(werr2.message).toBe('Access is denied due to an authorization error.')
+  })
+
+  test('13 - WERR_NOT_ACTIVE with default message', async () => {
+    const werr = new WERR_NOT_ACTIVE()
+    expect(werr.name).toBe('WERR_NOT_ACTIVE')
+    expect(werr.message).toBe(
+      `WalletStorageManager is not accessing user's active storage or there are conflicting active stores configured.`
+    )
+
+    const json = WalletError.unknownToJson(werr)
+    const werr2 = WalletErrorFromJson(JSON.parse(json))
+    expect(werr2.name).toBe('WERR_NOT_ACTIVE')
+    expect(werr2.message).toBe(
+      `WalletStorageManager is not accessing user's active storage or there are conflicting active stores configured.`
+    )
+  })
+
+  test('14 - WERR_INVALID_PUBLIC_KEY with key and mainnet network', async () => {
+    const werr = new WERR_INVALID_PUBLIC_KEY('invalidkey123', 'mainnet')
+    expect(werr.name).toBe('WERR_INVALID_PUBLIC_KEY')
+    expect(werr.message).toBe('The provided public key "invalidkey123" is invalid or malformed.')
+    expect((werr as WERR_INVALID_PUBLIC_KEY).key).toBe('invalidkey123')
+
+    const json = WalletError.unknownToJson(werr)
+    const parsedJson = JSON.parse(json)
+    const werr2 = WalletErrorFromJson(parsedJson)
+    expect(werr2.name).toBe('WERR_INVALID_PUBLIC_KEY')
+    expect(werr2.message).toBe('The provided public key "invalidkey123" is invalid or malformed.')
+    expect((werr2 as WERR_INVALID_PUBLIC_KEY).key).toBe('invalidkey123')
+  })
+
+  test('15 - WERR_INVALID_PUBLIC_KEY with key and testnet network', async () => {
+    const werr = new WERR_INVALID_PUBLIC_KEY('invalidkey123', 'testnet')
+    expect(werr.name).toBe('WERR_INVALID_PUBLIC_KEY')
+    expect(werr.message).toBe('The provided public key is invalid or malformed.')
+    expect((werr as WERR_INVALID_PUBLIC_KEY).key).toBe('invalidkey123')
+
+    const json = WalletError.unknownToJson(werr)
+    const parsedJson = JSON.parse(json)
+    const werr2 = WalletErrorFromJson(parsedJson)
+    expect(werr2.name).toBe('WERR_INVALID_PUBLIC_KEY')
+    expect(werr2.message).toBe('The provided public key is invalid or malformed.')
+    expect((werr2 as WERR_INVALID_PUBLIC_KEY).key).toBe('invalidkey123')
+  })
+
+  test('16 - WalletError basic constructor with details and stack', async () => {
+    const customStack = 'custom stack trace'
+    const werr = new WalletError('WERR_TEST', 'Test message', customStack, { detail1: 'value1', detail2: 'value2' })
+    expect(werr.isError).toBe(true)
+    expect(werr.name).toBe('WERR_TEST')
+    expect(werr.message).toBe('Test message')
+    expect(werr.stack).toBe(customStack)
+    expect(werr.details).toEqual({ detail1: 'value1', detail2: 'value2' })
+    expect(werr.code).toBe('WERR_TEST')
+    expect(werr.description).toBe('Test message')
+
+    werr.code = 'WERR_NEW_CODE'
+    werr.description = 'New description'
+    expect(werr.name).toBe('WERR_NEW_CODE')
+    expect(werr.message).toBe('New description')
+  })
+
+  test('17 - WalletError.fromUnknown with string', async () => {
+    const werr = WalletError.fromUnknown('String error message')
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('String error message')
+  })
+
+  test('18 - WalletError.fromUnknown with number', async () => {
+    const werr = WalletError.fromUnknown(404)
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('404')
+  })
+
+  test('19 - WalletError.fromUnknown with custom object', async () => {
+    const obj = { code: 'ERR_404', message: 'Not found', status: 404 }
+    const werr = WalletError.fromUnknown(obj)
+    expect(werr.name).toBe('ERR_404')
+    expect(werr.message).toBe('Not found')
+  })
+
+  test('20 - WalletError.fromUnknown with nested walletError', async () => {
+    const innerErr = new WERR_INTERNAL('Inner error')
+    const outerObj = { message: 'Outer error', walletError: innerErr }
+    const werr = WalletError.fromUnknown(outerObj)
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('Outer error')
+    expect((werr as any).walletError).toBeInstanceOf(WERR_INTERNAL)
+    expect((werr as any).walletError.message).toBe('Inner error')
+  })
+
+  test('21 - WalletError.fromUnknown with SQL details', async () => {
+    const err = { name: 'DBError', message: 'Query failed', sql: 'SELECT * FROM table', sqlMessage: 'Syntax error' }
+    const werr = WalletError.fromUnknown(err)
+    expect(werr.name).toBe('DBError')
+    expect(werr.message).toBe('Query failed')
+    expect(werr.details).toEqual({ sql: 'SELECT * FROM table', sqlMessage: 'Syntax error' })
+  })
+
+  test('22 - WalletError.unknownToJson with WalletError', async () => {
+    const werr = new WalletError('WERR_TEST', 'Test message')
+    const json = WalletError.unknownToJson(werr)
+    const parsed = JSON.parse(json)
+    expect(parsed.name).toBe('WERR_TEST')
+    expect(parsed.message).toBe('Test message')
+  })
+
+  test('23 - WalletError.unknownToJson with standard Error', async () => {
+    const err = new Error('Standard error')
+    const json = WalletError.unknownToJson(err)
+    const werr = WalletErrorFromJson(JSON.parse(json))
+    expect(werr.name).toBe('Error')
+    expect(werr.message).toBe('Standard error')
+  })
+
+  test('24 - WalletError.unknownToJson with string', async () => {
+    const json = WalletError.unknownToJson('String error')
+    const werr = WalletErrorFromJson(JSON.parse(json))
+    expect(werr.name).toBe('WERR_UNKNOWN')
+    expect(werr.message).toBe('String error')
+  })
+
+  test('25 - WalletError asStatus method', async () => {
+    const werr = new WalletError('WERR_TEST', 'Test description')
+    const status = werr.asStatus()
+    expect(status).toEqual({
+      status: 'error',
+      code: 'WERR_TEST',
+      description: 'Test description'
+    })
+  })
+})

package/src/sdk/index.ts

@@ -1,4 +1,5 @@
 export * from './WalletError'
+export * from './WalletErrorFromJson'
 export * from './WalletSigner.interfaces'
 export * from './WalletStorage.interfaces'
 export * from './WERR_errors'

package/src/services/__tests/verifyBeef.test.ts

@@ -1,4 +1,4 @@
-import { Beef } from '@bsv/sdk'
+import { Beef, Utils } from '@bsv/sdk'
 import { Services } from '../Services'
 import { _tu, logger } from '../../../test/utils/TestUtilsWalletStorage'
 import { verifyTruthy } from '../../utility/utilityHelpers'
@@ -38,4 +38,13 @@ describe('verifyBeef tests', () => {
       expect(ok).toBe(true)
     }
   })
+
+  test.skip('2_ review beef verify root', async () => {
+    const bhex =
+      '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'
+    const beef = Beef.fromString(bhex)
+    logger(beef.toLogString())
+    logger(Utils.toHex(beef.txs[1].rawTx!))
+    logger(beef.bumps[0].computeRoot('e47df21819ed320a78392e62e963ddd77143c3c52ad5255a07ff55ba507df71d'))
+  })
 })

package/src/services/chaintracker/ChaintracksChainTracker.ts

@@ -20,7 +20,7 @@ export class ChaintracksChainTracker implements ChainTracker {
     chain ||= 'main'
     this.chaintracks =
       chaintracks ??
-      new ChaintracksServiceClient(chain, `https://npm-registry.babbage.systems:808${chain === 'main' ? '4' : '3'}`)
+      new ChaintracksServiceClient(chain, `https://${chain}net-chaintracks.babbage.systems`)
     this.cache = {}
     this.options = options || {}
   }

package/src/services/chaintracker/chaintracks/util/ChaintracksFetch.ts

@@ -12,20 +12,27 @@ export class ChaintracksFetch implements ChaintracksFetchApi {
   constructor() {}
 
   async download(url: string): Promise<Uint8Array> {
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/octet-stream'
-      }
-    })
+    for (let retry = 0; ; retry++) {
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/octet-stream'
+        }
+      })
 
-    if (!response.ok) {
-      throw new Error(`Failed to download from ${url}: ${response.statusText}`)
-    }
+      if (!response.ok) {
+        if (response.statusText === 'Too Many Requests' && retry < 3) {
+          // WhatsOnChain rate limits requests, so backoff and retry
+          await wait(1000 * (retry + 1))
+          continue
+        }
+        throw new Error(`Failed to download from ${url}: ${response.statusText}`)
+      }
 
-    const data = await response.arrayBuffer()
+      const data = await response.arrayBuffer()
 
-    return new Uint8Array(data)
+      return new Uint8Array(data)
+    }
   }
 
   async fetchJson<R>(url: string): Promise<R> {

package/src/storage/StorageProvider.ts

@@ -230,7 +230,11 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
     for (const txid of txids) {
       const d: GetReqsAndBeefDetail = {
         txid,
+        // status: 'readyToSend' | 'alreadySent' | 'error' | 'unknown'
         status: 'unknown'
+        // req?: TableProvenTxReq
+        // proven?: TableProvenTx
+        // error?: string
       }
       r.details.push(d)
       try {

package/src/storage/WalletStorageManager.ts

@@ -1,6 +1,7 @@
 import {
   AbortActionArgs,
   AbortActionResult,
+  Beef,
   InternalizeActionArgs,
   InternalizeActionResult,
   ListActionsResult,
@@ -16,6 +17,7 @@ import {
   TableCertificateX,
   TableOutput,
   TableOutputBasket,
+  TableProvenTx,
   TableProvenTxReq,
   TableSettings,
   TableUser
@@ -519,6 +521,162 @@ export class WalletStorageManager implements sdk.WalletStorage {
     })
   }
 
+  /**
+   * For each proven_txs record currently sourcing its transaction merkle proof from the given deactivated header,
+   * attempt to reprove the transaction against the current chain,
+   * updating the proven_txs record if a new valid proof is found.
+   *
+   * @param deactivatedHash An orphaned header than may have served as a proof source for proven_txs records.
+   * @returns
+   */
+  async reproveHeader(deactivatedHash: string): Promise<sdk.ReproveHeaderResult> {
+    const r: sdk.ReproveHeaderResult = { log: '', updated: [], unchanged: [], unavailable: [] }
+    const services = this.getServices()
+    const chaintracker = await services.getChainTracker()
+
+    // Lookup all the proven_txs records matching the deactivated headers
+    let ptxs: TableProvenTx[] = []
+    await this.runAsStorageProvider(async sp => {
+      ptxs = await sp.findProvenTxs({ partial: { blockHash: deactivatedHash } })
+    })
+
+    r.log += `  block ${deactivatedHash} orphaned with ${ptxs.length} impacted transactions\n`
+
+    for (const ptx of ptxs) {
+      // Loop over proven_txs records matching the deactivated header
+      const rp = await this.reproveProven(ptx, true)
+
+      r.log += rp.log
+      if (rp.unavailable) r.unavailable.push(ptx)
+      if (rp.unchanged) r.unchanged.push(ptx)
+      if (rp.updated) r.updated.push({ was: ptx, update: rp.updated.update, logUpdate: rp.updated.logUpdate })
+    }
+
+    if (r.updated.length > 0) {
+      await this.runAsStorageProvider(async sp => {
+        for (const u of r.updated) {
+          await sp.updateProvenTx(u.was.provenTxId, u.update)
+          r.log += `    txid ${u.was.txid} proof data updated\n` + u.logUpdate
+        }
+      })
+    }
+
+    return r
+  }
+
+  /**
+   * Extends the Beef `verify` function to handle BUMPs that have become invalid due to a chain reorg.
+   *
+   * Any merkle root that fails `isValidRootForHeight` triggers a reprove attempt for that block header.
+   * This results in proven_txs with invalid proofs being updated with new valid proofs where possible.
+   * Finally, a new beef is generated and verified against the chaintracker.
+   *
+   * @param beef
+   * @param allowTxidOnly
+   * @returns
+   */
+  async verifyAndRepairBeef(beef: Beef, allowTxidOnly?: boolean): Promise<boolean> {
+    throw new sdk.WERR_NOT_IMPLEMENTED()
+
+    const services = this.getServices()
+    const chaintracker = await services.getChainTracker()
+    const verified = await beef.verify(chaintracker)
+
+    const r = beef.verifyValid(allowTxidOnly)
+    if (!r.valid) return false
+
+    const invalidRoots: Record<number, string> = {}
+    for (const height of Object.keys(r.roots)) {
+      const isValid = await chaintracker.isValidRootForHeight(r.roots[height], Number(height))
+      if (!isValid) {
+        invalidRoots[height] = r.roots[height]
+      }
+    }
+
+    if (Object.keys(invalidRoots).length === 0) {
+      // There are no invalid merkle roots and the beef is structurally valid,
+      // the beef is fully verified.
+      return true
+    }
+
+    for (const heightStr of Object.keys(invalidRoots)) {
+      const hash = invalidRoots[Number(heightStr)]
+      const r = await this.reproveHeader(hash)
+    }
+
+    // All invalid BUMPs must be removed from the beef
+    // and all txid's that were proven by those BUMPs need
+    // new beefs merged into the beef.
+    // In most cases, this will be a replacement BUMP,
+    // but it may also require a deeper proof.
+  }
+
+  /**
+   * Attempt to reprove the transaction against the current chain,
+   * If a new valid proof is found and noUpdate is not true,
+   * update the proven_txs record with new block and merkle proof data.
+   * If noUpdate is true, the update to be applied is available in the returned result.
+   *
+   * @param ptx proven_txs record to reprove
+   * @param noUpdate
+   * @returns
+   */
+  async reproveProven(ptx: TableProvenTx, noUpdate?: boolean): Promise<sdk.ReproveProvenResult> {
+    const r: sdk.ReproveProvenResult = { log: '', updated: undefined, unchanged: false, unavailable: false }
+    const services = this.getServices()
+    const chaintracker = await services.getChainTracker()
+
+    const mpr = await services.getMerklePath(ptx.txid)
+    if (mpr.merklePath && mpr.header) {
+      const mp = mpr.merklePath
+      const h = mpr.header
+      const leaf = mp.path[0].find(leaf => leaf.txid === true && leaf.hash === ptx.txid)
+      if (leaf) {
+        const update: Partial<TableProvenTx> = {
+          height: mp.blockHeight,
+          index: leaf.offset,
+          merklePath: mp.toBinary(),
+          merkleRoot: h.merkleRoot,
+          blockHash: h.hash
+        }
+        if (update.blockHash === ptx.blockHash) {
+          r.log += `    txid ${ptx.txid} merkle path update still based on deactivated header ${ptx.blockHash}\n`
+          r.unchanged = true
+        } else {
+          // Verify the new proof's validity.
+          const merkleRoot = mp.computeRoot(ptx.txid)
+          const isValid = await chaintracker.isValidRootForHeight(merkleRoot, update.height!)
+          const logUpdate = `      height ${ptx.height} ${ptx.height === update.height ? 'unchanged' : `-> ${update.height}`}\n`
+          r.log += `      blockHash ${ptx.blockHash} -> ${update.blockHash}\n`
+          r.log += `      merkleRoot ${ptx.merkleRoot} -> ${update.merkleRoot}\n`
+          r.log += `      index ${ptx.index} -> ${update.index}\n`
+          if (isValid) {
+            r.updated = { update, logUpdate }
+          } else {
+            r.log +=
+              `    txid ${ptx.txid} chaintracker fails to confirm updated merkle path update invalid\n` + logUpdate
+            r.unavailable = true
+          }
+        }
+      } else {
+        r.log += `    txid ${ptx.txid} merkle path update doesn't include txid\n`
+        r.unavailable = true
+      }
+    } else {
+      r.log += `    txid ${ptx.txid} merkle path update unavailable\n`
+      r.unavailable = true
+    }
+
+    if (r.updated && !noUpdate) {
+      await this.runAsStorageProvider(async sp => {
+        await sp.updateProvenTx(ptx.provenTxId, r.updated!.update)
+        r.log += `    txid ${ptx.txid} proof data updated\n` + r.updated!.logUpdate
+      })
+    }
+
+    return r
+  }
+
   async syncFromReader(
     identityKey: string,
     reader: sdk.WalletStorageSyncReader,

package/src/storage/__test/getBeefForTransaction.test.ts

@@ -1,5 +1,4 @@
-import { Beef, ListActionsResult, ListOutputsResult } from '@bsv/sdk'
-import { WalletError } from '../../sdk/WalletError'
+import { Beef, ListActionsResult, ListOutputsResult, Utils } from '@bsv/sdk'
 import { StorageAdminStats, StorageProvider } from '../StorageProvider'
 import { Chain } from '../../sdk/types'
 import { Services } from '../../services/Services'
@@ -60,6 +59,16 @@ describe('getBeefForTransaction tests', () => {
       expect(beef.bumps.length > 0)
     }
   })
+
+  test.skip('1 obtain atomic beef hex for txid', async () => {
+    const ps = new ProtoStorage('main')
+    const txid = '4cefbe79926d6ef2cc727d8faccac186d9bb141f170411dd75bc6329f428f5a4'
+    const beef = await ps.getBeefForTxid(txid)
+    expect(beef.bumps.length > 0)
+    console.log(beef.toLogString())
+    const hex = Utils.toHex(beef.toBinaryAtomic(txid))
+    console.log(hex)
+  })
 })
 
 class ProtoStorage extends StorageProvider {

package/src/storage/methods/internalizeAction.ts

@@ -18,7 +18,7 @@ import { randomBytesBase64, verifyId, verifyOne, verifyOneOrNone } from '../../u
 import { TransactionStatus } from '../../sdk/types'
 import { EntityProvenTxReq } from '../schema/entities/EntityProvenTxReq'
 import { blockHash } from '../../services/chaintracker/chaintracks/util/blockHeaderUtilities'
-import { TableProvenTx } from '../index.client'
+import { TableProvenTx } from '../schema/tables/TableProvenTx'
 
 /**
  * Internalize Action allows a wallet to take ownership of outputs in a pre-existing transaction.

package/src/storage/remoting/StorageClient.ts

@@ -44,6 +44,8 @@ import { TableOutputBasket } from '../schema/tables/TableOutputBasket'
 import { TableOutput } from '../schema/tables/TableOutput'
 import { TableProvenTxReq } from '../schema/tables/TableProvenTxReq'
 import { EntityTimeStamp } from '../../sdk/types'
+import { WalletError } from '../../sdk/WalletError'
+import { WalletErrorFromJson } from '../../sdk/WalletErrorFromJson'
 
 /**
  * `StorageClient` implements the `WalletStorageProvider` interface which allows it to
@@ -118,12 +120,8 @@ export class StorageClient implements WalletStorageProvider {
 
       const json = await response.json()
       if (json.error) {
-        const { code, message, data } = json.error
-        const err = new Error(`RPC Error: ${message}`)
-        // You could attach more info here if you like:
-        ;(err as any).code = code
-        ;(err as any).data = data
-        throw err
+        const werr = WalletErrorFromJson(json.error)
+        throw werr
       }
 
       return json.result