npm - @konemono/nostr-login - Versions diffs - 1.7.11 - Mend

@konemono/nostr-login 1.7.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/.prettierrc.json +13 -0
package/README.md +167 -0
package/dist/const/index.d.ts +1 -0
package/dist/iife-module.d.ts +1 -0
package/dist/index.d.ts +27 -0
package/dist/index.esm.js +18 -0
package/dist/index.esm.js.map +1 -0
package/dist/modules/AuthNostrService.d.ts +84 -0
package/dist/modules/BannerManager.d.ts +20 -0
package/dist/modules/ModalManager.d.ts +25 -0
package/dist/modules/Nip46.d.ts +56 -0
package/dist/modules/Nostr.d.ts +34 -0
package/dist/modules/NostrExtensionService.d.ts +17 -0
package/dist/modules/NostrParams.d.ts +8 -0
package/dist/modules/Popup.d.ts +7 -0
package/dist/modules/ProcessManager.d.ts +10 -0
package/dist/modules/Signer.d.ts +9 -0
package/dist/modules/index.d.ts +8 -0
package/dist/types.d.ts +72 -0
package/dist/unpkg.js +17 -0
package/dist/utils/index.d.ts +27 -0
package/dist/utils/nip44.d.ts +9 -0
package/index.html +30 -0
package/package.json +28 -0
package/rollup.config.js +55 -0
package/src/const/index.ts +1 -0
package/src/iife-module.ts +81 -0
package/src/index.ts +347 -0
package/src/modules/AuthNostrService.ts +756 -0
package/src/modules/BannerManager.ts +146 -0
package/src/modules/ModalManager.ts +635 -0
package/src/modules/Nip46.ts +441 -0
package/src/modules/Nostr.ts +107 -0
package/src/modules/NostrExtensionService.ts +99 -0
package/src/modules/NostrParams.ts +18 -0
package/src/modules/Popup.ts +27 -0
package/src/modules/ProcessManager.ts +67 -0
package/src/modules/Signer.ts +25 -0
package/src/modules/index.ts +8 -0
package/src/types.ts +124 -0
package/src/utils/index.ts +326 -0
package/src/utils/nip44.ts +185 -0
package/tsconfig.json +15 -0

package/dist/utils/index.d.ts ADDED Viewed

@@ -0,0 +1,27 @@
+import { Info, RecentType } from 'nostr-login-components';
+import NDK, { NDKSigner } from '@nostr-dev-kit/ndk';
+import { NostrLoginOptions } from '../types';
+export declare const localStorageSetItem: (key: string, value: string) => void;
+export declare const localStorageGetItem: (key: string) => any;
+export declare const localStorageRemoveItem: (key: string) => void;
+export declare const fetchProfile: (info: Info, profileNdk: NDK) => Promise<import("@nostr-dev-kit/ndk").NDKUserProfile | null>;
+export declare const prepareSignupRelays: (signupRelays?: string) => string[];
+export declare const createProfile: (info: Info, profileNdk: NDK, signer: NDKSigner, signupRelays?: string, outboxRelays?: string[]) => Promise<void>;
+export declare const bunkerUrlToInfo: (bunkerUrl: string, sk?: string) => Info;
+export declare const isBunkerUrl: (value: string) => boolean;
+export declare const getBunkerUrl: (value: string, optionsModal: NostrLoginOptions) => Promise<string>;
+export declare const checkNip05: (nip05: string) => Promise<{
+    available: boolean;
+    taken: boolean;
+    error: string;
+    pubkey: string;
+}>;
+export declare const localStorageAddAccount: (info: Info) => void;
+export declare const localStorageRemoveCurrentAccount: () => void;
+export declare const localStorageRemoveRecent: (user: RecentType) => void;
+export declare const localStorageGetRecents: () => RecentType[];
+export declare const localStorageGetAccounts: () => Info[];
+export declare const localStorageGetCurrent: () => Info | null;
+export declare const setDarkMode: (dark: boolean) => void;
+export declare const getDarkMode: (opt: NostrLoginOptions) => boolean;
+export declare const getIcon: () => Promise<string>;

package/dist/utils/nip44.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+export declare function encryptNip44(plaintext: string, conversationKey: Uint8Array, nonce?: Uint8Array): string;
+export declare function decryptNip44(payload: string, conversationKey: Uint8Array): string;
+export declare class Nip44 {
+    private cache;
+    createKey(privkey: string, pubkey: string): Uint8Array;
+    private getKey;
+    encrypt(privkey: string, pubkey: string, text: string): string;
+    decrypt(privkey: string, pubkey: string, data: string): string;
+}

package/index.html ADDED Viewed

@@ -0,0 +1,30 @@
+<!doctype html>
+<html dir="ltr" lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=5.0" />
+    <title>Modal Auth Demo</title>
+    <script type="module">
+        // import { init } from './dist/index.esm.js';
+        //
+        // const test = async () => {
+        //     const bunkerUrl = await launch({
+        //         theme: 'purple',
+        //         startScreen: 'signup',
+        //     });
+        //
+        //     console.log(bunkerUrl);
+        // };
+    </script>
+    <script src="./dist/unpkg.js" data-start-screen="local-signup"
+        data-signup-relays="wss://relay.nostr.band/,wss://relay.primal.net"></script>
+</head>
+<body>
+<!--<nl-button title-btn="Sign in" start-screen="login" nl-theme="lemonade"></nl-button>-->
+</body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,28 @@
+{
+  "name": "@konemono/nostr-login",
+  "version": "1.7.11",
+  "description": "",
+  "main": "./dist/index.esm.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "rollup -c",
+    "format": "npx prettier --write src"
+  },
+  "author": "a-fralou",
+  "dependencies": {
+    "@nostr-dev-kit/ndk": "^2.3.1",
+    "nostr-tools": "^1.17.0",
+    "tseep": "^1.2.1"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "nostr-login-components": "^1.0.3",
+    "prettier": "^3.2.2",
+    "rollup": "^4.9.6",
+    "rollup-plugin-typescript2": "^0.36.0"
+  },
+  "license": "MIT"
+}

package/rollup.config.js ADDED Viewed

@@ -0,0 +1,55 @@
+import commonjs from '@rollup/plugin-commonjs';
+import resolve from '@rollup/plugin-node-resolve';
+import typescript from 'rollup-plugin-typescript2';
+import terser from '@rollup/plugin-terser';
+export default [
+    {
+        input: 'src/index.ts',
+        output: [
+            {
+                file: 'dist/index.esm.js',
+                format: 'esm',
+                sourcemap: true,
+            },
+        ],
+        plugins: [
+            typescript({
+                tsconfig: 'tsconfig.json',
+            }),
+            resolve({
+                browser: true
+            }),
+            commonjs(),
+            terser({
+                compress: {
+                    toplevel: true,
+                }
+            })
+        ],
+    },
+    {
+        input: 'src/iife-module.ts',
+        output: [
+            {
+                file: 'dist/unpkg.js',
+                format: 'iife',
+            }
+        ],
+        plugins: [
+            typescript({
+                tsconfig: 'tsconfig.json',
+            }),
+            resolve({
+                browser: true
+            }),
+            commonjs(),
+            terser({
+                compress: {
+                    toplevel: true,
+                },
+            })
+        ],
+    }
+];

package/src/const/index.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export const CALL_TIMEOUT = 5000;

package/src/iife-module.ts ADDED Viewed

@@ -0,0 +1,81 @@
+import { init } from './index';
+import { NostrLoginOptions, StartScreens } from './types';
+// wrap to hide local vars
+(() => {
+  // currentScript only visible in global scope code, not event handlers
+  const cs = document.currentScript;
+  const start = async () => {
+    const options: NostrLoginOptions = {};
+    if (cs) {
+      const dm = cs.getAttribute('data-dark-mode');
+      if (dm) options.darkMode = dm === 'true';
+      const bunkers = cs.getAttribute('data-bunkers');
+      if (bunkers) options.bunkers = bunkers;
+      const startScreen = cs.getAttribute('data-start-screen');
+      if (startScreen) options.startScreen = startScreen as StartScreens;
+      const perms = cs.getAttribute('data-perms');
+      if (perms) options.perms = perms;
+      const theme = cs.getAttribute('data-theme');
+      if (theme) options.theme = theme;
+      const noBanner = cs.getAttribute('data-no-banner');
+      if (noBanner) options.noBanner = noBanner === 'true';
+      const localSignup = cs.getAttribute('data-local-signup');
+      if (localSignup) options.localSignup = localSignup === 'true';
+      const signupNjump = cs.getAttribute('data-signup-nstart') || cs.getAttribute('data-signup-njump');
+      if (signupNjump) options.signupNstart = signupNjump === 'true';
+      const followNpubs = cs.getAttribute('data-follow-npubs');
+      if (followNpubs) options.followNpubs = followNpubs;
+      const otpRequestUrl = cs.getAttribute('data-otp-request-url');
+      if (otpRequestUrl) options.otpRequestUrl = otpRequestUrl;
+      const otpReplyUrl = cs.getAttribute('data-otp-reply-url');
+      if (otpReplyUrl) options.otpReplyUrl = otpReplyUrl;
+      if (!!otpRequestUrl !== !!otpReplyUrl) console.warn('nostr-login: need request and reply urls for OTP auth');
+      const methods = cs.getAttribute('data-methods');
+      if (methods) {
+        // @ts-ignore
+        options.methods = methods
+          .trim()
+          .split(',')
+          .filter(m => !!m);
+      }
+      const title = cs.getAttribute('data-title');
+      if (title) options.title = title;
+      const description = cs.getAttribute('data-description');
+      if (description) options.description = description;
+      const signupRelays = cs.getAttribute('data-signup-relays');
+      if (signupRelays) options.signupRelays = signupRelays;
+      const outboxRelays = cs.getAttribute('data-outbox-relays');
+      if (outboxRelays) options.outboxRelays = outboxRelays.split(',');
+      const dev = cs.getAttribute('data-dev') === 'true';
+      if (dev) options.dev = dev;
+      const custom = cs.getAttribute('data-custom-nostr-connect') === 'true';
+      if (custom) options.customNostrConnect = custom;
+      console.log('nostr-login options', options);
+    }
+    init(options);
+  };
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', start);
+  else start();
+})();

package/src/index.ts ADDED Viewed

@@ -0,0 +1,347 @@
+import 'nostr-login-components';
+import { AuthNostrService, NostrExtensionService, Popup, NostrParams, Nostr, ProcessManager, BannerManager, ModalManager } from './modules';
+import { NostrLoginAuthOptions, NostrLoginOptions, StartScreens } from './types';
+import { localStorageGetAccounts, localStorageGetCurrent, localStorageGetRecents, localStorageSetItem } from './utils';
+import { Info } from 'nostr-login-components';
+import { NostrObjectParams } from './modules/Nostr';
+export class NostrLoginInitializer {
+  public extensionService: NostrExtensionService;
+  public params: NostrParams;
+  public authNostrService: AuthNostrService;
+  public nostr: Nostr;
+  public processManager: ProcessManager;
+  public popupManager: Popup;
+  public bannerManager: BannerManager;
+  public modalManager: ModalManager;
+  private customLaunchCallback?: () => void;
+  constructor() {
+    this.params = new NostrParams();
+    this.processManager = new ProcessManager();
+    this.popupManager = new Popup();
+    this.bannerManager = new BannerManager(this.params);
+    this.authNostrService = new AuthNostrService(this.params);
+    this.extensionService = new NostrExtensionService(this.params);
+    this.modalManager = new ModalManager(this.params, this.authNostrService, this.extensionService);
+    const nostrApi: NostrObjectParams = {
+      waitReady: async () => {
+        await this.authNostrService.waitReady();
+        await this.modalManager.waitReady();
+      },
+      getUserInfo: () => this.params.userInfo,
+      getSigner: () => {
+        if (this.params.userInfo!.authMethod === 'readOnly') throw new Error('Read only');
+        return this.params.userInfo!.authMethod === 'extension' ? this.extensionService.getExtension() : this.authNostrService;
+      },
+      launch: () => {
+        return this.launch();
+      },
+      wait: cb => this.processManager.wait(cb),
+    };
+    this.nostr = new Nostr(nostrApi);
+    this.processManager.on('onCallTimeout', () => {
+      this.bannerManager.onCallTimeout();
+    });
+    this.processManager.on('onCallEnd', () => {
+      this.bannerManager.onCallEnd();
+      this.modalManager.onCallEnd();
+    });
+    this.processManager.on('onCallStart', () => {
+      this.bannerManager.onCallStart();
+    });
+    this.authNostrService.on('onIframeUrl', url => {
+      this.modalManager.onIframeUrl(url);
+    });
+    this.authNostrService.on('iframeRestart', ({ iframeUrl }) => {
+      this.processManager.onIframeUrl();
+      this.bannerManager.onIframeRestart(iframeUrl);
+    });
+    this.authNostrService.on('onAuthUrl', ({ url, iframeUrl, eventToAddAccount }) => {
+      this.processManager.onAuthUrl();
+      if (eventToAddAccount) {
+        this.modalManager.onAuthUrl(url);
+        return;
+      }
+      if (this.params.userInfo) {
+        // show the 'Please confirm' banner
+        this.bannerManager.onAuthUrl(url, iframeUrl);
+      } else {
+        // if it fails we will either return 'failed'
+        // to the window.nostr caller, or show proper error
+        // in our modal
+        this.modalManager.onAuthUrl(url);
+      }
+    });
+    this.authNostrService.on('updateAccounts', () => {
+      this.updateAccounts();
+    });
+    this.authNostrService.on('onUserInfo', info => {
+      this.bannerManager.onUserInfo(info);
+    });
+    this.modalManager.on('onAuthUrlClick', url => {
+      this.openPopup(url);
+    });
+    this.bannerManager.on('onIframeAuthUrlClick', url => {
+      this.modalManager.showIframeUrl(url);
+    });
+    this.modalManager.on('onSwitchAccount', async (info: Info) => {
+      this.switchAccount(info);
+    });
+    this.modalManager.on('onLogoutBanner', async (info: Info) => {
+      logout();
+    });
+    this.bannerManager.on('onConfirmLogout', async () => {
+      // @ts-ignore
+      this.launch('confirm-logout');
+    });
+    this.modalManager.on('updateAccounts', () => {
+      this.updateAccounts();
+    });
+    this.bannerManager.on('logout', () => {
+      logout();
+    });
+    this.bannerManager.on('onAuthUrlClick', url => {
+      this.openPopup(url);
+    });
+    this.bannerManager.on('onSwitchAccount', async (info: Info) => {
+      this.switchAccount(info);
+    });
+    this.bannerManager.on('import', () => {
+      this.launch('import');
+    });
+    this.extensionService.on('extensionLogin', (pubkey: string) => {
+      this.authNostrService.setExtension(pubkey);
+    });
+    this.extensionService.on('extensionLogout', () => {
+      logout();
+    });
+    this.bannerManager.on('launch', (startScreen?: StartScreens) => {
+      this.launch(startScreen);
+    });
+  }
+  private openPopup(url: string) {
+    this.popupManager.openPopup(url);
+  }
+  private async switchAccount(info: Info, signup = false) {
+    console.log('nostr login switch to info', info);
+    // make sure extension is unlinked
+    this.extensionService.unsetExtension(this.nostr);
+    if (info.authMethod === 'readOnly') {
+      this.authNostrService.setReadOnly(info.pubkey);
+    } else if (info.authMethod === 'otp') {
+      this.authNostrService.setOTP(info.pubkey, info.otpData || '');
+    } else if (info.authMethod === 'local' && info.sk) {
+      this.authNostrService.setLocal(info, signup);
+    } else if (info.authMethod === 'extension') {
+      // trySetExtensionForPubkey will check if
+      // we still have the extension and it's the same pubkey
+      await this.extensionService.trySetExtensionForPubkey(info.pubkey);
+    } else if (info.authMethod === 'connect' && info.sk && info.relays && info.relays[0]) {
+      this.authNostrService.setConnect(info);
+    } else {
+      throw new Error('Bad auth info');
+    }
+  }
+  private updateAccounts() {
+    const accounts = localStorageGetAccounts();
+    const recents = localStorageGetRecents();
+    this.bannerManager.onUpdateAccounts(accounts);
+    this.modalManager.onUpdateAccounts(accounts, recents);
+  }
+  public async launchCustomNostrConnect() {
+    try {
+      if (this.authNostrService.isAuthing()) this.authNostrService.cancelNostrConnect();
+      const customLaunchPromise = new Promise<void>(ok => (this.customLaunchCallback = ok));
+      await this.authNostrService.startAuth();
+      await this.authNostrService.sendNeedAuth();
+      try {
+        await this.authNostrService.nostrConnect();
+        await this.authNostrService.endAuth();
+      } catch (e) {
+        // if client manually launches the UI we'll
+        // have cancelled error from the nostrConnect call,
+        // and that's when we should block on the customLaunchPromise
+        if (e === 'cancelled') await customLaunchPromise;
+      }
+    } catch (e) {
+      console.error('launchCustomNostrConnect', e);
+    }
+  }
+  private fulfillCustomLaunchPromise() {
+    if (this.customLaunchCallback) {
+      const cb = this.customLaunchCallback;
+      this.customLaunchCallback = undefined;
+      cb();
+    }
+  }
+  public launch = async (startScreen?: StartScreens | 'default') => {
+    if (!startScreen) {
+      if (this.params.optionsModal.customNostrConnect) {
+        return this.launchCustomNostrConnect();
+      }
+    }
+    const recent = localStorageGetRecents();
+    const accounts = localStorageGetAccounts();
+    const options = { ...this.params.optionsModal };
+    if (startScreen && startScreen !== 'default') options.startScreen = startScreen;
+    else if (Boolean(recent?.length) || Boolean(accounts?.length)) {
+      options.startScreen = 'switch-account';
+    }
+    // if we're being manually called in the middle of customNostrConnect
+    // flow then we'll reset the current auth session and launch
+    // our manual flow and then release the customNostrConnect session
+    // as if it finished properly
+    if (this.customLaunchCallback) this.authNostrService.cancelNostrConnect();
+    try {
+      await this.modalManager.launch(options);
+      // if custom launch was interrupted by manual
+      // launch then we unlock the custom launch to make
+      // it proceed
+      this.fulfillCustomLaunchPromise();
+    } catch (e) {
+      // don't throw if cancelled
+      console.log('nostr-login failed', e);
+    }
+  };
+  public init = async (opt: NostrLoginOptions) => {
+    // watch for extension trying to overwrite our window.nostr
+    this.extensionService.startCheckingExtension(this.nostr);
+    // set ourselves as nostr
+    // @ts-ignore
+    window.nostr = this.nostr;
+    // connect launching of our modals to nl-button elements
+    this.modalManager.connectModals(opt);
+    // launch
+    this.bannerManager.launchAuthBanner(opt);
+    // store options
+    if (opt) {
+      this.params.optionsModal = { ...opt };
+    }
+    try {
+      // read conf from localstore
+      const info = localStorageGetCurrent();
+      // have current session?
+      if (info) {
+        // wtf?
+        if (!info.pubkey) throw new Error('Bad stored info');
+        // switch to it
+        await this.switchAccount(info);
+      }
+    } catch (e) {
+      console.log('nostr login init error', e);
+      await logout();
+    }
+    // ensure current state
+    this.updateAccounts();
+  };
+  public logout = async () => {
+    // replace back
+    this.extensionService.unsetExtension(this.nostr);
+    await this.authNostrService.logout();
+  };
+  public setDarkMode = (dark: boolean) => {
+    localStorageSetItem('nl-dark-mode', `${dark}`);
+    this.bannerManager.onDarkMode(dark);
+    this.modalManager.onDarkMode(dark);
+  };
+  public setAuth = async (o: NostrLoginAuthOptions) => {
+    if (!o.type) throw new Error('Invalid auth event');
+    if (o.type !== 'login' && o.type !== 'logout' && o.type !== 'signup') throw new Error('Invalid auth event');
+    if (o.method && o.method !== 'connect' && o.method !== 'extension' && o.method !== 'local' && o.method !== 'otp' && o.method !== 'readOnly')
+      throw new Error('Invalid auth event');
+    if (o.type === 'logout') return this.logout();
+    if (!o.method || !o.pubkey) throw new Error('Invalid pubkey');
+    const info: Info = {
+      authMethod: o.method,
+      pubkey: o.pubkey,
+      relays: o.relays,
+      sk: o.localNsec,
+      otpData: o.otpData,
+      name: o.name,
+    };
+    await this.switchAccount(info, o.type === 'signup');
+  };
+  public cancelNeedAuth = () => {
+    console.log("cancelNeedAuth");
+    this.fulfillCustomLaunchPromise();
+    this.authNostrService.cancelNostrConnect();
+  };
+}
+const initializer = new NostrLoginInitializer();
+export const { init, launch, logout, setDarkMode, setAuth, cancelNeedAuth } = initializer;
+document.addEventListener('nlLogout', logout);
+document.addEventListener('nlLaunch', (event: any) => {
+  launch(event.detail || '');
+});
+document.addEventListener('nlNeedAuthCancel', () => {
+  cancelNeedAuth();
+});
+document.addEventListener('nlDarkMode', (event: any) => {
+  setDarkMode(!!event.detail);
+});
+document.addEventListener('nlSetAuth', (event: any) => {
+  setAuth(event.detail as NostrLoginAuthOptions);
+});