@origintrail-official/dkg-agent 10.0.20 → 10.0.21

package/dist/dkg-agent-join.js

@@ -1,3 +1,4 @@
+import { verifiedDelegationKeyIds, verifyJoinEncryptionKeyBundle } from './internal/join-encryption-key-bundle.js';
 // SPDX-License-Identifier: Apache-2.0
 /**
  * Join-request subsystem extracted from dkg-agent.ts as a mixin holder:
@@ -15,6 +16,8 @@ import { ethers } from 'ethers';
 import { canonicalAgentDidSubject } from './profile.js';
 import { computeDelegationDigest, computeWorkspaceEncryptionKeysAttestationDigest, signAgentDelegation, verifyAgentDelegation, } from './auth/agent-delegation.js';
 import { activeWorkspaceEncryptionKeys, verifyWorkspaceEncryptionKeyBinding, } from './agent-keystore.js';
+import { requesterHasDirectLoopbackConnection, selectCuratorJoinDialAddress, } from './curator-dial-address.js';
+import { recoverCuratorConnectionBeforeQueueing } from './curator-peer-connection.js';
 import { stripLiteral, } from './dkg-agent-utils.js';
 import { JOIN_DELEGATION_VALIDITY_MS, JOIN_REQUEST_SEND_TIMEOUT_MS, } from './dkg-agent-constants.js';
 import { normalizeAgentDid, joinDelegationScope, inferAdapterPublisherAddress, } from './dkg-agent-helpers.js';
@@ -45,7 +48,6 @@ const JOIN_ENCRYPTION_KEY_CACHE_GRAPH = 'urn:dkg:local:join-encryption-key-cache
 const JOIN_ENCRYPTION_KEY_CACHE_ISSUED_AT = 'urn:dkg:local:join-encryption-key-cache:issued-at-ms';
 const JOIN_ENCRYPTION_KEY_CACHE_KEY_SET_DIGEST = 'urn:dkg:local:join-encryption-key-cache:key-set-digest';
 const JOIN_ENCRYPTION_KEY_CACHE_DIGEST_RE = /^0x[0-9a-f]{64}$/i;
-const JOIN_ENCRYPTION_KEY_LIMIT = 8;
 const requesterJoinStateCache = new WeakMap();
 const requesterJoinStateTails = new WeakMap();
 const requesterJoinForwardTails = new WeakMap();
@@ -60,9 +62,6 @@ function sameStringSet(left, right) {
     }
     return true;
 }
-function verifiedDelegationKeyIds(agentAddress, keys) {
-    return new Set(keys.map((key) => workspaceAgentEncryptionKeyId(agentAddress, decodeWorkspaceEncryptionKey(key.publicEncryptionKey)).toLowerCase()));
-}
 function requesterJoinStateKey(contextGraphId, agentAddress) {
     return `${contextGraphId}\u0000${agentAddress.toLowerCase()}`;
 }
@@ -150,65 +149,25 @@ async function withJoinEncryptionKeyCacheLock(store, agentSubject, task) {
             tails.delete(agentSubject);
     }
 }
-function verifyJoinEncryptionKeyBundle(delegation, carrierPeerId) {
-    const keys = delegation.workspaceEncryptionKeys;
-    if (keys === undefined)
-        return null;
-    if (!Array.isArray(keys) || keys.length === 0 || keys.length > JOIN_ENCRYPTION_KEY_LIMIT) {
-        throw new Error(`Join request must carry between 1 and ${JOIN_ENCRYPTION_KEY_LIMIT} workspace encryption keys.`);
-    }
-    // Preserve the existing admission contract for a signed carrier mismatch:
-    // policy evaluation reports a bounded pending decision. Do not accept the
-    // bundle because the carrier has not proven it is the signed delegatee.
-    if (delegation.delegateePeerId !== carrierPeerId)
-        return null;
-    // issuedAtMs becomes the durable cross-CG cache high-water, so authenticate
-    // the base delegation here as well as at the admission boundary.
-    verifyAgentDelegation(delegation);
-    if (!Number.isSafeInteger(delegation.issuedAtMs) || delegation.issuedAtMs < 0) {
-        throw new Error('Join request carries an invalid encryption-key freshness timestamp.');
-    }
-    const verified = keys.map((key) => {
-        if (key === null
-            || typeof key !== 'object'
-            || key.encryptionKeyAlgorithm !== WORKSPACE_AGENT_ENCRYPTION_KEY_ALGORITHM_X25519
-            || typeof key.publicEncryptionKey !== 'string'
-            || typeof key.encryptionKeyProof !== 'string') {
-            throw new Error('Join request carries a malformed workspace encryption key.');
-        }
-        let valid = false;
-        try {
-            valid = verifyWorkspaceEncryptionKeyBinding(delegation.agentAddress, key.encryptionKeyAlgorithm, key.publicEncryptionKey, key.encryptionKeyProof);
-        }
-        catch {
-            valid = false;
-        }
-        if (!valid) {
-            throw new Error('Join request carries an invalid workspace encryption key proof.');
-        }
-        return key;
+function curatorJoinDialAddress(agent, requesterPeerId) {
+    return selectCuratorJoinDialAddress(agent.node.multiaddrs, agent.peerId, {
+        preferLoopback: requesterHasDirectLoopbackConnection(agent.node.libp2p.getConnections(), requesterPeerId),
     });
-    if (typeof delegation.workspaceEncryptionKeysSignature !== 'string') {
-        throw new Error('Join request is missing its workspace encryption-key attestation.');
-    }
-    let attestationSigner = '';
-    try {
-        attestationSigner = ethers.verifyMessage(computeWorkspaceEncryptionKeysAttestationDigest(delegation), delegation.workspaceEncryptionKeysSignature);
-    }
-    catch {
-        attestationSigner = '';
-    }
-    if (attestationSigner.toLowerCase() !== delegation.agentAddress.toLowerCase()) {
-        throw new Error('Join request carries an invalid workspace encryption-key attestation.');
-    }
-    const canonicalKeySet = [...new Set(verified.map((key) => JSON.stringify({
-            encryptionKeyAlgorithm: key.encryptionKeyAlgorithm,
-            publicEncryptionKey: key.publicEncryptionKey,
-        })))].sort();
-    return {
-        issuedAtMs: delegation.issuedAtMs,
-        keySetDigest: `0x${createHash('sha256').update(JSON.stringify(canonicalKeySet)).digest('hex')}`,
-        keys: verified,
+}
+function joinApprovalPayload(agent, contextGraphId, agentAddress, requestGeneration, curatorBinding) {
+    return (targetPeerId) => {
+        const curatorDialAddress = curatorJoinDialAddress(agent, targetPeerId);
+        return JSON.stringify({
+            type: 'join-approved',
+            contextGraphId,
+            agentAddress,
+            requestGeneration,
+            ...(curatorDialAddress === undefined ? {} : { curatorDialAddress }),
+            ...(curatorBinding === null ? {} : {
+                curatorAgentAddress: curatorBinding.agentAddress,
+                curatorAuthorityEra: curatorBinding.authorityEra,
+            }),
+        });
     };
 }
 export class JoinRequestMethods extends DKGAgentBase {
@@ -362,8 +321,9 @@ export class JoinRequestMethods extends DKGAgentBase {
         }
         // This is a total private-recipient cap, not merely an allowlist-row cap:
         // participant agents receive ciphertext keys and private read authority too.
-        // Use the fresh authoritative union (allowed + participant - revoked).
-        const activeMembers = await withRpcUsageSite(CG_AUTH_RPC_SITES.joinPolicyRoster, () => this.getMemberRecoveryGate(contextGraphId)) ?? [];
+        // Preserve the finalized chain roster for registered private graphs;
+        // unregistered graphs use the effective store-backed metadata union.
+        const activeMembers = await withRpcUsageSite(CG_AUTH_RPC_SITES.joinPolicyRoster, () => this.getMemberRecoveryRosterSource(contextGraphId)) ?? [];
         return {
             ownerDid,
             ownerAgentAddress,
@@ -594,7 +554,7 @@ export class JoinRequestMethods extends DKGAgentBase {
             withAdmissionLock: (contextGraphId, operation) => this.withContextGraphJoinAdmissionLock(contextGraphId, operation),
             isPolicyDisableRequested: (contextGraphId) => (this.contextGraphJoinPolicyDisableIntentCounts.get(contextGraphId) ?? 0) > 0,
             getContextGraphMeta: (contextGraphId) => this.getCgMeta(contextGraphId),
-            getActiveMembers: (contextGraphId) => withRpcUsageSite(CG_AUTH_RPC_SITES.joinAdmissionRoster, () => this.getMemberRecoveryGate(contextGraphId)),
+            getActiveMembers: (contextGraphId) => withRpcUsageSite(CG_AUTH_RPC_SITES.joinAdmissionRoster, () => this.getMemberRecoveryRosterSource(contextGraphId)),
             getContextGraphOwner: (contextGraphId) => this.getContextGraphOwner(contextGraphId),
             resolveLocalOwnerAddress: (ownerDid) => this.resolveLocalJoinPolicyOwnerAddress(ownerDid),
             assertAlreadyMemberDelegationRefresh: (contextGraphId, delegation, carrierPeerId) => this.assertAlreadyMemberDelegationRefresh(contextGraphId, delegation, carrierPeerId),
@@ -794,6 +754,20 @@ export class JoinRequestMethods extends DKGAgentBase {
             cache.delete(key);
             throw error;
         }
+        finally {
+            this.fenceRequesterJoinStateChange(contextGraphId);
+        }
+    }
+    /**
+     * The join proof behind an approved replica's reads, catalog roster and
+     * catalog authority is bound to the requester state. That state lives in
+     * its own graph, so store-level invalidation does not reach the context
+     * graph's facts revision, which is what those paths compare after the reads
+     * that follow the proof. Move it here for every attempted change, including
+     * one that failed part-way, so an in-flight result is discarded.
+     */
+    fenceRequesterJoinStateChange(contextGraphId) {
+        this.contextGraphMetaProjection.markDirty(contextGraphId);
     }
     async clearRequesterJoinRequestState(contextGraphId, agentAddress) {
         const key = requesterJoinStateKey(contextGraphId, agentAddress);
@@ -810,6 +784,9 @@ export class JoinRequestMethods extends DKGAgentBase {
             cache.delete(key);
             throw error;
         }
+        finally {
+            this.fenceRequesterJoinStateChange(contextGraphId);
+        }
     }
     /** Start a fresh requester-side generation and reset its local status. */
     async setRequesterJoinRequestPending(contextGraphId, agentAddress, requestGeneration, curatorPeerId) {
@@ -1653,18 +1630,37 @@ export class JoinRequestMethods extends DKGAgentBase {
         // The outbox replays these bytes verbatim, so a binding missing here is
         // missing for good; this read is admitted even while the circuit is open.
         const curatorBinding = await this.readRfc64CurrentCuratorAuthorityBindingV1(contextGraphId, { admitWhileOpen: true }).catch(() => null);
-        const payload = JSON.stringify({
-            type: 'join-approved',
-            contextGraphId,
-            agentAddress,
-            requestGeneration: resolvedGeneration,
-            ...(curatorBinding === null ? {} : {
-                curatorAgentAddress: curatorBinding.agentAddress,
-                curatorAuthorityEra: curatorBinding.authorityEra,
-            }),
-        });
+        const payload = joinApprovalPayload(this, contextGraphId, agentAddress, resolvedGeneration, curatorBinding);
         const result = await this.deliverPrivateJoinNotification(contextGraphId, agentAddress, resolvedGeneration, payload, 'join-approval');
         if (result.delivered) {
+            // The requester can join over an already-open P2P connection. Its
+            // connect-time catalog replay then predates the private roster update,
+            // and the cold requester cannot pull a head until it knows the new
+            // policy digest. Refresh after the durable approval and push only this
+            // graph's current head to the exact peer that received the approval.
+            // Bounded retries cover an overlapping authority composition that was
+            // revision-fenced during admission; transport still checks the current
+            // policy and roster before sending any private head.
+            if (result.peerId
+                && result.peerId !== this.peerId
+                && this.resolveRfc64CatalogServingAuthorityV1(contextGraphId).track2Enabled) {
+                for (const delayMs of [0, 250, 1_000]) {
+                    if (delayMs > 0) {
+                        await new Promise((resolve) => { setTimeout(resolve, delayMs); });
+                    }
+                    try {
+                        await this.reconcileRfc64CatalogAccessAuthorityV1(contextGraphId);
+                        if (await this.reannounceRfc64CatalogAfterJoinApprovalV1(contextGraphId, agentAddress, result.peerId))
+                            return;
+                    }
+                    catch {
+                        // The approval remains durable. The next bounded attempt can
+                        // observe the current authority generation.
+                    }
+                }
+                this.log.warn(createOperationContext('system'), `RFC-64 catalog replay remains pending after join approval for "${contextGraphId}"`);
+                this.scheduleRfc64CatalogAfterJoinApprovalRetryV1(contextGraphId, agentAddress, result.peerId);
+            }
             return;
         }
         // rc.9 PR-10: the substrate outbox already holds the queued send
@@ -1716,16 +1712,7 @@ export class JoinRequestMethods extends DKGAgentBase {
         // The outbox replays these bytes verbatim, so a binding missing here is
         // missing for good; this read is admitted even while the circuit is open.
         const curatorBinding = await this.readRfc64CurrentCuratorAuthorityBindingV1(contextGraphId, { admitWhileOpen: true }).catch(() => null);
-        const payload = JSON.stringify({
-            type: 'join-approved',
-            contextGraphId,
-            agentAddress,
-            requestGeneration,
-            ...(curatorBinding === null ? {} : {
-                curatorAgentAddress: curatorBinding.agentAddress,
-                curatorAuthorityEra: curatorBinding.authorityEra,
-            }),
-        });
+        const payload = joinApprovalPayload(this, contextGraphId, agentAddress, requestGeneration, curatorBinding);
         const result = await this.deliverPrivateJoinNotification(contextGraphId, agentAddress, requestGeneration, payload, 'join-approval');
         // rc.9 PR-10: attempts counter is no longer tracked at the agent
         // layer (substrate outbox owns retry bookkeeping per messageId).
@@ -2090,7 +2077,6 @@ export class JoinRequestMethods extends DKGAgentBase {
      *          fire-and-forget)
      */
     async deliverPrivateJoinNotification(contextGraphId, agentAddress, requestGeneration, payload, label) {
-        const payloadBytes = new TextEncoder().encode(payload);
         const ctx = createOperationContext('system');
         const addrLower = agentAddress.toLowerCase();
         let targetPeerId = null;
@@ -2153,6 +2139,9 @@ export class JoinRequestMethods extends DKGAgentBase {
             return { delivered: true, peerId: targetPeerId, error: null };
         }
         try {
+            // Resolve the exact recipient before encoding the approval. The outbox
+            // then persists these final bytes unchanged across later retries.
+            const payloadBytes = new TextEncoder().encode(typeof payload === 'function' ? payload(targetPeerId) : payload);
             // rc.9 PR-10: send via the Universal Messenger substrate. If
             // the substrate can't deliver synchronously it enqueues into
             // the SQLite outbox and retries in the background — this
@@ -2251,18 +2240,17 @@ export class JoinRequestMethods extends DKGAgentBase {
             if (curatorPeerId !== this.peerId) {
                 recordAcceptedBy(curatorPeerId);
                 try {
-                    // rc.9 PR-10: substrate send. queued surfaces as a throw
-                    // (matches the legacy sendToPeer ergonomics so the existing
-                    // catch path with broadcast fallback still kicks in).
+                    await recoverCuratorConnectionBeforeQueueing({ node: this.node, peerResolver: this.peerResolver, log: this.log }, curatorPeerId, AbortSignal.timeout(JOIN_REQUEST_SEND_TIMEOUT_MS), ctx);
                     const sendResult = await this.messenger.sendReliable(curatorPeerId, PROTOCOL_JOIN_REQUEST, payloadBytes, { timeoutMs: JOIN_REQUEST_SEND_TIMEOUT_MS });
                     if (!sendResult.delivered) {
                         // `delivered:false` means Messenger durably queued this exact
                         // request; it is still accepted for eventual delivery. Preserve the
-                        // generation so the later curator decision can be matched, while
-                        // continuing the immediate broadcast fallback for lower latency.
+                        // generation and trusted curator. A durable queue acceptance is
+                        // pending success rather than a synchronous delivery failure.
                         acceptedForDelivery = true;
                         recordAcceptedBy(curatorPeerId);
-                        throw new Error(`substrate queued (transport): ${sendResult.error}`);
+                        this.log.info(ctx, `Queued join request for "${contextGraphId}" from ${agentAddress} to curator ${curatorPeerId.slice(-8)}`);
+                        return { delivered: 0, queued: true, errors };
                     }
                     const responseBytes = sendResult.response;
                     const response = JSON.parse(new TextDecoder().decode(responseBytes));