@pushchain/core 6.0.20 → 6.0.21

package/src/lib/orchestrator/internals/outbound-sync.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OutboundFailedError = exports.OutboundTimeoutError = exports.INBOUND_INITIAL_WAIT_MS = exports.INBOUND_MAX_TIMEOUT_MS = exports.OUTBOUND_MAX_TIMEOUT_MS = exports.OUTBOUND_POLL_INTERVAL_MS = exports.OUTBOUND_INITIAL_WAIT_MS = void 0;
 exports.waitForOutboundTx = waitForOutboundTx;
 exports.waitForAllOutboundTxsV2 = waitForAllOutboundTxsV2;
-const tslib_1 = require("tslib");
+const tracking_1 = require("./pc20/tracking");
 const viem_1 = require("viem");
 const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
@@ -42,9 +42,11 @@ exports.INBOUND_INITIAL_WAIT_MS = 15000;
  * (→ 299-02) without resorting to error-message prefix matching.
  */
 class OutboundTimeoutError extends Error {
+    code = 'OUTBOUND_TIMEOUT';
+    pushChainTxHash;
+    elapsedMs;
     constructor(pushChainTxHash, elapsedMs, timeoutMs) {
         super(`Timeout waiting for outbound transaction. Push Chain TX: ${pushChainTxHash}. Timeout: ${timeoutMs}ms. The relay may still be processing.`);
-        this.code = 'OUTBOUND_TIMEOUT';
         this.name = 'OutboundTimeoutError';
         this.pushChainTxHash = pushChainTxHash;
         this.elapsedMs = elapsedMs;
@@ -57,9 +59,15 @@ exports.OutboundTimeoutError = OutboundTimeoutError;
  * a *failure* (→ 299-02) from a *timeout* (→ 299-03).
  */
 class OutboundFailedError extends Error {
+    code = 'OUTBOUND_FAILED';
+    pushChainTxHash;
+    destinationChain;
+    /** Observed tx hash on the destination chain (when available). Lets the
+     * receipt expose the reverted external tx so consumers can link to the
+     * explorer without parsing the error message. */
+    externalTxHash;
     constructor(message, pushChainTxHash, destinationChain, externalTxHash) {
         super(message);
-        this.code = 'OUTBOUND_FAILED';
         this.name = 'OutboundFailedError';
         this.pushChainTxHash = pushChainTxHash;
         this.destinationChain = destinationChain;
@@ -84,48 +92,45 @@ exports.OutboundFailedError = OutboundFailedError;
  *
  * EVM-only — SVM tiebreaker would need a separate signature lookup path.
  */
-function verifyExternalEvmReceipt(ctx, destinationChain, externalTxHash) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const chainInfo = chain_1.CHAIN_INFO[destinationChain];
-        if (!chainInfo || chainInfo.vm !== enums_1.VM.EVM) {
-            return 'unsupported';
-        }
-        // Guard against unit-test contexts that don't pass a real rpcUrls map —
-        // we'd otherwise hit live testnet RPC inside Jest.
-        if (!ctx.rpcUrls)
-            return 'unsupported';
-        const rpcUrls = ((_a = ctx.rpcUrls) === null || _a === void 0 ? void 0 : _a[destinationChain]) && ctx.rpcUrls[destinationChain].length > 0
-            ? ctx.rpcUrls[destinationChain]
-            : chainInfo.defaultRPC;
-        if (!(rpcUrls === null || rpcUrls === void 0 ? void 0 : rpcUrls.length))
-            return 'unsupported';
-        try {
-            const client = (0, viem_1.createPublicClient)({
-                transport: (0, viem_1.fallback)(rpcUrls.map((url) => (0, viem_1.http)(url))),
-            });
-            const receipt = yield client.getTransactionReceipt({
-                hash: externalTxHash,
-            });
-            if (!receipt)
-                return 'pending';
-            if (receipt.status === 'success')
-                return 'success';
-            if (receipt.status === 'reverted')
-                return 'reverted';
+async function verifyExternalEvmReceipt(ctx, destinationChain, externalTxHash) {
+    const chainInfo = chain_1.CHAIN_INFO[destinationChain];
+    if (!chainInfo || chainInfo.vm !== enums_1.VM.EVM) {
+        return 'unsupported';
+    }
+    // Guard against unit-test contexts that don't pass a real rpcUrls map —
+    // we'd otherwise hit live testnet RPC inside Jest.
+    if (!ctx.rpcUrls)
+        return 'unsupported';
+    const rpcUrls = ctx.rpcUrls?.[destinationChain] && ctx.rpcUrls[destinationChain].length > 0
+        ? ctx.rpcUrls[destinationChain]
+        : chainInfo.defaultRPC;
+    if (!rpcUrls?.length)
+        return 'unsupported';
+    try {
+        const client = (0, viem_1.createPublicClient)({
+            transport: (0, viem_1.fallback)(rpcUrls.map((url) => (0, viem_1.http)(url))),
+        });
+        const receipt = await client.getTransactionReceipt({
+            hash: externalTxHash,
+        });
+        if (!receipt)
             return 'pending';
-        }
-        catch (err) {
-            // viem throws TransactionReceiptNotFoundError when the tx isn't mined
-            // yet — treat as 'pending' rather than 'unsupported' so we keep polling.
-            const msg = err instanceof Error ? err.message : String(err);
-            if (/not found|TransactionReceiptNotFound|could not be found/i.test(msg)) {
-                return 'pending';
-            }
-            (0, context_1.printLog)(ctx, `[verifyExternalEvmReceipt] RPC error for ${destinationChain} tx ${externalTxHash}: ${msg}`);
+        if (receipt.status === 'success')
+            return 'success';
+        if (receipt.status === 'reverted')
+            return 'reverted';
+        return 'pending';
+    }
+    catch (err) {
+        // viem throws TransactionReceiptNotFoundError when the tx isn't mined
+        // yet — treat as 'pending' rather than 'unsupported' so we keep polling.
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/not found|TransactionReceiptNotFound|could not be found/i.test(msg)) {
             return 'pending';
         }
-    });
+        (0, context_1.printLog)(ctx, `[verifyExternalEvmReceipt] RPC error for ${destinationChain} tx ${externalTxHash}: ${msg}`);
+        return 'pending';
+    }
 }
 /**
  * Wait for outbound transaction to complete and return external chain details.
@@ -140,148 +145,370 @@ function verifyExternalEvmReceipt(ctx, destinationChain, externalTxHash) {
  * @returns External chain tx details
  * @throws Error on timeout
  */
-function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (ctx, pushChainTxHash, options = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
-        const { initialWaitMs = exports.OUTBOUND_INITIAL_WAIT_MS, pollingIntervalMs = exports.OUTBOUND_POLL_INTERVAL_MS, timeout = exports.OUTBOUND_MAX_TIMEOUT_MS, progressHook, _resolvedSubTxId, _expectedDestinationChain, _outboundIndex, } = options;
-        // Terminal failure states — fail fast instead of polling until timeout
-        const TERMINAL_FAILURE_STATES = new Set([
-            types_1.UniversalTxStatus.OUTBOUND_FAILED,
-            types_1.UniversalTxStatus.PC_EXECUTED_FAILED,
-            types_1.UniversalTxStatus.CANCELED,
-        ]);
-        const startTime = Date.now();
-        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Starting | txHash: ${pushChainTxHash} | initialWait: ${initialWaitMs}ms | pollInterval: ${pollingIntervalMs}ms | timeout: ${timeout}ms`);
-        progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'waiting', elapsed: 0 });
-        // Clamp the initial wait to the configured timeout so a short per-call
-        // `outboundTimeoutMs` (e.g. from `tx.wait({ outboundTimeoutMs })`) isn't
-        // blocked by the default 20s settle-time. Mirrors the equivalent
-        // Math.min(initialWaitMs, timeout) clamp in inbound-tracker.ts.
-        const effectiveInitialWaitMs = Math.min(initialWaitMs, timeout);
-        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Initial wait of ${effectiveInitialWaitMs}ms (configured: ${initialWaitMs}ms, clamped to timeout ${timeout}ms)...`);
-        yield new Promise((resolve) => setTimeout(resolve, effectiveInitialWaitMs));
-        // Fast-exit: if the clamped initial wait already consumed the full budget,
-        // skip the poll loop and go straight to the timeout throw below.
-        if (Date.now() - startTime >= timeout) {
-            const elapsedMs = Date.now() - startTime;
-            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Timeout reached during initial wait (elapsed: ${elapsedMs}ms / ${timeout}ms)`);
-            progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'timeout', elapsed: elapsedMs });
-            throw new OutboundTimeoutError(pushChainTxHash, elapsedMs, timeout);
-        }
-        // Start polling
-        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Initial wait done. Starting polling. Elapsed: ${Date.now() - startTime}ms`);
-        progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'polling', elapsed: Date.now() - startTime });
-        // Cache the universalSubTxId after first extraction to avoid redundant receipt fetches.
-        // If a pre-resolved ID was provided (cascade per-hop tracking), use it directly.
-        let cachedUniversalSubTxId = _resolvedSubTxId;
-        let pollCount = 0;
-        while (Date.now() - startTime < timeout) {
-            pollCount++;
-            const pollStart = Date.now();
-            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | Elapsed: ${pollStart - startTime}ms / ${timeout}ms`);
+async function waitForOutboundTx(ctx, pushChainTxHash, options = {}) {
+    const { initialWaitMs = exports.OUTBOUND_INITIAL_WAIT_MS, pollingIntervalMs = exports.OUTBOUND_POLL_INTERVAL_MS, timeout = exports.OUTBOUND_MAX_TIMEOUT_MS, progressHook, _resolvedSubTxId, _expectedDestinationChain, _outboundIndex, } = options;
+    // Terminal failure states — fail fast instead of polling until timeout
+    const TERMINAL_FAILURE_STATES = new Set([
+        types_1.UniversalTxStatus.OUTBOUND_FAILED,
+        types_1.UniversalTxStatus.PC_EXECUTED_FAILED,
+        types_1.UniversalTxStatus.CANCELED,
+    ]);
+    const startTime = Date.now();
+    (0, context_1.printLog)(ctx, `[waitForOutboundTx] Starting | txHash: ${pushChainTxHash} | initialWait: ${initialWaitMs}ms | pollInterval: ${pollingIntervalMs}ms | timeout: ${timeout}ms`);
+    progressHook?.({ status: 'waiting', elapsed: 0 });
+    // Clamp the initial wait to the configured timeout so a short per-call
+    // `outboundTimeoutMs` (e.g. from `tx.wait({ outboundTimeoutMs })`) isn't
+    // blocked by the default 20s settle-time. Mirrors the equivalent
+    // Math.min(initialWaitMs, timeout) clamp in inbound-tracker.ts.
+    const effectiveInitialWaitMs = Math.min(initialWaitMs, timeout);
+    (0, context_1.printLog)(ctx, `[waitForOutboundTx] Initial wait of ${effectiveInitialWaitMs}ms (configured: ${initialWaitMs}ms, clamped to timeout ${timeout}ms)...`);
+    await new Promise((resolve) => setTimeout(resolve, effectiveInitialWaitMs));
+    // Fast-exit: if the clamped initial wait already consumed the full budget,
+    // skip the poll loop and go straight to the timeout throw below.
+    if (Date.now() - startTime >= timeout) {
+        const elapsedMs = Date.now() - startTime;
+        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Timeout reached during initial wait (elapsed: ${elapsedMs}ms / ${timeout}ms)`);
+        progressHook?.({ status: 'timeout', elapsed: elapsedMs });
+        throw new OutboundTimeoutError(pushChainTxHash, elapsedMs, timeout);
+    }
+    // Start polling
+    (0, context_1.printLog)(ctx, `[waitForOutboundTx] Initial wait done. Starting polling. Elapsed: ${Date.now() - startTime}ms`);
+    progressHook?.({ status: 'polling', elapsed: Date.now() - startTime });
+    // Cache the universalSubTxId after first extraction to avoid redundant receipt fetches.
+    // If a pre-resolved ID was provided (cascade per-hop tracking), use it directly.
+    let cachedUniversalSubTxId = _resolvedSubTxId;
+    let pollCount = 0;
+    while (Date.now() - startTime < timeout) {
+        pollCount++;
+        const pollStart = Date.now();
+        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | Elapsed: ${pollStart - startTime}ms / ${timeout}ms`);
+        if (!cachedUniversalSubTxId) {
+            cachedUniversalSubTxId =
+                (await (0, outbound_tracker_1.extractUniversalSubTxIdFromTx)(ctx, pushChainTxHash)) ??
+                    undefined;
             if (!cachedUniversalSubTxId) {
-                cachedUniversalSubTxId =
-                    (_a = (yield (0, outbound_tracker_1.extractUniversalSubTxIdFromTx)(ctx, pushChainTxHash))) !== null && _a !== void 0 ? _a : undefined;
-                if (!cachedUniversalSubTxId) {
-                    cachedUniversalSubTxId = (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, pushChainTxHash);
-                }
-                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Extracted & cached universalSubTxId: ${cachedUniversalSubTxId}`);
+                cachedUniversalSubTxId = (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, pushChainTxHash);
             }
-            // Query with cached ID
-            const queryId = cachedUniversalSubTxId.startsWith('0x')
-                ? cachedUniversalSubTxId.slice(2)
-                : cachedUniversalSubTxId;
-            try {
-                const utxResponse = yield ctx.pushClient.getUniversalTxByIdV2(queryId);
-                const statusNum = (_b = utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) === null || _b === void 0 ? void 0 : _b.universalStatus;
-                const statusName = (_c = types_1.UniversalTxStatus[statusNum]) !== null && _c !== void 0 ? _c : statusNum;
-                const outbounds = ((_d = utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) === null || _d === void 0 ? void 0 : _d.outboundTx) || [];
-                const firstOutbound = outbounds[0];
-                const firstOutboundChain = (firstOutbound === null || firstOutbound === void 0 ? void 0 : firstOutbound.destinationChain)
-                    ? (0, helpers_1.chainFromNamespace)(firstOutbound.destinationChain)
-                    : undefined;
-                const firstDisplayTxHash = (_h = (_f = (0, helpers_1.toExternalTxHashDisplay)(firstOutboundChain !== null && firstOutboundChain !== void 0 ? firstOutboundChain : undefined, (_e = firstOutbound === null || firstOutbound === void 0 ? void 0 : firstOutbound.observedTx) === null || _e === void 0 ? void 0 : _e.txHash)) !== null && _f !== void 0 ? _f : (_g = firstOutbound === null || firstOutbound === void 0 ? void 0 : firstOutbound.observedTx) === null || _g === void 0 ? void 0 : _g.txHash) !== null && _h !== void 0 ? _h : '';
-                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${outbounds.length} | first txHash: '${firstDisplayTxHash}' | first dest: '${(firstOutbound === null || firstOutbound === void 0 ? void 0 : firstOutbound.destinationChain) || ''}'`);
-                // Check for terminal failure states — fail fast
-                if (TERMINAL_FAILURE_STATES.has(statusNum)) {
-                    (0, context_1.printLog)(ctx, `[waitForOutboundTx] Terminal failure state: ${statusName}`);
-                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
-                    throw new OutboundFailedError(`Outbound transaction failed with status ${statusName}. Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash);
+            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Extracted & cached universalSubTxId: ${cachedUniversalSubTxId}`);
+        }
+        // Query with cached ID
+        const queryId = cachedUniversalSubTxId.startsWith('0x')
+            ? cachedUniversalSubTxId.slice(2)
+            : cachedUniversalSubTxId;
+        try {
+            const utxResponse = await ctx.pushClient.getUniversalTxByIdV2(queryId);
+            const statusNum = utxResponse?.universalTx?.universalStatus;
+            const statusName = types_1.UniversalTxStatus[statusNum] ?? statusNum;
+            const outbounds = utxResponse?.universalTx?.outboundTx || [];
+            const firstOutbound = outbounds[0];
+            const firstOutboundChain = firstOutbound?.destinationChain
+                ? (0, helpers_1.chainFromNamespace)(firstOutbound.destinationChain)
+                : undefined;
+            const firstDisplayTxHash = (0, helpers_1.toExternalTxHashDisplay)(firstOutboundChain ?? undefined, firstOutbound?.observedTx?.txHash) ??
+                firstOutbound?.observedTx?.txHash ??
+                '';
+            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${outbounds.length} | first txHash: '${firstDisplayTxHash}' | first dest: '${firstOutbound?.destinationChain || ''}'`);
+            // Check for terminal failure states — fail fast
+            if (TERMINAL_FAILURE_STATES.has(statusNum)) {
+                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Terminal failure state: ${statusName}`);
+                progressHook?.({ status: 'failed', elapsed: Date.now() - startTime });
+                throw new OutboundFailedError(`Outbound transaction failed with status ${statusName}. Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash);
+            }
+            const pcTxs = utxResponse?.universalTx?.pcTx || [];
+            const failedPcTx = pcTxs.find((pcTx) => {
+                const status = String(pcTx.status || '').toUpperCase();
+                return status === 'FAILED' || Boolean(pcTx.errorMsg);
+            });
+            if (failedPcTx) {
+                const failedTxHash = failedPcTx.txHash || pushChainTxHash;
+                const reason = failedPcTx.errorMsg
+                    ? (0, formatters_1.normalizePcInsufficientFundsError)(failedPcTx.errorMsg)
+                    : 'Push Chain execution failed';
+                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Push Chain execution failed before outbound emission: ${reason}`);
+                progressHook?.({ status: 'failed', elapsed: Date.now() - startTime });
+                throw new OutboundFailedError(`Push Chain execution failed before outbound emission: ${reason}. Push Chain TX: ${failedTxHash}.`, pushChainTxHash, undefined, failedPcTx.txHash || undefined);
+            }
+            // Iterate V2 outbound array. For cascade tracking, multiple outbound
+            // entries can target the same destination chain (for example R2 BSC
+            // followed by R3 BSC -> Push). `_outboundIndex` disambiguates those
+            // same-chain entries by order after `_expectedDestinationChain` filtering.
+            let matchingOutboundIndex = 0;
+            for (const ob of outbounds) {
+                // If a destination chain filter is set, skip outbound entries that don't match.
+                if (_expectedDestinationChain &&
+                    ob.destinationChain !== _expectedDestinationChain) {
+                    (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound chain '${ob.destinationChain}' does not match expected '${_expectedDestinationChain}', skipping`);
+                    continue;
+                }
+                const currentOutboundIndex = matchingOutboundIndex;
+                matchingOutboundIndex += 1;
+                if (_outboundIndex !== undefined &&
+                    currentOutboundIndex !== _outboundIndex) {
+                    (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound index ${currentOutboundIndex} for '${ob.destinationChain}' does not match expected index ${_outboundIndex}, skipping`);
+                    continue;
                 }
-                const pcTxs = ((_j = utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) === null || _j === void 0 ? void 0 : _j.pcTx) || [];
-                const failedPcTx = pcTxs.find((pcTx) => {
-                    const status = String(pcTx.status || '').toUpperCase();
-                    return status === 'FAILED' || Boolean(pcTx.errorMsg);
-                });
-                if (failedPcTx) {
-                    const failedTxHash = failedPcTx.txHash || pushChainTxHash;
-                    const reason = failedPcTx.errorMsg
-                        ? (0, formatters_1.normalizePcInsufficientFundsError)(failedPcTx.errorMsg)
-                        : 'Push Chain execution failed';
-                    (0, context_1.printLog)(ctx, `[waitForOutboundTx] Push Chain execution failed before outbound emission: ${reason}`);
-                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
-                    throw new OutboundFailedError(`Push Chain execution failed before outbound emission: ${reason}. Push Chain TX: ${failedTxHash}.`, pushChainTxHash, undefined, failedPcTx.txHash || undefined);
+                // Fail fast on per-outbound REVERTED status
+                if (ob.outboundStatus === types_2.OutboundStatus.REVERTED) {
+                    (0, context_1.printLog)(ctx, `[waitForOutboundTx] Outbound to ${ob.destinationChain} REVERTED`);
+                    progressHook?.({ status: 'failed', elapsed: Date.now() - startTime });
+                    throw new OutboundFailedError(`Outbound to ${ob.destinationChain} reverted: ${ob.observedTx?.errorMsg || 'Unknown'}. Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash, ob.destinationChain, ob.observedTx?.txHash);
                 }
-                // Iterate V2 outbound array. For cascade tracking, multiple outbound
-                // entries can target the same destination chain (for example R2 BSC
-                // followed by R3 BSC -> Push). `_outboundIndex` disambiguates those
-                // same-chain entries by order after `_expectedDestinationChain` filtering.
-                let matchingOutboundIndex = 0;
-                for (const ob of outbounds) {
-                    // If a destination chain filter is set, skip outbound entries that don't match.
-                    if (_expectedDestinationChain &&
-                        ob.destinationChain !== _expectedDestinationChain) {
-                        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound chain '${ob.destinationChain}' does not match expected '${_expectedDestinationChain}', skipping`);
+                // FOUND gating logic:
+                //   1. Primary path — cosmos has transitioned to OBSERVED (the
+                //      authoritative success signal from the indexer).
+                //   2. Tiebreaker — cosmos has the txHash but outboundStatus is
+                //      still UNSPECIFIED/PENDING (indexer lag). We ask the
+                //      destination chain's own RPC: if its receipt is success,
+                //      treat as FOUND; if reverted, throw OutboundFailedError.
+                //      Pending receipts keep polling.
+                if (ob.observedTx?.txHash) {
+                    const chain = (0, helpers_1.chainFromNamespace)(ob.destinationChain);
+                    if (!chain)
                         continue;
+                    const isCosmosObserved = ob.outboundStatus === types_2.OutboundStatus.OBSERVED;
+                    if (!isCosmosObserved) {
+                        // Tiebreaker: ask the destination-chain RPC directly.
+                        const verdict = await verifyExternalEvmReceipt(ctx, chain, ob.observedTx.txHash);
+                        if (verdict === 'reverted') {
+                            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Source-chain RPC reports REVERTED for ${ob.destinationChain} tx ${ob.observedTx.txHash} (cosmos still ${types_1.UniversalTxStatus[statusNum] ?? statusNum})`);
+                            progressHook?.({
+                                status: 'failed',
+                                elapsed: Date.now() - startTime,
+                            });
+                            throw new OutboundFailedError(`Outbound to ${ob.destinationChain} reverted on source-chain RPC (tx: ${ob.observedTx.txHash}). Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash, ob.destinationChain, ob.observedTx.txHash);
+                        }
+                        if (verdict !== 'success') {
+                            // 'pending' or 'unsupported' — keep polling, cosmos will catch up.
+                            continue;
+                        }
+                        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Source-chain RPC tiebreaker: ${chain} tx ${ob.observedTx.txHash} succeeded; treating as FOUND despite cosmos status ${types_1.UniversalTxStatus[statusNum] ?? statusNum}`);
                     }
-                    const currentOutboundIndex = matchingOutboundIndex;
-                    matchingOutboundIndex += 1;
-                    if (_outboundIndex !== undefined &&
-                        currentOutboundIndex !== _outboundIndex) {
-                        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound index ${currentOutboundIndex} for '${ob.destinationChain}' does not match expected index ${_outboundIndex}, skipping`);
-                        continue;
+                    {
+                        const explorerBaseUrl = chain_1.CHAIN_INFO[chain]?.explorerUrl;
+                        const isSvm = chain_1.CHAIN_INFO[chain]?.vm === enums_1.VM.SVM;
+                        const displayTxHash = (0, helpers_1.toExternalTxHashDisplay)(chain, ob.observedTx.txHash) ??
+                            ob.observedTx.txHash;
+                        let explorerUrl = '';
+                        if (isSvm) {
+                            const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET
+                                ? '?cluster=devnet'
+                                : chain === enums_1.CHAIN.SOLANA_TESTNET
+                                    ? '?cluster=testnet'
+                                    : '';
+                            explorerUrl = explorerBaseUrl
+                                ? `${explorerBaseUrl}/tx/${displayTxHash}${cluster}`
+                                : '';
+                        }
+                        else {
+                            explorerUrl = explorerBaseUrl
+                                ? `${explorerBaseUrl}/tx/${displayTxHash}`
+                                : '';
+                        }
+                        // OutboundTxDetails carries the raw `0x`-hex form so internal
+                        // consumers (R3 inbound tracker in response-builder.ts:786 →
+                        // findChildUtxIdFromExternalTx → Cosmos query) keep working.
+                        // The base58 display form is applied at every user-facing
+                        // boundary via `toExternalTxHashDisplay` (helpers.ts).
+                        // PC20: `externalAssetAddr` is empty when the outbound is first
+                        // created, and a repeat export deploys no wrapper so nothing is
+                        // ever observed to backfill it. Resolve from UniversalCore instead,
+                        // keyed by the Push-native source token.
+                        const pc20Wrapper = await (0, tracking_1.resolvePC20WrapperForReceipt)(ctx, ob, { network: ctx.pushNetwork, rpcUrls: ctx.rpcUrls });
+                        const details = {
+                            externalTxHash: ob.observedTx.txHash,
+                            destinationChain: chain,
+                            explorerUrl,
+                            recipient: ob.recipient,
+                            amount: ob.amount,
+                            assetAddr: pc20Wrapper ?? ob.externalAssetAddr,
+                        };
+                        (0, context_1.printLog)(ctx, `[waitForOutboundTx] FOUND on poll #${pollCount} | elapsed: ${Date.now() - startTime}ms | externalTxHash: ${displayTxHash}`);
+                        progressHook?.({
+                            status: 'found',
+                            elapsed: Date.now() - startTime,
+                        });
+                        return details;
                     }
-                    // Fail fast on per-outbound REVERTED status
-                    if (ob.outboundStatus === types_2.OutboundStatus.REVERTED) {
-                        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Outbound to ${ob.destinationChain} REVERTED`);
-                        progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
-                        throw new OutboundFailedError(`Outbound to ${ob.destinationChain} reverted: ${((_k = ob.observedTx) === null || _k === void 0 ? void 0 : _k.errorMsg) || 'Unknown'}. Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash, ob.destinationChain, (_l = ob.observedTx) === null || _l === void 0 ? void 0 : _l.txHash);
+                }
+            }
+        }
+        catch (error) {
+            // Re-throw typed terminal failure so the caller can classify it as
+            // 299-02. Transient errors (RPC hiccups, deserialization) are logged
+            // and the loop continues polling until timeout.
+            if (error instanceof OutboundFailedError) {
+                throw error;
+            }
+            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} ERROR: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} not ready yet (${Date.now() - pollStart}ms). Waiting ${pollingIntervalMs}ms...`);
+        // Wait before next poll
+        await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+    }
+    const elapsedMs = Date.now() - startTime;
+    (0, context_1.printLog)(ctx, `[waitForOutboundTx] TIMEOUT after ${pollCount} polls | elapsed: ${elapsedMs}ms`);
+    progressHook?.({ status: 'timeout', elapsed: elapsedMs });
+    throw new OutboundTimeoutError(pushChainTxHash, elapsedMs, timeout);
+}
+// ============================================================================
+// waitForAllOutboundTxsV2
+// ============================================================================
+/**
+ * Tracks ALL outbound transactions for a cascade with multiple outbound hops
+ * (e.g., BNB + Solana). Uses V2 API which returns outboundTx[] with per-outbound
+ * status tracking, matching each outbound to the correct hop by destination chain.
+ */
+async function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
+    const { initialWaitMs, pollingIntervalMs, timeout, progressHook, _resolvedSubTxId, _outboundIndexByHop, } = options;
+    const startTime = Date.now();
+    // Build maps for matching outbound entries. When the cascade composer merged
+    // multiple logical hops into one outbound request, `_outboundIndexByHop` maps
+    // those hops to the same outbound ordinal.
+    const chainToHops = new Map();
+    for (const hop of outboundHops) {
+        const chainInfo = chain_1.CHAIN_INFO[hop.executionChain];
+        if (chainInfo) {
+            const namespace = `${chain_1.VM_NAMESPACE[chainInfo.vm]}:${chainInfo.chainId}`;
+            const existingByOrdinal = chainToHops.get(namespace) || new Map();
+            const fallbackOrdinal = [...existingByOrdinal.values()].reduce((count, hopsForOrdinal) => count + hopsForOrdinal.length, 0);
+            const outboundOrdinal = _outboundIndexByHop?.get(hop.hopIndex) ?? fallbackOrdinal;
+            const existing = existingByOrdinal.get(outboundOrdinal) || [];
+            existing.push(hop);
+            existingByOrdinal.set(outboundOrdinal, existing);
+            chainToHops.set(namespace, existingByOrdinal);
+        }
+    }
+    const expectedChains = [...chainToHops.keys()];
+    (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Starting | txHash: ${pushChainTxHash} | expectedChains: ${expectedChains.join(', ')} | timeout: ${timeout}ms`);
+    // Emit initial waiting status for all outbound hops
+    for (const hop of outboundHops) {
+        progressHook?.({
+            hopIndex: hop.hopIndex,
+            route: hop.route,
+            chain: hop.executionChain,
+            status: 'waiting',
+        });
+    }
+    // Initial wait before first poll
+    const waitMs = Math.min(initialWaitMs, timeout);
+    (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Initial wait of ${waitMs}ms...`);
+    await new Promise((resolve) => setTimeout(resolve, waitMs));
+    // Emit polling status for all hops
+    for (const hop of outboundHops) {
+        progressHook?.({
+            hopIndex: hop.hopIndex,
+            route: hop.route,
+            chain: hop.executionChain,
+            status: 'polling',
+        });
+    }
+    // Extract sub-tx ID for V2 query
+    let cachedQueryId = _resolvedSubTxId
+        ? _resolvedSubTxId.startsWith('0x')
+            ? _resolvedSubTxId.slice(2)
+            : _resolvedSubTxId
+        : undefined;
+    let pollCount = 0;
+    let consecutiveErrors = 0;
+    const MAX_CONSECUTIVE_ERRORS = 10;
+    while (Date.now() - startTime < timeout) {
+        pollCount++;
+        const elapsed = Date.now() - startTime;
+        (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} | Elapsed: ${elapsed}ms / ${timeout}ms`);
+        // Resolve query ID on first poll
+        if (!cachedQueryId) {
+            const allSubTxIds = await (0, outbound_tracker_1.extractAllUniversalSubTxIds)(ctx, pushChainTxHash);
+            const subTxId = allSubTxIds.length > 0
+                ? allSubTxIds[0]
+                : (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, pushChainTxHash);
+            cachedQueryId = subTxId.startsWith('0x') ? subTxId.slice(2) : subTxId;
+            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Resolved queryId: ${cachedQueryId}`);
+        }
+        try {
+            const v2Response = await ctx.pushClient.getUniversalTxByIdV2(cachedQueryId);
+            consecutiveErrors = 0; // Reset on successful RPC call
+            const utx = v2Response?.universalTx;
+            const statusNum = utx?.universalStatus;
+            const statusName = types_1.UniversalTxStatus[statusNum] ?? statusNum;
+            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${utx?.outboundTx?.length ?? 0}`);
+            if (utx?.outboundTx?.length) {
+                const outboundOrdinalByChain = new Map();
+                for (const ob of utx.outboundTx) {
+                    const destChain = ob.destinationChain;
+                    const hopsByOrdinal = chainToHops.get(destChain);
+                    if (!hopsByOrdinal)
+                        continue;
+                    const outboundOrdinal = outboundOrdinalByChain.get(destChain) ?? 0;
+                    outboundOrdinalByChain.set(destChain, outboundOrdinal + 1);
+                    const targetHops = hopsByOrdinal.get(outboundOrdinal) || [];
+                    const pendingTargetHops = targetHops.filter((hop) => hop.status !== 'confirmed' && hop.status !== 'failed');
+                    if (pendingTargetHops.length === 0)
+                        continue;
+                    const primaryTargetHop = pendingTargetHops[0];
+                    const externalTxHash = ob.observedTx?.txHash;
+                    const hasObservedTxHash = !!externalTxHash && externalTxHash !== 'EMPTY';
+                    const observedFailure = hasObservedTxHash &&
+                        ob.observedTx?.success === false &&
+                        Boolean(ob.observedTx?.errorMsg ||
+                            ob.abortReason ||
+                            ob.outboundStatus >= types_2.OutboundStatus.REVERTED);
+                    // Fail fast on per-outbound REVERTED or observed destination failure.
+                    if (ob.outboundStatus === types_2.OutboundStatus.REVERTED ||
+                        observedFailure) {
+                        for (const targetHop of pendingTargetHops) {
+                            targetHop.status = 'failed';
+                            progressHook?.({
+                                hopIndex: targetHop.hopIndex,
+                                route: targetHop.route,
+                                chain: targetHop.executionChain,
+                                status: 'failed',
+                            });
+                        }
+                        (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Outbound to ${destChain} REVERTED | outboundIndex ${outboundOrdinal} | hops ${pendingTargetHops
+                            .map((hop) => hop.hopIndex)
+                            .join(', ')} | error: ${ob.abortReason || ob.observedTx?.errorMsg || 'Unknown'}`);
+                        return { success: false, failedAt: primaryTargetHop.hopIndex };
                     }
-                    // FOUND gating logic:
-                    //   1. Primary path — cosmos has transitioned to OBSERVED (the
-                    //      authoritative success signal from the indexer).
-                    //   2. Tiebreaker — cosmos has the txHash but outboundStatus is
-                    //      still UNSPECIFIED/PENDING (indexer lag). We ask the
-                    //      destination chain's own RPC: if its receipt is success,
-                    //      treat as FOUND; if reverted, throw OutboundFailedError.
-                    //      Pending receipts keep polling.
-                    if ((_m = ob.observedTx) === null || _m === void 0 ? void 0 : _m.txHash) {
-                        const chain = (0, helpers_1.chainFromNamespace)(ob.destinationChain);
+                    // Check for observed tx hash. Cosmos may lag the status transition,
+                    // so EVM destinations are verified against the destination receipt.
+                    if (hasObservedTxHash && externalTxHash) {
+                        const chain = (0, helpers_1.chainFromNamespace)(destChain);
                         if (!chain)
                             continue;
                         const isCosmosObserved = ob.outboundStatus === types_2.OutboundStatus.OBSERVED;
                         if (!isCosmosObserved) {
-                            // Tiebreaker: ask the destination-chain RPC directly.
-                            const verdict = yield verifyExternalEvmReceipt(ctx, chain, ob.observedTx.txHash);
+                            const verdict = await verifyExternalEvmReceipt(ctx, chain, externalTxHash);
                             if (verdict === 'reverted') {
-                                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Source-chain RPC reports REVERTED for ${ob.destinationChain} tx ${ob.observedTx.txHash} (cosmos still ${(_o = types_1.UniversalTxStatus[statusNum]) !== null && _o !== void 0 ? _o : statusNum})`);
-                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                    status: 'failed',
-                                    elapsed: Date.now() - startTime,
-                                });
-                                throw new OutboundFailedError(`Outbound to ${ob.destinationChain} reverted on source-chain RPC (tx: ${ob.observedTx.txHash}). Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash, ob.destinationChain, ob.observedTx.txHash);
+                                for (const targetHop of pendingTargetHops) {
+                                    targetHop.status = 'failed';
+                                    progressHook?.({
+                                        hopIndex: targetHop.hopIndex,
+                                        route: targetHop.route,
+                                        chain: targetHop.executionChain,
+                                        status: 'failed',
+                                    });
+                                }
+                                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Source-chain RPC reports REVERTED for ${destChain} tx ${externalTxHash} | outboundIndex ${outboundOrdinal} | hops ${pendingTargetHops
+                                    .map((hop) => hop.hopIndex)
+                                    .join(', ')}`);
+                                return { success: false, failedAt: primaryTargetHop.hopIndex };
                             }
                             if (verdict !== 'success') {
-                                // 'pending' or 'unsupported' — keep polling, cosmos will catch up.
                                 continue;
                             }
-                            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Source-chain RPC tiebreaker: ${chain} tx ${ob.observedTx.txHash} succeeded; treating as FOUND despite cosmos status ${(_p = types_1.UniversalTxStatus[statusNum]) !== null && _p !== void 0 ? _p : statusNum}`);
                         }
-                        {
-                            const explorerBaseUrl = (_q = chain_1.CHAIN_INFO[chain]) === null || _q === void 0 ? void 0 : _q.explorerUrl;
-                            const isSvm = ((_r = chain_1.CHAIN_INFO[chain]) === null || _r === void 0 ? void 0 : _r.vm) === enums_1.VM.SVM;
-                            const displayTxHash = (_s = (0, helpers_1.toExternalTxHashDisplay)(chain, ob.observedTx.txHash)) !== null && _s !== void 0 ? _s : ob.observedTx.txHash;
-                            let explorerUrl = '';
+                        // Build the display form for SVM (base58) used in `hop.txHash` /
+                        // `hop.outboundDetails.externalTxHash` / the progressHook event —
+                        // these are USER-FACING. The internal raw-hex form stays only
+                        // inside this function; it's not exposed to consumers from the
+                        // cascade path (cascade.ts doesn't call findChildUtxIdFromExternalTx
+                        // for the cascade outbound hash).
+                        const displayTxHash = (0, helpers_1.toExternalTxHashDisplay)(chain ?? undefined, externalTxHash) ??
+                            externalTxHash;
+                        let explorerUrl = '';
+                        if (chain && externalTxHash) {
+                            const explorerBaseUrl = chain_1.CHAIN_INFO[chain]?.explorerUrl;
+                            const isSvm = chain_1.CHAIN_INFO[chain]?.vm === enums_1.VM.SVM;
                             if (isSvm) {
                                 const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET
                                     ? '?cluster=devnet'
@@ -297,310 +524,94 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                                     ? `${explorerBaseUrl}/tx/${displayTxHash}`
                                     : '';
                             }
-                            // OutboundTxDetails carries the raw `0x`-hex form so internal
-                            // consumers (R3 inbound tracker in response-builder.ts:786 →
-                            // findChildUtxIdFromExternalTx → Cosmos query) keep working.
-                            // The base58 display form is applied at every user-facing
-                            // boundary via `toExternalTxHashDisplay` (helpers.ts).
-                            const details = {
-                                externalTxHash: ob.observedTx.txHash,
-                                destinationChain: chain,
+                        }
+                        // Same PC20 fallback as the single-outbound path above.
+                        const hopPc20Wrapper = await (0, tracking_1.resolvePC20WrapperForReceipt)(ctx, ob, {
+                            network: ctx.pushNetwork,
+                            rpcUrls: ctx.rpcUrls,
+                        });
+                        for (const targetHop of pendingTargetHops) {
+                            targetHop.status = 'confirmed';
+                            targetHop.txHash = displayTxHash;
+                            targetHop.outboundDetails = {
+                                externalTxHash: displayTxHash,
+                                destinationChain: chain || targetHop.executionChain,
                                 explorerUrl,
                                 recipient: ob.recipient,
                                 amount: ob.amount,
-                                assetAddr: ob.externalAssetAddr,
+                                assetAddr: hopPc20Wrapper ?? ob.externalAssetAddr,
                             };
-                            (0, context_1.printLog)(ctx, `[waitForOutboundTx] FOUND on poll #${pollCount} | elapsed: ${Date.now() - startTime}ms | externalTxHash: ${displayTxHash}`);
-                            progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                status: 'found',
-                                elapsed: Date.now() - startTime,
+                            progressHook?.({
+                                hopIndex: targetHop.hopIndex,
+                                route: targetHop.route,
+                                chain: targetHop.executionChain,
+                                status: 'confirmed',
+                                txHash: displayTxHash,
                             });
-                            return details;
                         }
+                        (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] FOUND outbound for ${destChain} | outboundIndex ${outboundOrdinal} | hops ${pendingTargetHops
+                            .map((hop) => hop.hopIndex)
+                            .join(', ')} | externalTxHash: ${displayTxHash}`);
                     }
                 }
             }
-            catch (error) {
-                // Re-throw typed terminal failure so the caller can classify it as
-                // 299-02. Transient errors (RPC hiccups, deserialization) are logged
-                // and the loop continues polling until timeout.
-                if (error instanceof OutboundFailedError) {
-                    throw error;
+            // Check if all hops are now confirmed
+            if (outboundHops.every((h) => h.status === 'confirmed')) {
+                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] All ${outboundHops.length} hops confirmed via V2`);
+                return { success: true };
+            }
+            // If PC_EXECUTED_SUCCESS but some hops still unresolved, check outbound status.
+            // Only auto-confirm if there are NO pending outbound txs (status=1 with empty hash).
+            // Pending outbounds are still in flight on the relay — keep polling for their hashes.
+            if (statusNum === types_1.UniversalTxStatus.PC_EXECUTED_SUCCESS) {
+                const stillUnresolved = outboundHops.filter((h) => h.status !== 'confirmed');
+                if (stillUnresolved.length > 0) {
+                    const hasPendingOutbound = utx?.outboundTx?.some((ob) => ob.outboundStatus === types_2.OutboundStatus.PENDING &&
+                        (!ob.observedTx?.txHash || ob.observedTx.txHash === 'EMPTY'));
+                    if (!hasPendingOutbound) {
+                        // No pending outbounds — safe to auto-confirm remaining hops
+                        for (const hop of stillUnresolved) {
+                            hop.status = 'confirmed';
+                            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Auto-confirmed hop ${hop.hopIndex} (${hop.executionChain}) based on PC_EXECUTED_SUCCESS (no pending outbounds)`);
+                            progressHook?.({
+                                hopIndex: hop.hopIndex,
+                                route: hop.route,
+                                chain: hop.executionChain,
+                                status: 'confirmed',
+                            });
+                        }
+                        return { success: true };
+                    }
+                    // Pending outbound txs still in flight — continue polling
+                    (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] ${stillUnresolved.length} hop(s) unresolved, pending outbound txs in flight — continuing to poll`);
                 }
-                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} ERROR: ${error instanceof Error ? error.message : String(error)}`);
             }
-            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} not ready yet (${Date.now() - pollStart}ms). Waiting ${pollingIntervalMs}ms...`);
-            // Wait before next poll
-            yield new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
         }
-        const elapsedMs = Date.now() - startTime;
-        (0, context_1.printLog)(ctx, `[waitForOutboundTx] TIMEOUT after ${pollCount} polls | elapsed: ${elapsedMs}ms`);
-        progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'timeout', elapsed: elapsedMs });
-        throw new OutboundTimeoutError(pushChainTxHash, elapsedMs, timeout);
-    });
-}
-// ============================================================================
-// waitForAllOutboundTxsV2
-// ============================================================================
-/**
- * Tracks ALL outbound transactions for a cascade with multiple outbound hops
- * (e.g., BNB + Solana). Uses V2 API which returns outboundTx[] with per-outbound
- * status tracking, matching each outbound to the correct hop by destination chain.
- */
-function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
-        const { initialWaitMs, pollingIntervalMs, timeout, progressHook, _resolvedSubTxId, _outboundIndexByHop, } = options;
-        const startTime = Date.now();
-        // Build maps for matching outbound entries. When the cascade composer merged
-        // multiple logical hops into one outbound request, `_outboundIndexByHop` maps
-        // those hops to the same outbound ordinal.
-        const chainToHops = new Map();
-        for (const hop of outboundHops) {
-            const chainInfo = chain_1.CHAIN_INFO[hop.executionChain];
-            if (chainInfo) {
-                const namespace = `${chain_1.VM_NAMESPACE[chainInfo.vm]}:${chainInfo.chainId}`;
-                const existingByOrdinal = chainToHops.get(namespace) || new Map();
-                const fallbackOrdinal = [...existingByOrdinal.values()].reduce((count, hopsForOrdinal) => count + hopsForOrdinal.length, 0);
-                const outboundOrdinal = (_a = _outboundIndexByHop === null || _outboundIndexByHop === void 0 ? void 0 : _outboundIndexByHop.get(hop.hopIndex)) !== null && _a !== void 0 ? _a : fallbackOrdinal;
-                const existing = existingByOrdinal.get(outboundOrdinal) || [];
-                existing.push(hop);
-                existingByOrdinal.set(outboundOrdinal, existing);
-                chainToHops.set(namespace, existingByOrdinal);
+        catch (error) {
+            consecutiveErrors++;
+            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} ERROR (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${error instanceof Error ? error.message : String(error)}`);
+            if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Aborting — ${MAX_CONSECUTIVE_ERRORS} consecutive RPC errors`);
+                break;
             }
         }
-        const expectedChains = [...chainToHops.keys()];
-        (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Starting | txHash: ${pushChainTxHash} | expectedChains: ${expectedChains.join(', ')} | timeout: ${timeout}ms`);
-        // Emit initial waiting status for all outbound hops
-        for (const hop of outboundHops) {
-            progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                hopIndex: hop.hopIndex,
-                route: hop.route,
-                chain: hop.executionChain,
-                status: 'waiting',
-            });
-        }
-        // Initial wait before first poll
-        const waitMs = Math.min(initialWaitMs, timeout);
-        (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Initial wait of ${waitMs}ms...`);
-        yield new Promise((resolve) => setTimeout(resolve, waitMs));
-        // Emit polling status for all hops
-        for (const hop of outboundHops) {
-            progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+        await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+    }
+    // Timeout: fail any unresolved hops
+    const timedOutHops = outboundHops.filter((h) => h.status !== 'confirmed');
+    if (timedOutHops.length > 0) {
+        (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] TIMEOUT after ${pollCount} polls | ${timedOutHops.length} hop(s) unresolved`);
+        for (const hop of timedOutHops) {
+            hop.status = 'failed';
+            progressHook?.({
                 hopIndex: hop.hopIndex,
                 route: hop.route,
                 chain: hop.executionChain,
-                status: 'polling',
+                status: 'failed',
             });
         }
-        // Extract sub-tx ID for V2 query
-        let cachedQueryId = _resolvedSubTxId
-            ? _resolvedSubTxId.startsWith('0x')
-                ? _resolvedSubTxId.slice(2)
-                : _resolvedSubTxId
-            : undefined;
-        let pollCount = 0;
-        let consecutiveErrors = 0;
-        const MAX_CONSECUTIVE_ERRORS = 10;
-        while (Date.now() - startTime < timeout) {
-            pollCount++;
-            const elapsed = Date.now() - startTime;
-            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} | Elapsed: ${elapsed}ms / ${timeout}ms`);
-            // Resolve query ID on first poll
-            if (!cachedQueryId) {
-                const allSubTxIds = yield (0, outbound_tracker_1.extractAllUniversalSubTxIds)(ctx, pushChainTxHash);
-                const subTxId = allSubTxIds.length > 0
-                    ? allSubTxIds[0]
-                    : (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, pushChainTxHash);
-                cachedQueryId = subTxId.startsWith('0x') ? subTxId.slice(2) : subTxId;
-                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Resolved queryId: ${cachedQueryId}`);
-            }
-            try {
-                const v2Response = yield ctx.pushClient.getUniversalTxByIdV2(cachedQueryId);
-                consecutiveErrors = 0; // Reset on successful RPC call
-                const utx = v2Response === null || v2Response === void 0 ? void 0 : v2Response.universalTx;
-                const statusNum = utx === null || utx === void 0 ? void 0 : utx.universalStatus;
-                const statusName = (_b = types_1.UniversalTxStatus[statusNum]) !== null && _b !== void 0 ? _b : statusNum;
-                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${(_d = (_c = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0}`);
-                if ((_e = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _e === void 0 ? void 0 : _e.length) {
-                    const outboundOrdinalByChain = new Map();
-                    for (const ob of utx.outboundTx) {
-                        const destChain = ob.destinationChain;
-                        const hopsByOrdinal = chainToHops.get(destChain);
-                        if (!hopsByOrdinal)
-                            continue;
-                        const outboundOrdinal = (_f = outboundOrdinalByChain.get(destChain)) !== null && _f !== void 0 ? _f : 0;
-                        outboundOrdinalByChain.set(destChain, outboundOrdinal + 1);
-                        const targetHops = hopsByOrdinal.get(outboundOrdinal) || [];
-                        const pendingTargetHops = targetHops.filter((hop) => hop.status !== 'confirmed' && hop.status !== 'failed');
-                        if (pendingTargetHops.length === 0)
-                            continue;
-                        const primaryTargetHop = pendingTargetHops[0];
-                        const externalTxHash = (_g = ob.observedTx) === null || _g === void 0 ? void 0 : _g.txHash;
-                        const hasObservedTxHash = !!externalTxHash && externalTxHash !== 'EMPTY';
-                        const observedFailure = hasObservedTxHash &&
-                            ((_h = ob.observedTx) === null || _h === void 0 ? void 0 : _h.success) === false &&
-                            Boolean(((_j = ob.observedTx) === null || _j === void 0 ? void 0 : _j.errorMsg) ||
-                                ob.abortReason ||
-                                ob.outboundStatus >= types_2.OutboundStatus.REVERTED);
-                        // Fail fast on per-outbound REVERTED or observed destination failure.
-                        if (ob.outboundStatus === types_2.OutboundStatus.REVERTED ||
-                            observedFailure) {
-                            for (const targetHop of pendingTargetHops) {
-                                targetHop.status = 'failed';
-                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                    hopIndex: targetHop.hopIndex,
-                                    route: targetHop.route,
-                                    chain: targetHop.executionChain,
-                                    status: 'failed',
-                                });
-                            }
-                            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Outbound to ${destChain} REVERTED | outboundIndex ${outboundOrdinal} | hops ${pendingTargetHops
-                                .map((hop) => hop.hopIndex)
-                                .join(', ')} | error: ${ob.abortReason || ((_k = ob.observedTx) === null || _k === void 0 ? void 0 : _k.errorMsg) || 'Unknown'}`);
-                            return { success: false, failedAt: primaryTargetHop.hopIndex };
-                        }
-                        // Check for observed tx hash. Cosmos may lag the status transition,
-                        // so EVM destinations are verified against the destination receipt.
-                        if (hasObservedTxHash && externalTxHash) {
-                            const chain = (0, helpers_1.chainFromNamespace)(destChain);
-                            if (!chain)
-                                continue;
-                            const isCosmosObserved = ob.outboundStatus === types_2.OutboundStatus.OBSERVED;
-                            if (!isCosmosObserved) {
-                                const verdict = yield verifyExternalEvmReceipt(ctx, chain, externalTxHash);
-                                if (verdict === 'reverted') {
-                                    for (const targetHop of pendingTargetHops) {
-                                        targetHop.status = 'failed';
-                                        progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                            hopIndex: targetHop.hopIndex,
-                                            route: targetHop.route,
-                                            chain: targetHop.executionChain,
-                                            status: 'failed',
-                                        });
-                                    }
-                                    (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Source-chain RPC reports REVERTED for ${destChain} tx ${externalTxHash} | outboundIndex ${outboundOrdinal} | hops ${pendingTargetHops
-                                        .map((hop) => hop.hopIndex)
-                                        .join(', ')}`);
-                                    return { success: false, failedAt: primaryTargetHop.hopIndex };
-                                }
-                                if (verdict !== 'success') {
-                                    continue;
-                                }
-                            }
-                            // Build the display form for SVM (base58) used in `hop.txHash` /
-                            // `hop.outboundDetails.externalTxHash` / the progressHook event —
-                            // these are USER-FACING. The internal raw-hex form stays only
-                            // inside this function; it's not exposed to consumers from the
-                            // cascade path (cascade.ts doesn't call findChildUtxIdFromExternalTx
-                            // for the cascade outbound hash).
-                            const displayTxHash = (_l = (0, helpers_1.toExternalTxHashDisplay)(chain !== null && chain !== void 0 ? chain : undefined, externalTxHash)) !== null && _l !== void 0 ? _l : externalTxHash;
-                            let explorerUrl = '';
-                            if (chain && externalTxHash) {
-                                const explorerBaseUrl = (_m = chain_1.CHAIN_INFO[chain]) === null || _m === void 0 ? void 0 : _m.explorerUrl;
-                                const isSvm = ((_o = chain_1.CHAIN_INFO[chain]) === null || _o === void 0 ? void 0 : _o.vm) === enums_1.VM.SVM;
-                                if (isSvm) {
-                                    const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET
-                                        ? '?cluster=devnet'
-                                        : chain === enums_1.CHAIN.SOLANA_TESTNET
-                                            ? '?cluster=testnet'
-                                            : '';
-                                    explorerUrl = explorerBaseUrl
-                                        ? `${explorerBaseUrl}/tx/${displayTxHash}${cluster}`
-                                        : '';
-                                }
-                                else {
-                                    explorerUrl = explorerBaseUrl
-                                        ? `${explorerBaseUrl}/tx/${displayTxHash}`
-                                        : '';
-                                }
-                            }
-                            for (const targetHop of pendingTargetHops) {
-                                targetHop.status = 'confirmed';
-                                targetHop.txHash = displayTxHash;
-                                targetHop.outboundDetails = {
-                                    externalTxHash: displayTxHash,
-                                    destinationChain: chain || targetHop.executionChain,
-                                    explorerUrl,
-                                    recipient: ob.recipient,
-                                    amount: ob.amount,
-                                    assetAddr: ob.externalAssetAddr,
-                                };
-                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                    hopIndex: targetHop.hopIndex,
-                                    route: targetHop.route,
-                                    chain: targetHop.executionChain,
-                                    status: 'confirmed',
-                                    txHash: displayTxHash,
-                                });
-                            }
-                            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] FOUND outbound for ${destChain} | outboundIndex ${outboundOrdinal} | hops ${pendingTargetHops
-                                .map((hop) => hop.hopIndex)
-                                .join(', ')} | externalTxHash: ${displayTxHash}`);
-                        }
-                    }
-                }
-                // Check if all hops are now confirmed
-                if (outboundHops.every((h) => h.status === 'confirmed')) {
-                    (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] All ${outboundHops.length} hops confirmed via V2`);
-                    return { success: true };
-                }
-                // If PC_EXECUTED_SUCCESS but some hops still unresolved, check outbound status.
-                // Only auto-confirm if there are NO pending outbound txs (status=1 with empty hash).
-                // Pending outbounds are still in flight on the relay — keep polling for their hashes.
-                if (statusNum === types_1.UniversalTxStatus.PC_EXECUTED_SUCCESS) {
-                    const stillUnresolved = outboundHops.filter((h) => h.status !== 'confirmed');
-                    if (stillUnresolved.length > 0) {
-                        const hasPendingOutbound = (_p = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _p === void 0 ? void 0 : _p.some((ob) => {
-                            var _a;
-                            return ob.outboundStatus === types_2.OutboundStatus.PENDING &&
-                                (!((_a = ob.observedTx) === null || _a === void 0 ? void 0 : _a.txHash) || ob.observedTx.txHash === 'EMPTY');
-                        });
-                        if (!hasPendingOutbound) {
-                            // No pending outbounds — safe to auto-confirm remaining hops
-                            for (const hop of stillUnresolved) {
-                                hop.status = 'confirmed';
-                                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Auto-confirmed hop ${hop.hopIndex} (${hop.executionChain}) based on PC_EXECUTED_SUCCESS (no pending outbounds)`);
-                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                    hopIndex: hop.hopIndex,
-                                    route: hop.route,
-                                    chain: hop.executionChain,
-                                    status: 'confirmed',
-                                });
-                            }
-                            return { success: true };
-                        }
-                        // Pending outbound txs still in flight — continue polling
-                        (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] ${stillUnresolved.length} hop(s) unresolved, pending outbound txs in flight — continuing to poll`);
-                    }
-                }
-            }
-            catch (error) {
-                consecutiveErrors++;
-                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} ERROR (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${error instanceof Error ? error.message : String(error)}`);
-                if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-                    (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Aborting — ${MAX_CONSECUTIVE_ERRORS} consecutive RPC errors`);
-                    break;
-                }
-            }
-            yield new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
-        }
-        // Timeout: fail any unresolved hops
-        const timedOutHops = outboundHops.filter((h) => h.status !== 'confirmed');
-        if (timedOutHops.length > 0) {
-            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] TIMEOUT after ${pollCount} polls | ${timedOutHops.length} hop(s) unresolved`);
-            for (const hop of timedOutHops) {
-                hop.status = 'failed';
-                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                    hopIndex: hop.hopIndex,
-                    route: hop.route,
-                    chain: hop.executionChain,
-                    status: 'failed',
-                });
-            }
-            return { success: false, failedAt: timedOutHops[0].hopIndex };
-        }
-        return { success: true };
-    });
+        return { success: false, failedAt: timedOutHops[0].hopIndex };
+    }
+    return { success: true };
 }
 //# sourceMappingURL=outbound-sync.js.map