@bsv/wallet-toolbox 1.6.33 → 1.6.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.6.33",
+  "version": "1.6.34",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",

package/src/monitor/tasks/TaskReorg.ts

@@ -75,7 +75,11 @@ export class TaskReorg extends WalletMonitorTask {
           log += `      maximum retries ${this.maxRetries} exceeded\n`
         } else {
           log += `    retrying...\n`
-          this.monitor.deactivatedHeaders.push({ header: header.header, whenMsecs: Date.now(), tries: header.tries + 1 })
+          this.monitor.deactivatedHeaders.push({
+            header: header.header,
+            whenMsecs: Date.now(),
+            tries: header.tries + 1
+          })
         }
       }
     }

package/src/sdk/WERR_errors.ts

@@ -54,6 +54,11 @@ export class WERR_INVALID_PARAMETER extends WalletError {
   ) {
     super('WERR_INVALID_PARAMETER', `The ${parameter} parameter must be ${mustBe ?? 'valid.'}`)
   }
+  override toJson(): string {
+    const obj = JSON.parse(super.toJson())
+    obj.parameter = this.parameter
+    return JSON.stringify(obj)
+  }
 }
 
 /**
@@ -65,6 +70,11 @@ export class WERR_MISSING_PARAMETER extends WalletError {
   constructor(public parameter: string) {
     super('WERR_MISSING_PARAMETER', `The required ${parameter} parameter is missing.`)
   }
+  override toJson(): string {
+    const obj = JSON.parse(super.toJson())
+    obj.parameter = this.parameter
+    return JSON.stringify(obj)
+  }
 }
 
 /**
@@ -127,6 +137,12 @@ export class WERR_INSUFFICIENT_FUNDS extends WalletError {
       `Insufficient funds in the available inputs to cover the cost of the required outputs and the transaction fee (${moreSatoshisNeeded} more satoshis are needed, for a total of ${totalSatoshisNeeded}), plus whatever would be required in order to pay the fee to unlock and spend the outputs used to provide the additional satoshis.`
     )
   }
+  override toJson(): string {
+    const obj = JSON.parse(super.toJson())
+    obj.totalSatoshisNeeded = this.totalSatoshisNeeded
+    obj.moreSatoshisNeeded = this.moreSatoshisNeeded
+    return JSON.stringify(obj)
+  }
 }
 
 export class WERR_INVALID_PUBLIC_KEY extends WalletError {
@@ -144,6 +160,11 @@ export class WERR_INVALID_PUBLIC_KEY extends WalletError {
         : `The provided public key is invalid or malformed.`
     super('WERR_INVALID_PUBLIC_KEY', message)
   }
+  protected override toJson(): string {
+    const obj = JSON.parse(super.toJson())
+    obj.key = this.key
+    return JSON.stringify(obj)
+  }
 }
 
 /**
@@ -166,4 +187,17 @@ export class WERR_REVIEW_ACTIONS extends WalletError {
   ) {
     super('WERR_REVIEW_ACTIONS', 'Undelayed createAction or signAction results require review.')
   }
+  override toJson(): string {
+    const obj = JSON.parse(super.toJson())
+    obj.reviewActionResults = this.reviewActionResults
+    obj.sendWithResults = this.sendWithResults
+    obj.txid = this.txid
+    obj.tx = this.tx
+    obj.noSendChange = this.noSendChange
+    return JSON.stringify(obj)
+  }
 }
+
+/**
+ * IF YOU ADD NEW ERRORS, ALSO UPDATE THE WalletError.fromJson METHOD IN src/sdk/WalletError.ts
+ */

package/src/sdk/WalletError.ts

@@ -56,7 +56,7 @@ export class WalletError extends Error implements WalletErrorObject {
   static fromUnknown(err: unknown): WalletError {
     if (err instanceof WalletError) return err
     let name = 'WERR_UNKNOWN'
-    let message = ''
+    let message = typeof err === 'string' ? err : typeof err === 'number' ? err.toString() : ''
     let stack: string | undefined
     const details: Record<string, string> = {}
     if (err !== null && typeof err === 'object') {
@@ -116,4 +116,45 @@ export class WalletError extends Error implements WalletErrorObject {
       description: this.message
     }
   }
+
+  /**
+   * Base class default JSON serialization.
+   * Captures just the name and message properties.
+   *
+   * Override this method to safely (avoid deep, large, circular issues) serialize
+   * derived class properties.
+   *
+   * @returns stringified JSON representation of the WalletError.
+   */
+  protected toJson(): string {
+    const e = new WalletError(this.name, this.message)
+    const json = JSON.stringify({
+      isError: true,
+      name: e.name,
+      message: e.message
+    })
+    return json
+  }
+
+  /**
+   * Safely serializes a WalletError derived, WERR_REVIEW_ACTIONS (special case), Error or unknown error to JSON.
+   *
+   * Safely means avoiding deep, large, circular issues.
+   *
+   * @param error
+   * @returns stringified JSON representation of the error such that it can be desirialized to a WalletError.
+   */
+  static unknownToJson(error: unknown | WalletError): string {
+    let json: string | undefined
+    let e: WalletError | undefined
+    if (error instanceof WalletError || (typeof error === 'object' && error?.constructor.name.startsWith('WERR_'))) {
+      e = error as WalletError
+    } else if (error instanceof Error) {
+      e = new WalletError(error.name, error.message)
+    } else {
+      e = new WalletError('WERR_UNKNOWN', String(error))
+    }
+    json = e.toJson()
+    return json
+  }
 }

package/src/sdk/WalletErrorFromJson.ts

@@ -0,0 +1,80 @@
+import { WalletError } from './WalletError'
+import {
+  WERR_BAD_REQUEST,
+  WERR_BROADCAST_UNAVAILABLE,
+  WERR_INSUFFICIENT_FUNDS,
+  WERR_INTERNAL,
+  WERR_INVALID_OPERATION,
+  WERR_INVALID_PARAMETER,
+  WERR_INVALID_PUBLIC_KEY,
+  WERR_MISSING_PARAMETER,
+  WERR_NETWORK_CHAIN,
+  WERR_NOT_ACTIVE,
+  WERR_NOT_IMPLEMENTED,
+  WERR_REVIEW_ACTIONS,
+  WERR_UNAUTHORIZED
+} from './WERR_errors'
+
+/**
+ * Reconstruct the correct derived WalletError from a JSON object created by `WalletError.unknownToJson`.
+ *
+ * This function is implemented as a separate function instead of a WalletError class static
+ * to avoid circular dependencies.
+ *
+ * @param json
+ * @returns a WalletError derived error object, typically for re-throw.
+ */
+export function WalletErrorFromJson(json: object): WalletError {
+  let e: WalletError
+  const obj = json as any
+  switch (obj.name) {
+    case 'WERR_NOT_IMPLEMENTED':
+      e = new WERR_NOT_IMPLEMENTED(obj.message)
+      break
+    case 'WERR_INTERNAL':
+      e = new WERR_INTERNAL(obj.message)
+      break
+    case 'WERR_INVALID_OPERATION':
+      e = new WERR_INVALID_OPERATION(obj.message)
+      break
+    case 'WERR_BROADCAST_UNAVAILABLE':
+      e = new WERR_BROADCAST_UNAVAILABLE(obj.message)
+      break
+    case 'WERR_INVALID_PARAMETER':
+      e = new WERR_INVALID_PARAMETER(obj.parameter)
+      e.message = obj.message
+      break
+    case 'WERR_MISSING_PARAMETER':
+      e = new WERR_MISSING_PARAMETER(obj.parameter)
+      e.message = obj.message
+      break
+    case 'WERR_BAD_REQUEST':
+      e = new WERR_BAD_REQUEST(obj.message)
+      break
+    case 'WERR_NETWORK_CHAIN':
+      e = new WERR_NETWORK_CHAIN(obj.message)
+      break
+    case 'WERR_UNAUTHORIZED':
+      e = new WERR_UNAUTHORIZED(obj.message)
+      break
+    case 'WERR_NOT_ACTIVE':
+      e = new WERR_NOT_ACTIVE(obj.message)
+      break
+    case 'WERR_INSUFFICIENT_FUNDS':
+      e = new WERR_INSUFFICIENT_FUNDS(obj.totalSatoshisNeeded, obj.moreSatoshisNeeded)
+      break
+    case 'WERR_INVALID_PUBLIC_KEY':
+      e = new WERR_INVALID_PUBLIC_KEY(obj.key, 'mainnet')
+      e.message = obj.message
+      break
+    case 'WERR_REVIEW_ACTIONS':
+      e = new WERR_REVIEW_ACTIONS(obj.reviewActionResults, obj.sendWithResults, obj.txid, obj.tx, obj.noSendChange)
+      break
+    default:
+      {
+        e = new WalletError(obj.name || 'WERR_UNKNOWN', obj.message || '')
+      }
+      break
+  }
+  return e
+}

package/src/sdk/WalletStorage.interfaces.ts

@@ -572,7 +572,7 @@ export interface ReproveHeaderResult {
   /**
    * List of proven_txs records that were updated with new proof data.
    */
-  updated: { was: TableProvenTx; update: Partial<TableProvenTx>, logUpdate: string }[]
+  updated: { was: TableProvenTx; update: Partial<TableProvenTx>; logUpdate: string }[]
   /**
    * List of proven_txs records that were checked but currently available proof is unchanged.
    */
@@ -594,7 +594,7 @@ export interface ReproveProvenResult {
   /**
    * Valid if proof data for proven_txs record is available and has changed.
    */
-  updated?: { update: Partial<TableProvenTx>, logUpdate: string }
+  updated?: { update: Partial<TableProvenTx>; logUpdate: string }
   /**
    * True if proof data for proven_txs record was found to be unchanged.
    */
@@ -603,4 +603,4 @@ export interface ReproveProvenResult {
    * True if proof data for proven_txs record is currently unavailable.
    */
   unavailable: boolean
-}
+}

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

@@ -47,5 +47,4 @@ describe('verifyBeef tests', () => {
     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> {