@pushchain/core 4.0.14-alpha.0 → 5.1.0

package/src/lib/orchestrator/orchestrator.js

@@ -8,8 +8,12 @@ const viem_1 = require("viem");
 const abi_1 = require("../constants/abi");
 const uea_evm_1 = require("../constants/abi/uea.evm");
 const chain_1 = require("../constants/chain");
+const uea_factory_1 = require("../constants/abi/uea-factory");
 const enums_1 = require("../constants/enums");
 const tokens_1 = require("../constants/tokens");
+const types_1 = require("../generated/uexecutor/v1/types");
+const types_2 = require("../generated/uexecutor/v2/types");
+const orchestrator_types_1 = require("./orchestrator.types");
 const tx_1 = require("../generated/v1/tx");
 const price_fetch_1 = require("../price-fetch/price-fetch");
 const progress_hook_1 = tslib_1.__importDefault(require("../progress-hook/progress-hook"));
@@ -20,6 +24,9 @@ const push_client_1 = require("../push-client/push-client");
 const evm_client_1 = require("../vm-client/evm-client");
 const svm_client_1 = require("../vm-client/svm-client");
 const payload_builders_1 = require("./payload-builders");
+const route_detector_1 = require("./route-detector");
+const cea_utils_1 = require("./cea-utils");
+const selectors_1 = require("../constants/selectors");
 class Orchestrator {
     constructor(universalSigner, pushNetwork, rpcUrls = {}, printTraces = false, progressHook) {
         this.universalSigner = universalSigner;
@@ -27,6 +34,13 @@ class Orchestrator {
         this.rpcUrls = rpcUrls;
         this.printTraces = printTraces;
         this.progressHook = progressHook;
+        this.accountStatusCache = null;
+        /**
+         * Per-chain cache for detected gateway version (v0 or v1).
+         * Populated on first successful gateway tx per chain via try-V1-then-V0 fallback.
+         * TODO: Remove this cache + fallback logic once all chains are upgraded to V1.
+         */
+        this.gatewayVersionCache = new Map();
         let pushChain;
         if (pushNetwork === enums_1.PUSH_NETWORK.MAINNET) {
             pushChain = enums_1.CHAIN.PUSH_MAINNET;
@@ -43,6 +57,9 @@ class Orchestrator {
             rpcUrls: pushChainRPCs,
             network: pushNetwork,
         });
+        // BNB is already upgraded to V1 — pre-seed the cache so it never falls back to V0.
+        // TODO: Remove these entries once all chains are upgraded to V1.
+        this.gatewayVersionCache.set(enums_1.CHAIN.BNB_TESTNET, 'v1');
     }
     /**
      * Read-only accessors for current Orchestrator configuration
@@ -59,12 +76,242 @@ class Orchestrator {
     getProgressHook() {
         return this.progressHook;
     }
+    // =========================================================================
+    // Account Status & UEA Upgrade
+    // =========================================================================
     /**
-     * Executes an interaction on Push Chain
+     * Fetches account status including UEA deployment state and version info.
+     * Results are cached — pass forceRefresh to bypass cache.
      */
-    execute(execute) {
+    getAccountStatus(options) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+            if (this.accountStatusCache && !(options === null || options === void 0 ? void 0 : options.forceRefresh)) {
+                return this.accountStatusCache;
+            }
+            const chain = this.universalSigner.account.chain;
+            const { vm } = chain_1.CHAIN_INFO[chain];
+            const isReadOnly = false; // This is called from Orchestrator which always has a signer
+            const { deployed } = yield this.getUeaStatusAndNonce();
+            if (!deployed) {
+                const status = {
+                    mode: 'signer',
+                    uea: {
+                        loaded: true,
+                        deployed: false,
+                        version: '',
+                        minRequiredVersion: '',
+                        requiresUpgrade: false,
+                    },
+                };
+                this.accountStatusCache = status;
+                return status;
+            }
+            // Fetch current version and latest version from factory in parallel
+            const [currentVersion, minRequiredVersion] = yield Promise.all([
+                this.fetchUEAVersion(),
+                this.fetchLatestUEAVersion(vm),
+            ]);
+            const requiresUpgrade = (0, orchestrator_types_1.parseUEAVersion)(currentVersion) < (0, orchestrator_types_1.parseUEAVersion)(minRequiredVersion);
+            const status = {
+                mode: 'signer',
+                uea: {
+                    loaded: true,
+                    deployed: true,
+                    version: currentVersion,
+                    minRequiredVersion,
+                    requiresUpgrade,
+                },
+            };
+            this.accountStatusCache = status;
+            return status;
+        });
+    }
+    /**
+     * Upgrades the UEA to the latest implementation version.
+     * Sends MsgMigrateUEA Cosmos message with EIP-712 signed MigrationPayload.
+     * The UEA contract delegates to the UEAMigration contract to update implementation.
+     */
+    upgradeAccount(options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const hook = (options === null || options === void 0 ? void 0 : options.progressHook) || this.progressHook;
+            const fireHook = (hookId, ...args) => {
+                const hookEntry = progress_hook_1.default[hookId];
+                if (hookEntry && hook) {
+                    hook(hookEntry(...args));
+                }
+            };
+            // Step 1: Check status
+            fireHook(progress_hook_types_1.PROGRESS_HOOK.UEA_MIG_01);
+            const status = yield this.getAccountStatus({ forceRefresh: true });
+            if (!status.uea.requiresUpgrade) {
+                fireHook(progress_hook_types_1.PROGRESS_HOOK.UEA_MIG_9903);
+                return;
+            }
+            // Step 2: Awaiting signature
+            fireHook(progress_hook_types_1.PROGRESS_HOOK.UEA_MIG_02);
+            try {
+                const { chain, address } = this.universalSigner.account;
+                const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+                const ueaAddress = this.computeUEAOffchain();
+                const migrationContractAddress = chain_1.UEA_MIGRATION[this.pushNetwork];
+                if (!migrationContractAddress || migrationContractAddress === '0xTBD') {
+                    throw new Error('UEA migration contract address not configured');
+                }
+                // Read UEA nonce
+                const { nonce } = yield this.getUeaStatusAndNonce();
+                const deadline = BigInt(9999999999);
+                const ueaVersion = status.uea.version || '0.1.0';
+                // Sign MigrationPayload via EIP-712
+                if (!this.universalSigner.signTypedData) {
+                    throw new Error('signTypedData not available on signer');
+                }
+                const signatureBytes = yield this.universalSigner.signTypedData({
+                    domain: {
+                        version: ueaVersion,
+                        chainId: Number(chainId),
+                        verifyingContract: ueaAddress,
+                    },
+                    types: {
+                        MigrationPayload: [
+                            { name: 'migration', type: 'address' },
+                            { name: 'nonce', type: 'uint256' },
+                            { name: 'deadline', type: 'uint256' },
+                        ],
+                    },
+                    primaryType: 'MigrationPayload',
+                    message: {
+                        migration: migrationContractAddress,
+                        nonce,
+                        deadline,
+                    },
+                });
+                const signature = (0, viem_1.bytesToHex)(signatureBytes);
+                // Build Cosmos message
+                fireHook(progress_hook_types_1.PROGRESS_HOOK.UEA_MIG_03);
+                const universalAccountId = {
+                    chainNamespace: chain_1.VM_NAMESPACE[vm],
+                    chainId,
+                    owner: vm === enums_1.VM.EVM
+                        ? address
+                        : vm === enums_1.VM.SVM
+                            ? (0, viem_1.bytesToHex)(new Uint8Array(anchor_1.utils.bytes.bs58.decode(address)))
+                            : address,
+                };
+                const { cosmosAddress: signer } = this.pushClient.getSignerAddress();
+                const msg = this.pushClient.createMsgMigrateUEA({
+                    signer,
+                    universalAccountId,
+                    migrationPayload: {
+                        migration: migrationContractAddress,
+                        nonce: nonce.toString(),
+                        deadline: deadline.toString(),
+                    },
+                    signature,
+                });
+                const txBody = yield this.pushClient.createCosmosTxBody([msg]);
+                const txRaw = yield this.pushClient.signCosmosTx(txBody);
+                const tx = yield this.pushClient.broadcastCosmosTx(txRaw);
+                if (tx.code !== 0) {
+                    throw new Error(tx.rawLog || 'UEA migration transaction failed');
+                }
+                // Clear version cache so next read picks up new version
+                this.ueaVersionCache = undefined;
+                // Refresh account status
+                const updated = yield this.getAccountStatus({ forceRefresh: true });
+                fireHook(progress_hook_types_1.PROGRESS_HOOK.UEA_MIG_9901, updated.uea.version);
+            }
+            catch (err) {
+                fireHook(progress_hook_types_1.PROGRESS_HOOK.UEA_MIG_9902);
+                throw err;
+            }
+        });
+    }
+    /**
+     * Fetches the latest UEA version from UEAFactory contract.
+     * This is the version of the newest registered implementation — used as minRequiredVersion.
+     * Returns empty string if factory is unavailable.
+     */
+    fetchLatestUEAVersion(vm) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const factoryAddress = chain_1.UEA_FACTORY[this.pushNetwork];
+            if (!factoryAddress || factoryAddress === '0xTBD') {
+                return '';
+            }
+            try {
+                const vmHash = vm === enums_1.VM.EVM
+                    ? (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'string' }], ['EVM']))
+                    : (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'string' }], ['SVM']));
+                return yield this.pushClient.readContract({
+                    address: factoryAddress,
+                    abi: uea_factory_1.UEA_FACTORY_ABI,
+                    functionName: 'UEA_VERSION',
+                    args: [vmHash],
+                });
+            }
+            catch (_a) {
+                return '';
+            }
+        });
+    }
+    /**
+     * Migrate the CEA contract on an external chain to the latest version.
+     * Sends a MIGRATION_SELECTOR payload via Route 2 to trigger CEA upgrade.
+     *
+     * @param chain - The external chain where the CEA should be migrated
+     * @returns Transaction response
+     */
+    migrateCEA(chain) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.isPushChain(chain)) {
+                throw new Error('Cannot migrate CEA on Push Chain');
+            }
+            if (!(0, cea_utils_1.chainSupportsCEA)(chain)) {
+                throw new Error(`Chain ${chain} does not support CEA`);
+            }
+            const ueaAddress = this.computeUEAOffchain();
+            const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, chain, (_a = this.rpcUrls[chain]) === null || _a === void 0 ? void 0 : _a[0]);
+            if (!isDeployed) {
+                throw new Error(`CEA not deployed on chain ${chain}. Deploy CEA first.`);
+            }
+            return this.execute({
+                to: { address: cea, chain },
+                migration: true,
+            });
+        });
+    }
+    /**
+     * Executes a transaction with automatic route detection.
+     *
+     * Supports both simple Push Chain transactions and multi-chain routing:
+     * - Route 1 (UOA_TO_PUSH): `to` is a simple address string
+     * - Route 2 (UOA_TO_CEA): `to` is `{ address, chain }` targeting external chain
+     * - Route 3 (CEA_TO_PUSH): `from.chain` specified, targeting Push Chain
+     * - Route 4 (CEA_TO_CEA): `from.chain` specified, targeting external chain
+     *
+     * @param params - ExecuteParams or UniversalExecuteParams
+     * @returns Transaction response
+     */
+    execute(params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+            // Lazy UEA upgrade check
+            if (!this.accountStatusCache || !this.accountStatusCache.uea.loaded) {
+                yield this.getAccountStatus();
+            }
+            if (((_a = this.accountStatusCache) === null || _a === void 0 ? void 0 : _a.uea.deployed) &&
+                ((_b = this.accountStatusCache) === null || _b === void 0 ? void 0 : _b.uea.requiresUpgrade)) {
+                yield this.upgradeAccount({ progressHook: this.progressHook });
+            }
+            // Check if this is a multi-chain request (has ChainTarget or from.chain)
+            const isMultiChain = (0, route_detector_1.isChainTarget)(params.to) || ('from' in params && ((_c = params.from) === null || _c === void 0 ? void 0 : _c.chain));
+            if (isMultiChain) {
+                // sendTransaction delegates to prepareTransaction().send() for multi-chain routes
+                const prepared = yield this.prepareTransaction(params);
+                return prepared.send();
+            }
+            // Standard Push Chain execution (Route 1)
+            const execute = params;
             // Create buffer to collect events during execution for tx.progressHook() replay
             const eventBuffer = [];
             // Store original progressHook and wrap to collect events
@@ -186,14 +433,7 @@ class Orchestrator {
                                         isNative, bridgeAmount: bridgeAmount.toString(),
                                         nativeAmount: nativeAmount.toString(), bridgeToken,
                                     }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2));
-                                    txHash = yield evmClient.writeContract({
-                                        abi: abi_1.UNIVERSAL_GATEWAY_V0,
-                                        address: gatewayAddress,
-                                        functionName: 'sendUniversalTx',
-                                        args: [req],
-                                        signer: this.universalSigner,
-                                        value: isNative ? nativeAmount + bridgeAmount : nativeAmount,
-                                    });
+                                    txHash = yield this.sendGatewayTxWithFallback(evmClient, gatewayAddress, req, this.universalSigner, isNative ? nativeAmount + bridgeAmount : nativeAmount);
                                 }
                                 else {
                                     // FUNDS ONLY OTHER
@@ -214,14 +454,7 @@ class Orchestrator {
                                         isNative, bridgeAmount: bridgeAmount.toString(),
                                         nativeAmount: nativeAmount.toString(), bridgeToken,
                                     }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2));
-                                    txHash = yield evmClient.writeContract({
-                                        abi: abi_1.UNIVERSAL_GATEWAY_V0,
-                                        address: gatewayAddress,
-                                        functionName: 'sendUniversalTx',
-                                        args: [req],
-                                        signer: this.universalSigner,
-                                        value: isNative ? nativeAmount + bridgeAmount : nativeAmount,
-                                    });
+                                    txHash = yield this.sendGatewayTxWithFallback(evmClient, gatewayAddress, req, this.universalSigner, isNative ? nativeAmount + bridgeAmount : nativeAmount);
                                 }
                             }
                             catch (err) {
@@ -240,14 +473,14 @@ class Orchestrator {
                                 evmGatewayMethod: execute.to === ueaAddress ? 'sendFunds' : 'sendTxWithFunds',
                             }));
                             const pushChainUniversalTx = yield this.queryUniversalTxStatusFromGatewayTx(evmClient, gatewayAddress, txHash, execute.to === ueaAddress ? 'sendFunds' : 'sendTxWithFunds');
-                            if (!((_a = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _a === void 0 ? void 0 : _a.length)) {
+                            if (!((_d = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _d === void 0 ? void 0 : _d.length)) {
                                 throw new Error(`Failed to retrieve Push Chain transaction status for gateway tx: ${txHash}. ` +
                                     `The transaction may have failed on Push Chain or not been indexed yet.`);
                             }
                             // For sendFunds operations, MintPC (first) succeeds and executePayload (second) may fail
                             // Always use the last pcTx entry as it represents the final execution result
                             const lastPcTransaction = pushChainUniversalTx.pcTx.at(-1);
-                            this.printLog('sendFunds — pushChainUniversalTx pcTx: ' + JSON.stringify((_b = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _b === void 0 ? void 0 : _b.map((p) => ({ txHash: p.txHash, status: p.status, errorMsg: p.errorMsg })), null, 2));
+                            this.printLog('sendFunds — pushChainUniversalTx pcTx: ' + JSON.stringify((_e = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _e === void 0 ? void 0 : _e.map((p) => ({ txHash: p.txHash, status: p.status, errorMsg: p.errorMsg })), null, 2));
                             this.printLog('sendFunds — using lastPcTransaction: ' + JSON.stringify(lastPcTransaction, null, 2));
                             if (!(lastPcTransaction === null || lastPcTransaction === void 0 ? void 0 : lastPcTransaction.txHash)) {
                                 // Check for error messages in failed entries
@@ -270,7 +503,7 @@ class Orchestrator {
                             const programId = new web3_js_1.PublicKey(abi_1.SVM_GATEWAY_IDL.address);
                             const [configPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('config')], programId);
                             const [vaultPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('vault')], programId);
-                            const [whitelistPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('whitelist')], programId);
+                            const { feeVaultPda, protocolFeeLamports } = yield this._getSvmProtocolFee(svmClient, programId);
                             const [rateLimitConfigPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit_config')], programId);
                             const userPk = new web3_js_1.PublicKey(this.universalSigner.account.address);
                             const priceUpdatePk = new web3_js_1.PublicKey('7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE');
@@ -279,11 +512,6 @@ class Orchestrator {
                                 throw new Error('Pay-with token is not supported on Solana');
                             }
                             let txSignature;
-                            // SVM-specific RevertSettings: bytes must be a Buffer
-                            const revertSvm = {
-                                fundRecipient: userPk,
-                                revertMsg: Buffer.from([]),
-                            };
                             // New gateway expects EVM recipient as [u8; 20]
                             const recipientEvm20 = Array.from(Buffer.from(execute.to.slice(2).padStart(40, '0'), 'hex').subarray(0, 20));
                             this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_01);
@@ -298,18 +526,19 @@ class Orchestrator {
                                     token: web3_js_1.PublicKey.default,
                                     amount: bridgeAmount,
                                     payload: '0x',
-                                    fundRecipient: userPk,
+                                    revertRecipient: userPk,
                                     signatureData: '0x',
                                 });
                                 txSignature = yield svmClient.writeContract({
                                     abi: abi_1.SVM_GATEWAY_IDL,
                                     address: programId.toBase58(),
                                     functionName: 'sendUniversalTx',
-                                    args: [reqNative, bridgeAmount],
+                                    args: [reqNative, bridgeAmount + protocolFeeLamports],
                                     signer: this.universalSigner,
                                     accounts: {
                                         config: configPda,
                                         vault: vaultPda,
+                                        feeVault: feeVaultPda,
                                         userTokenAccount: vaultPda,
                                         gatewayTokenAccount: vaultPda,
                                         user: userPk,
@@ -344,18 +573,19 @@ class Orchestrator {
                                         token: mintPk,
                                         amount: bridgeAmount,
                                         payload: '0x',
-                                        fundRecipient: userPk,
+                                        revertRecipient: userPk,
                                         signatureData: '0x',
                                     });
                                     txSignature = yield svmClient.writeContract({
                                         abi: abi_1.SVM_GATEWAY_IDL,
                                         address: programId.toBase58(),
                                         functionName: 'sendUniversalTx',
-                                        args: [reqSpl, BigInt(0)],
+                                        args: [reqSpl, protocolFeeLamports],
                                         signer: this.universalSigner,
                                         accounts: {
                                             config: configPda,
                                             vault: vaultPda,
+                                            feeVault: feeVaultPda,
                                             userTokenAccount: userAta,
                                             gatewayTokenAccount: vaultAta,
                                             user: userPk,
@@ -375,18 +605,19 @@ class Orchestrator {
                                         token: mintPk,
                                         amount: bridgeAmount,
                                         payload: '0x',
-                                        fundRecipient: userPk,
+                                        revertRecipient: userPk,
                                         signatureData: '0x',
                                     });
                                     txSignature = yield svmClient.writeContract({
                                         abi: abi_1.SVM_GATEWAY_IDL,
                                         address: programId.toBase58(),
                                         functionName: 'sendUniversalTx',
-                                        args: [reqSpl, BigInt(0)],
+                                        args: [reqSpl, protocolFeeLamports],
                                         signer: this.universalSigner,
                                         accounts: {
                                             config: configPda,
                                             vault: vaultPda,
+                                            feeVault: feeVaultPda,
                                             userTokenAccount: userAta,
                                             gatewayTokenAccount: vaultAta,
                                             user: userPk,
@@ -411,7 +642,7 @@ class Orchestrator {
                             this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_05);
                             // After origin confirmations, query Push Chain for UniversalTx status (SVM)
                             const pushChainUniversalTx = yield this.queryUniversalTxStatusFromGatewayTx(undefined, undefined, txSignature, 'sendFunds');
-                            if (!((_c = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _c === void 0 ? void 0 : _c.length)) {
+                            if (!((_f = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _f === void 0 ? void 0 : _f.length)) {
                                 throw new Error(`Failed to retrieve Push Chain transaction status for gateway tx: ${txSignature}. ` +
                                     `The transaction may have failed on Push Chain or not been indexed yet.`);
                             }
@@ -459,7 +690,7 @@ class Orchestrator {
                         const gasEstimate = execute.gasLimit || BigInt(1e7);
                         const gasPrice = yield this.pushClient.getGasPrice();
                         const requiredGasFee = gasEstimate * gasPrice;
-                        const payloadValue = (_d = execute.value) !== null && _d !== void 0 ? _d : BigInt(0);
+                        const payloadValue = (_g = execute.value) !== null && _g !== void 0 ? _g : BigInt(0);
                         const requiredFunds = requiredGasFee + payloadValue;
                         const ueaAddress = this.computeUEAOffchain();
                         const [ueaBalance] = yield Promise.all([
@@ -492,8 +723,8 @@ class Orchestrator {
                                     functionName: 'config',
                                     args: [configPda.toBase58()],
                                 });
-                                const minField = (_e = cfg.minCapUniversalTxUsd) !== null && _e !== void 0 ? _e : cfg.min_cap_universal_tx_usd;
-                                const maxField = (_f = cfg.maxCapUniversalTxUsd) !== null && _f !== void 0 ? _f : cfg.max_cap_universal_tx_usd;
+                                const minField = (_h = cfg.minCapUniversalTxUsd) !== null && _h !== void 0 ? _h : cfg.min_cap_universal_tx_usd;
+                                const maxField = (_j = cfg.maxCapUniversalTxUsd) !== null && _j !== void 0 ? _j : cfg.max_cap_universal_tx_usd;
                                 const minCapUsd = BigInt(minField.toString());
                                 const maxCapUsd = BigInt(maxField.toString());
                                 if (depositUsd < minCapUsd)
@@ -505,7 +736,7 @@ class Orchestrator {
                                 if (depositUsd > maxCapUsd)
                                     depositUsd = maxCapUsd;
                             }
-                            catch (_q) {
+                            catch (_t) {
                                 // best-effort; fallback to previous bounds if read fails
                             }
                         }
@@ -556,7 +787,7 @@ class Orchestrator {
                                 // New behavior: if user provided a gasTokenAddress, pay gas in that token via Uniswap quote
                                 // Determine pay-with token address, min-out and slippage
                                 const payWith = execute.payGasWith;
-                                const gasTokenAddress = (_g = payWith === null || payWith === void 0 ? void 0 : payWith.token) === null || _g === void 0 ? void 0 : _g.address;
+                                const gasTokenAddress = (_k = payWith === null || payWith === void 0 ? void 0 : payWith.token) === null || _k === void 0 ? void 0 : _k.address;
                                 if (gasTokenAddress) {
                                     if (chain !== enums_1.CHAIN.ETHEREUM_SEPOLIA) {
                                         throw new Error(`Only ${push_chain_1.PushChain.utils.chains.getChainName(enums_1.CHAIN.ETHEREUM_SEPOLIA)} is supported for paying gas fees with ERC-20 tokens`);
@@ -564,7 +795,7 @@ class Orchestrator {
                                     let amountOutMinETH = (payWith === null || payWith === void 0 ? void 0 : payWith.minAmountOut) !== undefined
                                         ? BigInt(payWith.minAmountOut)
                                         : nativeAmount;
-                                    const slippageBps = (_h = payWith === null || payWith === void 0 ? void 0 : payWith.slippageBps) !== null && _h !== void 0 ? _h : 100;
+                                    const slippageBps = (_l = payWith === null || payWith === void 0 ? void 0 : payWith.slippageBps) !== null && _l !== void 0 ? _l : 100;
                                     amountOutMinETH = BigInt(push_chain_1.PushChain.utils.conversion.slippageToMinAmount(amountOutMinETH.toString(), { slippageBps }));
                                     const { gasAmount } = yield this.calculateGasAmountFromAmountOutMinETH(gasTokenAddress, amountOutMinETH);
                                     const deadline = BigInt(0);
@@ -576,8 +807,8 @@ class Orchestrator {
                                         ownerAddress,
                                     });
                                     if (gasTokenBalance < gasAmount) {
-                                        const sym = (_k = (_j = payWith === null || payWith === void 0 ? void 0 : payWith.token) === null || _j === void 0 ? void 0 : _j.symbol) !== null && _k !== void 0 ? _k : 'gas token';
-                                        const decimals = (_m = (_l = payWith === null || payWith === void 0 ? void 0 : payWith.token) === null || _l === void 0 ? void 0 : _l.decimals) !== null && _m !== void 0 ? _m : 18;
+                                        const sym = (_o = (_m = payWith === null || payWith === void 0 ? void 0 : payWith.token) === null || _m === void 0 ? void 0 : _m.symbol) !== null && _o !== void 0 ? _o : 'gas token';
+                                        const decimals = (_q = (_p = payWith === null || payWith === void 0 ? void 0 : payWith.token) === null || _p === void 0 ? void 0 : _p.decimals) !== null && _q !== void 0 ? _q : 18;
                                         const needFmt = utils_1.Utils.helpers.formatUnits(gasAmount, decimals);
                                         const haveFmt = utils_1.Utils.helpers.formatUnits(gasTokenBalance, decimals);
                                         throw new Error(`Insufficient ${sym} balance to cover gas fees: need ${needFmt}, have ${haveFmt}`);
@@ -600,13 +831,7 @@ class Orchestrator {
                                     const reqToken = Object.assign(Object.assign({}, req), { gasToken: gasTokenAddress, gasAmount,
                                         amountOutMinETH,
                                         deadline });
-                                    txHash = yield evmClientEvm.writeContract({
-                                        abi: abi_1.UNIVERSAL_GATEWAY_V0,
-                                        address: gatewayAddressEvm,
-                                        functionName: 'sendUniversalTx',
-                                        args: [reqToken],
-                                        signer: this.universalSigner,
-                                    });
+                                    txHash = yield this.sendGatewayTokenTxWithFallback(evmClientEvm, gatewayAddressEvm, reqToken, this.universalSigner);
                                 }
                                 else {
                                     // Existing native-ETH value path
@@ -631,14 +856,7 @@ class Orchestrator {
                                     const totalValue = isNativeToken
                                         ? nativeAmount + bridgeAmount
                                         : nativeAmount;
-                                    txHash = yield evmClientEvm.writeContract({
-                                        abi: abi_1.UNIVERSAL_GATEWAY_V0,
-                                        address: gatewayAddressEvm,
-                                        functionName: 'sendUniversalTx',
-                                        args: [req],
-                                        signer: this.universalSigner,
-                                        value: totalValue,
-                                    });
+                                    txHash = yield this.sendGatewayTxWithFallback(evmClientEvm, gatewayAddressEvm, req, this.universalSigner, totalValue);
                                 }
                             }
                             else {
@@ -705,7 +923,7 @@ class Orchestrator {
                             pushChainUniversalTx =
                                 yield this.queryUniversalTxStatusFromGatewayTx(undefined, undefined, txHash, 'sendTxWithFunds');
                         }
-                        if (!((_o = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _o === void 0 ? void 0 : _o.length)) {
+                        if (!((_r = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _r === void 0 ? void 0 : _r.length)) {
                             throw new Error(`Failed to retrieve Push Chain transaction status for gateway tx: ${txHash}. ` +
                                 `The transaction may have failed on Push Chain or not been indexed yet.`);
                         }
@@ -752,17 +970,32 @@ class Orchestrator {
                 const requiredFunds = requiredGasFee + execute.value;
                 this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_02_02, requiredFunds);
                 /**
-                 * Fetch UEA Details
+                 * Fetch UEA Details (or use pre-fetched status if available)
                  */
-                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_01);
                 const UEA = this.computeUEAOffchain();
-                const [code, funds] = yield Promise.all([
-                    this.pushClient.publicClient.getCode({ address: UEA }),
-                    this.pushClient.getBalance(UEA),
-                ]);
-                const isUEADeployed = code !== undefined;
-                const nonce = isUEADeployed ? yield this.getUEANonce(UEA) : BigInt(0);
-                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_02, UEA, isUEADeployed);
+                let isUEADeployed;
+                let nonce;
+                let funds;
+                if (execute._ueaStatus) {
+                    // Use pre-fetched UEA status (from executeUoaToCea)
+                    isUEADeployed = execute._ueaStatus.isDeployed;
+                    nonce = execute._ueaStatus.nonce;
+                    funds = execute._ueaStatus.balance;
+                    this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_01);
+                    this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_02, UEA, isUEADeployed);
+                }
+                else {
+                    // Fetch UEA status from Push Chain RPC
+                    this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_01);
+                    const [code, balance] = yield Promise.all([
+                        this.pushClient.publicClient.getCode({ address: UEA }),
+                        this.pushClient.getBalance(UEA),
+                    ]);
+                    isUEADeployed = code !== undefined;
+                    nonce = isUEADeployed ? yield this.getUEANonce(UEA) : BigInt(0);
+                    funds = balance;
+                    this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_02, UEA, isUEADeployed);
+                }
                 /**
                  * Compute Universal Payload Hash
                  */
@@ -772,9 +1005,11 @@ class Orchestrator {
                     const decoded = anchor_1.utils.bytes.bs58.decode(feeLockTxHash);
                     feeLockTxHash = (0, viem_1.bytesToHex)(new Uint8Array(decoded));
                 }
-                // Fee locking is required if UEA is not deployed OR insufficient funds
-                const feeLockingRequired = (!isUEADeployed || funds < requiredFunds) && !feeLockTxHash;
-                // const feeLockingRequired = true;
+                // Fee locking is required if UEA is not deployed OR insufficient funds.
+                // Skip for outbound flows (UEA→CEA) — those execute on Push Chain and
+                // don't need external-chain fee locking.
+                const feeLockingRequired = !execute._skipFeeLocking &&
+                    (!isUEADeployed || funds < requiredFunds) && !feeLockTxHash;
                 // Support multicall payload encoding when execute.data is an array
                 let payloadData;
                 let payloadTo;
@@ -931,7 +1166,7 @@ class Orchestrator {
                      * Note: queryTx may be undefined since validators don't recognize new UniversalTx event yet
                      */
                     // Transform to UniversalTxResponse (follow sendFunds pattern)
-                    if (!((_p = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _p === void 0 ? void 0 : _p.length)) {
+                    if (!((_s = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _s === void 0 ? void 0 : _s.length)) {
                         throw new Error(`Failed to retrieve Push Chain transaction status for gateway tx: ${feeLockTxHash}. ` +
                             `The transaction may have failed on Push Chain or not been indexed yet.`);
                     }
@@ -967,19 +1202,2179 @@ class Orchestrator {
                             try {
                                 return JSON.stringify(err);
                             }
-                            catch (_a) {
-                                return 'Unknown error';
+                            catch (_a) {
+                                return 'Unknown error';
+                            }
+                        })();
+                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_02, errMessage);
+                throw err;
+            }
+            finally {
+                // Restore original progressHook
+                this.progressHook = originalHook;
+            }
+        });
+    }
+    // ============================================================================
+    // Multi-Chain Universal Transaction Methods
+    // ============================================================================
+    /**
+     * Executes a universal transaction with multi-chain routing support.
+     * Supports 4 routes:
+     * - Route 1: UOA → Push Chain (existing behavior)
+     * - Route 2: UOA → CEA (outbound to external chain)
+     * - Route 3: CEA → Push Chain (inbound from external chain)
+     * - Route 4: CEA → CEA (external chain to external chain via Push)
+     *
+     * @param params - Universal execution parameters with optional chain targets
+     * @returns UniversalTxResponse with chain information
+     */
+    /**
+     * Internal method for multi-chain transaction routing.
+     * Called by execute() when ChainTarget or from.chain is detected.
+     */
+    executeMultiChain(params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Validate route parameters
+            (0, route_detector_1.validateRouteParams)(params, {
+                clientChain: this.universalSigner.account.chain,
+            });
+            // Detect the transaction route
+            const route = (0, route_detector_1.detectRoute)(params);
+            this.printLog(`executeMultiChain — detected route: ${route}, params: ${JSON.stringify({
+                to: typeof params.to === 'string'
+                    ? params.to
+                    : { address: params.to.address, chain: params.to.chain },
+                from: params.from,
+                hasValue: params.value !== undefined,
+                hasData: params.data !== undefined,
+                hasFunds: params.funds !== undefined,
+            }, null, 2)}`);
+            let response;
+            switch (route) {
+                case route_detector_1.TransactionRoute.UOA_TO_PUSH:
+                    // Route 1: Standard Push Chain execution
+                    response = yield this.execute(this.toExecuteParams(params));
+                    break;
+                case route_detector_1.TransactionRoute.UOA_TO_CEA:
+                    // Route 2: Outbound to external chain via CEA
+                    response = yield this.executeUoaToCea(params);
+                    break;
+                case route_detector_1.TransactionRoute.CEA_TO_PUSH:
+                    // Route 3: Inbound from CEA to Push Chain
+                    response = yield this.executeCeaToPush(params);
+                    break;
+                case route_detector_1.TransactionRoute.CEA_TO_CEA:
+                    // Route 4: CEA to CEA via Push Chain
+                    response = yield this.executeCeaToCea(params);
+                    break;
+                default:
+                    throw new Error(`Unknown transaction route: ${route}`);
+            }
+            // Set the route on the response for .wait() to use
+            response.route = route;
+            return response;
+        });
+    }
+    /**
+     * Prepare a universal transaction without executing it.
+     * Returns a PreparedUniversalTx that can be chained with thenOn() or sent with send().
+     *
+     * @param params - Universal execution parameters
+     * @returns PreparedUniversalTx with chaining capabilities
+     */
+    prepareTransaction(params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            (0, route_detector_1.validateRouteParams)(params, {
+                clientChain: this.universalSigner.account.chain,
+            });
+            const route = (0, route_detector_1.detectRoute)(params);
+            const { nonce, deployed } = yield this.getUeaStatusAndNonce();
+            const ueaAddress = this.computeUEAOffchain();
+            // Build the payload based on route
+            const { payload, gatewayRequest } = yield this.buildPayloadForRoute(params, route, nonce);
+            const gasEstimate = params.gasLimit || selectors_1.DEFAULT_OUTBOUND_GAS_LIMIT;
+            const deadline = params.deadline || BigInt(Math.floor(Date.now() / 1000) + 3600);
+            // Build the HopDescriptor with all metadata needed for cascade nesting
+            const hop = yield this.buildHopDescriptor(params, route, ueaAddress);
+            const prepared = {
+                route,
+                payload,
+                gatewayRequest,
+                estimatedGas: gasEstimate,
+                nonce,
+                deadline,
+                _hop: hop,
+                thenOn: (nextTx) => this.createCascadedBuilder([prepared, nextTx]),
+                send: () => this.executeMultiChain(params),
+            };
+            return prepared;
+        });
+    }
+    /**
+     * Build a HopDescriptor for a prepared transaction.
+     * Resolves CEA addresses, queries gas fees, and builds multicall arrays.
+     *
+     * @param params - Original user params
+     * @param route - Detected route
+     * @param ueaAddress - UEA address
+     * @returns HopDescriptor with all metadata
+     */
+    buildHopDescriptor(params, route, ueaAddress) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            // Pass 0 when user omits gasLimit → contract uses per-chain baseGasLimitByChainNamespace
+            const gasLimit = (_a = params.gasLimit) !== null && _a !== void 0 ? _a : BigInt(0);
+            const routeStr = route;
+            const baseDescriptor = {
+                params,
+                route: routeStr,
+                gasLimit,
+                ueaAddress,
+                revertRecipient: ueaAddress,
+            };
+            switch (route) {
+                case route_detector_1.TransactionRoute.UOA_TO_PUSH: {
+                    // Route 1: Build Push Chain multicalls
+                    const executeParams = this.toExecuteParams(params);
+                    const pushMulticalls = (0, payload_builders_1.buildExecuteMulticall)({
+                        execute: executeParams,
+                        ueaAddress,
+                    });
+                    return Object.assign(Object.assign({}, baseDescriptor), { pushMulticalls });
+                }
+                case route_detector_1.TransactionRoute.UOA_TO_CEA: {
+                    // Route 2: Build outbound metadata
+                    const target = params.to;
+                    const targetChain = target.chain;
+                    // Branch: SVM vs EVM
+                    if ((0, payload_builders_1.isSvmChain)(targetChain)) {
+                        // SVM path: no CEA lookup, build SVM payload
+                        const hasSvmExecute = !!params.svmExecute;
+                        let svmPayload = '0x';
+                        if (hasSvmExecute) {
+                            const exec = params.svmExecute;
+                            svmPayload = (0, payload_builders_1.encodeSvmExecutePayload)({
+                                targetProgram: exec.targetProgram,
+                                accounts: exec.accounts,
+                                ixData: exec.ixData,
+                                instructionId: 2,
+                            });
+                        }
+                        let prc20Token = selectors_1.ZERO_ADDRESS;
+                        let burnAmount = BigInt(0);
+                        if ((_b = params.funds) === null || _b === void 0 ? void 0 : _b.amount) {
+                            const token = params.funds.token;
+                            if (token) {
+                                prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                                burnAmount = params.funds.amount;
+                            }
+                        }
+                        else if (params.value && params.value > BigInt(0)) {
+                            prc20Token = this.getNativePRC20ForChain(targetChain);
+                            burnAmount = params.value;
+                        }
+                        else if (hasSvmExecute) {
+                            prc20Token = this.getNativePRC20ForChain(targetChain);
+                            burnAmount = BigInt(1);
+                        }
+                        let gasToken = selectors_1.ZERO_ADDRESS;
+                        let gasFee = BigInt(0);
+                        if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+                            const result = yield this.queryOutboundGasFee(prc20Token, gasLimit);
+                            gasToken = result.gasToken;
+                            gasFee = result.gasFee;
+                        }
+                        return Object.assign(Object.assign({}, baseDescriptor), { targetChain, isSvmTarget: true, svmPayload,
+                            prc20Token,
+                            burnAmount,
+                            gasToken,
+                            gasFee });
+                    }
+                    // EVM path: Resolve CEA address + build CEA multicalls
+                    const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain, (_c = this.rpcUrls[targetChain]) === null || _c === void 0 ? void 0 : _c[0]);
+                    // Migration path: raw MIGRATION_SELECTOR payload, no multicall wrapping
+                    if (params.migration) {
+                        const prc20Token = this.getNativePRC20ForChain(targetChain);
+                        const burnAmount = BigInt(0); // Migration is logic-only — no funds. CEA rejects msg.value != 0.
+                        let gasToken = selectors_1.ZERO_ADDRESS;
+                        let gasFee = BigInt(0);
+                        if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+                            const result = yield this.queryOutboundGasFee(prc20Token, gasLimit);
+                            gasToken = result.gasToken;
+                            gasFee = result.gasFee;
+                        }
+                        return Object.assign(Object.assign({}, baseDescriptor), { targetChain,
+                            ceaAddress, ceaMulticalls: [], prc20Token,
+                            burnAmount,
+                            gasToken,
+                            gasFee, isMigration: true });
+                    }
+                    // Build CEA multicalls
+                    const ceaMulticalls = [];
+                    if (params.data) {
+                        if (Array.isArray(params.data)) {
+                            ceaMulticalls.push(...params.data);
+                        }
+                        else {
+                            // When ERC-20 funds are provided with a single payload, auto-prepend a
+                            // transfer() call so the tokens minted to the CEA are forwarded to the
+                            // target address. This mirrors the Route 1 behavior in buildExecuteMulticall.
+                            if ((_d = params.funds) === null || _d === void 0 ? void 0 : _d.amount) {
+                                const token = params.funds.token;
+                                if (token && token.mechanism !== 'native') {
+                                    const erc20Transfer = (0, viem_1.encodeFunctionData)({
+                                        abi: abi_1.ERC20_EVM,
+                                        functionName: 'transfer',
+                                        args: [target.address, params.funds.amount],
+                                    });
+                                    ceaMulticalls.push({
+                                        to: token.address,
+                                        value: BigInt(0),
+                                        data: erc20Transfer,
+                                    });
+                                }
+                            }
+                            // Single call with data. Forward native value (if any) so the target
+                            // contract receives it alongside the payload call. The vault deposits
+                            // native value to the CEA, and the multicall forwards it to the target.
+                            ceaMulticalls.push({
+                                to: target.address,
+                                value: (_e = params.value) !== null && _e !== void 0 ? _e : BigInt(0),
+                                data: params.data,
+                            });
+                        }
+                    }
+                    else if (params.value) {
+                        // Skip multicall when sending native value to own CEA — gateway deposits directly.
+                        // Self-call with value would revert (CEA._handleMulticall rejects it).
+                        if (target.address.toLowerCase() !== ceaAddress.toLowerCase()) {
+                            ceaMulticalls.push({
+                                to: target.address,
+                                value: params.value,
+                                data: '0x',
+                            });
+                        }
+                    }
+                    // Determine PRC-20 token and burn amount
+                    let prc20Token = selectors_1.ZERO_ADDRESS;
+                    let burnAmount = BigInt(0);
+                    if ((_f = params.funds) === null || _f === void 0 ? void 0 : _f.amount) {
+                        const token = params.funds.token;
+                        if (token) {
+                            prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                            burnAmount = params.funds.amount;
+                        }
+                    }
+                    else if (params.value && params.value > BigInt(0)) {
+                        prc20Token = this.getNativePRC20ForChain(targetChain);
+                        burnAmount = params.value;
+                    }
+                    else if (params.data) {
+                        prc20Token = this.getNativePRC20ForChain(targetChain);
+                        burnAmount = BigInt(1); // Minimum for precompile
+                    }
+                    // Query gas fee
+                    let gasToken = selectors_1.ZERO_ADDRESS;
+                    let gasFee = BigInt(0);
+                    if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+                        const result = yield this.queryOutboundGasFee(prc20Token, gasLimit);
+                        gasToken = result.gasToken;
+                        gasFee = result.gasFee;
+                    }
+                    return Object.assign(Object.assign({}, baseDescriptor), { targetChain,
+                        ceaAddress,
+                        ceaMulticalls,
+                        prc20Token,
+                        burnAmount,
+                        gasToken,
+                        gasFee });
+                }
+                case route_detector_1.TransactionRoute.CEA_TO_PUSH: {
+                    // Route 3: Build CEA multicalls for sendUniversalTxFromCEA
+                    const sourceChain = params.from.chain;
+                    // SVM chains use PDA-based CEA, not factory-deployed CEA
+                    if ((0, payload_builders_1.isSvmChain)(sourceChain)) {
+                        const lockerContract = chain_1.CHAIN_INFO[sourceChain].lockerContract;
+                        if (!lockerContract) {
+                            throw new Error(`No SVM gateway program configured for chain ${sourceChain}`);
+                        }
+                        const programPk = new web3_js_1.PublicKey(lockerContract);
+                        const gatewayProgramHex = ('0x' + Buffer.from(programPk.toBytes()).toString('hex'));
+                        // Derive CEA PDA
+                        const ueaBytes = Buffer.from(ueaAddress.slice(2), 'hex');
+                        const [ceaPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('push_identity'), ueaBytes], programPk);
+                        const ceaPdaHex = ('0x' + Buffer.from(ceaPda.toBytes()).toString('hex'));
+                        let amount = BigInt(0);
+                        let prc20Token;
+                        if (((_g = params.funds) === null || _g === void 0 ? void 0 : _g.amount) && params.funds.amount > BigInt(0)) {
+                            amount = params.funds.amount;
+                            const token = params.funds.token;
+                            if (token && token.address) {
+                                prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                            }
+                            else {
+                                prc20Token = this.getNativePRC20ForChain(sourceChain);
+                            }
+                        }
+                        else if (params.value && params.value > BigInt(0)) {
+                            amount = params.value;
+                            prc20Token = this.getNativePRC20ForChain(sourceChain);
+                        }
+                        else {
+                            // Payload-only Route 3 SVM
+                            prc20Token = this.getNativePRC20ForChain(sourceChain);
+                        }
+                        let gasToken = selectors_1.ZERO_ADDRESS;
+                        let gasFee = BigInt(0);
+                        if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+                            const result = yield this.queryOutboundGasFee(prc20Token, gasLimit);
+                            gasToken = result.gasToken;
+                            gasFee = result.gasFee;
+                        }
+                        return Object.assign(Object.assign({}, baseDescriptor), { sourceChain, ceaAddress: ceaPdaHex, isSvmTarget: true, prc20Token, burnAmount: amount > BigInt(0) ? amount : BigInt(1), gasToken,
+                            gasFee });
+                    }
+                    const { cea: ceaAddress, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_h = this.rpcUrls[sourceChain]) === null || _h === void 0 ? void 0 : _h[0]);
+                    // Determine token/amount for the inbound
+                    let tokenAddress = selectors_1.ZERO_ADDRESS;
+                    let amount = BigInt(0);
+                    let nativeValue = BigInt(0);
+                    if ((_j = params.funds) === null || _j === void 0 ? void 0 : _j.amount) {
+                        const token = params.funds.token;
+                        if (token) {
+                            if (token.mechanism === 'native') {
+                                amount = params.funds.amount;
+                                nativeValue = params.funds.amount;
+                            }
+                            else {
+                                tokenAddress = token.address;
+                                amount = params.funds.amount;
+                            }
+                        }
+                    }
+                    else if (params.value && params.value > BigInt(0)) {
+                        amount = params.value;
+                        nativeValue = params.value;
+                    }
+                    // The PRC-20 for the outbound wrapper (Route 2 to source chain)
+                    const prc20Token = this.getNativePRC20ForChain(sourceChain);
+                    let gasToken = selectors_1.ZERO_ADDRESS;
+                    let gasFee = BigInt(0);
+                    if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+                        const result = yield this.queryOutboundGasFee(prc20Token, gasLimit);
+                        gasToken = result.gasToken;
+                        gasFee = result.gasFee;
+                    }
+                    return Object.assign(Object.assign({}, baseDescriptor), { sourceChain,
+                        ceaAddress,
+                        prc20Token, burnAmount: amount > BigInt(0) ? amount : BigInt(1), gasToken,
+                        gasFee });
+                }
+                default:
+                    return baseDescriptor;
+            }
+        });
+    }
+    /**
+     * Query outbound gas fee from UniversalCore contract.
+     * Extracted from executeUoaToCea for reuse.
+     *
+     * @param prc20Token - PRC-20 token address
+     * @param gasLimit - Gas limit for the outbound
+     * @returns gasToken address and gasFee amount
+     */
+    queryOutboundGasFee(prc20Token, gasLimit) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const gatewayPcAddress = this.getUniversalGatewayPCAddress();
+            const pushChain = this.getPushChainForNetwork();
+            const rpcUrl = ((_b = (_a = chain_1.CHAIN_INFO[pushChain]) === null || _a === void 0 ? void 0 : _a.defaultRPC) === null || _b === void 0 ? void 0 : _b[0]) || 'unknown';
+            this.printLog(`queryOutboundGasFee — [step 1] inputs: gateway=${gatewayPcAddress}, prc20Token=${prc20Token}, gasLimit=${gasLimit}, pushNetwork=${this.pushNetwork}, rpcUrl=${rpcUrl}`);
+            // Step 2: Get UNIVERSAL_CORE address from gateway
+            let universalCoreAddress;
+            try {
+                const gatewayCallData = (0, viem_1.encodeFunctionData)({
+                    abi: abi_1.UNIVERSAL_GATEWAY_PC,
+                    functionName: 'UNIVERSAL_CORE',
+                    args: [],
+                });
+                this.printLog(`queryOutboundGasFee — [step 2] reading UNIVERSAL_CORE from ${gatewayPcAddress}, callData=${gatewayCallData}`);
+                universalCoreAddress = yield this.pushClient.readContract({
+                    address: gatewayPcAddress,
+                    abi: abi_1.UNIVERSAL_GATEWAY_PC,
+                    functionName: 'UNIVERSAL_CORE',
+                    args: [],
+                });
+                this.printLog(`queryOutboundGasFee — [step 2] UNIVERSAL_CORE resolved to: ${universalCoreAddress}`);
+            }
+            catch (err) {
+                this.printLog(`queryOutboundGasFee — [step 2] FAILED to read UNIVERSAL_CORE: ${err instanceof Error ? err.message : String(err)}`);
+                throw err;
+            }
+            // Step 3: Call getOutboundTxGasAndFees on UNIVERSAL_CORE
+            const callData = (0, viem_1.encodeFunctionData)({
+                abi: abi_1.UNIVERSAL_CORE_EVM,
+                functionName: 'getOutboundTxGasAndFees',
+                args: [prc20Token, gasLimit],
+            });
+            this.printLog(`queryOutboundGasFee — [step 3] calling getOutboundTxGasAndFees on ${universalCoreAddress}`);
+            this.printLog(`queryOutboundGasFee — [step 3] eth_call: {"method":"eth_call","params":[{"to":"${universalCoreAddress}","data":"${callData}"},"latest"]}`);
+            let gasToken;
+            let gasFee;
+            let protocolFee;
+            let gasPrice = BigInt(0);
+            try {
+                const result = yield this.pushClient.readContract({
+                    address: universalCoreAddress,
+                    abi: abi_1.UNIVERSAL_CORE_EVM,
+                    functionName: 'getOutboundTxGasAndFees',
+                    args: [prc20Token, gasLimit],
+                });
+                gasToken = result[0];
+                gasFee = result[1];
+                protocolFee = result[2];
+                gasPrice = result[3];
+                this.printLog(`queryOutboundGasFee — [step 4] success: gasToken=${gasToken}, gasFee=${gasFee}, protocolFee=${protocolFee}, gasPrice=${gasPrice}`);
+            }
+            catch (err) {
+                this.printLog(`queryOutboundGasFee — [step 3] FAILED: ${err instanceof Error ? err.message : String(err)}`);
+                throw err;
+            }
+            // gasFee is in gas token units — exchange rate to PC is unknown without quoter.
+            // Use 1000000x buffer; excess is refunded by swapAndBurnGas to the UEA.
+            const nativeValueForGas = protocolFee + (gasFee * BigInt(1000000));
+            this.printLog(`queryOutboundGasFee — [step 5] using 1000000x buffer: nativeValueForGas=${nativeValueForGas}`);
+            return { gasToken, gasFee, protocolFee, nativeValueForGas, gasPrice };
+        });
+    }
+    // ============================================================================
+    // Cascade Composition (Advance Hopping)
+    // ============================================================================
+    /**
+     * Classify hops into segments for cascade composition.
+     * Consecutive same-type/same-chain hops are merged.
+     *
+     * @param hops - Array of HopDescriptors from prepared transactions
+     * @returns Array of CascadeSegments
+     */
+    classifyIntoSegments(hops) {
+        if (hops.length === 0)
+            return [];
+        const segments = [];
+        let currentSegment = null;
+        for (const hop of hops) {
+            const segType = this.getSegmentType(hop.route);
+            const chain = hop.targetChain || hop.sourceChain;
+            const canMerge = currentSegment &&
+                currentSegment.type === segType &&
+                // Same-chain merging for OUTBOUND_TO_CEA (EVM only — SVM hops are atomic)
+                (segType === 'OUTBOUND_TO_CEA'
+                    ? currentSegment.targetChain === hop.targetChain &&
+                        !hop.isSvmTarget
+                    : segType === 'PUSH_EXECUTION');
+            if (canMerge && currentSegment) {
+                // Merge into current segment
+                currentSegment.hops.push(hop);
+                if (segType === 'OUTBOUND_TO_CEA') {
+                    currentSegment.mergedCeaMulticalls = [
+                        ...(currentSegment.mergedCeaMulticalls || []),
+                        ...(hop.ceaMulticalls || []),
+                    ];
+                    currentSegment.totalBurnAmount =
+                        (currentSegment.totalBurnAmount || BigInt(0)) +
+                            (hop.burnAmount || BigInt(0));
+                    // Gas fee: take the max gasLimit across merged hops
+                    if (hop.gasLimit > (currentSegment.gasLimit || BigInt(0))) {
+                        currentSegment.gasLimit = hop.gasLimit;
+                    }
+                    // Accumulate gas fees
+                    currentSegment.gasFee =
+                        (currentSegment.gasFee || BigInt(0)) +
+                            (hop.gasFee || BigInt(0));
+                }
+                else if (segType === 'PUSH_EXECUTION') {
+                    currentSegment.mergedPushMulticalls = [
+                        ...(currentSegment.mergedPushMulticalls || []),
+                        ...(hop.pushMulticalls || []),
+                    ];
+                }
+            }
+            else {
+                // Start a new segment
+                currentSegment = {
+                    type: segType,
+                    hops: [hop],
+                    targetChain: hop.targetChain,
+                    sourceChain: hop.sourceChain,
+                    mergedCeaMulticalls: segType === 'OUTBOUND_TO_CEA' ? [...(hop.ceaMulticalls || [])] : undefined,
+                    mergedPushMulticalls: segType === 'PUSH_EXECUTION' ? [...(hop.pushMulticalls || [])] : undefined,
+                    totalBurnAmount: hop.burnAmount,
+                    prc20Token: hop.prc20Token,
+                    gasToken: hop.gasToken,
+                    gasFee: hop.gasFee,
+                    gasLimit: hop.gasLimit,
+                };
+                segments.push(currentSegment);
+            }
+        }
+        return segments;
+    }
+    /**
+     * Map route to segment type
+     */
+    getSegmentType(route) {
+        switch (route) {
+            case 'UOA_TO_PUSH':
+                return 'PUSH_EXECUTION';
+            case 'UOA_TO_CEA':
+                return 'OUTBOUND_TO_CEA';
+            case 'CEA_TO_PUSH':
+                return 'INBOUND_FROM_CEA';
+            default:
+                return 'PUSH_EXECUTION';
+        }
+    }
+    /**
+     * Compose cascade from segments using bottom-to-top nesting.
+     * Processes segments in reverse order, building nested payloads.
+     *
+     * @param segments - Classified segments from classifyIntoSegments()
+     * @param ueaAddress - UEA address
+     * @returns Final MultiCall[] to execute as the initial UEA multicall
+     */
+    composeCascade(segments, ueaAddress, ueaBalance, ueaNonce) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        let accumulatedPushMulticalls = [];
+        const gatewayPcAddress = this.getUniversalGatewayPCAddress();
+        // Compute per-outbound nativeValueForGas from UEA balance
+        // Each outbound segment needs native value for the gas swap on the destination chain.
+        // The contract refunds excess, so over-allocating is safe.
+        const numOutbounds = segments.filter(s => s.type !== 'PUSH_EXECUTION').length;
+        const CASCADE_GAS_RESERVE = BigInt(3e18); // 3 PC reserve for gas costs
+        let perOutboundNativeValue;
+        if (ueaBalance && numOutbounds > 0 && ueaBalance > CASCADE_GAS_RESERVE) {
+            perOutboundNativeValue = (ueaBalance - CASCADE_GAS_RESERVE) / BigInt(numOutbounds);
+        }
+        for (let i = segments.length - 1; i >= 0; i--) {
+            const segment = segments[i];
+            switch (segment.type) {
+                case 'PUSH_EXECUTION': {
+                    // Prepend Push Chain multicalls to accumulated
+                    accumulatedPushMulticalls = [
+                        ...(segment.mergedPushMulticalls || []),
+                        ...accumulatedPushMulticalls,
+                    ];
+                    break;
+                }
+                case 'OUTBOUND_TO_CEA': {
+                    const firstHop = segment.hops[0];
+                    const isSvmSegment = (firstHop === null || firstHop === void 0 ? void 0 : firstHop.isSvmTarget) === true;
+                    let outboundPayload;
+                    let targetForOutbound;
+                    const isMigration = (firstHop === null || firstHop === void 0 ? void 0 : firstHop.isMigration) === true;
+                    if (isSvmSegment) {
+                        // SVM: use the pre-built SVM payload from the hop descriptor
+                        outboundPayload = (_a = firstHop.svmPayload) !== null && _a !== void 0 ? _a : '0x';
+                        // For SVM, target is the recipient/program from the hop params
+                        const svmTarget = firstHop.params.to;
+                        targetForOutbound = (_c = (_b = firstHop.params.svmExecute) === null || _b === void 0 ? void 0 : _b.targetProgram) !== null && _c !== void 0 ? _c : svmTarget.address;
+                    }
+                    else if (isMigration) {
+                        // Migration: use raw 4-byte MIGRATION_SELECTOR, no multicall wrapping
+                        outboundPayload = (0, payload_builders_1.buildMigrationPayload)();
+                        targetForOutbound = (firstHop === null || firstHop === void 0 ? void 0 : firstHop.ceaAddress) || ueaAddress;
+                    }
+                    else {
+                        // EVM: build CEA payload from merged multicalls
+                        outboundPayload = (0, payload_builders_1.buildCeaMulticallPayload)(segment.mergedCeaMulticalls || []);
+                        // Get CEA address from the first hop
+                        targetForOutbound = (firstHop === null || firstHop === void 0 ? void 0 : firstHop.ceaAddress) || ueaAddress;
+                    }
+                    // Build outbound request
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetForOutbound, segment.prc20Token || selectors_1.ZERO_ADDRESS, segment.totalBurnAmount || BigInt(0), (_d = segment.gasLimit) !== null && _d !== void 0 ? _d : BigInt(0), outboundPayload, ueaAddress);
+                    // Build approval + outbound multicalls
+                    const segGasFee = segment.gasFee || BigInt(0);
+                    const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+                        prc20Token: segment.prc20Token || selectors_1.ZERO_ADDRESS,
+                        gasToken: segment.gasToken || selectors_1.ZERO_ADDRESS,
+                        burnAmount: segment.totalBurnAmount || BigInt(0),
+                        gasFee: segGasFee,
+                        nativeValueForGas: perOutboundNativeValue !== null && perOutboundNativeValue !== void 0 ? perOutboundNativeValue : segGasFee * BigInt(1000),
+                        gatewayPcAddress,
+                        outboundRequest: outboundReq,
+                    });
+                    // Prepend to accumulated
+                    accumulatedPushMulticalls = [
+                        ...outboundMulticalls,
+                        ...accumulatedPushMulticalls,
+                    ];
+                    break;
+                }
+                case 'INBOUND_FROM_CEA': {
+                    // The accumulated multicalls = what runs on Push Chain AFTER inbound arrives.
+                    // Wrap in UniversalPayload struct with correct UEA nonce for the relay.
+                    // Build push multicalls from this hop's own data (e.g., counter.increment())
+                    // This is the Route 3 hop's payload that executes on Push Chain after inbound.
+                    const hop0 = segment.hops[0];
+                    if ((_e = hop0 === null || hop0 === void 0 ? void 0 : hop0.params) === null || _e === void 0 ? void 0 : _e.data) {
+                        const hopPushMulticalls = (0, payload_builders_1.buildExecuteMulticall)({
+                            execute: {
+                                to: hop0.params.to,
+                                value: hop0.params.value,
+                                data: hop0.params.data,
+                            },
+                            ueaAddress,
+                        });
+                        // Prepend the Route 3's own push calls before subsequent hops
+                        accumulatedPushMulticalls = [
+                            ...hopPushMulticalls,
+                            ...accumulatedPushMulticalls,
+                        ];
+                    }
+                    let intermediatePayload = '0x';
+                    if (accumulatedPushMulticalls.length > 0) {
+                        const multicallPayload = this._buildMulticallPayloadData(ueaAddress, accumulatedPushMulticalls);
+                        // +1: the outbound tx consumes one nonce via execute()
+                        intermediatePayload = (0, payload_builders_1.buildInboundUniversalPayload)(multicallPayload, { nonce: (ueaNonce !== null && ueaNonce !== void 0 ? ueaNonce : BigInt(0)) + BigInt(1) });
+                    }
+                    const hop = segment.hops[0];
+                    const sourceChain = hop.sourceChain;
+                    const ceaAddress = hop.ceaAddress || ueaAddress;
+                    // SVM chains: build SVM CPI payload instead of EVM CEA multicall
+                    if ((0, payload_builders_1.isSvmChain)(sourceChain)) {
+                        const lockerContract = chain_1.CHAIN_INFO[sourceChain].lockerContract;
+                        if (!lockerContract) {
+                            throw new Error(`No SVM gateway program configured for chain ${sourceChain}`);
+                        }
+                        const programPk = new web3_js_1.PublicKey(lockerContract);
+                        const gatewayProgramHex = ('0x' + Buffer.from(programPk.toBytes()).toString('hex'));
+                        let drainAmount = BigInt(0);
+                        let tokenMintHex;
+                        const params = hop.params;
+                        if (((_f = params.funds) === null || _f === void 0 ? void 0 : _f.amount) && params.funds.amount > BigInt(0)) {
+                            drainAmount = params.funds.amount;
+                            const token = params.funds.token;
+                            if (token && token.address) {
+                                const mintPk = new web3_js_1.PublicKey(token.address);
+                                tokenMintHex = ('0x' + Buffer.from(mintPk.toBytes()).toString('hex'));
+                            }
+                        }
+                        else if (params.value && params.value > BigInt(0)) {
+                            drainAmount = params.value;
+                        }
+                        // Derive CEA PDA as revert recipient
+                        const ueaBytes = Buffer.from(ueaAddress.slice(2), 'hex');
+                        const [ceaPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('push_identity'), ueaBytes], programPk);
+                        const ceaPdaHex = ('0x' + Buffer.from(ceaPda.toBytes()).toString('hex'));
+                        // Build SVM payload with intermediate Push Chain payload embedded
+                        const svmPayload = (0, payload_builders_1.encodeSvmCeaToUeaPayload)({
+                            gatewayProgramHex,
+                            drainAmount,
+                            tokenMintHex,
+                            revertRecipientHex: ceaPdaHex,
+                            extraPayload: intermediatePayload !== '0x'
+                                ? new Uint8Array(Buffer.from(intermediatePayload.slice(2), 'hex'))
+                                : undefined,
+                        });
+                        const burnAmount = BigInt(1);
+                        const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, segment.prc20Token || this.getNativePRC20ForChain(sourceChain), burnAmount, (_g = segment.gasLimit) !== null && _g !== void 0 ? _g : BigInt(0), svmPayload, ueaAddress);
+                        const inboundGasFee = segment.gasFee || BigInt(0);
+                        const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+                            prc20Token: segment.prc20Token || this.getNativePRC20ForChain(sourceChain),
+                            gasToken: segment.gasToken || selectors_1.ZERO_ADDRESS,
+                            burnAmount,
+                            gasFee: inboundGasFee,
+                            nativeValueForGas: perOutboundNativeValue !== null && perOutboundNativeValue !== void 0 ? perOutboundNativeValue : inboundGasFee * BigInt(1000),
+                            gatewayPcAddress,
+                            outboundRequest: outboundReq,
+                        });
+                        accumulatedPushMulticalls = [...outboundMulticalls];
+                        break;
+                    }
+                    // EVM path: Build CEA multicall: [approve?, sendUniversalTxFromCEA(payload)]
+                    const ceaMulticalls = [];
+                    // Add hop's own CEA operations if any
+                    // (e.g., approve + swap before bridging back)
+                    if (hop.ceaMulticalls && hop.ceaMulticalls.length > 0) {
+                        ceaMulticalls.push(...hop.ceaMulticalls);
+                    }
+                    // Determine token/amount for inbound
+                    let tokenAddress = selectors_1.ZERO_ADDRESS;
+                    let amount = BigInt(0);
+                    const params = hop.params;
+                    if ((_h = params.funds) === null || _h === void 0 ? void 0 : _h.amount) {
+                        const token = params.funds.token;
+                        if (token) {
+                            if (token.mechanism === 'native') {
+                                amount = params.funds.amount;
+                            }
+                            else {
+                                tokenAddress = token.address;
+                                amount = params.funds.amount;
+                                // Add approve for ERC20 (CEA approves gateway)
+                                const gatewayAddr = chain_1.UNIVERSAL_GATEWAY_ADDRESSES[sourceChain];
+                                if (!gatewayAddr) {
+                                    throw new Error(`No UniversalGateway address configured for chain ${sourceChain}`);
+                                }
+                                const approveData = (0, viem_1.encodeFunctionData)({
+                                    abi: abi_1.ERC20_EVM,
+                                    functionName: 'approve',
+                                    args: [gatewayAddr, amount],
+                                });
+                                ceaMulticalls.push({
+                                    to: tokenAddress,
+                                    value: BigInt(0),
+                                    data: approveData,
+                                });
+                            }
+                        }
+                    }
+                    else if (params.value && params.value > BigInt(0)) {
+                        amount = params.value;
+                    }
+                    // Build sendUniversalTxToUEA self-call on CEA (to=CEA, value=0)
+                    const sendCall = (0, payload_builders_1.buildSendUniversalTxToUEA)(ceaAddress, tokenAddress, amount, intermediatePayload, ceaAddress);
+                    ceaMulticalls.push(sendCall);
+                    // Wrap CEA multicall in outbound from Push Chain
+                    const ceaPayload = (0, payload_builders_1.buildCeaMulticallPayload)(ceaMulticalls);
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, segment.prc20Token || this.getNativePRC20ForChain(sourceChain), segment.totalBurnAmount || BigInt(1), (_j = segment.gasLimit) !== null && _j !== void 0 ? _j : BigInt(0), ceaPayload, ueaAddress);
+                    const inboundGasFee = segment.gasFee || BigInt(0);
+                    const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+                        prc20Token: segment.prc20Token || this.getNativePRC20ForChain(sourceChain),
+                        gasToken: segment.gasToken || selectors_1.ZERO_ADDRESS,
+                        burnAmount: segment.totalBurnAmount || BigInt(1),
+                        gasFee: inboundGasFee,
+                        nativeValueForGas: perOutboundNativeValue !== null && perOutboundNativeValue !== void 0 ? perOutboundNativeValue : inboundGasFee * BigInt(1000),
+                        gatewayPcAddress,
+                        outboundRequest: outboundReq,
+                    });
+                    // Reset accumulated -- everything is now inside this outbound
+                    accumulatedPushMulticalls = [...outboundMulticalls];
+                    break;
+                }
+            }
+        }
+        return accumulatedPushMulticalls;
+    }
+    /**
+     * Creates a cascaded transaction builder for nested multi-chain execution.
+     * The cascade composes all hops bottom-to-top into a single Push Chain tx.
+     *
+     * @param preparedTxs - Array of prepared transactions
+     * @returns CascadedTransactionBuilder
+     */
+    createCascadedBuilder(preparedTxs) {
+        return {
+            thenOn: (nextTx) => this.createCascadedBuilder([...preparedTxs, nextTx]),
+            send: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const ueaAddress = this.computeUEAOffchain();
+                // Extract HopDescriptors
+                const hops = preparedTxs.map((tx) => tx._hop);
+                // Classify into segments
+                const segments = this.classifyIntoSegments(hops);
+                // Check if this is a single-hop Route 1 (no composition needed)
+                if (preparedTxs.length === 1 &&
+                    preparedTxs[0].route === 'UOA_TO_PUSH') {
+                    const response = yield this.executeMultiChain(hops[0].params);
+                    const singleRoute1Result = {
+                        initialTxHash: response.hash,
+                        initialTxResponse: response,
+                        hops: [
+                            {
+                                hopIndex: 0,
+                                route: hops[0].route,
+                                executionChain: enums_1.CHAIN.PUSH_TESTNET_DONUT,
+                                status: 'confirmed',
+                                txHash: response.hash,
+                            },
+                        ],
+                        hopCount: 1,
+                        waitForAll: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                            return ({
+                                success: true,
+                                hops: [
+                                    {
+                                        hopIndex: 0,
+                                        route: hops[0].route,
+                                        executionChain: enums_1.CHAIN.PUSH_TESTNET_DONUT,
+                                        status: 'confirmed',
+                                        txHash: response.hash,
+                                    },
+                                ],
+                            });
+                        }),
+                        wait: (opts) => tslib_1.__awaiter(this, void 0, void 0, function* () { return singleRoute1Result.waitForAll(opts); }),
+                    };
+                    return singleRoute1Result;
+                }
+                // Check if single-hop Route 2 (just execute directly)
+                if (preparedTxs.length === 1 &&
+                    preparedTxs[0].route === 'UOA_TO_CEA') {
+                    const response = yield this.executeMultiChain(hops[0].params);
+                    const targetChain = hops[0].targetChain || enums_1.CHAIN.PUSH_TESTNET_DONUT;
+                    const singleRoute2Result = {
+                        initialTxHash: response.hash,
+                        initialTxResponse: response,
+                        hops: [
+                            {
+                                hopIndex: 0,
+                                route: hops[0].route,
+                                executionChain: targetChain,
+                                status: 'confirmed',
+                                txHash: response.hash,
+                            },
+                        ],
+                        hopCount: 1,
+                        waitForAll: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                            return ({
+                                success: true,
+                                hops: [
+                                    {
+                                        hopIndex: 0,
+                                        route: hops[0].route,
+                                        executionChain: targetChain,
+                                        status: 'confirmed',
+                                        txHash: response.hash,
+                                    },
+                                ],
+                            });
+                        }),
+                        wait: (opts) => tslib_1.__awaiter(this, void 0, void 0, function* () { return singleRoute2Result.waitForAll(opts); }),
+                    };
+                    return singleRoute2Result;
+                }
+                // Multi-hop: compose cascade bottom-to-top
+                // Fetch UEA balance + nonce so composeCascade can allocate native value and build inbound payloads
+                const ueaBalance = yield this.pushClient.getBalance(ueaAddress);
+                const ueaCodeCascade = yield this.pushClient.publicClient.getCode({ address: ueaAddress });
+                const ueaNonceCascade = ueaCodeCascade !== undefined ? yield this.getUEANonce(ueaAddress) : BigInt(0);
+                const composedMulticalls = this.composeCascade(segments, ueaAddress, ueaBalance, ueaNonceCascade);
+                // Execute the composed multicall as a single Push Chain tx
+                const executeParams = {
+                    to: ueaAddress,
+                    data: composedMulticalls,
+                };
+                const response = yield this.execute(executeParams);
+                // Build hop info for tracking
+                const hopInfos = hops.map((hop, index) => ({
+                    hopIndex: index,
+                    route: hop.route,
+                    executionChain: hop.targetChain || hop.sourceChain || enums_1.CHAIN.PUSH_TESTNET_DONUT,
+                    status: 'pending',
+                }));
+                // Mark first hop as submitted
+                if (hopInfos.length > 0) {
+                    hopInfos[0].status = 'submitted';
+                    hopInfos[0].txHash = response.hash;
+                }
+                const cascadeResponse = {
+                    initialTxHash: response.hash,
+                    initialTxResponse: response,
+                    hops: hopInfos,
+                    hopCount: hops.length,
+                    waitForAll: (opts) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        const { pollingIntervalMs = 10000, timeout = 300000, progressHook: cascadeProgressHook, } = opts || {};
+                        const startTime = Date.now();
+                        try {
+                            // 1. Wait for initial Push Chain tx confirmation
+                            cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                hopIndex: 0,
+                                route: ((_a = hopInfos[0]) === null || _a === void 0 ? void 0 : _a.route) || 'UOA_TO_PUSH',
+                                chain: enums_1.CHAIN.PUSH_TESTNET_DONUT,
+                                status: 'waiting',
+                                elapsed: Date.now() - startTime,
+                            });
+                            yield response.wait();
+                            // Mark all Push Chain (Route 1) hops as confirmed
+                            for (const hop of hopInfos) {
+                                if (hop.route === 'UOA_TO_PUSH') {
+                                    hop.status = 'confirmed';
+                                    hop.txHash = response.hash;
+                                    cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                        hopIndex: hop.hopIndex,
+                                        route: hop.route,
+                                        chain: enums_1.CHAIN.PUSH_TESTNET_DONUT,
+                                        status: 'confirmed',
+                                        txHash: response.hash,
+                                        elapsed: Date.now() - startTime,
+                                    });
+                                }
+                            }
+                            // 2. Track outbound hops (Route 2: UOA_TO_CEA)
+                            // Hops after a CEA_TO_PUSH are "child outbounds" — they execute inside
+                            // the inbound payload on Push Chain and live under a DIFFERENT utx_id
+                            // (the inbound UTX, not the parent). We can't track them via the parent
+                            // utx_id polling, so we auto-confirm them.
+                            const ceaToPushIndex = hopInfos.findIndex((h) => h.route === 'CEA_TO_PUSH');
+                            const outboundHops = hopInfos.filter((h, i) => {
+                                if (h.route !== 'UOA_TO_CEA')
+                                    return false;
+                                // Child outbounds (after CEA_TO_PUSH) live under the inbound UTX,
+                                // not the parent — auto-confirm since we can't poll them here.
+                                if (ceaToPushIndex >= 0 && i > ceaToPushIndex) {
+                                    h.status = 'confirmed';
+                                    cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                        hopIndex: h.hopIndex,
+                                        route: h.route,
+                                        chain: h.executionChain,
+                                        status: 'confirmed',
+                                        elapsed: Date.now() - startTime,
+                                    });
+                                    return false;
+                                }
+                                return true;
+                            });
+                            if (outboundHops.length > 0) {
+                                if (outboundHops.length === 1) {
+                                    // Single direct outbound hop: use the existing V1-based tracking
+                                    const hop = outboundHops[0];
+                                    const remainingTimeout = timeout - (Date.now() - startTime);
+                                    if (remainingTimeout <= 0) {
+                                        hop.status = 'failed';
+                                        cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                            hopIndex: hop.hopIndex,
+                                            route: hop.route,
+                                            chain: hop.executionChain,
+                                            status: 'timeout',
+                                            elapsed: Date.now() - startTime,
+                                        });
+                                        return { success: false, hops: hopInfos, failedAt: hop.hopIndex };
+                                    }
+                                    cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                        hopIndex: hop.hopIndex,
+                                        route: hop.route,
+                                        chain: hop.executionChain,
+                                        status: 'polling',
+                                        elapsed: Date.now() - startTime,
+                                    });
+                                    try {
+                                        const outboundDetails = yield this.waitForOutboundTx(response.hash, {
+                                            initialWaitMs: Math.min(60000, remainingTimeout),
+                                            pollingIntervalMs,
+                                            timeout: remainingTimeout,
+                                            progressHook: (event) => {
+                                                cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                                    hopIndex: hop.hopIndex,
+                                                    route: hop.route,
+                                                    chain: hop.executionChain,
+                                                    status: event.status,
+                                                    elapsed: Date.now() - startTime,
+                                                });
+                                            },
+                                        });
+                                        hop.status = 'confirmed';
+                                        hop.txHash = outboundDetails.externalTxHash;
+                                        hop.outboundDetails = outboundDetails;
+                                        cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                            hopIndex: hop.hopIndex,
+                                            route: hop.route,
+                                            chain: hop.executionChain,
+                                            status: 'confirmed',
+                                            txHash: outboundDetails.externalTxHash,
+                                            elapsed: Date.now() - startTime,
+                                        });
+                                    }
+                                    catch (err) {
+                                        hop.status = 'failed';
+                                        cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                            hopIndex: hop.hopIndex,
+                                            route: hop.route,
+                                            chain: hop.executionChain,
+                                            status: 'failed',
+                                            elapsed: Date.now() - startTime,
+                                        });
+                                        return { success: false, hops: hopInfos, failedAt: hop.hopIndex };
+                                    }
+                                }
+                                else {
+                                    // Multiple outbound hops: use V2 API which returns outboundTx[]
+                                    const allOutboundDetails = yield this.waitForAllOutboundTxsV2(response.hash, outboundHops, {
+                                        initialWaitMs: Math.min(60000, timeout - (Date.now() - startTime)),
+                                        pollingIntervalMs,
+                                        timeout: timeout - (Date.now() - startTime),
+                                        progressHook: (event) => {
+                                            cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                                hopIndex: event.hopIndex,
+                                                route: event.route,
+                                                chain: event.chain,
+                                                status: event.status,
+                                                txHash: event.txHash,
+                                                elapsed: Date.now() - startTime,
+                                            });
+                                        },
+                                    });
+                                    if (!allOutboundDetails.success) {
+                                        return {
+                                            success: false,
+                                            hops: hopInfos,
+                                            failedAt: allOutboundDetails.failedAt,
+                                        };
+                                    }
+                                }
+                            }
+                            // 3. Route 3 (CEA_TO_PUSH) tracking - mark as submitted
+                            const inboundHops = hopInfos.filter((h) => h.route === 'CEA_TO_PUSH');
+                            for (const inboundHop of inboundHops) {
+                                inboundHop.status = 'submitted';
+                                cascadeProgressHook === null || cascadeProgressHook === void 0 ? void 0 : cascadeProgressHook({
+                                    hopIndex: inboundHop.hopIndex,
+                                    route: inboundHop.route,
+                                    chain: inboundHop.executionChain,
+                                    status: 'waiting',
+                                    elapsed: Date.now() - startTime,
+                                });
+                            }
+                            return { success: true, hops: hopInfos };
+                        }
+                        catch (err) {
+                            const failedIdx = hopInfos.findIndex((h) => h.status !== 'confirmed');
+                            return {
+                                success: false,
+                                hops: hopInfos,
+                                failedAt: failedIdx >= 0 ? failedIdx : 0,
+                            };
+                        }
+                    }),
+                    wait: (opts) => tslib_1.__awaiter(this, void 0, void 0, function* () { return cascadeResponse.waitForAll(opts); }),
+                };
+                return cascadeResponse;
+            }),
+        };
+    }
+    /**
+     * @deprecated Use createCascadedBuilder instead.
+     * Creates a chained transaction builder for sequential multi-chain execution.
+     *
+     * @param transactions - Array of transactions to execute in sequence
+     * @returns ChainedTransactionBuilder
+     */
+    createChainedBuilder(transactions) {
+        return {
+            thenOn: (nextTx) => this.createChainedBuilder([...transactions, nextTx]),
+            send: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const responses = [];
+                for (let i = 0; i < transactions.length; i++) {
+                    const response = yield this.execute(transactions[i]);
+                    response.hopIndex = i;
+                    if (i > 0 && responses[i - 1]) {
+                        response.parentTxHash = responses[i - 1].hash;
+                        responses[i - 1].childTxHash = response.hash;
+                    }
+                    responses.push(response);
+                }
+                return {
+                    transactions: responses,
+                    chains: responses.map((r) => ({
+                        chain: r.chain || enums_1.CHAIN.PUSH_TESTNET_DONUT,
+                        hash: r.hash,
+                        blockNumber: r.blockNumber,
+                        status: 'confirmed',
+                    })),
+                };
+            }),
+        };
+    }
+    /**
+     * Route 2: Execute outbound transaction from Push Chain to external CEA
+     *
+     * This method builds a multicall that executes on Push Chain (from UEA context):
+     * 1. Approves the gateway to spend PRC-20 tokens (if needed)
+     * 2. Calls sendUniversalTxOutbound on UniversalGatewayPC precompile
+     *
+     * The multicall is executed through the normal execute() flow which handles
+     * fee-locking on the origin chain and signature verification.
+     *
+     * @param params - Universal execution parameters with ChainTarget
+     * @returns UniversalTxResponse
+     */
+    executeUoaToCea(params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            const target = params.to;
+            const targetChain = target.chain;
+            const targetAddress = target.address;
+            const isSvm = (0, payload_builders_1.isSvmChain)(targetChain);
+            // Validate target address based on VM type
+            if (isSvm) {
+                // SVM: 32-byte hex address
+                if (!(0, payload_builders_1.isValidSolanaHexAddress)(targetAddress)) {
+                    throw new Error(`Invalid Solana address: ${targetAddress}. ` +
+                        `Expected 0x + 64 hex chars (32 bytes).`);
+                }
+                const ZERO_32 = ('0x' + '0'.repeat(64));
+                if (targetAddress.toLowerCase() === ZERO_32.toLowerCase()) {
+                    throw new Error(`Cannot send to zero address on Solana. ` +
+                        `This would result in permanent loss of funds.`);
+                }
+            }
+            else {
+                // EVM: 20-byte hex address
+                // Zero address is allowed for multicall (data is array) — the actual targets are in the data entries.
+                const isMulticall = Array.isArray(params.data);
+                if (targetAddress.toLowerCase() === selectors_1.ZERO_ADDRESS.toLowerCase() && !isMulticall) {
+                    throw new Error(`Cannot send to zero address (0x0000...0000). ` +
+                        `This would result in permanent loss of funds.`);
+                }
+            }
+            // Validate chain supports outbound operations
+            if (!(0, cea_utils_1.chainSupportsOutbound)(targetChain)) {
+                throw new Error(`Chain ${targetChain} does not support outbound operations. ` +
+                    `Supported chains: BNB_TESTNET, ETHEREUM_SEPOLIA, SOLANA_DEVNET, etc.`);
+            }
+            // Branch based on VM type
+            if (isSvm) {
+                return this.executeUoaToCeaSvm(params, target);
+            }
+            // ===== EVM path (existing logic) =====
+            // Get UEA address
+            const ueaAddress = this.computeUEAOffchain();
+            this.printLog(`executeUoaToCea — target chain: ${targetChain}, target address: ${targetAddress}, UEA: ${ueaAddress}`);
+            // Get CEA address for this UEA on target chain
+            const { cea: ceaAddress, isDeployed: ceaDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain, (_a = this.rpcUrls[targetChain]) === null || _a === void 0 ? void 0 : _a[0]);
+            this.printLog(`executeUoaToCea — CEA address: ${ceaAddress}, deployed: ${ceaDeployed}`);
+            // Migration path: raw MIGRATION_SELECTOR payload, no multicall wrapping
+            let ceaPayload;
+            let prc20Token = selectors_1.ZERO_ADDRESS;
+            let burnAmount = BigInt(0);
+            if (params.migration) {
+                ceaPayload = (0, payload_builders_1.buildMigrationPayload)();
+                prc20Token = this.getNativePRC20ForChain(targetChain);
+                burnAmount = BigInt(0); // Migration is logic-only — no funds. CEA rejects msg.value != 0.
+                this.printLog(`executeUoaToCea — MIGRATION: using raw MIGRATION_SELECTOR payload (${ceaPayload}), native PRC-20 ${prc20Token}`);
+            }
+            else {
+                // Build multicall for CEA execution on target chain
+                const ceaMulticalls = [];
+                // If there's data to execute on target
+                if (params.data) {
+                    if (Array.isArray(params.data)) {
+                        // User provided explicit multicall array
+                        ceaMulticalls.push(...params.data);
+                    }
+                    else {
+                        // When ERC-20 funds are provided with a single payload, auto-prepend a
+                        // transfer() call so the tokens minted to the CEA are forwarded to the
+                        // target address. This mirrors the Route 1 behavior in buildExecuteMulticall.
+                        if ((_b = params.funds) === null || _b === void 0 ? void 0 : _b.amount) {
+                            const token = params.funds.token;
+                            if (token && token.mechanism !== 'native') {
+                                const erc20Transfer = (0, viem_1.encodeFunctionData)({
+                                    abi: abi_1.ERC20_EVM,
+                                    functionName: 'transfer',
+                                    args: [targetAddress, params.funds.amount],
+                                });
+                                ceaMulticalls.push({
+                                    to: token.address,
+                                    value: BigInt(0),
+                                    data: erc20Transfer,
+                                });
+                            }
+                        }
+                        // Single call with data. Forward native value (if any) so the target
+                        // contract receives it alongside the payload call. The vault deposits
+                        // native value to the CEA, and the multicall forwards it to the target.
+                        ceaMulticalls.push({
+                            to: targetAddress,
+                            value: (_c = params.value) !== null && _c !== void 0 ? _c : BigInt(0),
+                            data: params.data,
+                        });
+                    }
+                }
+                else if (params.value) {
+                    // Native value transfer only.
+                    // If sending to the CEA itself, skip the multicall — the gateway deposits native
+                    // value directly to CEA. A self-call with value would revert (CEA._handleMulticall
+                    // rejects value-bearing self-calls).
+                    if (targetAddress.toLowerCase() !== ceaAddress.toLowerCase()) {
+                        ceaMulticalls.push({
+                            to: targetAddress,
+                            value: params.value,
+                            data: '0x',
+                        });
+                    }
+                }
+                // Build CEA multicall payload (this is what gets executed on the external chain)
+                ceaPayload = (0, payload_builders_1.buildCeaMulticallPayload)(ceaMulticalls);
+                // Determine token to burn on Push Chain
+                // NOTE: Even for PAYLOAD-only (no value), we need a valid PRC-20 token to:
+                // 1. Look up the target chain namespace in the gateway
+                // 2. Query and pay gas fees for the relay
+                if ((_d = params.funds) === null || _d === void 0 ? void 0 : _d.amount) {
+                    // User explicitly specified funds with token
+                    const token = params.funds.token;
+                    if (token) {
+                        prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                        burnAmount = params.funds.amount;
+                    }
+                }
+                else if (params.value && params.value > BigInt(0)) {
+                    // Native value transfer: auto-select the PRC-20 token for target chain
+                    prc20Token = this.getNativePRC20ForChain(targetChain);
+                    burnAmount = params.value;
+                    this.printLog(`executeUoaToCea — auto-selected native PRC-20 ${prc20Token} for chain ${targetChain}, amount: ${burnAmount.toString()}`);
+                }
+                else if (params.data) {
+                    // PAYLOAD-only (no value transfer): still need native token for chain namespace + gas fees
+                    prc20Token = this.getNativePRC20ForChain(targetChain);
+                    burnAmount = BigInt(0);
+                    this.printLog(`executeUoaToCea — PAYLOAD-only: using native PRC-20 ${prc20Token} for chain ${targetChain} with zero burn amount`);
+                }
+            }
+            // Build outbound request struct for the gateway
+            // NOTE: `target` is a LEGACY/DUMMY parameter for contract compatibility.
+            // The deployed UniversalGatewayPC still expects this field, but the relay does NOT use it
+            // to determine the actual destination. The relay determines destination from the PRC-20 token's
+            // SOURCE_CHAIN_NAMESPACE. We pass the CEA address as a non-zero placeholder.
+            // This field will be removed in future contract upgrades.
+            const targetBytes = ceaAddress; // Dummy value - any non-zero address works
+            const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_e = params.gasLimit) !== null && _e !== void 0 ? _e : BigInt(0), ceaPayload, ueaAddress // revert recipient is the UEA
+            );
+            this.printLog(`executeUoaToCea — outbound request: ${JSON.stringify({
+                target: outboundReq.target,
+                token: outboundReq.token,
+                amount: outboundReq.amount.toString(),
+                gasLimit: outboundReq.gasLimit.toString(),
+                payloadLength: outboundReq.payload.length,
+                revertRecipient: outboundReq.revertRecipient,
+            }, null, 2)}`);
+            // Get UniversalGatewayPC address
+            const gatewayPcAddress = this.getUniversalGatewayPCAddress();
+            // Pre-fetch UEA status early — balance is needed for gas value calculation
+            const [ueaCode, ueaBalance] = yield Promise.all([
+                this.pushClient.publicClient.getCode({ address: ueaAddress }),
+                this.pushClient.getBalance(ueaAddress),
+            ]);
+            const isUEADeployed = ueaCode !== undefined;
+            const ueaNonce = isUEADeployed ? yield this.getUEANonce(ueaAddress) : BigInt(0);
+            // Build the multicall that will execute ON Push Chain from UEA context
+            // This includes: 1) approve PRC-20 (if needed), 2) call sendUniversalTxOutbound
+            const pushChainMulticalls = [];
+            // Query gas fee from UniversalCore contract (needed for approval amount)
+            let gasFee = BigInt(0);
+            let nativeValueForGas = BigInt(0);
+            let gasToken = selectors_1.ZERO_ADDRESS;
+            if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+                try {
+                    const result = yield this.queryOutboundGasFee(prc20Token, outboundReq.gasLimit);
+                    gasFee = result.gasFee;
+                    gasToken = result.gasToken;
+                    nativeValueForGas = result.nativeValueForGas;
+                    this.printLog(`executeUoaToCea — queried gas fee: ${gasFee.toString()}, gasToken: ${gasToken}, nativeValueForGas: ${nativeValueForGas.toString()}`);
+                }
+                catch (err) {
+                    throw new Error(`Failed to query outbound gas fee: ${err}`);
+                }
+            }
+            // Adjust nativeValueForGas: the 1Mx multiplier from queryOutboundGasFee produces
+            // a value far too low for the actual WPC/gasToken swap price. Set it to 200 UPC
+            // (capped by balance) — enough for the swap, but avoids draining thin pools.
+            // The contract's swapAndBurnGas does exactOutputSingle and refunds excess PC.
+            const EVM_NATIVE_VALUE_TARGET = BigInt(200e18); // 200 UPC
+            const EVM_GAS_RESERVE = BigInt(3e18); // 3 UPC for tx overhead
+            const currentBalance = yield this.pushClient.getBalance(ueaAddress);
+            let adjustedValue;
+            if (currentBalance > EVM_NATIVE_VALUE_TARGET + EVM_GAS_RESERVE) {
+                // Enough balance: use 200 UPC target
+                adjustedValue = EVM_NATIVE_VALUE_TARGET;
+            }
+            else if (currentBalance > EVM_GAS_RESERVE) {
+                // Low balance: use what's available minus reserve
+                adjustedValue = currentBalance - EVM_GAS_RESERVE;
+            }
+            else {
+                // Very low balance: use original query value as-is
+                adjustedValue = nativeValueForGas;
+            }
+            if (adjustedValue !== nativeValueForGas) {
+                this.printLog(`executeUoaToCea — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (UEA balance: ${currentBalance.toString()})`);
+                nativeValueForGas = adjustedValue;
+            }
+            // Build outbound multicalls (approve burn + sendUniversalTxOutbound with native value)
+            const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+                prc20Token,
+                gasToken,
+                burnAmount,
+                gasFee,
+                nativeValueForGas,
+                gatewayPcAddress,
+                outboundRequest: outboundReq,
+            });
+            pushChainMulticalls.push(...outboundMulticalls);
+            this.printLog(`executeUoaToCea — Push Chain multicall has ${pushChainMulticalls.length} operations`);
+            // Execute through the normal execute() flow
+            // This handles fee-locking on origin chain and executes the multicall from UEA context
+            // Sum native values from multicall entries for proper fee calculation
+            const multicallNativeValue = pushChainMulticalls.reduce((sum, mc) => { var _a; return sum + ((_a = mc.value) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+            const executeParams = {
+                to: ueaAddress, // multicall executes from UEA
+                value: multicallNativeValue, // ensures correct requiredFunds calculation
+                data: pushChainMulticalls, // array triggers multicall mode
+                _ueaStatus: {
+                    isDeployed: isUEADeployed,
+                    nonce: ueaNonce,
+                    balance: ueaBalance,
+                },
+                _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+            };
+            const response = yield this.execute(executeParams);
+            // Add chain info to response
+            response.chain = targetChain;
+            response.chainNamespace = this.getChainNamespace(targetChain);
+            return response;
+        });
+    }
+    /**
+     * Route 2 for SVM targets: Outbound from Push Chain to Solana.
+     *
+     * Three cases:
+     * 1. Withdraw SOL: Burn pSOL on Push Chain, recipient gets native SOL
+     * 2. Withdraw SPL: Burn PRC-20 on Push Chain, recipient gets SPL token
+     * 3. Execute (CPI): Burn pSOL + execute CPI on target Solana program
+     *
+     * @param params - Universal execution parameters
+     * @param target - ChainTarget with Solana chain and hex address
+     * @returns UniversalTxResponse
+     */
+    executeUoaToCeaSvm(params, target) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const targetChain = target.chain;
+            const targetAddress = target.address; // 0x-prefixed, 32 bytes
+            const ueaAddress = this.computeUEAOffchain();
+            const hasSvmExecute = !!params.svmExecute;
+            this.printLog(`executeUoaToCeaSvm — target: ${targetAddress}, chain: ${targetChain}, ` +
+                `hasSvmExecute: ${hasSvmExecute}, value: ${(_b = (_a = params.value) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '0'}`);
+            // --- Build SVM payload ---
+            let svmPayload = '0x'; // empty for withdraw (SOL/SPL)
+            if (hasSvmExecute) {
+                // Execute case: encode the CPI payload
+                const exec = params.svmExecute;
+                svmPayload = (0, payload_builders_1.encodeSvmExecutePayload)({
+                    targetProgram: exec.targetProgram,
+                    accounts: exec.accounts,
+                    ixData: exec.ixData,
+                    instructionId: 2,
+                });
+                this.printLog(`executeUoaToCeaSvm — encoded execute payload: ${(svmPayload.length - 2) / 2} bytes, ` +
+                    `${exec.accounts.length} accounts`);
+            }
+            // --- Determine PRC-20 token and burn amount ---
+            let prc20Token = selectors_1.ZERO_ADDRESS;
+            let burnAmount = BigInt(0);
+            if ((_c = params.funds) === null || _c === void 0 ? void 0 : _c.amount) {
+                // User explicitly specified funds with token
+                const token = params.funds.token;
+                if (token) {
+                    prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                    burnAmount = params.funds.amount;
+                }
+            }
+            else if (params.value && params.value > BigInt(0)) {
+                // Native value transfer: auto-select pSOL for Solana chains
+                prc20Token = this.getNativePRC20ForChain(targetChain);
+                burnAmount = params.value;
+                this.printLog(`executeUoaToCeaSvm — auto-selected native PRC-20 ${prc20Token} for chain ${targetChain}, amount: ${burnAmount.toString()}`);
+            }
+            else if (hasSvmExecute) {
+                // Execute-only (no value): check if user specified an SPL token context
+                const token = params.funds && params.funds.token;
+                if (token) {
+                    prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                }
+                else {
+                    prc20Token = this.getNativePRC20ForChain(targetChain);
+                }
+                burnAmount = BigInt(0);
+                this.printLog(`executeUoaToCeaSvm — EXECUTE-only: using PRC-20 ${prc20Token} with zero burn amount`);
+            }
+            // --- Determine target bytes ---
+            // For withdraw: target is the Solana recipient pubkey
+            // For execute: target is the target Solana program
+            const targetBytes = hasSvmExecute
+                ? params.svmExecute.targetProgram
+                : targetAddress;
+            // --- Build outbound request ---
+            const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_d = params.gasLimit) !== null && _d !== void 0 ? _d : BigInt(0), svmPayload, ueaAddress // revert recipient is the UEA
+            );
+            this.printLog(`executeUoaToCeaSvm — outbound request: ${JSON.stringify({
+                target: outboundReq.target,
+                token: outboundReq.token,
+                amount: outboundReq.amount.toString(),
+                gasLimit: outboundReq.gasLimit.toString(),
+                payloadLength: (outboundReq.payload.length - 2) / 2,
+                revertRecipient: outboundReq.revertRecipient,
+            }, null, 2)}`);
+            // --- Pre-fetch UEA status early — balance is needed for gas value calculation ---
+            const gatewayPcAddress = this.getUniversalGatewayPCAddress();
+            const [ueaCode, ueaBalance] = yield Promise.all([
+                this.pushClient.publicClient.getCode({ address: ueaAddress }),
+                this.pushClient.getBalance(ueaAddress),
+            ]);
+            const isUEADeployed = ueaCode !== undefined;
+            const ueaNonce = isUEADeployed
+                ? yield this.getUEANonce(ueaAddress)
+                : BigInt(0);
+            // --- Query gas fee (identical to EVM path) ---
+            let gasFee = BigInt(0);
+            let gasToken = selectors_1.ZERO_ADDRESS;
+            let nativeValueForGas = BigInt(0);
+            if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+                const gasLimit = outboundReq.gasLimit;
+                try {
+                    const result = yield this.queryOutboundGasFee(prc20Token, gasLimit);
+                    gasFee = result.gasFee;
+                    gasToken = result.gasToken;
+                    nativeValueForGas = result.nativeValueForGas;
+                    // When user omits gasLimit (sent as 0), the contract computes fees using its internal
+                    // baseGasLimitByChainNamespace. But the relay reads the stored gasLimit=0 from the
+                    // on-chain outbound record and uses it as the Solana compute budget — 0 CU means the
+                    // relay cannot execute the tx. Derive the effective limit from gasFee/gasPrice so
+                    // the stored record has a non-zero compute budget the relay can use.
+                    if (!params.gasLimit && result.gasPrice > BigInt(0)) {
+                        outboundReq.gasLimit = result.gasFee / result.gasPrice;
+                        this.printLog(`executeUoaToCeaSvm — derived effectiveGasLimit: ${outboundReq.gasLimit} (gasFee=${result.gasFee} / gasPrice=${result.gasPrice})`);
+                    }
+                    this.printLog(`executeUoaToCeaSvm — queried gas fee: ${gasFee.toString()}, gasToken: ${gasToken}, nativeValueForGas: ${nativeValueForGas.toString()}`);
+                }
+                catch (err) {
+                    throw new Error(`Failed to query outbound gas fee: ${err}`);
+                }
+            }
+            // Adjust nativeValueForGas: the 1Mx multiplier from queryOutboundGasFee produces
+            // a value far too low for the actual WPC/gasToken swap price. Set it to 200 UPC
+            // (capped by balance) — enough for the swap, but avoids draining thin pools.
+            // The contract's swapAndBurnGas does exactOutputSingle and refunds excess PC.
+            const SVM_NATIVE_VALUE_TARGET = BigInt(200e18); // 200 UPC
+            const SVM_GAS_RESERVE = BigInt(3e18); // 3 UPC for tx overhead
+            const currentBalance = yield this.pushClient.getBalance(ueaAddress);
+            let adjustedValue;
+            if (currentBalance > SVM_NATIVE_VALUE_TARGET + SVM_GAS_RESERVE) {
+                // Enough balance: use 200 UPC target
+                adjustedValue = SVM_NATIVE_VALUE_TARGET;
+            }
+            else if (currentBalance > SVM_GAS_RESERVE) {
+                // Low balance: use what's available minus reserve
+                adjustedValue = currentBalance - SVM_GAS_RESERVE;
+            }
+            else {
+                // Very low balance: use original query value as-is
+                adjustedValue = nativeValueForGas;
+            }
+            if (adjustedValue !== nativeValueForGas) {
+                this.printLog(`executeUoaToCeaSvm — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (UEA balance: ${currentBalance.toString()})`);
+                nativeValueForGas = adjustedValue;
+            }
+            // --- Build Push Chain multicalls (approve + sendUniversalTxOutbound) ---
+            // Reuse the same builder as EVM — this part is identical
+            const pushChainMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+                prc20Token,
+                gasToken,
+                burnAmount,
+                gasFee,
+                nativeValueForGas,
+                gatewayPcAddress,
+                outboundRequest: outboundReq,
+            });
+            this.printLog(`executeUoaToCeaSvm — Push Chain multicall has ${pushChainMulticalls.length} operations`);
+            // Sum native values from multicall entries for proper fee calculation
+            const multicallNativeValue = pushChainMulticalls.reduce((sum, mc) => { var _a; return sum + ((_a = mc.value) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+            const executeParams = {
+                to: ueaAddress,
+                value: multicallNativeValue, // ensures correct requiredFunds calculation
+                data: pushChainMulticalls,
+                _ueaStatus: {
+                    isDeployed: isUEADeployed,
+                    nonce: ueaNonce,
+                    balance: ueaBalance,
+                },
+                _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+            };
+            const response = yield this.execute(executeParams);
+            // Add chain info to response
+            response.chain = targetChain;
+            response.chainNamespace = this.getChainNamespace(targetChain);
+            return response;
+        });
+    }
+    /**
+     * Route 3: Execute inbound transaction from CEA to Push Chain
+     *
+     * This route instructs CEA on an external chain to call sendUniversalTxFromCEA,
+     * bridging funds/payloads back to Push Chain.
+     *
+     * Flow:
+     * 1. Build multicall for CEA: [approve Gateway (if ERC20), sendUniversalTxFromCEA]
+     * 2. Execute via Route 2 (UOA → CEA) with PAYLOAD-only (CEA uses its own funds)
+     * 3. CEA executes multicall, Gateway locks funds, relayer mints PRC-20 on Push Chain
+     *
+     * @param params - Universal execution parameters with from.chain specified
+     * @returns UniversalTxResponse
+     */
+    executeCeaToPush(params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            // 1. Validate and extract source chain
+            if (!((_a = params.from) === null || _a === void 0 ? void 0 : _a.chain)) {
+                throw new Error('Route 3 (CEA → Push) requires from.chain to specify the source CEA chain');
+            }
+            const sourceChain = params.from.chain;
+            // SVM chains use a fundamentally different flow (gateway self-call, not CEA multicall)
+            if ((0, payload_builders_1.isSvmChain)(sourceChain)) {
+                return this.executeCeaToPushSvm(params, sourceChain);
+            }
+            // 2. Extract destination on Push Chain
+            // For Route 3, 'to' is a Push Chain address (string), not a ChainTarget
+            const pushDestination = params.to;
+            if (typeof params.to !== 'string') {
+                throw new Error('Route 3 (CEA → Push): to must be a Push Chain address (string), not a ChainTarget');
+            }
+            // 3. Get UEA address (will be recipient on Push Chain from CEA's perspective)
+            const ueaAddress = this.computeUEAOffchain();
+            // 4. Get CEA address on source chain
+            const { cea: ceaAddress, isDeployed: ceaDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_b = this.rpcUrls[sourceChain]) === null || _b === void 0 ? void 0 : _b[0]);
+            this.printLog(`executeCeaToPush — sourceChain: ${sourceChain}, CEA: ${ceaAddress}, deployed: ${ceaDeployed}`);
+            if (!ceaDeployed) {
+                throw new Error(`CEA not deployed on ${sourceChain}. ` +
+                    `Deploy CEA first using Route 2 (UOA → CEA) before using Route 3.`);
+            }
+            // 5. Get UniversalGateway address on source chain
+            const gatewayAddress = chain_1.UNIVERSAL_GATEWAY_ADDRESSES[sourceChain];
+            if (!gatewayAddress) {
+                throw new Error(`No UniversalGateway address configured for chain ${sourceChain}`);
+            }
+            // 6. Build multicall for CEA to execute on source chain (self-calls via sendUniversalTxToUEA)
+            const ceaMulticalls = [];
+            // Determine token and amount for sendUniversalTxToUEA
+            let tokenAddress = selectors_1.ZERO_ADDRESS;
+            let amount = BigInt(0);
+            if ((_c = params.funds) === null || _c === void 0 ? void 0 : _c.amount) {
+                // ERC20 token transfer from CEA
+                const token = params.funds.token;
+                if (token) {
+                    if (token.mechanism === 'native') {
+                        // Native token (e.g., BNB on BSC)
+                        tokenAddress = selectors_1.ZERO_ADDRESS;
+                        amount = params.funds.amount;
+                    }
+                    else {
+                        // ERC20 token - need approval for gateway before sendUniversalTxToUEA
+                        tokenAddress = token.address;
+                        amount = params.funds.amount;
+                    }
+                }
+            }
+            else if (params.value && params.value > BigInt(0)) {
+                // Native value transfer (e.g., BNB, ETH)
+                tokenAddress = selectors_1.ZERO_ADDRESS;
+                amount = params.value;
+            }
+            // bridgeAmount = only the burn amount (what the Vault will actually deposit to CEA).
+            // Previously this included ceaExistingBalance (CEA's pre-existing balance on the
+            // external chain), but that approach is racy: the balance can change between the SDK
+            // query and relay execution, causing sendUniversalTxToUEA to revert with
+            // InsufficientBalance. Pre-existing CEA funds remain parked and can be swept separately.
+            let bridgeAmount = amount;
+            // Note: CEA contract may reject amount=0 in sendUniversalTxToUEA.
+            // Keeping bridgeAmount as-is (0) for payload-only to test precompile behavior.
+            // For ERC20 tokens, add approve call for the bridge amount
+            // (CEA approves gateway to spend the Vault-deposited amount)
+            if (tokenAddress !== selectors_1.ZERO_ADDRESS && bridgeAmount > BigInt(0)) {
+                const approveData = (0, viem_1.encodeFunctionData)({
+                    abi: abi_1.ERC20_EVM,
+                    functionName: 'approve',
+                    args: [gatewayAddress, bridgeAmount],
+                });
+                ceaMulticalls.push({
+                    to: tokenAddress,
+                    value: BigInt(0),
+                    data: approveData,
+                });
+            }
+            // Pre-fetch UEA nonce — needed for the inbound UniversalPayload struct
+            const ueaCode = yield this.pushClient.publicClient.getCode({ address: ueaAddress });
+            const isUEADeployed = ueaCode !== undefined;
+            const ueaNonce = isUEADeployed ? yield this.getUEANonce(ueaAddress) : BigInt(0);
+            // Build payload for Push Chain execution (if any)
+            // This is what happens AFTER funds arrive on Push Chain.
+            // The relay expects a full UniversalPayload struct (to, value, data, gasLimit, ...),
+            // where `data` contains the multicall payload (with UEA_MULTICALL_SELECTOR prefix).
+            let pushPayload = '0x';
+            if (params.data) {
+                const multicallData = (0, payload_builders_1.buildExecuteMulticall)({
+                    execute: {
+                        to: pushDestination,
+                        value: params.value,
+                        data: params.data,
+                    },
+                    ueaAddress,
+                });
+                const multicallPayload = this._buildMulticallPayloadData(pushDestination, multicallData);
+                // Use ueaNonce + 1: the outbound tx itself consumes one nonce via execute(),
+                // so the inbound will arrive when the UEA nonce is already incremented.
+                pushPayload = (0, payload_builders_1.buildInboundUniversalPayload)(multicallPayload, { nonce: ueaNonce + BigInt(1) });
+            }
+            // Build sendUniversalTxToUEA self-call on CEA
+            // CEA multicall: to=CEA (self-call), value=0
+            // CEA internally calls gateway.sendUniversalTxFromCEA(...)
+            // Uses bridgeAmount (= burn amount deposited by Vault)
+            const sendUniversalTxCall = (0, payload_builders_1.buildSendUniversalTxToUEA)(ceaAddress, // to: CEA address (self-call)
+            tokenAddress, // token: address(0) for native, ERC20 address otherwise
+            bridgeAmount, // amount: burn amount only (Vault-deposited)
+            pushPayload, // payload: Push Chain execution payload
+            ueaAddress // revertRecipient: UEA on Push Chain (receives refund if inbound fails)
+            );
+            ceaMulticalls.push(sendUniversalTxCall);
+            // 7. Encode CEA multicalls into outbound payload
+            // CEA will self-execute this multicall (to=CEA, value=0)
+            const ceaPayload = (0, payload_builders_1.buildCeaMulticallPayload)(ceaMulticalls);
+            this.printLog(`executeCeaToPush — CEA payload (first 100 chars): ${ceaPayload.slice(0, 100)}...`);
+            // 8. Determine PRC-20 token for the outbound burn on Push Chain.
+            // For ERC20 flows (params.funds with token), use the token's PRC-20 (e.g. pUSDT)
+            // so the Vault deposits ERC20 to CEA. For native flows, use the chain's native PRC-20 (e.g. pBNB).
+            let prc20Token;
+            if (((_d = params.funds) === null || _d === void 0 ? void 0 : _d.amount) && params.funds.token) {
+                const token = params.funds.token;
+                prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+            }
+            else {
+                prc20Token = this.getNativePRC20ForChain(sourceChain);
+            }
+            // burnAmount = PRC20 to burn on Push Chain (NOT the bridge amount).
+            // Vault deposits burnAmount to CEA. CEA uses burnAmount + pre-existing balance for the bridge.
+            const burnAmount = amount;
+            this.printLog(`executeCeaToPush — prc20Token: ${prc20Token}, burnAmount: ${burnAmount.toString()}`);
+            // 9. Build outbound request (same structure as Route 2)
+            // target = CEA address (for self-execution), value = 0 in payload
+            const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, // target: CEA address (to=CEA for self-execution)
+            prc20Token, // token: native PRC-20 for source chain (for namespace lookup)
+            burnAmount, // amount: 1 wei (precompile workaround)
+            (_e = params.gasLimit) !== null && _e !== void 0 ? _e : BigInt(0), ceaPayload, // payload: ABI-encoded CEA multicall
+            ueaAddress // revertRecipient: UEA
+            );
+            this.printLog(`executeCeaToPush — outbound request: ${JSON.stringify({
+                target: outboundReq.target,
+                token: outboundReq.token,
+                amount: outboundReq.amount.toString(),
+                gasLimit: outboundReq.gasLimit.toString(),
+                payloadLength: outboundReq.payload.length,
+                revertRecipient: outboundReq.revertRecipient,
+            }, null, 2)}`);
+            // 10. Fetch UEA balance — needed for gas value calculation
+            // (UEA code + nonce already fetched above for the inbound UniversalPayload)
+            const gatewayPcAddress = this.getUniversalGatewayPCAddress();
+            const ueaBalance = yield this.pushClient.getBalance(ueaAddress);
+            // 11. Query gas fees from UniversalCore
+            let gasFee = BigInt(0);
+            let nativeValueForGas = BigInt(0);
+            let gasToken = selectors_1.ZERO_ADDRESS;
+            if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+                const gasLimit = outboundReq.gasLimit;
+                try {
+                    const result = yield this.queryOutboundGasFee(prc20Token, gasLimit);
+                    gasToken = result.gasToken;
+                    gasFee = result.gasFee;
+                    nativeValueForGas = result.nativeValueForGas;
+                    this.printLog(`executeCeaToPush — queried gas fee: ${gasFee.toString()}, gasToken: ${gasToken}, nativeValueForGas: ${nativeValueForGas.toString()}`);
+                }
+                catch (err) {
+                    throw new Error(`Failed to query outbound gas fee for Route 3: ${err}`);
+                }
+            }
+            // Adjust nativeValueForGas using UEA balance (contract refunds excess)
+            // Re-fetch balance to minimize staleness from gas fee query RPC roundtrips
+            const currentBalance = yield this.pushClient.getBalance(ueaAddress);
+            // Cosmos-EVM tx overhead costs ~1 PC per operation; 3 PC covers approve(s) + buffer.
+            const OUTBOUND_GAS_RESERVE_R3 = BigInt(3e18);
+            if (currentBalance > OUTBOUND_GAS_RESERVE_R3 && currentBalance - OUTBOUND_GAS_RESERVE_R3 > nativeValueForGas) {
+                const adjustedValue = currentBalance - OUTBOUND_GAS_RESERVE_R3;
+                this.printLog(`executeCeaToPush — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (UEA balance: ${currentBalance.toString()})`);
+                nativeValueForGas = adjustedValue;
+            }
+            // 12. Build Push Chain multicalls (approvals + sendUniversalTxOutbound)
+            const pushChainMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+                prc20Token,
+                gasToken,
+                burnAmount,
+                gasFee,
+                nativeValueForGas,
+                gatewayPcAddress,
+                outboundRequest: outboundReq,
+            });
+            this.printLog(`executeCeaToPush — Push Chain multicall has ${pushChainMulticalls.length} operations`);
+            // Sum native values from multicall entries for proper fee calculation
+            const multicallNativeValue = pushChainMulticalls.reduce((sum, mc) => { var _a; return sum + ((_a = mc.value) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+            // 13. Execute through the normal execute() flow
+            const executeParams = {
+                to: ueaAddress,
+                value: multicallNativeValue, // ensures correct requiredFunds calculation
+                data: pushChainMulticalls,
+                _ueaStatus: {
+                    isDeployed: isUEADeployed,
+                    nonce: ueaNonce,
+                    balance: ueaBalance,
+                },
+                _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+            };
+            const response = yield this.execute(executeParams);
+            // Add Route 3 context to response
+            response.chain = sourceChain;
+            const chainInfo = chain_1.CHAIN_INFO[sourceChain];
+            response.chainNamespace = `${chain_1.VM_NAMESPACE[chainInfo.vm]}:${chainInfo.chainId}`;
+            return response;
+        });
+    }
+    /**
+     * Route 3 SVM: Execute CEA-to-Push for Solana chains.
+     *
+     * Unlike EVM Route 3 which builds CEA multicalls, SVM Route 3 encodes a
+     * `send_universal_tx_to_uea` instruction as an execute payload targeting
+     * the SVM gateway program (self-call). The drain amount is embedded in
+     * the instruction data, not in the outbound request amount.
+     */
+    executeCeaToPushSvm(params, sourceChain) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (typeof params.to !== 'string') {
+                throw new Error('Route 3 SVM (CEA → Push): to must be a Push Chain address (string), not a ChainTarget');
+            }
+            const ueaAddress = this.computeUEAOffchain();
+            // Get gateway program ID from chain config and convert to 0x-hex 32 bytes
+            const lockerContract = chain_1.CHAIN_INFO[sourceChain].lockerContract;
+            if (!lockerContract) {
+                throw new Error(`No SVM gateway program configured for chain ${sourceChain}`);
+            }
+            const programPk = new web3_js_1.PublicKey(lockerContract);
+            const gatewayProgramHex = ('0x' + Buffer.from(programPk.toBytes()).toString('hex'));
+            this.printLog(`executeCeaToPushSvm — sourceChain: ${sourceChain}, gateway: ${lockerContract}`);
+            // Determine drain amount and token
+            let drainAmount = BigInt(0);
+            let tokenMintHex;
+            let prc20Token;
+            if (((_a = params.funds) === null || _a === void 0 ? void 0 : _a.amount) && params.funds.amount > BigInt(0)) {
+                // SPL token drain
+                drainAmount = params.funds.amount;
+                const token = params.funds.token;
+                if (token && token.address) {
+                    // Convert SPL mint address to 32-byte hex
+                    const mintPk = new web3_js_1.PublicKey(token.address);
+                    tokenMintHex = ('0x' + Buffer.from(mintPk.toBytes()).toString('hex'));
+                    prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                }
+                else {
+                    prc20Token = this.getNativePRC20ForChain(sourceChain);
+                }
+            }
+            else if (params.value && params.value > BigInt(0)) {
+                // Native SOL drain
+                drainAmount = params.value;
+                prc20Token = this.getNativePRC20ForChain(sourceChain);
+            }
+            else {
+                // Payload-only Route 3 SVM: no funds to drain, just execute data on Push Chain
+                drainAmount = BigInt(0);
+                prc20Token = this.getNativePRC20ForChain(sourceChain);
+            }
+            // Build the SVM CPI payload (send_universal_tx_to_uea wrapped in execute)
+            // If params.data is provided, pass it as extraPayload for Push Chain execution
+            let extraPayload;
+            if (params.data && typeof params.data === 'string') {
+                extraPayload = (0, viem_1.hexToBytes)(params.data);
+            }
+            // Derive CEA PDA as revert recipient: ["push_identity", ueaAddress_20_bytes]
+            const ueaBytes = Buffer.from(ueaAddress.slice(2), 'hex'); // 20 bytes
+            const [ceaPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('push_identity'), ueaBytes], programPk);
+            const ceaPdaHex = ('0x' + Buffer.from(ceaPda.toBytes()).toString('hex'));
+            const svmPayload = (0, payload_builders_1.encodeSvmCeaToUeaPayload)({
+                gatewayProgramHex,
+                drainAmount,
+                tokenMintHex,
+                extraPayload,
+                revertRecipientHex: ceaPdaHex,
+            });
+            this.printLog(`executeCeaToPushSvm — drainAmount: ${drainAmount.toString()}, payload length: ${(svmPayload.length - 2) / 2} bytes`);
+            // burnAmount = 1 (minimum for precompile; drain amount lives inside the ixData)
+            // The precompile rejects amount=0, so we use BigInt(1) as a workaround.
+            const burnAmount = BigInt(1);
+            // Build outbound request: target = gateway program (self-call)
+            const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, prc20Token, burnAmount, (_b = params.gasLimit) !== null && _b !== void 0 ? _b : BigInt(0), svmPayload, ueaAddress);
+            this.printLog(`executeCeaToPushSvm — outbound request: target=${outboundReq.target.slice(0, 20)}..., token=${outboundReq.token}`);
+            // Pre-fetch UEA status early — balance is needed for gas value calculation
+            const gatewayPcAddress = this.getUniversalGatewayPCAddress();
+            const [ueaCode, ueaBalance] = yield Promise.all([
+                this.pushClient.publicClient.getCode({ address: ueaAddress }),
+                this.pushClient.getBalance(ueaAddress),
+            ]);
+            const isUEADeployed = ueaCode !== undefined;
+            const ueaNonce = isUEADeployed ? yield this.getUEANonce(ueaAddress) : BigInt(0);
+            // Query gas fees
+            let gasFee = BigInt(0);
+            let nativeValueForGas = BigInt(0);
+            let gasToken = selectors_1.ZERO_ADDRESS;
+            if (prc20Token !== selectors_1.ZERO_ADDRESS) {
+                try {
+                    const result = yield this.queryOutboundGasFee(prc20Token, outboundReq.gasLimit);
+                    gasToken = result.gasToken;
+                    gasFee = result.gasFee;
+                    nativeValueForGas = result.nativeValueForGas;
+                    this.printLog(`executeCeaToPushSvm — gasFee: ${gasFee.toString()}, gasToken: ${gasToken}, nativeValueForGas: ${nativeValueForGas.toString()}`);
+                }
+                catch (err) {
+                    throw new Error(`Failed to query outbound gas fee for SVM Route 3: ${err}`);
+                }
+            }
+            // Adjust nativeValueForGas using UEA balance (contract refunds excess)
+            // Re-fetch balance to minimize staleness from gas fee query RPC roundtrips
+            const currentBalance = yield this.pushClient.getBalance(ueaAddress);
+            // Cosmos-EVM tx overhead costs ~1 PC per operation; 3 PC covers approve(s) + buffer.
+            const OUTBOUND_GAS_RESERVE_R3_SVM = BigInt(3e18);
+            if (currentBalance > OUTBOUND_GAS_RESERVE_R3_SVM && currentBalance - OUTBOUND_GAS_RESERVE_R3_SVM > nativeValueForGas) {
+                const adjustedValue = currentBalance - OUTBOUND_GAS_RESERVE_R3_SVM;
+                this.printLog(`executeCeaToPushSvm — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (UEA balance: ${currentBalance.toString()})`);
+                nativeValueForGas = adjustedValue;
+            }
+            // Build Push Chain multicalls (approvals + sendUniversalTxOutbound)
+            const pushChainMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
+                prc20Token,
+                gasToken,
+                burnAmount,
+                gasFee,
+                nativeValueForGas,
+                gatewayPcAddress,
+                outboundRequest: outboundReq,
+            });
+            // Sum native values from multicall entries for proper fee calculation
+            const multicallNativeValue = pushChainMulticalls.reduce((sum, mc) => { var _a; return sum + ((_a = mc.value) !== null && _a !== void 0 ? _a : BigInt(0)); }, BigInt(0));
+            // Execute through the normal execute() flow
+            const executeParams = {
+                to: ueaAddress,
+                value: multicallNativeValue, // ensures correct requiredFunds calculation
+                data: pushChainMulticalls,
+                _ueaStatus: {
+                    isDeployed: isUEADeployed,
+                    nonce: ueaNonce,
+                    balance: ueaBalance,
+                },
+                _skipFeeLocking: true, // outbound executes on Push Chain, no external fee locking
+            };
+            const response = yield this.execute(executeParams);
+            // Add Route 3 SVM context to response
+            response.chain = sourceChain;
+            const chainInfo = chain_1.CHAIN_INFO[sourceChain];
+            response.chainNamespace = `${chain_1.VM_NAMESPACE[chainInfo.vm]}:${chainInfo.chainId}`;
+            return response;
+        });
+    }
+    /**
+     * Route 4: Execute CEA to CEA transaction via Push Chain
+     *
+     * @param params - Universal execution parameters with from.chain and to.chain
+     * @returns UniversalTxResponse
+     */
+    executeCeaToCea(params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // CEA → CEA requires chaining Route 3 (CEA → Push) and Route 2 (Push → CEA)
+            // This is a complex flow that requires coordination
+            throw new Error('CEA → CEA transactions are not yet fully implemented. ' +
+                'Use prepareTransaction().thenOn() to chain Route 3 → Route 2 manually.');
+        });
+    }
+    /**
+     * Build payload for a specific route
+     */
+    buildPayloadForRoute(params, route, nonce) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+            const ueaAddress = this.computeUEAOffchain();
+            switch (route) {
+                case route_detector_1.TransactionRoute.UOA_TO_PUSH: {
+                    // Build standard Push Chain payload
+                    const executeParams = this.toExecuteParams(params);
+                    const multicallData = (0, payload_builders_1.buildExecuteMulticall)({
+                        execute: executeParams,
+                        ueaAddress,
+                    });
+                    const payload = this._buildMulticallPayloadData(executeParams.to, multicallData);
+                    const req = this._buildUniversalTxRequest({
+                        recipient: viem_1.zeroAddress,
+                        token: viem_1.zeroAddress,
+                        amount: BigInt(0),
+                        payload,
+                    });
+                    return { payload, gatewayRequest: req };
+                }
+                case route_detector_1.TransactionRoute.UOA_TO_CEA: {
+                    const target = params.to;
+                    // Branch: SVM vs EVM
+                    if ((0, payload_builders_1.isSvmChain)(target.chain)) {
+                        // SVM: build SVM payload (binary or empty for withdraw)
+                        let payload = '0x';
+                        if (params.svmExecute) {
+                            payload = (0, payload_builders_1.encodeSvmExecutePayload)({
+                                targetProgram: params.svmExecute.targetProgram,
+                                accounts: params.svmExecute.accounts,
+                                ixData: params.svmExecute.ixData,
+                                instructionId: 2,
+                            });
+                        }
+                        const targetBytes = (_b = (_a = params.svmExecute) === null || _a === void 0 ? void 0 : _a.targetProgram) !== null && _b !== void 0 ? _b : target.address;
+                        let prc20Token = selectors_1.ZERO_ADDRESS;
+                        let burnAmount = BigInt(0);
+                        if ((_c = params.funds) === null || _c === void 0 ? void 0 : _c.amount) {
+                            const token = params.funds.token;
+                            if (token) {
+                                prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                                burnAmount = params.funds.amount;
+                            }
+                        }
+                        else if (params.value && params.value > BigInt(0)) {
+                            prc20Token = this.getNativePRC20ForChain(target.chain);
+                            burnAmount = params.value;
+                        }
+                        else if (params.svmExecute) {
+                            prc20Token = this.getNativePRC20ForChain(target.chain);
+                            burnAmount = BigInt(1);
+                        }
+                        const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_d = params.gasLimit) !== null && _d !== void 0 ? _d : BigInt(0), payload, ueaAddress);
+                        return { payload, gatewayRequest: outboundReq };
+                    }
+                    // EVM path: Resolve CEA address first (needed for self-transfer check)
+                    const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, target.chain, (_e = this.rpcUrls[target.chain]) === null || _e === void 0 ? void 0 : _e[0]);
+                    // Build CEA outbound payload
+                    const multicalls = [];
+                    if (params.data) {
+                        if (Array.isArray(params.data)) {
+                            multicalls.push(...params.data);
+                        }
+                        else {
+                            // Single call with data. Native value (if any) is already delivered to
+                            // CEA by the Vault via executeUniversalTx{value: amount}(). Attaching
+                            // value to the call would revert if the target function is not payable.
+                            // To call a payable function with value, use explicit multicalls.
+                            multicalls.push({
+                                to: target.address,
+                                value: BigInt(0),
+                                data: params.data,
+                            });
+                        }
+                    }
+                    else if (params.value) {
+                        // Skip multicall when sending native value to own CEA — gateway deposits directly.
+                        // Self-call with value would revert (CEA._handleMulticall rejects it).
+                        if (target.address.toLowerCase() !== ceaAddress.toLowerCase()) {
+                            multicalls.push({
+                                to: target.address,
+                                value: params.value,
+                                data: '0x',
+                            });
+                        }
+                    }
+                    const payload = (0, payload_builders_1.buildCeaMulticallPayload)(multicalls);
+                    let prc20Token = selectors_1.ZERO_ADDRESS;
+                    let burnAmount = BigInt(0);
+                    if ((_f = params.funds) === null || _f === void 0 ? void 0 : _f.amount) {
+                        const token = params.funds.token;
+                        if (token) {
+                            prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                            burnAmount = params.funds.amount;
+                        }
+                    }
+                    const targetBytes = ceaAddress;
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_g = params.gasLimit) !== null && _g !== void 0 ? _g : BigInt(0), payload, ueaAddress);
+                    return { payload, gatewayRequest: outboundReq };
+                }
+                case route_detector_1.TransactionRoute.CEA_TO_PUSH: {
+                    // Route 3: CEA → Push Chain
+                    // Build CEA multicall (approve + sendUniversalTxFromCEA) and wrap in outbound
+                    if (!((_h = params.from) === null || _h === void 0 ? void 0 : _h.chain)) {
+                        throw new Error('Route 3 (CEA → Push) requires from.chain');
+                    }
+                    const sourceChain = params.from.chain;
+                    const pushDestination = params.to;
+                    // SVM chains use gateway self-call, not CEA multicall
+                    if ((0, payload_builders_1.isSvmChain)(sourceChain)) {
+                        const lockerContract = chain_1.CHAIN_INFO[sourceChain].lockerContract;
+                        if (!lockerContract) {
+                            throw new Error(`No SVM gateway program configured for chain ${sourceChain}`);
+                        }
+                        const programPk = new web3_js_1.PublicKey(lockerContract);
+                        const gatewayProgramHex = ('0x' + Buffer.from(programPk.toBytes()).toString('hex'));
+                        let drainAmount = BigInt(0);
+                        let tokenMintHex;
+                        let prc20Token;
+                        if (((_j = params.funds) === null || _j === void 0 ? void 0 : _j.amount) && params.funds.amount > BigInt(0)) {
+                            drainAmount = params.funds.amount;
+                            const token = params.funds.token;
+                            if (token && token.address) {
+                                const mintPk = new web3_js_1.PublicKey(token.address);
+                                tokenMintHex = ('0x' + Buffer.from(mintPk.toBytes()).toString('hex'));
+                                prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+                            }
+                            else {
+                                prc20Token = this.getNativePRC20ForChain(sourceChain);
+                            }
+                        }
+                        else if (params.value && params.value > BigInt(0)) {
+                            drainAmount = params.value;
+                            prc20Token = this.getNativePRC20ForChain(sourceChain);
+                        }
+                        else {
+                            // Payload-only Route 3 SVM: no funds to drain, just execute data on Push Chain
+                            drainAmount = BigInt(0);
+                            prc20Token = this.getNativePRC20ForChain(sourceChain);
+                        }
+                        // Derive CEA PDA as revert recipient
+                        const ueaBytes2 = Buffer.from(ueaAddress.slice(2), 'hex');
+                        const [ceaPda2] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('push_identity'), ueaBytes2], programPk);
+                        const ceaPdaHex2 = ('0x' + Buffer.from(ceaPda2.toBytes()).toString('hex'));
+                        const svmPayload = (0, payload_builders_1.encodeSvmCeaToUeaPayload)({
+                            gatewayProgramHex,
+                            drainAmount,
+                            tokenMintHex,
+                            revertRecipientHex: ceaPdaHex2,
+                        });
+                        // burnAmount = 1 (minimum for precompile; drain amount lives inside the ixData)
+                        const burnAmount = BigInt(1);
+                        const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, prc20Token, burnAmount, (_k = params.gasLimit) !== null && _k !== void 0 ? _k : BigInt(0), svmPayload, ueaAddress);
+                        return { payload: svmPayload, gatewayRequest: outboundReq };
+                    }
+                    const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_l = this.rpcUrls[sourceChain]) === null || _l === void 0 ? void 0 : _l[0]);
+                    const gatewayAddr = chain_1.UNIVERSAL_GATEWAY_ADDRESSES[sourceChain];
+                    if (!gatewayAddr) {
+                        throw new Error(`No UniversalGateway address configured for chain ${sourceChain}`);
+                    }
+                    // Build CEA multicalls (self-calls via sendUniversalTxToUEA)
+                    const ceaMulticalls = [];
+                    let tokenAddress = selectors_1.ZERO_ADDRESS;
+                    let amount = BigInt(0);
+                    if ((_m = params.funds) === null || _m === void 0 ? void 0 : _m.amount) {
+                        const token = params.funds.token;
+                        if (token) {
+                            if (token.mechanism === 'native') {
+                                tokenAddress = selectors_1.ZERO_ADDRESS;
+                                amount = params.funds.amount;
+                            }
+                            else {
+                                tokenAddress = token.address;
+                                amount = params.funds.amount;
+                                // Approve gateway for ERC20 (CEA self-call, value=0)
+                                const approveData = (0, viem_1.encodeFunctionData)({
+                                    abi: abi_1.ERC20_EVM,
+                                    functionName: 'approve',
+                                    args: [gatewayAddr, amount],
+                                });
+                                ceaMulticalls.push({
+                                    to: tokenAddress,
+                                    value: BigInt(0),
+                                    data: approveData,
+                                });
                             }
-                        })();
-                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_02, errMessage);
-                throw err;
-            }
-            finally {
-                // Restore original progressHook
-                this.progressHook = originalHook;
+                        }
+                    }
+                    else if (params.value && params.value > BigInt(0)) {
+                        tokenAddress = selectors_1.ZERO_ADDRESS;
+                        amount = params.value;
+                    }
+                    // Fetch UEA nonce for inbound UniversalPayload
+                    const ueaCodeHop = yield this.pushClient.publicClient.getCode({ address: ueaAddress });
+                    const ueaNonceHop = ueaCodeHop !== undefined ? yield this.getUEANonce(ueaAddress) : BigInt(0);
+                    // Build Push Chain payload (what executes after inbound arrives)
+                    // Wrap in UniversalPayload struct for the relay.
+                    let pushPayload = '0x';
+                    if (params.data) {
+                        const multicallData = (0, payload_builders_1.buildExecuteMulticall)({
+                            execute: {
+                                to: pushDestination,
+                                value: params.value,
+                                data: params.data,
+                            },
+                            ueaAddress,
+                        });
+                        const multicallPayload = this._buildMulticallPayloadData(pushDestination, multicallData);
+                        pushPayload = (0, payload_builders_1.buildInboundUniversalPayload)(multicallPayload, { nonce: ueaNonceHop + BigInt(1) });
+                    }
+                    // Build sendUniversalTxToUEA self-call on CEA (to=CEA, value=0)
+                    const sendCall = (0, payload_builders_1.buildSendUniversalTxToUEA)(ceaAddress, tokenAddress, amount, pushPayload, ceaAddress);
+                    ceaMulticalls.push(sendCall);
+                    const ceaPayload = (0, payload_builders_1.buildCeaMulticallPayload)(ceaMulticalls);
+                    const prc20Token = this.getNativePRC20ForChain(sourceChain);
+                    // burnAmount = actual amount needed by CEA. Vault deposits this as msg.value.
+                    // Fallback to BigInt(1) for payload-only outbound (precompile rejects amount=0).
+                    const burnAmount = amount > BigInt(0) ? amount : BigInt(1);
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, prc20Token, burnAmount, (_o = params.gasLimit) !== null && _o !== void 0 ? _o : BigInt(0), ceaPayload, ueaAddress);
+                    return { payload: ceaPayload, gatewayRequest: outboundReq };
+                }
+                default:
+                    throw new Error(`Cannot build payload for route: ${route}`);
             }
         });
     }
+    /**
+     * Convert UniversalExecuteParams to ExecuteParams for backwards compatibility
+     */
+    toExecuteParams(params) {
+        // Extract address from ChainTarget if needed
+        const to = typeof params.to === 'string'
+            ? params.to
+            : params.to.address;
+        return {
+            to,
+            value: params.value,
+            data: params.data,
+            funds: params.funds,
+            gasLimit: params.gasLimit,
+            maxFeePerGas: params.maxFeePerGas,
+            maxPriorityFeePerGas: params.maxPriorityFeePerGas,
+            deadline: params.deadline,
+            payGasWith: params.payGasWith,
+            feeLockTxHash: params.feeLockTxHash,
+        };
+    }
+    /**
+     * Get the UniversalGatewayPC address for the current Push network
+     */
+    getUniversalGatewayPCAddress() {
+        // UniversalGatewayPC is a precompile at a fixed address on Push Chain
+        // Address: 0x00000000000000000000000000000000000000C1
+        return '0x00000000000000000000000000000000000000C1';
+    }
+    /**
+     * Get the native PRC-20 token address on Push Chain for a target external chain.
+     * Maps chains to their native asset representations on Push Chain.
+     *
+     * @param targetChain - The target external chain
+     * @returns PRC-20 token address on Push Chain
+     */
+    getNativePRC20ForChain(targetChain) {
+        const synthetics = chain_1.SYNTHETIC_PUSH_ERC20[this.pushNetwork];
+        switch (targetChain) {
+            case enums_1.CHAIN.ETHEREUM_SEPOLIA:
+            case enums_1.CHAIN.ETHEREUM_MAINNET:
+                return synthetics.pETH;
+            case enums_1.CHAIN.ARBITRUM_SEPOLIA:
+                return synthetics.pETH_ARB;
+            case enums_1.CHAIN.BASE_SEPOLIA:
+                return synthetics.pETH_BASE;
+            case enums_1.CHAIN.BNB_TESTNET:
+                return synthetics.pETH_BNB;
+            case enums_1.CHAIN.SOLANA_DEVNET:
+            case enums_1.CHAIN.SOLANA_TESTNET:
+            case enums_1.CHAIN.SOLANA_MAINNET:
+                return synthetics.pSOL;
+            default:
+                throw new Error(`No native PRC-20 token mapping for chain ${targetChain}. ` +
+                    `Use 'funds' parameter to specify the token explicitly.`);
+        }
+    }
+    /**
+     * Get CAIP-2 chain namespace for a chain
+     */
+    getChainNamespace(chain) {
+        const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+        const namespace = chain_1.VM_NAMESPACE[vm];
+        return `${namespace}:${chainId}`;
+    }
     /**
      * Locks a fee on the origin chain by interacting with the chain's fee-locker contract.
      *
@@ -1015,22 +3410,7 @@ class Orchestrator {
                         (nativeTokenUsdPrice - BigInt(1))) /
                         nativeTokenUsdPrice;
                     nativeAmount = nativeAmount + BigInt(1);
-                    // const req: UniversalTxRequest = {
-                    //   recipient: zeroAddress,
-                    //   token: zeroAddress,
-                    //   amount: BigInt(0),
-                    //   payload: payloadBytes,
-                    //   revertInstruction: revertCFG,
-                    //   signatureData: '0x',
-                    // } as unknown as never;
-                    const txHash = yield evmClient.writeContract({
-                        abi: abi_1.UNIVERSAL_GATEWAY_V0,
-                        address: lockerContract,
-                        functionName: 'sendUniversalTx',
-                        args: [req],
-                        signer: this.universalSigner,
-                        value: nativeAmount,
-                    });
+                    const txHash = yield this.sendGatewayTxWithFallback(evmClient, lockerContract, req, this.universalSigner, nativeAmount);
                     return (0, viem_1.hexToBytes)(txHash);
                 }
                 case enums_1.VM.SVM: {
@@ -1058,21 +3438,19 @@ class Orchestrator {
                     const [rateLimitConfigPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit_config')], programId);
                     const [tokenRateLimitPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), web3_js_1.PublicKey.default.toBuffer()], programId);
                     const userPk = new web3_js_1.PublicKey(this.universalSigner.account.address);
-                    const revertSvm = {
-                        fundRecipient: userPk,
-                        revertMsg: Buffer.from([]),
-                    };
+                    const { feeVaultPda, protocolFeeLamports } = yield this._getSvmProtocolFee(svmClient, programId);
                     const gasReq = this._buildSvmUniversalTxRequestFromReq(req, userPk);
                     try {
                         const txHash = yield svmClient.writeContract({
                             abi: abi_1.SVM_GATEWAY_IDL,
                             address: programId.toBase58(),
                             functionName: 'sendUniversalTx',
-                            args: [gasReq, nativeAmount],
+                            args: [gasReq, nativeAmount + protocolFeeLamports],
                             signer: this.universalSigner,
                             accounts: {
                                 config: configPda,
                                 vault: vaultPda,
+                                feeVault: feeVaultPda,
                                 userTokenAccount: vaultPda,
                                 gatewayTokenAccount: vaultPda,
                                 user: userPk,
@@ -1109,12 +3487,200 @@ class Orchestrator {
             signatureData: '0x',
         };
     }
+    /**
+     * Returns the resolved gateway version for the current origin chain.
+     * Checks the per-chain runtime cache first, then falls back to static config.
+     * TODO: Remove V0 fallback once all chains are upgraded to V1.
+     */
+    getGatewayVersion() {
+        var _a;
+        const chain = this.universalSigner.account.chain;
+        // 1. Check runtime cache (set after a successful tx)
+        const cached = this.gatewayVersionCache.get(chain);
+        if (cached)
+            return cached;
+        // 2. Fall back to static config
+        return (_a = chain_1.CHAIN_INFO[chain].gatewayVersion) !== null && _a !== void 0 ? _a : 'v0';
+    }
+    /**
+     * Returns true if the current origin chain uses the V1 gateway (revertRecipient address).
+     */
+    isV1Gateway() {
+        return this.getGatewayVersion() === 'v1';
+    }
+    /**
+     * Returns the correct gateway ABI for the given version.
+     */
+    getGatewayAbiForVersion(version) {
+        return version === 'v1'
+            ? abi_1.UNIVERSAL_GATEWAY_V1_SEND
+            : abi_1.UNIVERSAL_GATEWAY_V0;
+    }
+    /**
+     * Returns the correct gateway ABI based on the origin chain's gateway version.
+     */
+    getGatewayAbi() {
+        return this.getGatewayAbiForVersion(this.getGatewayVersion());
+    }
+    /**
+     * Converts a V0 UniversalTxRequest to V1 format.
+     */
+    toGatewayRequestV1(req) {
+        return {
+            recipient: req.recipient,
+            token: req.token,
+            amount: req.amount,
+            payload: req.payload,
+            revertRecipient: req.revertInstruction.fundRecipient,
+            signatureData: req.signatureData,
+        };
+    }
+    /**
+     * Converts a V0 UniversalTxRequest to the correct format based on gateway version.
+     */
+    toGatewayRequest(req) {
+        if (!this.isV1Gateway())
+            return req;
+        return this.toGatewayRequestV1(req);
+    }
+    /**
+     * Converts a V0 UniversalTokenTxRequest to V1 format.
+     */
+    toGatewayTokenRequestV1(req) {
+        return {
+            recipient: req.recipient,
+            token: req.token,
+            amount: req.amount,
+            gasToken: req.gasToken,
+            gasAmount: req.gasAmount,
+            payload: req.payload,
+            revertRecipient: req.revertInstruction.fundRecipient,
+            signatureData: req.signatureData,
+            amountOutMinETH: req.amountOutMinETH,
+            deadline: req.deadline,
+        };
+    }
+    /**
+     * Converts a V0 UniversalTokenTxRequest to the correct format based on gateway version.
+     */
+    toGatewayTokenRequest(req) {
+        if (!this.isV1Gateway())
+            return req;
+        return this.toGatewayTokenRequestV1(req);
+    }
+    /**
+     * Sends a gateway transaction with V1-first, V0-fallback strategy.
+     *
+     * Strategy:
+     *   1. Try V1 (revertRecipient address format) first.
+     *   2. If V1 fails (contract not yet upgraded), retry with V0 (revertInstruction struct).
+     *   3. Cache the working version per chain so subsequent calls skip the fallback.
+     *
+     * TODO: Remove V0 fallback once all chains are upgraded to V1. After that,
+     *       delete this method and call writeContract directly with V1 ABI.
+     */
+    sendGatewayTxWithFallback(evmClient, address, req, signer, value) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const chain = this.universalSigner.account.chain;
+            const currentVersion = this.getGatewayVersion();
+            // If we already know the version (from cache or config), use it directly — no fallback needed.
+            if (this.gatewayVersionCache.has(chain)) {
+                return evmClient.writeContract({
+                    abi: this.getGatewayAbiForVersion(currentVersion),
+                    address,
+                    functionName: 'sendUniversalTx',
+                    args: [currentVersion === 'v1' ? this.toGatewayRequestV1(req) : req],
+                    signer,
+                    value,
+                });
+            }
+            // No cached version yet — try V1 first, fall back to V0.
+            // TODO: Remove this try/catch block once all chains are on V1.
+            try {
+                this.printLog(`[Gateway] Trying V1 format for chain ${chain}...`);
+                const txHash = yield evmClient.writeContract({
+                    abi: this.getGatewayAbiForVersion('v1'),
+                    address,
+                    functionName: 'sendUniversalTx',
+                    args: [this.toGatewayRequestV1(req)],
+                    signer,
+                    value,
+                });
+                // V1 succeeded — cache it
+                this.gatewayVersionCache.set(chain, 'v1');
+                this.printLog(`[Gateway] V1 succeeded for chain ${chain}, cached.`);
+                return txHash;
+            }
+            catch (v1Error) {
+                this.printLog(`[Gateway] V1 failed for chain ${chain}, falling back to V0... Error: ${v1Error}`);
+            }
+            // V0 fallback — contract not yet upgraded on this chain
+            // TODO: Remove this block once all chains are upgraded to V1.
+            try {
+                const txHash = yield evmClient.writeContract({
+                    abi: this.getGatewayAbiForVersion('v0'),
+                    address,
+                    functionName: 'sendUniversalTx',
+                    args: [req],
+                    signer,
+                    value,
+                });
+                // V0 succeeded — cache it
+                this.gatewayVersionCache.set(chain, 'v0');
+                this.printLog(`[Gateway] V0 succeeded for chain ${chain}, cached.`);
+                return txHash;
+            }
+            catch (v0Error) {
+                // Both versions failed — throw the V0 error (more likely to be the real issue on non-upgraded chains)
+                throw v0Error;
+            }
+        });
+    }
+    /**
+     * Sends a gateway token transaction with V1-first, V0-fallback strategy.
+     * Same as sendGatewayTxWithFallback but for UniversalTokenTxRequest (gas token path).
+     *
+     * TODO: Remove V0 fallback once all chains are upgraded to V1.
+     */
+    sendGatewayTokenTxWithFallback(evmClient, address, req, signer, value) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const chain = this.universalSigner.account.chain;
+            const currentVersion = this.getGatewayVersion();
+            // If we already know the version (from cache or config), use it directly.
+            if (this.gatewayVersionCache.has(chain)) {
+                return evmClient.writeContract(Object.assign({ abi: this.getGatewayAbiForVersion(currentVersion), address, functionName: 'sendUniversalTx', args: [currentVersion === 'v1' ? this.toGatewayTokenRequestV1(req) : req], signer }, (value !== undefined && { value })));
+            }
+            // No cached version yet — try V1 first, fall back to V0.
+            // TODO: Remove this try/catch block once all chains are on V1.
+            try {
+                this.printLog(`[Gateway] Trying V1 token format for chain ${chain}...`);
+                const txHash = yield evmClient.writeContract(Object.assign({ abi: this.getGatewayAbiForVersion('v1'), address, functionName: 'sendUniversalTx', args: [this.toGatewayTokenRequestV1(req)], signer }, (value !== undefined && { value })));
+                this.gatewayVersionCache.set(chain, 'v1');
+                this.printLog(`[Gateway] V1 token tx succeeded for chain ${chain}, cached.`);
+                return txHash;
+            }
+            catch (v1Error) {
+                this.printLog(`[Gateway] V1 token tx failed for chain ${chain}, falling back to V0... Error: ${v1Error}`);
+            }
+            // V0 fallback
+            // TODO: Remove this block once all chains are upgraded to V1.
+            try {
+                const txHash = yield evmClient.writeContract(Object.assign({ abi: this.getGatewayAbiForVersion('v0'), address, functionName: 'sendUniversalTx', args: [req], signer }, (value !== undefined && { value })));
+                this.gatewayVersionCache.set(chain, 'v0');
+                this.printLog(`[Gateway] V0 token tx succeeded for chain ${chain}, cached.`);
+                return txHash;
+            }
+            catch (v0Error) {
+                throw v0Error;
+            }
+        });
+    }
     /**
      * Builds the SVM UniversalTxRequest object from an existing EVM-style UniversalTxRequest.
      * This allows reusing the same request shape for both EVM and SVM while only translating
      * field encodings (addresses, bytes) to the Solana program format.
      */
-    _buildSvmUniversalTxRequestFromReq(req, fundRecipient, signatureDataOverride) {
+    _buildSvmUniversalTxRequestFromReq(req, revertRecipient, signatureDataOverride) {
         // recipient in EVM is a 20-byte address; the SVM gateway expects this as [u8; 20]
         const recipientBytes = (0, viem_1.hexToBytes)(req.recipient);
         const recipient = Array.from(recipientBytes.subarray(0, 20));
@@ -1143,7 +3709,7 @@ class Orchestrator {
             token,
             amount: req.amount,
             payload: req.payload,
-            fundRecipient,
+            revertRecipient,
             signatureData: signatureDataOverride !== null && signatureDataOverride !== void 0 ? signatureDataOverride : req.signatureData,
         });
     }
@@ -1151,7 +3717,7 @@ class Orchestrator {
      * Builds the SVM UniversalTxRequest object expected by the Solana gateway program.
      * Shape mirrors the request used in `svm-gateway` tests.
      */
-    _buildSvmUniversalTxRequest({ recipient, token, amount, payload, fundRecipient, signatureData, }) {
+    _buildSvmUniversalTxRequest({ recipient, token, amount, payload, revertRecipient, signatureData, }) {
         const payloadBuf = typeof payload === 'string' && payload.startsWith('0x')
             ? (() => {
                 const hex = payload.slice(2);
@@ -1188,13 +3754,29 @@ class Orchestrator {
             token,
             amount,
             payload: payloadBuf,
-            revertInstruction: {
-                fundRecipient,
-                revertMsg: Buffer.alloc(0),
-            },
+            revertRecipient: revertRecipient,
             signatureData: signatureBuf,
         };
     }
+    _getSvmProtocolFee(svmClient, programId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const [feeVaultPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('fee_vault')], programId);
+            try {
+                const feeVault = yield svmClient.readContract({
+                    abi: abi_1.SVM_GATEWAY_IDL,
+                    address: abi_1.SVM_GATEWAY_IDL.address,
+                    functionName: 'feeVault',
+                    args: [feeVaultPda.toBase58()],
+                });
+                const protocolFeeLamports = BigInt((_c = (_b = ((_a = feeVault.protocolFeeLamports) !== null && _a !== void 0 ? _a : feeVault.protocol_fee_lamports)) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : '0');
+                return { feeVaultPda, protocolFeeLamports };
+            }
+            catch (_d) {
+                return { feeVaultPda, protocolFeeLamports: BigInt(0) };
+            }
+        });
+    }
     signUniversalPayload(universalPayload, verifyingContract, version) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const chain = this.universalSigner.account.chain;
@@ -1246,7 +3828,7 @@ class Orchestrator {
      */
     sendUniversalTx(isUEADeployed_1, feeLockTxHash_1, universalPayload_1, verificationData_1) {
         return tslib_1.__awaiter(this, arguments, void 0, function* (isUEADeployed, feeLockTxHash, universalPayload, verificationData, eventBuffer = []) {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const { chain, address } = this.universalSigner.account;
             const { vm, chainId } = chain_1.CHAIN_INFO[chain];
             const universalAccountId = {
@@ -1293,12 +3875,40 @@ class Orchestrator {
             const txRaw = yield this.pushClient.signCosmosTx(txBody);
             const tx = yield this.pushClient.broadcastCosmosTx(txRaw);
             if (tx.code !== 0) {
+                // Try to extract ethereum tx hash even from failed tx
+                const failedEthTxHashes = (_b = (_a = tx.events) === null || _a === void 0 ? void 0 : _a.filter((e) => e.type === 'ethereum_tx').flatMap((e) => {
+                    var _a;
+                    return (_a = e.attributes) === null || _a === void 0 ? void 0 : _a.filter((attr) => attr.key === 'ethereumTxHash').map((attr) => attr.value);
+                })) !== null && _b !== void 0 ? _b : [];
+                // Print clean transaction failure summary
+                console.error(`\n${'='.repeat(80)}`);
+                console.error(`PUSH CHAIN TRANSACTION FAILED`);
+                console.error(`${'='.repeat(80)}`);
+                console.error(`\n--- TRANSACTION INFO ---`);
+                console.error(`Cosmos TX Hash: ${tx.transactionHash}`);
+                console.error(`Block Height: ${tx.height}`);
+                console.error(`TX Code: ${tx.code} (error)`);
+                console.error(`Gas Used: ${tx.gasUsed}`);
+                console.error(`Gas Wanted: ${tx.gasWanted}`);
+                if (failedEthTxHashes.length > 0) {
+                    console.error(`Ethereum TX Hash(es): ${failedEthTxHashes.join(', ')}`);
+                }
+                console.error(`\n--- ERROR ---`);
+                console.error(`${tx.rawLog}`);
+                console.error(`\n--- QUERY COMMANDS ---`);
+                console.error(`# Query via Cosmos RPC:`);
+                console.error(`curl -s "https://donut.rpc.push.org/tx?hash=0x${tx.transactionHash}"`);
+                if (failedEthTxHashes.length > 0) {
+                    console.error(`\n# View on explorer:`);
+                    console.error(`https://explorer.push.org/tx/${failedEthTxHashes[0]}`);
+                }
+                console.error(`\n${'='.repeat(80)}\n`);
                 throw new Error(tx.rawLog);
             }
-            const ethTxHashes = (_b = (_a = tx.events) === null || _a === void 0 ? void 0 : _a.filter((e) => e.type === 'ethereum_tx').flatMap((e) => {
+            const ethTxHashes = (_d = (_c = tx.events) === null || _c === void 0 ? void 0 : _c.filter((e) => e.type === 'ethereum_tx').flatMap((e) => {
                 var _a;
                 return (_a = e.attributes) === null || _a === void 0 ? void 0 : _a.filter((attr) => attr.key === 'ethereumTxHash').map((attr) => attr.value);
-            })) !== null && _b !== void 0 ? _b : [];
+            })) !== null && _d !== void 0 ? _d : [];
             if (ethTxHashes.length === 0) {
                 throw new Error('No ethereumTxHash found in transaction events');
             }
@@ -1307,7 +3917,8 @@ class Orchestrator {
                 return yield this.pushClient.getTransaction(hash);
             })));
             // Pass eventBuffer only to the last transaction (which is the one returned to user)
-            return yield Promise.all(evmTxs.map((tx, index) => this.transformToUniversalTxResponse(tx, index === evmTxs.length - 1 ? eventBuffer : [])));
+            const responses = yield Promise.all(evmTxs.map((tx, index) => this.transformToUniversalTxResponse(tx, index === evmTxs.length - 1 ? eventBuffer : [])));
+            return responses;
         });
     }
     /**
@@ -1318,9 +3929,68 @@ class Orchestrator {
      */
     sendPushTx(execute_1) {
         return tslib_1.__awaiter(this, arguments, void 0, function* (execute, eventBuffer = []) {
-            // For PushChain, multicall is not supported. Ensure data is hex string.
+            // If data is a multicall array, execute each call as a separate transaction
+            // EOAs on Push Chain cannot process UEA_MULTICALL encoded data — they are not contracts
+            // Nonces and gas are managed locally:
+            //   - Nonces: avoids stale nonce from estimateGas simulation on Cosmos-EVM
+            //   - Gas: avoids estimateGas failures when prior txs in the batch aren't committed yet
+            // Each tx is confirmed before sending the next to ensure state visibility.
             if (Array.isArray(execute.data)) {
-                throw new Error('Multicall is not supported on PushChain');
+                const PUSH_CHAIN_GAS_LIMIT = BigInt(500000);
+                const MAX_NONCE_RETRIES = 3;
+                // Fetch nonce once before the batch using 'pending' to include mempool txs
+                let nonce = yield this.pushClient.publicClient.getTransactionCount({
+                    address: this.universalSigner.account.address,
+                    blockTag: 'pending',
+                });
+                let lastTxHash = '0x';
+                const calls = execute.data;
+                for (let i = 0; i < calls.length; i++) {
+                    const call = calls[i];
+                    let txSent = false;
+                    for (let retry = 0; retry < MAX_NONCE_RETRIES && !txSent; retry++) {
+                        try {
+                            this.printLog(`sendPushTx — executing multicall operation ${i + 1}/${calls.length} to: ${call.to} (nonce: ${nonce})`);
+                            lastTxHash = yield this.pushClient.sendTransaction({
+                                to: call.to,
+                                data: (call.data || '0x'),
+                                value: call.value,
+                                signer: this.universalSigner,
+                                nonce,
+                                gas: PUSH_CHAIN_GAS_LIMIT,
+                            });
+                            txSent = true;
+                        }
+                        catch (err) {
+                            const msg = (err === null || err === void 0 ? void 0 : err.message) || (err === null || err === void 0 ? void 0 : err.details) || '';
+                            if (msg.includes('invalid nonce') || msg.includes('invalid sequence')) {
+                                // Re-fetch nonce from pending state and retry
+                                this.printLog(`sendPushTx — nonce mismatch on operation ${i + 1}/${calls.length} (retry ${retry + 1}/${MAX_NONCE_RETRIES}), re-fetching nonce`);
+                                nonce = yield this.pushClient.publicClient.getTransactionCount({
+                                    address: this.universalSigner.account.address,
+                                    blockTag: 'pending',
+                                });
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                    }
+                    if (!txSent) {
+                        throw new Error(`sendPushTx — multicall operation ${i + 1}/${calls.length} failed after ${MAX_NONCE_RETRIES} nonce retries`);
+                    }
+                    // Wait for tx receipt and verify it succeeded before sending next tx
+                    const receipt = yield this.pushClient.publicClient.waitForTransactionReceipt({
+                        hash: lastTxHash,
+                    });
+                    if (receipt.status === 'reverted') {
+                        throw new Error(`sendPushTx — multicall operation ${i + 1}/${calls.length} reverted (to: ${call.to}, txHash: ${lastTxHash})`);
+                    }
+                    this.printLog(`sendPushTx — operation ${i + 1}/${calls.length} confirmed in block ${receipt.blockNumber}`);
+                    nonce++; // increment locally for next tx
+                }
+                const txResponse = yield this.pushClient.getTransaction(lastTxHash);
+                return yield this.transformToUniversalTxResponse(txResponse, eventBuffer);
             }
             const txHash = yield this.pushClient.sendTransaction({
                 to: execute.to,
@@ -1632,7 +4302,7 @@ class Orchestrator {
             try {
                 // Attempt to find UniversalTx by searching pcTx entries
                 // For now, we'll try to look up by the tx hash
-                const utxResponse = yield this.pushClient.getUniversalTxById(txHash);
+                const utxResponse = yield this.pushClient.getUniversalTxByIdV2(txHash);
                 if (utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) {
                     universalTxData = utxResponse.universalTx;
                 }
@@ -1665,6 +4335,442 @@ class Orchestrator {
             return enums_1.CHAIN.PUSH_LOCALNET;
         }
     }
+    // ============================================================================
+    // Outbound Transaction Tracking
+    // ============================================================================
+    /**
+     * Compute UniversalTxId for Push Chain originated outbound transactions.
+     * Formula: keccak256("eip155:{pushChainId}:{pushChainTxHash}")
+     *
+     * @param pushChainTxHash - The Push Chain transaction hash
+     * @returns The UniversalTxId (keccak256 hash)
+     */
+    computeUniversalTxId(pushChainTxHash) {
+        const pushChain = this.getPushChainForNetwork();
+        const pushChainId = chain_1.CHAIN_INFO[pushChain].chainId;
+        const input = `eip155:${pushChainId}:${pushChainTxHash}`;
+        return (0, viem_1.keccak256)((0, viem_1.toBytes)(input));
+    }
+    /**
+     * Extract universalsubTxId from a Push Chain transaction by fetching Cosmos events.
+     * The universalsubTxId is found in the 'outbound_created' Cosmos event (attribute 'utx_id'),
+     * NOT in the EVM event data.
+     *
+     * @param pushChainTxHash - The Push Chain transaction hash
+     * @returns The universalsubTxId or null if not found
+     */
+    extractUniversalSubTxIdFromTx(pushChainTxHash) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.printLog(`[extractUniversalSubTxIdFromTx] Fetching Cosmos tx for: ${pushChainTxHash}`);
+            try {
+                // Query Cosmos transaction to get events
+                const cosmosTx = yield this.pushClient.getCosmosTx(pushChainTxHash);
+                if (!(cosmosTx === null || cosmosTx === void 0 ? void 0 : cosmosTx.events)) {
+                    this.printLog(`[extractUniversalSubTxIdFromTx] No events in Cosmos tx`);
+                    return null;
+                }
+                // Find the 'outbound_created' event which contains utx_id
+                for (const event of cosmosTx.events) {
+                    if (event.type === 'outbound_created') {
+                        // Find the utx_id attribute
+                        const utxIdAttr = (_a = event.attributes) === null || _a === void 0 ? void 0 : _a.find((attr) => attr.key === 'utx_id');
+                        if (utxIdAttr === null || utxIdAttr === void 0 ? void 0 : utxIdAttr.value) {
+                            // The utx_id is stored without 0x prefix in Cosmos events
+                            const universalsubTxId = utxIdAttr.value.startsWith('0x')
+                                ? utxIdAttr.value
+                                : `0x${utxIdAttr.value}`;
+                            this.printLog(`[extractUniversalSubTxIdFromTx] Found universalsubTxId from outbound_created event: ${universalsubTxId}`);
+                            return universalsubTxId;
+                        }
+                    }
+                }
+                this.printLog(`[extractUniversalSubTxIdFromTx] No outbound_created event found`);
+                return null;
+            }
+            catch (error) {
+                this.printLog(`[extractUniversalSubTxIdFromTx] Error: ${error instanceof Error ? error.message : String(error)}`);
+                return null;
+            }
+        });
+    }
+    /**
+     * Extract ALL universalSubTxIds from a Push Chain transaction.
+     * For cascaded transactions, a single Push Chain tx may emit multiple
+     * outbound_created events, each with its own utx_id.
+     *
+     * @param pushChainTxHash - The Push Chain transaction hash
+     * @returns Array of universalSubTxIds (may be empty)
+     */
+    extractAllUniversalSubTxIds(pushChainTxHash) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.printLog(`[extractAllUniversalSubTxIds] Fetching Cosmos tx for: ${pushChainTxHash}`);
+            try {
+                const cosmosTx = yield this.pushClient.getCosmosTx(pushChainTxHash);
+                if (!(cosmosTx === null || cosmosTx === void 0 ? void 0 : cosmosTx.events)) {
+                    this.printLog(`[extractAllUniversalSubTxIds] No events in Cosmos tx`);
+                    return [];
+                }
+                const subTxIds = [];
+                for (const event of cosmosTx.events) {
+                    if (event.type === 'outbound_created') {
+                        const utxIdAttr = (_a = event.attributes) === null || _a === void 0 ? void 0 : _a.find((attr) => attr.key === 'utx_id');
+                        if (utxIdAttr === null || utxIdAttr === void 0 ? void 0 : utxIdAttr.value) {
+                            const id = utxIdAttr.value.startsWith('0x')
+                                ? utxIdAttr.value
+                                : `0x${utxIdAttr.value}`;
+                            subTxIds.push(id);
+                        }
+                    }
+                }
+                this.printLog(`[extractAllUniversalSubTxIds] Found ${subTxIds.length} sub-tx IDs: ${subTxIds.join(', ')}`);
+                return subTxIds;
+            }
+            catch (error) {
+                this.printLog(`[extractAllUniversalSubTxIds] Error: ${error instanceof Error ? error.message : String(error)}`);
+                return [];
+            }
+        });
+    }
+    /**
+     * Convert CAIP-2 namespace (e.g., "eip155:97") to CHAIN enum
+     *
+     * @param namespace - CAIP-2 chain namespace string
+     * @returns CHAIN enum value or null if not found
+     */
+    chainFromNamespace(namespace) {
+        for (const [chainKey, info] of Object.entries(chain_1.CHAIN_INFO)) {
+            const expected = `${chain_1.VM_NAMESPACE[info.vm]}:${info.chainId}`;
+            if (expected === namespace) {
+                return chainKey;
+            }
+        }
+        return null;
+    }
+    /**
+     * Wait for outbound transaction to complete and return external chain details.
+     * @internal Used by .wait() for outbound routes - not part of public API.
+     * Uses polling with configurable initial wait, interval, and timeout.
+     *
+     * Default strategy: 30s initial wait, then poll every 5s, 120s total timeout.
+     *
+     * @param pushChainTxHash - The Push Chain transaction hash
+     * @param options - Polling configuration options
+     * @returns External chain tx details
+     * @throws Error on timeout
+     */
+    waitForOutboundTx(pushChainTxHash_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (pushChainTxHash, options = {}) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            const { initialWaitMs = Orchestrator.OUTBOUND_INITIAL_WAIT_MS, pollingIntervalMs = Orchestrator.OUTBOUND_POLL_INTERVAL_MS, timeout = Orchestrator.OUTBOUND_MAX_TIMEOUT_MS, progressHook, _resolvedSubTxId, _expectedDestinationChain, } = options;
+            // Terminal failure states — fail fast instead of polling until timeout
+            const TERMINAL_FAILURE_STATES = new Set([
+                types_1.UniversalTxStatus.OUTBOUND_FAILED,
+                types_1.UniversalTxStatus.PC_EXECUTED_FAILED,
+                types_1.UniversalTxStatus.CANCELED,
+            ]);
+            const startTime = Date.now();
+            this.printLog(`[waitForOutboundTx] Starting | txHash: ${pushChainTxHash} | initialWait: ${initialWaitMs}ms | pollInterval: ${pollingIntervalMs}ms | timeout: ${timeout}ms`);
+            // Emit initial waiting status
+            progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'waiting', elapsed: 0 });
+            // Initial wait before first poll
+            this.printLog(`[waitForOutboundTx] Initial wait of ${initialWaitMs}ms...`);
+            yield new Promise((resolve) => setTimeout(resolve, initialWaitMs));
+            // Start polling
+            this.printLog(`[waitForOutboundTx] Initial wait done. Starting polling. Elapsed: ${Date.now() - startTime}ms`);
+            progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'polling', elapsed: Date.now() - startTime });
+            // Cache the universalSubTxId after first extraction to avoid redundant receipt fetches.
+            // If a pre-resolved ID was provided (cascade per-hop tracking), use it directly.
+            let cachedUniversalSubTxId = _resolvedSubTxId;
+            let pollCount = 0;
+            while (Date.now() - startTime < timeout) {
+                pollCount++;
+                const pollStart = Date.now();
+                this.printLog(`[waitForOutboundTx] Poll #${pollCount} | Elapsed: ${pollStart - startTime}ms / ${timeout}ms`);
+                // First poll: extract the ID. Subsequent polls: reuse cached ID.
+                if (!cachedUniversalSubTxId) {
+                    cachedUniversalSubTxId = (_a = (yield this.extractUniversalSubTxIdFromTx(pushChainTxHash))) !== null && _a !== void 0 ? _a : undefined;
+                    if (!cachedUniversalSubTxId) {
+                        cachedUniversalSubTxId = this.computeUniversalTxId(pushChainTxHash);
+                    }
+                    this.printLog(`[waitForOutboundTx] Extracted & cached universalSubTxId: ${cachedUniversalSubTxId}`);
+                }
+                // Query with cached ID
+                const queryId = cachedUniversalSubTxId.startsWith('0x')
+                    ? cachedUniversalSubTxId.slice(2)
+                    : cachedUniversalSubTxId;
+                try {
+                    const utxResponse = yield this.pushClient.getUniversalTxByIdV2(queryId);
+                    const statusNum = (_b = utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) === null || _b === void 0 ? void 0 : _b.universalStatus;
+                    const statusName = (_c = types_1.UniversalTxStatus[statusNum]) !== null && _c !== void 0 ? _c : statusNum;
+                    const outbounds = ((_d = utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) === null || _d === void 0 ? void 0 : _d.outboundTx) || [];
+                    this.printLog(`[waitForOutboundTx] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${outbounds.length} | first txHash: '${((_f = (_e = outbounds[0]) === null || _e === void 0 ? void 0 : _e.observedTx) === null || _f === void 0 ? void 0 : _f.txHash) || ''}' | first dest: '${((_g = outbounds[0]) === null || _g === void 0 ? void 0 : _g.destinationChain) || ''}'`);
+                    // Check for terminal failure states — fail fast
+                    if (TERMINAL_FAILURE_STATES.has(statusNum)) {
+                        this.printLog(`[waitForOutboundTx] Terminal failure state: ${statusName}`);
+                        progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
+                        throw new Error(`Outbound transaction failed with status ${statusName}. Push Chain TX: ${pushChainTxHash}.`);
+                    }
+                    // Iterate V2 outbound array
+                    for (const ob of outbounds) {
+                        // Fail fast on per-outbound REVERTED status
+                        if (ob.outboundStatus === types_2.OutboundStatus.REVERTED) {
+                            this.printLog(`[waitForOutboundTx] Outbound to ${ob.destinationChain} REVERTED`);
+                            progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'failed', elapsed: Date.now() - startTime });
+                            throw new Error(`Outbound to ${ob.destinationChain} reverted: ${((_h = ob.observedTx) === null || _h === void 0 ? void 0 : _h.errorMsg) || 'Unknown'}. Push Chain TX: ${pushChainTxHash}.`);
+                        }
+                        if ((_j = ob.observedTx) === null || _j === void 0 ? void 0 : _j.txHash) {
+                            // If a destination chain filter is set, skip outbound entries that don't match
+                            if (_expectedDestinationChain && ob.destinationChain !== _expectedDestinationChain) {
+                                this.printLog(`[waitForOutboundTx] Poll #${pollCount} | outbound chain '${ob.destinationChain}' does not match expected '${_expectedDestinationChain}', skipping`);
+                                continue;
+                            }
+                            const chain = this.chainFromNamespace(ob.destinationChain);
+                            if (chain) {
+                                const explorerBaseUrl = (_k = chain_1.CHAIN_INFO[chain]) === null || _k === void 0 ? void 0 : _k.explorerUrl;
+                                const isSvm = ((_l = chain_1.CHAIN_INFO[chain]) === null || _l === void 0 ? void 0 : _l.vm) === enums_1.VM.SVM;
+                                // For SVM chains, convert hex txHash to base58 and append cluster param
+                                let displayTxHash = ob.observedTx.txHash;
+                                let explorerUrl = '';
+                                if (isSvm && ob.observedTx.txHash.startsWith('0x')) {
+                                    const bytes = new Uint8Array(Buffer.from(ob.observedTx.txHash.slice(2), 'hex'));
+                                    displayTxHash = anchor_1.utils.bytes.bs58.encode(bytes);
+                                    const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET ? '?cluster=devnet'
+                                        : chain === enums_1.CHAIN.SOLANA_TESTNET ? '?cluster=testnet' : '';
+                                    explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${displayTxHash}${cluster}` : '';
+                                }
+                                else {
+                                    explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${ob.observedTx.txHash}` : '';
+                                }
+                                const details = {
+                                    externalTxHash: ob.observedTx.txHash,
+                                    destinationChain: chain,
+                                    explorerUrl,
+                                    recipient: ob.recipient,
+                                    amount: ob.amount,
+                                    assetAddr: ob.externalAssetAddr,
+                                };
+                                this.printLog(`[waitForOutboundTx] FOUND on poll #${pollCount} | elapsed: ${Date.now() - startTime}ms | externalTxHash: ${details.externalTxHash}`);
+                                progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'found', elapsed: Date.now() - startTime });
+                                return details;
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // Re-throw terminal failure and reverted errors
+                    if (error instanceof Error && (error.message.includes('Outbound transaction failed') || error.message.includes('reverted'))) {
+                        throw error;
+                    }
+                    this.printLog(`[waitForOutboundTx] Poll #${pollCount} ERROR: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                this.printLog(`[waitForOutboundTx] Poll #${pollCount} not ready yet (${Date.now() - pollStart}ms). Waiting ${pollingIntervalMs}ms...`);
+                // Wait before next poll
+                yield new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+            }
+            this.printLog(`[waitForOutboundTx] TIMEOUT after ${pollCount} polls | elapsed: ${Date.now() - startTime}ms`);
+            progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'timeout', elapsed: Date.now() - startTime });
+            throw new Error(`Timeout waiting for outbound transaction. Push Chain TX: ${pushChainTxHash}. ` +
+                `Timeout: ${timeout}ms. The relay may still be processing.`);
+        });
+    }
+    /**
+     * Tracks ALL outbound transactions for a cascade with multiple outbound hops
+     * (e.g., BNB + Solana). Uses V2 API which returns outboundTx[] with per-outbound
+     * status tracking, matching each outbound to the correct hop by destination chain.
+     */
+    waitForAllOutboundTxsV2(pushChainTxHash, outboundHops, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const { initialWaitMs, pollingIntervalMs, timeout, progressHook } = options;
+            const startTime = Date.now();
+            // Build a map: CAIP-2 namespace -> hop(s) for matching outbound entries
+            const chainToHops = new Map();
+            for (const hop of outboundHops) {
+                const chainInfo = chain_1.CHAIN_INFO[hop.executionChain];
+                if (chainInfo) {
+                    const namespace = `${chain_1.VM_NAMESPACE[chainInfo.vm]}:${chainInfo.chainId}`;
+                    const existing = chainToHops.get(namespace) || [];
+                    existing.push(hop);
+                    chainToHops.set(namespace, existing);
+                }
+            }
+            const expectedChains = [...chainToHops.keys()];
+            this.printLog(`[waitForAllOutboundTxsV2] Starting | txHash: ${pushChainTxHash} | expectedChains: ${expectedChains.join(', ')} | timeout: ${timeout}ms`);
+            // Emit initial waiting status for all outbound hops
+            for (const hop of outboundHops) {
+                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                    hopIndex: hop.hopIndex,
+                    route: hop.route,
+                    chain: hop.executionChain,
+                    status: 'waiting',
+                });
+            }
+            // Initial wait before first poll
+            const waitMs = Math.min(initialWaitMs, timeout);
+            this.printLog(`[waitForAllOutboundTxsV2] Initial wait of ${waitMs}ms...`);
+            yield new Promise((resolve) => setTimeout(resolve, waitMs));
+            // Emit polling status for all hops
+            for (const hop of outboundHops) {
+                progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                    hopIndex: hop.hopIndex,
+                    route: hop.route,
+                    chain: hop.executionChain,
+                    status: 'polling',
+                });
+            }
+            // Extract sub-tx ID for V2 query
+            let cachedQueryId;
+            let pollCount = 0;
+            let consecutiveErrors = 0;
+            const MAX_CONSECUTIVE_ERRORS = 10;
+            while (Date.now() - startTime < timeout) {
+                pollCount++;
+                const elapsed = Date.now() - startTime;
+                this.printLog(`[waitForAllOutboundTxsV2] Poll #${pollCount} | Elapsed: ${elapsed}ms / ${timeout}ms`);
+                // Resolve query ID on first poll
+                if (!cachedQueryId) {
+                    const allSubTxIds = yield this.extractAllUniversalSubTxIds(pushChainTxHash);
+                    const subTxId = allSubTxIds.length > 0 ? allSubTxIds[0] : this.computeUniversalTxId(pushChainTxHash);
+                    cachedQueryId = subTxId.startsWith('0x') ? subTxId.slice(2) : subTxId;
+                    this.printLog(`[waitForAllOutboundTxsV2] Resolved queryId: ${cachedQueryId}`);
+                }
+                try {
+                    const v2Response = yield this.pushClient.getUniversalTxByIdV2(cachedQueryId);
+                    consecutiveErrors = 0; // Reset on successful RPC call
+                    const utx = v2Response === null || v2Response === void 0 ? void 0 : v2Response.universalTx;
+                    const statusNum = utx === null || utx === void 0 ? void 0 : utx.universalStatus;
+                    const statusName = (_a = types_1.UniversalTxStatus[statusNum]) !== null && _a !== void 0 ? _a : statusNum;
+                    this.printLog(`[waitForAllOutboundTxsV2] Poll #${pollCount} | status: ${statusNum} (${statusName}) | outboundTx count: ${(_c = (_b = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0}`);
+                    if ((_d = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _d === void 0 ? void 0 : _d.length) {
+                        for (const ob of utx.outboundTx) {
+                            const destChain = ob.destinationChain;
+                            const hopsForChain = chainToHops.get(destChain);
+                            if (!hopsForChain)
+                                continue;
+                            const unconfirmedForChain = hopsForChain.filter((h) => h.status !== 'confirmed' && h.status !== 'failed');
+                            if (unconfirmedForChain.length === 0)
+                                continue;
+                            // Fail fast on per-outbound REVERTED
+                            if (ob.outboundStatus === types_2.OutboundStatus.REVERTED) {
+                                for (const hop of unconfirmedForChain) {
+                                    hop.status = 'failed';
+                                    this.printLog(`[waitForAllOutboundTxsV2] Outbound to ${destChain} REVERTED | hop ${hop.hopIndex} | error: ${((_e = ob.observedTx) === null || _e === void 0 ? void 0 : _e.errorMsg) || 'Unknown'}`);
+                                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                        hopIndex: hop.hopIndex,
+                                        route: hop.route,
+                                        chain: hop.executionChain,
+                                        status: 'failed',
+                                    });
+                                }
+                                return { success: false, failedAt: unconfirmedForChain[0].hopIndex };
+                            }
+                            // Check for OBSERVED with txHash
+                            const externalTxHash = (_f = ob.observedTx) === null || _f === void 0 ? void 0 : _f.txHash;
+                            if (externalTxHash && (ob.outboundStatus === types_2.OutboundStatus.OBSERVED || ob.outboundStatus === 0)) {
+                                const chain = this.chainFromNamespace(destChain);
+                                let explorerUrl = '';
+                                if (chain && externalTxHash) {
+                                    const explorerBaseUrl = (_g = chain_1.CHAIN_INFO[chain]) === null || _g === void 0 ? void 0 : _g.explorerUrl;
+                                    const isSvm = ((_h = chain_1.CHAIN_INFO[chain]) === null || _h === void 0 ? void 0 : _h.vm) === enums_1.VM.SVM;
+                                    if (isSvm && externalTxHash.startsWith('0x')) {
+                                        const bytes = new Uint8Array(Buffer.from(externalTxHash.slice(2), 'hex'));
+                                        const base58Hash = anchor_1.utils.bytes.bs58.encode(bytes);
+                                        const cluster = chain === enums_1.CHAIN.SOLANA_DEVNET ? '?cluster=devnet'
+                                            : chain === enums_1.CHAIN.SOLANA_TESTNET ? '?cluster=testnet' : '';
+                                        explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${base58Hash}${cluster}` : '';
+                                    }
+                                    else {
+                                        explorerUrl = explorerBaseUrl ? `${explorerBaseUrl}/tx/${externalTxHash}` : '';
+                                    }
+                                }
+                                for (const hop of unconfirmedForChain) {
+                                    hop.status = 'confirmed';
+                                    hop.txHash = externalTxHash;
+                                    hop.outboundDetails = {
+                                        externalTxHash,
+                                        destinationChain: chain || hop.executionChain,
+                                        explorerUrl,
+                                        recipient: ob.recipient,
+                                        amount: ob.amount,
+                                        assetAddr: ob.externalAssetAddr,
+                                    };
+                                    this.printLog(`[waitForAllOutboundTxsV2] FOUND outbound for ${destChain} | hop ${hop.hopIndex} | externalTxHash: ${externalTxHash}`);
+                                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                        hopIndex: hop.hopIndex,
+                                        route: hop.route,
+                                        chain: hop.executionChain,
+                                        status: 'confirmed',
+                                        txHash: externalTxHash,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    // Check if all hops are now confirmed
+                    if (outboundHops.every((h) => h.status === 'confirmed')) {
+                        this.printLog(`[waitForAllOutboundTxsV2] All ${outboundHops.length} hops confirmed via V2`);
+                        return { success: true };
+                    }
+                    // If PC_EXECUTED_SUCCESS but some hops still unresolved, check outbound status.
+                    // Only auto-confirm if there are NO pending outbound txs (status=1 with empty hash).
+                    // Pending outbounds are still in flight on the relay — keep polling for their hashes.
+                    if (statusNum === types_1.UniversalTxStatus.PC_EXECUTED_SUCCESS) {
+                        const stillUnresolved = outboundHops.filter((h) => h.status !== 'confirmed');
+                        if (stillUnresolved.length > 0) {
+                            const hasPendingOutbound = (_j = utx === null || utx === void 0 ? void 0 : utx.outboundTx) === null || _j === void 0 ? void 0 : _j.some((ob) => {
+                                var _a;
+                                return ob.outboundStatus === types_2.OutboundStatus.PENDING &&
+                                    (!((_a = ob.observedTx) === null || _a === void 0 ? void 0 : _a.txHash) || ob.observedTx.txHash === 'EMPTY');
+                            });
+                            if (!hasPendingOutbound) {
+                                // No pending outbounds — safe to auto-confirm remaining hops
+                                for (const hop of stillUnresolved) {
+                                    hop.status = 'confirmed';
+                                    this.printLog(`[waitForAllOutboundTxsV2] Auto-confirmed hop ${hop.hopIndex} (${hop.executionChain}) based on PC_EXECUTED_SUCCESS (no pending outbounds)`);
+                                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                                        hopIndex: hop.hopIndex,
+                                        route: hop.route,
+                                        chain: hop.executionChain,
+                                        status: 'confirmed',
+                                    });
+                                }
+                                return { success: true };
+                            }
+                            // Pending outbound txs still in flight — continue polling
+                            this.printLog(`[waitForAllOutboundTxsV2] ${stillUnresolved.length} hop(s) unresolved, pending outbound txs in flight — continuing to poll`);
+                        }
+                    }
+                }
+                catch (error) {
+                    consecutiveErrors++;
+                    this.printLog(`[waitForAllOutboundTxsV2] Poll #${pollCount} ERROR (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${error instanceof Error ? error.message : String(error)}`);
+                    if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                        this.printLog(`[waitForAllOutboundTxsV2] Aborting — ${MAX_CONSECUTIVE_ERRORS} consecutive RPC errors`);
+                        break;
+                    }
+                }
+                yield new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+            }
+            // Timeout: fail any unresolved hops
+            const timedOutHops = outboundHops.filter((h) => h.status !== 'confirmed');
+            if (timedOutHops.length > 0) {
+                this.printLog(`[waitForAllOutboundTxsV2] TIMEOUT after ${pollCount} polls | ${timedOutHops.length} hop(s) unresolved`);
+                for (const hop of timedOutHops) {
+                    hop.status = 'failed';
+                    progressHook === null || progressHook === void 0 ? void 0 : progressHook({
+                        hopIndex: hop.hopIndex,
+                        route: hop.route,
+                        chain: hop.executionChain,
+                        status: 'failed',
+                    });
+                }
+                return { success: false, failedAt: timedOutHops[0].hopIndex };
+            }
+            return { success: true };
+        });
+    }
     /**
      * Computes UEA for given UniversalAccount
      * @dev - This fn calls a view fn of Factory Contract
@@ -1771,38 +4877,34 @@ class Orchestrator {
                 throw new Error('Token address is required for bridge path');
             }
             const isNative = mechanism === 'native' || execute.funds.token.symbol === 'SOL';
-            const revertSvm2 = {
-                fundRecipient: userPk,
-                revertMsg: Buffer.from([]),
-            };
+            const { feeVaultPda, protocolFeeLamports } = yield this._getSvmProtocolFee(svmClient, programId);
             // Compute signature for universal payload on SVM
             const ueaAddressSvm = this.computeUEAOffchain();
             const ueaVersion = yield this.fetchUEAVersion();
             const svmSignature = yield this.signUniversalPayload(universalPayload, ueaAddressSvm, ueaVersion);
             if (isNative) {
                 // Native SOL as bridge + gas
-                const [whitelistPdaLocal] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('whitelist')], programId);
                 const [tokenRateLimitPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), web3_js_1.PublicKey.default.toBuffer()], programId);
                 const nativeReq = this._buildSvmUniversalTxRequest({
                     recipient: Array.from(Buffer.alloc(20, 0)),
                     token: web3_js_1.PublicKey.default,
                     amount: bridgeAmount,
                     payload: Uint8Array.from(this.encodeUniversalPayloadSvm(universalPayload)),
-                    fundRecipient: userPk,
+                    revertRecipient: userPk,
                     signatureData: svmSignature,
                 });
                 return yield svmClient.writeContract({
                     abi: abi_1.SVM_GATEWAY_IDL,
                     address: programId.toBase58(),
                     functionName: 'sendUniversalTx',
-                    args: [nativeReq, nativeAmount],
+                    args: [nativeReq, nativeAmount + protocolFeeLamports],
                     signer: this.universalSigner,
                     accounts: {
                         config: configPda,
                         vault: vaultPda,
-                        tokenWhitelist: whitelistPdaLocal,
-                        userTokenAccount: vaultPda, // dummy for native SOL
-                        gatewayTokenAccount: vaultPda, // dummy for native SOL
+                        feeVault: feeVaultPda,
+                        userTokenAccount: vaultPda,
+                        gatewayTokenAccount: vaultPda,
                         user: userPk,
                         priceUpdate: priceUpdatePk,
                         tokenProgram: new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
@@ -1822,26 +4924,25 @@ class Orchestrator {
                 const ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
                 const userAta = web3_js_1.PublicKey.findProgramAddressSync([userPk.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mintPk.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
                 const vaultAta = web3_js_1.PublicKey.findProgramAddressSync([vaultPda.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mintPk.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
-                const [whitelistPdaLocal] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('whitelist')], programId);
                 const [tokenRateLimitPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), mintPk.toBuffer()], programId);
                 const splReq = this._buildSvmUniversalTxRequest({
                     recipient: Array.from(Buffer.alloc(20, 0)),
                     token: mintPk,
                     amount: bridgeAmount,
                     payload: Uint8Array.from(this.encodeUniversalPayloadSvm(universalPayload)),
-                    fundRecipient: userPk,
+                    revertRecipient: userPk,
                     signatureData: svmSignature,
                 });
                 return yield svmClient.writeContract({
                     abi: abi_1.SVM_GATEWAY_IDL,
                     address: programId.toBase58(),
                     functionName: 'sendUniversalTx',
-                    args: [splReq, nativeAmount],
+                    args: [splReq, nativeAmount + protocolFeeLamports],
                     signer: this.universalSigner,
                     accounts: {
                         config: configPda,
                         vault: vaultPda,
-                        tokenWhitelist: whitelistPdaLocal,
+                        feeVault: feeVaultPda,
                         userTokenAccount: userAta,
                         gatewayTokenAccount: vaultAta,
                         user: userPk,
@@ -2563,6 +5664,7 @@ class Orchestrator {
                 // 6. Utilities
                 wait: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
                     // Use trackTransaction with registered hook if available
+                    let baseReceipt;
                     if (registeredProgressHook) {
                         const trackedResponse = yield this.trackTransaction(tx.hash, {
                             waitForCompletion: true,
@@ -2570,10 +5672,31 @@ class Orchestrator {
                         });
                         // Get receipt from the tracked response
                         const receipt = yield tx.wait();
-                        return this.transformToUniversalTxReceipt(receipt, trackedResponse);
+                        baseReceipt = this.transformToUniversalTxReceipt(receipt, trackedResponse);
+                    }
+                    else {
+                        const receipt = yield tx.wait();
+                        baseReceipt = this.transformToUniversalTxReceipt(receipt, universalTxResponse);
                     }
-                    const receipt = yield tx.wait();
-                    return this.transformToUniversalTxReceipt(receipt, universalTxResponse);
+                    // If outbound route (Route 2: UOA → CEA, Route 3: CEA → Push), poll for external chain details
+                    if (universalTxResponse.route === route_detector_1.TransactionRoute.UOA_TO_CEA ||
+                        universalTxResponse.route === route_detector_1.TransactionRoute.CEA_TO_PUSH) {
+                        try {
+                            const outboundDetails = yield this.waitForOutboundTx(tx.hash, {
+                                initialWaitMs: Orchestrator.OUTBOUND_INITIAL_WAIT_MS,
+                                pollingIntervalMs: Orchestrator.OUTBOUND_POLL_INTERVAL_MS,
+                                timeout: Orchestrator.OUTBOUND_MAX_TIMEOUT_MS,
+                            });
+                            // Merge external chain details into receipt
+                            baseReceipt = Object.assign(Object.assign({}, baseReceipt), { externalTxHash: outboundDetails.externalTxHash, externalChain: outboundDetails.destinationChain, externalExplorerUrl: outboundDetails.explorerUrl, externalRecipient: outboundDetails.recipient, externalAmount: outboundDetails.amount, externalAssetAddr: outboundDetails.assetAddr });
+                        }
+                        catch (error) {
+                            // Outbound polling timed out - return partial receipt (don't throw)
+                            // Push Chain tx succeeded, external tracking can be retried later
+                            this.printLog(`[wait] External chain tracking failed: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    return baseReceipt;
                 }),
                 progressHook: (callback) => {
                     registeredProgressHook = callback;
@@ -2759,12 +5882,12 @@ class Orchestrator {
                     try {
                         const universalTxResp = yield this.pushClient.getUniversalTxById(idHex);
                         universalTxObj = universalTxResp === null || universalTxResp === void 0 ? void 0 : universalTxResp.universalTx;
-                        if (universalTxObj)
+                        if (universalTxObj) {
                             break;
+                        }
                     }
                     catch (error) {
                         // ignore and retry
-                        // console.log(error);
                     }
                     // Linear delay for first N attempts, then exponential backoff
                     let delay;
@@ -2780,7 +5903,7 @@ class Orchestrator {
                 }
                 return universalTxObj;
             }
-            catch (_d) {
+            catch (err) {
                 return undefined;
             }
         });
@@ -3018,4 +6141,8 @@ class Orchestrator {
     }
 }
 exports.Orchestrator = Orchestrator;
+// Outbound sync configuration constants
+Orchestrator.OUTBOUND_INITIAL_WAIT_MS = 30000; // 30s
+Orchestrator.OUTBOUND_POLL_INTERVAL_MS = 5000; // 5s
+Orchestrator.OUTBOUND_MAX_TIMEOUT_MS = 180000; // 180s (3 min)
 //# sourceMappingURL=orchestrator.js.map