holosphere 2.0.0-alpha11 → 2.0.0-alpha13

package/src/federation/handshake.js

@@ -15,8 +15,12 @@ import {
   createDMEvent,
   hexToNpub,
   generateNonce,
+  getPublicKey,
 } from '../crypto/nostr-utils.js';
 import { addFederatedPartner, storeInboundCapability } from './registry.js';
+import { registerHolon } from './holon-registry.js';
+import { issueCapability } from '../crypto/secp256k1.js';
+import * as cardStorage from './card-storage.js';
 
 // ============================================================================
 // Types (documented for reference)
@@ -194,26 +198,59 @@ export async function sendFederationResponse(client, privateKey, recipientPubKey
 
 /**
  * Subscribe to incoming federation DMs
+ * Fetches all historical DMs since last sync, then subscribes to new ones.
+ * DMs persist on relays like email - no need for both parties to be online.
  * @param {Object} client - NostrClient instance with subscribe method
  * @param {string} privateKey - Recipient's hex private key
  * @param {string} publicKey - Recipient's hex public key
  * @param {Object} handlers
  * @param {Function} handlers.onRequest - Called with (request, senderPubKey)
  * @param {Function} handlers.onResponse - Called with (response, senderPubKey)
+ * @param {Function} [handlers.onUpdate] - Called with (update, senderPubKey)
+ * @param {Function} [handlers.onUpdateResponse] - Called with (response, senderPubKey)
+ * @param {Object} options - Subscription options
+ * @param {string} options.appname - Application namespace (for persistent storage)
  * @returns {Function} Unsubscribe function
  */
-export function subscribeToFederationDMs(client, privateKey, publicKey, handlers) {
-  const { onRequest, onResponse } = handlers;
+export function subscribeToFederationDMs(client, privateKey, publicKey, handlers, options = {}) {
+  const { onRequest, onResponse, onUpdate, onUpdateResponse } = handlers;
+  const { appname } = options;
   let isActive = true;
+
+  // In-memory deduplication for this session
   const processedEventIds = new Set();
 
+  // Track processed DMs and responses persistently to prevent duplicate notifications
+  let processedDMIds = new Set();
+  let processedResponseIds = new Set();
+  let lastFetchTime = 0;
+
+  // Load processed DMs and responses from storage if appname is provided
+  const loadPersistedState = async () => {
+    if (appname && client?.client) {
+      try {
+        processedDMIds = await cardStorage.getProcessedDMIds(client.client, appname);
+        processedResponseIds = await cardStorage.getProcessedResponseIds(client.client, appname);
+        lastFetchTime = await cardStorage.getLastDMFetchTime(client.client, appname);
+        console.log('[Handshake] Loaded persisted state - last fetch:', lastFetchTime, 'processed DMs:', processedDMIds.size);
+      } catch (err) {
+        console.warn('[Handshake] Could not load persisted state:', err.message);
+      }
+    }
+  };
+
   const handleEvent = async (event) => {
     if (!isActive) return;
 
-    // Skip duplicates
+    // Skip duplicates (in-memory check for this session)
     if (processedEventIds.has(event.id)) return;
     processedEventIds.add(event.id);
 
+    // Skip if already processed in persistent storage
+    if (processedDMIds.has(event.id)) {
+      return;
+    }
+
     // Only kind 4 (encrypted DM) events tagged to us
     if (event.kind !== 4) return;
 
@@ -234,11 +271,83 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
       const payload = JSON.parse(decrypted);
 
       if (payload.type === 'federation_request' && payload.version === '1.0') {
+        // Check if this request was already dismissed
+        if (appname && client?.client) {
+          const isDismissed = await cardStorage.isRequestDismissed(client.client, appname, payload.requestId);
+          if (isDismissed) {
+            console.log('[Handshake] Skipping dismissed request:', payload.requestId);
+            // Mark this DM as processed so we don't check again
+            await cardStorage.markDMProcessed(client.client, appname, event.id, 'request');
+            processedDMIds.add(event.id);
+            return;
+          }
+        }
+
+        // Mark DM as processed before calling handler
+        if (appname && client?.client) {
+          await cardStorage.markDMProcessed(client.client, appname, event.id, 'request');
+          processedDMIds.add(event.id);
+        }
+
         console.log('[Handshake] Received federation request from:', event.pubkey.substring(0, 8) + '...');
         onRequest?.(payload, event.pubkey);
       } else if (payload.type === 'federation_response' && payload.version === '1.0') {
+        // Check if this response was already processed (persistent check)
+        const responseKey = `${payload.requestId}_${event.pubkey}`;
+        if (processedResponseIds.has(responseKey)) {
+          console.log('[Handshake] Skipping already processed response:', responseKey);
+          return;
+        }
+
+        // Mark as processed in persistent storage
+        if (appname && client?.client) {
+          await cardStorage.markResponseProcessed(client.client, appname, payload.requestId, event.pubkey);
+          await cardStorage.markDMProcessed(client.client, appname, event.id, 'response');
+          processedResponseIds.add(responseKey);
+          processedDMIds.add(event.id);
+        }
+
         console.log('[Handshake] Received federation response from:', event.pubkey.substring(0, 8) + '...');
         onResponse?.(payload, event.pubkey);
+      } else if (payload.type === 'federation_update' && payload.version === '1.0') {
+        // Federation update request (lens config change)
+        // Check if this update was already dismissed
+        if (appname && client?.client) {
+          const isDismissed = await cardStorage.isRequestDismissed(client.client, appname, payload.updateId);
+          if (isDismissed) {
+            console.log('[Handshake] Skipping dismissed update:', payload.updateId);
+            await cardStorage.markDMProcessed(client.client, appname, event.id, 'update');
+            processedDMIds.add(event.id);
+            return;
+          }
+        }
+
+        // Mark DM as processed
+        if (appname && client?.client) {
+          await cardStorage.markDMProcessed(client.client, appname, event.id, 'update');
+          processedDMIds.add(event.id);
+        }
+
+        console.log('[Handshake] Received federation update from:', event.pubkey.substring(0, 8) + '...');
+        onUpdate?.(payload, event.pubkey);
+      } else if (payload.type === 'federation_update_response' && payload.version === '1.0') {
+        // Federation update response
+        const responseKey = `update_${payload.updateId}_${event.pubkey}`;
+        if (processedResponseIds.has(responseKey)) {
+          console.log('[Handshake] Skipping already processed update response:', responseKey);
+          return;
+        }
+
+        // Mark as processed
+        if (appname && client?.client) {
+          await cardStorage.markResponseProcessed(client.client, appname, payload.updateId, event.pubkey);
+          await cardStorage.markDMProcessed(client.client, appname, event.id, 'update_response');
+          processedResponseIds.add(responseKey);
+          processedDMIds.add(event.id);
+        }
+
+        console.log('[Handshake] Received federation update response from:', event.pubkey.substring(0, 8) + '...');
+        onUpdateResponse?.(payload, event.pubkey);
       }
     } catch (error) {
       // Silently ignore non-federation DMs
@@ -250,6 +359,9 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
   let subscription = null;
 
   const startSubscription = async () => {
+    // Load persisted state first
+    await loadPersistedState();
+
     // Get the NostrClient from HoloSphere instance
     const nostrClient = client?.client;
     if (!nostrClient?.subscribe) {
@@ -257,16 +369,27 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
       return;
     }
 
+    // Use last fetch time or 0 for first-time sync (fetch all historical DMs)
+    // This makes federation DMs work like email - they persist on relays
+    const sinceTime = lastFetchTime || 0;
+    console.log('[Handshake] Fetching DMs since:', sinceTime ? new Date(sinceTime * 1000).toISOString() : 'beginning of time');
+
     const filter = {
       kinds: [4],
       '#p': [publicKey],
-      since: Math.floor(Date.now() / 1000) - 86400, // Last 24 hours
+      since: sinceTime,
     };
 
     try {
       // NostrClient.subscribe(filter, onEvent, options) returns { unsubscribe }
       subscription = await nostrClient.subscribe(filter, handleEvent, {});
       console.log('[Handshake] Federation DM subscription started');
+
+      // Update last fetch time to now (for next session)
+      if (appname && client?.client) {
+        const now = Math.floor(Date.now() / 1000);
+        await cardStorage.setLastDMFetchTime(client.client, appname, now);
+      }
     } catch (error) {
       console.error('[Handshake] Failed to subscribe:', error);
     }
@@ -313,16 +436,39 @@ export async function initiateFederationHandshake(holosphere, privateKey, params
 
   try {
     // Get sender's public key
-    const { getPublicKey } = await import('../crypto/nostr-utils.js');
     const senderPubKey = getPublicKey(privateKey);
 
+    // Issue capabilities for outbound lenses (lenses we're sharing with partner)
+    const capabilities = [];
+    for (const lensName of (lensConfig.outbound || [])) {
+      try {
+        const token = await issueCapability(
+          ['read'],
+          { holonId, lensName, dataId: '*' },
+          partnerPubKey,
+          {
+            expiresIn: 365 * 24 * 60 * 60 * 1000, // 1 year
+            issuer: senderPubKey,
+            issuerKey: privateKey,
+          }
+        );
+        capabilities.push({
+          token,
+          scope: { holonId, lensName },
+          permissions: ['read'],
+        });
+      } catch (err) {
+        console.warn(`[Handshake] Failed to issue capability for ${lensName}:`, err.message);
+      }
+    }
+
     // Create federation request
     const request = createFederationRequest({
       senderHolonId: holonId,
       senderHolonName: holonName,
       senderPubKey,
       lensConfig,
-      capabilities: [],
+      capabilities,
       message,
     });
 
@@ -373,7 +519,6 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
 
   try {
     // Get responder's public key
-    const { getPublicKey } = await import('../crypto/nostr-utils.js');
     const responderPubKey = getPublicKey(privateKey);
 
     // Add sender as federated partner in Nostr registry
@@ -389,6 +534,18 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
           await storeInboundCapability(holosphere.client, holosphere.config.appName, senderPubKey, cap);
         }
       }
+
+      // Register the sender's holon -> pubkey mapping in our holon registry
+      // This is critical for resolveHolonToPubkey to work when navigating to their holon
+      if (request.senderHolonId) {
+        await registerHolon(holosphere.client, holosphere.config.appName, request.senderHolonId, senderPubKey, {
+          alias: request.senderHolonName,
+        });
+        console.log('[Handshake] Registered partner holon:', {
+          holonId: request.senderHolonId,
+          pubKey: senderPubKey?.slice(0, 12) + '...'
+        });
+      }
     }
 
     // Create the actual federation record in GunDB storage
@@ -399,6 +556,30 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
       partnerName: request.senderHolonName
     });
 
+    // Issue capabilities for our outbound lenses (lenses we're sharing with partner)
+    const capabilities = [];
+    for (const lensName of (lensConfig.outbound || [])) {
+      try {
+        const token = await issueCapability(
+          ['read'],
+          { holonId, lensName, dataId: '*' },
+          senderPubKey,
+          {
+            expiresIn: 365 * 24 * 60 * 60 * 1000, // 1 year
+            issuer: responderPubKey,
+            issuerKey: privateKey,
+          }
+        );
+        capabilities.push({
+          token,
+          scope: { holonId, lensName },
+          permissions: ['read'],
+        });
+      } catch (err) {
+        console.warn(`[Handshake] Failed to issue capability for ${lensName}:`, err.message);
+      }
+    }
+
     // Create and send response
     const response = createFederationResponse({
       requestId: request.requestId,
@@ -407,14 +588,50 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
       responderHolonName: holonName,
       responderPubKey,
       lensConfig,
-      capabilities: [],
+      capabilities,
       message,
     });
 
     const sent = await sendFederationResponse(holosphere.client, privateKey, senderPubKey, response);
 
     if (sent) {
-      return { success: true };
+      // Dismiss the request so it won't reappear
+      if (holosphere.client && request.requestId) {
+        await cardStorage.dismissRequest(holosphere.client, holosphere.config.appName, request.requestId);
+        console.log('[Handshake] Request dismissed after acceptance:', request.requestId);
+      }
+
+      // Auto-receive federated lens data as holograms for configured inbound lenses
+      // This enables the user to immediately see the partner's data in their holon
+      const receivedHolograms = {};
+      const inboundLenses = lensConfig.inbound || [];
+
+      if (inboundLenses.length > 0 && holosphere.receiveFederatedLens) {
+        console.log('[Handshake] Receiving federated lens data as holograms...');
+
+        for (const lensName of inboundLenses) {
+          try {
+            // The sender's holon ID comes from the request
+            const senderHolonId = request.senderHolonId;
+
+            const result = await holosphere.receiveFederatedLens(
+              senderPubKey,
+              senderHolonId,
+              lensName,
+              holonId,
+              { overwrite: false }
+            );
+
+            receivedHolograms[lensName] = result;
+            console.log(`[Handshake] Received ${result.received} holograms for lens "${lensName}"`);
+          } catch (err) {
+            console.warn(`[Handshake] Failed to receive holograms for lens "${lensName}":`, err.message);
+            receivedHolograms[lensName] = { error: err.message };
+          }
+        }
+      }
+
+      return { success: true, requestId: request.requestId, receivedHolograms };
     } else {
       return { success: false, error: 'Failed to send response DM' };
     }
@@ -452,6 +669,86 @@ export async function rejectFederationRequest(holosphere, privateKey, params) {
   }
 }
 
+/**
+ * Process a federation response (called by initiator when receiving acceptance)
+ * Stores capabilities from the responder in the local registry and receives holograms
+ * @param {Object} holosphere - HoloSphere instance
+ * @param {Object} response - Federation response payload
+ * @param {string} responderPubKey - Responder's public key
+ * @param {Object} [options={}] - Processing options
+ * @param {string} [options.holonId] - Initiator's holon ID (for receiving holograms)
+ * @param {string[]} [options.inboundLenses] - Lenses to receive from responder
+ * @returns {Promise<Object>} Result with success, stored capability count, and received holograms
+ */
+export async function processFederationResponse(holosphere, response, responderPubKey, options = {}) {
+  if (!response || response.status !== 'accepted') {
+    return { success: false, error: 'Response not accepted', storedCapabilities: 0 };
+  }
+
+  const { holonId, inboundLenses = [] } = options;
+  let storedCapabilities = 0;
+
+  // Store capabilities from the responder
+  if (holosphere.client && response.capabilities && response.capabilities.length > 0) {
+    for (const cap of response.capabilities) {
+      try {
+        await storeInboundCapability(holosphere.client, holosphere.config.appName, responderPubKey, cap);
+        storedCapabilities++;
+      } catch (err) {
+        console.warn(`[Handshake] Failed to store capability:`, err.message);
+      }
+    }
+  }
+
+  // Add responder as federated partner if not already
+  if (holosphere.client) {
+    await addFederatedPartner(holosphere.client, holosphere.config.appName, responderPubKey, {
+      alias: response.responderHolonName,
+      addedVia: 'handshake_accepted',
+    });
+
+    // Register the responder's holon -> pubkey mapping in our holon registry
+    // This is critical for resolveHolonToPubkey to work when navigating to their holon
+    if (response.responderHolonId) {
+      await registerHolon(holosphere.client, holosphere.config.appName, response.responderHolonId, responderPubKey, {
+        alias: response.responderHolonName,
+      });
+      console.log('[Handshake] Registered partner holon from response:', {
+        holonId: response.responderHolonId,
+        pubKey: responderPubKey?.slice(0, 12) + '...'
+      });
+    }
+  }
+
+  // Auto-receive federated lens data as holograms for configured inbound lenses
+  const receivedHolograms = {};
+  const responderHolonId = response.responderHolonId;
+
+  if (holonId && responderHolonId && inboundLenses.length > 0 && holosphere.receiveFederatedLens) {
+    console.log('[Handshake] Receiving federated lens data as holograms from responder...');
+
+    for (const lensName of inboundLenses) {
+      try {
+        const result = await holosphere.receiveFederatedLens(
+          responderPubKey,
+          responderHolonId,
+          lensName,
+          holonId,
+          { overwrite: false }
+        );
+
+        receivedHolograms[lensName] = result;
+        console.log(`[Handshake] Received ${result.received} holograms for lens "${lensName}"`);
+      } catch (err) {
+        console.warn(`[Handshake] Failed to receive holograms for lens "${lensName}":`, err.message);
+        receivedHolograms[lensName] = { error: err.message };
+      }
+    }
+  }
+
+  return { success: true, storedCapabilities, receivedHolograms };
+}
+
 // ============================================================================
 // Payload Validation
 // ============================================================================
@@ -473,3 +770,258 @@ export function isFederationRequest(payload) {
 export function isFederationResponse(payload) {
   return payload?.type === 'federation_response' && payload?.version === '1.0';
 }
+
+// ============================================================================
+// Federation Update (Renegotiation) Protocol
+// ============================================================================
+
+/**
+ * @typedef {Object} FederationUpdatePayload
+ * @property {'federation_update'} type
+ * @property {'1.0'} version
+ * @property {string} updateId - Unique update ID
+ * @property {number} timestamp
+ * @property {string} senderHolonId
+ * @property {string} senderHolonName
+ * @property {string} senderNpub
+ * @property {Object} newLensConfig - New lens configuration
+ * @property {string[]} newLensConfig.inbound
+ * @property {string[]} newLensConfig.outbound
+ * @property {string} [message]
+ */
+
+/**
+ * @typedef {Object} FederationUpdateResponsePayload
+ * @property {'federation_update_response'} type
+ * @property {'1.0'} version
+ * @property {string} updateId - References original update
+ * @property {number} timestamp
+ * @property {'accepted'|'rejected'} status
+ * @property {string} [message]
+ */
+
+/**
+ * Create a federation update payload
+ * @param {Object} params
+ * @param {string} params.senderHolonId
+ * @param {string} params.senderHolonName
+ * @param {string} params.senderPubKey
+ * @param {Object} params.newLensConfig
+ * @param {string} [params.message]
+ * @returns {FederationUpdatePayload}
+ */
+export function createFederationUpdate({
+  senderHolonId,
+  senderHolonName,
+  senderPubKey,
+  newLensConfig,
+  message,
+}) {
+  return {
+    type: 'federation_update',
+    version: '1.0',
+    updateId: generateNonce(),
+    timestamp: Date.now(),
+    senderHolonId,
+    senderHolonName,
+    senderNpub: hexToNpub(senderPubKey),
+    newLensConfig,
+    message,
+  };
+}
+
+/**
+ * Create a federation update response payload
+ * @param {Object} params
+ * @param {string} params.updateId
+ * @param {'accepted'|'rejected'} params.status
+ * @param {string} [params.message]
+ * @returns {FederationUpdateResponsePayload}
+ */
+export function createFederationUpdateResponse({
+  updateId,
+  status,
+  message,
+}) {
+  return {
+    type: 'federation_update_response',
+    version: '1.0',
+    updateId,
+    timestamp: Date.now(),
+    status,
+    message,
+  };
+}
+
+/**
+ * Send a federation update request DM
+ * @param {Object} client - NostrClient instance
+ * @param {string} privateKey - Sender's hex private key
+ * @param {string} recipientPubKey - Recipient's hex public key
+ * @param {FederationUpdatePayload} update - Update payload
+ * @returns {Promise<boolean>}
+ */
+export async function sendFederationUpdate(client, privateKey, recipientPubKey, update) {
+  try {
+    const content = JSON.stringify(update);
+    const encrypted = encryptNIP44(privateKey, recipientPubKey, content);
+    const event = createDMEvent(recipientPubKey, encrypted, privateKey);
+
+    if (client?.publish) {
+      await client.publish(event);
+      console.log('[Handshake] Federation update sent to:', recipientPubKey.substring(0, 8) + '...');
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.error('[Handshake] Failed to send federation update:', error);
+    return false;
+  }
+}
+
+/**
+ * Send a federation update response DM
+ * @param {Object} client - NostrClient instance
+ * @param {string} privateKey - Sender's hex private key
+ * @param {string} recipientPubKey - Recipient's hex public key
+ * @param {FederationUpdateResponsePayload} response - Response payload
+ * @returns {Promise<boolean>}
+ */
+export async function sendFederationUpdateResponse(client, privateKey, recipientPubKey, response) {
+  try {
+    const content = JSON.stringify(response);
+    const encrypted = encryptNIP44(privateKey, recipientPubKey, content);
+    const event = createDMEvent(recipientPubKey, encrypted, privateKey);
+
+    if (client?.publish) {
+      await client.publish(event);
+      console.log('[Handshake] Federation update response sent to:', recipientPubKey.substring(0, 8) + '...');
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.error('[Handshake] Failed to send federation update response:', error);
+    return false;
+  }
+}
+
+/**
+ * Request a federation update (lens config change)
+ * @param {Object} holosphere - HoloSphere instance
+ * @param {string} privateKey - Sender's hex private key
+ * @param {Object} params
+ * @param {string} params.partnerPubKey - Partner's hex public key
+ * @param {string} params.holonId - Current holon ID
+ * @param {string} params.holonName - Current holon name
+ * @param {Object} params.newLensConfig - New lens configuration
+ * @param {string} [params.message]
+ * @returns {Promise<Object>}
+ */
+export async function requestFederationUpdate(holosphere, privateKey, params) {
+  const { partnerPubKey, holonId, holonName, newLensConfig, message } = params;
+
+  try {
+    const senderPubKey = getPublicKey(privateKey);
+
+    const update = createFederationUpdate({
+      senderHolonId: holonId,
+      senderHolonName: holonName,
+      senderPubKey,
+      newLensConfig,
+      message,
+    });
+
+    const sent = await sendFederationUpdate(holosphere.client, privateKey, partnerPubKey, update);
+
+    if (sent) {
+      return { success: true, updateId: update.updateId };
+    }
+    return { success: false, error: 'Failed to send update DM' };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Accept a federation update request
+ * @param {Object} holosphere - HoloSphere instance
+ * @param {string} privateKey - Responder's hex private key
+ * @param {Object} params
+ * @param {string} params.updateId - Update ID
+ * @param {string} params.senderPubKey - Original sender's public key
+ * @param {string} params.holonId - Our holon ID
+ * @param {Object} params.newLensConfig - The new lens config to apply
+ * @param {string} [params.message]
+ * @returns {Promise<Object>}
+ */
+export async function acceptFederationUpdate(holosphere, privateKey, params) {
+  const { updateId, senderPubKey, holonId, newLensConfig, message } = params;
+
+  try {
+    // Update the local federation with new lens config
+    if (holosphere.federateHolon) {
+      await holosphere.federateHolon(holonId, senderPubKey, {
+        lensConfig: newLensConfig,
+      });
+    }
+
+    // Send acceptance response
+    const response = createFederationUpdateResponse({
+      updateId,
+      status: 'accepted',
+      message,
+    });
+
+    const sent = await sendFederationUpdateResponse(holosphere.client, privateKey, senderPubKey, response);
+
+    return { success: sent, error: sent ? undefined : 'Failed to send response' };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Reject a federation update request
+ * @param {Object} holosphere - HoloSphere instance
+ * @param {string} privateKey - Responder's hex private key
+ * @param {Object} params
+ * @param {string} params.updateId - Update ID
+ * @param {string} params.senderPubKey - Original sender's public key
+ * @param {string} [params.message]
+ * @returns {Promise<Object>}
+ */
+export async function rejectFederationUpdate(holosphere, privateKey, params) {
+  const { updateId, senderPubKey, message } = params;
+
+  try {
+    const response = createFederationUpdateResponse({
+      updateId,
+      status: 'rejected',
+      message,
+    });
+
+    const sent = await sendFederationUpdateResponse(holosphere.client, privateKey, senderPubKey, response);
+
+    return { success: sent, error: sent ? undefined : 'Failed to send response' };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Check if payload is a federation update
+ * @param {*} payload
+ * @returns {boolean}
+ */
+export function isFederationUpdate(payload) {
+  return payload?.type === 'federation_update' && payload?.version === '1.0';
+}
+
+/**
+ * Check if payload is a federation update response
+ * @param {*} payload
+ * @returns {boolean}
+ */
+export function isFederationUpdateResponse(payload) {
+  return payload?.type === 'federation_update_response' && payload?.version === '1.0';
+}