@pushchain/core 5.1.4-alpha.7 → 5.1.4-alpha.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushchain/core",
-  "version": "5.1.4-alpha.7",
+  "version": "5.1.4-alpha.9",
   "homepage": "https://push.org",
   "keywords": [
     "pushchain",

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

@@ -263,44 +263,70 @@ function executeUoaToCea(ctx, params, executeFn) {
         let gasFee = BigInt(0);
         let nativeValueForGas = BigInt(0);
         let gasToken = selectors_1.ZERO_ADDRESS;
+        let universalCoreAddress;
         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;
+                universalCoreAddress = result.universalCoreAddress;
                 (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.
+        // 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.
         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
+        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;
+            }
+        }
+        // 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;
-        // Balance-aware adjustment — same logic whether UEA is deployed or not.
-        // The old !isUEADeployed branch blindly used 200 UPC assuming fee-locking
-        // would deposit enough, but the actual deposit depends on origin-chain ETH
-        // locked — not a guaranteed 200 UPC. This caused executeUniversalTx to
-        // revert when UEA balance < 200 UPC. The contract's swapAndBurnGas does
-        // exactOutputSingle and refunds excess PC, so overshooting within balance
-        // is safe.
         let adjustedValue;
         if (currentBalance > EVM_NATIVE_VALUE_TARGET + EVM_GAS_RESERVE) {
-            // Enough balance: use 200 UPC target
-            adjustedValue = EVM_NATIVE_VALUE_TARGET;
+            // Enough balance: cap at 200 UPC (pool estimate may be lower)
+            adjustedValue = nativeValueForGas < EVM_NATIVE_VALUE_TARGET
+                ? nativeValueForGas
+                : EVM_NATIVE_VALUE_TARGET;
         }
         else if (currentBalance > EVM_GAS_RESERVE) {
             // Low balance: use what's available minus reserve
-            adjustedValue = currentBalance - EVM_GAS_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 {
-            // Very low balance: use original query value as-is
+            // 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) {