@pushchain/core 5.1.3 → 5.1.4-alpha.1

package/src/lib/orchestrator/internals/response-builder.js

@@ -0,0 +1,504 @@
+"use strict";
+/**
+ * Response builder functions extracted from Orchestrator.
+ *
+ * Contains: queryUniversalTxStatusFromGatewayTx, trackTransaction,
+ * transformToUniversalTxResponse, and the ResponseBuilderCallbacks interface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryUniversalTxStatusFromGatewayTx = queryUniversalTxStatusFromGatewayTx;
+exports.trackTransaction = trackTransaction;
+exports.transformToUniversalTxResponse = transformToUniversalTxResponse;
+const tslib_1 = require("tslib");
+const bs58_1 = require("../../internal/bs58");
+const web3_js_1 = require("@solana/web3.js");
+const viem_1 = require("viem");
+const uea_evm_1 = require("../../constants/abi/uea.evm");
+const chain_1 = require("../../constants/chain");
+const enums_1 = require("../../constants/enums");
+const account_1 = require("../../universal/account/account");
+const push_client_1 = require("../../push-client/push-client");
+const route_detector_1 = require("../route-detector");
+const context_1 = require("./context");
+const helpers_1 = require("./helpers");
+const svm_helpers_1 = require("./svm-helpers");
+const outbound_tracker_1 = require("./outbound-tracker");
+const tx_transformer_1 = require("./tx-transformer");
+// ============================================================================
+// queryUniversalTxStatusFromGatewayTx
+// ============================================================================
+function queryUniversalTxStatusFromGatewayTx(ctx, evmClient, gatewayAddress, 
+// DEBUG: section marker added
+txHash, evmGatewayMethod) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            const chain = ctx.universalSigner.account.chain;
+            const { vm } = chain_1.CHAIN_INFO[chain];
+            let logIndexStr = '0';
+            let txHashHex = txHash;
+            if (vm === enums_1.VM.EVM) {
+                if (!evmClient || !gatewayAddress)
+                    throw new Error('Missing EVM context');
+                let receipt;
+                try {
+                    receipt = yield evmClient.publicClient.getTransactionReceipt({
+                        hash: txHash,
+                    });
+                }
+                catch (_c) {
+                    // Receipt might not be indexed yet on this RPC; wait briefly for it
+                    receipt = yield evmClient.publicClient.waitForTransactionReceipt({
+                        hash: txHash,
+                        confirmations: 0,
+                        timeout: chain_1.CHAIN_INFO[chain].timeout,
+                    });
+                }
+                const gatewayLogs = (receipt.logs || []).filter((l) => (l.address || '').toLowerCase() === gatewayAddress.toLowerCase());
+                (0, context_1.printLog)(ctx, `queryUniversalTxStatus — receipt logs count: ${(_a = receipt.logs) === null || _a === void 0 ? void 0 : _a.length}, gateway logs count: ${gatewayLogs.length}, evmGatewayMethod: ${evmGatewayMethod}`);
+                (0, context_1.printLog)(ctx, 'queryUniversalTxStatus — gatewayLogs: ' + JSON.stringify(gatewayLogs.map((l) => { var _a; return ({ address: l.address, logIndex: l.logIndex, topics: (_a = l.topics) === null || _a === void 0 ? void 0 : _a[0] }); }), null, 2));
+                // Use the last gateway log to derive the log index
+                const logIndexToUse = gatewayLogs.length - 1;
+                const firstLog = (gatewayLogs[logIndexToUse] ||
+                    (receipt.logs || []).at(-1));
+                const logIndexVal = (_b = firstLog === null || firstLog === void 0 ? void 0 : firstLog.logIndex) !== null && _b !== void 0 ? _b : 0;
+                (0, context_1.printLog)(ctx, `queryUniversalTxStatus — logIndexToUse: ${logIndexToUse}, firstLog.logIndex: ${firstLog === null || firstLog === void 0 ? void 0 : firstLog.logIndex}, logIndexVal: ${logIndexVal}`);
+                logIndexStr =
+                    typeof logIndexVal === 'bigint'
+                        ? logIndexVal.toString()
+                        : String(logIndexVal);
+            }
+            else if (vm === enums_1.VM.SVM) {
+                // Normalize Solana signature to 0x-hex for ID composition
+                let txSignature = txHash;
+                if (!txHash.startsWith('0x')) {
+                    const decoded = bs58_1.bs58.decode(txHash);
+                    txHashHex = (0, viem_1.bytesToHex)(new Uint8Array(decoded));
+                }
+                else {
+                    // When provided as hex, convert to base58 for RPC
+                    const hex = txHash.slice(2);
+                    const bytes = Uint8Array.from(Buffer.from(hex, 'hex'));
+                    txSignature = bs58_1.bs58.encode(Buffer.from(bytes));
+                }
+                // Fetch transaction by initializing a Connection and calling Solana RPC
+                const rpcUrls = ctx.rpcUrls[chain] || chain_1.CHAIN_INFO[chain].defaultRPC;
+                const connection = new web3_js_1.Connection(rpcUrls[0], 'confirmed');
+                const txResp = yield connection.getTransaction(txSignature, {
+                    maxSupportedTransactionVersion: 0,
+                    commitment: 'confirmed',
+                });
+                // Derive proper log index using discriminator matching
+                const svmLogIndex = (0, svm_helpers_1.getSvmGatewayLogIndexFromTx)(txResp);
+                logIndexStr = String(svmLogIndex);
+            }
+            const sourceChain = `${chain_1.VM_NAMESPACE[vm]}:${chain_1.CHAIN_INFO[chain].chainId}`;
+            // ID = sha256("${sourceChain}:${txHash}:${logIndex}") as hex string (no 0x)
+            const idInput = `${sourceChain}:${txHashHex}:${logIndexStr}`;
+            const idHex = (0, viem_1.sha256)((0, viem_1.stringToBytes)(idInput)).slice(2);
+            (0, context_1.printLog)(ctx, 'Query ID extraction: ' + JSON.stringify({
+                sourceChain,
+                txHashHex,
+                logIndexStr,
+                idInput,
+                idHex,
+            }, null, 2));
+            // Fetch UniversalTx via gRPC with linear-then-exponential retry
+            const LINEAR_ATTEMPTS = 10;
+            const LINEAR_DELAY_MS = 3000;
+            const EXPONENTIAL_BASE_MS = 4000;
+            const MAX_ATTEMPTS = 15;
+            let universalTxObj;
+            for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+                (0, context_1.printLog)(ctx, `[Sync] Attempt ${attempt + 1}/${MAX_ATTEMPTS} | Query ID: ${idHex}`);
+                try {
+                    const universalTxResp = yield ctx.pushClient.getUniversalTxById(idHex);
+                    universalTxObj = universalTxResp === null || universalTxResp === void 0 ? void 0 : universalTxResp.universalTx;
+                    if (universalTxObj) {
+                        break;
+                    }
+                }
+                catch (error) {
+                    // ignore and retry
+                }
+                // Linear delay for first N attempts, then exponential backoff
+                let delay;
+                if (attempt < LINEAR_ATTEMPTS) {
+                    delay = LINEAR_DELAY_MS;
+                }
+                else {
+                    // Exponential: 2000, 4000, 8000, 16000, ...
+                    const exponentialAttempt = attempt - LINEAR_ATTEMPTS;
+                    delay = EXPONENTIAL_BASE_MS * Math.pow(2, exponentialAttempt);
+                }
+                yield new Promise((r) => setTimeout(r, delay));
+            }
+            return universalTxObj;
+        }
+        catch (err) {
+            (0, context_1.printLog)(ctx, `queryUniversalTxStatusFromGatewayTx failed: ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        }
+    });
+}
+// ============================================================================
+// trackTransaction
+// ============================================================================
+function trackTransaction(ctx, txHash, options, callbacks) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!callbacks) {
+            throw new Error('trackTransaction requires ResponseBuilderCallbacks');
+        }
+        const { chain = (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork), progressHook, waitForCompletion = true, advanced = {}, } = options !== null && options !== void 0 ? options : {};
+        const { timeout = 300000, rpcUrls = {} } = advanced;
+        // Event buffer for replay via response.progressHook()
+        const eventBuffer = [];
+        // Helper to emit progress events
+        const emitProgress = (event) => {
+            eventBuffer.push(event);
+            (0, context_1.printLog)(ctx, event.message);
+            // Per-transaction hook called FIRST
+            if (progressHook) {
+                progressHook(event);
+            }
+            // Orchestrator-level hook called SECOND
+            if (ctx.progressHook) {
+                ctx.progressHook(event);
+            }
+        };
+        // Create client for target chain with optional RPC override
+        const chainRPCs = rpcUrls[chain] || ctx.rpcUrls[chain] || chain_1.CHAIN_INFO[chain].defaultRPC;
+        const client = new push_client_1.PushClient({
+            rpcUrls: chainRPCs,
+            network: ctx.pushNetwork,
+        });
+        // Poll for transaction
+        const start = Date.now();
+        let tx;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            try {
+                tx = yield client.getTransaction(txHash);
+                break; // Found transaction
+            }
+            catch (err) {
+                if (!waitForCompletion) {
+                    throw new Error(`Transaction ${txHash} not found`);
+                }
+                // Check timeout
+                if (Date.now() - start > timeout) {
+                    throw new Error(`Timeout: transaction ${txHash} not confirmed within ${timeout}ms`);
+                }
+                // Brief delay before retry
+                yield new Promise((r) => setTimeout(r, 1000));
+            }
+        }
+        // Try to get UniversalTx data for richer progress reconstruction
+        // (may not exist for direct Push Chain transactions)
+        // Three-tier lookup: direct hash → computed keccak ID → Cosmos event extraction
+        let universalTxData;
+        try {
+            const utxResponse = yield ctx.pushClient.getUniversalTxByIdV2(txHash);
+            if (utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) {
+                universalTxData = utxResponse.universalTx;
+            }
+        }
+        catch (_a) {
+            // Ignore - try computed ID next
+        }
+        if (!universalTxData) {
+            try {
+                const computedId = (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, txHash);
+                const queryId = computedId.startsWith('0x') ? computedId.slice(2) : computedId;
+                const utxResponse = yield ctx.pushClient.getUniversalTxByIdV2(queryId);
+                if (utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) {
+                    universalTxData = utxResponse.universalTx;
+                }
+            }
+            catch (_b) {
+                // Ignore - try Cosmos event extraction next
+            }
+        }
+        if (!universalTxData) {
+            try {
+                const extractedId = yield (0, outbound_tracker_1.extractUniversalSubTxIdFromTx)(ctx, txHash);
+                if (extractedId) {
+                    const queryId = extractedId.startsWith('0x') ? extractedId.slice(2) : extractedId;
+                    const utxResponse = yield ctx.pushClient.getUniversalTxByIdV2(queryId);
+                    if (utxResponse === null || utxResponse === void 0 ? void 0 : utxResponse.universalTx) {
+                        universalTxData = utxResponse.universalTx;
+                    }
+                }
+            }
+            catch (_c) {
+                // Ignore - no universal tx data available
+            }
+        }
+        // Transform to UniversalTxResponse
+        const universalTxResponse = yield transformToUniversalTxResponse(ctx, tx, eventBuffer, callbacks);
+        // Detect route from UniversalTxV2 data and set on response
+        // This enables wait() to trigger outbound polling via waitForOutboundTx()
+        const detectedRoute = (0, tx_transformer_1.detectRouteFromUniversalTxData)(universalTxData);
+        if (detectedRoute) {
+            universalTxResponse.route = detectedRoute;
+        }
+        // Reconstruct and emit SEND-TX-* progress events
+        const reconstructedEvents = (0, tx_transformer_1.reconstructProgressEvents)(universalTxResponse, universalTxData);
+        for (const event of reconstructedEvents) {
+            emitProgress(event);
+        }
+        return universalTxResponse;
+    });
+}
+// ============================================================================
+// transformToUniversalTxResponse
+// ============================================================================
+function transformToUniversalTxResponse(ctx_1, tx_1) {
+    return tslib_1.__awaiter(this, arguments, void 0, function* (ctx, tx, eventBuffer = [], callbacks) {
+        const chain = ctx.universalSigner.account.chain;
+        const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+        let from;
+        let to;
+        let value;
+        let data;
+        let rawTransactionData;
+        const ueaOrigin = yield (0, account_1.convertExecutorToOrigin)(tx.to, { _internal: true });
+        let originAddress;
+        if (ueaOrigin.exists) {
+            if (!ueaOrigin.account) {
+                throw new Error('UEA origin account is null');
+            }
+            originAddress = ueaOrigin.account.address;
+            from = (0, viem_1.getAddress)(tx.to);
+            let decoded;
+            if (tx.input !== '0x') {
+                decoded = (0, viem_1.decodeFunctionData)({
+                    abi: uea_evm_1.UEA_EVM,
+                    data: tx.input,
+                });
+                if (!(decoded === null || decoded === void 0 ? void 0 : decoded.args)) {
+                    throw new Error('Failed to decode function data');
+                }
+                const universalPayload = decoded === null || decoded === void 0 ? void 0 : decoded.args[0];
+                to = universalPayload.to;
+                value = BigInt(universalPayload.value);
+                data = universalPayload.data;
+                // Extract 'to' from single-element multicall
+                if (data && data.length >= 10) {
+                    const multicallSelector = (0, viem_1.keccak256)((0, viem_1.toBytes)('UEA_MULTICALL')).slice(0, 10);
+                    if (data.slice(0, 10) === multicallSelector) {
+                        try {
+                            const innerData = ('0x' + data.slice(10));
+                            const [decodedCalls] = (0, viem_1.decodeAbiParameters)([
+                                {
+                                    type: 'tuple[]',
+                                    components: [
+                                        { name: 'to', type: 'address' },
+                                        { name: 'value', type: 'uint256' },
+                                        { name: 'data', type: 'bytes' },
+                                    ],
+                                },
+                            ], innerData);
+                            // If single call, use its 'to' address
+                            if (decodedCalls.length === 1) {
+                                to = (0, viem_1.getAddress)(decodedCalls[0].to);
+                            }
+                        }
+                        catch (_a) {
+                            // Keep original 'to' if decoding fails
+                        }
+                    }
+                }
+                rawTransactionData = {
+                    from: (0, viem_1.getAddress)(tx.from),
+                    to: (0, viem_1.getAddress)(tx.to),
+                    nonce: tx.nonce,
+                    data: tx.input,
+                    value: tx.value,
+                };
+            }
+            else {
+                to = (0, viem_1.getAddress)(tx.to);
+                value = tx.value;
+                data = tx.input;
+                rawTransactionData = {
+                    from: (0, viem_1.getAddress)(tx.from),
+                    to: (0, viem_1.getAddress)(tx.to),
+                    nonce: tx.nonce,
+                    data: tx.input,
+                    value: tx.value,
+                };
+            }
+        }
+        else {
+            originAddress = (0, viem_1.getAddress)(tx.from);
+            from = (0, viem_1.getAddress)(tx.from);
+            to = (0, viem_1.getAddress)(tx.to);
+            value = tx.value;
+            data = tx.input;
+            rawTransactionData = {
+                from: (0, viem_1.getAddress)(tx.from),
+                to: (0, viem_1.getAddress)(tx.to),
+                nonce: tx.nonce,
+                data: tx.input,
+                value: tx.value,
+            };
+        }
+        // Extract 'to' and 'from' from depositPRC20WithAutoSwap (precompile call)
+        if (data && data.length >= 10) {
+            const depositPRC20Selector = '0x780ad827';
+            if (data.slice(0, 10) === depositPRC20Selector) {
+                try {
+                    const decoded = (0, viem_1.decodeFunctionData)({
+                        abi: [
+                            {
+                                name: 'depositPRC20WithAutoSwap',
+                                type: 'function',
+                                inputs: [
+                                    { name: 'prc20', type: 'address' },
+                                    { name: 'amount', type: 'uint256' },
+                                    { name: 'target', type: 'address' },
+                                    { name: 'fee', type: 'uint24' },
+                                    { name: 'minPCOut', type: 'uint256' },
+                                    { name: 'deadline', type: 'uint256' },
+                                ],
+                            },
+                        ],
+                        data: data,
+                    });
+                    if (decoded.args) {
+                        const target = decoded.args[2];
+                        to = (0, viem_1.getAddress)(target);
+                        from = '0x0000000000000000000000000000000000000000';
+                    }
+                }
+                catch (_b) {
+                    // Keep original values if decoding fails
+                }
+            }
+        }
+        const origin = `${chain_1.VM_NAMESPACE[vm]}:${chainId}:${originAddress}`;
+        // Create signature from transaction r, s, v values
+        let signature;
+        try {
+            signature = {
+                r: tx.r || '0x0',
+                s: tx.s || '0x0',
+                v: typeof tx.v === 'bigint' ? Number(tx.v) : tx.v || 0,
+                yParity: tx.yParity,
+            };
+        }
+        catch (_c) {
+            // Fallback signature if parsing fails
+            signature = {
+                r: '0x0000000000000000000000000000000000000000000000000000000000000000',
+                s: '0x0000000000000000000000000000000000000000000000000000000000000000',
+                v: 0,
+                yParity: 0,
+            };
+        }
+        // Determine transaction type and typeVerbose
+        let type = '99'; // universal
+        let typeVerbose = 'universal';
+        if (tx.type !== undefined) {
+            const txType = tx.type;
+            if (txType === 'eip1559') {
+                type = '2';
+                typeVerbose = 'eip1559';
+            }
+            else if (txType === 'eip2930') {
+                type = '1';
+                typeVerbose = 'eip2930';
+            }
+            else if (txType === 'legacy') {
+                type = '0';
+                typeVerbose = 'legacy';
+            }
+            else if (txType === 'eip4844') {
+                type = '3';
+                typeVerbose = 'eip4844';
+            }
+        }
+        // Storage for registered progress callback (used by progressHook method)
+        let registeredProgressHook;
+        const universalTxResponse = {
+            // 1. Identity
+            hash: tx.hash,
+            origin,
+            // 2. Block Info
+            blockNumber: tx.blockNumber || BigInt(0),
+            blockHash: tx.blockHash || '',
+            transactionIndex: tx.transactionIndex || 0,
+            chainId,
+            // 3. Execution Context
+            from: from, // UEA (executor) address, checksummed for EVM
+            to: to || '',
+            nonce: tx.nonce,
+            // 4. Payload
+            data, // perceived calldata (was input)
+            value,
+            // 5. Gas
+            gasLimit: tx.gas || BigInt(0), // (was gas)
+            gasPrice: tx.gasPrice,
+            maxFeePerGas: tx.maxFeePerGas,
+            maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+            accessList: Array.isArray(tx.accessList) ? [...tx.accessList] : [],
+            // 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 callbacks.trackTransaction(tx.hash, {
+                        waitForCompletion: true,
+                        progressHook: registeredProgressHook,
+                    });
+                    // Get receipt from the tracked response
+                    const receipt = yield tx.wait();
+                    baseReceipt = callbacks.transformToUniversalTxReceipt(receipt, trackedResponse);
+                }
+                else {
+                    const receipt = yield tx.wait();
+                    baseReceipt = callbacks.transformToUniversalTxReceipt(receipt, universalTxResponse);
+                }
+                // If outbound route, poll for external chain details
+                const routeInfo = universalTxResponse.route
+                    ? (0, route_detector_1.getRouteInfo)(universalTxResponse.route)
+                    : undefined;
+                if (routeInfo === null || routeInfo === void 0 ? void 0 : routeInfo.isOutbound) {
+                    try {
+                        const outboundDetails = yield callbacks.waitForOutboundTx(tx.hash, {
+                            initialWaitMs: callbacks.outboundConstants.initialWaitMs,
+                            pollingIntervalMs: callbacks.outboundConstants.pollingIntervalMs,
+                            timeout: callbacks.outboundConstants.maxTimeoutMs,
+                        });
+                        // 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
+                        callbacks.printLog(`[wait] External chain tracking failed: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                return baseReceipt;
+            }),
+            progressHook: (callback) => {
+                registeredProgressHook = callback;
+                // Immediately replay buffered events from execution
+                if (eventBuffer.length > 0) {
+                    for (const event of eventBuffer) {
+                        callback(event);
+                    }
+                }
+            },
+            // 7. Metadata
+            type,
+            typeVerbose,
+            signature,
+            // 8. Raw Universal Fields
+            raw: rawTransactionData,
+        };
+        return universalTxResponse;
+    });
+}
+//# sourceMappingURL=response-builder.js.map

package/src/lib/orchestrator/internals/route-handlers.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Route handler functions extracted from Orchestrator.
+ *
+ * Each function corresponds to one of the multichain execution routes:
+ *   - executeMultiChain  (dispatch)
+ *   - executeUoaToCea    (Route 2 EVM)
+ *   - executeUoaToCeaSvm (Route 2 SVM)
+ *   - executeCeaToPush   (Route 3 EVM)
+ *   - executeCeaToPushSvm(Route 3 SVM)
+ *   - executeCeaToCea    (Route 4 stub)
+ *   - buildPayloadForRoute
+ *
+ * Every method receives an `OrchestratorContext` as first parameter and an
+ * `executeFn` callback that replaces the former `this.execute()` call.
+ */
+import type { OrchestratorContext } from './context';
+import { CHAIN } from '../../constants/enums';
+import { TransactionRoute } from '../route-detector';
+import type { ChainTarget, ExecuteParams, UniversalExecuteParams, UniversalOutboundTxRequest, UniversalTxRequest, UniversalTxResponse } from '../orchestrator.types';
+type ExecuteFn = (params: ExecuteParams | UniversalExecuteParams) => Promise<UniversalTxResponse>;
+/**
+ * Dispatch a universal execution to the correct route handler.
+ */
+export declare function executeMultiChain(ctx: OrchestratorContext, params: UniversalExecuteParams, executeFn: ExecuteFn): Promise<UniversalTxResponse>;
+/**
+ * Route 2: Execute outbound transaction from Push Chain to external CEA.
+ *
+ * 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.
+ */
+export declare function executeUoaToCea(ctx: OrchestratorContext, params: UniversalExecuteParams, executeFn: ExecuteFn): Promise<UniversalTxResponse>;
+/**
+ * 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
+ */
+export declare function executeUoaToCeaSvm(ctx: OrchestratorContext, params: UniversalExecuteParams, target: ChainTarget, executeFn: ExecuteFn): Promise<UniversalTxResponse>;
+/**
+ * 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
+ */
+export declare function executeCeaToPush(ctx: OrchestratorContext, params: UniversalExecuteParams, executeFn: ExecuteFn): Promise<UniversalTxResponse>;
+/**
+ * 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.
+ */
+export declare function executeCeaToPushSvm(ctx: OrchestratorContext, params: UniversalExecuteParams, sourceChain: CHAIN, executeFn: ExecuteFn): Promise<UniversalTxResponse>;
+/**
+ * Route 4: Execute CEA to CEA transaction via Push Chain.
+ */
+export declare function executeCeaToCea(ctx: OrchestratorContext, params: UniversalExecuteParams, executeFn: ExecuteFn): Promise<UniversalTxResponse>;
+/**
+ * Build payload for a specific route.
+ */
+export declare function buildPayloadForRoute(ctx: OrchestratorContext, params: UniversalExecuteParams, route: TransactionRoute, nonce: bigint): Promise<{
+    payload: `0x${string}`;
+    gatewayRequest: UniversalTxRequest | UniversalOutboundTxRequest;
+}>;
+export {};