holosphere 2.0.0-alpha12 → 2.0.0-alpha13

package/src/federation/registry.js

@@ -147,22 +147,61 @@ export async function getFederatedPartner(client, appname, partnerPubKey) {
  */
 export async function getCapabilityForAuthor(client, appname, authorPubKey, scope) {
   const registry = await getFederationRegistry(client, appname);
+
+  console.log('[Registry] 🔍 getCapabilityForAuthor called:', {
+    authorPubKey: authorPubKey?.slice(0, 12) + '...',
+    scope,
+    federatedWithCount: registry.federatedWith?.length || 0,
+    federatedPartners: registry.federatedWith?.map(p => p.pubKey?.slice(0, 12) + '...') || []
+  });
+
   const partner = registry.federatedWith.find(p => p.pubKey === authorPubKey);
 
-  if (!partner || !partner.inboundCapabilities) {
+  if (!partner) {
+    console.log('[Registry] ❌ Partner not found in federatedWith');
+    return null;
+  }
+
+  if (!partner.inboundCapabilities || partner.inboundCapabilities.length === 0) {
+    console.log('[Registry] ❌ Partner has no inboundCapabilities:', {
+      partnerPubKey: authorPubKey?.slice(0, 12) + '...',
+      hasInboundCaps: !!partner.inboundCapabilities,
+      inboundCapsLength: partner.inboundCapabilities?.length || 0
+    });
     return null;
   }
 
+  console.log('[Registry] Partner found with inboundCapabilities:', {
+    partnerPubKey: authorPubKey?.slice(0, 12) + '...',
+    capsCount: partner.inboundCapabilities.length,
+    capScopes: partner.inboundCapabilities.map(c => c.scope)
+  });
+
   // Find matching, non-expired capability
-  return partner.inboundCapabilities.find(cap => {
+  const result = partner.inboundCapabilities.find(cap => {
     // Check expiration
     if (cap.expires && cap.expires < Date.now()) {
+      console.log('[Registry] Capability expired:', { expires: cap.expires, now: Date.now() });
       return false;
     }
 
     // Check scope match (supports wildcards)
-    return matchScope(cap.scope, scope);
+    const matches = matchScope(cap.scope, scope);
+    console.log('[Registry] Scope match check:', {
+      capScope: cap.scope,
+      requestedScope: scope,
+      matches
+    });
+    return matches;
   }) || null;
+
+  if (result) {
+    console.log('[Registry] ✅ Matching capability found');
+  } else {
+    console.log('[Registry] ❌ No matching capability found');
+  }
+
+  return result;
 }
 
 /**
@@ -178,10 +217,17 @@ export async function getCapabilityForAuthor(client, appname, authorPubKey, scop
  * @returns {Promise<boolean>} Success indicator
  */
 export async function storeInboundCapability(client, appname, partnerPubKey, capabilityInfo) {
+  console.log('[Registry] 📥 storeInboundCapability called:', {
+    partnerPubKey: partnerPubKey?.slice(0, 12) + '...',
+    scope: capabilityInfo?.scope,
+    hasToken: !!capabilityInfo?.token
+  });
+
   const registry = await getFederationRegistry(client, appname);
   const partner = registry.federatedWith.find(p => p.pubKey === partnerPubKey);
 
   if (!partner) {
+    console.log('[Registry] Partner not in registry, auto-adding with capability');
     // Auto-add partner if not exists
     return addFederatedPartner(client, appname, partnerPubKey, {
       addedVia: 'capability_received',
@@ -199,12 +245,14 @@ export async function storeInboundCapability(client, appname, partnerPubKey, cap
   );
 
   if (existingIndex >= 0) {
+    console.log('[Registry] Updating existing capability at index:', existingIndex);
     // Update existing capability
     partner.inboundCapabilities[existingIndex] = {
       ...capabilityInfo,
       updatedAt: Date.now()
     };
   } else {
+    console.log('[Registry] Adding new capability, total will be:', partner.inboundCapabilities.length + 1);
     // Add new capability
     partner.inboundCapabilities.push({
       ...capabilityInfo,
@@ -212,7 +260,9 @@ export async function storeInboundCapability(client, appname, partnerPubKey, cap
     });
   }
 
-  return saveFederationRegistry(client, appname, registry);
+  const result = await saveFederationRegistry(client, appname, registry);
+  console.log('[Registry] ✅ Capability stored, registry saved:', result);
+  return result;
 }
 
 /**

package/src/index.js

@@ -321,6 +321,7 @@ class HoloSphereBase extends HoloSphereCore {
    * @param {boolean} [options.autoPropagate=true] - Whether to propagate to federated holons
    * @param {Object} [options.propagationOptions] - Options for propagation
    * @param {boolean} [options.blocking=false] - If true, wait for relay confirmation before returning
+   * @param {string} [options.signingKey] - Private key to sign with (hex format). If not provided, uses holosphere's default key.
    * @returns {Promise<boolean>} True if write succeeded (or queued for optimistic writes)
    * @throws {ValidationError} If holonId, lensName, or data is invalid
    * @throws {AuthorizationError} If capability token is invalid
@@ -427,7 +428,8 @@ class HoloSphereBase extends HoloSphereCore {
       }
 
       // Regular write to relay
-      await storage.write(this.client, path, data);
+      const writeOptions = options.signingKey ? { signingKey: options.signingKey } : {};
+      await storage.write(this.client, path, data, writeOptions);
 
       const endTime = Date.now();
       const duration = endTime - startTime;
@@ -688,6 +690,34 @@ class HoloSphereBase extends HoloSphereCore {
       throw new ValidationError('ValidationError: lensName must be a non-empty string');
     }
 
+    // OPTIMIZATION: Check local caches first before any network/registry operations
+    // This ensures data we just wrote can be read back immediately (important for capability-based writes)
+    if (dataId) {
+      const earlyPath = storage.buildPath(this.config.appName, holonId, lensName, dataId);
+
+      // Check delete cache first - if deleted, return null immediately
+      if (this._deleteCache.has(earlyPath)) {
+        this._log('DEBUG', '🗑️ EARLY CACHE: Deleted item', { path: earlyPath });
+        return null;
+      }
+
+      // Check write cache - if this instance wrote data, return it immediately
+      const cached = this._writeCache.get(earlyPath);
+      if (cached) {
+        const cacheAge = Date.now() - cached.timestamp;
+        this._log('DEBUG', '⚡ EARLY CACHE HIT: Write cache', {
+          path: earlyPath,
+          cacheAge: `${cacheAge}ms`
+        });
+        // Still resolve holograms if needed
+        const { resolveHolograms = true } = options;
+        if (resolveHolograms && cached.data) {
+          return this._resolveHolograms(cached.data);
+        }
+        return cached.data;
+      }
+    }
+
     // Resolve holonId to public key (if registered)
     const targetPubkey = await this._resolveHolonToPubkey(holonId);
 
@@ -709,11 +739,27 @@ class HoloSphereBase extends HoloSphereCore {
       }
     } else if (isOtherAuthor) {
       // Auto-check capability for other author's data
+      this._log('DEBUG', '🔍 Looking up capability for federated author', {
+        holonId,
+        lensName,
+        dataId: dataId || '*',
+        targetPubkey: targetPubkey?.slice(0, 12) + '...',
+        myPubkey: this.client?.publicKey?.slice(0, 12) + '...'
+      });
       const capability = await this._getCapabilityForAuthor(targetPubkey, { holonId, lensName, dataId });
       if (!capability) {
-        this._log('DEBUG', 'No capability for author', { holonId, targetPubkey });
+        this._log('WARN', '❌ No capability found for federated author - returning empty', {
+          holonId,
+          lensName,
+          targetPubkey: targetPubkey?.slice(0, 12) + '...'
+        });
         return dataId ? null : [];
       }
+      this._log('DEBUG', '✅ Capability found for federated author', {
+        holonId,
+        lensName,
+        targetPubkey: targetPubkey?.slice(0, 12) + '...'
+      });
       readOptions.authors = [targetPubkey];
     }
 
@@ -753,8 +799,10 @@ class HoloSphereBase extends HoloSphereCore {
         });
         result = null;
       } else {
-        // Check write cache for optimistic reads (only for own data)
-        const cached = !isOtherAuthor ? this._writeCache.get(path) : null;
+        // Check write cache for optimistic reads
+        // Always check write cache first - if this instance wrote data, it should be able to read it back
+        // regardless of holon ownership (important for capability-based writes)
+        const cached = this._writeCache.get(path);
         if (cached) {
           const cacheAge = Date.now() - cached.timestamp;
           this._log('DEBUG', '⚡ CACHE HIT: Write cache', {

package/src/storage/indexeddb-storage.js

@@ -39,6 +39,7 @@ export class IndexedDBStorage extends PersistentStorage {
    * Initialize storage with namespace.
    *
    * Creates or opens the IndexedDB database and object store.
+   * Handles version conflicts by deleting and recreating the database if needed.
    *
    * @param {string} namespace - Storage namespace
    * @returns {Promise<void>}
@@ -46,6 +47,27 @@ export class IndexedDBStorage extends PersistentStorage {
   async init(namespace) {
     this.dbName = `holosphere_${namespace}`;
 
+    try {
+      await this._openDatabase();
+    } catch (error) {
+      // Handle version conflict by deleting and recreating the database
+      if (error.name === 'VersionError') {
+        console.warn(`[IndexedDBStorage] Version conflict detected for ${this.dbName}, recreating database...`);
+        await this._deleteDatabase();
+        await this._openDatabase();
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Open the IndexedDB database.
+   *
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _openDatabase() {
     return new Promise((resolve, reject) => {
       const request = indexedDB.open(this.dbName, 1);
 
@@ -69,6 +91,25 @@ export class IndexedDBStorage extends PersistentStorage {
     });
   }
 
+  /**
+   * Delete the IndexedDB database.
+   *
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _deleteDatabase() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.deleteDatabase(this.dbName);
+      request.onsuccess = () => resolve(undefined);
+      request.onerror = () => reject(request.error);
+      request.onblocked = () => {
+        console.warn(`[IndexedDBStorage] Database deletion blocked for ${this.dbName}`);
+        // Still resolve - the next open attempt will handle it
+        resolve(undefined);
+      };
+    });
+  }
+
   /**
    * Store an event.
    *

package/src/storage/nostr-async.js

@@ -42,13 +42,21 @@ const QUERY_DEDUP_WINDOW = 2000;
  * @param {Object} client - NostrClient instance
  * @param {string} path - Path identifier (encoded in d-tag)
  * @param {Object} data - Data to store
- * @param {number} [kind=30000] - Event kind (default: 30000 for parameterized replaceable)
+ * @param {number|Object} [kindOrOptions=30000] - Event kind (number) or options object
+ * @param {number} [kindOrOptions.kind=30000] - Event kind
+ * @param {string} [kindOrOptions.signingKey] - Private key to sign with (hex format)
  * @returns {Promise<Object>} Published event result with relay responses
  * @example
  * const result = await nostrPut(client, 'myapp/holon123/items/item1', { name: 'Test' });
  * console.log(result.event.id); // Event ID
  */
-export async function nostrPut(client, path, data, kind = 30000) {
+export async function nostrPut(client, path, data, kindOrOptions = 30000) {
+  // Support both old signature (kind as number) and new signature (options object)
+  const options = typeof kindOrOptions === 'number'
+    ? { kind: kindOrOptions }
+    : kindOrOptions;
+  const kind = options.kind || 30000;
+
   const dataEvent = {
     kind,
     created_at: Math.floor(Date.now() / 1000),
@@ -58,7 +66,8 @@ export async function nostrPut(client, path, data, kind = 30000) {
     content: JSON.stringify(data),
   };
 
-  const result = await client.publish(dataEvent);
+  const publishOptions = options.signingKey ? { signingKey: options.signingKey } : {};
+  const result = await client.publish(dataEvent, publishOptions);
   return result;
 }
 

package/src/storage/nostr-client.js

@@ -369,14 +369,27 @@ export class NostrClient {
     let cacheAdapter = null;
 
     if (CacheAdapter && this.config.appName) {
+      // Use distinct name from IndexedDBStorage to avoid conflicts
+      const dbName = `holosphere_ndk_${this.config.appName}`;
+
+      // Pre-emptively check for and clear incompatible NDK cache database
+      // This prevents async Dexie UpgradeError crashes during background cache operations
+      await this._clearIncompatibleNDKCache(dbName);
+
       try {
         // Create NDK cache adapter with app-specific database name
-        cacheAdapter = new CacheAdapter({
-          dbName: `holosphere_${this.config.appName}`,
-        });
+        cacheAdapter = new CacheAdapter({ dbName });
         this._useNDKCache = true;
       } catch (e) {
         console.warn('[nostr] Failed to initialize NDK cache adapter:', e.message);
+        // Try once more after clearing the database
+        await this._deleteDexieDatabase(dbName);
+        try {
+          cacheAdapter = new CacheAdapter({ dbName });
+          this._useNDKCache = true;
+        } catch (retryError) {
+          console.warn('[nostr] Failed to initialize NDK cache adapter after reset:', retryError.message);
+        }
       }
     }
 
@@ -529,6 +542,83 @@ export class NostrClient {
     }
   }
 
+  /**
+   * Check if NDK cache database exists with potentially incompatible schema.
+   * NDK cache adapter uses Dexie which can't handle primary key changes.
+   * We detect this by checking if the database exists and clearing it if needed.
+   * @param {string} dbName - The database name to check
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _clearIncompatibleNDKCache(dbName) {
+    if (typeof indexedDB === 'undefined') return;
+
+    // Check if database exists and get its version
+    const databases = await indexedDB.databases?.() || [];
+    const existingDb = databases.find(db => db.name === dbName);
+
+    if (existingDb) {
+      // NDK cache adapter expects specific schema versions
+      // If the database exists but was created with an incompatible version,
+      // we need to delete it to prevent UpgradeError crashes
+      // The NDK cache adapter will recreate it with the correct schema
+      try {
+        await new Promise((resolve, reject) => {
+          const request = indexedDB.open(dbName);
+          request.onsuccess = () => {
+            const db = request.result;
+            const storeNames = Array.from(db.objectStoreNames);
+            db.close();
+
+            // Check for known incompatible schemas (missing required stores or wrong structure)
+            // NDK cache adapter expects: events, eventTags, users, nip05, profiles, etc.
+            const requiredStores = ['events', 'eventTags'];
+            const hasRequiredStores = requiredStores.every(name => storeNames.includes(name));
+
+            if (!hasRequiredStores && storeNames.length > 0) {
+              // Database exists but doesn't have the right structure
+              console.warn(`[nostr] NDK cache database ${dbName} has incompatible schema, clearing...`);
+              this._deleteDexieDatabase(dbName).then(resolve).catch(resolve);
+            } else {
+              resolve();
+            }
+          };
+          request.onerror = () => resolve(); // Ignore errors, continue without cache
+          request.onblocked = () => resolve();
+        });
+      } catch {
+        // Ignore errors during compatibility check
+      }
+    }
+  }
+
+  /**
+   * Delete a Dexie database by name.
+   * Used to recover from schema upgrade errors.
+   * @param {string} dbName - The database name to delete
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _deleteDexieDatabase(dbName) {
+    if (typeof indexedDB === 'undefined') return;
+
+    return new Promise((resolve) => {
+      const request = indexedDB.deleteDatabase(dbName);
+      request.onsuccess = () => {
+        console.log(`[nostr] Deleted incompatible database: ${dbName}`);
+        resolve();
+      };
+      request.onerror = () => {
+        console.warn(`[nostr] Failed to delete database: ${dbName}`);
+        resolve(); // Resolve anyway to continue initialization
+      };
+      request.onblocked = () => {
+        console.warn(`[nostr] Database deletion blocked: ${dbName}`);
+        resolve(); // Resolve anyway to continue initialization
+      };
+    });
+  }
+
   /**
    * Load events from persistent storage into cache
    * @private
@@ -645,6 +735,7 @@ export class NostrClient {
    * @param {Object} [options={}] - Publish options
    * @param {boolean} [options.waitForRelays=false] - Wait for relay confirmation
    * @param {boolean} [options.debounce=true] - Debounce rapid writes to same d-tag
+   * @param {string} [options.signingKey] - Private key to sign with (hex format). If not provided, uses client's default key.
    * @returns {Promise<Object>} Signed event with relay publish results
    * @example
    * const result = await client.publish({
@@ -707,7 +798,7 @@ export class NostrClient {
       pendingWrites.set(dTagPath, { event, timer, resolve, reject });
 
       // Cache immediately for local-first reads (even before relay publish)
-      const signedEvent = this._createSignedEvent(event);
+      const signedEvent = this._createSignedEvent(event, options.signingKey);
       this._cacheEvent(signedEvent);
     });
   }
@@ -716,9 +807,13 @@ export class NostrClient {
    * Create a signed event using NDK or nostr-tools fallback.
    * @private
    * @param {Object} event - Unsigned event
+   * @param {string} [signingKey] - Optional private key to sign with (hex format)
    * @returns {Object} Signed event
    */
-  _createSignedEvent(event) {
+  _createSignedEvent(event, signingKey = null) {
+    const keyToUse = signingKey || this.privateKey;
+    const pubkeyToUse = signingKey ? nostrToolsGetPublicKey(hexToBytes(signingKey)) : this.publicKey;
+
     // If NDK is available and we have a signer, use NDKEvent
     if (this.ndk) {
       const ndkEvent = new NDKEvent(this.ndk);
@@ -733,7 +828,7 @@ export class NostrClient {
         content: ndkEvent.content,
         tags: ndkEvent.tags,
         created_at: ndkEvent.created_at,
-        pubkey: this.publicKey,
+        pubkey: pubkeyToUse,
         id: '', // Will be set during actual publish
         sig: '', // Will be set during actual publish
       };
@@ -741,12 +836,12 @@ export class NostrClient {
 
     // Mock mode - use nostr-tools to create a properly signed event
     try {
-      return nostrToolsFinalizeEvent(event, hexToBytes(this.privateKey));
+      return nostrToolsFinalizeEvent(event, hexToBytes(keyToUse));
     } catch (e) {
       // Return mock signed event if signing fails
       return {
         ...event,
-        pubkey: this.publicKey,
+        pubkey: pubkeyToUse,
         id: Math.random().toString(16).slice(2).padStart(64, '0'),
         sig: 'mock-signature',
         created_at: event.created_at || Math.floor(Date.now() / 1000),
@@ -760,6 +855,7 @@ export class NostrClient {
    */
   async _doPublish(event, options = {}) {
     const waitForRelays = options.waitForRelays || false;
+    const signingKey = options.signingKey || null;
 
     // Check if event is already signed (has id and sig)
     let signedEvent;
@@ -773,12 +869,17 @@ export class NostrClient {
       ndkEvent.tags = event.tags || [];
       ndkEvent.created_at = event.created_at || Math.floor(Date.now() / 1000);
 
-      // Sign the event
-      await ndkEvent.sign(this.signer);
+      // Sign the event - use different signer if signingKey provided
+      if (signingKey) {
+        const tempSigner = new NDKPrivateKeySigner(signingKey);
+        await ndkEvent.sign(tempSigner);
+      } else {
+        await ndkEvent.sign(this.signer);
+      }
       signedEvent = ndkEvent.rawEvent();
     } else {
       // Mock mode - create mock signed event
-      signedEvent = this._createSignedEvent(event);
+      signedEvent = this._createSignedEvent(event, signingKey);
     }
 
     // 1. Cache the event locally first (this makes reads instant)

package/src/storage/nostr-wrapper.js

@@ -53,11 +53,14 @@ function encodePathComponent(component) {
  * @param {Object} client - NostrClient instance
  * @param {string} path - Path
  * @param {Object} data - Data to write
+ * @param {Object} [options={}] - Write options
+ * @param {string} [options.signingKey] - Private key to sign with (hex format)
  * @returns {Promise<boolean>} Success indicator
  */
-export async function write(client, path, data) {
+export async function write(client, path, data, options = {}) {
   try {
-    const result = await nostrPut(client, path, data);
+    const putOptions = options.signingKey ? { signingKey: options.signingKey } : {};
+    const result = await nostrPut(client, path, data, putOptions);
     // Check if at least one relay accepted the event
     // If no relays (testing mode), consider it successful if event was created
     const success = result.results.length === 0 ? true : result.results.some(r => r.status === 'fulfilled');