@bopen-io/wallet-toolbox 1.7.18

package/src/services/providers/getBeefForTxid.ts

@@ -0,0 +1,369 @@
+import { Beef, ListActionsResult, ListOutputsResult, Validation } from '@bsv/sdk'
+import {
+  TrxToken,
+  PurgeParams,
+  PurgeResults,
+  ProvenOrRawTx,
+  AuthId,
+  FindCertificatesArgs,
+  FindOutputBasketsArgs,
+  FindOutputsArgs,
+  FindOutputTagMapsArgs,
+  FindProvenTxReqsArgs,
+  FindProvenTxsArgs,
+  FindTxLabelMapsArgs,
+  FindCertificateFieldsArgs,
+  FindCommissionsArgs,
+  FindMonitorEventsArgs,
+  FindOutputTagsArgs,
+  FindSyncStatesArgs,
+  FindTransactionsArgs,
+  FindTxLabelsArgs,
+  FindUsersArgs,
+  FindForUserSincePagedArgs,
+  StorageGetBeefOptions
+} from '../../sdk'
+import {
+  TableCertificate,
+  TableCertificateField,
+  TableCertificateX,
+  TableCommission,
+  TableMonitorEvent,
+  TableOutput,
+  TableOutputBasket,
+  TableOutputTag,
+  TableOutputTagMap,
+  TableProvenTx,
+  TableProvenTxReq,
+  TableSettings,
+  TableSyncState,
+  TableTransaction,
+  TableTxLabel,
+  TableTxLabelMap,
+  TableUser,
+  Services,
+  StorageAdminStats
+} from '../../index.client'
+import { StorageProvider } from '../../storage/StorageProvider'
+
+export async function getBeefForTxid(services: Services, txid: string): Promise<Beef> {
+  const storage = new ServicesOnlyStorageProvider(services)
+  const beef = await storage.getBeefForTxid(txid)
+  return beef
+}
+
+/**
+ * The generalized implementation of getBeefForTransaction uses storage to
+ * avoid incurring the cost of redundant block chain data queries.
+ *
+ * This class makes the generalized implementation of getBeefForTransaction
+ * available in situations where there storage is not relevant.
+ */
+class ServicesOnlyStorageProvider extends StorageProvider {
+  gbo: StorageGetBeefOptions
+
+  constructor(services: Services) {
+    const o = StorageProvider.createStorageBaseOptions(services.chain)
+    super(o)
+    this.setServices(services)
+    this.gbo = {
+      ignoreServices: false,
+      ignoreStorage: true,
+      ignoreNewProven: true
+    }
+  }
+
+  async getBeefForTxid(txid: string): Promise<Beef> {
+    const beef = await 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/signer/README.md

@@ -0,0 +1,5 @@
+# WalletSigner
+
+Combines KeyDeriver and WalletStorage to implement the full Wallet.interfaces.
+
+

package/src/signer/WalletSigner.ts

@@ -0,0 +1,17 @@
+import { KeyDeriverApi } from '@bsv/sdk'
+import { WalletStorageManager } from '../storage/WalletStorageManager'
+import { Chain } from '../sdk/types'
+
+export class WalletSigner {
+  isWalletSigner: true = true
+
+  chain: Chain
+  keyDeriver: KeyDeriverApi
+  storage: WalletStorageManager
+
+  constructor(chain: Chain, keyDeriver: KeyDeriverApi, storage: WalletStorageManager) {
+    this.chain = chain
+    this.keyDeriver = keyDeriver
+    this.storage = storage
+  }
+}

package/src/signer/methods/acquireDirectCertificate.ts

@@ -0,0 +1,52 @@
+import { AcquireCertificateResult, Validation } from '@bsv/sdk'
+import { Wallet } from '../../Wallet'
+import { AuthId } from '../../sdk/WalletStorage.interfaces'
+import { TableCertificateX } from '../../storage/schema/tables/TableCertificate'
+
+export async function acquireDirectCertificate(
+  wallet: Wallet,
+  auth: AuthId,
+  vargs: Validation.ValidAcquireDirectCertificateArgs
+): Promise<AcquireCertificateResult> {
+  const now = new Date()
+  const newCert: TableCertificateX = {
+    certificateId: 0, // replaced by storage insert
+    created_at: now,
+    updated_at: now,
+    userId: auth.userId!,
+    type: vargs.type,
+    subject: vargs.subject,
+    verifier: vargs.keyringRevealer === 'certifier' ? vargs.certifier : vargs.keyringRevealer,
+    serialNumber: vargs.serialNumber,
+    certifier: vargs.certifier,
+    revocationOutpoint: vargs.revocationOutpoint,
+    signature: vargs.signature,
+    fields: [],
+    isDeleted: false
+  }
+  for (const [name, value] of Object.entries(vargs.fields)) {
+    newCert.fields?.push({
+      certificateId: 0, // replaced by storage insert
+      created_at: now,
+      updated_at: now,
+      userId: auth.userId!,
+      fieldName: name,
+      fieldValue: value,
+      masterKey: vargs.keyringForSubject[name] || ''
+    })
+  }
+
+  const count = await wallet.storage.insertCertificate(newCert)
+
+  const r: AcquireCertificateResult = {
+    type: vargs.type,
+    subject: vargs.subject,
+    serialNumber: vargs.serialNumber,
+    certifier: vargs.certifier,
+    revocationOutpoint: vargs.revocationOutpoint,
+    signature: vargs.signature,
+    fields: vargs.fields
+  }
+
+  return r
+}

package/src/signer/methods/buildSignableTransaction.ts

@@ -0,0 +1,183 @@
+import { Beef, Script, Transaction, TransactionInput, TransactionOutput, Validation } from '@bsv/sdk'
+import { Wallet, PendingStorageInput } from '../../Wallet'
+import {
+  StorageCreateActionResult,
+  StorageCreateTransactionSdkInput,
+  StorageCreateTransactionSdkOutput
+} from '../../sdk/WalletStorage.interfaces'
+import { WERR_INVALID_PARAMETER } from '../../sdk/WERR_errors'
+import { asBsvSdkScript, verifyTruthy } from '../../utility/utilityHelpers'
+import { KeyPair } from '../../sdk/types'
+import { ScriptTemplateBRC29 } from '../../utility/ScriptTemplateBRC29'
+
+export function buildSignableTransaction(
+  dctr: StorageCreateActionResult,
+  args: Validation.ValidCreateActionArgs,
+  wallet: Wallet
+): {
+  tx: Transaction
+  amount: number
+  pdi: PendingStorageInput[]
+  log: string
+} {
+  const changeKeys = wallet.getClientChangeKeyPair()
+
+  const inputBeef = args.inputBEEF ? Beef.fromBinary(args.inputBEEF) : undefined
+
+  const { inputs: storageInputs, outputs: storageOutputs } = dctr
+
+  const tx = new Transaction(args.version, [], [], args.lockTime)
+
+  // The order of outputs in storageOutputs is always:
+  // CreateActionArgs.outputs in the original order
+  // Commission output
+  // Change outputs
+  // The Vout values will be randomized if args.options.randomizeOutputs is true. Default is true.
+  const voutToIndex = Array<number>(storageOutputs.length)
+  for (let vout = 0; vout < storageOutputs.length; vout++) {
+    const i = storageOutputs.findIndex(o => o.vout === vout)
+    if (i < 0) throw new WERR_INVALID_PARAMETER('output.vout', `sequential. ${vout} is missing`)
+    voutToIndex[vout] = i
+  }
+
+  //////////////
+  // Add OUTPUTS
+  /////////////
+  for (let vout = 0; vout < storageOutputs.length; vout++) {
+    const i = voutToIndex[vout]
+    const out = storageOutputs[i]
+    if (vout !== out.vout)
+      throw new WERR_INVALID_PARAMETER('output.vout', `equal to array index. ${out.vout} !== ${vout}`)
+
+    const change = out.providedBy === 'storage' && out.purpose === 'change'
+
+    const lockingScript = change
+      ? makeChangeLock(out, dctr, args, changeKeys, wallet)
+      : asBsvSdkScript(out.lockingScript)
+
+    const output: TransactionOutput = {
+      satoshis: out.satoshis,
+      lockingScript,
+      change
+    }
+    tx.addOutput(output)
+  }
+
+  if (storageOutputs.length === 0) {
+    // Add a dummy output to avoid transaction rejection by processors for having no outputs.
+    const output: TransactionOutput = {
+      satoshis: 0,
+      lockingScript: Script.fromASM('OP_FALSE OP_RETURN 42'),
+      change: false
+    }
+    tx.addOutput(output)
+  }
+
+  //////////////
+  // Merge and sort INPUTS info by vin order.
+  /////////////
+  const inputs: {
+    argsInput: Validation.ValidCreateActionInput | undefined
+    storageInput: StorageCreateTransactionSdkInput
+  }[] = []
+  for (const storageInput of storageInputs) {
+    const argsInput =
+      storageInput.vin !== undefined && storageInput.vin < args.inputs.length
+        ? args.inputs[storageInput.vin]
+        : undefined
+    inputs.push({ argsInput, storageInput })
+  }
+  inputs.sort((a, b) =>
+    a.storageInput.vin! < b.storageInput.vin! ? -1 : a.storageInput.vin! === b.storageInput.vin! ? 0 : 1
+  )
+
+  const pendingStorageInputs: PendingStorageInput[] = []
+
+  //////////////
+  // Add INPUTS
+  /////////////
+  let totalChangeInputs = 0
+  for (const { storageInput, argsInput } of inputs) {
+    // Two types of inputs are handled: user specified wth/without unlockingScript and storage specified using SABPPP template.
+    if (argsInput) {
+      // Type 1: User supplied input, with or without an explicit unlockingScript.
+      // If without, signAction must be used to provide the actual unlockScript.
+      const hasUnlock = typeof argsInput.unlockingScript === 'string'
+      const unlock = hasUnlock ? asBsvSdkScript(argsInput.unlockingScript!) : new Script()
+      const sourceTransaction = args.isSignAction ? inputBeef?.findTxid(argsInput.outpoint.txid)?.tx : undefined
+      const inputToAdd: TransactionInput = {
+        sourceTXID: argsInput.outpoint.txid,
+        sourceOutputIndex: argsInput.outpoint.vout,
+        // Include the source transaction for access to the outputs locking script and output satoshis for user side fee calculation.
+        // TODO: Make this conditional to improve performance when user can supply locking scripts themselves.
+        sourceTransaction,
+        unlockingScript: unlock,
+        sequence: argsInput.sequenceNumber
+      }
+      tx.addInput(inputToAdd)
+    } else {
+      // Type2: SABPPP protocol inputs which are signed using ScriptTemplateBRC29.
+      if (storageInput.type !== 'P2PKH')
+        throw new WERR_INVALID_PARAMETER(
+          'type',
+          `vin ${storageInput.vin}, "${storageInput.type}" is not a supported unlocking script type.`
+        )
+
+      pendingStorageInputs.push({
+        vin: tx.inputs.length,
+        derivationPrefix: verifyTruthy(storageInput.derivationPrefix),
+        derivationSuffix: verifyTruthy(storageInput.derivationSuffix),
+        unlockerPubKey: storageInput.senderIdentityKey,
+        sourceSatoshis: storageInput.sourceSatoshis,
+        lockingScript: storageInput.sourceLockingScript
+      })
+
+      const inputToAdd: TransactionInput = {
+        sourceTXID: storageInput.sourceTxid,
+        sourceOutputIndex: storageInput.sourceVout,
+        sourceTransaction: storageInput.sourceTransaction
+          ? Transaction.fromBinary(storageInput.sourceTransaction)
+          : undefined,
+        unlockingScript: new Script(),
+        sequence: 0xffffffff
+      }
+      tx.addInput(inputToAdd)
+      totalChangeInputs += Validation.validateSatoshis(storageInput.sourceSatoshis, 'storageInput.sourceSatoshis')
+    }
+  }
+
+  // The amount is the total of non-foreign inputs minus change outputs
+  // Note that the amount can be negative when we are redeeming more inputs than we are spending
+  const totalChangeOutputs = storageOutputs
+    .filter(x => x.purpose === 'change')
+    .reduce((acc, el) => acc + el.satoshis, 0)
+  const amount = totalChangeInputs - totalChangeOutputs
+
+  return {
+    tx,
+    amount,
+    pdi: pendingStorageInputs,
+    log: ''
+  }
+}
+
+/**
+ * Derive a change output locking script
+ */
+export function makeChangeLock(
+  out: StorageCreateTransactionSdkOutput,
+  dctr: StorageCreateActionResult,
+  args: Validation.ValidCreateActionArgs,
+  changeKeys: KeyPair,
+  wallet: Wallet
+): Script {
+  const derivationPrefix = dctr.derivationPrefix
+  const derivationSuffix = verifyTruthy(out.derivationSuffix)
+  const sabppp = new ScriptTemplateBRC29({
+    derivationPrefix,
+    derivationSuffix,
+    keyDeriver: wallet.keyDeriver
+  })
+  const lockingScript = sabppp.lock(changeKeys.privateKey, changeKeys.publicKey)
+  return lockingScript
+}