@bopen-io/wallet-toolbox 1.7.18

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

@@ -0,0 +1,385 @@
+import { Beef, ListActionsResult, ListOutputsResult, Utils, Validation } from '@bsv/sdk'
+import { StorageAdminStats, StorageProvider } from '../StorageProvider'
+import { Chain } from '../../sdk/types'
+import { Services } from '../../services/Services'
+import {
+  TableCertificate,
+  TableCertificateField,
+  TableCertificateX,
+  TableCommission,
+  TableMonitorEvent,
+  TableOutput,
+  TableOutputBasket,
+  TableOutputTag,
+  TableOutputTagMap,
+  TableProvenTx,
+  TableProvenTxReq,
+  TableSettings,
+  TableSyncState,
+  TableTransaction,
+  TableTxLabel,
+  TableTxLabelMap,
+  TableUser
+} from '../schema/tables'
+import {
+  AuthId,
+  FindCertificateFieldsArgs,
+  FindCertificatesArgs,
+  FindCommissionsArgs,
+  FindForUserSincePagedArgs,
+  FindMonitorEventsArgs,
+  FindOutputBasketsArgs,
+  FindOutputsArgs,
+  FindOutputTagMapsArgs,
+  FindOutputTagsArgs,
+  FindProvenTxReqsArgs,
+  FindProvenTxsArgs,
+  FindSyncStatesArgs,
+  FindTransactionsArgs,
+  FindTxLabelMapsArgs,
+  FindTxLabelsArgs,
+  FindUsersArgs,
+  ProvenOrRawTx,
+  PurgeParams,
+  PurgeResults,
+  StorageGetBeefOptions,
+  TrxToken
+} from '../../sdk/WalletStorage.interfaces'
+
+describe('getBeefForTransaction tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 ProtoStorage.getBeefForTxid', async () => {
+    const ps = new ProtoStorage('main')
+    const beef = await ps.getBeefForTxid('794f836052ad73732a550c38bea3697a722c6a1e54bcbe63735ba79e0d23f623')
+    expect(beef.bumps.length > 0)
+    {
+      const beef = await ps.getBeefForTxid('53023657e79f446ca457040a0ab3b903000d7281a091397c7853f021726a560e')
+      expect(beef.bumps.length > 0)
+    }
+  })
+
+  test.skip('1 obtain atomic beef hex for txid', async () => {
+    const ps = new ProtoStorage('main')
+    const txid = '4cefbe79926d6ef2cc727d8faccac186d9bb141f170411dd75bc6329f428f5a4'
+    const beef = await ps.getBeefForTxid(txid)
+    expect(beef.bumps.length > 0)
+    console.log(beef.toLogString())
+    const hex = Utils.toHex(beef.toBinaryAtomic(txid))
+    console.log(hex)
+  })
+})
+
+class ProtoStorage extends StorageProvider {
+  gbo: StorageGetBeefOptions
+  whatsOnChainApiKey?: string
+
+  constructor(chain: Chain) {
+    const o = StorageProvider.createStorageBaseOptions(chain)
+    super(o)
+    const so = Services.createDefaultOptions(chain)
+    // so.whatsOnChainApiKey = 'my_api_key'
+    const s = new Services(so)
+    this.setServices(s)
+    this.gbo = {
+      ignoreNewProven: true,
+      ignoreServices: false,
+      ignoreStorage: true
+    }
+    this.maxRecursionDepth = 2
+  }
+
+  async getBeefForTxid(txid: string): Promise<Beef> {
+    const beef = this.getBeefForTransaction(txid, this.gbo)
+    return beef
+  }
+
+  nip = new Error('Method not implemented.')
+  override reviewStatus(args: { agedLimit: Date; trx?: TrxToken }): Promise<{ log: string }> {
+    throw this.nip
+  }
+  override purgeData(params: PurgeParams, trx?: TrxToken): Promise<PurgeResults> {
+    throw this.nip
+  }
+  override allocateChangeInput(
+    userId: number,
+    basketId: number,
+    targetSatoshis: number,
+    exactSatoshis: number | undefined,
+    excludeSending: boolean,
+    transactionId: number
+  ): Promise<TableOutput | undefined> {
+    throw this.nip
+  }
+  override getProvenOrRawTx(txid: string, trx?: TrxToken): Promise<ProvenOrRawTx> {
+    throw this.nip
+  }
+  override getRawTxOfKnownValidTransaction(
+    txid?: string,
+    offset?: number,
+    length?: number,
+    trx?: TrxToken
+  ): Promise<number[] | undefined> {
+    throw this.nip
+  }
+  override getLabelsForTransactionId(transactionId?: number, trx?: TrxToken): Promise<TableTxLabel[]> {
+    throw this.nip
+  }
+  override getTagsForOutputId(outputId: number, trx?: TrxToken): Promise<TableOutputTag[]> {
+    throw this.nip
+  }
+  override listActions(auth: AuthId, args: Validation.ValidListActionsArgs): Promise<ListActionsResult> {
+    throw this.nip
+  }
+  override listOutputs(auth: AuthId, args: Validation.ValidListOutputsArgs): Promise<ListOutputsResult> {
+    throw this.nip
+  }
+  override countChangeInputs(userId: number, basketId: number, excludeSending: boolean): Promise<number> {
+    throw this.nip
+  }
+  override findCertificatesAuth(auth: AuthId, args: FindCertificatesArgs): Promise<TableCertificateX[]> {
+    throw this.nip
+  }
+  override findOutputBasketsAuth(auth: AuthId, args: FindOutputBasketsArgs): Promise<TableOutputBasket[]> {
+    throw this.nip
+  }
+  override findOutputsAuth(auth: AuthId, args: FindOutputsArgs): Promise<TableOutput[]> {
+    throw this.nip
+  }
+  override insertCertificateAuth(auth: AuthId, certificate: TableCertificateX): Promise<number> {
+    throw this.nip
+  }
+  override dropAllData(): Promise<void> {
+    throw this.nip
+  }
+  override migrate(storageName: string, storageIdentityKey: string): Promise<string> {
+    throw this.nip
+  }
+  override findOutputTagMaps(args: FindOutputTagMapsArgs): Promise<TableOutputTagMap[]> {
+    throw this.nip
+  }
+  override findProvenTxReqs(args: FindProvenTxReqsArgs): Promise<TableProvenTxReq[]> {
+    throw this.nip
+  }
+  override findProvenTxs(args: FindProvenTxsArgs): Promise<TableProvenTx[]> {
+    throw this.nip
+  }
+  override findTxLabelMaps(args: FindTxLabelMapsArgs): Promise<TableTxLabelMap[]> {
+    throw this.nip
+  }
+  override countOutputTagMaps(args: FindOutputTagMapsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countProvenTxReqs(args: FindProvenTxReqsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countProvenTxs(args: FindProvenTxsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countTxLabelMaps(args: FindTxLabelMapsArgs): Promise<number> {
+    throw this.nip
+  }
+  override insertCertificate(certificate: TableCertificate, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertCertificateField(certificateField: TableCertificateField, trx?: TrxToken): Promise<void> {
+    throw this.nip
+  }
+  override insertCommission(commission: TableCommission, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertMonitorEvent(event: TableMonitorEvent, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertOutput(output: TableOutput, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertOutputBasket(basket: TableOutputBasket, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertOutputTag(tag: TableOutputTag, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertOutputTagMap(tagMap: TableOutputTagMap, trx?: TrxToken): Promise<void> {
+    throw this.nip
+  }
+  override insertProvenTx(tx: TableProvenTx, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertProvenTxReq(tx: TableProvenTxReq, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertSyncState(syncState: TableSyncState, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertTransaction(tx: TableTransaction, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertTxLabel(label: TableTxLabel, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override insertTxLabelMap(labelMap: TableTxLabelMap, trx?: TrxToken): Promise<void> {
+    throw this.nip
+  }
+  override insertUser(user: TableUser, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateCertificate(id: number, update: Partial<TableCertificate>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateCertificateField(
+    certificateId: number,
+    fieldName: string,
+    update: Partial<TableCertificateField>,
+    trx?: TrxToken
+  ): Promise<number> {
+    throw this.nip
+  }
+  override updateCommission(id: number, update: Partial<TableCommission>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateMonitorEvent(id: number, update: Partial<TableMonitorEvent>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateOutput(id: number, update: Partial<TableOutput>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateOutputBasket(id: number, update: Partial<TableOutputBasket>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateOutputTag(id: number, update: Partial<TableOutputTag>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateOutputTagMap(
+    outputId: number,
+    tagId: number,
+    update: Partial<TableOutputTagMap>,
+    trx?: TrxToken
+  ): Promise<number> {
+    throw this.nip
+  }
+  override updateProvenTx(id: number, update: Partial<TableProvenTx>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateProvenTxReq(
+    id: number | number[],
+    update: Partial<TableProvenTxReq>,
+    trx?: TrxToken
+  ): Promise<number> {
+    throw this.nip
+  }
+  override updateSyncState(id: number, update: Partial<TableSyncState>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateTransaction(
+    id: number | number[],
+    update: Partial<TableTransaction>,
+    trx?: TrxToken
+  ): Promise<number> {
+    throw this.nip
+  }
+  override updateTxLabel(id: number, update: Partial<TableTxLabel>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override updateTxLabelMap(
+    transactionId: number,
+    txLabelId: number,
+    update: Partial<TableTxLabelMap>,
+    trx?: TrxToken
+  ): Promise<number> {
+    throw this.nip
+  }
+  override updateUser(id: number, update: Partial<TableUser>, trx?: TrxToken): Promise<number> {
+    throw this.nip
+  }
+  override destroy(): Promise<void> {
+    throw this.nip
+  }
+  override transaction<T>(scope: (trx: TrxToken) => Promise<T>, trx?: TrxToken): Promise<T> {
+    throw this.nip
+  }
+  override readSettings(trx?: TrxToken): Promise<TableSettings> {
+    throw this.nip
+  }
+  override findCertificateFields(args: FindCertificateFieldsArgs): Promise<TableCertificateField[]> {
+    throw this.nip
+  }
+  override findCertificates(args: FindCertificatesArgs): Promise<TableCertificateX[]> {
+    throw this.nip
+  }
+  override findCommissions(args: FindCommissionsArgs): Promise<TableCommission[]> {
+    throw this.nip
+  }
+  override findMonitorEvents(args: FindMonitorEventsArgs): Promise<TableMonitorEvent[]> {
+    throw this.nip
+  }
+  override findOutputBaskets(args: FindOutputBasketsArgs): Promise<TableOutputBasket[]> {
+    throw this.nip
+  }
+  override findOutputs(args: FindOutputsArgs): Promise<TableOutput[]> {
+    throw this.nip
+  }
+  override findOutputTags(args: FindOutputTagsArgs): Promise<TableOutputTag[]> {
+    throw this.nip
+  }
+  override findSyncStates(args: FindSyncStatesArgs): Promise<TableSyncState[]> {
+    throw this.nip
+  }
+  override findTransactions(args: FindTransactionsArgs): Promise<TableTransaction[]> {
+    throw this.nip
+  }
+  override findTxLabels(args: FindTxLabelsArgs): Promise<TableTxLabel[]> {
+    throw this.nip
+  }
+  override findUsers(args: FindUsersArgs): Promise<TableUser[]> {
+    throw this.nip
+  }
+  override countCertificateFields(args: FindCertificateFieldsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countCertificates(args: FindCertificatesArgs): Promise<number> {
+    throw this.nip
+  }
+  override countCommissions(args: FindCommissionsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countMonitorEvents(args: FindMonitorEventsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countOutputBaskets(args: FindOutputBasketsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countOutputs(args: FindOutputsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countOutputTags(args: FindOutputTagsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countSyncStates(args: FindSyncStatesArgs): Promise<number> {
+    throw this.nip
+  }
+  override countTransactions(args: FindTransactionsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countTxLabels(args: FindTxLabelsArgs): Promise<number> {
+    throw this.nip
+  }
+  override countUsers(args: FindUsersArgs): Promise<number> {
+    throw this.nip
+  }
+  override getProvenTxsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTx[]> {
+    throw this.nip
+  }
+  override getProvenTxReqsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTxReq[]> {
+    throw this.nip
+  }
+  override getTxLabelMapsForUser(args: FindForUserSincePagedArgs): Promise<TableTxLabelMap[]> {
+    throw this.nip
+  }
+  override getOutputTagMapsForUser(args: FindForUserSincePagedArgs): Promise<TableOutputTagMap[]> {
+    throw this.nip
+  }
+  override adminStats(adminIdentityKey: string): Promise<StorageAdminStats> {
+    throw this.nip
+  }
+}

package/src/storage/index.all.ts

@@ -0,0 +1,11 @@
+export * from './WalletStorageManager'
+export * from './StorageProvider'
+export * from './StorageSyncReader'
+export * from './remoting/StorageClient'
+export * from './remoting/StorageServer'
+export * from './schema/KnexMigrations'
+export * from './StorageKnex'
+export * from './StorageIdb'
+export * from './schema/tables/index'
+export * from './schema/entities/index'
+export * as sync from './sync'

package/src/storage/index.client.ts

@@ -0,0 +1,7 @@
+export * from './WalletStorageManager'
+export * from './StorageIdb'
+export * from './StorageProvider'
+export * from './StorageSyncReader'
+export * from './schema/tables/index'
+export * from './schema/entities/index'
+export * from './remoting/StorageClient'

package/src/storage/index.mobile.ts

@@ -0,0 +1,6 @@
+export * from './WalletStorageManager'
+export * from './StorageProvider'
+export * from './StorageSyncReader'
+export * from './schema/tables/index'
+export * from './schema/entities/index'
+export * from './remoting/StorageMobile'

package/src/storage/methods/ListActionsSpecOp.ts

@@ -0,0 +1,70 @@
+import { Validation } from '@bsv/sdk'
+import { specOpFailedActions, specOpNoSendActions, TransactionStatus } from '../../sdk/types'
+import { AuthId } from '../../sdk/WalletStorage.interfaces'
+import { TableTransaction } from '../schema/tables/TableTransaction'
+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?: () => TransactionStatus[]
+  postProcess?: (
+    s: StorageProvider,
+    auth: AuthId,
+    vargs: Validation.ValidListActionsArgs,
+    specOpLabels: string[],
+    txs: Partial<TableTransaction>[]
+  ) => Promise<void>
+}
+
+export const getLabelToSpecOp: () => Record<string, ListActionsSpecOp> = () => {
+  return {
+    [specOpNoSendActions]: {
+      name: 'noSendActions',
+      labelsToIntercept: ['abort'],
+      setStatusFilter: () => ['nosend'],
+      postProcess: async (
+        s: StorageProvider,
+        auth: AuthId,
+        vargs: Validation.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'
+            }
+          }
+        }
+      }
+    },
+    [specOpFailedActions]: {
+      name: 'failedActions',
+      labelsToIntercept: ['unfail'],
+      setStatusFilter: () => ['failed'],
+      postProcess: async (
+        s: StorageProvider,
+        auth: AuthId,
+        vargs: Validation.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,129 @@
+import { ListOutputsResult, Validation } from '@bsv/sdk'
+import { StorageProvider } from '../StorageProvider'
+import { AuthId } from '../../sdk/WalletStorage.interfaces'
+import { TableOutput } from '../schema/tables/TableOutput'
+import { specOpInvalidChange, specOpSetWalletChangeParams, specOpWalletBalance } from '../../sdk/types'
+import { verifyId, verifyInteger, verifyOne } from '../../utility/utilityHelpers'
+import { WERR_INVALID_PARAMETER } from '../../sdk/WERR_errors'
+
+export interface ListOutputsSpecOp {
+  name: string
+  useBasket?: string
+  ignoreLimit?: boolean
+  includeOutputScripts?: boolean
+  includeSpent?: boolean
+  resultFromTags?: (
+    s: StorageProvider,
+    auth: AuthId,
+    vargs: Validation.ValidListOutputsArgs,
+    specOpTags: string[]
+  ) => Promise<ListOutputsResult>
+  resultFromOutputs?: (
+    s: StorageProvider,
+    auth: AuthId,
+    vargs: Validation.ValidListOutputsArgs,
+    specOpTags: string[],
+    outputs: TableOutput[]
+  ) => Promise<ListOutputsResult>
+  filterOutputs?: (
+    s: StorageProvider,
+    auth: AuthId,
+    vargs: Validation.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 {
+    [specOpWalletBalance]: {
+      name: 'totalOutputsIsWalletBalance',
+      useBasket: 'default',
+      ignoreLimit: true,
+      resultFromOutputs: async (
+        s: StorageProvider,
+        auth: AuthId,
+        vargs: Validation.ValidListOutputsArgs,
+        specOpTags: string[],
+        outputs: TableOutput[]
+      ): Promise<ListOutputsResult> => {
+        let totalOutputs = 0
+        for (const o of outputs) totalOutputs += o.satoshis
+        return { totalOutputs, outputs: [] }
+      }
+    },
+    [specOpInvalidChange]: {
+      name: 'invalidChangeOutputs',
+      useBasket: 'default',
+      ignoreLimit: true,
+      includeOutputScripts: true,
+      includeSpent: false,
+      tagsToIntercept: ['release', 'all'],
+      filterOutputs: async (
+        s: StorageProvider,
+        auth: AuthId,
+        vargs: Validation.ValidListOutputsArgs,
+        specOpTags: string[],
+        outputs: TableOutput[]
+      ): Promise<TableOutput[]> => {
+        const filteredOutputs: TableOutput[] = []
+        const services = s.getServices()
+        for (const o of outputs) {
+          if (!o.basketId) continue // only care about outputs assigned to baskets.
+          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
+      }
+    },
+    [specOpSetWalletChangeParams]: {
+      name: 'setWalletChangeParams',
+      tagsParamsCount: 2,
+      resultFromTags: async (
+        s: StorageProvider,
+        auth: AuthId,
+        vargs: Validation.ValidListOutputsArgs,
+        specOpTags: string[]
+      ): Promise<ListOutputsResult> => {
+        if (specOpTags.length !== 2)
+          throw new 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: [] }
+      }
+    }
+  }
+}