@bopen-io/wallet-toolbox 1.7.18

package/src/WalletAuthenticationManager.ts

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

@@ -0,0 +1,213 @@
+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[]
+}