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

package/src/WalletAuthenticationManager.ts

@@ -1,153 +0,0 @@
-import { CWIStyleWalletManager, UMPTokenInteractor, OverlayUMPTokenInteractor } from './CWIStyleWalletManager'
-import { PrivilegedKeyManager } from './sdk/PrivilegedKeyManager'
-import { WalletInterface, Random, Utils, Transaction, RPuzzle, PrivateKey, BigNumber } from '@bsv/sdk'
-import { WABClient } from './wab-client/WABClient'
-import { AuthMethodInteractor } from './wab-client/auth-method-interactors/AuthMethodInteractor'
-
-/**
- * WalletAuthenticationManager
- *
- * A wallet manager that integrates
- * with a WABClient for user authentication flows (e.g. Twilio phone).
- */
-export class WalletAuthenticationManager extends CWIStyleWalletManager {
-  private wabClient: WABClient // instance of WABClient
-  private authMethod?: AuthMethodInteractor // chosen AuthMethod interactor
-  private tempPresentationKey?: string // for temporary persistence between auth steps
-
-  constructor(
-    adminOriginator: string,
-    walletBuilder: (primaryKey: number[], privilegedKeyManager: PrivilegedKeyManager) => Promise<WalletInterface>,
-    interactor: UMPTokenInteractor = new OverlayUMPTokenInteractor(),
-    recoveryKeySaver: (key: number[]) => Promise<true>,
-    passwordRetriever: (reason: string, test: (passwordCandidate: string) => boolean) => Promise<string>,
-    wabClient: WABClient,
-    authMethod?: AuthMethodInteractor,
-    stateSnapshot?: number[]
-  ) {
-    super(
-      adminOriginator,
-      walletBuilder,
-      interactor,
-      recoveryKeySaver,
-      passwordRetriever,
-      // Here, we provide a custom new wallet funder that uses the Secret Server
-      async (presentationKey: number[], wallet: WalletInterface, adminOriginator: string) => {
-        debugger
-        const { paymentData } = await this.wabClient.requestFaucet(Utils.toHex(presentationKey))
-        if (!paymentData.k || !paymentData.tx) {
-          throw new Error('Invalid')
-        }
-        const tx = Transaction.fromAtomicBEEF(paymentData.tx as number[])
-        console.log(paymentData)
-        const faucetRedeemTXCreationResult = await wallet.createAction(
-          {
-            inputBEEF: tx.toBEEF(),
-            inputs: [
-              {
-                outpoint: `${paymentData.txid}.0`,
-                unlockingScriptLength: 108,
-                inputDescription: 'Fund from faucet'
-              }
-            ],
-            description: 'Fund wallet',
-            options: {
-              acceptDelayedBroadcast: false
-            }
-          },
-          adminOriginator
-        )
-        const faucetRedeemTX = Transaction.fromAtomicBEEF(faucetRedeemTXCreationResult.signableTransaction!.tx)
-        const faucetRedemptionPuzzle = new RPuzzle()
-        const randomRedemptionPrivateKey = PrivateKey.fromRandom()
-        const faucetRedeemUnlocker = faucetRedemptionPuzzle.unlock(
-          new BigNumber(paymentData.k, 16),
-          randomRedemptionPrivateKey
-        )
-        const faucetRedeemUnlockingScript = await faucetRedeemUnlocker.sign(faucetRedeemTX, 0)
-        const signActionResult = await wallet.signAction({
-          reference: faucetRedeemTXCreationResult.signableTransaction!.reference,
-          spends: {
-            0: {
-              unlockingScript: faucetRedeemUnlockingScript.toHex()
-            }
-          }
-        })
-        console.log('Sign action result:', signActionResult)
-      },
-      stateSnapshot
-    )
-
-    this.wabClient = wabClient
-    this.authMethod = authMethod
-  }
-
-  /**
-   * Sets (or switches) the chosen AuthMethodInteractor at runtime,
-   * in case the user changes their mind or picks a new method in the UI.
-   */
-  public setAuthMethod(method: AuthMethodInteractor) {
-    this.authMethod = method
-  }
-
-  /**
-   * Initiate the WAB-based flow, e.g. sending an SMS code or starting an ID check,
-   * using the chosen AuthMethodInteractor.
-   */
-  public async startAuth(payload: any): Promise<void> {
-    if (!this.authMethod) {
-      throw new Error('No AuthMethod selected in WalletAuthenticationManager')
-    }
-    this.tempPresentationKey = this.generateTemporaryPresentationKey()
-
-    // For example, if this.authMethod is Twilio, `payload` might contain { phoneNumber: "+1..." }
-    const startRes = await this.wabClient.startAuthMethod(
-      this.authMethod,
-      // The user might not have a presentationKey yet, so we generate one locally to pass to the server.
-      // If it’s an existing user on the WAB side, the WAB will give us the stored key later.
-      // But we do need some placeholder key for the 'startAuth' call:
-      this.tempPresentationKey,
-      payload
-    )
-
-    if (!startRes.success) {
-      throw new Error(startRes.message || 'Failed to start WAB auth method')
-    }
-  }
-
-  /**
-   * Completes the WAB-based flow, retrieving the final presentationKey from WAB if successful.
-   */
-  public async completeAuth(payload: any): Promise<void> {
-    if (!this.authMethod || !this.tempPresentationKey) {
-      throw new Error('No AuthMethod selected in WalletAuthenticationManager or startAuth has yet to be called.')
-    }
-
-    // Unser the temp presentation key early (for security)
-    const tempKey = this.tempPresentationKey
-    this.tempPresentationKey = undefined
-
-    const result = await this.wabClient.completeAuthMethod(this.authMethod, tempKey, payload)
-
-    if (!result.success || !result.presentationKey) {
-      throw new Error(result.message || 'Failed to complete WAB auth')
-    }
-
-    // We now have the final 256-bit key in hex from the WAB
-    const presentationKeyHex = result.presentationKey
-    const presentationKeyBytes = Utils.toArray(presentationKeyHex, 'hex')
-
-    // Provide this presentation key to the underlying CWI logic:
-    // This sets 'this.presentationKey' and determines if it's a new or existing user
-    // based on whether a UMP token exists on chain.  We'll do "presentation-key-and-password"
-    // for new user flows, for example, or user might choose "presentation-key-and-recovery-key" if we wanted.
-    // Either way, WAB has now done its job and we are off to base-layer CWI logic at this point!
-    await this.providePresentationKey(presentationKeyBytes)
-  }
-
-  private generateTemporaryPresentationKey(): string {
-    // For the 'startAuth' call, we can generate a random 32 bytes → 64 hex chars.
-    const randomBytes = Random(32) // array of length 32
-    return Utils.toHex(randomBytes)
-  }
-}

package/src/WalletLogger.ts

@@ -1,213 +0,0 @@
-import { Beef, CreateActionArgs, WalletInterface, WalletLoggerInterface, WalletLoggerLog } from '@bsv/sdk'
-import { WalletError } from './sdk/WalletError'
-
-export class WalletLogger implements WalletLoggerInterface {
-  indent: number = 0
-  logs: WalletLoggerLog[] = []
-  isOrigin: boolean = true
-  isError: boolean = false
-  level?: WalletLoggerLevel
-  flushFormat?: 'json'
-
-  constructor(log?: string | WalletLoggerInterface) {
-    if (log) {
-      const lo = typeof log === 'string' ? JSON.parse(log) : log
-      this.indent = lo.indent || 0
-      this.logs = lo.logs || []
-      this.isOrigin = this.indent === 0
-      this.level = lo.level
-    }
-  }
-
-  private logAny(message?: any): string {
-    if (!message) return ''
-    if (typeof message === 'string') return message
-    if (typeof message === 'object') return JSON.stringify(message)
-    return ''
-  }
-
-  private toAdd(
-    isBegin: boolean,
-    isEnd: boolean,
-    isError: boolean,
-    message?: any,
-    optionalParams?: any[]
-  ): WalletLoggerLog {
-    let add = ''
-    if (message) add += this.logAny(message)
-    if (optionalParams) for (const p of optionalParams) add += this.logAny(p)
-    let log = {
-      when: Date.now(),
-      indent: this.indent,
-      isBegin,
-      isEnd,
-      isError,
-      log: add
-    }
-    return log
-  }
-
-  private stampLog(isBegin: boolean, isEnd: boolean, isError: boolean, message?: any, optionalParams?: any[]) {
-    const add = this.toAdd(isBegin, isEnd, isError, message, optionalParams)
-    this.logs.push(add)
-  }
-
-  group(...label: any[]): void {
-    this.stampLog(true, false, false, undefined, label)
-    this.indent++
-  }
-
-  groupEnd(): void {
-    this.indent--
-    if (this.indent < 0) this.indent = 0
-    this.stampLog(false, true, false)
-  }
-
-  log(message?: any, ...optionalParams: any[]): void {
-    this.stampLog(false, false, false, message, optionalParams)
-  }
-  error(message?: any, ...optionalParams: any[]): void {
-    this.stampLog(false, false, true, message, optionalParams)
-    this.isError = true
-  }
-
-  toWalletLoggerJson(): object {
-    const json: object = {
-      isWalletLoggerJson: true,
-      indent: this.indent,
-      logs: this.logs,
-      isError: this.isError
-    }
-    return json
-  }
-
-  toLogString(): string {
-    let log = ''
-    if (this.logs.length > 0) {
-      const first = this.logs[0]
-      const last = this.logs.slice(-1)[0]
-      const msecs = last.when - first.when
-      log += `   msecs WalletLogger ${new Date(first.when).toISOString()} logged ${msecs / 1000} seconds\n`
-      let prev = first
-      const begins: WalletLoggerLog[] = []
-      for (const d of this.logs) {
-        let df = (d.when - prev.when).toString()
-        df = `${' '.repeat(8 - df.length)}${df}`
-        const what = d.isBegin ? ' begin' : d.isEnd ? ' end' : d.isError ? ' ERROR' : ''
-        if (d.isBegin) begins.push(d)
-        let m = d.log
-        if (!m && d.isEnd && begins.length > 0) {
-          const begin = begins.pop()!
-          m = begin.log
-        }
-        log += `${df}${'  '.repeat(d.indent)}${what} ${m}\n`
-        prev = d
-      }
-    }
-    return log
-  }
-
-  flush(): object | undefined {
-    if (this.logs.length > 0) {
-      const trace = this.toLogString()
-      const output = this.isError ? console.error : console.log
-      if (this.flushFormat === 'json') {
-        const name = this.logs[0].log
-        const log = {
-          name,
-          trace
-        }
-        output(JSON.stringify(log))
-      } else {
-        output(trace)
-      }
-    }
-    const r = this.isOrigin ? undefined : this.toWalletLoggerJson()
-    return r
-  }
-
-  merge(log: WalletLoggerInterface): void {
-    if (log.logs) {
-      this.logs.push(...log.logs)
-    }
-  }
-}
-
-export function logWalletError(eu: unknown, logger?: WalletLoggerInterface, label?: string): void {
-  if (!logger) return
-  logger.error(label || 'WalletError', WalletError.unknownToJson(eu))
-}
-
-export function logCreateActionArgs(args: CreateActionArgs): object {
-  const o: any = {
-    description: args.description
-  }
-  if (args.labels) o.labels = args.labels
-  if (args.inputBEEF) o.inputBEEF = Beef.fromBinary(args.inputBEEF).toLogString()
-  if (args.lockTime !== undefined) o.lockTime = args.lockTime
-  if (args.version !== undefined) o.version = args.version
-  /*
-    if (args.inputs) {
-
-    }
-    if (args.outputs) {
-
-    }
-    options: validateCreateActionOptions(args.options),
-    isSendWith: false,
-    isDelayed: false,
-    isNoSend: false,
-    isNewTx: false,
-    isRemixChange: false,
-    isSignAction: false,
-    randomVals: undefined,
-    includeAllSourceTransactions: false,
-    isTestWerrReviewActions: false
-  */
-  return o
-}
-
-/**
- * Optional. Logging levels that may influence what is logged.
- *
- * 'error' Only requests resulting in an exception should be logged.
- * 'warn' Also log requests that succeed but with an abnormal condition.
- * 'info' Also log normal successful requests.
- * 'debug' Add input parm and result details where possible.
- * 'trace' Instead of adding debug details, focus on execution path and timing.
- */
-export type WalletLoggerLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace'
-
-/**
- * Constructor properties available to `WalletLogger`
- */
-export interface WalletLoggerArgs {
-  /**
-   * Optional. Logging levels that may influence what is logged.
-   *
-   * 'error' Only requests resulting in an exception should be logged.
-   * 'warn' Also log requests that succeed but with an abnormal condition.
-   * 'info' Also log normal successful requests.
-   * 'debug' Add input parm and result details where possible.
-   * 'trace' Instead of adding debug details, focus on execution path and timing.
-   */
-  level?: 'error' | 'warn' | 'info' | 'debug' | 'trace'
-
-  /**
-   * Valid if an accumulating logger. Count of `group` calls without matching `groupEnd`.
-   */
-  indent?: number
-  /**
-   * True if this is an accumulating logger and the logger belongs to the object servicing the initial request.
-   */
-  isOrigin?: boolean
-  /**
-   * True if this is an accumulating logger and an error was logged.
-   */
-  isError?: boolean
-
-  /**
-   * Optional array of accumulated logged data and errors.
-   */
-  logs?: WalletLoggerLog[]
-}