@bsv/wallet-toolbox 1.7.1 → 1.7.2

package/src/signer/methods/createAction.ts

@@ -7,24 +7,19 @@ import {
   SignableTransaction,
   TXIDHexString,
   Script,
-  Transaction
+  Transaction,
+  Validation
 } from '@bsv/sdk'
 import { buildSignableTransaction } from './buildSignableTransaction'
 import {
   AuthId,
   ReviewActionResult,
-  StorageCreateActionResult,
-  StorageCreateTransactionSdkOutput,
   StorageProcessActionArgs,
   StorageProcessActionResults
 } from '../../sdk/WalletStorage.interfaces'
 import { completeSignedTransaction, verifyUnlockScripts } from './completeSignedTransaction'
 import { PendingSignAction, Wallet } from '../../Wallet'
-import { ValidCreateActionArgs, ValidCreateActionInput, ValidProcessActionArgs } from '../../sdk/validationHelpers'
 import { WERR_INTERNAL } from '../../sdk/WERR_errors'
-import { KeyPair } from '../../sdk/types'
-import { verifyTruthy } from '../../utility/utilityHelpers'
-import { ScriptTemplateBRC29 } from '../../utility/ScriptTemplateBRC29'
 
 export interface CreateActionResultX extends CreateActionResult {
   txid?: TXIDHexString
@@ -38,33 +33,41 @@ export interface CreateActionResultX extends CreateActionResult {
 export async function createAction(
   wallet: Wallet,
   auth: AuthId,
-  vargs: ValidCreateActionArgs
+  vargs: Validation.ValidCreateActionArgs
 ): Promise<CreateActionResultX> {
   const r: CreateActionResultX = {}
+  const logger = vargs.logger
 
   let prior: PendingSignAction | undefined = undefined
 
   if (vargs.isNewTx || vargs.isTestWerrReviewActions) {
     prior = await createNewTx(wallet, vargs)
+    logger?.log('created new transaction')
 
     if (vargs.isSignAction) {
-      return makeSignableTransactionResult(prior, wallet, vargs)
+      const r = makeSignableTransactionResult(prior, wallet, vargs)
+      logger?.log('created signable transaction result')
+      return r
     }
 
     prior.tx = await completeSignedTransaction(prior, {}, wallet)
+    logger?.log('completed signed transaction')
 
     r.txid = prior.tx.id('hex')
     const beef = new Beef()
     if (prior.dcr.inputBeef) beef.mergeBeef(prior.dcr.inputBeef)
     beef.mergeTransaction(prior.tx)
+    logger?.log('merged beef')
 
     verifyUnlockScripts(r.txid, beef)
+    logger?.log('verified unlock scripts')
 
     r.noSendChange = prior.dcr.noSendChangeOutputVouts?.map(vout => `${r.txid}.${vout}`)
     if (!vargs.options.returnTXIDOnly) r.tx = beef.toBinaryAtomic(r.txid)
   }
 
   const { sendWithResults, notDelayedResults } = await processAction(prior, wallet, auth, vargs)
+  logger?.log('processed transaction')
 
   r.sendWithResults = sendWithResults
   r.notDelayedResults = notDelayedResults
@@ -72,15 +75,17 @@ export async function createAction(
   return r
 }
 
-async function createNewTx(wallet: Wallet, args: ValidCreateActionArgs): Promise<PendingSignAction> {
-  const storageArgs = removeUnlockScripts(args)
+async function createNewTx(wallet: Wallet, vargs: Validation.ValidCreateActionArgs): Promise<PendingSignAction> {
+  const logger = vargs.logger
+  const storageArgs = removeUnlockScripts(vargs)
   const dcr = await wallet.storage.createAction(storageArgs)
 
   const reference = dcr.reference
 
-  const { tx, amount, pdi } = buildSignableTransaction(dcr, args, wallet)
+  const { tx, amount, pdi } = buildSignableTransaction(dcr, vargs, wallet)
+  logger?.log('built signable transaction')
 
-  const prior: PendingSignAction = { reference, dcr, args, amount, tx, pdi }
+  const prior: PendingSignAction = { reference, dcr, args: vargs, amount, tx, pdi }
 
   return prior
 }
@@ -88,7 +93,7 @@ async function createNewTx(wallet: Wallet, args: ValidCreateActionArgs): Promise
 function makeSignableTransactionResult(
   prior: PendingSignAction,
   wallet: Wallet,
-  args: ValidCreateActionArgs
+  args: Validation.ValidCreateActionArgs
 ): CreateActionResult {
   if (!prior.dcr.inputBeef) throw new WERR_INTERNAL('prior.dcr.inputBeef must be valid')
 
@@ -120,13 +125,13 @@ function makeSignableTransactionBeef(tx: Transaction, inputBEEF: number[]): numb
   return beef.toBinaryAtomic(tx.id('hex'))
 }
 
-function removeUnlockScripts(args: ValidCreateActionArgs) {
+function removeUnlockScripts(args: Validation.ValidCreateActionArgs) {
   let storageArgs = args
   if (!storageArgs.inputs.every(i => i.unlockingScript === undefined)) {
     // Never send unlocking scripts to storage, all it needs is the script length.
     storageArgs = { ...args, inputs: [] }
     for (const i of args.inputs) {
-      const di: ValidCreateActionInput = {
+      const di: Validation.ValidCreateActionInput = {
         ...i,
         unlockingScriptLength: i.unlockingScript !== undefined ? i.unlockingScript.length : i.unlockingScriptLength
       }
@@ -141,7 +146,7 @@ export async function processAction(
   prior: PendingSignAction | undefined,
   wallet: Wallet,
   auth: AuthId,
-  vargs: ValidProcessActionArgs
+  vargs: Validation.ValidProcessActionArgs
 ): Promise<StorageProcessActionResults> {
   const args: StorageProcessActionArgs = {
     isNewTx: vargs.isNewTx,
@@ -151,7 +156,8 @@ export async function processAction(
     reference: prior ? prior.reference : undefined,
     txid: prior ? prior.tx.id('hex') : undefined,
     rawTx: prior ? prior.tx.toBinary() : undefined,
-    sendWith: vargs.isSendWith ? vargs.options.sendWith : []
+    sendWith: vargs.isSendWith ? vargs.options.sendWith : [],
+    logger: vargs.logger
   }
   const r: StorageProcessActionResults = await wallet.storage.processAction(args)
 

package/src/signer/methods/internalizeAction.ts

@@ -1,7 +1,6 @@
-import { Beef, InternalizeActionArgs, InternalizeOutput, P2PKH, WalletProtocol } from '@bsv/sdk'
+import { Beef, InternalizeActionArgs, InternalizeOutput, P2PKH, WalletProtocol, Validation } from '@bsv/sdk'
 import { Wallet } from '../../Wallet'
 import { AuthId, StorageInternalizeActionResult } from '../../sdk/WalletStorage.interfaces'
-import { validateInternalizeActionArgs, ValidInternalizeActionArgs } from '../../sdk/validationHelpers'
 import { WERR_INTERNAL, WERR_INVALID_PARAMETER } from '../../sdk/WERR_errors'
 
 /**
@@ -36,7 +35,7 @@ export async function internalizeAction(
   auth: AuthId,
   args: InternalizeActionArgs
 ): Promise<StorageInternalizeActionResult> {
-  const vargs = validateInternalizeActionArgs(args)
+  const vargs = Validation.validateInternalizeActionArgs(args)
 
   const { ab, tx, txid } = await validateAtomicBeef()
   const brc29ProtocolID: WalletProtocol = [2, '3241645161d8']
@@ -60,7 +59,7 @@ export async function internalizeAction(
 
   return r
 
-  function setupWalletPaymentForOutput(o: InternalizeOutput, dargs: ValidInternalizeActionArgs) {
+  function setupWalletPaymentForOutput(o: InternalizeOutput, dargs: Validation.ValidInternalizeActionArgs) {
     const p = o.paymentRemittance
     const output = tx.outputs[o.outputIndex]
     if (!p) throw new WERR_INVALID_PARAMETER('paymentRemittance', `valid for protocol ${o.protocol}`)
@@ -73,7 +72,7 @@ export async function internalizeAction(
       throw new WERR_INVALID_PARAMETER('paymentRemittance', `locked by script conforming to BRC-29`)
   }
 
-  function setupBasketInsertionForOutput(o: InternalizeOutput, dargs: ValidInternalizeActionArgs) {
+  function setupBasketInsertionForOutput(o: InternalizeOutput, dargs: Validation.ValidInternalizeActionArgs) {
     /*
     No additional validations...
     */

package/src/signer/methods/proveCertificate.ts

@@ -1,15 +1,14 @@
-import { MasterCertificate, ProveCertificateResult } from '@bsv/sdk'
+import { MasterCertificate, ProveCertificateResult, Validation } from '@bsv/sdk'
 import { Wallet } from '../../Wallet'
 import { WERR_INVALID_PARAMETER } from '../../sdk/WERR_errors'
-import { ValidListCertificatesArgs, ValidProveCertificateArgs } from '../../sdk/validationHelpers'
 import { AuthId } from '../../sdk/WalletStorage.interfaces'
 
 export async function proveCertificate(
   wallet: Wallet,
   auth: AuthId,
-  vargs: ValidProveCertificateArgs
+  vargs: Validation.ValidProveCertificateArgs
 ): Promise<ProveCertificateResult> {
-  const lcargs: ValidListCertificatesArgs = {
+  const lcargs: Validation.ValidListCertificatesArgs = {
     partial: {
       type: vargs.type,
       serialNumber: vargs.serialNumber,

package/src/signer/methods/signAction.ts

@@ -1,10 +1,9 @@
-import { AtomicBEEF, Beef, SendWithResult, SignActionArgs, SignActionResult, TXIDHexString } from '@bsv/sdk'
+import { AtomicBEEF, Beef, SendWithResult, SignActionArgs, SignActionResult, TXIDHexString, Validation } from '@bsv/sdk'
 import { processAction } from './createAction'
 import { AuthId, ReviewActionResult } from '../../sdk/WalletStorage.interfaces'
 import { completeSignedTransaction, verifyUnlockScripts } from './completeSignedTransaction'
 import { Wallet } from '../../Wallet'
 import { WERR_INTERNAL, WERR_NOT_IMPLEMENTED } from '../../sdk/WERR_errors'
-import { validateSignActionArgs, ValidCreateActionArgs, ValidSignActionArgs } from '../../sdk/validationHelpers'
 
 export interface SignActionResultX extends SignActionResult {
   txid?: TXIDHexString
@@ -41,12 +40,15 @@ export async function signAction(wallet: Wallet, auth: AuthId, args: SignActionA
   return r
 }
 
-function mergePriorOptions(caVargs: ValidCreateActionArgs, saArgs: SignActionArgs): ValidSignActionArgs {
+function mergePriorOptions(
+  caVargs: Validation.ValidCreateActionArgs,
+  saArgs: SignActionArgs
+): Validation.ValidSignActionArgs {
   const saOptions = (saArgs.options ||= {})
   if (saOptions.acceptDelayedBroadcast === undefined)
     saOptions.acceptDelayedBroadcast = caVargs.options.acceptDelayedBroadcast
   if (saOptions.returnTXIDOnly === undefined) saOptions.returnTXIDOnly = caVargs.options.returnTXIDOnly
   if (saOptions.noSend === undefined) saOptions.noSend = caVargs.options.noSend
   if (saOptions.sendWith === undefined) saOptions.sendWith = caVargs.options.sendWith
-  return validateSignActionArgs(saArgs)
+  return Validation.validateSignActionArgs(saArgs)
 }

package/src/storage/StorageIdb.ts

@@ -1,5 +1,5 @@
 import { deleteDB, IDBPCursorWithValue, IDBPDatabase, IDBPTransaction, openDB } from 'idb'
-import { ListActionsResult, ListOutputsResult } from '@bsv/sdk'
+import { ListActionsResult, ListOutputsResult, Validation } from '@bsv/sdk'
 import {
   TableCertificate,
   TableCertificateField,
@@ -53,7 +53,6 @@ import {
 } from '../sdk/WalletStorage.interfaces'
 import { WERR_INTERNAL, WERR_INVALID_OPERATION, WERR_INVALID_PARAMETER, WERR_UNAUTHORIZED } from '../sdk/WERR_errors'
 import { EntityTimeStamp, TransactionStatus } from '../sdk/types'
-import { ValidListActionsArgs, ValidListOutputsArgs } from '../sdk/validationHelpers'
 
 export interface StorageIdbOptions extends StorageProviderOptions {}
 
@@ -464,12 +463,12 @@ export class StorageIdb extends StorageProvider implements WalletStorageProvider
     return tags
   }
 
-  async listActions(auth: AuthId, vargs: ValidListActionsArgs): Promise<ListActionsResult> {
+  async listActions(auth: AuthId, vargs: Validation.ValidListActionsArgs): Promise<ListActionsResult> {
     if (!auth.userId) throw new WERR_UNAUTHORIZED()
     return await listActionsIdb(this, auth, vargs)
   }
 
-  async listOutputs(auth: AuthId, vargs: ValidListOutputsArgs): Promise<ListOutputsResult> {
+  async listOutputs(auth: AuthId, vargs: Validation.ValidListOutputsArgs): Promise<ListOutputsResult> {
     if (!auth.userId) throw new WERR_UNAUTHORIZED()
     return await listOutputsIdb(this, auth, vargs)
   }

package/src/storage/StorageKnex.ts

@@ -1,4 +1,4 @@
-import { ListActionsResult, ListOutputsResult } from '@bsv/sdk'
+import { ListActionsResult, ListOutputsResult, Validation } from '@bsv/sdk'
 import {
   outputColumnsWithoutLockingScript,
   TableCertificate,
@@ -56,7 +56,6 @@ import {
 } from '../sdk/WalletStorage.interfaces'
 import { WERR_INTERNAL, WERR_INVALID_PARAMETER, WERR_NOT_IMPLEMENTED, WERR_UNAUTHORIZED } from '../sdk/WERR_errors'
 import { verifyOne, verifyOneOrNone, verifyTruthy } from '../utility/utilityHelpers'
-import { ValidListActionsArgs, ValidListOutputsArgs } from '../sdk/validationHelpers'
 import { EntityTimeStamp, TransactionStatus } from '../sdk/types'
 
 export interface StorageKnexOptions extends StorageProviderOptions {
@@ -232,11 +231,11 @@ export class StorageKnex extends StorageProvider implements WalletStorageProvide
     return this.validateEntities(rs, undefined, ['isDeleted'])
   }
 
-  override async listActions(auth: AuthId, vargs: ValidListActionsArgs): Promise<ListActionsResult> {
+  override async listActions(auth: AuthId, vargs: Validation.ValidListActionsArgs): Promise<ListActionsResult> {
     if (!auth.userId) throw new WERR_UNAUTHORIZED()
     return await listActions(this, auth, vargs)
   }
-  override async listOutputs(auth: AuthId, vargs: ValidListOutputsArgs): Promise<ListOutputsResult> {
+  override async listOutputs(auth: AuthId, vargs: Validation.ValidListOutputsArgs): Promise<ListOutputsResult> {
     if (!auth.userId) throw new WERR_UNAUTHORIZED()
     return await listOutputs(this, auth, vargs)
   }

package/src/storage/StorageProvider.ts

@@ -3,7 +3,6 @@ import {
   AbortActionResult,
   Beef,
   InternalizeActionArgs,
-  InternalizeActionResult,
   ListActionsResult,
   ListOutputsResult,
   PubKeyHex,
@@ -11,7 +10,9 @@ import {
   TrustSelf,
   RelinquishCertificateArgs,
   RelinquishOutputArgs,
-  AbortActionArgs
+  AbortActionArgs,
+  Validation,
+  WalletLoggerInterface
 } from '@bsv/sdk'
 import { getBeefForTransaction } from './methods/getBeefForTransaction'
 import { GetReqsAndBeefDetail, GetReqsAndBeefResult, processAction } from './methods/processAction'
@@ -53,15 +54,6 @@ import { TableOutput, TableOutputX } from '../../src/storage/schema/tables/Table
 import { TableOutputTag } from '../../src/storage/schema/tables/TableOutputTag'
 import { TableTxLabel } from '../../src/storage/schema/tables/TableTxLabel'
 import { TableMonitorEvent } from '../../src/storage/schema/tables/TableMonitorEvent'
-import {
-  parseWalletOutpoint,
-  validateRelinquishCertificateArgs,
-  validateRelinquishOutputArgs,
-  ValidCreateActionArgs,
-  ValidListActionsArgs,
-  ValidListCertificatesArgs,
-  ValidListOutputsArgs
-} from '../sdk/validationHelpers'
 import { TableCertificateX } from './schema/tables/TableCertificate'
 import {
   WERR_INTERNAL,
@@ -130,8 +122,8 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
   abstract getLabelsForTransactionId(transactionId?: number, trx?: TrxToken): Promise<TableTxLabel[]>
   abstract getTagsForOutputId(outputId: number, trx?: TrxToken): Promise<TableOutputTag[]>
 
-  abstract listActions(auth: AuthId, args: ValidListActionsArgs): Promise<ListActionsResult>
-  abstract listOutputs(auth: AuthId, args: ValidListOutputsArgs): Promise<ListOutputsResult>
+  abstract listActions(auth: AuthId, args: Validation.ValidListActionsArgs): Promise<ListActionsResult>
+  abstract listOutputs(auth: AuthId, args: Validation.ValidListOutputsArgs): Promise<ListOutputsResult>
 
   abstract countChangeInputs(userId: number, basketId: number, excludeSending: boolean): Promise<number>
 
@@ -420,7 +412,7 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
     }, trx)
   }
 
-  async createAction(auth: AuthId, args: ValidCreateActionArgs): Promise<StorageCreateActionResult> {
+  async createAction(auth: AuthId, args: Validation.ValidCreateActionArgs): Promise<StorageCreateActionResult> {
     if (!auth.userId) throw new WERR_UNAUTHORIZED()
     return await createAction(this, auth, args)
   }
@@ -429,11 +421,15 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
     return await processAction(this, auth, args)
   }
 
-  async attemptToPostReqsToNetwork(reqs: EntityProvenTxReq[], trx?: TrxToken): Promise<PostReqsToNetworkResult> {
-    return await attemptToPostReqsToNetwork(this, reqs, trx)
+  async attemptToPostReqsToNetwork(
+    reqs: EntityProvenTxReq[],
+    trx?: TrxToken,
+    logger?: WalletLoggerInterface
+  ): Promise<PostReqsToNetworkResult> {
+    return await attemptToPostReqsToNetwork(this, reqs, trx, logger)
   }
 
-  async listCertificates(auth: AuthId, args: ValidListCertificatesArgs): Promise<ListCertificatesResult> {
+  async listCertificates(auth: AuthId, args: Validation.ValidListCertificatesArgs): Promise<ListCertificatesResult> {
     return await listCertificates(this, auth, args)
   }
 
@@ -511,7 +507,7 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
   }
 
   async relinquishCertificate(auth: AuthId, args: RelinquishCertificateArgs): Promise<number> {
-    const vargs = validateRelinquishCertificateArgs(args)
+    const vargs = Validation.validateRelinquishCertificateArgs(args)
     const cert = verifyOne(
       await this.findCertificates({
         partial: {
@@ -527,8 +523,8 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
   }
 
   async relinquishOutput(auth: AuthId, args: RelinquishOutputArgs): Promise<number> {
-    const vargs = validateRelinquishOutputArgs(args)
-    const { txid, vout } = parseWalletOutpoint(vargs.output)
+    const vargs = Validation.validateRelinquishOutputArgs(args)
+    const { txid, vout } = Validation.parseWalletOutpoint(vargs.output)
     const output = verifyOne(await this.findOutputs({ partial: { txid, vout } }))
     return await this.updateOutput(output.outputId, { basketId: undefined })
   }

package/src/storage/WalletStorageManager.ts

@@ -3,12 +3,12 @@ import {
   AbortActionResult,
   Beef,
   InternalizeActionArgs,
-  InternalizeActionResult,
   ListActionsResult,
   ListCertificatesResult,
   ListOutputsResult,
   RelinquishCertificateArgs,
-  RelinquishOutputArgs
+  RelinquishOutputArgs,
+  Validation
 } from '@bsv/sdk'
 import { EntitySyncState } from '../storage/schema/entities'
 import * as sdk from '../sdk'
@@ -22,7 +22,6 @@ import {
   TableSettings,
   TableUser
 } from '../storage/schema/tables'
-import { wait } from '../utility/utilityHelpers'
 import { StorageProvider } from './StorageProvider'
 import { StorageClient } from './remoting/StorageClient'
 
@@ -430,20 +429,20 @@ export class WalletStorageManager implements sdk.WalletStorage {
   }
 
   async abortAction(args: AbortActionArgs): Promise<AbortActionResult> {
-    sdk.validateAbortActionArgs(args)
+    Validation.validateAbortActionArgs(args)
     return await this.runAsWriter(async writer => {
       const auth = await this.getAuth(true)
       return await writer.abortAction(auth, args)
     })
   }
-  async createAction(vargs: sdk.ValidCreateActionArgs): Promise<sdk.StorageCreateActionResult> {
+  async createAction(vargs: Validation.ValidCreateActionArgs): Promise<sdk.StorageCreateActionResult> {
     return await this.runAsWriter(async writer => {
       const auth = await this.getAuth(true)
       return await writer.createAction(auth, vargs)
     })
   }
   async internalizeAction(args: InternalizeActionArgs): Promise<sdk.StorageInternalizeActionResult> {
-    sdk.validateInternalizeActionArgs(args)
+    Validation.validateInternalizeActionArgs(args)
     return await this.runAsWriter(async writer => {
       const auth = await this.getAuth(true)
       return await writer.internalizeAction(auth, args)
@@ -451,14 +450,14 @@ export class WalletStorageManager implements sdk.WalletStorage {
   }
 
   async relinquishCertificate(args: RelinquishCertificateArgs): Promise<number> {
-    sdk.validateRelinquishCertificateArgs(args)
+    Validation.validateRelinquishCertificateArgs(args)
     return await this.runAsWriter(async writer => {
       const auth = await this.getAuth(true)
       return await writer.relinquishCertificate(auth, args)
     })
   }
   async relinquishOutput(args: RelinquishOutputArgs): Promise<number> {
-    sdk.validateRelinquishOutputArgs(args)
+    Validation.validateRelinquishOutputArgs(args)
     return await this.runAsWriter(async writer => {
       const auth = await this.getAuth(true)
       return await writer.relinquishOutput(auth, args)
@@ -478,19 +477,19 @@ export class WalletStorageManager implements sdk.WalletStorage {
     })
   }
 
-  async listActions(vargs: sdk.ValidListActionsArgs): Promise<ListActionsResult> {
+  async listActions(vargs: Validation.ValidListActionsArgs): Promise<ListActionsResult> {
     const auth = await this.getAuth()
     return await this.runAsReader(async reader => {
       return await reader.listActions(auth, vargs)
     })
   }
-  async listCertificates(args: sdk.ValidListCertificatesArgs): Promise<ListCertificatesResult> {
+  async listCertificates(args: Validation.ValidListCertificatesArgs): Promise<ListCertificatesResult> {
     const auth = await this.getAuth()
     return await this.runAsReader(async reader => {
       return await reader.listCertificates(auth, args)
     })
   }
-  async listOutputs(vargs: sdk.ValidListOutputsArgs): Promise<ListOutputsResult> {
+  async listOutputs(vargs: Validation.ValidListOutputsArgs): Promise<ListOutputsResult> {
     const auth = await this.getAuth()
     return await this.runAsReader(async reader => {
       return await reader.listOutputs(auth, vargs)

package/src/storage/__test/getBeefForTransaction.test.ts

@@ -1,4 +1,4 @@
-import { Beef, ListActionsResult, ListOutputsResult, Utils } from '@bsv/sdk'
+import { Beef, ListActionsResult, ListOutputsResult, Utils, Validation } from '@bsv/sdk'
 import { StorageAdminStats, StorageProvider } from '../StorageProvider'
 import { Chain } from '../../sdk/types'
 import { Services } from '../../services/Services'
@@ -45,7 +45,6 @@ import {
   StorageGetBeefOptions,
   TrxToken
 } from '../../sdk/WalletStorage.interfaces'
-import { ValidListActionsArgs, ValidListOutputsArgs } from '../../sdk/validationHelpers'
 
 describe('getBeefForTransaction tests', () => {
   jest.setTimeout(99999999)
@@ -129,10 +128,10 @@ class ProtoStorage 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/storage/methods/ListActionsSpecOp.ts

@@ -1,5 +1,5 @@
+import { Validation } from '@bsv/sdk'
 import { specOpFailedActions, specOpNoSendActions, TransactionStatus } from '../../sdk/types'
-import { ValidListActionsArgs } from '../../sdk/validationHelpers'
 import { AuthId } from '../../sdk/WalletStorage.interfaces'
 import { TableTransaction } from '../schema/tables/TableTransaction'
 import { StorageProvider } from '../StorageProvider'
@@ -16,7 +16,7 @@ export interface ListActionsSpecOp {
   postProcess?: (
     s: StorageProvider,
     auth: AuthId,
-    vargs: ValidListActionsArgs,
+    vargs: Validation.ValidListActionsArgs,
     specOpLabels: string[],
     txs: Partial<TableTransaction>[]
   ) => Promise<void>
@@ -31,7 +31,7 @@ export const getLabelToSpecOp: () => Record<string, ListActionsSpecOp> = () => {
       postProcess: async (
         s: StorageProvider,
         auth: AuthId,
-        vargs: ValidListActionsArgs,
+        vargs: Validation.ValidListActionsArgs,
         specOpLabels: string[],
         txs: Partial<TableTransaction>[]
       ): Promise<void> => {
@@ -52,7 +52,7 @@ export const getLabelToSpecOp: () => Record<string, ListActionsSpecOp> = () => {
       postProcess: async (
         s: StorageProvider,
         auth: AuthId,
-        vargs: ValidListActionsArgs,
+        vargs: Validation.ValidListActionsArgs,
         specOpLabels: string[],
         txs: Partial<TableTransaction>[]
       ): Promise<void> => {

package/src/storage/methods/ListOutputsSpecOp.ts

@@ -1,5 +1,4 @@
-import { ListOutputsResult } from '@bsv/sdk'
-import { ValidListOutputsArgs } from '../../sdk/validationHelpers'
+import { ListOutputsResult, Validation } from '@bsv/sdk'
 import { StorageProvider } from '../StorageProvider'
 import { AuthId } from '../../sdk/WalletStorage.interfaces'
 import { TableOutput } from '../schema/tables/TableOutput'
@@ -16,20 +15,20 @@ export interface ListOutputsSpecOp {
   resultFromTags?: (
     s: StorageProvider,
     auth: AuthId,
-    vargs: ValidListOutputsArgs,
+    vargs: Validation.ValidListOutputsArgs,
     specOpTags: string[]
   ) => Promise<ListOutputsResult>
   resultFromOutputs?: (
     s: StorageProvider,
     auth: AuthId,
-    vargs: ValidListOutputsArgs,
+    vargs: Validation.ValidListOutputsArgs,
     specOpTags: string[],
     outputs: TableOutput[]
   ) => Promise<ListOutputsResult>
   filterOutputs?: (
     s: StorageProvider,
     auth: AuthId,
-    vargs: ValidListOutputsArgs,
+    vargs: Validation.ValidListOutputsArgs,
     specOpTags: string[],
     outputs: TableOutput[]
   ) => Promise<TableOutput[]>
@@ -54,7 +53,7 @@ export const getBasketToSpecOp: () => Record<string, ListOutputsSpecOp> = () =>
       resultFromOutputs: async (
         s: StorageProvider,
         auth: AuthId,
-        vargs: ValidListOutputsArgs,
+        vargs: Validation.ValidListOutputsArgs,
         specOpTags: string[],
         outputs: TableOutput[]
       ): Promise<ListOutputsResult> => {
@@ -73,7 +72,7 @@ export const getBasketToSpecOp: () => Record<string, ListOutputsSpecOp> = () =>
       filterOutputs: async (
         s: StorageProvider,
         auth: AuthId,
-        vargs: ValidListOutputsArgs,
+        vargs: Validation.ValidListOutputsArgs,
         specOpTags: string[],
         outputs: TableOutput[]
       ): Promise<TableOutput[]> => {
@@ -106,7 +105,7 @@ export const getBasketToSpecOp: () => Record<string, ListOutputsSpecOp> = () =>
       resultFromTags: async (
         s: StorageProvider,
         auth: AuthId,
-        vargs: ValidListOutputsArgs,
+        vargs: Validation.ValidListOutputsArgs,
         specOpTags: string[]
       ): Promise<ListOutputsResult> => {
         if (specOpTags.length !== 2)

package/src/storage/methods/attemptToPostReqsToNetwork.ts

@@ -1,4 +1,4 @@
-import { Beef, Transaction } from '@bsv/sdk'
+import { Beef, Transaction, WalletLoggerInterface } from '@bsv/sdk'
 import { StorageProvider } from '../StorageProvider'
 import { EntityProvenTxReq } from '../schema/entities'
 import * as sdk from '../../sdk'
@@ -14,15 +14,17 @@ import { wait } from '../../utility/utilityHelpers'
 export async function attemptToPostReqsToNetwork(
   storage: StorageProvider,
   reqs: EntityProvenTxReq[],
-  trx?: sdk.TrxToken
+  trx?: sdk.TrxToken,
+  logger?: WalletLoggerInterface
 ): Promise<PostReqsToNetworkResult> {
   // initialize results, validate reqs ready to post, txids are of the transactions in the beef that we care about.
 
   const { r, vreqs, txids } = await validateReqsAndMergeBeefs(storage, reqs, trx)
+  logger?.log(`validated request and merged beefs`)
 
   const services = storage.getServices()
 
-  const pbrs = await services.postBeef(r.beef, txids)
+  const pbrs = await services.postBeef(r.beef, txids, logger)
 
   // post beef results (pbrs) is an array by service provider
   // for each service provider, there's an aggregate result and individual results by txid.
@@ -31,7 +33,7 @@ export async function attemptToPostReqsToNetwork(
 
   const apbrs = aggregatePostBeefResultsByTxid(txids, vreqs, pbrs)
 
-  await updateReqsFromAggregateResults(txids, r, apbrs, storage, services, trx)
+  await updateReqsFromAggregateResults(txids, r, apbrs, storage, services, trx, logger)
 
   return r
 }
@@ -192,8 +194,10 @@ async function updateReqsFromAggregateResults(
   apbrs: Record<string, AggregatePostBeefTxResult>,
   storage: StorageProvider,
   services?: sdk.WalletServices,
-  trx?: sdk.TrxToken
+  trx?: sdk.TrxToken,
+  logger?: WalletLoggerInterface
 ): Promise<void> {
+  logger?.group('update storage from aggregate results')
   for (const txid of txids) {
     const ar = apbrs[txid]!
     const req = ar.vreq.req
@@ -216,7 +220,7 @@ async function updateReqsFromAggregateResults(
       // However it happened, don't degrade status if it is somehow already beyond broadcast stage
       continue
 
-    if (ar.status === 'doubleSpend' && services && !trx) await confirmDoubleSpend(ar, r.beef, storage, services)
+    if (ar.status === 'doubleSpend' && services && !trx) await confirmDoubleSpend(ar, r.beef, storage, services, logger)
 
     let newReqStatus: sdk.ProvenTxReqStatus | undefined = undefined
     let newTxStatus: sdk.TransactionStatus | undefined = undefined
@@ -263,7 +267,9 @@ async function updateReqsFromAggregateResults(
     const details = r.details.find(d => d.txid === txid)!
     details.status = ar.status
     details.competingTxs = ar.competingTxs
+    logger?.log(`updated ${txid}`)
   }
+  logger?.group('update storage from aggregate results')
 }
 
 /**
@@ -281,7 +287,8 @@ async function confirmDoubleSpend(
   ar: AggregatePostBeefTxResult,
   beef: Beef,
   storage: StorageProvider,
-  services: sdk.WalletServices
+  services: sdk.WalletServices,
+  logger?: WalletLoggerInterface
 ): Promise<void> {
   const req = ar.vreq.req
   const note: ReqHistoryNote = { when: new Date().toISOString(), what: 'confirmDoubleSpend' }
@@ -312,7 +319,7 @@ async function confirmDoubleSpend(
       if (!sourceTx) throw new sdk.WERR_INTERNAL(`beef lacks tx for ${input.sourceTXID}`)
       const lockingScript = sourceTx.outputs[input.sourceOutputIndex].lockingScript.toHex()
       const hash = services.hashOutputScript(lockingScript)
-      const shhrs = await services.getScriptHashHistory(hash)
+      const shhrs = await services.getScriptHashHistory(hash, undefined, logger)
       if (shhrs.status === 'success') {
         for (const h of shhrs.history) {
           // Neither the source of the input nor the current transaction are competition.