Chain Synchronization

1. Connect via WebSocket
2. Find an intersection point
3. Request blocks with nextBlock
4. Process each block (forward or rollback)
5. Repeat step 3

// Start from genesis (sync entire chain)
{ "points": ["origin"] }

// Start from a specific block
{
  "points": [
    { "slot": 12345678, "id": "abc123..." }
  ]
}

// Try multiple points (node picks best match)
{
  "points": [
    { "slot": 12345678, "id": "abc123..." },
    { "slot": 12345600, "id": "def456..." },
    "origin"
  ]
}

function handleBlock(result) {
  if (result.direction === 'forward') {
    // New block - add to your state
    applyBlock(result.block);
  } else if (result.direction === 'backward') {
    // Rollback - undo blocks back to this point
    rollbackTo(result.point);
  }
}

function rollbackTo(point) {
  // Remove any blocks after this point
  // Re-process transactions that were in rolled-back blocks
  console.log(`Rolling back to slot ${point.slot}`);
}

const watchedAddresses = new Set([
  'addr1...',
  'addr1...'
]);

function processTransaction(tx) {
  // Check outputs
  tx.outputs?.forEach((output, index) => {
    if (watchedAddresses.has(output.address)) {
      console.log(`Incoming transaction to ${output.address}`);
      console.log(`  TxHash: ${tx.id}`);
      console.log(`  Amount: ${output.value.ada.lovelace} lovelace`);

      // Emit notification, update database, etc.
      notifyIncoming(tx.id, output);
    }
  });

  // Check inputs (for outgoing)
  tx.inputs?.forEach(input => {
    // You'd need to look up the input's address
    // from your local UTxO tracking
  });
}

// Number of concurrent requests to keep in flight
// Higher = faster sync, but uses more memory
const PIPELINE_DEPTH = 100;
let pending = 0;  // Track how many requests are awaiting responses

function requestBlocks(count) {
  // Send multiple nextBlock requests without waiting for responses
  for (let i = 0; i < count; i++) {
    ws.send(JSON.stringify({
      jsonrpc: '2.0',
      method: 'nextBlock',
      id: `block-${Date.now()}-${i}`  // Unique ID for each request
    }));
    pending++;
  }
}

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);

  // Check if this is a block response (not intersection)
  if (data.result?.block || data.result?.direction) {
    handleBlock(data.result);
    pending--;  // One response received

    // Refill the pipeline when it drops below half capacity
    // This keeps blocks streaming in continuously
    if (pending < PIPELINE_DEPTH / 2) {
      requestBlocks(PIPELINE_DEPTH - pending);
    }
  }
};

// Initial setup
ws.onopen = () => {
  findIntersection();
  // After intersection found, fill the pipeline to start fast sync
};

/**
 * Chain sync client with automatic reconnection.
 * Tracks last processed block to resume from the correct point.
 */
class ResilientChainSync {
  constructor(apiKey, onBlock) {
    this.apiKey = apiKey;
    this.onBlock = onBlock;
    // Store the last processed block point for resuming after reconnect
    this.lastPoint = null;
    this.connect();
  }

  connect() {
    this.ws = new WebSocket(
      `wss://api.nacho.builders/v1/ogmios?apikey=${this.apiKey}`
    );

    this.ws.onopen = () => {
      // On reconnect, try to resume from last known point
      // Falls back to 'origin' if no previous state
      const points = this.lastPoint
        ? [this.lastPoint, 'origin']  // Try last point first, then origin
        : ['origin'];                  // First connection - start from genesis

      this.ws.send(JSON.stringify({
        jsonrpc: '2.0',
        method: 'findIntersection',
        params: { points }
      }));
    };

    this.ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      if (data.result?.block) {
        // Save this block as our resume point for reconnection
        this.lastPoint = {
          slot: data.result.block.slot,
          id: data.result.block.id
        };
        // Pass block to handler
        this.onBlock(data.result.block);
      }
      // Continue the sync loop
      this.requestNext();
    };

    this.ws.onclose = () => {
      // Connection lost - schedule reconnection
      // Production apps should use exponential backoff
      console.log('Connection closed, reconnecting in 5s...');
      setTimeout(() => this.connect(), 5000);
    };

    this.ws.onerror = (error) => {
      console.error('WebSocket error:', error);
      // Error will trigger onclose, which handles reconnection
    };
  }

  requestNext() {
    // Only send if connection is open (prevents errors during reconnect)
    if (this.ws.readyState === WebSocket.OPEN) {
      this.ws.send(JSON.stringify({
        jsonrpc: '2.0',
        method: 'nextBlock'
      }));
    }
  }
}