@bsv/wallet-toolbox 1.3.27 → 1.3.29

package/package.json

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

package/src/monitor/Monitor.ts

@@ -221,7 +221,7 @@ export class Monitor {
           if (this.storage.getActive().isStorageProvider()) {
             const log = await ttr.runTask()
             if (log && log.length > 0) {
-              console.log(`Task${ttr.name} ${log}`)
+              console.log(`Task${ttr.name} ${log.slice(0, 80)}`)
               await this.logEvent(ttr.name, log)
             }
           }

package/src/sdk/WalletServices.interfaces.ts

@@ -173,7 +173,7 @@ export interface WalletServices {
    * @param reset if true, ends current interval and starts a new one.
    * @returns a history of service calls made to the configured services.
    */
-  getServicesCallHistory(reset?: boolean) : ServicesCallHistory
+  getServicesCallHistory(reset?: boolean): ServicesCallHistory
 }
 
 export type ScriptHashFormat = 'hashLE' | 'hashBE' | 'script'
@@ -539,7 +539,7 @@ export interface ServiceCall {
   /**
    * Error code and message iff success is false and a exception was thrown.
    */
-  error?: { message: string, code: string }
+  error?: { message: string; code: string }
 }
 
 /**

package/src/services/ServiceCollection.ts

@@ -1,5 +1,5 @@
-import { WalletError } from "../sdk/WalletError";
-import { ProviderCallHistory, ServiceCallHistory } from "../sdk/WalletServices.interfaces";
+import { WalletError } from '../sdk/WalletError'
+import { ProviderCallHistory, ServiceCallHistory } from '../sdk/WalletServices.interfaces'
 
 const MAX_RESET_COUNTS = 32
 const MAX_CALL_HISTORY = 32
@@ -14,7 +14,10 @@ export class ServiceCollection<T> {
   readonly since: Date
   _historyByProvider: Record<string, ProviderCallHistory> = {}
 
-  constructor(public serviceName: string, services?: { name: string; service: T }[]) {
+  constructor(
+    public serviceName: string,
+    services?: { name: string; service: T }[]
+  ) {
     this.services = services || []
     this._index = 0
     this.since = new Date()
@@ -92,7 +95,7 @@ export class ServiceCollection<T> {
       this._historyByProvider[providerName] = h
     }
     h.calls.unshift(call)
-    h.calls = h.calls.slice(0,MAX_CALL_HISTORY)
+    h.calls = h.calls.slice(0, MAX_CALL_HISTORY)
     h.totalCounts.until = now
     h.resetCounts[0].until = now
     return h
@@ -220,7 +223,7 @@ export interface ServiceCall {
   /**
    * Error code and message iff success is false and a exception was thrown.
    */
-  error?: { message: string, code: string }
+  error?: { message: string; code: string }
 }
 
 export interface ServiceToCall<T> {
@@ -228,4 +231,4 @@ export interface ServiceToCall<T> {
   serviceName: string
   service: T
   call: ServiceCall
-}
+}

package/src/services/Services.ts

@@ -84,7 +84,7 @@ export class Services implements sdk.WalletServices {
       .add({ name: 'exchangeratesapi', service: updateExchangeratesapi })
   }
 
-  getServicesCallHistory(reset?: boolean) : ServicesCallHistory {
+  getServicesCallHistory(reset?: boolean): ServicesCallHistory {
     return {
       version: 2,
       getMerklePath: this.getMerklePathServices.getServiceCallHistory(reset),
@@ -155,10 +155,8 @@ export class Services implements sdk.WalletServices {
           r0 = r
           break
         } else {
-          if (r.error)
-            services.addServiceCallError(stc, r.error)
-          else
-            services.addServiceCallFailure(stc)
+          if (r.error) services.addServiceCallError(stc, r.error)
+          else services.addServiceCallFailure(stc)
         }
       } catch (eu: unknown) {
         const e = sdk.WalletError.fromUnknown(eu)
@@ -217,10 +215,8 @@ export class Services implements sdk.WalletServices {
             r0 = r
             break
           } else {
-            if (r.error)
-              services.addServiceCallError(stc, r.error)
-            else
-              services.addServiceCallFailure(stc)
+            if (r.error) services.addServiceCallError(stc, r.error)
+            else services.addServiceCallFailure(stc)
           }
         } catch (eu: unknown) {
           const e = sdk.WalletError.fromUnknown(eu)
@@ -253,10 +249,8 @@ export class Services implements sdk.WalletServices {
           r0 = r
           break
         } else {
-          if (r.error)
-            services.addServiceCallError(stc, r.error)
-          else
-            services.addServiceCallFailure(stc)
+          if (r.error) services.addServiceCallError(stc, r.error)
+          else services.addServiceCallFailure(stc)
         }
       } catch (eu: unknown) {
         const e = sdk.WalletError.fromUnknown(eu)
@@ -319,17 +313,13 @@ export class Services implements sdk.WalletServices {
           r.rawTx = undefined
         }
 
-        if (r.error)
-          services.addServiceCallError(stc, r.error)
-        else if (!r.rawTx)
-          services.addServiceCallSuccess(stc, `not found`)
-        else
-          services.addServiceCallFailure(stc)
+        if (r.error) services.addServiceCallError(stc, r.error)
+        else if (!r.rawTx) services.addServiceCallSuccess(stc, `not found`)
+        else services.addServiceCallFailure(stc)
 
         if (r.error && !r0.error && !r0.rawTx)
           // If we have an error and didn't before...
           r0.error = r.error
-
       } catch (eu: unknown) {
         const e = sdk.WalletError.fromUnknown(eu)
         services.addServiceCallError(stc, e)
@@ -401,11 +391,9 @@ export class Services implements sdk.WalletServices {
           services.addServiceCallSuccess(stc)
           break
         }
-        
-        if (r.error)
-          services.addServiceCallError(stc, r.error)
-        else
-          services.addServiceCallFailure(stc)
+
+        if (r.error) services.addServiceCallError(stc, r.error)
+        else services.addServiceCallFailure(stc)
 
         if (r.error && !r0.error) {
           // If we have an error and didn't before...

package/src/services/createDefaultWalletServicesOptions.ts

@@ -7,10 +7,7 @@ export function createDefaultWalletServicesOptions(chain: sdk.Chain): sdk.Wallet
     chain === 'main'
       ? 'mainnet_9596de07e92300c6287e4393594ae39c' // no plan
       : 'testnet_0e6cf72133b43ea2d7861da2a38684e3' // personal "starter" key
-  const gorillaPoolApiKey =
-    chain === 'main'
-      ? ''
-      : ''
+  const gorillaPoolApiKey = chain === 'main' ? '' : ''
 
   const o: sdk.WalletServicesOptions = {
     chain,

package/src/signer/methods/completeSignedTransaction.ts

@@ -0,0 +1,115 @@
+import { Beef, SignActionResult, SignActionSpend, Spend, Transaction } from '@bsv/sdk'
+import { PendingSignAction, Wallet } from '../../Wallet'
+import { asBsvSdkScript, ScriptTemplateBRC29, sdk } from '../../index.client'
+import { WalletError, WERR_INTERNAL, WERR_INVALID_PARAMETER } from '../../sdk'
+
+export async function completeSignedTransaction(
+  prior: PendingSignAction,
+  spends: Record<number, SignActionSpend>,
+  wallet: Wallet
+): Promise<Transaction> {
+  /////////////////////
+  // Insert the user provided unlocking scripts from "spends" arg
+  /////////////////////
+  for (const [key, spend] of Object.entries(spends)) {
+    const vin = Number(key)
+    const createInput = prior.args.inputs[vin]
+    const input = prior.tx.inputs[vin]
+    if (!createInput || !input || createInput.unlockingScript || !Number.isInteger(createInput.unlockingScriptLength))
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'args',
+        `spend does not correspond to prior input with valid unlockingScriptLength.`
+      )
+    if (spend.unlockingScript.length / 2 > createInput.unlockingScriptLength!)
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'args',
+        `spend unlockingScript length ${spend.unlockingScript.length} exceeds expected length ${createInput.unlockingScriptLength}`
+      )
+    input.unlockingScript = asBsvSdkScript(spend.unlockingScript)
+    if (spend.sequenceNumber !== undefined) input.sequence = spend.sequenceNumber
+  }
+
+  const results = {
+    sdk: <SignActionResult>{}
+  }
+
+  /////////////////////
+  // Insert SABPPP unlock templates for wallet signed inputs
+  /////////////////////
+  for (const pdi of prior.pdi) {
+    const sabppp = new ScriptTemplateBRC29({
+      derivationPrefix: pdi.derivationPrefix,
+      derivationSuffix: pdi.derivationSuffix,
+      keyDeriver: wallet.keyDeriver
+    })
+    const keys = wallet.getClientChangeKeyPair()
+    const lockerPrivKey = keys.privateKey
+    const unlockerPubKey = pdi.unlockerPubKey || keys.publicKey
+    const sourceSatoshis = pdi.sourceSatoshis
+    const lockingScript = asBsvSdkScript(pdi.lockingScript)
+    const unlockTemplate = sabppp.unlock(lockerPrivKey, unlockerPubKey, sourceSatoshis, lockingScript)
+    const input = prior.tx.inputs[pdi.vin]
+    input.unlockingScriptTemplate = unlockTemplate
+  }
+
+  /////////////////////
+  // Sign wallet signed inputs making transaction fully valid.
+  /////////////////////
+  await prior.tx.sign()
+
+  return prior.tx
+}
+
+/**
+ * @param txid The TXID of a transaction in the beef for which all unlocking scripts must be valid.
+ * @param beef Must contain transactions for txid and all its inputs.
+ * @throws WERR_INVALID_PARAMETER if any unlocking script is invalid, if sourceTXID is invalid, if beef doesn't contain required transactions.
+ */
+export function verifyUnlockScripts(txid: string, beef: Beef): void {
+  const tx = beef.findTxid(txid)?.tx
+  if (!tx) throw new WERR_INVALID_PARAMETER(`txid`, `contained in beef, txid ${txid}`)
+
+  for (let i = 0; i < tx.inputs.length; i++) {
+    const input = tx.inputs[i]
+    if (!input.sourceTXID) throw new WERR_INVALID_PARAMETER(`inputs[${i}].sourceTXID`, `valid`)
+    if (!input.unlockingScript) throw new WERR_INVALID_PARAMETER(`inputs[${i}].unlockingScript`, `valid`)
+    input.sourceTransaction = beef.findTxid(input.sourceTXID)?.tx
+    if (!input.sourceTransaction) {
+      // The beef doesn't contain all the source transactions only if advanced features
+      // such as knownTxids are used.
+      // Skip unlock script checks.
+      return
+      // throw new WERR_INVALID_PARAMETER(`inputs[${i}].sourceTXID`, `contained in beef`)
+    }
+  }
+
+  for (let i = 0; i < tx.inputs.length; i++) {
+    const input = tx.inputs[i]
+    const sourceOutput = input.sourceTransaction!.outputs[input.sourceOutputIndex]
+
+    const otherInputs = tx.inputs.filter((_, idx) => idx !== i)
+
+    const spend = new Spend({
+      sourceTXID: input.sourceTXID!,
+      sourceOutputIndex: input.sourceOutputIndex,
+      lockingScript: sourceOutput.lockingScript,
+      sourceSatoshis: sourceOutput.satoshis ?? 0,
+      transactionVersion: tx.version,
+      otherInputs,
+      unlockingScript: input.unlockingScript!,
+      inputSequence: input.sequence ?? 0,
+      inputIndex: i,
+      outputs: tx.outputs,
+      lockTime: tx.lockTime
+    })
+
+    try {
+    const spendValid = spend.validate()
+
+    if (!spendValid) throw new WERR_INVALID_PARAMETER(`inputs[${i}].unlockScript`, `valid`)
+    } catch (eu: unknown) {
+      const e = WalletError.fromUnknown(eu)
+      throw new WERR_INVALID_PARAMETER(`inputs[${i}].unlockScript`, `valid. ${e.message}`)
+    }
+  }
+}

package/src/signer/methods/createAction.ts

@@ -5,22 +5,13 @@ import {
   OutpointString,
   SendWithResult,
   SignableTransaction,
-  SignActionResult,
-  SignActionSpend,
   TXIDHexString
 } from '@bsv/sdk'
 import { Script, Transaction } from '@bsv/sdk'
-import {
-  asBsvSdkScript,
-  makeAtomicBeef,
-  PendingSignAction,
-  ScriptTemplateBRC29,
-  sdk,
-  verifyTruthy,
-  Wallet
-} from '../../index.client'
+import { makeAtomicBeef, PendingSignAction, ScriptTemplateBRC29, sdk, verifyTruthy, Wallet } from '../../index.client'
 import { buildSignableTransaction } from './buildSignableTransaction'
 import { ReviewActionResult } from '../../sdk/WalletStorage.interfaces'
+import { completeSignedTransaction, verifyUnlockScripts } from './completeSignedTransaction'
 
 export interface CreateActionResultX extends CreateActionResult {
   txid?: TXIDHexString
@@ -50,8 +41,14 @@ export async function createAction(
     prior.tx = await completeSignedTransaction(prior, {}, wallet)
 
     r.txid = prior.tx.id('hex')
+    const beef = new Beef()
+    if (prior.dcr.inputBeef) beef.mergeBeef(prior.dcr.inputBeef)
+    beef.mergeTransaction(prior.tx)
+
+    verifyUnlockScripts(r.txid, beef)
+
     r.noSendChange = prior.dcr.noSendChangeOutputVouts?.map(vout => `${r.txid}.${vout}`)
-    if (!vargs.options.returnTXIDOnly) r.tx = makeAtomicBeef(prior.tx, prior.dcr.inputBeef!)
+    if (!vargs.options.returnTXIDOnly) r.tx = beef.toBinaryAtomic(r.txid)
   }
 
   const { sendWithResults, notDelayedResults } = await processAction(prior, wallet, auth, vargs)
@@ -131,62 +128,6 @@ export function makeChangeLock(
   return lockingScript
 }
 
-export async function completeSignedTransaction(
-  prior: PendingSignAction,
-  spends: Record<number, SignActionSpend>,
-  wallet: Wallet
-): Promise<Transaction> {
-  /////////////////////
-  // Insert the user provided unlocking scripts from "spends" arg
-  /////////////////////
-  for (const [key, spend] of Object.entries(spends)) {
-    const vin = Number(key)
-    const createInput = prior.args.inputs[vin]
-    const input = prior.tx.inputs[vin]
-    if (!createInput || !input || createInput.unlockingScript || !Number.isInteger(createInput.unlockingScriptLength))
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args',
-        `spend does not correspond to prior input with valid unlockingScriptLength.`
-      )
-    if (spend.unlockingScript.length / 2 > createInput.unlockingScriptLength!)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args',
-        `spend unlockingScript length ${spend.unlockingScript.length} exceeds expected length ${createInput.unlockingScriptLength}`
-      )
-    input.unlockingScript = asBsvSdkScript(spend.unlockingScript)
-    if (spend.sequenceNumber !== undefined) input.sequence = spend.sequenceNumber
-  }
-
-  const results = {
-    sdk: <SignActionResult>{}
-  }
-
-  /////////////////////
-  // Insert SABPPP unlock templates for storage signed inputs
-  /////////////////////
-  for (const pdi of prior.pdi) {
-    const sabppp = new ScriptTemplateBRC29({
-      derivationPrefix: pdi.derivationPrefix,
-      derivationSuffix: pdi.derivationSuffix,
-      keyDeriver: wallet.keyDeriver
-    })
-    const keys = wallet.getClientChangeKeyPair()
-    const lockerPrivKey = keys.privateKey
-    const unlockerPubKey = pdi.unlockerPubKey || keys.publicKey
-    const sourceSatoshis = pdi.sourceSatoshis
-    const lockingScript = asBsvSdkScript(pdi.lockingScript)
-    const unlockTemplate = sabppp.unlock(lockerPrivKey, unlockerPubKey, sourceSatoshis, lockingScript)
-    const input = prior.tx.inputs[pdi.vin]
-    input.unlockingScriptTemplate = unlockTemplate
-  }
-
-  /////////////////////
-  // Sign storage signed inputs making transaction fully valid.
-  /////////////////////
-  await prior.tx.sign()
-
-  return prior.tx
-}
 function removeUnlockScripts(args: sdk.ValidCreateActionArgs) {
   let storageArgs = args
   if (!storageArgs.inputs.every(i => i.unlockingScript === undefined)) {

package/src/signer/methods/signAction.ts

@@ -1,20 +1,10 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-import {
-  AtomicBEEF,
-  Beef,
-  Transaction as BsvTransaction,
-  SendWithResult,
-  SignActionArgs,
-  SignActionOptions,
-  SignActionResult,
-  SignActionSpend,
-  TXIDHexString
-} from '@bsv/sdk'
-import { asBsvSdkScript, PendingSignAction, ScriptTemplateBRC29, sdk, Wallet } from '../../index.client'
+import { AtomicBEEF, Beef, SendWithResult, SignActionArgs, SignActionResult, TXIDHexString } from '@bsv/sdk'
+import { sdk, Wallet } from '../../index.client'
 import { processAction } from './createAction'
 import { ReviewActionResult } from '../../sdk/WalletStorage.interfaces'
 import { validateSignActionArgs } from '../../sdk'
+import { completeSignedTransaction, verifyUnlockScripts } from './completeSignedTransaction'
+import { makeAtomicBeef } from '../../utility/utilityHelpers'
 
 export interface SignActionResultX extends SignActionResult {
   txid?: TXIDHexString
@@ -35,9 +25,15 @@ export async function signAction(wallet: Wallet, auth: sdk.AuthId, args: SignAct
 
   const { sendWithResults, notDelayedResults } = await processAction(prior, wallet, auth, vargs)
 
+  const txid = prior.tx.id('hex')
+  const beef = Beef.fromBinary(prior.dcr.inputBeef)
+  beef.mergeTransaction(prior.tx)
+
+  verifyUnlockScripts(txid, beef)
+
   const r: SignActionResultX = {
     txid: prior.tx.id('hex'),
-    tx: vargs.options.returnTXIDOnly ? undefined : makeAtomicBeef(prior.tx, prior.dcr.inputBeef),
+    tx: vargs.options.returnTXIDOnly ? undefined : beef.toBinaryAtomic(txid),
     sendWithResults,
     notDelayedResults
   }
@@ -45,69 +41,6 @@ export async function signAction(wallet: Wallet, auth: sdk.AuthId, args: SignAct
   return r
 }
 
-export function makeAtomicBeef(tx: BsvTransaction, beef: number[] | Beef): number[] {
-  if (Array.isArray(beef)) beef = Beef.fromBinary(beef)
-  beef.mergeTransaction(tx)
-  return beef.toBinaryAtomic(tx.id('hex'))
-}
-
-export async function completeSignedTransaction(
-  prior: PendingSignAction,
-  spends: Record<number, SignActionSpend>,
-  wallet: Wallet
-): Promise<BsvTransaction> {
-  /////////////////////
-  // Insert the user provided unlocking scripts from "spends" arg
-  /////////////////////
-  for (const [key, spend] of Object.entries(spends)) {
-    const vin = Number(key)
-    const createInput = prior.args.inputs[vin]
-    const input = prior.tx.inputs[vin]
-    if (!createInput || !input || createInput.unlockingScript || !Number.isInteger(createInput.unlockingScriptLength))
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args',
-        `spend does not correspond to prior input with valid unlockingScriptLength.`
-      )
-    if (spend.unlockingScript.length / 2 > createInput.unlockingScriptLength!)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args',
-        `spend unlockingScript length ${spend.unlockingScript.length} exceeds expected length ${createInput.unlockingScriptLength}`
-      )
-    input.unlockingScript = asBsvSdkScript(spend.unlockingScript)
-    if (spend.sequenceNumber !== undefined) input.sequence = spend.sequenceNumber
-  }
-
-  const results = {
-    sdk: <SignActionResult>{}
-  }
-
-  /////////////////////
-  // Insert SABPPP unlock templates for wallet signed inputs
-  /////////////////////
-  for (const pdi of prior.pdi) {
-    const sabppp = new ScriptTemplateBRC29({
-      derivationPrefix: pdi.derivationPrefix,
-      derivationSuffix: pdi.derivationSuffix,
-      keyDeriver: wallet.keyDeriver
-    })
-    const keys = wallet.getClientChangeKeyPair()
-    const lockerPrivKey = keys.privateKey
-    const unlockerPubKey = pdi.unlockerPubKey || keys.publicKey
-    const sourceSatoshis = pdi.sourceSatoshis
-    const lockingScript = asBsvSdkScript(pdi.lockingScript)
-    const unlockTemplate = sabppp.unlock(lockerPrivKey, unlockerPubKey, sourceSatoshis, lockingScript)
-    const input = prior.tx.inputs[pdi.vin]
-    input.unlockingScriptTemplate = unlockTemplate
-  }
-
-  /////////////////////
-  // Sign wallet signed inputs making transaction fully valid.
-  /////////////////////
-  await prior.tx.sign()
-
-  return prior.tx
-}
-
 function mergePriorOptions(caVargs: sdk.ValidCreateActionArgs, saArgs: SignActionArgs): sdk.ValidSignActionArgs {
   const saOptions = (saArgs.options ||= {})
   if (saOptions.acceptDelayedBroadcast === undefined)

package/src/storage/StorageKnex.ts

@@ -492,19 +492,44 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     if (args.orderDescending) {
       let sortColumn = ''
       switch (table) {
-        case 'certificates': sortColumn = 'certificateId'; break
-        case 'commissions': sortColumn = 'commissionId'; break
-        case 'output_baskets': sortColumn = 'basketId'; break
-        case 'outputs': sortColumn = 'outputId'; break
-        case 'output_tags': sortColumn = 'outputTagId'; break
-        case 'proven_tx_reqs': sortColumn = 'provenTxReqId'; break
-        case 'proven_txs': sortColumn = 'provenTxId'; break
-        case 'sync_states': sortColumn = 'syncStateId'; break
-        case 'transactions': sortColumn = 'transactionId'; break
-        case 'tx_labels': sortColumn = 'txLabelId'; break
-        case 'users': sortColumn = 'userId'; break
-        case 'monitor_events': sortColumn = 'id'; break
-        default: break;
+        case 'certificates':
+          sortColumn = 'certificateId'
+          break
+        case 'commissions':
+          sortColumn = 'commissionId'
+          break
+        case 'output_baskets':
+          sortColumn = 'basketId'
+          break
+        case 'outputs':
+          sortColumn = 'outputId'
+          break
+        case 'output_tags':
+          sortColumn = 'outputTagId'
+          break
+        case 'proven_tx_reqs':
+          sortColumn = 'provenTxReqId'
+          break
+        case 'proven_txs':
+          sortColumn = 'provenTxId'
+          break
+        case 'sync_states':
+          sortColumn = 'syncStateId'
+          break
+        case 'transactions':
+          sortColumn = 'transactionId'
+          break
+        case 'tx_labels':
+          sortColumn = 'txLabelId'
+          break
+        case 'users':
+          sortColumn = 'userId'
+          break
+        case 'monitor_events':
+          sortColumn = 'id'
+          break
+        default:
+          break
       }
       if (sortColumn !== '') {
         q.orderBy(sortColumn, 'desc')
@@ -1156,7 +1181,13 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
   async adminStats(adminIdentityKey: string): Promise<AdminStatsResult> {
     if (this.dbtype !== 'MySQL') throw new sdk.WERR_NOT_IMPLEMENTED('adminStats, only MySQL is supported')
 
-    const monitorEvent = verifyOneOrNone(await this.findMonitorEvents({ partial: { event: 'ServiceCallHistory'}, orderDescending: true, paged: { limit: 1 } }))
+    const monitorEvent = verifyOneOrNone(
+      await this.findMonitorEvents({
+        partial: { event: 'MonitorCallHistory' },
+        orderDescending: true,
+        paged: { limit: 1 }
+      })
+    )
     const monitorStats: ServicesCallHistory | undefined = monitorEvent ? JSON.parse(monitorEvent.details!) : undefined
     const servicesStats = this.getServices().getServicesCallHistory(true)
     await this.insertMonitorEvent({

package/src/storage/StorageProvider.ts

@@ -778,4 +778,4 @@ export interface StorageAdminStats {
 export interface AdminStatsResult extends StorageAdminStats {
   servicesStats?: ServicesCallHistory
   monitorStats?: ServicesCallHistory
-}
+}

package/src/storage/methods/createAction.ts

@@ -603,7 +603,10 @@ async function validateRequiredInputs(
     const output = verifyOneOrNone(await storage.findOutputs({ partial: { userId, txid, vout } }))
     if (output) {
       if (output.change) {
-        throw new sdk.WERR_INVALID_PARAMETER(`inputs[${input.vin}]`, 'an unmanaged input. Change outputs are managed by your wallet.')
+        throw new sdk.WERR_INVALID_PARAMETER(
+          `inputs[${input.vin}]`,
+          'an unmanaged input. Change outputs are managed by your wallet.'
+        )
       }
       input.output = output
       if (!Array.isArray(output.lockingScript) || !Number.isInteger(output.satoshis))