@konemono/nostr-login 1.9.14 → 1.10.1

package/dist/modules/AuthNostrService.d.ts

@@ -3,12 +3,14 @@ import { NostrParams } from './';
 import { EventEmitter } from 'tseep';
 import { Signer } from './Nostr';
 declare class AuthNostrService extends EventEmitter implements Signer {
+    private ndk;
+    private profileNdk;
     private signer;
-    private amberSigner;
     private localSigner;
     private params;
     private signerPromise?;
     private signerErrCallback?;
+    private signerAbortController?;
     private readyPromise?;
     private readyCallback?;
     private nip44Codec;
@@ -25,19 +27,17 @@ declare class AuthNostrService extends EventEmitter implements Signer {
         decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     constructor(params: NostrParams);
-    private checkAmberResponse;
-    private handledAmberIds;
-    private handleAmberResponse;
     isIframe(): boolean;
     waitReady(): Promise<void>;
     cancelNostrConnect(): void;
-    nostrConnect(relays?: string[], { domain, link, iframeUrl, importConnect, }?: {
+    cancelSignerInit(): void;
+    nostrConnect(relay?: string, { domain, link, iframeUrl, importConnect, }?: {
         domain?: string;
         link?: string;
         importConnect?: boolean;
         iframeUrl?: string;
     }): Promise<Info>;
-    createNostrConnect(relays?: string[]): Promise<string>;
+    createNostrConnect(relay?: string): Promise<string>;
     getNostrConnectServices(): Promise<[string, ConnectionString[]]>;
     localSignup(name: string, sk?: string): Promise<void>;
     setLocal(info: Info, signup?: boolean): Promise<void>;
@@ -47,7 +47,6 @@ declare class AuthNostrService extends EventEmitter implements Signer {
     setExtension(pubkey: string): void;
     setOTP(pubkey: string, data: string): void;
     setConnect(info: Info): Promise<void>;
-    setAmber(info: Info): Promise<void>;
     createAccount(nip05: string): Promise<{
         bunkerUrl: string;
         sk: string | undefined;
@@ -60,27 +59,29 @@ declare class AuthNostrService extends EventEmitter implements Signer {
     private createIframe;
     sendNeedAuth(): Promise<void>;
     isAuthing(): boolean;
-    startAuth(): void;
+    startAuth(): Promise<void>;
     endAuth(): Promise<void>;
     resetAuth(): void;
     private listen;
-    connect(info: Info, perms?: string): Promise<any>;
+    connect(info: Info, perms?: string): Promise<void>;
     initSigner(info: Info, { listen, connect, eventToAddAccount }?: {
         listen?: boolean | undefined;
         connect?: boolean | undefined;
         eventToAddAccount?: boolean | undefined;
     }): Promise<void>;
-    authNip46(type: 'login' | 'signup', { name, bunkerUrl, sk, domain, iframeUrl }: {
+    private initSignerInternal;
+    authNip46(type: 'login' | 'signup', { name, bunkerUrl, sk, domain, iframeUrl, customRelays, }: {
         name: string;
         bunkerUrl: string;
         sk?: string;
         domain?: string;
         iframeUrl?: string;
+        customRelays?: string[];
     }): Promise<void>;
     signEvent(event: any): Promise<any>;
     private codec_call;
-    encrypt04(pubkey: string, plaintext: string): Promise<any>;
-    decrypt04(pubkey: string, ciphertext: string): Promise<any>;
+    encrypt04(pubkey: string, plaintext: string): Promise<string>;
+    decrypt04(pubkey: string, ciphertext: string): Promise<string>;
     encrypt44(pubkey: string, plaintext: string): Promise<string>;
     decrypt44(pubkey: string, ciphertext: string): Promise<string>;
 }

package/dist/modules/ModalManager.d.ts

@@ -11,6 +11,7 @@ declare class ModalManager extends EventEmitter {
     private accounts;
     private recents;
     private opt?;
+    private customNip46Relays;
     constructor(params: NostrParams, authNostrService: AuthNostrService, extensionManager: NostrExtensionService);
     waitReady(): Promise<void>;
     launch(opt: NostrLoginOptions): Promise<void>;

package/dist/modules/Nip46.d.ts

@@ -1,51 +1,46 @@
-import { EventEmitter } from 'tseep';
-import { SimplePool } from 'nostr-tools';
+import NDK, { NDKEvent, NDKFilter, NDKNip46Signer, NDKNostrRpc, NDKRpcRequest, NDKRpcResponse, NDKSubscription } from '@nostr-dev-kit/ndk';
 import { PrivateKeySigner } from './Signer';
-export type RpcRequest = {
-    id: string;
-    pubkey: string;
-    method: string;
-    params: any[];
-    event?: any;
-};
-export type RpcResponse = {
-    id: string;
-    result?: any;
-    error?: any;
-    event?: any;
-};
-export declare class NostrRpc extends EventEmitter {
-    protected localSigner: PrivateKeySigner;
-    protected localPubkey: string;
-    protected localPrivateKey: string;
-    protected remotePubkey: string;
-    protected pool: SimplePool;
-    protected relays: string[];
-    protected subscription: any;
-    protected isSubscribed: boolean;
-    protected useNip44: boolean;
+declare class NostrRpc extends NDKNostrRpc {
+    protected _ndk: NDK;
+    protected _signer: PrivateKeySigner;
     protected requests: Set<string>;
-    constructor(localSigner: PrivateKeySigner, relays?: string[]);
-    setUseNip44(use: boolean): void;
-    protected isNip04(ciphertext: string): boolean;
-    protected decryptEventContent(event: any): Promise<any>;
-    protected parseEvent(event: any): Promise<RpcRequest | RpcResponse>;
-    subscribe(relays: string[], filter: any): void;
+    private sub?;
+    protected _useNip44: boolean;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    constructor(ndk: NDK, signer: PrivateKeySigner);
+    subscribe(filter: NDKFilter): Promise<NDKSubscription>;
     stop(): void;
+    setUseNip44(useNip44: boolean): void;
+    private isNip04;
+    parseEvent(event: NDKEvent): Promise<NDKRpcRequest | NDKRpcResponse>;
+    parseNostrConnectReply(reply: any, secret: string): Promise<string>;
+    listen(nostrConnectSecret: string): Promise<string>;
+    connect(pubkey: string, token?: string, perms?: string): Promise<void>;
+    connectWithTimeout(pubkey: string, token?: string, perms?: string, timeoutMs?: number): Promise<void>;
+    sendRequestWithTimeout(remotePubkey: string, method: string, params?: string[], kind?: number, timeoutMs?: number): Promise<NDKRpcResponse>;
+    private setupConnectionMonitoring;
+    private ensureConnected;
+    protected reconnect(): Promise<void>;
     protected getId(): string;
-    protected setResponseHandler(id: string, cb?: (res: RpcResponse) => void): void;
-    protected createRequestEvent(id: string, remotePubkey: string, method: string, params?: any[], kind?: number): Promise<any>;
-    protected publishRequest(event: any): Promise<void>;
-    sendRequest(remotePubkey: string, method: string, params?: any[], kind?: number, cb?: (res: RpcResponse) => void): Promise<RpcResponse | undefined>;
-    listen(nostrConnectSecret: string, relays?: string[]): Promise<string>;
+    sendRequest(remotePubkey: string, method: string, params?: string[], kind?: number, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse>;
+    protected setResponseHandler(id: string, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse>;
+    protected createRequestEvent(id: string, remotePubkey: string, method: string, params?: string[], kind?: number): Promise<NDKEvent>;
 }
 export declare class IframeNostrRpc extends NostrRpc {
     private peerOrigin?;
     private iframePort?;
     private iframeRequests;
-    constructor(localSigner: PrivateKeySigner, iframePeerOrigin?: string, relays?: string[]);
+    private heartbeatInterval?;
+    private lastResponseTime;
+    private heartbeatTimeoutMs;
+    constructor(ndk: NDK, localSigner: PrivateKeySigner, iframePeerOrigin?: string);
+    subscribe(filter: NDKFilter): Promise<NDKSubscription>;
+    private startHeartbeat;
+    private stopHeartbeat;
     setWorkerIframePort(port: MessagePort): void;
-    sendRequest(remotePubkey: string, method: string, params?: any[], kind?: number, cb?: (res: RpcResponse) => void): Promise<RpcResponse | undefined>;
+    sendRequest(remotePubkey: string, method: string, params?: string[], kind?: number, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse>;
 }
 export declare class ReadyListener {
     origin: string;
@@ -54,19 +49,21 @@ export declare class ReadyListener {
     constructor(messages: string[], origin: string);
     wait(): Promise<any>;
 }
-export declare class Nip46Signer extends EventEmitter {
+export declare class Nip46Signer extends NDKNip46Signer {
     private _userPubkey;
-    remotePubkey: string;
-    rpc: IframeNostrRpc | NostrRpc;
-    private localSigner;
-    constructor(localSigner: PrivateKeySigner, signerPubkey: string, iframeOrigin?: string, relays?: string[]);
+    private _rpc;
+    constructor(ndk: NDK, localSigner: PrivateKeySigner, signerPubkey: string, iframeOrigin?: string);
     get userPubkey(): string;
     private setSignerPubkey;
     initUserPubkey(hintPubkey?: string): Promise<void>;
     listen(nostrConnectSecret: string): Promise<void>;
     connect(token?: string, perms?: string): Promise<void>;
-    createAccount2(params: any): Promise<unknown>;
-    encrypt(pubkey: string, plaintext: string): Promise<string>;
-    decrypt(pubkey: string, ciphertext: string): Promise<string>;
-    sign(event: any): Promise<any>;
+    setListenReply(reply: any, nostrConnectSecret: string): Promise<void>;
+    createAccount2({ bunkerPubkey, name, domain, perms }: {
+        bunkerPubkey: string;
+        name: string;
+        domain: string;
+        perms?: string;
+    }): Promise<string>;
 }
+export {};

package/dist/modules/NostrExtensionService.d.ts

@@ -1,10 +1,5 @@
 import { Nostr, NostrParams } from './';
 import { EventEmitter } from 'tseep';
-declare global {
-    interface Window {
-        nostr?: any;
-    }
-}
 declare class NostrExtensionService extends EventEmitter {
     private params;
     private nostrExtension;

package/dist/modules/Signer.d.ts

@@ -1,16 +1,9 @@
-export declare class PrivateKeySigner {
+import { NDKPrivateKeySigner, NDKUser } from '@nostr-dev-kit/ndk';
+export declare class PrivateKeySigner extends NDKPrivateKeySigner {
     private nip44;
     private _pubkey;
-    privateKey: string;
     constructor(privateKey: string);
     get pubkey(): string;
-    blockUntilReady(): Promise<void>;
-    user(): Promise<{
-        pubkey: string;
-    }>;
-    sign(event: any): Promise<string>;
-    encrypt(recipient: any, plaintext: string): Promise<string>;
-    decrypt(sender: any, ciphertext: string): Promise<string>;
-    encryptNip44(recipient: any, value: string): Promise<string>;
-    decryptNip44(sender: any, value: string): Promise<string>;
+    encryptNip44(recipient: NDKUser, value: string): Promise<string>;
+    decryptNip44(sender: NDKUser, value: string): Promise<string>;
 }

package/dist/types.d.ts

@@ -70,8 +70,3 @@ export interface Response {
     result?: string;
     error?: string;
 }
-export interface AmberResponse {
-    id: string;
-    type: string;
-    result: string;
-}