@pushchain/core 5.1.17 → 6.0.0

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

@@ -11,6 +11,7 @@ exports.prepareTransaction = prepareTransaction;
 exports.buildHopDescriptor = buildHopDescriptor;
 exports.classifyIntoSegments = classifyIntoSegments;
 exports.getSegmentType = getSegmentType;
+exports.composeCascadeDetailed = composeCascadeDetailed;
 exports.composeCascade = composeCascade;
 exports.createCascadedBuilder = createCascadedBuilder;
 const tslib_1 = require("tslib");
@@ -38,6 +39,7 @@ const preflight_1 = require("./preflight");
 const svm_rent_1 = require("./svm-rent");
 const errors_1 = require("./errors");
 const context_2 = require("./context");
+const inbound_tracker_1 = require("./inbound-tracker");
 // ============================================================================
 // dispatchCascadeProgressEvent
 // ============================================================================
@@ -120,20 +122,32 @@ function prepareTransaction(ctx, params, callbacks) {
 // ============================================================================
 function buildHopDescriptor(ctx, params, route, ueaAddress) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-        // Pass 0 when user omits gasLimit → contract uses per-chain baseGasLimitByChainNamespace
-        const gasLimit = (_a = params.gasLimit) !== null && _a !== void 0 ? _a : BigInt(0);
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        // Pass 0 when user omits gasLimit so the contract uses the per-chain base,
+        // except EVM Route 3 where a CEA deploy + sendUniversalTxToUEA needs more
+        // than the generic 500k source-chain base.
+        const defaultGasLimit = route === route_detector_1.TransactionRoute.CEA_TO_PUSH &&
+            ((_a = params.from) === null || _a === void 0 ? void 0 : _a.chain) &&
+            !(0, payload_builders_1.isSvmChain)(params.from.chain)
+            ? selectors_1.DEFAULT_CEA_TO_PUSH_GAS_LIMIT
+            : BigInt(0);
+        const gasLimit = (_b = params.gasLimit) !== null && _b !== void 0 ? _b : defaultGasLimit;
         const routeStr = route;
         const baseDescriptor = {
             params,
             route: routeStr,
             gasLimit,
+            maxPCForGas: (_c = params.maxPCForGas) !== null && _c !== void 0 ? _c : BigInt(0),
             ueaAddress,
             revertRecipient: ueaAddress,
         };
         switch (route) {
             case route_detector_1.TransactionRoute.UOA_TO_PUSH: {
                 // Route 1: Build Push Chain multicalls
+                const seedAmount = (_d = params.value) !== null && _d !== void 0 ? _d : BigInt(0);
+                if (isValueOnlyNativeSeedToOwnUea(params, ueaAddress)) {
+                    return Object.assign(Object.assign({}, baseDescriptor), { pushMulticalls: [], nativeSeedOnly: true, nativeSeedAmount: seedAmount });
+                }
                 const executeParams = (0, helpers_1.toExecuteParams)(params);
                 const pushMulticalls = (0, payload_builders_1.buildExecuteMulticall)({
                     execute: executeParams,
@@ -155,7 +169,7 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                     });
                     let prc20Token = selectors_1.ZERO_ADDRESS;
                     let burnAmount = BigInt(0);
-                    if ((_b = params.funds) === null || _b === void 0 ? void 0 : _b.amount) {
+                    if ((_e = params.funds) === null || _e === void 0 ? void 0 : _e.amount) {
                         const token = params.funds.token;
                         if (token) {
                             prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token).address;
@@ -177,53 +191,70 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                     }
                     let gasToken = selectors_1.ZERO_ADDRESS;
                     let gasFee = BigInt(0);
+                    let gasPrice = BigInt(0);
                     let sizing;
-                    // Conditional CEA-ATA rent bump (SPL-only). Mirrors single-route
-                    // executeUoaToCeaSvm path. See svm-rent.ts for rationale.
-                    const splMintBase58 = burnAmount > BigInt(0)
-                        ? (_d = (_c = params.funds) === null || _c === void 0 ? void 0 : _c.token) === null || _d === void 0 ? void 0 : _d.address
+                    // SVM finalize budget: compare the quoted gasFee in lamports against
+                    // the gateway finalize minimum, then re-query with a bumped gasLimit
+                    // if the default quote is too low.
+                    const svmFundsToken = burnAmount > BigInt(0)
+                        ? (_f = params.funds) === null || _f === void 0 ? void 0 : _f.token
                         : undefined;
-                    const effectiveGasLimit = yield (0, svm_rent_1.maybeBumpForCeaAtaRent)({
-                        ctx,
-                        ueaAddress,
-                        targetChain,
-                        splMintBase58,
-                        burnAmount,
-                        effectiveGasLimit: gasLimit,
-                    });
+                    const splMintBase58 = (svmFundsToken === null || svmFundsToken === void 0 ? void 0 : svmFundsToken.mechanism) === 'approve'
+                        ? svmFundsToken.address
+                        : undefined;
+                    let effectiveGasLimit = gasLimit;
                     if (prc20Token !== selectors_1.ZERO_ADDRESS) {
-                        const result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, effectiveGasLimit, targetChain);
+                        let result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, effectiveGasLimit, targetChain);
+                        result = yield (0, svm_rent_1.ensureSvmFinalizeGasBudgetQuote)({
+                            ctx,
+                            ueaAddress,
+                            targetChain,
+                            prc20Token,
+                            quote: result,
+                            splMintBase58,
+                            burnAmount,
+                            pathTag: 'buildHopDescriptor',
+                        });
                         gasToken = result.gasToken;
                         gasFee = result.gasFee;
+                        gasPrice = result.gasPrice;
                         sizing = result.sizing;
+                        effectiveGasLimit = result.gasLimitUsed;
+                        if (!params.gasLimit) {
+                            (0, context_1.printLog)(ctx, `buildHopDescriptor — SVM resolved effectiveGasLimit: ${effectiveGasLimit} ` +
+                                `(gasFee=${result.gasFee}, gasPrice=${result.gasPrice})`);
+                        }
                     }
                     return Object.assign(Object.assign({}, baseDescriptor), { targetChain, isSvmTarget: true, svmPayload,
                         prc20Token,
                         burnAmount,
                         gasToken,
                         gasFee,
-                        sizing });
+                        gasPrice, gasLimit: effectiveGasLimit, sizing });
                 }
                 // EVM path: Resolve CEA address + build CEA multicalls
-                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain, (_e = ctx.rpcUrls[targetChain]) === null || _e === void 0 ? void 0 : _e[0]);
+                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain, (_g = ctx.rpcUrls[targetChain]) === null || _g === void 0 ? void 0 : _g[0]);
                 // Migration path: raw MIGRATION_SELECTOR payload, no multicall wrapping
                 if (params.migration) {
                     const prc20Token = (0, helpers_1.getNativePRC20ForChain)(targetChain, ctx.pushNetwork);
                     const burnAmount = BigInt(0); // Migration is logic-only — no funds. CEA rejects msg.value != 0.
                     let gasToken = selectors_1.ZERO_ADDRESS;
                     let gasFee = BigInt(0);
+                    let gasPrice = BigInt(0);
                     let sizing;
                     if (prc20Token !== selectors_1.ZERO_ADDRESS) {
                         const result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, gasLimit, targetChain);
                         gasToken = result.gasToken;
                         gasFee = result.gasFee;
+                        gasPrice = result.gasPrice;
                         sizing = result.sizing;
                     }
                     return Object.assign(Object.assign({}, baseDescriptor), { targetChain,
                         ceaAddress, ceaMulticalls: [], prc20Token,
                         burnAmount,
                         gasToken,
-                        gasFee, isMigration: true, sizing });
+                        gasFee,
+                        gasPrice, isMigration: true, sizing });
                 }
                 // Build CEA multicalls
                 const ceaMulticalls = [];
@@ -235,7 +266,7 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                         // When ERC-20 funds are provided with a single payload, auto-prepend a
                         // transfer() call so the tokens minted to the CEA are forwarded to the
                         // target address. This mirrors the Route 1 behavior in buildExecuteMulticall.
-                        if ((_f = params.funds) === null || _f === void 0 ? void 0 : _f.amount) {
+                        if ((_h = params.funds) === null || _h === void 0 ? void 0 : _h.amount) {
                             const token = params.funds.token;
                             if (token && token.mechanism !== 'native') {
                                 const erc20Transfer = (0, viem_1.encodeFunctionData)({
@@ -255,7 +286,7 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                         // native value to the CEA, and the multicall forwards it to the target.
                         ceaMulticalls.push({
                             to: target.address,
-                            value: (_g = params.value) !== null && _g !== void 0 ? _g : BigInt(0),
+                            value: (_j = params.value) !== null && _j !== void 0 ? _j : BigInt(0),
                             data: params.data,
                         });
                     }
@@ -271,7 +302,7 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                         });
                     }
                 }
-                else if ((_h = params.funds) === null || _h === void 0 ? void 0 : _h.amount) {
+                else if ((_k = params.funds) === null || _k === void 0 ? void 0 : _k.amount) {
                     // Funds-only transfer (no data, no value). Without this branch the
                     // CEA multicall is empty and relayed funds stay in the CEA instead
                     // of reaching the caller's recipient.
@@ -303,7 +334,7 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                 // Determine PRC-20 token and burn amount
                 let prc20Token = selectors_1.ZERO_ADDRESS;
                 let burnAmount = BigInt(0);
-                if ((_j = params.funds) === null || _j === void 0 ? void 0 : _j.amount) {
+                if ((_l = params.funds) === null || _l === void 0 ? void 0 : _l.amount) {
                     const token = params.funds.token;
                     if (token) {
                         prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token).address;
@@ -326,11 +357,13 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                 // Query gas fee
                 let gasToken = selectors_1.ZERO_ADDRESS;
                 let gasFee = BigInt(0);
+                let gasPrice = BigInt(0);
                 let sizing;
                 if (prc20Token !== selectors_1.ZERO_ADDRESS) {
                     const result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, gasLimit, targetChain);
                     gasToken = result.gasToken;
                     gasFee = result.gasFee;
+                    gasPrice = result.gasPrice;
                     sizing = result.sizing;
                 }
                 return Object.assign(Object.assign({}, baseDescriptor), { targetChain,
@@ -340,11 +373,16 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                     burnAmount,
                     gasToken,
                     gasFee,
+                    gasPrice,
                     sizing });
             }
             case route_detector_1.TransactionRoute.CEA_TO_PUSH: {
                 // Route 3: Build CEA multicalls for sendUniversalTxFromCEA
                 const sourceChain = params.from.chain;
+                const seedAmount = (_m = params.value) !== null && _m !== void 0 ? _m : BigInt(0);
+                if (isValueOnlyNativeSeedToOwnUea(params, ueaAddress)) {
+                    return Object.assign(Object.assign({}, baseDescriptor), { sourceChain, burnAmount: BigInt(0), gasToken: selectors_1.ZERO_ADDRESS, gasFee: BigInt(0), nativeSeedOnly: true, nativeSeedAmount: seedAmount });
+                }
                 // SVM chains use PDA-based CEA, not factory-deployed CEA
                 if ((0, payload_builders_1.isSvmChain)(sourceChain)) {
                     const lockerContract = chain_1.CHAIN_INFO[sourceChain].lockerContract;
@@ -361,7 +399,7 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                         Buffer.from(ceaPda.toBytes()).toString('hex'));
                     let amount = BigInt(0);
                     let prc20Token;
-                    if (((_k = params.funds) === null || _k === void 0 ? void 0 : _k.amount) && params.funds.amount > BigInt(0)) {
+                    if (((_o = params.funds) === null || _o === void 0 ? void 0 : _o.amount) && params.funds.amount > BigInt(0)) {
                         amount = params.funds.amount;
                         const token = params.funds.token;
                         if (token && token.address) {
@@ -381,25 +419,42 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                     }
                     let gasToken = selectors_1.ZERO_ADDRESS;
                     let gasFee = BigInt(0);
+                    let gasPrice = BigInt(0);
                     let sizing;
+                    let effectiveGasLimit = gasLimit;
                     if (prc20Token !== selectors_1.ZERO_ADDRESS) {
-                        const result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, gasLimit, sourceChain);
+                        let result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, effectiveGasLimit, sourceChain);
+                        result = yield (0, svm_rent_1.ensureSvmFinalizeGasBudgetQuote)({
+                            ctx,
+                            ueaAddress,
+                            targetChain: sourceChain,
+                            prc20Token,
+                            quote: result,
+                            splMintBase58: undefined,
+                            burnAmount: BigInt(0),
+                            pathTag: 'buildHopDescriptor',
+                        });
                         gasToken = result.gasToken;
                         gasFee = result.gasFee;
+                        gasPrice = result.gasPrice;
                         sizing = result.sizing;
+                        effectiveGasLimit = result.gasLimitUsed;
                     }
-                    return Object.assign(Object.assign({}, baseDescriptor), { sourceChain, ceaAddress: ceaPdaHex, isSvmTarget: true, prc20Token, burnAmount: amount, gasToken,
+                    return Object.assign(Object.assign({}, baseDescriptor), { sourceChain, ceaAddress: ceaPdaHex, isSvmTarget: true, prc20Token, 
+                        // Route 3 is payload-only on Push: the drain amount lives inside the
+                        // SVM payload. Burning here would require the UEA to pre-hold pSOL.
+                        burnAmount: BigInt(0), gasToken,
                         gasFee,
-                        sizing });
+                        gasPrice, gasLimit: effectiveGasLimit, sizing });
                 }
-                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_l = ctx.rpcUrls[sourceChain]) === null || _l === void 0 ? void 0 : _l[0]);
+                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_p = ctx.rpcUrls[sourceChain]) === null || _p === void 0 ? void 0 : _p[0]);
                 // CEA auto-deploys on-chain: Vault.finalizeUniversalTx calls CEAFactory.deployCEA()
                 // if CEA doesn't exist yet. No SDK-side blocking needed.
                 // Determine token/amount for the inbound
                 let tokenAddress = selectors_1.ZERO_ADDRESS;
                 let amount = BigInt(0);
                 let nativeValue = BigInt(0);
-                if ((_m = params.funds) === null || _m === void 0 ? void 0 : _m.amount) {
+                if ((_q = params.funds) === null || _q === void 0 ? void 0 : _q.amount) {
                     const token = params.funds.token;
                     if (token) {
                         if (token.mechanism === 'native') {
@@ -420,17 +475,24 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                 const prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
                 let gasToken = selectors_1.ZERO_ADDRESS;
                 let gasFee = BigInt(0);
+                let gasPrice = BigInt(0);
                 let sizing;
                 if (prc20Token !== selectors_1.ZERO_ADDRESS) {
                     const result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, gasLimit, sourceChain);
                     gasToken = result.gasToken;
                     gasFee = result.gasFee;
+                    gasPrice = result.gasPrice;
                     sizing = result.sizing;
                 }
                 return Object.assign(Object.assign({}, baseDescriptor), { sourceChain,
                     ceaAddress,
-                    prc20Token, burnAmount: amount, gasToken,
+                    prc20Token, 
+                    // Route 3 is payload-only on Push: the CEA-side sendUniversalTxToUEA
+                    // carries `amount`. Burning here would require the UEA to pre-hold the
+                    // token it is trying to receive from the external CEA.
+                    burnAmount: BigInt(0), gasToken,
                     gasFee,
+                    gasPrice,
                     sizing });
             }
             default:
@@ -463,7 +525,9 @@ function classifyIntoSegments(hops) {
                 ? currentSegment.targetChain === hop.targetChain && !hop.isSvmTarget
                 : segType === 'INBOUND_FROM_CEA'
                     ? currentSegment.sourceChain === hop.sourceChain &&
-                        !(0, payload_builders_1.isSvmChain)(hop.sourceChain)
+                        !(0, payload_builders_1.isSvmChain)(hop.sourceChain) &&
+                        isNativeSeedOnlyHop(currentSegment.hops[0]) ===
+                            isNativeSeedOnlyHop(hop)
                     : segType === 'PUSH_EXECUTION');
         if (canMerge && currentSegment) {
             // Merge into current segment
@@ -483,6 +547,8 @@ function classifyIntoSegments(hops) {
                 // Accumulate gas fees
                 currentSegment.gasFee =
                     (currentSegment.gasFee || BigInt(0)) + (hop.gasFee || BigInt(0));
+                currentSegment.gasPrice = mergeGasPrice(currentSegment.gasPrice, hop.gasPrice);
+                currentSegment.maxPCForGas = mergeMaxPCForGas(currentSegment.maxPCForGas, hop.maxPCForGas);
             }
             else if (segType === 'INBOUND_FROM_CEA') {
                 // Sum burn amounts so the single sendUniversalTxToUEA carries the
@@ -495,6 +561,8 @@ function classifyIntoSegments(hops) {
                 }
                 currentSegment.gasFee =
                     (currentSegment.gasFee || BigInt(0)) + (hop.gasFee || BigInt(0));
+                currentSegment.gasPrice = mergeGasPrice(currentSegment.gasPrice, hop.gasPrice);
+                currentSegment.maxPCForGas = mergeMaxPCForGas(currentSegment.maxPCForGas, hop.maxPCForGas);
             }
             else if (segType === 'PUSH_EXECUTION') {
                 currentSegment.mergedPushMulticalls = [
@@ -532,7 +600,9 @@ function classifyIntoSegments(hops) {
                 prc20Token: hop.prc20Token,
                 gasToken: hop.gasToken,
                 gasFee: hop.gasFee,
+                gasPrice: hop.gasPrice,
                 gasLimit: hop.gasLimit,
+                maxPCForGas: hop.maxPCForGas,
                 sizing: hop.sizing,
             };
             segments.push(currentSegment);
@@ -544,6 +614,18 @@ function classifyIntoSegments(hops) {
 function categoryRank(c) {
     return c === 'C' ? 2 : c === 'B' ? 1 : 0;
 }
+function mergeMaxPCForGas(current, next) {
+    const a = current !== null && current !== void 0 ? current : BigInt(0);
+    const b = next !== null && next !== void 0 ? next : BigInt(0);
+    if (a === BigInt(0) || b === BigInt(0))
+        return BigInt(0);
+    return a + b;
+}
+function mergeGasPrice(current, next) {
+    const a = current !== null && current !== void 0 ? current : BigInt(0);
+    const b = next !== null && next !== void 0 ? next : BigInt(0);
+    return a > b ? a : b;
+}
 // ============================================================================
 // getSegmentType
 // ============================================================================
@@ -559,46 +641,156 @@ function getSegmentType(route) {
             return 'PUSH_EXECUTION';
     }
 }
-// ============================================================================
-// composeCascade
-// ============================================================================
-function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
+function sumMulticallNativeValue(multicalls) {
+    return (multicalls !== null && multicalls !== void 0 ? multicalls : []).reduce((sum, mc) => { var _a; return sum + ((_a = mc.value) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+}
+function isEmptyPayloadData(data) {
+    return (data === undefined ||
+        data === '0x' ||
+        (Array.isArray(data) && data.length === 0));
+}
+function isValueOnlyNativeSeedToOwnUea(params, ueaAddress) {
+    var _a, _b;
+    return (((_a = params.value) !== null && _a !== void 0 ? _a : BigInt(0)) > BigInt(0) &&
+        !((_b = params.funds) === null || _b === void 0 ? void 0 : _b.amount) &&
+        isEmptyPayloadData(params.data) &&
+        typeof params.to === 'string' &&
+        params.to.toLowerCase() === ueaAddress.toLowerCase());
+}
+function isNativeSeedOnlyHop(hop) {
+    return (hop === null || hop === void 0 ? void 0 : hop.nativeSeedOnly) === true;
+}
+function isNativeSeedOnlySegment(segment) {
+    return (segment.type === 'INBOUND_FROM_CEA' &&
+        segment.hops.length > 0 &&
+        segment.hops.every((hop) => isNativeSeedOnlyHop(hop)));
+}
+function segmentNeedsOutboundGas(segment) {
+    return segment.type !== 'PUSH_EXECUTION' && !isNativeSeedOnlySegment(segment);
+}
+function buildRootOutboundIndexByHop(segments, hops) {
+    var _a;
+    const hopIndexByDescriptor = new Map();
+    hops.forEach((hop, index) => hopIndexByDescriptor.set(hop, index));
+    const nextIndexByChain = new Map();
+    const result = new Map();
+    for (const segment of segments) {
+        let chain;
+        if (segment.type === 'OUTBOUND_TO_CEA') {
+            chain = segment.targetChain;
+        }
+        else if (segment.type === 'INBOUND_FROM_CEA' &&
+            !isNativeSeedOnlySegment(segment)) {
+            chain = segment.sourceChain;
+        }
+        if (!chain)
+            continue;
+        const outboundIndex = (_a = nextIndexByChain.get(chain)) !== null && _a !== void 0 ? _a : 0;
+        for (const hop of segment.hops) {
+            const hopIndex = hopIndexByDescriptor.get(hop);
+            if (hopIndex !== undefined) {
+                result.set(hopIndex, outboundIndex);
+            }
+        }
+        nextIndexByChain.set(chain, outboundIndex + 1);
+    }
+    return result;
+}
+function sumNativeSeedAmount(hops) {
+    return hops.reduce((sum, hop) => { var _a; return sum + ((_a = hop.nativeSeedAmount) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+}
+function getCascadeNativeSeed(segments) {
+    var _a, _b, _c;
+    let total = BigInt(0);
+    for (const segment of segments) {
+        for (const hop of segment.hops) {
+            const value = (_a = hop.params.value) !== null && _a !== void 0 ? _a : BigInt(0);
+            if (isNativeSeedOnlyHop(hop)) {
+                total += (_b = hop.nativeSeedAmount) !== null && _b !== void 0 ? _b : value;
+                continue;
+            }
+            // In a CEA->Push hop that also supplies `funds`, `value` is native PC
+            // forwarded inside the inbound UEA payload. That value is available to
+            // later Push-side cascade calls and must be counted for sizing fresh UEAs.
+            if (segment.type === 'INBOUND_FROM_CEA' &&
+                value > BigInt(0) &&
+                ((_c = hop.params.funds) === null || _c === void 0 ? void 0 : _c.amount)) {
+                total += value;
+            }
+        }
+    }
+    return total;
+}
+function getInboundFundingForBurnToken(segments, beforeSegmentIndex, burnToken, pushNetwork) {
+    var _a;
+    let total = BigInt(0);
+    const normalizedBurnToken = burnToken.toLowerCase();
+    for (const segment of segments.slice(0, beforeSegmentIndex)) {
+        if (segment.type !== 'INBOUND_FROM_CEA')
+            continue;
+        for (const hop of segment.hops) {
+            const params = hop.params;
+            let fundedToken;
+            let fundedAmount = BigInt(0);
+            if ((_a = params.funds) === null || _a === void 0 ? void 0 : _a.amount) {
+                const token = params.funds.token;
+                if (token) {
+                    fundedToken = push_chain_1.PushChain.utils.tokens.getPRC20Address(token).address;
+                    fundedAmount = params.funds.amount;
+                }
+            }
+            else if (params.value &&
+                params.value > BigInt(0) &&
+                hop.sourceChain &&
+                !isNativeSeedOnlyHop(hop)) {
+                fundedToken = (0, helpers_1.getNativePRC20ForChain)(hop.sourceChain, pushNetwork);
+                fundedAmount = params.value;
+            }
+            if ((fundedToken === null || fundedToken === void 0 ? void 0 : fundedToken.toLowerCase()) === normalizedBurnToken) {
+                total += fundedAmount;
+            }
+        }
+    }
+    return total;
+}
+function composeCascadeDetailed(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
         let accumulatedPushMulticalls = [];
+        let requiredNativeValue = BigInt(0);
         const gatewayPcAddress = (0, helpers_1.getUniversalGatewayPCAddress)();
+        const currentUeaBalance = ueaBalance !== null && ueaBalance !== void 0 ? ueaBalance : BigInt(0);
+        const cascadeNativeSeed = getCascadeNativeSeed(segments);
+        const effectiveUeaBalance = currentUeaBalance + cascadeNativeSeed;
+        if (cascadeNativeSeed > BigInt(0)) {
+            (0, context_1.printLog)(ctx, `composeCascade — counting cascade native seed ${cascadeNativeSeed.toString()} for cascade sizing (current UEA balance ${currentUeaBalance.toString()})`);
+        }
         // Compute per-outbound nativeValueForGas from UEA balance
         // Each outbound segment needs native value for the gas swap on the destination chain.
         // The contract refunds excess, so over-allocating is safe.
-        const numOutbounds = segments.filter((s) => s.type !== 'PUSH_EXECUTION').length;
+        const numOutbounds = segments.filter(segmentNeedsOutboundGas).length;
         const CASCADE_GAS_RESERVE = BigInt(3e18); // 3 PC reserve for gas costs
         // Cascade pre-flight: catches the zero-balance silent-segment-zero failure
         // mode. When `ueaBalance <= CASCADE_GAS_RESERVE`, `perOutboundNativeValue`
         // is left undefined and downstream segments silently allocate value=0,
         // producing under-funded swaps that revert inside Uniswap. Throw early
         // with a structured error so the caller knows which path / hop failed.
-        // Honor the per-call opt-out from the first non-PUSH segment (segments share
-        // the same UniversalExecuteParams.options.allowUnderfundedSwap shape).
-        const firstOutboundSegment = segments.find((s) => s.type !== 'PUSH_EXECUTION');
-        const cascadeAllowUnderfunded = ((_d = (_c = (_b = (_a = firstOutboundSegment === null || firstOutboundSegment === void 0 ? void 0 : firstOutboundSegment.hops) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.params) === null || _c === void 0 ? void 0 : _c.options) === null || _d === void 0 ? void 0 : _d.allowUnderfundedSwap) ===
-            true;
         if (numOutbounds > 0) {
             (0, preflight_1.runPreflight)({
                 ctx,
                 ueaAddress,
-                ueaBalance: ueaBalance !== null && ueaBalance !== void 0 ? ueaBalance : BigInt(0),
+                ueaBalance: effectiveUeaBalance,
                 // Required = at least one wei of allocatable PC after reserve. The
                 // per-segment min-swap check below catches finer-grained shortfalls.
                 requiredValue: BigInt(1),
                 gasReserve: CASCADE_GAS_RESERVE,
                 pathTag: 'CASCADE',
-                allowUnderfundedSwap: cascadeAllowUnderfunded,
             });
         }
         let perOutboundNativeValue;
-        if (ueaBalance && numOutbounds > 0 && ueaBalance > CASCADE_GAS_RESERVE) {
+        if (numOutbounds > 0 && effectiveUeaBalance > CASCADE_GAS_RESERVE) {
             perOutboundNativeValue =
-                (ueaBalance - CASCADE_GAS_RESERVE) / BigInt(numOutbounds);
+                (effectiveUeaBalance - CASCADE_GAS_RESERVE) / BigInt(numOutbounds);
         }
         // Pool-price-based native-value override for SVM outbounds.
         // The flat split above works for EVM gas tokens (pBNB/pETH — cheap per unit),
@@ -614,11 +806,11 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                 s.gasFee > BigInt(0);
         });
         const svmNativeValueBySegment = new Map();
-        if (svmSegments.length > 0 && ueaBalance && ueaBalance > CASCADE_GAS_RESERVE) {
+        if (svmSegments.length > 0 && effectiveUeaBalance > CASCADE_GAS_RESERVE) {
             const universalCoreAddress = yield ctx.pushClient.readContract({
                 address: gatewayPcAddress,
                 abi: abi_1.UNIVERSAL_GATEWAY_PC,
-                functionName: 'UNIVERSAL_CORE',
+                functionName: 'universalCore',
                 args: [],
             });
             // Compute per-SVM budget = ueaBalance − (PC needed for EVM outbounds) − 1 PC safety
@@ -629,11 +821,11 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                 ? perOutboundNativeValue * BigInt(numEvmOutbounds)
                 : BigInt(0);
             const outerSafety = BigInt(1e18); // 1 PC for outer-tx gas
-            const svmTotal = ueaBalance > evmReservation + outerSafety
-                ? ueaBalance - evmReservation - outerSafety
+            const svmTotal = effectiveUeaBalance > evmReservation + outerSafety
+                ? effectiveUeaBalance - evmReservation - outerSafety
                 : BigInt(0);
             const perSvmCap = svmTotal / BigInt(svmSegments.length);
-            const UNCAPPED_BALANCE = BigInt(1e30); // effectively disable estimator's internal cap
+            const UNCAPPED_BALANCE = BigInt('1000000000000000000000000000000'); // effectively disable estimator's internal cap
             for (const seg of svmSegments) {
                 // Cascade-level segment index (position in `segments`, not in `svmSegments`)
                 // so the error's `segmentIndex` lines up with what the caller sees.
@@ -643,8 +835,13 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                 (0, preflight_1.maybeFireSvmWarnThreshold)(ctx, estimated, seg.gasToken, 'CASCADE');
                 const flat = perOutboundNativeValue !== null && perOutboundNativeValue !== void 0 ? perOutboundNativeValue : BigInt(0);
                 let value = estimated > flat ? estimated : flat;
-                if (perSvmCap > BigInt(0) && value > perSvmCap)
-                    value = perSvmCap;
+                if (perSvmCap > BigInt(0) && value > perSvmCap) {
+                    const cappedValue = perSvmCap >= estimated ? perSvmCap : estimated;
+                    if (cappedValue !== perSvmCap) {
+                        (0, context_1.printLog)(ctx, `composeCascade — SVM outbound to ${(_a = seg.hops[0]) === null || _a === void 0 ? void 0 : _a.targetChain}: perSvmCap=${perSvmCap} is below live pool quote=${estimated}; using quote to avoid underfunded gas swap`);
+                    }
+                    value = cappedValue;
+                }
                 // Upward-allocation ceiling (mirrors R3 SVM Fix #4 in route-handlers.ts:1690).
                 // When UEA balance is huge, the flat split or perSvmCap can produce a value
                 // far above what the swap actually needs. Submitting that into a Uniswap
@@ -659,16 +856,16 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     ? estimated * BigInt(5)
                     : UPWARD_BASE_CEILING_CASCADE_SVM;
                 if (value > upwardCeilingCascadeSvm) {
-                    (0, context_1.printLog)(ctx, `composeCascade — SVM outbound to ${(_e = seg.hops[0]) === null || _e === void 0 ? void 0 : _e.targetChain}: capping value from ${value} to upwardCeiling=${upwardCeilingCascadeSvm} (pool quote=${estimated})`);
+                    (0, context_1.printLog)(ctx, `composeCascade — SVM outbound to ${(_b = seg.hops[0]) === null || _b === void 0 ? void 0 : _b.targetChain}: capping value from ${value} to upwardCeiling=${upwardCeilingCascadeSvm} (pool quote=${estimated})`);
                     value = upwardCeilingCascadeSvm;
                 }
-                (0, context_1.printLog)(ctx, `composeCascade — SVM outbound to ${(_f = seg.hops[0]) === null || _f === void 0 ? void 0 : _f.targetChain}: gasFee=${seg.gasFee}, estimatedWpc=${estimated}, flat=${flat}, perSvmCap=${perSvmCap}, upwardCeiling=${upwardCeilingCascadeSvm}, chosen=${value}`);
+                (0, context_1.printLog)(ctx, `composeCascade — SVM outbound to ${(_c = seg.hops[0]) === null || _c === void 0 ? void 0 : _c.targetChain}: gasFee=${seg.gasFee}, estimatedWpc=${estimated}, flat=${flat}, perSvmCap=${perSvmCap}, upwardCeiling=${upwardCeilingCascadeSvm}, chosen=${value}`);
                 // Per-segment minimum-viable-swap check: if the chosen `value` is below
                 // the live pool quote (`estimated`), the cap squeezed the budget below
                 // what the swap actually needs and the segment will revert inside
                 // Uniswap with STF. Throw cleanly with `segmentIndex` so the caller
                 // knows which hop's pool is misbehaving.
-                if (estimated > BigInt(0) && value < estimated && !cascadeAllowUnderfunded) {
+                if (estimated > BigInt(0) && value < estimated) {
                     const shortfall = estimated - value;
                     (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_003_04, estimated, value, shortfall, ueaAddress, 'CASCADE', { kind: 'NATIVE', segmentIndex: cascadeIdx });
                     throw new errors_1.InsufficientUEABalanceError({
@@ -689,6 +886,11 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
             switch (segment.type) {
                 case 'PUSH_EXECUTION': {
                     // Prepend Push Chain multicalls to accumulated
+                    const seedAmount = sumNativeSeedAmount(segment.hops);
+                    if (seedAmount > requiredNativeValue) {
+                        requiredNativeValue = seedAmount;
+                    }
+                    requiredNativeValue += sumMulticallNativeValue(segment.mergedPushMulticalls);
                     accumulatedPushMulticalls = [
                         ...(segment.mergedPushMulticalls || []),
                         ...accumulatedPushMulticalls,
@@ -703,7 +905,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     const isMigration = (firstHop === null || firstHop === void 0 ? void 0 : firstHop.isMigration) === true;
                     if (isSvmSegment) {
                         // SVM: use the pre-built SVM payload from the hop descriptor
-                        outboundPayload = (_g = firstHop.svmPayload) !== null && _g !== void 0 ? _g : '0x';
+                        outboundPayload = (_d = firstHop.svmPayload) !== null && _d !== void 0 ? _d : '0x';
                         // For SVM, to.address IS the target (program for execute, recipient for withdraw)
                         const svmTarget = firstHop.params.to;
                         targetForOutbound = svmTarget.address;
@@ -717,7 +919,10 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         // EVM: build CEA payload from merged multicalls
                         outboundPayload = (0, payload_builders_1.buildCeaMulticallPayload)(segment.mergedCeaMulticalls || []);
                         // Get CEA address from the first hop
-                        targetForOutbound = (firstHop === null || firstHop === void 0 ? void 0 : firstHop.ceaAddress) || ueaAddress;
+                        targetForOutbound = outboundPayload === '0x'
+                            ? selectors_1.ZERO_ADDRESS
+                            : (firstHop === null || firstHop === void 0 ? void 0 : firstHop.ceaAddress) || ueaAddress;
+                        (0, payload_builders_1.assertCeaFundsParkingInvariant)(targetForOutbound, outboundPayload);
                     }
                     // Per-segment PRC-20 burn-balance pre-check (cascade R2-style segments
                     // only — INBOUND_FROM_CEA segments are payload-only with totalBurnAmount=0
@@ -736,12 +941,24 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         });
                         const sufficient = onHand >= segBurnAmount;
                         (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_003_03, segBurnAmount, onHand, sufficient, ueaAddress, 'CASCADE', { kind: 'PRC20', burnToken: segBurnToken, segmentIndex: segIdxLoop });
-                        if (!sufficient && !cascadeAllowUnderfunded) {
-                            const shortfall = segBurnAmount - onHand;
-                            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_003_04, segBurnAmount, onHand, shortfall, ueaAddress, 'CASCADE', { kind: 'PRC20', burnToken: segBurnToken, segmentIndex: segIdxLoop });
+                        const priorPushExecutionMayFundBurn = segments
+                            .slice(0, segIdxLoop)
+                            .some((s) => s.type === 'PUSH_EXECUTION');
+                        const priorInboundFundingForBurn = getInboundFundingForBurnToken(segments, segIdxLoop, segBurnToken, ctx.pushNetwork);
+                        const priorInboundMayFundBurn = onHand + priorInboundFundingForBurn >= segBurnAmount;
+                        if (!sufficient &&
+                            !priorPushExecutionMayFundBurn &&
+                            !priorInboundMayFundBurn) {
+                            const projectedOnHand = onHand + priorInboundFundingForBurn;
+                            const shortfall = segBurnAmount - projectedOnHand;
+                            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_003_04, segBurnAmount, projectedOnHand, shortfall, ueaAddress, 'CASCADE', {
+                                kind: 'PRC20',
+                                burnToken: segBurnToken,
+                                segmentIndex: segIdxLoop,
+                            });
                             throw new errors_1.InsufficientUEABalanceError({
                                 required: segBurnAmount,
-                                available: onHand,
+                                available: projectedOnHand,
                                 shortfall,
                                 ueaAddress,
                                 pathTag: 'CASCADE',
@@ -750,9 +967,15 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                                 segmentIndex: segIdxLoop,
                             });
                         }
+                        else if (!sufficient && priorPushExecutionMayFundBurn) {
+                            (0, context_1.printLog)(ctx, `composeCascade — skipping PRC-20 preflight failure for segment ${segIdxLoop}; earlier Push execution may fund ${segBurnToken} before this outbound runs`);
+                        }
+                        else if (!sufficient && priorInboundMayFundBurn) {
+                            (0, context_1.printLog)(ctx, `composeCascade — skipping PRC-20 preflight failure for segment ${segIdxLoop}; earlier inbound funds ${priorInboundFundingForBurn.toString()} units of ${segBurnToken} before this outbound runs`);
+                        }
                     }
                     // Build outbound request
-                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetForOutbound, segment.prc20Token || selectors_1.ZERO_ADDRESS, segment.totalBurnAmount || BigInt(0), (_h = segment.gasLimit) !== null && _h !== void 0 ? _h : BigInt(0), outboundPayload, ueaAddress);
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetForOutbound, segment.prc20Token || selectors_1.ZERO_ADDRESS, segment.totalBurnAmount || BigInt(0), (_e = segment.gasLimit) !== null && _e !== void 0 ? _e : BigInt(0), outboundPayload, ueaAddress, (_f = segment.maxPCForGas) !== null && _f !== void 0 ? _f : BigInt(0), (_g = segment.gasPrice) !== null && _g !== void 0 ? _g : BigInt(0));
                     // Build approval + outbound multicalls
                     const segGasFee = segment.gasFee || BigInt(0);
                     const svmOverride = svmNativeValueBySegment.get(segment);
@@ -762,13 +985,14 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     // across outbound segments. The contract refunds excess via
                     // swapAndBurnGas, so overshooting is safe; undershooting causes STF.
                     let evmFallbackValue;
-                    if (ueaBalance && ueaBalance > BigInt(0)) {
-                        evmFallbackValue = ueaBalance / BigInt(Math.max(numOutbounds, 1));
+                    if (effectiveUeaBalance > BigInt(0)) {
+                        evmFallbackValue =
+                            effectiveUeaBalance / BigInt(Math.max(numOutbounds, 1));
                     }
                     else {
                         evmFallbackValue = segGasFee * BigInt(1000000);
                     }
-                    let nativeValueForGas = (_j = svmOverride !== null && svmOverride !== void 0 ? svmOverride : perOutboundNativeValue) !== null && _j !== void 0 ? _j : evmFallbackValue;
+                    let nativeValueForGas = (_h = svmOverride !== null && svmOverride !== void 0 ? svmOverride : perOutboundNativeValue) !== null && _h !== void 0 ? _h : evmFallbackValue;
                     // SDK 5.2 Case C: when the segment's sizing is category C, compose
                     // R2/OUTBOUND_TO_CEA segments no longer apply Case A/B/C sizing
                     // (scoped to R1 + R3 only). segment.sizing may still be populated
@@ -784,6 +1008,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         gatewayPcAddress,
                         outboundRequest: outboundReq,
                     });
+                    requiredNativeValue += sumMulticallNativeValue(outboundMulticalls);
                     // Prepend to accumulated
                     accumulatedPushMulticalls = [
                         ...outboundMulticalls,
@@ -794,13 +1019,21 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                 case 'INBOUND_FROM_CEA': {
                     // The accumulated multicalls = what runs on Push Chain AFTER inbound arrives.
                     // Wrap in UniversalPayload struct with correct UEA nonce for the relay.
+                    if (isNativeSeedOnlySegment(segment)) {
+                        const seedAmount = sumNativeSeedAmount(segment.hops);
+                        if (seedAmount > requiredNativeValue) {
+                            requiredNativeValue = seedAmount;
+                        }
+                        (0, context_1.printLog)(ctx, `composeCascade — value-only CEA_TO_PUSH seed ${seedAmount.toString()} folded into root Push execution; no source-chain outbound needed`);
+                        break;
+                    }
                     // Build push multicalls from EVERY merged hop's own data in original
                     // order (e.g. counter.increment() + value transfer). Multi-hop R3
                     // segments (same sourceChain) bundle all target ops into the single
                     // UEA multicall so no nested outbound is needed.
                     const mergedHopMulticalls = [];
                     for (const h of segment.hops) {
-                        if (((_k = h === null || h === void 0 ? void 0 : h.params) === null || _k === void 0 ? void 0 : _k.data) || ((_l = h === null || h === void 0 ? void 0 : h.params) === null || _l === void 0 ? void 0 : _l.value)) {
+                        if (((_j = h === null || h === void 0 ? void 0 : h.params) === null || _j === void 0 ? void 0 : _j.data) || ((_k = h === null || h === void 0 ? void 0 : h.params) === null || _k === void 0 ? void 0 : _k.value)) {
                             const hopCalls = (0, payload_builders_1.buildExecuteMulticall)({
                                 execute: {
                                     to: h.params.to,
@@ -813,6 +1046,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         }
                     }
                     if (mergedHopMulticalls.length > 0) {
+                        requiredNativeValue += sumMulticallNativeValue(mergedHopMulticalls);
                         accumulatedPushMulticalls = [
                             ...mergedHopMulticalls,
                             ...accumulatedPushMulticalls,
@@ -824,7 +1058,9 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     if (accumulatedPushMulticalls.length > 0) {
                         const multicallPayload = (0, payload_builder_1.buildMulticallPayloadData)(ctx, ueaAddress, accumulatedPushMulticalls);
                         // +1: the outbound tx consumes one nonce via execute()
-                        intermediatePayload = (0, payload_builders_1.buildInboundUniversalPayload)(multicallPayload, { nonce: (ueaNonce !== null && ueaNonce !== void 0 ? ueaNonce : BigInt(0)) + BigInt(1) });
+                        intermediatePayload = (0, payload_builders_1.buildInboundUniversalPayload)(multicallPayload, {
+                            nonce: (ueaNonce !== null && ueaNonce !== void 0 ? ueaNonce : BigInt(0)) + BigInt(1),
+                        });
                     }
                     const hop = segment.hops[0];
                     const sourceChain = hop.sourceChain;
@@ -841,7 +1077,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         let drainAmount = BigInt(0);
                         let tokenMintHex;
                         const params = hop.params;
-                        if (((_m = params.funds) === null || _m === void 0 ? void 0 : _m.amount) && params.funds.amount > BigInt(0)) {
+                        if (((_l = params.funds) === null || _l === void 0 ? void 0 : _l.amount) && params.funds.amount > BigInt(0)) {
                             drainAmount = params.funds.amount;
                             const token = params.funds.token;
                             if (token && token.address) {
@@ -870,11 +1106,12 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         });
                         const svmBurnAmount = segment.totalBurnAmount || BigInt(0);
                         const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, segment.prc20Token ||
-                            (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), svmBurnAmount, (_o = segment.gasLimit) !== null && _o !== void 0 ? _o : BigInt(0), svmPayload, ueaAddress);
+                            (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), svmBurnAmount, (_m = segment.gasLimit) !== null && _m !== void 0 ? _m : BigInt(0), svmPayload, ueaAddress, (_o = segment.maxPCForGas) !== null && _o !== void 0 ? _o : BigInt(0), (_p = segment.gasPrice) !== null && _p !== void 0 ? _p : BigInt(0));
                         const inboundGasFee = segment.gasFee || BigInt(0);
                         let svmInboundFallback;
-                        if (ueaBalance && ueaBalance > BigInt(0)) {
-                            svmInboundFallback = ueaBalance / BigInt(Math.max(numOutbounds, 1));
+                        if (effectiveUeaBalance > BigInt(0)) {
+                            svmInboundFallback =
+                                effectiveUeaBalance / BigInt(Math.max(numOutbounds, 1));
                         }
                         else {
                             svmInboundFallback = inboundGasFee * BigInt(1000000);
@@ -883,7 +1120,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         // SDK 5.2 R3-style Case C bump: when the inbound segment's sizing
                         // is C, top up the swap budget by the overflow. No bridge-swap —
                         // R3 has no destination funds delivery.
-                        if (((_p = segment.sizing) === null || _p === void 0 ? void 0 : _p.category) === 'C' &&
+                        if (((_q = segment.sizing) === null || _q === void 0 ? void 0 : _q.category) === 'C' &&
                             segment.sizing.overflowNativePc > BigInt(0)) {
                             const bumped = svmInboundNativeValue + segment.sizing.overflowNativePc;
                             (0, context_1.printLog)(ctx, `composeCascade — INBOUND_FROM_CEA (SVM) Case C: bumping nativeValueForGas from ${svmInboundNativeValue} to ${bumped} (overflow=${segment.sizing.overflowNativePc})`);
@@ -899,10 +1136,12 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                             gatewayPcAddress,
                             outboundRequest: outboundReq,
                         });
+                        requiredNativeValue += sumMulticallNativeValue(outboundMulticalls);
                         accumulatedPushMulticalls = [...outboundMulticalls];
                         break;
                     }
-                    // EVM path: Build CEA multicall: [approve?, sendUniversalTxFromCEA(payload)]
+                    // EVM path: Build CEA multicall: sendUniversalTxToUEA(payload).
+                    // CEA handles ERC20 gateway approval internally.
                     const ceaMulticalls = [];
                     // Add primary hop's own CEA operations if any
                     // (e.g., approve + swap before bridging back)
@@ -918,7 +1157,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     let amount = BigInt(0);
                     for (const mergedHop of segment.hops) {
                         const hParams = mergedHop.params;
-                        if ((_q = hParams.funds) === null || _q === void 0 ? void 0 : _q.amount) {
+                        if ((_r = hParams.funds) === null || _r === void 0 ? void 0 : _r.amount) {
                             const token = hParams.funds.token;
                             if (token) {
                                 if (token.mechanism === 'native') {
@@ -932,32 +1171,6 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                                     }
                                     tokenAddress = addr;
                                     amount += hParams.funds.amount;
-                                    // CEA approves gateway once with the cumulative allowance.
-                                    const gatewayAddr = chain_1.UNIVERSAL_GATEWAY_ADDRESSES[sourceChain];
-                                    if (!gatewayAddr) {
-                                        throw new Error(`No UniversalGateway address configured for chain ${sourceChain}`);
-                                    }
-                                    // Reset allowance to 0 first for USDT-style tokens
-                                    const approveZeroData = (0, viem_1.encodeFunctionData)({
-                                        abi: erc20_evm_1.ERC20_EVM,
-                                        functionName: 'approve',
-                                        args: [gatewayAddr, BigInt(0)],
-                                    });
-                                    ceaMulticalls.push({
-                                        to: tokenAddress,
-                                        value: BigInt(0),
-                                        data: approveZeroData,
-                                    });
-                                    const approveData = (0, viem_1.encodeFunctionData)({
-                                        abi: erc20_evm_1.ERC20_EVM,
-                                        functionName: 'approve',
-                                        args: [gatewayAddr, hParams.funds.amount],
-                                    });
-                                    ceaMulticalls.push({
-                                        to: tokenAddress,
-                                        value: BigInt(0),
-                                        data: approveData,
-                                    });
                                 }
                             }
                         }
@@ -965,7 +1178,8 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                             amount += hParams.value;
                         }
                     }
-                    // Build sendUniversalTxToUEA self-call on CEA (to=CEA, value=0)
+                    // Build sendUniversalTxToUEA self-call on CEA. CEA self-calls must
+                    // always use value=0; native funds are spent from the CEA balance.
                     const sendCall = (0, payload_builders_1.buildSendUniversalTxToUEA)(ceaAddress, tokenAddress, amount, intermediatePayload, ceaAddress);
                     ceaMulticalls.push(sendCall);
                     // Wrap CEA multicall in outbound from Push Chain
@@ -974,17 +1188,17 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     // gasLimit — UGPC.sendUniversalTxOutbound reverts with
                     // "Missing or invalid parameters" on 0. When the hop didn't supply
                     // one (typical for a pure-R3 leg composed inside a cascade), fall
-                    // back to DEFAULT_OUTBOUND_GAS_LIMIT just like the initial outbound
-                    // path does.
+                    // back to the EVM Route 3 default.
                     const effectiveGasLimit = segment.gasLimit && segment.gasLimit > BigInt(0)
                         ? segment.gasLimit
-                        : selectors_1.DEFAULT_OUTBOUND_GAS_LIMIT;
+                        : selectors_1.DEFAULT_CEA_TO_PUSH_GAS_LIMIT;
                     const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, segment.prc20Token ||
-                        (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), segment.totalBurnAmount || BigInt(0), effectiveGasLimit, ceaPayload, ueaAddress);
+                        (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), segment.totalBurnAmount || BigInt(0), effectiveGasLimit, ceaPayload, ueaAddress, (_s = segment.maxPCForGas) !== null && _s !== void 0 ? _s : BigInt(0), (_t = segment.gasPrice) !== null && _t !== void 0 ? _t : BigInt(0));
                     const inboundGasFee = segment.gasFee || BigInt(0);
                     let evmInboundFallback;
-                    if (ueaBalance && ueaBalance > BigInt(0)) {
-                        evmInboundFallback = ueaBalance / BigInt(Math.max(numOutbounds, 1));
+                    if (effectiveUeaBalance > BigInt(0)) {
+                        evmInboundFallback =
+                            effectiveUeaBalance / BigInt(Math.max(numOutbounds, 1));
                     }
                     else {
                         evmInboundFallback = inboundGasFee * BigInt(1000000);
@@ -993,7 +1207,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     // SDK 5.2 R3-style Case C bump: when the inbound segment's sizing
                     // is C, top up the swap budget by the overflow. No bridge-swap —
                     // R3 has no destination funds delivery.
-                    if (((_r = segment.sizing) === null || _r === void 0 ? void 0 : _r.category) === 'C' &&
+                    if (((_u = segment.sizing) === null || _u === void 0 ? void 0 : _u.category) === 'C' &&
                         segment.sizing.overflowNativePc > BigInt(0)) {
                         const bumped = evmInboundNativeValue + segment.sizing.overflowNativePc;
                         (0, context_1.printLog)(ctx, `composeCascade — INBOUND_FROM_CEA (EVM) Case C: bumping nativeValueForGas from ${evmInboundNativeValue} to ${bumped} (overflow=${segment.sizing.overflowNativePc})`);
@@ -1009,19 +1223,29 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         gatewayPcAddress,
                         outboundRequest: outboundReq,
                     });
+                    requiredNativeValue += sumMulticallNativeValue(outboundMulticalls);
                     // Reset accumulated -- everything is now inside this outbound
                     accumulatedPushMulticalls = [...outboundMulticalls];
                     break;
                 }
             }
         }
-        return accumulatedPushMulticalls;
+        return {
+            multicalls: accumulatedPushMulticalls,
+            requiredNativeValue,
+        };
+    });
+}
+function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const result = yield composeCascadeDetailed(ctx, segments, ueaAddress, ueaBalance, ueaNonce);
+        return result.multicalls;
     });
 }
 // ============================================================================
 // createCascadedBuilder
 // ============================================================================
-function createCascadedBuilder(ctx, preparedTxs, callbacks) {
+function createCascadedBuilder(ctx, preparedTxs, callbacks, defaultEventHook) {
     return {
         send: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -1031,8 +1255,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
             // Classify into segments
             const segments = classifyIntoSegments(hops);
             // Check if this is a single-hop Route 1 (no composition needed)
-            if (preparedTxs.length === 1 &&
-                preparedTxs[0].route === 'UOA_TO_PUSH') {
+            if (preparedTxs.length === 1 && preparedTxs[0].route === 'UOA_TO_PUSH') {
                 const response = yield callbacks.executeFn(hops[0].params);
                 const singleRoute1Result = {
                     initialTxHash: response.hash,
@@ -1066,8 +1289,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                 return singleRoute1Result;
             }
             // Check if single-hop Route 2 (just execute directly)
-            if (preparedTxs.length === 1 &&
-                preparedTxs[0].route === 'UOA_TO_CEA') {
+            if (preparedTxs.length === 1 && preparedTxs[0].route === 'UOA_TO_CEA') {
                 const response = yield callbacks.executeFn(hops[0].params);
                 const targetChain = hops[0].targetChain || (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork);
                 const singleRoute2Result = {
@@ -1111,8 +1333,11 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                 ? yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress)
                 : BigInt(0);
             let composedMulticalls;
+            let cascadeRequiredNativeValue = BigInt(0);
             try {
-                composedMulticalls = yield composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonceCascade);
+                const composed = yield composeCascadeDetailed(ctx, segments, ueaAddress, ueaBalance, ueaNonceCascade);
+                composedMulticalls = composed.multicalls;
+                cascadeRequiredNativeValue = composed.requiredNativeValue;
             }
             catch (err) {
                 // Pre-flight or per-segment min-swap failure inside composeCascade
@@ -1129,6 +1354,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
             // Execute the composed multicall as a single Push Chain tx
             const executeParams = {
                 to: ueaAddress,
+                value: cascadeRequiredNativeValue,
                 data: composedMulticalls,
             };
             const response = yield callbacks.executeFn(executeParams);
@@ -1136,7 +1362,9 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
             const hopInfos = hops.map((hop, index) => ({
                 hopIndex: index,
                 route: hop.route,
-                executionChain: hop.targetChain || hop.sourceChain || (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork),
+                executionChain: hop.targetChain ||
+                    hop.sourceChain ||
+                    (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork),
                 status: 'pending',
             }));
             // Mark first hop as submitted
@@ -1150,8 +1378,8 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                 hops: hopInfos,
                 hopCount: hops.length,
                 waitForAll: (opts) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    var _a, _b, _c, _d, _e;
-                    const { pollingIntervalMs = 10000, timeout = 300000, progressHook: cascadeProgressHook, eventHook, } = opts || {};
+                    var _a, _b, _c, _d, _e, _f, _g, _h;
+                    const { pollingIntervalMs = 10000, timeout = 300000, progressHook: cascadeProgressHook, eventHook = defaultEventHook, } = opts || {};
                     const startTime = Date.now();
                     // Per-hop progress emission. Fans out cascade markers to BOTH the
                     // explicit `eventHook` (passed into waitForAll) AND the init-time
@@ -1180,9 +1408,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                         if (!isMulti)
                             return;
                         const n = hopIndex0 + 1;
-                        const fromChain = hopIndex0 === 0
-                            ? signerOriginChain
-                            : chainLabels[hopIndex0 - 1];
+                        const fromChain = hopIndex0 === 0 ? signerOriginChain : chainLabels[hopIndex0 - 1];
                         const toChain = chainLabels[hopIndex0];
                         emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_002_01](n, totalHops, fromChain, toChain));
                     };
@@ -1229,49 +1455,14 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                             elapsed: Date.now() - startTime,
                         });
                         yield response.wait();
-                        // Mark all Push Chain (Route 1) hops as confirmed
-                        for (const hop of hopInfos) {
-                            if (hop.route === 'UOA_TO_PUSH') {
-                                hop.status = 'confirmed';
-                                hop.txHash = response.hash;
-                                cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
-                                    hopIndex: hop.hopIndex,
-                                    route: hop.route,
-                                    chain: (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork),
-                                    status: 'confirmed',
-                                    txHash: response.hash,
-                                    elapsed: Date.now() - startTime,
-                                });
-                                emitHopComplete(hop.hopIndex);
-                            }
-                        }
-                        // 2. Track outbound hops (Route 2: UOA_TO_CEA)
-                        // Hops after a CEA_TO_PUSH are "child outbounds" — they execute inside
-                        // the inbound payload on Push Chain and live under a DIFFERENT utx_id
-                        // (the inbound UTX, not the parent). We can't track them via the parent
-                        // utx_id polling, so we auto-confirm them.
-                        const ceaToPushIndex = hopInfos.findIndex((h) => h.route === 'CEA_TO_PUSH');
-                        const outboundHops = hopInfos.filter((h, i) => {
-                            if (h.route !== 'UOA_TO_CEA')
-                                return false;
-                            // Child outbounds (after CEA_TO_PUSH) live under the inbound UTX,
-                            // not the parent — auto-confirm since we can't poll them here.
-                            if (ceaToPushIndex >= 0 && i > ceaToPushIndex) {
-                                h.status = 'confirmed';
-                                cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
-                                    hopIndex: h.hopIndex,
-                                    route: h.route,
-                                    chain: h.executionChain,
-                                    status: 'confirmed',
-                                    elapsed: Date.now() - startTime,
-                                });
-                                return false;
-                            }
-                            return true;
-                        });
-                        if (outboundHops.length > 0) {
+                        const ceaToPushIndex = hopInfos.findIndex((h, index) => h.route === 'CEA_TO_PUSH' && !isNativeSeedOnlyHop(hops[index]));
+                        const isAfterCeaToPush = (index) => ceaToPushIndex >= 0 && index > ceaToPushIndex;
+                        const rootOutboundIndexByHop = buildRootOutboundIndexByHop(segments, hops);
+                        const trackOutboundHops = (outboundHops, pushTxHash, resolvedSubTxId, outboundIndexByHop) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                            var _a, _b, _c, _d;
+                            if (outboundHops.length === 0)
+                                return null;
                             if (outboundHops.length === 1) {
-                                // Single direct outbound hop: use the existing V1-based tracking
                                 const hop = outboundHops[0];
                                 const hopHooks = (0, progress_route_hooks_1.pickWaitHooks)(hop.route);
                                 const remainingTimeout = timeout - (Date.now() - startTime);
@@ -1303,11 +1494,11 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                                 });
                                 let lastEmittedStatus;
                                 try {
-                                    const outboundDetails = yield callbacks.waitForOutboundTxFn(response.hash, {
-                                        initialWaitMs: Math.min(60000, remainingTimeout),
-                                        pollingIntervalMs,
-                                        timeout: remainingTimeout,
-                                        progressHook: (event) => {
+                                    const outboundDetails = yield callbacks.waitForOutboundTxFn(pushTxHash, Object.assign(Object.assign({ initialWaitMs: Math.min(60000, remainingTimeout), pollingIntervalMs, timeout: remainingTimeout, _resolvedSubTxId: resolvedSubTxId, _expectedDestinationChain: hop.executionChain }, (outboundIndexByHop
+                                        ? {
+                                            _outboundIndex: (_a = outboundIndexByHop.get(hop.hopIndex)) !== null && _a !== void 0 ? _a : 0,
+                                        }
+                                        : {})), { progressHook: (event) => {
                                             cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
                                                 hopIndex: hop.hopIndex,
                                                 route: hop.route,
@@ -1320,19 +1511,25 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                                                 lastEmittedStatus = 'polling';
                                                 emitHopEvent(hopHooks.polling(hop.executionChain, event.elapsed));
                                             }
-                                        },
-                                    });
+                                        } }));
+                                    // `outboundDetails.externalTxHash` from waitForOutboundTx
+                                    // is the raw `0x`-hex form (internal canonical). For the
+                                    // user-facing `hop.txHash`, `hop.outboundDetails`, and
+                                    // cascade progress event, normalize to base58 for SVM so
+                                    // consumers can paste it straight into a Solana explorer.
+                                    const displayTxHash = (_b = (0, helpers_1.toExternalTxHashDisplay)(outboundDetails.destinationChain, outboundDetails.externalTxHash)) !== null && _b !== void 0 ? _b : outboundDetails.externalTxHash;
+                                    const userFacingOutboundDetails = Object.assign(Object.assign({}, outboundDetails), { externalTxHash: displayTxHash });
                                     hop.status = 'confirmed';
-                                    hop.txHash = outboundDetails.externalTxHash;
-                                    hop.outboundDetails = outboundDetails;
-                                    emitHopEvent(hopHooks.success(outboundDetails));
+                                    hop.txHash = displayTxHash;
+                                    hop.outboundDetails = userFacingOutboundDetails;
+                                    emitHopEvent(hopHooks.success(userFacingOutboundDetails));
                                     emitHopComplete(hop.hopIndex);
                                     cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
                                         hopIndex: hop.hopIndex,
                                         route: hop.route,
                                         chain: hop.executionChain,
                                         status: 'confirmed',
-                                        txHash: outboundDetails.externalTxHash,
+                                        txHash: displayTxHash,
                                         elapsed: Date.now() - startTime,
                                     });
                                 }
@@ -1364,19 +1561,17 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                                 }
                             }
                             else {
-                                // Multiple outbound hops: use V2 API which returns outboundTx[]
-                                // Emit "Awaiting External Chain" once per outbound hop before
-                                // polling begins, using the route-specific awaiting hook.
                                 for (const outHop of outboundHops) {
                                     emitHopStart(outHop.hopIndex);
                                     emitHopEvent((0, progress_route_hooks_1.pickWaitHooks)(outHop.route).awaiting(outHop.executionChain));
                                 }
                                 const perHopLastStatus = new Map();
                                 const confirmedHops = new Set();
-                                const allOutboundDetails = yield callbacks.waitForAllOutboundTxsFn(response.hash, outboundHops, {
+                                const allOutboundDetails = yield callbacks.waitForAllOutboundTxsFn(pushTxHash, outboundHops, {
                                     initialWaitMs: Math.min(60000, timeout - (Date.now() - startTime)),
                                     pollingIntervalMs,
                                     timeout: timeout - (Date.now() - startTime),
+                                    _resolvedSubTxId: resolvedSubTxId,
                                     progressHook: (event) => {
                                         var _a, _b;
                                         cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
@@ -1390,8 +1585,7 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                                         const matchedHop = outboundHops.find((h) => h.hopIndex === event.hopIndex);
                                         const eventHooks = (0, progress_route_hooks_1.pickWaitHooks)(matchedHop === null || matchedHop === void 0 ? void 0 : matchedHop.route);
                                         const prev = perHopLastStatus.get(event.hopIndex);
-                                        if (event.status === 'polling' &&
-                                            prev !== 'polling') {
+                                        if (event.status === 'polling' && prev !== 'polling') {
                                             perHopLastStatus.set(event.hopIndex, 'polling');
                                             emitHopEvent(eventHooks.polling((_b = (_a = matchedHop === null || matchedHop === void 0 ? void 0 : matchedHop.executionChain) !== null && _a !== void 0 ? _a : event.chain) !== null && _b !== void 0 ? _b : '', Date.now() - startTime));
                                         }
@@ -1412,12 +1606,12 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                                     },
                                 });
                                 if (!allOutboundDetails.success) {
-                                    const failedIdx = (_d = allOutboundDetails.failedAt) !== null && _d !== void 0 ? _d : 0;
+                                    const failedIdx = (_c = allOutboundDetails.failedAt) !== null && _c !== void 0 ? _c : 0;
                                     const failedHop = outboundHops.find((h) => h.hopIndex === failedIdx);
                                     const failMsg = failedHop
                                         ? `Outbound failed for hop ${failedIdx} on ${failedHop.executionChain}`
                                         : `Outbound cascade failed at hop ${failedIdx}`;
-                                    emitHopEvent((0, progress_route_hooks_1.pickWaitHooks)(failedHop === null || failedHop === void 0 ? void 0 : failedHop.route).failed((_e = failedHop === null || failedHop === void 0 ? void 0 : failedHop.executionChain) !== null && _e !== void 0 ? _e : '', failMsg));
+                                    emitHopEvent((0, progress_route_hooks_1.pickWaitHooks)(failedHop === null || failedHop === void 0 ? void 0 : failedHop.route).failed((_d = failedHop === null || failedHop === void 0 ? void 0 : failedHop.executionChain) !== null && _d !== void 0 ? _d : '', failMsg));
                                     emitCascadeFailed(failedIdx, failMsg);
                                     return {
                                         success: false,
@@ -1426,23 +1620,230 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                                     };
                                 }
                             }
+                            return null;
+                        });
+                        // Mark only root Push Chain (Route 1) hops as confirmed. Route 1
+                        // hops after a Route 3 leg execute in the child inbound Push tx and
+                        // must wait for that child UTX to reach terminal success.
+                        for (const hop of hopInfos) {
+                            if (hop.route === 'CEA_TO_PUSH' &&
+                                isNativeSeedOnlyHop(hops[hop.hopIndex])) {
+                                emitHopStart(hop.hopIndex);
+                                hop.status = 'confirmed';
+                                hop.txHash = response.hash;
+                                cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                    hopIndex: hop.hopIndex,
+                                    route: hop.route,
+                                    chain: (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork),
+                                    status: 'confirmed',
+                                    txHash: response.hash,
+                                    elapsed: Date.now() - startTime,
+                                });
+                                emitHopComplete(hop.hopIndex);
+                            }
                         }
-                        // 3. Route 3 (CEA_TO_PUSH) tracking - mark as submitted
-                        // Cascade does not poll inbound completion; we surface the hop-start
-                        // marker so consumers see a "Starting tx N" event for the inbound,
-                        // but skip emitHopComplete since we never observe terminal state.
-                        const inboundHops = hopInfos.filter((h) => h.route === 'CEA_TO_PUSH');
-                        for (const inboundHop of inboundHops) {
-                            inboundHop.status = 'submitted';
+                        for (const hop of hopInfos) {
+                            if (hop.route === 'UOA_TO_PUSH' && !isAfterCeaToPush(hop.hopIndex)) {
+                                hop.status = 'confirmed';
+                                hop.txHash = response.hash;
+                                cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                    hopIndex: hop.hopIndex,
+                                    route: hop.route,
+                                    chain: (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork),
+                                    status: 'confirmed',
+                                    txHash: response.hash,
+                                    elapsed: Date.now() - startTime,
+                                });
+                                emitHopComplete(hop.hopIndex);
+                            }
+                        }
+                        // 2. Track direct outbound hops (Route 2: UOA_TO_CEA) that belong
+                        // to the root Push UTX.
+                        const rootOutboundHops = hopInfos.filter((h) => h.route === 'UOA_TO_CEA' && !isAfterCeaToPush(h.hopIndex));
+                        const rootOutboundFailure = yield trackOutboundHops(rootOutboundHops, response.hash, undefined, rootOutboundIndexByHop);
+                        if (rootOutboundFailure)
+                            return rootOutboundFailure;
+                        let childInbound;
+                        if (ceaToPushIndex >= 0) {
+                            const inboundHop = hopInfos[ceaToPushIndex];
+                            const hopHooks = (0, progress_route_hooks_1.pickWaitHooks)(inboundHop.route);
+                            const remainingTimeout = timeout - (Date.now() - startTime);
+                            if (remainingTimeout <= 0) {
+                                inboundHop.status = 'failed';
+                                emitHopEvent(hopHooks.timeout(inboundHop.executionChain, Date.now() - startTime));
+                                emitCascadeTimeout(inboundHop.hopIndex);
+                                return {
+                                    success: false,
+                                    hops: hopInfos,
+                                    failedAt: inboundHop.hopIndex,
+                                };
+                            }
                             emitHopStart(inboundHop.hopIndex);
+                            emitHopEvent(hopHooks.awaiting(inboundHop.executionChain));
+                            cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                hopIndex: inboundHop.hopIndex,
+                                route: inboundHop.route,
+                                chain: inboundHop.executionChain,
+                                status: 'polling',
+                                elapsed: Date.now() - startTime,
+                            });
+                            let outboundLastStatus;
+                            let sourceOutboundDetails;
+                            try {
+                                sourceOutboundDetails = yield callbacks.waitForOutboundTxFn(response.hash, {
+                                    initialWaitMs: Math.min(60000, remainingTimeout),
+                                    pollingIntervalMs,
+                                    timeout: remainingTimeout,
+                                    _expectedDestinationChain: inboundHop.executionChain,
+                                    _outboundIndex: (_d = rootOutboundIndexByHop.get(inboundHop.hopIndex)) !== null && _d !== void 0 ? _d : 0,
+                                    progressHook: (event) => {
+                                        cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                            hopIndex: inboundHop.hopIndex,
+                                            route: inboundHop.route,
+                                            chain: inboundHop.executionChain,
+                                            status: event.status,
+                                            elapsed: Date.now() - startTime,
+                                        });
+                                        if (event.status === 'polling' &&
+                                            outboundLastStatus !== 'polling') {
+                                            outboundLastStatus = 'polling';
+                                            emitHopEvent(hopHooks.polling(inboundHop.executionChain, event.elapsed));
+                                        }
+                                    },
+                                });
+                            }
+                            catch (err) {
+                                const errMsg = err instanceof Error ? err.message : String(err);
+                                const isTimeout = errMsg.startsWith('Timeout waiting for outbound transaction');
+                                emitHopEvent(isTimeout
+                                    ? hopHooks.timeout(inboundHop.executionChain, remainingTimeout)
+                                    : hopHooks.failed(inboundHop.executionChain, errMsg));
+                                if (isTimeout)
+                                    emitCascadeTimeout(inboundHop.hopIndex);
+                                else
+                                    emitCascadeFailed(inboundHop.hopIndex, errMsg);
+                                inboundHop.status = 'failed';
+                                const failedExternalTxHash = err === null || err === void 0 ? void 0 : err.externalTxHash;
+                                const failedDisplayTxHash = (_e = (0, helpers_1.toExternalTxHashDisplay)(inboundHop.executionChain, failedExternalTxHash)) !== null && _e !== void 0 ? _e : failedExternalTxHash;
+                                if (failedDisplayTxHash)
+                                    inboundHop.txHash = failedDisplayTxHash;
+                                cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                    hopIndex: inboundHop.hopIndex,
+                                    route: inboundHop.route,
+                                    chain: inboundHop.executionChain,
+                                    status: 'failed',
+                                    txHash: failedDisplayTxHash,
+                                    elapsed: Date.now() - startTime,
+                                });
+                                return {
+                                    success: false,
+                                    hops: hopInfos,
+                                    failedAt: inboundHop.hopIndex,
+                                };
+                            }
+                            const displayExternalTxHash = (_f = (0, helpers_1.toExternalTxHashDisplay)(sourceOutboundDetails.destinationChain, sourceOutboundDetails.externalTxHash)) !== null && _f !== void 0 ? _f : sourceOutboundDetails.externalTxHash;
+                            inboundHop.outboundDetails = Object.assign(Object.assign({}, sourceOutboundDetails), { externalTxHash: displayExternalTxHash });
+                            inboundHop.txHash = displayExternalTxHash;
+                            emitHopEvent(hopHooks.success(inboundHop.outboundDetails));
+                            emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_01](inboundHop.executionChain));
+                            let inboundLastStatus;
+                            const inboundRemainingTimeout = timeout - (Date.now() - startTime);
+                            try {
+                                childInbound = yield ((_g = callbacks.waitForInboundPushTxFn) !== null && _g !== void 0 ? _g : ((externalTxHash, sourceChain, opts) => (0, inbound_tracker_1.waitForInboundPushTx)(ctx, externalTxHash, sourceChain, opts)))(sourceOutboundDetails.externalTxHash, inboundHop.executionChain, {
+                                    initialWaitMs: Math.min(60000, inboundRemainingTimeout),
+                                    pollingIntervalMs,
+                                    timeout: inboundRemainingTimeout,
+                                    progressHook: (event) => {
+                                        if (event.status === 'polling' &&
+                                            inboundLastStatus !== 'polling') {
+                                            inboundLastStatus = 'polling';
+                                            emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_02](inboundHop.executionChain, event.elapsedMs));
+                                        }
+                                    },
+                                });
+                            }
+                            catch (err) {
+                                const errMsg = err instanceof Error ? err.message : String(err);
+                                const isTimeout = err instanceof inbound_tracker_1.InboundTimeoutError;
+                                emitHopEvent(isTimeout
+                                    ? progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_03](inboundHop.executionChain, inboundRemainingTimeout, 'inbound')
+                                    : progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](errMsg, 'inbound', inboundHop.executionChain));
+                                if (isTimeout)
+                                    emitCascadeTimeout(inboundHop.hopIndex);
+                                else
+                                    emitCascadeFailed(inboundHop.hopIndex, errMsg);
+                                inboundHop.status = 'failed';
+                                cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                    hopIndex: inboundHop.hopIndex,
+                                    route: inboundHop.route,
+                                    chain: inboundHop.executionChain,
+                                    status: 'failed',
+                                    elapsed: Date.now() - startTime,
+                                });
+                                return {
+                                    success: false,
+                                    hops: hopInfos,
+                                    failedAt: inboundHop.hopIndex,
+                                };
+                            }
+                            if (childInbound.status !== 'confirmed') {
+                                const failMsg = (_h = childInbound.errorMessage) !== null && _h !== void 0 ? _h : 'inbound execution failed on Push Chain';
+                                inboundHop.status = 'failed';
+                                inboundHop.txHash =
+                                    childInbound.pushTxHash || displayExternalTxHash;
+                                emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02](failMsg, 'inbound', inboundHop.executionChain));
+                                emitCascadeFailed(inboundHop.hopIndex, failMsg);
+                                cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                    hopIndex: inboundHop.hopIndex,
+                                    route: inboundHop.route,
+                                    chain: inboundHop.executionChain,
+                                    status: 'failed',
+                                    txHash: inboundHop.txHash,
+                                    elapsed: Date.now() - startTime,
+                                });
+                                return {
+                                    success: false,
+                                    hops: hopInfos,
+                                    failedAt: inboundHop.hopIndex,
+                                };
+                            }
+                            inboundHop.status = 'confirmed';
+                            inboundHop.txHash =
+                                childInbound.pushTxHash || displayExternalTxHash;
+                            emitHopEvent(progress_hook_1.default[progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_01](inboundHop.executionChain, childInbound.pushTxHash));
+                            emitHopComplete(inboundHop.hopIndex);
                             cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
                                 hopIndex: inboundHop.hopIndex,
                                 route: inboundHop.route,
                                 chain: inboundHop.executionChain,
-                                status: 'waiting',
+                                status: 'confirmed',
+                                txHash: inboundHop.txHash,
                                 elapsed: Date.now() - startTime,
                             });
                         }
+                        if (childInbound) {
+                            for (const hop of hopInfos) {
+                                if (hop.route === 'UOA_TO_PUSH' &&
+                                    isAfterCeaToPush(hop.hopIndex)) {
+                                    emitHopStart(hop.hopIndex);
+                                    hop.status = 'confirmed';
+                                    hop.txHash = childInbound.pushTxHash;
+                                    cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                        hopIndex: hop.hopIndex,
+                                        route: hop.route,
+                                        chain: (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork),
+                                        status: 'confirmed',
+                                        txHash: childInbound.pushTxHash,
+                                        elapsed: Date.now() - startTime,
+                                    });
+                                    emitHopComplete(hop.hopIndex);
+                                }
+                            }
+                            const childOutboundHops = hopInfos.filter((h) => h.route === 'UOA_TO_CEA' && isAfterCeaToPush(h.hopIndex));
+                            const childOutboundFailure = yield trackOutboundHops(childOutboundHops, childInbound.pushTxHash || response.hash, childInbound.childUtxId);
+                            if (childOutboundFailure)
+                                return childOutboundFailure;
+                        }
                         emitCascadeSuccess();
                         return { success: true, hops: hopInfos };
                     }