libp2p-native-bridge/interfaces/ILibp2pComponent.ts

/**
 * Core libp2p component interfaces
 */

export interface PeerId {
  toString(): string;
  toBytes(): Uint8Array;
  equals(other: PeerId): boolean;
}

export interface Multiaddr {
  toString(): string;
  bytes: Uint8Array;
  protos(): Array<{ code: number; name: string }>;
  getPeerId(): string | null;
}

export interface Connection {
  id: string;
  remotePeer: PeerId;
  remoteAddr: Multiaddr;
  stat: {
    direction: 'inbound' | 'outbound';
    status: 'pending' | 'open' | 'closing' | 'closed';
    timeline: {
      open: number;
      upgraded?: number;
      close?: number;
    };
  };
}

export interface PeerInfo {
  id: PeerId;
  multiaddrs: Multiaddr[];
  metadata?: {
    userId?: string;
    deviceName?: string;
    source?: string;
    [key: string]: any;
  };
}

export interface ProtocolHandler {
  protocolId: string;
  handler: (data: { peerId: string; data?: Uint8Array }) => void | Promise<void>;
}

export interface ILibp2pComponent {
  peerId: PeerId | null;
  multiaddrs: Multiaddr[];
  isStarted: boolean;
  isStarting: boolean;
  error: string | null;

  start(): Promise<void>;
  stop(): Promise<void>;
  dial(multiaddr: string): Promise<Connection>;
  hangUp(peerId: string): Promise<void>;
  getConnections(peerId?: string): Promise<Connection[]>;
  sendProtocolData(peerId: string, protocolId: string, data: Uint8Array): Promise<void>;
  refreshDiscovery(): Promise<void>;
  pingPeer(peerId: string): Promise<{ success: boolean; rtt?: number; peerId: string }>;
  acceptConnection(peerId: string): Promise<void>;
  rejectConnection(peerId: string): Promise<void>;
  cleanup(): void;

  addEventListener<K extends keyof Libp2pEvents>(
    event: K,
    handler: (evt: Libp2pEvents[K]) => void,
  ): void;

  removeEventListener<K extends keyof Libp2pEvents>(
    event: K,
    handler: (evt: Libp2pEvents[K]) => void,
  ): void;
}

export interface Libp2pEvents {
  'peer:discovery': CustomEvent<PeerInfo>;
  'peer:lost': CustomEvent<{ id: PeerId }>;
  'peer:connect': CustomEvent<Connection>;
  'peer:disconnect': CustomEvent<Connection>;
  'connection:open': CustomEvent<Connection>;
  'connection:close': CustomEvent<Connection>;
  'self:peer:update': CustomEvent<{ peerId: PeerId; multiaddrs: Multiaddr[] }>;
  'multiaddresses:changed': CustomEvent<{ multiaddrs: Multiaddr[] }>;
}

export interface Libp2pOptions {
  config?: {
    tcpPort?: number;
    wsPort?: number;
  };
  protocols?: ProtocolHandler[];
  keypair?: {
    privateKey: Uint8Array;
    publicKey: Uint8Array;
  };
}