header.payload.signature

import { RWT } from 'dragonstream-sdk';
import express from 'express';

const app = express();

// RWT authentication middleware
function rwtAuth(req, res, next) {
  const authHeader = req.headers.authorization;
  if (!authHeader || !authHeader.startsWith('RWT ')) {
    return res.status(401).json({ error: 'Missing or invalid authorization header' });
  }
  
  const token = authHeader.split(' ')[1];
  const userKey = getUserKeyFromDatabase(req.params.userId); // Your function to get UserKey
  
  if (!RWT.verify(token, userKey)) {
    return res.status(401).json({ error: 'Invalid or expired token' });
  }
  
  // Set decoded token information for route handlers
  req.rwt = RWT.decode(token);
  next();
}

// Protected route
app.get('/api/protected', rwtAuth, (req, res) => {
  res.json({ data: 'Protected data', user: req.rwt.payload.meta.userId });
});

// api.js
import { RWT } from 'dragonstream-sdk';

// Stored securely in localStorage or a more secure alternative
const userKey = localStorage.getItem('userKey');

export async function fetchProtectedData() {
  // Generate a new token valid for the next 15 minutes
  const token = RWT.generate(userKey, {
    releaseAt: Date.now(),
    expiresAt: Date.now() + (15 * 60 * 1000),
    meta: { userId: localStorage.getItem('userId') }
  });
  
  const response = await fetch('https://api.example.com/protected', {
    headers: {
      'Authorization': `RWT ${token}`
    }
  });
  
  return response.json();
}

import { RWT } from 'dragonstream-sdk';

// Admin creates tokens for future product drop
function createProductDropTokens(userIds, dropTime) {
  const dropTokens = {};
  
  userIds.forEach(userId => {
    const userKey = getUserKey(userId);
    dropTokens[userId] = RWT.generate(userKey, {
      releaseAt: dropTime,
      expiresAt: dropTime + (24 * 60 * 60 * 1000), // Valid for 24 hours after drop
      meta: {
        userId,
        productId: 'limited-edition-001'
      }
    });
  });
  
  return dropTokens;
}

// Frontend uses token to access product at launch time
async function purchaseProduct(token) {
  const response = await fetch('/api/purchase', {
    method: 'POST',
    headers: {
      'Authorization': `RWT ${token}`
    },
    body: JSON.stringify({
      productId: 'limited-edition-001'
    })
  });
  
  return response.json();
}

import { RWT } from 'dragonstream-sdk';

// Generate a secure download link valid for 24 hours
function generateSecureDownloadLink(fileId, userId) {
  const userKey = getUserKey(userId);
  
  const token = RWT.generate(userKey, {
    releaseAt: Date.now(),
    expiresAt: Date.now() + (24 * 60 * 60 * 1000),
    meta: {
      fileId,
      userId
    }
  });
  
  return `https://files.example.com/download/${fileId}?token=${token}`;
}

// Server-side handler validates token before serving file
function handleFileDownload(req, res) {
  const { fileId } = req.params;
  const { token } = req.query;
  const userId = extractUserIdFromToken(token); // Your function
  const userKey = getUserKey(userId);
  
  if (!RWT.verify(token, userKey)) {
    return res.status(401).send('Download link expired or invalid');
  }
  
  // Token valid, serve the file
  serveFile(res, fileId);
}

import { RWT } from 'dragonstream-sdk';

// Generate an event ticket valid only during event hours
function generateEventTicket(userId, eventId, eventStart, eventEnd) {
  const userKey = getUserKey(userId);
  
  // Valid from 1 hour before until the end of the event
  const ticketToken = RWT.generate(userKey, {
    releaseAt: eventStart - (60 * 60 * 1000), // 1 hour before event
    expiresAt: eventEnd,
    meta: {
      userId,
      eventId,
      ticketType: 'standard'
    }
  });
  
  return ticketToken;
}

// Verify ticket at event entrance
function verifyTicket(token, userId) {
  const userKey = getUserKey(userId);
  
  if (RWT.verify(token, userKey)) {
    const decoded = RWT.decode(token);
    return {
      valid: true,
      attendee: {
        userId: decoded.payload.meta.userId,
        ticketType: decoded.payload.meta.ticketType
      }
    };
  }
  
  return { valid: false };
}

import { RWT } from 'dragonstream-sdk';

// Connect to a DragonNet server
const dragonnet = new RWT.DragonNet('dragon.example.com:9001', {
  userKey: getUserKey(),
  meta: { userId: 'user123' }
});

// Send and receive messages
dragonnet.on('open', () => {
  console.log('Connected to DragonNet server');
  dragonnet.send({ type: 'greeting', message: 'Hello, server!' });
});

dragonnet.on('message', (data) => {
  console.log('Received:', data);
});

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

dragonnet.on('close', () => {
  console.log('Connection closed');
});

import { RWT } from 'dragonstream-sdk';

// Connect to the nearest GeoNet server
const geonet = new RWT.GeoNet('geo.example.com', {
  userKey: getUserKey(),
  region: 'auto', // Automatically detect closest region
  meta: { userId: 'user123' }
});

// Or specify a region
const asiaGeonet = new RWT.GeoNet('geo.example.com', {
  userKey: getUserKey(),
  region: 'asia-southeast',
  meta: { userId: 'user123' }
});

// GeoNet has the same API as DragonNet
geonet.on('open', () => {
  console.log('Connected to nearest GeoNet server');
  geonet.send({ type: 'ping' });
});

// Debug token information
console.log(RWT.debug(token));
// Outputs detailed token information including timing, verification status, etc.

// Time window analysis
console.log(RWT.getTimeWindow(token));
// Shows when token becomes valid and expires