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

package/package.json

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

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/universal/account/account.d.ts

@@ -69,29 +69,29 @@ 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 Push Chain 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.
+ * @param address - Plain address string (e.g., "0xABC...")
+ * @param options.chain - Target external chain for CEA derivation. If omitted, treats address as Push Chain account.
  * @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(address: string, 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,62 @@ 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 Push Chain 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.
+ * @param address - Plain address string (e.g., "0xABC...")
+ * @param options.chain - Target external chain for CEA derivation. If omitted, treats address as Push Chain account.
  * @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) {
+function deriveExecutorAccount(address, 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
-            let ueaAddress;
-            if (isPushChain(originChain)) {
-                ueaAddress = address;
-            }
-            else {
-                const ueaResult = yield deriveExecutorAccount(account);
-                ueaAddress = ueaResult.address;
-            }
-            // Get CEA on the target external chain
-            const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain);
+            const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(address, targetChain);
             return { address: cea, deployed: skipNetworkCheck ? false : isDeployed };
         }
-        // If origin is Push chain, return the address directly
-        if (isPushChain(originChain)) {
-            if (skipNetworkCheck) {
-                return { address: address, 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,
-            });
-            return { address: address, deployed: byteCode !== undefined };
-        }
-        // 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,
-                };
-            }
+        // Address is on Push Chain — return with deployment check
+        if (skipNetworkCheck) {
+            return { address: address, deployed: false };
         }
+        const pushNetwork = targetChain && isPushChain(targetChain)
+            ? getPushNetworkFromChain(targetChain)
+            : enums_1.PUSH_NETWORK.TESTNET_DONUT;
         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 +539,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 +584,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,