lotus-sdk/dist/lib/p2p/types.d.ts

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

import { PublicKey } from '../bitcore/publickey.js';
import type { Connection, Stream, PeerId, PrivateKey } from '@libp2p/interface';
import type { Multiaddr } from '@multiformats/multiaddr';
import type { Libp2p } from 'libp2p';
import type { PeerInfoMapper } from '@libp2p/kad-dht';
export type { PeerId, Connection, Stream, Multiaddr, Libp2p, PeerInfoMapper };
export declare enum BaseMessageType {
    PEER_HANDSHAKE = "peer-handshake",
    PEER_DISCONNECT = "peer-disconnect",
    PEER_HEARTBEAT = "peer-heartbeat",
    DHT_ANNOUNCE = "dht-announce",
    DHT_QUERY = "dht-query",
    DHT_RESPONSE = "dht-response",
    DATA_MESSAGE = "data-message",
    DATA_BROADCAST = "data-broadcast",
    ERROR = "error"
}
export interface PeerInfo {
    peerId: string;
    publicKey?: PublicKey;
    multiaddrs?: string[];
    metadata?: Record<string, unknown>;
    lastSeen?: number;
}
export interface P2PMessage<T = unknown> {
    type: string;
    from: string;
    to?: string;
    payload: T;
    timestamp: number;
    messageId: string;
    signature?: Buffer;
    protocol?: string;
}
export interface DHTQuery {
    key: string;
    filters?: Record<string, unknown>;
    maxResults?: number;
}
export declare enum ConnectionEvent {
    CONNECTED = "peer:connect",
    DISCONNECTED = "peer:disconnect",
    DISCOVERED = "peer:discovery",
    UPDATED = "peer:update",
    MESSAGE = "message",
    ERROR = "error"
}
export declare enum RelayEvent {
    ADDRESSES_AVAILABLE = "relay:addresses-available",
    CONNECTED = "relay:connected",
    DISCONNECTED = "relay:disconnected"
}
export interface P2PConfig {
    privateKey?: PrivateKey;
    listen?: string[];
    announce?: string[];
    bootstrapPeers?: string[];
    enableDHT?: boolean;
    dhtProtocol?: string;
    enableDHTServer?: boolean;
    enableGossipSub?: boolean;
    securityConfig?: {
        disableRateLimiting?: boolean;
        customLimits?: Partial<typeof CORE_P2P_SECURITY_LIMITS>;
    };
    dhtPeerInfoMapper?: PeerInfoMapper;
    enableRelay?: boolean;
    enableRelayServer?: boolean;
    enableAutoNAT?: boolean;
    enableDCUTR?: boolean;
    enableUPnP?: boolean;
    maxConnections?: number;
    connectionManager?: {
        maxConnections?: number;
    };
    metadata?: Record<string, unknown>;
    relayMonitoring?: {
        enabled?: boolean;
        checkInterval?: number;
        bootstrapOnly?: boolean;
    };
}
export interface IProtocolHandler {
    readonly protocolName: string;
    readonly protocolId: string;
    handleMessage(message: P2PMessage, from: PeerInfo): Promise<void>;
    onPeerDiscovered?(peerInfo: PeerInfo): Promise<void>;
    onPeerConnected?(peerId: string): Promise<void>;
    onPeerDisconnected?(peerId: string): Promise<void>;
    onPeerUpdated?(peerInfo: PeerInfo): Promise<void>;
    handleStream?(stream: Stream, connection: Connection): Promise<void>;
    onRelayAddressesChanged?(data: {
        peerId: string;
        reachableAddresses: string[];
        relayAddresses: string[];
        timestamp: number;
    }): Promise<void>;
}
export interface ResourceAnnouncement<T = unknown> {
    resourceId: string;
    resourceType: string;
    creatorPeerId: string;
    data: T;
    createdAt: number;
    expiresAt?: number;
    signature?: Buffer;
}
export interface BroadcastOptions {
    exclude?: string[];
    includedOnly?: string[];
    protocol?: string;
}
export type MessageHandler = (message: P2PMessage, from: PeerInfo) => Promise<void> | void;
export interface DHTStats {
    enabled: boolean;
    mode: 'client' | 'server' | 'disabled';
    routingTableSize: number;
    isReady: boolean;
}
export interface P2PStats {
    peerId: string;
    peers: {
        total: number;
        connected: number;
    };
    dht: {
        enabled: boolean;
        mode: 'client' | 'server' | 'disabled';
        routingTableSize: number;
        localRecords: number;
    };
    multiaddrs: string[];
}
export declare const CORE_P2P_SECURITY_LIMITS: {
    readonly MAX_P2P_MESSAGE_SIZE: 100000;
    readonly MIN_DHT_ANNOUNCEMENT_INTERVAL: 30000;
    readonly MAX_DHT_RESOURCES_PER_PEER: 100;
    readonly MAX_DHT_RESOURCES_PER_TYPE_PER_PEER: 20;
    readonly DHT_CLEANUP_INTERVAL: number;
    readonly MAX_INVALID_MESSAGES_PER_PEER: 20;
};
export interface IProtocolValidator {
    validateResourceAnnouncement?(resourceType: string, resourceId: string, data: unknown, peerId: string): Promise<boolean> | boolean;
    validateMessage?(message: P2PMessage, from: PeerInfo): Promise<boolean> | boolean;
    canAnnounceResource?(resourceType: string, peerId: string): Promise<boolean> | boolean;
}
export interface CoreSecurityMetrics {
    dhtAnnouncements: {
        total: number;
        rejected: number;
        rateLimited: number;
    };
    messages: {
        total: number;
        rejected: number;
        oversized: number;
    };
    peers: {
        banned: number;
        warnings: number;
    };
}
//# sourceMappingURL=types.d.ts.map