@bsv/wallet-toolbox 1.3.23 → 1.3.25

package/src/storage/StorageProvider.ts

@@ -14,6 +14,9 @@ import {
   AbortActionArgs
 } from '@bsv/sdk'
 import {
+  asArray,
+  asString,
+  sdk,
   TableCertificateX,
   TableMonitorEvent,
   TableOutput,
@@ -23,11 +26,12 @@ import {
   TableProvenTxReq,
   TableProvenTxReqDynamics,
   TableTransaction,
-  TableTxLabel
-} from './schema/tables'
-import { verifyId, verifyOne, verifyOneOrNone, verifyTruthy } from '../utility/utilityHelpers'
-import * as sdk from '../sdk/index'
-import { asArray, asString } from '../utility/utilityHelpers.noBuffer'
+  TableTxLabel,
+  verifyId,
+  verifyOne,
+  verifyOneOrNone,
+  verifyTruthy
+} from '../index.client'
 import { getBeefForTransaction } from './methods/getBeefForTransaction'
 import { GetReqsAndBeefDetail, GetReqsAndBeefResult, processAction } from './methods/processAction'
 import { attemptToPostReqsToNetwork, PostReqsToNetworkResult } from './methods/attemptToPostReqsToNetwork'
@@ -166,7 +170,7 @@ export abstract class StorageProvider extends StorageReaderWriter implements sdk
     return r
   }
 
-  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<InternalizeActionResult> {
+  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<sdk.StorageInternalizeActionResult> {
     return await internalizeAction(this, auth, args)
   }
 
@@ -409,10 +413,11 @@ export abstract class StorageProvider extends StorageReaderWriter implements sdk
     mergeToBeef?: Beef,
     trustSelf?: TrustSelf,
     knownTxids?: string[],
-    trx?: sdk.TrxToken
+    trx?: sdk.TrxToken,
+    requiredLevels?: number
   ): Promise<Beef> {
-    const beef = await this.getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx)
-    if (!beef) throw new sdk.WERR_INVALID_PARAMETER('txid', `${txid} is not known to storage.`)
+    const beef = await this.getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels)
+    if (!beef) throw new sdk.WERR_INVALID_PARAMETER('txid', `known to storage. ${txid} is not known.`)
     return beef
   }
 
@@ -421,43 +426,50 @@ export abstract class StorageProvider extends StorageReaderWriter implements sdk
     mergeToBeef?: Beef,
     trustSelf?: TrustSelf,
     knownTxids?: string[],
-    trx?: sdk.TrxToken
+    trx?: sdk.TrxToken,
+    requiredLevels?: number
   ): Promise<Beef | undefined> {
     const beef = mergeToBeef || new Beef()
 
     const r = await this.getProvenOrRawTx(txid, trx)
     if (r.proven) {
-      if (trustSelf === 'known') beef.mergeTxidOnly(txid)
-      else {
-        beef.mergeRawTx(r.proven.rawTx)
-        const mp = new EntityProvenTx(r.proven).getMerklePath()
-        beef.mergeBump(mp)
-        return beef
+      if (requiredLevels) {
+        r.rawTx = r.proven.rawTx
+      } else {
+        if (trustSelf === 'known') beef.mergeTxidOnly(txid)
+        else {
+          beef.mergeRawTx(r.proven.rawTx)
+          const mp = new EntityProvenTx(r.proven).getMerklePath()
+          beef.mergeBump(mp)
+          return beef
+        }
       }
     }
 
-    if (r.rawTx && r.inputBEEF) {
-      if (trustSelf === 'known') beef.mergeTxidOnly(txid)
-      else {
-        beef.mergeRawTx(r.rawTx)
-        beef.mergeBeef(r.inputBEEF)
-        const tx = Transaction.fromBinary(r.rawTx)
-        for (const input of tx.inputs) {
-          const btx = beef.findTxid(input.sourceTXID!)
-          if (!btx) {
-            if (knownTxids && knownTxids.indexOf(input.sourceTXID!) > -1) beef.mergeTxidOnly(input.sourceTXID!)
-            else await this.getValidBeefForKnownTxid(input.sourceTXID!, beef, trustSelf, knownTxids, trx)
-          }
+    if (!r.rawTx) return undefined
+
+    if (trustSelf === 'known') {
+      beef.mergeTxidOnly(txid)
+    } else {
+      beef.mergeRawTx(r.rawTx)
+      if (r.inputBEEF) beef.mergeBeef(r.inputBEEF)
+      const tx = Transaction.fromBinary(r.rawTx)
+      if (requiredLevels) requiredLevels--
+      for (const input of tx.inputs) {
+        const btx = beef.findTxid(input.sourceTXID!)
+        if (!btx) {
+          if (!requiredLevels && knownTxids && knownTxids.indexOf(input.sourceTXID!) > -1)
+            beef.mergeTxidOnly(input.sourceTXID!)
+          else await this.getValidBeefForKnownTxid(input.sourceTXID!, beef, trustSelf, knownTxids, trx, requiredLevels)
         }
-        return beef
       }
     }
-
-    return undefined
+    return beef
   }
 
   async getBeefForTransaction(txid: string, options: sdk.StorageGetBeefOptions): Promise<Beef> {
-    return await getBeefForTransaction(this, txid, options)
+    const beef = await getBeefForTransaction(this, txid, options)
+    return beef
   }
 
   async findMonitorEventById(id: number, trx?: sdk.TrxToken): Promise<TableMonitorEvent | undefined> {

package/src/storage/WalletStorageManager.ts

@@ -438,7 +438,7 @@ export class WalletStorageManager implements sdk.WalletStorage {
       return await writer.createAction(auth, vargs)
     })
   }
-  async internalizeAction(args: InternalizeActionArgs): Promise<InternalizeActionResult> {
+  async internalizeAction(args: InternalizeActionArgs): Promise<sdk.StorageInternalizeActionResult> {
     sdk.validateInternalizeActionArgs(args)
     return await this.runAsWriter(async writer => {
       const auth = await this.getAuth(true)

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

@@ -17,6 +17,7 @@ describe('StorageIdb tests', () => {
   })
 
   test('1', async () => {
+    // TODO: THIS TEST PASSES WHEN Describe is run alone, but fails to exit cleanly when run with `npm run test`
     if (Setup.noEnv('test')) return
     const env = Setup.getEnv('test')
     const wallet = await SetupClient.createWalletClientNoEnv({

package/src/storage/__test/adminStats.man.test.ts

@@ -4,6 +4,7 @@ import { Setup } from '../../Setup'
 import { StorageKnex } from '../StorageKnex'
 import { AuthFetch, WalletInterface } from '@bsv/sdk'
 import { StorageAdminStats, StorageClient } from '../index.client'
+import { Format } from '../../utility/Format'
 
 describe('storage adminStats tests', () => {
   jest.setTimeout(99999999)
@@ -36,6 +37,7 @@ describe('storage adminStats tests', () => {
 
   test('0 adminStats StorageKnex', async () => {
     const r = await storage.adminStats(env.identityKey)
+    console.log(Format.toLogStringAdminStats(r))
     expect(r.requestedBy).toBe(env.identityKey)
     expect(r.usersTotal).toBeGreaterThan(0)
   })

package/src/storage/methods/createAction.ts

@@ -18,8 +18,6 @@ import {
   randomBytesBase64,
   sdk,
   sha256Hash,
-  stampLog,
-  stampLogFormat,
   StorageProvider,
   TableOutput,
   TableOutputBasket,
@@ -552,7 +550,8 @@ async function validateRequiredInputs(
     ...input,
     vin,
     satoshis: -1,
-    lockingScript: new Script()
+    lockingScript: new Script(),
+    output: undefined
   }))
 
   const trustSelf = vargs.options.trustSelf === 'known'
@@ -603,6 +602,9 @@ async function validateRequiredInputs(
     const { txid, vout } = input.outpoint
     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.')
+      }
       input.output = output
       if (!Array.isArray(output.lockingScript) || !Number.isInteger(output.satoshis))
         throw new sdk.WERR_INVALID_PARAMETER(`${txid}.${vout}`, 'output with valid lockingScript and satoshis')

package/src/storage/methods/generateChange.ts

@@ -1,4 +1,5 @@
 import { sdk, validateStorageFeeModel } from '../../index.client'
+import { transactionSize } from './utils'
 
 /**
  * An output of this satoshis amount will be adjusted to the largest fundable amount.
@@ -545,57 +546,3 @@ export function generateChangeSdkMakeStorage(availableChange: GenerateChangeSdkC
 
   return { allocateChangeInput, releaseChangeInput, getLog }
 }
-
-/**
- * Returns the byte size required to encode number as Bitcoin VarUint
- * @publicbody
- */
-export function varUintSize(val: number): 1 | 3 | 5 | 9 {
-  if (val < 0) throw new sdk.WERR_INVALID_PARAMETER('varUint', 'non-negative')
-  return val <= 0xfc ? 1 : val <= 0xffff ? 3 : val <= 0xffffffff ? 5 : 9
-}
-
-/**
- * @param scriptSize byte length of input script
- * @returns serialized byte length a transaction input
- */
-export function transactionInputSize(scriptSize: number): number {
-  return (
-    32 + // txid
-    4 + // vout
-    varUintSize(scriptSize) + // script length, this is already in bytes
-    scriptSize + // script
-    4
-  ) // sequence number
-}
-
-/**
- * @param scriptSize byte length of output script
- * @returns serialized byte length a transaction output
- */
-export function transactionOutputSize(scriptSize: number): number {
-  return (
-    varUintSize(scriptSize) + // output script length, from script encoded as hex string
-    scriptSize + // output script
-    8
-  ) // output amount (satoshis)
-}
-
-/**
- * Compute the serialized binary transaction size in bytes
- * given the number of inputs and outputs,
- * and the size of each script.
- * @param inputs array of input script lengths, in bytes
- * @param outputs array of output script lengths, in bytes
- * @returns total transaction size in bytes
- */
-export function transactionSize(inputs: number[], outputs: number[]): number {
-  return (
-    4 + // Version
-    varUintSize(inputs.length) + // Number of inputs
-    inputs.reduce((a, e) => a + transactionInputSize(e), 0) + // all inputs
-    varUintSize(outputs.length) + // Number of outputs
-    outputs.reduce((a, e) => a + transactionOutputSize(e), 0) + // all outputs
-    4
-  ) // lock time
-}

package/src/storage/methods/getBeefForTransaction.ts

@@ -71,7 +71,15 @@ async function mergeBeefForTransactionRecurse(
 
   if (!options.ignoreStorage) {
     // if we can use storage, ask storage if it has the txid
-    const knownBeef = await storage.getValidBeefForTxid(txid, beef, options.trustSelf, options.knownTxids)
+    const requiredLevels = options.minProofLevel === undefined ? undefined : options.minProofLevel + recursionDepth
+    const knownBeef = await storage.getValidBeefForTxid(
+      txid,
+      beef,
+      options.trustSelf,
+      options.knownTxids,
+      undefined,
+      requiredLevels
+    )
     if (knownBeef) return knownBeef
   }
 
@@ -82,7 +90,7 @@ async function mergeBeefForTransactionRecurse(
   // to find it and if it has a proof, remember it.
   const r = await getProvenOrRawTxFromServices(storage, txid, options)
 
-  if (r.proven && options.minProofLevel && options.minProofLevel > recursionDepth) {
+  if (r.proven && options.minProofLevel !== undefined && options.minProofLevel > recursionDepth) {
     // ignore proof at this recursion depth
     r.proven = undefined
   }

package/src/storage/methods/internalizeAction.ts

@@ -5,7 +5,6 @@ import {
   WalletPayment,
   BasketInsertion,
   InternalizeActionArgs,
-  InternalizeActionResult,
   TransactionOutput,
   Beef
 } from '@bsv/sdk'
@@ -13,7 +12,6 @@ import {
   EntityProvenTxReq,
   randomBytesBase64,
   sdk,
-  stampLog,
   StorageProvider,
   TableOutput,
   TableOutputBasket,
@@ -22,15 +20,7 @@ import {
   verifyOne,
   verifyOneOrNone
 } from '../../index.client'
-
-export interface StorageInternalizeActionResult extends InternalizeActionResult {
-  /** true if internalizing outputs on an existing storage transaction */
-  isMerge: boolean
-  /** txid of transaction being internalized */
-  txid: string
-  /** net change in change balance for user due to this internalization */
-  satoshis: number
-}
+import { shareReqsWithWorld } from './processAction'
 
 /**
  * Internalize Action allows a wallet to take ownership of outputs in a pre-existing transaction.
@@ -62,7 +52,7 @@ export async function internalizeAction(
   storage: StorageProvider,
   auth: sdk.AuthId,
   args: InternalizeActionArgs
-): Promise<InternalizeActionResult> {
+): Promise<sdk.StorageInternalizeActionResult> {
   const ctx = new InternalizeActionContext(storage, auth, args)
   await ctx.asyncSetup()
 
@@ -94,7 +84,7 @@ interface WalletPaymentX extends WalletPayment {
 
 class InternalizeActionContext {
   /** result to be returned */
-  r: StorageInternalizeActionResult
+  r: sdk.StorageInternalizeActionResult
   /** the parsed input AtomicBEEF */
   ab: Beef
   /** the incoming transaction extracted from AtomicBEEF */
@@ -356,11 +346,30 @@ class InternalizeActionContext {
     // transaction record for user is new, but the txid may not be new to storage
     // make sure storage pursues getting a proof for it.
     const newReq = EntityProvenTxReq.fromTxid(this.txid, this.tx.toBinary(), this.args.tx)
-    newReq.status = 'unmined'
+    // this status is only relevant if the transaction is new to storage.
+    newReq.status = 'unsent'
+    // this history and notify will be merged into an existing req if it exists.
     newReq.addHistoryNote({ what: 'internalizeAction', userId: this.userId })
     newReq.addNotifyTransactionId(transactionId)
     const pr = await this.storage.getProvenOrReq(this.txid, newReq.toApi())
 
+    if (pr.isNew) {
+      // This storage doesn't know about this txid yet.
+
+      // TODO Can we immediately prove this txid?
+      // TODO Do full validation on the transaction?
+
+      // Attempt to broadcast it to the network, throwing an error if it fails.
+
+      const { swr, ndr } = await shareReqsWithWorld(this.storage, this.userId, [this.txid], false)
+      if (ndr![0].status !== 'success') {
+        this.r.sendWithResults = swr
+        this.r.notDelayedResults = ndr
+        // abort the internalize action, WERR_REVIEW_ACTIONS exception will be thrown
+        return
+      }
+    }
+
     await this.addLabels(transactionId)
 
     for (const payment of this.walletPayments) {

package/src/storage/methods/processAction.ts

@@ -108,7 +108,7 @@ export interface PostBeefResultForTxidApi {
  * @param txids
  * @param isDelayed
  */
-async function shareReqsWithWorld(
+export async function shareReqsWithWorld(
   storage: StorageProvider,
   userId: number,
   txids: string[],
@@ -154,7 +154,10 @@ async function shareReqsWithWorld(
   // If isDelayed, this (or a different beef) will have to be rebuilt at the time of sending.
   if (readyToSendReqs.length > 0) {
     const beefIsValid = await r.beef.verify(await storage.getServices().getChainTracker())
-    if (!beefIsValid) throw new sdk.WERR_INTERNAL(`merged Beef failed validation.`)
+    if (!beefIsValid) {
+      console.log(`VERIFY FALSE BEEF: ${r.beef.toLogString()}`)
+      throw new sdk.WERR_INTERNAL(`merged Beef failed validation.`)
+    }
   }
 
   // Set req batch property for the reqs being sent

package/src/storage/methods/utils.Buffer.ts

@@ -0,0 +1,33 @@
+/**
+ * Returns a copy of a Buffer with byte order reversed.
+ * @returns new buffer with byte order reversed.
+ * @publicbody
+ */
+export function swapByteOrder(buffer: Buffer): Buffer {
+  return Buffer.from(buffer).reverse()
+}
+
+/**
+ * @param num a number value in the Uint32 value range
+ * @param littleEndian true for little-endian byte order in Buffer
+ * @returns four byte buffer with Uint32 number encoded
+ * @publicbody
+ */
+export function convertUint32ToBuffer(num: number, littleEndian = true): Buffer {
+  const arr = new ArrayBuffer(4)
+  const view = new DataView(arr)
+  view.setUint32(0, num, littleEndian) // byteOffset = 0
+  return Buffer.from(arr)
+}
+
+/**
+ * @param buffer four byte buffer with Uint32 number encoded
+ * @param littleEndian true for little-endian byte order in Buffer
+ * @returns a number value in the Uint32 value range
+ * @publicbody
+ */
+export function convertBufferToUint32(buffer: Buffer, littleEndian = true): number {
+  const arr = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+  const view = new DataView(arr)
+  return view.getUint32(0, littleEndian)
+}

package/src/storage/methods/utils.ts

@@ -0,0 +1,56 @@
+import { sdk } from '../../index.client'
+
+/**
+ * Returns the byte size required to encode number as Bitcoin VarUint
+ * @publicbody
+ */
+export function varUintSize(val: number): 1 | 3 | 5 | 9 {
+  if (val < 0) throw new sdk.WERR_INVALID_PARAMETER('varUint', 'non-negative')
+  return val <= 0xfc ? 1 : val <= 0xffff ? 3 : val <= 0xffffffff ? 5 : 9
+}
+
+/**
+ * @param scriptSize byte length of input script
+ * @returns serialized byte length a transaction input
+ */
+export function transactionInputSize(scriptSize: number): number {
+  return (
+    32 + // txid
+    4 + // vout
+    varUintSize(scriptSize) + // script length, this is already in bytes
+    scriptSize + // script
+    4
+  ) // sequence number
+}
+
+/**
+ * @param scriptSize byte length of output script
+ * @returns serialized byte length a transaction output
+ */
+
+export function transactionOutputSize(scriptSize: number): number {
+  return (
+    varUintSize(scriptSize) + // output script length, from script encoded as hex string
+    scriptSize + // output script
+    8
+  ) // output amount (satoshis)
+}
+
+/**
+ * Compute the serialized binary transaction size in bytes
+ * given the number of inputs and outputs,
+ * and the size of each script.
+ * @param inputs array of input script lengths, in bytes
+ * @param outputs array of output script lengths, in bytes
+ * @returns total transaction size in bytes
+ */
+export function transactionSize(inputs: number[], outputs: number[]): number {
+  return (
+    4 + // Version
+    varUintSize(inputs.length) + // Number of inputs
+    inputs.reduce((a, e) => a + transactionInputSize(e), 0) + // all inputs
+    varUintSize(outputs.length) + // Number of outputs
+    outputs.reduce((a, e) => a + transactionOutputSize(e), 0) + // all outputs
+    4
+  ) // lock time
+}

package/src/storage/remoting/StorageClient.ts

@@ -195,8 +195,8 @@ export class StorageClient implements sdk.WalletStorageProvider {
    * @param args Original wallet `internalizeAction` arguments.
    * @returns `internalizeAction` results
    */
-  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<InternalizeActionResult> {
-    return this.rpcCall<InternalizeActionResult>('internalizeAction', [auth, args])
+  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<sdk.StorageInternalizeActionResult> {
+    return this.rpcCall<sdk.StorageInternalizeActionResult>('internalizeAction', [auth, args])
   }
 
   /**

package/src/storage/remoting/StorageMobile.ts

@@ -195,8 +195,8 @@ export class StorageClient implements sdk.WalletStorageProvider {
    * @param args Original wallet `internalizeAction` arguments.
    * @returns `internalizeAction` results
    */
-  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<InternalizeActionResult> {
-    return this.rpcCall<InternalizeActionResult>('internalizeAction', [auth, args])
+  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<sdk.StorageInternalizeActionResult> {
+    return this.rpcCall<sdk.StorageInternalizeActionResult>('internalizeAction', [auth, args])
   }
 
   /**

package/src/storage/schema/KnexMigrations.ts

@@ -70,6 +70,19 @@ export class KnexMigrations implements MigrationSource<string> {
       }
     }
 
+    migrations['2025-05-13-001 add monitor events event index'] = {
+      async up(knex) {
+        await knex.schema.alterTable('monitor_events', table => {
+          table.index('event')
+        })
+      },
+      async down(knex) {
+        await knex.schema.alterTable('monitor_events', table => {
+          table.dropIndex('event')
+        })
+      }
+    }
+
     migrations['2025-03-03-001 descriptions to 2000'] = {
       async up(knex) {
         await knex.schema.alterTable('transactions', table => {

package/src/utility/Format.ts

@@ -0,0 +1,133 @@
+import { Beef, Transaction } from '@bsv/sdk'
+import * as sdk from '../sdk'
+import { TableTransaction } from '../storage/schema/tables'
+import { StorageAdminStats, StorageProvider } from '../storage/StorageProvider'
+
+export abstract class Format {
+  static alignLeft(v: string | number, fixedWidth: number): string {
+    v = v.toString()
+    if (v.length > fixedWidth) {
+      return v.slice(0, fixedWidth - 1) + '…'
+    }
+    return v.toString().padEnd(fixedWidth)
+  }
+
+  static alignRight(v: string | number, fixedWidth: number): string {
+    v = v.toString()
+    if (v.length > fixedWidth) {
+      return '…' + v.slice(-fixedWidth + 1)
+    }
+    return v.toString().padStart(fixedWidth)
+  }
+
+  static alignMiddle(v: string | number, fixedWidth: number): string {
+    v = v.toString()
+    if (v.length === fixedWidth) return v
+    const l = Math.ceil(fixedWidth / 2)
+    const r = Math.floor(fixedWidth / 2)
+    if (v.length > fixedWidth) {
+      return `${al(v, l)}${ar(v, r)}`
+    }
+    const pl = Math.ceil(v.length / 2)
+    const pr = Math.floor(v.length / 2)
+    return `${ar(v.slice(0, pl), l)}${al(v.slice(-pr), r)}`
+  }
+
+  static satoshis(s: number): string {
+    const minus = s < 0 ? '-' : ''
+    s = Math.abs(s)
+    let a = s.toString().split('')
+    if (a.length > 2) a.splice(-2, 0, '_')
+    if (a.length > 6) a.splice(-6, 0, '_')
+    if (a.length > 10) a.splice(-10, 0, '.')
+    if (a.length > 14) a.splice(-14, 0, '_')
+    if (a.length > 18) a.splice(-18, 0, '_')
+    let v = a.join('')
+    return minus + v
+  }
+
+  static toLogStringTransaction(tx: Transaction): string {
+    const txid = tx.id('hex')
+    try {
+      let log = ''
+      let totalIn = 0,
+        totalOut = 0
+      for (let i = 0; i < Math.max(tx.inputs.length, tx.outputs.length); i++) {
+        let ilog: string = ''
+        let olog: string = ''
+        if (i < tx.inputs.length) {
+          const input = tx.inputs[i]
+          const satoshis = input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis || 0
+          totalIn += satoshis
+          ilog = `${al(`${am(input.sourceTXID || '', 12)}.${input.sourceOutputIndex}`, 17)} ${ar(sa(satoshis), 12)}`
+        }
+        if (i < tx.outputs.length) {
+          const output = tx.outputs[i]
+          totalOut += output.satoshis || 0
+          const script = output.lockingScript.toHex()
+          olog = `${ar(sa(output.satoshis || 0), 12)} (${script.length})${am(script, 13)}`
+        }
+        log += `${al(ilog, 30)} ${ar('' + i, 5)} ${olog}\n`
+      }
+      let h = `txid ${txid}\n`
+      h += `total in:${sa(totalIn)} out:${sa(totalOut)} fee:${sa(totalIn - totalOut)}\n`
+      h += `${al('Inputs', 30)} ${ar('Vin/', 5)} ${'Outputs'}\n`
+      h += `${al('Outpoint', 17)} ${ar('Satoshis', 12)} ${ar('Vout', 5)} ${ar('Satoshis', 12)} ${al('Lock Script', 23)}\n`
+      return h + log
+    } catch (eu: unknown) {
+      const e = sdk.WalletError.fromUnknown(eu)
+      return `Transaction with txid ${txid} is invalid`
+    }
+  }
+
+  static toLogStringBeefTxid(beef: Beef, txid: string): string {
+    const tx = beef.findAtomicTransaction(txid)
+    if (!tx) return `Transaction ${txid} not found in beef`
+    return Format.toLogStringTransaction(tx)
+  }
+
+  static async toLogStringTableTransaction(tx: TableTransaction, storage: StorageProvider): Promise<string> {
+    if (!tx.txid) return `Transaction ${tx.transactionId} has no txid`
+    try {
+      const beef = await storage.getBeefForTransaction(tx.txid, { minProofLevel: 1 })
+      const log = Format.toLogStringBeefTxid(beef, tx.txid)
+      const h = `transactionId:${tx.transactionId} userId:${tx.userId} ${tx.status} satoshis:${sa(tx.satoshis)}\n`
+      return h + log
+    } catch (eu: unknown) {
+      const e = sdk.WalletError.fromUnknown(eu)
+      return `Transaction ${tx.transactionId} with txid ${tx.txid} is invalid`
+    }
+  }
+
+  static toLogStringAdminStats(s: StorageAdminStats): string {
+    let log = `StorageAdminStats: ${s.when} ${s.requestedBy}\n`
+    log += `  ${al('', 13)} ${ar('Day', 15)} ${ar('Month', 15)} ${ar('Total', 15)}\n`
+    log += dmt('users', s.usersDay, s.usersMonth, s.usersTotal)
+    log += dmt('change sats', sa(s.satoshisDefaultDay), sa(s.satoshisDefaultMonth), sa(s.satoshisDefaultTotal))
+    log += dmt('other sats', sa(s.satoshisOtherDay), sa(s.satoshisOtherMonth), sa(s.satoshisOtherTotal))
+    log += dmt('labels', s.labelsDay, s.labelsMonth, s.labelsTotal)
+    log += dmt('tags', s.tagsDay, s.tagsMonth, s.tagsTotal)
+    log += dmt('baskets', s.basketsDay, s.basketsMonth, s.basketsTotal)
+    log += dmt('transactions', s.transactionsDay, s.transactionsMonth, s.transactionsTotal)
+    log += dmt('  completed', s.txCompletedDay, s.txCompletedMonth, s.txCompletedTotal)
+    log += dmt('  failed', s.txFailedDay, s.txFailedMonth, s.txFailedTotal)
+    log += dmt('  nosend', s.txNosendDay, s.txNosendMonth, s.txNosendTotal)
+    log += dmt('  unproven', s.txUnprovenDay, s.txUnprovenMonth, s.txUnprovenTotal)
+    log += dmt('  sending', s.txSendingDay, s.txSendingMonth, s.txSendingTotal)
+    log += dmt('  unprocessed', s.txUnprocessedDay, s.txUnprocessedMonth, s.txUnprocessedTotal)
+    log += dmt('  unsigned', s.txUnsignedDay, s.txUnsignedMonth, s.txUnsignedTotal)
+    log += dmt('  nonfinal', s.txNonfinalDay, s.txNonfinalMonth, s.txNonfinalTotal)
+    log += dmt('  unfail', s.txUnfailDay, s.txUnfailMonth, s.txUnfailTotal)
+
+    return log
+
+    function dmt(l: string, d: number | string, m: number | string, t: number | string): string {
+      return `  ${al(l, 13)} ${ar(d, 15)} ${ar(m, 15)} ${ar(t, 15)}\n`
+    }
+  }
+}
+
+const al = Format.alignLeft
+const ar = Format.alignRight
+const am = Format.alignMiddle
+const sa = Format.satoshis

package/src/utility/utilityHelpers.ts

@@ -231,7 +231,7 @@ export function sha256Hash(data: number[]): number[] {
  * @returns double sha256 hash of data, byte 0 of hash first.
  * @publicbody
  */
-export function doubleSha256HashLE(data: number[]): number[] {
+export function doubleSha256LE(data: number[]): number[] {
   const first = new Hash.SHA256().update(data).digest()
   const second = new Hash.SHA256().update(first).digest()
   return second
@@ -244,5 +244,5 @@ export function doubleSha256HashLE(data: number[]): number[] {
  * @publicbody
  */
 export function doubleSha256BE(data: number[]): number[] {
-  return doubleSha256HashLE(data).reverse()
+  return doubleSha256LE(data).reverse()
 }