@pushchain/core 6.0.19 → 6.0.21

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

@@ -9,7 +9,6 @@ exports.convertExecutorToOrigin = convertExecutorToOrigin;
 exports.deriveSvmCeaPda = deriveSvmCeaPda;
 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");
@@ -44,7 +43,7 @@ function formatAddress(chain, address) {
         try {
             return (0, viem_1.getAddress)(address.toLowerCase());
         }
-        catch (_a) {
+        catch {
             throw new Error('Invalid EVM address format');
         }
     }
@@ -111,9 +110,8 @@ function toChainAgnostic(address, options) {
  * // → { chain: CHAIN.ETHEREUM_SEPOLIA, address: '0xabc...' }
  */
 function fromChainAgnostic(caip) {
-    var _a, _b;
     const [namespace, chainId, rawAddress] = caip.split(':');
-    const chain = ((_b = (_a = Object.entries(chain_1.CHAIN_INFO).find(([, info]) => info.chainId === chainId && chain_1.VM_NAMESPACE[info.vm] === namespace)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : null);
+    const chain = (Object.entries(chain_1.CHAIN_INFO).find(([, info]) => info.chainId === chainId && chain_1.VM_NAMESPACE[info.vm] === namespace)?.[0] ?? null);
     if (!chain) {
         throw new Error(`Unsupported or unknown CAIP address: ${caip}`);
     }
@@ -166,111 +164,109 @@ let _convertOriginToExecutorWarned = false;
  * @deprecated Use `deriveExecutorAccount()` instead, which accepts a CAIP-10
  *   string and uses `options.chain` to control UEA vs CEA derivation.
  */
-function convertOriginToExecutor(account_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (account, options = { onlyCompute: true }) {
-        if (!_convertOriginToExecutorWarned) {
-            console.warn('[PushChain] convertOriginToExecutor() is deprecated. Use deriveExecutorAccount() instead.');
-            _convertOriginToExecutorWarned = true;
-        }
-        const { chain, address } = account;
-        const { vm, chainId } = chain_1.CHAIN_INFO[chain];
-        // If target chain is external, compute CEA on that chain
-        if (options.chain && !isPushChain(options.chain)) {
-            // Get UEA first — if input is already on Push chain, use directly
-            let ueaAddress;
-            if (isPushChain(chain)) {
-                ueaAddress = address;
-            }
-            else {
-                // Compute UEA from origin account
-                const ueaResult = yield convertOriginToExecutor(account, {
-                    onlyCompute: false,
-                });
-                ueaAddress = ueaResult.address;
-            }
-            // Get CEA on the target external chain
-            const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, options.chain);
-            if (options.onlyCompute) {
-                return { address: cea, deployed: isDeployed };
-            }
-            return { address: cea };
-        }
+async function convertOriginToExecutor(account, options = { onlyCompute: true }) {
+    if (!_convertOriginToExecutorWarned) {
+        console.warn('[PushChain] convertOriginToExecutor() is deprecated. Use deriveExecutorAccount() instead.');
+        _convertOriginToExecutorWarned = true;
+    }
+    const { chain, address } = account;
+    const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+    // If target chain is external, compute CEA on that chain
+    if (options.chain && !isPushChain(options.chain)) {
+        // Get UEA first — if input is already on Push chain, use directly
+        let ueaAddress;
         if (isPushChain(chain)) {
-            if (options.onlyCompute) {
-                return { address: account.address, deployed: false };
-            }
-            return { address: account.address };
-        }
-        // Determine Push Network from the chain
-        const pushNetwork = getPushNetworkFromChain(chain);
-        // Check cache for computed address
-        const cachedAddress = accountCache.get(cache_1.CacheKeys.ueaAddressOnchain(chain, address, pushNetwork, vm));
-        if (cachedAddress) {
-            if (options.onlyCompute) {
-                // Check cache for deployment status
-                const cachedDeploymentStatus = accountCache.get(cache_1.CacheKeys.deploymentStatus(cachedAddress));
-                if (cachedDeploymentStatus !== null) {
-                    return {
-                        address: cachedAddress,
-                        deployed: cachedDeploymentStatus,
-                    };
-                }
-            }
-            else {
-                return { address: cachedAddress };
-            }
+            ueaAddress = address;
         }
-        let pushChain;
-        if (pushNetwork === enums_1.PUSH_NETWORK.MAINNET) {
-            pushChain = enums_1.CHAIN.PUSH_MAINNET;
+        else {
+            // Compute UEA from origin account
+            const ueaResult = await convertOriginToExecutor(account, {
+                onlyCompute: false,
+            });
+            ueaAddress = ueaResult.address;
         }
-        else if (pushNetwork === enums_1.PUSH_NETWORK.TESTNET_DONUT ||
-            pushNetwork === enums_1.PUSH_NETWORK.TESTNET) {
-            pushChain = enums_1.CHAIN.PUSH_TESTNET_DONUT;
+        // Get CEA on the target external chain
+        const { cea, isDeployed } = await (0, cea_utils_1.getCEAAddress)(ueaAddress, options.chain);
+        if (options.onlyCompute) {
+            return { address: cea, deployed: isDeployed };
         }
-        else {
-            pushChain = enums_1.CHAIN.PUSH_LOCALNET;
+        return { address: cea };
+    }
+    if (isPushChain(chain)) {
+        if (options.onlyCompute) {
+            return { address: account.address, deployed: false };
         }
-        // Create PushClient to get factory address
-        const pushClient = new push_client_1.PushClient({
-            rpcUrls: chain_1.CHAIN_INFO[pushChain].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,
-                    /**
-                     * @dev - OwnerKey should be in bytes
-                     * for eth - convert hex to bytes
-                     * for sol - convert base64 to bytes
-                     * for others - not defined yet
-                     */
-                    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), computedAddress);
-        const byteCode = yield pushClient.publicClient.getCode({
-            address: computedAddress,
-        });
-        const isDeployed = byteCode !== undefined;
-        // Cache the deployment status
-        accountCache.set(cache_1.CacheKeys.deploymentStatus(computedAddress), isDeployed);
+        return { address: account.address };
+    }
+    // Determine Push Network from the chain
+    const pushNetwork = getPushNetworkFromChain(chain);
+    // Check cache for computed address
+    const cachedAddress = accountCache.get(cache_1.CacheKeys.ueaAddressOnchain(chain, address, pushNetwork, vm));
+    if (cachedAddress) {
         if (options.onlyCompute) {
-            return { address: computedAddress, deployed: isDeployed };
+            // Check cache for deployment status
+            const cachedDeploymentStatus = accountCache.get(cache_1.CacheKeys.deploymentStatus(cachedAddress));
+            if (cachedDeploymentStatus !== null) {
+                return {
+                    address: cachedAddress,
+                    deployed: cachedDeploymentStatus,
+                };
+            }
         }
-        return { address: computedAddress };
+        else {
+            return { address: cachedAddress };
+        }
+    }
+    let pushChain;
+    if (pushNetwork === enums_1.PUSH_NETWORK.MAINNET) {
+        pushChain = enums_1.CHAIN.PUSH_MAINNET;
+    }
+    else if (pushNetwork === enums_1.PUSH_NETWORK.TESTNET_DONUT ||
+        pushNetwork === enums_1.PUSH_NETWORK.TESTNET) {
+        pushChain = enums_1.CHAIN.PUSH_TESTNET_DONUT;
+    }
+    else {
+        pushChain = enums_1.CHAIN.PUSH_LOCALNET;
+    }
+    // Create PushClient to get factory address
+    const pushClient = new push_client_1.PushClient({
+        rpcUrls: chain_1.CHAIN_INFO[pushChain].defaultRPC,
+        network: pushNetwork,
+    });
+    const computedAddress = await pushClient.readContract({
+        address: pushClient.pushChainInfo.factoryAddress,
+        abi: factoryV1_1.FACTORY_V1,
+        functionName: 'computeUEA',
+        args: [
+            {
+                chainNamespace: chain_1.VM_NAMESPACE[vm],
+                chainId: chainId,
+                /**
+                 * @dev - OwnerKey should be in bytes
+                 * for eth - convert hex to bytes
+                 * for sol - convert base64 to bytes
+                 * for others - not defined yet
+                 */
+                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), computedAddress);
+    const byteCode = await pushClient.publicClient.getCode({
+        address: computedAddress,
+    });
+    const isDeployed = byteCode !== undefined;
+    // Cache the deployment status
+    accountCache.set(cache_1.CacheKeys.deploymentStatus(computedAddress), isDeployed);
+    if (options.onlyCompute) {
+        return { address: computedAddress, deployed: isDeployed };
+    }
+    return { address: computedAddress };
 }
 /**
  * Convert Executor to Origin Account
@@ -282,43 +278,40 @@ function convertOriginToExecutor(account_1) {
  *   UEA and CEA lookups via the optional `options.chain` parameter.
  */
 let _convertExecutorToOriginAccountWarned = false;
-function convertExecutorToOriginAccount(ueaAddress, options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a;
-        if (!_convertExecutorToOriginAccountWarned) {
-            console.warn('[PushChain] convertExecutorToOriginAccount() is deprecated. Use resolveControllerAccount() instead.');
-            _convertExecutorToOriginAccountWarned = true;
-        }
-        const pushChainKey = pushNetworkToChainKey((_a = options === null || options === void 0 ? void 0 : options.network) !== null && _a !== void 0 ? _a : enums_1.PUSH_NETWORK.TESTNET_DONUT);
-        const RPC_URL = chain_1.PUSH_CHAIN_INFO[pushChainKey].defaultRPC[0];
-        const FACTORY_ADDRESS = chain_1.PUSH_CHAIN_INFO[pushChainKey].factoryAddress;
-        // Create viem public client
-        const client = (0, viem_1.createPublicClient)({
-            chain: (0, chain_1.getPushViemChain)(pushChainKey),
-            transport: (0, viem_1.http)(RPC_URL),
-        });
-        const originResult = (yield client.readContract({
-            address: FACTORY_ADDRESS,
-            abi: factoryV1_1.FACTORY_V1,
-            functionName: 'getOriginForUEA',
-            args: [ueaAddress],
-        }));
-        const [account, isUEA] = originResult;
-        if (account.chainNamespace === '' ||
-            account.chainId === '' ||
-            account.owner === '0x') {
-            return { account: null, exists: isUEA };
-        }
-        const universalAccount = push_chain_1.PushChain.utils.account.fromChainAgnostic(`${account.chainNamespace}:${account.chainId}:${account.owner}`);
-        if (isUEA) {
-            if (universalAccount.chain.startsWith(chain_1.VM_NAMESPACE[enums_1.VM.SVM])) {
-                // Convert hex-encoded owner to base58 address format
-                const hexBytes = (0, viem_1.hexToBytes)(account.owner);
-                universalAccount.address = bs58_1.bs58.encode(Buffer.from(hexBytes));
-            }
-        }
-        return { account: universalAccount, exists: isUEA };
+async function convertExecutorToOriginAccount(ueaAddress, options) {
+    if (!_convertExecutorToOriginAccountWarned) {
+        console.warn('[PushChain] convertExecutorToOriginAccount() is deprecated. Use resolveControllerAccount() instead.');
+        _convertExecutorToOriginAccountWarned = true;
+    }
+    const pushChainKey = pushNetworkToChainKey(options?.network ?? enums_1.PUSH_NETWORK.TESTNET_DONUT);
+    const RPC_URL = chain_1.PUSH_CHAIN_INFO[pushChainKey].defaultRPC[0];
+    const FACTORY_ADDRESS = chain_1.PUSH_CHAIN_INFO[pushChainKey].factoryAddress;
+    // Create viem public client
+    const client = (0, viem_1.createPublicClient)({
+        chain: (0, chain_1.getPushViemChain)(pushChainKey),
+        transport: (0, viem_1.http)(RPC_URL),
     });
+    const originResult = (await client.readContract({
+        address: FACTORY_ADDRESS,
+        abi: factoryV1_1.FACTORY_V1,
+        functionName: 'getOriginForUEA',
+        args: [ueaAddress],
+    }));
+    const [account, isUEA] = originResult;
+    if (account.chainNamespace === '' ||
+        account.chainId === '' ||
+        account.owner === '0x') {
+        return { account: null, exists: isUEA };
+    }
+    const universalAccount = push_chain_1.PushChain.utils.account.fromChainAgnostic(`${account.chainNamespace}:${account.chainId}:${account.owner}`);
+    if (isUEA) {
+        if (universalAccount.chain.startsWith(chain_1.VM_NAMESPACE[enums_1.VM.SVM])) {
+            // Convert hex-encoded owner to base58 address format
+            const hexBytes = (0, viem_1.hexToBytes)(account.owner);
+            universalAccount.address = bs58_1.bs58.encode(Buffer.from(hexBytes));
+        }
+    }
+    return { account: universalAccount, exists: isUEA };
 }
 /**
  * Convert Executor to Origin Account (with optional chain context)
@@ -332,80 +325,77 @@ function convertExecutorToOriginAccount(ueaAddress, options) {
  *   string and supports both UEA and CEA lookups via `options.chain`.
  */
 let _convertExecutorToOriginWarned = false;
-function convertExecutorToOrigin(executorAddress, options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a;
-        if (!(options === null || options === void 0 ? void 0 : options._internal) && !_convertExecutorToOriginWarned) {
-            console.warn('[PushChain] convertExecutorToOrigin() is deprecated. Use resolveControllerAccount() instead.');
-            _convertExecutorToOriginWarned = true;
-        }
-        if ((options === null || options === void 0 ? void 0 : options.chain) && !isPushChain(options.chain)) {
-            // CEA on external chain → look up PushAccount (UEA) on Push Chain
-            const pushAccountAddress = yield (0, cea_utils_1.getPushAccountForCEA)(executorAddress, options.chain);
-            if (pushAccountAddress ===
-                '0x0000000000000000000000000000000000000000') {
-                return { account: null, exists: false };
-            }
-            // Determine Push Chain from the external chain's network
-            const pushNetwork = getPushNetworkFromChain(options.chain);
-            let pushChain;
-            if (pushNetwork === enums_1.PUSH_NETWORK.MAINNET) {
-                pushChain = enums_1.CHAIN.PUSH_MAINNET;
-            }
-            else if (pushNetwork === enums_1.PUSH_NETWORK.TESTNET_DONUT ||
-                pushNetwork === enums_1.PUSH_NETWORK.TESTNET) {
-                pushChain = enums_1.CHAIN.PUSH_TESTNET_DONUT;
-            }
-            else {
-                pushChain = enums_1.CHAIN.PUSH_LOCALNET;
-            }
-            return {
-                account: {
-                    chain: pushChain,
-                    address: pushAccountAddress,
-                },
-                exists: true,
-            };
+async function convertExecutorToOrigin(executorAddress, options) {
+    if (!options?._internal && !_convertExecutorToOriginWarned) {
+        console.warn('[PushChain] convertExecutorToOrigin() is deprecated. Use resolveControllerAccount() instead.');
+        _convertExecutorToOriginWarned = true;
+    }
+    if (options?.chain && !isPushChain(options.chain)) {
+        // CEA on external chain → look up PushAccount (UEA) on Push Chain
+        const pushAccountAddress = await (0, cea_utils_1.getPushAccountForCEA)(executorAddress, options.chain);
+        if (pushAccountAddress ===
+            '0x0000000000000000000000000000000000000000') {
+            return { account: null, exists: false };
         }
-        // Default: UEA on Push Chain → origin account
-        const network = (_a = options === null || options === void 0 ? void 0 : options.network) !== null && _a !== void 0 ? _a : enums_1.PUSH_NETWORK.TESTNET_DONUT;
-        const cacheKey = `${executorAddress.toLowerCase()}:${network}`;
-        const cached = executorToOriginCache.get(cacheKey);
-        if (cached) {
-            return cached;
+        // Determine Push Chain from the external chain's network
+        const pushNetwork = getPushNetworkFromChain(options.chain);
+        let pushChain;
+        if (pushNetwork === enums_1.PUSH_NETWORK.MAINNET) {
+            pushChain = enums_1.CHAIN.PUSH_MAINNET;
         }
-        const pushChainKey = pushNetworkToChainKey(network);
-        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)({
-            chain: (0, chain_1.getPushViemChain)(pushChainKey),
-            transport: (0, viem_1.http)(RPC_URL),
-        });
-        const originResult = (yield client.readContract({
-            address: FACTORY_ADDRESS,
-            abi: factoryV1_1.FACTORY_V1,
-            functionName: 'getOriginForUEA',
-            args: [executorAddress],
-        }));
-        const [account, isUEA] = originResult;
-        if (account.chainNamespace === '' ||
-            account.chainId === '' ||
-            account.owner === '0x') {
-            const result = { account: null, exists: isUEA };
-            executorToOriginCache.set(cacheKey, result);
-            return result;
+        else if (pushNetwork === enums_1.PUSH_NETWORK.TESTNET_DONUT ||
+            pushNetwork === enums_1.PUSH_NETWORK.TESTNET) {
+            pushChain = enums_1.CHAIN.PUSH_TESTNET_DONUT;
         }
-        const universalAccount = push_chain_1.PushChain.utils.account.fromChainAgnostic(`${account.chainNamespace}:${account.chainId}:${account.owner}`);
-        if (isUEA) {
-            if (universalAccount.chain.startsWith(chain_1.VM_NAMESPACE[enums_1.VM.SVM])) {
-                const hexBytes = (0, viem_1.hexToBytes)(account.owner);
-                universalAccount.address = bs58_1.bs58.encode(Buffer.from(hexBytes));
-            }
+        else {
+            pushChain = enums_1.CHAIN.PUSH_LOCALNET;
         }
-        const result = { account: universalAccount, exists: isUEA };
+        return {
+            account: {
+                chain: pushChain,
+                address: pushAccountAddress,
+            },
+            exists: true,
+        };
+    }
+    // Default: UEA on Push Chain → origin account
+    const network = options?.network ?? enums_1.PUSH_NETWORK.TESTNET_DONUT;
+    const cacheKey = `${executorAddress.toLowerCase()}:${network}`;
+    const cached = executorToOriginCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const pushChainKey = pushNetworkToChainKey(network);
+    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)({
+        chain: (0, chain_1.getPushViemChain)(pushChainKey),
+        transport: (0, viem_1.http)(RPC_URL),
+    });
+    const originResult = (await client.readContract({
+        address: FACTORY_ADDRESS,
+        abi: factoryV1_1.FACTORY_V1,
+        functionName: 'getOriginForUEA',
+        args: [executorAddress],
+    }));
+    const [account, isUEA] = originResult;
+    if (account.chainNamespace === '' ||
+        account.chainId === '' ||
+        account.owner === '0x') {
+        const result = { account: null, exists: isUEA };
         executorToOriginCache.set(cacheKey, result);
         return result;
-    });
+    }
+    const universalAccount = push_chain_1.PushChain.utils.account.fromChainAgnostic(`${account.chainNamespace}:${account.chainId}:${account.owner}`);
+    if (isUEA) {
+        if (universalAccount.chain.startsWith(chain_1.VM_NAMESPACE[enums_1.VM.SVM])) {
+            const hexBytes = (0, viem_1.hexToBytes)(account.owner);
+            universalAccount.address = bs58_1.bs58.encode(Buffer.from(hexBytes));
+        }
+    }
+    const result = { account: universalAccount, exists: isUEA };
+    executorToOriginCache.set(cacheKey, result);
+    return result;
 }
 /**
  * Maps a PUSH_NETWORK to the corresponding Push Chain key for PUSH_CHAIN_INFO lookup.
@@ -474,103 +464,100 @@ function deriveSvmCeaPda(ueaAddress, targetChain, skipNetworkCheck) {
  * @param options.skipNetworkCheck - If true, skip deployment check and return deployed: null.
  * @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 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;
-        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 (cachedUea) {
-                ueaAddress = cachedUea;
-            }
-            else {
-                // 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);
-            }
-            // 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 };
-            }
-            // Return UEA with deployment check
-            if (skipNetworkCheck) {
-                return { address: ueaAddress, deployed: null };
-            }
+async function deriveExecutorAccount(account, options) {
+    const skipNetworkCheck = options?.skipNetworkCheck ?? false;
+    const targetChain = options?.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 (cachedUea) {
+            ueaAddress = cachedUea;
+        }
+        else {
+            // 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,
             });
-            const byteCode = yield pushClient.publicClient.getCode({
-                address: ueaAddress,
+            ueaAddress = await 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,
+                    },
+                ],
             });
-            const isDeployed = byteCode !== undefined;
-            accountCache.set(cache_1.CacheKeys.deploymentStatus(ueaAddress), isDeployed);
-            return { address: ueaAddress, deployed: isDeployed };
+            // Cache the computed address
+            accountCache.set(cache_1.CacheKeys.ueaAddressOnchain(chain, address, pushNetwork, vm), ueaAddress);
         }
-        // --- Case 2: Input is on Push Chain ---
-        // If target chain is external, derive CEA
+        // 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(address, targetChain, skipNetworkCheck);
+                return deriveSvmCeaPda(ueaAddress, targetChain, skipNetworkCheck);
             }
-            const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(address, targetChain);
+            const { cea, isDeployed } = await (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain);
             return { address: cea, deployed: skipNetworkCheck ? null : isDeployed };
         }
-        // Push address, no external target — return with deployment check
+        // Return UEA with deployment check
         if (skipNetworkCheck) {
-            return { address: address, deployed: null };
+            return { address: ueaAddress, deployed: null };
         }
-        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 byteCode = yield pushClient.publicClient.getCode({
-            address: address,
+        const byteCode = await pushClient.publicClient.getCode({
+            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 };
+    }
+    // --- 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 } = await (0, cea_utils_1.getCEAAddress)(address, targetChain);
+        return { address: cea, deployed: skipNetworkCheck ? null : isDeployed };
+    }
+    // Push address, no external target — return with deployment check
+    if (skipNetworkCheck) {
+        return { address: address, deployed: null };
+    }
+    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 byteCode = await pushClient.publicClient.getCode({
+        address: address,
+    });
+    return {
+        address: address,
+        deployed: byteCode !== undefined,
+    };
 }
 /**
  * Resolve the controller (origin) accounts for a given executor address.
@@ -583,73 +570,20 @@ function deriveExecutorAccount(account, options) {
  * @param options.skipNetworkCheck - If true, skip existence checks, set exists: false
  * @returns Resolved accounts in the controller chain
  */
-function resolveControllerAccount(address, options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a;
-        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: 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') {
-                return { accounts: [] };
-            }
-            // Determine Push Chain from external chain's network
-            const pushNetwork = getPushNetworkFromChain(inputChain);
-            const pushChainKey = pushNetworkToChainKey(pushNetwork);
-            // Now resolve UEA → origin
-            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)({
-                chain: (0, chain_1.getPushViemChain)(pushChainKey),
-                transport: (0, viem_1.http)(RPC_URL),
-            });
-            const originResult = (yield client.readContract({
-                address: FACTORY_ADDRESS,
-                abi: factoryV1_1.FACTORY_V1,
-                functionName: 'getOriginForUEA',
-                args: [pushAccountAddress],
-            }));
-            const [originAccount, isUEA] = originResult;
-            const accounts = [];
-            // Add UEA entry
-            accounts.push({
-                chain: pushChainId,
-                chainName: getChainName(pushChainId),
-                address: pushAccountAddress,
-                type: 'uea',
-                exists: skipNetworkCheck ? false : true,
-            });
-            // Add origin (UOA) entry if found
-            if (isUEA &&
-                originAccount.chainNamespace !== '' &&
-                originAccount.chainId !== '' &&
-                originAccount.owner !== '0x') {
-                const originUniversal = fromChainAgnostic(`${originAccount.chainNamespace}:${originAccount.chainId}:${originAccount.owner}`);
-                // Handle SVM address conversion
-                let originAddress = originUniversal.address;
-                if (originUniversal.chain.startsWith(chain_1.VM_NAMESPACE[enums_1.VM.SVM])) {
-                    const hexBytes = (0, viem_1.hexToBytes)(originAccount.owner);
-                    originAddress = bs58_1.bs58.encode(Buffer.from(hexBytes));
-                }
-                accounts.push({
-                    chain: originUniversal.chain,
-                    chainName: getChainName(originUniversal.chain),
-                    address: originAddress,
-                    type: 'uoa',
-                    exists: skipNetworkCheck ? false : true,
-                    role: 'controller',
-                });
-            }
-            return { accounts };
+async function resolveControllerAccount(address, options) {
+    const inputChain = options?.chain;
+    const skipNetworkCheck = options?.skipNetworkCheck ?? false;
+    // 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 = await (0, cea_utils_1.getPushAccountForCEA)(address, inputChain);
+        if (pushAccountAddress === '0x0000000000000000000000000000000000000000') {
+            return { accounts: [] };
         }
-        // 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;
+        // Determine Push Chain from external chain's network
+        const pushNetwork = getPushNetworkFromChain(inputChain);
         const pushChainKey = pushNetworkToChainKey(pushNetwork);
+        // Now resolve UEA → origin
         const pushChainId = pushChainKey;
         const RPC_URL = chain_1.PUSH_CHAIN_INFO[pushChainKey].defaultRPC[0];
         const FACTORY_ADDRESS = chain_1.PUSH_CHAIN_INFO[pushChainKey].factoryAddress;
@@ -657,14 +591,23 @@ function resolveControllerAccount(address, options) {
             chain: (0, chain_1.getPushViemChain)(pushChainKey),
             transport: (0, viem_1.http)(RPC_URL),
         });
-        const originResult = (yield client.readContract({
+        const originResult = (await client.readContract({
             address: FACTORY_ADDRESS,
             abi: factoryV1_1.FACTORY_V1,
             functionName: 'getOriginForUEA',
-            args: [address],
+            args: [pushAccountAddress],
         }));
         const [originAccount, isUEA] = originResult;
-        // If it's a UEA, resolve to origin
+        const accounts = [];
+        // Add UEA entry
+        accounts.push({
+            chain: pushChainId,
+            chainName: getChainName(pushChainId),
+            address: pushAccountAddress,
+            type: 'uea',
+            exists: skipNetworkCheck ? false : true,
+        });
+        // Add origin (UOA) entry if found
         if (isUEA &&
             originAccount.chainNamespace !== '' &&
             originAccount.chainId !== '' &&
@@ -676,32 +619,73 @@ function resolveControllerAccount(address, options) {
                 const hexBytes = (0, viem_1.hexToBytes)(originAccount.owner);
                 originAddress = bs58_1.bs58.encode(Buffer.from(hexBytes));
             }
-            return {
-                accounts: [
-                    {
-                        chain: originUniversal.chain,
-                        chainName: getChainName(originUniversal.chain),
-                        address: originAddress,
-                        type: 'uoa',
-                        exists: skipNetworkCheck ? false : true,
-                        role: 'controller',
-                    },
-                ],
-            };
+            accounts.push({
+                chain: originUniversal.chain,
+                chainName: getChainName(originUniversal.chain),
+                address: originAddress,
+                type: 'uoa',
+                exists: skipNetworkCheck ? false : true,
+                role: 'controller',
+            });
+        }
+        return { accounts };
+    }
+    // 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)({
+        chain: (0, chain_1.getPushViemChain)(pushChainKey),
+        transport: (0, viem_1.http)(RPC_URL),
+    });
+    const originResult = (await client.readContract({
+        address: FACTORY_ADDRESS,
+        abi: factoryV1_1.FACTORY_V1,
+        functionName: 'getOriginForUEA',
+        args: [address],
+    }));
+    const [originAccount, isUEA] = originResult;
+    // If it's a UEA, resolve to origin
+    if (isUEA &&
+        originAccount.chainNamespace !== '' &&
+        originAccount.chainId !== '' &&
+        originAccount.owner !== '0x') {
+        const originUniversal = fromChainAgnostic(`${originAccount.chainNamespace}:${originAccount.chainId}:${originAccount.owner}`);
+        // Handle SVM address conversion
+        let originAddress = originUniversal.address;
+        if (originUniversal.chain.startsWith(chain_1.VM_NAMESPACE[enums_1.VM.SVM])) {
+            const hexBytes = (0, viem_1.hexToBytes)(originAccount.owner);
+            originAddress = bs58_1.bs58.encode(Buffer.from(hexBytes));
         }
-        // Not a UEA — Push Chain EOA/smart contract, return as controller
         return {
             accounts: [
                 {
-                    chain: pushChainId,
-                    chainName: getChainName(pushChainId),
-                    address: address,
+                    chain: originUniversal.chain,
+                    chainName: getChainName(originUniversal.chain),
+                    address: originAddress,
                     type: 'uoa',
                     exists: skipNetworkCheck ? false : true,
                     role: 'controller',
                 },
             ],
         };
-    });
+    }
+    // Not a UEA — Push Chain EOA/smart contract, return as controller
+    return {
+        accounts: [
+            {
+                chain: pushChainId,
+                chainName: getChainName(pushChainId),
+                address: address,
+                type: 'uoa',
+                exists: skipNetworkCheck ? false : true,
+                role: 'controller',
+            },
+        ],
+    };
 }
 //# sourceMappingURL=account.js.map