lotus-sdk/dist/lib/p2p/musig2/coordinator.d.ts

Central repository for several classes of tools for integrating with, and building for, the Lotusia ecosystem

import { EventEmitter } from 'events';
import type { P2PConfig } from '../types.js';
import { type MuSig2SecurityConfig } from './security.js';
import { type MuSig2P2PConfig, type MuSig2P2PSession, type SessionAnnouncement, type SessionParticipant } from './types.js';
import { PublicKey } from '../../bitcore/publickey.js';
import { PrivateKey } from '../../bitcore/privatekey.js';
import { MuSig2Discovery } from './discovery-extension.js';
import type { MuSig2DiscoveryConfig } from './discovery-types.js';
export declare class MuSig2P2PCoordinator extends EventEmitter {
    private coordinator;
    private protocolHandler;
    private securityValidator;
    private sessionManager;
    private protocol;
    private discovery?;
    private sessions;
    private config;
    private cleanupInterval?;
    private sessionTimeouts;
    private broadcastTimeouts;
    private usedNonces;
    private metrics;
    constructor(p2pConfig: P2PConfig, musig2Config?: MuSig2P2PConfig, securityConfig?: MuSig2SecurityConfig, discoveryConfig?: MuSig2DiscoveryConfig);
    start(): Promise<void>;
    stop(): Promise<void>;
    get peerId(): string;
    getDiscovery(): MuSig2Discovery | undefined;
    hasDiscovery(): boolean;
    createSession(signers: PublicKey[], myPrivateKey: PrivateKey, message: Buffer, metadata?: Record<string, unknown>): Promise<string>;
    announceSession(sessionId: string): Promise<void>;
    joinSession(announcement: SessionAnnouncement, myPrivateKey: PrivateKey): Promise<string>;
    getSession(sessionId: string): MuSig2P2PSession | undefined;
    getAllSessions(): MuSig2P2PSession[];
    shareNonces(sessionId: string, privateKey: PrivateKey): Promise<void>;
    sharePartialSignature(sessionId: string, privateKey: PrivateKey): Promise<void>;
    canFinalizeSession(sessionId: string): boolean;
    finalizeSession(sessionId: string): Promise<Buffer>;
    abortSession(sessionId: string, reason: string): Promise<void>;
    private _setupProtocolHandlers;
    private _handleProtocolError;
    private _handleSessionAnnouncement;
    private _handleSessionComplete;
    private _handleNonceShare;
    private _handlePartialSigShare;
    private _handleSessionAbort;
    private _handleSessionJoin;
    private _handleSessionJoinAck;
    private _sendJoinAck;
    private _handlePeerDisconnected;
    private _broadcastToSessionParticipants;
    private _validatePayloadForMessage;
    private startCleanup;
    private cleanup;
    private _setNonceTimeout;
    private _setPartialSigTimeout;
    private _clearSessionTimeout;
    private _hashNonce;
    private _getElectionMethod;
    private _setBroadcastTimeout;
    private _clearBroadcastTimeout;
    private _handleBroadcastTimeout;
    private _clearSessionNonces;
    getParticipants(sessionId: string): SessionParticipant[];
    getParticipant(sessionId: string, peerId: string): SessionParticipant | undefined;
    removeParticipant(sessionId: string, peerId: string): boolean;
    getValidationStatus(): {
        validation: {
            enabled: boolean;
            layer: string;
            fieldSafety: string;
            errorHandling: string;
        };
        serialization: {
            enabled: boolean;
            format: string;
            compression: string;
            errorHandling: string;
        };
        protocol: {
            validationEnabled: boolean;
            errorHandlingEnabled: boolean;
            securityChecksEnabled: boolean;
        };
        security: {
            blockedPeers: string[];
            blockedPeerCount: number;
            validationViolations: {
                [k: string]: number;
            };
            totalViolations: number;
            config: {
                maxMessageSize: number;
                maxTimestampSkew: number;
                maxInvalidMessagesPerPeer: number;
                enableValidationSecurity: boolean;
                trackValidationViolations: boolean;
            };
        };
        metrics: {
            sessionsCreated: number;
            sessionsCompleted: number;
            sessionsAborted: number;
            sessionsTimedOut: number;
        };
    };
    getSecurityStatus(): {
        blockedPeers: string[];
        blockedPeerCount: number;
        validationViolations: {
            [k: string]: number;
        };
        totalViolations: number;
        config: {
            maxMessageSize: number;
            maxTimestampSkew: number;
            maxInvalidMessagesPerPeer: number;
            enableValidationSecurity: boolean;
            trackValidationViolations: boolean;
        };
    };
    isPeerBlocked(peerId: string): boolean;
    unblockPeer(peerId: string): boolean;
    getSessionMetrics(): {
        activeSessions: number;
        usedNonces: number;
        validation: {
            enabled: boolean;
            errorHandlingEnabled: boolean;
            securityChecksEnabled: boolean;
        };
        security: {
            blockedPeers: string[];
            blockedPeerCount: number;
            validationViolations: {
                [k: string]: number;
            };
            totalViolations: number;
            config: {
                maxMessageSize: number;
                maxTimestampSkew: number;
                maxInvalidMessagesPerPeer: number;
                enableValidationSecurity: boolean;
                trackValidationViolations: boolean;
            };
        };
        sessionsCreated: number;
        sessionsCompleted: number;
        sessionsAborted: number;
        sessionsTimedOut: number;
    };
    getMetrics(): {
        activeSessions: number;
        totalUsedNonces: number;
        validationStatus: {
            validation: {
                enabled: boolean;
                layer: string;
                fieldSafety: string;
                errorHandling: string;
            };
            serialization: {
                enabled: boolean;
                format: string;
                compression: string;
                errorHandling: string;
            };
            protocol: {
                validationEnabled: boolean;
                errorHandlingEnabled: boolean;
                securityChecksEnabled: boolean;
            };
            security: {
                blockedPeers: string[];
                blockedPeerCount: number;
                validationViolations: {
                    [k: string]: number;
                };
                totalViolations: number;
                config: {
                    maxMessageSize: number;
                    maxTimestampSkew: number;
                    maxInvalidMessagesPerPeer: number;
                    enableValidationSecurity: boolean;
                    trackValidationViolations: boolean;
                };
            };
            metrics: {
                sessionsCreated: number;
                sessionsCompleted: number;
                sessionsAborted: number;
                sessionsTimedOut: number;
            };
        };
        sessionsCreated: number;
        sessionsCompleted: number;
        sessionsAborted: number;
        sessionsTimedOut: number;
    };
    hasSession(sessionId: string): boolean;
    getSessionCount(): number;
    isCoordinator(sessionId: string): boolean;
    getCoordinatorInfo(sessionId: string): {
        coordinatorIndex: number | undefined;
        isCoordinator: boolean;
        electionMethod: string | undefined;
        electionProof: string | undefined;
        backupCoordinators: number[] | undefined;
    };
    getBackupCoordinator(sessionId: string): number | null;
    getCoordinatorPriorityList(sessionId: string): number[];
    notifyBroadcastComplete(sessionId: string): void;
    addParticipant(sessionId: string, peerId: string, signerIndex: number, publicKey: PublicKey): void;
}
//# sourceMappingURL=coordinator.d.ts.map