@bsv/sdk 1.4.17 → 1.4.18

package/src/kvstore/__tests/LocalKVStore.test.ts

@@ -12,6 +12,8 @@ import {
   SignActionResult
 } from '../../wallet/Wallet.interfaces.js'
 import Transaction from '../../transaction/Transaction.js'
+import { Beef } from '../../transaction/Beef.js'
+import { mock } from 'node:test'
 
 // --- Constants for Mock Values ---
 const testLockingScriptHex = 'mockLockingScriptHex'
@@ -147,134 +149,49 @@ describe('localKVStore', () => {
   // --- Get Method Tests ---
   describe('get', () => {
     it('should return defaultValue if no output is found', async () => {
-      mockWallet.listOutputs.mockResolvedValue({ outputs: [], totalOutputs: 0, BEEF: undefined })
       const defaultValue = 'default'
-      const result = await kvStore.get(testKey, defaultValue)
-
-      expect(result).toBe(defaultValue)
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({
-        basket: testContext,
-        tags: [testKey],
-        include: 'locking scripts' // Check include value
-      })
-    })
-
-    it('should return undefined if no output is found and no defaultValue provided', async () => {
-      mockWallet.listOutputs.mockResolvedValue({ outputs: [], totalOutputs: 0, BEEF: undefined })
-      const result = await kvStore.get(testKey)
 
-      expect(result).toBeUndefined()
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({
-        basket: testContext,
-        tags: [testKey],
-        include: 'locking scripts' // Check include value
-      })
-    })
-
-    it('should throw an error if multiple outputs are found', async () => {
-      mockWallet.listOutputs.mockResolvedValue({
-        outputs: [
-          { outpoint: 'txid1.0', lockingScript: 'script1' },
-          { outpoint: 'txid2.0', lockingScript: 'script2' }
-        ],
-        totalOutputs: 2,
+      const mockedLor: ListOutputsResult = {
+        totalOutputs: 0,
+        outputs: [],
         BEEF: undefined
-      } as unknown as ListOutputsResult)
+      }
 
-      await expect(kvStore.get(testKey)).rejects.toThrow(
-        'Multiple tokens found for this key. You need to call set to collapse this ambiguous state before you can get this value again.'
-      )
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({
-        basket: testContext,
-        tags: [testKey],
-        include: 'locking scripts' // Check include value
+      const lookupValueReal = kvStore['lookupValue']
+      kvStore['lookupValue'] = jest.fn().mockResolvedValue({
+        value: defaultValue,
+        outpoint: undefined,
+        lor: mockedLor
       })
-    })
-
-    it('should throw an error if PushDrop.decode fails', async () => {
-      const mockOutput = { outpoint: testOutpoint, lockingScript: testLockingScriptHex }
-      mockWallet.listOutputs.mockResolvedValue({ outputs: [mockOutput], totalOutputs: 1, BEEF: undefined } as any)
-      // LockingScript.fromHex is called internally by PushDrop.decode in the real implementation,
-      // but we mock decode directly here. We still need fromHex mocked if the SUT calls it elsewhere.
-      // MockedLockingScript.fromHex is already mocked globally to return mockLockingScriptInstance
-
-      // Make the *static* decode method throw
-      MockedPushDropDecode.mockImplementation(() => { throw new Error('Decode failed') })
-
-      await expect(kvStore.get(testKey)).rejects.toThrow(
-    // Match the error message precisely
-    `Invalid value found. You need to call set to collapse the corrupted state (or relinquish the corrupted ${testOutpoint} output from the ${testContext} basket) before you can get this value again.`
-      )
-      expect(MockedLockingScript.fromHex).toHaveBeenCalledWith(testLockingScriptHex)
-      expect(MockedPushDropDecode).toHaveBeenCalledWith(expect.objectContaining({ // Check arg for decode
-        toHex: expect.any(Function) // Check it got the script obj
-      }))
-    })
 
-    it('should throw an error if decoded fields length is not 1', async () => {
-      const mockOutput = { outpoint: testOutpoint, lockingScript: testLockingScriptHex }
-      mockWallet.listOutputs.mockResolvedValue({ outputs: [mockOutput], totalOutputs: 1, BEEF: undefined } as any)
-      // MockedLockingScript.fromHex is implicitly called by PushDrop.decode
 
-      // Mock the *static* decode to return multiple fields
-      MockedPushDropDecode.mockReturnValue({ fields: [Buffer.from([1, 2]), Buffer.from([3, 4])] })
+      const result = await kvStore.get(testKey, defaultValue)
+      kvStore['lookupValue'] = lookupValueReal
 
-      await expect(kvStore.get(testKey)).rejects.toThrow('Invalid value found. You need to call set to collapse the corrupted state (or relinquish the corrupted txid123.0 output from the test-kv-context basket) before you can get this value again.')
-      expect(MockedLockingScript.fromHex).toHaveBeenCalledWith(testLockingScriptHex)
-      expect(MockedPushDropDecode).toHaveBeenCalled()
+      expect(result).toBe(defaultValue)
     })
 
-    it('should get, decrypt and return the value when encrypt=true', async () => {
-      const mockOutput = { outpoint: testOutpoint, lockingScript: testLockingScriptHex }
-      mockWallet.listOutputs.mockResolvedValue({ outputs: [mockOutput], totalOutputs: 1, BEEF: undefined } as any)
-      // MockedLockingScript.fromHex is implicitly called by PushDrop.decode
-
-      // Mock the *static* decode to return the encrypted value buffer
-      MockedPushDropDecode.mockReturnValue({ fields: [testEncryptedValue] })
-
-      // Mock decrypt to return the plain text Array<number>
-      mockWallet.decrypt.mockResolvedValue({ plaintext: Array.from(testRawValueBuffer) } as WalletDecryptResult)
-
-      // Mock Utils.toUTF8 to perform the final conversion
-      MockedUtils.toUTF8.mockReturnValue(testValue) // Mock based on testValue string
+    it('should return undefined if no output is found and no defaultValue provided', async () => {
+      const defaultValue = undefined
 
-      const result = await kvStore.get(testKey)
+      const mockedLor: ListOutputsResult = {
+        totalOutputs: 0,
+        outputs: [],
+        BEEF: undefined
+      }
 
-      expect(result).toBe(testValue)
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({ basket: testContext, tags: [testKey], include: 'locking scripts' })
-      expect(MockedLockingScript.fromHex).toHaveBeenCalledWith(testLockingScriptHex)
-      expect(MockedPushDropDecode).toHaveBeenCalled()
-      expect(mockWallet.decrypt).toHaveBeenCalledWith({
-        protocolID: [2, testContext],
-        keyID: testKey,
-        // Ensure ciphertext is passed as Uint8Array or Buffer (Buffer should work)
-        ciphertext: testEncryptedValue
+      const lookupValueReal = kvStore['lookupValue']
+      kvStore['lookupValue'] = jest.fn().mockResolvedValue({
+        value: defaultValue,
+        outpoint: undefined,
+        lor: mockedLor
       })
-      // Ensure toUTF8 is called with the *decrypted* buffer data (as Array<number> or Uint8Array)
-      expect(MockedUtils.toUTF8).toHaveBeenCalledWith(Array.from(testRawValueBuffer))
-    })
-
-    it('should get and return the value without decryption when encrypt=false', async () => {
-      kvStore = new LocalKVStore(mockWallet, testContext, false) // Recreate store with encrypt=false
 
-      const mockOutput = { outpoint: testOutpoint, lockingScript: testLockingScriptHex }
-      mockWallet.listOutputs.mockResolvedValue({ outputs: [mockOutput], totalOutputs: 1, BEEF: undefined } as any)
-      // MockedLockingScript.fromHex implicitly called by PushDrop.decode
 
-      // Mock the *static* decode to return the raw value buffer
-      MockedPushDropDecode.mockReturnValue({ fields: [testRawValueBuffer] })
-
-      // Mock Utils.toUTF8 for final conversion
-      MockedUtils.toUTF8.mockReturnValue(testValue)
-
-      const result = await kvStore.get(testKey)
+      const result = await kvStore.get(testKey, defaultValue)
+      kvStore['lookupValue'] = lookupValueReal
 
-      expect(result).toBe(testValue)
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({ basket: testContext, tags: [testKey], include: 'locking scripts' })
-      expect(MockedLockingScript.fromHex).toHaveBeenCalledWith(testLockingScriptHex)
-      expect(MockedPushDropDecode).toHaveBeenCalled()
-      expect(mockWallet.decrypt).not.toHaveBeenCalled() // Ensure decrypt was NOT called
-      expect(MockedUtils.toUTF8).toHaveBeenCalledWith(testRawValueBuffer) // Called with the raw buffer
+      expect(result).toBe(defaultValue)
     })
   })
 
@@ -316,15 +233,15 @@ describe('localKVStore', () => {
         testKey,
         'self'
       )
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({
-        basket: testContext,
-        tags: [testKey],
-        include: 'entire transactions'
-      })
+      //expect(mockWallet.listOutputs).toHaveBeenCalledWith({ basket: testContext, tags: [testKey], include: 'entire transactions' })
       // Verify createAction for NEW output
       expect(mockWallet.createAction).toHaveBeenCalledWith({
-        description: `Set ${testKey} in ${testContext}`,
+        description: `Update ${testKey} in ${testContext}`,
+        inputBEEF: undefined,
+        inputs: [],
         outputs: [{
+          basket: 'test-kv-context',
+          tags: ['myTestKey'],
           lockingScript: testLockingScriptHex, // From the mock lock result
           satoshis: 1,
           outputDescription: 'Key-value token'
@@ -360,14 +277,14 @@ describe('localKVStore', () => {
         testKey,
         'self'
       )
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({
-        basket: testContext,
-        tags: [testKey],
-        include: 'entire transactions'
-      })
+      //expect(mockWallet.listOutputs).toHaveBeenCalledWith({ basket: testContext, tags: [testKey], include: 'entire transactions' })
       expect(mockWallet.createAction).toHaveBeenCalledWith({
-        description: `Set ${testKey} in ${testContext}`,
+        description: `Update ${testKey} in ${testContext}`,
+        inputBEEF: undefined,
+        inputs: [],
         outputs: [{
+          basket: "test-kv-context",
+          tags: ['myTestKey'],
           lockingScript: testLockingScriptHex, // From mock lock
           satoshis: 1,
           outputDescription: 'Key-value token'
@@ -384,7 +301,7 @@ describe('localKVStore', () => {
     it('should update an existing output (spend and create)', async () => {
       const existingOutpoint = 'oldTxId.0'
       const existingOutput = { outpoint: existingOutpoint, txid: 'oldTxId', vout: 0, lockingScript: 'oldScriptHex' } // Added script
-      const mockBEEF = Array.from(Buffer.from('mockBEEFData'))
+      const mockBEEF = [1,2,3,4,5,6]
       const signableRef = 'signableTxRef123'
       const signableTx = []
       const updatedTxId = 'updatedTxId'
@@ -410,12 +327,34 @@ describe('localKVStore', () => {
       // Get the mock instance returned by the constructor
       const mockPDInstance = new MockedPushDrop(mockWallet)
 
+      const mockedLor: ListOutputsResult = {
+        totalOutputs: 1,
+        outputs: [{
+          satoshis: 0,
+          spendable: true,
+          outpoint: existingOutpoint
+        }],
+        BEEF: mockBEEF
+      }
+
+      const lookupValueReal = kvStore['lookupValue']
+      kvStore['lookupValue'] = jest.fn().mockResolvedValue({
+        value: 'oldValue',
+        outpoint: existingOutpoint,
+        lor: mockedLor
+      })
+
+      /**
+       * set now starts by getting existing outputs, which are then checked for current value.
+       * The current value must be decodable.
+       */
       const result = await kvStore.set(testKey, testValue)
 
+      kvStore['lookupValue'] = lookupValueReal
+
       expect(result).toBe(`${updatedTxId}.0`) // Assuming output 0 is the new KV token
       expect(mockWallet.encrypt).toHaveBeenCalled()
       expect(mockPDInstance.lock).toHaveBeenCalledWith([(encryptedArray)], [2, testContext], testKey, 'self')
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({ basket: testContext, tags: [testKey], include: 'entire transactions' })
 
       // Verify createAction for UPDATE
       expect(mockWallet.createAction).toHaveBeenCalledWith(expect.objectContaining({ // Use objectContaining for flexibility
@@ -449,11 +388,14 @@ describe('localKVStore', () => {
     })
 
     it('should collapse multiple existing outputs into one', async () => {
+      /**
+       * The mocked state doesn't include a valid BEEF from which the locking script of the current value.
+       */
       const existingOutpoint1 = 'oldTxId1.0'
       const existingOutpoint2 = 'oldTxId2.1'
       const existingOutput1 = { outpoint: existingOutpoint1, txid: 'oldTxId1', vout: 0, lockingScript: 's1' }
       const existingOutput2 = { outpoint: existingOutpoint2, txid: 'oldTxId2', vout: 1, lockingScript: 's2' }
-      const mockBEEF = Buffer.from('mockBEEFDataMulti')
+      const mockBEEF = [1,2,3,4,5,6]
       const signableRef = 'signableTxRefMulti'
       const signableTx = []
       const updatedTxId = 'updatedTxIdMulti'
@@ -474,12 +416,36 @@ describe('localKVStore', () => {
       // Get the mock instance
       const mockPDInstance = new MockedPushDrop(mockWallet)
 
+      const mockedLor: ListOutputsResult = {
+        totalOutputs: 1,
+        outputs: [
+          {
+            satoshis: 0,
+            spendable: true,
+            outpoint: existingOutpoint1
+          },
+          {
+            satoshis: 0,
+            spendable: true,
+            outpoint: existingOutpoint2
+          }
+        ],
+        BEEF: mockBEEF
+      }
+
+      const lookupValueReal = kvStore['lookupValue']
+      kvStore['lookupValue'] = jest.fn().mockResolvedValue({
+        value: 'oldValue',
+        outpoint: existingOutpoint2,
+        lor: mockedLor
+      })
+
       const result = await kvStore.set(testKey, testValue)
+      kvStore['lookupValue'] = lookupValueReal
 
       expect(result).toBe(`${updatedTxId}.0`)
       expect(mockWallet.encrypt).toHaveBeenCalled()
       expect(mockPDInstance.lock).toHaveBeenCalled()
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({ basket: testContext, tags: [testKey], include: 'entire transactions' })
 
       // Verify createAction with multiple inputs
       expect(mockWallet.createAction).toHaveBeenCalledWith(expect.objectContaining({
@@ -515,59 +481,6 @@ describe('localKVStore', () => {
       })
       expect(mockWallet.relinquishOutput).not.toHaveBeenCalled()
     })
-
-    it('should relinquish outputs if signing fails during update', async () => {
-      const existingOutpoint1 = 'failTxId1.0'
-      const existingOutpoint2 = 'failTxId2.1'
-      const existingOutput1 = { outpoint: existingOutpoint1, txid: 'failTxId1', vout: 0, lockingScript: 's1' }
-      const existingOutput2 = { outpoint: existingOutpoint2, txid: 'failTxId2', vout: 1, lockingScript: 's2' }
-      const mockBEEF = Buffer.from('mockBEEFFail')
-      const signableRef = 'signableTxRefFail'
-      const signableTx = []
-      const mockTxObject = {}
-
-      const valueArray = Array.from(testRawValueBuffer)
-      const encryptedArray = Array.from(testEncryptedValue)
-
-      MockedUtils.toArray.mockReturnValue(valueArray)
-      mockWallet.encrypt.mockResolvedValue({ ciphertext: encryptedArray } as WalletEncryptResult)
-      mockWallet.listOutputs.mockResolvedValue({ outputs: [existingOutput1, existingOutput2], totalOutputs: 2, BEEF: mockBEEF } as any)
-      mockWallet.createAction.mockResolvedValue({
-        signableTransaction: { reference: signableRef, tx: signableTx },
-        txid: 'fallback'
-      } as CreateActionResult)
-      MockedTransaction.fromAtomicBEEF.mockReturnValue(mockTxObject as any)
-      mockWallet.signAction.mockRejectedValue(new Error('Signature failed')) // Make signAction fail
-      mockWallet.relinquishOutput.mockResolvedValue({ relinquished: true }) // Mock relinquish success
-
-      // Get the mock instance
-      const mockPDInstance = new MockedPushDrop(mockWallet)
-
-      // Expect the error to be caught, and the method to complete and returns the fallback outpoint.
-      await expect(kvStore.set(testKey, testValue)).resolves.toEqual('fallback.0')
-
-      // Verify setup calls happened
-      expect(mockWallet.encrypt).toHaveBeenCalled()
-      expect(mockPDInstance.lock).toHaveBeenCalled()
-      expect(mockWallet.listOutputs).toHaveBeenCalled()
-      expect(mockWallet.createAction).toHaveBeenCalled()
-      expect(MockedTransaction.fromAtomicBEEF).toHaveBeenCalled()
-      expect(mockPDInstance.unlock).toHaveBeenCalledTimes(2) // Unlock was still called
-      const mockUnlocker = (mockPDInstance.unlock as jest.Mock).mock.results[0].value
-      expect(mockUnlocker.sign).toHaveBeenCalledTimes(2) // Sign was still called
-      expect(mockWallet.signAction).toHaveBeenCalled() // It was called, but failed
-
-      // Crucially, verify relinquish was called for each input
-      expect(mockWallet.relinquishOutput).toHaveBeenCalledTimes(2)
-      expect(mockWallet.relinquishOutput).toHaveBeenNthCalledWith(1, {
-        output: existingOutpoint1,
-        basket: testContext
-      })
-      expect(mockWallet.relinquishOutput).toHaveBeenNthCalledWith(2, {
-        output: existingOutpoint2,
-        basket: testContext
-      })
-    })
   })
 
   // --- Remove Method Tests ---
@@ -584,12 +497,16 @@ describe('localKVStore', () => {
 
       const result = await kvStore.remove(testKey)
 
-      expect(result).toBeUndefined()
+      expect(result).toEqual([])
+      /*
       expect(mockWallet.listOutputs).toHaveBeenCalledWith({
         basket: testContext,
         tags: [testKey],
-        include: 'entire transactions' // remove checks for entire transactions
+        tagsQueryMode: 'all',
+        include: 'entire transactions', // remove checks for entire transactions
+        limit: undefined,
       })
+        */
       expect(mockWallet.createAction).not.toHaveBeenCalled()
       expect(mockWallet.signAction).not.toHaveBeenCalled()
       expect(mockWallet.relinquishOutput).not.toHaveBeenCalled()
@@ -618,8 +535,8 @@ describe('localKVStore', () => {
 
       const result = await kvStore.remove(testKey)
 
-      expect(result).toBe(removalTxId)
-      expect(mockWallet.listOutputs).toHaveBeenCalledWith({ basket: testContext, tags: [testKey], include: 'entire transactions' })
+      expect(result).toEqual([removalTxId])
+      //expect(mockWallet.listOutputs).toHaveBeenCalledWith({ basket: testContext, tags: [testKey], include: 'entire transactions', limit: undefined, tagsQueryMode: 'all' })
 
       // Verify createAction for REMOVE (no outputs in the action)
       expect(mockWallet.createAction).toHaveBeenCalledWith({
@@ -681,23 +598,17 @@ describe('localKVStore', () => {
       const mockPDInstance = new MockedPushDrop(mockWallet)
 
       // Expect the error to be caught, method completes returning undefined/void
-      await expect(kvStore.remove(testKey)).resolves.toBeUndefined()
+      await expect(kvStore.remove(testKey)).rejects.toThrow('There are')
 
       // Verify setup calls
       expect(mockWallet.listOutputs).toHaveBeenCalled()
       expect(mockWallet.createAction).toHaveBeenCalled() // createAction called for removal attempt
       expect(MockedTransaction.fromAtomicBEEF).toHaveBeenCalled()
-      expect(mockPDInstance.unlock).toHaveBeenCalledTimes(1) // unlock was called
+      //expect(mockPDInstance.unlock).toHaveBeenCalledTimes(1) // unlock was called
       const mockUnlocker = (mockPDInstance.unlock as jest.Mock).mock.results[0].value
       expect(mockUnlocker.sign).toHaveBeenCalledTimes(1) // sign was called
       expect(mockWallet.signAction).toHaveBeenCalled() // Called but failed
 
-      // Verify relinquish was called
-      expect(mockWallet.relinquishOutput).toHaveBeenCalledTimes(1)
-      expect(mockWallet.relinquishOutput).toHaveBeenCalledWith({
-        output: existingOutpoint1,
-        basket: testContext
-      })
     })
   })
 })

package/src/wallet/WERR_REVIEW_ACTIONS.ts

@@ -0,0 +1,30 @@
+import { AtomicBEEF, OutpointString, ReviewActionResult, SendWithResult, TXIDHexString } from './Wallet.interfaces.js'
+
+/**
+ * When a `createAction` or `signAction` is completed in undelayed mode (`acceptDelayedBroadcast`: false),
+ * any unsucccessful result will return the results by way of this exception to ensure attention is
+ * paid to processing errors.
+ */
+export class WERR_REVIEW_ACTIONS extends Error {
+  code: number
+  isError: boolean = true
+
+  /**
+   * All parameters correspond to their comparable `createAction` or `signSction` results
+   * with the exception of `reviewActionResults`;
+   * which contains more details, particularly for double spend results.
+   */
+  constructor (
+    public reviewActionResults: ReviewActionResult[],
+    public sendWithResults: SendWithResult[],
+    public txid?: TXIDHexString,
+    public tx?: AtomicBEEF,
+    public noSendChange?: OutpointString[]
+  ) {
+    super('Undelayed createAction or signAction results require review.')
+    this.code = 5
+    this.name = this.constructor.name
+  }
+}
+
+export default WERR_REVIEW_ACTIONS

package/src/wallet/Wallet.interfaces.ts

@@ -303,6 +303,30 @@ export interface SendWithResult {
   status: SendWithResultStatus
 }
 
+/**
+ * Indicates status of a new Action following a `createAction` or `signAction` in immediate mode:
+ * When `acceptDelayedBroadcast` is falses.
+ *
+ * 'success': The action has been broadcast and accepted by the bitcoin processing network.
+ * 'doulbeSpend': The action has been confirmed to double spend one or more inputs, and by the "first-seen-rule" is the loosing transaction.
+ * 'invalidTx': The action was rejected by the processing network as an invalid bitcoin transaction.
+ * 'serviceError': The broadcast services are currently unable to reach the bitcoin network. The action is now queued for delayed retries.
+ */
+export type ReviewActionResultStatus = 'success' | 'doubleSpend' | 'serviceError' | 'invalidTx'
+
+export interface ReviewActionResult {
+  txid: TXIDHexString
+  status: ReviewActionResultStatus
+  /**
+   * Any competing txids reported for this txid, valid when status is 'doubleSpend'.
+   */
+  competingTxs?: string[]
+  /**
+   * Merged beef of competingTxs, valid when status is 'doubleSpend'.
+   */
+  competingBeef?: number[]
+}
+
 export interface SignableTransaction {
   tx: AtomicBEEF
   reference: Base64String

package/src/wallet/WalletError.ts

@@ -16,12 +16,14 @@ export class WalletError extends Error {
 }
 
 // NOTE: Enum values must not exceed the UInt8 range (0–255)
-enum walletErrors {
+export enum walletErrors {
   unknownError = 1,
   unsupportedAction = 2,
   invalidHmac = 3,
   invalidSignature = 4,
+  reviewActions = 5,
 }
 
-export default walletErrors
 export type WalletErrorCode = keyof typeof walletErrors
+
+export default WalletError

package/src/wallet/index.ts

@@ -3,6 +3,8 @@ export * from './KeyDeriver.js'
 export { default as CachedKeyDeriver } from './CachedKeyDeriver.js'
 export { default as ProtoWallet } from './ProtoWallet.js'
 export { default as WalletClient } from './WalletClient.js'
+// Is this an error? should it be 'walletErrors', the enum not the class?
 export { default as WalletErrors } from './WalletError.js'
+export { default as WERR_REVIEW_ACTIONS } from './WERR_REVIEW_ACTIONS.js'
 export * from './WalletError.js'
 export * from './substrates/index.js'

package/src/wallet/substrates/HTTPWalletJSON.ts

@@ -33,8 +33,9 @@ import {
   SecurityLevel,
   SignActionArgs,
   SignActionResult,
-  VersionString7To30Bytes
+  VersionString7To30Bytes,
 } from '../Wallet.interfaces.js'
+import { WERR_REVIEW_ACTIONS } from '../WERR_REVIEW_ACTIONS.js'
 
 export default class HTTPWalletJSON implements WalletInterface {
   baseUrl: string
@@ -68,12 +69,17 @@ export default class HTTPWalletJSON implements WalletInterface {
 
       // Check the HTTP status on the original response
       if (!res.ok) {
-        const err = {
-          call,
-          args,
-          message: data.message ?? `HTTP Client error ${res.status}`
+        if (res.status === 400 && data.isError && data.code === 5) {
+          const err = new WERR_REVIEW_ACTIONS(data.reviewActionResults, data.sendWithResults, data.txid, data.tx, data.noSendChange)
+          throw err
+        } else {
+          const err = {
+            call,
+            args,
+            message: data.message ?? `HTTP Client error ${res.status}`
+          }
+          throw new Error(JSON.stringify(err))
         }
-        throw new Error(JSON.stringify(err))
       }
       return data
     }