@iota-big3/sdk-quantum/dist/types/quantum.types.d.ts

Quantum-ready architecture with post-quantum cryptography

export type QuantumAlgorithm = 'kyber' | 'dilithium' | 'falcon' | 'sphincs+' | 'ntru' | 'frodo' | 'saber' | 'classic-mceliece';
export type SecurityLevel = 1 | 2 | 3 | 5;
export type CryptoMode = 'quantum-only' | 'hybrid' | 'transitional' | 'classic-fallback';
export interface QuantumConfig {
    mode: CryptoMode;
    algorithms: AlgorithmConfig;
    securityLevel: SecurityLevel;
    migration?: MigrationConfig;
    performance?: PerformanceConfig;
}
export interface AlgorithmConfig {
    kem: QuantumAlgorithm;
    signature: QuantumAlgorithm;
    hash?: string;
    symmetric?: string;
}
export interface MigrationConfig {
    enabled: boolean;
    strategy: 'immediate' | 'gradual' | 'on-demand';
    compatibilityMode: boolean;
    legacyTimeout?: number;
}
export interface PerformanceConfig {
    cacheKeys: boolean;
    parallelOperations: number;
    hardwareAcceleration?: boolean;
    optimizeFor: 'speed' | 'size' | 'balanced';
}
export interface QuantumKeyPair {
    algorithm: QuantumAlgorithm;
    publicKey: Uint8Array;
    privateKey: Uint8Array;
    metadata: KeyMetadata;
}
export interface KeyMetadata {
    id: string;
    created: Date;
    algorithm: QuantumAlgorithm;
    securityLevel: SecurityLevel;
    usage: KeyUsage[];
    expires?: Date;
}
export type KeyUsage = 'encrypt' | 'decrypt' | 'sign' | 'verify' | 'keyAgreement' | 'keyEncapsulation';
export interface EncapsulatedSecret {
    ciphertext: Uint8Array;
    sharedSecret: Uint8Array;
}
export interface QuantumSignature {
    signature: Uint8Array;
    algorithm: QuantumAlgorithm;
    publicKey?: Uint8Array;
}
export interface HybridCrypto {
    classical: ClassicalCrypto;
    quantum: QuantumCrypto;
    combiner: CombinerFunction;
}
export interface ClassicalCrypto {
    algorithm: string;
    keySize: number;
    mode?: string;
}
export interface QuantumCrypto {
    algorithm: QuantumAlgorithm;
    securityLevel: SecurityLevel;
    parameters?: any;
}
export type CombinerFunction = 'concatenate' | 'xor' | 'kdf' | 'nested';
export interface CryptoAgility {
    supportedAlgorithms: QuantumAlgorithm[];
    currentAlgorithm: QuantumAlgorithm;
    canMigrate: boolean;
    migrationPath?: MigrationPath;
}
export interface MigrationPath {
    from: QuantumAlgorithm;
    to: QuantumAlgorithm;
    steps: MigrationStep[];
    estimatedTime: number;
}
export interface MigrationStep {
    action: 'generate' | 'convert' | 'test' | 'switch' | 'cleanup';
    description: string;
    required: boolean;
    risk: 'low' | 'medium' | 'high';
}
export interface QuantumMetrics {
    operationsPerSecond: number;
    keyGenerationTime: number;
    encryptionTime: number;
    decryptionTime: number;
    signatureTime: number;
    verificationTime: number;
    keySize: KeySizeMetrics;
}
export interface KeySizeMetrics {
    publicKey: number;
    privateKey: number;
    signature: number;
    ciphertext: number;
}
export interface QuantumThreat {
    type: 'harvest-now-decrypt-later' | 'quantum-computer' | 'side-channel';
    severity: 'low' | 'medium' | 'high' | 'critical';
    mitigations: string[];
    timeline?: string;
}
export interface QuantumReadiness {
    score: number;
    algorithms: boolean;
    keyManagement: boolean;
    protocols: boolean;
    testing: boolean;
    threats: QuantumThreat[];
}
export interface QuantumSimulator {
    qubits: number;
    gates: QuantumGate[];
    noise?: NoiseModel;
    backend: 'statevector' | 'qasm' | 'real';
}
export interface QuantumGate {
    type: 'X' | 'Y' | 'Z' | 'H' | 'CNOT' | 'Toffoli' | 'custom';
    qubits: number[];
    parameters?: number[];
}
export interface NoiseModel {
    errorRate: number;
    decoherenceTime: number;
    gateErrors: Record<string, number>;
}
export interface QuantumCircuit {
    qubits: number;
    classicalBits: number;
    gates: QuantumGate[];
    measurements: Measurement[];
}
export interface Measurement {
    qubit: number;
    classicalBit: number;
    basis?: 'Z' | 'X' | 'Y';
}
export interface QuantumState {
    amplitudes: Complex[];
    probabilities: number[];
    entanglement: number;
}
export interface Complex {
    real: number;
    imaginary: number;
}
export interface LatticeParameters {
    dimension: number;
    modulus: bigint;
    standardDeviation: number;
    compressionFactor?: number;
}
export interface HashBasedSignature {
    type: 'XMSS' | 'SPHINCS' | 'LMS';
    treeHeight: number;
    winternitzParameter: number;
    layers?: number;
}
export interface CodeBasedCrypto {
    type: 'McEliece' | 'Niederreiter' | 'BIKE';
    codeLength: number;
    codeDimension: number;
    errorWeight: number;
}
export interface IsogenyCrypto {
    type: 'SIKE' | 'CSIDH';
    primeSize: number;
    isogenyDegree: number;
}
export interface QuantumSafeProtocol {
    name: string;
    version: string;
    algorithms: QuantumAlgorithm[];
    handshake: HandshakeProtocol;
}
export interface HandshakeProtocol {
    steps: HandshakeStep[];
    timeout: number;
    fallback?: string;
}
export interface HandshakeStep {
    type: 'kem' | 'sign' | 'verify' | 'derive';
    algorithm: QuantumAlgorithm;
    data?: Uint8Array;
}
export interface QuantumStorage {
    encrypted: boolean;
    algorithm: QuantumAlgorithm;
    keyDerivation: string;
    iterations: number;
    salt: Uint8Array;
}
export interface QuantumBackup {
    version: string;
    timestamp: Date;
    keys: EncryptedKey[];
    metadata: BackupMetadata;
}
export interface EncryptedKey {
    id: string;
    algorithm: QuantumAlgorithm;
    encryptedData: Uint8Array;
    mac: Uint8Array;
}
export interface BackupMetadata {
    created: Date;
    expires?: Date;
    description?: string;
    recovery: RecoveryInfo;
}
export interface RecoveryInfo {
    method: 'shamir' | 'threshold' | 'multiparty';
    threshold: number;
    shares: number;
}
//# sourceMappingURL=quantum.types.d.ts.map