@xtr-dev/rondevu-client 0.7.12 → 0.8.1

package/dist/usernames.js

@@ -0,0 +1,147 @@
+import * as ed25519 from '@noble/ed25519';
+/**
+ * Convert Uint8Array to base64 string
+ */
+function bytesToBase64(bytes) {
+    const binString = Array.from(bytes, (byte) => String.fromCodePoint(byte)).join('');
+    return btoa(binString);
+}
+/**
+ * Convert base64 string to Uint8Array
+ */
+function base64ToBytes(base64) {
+    const binString = atob(base64);
+    return Uint8Array.from(binString, (char) => char.codePointAt(0));
+}
+/**
+ * Rondevu Username API
+ * Handles username claiming with Ed25519 cryptographic proof
+ */
+export class RondevuUsername {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    /**
+     * Generates an Ed25519 keypair for username claiming
+     */
+    async generateKeypair() {
+        const privateKey = ed25519.utils.randomSecretKey();
+        const publicKey = await ed25519.getPublicKey(privateKey);
+        return {
+            publicKey: bytesToBase64(publicKey),
+            privateKey: bytesToBase64(privateKey)
+        };
+    }
+    /**
+     * Signs a message with an Ed25519 private key
+     */
+    async signMessage(message, privateKeyBase64) {
+        const privateKey = base64ToBytes(privateKeyBase64);
+        const encoder = new TextEncoder();
+        const messageBytes = encoder.encode(message);
+        const signature = await ed25519.sign(messageBytes, privateKey);
+        return bytesToBase64(signature);
+    }
+    /**
+     * Claims a username
+     * Generates a new keypair if one is not provided
+     */
+    async claimUsername(username, existingKeypair) {
+        // Generate or use existing keypair
+        const keypair = existingKeypair || await this.generateKeypair();
+        // Create signed message
+        const timestamp = Date.now();
+        const message = `claim:${username}:${timestamp}`;
+        const signature = await this.signMessage(message, keypair.privateKey);
+        // Send claim request
+        const response = await fetch(`${this.baseUrl}/usernames/claim`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                username,
+                publicKey: keypair.publicKey,
+                signature,
+                message
+            })
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.error || 'Failed to claim username');
+        }
+        const data = await response.json();
+        return {
+            username: data.username,
+            publicKey: keypair.publicKey,
+            privateKey: keypair.privateKey,
+            claimedAt: data.claimedAt,
+            expiresAt: data.expiresAt
+        };
+    }
+    /**
+     * Checks if a username is available
+     */
+    async checkUsername(username) {
+        const response = await fetch(`${this.baseUrl}/usernames/${username}`);
+        if (!response.ok) {
+            throw new Error('Failed to check username');
+        }
+        const data = await response.json();
+        return {
+            username: data.username,
+            available: data.available,
+            claimedAt: data.claimedAt,
+            expiresAt: data.expiresAt,
+            publicKey: data.publicKey
+        };
+    }
+    /**
+     * Helper: Save keypair to localStorage
+     * WARNING: This stores the private key in localStorage which is not the most secure
+     * For production use, consider using IndexedDB with encryption or hardware security modules
+     */
+    saveKeypairToStorage(username, publicKey, privateKey) {
+        const data = { username, publicKey, privateKey, savedAt: Date.now() };
+        localStorage.setItem(`rondevu:keypair:${username}`, JSON.stringify(data));
+    }
+    /**
+     * Helper: Load keypair from localStorage
+     */
+    loadKeypairFromStorage(username) {
+        const stored = localStorage.getItem(`rondevu:keypair:${username}`);
+        if (!stored)
+            return null;
+        try {
+            const data = JSON.parse(stored);
+            return { publicKey: data.publicKey, privateKey: data.privateKey };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Helper: Delete keypair from localStorage
+     */
+    deleteKeypairFromStorage(username) {
+        localStorage.removeItem(`rondevu:keypair:${username}`);
+    }
+    /**
+     * Export keypair as JSON string (for backup)
+     */
+    exportKeypair(publicKey, privateKey) {
+        return JSON.stringify({
+            publicKey,
+            privateKey,
+            exportedAt: Date.now()
+        });
+    }
+    /**
+     * Import keypair from JSON string
+     */
+    importKeypair(json) {
+        const data = JSON.parse(json);
+        if (!data.publicKey || !data.privateKey) {
+            throw new Error('Invalid keypair format');
+        }
+        return { publicKey: data.publicKey, privateKey: data.privateKey };
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.7.12",
-  "description": "TypeScript client for Rondevu topic-based peer discovery and signaling server",
+  "version": "0.8.1",
+  "description": "TypeScript client for Rondevu DNS-like WebRTC with username claiming and service discovery",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,6 +27,6 @@
     "README.md"
   ],
   "dependencies": {
-    "@xtr-dev/rondevu-client": "^0.5.1"
+    "@noble/ed25519": "^3.0.0"
   }
 }