WebSocket Streaming

enum WSEventType {
  Created = "created",
  Received = "received", 
  Completed = "completed",
  Failed = "failed"
}

interface WSEvent {
  eventType: WSEventType;
  timestamp: number;
  order: WSOrder;
}

interface WSOrder {
  orderHash: string;
  offerer: string;
  recipient: string;
  inputToken: string;
  inputAmount: string;
  inputChain: string;
  outputToken: string;
  outputAmount: string;
  outputChain: string;
  startTime: number;
  srcTx: string;
  dstTx: string;
  endTime: number;
}

import { AoriWebSocket } from '@aori/aori-ts';

const ws = new AoriWebSocket('wss://api.aori.io/stream', {
  onMessage: (event) => {
    console.log('Order event:', event.eventType);
    console.log('Order hash:', event.order.orderHash);
  },
  onConnect: () => {
    console.log('WebSocket connected');
  },
  onDisconnect: (event) => {
    console.log('WebSocket disconnected');
  },
  onError: (error) => {
    console.error('WebSocket error:', error);
  }
});

// Connect to the WebSocket
await ws.connect();

// Check connection status
console.log('Connected:', ws.isConnected());

// Disconnect when done
ws.disconnect();

import { AoriWebSocket, WSEvent } from '@aori/aori-ts';

// Create a filtered event handler
function createFilteredHandler(filters: Partial<WSEvent['order']> & { eventType?: string }) {
  return (event: WSEvent) => {
    // Filter by event type
    if (filters.eventType && event.eventType !== filters.eventType) {
      return;
    }

    // Filter by order properties
    const order = event.order;
    if (filters.orderHash && order.orderHash !== filters.orderHash) return;
    if (filters.offerer && order.offerer !== filters.offerer) return;
    if (filters.recipient && order.recipient !== filters.recipient) return;
    if (filters.inputToken && order.inputToken !== filters.inputToken) return;
    if (filters.inputChain && order.inputChain !== filters.inputChain) return;
    if (filters.outputToken && order.outputToken !== filters.outputToken) return;
    if (filters.outputChain && order.outputChain !== filters.outputChain) return;

    // Event matches filters - process it
    console.log('Filtered event:', event);
  };
}

// Example: Track specific user's completed orders
const ws = new AoriWebSocket('wss://api.aori.io/stream', {
  onMessage: createFilteredHandler({
    offerer: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b',
    eventType: 'completed'
  })
});

await ws.connect();

class WebSocketManager {
  private ws: AoriWebSocket | null = null;
  private reconnectAttempts = 0;
  private maxReconnectAttempts = 5;
  private reconnectDelay = 1000;
  private reconnectTimeout: NodeJS.Timeout | null = null;

  async connect(url: string, onEvent: (event: WSEvent) => void, apiKey?: string) {
    try {
      this.ws = new AoriWebSocket(url, {
        onMessage: onEvent,
        onConnect: () => {
          console.log('WebSocket connected');
          this.reconnectAttempts = 0;
        },
        onDisconnect: () => {
          console.log('WebSocket disconnected');
          this.attemptReconnect(url, onEvent, apiKey);
        },
        onError: this.handleError.bind(this)
      }, apiKey);

      await this.ws.connect();
    } catch (error) {
      this.handleError(error as Event);
    }
  }

  private attemptReconnect(url: string, onEvent: (event: WSEvent) => void, apiKey?: string) {
    if (this.reconnectAttempts < this.maxReconnectAttempts) {
      this.reconnectAttempts++;
      const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
      
      this.reconnectTimeout = setTimeout(() => {
        console.log(`Reconnecting... (attempt ${this.reconnectAttempts})`);
        this.connect(url, onEvent, apiKey);
      }, delay);
    } else {
      console.error('Max reconnection attempts reached');
    }
  }

  private handleError(error: Event) {
    console.error('WebSocket error:', error);
  }

  disconnect() {
    if (this.reconnectTimeout) {
      clearTimeout(this.reconnectTimeout);
      this.reconnectTimeout = null;
    }
    
    if (this.ws) {
      this.ws.disconnect();
      this.ws = null;
    }
  }
}

// Usage
const manager = new WebSocketManager();
await manager.connect('wss://api.aori.io/stream', (event) => {
  console.log('Event received:', event);
}, 'your-api-key');