holosphere 1.1.20 → 2.0.0-alpha0

package/src/federation/discovery.js

@@ -0,0 +1,334 @@
+/**
+ * Nostr-based Federation Discovery Protocol
+ * Optional feature for automated federation handshake via Nostr events
+ */
+
+import { issueCapability } from '../crypto/secp256k1.js';
+import { addFederatedPartner, storeInboundCapability } from './registry.js';
+
+// Custom event kinds for federation protocol
+const FEDERATION_REQUEST_KIND = 30078;
+const FEDERATION_ACCEPT_KIND = 30079;
+const FEDERATION_DECLINE_KIND = 30080;
+
+/**
+ * Send a federation request to another holosphere via Nostr
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} targetPubKey - Target holosphere's public key
+ * @param {Object} options - Request options
+ * @param {Object} options.scope - Requested scope { holonId, lensName }
+ * @param {string[]} options.permissions - Requested permissions
+ * @param {string} options.message - Optional message to include
+ * @param {number} options.expiresIn - Token expiration in ms (default: 30 days)
+ * @returns {Promise<Object>} Published event info
+ */
+export async function sendFederationRequest(client, appname, targetPubKey, options = {}) {
+  const {
+    scope = { holonId: '*', lensName: '*' },
+    permissions = ['read'],
+    message = 'Federation request',
+    expiresIn = 30 * 24 * 60 * 60 * 1000, // 30 days
+  } = options;
+
+  // Issue capability we're offering them (access to our data)
+  const offeredCapability = await issueCapability(
+    permissions,
+    scope,
+    targetPubKey,
+    { issuerKey: client.privateKey, expiresIn }
+  );
+
+  const event = {
+    kind: FEDERATION_REQUEST_KIND,
+    created_at: Math.floor(Date.now() / 1000),
+    tags: [
+      ['d', `federation-request-${targetPubKey.slice(0, 16)}`],
+      ['p', targetPubKey],
+      ['holosphere', appname],
+      ['scope', JSON.stringify(scope)],
+      ['permissions', permissions.join(',')],
+    ],
+    content: JSON.stringify({
+      message,
+      offeredCapability,
+      requestedScope: scope,
+      requestedPermissions: permissions,
+    }),
+  };
+
+  const result = await client.publish(event);
+  return {
+    eventId: result.id || null,
+    targetPubKey,
+    scope,
+    permissions,
+    offeredCapability,
+    ...result,
+  };
+}
+
+/**
+ * Subscribe to incoming federation requests
+ * @param {Object} client - NostrClient instance
+ * @param {Function} callback - Called with each request
+ * @returns {Promise<Object>} Subscription with unsubscribe method
+ */
+export async function subscribeFederationRequests(client, callback) {
+  const filter = {
+    kinds: [FEDERATION_REQUEST_KIND],
+    '#p': [client.publicKey],
+  };
+
+  return client.subscribe(filter, (event) => {
+    try {
+      const content = JSON.parse(event.content);
+      const scopeTag = event.tags.find(t => t[0] === 'scope');
+      const permissionsTag = event.tags.find(t => t[0] === 'permissions');
+      const holosphereTag = event.tags.find(t => t[0] === 'holosphere');
+
+      const request = {
+        eventId: event.id,
+        requesterPubKey: event.pubkey,
+        appname: holosphereTag?.[1],
+        scope: scopeTag ? JSON.parse(scopeTag[1]) : { holonId: '*', lensName: '*' },
+        permissions: permissionsTag ? permissionsTag[1].split(',') : ['read'],
+        message: content.message,
+        offeredCapability: content.offeredCapability,
+        timestamp: event.created_at,
+      };
+
+      callback(request);
+    } catch (error) {
+      console.error('Failed to parse federation request:', error);
+    }
+  });
+}
+
+/**
+ * Accept a federation request
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {Object} request - Request object from subscription
+ * @param {Object} options - Acceptance options
+ * @param {Object} options.scope - Scope we're granting (defaults to requested)
+ * @param {string[]} options.permissions - Permissions we're granting
+ * @param {string} options.alias - Alias for this partner
+ * @param {number} options.expiresIn - Token expiration in ms
+ * @returns {Promise<Object>} Published acceptance event info
+ */
+export async function acceptFederationRequest(client, appname, request, options = {}) {
+  const {
+    scope = request.scope,
+    permissions = request.permissions,
+    alias = null,
+    expiresIn = 30 * 24 * 60 * 60 * 1000,
+  } = options;
+
+  // Issue our capability to them
+  const grantedCapability = await issueCapability(
+    permissions,
+    scope,
+    request.requesterPubKey,
+    { issuerKey: client.privateKey, expiresIn }
+  );
+
+  // Store their offered capability in our registry
+  await addFederatedPartner(client, appname, request.requesterPubKey, {
+    alias,
+    addedVia: 'nostr_discovery',
+    inboundCapabilities: [{
+      token: request.offeredCapability,
+      scope: request.scope,
+      permissions: request.permissions,
+      expires: Date.now() + expiresIn,
+    }],
+  });
+
+  // Publish acceptance event
+  const event = {
+    kind: FEDERATION_ACCEPT_KIND,
+    created_at: Math.floor(Date.now() / 1000),
+    tags: [
+      ['d', `federation-accept-${request.requesterPubKey.slice(0, 16)}`],
+      ['p', request.requesterPubKey],
+      ['e', request.eventId], // Reference to original request
+      ['holosphere', appname],
+      ['scope', JSON.stringify(scope)],
+      ['permissions', permissions.join(',')],
+    ],
+    content: JSON.stringify({
+      acceptedScope: scope,
+      grantedCapability,
+    }),
+  };
+
+  const result = await client.publish(event);
+  return {
+    eventId: result.id || null,
+    requesterPubKey: request.requesterPubKey,
+    grantedCapability,
+    acceptedScope: scope,
+    ...result,
+  };
+}
+
+/**
+ * Decline a federation request
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {Object} request - Request object from subscription
+ * @param {string} reason - Optional decline reason
+ * @returns {Promise<Object>} Published decline event info
+ */
+export async function declineFederationRequest(client, appname, request, reason = '') {
+  const event = {
+    kind: FEDERATION_DECLINE_KIND,
+    created_at: Math.floor(Date.now() / 1000),
+    tags: [
+      ['d', `federation-decline-${request.requesterPubKey.slice(0, 16)}`],
+      ['p', request.requesterPubKey],
+      ['e', request.eventId],
+      ['holosphere', appname],
+    ],
+    content: JSON.stringify({ reason }),
+  };
+
+  const result = await client.publish(event);
+  return {
+    eventId: result.id || null,
+    requesterPubKey: request.requesterPubKey,
+    reason,
+    ...result,
+  };
+}
+
+/**
+ * Subscribe to federation acceptances (responses to our requests)
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {Function} callback - Called with each acceptance
+ * @returns {Promise<Object>} Subscription with unsubscribe method
+ */
+export async function subscribeFederationAcceptances(client, appname, callback) {
+  const filter = {
+    kinds: [FEDERATION_ACCEPT_KIND],
+    '#p': [client.publicKey],
+  };
+
+  return client.subscribe(filter, async (event) => {
+    try {
+      const content = JSON.parse(event.content);
+      const scopeTag = event.tags.find(t => t[0] === 'scope');
+      const permissionsTag = event.tags.find(t => t[0] === 'permissions');
+
+      // Store their granted capability in our registry
+      await storeInboundCapability(client, appname, event.pubkey, {
+        token: content.grantedCapability,
+        scope: scopeTag ? JSON.parse(scopeTag[1]) : content.acceptedScope,
+        permissions: permissionsTag ? permissionsTag[1].split(',') : ['read'],
+        expires: Date.now() + 30 * 24 * 60 * 60 * 1000, // Assume 30 day expiry
+      });
+
+      callback({
+        accepterPubKey: event.pubkey,
+        originalRequestId: event.tags.find(t => t[0] === 'e')?.[1],
+        acceptedScope: content.acceptedScope,
+        grantedCapability: content.grantedCapability,
+        timestamp: event.created_at,
+      });
+    } catch (error) {
+      console.error('Failed to parse federation acceptance:', error);
+    }
+  });
+}
+
+/**
+ * Subscribe to federation declines
+ * @param {Object} client - NostrClient instance
+ * @param {Function} callback - Called with each decline
+ * @returns {Promise<Object>} Subscription with unsubscribe method
+ */
+export async function subscribeFederationDeclines(client, callback) {
+  const filter = {
+    kinds: [FEDERATION_DECLINE_KIND],
+    '#p': [client.publicKey],
+  };
+
+  return client.subscribe(filter, (event) => {
+    try {
+      const content = JSON.parse(event.content);
+
+      callback({
+        declinerPubKey: event.pubkey,
+        originalRequestId: event.tags.find(t => t[0] === 'e')?.[1],
+        reason: content.reason || '',
+        timestamp: event.created_at,
+      });
+    } catch (error) {
+      console.error('Failed to parse federation decline:', error);
+    }
+  });
+}
+
+/**
+ * Query for pending federation requests (requests we've sent that haven't been answered)
+ * @param {Object} client - NostrClient instance
+ * @param {Object} options - Query options
+ * @param {number} options.since - Only get requests since this timestamp (seconds)
+ * @returns {Promise<Object[]>} Array of pending requests
+ */
+export async function getPendingFederationRequests(client, options = {}) {
+  const since = options.since || Math.floor((Date.now() - 30 * 24 * 60 * 60 * 1000) / 1000);
+
+  // Get our requests
+  const requestFilter = {
+    kinds: [FEDERATION_REQUEST_KIND],
+    authors: [client.publicKey],
+    since,
+  };
+  const requests = await client.query(requestFilter);
+
+  // Get all acceptances and declines to our requests
+  const responseFilter = {
+    kinds: [FEDERATION_ACCEPT_KIND, FEDERATION_DECLINE_KIND],
+    '#p': [client.publicKey],
+    since,
+  };
+  const responses = await client.query(responseFilter);
+
+  // Find request event IDs that have been responded to
+  const respondedRequestIds = new Set();
+  for (const response of responses) {
+    const eTag = response.tags.find(t => t[0] === 'e');
+    if (eTag) {
+      respondedRequestIds.add(eTag[1]);
+    }
+  }
+
+  // Filter to only pending requests
+  const pending = [];
+  for (const request of requests) {
+    if (!respondedRequestIds.has(request.id)) {
+      try {
+        const content = JSON.parse(request.content);
+        const pTag = request.tags.find(t => t[0] === 'p');
+        const scopeTag = request.tags.find(t => t[0] === 'scope');
+        const permissionsTag = request.tags.find(t => t[0] === 'permissions');
+
+        pending.push({
+          eventId: request.id,
+          targetPubKey: pTag?.[1],
+          scope: scopeTag ? JSON.parse(scopeTag[1]) : { holonId: '*', lensName: '*' },
+          permissions: permissionsTag ? permissionsTag[1].split(',') : ['read'],
+          message: content.message,
+          timestamp: request.created_at,
+        });
+      } catch (error) {
+        console.error('Failed to parse pending request:', error);
+      }
+    }
+  }
+
+  return pending;
+}