@konemono/nostr-login 1.11.0 → 1.11.3

package/src/modules/NostrExtensionService.ts

@@ -60,7 +60,6 @@ class NostrExtensionService extends EventEmitter {
   }
 
   private async setExtensionReadPubkey(expectedPubkey?: string) {
-    // @ts-ignore
     window.nostr = this.nostrExtension;
     // @ts-ignore
     const pubkey = await window.nostr.getPublicKey();
@@ -82,7 +81,6 @@ class NostrExtensionService extends EventEmitter {
   }
 
   public unsetExtension(nostr: Nostr) {
-    // @ts-ignore
     if (window.nostr === this.nostrExtension) {
       // @ts-ignore
       window.nostr = nostr;

package/src/modules/Signer.ts

@@ -1,48 +1,25 @@
+import { NDKPrivateKeySigner, NDKUser } from '@nostr-dev-kit/ndk';
 import { Nip44 } from '../utils/nip44';
-import { getPublicKey, finalizeEvent, nip04 } from 'nostr-tools';
+import { getPublicKey } from 'nostr-tools';
 
-export class PrivateKeySigner {
-  public privateKey: Uint8Array;
+export class PrivateKeySigner extends NDKPrivateKeySigner {
   private nip44: Nip44 = new Nip44();
-  private __pubkey: string;
+  private _pubkey: string;
 
-  constructor(privateKey: Uint8Array) {
-    this.privateKey = privateKey;
-    this.__pubkey = getPublicKey(privateKey);
+  constructor(privateKey: string) {
+    super(privateKey);
+    this._pubkey = getPublicKey(privateKey);
   }
 
   get pubkey() {
-    return this.__pubkey;
+    return this._pubkey;
   }
 
-  async user(): Promise<{ pubkey: string }> {
-    return { pubkey: this.__pubkey };
+  encryptNip44(recipient: NDKUser, value: string): Promise<string> {
+    return Promise.resolve(this.nip44.encrypt(this.privateKey!, recipient.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);
+  decryptNip44(sender: NDKUser, value: string): Promise<string> {
+    return Promise.resolve(this.nip44.decrypt(this.privateKey!, sender.pubkey, value));
   }
 }

package/src/utils/index.ts

@@ -1,9 +1,7 @@
 import { Info, RecentType } from 'nostr-login-components/dist/types/types';
-import { createRxForwardReq, RxNostr } from 'rx-nostr';
-import { generateSecretKey, type Event as NostrEvent, type UnsignedEvent } from 'nostr-tools';
+import NDK, { NDKEvent, NDKRelaySet, NDKSigner, NDKUser } from '@nostr-dev-kit/ndk';
+import { generatePrivateKey } 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';
@@ -11,19 +9,6 @@ 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);
 };
@@ -34,7 +19,7 @@ export const localStorageGetItem = (key: string) => {
   if (value) {
     try {
       return JSON.parse(value);
-    } catch { }
+    } catch {}
   }
 
   return null;
@@ -44,30 +29,12 @@ export const localStorageRemoveItem = (key: string) => {
   localStorage.removeItem(key);
 };
 
-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.
+export const fetchProfile = async (info: Info, profileNdk: NDK) => {
+  const user = new NDKUser({ pubkey: info.pubkey });
 
-  req.emit({ kinds: [0], authors: [info.pubkey], limit: 1 });
+  user.ndk = profileNdk;
 
-  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;
+  return await user.fetchProfile();
 };
 
 export const prepareSignupRelays = (signupRelays?: string) => {
@@ -79,70 +46,53 @@ export const prepareSignupRelays = (signupRelays?: string) => {
   return relays;
 };
 
-export const createProfile = async (info: Info, rxNostr: RxNostr, signer: PrivateKeySigner, signupRelays?: string, outboxRelays?: string[]) => {
+export const createProfile = async (info: Info, profileNdk: NDK, signer: NDKSigner, signupRelays?: string, outboxRelays?: string[]) => {
   const meta = {
     name: info.name,
   };
 
-  const profileEvent: UnsignedEvent = {
+  const profileEvent = new NDKEvent(profileNdk, {
     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: UnsignedEvent = {
+  const relaysEvent = new NDKEvent(profileNdk, {
     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]);
   }
 
-  // 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.
+  await profileEvent.sign(signer);
+  console.log('signed profile', profileEvent);
+  await relaysEvent.sign(signer);
+  console.log('signed relays', relaysEvent);
 
-  // Actually, checking AuthNostrService, it does:
-  // event.id = getEventHash(event);
-  // event.sig = await signer.sign(event);
+  const outboxRelaysFinal = outboxRelays && outboxRelays.length ? outboxRelays : OUTBOX_RELAYS;
 
-  // 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.
+  await profileEvent.publish(NDKRelaySet.fromRelayUrls(outboxRelaysFinal, profileNdk));
+  console.log('published profile', profileEvent);
+  await relaysEvent.publish(NDKRelaySet.fromRelayUrls(outboxRelaysFinal, profileNdk));
+  console.log('published relays', relaysEvent);
 };
 
 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: skHex,
+    sk: sk || generatePrivateKey(),
     relays: url.searchParams.getAll('relay'),
     token: url.searchParams.get('secret') || '',
     authMethod: 'connect',
@@ -215,7 +165,7 @@ export const checkNip05 = async (nip05: string) => {
         pubkey = d.names[name];
         return;
       }
-    } catch { }
+    } catch {}
 
     available = true;
   })();

package/src/utils/nip44.ts

@@ -10,7 +10,6 @@ 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
 
@@ -160,30 +159,26 @@ export function decryptNip44(payload: string, conversationKey: Uint8Array): stri
 export class Nip44 {
   private cache = new Map<string, Uint8Array>()
 
-  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)
+  public createKey(privkey: string, pubkey: string) {
+    return u.getConversationKey(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
+  private getKey(privkey: string, pubkey: string, extractable?: boolean) {
+    const id = getPublicKey(privkey) + pubkey
     let cryptoKey = this.cache.get(id)
     if (cryptoKey) return cryptoKey
 
-    const key = this.createKey(privBytes, pubkey)
+    const key = this.createKey(privkey, pubkey)
     this.cache.set(id, key)
     return key
   }
 
-  public encrypt(privkey: string | Uint8Array, pubkey: string, text: string): string {
+  public encrypt(privkey: string, pubkey: string, text: string): string {
     const key = this.getKey(privkey, pubkey)
     return encryptNip44(text, key)
   }
 
-  public decrypt(privkey: string | Uint8Array, pubkey: string, data: string): string {
+  public decrypt(privkey: string, pubkey: string, data: string): string {
     const key = this.getKey(privkey, pubkey)
     return decryptNip44(data, key)
   }