holosphere 2.0.0-alpha1 → 2.0.0-alpha4

package/src/lib/federation-methods.js

@@ -0,0 +1,238 @@
+/**
+ * Federation Methods Mixin
+ * Cross-Holosphere federation and Nostr discovery operations
+ */
+
+import * as registry from '../federation/registry.js';
+import * as discovery from '../federation/discovery.js';
+import * as federation from '../federation/hologram.js';
+import * as storage from '../storage/unified-storage.js';
+import * as nostrAsync from '../storage/nostr-async.js';
+import * as crypto from '../crypto/secp256k1.js';
+import { ValidationError, AuthorizationError } from './errors.js';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+
+/**
+ * Mixin that adds federation methods to a HoloSphere class
+ * @param {Class} Base - Base class to extend
+ * @returns {Class} Extended class with federation methods
+ */
+export function withFederationMethods(Base) {
+  return class extends Base {
+    // === Cross-Holosphere Federation ===
+
+    async addFederatedHolosphere(pubKey, options = {}) {
+      if (!pubKey || typeof pubKey !== 'string') {
+        throw new ValidationError('pubKey must be a valid public key string');
+      }
+      return registry.addFederatedPartner(
+        this.client,
+        this.config.appName,
+        pubKey,
+        options
+      );
+    }
+
+    async removeFederatedHolosphere(pubKey) {
+      return registry.removeFederatedPartner(
+        this.client,
+        this.config.appName,
+        pubKey
+      );
+    }
+
+    async getFederatedHolospheres() {
+      return registry.getFederatedAuthors(
+        this.client,
+        this.config.appName
+      );
+    }
+
+    async getFederationRegistry() {
+      return registry.getFederationRegistry(
+        this.client,
+        this.config.appName
+      );
+    }
+
+    async storeInboundCapability(partnerPubKey, capabilityInfo) {
+      return registry.storeInboundCapability(
+        this.client,
+        this.config.appName,
+        partnerPubKey,
+        capabilityInfo
+      );
+    }
+
+    async readFromFederatedSource(sourcePubKey, holonId, lensName, dataId = null) {
+      const capabilityEntry = await registry.getCapabilityForAuthor(
+        this.client,
+        this.config.appName,
+        sourcePubKey,
+        { holonId, lensName, dataId }
+      );
+
+      if (!capabilityEntry) {
+        throw new AuthorizationError('No valid capability for federated source', 'read');
+      }
+
+      const isValid = await this.verifyCapability(
+        capabilityEntry.token,
+        'read',
+        { holonId, lensName, dataId }
+      );
+
+      if (!isValid) {
+        throw new AuthorizationError('Capability verification failed', 'read');
+      }
+
+      if (dataId) {
+        const path = storage.buildPath(this.config.appName, holonId, lensName, dataId);
+        return nostrAsync.nostrGet(this.client, path, 30000, {
+          authors: [sourcePubKey],
+          includeAuthor: true,
+        });
+      } else {
+        const path = storage.buildPath(this.config.appName, holonId, lensName);
+        return nostrAsync.nostrGetAll(this.client, path, 30000, {
+          authors: [sourcePubKey],
+          includeAuthor: true,
+        });
+      }
+    }
+
+    async createCrossHolosphereHologram(sourcePubKey, sourceHolon, lensName, dataId, targetHolon, options = {}) {
+      const { embedCapability = true } = options;
+
+      const capabilityEntry = await registry.getCapabilityForAuthor(
+        this.client,
+        this.config.appName,
+        sourcePubKey,
+        { holonId: sourceHolon, lensName, dataId }
+      );
+
+      if (!capabilityEntry) {
+        throw new AuthorizationError('No valid capability for cross-holosphere hologram', 'read');
+      }
+
+      const hologram = federation.createHologram(
+        sourceHolon,
+        targetHolon,
+        lensName,
+        dataId,
+        this.config.appName,
+        {
+          authorPubKey: sourcePubKey,
+          capability: embedCapability ? capabilityEntry.token : null,
+        }
+      );
+
+      const targetPath = storage.buildPath(this.config.appName, targetHolon, lensName, dataId);
+      await storage.write(this.client, targetPath, hologram);
+
+      return hologram;
+    }
+
+    async issueCapabilityForFederation(targetPubKey, scope, permissions, options = {}) {
+      const { expiresIn = 3600000, trackInRegistry = true } = options;
+
+      const token = await crypto.issueCapability(
+        permissions,
+        scope,
+        targetPubKey,
+        {
+          expiresIn,
+          issuerKey: this.client.privateKey,
+        }
+      );
+
+      if (trackInRegistry) {
+        const partner = await registry.getFederatedPartner(
+          this.client,
+          this.config.appName,
+          targetPubKey
+        );
+
+        if (!partner) {
+          await registry.addFederatedPartner(
+            this.client,
+            this.config.appName,
+            targetPubKey,
+            { addedVia: 'capability_issued' }
+          );
+        }
+
+        await registry.storeOutboundCapability(
+          this.client,
+          this.config.appName,
+          targetPubKey,
+          {
+            tokenHash: await this._hashToken(token),
+            scope,
+            permissions,
+            expires: Date.now() + expiresIn,
+          }
+        );
+      }
+
+      return token;
+    }
+
+    async _hashToken(token) {
+      const encoder = new TextEncoder();
+      return bytesToHex(sha256(encoder.encode(token)));
+    }
+
+    // === Nostr Discovery Protocol ===
+
+    async sendFederationRequest(targetPubKey, options = {}) {
+      return discovery.sendFederationRequest(
+        this.client,
+        this.config.appName,
+        targetPubKey,
+        options
+      );
+    }
+
+    async subscribeFederationRequests(callback) {
+      return discovery.subscribeFederationRequests(this.client, callback);
+    }
+
+    async acceptFederationRequest(request, options = {}) {
+      return discovery.acceptFederationRequest(
+        this.client,
+        this.config.appName,
+        request,
+        options
+      );
+    }
+
+    async declineFederationRequest(request, reason = '') {
+      return discovery.declineFederationRequest(
+        this.client,
+        this.config.appName,
+        request,
+        reason
+      );
+    }
+
+    async subscribeFederationAcceptances(callback) {
+      return discovery.subscribeFederationAcceptances(
+        this.client,
+        this.config.appName,
+        callback
+      );
+    }
+
+    async subscribeFederationDeclines(callback) {
+      return discovery.subscribeFederationDeclines(this.client, callback);
+    }
+
+    async getPendingFederationRequests(options = {}) {
+      return discovery.getPendingFederationRequests(this.client, options);
+    }
+  };
+}
+
+export default withFederationMethods;

package/src/lib/index.js

@@ -0,0 +1,26 @@
+/**
+ * HoloSphere Library Modules
+ * Mixins for extending the base HoloSphere class
+ */
+
+export { withAIMethods } from './ai-methods.js';
+export { withContractMethods } from './contract-methods.js';
+export { withFederationMethods } from './federation-methods.js';
+export { AuthorizationError, ValidationError } from './errors.js';
+
+/**
+ * Compose multiple mixins into a single class
+ * @param {Class} BaseClass - Base class to extend
+ * @param {...Function} mixins - Mixin functions to apply
+ * @returns {Class} Composed class
+ */
+export function compose(BaseClass, ...mixins) {
+  return mixins.reduce((acc, mixin) => mixin(acc), BaseClass);
+}
+
+export default {
+  withAIMethods,
+  withContractMethods,
+  withFederationMethods,
+  compose
+};

package/src/spatial/h3-operations.js

@@ -92,8 +92,8 @@ export function getChildren(holonId) {
  */
 export function isValidH3(holonId) {
   if (typeof holonId !== 'string') return false;
-  if (holonId.length < 15) return false;
-  if (!holonId.startsWith('8')) return false;
+  // H3 indexes are 15-character hex strings, but can vary slightly
+  // Use h3-js isValidCell for proper validation
   return isValidCell(holonId);
 }