@pushchain/core 6.0.15 → 6.0.17

package/src/lib/orchestrator/internals/execute-funds-only.js

@@ -20,6 +20,9 @@ const svm_client_1 = require("../../vm-client/svm-client");
 const context_2 = require("./context");
 const gas_calculator_1 = require("./gas-calculator");
 const gateway_client_1 = require("./gateway-client");
+const gas_usd_sizer_1 = require("./gas-usd-sizer");
+const price_fetch_1 = require("../../price-fetch/price-fetch");
+const utils_1 = require("../../utils");
 const helpers_1 = require("./helpers");
 const payload_builder_1 = require("./payload-builder");
 const uea_manager_1 = require("./uea-manager");
@@ -100,7 +103,11 @@ function executeFundsOnlyEvm(ctx, execute, eventBuffer, transformFn, chain, rpcU
         const gasPrice = yield ctx.pushClient.getGasPrice();
         const requiredGasFee = gasEstimate * gasPrice;
         const requiredFunds = requiredGasFee + ((_c = execute.value) !== null && _c !== void 0 ? _c : BigInt(0));
-        let nativeAmount = yield (0, gas_calculator_1.calculateNativeAmountForDeposit)(ctx, chain, requiredFunds, ueaBalanceForGas);
+        let nativeAmount = yield (0, gas_calculator_1.calculateNativeAmountForDeposit)(ctx, chain, requiredFunds, ueaBalanceForGas, 
+        // Defer the 103-03-04 ("Prepaid Deposit Estimated") hook — we emit the full
+        // 103-03 sizing sequence below, after 103-01/103-02 (UEA resolution), to
+        // match the funds-payload path ordering.
+        { emitDepositEstimated: false });
         // For EVM fee-locking, fixed-rate PC→USD sizing can underfund when the
         // live WPC/native pool prices PC above the SDK's fallback price. Size the
         // native deposit against the same Push Chain pool used by the gateway.
@@ -121,6 +128,41 @@ function executeFundsOnlyEvm(ctx, execute, eventBuffer, transformFn, chain, rpcU
         (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_01);
         (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_02, ueaAddress, deployed);
         (0, context_2.printLog)(ctx, `UEA resolved: ${ueaAddress}, deployed: ${deployed}`);
+        // SDK 5.2 R1 deposit-sizing progress (parent + Case A/B/C + terminal),
+        // emitted here — after UEA resolution — to match the funds-payload path's
+        // ordering. The terminal 103-03-04 hook was suppressed inside
+        // calculateNativeAmountForDeposit above so it lands in this position instead
+        // of before 103-01/103-02. Purely cosmetic: a pool/price read failure here
+        // must never block the bridge, so we fall back to the terminal hook alone.
+        try {
+            const r1Sizing = yield (0, gas_usd_sizer_1.sizeR1PushGas)(ctx, {
+                pushGasFeeWei: requiredGasFee,
+                originChain: chain,
+            });
+            const nativeTokenUsdPrice = yield new price_fetch_1.PriceFetch(ctx.rpcUrls).getPrice(chain);
+            const nativeDecimals = chain_1.CHAIN_INFO[chain].vm === enums_1.VM.SVM ? 9 : 18;
+            const oneNativeUnit = utils_1.Utils.helpers.parseUnits('1', nativeDecimals);
+            const plannedPCDeposit = nativeTokenUsdPrice === BigInt(0)
+                ? BigInt(0)
+                : (r1Sizing.paddedDepositUsd * oneNativeUnit +
+                    (nativeTokenUsdPrice - BigInt(1))) /
+                    nativeTokenUsdPrice +
+                    BigInt(1);
+            const extraDepositPC = plannedPCDeposit > requiredGasFee
+                ? plannedPCDeposit - requiredGasFee
+                : BigInt(0);
+            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_03, chain, r1Sizing.paddedDepositUsd);
+            const r1SizingHookId = {
+                A: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_03_01,
+                B: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_03_02,
+                C: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_03_03,
+            }[r1Sizing.category];
+            (0, context_2.fireProgressHook)(ctx, r1SizingHookId, chain, requiredGasFee, extraDepositPC, r1Sizing.paddedDepositUsd);
+            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_03_04, nativeAmount, r1Sizing.paddedDepositUsd, chain);
+        }
+        catch (_d) {
+            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_03_04, nativeAmount, BigInt(0), chain);
+        }
         (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_01, execute.funds.amount, execute.funds.token.decimals, symbol);
         // Approve gateway to pull tokens if ERC-20
         if (execute.funds.token.mechanism === 'approve') {

package/src/lib/orchestrator/internals/execute-standard.d.ts

@@ -10,4 +10,5 @@ import { ProgressEvent } from '../../progress-hook/progress-hook.types';
 import type { ExecuteParams, UniversalTxResponse } from '../orchestrator.types';
 import type { OrchestratorContext } from './context';
 import { type ResponseBuilderCallbacks } from './response-builder';
+export declare function resolveRequiredFunds(requiredGasFee: bigint, executeValue: bigint, requiredFundsOverride?: bigint): bigint;
 export declare function executeStandardPayload(ctx: OrchestratorContext, execute: ExecuteParams, eventBuffer: ProgressEvent[], getResponseCallbacks: () => ResponseBuilderCallbacks): Promise<UniversalTxResponse>;

package/src/lib/orchestrator/internals/execute-standard.js

@@ -8,6 +8,7 @@
  * - Signed verification path for deployed UEA with funds
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRequiredFunds = resolveRequiredFunds;
 exports.executeStandardPayload = executeStandardPayload;
 const tslib_1 = require("tslib");
 const bs58_1 = require("../../internal/bs58");
@@ -76,6 +77,12 @@ function encodePayloadForOriginIfNeeded(ctx, payload, feeLockingRequired) {
     }
     return encodePayloadForOrigin(ctx, payload);
 }
+function resolveRequiredFunds(requiredGasFee, executeValue, requiredFundsOverride) {
+    const baseRequiredFunds = requiredGasFee + executeValue;
+    return requiredFundsOverride && requiredFundsOverride > baseRequiredFunds
+        ? requiredFundsOverride
+        : baseRequiredFunds;
+}
 function executeStandardPayload(ctx, execute, eventBuffer, getResponseCallbacks) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c;
@@ -122,7 +129,7 @@ function executeStandardPayload(ctx, execute, eventBuffer, getResponseCallbacks)
         const gasEstimate = execute.gasLimit || BigInt(1e7);
         const gasPrice = yield ctx.pushClient.getGasPrice();
         const requiredGasFee = gasEstimate * gasPrice;
-        const requiredFunds = requiredGasFee + execute.value;
+        const requiredFunds = resolveRequiredFunds(requiredGasFee, execute.value, execute._requiredFundsOverride);
         // Fetch UEA Details (or use pre-fetched status if available)
         const UEA = (0, uea_manager_1.computeUEAOffchain)(ctx);
         let isUEADeployed;

package/src/lib/orchestrator/internals/gas-calculator.d.ts

@@ -25,6 +25,23 @@ export declare function queryOutboundGasFee(ctx: OrchestratorContext, prc20Token
  * Falls back to a percentage of accountBalance if any on-chain query fails.
  */
 export declare function estimateNativeValueForSwap(ctx: OrchestratorContext, universalCoreAddress: `0x${string}`, gasToken: `0x${string}`, gasFee: bigint, accountBalance: bigint): Promise<bigint>;
+/**
+ * Bound the buffered swap estimate by the UEA's affordable PC.
+ *
+ * `result` is the 2.2x-buffered WPC needed for the gas swap; `minNeeded` is the
+ * un-buffered minimum the WPC->gasToken `exactOutput` swap actually consumes.
+ *
+ * Reducing the buffer to fit a tight balance is fine - but ONLY while the
+ * affordable amount (`accountBalance - reserve`) still covers `minNeeded`.
+ * Below that floor the swap cannot complete and reverts on-chain with Uniswap
+ * `STF`. The previous logic returned `accountBalance - reserve` unconditionally,
+ * which (a) under-funded `msg.value` into a doomed swap and (b) made the native
+ * preflight self-satisfying (`balance >= (balance - reserve) + reserve`), so the
+ * shortfall went undetected. When the balance can't cover the floor we now
+ * return the full `result` so the caller's preflight reports the real shortfall
+ * instead of emitting a cryptic STF.
+ */
+export declare function capSwapEstimate(result: bigint, accountBalance: bigint, reserve: bigint, minNeeded?: bigint): bigint;
 export declare function queryRescueGasFee(ctx: OrchestratorContext, prc20Token: `0x${string}`, destinationChain?: CHAIN): Promise<{
     gasToken: `0x${string}`;
     gasFee: bigint;
@@ -33,7 +50,9 @@ export declare function queryRescueGasFee(ctx: OrchestratorContext, prc20Token:
     nativeValueForGas: bigint;
     sizing?: GasSizingDecision;
 }>;
-export declare function calculateNativeAmountForDeposit(ctx: OrchestratorContext, chain: CHAIN, requiredFunds: bigint, ueaBalance: bigint): Promise<bigint>;
+export declare function calculateNativeAmountForDeposit(ctx: OrchestratorContext, chain: CHAIN, requiredFunds: bigint, ueaBalance: bigint, opts?: {
+    emitDepositEstimated?: boolean;
+}): Promise<bigint>;
 export declare function calculateGasAmountFromAmountOutMinETH(ctx: OrchestratorContext, gasTokenAddress: `0x${string}`, amountOutMinETH: bigint | string, quoteExactOutputFn: (amountOut: bigint, opts: {
     from: PayableToken | undefined;
     to: MoveableToken | undefined;

package/src/lib/orchestrator/internals/gas-calculator.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureErc20Allowance = ensureErc20Allowance;
 exports.queryOutboundGasFee = queryOutboundGasFee;
 exports.estimateNativeValueForSwap = estimateNativeValueForSwap;
+exports.capSwapEstimate = capSwapEstimate;
 exports.queryRescueGasFee = queryRescueGasFee;
 exports.calculateNativeAmountForDeposit = calculateNativeAmountForDeposit;
 exports.calculateGasAmountFromAmountOutMinETH = calculateGasAmountFromAmountOutMinETH;
@@ -309,7 +310,7 @@ function estimateNativeValueForSwap(ctx, universalCoreAddress, gasToken, gasFee,
                     const result = (exactWpcNeeded * SWAP_BUFFER_NUM) / SWAP_BUFFER_DEN;
                     (0, context_1.printLog)(ctx, `estimateNativeValueForSwap — exactOutput quoter=${quoterAddress}, ` +
                         `wpcNeeded=${exactWpcNeeded}, withBuffer(2.2x)=${result}`);
-                    return capSwapEstimate(result, accountBalance, GAS_RESERVE);
+                    return capSwapEstimate(result, accountBalance, GAS_RESERVE, exactWpcNeeded);
                 }
                 catch (quoteErr) {
                     (0, context_1.printLog)(ctx, `estimateNativeValueForSwap — exactOutput quote failed: ${quoteErr instanceof Error ? quoteErr.message : String(quoteErr)}, falling back to slot0 price`);
@@ -355,7 +356,7 @@ function estimateNativeValueForSwap(ctx, universalCoreAddress, gasToken, gasFee,
             const result = (wpcNeeded * SWAP_BUFFER_NUM) / SWAP_BUFFER_DEN;
             (0, context_1.printLog)(ctx, `estimateNativeValueForSwap — pool=${poolAddress}, sqrtPriceX96=${sqrtPriceX96}, ` +
                 `wpcNeeded=${wpcNeeded}, withBuffer(2.2x)=${result}`);
-            return capSwapEstimate(result, accountBalance, GAS_RESERVE);
+            return capSwapEstimate(result, accountBalance, GAS_RESERVE, wpcNeeded);
         }
         catch (err) {
             (0, context_1.printLog)(ctx, `estimateNativeValueForSwap — failed: ${err instanceof Error ? err.message : String(err)}, using balance fallback`);
@@ -363,14 +364,30 @@ function estimateNativeValueForSwap(ctx, universalCoreAddress, gasToken, gasFee,
         }
     });
 }
-function capSwapEstimate(result, accountBalance, reserve) {
+/**
+ * Bound the buffered swap estimate by the UEA's affordable PC.
+ *
+ * `result` is the 2.2x-buffered WPC needed for the gas swap; `minNeeded` is the
+ * un-buffered minimum the WPC->gasToken `exactOutput` swap actually consumes.
+ *
+ * Reducing the buffer to fit a tight balance is fine - but ONLY while the
+ * affordable amount (`accountBalance - reserve`) still covers `minNeeded`.
+ * Below that floor the swap cannot complete and reverts on-chain with Uniswap
+ * `STF`. The previous logic returned `accountBalance - reserve` unconditionally,
+ * which (a) under-funded `msg.value` into a doomed swap and (b) made the native
+ * preflight self-satisfying (`balance >= (balance - reserve) + reserve`), so the
+ * shortfall went undetected. When the balance can't cover the floor we now
+ * return the full `result` so the caller's preflight reports the real shortfall
+ * instead of emitting a cryptic STF.
+ */
+function capSwapEstimate(result, accountBalance, reserve, minNeeded = BigInt(0)) {
     if (accountBalance > result + reserve) {
         return result;
     }
-    if (accountBalance > reserve) {
+    if (accountBalance > reserve && accountBalance - reserve >= minNeeded) {
         return accountBalance - reserve;
     }
-    return result; // let caller decide if balance is too low
+    return result; // balance can't cover the swap floor - surface true need to preflight
 }
 function balanceFallback(balance, divisor, reserve) {
     const fraction = balance / divisor;
@@ -449,7 +466,12 @@ function queryRescueGasFee(ctx, prc20Token, destinationChain) {
 // ============================================================================
 // Native Amount Calculation for Deposit
 // ============================================================================
-function calculateNativeAmountForDeposit(ctx, chain, requiredFunds, ueaBalance) {
+function calculateNativeAmountForDeposit(ctx, chain, requiredFunds, ueaBalance, 
+// When false, suppress the SEND-TX-103-03-04 ("Prepaid Deposit Estimated")
+// progress hook so the caller can emit the full 103-03 sizing sequence
+// (parent + Case A/B/C + terminal) AFTER 103-01/103-02, matching the
+// funds-payload path ordering. The deposit math is unaffected.
+opts) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         var _a, _b;
         (0, context_1.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_102_01);
@@ -497,7 +519,9 @@ function calculateNativeAmountForDeposit(ctx, chain, requiredFunds, ueaBalance)
         let nativeAmount = (depositUsd * oneNativeUnit + (nativeTokenUsdPrice - BigInt(1))) /
             nativeTokenUsdPrice;
         nativeAmount = nativeAmount + BigInt(1);
-        (0, context_1.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_03_04, nativeAmount, depositUsd, chain);
+        if ((opts === null || opts === void 0 ? void 0 : opts.emitDepositEstimated) !== false) {
+            (0, context_1.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_03_04, nativeAmount, depositUsd, chain);
+        }
         return nativeAmount;
     });
 }

package/src/lib/orchestrator/internals/outbound-sync.d.ts

@@ -68,6 +68,7 @@ export declare function waitForAllOutboundTxsV2(ctx: OrchestratorContext, pushCh
     pollingIntervalMs: number;
     timeout: number;
     _resolvedSubTxId?: string;
+    _outboundIndexByHop?: Map<number, number>;
     progressHook?: (event: {
         hopIndex: number;
         route: TransactionRouteType;

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

@@ -180,7 +180,8 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
             const pollStart = Date.now();
             (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | Elapsed: ${pollStart - startTime}ms / ${timeout}ms`);
             if (!cachedUniversalSubTxId) {
-                cachedUniversalSubTxId = (_a = (yield (0, outbound_tracker_1.extractUniversalSubTxIdFromTx)(ctx, pushChainTxHash))) !== null && _a !== void 0 ? _a : undefined;
+                cachedUniversalSubTxId =
+                    (_a = (yield (0, outbound_tracker_1.extractUniversalSubTxIdFromTx)(ctx, pushChainTxHash))) !== null && _a !== void 0 ? _a : undefined;
                 if (!cachedUniversalSubTxId) {
                     cachedUniversalSubTxId = (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, pushChainTxHash);
                 }
@@ -228,13 +229,15 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                 let matchingOutboundIndex = 0;
                 for (const ob of outbounds) {
                     // If a destination chain filter is set, skip outbound entries that don't match.
-                    if (_expectedDestinationChain && ob.destinationChain !== _expectedDestinationChain) {
+                    if (_expectedDestinationChain &&
+                        ob.destinationChain !== _expectedDestinationChain) {
                         (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound chain '${ob.destinationChain}' does not match expected '${_expectedDestinationChain}', skipping`);
                         continue;
                     }
                     const currentOutboundIndex = matchingOutboundIndex;
                     matchingOutboundIndex += 1;
-                    if (_outboundIndex !== undefined && currentOutboundIndex !== _outboundIndex) {
+                    if (_outboundIndex !== undefined &&
+                        currentOutboundIndex !== _outboundIndex) {
                         (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound index ${currentOutboundIndex} for '${ob.destinationChain}' does not match expected index ${_outboundIndex}, skipping`);
                         continue;
                     }
@@ -262,7 +265,10 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                             const verdict = yield verifyExternalEvmReceipt(ctx, chain, ob.observedTx.txHash);
                             if (verdict === 'reverted') {
                                 (0, context_1.printLog)(ctx, `[waitForOutboundTx] Source-chain RPC reports REVERTED for ${ob.destinationChain} tx ${ob.observedTx.txHash} (cosmos still ${(_o = types_1.UniversalTxStatus[statusNum]) !== null && _o !== void 0 ? _o : statusNum})`);
-                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
+                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                    status: 'failed',
+                                    elapsed: Date.now() - startTime,
+                                });
                                 throw new OutboundFailedError(`Outbound to ${ob.destinationChain} reverted on source-chain RPC (tx: ${ob.observedTx.txHash}). Push Chain TX: ${pushChainTxHash}.`, pushChainTxHash, ob.destinationChain, ob.observedTx.txHash);
                             }
                             if (verdict !== 'success') {
@@ -277,12 +283,19 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                             const displayTxHash = (_s = (0, helpers_1.toExternalTxHashDisplay)(chain, ob.observedTx.txHash)) !== null && _s !== void 0 ? _s : ob.observedTx.txHash;
                             let explorerUrl = '';
                             if (isSvm) {
-                                const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET ? '?cluster=devnet'
-                                    : chain === enums_1.CHAIN.SOLANA_TESTNET ? '?cluster=testnet' : '';
-                                explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${displayTxHash}${cluster}` : '';
+                                const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET
+                                    ? '?cluster=devnet'
+                                    : chain === enums_1.CHAIN.SOLANA_TESTNET
+                                        ? '?cluster=testnet'
+                                        : '';
+                                explorerUrl = explorerBaseUrl
+                                    ? `${explorerBaseUrl}/tx/${displayTxHash}${cluster}`
+                                    : '';
                             }
                             else {
-                                explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${displayTxHash}` : '';
+                                explorerUrl = explorerBaseUrl
+                                    ? `${explorerBaseUrl}/tx/${displayTxHash}`
+                                    : '';
                             }
                             // OutboundTxDetails carries the raw `0x`-hex form so internal
                             // consumers (R3 inbound tracker in response-builder.ts:786 →
@@ -298,7 +311,10 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
                                 assetAddr: ob.externalAssetAddr,
                             };
                             (0, context_1.printLog)(ctx, `[waitForOutboundTx] FOUND on poll #${pollCount} | elapsed: ${Date.now() - startTime}ms | externalTxHash: ${displayTxHash}`);
-                            progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'found', elapsed: Date.now() - startTime });
+                            progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                status: 'found',
+                                elapsed: Date.now() - startTime,
+                            });
                             return details;
                         }
                     }
@@ -333,18 +349,24 @@ function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
  */
 function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-        const { initialWaitMs, pollingIntervalMs, timeout, progressHook, _resolvedSubTxId, } = options;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const { initialWaitMs, pollingIntervalMs, timeout, progressHook, _resolvedSubTxId, _outboundIndexByHop, } = options;
         const startTime = Date.now();
-        // Build a map: CAIP-2 namespace -> hop(s) for matching outbound entries
+        // Build maps for matching outbound entries. When the cascade composer merged
+        // multiple logical hops into one outbound request, `_outboundIndexByHop` maps
+        // those hops to the same outbound ordinal.
         const chainToHops = new Map();
         for (const hop of outboundHops) {
             const chainInfo = chain_1.CHAIN_INFO[hop.executionChain];
             if (chainInfo) {
                 const namespace = `${chain_1.VM_NAMESPACE[chainInfo.vm]}:${chainInfo.chainId}`;
-                const existing = chainToHops.get(namespace) || [];
+                const existingByOrdinal = chainToHops.get(namespace) || new Map();
+                const fallbackOrdinal = [...existingByOrdinal.values()].reduce((count, hopsForOrdinal) => count + hopsForOrdinal.length, 0);
+                const outboundOrdinal = (_a = _outboundIndexByHop === null || _outboundIndexByHop === void 0 ? void 0 : _outboundIndexByHop.get(hop.hopIndex)) !== null && _a !== void 0 ? _a : fallbackOrdinal;
+                const existing = existingByOrdinal.get(outboundOrdinal) || [];
                 existing.push(hop);
-                chainToHops.set(namespace, existing);
+                existingByOrdinal.set(outboundOrdinal, existing);
+                chainToHops.set(namespace, existingByOrdinal);
             }
         }
         const expectedChains = [...chainToHops.keys()];
@@ -387,7 +409,9 @@ function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
             // Resolve query ID on first poll
             if (!cachedQueryId) {
                 const allSubTxIds = yield (0, outbound_tracker_1.extractAllUniversalSubTxIds)(ctx, pushChainTxHash);
-                const subTxId = allSubTxIds.length > 0 ? allSubTxIds[0] : (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, pushChainTxHash);
+                const subTxId = allSubTxIds.length > 0
+                    ? allSubTxIds[0]
+                    : (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, pushChainTxHash);
                 cachedQueryId = subTxId.startsWith('0x') ? subTxId.slice(2) : subTxId;
                 (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Resolved queryId: ${cachedQueryId}`);
             }
@@ -396,41 +420,45 @@ function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
                 consecutiveErrors = 0; // Reset on successful RPC call
                 const utx = v2Response === null || v2Response === void 0 ? void 0 : v2Response.universalTx;
                 const statusNum = utx === null || utx === void 0 ? void 0 : utx.universalStatus;
-                const statusName = (_a = types_1.UniversalTxStatus[statusNum]) !== null && _a !== void 0 ? _a : statusNum;
-                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${(_c = (_b = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0}`);
-                if ((_d = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _d === void 0 ? void 0 : _d.length) {
+                const statusName = (_b = types_1.UniversalTxStatus[statusNum]) !== null && _b !== void 0 ? _b : statusNum;
+                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${(_d = (_c = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0}`);
+                if ((_e = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _e === void 0 ? void 0 : _e.length) {
                     const outboundOrdinalByChain = new Map();
                     for (const ob of utx.outboundTx) {
                         const destChain = ob.destinationChain;
-                        const hopsForChain = chainToHops.get(destChain);
-                        if (!hopsForChain)
+                        const hopsByOrdinal = chainToHops.get(destChain);
+                        if (!hopsByOrdinal)
                             continue;
-                        const outboundOrdinal = (_e = outboundOrdinalByChain.get(destChain)) !== null && _e !== void 0 ? _e : 0;
+                        const outboundOrdinal = (_f = outboundOrdinalByChain.get(destChain)) !== null && _f !== void 0 ? _f : 0;
                         outboundOrdinalByChain.set(destChain, outboundOrdinal + 1);
-                        const targetHop = hopsForChain[outboundOrdinal];
-                        if (!targetHop ||
-                            targetHop.status === 'confirmed' ||
-                            targetHop.status === 'failed') {
+                        const targetHops = hopsByOrdinal.get(outboundOrdinal) || [];
+                        const pendingTargetHops = targetHops.filter((hop) => hop.status !== 'confirmed' && hop.status !== 'failed');
+                        if (pendingTargetHops.length === 0)
                             continue;
-                        }
-                        const externalTxHash = (_f = ob.observedTx) === null || _f === void 0 ? void 0 : _f.txHash;
+                        const primaryTargetHop = pendingTargetHops[0];
+                        const externalTxHash = (_g = ob.observedTx) === null || _g === void 0 ? void 0 : _g.txHash;
                         const hasObservedTxHash = !!externalTxHash && externalTxHash !== 'EMPTY';
                         const observedFailure = hasObservedTxHash &&
-                            ((_g = ob.observedTx) === null || _g === void 0 ? void 0 : _g.success) === false &&
-                            Boolean(((_h = ob.observedTx) === null || _h === void 0 ? void 0 : _h.errorMsg) ||
+                            ((_h = ob.observedTx) === null || _h === void 0 ? void 0 : _h.success) === false &&
+                            Boolean(((_j = ob.observedTx) === null || _j === void 0 ? void 0 : _j.errorMsg) ||
                                 ob.abortReason ||
                                 ob.outboundStatus >= types_2.OutboundStatus.REVERTED);
                         // Fail fast on per-outbound REVERTED or observed destination failure.
-                        if (ob.outboundStatus === types_2.OutboundStatus.REVERTED || observedFailure) {
-                            targetHop.status = 'failed';
-                            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Outbound to ${destChain} REVERTED | outboundIndex ${outboundOrdinal} | hop ${targetHop.hopIndex} | error: ${ob.abortReason || ((_j = ob.observedTx) === null || _j === void 0 ? void 0 : _j.errorMsg) || 'Unknown'}`);
-                            progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                hopIndex: targetHop.hopIndex,
-                                route: targetHop.route,
-                                chain: targetHop.executionChain,
-                                status: 'failed',
-                            });
-                            return { success: false, failedAt: targetHop.hopIndex };
+                        if (ob.outboundStatus === types_2.OutboundStatus.REVERTED ||
+                            observedFailure) {
+                            for (const targetHop of pendingTargetHops) {
+                                targetHop.status = 'failed';
+                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                    hopIndex: targetHop.hopIndex,
+                                    route: targetHop.route,
+                                    chain: targetHop.executionChain,
+                                    status: 'failed',
+                                });
+                            }
+                            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Outbound to ${destChain} REVERTED | outboundIndex ${outboundOrdinal} | hops ${pendingTargetHops
+                                .map((hop) => hop.hopIndex)
+                                .join(', ')} | error: ${ob.abortReason || ((_k = ob.observedTx) === null || _k === void 0 ? void 0 : _k.errorMsg) || 'Unknown'}`);
+                            return { success: false, failedAt: primaryTargetHop.hopIndex };
                         }
                         // Check for observed tx hash. Cosmos may lag the status transition,
                         // so EVM destinations are verified against the destination receipt.
@@ -442,15 +470,19 @@ function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
                             if (!isCosmosObserved) {
                                 const verdict = yield verifyExternalEvmReceipt(ctx, chain, externalTxHash);
                                 if (verdict === 'reverted') {
-                                    targetHop.status = 'failed';
-                                    (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Source-chain RPC reports REVERTED for ${destChain} tx ${externalTxHash} | outboundIndex ${outboundOrdinal} | hop ${targetHop.hopIndex}`);
-                                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                        hopIndex: targetHop.hopIndex,
-                                        route: targetHop.route,
-                                        chain: targetHop.executionChain,
-                                        status: 'failed',
-                                    });
-                                    return { success: false, failedAt: targetHop.hopIndex };
+                                    for (const targetHop of pendingTargetHops) {
+                                        targetHop.status = 'failed';
+                                        progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                            hopIndex: targetHop.hopIndex,
+                                            route: targetHop.route,
+                                            chain: targetHop.executionChain,
+                                            status: 'failed',
+                                        });
+                                    }
+                                    (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Source-chain RPC reports REVERTED for ${destChain} tx ${externalTxHash} | outboundIndex ${outboundOrdinal} | hops ${pendingTargetHops
+                                        .map((hop) => hop.hopIndex)
+                                        .join(', ')}`);
+                                    return { success: false, failedAt: primaryTargetHop.hopIndex };
                                 }
                                 if (verdict !== 'success') {
                                     continue;
@@ -462,38 +494,49 @@ function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
                             // inside this function; it's not exposed to consumers from the
                             // cascade path (cascade.ts doesn't call findChildUtxIdFromExternalTx
                             // for the cascade outbound hash).
-                            const displayTxHash = (_k = (0, helpers_1.toExternalTxHashDisplay)(chain !== null && chain !== void 0 ? chain : undefined, externalTxHash)) !== null && _k !== void 0 ? _k : externalTxHash;
+                            const displayTxHash = (_l = (0, helpers_1.toExternalTxHashDisplay)(chain !== null && chain !== void 0 ? chain : undefined, externalTxHash)) !== null && _l !== void 0 ? _l : externalTxHash;
                             let explorerUrl = '';
                             if (chain && externalTxHash) {
-                                const explorerBaseUrl = (_l = chain_1.CHAIN_INFO[chain]) === null || _l === void 0 ? void 0 : _l.explorerUrl;
-                                const isSvm = ((_m = chain_1.CHAIN_INFO[chain]) === null || _m === void 0 ? void 0 : _m.vm) === enums_1.VM.SVM;
+                                const explorerBaseUrl = (_m = chain_1.CHAIN_INFO[chain]) === null || _m === void 0 ? void 0 : _m.explorerUrl;
+                                const isSvm = ((_o = chain_1.CHAIN_INFO[chain]) === null || _o === void 0 ? void 0 : _o.vm) === enums_1.VM.SVM;
                                 if (isSvm) {
-                                    const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET ? '?cluster=devnet'
-                                        : chain === enums_1.CHAIN.SOLANA_TESTNET ? '?cluster=testnet' : '';
-                                    explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${displayTxHash}${cluster}` : '';
+                                    const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET
+                                        ? '?cluster=devnet'
+                                        : chain === enums_1.CHAIN.SOLANA_TESTNET
+                                            ? '?cluster=testnet'
+                                            : '';
+                                    explorerUrl = explorerBaseUrl
+                                        ? `${explorerBaseUrl}/tx/${displayTxHash}${cluster}`
+                                        : '';
                                 }
                                 else {
-                                    explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${displayTxHash}` : '';
+                                    explorerUrl = explorerBaseUrl
+                                        ? `${explorerBaseUrl}/tx/${displayTxHash}`
+                                        : '';
                                 }
                             }
-                            targetHop.status = 'confirmed';
-                            targetHop.txHash = displayTxHash;
-                            targetHop.outboundDetails = {
-                                externalTxHash: displayTxHash,
-                                destinationChain: chain || targetHop.executionChain,
-                                explorerUrl,
-                                recipient: ob.recipient,
-                                amount: ob.amount,
-                                assetAddr: ob.externalAssetAddr,
-                            };
-                            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] FOUND outbound for ${destChain} | outboundIndex ${outboundOrdinal} | hop ${targetHop.hopIndex} | externalTxHash: ${displayTxHash}`);
-                            progressHook === null || progressHook === void 0 ? void 0 : progressHook({
-                                hopIndex: targetHop.hopIndex,
-                                route: targetHop.route,
-                                chain: targetHop.executionChain,
-                                status: 'confirmed',
-                                txHash: displayTxHash,
-                            });
+                            for (const targetHop of pendingTargetHops) {
+                                targetHop.status = 'confirmed';
+                                targetHop.txHash = displayTxHash;
+                                targetHop.outboundDetails = {
+                                    externalTxHash: displayTxHash,
+                                    destinationChain: chain || targetHop.executionChain,
+                                    explorerUrl,
+                                    recipient: ob.recipient,
+                                    amount: ob.amount,
+                                    assetAddr: ob.externalAssetAddr,
+                                };
+                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                    hopIndex: targetHop.hopIndex,
+                                    route: targetHop.route,
+                                    chain: targetHop.executionChain,
+                                    status: 'confirmed',
+                                    txHash: displayTxHash,
+                                });
+                            }
+                            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] FOUND outbound for ${destChain} | outboundIndex ${outboundOrdinal} | hops ${pendingTargetHops
+                                .map((hop) => hop.hopIndex)
+                                .join(', ')} | externalTxHash: ${displayTxHash}`);
                         }
                     }
                 }
@@ -508,7 +551,7 @@ function waitForAllOutboundTxsV2(ctx, pushChainTxHash, outboundHops, options) {
                 if (statusNum === types_1.UniversalTxStatus.PC_EXECUTED_SUCCESS) {
                     const stillUnresolved = outboundHops.filter((h) => h.status !== 'confirmed');
                     if (stillUnresolved.length > 0) {
-                        const hasPendingOutbound = (_o = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _o === void 0 ? void 0 : _o.some((ob) => {
+                        const hasPendingOutbound = (_p = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _p === void 0 ? void 0 : _p.some((ob) => {
                             var _a;
                             return ob.outboundStatus === types_2.OutboundStatus.PENDING &&
                                 (!((_a = ob.observedTx) === null || _a === void 0 ? void 0 : _a.txHash) || ob.observedTx.txHash === 'EMPTY');

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

@@ -563,14 +563,32 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
             }
         }
         const origin = `${chain_1.VM_NAMESPACE[vm]}:${chainId}:${originAddress}`;
-        // Create signature from transaction r, s, v values
+        // Create signature from transaction r, s, v values.
+        //
+        // Push Chain's derived (module-injected) inbound txs are reported over the EVM
+        // JSON-RPC as **legacy `type 0x0`**, which omits the `yParity` field that viem
+        // only populates for typed (EIP-1559/2930) txs — so `tx.yParity` is `undefined`.
+        // Per the chain team (the hash inconsistencies were fixed chain-side, but
+        // derived txs remain legacy 0x0 by design), the SDK must accept `0x0` and
+        // surface a numeric `yParity`. Derive it from `v`: 0/1 → as-is, 27/28 → v-27,
+        // EIP-155 → (v-35)%2. (For the zeroed-signature derived txs, v=0 → yParity=0.)
         let signature;
         try {
+            const vNum = typeof tx.v === 'bigint' ? Number(tx.v) : tx.v || 0;
+            let yParity = tx.yParity;
+            if (yParity === undefined) {
+                if (vNum === 0 || vNum === 1)
+                    yParity = vNum;
+                else if (vNum === 27 || vNum === 28)
+                    yParity = vNum - 27;
+                else
+                    yParity = (vNum - 35) % 2;
+            }
             signature = {
                 r: tx.r || '0x0',
                 s: tx.s || '0x0',
-                v: typeof tx.v === 'bigint' ? Number(tx.v) : tx.v || 0,
-                yParity: tx.yParity,
+                v: vNum,
+                yParity,
             };
         }
         catch (_d) {
@@ -631,7 +649,7 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
             accessList: Array.isArray(tx.accessList) ? [...tx.accessList] : [],
             // 6. Utilities
             wait: (waitOptions) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
                 // For trackTransaction replays the tx is historical — cosmos already
                 // has the full graph indexed, so the 20s/30s initial-wait buffers
                 // designed for live sends are pure deadweight. Default them to 0 when
@@ -776,7 +794,15 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                 // Resolve the terminal hash for the whole journey: inbound (R3) >
                 // external outbound (R2) > the Push tx itself (R1). Single-tx analogue
                 // of CascadeCompletionResult.finalTxHash.
-                baseReceipt = Object.assign(Object.assign({}, baseReceipt), { finalTxHash: (_l = (_k = baseReceipt.pushInboundTxHash) !== null && _k !== void 0 ? _k : baseReceipt.externalTxHash) !== null && _l !== void 0 ? _l : baseReceipt.hash });
+                baseReceipt = Object.assign(Object.assign({}, baseReceipt), { finalTxHash: (_l = (_k = baseReceipt.pushInboundTxHash) !== null && _k !== void 0 ? _k : baseReceipt.externalTxHash) !== null && _l !== void 0 ? _l : baseReceipt.hash, 
+                    // Ensure `externalChain` is populated whenever an external/inbound leg
+                    // surfaced an `externalTxHash`. The outbound-success branch already sets
+                    // it to the destination chain (so this `??` never overrides it); this
+                    // only fills the inbound/R3 and failed/timeout paths, where it should be
+                    // the route's external chain (= the response's `chain`).
+                    externalChain: (_m = baseReceipt.externalChain) !== null && _m !== void 0 ? _m : (baseReceipt.externalTxHash
+                        ? universalTxResponse.chain
+                        : baseReceipt.externalChain) });
                 return baseReceipt;
             }),
             // Internal: register a wait-phase progressHook without replaying

package/src/lib/orchestrator/internals/route-handlers.d.ts

@@ -19,6 +19,13 @@ import { MoveableToken } from '../../constants/tokens';
 import { TransactionRoute } from '../route-detector';
 import type { ChainTarget, ExecuteParams, UniversalExecuteParams, UniversalOutboundTxRequest, UniversalTxRequest, UniversalTxResponse } from '../orchestrator.types';
 import type { PUSH_NETWORK } from '../../constants/enums';
+export declare function getRequiredNativeBalanceForOutbound(nativeValueForGas: bigint, gasReserve: bigint): bigint;
+export declare function shouldSkipFeeLockingForOutbound(opts: {
+    isUEADeployed: boolean;
+    balance: bigint;
+    nativeValueForGas: bigint;
+    gasReserve: bigint;
+}): boolean;
 export declare function resolveR2DestinationFundsToken(token: MoveableToken, targetChain: CHAIN, pushNetwork: PUSH_NETWORK): MoveableToken;
 type ExecuteFn = (params: ExecuteParams | UniversalExecuteParams) => Promise<UniversalTxResponse>;
 /**