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

package/src/wab-client/WABClient.ts

@@ -1,94 +0,0 @@
-/**
- * WABClient
- *
- * Provides high-level methods to:
- *  - Retrieve server info (supported auth methods, faucet info)
- *  - Generate a random presentation key
- *  - Start/Complete authentication with a chosen AuthMethodInteractor
- *  - Link/unlink methods
- *  - Request faucet
- *  - Delete user
- */
-import { AuthMethodInteractor } from './auth-method-interactors/AuthMethodInteractor'
-import { PrivateKey } from '@bsv/sdk'
-
-export class WABClient {
-  constructor(private serverUrl: string) {}
-
-  /**
-   * Return the WAB server info
-   */
-  public async getInfo() {
-    const res = await fetch(`${this.serverUrl}/info`)
-    return res.json()
-  }
-
-  /**
-   * Generate a random 256-bit presentation key as a hex string (client side).
-   */
-  public generateRandomPresentationKey(): string {
-    return PrivateKey.fromRandom().toHex()
-  }
-
-  /**
-   * Start an Auth Method flow
-   */
-  public async startAuthMethod(authMethod: AuthMethodInteractor, presentationKey: string, payload: any) {
-    return authMethod.startAuth(this.serverUrl, presentationKey, payload)
-  }
-
-  /**
-   * Complete an Auth Method flow
-   */
-  public async completeAuthMethod(authMethod: AuthMethodInteractor, presentationKey: string, payload: any) {
-    return authMethod.completeAuth(this.serverUrl, presentationKey, payload)
-  }
-
-  /**
-   * List user-linked methods
-   */
-  public async listLinkedMethods(presentationKey: string) {
-    const res = await fetch(`${this.serverUrl}/user/linkedMethods`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ presentationKey })
-    })
-    return res.json()
-  }
-
-  /**
-   * Unlink a given Auth Method by ID
-   */
-  public async unlinkMethod(presentationKey: string, authMethodId: number) {
-    const res = await fetch(`${this.serverUrl}/user/unlinkMethod`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ presentationKey, authMethodId })
-    })
-    return res.json()
-  }
-
-  /**
-   * Request faucet
-   */
-  public async requestFaucet(presentationKey: string) {
-    const res = await fetch(`${this.serverUrl}/faucet/request`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ presentationKey })
-    })
-    return res.json()
-  }
-
-  /**
-   * Delete user
-   */
-  public async deleteUser(presentationKey: string) {
-    const res = await fetch(`${this.serverUrl}/user/delete`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ presentationKey })
-    })
-    return res.json()
-  }
-}

package/src/wab-client/__tests/WABClient.man.test.ts

@@ -1,59 +0,0 @@
-import { _tu } from '../../../test/utils/TestUtilsWalletStorage'
-import { WABClient } from '../WABClient'
-import { TwilioPhoneInteractor } from '../auth-method-interactors/TwilioPhoneInteractor'
-
-// This test suite requires the WAB server to be running on localhost:3000 or you can
-// spin up a test environment or mock server. For demonstration, we'll keep it simple.
-
-describe('WABClient', () => {
-  let client: WABClient
-  const serverUrl = 'http://localhost:3000' // Adjust if your server is different
-  const testPresentationKey = 'clientTestKey' + Date.now()
-
-  beforeAll(() => {
-    client = new WABClient(serverUrl)
-  })
-
-  it('00', () => {})
-  // Don't run any of these tests whe
-  if (_tu.noEnv('main')) return
-
-  it('should get server info', async () => {
-    const info = await client.getInfo()
-    expect(info.supportedAuthMethods).toContain('TwilioPhone')
-  })
-
-  it('should do Twilio phone flow', async () => {
-    const twilio = new TwilioPhoneInteractor()
-
-    const startRes = await client.startAuthMethod(twilio, testPresentationKey, {
-      phoneNumber: '+12223334444'
-    })
-    expect(startRes.success).toBe(true)
-
-    const completeRes = await client.completeAuthMethod(twilio, testPresentationKey, {
-      otp: '123456',
-      phoneNumber: '+12223334444'
-    })
-    expect(completeRes.success).toBe(true)
-    expect(completeRes.presentationKey).toBe(testPresentationKey)
-  })
-
-  it('should request faucet', async () => {
-    const faucetRes = await client.requestFaucet(testPresentationKey)
-    expect(faucetRes.success).toBe(true)
-    expect(faucetRes.paymentData).toBeDefined()
-    expect(faucetRes.paymentData.amount).toBe(1000)
-  })
-
-  it('should list linked methods', async () => {
-    const linked = await client.listLinkedMethods(testPresentationKey)
-    expect(linked.authMethods).toHaveLength(1)
-    expect(linked.authMethods[0].methodType).toBe('TwilioPhone')
-  })
-
-  it('can delete user', async () => {
-    const del = await client.deleteUser(testPresentationKey)
-    expect(del.success).toBe(true)
-  })
-})

package/src/wab-client/auth-method-interactors/AuthMethodInteractor.ts

@@ -1,47 +0,0 @@
-/**
- * AuthMethodInteractor
- *
- * A base interface/class for client-side logic to interact with a server
- * for a specific Auth Method's flow (start, complete).
- */
-
-export interface AuthPayload {
-  [key: string]: any
-}
-
-export interface StartAuthResponse {
-  success: boolean
-  message?: string
-  data?: any
-}
-
-export interface CompleteAuthResponse {
-  success: boolean
-  message?: string
-  presentationKey?: string
-}
-
-/**
- * Abstract client-side interactor for an Auth Method
- */
-export abstract class AuthMethodInteractor {
-  public abstract methodType: string
-
-  /**
-   * Start the flow (e.g. request an OTP or create a session).
-   */
-  public abstract startAuth(
-    serverUrl: string,
-    presentationKey: string,
-    payload: AuthPayload
-  ): Promise<StartAuthResponse>
-
-  /**
-   * Complete the flow (e.g. confirm OTP).
-   */
-  public abstract completeAuth(
-    serverUrl: string,
-    presentationKey: string,
-    payload: AuthPayload
-  ): Promise<CompleteAuthResponse>
-}

package/src/wab-client/auth-method-interactors/DevConsoleInteractor.ts

@@ -1,73 +0,0 @@
-import { AuthMethodInteractor, AuthPayload, StartAuthResponse, CompleteAuthResponse } from './AuthMethodInteractor'
-
-/**
- * DevConsoleInteractor
- *
- * A client-side class that knows how to call the WAB server for DevConsole-based authentication.
- * This is a development-only auth method that generates OTP codes and logs them to the console.
- */
-export class DevConsoleInteractor extends AuthMethodInteractor {
-  public methodType = 'DevConsole'
-
-  /**
-   * Start the DevConsole authentication on the server.
-   * - The server will generate an OTP code and log it to the console for development use.
-   * @param serverUrl         - The base URL of the WAB server (e.g. http://localhost:3000)
-   * @param presentationKey   - The 256-bit key the client is attempting to authenticate with
-   * @param payload           - { phoneNumber: string } (identifier for the authentication)
-   * @returns                 - { success, message, data }
-   */
-  public async startAuth(serverUrl: string, presentationKey: string, payload: AuthPayload): Promise<StartAuthResponse> {
-    const res = await fetch(`${serverUrl}/auth/start`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        methodType: this.methodType,
-        presentationKey,
-        payload
-      })
-    })
-
-    if (!res.ok) {
-      return {
-        success: false,
-        message: `HTTP error ${res.status}`
-      }
-    }
-
-    return res.json()
-  }
-
-  /**
-   * Complete the DevConsole authentication on the server.
-   * - The server will verify the OTP code that was generated and logged to the console.
-   * @param serverUrl         - The base URL of the WAB server
-   * @param presentationKey   - The 256-bit key
-   * @param payload           - { phoneNumber: string, otp: string } (the identifier and OTP code from console)
-   * @returns                 - { success, message, presentationKey }
-   */
-  public async completeAuth(
-    serverUrl: string,
-    presentationKey: string,
-    payload: AuthPayload
-  ): Promise<CompleteAuthResponse> {
-    const res = await fetch(`${serverUrl}/auth/complete`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        methodType: this.methodType,
-        presentationKey,
-        payload
-      })
-    })
-
-    if (!res.ok) {
-      return {
-        success: false,
-        message: `HTTP error ${res.status}`
-      }
-    }
-
-    return res.json()
-  }
-}

package/src/wab-client/auth-method-interactors/PersonaIDInteractor.ts

@@ -1,35 +0,0 @@
-import { AuthMethodInteractor, AuthPayload, StartAuthResponse, CompleteAuthResponse } from './AuthMethodInteractor'
-
-export class PersonaIDInteractor extends AuthMethodInteractor {
-  public methodType = 'PersonaID'
-
-  public async startAuth(serverUrl: string, presentationKey: string, payload: AuthPayload): Promise<StartAuthResponse> {
-    const res = await fetch(`${serverUrl}/auth/start`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        methodType: this.methodType,
-        presentationKey,
-        payload
-      })
-    })
-    return res.json()
-  }
-
-  public async completeAuth(
-    serverUrl: string,
-    presentationKey: string,
-    payload: AuthPayload
-  ): Promise<CompleteAuthResponse> {
-    const res = await fetch(`${serverUrl}/auth/complete`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        methodType: this.methodType,
-        presentationKey,
-        payload
-      })
-    })
-    return res.json()
-  }
-}

package/src/wab-client/auth-method-interactors/TwilioPhoneInteractor.ts

@@ -1,72 +0,0 @@
-import { AuthMethodInteractor, AuthPayload, StartAuthResponse, CompleteAuthResponse } from './AuthMethodInteractor'
-
-/**
- * TwilioPhoneInteractor
- *
- * A client-side class that knows how to call the WAB server for Twilio-based phone verification.
- */
-export class TwilioPhoneInteractor extends AuthMethodInteractor {
-  public methodType = 'TwilioPhone'
-
-  /**
-   * Start the Twilio phone verification on the server.
-   * - The server will send an SMS code to the user’s phone, using Twilio Verify.
-   * @param serverUrl         - The base URL of the WAB server (e.g. http://localhost:3000)
-   * @param presentationKey   - The 256-bit key the client is attempting to authenticate with
-   * @param payload           - { phoneNumber: string } (the phone number to verify)
-   * @returns                 - { success, message, data }
-   */
-  public async startAuth(serverUrl: string, presentationKey: string, payload: AuthPayload): Promise<StartAuthResponse> {
-    const res = await fetch(`${serverUrl}/auth/start`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        methodType: this.methodType,
-        presentationKey,
-        payload
-      })
-    })
-
-    if (!res.ok) {
-      return {
-        success: false,
-        message: `HTTP error ${res.status}`
-      }
-    }
-
-    return res.json()
-  }
-
-  /**
-   * Complete the Twilio phone verification on the server.
-   * - The server will verify the code with Twilio Verify’s verificationChecks endpoint.
-   * @param serverUrl         - The base URL of the WAB server
-   * @param presentationKey   - The 256-bit key
-   * @param payload           - { phoneNumber: string, otp: string } (the code that was received via SMS)
-   * @returns                 - { success, message, presentationKey }
-   */
-  public async completeAuth(
-    serverUrl: string,
-    presentationKey: string,
-    payload: AuthPayload
-  ): Promise<CompleteAuthResponse> {
-    const res = await fetch(`${serverUrl}/auth/complete`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        methodType: this.methodType,
-        presentationKey,
-        payload
-      })
-    })
-
-    if (!res.ok) {
-      return {
-        success: false,
-        message: `HTTP error ${res.status}`
-      }
-    }
-
-    return res.json()
-  }
-}

package/syncVersions.js

@@ -1,71 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-/**
- * Synchronizes version numbers from root package.json to mobile and client package.json files
- * and updates package-lock.json files by running npm install
- */
-function syncVersions() {
-  try {
-    // Read the root package.json
-    const rootPackagePath = path.join(__dirname, 'package.json');
-    const rootPackage = JSON.parse(fs.readFileSync(rootPackagePath, 'utf8'));
-    const version = rootPackage.version;
-
-    console.log(`Root package version: ${version}`);
-
-    // Directories to update
-    const directoriesToUpdate = [
-      { packagePath: './mobile/package.json', dir: './mobile' },
-      { packagePath: './client/package.json', dir: './client' }
-    ];
-
-    // Update each package.json file and run npm install
-    directoriesToUpdate.forEach(({ packagePath, dir }) => {
-      const fullPath = path.join(__dirname, packagePath);
-      const fullDirPath = path.join(__dirname, dir);
-      
-      if (fs.existsSync(fullPath)) {
-        const packageData = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
-        const oldVersion = packageData.version;
-        
-        packageData.version = version;
-        fs.writeFileSync(fullPath, JSON.stringify(packageData, null, 2) + '\n');
-        
-        console.log(`Updated ${packagePath}: ${oldVersion} → ${version}`);
-        
-        // Run npm install to update package-lock.json
-        if (fs.existsSync(fullDirPath)) {
-          console.log(`Running npm install in ${dir}...`);
-          try {
-            execSync('npm install', { 
-              cwd: fullDirPath, 
-              stdio: 'inherit',
-              timeout: 60000 // 60 second timeout
-            });
-            console.log(`✓ npm install completed in ${dir}`);
-          } catch (installError) {
-            console.error(`✗ npm install failed in ${dir}:`, installError.message);
-          }
-        } else {
-          console.warn(`Warning: Directory ${dir} not found`);
-        }
-      } else {
-        console.warn(`Warning: ${packagePath} not found`);
-      }
-    });
-
-    console.log('Version synchronization completed successfully!');
-  } catch (error) {
-    console.error('Error synchronizing versions:', error.message);
-    process.exit(1);
-  }
-}
-
-// Run the function if this script is executed directly
-if (require.main === module) {
-  syncVersions();
-}
-
-module.exports = syncVersions;

package/test/Wallet/StorageClient/storageClient.man.test.ts

@@ -1,75 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { sdk, StorageClient } from '../../../src/index.all'
-import { _tu, TestWalletOnly } from '../../utils/TestUtilsWalletStorage'
-
-/**
- * WARNING: This test hangs the commit to master automated test run cycle if included in regular tests...
- */
-
-describe('walletStorageClient test', () => {
-  jest.setTimeout(99999999)
-
-  const env = _tu.getEnv('test')
-  const testName = () => expect.getState().currentTestName || 'test'
-
-  const ctxs: TestWalletOnly[] = []
-
-  beforeAll(async () => {
-    //_tu.mockPostServicesAsSuccess(ctxs)
-  })
-
-  afterAll(async () => {
-    for (const ctx of ctxs) {
-      await ctx.storage.destroy()
-    }
-  })
-
-  test('1 backup to client', async () => {
-    const ctx = await _tu.createLegacyWalletSQLiteCopy('walletStorageClient1')
-    ctxs.push(ctx)
-    const { wallet, storage } = ctx
-
-    {
-      const client = new StorageClient(wallet, 'https://staging-storage.babbage.systems')
-      await storage.addWalletStorageProvider(client)
-      await storage.updateBackups()
-    }
-  })
-
-  test('2 create storage client backup for test wallet', async () => {
-    const ctx = await _tu.createTestWalletWithStorageClient({
-      rootKeyHex: '1'.repeat(64),
-      endpointUrl: 'https://staging-storage.babbage.systems'
-    })
-    ctxs.push(ctx)
-    const { wallet, storage } = ctx
-
-    {
-      const auth = await storage.getAuth()
-      expect(auth.userId).toBeTruthy()
-    }
-  })
-
-  test('3 create storage client backup for main wallet', async () => {
-    const filePath = process.env.MY_MAIN_FILEPATH
-    const identityKey = process.env.MY_MAIN_IDENTITY || ''
-    const rootKeyHex = env.devKeys[identityKey]
-    expect(filePath && identityKey && rootKeyHex)
-
-    const chain: sdk.Chain = 'main'
-
-    const main = await _tu.createSQLiteTestWallet({
-      filePath,
-      databaseName: 'tone42',
-      chain,
-      rootKeyHex
-    })
-    ctxs.push(main)
-
-    {
-      const client = new StorageClient(main.wallet, 'https://storage.babbage.systems')
-      await main.storage.addWalletStorageProvider(client)
-      await main.storage.updateBackups()
-    }
-  })
-})