nostr-wot-sdk 0.4.2 → 0.5.0

package/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2025-02-05
+
+### Changed
+
+- **Simplified extension connection** - Removed event-based connection flow
+  - SDK now simply checks `window.nostr.wot` directly
+  - Extension auto-injects when enabled, no handshake needed
+  - Faster and more reliable connection
+
+- **React context simplified**
+  - Removed `ExtensionConnector` usage
+  - `useExtension()` hook now returns simpler state: `isConnected`, `isChecking`, `isChecked`, `refresh`
+  - Removed `extensionOptions` prop from `WoTProvider`
+  - State is now `'checking' | 'connected' | 'not-available'`
+
+### Removed
+
+- Removed event-based connection (`nostr-wot-check`, `nostr-wot-connect` events)
+- Removed `ExtensionConnectionOptions` from React exports
+- Extension connection utilities (`checkExtension`, `connectExtension`, `checkAndConnect`, `ExtensionConnector`) are still exported but deprecated
+
 ## [0.4.2] - 2025-02-05
 
 ### Fixed
@@ -180,6 +201,7 @@ function Profile({ pubkey }) {
 - TypeScript support with full type definitions
 - Error classes: `WoTError`, `NetworkError`, `NotFoundError`, `TimeoutError`, `ValidationError`
 
+[0.5.0]: https://github.com/nostr-wot/nostr-wot-sdk/compare/v0.4.2...v0.5.0
 [0.4.2]: https://github.com/nostr-wot/nostr-wot-sdk/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/nostr-wot/nostr-wot-sdk/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/nostr-wot/nostr-wot-sdk/compare/v0.3.2...v0.4.0

package/README.md

@@ -251,7 +251,7 @@ Install the [Nostr WoT Extension](https://github.com/nostr-wot/nostr-wot-extensi
 - **Privacy** — Queries never leave your browser
 - **Offline** — Works without internet once synced
 
-The SDK automatically detects and connects to the extension using an event-based handshake. When the extension is present, it **always takes priority** over oracle settings.
+The SDK automatically detects the extension via `window.nostr.wot`. When the extension is present (with auto-inject enabled), it **always takes priority** over oracle settings.
 
 ```javascript
 const wot = new WoT({
@@ -269,60 +269,16 @@ if (await wot.isUsingExtension()) {
 }
 ```
 
-### Extension Connection Utilities
-
-For advanced use cases, the SDK exports low-level extension connection functions:
-
-```javascript
-import {
-  checkExtension,     // Check if extension is installed
-  connectExtension,   // Connect to the extension
-  checkAndConnect,    // Check and connect in one call
-  ExtensionConnector  // Stateful connector class
-} from 'nostr-wot-sdk';
-
-// Check if extension is installed (100ms timeout)
-const isInstalled = await checkExtension();
-
-// Connect to extension (5s timeout)
-const extension = await connectExtension();
-
-// Or do both in one call
-const result = await checkAndConnect();
-if (result.state === 'connected') {
-  const distance = await result.extension.getDistance('target...');
-}
-
-// For stateful connection management
-const connector = new ExtensionConnector();
-connector.subscribe((result) => {
-  console.log('State changed:', result.state);
-});
-await connector.connect();
-```
-
-#### Extension Events
-
-The SDK uses a standard event-based protocol to communicate with the extension:
-
-| Event | Direction | Purpose |
-|-------|-----------|---------|
-| `nostr-wot-check` | Page → Extension | Check if extension installed |
-| `nostr-wot-present` | Extension → Page | Response confirming presence |
-| `nostr-wot-connect` | Page → Extension | Request API injection |
-| `nostr-wot-ready` | Extension → Page | API is ready at `window.nostr.wot` |
-| `nostr-wot-error` | Extension → Page | Injection failed with error |
-
 ## Framework Integration
 
 ### React
 
-The SDK provides first-class React support with automatic extension detection and connection. Just wrap your app with `WoTProvider` and you're ready to go — no additional configuration needed.
+The SDK provides first-class React support with automatic extension detection. Just wrap your app with `WoTProvider` and you're ready to go — no additional configuration needed.
 
 ```javascript
 import { WoTProvider, useWoT, useExtension } from 'nostr-wot-sdk/react';
 
-// Wrap your app - automatically connects to extension
+// Wrap your app - automatically detects extension
 function App() {
   return (
     <WoTProvider>
@@ -333,13 +289,11 @@ function App() {
 
 // Check extension status anywhere
 function ExtensionStatus() {
-  const { isConnected, isConnecting, isInstalled, error } = useExtension();
+  const { isConnected, isChecking } = useExtension();
 
-  if (isConnecting) return <span>Connecting to extension...</span>;
-  if (!isInstalled) return <span>Install the WoT extension for best experience</span>;
-  if (error) return <span>Error: {error}</span>;
-  if (isConnected) return <span>Connected to extension!</span>;
-  return null;
+  if (isChecking) return <span>Checking for extension...</span>;
+  if (isConnected) return <span>Extension connected!</span>;
+  return <span>Extension not available</span>;
 }
 
 // Use WoT data in components
@@ -363,16 +317,10 @@ function Profile({ pubkey }) {
 #### Provider Options
 
 ```javascript
-// With fallback for when extension is not installed
+// With fallback for when extension is not available
 <WoTProvider options={{
   fallback: { myPubkey: 'abc123...' }
 }}>
-
-// Custom extension connection timeouts
-<WoTProvider extensionOptions={{
-  checkTimeout: 100,    // Extension detection timeout (ms)
-  connectTimeout: 5000  // Connection timeout (ms)
-}}>
 ```
 
 #### Available Hooks
@@ -388,17 +336,15 @@ function Profile({ pubkey }) {
 
 #### Extension State
 
-The `useExtension()` hook provides detailed extension status:
+The `useExtension()` hook provides extension status:
 
 ```javascript
 const {
-  state,        // 'idle' | 'checking' | 'connecting' | 'connected' | 'not-installed' | 'error'
+  state,        // 'checking' | 'connected' | 'not-available'
   isConnected,  // Extension is connected and ready
-  isConnecting, // Currently checking/connecting
-  isInstalled,  // Extension is installed (may still be connecting)
-  isChecked,    // Initial check complete
-  error,        // Error message if connection failed
-  connect,      // Function to manually retry connection
+  isChecking,   // Currently checking
+  isChecked,    // Check complete
+  refresh,      // Function to re-check extension availability
 } = useExtension();
 ```
 

package/dist/index.cjs

@@ -85,236 +85,10 @@ function chunk(array, size) {
   return chunks;
 }
 
-// src/extension.ts
-function checkExtension(timeout = 100) {
-  return new Promise((resolve) => {
-    var _a;
-    if (typeof window === "undefined") {
-      resolve(false);
-      return;
-    }
-    const win = window;
-    if ((_a = win.nostr) == null ? void 0 : _a.wot) {
-      resolve(true);
-      return;
-    }
-    const handler = () => {
-      window.removeEventListener("nostr-wot-present", handler);
-      clearTimeout(timer);
-      resolve(true);
-    };
-    window.addEventListener("nostr-wot-present", handler);
-    const timer = setTimeout(() => {
-      window.removeEventListener("nostr-wot-present", handler);
-      resolve(false);
-    }, timeout);
-    window.dispatchEvent(new CustomEvent("nostr-wot-check"));
-  });
-}
-function connectExtension(timeout = 5e3) {
-  return new Promise((resolve, reject) => {
-    var _a;
-    if (typeof window === "undefined") {
-      reject(new Error("Not in browser environment"));
-      return;
-    }
-    const win = window;
-    if ((_a = win.nostr) == null ? void 0 : _a.wot) {
-      resolve(win.nostr.wot);
-      return;
-    }
-    let timer;
-    const onReady = () => {
-      var _a2;
-      cleanup();
-      const ext = (_a2 = window.nostr) == null ? void 0 : _a2.wot;
-      if (ext) {
-        resolve(ext);
-      } else {
-        reject(new Error("Extension ready event fired but API not found"));
-      }
-    };
-    const onError = (e) => {
-      cleanup();
-      const detail = e.detail;
-      reject(new Error((detail == null ? void 0 : detail.error) || "Connection failed"));
-    };
-    const cleanup = () => {
-      clearTimeout(timer);
-      window.removeEventListener("nostr-wot-ready", onReady);
-      window.removeEventListener("nostr-wot-error", onError);
-    };
-    window.addEventListener("nostr-wot-ready", onReady);
-    window.addEventListener("nostr-wot-error", onError);
-    window.dispatchEvent(new CustomEvent("nostr-wot-connect"));
-    timer = setTimeout(() => {
-      cleanup();
-      reject(new Error("Connection timeout"));
-    }, timeout);
-  });
-}
-async function checkAndConnect(options = {}) {
-  var _a;
-  const { checkTimeout = 100, connectTimeout = 5e3, autoConnect = true } = options;
-  if (typeof window === "undefined") {
-    return { state: "not-installed", extension: null };
-  }
-  const win = window;
-  if ((_a = win.nostr) == null ? void 0 : _a.wot) {
-    return { state: "connected", extension: win.nostr.wot };
-  }
-  const isInstalled = await checkExtension(checkTimeout);
-  if (!isInstalled) {
-    return { state: "not-installed", extension: null };
-  }
-  if (!autoConnect) {
-    return { state: "idle", extension: null };
-  }
-  try {
-    const extension = await connectExtension(connectTimeout);
-    return { state: "connected", extension };
-  } catch (error) {
-    return {
-      state: "error",
-      extension: null,
-      error: error instanceof Error ? error.message : "Unknown error"
-    };
-  }
-}
-var ExtensionConnector = class {
-  constructor(options = {}) {
-    this.options = options;
-    this.state = "idle";
-    this.extension = null;
-    this.connectionPromise = null;
-    this.listeners = /* @__PURE__ */ new Set();
-  }
-  /**
-   * Get current state
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * Get current extension instance
-   */
-  getExtension() {
-    return this.extension;
-  }
-  /**
-   * Get current error
-   */
-  getError() {
-    return this.error;
-  }
-  /**
-   * Get current result
-   */
-  getResult() {
-    return {
-      state: this.state,
-      extension: this.extension,
-      error: this.error
-    };
-  }
-  /**
-   * Subscribe to state changes
-   */
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  notify() {
-    const result = this.getResult();
-    for (const listener of this.listeners) {
-      listener(result);
-    }
-  }
-  setState(state, extension = null, error) {
-    this.state = state;
-    this.extension = extension;
-    this.error = error;
-    this.notify();
-  }
-  /**
-   * Connect to the extension
-   * Returns existing promise if already connecting
-   */
-  async connect() {
-    if (this.state === "connected" && this.extension) {
-      return this.getResult();
-    }
-    if (this.connectionPromise) {
-      return this.connectionPromise;
-    }
-    this.connectionPromise = this.doConnect();
-    const result = await this.connectionPromise;
-    this.connectionPromise = null;
-    return result;
-  }
-  async doConnect() {
-    var _a;
-    const { checkTimeout = 100, connectTimeout = 5e3 } = this.options;
-    if (typeof window === "undefined") {
-      this.setState("not-installed");
-      return this.getResult();
-    }
-    const win = window;
-    if ((_a = win.nostr) == null ? void 0 : _a.wot) {
-      this.setState("connected", win.nostr.wot);
-      return this.getResult();
-    }
-    this.setState("checking");
-    const isInstalled = await checkExtension(checkTimeout);
-    if (!isInstalled) {
-      this.setState("not-installed");
-      return this.getResult();
-    }
-    this.setState("connecting");
-    try {
-      const extension = await connectExtension(connectTimeout);
-      this.setState("connected", extension);
-    } catch (error) {
-      this.setState(
-        "error",
-        null,
-        error instanceof Error ? error.message : "Unknown error"
-      );
-    }
-    return this.getResult();
-  }
-  /**
-   * Reset state and disconnect
-   */
-  reset() {
-    this.state = "idle";
-    this.extension = null;
-    this.error = void 0;
-    this.connectionPromise = null;
-    this.notify();
-  }
-};
-var defaultConnector = null;
-function getDefaultConnector(options) {
-  if (!defaultConnector) {
-    defaultConnector = new ExtensionConnector(options);
-  }
-  return defaultConnector;
-}
-function resetDefaultConnector() {
-  if (defaultConnector) {
-    defaultConnector.reset();
-    defaultConnector = null;
-  }
-}
-
 // src/wot.ts
 var WoT = class {
   constructor(options = {}) {
     this.extension = null;
-    this.extensionChecked = false;
     this.extensionPubkey = null;
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     this.fallbackOptions = (_a = options.fallback) != null ? _a : null;
@@ -335,16 +109,15 @@ var WoT = class {
   }
   /**
    * Checks if browser extension is available and returns it
-   * Uses event-based connection flow for reliable detection
-   * Always returns fresh reference from window.nostr.wot to handle extension reloads
+   * Simply checks window.nostr.wot - extension auto-injects when enabled
+   * Always returns fresh reference to handle extension reloads
    */
   async getExtension() {
-    var _a, _b, _c;
+    var _a, _b;
     if (typeof window === "undefined") return null;
     const win = window;
     if ((_a = win.nostr) == null ? void 0 : _a.wot) {
       this.extension = win.nostr.wot;
-      this.extensionChecked = true;
       if (!this.extensionPubkey) {
         try {
           this.extensionPubkey = await this.extension.getMyPubkey();
@@ -359,27 +132,8 @@ var WoT = class {
       }
       return this.extension;
     }
-    if (this.extensionChecked) return this.extension;
-    this.extensionChecked = true;
-    const result = await checkAndConnect({
-      checkTimeout: 100,
-      connectTimeout: 5e3,
-      autoConnect: true
-    });
-    if (result.state === "connected" && result.extension) {
-      this.extension = result.extension;
-      try {
-        this.extensionPubkey = await this.extension.getMyPubkey();
-      } catch (e) {
-        if ((_c = win.nostr) == null ? void 0 : _c.getPublicKey) {
-          try {
-            this.extensionPubkey = await win.nostr.getPublicKey();
-          } catch (e2) {
-          }
-        }
-      }
-    }
-    return this.extension;
+    this.extension = null;
+    return null;
   }
   /**
    * Gets the effective pubkey (from extension or fallback)
@@ -823,6 +577,231 @@ var WoT = class {
   }
 };
 
+// src/extension.ts
+function checkExtension(timeout = 100) {
+  return new Promise((resolve) => {
+    var _a;
+    if (typeof window === "undefined") {
+      resolve(false);
+      return;
+    }
+    const win = window;
+    if ((_a = win.nostr) == null ? void 0 : _a.wot) {
+      resolve(true);
+      return;
+    }
+    const handler = () => {
+      window.removeEventListener("nostr-wot-present", handler);
+      clearTimeout(timer);
+      resolve(true);
+    };
+    window.addEventListener("nostr-wot-present", handler);
+    const timer = setTimeout(() => {
+      window.removeEventListener("nostr-wot-present", handler);
+      resolve(false);
+    }, timeout);
+    window.dispatchEvent(new CustomEvent("nostr-wot-check"));
+  });
+}
+function connectExtension(timeout = 5e3) {
+  return new Promise((resolve, reject) => {
+    var _a;
+    if (typeof window === "undefined") {
+      reject(new Error("Not in browser environment"));
+      return;
+    }
+    const win = window;
+    if ((_a = win.nostr) == null ? void 0 : _a.wot) {
+      resolve(win.nostr.wot);
+      return;
+    }
+    let timer;
+    const onReady = () => {
+      var _a2;
+      cleanup();
+      const ext = (_a2 = window.nostr) == null ? void 0 : _a2.wot;
+      if (ext) {
+        resolve(ext);
+      } else {
+        reject(new Error("Extension ready event fired but API not found"));
+      }
+    };
+    const onError = (e) => {
+      cleanup();
+      const detail = e.detail;
+      reject(new Error((detail == null ? void 0 : detail.error) || "Connection failed"));
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      window.removeEventListener("nostr-wot-ready", onReady);
+      window.removeEventListener("nostr-wot-error", onError);
+    };
+    window.addEventListener("nostr-wot-ready", onReady);
+    window.addEventListener("nostr-wot-error", onError);
+    window.dispatchEvent(new CustomEvent("nostr-wot-connect"));
+    timer = setTimeout(() => {
+      cleanup();
+      reject(new Error("Connection timeout"));
+    }, timeout);
+  });
+}
+async function checkAndConnect(options = {}) {
+  var _a;
+  const { checkTimeout = 100, connectTimeout = 5e3, autoConnect = true } = options;
+  if (typeof window === "undefined") {
+    return { state: "not-installed", extension: null };
+  }
+  const win = window;
+  if ((_a = win.nostr) == null ? void 0 : _a.wot) {
+    return { state: "connected", extension: win.nostr.wot };
+  }
+  const isInstalled = await checkExtension(checkTimeout);
+  if (!isInstalled) {
+    return { state: "not-installed", extension: null };
+  }
+  if (!autoConnect) {
+    return { state: "idle", extension: null };
+  }
+  try {
+    const extension = await connectExtension(connectTimeout);
+    return { state: "connected", extension };
+  } catch (error) {
+    return {
+      state: "error",
+      extension: null,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+var ExtensionConnector = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.state = "idle";
+    this.extension = null;
+    this.connectionPromise = null;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get current extension instance
+   */
+  getExtension() {
+    return this.extension;
+  }
+  /**
+   * Get current error
+   */
+  getError() {
+    return this.error;
+  }
+  /**
+   * Get current result
+   */
+  getResult() {
+    return {
+      state: this.state,
+      extension: this.extension,
+      error: this.error
+    };
+  }
+  /**
+   * Subscribe to state changes
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify() {
+    const result = this.getResult();
+    for (const listener of this.listeners) {
+      listener(result);
+    }
+  }
+  setState(state, extension = null, error) {
+    this.state = state;
+    this.extension = extension;
+    this.error = error;
+    this.notify();
+  }
+  /**
+   * Connect to the extension
+   * Returns existing promise if already connecting
+   */
+  async connect() {
+    if (this.state === "connected" && this.extension) {
+      return this.getResult();
+    }
+    if (this.connectionPromise) {
+      return this.connectionPromise;
+    }
+    this.connectionPromise = this.doConnect();
+    const result = await this.connectionPromise;
+    this.connectionPromise = null;
+    return result;
+  }
+  async doConnect() {
+    var _a;
+    const { checkTimeout = 100, connectTimeout = 5e3 } = this.options;
+    if (typeof window === "undefined") {
+      this.setState("not-installed");
+      return this.getResult();
+    }
+    const win = window;
+    if ((_a = win.nostr) == null ? void 0 : _a.wot) {
+      this.setState("connected", win.nostr.wot);
+      return this.getResult();
+    }
+    this.setState("checking");
+    const isInstalled = await checkExtension(checkTimeout);
+    if (!isInstalled) {
+      this.setState("not-installed");
+      return this.getResult();
+    }
+    this.setState("connecting");
+    try {
+      const extension = await connectExtension(connectTimeout);
+      this.setState("connected", extension);
+    } catch (error) {
+      this.setState(
+        "error",
+        null,
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+    return this.getResult();
+  }
+  /**
+   * Reset state and disconnect
+   */
+  reset() {
+    this.state = "idle";
+    this.extension = null;
+    this.error = void 0;
+    this.connectionPromise = null;
+    this.notify();
+  }
+};
+var defaultConnector = null;
+function getDefaultConnector(options) {
+  if (!defaultConnector) {
+    defaultConnector = new ExtensionConnector(options);
+  }
+  return defaultConnector;
+}
+function resetDefaultConnector() {
+  if (defaultConnector) {
+    defaultConnector.reset();
+    defaultConnector = null;
+  }
+}
+
 exports.DEFAULT_MAX_HOPS = DEFAULT_MAX_HOPS;
 exports.DEFAULT_ORACLE = DEFAULT_ORACLE;
 exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;

package/dist/index.d.cts

@@ -365,13 +365,12 @@ declare class WoT {
     private readonly timeout;
     private readonly fallbackOptions;
     private extension;
-    private extensionChecked;
     private extensionPubkey;
     constructor(options?: WoTOptions);
     /**
      * Checks if browser extension is available and returns it
-     * Uses event-based connection flow for reliable detection
-     * Always returns fresh reference from window.nostr.wot to handle extension reloads
+     * Simply checks window.nostr.wot - extension auto-injects when enabled
+     * Always returns fresh reference to handle extension reloads
      */
     private getExtension;
     /**