@pushchain/core 5.1.4-alpha.1 → 5.1.4-alpha.3

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

@@ -255,11 +255,7 @@ function executeUoaToCea(ctx, params, executeFn) {
             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);
+        const ueaNonce = (!isUEADeployed || 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 = [];
@@ -288,7 +284,11 @@ function executeUoaToCea(ctx, params, executeFn) {
         // 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) {
+        if (!isUEADeployed) {
+            // UEA not yet deployed — fee-locking will deposit funds; use target value, excess is refunded
+            adjustedValue = nativeValueForGas > BigInt(0) ? EVM_NATIVE_VALUE_TARGET : nativeValueForGas;
+        }
+        else if (currentBalance > EVM_NATIVE_VALUE_TARGET + EVM_GAS_RESERVE) {
             // Enough balance: use 200 UPC target
             adjustedValue = EVM_NATIVE_VALUE_TARGET;
         }
@@ -354,7 +354,7 @@ function executeUoaToCea(ctx, params, executeFn) {
                 nonce: ueaNonce,
                 balance: ueaBalance,
             },
-            _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+            _skipFeeLocking: isUEADeployed, // skip fee-locking only if UEA is already deployed
         };
         const response = yield executeFn(executeParams);
         // Add chain info to response
@@ -463,11 +463,7 @@ function executeUoaToCeaSvm(ctx, params, target, executeFn) {
             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);
+        const ueaNonce = (!isUEADeployed || 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;
@@ -531,7 +527,7 @@ function executeUoaToCeaSvm(ctx, params, target, executeFn) {
                 nonce: ueaNonce,
                 balance: ueaBalance,
             },
-            _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+            _skipFeeLocking: isUEADeployed, // skip fee-locking only if UEA is already deployed
         };
         const response = yield executeFn(executeParams);
         // Add chain info to response
@@ -617,7 +613,7 @@ function executeCeaToPush(ctx, params, executeFn) {
         // 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;
+        const 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

package/src/lib/orchestrator/orchestrator.js

@@ -129,7 +129,7 @@ class Orchestrator {
      */
     execute(params) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d;
             // Lazy UEA upgrade check
             try {
                 if (!this.accountStatusCache || !this.accountStatusCache.uea.loaded) {
@@ -166,16 +166,6 @@ class Orchestrator {
             try {
                 const rcb = () => this._getResponseCallbacks();
                 if (execute.funds) {
-                    const hasData = execute.data && execute.data !== '0x';
-                    const isSVM = ((_e = chain_1.CHAIN_INFO[this.ctx.universalSigner.account.chain]) === null || _e === void 0 ? void 0 : _e.vm) === enums_1.VM.SVM;
-                    // SVM two-phase: bridge funds first, then execute payload separately
-                    // (Push Chain node doesn't support FUNDS_AND_PAYLOAD payload decoding for SVM yet)
-                    if (hasData && isSVM) {
-                        const fundsOnly = Object.assign(Object.assign({}, execute), { data: undefined });
-                        yield (0, internals_1.executeFundsOnly)(this.ctx, fundsOnly, eventBuffer, rcb);
-                        const dataOnly = Object.assign(Object.assign({}, execute), { funds: undefined });
-                        return yield (0, internals_1.executeStandardPayload)(this.ctx, dataOnly, eventBuffer, rcb);
-                    }
                     return !hasData
                         ? yield (0, internals_1.executeFundsOnly)(this.ctx, execute, eventBuffer, rcb)
                         : yield (0, internals_1.executeFundsWithPayload)(this.ctx, execute, eventBuffer, rcb);

package/src/lib/push-chain/push-chain.js

@@ -400,6 +400,7 @@ class PushChain {
             // Stored on instance so consumers can await it if needed: await client.accountStatusReady
             const ACCOUNT_STATUS_TIMEOUT = 30000;
             instance.accountStatusReady = Promise.race([
+                // eslint-disable-next-line @typescript-eslint/no-empty-function
                 instance.getAccountStatus().then(() => { }),
                 new Promise((_, reject) => setTimeout(() => reject(new Error('Account status fetch timed out')), ACCOUNT_STATUS_TIMEOUT)),
             ]).catch(() => {

package/src/lib/universal/account/account.d.ts

@@ -69,29 +69,37 @@ export declare function convertExecutorToOrigin(executorAddress: string, options
     _internal?: boolean;
 }): Promise<OriginAccountInfo>;
 /**
- * Derive the executor account (UEA or CEA) for a given origin account.
+ * Derive the executor account (UEA or CEA) for a given account.
  *
- * @param account - CAIP-10 formatted address string (e.g., "eip155:11155111:0xABC...")
- * @param options.chain - Target chain for CEA derivation. If omitted, derives UEA on Push Chain.
+ * - If account is on an external chain (Ethereum, Solana, etc.):
+ *   Computes the UEA on Push Chain via the factory contract's computeUEA.
+ *   If options.chain is an external chain, further derives the CEA on that chain.
+ *
+ * - If account is on Push Chain:
+ *   Returns the address as-is (it's already a UEA or Push EOA).
+ *   If options.chain is an external chain, derives the CEA on that chain.
+ *
+ * @param account - UniversalAccount with chain and address.
+ * @param options.chain - Target external chain for CEA derivation. If omitted, returns UEA.
  * @param options.skipNetworkCheck - If true, skip deployment check and return deployed: false.
  * @returns The derived executor account address and deployment status.
  */
-export declare function deriveExecutorAccount(account: string, options?: {
+export declare function deriveExecutorAccount(account: UniversalAccount, options?: {
     chain?: CHAIN;
     skipNetworkCheck?: boolean;
 }): Promise<DerivedExecutorAccount>;
 /**
  * Resolve the controller (origin) accounts for a given executor address.
  *
- * Given a UEA or CEA address (as CAIP-10), resolves the full controller chain
+ * Given a UEA or CEA plain address, resolves the full controller chain
  * back to the origin account.
  *
- * @param account - CAIP-10 formatted address string of the executor account
- * @param options.chain - Supplementary chain context (chain info is in CAIP-10)
+ * @param address - Plain address string of the executor account (e.g., "0xABC...")
+ * @param options.chain - Chain context. If external chain, address is treated as CEA on that chain. If omitted or Push chain, address is treated as UEA on Push Chain.
  * @param options.skipNetworkCheck - If true, skip existence checks, set exists: false
  * @returns Resolved accounts in the controller chain
  */
-export declare function resolveControllerAccount(account: string, options?: {
+export declare function resolveControllerAccount(address: string, options?: {
     chain?: CHAIN;
     skipNetworkCheck?: boolean;
 }): Promise<ResolvedControllerAccounts>;

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

@@ -431,120 +431,129 @@ function getChainName(chain) {
     return entry ? entry[0] : chain;
 }
 /**
- * Derive the executor account (UEA or CEA) for a given origin account.
+ * Derive the executor account (UEA or CEA) for a given account.
  *
- * @param account - CAIP-10 formatted address string (e.g., "eip155:11155111:0xABC...")
- * @param options.chain - Target chain for CEA derivation. If omitted, derives UEA on Push Chain.
+ * - If account is on an external chain (Ethereum, Solana, etc.):
+ *   Computes the UEA on Push Chain via the factory contract's computeUEA.
+ *   If options.chain is an external chain, further derives the CEA on that chain.
+ *
+ * - If account is on Push Chain:
+ *   Returns the address as-is (it's already a UEA or Push EOA).
+ *   If options.chain is an external chain, derives the CEA on that chain.
+ *
+ * @param account - UniversalAccount with chain and address.
+ * @param options.chain - Target external chain for CEA derivation. If omitted, returns UEA.
  * @param options.skipNetworkCheck - If true, skip deployment check and return deployed: false.
  * @returns The derived executor account address and deployment status.
  */
 function deriveExecutorAccount(account, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         var _a;
-        const { chain: originChain, address } = fromChainAgnostic(account);
         const skipNetworkCheck = (_a = options === null || options === void 0 ? void 0 : options.skipNetworkCheck) !== null && _a !== void 0 ? _a : false;
         const targetChain = options === null || options === void 0 ? void 0 : options.chain;
-        // If target chain is external, derive CEA on that chain
-        if (targetChain && !isPushChain(targetChain)) {
-            // First get the UEA on Push Chain
+        const { chain, address } = account;
+        // --- Case 1: Input is on an external chain ---
+        if (!isPushChain(chain)) {
+            const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+            const pushNetwork = getPushNetworkFromChain(chain);
+            // Check cache for previously computed UEA
+            const cachedUea = accountCache.get(cache_1.CacheKeys.ueaAddressOnchain(chain, address, pushNetwork, vm));
             let ueaAddress;
-            if (isPushChain(originChain)) {
-                ueaAddress = address;
+            if (cachedUea) {
+                ueaAddress = cachedUea;
             }
             else {
-                const ueaResult = yield deriveExecutorAccount(account);
-                ueaAddress = ueaResult.address;
+                // Compute UEA via factory contract
+                const pushChainKey = pushNetworkToChainKey(pushNetwork);
+                const pushClient = new push_client_1.PushClient({
+                    rpcUrls: chain_1.CHAIN_INFO[pushChainKey].defaultRPC,
+                    network: pushNetwork,
+                });
+                ueaAddress = yield pushClient.readContract({
+                    address: pushClient.pushChainInfo.factoryAddress,
+                    abi: factoryV1_1.FACTORY_V1,
+                    functionName: 'computeUEA',
+                    args: [
+                        {
+                            chainNamespace: chain_1.VM_NAMESPACE[vm],
+                            chainId: chainId,
+                            owner: vm === enums_1.VM.EVM
+                                ? address
+                                : vm === enums_1.VM.SVM
+                                    ? (0, viem_1.bytesToHex)(Uint8Array.from(bs58_1.bs58.decode(address)))
+                                    : address,
+                        },
+                    ],
+                });
+                // Cache the computed address
+                accountCache.set(cache_1.CacheKeys.ueaAddressOnchain(chain, address, pushNetwork, vm), ueaAddress);
             }
-            // Get CEA on the target external chain
-            const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain);
-            return { address: cea, deployed: skipNetworkCheck ? false : isDeployed };
-        }
-        // If origin is Push chain, return the address directly
-        if (isPushChain(originChain)) {
+            // If target chain is external, derive CEA from the computed UEA
+            if (targetChain && !isPushChain(targetChain)) {
+                const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain);
+                return { address: cea, deployed: skipNetworkCheck ? false : isDeployed };
+            }
+            // Return UEA with deployment check
             if (skipNetworkCheck) {
-                return { address: address, deployed: false };
+                return { address: ueaAddress, deployed: false };
             }
-            const pushNetwork = getPushNetworkFromChain(originChain);
             const pushChainKey = pushNetworkToChainKey(pushNetwork);
             const pushClient = new push_client_1.PushClient({
                 rpcUrls: chain_1.CHAIN_INFO[pushChainKey].defaultRPC,
                 network: pushNetwork,
             });
             const byteCode = yield pushClient.publicClient.getCode({
-                address: address,
+                address: ueaAddress,
             });
-            return { address: address, deployed: byteCode !== undefined };
+            const isDeployed = byteCode !== undefined;
+            accountCache.set(cache_1.CacheKeys.deploymentStatus(ueaAddress), isDeployed);
+            return { address: ueaAddress, deployed: isDeployed };
         }
-        // Origin is external chain → compute UEA on Push Chain
-        const { vm, chainId } = chain_1.CHAIN_INFO[originChain];
-        const pushNetwork = getPushNetworkFromChain(originChain);
-        // Check cache
-        const cachedAddress = accountCache.get(cache_1.CacheKeys.ueaAddressOnchain(originChain, address, pushNetwork, vm));
-        if (cachedAddress) {
-            if (skipNetworkCheck) {
-                return { address: cachedAddress, deployed: false };
-            }
-            const cachedDeploymentStatus = accountCache.get(cache_1.CacheKeys.deploymentStatus(cachedAddress));
-            if (cachedDeploymentStatus !== null) {
-                return {
-                    address: cachedAddress,
-                    deployed: cachedDeploymentStatus,
-                };
-            }
+        // --- Case 2: Input is on Push Chain ---
+        // If target chain is external, derive CEA
+        if (targetChain && !isPushChain(targetChain)) {
+            const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(address, targetChain);
+            return { address: cea, deployed: skipNetworkCheck ? false : isDeployed };
         }
+        // Push address, no external target — return with deployment check
+        if (skipNetworkCheck) {
+            return { address: address, deployed: false };
+        }
+        const pushNetwork = targetChain && isPushChain(targetChain)
+            ? getPushNetworkFromChain(targetChain)
+            : getPushNetworkFromChain(chain);
         const pushChainKey = pushNetworkToChainKey(pushNetwork);
         const pushClient = new push_client_1.PushClient({
             rpcUrls: chain_1.CHAIN_INFO[pushChainKey].defaultRPC,
             network: pushNetwork,
         });
-        const computedAddress = yield pushClient.readContract({
-            address: pushClient.pushChainInfo.factoryAddress,
-            abi: factoryV1_1.FACTORY_V1,
-            functionName: 'computeUEA',
-            args: [
-                {
-                    chainNamespace: chain_1.VM_NAMESPACE[vm],
-                    chainId: chainId,
-                    owner: vm === enums_1.VM.EVM
-                        ? address
-                        : vm === enums_1.VM.SVM
-                            ? (0, viem_1.bytesToHex)(Uint8Array.from(bs58_1.bs58.decode(address)))
-                            : address,
-                },
-            ],
-        });
-        // Cache the computed address
-        accountCache.set(cache_1.CacheKeys.ueaAddressOnchain(originChain, address, pushNetwork, vm), computedAddress);
-        if (skipNetworkCheck) {
-            return { address: computedAddress, deployed: false };
-        }
         const byteCode = yield pushClient.publicClient.getCode({
-            address: computedAddress,
+            address: address,
         });
-        const isDeployed = byteCode !== undefined;
-        // Cache the deployment status
-        accountCache.set(cache_1.CacheKeys.deploymentStatus(computedAddress), isDeployed);
-        return { address: computedAddress, deployed: isDeployed };
+        return {
+            address: address,
+            deployed: byteCode !== undefined,
+        };
     });
 }
 /**
  * Resolve the controller (origin) accounts for a given executor address.
  *
- * Given a UEA or CEA address (as CAIP-10), resolves the full controller chain
+ * Given a UEA or CEA plain address, resolves the full controller chain
  * back to the origin account.
  *
- * @param account - CAIP-10 formatted address string of the executor account
- * @param options.chain - Supplementary chain context (chain info is in CAIP-10)
+ * @param address - Plain address string of the executor account (e.g., "0xABC...")
+ * @param options.chain - Chain context. If external chain, address is treated as CEA on that chain. If omitted or Push chain, address is treated as UEA on Push Chain.
  * @param options.skipNetworkCheck - If true, skip existence checks, set exists: false
  * @returns Resolved accounts in the controller chain
  */
-function resolveControllerAccount(account, options) {
+function resolveControllerAccount(address, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         var _a;
-        const { chain: inputChain, address } = fromChainAgnostic(account);
+        const inputChain = options === null || options === void 0 ? void 0 : options.chain;
         const skipNetworkCheck = (_a = options === null || options === void 0 ? void 0 : options.skipNetworkCheck) !== null && _a !== void 0 ? _a : false;
-        // Case A: Input is on an external chain (CEA)
-        if (!isPushChain(inputChain)) {
+        // Case A: External chain → address is a CEA on that chain
+        if (inputChain && !isPushChain(inputChain)) {
             // Look up UEA on Push Chain from CEA
             const pushAccountAddress = yield (0, cea_utils_1.getPushAccountForCEA)(address, inputChain);
             if (pushAccountAddress === '0x0000000000000000000000000000000000000000') {
@@ -597,9 +606,12 @@ function resolveControllerAccount(account, options) {
             }
             return { accounts };
         }
-        // Case B: Input is on Push Chain (UEA or EOA)
-        const pushNetwork = getPushNetworkFromChain(inputChain);
+        // Case B: No chain or Push chain → address is a UEA or EOA on Push Chain
+        const pushNetwork = inputChain && isPushChain(inputChain)
+            ? getPushNetworkFromChain(inputChain)
+            : enums_1.PUSH_NETWORK.TESTNET_DONUT;
         const pushChainKey = pushNetworkToChainKey(pushNetwork);
+        const pushChainId = pushChainKey;
         const RPC_URL = chain_1.PUSH_CHAIN_INFO[pushChainKey].defaultRPC[0];
         const FACTORY_ADDRESS = chain_1.PUSH_CHAIN_INFO[pushChainKey].factoryAddress;
         const client = (0, viem_1.createPublicClient)({ transport: (0, viem_1.http)(RPC_URL) });
@@ -639,8 +651,8 @@ function resolveControllerAccount(account, options) {
         return {
             accounts: [
                 {
-                    chain: inputChain,
-                    chainName: getChainName(inputChain),
+                    chain: pushChainId,
+                    chainName: getChainName(pushChainId),
                     address: address,
                     type: 'uoa',
                     exists: skipNetworkCheck ? false : true,