@psavelis/enterprise-blockchain 0.1.0 → 1.1.1

package/dist/mpc/index.d.ts

@@ -0,0 +1,135 @@
+import type { RandomnessProvider, CommitmentProvider } from "./ports.js";
+export { FieldArithmetic, getFieldConfig, DEMO_PRIME, PRODUCTION_PRIME, productionField, } from "./field.js";
+export type { FieldConfig, FieldMode } from "./field.js";
+export interface PartyConfig {
+    id: string;
+    name: string;
+    endpoint: string;
+}
+export interface SecretShare {
+    partyId: string;
+    shareIndex: number;
+    shareCount: number;
+    value: number;
+    nonce: string;
+    commitment: string;
+}
+export type ComputationOp = "sum" | "threshold";
+export interface SumResult {
+    computationId: string;
+    op: "sum";
+    participantCount: number;
+    aggregate: number;
+    meta: Record<string, string | number | boolean>;
+    integrityProof: string;
+}
+export interface ThresholdResult {
+    computationId: string;
+    op: "threshold";
+    participantCount: number;
+    exceeded: boolean;
+    meta: Record<string, string | number | boolean>;
+    integrityProof: string;
+}
+export type ComputationResult = SumResult | ThresholdResult;
+export interface ResourceQuotaConfig {
+    /** Maximum active sessions per party. Default: 100 */
+    maxSessionsPerParty: number;
+    /** Maximum total active sessions. Default: 1000 */
+    maxTotalSessions: number;
+    /** Session TTL in milliseconds. Default: 5 minutes */
+    sessionTtlMs: number;
+    /** Maximum memory for shares in bytes. Default: 10MB */
+    maxMemoryBytes: number;
+}
+export declare const DEFAULT_QUOTA_CONFIG: ResourceQuotaConfig;
+export interface ResourceQuotaManager {
+    checkSessionQuota(partyId: string): boolean;
+    checkTotalSessionQuota(): boolean;
+    checkMemoryQuota(additionalBytes: number): boolean;
+    recordSession(partyId: string, computationId: string): void;
+    releaseSession(computationId: string): void;
+    getUsage(): ResourceUsage;
+}
+export interface ResourceUsage {
+    totalSessions: number;
+    sessionsByParty: Map<string, number>;
+    estimatedMemoryBytes: number;
+    oldestSessionAgeMs: number;
+}
+export declare class InMemoryResourceQuotaManager implements ResourceQuotaManager {
+    private readonly config;
+    private readonly sessionsByParty;
+    private readonly sessionCreatedAt;
+    private estimatedMemoryBytes;
+    constructor(config?: Partial<ResourceQuotaConfig>);
+    checkSessionQuota(partyId: string): boolean;
+    checkTotalSessionQuota(): boolean;
+    checkMemoryQuota(additionalBytes: number): boolean;
+    recordSession(partyId: string, computationId: string): void;
+    releaseSession(computationId: string): void;
+    getUsage(): ResourceUsage;
+    /** Expire sessions older than TTL. Returns number of expired sessions. */
+    expireOldSessions(): number;
+}
+export interface MPCEngineConfig {
+    quotaManager?: ResourceQuotaManager;
+    /** Optional randomness provider for dependency injection (testing). */
+    randomnessProvider?: RandomnessProvider;
+    /** Optional commitment provider for dependency injection (testing). */
+    commitmentProvider?: CommitmentProvider;
+}
+export declare class MPCEngine {
+    private readonly parties;
+    private readonly rounds;
+    private readonly quotaManager;
+    private readonly randomness;
+    private readonly commitment;
+    constructor(config?: MPCEngineConfig);
+    registerParty(party: PartyConfig): void;
+    /**
+     * Split `secret` into `partyIds.length` additive shares.
+     * Any strict subset of shares reveals nothing about the secret;
+     * summing all shares reconstructs the original value.
+     */
+    splitSecret(secret: number, partyIds: string[]): SecretShare[];
+    submitShare(computationId: string, share: SecretShare): void;
+    /**
+     * - **sum**: reconstructs the aggregate value from all shares.
+     * - **threshold**: checks whether the aggregate meets a given
+     *   limit supplied via the `threshold` parameter.
+     */
+    compute(computationId: string, op: "sum", opts?: {
+        threshold?: number;
+    }): SumResult;
+    compute(computationId: string, op: "threshold", opts?: {
+        threshold?: number;
+    }): ThresholdResult;
+    verifyIntegrity(computationId: string): boolean;
+    /**
+     * Release a completed computation and free associated resources.
+     * Call this after compute() to prevent memory accumulation.
+     */
+    releaseComputation(computationId: string): void;
+    /**
+     * Get current resource usage statistics.
+     * Returns null if no quota manager is configured.
+     */
+    getResourceUsage(): ResourceUsage | null;
+    /**
+     * Expire stale sessions that have exceeded TTL.
+     * Returns number of expired sessions.
+     */
+    expireStaleSessions(): number;
+}
+export type { RandomnessProvider, CommitmentProvider } from "./ports.js";
+export { NodeRandomnessProvider, NodeCommitmentProvider, defaultRandomnessProvider, defaultCommitmentProvider, } from "./adapters.js";
+export { KyberKem, ML_KEM_SIZES } from "./kyber.js";
+export type { KyberKeyPair, KemEncapsulation, KemAuditRecord, MlKemParams, } from "./kyber.js";
+export { HybridKem } from "./hybrid-kem.js";
+export type { HybridKeyPairs, HybridEncapsulation, HybridDecapsulation, } from "./hybrid-kem.js";
+export { MlDsaSigner, ML_DSA_SIZES } from "./dsa.js";
+export type { DsaKeyPair, DsaSignatureResult, DsaAuditRecord, MlDsaParams, } from "./dsa.js";
+export { QuantumResistantVault } from "./quantum.js";
+export type { ThresholdShare, HashLadderKey, QuantumResistantAnchor, VaultConfig, } from "./quantum.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/mpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mpc/index.ts"],"names":[],"mappings":"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"}

package/dist/mpc/index.js

@@ -0,0 +1,348 @@
+import { defaultRandomnessProvider, defaultCommitmentProvider, } from "./adapters.js";
+/** Estimated bytes per share entry for memory quota tracking */
+const BYTES_PER_SHARE = 200;
+// Re-export field arithmetic for advanced use cases
+// Note: demoField is intentionally NOT exported to prevent accidental use in production.
+// Use `new FieldArithmetic({ mode: "demo", prime: DEMO_PRIME })` explicitly in tests.
+export { FieldArithmetic, getFieldConfig, DEMO_PRIME, PRODUCTION_PRIME, productionField, } from "./field.js";
+export const DEFAULT_QUOTA_CONFIG = {
+    maxSessionsPerParty: 100,
+    maxTotalSessions: 1000,
+    sessionTtlMs: 5 * 60 * 1000, // 5 minutes
+    maxMemoryBytes: 10 * 1024 * 1024, // 10MB
+};
+export class InMemoryResourceQuotaManager {
+    config;
+    sessionsByParty = new Map();
+    sessionCreatedAt = new Map();
+    estimatedMemoryBytes = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_QUOTA_CONFIG, ...config };
+    }
+    checkSessionQuota(partyId) {
+        const partySessions = this.sessionsByParty.get(partyId);
+        if (!partySessions)
+            return true;
+        return partySessions.size < this.config.maxSessionsPerParty;
+    }
+    checkTotalSessionQuota() {
+        let total = 0;
+        for (const sessions of this.sessionsByParty.values()) {
+            total += sessions.size;
+        }
+        return total < this.config.maxTotalSessions;
+    }
+    checkMemoryQuota(additionalBytes) {
+        return (this.estimatedMemoryBytes + additionalBytes <= this.config.maxMemoryBytes);
+    }
+    recordSession(partyId, computationId) {
+        let partySessions = this.sessionsByParty.get(partyId);
+        if (!partySessions) {
+            partySessions = new Set();
+            this.sessionsByParty.set(partyId, partySessions);
+        }
+        partySessions.add(computationId);
+        this.sessionCreatedAt.set(computationId, Date.now());
+        this.estimatedMemoryBytes += BYTES_PER_SHARE;
+    }
+    releaseSession(computationId) {
+        for (const [partyId, sessions] of this.sessionsByParty.entries()) {
+            if (sessions.delete(computationId)) {
+                if (sessions.size === 0) {
+                    this.sessionsByParty.delete(partyId);
+                }
+                break;
+            }
+        }
+        this.sessionCreatedAt.delete(computationId);
+        this.estimatedMemoryBytes = Math.max(0, this.estimatedMemoryBytes - BYTES_PER_SHARE);
+    }
+    getUsage() {
+        const sessionsByParty = new Map();
+        let totalSessions = 0;
+        let oldestAge = 0;
+        const now = Date.now();
+        for (const [partyId, sessions] of this.sessionsByParty.entries()) {
+            sessionsByParty.set(partyId, sessions.size);
+            totalSessions += sessions.size;
+        }
+        for (const createdAt of this.sessionCreatedAt.values()) {
+            const age = now - createdAt;
+            if (age > oldestAge)
+                oldestAge = age;
+        }
+        return {
+            totalSessions,
+            sessionsByParty,
+            estimatedMemoryBytes: this.estimatedMemoryBytes,
+            oldestSessionAgeMs: oldestAge,
+        };
+    }
+    /** Expire sessions older than TTL. Returns number of expired sessions. */
+    expireOldSessions() {
+        const now = Date.now();
+        const expired = [];
+        for (const [computationId, createdAt] of this.sessionCreatedAt.entries()) {
+            if (now - createdAt > this.config.sessionTtlMs) {
+                expired.push(computationId);
+            }
+        }
+        for (const computationId of expired) {
+            this.releaseSession(computationId);
+        }
+        return expired.length;
+    }
+}
+export class MPCEngine {
+    parties = new Map();
+    rounds = new Map();
+    quotaManager;
+    randomness;
+    commitment;
+    constructor(config = {}) {
+        this.quotaManager = config.quotaManager ?? null;
+        this.randomness = config.randomnessProvider ?? defaultRandomnessProvider;
+        this.commitment = config.commitmentProvider ?? defaultCommitmentProvider;
+    }
+    registerParty(party) {
+        this.parties.set(party.id, party);
+    }
+    /**
+     * Split `secret` into `partyIds.length` additive shares.
+     * Any strict subset of shares reveals nothing about the secret;
+     * summing all shares reconstructs the original value.
+     */
+    splitSecret(secret, partyIds) {
+        if (partyIds.length < 2) {
+            throw new Error("At least two parties are required for secret sharing");
+        }
+        const shares = [];
+        let remaining = secret;
+        // Use a range large enough to make individual shares
+        // statistically indistinguishable from random.
+        // Node.js randomInt supports a max span of 2^48 − 1.
+        const lo = -(2 ** 47) + 1;
+        const hi = 2 ** 47;
+        for (let i = 0; i < partyIds.length - 1; i++) {
+            const value = this.randomness.randomInt(lo, hi);
+            remaining -= value;
+            const nonce = this.randomness.randomBytes(16).toString("hex");
+            shares.push({
+                partyId: partyIds[i],
+                shareIndex: i,
+                shareCount: partyIds.length,
+                value,
+                nonce,
+                commitment: this.commitment.commitShare(partyIds[i], i, value, nonce),
+            });
+        }
+        const lastNonce = this.randomness.randomBytes(16).toString("hex");
+        shares.push({
+            partyId: partyIds[partyIds.length - 1],
+            shareIndex: partyIds.length - 1,
+            shareCount: partyIds.length,
+            value: remaining,
+            nonce: lastNonce,
+            commitment: this.commitment.commitShare(partyIds[partyIds.length - 1], partyIds.length - 1, remaining, lastNonce),
+        });
+        return shares;
+    }
+    submitShare(computationId, share) {
+        const party = this.parties.get(share.partyId);
+        if (!party) {
+            throw new Error(`Unknown party ${share.partyId}`);
+        }
+        // Check resource quotas before accepting new sessions
+        if (this.quotaManager) {
+            // For new sessions, verify quotas
+            if (!this.rounds.has(computationId)) {
+                if (!this.quotaManager.checkTotalSessionQuota()) {
+                    throw new Error(`Resource quota exceeded: maximum total sessions reached`);
+                }
+                if (!this.quotaManager.checkSessionQuota(share.partyId)) {
+                    throw new Error(`Resource quota exceeded: party ${share.partyId} has too many active sessions`);
+                }
+                if (!this.quotaManager.checkMemoryQuota(BYTES_PER_SHARE * share.shareCount)) {
+                    throw new Error(`Resource quota exceeded: memory limit would be exceeded`);
+                }
+            }
+        }
+        // Verify commitment before accepting the share.
+        // This prevents a malicious party from submitting a bogus value
+        // with a valid-looking commitment, which would corrupt the result.
+        // Uses timing-safe comparison to prevent timing attacks that could
+        // leak information about valid commitment prefixes.
+        const expected = this.commitment.commitShare(share.partyId, share.shareIndex, share.value, share.nonce);
+        if (!this.commitment.timingSafeCompare(expected, share.commitment)) {
+            throw new Error(`Commitment verification failed for party ${share.partyId} in computation ${computationId}`);
+        }
+        let round = this.rounds.get(computationId);
+        if (!round) {
+            round = {
+                expectedShareCount: share.shareCount,
+                shares: new Map(),
+                createdAt: Date.now(),
+                usedNonces: new Set(),
+            };
+            this.rounds.set(computationId, round);
+            // Record session for quota tracking
+            if (this.quotaManager) {
+                this.quotaManager.recordSession(share.partyId, computationId);
+            }
+        }
+        if (share.shareCount !== round.expectedShareCount) {
+            throw new Error(`Inconsistent share count for computation ${computationId}`);
+        }
+        if (round.shares.has(share.partyId)) {
+            throw new Error(`Party ${share.partyId} already submitted a share for ${computationId}`);
+        }
+        // SECURITY: Prevent replay attacks within the same computation.
+        // Nonces must be unique per computation to prevent an attacker from
+        // submitting the same share twice (e.g., to corrupt the aggregate).
+        // Note: Cross-computation replay is prevented by commitment binding
+        // (partyId + shareIndex + value + nonce) which makes replayed shares
+        // fail commitment verification in a different computation context.
+        if (round.usedNonces.has(share.nonce)) {
+            throw new Error(`Replay attack detected: nonce already used in computation ${computationId}`);
+        }
+        round.usedNonces.add(share.nonce);
+        // Store a defensive copy to prevent callers from mutating the share
+        // after submission, which could corrupt the computation result.
+        round.shares.set(share.partyId, { ...share });
+    }
+    compute(computationId, op, opts) {
+        const round = this.rounds.get(computationId);
+        if (!round || round.shares.size === 0) {
+            throw new Error(`No shares submitted for computation ${computationId}`);
+        }
+        const participantCount = round.shares.size;
+        if (participantCount !== round.expectedShareCount) {
+            throw new Error(`Incomplete share set for computation ${computationId}: expected ${round.expectedShareCount}, got ${participantCount}`);
+        }
+        switch (op) {
+            case "sum": {
+                // Verify commitments BEFORE aggregating values to ensure
+                // no share was mutated between submitShare and compute.
+                const commitmentsVerified = this.verifyIntegrity(computationId);
+                if (!commitmentsVerified) {
+                    throw new Error(`Commitment verification failed during computation ${computationId} — aborting to prevent corrupted result`);
+                }
+                let aggregate = 0;
+                for (const share of round.shares.values()) {
+                    aggregate += share.value;
+                }
+                return {
+                    computationId,
+                    op: "sum",
+                    participantCount,
+                    aggregate,
+                    meta: {
+                        operation: "additive-reconstruction",
+                        commitmentsVerified,
+                    },
+                    integrityProof: this.commitment.sha256hex(JSON.stringify({
+                        computationId,
+                        op: "sum",
+                        participantCount,
+                        aggregate,
+                        commitmentsVerified,
+                    })),
+                };
+            }
+            case "threshold": {
+                // Verify commitments BEFORE aggregating values to ensure
+                // no share was mutated between submitShare and compute.
+                const commitmentsVerified = this.verifyIntegrity(computationId);
+                if (!commitmentsVerified) {
+                    throw new Error(`Commitment verification failed during computation ${computationId} — aborting to prevent corrupted result`);
+                }
+                const t = opts?.threshold ?? 0;
+                let total = 0;
+                for (const share of round.shares.values()) {
+                    total += share.value;
+                }
+                const exceeded = total >= t;
+                return {
+                    computationId,
+                    op: "threshold",
+                    participantCount,
+                    exceeded,
+                    meta: {
+                        operation: "threshold-check",
+                        threshold: t,
+                        commitmentsVerified,
+                    },
+                    integrityProof: this.commitment.sha256hex(JSON.stringify({
+                        computationId,
+                        op: "threshold",
+                        participantCount,
+                        exceeded,
+                        commitmentsVerified,
+                    })),
+                };
+            }
+        }
+    }
+    verifyIntegrity(computationId) {
+        const round = this.rounds.get(computationId);
+        if (!round)
+            return false;
+        for (const share of round.shares.values()) {
+            const expected = this.commitment.commitShare(share.partyId, share.shareIndex, share.value, share.nonce);
+            // SECURITY: Use timing-safe comparison to prevent timing attacks
+            // that could leak information about valid commitment prefixes.
+            if (!this.commitment.timingSafeCompare(expected, share.commitment)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Release a completed computation and free associated resources.
+     * Call this after compute() to prevent memory accumulation.
+     */
+    releaseComputation(computationId) {
+        const round = this.rounds.get(computationId);
+        if (round) {
+            this.rounds.delete(computationId);
+            if (this.quotaManager) {
+                this.quotaManager.releaseSession(computationId);
+            }
+        }
+    }
+    /**
+     * Get current resource usage statistics.
+     * Returns null if no quota manager is configured.
+     */
+    getResourceUsage() {
+        return this.quotaManager?.getUsage() ?? null;
+    }
+    /**
+     * Expire stale sessions that have exceeded TTL.
+     * Returns number of expired sessions.
+     */
+    expireStaleSessions() {
+        if (!this.quotaManager)
+            return 0;
+        const manager = this.quotaManager;
+        if (typeof manager.expireOldSessions !== "function")
+            return 0;
+        const expiredCount = manager.expireOldSessions();
+        // Also clean up rounds map for expired sessions
+        const now = Date.now();
+        const config = DEFAULT_QUOTA_CONFIG;
+        for (const [computationId, round] of this.rounds.entries()) {
+            if (now - round.createdAt > config.sessionTtlMs) {
+                this.rounds.delete(computationId);
+            }
+        }
+        return expiredCount;
+    }
+}
+export { NodeRandomnessProvider, NodeCommitmentProvider, defaultRandomnessProvider, defaultCommitmentProvider, } from "./adapters.js";
+// Re-export ML-KEM and Hybrid KEM so consumers can reach them via the module
+// root without needing to know the internal file layout.
+export { KyberKem, ML_KEM_SIZES } from "./kyber.js";
+export { HybridKem } from "./hybrid-kem.js";
+export { MlDsaSigner, ML_DSA_SIZES } from "./dsa.js";
+export { QuantumResistantVault } from "./quantum.js";

package/dist/mpc/kyber.d.ts

@@ -0,0 +1,134 @@
+/**
+ * ML-KEM (Kyber) — Key Encapsulation Mechanism
+ *
+ * Classical key exchange (ECDH, RSA) relies on the hardness of the discrete
+ * logarithm and integer factorisation problems.  Shor's algorithm, running on
+ * a sufficiently large cryptographically-relevant quantum computer (CRQC),
+ * solves both in polynomial time — meaning today's encrypted traffic could be
+ * recorded now and decrypted later once CRQCs mature ("harvest-now,
+ * decrypt-later" attacks).
+ *
+ * ML-KEM is the NIST-standardised Key Encapsulation Mechanism designed to
+ * replace ECDH in key exchange.  It is based on the Module-Lattice problem
+ * (MLWE), which has no known quantum speedup beyond Grover's algorithm
+ * (affecting only symmetric-key security, and only by halving the bit level).
+ *
+ * Standard: NIST FIPS 203 (finalised August 2024)
+ * Reference: https://csrc.nist.gov/pubs/fips/203/final
+ *
+ * This module wraps @noble/post-quantum, a pure-TypeScript implementation with
+ * zero native-code dependencies, which makes it platform-portable and easy to
+ * audit.
+ */
+/**
+ * ML-KEM parameter sets standardised in FIPS 203.
+ *
+ * The number (512 / 768 / 1024) corresponds to the module dimension k:
+ * - 512  → k=2, ~128-bit post-quantum security (comparable to AES-128)
+ * - 768  → k=3, ~192-bit post-quantum security (comparable to AES-192)
+ * - 1024 → k=4, ~256-bit post-quantum security (comparable to AES-256)
+ *
+ * NIST recommends ML-KEM-768 as the general-purpose choice for new systems.
+ * ML-KEM-1024 is appropriate when the highest assurance level is required
+ * (e.g., protecting data that must stay secret for 30+ years).
+ */
+export type MlKemParams = "ml-kem-512" | "ml-kem-768" | "ml-kem-1024";
+/**
+ * Public key, secret key, and ciphertext lengths (in bytes) for each
+ * parameter set.  Useful for validation and test assertions.
+ */
+export declare const ML_KEM_SIZES: Record<MlKemParams, {
+    publicKey: number;
+    secretKey: number;
+    ciphertext: number;
+    sharedSecret: number;
+}>;
+export interface KyberKeyPair {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+    /** Which ML-KEM parameter set this keypair belongs to. */
+    params: MlKemParams;
+}
+export interface KemEncapsulation {
+    /**
+     * The ciphertext to send to the recipient.  It contains everything needed
+     * to recover the sharedSecret with the matching secretKey.
+     */
+    ciphertext: Uint8Array;
+    /**
+     * The shared secret — 32 bytes of uniform randomness.  The sender uses this
+     * to derive a symmetric key (e.g., AES-256) via HKDF.  Never transmit this
+     * value; only transmit `ciphertext`.
+     */
+    sharedSecret: Uint8Array;
+    /**
+     * SHA-256 hex digest of the ciphertext's hex encoding.
+     *
+     * Computed as: sha256hex(Buffer.from(ciphertext).toString("hex"))
+     *
+     * This means the hash is over the hex-encoded string representation of the
+     * ciphertext bytes, not the raw bytes directly. Suitable for on-chain
+     * commitments or audit logs — proves a specific ciphertext was used without
+     * revealing the shared secret.
+     */
+    auditCommitment: string;
+}
+export interface KemAuditRecord {
+    params: MlKemParams;
+    /** SHA-256 of the public key — stable identifier for the recipient's keypair. */
+    publicKeyHash: string;
+    /** SHA-256 of the ciphertext — unique per session. */
+    ciphertextHash: string;
+    /** ISO-8601 timestamp of the encapsulation event. */
+    timestamp: string;
+    /** Byte length of the AES key derived from the shared secret via HKDF. */
+    derivedKeyLength: number;
+}
+export declare class KyberKem {
+    #private;
+    /**
+     * Generate a new ML-KEM keypair.
+     *
+     * The public key is shared with anyone who needs to send you an encrypted
+     * session key.  The secret key must be stored securely — ideally in an HSM
+     * or hardware-backed key store.
+     */
+    generateKeyPair(params: MlKemParams): KyberKeyPair;
+    /**
+     * Sender-side operation: encapsulate a fresh random shared secret using
+     * the recipient's public key.
+     *
+     * Returns the ciphertext (to send) and the sharedSecret (to use locally for
+     * key derivation).  The sharedSecret is never transmitted.
+     */
+    encapsulate(publicKey: Uint8Array, params: MlKemParams): KemEncapsulation;
+    /**
+     * Receiver-side operation: recover the sharedSecret from a ciphertext using
+     * the secret key.
+     *
+     * If the ciphertext was produced with a different public key, ML-KEM
+     * returns a pseudorandom value instead of the real shared secret — this is
+     * the implicit rejection property that prevents chosen-ciphertext attacks.
+     */
+    decapsulate(ciphertext: Uint8Array, secretKey: Uint8Array, params: MlKemParams): Uint8Array;
+    /**
+     * Derive a symmetric key from an ML-KEM shared secret using HKDF-SHA256.
+     *
+     * The shared secret from ML-KEM is already 32 bytes of uniform randomness,
+     * but running it through HKDF lets you bind context (e.g., session IDs,
+     * party identifiers) into the derived key — useful for domain separation.
+     *
+     * @param sharedSecret - Raw 32-byte output from encapsulate/decapsulate
+     * @param info - Optional context string bound into the derived key
+     * @param salt - Optional random salt (defaults to 32 zero bytes if omitted)
+     */
+    deriveAesKey(sharedSecret: Uint8Array, info?: string, salt?: Buffer): Buffer;
+    /**
+     * Build an audit record for a completed encapsulation round.
+     * Suitable for writing to an immutable ledger (Fabric, Besu, Corda) as
+     * proof that a particular key exchange occurred without revealing the
+     * shared secret.
+     */
+    auditRecord(encap: KemEncapsulation, publicKey: Uint8Array, params: MlKemParams): KemAuditRecord;
+}
+//# sourceMappingURL=kyber.d.ts.map

package/dist/mpc/kyber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kyber.d.ts","sourceRoot":"","sources":["../../src/mpc/kyber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAgBH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,YAAY,GAAG,aAAa,CAAC;AAMtE;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAC/B,WAAW,EACX;IACE,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,CAoBF,CAAC;AAMF,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,UAAU,CAAC;IACtB,SAAS,EAAE,UAAU,CAAC;IACtB,0DAA0D;IAC1D,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,UAAU,EAAE,UAAU,CAAC;IACvB;;;;OAIG;IACH,YAAY,EAAE,UAAU,CAAC;IACzB;;;;;;;;;OASG;IACH,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,WAAW,CAAC;IACpB,iFAAiF;IACjF,aAAa,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,cAAc,EAAE,MAAM,CAAC;IACvB,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAMD,qBAAa,QAAQ;;IACnB;;;;;;OAMG;IACH,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY;IAMlD;;;;;;OAMG;IACH,WAAW,CAAC,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,gBAAgB;IAUzE;;;;;;;OAOG;IACH,WAAW,CACT,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,UAAU,EACrB,MAAM,EAAE,WAAW,GAClB,UAAU;IAKb;;;;;;;;;;OAUG;IACH,YAAY,CACV,YAAY,EAAE,UAAU,EACxB,IAAI,SAAsB,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM;IAgBT;;;;;OAKG;IACH,WAAW,CACT,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,UAAU,EACrB,MAAM,EAAE,WAAW,GAClB,cAAc;CAwBlB"}