anon-identity/dist/ld/signature-suites/signature-suite.d.ts

Decentralized identity framework with DIDs, Verifiable Credentials, and privacy-preserving selective disclosure

import { Proof, ProofPurpose } from '../../types/vc2';
import { JsonLdProcessor } from '../jsonld-processor';
/**
 * Key type supported by a signature suite
 */
export declare enum KeyType {
    Ed25519 = "Ed25519",
    BLS12381G2 = "Bls12381G2"
}
/**
 * Signature suite configuration
 */
export interface SignatureSuiteOptions {
    jsonLdProcessor?: JsonLdProcessor;
    [key: string]: any;
}
/**
 * Signing options
 */
export interface SigningOptions {
    document: any;
    purpose: ProofPurpose | string;
    verificationMethod: string;
    privateKey: Uint8Array;
    challenge?: string;
    domain?: string;
    created?: string;
    expires?: string;
}
/**
 * Verification options
 */
export interface VerificationOptions {
    document: any;
    proof: Proof;
    publicKey: Uint8Array;
    expectedPurpose: ProofPurpose | string;
    expectedChallenge?: string;
    expectedDomain?: string;
}
/**
 * Selective disclosure options (for BBS+)
 */
export interface SelectiveDisclosureOptions {
    document: any;
    proof: Proof;
    revealedAttributes: string[];
    holderPrivateKey?: Uint8Array;
    nonce?: string;
}
/**
 * Abstract base class for signature suites
 */
export declare abstract class SignatureSuite {
    abstract readonly type: string;
    abstract readonly requiredKeyType: KeyType;
    abstract readonly supportsSelectiveDisclosure: boolean;
    readonly canonicalizationAlgorithm: string;
    protected jsonLdProcessor: JsonLdProcessor;
    constructor(options?: SignatureSuiteOptions);
    /**
     * Create a proof for a document
     */
    abstract createProof(options: SigningOptions): Promise<Proof>;
    /**
     * Verify a proof on a document
     */
    abstract verifyProof(options: VerificationOptions): Promise<boolean>;
    /**
     * Create a derived proof with selective disclosure (if supported)
     */
    createDerivedProof(options: SelectiveDisclosureOptions): Promise<Proof>;
    /**
     * Verify a derived proof (if supported)
     */
    verifyDerivedProof(options: VerificationOptions): Promise<boolean>;
    /**
     * Canonicalize document for signing/verification
     */
    protected canonicalizeDocument(document: any): Promise<string>;
    /**
     * Create proof value metadata
     */
    protected createProofMetadata(options: SigningOptions): Partial<Proof>;
    /**
     * Validate proof metadata
     */
    protected validateProofMetadata(proof: Proof, options: VerificationOptions): {
        valid: boolean;
        error?: string;
    };
}
/**
 * Registry for signature suites
 */
export declare class SignatureSuiteRegistry {
    private static suites;
    /**
     * Register a signature suite
     */
    static register(type: string, suiteClass: new (options?: SignatureSuiteOptions) => SignatureSuite): void;
    /**
     * Get a signature suite by type
     */
    static getSuite(type: string, options?: SignatureSuiteOptions): SignatureSuite;
    /**
     * Check if a suite is registered
     */
    static hasSuite(type: string): boolean;
    /**
     * Get all registered suite types
     */
    static getRegisteredTypes(): string[];
}
//# sourceMappingURL=signature-suite.d.ts.map