@bsv/sdk 1.8.9 → 1.8.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.8.9",
+  "version": "1.8.11",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/primitives/__tests/utils.test.ts

@@ -7,7 +7,8 @@ import {
   fromBase58,
   toBase58,
   fromBase58Check,
-  toBase58Check
+  toBase58Check,
+  verifyNotNull
 } from '../../primitives/utils'
 
 describe('utils', () => {
@@ -207,3 +208,28 @@ describe('utils', () => {
     expect(toArray(input)).toEqual(expected)
   })
 })
+
+describe('verifyNotNull', () => {
+  it('should return the value if it is not null or undefined', () => {
+    expect(verifyNotNull(42)).toBe(42)
+    expect(verifyNotNull('hello')).toBe('hello')
+    expect(verifyNotNull({})).toEqual({})
+    expect(verifyNotNull([])).toEqual([])
+  })
+
+  it('should throw an error with default message if value is null', () => {
+    expect(() => verifyNotNull(null)).toThrow('Expected a valid value, but got undefined or null.')
+  })
+
+  it('should throw an error with default message if value is undefined', () => {
+    expect(() => verifyNotNull(undefined)).toThrow('Expected a valid value, but got undefined or null.')
+  })
+
+  it('should throw an error with custom message if value is null', () => {
+    expect(() => verifyNotNull(null, 'Custom error')).toThrow('Custom error')
+  })
+
+  it('should throw an error with custom message if value is undefined', () => {
+    expect(() => verifyNotNull(undefined, 'Another custom error')).toThrow('Another custom error')
+  })
+})

package/src/primitives/utils.ts

@@ -819,3 +819,20 @@ export const minimallyEncode = (buf: number[]): number[] => {
 
 const OverflowInt64 = new BigNumber(2).pow(new BigNumber(63))
 const OverflowUint64 = new BigNumber(2).pow(new BigNumber(64))
+
+/**
+ * Verifies that a value is not null or undefined, throwing an error if it is.
+ *
+ * @template T - The type of the value being verified
+ * @param {T | undefined | null} value - The value to verify
+ * @param {string} errorMessage - The error message to throw if the value is null or undefined
+ * @returns {T} - The verified value
+ * @throws {Error} - If the value is null or undefined
+ *
+ * @example
+ * const myValue = verifyNotNull(someValue, 'someValue must be defined')
+ */
+export function verifyNotNull<T> (value: T | undefined | null, errorMessage: string = 'Expected a valid value, but got undefined or null.'): T {
+  if (value == null) throw new Error(errorMessage)
+  return value
+}

package/src/script/__tests/Spend.test.ts

@@ -7,8 +7,30 @@ import RPuzzle from '../../script/templates/RPuzzle'
 import Transaction from '../../transaction/Transaction'
 import LockingScript from '../../script/LockingScript'
 import UnlockingScript from '../../script/UnlockingScript'
-
+import MerklePath from '../../transaction/MerklePath'
+import ChainTracker from '../../transaction/ChainTracker'
 import spendValid from './spend.valid.vectors'
+import Script from '../../script/Script'
+
+export class MockChain implements ChainTracker {
+  mock: { blockheaders: string[] }
+
+  constructor(mock: { blockheaders: string[] }) {
+    this.mock = mock
+  }
+
+  addBlock(merkleRoot: string) {
+    this.mock.blockheaders.push(merkleRoot)
+  }
+
+  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
+    return this.mock.blockheaders[height] === root
+  }
+
+  async currentHeight(): Promise<number> {
+    return this.mock.blockheaders.length
+  }
+}
 
 describe('Spend', () => {
   it('Successfully validates a P2PKH spend', async () => {
@@ -368,4 +390,55 @@ describe('Spend', () => {
       expect(spend.validate()).toBe(true)
     })
   }
+
+  it('Successfully validates a spend where sequence is set to undefined', async () => {
+    const sourceTransaction = new Transaction(
+      1,
+      [{
+        sourceTXID: '0000000000000000000000000000000000000000000000000000000000000000',
+        sourceOutputIndex: 0,
+        unlockingScript: Script.fromASM('OP_TRUE'),
+        sequence: 0xffffffff
+      }],
+      [
+        {
+          lockingScript: Script.fromASM('OP_NOP'),
+          satoshis: 2
+        }
+      ],
+      0
+    )
+    const txid = sourceTransaction.id('hex')
+    sourceTransaction.merklePath = MerklePath.fromCoinbaseTxidAndHeight(txid, 0)
+    const chain = new MockChain({ blockheaders: [] })
+    chain.addBlock(txid)
+
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          unlockingScript: Script.fromASM('OP_TRUE'),
+          sourceTransaction,
+          sourceOutputIndex: 0
+        }
+      ],
+      [{
+          lockingScript: Script.fromASM('OP_NOP'),
+          satoshis: 1
+      }],
+      0
+    )
+
+    const valid = await spendTx.verify(chain)
+    
+    expect(valid).toBe(true)
+
+    const b = spendTx.toBinary()
+    const t = Transaction.fromBinary(b)
+    expect(t.inputs[0].sequence).toBe(0xffffffff)
+
+    const b2 = spendTx.toEF()
+    const t2 = Transaction.fromEF(b2)
+    expect(t2.inputs[0].sequence).toBe(0xffffffff)
+  })
 })

package/src/script/__tests/SpendComplex.test.ts

@@ -1,6 +1,7 @@
 import Script from '../../script/Script'
 import Spend from '../../script/Spend'
 import Transaction from '../../transaction/Transaction'
+import { verifyNotNull } from '../../primitives/utils'
 
 describe('SpendComplex', () => {
   it('complex unlock script validation', () => {
@@ -19,11 +20,6 @@ describe('SpendComplex', () => {
   })
 })
 
-function verifyTruthy<T> (v: T | undefined): T {
-  if (v == null) throw new Error('must have value')
-  return v
-}
-
 export function validateUnlockScript (
   spendingRawTx: string,
   vin: number,
@@ -34,16 +30,16 @@ export function validateUnlockScript (
   const ls = Script.fromHex(lockingScript)
 
   const spend = new Spend({
-    sourceTXID: verifyTruthy(spendingTx.inputs[vin].sourceTXID),
-    sourceOutputIndex: verifyTruthy(spendingTx.inputs[vin].sourceOutputIndex),
+    sourceTXID: verifyNotNull(spendingTx.inputs[vin].sourceTXID, 'sourceTXID must have value'),
+    sourceOutputIndex: verifyNotNull(spendingTx.inputs[vin].sourceOutputIndex, 'sourceOutputIndex must have value'),
     sourceSatoshis: amount,
     lockingScript: ls,
     transactionVersion: spendingTx.version,
     otherInputs: spendingTx.inputs.filter((v, i) => i !== vin),
     inputIndex: vin,
-    unlockingScript: verifyTruthy(spendingTx.inputs[vin].unlockingScript),
+    unlockingScript: verifyNotNull(spendingTx.inputs[vin].unlockingScript, 'unlockingScript must have value'),
     outputs: spendingTx.outputs,
-    inputSequence: verifyTruthy(spendingTx.inputs[vin].sequence),
+    inputSequence: verifyNotNull(spendingTx.inputs[vin].sequence, 'sequence must have value'),
     lockTime: spendingTx.lockTime
   })
 

package/src/script/templates/P2PKH.ts

@@ -1,6 +1,6 @@
 import OP from '../OP.js'
 import ScriptTemplate from '../ScriptTemplate.js'
-import { fromBase58Check } from '../../primitives/utils.js'
+import { fromBase58Check, verifyNotNull } from '../../primitives/utils.js'
 import LockingScript from '../LockingScript.js'
 import UnlockingScript from '../UnlockingScript.js'
 import Transaction from '../../transaction/Transaction.js'
@@ -9,11 +9,6 @@ import TransactionSignature from '../../primitives/TransactionSignature.js'
 import { sha256 } from '../../primitives/Hash.js'
 import Script from '../Script.js'
 
-function verifyTruthy<T>(v: T | undefined): T {
-  if (v == null) throw new Error('must have value')
-  return v
-}
-
 /**
  * P2PKH (Pay To Public Key Hash) class implementing ScriptTemplate.
  *
@@ -125,13 +120,13 @@ export default class P2PKH implements ScriptTemplate {
 
         const preimage = TransactionSignature.format({
           sourceTXID,
-          sourceOutputIndex: verifyTruthy(input.sourceOutputIndex),
+          sourceOutputIndex: verifyNotNull(input.sourceOutputIndex, 'input.sourceOutputIndex must have value'),
           sourceSatoshis,
           transactionVersion: tx.version,
           otherInputs,
           inputIndex,
           outputs: tx.outputs,
-          inputSequence: verifyTruthy(input.sequence),
+          inputSequence: verifyNotNull(input.sequence, 'input.sequence must have value'),
           subscript: lockingScript,
           lockTime: tx.lockTime,
           scope: signatureScope

package/src/script/templates/PushDrop.ts

@@ -9,11 +9,7 @@ import {
 import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
 import { Transaction } from '../../transaction/index.js'
 import { WalletProtocol } from '../../wallet/Wallet.interfaces.js'
-
-function verifyTruthy<T>(v: T | undefined): T {
-  if (v == null) throw new Error('must have value')
-  return v
-}
+import { verifyNotNull } from '../../primitives/utils.js'
 
 /**
  * For a given piece of data to push onto the stack in script, creates the correct minimally-encoded script chunk,
@@ -71,7 +67,7 @@ export default class PushDrop implements ScriptTemplate {
     fields: number[][]
   } {
     const lockingPublicKey = PublicKey.fromString(
-      Utils.toHex(verifyTruthy(script.chunks[0].data)) // ✅ Ensure not undefined
+      Utils.toHex(verifyNotNull(script.chunks[0].data, 'script.chunks[0].data must have value'))
     )
 
     const fields: number[][] = []
@@ -249,7 +245,7 @@ export default class PushDrop implements ScriptTemplate {
 
         const preimage = TransactionSignature.format({
           sourceTXID,
-          sourceOutputIndex: verifyTruthy(input.sourceOutputIndex),
+          sourceOutputIndex: verifyNotNull(input.sourceOutputIndex, 'input.sourceOutputIndex must have value'),
           sourceSatoshis,
           transactionVersion: tx.version,
           otherInputs,

package/src/transaction/Beef.ts

@@ -2,14 +2,9 @@ import MerklePath from './MerklePath.js'
 import Transaction from './Transaction.js'
 import ChainTracker from './ChainTracker.js'
 import BeefTx from './BeefTx.js'
-import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
+import { Reader, Writer, toHex, toArray, verifyNotNull } from '../primitives/utils.js'
 import { hash256 } from '../primitives/Hash.js'
 
-function verifyTruthy<T> (v: T | undefined): T {
-  if (v == null) throw new Error('Expected a valid value, but got undefined.')
-  return v
-}
-
 export const BEEF_V1 = 4022206465 // 0100BEEF in LE order
 export const BEEF_V2 = 4022206466 // 0200BEEF in LE order
 export const ATOMIC_BEEF = 0x01010101 // 01010101
@@ -156,7 +151,7 @@ export class Beef {
 
     for (const i of beefTx.tx.inputs) {
       if (i.sourceTransaction == null) {
-        const itx = this.findTxid(verifyTruthy(i.sourceTXID)) // Ensure sourceTXID is valid
+        const itx = this.findTxid(verifyNotNull(i.sourceTXID, 'sourceTXID must be valid'))
         if (itx != null) {
           i.sourceTransaction = itx.tx
         }
@@ -185,7 +180,7 @@ export class Beef {
       } else {
         for (const i of tx.inputs) {
           if (i.sourceTransaction == null) {
-            const itx = beef.findTxid(verifyTruthy(i.sourceTXID)) // Ensure sourceTXID is valid
+            const itx = beef.findTxid(verifyNotNull(i.sourceTXID, 'sourceTXID must be valid'))
             if (itx != null) {
               i.sourceTransaction = itx.tx
             }
@@ -869,3 +864,5 @@ export class Beef {
     }
   }
 }
+
+export default Beef

package/src/transaction/Transaction.ts

@@ -618,7 +618,7 @@ export default class Transaction {
       const scriptBin = i.unlockingScript.toBinary()
       writer.writeVarIntNum(scriptBin.length)
       writer.write(scriptBin)
-      writer.writeUInt32LE(i.sequence ?? 0)
+      writer.writeUInt32LE(i.sequence ?? 0xffffffff) // default to max sequence
     }
     writer.writeVarIntNum(this.outputs.length)
     for (const o of this.outputs) {
@@ -659,7 +659,7 @@ export default class Transaction {
       const scriptBin = i.unlockingScript.toBinary()
       writer.writeVarIntNum(scriptBin.length)
       writer.write(scriptBin)
-      writer.writeUInt32LE(i.sequence ?? 0)
+      writer.writeUInt32LE(i.sequence ?? 0xffffffff) // default to max sequence
       writer.writeUInt64LE(
         i.sourceTransaction.outputs[i.sourceOutputIndex].satoshis ?? 0
       )
@@ -866,7 +866,7 @@ export default class Transaction {
           transactionVersion: tx.version,
           otherInputs,
           unlockingScript: input.unlockingScript,
-          inputSequence: input.sequence ?? 0,
+          inputSequence: input.sequence ?? 0xffffffff, // default to max sequence
           inputIndex: i,
           outputs: tx.outputs,
           lockTime: tx.lockTime,

package/src/wallet/WERR_INSUFFICIENT_FUNDS.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+export class WERR_INSUFFICIENT_FUNDS extends Error {
+  code: number
+  isError: boolean = true
+
+  /**
+   * @param totalSatoshisNeeded Total satoshis required to fund transactions after net of required inputs and outputs.
+   * @param moreSatoshisNeeded Shortfall on total satoshis required to fund transactions after net of required inputs and outputs.
+   */
+  constructor (
+    public totalSatoshisNeeded: number,
+    public moreSatoshisNeeded: number
+  ) {
+    super(`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.`)
+    this.code = 7
+    this.name = this.constructor.name
+  }
+}
+
+export default WERR_INSUFFICIENT_FUNDS

package/src/wallet/WERR_INVALID_PARAMETER.ts

@@ -0,0 +1,20 @@
+/**
+ * The ${parameter} parameter is invalid.
+ *
+ * This is an example of an error object with a custom property `parameter` and templated `message`.
+ */
+export class WERR_INVALID_PARAMETER extends Error {
+  code: number
+  isError: boolean = true
+
+  constructor (
+    public parameter: string,
+    mustBe?: string
+  ) {
+    super(`The ${parameter} parameter must be ${mustBe ?? 'valid.'}`)
+    this.code = 6
+    this.name = this.constructor.name
+  }
+}
+
+export default WERR_INVALID_PARAMETER

package/src/wallet/WalletClient.ts

@@ -41,6 +41,23 @@ import WalletWireTransceiver from './substrates/WalletWireTransceiver.js'
 import HTTPWalletWire from './substrates/HTTPWalletWire.js'
 import HTTPWalletJSON from './substrates/HTTPWalletJSON.js'
 import ReactNativeWebView from './substrates/ReactNativeWebView.js'
+import {
+  validateAbortActionArgs,
+  validateAcquireDirectCertificateArgs,
+  validateAcquireIssuanceCertificateArgs,
+  validateCreateActionArgs,
+  validateDiscoverByAttributesArgs,
+  validateDiscoverByIdentityKeyArgs,
+  validateInternalizeActionArgs,
+  validateListActionsArgs,
+  validateListCertificatesArgs,
+  validateListOutputsArgs,
+  validateProveCertificateArgs,
+  validateRelinquishCertificateArgs,
+  validateRelinquishOutputArgs,
+  validateSignActionArgs
+} from './validationHelpers.js'
+import { WERR_INVALID_PARAMETER } from './WERR_INVALID_PARAMETER.js'
 
 const MAX_XDM_RESPONSE_WAIT = 200
 
@@ -133,6 +150,7 @@ export default class WalletClient implements WalletInterface {
   }
 
   async createAction (args: CreateActionArgs): Promise<CreateActionResult> {
+    validateCreateActionArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).createAction(
       args,
@@ -141,6 +159,7 @@ export default class WalletClient implements WalletInterface {
   }
 
   async signAction (args: SignActionArgs): Promise<SignActionResult> {
+    validateSignActionArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).signAction(
       args,
@@ -151,6 +170,7 @@ export default class WalletClient implements WalletInterface {
   async abortAction (args: {
     reference: Base64String
   }): Promise<{ aborted: true }> {
+    validateAbortActionArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).abortAction(
       args,
@@ -159,6 +179,7 @@ export default class WalletClient implements WalletInterface {
   }
 
   async listActions (args: ListActionsArgs): Promise<ListActionsResult> {
+    validateListActionsArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).listActions(
       args,
@@ -169,6 +190,7 @@ export default class WalletClient implements WalletInterface {
   async internalizeAction (
     args: InternalizeActionArgs
   ): Promise<{ accepted: true }> {
+    validateInternalizeActionArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).internalizeAction(
       args,
@@ -177,6 +199,7 @@ export default class WalletClient implements WalletInterface {
   }
 
   async listOutputs (args: ListOutputsArgs): Promise<ListOutputsResult> {
+    validateListOutputsArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).listOutputs(
       args,
@@ -188,6 +211,7 @@ export default class WalletClient implements WalletInterface {
     basket: BasketStringUnder300Bytes
     output: OutpointString
   }): Promise<{ relinquished: true }> {
+    validateRelinquishOutputArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).relinquishOutput(
       args,
@@ -352,6 +376,7 @@ export default class WalletClient implements WalletInterface {
   async acquireCertificate (
     args: AcquireCertificateArgs
   ): Promise<AcquireCertificateResult> {
+    if (args.acquisitionProtocol === 'direct') { validateAcquireDirectCertificateArgs(args) } else if (args.acquisitionProtocol === 'issuance') { validateAcquireIssuanceCertificateArgs(args) } else { throw new WERR_INVALID_PARAMETER('acquisitionProtocol', `valid. ${String(args.acquisitionProtocol)} is unrecognized.`) }
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).acquireCertificate(
       args,
@@ -367,6 +392,7 @@ export default class WalletClient implements WalletInterface {
     privileged?: BooleanDefaultFalse
     privilegedReason?: DescriptionString5to50Bytes
   }): Promise<ListCertificatesResult> {
+    validateListCertificatesArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).listCertificates(
       args,
@@ -377,6 +403,7 @@ export default class WalletClient implements WalletInterface {
   async proveCertificate (
     args: ProveCertificateArgs
   ): Promise<ProveCertificateResult> {
+    validateProveCertificateArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).proveCertificate(
       args,
@@ -389,6 +416,7 @@ export default class WalletClient implements WalletInterface {
     serialNumber: Base64String
     certifier: PubKeyHex
   }): Promise<{ relinquished: true }> {
+    validateRelinquishCertificateArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).relinquishCertificate(
       args,
@@ -401,6 +429,7 @@ export default class WalletClient implements WalletInterface {
     limit?: PositiveIntegerDefault10Max10000
     offset?: PositiveIntegerOrZero
   }): Promise<DiscoverCertificatesResult> {
+    validateDiscoverByIdentityKeyArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).discoverByIdentityKey(
       args,
@@ -413,6 +442,7 @@ export default class WalletClient implements WalletInterface {
     limit?: PositiveIntegerDefault10Max10000
     offset?: PositiveIntegerOrZero
   }): Promise<DiscoverCertificatesResult> {
+    validateDiscoverByAttributesArgs(args)
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).discoverByAttributes(
       args,

package/src/wallet/WalletError.ts

@@ -13,6 +13,56 @@ export class WalletError extends Error {
       Error.captureStackTrace(this, this.constructor)
     }
   }
+
+  /**
+   * Safely serializes a WalletError (including special cases), Error or unknown error to JSON.
+   *
+   * Safely means avoiding deep, large, circular issues.
+   *
+   * Example deserialization can be found in HTTPWalletJSON.ts of bsv ts-sdk.
+   *
+   * @param error
+   * @returns stringified JSON representation of the error such that it can be deserialized to a WalletError.
+   */
+  static unknownToJson (error: any): string {
+    let e: any | undefined
+    if (typeof error.constructor.name === 'string' && String(error.constructor.name).startsWith('WERR_')) {
+      e = {
+        name: error.constructor.name,
+        message: error.message,
+        isError: true
+      }
+      if (e.name === 'WERR_REVIEW_ACTIONS') {
+        e.reviewActionResults = error.reviewActionResults
+        e.sendWithResults = error.sendWithResults
+        e.txid = error.txid
+        e.tx = error.tx
+        e.noSendChange = error.noSendChange
+        e.code = 5
+      } else if (e.name === 'WERR_INVALID_PARAMETER') {
+        e.parameter = error.parameter
+        e.code = 6
+      } else if (e.name === 'WERR_INSUFFICIENT_FUNDS') {
+        e.totalSatoshisNeeded = error.totalSatoshisNeeded
+        e.moreSatoshisNeeded = error.moreSatoshisNeeded
+        e.code = 7
+      }
+    } else if (error instanceof Error) {
+      e = {
+        name: error.constructor.name,
+        message: error.message,
+        isError: true
+      }
+    } else {
+      e = {
+        name: 'WERR_UNKNOWN',
+        message: String(error),
+        isError: true
+      }
+    }
+    const json = JSON.stringify(e)
+    return json
+  }
 }
 
 // NOTE: Enum values must not exceed the UInt8 range (0–255)
@@ -22,6 +72,8 @@ export enum walletErrors {
   invalidHmac = 3,
   invalidSignature = 4,
   reviewActions = 5,
+  invalidParameter = 6,
+  insufficientFunds = 7,
 }
 
 export type WalletErrorCode = keyof typeof walletErrors

package/src/wallet/__tests/WalletClient.test.ts

@@ -0,0 +1,31 @@
+import { CreateActionArgs } from '../Wallet.interfaces'
+import WalletClient from '../WalletClient'
+describe('WalletClient', () => {
+  it('0 createAction', async () => {
+    const wallet = new WalletClient('auto', '0.WalletClient.test')
+
+    async function testArgs(args: CreateActionArgs, parameter: string) {
+      try {
+        const r = await wallet.createAction(args)
+        expect(true).toBe(false)
+      } catch (e: any) {
+        expect(e.name).toBe('WERR_INVALID_PARAMETER')
+        expect(e.parameter).toBe(parameter)
+      }
+    }
+
+    const args: CreateActionArgs = {
+      description: 't' // too short to be valid
+    }
+    testArgs(args, 'description')
+    args.description = '12345'
+    args.outputs = [{
+      lockingScript: '',
+      satoshis: 0,
+      outputDescription: ''
+    }]
+    testArgs(args, 'lockingScript')
+    args.outputs[0].lockingScript = '1234'
+    testArgs(args, 'outputDescription')
+  })
+})

package/src/wallet/index.ts

@@ -6,5 +6,8 @@ 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 { default as WERR_INVALID_PARAMETER } from './WERR_INVALID_PARAMETER.js'
+export { default as WERR_INSUFFICIENT_FUNDS } from './WERR_INSUFFICIENT_FUNDS.js'
 export * from './WalletError.js'
+export * as Validation from './validationHelpers.js'
 export * from './substrates/index.js'

package/src/wallet/substrates/HTTPWalletJSON.ts

@@ -36,7 +36,9 @@ import {
   VersionString7To30Bytes,
 } from '../Wallet.interfaces.js'
 import { WERR_REVIEW_ACTIONS } from '../WERR_REVIEW_ACTIONS.js'
+import { WERR_INVALID_PARAMETER } from '../WERR_INVALID_PARAMETER.js'
 import { toOriginHeader } from './utils/toOriginHeader.js'
+import WERR_INSUFFICIENT_FUNDS from '../WERR_INSUFFICIENT_FUNDS.js'
 
 export default class HTTPWalletJSON implements WalletInterface {
   baseUrl: string
@@ -84,17 +86,25 @@ export default class HTTPWalletJSON implements WalletInterface {
 
       // Check the HTTP status on the original response
       if (!res.ok) {
-        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}`
+        if (res.status === 400 && data.isError) {
+          let err: any
+          switch (data.code) {
+            case 5:
+              err = new WERR_REVIEW_ACTIONS(data.reviewActionResults, data.sendWithResults, data.txid, data.tx, data.noSendChange); break;
+            case 6:
+              err = new WERR_INVALID_PARAMETER(data.parameter); err.message = data.message; break;
+            case 7:
+              err = new WERR_INSUFFICIENT_FUNDS(data.totalSatoshisNeeded, data.moreSatoshisNeeded); break;
+            default: break;
           }
-          throw new Error(JSON.stringify(err))
+          if (err) throw err
         }
+        const err = {
+          call,
+          args,
+          message: data.message ?? `HTTP Client error ${res.status}`
+        }
+        throw new Error(JSON.stringify(err))
       }
       return data
     }