@pushchain/core 5.1.3 → 5.1.4-alpha.1

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

@@ -6,12 +6,14 @@ exports.fromChainAgnostic = fromChainAgnostic;
 exports.convertOriginToExecutor = convertOriginToExecutor;
 exports.convertExecutorToOriginAccount = convertExecutorToOriginAccount;
 exports.convertExecutorToOrigin = convertExecutorToOrigin;
+exports.deriveExecutorAccount = deriveExecutorAccount;
+exports.resolveControllerAccount = resolveControllerAccount;
 const tslib_1 = require("tslib");
 const viem_1 = require("viem");
 const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
-const anchor_1 = require("@coral-xyz/anchor");
-const abi_1 = require("../../constants/abi");
+const bs58_1 = require("../../internal/bs58");
+const factoryV1_1 = require("../../constants/abi/factoryV1");
 const push_client_1 = require("../../push-client/push-client");
 const cache_1 = require("../../cache/cache");
 const push_chain_1 = require("../../push-chain/push-chain");
@@ -120,6 +122,9 @@ function fromChainAgnostic(caip) {
 }
 // Global cache instance for convertOriginToExecutor
 const accountCache = new cache_1.Cache();
+// Cache for convertExecutorToOrigin — UEA→origin mapping is immutable once deployed.
+// Keyed by `${address}:${network}` to handle different Push Chain networks.
+const executorToOriginCache = new Map();
 /**
  * Determines the Push Network based on the chain type (testnet vs mainnet)
  */
@@ -154,8 +159,17 @@ function getPushNetworkFromChain(chain) {
         throw new Error(`Unsupported chain for Push Network mapping: ${chain}`);
     }
 }
+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
@@ -222,7 +236,7 @@ function convertOriginToExecutor(account_1) {
         });
         const computedAddress = yield pushClient.readContract({
             address: pushClient.pushChainInfo.factoryAddress,
-            abi: abi_1.FACTORY_V1,
+            abi: factoryV1_1.FACTORY_V1,
             functionName: 'computeUEA',
             args: [
                 {
@@ -237,7 +251,7 @@ function convertOriginToExecutor(account_1) {
                     owner: vm === enums_1.VM.EVM
                         ? address
                         : vm === enums_1.VM.SVM
-                            ? (0, viem_1.bytesToHex)(Uint8Array.from(anchor_1.utils.bytes.bs58.decode(address)))
+                            ? (0, viem_1.bytesToHex)(Uint8Array.from(bs58_1.bs58.decode(address)))
                             : address,
                 },
             ],
@@ -265,18 +279,24 @@ function convertOriginToExecutor(account_1) {
  * @deprecated Use `convertExecutorToOrigin()` instead, which supports both
  *   UEA and CEA lookups via the optional `options.chain` parameter.
  */
-function convertExecutorToOriginAccount(ueaAddress) {
+let _convertExecutorToOriginAccountWarned = false;
+function convertExecutorToOriginAccount(ueaAddress, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        console.warn('[PushChain] convertExecutorToOriginAccount() is deprecated. Use convertExecutorToOrigin() instead.');
-        const RPC_URL = chain_1.PUSH_CHAIN_INFO[enums_1.CHAIN.PUSH_TESTNET_DONUT].defaultRPC[0];
-        const FACTORY_ADDRESS = chain_1.PUSH_CHAIN_INFO[enums_1.CHAIN.PUSH_TESTNET_DONUT].factoryAddress;
+        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)({
             transport: (0, viem_1.http)(RPC_URL),
         });
         const originResult = (yield client.readContract({
             address: FACTORY_ADDRESS,
-            abi: abi_1.FACTORY_V1,
+            abi: factoryV1_1.FACTORY_V1,
             functionName: 'getOriginForUEA',
             args: [ueaAddress],
         }));
@@ -291,7 +311,7 @@ function convertExecutorToOriginAccount(ueaAddress) {
             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 = anchor_1.utils.bytes.bs58.encode(hexBytes);
+                universalAccount.address = bs58_1.bs58.encode(Buffer.from(hexBytes));
             }
         }
         return { account: universalAccount, exists: isUEA };
@@ -304,9 +324,18 @@ function convertExecutorToOriginAccount(ueaAddress) {
  *   the mapped origin account (same as convertExecutorToOriginAccount).
  * - With `chain`: treats the address as a CEA on the specified external chain,
  *   looks up the corresponding PushAccount (UEA) on Push Chain, and returns it.
+ *
+ * @deprecated Use `resolveControllerAccount()` instead, which accepts a CAIP-10
+ *   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);
@@ -336,14 +365,21 @@ function convertExecutorToOrigin(executorAddress, options) {
             };
         }
         // Default: UEA on Push Chain → origin account
-        const RPC_URL = chain_1.PUSH_CHAIN_INFO[enums_1.CHAIN.PUSH_TESTNET_DONUT].defaultRPC[0];
-        const FACTORY_ADDRESS = chain_1.PUSH_CHAIN_INFO[enums_1.CHAIN.PUSH_TESTNET_DONUT].factoryAddress;
+        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;
+        }
+        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)({
             transport: (0, viem_1.http)(RPC_URL),
         });
         const originResult = (yield client.readContract({
             address: FACTORY_ADDRESS,
-            abi: abi_1.FACTORY_V1,
+            abi: factoryV1_1.FACTORY_V1,
             functionName: 'getOriginForUEA',
             args: [executorAddress],
         }));
@@ -351,21 +387,267 @@ function convertExecutorToOrigin(executorAddress, options) {
         if (account.chainNamespace === '' ||
             account.chainId === '' ||
             account.owner === '0x') {
-            return { account: null, exists: isUEA };
+            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 = anchor_1.utils.bytes.bs58.encode(hexBytes);
+                universalAccount.address = bs58_1.bs58.encode(Buffer.from(hexBytes));
             }
         }
-        return { account: universalAccount, exists: isUEA };
+        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.
+ */
+function pushNetworkToChainKey(network) {
+    if (network === enums_1.PUSH_NETWORK.MAINNET)
+        return enums_1.CHAIN.PUSH_MAINNET;
+    if (network === enums_1.PUSH_NETWORK.TESTNET_DONUT || network === enums_1.PUSH_NETWORK.TESTNET)
+        return enums_1.CHAIN.PUSH_TESTNET_DONUT;
+    return enums_1.CHAIN.PUSH_LOCALNET;
+}
 function isPushChain(chain) {
     return (chain === enums_1.CHAIN.PUSH_MAINNET ||
         chain === enums_1.CHAIN.PUSH_TESTNET_DONUT ||
         chain === enums_1.CHAIN.PUSH_LOCALNET);
 }
+/**
+ * Resolves the chain name (enum key) for a CHAIN value.
+ * e.g., CHAIN.PUSH_TESTNET_DONUT → "PUSH_TESTNET_DONUT"
+ */
+function getChainName(chain) {
+    // Special case: prefer PUSH_TESTNET_DONUT over PUSH_TESTNET for 'eip155:42101'
+    if (chain === 'eip155:42101') {
+        return 'PUSH_TESTNET_DONUT';
+    }
+    const entry = Object.entries(enums_1.CHAIN).find(([, val]) => val === chain);
+    return entry ? entry[0] : chain;
+}
+/**
+ * Derive the executor account (UEA or CEA) for a given origin 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 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
+            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);
+            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,
+                };
+            }
+        }
+        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,
+        });
+        const isDeployed = byteCode !== undefined;
+        // Cache the deployment status
+        accountCache.set(cache_1.CacheKeys.deploymentStatus(computedAddress), isDeployed);
+        return { address: computedAddress, deployed: isDeployed };
+    });
+}
+/**
+ * Resolve the controller (origin) accounts for a given executor address.
+ *
+ * Given a UEA or CEA address (as CAIP-10), 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 options.skipNetworkCheck - If true, skip existence checks, set exists: false
+ * @returns Resolved accounts in the controller chain
+ */
+function resolveControllerAccount(account, options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { chain: inputChain, address } = fromChainAgnostic(account);
+        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)) {
+            // 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)({ 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 };
+        }
+        // Case B: Input is on Push Chain (UEA or EOA)
+        const pushNetwork = getPushNetworkFromChain(inputChain);
+        const pushChainKey = pushNetworkToChainKey(pushNetwork);
+        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) });
+        const originResult = (yield 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));
+            }
+            return {
+                accounts: [
+                    {
+                        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: inputChain,
+                    chainName: getChainName(inputChain),
+                    address: address,
+                    type: 'uoa',
+                    exists: skipNetworkCheck ? false : true,
+                    role: 'controller',
+                },
+            ],
+        };
+    });
+}
 //# sourceMappingURL=account.js.map

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

@@ -3,7 +3,6 @@ import { TypedDataDomain, TypedData } from '../../constants';
 import { EthersV5SignerType, EthersV6SignerType, UniversalAccount, UniversalSigner, UniversalSignerSkeleton, ViemSignerType } from '../universal.types';
 import { Keypair } from '@solana/web3.js';
 import { CHAIN, LIBRARY } from '../../constants/enums';
-import { ethers } from 'ethers';
 /**
  * Creates a `UniversalSigner` object for signing messages and transactions
  * on any supported chain.
@@ -27,11 +26,11 @@ export declare function createUniversalSigner({ account, signMessage, signAndSen
 /**
  * Creates a UniversalSigner from either a viem, ethers, solana WalletClient or Account instance.
  *
- * @param {WalletClient | Account | Keypair | ethers.HDNodeWallet} clientOrAccount - The viem WalletClient or Account instance
+ * @param {WalletClient | Account | Keypair} clientOrAccount - The viem WalletClient or Account instance
  * @param {CHAIN} chain - The chain the signer will operate on
  * @returns {Promise<UniversalSigner>} A signer object configured for the specified chain
  */
-export declare function toUniversalFromKeypair(clientOrAccount: WalletClient | Keypair | ethers.Wallet | ethers.HDNodeWallet, { chain, library }: {
+export declare function toUniversalFromKeypair(clientOrAccount: WalletClient | Keypair | EthersV6SignerType, { chain, library }: {
     chain: CHAIN;
     library: LIBRARY;
 }): Promise<UniversalSigner>;