@pushchain/core 5.1.4-alpha.6 → 5.1.4-alpha.8

package/package.json

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

package/src/lib/orchestrator/internals/cascade.js

@@ -37,16 +37,28 @@ function prepareTransaction(ctx, params, callbacks) {
             clientChain: ctx.universalSigner.account.chain,
         });
         const route = (0, route_detector_1.detectRoute)(params);
-        // Skip getCode if accountStatusCache already confirmed deployment
+        // Push native EOA: block Route 1 — use sendTransaction() for direct Push calls
+        const signerChain = ctx.universalSigner.account.chain;
+        const isPushNativeEOA = (0, helpers_1.isPushChain)(signerChain);
+        if (isPushNativeEOA && route === route_detector_1.TransactionRoute.UOA_TO_PUSH) {
+            throw new Error('Push native accounts cannot use prepareTransaction for Push Chain transactions. ' +
+                'Use sendTransaction() instead for direct Push Chain calls.');
+        }
+        // Fetch UEA nonce (skip for Push native EOA — uses EVM nonce, not UEA contract nonce)
         let nonce;
-        const deployedHintCascade = (_b = (_a = ctx.accountStatusCache) === null || _a === void 0 ? void 0 : _a.uea) === null || _b === void 0 ? void 0 : _b.deployed;
         const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
-        if (deployedHintCascade) {
-            nonce = yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress);
+        if (isPushNativeEOA) {
+            nonce = BigInt(0);
         }
         else {
-            const status = yield (0, uea_manager_1.getUeaStatusAndNonce)(ctx);
-            nonce = status.nonce;
+            const deployedHintCascade = (_b = (_a = ctx.accountStatusCache) === null || _a === void 0 ? void 0 : _a.uea) === null || _b === void 0 ? void 0 : _b.deployed;
+            if (deployedHintCascade) {
+                nonce = yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress);
+            }
+            else {
+                const status = yield (0, uea_manager_1.getUeaStatusAndNonce)(ctx);
+                nonce = status.nonce;
+            }
         }
         // Build the payload based on route
         const { payload, gatewayRequest } = yield (0, route_handlers_1.buildPayloadForRoute)(ctx, params, route, nonce);
@@ -220,8 +232,13 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                     burnAmount = params.value;
                 }
                 else if (params.data) {
+                    // PAYLOAD-only (no value transfer): still need native PRC-20 token for
+                    // chain namespace lookup + gas fees, but burn amount must be zero.
+                    // Matches the direct executeUoaToCea path (route-handlers.ts).
+                    // Using burnAmount=1 would trigger transferFrom on the PRC-20 token,
+                    // which reverts when the UEA has no PRC-20 balance for that chain.
                     prc20Token = (0, helpers_1.getNativePRC20ForChain)(targetChain, ctx.pushNetwork);
-                    burnAmount = BigInt(1); // Minimum for precompile
+                    burnAmount = BigInt(0);
                 }
                 // Query gas fee
                 let gasToken = selectors_1.ZERO_ADDRESS;
@@ -283,10 +300,12 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                         gasToken = result.gasToken;
                         gasFee = result.gasFee;
                     }
-                    return Object.assign(Object.assign({}, baseDescriptor), { sourceChain, ceaAddress: ceaPdaHex, isSvmTarget: true, prc20Token, burnAmount: amount > BigInt(0) ? amount : BigInt(1), gasToken,
+                    return Object.assign(Object.assign({}, baseDescriptor), { sourceChain, ceaAddress: ceaPdaHex, isSvmTarget: true, prc20Token, burnAmount: amount, gasToken,
                         gasFee });
                 }
-                const { cea: ceaAddress, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_h = ctx.rpcUrls[sourceChain]) === null || _h === void 0 ? void 0 : _h[0]);
+                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_h = ctx.rpcUrls[sourceChain]) === null || _h === void 0 ? void 0 : _h[0]);
+                // CEA auto-deploys on-chain: Vault.finalizeUniversalTx calls CEAFactory.deployCEA()
+                // if CEA doesn't exist yet. No SDK-side blocking needed.
                 // Determine token/amount for the inbound
                 let tokenAddress = selectors_1.ZERO_ADDRESS;
                 let amount = BigInt(0);
@@ -319,7 +338,7 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                 }
                 return Object.assign(Object.assign({}, baseDescriptor), { sourceChain,
                     ceaAddress,
-                    prc20Token, burnAmount: amount > BigInt(0) ? amount : BigInt(1), gasToken,
+                    prc20Token, burnAmount: amount, gasToken,
                     gasFee });
             }
             default:
@@ -551,15 +570,15 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                             ? new Uint8Array(Buffer.from(intermediatePayload.slice(2), 'hex'))
                             : undefined,
                     });
-                    const burnAmount = BigInt(1);
+                    const svmBurnAmount = segment.totalBurnAmount || BigInt(0);
                     const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, segment.prc20Token ||
-                        (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), burnAmount, (_g = segment.gasLimit) !== null && _g !== void 0 ? _g : BigInt(0), svmPayload, ueaAddress);
+                        (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), svmBurnAmount, (_g = segment.gasLimit) !== null && _g !== void 0 ? _g : BigInt(0), svmPayload, ueaAddress);
                     const inboundGasFee = segment.gasFee || BigInt(0);
                     const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
                         prc20Token: segment.prc20Token ||
                             (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork),
                         gasToken: segment.gasToken || selectors_1.ZERO_ADDRESS,
-                        burnAmount,
+                        burnAmount: svmBurnAmount,
                         gasFee: inboundGasFee,
                         nativeValueForGas: perOutboundNativeValue !== null && perOutboundNativeValue !== void 0 ? perOutboundNativeValue : inboundGasFee * BigInt(1000),
                         gatewayPcAddress,
@@ -626,13 +645,13 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                 // Wrap CEA multicall in outbound from Push Chain
                 const ceaPayload = (0, payload_builders_1.buildCeaMulticallPayload)(ceaMulticalls);
                 const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, segment.prc20Token ||
-                    (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), segment.totalBurnAmount || BigInt(1), (_j = segment.gasLimit) !== null && _j !== void 0 ? _j : BigInt(0), ceaPayload, ueaAddress);
+                    (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), segment.totalBurnAmount || BigInt(0), (_j = segment.gasLimit) !== null && _j !== void 0 ? _j : BigInt(0), ceaPayload, ueaAddress);
                 const inboundGasFee = segment.gasFee || BigInt(0);
                 const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
                     prc20Token: segment.prc20Token ||
                         (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork),
                     gasToken: segment.gasToken || selectors_1.ZERO_ADDRESS,
-                    burnAmount: segment.totalBurnAmount || BigInt(1),
+                    burnAmount: segment.totalBurnAmount || BigInt(0),
                     gasFee: inboundGasFee,
                     nativeValueForGas: perOutboundNativeValue !== null && perOutboundNativeValue !== void 0 ? perOutboundNativeValue : inboundGasFee * BigInt(1000),
                     gatewayPcAddress,

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

@@ -263,44 +263,56 @@ 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.
+        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, `executeUoaToCea — pool-price estimate: ${estimated.toString()} ` +
+                    `(was ${nativeValueForGas.toString()}), UEA balance: ${ueaBalance.toString()}`);
+                nativeValueForGas = estimated;
+            }
+        }
+        // Balance-aware cap: 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 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;
-        // 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 {
-            // Very low balance: use original query value as-is
+            // Very low/zero balance (fresh wallet). The pool-price estimate (now in
+            // nativeValueForGas) is accurate. Fee-locking will deposit enough UPC
+            // because requiredFunds includes this value, and lockFee floors at $1.
             adjustedValue = nativeValueForGas;
         }
         if (adjustedValue !== nativeValueForGas) {
@@ -576,10 +588,8 @@ function executeCeaToPush(ctx, params, executeFn) {
         // 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.`);
-        }
+        // CEA auto-deploys on-chain: Vault.finalizeUniversalTx calls CEAFactory.deployCEA()
+        // if CEA doesn't exist yet. No SDK-side blocking needed.
         // 5. Get UniversalGateway address on source chain
         const gatewayAddress = chain_1.UNIVERSAL_GATEWAY_ADDRESSES[sourceChain];
         if (!gatewayAddress) {
@@ -1108,6 +1118,8 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                     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]);
+                // 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];
                 if (!gatewayAddr) {
                     throw new Error(`No UniversalGateway address configured for chain ${sourceChain}`);

package/src/lib/universal/account/account.js

@@ -10,6 +10,7 @@ exports.deriveExecutorAccount = deriveExecutorAccount;
 exports.resolveControllerAccount = resolveControllerAccount;
 const tslib_1 = require("tslib");
 const viem_1 = require("viem");
+const web3_js_1 = require("@solana/web3.js");
 const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
 const bs58_1 = require("../../internal/bs58");
@@ -430,6 +431,30 @@ function getChainName(chain) {
     const entry = Object.entries(enums_1.CHAIN).find(([, val]) => val === chain);
     return entry ? entry[0] : chain;
 }
+/**
+ * Derive the SVM CEA (PDA) for a UEA address on a Solana-based chain.
+ *
+ * Solana doesn't use a CEAFactory contract — instead, the CEA is a
+ * Program Derived Address (PDA) with seeds: ["push_identity", ueaBytes]
+ * and the SVM gateway program as the program ID.
+ *
+ * @param ueaAddress - The UEA (or Push EOA) hex address (20 bytes).
+ * @param targetChain - The SVM target chain.
+ * @param skipNetworkCheck - Whether to skip deployment status check.
+ * @returns The derived 32-byte Solana PDA address (as 0x-prefixed hex) and deployment status.
+ */
+function deriveSvmCeaPda(ueaAddress, targetChain, skipNetworkCheck) {
+    const gatewayAddress = chain_1.CHAIN_INFO[targetChain].lockerContract;
+    if (!gatewayAddress) {
+        throw new Error(`SVM gateway program not configured for chain ${targetChain}`);
+    }
+    const gatewayProgramId = new web3_js_1.PublicKey(gatewayAddress);
+    const ueaBytes = Buffer.from(ueaAddress.slice(2), 'hex'); // 20 bytes
+    const [ceaPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('push_identity'), ueaBytes], gatewayProgramId);
+    const ceaPdaHex = ('0x' +
+        Buffer.from(ceaPda.toBytes()).toString('hex'));
+    return { address: ceaPdaHex, deployed: skipNetworkCheck ? null : null };
+}
 /**
  * Derive the executor account (UEA or CEA) for a given account.
  *
@@ -490,6 +515,10 @@ function deriveExecutorAccount(account, options) {
             }
             // If target chain is external, derive CEA from the computed UEA
             if (targetChain && !isPushChain(targetChain)) {
+                // SVM chains use PDA derivation, not CEAFactory
+                if (chain_1.CHAIN_INFO[targetChain].vm === enums_1.VM.SVM) {
+                    return deriveSvmCeaPda(ueaAddress, targetChain, skipNetworkCheck);
+                }
                 const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain);
                 return { address: cea, deployed: skipNetworkCheck ? null : isDeployed };
             }
@@ -512,6 +541,10 @@ function deriveExecutorAccount(account, options) {
         // --- Case 2: Input is on Push Chain ---
         // If target chain is external, derive CEA
         if (targetChain && !isPushChain(targetChain)) {
+            // SVM chains use PDA derivation, not CEAFactory
+            if (chain_1.CHAIN_INFO[targetChain].vm === enums_1.VM.SVM) {
+                return deriveSvmCeaPda(address, targetChain, skipNetworkCheck);
+            }
             const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(address, targetChain);
             return { address: cea, deployed: skipNetworkCheck ? null : isDeployed };
         }