@terminal3/t3n-sdk 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,819 @@
+/**
+ * WASM Component Interface - Mirrors the WIT specification exactly
+ *
+ * This interface works with completely opaque byte arrays, just like the WIT interface.
+ * The TypeScript SDK doesn't know about internal state machine phases or details.
+ */
+/**
+ * Result type for WASM next() operations
+ */
+interface WasmNextResult {
+    state: Uint8Array;
+    request: Uint8Array;
+}
+/**
+ * Client handshake operations - completely opaque byte arrays only
+ */
+interface ClientHandshake {
+    /**
+     * Process next step in handshake
+     * @param state - Current handshake state (null for initial call)
+     * @param action - Action to process (opaque bytes)
+     * @returns Promise with new state and request to send
+     */
+    next(state: Uint8Array | null, action: Uint8Array): Promise<WasmNextResult>;
+    /**
+     * Attempt to finalize handshake
+     * @param state - Current handshake state
+     * @returns Promise with session bytes if successful
+     * @throws Error if handshake not ready to finalize
+     */
+    finish(state: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Client authentication operations - completely opaque byte arrays only
+ */
+interface ClientAuth {
+    /**
+     * Process next step in authentication
+     * @param state - Current auth state (null for initial call)
+     * @param action - Action to process (opaque bytes)
+     * @returns Promise with new state and request to send
+     */
+    next(state: Uint8Array | null, action: Uint8Array): Promise<WasmNextResult>;
+    /**
+     * Attempt to finalize authentication
+     * @param state - Current auth state
+     * @returns Promise with DID bytes if successful
+     * @throws Error if authentication not ready to finalize
+     */
+    finish(state: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Client authentication operations - completely opaque byte arrays only
+ */
+interface ClientExecute {
+    /**
+     * Process next step in authentication
+     * @param state - Current auth state (null for initial call)
+     * @param action - Action to process (opaque bytes)
+     * @returns Promise with new state and request to send
+     */
+    next(state: Uint8Array | null, action: Uint8Array): Promise<WasmNextResult>;
+    /**
+     * Attempt to finalize authentication
+     * @param state - Current auth state
+     * @returns Promise with DID bytes if successful
+     * @throws Error if authentication not ready to finalize
+     */
+    finish(state: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Session encryption/decryption operations - completely opaque byte arrays only
+ */
+interface SessionCrypto {
+    /**
+     * Encrypt plaintext using session
+     * @param session - Session state (opaque bytes)
+     * @param nonce - Nonce to use for encryption
+     * @param plaintext - Data to encrypt
+     * @returns Promise with encrypted bytes
+     */
+    encrypt(session: Uint8Array, nonce: Uint8Array, plaintext: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt ciphertext using session
+     * @param session - Session state (opaque bytes)
+     * @param ciphertext - Data to decrypt
+     * @returns Promise with decrypted bytes
+     */
+    decrypt(session: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Main WASM Component interface - mirrors the WIT interface exactly
+ *
+ * This is completely opaque to the TypeScript layer. All state machine logic,
+ * authentication flows, and cryptographic operations are handled in WASM.
+ */
+interface WasmComponent {
+    /** Client handshake operations */
+    flow: {
+        handshake: ClientHandshake;
+        auth: ClientAuth;
+        execute: ClientExecute;
+    };
+    session: SessionCrypto;
+}
+
+/**
+ * Logger interface and implementations for T3n SDK
+ *
+ * Provides hierarchical log level control (DEBUG, INFO, WARN, ERROR) with
+ * global defaults and per-component override capabilities.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { getLogger, setGlobalLogLevel, LogLevel } from '@t3n-sdk/logger';
+ *
+ * // Use the global logger (defaults to ERROR level)
+ * const logger = getLogger();
+ * logger.error("This will be logged");
+ * logger.debug("This will NOT be logged by default");
+ *
+ * // Enable debug logging globally
+ * setGlobalLogLevel(LogLevel.DEBUG);
+ * const debugLogger = getLogger();
+ * debugLogger.debug("This will now be logged");
+ *
+ * // Create a logger with a specific level (overrides global)
+ * const infoLogger = createLogger(LogLevel.INFO);
+ * infoLogger.info("This will be logged");
+ * infoLogger.debug("This will NOT be logged");
+ * ```
+ *
+ * ## Log Levels
+ *
+ * - `DEBUG` (0): Most verbose, logs everything
+ * - `INFO` (1): Logs info, warnings, and errors
+ * - `WARN` (2): Logs warnings and errors only
+ * - `ERROR` (3): Logs errors only (default)
+ */
+/**
+ * Log levels in hierarchical order (lower values = more verbose)
+ */
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+/**
+ * Logger interface for SDK debugging and monitoring
+ */
+interface Logger {
+    /**
+     * Log a debug message (most verbose)
+     * @param args - Arguments to log
+     */
+    debug(...args: any[]): void;
+    /**
+     * Log an info message
+     * @param args - Arguments to log
+     */
+    info(...args: any[]): void;
+    /**
+     * Log a warning message
+     * @param args - Arguments to log
+     */
+    warn(...args: any[]): void;
+    /**
+     * Log an error message (least verbose)
+     * @param args - Arguments to log
+     */
+    error(...args: any[]): void;
+}
+/**
+ * Set the global default log level for all components
+ *
+ * This affects all loggers created without an explicit log level.
+ * The default global log level is LogLevel.ERROR (only errors are logged).
+ *
+ * @param level - The log level to set as default for all components
+ *
+ * @example
+ * ```typescript
+ * // Enable debug logging globally
+ * setGlobalLogLevel(LogLevel.DEBUG);
+ *
+ * // Only log errors (default)
+ * setGlobalLogLevel(LogLevel.ERROR);
+ * ```
+ */
+declare function setGlobalLogLevel(level: LogLevel): void;
+/**
+ * Get the current global log level
+ * @returns The current global log level (default: LogLevel.ERROR)
+ */
+declare function getGlobalLogLevel(): LogLevel;
+/**
+ * Create a logger instance with the specified log level
+ * @param level - The log level for this logger. If not provided, defaults to the global log level (LogLevel.ERROR).
+ * @returns Logger instance configured with the specified or default log level
+ */
+declare function createLogger(level?: LogLevel): Logger;
+/**
+ * Get a logger instance using the global log level
+ * @returns Logger instance with global log level (default: LogLevel.ERROR)
+ */
+declare function getLogger(): Logger;
+
+/**
+ * WASM Component Loader
+ *
+ * This module provides utilities for loading and initializing the WASM component.
+ * The actual WASM loading implementation will depend on the build system and
+ * deployment environment.
+ */
+
+/**
+ * Configuration for WASM component loading
+ */
+interface WasmLoadConfig {
+    /** Path or URL to the WASM module */
+    wasmPath?: string;
+    /** Custom fetch function for loading WASM */
+    fetchFn?: typeof fetch;
+    /** Additional initialization options */
+    initOptions?: Record<string, any>;
+    /** Optional logger instance - if not provided, uses global default */
+    logger?: Logger;
+}
+/**
+ * Load and initialize the T3n WASM component
+ *
+ * @param config - Optional configuration for loading the WASM component
+ * @returns Promise that resolves to the initialized WASM component
+ *
+ * @example
+ * ```typescript
+ * const wasmComponent = await loadWasmComponent({
+ *   wasmPath: '/path/to/t3n.wasm'
+ * });
+ * ```
+ */
+declare function loadWasmComponent(config?: WasmLoadConfig): Promise<WasmComponent>;
+
+/**
+ * Session-related types for T3n SDK
+ */
+interface SessionId {
+    readonly value: string;
+}
+interface Did {
+    readonly value: string;
+    toString(): string;
+}
+interface HandshakeResult {
+    readonly sessionId: SessionId;
+    readonly expiry: number;
+    readonly authenticated: boolean;
+    readonly did?: Did;
+}
+/**
+ * Simple status enum - mirrors server SessionStatus only
+ */
+declare enum SessionStatus {
+    Init = 0,
+    Encrypted = 1,
+    Authenticated = 2
+}
+
+/**
+ * Authentication-related types for T3n SDK
+ */
+/**
+ * Authentication method enum
+ */
+declare enum AuthMethod {
+    Ethereum = "eth",
+    OIDC = "oidc"
+}
+/**
+ * OIDC credentials interface
+ */
+interface OidcCredentials {
+    provider: string;
+    idToken: string;
+}
+/**
+ * Base authentication input with method discriminator
+ */
+interface BaseAuthInput {
+    method: AuthMethod;
+}
+/**
+ * Ethereum authentication input
+ */
+interface EthAuthInput extends BaseAuthInput {
+    method: AuthMethod.Ethereum;
+    address: string;
+}
+/**
+ * OIDC authentication input
+ */
+interface OidcAuthInput extends BaseAuthInput {
+    method: AuthMethod.OIDC;
+    credentials: OidcCredentials;
+}
+/**
+ * Union type for all supported authentication inputs
+ */
+type AuthInput = EthAuthInput | OidcAuthInput;
+/**
+ * Helper functions to create auth inputs
+ */
+declare function createEthAuthInput(address: string): EthAuthInput;
+declare function createOidcAuthInput(credentials: OidcCredentials): OidcAuthInput;
+
+/**
+ * Public types export for T3n SDK
+ */
+/**
+ * Guest-to-Host request handler function type
+ * Handles requests from WASM guest that need host (SDK) to perform side effects
+ */
+type GuestToHostHandler = (requestData: any) => Promise<Uint8Array>;
+/**
+ * Map of guest-to-host request handlers
+ * Keys match the guest_to_host tag values from the WASM
+ */
+interface GuestToHostHandlers {
+    /**
+     * Handle Ethereum signature requests
+     * requestData: { guest_to_host: "EthSign", challenge: string (base64) }
+     * Returns: JSON bytes of { host_to_guest: "EthSign", challenge: string, signature: string }
+     */
+    EthSign?: GuestToHostHandler;
+    /**
+     * Handle MlKem public key requests
+     * requestData: { guest_to_host: "MlKemPublicKey" }
+     * Returns: JSON bytes of { host_to_guest: "MlKemPublicKey", key: string }
+     */
+    MlKemPublicKey?: GuestToHostHandler;
+    /**
+     * Handle random bytes requests
+     * requestData: { guest_to_host: "Random", len?: number }
+     * Returns: JSON bytes of { host_to_guest: "Random", bytes: string (base64) }
+     */
+    Random?: GuestToHostHandler;
+    [key: string]: GuestToHostHandler | undefined;
+}
+
+/**
+ * Transport layer for T3n SDK
+ *
+ * Abstracts the communication with T3n nodes, allowing for different
+ * implementations (HTTP, WebSocket, Mock) and easy testing.
+ */
+/**
+ * JSON-RPC request structure
+ */
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    method: string;
+    params: any;
+    id: string | number;
+}
+/**
+ * JSON-RPC response structure
+ */
+interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+    id: string | number;
+}
+/**
+ * Transport interface for sending requests to T3n nodes
+ */
+interface Transport {
+    /**
+     * Send a JSON-RPC request to the T3n node
+     * @param request - The JSON-RPC request to send
+     * @param headers - Additional headers to include
+     * @returns Promise that resolves to the JSON-RPC response
+     */
+    send(request: JsonRpcRequest, headers: Record<string, string>): Promise<JsonRpcResponse>;
+    /**
+     * Optional accessor for the latest Set-Cookie header value.
+     * (Useful in Node.js demos/tests; browsers block HttpOnly cookies.)
+     */
+    getLastSetCookie?(): string | null;
+    /**
+     * Optional accessor for the last response headers (debugging).
+     */
+    getLastResponseHeaders?(): Record<string, string>;
+}
+/**
+ * HTTP transport implementation using fetch
+ */
+declare class HttpTransport implements Transport {
+    private baseUrl;
+    private timeout;
+    private lastSetCookie;
+    private lastResponseHeaders;
+    constructor(baseUrl: string, timeout?: number);
+    getLastSetCookie(): string | null;
+    getLastResponseHeaders(): Record<string, string>;
+    send(request: JsonRpcRequest, headers: Record<string, string>): Promise<JsonRpcResponse>;
+}
+/**
+ * Mock transport for testing
+ *
+ * @example
+ * ```typescript
+ * const mockTransport = new MockTransport();
+ * mockTransport.mockResponse("auth.handshake", { result: "..." });
+ *
+ * const client = new T3nClient({
+ *   transport: mockTransport,
+ *   wasmComponent: mockWasm,
+ * });
+ * ```
+ */
+declare class MockTransport implements Transport {
+    private responses;
+    private requests;
+    /**
+     * Mock a response for a specific method
+     */
+    mockResponse(method: string, response: Partial<JsonRpcResponse>): void;
+    /**
+     * Mock an error response for a specific method
+     */
+    mockError(method: string, code: number, message: string, data?: any): void;
+    /**
+     * Get all requests that were sent
+     */
+    getRequests(): Array<{
+        request: JsonRpcRequest;
+        headers: Record<string, string>;
+    }>;
+    /**
+     * Get requests for a specific method
+     */
+    getRequestsForMethod(method: string): Array<{
+        request: JsonRpcRequest;
+        headers: Record<string, string>;
+    }>;
+    /**
+     * Clear all recorded requests
+     */
+    clearRequests(): void;
+    send(request: JsonRpcRequest, headers: Record<string, string>): Promise<JsonRpcResponse>;
+}
+
+/**
+ * Configuration types for T3n Client
+ */
+
+/**
+ * Configuration interface for T3n Client
+ */
+interface T3nClientConfig {
+    /** Base URL of the T3n node (used if transport not provided) */
+    baseUrl?: string;
+    /** WASM component instance for cryptographic operations */
+    wasmComponent: WasmComponent;
+    /** Optional transport layer - if not provided, uses HttpTransport with baseUrl */
+    transport?: Transport;
+    /** Optional session ID - will be generated if not provided */
+    sessionId?: SessionId;
+    /** Optional request timeout in milliseconds (default: 30000) - used for HttpTransport */
+    timeout?: number;
+    /** Optional custom headers to include in requests */
+    headers?: Record<string, string>;
+    /**
+     * Log level for this client instance.
+     * Defaults to global log level (LogLevel.ERROR) if not specified.
+     * Use LogLevel.DEBUG for verbose logging, LogLevel.INFO for informational messages,
+     * LogLevel.WARN for warnings, or LogLevel.ERROR for errors only.
+     */
+    logLevel?: LogLevel;
+    /** Optional custom logger - if provided, overrides logLevel */
+    logger?: Logger;
+    /** Optional guest-to-host request handlers - provides custom behavior for WASM requests */
+    handlers?: GuestToHostHandlers;
+}
+
+/**
+ * T3n Client - Main SDK class
+ *
+ * Provides a simple interface for establishing secure sessions with T3n nodes.
+ * All cryptographic complexity is handled in WASM components.
+ */
+
+/**
+ * Main T3n SDK Client
+ */
+declare class T3nClient {
+    private readonly config;
+    private readonly transport;
+    private readonly sessionId;
+    private readonly logger;
+    private readonly encryption;
+    private status;
+    private wasmState;
+    private did;
+    private handshakeResult;
+    constructor(config: T3nClientConfig);
+    /**
+     * Start the handshake process with the T3n node
+     */
+    handshake(): Promise<HandshakeResult>;
+    /**
+     * Authenticate with the T3n node
+     */
+    authenticate(authInput: AuthInput): Promise<Did>;
+    /**
+     * Execute an action on the T3n node
+     */
+    execute(payload: unknown): Promise<string>;
+    getSessionId(): SessionId;
+    getStatus(): SessionStatus;
+    getDid(): Did | null;
+    getLastSetCookie(): string | null;
+    getLastResponseHeaders(): Record<string, string>;
+    isAuthenticated(): boolean;
+    /**
+     * Run a WASM state machine flow to completion
+     */
+    private runFlow;
+    /**
+     * Try to finalize the current flow
+     */
+    private tryFinalize;
+    /**
+     * Handle a WASM request based on its type
+     */
+    private handleWasmRequest;
+    /**
+     * Handle a send-remote request by calling the RPC endpoint
+     */
+    private handleSendRemote;
+    private captureHandshakeResult;
+    /**
+     * Handle a guest-to-host request using configured handlers
+     */
+    private handleGuestToHost;
+    /**
+     * Send an RPC request with automatic encryption/decryption
+     */
+    private sendRpcRequest;
+    /**
+     * Get the current session state for encryption
+     */
+    private getSessionState;
+}
+
+/**
+ * Guest-to-Host Request Handlers
+ *
+ * These handle requests from WASM that need the host environment to perform side effects.
+ * Examples: signing challenges, providing public keys, generating random bytes.
+ */
+
+/**
+ * Create an EthSign handler using MetaMask (window.ethereum)
+ * @param account - MetaMask account (string address or object with address property)
+ * @param logger - Optional logger instance. Defaults to a logger using the global log level (LogLevel.ERROR).
+ *   Pass a custom logger to override logging behavior for this handler.
+ * @param privateKey - Optional private key for signing (if provided, MetaMask is not used)
+ */
+declare function metamask_sign(account: any, logger?: Logger, privateKey?: string | undefined): GuestToHostHandler;
+/**
+ * Get the current MetaMask address
+ * @returns Ethereum address (lowercase, 0x prefixed)
+ */
+declare function metamask_get_address(): Promise<string>;
+/**
+ * Get the address for a given private key
+ * @param privateKey - Ethereum private key (0x prefixed hex string)
+ * @returns Ethereum address (lowercase, 0x prefixed)
+ */
+declare function eth_get_address(privateKey: string): string;
+/**
+ * Create MlKemPublicKey handler that returns the environment-specific root public key
+ * Note: The Rust PkWithRho type serializes as an array of bytes, not a base64 string
+ */
+declare function createMlKemPublicKeyHandler(): GuestToHostHandler;
+/**
+ * Create Random handler backed by crypto.getRandomValues
+ * Note: The Rust Vec<u8> type serializes as an array of bytes, not a base64 string
+ */
+declare function createRandomHandler(): GuestToHostHandler;
+/**
+ * Create the default handler set required by the T3n handshake
+ */
+declare function createDefaultHandlers(): GuestToHostHandlers;
+
+/**
+ * Cryptographic utilities for T3n SDK
+ *
+ * Cross-platform crypto support:
+ * - Browsers: Uses Web Crypto API (global crypto)
+ * - Node.js 19+: Uses global crypto
+ * - Node.js 16-18: Imports crypto module
+ */
+/**
+ * Generate a cryptographically secure random string
+ * @param length - Length of the random string in bytes
+ * @returns Base64-encoded random string
+ */
+declare function generateRandomString(length?: number): string;
+/**
+ * Generate a UUID v4
+ * @returns UUID string
+ */
+declare function generateUUID(): string;
+/**
+ * Convert a string to Uint8Array
+ * @param str - String to convert
+ * @returns Uint8Array representation
+ */
+declare function stringToBytes(str: string): Uint8Array;
+/**
+ * Convert Uint8Array to string
+ * @param bytes - Bytes to convert
+ * @returns String representation
+ */
+declare function bytesToString(bytes: Uint8Array): string;
+
+declare function getScriptVersion(rpcUrl: string, scriptName: string): Promise<string>;
+
+/**
+ * Error classes for T3n SDK
+ */
+/**
+ * Base error class for T3n SDK errors
+ */
+declare class T3nError extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+/**
+ * Error thrown when session is in invalid state for operation
+ */
+declare class SessionStateError extends T3nError {
+    readonly currentState: string;
+    constructor(message: string, currentState: string);
+}
+/**
+ * Error thrown during authentication process
+ */
+declare class AuthenticationError extends T3nError {
+    readonly authMethod?: string | undefined;
+    constructor(message: string, authMethod?: string | undefined);
+}
+/**
+ * Error thrown during handshake process
+ */
+declare class HandshakeError extends T3nError {
+    constructor(message: string);
+}
+/**
+ * Error thrown during RPC communication
+ */
+declare class RpcError extends T3nError {
+    readonly rpcMethod?: string | undefined;
+    readonly httpStatus?: number | undefined;
+    constructor(message: string, rpcMethod?: string | undefined, httpStatus?: number | undefined);
+}
+/**
+ * Error thrown when WASM operations fail
+ */
+declare class WasmError extends T3nError {
+    readonly operation?: string | undefined;
+    readonly payload?: unknown | undefined;
+    constructor(message: string, operation?: string | undefined, payload?: unknown | undefined);
+}
+/**
+ * Decode WASM error message from comma-separated byte array format
+ * WASM errors often come as "83,101,114,100,101..." which represents ASCII bytes
+ *
+ * @param errorMessage - The error message string that may contain comma-separated bytes
+ * @returns Decoded error message if it was encoded, otherwise original message
+ */
+declare function decodeWasmErrorMessage(errorMessage: string): string;
+/**
+ * Extract and decode error from WASM ComponentError
+ *
+ * @param error - The error object from WASM
+ * @returns Decoded error message
+ */
+declare function extractWasmError(error: unknown): string;
+
+/**
+ * Secret redaction utilities for T3n SDK
+ *
+ * Provides functions to redact sensitive information before logging
+ */
+/**
+ * Redact secrets from values before logging
+ */
+declare function redactSecrets(value: any): any;
+/**
+ * Redact secrets from a JSON string
+ */
+declare function redactSecretsFromJson(jsonString: string): string;
+
+/**
+ * Configuration types for T3n SDK
+ */
+/**
+ * Environment type for SDK configuration
+ */
+type Environment = "local" | "staging" | "production" | "test";
+/**
+ * SDK configuration structure
+ */
+interface SdkConfig {
+    /** Environment identifier */
+    environment: Environment;
+    /** Base64-encoded ML-KEM root public key */
+    mlKemPublicKey: string;
+    /** Configuration version */
+    version: string;
+}
+/**
+ * Configuration validation result
+ */
+interface ConfigValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+
+/**
+ * Configuration loader for T3n SDK
+ *
+ * This module provides configuration validation utilities.
+ * All environment keys are included in the bundle, and runtime selection is done via setEnvironment().
+ */
+
+/**
+ * Validate SDK configuration
+ */
+declare function validateConfig(config: unknown): ConfigValidationResult;
+
+/**
+ * Configuration entry point for T3n SDK
+ *
+ * This module imports all environment keys as base64 strings. All keys are included
+ * in the bundle, and the active key is selected at runtime via setEnvironment().
+ *
+ * Runtime key selection:
+ * - All keys (local, staging, production, test) are included in the bundle
+ * - Default environment is "production"
+ * - Use setEnvironment(env) to change the active key at runtime
+ *
+ * Binary files are converted to base64 strings at build time by the rollup binary plugin.
+ * In development mode (when running with tsx), files are read from the filesystem.
+ */
+
+/**
+ * Set the active environment for key selection
+ *
+ * This function allows engineers to configure which ML-KEM public key
+ * should be used at runtime. All keys are included in the bundle, so
+ * switching environments doesn't require rebuilding.
+ *
+ * @param env - The environment identifier (local, staging, production, or test)
+ * @throws Error if the environment is invalid
+ *
+ * @example
+ * ```typescript
+ * import { setEnvironment } from '@terminal3/t3n-sdk';
+ *
+ * // Use staging environment
+ * setEnvironment('staging');
+ * ```
+ */
+declare function setEnvironment(env: Environment): void;
+/**
+ * Get the current environment identifier
+ *
+ * Returns the currently active environment, which defaults to "production".
+ * Use setEnvironment() to change the active environment.
+ *
+ * @returns The current environment identifier
+ */
+declare function getEnvironment(): Environment;
+/**
+ * Load configuration for the current environment
+ *
+ * Returns the SDK configuration with the ML-KEM public key for the
+ * currently active environment (set via setEnvironment()).
+ *
+ * @returns A minimal SdkConfig object with the ML-KEM public key
+ */
+declare function loadConfig(): SdkConfig;
+/**
+ * Get the ML-KEM public key from the current configuration
+ * This is the main entry point used by handlers
+ *
+ * @returns The base64-encoded ML-KEM public key for the current environment
+ */
+declare function getMlKemPublicKey(): string;
+/**
+ * Get the current environment identifier
+ *
+ * @returns The current environment name
+ */
+declare function getEnvironmentName(): string;
+
+export { AuthMethod, AuthenticationError, HandshakeError, HttpTransport, LogLevel, MockTransport, RpcError, SessionStateError, SessionStatus, T3nClient, T3nError, WasmError, bytesToString, createDefaultHandlers, createEthAuthInput, createLogger, createMlKemPublicKeyHandler, createOidcAuthInput, createRandomHandler, decodeWasmErrorMessage, eth_get_address, extractWasmError, generateRandomString, generateUUID, getEnvironment, getEnvironmentName, getGlobalLogLevel, getLogger, getMlKemPublicKey, getScriptVersion, loadConfig, loadWasmComponent, metamask_get_address, metamask_sign, redactSecrets, redactSecretsFromJson, setEnvironment, setGlobalLogLevel, stringToBytes, validateConfig };
+export type { AuthInput, ClientAuth, ClientHandshake, ConfigValidationResult, Did, Environment, EthAuthInput, GuestToHostHandler, GuestToHostHandlers, HandshakeResult, JsonRpcRequest, JsonRpcResponse, Logger, OidcAuthInput, OidcCredentials, SdkConfig, SessionCrypto, SessionId, T3nClientConfig, Transport, WasmComponent, WasmNextResult };