holosphere 2.0.0-alpha5 → 2.0.0-alpha7

package/src/contracts/deployer.js

@@ -304,6 +304,7 @@ export class ContractDeployer {
 
   /**
    * Deploy a Bundle contract (2-way split with steepness)
+   * This is the simplest way to deploy a holon - no registry needed!
    * @param {string} name - Contract name
    * @param {number} [steepness=500000000000000000n] - Steepness factor (0.5e18 = 50% decay)
    * @param {number} [nZones=6] - Number of zones
@@ -319,9 +320,17 @@ export class ContractDeployer {
     // Default steepness: 0.5e18 (50% decay per zone)
     const steepnessValue = steepness || ethers.parseEther('0.5');
 
+    // BundleABI now has { abi, bytecode } structure
+    const abi = BundleABI.abi || BundleABI;
+    const bytecode = BundleABI.bytecode;
+
+    if (!bytecode) {
+      throw new Error('Bundle bytecode not available. Please rebuild contracts.');
+    }
+
     const result = await this._deployContract(
-      BundleABI.abi,
-      BundleABI.bytecode,
+      abi,
+      bytecode,
       [deployerAddress, creatorUserId, name, steepnessValue, nZones]
     );
 
@@ -329,10 +338,30 @@ export class ContractDeployer {
       ...result,
       type: 'Bundle',
       steepness: steepnessValue,
-      nZones
+      nZones,
+      creatorUserId,
+      name
     };
   }
 
+  /**
+   * Deploy a Bundle contract directly (simplified 1-click deployment)
+   * No registry needed - just deploys and returns the address
+   * @param {string} holonId - Unique identifier for the holon
+   * @param {string} name - Display name for the holon
+   * @param {Object} [options] - Options { steepness, nZones }
+   * @returns {Promise<{address, txHash, contract}>}
+   */
+  async deployBundleDirect(holonId, name, options = {}) {
+    const steepness = options.steepness;
+    const nZones = options.nZones || 6;
+
+    return this.deployBundle(name, steepness, nZones, {
+      creatorUserId: holonId,
+      ...options
+    });
+  }
+
   /**
    * Deploy a TestToken (ERC20 for testing)
    * @param {string} [initialSupply='1000000'] - Initial supply in whole tokens

package/src/federation/handshake.js

@@ -301,8 +301,8 @@ export async function initiateFederationHandshake(holosphere, privateKey, params
 
   try {
     // Get sender's public key
-    const { getPublicKeyFromPrivate } = await import('../crypto/nostr-utils.js');
-    const senderPubKey = getPublicKeyFromPrivate(privateKey);
+    const { getPublicKey } = await import('../crypto/nostr-utils.js');
+    const senderPubKey = getPublicKey(privateKey);
 
     // Create federation request
     const request = createFederationRequest({
@@ -361,10 +361,10 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
 
   try {
     // Get responder's public key
-    const { getPublicKeyFromPrivate } = await import('../crypto/nostr-utils.js');
-    const responderPubKey = getPublicKeyFromPrivate(privateKey);
+    const { getPublicKey } = await import('../crypto/nostr-utils.js');
+    const responderPubKey = getPublicKey(privateKey);
 
-    // Add sender as federated partner
+    // Add sender as federated partner in Nostr registry
     if (holosphere.client) {
       await addFederatedPartner(holosphere.client, holosphere.config.appName, senderPubKey, {
         alias: request.senderHolonName,
@@ -379,6 +379,14 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
       }
     }
 
+    // Create the actual federation record in GunDB storage
+    // This is what makes the partner appear in getFederation() / loadFederationData()
+    // Store the sender's name so we can display it without reading their settings
+    await holosphere.federateHolon(holonId, senderPubKey, {
+      lensConfig,
+      partnerName: request.senderHolonName
+    });
+
     // Create and send response
     const response = createFederationResponse({
       requestId: request.requestId,

package/src/index.js

@@ -798,6 +798,7 @@ class HoloSphereBase extends HoloSphereCore {
     if (!Array.isArray(data.inbound)) data.inbound = [];
     if (!Array.isArray(data.outbound)) data.outbound = [];
     if (!data.lensConfig || typeof data.lensConfig !== 'object') data.lensConfig = {};
+    if (!data.partnerNames || typeof data.partnerNames !== 'object') data.partnerNames = {};
 
     if (!Array.isArray(data.federated)) {
       const allFederated = new Set([...data.inbound, ...data.outbound]);
@@ -808,7 +809,7 @@ class HoloSphereBase extends HoloSphereCore {
   }
 
   async federateHolon(sourceHolon, targetHolon, options = {}) {
-    const { lensConfig = { inbound: [], outbound: [] } } = options;
+    const { lensConfig = { inbound: [], outbound: [] }, partnerName = null } = options;
 
     if (sourceHolon === targetHolon) {
       throw new Error('Cannot federate a holon with itself');
@@ -821,6 +822,7 @@ class HoloSphereBase extends HoloSphereCore {
       inbound: [],
       outbound: [],
       lensConfig: {},
+      partnerNames: {},
       timestamp: Date.now()
     };
 
@@ -828,11 +830,17 @@ class HoloSphereBase extends HoloSphereCore {
     if (!Array.isArray(federationData.inbound)) federationData.inbound = [];
     if (!Array.isArray(federationData.outbound)) federationData.outbound = [];
     if (!federationData.lensConfig || typeof federationData.lensConfig !== 'object') federationData.lensConfig = {};
+    if (!federationData.partnerNames || typeof federationData.partnerNames !== 'object') federationData.partnerNames = {};
 
     if (!federationData.federated.includes(targetHolon)) {
       federationData.federated.push(targetHolon);
     }
 
+    // Store the partner's name if provided
+    if (partnerName) {
+      federationData.partnerNames[targetHolon] = partnerName;
+    }
+
     if (lensConfig.outbound && lensConfig.outbound.length > 0) {
       if (!federationData.outbound.includes(targetHolon)) {
         federationData.outbound.push(targetHolon);

package/src/storage/gun-async.js

@@ -64,22 +64,73 @@ export function gunPut(gunChain, data, timeout = 1000) {
 
 /**
  * Get all items from a Gun map
+ * First gets count of items, then collects until count is reached
  * @param {Object} gunChain - Gun chain reference
- * @param {number} timeout - Timeout in ms (default 300ms)
+ * @param {number} timeout - Timeout in ms (fallback, default 5000ms)
  * @returns {Promise<Object>} Promise resolving to map of items
  */
-export async function gunMap(gunChain, timeout = 300) {
+export async function gunMap(gunChain, timeout = 5000) {
   return new Promise((resolve) => {
     const items = {};
+    let settled = false;
+    let expectedCount = 0;
+    let receivedCount = 0;
 
-    gunChain.map().once((data, key) => {
-      if (data && !key.startsWith('_')) {
-        items[key] = data;
+    const tryResolve = () => {
+      if (settled) return;
+      if (expectedCount > 0 && receivedCount >= expectedCount) {
+        settled = true;
+        resolve(items);
+      }
+    };
+
+    // Step 1: Get parent to count expected items
+    gunChain.once((parentData) => {
+      if (settled) return;
+
+      if (!parentData) {
+        settled = true;
+        resolve({});
+        return;
+      }
+
+      const keys = Object.keys(parentData).filter(k => k !== '_');
+      if (keys.length === 0) {
+        settled = true;
+        resolve({});
+        return;
       }
+
+      // Pre-collect inline items (not Gun references)
+      for (const key of keys) {
+        const rawItem = parentData[key];
+        if (!rawItem) continue;
+
+        // Skip Gun references - will be fetched via map().once()
+        if (typeof rawItem === 'object' && rawItem['#']) continue;
+
+        items[key] = rawItem;
+      }
+
+      // Expected count is ALL keys (map().once() fires for all)
+      expectedCount = keys.length;
+
+      // Step 2: Collect items via map().once(), counting as we go
+      gunChain.map().once((data, key) => {
+        if (settled || !data || key.startsWith('_')) return;
+        // Add/update the item (inline items may be updated by map().once())
+        items[key] = data;
+        receivedCount++;
+        tryResolve();
+      });
     });
 
+    // Fallback timeout
     setTimeout(() => {
-      resolve(items);
+      if (!settled) {
+        settled = true;
+        resolve(items);
+      }
     }, timeout);
   });
 }

package/src/storage/gun-auth.js

@@ -208,11 +208,12 @@ export class GunAuth {
 
   /**
    * Read all data from a private lens
+   * First gets count of items, then collects until count is reached
    * @param {string} lens - Lens name
-   * @param {number} timeout - Timeout in ms
+   * @param {number} timeout - Timeout in ms (fallback)
    * @returns {Promise<Object[]>} Array of data objects
    */
-  async readAllPrivate(lens, timeout = 2000) {
+  async readAllPrivate(lens, timeout = 5000) {
     if (!this.isAuthenticated()) {
       throw new Error('Not authenticated');
     }
@@ -221,42 +222,100 @@ export class GunAuth {
       const results = [];
       const seen = new Set();
       const ref = this.getPrivatePath(lens);
+      let settled = false;
+      let expectedCount = 0;
+      let receivedCount = 0;
+
+      const tryResolve = () => {
+        if (settled) return;
+        if (expectedCount > 0 && receivedCount >= expectedCount) {
+          settled = true;
+          resolve(results);
+        }
+      };
 
-      const timer = setTimeout(() => {
-        try {
-          ref.off();
-        } catch (e) {}
-        resolve(results);
-      }, timeout);
-
-      ref.map().once((data, key) => {
-        if (data && !key.startsWith('_') && !seen.has(key)) {
-          seen.add(key);
-
-          let parsed = null;
-          // Primary: JSON string format (like old holosphere)
-          if (typeof data === 'string') {
-            try {
-              parsed = JSON.parse(data);
-            } catch (e) {
-              parsed = data;
-            }
-          // Legacy: _json wrapper format
-          } else if (data._json && typeof data._json === 'string') {
-            try {
-              parsed = JSON.parse(data._json);
-            } catch (e) {}
-          // Plain object
-          } else if (typeof data === 'object') {
-            parsed = { ...data };
-            delete parsed['_'];
+      const parseItem = (data) => {
+        if (!data) return null;
+        let parsed = null;
+        // Primary: JSON string format (like old holosphere)
+        if (typeof data === 'string') {
+          try {
+            parsed = JSON.parse(data);
+          } catch (e) {
+            parsed = data;
           }
+        // Legacy: _json wrapper format
+        } else if (data._json && typeof data._json === 'string') {
+          try {
+            parsed = JSON.parse(data._json);
+          } catch (e) {}
+        // Plain object
+        } else if (typeof data === 'object') {
+          parsed = { ...data };
+          delete parsed['_'];
+        }
+        return parsed;
+      };
+
+      // Step 1: Get parent to count expected items
+      ref.once((parentData) => {
+        if (settled) return;
 
-          if (parsed && !parsed._deleted) {
+        if (!parentData) {
+          settled = true;
+          resolve([]);
+          return;
+        }
+
+        const keys = Object.keys(parentData).filter(k => k !== '_');
+        if (keys.length === 0) {
+          settled = true;
+          resolve([]);
+          return;
+        }
+
+        // Pre-parse inline items (not Gun references)
+        for (const key of keys) {
+          const rawItem = parentData[key];
+          if (!rawItem) continue;
+
+          // Skip Gun references - will be fetched via map().once()
+          if (typeof rawItem === 'object' && rawItem['#']) continue;
+
+          const parsed = parseItem(rawItem);
+          if (parsed && !parsed._deleted && !seen.has(key)) {
+            seen.add(key);
             results.push(parsed);
           }
         }
+
+        // Expected count is ALL keys (map().once() fires for all)
+        expectedCount = keys.length;
+
+        // Step 2: Collect items via map().once(), counting as we go
+        ref.map().once((data, key) => {
+          if (settled || !data || key.startsWith('_')) return;
+
+          // Count every item, but only add if not already seen
+          if (!seen.has(key)) {
+            seen.add(key);
+            const parsed = parseItem(data);
+            if (parsed && !parsed._deleted) {
+              results.push(parsed);
+            }
+          }
+          receivedCount++;
+          tryResolve();
+        });
       });
+
+      // Fallback timeout
+      setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          resolve(results);
+        }
+      }, timeout);
     });
   }
 

package/src/storage/gun-wrapper.js

@@ -186,20 +186,34 @@ export async function read(gun, path) {
 
 /**
  * Read all data under a path (lens query)
- * Uses Gun's .open() which waits for nested data to load
- * Falls back to .once() with iteration
+ * First gets the count of expected items, then collects until count is reached
  * @param {Object} gun - Gun instance
  * @param {string} path - Gun path
+ * @param {number} timeout - Maximum timeout in ms (default 5000)
  * @returns {Promise<Object[]>} Array of data objects
  */
-export async function readAll(gun, path) {
+export async function readAll(gun, path, timeout = 5000) {
   return new Promise((resolve) => {
     const output = new Map();
     let settled = false;
+    let expectedCount = 0;
+    let receivedCount = 0;
 
     const ref = gun.get(path);
 
-    // Use .once() on parent to get all keys, then process
+    const tryResolve = () => {
+      if (settled) return;
+      if (expectedCount > 0 && receivedCount >= expectedCount) {
+        settled = true;
+        resolve(Array.from(output.values()));
+      }
+    };
+
+    const parseItem = (data) => {
+      return deserializeFromGun(data);
+    };
+
+    // Step 1: Get the parent data to count expected items
     ref.once((parentData) => {
       if (settled) return;
 
@@ -218,81 +232,61 @@ export async function readAll(gun, path) {
         return;
       }
 
-      // Process inline data directly from parentData
-      // Gun often includes the data inline as references or direct values
+      // Count expected items and check for inline data
+      const referenceKeys = [];
+
       for (const key of keys) {
         const rawItem = parentData[key];
         if (!rawItem) continue;
 
-        let item = null;
-
-        // Check if it's a Gun reference (soul)
+        // Check if it's a Gun reference (soul) - need to fetch separately
         if (typeof rawItem === 'object' && rawItem['#']) {
-          // Skip references for now, map().once will handle them
+          referenceKeys.push(key);
           continue;
         }
 
-        // Try to parse as _json wrapper
-        if (rawItem._json && typeof rawItem._json === 'string') {
-          try {
-            item = JSON.parse(rawItem._json);
-          } catch (e) {}
-        }
-        // Try as direct JSON string
-        else if (typeof rawItem === 'string') {
-          try {
-            item = JSON.parse(rawItem);
-          } catch (e) {}
-        }
-
+        // Try to parse inline data (don't count yet - will count in map().once() phase)
+        const item = parseItem(rawItem);
         if (item && item.id && !item._deleted) {
           output.set(item.id, item);
         }
       }
 
-      // If we got all data inline, resolve now
-      if (output.size > 0) {
+      // Set expected count: ALL keys that could have data (references + inline)
+      // We use total keys because map().once() will fire for all of them
+      expectedCount = keys.length;
+
+      // If no keys, we're done (shouldn't happen but be safe)
+      if (expectedCount === 0) {
         settled = true;
         resolve(Array.from(output.values()));
         return;
       }
 
-      // Otherwise use map().once() to resolve references
+      // Step 2: Use map().once() to resolve all items, counting as we go
       ref.map().once((data, key) => {
         if (settled || !data || key === '_') return;
 
-        let item = null;
-        if (data._json && typeof data._json === 'string') {
-          try {
-            item = JSON.parse(data._json);
-          } catch (e) {}
-        } else if (typeof data === 'string') {
-          try {
-            item = JSON.parse(data);
-          } catch (e) {}
-        }
-
+        const item = parseItem(data);
         if (item && item.id && !item._deleted) {
-          output.set(item.id, item);
+          // Add to output if not already there (inline items already added)
+          if (!output.has(item.id)) {
+            output.set(item.id, item);
+          }
         }
+        // Count every item received (inline or reference)
+        receivedCount++;
+        tryResolve();
       });
-
-      // Give map().once() time to complete
-      setTimeout(() => {
-        if (!settled) {
-          settled = true;
-          resolve(Array.from(output.values()));
-        }
-      }, 500);
     });
 
-    // Overall timeout
+    // Fallback timeout in case count-based resolution fails
     setTimeout(() => {
       if (!settled) {
         settled = true;
         resolve(Array.from(output.values()));
       }
-    }, 2000);
+    }, timeout);
   });
 }
 

package/src/storage/nostr-client.js

@@ -496,8 +496,11 @@ export class NostrClient {
   async _doPublish(event, options = {}) {
     const waitForRelays = options.waitForRelays || false;
 
-    // Sign the event
-    const signedEvent = finalizeEvent(event, this.privateKey);
+    // Check if event is already signed (has id and sig)
+    // If so, use it as-is; otherwise sign it
+    const signedEvent = (event.id && event.sig)
+      ? event
+      : finalizeEvent(event, this.privateKey);
 
     // 1. Cache the event locally first (this makes reads instant)
     await this._cacheEvent(signedEvent);