@bsv/wallet-toolbox 1.3.2 → 1.3.4

package/src/storage/StorageKnex.ts

@@ -27,8 +27,8 @@ import {
 import { Knex } from 'knex'
 import { StorageProvider, StorageProviderOptions } from './StorageProvider'
 import { purgeData } from './methods/purgeData'
-import { listActions } from './methods/listActions'
-import { listOutputs } from './methods/listOutputs'
+import { listActions } from './methods/listActionsKnex'
+import { listOutputs } from './methods/listOutputsKnex'
 import { DBType } from './StorageReader'
 import { reviewStatus } from './methods/reviewStatus'
 
@@ -835,19 +835,6 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     t.rawTx = rawTx
   }
 
-  async validateOutputScript(o: TableOutput, trx?: sdk.TrxToken): Promise<void> {
-    // without offset and length values return what we have (make no changes)
-    if (!o.scriptLength || !o.scriptOffset || !o.txid) return
-    // if there is an outputScript and its length is the expected length return what we have.
-    if (o.lockingScript && o.lockingScript.length === o.scriptLength) return
-
-    // outputScript is missing or has incorrect length...
-
-    const script = await this.getRawTxOfKnownValidTransaction(o.txid, o.scriptOffset, o.scriptLength, trx)
-    if (!script) return
-    o.lockingScript = script
-  }
-
   _verifiedReadyForDatabaseAccess: boolean = false
 
   /**
@@ -961,20 +948,6 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     return this.validateEntities(labels, undefined, ['isDeleted'])
   }
 
-  async extendOutput(
-    o: TableOutput,
-    includeBasket = false,
-    includeTags = false,
-    trx?: sdk.TrxToken
-  ): Promise<TableOutputX> {
-    const ox = o as TableOutputX
-    if (includeBasket && ox.basketId) ox.basket = await this.findOutputBasketById(o.basketId!, trx)
-    if (includeTags) {
-      ox.tags = await this.getTagsForOutputId(o.outputId)
-    }
-    return o
-  }
-
   override async getTagsForOutputId(outputId: number, trx?: sdk.TrxToken): Promise<TableOutputTag[]> {
     const tags = await this.toDb(trx)<TableOutputTag>('output_tags')
       .join('output_tags_map', 'output_tags_map.outputTagId', 'output_tags.outputTagId')
@@ -993,9 +966,11 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
   }
 
   /**
-   *  Finds closest matching available change output to use as input for new transaction.
-   *
-   * Transactionally allocate the output such that
+   * Counts the outputs for userId in basketId that are spendable: true
+   * AND whose transaction status is one of:
+   * - completed
+   * - unproven
+   * - sending (if excludeSending is false)
    */
   async countChangeInputs(userId: number, basketId: number, excludeSending: boolean): Promise<number> {
     const status: sdk.TransactionStatus[] = ['completed', 'unproven']

package/src/storage/StorageProvider.ts

@@ -22,6 +22,7 @@ import {
   TableOutput,
   TableOutputBasket,
   TableOutputTag,
+  TableOutputX,
   TableProvenTxReq,
   TableProvenTxReqDynamics,
   TableTransaction,
@@ -635,6 +636,33 @@ export abstract class StorageProvider extends StorageReaderWriter implements sdk
 
     return await this.updateProvenTxReq(id, partial, trx)
   }
+
+  async extendOutput(
+    o: TableOutput,
+    includeBasket = false,
+    includeTags = false,
+    trx?: sdk.TrxToken
+  ): Promise<TableOutputX> {
+    const ox = o as TableOutputX
+    if (includeBasket && ox.basketId) ox.basket = await this.findOutputBasketById(o.basketId!, trx)
+    if (includeTags) {
+      ox.tags = await this.getTagsForOutputId(o.outputId)
+    }
+    return o
+  }
+
+  async validateOutputScript(o: TableOutput, trx?: sdk.TrxToken): Promise<void> {
+    // without offset and length values return what we have (make no changes)
+    if (!o.scriptLength || !o.scriptOffset || !o.txid) return
+    // if there is an outputScript and its length is the expected length return what we have.
+    if (o.lockingScript && o.lockingScript.length === o.scriptLength) return
+
+    // outputScript is missing or has incorrect length...
+
+    const script = await this.getRawTxOfKnownValidTransaction(o.txid, o.scriptOffset, o.scriptLength, trx)
+    if (!script) return
+    o.lockingScript = script
+  }
 }
 
 export interface StorageProviderOptions extends StorageReaderWriterOptions {

package/src/storage/StorageReader.ts

@@ -51,6 +51,7 @@ export abstract class StorageReader implements sdk.WalletStorageSyncReader {
     return !!this._settings
   }
   async makeAvailable(): Promise<TableSettings> {
+    if (this._settings) return this._settings
     return (this._settings = await this.readSettings())
   }
 
@@ -115,6 +116,7 @@ export abstract class StorageReader implements sdk.WalletStorageSyncReader {
     if (!this.dbtype) throw new sdk.WERR_INTERNAL('must call verifyReadyForDatabaseAccess first')
     let r: Date | string = this.validateDate(date)
     switch (this.dbtype) {
+      case 'IndexedDB':
       case 'MySQL':
         break
       case 'SQLite':
@@ -140,6 +142,7 @@ export abstract class StorageReader implements sdk.WalletStorageSyncReader {
     let r: Date | string | undefined = this.validateOptionalDate(date)
     if (!r && useNowAsDefault) r = new Date()
     switch (this.dbtype) {
+      case 'IndexedDB':
       case 'MySQL':
         break
       case 'SQLite':
@@ -169,6 +172,7 @@ export abstract class StorageReader implements sdk.WalletStorageSyncReader {
     const vdate = verifyTruthy(this.validateDate(date))
     let r: Date | string | number
     switch (this.dbtype) {
+      case 'IndexedDB':
       case 'MySQL':
         r = vdate
         break
@@ -186,7 +190,7 @@ export interface StorageReaderOptions {
   chain: sdk.Chain
 }
 
-export type DBType = 'SQLite' | 'MySQL'
+export type DBType = 'SQLite' | 'MySQL' | 'IndexedDB'
 
 type DbEntityTimeStamp<T extends sdk.EntityTimeStamp> = {
   [K in keyof T]: T[K] extends Date ? Date | string : T[K]

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

@@ -0,0 +1,15 @@
+import { StorageIdb } from '../StorageIdb'
+import { StorageProvider, StorageProviderOptions } from '../StorageProvider'
+import 'fake-indexeddb/auto'
+
+describe('StorageIdb tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0', async () => {
+    const options: StorageProviderOptions = StorageProvider.createStorageBaseOptions('main')
+    const storage = new StorageIdb(options)
+    const r = await storage.migrate('storageIdbTest', `42`.repeat(32))
+    const db = storage.db!
+    expect(db).toBeTruthy()
+  })
+})

package/src/storage/methods/ListActionsSpecOp.ts

@@ -0,0 +1,68 @@
+import { sdk } from '../../index.client'
+import { TableTransaction } from '../index.client'
+import { StorageProvider } from '../StorageProvider'
+
+export interface ListActionsSpecOp {
+  name: string
+  /**
+   * undefined to intercept no labels from vargs,
+   * empty array to intercept all labels,
+   * or an explicit array of labels to intercept.
+   */
+  labelsToIntercept?: string[]
+  setStatusFilter?: () => sdk.TransactionStatus[]
+  postProcess?: (
+    s: StorageProvider,
+    auth: sdk.AuthId,
+    vargs: sdk.ValidListActionsArgs,
+    specOpLabels: string[],
+    txs: Partial<TableTransaction>[]
+  ) => Promise<void>
+}
+
+export const getLabelToSpecOp: () => Record<string, ListActionsSpecOp> = () => {
+  return {
+    [sdk.specOpNoSendActions]: {
+      name: 'noSendActions',
+      labelsToIntercept: ['abort'],
+      setStatusFilter: () => ['nosend'],
+      postProcess: async (
+        s: StorageProvider,
+        auth: sdk.AuthId,
+        vargs: sdk.ValidListActionsArgs,
+        specOpLabels: string[],
+        txs: Partial<TableTransaction>[]
+      ): Promise<void> => {
+        if (specOpLabels.indexOf('abort') >= 0) {
+          for (const tx of txs) {
+            if (tx.status === 'nosend') {
+              await s.abortAction(auth, { reference: tx.reference! })
+              tx.status = 'failed'
+            }
+          }
+        }
+      }
+    },
+    [sdk.specOpFailedActions]: {
+      name: 'failedActions',
+      labelsToIntercept: ['unfail'],
+      setStatusFilter: () => ['failed'],
+      postProcess: async (
+        s: StorageProvider,
+        auth: sdk.AuthId,
+        vargs: sdk.ValidListActionsArgs,
+        specOpLabels: string[],
+        txs: Partial<TableTransaction>[]
+      ): Promise<void> => {
+        if (specOpLabels.indexOf('unfail') >= 0) {
+          for (const tx of txs) {
+            if (tx.status === 'failed') {
+              await s.updateTransaction(tx.transactionId!, { status: 'unfail' })
+              // wallet wire does not support 'unfail' status, return as 'failed'.
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/storage/methods/ListOutputsSpecOp.ts

@@ -0,0 +1,125 @@
+import { ListOutputsResult } from '@bsv/sdk'
+import { StorageProvider, TableOutput } from '../index.client'
+import { asString, sdk, verifyId, verifyInteger, verifyOne } from '../../index.client'
+import { ValidListOutputsArgs } from '../../sdk/validationHelpers'
+
+export interface ListOutputsSpecOp {
+  name: string
+  useBasket?: string
+  ignoreLimit?: boolean
+  includeOutputScripts?: boolean
+  includeSpent?: boolean
+  resultFromTags?: (
+    s: StorageProvider,
+    auth: sdk.AuthId,
+    vargs: ValidListOutputsArgs,
+    specOpTags: string[]
+  ) => Promise<ListOutputsResult>
+  resultFromOutputs?: (
+    s: StorageProvider,
+    auth: sdk.AuthId,
+    vargs: ValidListOutputsArgs,
+    specOpTags: string[],
+    outputs: TableOutput[]
+  ) => Promise<ListOutputsResult>
+  filterOutputs?: (
+    s: StorageProvider,
+    auth: sdk.AuthId,
+    vargs: ValidListOutputsArgs,
+    specOpTags: string[],
+    outputs: TableOutput[]
+  ) => Promise<TableOutput[]>
+  /**
+   * undefined to intercept no tags from vargs,
+   * empty array to intercept all tags,
+   * or an explicit array of tags to intercept.
+   */
+  tagsToIntercept?: string[]
+  /**
+   * How many positional tags to intercept.
+   */
+  tagsParamsCount?: number
+}
+
+export const getBasketToSpecOp: () => Record<string, ListOutputsSpecOp> = () => {
+  return {
+    [sdk.specOpWalletBalance]: {
+      name: 'totalOutputsIsWalletBalance',
+      useBasket: 'default',
+      ignoreLimit: true,
+      resultFromOutputs: async (
+        s: StorageProvider,
+        auth: sdk.AuthId,
+        vargs: ValidListOutputsArgs,
+        specOpTags: string[],
+        outputs: TableOutput[]
+      ): Promise<ListOutputsResult> => {
+        let totalOutputs = 0
+        for (const o of outputs) totalOutputs += o.satoshis
+        return { totalOutputs, outputs: [] }
+      }
+    },
+    [sdk.specOpInvalidChange]: {
+      name: 'invalidChangeOutputs',
+      useBasket: 'default',
+      ignoreLimit: true,
+      includeOutputScripts: true,
+      includeSpent: false,
+      tagsToIntercept: ['release', 'all'],
+      filterOutputs: async (
+        s: StorageProvider,
+        auth: sdk.AuthId,
+        vargs: ValidListOutputsArgs,
+        specOpTags: string[],
+        outputs: TableOutput[]
+      ): Promise<TableOutput[]> => {
+        const filteredOutputs: TableOutput[] = []
+        const services = s.getServices()
+        for (const o of outputs) {
+          await s.validateOutputScript(o)
+          let ok: boolean | undefined = false
+          if (o.lockingScript && o.lockingScript.length > 0) {
+            ok = await services.isUtxo(o)
+          } else {
+            ok = undefined
+          }
+          if (ok === false) {
+            filteredOutputs.push(o)
+          }
+        }
+        if (specOpTags.indexOf('release') >= 0) {
+          for (const o of filteredOutputs) {
+            await s.updateOutput(o.outputId, { spendable: false })
+            o.spendable = false
+          }
+        }
+        return filteredOutputs
+      }
+    },
+    [sdk.specOpSetWalletChangeParams]: {
+      name: 'setWalletChangeParams',
+      tagsParamsCount: 2,
+      resultFromTags: async (
+        s: StorageProvider,
+        auth: sdk.AuthId,
+        vargs: ValidListOutputsArgs,
+        specOpTags: string[]
+      ): Promise<ListOutputsResult> => {
+        if (specOpTags.length !== 2)
+          throw new sdk.WERR_INVALID_PARAMETER('numberOfDesiredUTXOs and minimumDesiredUTXOValue', 'valid')
+        const numberOfDesiredUTXOs: number = verifyInteger(Number(specOpTags[0]))
+        const minimumDesiredUTXOValue: number = verifyInteger(Number(specOpTags[1]))
+        const basket = verifyOne(
+          await s.findOutputBaskets({
+            partial: { userId: verifyId(auth.userId), name: 'default' }
+          })
+        )
+        await s.updateOutputBasket(basket.basketId, {
+          numberOfDesiredUTXOs,
+          minimumDesiredUTXOValue
+        })
+        return { totalOutputs: 0, outputs: [] }
+      }
+    }
+  }
+}

package/src/storage/methods/listActionsIdb.ts

@@ -0,0 +1,181 @@
+import {
+  Transaction as BsvTransaction,
+  ActionStatus,
+  ListActionsResult,
+  WalletAction,
+  WalletActionOutput,
+  WalletActionInput
+} from '@bsv/sdk'
+import { TableOutputX, TableTransaction, TableTxLabel } from '../index.client'
+import { asString, sdk, verifyOne } from '../../index.client'
+import { isListActionsSpecOp, TransactionStatus } from '../../sdk'
+import { StorageIdb } from '../StorageIdb'
+import { getLabelToSpecOp, ListActionsSpecOp } from './ListActionsSpecOp'
+
+export async function listActionsIdb(
+  storage: StorageIdb,
+  auth: sdk.AuthId,
+  vargs: sdk.ValidListActionsArgs
+): Promise<ListActionsResult> {
+  const limit = vargs.limit
+  const offset = vargs.offset
+
+  const r: ListActionsResult = {
+    totalActions: 0,
+    actions: []
+  }
+
+  let specOp: ListActionsSpecOp | undefined = undefined
+  let specOpLabels: string[] = []
+  let labels: string[] = []
+  for (const label of vargs.labels) {
+    if (isListActionsSpecOp(label)) {
+      specOp = getLabelToSpecOp()[label]
+    } else {
+      labels.push(label)
+    }
+  }
+  if (specOp?.labelsToIntercept !== undefined) {
+    const intercept = specOp.labelsToIntercept!
+    const labels2 = labels
+    labels = []
+    if (intercept.length === 0) {
+      specOpLabels = labels2
+    }
+    for (const label of labels2) {
+      if (intercept.indexOf(label) >= 0) {
+        specOpLabels.push(label)
+      } else {
+        labels.push(label)
+      }
+    }
+  }
+
+  let labelIds: number[] = []
+  if (labels.length > 0) {
+    await storage.filterTxLabels({ partial: { userId: auth.userId, isDeleted: false } }, tl => {
+      if (labels.includes(tl.label)) {
+        labelIds.push(tl.txLabelId)
+      }
+    })
+  }
+
+  const isQueryModeAll = vargs.labelQueryMode === 'all'
+  if (isQueryModeAll && labelIds.length < labels.length)
+    // all the required labels don't exist, impossible to satisfy.
+    return r
+
+  if (!isQueryModeAll && labelIds.length === 0 && labels.length > 0)
+    // any and only non-existing labels, impossible to satisfy.
+    return r
+
+  const stati: TransactionStatus[] = specOp?.setStatusFilter
+    ? specOp.setStatusFilter()
+    : ['completed', 'unprocessed', 'sending', 'unproven', 'unsigned', 'nosend', 'nonfinal']
+
+  const noLabels = labelIds.length === 0
+
+  const txs = await storage.findTransactions(
+    {
+      partial: { userId: auth.userId },
+      status: stati,
+      paged: { limit: vargs.limit, offset: vargs.offset },
+      noRawTx: true
+    },
+    labelIds,
+    isQueryModeAll
+  )
+  if (txs.length === vargs.limit) {
+    r.totalActions = await storage.countTransactions(
+      { partial: { userId: auth.userId }, status: stati },
+      labelIds,
+      isQueryModeAll
+    )
+  } else {
+    r.totalActions = txs.length
+  }
+
+  if (specOp?.postProcess) {
+    await specOp.postProcess(storage, auth, vargs, specOpLabels, txs)
+  }
+
+  for (const tx of txs) {
+    const wtx: WalletAction = {
+      txid: tx.txid || '',
+      satoshis: tx.satoshis || 0,
+      status: <ActionStatus>tx.status!,
+      isOutgoing: !!tx.isOutgoing,
+      description: tx.description || '',
+      version: tx.version || 0,
+      lockTime: tx.lockTime || 0
+    }
+    r.actions.push(wtx)
+  }
+
+  if (vargs.includeLabels || vargs.includeInputs || vargs.includeOutputs) {
+    await Promise.all(
+      txs.map(async (tx, i) => {
+        //let i = -1
+        //for (const tx of txs) {
+        //    i++
+        const action = r.actions[i]
+        if (vargs.includeLabels) {
+          action.labels = (await storage.getLabelsForTransactionId(tx.transactionId)).map(l => l.label)
+        }
+        if (vargs.includeOutputs) {
+          const outputs: TableOutputX[] = await storage.findOutputs({
+            partial: { transactionId: tx.transactionId },
+            noScript: !vargs.includeOutputLockingScripts
+          })
+          action.outputs = []
+          for (const o of outputs) {
+            await storage.extendOutput(o, true, true)
+            const wo: WalletActionOutput = {
+              satoshis: o.satoshis || 0,
+              spendable: !!o.spendable,
+              tags: o.tags?.map(t => t.tag) || [],
+              outputIndex: Number(o.vout),
+              outputDescription: o.outputDescription || '',
+              basket: o.basket?.name || ''
+            }
+            if (vargs.includeOutputLockingScripts) wo.lockingScript = asString(o.lockingScript || [])
+            action.outputs.push(wo)
+          }
+        }
+        if (vargs.includeInputs) {
+          const inputs: TableOutputX[] = await storage.findOutputs({
+            partial: { spentBy: tx.transactionId },
+            noScript: !vargs.includeInputSourceLockingScripts
+          })
+          action.inputs = []
+          if (inputs.length > 0) {
+            const rawTx = await storage.getRawTxOfKnownValidTransaction(tx.txid)
+            let bsvTx: BsvTransaction | undefined = undefined
+            if (rawTx) {
+              bsvTx = BsvTransaction.fromBinary(rawTx)
+            }
+            for (const o of inputs) {
+              await storage.extendOutput(o, true, true)
+              const input = bsvTx?.inputs.find(v => v.sourceTXID === o.txid && v.sourceOutputIndex === o.vout)
+              const wo: WalletActionInput = {
+                sourceOutpoint: `${o.txid}.${o.vout}`,
+                sourceSatoshis: o.satoshis || 0,
+                inputDescription: o.outputDescription || '',
+                sequenceNumber: input?.sequence || 0
+              }
+              action.inputs.push(wo)
+              if (vargs.includeInputSourceLockingScripts) {
+                wo.sourceLockingScript = asString(o.lockingScript || [])
+              }
+              if (vargs.includeInputUnlockingScripts) {
+                wo.unlockingScript = input?.unlockingScript?.toHex()
+              }
+            }
+          }
+        }
+        //}
+      })
+    )
+  }
+  return r
+}

package/src/storage/methods/{listActions.ts → listActionsKnex.ts}

@@ -10,69 +10,7 @@ import { TableOutputX, TableTransaction, TableTxLabel } from '../index.client'
 import { asString, sdk, verifyOne } from '../../index.client'
 import { StorageKnex } from '../StorageKnex'
 import { isListActionsSpecOp } from '../../sdk'
-
-interface ListActionsSpecOp {
-  name: string
-  /**
-   * undefined to intercept no labels from vargs,
-   * empty array to intercept all labels,
-   * or an explicit array of labels to intercept.
-   */
-  labelsToIntercept?: string[]
-  setStatusFilter?: () => string[]
-  postProcess?: (
-    s: StorageKnex,
-    auth: sdk.AuthId,
-    vargs: sdk.ValidListActionsArgs,
-    specOpLabels: string[],
-    txs: Partial<TableTransaction>[]
-  ) => Promise<void>
-}
-
-const labelToSpecOp: Record<string, ListActionsSpecOp> = {
-  [sdk.specOpNoSendActions]: {
-    name: 'noSendActions',
-    labelsToIntercept: ['abort'],
-    setStatusFilter: () => ['nosend'],
-    postProcess: async (
-      s: StorageKnex,
-      auth: sdk.AuthId,
-      vargs: sdk.ValidListActionsArgs,
-      specOpLabels: string[],
-      txs: Partial<TableTransaction>[]
-    ): Promise<void> => {
-      if (specOpLabels.indexOf('abort') >= 0) {
-        for (const tx of txs) {
-          if (tx.status === 'nosend') {
-            await s.abortAction(auth, { reference: tx.reference! })
-            tx.status = 'failed'
-          }
-        }
-      }
-    }
-  },
-  [sdk.specOpFailedActions]: {
-    name: 'failedActions',
-    labelsToIntercept: ['unfail'],
-    setStatusFilter: () => ['failed'],
-    postProcess: async (
-      s: StorageKnex,
-      auth: sdk.AuthId,
-      vargs: sdk.ValidListActionsArgs,
-      specOpLabels: string[],
-      txs: Partial<TableTransaction>[]
-    ): Promise<void> => {
-      if (specOpLabels.indexOf('unfail') >= 0) {
-        for (const tx of txs) {
-          if (tx.status === 'failed') {
-            await s.updateTransaction(tx.transactionId!, { status: 'unfail' })
-            // wallet wire does not support 'unfail' status, return as 'failed'.
-          }
-        }
-      }
-    }
-  }
-}
+import { getLabelToSpecOp, ListActionsSpecOp } from './ListActionsSpecOp'
 
 export async function listActions(
   storage: StorageKnex,
@@ -94,7 +32,7 @@ export async function listActions(
   let labels: string[] = []
   for (const label of vargs.labels) {
     if (isListActionsSpecOp(label)) {
-      specOp = labelToSpecOp[label]
+      specOp = getLabelToSpecOp()[label]
     } else {
       labels.push(label)
     }