@dynamic-labs-wallet/forward-mpc-shared 0.2.0 → 0.3.0

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import * as fp_ts_lib_Either from 'fp-ts/lib/Either';
 import * as io_ts from 'io-ts';
-import { TypeOf, Type } from 'io-ts';
+import { Type, TypeOf } from 'io-ts';
 import { SigningAlgorithm } from '@dynamic-labs-wallet/core';
 import { either } from 'fp-ts';
 
@@ -73,6 +73,267 @@ declare abstract class BaseMessage<TRuntime = any, TWire = any> implements IMess
     getData(): TRuntime;
 }
 
+declare const Uint8ArrayCodec: Type<Uint8Array<ArrayBufferLike>, string, unknown>;
+
+declare const Uint32ArrayCodec: Type<Uint32Array<ArrayBufferLike>, string, unknown>;
+
+/**
+ * Generic encrypted payload structure for secure transmission
+ * Contains HKDF salt and AES-256-GCM encrypted payload
+ * Used for keyshares, keygen init, and other encrypted data
+ */
+declare const EncryptedPayloadCodec: io_ts.TypeC<{
+    salt: io_ts.Type<Uint8Array<ArrayBufferLike>, string, unknown>;
+    encryptedPayload: io_ts.Type<Uint8Array<ArrayBufferLike>, string, unknown>;
+}>;
+type EncryptedPayload = TypeOf<typeof EncryptedPayloadCodec>;
+
+/**
+ * Trace Context for request tracing
+ */
+interface TraceContext {
+    traceId?: string;
+    startTime?: number;
+}
+/**
+ * Trace Context Codec - optional by default (allows undefined)
+ */
+declare const TraceContextCodec: io_ts.UnionC<[io_ts.PartialC<{
+    traceId: io_ts.StringC;
+    startTime: io_ts.NumberC;
+}>, io_ts.UndefinedC]>;
+
+/**
+ * Optional String Codec - validates string or undefined
+ */
+declare const OptionalStringCodec: io_ts.UnionC<[io_ts.StringC, io_ts.UndefinedC]>;
+
+/**
+ * ReceiveKey Response Runtime Data
+ */
+interface ReceiveKeyResponseData {
+    keygenResult?: EncryptedPayload;
+    error?: WebSocketError;
+}
+/**
+ * ReceiveKey Response Wire Format
+ */
+interface ReceiveKeyResponseWire {
+    type: 'receiveKey_response';
+    version: 1;
+    keygenResult?: {
+        salt: string;
+        encryptedPayload: string;
+    };
+    error?: WebSocketError;
+}
+/**
+ * ReceiveKey Response Schema
+ */
+declare const ReceiveKeyResponseSchema: io_ts.Type<any, any, unknown>;
+type ReceiveKeyResponse = TypeOf<typeof ReceiveKeyResponseSchema>;
+/**
+ * ReceiveKey V1 Response Message Class
+ */
+declare const ReceiveKeyV1ResponseMessage: {
+    new (data: ReceiveKeyResponseData): {
+        readonly type: "receiveKey_response";
+        readonly version: 1;
+        encode(): ReceiveKeyResponseWire;
+        readonly data: ReceiveKeyResponseData;
+        getData(): ReceiveKeyResponseData;
+    };
+    readonly MESSAGE_TYPE: "receiveKey_response";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: io_ts.Type<any, any, unknown>;
+    decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+        readonly type: "receiveKey_response";
+        readonly version: 1;
+        encode(): ReceiveKeyResponseWire;
+        readonly data: ReceiveKeyResponseData;
+        getData(): ReceiveKeyResponseData;
+    }>;
+};
+
+/**
+ * ReceiveKey Request Runtime Data
+ * Used for ExportableEd25519 key generation where one party receives the key
+ */
+interface ReceiveKeyRequestData {
+    relayDomain: string;
+    signingAlgo: 'ed25519';
+    roomUuid: string;
+    numParties: number;
+    threshold: number;
+    keygenInit: EncryptedPayload;
+    keygenIds: string[];
+    userId?: string;
+    environmentId?: string;
+    traceContext?: TraceContext;
+}
+/**
+ * ReceiveKey Request Wire Format
+ */
+interface ReceiveKeyRequestWire {
+    type: 'receiveKey';
+    version: 1;
+    relayDomain: string;
+    signingAlgo: 'ed25519';
+    roomUuid: string;
+    numParties: number;
+    threshold: number;
+    keygenInit: {
+        salt: string;
+        encryptedPayload: string;
+    };
+    keygenIds: string[];
+    userId?: string;
+    environmentId?: string;
+    traceContext?: TraceContext;
+}
+/**
+ * ReceiveKey V1 Request Schema
+ */
+declare const ReceiveKeyRequestSchema: io_ts.Type<any, any, unknown>;
+type ReceiveKeyRequest = TypeOf<typeof ReceiveKeyRequestSchema>;
+/**
+ * ReceiveKey V1 Request Message Class
+ * Represents a request to receive an exportable ED25519 key from another party
+ */
+declare const ReceiveKeyV1RequestMessage: {
+    new (data: ReceiveKeyRequestData): {
+        readonly type: "receiveKey";
+        readonly version: 1;
+        encode(): ReceiveKeyRequestWire;
+        readonly data: ReceiveKeyRequestData;
+        getData(): ReceiveKeyRequestData;
+    };
+    readonly MESSAGE_TYPE: "receiveKey";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: io_ts.Type<any, any, unknown>;
+    decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+        readonly type: "receiveKey";
+        readonly version: 1;
+        encode(): ReceiveKeyRequestWire;
+        readonly data: ReceiveKeyRequestData;
+        getData(): ReceiveKeyRequestData;
+    }>;
+};
+
+/**
+ * Keygen Response Runtime Data
+ */
+interface KeygenResponseData {
+    keygenResult?: EncryptedPayload;
+    error?: WebSocketError;
+}
+/**
+ * Keygen Response Wire Format
+ */
+interface KeygenResponseWire {
+    type: 'keygen_response';
+    version: 1;
+    keygenResult?: {
+        salt: string;
+        encryptedPayload: string;
+    };
+    error?: WebSocketError;
+}
+/**
+ * Keygen Response Schema
+ */
+declare const KeygenResponseSchema: io_ts.Type<any, any, unknown>;
+type KeygenResponse = TypeOf<typeof KeygenResponseSchema>;
+/**
+ * Keygen V1 Response Message Class
+ */
+declare const KeygenV1ResponseMessage: {
+    new (data: KeygenResponseData): {
+        readonly type: "keygen_response";
+        readonly version: 1;
+        encode(): KeygenResponseWire;
+        readonly data: KeygenResponseData;
+        getData(): KeygenResponseData;
+    };
+    readonly MESSAGE_TYPE: "keygen_response";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: io_ts.Type<any, any, unknown>;
+    decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+        readonly type: "keygen_response";
+        readonly version: 1;
+        encode(): KeygenResponseWire;
+        readonly data: KeygenResponseData;
+        getData(): KeygenResponseData;
+    }>;
+};
+
+/**
+ * Keygen Request Runtime Data
+ * Supports ECDSA and BIP340 algorithms only
+ * Note: ED25519 uses separate SampleKeyV1Request/ReceiveKeyV1Request messages
+ */
+interface KeygenRequestData {
+    relayDomain: string;
+    signingAlgo: SigningAlgorithm;
+    roomUuid: string;
+    numParties: number;
+    threshold: number;
+    keygenInit: EncryptedPayload;
+    keygenIds: string[];
+    userId?: string;
+    environmentId?: string;
+    traceContext?: TraceContext;
+}
+/**
+ * Keygen Request Wire Format
+ * Supports ECDSA and BIP340 algorithms only
+ * Note: ED25519 uses separate 'sampleKey'/'receiveKey' message types
+ */
+interface KeygenRequestWire {
+    type: 'keygen';
+    version: 1;
+    relayDomain: string;
+    signingAlgo: SigningAlgorithm;
+    roomUuid: string;
+    numParties: number;
+    threshold: number;
+    keygenInit: {
+        salt: string;
+        encryptedPayload: string;
+    };
+    keygenIds: string[];
+    userId?: string;
+    environmentId?: string;
+    traceContext?: TraceContext;
+}
+/**
+ * Keygen Request Schema
+ */
+declare const KeygenRequestSchema: io_ts.Type<any, any, unknown>;
+type KeygenRequest = TypeOf<typeof KeygenRequestSchema>;
+/**
+ * Keygen V1 Request Message Class
+ */
+declare const KeygenV1RequestMessage: {
+    new (data: KeygenRequestData): {
+        readonly type: "keygen";
+        readonly version: 1;
+        encode(): unknown;
+        readonly data: KeygenRequestData;
+        getData(): KeygenRequestData;
+    };
+    readonly MESSAGE_TYPE: "keygen";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: io_ts.Type<any, any, unknown>;
+    decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+        readonly type: "keygen";
+        readonly version: 1;
+        encode(): unknown;
+        readonly data: KeygenRequestData;
+        getData(): KeygenRequestData;
+    }>;
+};
+
 /**
  * Connection Acknowledgment Response Runtime Data
  */
@@ -204,40 +465,6 @@ declare const SignMessageV1ResponseMessage: {
     }>;
 };
 
-declare const Uint8ArrayCodec: Type<Uint8Array<ArrayBufferLike>, string, unknown>;
-
-declare const Uint32ArrayCodec: Type<Uint32Array<ArrayBufferLike>, string, unknown>;
-
-/**
- * Encrypted keyshare structure for secure transmission
- * Contains HKDF salt and AES-256-GCM encrypted payload
- */
-declare const EncryptedKeyshareCodec: io_ts.TypeC<{
-    salt: io_ts.Type<Uint8Array<ArrayBufferLike>, string, unknown>;
-    encryptedPayload: io_ts.Type<Uint8Array<ArrayBufferLike>, string, unknown>;
-}>;
-type EncryptedKeyshare = TypeOf<typeof EncryptedKeyshareCodec>;
-
-/**
- * Trace Context for request tracing
- */
-interface TraceContext {
-    traceId?: string;
-    startTime?: number;
-}
-/**
- * Trace Context Codec - optional by default (allows undefined)
- */
-declare const TraceContextCodec: io_ts.UnionC<[io_ts.PartialC<{
-    traceId: io_ts.StringC;
-    startTime: io_ts.NumberC;
-}>, io_ts.UndefinedC]>;
-
-/**
- * Optional String Codec - validates string or undefined
- */
-declare const OptionalStringCodec: io_ts.UnionC<[io_ts.StringC, io_ts.UndefinedC]>;
-
 /**
  * Base secret share data (what gets encrypted)
  */
@@ -279,6 +506,22 @@ declare abstract class BaseSigningAlgorithm implements ISigningAlgorithm {
     abstract processSignResult(result: any): Uint8Array;
 }
 
+/**
+ * ED25519 signing algorithm
+ *
+ * IMPORTANT: This uses Dynamic SDK's ExportableEd25519 implementation under the hood.
+ * When you call getMPCSignatureScheme(SigningAlgorithm.ED25519), you get ExportableEd25519.
+ *
+ * Key characteristics:
+ * - Uses sampleKey/receiveKey for keygen (one party samples, other receives)
+ * - Can export private keys
+ *
+ * DERIVATION PATH CAVEAT:
+ * - The schema accepts derivationPath for backwards compatibility
+ * - However, ExportableEd25519 does NOT support BIP32/BIP44 derivation in signing
+ * - If derivationPath is provided, it may be ignored or cause errors
+ * - See: https://docs.sodot.dev/sodot-docs/mpc-api/key-management/exportable-ed25519-keys
+ */
 interface Ed25519SignMessageSchema {
     signingAlgo: 'ed25519';
     derivationPath?: Uint32Array;
@@ -337,6 +580,9 @@ declare class EcdsaSigningAlgorithm extends BaseSigningAlgorithm {
 /**
  * 🎯 SINGLE SOURCE OF TRUTH - Add new algorithms here and everything else is automatic!
  * This is the ONLY place you need to add new signing algorithms
+ *
+ * Maps 1:1 with Dynamic SDK's SigningAlgorithm enum (ECDSA, ED25519, BIP340)
+ * NOTE: ED25519 uses ExportableEd25519 implementation (no derivation support)
  */
 declare const SIGNING_ALGORITHM_CLASSES: {
     readonly ed25519: typeof Ed25519SigningAlgorithm;
@@ -438,7 +684,7 @@ interface SignMessageRequestData {
     hashAlgo?: HashAlgorithm;
     derivationPath?: Uint32Array;
     tweak?: Uint8Array;
-    keyshare: EncryptedKeyshare;
+    keyshare: EncryptedPayload;
     message: Uint8Array | string;
     roomUuid: string;
     userId?: string;
@@ -704,6 +950,78 @@ declare class MessageRegistry {
             readonly data: ConnectionAckResponseData;
             getData(): ConnectionAckResponseData;
         }>;
+    } | {
+        new (data: KeygenRequestData): {
+            readonly type: "keygen";
+            readonly version: 1;
+            encode(): unknown;
+            readonly data: KeygenRequestData;
+            getData(): KeygenRequestData;
+        };
+        readonly MESSAGE_TYPE: "keygen";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: io_ts.Type<any, any, unknown>;
+        decode(wireData: unknown): either.Either<io_ts.Errors, {
+            readonly type: "keygen";
+            readonly version: 1;
+            encode(): unknown;
+            readonly data: KeygenRequestData;
+            getData(): KeygenRequestData;
+        }>;
+    } | {
+        new (data: KeygenResponseData): {
+            readonly type: "keygen_response";
+            readonly version: 1;
+            encode(): KeygenResponseWire;
+            readonly data: KeygenResponseData;
+            getData(): KeygenResponseData;
+        };
+        readonly MESSAGE_TYPE: "keygen_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: io_ts.Type<any, any, unknown>;
+        decode(wireData: unknown): either.Either<io_ts.Errors, {
+            readonly type: "keygen_response";
+            readonly version: 1;
+            encode(): KeygenResponseWire;
+            readonly data: KeygenResponseData;
+            getData(): KeygenResponseData;
+        }>;
+    } | {
+        new (data: ReceiveKeyRequestData): {
+            readonly type: "receiveKey";
+            readonly version: 1;
+            encode(): ReceiveKeyRequestWire;
+            readonly data: ReceiveKeyRequestData;
+            getData(): ReceiveKeyRequestData;
+        };
+        readonly MESSAGE_TYPE: "receiveKey";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: io_ts.Type<any, any, unknown>;
+        decode(wireData: unknown): either.Either<io_ts.Errors, {
+            readonly type: "receiveKey";
+            readonly version: 1;
+            encode(): ReceiveKeyRequestWire;
+            readonly data: ReceiveKeyRequestData;
+            getData(): ReceiveKeyRequestData;
+        }>;
+    } | {
+        new (data: ReceiveKeyResponseData): {
+            readonly type: "receiveKey_response";
+            readonly version: 1;
+            encode(): ReceiveKeyResponseWire;
+            readonly data: ReceiveKeyResponseData;
+            getData(): ReceiveKeyResponseData;
+        };
+        readonly MESSAGE_TYPE: "receiveKey_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: io_ts.Type<any, any, unknown>;
+        decode(wireData: unknown): either.Either<io_ts.Errors, {
+            readonly type: "receiveKey_response";
+            readonly version: 1;
+            encode(): ReceiveKeyResponseWire;
+            readonly data: ReceiveKeyResponseData;
+            getData(): ReceiveKeyResponseData;
+        }>;
     } | undefined;
     /**
      * Create a message instance from wire data (using derived message classes)
@@ -839,6 +1157,82 @@ declare const ALL_MESSAGE_CLASSES: {
             getData(): ConnectionAckResponseData;
         }>;
     };
+    readonly 'keygen@1': {
+        new (data: KeygenRequestData): {
+            readonly type: "keygen";
+            readonly version: 1;
+            encode(): unknown;
+            readonly data: KeygenRequestData;
+            getData(): KeygenRequestData;
+        };
+        readonly MESSAGE_TYPE: "keygen";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: io_ts.Type<any, any, unknown>;
+        decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+            readonly type: "keygen";
+            readonly version: 1;
+            encode(): unknown;
+            readonly data: KeygenRequestData;
+            getData(): KeygenRequestData;
+        }>;
+    };
+    readonly 'keygen_response@1': {
+        new (data: KeygenResponseData): {
+            readonly type: "keygen_response";
+            readonly version: 1;
+            encode(): KeygenResponseWire;
+            readonly data: KeygenResponseData;
+            getData(): KeygenResponseData;
+        };
+        readonly MESSAGE_TYPE: "keygen_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: io_ts.Type<any, any, unknown>;
+        decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+            readonly type: "keygen_response";
+            readonly version: 1;
+            encode(): KeygenResponseWire;
+            readonly data: KeygenResponseData;
+            getData(): KeygenResponseData;
+        }>;
+    };
+    readonly 'receiveKey@1': {
+        new (data: ReceiveKeyRequestData): {
+            readonly type: "receiveKey";
+            readonly version: 1;
+            encode(): ReceiveKeyRequestWire;
+            readonly data: ReceiveKeyRequestData;
+            getData(): ReceiveKeyRequestData;
+        };
+        readonly MESSAGE_TYPE: "receiveKey";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: io_ts.Type<any, any, unknown>;
+        decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+            readonly type: "receiveKey";
+            readonly version: 1;
+            encode(): ReceiveKeyRequestWire;
+            readonly data: ReceiveKeyRequestData;
+            getData(): ReceiveKeyRequestData;
+        }>;
+    };
+    readonly 'receiveKey_response@1': {
+        new (data: ReceiveKeyResponseData): {
+            readonly type: "receiveKey_response";
+            readonly version: 1;
+            encode(): ReceiveKeyResponseWire;
+            readonly data: ReceiveKeyResponseData;
+            getData(): ReceiveKeyResponseData;
+        };
+        readonly MESSAGE_TYPE: "receiveKey_response";
+        readonly MESSAGE_VERSION: 1;
+        readonly schema: io_ts.Type<any, any, unknown>;
+        decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+            readonly type: "receiveKey_response";
+            readonly version: 1;
+            encode(): ReceiveKeyResponseWire;
+            readonly data: ReceiveKeyResponseData;
+            getData(): ReceiveKeyResponseData;
+        }>;
+    };
 };
 /**
  * Derive message type union from classes
@@ -959,6 +1353,78 @@ declare function getMessageClass(type: string, version: number): {
         readonly data: ConnectionAckResponseData;
         getData(): ConnectionAckResponseData;
     }>;
+} | {
+    new (data: KeygenRequestData): {
+        readonly type: "keygen";
+        readonly version: 1;
+        encode(): unknown;
+        readonly data: KeygenRequestData;
+        getData(): KeygenRequestData;
+    };
+    readonly MESSAGE_TYPE: "keygen";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: io_ts.Type<any, any, unknown>;
+    decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+        readonly type: "keygen";
+        readonly version: 1;
+        encode(): unknown;
+        readonly data: KeygenRequestData;
+        getData(): KeygenRequestData;
+    }>;
+} | {
+    new (data: KeygenResponseData): {
+        readonly type: "keygen_response";
+        readonly version: 1;
+        encode(): KeygenResponseWire;
+        readonly data: KeygenResponseData;
+        getData(): KeygenResponseData;
+    };
+    readonly MESSAGE_TYPE: "keygen_response";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: io_ts.Type<any, any, unknown>;
+    decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+        readonly type: "keygen_response";
+        readonly version: 1;
+        encode(): KeygenResponseWire;
+        readonly data: KeygenResponseData;
+        getData(): KeygenResponseData;
+    }>;
+} | {
+    new (data: ReceiveKeyRequestData): {
+        readonly type: "receiveKey";
+        readonly version: 1;
+        encode(): ReceiveKeyRequestWire;
+        readonly data: ReceiveKeyRequestData;
+        getData(): ReceiveKeyRequestData;
+    };
+    readonly MESSAGE_TYPE: "receiveKey";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: io_ts.Type<any, any, unknown>;
+    decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+        readonly type: "receiveKey";
+        readonly version: 1;
+        encode(): ReceiveKeyRequestWire;
+        readonly data: ReceiveKeyRequestData;
+        getData(): ReceiveKeyRequestData;
+    }>;
+} | {
+    new (data: ReceiveKeyResponseData): {
+        readonly type: "receiveKey_response";
+        readonly version: 1;
+        encode(): ReceiveKeyResponseWire;
+        readonly data: ReceiveKeyResponseData;
+        getData(): ReceiveKeyResponseData;
+    };
+    readonly MESSAGE_TYPE: "receiveKey_response";
+    readonly MESSAGE_VERSION: 1;
+    readonly schema: io_ts.Type<any, any, unknown>;
+    decode(wireData: unknown): fp_ts_lib_Either.Either<io_ts.Errors, {
+        readonly type: "receiveKey_response";
+        readonly version: 1;
+        encode(): ReceiveKeyResponseWire;
+        readonly data: ReceiveKeyResponseData;
+        getData(): ReceiveKeyResponseData;
+    }>;
 };
 /**
  * Type-safe check if message type exists
@@ -995,6 +1461,15 @@ declare const AES_256_GCM_KEY_SIZE = 32;
 declare const AES_256_GCM_NONCE_SIZE = 12;
 declare const AES_256_GCM_TAG_SIZE = 16;
 declare const HKDF_SALT_SIZE = 32;
+/**
+ * Encryption purpose enum to prevent typos and ensure consistency
+ */
+declare enum EncryptionPurpose {
+    KEYSHARE = "keyshare",
+    KEYGEN_INIT = "keygen_init",
+    KEYGEN_RESULT = "keygen_result",
+    TEST = "test"
+}
 /**
  * Derive AES-256 key from ML-KEM shared secret using HKDF
  * Following NIST SP 800-56C recommendations
@@ -1003,7 +1478,50 @@ declare function deriveAESKey(sharedSecret: Uint8Array, salt: Uint8Array, info:
 /**
  * Create standardized context info for HKDF
  */
-declare function createKeyDerivationInfo(purpose: 'keyshare' | 'hmac', connectionId: string, version?: number): string;
+declare function createKeyDerivationInfo(purpose: EncryptionPurpose, connectionId: string, version?: number): string;
+
+/**
+ * Options for encrypting a payload
+ */
+interface EncryptPayloadOptions {
+    /** The data to encrypt (will be JSON stringified) */
+    payload: unknown;
+    /** ML-KEM shared secret from handshake (min 32 bytes) */
+    sharedSecret: Uint8Array;
+    /** Unique connection identifier (non-empty) */
+    connectionId: string;
+    /** Purpose for HKDF context (prevents key reuse across contexts) */
+    purpose: EncryptionPurpose;
+}
+/**
+ * Generic payload encryption using AES-256-GCM with ML-KEM derived key
+ *
+ * @param options - Encryption options
+ * @returns Encrypted payload with salt and encrypted data
+ * @throws Error if inputs are invalid or encryption fails
+ */
+declare function encryptPayload(options: EncryptPayloadOptions): EncryptedPayload;
+/**
+ * Options for decrypting a payload
+ */
+interface DecryptPayloadOptions {
+    /** Encrypted payload with salt and encrypted data */
+    encrypted: EncryptedPayload;
+    /** ML-KEM shared secret from handshake (min 32 bytes) */
+    sharedSecret: Uint8Array;
+    /** Unique connection identifier (non-empty) */
+    connectionId: string;
+    /** Purpose for HKDF context (must match encryption) */
+    purpose: EncryptionPurpose;
+}
+/**
+ * Generic payload decryption using AES-256-GCM with ML-KEM derived key
+ *
+ * @param options - Decryption options
+ * @returns Decrypted and parsed JSON data
+ * @throws Error if inputs are invalid or decryption fails
+ */
+declare function decryptPayload<T = any>(options: DecryptPayloadOptions): T;
 
 /**
  * Encrypt keyshare using AES-256-GCM with ML-KEM derived key
@@ -1014,7 +1532,34 @@ declare function createKeyDerivationInfo(purpose: 'keyshare' | 'hmac', connectio
  * @param signingAlgorithm - Algorithm name for context
  * @returns Encrypted keyshare with salt and encrypted payload
  */
-declare function encryptKeyshare(keyshare: any, sharedSecret: Uint8Array, connectionId: string, signingAlgorithm: SigningAlgorithmName): Promise<EncryptedKeyshare>;
+declare function encryptKeyshare(keyshare: any, sharedSecret: Uint8Array, connectionId: string, signingAlgorithm: SigningAlgorithmName): EncryptedPayload;
+
+/**
+ * Encrypt keygen init data (keygenId + keygenSecret)
+ *
+ * @param keygenInit - The keygen init object with keygenId and keygenSecret
+ * @param sharedSecret - ML-KEM shared secret from handshake
+ * @param connectionId - Unique connection identifier
+ * @returns Encrypted keygen init with salt and encrypted payload
+ * @throws Error if keygenInit contains empty or invalid fields
+ */
+declare function encryptKeygenInit(keygenInit: {
+    keygenId: string;
+    keygenSecret: string;
+}, sharedSecret: Uint8Array, connectionId: string): EncryptedPayload;
+/**
+ * Decrypt keygen result (pubkey + secretShare)
+ *
+ * @param encrypted - Encrypted keygen result from server
+ * @param sharedSecret - ML-KEM shared secret from handshake
+ * @param connectionId - Unique connection identifier
+ * @returns Decrypted keygen result with pubkey and secretShare
+ * @throws Error if decrypted data is missing required fields or has invalid types
+ */
+declare function decryptKeygenResult(encrypted: EncryptedPayload, sharedSecret: Uint8Array, connectionId: string): {
+    pubkey: Uint8Array;
+    secretShare: string;
+};
 
 /**
  * Asserts that a value is defined (not null or undefined)
@@ -1055,4 +1600,4 @@ declare class SigningAlgorithmRegistry {
 }
 declare const signingAlgorithmRegistry: SigningAlgorithmRegistry;
 
-export { AES_256_GCM_KEY_SIZE, AES_256_GCM_NONCE_SIZE, AES_256_GCM_TAG_SIZE, ALGORITHMS, ALL_MESSAGE_CLASSES, ALL_MESSAGE_KEYS, ALL_SIGNING_ALGORITHM_NAMES, ALL_SIGNING_ALGORITHM_SCHEMA, type AllMessageTypes, type AllSigningAlgorithmSchemas, BIP340SigningAlgorithm, BaseMessage, BaseSigningAlgorithm, type BaseWebSocketMessage, type ConnectionAckRequest, type ConnectionAckRequestData, ConnectionAckRequestSchema, type ConnectionAckRequestWire, type ConnectionAckResponse, type ConnectionAckResponseData, ConnectionAckResponseSchema, type ConnectionAckResponseWire, ConnectionAckV1RequestMessage, ConnectionAckV1ResponseMessage, type DecryptedSecretShare, EcdsaSigningAlgorithm, Ed25519SigningAlgorithm, type EncryptedKeyshare, EncryptedKeyshareCodec, type ErrorResponse, HKDF_SALT_SIZE, type HandshakeRequest, type HandshakeRequestData, HandshakeRequestSchema, type HandshakeRequestWire, type HandshakeResponse, type HandshakeResponseData, HandshakeResponseSchema, type HandshakeResponseWire, HandshakeV1RequestMessage, HandshakeV1ResponseMessage, type HashAlgorithm, type IMessage, type ISigningAlgorithm, MessageRegistry, OptionalStringCodec, SIGNING_ALGORITHM_CLASSES, SIGNING_ALGORITHM_INSTANCES, type SecretShareData, type SignMessageRequest, type SignMessageRequestData, SignMessageRequestSchema, type SignMessageRequestWire, type SignMessageResponse, type SignMessageResponseData, SignMessageResponseSchema, type SignMessageResponseWire, SignMessageV1RequestMessage, SignMessageV1ResponseMessage, SignatureAlgoSchema, type SigningAlgorithmName, type SigningAlgorithmSchemaFor, type AllSigningAlgorithmSchemas as SigningAlgorithmSchemas, type TraceContext, TraceContextCodec, Uint32ArrayCodec, Uint8ArrayCodec, type WebSocketConnectionInfo, type WebSocketError, WebSocketErrorType, assertDefined, assertNotNull, createKeyDerivationInfo, createKeygenResultFromSecretShare, decapsulateMlKem768, deriveAESKey, encapsulateMlKem768, encryptKeyshare, fromDynamicSigningAlgorithm, generateMlKem768Keypair, getAllSupportedMessages, getDefined, getMessageClass, isValidMessageType, isValidSigningAlgorithm, messageRegistry, parseMessageKey, signingAlgorithmRegistry, toDynamicSigningAlgorithm };
+export { AES_256_GCM_KEY_SIZE, AES_256_GCM_NONCE_SIZE, AES_256_GCM_TAG_SIZE, ALGORITHMS, ALL_MESSAGE_CLASSES, ALL_MESSAGE_KEYS, ALL_SIGNING_ALGORITHM_NAMES, ALL_SIGNING_ALGORITHM_SCHEMA, type AllMessageTypes, type AllSigningAlgorithmSchemas, BIP340SigningAlgorithm, BaseMessage, BaseSigningAlgorithm, type BaseWebSocketMessage, type ConnectionAckRequest, type ConnectionAckRequestData, ConnectionAckRequestSchema, type ConnectionAckRequestWire, type ConnectionAckResponse, type ConnectionAckResponseData, ConnectionAckResponseSchema, type ConnectionAckResponseWire, ConnectionAckV1RequestMessage, ConnectionAckV1ResponseMessage, type DecryptPayloadOptions, type DecryptedSecretShare, EcdsaSigningAlgorithm, Ed25519SigningAlgorithm, type EncryptPayloadOptions, type EncryptedPayload, EncryptedPayloadCodec, EncryptionPurpose, type ErrorResponse, HKDF_SALT_SIZE, type HandshakeRequest, type HandshakeRequestData, HandshakeRequestSchema, type HandshakeRequestWire, type HandshakeResponse, type HandshakeResponseData, HandshakeResponseSchema, type HandshakeResponseWire, HandshakeV1RequestMessage, HandshakeV1ResponseMessage, type HashAlgorithm, type IMessage, type ISigningAlgorithm, type KeygenRequest, type KeygenRequestData, KeygenRequestSchema, type KeygenRequestWire, type KeygenResponse, type KeygenResponseData, KeygenResponseSchema, type KeygenResponseWire, KeygenV1RequestMessage, KeygenV1ResponseMessage, MessageRegistry, OptionalStringCodec, type ReceiveKeyRequest, type ReceiveKeyRequestData, ReceiveKeyRequestSchema, type ReceiveKeyRequestWire, type ReceiveKeyResponse, type ReceiveKeyResponseData, ReceiveKeyResponseSchema, type ReceiveKeyResponseWire, ReceiveKeyV1RequestMessage, ReceiveKeyV1ResponseMessage, SIGNING_ALGORITHM_CLASSES, SIGNING_ALGORITHM_INSTANCES, type SecretShareData, type SignMessageRequest, type SignMessageRequestData, SignMessageRequestSchema, type SignMessageRequestWire, type SignMessageResponse, type SignMessageResponseData, SignMessageResponseSchema, type SignMessageResponseWire, SignMessageV1RequestMessage, SignMessageV1ResponseMessage, SignatureAlgoSchema, type SigningAlgorithmName, type SigningAlgorithmSchemaFor, type AllSigningAlgorithmSchemas as SigningAlgorithmSchemas, type TraceContext, TraceContextCodec, Uint32ArrayCodec, Uint8ArrayCodec, type WebSocketConnectionInfo, type WebSocketError, WebSocketErrorType, assertDefined, assertNotNull, createKeyDerivationInfo, createKeygenResultFromSecretShare, decapsulateMlKem768, decryptKeygenResult, decryptPayload, deriveAESKey, encapsulateMlKem768, encryptKeygenInit, encryptKeyshare, encryptPayload, fromDynamicSigningAlgorithm, generateMlKem768Keypair, getAllSupportedMessages, getDefined, getMessageClass, isValidMessageType, isValidSigningAlgorithm, messageRegistry, parseMessageKey, signingAlgorithmRegistry, toDynamicSigningAlgorithm };