@bsv/wallet-toolbox 1.7.18 → 2.0.0-beta.0

package/src/services/providers/getBeefForTxid.ts

@@ -1,369 +0,0 @@
-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

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

package/src/signer/WalletSigner.ts

@@ -1,17 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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
-}