@bandeira-tech/b3nd-web 0.2.5 → 0.2.7

package/dist/wallet/mod.d.ts

@@ -1,354 +1,135 @@
-/**
- * Wallet Client Types
- *
- * Type definitions for the B3nd Wallet Client that interacts with wallet servers.
- */
-/**
- * Configuration for wallet client
- */
-interface WalletClientConfig {
-    /**
-     * Wallet server URL (e.g., "http://localhost:3001")
-     */
-    walletServerUrl: string;
-    /**
-     * API base path prefix (e.g., "/api/v1"). Must be provided explicitly.
-     */
-    apiBasePath: string;
-    /**
-     * Optional fetch implementation (for custom HTTP handling)
-     */
-    fetch?: typeof fetch;
-}
-/**
- * User credentials for authentication
- */
-interface UserCredentials {
-    username: string;
-    password: string;
-}
-/**
- * Authenticated session with JWT token
- */
-interface AuthSession {
-    username: string;
-    token: string;
-    expiresIn: number;
-}
-/**
- * User's public keys
- */
-interface UserPublicKeys {
-    accountPublicKeyHex: string;
-    encryptionPublicKeyHex: string;
-}
-/**
- * Password reset token
- */
-interface PasswordResetToken {
-    resetToken: string;
-    expiresIn: number;
-}
-/**
- * Write proxy request
- */
-interface ProxyWriteRequest {
-    uri: string;
-    data: unknown;
-    encrypt?: boolean;
-}
-/**
- * Write proxy response
- */
-interface ProxyWriteResponse {
-    success: boolean;
-    uri: string;
-    resolvedUri?: string;
-    data: unknown;
-    record?: {
-        data: unknown;
-        ts: number;
-    };
-}
-/**
- * Read proxy request
- */
-interface ProxyReadRequest {
-    uri: string;
-}
-/**
- * Read proxy response
- */
-interface ProxyReadResponse {
-    success: boolean;
-    uri: string;
-    record?: {
-        data: unknown;
-        ts: number;
-    };
-    decrypted?: unknown;
-    error?: string;
-}
-/**
- * API response wrapper
- */
-interface ApiResponse {
-    success: boolean;
-    error?: string;
-    [key: string]: unknown;
-}
-/**
- * Signup response
- */
-interface SignupResponse extends ApiResponse {
-    username: string;
-    token: string;
-    expiresIn: number;
-}
-/**
- * Login response
- */
-interface LoginResponse extends ApiResponse {
-    username: string;
-    token: string;
-    expiresIn: number;
-}
-/**
- * Public keys response
- */
-interface PublicKeysResponse extends ApiResponse {
-    accountPublicKeyHex: string;
-    encryptionPublicKeyHex: string;
-}
-/**
- * Change password response
- */
-interface ChangePasswordResponse extends ApiResponse {
-    message: string;
-}
-/**
- * Request password reset response
- */
-interface RequestPasswordResetResponse extends ApiResponse {
-    message: string;
-    resetToken: string;
-    expiresIn: number;
-}
-/**
- * Reset password response
- */
-interface ResetPasswordResponse extends ApiResponse {
-    message: string;
-    username: string;
-    token: string;
-    expiresIn: number;
-}
-/**
- * Health check response
- */
-interface HealthResponse extends ApiResponse {
-    status: string;
-    server: string;
-    timestamp: string;
-}
-/**
- * Google OAuth session (extended AuthSession with Google profile info)
- */
-interface GoogleAuthSession extends AuthSession {
-    email: string;
-    name?: string;
-    picture?: string;
-}
-/**
- * Google signup response
- */
-interface GoogleSignupResponse extends ApiResponse {
-    username: string;
-    email: string;
-    name?: string;
-    picture?: string;
-    token: string;
-    expiresIn: number;
-}
-/**
- * Google login response
- */
-interface GoogleLoginResponse extends ApiResponse {
-    username: string;
-    email: string;
-    name?: string;
-    picture?: string;
-    token: string;
-    expiresIn: number;
-}
+import { A as AuthSession, H as HealthResponse, U as UserCredentials, P as PasswordResetToken, a as UserPublicKeys, b as ProxyWriteRequest, c as ProxyWriteResponse, d as ProxyReadRequest, e as ProxyReadResponse, G as GoogleAuthSession } from '../client-B0Ekm99R.js';
+export { g as ApiResponse, C as ChangePasswordResponse, k as GoogleLoginResponse, j as GoogleSignupResponse, L as LoginResponse, h as PublicKeysResponse, R as RequestPasswordResetResponse, i as ResetPasswordResponse, S as SignupResponse, W as WalletClient, f as WalletClientConfig } from '../client-B0Ekm99R.js';
+import { N as NodeProtocolInterface } from '../types-oQCx3U-_.js';
+import { S as ServerKeys, W as WalletServerCore } from '../core-CgxQpSVM.js';
+import 'hono';
 
 /**
- * B3nd Wallet Client
+ * Memory Wallet Client
  *
- * Client library for interacting with B3nd wallet servers.
- * Provides authentication, key management, and write proxying functionality.
- *
- * Works in both Deno and browser environments.
- */
-
-/**
- * B3nd Wallet Client
+ * In-memory implementation of the wallet client for testing.
+ * Embeds WalletServerCore with MemoryClient storage - no HTTP required.
  *
- * Manages authentication with a wallet server and provides methods
- * for user management, key retrieval, and proxied writes.
+ * Same interface as WalletClient, so you can swap between them:
  *
  * @example
  * ```typescript
+ * // Production
+ * const backend = new HttpClient({ baseUrl: "http://localhost:8842" });
  * const wallet = new WalletClient({
- *   walletServerUrl: "http://localhost:3001",
- *   apiBasePath: "/api/v1",
+ *   walletServerUrl: "http://localhost:8843",
+ *   apiBasePath: "/api/v1"
  * });
  *
- * // Sign up a new user
- * const session = await wallet.signup({
- *   username: "alice",
- *   password: "secure-password-123"
- * });
+ * // Tests - share same backend between wallet and direct operations
+ * const backend = new MemoryClient({ schema: { "mutable://accounts": ... } });
+ * const wallet = await MemoryWalletClient.create({ backend });
  *
- * // Activate the session
- * wallet.setSession(session);
+ * // Same API works for both
+ * await wallet.signupWithToken(appKey, { username: "alice", password: "secret" });
+ * await wallet.proxyWrite({ uri: "mutable://data/test", data: { foo: "bar" } });
  *
- * // Write data through proxy
- * await wallet.proxyWrite({
- *   uri: "mutable://data/my-app/profile",
- *   data: { name: "Alice" },
- *   encrypt: true
- * });
+ * // Direct backend access in tests
+ * const result = await backend.read("mutable://accounts/...");
  * ```
  */
-declare class WalletClient {
-    private walletServerUrl;
-    private apiBasePath;
-    private fetchImpl;
-    private currentSession;
-    constructor(config: WalletClientConfig);
-    private buildUrl;
-    private buildAppKeyUrl;
+
+interface MemoryWalletClientConfig {
     /**
-     * Get the current authenticated session
+     * Optional server keys. If not provided, keys are auto-generated.
      */
-    getSession(): AuthSession | null;
+    serverKeys?: ServerKeys;
     /**
-     * Set the current session (useful for restoring from storage)
+     * Optional JWT secret. Defaults to a test secret.
      */
-    setSession(session: AuthSession | null): void;
+    jwtSecret?: string;
     /**
-     * Check if user is currently authenticated
+     * Optional JWT expiration in seconds. Defaults to 3600 (1 hour).
      */
-    isAuthenticated(): boolean;
+    jwtExpirationSeconds?: number;
     /**
-     * Get current username (if authenticated)
+     * Shared backend storage (e.g., MemoryClient).
+     * Use this to share the same storage between wallet and direct operations.
+     * If not provided, a new MemoryClient is created.
+     *
+     * @example
+     * ```typescript
+     * const backend = new MemoryClient({ schema: { ... } });
+     * const wallet = await MemoryWalletClient.create({ backend });
+     *
+     * // Both use the same storage
+     * await backend.write("mutable://accounts/...", data);
+     * await wallet.proxyWrite({ uri: "mutable://...", data });
+     * ```
      */
-    getUsername(): string | null;
+    backend?: NodeProtocolInterface;
+}
+/**
+ * Generate server keys for testing
+ */
+declare function generateTestServerKeys(): Promise<ServerKeys>;
+/**
+ * Memory Wallet Client
+ *
+ * In-memory implementation that embeds WalletServerCore.
+ * Use for testing without running a real server.
+ */
+declare class MemoryWalletClient {
+    private server;
+    private handler;
+    private currentSession;
+    private apiBasePath;
+    private constructor();
     /**
-     * Get current JWT token (if authenticated)
+     * Create a new MemoryWalletClient
+     * Use this factory method instead of constructor (async key generation)
      */
-    getToken(): string | null;
+    static create(config?: MemoryWalletClientConfig): Promise<MemoryWalletClient>;
     /**
-     * Clear current session (logout)
+     * Make a request to the embedded server
      */
-    logout(): void;
+    private request;
     /**
-     * Check wallet server health
+     * Make an authenticated request
      */
+    private authRequest;
+    getSession(): AuthSession | null;
+    setSession(session: AuthSession | null): void;
+    isAuthenticated(): boolean;
+    getUsername(): string | null;
+    getToken(): string | null;
+    logout(): void;
     health(): Promise<HealthResponse>;
-    /**
-     * Sign up a new user
-     * Returns session data - call setSession() to activate it
-     */
+    getServerKeys(): Promise<{
+        identityPublicKeyHex: string;
+        encryptionPublicKeyHex: string;
+    }>;
     signup(_credentials: UserCredentials): Promise<AuthSession>;
-    /**
-     * Login existing user
-     * Returns session data - call setSession() to activate it
-     */
     login(_credentials: UserCredentials): Promise<AuthSession>;
-    /**
-     * Change password for current user
-     * Requires active authentication session
-     */
+    signupWithToken(appKey: string, tokenOrCredentials: string | UserCredentials, maybeCredentials?: UserCredentials): Promise<AuthSession>;
+    loginWithTokenSession(appKey: string, tokenOrSession: string, sessionOrCredentials: string | UserCredentials, maybeCredentials?: UserCredentials): Promise<AuthSession>;
     changePassword(appKey: string, oldPassword: string, newPassword: string): Promise<void>;
-    /**
-     * Request a password reset token
-     * Does not require authentication
-     */
     requestPasswordReset(_username: string): Promise<PasswordResetToken>;
-    /**
-     * Reset password using a reset token
-     * Returns session data - call setSession() to activate it
-     */
     resetPassword(_username: string, _resetToken: string, _newPassword: string): Promise<AuthSession>;
-    /**
-     * Sign up with app token (scoped to an app)
-     */
-    signupWithToken(appKey: string, tokenOrCredentials: string | UserCredentials, maybeCredentials?: UserCredentials): Promise<AuthSession>;
-    /**
-     * Login with app token and session (scoped to an app)
-     */
-    loginWithTokenSession(appKey: string, tokenOrSession: string, sessionOrCredentials: string | UserCredentials, maybeCredentials?: UserCredentials): Promise<AuthSession>;
-    /**
-     * Request password reset scoped to app token
-     */
     requestPasswordResetWithToken(appKey: string, tokenOrUsername: string, maybeUsername?: string): Promise<PasswordResetToken>;
-    /**
-     * Reset password scoped to an app
-     */
     resetPasswordWithToken(appKey: string, _tokenOrUsername: string, usernameOrReset: string, resetToken?: string, newPassword?: string): Promise<AuthSession>;
-    /**
-     * Get public keys for the current authenticated user.
-     * Requires an active authentication session.
-     */
     getPublicKeys(appKey: string): Promise<UserPublicKeys>;
-    /**
-     * Proxy a write request through the wallet server
-     * The server signs the write with its identity key
-     * Requires active authentication session
-     */
+    getMyPublicKeys(appKey: string): Promise<UserPublicKeys>;
     proxyWrite(request: ProxyWriteRequest): Promise<ProxyWriteResponse>;
-    /**
-     * Proxy a read request through the wallet server
-     * The server decrypts encrypted data using user's encryption key
-     * Requires active authentication session
-     */
     proxyRead(request: ProxyReadRequest): Promise<ProxyReadResponse>;
+    signupWithGoogle(appKey: string, token: string, googleIdToken: string): Promise<GoogleAuthSession>;
+    loginWithGoogle(appKey: string, token: string, session: string, googleIdToken: string): Promise<GoogleAuthSession>;
     /**
-     * Convenience method: Get current user's public keys
-     * Requires active authentication session
+     * Get the underlying WalletServerCore (for testing/inspection)
      */
-    getMyPublicKeys(appKey: string): Promise<UserPublicKeys>;
+    getServer(): WalletServerCore;
     /**
-     * Get server's public keys
-     *
-     * @returns Server's identity and encryption public keys
-     * @throws Error if request fails
+     * Get server's public keys directly (convenience method)
      */
-    getServerKeys(): Promise<{
+    getServerPublicKeys(): {
         identityPublicKeyHex: string;
         encryptionPublicKeyHex: string;
-    }>;
-    /**
-     * Sign up with Google OAuth (scoped to app token)
-     * Returns session data with Google profile info - call setSession() to activate it
-     *
-     * @param token - App token from app server
-     * @param googleIdToken - Google ID token from Google Sign-In
-     * @returns GoogleAuthSession with username, JWT token, and Google profile info
-     */
-    signupWithGoogle(appKey: string, token: string, googleIdToken: string): Promise<GoogleAuthSession>;
-    /**
-     * Login with Google OAuth (scoped to app token and session)
-     * Returns session data with Google profile info - call setSession() to activate it
-     *
-     * @param token - App token from app server
-     * @param session - Session key from app server
-     * @param googleIdToken - Google ID token from Google Sign-In
-     * @returns GoogleAuthSession with username, JWT token, and Google profile info
-     */
-    loginWithGoogle(appKey: string, token: string, session: string, googleIdToken: string): Promise<GoogleAuthSession>;
+    };
 }
 
-export { type ApiResponse, type AuthSession, type ChangePasswordResponse, type GoogleAuthSession, type GoogleLoginResponse, type GoogleSignupResponse, type HealthResponse, type LoginResponse, type PasswordResetToken, type ProxyReadRequest, type ProxyReadResponse, type ProxyWriteRequest, type ProxyWriteResponse, type PublicKeysResponse, type RequestPasswordResetResponse, type ResetPasswordResponse, type SignupResponse, type UserCredentials, type UserPublicKeys, WalletClient, type WalletClientConfig };
+export { AuthSession, GoogleAuthSession, HealthResponse, MemoryWalletClient, type MemoryWalletClientConfig, PasswordResetToken, ProxyReadRequest, ProxyReadResponse, ProxyWriteRequest, ProxyWriteResponse, UserCredentials, UserPublicKeys, generateTestServerKeys };

package/dist/wallet/mod.js

@@ -1,7 +1,15 @@
 import {
-  WalletClient
-} from "../chunk-S7NJA6B6.js";
+  MemoryWalletClient,
+  WalletClient,
+  generateTestServerKeys
+} from "../chunk-7O4D7SF6.js";
+import "../chunk-GIMIWVPX.js";
+import "../chunk-F3W5GZU6.js";
+import "../chunk-JN75UL5C.js";
+import "../chunk-LFUC4ETD.js";
 import "../chunk-MLKGABMK.js";
 export {
-  WalletClient
+  MemoryWalletClient,
+  WalletClient,
+  generateTestServerKeys
 };

package/dist/wallet-server/adapters/browser.js

@@ -1,3 +1,6 @@
+import {
+  LocalStorageClient
+} from "../../chunk-7U5JDFQW.js";
 import {
   ConfigEnvironment,
   MemoryFileStorage,
@@ -5,9 +8,6 @@ import {
 } from "../../chunk-F3W5GZU6.js";
 import "../../chunk-JN75UL5C.js";
 import "../../chunk-LFUC4ETD.js";
-import {
-  LocalStorageClient
-} from "../../chunk-7U5JDFQW.js";
 import "../../chunk-MLKGABMK.js";
 
 // wallet-server/adapters/browser.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bandeira-tech/b3nd-web",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Browser-focused B3nd SDK bundle",
   "type": "module",
   "main": "./dist/src/mod.web.js",