@pushchain/core 6.0.4 → 6.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushchain/core",
-  "version": "6.0.4",
+  "version": "6.0.5",
   "homepage": "https://push.org",
   "keywords": [
     "pushchain",

package/src/lib/orchestrator/internals/cascade.js

@@ -1265,6 +1265,31 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
 // ============================================================================
 // createCascadedBuilder
 // ============================================================================
+function txHashFromProgressEvent(event) {
+    var _a, _b, _c, _d;
+    const response = event.response;
+    return (_d = (_a = response === null || response === void 0 ? void 0 : response.txHash) !== null && _a !== void 0 ? _a : (_c = (_b = response === null || response === void 0 ? void 0 : response.response) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.hash) !== null && _d !== void 0 ? _d : '';
+}
+function withMultihopRootProgressMapping(ctx, run) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const originalHook = ctx.progressHook;
+        if (!originalHook)
+            return run();
+        ctx.progressHook = (event) => {
+            if (event.id === progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_01) {
+                originalHook(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_99](txHashFromProgressEvent(event)));
+                return;
+            }
+            originalHook(event);
+        };
+        try {
+            return yield run();
+        }
+        finally {
+            ctx.progressHook = originalHook;
+        }
+    });
+}
 function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
     return {
         send: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -1293,6 +1318,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                         },
                     ],
                     hopCount: 1,
+                    finalTxHash: response.hash,
                     waitForAll: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
                         return ({
                             success: true,
@@ -1305,6 +1331,8 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                     txHash: response.hash,
                                 },
                             ],
+                            finalTxHash: response.hash,
+                            finalTxResponse: singleRoute1Result,
                         });
                     }),
                     wait: (opts) => tslib_1.__awaiter(this, void 0, void 0, function* () { return singleRoute1Result.waitForAll(opts); }),
@@ -1328,6 +1356,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                         },
                     ],
                     hopCount: 1,
+                    finalTxHash: response.hash,
                     waitForAll: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
                         return ({
                             success: true,
@@ -1340,6 +1369,8 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                     txHash: response.hash,
                                 },
                             ],
+                            finalTxHash: response.hash,
+                            finalTxResponse: singleRoute2Result,
                         });
                     }),
                     wait: (opts) => tslib_1.__awaiter(this, void 0, void 0, function* () { return singleRoute2Result.waitForAll(opts); }),
@@ -1380,7 +1411,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                 value: cascadeRequiredNativeValue,
                 data: composedMulticalls,
             };
-            const response = yield callbacks.executeFn(executeParams);
+            const response = yield withMultihopRootProgressMapping(ctx, () => callbacks.executeFn(executeParams));
             // Build hop info for tracking
             const hopInfos = hops.map((hop, index) => ({
                 hopIndex: index,
@@ -1458,6 +1489,34 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                             return;
                         emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_03](failedIdx0 + 1, totalHops));
                     };
+                    const emitRouteIntermediateComplete = (hop, txHash) => {
+                        var _a;
+                        if (!isMulti)
+                            return;
+                        const n = hop.hopIndex + 1;
+                        if (n >= totalHops)
+                            return; // final terminal is 999-01
+                        const resolvedTxHash = (_a = txHash !== null && txHash !== void 0 ? txHash : hop.txHash) !== null && _a !== void 0 ? _a : response.hash;
+                        if (hop.route === 'UOA_TO_PUSH') {
+                            emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_99](resolvedTxHash));
+                            return;
+                        }
+                        if (hop.route === 'UOA_TO_CEA') {
+                            emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_99](hop.executionChain, resolvedTxHash));
+                            return;
+                        }
+                        if (hop.route === 'CEA_TO_PUSH') {
+                            emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_99](hop.executionChain, resolvedTxHash));
+                        }
+                    };
+                    const buildCompletionResult = (success, failedAt) => {
+                        var _a, _b;
+                        const finalTxHash = (_b = (_a = [...hopInfos]
+                            .reverse()
+                            .find((hop) => hop.status === 'confirmed' && hop.txHash)) === null || _a === void 0 ? void 0 : _a.txHash) !== null && _b !== void 0 ? _b : response.hash;
+                        cascadeResponse.finalTxHash = finalTxHash;
+                        return Object.assign({ success, hops: hopInfos, finalTxHash, finalTxResponse: cascadeResponse }, (failedAt !== undefined ? { failedAt } : {}));
+                    };
                     if (isMulti) {
                         emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_001](totalHops, chainLabels));
                     }
@@ -1500,11 +1559,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                     });
                                     emitHopEvent(hopHooks.timeout(hop.executionChain, Date.now() - startTime));
                                     emitCascadeTimeout(hop.hopIndex);
-                                    return {
-                                        success: false,
-                                        hops: hopInfos,
-                                        failedAt: hop.hopIndex,
-                                    };
+                                    return buildCompletionResult(false, hop.hopIndex);
                                 }
                                 emitHopStart(hop.hopIndex);
                                 emitHopEvent(hopHooks.awaiting(hop.executionChain));
@@ -1545,7 +1600,12 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                     hop.status = 'confirmed';
                                     hop.txHash = displayTxHash;
                                     hop.outboundDetails = userFacingOutboundDetails;
-                                    emitHopEvent(hopHooks.success(userFacingOutboundDetails));
+                                    if (isMulti) {
+                                        emitRouteIntermediateComplete(hop, displayTxHash);
+                                    }
+                                    else {
+                                        emitHopEvent(hopHooks.success(userFacingOutboundDetails));
+                                    }
                                     emitHopComplete(hop.hopIndex);
                                     cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
                                         hopIndex: hop.hopIndex,
@@ -1576,11 +1636,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                         status: 'failed',
                                         elapsed: Date.now() - startTime,
                                     });
-                                    return {
-                                        success: false,
-                                        hops: hopInfos,
-                                        failedAt: hop.hopIndex,
-                                    };
+                                    return buildCompletionResult(false, hop.hopIndex);
                                 }
                             }
                             else {
@@ -1622,7 +1678,12 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                             // guard above, so we only reach here with full details.
                                             if (matchedHop === null || matchedHop === void 0 ? void 0 : matchedHop.outboundDetails) {
                                                 confirmedHops.add(event.hopIndex);
-                                                emitHopEvent(eventHooks.success(matchedHop.outboundDetails));
+                                                if (isMulti) {
+                                                    emitRouteIntermediateComplete(matchedHop, event.txHash);
+                                                }
+                                                else {
+                                                    emitHopEvent(eventHooks.success(matchedHop.outboundDetails));
+                                                }
                                                 emitHopComplete(event.hopIndex);
                                             }
                                         }
@@ -1636,11 +1697,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                         : `Outbound cascade failed at hop ${failedIdx}`;
                                     emitHopEvent((0, progress_route_hooks_1.pickWaitHooks)(failedHop === null || failedHop === void 0 ? void 0 : failedHop.route).failed((_d = failedHop === null || failedHop === void 0 ? void 0 : failedHop.executionChain) !== null && _d !== void 0 ? _d : '', failMsg));
                                     emitCascadeFailed(failedIdx, failMsg);
-                                    return {
-                                        success: false,
-                                        hops: hopInfos,
-                                        failedAt: failedIdx,
-                                    };
+                                    return buildCompletionResult(false, failedIdx);
                                 }
                             }
                             return null;
@@ -1695,11 +1752,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                 inboundHop.status = 'failed';
                                 emitHopEvent(hopHooks.timeout(inboundHop.executionChain, Date.now() - startTime));
                                 emitCascadeTimeout(inboundHop.hopIndex);
-                                return {
-                                    success: false,
-                                    hops: hopInfos,
-                                    failedAt: inboundHop.hopIndex,
-                                };
+                                return buildCompletionResult(false, inboundHop.hopIndex);
                             }
                             emitHopStart(inboundHop.hopIndex);
                             emitHopEvent(hopHooks.awaiting(inboundHop.executionChain));
@@ -1758,11 +1811,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                     txHash: failedDisplayTxHash,
                                     elapsed: Date.now() - startTime,
                                 });
-                                return {
-                                    success: false,
-                                    hops: hopInfos,
-                                    failedAt: inboundHop.hopIndex,
-                                };
+                                return buildCompletionResult(false, inboundHop.hopIndex);
                             }
                             const displayExternalTxHash = (_f = (0, helpers_1.toExternalTxHashDisplay)(sourceOutboundDetails.destinationChain, sourceOutboundDetails.externalTxHash)) !== null && _f !== void 0 ? _f : sourceOutboundDetails.externalTxHash;
                             inboundHop.outboundDetails = Object.assign(Object.assign({}, sourceOutboundDetails), { externalTxHash: displayExternalTxHash });
@@ -1803,11 +1852,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                     status: 'failed',
                                     elapsed: Date.now() - startTime,
                                 });
-                                return {
-                                    success: false,
-                                    hops: hopInfos,
-                                    failedAt: inboundHop.hopIndex,
-                                };
+                                return buildCompletionResult(false, inboundHop.hopIndex);
                             }
                             if (childInbound.status !== 'confirmed') {
                                 const failMsg = (_h = childInbound.errorMessage) !== null && _h !== void 0 ? _h : 'inbound execution failed on Push Chain';
@@ -1824,16 +1869,17 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                     txHash: inboundHop.txHash,
                                     elapsed: Date.now() - startTime,
                                 });
-                                return {
-                                    success: false,
-                                    hops: hopInfos,
-                                    failedAt: inboundHop.hopIndex,
-                                };
+                                return buildCompletionResult(false, inboundHop.hopIndex);
                             }
                             inboundHop.status = 'confirmed';
                             inboundHop.txHash =
                                 childInbound.pushTxHash || displayExternalTxHash;
-                            emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_01](inboundHop.executionChain, childInbound.pushTxHash));
+                            if (isMulti) {
+                                emitRouteIntermediateComplete(inboundHop, inboundHop.txHash);
+                            }
+                            else {
+                                emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_01](inboundHop.executionChain, childInbound.pushTxHash));
+                            }
                             emitHopComplete(inboundHop.hopIndex);
                             cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
                                 hopIndex: inboundHop.hopIndex,
@@ -1859,6 +1905,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                         txHash: childInbound.pushTxHash,
                                         elapsed: Date.now() - startTime,
                                     });
+                                    emitRouteIntermediateComplete(hop, childInbound.pushTxHash);
                                     emitHopComplete(hop.hopIndex);
                                 }
                             }
@@ -1868,7 +1915,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                                 return childOutboundFailure;
                         }
                         emitCascadeSuccess();
-                        return { success: true, hops: hopInfos };
+                        return buildCompletionResult(true);
                     }
                     catch (err) {
                         const failedIdx = hopInfos.findIndex((h) => h.status !== 'confirmed');
@@ -1881,11 +1928,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
                         else {
                             emitCascadeFailed(failedAt, errMsg);
                         }
-                        return {
-                            success: false,
-                            hops: hopInfos,
-                            failedAt,
-                        };
+                        return buildCompletionResult(false, failedAt);
                     }
                 }),
                 wait: (opts) => tslib_1.__awaiter(this, void 0, void 0, function* () { return cascadeResponse.waitForAll(opts); }),

package/src/lib/orchestrator/internals/context.js

@@ -48,9 +48,8 @@ function printLog(ctx, msg) {
  * Exceptions kept in the stream regardless of route:
  *   - All UEA migration hooks.
  *
- * Separately, the intermediate Push-success markers 199-99-99 (R3) and
- * 299-99 (R2) are suppressed at `fanOut` in response-builder.ts — they're
- * internal transition signals, not consumer-facing spec events.
+ * Multihop-only intermediate success markers (199-99 / 299-99 / 399-99)
+ * are emitted by cascade tracking, not by the single-route wait path.
  */
 const R1_SUPPRESSED_IN_NON_R1 = new Set([
     progress_hook_types_1.PROGRESS_HOOK.SEND_TX_101,

package/src/lib/orchestrator/internals/progress-route-hooks.d.ts

@@ -10,7 +10,6 @@ import type { OutboundTxDetails } from '../orchestrator.types';
 import type { ProgressEvent } from '../../progress-hook/progress-hook.types';
 import { TransactionRoute } from '../route-detector';
 export type WaitHookSet = {
-    intermediatePushOk?: (chain: string, pushTxHash: string) => ProgressEvent;
     awaiting: (chain: string) => ProgressEvent;
     polling: (chain: string, elapsedMs: number) => ProgressEvent;
     success: (details: OutboundTxDetails) => ProgressEvent;

package/src/lib/orchestrator/internals/progress-route-hooks.js

@@ -17,7 +17,6 @@ const route_detector_1 = require("../route-detector");
 function pickWaitHooks(route) {
     if (route === route_detector_1.TransactionRoute.UOA_TO_CEA) {
         return {
-            intermediatePushOk: (chain, txHash) => progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_99](chain, txHash),
             awaiting: (chain) => progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_209_01](chain),
             polling: (chain, elapsed) => progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_209_02](chain, elapsed),
             success: (details) => progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_01](details),
@@ -27,7 +26,6 @@ function pickWaitHooks(route) {
     }
     if (route === route_detector_1.TransactionRoute.CEA_TO_PUSH) {
         return {
-            intermediatePushOk: (_chain, txHash) => progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_99_99](txHash),
             awaiting: (chain) => progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_309_01](chain),
             polling: (chain, elapsed) => progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_309_02](chain, elapsed),
             // For R3, the outbound-poll "success" is the source-chain CEA executing

package/src/lib/orchestrator/internals/response-builder.js

@@ -29,30 +29,14 @@ const inbound_tracker_1 = require("./inbound-tracker");
 const tx_transformer_1 = require("./tx-transformer");
 const progress_route_hooks_1 = require("./progress-route-hooks");
 const outbound_sync_1 = require("./outbound-sync");
-/**
- * Intermediate Push-success markers (199-99-99 for R3, 299-99 for R2) are
- * internal transition signals — they tell response-builder's wait-phase
- * branch that the Push leg has settled so it can skip re-emitting the
- * intermediate marker on top of a reconstructed stream. They are not part
- * of the published 1XX/2XX/3XX/4XX spec and are suppressed at the consumer
- * dispatch boundary. `printLog` still fires for these so internal traces
- * retain the transition record.
- */
-const INTERMEDIATE_INTERNAL_IDS = new Set([
-    progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_99_99,
-    progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_99,
-]);
 /**
  * Fan out a progress event to one or two registered callbacks, deduping
  * when both slots hold the same reference. Keeps the emission policy in a
  * single place shared by `emitProgress` (execute phase) and `emit` (wait
  * phase) — so consumers that wire the same callback at multiple levels
- * never see double-invocation. Intermediate internal markers are dropped
- * here so they never reach the consumer.
+ * never see double-invocation.
  */
 function fanOut(event, primary, secondary) {
-    if (INTERMEDIATE_INTERNAL_IDS.has(event.id))
-        return;
     if (primary)
         primary(event);
     if (secondary && secondary !== primary)
@@ -549,13 +533,6 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                 const inboundInitialWaitMs = isReplay
                     ? 0
                     : callbacks.inboundConstants.initialWaitMs;
-                // Track whether reconstruction already emitted the route's
-                // intermediate Push-success marker (299-99 / 199-99-99). When it has,
-                // skip re-emitting from the outbound branch below to avoid duplicates.
-                // This flag is only true when `this` response was created by
-                // trackTransaction() and the reconstructed stream already fired.
-                const alreadyReconstructed = universalTxResponse._eventsReconstructed === true;
-                let intermediateAlreadyEmitted = alreadyReconstructed;
                 // Build the base receipt directly from this response. Any per-call
                 // `tx.progressHook(cb)` already replayed buffered execute-phase events
                 // to `cb` via the progressHook setter — re-running trackTransaction
@@ -580,15 +557,6 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                             return;
                         fanOut(event, registeredProgressHook, ctx.progressHook);
                     };
-                    // Intermediate INFO marker — Push Chain tx confirmed, external/inbound
-                    // leg still pending. Per spec, R1 keeps 199-01 as terminal; R2/R3
-                    // reclassify Push success as intermediate. Skip when trackTransaction
-                    // (called above) already reconstructed the same marker via
-                    // reconstructR2/R3, otherwise the consumer sees 299-99 / 199-99-99
-                    // twice in their stream.
-                    if (hooks.intermediatePushOk && !intermediateAlreadyEmitted) {
-                        emit(hooks.intermediatePushOk(targetChain, tx.hash));
-                    }
                     // Awaiting relay
                     emit(hooks.awaiting(targetChain));
                     let lastEmittedStatus;

package/src/lib/orchestrator/internals/tx-transformer.js

@@ -160,11 +160,6 @@ function reconstructR2(universalTxResponse, universalTxData, isFailed, errorMsg)
     if (isFailed) {
         events.push(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_02](errorMsg));
     }
-    else {
-        // Push Chain success is intermediate for R2 — the wait() outbound poll
-        // appends the real terminal (299-01/02/03) once the external leg resolves.
-        events.push(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_99](targetChain, universalTxResponse.hash));
-    }
     return events;
 }
 function reconstructR3(universalTxResponse, universalTxData, isFailed, errorMsg) {
@@ -190,11 +185,6 @@ function reconstructR3(universalTxResponse, universalTxData, isFailed, errorMsg)
         // "Push Chain Tx Failed" rather than the inbound copy.
         events.push(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](errorMsg, 'push'));
     }
-    else {
-        // Push Chain success is intermediate for R3 — wait() drives the source-chain
-        // CEA poll (309-xx) and the inbound-to-Push poll (310-xx / 399-xx) on top.
-        events.push(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_99_99](universalTxResponse.hash));
-    }
     return events;
 }
 // ============================================================================
@@ -315,7 +305,7 @@ function reconstructMultichain(universalTxResponse, universalTxData, isFailed, e
     let failedAt = null;
     let failureMsg = errorMsg;
     outbounds.forEach((ob, i) => {
-        var _a;
+        var _a, _b;
         const hopNum = i + 1;
         const fromChain = i === 0 ? sourceChain : outbounds[i - 1].destinationChain;
         const toChain = ob.destinationChain;
@@ -336,6 +326,12 @@ function reconstructMultichain(universalTxResponse, universalTxData, isFailed, e
             events.push(...reconstructR2(legResponse, legData, legFailed, legError));
         }
         if (!legFailed) {
+            if (hopNum < hopCount) {
+                const txHash = ((_b = ob.observedTx) === null || _b === void 0 ? void 0 : _b.txHash) || legResponse.hash;
+                events.push(isR3Leg
+                    ? progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_99](toChain, txHash)
+                    : progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_99](toChain, txHash));
+            }
             events.push(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_002_99_99](hopNum, hopCount));
         }
         else if (failedAt === null) {

package/src/lib/orchestrator/orchestrator.types.d.ts

@@ -639,6 +639,8 @@ export interface CascadedTxResponse {
     hops: CascadeHopInfo[];
     /** Total number of hops in the cascade */
     hopCount: number;
+    /** Final tx hash resolved by waitForAll()/wait(), when available */
+    finalTxHash?: string;
     /** Wait for ALL hops to complete across all chains */
     waitForAll: (opts?: CascadeTrackOptions) => Promise<CascadeCompletionResult>;
     /** Convenience alias for waitForAll() */
@@ -713,6 +715,10 @@ export interface CascadeCompletionResult {
     success: boolean;
     /** Final state of all hops */
     hops: CascadeHopInfo[];
+    /** Final tx hash for the last confirmed hop, when available */
+    finalTxHash?: string;
+    /** Original cascaded response object for consumers that need the full context */
+    finalTxResponse?: CascadedTxResponse;
     /** Index of first failed hop (if any) */
     failedAt?: number;
 }

package/src/lib/progress-hook/progress-hook.js

@@ -273,6 +273,20 @@ const RAW_HOOKS_R1 = {
             level: 'ERROR',
         };
     },
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_03]: (targetChain, elapsedMs) => ({
+        id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_03,
+        title: `Syncing State with ${friendlyChain(targetChain)} Timeout`,
+        message: `Timed out waiting for UGPC relay to ${targetChain}`,
+        response: { error: 'relay timeout', chain: targetChain, elapsedMs },
+        level: 'ERROR',
+    }),
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_99]: (txHash) => ({
+        id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_99,
+        title: 'Push Chain Tx Completed',
+        message: `Intermediate Push Chain tx confirmed: ${txHash}, progressing to next phase`,
+        response: { txHash },
+        level: 'INFO',
+    }),
 };
 // =============================================================================
 // Route 2 — UEA → UGPC → CEA on target chain (201–299, signature-only)
@@ -467,13 +481,6 @@ const RAW_HOOKS_R2 = {
 // Route 3 — UEA → UGPC → CEA → sendUniversalTxToUEA → Push Chain (301–399)
 // =============================================================================
 const RAW_HOOKS_R3 = {
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_99_99]: (txHash) => ({
-        id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_99_99,
-        title: 'Push Chain Tx Completed',
-        message: `Intermediate Push Chain tx confirmed: ${txHash}, progressing to next phase`,
-        response: { txHash },
-        level: 'INFO',
-    }),
     [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_301]: (sourceChain, ceaAddress) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_301,
         title: `${friendlyChain(sourceChain)}'s Executor Account Detected`,
@@ -727,6 +734,13 @@ const RAW_HOOKS_R3 = {
         },
         level: 'ERROR',
     }),
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_99]: (sourceChain, txHash) => ({
+        id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_99,
+        title: `${friendlyChain(sourceChain)} Tx Completed`,
+        message: `Intermediate ${friendlyChain(sourceChain)} tx confirmed: ${txHash}, progressing to next phase`,
+        response: { chain: sourceChain, txHash },
+        level: 'INFO',
+    }),
 };
 // =============================================================================
 // UEA Migration hooks (unchanged)

package/src/lib/progress-hook/progress-hook.types.d.ts

@@ -40,7 +40,8 @@ export declare enum PROGRESS_HOOK {
     SEND_TX_107 = "SEND-TX-107",
     SEND_TX_199_01 = "SEND-TX-199-01",// R1 terminal Push success
     SEND_TX_199_02 = "SEND-TX-199-02",// R1 terminal Push failure
-    SEND_TX_199_99_99 = "SEND-TX-199-99-99",// R3 intermediate Push success
+    SEND_TX_199_03 = "SEND-TX-199-03",
+    SEND_TX_199_99 = "SEND-TX-199-99",// R1 multihop intermediate Push success
     SEND_TX_201 = "SEND-TX-201",
     SEND_TX_202_01 = "SEND-TX-202-01",
     SEND_TX_202_02 = "SEND-TX-202-02",
@@ -84,6 +85,7 @@ export declare enum PROGRESS_HOOK {
     SEND_TX_399_01 = "SEND-TX-399-01",
     SEND_TX_399_02 = "SEND-TX-399-02",
     SEND_TX_399_03 = "SEND-TX-399-03",
+    SEND_TX_399_99 = "SEND-TX-399-99",// R3 multihop intermediate round-trip success
     SEND_TX_001 = "SEND-TX-001",
     SEND_TX_002_01 = "SEND-TX-002-01",
     SEND_TX_002_99_99 = "SEND-TX-002-99-99",
@@ -100,9 +102,9 @@ export declare enum PROGRESS_HOOK {
     UEA_MIG_9902 = "UEA-MIG-9902",
     UEA_MIG_9903 = "UEA-MIG-9903"
 }
-export type PROGRESS_HOOK_R1 = PROGRESS_HOOK.SEND_TX_101 | PROGRESS_HOOK.SEND_TX_102_01 | PROGRESS_HOOK.SEND_TX_103_01 | PROGRESS_HOOK.SEND_TX_103_02 | PROGRESS_HOOK.SEND_TX_103_03 | PROGRESS_HOOK.SEND_TX_103_03_01 | PROGRESS_HOOK.SEND_TX_103_03_02 | PROGRESS_HOOK.SEND_TX_103_03_03 | PROGRESS_HOOK.SEND_TX_103_03_04 | PROGRESS_HOOK.SEND_TX_104_01 | PROGRESS_HOOK.SEND_TX_104_02 | PROGRESS_HOOK.SEND_TX_104_03 | PROGRESS_HOOK.SEND_TX_104_04 | PROGRESS_HOOK.SEND_TX_105_01 | PROGRESS_HOOK.SEND_TX_105_02 | PROGRESS_HOOK.SEND_TX_106_01 | PROGRESS_HOOK.SEND_TX_106_02 | PROGRESS_HOOK.SEND_TX_106_03 | PROGRESS_HOOK.SEND_TX_106_03_01 | PROGRESS_HOOK.SEND_TX_106_03_02 | PROGRESS_HOOK.SEND_TX_106_04 | PROGRESS_HOOK.SEND_TX_106_05 | PROGRESS_HOOK.SEND_TX_106_06 | PROGRESS_HOOK.SEND_TX_107 | PROGRESS_HOOK.SEND_TX_199_01 | PROGRESS_HOOK.SEND_TX_199_02;
+export type PROGRESS_HOOK_R1 = PROGRESS_HOOK.SEND_TX_101 | PROGRESS_HOOK.SEND_TX_102_01 | PROGRESS_HOOK.SEND_TX_103_01 | PROGRESS_HOOK.SEND_TX_103_02 | PROGRESS_HOOK.SEND_TX_103_03 | PROGRESS_HOOK.SEND_TX_103_03_01 | PROGRESS_HOOK.SEND_TX_103_03_02 | PROGRESS_HOOK.SEND_TX_103_03_03 | PROGRESS_HOOK.SEND_TX_103_03_04 | PROGRESS_HOOK.SEND_TX_104_01 | PROGRESS_HOOK.SEND_TX_104_02 | PROGRESS_HOOK.SEND_TX_104_03 | PROGRESS_HOOK.SEND_TX_104_04 | PROGRESS_HOOK.SEND_TX_105_01 | PROGRESS_HOOK.SEND_TX_105_02 | PROGRESS_HOOK.SEND_TX_106_01 | PROGRESS_HOOK.SEND_TX_106_02 | PROGRESS_HOOK.SEND_TX_106_03 | PROGRESS_HOOK.SEND_TX_106_03_01 | PROGRESS_HOOK.SEND_TX_106_03_02 | PROGRESS_HOOK.SEND_TX_106_04 | PROGRESS_HOOK.SEND_TX_106_05 | PROGRESS_HOOK.SEND_TX_106_06 | PROGRESS_HOOK.SEND_TX_107 | PROGRESS_HOOK.SEND_TX_199_01 | PROGRESS_HOOK.SEND_TX_199_02 | PROGRESS_HOOK.SEND_TX_199_03 | PROGRESS_HOOK.SEND_TX_199_99;
 export type PROGRESS_HOOK_R2 = PROGRESS_HOOK.SEND_TX_201 | PROGRESS_HOOK.SEND_TX_202_01 | PROGRESS_HOOK.SEND_TX_202_02 | PROGRESS_HOOK.SEND_TX_203_01 | PROGRESS_HOOK.SEND_TX_203_02 | PROGRESS_HOOK.SEND_TX_203_03 | PROGRESS_HOOK.SEND_TX_203_04 | PROGRESS_HOOK.SEND_TX_203_05 | PROGRESS_HOOK.SEND_TX_204_01 | PROGRESS_HOOK.SEND_TX_204_02 | PROGRESS_HOOK.SEND_TX_204_03 | PROGRESS_HOOK.SEND_TX_204_04 | PROGRESS_HOOK.SEND_TX_207 | PROGRESS_HOOK.SEND_TX_209_01 | PROGRESS_HOOK.SEND_TX_209_02 | PROGRESS_HOOK.SEND_TX_299_01 | PROGRESS_HOOK.SEND_TX_299_02 | PROGRESS_HOOK.SEND_TX_299_03 | PROGRESS_HOOK.SEND_TX_299_99;
-export type PROGRESS_HOOK_R3 = PROGRESS_HOOK.SEND_TX_199_99_99 | PROGRESS_HOOK.SEND_TX_301 | PROGRESS_HOOK.SEND_TX_302_01 | PROGRESS_HOOK.SEND_TX_302_02 | PROGRESS_HOOK.SEND_TX_303_01 | PROGRESS_HOOK.SEND_TX_303_02 | PROGRESS_HOOK.SEND_TX_303_03_01 | PROGRESS_HOOK.SEND_TX_303_03_02 | PROGRESS_HOOK.SEND_TX_303_03_03 | PROGRESS_HOOK.SEND_TX_303_04 | PROGRESS_HOOK.SEND_TX_303_05 | PROGRESS_HOOK.SEND_TX_303_06 | PROGRESS_HOOK.SEND_TX_304_01 | PROGRESS_HOOK.SEND_TX_304_02 | PROGRESS_HOOK.SEND_TX_304_03 | PROGRESS_HOOK.SEND_TX_304_04 | PROGRESS_HOOK.SEND_TX_307 | PROGRESS_HOOK.SEND_TX_309_01 | PROGRESS_HOOK.SEND_TX_309_02 | PROGRESS_HOOK.SEND_TX_309_03 | PROGRESS_HOOK.SEND_TX_310_01 | PROGRESS_HOOK.SEND_TX_310_02 | PROGRESS_HOOK.SEND_TX_399_01 | PROGRESS_HOOK.SEND_TX_399_02 | PROGRESS_HOOK.SEND_TX_399_03;
+export type PROGRESS_HOOK_R3 = PROGRESS_HOOK.SEND_TX_301 | PROGRESS_HOOK.SEND_TX_302_01 | PROGRESS_HOOK.SEND_TX_302_02 | PROGRESS_HOOK.SEND_TX_303_01 | PROGRESS_HOOK.SEND_TX_303_02 | PROGRESS_HOOK.SEND_TX_303_03_01 | PROGRESS_HOOK.SEND_TX_303_03_02 | PROGRESS_HOOK.SEND_TX_303_03_03 | PROGRESS_HOOK.SEND_TX_303_04 | PROGRESS_HOOK.SEND_TX_303_05 | PROGRESS_HOOK.SEND_TX_303_06 | PROGRESS_HOOK.SEND_TX_304_01 | PROGRESS_HOOK.SEND_TX_304_02 | PROGRESS_HOOK.SEND_TX_304_03 | PROGRESS_HOOK.SEND_TX_304_04 | PROGRESS_HOOK.SEND_TX_307 | PROGRESS_HOOK.SEND_TX_309_01 | PROGRESS_HOOK.SEND_TX_309_02 | PROGRESS_HOOK.SEND_TX_309_03 | PROGRESS_HOOK.SEND_TX_310_01 | PROGRESS_HOOK.SEND_TX_310_02 | PROGRESS_HOOK.SEND_TX_399_01 | PROGRESS_HOOK.SEND_TX_399_02 | PROGRESS_HOOK.SEND_TX_399_03 | PROGRESS_HOOK.SEND_TX_399_99;
 export type PROGRESS_HOOK_MULTICHAIN = PROGRESS_HOOK.SEND_TX_001 | PROGRESS_HOOK.SEND_TX_002_01 | PROGRESS_HOOK.SEND_TX_002_99_99 | PROGRESS_HOOK.SEND_TX_003_03 | PROGRESS_HOOK.SEND_TX_003_04 | PROGRESS_HOOK.SEND_TX_003_05 | PROGRESS_HOOK.SEND_TX_999_01 | PROGRESS_HOOK.SEND_TX_999_02 | PROGRESS_HOOK.SEND_TX_999_03;
 export type PROGRESS_HOOK_MIG = PROGRESS_HOOK.UEA_MIG_01 | PROGRESS_HOOK.UEA_MIG_02 | PROGRESS_HOOK.UEA_MIG_03 | PROGRESS_HOOK.UEA_MIG_9901 | PROGRESS_HOOK.UEA_MIG_9902 | PROGRESS_HOOK.UEA_MIG_9903;
 export {};

package/src/lib/progress-hook/progress-hook.types.js

@@ -30,7 +30,8 @@ var PROGRESS_HOOK;
     PROGRESS_HOOK["SEND_TX_107"] = "SEND-TX-107";
     PROGRESS_HOOK["SEND_TX_199_01"] = "SEND-TX-199-01";
     PROGRESS_HOOK["SEND_TX_199_02"] = "SEND-TX-199-02";
-    PROGRESS_HOOK["SEND_TX_199_99_99"] = "SEND-TX-199-99-99";
+    PROGRESS_HOOK["SEND_TX_199_03"] = "SEND-TX-199-03";
+    PROGRESS_HOOK["SEND_TX_199_99"] = "SEND-TX-199-99";
     // Route 2: UEA → UGPC → CEA on target chain (201–299)
     PROGRESS_HOOK["SEND_TX_201"] = "SEND-TX-201";
     PROGRESS_HOOK["SEND_TX_202_01"] = "SEND-TX-202-01";
@@ -86,6 +87,7 @@ var PROGRESS_HOOK;
     PROGRESS_HOOK["SEND_TX_399_01"] = "SEND-TX-399-01";
     PROGRESS_HOOK["SEND_TX_399_02"] = "SEND-TX-399-02";
     PROGRESS_HOOK["SEND_TX_399_03"] = "SEND-TX-399-03";
+    PROGRESS_HOOK["SEND_TX_399_99"] = "SEND-TX-399-99";
     // Multichain (multi-hop) cascade markers
     PROGRESS_HOOK["SEND_TX_001"] = "SEND-TX-001";
     PROGRESS_HOOK["SEND_TX_002_01"] = "SEND-TX-002-01";