@pushchain/core 5.1.4-alpha.9 → 5.1.5-alpha.0

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

@@ -31,8 +31,11 @@ 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 utils_1 = require("../../utils");
+const price_fetch_1 = require("../../price-fetch/price-fetch");
 const route_detector_1 = require("../route-detector");
 const cea_utils_1 = require("../cea-utils");
+const build_payload_1 = require("../svm-idl/build-payload");
 const payload_builders_1 = require("../payload-builders");
 const selectors_1 = require("../../constants/selectors");
 const erc20_evm_1 = require("../../constants/abi/erc20.evm");
@@ -277,60 +280,48 @@ function executeUoaToCea(ctx, params, executeFn) {
                 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.
-        // This matches the SVM path (executeUoaToCeaSvm) which already uses this.
-        // Excess msg.value is refunded by the contract's swapAndBurnGas.
+        // Balance-aware adjustment: MAXIMIZE nativeValueForGas within available balance.
+        // The contract's swapAndBurnGas does exactOutputSingle and refunds excess PC,
+        // so overshooting within balance is safe. Undershooting causes the swap to revert.
         const EVM_NATIVE_VALUE_TARGET = BigInt(200e18); // 200 UPC
         const EVM_GAS_RESERVE = BigInt(3e18); // 3 UPC for tx overhead
-        if (universalCoreAddress && gasFee > BigInt(0)) {
-            // When UEA balance is 0, pass EVM_NATIVE_VALUE_TARGET as the balance hint
-            // so the pool estimate isn't capped/fallback'd to zero.
-            const balanceHint = ueaBalance > BigInt(0) ? ueaBalance : EVM_NATIVE_VALUE_TARGET;
-            const estimated = yield (0, gas_calculator_1.estimateNativeValueForSwap)(ctx, universalCoreAddress, gasToken, gasFee, balanceHint);
-            if (estimated > nativeValueForGas) {
-                (0, context_1.printLog)(ctx, `executeUoaToCea — pool-price estimate: ${estimated.toString()} ` +
-                    `(was ${nativeValueForGas.toString()}), UEA balance: ${ueaBalance.toString()}`);
-                nativeValueForGas = estimated;
+        const ROUTE2_MINIMUM_DEPOSIT_USD = utils_1.Utils.helpers.parseUnits('10', 8); // $10
+        // Determine effective balance for the adjustment.
+        // For deployed UEAs: use real balance.
+        // For fresh wallets: predict the post-fee-locking balance by querying the same
+        // Uniswap V3 quoter the chain uses (pETH → WPC swap in execute_inbound_gas.go).
+        let effectiveBalance = ueaBalance;
+        if (!isUEADeployed && effectiveBalance <= EVM_GAS_RESERVE) {
+            // Calculate the ETH amount lockFee will send (same formula as lockFee)
+            const ethPrice = yield new price_fetch_1.PriceFetch(ctx.rpcUrls).getPrice(signerChain);
+            const nativeAmountETH = ethPrice > BigInt(0)
+                ? (ROUTE2_MINIMUM_DEPOSIT_USD * BigInt(1e18) + (ethPrice - BigInt(1))) / ethPrice + BigInt(1)
+                : BigInt(0);
+            if (nativeAmountETH > BigInt(0)) {
+                // Query the real swap quote: how much WPC (UPC) for this pETH amount?
+                const originPrc20 = (0, helpers_1.getNativePRC20ForChain)(signerChain, ctx.pushNetwork);
+                const predictedUPC = yield (0, gas_calculator_1.estimateDepositFromLockedNative)(ctx, nativeAmountETH, originPrc20);
+                if (predictedUPC > BigInt(0)) {
+                    // 10% safety margin for slippage between quote and actual execution
+                    effectiveBalance = (predictedUPC * BigInt(90)) / BigInt(100);
+                    (0, context_1.printLog)(ctx, `executeUoaToCea — fresh wallet: Uniswap quote predicts ${predictedUPC.toString()} UPC ` +
+                        `from ${nativeAmountETH.toString()} wei pETH, using ${effectiveBalance.toString()} (90%)`);
+                }
             }
         }
-        // Balance-aware adjustment: avoid draining the entire UEA balance for gas.
-        // The contract's swapAndBurnGas does exactOutputSingle and refunds excess PC,
-        // so overshooting within balance is safe.
-        const currentBalance = ueaBalance;
         let adjustedValue;
-        if (currentBalance > EVM_NATIVE_VALUE_TARGET + EVM_GAS_RESERVE) {
-            // Enough balance: cap at 200 UPC (pool estimate may be lower)
-            adjustedValue = nativeValueForGas < EVM_NATIVE_VALUE_TARGET
-                ? nativeValueForGas
-                : EVM_NATIVE_VALUE_TARGET;
+        if (effectiveBalance > EVM_NATIVE_VALUE_TARGET + EVM_GAS_RESERVE) {
+            adjustedValue = EVM_NATIVE_VALUE_TARGET;
         }
-        else if (currentBalance > EVM_GAS_RESERVE) {
-            // Low balance: use what's available minus reserve
-            const available = currentBalance - EVM_GAS_RESERVE;
-            adjustedValue = nativeValueForGas < available ? nativeValueForGas : available;
-        }
-        else if (!isUEADeployed) {
-            // Fresh wallet: UEA not deployed, fee-locking WILL run and deposit funds.
-            // Use EVM_NATIVE_VALUE_TARGET (200 UPC) — fee-locking auto-covers this
-            // because requiredFunds includes nativeValueForGas, and lockFee converts
-            // the UPC amount to USD and deposits the equivalent ETH.
-            // The contract's swapAndBurnGas refunds any excess.
-            // If pool estimate produced a usable value, prefer it (capped at 200 UPC).
-            adjustedValue = nativeValueForGas > EVM_NATIVE_VALUE_TARGET
-                ? EVM_NATIVE_VALUE_TARGET
-                : nativeValueForGas > BigInt(0) ? nativeValueForGas : EVM_NATIVE_VALUE_TARGET;
-            (0, context_1.printLog)(ctx, `executeUoaToCea — fresh wallet (UEA not deployed): using ${adjustedValue.toString()} for nativeValueForGas`);
+        else if (effectiveBalance > EVM_GAS_RESERVE) {
+            adjustedValue = effectiveBalance - EVM_GAS_RESERVE;
         }
         else {
-            // Deployed UEA with near-zero balance: best-effort with pool/1M estimate.
-            // User may need to add funds to UEA manually.
             adjustedValue = nativeValueForGas;
         }
         if (adjustedValue !== nativeValueForGas) {
-            (0, context_1.printLog)(ctx, `executeUoaToCea — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (UEA balance: ${currentBalance.toString()})`);
+            (0, context_1.printLog)(ctx, `executeUoaToCea — adjusting nativeValueForGas from ${nativeValueForGas.toString()} ` +
+                `to ${adjustedValue.toString()} (effective balance: ${effectiveBalance.toString()})`);
             nativeValueForGas = adjustedValue;
         }
         // Build outbound multicalls (approve burn + sendUniversalTxOutbound with native value)
@@ -374,17 +365,11 @@ function executeUoaToCea(ctx, params, executeFn) {
         // 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: {
+        const executeParams = Object.assign({ to: ueaAddress, value: multicallNativeValue, data: pushChainMulticalls, _ueaStatus: {
                 isDeployed: isUEADeployed,
                 nonce: ueaNonce,
                 balance: ueaBalance,
-            },
-            _skipFeeLocking: isUEADeployed, // skip fee-locking only if UEA is already deployed
-        };
+            }, _skipFeeLocking: isUEADeployed }, (!isUEADeployed ? { _minimumDepositUsd: ROUTE2_MINIMUM_DEPOSIT_USD } : {}));
         const response = yield executeFn(executeParams);
         // Add chain info to response
         response.chain = targetChain;
@@ -409,22 +394,15 @@ function executeUoaToCeaSvm(ctx, params, target, executeFn) {
         const targetChain = target.chain;
         const targetAddress = target.address; // 0x-prefixed, 32 bytes
         const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
-        const hasSvmExecute = !!params.svmExecute;
+        const { svmPayload, targetBytes, hasExecute: hasSvmExecute, } = (0, build_payload_1.buildSvmPayloadFromParams)({
+            data: params.data,
+            to: target,
+            senderUea: ueaAddress,
+        });
         (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`);
+            (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — encoded execute payload: ${(svmPayload.length - 2) / 2} bytes`);
         }
         // --- Determine PRC-20 token and burn amount ---
         let prc20Token = selectors_1.ZERO_ADDRESS;
@@ -455,13 +433,8 @@ function executeUoaToCeaSvm(ctx, params, target, executeFn) {
             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 ---
+        // targetBytes: for execute = program id (resolver output); for withdraw = to.address
         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({
@@ -581,7 +554,7 @@ function executeUoaToCeaSvm(ctx, params, target, executeFn) {
  */
 function executeCeaToPush(ctx, params, executeFn) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f;
         // 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');
@@ -716,27 +689,24 @@ function executeCeaToPush(ctx, params, executeFn) {
         // 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;
+        // 8. Determine PRC-20 token for the outbound relay.
+        // Route 3: ALWAYS use native PRC-20 for chain namespace lookup + gas fees.
+        // The CEA uses its OWN pre-existing balance on the external chain to bridge
+        // tokens back — no PRC-20 burn is needed on Push Chain.
+        // burnAmount = 0 makes this a payload-only outbound relay.
+        //
+        // Previously this burned pUSDT/pToken equal to the bridge amount, which failed
+        // because the UEA never holds pUSDT — the whole point of Route 3 is to get
+        // tokens FROM the CEA back to Push Chain, not to round-trip them.
+        const prc20Token = (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork);
+        const burnAmount = BigInt(0);
         (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
+        burnAmount, // amount: 0 (payload-only, CEA uses its own balance)
+        (_f = params.gasLimit) !== null && _f !== void 0 ? _f : BigInt(0), ceaPayload, // payload: ABI-encoded CEA multicall
         ueaAddress // revertRecipient: UEA
         );
         (0, context_1.printLog)(ctx, `executeCeaToPush — outbound request: ${JSON.stringify({
@@ -773,9 +743,43 @@ function executeCeaToPush(ctx, params, executeFn) {
         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()})`);
+        const ROUTE3_MINIMUM_DEPOSIT_USD = utils_1.Utils.helpers.parseUnits('10', 8); // $10
+        // For fresh wallets: predict post-fee-locking UPC balance using the same
+        // Uniswap V3 quoter the chain uses (pETH → WPC swap), matching Route 2 logic.
+        let effectiveBalance = currentBalance;
+        if (!isUEADeployed && effectiveBalance <= OUTBOUND_GAS_RESERVE_R3) {
+            const signerChain = ctx.universalSigner.account.chain;
+            const ethPrice = yield new price_fetch_1.PriceFetch(ctx.rpcUrls).getPrice(signerChain);
+            const nativeAmountETH = ethPrice > BigInt(0)
+                ? (ROUTE3_MINIMUM_DEPOSIT_USD * BigInt(1e18) + (ethPrice - BigInt(1))) / ethPrice + BigInt(1)
+                : BigInt(0);
+            if (nativeAmountETH > BigInt(0)) {
+                const originPrc20 = (0, helpers_1.getNativePRC20ForChain)(signerChain, ctx.pushNetwork);
+                const predictedUPC = yield (0, gas_calculator_1.estimateDepositFromLockedNative)(ctx, nativeAmountETH, originPrc20);
+                if (predictedUPC > BigInt(0)) {
+                    effectiveBalance = (predictedUPC * BigInt(90)) / BigInt(100);
+                    (0, context_1.printLog)(ctx, `executeCeaToPush — fresh wallet: Uniswap quote predicts ${predictedUPC.toString()} UPC ` +
+                        `from ${nativeAmountETH.toString()} wei pETH, using ${effectiveBalance.toString()} (90%)`);
+                }
+            }
+        }
+        // Balance-aware adjustment matching Route 2 logic:
+        // - If balance exceeds target + reserve: use target (200 UPC)
+        // - If balance exceeds reserve: use balance - reserve (maximize within budget)
+        // - Otherwise: keep original nativeValueForGas (fallback)
+        const EVM_NATIVE_VALUE_TARGET_R3 = BigInt(200e18); // 200 UPC
+        let adjustedValue;
+        if (effectiveBalance > EVM_NATIVE_VALUE_TARGET_R3 + OUTBOUND_GAS_RESERVE_R3) {
+            adjustedValue = EVM_NATIVE_VALUE_TARGET_R3;
+        }
+        else if (effectiveBalance > OUTBOUND_GAS_RESERVE_R3) {
+            adjustedValue = effectiveBalance - OUTBOUND_GAS_RESERVE_R3;
+        }
+        else {
+            adjustedValue = nativeValueForGas;
+        }
+        if (adjustedValue !== nativeValueForGas) {
+            (0, context_1.printLog)(ctx, `executeCeaToPush — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (effective balance: ${effectiveBalance.toString()})`);
             nativeValueForGas = adjustedValue;
         }
         // 12. Build Push Chain multicalls (approvals + sendUniversalTxOutbound)
@@ -792,17 +796,11 @@ function executeCeaToPush(ctx, params, executeFn) {
         // 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: {
+        const executeParams = Object.assign({ to: ueaAddress, value: multicallNativeValue, data: pushChainMulticalls, _ueaStatus: {
                 isDeployed: isUEADeployed,
                 nonce: ueaNonce,
                 balance: ueaBalance,
-            },
-            _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
-        };
+            }, _skipFeeLocking: isUEADeployed }, (!isUEADeployed ? { _minimumDepositUsd: ROUTE3_MINIMUM_DEPOSIT_USD } : {}));
         const response = yield executeFn(executeParams);
         // Add Route 3 context to response
         response.chain = sourceChain;
@@ -840,7 +838,6 @@ function executeCeaToPushSvm(ctx, params, sourceChain, executeFn) {
         // 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;
@@ -849,22 +846,15 @@ function executeCeaToPushSvm(ctx, params, sourceChain, executeFn) {
                 // 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);
         }
+        // Route 3 SVM: ALWAYS use native PRC-20 for chain namespace lookup + gas fees.
+        // CEA uses its own pre-existing balance — no PRC-20 burn needed on Push Chain.
+        const 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;
@@ -936,17 +926,11 @@ function executeCeaToPushSvm(ctx, params, sourceChain, executeFn) {
         // 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: {
+        const executeParams = Object.assign({ to: ueaAddress, value: multicallNativeValue, data: pushChainMulticalls, _ueaStatus: {
                 isDeployed: isUEADeployed,
                 nonce: ueaNonce,
                 balance: ueaBalance,
-            },
-            _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
-        };
+            }, _skipFeeLocking: isUEADeployed }, (!isUEADeployed ? { _minimumDepositUsd: utils_1.Utils.helpers.parseUnits('10', 8) } : {}));
         const response = yield executeFn(executeParams);
         // Add Route 3 SVM context to response
         response.chain = sourceChain;
@@ -977,7 +961,7 @@ function executeCeaToCea(ctx, params, executeFn) {
  */
 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;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
         switch (route) {
             case route_detector_1.TransactionRoute.UOA_TO_PUSH: {
@@ -1000,20 +984,15 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                 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;
+                    // SVM: build SVM payload (binary or empty for withdraw) via IDL resolver
+                    const { svmPayload: payload, targetBytes, hasExecute, } = (0, build_payload_1.buildSvmPayloadFromParams)({
+                        data: params.data,
+                        to: target,
+                        senderUea: ueaAddress,
+                    });
                     let prc20Token = selectors_1.ZERO_ADDRESS;
                     let burnAmount = BigInt(0);
-                    if ((_c = params.funds) === null || _c === void 0 ? void 0 : _c.amount) {
+                    if ((_a = params.funds) === null || _a === void 0 ? void 0 : _a.amount) {
                         const token = params.funds.token;
                         if (token) {
                             prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
@@ -1024,15 +1003,15 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                         prc20Token = (0, helpers_1.getNativePRC20ForChain)(target.chain, ctx.pushNetwork);
                         burnAmount = params.value;
                     }
-                    else if (params.svmExecute) {
+                    else if (hasExecute) {
                         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);
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_b = params.gasLimit) !== null && _b !== void 0 ? _b : 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]);
+                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, target.chain, (_c = ctx.rpcUrls[target.chain]) === null || _c === void 0 ? void 0 : _c[0]);
                 // Build CEA outbound payload
                 const multicalls = [];
                 if (params.data) {
@@ -1065,7 +1044,7 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                 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) {
+                if ((_d = params.funds) === null || _d === void 0 ? void 0 : _d.amount) {
                     const token = params.funds.token;
                     if (token) {
                         prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
@@ -1073,13 +1052,13 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                     }
                 }
                 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);
+                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_e = params.gasLimit) !== null && _e !== void 0 ? _e : 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)) {
+                if (!((_f = params.from) === null || _f === void 0 ? void 0 : _f.chain)) {
                     throw new Error('Route 3 (CEA -> Push) requires from.chain');
                 }
                 const sourceChain = params.from.chain;
@@ -1094,28 +1073,19 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                     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)) {
+                    if (((_g = params.funds) === null || _g === void 0 ? void 0 : _g.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);
                     }
+                    // Route 3 SVM: ALWAYS use native PRC-20, CEA uses its own balance.
+                    const 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);
@@ -1128,10 +1098,10 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                     });
                     // 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);
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, prc20Token, burnAmount, (_h = params.gasLimit) !== null && _h !== void 0 ? _h : 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 { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_j = ctx.rpcUrls[sourceChain]) === null || _j === void 0 ? void 0 : _j[0]);
                 // CEA auto-deploys on-chain: Vault.finalizeUniversalTx calls CEAFactory.deployCEA()
                 // if CEA doesn't exist yet. No SDK-side blocking needed.
                 const gatewayAddr = chain_1.UNIVERSAL_GATEWAY_ADDRESSES[sourceChain];
@@ -1142,7 +1112,7 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                 const ceaMulticalls = [];
                 let tokenAddress = selectors_1.ZERO_ADDRESS;
                 let amount = BigInt(0);
-                if ((_m = params.funds) === null || _m === void 0 ? void 0 : _m.amount) {
+                if ((_k = params.funds) === null || _k === void 0 ? void 0 : _k.amount) {
                     const token = params.funds.token;
                     if (token) {
                         if (token.mechanism === 'native') {
@@ -1203,10 +1173,10 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                 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);
+                // Route 3: CEA uses its own pre-existing balance — no PRC-20 burn needed.
+                // burnAmount = 0 makes this a payload-only outbound relay.
+                const burnAmount = BigInt(0);
+                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, prc20Token, burnAmount, (_l = params.gasLimit) !== null && _l !== void 0 ? _l : BigInt(0), ceaPayload, ueaAddress);
                 return { payload: ceaPayload, gatewayRequest: outboundReq };
             }
             default:

package/src/lib/orchestrator/orchestrator.types.d.ts

@@ -106,6 +106,14 @@ export type ExecuteParams = {
      * @internal
      */
     _skipFeeLocking?: boolean;
+    /**
+     * Internal: Minimum fee-locking deposit in USD (8 decimals).
+     * Overrides the default $1 floor when the caller needs a larger deposit
+     * (e.g., Route 2 needs enough UPC for the outbound swap).
+     * Still capped at $1000 by lockFee.
+     * @internal
+     */
+    _minimumDepositUsd?: bigint;
 };
 /**
  * New Universal Transaction Receipt interface with prioritized field ordering
@@ -283,16 +291,9 @@ export type UniversalExecuteParams = Omit<ExecuteParams, 'to'> & {
      * - ChainTarget: External chain target (Routes 2, 3, 4)
      */
     to: UniversalTo;
-    /**
-     * SVM-specific: CPI execution parameters for Solana targets (Route 2).
-     * When present, the outbound transaction will execute a Cross-Program Invocation
-     * on the specified Solana program with the given accounts and instruction data.
-     * Only applicable when `to.chain` is a Solana chain.
-     */
-    svmExecute?: SvmExecuteParams;
     /**
      * When true, sends MIGRATION_SELECTOR as raw CEA payload (no multicall wrapping).
-     * Used for CEA contract upgrades. Incompatible with value/funds/data/svmExecute.
+     * Used for CEA contract upgrades. Incompatible with value/funds/data.
      * Only applicable for Route 2 (UOA_TO_CEA) on EVM chains.
      */
     migration?: boolean;
@@ -321,18 +322,6 @@ export interface SvmExecutePayloadFields {
     /** Instruction ID: 2 = execute (default) */
     instructionId?: number;
 }
-/**
- * User-facing parameters for CPI execution on a Solana program via Route 2.
- * Passed as `svmExecute` in UniversalExecuteParams when targeting SVM chains.
- */
-export interface SvmExecuteParams {
-    /** Target Solana program to CPI into (32 bytes, 0x-prefixed hex) */
-    targetProgram: `0x${string}`;
-    /** Accounts required for the CPI call */
-    accounts: SvmGatewayAccountMeta[];
-    /** Raw instruction data for the target program */
-    ixData: Uint8Array;
-}
 /**
  * Request structure for sendUniversalTxOutbound on Push Chain
  * Used for Routes 2, 3, 4 (outbound from Push)

package/src/lib/orchestrator/route-detector.js

@@ -249,9 +249,6 @@ function validateRouteParams(params, context) {
         if (params.data) {
             throw new RouteValidationError('migration is incompatible with data');
         }
-        if (params.svmExecute) {
-            throw new RouteValidationError('migration is incompatible with svmExecute');
-        }
         if (isChainTarget(params.to) && (0, payload_builders_1.isSvmChain)(params.to.chain)) {
             throw new RouteValidationError('migration is not supported on SVM chains');
         }

package/src/lib/orchestrator/svm-idl/build-payload.d.ts

@@ -0,0 +1,11 @@
+import type { ChainTarget } from '../orchestrator.types';
+export interface SvmPayloadBundle {
+    svmPayload: `0x${string}`;
+    targetBytes: `0x${string}`;
+    hasExecute: boolean;
+}
+export declare function buildSvmPayloadFromParams(params: {
+    data?: `0x${string}` | unknown;
+    to: ChainTarget;
+    senderUea: `0x${string}`;
+}): SvmPayloadBundle;

package/src/lib/orchestrator/svm-idl/build-payload.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSvmPayloadFromParams = buildSvmPayloadFromParams;
+const viem_1 = require("viem");
+const payload_builders_1 = require("../payload-builders");
+const resolve_1 = require("./resolve");
+function buildSvmPayloadFromParams(params) {
+    const hasExecute = typeof params.data === 'string' &&
+        params.data.startsWith('0x') &&
+        params.data.length > 2;
+    if (!hasExecute) {
+        return {
+            svmPayload: '0x',
+            targetBytes: params.to.address,
+            hasExecute: false,
+        };
+    }
+    const resolved = (0, resolve_1.resolveSvmCall)({
+        programAddress: params.to.address,
+        data: (0, viem_1.hexToBytes)(params.data),
+        senderUea: params.senderUea,
+        targetChain: params.to.chain,
+    });
+    const svmPayload = (0, payload_builders_1.encodeSvmExecutePayload)({
+        targetProgram: resolved.targetProgram,
+        accounts: resolved.accounts,
+        ixData: resolved.ixData,
+        instructionId: 2,
+    });
+    return {
+        svmPayload,
+        targetBytes: resolved.targetProgram,
+        hasExecute: true,
+    };
+}
+//# sourceMappingURL=build-payload.js.map

package/src/lib/orchestrator/svm-idl/ix-encoder.d.ts

@@ -0,0 +1,3 @@
+import { type Idl } from '@coral-xyz/anchor';
+export declare function encodeAnchorIxData(idl: Idl, functionName: string, positionalArgs?: unknown[]): Uint8Array;
+export declare function isAnchorIdl(value: unknown): value is Idl;