@pushchain/core 6.0.20 → 6.0.21

package/src/lib/orchestrator/internals/inbound-tracker.js

@@ -15,7 +15,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InboundTimeoutError = void 0;
 exports.findChildUtxIdFromExternalTx = findChildUtxIdFromExternalTx;
 exports.waitForInboundPushTx = waitForInboundPushTx;
-const tslib_1 = require("tslib");
 const types_1 = require("../../generated/uexecutor/v2/types");
 const context_1 = require("./context");
 const detector_1 = require("../../universal-tx-detector/detector");
@@ -51,58 +50,56 @@ const ensureHex = (id) => id.startsWith('0x') ? id : `0x${id}`;
  * has seen it yet, or `{ utxId: null, error }` when both paths failed with
  * recoverable RPC errors.
  */
-function findChildUtxIdFromExternalTx(ctx, externalTxHash, sourceChain) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        // Primary: detector-based deterministic derivation.
-        if (sourceChain) {
-            try {
-                const detection = yield (0, detector_1.detectUniversalTx)(externalTxHash, sourceChain, {
-                    pushClient: ctx.pushClient,
-                    rpcUrls: ctx.rpcUrls,
-                    skipPushChainLookup: true,
-                });
-                const resolutions = yield (0, child_inbounds_1.resolveChildInboundsFromDetection)(ctx.pushClient, detection);
-                // Pick the R3 return-trip child: prefer UniversalTx over RevertUniversalTx.
-                const match = (_a = resolutions.find((r) => r.sourceEventName === 'UniversalTx')) !== null && _a !== void 0 ? _a : resolutions[0];
-                if (match === null || match === void 0 ? void 0 : match.universalTxId) {
-                    (0, context_1.printLog)(ctx, `[findChildUtxIdFromExternalTx] detector derived utxId ${match.universalTxId} for ${externalTxHash} on ${sourceChain}`);
-                    return { utxId: ensureHex(match.universalTxId), derivedFrom: 'detector' };
-                }
-            }
-            catch (err) {
-                const wrapped = err instanceof Error ? err : new Error(String(err));
-                (0, context_1.printLog)(ctx, `[findChildUtxIdFromExternalTx] detector path failed: ${wrapped.message} — falling back to cosmos search`);
-                // Fall through to cosmos search.
+async function findChildUtxIdFromExternalTx(ctx, externalTxHash, sourceChain) {
+    // Primary: detector-based deterministic derivation.
+    if (sourceChain) {
+        try {
+            const detection = await (0, detector_1.detectUniversalTx)(externalTxHash, sourceChain, {
+                pushClient: ctx.pushClient,
+                rpcUrls: ctx.rpcUrls,
+                skipPushChainLookup: true,
+            });
+            const resolutions = await (0, child_inbounds_1.resolveChildInboundsFromDetection)(ctx.pushClient, detection);
+            // Pick the R3 return-trip child: prefer UniversalTx over RevertUniversalTx.
+            const match = resolutions.find((r) => r.sourceEventName === 'UniversalTx') ??
+                resolutions[0];
+            if (match?.universalTxId) {
+                (0, context_1.printLog)(ctx, `[findChildUtxIdFromExternalTx] detector derived utxId ${match.universalTxId} for ${externalTxHash} on ${sourceChain}`);
+                return { utxId: ensureHex(match.universalTxId), derivedFrom: 'detector' };
             }
         }
-        // Fallback: cosmos text search (original path).
-        try {
-            const query = `universal_tx_created.inbound_tx_hash='${externalTxHash}'`;
-            const results = yield ctx.pushClient.searchCosmosByQuery(query);
-            for (const tx of results) {
-                for (const event of (_b = tx.events) !== null && _b !== void 0 ? _b : []) {
-                    if (event.type === 'universal_tx_created' ||
-                        event.type === 'outbound_created') {
-                        for (const attr of (_c = event.attributes) !== null && _c !== void 0 ? _c : []) {
-                            if (attr.key === 'utx_id' && attr.value) {
-                                return {
-                                    utxId: ensureHex(attr.value),
-                                    derivedFrom: 'cosmos-fallback',
-                                };
-                            }
+        catch (err) {
+            const wrapped = err instanceof Error ? err : new Error(String(err));
+            (0, context_1.printLog)(ctx, `[findChildUtxIdFromExternalTx] detector path failed: ${wrapped.message} — falling back to cosmos search`);
+            // Fall through to cosmos search.
+        }
+    }
+    // Fallback: cosmos text search (original path).
+    try {
+        const query = `universal_tx_created.inbound_tx_hash='${externalTxHash}'`;
+        const results = await ctx.pushClient.searchCosmosByQuery(query);
+        for (const tx of results) {
+            for (const event of tx.events ?? []) {
+                if (event.type === 'universal_tx_created' ||
+                    event.type === 'outbound_created') {
+                    for (const attr of event.attributes ?? []) {
+                        if (attr.key === 'utx_id' && attr.value) {
+                            return {
+                                utxId: ensureHex(attr.value),
+                                derivedFrom: 'cosmos-fallback',
+                            };
                         }
                     }
                 }
             }
-            return { utxId: null };
-        }
-        catch (err) {
-            const wrapped = err instanceof Error ? err : new Error(String(err));
-            (0, context_1.printLog)(ctx, `[findChildUtxIdFromExternalTx] cosmos fallback also failed: ${wrapped.message}`);
-            return { utxId: null, error: wrapped };
         }
-    });
+        return { utxId: null };
+    }
+    catch (err) {
+        const wrapped = err instanceof Error ? err : new Error(String(err));
+        (0, context_1.printLog)(ctx, `[findChildUtxIdFromExternalTx] cosmos fallback also failed: ${wrapped.message}`);
+        return { utxId: null, error: wrapped };
+    }
 }
 /**
  * Polls Push Chain for the inbound tx that closes an R3 round-trip.
@@ -110,91 +107,155 @@ function findChildUtxIdFromExternalTx(ctx, externalTxHash, sourceChain) {
  * rejects with a Timeout error if neither child UTX nor terminal state is
  * observed within the configured timeout.
  */
-function waitForInboundPushTx(ctx_1, outboundExternalTxHash_1, sourceChain_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (ctx, outboundExternalTxHash, sourceChain, opts = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        const initialWaitMs = (_a = opts.initialWaitMs) !== null && _a !== void 0 ? _a : 30000;
-        const pollingIntervalMs = (_b = opts.pollingIntervalMs) !== null && _b !== void 0 ? _b : 5000;
-        const timeout = (_c = opts.timeout) !== null && _c !== void 0 ? _c : 300000;
-        const progressHook = opts.progressHook;
-        const startedAt = Date.now();
-        const elapsed = () => Date.now() - startedAt;
-        (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Starting | externalTxHash: ${outboundExternalTxHash} | sourceChain: ${sourceChain} | initialWait: ${initialWaitMs}ms | pollInterval: ${pollingIntervalMs}ms | timeout: ${timeout}ms`);
-        progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'waiting', elapsedMs: 0 });
-        if (initialWaitMs > 0) {
-            (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Initial wait of ${initialWaitMs}ms...`);
-            yield new Promise((r) => setTimeout(r, Math.min(initialWaitMs, timeout)));
-            (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Initial wait done. Starting polling. Elapsed: ${elapsed()}ms`);
+async function waitForInboundPushTx(ctx, outboundExternalTxHash, sourceChain, opts = {}) {
+    const initialWaitMs = opts.initialWaitMs ?? 30000;
+    const pollingIntervalMs = opts.pollingIntervalMs ?? 5000;
+    const timeout = opts.timeout ?? 300000;
+    const progressHook = opts.progressHook;
+    const startedAt = Date.now();
+    const elapsed = () => Date.now() - startedAt;
+    (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Starting | externalTxHash: ${outboundExternalTxHash} | sourceChain: ${sourceChain} | initialWait: ${initialWaitMs}ms | pollInterval: ${pollingIntervalMs}ms | timeout: ${timeout}ms`);
+    progressHook?.({ status: 'waiting', elapsedMs: 0 });
+    if (initialWaitMs > 0) {
+        (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Initial wait of ${initialWaitMs}ms...`);
+        await new Promise((r) => setTimeout(r, Math.min(initialWaitMs, timeout)));
+        (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Initial wait done. Starting polling. Elapsed: ${elapsed()}ms`);
+    }
+    let childUtxId = null;
+    let strippedChildUtxId;
+    let pushTxHash;
+    let lastEmittedStatus;
+    let consecutiveRpcErrors = 0;
+    let pendingTerminalSuccessRetries = 0;
+    let pollCount = 0;
+    // Heuristic threshold — log a distinct warning when this many back-to-back
+    // RPC failures happen so callers can see the difference between
+    // "indexer hasn't seen it yet" and "RPC is down."
+    const RPC_FAILURE_WARN_THRESHOLD = 5;
+    // When chain reports terminal success but pcTx hasn't populated yet, give
+    // the indexer one extra poll cycle to catch up before returning empty hash.
+    const MAX_PENDING_TERMINAL_RETRIES = 2;
+    while (elapsed() < timeout) {
+        pollCount++;
+        const pollStart = Date.now();
+        (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Poll #${pollCount} | Elapsed: ${elapsed()}ms / ${timeout}ms | phase: ${childUtxId ? 'utx-status' : 'child-search'}`);
+        // Phase 1 — find child UTX id from the outbound external tx hash
+        if (!childUtxId) {
+            const search = await findChildUtxIdFromExternalTx(ctx, outboundExternalTxHash, sourceChain);
+            (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Poll #${pollCount} child-search result: utxId=${search.utxId ?? 'null'}${search.error ? ` error=${search.error.message}` : ''}`);
+            if (search.error) {
+                consecutiveRpcErrors++;
+                if (consecutiveRpcErrors === RPC_FAILURE_WARN_THRESHOLD) {
+                    (0, context_1.printLog)(ctx, `[waitForInboundPushTx] ${RPC_FAILURE_WARN_THRESHOLD} consecutive Cosmos search errors — RPC may be unhealthy. Continuing until timeout.`);
+                }
+            }
+            else {
+                consecutiveRpcErrors = 0;
+                if (search.utxId) {
+                    childUtxId = search.utxId;
+                    strippedChildUtxId = stripHex(childUtxId);
+                    progressHook?.({
+                        status: 'found',
+                        elapsedMs: elapsed(),
+                        childUtxId,
+                    });
+                    lastEmittedStatus = 'found';
+                }
+                else if (lastEmittedStatus !== 'polling') {
+                    progressHook?.({ status: 'polling', elapsedMs: elapsed() });
+                    lastEmittedStatus = 'polling';
+                }
+            }
         }
-        let childUtxId = null;
-        let strippedChildUtxId;
-        let pushTxHash;
-        let lastEmittedStatus;
-        let consecutiveRpcErrors = 0;
-        let pendingTerminalSuccessRetries = 0;
-        let pollCount = 0;
-        // Heuristic threshold — log a distinct warning when this many back-to-back
-        // RPC failures happen so callers can see the difference between
-        // "indexer hasn't seen it yet" and "RPC is down."
-        const RPC_FAILURE_WARN_THRESHOLD = 5;
-        // When chain reports terminal success but pcTx hasn't populated yet, give
-        // the indexer one extra poll cycle to catch up before returning empty hash.
-        const MAX_PENDING_TERMINAL_RETRIES = 2;
-        while (elapsed() < timeout) {
-            pollCount++;
-            const pollStart = Date.now();
-            (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Poll #${pollCount} | Elapsed: ${elapsed()}ms / ${timeout}ms | phase: ${childUtxId ? 'utx-status' : 'child-search'}`);
-            // Phase 1 — find child UTX id from the outbound external tx hash
-            if (!childUtxId) {
-                const search = yield findChildUtxIdFromExternalTx(ctx, outboundExternalTxHash, sourceChain);
-                (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Poll #${pollCount} child-search result: utxId=${(_d = search.utxId) !== null && _d !== void 0 ? _d : 'null'}${search.error ? ` error=${search.error.message}` : ''}`);
-                if (search.error) {
-                    consecutiveRpcErrors++;
-                    if (consecutiveRpcErrors === RPC_FAILURE_WARN_THRESHOLD) {
-                        (0, context_1.printLog)(ctx, `[waitForInboundPushTx] ${RPC_FAILURE_WARN_THRESHOLD} consecutive Cosmos search errors — RPC may be unhealthy. Continuing until timeout.`);
-                    }
+        // Phase 2 — once we have the child UTX, query its status until terminal
+        if (childUtxId && strippedChildUtxId) {
+            try {
+                const response = await ctx.pushClient.getUniversalTxByIdV2(strippedChildUtxId);
+                consecutiveRpcErrors = 0;
+                const utx = response?.universalTx;
+                const status = utx?.universalStatus ?? -1;
+                if (utx?.pcTx?.[0]?.txHash) {
+                    pushTxHash = utx.pcTx[0].txHash;
                 }
-                else {
-                    consecutiveRpcErrors = 0;
-                    if (search.utxId) {
-                        childUtxId = search.utxId;
-                        strippedChildUtxId = stripHex(childUtxId);
-                        progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                            status: 'found',
+                (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Poll #${pollCount} utx-status | status: ${status} | pcTx[0].txHash: '${pushTxHash ?? ''}' | pcTx len: ${utx?.pcTx?.length ?? 0}`);
+                const failedPcTx = utx?.pcTx?.find((pcTx) => {
+                    const pcTxStatus = String(pcTx.status || '').toUpperCase();
+                    return pcTxStatus === 'FAILED' || Boolean(pcTx.errorMsg);
+                });
+                if (TERMINAL_SUCCESS_STATUSES.has(status)) {
+                    // Wait one more poll cycle if pcTx hasn't populated yet — the
+                    // indexer occasionally flips status before the pcTx hash is queryable.
+                    if (!pushTxHash && pendingTerminalSuccessRetries < MAX_PENDING_TERMINAL_RETRIES) {
+                        pendingTerminalSuccessRetries++;
+                    }
+                    else {
+                        progressHook?.({
+                            status: 'confirmed',
                             elapsedMs: elapsed(),
                             childUtxId,
+                            pushTxHash,
                         });
-                        lastEmittedStatus = 'found';
-                    }
-                    else if (lastEmittedStatus !== 'polling') {
-                        progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'polling', elapsedMs: elapsed() });
-                        lastEmittedStatus = 'polling';
+                        return {
+                            childUtxId,
+                            pushTxHash: pushTxHash ?? '',
+                            sourceChain,
+                            outboundExternalTxHash,
+                            status: 'confirmed',
+                        };
                     }
                 }
-            }
-            // Phase 2 — once we have the child UTX, query its status until terminal
-            if (childUtxId && strippedChildUtxId) {
-                try {
-                    const response = yield ctx.pushClient.getUniversalTxByIdV2(strippedChildUtxId);
-                    consecutiveRpcErrors = 0;
-                    const utx = response === null || response === void 0 ? void 0 : response.universalTx;
-                    const status = (_e = utx === null || utx === void 0 ? void 0 : utx.universalStatus) !== null && _e !== void 0 ? _e : -1;
-                    if ((_g = (_f = utx === null || utx === void 0 ? void 0 : utx.pcTx) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.txHash) {
-                        pushTxHash = utx.pcTx[0].txHash;
-                    }
-                    (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Poll #${pollCount} utx-status | status: ${status} | pcTx[0].txHash: '${pushTxHash !== null && pushTxHash !== void 0 ? pushTxHash : ''}' | pcTx len: ${(_j = (_h = utx === null || utx === void 0 ? void 0 : utx.pcTx) === null || _h === void 0 ? void 0 : _h.length) !== null && _j !== void 0 ? _j : 0}`);
-                    const failedPcTx = (_k = utx === null || utx === void 0 ? void 0 : utx.pcTx) === null || _k === void 0 ? void 0 : _k.find((pcTx) => {
-                        const pcTxStatus = String(pcTx.status || '').toUpperCase();
-                        return pcTxStatus === 'FAILED' || Boolean(pcTx.errorMsg);
+                else if (TERMINAL_FAILURE_STATUSES.has(status)) {
+                    const errMsg = failedPcTx?.errorMsg
+                        ? (0, formatters_1.normalizePcInsufficientFundsError)(failedPcTx.errorMsg)
+                        : `inbound terminated with status ${status}`;
+                    progressHook?.({
+                        status: 'failed',
+                        elapsedMs: elapsed(),
+                        childUtxId,
+                        pushTxHash,
                     });
-                    if (TERMINAL_SUCCESS_STATUSES.has(status)) {
-                        // Wait one more poll cycle if pcTx hasn't populated yet — the
-                        // indexer occasionally flips status before the pcTx hash is queryable.
-                        if (!pushTxHash && pendingTerminalSuccessRetries < MAX_PENDING_TERMINAL_RETRIES) {
-                            pendingTerminalSuccessRetries++;
-                        }
-                        else {
-                            progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                    return {
+                        childUtxId,
+                        pushTxHash: pushTxHash ?? '',
+                        sourceChain,
+                        outboundExternalTxHash,
+                        status: 'failed',
+                        errorMessage: errMsg,
+                    };
+                }
+                else if (failedPcTx) {
+                    const errMsg = failedPcTx.errorMsg
+                        ? (0, formatters_1.normalizePcInsufficientFundsError)(failedPcTx.errorMsg)
+                        : `inbound Push tx failed while universalStatus=${status}`;
+                    progressHook?.({
+                        status: 'failed',
+                        elapsedMs: elapsed(),
+                        childUtxId,
+                        pushTxHash,
+                    });
+                    return {
+                        childUtxId,
+                        pushTxHash: pushTxHash ?? '',
+                        sourceChain,
+                        outboundExternalTxHash,
+                        status: 'failed',
+                        errorMessage: errMsg,
+                    };
+                }
+                else if (pushTxHash) {
+                    // Tiebreaker: cosmos has the Push Chain tx hash populated but the
+                    // indexer hasn't transitioned universalStatus to a terminal yet.
+                    // Query Push RPC directly for the receipt — if it's confirmed on
+                    // chain, treat as terminal-success; if it reverted, treat as
+                    // terminal-failure. Cosmos-indexer lag stops blocking us here.
+                    try {
+                        // Archive-fallback variant: a Push-leg receipt outside the prune
+                        // window still resolves via the archive node. On chains without an
+                        // archive endpoint this behaves as a plain prune-only lookup.
+                        const receipt = await ctx.pushClient.getTransactionReceiptWithArchiveFallback(pushTxHash);
+                        if (receipt?.status === 'success') {
+                            (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Push RPC tiebreaker: ${pushTxHash} confirmed on chain (cosmos still status=${status}); treating as terminal-success`);
+                            progressHook?.({
                                 status: 'confirmed',
                                 elapsedMs: elapsed(),
                                 childUtxId,
@@ -202,132 +263,65 @@ function waitForInboundPushTx(ctx_1, outboundExternalTxHash_1, sourceChain_1) {
                             });
                             return {
                                 childUtxId,
-                                pushTxHash: pushTxHash !== null && pushTxHash !== void 0 ? pushTxHash : '',
+                                pushTxHash,
                                 sourceChain,
                                 outboundExternalTxHash,
                                 status: 'confirmed',
                             };
                         }
-                    }
-                    else if (TERMINAL_FAILURE_STATUSES.has(status)) {
-                        const errMsg = (failedPcTx === null || failedPcTx === void 0 ? void 0 : failedPcTx.errorMsg)
-                            ? (0, formatters_1.normalizePcInsufficientFundsError)(failedPcTx.errorMsg)
-                            : `inbound terminated with status ${status}`;
-                        progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                            status: 'failed',
-                            elapsedMs: elapsed(),
-                            childUtxId,
-                            pushTxHash,
-                        });
-                        return {
-                            childUtxId,
-                            pushTxHash: pushTxHash !== null && pushTxHash !== void 0 ? pushTxHash : '',
-                            sourceChain,
-                            outboundExternalTxHash,
-                            status: 'failed',
-                            errorMessage: errMsg,
-                        };
-                    }
-                    else if (failedPcTx) {
-                        const errMsg = failedPcTx.errorMsg
-                            ? (0, formatters_1.normalizePcInsufficientFundsError)(failedPcTx.errorMsg)
-                            : `inbound Push tx failed while universalStatus=${status}`;
-                        progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                            status: 'failed',
-                            elapsedMs: elapsed(),
-                            childUtxId,
-                            pushTxHash,
-                        });
-                        return {
-                            childUtxId,
-                            pushTxHash: pushTxHash !== null && pushTxHash !== void 0 ? pushTxHash : '',
-                            sourceChain,
-                            outboundExternalTxHash,
-                            status: 'failed',
-                            errorMessage: errMsg,
-                        };
-                    }
-                    else if (pushTxHash) {
-                        // Tiebreaker: cosmos has the Push Chain tx hash populated but the
-                        // indexer hasn't transitioned universalStatus to a terminal yet.
-                        // Query Push RPC directly for the receipt — if it's confirmed on
-                        // chain, treat as terminal-success; if it reverted, treat as
-                        // terminal-failure. Cosmos-indexer lag stops blocking us here.
-                        try {
-                            // Archive-fallback variant: a Push-leg receipt outside the prune
-                            // window still resolves via the archive node. On chains without an
-                            // archive endpoint this behaves as a plain prune-only lookup.
-                            const receipt = yield ctx.pushClient.getTransactionReceiptWithArchiveFallback(pushTxHash);
-                            if ((receipt === null || receipt === void 0 ? void 0 : receipt.status) === 'success') {
-                                (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Push RPC tiebreaker: ${pushTxHash} confirmed on chain (cosmos still status=${status}); treating as terminal-success`);
-                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                    status: 'confirmed',
-                                    elapsedMs: elapsed(),
-                                    childUtxId,
-                                    pushTxHash,
-                                });
-                                return {
-                                    childUtxId,
-                                    pushTxHash,
-                                    sourceChain,
-                                    outboundExternalTxHash,
-                                    status: 'confirmed',
-                                };
-                            }
-                            if ((receipt === null || receipt === void 0 ? void 0 : receipt.status) === 'reverted') {
-                                (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Push RPC tiebreaker: ${pushTxHash} REVERTED on chain (cosmos still status=${status}); treating as terminal-failure`);
-                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                    status: 'failed',
-                                    elapsedMs: elapsed(),
-                                    childUtxId,
-                                    pushTxHash,
-                                });
-                                return {
-                                    childUtxId,
-                                    pushTxHash,
-                                    sourceChain,
-                                    outboundExternalTxHash,
-                                    status: 'failed',
-                                    errorMessage: 'Push Chain inbound tx reverted on chain',
-                                };
-                            }
-                            // receipt missing / pending — keep polling.
-                        }
-                        catch (rpcErr) {
-                            // TransactionReceiptNotFoundError means not yet mined — continue
-                            // polling. Other errors get logged but don't break the loop.
-                            const msg = rpcErr instanceof Error ? rpcErr.message : String(rpcErr);
-                            if (!/not found|TransactionReceiptNotFound|could not be found/i.test(msg)) {
-                                (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Push RPC tiebreaker failed for ${pushTxHash}: ${msg}`);
-                            }
+                        if (receipt?.status === 'reverted') {
+                            (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Push RPC tiebreaker: ${pushTxHash} REVERTED on chain (cosmos still status=${status}); treating as terminal-failure`);
+                            progressHook?.({
+                                status: 'failed',
+                                elapsedMs: elapsed(),
+                                childUtxId,
+                                pushTxHash,
+                            });
+                            return {
+                                childUtxId,
+                                pushTxHash,
+                                sourceChain,
+                                outboundExternalTxHash,
+                                status: 'failed',
+                                errorMessage: 'Push Chain inbound tx reverted on chain',
+                            };
                         }
+                        // receipt missing / pending — keep polling.
                     }
-                }
-                catch (err) {
-                    consecutiveRpcErrors++;
-                    if (consecutiveRpcErrors === RPC_FAILURE_WARN_THRESHOLD) {
-                        (0, context_1.printLog)(ctx, `[waitForInboundPushTx] ${RPC_FAILURE_WARN_THRESHOLD} consecutive getUniversalTxByIdV2 errors — RPC may be unhealthy. Continuing until timeout.`);
+                    catch (rpcErr) {
+                        // TransactionReceiptNotFoundError means not yet mined — continue
+                        // polling. Other errors get logged but don't break the loop.
+                        const msg = rpcErr instanceof Error ? rpcErr.message : String(rpcErr);
+                        if (!/not found|TransactionReceiptNotFound|could not be found/i.test(msg)) {
+                            (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Push RPC tiebreaker failed for ${pushTxHash}: ${msg}`);
+                        }
                     }
-                    (0, context_1.printLog)(ctx, `[waitForInboundPushTx] getUniversalTxByIdV2 failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
-                if (lastEmittedStatus !== 'polling') {
-                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                        status: 'polling',
-                        elapsedMs: elapsed(),
-                        childUtxId,
-                    });
-                    lastEmittedStatus = 'polling';
+            }
+            catch (err) {
+                consecutiveRpcErrors++;
+                if (consecutiveRpcErrors === RPC_FAILURE_WARN_THRESHOLD) {
+                    (0, context_1.printLog)(ctx, `[waitForInboundPushTx] ${RPC_FAILURE_WARN_THRESHOLD} consecutive getUniversalTxByIdV2 errors — RPC may be unhealthy. Continuing until timeout.`);
                 }
+                (0, context_1.printLog)(ctx, `[waitForInboundPushTx] getUniversalTxByIdV2 failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            if (lastEmittedStatus !== 'polling') {
+                progressHook?.({
+                    status: 'polling',
+                    elapsedMs: elapsed(),
+                    childUtxId,
+                });
+                lastEmittedStatus = 'polling';
             }
-            if (elapsed() >= timeout)
-                break;
-            (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Poll #${pollCount} not ready (${Date.now() - pollStart}ms). Waiting ${pollingIntervalMs}ms...`);
-            yield new Promise((r) => setTimeout(r, pollingIntervalMs));
         }
-        (0, context_1.printLog)(ctx, `[waitForInboundPushTx] TIMEOUT after ${pollCount} polls | elapsed: ${elapsed()}ms`);
-        progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'timeout', elapsedMs: elapsed() });
-        throw new InboundTimeoutError(outboundExternalTxHash, elapsed());
-    });
+        if (elapsed() >= timeout)
+            break;
+        (0, context_1.printLog)(ctx, `[waitForInboundPushTx] Poll #${pollCount} not ready (${Date.now() - pollStart}ms). Waiting ${pollingIntervalMs}ms...`);
+        await new Promise((r) => setTimeout(r, pollingIntervalMs));
+    }
+    (0, context_1.printLog)(ctx, `[waitForInboundPushTx] TIMEOUT after ${pollCount} polls | elapsed: ${elapsed()}ms`);
+    progressHook?.({ status: 'timeout', elapsedMs: elapsed() });
+    throw new InboundTimeoutError(outboundExternalTxHash, elapsed());
 }
 /**
  * Thrown by `waitForInboundPushTx` when the polling loop exceeds the
@@ -336,9 +330,11 @@ function waitForInboundPushTx(ctx_1, outboundExternalTxHash_1, sourceChain_1) {
  * from generic failure (→ 399-02) without relying on error-message prefixes.
  */
 class InboundTimeoutError extends Error {
+    code = 'INBOUND_TIMEOUT';
+    correlationKey;
+    elapsedMs;
     constructor(correlationKey, elapsedMs) {
         super(`Timeout waiting for inbound Push tx after ${Math.round(elapsedMs / 1000)}s (correlation key: ${correlationKey}).`);
-        this.code = 'INBOUND_TIMEOUT';
         this.name = 'InboundTimeoutError';
         this.correlationKey = correlationKey;
         this.elapsedMs = elapsedMs;