@bsv/wallet-toolbox 1.7.1 → 1.7.2

package/src/__tests/WalletPermissionsManager.proxying.test.ts

@@ -74,98 +74,102 @@ describe('WalletPermissionsManager - Regression & Integration with Underlying Wa
    * ----------------------------------------------------------------------- */
 
   it('should pass createAction calls through, label them, handle metadata encryption, and check spending authorization', async () => {
-    // We'll mock the "netSpent" scenario to be >0 by returning some mock input & output satoshis from the signableTransaction.
-    // The underlying mock createAction returns a signableTransaction with tx = []
-    // We can stub out the mock so that the manager sees inputs/outputs with certain sat amounts.
-    // But we have to remember the manager is parsing the signableTransaction via fromAtomicBEEF(…).
-    // We'll control that by adjusting the mock signableTransaction in the underlying.
-
-    // let's set a custom signableTransaction that returns 500 sat in inputs, 1000 in outputs, and 100 in fee
-    underlying.createAction.mockResolvedValueOnce({
-      signableTransaction: {
-        // The manager calls Transaction.fromAtomicBEEF() on this
-        tx: [0xde, 0xad], // not used in detail, but let's just pass some array
-        reference: 'test-ref'
-      }
-    })
+    try {
+      // We'll mock the "netSpent" scenario to be >0 by returning some mock input & output satoshis from the signableTransaction.
+      // The underlying mock createAction returns a signableTransaction with tx = []
+      // We can stub out the mock so that the manager sees inputs/outputs with certain sat amounts.
+      // But we have to remember the manager is parsing the signableTransaction via fromAtomicBEEF(…).
+      // We'll control that by adjusting the mock signableTransaction in the underlying.
+
+      // let's set a custom signableTransaction that returns 500 sat in inputs, 1000 in outputs, and 100 in fee
+      underlying.createAction.mockResolvedValueOnce({
+        signableTransaction: {
+          // The manager calls Transaction.fromAtomicBEEF() on this
+          tx: [0xde, 0xad], // not used in detail, but let's just pass some array
+          reference: 'test-ref'
+        }
+      })
 
-    // We also need to configure the fromAtomicBEEF mock so it returns a transaction with the specified inputs/outputs
-    const mockTx = new MockTransaction()
-    mockTx.fee = 100
-    // We'll define exactly one input we consider "originator-provided" with 500 sat
-    mockTx.inputs = [
-      {
-        sourceTXID: 'aaa',
-        sourceOutputIndex: 0,
-        sourceTransaction: {
-          outputs: [{ satoshis: 500 }]
+      // We also need to configure the fromAtomicBEEF mock so it returns a transaction with the specified inputs/outputs
+      const mockTx = new MockTransaction()
+      mockTx.fee = 100
+      // We'll define exactly one input we consider "originator-provided" with 500 sat
+      mockTx.inputs = [
+        {
+          sourceTXID: 'aaa',
+          sourceOutputIndex: 0,
+          sourceTransaction: {
+            outputs: [{ satoshis: 500 }]
+          }
         }
-      }
-    ]
-    // We'll define 2 outputs. The manager will read the output amounts from the createAction call's "args.outputs" too,
-    // but we also set them here in case it cross-references them. We'll keep it consistent (2 outputs with total 1000).
-    mockTx.outputs = [{ satoshis: 600 }, { satoshis: 400 }]
+      ]
+      // We'll define 2 outputs. The manager will read the output amounts from the createAction call's "args.outputs" too,
+      // but we also set them here in case it cross-references them. We'll keep it consistent (2 outputs with total 1000).
+      mockTx.outputs = [{ satoshis: 600 }, { satoshis: 400 }]
 
-    // Now override fromAtomicBEEF to return our mockTx:
-    ;(MockedBSV_SDK.Transaction.fromAtomicBEEF as jest.Mock).mockReturnValue(mockTx)
+        // Now override fromAtomicBEEF to return our mockTx:
+        ; (MockedBSV_SDK.Transaction.fromAtomicBEEF as jest.Mock).mockReturnValue(mockTx)
 
-    // Attempt to create an action from a non-admin origin
-    await manager.createAction(
-      {
-        description: 'User purchase',
-        inputs: [
-          {
-            outpoint: 'aaa.0',
-            unlockingScriptLength: 73,
-            inputDescription: 'My input'
-          }
-        ],
-        outputs: [
-          {
-            lockingScript: '00abcd',
-            satoshis: 1000,
-            outputDescription: 'Purchase output',
-            basket: 'my-basket'
-          }
-        ],
-        labels: ['user-label', 'something-else']
-      },
-      'shop.example.com'
-    )
+      // Attempt to create an action from a non-admin origin
+      await manager.createAction(
+        {
+          description: 'User purchase',
+          inputs: [
+            {
+              outpoint: 'aaa.0',
+              unlockingScriptLength: 73,
+              inputDescription: 'My input'
+            }
+          ],
+          outputs: [
+            {
+              lockingScript: '00abcd',
+              satoshis: 1000,
+              outputDescription: 'Purchase output',
+              basket: 'my-basket'
+            }
+          ],
+          labels: ['user-label', 'something-else']
+        },
+        'shop.example.com'
+      )
 
-    // The manager should have:
-    // 1) Called underlying.createAction
-    // 2) Inserted "admin originator shop.example.com" & "admin month YYYY-MM" into labels
-    // 3) Encrypted the metadata fields (description, inputDescription, outputDescription)
-    // 4) Ensured we needed spending permission for netSpent= (1000 + fee100) - 500 = 600
-    //    The onSpendingAuthorizationRequested callback ephemeral-granted it.
-    expect(underlying.createAction).toHaveBeenCalledTimes(1)
-    const callArgs = underlying.createAction.mock.calls[0][0]
-    expect(callArgs.labels).toContain('admin originator shop.example.com')
-    expect(callArgs.labels).toEqual(
-      expect.arrayContaining([
-        expect.stringContaining('admin month'),
-        'user-label',
-        'something-else',
-        'admin originator shop.example.com'
-      ])
-    )
-    // Confirm the metadata was replaced with some ciphertext array in createAction call
-    expect(callArgs.description).not.toBe('User purchase') // manager encrypts it
-    if (callArgs.inputs[0].inputDescription) {
-      expect(callArgs.inputs[0].inputDescription).not.toBe('My input')
-    }
-    if (callArgs.outputs[0].outputDescription) {
-      expect(callArgs.outputs[0].outputDescription).not.toBe('Purchase output')
-    }
+      // The manager should have:
+      // 1) Called underlying.createAction
+      // 2) Inserted "admin originator shop.example.com" & "admin month YYYY-MM" into labels
+      // 3) Encrypted the metadata fields (description, inputDescription, outputDescription)
+      // 4) Ensured we needed spending permission for netSpent= (1000 + fee100) - 500 = 600
+      //    The onSpendingAuthorizationRequested callback ephemeral-granted it.
+      expect(underlying.createAction).toHaveBeenCalledTimes(1)
+      const callArgs = underlying.createAction.mock.calls[0][0]
+      expect(callArgs.labels).toContain('admin originator shop.example.com')
+      expect(callArgs.labels).toEqual(
+        expect.arrayContaining([
+          expect.stringContaining('admin month'),
+          'user-label',
+          'something-else',
+          'admin originator shop.example.com'
+        ])
+      )
+      // Confirm the metadata was replaced with some ciphertext array in createAction call
+      expect(callArgs.description).not.toBe('User purchase') // manager encrypts it
+      if (callArgs.inputs[0].inputDescription) {
+        expect(callArgs.inputs[0].inputDescription).not.toBe('My input')
+      }
+      if (callArgs.outputs[0].outputDescription) {
+        expect(callArgs.outputs[0].outputDescription).not.toBe('Purchase output')
+      }
 
-    // Also confirm we set signAndProcess to false if origin is non-admin
-    expect(callArgs.options.signAndProcess).toBe(false)
+      // Also confirm we set signAndProcess to false if origin is non-admin
+      expect(callArgs.options.signAndProcess).toBe(false)
 
-    // The manager will parse the resulting signableTransaction, see netSpent=600, and request spending permission.
-    // Our callback ephemeral-granted.  So everything should proceed with no error.
-    // The manager returns the partial result from underlying
-    // We don't have a final sign call from the manager because signAndProcess is forcibly false.
+      // The manager will parse the resulting signableTransaction, see netSpent=600, and request spending permission.
+      // Our callback ephemeral-granted.  So everything should proceed with no error.
+      // The manager returns the partial result from underlying
+      // We don't have a final sign call from the manager because signAndProcess is forcibly false.
+    } catch (eu) {
+      expect(true).toBe(false)
+    }
   })
 
   it('should abort the action if spending permission is denied', async () => {

package/src/sdk/WERR_errors.ts

@@ -64,7 +64,7 @@ export class WERR_INVALID_PARAMETER extends WalletError {
 
 /**
  * Invalid merkleRoot ${merkleRoot} for block ${blockHash} at height ${blockHeight}${txid ? ` for txid ${txid}` : ''}.
- * 
+ *
  * Typically thrown when a chain tracker fails to validate a merkle root.
  */
 export class WERR_INVALID_MERKLE_ROOT extends WalletError {
@@ -72,9 +72,12 @@ export class WERR_INVALID_MERKLE_ROOT extends WalletError {
     public blockHash: string,
     public blockHeight: number,
     public merkleRoot: string,
-    public txid?: string,
+    public txid?: string
   ) {
-    super('WERR_INVALID_MERKLE_ROOT', `Invalid merkleRoot ${merkleRoot} for block ${blockHash} at height ${blockHeight}${txid ? ` for txid ${txid}` : ''}.`)
+    super(
+      'WERR_INVALID_MERKLE_ROOT',
+      `Invalid merkleRoot ${merkleRoot} for block ${blockHash} at height ${blockHeight}${txid ? ` for txid ${txid}` : ''}.`
+    )
   }
   override toJson(): string {
     const obj = JSON.parse(super.toJson())

package/src/sdk/WalletError.ts

@@ -156,9 +156,6 @@ export class WalletError extends Error implements WalletErrorObject {
       t === 'object' && error !== null && typeof (error as any).toJson === 'function'
         ? (error as any).toJson
         : undefined
-    console.log(
-      `WalletError.unknownToJson: error type=${t} ctor=${ctor} name=${name} message=${message} hasToJson=${toJson ? 'yes' : 'no'}`
-    )
     if (ctor && ctor.startsWith('WERR_') && toJson !== undefined) {
       json = (error as WalletError).toJson()
     } else if (name && message) {
@@ -168,7 +165,6 @@ export class WalletError extends Error implements WalletErrorObject {
       e = new WalletError('WERR_UNKNOWN', String(error))
       json = e.toJson()
     }
-    console.log(`WalletError.unknownToJson: json=${json}`)
     return json
   }
 }

package/src/sdk/WalletServices.interfaces.ts

@@ -1,4 +1,11 @@
-import { ArcConfig, Beef, Transaction as BsvTransaction, ChainTracker, MerklePath } from '@bsv/sdk'
+import {
+  ArcConfig,
+  Beef,
+  Transaction as BsvTransaction,
+  ChainTracker,
+  MerklePath,
+  WalletLoggerInterface
+} from '@bsv/sdk'
 import { Chain, ReqHistoryNote } from './types'
 import { WalletError } from './WalletError'
 import { TableOutput } from '../storage/schema/tables/TableOutput'
@@ -92,7 +99,7 @@ export interface WalletServices {
    * @param chain
    * @returns
    */
-  postBeef(beef: Beef, txids: string[]): Promise<PostBeefResult[]>
+  postBeef(beef: Beef, txids: string[], logger?: WalletLoggerInterface): Promise<PostBeefResult[]>
 
   /**
    * @param script Output script to be hashed for `getUtxoStatus` default `outputFormat`
@@ -143,7 +150,11 @@ export interface WalletServices {
     useNext?: boolean
   ): Promise<GetUtxoStatusResult>
 
-  getScriptHashHistory(hash: string, useNext?: boolean): Promise<GetScriptHashHistoryResult>
+  getScriptHashHistory(
+    hash: string,
+    useNext?: boolean,
+    logger?: WalletLoggerInterface
+  ): Promise<GetScriptHashHistoryResult>
 
   /**
    * @returns a block header

package/src/sdk/WalletStorage.interfaces.ts

@@ -13,7 +13,9 @@ import {
   RelinquishCertificateArgs,
   RelinquishOutputArgs,
   SendWithResult,
-  TXIDHexString
+  TXIDHexString,
+  Validation,
+  WalletLoggerInterface
 } from '@bsv/sdk'
 import {
   TableCertificate,
@@ -35,13 +37,6 @@ import {
   TableUser
 } from '../storage/schema/tables'
 import { WalletServices } from './WalletServices.interfaces'
-import {
-  ValidCreateActionArgs,
-  ValidCreateActionOutput,
-  ValidListActionsArgs,
-  ValidListCertificatesArgs,
-  ValidListOutputsArgs
-} from './validationHelpers'
 import { Chain, Paged, ProvenTxReqStatus, TransactionStatus } from './types'
 import { WalletError } from './WalletError'
 
@@ -72,7 +67,7 @@ export interface WalletStorage {
   findOrInsertUser(identityKey: string): Promise<{ user: TableUser; isNew: boolean }>
 
   abortAction(args: AbortActionArgs): Promise<AbortActionResult>
-  createAction(args: ValidCreateActionArgs): Promise<StorageCreateActionResult>
+  createAction(args: Validation.ValidCreateActionArgs): Promise<StorageCreateActionResult>
   processAction(args: StorageProcessActionArgs): Promise<StorageProcessActionResults>
   internalizeAction(args: InternalizeActionArgs): Promise<InternalizeActionResult>
 
@@ -82,7 +77,7 @@ export interface WalletStorage {
   findProvenTxReqs(args: FindProvenTxReqsArgs): Promise<TableProvenTxReq[]>
 
   listActions(args: ListActionsArgs): Promise<ListActionsResult>
-  listCertificates(args: ValidListCertificatesArgs): Promise<ListCertificatesResult>
+  listCertificates(args: Validation.ValidListCertificatesArgs): Promise<ListCertificatesResult>
   listOutputs(args: ListOutputsArgs): Promise<ListOutputsResult>
 
   insertCertificate(certificate: TableCertificateX): Promise<number>
@@ -154,7 +149,7 @@ export interface WalletStorageWriter extends WalletStorageReader {
   findOrInsertUser(identityKey: string): Promise<{ user: TableUser; isNew: boolean }>
 
   abortAction(auth: AuthId, args: AbortActionArgs): Promise<AbortActionResult>
-  createAction(auth: AuthId, args: ValidCreateActionArgs): Promise<StorageCreateActionResult>
+  createAction(auth: AuthId, args: Validation.ValidCreateActionArgs): Promise<StorageCreateActionResult>
   processAction(auth: AuthId, args: StorageProcessActionArgs): Promise<StorageProcessActionResults>
   internalizeAction(auth: AuthId, args: InternalizeActionArgs): Promise<StorageInternalizeActionResult>
 
@@ -175,9 +170,9 @@ export interface WalletStorageReader {
   findOutputsAuth(auth: AuthId, args: FindOutputsArgs): Promise<TableOutput[]>
   findProvenTxReqs(args: FindProvenTxReqsArgs): Promise<TableProvenTxReq[]>
 
-  listActions(auth: AuthId, vargs: ValidListActionsArgs): Promise<ListActionsResult>
-  listCertificates(auth: AuthId, vargs: ValidListCertificatesArgs): Promise<ListCertificatesResult>
-  listOutputs(auth: AuthId, vargs: ValidListOutputsArgs): Promise<ListOutputsResult>
+  listActions(auth: AuthId, vargs: Validation.ValidListActionsArgs): Promise<ListActionsResult>
+  listCertificates(auth: AuthId, vargs: Validation.ValidListCertificatesArgs): Promise<ListCertificatesResult>
+  listOutputs(auth: AuthId, vargs: Validation.ValidListOutputsArgs): Promise<ListOutputsResult>
 }
 
 export interface AuthId {
@@ -243,7 +238,7 @@ export interface StorageCreateTransactionSdkInput {
   senderIdentityKey?: string
 }
 
-export interface StorageCreateTransactionSdkOutput extends ValidCreateActionOutput {
+export interface StorageCreateTransactionSdkOutput extends Validation.ValidCreateActionOutput {
   vout: number
   providedBy: StorageProvidedBy
   purpose?: string
@@ -270,7 +265,7 @@ export interface StorageProcessActionArgs {
   txid?: string
   rawTx?: number[]
   sendWith: string[]
-  log?: string
+  logger?: WalletLoggerInterface
 }
 
 export interface StorageInternalizeActionResult extends InternalizeActionResult {

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

@@ -1,22 +1,21 @@
-import { Utils } from '@bsv/sdk'
-import { validateBase64String } from '../validationHelpers'
+import { Utils, Validation as V } from '@bsv/sdk'
 describe('validationHelpers tests', () => {
   jest.setTimeout(99999999)
 
   test('0 validateBase64String', async () => {
     const validB64 = 'SGVsbG8gV29ybGQh' // "Hello World!"
 
-    const s = validateBase64String(validB64, 'testParam', 1, 20)
+    const s = V.validateBase64String(validB64, 'testParam', 1, 20)
     expect(s).toBe(validB64)
 
     {
       const invalidB64 = 'SGVsbG8g29ybGQh'
-      expect(() => validateBase64String(invalidB64, 'testParam', 1, 20)).toThrow()
+      expect(() => V.validateBase64String(invalidB64, 'testParam', 1, 20)).toThrow()
     }
 
     {
       const invalidB64 = 'SGVsbG8gV29ybGQh='
-      expect(() => validateBase64String(invalidB64, 'testParam', 1, 20)).toThrow()
+      expect(() => V.validateBase64String(invalidB64, 'testParam', 1, 20)).toThrow()
     }
   })
 })

package/src/sdk/index.ts

@@ -3,7 +3,7 @@ export * from './WalletErrorFromJson'
 export * from './WalletSigner.interfaces'
 export * from './WalletStorage.interfaces'
 export * from './WERR_errors'
-export * from './validationHelpers'
+export { Validation } from '@bsv/sdk'
 export * from './CertOpsWallet'
 export * from './types'
 export * from './WalletServices.interfaces'

package/src/services/Services.ts

@@ -1,4 +1,4 @@
-import { Transaction as BsvTransaction, Beef, ChainTracker, Utils } from '@bsv/sdk'
+import { Transaction as BsvTransaction, Beef, ChainTracker, Utils, WalletLoggerInterface } from '@bsv/sdk'
 import { ServiceCollection, ServiceToCall } from './ServiceCollection'
 import { createDefaultWalletServicesOptions } from './createDefaultWalletServicesOptions'
 import { WhatsOnChain } from './providers/WhatsOnChain'
@@ -216,7 +216,8 @@ export class Services implements WalletServices {
     output: string,
     outputFormat?: GetUtxoStatusOutputFormat,
     outpoint?: string,
-    useNext?: boolean
+    useNext?: boolean,
+    logger?: WalletLoggerInterface
   ): Promise<GetUtxoStatusResult> {
     const services = this.getUtxoStatusServices
     if (useNext) services.next()
@@ -228,11 +229,13 @@ export class Services implements WalletServices {
       details: []
     }
 
+    logger?.group(`services getUtxoStatus`)
     for (let retry = 0; retry < 2; retry++) {
       for (let tries = 0; tries < services.count; tries++) {
         const stc = services.serviceToCall
         try {
           const r = await stc.service(output, outputFormat, outpoint)
+          logger?.log(`${stc.providerName} status ${r.status}`)
           if (r.status === 'success') {
             services.addServiceCallSuccess(stc)
             r0 = r
@@ -250,10 +253,15 @@ export class Services implements WalletServices {
       if (r0.status === 'success') break
       await wait(2000)
     }
+    logger?.groupEnd()
     return r0
   }
 
-  async getScriptHashHistory(hash: string, useNext?: boolean): Promise<GetScriptHashHistoryResult> {
+  async getScriptHashHistory(
+    hash: string,
+    useNext?: boolean,
+    logger?: WalletLoggerInterface
+  ): Promise<GetScriptHashHistoryResult> {
     const services = this.getScriptHashHistoryServices
     if (useNext) services.next()
 
@@ -264,10 +272,12 @@ export class Services implements WalletServices {
       history: []
     }
 
+    logger?.group(`services getScriptHashHistory`)
     for (let tries = 0; tries < services.count; tries++) {
       const stc = services.serviceToCall
       try {
         const r = await stc.service(hash)
+        logger?.log(`${stc.providerName} status ${r.status}`)
         if (r.status === 'success') {
           r0 = r
           break
@@ -281,6 +291,7 @@ export class Services implements WalletServices {
       }
       services.next()
     }
+    logger?.groupEnd()
     return r0
   }
 
@@ -292,15 +303,17 @@ export class Services implements WalletServices {
    * @param chain
    * @returns
    */
-  async postBeef(beef: Beef, txids: string[]): Promise<PostBeefResult[]> {
+  async postBeef(beef: Beef, txids: string[], logger?: WalletLoggerInterface): Promise<PostBeefResult[]> {
     let rs: PostBeefResult[] = []
     const services = this.postBeefServices
     const stcs = services.allServicesToCall
+    logger?.group(`services postBeef`)
     switch (this.postBeefMode) {
       case 'UntilSuccess':
         {
           for (const stc of stcs) {
             const r = await callService(stc)
+            logger?.log(`${stc.providerName} status ${r.status}`)
             rs.push(r)
             if (r.status === 'success') break
             if (r.txidResults && r.txidResults.every(txr => txr.serviceError)) {
@@ -321,6 +334,7 @@ export class Services implements WalletServices {
         }
         break
     }
+    logger?.groupEnd()
     return rs
 
     async function callService(stc: ServiceToCall<PostBeefService>) {
@@ -423,12 +437,13 @@ export class Services implements WalletServices {
     return header
   }
 
-  async getMerklePath(txid: string, useNext?: boolean): Promise<GetMerklePathResult> {
+  async getMerklePath(txid: string, useNext?: boolean, logger?: WalletLoggerInterface): Promise<GetMerklePathResult> {
     const services = this.getMerklePathServices
     if (useNext) services.next()
 
     const r0: GetMerklePathResult = { notes: [] }
 
+    logger?.group(`services getMerklePath`)
     for (let tries = 0; tries < services.count; tries++) {
       const stc = services.serviceToCall
       try {
@@ -436,6 +451,7 @@ export class Services implements WalletServices {
         if (r.notes) r0.notes!.push(...r.notes)
         if (!r0.name) r0.name = r.name
         if (r.merklePath) {
+          logger?.log(`${stc.providerName} has merklePath`)
           // If we have a proof, call it done.
           r0.merklePath = r.merklePath
           r0.header = r.header
@@ -443,6 +459,8 @@ export class Services implements WalletServices {
           r0.error = undefined
           services.addServiceCallSuccess(stc)
           break
+        } else {
+          logger?.log(`${stc.providerName} no merklePath`)
         }
 
         if (r.error) services.addServiceCallError(stc, r.error)

package/src/services/providers/WhatsOnChain.ts

@@ -1,4 +1,4 @@
-import { Beef, HexString, Utils, WhatsOnChainConfig } from '@bsv/sdk'
+import { Beef, HexString, Utils, WhatsOnChainConfig, Validation } from '@bsv/sdk'
 import { convertProofToMerklePath } from '../../utility/tscProofToMerklePath'
 import SdkWhatsOnChain from './SdkWhatsOnChain'
 import { Chain, ReqHistoryNote } from '../../sdk/types'
@@ -20,7 +20,6 @@ import { WalletError } from '../../sdk/WalletError'
 import { doubleSha256BE, wait } from '../../utility/utilityHelpers'
 import { asArray, asString } from '../../utility/utilityHelpers.noBuffer'
 import { Services, validateScriptHash } from '../Services'
-import { parseWalletOutpoint } from '../../sdk/validationHelpers'
 
 export class WhatsOnChainNoServices extends SdkWhatsOnChain {
   constructor(chain: Chain = 'main', config: WhatsOnChainConfig = {}) {
@@ -405,7 +404,7 @@ export class WhatsOnChainNoServices extends SdkWhatsOnChain {
             })
           }
           if (outpoint) {
-            const { txid, vout } = parseWalletOutpoint(outpoint)
+            const { txid, vout } = Validation.parseWalletOutpoint(outpoint)
             r.isUtxo = r.details.find(d => d.txid === txid && d.index === vout) !== undefined
           } else r.isUtxo = r.details.length > 0
         }

package/src/services/providers/getBeefForTxid.ts

@@ -1,12 +1,10 @@
-import { Beef, ListActionsResult, ListOutputsResult } from '@bsv/sdk'
+import { Beef, ListActionsResult, ListOutputsResult, Validation } from '@bsv/sdk'
 import {
   TrxToken,
   PurgeParams,
   PurgeResults,
   ProvenOrRawTx,
   AuthId,
-  ValidListActionsArgs,
-  ValidListOutputsArgs,
   FindCertificatesArgs,
   FindOutputBasketsArgs,
   FindOutputsArgs,
@@ -114,10 +112,10 @@ class ServicesOnlyStorageProvider extends StorageProvider {
   override getTagsForOutputId(outputId: number, trx?: TrxToken): Promise<TableOutputTag[]> {
     throw this.nip
   }
-  override listActions(auth: AuthId, args: ValidListActionsArgs): Promise<ListActionsResult> {
+  override listActions(auth: AuthId, args: Validation.ValidListActionsArgs): Promise<ListActionsResult> {
     throw this.nip
   }
-  override listOutputs(auth: AuthId, args: ValidListOutputsArgs): Promise<ListOutputsResult> {
+  override listOutputs(auth: AuthId, args: Validation.ValidListOutputsArgs): Promise<ListOutputsResult> {
     throw this.nip
   }
   override countChangeInputs(userId: number, basketId: number, excludeSending: boolean): Promise<number> {

package/src/signer/methods/acquireDirectCertificate.ts

@@ -1,13 +1,12 @@
-import { AcquireCertificateResult } from '@bsv/sdk'
+import { AcquireCertificateResult, Validation } from '@bsv/sdk'
 import { Wallet } from '../../Wallet'
 import { AuthId } from '../../sdk/WalletStorage.interfaces'
-import { ValidAcquireDirectCertificateArgs } from '../../sdk/validationHelpers'
 import { TableCertificateX } from '../../storage/schema/tables/TableCertificate'
 
 export async function acquireDirectCertificate(
   wallet: Wallet,
   auth: AuthId,
-  vargs: ValidAcquireDirectCertificateArgs
+  vargs: Validation.ValidAcquireDirectCertificateArgs
 ): Promise<AcquireCertificateResult> {
   const now = new Date()
   const newCert: TableCertificateX = {

package/src/signer/methods/buildSignableTransaction.ts

@@ -1,11 +1,10 @@
-import { Beef, Script, Transaction, TransactionInput, TransactionOutput } from '@bsv/sdk'
+import { Beef, Script, Transaction, TransactionInput, TransactionOutput, Validation } from '@bsv/sdk'
 import { Wallet, PendingStorageInput } from '../../Wallet'
 import {
   StorageCreateActionResult,
   StorageCreateTransactionSdkInput,
   StorageCreateTransactionSdkOutput
 } from '../../sdk/WalletStorage.interfaces'
-import { validateSatoshis, ValidCreateActionArgs, ValidCreateActionInput } from '../../sdk/validationHelpers'
 import { WERR_INVALID_PARAMETER } from '../../sdk/WERR_errors'
 import { asBsvSdkScript, verifyTruthy } from '../../utility/utilityHelpers'
 import { KeyPair } from '../../sdk/types'
@@ -13,7 +12,7 @@ import { ScriptTemplateBRC29 } from '../../utility/ScriptTemplateBRC29'
 
 export function buildSignableTransaction(
   dctr: StorageCreateActionResult,
-  args: ValidCreateActionArgs,
+  args: Validation.ValidCreateActionArgs,
   wallet: Wallet
 ): {
   tx: Transaction
@@ -78,7 +77,7 @@ export function buildSignableTransaction(
   // Merge and sort INPUTS info by vin order.
   /////////////
   const inputs: {
-    argsInput: ValidCreateActionInput | undefined
+    argsInput: Validation.ValidCreateActionInput | undefined
     storageInput: StorageCreateTransactionSdkInput
   }[] = []
   for (const storageInput of storageInputs) {
@@ -143,7 +142,7 @@ export function buildSignableTransaction(
         sequence: 0xffffffff
       }
       tx.addInput(inputToAdd)
-      totalChangeInputs += validateSatoshis(storageInput.sourceSatoshis, 'storageInput.sourceSatoshis')
+      totalChangeInputs += Validation.validateSatoshis(storageInput.sourceSatoshis, 'storageInput.sourceSatoshis')
     }
   }
 
@@ -168,7 +167,7 @@ export function buildSignableTransaction(
 export function makeChangeLock(
   out: StorageCreateTransactionSdkOutput,
   dctr: StorageCreateActionResult,
-  args: ValidCreateActionArgs,
+  args: Validation.ValidCreateActionArgs,
   changeKeys: KeyPair,
   wallet: Wallet
 ): Script {