@ibgib/space-gib 0.0.2 → 0.0.4

package/src/client/dev-tools/phase-4-2.mts

@@ -0,0 +1,388 @@
+import { extractErrorMsg, getUUID, getTimestamp } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { Factory_V1 as factory } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+import { ROOT } from '@ibgib/ts-gib/dist/V1/constants.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { KeystoneIbGib_V1 } from '@ibgib/core-gib/dist/keystone/keystone-types.mjs';
+import { KeystoneService_V1 } from '@ibgib/core-gib/dist/keystone/keystone-service-v1.mjs';
+import { getGlobalMetaspace_waitIfNeeded } from "@ibgib/web-gib/dist/helpers.mjs";
+import { mut8Timeline } from '@ibgib/core-gib/dist/timeline/timeline-api.mjs';
+import { graphsAreEquivalent } from '@ibgib/core-gib/dist/common/other/graph-helper.mjs';
+import { SyncPeerWebSocketSender_V1 } from '@ibgib/core-gib/dist/sync/sync-peer/sync-peer-websocket/sync-peer-websocket-sender/sync-peer-websocket-sender-v1.mjs';
+import { SyncSagaCoordinator } from '@ibgib/core-gib/dist/sync/sync-saga-coordinator.mjs';
+import { SyncConflictStrategy } from '@ibgib/core-gib/dist/sync/sync-constants.mjs';
+import { SESSION_KEYSTONE_POLICY, getSpaceGibPoolConfig } from "../../common/keystone-policies.mjs";
+import { SpaceGibApiBridge } from '../api/space-gib-api-bridge.mjs';
+
+import { debugState, devLog, lc, performPhaseSetup } from './common.mjs';
+
+export function init4_2bSetupButton(): void {
+    const btn = document.getElementById('btn-4-2b-setup') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', () => {
+        performPhaseSetup({
+            phaseText: '4.2B',
+            btnId: 'btn-4-2b-setup',
+            nextBtnId: 'btn-4-2b-sync',
+            masterSecret: 'test-sender-secret-phase4-2',
+            syncSalt: 'senderidentitysyncsaltphase4-2',
+            manageSalt: 'senderidentitymanagesaltphase4-2',
+            ib: 'dummy target 4.2b',
+            data: { hello: 'dummy' }
+        });
+    });
+}
+
+async function performPhaseSync4_2b(): Promise<void> {
+    const lc_fn = `${lc}[performPhaseSync4_2b]`;
+    const btn = document.getElementById('btn-4-2b-sync') as HTMLButtonElement | null;
+    if (!btn) { return; }
+
+    try {
+        btn.disabled = true;
+        devLog(`4.2B Sync: Creating Constants and executing three-pass WebSocket Sync...`);
+
+        const domainI = debugState.domainI;
+        if (!domainI) {
+            devLog(`⚠ 4.2B Sync: Missing setup state. Please run Setup first.`);
+            btn.disabled = false;
+            return;
+        }
+
+        const domainAddr = getIbGibAddr({ ibGib: domainI });
+        const metaspace = await getGlobalMetaspace_waitIfNeeded();
+        const space = await metaspace.getLocalUserSpace({});
+        if (!space) { throw new Error("No default space."); }
+
+        // 1. Create Constant C1 locally
+        const c1 = await factory.constant({
+            parentPrimitiveIb: 'root',
+            ib: 'constant_c1_' + (await getUUID()).slice(0, 8),
+            data: { some: 'data_4_2b', random: Math.random() },
+        });
+        const addrC1 = getIbGibAddr({ ibGib: c1 });
+        await metaspace.put({ ibGib: c1, space });
+        await metaspace.registerNewIbGib({ ibGib: c1 });
+        debugState.targetC1 = c1;
+        devLog(`4.2B Sync: ✓ Constant C1 created: ${addrC1}`);
+
+        // --- Sync 1: C1 First Pass ---
+        devLog(`4.2B Sync: Starting Pass 1 (Sync C1)...`);
+        const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+        let senderPeer = new SyncPeerWebSocketSender_V1({
+            classname: 'SyncPeerWebSocketSender_V1',
+            httpEvolveUrl: `${location.protocol}//${location.host}/api/keystone/evolve/${encodeURIComponent(domainAddr)}`,
+            wsUrl: `${protocol}//${location.host}/api/sync/ws/${encodeURIComponent(domainAddr)}`
+        });
+
+        let coordinator = new SyncSagaCoordinator();
+        let sagaId = await getUUID();
+        debugState.sagaId = sagaId;
+        debugState.senderPeer = senderPeer;
+
+        await senderPeer.initializeOpts({
+            localMetaspace: metaspace,
+            localSpace: space,
+            senderIdentity: domainI,
+            fnSenderSecret: async () => debugState.domainIMasterSecret!,
+            sagaId,
+            sessionConnectPoolConfig: SESSION_KEYSTONE_POLICY.CONNECT_POOL as any,
+            sessionSyncPoolConfig: SESSION_KEYSTONE_POLICY.DEFAULT_POOL as any,
+            targetAddrs: [domainAddr]
+        });
+
+        let syncSaga = await coordinator.sync({
+            domainIbGibs: [c1],
+            senderIdentity: domainI,
+            fnSenderSecret: async () => debugState.domainIMasterSecret!,
+            peer: senderPeer,
+            localSpace: space,
+            metaspace,
+            conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+        });
+        await syncSaga.done;
+        devLog(`4.2B Sync: ✓ Pass 1 Complete.`);
+
+        const latestSenderAddr1 = await metaspace.getLatestAddr({
+            addr: getIbGibAddr({ ibGib: domainI }),
+            space,
+        });
+        const resGetLatestI1 = await metaspace.get({ addrs: [latestSenderAddr1!], space });
+        const senderIdentityEvolved1 = resGetLatestI1.ibGibs![0] as KeystoneIbGib_V1;
+
+        // --- Sync 2: C1 Second Pass (Idempotent check) ---
+        devLog(`4.2B Sync: Starting Pass 2 (Sync C1 - Idempotent)...`);
+        senderPeer = new SyncPeerWebSocketSender_V1({
+            classname: 'SyncPeerWebSocketSender_V1',
+            httpEvolveUrl: `${location.protocol}//${location.host}/api/keystone/evolve/${encodeURIComponent(domainAddr)}`,
+            wsUrl: `${protocol}//${location.host}/api/sync/ws/${encodeURIComponent(domainAddr)}`
+        });
+        coordinator = new SyncSagaCoordinator();
+        sagaId = await getUUID();
+        debugState.sagaId = sagaId;
+        debugState.senderPeer = senderPeer;
+
+        await senderPeer.initializeOpts({
+            localMetaspace: metaspace,
+            localSpace: space,
+            senderIdentity: senderIdentityEvolved1,
+            fnSenderSecret: async () => debugState.domainIMasterSecret!,
+            sagaId,
+            sessionConnectPoolConfig: SESSION_KEYSTONE_POLICY.CONNECT_POOL as any,
+            sessionSyncPoolConfig: SESSION_KEYSTONE_POLICY.DEFAULT_POOL as any,
+            targetAddrs: [domainAddr]
+        });
+
+        syncSaga = await coordinator.sync({
+            domainIbGibs: [c1],
+            senderIdentity: senderIdentityEvolved1,
+            fnSenderSecret: async () => debugState.domainIMasterSecret!,
+            peer: senderPeer,
+            localSpace: space,
+            metaspace,
+            conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+        });
+        await syncSaga.done;
+        devLog(`4.2B Sync: ✓ Pass 2 Complete.`);
+
+        const latestSenderAddr2 = await metaspace.getLatestAddr({
+            addr: getIbGibAddr({ ibGib: domainI }),
+            space,
+        });
+        const resGetLatestI2 = await metaspace.get({ addrs: [latestSenderAddr2!], space });
+        const senderIdentityEvolved2 = resGetLatestI2.ibGibs![0] as KeystoneIbGib_V1;
+
+        // 2. Create Constant C2 locally linking to C1
+        const c2 = await factory.constant({
+            ib: 'constant_c2_' + (await getUUID()).slice(0, 8),
+            parentPrimitiveIb: 'root',
+            rel8ns: {
+                link: [addrC1],
+            },
+        });
+        const addrC2 = getIbGibAddr({ ibGib: c2 });
+        await metaspace.put({ ibGib: c2, space });
+        await metaspace.registerNewIbGib({ ibGib: c2 });
+        debugState.targetC2 = c2;
+        devLog(`4.2B Sync: ✓ Constant C2 created linking to C1: ${addrC2}`);
+
+        // --- Sync 3: C2 Pass ---
+        devLog(`4.2B Sync: Starting Pass 3 (Sync C2)...`);
+        senderPeer = new SyncPeerWebSocketSender_V1({
+            classname: 'SyncPeerWebSocketSender_V1',
+            httpEvolveUrl: `${location.protocol}//${location.host}/api/keystone/evolve/${encodeURIComponent(domainAddr)}`,
+            wsUrl: `${protocol}//${location.host}/api/sync/ws/${encodeURIComponent(domainAddr)}`
+        });
+        coordinator = new SyncSagaCoordinator();
+        sagaId = await getUUID();
+        debugState.sagaId = sagaId;
+        debugState.senderPeer = senderPeer;
+
+        await senderPeer.initializeOpts({
+            localMetaspace: metaspace,
+            localSpace: space,
+            senderIdentity: senderIdentityEvolved2,
+            fnSenderSecret: async () => debugState.domainIMasterSecret!,
+            sagaId,
+            sessionConnectPoolConfig: SESSION_KEYSTONE_POLICY.CONNECT_POOL as any,
+            sessionSyncPoolConfig: SESSION_KEYSTONE_POLICY.DEFAULT_POOL as any,
+            targetAddrs: [domainAddr]
+        });
+
+        syncSaga = await coordinator.sync({
+            domainIbGibs: [c2],
+            senderIdentity: senderIdentityEvolved2,
+            fnSenderSecret: async () => debugState.domainIMasterSecret!,
+            peer: senderPeer,
+            localSpace: space,
+            metaspace,
+            conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+        });
+        await syncSaga.done;
+        devLog(`4.2B Sync: ✓ Pass 3 Complete.`);
+
+        devLog(`✓ 4.2B Sync Sequence Complete! Ready for State Checks.`);
+        btn.textContent = `✓ 4.2B Sync Run`;
+
+        const checkBtn = document.getElementById('btn-4-2b-check') as HTMLButtonElement | null;
+        if (checkBtn) { checkBtn.disabled = false; }
+
+    } catch (error) {
+        devLog(`✗ 4.2B Sync FAILED: ${extractErrorMsg(error)}`);
+        console.error(`${lc_fn} 4.2B Sync error:`, error);
+        btn.disabled = false;
+    }
+}
+
+export function init4_2bSyncButton(): void {
+    const btn = document.getElementById('btn-4-2b-sync') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', () => {
+        performPhaseSync4_2b();
+    });
+}
+
+export function init4_2bCheckButton(): void {
+    const lc_fn = `${lc}[init4_2bCheckButton]`;
+    const btn = document.getElementById('btn-4-2b-check') as HTMLButtonElement | null;
+    if (!btn) { return; }
+
+    btn.addEventListener('click', async () => {
+        try {
+            devLog('4.2B Check: Asserting cryptographic and WebSocket state expectations...');
+
+            const metaspace = await getGlobalMetaspace_waitIfNeeded();
+            const space = await metaspace.getLocalUserSpace({});
+            if (!space) { throw new Error("No default space."); }
+
+            const domainI = debugState.domainI!;
+            const targetC1 = debugState.targetC1!;
+            const targetC2 = debugState.targetC2!;
+            const c1Addr = getIbGibAddr({ ibGib: targetC1 });
+            const c2Addr = getIbGibAddr({ ibGib: targetC2 });
+            const domainAddr = getIbGibAddr({ ibGib: domainI });
+
+            // 1. Verify C1 and C2 exist locally
+            const localC1Res = await metaspace.get({ addrs: [c1Addr], space });
+            const localC2Res = await metaspace.get({ addrs: [c2Addr], space });
+            if (!localC1Res.success || !localC1Res.ibGibs?.[0]) {
+                devLog('✗ Check: Constant C1 NOT found locally.');
+                return;
+            }
+            if (!localC2Res.success || !localC2Res.ibGibs?.[0]) {
+                devLog('✗ Check: Constant C2 NOT found locally.');
+                return;
+            }
+            devLog(`✓ Check: Constants C1 and C2 exist locally.`);
+
+            // 2. Fetch server's graphs for C1 and C2
+            const apiBridge = new SpaceGibApiBridge();
+            const serverC1Res = await apiBridge.getIbGib(domainAddr, c1Addr);
+            const serverC2Res = await apiBridge.getIbGib(domainAddr, c2Addr);
+            if (!serverC1Res.success || !serverC1Res.ibGib) {
+                devLog(`✗ Check: Constant C1 NOT found on server: ${serverC1Res.message}`);
+                return;
+            }
+            if (!serverC2Res.success || !serverC2Res.ibGib) {
+                devLog(`✗ Check: Constant C2 NOT found on server: ${serverC2Res.message}`);
+                return;
+            }
+            devLog(`✓ Check: Constants C1 and C2 exist on server.`);
+
+            const localC2Graph = await metaspace.getDependencyGraph({
+                ibGibAddr: c2Addr,
+                space
+            });
+            const serverC2GetGraphRes = await apiBridge.getIbGibGraph(domainAddr, c2Addr, true);
+            if (!serverC2GetGraphRes.success || !serverC2GetGraphRes.graph) {
+                devLog(`✗ Check: Failed to fetch C2 graph from server: ${serverC2GetGraphRes.message}`);
+                return;
+            }
+            const serverC2Graph = serverC2GetGraphRes.graph;
+
+            const c2GraphsEqual = graphsAreEquivalent({ graphA: localC2Graph, graphB: serverC2Graph });
+            if (c2GraphsEqual) {
+                devLog('✓ Check: C2 dependency graphs are equivalent on client and server.');
+            } else {
+                devLog('✗ Check: C2 dependency graphs mismatch between client and server!');
+                return;
+            }
+
+            // 3. Verify evolved sender identity I exists locally and on server, n = 3
+            const latestLocalIAddr = await metaspace.getLatestAddr({
+                addr: domainAddr,
+                space
+            });
+            if (!latestLocalIAddr) {
+                devLog('✗ Check: Evolved domain keystone tip I3 NOT found in local space!');
+                return;
+            }
+            const localIRes = await metaspace.get({ addrs: [latestLocalIAddr], space });
+            const localI = localIRes.ibGibs?.[0] as KeystoneIbGib_V1 | undefined;
+            if (!localI) {
+                devLog('✗ Check: Failed to load evolved I from local space.');
+                return;
+            }
+            devLog(`✓ Check: Evolved Domain Keystone exists locally: ${latestLocalIAddr}`);
+
+            const nI = localI.data?.n;
+            devLog(`✓ Check: Evolved I tip is at n = ${nI}.`);
+            if (nI !== 3) {
+                devLog(`✗ Check: Expected I to evolve to n = 3, got n = ${nI}.`);
+                return;
+            }
+
+            const serverIGetRes = await apiBridge.getIbGib(domainAddr, latestLocalIAddr);
+            if (!serverIGetRes.success || !serverIGetRes.ibGib) {
+                devLog(`✗ Check: Evolved Domain Keystone tip NOT found on server!`);
+                return;
+            }
+            devLog(`✓ Check: Evolved Domain Keystone tip exists on server.`);
+
+            // 4. Verify session identity S tip exists locally and on server
+            const syncProof = localI.data?.proofs?.find(p => p.claim?.verb === 'sync');
+            const sessionIdentityTjpAddr = syncProof?.claim?.target;
+            if (!sessionIdentityTjpAddr) {
+                devLog('✗ Check: Evolved I sync claim does not target a session keystone.');
+                return;
+            }
+
+            const latestLocalSAddr = await metaspace.getLatestAddr({
+                addr: sessionIdentityTjpAddr,
+                space
+            });
+            if (!latestLocalSAddr) {
+                devLog('✗ Check: Latest Session Keystone (S) NOT found in local space.');
+                return;
+            }
+            devLog(`✓ Check: Found latest session keystone (S) locally: ${latestLocalSAddr}`);
+
+            const localSRes = await metaspace.get({ addrs: [latestLocalSAddr], space });
+            const sessionS = localSRes.ibGibs?.[0] as KeystoneIbGib_V1 | undefined;
+            if (!sessionS) {
+                devLog('✗ Check: Failed to load latest Session Keystone (S) locally.');
+                return;
+            }
+
+            const nS = sessionS.data?.n;
+            devLog(`✓ Check: Latest session S tip evolved to n = ${nS}.`);
+            if (nS !== 3) {
+                devLog(`✗ Check: Expected latest session S to evolve to n = 3, got n = ${nS}.`);
+                return;
+            }
+
+            const serverSGetRes = await apiBridge.getIbGib(domainAddr, latestLocalSAddr);
+            if (!serverSGetRes.success || !serverSGetRes.ibGib) {
+                devLog(`✗ Check: Latest Session Keystone (S) NOT found on server!`);
+                return;
+            }
+            devLog(`✓ Check: Latest Session Keystone (S) exists on server.`);
+
+            // 5. Assert S graph is identical on client and server
+            const localSGraph = await metaspace.getDependencyGraph({
+                ibGibAddr: latestLocalSAddr,
+                space
+            });
+            const serverSGetGraphRes = await apiBridge.getIbGibGraph(domainAddr, sessionIdentityTjpAddr, true);
+            if (!serverSGetGraphRes.success || !serverSGetGraphRes.graph) {
+                devLog(`✗ Check: Failed to fetch session S graph from server: ${serverSGetGraphRes.message}`);
+                return;
+            }
+            const serverSGraph = serverSGetGraphRes.graph;
+
+            const sGraphsEqual = graphsAreEquivalent({ graphA: localSGraph, graphB: serverSGraph });
+            if (sGraphsEqual) {
+                devLog('✓ Check: Session Keystone (S) dependency graphs are equivalent on client and server.');
+            } else {
+                devLog('✗ Check: Session Keystone (S) dependency graphs mismatch between client and server!');
+                return;
+            }
+
+            devLog('🎉 ALL PHASE 4.2B TRANSACTION SYNC CHECKS PASSED FLAWLESSLY! ✓');
+            btn.textContent = '✓ 4.2B All Passed';
+
+        } catch (error) {
+            devLog(`✗ 4.2B Check FAILED: ${extractErrorMsg(error)}`);
+            console.error(`${lc_fn} 4.2B Check error:`, error);
+        }
+    });
+}