@bopen-io/wallet-toolbox 1.7.18

package/src/storage/methods/reviewStatus.ts

@@ -0,0 +1,101 @@
+import { Knex } from 'knex'
+import { StorageKnex } from '../StorageKnex'
+import { TrxToken } from '../../sdk/WalletStorage.interfaces'
+import { WalletError } from '../../sdk/WalletError'
+import { TableTransaction } from '../schema/tables/TableTransaction'
+import { TableOutput } from '../schema/tables/TableOutput'
+
+/**
+ * Looks for unpropagated state:
+ *
+ * 1. set transactions to 'failed' if not already failed and provenTxReq with matching txid has status of 'invalid'.
+ * 2. sets outputs to spendable true, spentBy undefined if spentBy is a transaction with status 'failed'.
+ * 3. sets transactions to 'completed' if provenTx with matching txid exists and current provenTxId is null.
+ *
+ * @param storage
+ * @param args
+ * @returns
+ */
+export async function reviewStatus(
+  storage: StorageKnex,
+  args: { agedLimit: Date; trx?: TrxToken }
+): Promise<{ log: string }> {
+  const r: { log: string } = { log: '' }
+
+  const runReviewStatusQuery = async <T extends object>(pq: ReviewStatusQuery): Promise<void> => {
+    try {
+      pq.sql = pq.q.toString()
+      const count = await pq.q
+      if (count > 0) {
+        r.log += `${count} ${pq.log}\n`
+      }
+    } catch (eu: unknown) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const e = WalletError.fromUnknown(eu)
+      throw eu
+    }
+  }
+
+  const k = storage.toDb(args.trx)
+
+  const qs: ReviewStatusQuery[] = []
+
+  qs.push({
+    log: `transactions updated to status of 'failed' where provenTxReq with matching txid is 'invalid'`,
+    /*
+        UPDATE transactions SET status = 'failed'
+        WHERE exists(select 1 from proven_tx_reqs as r where transactions.txid = r.txid and r.status = 'invalid')
+        */
+    q: k<TableTransaction>('transactions')
+      .update({ status: 'failed' })
+      .whereNot({ status: 'failed' })
+      .whereExists(function () {
+        this.select(k.raw(1))
+          .from('proven_tx_reqs as r')
+          .whereRaw(`transactions.txid = r.txid and r.status = 'invalid'`)
+      })
+  })
+
+  qs.push({
+    log: `outputs updated to spendable where spentBy is a transaction with status 'failed'`,
+    /*
+        UPDATE outputs SET spentBy = null, spendable = 1
+        where exists(select 1 from transactions as t where outputs.spentBy = t.transactionId and t.status = 'failed')
+        */
+    q: k<TableOutput>('outputs')
+      .update({ spentBy: null as unknown as undefined, spendable: true })
+      .whereExists(function () {
+        this.select(k.raw(1))
+          .from('transactions as t')
+          .whereRaw(`outputs.spentBy = t.transactionId and t.status = 'failed'`)
+      })
+  })
+
+  qs.push({
+    log: `transactions updated with provenTxId and status of 'completed' where provenTx with matching txid exists`,
+    /*
+        UPDATE transactions SET status = 'completed', provenTxId = p.provenTxId
+        FROM proven_txs p
+        WHERE transactions.txid = p.txid AND transactions.provenTxId IS NULL
+        */
+    q: k<TableTransaction>('transactions')
+      .update({
+        status: 'completed',
+        provenTxId: k.raw('(SELECT provenTxId FROM proven_txs AS p WHERE transactions.txid = p.txid)')
+      })
+      .whereNull('provenTxId')
+      .whereExists(function () {
+        this.select(k.raw(1)).from('proven_txs as p').whereRaw('transactions.txid = p.txid')
+      })
+  })
+
+  for (const q of qs) await runReviewStatusQuery(q)
+
+  return r
+}
+
+interface ReviewStatusQuery {
+  q: Knex.QueryBuilder<any, number>
+  sql?: string
+  log: string
+}

package/src/storage/methods/reviewStatusIdb.ts

@@ -0,0 +1,43 @@
+import { Beef } from '@bsv/sdk'
+import { Knex } from 'knex'
+import { TableOutput, TableTransaction } from '../index.client'
+import { sdk } from '../../index.client'
+import { StorageIdb } from '../StorageIdb'
+
+/**
+ * Looks for unpropagated state:
+ *
+ * 1. set transactions to 'failed' if not already failed and provenTxReq with matching txid has status of 'invalid'.
+ * 2. sets transactions to 'completed' if provenTx with matching txid exists and current provenTxId is null.
+ * 3. sets outputs to spendable true, spentBy undefined if spentBy is a transaction with status 'failed'.
+ *
+ * @param storage
+ * @param args
+ * @returns
+ */
+export async function reviewStatusIdb(
+  storage: StorageIdb,
+  args: { agedLimit: Date; trx?: sdk.TrxToken }
+): Promise<{ log: string }> {
+  const r: { log: string } = { log: '' }
+
+  // 1. set transactions to 'failed' if not already failed and provenTxReq with matching txid has status of 'invalid'.
+  const invalidTxids: string[] = []
+  await storage.filterProvenTxReqs({ partial: { status: 'invalid' } }, txReq => {
+    invalidTxids.push(txReq.txid)
+  })
+  for (const txid of invalidTxids) {
+    const txs = await storage.findTransactions({ partial: { txid } })
+    for (const tx of txs) {
+      if (tx.status !== 'failed') {
+        r.log += `transaction ${tx.transactionId} updated to status of 'failed' was ${tx.status}\n`
+        await storage.updateTransactionStatus('failed', tx.transactionId)
+      }
+    }
+  }
+
+  // 2. sets transactions to 'completed' if provenTx with matching txid exists and current provenTxId is null.
+  // 3. sets outputs to spendable true, spentBy undefined if spentBy is a transaction with status 'failed'.
+
+  return r
+}

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 { WERR_INVALID_PARAMETER } from '../../sdk/WERR_errors'
+
+/**
+ * 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 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
+}