@bopen-io/wallet-toolbox 1.7.18

package/src/wab-client/WABClient.ts

@@ -0,0 +1,94 @@
+/**
+ * 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

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

@@ -0,0 +1,47 @@
+/**
+ * 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

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

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

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

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

@@ -0,0 +1,75 @@
+/* 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()
+    }
+  })
+})

package/test/Wallet/action/abortAction.test.ts

@@ -0,0 +1,47 @@
+import { AbortActionArgs } from '@bsv/sdk'
+import { sdk } from '../../../src/index.client'
+import { _tu, expectToThrowWERR, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+
+describe('abortAction tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+
+  beforeAll(async () => {})
+
+  afterAll(async () => {})
+
+  test('0 invalid params', async () => {
+    const ctxs: TestWalletNoSetup[] = []
+    if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('abortActionTests'))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('abortActionTests'))
+    for (const { wallet } of ctxs) {
+      const invalidArgs: AbortActionArgs[] = [
+        { reference: '' },
+        { reference: '====' },
+        { reference: 'a'.repeat(301) },
+        { reference: 'a'.repeat(300) }
+        // Oh so many things to test...
+      ]
+
+      for (const args of invalidArgs) {
+        await expectToThrowWERR(sdk.WERR_INVALID_PARAMETER, () => wallet.abortAction(args))
+      }
+    }
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('1_abort reference 49f878d8405589', async () => {
+    const ctxs: TestWalletNoSetup[] = []
+    if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('abortActionTests'))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('abortActionTests'))
+    for (const { wallet } of ctxs) {
+      await wallet.abortAction({ reference: 'Sfh42EBViQ==' })
+    }
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+})