Overview

The DragonFire RWT (Rotational WebSockets) Client SDK enables secure, high-performance connections to DragonFire services using our proprietary Rotational WebSockets protocol. This protocol combines secure token authentication with advanced socket management for optimal data transmission.

Installation

Install the RWT Client SDK using npm or yarn:

npm install @dragonfire/rwt-client

yarn add @dragonfire/rwt-client

Or include it directly in your HTML:

<script src="https://cdn.dragonfire1.com/sdk/rwt-client-0.9.2.js"></script>

Authentication

The RWT Client SDK uses rotating tokens for authentication to DragonFire services. You'll need to obtain API credentials from the Developer Portal.

Initializing with credentials

import { RWTClient } from '@dragonfire/rwt-client';

// Initialize with API key
const rwtClient = new RWTClient({
  apiKey: 'your-api-key',
  region: 'us-west'
});

Connecting to Services

After initializing the client, you can connect to specific DragonFire services:

// Connect to a service
await rwtClient.connect('cache-service');

// Connect with options
await rwtClient.connect('compute-service', {
  rotationInterval: 60000, // 60 seconds
  maxRetries: 5,
  protocol: 'phi'  // Use phi-resonant protocol
});

Connection Events

Listen for connection events:

rwtClient.on('connected', () => {
  console.log('Connected to DragonFire service');
});

rwtClient.on('disconnected', (reason) => {
  console.log(`Disconnected: ${reason}`);
});

rwtClient.on('error', (error) => {
  console.error('Connection error:', error);
});

Data Transfer

Send and receive data through the RWT connection:

// Send data to the service
rwtClient.send('compute-task', {
  operation: 'fractal-transform',
  data: [1, 1, 2, 3, 5, 8, 13],
  options: {
    precision: 'high'
  }
});

// Receive data from the service
rwtClient.on('message', (channel, data) => {
  console.log(`Received message on ${channel}:`, data);
});

Channels and Topics

RWT uses channels and topics for organized communication:

// Subscribe to a specific channel
rwtClient.subscribe('computation-results');

// Subscribe with a callback
rwtClient.subscribe('status-updates', (data) => {
  updateStatus(data);
});

// Unsubscribe when done
rwtClient.unsubscribe('computation-results');

Error Handling

The SDK provides robust error handling capabilities:

try {
  await rwtClient.connect('service-name');
} catch (error) {
  if (error.code === 'AUTH_FAILED') {
    // Handle authentication failure
  } else if (error.code === 'SERVICE_UNAVAILABLE') {
    // Handle service availability issues
  } else {
    // Handle other errors
  }
}

Error Codes

Code Examples

Complete Connection Example

import { RWTClient } from '@dragonfire/rwt-client';

async function connectToService() {
  // Initialize client
  const rwtClient = new RWTClient({
    apiKey: 'your-api-key',
    region: 'us-west'
  });
  
  // Set up event listeners
  rwtClient.on('connected', () => {
    console.log('Connected successfully');
  });
  
  rwtClient.on('message', (channel, data) => {
    console.log(`Received on ${channel}:`, data);
  });
  
  rwtClient.on('error', (error) => {
    console.error('Error:', error);
  });
  
  try {
    // Connect to the service
    await rwtClient.connect('data-processing');
    
    // Subscribe to channels
    rwtClient.subscribe('processing-updates');
    rwtClient.subscribe('system-status');
    
    // Send a request
    rwtClient.send('data-request', {
      type: 'vector-operation',
      vectors: [[1, 2, 3], [4, 5, 6]],
      operation: 'cross-product'
    });
  } catch (error) {
    console.error('Failed to connect:', error);
  }
}

connectToService();

React Integration Example

import React, { useEffect, useState } from 'react';
import { RWTClient } from '@dragonfire/rwt-client';

function DragonFireComponent() {
  const [status, setStatus] = useState('disconnected');
  const [data, setData] = useState(null);
  const [client, setClient] = useState(null);
  
  useEffect(() => {
    // Initialize client
    const rwtClient = new RWTClient({
      apiKey: 'your-api-key',
      region: 'us-west'
    });
    
    // Set up event listeners
    rwtClient.on('connected', () => {
      setStatus('connected');
    });
    
    rwtClient.on('disconnected', () => {
      setStatus('disconnected');
    });
    
    rwtClient.on('message', (channel, receivedData) => {
      if (channel === 'results') {
        setData(receivedData);
      }
    });
    
    // Connect to service
    rwtClient.connect('real-time-data')
      .catch(error => console.error('Connection failed:', error));
    
    // Store client instance
    setClient(rwtClient);
    
    // Cleanup on unmount
    return () => {
      rwtClient.disconnect();
    };
  }, []);
  
  const sendRequest = () => {
    if (client && status === 'connected') {
      client.send('request', { type: 'data-query', parameters: { limit: 10 } });
    }
  };
  
  return (
    

      

        Status: {status}
      
      
      
        Request Data
      
      
      {data && (
        

          
Received Data:
          
{JSON.stringify(data, null, 2)}
        
      )}
    
  );
}

export default DragonFireComponent;