@pushchain/core 0.1.17 → 0.1.19

package/src/lib/orchestrator/orchestrator.js

@@ -14,7 +14,6 @@ const anchor = tslib_1.__importStar(require("@coral-xyz/anchor"));
 const tx_1 = require("../generated/v1/tx");
 const price_fetch_1 = require("../price-fetch/price-fetch");
 const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
-const ethers_1 = require("ethers");
 class Orchestrator {
     constructor(universalSigner, pushNetwork, rpcUrls = {}, printTraces = false) {
         this.universalSigner = universalSigner;
@@ -43,146 +42,94 @@ class Orchestrator {
     execute(execute) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const chain = this.universalSigner.account.chain;
-            if (!execute.data) {
-                execute.data = '0x';
-            }
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Starting cross-chain execution from chain: ${chain}`);
-            }
-            // Add validation that if sepolia, or any origin testnet, you can only interact with Push testnet. Same for mainnet
-            const isTestnet = [
-                enums_1.CHAIN.ETHEREUM_SEPOLIA,
-                enums_1.CHAIN.SOLANA_TESTNET,
-                enums_1.CHAIN.SOLANA_DEVNET,
-            ].includes(chain);
-            const isMainnet = [enums_1.CHAIN.ETHEREUM_MAINNET, enums_1.CHAIN.SOLANA_MAINNET].includes(chain);
-            if (isTestnet &&
-                this.pushClient.pushChainInfo.chainId !==
-                    chain_1.CHAIN_INFO[enums_1.CHAIN.PUSH_TESTNET_DONUT].chainId &&
-                this.pushClient.pushChainInfo.chainId !==
-                    chain_1.CHAIN_INFO[enums_1.CHAIN.PUSH_LOCALNET].chainId) {
-                throw new Error('Testnet chains can only interact with Push Testnet or Localnet');
-            }
-            if (isMainnet &&
-                this.pushClient.pushChainInfo.chainId !==
-                    chain_1.CHAIN_INFO[enums_1.CHAIN.PUSH_MAINNET].chainId) {
-                throw new Error('Mainnet chains can only interact with Push Mainnet');
-            }
+            this.validateMainnetConnection(chain);
             // 1. Execute direct tx if signer is already on Push Chain
             if (this.isPushChain(chain)) {
-                return this.pushClient.sendTransaction({
-                    to: execute.target,
-                    data: execute.data,
+                this.printLog('Push to Push Transaction Detected');
+                const txHash = yield this.pushClient.sendTransaction({
+                    to: execute.to,
+                    data: execute.data || '0x',
                     value: execute.value,
                     signer: this.universalSigner,
                 });
+                if (chain === enums_1.CHAIN.PUSH_LOCALNET) {
+                    // @dev - Required for preventing cosmos fetching failures
+                    const delay = (ms) => {
+                        return new Promise((resolve) => setTimeout(resolve, ms));
+                    };
+                    yield delay(3000);
+                }
+                return this.pushClient.getCosmosTx(txHash);
             }
-            // 2. Get Push chain NMSC address for this signer
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Fetching NMSC address for UniversalSigner`);
-            }
-            const { address: nmscAddress, deployed: isNMSCDeployed } = yield this.getNMSCAddress();
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] NMSC Address: ${nmscAddress}`);
-                console.log(`[${this.constructor.name}] Deployed: ${isNMSCDeployed}`);
-            }
+            // 2. Get Push chain UEA address for this signer
+            this.printLog('Fetching UEA for Connected Universal Account');
+            const { address: UEA, deployed: isUEADeployed } = yield this.computeUEA();
+            this.printLog(`UEA: ${UEA}, Deployed: ${isUEADeployed}`);
             // 3. Estimate funds required for the execution
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Estimating cost of execution`);
-            }
-            const gasEstimate = yield this.pushClient.estimateGas({
-                to: execute.target,
-                data: execute.data,
-                // value: execute.value, @DEV - taking 0 as of now
-            });
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] GasEstimate: ${gasEstimate}`);
-            }
+            this.printLog('Estimating Gas Limit for Execution');
+            // const gasEstimate = await this.pushClient.estimateGas({
+            //   to: execute.target,
+            //   data: execute.data,
+            //   // value: execute.value, @DEV - taking 0 as of now
+            // });
+            const gasEstimate = execute.gasLimit || BigInt(1e7);
+            this.printLog(`GasEstimate: ${gasEstimate}`);
             // Fetch current gas price
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Fetching Gas Price`);
-            }
+            this.printLog('Fetching Gas Price');
             const gasPrice = yield this.pushClient.getGasPrice();
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Gas Price: ${gasPrice}`);
-            }
-            // Add 10% buffer as integer math
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Calculating estimated gas fee for execution`);
-            }
-            const requiredGasFee = (gasEstimate * gasPrice * BigInt(110)) / BigInt(100);
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Required Gas Fee: ${requiredGasFee}`);
-            }
-            // Total funds = gas fee + value being sent
+            this.printLog(`Gas Price: ${gasPrice}`);
+            const requiredGasFee = gasEstimate * gasPrice;
+            this.printLog(`Required Gas Fee for Execution: ${requiredGasFee} upc`);
             const requiredFunds = requiredGasFee + execute.value;
-            // 4. Check NMSC balance on Push Chain ( in nPUSH )
-            if (this.printTraces) {
-                console.log(`${this.constructor.name}]  Checking NMSC balance...`);
-            }
-            const funds = yield this.pushClient.getBalance(nmscAddress);
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}]  Current balance: ${funds}`);
-            }
-            // 5. Get NMSC Nonce
-            const nonce = isNMSCDeployed
-                ? yield this.getNMSCNonce(nmscAddress)
-                : BigInt(0);
+            this.printLog(`Total Required Funds for Execution (fee + value): ${requiredFunds} upc`);
+            // 4. Check UEA balance on Push Chain
+            this.printLog('Checking UEA balance');
+            const funds = yield this.pushClient.getBalance(UEA);
+            this.printLog(`Current balance: ${funds}`);
+            // 5. Get UEA Nonce
+            this.printLog('Fetching UEA nonce');
+            const nonce = isUEADeployed ? yield this.getUEANonce(UEA) : BigInt(0);
+            this.printLog(`Current Nonce: ${nonce}`);
             // 6. Create execution hash ( execution data to be signed )
-            const crosschainPayload = {
-                target: execute.target,
+            const universalPayload = JSON.parse(JSON.stringify({
+                to: execute.to,
                 value: execute.value,
-                data: execute.data,
-                gasLimit: execute.gasLimit || BigInt(1e18),
+                data: execute.data || '0x',
+                gasLimit: execute.gasLimit || BigInt(1e7),
                 maxFeePerGas: execute.maxFeePerGas || BigInt(1e10),
-                maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(2),
+                maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(0),
                 nonce,
                 deadline: execute.deadline || BigInt(9999999999),
-            };
+                sigType: tx_1.SignatureType.signedVerification,
+            }, this.bigintReplacer));
             const executionHash = this.computeExecutionHash({
-                verifyingContract: nmscAddress,
-                payload: crosschainPayload,
+                verifyingContract: UEA,
+                payload: universalPayload,
             });
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Execution hash: ${executionHash}`);
-            }
+            this.printLog(`Universal Payload Hash: ${executionHash}`);
             // 7. If not enough funds, lock required fee on source chain and send tx to Push chain
             let feeLockTxHash = execute.feeLockTxHash;
             if (funds < requiredFunds && !feeLockTxHash) {
-                if (this.printTraces) {
-                    console.log(`[${this.constructor.name}] Insufficient funds, locking additional fees...`);
-                }
                 const fundDifference = requiredFunds - funds;
+                this.printLog(`Insufficient funds, locking funds ${fundDifference} upc`);
                 const fundDifferenceInUSDC = this.pushClient.pushToUSDC(fundDifference); // ( USDC with 8 decimal points )
                 feeLockTxHash = yield this.lockFee(fundDifferenceInUSDC, executionHash);
-                if (this.printTraces) {
-                    console.log(`[${this.constructor.name}] Fee lock transaction hash: ${feeLockTxHash}`);
-                }
-                if (this.printTraces) {
-                    console.log(`[${this.constructor.name}] Waiting for Block Confirmations..`);
-                }
+                this.printLog(`Fee lock TxHash: ${feeLockTxHash}`);
+                this.printLog('Waiting for Block Confirmations of Fee lock Tx on Origin Chain');
                 yield this.waitForLockerFeeConfirmation(feeLockTxHash);
-                if (this.printTraces) {
-                    console.log(`[${this.constructor.name}] Enough Origin Chain Block confirmations received`);
-                }
-            }
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Signing execution data...`);
+                this.printLog('Enough Confirmations received');
             }
             // 8. Sign execution data
-            const signature = yield this.signCrossChainPayload(crosschainPayload, nmscAddress);
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Execution data signed successfully`);
-            }
-            // 8. Send Tx to Push chain
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Sending transaction to Push chain...`);
-            }
-            const txHash = yield this.sendCrossChainPushTx(isNMSCDeployed, feeLockTxHash, Object.assign(Object.assign({}, crosschainPayload), { value: crosschainPayload.value.toString(), gasLimit: crosschainPayload.gasLimit.toString(), maxFeePerGas: crosschainPayload.maxFeePerGas.toString(), maxPriorityFeePerGas: crosschainPayload.maxPriorityFeePerGas.toString(), nonce: crosschainPayload.nonce.toString(), deadline: crosschainPayload.deadline.toString() }), signature);
-            if (this.printTraces) {
-                console.log(`[${this.constructor.name}] Transaction sent successfully. Hash: ${txHash}`);
-            }
-            return txHash;
+            this.printLog(`Signing Universal Payload`);
+            const signature = yield this.signUniversalPayload(universalPayload, UEA);
+            this.printLog(`Signature: ${(0, viem_1.bytesToHex)(signature)}`);
+            // 9. Send Tx to Push chain
+            this.printLog('Sending transaction to Push chain');
+            // Serialize & parse in one go to convert all bigint → string
+            const serializedPayload = JSON.parse(JSON.stringify(universalPayload, this.bigintReplacer));
+            const tx = yield this.sendUniversalTx(isUEADeployed, feeLockTxHash, serializedPayload, signature);
+            this.printLog(`Tx: ${JSON.stringify(tx, this.bigintReplacer, 2)}`);
+            return tx;
         });
     }
     /**
@@ -224,7 +171,7 @@ class Orchestrator {
                     nativeAmount =
                         (amount * BigInt(Math.pow(10, nativeDecimals))) / nativeTokenUsdPrice;
                     const svmClient = new svm_client_1.SvmClient({ rpcUrls });
-                    const [lockerPda, lockerBump] = anchor.web3.PublicKey.findProgramAddressSync([Buffer.from('locker')], new web3_js_1.PublicKey(lockerContract));
+                    const [lockerPda] = anchor.web3.PublicKey.findProgramAddressSync([Buffer.from('locker')], new web3_js_1.PublicKey(lockerContract));
                     return yield svmClient.writeContract({
                         abi: abi_1.FEE_LOCKER_SVM,
                         address: lockerContract,
@@ -244,7 +191,7 @@ class Orchestrator {
             }
         });
     }
-    signCrossChainPayload(crosschainPayload, verifyingContract, version) {
+    signUniversalPayload(universalPayload, verifyingContract, version) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const chain = this.universalSigner.account.chain;
             const { vm } = chain_1.CHAIN_INFO[chain];
@@ -260,8 +207,8 @@ class Orchestrator {
                             verifyingContract,
                         },
                         types: {
-                            CrossChainPayload: [
-                                { name: 'target', type: 'address' },
+                            UniversalPayload: [
+                                { name: 'to', type: 'address' },
                                 { name: 'value', type: 'uint256' },
                                 { name: 'data', type: 'bytes' },
                                 { name: 'gasLimit', type: 'uint256' },
@@ -269,17 +216,18 @@ class Orchestrator {
                                 { name: 'maxPriorityFeePerGas', type: 'uint256' },
                                 { name: 'nonce', type: 'uint256' },
                                 { name: 'deadline', type: 'uint256' },
+                                { name: 'sigType', type: 'uint8' },
                             ],
                         },
-                        primaryType: 'CrossChainPayload',
-                        message: crosschainPayload,
+                        primaryType: 'UniversalPayload',
+                        message: universalPayload,
                     });
                 }
                 case enums_1.VM.SVM: {
                     const digest = this.computeExecutionHash({
                         chainId: Number(this.pushClient.pushChainInfo.chainId),
                         verifyingContract,
-                        payload: crosschainPayload,
+                        payload: universalPayload,
                         version: version || '0.1.0',
                     });
                     return this.universalSigner.signMessage((0, viem_1.stringToBytes)(digest));
@@ -293,89 +241,69 @@ class Orchestrator {
     /**
      * Sends a custom Cosmos tx to Push Chain (gasless) to execute user intent.
      */
-    sendCrossChainPushTx(isNMSCDeployed, feeLockTxHash, crosschainPayload, signature) {
+    sendUniversalTx(isUEADeployed, feeLockTxHash, universalPayload, signature) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const { chain, address } = this.universalSigner.account;
-            const { vm, chainId } = chain_1.CHAIN_INFO[chain];
-            const accountId = {
-                namespace: chain_1.VM_NAMESPACE[vm],
-                chainId,
-                ownerKey: vm === enums_1.VM.EVM
+            const { vm } = chain_1.CHAIN_INFO[chain];
+            const universalAccount = {
+                chain,
+                owner: vm === enums_1.VM.EVM
                     ? address
                     : vm === enums_1.VM.SVM
                         ? (0, viem_1.bytesToHex)(bytes_1.bs58.decode(address))
                         : address,
-                vmType: tx_1.vmType[vm],
             };
             const { cosmosAddress: signer } = this.pushClient.getSignerAddress();
             const msgs = [];
-            if (!isNMSCDeployed) {
+            if (!isUEADeployed) {
                 /**
-                 * @dev - fee should be locked for NMSC deployment to avoid spamming
+                 * @dev - fee should be locked for UEA deployment to avoid spamming
                  */
                 if (!feeLockTxHash) {
-                    throw new Error('NMSC cannot be deployed without fee locking');
+                    throw new Error('UEA cannot be deployed without fee locking');
                 }
-                msgs.push(this.pushClient.createMsgDeployNMSC({
+                msgs.push(this.pushClient.createMsgDeployUEA({
                     signer,
-                    accountId,
+                    universalAccount,
                     txHash: feeLockTxHash,
                 }));
             }
             if (feeLockTxHash) {
-                msgs.push(this.pushClient.createMsgMintPush({
+                msgs.push(this.pushClient.createMsgMintPC({
                     signer,
-                    accountId,
+                    universalAccount,
                     txHash: feeLockTxHash,
                 }));
             }
-            if (crosschainPayload && signature) {
+            if (universalPayload && signature) {
                 msgs.push(this.pushClient.createMsgExecutePayload({
                     signer,
-                    accountId,
-                    crosschainPayload,
+                    universalAccount,
+                    universalPayload,
                     signature: (0, viem_1.bytesToHex)(signature),
                 }));
             }
             const txBody = yield this.pushClient.createCosmosTxBody(msgs);
             const txRaw = yield this.pushClient.signCosmosTx(txBody);
-            const txresponse = yield this.pushClient.broadcastCosmosTx(txRaw);
-            if (txresponse.code === 0) {
-                return txresponse.transactionHash;
-            }
-            else {
-                throw new Error(txresponse.rawLog);
-            }
+            return this.pushClient.broadcastCosmosTx(txRaw);
         });
     }
     /**
-     * Checks if the given chain belongs to the Push Chain ecosystem.
-     * Used to differentiate logic for Push-native interactions vs external chains.
-     *
-     * @param chain - The chain identifier (e.g., PUSH_MAINNET, PUSH_TESTNET_DONUT)
-     * @returns True if the chain is a Push chain, false otherwise.
-     */
-    isPushChain(chain) {
-        return (chain === enums_1.CHAIN.PUSH_MAINNET ||
-            chain === enums_1.CHAIN.PUSH_TESTNET_DONUT ||
-            chain === enums_1.CHAIN.PUSH_LOCALNET);
-    }
-    /**
-     * Computes the EIP-712 digest hash for the CrossChainPayload structure.
+     * Computes the EIP-712 digest hash for the UniversalPayload structure.
      * This is the message that should be signed by the user's wallet (e.g., Solana signer).
      *
      * The resulting hash is equivalent to:
      * keccak256("\x19\x01" || domainSeparator || structHash)
      *
      * @param chainId - EVM chain ID of the destination chain (Push Chain)
-     * @param verifyingContract - Address of the verifying contract (i.e., the user's NMSC smart wallet)
+     * @param verifyingContract - Address of the verifying contract (i.e., the user's UEA smart wallet)
      * @param version - Optional EIP-712 domain version (default: '0.1.0')
-     * @param payload - Execution details encoded into the CrossChainPayload struct
+     * @param payload - Execution details encoded into the UniversalPayload struct
      * @returns keccak256 digest to be signed by the user
      */
     computeExecutionHash({ chainId = Number(this.pushClient.pushChainInfo.chainId), verifyingContract, payload, version = '0.1.0', }) {
-        // 1. Hash the type signature
-        const typeHash = (0, viem_1.keccak256)((0, viem_1.toBytes)('CrossChainPayload(address target,uint256 value,bytes data,uint256 gasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,uint256 nonce,uint256 deadline)'));
+        // 1. Type hash
+        const typeHash = (0, viem_1.keccak256)((0, viem_1.toBytes)('UniversalPayload(address to,uint256 value,bytes data,uint256 gasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,uint256 nonce,uint256 deadline,uint8 sigType)'));
         // 2. Domain separator
         const domainTypeHash = (0, viem_1.keccak256)((0, viem_1.toBytes)('EIP712Domain(string version,uint256 chainId,address verifyingContract)'));
         const domainSeparator = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
@@ -392,7 +320,7 @@ class Orchestrator {
         // 3. Struct hash
         const structHash = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
             { name: 'typeHash', type: 'bytes32' },
-            { name: 'target', type: 'address' },
+            { name: 'to', type: 'address' },
             { name: 'value', type: 'uint256' },
             { name: 'dataHash', type: 'bytes32' },
             { name: 'gasLimit', type: 'uint256' },
@@ -400,59 +328,52 @@ class Orchestrator {
             { name: 'maxPriorityFeePerGas', type: 'uint256' },
             { name: 'nonce', type: 'uint256' },
             { name: 'deadline', type: 'uint256' },
+            { name: 'sigType', type: 'uint8' },
         ], [
             typeHash,
-            payload.target,
-            payload.value,
+            payload.to,
+            BigInt(payload.value),
             (0, viem_1.keccak256)(payload.data),
-            payload.gasLimit,
-            payload.maxFeePerGas,
-            payload.maxPriorityFeePerGas,
-            payload.nonce,
-            payload.deadline,
+            BigInt(payload.gasLimit),
+            BigInt(payload.maxFeePerGas),
+            BigInt(payload.maxPriorityFeePerGas),
+            BigInt(payload.nonce),
+            BigInt(payload.deadline),
+            payload.sigType,
         ]));
-        // 4. Final digest: keccak256("\x19\x01" || domainSeparator || structHash)
-        const digest = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string', 'bytes32', 'bytes32'], ['\x19\x01', domainSeparator, structHash]));
-        return digest;
+        // 4. Final digest
+        return (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string', 'bytes32', 'bytes32'], ['\x19\x01', domainSeparator, structHash]));
     }
     /**
-     * Computes the smart wallet (NMSC) on Push Chain.
+     * Computes UEA for given UniversalAccount
+     * @dev - This fn calls a view fn of Factory Contract
+     * @returns UEA Address with Deployment Status
      */
-    // TODO: DON'T CALL THIS FUNCTION FOR .ADDRESS. MAKE FUNCTION SYNC.
-    // TODO: CREATE ANOTHER FUNCTION TO CHECK IF NMSC IS DEPLOYED.
-    getNMSCAddress() {
+    computeUEA() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const { chain, address } = this.universalSigner.account;
-            const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+            const { vm } = chain_1.CHAIN_INFO[chain];
             if (this.isPushChain(chain)) {
-                throw new Error('NMSC address cannot be computed for a Push Chain Address');
+                throw new Error('UEA cannot be computed for a Push Chain Address');
             }
             const computedAddress = yield this.pushClient.readContract({
                 address: this.pushClient.pushChainInfo.factoryAddress,
                 abi: abi_1.FACTORY_V1,
-                functionName: 'computeSmartAccountAddress',
+                functionName: 'computeUEA',
                 args: [
                     {
-                        namespace: chain_1.VM_NAMESPACE[vm],
-                        chainId,
+                        chain,
                         /**
-                         * @dev - OwnerKey should be in bytes
+                         * @dev - Owner should be in bytes
                          * for eth - convert hex to bytes
                          * for sol - convert base64 to bytes
                          * for others - not defined yet
                          */
-                        ownerKey: vm === enums_1.VM.EVM
+                        owner: vm === enums_1.VM.EVM
                             ? address
                             : vm === enums_1.VM.SVM
                                 ? (0, viem_1.bytesToHex)(bytes_1.bs58.decode(address))
                                 : address,
-                        /**
-                         * @dev
-                         * 0 -> evm
-                         * 1 -> svm
-                         * Rest are not defined
-                         */
-                        vmType: vm === enums_1.VM.EVM ? 0 : vm === enums_1.VM.SVM ? 1 : 2,
                     },
                 ],
             });
@@ -462,57 +383,55 @@ class Orchestrator {
             return { address: computedAddress, deployed: byteCode !== undefined };
         });
     }
-    // TODO: Convert to viem
-    calculateUEAOffchain() {
+    computeUEAOffchain() {
         const { chain, address } = this.universalSigner.account;
-        const { vm, implementationAddress, chainId } = chain_1.CHAIN_INFO[chain];
+        const { implementationAddress } = chain_1.CHAIN_INFO[chain];
+        // If already an on-chain Push EOA, just return it
         if (this.isPushChain(chain)) {
             return address;
         }
+        // 1) Figure out the external‐chain ownerKey bytes
         let ownerKey;
-        if (vm === enums_1.VM.EVM) {
+        if (chain_1.CHAIN_INFO[chain].vm === enums_1.VM.EVM) {
             ownerKey = address;
         }
-        else if (vm === enums_1.VM.SVM) {
+        else if (chain_1.CHAIN_INFO[chain].vm === enums_1.VM.SVM) {
             ownerKey = (0, viem_1.bytesToHex)(bytes_1.bs58.decode(address));
         }
         else {
-            throw new Error(`Unsupported VM type: ${vm}`);
+            throw new Error(`Unsupported VM type: ${chain_1.CHAIN_INFO[chain].vm}`);
         }
-        const accountId = {
-            namespace: chain_1.VM_NAMESPACE[vm],
-            chainId,
-            ownerKey,
-            vmType: vm === enums_1.VM.EVM ? 0 : vm === enums_1.VM.SVM ? 1 : 2,
-        };
-        // Step 1: Recreate the salt: keccak256(abi.encode(AccountId))
-        const abiCoder = ethers_1.AbiCoder.defaultAbiCoder();
-        const encodedAccountId = abiCoder.encode(['tuple(string namespace,string chainId,bytes ownerKey,uint8 vmType)'], [
-            [
-                accountId.namespace,
-                accountId.chainId,
-                accountId.ownerKey,
-                accountId.vmType,
-            ],
-        ]);
-        const salt = ethers_1.ethers.keccak256(encodedAccountId);
+        // Step 1: Recreate the salt: keccak256(abi.encode(UniversalAccount))
+        const encodedAccountId = (0, viem_1.encodeAbiParameters)([
+            {
+                type: 'tuple',
+                components: [
+                    { name: 'chain', type: 'string' },
+                    { name: 'owner', type: 'bytes' },
+                ],
+            },
+        ], [{ chain, owner: ownerKey }]);
+        const salt = (0, viem_1.keccak256)(encodedAccountId);
         // Step 2: Clone Minimal Proxy bytecode
-        const minimalProxyRuntimeCode = '0x3d602d80600a3d3981f3' +
+        const minimalProxyRuntimeCode = ('0x3d602d80600a3d3981f3' +
             '363d3d373d3d3d363d73' +
             implementationAddress.toLowerCase().replace(/^0x/, '') +
-            '5af43d82803e903d91602b57fd5bf3';
+            '5af43d82803e903d91602b57fd5bf3');
         // Step 3: Get init code hash (used by CREATE2)
-        const initCodeHash = ethers_1.ethers.keccak256(minimalProxyRuntimeCode);
+        const initCodeHash = (0, viem_1.keccak256)(minimalProxyRuntimeCode);
         // Step 4: Predict the address using standard CREATE2 formula
-        const predictedAddress = ethers_1.ethers.getCreate2Address(this.pushClient.pushChainInfo.factoryAddress, salt, initCodeHash);
-        return predictedAddress;
+        return (0, viem_1.getCreate2Address)({
+            from: this.pushClient.pushChainInfo.factoryAddress,
+            salt,
+            bytecodeHash: initCodeHash,
+        });
     }
     /**
      * @dev - Although as of now nonce var is same in evm & svm so switch conditions does not matter
-     * @param address NMSC address
-     * @returns NMSC current nonce
+     * @param address UEA address
+     * @returns UEA current nonce
      */
-    getNMSCNonce(address) {
+    getUEANonce(address) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const chain = this.universalSigner.account.chain;
             const { vm } = chain_1.CHAIN_INFO[chain];
@@ -520,14 +439,14 @@ class Orchestrator {
                 case enums_1.VM.EVM: {
                     return this.pushClient.readContract({
                         address,
-                        abi: abi_1.SMART_ACCOUNT_EVM,
+                        abi: abi_1.UEA_EVM,
                         functionName: 'nonce',
                     });
                 }
                 case enums_1.VM.SVM: {
                     return this.pushClient.readContract({
                         address,
-                        abi: abi_1.SMART_ACCOUNT_SVM,
+                        abi: abi_1.UEA_SVM,
                         functionName: 'nonce',
                     });
                 }
@@ -537,6 +456,7 @@ class Orchestrator {
             }
         });
     }
+    // TODO: Fix this fn - It needs to get UOA for a given UEA
     getUOA() {
         return {
             chain: this.universalSigner.account.chain,
@@ -566,6 +486,38 @@ class Orchestrator {
             }
         });
     }
+    /********************************** HELPER FUNCTIONS **************************************************/
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    bigintReplacer(_key, value) {
+        return typeof value === 'bigint'
+            ? value.toString() // convert BigInt to string
+            : value;
+    }
+    /**
+     * Checks if the given chain belongs to the Push Chain ecosystem.
+     * Used to differentiate logic for Push-native interactions vs external chains.
+     *
+     * @param chain - The chain identifier (e.g., PUSH_MAINNET, PUSH_TESTNET_DONUT)
+     * @returns True if the chain is a Push chain, false otherwise.
+     */
+    isPushChain(chain) {
+        return (chain === enums_1.CHAIN.PUSH_MAINNET ||
+            chain === enums_1.CHAIN.PUSH_TESTNET_DONUT ||
+            chain === enums_1.CHAIN.PUSH_LOCALNET);
+    }
+    validateMainnetConnection(chain) {
+        const isMainnet = [enums_1.CHAIN.ETHEREUM_MAINNET, enums_1.CHAIN.SOLANA_MAINNET].includes(chain);
+        if (isMainnet &&
+            this.pushClient.pushChainInfo.chainId !==
+                chain_1.CHAIN_INFO[enums_1.CHAIN.PUSH_MAINNET].chainId) {
+            throw new Error('Mainnet chains can only interact with Push Mainnet');
+        }
+    }
+    printLog(log) {
+        if (this.printTraces) {
+            console.log(`[${this.constructor.name}] ${log}`);
+        }
+    }
 }
 exports.Orchestrator = Orchestrator;
 //# sourceMappingURL=orchestrator.js.map