@bsv/wallet-toolbox 1.1.0

package/src/storage/methods/listActions.ts

@@ -0,0 +1,203 @@
+import {
+  Transaction as BsvTransaction,
+  ActionStatus,
+  ListActionsResult,
+  WalletAction,
+  WalletActionOutput,
+  WalletActionInput
+} from '@bsv/sdk'
+import { table } from '../index.client'
+import { asString, sdk, verifyOne } from '../../index.client'
+import { StorageKnex } from '../StorageKnex'
+
+export async function listActions(
+  storage: StorageKnex,
+  auth: sdk.AuthId,
+  vargs: sdk.ValidListActionsArgs
+): Promise<ListActionsResult> {
+  const limit = vargs.limit
+  const offset = vargs.offset
+
+  const k = storage.toDb(undefined)
+
+  const r: ListActionsResult = {
+    totalActions: 0,
+    actions: []
+  }
+
+  let labelIds: number[] = []
+  if (vargs.labels.length > 0) {
+    const q = k<table.TxLabel>('tx_labels')
+      .where({
+        userId: auth.userId,
+        isDeleted: false
+      })
+      .whereNotNull('txLabelId')
+      .whereIn('label', vargs.labels)
+      .select('txLabelId')
+    const r = await q
+    labelIds = r.map(r => r.txLabelId!)
+  }
+
+  const isQueryModeAll = vargs.labelQueryMode === 'all'
+  if (isQueryModeAll && labelIds.length < vargs.labels.length)
+    // all the required labels don't exist, impossible to satisfy.
+    return r
+
+  if (!isQueryModeAll && labelIds.length === 0 && vargs.labels.length > 0)
+    // any and only non-existing labels, impossible to satisfy.
+    return r
+
+  const columns: string[] = [
+    'transactionId',
+    'txid',
+    'satoshis',
+    'status',
+    'isOutgoing',
+    'description',
+    'version',
+    'lockTime'
+  ]
+  const stati: string[] = [
+    'completed',
+    'unprocessed',
+    'sending',
+    'unproven',
+    'unsigned',
+    'nosend',
+    'nonfinal'
+  ]
+
+  const noLabels = labelIds.length === 0
+
+  const makeWithLabelsQueries = () => {
+    const cteq = k.raw(`
+            SELECT ${columns.map(c => 't.' + c).join(',')}, 
+                    (SELECT COUNT(*) 
+                    FROM tx_labels_map AS m 
+                    WHERE m.transactionId = t.transactionId 
+                    AND m.txLabelId IN (${labelIds.join(',')}) 
+                    ) AS lc
+            FROM transactions AS t
+            WHERE t.userId = ${auth.userId}
+            AND t.status in (${stati.map(s => `'${s}'`).join(',')})
+            `)
+
+    const q = k.with('tlc', cteq)
+    q.from('tlc')
+    if (isQueryModeAll) q.where('lc', labelIds.length)
+    else q.where('lc', '>', 0)
+    const qcount = q.clone()
+    q.select(columns)
+    qcount.count('transactionId as total')
+    return { q, qcount }
+  }
+
+  const makeWithoutLabelsQueries = () => {
+    const q = k('transactions')
+      .where('userId', auth.userId)
+      .whereIn('status', stati)
+    const qcount = q.clone().count('transactionId as total')
+    return { q, qcount }
+  }
+
+  const { q, qcount } = noLabels
+    ? makeWithoutLabelsQueries()
+    : makeWithLabelsQueries()
+
+  q.limit(limit).offset(offset).orderBy('transactionId', 'asc')
+
+  const txs: Partial<table.Transaction>[] = await q
+
+  if (!limit || txs.length < limit) r.totalActions = txs.length
+  else {
+    const total = verifyOne(await qcount)['total']
+    r.totalActions = Number(total)
+  }
+
+  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: table.OutputX[] = 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: table.OutputX[] = 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/listCertificates.ts

@@ -0,0 +1,81 @@
+import {
+  ListCertificatesResult,
+  OriginatorDomainNameStringUnder250Bytes
+} from '@bsv/sdk'
+import { StorageProvider, table } from '../index.client'
+import { sdk } from '../../index.client'
+
+export async function listCertificates(
+  storage: StorageProvider,
+  auth: sdk.AuthId,
+  vargs: sdk.ValidListCertificatesArgs,
+  originator?: OriginatorDomainNameStringUnder250Bytes
+): Promise<ListCertificatesResult> {
+  const paged: sdk.Paged = { limit: vargs.limit, offset: vargs.offset }
+
+  const partial: Partial<table.Certificate> = {
+    userId: auth.userId,
+    isDeleted: false
+  }
+
+  if (vargs.partial) {
+    const vp = vargs.partial
+    if (vp.type) partial['type'] = vp.type
+    if (vp.subject) partial['subject'] = vp.subject
+    if (vp.serialNumber) partial['serialNumber'] = vp.serialNumber
+    if (vp.certifier) partial['certifier'] = vp.certifier
+    if (vp.revocationOutpoint)
+      partial['revocationOutpoint'] = vp.revocationOutpoint
+    if (vp.signature) partial['signature'] = vp.signature
+  }
+
+  const r = await storage.transaction(async trx => {
+    const findCertsArgs: sdk.FindCertificatesArgs = {
+      partial,
+      certifiers: vargs.certifiers,
+      types: vargs.types,
+      paged,
+      trx
+    }
+    const certs = await storage.findCertificates(findCertsArgs)
+    const certsWithFields = await Promise.all(
+      certs.map(async cert => {
+        const fields = await storage.findCertificateFields({
+          partial: { certificateId: cert.certificateId, userId: auth.userId },
+          trx
+        })
+        return {
+          ...cert,
+          fields: Object.fromEntries(
+            fields.map(f => [f.fieldName, f.fieldValue])
+          ),
+          masterKeyring: Object.fromEntries(
+            fields.map(f => [f.fieldName, f.masterKey])
+          )
+        }
+      })
+    )
+    const r: ListCertificatesResult = {
+      totalCertificates: 0,
+      certificates: certsWithFields.map(cwf => ({
+        type: cwf.type,
+        subject: cwf.subject,
+        serialNumber: cwf.serialNumber,
+        certifier: cwf.certifier,
+        revocationOutpoint: cwf.revocationOutpoint,
+        signature: cwf.signature,
+        fields: cwf.fields,
+        verifier: cwf.verifier,
+        keyring: cwf.masterKeyring
+      }))
+    }
+    if (r.certificates.length < paged.limit)
+      r.totalCertificates = r.certificates.length
+    else {
+      r.totalCertificates = await storage.countCertificates(findCertsArgs)
+    }
+    return r
+  })
+
+  return r
+}

package/src/storage/methods/listOutputs.ts

@@ -0,0 +1,219 @@
+import {
+  Beef,
+  ListOutputsResult,
+  OriginatorDomainNameStringUnder250Bytes,
+  WalletOutput
+} from '@bsv/sdk'
+import { table } from '../index.client'
+import { asString, sdk, verifyId, verifyOne } from '../../index.client'
+import { StorageKnex } from '../StorageKnex'
+
+export async function listOutputs(
+  dsk: StorageKnex,
+  auth: sdk.AuthId,
+  vargs: sdk.ValidListOutputsArgs,
+  originator?: OriginatorDomainNameStringUnder250Bytes
+): Promise<ListOutputsResult> {
+  const trx: sdk.TrxToken | undefined = undefined
+  const userId = verifyId(auth.userId)
+  const limit = vargs.limit
+  const offset = vargs.offset
+
+  const k = dsk.toDb(trx)
+
+  const r: ListOutputsResult = {
+    totalOutputs: 0,
+    outputs: []
+  }
+
+  /*
+        ListOutputsArgs {
+            basket: BasketStringUnder300Bytes
+
+            tags?: OutputTagStringUnder300Bytes[]
+            tagQueryMode?: 'all' | 'any' // default any
+
+            limit?: PositiveIntegerDefault10Max10000
+            offset?: PositiveIntegerOrZero
+        }
+    */
+
+  let basketId: number | undefined = undefined
+  const basketsById: Record<number, table.OutputBasket> = {}
+  if (vargs.basket) {
+    const baskets = await dsk.findOutputBaskets({
+      partial: { userId, name: vargs.basket },
+      trx
+    })
+    if (baskets.length !== 1)
+      throw new sdk.WERR_INVALID_PARAMETER('basket', 'valid basket name.')
+    const basket = baskets[0]
+    basketId = basket.basketId!
+    basketsById[basketId!] = basket
+  }
+
+  let tagIds: number[] = []
+  if (vargs.tags && vargs.tags.length > 0) {
+    const q = k<table.OutputTag>('output_tags')
+      .where({
+        userId: userId,
+        isDeleted: false
+      })
+      .whereNotNull('outputTagId')
+      .whereIn('tag', vargs.tags)
+      .select('outputTagId')
+    const r = await q
+    tagIds = r.map(r => r.outputTagId!)
+  }
+
+  const isQueryModeAll = vargs.tagQueryMode === 'all'
+  if (isQueryModeAll && tagIds.length < vargs.tags.length) return r
+
+  const columns: string[] = [
+    'outputId',
+    'transactionId',
+    'basketId',
+    'spendable',
+    'txid',
+    'vout',
+    'satoshis',
+    'lockingScript',
+    'customInstructions',
+    'outputDescription',
+    'spendingDescription',
+    'scriptLength',
+    'scriptOffset'
+  ]
+
+  const noTags = tagIds.length === 0
+  const includeSpent = false
+
+  const txStatusOk = `(select status as tstatus from transactions where transactions.transactionId = outputs.transactionId) in ('completed', 'unproven', 'nosend')`
+  const txStatusOkCteq = `(select status as tstatus from transactions where transactions.transactionId = o.transactionId) in ('completed', 'unproven', 'nosend')`
+
+  const makeWithTagsQueries = () => {
+    let cteqOptions = ''
+    if (basketId) cteqOptions += ` AND o.basketId = ${basketId}`
+    if (!includeSpent) cteqOptions += ` AND o.spendable`
+    const cteq = k.raw(`
+            SELECT ${columns.map(c => 'o.' + c).join(',')}, 
+                    (SELECT COUNT(*) 
+                    FROM output_tags_map AS m 
+                    WHERE m.OutputId = o.OutputId 
+                    AND m.outputTagId IN (${tagIds.join(',')}) 
+                    ) AS tc
+            FROM outputs AS o
+            WHERE o.userId = ${userId} ${cteqOptions} AND ${txStatusOkCteq}
+            `)
+
+    const q = k.with('otc', cteq)
+    q.from('otc')
+    if (isQueryModeAll) q.where('tc', tagIds.length)
+    else q.where('tc', '>', 0)
+    const qcount = q.clone()
+    q.select(columns)
+    qcount.count('outputId as total')
+    return { q, qcount }
+  }
+
+  const makeWithoutTagsQueries = () => {
+    const where: Partial<table.Output> = { userId }
+    if (basketId) where.basketId = basketId
+    if (!includeSpent) where.spendable = true
+    const q = k('outputs').where(where).whereRaw(txStatusOk)
+    const qcount = q.clone().count('outputId as total')
+    return { q, qcount }
+  }
+
+  const { q, qcount } = noTags
+    ? makeWithoutTagsQueries()
+    : makeWithTagsQueries()
+
+  // Sort order when limit and offset are possible must be ascending for determinism.
+  q.limit(limit).offset(offset).orderBy('outputId', 'asc')
+
+  const outputs: table.Output[] = await q
+
+  if (!limit || outputs.length < limit) r.totalOutputs = outputs.length
+  else {
+    const total = verifyOne(await qcount)['total']
+    r.totalOutputs = Number(total)
+  }
+
+  /*
+        ListOutputsArgs {
+            include?: 'locking scripts' | 'entire transactions'
+            includeCustomInstructions?: BooleanDefaultFalse
+            includeTags?: BooleanDefaultFalse
+            includeLabels?: BooleanDefaultFalse
+        }
+
+        ListOutputsResult {
+            totalOutputs: PositiveIntegerOrZero
+            BEEF?: BEEF
+            outputs: Array<WalletOutput>
+        }
+
+        WalletOutput {
+            satoshis: SatoshiValue
+            spendable: boolean
+            outpoint: OutpointString
+
+            customInstructions?: string
+            lockingScript?: HexString
+            tags?: OutputTagStringUnder300Bytes[]
+            labels?: LabelStringUnder300Bytes[]
+        }
+    */
+
+  const labelsByTxid: Record<string, string[]> = {}
+
+  const beef = new Beef()
+
+  for (const o of outputs) {
+    const wo: WalletOutput = {
+      satoshis: Number(o.satoshis),
+      spendable: !!o.spendable,
+      outpoint: `${o.txid}.${o.vout}`
+    }
+    r.outputs.push(wo)
+    //if (vargs.includeBasket && o.basketId) {
+    //    if (!basketsById[o.basketId]) {
+    //        basketsById[o.basketId] = verifyTruthy(await dsk.findOutputBasketId(o.basketId!, trx))
+    //    }
+    //    wo.basket = basketsById[o.basketId].name
+    //}
+    if (vargs.includeCustomInstructions && o.customInstructions)
+      wo.customInstructions = o.customInstructions
+    if (vargs.includeLabels && o.txid) {
+      if (labelsByTxid[o.txid] === undefined) {
+        labelsByTxid[o.txid] = (
+          await dsk.getLabelsForTransactionId(o.transactionId, trx)
+        ).map(l => l.label)
+      }
+      wo.labels = labelsByTxid[o.txid]
+    }
+    if (vargs.includeTags) {
+      wo.tags = (await dsk.getTagsForOutputId(o.outputId, trx)).map(t => t.tag)
+    }
+    if (vargs.includeLockingScripts) {
+      await dsk.validateOutputScript(o, trx)
+      if (o.lockingScript) wo.lockingScript = asString(o.lockingScript)
+    }
+    if (vargs.includeTransactions && !beef.findTxid(o.txid!)) {
+      await dsk.getValidBeefForKnownTxid(
+        o.txid!,
+        beef,
+        undefined,
+        vargs.knownTxids,
+        trx
+      )
+    }
+  }
+
+  if (vargs.includeTransactions) {
+    r.BEEF = beef.toBinary()
+  }
+
+  return r
+}