nostr-wot-sdk 0.4.0 → 0.4.1

package/CHANGELOG.md

@@ -5,6 +5,24 @@ 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.4.1] - 2025-02-05
+
+### Changed
+
+- **`getDetails` now returns `score`** in addition to `hops` and `paths`
+  - Extension: `{ hops: 2, paths: 5, score: 0.65 }`
+  - Oracle fallback: `{ hops: 2, paths: 5, score: 0 }` (score is 0 when using oracle)
+
+- **`getDistanceBatch` now accepts options object** instead of boolean
+  - `{ includePaths: true }` - Include path counts
+  - `{ includeScores: true }` - Include trust scores
+  - `{ includePaths: true, includeScores: true }` - Include both
+  - Legacy boolean `true` still works (backwards compatible, same as `{ includePaths: true }`)
+
+### Added
+
+- New `DistanceBatchOptions` type exported for TypeScript users
+
 ## [0.4.0] - 2025-02-05
 
 ### Breaking Changes
@@ -153,6 +171,7 @@ function Profile({ pubkey }) {
 - TypeScript support with full type definitions
 - Error classes: `WoTError`, `NetworkError`, `NotFoundError`, `TimeoutError`, `ValidationError`
 
+[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
 [0.3.2]: https://github.com/nostr-wot/nostr-wot-sdk/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/nostr-wot/nostr-wot-sdk/compare/v0.3.0...v0.3.1

package/README.md

@@ -124,11 +124,11 @@ const results = await wot.batchCheck(['pk1...', 'pk2...', 'pk3...']);
 
 #### `getDetails(target, options?)`
 
-Get distance and path count details.
+Get distance, path count, and score details.
 ```javascript
 const details = await wot.getDetails('def456...');
-// Returns: { hops: 2, paths: 5 }
-// Oracle may also return: bridges, mutual
+// Returns: { hops: 2, paths: 5, score: 0.65 }
+// Oracle may also return: bridges, mutual (but score will be 0)
 ```
 
 #### `getMyPubkey()`
@@ -157,17 +157,28 @@ const config = await wot.getExtensionConfig();
 
 ### Batch Operations
 
-#### `getDistanceBatch(targets, includePaths?)`
+#### `getDistanceBatch(targets, options?)`
 
 Get distances for multiple pubkeys in a single call.
 ```javascript
-// Without paths (faster, default)
+// Default (just hops)
 const distances = await wot.getDistanceBatch(['pk1...', 'pk2...']);
 // Returns: { 'pk1...': 2, 'pk2...': null }
 
-// With paths (includes path count for scoring)
-const details = await wot.getDistanceBatch(['pk1...', 'pk2...'], true);
+// With paths
+const withPaths = await wot.getDistanceBatch(['pk1...', 'pk2...'], { includePaths: true });
 // Returns: { 'pk1...': { hops: 2, paths: 5 }, 'pk2...': null }
+
+// With scores
+const withScores = await wot.getDistanceBatch(['pk1...', 'pk2...'], { includeScores: true });
+// Returns: { 'pk1...': { hops: 2, score: 0.65 }, 'pk2...': null }
+
+// With both
+const full = await wot.getDistanceBatch(['pk1...', 'pk2...'], { includePaths: true, includeScores: true });
+// Returns: { 'pk1...': { hops: 2, paths: 5, score: 0.65 }, 'pk2...': null }
+
+// Legacy boolean still works (backwards compatible)
+const legacy = await wot.getDistanceBatch(['pk1...'], true);  // same as { includePaths: true }
 ```
 
 #### `getTrustScoreBatch(targets)`

package/dist/index.cjs

@@ -621,10 +621,11 @@ var WoT = class {
     const myPubkey = await this.getEffectivePubkey();
     const maxHops = (_a = options == null ? void 0 : options.maxHops) != null ? _a : this.maxHops;
     try {
-      return await this.apiRequest(
+      const response = await this.apiRequest(
         `/details/${myPubkey}/${normalizedTarget}?maxHops=${maxHops}`,
         options
       );
+      return { ...response, score: 0 };
     } catch (error) {
       if (error instanceof NotFoundError) {
         return null;
@@ -745,26 +746,32 @@ var WoT = class {
     const normalizedTarget = this.validatePubkey(target, "target");
     return ext.getPath(normalizedTarget);
   }
-  async getDistanceBatch(targets, includePaths = false) {
+  async getDistanceBatch(targets, options = false) {
     if (!Array.isArray(targets) || targets.length === 0) {
       return {};
     }
     const normalizedTargets = targets.map(
       (t, i) => this.validatePubkey(t, `targets[${i}]`)
     );
+    const opts = typeof options === "boolean" ? { includePaths: options } : options || {};
+    const { includePaths, includeScores } = opts;
     const ext = await this.getExtension();
     if (ext) {
-      if (includePaths) {
-        return ext.getDistanceBatch(normalizedTargets, true);
-      }
-      return ext.getDistanceBatch(normalizedTargets, false);
+      return ext.getDistanceBatch(normalizedTargets, opts);
     }
-    if (includePaths) {
+    if (includePaths || includeScores) {
       const results2 = {};
       await Promise.all(
         normalizedTargets.map(async (pubkey) => {
           const details = await this.getDetails(pubkey);
-          results2[pubkey] = details ? { hops: details.hops, paths: details.paths } : null;
+          if (!details) {
+            results2[pubkey] = null;
+            return;
+          }
+          const result = { hops: details.hops };
+          if (includePaths) result.paths = details.paths;
+          if (includeScores) result.score = details.score;
+          results2[pubkey] = result;
         })
       );
       return results2;

package/dist/index.d.cts

@@ -88,7 +88,7 @@ interface QueryOptions {
     timeout?: number;
 }
 /**
- * Distance result from extension (simpler)
+ * Distance result from extension
  */
 interface ExtensionDistanceResult {
     /**
@@ -99,6 +99,24 @@ interface ExtensionDistanceResult {
      * Number of distinct paths to target
      */
     paths: number;
+    /**
+     * Trust score (0-1)
+     * Note: Only available from extension, oracle returns 0
+     */
+    score: number;
+}
+/**
+ * Options for getDistanceBatch
+ */
+interface DistanceBatchOptions {
+    /**
+     * Include path count in results
+     */
+    includePaths?: boolean;
+    /**
+     * Include trust scores in results
+     */
+    includeScores?: boolean;
 }
 /**
  * Full distance result with additional details (from oracle)
@@ -231,8 +249,8 @@ interface NostrWoTExtension {
      */
     getTrustScore(target: string): Promise<number | null>;
     /**
-     * Get distance and path count details
-     * @returns Object with hops and paths count, or null if not connected
+     * Get distance, path count, and score details
+     * @returns Object with hops, paths, and score, or null if not connected
      */
     getDetails(target: string): Promise<ExtensionDistanceResult | null>;
     /**
@@ -243,17 +261,40 @@ interface NostrWoTExtension {
     /**
      * Get distances for multiple pubkeys in a single call
      * @param targets - Array of target pubkeys
-     * @param includePaths - When true, includes path count for each target
-     * @returns Map of pubkey to hop count (or { hops, paths } if includePaths is true)
-     */
-    getDistanceBatch(targets: string[], includePaths?: false): Promise<Record<string, number | null>>;
-    getDistanceBatch(targets: string[], includePaths: true): Promise<Record<string, {
+     * @param options - Options object or boolean for backwards compatibility
+     *   - `{ includePaths: true }` - Include path counts
+     *   - `{ includeScores: true }` - Include trust scores
+     *   - `{ includePaths: true, includeScores: true }` - Include both
+     *   - `true` (legacy) - Same as `{ includePaths: true }`
+     * @returns Map of pubkey to result based on options
+     */
+    getDistanceBatch(targets: string[], options?: false | undefined): Promise<Record<string, number | null>>;
+    getDistanceBatch(targets: string[], options: true | {
+        includePaths: true;
+        includeScores?: false;
+    }): Promise<Record<string, {
         hops: number;
         paths: number;
     } | null>>;
-    getDistanceBatch(targets: string[], includePaths?: boolean): Promise<Record<string, number | {
+    getDistanceBatch(targets: string[], options: {
+        includePaths?: false;
+        includeScores: true;
+    }): Promise<Record<string, {
+        hops: number;
+        score: number;
+    } | null>>;
+    getDistanceBatch(targets: string[], options: {
+        includePaths: true;
+        includeScores: true;
+    }): Promise<Record<string, {
         hops: number;
         paths: number;
+        score: number;
+    } | null>>;
+    getDistanceBatch(targets: string[], options?: boolean | DistanceBatchOptions): Promise<Record<string, number | {
+        hops: number;
+        paths?: number;
+        score?: number;
     } | null>>;
     /**
      * Get trust scores for multiple pubkeys in a single call
@@ -455,17 +496,40 @@ declare class WoT {
     /**
      * Get distances for multiple pubkeys in a single call
      * @param targets - Array of target pubkeys
-     * @param includePaths - When true, includes path count for each target
-     * @returns Record of pubkey to hop count (or { hops, paths } if includePaths is true)
-     */
-    getDistanceBatch(targets: string[], includePaths?: false): Promise<Record<string, number | null>>;
-    getDistanceBatch(targets: string[], includePaths: true): Promise<Record<string, {
+     * @param options - Options object or boolean for backwards compatibility
+     *   - `{ includePaths: true }` - Include path counts
+     *   - `{ includeScores: true }` - Include trust scores
+     *   - `{ includePaths: true, includeScores: true }` - Include both
+     *   - `true` (legacy) - Same as `{ includePaths: true }`
+     * @returns Record of pubkey to result based on options
+     */
+    getDistanceBatch(targets: string[], options?: false | undefined): Promise<Record<string, number | null>>;
+    getDistanceBatch(targets: string[], options: true | {
+        includePaths: true;
+        includeScores?: false;
+    }): Promise<Record<string, {
         hops: number;
         paths: number;
     } | null>>;
-    getDistanceBatch(targets: string[], includePaths?: boolean): Promise<Record<string, number | {
+    getDistanceBatch(targets: string[], options: {
+        includePaths?: false;
+        includeScores: true;
+    }): Promise<Record<string, {
+        hops: number;
+        score: number;
+    } | null>>;
+    getDistanceBatch(targets: string[], options: {
+        includePaths: true;
+        includeScores: true;
+    }): Promise<Record<string, {
         hops: number;
         paths: number;
+        score: number;
+    } | null>>;
+    getDistanceBatch(targets: string[], options?: boolean | DistanceBatchOptions): Promise<Record<string, number | {
+        hops: number;
+        paths?: number;
+        score?: number;
     } | null>>;
     /**
      * Get trust scores for multiple pubkeys in a single call
@@ -644,4 +708,4 @@ declare const MAX_BATCH_SIZE = 10000;
  */
 declare function normalizePubkey(pubkey: string): string;
 
-export { type BatchResult, DEFAULT_MAX_HOPS, DEFAULT_ORACLE, DEFAULT_TIMEOUT, type DistanceResult, type ExtensionConfig, type ExtensionConnectionOptions, type ExtensionConnectionResult, type ExtensionConnectionState, ExtensionConnector, type ExtensionDistanceResult, type ExtensionStatus, type GraphStats, MAX_BATCH_SIZE, NetworkError, type NostrContactEvent, type NostrWindow, type NostrWoTExtension, NotFoundError, type QueryOptions, type ScoringConfig, TimeoutError, ValidationError, WoT, WoTError, type WoTFallbackOptions, type WoTOptions, checkAndConnect, checkExtension, connectExtension, getDefaultConnector, isValidOracleUrl, isValidPubkey, normalizePubkey, resetDefaultConnector };
+export { type BatchResult, DEFAULT_MAX_HOPS, DEFAULT_ORACLE, DEFAULT_TIMEOUT, type DistanceBatchOptions, type DistanceResult, type ExtensionConfig, type ExtensionConnectionOptions, type ExtensionConnectionResult, type ExtensionConnectionState, ExtensionConnector, type ExtensionDistanceResult, type ExtensionStatus, type GraphStats, MAX_BATCH_SIZE, NetworkError, type NostrContactEvent, type NostrWindow, type NostrWoTExtension, NotFoundError, type QueryOptions, type ScoringConfig, TimeoutError, ValidationError, WoT, WoTError, type WoTFallbackOptions, type WoTOptions, checkAndConnect, checkExtension, connectExtension, getDefaultConnector, isValidOracleUrl, isValidPubkey, normalizePubkey, resetDefaultConnector };

package/dist/index.d.ts

@@ -88,7 +88,7 @@ interface QueryOptions {
     timeout?: number;
 }
 /**
- * Distance result from extension (simpler)
+ * Distance result from extension
  */
 interface ExtensionDistanceResult {
     /**
@@ -99,6 +99,24 @@ interface ExtensionDistanceResult {
      * Number of distinct paths to target
      */
     paths: number;
+    /**
+     * Trust score (0-1)
+     * Note: Only available from extension, oracle returns 0
+     */
+    score: number;
+}
+/**
+ * Options for getDistanceBatch
+ */
+interface DistanceBatchOptions {
+    /**
+     * Include path count in results
+     */
+    includePaths?: boolean;
+    /**
+     * Include trust scores in results
+     */
+    includeScores?: boolean;
 }
 /**
  * Full distance result with additional details (from oracle)
@@ -231,8 +249,8 @@ interface NostrWoTExtension {
      */
     getTrustScore(target: string): Promise<number | null>;
     /**
-     * Get distance and path count details
-     * @returns Object with hops and paths count, or null if not connected
+     * Get distance, path count, and score details
+     * @returns Object with hops, paths, and score, or null if not connected
      */
     getDetails(target: string): Promise<ExtensionDistanceResult | null>;
     /**
@@ -243,17 +261,40 @@ interface NostrWoTExtension {
     /**
      * Get distances for multiple pubkeys in a single call
      * @param targets - Array of target pubkeys
-     * @param includePaths - When true, includes path count for each target
-     * @returns Map of pubkey to hop count (or { hops, paths } if includePaths is true)
-     */
-    getDistanceBatch(targets: string[], includePaths?: false): Promise<Record<string, number | null>>;
-    getDistanceBatch(targets: string[], includePaths: true): Promise<Record<string, {
+     * @param options - Options object or boolean for backwards compatibility
+     *   - `{ includePaths: true }` - Include path counts
+     *   - `{ includeScores: true }` - Include trust scores
+     *   - `{ includePaths: true, includeScores: true }` - Include both
+     *   - `true` (legacy) - Same as `{ includePaths: true }`
+     * @returns Map of pubkey to result based on options
+     */
+    getDistanceBatch(targets: string[], options?: false | undefined): Promise<Record<string, number | null>>;
+    getDistanceBatch(targets: string[], options: true | {
+        includePaths: true;
+        includeScores?: false;
+    }): Promise<Record<string, {
         hops: number;
         paths: number;
     } | null>>;
-    getDistanceBatch(targets: string[], includePaths?: boolean): Promise<Record<string, number | {
+    getDistanceBatch(targets: string[], options: {
+        includePaths?: false;
+        includeScores: true;
+    }): Promise<Record<string, {
+        hops: number;
+        score: number;
+    } | null>>;
+    getDistanceBatch(targets: string[], options: {
+        includePaths: true;
+        includeScores: true;
+    }): Promise<Record<string, {
         hops: number;
         paths: number;
+        score: number;
+    } | null>>;
+    getDistanceBatch(targets: string[], options?: boolean | DistanceBatchOptions): Promise<Record<string, number | {
+        hops: number;
+        paths?: number;
+        score?: number;
     } | null>>;
     /**
      * Get trust scores for multiple pubkeys in a single call
@@ -455,17 +496,40 @@ declare class WoT {
     /**
      * Get distances for multiple pubkeys in a single call
      * @param targets - Array of target pubkeys
-     * @param includePaths - When true, includes path count for each target
-     * @returns Record of pubkey to hop count (or { hops, paths } if includePaths is true)
-     */
-    getDistanceBatch(targets: string[], includePaths?: false): Promise<Record<string, number | null>>;
-    getDistanceBatch(targets: string[], includePaths: true): Promise<Record<string, {
+     * @param options - Options object or boolean for backwards compatibility
+     *   - `{ includePaths: true }` - Include path counts
+     *   - `{ includeScores: true }` - Include trust scores
+     *   - `{ includePaths: true, includeScores: true }` - Include both
+     *   - `true` (legacy) - Same as `{ includePaths: true }`
+     * @returns Record of pubkey to result based on options
+     */
+    getDistanceBatch(targets: string[], options?: false | undefined): Promise<Record<string, number | null>>;
+    getDistanceBatch(targets: string[], options: true | {
+        includePaths: true;
+        includeScores?: false;
+    }): Promise<Record<string, {
         hops: number;
         paths: number;
     } | null>>;
-    getDistanceBatch(targets: string[], includePaths?: boolean): Promise<Record<string, number | {
+    getDistanceBatch(targets: string[], options: {
+        includePaths?: false;
+        includeScores: true;
+    }): Promise<Record<string, {
+        hops: number;
+        score: number;
+    } | null>>;
+    getDistanceBatch(targets: string[], options: {
+        includePaths: true;
+        includeScores: true;
+    }): Promise<Record<string, {
         hops: number;
         paths: number;
+        score: number;
+    } | null>>;
+    getDistanceBatch(targets: string[], options?: boolean | DistanceBatchOptions): Promise<Record<string, number | {
+        hops: number;
+        paths?: number;
+        score?: number;
     } | null>>;
     /**
      * Get trust scores for multiple pubkeys in a single call
@@ -644,4 +708,4 @@ declare const MAX_BATCH_SIZE = 10000;
  */
 declare function normalizePubkey(pubkey: string): string;
 
-export { type BatchResult, DEFAULT_MAX_HOPS, DEFAULT_ORACLE, DEFAULT_TIMEOUT, type DistanceResult, type ExtensionConfig, type ExtensionConnectionOptions, type ExtensionConnectionResult, type ExtensionConnectionState, ExtensionConnector, type ExtensionDistanceResult, type ExtensionStatus, type GraphStats, MAX_BATCH_SIZE, NetworkError, type NostrContactEvent, type NostrWindow, type NostrWoTExtension, NotFoundError, type QueryOptions, type ScoringConfig, TimeoutError, ValidationError, WoT, WoTError, type WoTFallbackOptions, type WoTOptions, checkAndConnect, checkExtension, connectExtension, getDefaultConnector, isValidOracleUrl, isValidPubkey, normalizePubkey, resetDefaultConnector };
+export { type BatchResult, DEFAULT_MAX_HOPS, DEFAULT_ORACLE, DEFAULT_TIMEOUT, type DistanceBatchOptions, type DistanceResult, type ExtensionConfig, type ExtensionConnectionOptions, type ExtensionConnectionResult, type ExtensionConnectionState, ExtensionConnector, type ExtensionDistanceResult, type ExtensionStatus, type GraphStats, MAX_BATCH_SIZE, NetworkError, type NostrContactEvent, type NostrWindow, type NostrWoTExtension, NotFoundError, type QueryOptions, type ScoringConfig, TimeoutError, ValidationError, WoT, WoTError, type WoTFallbackOptions, type WoTOptions, checkAndConnect, checkExtension, connectExtension, getDefaultConnector, isValidOracleUrl, isValidPubkey, normalizePubkey, resetDefaultConnector };

package/dist/index.js

@@ -619,10 +619,11 @@ var WoT = class {
     const myPubkey = await this.getEffectivePubkey();
     const maxHops = (_a = options == null ? void 0 : options.maxHops) != null ? _a : this.maxHops;
     try {
-      return await this.apiRequest(
+      const response = await this.apiRequest(
         `/details/${myPubkey}/${normalizedTarget}?maxHops=${maxHops}`,
         options
       );
+      return { ...response, score: 0 };
     } catch (error) {
       if (error instanceof NotFoundError) {
         return null;
@@ -743,26 +744,32 @@ var WoT = class {
     const normalizedTarget = this.validatePubkey(target, "target");
     return ext.getPath(normalizedTarget);
   }
-  async getDistanceBatch(targets, includePaths = false) {
+  async getDistanceBatch(targets, options = false) {
     if (!Array.isArray(targets) || targets.length === 0) {
       return {};
     }
     const normalizedTargets = targets.map(
       (t, i) => this.validatePubkey(t, `targets[${i}]`)
     );
+    const opts = typeof options === "boolean" ? { includePaths: options } : options || {};
+    const { includePaths, includeScores } = opts;
     const ext = await this.getExtension();
     if (ext) {
-      if (includePaths) {
-        return ext.getDistanceBatch(normalizedTargets, true);
-      }
-      return ext.getDistanceBatch(normalizedTargets, false);
+      return ext.getDistanceBatch(normalizedTargets, opts);
     }
-    if (includePaths) {
+    if (includePaths || includeScores) {
       const results2 = {};
       await Promise.all(
         normalizedTargets.map(async (pubkey) => {
           const details = await this.getDetails(pubkey);
-          results2[pubkey] = details ? { hops: details.hops, paths: details.paths } : null;
+          if (!details) {
+            results2[pubkey] = null;
+            return;
+          }
+          const result = { hops: details.hops };
+          if (includePaths) result.paths = details.paths;
+          if (includeScores) result.score = details.score;
+          results2[pubkey] = result;
         })
       );
       return results2;

package/dist/react/index.cjs

@@ -613,10 +613,11 @@ var WoT = class {
     const myPubkey = await this.getEffectivePubkey();
     const maxHops = (_a = options == null ? void 0 : options.maxHops) != null ? _a : this.maxHops;
     try {
-      return await this.apiRequest(
+      const response = await this.apiRequest(
         `/details/${myPubkey}/${normalizedTarget}?maxHops=${maxHops}`,
         options
       );
+      return { ...response, score: 0 };
     } catch (error) {
       if (error instanceof NotFoundError) {
         return null;
@@ -737,26 +738,32 @@ var WoT = class {
     const normalizedTarget = this.validatePubkey(target, "target");
     return ext.getPath(normalizedTarget);
   }
-  async getDistanceBatch(targets, includePaths = false) {
+  async getDistanceBatch(targets, options = false) {
     if (!Array.isArray(targets) || targets.length === 0) {
       return {};
     }
     const normalizedTargets = targets.map(
       (t, i) => this.validatePubkey(t, `targets[${i}]`)
     );
+    const opts = typeof options === "boolean" ? { includePaths: options } : options || {};
+    const { includePaths, includeScores } = opts;
     const ext = await this.getExtension();
     if (ext) {
-      if (includePaths) {
-        return ext.getDistanceBatch(normalizedTargets, true);
-      }
-      return ext.getDistanceBatch(normalizedTargets, false);
+      return ext.getDistanceBatch(normalizedTargets, opts);
     }
-    if (includePaths) {
+    if (includePaths || includeScores) {
       const results2 = {};
       await Promise.all(
         normalizedTargets.map(async (pubkey) => {
           const details = await this.getDetails(pubkey);
-          results2[pubkey] = details ? { hops: details.hops, paths: details.paths } : null;
+          if (!details) {
+            results2[pubkey] = null;
+            return;
+          }
+          const result = { hops: details.hops };
+          if (includePaths) result.paths = details.paths;
+          if (includeScores) result.score = details.score;
+          results2[pubkey] = result;
         })
       );
       return results2;