@bopen-io/wallet-toolbox 1.7.18

package/src/storage/methods/listOutputsKnex.ts

@@ -0,0 +1,263 @@
+import { Beef, ListOutputsResult, OriginatorDomainNameStringUnder250Bytes, WalletOutput, Validation } from '@bsv/sdk'
+import { StorageKnex } from '../StorageKnex'
+import { getBasketToSpecOp, ListOutputsSpecOp } from './ListOutputsSpecOp'
+import { AuthId, TrxToken } from '../../sdk/WalletStorage.interfaces'
+import { verifyId, verifyOne } from '../../utility/utilityHelpers'
+import { TableOutputBasket } from '../schema/tables/TableOutputBasket'
+import { TableOutputTag } from '../schema/tables/TableOutputTag'
+import { TableOutput } from '../schema/tables/TableOutput'
+import { asString } from '../../utility/utilityHelpers.noBuffer'
+
+export async function listOutputs(
+  dsk: StorageKnex,
+  auth: AuthId,
+  vargs: Validation.ValidListOutputsArgs,
+  originator?: OriginatorDomainNameStringUnder250Bytes
+): Promise<ListOutputsResult> {
+  const trx: TrxToken | undefined = undefined
+  const userId = verifyId(auth.userId)
+  const limit = vargs.limit
+  let offset = vargs.offset
+  let orderBy: 'asc' | 'desc' = 'asc'
+  if (offset < 0) {
+    offset = -offset - 1
+    orderBy = 'desc'
+  }
+
+  const k = dsk.toDb(trx)
+
+  const r: ListOutputsResult = {
+    totalOutputs: 0,
+    outputs: []
+  }
+
+  /*
+        ValidListOutputsArgs {
+            basket: BasketStringUnder300Bytes
+
+            tags: OutputTagStringUnder300Bytes[]
+            tagQueryMode: 'all' | 'any' // default any
+
+            limit: PositiveIntegerDefault10Max10000 // default 10
+            offset: number // default 0
+        }
+    */
+
+  let specOp: ListOutputsSpecOp | undefined = undefined
+  let basketId: number | undefined = undefined
+  const basketsById: Record<number, TableOutputBasket> = {}
+  if (vargs.basket) {
+    let b = vargs.basket
+    specOp = getBasketToSpecOp()[b]
+    b = specOp ? (specOp.useBasket ? specOp.useBasket : '') : b
+    if (b) {
+      const baskets = await dsk.findOutputBaskets({
+        partial: { userId, name: b },
+        trx
+      })
+      if (baskets.length !== 1) {
+        // If basket does not exist, result is no outputs.
+        return r
+      }
+      const basket = baskets[0]
+      basketId = basket.basketId!
+      basketsById[basketId!] = basket
+    }
+  }
+
+  let tagIds: number[] = []
+  let tags = [...vargs.tags]
+  const specOpTags: string[] = []
+  if (specOp && specOp.tagsParamsCount) {
+    specOpTags.push(...tags.splice(0, Math.min(tags.length, specOp.tagsParamsCount)))
+  }
+  if (specOp && specOp.tagsToIntercept) {
+    // Pull out tags used by current specOp
+    const ts = tags
+    tags = []
+    for (const t of ts) {
+      if (specOp.tagsToIntercept.length === 0 || specOp.tagsToIntercept.indexOf(t) >= 0) {
+        specOpTags.push(t)
+        if (t === 'all') {
+          basketId = undefined
+        }
+      } else {
+        tags.push(t)
+      }
+    }
+  }
+
+  if (specOp && specOp.resultFromTags) {
+    const r = await specOp.resultFromTags(dsk, auth, vargs, specOpTags)
+    return r
+  }
+
+  if (tags && tags.length > 0) {
+    const q = k<TableOutputTag>('output_tags')
+      .where({
+        userId: userId,
+        isDeleted: false
+      })
+      .whereNotNull('outputTagId')
+      .whereIn('tag', tags)
+      .select('outputTagId')
+    const r = await q
+    tagIds = r.map(r => r.outputTagId!)
+  }
+
+  const isQueryModeAll = vargs.tagQueryMode === 'all'
+  if (isQueryModeAll && tagIds.length < tags.length)
+    // all the required tags don't exist, impossible to satisfy.
+    return r
+
+  if (!isQueryModeAll && tagIds.length === 0 && tags.length > 0)
+    // any and only non-existing labels, impossible to satisfy.
+    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 = specOp && specOp.includeSpent ? specOp.includeSpent : false
+
+  const txStatusOk = `(select status as tstatus from transactions where transactions.transactionId = outputs.transactionId) in ('completed', 'unproven', 'nosend', 'sending')`
+  const txStatusOkCteq = `(select status as tstatus from transactions where transactions.transactionId = o.transactionId) in ('completed', 'unproven', 'nosend', 'sending')`
+
+  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<TableOutput> = { 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.
+  if (!specOp || !specOp.ignoreLimit) q.limit(limit).offset(offset)
+
+  q.orderBy('outputId', orderBy)
+
+  let outputs: TableOutput[] = await q
+
+  if (specOp) {
+    if (specOp.filterOutputs) outputs = await specOp.filterOutputs(dsk, auth, vargs, specOpTags, outputs)
+    if (specOp.resultFromOutputs) {
+      const r = await specOp.resultFromOutputs(dsk, auth, vargs, specOpTags, outputs)
+      return r
+    }
+  }
+
+  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
+}

package/src/storage/methods/offsetKey.ts

@@ -0,0 +1,89 @@
+import { PublicKey, BigNumber, PrivateKey, Curve, P2PKH, PubKeyHex, CreateActionInput } from '@bsv/sdk'
+import { TableCommission } from '../schema/tables/TableCommission'
+import { sha256Hash } from '../../utility/utilityHelpers'
+
+export function keyOffsetToHashedSecret(
+  pub: PublicKey,
+  keyOffset?: string
+): { hashedSecret: BigNumber; keyOffset: string } {
+  let offset: PrivateKey
+  if (keyOffset !== undefined && typeof keyOffset === 'string') {
+    if (keyOffset.length === 64) offset = PrivateKey.fromString(keyOffset, 'hex')
+    else offset = PrivateKey.fromWif(keyOffset)
+  } else {
+    offset = PrivateKey.fromRandom()
+    keyOffset = offset.toWif()
+  }
+
+  const sharedSecret = pub.mul(offset).encode(true, undefined) as number[]
+  const hashedSecret = sha256Hash(sharedSecret)
+
+  return { hashedSecret: new BigNumber(hashedSecret), keyOffset }
+}
+
+export function offsetPrivKey(privKey: string, keyOffset?: string): { offsetPrivKey: string; keyOffset: string } {
+  const priv = PrivateKey.fromWif(privKey)
+
+  const pub = priv.toPublicKey()
+
+  const r = keyOffsetToHashedSecret(pub, keyOffset)
+
+  const bn = priv.add(r.hashedSecret).mod(new Curve().n)
+
+  const offsetPrivKey = new PrivateKey(bn).toWif()
+
+  return { offsetPrivKey, keyOffset: r.keyOffset }
+}
+
+export function offsetPubKey(pubKey: string, keyOffset?: string): { offsetPubKey: string; keyOffset: string } {
+  const pub = PublicKey.fromString(pubKey)
+
+  const r = keyOffsetToHashedSecret(pub, keyOffset)
+
+  // The hashed secret is multiplied by the generator point.
+  const point = new Curve().g.mul(r.hashedSecret)
+
+  // The resulting point is added to the recipient public key.
+  const offsetPubKey = new PublicKey(pub.add(point))
+
+  return { offsetPubKey: offsetPubKey.toString(), keyOffset: r.keyOffset }
+}
+
+export function lockScriptWithKeyOffsetFromPubKey(
+  pubKey: string,
+  keyOffset?: string
+): { script: string; keyOffset: string } {
+  const r = offsetPubKey(pubKey, keyOffset)
+
+  const offsetPub = PublicKey.fromString(r.offsetPubKey)
+
+  const hash = offsetPub.toHash() as number[]
+
+  const script = new P2PKH().lock(hash).toHex()
+
+  return { script, keyOffset: r.keyOffset }
+}
+
+export function createStorageServiceChargeScript(pubKeyHex: PubKeyHex): {
+  script: string
+  keyOffset: string
+} {
+  return lockScriptWithKeyOffsetFromPubKey(pubKeyHex)
+}
+
+export function redeemServiceCharges(privateKeyWif: string, charges: TableCommission[]): {}[] {
+  const priv = PrivateKey.fromWif(privateKeyWif)
+  const pub = priv.toPublicKey()
+  const p2pkh = new P2PKH()
+
+  const inputs: CreateActionInput[] = []
+
+  for (const c of charges) {
+    const { hashedSecret } = keyOffsetToHashedSecret(pub, c.keyOffset)
+    const bn = priv.add(hashedSecret).mod(new Curve().n)
+    const offsetPrivKey = new PrivateKey(bn)
+    //const unlock = p2pkh.unlock(offsetPrivKey, signOutputs, anyoneCanPay)
+  }
+
+  return []
+}