@bsv/wallet-toolbox 1.6.33 → 1.6.35

package/package.json

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

package/src/Wallet.ts

@@ -770,8 +770,6 @@ export class Wallet implements WalletInterface, ProtoWallet {
 
     const { auth, vargs } = this.validateAuthAndArgs(args, validateCreateActionArgs)
 
-    if (vargs.labels.indexOf(specOpThrowReviewActions) >= 0) throwDummyReviewActions()
-
     vargs.includeAllSourceTransactions = this.includeAllSourceTransactions
     if (this.randomVals && this.randomVals.length > 1) {
       vargs.randomVals = [...this.randomVals]
@@ -1105,7 +1103,7 @@ function throwIfUnsuccessfulInternalizeAction(r: StorageInternalizeActionResult)
 /**
  * Throws a WERR_REVIEW_ACTIONS with a full set of properties to test data formats and propagation.
  */
-function throwDummyReviewActions() {
+export function throwDummyReviewActions() {
   const b58Beef =
     'gno9MC7VXii1KoCkc2nsVyYJpqzN3dhBzYATETJcys62emMKfpBof4R7GozwYEaSapUtnNvqQ57aaYYjm3U2dv9eUJ1sV46boHkQgppYmAz9YH8FdZduV8aJayPViaKcyPmbDhEw6UW8TM5iFZLXNs7HBnJHUKCeTdNK4FUEL7vAugxAV9WUUZ43BZjJk2SmSeps9TCXjt1Ci9fKWp3d9QSoYvTpxwzyUFHjRKtbUgwq55ZfkBp5bV2Bpz9qSuKywKewW7Hh4S1nCUScwwzpKDozb3zic1V9p2k8rQxoPsRxjUJ8bjhNDdsN8d7KukFuc3n47fXzdWttvnxwsujLJRGnQbgJuknQqx3KLf5kJXHzwjG6TzigZk2t24qeB6d3hbYiaDr2fFkUJBL3tukTHhfNkQYRXuz3kucVDzvejHyqJaF51mXG8BjMN5aQj91ZJXCaPVqkMWCzmvyaqmXMdRiJdSAynhXbQK91xf6RwdNhz1tg5f9B6oJJMhsi9UYSVymmax8VLKD9AKzBCBDcfyD83m3jyS1VgKGZn3SkQmr6bsoWq88L3GsMnnmYUGogvdAYarTqg3pzkjCMxHzmJBMN6ofnUk8c1sRTXQue7BbyUaN5uZu3KW6CmFsEfpuqVvnqFW93TU1jrPP2S8yz8AexAnARPCKE8Yz7RfVaT6RCavwQKL3u5iookwRWEZXW1QWmM37yJWHD87SjVynyg327a1CLwcBxmE2CB48QeNVGyQki4CTQMqw2o8TMhDPJej1g68oniAjBcxBLSCs7KGvK3k7AfrHbCMULX9CTibYhCjdFjbsbBoocqJpxxcvkMo1fEEiAzZuiBVZQDYktDdTVbhKHvYkW25HcYX75NJrpNAhm7AjFeKLzEVxqAQkMfvTufpESNRZF4kQqg2Rg8h2ajcKTd5cpEPwXCrZLHm4EaZEmZVbg3QNfGhn7BJu1bHMtLqPD4y8eJxm2uGrW6saf6qKYmmu64F8A667NbD4yskPRQ1S863VzwGpxxmgLc1Ta3R46jEqsAoRDoZVUaCgBBZG3Yg1CTgi1EVBMXU7qvY4n3h8o2FLCEMWY4KadnV3iD4FbcdCmg4yxBosNAZgbPjhgGjCimjh4YsLd9zymGLmivmz2ZBg5m3xaiXT9NN81X9C1JUujd'
   const beef = Beef.fromBinary(Utils.fromBase58(b58Beef))

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/sdk/validationHelpers.ts

@@ -44,7 +44,7 @@ import {
   Utils,
   WalletPayment
 } from '@bsv/sdk'
-import { OutPoint } from './types'
+import { OutPoint, specOpThrowReviewActions } from './types'
 import { WERR_INTERNAL, WERR_INVALID_PARAMETER } from './WERR_errors'
 
 export function parseWalletOutpoint(outpoint: string): {
@@ -327,6 +327,8 @@ export interface ValidProcessActionArgs extends ValidWalletSignerArgs {
   isNoSend: boolean
   // true if options.acceptDelayedBroadcast is true
   isDelayed: boolean
+  // true if WERR_REVIEW_ACTIONS should be thrown to test review actions handling
+  isTestWerrReviewActions: boolean
 }
 
 export interface ValidCreateActionArgs extends ValidProcessActionArgs {
@@ -357,6 +359,13 @@ export interface ValidSignActionArgs extends ValidProcessActionArgs {
   options: ValidSignActionOptions
 }
 
+/**
+ * Validate the arguments for creating a new action.
+ *
+ * @param args
+ * @returns validated arguments
+ * @throws primarily WERR_INVALID_PARAMETER if args are invalid.
+ */
 export function validateCreateActionArgs(args: CreateActionArgs): ValidCreateActionArgs {
   const vargs: ValidCreateActionArgs = {
     description: validateStringLength(args.description, 'description', 5, 2000),
@@ -374,8 +383,10 @@ export function validateCreateActionArgs(args: CreateActionArgs): ValidCreateAct
     isRemixChange: false,
     isSignAction: false,
     randomVals: undefined,
-    includeAllSourceTransactions: false
+    includeAllSourceTransactions: false,
+    isTestWerrReviewActions: false
   }
+  vargs.isTestWerrReviewActions = vargs.labels.indexOf(specOpThrowReviewActions) >= 0
   vargs.isSendWith = vargs.options.sendWith.length > 0
   vargs.isRemixChange = !vargs.isSendWith && vargs.inputs.length === 0 && vargs.outputs.length === 0
   vargs.isNewTx = vargs.isRemixChange || vargs.inputs.length > 0 || vargs.outputs.length > 0
@@ -413,7 +424,8 @@ export function validateSignActionArgs(args: SignActionArgs): ValidSignActionArg
     isDelayed: false,
     isNoSend: false,
     isNewTx: true,
-    isRemixChange: false
+    isRemixChange: false,
+    isTestWerrReviewActions: false
   }
   vargs.isSendWith = vargs.options.sendWith.length > 0
   vargs.isDelayed = vargs.options.acceptDelayedBroadcast

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

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