@pushchain/core 5.1.5-alpha.0 → 5.1.5

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

@@ -16,6 +16,8 @@ const viem_1 = require("viem");
 const uea_evm_1 = require("../../constants/abi/uea.evm");
 const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
+const progress_hook_types_1 = require("../../progress-hook/progress-hook.types");
+const progress_hook_1 = tslib_1.__importDefault(require("../../progress-hook/progress-hook"));
 const account_1 = require("../../universal/account/account");
 const push_client_1 = require("../../push-client/push-client");
 const route_detector_1 = require("../route-detector");
@@ -23,7 +25,39 @@ const context_1 = require("./context");
 const helpers_1 = require("./helpers");
 const svm_helpers_1 = require("./svm-helpers");
 const outbound_tracker_1 = require("./outbound-tracker");
+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.
+ */
+function fanOut(event, primary, secondary) {
+    if (INTERMEDIATE_INTERNAL_IDS.has(event.id))
+        return;
+    if (primary)
+        primary(event);
+    if (secondary && secondary !== primary)
+        secondary(event);
+}
 // ============================================================================
 // queryUniversalTxStatusFromGatewayTx
 // ============================================================================
@@ -105,8 +139,8 @@ txHash, evmGatewayMethod) {
             }, null, 2));
             // Fetch UniversalTx via gRPC with linear-then-exponential retry
             const LINEAR_ATTEMPTS = 10;
-            const LINEAR_DELAY_MS = 3000;
-            const EXPONENTIAL_BASE_MS = 4000;
+            const LINEAR_DELAY_MS = 3600;
+            const EXPONENTIAL_BASE_MS = 4800;
             const MAX_ATTEMPTS = 15;
             let universalTxObj;
             for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
@@ -146,6 +180,7 @@ txHash, evmGatewayMethod) {
 // ============================================================================
 function trackTransaction(ctx, txHash, options, callbacks) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
         if (!callbacks) {
             throw new Error('trackTransaction requires ResponseBuilderCallbacks');
         }
@@ -153,18 +188,13 @@ function trackTransaction(ctx, txHash, options, callbacks) {
         const { timeout = 300000, pollingIntervalMs = 1000, rpcUrls = {} } = advanced;
         // Event buffer for replay via response.progressHook()
         const eventBuffer = [];
-        // Helper to emit progress events
+        // Helper to emit progress events. Per-tx hook (passed to trackTransaction)
+        // fires first, then the orchestrator-level hook — deduped via `fanOut` so
+        // a caller that wires the same callback at both levels isn't double-fired.
         const emitProgress = (event) => {
             eventBuffer.push(event);
             (0, context_1.printLog)(ctx, event.message);
-            // Per-transaction hook called FIRST
-            if (progressHook) {
-                progressHook(event);
-            }
-            // Orchestrator-level hook called SECOND
-            if (ctx.progressHook) {
-                ctx.progressHook(event);
-            }
+            fanOut(event, progressHook, ctx.progressHook);
         };
         // Create client for target chain with optional RPC override
         const chainRPCs = rpcUrls[chain] || ctx.rpcUrls[chain] || chain_1.CHAIN_INFO[chain].defaultRPC;
@@ -203,7 +233,7 @@ function trackTransaction(ctx, txHash, options, callbacks) {
                 universalTxData = utxResponse.universalTx;
             }
         }
-        catch (_a) {
+        catch (_c) {
             // Ignore - try computed ID next
         }
         if (!universalTxData) {
@@ -215,7 +245,7 @@ function trackTransaction(ctx, txHash, options, callbacks) {
                     universalTxData = utxResponse.universalTx;
                 }
             }
-            catch (_b) {
+            catch (_d) {
                 // Ignore - try Cosmos event extraction next
             }
         }
@@ -230,7 +260,7 @@ function trackTransaction(ctx, txHash, options, callbacks) {
                     }
                 }
             }
-            catch (_c) {
+            catch (_e) {
                 // Ignore - no universal tx data available
             }
         }
@@ -241,12 +271,48 @@ function trackTransaction(ctx, txHash, options, callbacks) {
         const detectedRoute = (0, tx_transformer_1.detectRouteFromUniversalTxData)(universalTxData);
         if (detectedRoute) {
             universalTxResponse.route = detectedRoute;
+            // Mirror the route on the context so emission code in wait()/cascade
+            // picks the correct ID range — keeps trackTransaction in lockstep with
+            // sendUniversalTransaction, which sets currentRoute in execute().
+            ctx.currentRoute = detectedRoute;
+            // Populate the destination/source chain on the response so
+            // reconstructR2/R3 (and any downstream emission that reads
+            // universalTxResponse.chain) emit the proper friendly chain name
+            // instead of the "external" fallback. The first outbound's destination
+            // is the target chain for R2 and the source CEA chain for R3.
+            const firstOutboundChain = (_b = (_a = universalTxData === null || universalTxData === void 0 ? void 0 : universalTxData.outboundTx) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.destinationChain;
+            if (firstOutboundChain && !universalTxResponse.chain) {
+                universalTxResponse.chain = firstOutboundChain;
+                universalTxResponse.chainNamespace = firstOutboundChain;
+            }
+            // For R3 replays, enable inbound round-trip tracking so `.wait()` runs
+            // the 310-01 → 399-01 sequence. Live execute sets this in
+            // route-handlers.ts via `amount > 0n`; trackTransaction has no
+            // execute-phase args, so we enable it unconditionally for CEA_TO_PUSH.
+            // The inbound block tolerates no-inbound (payload-only R3) by timing
+            // out — same as live behaviour when the source tx has no round-trip.
+            if (detectedRoute === route_detector_1.TransactionRoute.CEA_TO_PUSH) {
+                universalTxResponse._expectsInboundRoundTrip = true;
+            }
         }
         // Reconstruct and emit SEND-TX-* progress events
         const reconstructedEvents = (0, tx_transformer_1.reconstructProgressEvents)(universalTxResponse, universalTxData);
         for (const event of reconstructedEvents) {
             emitProgress(event);
         }
+        // Mark the response so the wait() closure (when later invoked) doesn't
+        // call trackTransaction a second time and re-emit the same reconstructed
+        // events to the user's progressHook.
+        universalTxResponse._eventsReconstructed = true;
+        // Auto-register the caller's per-call progressHook as the response's
+        // registeredProgressHook so that tracked.wait() fires wait-phase events
+        // (209-xx / 299-xx / 399-xx) to the same callback without requiring
+        // tracked.progressHook(cb) to be called again. Skip replay of buffered
+        // events because we just fired them above via emitProgress — calling
+        // response.progressHook(cb) here would re-emit the reconstructed stream.
+        if (progressHook && universalTxResponse._setProgressHookNoReplay) {
+            universalTxResponse._setProgressHookNoReplay(progressHook);
+        }
         return universalTxResponse;
     });
 }
@@ -278,18 +344,36 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
             }
             from = (0, viem_1.getAddress)(tx.to);
             let decoded;
+            let decodedPayload = null;
             if (tx.input !== '0x') {
-                decoded = (0, viem_1.decodeFunctionData)({
-                    abi: uea_evm_1.UEA_EVM,
-                    data: tx.input,
-                });
-                if (!(decoded === null || decoded === void 0 ? void 0 : decoded.args)) {
-                    throw new Error('Failed to decode function data');
+                // Try to decode the input as a known UEA_EVM call. Older txs — or
+                // txs sent to a UEA that was upgraded to expose a function not yet
+                // reflected in the bundled `uea.evm.ts` ABI — carry a selector that
+                // viem can't match. In that case the reconstructor should still
+                // produce a usable response (and emit progress hooks) using the raw
+                // tx fields, rather than throwing before any hook fires.
+                try {
+                    decoded = (0, viem_1.decodeFunctionData)({ abi: uea_evm_1.UEA_EVM, data: tx.input });
+                    if (decoded === null || decoded === void 0 ? void 0 : decoded.args) {
+                        decodedPayload = decoded.args[0];
+                    }
+                }
+                catch (_a) {
+                    decodedPayload = null;
+                }
+                if (decodedPayload) {
+                    to = decodedPayload.to;
+                    value = BigInt(decodedPayload.value);
+                    data = decodedPayload.data;
+                }
+                else {
+                    // Unknown / unsupported UEA function — fall back to raw fields so
+                    // transformToUniversalTxResponse can still return a valid response
+                    // and downstream progress-hook reconstruction can proceed.
+                    to = (0, viem_1.getAddress)(tx.to);
+                    value = tx.value;
+                    data = tx.input;
                 }
-                const universalPayload = decoded === null || decoded === void 0 ? void 0 : decoded.args[0];
-                to = universalPayload.to;
-                value = BigInt(universalPayload.value);
-                data = universalPayload.data;
                 // Extract 'to' from single-element multicall
                 if (data && data.length >= 10) {
                     const multicallSelector = (0, viem_1.keccak256)((0, viem_1.toBytes)('UEA_MULTICALL')).slice(0, 10);
@@ -311,7 +395,7 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                                 to = (0, viem_1.getAddress)(decodedCalls[0].to);
                             }
                         }
-                        catch (_a) {
+                        catch (_b) {
                             // Keep original 'to' if decoding fails
                         }
                     }
@@ -379,7 +463,7 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                         from = '0x0000000000000000000000000000000000000000';
                     }
                 }
-                catch (_b) {
+                catch (_c) {
                     // Keep original values if decoding fails
                 }
             }
@@ -395,7 +479,7 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                 yParity: tx.yParity,
             };
         }
-        catch (_c) {
+        catch (_d) {
             // Fallback signature if parsing fails
             signature = {
                 r: '0x0000000000000000000000000000000000000000000000000000000000000000',
@@ -451,44 +535,159 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
             maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
             accessList: Array.isArray(tx.accessList) ? [...tx.accessList] : [],
             // 6. Utilities
-            wait: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                // Use trackTransaction with registered hook if available
-                let baseReceipt;
-                if (registeredProgressHook) {
-                    const trackedResponse = yield callbacks.trackTransaction(tx.hash, {
-                        waitForCompletion: true,
-                        progressHook: registeredProgressHook,
-                    });
-                    // Get receipt from the tracked response
-                    const receipt = yield tx.wait();
-                    baseReceipt = callbacks.transformToUniversalTxReceipt(receipt, trackedResponse);
-                }
-                else {
-                    const receipt = yield tx.wait();
-                    baseReceipt = callbacks.transformToUniversalTxReceipt(receipt, universalTxResponse);
-                }
+            wait: (waitOptions) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f;
+                // For trackTransaction replays the tx is historical — cosmos already
+                // has the full graph indexed, so the 20s/30s initial-wait buffers
+                // designed for live sends are pure deadweight. Default them to 0 when
+                // replaying; callers can still override via WaitOptions.
+                const isReplay = universalTxResponse._eventsReconstructed === true;
+                const outboundTimeoutMs = (_a = waitOptions === null || waitOptions === void 0 ? void 0 : waitOptions.outboundTimeoutMs) !== null && _a !== void 0 ? _a : callbacks.outboundConstants.maxTimeoutMs;
+                const inboundTimeoutMs = (_b = waitOptions === null || waitOptions === void 0 ? void 0 : waitOptions.inboundTimeoutMs) !== null && _b !== void 0 ? _b : callbacks.inboundConstants.maxTimeoutMs;
+                const outboundInitialWaitMs = (_c = waitOptions === null || waitOptions === void 0 ? void 0 : waitOptions.outboundInitialWaitMs) !== null && _c !== void 0 ? _c : (isReplay ? 0 : callbacks.outboundConstants.initialWaitMs);
+                const outboundPollingIntervalMs = (_d = waitOptions === null || waitOptions === void 0 ? void 0 : waitOptions.outboundPollingIntervalMs) !== null && _d !== void 0 ? _d : callbacks.outboundConstants.pollingIntervalMs;
+                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
+                // here would duplicate the reconstructed stream on top of that replay,
+                // which is exactly what broke R1 parity. Wait-phase events (209-xx /
+                // 299-xx / 399-xx) still reach `registeredProgressHook` and
+                // `ctx.progressHook` via the `emit` closure in the outbound branch.
+                const receipt = yield tx.wait();
+                let baseReceipt = callbacks.transformToUniversalTxReceipt(receipt, universalTxResponse);
                 // If outbound route, poll for external chain details
-                const routeInfo = universalTxResponse.route
-                    ? (0, route_detector_1.getRouteInfo)(universalTxResponse.route)
-                    : undefined;
+                const route = universalTxResponse.route;
+                const routeInfo = route ? (0, route_detector_1.getRouteInfo)(route) : undefined;
                 if (routeInfo === null || routeInfo === void 0 ? void 0 : routeInfo.isOutbound) {
+                    // Pick route-specific hook builders. R4 (CEA_TO_CEA) currently has
+                    // no spec'd IDs — pickWaitHooks returns a no-op set that yields
+                    // events with `id: ''`. `emit` drops those so the consumer never
+                    // sees placeholder events, while receipt mutation still runs.
+                    const hooks = (0, progress_route_hooks_1.pickWaitHooks)(route);
+                    const targetChain = ((_e = universalTxResponse.chain) !== null && _e !== void 0 ? _e : 'external');
+                    const emit = (event) => {
+                        if (!event.id)
+                            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;
+                    const outboundTranslator = (event) => {
+                        if (event.status === 'polling' && lastEmittedStatus !== 'polling') {
+                            lastEmittedStatus = 'polling';
+                            emit(hooks.polling(targetChain, event.elapsed));
+                        }
+                    };
                     try {
                         const outboundDetails = yield callbacks.waitForOutboundTx(tx.hash, {
-                            initialWaitMs: callbacks.outboundConstants.initialWaitMs,
-                            pollingIntervalMs: callbacks.outboundConstants.pollingIntervalMs,
-                            timeout: callbacks.outboundConstants.maxTimeoutMs,
+                            initialWaitMs: outboundInitialWaitMs,
+                            pollingIntervalMs: outboundPollingIntervalMs,
+                            timeout: outboundTimeoutMs,
+                            progressHook: outboundTranslator,
                         });
+                        emit(hooks.success(outboundDetails));
                         // Merge external chain details into receipt
-                        baseReceipt = Object.assign(Object.assign({}, baseReceipt), { externalTxHash: outboundDetails.externalTxHash, externalChain: outboundDetails.destinationChain, externalExplorerUrl: outboundDetails.explorerUrl, externalRecipient: outboundDetails.recipient, externalAmount: outboundDetails.amount, externalAssetAddr: outboundDetails.assetAddr });
+                        baseReceipt = Object.assign(Object.assign({}, baseReceipt), { externalTxHash: outboundDetails.externalTxHash, externalChain: outboundDetails.destinationChain, externalExplorerUrl: outboundDetails.explorerUrl, externalRecipient: outboundDetails.recipient, externalAmount: outboundDetails.amount, externalAssetAddr: outboundDetails.assetAddr, externalStatus: 'success' });
+                        // R3 round-trip: poll Push Chain for the inbound tx that the
+                        // source-chain CEA's sendUniversalTxToUEA call produces. Correlate
+                        // via the outbound external tx hash → child UTX id → child pcTx.
+                        // Only run when the CEA payload actually fires sendUniversalTxToUEA;
+                        // payload-only R3 (no funds flowing back) has no child UTX and would
+                        // otherwise time out after 300s.
+                        if (route === route_detector_1.TransactionRoute.CEA_TO_PUSH &&
+                            universalTxResponse._expectsInboundRoundTrip === true) {
+                            emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_01](targetChain));
+                            let inboundLastEmitted;
+                            try {
+                                const inbound = yield (0, inbound_tracker_1.waitForInboundPushTx)(ctx, outboundDetails.externalTxHash, targetChain, {
+                                    initialWaitMs: inboundInitialWaitMs,
+                                    pollingIntervalMs: callbacks.inboundConstants.pollingIntervalMs,
+                                    timeout: inboundTimeoutMs,
+                                    progressHook: (event) => {
+                                        if (event.status === 'polling' &&
+                                            inboundLastEmitted !== 'polling') {
+                                            inboundLastEmitted = 'polling';
+                                            emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_02](targetChain, event.elapsedMs));
+                                        }
+                                    },
+                                });
+                                if (inbound.status === 'confirmed') {
+                                    emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_01](targetChain, inbound.pushTxHash, baseReceipt));
+                                    baseReceipt = Object.assign(Object.assign({}, baseReceipt), { pushInboundTxHash: inbound.pushTxHash, pushInboundUtxId: inbound.childUtxId });
+                                }
+                                else {
+                                    // status === 'failed' (terminal failure status from chain)
+                                    const failMsg = (_f = inbound.errorMessage) !== null && _f !== void 0 ? _f : 'inbound execution failed on Push Chain';
+                                    emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](failMsg, 'inbound', targetChain));
+                                    baseReceipt = Object.assign(Object.assign({}, baseReceipt), { pushInboundUtxId: inbound.childUtxId, pushInboundTxHash: inbound.pushTxHash || undefined, externalStatus: 'failed', externalError: failMsg });
+                                }
+                            }
+                            catch (inboundErr) {
+                                const errMsg = inboundErr instanceof Error
+                                    ? inboundErr.message
+                                    : String(inboundErr);
+                                const isTimeout = inboundErr instanceof inbound_tracker_1.InboundTimeoutError;
+                                // Annotate receipt for inbound-leg outcome too.
+                                baseReceipt = Object.assign(Object.assign({}, baseReceipt), { externalStatus: isTimeout ? 'timeout' : 'failed', externalError: errMsg });
+                                emit(isTimeout
+                                    ? progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_03](targetChain, inboundTimeoutMs, 'inbound')
+                                    : progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](errMsg, 'inbound', targetChain));
+                                callbacks.printLog(`[wait] R3 inbound tracking failed: ${errMsg}`);
+                            }
+                        }
                     }
                     catch (error) {
-                        // Outbound polling timed out - return partial receipt (don't throw)
-                        // Push Chain tx succeeded, external tracking can be retried later
-                        callbacks.printLog(`[wait] External chain tracking failed: ${error instanceof Error ? error.message : String(error)}`);
+                        const errMsg = error instanceof Error ? error.message : String(error);
+                        const isTimeout = error instanceof outbound_sync_1.OutboundTimeoutError;
+                        emit(isTimeout
+                            ? hooks.timeout(targetChain, outboundTimeoutMs)
+                            : hooks.failed(targetChain, errMsg));
+                        // Annotate the receipt so callers can distinguish external-leg
+                        // outcomes without sniffing errMsg. Push Chain leg still succeeded
+                        // (status stays 1); inspect `externalStatus` / `externalError` for
+                        // the external/inbound leg outcome. On a reverted outbound the
+                        // observed tx hash is carried by OutboundFailedError — expose it
+                        // as externalTxHash so consumers can link to the explorer.
+                        const failedExternalTxHash = error instanceof outbound_sync_1.OutboundFailedError ? error.externalTxHash : undefined;
+                        baseReceipt = Object.assign(Object.assign(Object.assign({}, baseReceipt), { externalStatus: isTimeout ? 'timeout' : 'failed', externalError: errMsg }), (failedExternalTxHash
+                            ? { externalTxHash: failedExternalTxHash }
+                            : {}));
+                        // Outbound polling timed out or failed — return the annotated
+                        // receipt without throwing. Push Chain tx succeeded, external
+                        // tracking can be retried later.
+                        callbacks.printLog(`[wait] External chain tracking ${isTimeout ? 'timed out' : 'failed'}: ${errMsg}`);
                     }
                 }
                 return baseReceipt;
             }),
+            // Internal: register a wait-phase progressHook without replaying
+            // buffered events. Used by trackTransaction() after it has already
+            // emitted the reconstructed stream to the caller's per-call hook,
+            // so that tracked.wait() can deliver wait-phase events (209-xx /
+            // 299-xx / 399-xx) to the same callback without duplicating replay.
+            _setProgressHookNoReplay: (callback) => {
+                registeredProgressHook = callback;
+            },
             progressHook: (callback) => {
                 registeredProgressHook = callback;
                 // Immediately replay buffered events from execution