@pushchain/core 6.0.19 → 6.0.21

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

@@ -6,6 +6,7 @@
  * transformToUniversalTxResponse, and the ResponseBuilderCallbacks interface.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPC20GatewayLogIndex = findPC20GatewayLogIndex;
 exports.queryUniversalTxStatusFromGatewayTx = queryUniversalTxStatusFromGatewayTx;
 exports.resolveUniversalTxFromSourceHash = resolveUniversalTxFromSourceHash;
 exports.trackTransaction = trackTransaction;
@@ -14,6 +15,8 @@ const tslib_1 = require("tslib");
 const bs58_1 = require("../../internal/bs58");
 const web3_js_1 = require("@solana/web3.js");
 const viem_1 = require("viem");
+const events_1 = require("../../universal-tx-detector/events");
+const export_1 = require("./pc20/export");
 const uea_evm_1 = require("../../constants/abi/uea.evm");
 const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
@@ -47,119 +50,166 @@ function fanOut(event, primary, secondary) {
 // ============================================================================
 // queryUniversalTxStatusFromGatewayTx
 // ============================================================================
-function queryUniversalTxStatusFromGatewayTx(ctx, evmClient, gatewayAddress, 
-// DEBUG: section marker added
-txHash, evmGatewayMethod) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+/**
+ * Pick the gateway log whose event is the PC20 burn — the leg that carries the
+ * user's transfer.
+ *
+ * A PC20 return with a prepaid gas deposit makes the gateway emit TWO
+ * `UniversalTx` events from one user tx: the PC20 burn (payload prefixed with
+ * the `PC20` selector) and, second, a plain FUNDS event for the attached
+ * native value. Each becomes its own UTX on Push. The default "last gateway
+ * log" heuristic therefore selects the *fee-credit* leg, so a failure there
+ * (see the known fee-credit bug) is reported as the whole transfer failing —
+ * even though the tokens arrived via the first leg.
+ *
+ * Identification is by payload prefix rather than log order: the selector is
+ * what the gateway itself stamps on the PC20 leg, so it stays correct if the
+ * emission order ever changes. Returns null when no PC20 leg is present, and
+ * the caller keeps its existing behaviour.
+ */
+function findPC20GatewayLogIndex(ctx, gatewayLogs) {
+    for (let i = 0; i < gatewayLogs.length; i++) {
+        const log = gatewayLogs[i];
         try {
-            const chain = ctx.universalSigner.account.chain;
-            const { vm } = chain_1.CHAIN_INFO[chain];
-            let logIndexStr = '0';
-            let txHashHex = txHash;
-            if (vm === enums_1.VM.EVM) {
-                if (!evmClient || !gatewayAddress)
-                    throw new Error('Missing EVM context');
-                let receipt;
-                try {
-                    receipt = yield evmClient.publicClient.getTransactionReceipt({
-                        hash: txHash,
-                    });
-                }
-                catch (_c) {
-                    // Receipt might not be indexed yet on this RPC; wait briefly for it
-                    receipt = yield evmClient.publicClient.waitForTransactionReceipt({
-                        hash: txHash,
-                        confirmations: 0,
-                        timeout: chain_1.CHAIN_INFO[chain].timeout,
-                    });
-                }
-                const gatewayLogs = (receipt.logs || []).filter((l) => (l.address || '').toLowerCase() === gatewayAddress.toLowerCase());
-                (0, context_1.printLog)(ctx, `queryUniversalTxStatus — receipt logs count: ${(_a = receipt.logs) === null || _a === void 0 ? void 0 : _a.length}, gateway logs count: ${gatewayLogs.length}, evmGatewayMethod: ${evmGatewayMethod}`);
-                (0, context_1.printLog)(ctx, 'queryUniversalTxStatus — gatewayLogs: ' + JSON.stringify(gatewayLogs.map((l) => { var _a; return ({ address: l.address, logIndex: l.logIndex, topics: (_a = l.topics) === null || _a === void 0 ? void 0 : _a[0] }); }), null, 2));
-                // Use the last gateway log to derive the log index
-                const logIndexToUse = gatewayLogs.length - 1;
-                const firstLog = (gatewayLogs[logIndexToUse] ||
-                    (receipt.logs || []).at(-1));
-                const logIndexVal = (_b = firstLog === null || firstLog === void 0 ? void 0 : firstLog.logIndex) !== null && _b !== void 0 ? _b : 0;
-                (0, context_1.printLog)(ctx, `queryUniversalTxStatus — logIndexToUse: ${logIndexToUse}, firstLog.logIndex: ${firstLog === null || firstLog === void 0 ? void 0 : firstLog.logIndex}, logIndexVal: ${logIndexVal}`);
-                logIndexStr =
-                    typeof logIndexVal === 'bigint'
-                        ? logIndexVal.toString()
-                        : String(logIndexVal);
+            const decoded = (0, viem_1.decodeEventLog)({
+                abi: [events_1.EVENT_UNIVERSAL_TX],
+                data: log.data,
+                topics: log.topics,
+            });
+            const payload = decoded.args?.payload;
+            if (typeof payload === 'string' &&
+                payload.toLowerCase().startsWith(export_1.PC20_SELECTOR.toLowerCase())) {
+                (0, context_1.printLog)(ctx, `queryUniversalTxStatus — PC20 leg found at gateway log ${i} ` +
+                    `(logIndex ${String(log.logIndex)}); tracking it instead of the last log`);
+                return i;
             }
-            else if (vm === enums_1.VM.SVM) {
-                // Normalize Solana signature to 0x-hex for ID composition
-                let txSignature = txHash;
-                if (!txHash.startsWith('0x')) {
-                    const decoded = bs58_1.bs58.decode(txHash);
-                    txHashHex = (0, viem_1.bytesToHex)(new Uint8Array(decoded));
-                }
-                else {
-                    // When provided as hex, convert to base58 for RPC
-                    const hex = txHash.slice(2);
-                    const bytes = Uint8Array.from(Buffer.from(hex, 'hex'));
-                    txSignature = bs58_1.bs58.encode(Buffer.from(bytes));
-                }
-                // Fetch transaction by initializing a Connection and calling Solana RPC
-                const rpcUrls = ctx.rpcUrls[chain] || chain_1.CHAIN_INFO[chain].defaultRPC;
-                const connection = new web3_js_1.Connection(rpcUrls[0], 'confirmed');
-                const txResp = yield connection.getTransaction(txSignature, {
-                    maxSupportedTransactionVersion: 0,
-                    commitment: 'confirmed',
+        }
+        catch {
+            // Not a UniversalTx event (or an ABI we do not model) — skip it.
+        }
+    }
+    return null;
+}
+async function queryUniversalTxStatusFromGatewayTx(ctx, evmClient, gatewayAddress, 
+// DEBUG: section marker added
+txHash, evmGatewayMethod, 
+/**
+ * Set for PC20 imports (wrapper burns). Selects the PC20 burn leg rather
+ * than the last gateway log — see {@link findPC20GatewayLogIndex}.
+ */
+preferPC20Log = false) {
+    try {
+        const chain = ctx.universalSigner.account.chain;
+        const { vm } = chain_1.CHAIN_INFO[chain];
+        let logIndexStr = '0';
+        let txHashHex = txHash;
+        if (vm === enums_1.VM.EVM) {
+            if (!evmClient || !gatewayAddress)
+                throw new Error('Missing EVM context');
+            let receipt;
+            try {
+                receipt = await evmClient.publicClient.getTransactionReceipt({
+                    hash: txHash,
                 });
-                // Derive proper log index using discriminator matching
-                const svmLogIndex = (0, svm_helpers_1.getSvmGatewayLogIndexFromTx)(txResp);
-                logIndexStr = String(svmLogIndex);
             }
-            const sourceChain = `${chain_1.VM_NAMESPACE[vm]}:${chain_1.CHAIN_INFO[chain].chainId}`;
-            // ID = sha256("${sourceChain}:${txHash}:${logIndex}") as hex string (no 0x)
-            const idInput = `${sourceChain}:${txHashHex}:${logIndexStr}`;
-            const idHex = (0, viem_1.sha256)((0, viem_1.stringToBytes)(idInput)).slice(2);
-            (0, context_1.printLog)(ctx, 'Query ID extraction: ' + JSON.stringify({
-                sourceChain,
-                txHashHex,
-                logIndexStr,
-                idInput,
-                idHex,
-            }, null, 2));
-            // Fetch UniversalTx via gRPC with linear-then-exponential retry
-            const LINEAR_ATTEMPTS = 10;
-            const LINEAR_DELAY_MS = 3600;
-            const EXPONENTIAL_BASE_MS = 4800;
-            const MAX_ATTEMPTS = 15;
-            let universalTxObj;
-            for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
-                (0, context_1.printLog)(ctx, `[Sync] Attempt ${attempt + 1}/${MAX_ATTEMPTS} | Query ID: ${idHex}`);
-                try {
-                    const universalTxResp = yield ctx.pushClient.getUniversalTxById(idHex);
-                    universalTxObj = universalTxResp === null || universalTxResp === void 0 ? void 0 : universalTxResp.universalTx;
-                    if (universalTxObj) {
-                        break;
-                    }
-                }
-                catch (error) {
-                    // ignore and retry
-                }
-                // Linear delay for first N attempts, then exponential backoff
-                let delay;
-                if (attempt < LINEAR_ATTEMPTS) {
-                    delay = LINEAR_DELAY_MS;
-                }
-                else {
-                    // Exponential: 2000, 4000, 8000, 16000, ...
-                    const exponentialAttempt = attempt - LINEAR_ATTEMPTS;
-                    delay = EXPONENTIAL_BASE_MS * Math.pow(2, exponentialAttempt);
-                }
-                yield new Promise((r) => setTimeout(r, delay));
+            catch {
+                // Receipt might not be indexed yet on this RPC; wait briefly for it
+                receipt = await evmClient.publicClient.waitForTransactionReceipt({
+                    hash: txHash,
+                    confirmations: 0,
+                    timeout: chain_1.CHAIN_INFO[chain].timeout,
+                });
             }
-            return universalTxObj;
+            const gatewayLogs = (receipt.logs || []).filter((l) => (l.address || '').toLowerCase() === gatewayAddress.toLowerCase());
+            (0, context_1.printLog)(ctx, `queryUniversalTxStatus — receipt logs count: ${receipt.logs?.length}, gateway logs count: ${gatewayLogs.length}, evmGatewayMethod: ${evmGatewayMethod}`);
+            (0, context_1.printLog)(ctx, 'queryUniversalTxStatus — gatewayLogs: ' + JSON.stringify(gatewayLogs.map((l) => ({ address: l.address, logIndex: l.logIndex, topics: l.topics?.[0] })), null, 2));
+            // Use the last gateway log to derive the log index, except for a PC20
+            // import, where the last log is the fee-credit leg rather than the
+            // user's transfer (see findPC20GatewayLogIndex).
+            const pc20LogIndex = preferPC20Log
+                ? findPC20GatewayLogIndex(ctx, gatewayLogs)
+                : null;
+            const logIndexToUse = pc20LogIndex ?? gatewayLogs.length - 1;
+            const firstLog = (gatewayLogs[logIndexToUse] ||
+                (receipt.logs || []).at(-1));
+            const logIndexVal = firstLog?.logIndex ?? 0;
+            (0, context_1.printLog)(ctx, `queryUniversalTxStatus — logIndexToUse: ${logIndexToUse}, firstLog.logIndex: ${firstLog?.logIndex}, logIndexVal: ${logIndexVal}`);
+            logIndexStr =
+                typeof logIndexVal === 'bigint'
+                    ? logIndexVal.toString()
+                    : String(logIndexVal);
         }
-        catch (err) {
-            (0, context_1.printLog)(ctx, `queryUniversalTxStatusFromGatewayTx failed: ${err instanceof Error ? err.message : String(err)}`);
-            return undefined;
+        else if (vm === enums_1.VM.SVM) {
+            // Normalize Solana signature to 0x-hex for ID composition
+            let txSignature = txHash;
+            if (!txHash.startsWith('0x')) {
+                const decoded = bs58_1.bs58.decode(txHash);
+                txHashHex = (0, viem_1.bytesToHex)(new Uint8Array(decoded));
+            }
+            else {
+                // When provided as hex, convert to base58 for RPC
+                const hex = txHash.slice(2);
+                const bytes = Uint8Array.from(Buffer.from(hex, 'hex'));
+                txSignature = bs58_1.bs58.encode(Buffer.from(bytes));
+            }
+            // Fetch transaction by initializing a Connection and calling Solana RPC
+            const rpcUrls = ctx.rpcUrls[chain] || chain_1.CHAIN_INFO[chain].defaultRPC;
+            const connection = new web3_js_1.Connection(rpcUrls[0], 'confirmed');
+            const txResp = await connection.getTransaction(txSignature, {
+                maxSupportedTransactionVersion: 0,
+                commitment: 'confirmed',
+            });
+            // Derive proper log index using discriminator matching
+            const svmLogIndex = (0, svm_helpers_1.getSvmGatewayLogIndexFromTx)(txResp, preferPC20Log);
+            logIndexStr = String(svmLogIndex);
         }
-    });
+        const sourceChain = `${chain_1.VM_NAMESPACE[vm]}:${chain_1.CHAIN_INFO[chain].chainId}`;
+        // ID = sha256("${sourceChain}:${txHash}:${logIndex}") as hex string (no 0x)
+        const idInput = `${sourceChain}:${txHashHex}:${logIndexStr}`;
+        const idHex = (0, viem_1.sha256)((0, viem_1.stringToBytes)(idInput)).slice(2);
+        (0, context_1.printLog)(ctx, 'Query ID extraction: ' + JSON.stringify({
+            sourceChain,
+            txHashHex,
+            logIndexStr,
+            idInput,
+            idHex,
+        }, null, 2));
+        // Fetch UniversalTx via gRPC with linear-then-exponential retry
+        const LINEAR_ATTEMPTS = 10;
+        const LINEAR_DELAY_MS = 3600;
+        const EXPONENTIAL_BASE_MS = 4800;
+        const MAX_ATTEMPTS = 15;
+        let universalTxObj;
+        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            (0, context_1.printLog)(ctx, `[Sync] Attempt ${attempt + 1}/${MAX_ATTEMPTS} | Query ID: ${idHex}`);
+            try {
+                const universalTxResp = await ctx.pushClient.getUniversalTxById(idHex);
+                universalTxObj = universalTxResp?.universalTx;
+                if (universalTxObj) {
+                    break;
+                }
+            }
+            catch (error) {
+                // ignore and retry
+            }
+            // Linear delay for first N attempts, then exponential backoff
+            let delay;
+            if (attempt < LINEAR_ATTEMPTS) {
+                delay = LINEAR_DELAY_MS;
+            }
+            else {
+                // Exponential: 2000, 4000, 8000, 16000, ...
+                const exponentialAttempt = attempt - LINEAR_ATTEMPTS;
+                delay = EXPONENTIAL_BASE_MS * Math.pow(2, exponentialAttempt);
+            }
+            await new Promise((r) => setTimeout(r, delay));
+        }
+        return universalTxObj;
+    }
+    catch (err) {
+        (0, context_1.printLog)(ctx, `queryUniversalTxStatusFromGatewayTx failed: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
 }
 // ============================================================================
 // trackTransaction
@@ -182,342 +232,320 @@ const PUSH_CHAINS = new Set([
  * the universal record and its first Push pcTx so the caller can reconstruct
  * from the Push side.
  */
-function resolveUniversalTxFromSourceHash(ctx, sourceHash, sourceChain, rpcUrls) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const detection = yield (0, detector_1.detectUniversalTx)(sourceHash, sourceChain, {
-            pushClient: ctx.pushClient,
-            rpcUrls: Object.assign(Object.assign({}, ctx.rpcUrls), rpcUrls),
-            // We do our own getUniversalTxByIdV2 below; the detector's cosmos
-            // cross-ref can come back empty for SVM even when the record exists.
-            skipPushChainLookup: true,
-        });
-        const utxId = detection.decoded.universalTxId;
-        if (!utxId) {
-            throw new Error(`trackTransaction: could not resolve a universal transaction from hash ` +
-                `"${sourceHash}" on ${sourceChain} (detected kind: ${detection.kind}). ` +
-                `Pass the Push Chain root hash, or a source hash that emitted a ` +
-                `UniversalTx event.`);
-        }
-        const utxResponse = yield ctx.pushClient.getUniversalTxByIdV2(utxId);
-        const universalTxData = utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx;
-        if (!universalTxData) {
-            throw new Error(`trackTransaction: resolved universalTxId ${utxId} from ${sourceChain} ` +
-                `hash "${sourceHash}", but no universal transaction record exists on ` +
-                `Push Chain yet (it may still be relaying).`);
-        }
-        const pushTxHash = (_b = (_a = universalTxData.pcTx) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.txHash;
-        if (!pushTxHash) {
-            throw new Error(`trackTransaction: universal tx ${utxId} (from ${sourceChain} hash ` +
-                `"${sourceHash}") has no Push Chain tx recorded yet.`);
-        }
-        return { universalTxData, pushTxHash, sourceSender: detection.decoded.sender };
+async function resolveUniversalTxFromSourceHash(ctx, sourceHash, sourceChain, rpcUrls) {
+    const detection = await (0, detector_1.detectUniversalTx)(sourceHash, sourceChain, {
+        pushClient: ctx.pushClient,
+        rpcUrls: { ...ctx.rpcUrls, ...rpcUrls },
+        // We do our own getUniversalTxByIdV2 below; the detector's cosmos
+        // cross-ref can come back empty for SVM even when the record exists.
+        skipPushChainLookup: true,
     });
+    const utxId = detection.decoded.universalTxId;
+    if (!utxId) {
+        throw new Error(`trackTransaction: could not resolve a universal transaction from hash ` +
+            `"${sourceHash}" on ${sourceChain} (detected kind: ${detection.kind}). ` +
+            `Pass the Push Chain root hash, or a source hash that emitted a ` +
+            `UniversalTx event.`);
+    }
+    const utxResponse = await ctx.pushClient.getUniversalTxByIdV2(utxId);
+    const universalTxData = utxResponse?.universalTx;
+    if (!universalTxData) {
+        throw new Error(`trackTransaction: resolved universalTxId ${utxId} from ${sourceChain} ` +
+            `hash "${sourceHash}", but no universal transaction record exists on ` +
+            `Push Chain yet (it may still be relaying).`);
+    }
+    const pushTxHash = universalTxData.pcTx?.[0]?.txHash;
+    if (!pushTxHash) {
+        throw new Error(`trackTransaction: universal tx ${utxId} (from ${sourceChain} hash ` +
+            `"${sourceHash}") has no Push Chain tx recorded yet.`);
+    }
+    return { universalTxData, pushTxHash, sourceSender: detection.decoded.sender };
 }
-function trackTransaction(ctx, txHash, options, callbacks) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        if (!callbacks) {
-            throw new Error('trackTransaction requires ResponseBuilderCallbacks');
-        }
-        const { chain = (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork), progressHook, waitForCompletion = true, advanced = {}, } = options !== null && options !== void 0 ? options : {};
-        // Fail fast on an unsupported `chain`. It defaults to Push Chain when the
-        // caller omits it; an explicitly-passed value that isn't a known CHAIN_INFO
-        // entry (a raw numeric chainId, a typo, or a chain from a plain-JS caller
-        // that skips the CHAIN type) would otherwise throw an opaque "Cannot read
-        // properties of undefined (reading 'defaultRPC')" at the RPC lookup below.
-        if (!chain_1.CHAIN_INFO[chain]) {
-            throw new Error(`trackTransaction: unsupported chain "${String(chain)}". Pass a ` +
-                `PushChain.CONSTANTS.CHAIN value. Supported: ${Object.keys(chain_1.CHAIN_INFO).join(', ')}`);
-        }
-        const { timeout = 300000, pollingIntervalMs = 1000, rpcUrls = {} } = advanced;
-        // Source-hash mode: a non-Push `chain` means `txHash` is an origin/source-leg
-        // hash (a Sepolia tx hash, a Solana signature, …), not a Push Chain hash.
-        // Resolve it to the universal record + its Push pcTx via the detector, then
-        // reconstruct from the Push side. Push-native tracking (below) is unchanged.
-        let preResolvedUtxData;
-        let sourceOriginChain;
-        let sourceSender;
-        let trackChain = chain;
-        let trackHash = txHash;
-        if (!PUSH_CHAINS.has(chain)) {
-            const resolved = yield resolveUniversalTxFromSourceHash(ctx, txHash, chain, rpcUrls);
-            preResolvedUtxData = resolved.universalTxData;
-            sourceOriginChain = chain;
-            sourceSender = resolved.sourceSender;
-            trackHash = resolved.pushTxHash;
-            trackChain = (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork);
+async function trackTransaction(ctx, txHash, options, callbacks) {
+    if (!callbacks) {
+        throw new Error('trackTransaction requires ResponseBuilderCallbacks');
+    }
+    const { chain = (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork), progressHook, waitForCompletion = true, advanced = {}, } = options ?? {};
+    // Fail fast on an unsupported `chain`. It defaults to Push Chain when the
+    // caller omits it; an explicitly-passed value that isn't a known CHAIN_INFO
+    // entry (a raw numeric chainId, a typo, or a chain from a plain-JS caller
+    // that skips the CHAIN type) would otherwise throw an opaque "Cannot read
+    // properties of undefined (reading 'defaultRPC')" at the RPC lookup below.
+    if (!chain_1.CHAIN_INFO[chain]) {
+        throw new Error(`trackTransaction: unsupported chain "${String(chain)}". Pass a ` +
+            `PushChain.CONSTANTS.CHAIN value. Supported: ${Object.keys(chain_1.CHAIN_INFO).join(', ')}`);
+    }
+    const { timeout = 300000, pollingIntervalMs = 1000, rpcUrls = {} } = advanced;
+    // Source-hash mode: a non-Push `chain` means `txHash` is an origin/source-leg
+    // hash (a Sepolia tx hash, a Solana signature, …), not a Push Chain hash.
+    // Resolve it to the universal record + its Push pcTx via the detector, then
+    // reconstruct from the Push side. Push-native tracking (below) is unchanged.
+    let preResolvedUtxData;
+    let sourceOriginChain;
+    let sourceSender;
+    let trackChain = chain;
+    let trackHash = txHash;
+    if (!PUSH_CHAINS.has(chain)) {
+        const resolved = await resolveUniversalTxFromSourceHash(ctx, txHash, chain, rpcUrls);
+        preResolvedUtxData = resolved.universalTxData;
+        sourceOriginChain = chain;
+        sourceSender = resolved.sourceSender;
+        trackHash = resolved.pushTxHash;
+        trackChain = (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork);
+    }
+    // Event buffer for replay via response.progressHook()
+    const eventBuffer = [];
+    // Helper to emit progress events. Per-tx hook (passed to trackTransaction)
+    // fires first, then the orchestrator-level hook — deduped via `fanOut` so
+    // a caller that wires the same callback at both levels isn't double-fired.
+    const emitProgress = (event) => {
+        eventBuffer.push(event);
+        (0, context_1.printLog)(ctx, event.message);
+        fanOut(event, progressHook, ctx.progressHook);
+    };
+    // Create client for target chain with optional RPC override. In source-hash
+    // mode `trackChain` is Push (the resolved pcTx lives on Push Chain).
+    const chainRPCs = rpcUrls[trackChain] ||
+        ctx.rpcUrls[trackChain] ||
+        chain_1.CHAIN_INFO[trackChain].defaultRPC;
+    const client = new push_client_1.PushClient({
+        rpcUrls: chainRPCs,
+        network: ctx.pushNetwork,
+    });
+    // Poll for transaction
+    const start = Date.now();
+    let tx;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            tx = await client.getTransaction(trackHash);
+            break; // Found transaction
         }
-        // Event buffer for replay via response.progressHook()
-        const eventBuffer = [];
-        // Helper to emit progress events. Per-tx hook (passed to trackTransaction)
-        // fires first, then the orchestrator-level hook — deduped via `fanOut` so
-        // a caller that wires the same callback at both levels isn't double-fired.
-        const emitProgress = (event) => {
-            eventBuffer.push(event);
-            (0, context_1.printLog)(ctx, event.message);
-            fanOut(event, progressHook, ctx.progressHook);
-        };
-        // Create client for target chain with optional RPC override. In source-hash
-        // mode `trackChain` is Push (the resolved pcTx lives on Push Chain).
-        const chainRPCs = rpcUrls[trackChain] ||
-            ctx.rpcUrls[trackChain] ||
-            chain_1.CHAIN_INFO[trackChain].defaultRPC;
-        const client = new push_client_1.PushClient({
-            rpcUrls: chainRPCs,
-            network: ctx.pushNetwork,
-        });
-        // Poll for transaction
-        const start = Date.now();
-        let tx;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            try {
-                tx = yield client.getTransaction(trackHash);
-                break; // Found transaction
+        catch (err) {
+            if (!waitForCompletion) {
+                throw new Error(`Transaction ${trackHash} not found`);
             }
-            catch (err) {
-                if (!waitForCompletion) {
-                    throw new Error(`Transaction ${trackHash} not found`);
-                }
-                // Check timeout
-                if (Date.now() - start > timeout) {
-                    throw new Error(`Timeout: transaction ${trackHash} not confirmed within ${timeout}ms`);
-                }
-                // Brief delay before retry
-                yield new Promise((r) => setTimeout(r, pollingIntervalMs));
+            // Check timeout
+            if (Date.now() - start > timeout) {
+                throw new Error(`Timeout: transaction ${trackHash} not confirmed within ${timeout}ms`);
             }
+            // Brief delay before retry
+            await new Promise((r) => setTimeout(r, pollingIntervalMs));
         }
-        // Try to get UniversalTx data for richer progress reconstruction.
-        // In source-hash mode we already resolved the record above; otherwise run the
-        // three-tier lookup: direct hash → computed keccak ID → Cosmos extraction.
-        let universalTxData = preResolvedUtxData;
-        if (!universalTxData) {
-            try {
-                const utxResponse = yield ctx.pushClient.getUniversalTxByIdV2(trackHash);
-                if (utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) {
-                    universalTxData = utxResponse.universalTx;
-                }
-            }
-            catch (_c) {
-                // Ignore - try computed ID next
+    }
+    // Try to get UniversalTx data for richer progress reconstruction.
+    // In source-hash mode we already resolved the record above; otherwise run the
+    // three-tier lookup: direct hash → computed keccak ID → Cosmos extraction.
+    let universalTxData = preResolvedUtxData;
+    if (!universalTxData) {
+        try {
+            const utxResponse = await ctx.pushClient.getUniversalTxByIdV2(trackHash);
+            if (utxResponse?.universalTx) {
+                universalTxData = utxResponse.universalTx;
             }
         }
-        if (!universalTxData) {
-            try {
-                const computedId = (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, trackHash);
-                const queryId = computedId.startsWith('0x') ? computedId.slice(2) : computedId;
-                const utxResponse = yield ctx.pushClient.getUniversalTxByIdV2(queryId);
-                if (utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) {
-                    universalTxData = utxResponse.universalTx;
-                }
-            }
-            catch (_d) {
-                // Ignore - try Cosmos event extraction next
+        catch {
+            // Ignore - try computed ID next
+        }
+    }
+    if (!universalTxData) {
+        try {
+            const computedId = (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, trackHash);
+            const queryId = computedId.startsWith('0x') ? computedId.slice(2) : computedId;
+            const utxResponse = await ctx.pushClient.getUniversalTxByIdV2(queryId);
+            if (utxResponse?.universalTx) {
+                universalTxData = utxResponse.universalTx;
             }
         }
-        if (!universalTxData) {
-            try {
-                const extractedId = yield (0, outbound_tracker_1.extractUniversalSubTxIdFromTx)(ctx, trackHash);
-                if (extractedId) {
-                    const queryId = extractedId.startsWith('0x') ? extractedId.slice(2) : extractedId;
-                    const utxResponse = yield ctx.pushClient.getUniversalTxByIdV2(queryId);
-                    if (utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) {
-                        universalTxData = utxResponse.universalTx;
-                    }
+        catch {
+            // Ignore - try Cosmos event extraction next
+        }
+    }
+    if (!universalTxData) {
+        try {
+            const extractedId = await (0, outbound_tracker_1.extractUniversalSubTxIdFromTx)(ctx, trackHash);
+            if (extractedId) {
+                const queryId = extractedId.startsWith('0x') ? extractedId.slice(2) : extractedId;
+                const utxResponse = await ctx.pushClient.getUniversalTxByIdV2(queryId);
+                if (utxResponse?.universalTx) {
+                    universalTxData = utxResponse.universalTx;
                 }
             }
-            catch (_e) {
-                // Ignore - no universal tx data available
-            }
         }
-        // Transform to UniversalTxResponse
-        const universalTxResponse = yield transformToUniversalTxResponse(ctx, tx, eventBuffer, callbacks);
-        // Detect route from UniversalTxV2 data and set on response
-        // This enables wait() to trigger outbound polling via waitForOutboundTx()
-        const detectedRoute = (0, tx_transformer_1.detectRouteFromUniversalTxData)(universalTxData);
-        if (detectedRoute) {
-            universalTxResponse.route = detectedRoute;
-            // Mirror the route on the context so emission code in wait()/cascade
-            // picks the correct ID range — keeps trackTransaction in lockstep with
-            // sendUniversalTransaction, which sets currentRoute in execute().
-            ctx.currentRoute = detectedRoute;
-            // Populate the destination/source chain on the response so
-            // reconstructR2/R3 (and any downstream emission that reads
-            // universalTxResponse.chain) emit the proper friendly chain name
-            // instead of the "external" fallback. The first outbound's destination
-            // is the target chain for R2 and the source CEA chain for R3.
-            const firstOutboundChain = (_b = (_a = universalTxData === null || universalTxData === void 0 ? void 0 : universalTxData.outboundTx) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.destinationChain;
-            if (firstOutboundChain && !universalTxResponse.chain) {
-                universalTxResponse.chain = firstOutboundChain;
-                universalTxResponse.chainNamespace = firstOutboundChain;
-            }
-            // For R3 replays, enable inbound round-trip tracking so `.wait()` runs
-            // the 310-01 → 399-01 sequence. Live execute sets this in
-            // route-handlers.ts via `amount > 0n`; trackTransaction has no
-            // execute-phase args, so we enable it unconditionally for CEA_TO_PUSH.
-            // The inbound block tolerates no-inbound (payload-only R3) by timing
-            // out — same as live behaviour when the source tx has no round-trip.
-            if (detectedRoute === route_detector_1.TransactionRoute.CEA_TO_PUSH) {
-                universalTxResponse._expectsInboundRoundTrip = true;
-            }
+        catch {
+            // Ignore - no universal tx data available
         }
-        // Source-hash mode: the pcTx we fetched lives on Push Chain, so the
-        // transform resolves chain to the Push side. Surface the true source chain
-        // the caller tracked so `chain`/`chainNamespace` reflect where the universal
-        // tx actually originated. (An outbound-derived chain above, if any, wins.)
-        if (sourceOriginChain && !universalTxResponse.chain) {
-            universalTxResponse.chain = sourceOriginChain;
-            universalTxResponse.chainNamespace = sourceOriginChain;
+    }
+    // Transform to UniversalTxResponse
+    const universalTxResponse = await transformToUniversalTxResponse(ctx, tx, eventBuffer, callbacks);
+    // Detect route from UniversalTxV2 data and set on response
+    // This enables wait() to trigger outbound polling via waitForOutboundTx()
+    const detectedRoute = (0, tx_transformer_1.detectRouteFromUniversalTxData)(universalTxData);
+    if (detectedRoute) {
+        universalTxResponse.route = detectedRoute;
+        // Mirror the route on the context so emission code in wait()/cascade
+        // picks the correct ID range — keeps trackTransaction in lockstep with
+        // sendUniversalTransaction, which sets currentRoute in execute().
+        ctx.currentRoute = detectedRoute;
+        // Populate the destination/source chain on the response so
+        // reconstructR2/R3 (and any downstream emission that reads
+        // universalTxResponse.chain) emit the proper friendly chain name
+        // instead of the "external" fallback. The first outbound's destination
+        // is the target chain for R2 and the source CEA chain for R3.
+        const firstOutboundChain = universalTxData?.outboundTx?.[0]?.destinationChain;
+        if (firstOutboundChain && !universalTxResponse.chain) {
+            universalTxResponse.chain = firstOutboundChain;
+            universalTxResponse.chainNamespace = firstOutboundChain;
         }
-        // Override `origin` with the true source account. The transform derives
-        // origin from the Push pcTx (whose `from` is the keeper that submitted the
-        // inbound), so in source-hash mode it would otherwise read as a Push
-        // address. Rebuild it as `<sourceChainCaip>:<sourceSender>` using the
-        // chain's native address encoding (0x for EVM, base58 for SVM).
-        if (sourceOriginChain && sourceSender) {
-            let originAddr = sourceSender;
-            try {
-                originAddr =
-                    chain_1.CHAIN_INFO[sourceOriginChain].vm === enums_1.VM.SVM
-                        ? bs58_1.bs58.encode((0, viem_1.toBytes)(sourceSender))
-                        : (0, viem_1.getAddress)(sourceSender);
-            }
-            catch (_f) {
-                // Keep the raw sender if re-encoding fails.
-            }
-            universalTxResponse.origin = `${sourceOriginChain}:${originAddr}`;
-            universalTxResponse.chainId = chain_1.CHAIN_INFO[sourceOriginChain].chainId;
+        // For R3 replays, enable inbound round-trip tracking so `.wait()` runs
+        // the 310-01 → 399-01 sequence. Live execute sets this in
+        // route-handlers.ts via `amount > 0n`; trackTransaction has no
+        // execute-phase args, so we enable it unconditionally for CEA_TO_PUSH.
+        // The inbound block tolerates no-inbound (payload-only R3) by timing
+        // out — same as live behaviour when the source tx has no round-trip.
+        if (detectedRoute === route_detector_1.TransactionRoute.CEA_TO_PUSH) {
+            universalTxResponse._expectsInboundRoundTrip = true;
         }
-        // Reconstruct and emit SEND-TX-* progress events
-        const reconstructedEvents = (0, tx_transformer_1.reconstructProgressEvents)(universalTxResponse, universalTxData);
-        for (const event of reconstructedEvents) {
-            emitProgress(event);
+    }
+    // Source-hash mode: the pcTx we fetched lives on Push Chain, so the
+    // transform resolves chain to the Push side. Surface the true source chain
+    // the caller tracked so `chain`/`chainNamespace` reflect where the universal
+    // tx actually originated. (An outbound-derived chain above, if any, wins.)
+    if (sourceOriginChain && !universalTxResponse.chain) {
+        universalTxResponse.chain = sourceOriginChain;
+        universalTxResponse.chainNamespace = sourceOriginChain;
+    }
+    // Override `origin` with the true source account. The transform derives
+    // origin from the Push pcTx (whose `from` is the keeper that submitted the
+    // inbound), so in source-hash mode it would otherwise read as a Push
+    // address. Rebuild it as `<sourceChainCaip>:<sourceSender>` using the
+    // chain's native address encoding (0x for EVM, base58 for SVM).
+    if (sourceOriginChain && sourceSender) {
+        let originAddr = sourceSender;
+        try {
+            originAddr =
+                chain_1.CHAIN_INFO[sourceOriginChain].vm === enums_1.VM.SVM
+                    ? bs58_1.bs58.encode((0, viem_1.toBytes)(sourceSender))
+                    : (0, viem_1.getAddress)(sourceSender);
         }
-        // Mark the response so the wait() closure (when later invoked) doesn't
-        // call trackTransaction a second time and re-emit the same reconstructed
-        // events to the user's progressHook.
-        universalTxResponse._eventsReconstructed = true;
-        // Auto-register the caller's per-call progressHook as the response's
-        // registeredProgressHook so that tracked.wait() fires wait-phase events
-        // (209-xx / 299-xx / 399-xx) to the same callback without requiring
-        // tracked.progressHook(cb) to be called again. Skip replay of buffered
-        // events because we just fired them above via emitProgress — calling
-        // response.progressHook(cb) here would re-emit the reconstructed stream.
-        if (progressHook && universalTxResponse._setProgressHookNoReplay) {
-            universalTxResponse._setProgressHookNoReplay(progressHook);
+        catch {
+            // Keep the raw sender if re-encoding fails.
         }
-        return universalTxResponse;
-    });
+        universalTxResponse.origin = `${sourceOriginChain}:${originAddr}`;
+        universalTxResponse.chainId = chain_1.CHAIN_INFO[sourceOriginChain].chainId;
+    }
+    // Reconstruct and emit SEND-TX-* progress events
+    const reconstructedEvents = (0, tx_transformer_1.reconstructProgressEvents)(universalTxResponse, universalTxData);
+    for (const event of reconstructedEvents) {
+        emitProgress(event);
+    }
+    // Mark the response so the wait() closure (when later invoked) doesn't
+    // call trackTransaction a second time and re-emit the same reconstructed
+    // events to the user's progressHook.
+    universalTxResponse._eventsReconstructed = true;
+    // Auto-register the caller's per-call progressHook as the response's
+    // registeredProgressHook so that tracked.wait() fires wait-phase events
+    // (209-xx / 299-xx / 399-xx) to the same callback without requiring
+    // tracked.progressHook(cb) to be called again. Skip replay of buffered
+    // events because we just fired them above via emitProgress — calling
+    // response.progressHook(cb) here would re-emit the reconstructed stream.
+    if (progressHook && universalTxResponse._setProgressHookNoReplay) {
+        universalTxResponse._setProgressHookNoReplay(progressHook);
+    }
+    return universalTxResponse;
 }
 // ============================================================================
 // transformToUniversalTxResponse
 // ============================================================================
-function transformToUniversalTxResponse(ctx_1, tx_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (ctx, tx, eventBuffer = [], callbacks) {
-        const chain = ctx.universalSigner.account.chain;
-        let { vm, chainId } = chain_1.CHAIN_INFO[chain];
-        let from;
-        let to;
-        let value;
-        let data;
-        let rawTransactionData;
-        const ueaOrigin = yield (0, account_1.convertExecutorToOrigin)(tx.to, { _internal: true });
-        let originAddress;
-        if (ueaOrigin.exists) {
-            if (!ueaOrigin.account) {
-                throw new Error('UEA origin account is null');
+async function transformToUniversalTxResponse(ctx, tx, eventBuffer = [], callbacks) {
+    const chain = ctx.universalSigner.account.chain;
+    let { vm, chainId } = chain_1.CHAIN_INFO[chain];
+    let from;
+    let to;
+    let value;
+    let data;
+    let rawTransactionData;
+    const ueaOrigin = await (0, account_1.convertExecutorToOrigin)(tx.to, { _internal: true });
+    let originAddress;
+    if (ueaOrigin.exists) {
+        if (!ueaOrigin.account) {
+            throw new Error('UEA origin account is null');
+        }
+        originAddress = ueaOrigin.account.address;
+        // Use the resolved origin chain for vm/chainId so that the `origin`
+        // field reflects the transaction's actual origin, not the tracker's.
+        const resolvedChainInfo = chain_1.CHAIN_INFO[ueaOrigin.account.chain];
+        if (resolvedChainInfo) {
+            vm = resolvedChainInfo.vm;
+            chainId = resolvedChainInfo.chainId;
+        }
+        from = (0, viem_1.getAddress)(tx.to);
+        let decoded;
+        let decodedPayload = null;
+        if (tx.input !== '0x') {
+            // Try to decode the input as a known UEA_EVM call. Older txs — or
+            // txs sent to a UEA that was upgraded to expose a function not yet
+            // reflected in the bundled `uea.evm.ts` ABI — carry a selector that
+            // viem can't match. In that case the reconstructor should still
+            // produce a usable response (and emit progress hooks) using the raw
+            // tx fields, rather than throwing before any hook fires.
+            try {
+                decoded = (0, viem_1.decodeFunctionData)({ abi: uea_evm_1.UEA_EVM, data: tx.input });
+                if (decoded?.args) {
+                    decodedPayload = decoded.args[0];
+                }
             }
-            originAddress = ueaOrigin.account.address;
-            // Use the resolved origin chain for vm/chainId so that the `origin`
-            // field reflects the transaction's actual origin, not the tracker's.
-            const resolvedChainInfo = chain_1.CHAIN_INFO[ueaOrigin.account.chain];
-            if (resolvedChainInfo) {
-                vm = resolvedChainInfo.vm;
-                chainId = resolvedChainInfo.chainId;
+            catch {
+                decodedPayload = null;
             }
-            from = (0, viem_1.getAddress)(tx.to);
-            let decoded;
-            let decodedPayload = null;
-            if (tx.input !== '0x') {
-                // Try to decode the input as a known UEA_EVM call. Older txs — or
-                // txs sent to a UEA that was upgraded to expose a function not yet
-                // reflected in the bundled `uea.evm.ts` ABI — carry a selector that
-                // viem can't match. In that case the reconstructor should still
-                // produce a usable response (and emit progress hooks) using the raw
-                // tx fields, rather than throwing before any hook fires.
-                try {
-                    decoded = (0, viem_1.decodeFunctionData)({ abi: uea_evm_1.UEA_EVM, data: tx.input });
-                    if (decoded === null || decoded === void 0 ? void 0 : decoded.args) {
-                        decodedPayload = decoded.args[0];
-                    }
-                }
-                catch (_a) {
-                    decodedPayload = null;
-                }
-                if (decodedPayload) {
-                    to = decodedPayload.to;
-                    value = BigInt(decodedPayload.value);
-                    data = decodedPayload.data;
-                }
-                else {
-                    // Unknown / unsupported UEA function — fall back to raw fields so
-                    // transformToUniversalTxResponse can still return a valid response
-                    // and downstream progress-hook reconstruction can proceed.
-                    to = (0, viem_1.getAddress)(tx.to);
-                    value = tx.value;
-                    data = tx.input;
-                }
-                // Extract 'to' from single-element multicall
-                if (data && data.length >= 10) {
-                    const multicallSelector = (0, viem_1.keccak256)((0, viem_1.toBytes)('UEA_MULTICALL')).slice(0, 10);
-                    if (data.slice(0, 10) === multicallSelector) {
-                        try {
-                            const innerData = ('0x' + data.slice(10));
-                            const [decodedCalls] = (0, viem_1.decodeAbiParameters)([
-                                {
-                                    type: 'tuple[]',
-                                    components: [
-                                        { name: 'to', type: 'address' },
-                                        { name: 'value', type: 'uint256' },
-                                        { name: 'data', type: 'bytes' },
-                                    ],
-                                },
-                            ], innerData);
-                            // If single call, use its 'to' address
-                            if (decodedCalls.length === 1) {
-                                to = (0, viem_1.getAddress)(decodedCalls[0].to);
-                            }
-                        }
-                        catch (_b) {
-                            // Keep original 'to' if decoding fails
-                        }
-                    }
-                }
-                rawTransactionData = {
-                    from: (0, viem_1.getAddress)(tx.from),
-                    to: (0, viem_1.getAddress)(tx.to),
-                    nonce: tx.nonce,
-                    data: tx.input,
-                    value: tx.value,
-                };
+            if (decodedPayload) {
+                to = decodedPayload.to;
+                value = BigInt(decodedPayload.value);
+                data = decodedPayload.data;
             }
             else {
+                // Unknown / unsupported UEA function — fall back to raw fields so
+                // transformToUniversalTxResponse can still return a valid response
+                // and downstream progress-hook reconstruction can proceed.
                 to = (0, viem_1.getAddress)(tx.to);
                 value = tx.value;
                 data = tx.input;
-                rawTransactionData = {
-                    from: (0, viem_1.getAddress)(tx.from),
-                    to: (0, viem_1.getAddress)(tx.to),
-                    nonce: tx.nonce,
-                    data: tx.input,
-                    value: tx.value,
-                };
             }
+            // Extract 'to' from single-element multicall
+            if (data && data.length >= 10) {
+                const multicallSelector = (0, viem_1.keccak256)((0, viem_1.toBytes)('UEA_MULTICALL')).slice(0, 10);
+                if (data.slice(0, 10) === multicallSelector) {
+                    try {
+                        const innerData = ('0x' + data.slice(10));
+                        const [decodedCalls] = (0, viem_1.decodeAbiParameters)([
+                            {
+                                type: 'tuple[]',
+                                components: [
+                                    { name: 'to', type: 'address' },
+                                    { name: 'value', type: 'uint256' },
+                                    { name: 'data', type: 'bytes' },
+                                ],
+                            },
+                        ], innerData);
+                        // If single call, use its 'to' address
+                        if (decodedCalls.length === 1) {
+                            to = (0, viem_1.getAddress)(decodedCalls[0].to);
+                        }
+                    }
+                    catch {
+                        // Keep original 'to' if decoding fails
+                    }
+                }
+            }
+            rawTransactionData = {
+                from: (0, viem_1.getAddress)(tx.from),
+                to: (0, viem_1.getAddress)(tx.to),
+                nonce: tx.nonce,
+                data: tx.input,
+                value: tx.value,
+            };
         }
         else {
-            originAddress = (0, viem_1.getAddress)(tx.from);
-            from = (0, viem_1.getAddress)(tx.from);
             to = (0, viem_1.getAddress)(tx.to);
             value = tx.value;
             data = tx.input;
@@ -529,316 +557,404 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                 value: tx.value,
             };
         }
-        // Extract 'to' and 'from' from depositPRC20WithAutoSwap (precompile call)
-        if (data && data.length >= 10) {
-            const depositPRC20Selector = '0x780ad827';
-            if (data.slice(0, 10) === depositPRC20Selector) {
-                try {
-                    const decoded = (0, viem_1.decodeFunctionData)({
-                        abi: [
-                            {
-                                name: 'depositPRC20WithAutoSwap',
-                                type: 'function',
-                                inputs: [
-                                    { name: 'prc20', type: 'address' },
-                                    { name: 'amount', type: 'uint256' },
-                                    { name: 'target', type: 'address' },
-                                    { name: 'fee', type: 'uint24' },
-                                    { name: 'minPCOut', type: 'uint256' },
-                                    { name: 'deadline', type: 'uint256' },
-                                ],
-                            },
-                        ],
-                        data: data,
-                    });
-                    if (decoded.args) {
-                        const target = decoded.args[2];
-                        to = (0, viem_1.getAddress)(target);
-                        from = '0x0000000000000000000000000000000000000000';
-                    }
-                }
-                catch (_c) {
-                    // Keep original values if decoding fails
+    }
+    else {
+        originAddress = (0, viem_1.getAddress)(tx.from);
+        from = (0, viem_1.getAddress)(tx.from);
+        to = (0, viem_1.getAddress)(tx.to);
+        value = tx.value;
+        data = tx.input;
+        rawTransactionData = {
+            from: (0, viem_1.getAddress)(tx.from),
+            to: (0, viem_1.getAddress)(tx.to),
+            nonce: tx.nonce,
+            data: tx.input,
+            value: tx.value,
+        };
+    }
+    // Extract 'to' and 'from' from depositPRC20WithAutoSwap (precompile call)
+    if (data && data.length >= 10) {
+        const depositPRC20Selector = '0x780ad827';
+        if (data.slice(0, 10) === depositPRC20Selector) {
+            try {
+                const decoded = (0, viem_1.decodeFunctionData)({
+                    abi: [
+                        {
+                            name: 'depositPRC20WithAutoSwap',
+                            type: 'function',
+                            inputs: [
+                                { name: 'prc20', type: 'address' },
+                                { name: 'amount', type: 'uint256' },
+                                { name: 'target', type: 'address' },
+                                { name: 'fee', type: 'uint24' },
+                                { name: 'minPCOut', type: 'uint256' },
+                                { name: 'deadline', type: 'uint256' },
+                            ],
+                        },
+                    ],
+                    data: data,
+                });
+                if (decoded.args) {
+                    const target = decoded.args[2];
+                    to = (0, viem_1.getAddress)(target);
+                    from = '0x0000000000000000000000000000000000000000';
                 }
             }
-        }
-        const origin = `${chain_1.VM_NAMESPACE[vm]}:${chainId}:${originAddress}`;
-        // Create signature from transaction r, s, v values.
-        //
-        // Push Chain's derived (module-injected) inbound txs are reported over the EVM
-        // JSON-RPC as **legacy `type 0x0`**, which omits the `yParity` field that viem
-        // only populates for typed (EIP-1559/2930) txs — so `tx.yParity` is `undefined`.
-        // Per the chain team (the hash inconsistencies were fixed chain-side, but
-        // derived txs remain legacy 0x0 by design), the SDK must accept `0x0` and
-        // surface a numeric `yParity`. Derive it from `v`: 0/1 → as-is, 27/28 → v-27,
-        // EIP-155 → (v-35)%2. (For the zeroed-signature derived txs, v=0 → yParity=0.)
-        let signature;
-        try {
-            const vNum = typeof tx.v === 'bigint' ? Number(tx.v) : tx.v || 0;
-            let yParity = tx.yParity;
-            if (yParity === undefined) {
-                if (vNum === 0 || vNum === 1)
-                    yParity = vNum;
-                else if (vNum === 27 || vNum === 28)
-                    yParity = vNum - 27;
-                else
-                    yParity = (vNum - 35) % 2;
+            catch {
+                // Keep original values if decoding fails
             }
-            signature = {
-                r: tx.r || '0x0',
-                s: tx.s || '0x0',
-                v: vNum,
-                yParity,
-            };
         }
-        catch (_d) {
-            // Fallback signature if parsing fails
-            signature = {
-                r: '0x0000000000000000000000000000000000000000000000000000000000000000',
-                s: '0x0000000000000000000000000000000000000000000000000000000000000000',
-                v: 0,
-                yParity: 0,
-            };
+    }
+    const origin = `${chain_1.VM_NAMESPACE[vm]}:${chainId}:${originAddress}`;
+    // Create signature from transaction r, s, v values.
+    //
+    // Push Chain's derived (module-injected) inbound txs are reported over the EVM
+    // JSON-RPC as **legacy `type 0x0`**, which omits the `yParity` field that viem
+    // only populates for typed (EIP-1559/2930) txs — so `tx.yParity` is `undefined`.
+    // Per the chain team (the hash inconsistencies were fixed chain-side, but
+    // derived txs remain legacy 0x0 by design), the SDK must accept `0x0` and
+    // surface a numeric `yParity`. Derive it from `v`: 0/1 → as-is, 27/28 → v-27,
+    // EIP-155 → (v-35)%2. (For the zeroed-signature derived txs, v=0 → yParity=0.)
+    let signature;
+    try {
+        const vNum = typeof tx.v === 'bigint' ? Number(tx.v) : tx.v || 0;
+        let yParity = tx.yParity;
+        if (yParity === undefined) {
+            if (vNum === 0 || vNum === 1)
+                yParity = vNum;
+            else if (vNum === 27 || vNum === 28)
+                yParity = vNum - 27;
+            else
+                yParity = (vNum - 35) % 2;
         }
-        // Determine transaction type and typeVerbose
-        let type = '99'; // universal
-        let typeVerbose = 'universal';
-        if (tx.type !== undefined) {
-            const txType = tx.type;
-            if (txType === 'eip1559') {
-                type = '2';
-                typeVerbose = 'eip1559';
-            }
-            else if (txType === 'eip2930') {
-                type = '1';
-                typeVerbose = 'eip2930';
-            }
-            else if (txType === 'legacy') {
-                type = '0';
-                typeVerbose = 'legacy';
-            }
-            else if (txType === 'eip4844') {
-                type = '3';
-                typeVerbose = 'eip4844';
-            }
+        signature = {
+            r: tx.r || '0x0',
+            s: tx.s || '0x0',
+            v: vNum,
+            yParity,
+        };
+    }
+    catch {
+        // Fallback signature if parsing fails
+        signature = {
+            r: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            s: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            v: 0,
+            yParity: 0,
+        };
+    }
+    // Determine transaction type and typeVerbose
+    let type = '99'; // universal
+    let typeVerbose = 'universal';
+    if (tx.type !== undefined) {
+        const txType = tx.type;
+        if (txType === 'eip1559') {
+            type = '2';
+            typeVerbose = 'eip1559';
         }
-        // Storage for registered progress callback (used by progressHook method)
-        let registeredProgressHook;
-        const universalTxResponse = {
-            // 1. Identity
-            hash: tx.hash,
-            finalTxHash: tx.hash, // Push tx hash; .wait()'s receipt refines it for R2/R3
-            origin,
-            // 2. Block Info
-            blockNumber: tx.blockNumber || BigInt(0),
-            blockHash: tx.blockHash || '',
-            transactionIndex: tx.transactionIndex || 0,
-            chainId,
-            // 3. Execution Context
-            from: from, // UEA (executor) address, checksummed for EVM
-            to: to || '',
-            nonce: tx.nonce,
-            // 4. Payload
-            data, // perceived calldata (was input)
-            value,
-            // 5. Gas
-            gasLimit: tx.gas || BigInt(0), // (was gas)
-            gasPrice: tx.gasPrice,
-            maxFeePerGas: tx.maxFeePerGas,
-            maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-            accessList: Array.isArray(tx.accessList) ? [...tx.accessList] : [],
-            // 6. Utilities
-            wait: (waitOptions) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-                // For trackTransaction replays the tx is historical — cosmos already
-                // has the full graph indexed, so the 20s/30s initial-wait buffers
-                // designed for live sends are pure deadweight. Default them to 0 when
-                // replaying; callers can still override via WaitOptions.
-                const isReplay = universalTxResponse._eventsReconstructed === true;
-                const outboundTimeoutMs = (_a = waitOptions === null || waitOptions === void 0 ? void 0 : waitOptions.outboundTimeoutMs) !== null && _a !== void 0 ? _a : callbacks.outboundConstants.maxTimeoutMs;
-                const inboundTimeoutMs = (_b = waitOptions === null || waitOptions === void 0 ? void 0 : waitOptions.inboundTimeoutMs) !== null && _b !== void 0 ? _b : callbacks.inboundConstants.maxTimeoutMs;
-                const outboundInitialWaitMs = (_c = waitOptions === null || waitOptions === void 0 ? void 0 : waitOptions.outboundInitialWaitMs) !== null && _c !== void 0 ? _c : (isReplay ? 0 : callbacks.outboundConstants.initialWaitMs);
-                const outboundPollingIntervalMs = (_d = waitOptions === null || waitOptions === void 0 ? void 0 : waitOptions.outboundPollingIntervalMs) !== null && _d !== void 0 ? _d : callbacks.outboundConstants.pollingIntervalMs;
-                const inboundInitialWaitMs = isReplay
-                    ? 0
-                    : callbacks.inboundConstants.initialWaitMs;
-                // Build the base receipt directly from this response. Any per-call
-                // `tx.progressHook(cb)` already replayed buffered execute-phase events
-                // to `cb` via the progressHook setter — re-running trackTransaction
-                // here would duplicate the reconstructed stream on top of that replay,
-                // which is exactly what broke R1 parity. Wait-phase events (209-xx /
-                // 299-xx / 399-xx) still reach `registeredProgressHook` and
-                // `ctx.progressHook` via the `emit` closure in the outbound branch.
-                const receipt = yield tx.wait();
-                let baseReceipt = callbacks.transformToUniversalTxReceipt(receipt, universalTxResponse);
-                // If outbound route, poll for external chain details
-                const route = universalTxResponse.route;
-                const routeInfo = route ? (0, route_detector_1.getRouteInfo)(route) : undefined;
-                if (routeInfo === null || routeInfo === void 0 ? void 0 : routeInfo.isOutbound) {
-                    // Pick route-specific hook builders. R4 (CEA_TO_CEA) currently has
-                    // no spec'd IDs — pickWaitHooks returns a no-op set that yields
-                    // events with `id: ''`. `emit` drops those so the consumer never
-                    // sees placeholder events, while receipt mutation still runs.
-                    const hooks = (0, progress_route_hooks_1.pickWaitHooks)(route);
-                    const targetChain = ((_e = universalTxResponse.chain) !== null && _e !== void 0 ? _e : 'external');
+        else if (txType === 'eip2930') {
+            type = '1';
+            typeVerbose = 'eip2930';
+        }
+        else if (txType === 'legacy') {
+            type = '0';
+            typeVerbose = 'legacy';
+        }
+        else if (txType === 'eip4844') {
+            type = '3';
+            typeVerbose = 'eip4844';
+        }
+    }
+    // Storage for registered progress callback (used by progressHook method)
+    let registeredProgressHook;
+    const universalTxResponse = {
+        // 1. Identity
+        hash: tx.hash,
+        finalTxHash: tx.hash, // Push tx hash; .wait()'s receipt refines it for R2/R3
+        origin,
+        // 2. Block Info
+        blockNumber: tx.blockNumber || BigInt(0),
+        blockHash: tx.blockHash || '',
+        transactionIndex: tx.transactionIndex || 0,
+        chainId,
+        // 3. Execution Context
+        from: from, // UEA (executor) address, checksummed for EVM
+        to: to || '',
+        nonce: tx.nonce,
+        // 4. Payload
+        data, // perceived calldata (was input)
+        value,
+        // 5. Gas
+        gasLimit: tx.gas || BigInt(0), // (was gas)
+        gasPrice: tx.gasPrice,
+        maxFeePerGas: tx.maxFeePerGas,
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+        accessList: Array.isArray(tx.accessList) ? [...tx.accessList] : [],
+        // 6. Utilities
+        wait: async (waitOptions) => {
+            // For trackTransaction replays the tx is historical — cosmos already
+            // has the full graph indexed, so the 20s/30s initial-wait buffers
+            // designed for live sends are pure deadweight. Default them to 0 when
+            // replaying; callers can still override via WaitOptions.
+            const isReplay = universalTxResponse._eventsReconstructed === true;
+            const outboundTimeoutMs = waitOptions?.outboundTimeoutMs ??
+                callbacks.outboundConstants.maxTimeoutMs;
+            const inboundTimeoutMs = waitOptions?.inboundTimeoutMs ??
+                callbacks.inboundConstants.maxTimeoutMs;
+            const outboundInitialWaitMs = waitOptions?.outboundInitialWaitMs ??
+                (isReplay ? 0 : callbacks.outboundConstants.initialWaitMs);
+            const outboundPollingIntervalMs = waitOptions?.outboundPollingIntervalMs ??
+                callbacks.outboundConstants.pollingIntervalMs;
+            const inboundInitialWaitMs = isReplay
+                ? 0
+                : callbacks.inboundConstants.initialWaitMs;
+            // Build the base receipt directly from this response. Any per-call
+            // `tx.progressHook(cb)` already replayed buffered execute-phase events
+            // to `cb` via the progressHook setter — re-running trackTransaction
+            // here would duplicate the reconstructed stream on top of that replay,
+            // which is exactly what broke R1 parity. Wait-phase events (209-xx /
+            // 299-xx / 399-xx) still reach `registeredProgressHook` and
+            // `ctx.progressHook` via the `emit` closure in the outbound branch.
+            const receipt = await tx.wait();
+            let baseReceipt = callbacks.transformToUniversalTxReceipt(receipt, universalTxResponse);
+            // If outbound route, poll for external chain details
+            const route = universalTxResponse.route;
+            const routeInfo = route ? (0, route_detector_1.getRouteInfo)(route) : undefined;
+            // A reverted Push-chain root transaction can never produce an outbound
+            // leg. Previously we still entered waitForOutboundTx() here, which made
+            // a known failure look like an in-progress relay until the outbound
+            // timeout elapsed. Stop at the root receipt instead and emit the
+            // route-terminal failure immediately. `externalStatus` intentionally
+            // remains unset: no external transaction was submitted, so the failure
+            // is represented by the canonical receipt `status === 0`.
+            if (baseReceipt.status === 0) {
+                const errMsg = `Push Chain transaction ${universalTxResponse.hash} reverted; ` +
+                    'outbound relay was not started';
+                if (routeInfo?.isOutbound) {
+                    const targetChain = (universalTxResponse.chain ??
+                        'external');
                     const emit = (event) => {
                         if (!event.id)
                             return;
                         fanOut(event, registeredProgressHook, ctx.progressHook);
                     };
-                    // Awaiting relay
-                    emit(hooks.awaiting(targetChain, universalTxResponse.hash));
-                    let lastEmittedStatus;
-                    const outboundTranslator = (event) => {
-                        if (event.status === 'polling' && lastEmittedStatus !== 'polling') {
-                            lastEmittedStatus = 'polling';
-                            emit(hooks.polling(targetChain, event.elapsed, universalTxResponse.hash));
-                        }
+                    if (route === route_detector_1.TransactionRoute.CEA_TO_PUSH) {
+                        emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](errMsg, 'push', targetChain, undefined, universalTxResponse.hash));
+                    }
+                    else {
+                        emit((0, progress_route_hooks_1.pickWaitHooks)(route).failed(targetChain, errMsg, {
+                            pushTxHash: universalTxResponse.hash,
+                        }));
+                    }
+                }
+                callbacks.printLog(`[wait] ${errMsg}`);
+                return baseReceipt;
+            }
+            if (routeInfo?.isOutbound) {
+                // Pick route-specific hook builders. R4 (CEA_TO_CEA) currently has
+                // no spec'd IDs — pickWaitHooks returns a no-op set that yields
+                // events with `id: ''`. `emit` drops those so the consumer never
+                // sees placeholder events, while receipt mutation still runs.
+                const hooks = (0, progress_route_hooks_1.pickWaitHooks)(route);
+                const targetChain = (universalTxResponse.chain ?? 'external');
+                const emit = (event) => {
+                    if (!event.id)
+                        return;
+                    fanOut(event, registeredProgressHook, ctx.progressHook);
+                };
+                // Awaiting relay
+                emit(hooks.awaiting(targetChain, universalTxResponse.hash));
+                let lastEmittedStatus;
+                const outboundTranslator = (event) => {
+                    if (event.status === 'polling' && lastEmittedStatus !== 'polling') {
+                        lastEmittedStatus = 'polling';
+                        emit(hooks.polling(targetChain, event.elapsed, universalTxResponse.hash));
+                    }
+                };
+                try {
+                    const outboundDetails = await callbacks.waitForOutboundTx(tx.hash, {
+                        initialWaitMs: outboundInitialWaitMs,
+                        pollingIntervalMs: outboundPollingIntervalMs,
+                        timeout: outboundTimeoutMs,
+                        progressHook: outboundTranslator,
+                    });
+                    // `outboundDetails.externalTxHash` is the raw `0x`-hex form (kept
+                    // internally so the R3 inbound tracker below can query Cosmos with
+                    // it via `waitForInboundPushTx → findChildUtxIdFromExternalTx`).
+                    // For every USER-FACING surface (progress hook event + receipt) we
+                    // want the chain-native form so consumers can paste it straight
+                    // into an explorer / RPC: base58 for SVM, hex for EVM. Build a
+                    // display copy and use it for both the hook and the receipt.
+                    const displayExternalTxHash = (0, helpers_1.toExternalTxHashDisplay)(outboundDetails.destinationChain, outboundDetails.externalTxHash) ?? outboundDetails.externalTxHash;
+                    const userFacingOutboundDetails = {
+                        ...outboundDetails,
+                        externalTxHash: displayExternalTxHash,
                     };
-                    try {
-                        const outboundDetails = yield callbacks.waitForOutboundTx(tx.hash, {
-                            initialWaitMs: outboundInitialWaitMs,
-                            pollingIntervalMs: outboundPollingIntervalMs,
-                            timeout: outboundTimeoutMs,
-                            progressHook: outboundTranslator,
-                        });
-                        // `outboundDetails.externalTxHash` is the raw `0x`-hex form (kept
-                        // internally so the R3 inbound tracker below can query Cosmos with
-                        // it via `waitForInboundPushTx → findChildUtxIdFromExternalTx`).
-                        // For every USER-FACING surface (progress hook event + receipt) we
-                        // want the chain-native form so consumers can paste it straight
-                        // into an explorer / RPC: base58 for SVM, hex for EVM. Build a
-                        // display copy and use it for both the hook and the receipt.
-                        const displayExternalTxHash = (_f = (0, helpers_1.toExternalTxHashDisplay)(outboundDetails.destinationChain, outboundDetails.externalTxHash)) !== null && _f !== void 0 ? _f : outboundDetails.externalTxHash;
-                        const userFacingOutboundDetails = Object.assign(Object.assign({}, outboundDetails), { externalTxHash: displayExternalTxHash });
-                        emit(hooks.success(userFacingOutboundDetails));
-                        baseReceipt = Object.assign(Object.assign({}, baseReceipt), { externalTxHash: displayExternalTxHash, externalChain: outboundDetails.destinationChain, externalExplorerUrl: outboundDetails.explorerUrl, externalRecipient: outboundDetails.recipient, externalAmount: outboundDetails.amount, externalAssetAddr: outboundDetails.assetAddr, externalStatus: 'success' });
-                        // R3 round-trip: poll Push Chain for the inbound tx that the
-                        // source-chain CEA's sendUniversalTxToUEA call produces. Correlate
-                        // via the outbound external tx hash → child UTX id → child pcTx.
-                        // Only run when the CEA payload actually fires sendUniversalTxToUEA;
-                        // payload-only R3 (no funds flowing back) has no child UTX and would
-                        // otherwise time out after 300s.
-                        if (route === route_detector_1.TransactionRoute.CEA_TO_PUSH &&
-                            universalTxResponse._expectsInboundRoundTrip === true) {
-                            emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_01](targetChain, universalTxResponse.hash));
-                            let inboundLastEmitted;
-                            try {
-                                const inbound = yield (0, inbound_tracker_1.waitForInboundPushTx)(ctx, outboundDetails.externalTxHash, targetChain, {
-                                    initialWaitMs: inboundInitialWaitMs,
-                                    pollingIntervalMs: callbacks.inboundConstants.pollingIntervalMs,
-                                    timeout: inboundTimeoutMs,
-                                    progressHook: (event) => {
-                                        if (event.status === 'polling' &&
-                                            inboundLastEmitted !== 'polling') {
-                                            inboundLastEmitted = 'polling';
-                                            emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_02](targetChain, event.elapsedMs, universalTxResponse.hash));
-                                        }
-                                    },
-                                });
-                                if (inbound.status === 'confirmed') {
-                                    emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_01](targetChain, inbound.pushTxHash, baseReceipt));
-                                    baseReceipt = Object.assign(Object.assign({}, baseReceipt), { pushInboundTxHash: inbound.pushTxHash, pushInboundUtxId: inbound.childUtxId });
-                                }
-                                else {
-                                    // status === 'failed' (terminal failure status from chain)
-                                    const failMsg = (_g = inbound.errorMessage) !== null && _g !== void 0 ? _g : 'inbound execution failed on Push Chain';
-                                    emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](failMsg, 'inbound', targetChain, undefined, universalTxResponse.hash, inbound.pushTxHash || undefined));
-                                    baseReceipt = Object.assign(Object.assign({}, baseReceipt), { pushInboundUtxId: inbound.childUtxId, pushInboundTxHash: inbound.pushTxHash || undefined, externalStatus: 'failed', externalError: failMsg });
-                                }
+                    emit(hooks.success(userFacingOutboundDetails));
+                    baseReceipt = {
+                        ...baseReceipt,
+                        externalTxHash: displayExternalTxHash,
+                        externalChain: outboundDetails.destinationChain,
+                        externalExplorerUrl: outboundDetails.explorerUrl,
+                        externalRecipient: outboundDetails.recipient,
+                        externalAmount: outboundDetails.amount,
+                        externalAssetAddr: outboundDetails.assetAddr,
+                        externalStatus: 'success',
+                    };
+                    // R3 round-trip: poll Push Chain for the inbound tx that the
+                    // source-chain CEA's sendUniversalTxToUEA call produces. Correlate
+                    // via the outbound external tx hash → child UTX id → child pcTx.
+                    // Only run when the CEA payload actually fires sendUniversalTxToUEA;
+                    // payload-only R3 (no funds flowing back) has no child UTX and would
+                    // otherwise time out after 300s.
+                    if (route === route_detector_1.TransactionRoute.CEA_TO_PUSH &&
+                        universalTxResponse._expectsInboundRoundTrip === true) {
+                        emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_01](targetChain, universalTxResponse.hash));
+                        let inboundLastEmitted;
+                        try {
+                            const inbound = await (0, inbound_tracker_1.waitForInboundPushTx)(ctx, outboundDetails.externalTxHash, targetChain, {
+                                initialWaitMs: inboundInitialWaitMs,
+                                pollingIntervalMs: callbacks.inboundConstants.pollingIntervalMs,
+                                timeout: inboundTimeoutMs,
+                                progressHook: (event) => {
+                                    if (event.status === 'polling' &&
+                                        inboundLastEmitted !== 'polling') {
+                                        inboundLastEmitted = 'polling';
+                                        emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_02](targetChain, event.elapsedMs, universalTxResponse.hash));
+                                    }
+                                },
+                            });
+                            if (inbound.status === 'confirmed') {
+                                emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_01](targetChain, inbound.pushTxHash, baseReceipt));
+                                baseReceipt = {
+                                    ...baseReceipt,
+                                    pushInboundTxHash: inbound.pushTxHash,
+                                    pushInboundUtxId: inbound.childUtxId,
+                                    // Round-trip completed. externalStatus stays 'success'
+                                    // (set on the outbound-found branch above).
+                                };
                             }
-                            catch (inboundErr) {
-                                const errMsg = inboundErr instanceof Error
-                                    ? inboundErr.message
-                                    : String(inboundErr);
-                                const isTimeout = inboundErr instanceof inbound_tracker_1.InboundTimeoutError;
-                                // Annotate receipt for inbound-leg outcome too.
-                                baseReceipt = Object.assign(Object.assign({}, baseReceipt), { externalStatus: isTimeout ? 'timeout' : 'failed', externalError: errMsg });
-                                emit(isTimeout
-                                    ? progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_03](targetChain, inboundTimeoutMs, 'inbound', universalTxResponse.hash)
-                                    : progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](errMsg, 'inbound', targetChain, undefined, universalTxResponse.hash));
-                                callbacks.printLog(`[wait] R3 inbound tracking failed: ${errMsg}`);
+                            else {
+                                // status === 'failed' (terminal failure status from chain)
+                                const failMsg = inbound.errorMessage ??
+                                    'inbound execution failed on Push Chain';
+                                emit(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](failMsg, 'inbound', targetChain, undefined, universalTxResponse.hash, inbound.pushTxHash || undefined));
+                                baseReceipt = {
+                                    ...baseReceipt,
+                                    pushInboundUtxId: inbound.childUtxId,
+                                    pushInboundTxHash: inbound.pushTxHash || undefined,
+                                    externalStatus: 'failed',
+                                    externalError: failMsg,
+                                };
                             }
                         }
+                        catch (inboundErr) {
+                            const errMsg = inboundErr instanceof Error
+                                ? inboundErr.message
+                                : String(inboundErr);
+                            const isTimeout = inboundErr instanceof inbound_tracker_1.InboundTimeoutError;
+                            // Annotate receipt for inbound-leg outcome too.
+                            baseReceipt = {
+                                ...baseReceipt,
+                                externalStatus: isTimeout ? 'timeout' : 'failed',
+                                externalError: errMsg,
+                            };
+                            emit(isTimeout
+                                ? progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_03](targetChain, inboundTimeoutMs, 'inbound', universalTxResponse.hash)
+                                : progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](errMsg, 'inbound', targetChain, undefined, universalTxResponse.hash));
+                            callbacks.printLog(`[wait] R3 inbound tracking failed: ${errMsg}`);
+                        }
                     }
-                    catch (error) {
-                        const errMsg = error instanceof Error ? error.message : String(error);
-                        const isTimeout = error instanceof outbound_sync_1.OutboundTimeoutError;
-                        const failedExternalTxHash = error instanceof outbound_sync_1.OutboundFailedError ? error.externalTxHash : undefined;
-                        // Normalize to chain-native display form for SVM (base58); EVM hex
-                        // passes through unchanged. `OutboundFailedError.destinationChain`
-                        // is a chain namespace string (e.g., 'solana:devnet') — convert to
-                        // the CHAIN enum via the same helper used in outbound-sync.
-                        const failedChain = error instanceof outbound_sync_1.OutboundFailedError && error.destinationChain
-                            ? (_h = (0, helpers_1.chainFromNamespace)(error.destinationChain)) !== null && _h !== void 0 ? _h : undefined
-                            : undefined;
-                        const failedExternalTxHashDisplay = (_j = (0, helpers_1.toExternalTxHashDisplay)(failedChain, failedExternalTxHash)) !== null && _j !== void 0 ? _j : failedExternalTxHash;
-                        emit(isTimeout
-                            ? hooks.timeout(targetChain, outboundTimeoutMs, universalTxResponse.hash)
-                            : hooks.failed(targetChain, errMsg, {
-                                pushTxHash: universalTxResponse.hash,
-                                txHash: failedExternalTxHashDisplay,
-                            }));
-                        // Annotate the receipt so callers can distinguish external-leg
-                        // outcomes without sniffing errMsg. Push Chain leg still succeeded
-                        // (status stays 1); inspect `externalStatus` / `externalError` for
-                        // the external/inbound leg outcome. On a reverted outbound the
-                        // observed tx hash is carried by OutboundFailedError — expose it
-                        // as externalTxHash so consumers can link to the explorer.
-                        baseReceipt = Object.assign(Object.assign(Object.assign({}, baseReceipt), { externalStatus: isTimeout ? 'timeout' : 'failed', externalError: errMsg }), (failedExternalTxHashDisplay
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    const isTimeout = error instanceof outbound_sync_1.OutboundTimeoutError;
+                    const failedExternalTxHash = error instanceof outbound_sync_1.OutboundFailedError ? error.externalTxHash : undefined;
+                    // Normalize to chain-native display form for SVM (base58); EVM hex
+                    // passes through unchanged. `OutboundFailedError.destinationChain`
+                    // is a chain namespace string (e.g., 'solana:devnet') — convert to
+                    // the CHAIN enum via the same helper used in outbound-sync.
+                    const failedChain = error instanceof outbound_sync_1.OutboundFailedError && error.destinationChain
+                        ? (0, helpers_1.chainFromNamespace)(error.destinationChain) ?? undefined
+                        : undefined;
+                    const failedExternalTxHashDisplay = (0, helpers_1.toExternalTxHashDisplay)(failedChain, failedExternalTxHash) ??
+                        failedExternalTxHash;
+                    emit(isTimeout
+                        ? hooks.timeout(targetChain, outboundTimeoutMs, universalTxResponse.hash)
+                        : hooks.failed(targetChain, errMsg, {
+                            pushTxHash: universalTxResponse.hash,
+                            txHash: failedExternalTxHashDisplay,
+                        }));
+                    // Annotate the receipt so callers can distinguish external-leg
+                    // outcomes without sniffing errMsg. Push Chain leg still succeeded
+                    // (status stays 1); inspect `externalStatus` / `externalError` for
+                    // the external/inbound leg outcome. On a reverted outbound the
+                    // observed tx hash is carried by OutboundFailedError — expose it
+                    // as externalTxHash so consumers can link to the explorer.
+                    baseReceipt = {
+                        ...baseReceipt,
+                        externalStatus: isTimeout ? 'timeout' : 'failed',
+                        externalError: errMsg,
+                        ...(failedExternalTxHashDisplay
                             ? { externalTxHash: failedExternalTxHashDisplay }
-                            : {}));
-                        // Outbound polling timed out or failed — return the annotated
-                        // receipt without throwing. Push Chain tx succeeded, external
-                        // tracking can be retried later.
-                        callbacks.printLog(`[wait] External chain tracking ${isTimeout ? 'timed out' : 'failed'}: ${errMsg}`);
-                    }
+                            : {}),
+                    };
+                    // Outbound polling timed out or failed — return the annotated
+                    // receipt without throwing. Push Chain tx succeeded, external
+                    // tracking can be retried later.
+                    callbacks.printLog(`[wait] External chain tracking ${isTimeout ? 'timed out' : 'failed'}: ${errMsg}`);
                 }
-                // Resolve the terminal hash for the whole journey: inbound (R3) >
-                // external outbound (R2) > the Push tx itself (R1). Single-tx analogue
-                // of CascadeCompletionResult.finalTxHash.
-                baseReceipt = Object.assign(Object.assign({}, baseReceipt), { finalTxHash: (_l = (_k = baseReceipt.pushInboundTxHash) !== null && _k !== void 0 ? _k : baseReceipt.externalTxHash) !== null && _l !== void 0 ? _l : baseReceipt.hash, 
-                    // Ensure `externalChain` is populated whenever an external/inbound leg
-                    // surfaced an `externalTxHash`. The outbound-success branch already sets
-                    // it to the destination chain (so this `??` never overrides it); this
-                    // only fills the inbound/R3 and failed/timeout paths, where it should be
-                    // the route's external chain (= the response's `chain`).
-                    externalChain: (_m = baseReceipt.externalChain) !== null && _m !== void 0 ? _m : (baseReceipt.externalTxHash
+            }
+            // Resolve the terminal hash for the whole journey: inbound (R3) >
+            // external outbound (R2) > the Push tx itself (R1). Single-tx analogue
+            // of CascadeCompletionResult.finalTxHash.
+            baseReceipt = {
+                ...baseReceipt,
+                finalTxHash: baseReceipt.pushInboundTxHash ??
+                    baseReceipt.externalTxHash ??
+                    baseReceipt.hash,
+                // Ensure `externalChain` is populated whenever an external/inbound leg
+                // surfaced an `externalTxHash`. The outbound-success branch already sets
+                // it to the destination chain (so this `??` never overrides it); this
+                // only fills the inbound/R3 and failed/timeout paths, where it should be
+                // the route's external chain (= the response's `chain`).
+                externalChain: baseReceipt.externalChain ??
+                    (baseReceipt.externalTxHash
                         ? universalTxResponse.chain
-                        : baseReceipt.externalChain) });
-                return baseReceipt;
-            }),
-            // Internal: register a wait-phase progressHook without replaying
-            // buffered events. Used by trackTransaction() after it has already
-            // emitted the reconstructed stream to the caller's per-call hook,
-            // so that tracked.wait() can deliver wait-phase events (209-xx /
-            // 299-xx / 399-xx) to the same callback without duplicating replay.
-            _setProgressHookNoReplay: (callback) => {
-                registeredProgressHook = callback;
-            },
-            progressHook: (callback) => {
-                registeredProgressHook = callback;
-                // Immediately replay buffered events from execution
-                if (eventBuffer.length > 0) {
-                    for (const event of eventBuffer) {
-                        callback(event);
-                    }
+                        : baseReceipt.externalChain),
+            };
+            return baseReceipt;
+        },
+        // Internal: register a wait-phase progressHook without replaying
+        // buffered events. Used by trackTransaction() after it has already
+        // emitted the reconstructed stream to the caller's per-call hook,
+        // so that tracked.wait() can deliver wait-phase events (209-xx /
+        // 299-xx / 399-xx) to the same callback without duplicating replay.
+        _setProgressHookNoReplay: (callback) => {
+            registeredProgressHook = callback;
+        },
+        progressHook: (callback) => {
+            registeredProgressHook = callback;
+            // Immediately replay buffered events from execution
+            if (eventBuffer.length > 0) {
+                for (const event of eventBuffer) {
+                    callback(event);
                 }
-            },
-            // 7. Metadata
-            type,
-            typeVerbose,
-            // Atomic by default — a single tx, an EIP-7702 batch, and a UEA multicall
-            // are all all-or-nothing. Only the native sequential fallback loop overrides
-            // this to `false` (see sendPushTx in push-chain-tx.ts). Historical lookups
-            // via trackTransaction also keep the default, since the past execution mode
-            // isn't always recoverable.
-            atomic: true,
-            signature,
-            // 8. Raw Universal Fields
-            raw: rawTransactionData,
-        };
-        return universalTxResponse;
-    });
+            }
+        },
+        // 7. Metadata
+        type,
+        typeVerbose,
+        // Atomic by default — a single tx, an EIP-7702 batch, and a UEA multicall
+        // are all all-or-nothing. Only the native sequential fallback loop overrides
+        // this to `false` (see sendPushTx in push-chain-tx.ts). Historical lookups
+        // via trackTransaction also keep the default, since the past execution mode
+        // isn't always recoverable.
+        atomic: true,
+        signature,
+        // 8. Raw Universal Fields
+        raw: rawTransactionData,
+    };
+    return universalTxResponse;
 }
 //# sourceMappingURL=response-builder.js.map