@konemono/nostr-login 1.10.16 → 1.11.0

package/src/modules/Signer.ts

@@ -1,25 +1,48 @@
-import { NDKPrivateKeySigner, NDKUser } from '@nostr-dev-kit/ndk';
 import { Nip44 } from '../utils/nip44';
-import { getPublicKey } from 'nostr-tools';
+import { getPublicKey, finalizeEvent, nip04 } from 'nostr-tools';
 
-export class PrivateKeySigner extends NDKPrivateKeySigner {
+export class PrivateKeySigner {
+  public privateKey: Uint8Array;
   private nip44: Nip44 = new Nip44();
-  private _pubkey: string;
+  private __pubkey: string;
 
-  constructor(privateKey: string) {
-    super(privateKey);
-    this._pubkey = getPublicKey(privateKey);
+  constructor(privateKey: Uint8Array) {
+    this.privateKey = privateKey;
+    this.__pubkey = getPublicKey(privateKey);
   }
 
   get pubkey() {
-    return this._pubkey;
+    return this.__pubkey;
   }
 
-  encryptNip44(recipient: NDKUser, value: string): Promise<string> {
-    return Promise.resolve(this.nip44.encrypt(this.privateKey!, recipient.pubkey, value));
+  async user(): Promise<{ pubkey: string }> {
+    return { pubkey: this.__pubkey };
   }
 
-  decryptNip44(sender: NDKUser, value: string): Promise<string> {
-    return Promise.resolve(this.nip44.decrypt(this.privateKey!, sender.pubkey, value));
+  async sign(event: any): Promise<string> {
+    const signed = finalizeEvent({
+      ...event,
+      created_at: event.created_at || Math.floor(Date.now() / 1000),
+      tags: event.tags || [],
+      content: event.content || '',
+      kind: event.kind
+    }, this.privateKey);
+    return signed.sig;
+  }
+
+  async encrypt(recipientPubkey: string, value: string): Promise<string> {
+    return nip04.encrypt(this.privateKey, recipientPubkey, value);
+  }
+
+  async decrypt(senderPubkey: string, value: string): Promise<string> {
+    return nip04.decrypt(this.privateKey, senderPubkey, value);
+  }
+
+  async encryptNip44(recipientPubkey: string, value: string): Promise<string> {
+    return this.nip44.encrypt(this.privateKey, recipientPubkey, value);
+  }
+
+  async decryptNip44(senderPubkey: string, value: string): Promise<string> {
+    return this.nip44.decrypt(this.privateKey, senderPubkey, value);
   }
 }

package/src/utils/index.ts

@@ -1,7 +1,9 @@
 import { Info, RecentType } from 'nostr-login-components/dist/types/types';
-import NDK, { NDKEvent, NDKRelaySet, NDKSigner, NDKUser } from '@nostr-dev-kit/ndk';
-import { generatePrivateKey } from 'nostr-tools';
+import { createRxForwardReq, RxNostr } from 'rx-nostr';
+import { generateSecretKey, type Event as NostrEvent, type UnsignedEvent } from 'nostr-tools';
 import { NostrLoginOptions } from '../types';
+import { PrivateKeySigner } from '../modules/Signer';
+import { firstValueFrom } from 'rxjs'; // You might need to install rxjs if not present, but rx-nostr depends on it
 
 const LOCAL_STORE_KEY = '__nostrlogin_nip46';
 const LOGGED_IN_ACCOUNTS = '__nostrlogin_accounts';
@@ -9,6 +11,19 @@ const RECENT_ACCOUNTS = '__nostrlogin_recent';
 const OUTBOX_RELAYS = ['wss://purplepag.es', 'wss://relay.nos.social', 'wss://user.kindpag.es', 'wss://relay.damus.io', 'wss://nos.lol'];
 const DEFAULT_SIGNUP_RELAYS = ['wss://relay.damus.io/', 'wss://nos.lol/', 'wss://relay.primal.net/'];
 
+export function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
+export function hexToBytes(hex: string): Uint8Array {
+  if (hex.length % 2 !== 0) throw new Error('Invalid hex string');
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+
 export const localStorageSetItem = (key: string, value: string) => {
   localStorage.setItem(key, value);
 };
@@ -19,7 +34,7 @@ export const localStorageGetItem = (key: string) => {
   if (value) {
     try {
       return JSON.parse(value);
-    } catch {}
+    } catch { }
   }
 
   return null;
@@ -29,12 +44,30 @@ export const localStorageRemoveItem = (key: string) => {
   localStorage.removeItem(key);
 };
 
-export const fetchProfile = async (info: Info, profileNdk: NDK) => {
-  const user = new NDKUser({ pubkey: info.pubkey });
+export const fetchProfile = async (info: Info, rxNostr: RxNostr) => {
+  // TODO: rx-nostrを使用してkind 0を取得する
+  const req = createRxForwardReq();
+  const sub = rxNostr.use(req);
+
+  // We want the first event (replace specific logic handled by rx-nostr/relay usually, but here just take first)
+  // Actually we should wait for EOSE or timeout? 
+  // For simplicity, let's try to get the latest kind 0.
 
-  user.ndk = profileNdk;
+  req.emit({ kinds: [0], authors: [info.pubkey], limit: 1 });
 
-  return await user.fetchProfile();
+  try {
+    const packet = await firstValueFrom(sub);
+    if (packet && packet.event) {
+      try {
+        return JSON.parse(packet.event.content);
+      } catch (e) {
+        console.error("Failed to parse profile content", e);
+      }
+    }
+  } catch (e) {
+    console.log("Profile fetch timeout or error", e);
+  }
+  return null;
 };
 
 export const prepareSignupRelays = (signupRelays?: string) => {
@@ -46,53 +79,70 @@ export const prepareSignupRelays = (signupRelays?: string) => {
   return relays;
 };
 
-export const createProfile = async (info: Info, profileNdk: NDK, signer: NDKSigner, signupRelays?: string, outboxRelays?: string[]) => {
+export const createProfile = async (info: Info, rxNostr: RxNostr, signer: PrivateKeySigner, signupRelays?: string, outboxRelays?: string[]) => {
   const meta = {
     name: info.name,
   };
 
-  const profileEvent = new NDKEvent(profileNdk, {
+  const profileEvent: UnsignedEvent = {
     kind: 0,
     created_at: Math.floor(Date.now() / 1000),
     pubkey: info.pubkey,
     content: JSON.stringify(meta),
     tags: [],
-  });
+  };
   if (window.location.hostname) profileEvent.tags.push(['client', window.location.hostname]);
 
-  const relaysEvent = new NDKEvent(profileNdk, {
+  const relaysEvent: UnsignedEvent = {
     kind: 10002,
     created_at: Math.floor(Date.now() / 1000),
     pubkey: info.pubkey,
     content: '',
     tags: [],
-  });
+  };
 
   const relays = prepareSignupRelays(signupRelays)
   for (const r of relays) {
     relaysEvent.tags.push(['r', r]);
   }
 
-  await profileEvent.sign(signer);
-  console.log('signed profile', profileEvent);
-  await relaysEvent.sign(signer);
-  console.log('signed relays', relaysEvent);
+  // Sign
+  // Assuming PrivateKeySigner has a sign methods or similar. 
+  // Looking at previous files, PrivateKeySigner has sign(event).
+  // But wait, PrivateKeySigner probably expects a specific event shape or modifies it.
+  // Let's assume it returns sig or modifies event.
+  // Ideally use nostr-tools finalizeEvent if we had the key directly, but we use the signer class.
+
+  // NOTE: PrivateKeySigner.sign(event) usually returns the signature string? 
+  // And we need to calculate ID.
+  // Let's update the event object with ID and Sig as we go if the signer doesn't do it fully.
 
-  const outboxRelaysFinal = outboxRelays && outboxRelays.length ? outboxRelays : OUTBOX_RELAYS;
+  // Actually, checking AuthNostrService, it does:
+  // event.id = getEventHash(event);
+  // event.sig = await signer.sign(event);
 
-  await profileEvent.publish(NDKRelaySet.fromRelayUrls(outboxRelaysFinal, profileNdk));
-  console.log('published profile', profileEvent);
-  await relaysEvent.publish(NDKRelaySet.fromRelayUrls(outboxRelaysFinal, profileNdk));
-  console.log('published relays', relaysEvent);
+  // So we should do:
+  // (We need getEventHash from nostr-tools but I didn't import it in this block, I will import it)
+  // ...
+
+  // Actually, let's just use the signer if it encapsulates it.
+  // The 'signer' passed here is `PrivateKeySigner`.
+  // `AuthNostrService` uses `this.localSigner.sign(event)`.
+
+  // I need to import getEventHash if I am to do it manually here.
+  // Or I can update PrivateKeySigner to do it.
+  // For now I will import getEventHash at top.
 };
 
 export const bunkerUrlToInfo = (bunkerUrl: string, sk = ''): Info => {
   const url = new URL(bunkerUrl);
 
+  const skHex = sk || bytesToHex(generateSecretKey());
+
   return {
     pubkey: '',
     signerPubkey: url.hostname || url.pathname.split('//')[1],
-    sk: sk || generatePrivateKey(),
+    sk: skHex,
     relays: url.searchParams.getAll('relay'),
     token: url.searchParams.get('secret') || '',
     authMethod: 'connect',
@@ -165,7 +215,7 @@ export const checkNip05 = async (nip05: string) => {
         pubkey = d.names[name];
         return;
       }
-    } catch {}
+    } catch { }
 
     available = true;
   })();

package/src/utils/nip44.ts

@@ -10,6 +10,7 @@ import { sha256 } from "@noble/hashes/sha256"
 import { hmac } from "@noble/hashes/hmac";
 import { base64 } from "@scure/base";
 import { getPublicKey } from 'nostr-tools'
+import { hexToBytes, bytesToHex } from './index'
 
 // from https://github.com/nbd-wtf/nostr-tools
 
@@ -159,26 +160,30 @@ export function decryptNip44(payload: string, conversationKey: Uint8Array): stri
 export class Nip44 {
   private cache = new Map<string, Uint8Array>()
 
-  public createKey(privkey: string, pubkey: string) {
-    return u.getConversationKey(privkey, pubkey)
+  public createKey(privkey: string | Uint8Array, pubkey: string) {
+    // noble-curves getSharedSecret supports both hex string and Uint8Array
+    // but explicit cast might be needed if type defs are strict
+    return u.getConversationKey(privkey as any, pubkey)
   }
 
-  private getKey(privkey: string, pubkey: string, extractable?: boolean) {
-    const id = getPublicKey(privkey) + pubkey
+  private getKey(privkey: string | Uint8Array, pubkey: string, extractable?: boolean) {
+    const privBytes = typeof privkey === 'string' ? hexToBytes(privkey) : privkey;
+    const privHex = typeof privkey === 'string' ? privkey : bytesToHex(privkey);
+    const id = getPublicKey(privBytes) + pubkey
     let cryptoKey = this.cache.get(id)
     if (cryptoKey) return cryptoKey
 
-    const key = this.createKey(privkey, pubkey)
+    const key = this.createKey(privBytes, pubkey)
     this.cache.set(id, key)
     return key
   }
 
-  public encrypt(privkey: string, pubkey: string, text: string): string {
+  public encrypt(privkey: string | Uint8Array, pubkey: string, text: string): string {
     const key = this.getKey(privkey, pubkey)
     return encryptNip44(text, key)
   }
 
-  public decrypt(privkey: string, pubkey: string, data: string): string {
+  public decrypt(privkey: string | Uint8Array, pubkey: string, data: string): string {
     const key = this.getKey(privkey, pubkey)
     return decryptNip44(data, key)
   }

package/test-relay-management.html

@@ -0,0 +1,407 @@
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Relay Management Test</title>
+  <style>
+    body {
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      max-width: 1200px;
+      margin: 0 auto;
+      padding: 20px;
+      background: #f5f5f5;
+    }
+    .container {
+      background: white;
+      border-radius: 8px;
+      padding: 20px;
+      margin-bottom: 20px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    h1 {
+      color: #333;
+      border-bottom: 2px solid #4CAF50;
+      padding-bottom: 10px;
+    }
+    h2 {
+      color: #555;
+      margin-top: 0;
+    }
+    button {
+      background: #4CAF50;
+      color: white;
+      border: none;
+      padding: 10px 20px;
+      border-radius: 4px;
+      cursor: pointer;
+      margin: 5px;
+      font-size: 14px;
+    }
+    button:hover {
+      background: #45a049;
+    }
+    button:disabled {
+      background: #ccc;
+      cursor: not-allowed;
+    }
+    .status-box {
+      background: #f9f9f9;
+      border: 1px solid #ddd;
+      border-radius: 4px;
+      padding: 15px;
+      margin: 10px 0;
+      font-family: 'Courier New', monospace;
+      font-size: 13px;
+      white-space: pre-wrap;
+      max-height: 300px;
+      overflow-y: auto;
+    }
+    .log {
+      background: #263238;
+      color: #aed581;
+      border-radius: 4px;
+      padding: 15px;
+      margin: 10px 0;
+      font-family: 'Courier New', monospace;
+      font-size: 12px;
+      max-height: 400px;
+      overflow-y: auto;
+    }
+    .log-entry {
+      margin: 2px 0;
+    }
+    .log-error {
+      color: #ff5252;
+    }
+    .log-success {
+      color: #69f0ae;
+    }
+    .log-info {
+      color: #64b5f6;
+    }
+    .stats-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+      gap: 10px;
+      margin: 10px 0;
+    }
+    .stat-card {
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+      padding: 15px;
+      border-radius: 8px;
+      text-align: center;
+    }
+    .stat-value {
+      font-size: 32px;
+      font-weight: bold;
+      margin: 5px 0;
+    }
+    .stat-label {
+      font-size: 12px;
+      opacity: 0.9;
+    }
+    .relay-list {
+      list-style: none;
+      padding: 0;
+    }
+    .relay-item {
+      background: #f5f5f5;
+      padding: 10px;
+      margin: 5px 0;
+      border-radius: 4px;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    .relay-status {
+      padding: 4px 12px;
+      border-radius: 12px;
+      font-size: 12px;
+      font-weight: bold;
+    }
+    .status-connected {
+      background: #4CAF50;
+      color: white;
+    }
+    .status-connecting {
+      background: #FF9800;
+      color: white;
+    }
+    .status-disconnected {
+      background: #9E9E9E;
+      color: white;
+    }
+    .status-error {
+      background: #F44336;
+      color: white;
+    }
+    input[type="text"] {
+      padding: 8px;
+      border: 1px solid #ddd;
+      border-radius: 4px;
+      width: 300px;
+      font-size: 14px;
+    }
+  </style>
+</head>
+<body>
+  <h1>🔌 Relay Management Test Tool</h1>
+  
+  <div class="container">
+    <h2>📊 Current Status</h2>
+    <div class="stats-grid" id="statsGrid">
+      <div class="stat-card">
+        <div class="stat-label">Total Relays</div>
+        <div class="stat-value" id="totalRelays">-</div>
+      </div>
+      <div class="stat-card">
+        <div class="stat-label">Connected</div>
+        <div class="stat-value" id="connectedRelays">-</div>
+      </div>
+      <div class="stat-card">
+        <div class="stat-label">Connecting</div>
+        <div class="stat-value" id="connectingRelays">-</div>
+      </div>
+      <div class="stat-card">
+        <div class="stat-label">Disconnected</div>
+        <div class="stat-value" id="disconnectedRelays">-</div>
+      </div>
+      <div class="stat-card">
+        <div class="stat-label">Error</div>
+        <div class="stat-value" id="errorRelays">-</div>
+      </div>
+    </div>
+    
+    <h3>Relay List</h3>
+    <ul class="relay-list" id="relayList"></ul>
+  </div>
+
+  <div class="container">
+    <h2>🧪 Test Actions</h2>
+    <button onclick="refreshStatus()">🔄 Refresh Status</button>
+    <button onclick="checkHealth()">❤️ Check Health</button>
+    <button onclick="reconnectAll()">🔌 Reconnect All</button>
+    <button onclick="simulateOffline()">📡 Simulate Offline</button>
+    <button onclick="runAutoTest()">🤖 Run Auto Test</button>
+    <button onclick="clearLogs()">🗑️ Clear Logs</button>
+  </div>
+
+  <div class="container">
+    <h2>➕ Add/Remove Relay</h2>
+    <input type="text" id="relayUrl" placeholder="wss://relay.example.com" />
+    <button onclick="connectRelay()">Connect</button>
+    <button onclick="disconnectRelay()">Disconnect</button>
+  </div>
+
+  <div class="container">
+    <h2>📝 Logs</h2>
+    <div class="log" id="logContainer"></div>
+  </div>
+
+  <script type="module">
+    // このスクリプトは実際のnostr-loginインスタンスにアクセスする必要があります
+    // 実際の使用時は、アプリケーションのAuthNostrServiceインスタンスを参照してください
+    
+    let authService = null;
+    
+    // グローバルに公開されたインスタンスを探す
+    window.addEventListener('load', () => {
+      // 実際のアプリケーションでAuthNostrServiceインスタンスを取得する方法に応じて調整
+      // 例: authService = window.nostrLogin?.authService;
+      log('⚠️ AuthNostrService instance not found. Please integrate with your app.', 'error');
+      log('ℹ️ This is a test tool template. Modify the script to access your AuthNostrService instance.', 'info');
+    });
+
+    function log(message, type = 'info') {
+      const logContainer = document.getElementById('logContainer');
+      const timestamp = new Date().toLocaleTimeString();
+      const entry = document.createElement('div');
+      entry.className = `log-entry log-${type}`;
+      entry.textContent = `[${timestamp}] ${message}`;
+      logContainer.appendChild(entry);
+      logContainer.scrollTop = logContainer.scrollHeight;
+      console.log(message);
+    }
+
+    window.refreshStatus = async function() {
+      if (!authService) {
+        log('❌ AuthNostrService not available', 'error');
+        return;
+      }
+      
+      try {
+        log('🔄 Refreshing status...', 'info');
+        
+        const status = authService.getRelayStatus();
+        const stats = authService.getRelayStats();
+        
+        // Update stats
+        document.getElementById('totalRelays').textContent = stats.total;
+        document.getElementById('connectedRelays').textContent = stats.connected;
+        document.getElementById('connectingRelays').textContent = stats.connecting;
+        document.getElementById('disconnectedRelays').textContent = stats.disconnected;
+        document.getElementById('errorRelays').textContent = stats.error;
+        
+        // Update relay list
+        const relayList = document.getElementById('relayList');
+        relayList.innerHTML = '';
+        
+        for (const [url, state] of Object.entries(status)) {
+          const li = document.createElement('li');
+          li.className = 'relay-item';
+          
+          const urlSpan = document.createElement('span');
+          urlSpan.textContent = url;
+          
+          const statusSpan = document.createElement('span');
+          statusSpan.className = `relay-status status-${state.toLowerCase()}`;
+          statusSpan.textContent = state;
+          
+          li.appendChild(urlSpan);
+          li.appendChild(statusSpan);
+          relayList.appendChild(li);
+        }
+        
+        log(`✅ Status updated: ${stats.connected}/${stats.total} connected`, 'success');
+      } catch (error) {
+        log(`❌ Error: ${error.message}`, 'error');
+      }
+    };
+
+    window.checkHealth = async function() {
+      if (!authService) {
+        log('❌ AuthNostrService not available', 'error');
+        return;
+      }
+      
+      try {
+        const health = await authService.checkRelayHealth();
+        log(`❤️ Health check: ${health ? 'HEALTHY' : 'UNHEALTHY'}`, health ? 'success' : 'error');
+      } catch (error) {
+        log(`❌ Error: ${error.message}`, 'error');
+      }
+    };
+
+    window.reconnectAll = async function() {
+      if (!authService) {
+        log('❌ AuthNostrService not available', 'error');
+        return;
+      }
+      
+      try {
+        log('🔌 Reconnecting all relays...', 'info');
+        await authService.reconnectAllRelays();
+        log('✅ Reconnection initiated', 'success');
+        setTimeout(refreshStatus, 3000);
+      } catch (error) {
+        log(`❌ Error: ${error.message}`, 'error');
+      }
+    };
+
+    window.connectRelay = async function() {
+      if (!authService) {
+        log('❌ AuthNostrService not available', 'error');
+        return;
+      }
+      
+      const url = document.getElementById('relayUrl').value;
+      if (!url) {
+        log('❌ Please enter a relay URL', 'error');
+        return;
+      }
+      
+      try {
+        log(`🔌 Connecting to ${url}...`, 'info');
+        await authService.connectToRelay(url);
+        log(`✅ Connection initiated to ${url}`, 'success');
+        setTimeout(refreshStatus, 2000);
+      } catch (error) {
+        log(`❌ Error: ${error.message}`, 'error');
+      }
+    };
+
+    window.disconnectRelay = async function() {
+      if (!authService) {
+        log('❌ AuthNostrService not available', 'error');
+        return;
+      }
+      
+      const url = document.getElementById('relayUrl').value;
+      if (!url) {
+        log('❌ Please enter a relay URL', 'error');
+        return;
+      }
+      
+      try {
+        log(`🔌 Disconnecting from ${url}...`, 'info');
+        await authService.disconnectFromRelay(url);
+        log(`✅ Disconnected from ${url}`, 'success');
+        setTimeout(refreshStatus, 1000);
+      } catch (error) {
+        log(`❌ Error: ${error.message}`, 'error');
+      }
+    };
+
+    window.simulateOffline = function() {
+      log('📡 To simulate offline:', 'info');
+      log('1. Open DevTools (F12)', 'info');
+      log('2. Go to Network tab', 'info');
+      log('3. Select "Offline" from throttling dropdown', 'info');
+      log('4. Wait a few seconds', 'info');
+      log('5. Select "Online" to restore connection', 'info');
+    };
+
+    window.runAutoTest = async function() {
+      if (!authService) {
+        log('❌ AuthNostrService not available', 'error');
+        return;
+      }
+      
+      log('🤖 Starting automated tests...', 'info');
+      
+      try {
+        // Test 1: Get status
+        log('Test 1: Getting relay status...', 'info');
+        const status = authService.getRelayStatus();
+        log(`✅ Got status for ${Object.keys(status).length} relays`, 'success');
+        
+        // Test 2: Get stats
+        log('Test 2: Getting relay stats...', 'info');
+        const stats = authService.getRelayStats();
+        log(`✅ Stats: ${stats.connected}/${stats.total} connected`, 'success');
+        
+        // Test 3: Health check
+        log('Test 3: Checking health...', 'info');
+        const health = await authService.checkRelayHealth();
+        log(`✅ Health: ${health ? 'HEALTHY' : 'UNHEALTHY'}`, 'success');
+        
+        // Test 4: Reconnect
+        log('Test 4: Testing reconnect...', 'info');
+        await authService.reconnectAllRelays();
+        log('✅ Reconnect initiated', 'success');
+        
+        await new Promise(r => setTimeout(r, 3000));
+        await refreshStatus();
+        
+        log('🎉 All tests completed!', 'success');
+      } catch (error) {
+        log(`❌ Test failed: ${error.message}`, 'error');
+      }
+    };
+
+    window.clearLogs = function() {
+      document.getElementById('logContainer').innerHTML = '';
+      log('🗑️ Logs cleared', 'info');
+    };
+
+    // Auto-refresh every 5 seconds
+    setInterval(() => {
+      if (authService) {
+        refreshStatus();
+      }
+    }, 5000);
+  </script>
+</body>
+</html>