@pushchain/core 5.1.3 → 5.1.4-alpha.1

package/src/lib/orchestrator/internals/route-handlers.js

@@ -0,0 +1,1192 @@
+"use strict";
+/**
+ * Route handler functions extracted from Orchestrator.
+ *
+ * Each function corresponds to one of the multichain execution routes:
+ *   - executeMultiChain  (dispatch)
+ *   - executeUoaToCea    (Route 2 EVM)
+ *   - executeUoaToCeaSvm (Route 2 SVM)
+ *   - executeCeaToPush   (Route 3 EVM)
+ *   - executeCeaToPushSvm(Route 3 SVM)
+ *   - executeCeaToCea    (Route 4 stub)
+ *   - buildPayloadForRoute
+ *
+ * Every method receives an `OrchestratorContext` as first parameter and an
+ * `executeFn` callback that replaces the former `this.execute()` call.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeMultiChain = executeMultiChain;
+exports.executeUoaToCea = executeUoaToCea;
+exports.executeUoaToCeaSvm = executeUoaToCeaSvm;
+exports.executeCeaToPush = executeCeaToPush;
+exports.executeCeaToPushSvm = executeCeaToPushSvm;
+exports.executeCeaToCea = executeCeaToCea;
+exports.buildPayloadForRoute = buildPayloadForRoute;
+const tslib_1 = require("tslib");
+const web3_js_1 = require("@solana/web3.js");
+const viem_1 = require("viem");
+const context_1 = require("./context");
+const helpers_1 = require("./helpers");
+const payload_builder_1 = require("./payload-builder");
+const uea_manager_1 = require("./uea-manager");
+const gas_calculator_1 = require("./gas-calculator");
+const chain_1 = require("../../constants/chain");
+const route_detector_1 = require("../route-detector");
+const cea_utils_1 = require("../cea-utils");
+const payload_builders_1 = require("../payload-builders");
+const selectors_1 = require("../../constants/selectors");
+const erc20_evm_1 = require("../../constants/abi/erc20.evm");
+const push_chain_1 = require("../../push-chain/push-chain");
+// ---------------------------------------------------------------------------
+// executeMultiChain
+// ---------------------------------------------------------------------------
+/**
+ * Dispatch a universal execution to the correct route handler.
+ */
+function executeMultiChain(ctx, params, executeFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // Validate route parameters
+        (0, route_detector_1.validateRouteParams)(params, {
+            clientChain: ctx.universalSigner.account.chain,
+        });
+        // Detect the transaction route
+        const route = (0, route_detector_1.detectRoute)(params);
+        (0, context_1.printLog)(ctx, `executeMultiChain — detected route: ${route}, params: ${JSON.stringify({
+            to: typeof params.to === 'string'
+                ? params.to
+                : { address: params.to.address, chain: params.to.chain },
+            from: params.from,
+            hasValue: params.value !== undefined,
+            hasData: params.data !== undefined,
+            hasFunds: params.funds !== undefined,
+        }, null, 2)}`);
+        let response;
+        switch (route) {
+            case route_detector_1.TransactionRoute.UOA_TO_PUSH:
+                response = yield executeFn((0, helpers_1.toExecuteParams)(params));
+                break;
+            case route_detector_1.TransactionRoute.UOA_TO_CEA:
+                response = yield executeUoaToCea(ctx, params, executeFn);
+                break;
+            case route_detector_1.TransactionRoute.CEA_TO_PUSH:
+                response = yield executeCeaToPush(ctx, params, executeFn);
+                break;
+            case route_detector_1.TransactionRoute.CEA_TO_CEA:
+                response = yield executeCeaToCea(ctx, params, executeFn);
+                break;
+            default:
+                throw new Error(`Unknown transaction route: ${route}`);
+        }
+        // Set the route on the response for .wait() to use
+        response.route = route;
+        return response;
+    });
+}
+// ---------------------------------------------------------------------------
+// executeUoaToCea  (Route 2 — EVM)
+// ---------------------------------------------------------------------------
+/**
+ * Route 2: Execute outbound transaction from Push Chain to external CEA.
+ *
+ * Builds a multicall that executes on Push Chain (from UEA context):
+ * 1. Approves the gateway to spend PRC-20 tokens (if needed)
+ * 2. Calls sendUniversalTxOutbound on UniversalGatewayPC precompile
+ *
+ * The multicall is executed through the normal execute() flow which handles
+ * fee-locking on the origin chain and signature verification.
+ */
+function executeUoaToCea(ctx, params, executeFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const target = params.to;
+        const targetChain = target.chain;
+        const targetAddress = target.address;
+        const isSvm = (0, payload_builders_1.isSvmChain)(targetChain);
+        // Validate target address based on VM type
+        if (isSvm) {
+            // SVM: 32-byte hex address
+            if (!(0, payload_builders_1.isValidSolanaHexAddress)(targetAddress)) {
+                throw new Error(`Invalid Solana address: ${targetAddress}. ` +
+                    `Expected 0x + 64 hex chars (32 bytes).`);
+            }
+            const ZERO_32 = ('0x' + '0'.repeat(64));
+            if (targetAddress.toLowerCase() === ZERO_32.toLowerCase()) {
+                throw new Error(`Cannot send to zero address on Solana. ` +
+                    `This would result in permanent loss of funds.`);
+            }
+        }
+        else {
+            // EVM: 20-byte hex address
+            // Zero address is allowed for multicall (data is array) — the actual targets are in the data entries.
+            const isMulticall = Array.isArray(params.data);
+            if (targetAddress.toLowerCase() === selectors_1.ZERO_ADDRESS.toLowerCase() && !isMulticall) {
+                throw new Error(`Cannot send to zero address (0x0000...0000). ` +
+                    `This would result in permanent loss of funds.`);
+            }
+        }
+        // Validate chain supports outbound operations
+        if (!(0, cea_utils_1.chainSupportsOutbound)(targetChain)) {
+            throw new Error(`Chain ${targetChain} does not support outbound operations. ` +
+                `Supported chains: BNB_TESTNET, ETHEREUM_SEPOLIA, SOLANA_DEVNET, etc.`);
+        }
+        // Branch based on VM type
+        if (isSvm) {
+            return executeUoaToCeaSvm(ctx, params, target, executeFn);
+        }
+        // ===== EVM path (existing logic) =====
+        // Get UEA address
+        const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
+        (0, context_1.printLog)(ctx, `executeUoaToCea — target chain: ${targetChain}, target address: ${targetAddress}, UEA: ${ueaAddress}`);
+        // Get CEA address for this UEA on target chain
+        const { cea: ceaAddress, isDeployed: ceaDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain, (_a = ctx.rpcUrls[targetChain]) === null || _a === void 0 ? void 0 : _a[0]);
+        (0, context_1.printLog)(ctx, `executeUoaToCea — CEA address: ${ceaAddress}, deployed: ${ceaDeployed}`);
+        // Migration path: raw MIGRATION_SELECTOR payload, no multicall wrapping
+        let ceaPayload;
+        let prc20Token = selectors_1.ZERO_ADDRESS;
+        let burnAmount = BigInt(0);
+        if (params.migration) {
+            ceaPayload = (0, payload_builders_1.buildMigrationPayload)();
+            prc20Token = (0, helpers_1.getNativePRC20ForChain)(targetChain, ctx.pushNetwork);
+            burnAmount = BigInt(0); // Migration is logic-only — no funds. CEA rejects msg.value != 0.
+            (0, context_1.printLog)(ctx, `executeUoaToCea — MIGRATION: using raw MIGRATION_SELECTOR payload (${ceaPayload}), native PRC-20 ${prc20Token}`);
+        }
+        else {
+            // Build multicall for CEA execution on target chain
+            const ceaMulticalls = [];
+            // If there's data to execute on target
+            if (params.data) {
+                if (Array.isArray(params.data)) {
+                    // User provided explicit multicall array
+                    ceaMulticalls.push(...params.data);
+                }
+                else {
+                    // 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 ((_b = params.funds) === null || _b === void 0 ? void 0 : _b.amount) {
+                        const token = params.funds.token;
+                        if (token && token.mechanism !== 'native') {
+                            const erc20Transfer = (0, viem_1.encodeFunctionData)({
+                                abi: erc20_evm_1.ERC20_EVM,
+                                functionName: 'transfer',
+                                args: [targetAddress, params.funds.amount],
+                            });
+                            ceaMulticalls.push({
+                                to: token.address,
+                                value: BigInt(0),
+                                data: erc20Transfer,
+                            });
+                        }
+                    }
+                    // Single call with data. Forward native value (if any) so the target
+                    // contract receives it alongside the payload call. The vault deposits
+                    // native value to the CEA, and the multicall forwards it to the target.
+                    ceaMulticalls.push({
+                        to: targetAddress,
+                        value: (_c = params.value) !== null && _c !== void 0 ? _c : BigInt(0),
+                        data: params.data,
+                    });
+                }
+            }
+            else if (params.value) {
+                // Native value transfer only.
+                // If sending to the CEA itself, skip the multicall — the gateway deposits native
+                // value directly to CEA. A self-call with value would revert (CEA._handleMulticall
+                // rejects value-bearing self-calls).
+                if (targetAddress.toLowerCase() !== ceaAddress.toLowerCase()) {
+                    ceaMulticalls.push({
+                        to: targetAddress,
+                        value: params.value,
+                        data: '0x',
+                    });
+                }
+            }
+            // Build CEA multicall payload (this is what gets executed on the external chain)
+            ceaPayload = (0, payload_builders_1.buildCeaMulticallPayload)(ceaMulticalls);
+            // Determine token to burn on Push Chain
+            // NOTE: Even for PAYLOAD-only (no value), we need a valid PRC-20 token to:
+            // 1. Look up the target chain namespace in the gateway
+            // 2. Query and pay gas fees for the relay
+            if ((_d = params.funds) === null || _d === void 0 ? void 0 : _d.amount) {
+                // User explicitly specified funds with token
+                const token = params.funds.token;
+                if (token) {
+                    prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                    burnAmount = params.funds.amount;
+                }
+            }
+            else if (params.value && params.value > BigInt(0)) {
+                // Native value transfer: auto-select the PRC-20 token for target chain
+                prc20Token = (0, helpers_1.getNativePRC20ForChain)(targetChain, ctx.pushNetwork);
+                burnAmount = params.value;
+                (0, context_1.printLog)(ctx, `executeUoaToCea — auto-selected native PRC-20 ${prc20Token} for chain ${targetChain}, amount: ${burnAmount.toString()}`);
+            }
+            else if (params.data) {
+                // PAYLOAD-only (no value transfer): still need native token for chain namespace + gas fees
+                prc20Token = (0, helpers_1.getNativePRC20ForChain)(targetChain, ctx.pushNetwork);
+                burnAmount = BigInt(0);
+                (0, context_1.printLog)(ctx, `executeUoaToCea — PAYLOAD-only: using native PRC-20 ${prc20Token} for chain ${targetChain} with zero burn amount`);
+            }
+        }
+        // Build outbound request struct for the gateway
+        // NOTE: `target` is a LEGACY/DUMMY parameter for contract compatibility.
+        // The deployed UniversalGatewayPC still expects this field, but the relay does NOT use it
+        // to determine the actual destination. The relay determines destination from the PRC-20 token's
+        // SOURCE_CHAIN_NAMESPACE. We pass the CEA address as a non-zero placeholder.
+        // This field will be removed in future contract upgrades.
+        const targetBytes = ceaAddress; // Dummy value - any non-zero address works
+        const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_e = params.gasLimit) !== null && _e !== void 0 ? _e : BigInt(0), ceaPayload, ueaAddress // revert recipient is the UEA
+        );
+        (0, context_1.printLog)(ctx, `executeUoaToCea — outbound request: ${JSON.stringify({
+            target: outboundReq.target,
+            token: outboundReq.token,
+            amount: outboundReq.amount.toString(),
+            gasLimit: outboundReq.gasLimit.toString(),
+            payloadLength: outboundReq.payload.length,
+            revertRecipient: outboundReq.revertRecipient,
+        }, null, 2)}`);
+        // Get UniversalGatewayPC address
+        const gatewayPcAddress = (0, helpers_1.getUniversalGatewayPCAddress)();
+        // Pre-fetch UEA status early — balance is needed for gas value calculation
+        const signerChain = ctx.universalSigner.account.chain;
+        const isNativePushEOA = (0, helpers_1.isPushChain)(signerChain);
+        const [ueaCode, ueaBalance] = yield Promise.all([
+            ctx.pushClient.publicClient.getCode({ address: ueaAddress }),
+            ctx.pushClient.getBalance(ueaAddress),
+        ]);
+        const isUEADeployed = isNativePushEOA || ueaCode !== undefined;
+        if (!isUEADeployed) {
+            throw new Error('UEA is not deployed. Please send an inbound transaction to Push Chain first ' +
+                '(e.g. sendTransaction with value) to deploy your Universal Execution Account before using outbound transfers.');
+        }
+        const ueaNonce = isNativePushEOA ? BigInt(0) : yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress);
+        // Build the multicall that will execute ON Push Chain from UEA context
+        // This includes: 1) approve PRC-20 (if needed), 2) call sendUniversalTxOutbound
+        const pushChainMulticalls = [];
+        // Query gas fee from UniversalCore contract (needed for approval amount)
+        let gasFee = BigInt(0);
+        let nativeValueForGas = BigInt(0);
+        let gasToken = selectors_1.ZERO_ADDRESS;
+        if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+            try {
+                const result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, outboundReq.gasLimit);
+                gasFee = result.gasFee;
+                gasToken = result.gasToken;
+                nativeValueForGas = result.nativeValueForGas;
+                (0, context_1.printLog)(ctx, `executeUoaToCea — queried gas fee: ${gasFee.toString()}, gasToken: ${gasToken}, nativeValueForGas: ${nativeValueForGas.toString()}`);
+            }
+            catch (err) {
+                throw new Error(`Failed to query outbound gas fee: ${err}`);
+            }
+        }
+        // Adjust nativeValueForGas: the 1Mx multiplier from queryOutboundGasFee produces
+        // a value far too low for the actual WPC/gasToken swap price. Set it to 200 UPC
+        // (capped by balance) — enough for the swap, but avoids draining thin pools.
+        // The contract's swapAndBurnGas does exactOutputSingle and refunds excess PC.
+        const EVM_NATIVE_VALUE_TARGET = BigInt(200e18); // 200 UPC
+        const EVM_GAS_RESERVE = BigInt(3e18); // 3 UPC for tx overhead
+        // Reuse ueaBalance fetched earlier (line 383) — no tx sent between, balance is stable
+        const currentBalance = ueaBalance;
+        let adjustedValue;
+        if (currentBalance > EVM_NATIVE_VALUE_TARGET + EVM_GAS_RESERVE) {
+            // Enough balance: use 200 UPC target
+            adjustedValue = EVM_NATIVE_VALUE_TARGET;
+        }
+        else if (currentBalance > EVM_GAS_RESERVE) {
+            // Low balance: use what's available minus reserve
+            adjustedValue = currentBalance - EVM_GAS_RESERVE;
+        }
+        else {
+            // Very low balance: use original query value as-is
+            adjustedValue = nativeValueForGas;
+        }
+        if (adjustedValue !== nativeValueForGas) {
+            (0, context_1.printLog)(ctx, `executeUoaToCea — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (UEA balance: ${currentBalance.toString()})`);
+            nativeValueForGas = adjustedValue;
+        }
+        // Build outbound multicalls (approve burn + sendUniversalTxOutbound with native value)
+        const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+            prc20Token,
+            gasToken,
+            burnAmount,
+            gasFee,
+            nativeValueForGas,
+            gatewayPcAddress,
+            outboundRequest: outboundReq,
+        });
+        pushChainMulticalls.push(...outboundMulticalls);
+        (0, context_1.printLog)(ctx, `executeUoaToCea — Push Chain multicall has ${pushChainMulticalls.length} operations`);
+        // TODO: Enable pre-flight balance checks once outbound flow is stable
+        // if (burnAmount > BigInt(0)) {
+        //   const prc20Balance = await ctx.pushClient.publicClient.readContract({
+        //     address: prc20Token,
+        //     abi: [{ name: 'balanceOf', type: 'function', stateMutability: 'view', inputs: [{ name: 'account', type: 'address' }], outputs: [{ name: '', type: 'uint256' }] }],
+        //     functionName: 'balanceOf',
+        //     args: [ueaAddress],
+        //   }) as bigint;
+        //   if (prc20Balance < burnAmount) {
+        //     throw new Error(
+        //       `Insufficient PRC-20 token balance on UEA. ` +
+        //       `Required: ${burnAmount.toString()}, Available: ${prc20Balance.toString()}, ` +
+        //       `Token: ${prc20Token}, UEA: ${ueaAddress}. ` +
+        //       `Please bridge tokens to Push Chain first.`
+        //     );
+        //   }
+        // }
+        // const currentUeaBalance = await ctx.pushClient.getBalance(ueaAddress);
+        // if (currentUeaBalance < nativeValueForGas) {
+        //   throw new Error(
+        //     `Insufficient native balance on UEA for outbound gas. ` +
+        //     `Required: ${nativeValueForGas.toString()} wei, Available: ${currentUeaBalance.toString()} wei, ` +
+        //     `UEA: ${ueaAddress}. Please send UPC to your UEA first.`
+        //   );
+        // }
+        // Execute through the normal execute() flow
+        // This handles fee-locking on origin chain and executes the multicall from UEA context
+        // Sum native values from multicall entries for proper fee calculation
+        const multicallNativeValue = pushChainMulticalls.reduce((sum, mc) => { var _a; return sum + ((_a = mc.value) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+        const executeParams = {
+            to: ueaAddress, // multicall executes from UEA
+            value: multicallNativeValue, // ensures correct requiredFunds calculation
+            data: pushChainMulticalls, // array triggers multicall mode
+            _ueaStatus: {
+                isDeployed: isUEADeployed,
+                nonce: ueaNonce,
+                balance: ueaBalance,
+            },
+            _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+        };
+        const response = yield executeFn(executeParams);
+        // Add chain info to response
+        response.chain = targetChain;
+        response.chainNamespace = (0, helpers_1.getChainNamespace)(targetChain);
+        return response;
+    });
+}
+// ---------------------------------------------------------------------------
+// executeUoaToCeaSvm  (Route 2 — SVM)
+// ---------------------------------------------------------------------------
+/**
+ * Route 2 for SVM targets: Outbound from Push Chain to Solana.
+ *
+ * Three cases:
+ * 1. Withdraw SOL: Burn pSOL on Push Chain, recipient gets native SOL
+ * 2. Withdraw SPL: Burn PRC-20 on Push Chain, recipient gets SPL token
+ * 3. Execute (CPI): Burn pSOL + execute CPI on target Solana program
+ */
+function executeUoaToCeaSvm(ctx, params, target, executeFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        const targetChain = target.chain;
+        const targetAddress = target.address; // 0x-prefixed, 32 bytes
+        const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
+        const hasSvmExecute = !!params.svmExecute;
+        (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — target: ${targetAddress}, chain: ${targetChain}, ` +
+            `hasSvmExecute: ${hasSvmExecute}, value: ${(_b = (_a = params.value) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '0'}`);
+        // --- Build SVM payload ---
+        let svmPayload = '0x'; // empty for withdraw (SOL/SPL)
+        if (hasSvmExecute) {
+            // Execute case: encode the CPI payload
+            const exec = params.svmExecute;
+            svmPayload = (0, payload_builders_1.encodeSvmExecutePayload)({
+                targetProgram: exec.targetProgram,
+                accounts: exec.accounts,
+                ixData: exec.ixData,
+                instructionId: 2,
+            });
+            (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — encoded execute payload: ${(svmPayload.length - 2) / 2} bytes, ` +
+                `${exec.accounts.length} accounts`);
+        }
+        // --- Determine PRC-20 token and burn amount ---
+        let prc20Token = selectors_1.ZERO_ADDRESS;
+        let burnAmount = BigInt(0);
+        if ((_c = params.funds) === null || _c === void 0 ? void 0 : _c.amount) {
+            // User explicitly specified funds with token
+            const token = params.funds.token;
+            if (token) {
+                prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                burnAmount = params.funds.amount;
+            }
+        }
+        else if (params.value && params.value > BigInt(0)) {
+            // Native value transfer: auto-select pSOL for Solana chains
+            prc20Token = (0, helpers_1.getNativePRC20ForChain)(targetChain, ctx.pushNetwork);
+            burnAmount = params.value;
+            (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — auto-selected native PRC-20 ${prc20Token} for chain ${targetChain}, amount: ${burnAmount.toString()}`);
+        }
+        else if (hasSvmExecute) {
+            // Execute-only (no value): check if user specified an SPL token context
+            const token = params.funds && params.funds.token;
+            if (token) {
+                prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+            }
+            else {
+                prc20Token = (0, helpers_1.getNativePRC20ForChain)(targetChain, ctx.pushNetwork);
+            }
+            burnAmount = BigInt(0);
+            (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — EXECUTE-only: using PRC-20 ${prc20Token} with zero burn amount`);
+        }
+        // --- Determine target bytes ---
+        // For withdraw: target is the Solana recipient pubkey
+        // For execute: target is the target Solana program
+        const targetBytes = hasSvmExecute
+            ? params.svmExecute.targetProgram
+            : targetAddress;
+        // --- Build outbound request ---
+        const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_d = params.gasLimit) !== null && _d !== void 0 ? _d : BigInt(0), svmPayload, ueaAddress // revert recipient is the UEA
+        );
+        (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — outbound request: ${JSON.stringify({
+            target: outboundReq.target,
+            token: outboundReq.token,
+            amount: outboundReq.amount.toString(),
+            gasLimit: outboundReq.gasLimit.toString(),
+            payloadLength: (outboundReq.payload.length - 2) / 2,
+            revertRecipient: outboundReq.revertRecipient,
+        }, null, 2)}`);
+        // --- Pre-fetch UEA status early — balance is needed for gas value calculation ---
+        const gatewayPcAddress = (0, helpers_1.getUniversalGatewayPCAddress)();
+        const signerChainSvm = ctx.universalSigner.account.chain;
+        const isNativePushEOASvm = (0, helpers_1.isPushChain)(signerChainSvm);
+        // Skip getCode if accountStatusCache already confirmed deployment
+        const deployedHintSvm = (_f = (_e = ctx.accountStatusCache) === null || _e === void 0 ? void 0 : _e.uea) === null || _f === void 0 ? void 0 : _f.deployed;
+        let ueaBalance;
+        let isUEADeployed;
+        if (deployedHintSvm || isNativePushEOASvm) {
+            isUEADeployed = true;
+            ueaBalance = yield ctx.pushClient.getBalance(ueaAddress);
+        }
+        else {
+            const [ueaCode, balance] = yield Promise.all([
+                ctx.pushClient.publicClient.getCode({ address: ueaAddress }),
+                ctx.pushClient.getBalance(ueaAddress),
+            ]);
+            isUEADeployed = ueaCode !== undefined;
+            ueaBalance = balance;
+        }
+        if (!isUEADeployed) {
+            throw new Error('UEA is not deployed. Please send an inbound transaction to Push Chain first ' +
+                '(e.g. sendTransaction with value) to deploy your Universal Execution Account before using outbound transfers.');
+        }
+        const ueaNonce = isNativePushEOASvm ? BigInt(0) : yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress);
+        // --- Query gas fee (identical to EVM path) ---
+        let gasFee = BigInt(0);
+        let gasToken = selectors_1.ZERO_ADDRESS;
+        let universalCoreAddress;
+        let nativeValueForGas = BigInt(0);
+        if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+            const gasLimit = outboundReq.gasLimit;
+            try {
+                const result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, gasLimit);
+                gasFee = result.gasFee;
+                gasToken = result.gasToken;
+                nativeValueForGas = result.nativeValueForGas;
+                universalCoreAddress = result.universalCoreAddress;
+                // When user omits gasLimit (sent as 0), the contract computes fees using its internal
+                // baseGasLimitByChainNamespace. But the relay reads the stored gasLimit=0 from the
+                // on-chain outbound record and uses it as the Solana compute budget — 0 CU means the
+                // relay cannot execute the tx. Derive the effective limit from gasFee/gasPrice so
+                // the stored record has a non-zero compute budget the relay can use.
+                if (!params.gasLimit && result.gasPrice > BigInt(0)) {
+                    outboundReq.gasLimit = result.gasFee / result.gasPrice;
+                    (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — derived effectiveGasLimit: ${outboundReq.gasLimit} (gasFee=${result.gasFee} / gasPrice=${result.gasPrice})`);
+                }
+                (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — queried gas fee: ${gasFee.toString()}, gasToken: ${gasToken}, nativeValueForGas: ${nativeValueForGas.toString()}`);
+            }
+            catch (err) {
+                throw new Error(`Failed to query outbound gas fee: ${err}`);
+            }
+        }
+        // Estimate the actual WPC needed for the swap using on-chain pool price.
+        // The static 1Mx multiplier from queryOutboundGasFee doesn't reflect the real
+        // WPC/gasToken exchange rate. estimateNativeValueForSwap reads the Uniswap V3
+        // pool's slot0, computes the true cost, and adds a 2x buffer.
+        // Excess msg.value is refunded by the contract's swapAndBurnGas.
+        if (universalCoreAddress && gasFee > BigInt(0)) {
+            const estimated = yield (0, gas_calculator_1.estimateNativeValueForSwap)(ctx, universalCoreAddress, gasToken, gasFee, ueaBalance);
+            if (estimated > nativeValueForGas) {
+                (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${estimated.toString()} (pool-price estimate, UEA balance: ${ueaBalance.toString()})`);
+                nativeValueForGas = estimated;
+            }
+        }
+        // --- Build Push Chain multicalls (approve + sendUniversalTxOutbound) ---
+        // Reuse the same builder as EVM — this part is identical
+        const pushChainMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+            prc20Token,
+            gasToken,
+            burnAmount,
+            gasFee,
+            nativeValueForGas,
+            gatewayPcAddress,
+            outboundRequest: outboundReq,
+        });
+        (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — Push Chain multicall has ${pushChainMulticalls.length} operations`);
+        // Sum native values from multicall entries for proper fee calculation
+        const multicallNativeValue = pushChainMulticalls.reduce((sum, mc) => { var _a; return sum + ((_a = mc.value) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+        const executeParams = {
+            to: ueaAddress,
+            value: multicallNativeValue, // ensures correct requiredFunds calculation
+            data: pushChainMulticalls,
+            _ueaStatus: {
+                isDeployed: isUEADeployed,
+                nonce: ueaNonce,
+                balance: ueaBalance,
+            },
+            _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+        };
+        const response = yield executeFn(executeParams);
+        // Add chain info to response
+        response.chain = targetChain;
+        response.chainNamespace = (0, helpers_1.getChainNamespace)(targetChain);
+        return response;
+    });
+}
+// ---------------------------------------------------------------------------
+// executeCeaToPush  (Route 3 — EVM)
+// ---------------------------------------------------------------------------
+/**
+ * Route 3: Execute inbound transaction from CEA to Push Chain.
+ *
+ * This route instructs CEA on an external chain to call sendUniversalTxFromCEA,
+ * bridging funds/payloads back to Push Chain.
+ *
+ * Flow:
+ * 1. Build multicall for CEA: [approve Gateway (if ERC20), sendUniversalTxFromCEA]
+ * 2. Execute via Route 2 (UOA -> CEA) with PAYLOAD-only (CEA uses its own funds)
+ * 3. CEA executes multicall, Gateway locks funds, relayer mints PRC-20 on Push Chain
+ */
+function executeCeaToPush(ctx, params, executeFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g;
+        // 1. Validate and extract source chain
+        if (!((_a = params.from) === null || _a === void 0 ? void 0 : _a.chain)) {
+            throw new Error('Route 3 (CEA -> Push) requires from.chain to specify the source CEA chain');
+        }
+        const sourceChain = params.from.chain;
+        // SVM chains use a fundamentally different flow (gateway self-call, not CEA multicall)
+        if ((0, payload_builders_1.isSvmChain)(sourceChain)) {
+            return executeCeaToPushSvm(ctx, params, sourceChain, executeFn);
+        }
+        // 2. Extract destination on Push Chain
+        // For Route 3, 'to' is a Push Chain address (string), not a ChainTarget
+        const pushDestination = params.to;
+        if (typeof params.to !== 'string') {
+            throw new Error('Route 3 (CEA -> Push): to must be a Push Chain address (string), not a ChainTarget');
+        }
+        // 3. Get UEA address (will be recipient on Push Chain from CEA's perspective)
+        const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
+        // 4. Get CEA address on source chain
+        const { cea: ceaAddress, isDeployed: ceaDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_b = ctx.rpcUrls[sourceChain]) === null || _b === void 0 ? void 0 : _b[0]);
+        (0, context_1.printLog)(ctx, `executeCeaToPush — sourceChain: ${sourceChain}, CEA: ${ceaAddress}, deployed: ${ceaDeployed}`);
+        if (!ceaDeployed) {
+            throw new Error(`CEA not deployed on ${sourceChain}. ` +
+                `Deploy CEA first using Route 2 (UOA -> CEA) before using Route 3.`);
+        }
+        // 5. Get UniversalGateway address on source chain
+        const gatewayAddress = chain_1.UNIVERSAL_GATEWAY_ADDRESSES[sourceChain];
+        if (!gatewayAddress) {
+            throw new Error(`No UniversalGateway address configured for chain ${sourceChain}`);
+        }
+        // 6. Build multicall for CEA to execute on source chain (self-calls via sendUniversalTxToUEA)
+        const ceaMulticalls = [];
+        // Determine token and amount for sendUniversalTxToUEA
+        let tokenAddress = selectors_1.ZERO_ADDRESS;
+        let amount = BigInt(0);
+        if ((_c = params.funds) === null || _c === void 0 ? void 0 : _c.amount) {
+            // ERC20 token transfer from CEA
+            const token = params.funds.token;
+            if (token) {
+                if (token.mechanism === 'native') {
+                    // Native token (e.g., BNB on BSC)
+                    tokenAddress = selectors_1.ZERO_ADDRESS;
+                    amount = params.funds.amount;
+                }
+                else {
+                    // ERC20 token - need approval for gateway before sendUniversalTxToUEA
+                    tokenAddress = token.address;
+                    amount = params.funds.amount;
+                }
+            }
+        }
+        else if (params.value && params.value > BigInt(0)) {
+            // Native value transfer (e.g., BNB, ETH)
+            tokenAddress = selectors_1.ZERO_ADDRESS;
+            amount = params.value;
+        }
+        // bridgeAmount = only the burn amount (what the Vault will actually deposit to CEA).
+        // Previously this included ceaExistingBalance (CEA's pre-existing balance on the
+        // external chain), but that approach is racy: the balance can change between the SDK
+        // query and relay execution, causing sendUniversalTxToUEA to revert with
+        // InsufficientBalance. Pre-existing CEA funds remain parked and can be swept separately.
+        let bridgeAmount = amount;
+        // Note: CEA contract may reject amount=0 in sendUniversalTxToUEA.
+        // Keeping bridgeAmount as-is (0) for payload-only to test precompile behavior.
+        // For ERC20 tokens, add approve call for the bridge amount
+        // (CEA approves gateway to spend the Vault-deposited amount)
+        // Reset to 0 first for USDT-style tokens that revert on non-zero to non-zero approve.
+        if (tokenAddress !== selectors_1.ZERO_ADDRESS && bridgeAmount > BigInt(0)) {
+            const approveZeroData = (0, viem_1.encodeFunctionData)({
+                abi: erc20_evm_1.ERC20_EVM,
+                functionName: 'approve',
+                args: [gatewayAddress, BigInt(0)],
+            });
+            ceaMulticalls.push({
+                to: tokenAddress,
+                value: BigInt(0),
+                data: approveZeroData,
+            });
+            const approveData = (0, viem_1.encodeFunctionData)({
+                abi: erc20_evm_1.ERC20_EVM,
+                functionName: 'approve',
+                args: [gatewayAddress, bridgeAmount],
+            });
+            ceaMulticalls.push({
+                to: tokenAddress,
+                value: BigInt(0),
+                data: approveData,
+            });
+        }
+        // Pre-fetch UEA nonce — needed for the inbound UniversalPayload struct
+        // Skip getCode if accountStatusCache already confirmed deployment
+        let isUEADeployed;
+        let ueaNonce;
+        const deployedHintR3 = (_e = (_d = ctx.accountStatusCache) === null || _d === void 0 ? void 0 : _d.uea) === null || _e === void 0 ? void 0 : _e.deployed;
+        if (deployedHintR3) {
+            isUEADeployed = true;
+            ueaNonce = yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress);
+        }
+        else {
+            const ueaCode = yield ctx.pushClient.publicClient.getCode({ address: ueaAddress });
+            isUEADeployed = ueaCode !== undefined;
+            ueaNonce = isUEADeployed ? yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress) : BigInt(0);
+        }
+        // Build payload for Push Chain execution (if any)
+        // This is what happens AFTER funds arrive on Push Chain.
+        // The relay expects a full UniversalPayload struct (to, value, data, gasLimit, ...),
+        // where `data` contains the multicall payload (with UEA_MULTICALL_SELECTOR prefix).
+        let pushPayload = '0x';
+        if (params.data) {
+            const multicallData = (0, payload_builders_1.buildExecuteMulticall)({
+                execute: {
+                    to: pushDestination,
+                    value: params.value,
+                    data: params.data,
+                },
+                ueaAddress,
+            });
+            const multicallPayload = (0, payload_builder_1.buildMulticallPayloadData)(ctx, pushDestination, multicallData);
+            // Use ueaNonce + 1: the outbound tx itself consumes one nonce via execute(),
+            // so the inbound will arrive when the UEA nonce is already incremented.
+            pushPayload = (0, payload_builders_1.buildInboundUniversalPayload)(multicallPayload, { nonce: ueaNonce + BigInt(1) });
+        }
+        // Build sendUniversalTxToUEA self-call on CEA
+        // CEA multicall: to=CEA (self-call), value=0
+        // CEA internally calls gateway.sendUniversalTxFromCEA(...)
+        // Uses bridgeAmount (= burn amount deposited by Vault)
+        const sendUniversalTxCall = (0, payload_builders_1.buildSendUniversalTxToUEA)(ceaAddress, // to: CEA address (self-call)
+        tokenAddress, // token: address(0) for native, ERC20 address otherwise
+        bridgeAmount, // amount: burn amount only (Vault-deposited)
+        pushPayload, // payload: Push Chain execution payload
+        ueaAddress // revertRecipient: UEA on Push Chain (receives refund if inbound fails)
+        );
+        ceaMulticalls.push(sendUniversalTxCall);
+        // 7. Encode CEA multicalls into outbound payload
+        // CEA will self-execute this multicall (to=CEA, value=0)
+        const ceaPayload = (0, payload_builders_1.buildCeaMulticallPayload)(ceaMulticalls);
+        (0, context_1.printLog)(ctx, `executeCeaToPush — CEA payload (first 100 chars): ${ceaPayload.slice(0, 100)}...`);
+        // 8. Determine PRC-20 token for the outbound burn on Push Chain.
+        // For ERC20 flows (params.funds with token), use the token's PRC-20 (e.g. pUSDT)
+        // so the Vault deposits ERC20 to CEA. For native flows, use the chain's native PRC-20 (e.g. pBNB).
+        let prc20Token;
+        if (((_f = params.funds) === null || _f === void 0 ? void 0 : _f.amount) && params.funds.token) {
+            const token = params.funds.token;
+            prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+        }
+        else {
+            prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
+        }
+        // burnAmount = PRC20 to burn on Push Chain (NOT the bridge amount).
+        // Vault deposits burnAmount to CEA. CEA uses burnAmount + pre-existing balance for the bridge.
+        const burnAmount = amount;
+        (0, context_1.printLog)(ctx, `executeCeaToPush — prc20Token: ${prc20Token}, burnAmount: ${burnAmount.toString()}`);
+        // 9. Build outbound request (same structure as Route 2)
+        // target = CEA address (for self-execution), value = 0 in payload
+        const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, // target: CEA address (to=CEA for self-execution)
+        prc20Token, // token: native PRC-20 for source chain (for namespace lookup)
+        burnAmount, // amount: 1 wei (precompile workaround)
+        (_g = params.gasLimit) !== null && _g !== void 0 ? _g : BigInt(0), ceaPayload, // payload: ABI-encoded CEA multicall
+        ueaAddress // revertRecipient: UEA
+        );
+        (0, context_1.printLog)(ctx, `executeCeaToPush — outbound request: ${JSON.stringify({
+            target: outboundReq.target,
+            token: outboundReq.token,
+            amount: outboundReq.amount.toString(),
+            gasLimit: outboundReq.gasLimit.toString(),
+            payloadLength: outboundReq.payload.length,
+            revertRecipient: outboundReq.revertRecipient,
+        }, null, 2)}`);
+        // 10. Fetch UEA balance — needed for gas value calculation
+        // (UEA code + nonce already fetched above for the inbound UniversalPayload)
+        const gatewayPcAddress = (0, helpers_1.getUniversalGatewayPCAddress)();
+        const ueaBalance = yield ctx.pushClient.getBalance(ueaAddress);
+        // 11. Query gas fees from UniversalCore
+        let gasFee = BigInt(0);
+        let nativeValueForGas = BigInt(0);
+        let gasToken = selectors_1.ZERO_ADDRESS;
+        if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+            const gasLimit = outboundReq.gasLimit;
+            try {
+                const result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, gasLimit);
+                gasToken = result.gasToken;
+                gasFee = result.gasFee;
+                nativeValueForGas = result.nativeValueForGas;
+                (0, context_1.printLog)(ctx, `executeCeaToPush — queried gas fee: ${gasFee.toString()}, gasToken: ${gasToken}, nativeValueForGas: ${nativeValueForGas.toString()}`);
+            }
+            catch (err) {
+                throw new Error(`Failed to query outbound gas fee for Route 3: ${err}`);
+            }
+        }
+        // Adjust nativeValueForGas using UEA balance (contract refunds excess)
+        // Reuse ueaBalance from line 978 — no tx sent between, balance is stable
+        const currentBalance = ueaBalance;
+        // Cosmos-EVM tx overhead costs ~1 PC per operation; 3 PC covers approve(s) + buffer.
+        const OUTBOUND_GAS_RESERVE_R3 = BigInt(3e18);
+        if (currentBalance > OUTBOUND_GAS_RESERVE_R3 && currentBalance - OUTBOUND_GAS_RESERVE_R3 > nativeValueForGas) {
+            const adjustedValue = currentBalance - OUTBOUND_GAS_RESERVE_R3;
+            (0, context_1.printLog)(ctx, `executeCeaToPush — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (UEA balance: ${currentBalance.toString()})`);
+            nativeValueForGas = adjustedValue;
+        }
+        // 12. Build Push Chain multicalls (approvals + sendUniversalTxOutbound)
+        const pushChainMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+            prc20Token,
+            gasToken,
+            burnAmount,
+            gasFee,
+            nativeValueForGas,
+            gatewayPcAddress,
+            outboundRequest: outboundReq,
+        });
+        (0, context_1.printLog)(ctx, `executeCeaToPush — Push Chain multicall has ${pushChainMulticalls.length} operations`);
+        // Sum native values from multicall entries for proper fee calculation
+        const multicallNativeValue = pushChainMulticalls.reduce((sum, mc) => { var _a; return sum + ((_a = mc.value) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+        // 13. Execute through the normal execute() flow
+        const executeParams = {
+            to: ueaAddress,
+            value: multicallNativeValue, // ensures correct requiredFunds calculation
+            data: pushChainMulticalls,
+            _ueaStatus: {
+                isDeployed: isUEADeployed,
+                nonce: ueaNonce,
+                balance: ueaBalance,
+            },
+            _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+        };
+        const response = yield executeFn(executeParams);
+        // Add Route 3 context to response
+        response.chain = sourceChain;
+        const chainInfo = chain_1.CHAIN_INFO[sourceChain];
+        response.chainNamespace = `${chain_1.VM_NAMESPACE[chainInfo.vm]}:${chainInfo.chainId}`;
+        return response;
+    });
+}
+// ---------------------------------------------------------------------------
+// executeCeaToPushSvm  (Route 3 — SVM)
+// ---------------------------------------------------------------------------
+/**
+ * Route 3 SVM: Execute CEA-to-Push for Solana chains.
+ *
+ * Unlike EVM Route 3 which builds CEA multicalls, SVM Route 3 encodes a
+ * `send_universal_tx_to_uea` instruction as an execute payload targeting
+ * the SVM gateway program (self-call). The drain amount is embedded in
+ * the instruction data, not in the outbound request amount.
+ */
+function executeCeaToPushSvm(ctx, params, sourceChain, executeFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (typeof params.to !== 'string') {
+            throw new Error('Route 3 SVM (CEA -> Push): to must be a Push Chain address (string), not a ChainTarget');
+        }
+        const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
+        // Get gateway program ID from chain config and convert to 0x-hex 32 bytes
+        const lockerContract = chain_1.CHAIN_INFO[sourceChain].lockerContract;
+        if (!lockerContract) {
+            throw new Error(`No SVM gateway program configured for chain ${sourceChain}`);
+        }
+        const programPk = new web3_js_1.PublicKey(lockerContract);
+        const gatewayProgramHex = ('0x' + Buffer.from(programPk.toBytes()).toString('hex'));
+        (0, context_1.printLog)(ctx, `executeCeaToPushSvm — sourceChain: ${sourceChain}, gateway: ${lockerContract}`);
+        // Determine drain amount and token
+        let drainAmount = BigInt(0);
+        let tokenMintHex;
+        let prc20Token;
+        if (((_a = params.funds) === null || _a === void 0 ? void 0 : _a.amount) && params.funds.amount > BigInt(0)) {
+            // SPL token drain
+            drainAmount = params.funds.amount;
+            const token = params.funds.token;
+            if (token && token.address) {
+                // Convert SPL mint address to 32-byte hex
+                const mintPk = new web3_js_1.PublicKey(token.address);
+                tokenMintHex = ('0x' + Buffer.from(mintPk.toBytes()).toString('hex'));
+                prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+            }
+            else {
+                prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
+            }
+        }
+        else if (params.value && params.value > BigInt(0)) {
+            // Native SOL drain
+            drainAmount = params.value;
+            prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
+        }
+        else {
+            // Payload-only Route 3 SVM: no funds to drain, just execute data on Push Chain
+            drainAmount = BigInt(0);
+            prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
+        }
+        // Build the SVM CPI payload (send_universal_tx_to_uea wrapped in execute)
+        // If params.data is provided, pass it as extraPayload for Push Chain execution
+        let extraPayload;
+        if (params.data && typeof params.data === 'string') {
+            extraPayload = (0, viem_1.hexToBytes)(params.data);
+        }
+        // Derive CEA PDA as revert recipient: ["push_identity", ueaAddress_20_bytes]
+        const ueaBytes = Buffer.from(ueaAddress.slice(2), 'hex'); // 20 bytes
+        const [ceaPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('push_identity'), ueaBytes], programPk);
+        const ceaPdaHex = ('0x' + Buffer.from(ceaPda.toBytes()).toString('hex'));
+        const svmPayload = (0, payload_builders_1.encodeSvmCeaToUeaPayload)({
+            gatewayProgramHex,
+            drainAmount,
+            tokenMintHex,
+            extraPayload,
+            revertRecipientHex: ceaPdaHex,
+        });
+        (0, context_1.printLog)(ctx, `executeCeaToPushSvm — drainAmount: ${drainAmount.toString()}, payload length: ${(svmPayload.length - 2) / 2} bytes`);
+        // burnAmount = 1 (minimum for precompile; drain amount lives inside the ixData)
+        // The precompile rejects amount=0, so we use BigInt(1) as a workaround.
+        const burnAmount = BigInt(1);
+        // Build outbound request: target = gateway program (self-call)
+        const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, prc20Token, burnAmount, (_b = params.gasLimit) !== null && _b !== void 0 ? _b : BigInt(0), svmPayload, ueaAddress);
+        (0, context_1.printLog)(ctx, `executeCeaToPushSvm — outbound request: target=${outboundReq.target.slice(0, 20)}..., token=${outboundReq.token}`);
+        // Pre-fetch UEA status early — balance is needed for gas value calculation
+        const gatewayPcAddress = (0, helpers_1.getUniversalGatewayPCAddress)();
+        const [ueaCode, ueaBalance] = yield Promise.all([
+            ctx.pushClient.publicClient.getCode({ address: ueaAddress }),
+            ctx.pushClient.getBalance(ueaAddress),
+        ]);
+        const isUEADeployed = ueaCode !== undefined;
+        const ueaNonce = isUEADeployed ? yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress) : BigInt(0);
+        // Query gas fees
+        let gasFee = BigInt(0);
+        let nativeValueForGas = BigInt(0);
+        let gasToken = selectors_1.ZERO_ADDRESS;
+        if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+            try {
+                const result = yield (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, outboundReq.gasLimit);
+                gasToken = result.gasToken;
+                gasFee = result.gasFee;
+                nativeValueForGas = result.nativeValueForGas;
+                (0, context_1.printLog)(ctx, `executeCeaToPushSvm — gasFee: ${gasFee.toString()}, gasToken: ${gasToken}, nativeValueForGas: ${nativeValueForGas.toString()}`);
+            }
+            catch (err) {
+                throw new Error(`Failed to query outbound gas fee for SVM Route 3: ${err}`);
+            }
+        }
+        // Adjust nativeValueForGas using UEA balance (contract refunds excess)
+        // Re-fetch balance to minimize staleness from gas fee query RPC roundtrips
+        const currentBalance = yield ctx.pushClient.getBalance(ueaAddress);
+        // Cosmos-EVM tx overhead costs ~1 PC per operation; 3 PC covers approve(s) + buffer.
+        const OUTBOUND_GAS_RESERVE_R3_SVM = BigInt(3e18);
+        if (currentBalance > OUTBOUND_GAS_RESERVE_R3_SVM && currentBalance - OUTBOUND_GAS_RESERVE_R3_SVM > nativeValueForGas) {
+            const adjustedValue = currentBalance - OUTBOUND_GAS_RESERVE_R3_SVM;
+            (0, context_1.printLog)(ctx, `executeCeaToPushSvm — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (UEA balance: ${currentBalance.toString()})`);
+            nativeValueForGas = adjustedValue;
+        }
+        // Build Push Chain multicalls (approvals + sendUniversalTxOutbound)
+        const pushChainMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+            prc20Token,
+            gasToken,
+            burnAmount,
+            gasFee,
+            nativeValueForGas,
+            gatewayPcAddress,
+            outboundRequest: outboundReq,
+        });
+        // Sum native values from multicall entries for proper fee calculation
+        const multicallNativeValue = pushChainMulticalls.reduce((sum, mc) => { var _a; return sum + ((_a = mc.value) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+        // Execute through the normal execute() flow
+        const executeParams = {
+            to: ueaAddress,
+            value: multicallNativeValue, // ensures correct requiredFunds calculation
+            data: pushChainMulticalls,
+            _ueaStatus: {
+                isDeployed: isUEADeployed,
+                nonce: ueaNonce,
+                balance: ueaBalance,
+            },
+            _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+        };
+        const response = yield executeFn(executeParams);
+        // Add Route 3 SVM context to response
+        response.chain = sourceChain;
+        const chainInfo = chain_1.CHAIN_INFO[sourceChain];
+        response.chainNamespace = `${chain_1.VM_NAMESPACE[chainInfo.vm]}:${chainInfo.chainId}`;
+        return response;
+    });
+}
+// ---------------------------------------------------------------------------
+// executeCeaToCea  (Route 4 — stub)
+// ---------------------------------------------------------------------------
+/**
+ * Route 4: Execute CEA to CEA transaction via Push Chain.
+ */
+function executeCeaToCea(ctx, params, executeFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // CEA -> CEA requires chaining Route 3 (CEA -> Push) and Route 2 (Push -> CEA)
+        // This is a complex flow that requires coordination
+        throw new Error('CEA -> CEA transactions are not yet fully implemented. ' +
+            'Use prepareTransaction().thenOn() to chain Route 3 -> Route 2 manually.');
+    });
+}
+// ---------------------------------------------------------------------------
+// buildPayloadForRoute
+// ---------------------------------------------------------------------------
+/**
+ * Build payload for a specific route.
+ */
+function buildPayloadForRoute(ctx, params, route, nonce) {
+    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 ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
+        switch (route) {
+            case route_detector_1.TransactionRoute.UOA_TO_PUSH: {
+                // Build standard Push Chain payload
+                const executeParams = (0, helpers_1.toExecuteParams)(params);
+                const multicallData = (0, payload_builders_1.buildExecuteMulticall)({
+                    execute: executeParams,
+                    ueaAddress,
+                });
+                const payload = (0, payload_builder_1.buildMulticallPayloadData)(ctx, executeParams.to, multicallData);
+                const req = (0, payload_builder_1.buildUniversalTxRequest)(ctx.universalSigner.account.address, {
+                    recipient: viem_1.zeroAddress,
+                    token: viem_1.zeroAddress,
+                    amount: BigInt(0),
+                    payload,
+                });
+                return { payload, gatewayRequest: req };
+            }
+            case route_detector_1.TransactionRoute.UOA_TO_CEA: {
+                const target = params.to;
+                // Branch: SVM vs EVM
+                if ((0, payload_builders_1.isSvmChain)(target.chain)) {
+                    // SVM: build SVM payload (binary or empty for withdraw)
+                    let payload = '0x';
+                    if (params.svmExecute) {
+                        payload = (0, payload_builders_1.encodeSvmExecutePayload)({
+                            targetProgram: params.svmExecute.targetProgram,
+                            accounts: params.svmExecute.accounts,
+                            ixData: params.svmExecute.ixData,
+                            instructionId: 2,
+                        });
+                    }
+                    const targetBytes = (_b = (_a = params.svmExecute) === null || _a === void 0 ? void 0 : _a.targetProgram) !== null && _b !== void 0 ? _b : target.address;
+                    let prc20Token = selectors_1.ZERO_ADDRESS;
+                    let burnAmount = BigInt(0);
+                    if ((_c = params.funds) === null || _c === void 0 ? void 0 : _c.amount) {
+                        const token = params.funds.token;
+                        if (token) {
+                            prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                            burnAmount = params.funds.amount;
+                        }
+                    }
+                    else if (params.value && params.value > BigInt(0)) {
+                        prc20Token = (0, helpers_1.getNativePRC20ForChain)(target.chain, ctx.pushNetwork);
+                        burnAmount = params.value;
+                    }
+                    else if (params.svmExecute) {
+                        prc20Token = (0, helpers_1.getNativePRC20ForChain)(target.chain, ctx.pushNetwork);
+                        burnAmount = BigInt(1);
+                    }
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_d = params.gasLimit) !== null && _d !== void 0 ? _d : BigInt(0), payload, ueaAddress);
+                    return { payload, gatewayRequest: outboundReq };
+                }
+                // EVM path: Resolve CEA address first (needed for self-transfer check)
+                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, target.chain, (_e = ctx.rpcUrls[target.chain]) === null || _e === void 0 ? void 0 : _e[0]);
+                // Build CEA outbound payload
+                const multicalls = [];
+                if (params.data) {
+                    if (Array.isArray(params.data)) {
+                        multicalls.push(...params.data);
+                    }
+                    else {
+                        // Single call with data. Native value (if any) is already delivered to
+                        // CEA by the Vault via executeUniversalTx{value: amount}(). Attaching
+                        // value to the call would revert if the target function is not payable.
+                        // To call a payable function with value, use explicit multicalls.
+                        multicalls.push({
+                            to: target.address,
+                            value: BigInt(0),
+                            data: params.data,
+                        });
+                    }
+                }
+                else if (params.value) {
+                    // Skip multicall when sending native value to own CEA — gateway deposits directly.
+                    // Self-call with value would revert (CEA._handleMulticall rejects it).
+                    if (target.address.toLowerCase() !== ceaAddress.toLowerCase()) {
+                        multicalls.push({
+                            to: target.address,
+                            value: params.value,
+                            data: '0x',
+                        });
+                    }
+                }
+                const payload = (0, payload_builders_1.buildCeaMulticallPayload)(multicalls);
+                let prc20Token = selectors_1.ZERO_ADDRESS;
+                let burnAmount = BigInt(0);
+                if ((_f = params.funds) === null || _f === void 0 ? void 0 : _f.amount) {
+                    const token = params.funds.token;
+                    if (token) {
+                        prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                        burnAmount = params.funds.amount;
+                    }
+                }
+                const targetBytes = ceaAddress;
+                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_g = params.gasLimit) !== null && _g !== void 0 ? _g : BigInt(0), payload, ueaAddress);
+                return { payload, gatewayRequest: outboundReq };
+            }
+            case route_detector_1.TransactionRoute.CEA_TO_PUSH: {
+                // Route 3: CEA -> Push Chain
+                // Build CEA multicall (approve + sendUniversalTxFromCEA) and wrap in outbound
+                if (!((_h = params.from) === null || _h === void 0 ? void 0 : _h.chain)) {
+                    throw new Error('Route 3 (CEA -> Push) requires from.chain');
+                }
+                const sourceChain = params.from.chain;
+                const pushDestination = params.to;
+                // SVM chains use gateway self-call, not CEA multicall
+                if ((0, payload_builders_1.isSvmChain)(sourceChain)) {
+                    const lockerContract = chain_1.CHAIN_INFO[sourceChain].lockerContract;
+                    if (!lockerContract) {
+                        throw new Error(`No SVM gateway program configured for chain ${sourceChain}`);
+                    }
+                    const programPk = new web3_js_1.PublicKey(lockerContract);
+                    const gatewayProgramHex = ('0x' + Buffer.from(programPk.toBytes()).toString('hex'));
+                    let drainAmount = BigInt(0);
+                    let tokenMintHex;
+                    let prc20Token;
+                    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) {
+                            const mintPk = new web3_js_1.PublicKey(token.address);
+                            tokenMintHex = ('0x' + Buffer.from(mintPk.toBytes()).toString('hex'));
+                            prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                        }
+                        else {
+                            prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
+                        }
+                    }
+                    else if (params.value && params.value > BigInt(0)) {
+                        drainAmount = params.value;
+                        prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
+                    }
+                    else {
+                        // Payload-only Route 3 SVM: no funds to drain, just execute data on Push Chain
+                        drainAmount = BigInt(0);
+                        prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
+                    }
+                    // Derive CEA PDA as revert recipient
+                    const ueaBytes2 = Buffer.from(ueaAddress.slice(2), 'hex');
+                    const [ceaPda2] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('push_identity'), ueaBytes2], programPk);
+                    const ceaPdaHex2 = ('0x' + Buffer.from(ceaPda2.toBytes()).toString('hex'));
+                    const svmPayload = (0, payload_builders_1.encodeSvmCeaToUeaPayload)({
+                        gatewayProgramHex,
+                        drainAmount,
+                        tokenMintHex,
+                        revertRecipientHex: ceaPdaHex2,
+                    });
+                    // burnAmount = 1 (minimum for precompile; drain amount lives inside the ixData)
+                    const burnAmount = BigInt(1);
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, prc20Token, burnAmount, (_k = params.gasLimit) !== null && _k !== void 0 ? _k : BigInt(0), svmPayload, ueaAddress);
+                    return { payload: svmPayload, gatewayRequest: outboundReq };
+                }
+                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_l = ctx.rpcUrls[sourceChain]) === null || _l === void 0 ? void 0 : _l[0]);
+                const gatewayAddr = chain_1.UNIVERSAL_GATEWAY_ADDRESSES[sourceChain];
+                if (!gatewayAddr) {
+                    throw new Error(`No UniversalGateway address configured for chain ${sourceChain}`);
+                }
+                // Build CEA multicalls (self-calls via sendUniversalTxToUEA)
+                const ceaMulticalls = [];
+                let tokenAddress = selectors_1.ZERO_ADDRESS;
+                let amount = BigInt(0);
+                if ((_m = params.funds) === null || _m === void 0 ? void 0 : _m.amount) {
+                    const token = params.funds.token;
+                    if (token) {
+                        if (token.mechanism === 'native') {
+                            tokenAddress = selectors_1.ZERO_ADDRESS;
+                            amount = params.funds.amount;
+                        }
+                        else {
+                            tokenAddress = token.address;
+                            amount = params.funds.amount;
+                            // Reset allowance to 0 first for USDT-style tokens, then approve
+                            const approveZeroData = (0, viem_1.encodeFunctionData)({
+                                abi: erc20_evm_1.ERC20_EVM,
+                                functionName: 'approve',
+                                args: [gatewayAddr, BigInt(0)],
+                            });
+                            ceaMulticalls.push({
+                                to: tokenAddress,
+                                value: BigInt(0),
+                                data: approveZeroData,
+                            });
+                            const approveData = (0, viem_1.encodeFunctionData)({
+                                abi: erc20_evm_1.ERC20_EVM,
+                                functionName: 'approve',
+                                args: [gatewayAddr, amount],
+                            });
+                            ceaMulticalls.push({
+                                to: tokenAddress,
+                                value: BigInt(0),
+                                data: approveData,
+                            });
+                        }
+                    }
+                }
+                else if (params.value && params.value > BigInt(0)) {
+                    tokenAddress = selectors_1.ZERO_ADDRESS;
+                    amount = params.value;
+                }
+                // Fetch UEA nonce for inbound UniversalPayload
+                const ueaCodeHop = yield ctx.pushClient.publicClient.getCode({ address: ueaAddress });
+                const ueaNonceHop = ueaCodeHop !== undefined ? yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress) : BigInt(0);
+                // Build Push Chain payload (what executes after inbound arrives)
+                // Wrap in UniversalPayload struct for the relay.
+                let pushPayload = '0x';
+                if (params.data) {
+                    const multicallData = (0, payload_builders_1.buildExecuteMulticall)({
+                        execute: {
+                            to: pushDestination,
+                            value: params.value,
+                            data: params.data,
+                        },
+                        ueaAddress,
+                    });
+                    const multicallPayload = (0, payload_builder_1.buildMulticallPayloadData)(ctx, pushDestination, multicallData);
+                    pushPayload = (0, payload_builders_1.buildInboundUniversalPayload)(multicallPayload, { nonce: ueaNonceHop + BigInt(1) });
+                }
+                // Build sendUniversalTxToUEA self-call on CEA (to=CEA, value=0)
+                const sendCall = (0, payload_builders_1.buildSendUniversalTxToUEA)(ceaAddress, tokenAddress, amount, pushPayload, ceaAddress);
+                ceaMulticalls.push(sendCall);
+                const ceaPayload = (0, payload_builders_1.buildCeaMulticallPayload)(ceaMulticalls);
+                const prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
+                // burnAmount = actual amount needed by CEA. Vault deposits this as msg.value.
+                // Fallback to BigInt(1) for payload-only outbound (precompile rejects amount=0).
+                const burnAmount = amount > BigInt(0) ? amount : BigInt(1);
+                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, prc20Token, burnAmount, (_o = params.gasLimit) !== null && _o !== void 0 ? _o : BigInt(0), ceaPayload, ueaAddress);
+                return { payload: ceaPayload, gatewayRequest: outboundReq };
+            }
+            default:
+                throw new Error(`Cannot build payload for route: ${route}`);
+        }
+    });
+}
+//# sourceMappingURL=route-handlers.js.map