@pushchain/core 5.1.16 → 5.1.18

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,9 +122,16 @@ 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,
@@ -134,6 +143,10 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
         switch (route) {
             case route_detector_1.TransactionRoute.UOA_TO_PUSH: {
                 // Route 1: Build Push Chain multicalls
+                const seedAmount = (_c = params.value) !== null && _c !== void 0 ? _c : 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 +168,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 ((_d = params.funds) === null || _d === void 0 ? void 0 : _d.amount) {
                         const token = params.funds.token;
                         if (token) {
                             prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token).address;
@@ -181,9 +194,9 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                     // 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
+                        ? (_f = (_e = params.funds) === null || _e === void 0 ? void 0 : _e.token) === null || _f === void 0 ? void 0 : _f.address
                         : undefined;
-                    const effectiveGasLimit = yield (0, svm_rent_1.maybeBumpForCeaAtaRent)({
+                    let effectiveGasLimit = yield (0, svm_rent_1.maybeBumpForCeaAtaRent)({
                         ctx,
                         ueaAddress,
                         targetChain,
@@ -196,16 +209,19 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                         gasToken = result.gasToken;
                         gasFee = result.gasFee;
                         sizing = result.sizing;
+                        if (!params.gasLimit && result.gasPrice > BigInt(0)) {
+                            effectiveGasLimit = result.gasFee / result.gasPrice;
+                            (0, context_1.printLog)(ctx, `buildHopDescriptor — SVM derived effectiveGasLimit: ${effectiveGasLimit} (gasFee=${result.gasFee} / gasPrice=${result.gasPrice})`);
+                        }
                     }
                     return Object.assign(Object.assign({}, baseDescriptor), { targetChain, isSvmTarget: true, svmPayload,
                         prc20Token,
                         burnAmount,
                         gasToken,
-                        gasFee,
-                        sizing });
+                        gasFee, 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);
@@ -235,7 +251,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 +271,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 +287,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 +319,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;
@@ -345,6 +361,10 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
             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 +381,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) {
@@ -388,18 +408,21 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                         gasFee = result.gasFee;
                         sizing = result.sizing;
                     }
-                    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 });
                 }
-                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') {
@@ -429,7 +452,11 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                 }
                 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,
                     sizing });
             }
@@ -463,7 +490,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
@@ -559,46 +588,128 @@ 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 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;
         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,7 +725,7 @@ 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,
@@ -629,11 +740,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 +754,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 +775,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 +805,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 +824,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;
@@ -736,12 +857,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 +883,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);
                     // Build approval + outbound multicalls
                     const segGasFee = segment.gasFee || BigInt(0);
                     const svmOverride = svmNativeValueBySegment.get(segment);
@@ -762,13 +901,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 = (_f = svmOverride !== null && svmOverride !== void 0 ? svmOverride : perOutboundNativeValue) !== null && _f !== void 0 ? _f : 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 +924,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         gatewayPcAddress,
                         outboundRequest: outboundReq,
                     });
+                    requiredNativeValue += sumMulticallNativeValue(outboundMulticalls);
                     // Prepend to accumulated
                     accumulatedPushMulticalls = [
                         ...outboundMulticalls,
@@ -794,13 +935,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 (((_g = h === null || h === void 0 ? void 0 : h.params) === null || _g === void 0 ? void 0 : _g.data) || ((_h = h === null || h === void 0 ? void 0 : h.params) === null || _h === void 0 ? void 0 : _h.value)) {
                             const hopCalls = (0, payload_builders_1.buildExecuteMulticall)({
                                 execute: {
                                     to: h.params.to,
@@ -813,6 +962,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                         }
                     }
                     if (mergedHopMulticalls.length > 0) {
+                        requiredNativeValue += sumMulticallNativeValue(mergedHopMulticalls);
                         accumulatedPushMulticalls = [
                             ...mergedHopMulticalls,
                             ...accumulatedPushMulticalls,
@@ -824,7 +974,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 +993,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 (((_j = params.funds) === null || _j === void 0 ? void 0 : _j.amount) && params.funds.amount > BigInt(0)) {
                             drainAmount = params.funds.amount;
                             const token = params.funds.token;
                             if (token && token.address) {
@@ -870,11 +1022,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, (_k = segment.gasLimit) !== null && _k !== void 0 ? _k : BigInt(0), svmPayload, ueaAddress);
                         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 +1036,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 (((_l = segment.sizing) === null || _l === void 0 ? void 0 : _l.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,6 +1052,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                             gatewayPcAddress,
                             outboundRequest: outboundReq,
                         });
+                        requiredNativeValue += sumMulticallNativeValue(outboundMulticalls);
                         accumulatedPushMulticalls = [...outboundMulticalls];
                         break;
                     }
@@ -918,7 +1072,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 ((_m = hParams.funds) === null || _m === void 0 ? void 0 : _m.amount) {
                             const token = hParams.funds.token;
                             if (token) {
                                 if (token.mechanism === 'native') {
@@ -965,7 +1119,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 +1129,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);
                     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 +1148,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 (((_o = segment.sizing) === null || _o === void 0 ? void 0 : _o.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 +1164,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 +1196,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 +1230,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 +1274,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 +1295,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 +1303,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 +1319,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;
+                    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 +1349,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 +1396,13 @@ 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 trackOutboundHops = (outboundHops, pushTxHash, resolvedSubTxId) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                            var _a, _b, _c;
+                            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,10 +1434,12 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                                 });
                                 let lastEmittedStatus;
                                 try {
-                                    const outboundDetails = yield callbacks.waitForOutboundTxFn(response.hash, {
+                                    const outboundDetails = yield callbacks.waitForOutboundTxFn(pushTxHash, {
                                         initialWaitMs: Math.min(60000, remainingTimeout),
                                         pollingIntervalMs,
                                         timeout: remainingTimeout,
+                                        _resolvedSubTxId: resolvedSubTxId,
+                                        _expectedDestinationChain: hop.executionChain,
                                         progressHook: (event) => {
                                             cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
                                                 hopIndex: hop.hopIndex,
@@ -1322,17 +1455,24 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                                             }
                                         },
                                     });
+                                    // `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 = (_a = (0, helpers_1.toExternalTxHashDisplay)(outboundDetails.destinationChain, outboundDetails.externalTxHash)) !== null && _a !== void 0 ? _a : 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 +1504,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 +1528,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 +1549,12 @@ function createCascadedBuilder(ctx, preparedTxs, callbacks) {
                                     },
                                 });
                                 if (!allOutboundDetails.success) {
-                                    const failedIdx = (_d = allOutboundDetails.failedAt) !== null && _d !== void 0 ? _d : 0;
+                                    const failedIdx = (_b = allOutboundDetails.failedAt) !== null && _b !== void 0 ? _b : 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((_c = failedHop === null || failedHop === void 0 ? void 0 : failedHop.executionChain) !== null && _c !== void 0 ? _c : '', failMsg));
                                     emitCascadeFailed(failedIdx, failMsg);
                                     return {
                                         success: false,
@@ -1426,22 +1563,228 @@ 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);
+                            }
+                        }
+                        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);
+                            }
                         }
-                        // 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';
+                        // 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);
+                        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: 'waiting',
+                                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,
+                                    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 = (_d = (0, helpers_1.toExternalTxHashDisplay)(inboundHop.executionChain, failedExternalTxHash)) !== null && _d !== void 0 ? _d : 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 = (_e = (0, helpers_1.toExternalTxHashDisplay)(sourceOutboundDetails.destinationChain, sourceOutboundDetails.externalTxHash)) !== null && _e !== void 0 ? _e : 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 ((_f = callbacks.waitForInboundPushTxFn) !== null && _f !== void 0 ? _f : ((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 = (_g = childInbound.errorMessage) !== null && _g !== void 0 ? _g : '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: '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 };