@terminal3/t3n-sdk 0.7.0 → 0.10.0

package/dist/index.d.ts

@@ -1,106 +1,71 @@
 /**
- * WASM Component Interface - Mirrors the WIT specification exactly
+ * WASM Component Interface — async direct-call.
  *
- * 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.
+ * Mirrors `tee:session@1.0.0` WIT world. The SDK talks to the WASM
+ * only through these exports (plus host imports supplied at
+ * instantiation); all protocol glue lives inside the contract.
  */
-/**
- * Result type for WASM next() operations
- */
-interface WasmNextResult {
-    state: Uint8Array;
-    request: Uint8Array;
+interface ClientSessionKeys {
+    /** `encrypt_key || decrypt_key`, 64 bytes. */
+    blob: Uint8Array;
+    sid: Uint8Array;
+}
+interface HandshakeOutcome {
+    keys: ClientSessionKeys;
+    authenticated: boolean;
+    did?: string;
+    expirySec: bigint;
 }
-/**
- * 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>;
+    run(sid: Uint8Array, cookie: string | undefined): HandshakeOutcome;
+}
+interface AuthOutcome {
+    did: string;
+    cookie?: string;
 }
-/**
- * Client authentication operations - completely opaque byte arrays only
- */
 interface ClientAuth {
+    runEth(sessionKeys: Uint8Array, ethAddress: string, siweDomain: string | undefined, siweUrl: string | undefined, siweChainId: bigint | undefined): AuthOutcome;
     /**
-     * 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
+     * Run the full OIDC flow in one call. The contract drives both
+     * server round-trips and invokes the SDK's `getIdToken(provider,
+     * nonce)` host import in between to obtain the IdP-signed token.
      */
-    finish(state: Uint8Array): Promise<Uint8Array>;
+    runOidc(sessionKeys: Uint8Array, provider: string): AuthOutcome;
 }
-/**
- * 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>;
+interface ServerSessionKeys {
+    c2s: Uint8Array;
+    s2c: Uint8Array;
+    sid: Uint8Array;
+}
+interface ServerOutcome {
+    keys: ServerSessionKeys;
+    authenticated: boolean;
+    did?: string;
+    expirySec: bigint;
+    refreshedCookie?: string;
+}
+interface ServerHandshake {
+    run(sid: Uint8Array, ciphertext: Uint8Array, cookieValue: string | undefined): ServerOutcome;
 }
-/**
- * Session encryption/decryption operations - completely opaque byte arrays only
- */
 interface SessionCrypto {
-    /**
-     * Encrypt plaintext using session
-     * @param session - Session state (opaque bytes)
-     * @param plaintext - Data to encrypt
-     * @returns Promise with encrypted bytes
-     */
-    encrypt(session: 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>;
+    encrypt(keys: Uint8Array, plaintext: Uint8Array): Uint8Array;
+    decrypt(keys: Uint8Array, ciphertext: Uint8Array): 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 Validation {
+    authenticated: boolean;
+    did?: string;
+    exp: bigint;
+}
+interface CookieIface {
+    validate(cookieValue: string, teeAddress: Uint8Array, nowSec: bigint): Validation;
+}
+/** Fully instantiated session component. */
 interface WasmComponent {
-    /** Client handshake operations */
-    flow: {
-        handshake: ClientHandshake;
-        auth: ClientAuth;
-        execute: ClientExecute;
-    };
-    session: SessionCrypto;
+    clientHandshake: ClientHandshake;
+    clientAuth: ClientAuth;
+    serverHandshake: ServerHandshake;
+    sessionCrypto: SessionCrypto;
+    cookie: CookieIface;
 }
 
 /**
@@ -207,38 +172,75 @@ declare function createLogger(level?: LogLevel): Logger;
 declare function getLogger(): Logger;
 
 /**
- * WASM Component Loader
+ * WASM Component Loader — async direct-call shape.
+ *
+ * Loads the `tee:session@1.0.0` jco-transpiled component. Host
+ * imports (`host:session-interfaces/*`) are supplied at
+ * instantiation; the caller can override any of them via
+ * `WasmLoadConfig.hostImports` to plug a custom KEM public-key
+ * source, ETH signer, etc. Defaults cover the common case for the
+ * browser SDK:
  *
- * 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.
+ *   - `entropy.random`:        WebCrypto `getRandomValues`
+ *   - `kem.mlKemPublicKey`:    HTTP fetch of /pubkey (caller sets URL)
+ *   - `kem.decapsulate`:       server-only; client-side stub returns error
+ *   - `eth-signer.eth-sign`:   injected wallet (window.ethereum) if present
+ *   - `session-ops.now-ms`:    Date.now()
+ *   - `session-ops.tee-address`, `set-cookie`: caller-supplied or stubs
  */
 
+/**
+ * Host imports supplied at WASM instantiation. Any subset may be
+ * overridden by the caller; unset ones fall back to a safe default
+ * (or an error stub for server-only methods like `decapsulate`).
+ */
+interface SessionHostImports {
+    /** Fetch the server's ML-KEM public key (client-side). */
+    mlKemPublicKey?: () => Uint8Array | Promise<Uint8Array>;
+    /** CSPRNG. Defaults to WebCrypto `getRandomValues`. */
+    random?: (len: number) => Uint8Array;
+    /** EIP-191 / SIWE signer. Defaults to error (caller must supply). */
+    ethSign?: (message: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+    /**
+     * OIDC user-interaction callback. The contract supplies the
+     * server-bound `nonce`; the SDK consumer runs whatever popup /
+     * redirect flow is appropriate for `provider` and returns the
+     * IdP-signed `id_token`. Defaults to error (caller must supply
+     * when using OIDC auth).
+     */
+    getIdToken?: (provider: string, nonce: string) => string | Promise<string>;
+    /** Current time in ms. Defaults to Date.now() (as bigint). */
+    nowMs?: () => bigint;
+    /** TEE address — server-only; client stub returns 20 zero bytes. */
+    teeAddress?: () => Uint8Array;
+    /** Called when the guest emits a refreshed cookie. */
+    setCookie?: (value: string) => void;
+    /**
+     * HTTP transport the contract uses to POST JSON-RPC requests. The
+     * SDK wires this to its `Transport` under the hood — the contract
+     * supplies the method name and params bytes; the SDK layers on the
+     * Session-Id header, JSON-RPC envelope, and returns the raw result
+     * bytes.
+     */
+    postRpc?: (method: string, sessionId: string, params: string) => string | Promise<string>;
+}
 /**
  * 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, unknown>;
     /** Optional logger instance - if not provided, uses global default */
     logger?: Logger;
+    /** Overrides for the host-import functions. */
+    hostImports?: SessionHostImports;
 }
 /**
- * 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
+ * Load and initialize the T3n WASM component (async direct-call).
  *
- * @example
- * ```typescript
- * const wasmComponent = await loadWasmComponent({
- *   wasmPath: '/path/to/t3n.wasm'
- * });
- * ```
+ * The caller normally only needs to override `mlKemPublicKey` (to
+ * point at the node URL) and `ethSign` (to bridge to the browser
+ * wallet). All other imports have sensible defaults.
  */
 declare function loadWasmComponent(config?: WasmLoadConfig): Promise<WasmComponent>;
 
@@ -280,14 +282,15 @@ declare enum AuthMethod {
 /**
  * OIDC credentials interface.
  *
- * The TEE generates a session-binding nonce that must be included in
- * the Google authorization URL (`&nonce=…`). The `getIdToken` callback
- * receives this nonce and must return the `id_token` JWT obtained
- * from the OIDC provider with the nonce baked into its claims.
+ * The TEE generates a session-binding nonce; the user-interaction
+ * step is wired at WASM load time via `hostImports.getIdToken`
+ * (see `loadWasmComponent`), mirroring how `hostImports.ethSign`
+ * supplies wallet access. The contract calls `getIdToken(provider,
+ * nonce)` from inside `runOidc` and feeds the returned `id_token`
+ * to the server.
  */
 interface OidcCredentials {
     provider: string;
-    getIdToken: (nonce: string) => Promise<string>;
 }
 /**
  * Base authentication input with method discriminator
@@ -319,47 +322,6 @@ type AuthInput = EthAuthInput | OidcAuthInput;
 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. The exact shape of `requestData` depends on the specific
- * handler — see `GuestToHostHandlers` below for the per-handler shapes.
- * The wrapper layer in `T3nClient.handleGuestToHost` parses the JSON
- * envelope and calls the matching handler with the parsed data, so
- * each handler's implementation should narrow `requestData` to its
- * own expected shape.
- */
-type GuestToHostHandler = (requestData: Record<string, unknown>) => 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
  *
@@ -478,7 +440,7 @@ declare class MockTransport implements Transport {
 interface T3nClientConfig {
     /** Base URL of the T3n node (used if transport not provided) */
     baseUrl?: string;
-    /** WASM component instance for cryptographic operations */
+    /** WASM component instance (async direct-call — `tee:session@1.0.0`). */
     wasmComponent: WasmComponent;
     /** Optional transport layer - if not provided, uses HttpTransport with baseUrl */
     transport?: Transport;
@@ -488,171 +450,90 @@ interface T3nClientConfig {
     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.
-     */
+    /** Log level for this client instance. */
     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;
+    /**
+     * Optional signer bridge used by `authenticate()` for the ETH
+     * (SIWE) flow. Given the SIWE message bytes, the callback must
+     * produce a 65-byte `(r || s || v)` signature over the EIP-191
+     * personal-sign digest — matching `cryptography::ecdsa::eth`
+     * recovery on the node. A convenience wrapper for raw-private-key
+     * signing is planned for the follow-up commit that lands full
+     * ETH auth support.
+     */
+    ethSign?: (message: Uint8Array) => Promise<Uint8Array>;
+    /**
+     * Ethereum address (0x-prefixed, 20 bytes hex) of the user
+     * authenticating. Required by `authenticate()` for the ETH flow —
+     * the server recovers the signer from the SIWE message and
+     * compares to this address.
+     */
+    ethAddress?: string;
+    /**
+     * SIWE domain / URI / chain-id used in the message the SDK builds.
+     * Matches `SiwePolicy` on the server — the server's allowlist
+     * policy (if configured in NodeConfig) only accepts matching
+     * values. Defaults: domain `"localhost"`, URL `"https://trinity.io"`,
+     * chain ID `1` (Ethereum mainnet).
+     */
+    siweDomain?: string;
+    siweUrl?: string;
+    siweChainId?: number;
 }
 
 /**
- * T3n Client - Main SDK class
+ * T3n Client — thin host-function provider + WASM sequencer.
+ *
+ * The SDK communicates with the session contract strictly through
+ * WIT:
+ *   - Calls `clientHandshake.run(sid)` — contract handles ML-KEM
+ *     encapsulation, HKDF, POSTs via `host.transport.postRpc`,
+ *     derives session keys, returns them.
+ *   - Calls `clientAuth.runEth(keys, address, ...)` — contract
+ *     builds the SIWE message, signs via `host.eth-signer.ethSign`,
+ *     POSTs + parses the Finish response, returns the DID.
+ *   - For `execute()`, the SDK just encrypts the JSON-RPC payload
+ *     via `sessionCrypto.encrypt` and POSTs it through its transport.
  *
- * Provides a simple interface for establishing secure sessions with T3n nodes.
- * All cryptographic complexity is handled in WASM components.
+ * No SIWE building, no HKDF, no hex/base64 shuffling, no wire
+ * envelopes outside the contract. The contract is the single source
+ * of protocol truth.
  */
 
-/**
- * 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 sessionKeys;
     private did;
-    private handshakeResult;
     constructor(config: T3nClientConfig);
-    /**
-     * Start the handshake process with the T3n node
-     */
     handshake(): Promise<HandshakeResult>;
-    /**
-     * Authenticate with the T3n node.
-     *
-     * For OIDC, this runs a two-step nonce-bound flow:
-     * 1. Sends `InitOidcAuth` to server → receives session-binding nonce.
-     * 2. Calls `getIdToken(nonce)` callback so the app can include the
-     *    nonce in the Google authorization URL.
-     * 3. Sends `SubmitIdToken` with the nonce-bearing token → receives DID.
-     */
     authenticate(authInput: AuthInput): Promise<Did>;
-    /**
-     * OIDC two-step authentication with session-binding nonce.
-     *
-     * Bypasses the WASM client state machine and makes two encrypted
-     * RPC calls directly:
-     * 1. `InitOidcAuth { provider }` → server generates nonce → returns
-     *    `ProvideNonce { nonce }`.
-     * 2. App calls `getIdToken(nonce)` to obtain a nonce-bound `id_token`.
-     * 3. `SubmitIdToken { id_token }` → server verifies token + nonce →
-     *    returns `Finish { did }`.
-     */
-    private authenticateOidc;
-    /**
-     * Execute an action on the T3n node
-     */
     execute(payload: unknown): Promise<string>;
     getSessionId(): SessionId;
     getStatus(): SessionStatus;
     getDid(): Did | null;
+    isAuthenticated(): boolean;
     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
+     * Build the `host.transport.postRpc` callback the contract uses for
+     * all its HTTP round-trips. Must be passed into `loadWasmComponent`
+     * at instantiation time so the contract can POST during handshake
+     * and auth.
+     *
+     * `params` from the contract is the opaque JSON-RPC params (already
+     * encrypted where encryption is needed). The SDK wraps in the
+     * JSON-RPC envelope and injects the Session-Id header.
      */
-    private getSessionState;
+    buildPostRpcHostImport(): (method: string, _sessionIdFromGuest: string, params: string) => Promise<string>;
+    private sendRpcRaw;
 }
 
-/**
- * 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.
- */
-
-/**
- * Account — MetaMask handler accepts either a plain address string or an
- * object with an `address` field (for compatibility with various wallet
- * libraries).
- */
-type EthAccount = string | {
-    address: string;
-};
-/**
- * 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: EthAccount, 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 an MlKemPublicKey handler that lazily fetches the root public key
- * from `${baseUrl}/status` on first invocation and caches the encoded
- * response for subsequent calls.
- *
- * @param baseUrl - **Required**. The node URL whose `/status` endpoint should
- *                  serve the ML-KEM public key. Must be the same URL the
- *                  T3nClient is constructed with — otherwise the handshake
- *                  encrypts to one node and sends ciphertext to another.
- *
- *                  Was optional in 0.3.x, where omitting it caused the lazy
- *                  fetch to silently fall back to `NODE_URLS[currentEnv]` and
- *                  hit the wrong node. Three downstream consumers (demo.ts,
- *                  t3-apps dev wallet hooks, t3n-mcp session manager) all
- *                  hit this trap before we tightened the type.
- */
-declare function createMlKemPublicKeyHandler(baseUrl: string): 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.
- *
- * @param baseUrl - **Required**. Forwarded to `createMlKemPublicKeyHandler`
- *                  so the lazy /status fetch hits the right node.
- */
-declare function createDefaultHandlers(baseUrl: string): GuestToHostHandlers;
-
 /**
  * Cryptographic utilities for T3n SDK
  *
@@ -789,6 +670,65 @@ interface ConfigValidationResult {
     errors: string[];
 }
 
+/**
+ * TDX quote verifier backed by the Rust `signature` crate compiled to
+ * WASM. Full cryptographic verification: ECDSA P-256 attestation-key
+ * signature, PCK certificate chain walk to Intel's root CA, and
+ * report_data + RTMR comparison.
+ *
+ * The WASM bytes are inlined as base64 (see quote_verifier_bytes.ts)
+ * so the SDK works without bundler WASM plugins and without runtime
+ * asset URL resolution.
+ */
+interface QuoteVerifyResult {
+    valid: boolean;
+    error?: string;
+    rtmr3?: string;
+    report_data?: string;
+}
+interface PeerQuoteResult {
+    peer_id: string;
+    valid: boolean;
+    error?: string;
+    rtmr3?: string;
+}
+interface DkgVerifyResult {
+    valid: boolean;
+    results: PeerQuoteResult[];
+    valid_count: number;
+    expected_count: number;
+    error?: string;
+}
+/**
+ * Verify a single TDX attestation quote with full cryptographic verification.
+ *
+ * @param quoteB64 - Base64-encoded raw TDX v4 quote
+ * @param attestationMsgB64 - Base64-encoded attestation message
+ *   (for DKG: encaps_key || sorted_peer_id_bytes)
+ * @param expectedRtmr3B64 - Optional base64-encoded 48-byte RTMR3
+ * @returns Verification result with extracted measurements
+ */
+declare function verifyTdxQuote(quoteB64: string, attestationMsgB64: string, expectedRtmr3B64?: string): Promise<QuoteVerifyResult>;
+/**
+ * Verify a full DKG attestation bundle: multiple TDX quotes from all
+ * participating nodes, plus the binding between the quotes and the
+ * ML-KEM encapsulation key. Checks:
+ *   1. attestationMsg starts with encapsKey (server can't swap the key)
+ *   2. Every quote's ECDSA signature chains to Intel's SGX root CA
+ *   3. Every quote's report_data == keccak512(attestationMsg)
+ *   4. Optional RTMR3 pinning per quote
+ *
+ * @param encapsKeyB64 - Base64-encoded ML-KEM encapsulation key
+ *   (from `/status.encaps_key`)
+ * @param attestationMsgB64 - Base64-encoded raw attestation message
+ *   (from `/status.dkg_attestation.attestation_msg`)
+ * @param peerIds - Sorted array of base58 peer IDs
+ * @param quotes - Map of peer_id → base64-encoded TDX quote
+ * @param expectedRtmr3B64 - Optional base64-encoded 48-byte RTMR3
+ * @returns Per-peer verification results and overall validity
+ */
+declare function verifyDkgAttestation(encapsKeyB64: string, attestationMsgB64: string, peerIds: string[], quotes: Record<string, string>, expectedRtmr3B64?: string): Promise<DkgVerifyResult>;
+
 /**
  * Configuration validation for T3n SDK
  */
@@ -812,6 +752,18 @@ declare function validateConfig(config: unknown): ConfigValidationResult;
  * or by passing `baseUrl` to `T3nClient`.
  */
 declare const NODE_URLS: Record<Environment, string>;
+/** DKG attestation bundle from the cluster. */
+interface DkgAttestation {
+    /** Sorted base58 peer IDs that participated in DKG. */
+    peer_ids: string[];
+    /** Per-node TDX quotes keyed by base58 peer ID (base64-encoded). */
+    quotes: Record<string, string>;
+    /**
+     * Base64-encoded raw attestation message: `encaps_key || sorted_peer_ids`.
+     * Each quote's `report_data` is `keccak512(attestation_msg)`.
+     */
+    attestation_msg: string;
+}
 /**
  * Set the active environment. Clears any previous URL override and the key
  * cache so the next fetch uses the new environment's default URL.
@@ -832,10 +784,30 @@ declare function setNodeUrl(url: string | null): void;
 /** Resolve the active node URL: explicit `baseUrl` > override > env default. */
 declare function getNodeUrl(baseUrl?: string): string;
 /**
- * Fetch the ML-KEM root public key from `${nodeUrl}/status`. Cached per URL.
- * The node must be in the `Ready` phase and expose `encaps_key`.
+ * Fetch the ML-KEM root public key from `${nodeUrl}/status`. Cached
+ * per URL because the key is stable for the cluster's lifetime (a
+ * new DKG means a full redeploy; callers clear the cache via
+ * `clearKeyCache()` or `setNodeUrl()` in that case).
+ *
+ * Returns only the base64-encoded key. For the DKG attestation
+ * bundle (which changes over time as peer quotes replicate via
+ * Raft), call `fetchDkgAttestation()` \u2014 that path is
+ * intentionally uncached.
  */
 declare function fetchMlKemPublicKey(baseUrl?: string): Promise<string>;
+/**
+ * Fetch the DKG attestation bundle from `${nodeUrl}/status`. Never
+ * cached \u2014 peer quotes are written to consensus KV asynchronously
+ * during cluster bootstrap, so early reads may see a subset of the
+ * expected quotes. Caching would pin an incomplete bundle and cause
+ * spurious `valid_count < expected_count` failures in
+ * `verifyDkgAttestation()` for the whole process lifetime.
+ *
+ * Returns `undefined` when the node has not yet published an
+ * attestation (e.g. still bootstrapping, or running with a mock
+ * signer where attestation is skipped by design).
+ */
+declare function fetchDkgAttestation(baseUrl?: string): Promise<DkgAttestation | undefined>;
 /** Clear the cached ML-KEM public keys. Useful in tests. */
 declare function clearKeyCache(): void;
 /**
@@ -845,5 +817,5 @@ declare function clearKeyCache(): void;
  */
 declare function loadConfig(baseUrl?: string): SdkConfig;
 
-export { AuthMethod, AuthenticationError, HandshakeError, HttpTransport, LogLevel, MockTransport, NODE_URLS, RpcError, SessionStateError, SessionStatus, T3nClient, T3nError, WasmError, bytesToString, clearKeyCache, createDefaultHandlers, createEthAuthInput, createLogger, createMlKemPublicKeyHandler, createOidcAuthInput, createRandomHandler, decodeWasmErrorMessage, eth_get_address, extractWasmError, fetchMlKemPublicKey, generateRandomString, generateUUID, getEnvironment, getEnvironmentName, getGlobalLogLevel, getLogger, getNodeUrl, getScriptVersion, loadConfig, loadWasmComponent, metamask_get_address, metamask_sign, redactSecrets, redactSecretsFromJson, setEnvironment, setGlobalLogLevel, setNodeUrl, 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 };
+export { AuthMethod, AuthenticationError, HandshakeError, HttpTransport, LogLevel, MockTransport, NODE_URLS, RpcError, SessionStateError, SessionStatus, T3nClient, T3nError, WasmError, bytesToString, clearKeyCache, createEthAuthInput, createLogger, createOidcAuthInput, decodeWasmErrorMessage, extractWasmError, fetchDkgAttestation, fetchMlKemPublicKey, generateRandomString, generateUUID, getEnvironment, getEnvironmentName, getGlobalLogLevel, getLogger, getNodeUrl, getScriptVersion, loadConfig, loadWasmComponent, redactSecrets, redactSecretsFromJson, setEnvironment, setGlobalLogLevel, setNodeUrl, stringToBytes, validateConfig, verifyDkgAttestation, verifyTdxQuote };
+export type { AuthInput, AuthOutcome, ClientAuth, ClientHandshake, ClientSessionKeys, ConfigValidationResult, CookieIface, Did, DkgAttestation, DkgVerifyResult, Environment, EthAuthInput, HandshakeOutcome, HandshakeResult, JsonRpcRequest, JsonRpcResponse, Logger, OidcAuthInput, OidcCredentials, PeerQuoteResult, QuoteVerifyResult, SdkConfig, ServerHandshake, ServerOutcome, ServerSessionKeys, SessionCrypto, SessionHostImports, SessionId, T3nClientConfig, Transport, Validation, WasmComponent };