@pushchain/core 5.1.17 → 6.0.0

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

@@ -11,11 +11,11 @@ exports.waitForOutboundTx = waitForOutboundTx;
 exports.waitForAllOutboundTxsV2 = waitForAllOutboundTxsV2;
 const tslib_1 = require("tslib");
 const viem_1 = require("viem");
-const bs58_1 = require("../../internal/bs58");
 const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
 const types_1 = require("../../generated/uexecutor/v1/types");
 const types_2 = require("../../generated/uexecutor/v2/types");
+const formatters_1 = require("../../formatters");
 const context_1 = require("./context");
 const helpers_1 = require("./helpers");
 const outbound_tracker_1 = require("./outbound-tracker");
@@ -142,8 +142,8 @@ function verifyExternalEvmReceipt(ctx, destinationChain, externalTxHash) {
  */
 function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
     return tslib_1.__awaiter(this, arguments, void 0, function* (ctx, pushChainTxHash, options = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
-        const { initialWaitMs = exports.OUTBOUND_INITIAL_WAIT_MS, pollingIntervalMs = exports.OUTBOUND_POLL_INTERVAL_MS, timeout = exports.OUTBOUND_MAX_TIMEOUT_MS, progressHook, _resolvedSubTxId, _expectedDestinationChain, } = options;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        const { initialWaitMs = exports.OUTBOUND_INITIAL_WAIT_MS, pollingIntervalMs = exports.OUTBOUND_POLL_INTERVAL_MS, timeout = exports.OUTBOUND_MAX_TIMEOUT_MS, progressHook, _resolvedSubTxId, _expectedDestinationChain, _outboundIndex, } = options;
         // Terminal failure states — fail fast instead of polling until timeout
         const TERMINAL_FAILURE_STATES = new Set([
             types_1.UniversalTxStatus.OUTBOUND_FAILED,
@@ -195,20 +195,54 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                 const statusNum = (_b = utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) === null || _b === void 0 ? void 0 : _b.universalStatus;
                 const statusName = (_c = types_1.UniversalTxStatus[statusNum]) !== null && _c !== void 0 ? _c : statusNum;
                 const outbounds = ((_d = utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) === null || _d === void 0 ? void 0 : _d.outboundTx) || [];
-                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${outbounds.length} | first txHash: '${((_f = (_e = outbounds[0]) === null || _e === void 0 ? void 0 : _e.observedTx) === null || _f === void 0 ? void 0 : _f.txHash) || ''}' | first dest: '${((_g = outbounds[0]) === null || _g === void 0 ? void 0 : _g.destinationChain) || ''}'`);
+                const firstOutbound = outbounds[0];
+                const firstOutboundChain = (firstOutbound === null || firstOutbound === void 0 ? void 0 : firstOutbound.destinationChain)
+                    ? (0, helpers_1.chainFromNamespace)(firstOutbound.destinationChain)
+                    : undefined;
+                const firstDisplayTxHash = (_h = (_f = (0, helpers_1.toExternalTxHashDisplay)(firstOutboundChain !== null && firstOutboundChain !== void 0 ? firstOutboundChain : undefined, (_e = firstOutbound === null || firstOutbound === void 0 ? void 0 : firstOutbound.observedTx) === null || _e === void 0 ? void 0 : _e.txHash)) !== null && _f !== void 0 ? _f : (_g = firstOutbound === null || firstOutbound === void 0 ? void 0 : firstOutbound.observedTx) === null || _g === void 0 ? void 0 : _g.txHash) !== null && _h !== void 0 ? _h : '';
+                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${outbounds.length} | first txHash: '${firstDisplayTxHash}' | first dest: '${(firstOutbound === null || firstOutbound === void 0 ? void 0 : firstOutbound.destinationChain) || ''}'`);
                 // Check for terminal failure states — fail fast
                 if (TERMINAL_FAILURE_STATES.has(statusNum)) {
                     (0, context_1.printLog)(ctx, `[waitForOutboundTx] Terminal failure state: ${statusName}`);
                     progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
                     throw new OutboundFailedError(`Outbound transaction failed with status ${statusName}. Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash);
                 }
-                // Iterate V2 outbound array
+                const pcTxs = ((_j = utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) === null || _j === void 0 ? void 0 : _j.pcTx) || [];
+                const failedPcTx = pcTxs.find((pcTx) => {
+                    const status = String(pcTx.status || '').toUpperCase();
+                    return status === 'FAILED' || Boolean(pcTx.errorMsg);
+                });
+                if (failedPcTx) {
+                    const failedTxHash = failedPcTx.txHash || pushChainTxHash;
+                    const reason = failedPcTx.errorMsg
+                        ? (0, formatters_1.normalizePcInsufficientFundsError)(failedPcTx.errorMsg)
+                        : 'Push Chain execution failed';
+                    (0, context_1.printLog)(ctx, `[waitForOutboundTx] Push Chain execution failed before outbound emission: ${reason}`);
+                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
+                    throw new OutboundFailedError(`Push Chain execution failed before outbound emission: ${reason}. Push Chain TX: ${failedTxHash}.`, pushChainTxHash, undefined, failedPcTx.txHash || undefined);
+                }
+                // Iterate V2 outbound array. For cascade tracking, multiple outbound
+                // entries can target the same destination chain (for example R2 BSC
+                // followed by R3 BSC -> Push). `_outboundIndex` disambiguates those
+                // same-chain entries by order after `_expectedDestinationChain` filtering.
+                let matchingOutboundIndex = 0;
                 for (const ob of outbounds) {
+                    // If a destination chain filter is set, skip outbound entries that don't match.
+                    if (_expectedDestinationChain && ob.destinationChain !== _expectedDestinationChain) {
+                        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound chain '${ob.destinationChain}' does not match expected '${_expectedDestinationChain}', skipping`);
+                        continue;
+                    }
+                    const currentOutboundIndex = matchingOutboundIndex;
+                    matchingOutboundIndex += 1;
+                    if (_outboundIndex !== undefined && currentOutboundIndex !== _outboundIndex) {
+                        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound index ${currentOutboundIndex} for '${ob.destinationChain}' does not match expected index ${_outboundIndex}, skipping`);
+                        continue;
+                    }
                     // Fail fast on per-outbound REVERTED status
                     if (ob.outboundStatus === types_2.OutboundStatus.REVERTED) {
                         (0, context_1.printLog)(ctx, `[waitForOutboundTx] Outbound to ${ob.destinationChain} REVERTED`);
                         progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
-                        throw new OutboundFailedError(`Outbound to ${ob.destinationChain} reverted: ${((_h = ob.observedTx) === null || _h === void 0 ? void 0 : _h.errorMsg) || 'Unknown'}. Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash, ob.destinationChain, (_j = ob.observedTx) === null || _j === void 0 ? void 0 : _j.txHash);
+                        throw new OutboundFailedError(`Outbound to ${ob.destinationChain} reverted: ${((_k = ob.observedTx) === null || _k === void 0 ? void 0 : _k.errorMsg) || 'Unknown'}. Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash, ob.destinationChain, (_l = ob.observedTx) === null || _l === void 0 ? void 0 : _l.txHash);
                     }
                     // FOUND gating logic:
                     //   1. Primary path — cosmos has transitioned to OBSERVED (the
@@ -218,12 +252,7 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                     //      destination chain's own RPC: if its receipt is success,
                     //      treat as FOUND; if reverted, throw OutboundFailedError.
                     //      Pending receipts keep polling.
-                    if ((_k = ob.observedTx) === null || _k === void 0 ? void 0 : _k.txHash) {
-                        // If a destination chain filter is set, skip outbound entries that don't match
-                        if (_expectedDestinationChain && ob.destinationChain !== _expectedDestinationChain) {
-                            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound chain '${ob.destinationChain}' does not match expected '${_expectedDestinationChain}', skipping`);
-                            continue;
-                        }
+                    if ((_m = ob.observedTx) === null || _m === void 0 ? void 0 : _m.txHash) {
                         const chain = (0, helpers_1.chainFromNamespace)(ob.destinationChain);
                         if (!chain)
                             continue;
@@ -232,7 +261,7 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                             // Tiebreaker: ask the destination-chain RPC directly.
                             const verdict = yield verifyExternalEvmReceipt(ctx, chain, ob.observedTx.txHash);
                             if (verdict === 'reverted') {
-                                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Source-chain RPC reports REVERTED for ${ob.destinationChain} tx ${ob.observedTx.txHash} (cosmos still ${(_l = types_1.UniversalTxStatus[statusNum]) !== null && _l !== void 0 ? _l : statusNum})`);
+                                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Source-chain RPC reports REVERTED for ${ob.destinationChain} tx ${ob.observedTx.txHash} (cosmos still ${(_o = types_1.UniversalTxStatus[statusNum]) !== null && _o !== void 0 ? _o : statusNum})`);
                                 progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
                                 throw new OutboundFailedError(`Outbound to ${ob.destinationChain} reverted on source-chain RPC (tx: ${ob.observedTx.txHash}). Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash, ob.destinationChain, ob.observedTx.txHash);
                             }
@@ -240,24 +269,26 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                                 // 'pending' or 'unsupported' — keep polling, cosmos will catch up.
                                 continue;
                             }
-                            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Source-chain RPC tiebreaker: ${chain} tx ${ob.observedTx.txHash} succeeded; treating as FOUND despite cosmos status ${(_m = types_1.UniversalTxStatus[statusNum]) !== null && _m !== void 0 ? _m : statusNum}`);
+                            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Source-chain RPC tiebreaker: ${chain} tx ${ob.observedTx.txHash} succeeded; treating as FOUND despite cosmos status ${(_p = types_1.UniversalTxStatus[statusNum]) !== null && _p !== void 0 ? _p : statusNum}`);
                         }
                         {
-                            const explorerBaseUrl = (_o = chain_1.CHAIN_INFO[chain]) === null || _o === void 0 ? void 0 : _o.explorerUrl;
-                            const isSvm = ((_p = chain_1.CHAIN_INFO[chain]) === null || _p === void 0 ? void 0 : _p.vm) === enums_1.VM.SVM;
-                            // For SVM chains, convert hex txHash to base58 and append cluster param
-                            let displayTxHash = ob.observedTx.txHash;
+                            const explorerBaseUrl = (_q = chain_1.CHAIN_INFO[chain]) === null || _q === void 0 ? void 0 : _q.explorerUrl;
+                            const isSvm = ((_r = chain_1.CHAIN_INFO[chain]) === null || _r === void 0 ? void 0 : _r.vm) === enums_1.VM.SVM;
+                            const displayTxHash = (_s = (0, helpers_1.toExternalTxHashDisplay)(chain, ob.observedTx.txHash)) !== null && _s !== void 0 ? _s : ob.observedTx.txHash;
                             let explorerUrl = '';
-                            if (isSvm && ob.observedTx.txHash.startsWith('0x')) {
-                                const bytes = new Uint8Array(Buffer.from(ob.observedTx.txHash.slice(2), 'hex'));
-                                displayTxHash = bs58_1.bs58.encode(Buffer.from(bytes));
+                            if (isSvm) {
                                 const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET ? '?cluster=devnet'
                                     : chain === enums_1.CHAIN.SOLANA_TESTNET ? '?cluster=testnet' : '';
                                 explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${displayTxHash}${cluster}` : '';
                             }
                             else {
-                                explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${ob.observedTx.txHash}` : '';
+                                explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${displayTxHash}` : '';
                             }
+                            // OutboundTxDetails carries the raw `0x`-hex form so internal
+                            // consumers (R3 inbound tracker in response-builder.ts:786 →
+                            // findChildUtxIdFromExternalTx → Cosmos query) keep working.
+                            // The base58 display form is applied at every user-facing
+                            // boundary via `toExternalTxHashDisplay` (helpers.ts).
                             const details = {
                                 externalTxHash: ob.observedTx.txHash,
                                 destinationChain: chain,
@@ -266,7 +297,7 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                                 amount: ob.amount,
                                 assetAddr: ob.externalAssetAddr,
                             };
-                            (0, context_1.printLog)(ctx, `[waitForOutboundTx] FOUND on poll #${pollCount} | elapsed: ${Date.now() - startTime}ms | externalTxHash: ${details.externalTxHash}`);
+                            (0, context_1.printLog)(ctx, `[waitForOutboundTx] FOUND on poll #${pollCount} | elapsed: ${Date.now() - startTime}ms | externalTxHash: ${displayTxHash}`);
                             progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'found', elapsed: Date.now() - startTime });
                             return details;
                         }
@@ -302,8 +333,8 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
  */
 function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        const { initialWaitMs, pollingIntervalMs, timeout, progressHook } = options;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        const { initialWaitMs, pollingIntervalMs, timeout, progressHook, _resolvedSubTxId, } = options;
         const startTime = Date.now();
         // Build a map: CAIP-2 namespace -> hop(s) for matching outbound entries
         const chainToHops = new Map();
@@ -341,7 +372,11 @@ function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
             });
         }
         // Extract sub-tx ID for V2 query
-        let cachedQueryId;
+        let cachedQueryId = _resolvedSubTxId
+            ? _resolvedSubTxId.startsWith('0x')
+                ? _resolvedSubTxId.slice(2)
+                : _resolvedSubTxId
+            : undefined;
         let pollCount = 0;
         let consecutiveErrors = 0;
         const MAX_CONSECUTIVE_ERRORS = 10;
@@ -364,67 +399,101 @@ function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
                 const statusName = (_a = types_1.UniversalTxStatus[statusNum]) !== null && _a !== void 0 ? _a : statusNum;
                 (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${(_c = (_b = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0}`);
                 if ((_d = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _d === void 0 ? void 0 : _d.length) {
+                    const outboundOrdinalByChain = new Map();
                     for (const ob of utx.outboundTx) {
                         const destChain = ob.destinationChain;
                         const hopsForChain = chainToHops.get(destChain);
                         if (!hopsForChain)
                             continue;
-                        const unconfirmedForChain = hopsForChain.filter((h) => h.status !== 'confirmed' && h.status !== 'failed');
-                        if (unconfirmedForChain.length === 0)
+                        const outboundOrdinal = (_e = outboundOrdinalByChain.get(destChain)) !== null && _e !== void 0 ? _e : 0;
+                        outboundOrdinalByChain.set(destChain, outboundOrdinal + 1);
+                        const targetHop = hopsForChain[outboundOrdinal];
+                        if (!targetHop ||
+                            targetHop.status === 'confirmed' ||
+                            targetHop.status === 'failed') {
                             continue;
-                        // Fail fast on per-outbound REVERTED
-                        if (ob.outboundStatus === types_2.OutboundStatus.REVERTED) {
-                            for (const hop of unconfirmedForChain) {
-                                hop.status = 'failed';
-                                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Outbound to ${destChain} REVERTED | hop ${hop.hopIndex} | error: ${((_e = ob.observedTx) === null || _e === void 0 ? void 0 : _e.errorMsg) || 'Unknown'}`);
-                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                    hopIndex: hop.hopIndex,
-                                    route: hop.route,
-                                    chain: hop.executionChain,
-                                    status: 'failed',
-                                });
-                            }
-                            return { success: false, failedAt: unconfirmedForChain[0].hopIndex };
                         }
-                        // Check for OBSERVED with txHash
                         const externalTxHash = (_f = ob.observedTx) === null || _f === void 0 ? void 0 : _f.txHash;
-                        if (externalTxHash && (ob.outboundStatus === types_2.OutboundStatus.OBSERVED || ob.outboundStatus === 0)) {
+                        const hasObservedTxHash = !!externalTxHash && externalTxHash !== 'EMPTY';
+                        const observedFailure = hasObservedTxHash &&
+                            ((_g = ob.observedTx) === null || _g === void 0 ? void 0 : _g.success) === false &&
+                            Boolean(((_h = ob.observedTx) === null || _h === void 0 ? void 0 : _h.errorMsg) ||
+                                ob.abortReason ||
+                                ob.outboundStatus >= types_2.OutboundStatus.REVERTED);
+                        // Fail fast on per-outbound REVERTED or observed destination failure.
+                        if (ob.outboundStatus === types_2.OutboundStatus.REVERTED || observedFailure) {
+                            targetHop.status = 'failed';
+                            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Outbound to ${destChain} REVERTED | outboundIndex ${outboundOrdinal} | hop ${targetHop.hopIndex} | error: ${ob.abortReason || ((_j = ob.observedTx) === null || _j === void 0 ? void 0 : _j.errorMsg) || 'Unknown'}`);
+                            progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                hopIndex: targetHop.hopIndex,
+                                route: targetHop.route,
+                                chain: targetHop.executionChain,
+                                status: 'failed',
+                            });
+                            return { success: false, failedAt: targetHop.hopIndex };
+                        }
+                        // Check for observed tx hash. Cosmos may lag the status transition,
+                        // so EVM destinations are verified against the destination receipt.
+                        if (hasObservedTxHash && externalTxHash) {
                             const chain = (0, helpers_1.chainFromNamespace)(destChain);
+                            if (!chain)
+                                continue;
+                            const isCosmosObserved = ob.outboundStatus === types_2.OutboundStatus.OBSERVED;
+                            if (!isCosmosObserved) {
+                                const verdict = yield verifyExternalEvmReceipt(ctx, chain, externalTxHash);
+                                if (verdict === 'reverted') {
+                                    targetHop.status = 'failed';
+                                    (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Source-chain RPC reports REVERTED for ${destChain} tx ${externalTxHash} | outboundIndex ${outboundOrdinal} | hop ${targetHop.hopIndex}`);
+                                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                        hopIndex: targetHop.hopIndex,
+                                        route: targetHop.route,
+                                        chain: targetHop.executionChain,
+                                        status: 'failed',
+                                    });
+                                    return { success: false, failedAt: targetHop.hopIndex };
+                                }
+                                if (verdict !== 'success') {
+                                    continue;
+                                }
+                            }
+                            // Build the display form for SVM (base58) used in `hop.txHash` /
+                            // `hop.outboundDetails.externalTxHash` / the progressHook event —
+                            // these are USER-FACING. The internal raw-hex form stays only
+                            // inside this function; it's not exposed to consumers from the
+                            // cascade path (cascade.ts doesn't call findChildUtxIdFromExternalTx
+                            // for the cascade outbound hash).
+                            const displayTxHash = (_k = (0, helpers_1.toExternalTxHashDisplay)(chain !== null && chain !== void 0 ? chain : undefined, externalTxHash)) !== null && _k !== void 0 ? _k : externalTxHash;
                             let explorerUrl = '';
                             if (chain && externalTxHash) {
-                                const explorerBaseUrl = (_g = chain_1.CHAIN_INFO[chain]) === null || _g === void 0 ? void 0 : _g.explorerUrl;
-                                const isSvm = ((_h = chain_1.CHAIN_INFO[chain]) === null || _h === void 0 ? void 0 : _h.vm) === enums_1.VM.SVM;
-                                if (isSvm && externalTxHash.startsWith('0x')) {
-                                    const bytes = new Uint8Array(Buffer.from(externalTxHash.slice(2), 'hex'));
-                                    const base58Hash = bs58_1.bs58.encode(Buffer.from(bytes));
+                                const explorerBaseUrl = (_l = chain_1.CHAIN_INFO[chain]) === null || _l === void 0 ? void 0 : _l.explorerUrl;
+                                const isSvm = ((_m = chain_1.CHAIN_INFO[chain]) === null || _m === void 0 ? void 0 : _m.vm) === enums_1.VM.SVM;
+                                if (isSvm) {
                                     const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET ? '?cluster=devnet'
                                         : chain === enums_1.CHAIN.SOLANA_TESTNET ? '?cluster=testnet' : '';
-                                    explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${base58Hash}${cluster}` : '';
+                                    explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${displayTxHash}${cluster}` : '';
                                 }
                                 else {
-                                    explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${externalTxHash}` : '';
+                                    explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${displayTxHash}` : '';
                                 }
                             }
-                            for (const hop of unconfirmedForChain) {
-                                hop.status = 'confirmed';
-                                hop.txHash = externalTxHash;
-                                hop.outboundDetails = {
-                                    externalTxHash,
-                                    destinationChain: chain || hop.executionChain,
-                                    explorerUrl,
-                                    recipient: ob.recipient,
-                                    amount: ob.amount,
-                                    assetAddr: ob.externalAssetAddr,
-                                };
-                                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] FOUND outbound for ${destChain} | hop ${hop.hopIndex} | externalTxHash: ${externalTxHash}`);
-                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                    hopIndex: hop.hopIndex,
-                                    route: hop.route,
-                                    chain: hop.executionChain,
-                                    status: 'confirmed',
-                                    txHash: externalTxHash,
-                                });
-                            }
+                            targetHop.status = 'confirmed';
+                            targetHop.txHash = displayTxHash;
+                            targetHop.outboundDetails = {
+                                externalTxHash: displayTxHash,
+                                destinationChain: chain || targetHop.executionChain,
+                                explorerUrl,
+                                recipient: ob.recipient,
+                                amount: ob.amount,
+                                assetAddr: ob.externalAssetAddr,
+                            };
+                            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] FOUND outbound for ${destChain} | outboundIndex ${outboundOrdinal} | hop ${targetHop.hopIndex} | externalTxHash: ${displayTxHash}`);
+                            progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                hopIndex: targetHop.hopIndex,
+                                route: targetHop.route,
+                                chain: targetHop.executionChain,
+                                status: 'confirmed',
+                                txHash: displayTxHash,
+                            });
                         }
                     }
                 }
@@ -439,7 +508,7 @@ function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
                 if (statusNum === types_1.UniversalTxStatus.PC_EXECUTED_SUCCESS) {
                     const stillUnresolved = outboundHops.filter((h) => h.status !== 'confirmed');
                     if (stillUnresolved.length > 0) {
-                        const hasPendingOutbound = (_j = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _j === void 0 ? void 0 : _j.some((ob) => {
+                        const hasPendingOutbound = (_o = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _o === void 0 ? void 0 : _o.some((ob) => {
                             var _a;
                             return ob.outboundStatus === types_2.OutboundStatus.PENDING &&
                                 (!((_a = ob.observedTx) === null || _a === void 0 ? void 0 : _a.txHash) || ob.observedTx.txHash === 'EMPTY');

package/src/lib/orchestrator/internals/pc-usd-oracle.d.ts

@@ -1,6 +1,6 @@
 import { CHAIN } from '../../constants/enums';
 import type { OrchestratorContext } from './context';
-type StableKey = 'USDT_ETH' | 'USDT_ARB' | 'USDT_BASE' | 'USDT_BNB' | 'USDT_SOL';
+type StableKey = 'USDT_ETH' | 'USDT_ARB' | 'USDT_BASE' | 'USDT_BNB' | 'USDC_BNB' | 'USDT_SOL';
 /**
  * Get $PC/USD price (8 decimals) for the given origin chain's route.
  * Returns 0 on any failure — caller is expected to fall back to

package/src/lib/orchestrator/internals/pc-usd-oracle.js

@@ -15,8 +15,9 @@ const tslib_1 = require("tslib");
  *   - Ethereum / Arbitrum / Base / BNB → WPC/USDT.<route>
  *   - Solana → WPC/USDT.sol
  *
- * Pool pair (USDT vs USDC) is pending Zaryab/Zartaj confirmation — flip the
- * ORIGIN_TO_STABLE map below if they pick USDC.
+ * Confirmed testnet pool-token addresses are sourced from
+ * SYNTHETIC_PUSH_ERC20. Flip ORIGIN_TO_STABLE if a route should use USDC
+ * instead of USDT.
  *
  * Returns price in **8 decimals** (USD per 1 WPC) to match the convention
  * used by PriceFetch.getPrice.
@@ -153,7 +154,7 @@ function getPcUsdPrice(ctx, originChain) {
             const universalCoreAddress = yield ctx.pushClient.readContract({
                 address: gatewayPcAddress,
                 abi: abi_1.UNIVERSAL_GATEWAY_PC,
-                functionName: 'UNIVERSAL_CORE',
+                functionName: 'universalCore',
                 args: [],
             });
             const [wpcAddress, factoryAddress, defaultFeeTier] = yield Promise.all([

package/src/lib/orchestrator/internals/preflight.d.ts

@@ -23,7 +23,7 @@ import { type PreflightPathTag } from './errors';
 export interface RunPreflightOpts {
     ctx: OrchestratorContext;
     ueaAddress: `0x${string}`;
-    /** Effective UEA balance in wei UPC (already includes fresh-wallet prediction). */
+    /** Effective UEA balance in native PC wei (already includes fresh-wallet prediction). */
     ueaBalance: bigint;
     /** Buffered pool quote (pre-clamp) — what the SDK would actually attempt. */
     requiredValue: bigint;
@@ -36,30 +36,16 @@ export interface RunPreflightOpts {
     prc20Balance?: bigint;
     /** Cascade-only: identifies which segment failed. */
     segmentIndex?: number;
-    /**
-     * Per-call opt-out (`params.options.allowUnderfundedSwap`). When `true`,
-     * pre-flight logs the shortfall but does NOT fire 203-04 or throw —
-     * caller can fall back to the legacy clamp-and-refund branch.
-     */
-    allowUnderfundedSwap?: boolean;
 }
 export type PreflightResult = {
     ok: true;
     /** What `nativeValueForGas` should be (== requiredValue when sufficient). */
     adjustedValue: bigint;
-} | {
-    ok: false;
-    /** Set when allowUnderfundedSwap=true: the legacy clamped value. */
-    legacyClampedValue: bigint;
 };
 /**
  * Pre-flight check. PRC-20 balance is checked before the native check —
  * a missing burn token fails before the gas-balance check, so the user
- * sees the actionable PRC-20 shortfall instead of a stale UPC error.
- *
- * Returns a result object instead of throwing for the legacy opt-out
- * path. The throw happens here (not in the caller) for the default
- * `allowUnderfundedSwap=false` case so all 6 paths share one throw site.
+ * sees the actionable PRC-20 shortfall instead of a stale native PC error.
  */
 export declare function runPreflight(opts: RunPreflightOpts): PreflightResult;
 /**

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

@@ -26,31 +26,13 @@ exports.maybeFireSvmWarnThreshold = maybeFireSvmWarnThreshold;
 const context_1 = require("./context");
 const progress_hook_types_1 = require("../../progress-hook/progress-hook.types");
 const errors_1 = require("./errors");
-/**
- * Internal: compute the legacy clamp value (matches the pre-existing
- * branches in route-handlers.ts:643-659 / :968-980 / :1396-1412).
- * Returned only when `allowUnderfundedSwap=true`.
- */
-function legacyClamp(ueaBalance, requiredValue, gasReserve) {
-    if (ueaBalance >= requiredValue + gasReserve)
-        return requiredValue;
-    if (ueaBalance > gasReserve)
-        return ueaBalance - gasReserve;
-    if (ueaBalance > BigInt(0))
-        return ueaBalance < requiredValue ? ueaBalance : requiredValue;
-    return BigInt(0);
-}
 /**
  * Pre-flight check. PRC-20 balance is checked before the native check —
  * a missing burn token fails before the gas-balance check, so the user
- * sees the actionable PRC-20 shortfall instead of a stale UPC error.
- *
- * Returns a result object instead of throwing for the legacy opt-out
- * path. The throw happens here (not in the caller) for the default
- * `allowUnderfundedSwap=false` case so all 6 paths share one throw site.
+ * sees the actionable PRC-20 shortfall instead of a stale native PC error.
  */
 function runPreflight(opts) {
-    const { ctx, ueaAddress, ueaBalance, requiredValue, gasReserve, pathTag, burnToken, burnAmount, prc20Balance, segmentIndex, allowUnderfundedSwap, } = opts;
+    const { ctx, ueaAddress, ueaBalance, requiredValue, gasReserve, pathTag, burnToken, burnAmount, prc20Balance, segmentIndex, } = opts;
     // Each route bucket gets its own preflight IDs so hook streams stay
     // self-consistent within their convention (R2 → 203-xx, R3 → 303-xx,
     // cascade → 003-xx). The three hook formatters share an identical
@@ -75,15 +57,6 @@ function runPreflight(opts) {
         (0, context_1.fireProgressHook)(ctx, HOOK_PRE_INFO, burnAmount, onHand, sufficient, ueaAddress, pathTag, { kind: 'PRC20', burnToken, segmentIndex });
         if (!sufficient) {
             const shortfall = burnAmount - onHand;
-            if (allowUnderfundedSwap) {
-                (0, context_1.printLog)(ctx, `[preflight ${pathTag}] PRC-20 shortfall ${shortfall} of ${burnToken}; ` +
-                    `allowUnderfundedSwap=true — proceeding with legacy clamp behaviour, ` +
-                    `swap is expected to revert with InsufficientBalance(0xf4d678b8) on-chain.`);
-                return {
-                    ok: false,
-                    legacyClampedValue: legacyClamp(ueaBalance, requiredValue, gasReserve),
-                };
-            }
             (0, context_1.fireProgressHook)(ctx, HOOK_PRE_FAIL, burnAmount, onHand, shortfall, ueaAddress, pathTag, { kind: 'PRC20', burnToken, segmentIndex });
             throw new errors_1.InsufficientUEABalanceError({
                 required: burnAmount,
@@ -105,13 +78,6 @@ function runPreflight(opts) {
         return { ok: true, adjustedValue: requiredValue };
     }
     const shortfall = totalRequired - ueaBalance;
-    if (allowUnderfundedSwap) {
-        const clamped = legacyClamp(ueaBalance, requiredValue, gasReserve);
-        (0, context_1.printLog)(ctx, `[preflight ${pathTag}] UPC shortfall ${shortfall} wei; ` +
-            `allowUnderfundedSwap=true — proceeding with legacy clamped value ${clamped}, ` +
-            `swap may revert inside Uniswap with Error("STF") if the clamp under-funds the pool quote.`);
-        return { ok: false, legacyClampedValue: clamped };
-    }
     (0, context_1.fireProgressHook)(ctx, HOOK_PRE_FAIL, totalRequired, ueaBalance, shortfall, ueaAddress, pathTag, { kind: 'NATIVE', segmentIndex });
     throw new errors_1.InsufficientUEABalanceError({
         required: totalRequired,

package/src/lib/orchestrator/internals/push-chain-tx.js

@@ -20,6 +20,7 @@ const context_1 = require("./context");
 const error_decoder_1 = require("./error-decoder");
 const errors_1 = require("./errors");
 Object.defineProperty(exports, "PushChainExecutionError", { enumerable: true, get: function () { return errors_1.PushChainExecutionError; } });
+const formatters_1 = require("../../formatters");
 // ============================================================================
 // sendPushTx
 // ============================================================================
@@ -302,7 +303,10 @@ function extractPcTxAndTransform(ctx, pushChainUniversalTx, gatewayTxHash, event
             const failedPcTx = (lastPcTransaction === null || lastPcTransaction === void 0 ? void 0 : lastPcTransaction.status) === 'FAILED'
                 ? lastPcTransaction
                 : pushChainUniversalTx.pcTx.find((pcTx) => pcTx.status === 'FAILED' && pcTx.errorMsg);
-            const errorDetails = (failedPcTx === null || failedPcTx === void 0 ? void 0 : failedPcTx.errorMsg) ? `: ${failedPcTx.errorMsg}` : '';
+            const failedPcTxErrorMsg = (failedPcTx === null || failedPcTx === void 0 ? void 0 : failedPcTx.errorMsg)
+                ? (0, formatters_1.normalizePcInsufficientFundsError)(failedPcTx.errorMsg)
+                : '';
+            const errorDetails = failedPcTxErrorMsg ? `: ${failedPcTxErrorMsg}` : '';
             // Decode known revert selectors and ABI-encoded `Error(string)` reverts
             // into actionable hints. Unknown selectors are logged at INFO so the
             // table can grow from real reverts.

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

@@ -536,7 +536,7 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
             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;
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j;
                 // 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
@@ -605,9 +605,17 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                             timeout: outboundTimeoutMs,
                             progressHook: outboundTranslator,
                         });
-                        emit(hooks.success(outboundDetails));
-                        // Merge external chain details into receipt
-                        baseReceipt = Object.assign(Object.assign({}, baseReceipt), { externalTxHash: outboundDetails.externalTxHash, externalChain: outboundDetails.destinationChain, externalExplorerUrl: outboundDetails.explorerUrl, externalRecipient: outboundDetails.recipient, externalAmount: outboundDetails.amount, externalAssetAddr: outboundDetails.assetAddr, externalStatus: 'success' });
+                        // `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.
@@ -637,7 +645,7 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                                 }
                                 else {
                                     // status === 'failed' (terminal failure status from chain)
-                                    const failMsg = (_f = inbound.errorMessage) !== null && _f !== void 0 ? _f : 'inbound execution failed on Push 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));
                                     baseReceipt = Object.assign(Object.assign({}, baseReceipt), { pushInboundUtxId: inbound.childUtxId, pushInboundTxHash: inbound.pushTxHash || undefined, externalStatus: 'failed', externalError: failMsg });
                                 }
@@ -669,8 +677,16 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                         // observed tx hash is carried by OutboundFailedError — expose it
                         // as externalTxHash so consumers can link to the explorer.
                         const failedExternalTxHash = error instanceof outbound_sync_1.OutboundFailedError ? error.externalTxHash : undefined;
-                        baseReceipt = Object.assign(Object.assign(Object.assign({}, baseReceipt), { externalStatus: isTimeout ? 'timeout' : 'failed', externalError: errMsg }), (failedExternalTxHash
-                            ? { externalTxHash: failedExternalTxHash }
+                        // 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;
+                        baseReceipt = Object.assign(Object.assign(Object.assign({}, 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