@ibgib/core-gib 0.1.59 → 0.1.60

package/src/sync/sync-peer/sync-peer-websocket/sync-peer-websocket-sender/sync-peer-websocket-sender-v1.mts

@@ -11,6 +11,7 @@ import { KeystoneStrategyFactory } from '../../../../keystone/strategy/keystone-
 import { deriveSessionSecret } from '../../../sync-helpers.mjs';
 import { SyncPeer_V1 } from '../../sync-peer-v1.mjs';
 import { SyncSagaContextIbGib_V1 } from '../../../sync-saga-context/sync-saga-context-types.mjs';
+import { validateContextAndSagaFrame } from '../../../sync-saga-context/sync-saga-context-helpers.mjs';
 import { GLOBAL_LOG_A_LOT } from '../../../../core-constants.mjs';
 import {
     ConnectSyncPeerWebSocketSenderOpts,
@@ -23,7 +24,17 @@ import {
     SESSION_KEYSTONE_POLICY,
     getConnectChallenge
 } from '../sync-peer-websocket-receiver/sync-websocket-peer-helpers.mjs';
-import { SyncWebSocketMsgType } from '../sync-peer-websocket-constants.mjs';
+import { SyncWebSocketMsgType, isSyncWebSocketMsgType, SYNC_WEB_SOCKET_MSG_TYPE_VALID_VALUES } from '../sync-peer-websocket-constants.mjs';
+import { toDto } from '../../../../common/other/ibgib-helper.mjs';
+import { putInSpace, registerNewIbGib } from '../../../../witness/space/space-helper.mjs';
+
+/**
+ * helper in creating compile-time safety that we're handling all message types.
+ */
+function assertUnreachable(x: never): never {
+    throw new Error(`Unhandled message type: ${x} (E: e928a3f82cd7469a98ef1bc248a3f826)`);
+}
+
 
 const logalot = GLOBAL_LOG_A_LOT || true;
 
@@ -51,6 +62,7 @@ export class SyncPeerWebSocketSender_V1
     protected activeResolve?: (value: SyncSagaContextIbGib_V1 | undefined) => void;
     protected activeReject?: (reason: any) => void;
     protected pendingPayloadsToSend: IbGib_V1[] = [];
+    protected handshakeMessageListener?: (event: MessageEvent) => Promise<void>;
 
     constructor(
         initialData: SyncPeerWebSocketSenderData_V1,
@@ -188,63 +200,64 @@ export class SyncPeerWebSocketSender_V1
                     if (logalot) { console.log(`${lc} WebSocket opened. Awaiting challenge...`); }
                 });
 
-                ws.addEventListener('message', async (ev) => {
+                this.handshakeMessageListener = async (ev) => {
                     try {
                         const msg = JSON.parse(ev.data);
-                        if (logalot) { console.log(`${lc} received frame: ${msg.type}`); }
-
-                        if (msg.type === SyncWebSocketMsgType.auth_challenge_init) {
-                            ws.send(JSON.stringify({
-                                type: SyncWebSocketMsgType.auth_init,
-                                sAddr: targetSAddr
-                            }));
-                        } else if (msg.type === SyncWebSocketMsgType.auth_challenge) {
-                            const { challengeUuid, demandedIds } = msg;
-                            if (logalot) { console.log(`${lc} solving demanded challenges: ${demandedIds.join(', ')}`); }
-
-                            const keystoneService = new KeystoneService_V1();
-                            const proofFrame = await keystoneService.sign({
-                                latestKeystone: sessionS,
-                                masterSecret: sessionSecret,
-                                poolId: SESSION_KEYSTONE_POLICY.CONNECT_POOL.ID,
-                                requiredChallengeIds: demandedIds,
-                                claim: {
-                                    verb: SESSION_KEYSTONE_POLICY.CONNECT_POOL.VERB,
-                                    target: challengeUuid
-                                },
-                                metaspace: localMetaspace,
-                                space: localSpace
-                            });
-
-                            ws.send(JSON.stringify({
-                                type: SyncWebSocketMsgType.auth_proof,
-                                proofFrame
-                            }));
-                        } else if (msg.type === SyncWebSocketMsgType.auth_ok) {
-                            if (logalot) { console.log(`${lc} WebSocket connect SUCCESS!`); }
-                            isResolved = true;
-
-                            // Setup persistent runtime listeners
-                            ws.removeEventListener('message', (() => { }) as any);
-                            ws.addEventListener('message', (event) => this.handleRuntimeMessage(event));
-
-                            resolve();
-                        } else if (msg.type === SyncWebSocketMsgType.auth_fail) {
-                            reject(new Error(`Connect failed: ${msg.message}`));
+                        if (logalot) { console.log(`${lc} received handshake frame: ${msg.type}`); }
+
+                        const msgType = msg.type;
+                        if (!isSyncWebSocketMsgType(msgType)) {
+                            const validTypes = SYNC_WEB_SOCKET_MSG_TYPE_VALID_VALUES.join(', ');
+                            throw new Error(`Unknown message type '${msgType}' received during connection handshake. Valid types are: ${validTypes} (E: e983271bc84f46928e4695be2409826)`);
+                        }
+
+                        switch (msgType) {
+                            case SyncWebSocketMsgType.auth_challenge_init:
+                                await this.handleHandshakeAuthChallengeInit(ws, targetSAddr);
+                                break;
+                            case SyncWebSocketMsgType.auth_challenge:
+                                await this.handleHandshakeAuthChallenge(ws, msg, sessionS, sessionSecret);
+                                break;
+                            case SyncWebSocketMsgType.auth_ok:
+                                isResolved = true;
+                                this.handleHandshakeAuthOk(ws, resolve);
+                                break;
+                            case SyncWebSocketMsgType.auth_fail:
+                                this.handleHandshakeAuthFail(msg, reject);
+                                break;
+                            case SyncWebSocketMsgType.sync_error:
+                                this.handleHandshakeSyncError(msg, reject);
+                                break;
+                            // Protocol violations / unexpected messages during connection handshake
+                            case SyncWebSocketMsgType.auth_init:
+                            case SyncWebSocketMsgType.auth_proof:
+                            case SyncWebSocketMsgType.sync_frame:
+                            case SyncWebSocketMsgType.sync_frame_response:
+                            case SyncWebSocketMsgType.sync_frame_authenticated:
+                            case SyncWebSocketMsgType.sync_frame_response_authenticated:
+                            case SyncWebSocketMsgType.domain_payload:
+                                throw new Error(`Unexpected message type '${msgType}' during connection handshake (E: e3f80c68ab2a46c2b1858c8a1e2f8926)`);
+                            default:
+                                assertUnreachable(msgType);
                         }
                     } catch (error) {
+                        console.error(`${lc} ${extractErrorMsg(error)}`);
                         reject(error);
                     }
-                });
+                };
+
+                ws.addEventListener('message', this.handshakeMessageListener);
 
                 ws.addEventListener('close', (event) => {
                     if (!isResolved) {
+                        this.disconnect();
                         reject(new Error(`WebSocket closed before connect completed (code: ${event.code})`));
                     }
                 });
 
                 ws.addEventListener('error', (err) => {
                     if (!isResolved) {
+                        this.disconnect();
                         reject(new Error(`WebSocket connection error`));
                     }
                 });
@@ -256,6 +269,36 @@ export class SyncPeerWebSocketSender_V1
         }
     }
 
+    /**
+     * Cleanly closes the socket and removes the handshake message listener.
+     *
+     * LOGS AND SWALLOWS ERRORS, DOES NOT THROW
+     */
+    public disconnect(): void {
+        const lc = `${this.lc}[${this.disconnect.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: 35c4b85fca0c6e9d042f5ff87cde3826)`); }
+
+            if (this.ws) {
+                if (this.handshakeMessageListener) {
+                    this.ws.removeEventListener('message', this.handshakeMessageListener);
+                    this.handshakeMessageListener = undefined;
+                }
+                try {
+                    this.ws.close();
+                } catch (error) {
+                    console.error(`${lc} failed to close websocket: ${extractErrorMsg(error)}`);
+                }
+                this.ws = undefined;
+            }
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            // throw error; // disconnect does NOT rethrow
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+    }
+
     /**
      * Handles synchronizing messages and evolved context frames during active transaction turns.
      */
@@ -265,49 +308,170 @@ export class SyncPeerWebSocketSender_V1
             const msg = JSON.parse(event.data);
             if (logalot) { console.log(`${lc} received runtime frame: ${msg.type}`); }
 
-            if (msg.type === SyncWebSocketMsgType.sync_frame_response) {
-                const responseContext = msg.context as SyncSagaContextIbGib_V1;
-
-                // Validate and authenticate Bob's response context first
-                await this.authenticateAndValidate({ context: responseContext });
-
-                // If response has expected payloads, authorize Bob to stream them
-                const expectedPayloadAddrs = responseContext.data?.['@payloadAddrsDomain'] || [];
-                if (expectedPayloadAddrs.length > 0) {
-                    this.ws!.send(JSON.stringify({
-                        type: SyncWebSocketMsgType.sync_frame_response_authenticated,
-                        contextAddr: getIbGibAddr({ ibGib: responseContext })
-                    }));
-                }
+            const msgType = msg.type;
+            if (!isSyncWebSocketMsgType(msgType)) {
+                const validTypes = SYNC_WEB_SOCKET_MSG_TYPE_VALID_VALUES.join(', ');
+                throw new Error(`Unknown message type '${msgType}' received during active sync saga loop. Valid types are: ${validTypes} (E: e23a8d10b74d47fb90518f8e3f4b826)`);
+            }
 
-                if (this.activeResolve) {
-                    const resolve = this.activeResolve;
-                    this.activeResolve = undefined;
-                    this.activeReject = undefined;
-                    resolve(responseContext);
-                }
-            } else if (msg.type === SyncWebSocketMsgType.sync_frame_authenticated) {
-                // Bob authenticated our context, stream buffered payloads
-                const payloads = this.pendingPayloadsToSend || [];
-                this.pendingPayloadsToSend = [];
-                for (const ibGib of payloads) {
-                    this.ws!.send(JSON.stringify({
-                        type: SyncWebSocketMsgType.domain_payload,
-                        ibGib
-                    }));
-                }
-            } else if (msg.type === SyncWebSocketMsgType.domain_payload) {
-                const payload = msg.ibGib as IbGib_V1;
-                this.payloadIbGibsDomainReceived$.next(payload);
+            switch (msgType) {
+                case SyncWebSocketMsgType.sync_frame_response:
+                    await this.handleRuntimeSyncFrameResponse(msg);
+                    break;
+                case SyncWebSocketMsgType.sync_frame_authenticated:
+                    this.handleRuntimeSyncFrameAuthenticated();
+                    break;
+                case SyncWebSocketMsgType.domain_payload:
+                    this.handleRuntimeDomainPayload(msg);
+                    break;
+                case SyncWebSocketMsgType.sync_error:
+                    this.handleRuntimeSyncError(msg);
+                    break;
+                // Handshake messages / unexpected messages during active sync saga loop
+                case SyncWebSocketMsgType.auth_challenge_init:
+                case SyncWebSocketMsgType.auth_init:
+                case SyncWebSocketMsgType.auth_challenge:
+                case SyncWebSocketMsgType.auth_proof:
+                case SyncWebSocketMsgType.auth_ok:
+                case SyncWebSocketMsgType.auth_fail:
+                case SyncWebSocketMsgType.sync_frame:
+                case SyncWebSocketMsgType.sync_frame_response_authenticated:
+                    throw new Error(`Unexpected message type '${msgType}' during active sync saga loop (E: e982b12cf92c448bbad0e84b7263c826)`);
+                default:
+                    assertUnreachable(msgType);
             }
         } catch (error) {
-            console.error(`${lc} failed parsing runtime frame: ${extractErrorMsg(error)}`);
+            console.error(`${lc} failed parsing/handling runtime frame: ${extractErrorMsg(error)}`);
+            this.disconnect();
             if (this.activeReject) {
-                this.activeReject(error);
+                const reject = this.activeReject;
+                this.activeResolve = undefined;
+                this.activeReject = undefined;
+                reject(error);
             }
         }
     }
 
+    protected async handleHandshakeAuthChallengeInit(ws: WebSocket, targetSAddr: string): Promise<void> {
+        ws.send(JSON.stringify({
+            type: SyncWebSocketMsgType.auth_init,
+            sAddr: targetSAddr
+        }));
+    }
+
+    protected async handleHandshakeAuthChallenge(
+        ws: WebSocket,
+        msg: any,
+        sessionS: KeystoneIbGib_V1,
+        sessionSecret: string
+    ): Promise<void> {
+        const { challengeUuid, demandedIds } = msg;
+        if (logalot) { console.log(`${this.lc} solving demanded challenges: ${demandedIds.join(', ')}`); }
+
+        const proofFrame = await this.signContextConnect({
+            challengeUuid,
+            demandedIds
+        });
+
+        if (!proofFrame) {
+            throw new Error(`Failed to sign connect challenge proof (E: e9807f28ae9248bbadd0a7f1a8e9826)`);
+        }
+
+        ws.send(JSON.stringify({
+            type: SyncWebSocketMsgType.auth_proof,
+            proofFrame
+        }));
+    }
+
+    protected handleHandshakeAuthOk(ws: WebSocket, resolve: () => void): void {
+        if (logalot) { console.log(`${this.lc} WebSocket connect SUCCESS!`); }
+        if (this.handshakeMessageListener) {
+            ws.removeEventListener('message', this.handshakeMessageListener);
+            this.handshakeMessageListener = undefined;
+        }
+        ws.addEventListener('message', (event) => this.handleRuntimeMessage(event));
+        resolve();
+    }
+
+    protected handleHandshakeAuthFail(msg: any, reject: (err: Error) => void): void {
+        this.disconnect();
+        reject(new Error(`Handshake auth failed: ${msg.message || 'Unknown fail reason'} (E: f380b271a2be498db257bc8209fa8926)`));
+    }
+
+    protected handleHandshakeSyncError(msg: any, reject: (err: Error) => void): void {
+        this.disconnect();
+        reject(new Error(`Handshake sync error: ${msg.message || msg.error || 'Unknown sync error'} (E: f9208a01fe434cbbad83f210ea8f3426)`));
+    }
+
+    protected async handleRuntimeSyncFrameResponse(msg: any): Promise<void> {
+        const responseContext = msg.context as SyncSagaContextIbGib_V1;
+
+        const validationErrors = await validateContextAndSagaFrame({ context: responseContext });
+        if (validationErrors.length > 0) {
+            throw new Error(`Invalid response context received: ${validationErrors.join(', ')} (E: d7b5a283cf4c43ba8659c803800cf826)`);
+        }
+
+        // Put response control ibgibs into durable space immediately
+        const allControlIbGibs: IbGib_V1[] = [
+            toDto({ ibGib: responseContext }),
+            responseContext.sagaFrame,
+            responseContext.sagaFrameMsg!
+        ];
+        if (responseContext.signedSessionIdentity) {
+            allControlIbGibs.push(responseContext.signedSessionIdentity);
+        }
+
+        const { localSpace } = this.opts!;
+        for (const ibGib of allControlIbGibs) {
+            await putInSpace({ space: localSpace, ibGibs: [ibGib] });
+            await registerNewIbGib({ space: localSpace, ibGib });
+        }
+
+        const expectedPayloadAddrs = responseContext.data?.['@payloadAddrsDomain'] || [];
+        if (expectedPayloadAddrs.length > 0) {
+            this.ws!.send(JSON.stringify({
+                type: SyncWebSocketMsgType.sync_frame_response_authenticated,
+                contextAddr: getIbGibAddr({ ibGib: responseContext })
+            }));
+        }
+
+        if (this.activeResolve) {
+            const resolve = this.activeResolve;
+            this.activeResolve = undefined;
+            this.activeReject = undefined;
+            resolve(responseContext);
+        }
+    }
+
+    protected handleRuntimeSyncFrameAuthenticated(): void {
+        const payloads = this.pendingPayloadsToSend || [];
+        this.pendingPayloadsToSend = [];
+        for (const ibGib of payloads) {
+            this.ws!.send(JSON.stringify({
+                type: SyncWebSocketMsgType.domain_payload,
+                ibGib
+            }));
+        }
+    }
+
+    protected handleRuntimeDomainPayload(msg: any): void {
+        const payload = msg.ibGib as IbGib_V1;
+        this.payloadIbGibsDomainReceived$.next(payload);
+    }
+
+    protected handleRuntimeSyncError(msg: any): void {
+        const errorDetail = msg.message || msg.error || 'Unknown sync runtime error';
+        const error = new Error(`Sync runtime error from receiver: ${errorDetail} (E: e983bc1c828d447fa0581da2b8004f26)`);
+        if (this.activeReject) {
+            const reject = this.activeReject;
+            this.activeResolve = undefined;
+            this.activeReject = undefined;
+            reject(error);
+        } else {
+            throw error;
+        }
+    }
+
     /**
      * Serializes the transaction context and payload down the active WebSocket connection.
      */

package/src/sync/sync-saga-context/sync-saga-context-helpers.mts

@@ -2,14 +2,14 @@
  * @module sync saga context helpers
  */
 
-import { extractErrorMsg, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { extractErrorMsg, pretty, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { getIbGibAddr, } from '@ibgib/ts-gib/dist/helper.mjs';
 import { Ib, } from '@ibgib/ts-gib/dist/types.mjs';
 import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
 
 import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
 import { SYNC_SAGA_CONTEXT_ATOM } from './sync-saga-context-constants.mjs';
-import { SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN } from '../sync-constants.mjs';
+import { SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN, SYNC_MSG_REL8N_NAME } from '../sync-constants.mjs';
 import {
     SyncSagaContextData_V1, SyncSagaContextIbGib_V1, SyncSagaContextIb_V1,
 } from './sync-saga-context-types.mjs';
@@ -17,9 +17,9 @@ import { IbGibSpaceAny } from '../../witness/space/space-base-v1.mjs';
 import { getFromSpace, getLatestAddrs, getTjpIbGib } from '../../witness/space/space-helper.mjs';
 import { SessionGenesisFrameDetails, } from '../sync-types.mjs';
 import { validateSyncSagaFrame } from '../sync-helpers.mjs';
-import { isIbGibWithAtom } from '../../common/other/ibgib-helper.mjs';
+import { isIbGibWithAtom, toDto } from '../../common/other/ibgib-helper.mjs';
 import { KeystoneService_V1 } from '../../keystone/keystone-service-v1.mjs';
-import { KeystoneIbGib_V1 } from '../../keystone/keystone-types.mjs';
+import { KeystoneData_V1, KeystoneIbGib_V1 } from '../../keystone/keystone-types.mjs';
 import { KEYSTONE_VERB_SYNC } from '../../keystone/keystone-constants.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT;
@@ -150,6 +150,26 @@ export async function validateContextAndSagaFrame({
             errors.push(`context.sagaFrame is falsy. (E: b4edd88f4963f493789f83b29ba2df26)`);
         }
 
+        if (context.sagaFrameMsg) {
+            const sagaFrameMsgErrors =
+                await validateIbGibIntrinsically({ ibGib: context.sagaFrameMsg }) ?? [];
+            sagaFrameMsgErrors.forEach(x => errors.push(x));
+
+            if (context.sagaFrame) {
+                const expectedMsgAddr = context.sagaFrame.rel8ns?.[SYNC_MSG_REL8N_NAME]?.[0];
+                if (expectedMsgAddr) {
+                    const actualMsgAddr = getIbGibAddr({ ibGib: context.sagaFrameMsg });
+                    if (actualMsgAddr !== expectedMsgAddr) {
+                        errors.push(`context.sagaFrameMsg address (${actualMsgAddr}) does not match the stone address referenced in sagaFrame relations (${expectedMsgAddr}). (E: a983b271fcae46bbad7e82098bc24826)`);
+                    }
+                } else {
+                    errors.push(`context.sagaFrame is missing the message stone relation '${SYNC_MSG_REL8N_NAME}'. (E: da872cf3a8d46dbbad89d0a68d712826)`);
+                }
+            }
+        } else {
+            errors.push(`context.sagaFrameMsg is falsy. (E: ed405a72ab0d8bbdca7b9605d8f9a26)`);
+        }
+
         // if this is already invalid, we could have intrinsic validation
         // errors, which are a non-starter.
         if (errors.length > 0) { return errors; /* <<<< returns early */ }
@@ -301,6 +321,28 @@ export async function authenticateContextIntrinsically({
             } else {
                 // debugger; // in sync saga context auth, want to know if this hits...so far this does NOT hit
                 errors.push(`context.rel8ns.sessionIdentity does not point to the most recent in the space (${space.ib}). (E: 2f8288f53c87b6aa47bd2178d9df0c26)`)
+
+                // #region debug error keystone
+                console.log(`context: ${pretty(toDto({ ibGib: context }))}`)
+                console.log(`prevSessionIdentityAddr (context.rel8ns.sessionIdentity): ${prevSessionIdentityAddr}`)
+                console.log(`prevSessionIdentityAddr_latest: ${prevSessionIdentityAddr_latest}`)
+                console.log(`currSessionIdentity (context.signedSessionIdentity): ${pretty(toDto({
+                    ibGib: {
+                        ib: currSessionIdentity.ib,
+                        gib: currSessionIdentity.gib,
+                        rel8ns: currSessionIdentity.rel8ns,
+                        data: {
+                            ...currSessionIdentity.data,
+                            challengePools: currSessionIdentity.data.challengePools.map(p => {
+                                return { ...p, challenges: {} }
+                            }),
+                        } satisfies Partial<KeystoneData_V1>,
+
+                    }
+                }))}`)
+                console.log(`currSessionIdentityAddr: ${currSessionIdentityAddr}`)
+
+                // #endregion debug error keystone
                 return errors; /* <<<< returns early */
             }
         }

package/src/sync/sync-saga-context/sync-saga-context-types.mts

@@ -79,4 +79,9 @@ export interface SyncSagaContextIbGib_V1 extends IbGib_V1<SyncSagaContextData_V1
      * Evolved session identity frame signed by Alice targeting this context.
      */
     signedSessionIdentity?: KeystoneIbGib_V1;
+
+    /**
+     * The actual message stone (the sync saga message containing state/stage).
+     */
+    sagaFrameMsg: IbGib_V1;
 }

package/src/sync/sync-saga-coordinator.mts

@@ -32,7 +32,7 @@ import {
     HandleSagaResponseContextResult,
     SyncSagaFrameDependencyGraph,
 } from "./sync-types.mjs";
-import { getSyncSagaFrameOrigin, getFullSyncSagaHistory, getSyncIb, getTempSpaceName, isPastFrame, putInSpace_dnasThenNonDnas, validateFullSyncSagaHistory, getAllOrphanedAddresses, getFinalConflictsInfo } from "./sync-helpers.mjs";
+import { getSyncSagaFrameOrigin, getFullSyncSagaHistory, getSyncIb, getTempSpaceName, isPastFrame, putInSpace_dnasThenNonDnas, validateFullSyncSagaHistory, getAllOrphanedAddresses, getFinalConflictsInfo, getSyncSagaFrameDependencyGraph } from "./sync-helpers.mjs";
 import { getDeltaDependencyGraph, getDependencyGraph, toFlatGraph } from "../common/other/graph-helper.mjs";
 import {
     SyncSagaMessageData_V1, SyncSagaMessageInitData_V1,
@@ -533,6 +533,16 @@ export class SyncSagaCoordinator {
                 await validateContextAndSagaFrame({ context: responseCtx });
             if (contextAndSagaFrameValidationErrors.length > 0) { throw new Error(`contextAndSagaFrameValidationErrors: ${contextAndSagaFrameValidationErrors} (E: 6eebe8e7fa437c00a8cde3ada3c66826)`); }
 
+            // Turn-by-turn continuation & identity checks
+            const returnContextErrors = await this.validateReturnContext({
+                requestCtx,
+                responseCtx,
+                localSpace,
+            });
+            if (returnContextErrors.length > 0) {
+                throw new Error(`validateReturnContext errors: ${returnContextErrors.join(', ')} (E: cb8a023b9d0728cceb09fa3da0bb8226)`);
+            }
+
             // Extract expected domain addresses from response context
             const responsePayloadAddrsDomain = responseCtx.data[SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN] as string[] || [];
 
@@ -738,6 +748,16 @@ export class SyncSagaCoordinator {
 
             // Attach actual ibgibs for transport
             contextIbGib.sagaFrame = sagaFrame;
+
+            const { msgStones } = await getSyncSagaFrameDependencyGraph({
+                sagaIbGib: sagaFrame,
+                localSpace: localSpace,
+            });
+            if (msgStones.length !== 1) {
+                throw new Error(`(UNEXPECTED) msgStones.length !== 1 inside createSyncSagaContext? (E: a98165cf46ab4e82b7bd5e45a273b826)`);
+            }
+            contextIbGib.sagaFrameMsg = msgStones[0];
+
             if (payloadIbGibsDomain && payloadIbGibsDomain.length > 0) {
                 contextIbGib.payloadIbGibsDomain = payloadIbGibsDomain;
             }
@@ -942,6 +962,54 @@ export class SyncSagaCoordinator {
         }
     }
 
+    /**
+     * Validates that the return context received from a peer is a valid
+     * continuation of the outbound context and that the session identity
+     * is consistent.
+     */
+    private async validateReturnContext({
+        requestCtx,
+        responseCtx,
+        localSpace,
+    }: {
+        requestCtx: SyncSagaContextIbGib_V1,
+        responseCtx: SyncSagaContextIbGib_V1,
+        localSpace: IbGibSpaceAny,
+    }): Promise<string[]> {
+        const lc = `${this.lc}[${this.validateReturnContext.name}]`;
+        const errors: string[] = [];
+        try {
+            // 1. Verify saga frame continuation
+            if (requestCtx.sagaFrame && responseCtx.sagaFrame) {
+                const requestFrameAddr = getIbGibAddr({ ibGib: requestCtx.sagaFrame });
+                const responseFrameAddr = getIbGibAddr({ ibGib: responseCtx.sagaFrame });
+                
+                const isContinuation = await isPastFrame({
+                    olderAddr: requestFrameAddr,
+                    newerAddr: responseFrameAddr,
+                    space: localSpace,
+                });
+                if (!isContinuation) {
+                    errors.push(`Response saga frame (${responseFrameAddr}) is not a valid continuation of request saga frame (${requestFrameAddr}). (E: 2c85e8d97318ff24ac8a02bd3a068226)`);
+                }
+            } else {
+                errors.push(`Missing sagaFrame on requestCtx or responseCtx. (E: b65c68ff891000ddca8d22384a088226)`);
+            }
+
+            // 2. Verify session identity has not changed
+            const expectedSessionIdAddr = requestCtx.signedSessionIdentity ?
+                getIbGibAddr({ ibGib: requestCtx.signedSessionIdentity }) :
+                requestCtx.rel8ns?.sessionIdentity?.[0];
+            const responseSessionIdAddr = responseCtx.rel8ns?.sessionIdentity?.[0];
+            if (expectedSessionIdAddr !== responseSessionIdAddr) {
+                errors.push(`Session identity mismatch. Expected ${expectedSessionIdAddr}, got ${responseSessionIdAddr}. (E: ab98716bca88d2243cc822187768226)`);
+            }
+        } catch (error) {
+            errors.push(`Error during validateReturnContext: ${extractErrorMsg(error)} (E: da878e1239aa88ee27bdfca005c28226)`);
+        }
+        return errors;
+    }
+
     /**
      * Helper to poll for streaming domain payloads and put them in the
      * local {@link tempSpace}.

package/src/sync/sync-withid.pingpong.respec.mts

@@ -34,7 +34,8 @@ import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
 import { getIdentity_throwIfUndefined } from '../keystone/keystone-helpers.mjs';
 import { Factory_V1 } from '@ibgib/ts-gib/dist/V1/factory.mjs';
 import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
-import { getDependencyGraph } from '../common/other/graph-helper.mjs';
+import { getDependencyGraph, graphsAreEquivalent } from '../common/other/graph-helper.mjs';
+import { getFromSpace } from '../witness/space/space-helper.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT;
 const lc = sir;
@@ -158,4 +159,76 @@ await respecfully(sir, `Test Phase 3A: Ping Pong Sync with Identity`, async () =
         iReckon(sir, syncError).asTo(`syncError: ${errorMsg}`).isGonnaBeFalsy();
     });
 
+    await ifWeMight(sir, 'alpha dep graph matches on source and dest', async () => {
+        const resGetDest = await getFromSpace({ space: destSpace, addr: xStoneAddr });
+        iReckon(sir, resGetDest.success && resGetDest.ibGibs?.length === 1).asTo('xStone exists in destSpace').isGonnaBeTrue();
+        if (resGetDest.success && resGetDest.ibGibs?.[0]) {
+            const xStoneDest = resGetDest.ibGibs[0];
+            const depGraphSource = await getDependencyGraph({ ibGib: xStone, space: sourceSpace });
+            const depGraphDest = await getDependencyGraph({ ibGib: xStoneDest, space: destSpace });
+            const equal = graphsAreEquivalent({ graphA: depGraphSource, graphB: depGraphDest });
+            iReckon(sir, equal).asTo('graphs are equivalent').isGonnaBeTrue();
+        }
+    });
+
+    await ifWeMight(sir, 'sessionIdentity evolved the expected number of times', async () => {
+        const latestS = peer.currentSessionIdentity;
+        iReckon(sir, latestS).asTo('latest session identity exists on peer').isGonnaBeTruthy();
+        if (latestS) {
+            iReckon(sir, latestS.data?.n).asTo('session identity data.n').isGonnaBe(2);
+        }
+    });
+
+    await ifWeMight(sir, 'sender durable space has I (evolved frame)', async () => {
+        const latestSenderIdentityAddr = await metaspace.getLatestAddr({
+            addr: getIbGibAddr({ ibGib: senderIdentity }),
+            space: sourceSpace,
+        });
+        iReckon(sir, latestSenderIdentityAddr).asTo('latestSenderIdentityAddr exists').isGonnaBeTruthy();
+        if (latestSenderIdentityAddr) {
+            const resGetSourceI = await getFromSpace({ space: sourceSpace, addr: latestSenderIdentityAddr });
+            iReckon(sir, resGetSourceI.success && resGetSourceI.ibGibs?.length === 1).asTo('evolved I exists in sourceSpace').isGonnaBeTrue();
+            if (resGetSourceI.success && resGetSourceI.ibGibs?.[0]) {
+                const evolvedI = resGetSourceI.ibGibs[0];
+                iReckon(sir, evolvedI.data?.n).asTo('evolved I data.n').isGonnaBe(1);
+            }
+        }
+    });
+
+    await ifWeMight(sir, 'receiver durable space has I (evolved frame)', async () => {
+        const latestSenderIdentityAddr = await metaspace.getLatestAddr({
+            addr: getIbGibAddr({ ibGib: senderIdentity }),
+            space: sourceSpace,
+        });
+        iReckon(sir, latestSenderIdentityAddr).asTo('latestSenderIdentityAddr exists').isGonnaBeTruthy();
+        if (latestSenderIdentityAddr) {
+            const resGetDestI = await getFromSpace({ space: destSpace, addr: latestSenderIdentityAddr });
+            iReckon(sir, resGetDestI.success && resGetDestI.ibGibs?.length === 1).asTo('evolved I exists in destSpace').isGonnaBeTrue();
+            if (resGetDestI.success && resGetDestI.ibGibs?.[0]) {
+                const evolvedI = resGetDestI.ibGibs[0];
+                iReckon(sir, evolvedI.data?.n).asTo('evolved I data.n').isGonnaBe(1);
+            }
+        }
+    });
+
+    await ifWeMight(sir, 'sender durable space has full S dep graph', async () => {
+        const latestS = peer.currentSessionIdentity;
+        iReckon(sir, latestS).asTo('latestS exists').isGonnaBeTruthy();
+        if (latestS) {
+            const depGraphS = await getDependencyGraph({ ibGib: latestS, space: sourceSpace });
+            const addrs = Object.keys(depGraphS);
+            iReckon(sir, addrs.length > 2).asTo('number of nodes in S graph > 2').isGonnaBeTrue();
+        }
+    });
+
+    await ifWeMight(sir, 'receiver durable space has full S dep graph', async () => {
+        const latestS = peer.currentSessionIdentity;
+        iReckon(sir, latestS).asTo('latestS exists').isGonnaBeTruthy();
+        if (latestS) {
+            const depGraphS = await getDependencyGraph({ ibGib: latestS, space: destSpace });
+            const addrs = Object.keys(depGraphS);
+            iReckon(sir, addrs.length > 2).asTo('number of nodes in S graph in destSpace > 2').isGonnaBeTrue();
+        }
+    });
+
 });