@pushchain/core 5.1.3 → 5.1.4-alpha.1

package/src/lib/orchestrator/internals/push-chain-tx.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Push Chain transaction broadcasting — extracted from Orchestrator.
+ *
+ * sendPushTx:       Direct EVM tx on Push Chain (single or multicall batch)
+ * sendUniversalTx:  Cosmos-wrapped EVM tx via PushClient (gasless path)
+ */
+import type { UniversalTx } from '../../generated/uexecutor/v1/types';
+import { ProgressEvent } from '../../progress-hook/progress-hook.types';
+import { UniversalPayload } from '../../generated/v1/tx';
+import type { TxResponse } from '../../vm-client/vm-client.types';
+import type { ExecuteParams, UniversalTxResponse } from '../orchestrator.types';
+import type { OrchestratorContext } from './context';
+type TransformToResponseFn = (tx: TxResponse, eventBuffer: ProgressEvent[]) => Promise<UniversalTxResponse>;
+/**
+ * Sends an EVM transaction directly on Push Chain.
+ * Only used when universal signer is on Push Chain.
+ *
+ * For multicall arrays: executes each call as a separate transaction with
+ * local nonce management and per-tx receipt confirmation.
+ */
+export declare function sendPushTx(ctx: OrchestratorContext, execute: ExecuteParams, eventBuffer: ProgressEvent[], transformFn: TransformToResponseFn): Promise<UniversalTxResponse>;
+/**
+ * Sends a Cosmos tx to Push Chain (gasless) to execute user intent.
+ * Wraps the EVM payload in a MsgExecutePayload Cosmos message.
+ */
+export declare function sendUniversalTx(ctx: OrchestratorContext, isUEADeployed: boolean, feeLockTxHash: string | undefined, universalPayload: UniversalPayload | undefined, verificationData: `0x${string}` | undefined, eventBuffer: ProgressEvent[], transformFn: TransformToResponseFn): Promise<UniversalTxResponse[]>;
+/**
+ * Validates Push Chain tx response, extracts last pcTx, fetches EVM tx,
+ * and transforms to UniversalTxResponse.
+ */
+export declare function extractPcTxAndTransform(ctx: OrchestratorContext, pushChainUniversalTx: UniversalTx | undefined, gatewayTxHash: string, eventBuffer: ProgressEvent[], label: string, transformFn: TransformToResponseFn): Promise<UniversalTxResponse>;
+export {};

package/src/lib/orchestrator/internals/push-chain-tx.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * Push Chain transaction broadcasting — extracted from Orchestrator.
+ *
+ * sendPushTx:       Direct EVM tx on Push Chain (single or multicall batch)
+ * sendUniversalTx:  Cosmos-wrapped EVM tx via PushClient (gasless path)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendPushTx = sendPushTx;
+exports.sendUniversalTx = sendUniversalTx;
+exports.extractPcTxAndTransform = extractPcTxAndTransform;
+const tslib_1 = require("tslib");
+const bs58_1 = require("../../internal/bs58");
+const viem_1 = require("viem");
+const chain_1 = require("../../constants/chain");
+const enums_1 = require("../../constants/enums");
+const context_1 = require("./context");
+// ============================================================================
+// sendPushTx
+// ============================================================================
+/**
+ * Sends an EVM transaction directly on Push Chain.
+ * Only used when universal signer is on Push Chain.
+ *
+ * For multicall arrays: executes each call as a separate transaction with
+ * local nonce management and per-tx receipt confirmation.
+ */
+function sendPushTx(ctx, execute, eventBuffer, transformFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        if (Array.isArray(execute.data)) {
+            const PUSH_CHAIN_GAS_LIMIT = BigInt(500000);
+            const MAX_NONCE_RETRIES = 3;
+            let nonce = yield ctx.pushClient.publicClient.getTransactionCount({
+                address: ctx.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 {
+                        (0, context_1.printLog)(ctx, `sendPushTx — executing multicall operation ${i + 1}/${calls.length} to: ${call.to} (nonce: ${nonce})`);
+                        lastTxHash = yield ctx.pushClient.sendTransaction({
+                            to: call.to,
+                            data: (call.data || '0x'),
+                            value: call.value,
+                            signer: ctx.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')) {
+                            (0, context_1.printLog)(ctx, `sendPushTx — nonce mismatch on operation ${i + 1}/${calls.length} (retry ${retry + 1}/${MAX_NONCE_RETRIES}), re-fetching nonce`);
+                            nonce = yield ctx.pushClient.publicClient.getTransactionCount({
+                                address: ctx.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`);
+                }
+                const receipt = yield ctx.pushClient.publicClient.waitForTransactionReceipt({
+                    hash: lastTxHash,
+                });
+                if (receipt.status === 'reverted') {
+                    // Simulate the failed call to extract the revert reason
+                    let revertReason = 'unknown';
+                    try {
+                        yield ctx.pushClient.publicClient.call({
+                            to: call.to,
+                            data: (call.data || '0x'),
+                            value: call.value,
+                            account: ctx.universalSigner.account.address,
+                            blockNumber: receipt.blockNumber,
+                        });
+                    }
+                    catch (simErr) {
+                        // viem decodes common revert reasons into shortMessage
+                        revertReason =
+                            (simErr === null || simErr === void 0 ? void 0 : simErr.shortMessage) || ((_a = simErr === null || simErr === void 0 ? void 0 : simErr.cause) === null || _a === void 0 ? void 0 : _a.reason) || ((_b = simErr === null || simErr === void 0 ? void 0 : simErr.cause) === null || _b === void 0 ? void 0 : _b.message) || (simErr === null || simErr === void 0 ? void 0 : simErr.message) || String(simErr);
+                        // Also log the raw revert data if available
+                        const revertData = ((_c = simErr === null || simErr === void 0 ? void 0 : simErr.cause) === null || _c === void 0 ? void 0 : _c.data) || (simErr === null || simErr === void 0 ? void 0 : simErr.data);
+                        if (revertData) {
+                            revertReason += ` [data: ${revertData}]`;
+                        }
+                    }
+                    (0, context_1.printLog)(ctx, `sendPushTx — multicall operation ${i + 1}/${calls.length} reverted (to: ${call.to}, txHash: ${lastTxHash}, revertReason: ${revertReason})`);
+                    throw new Error(`sendPushTx — multicall operation ${i + 1}/${calls.length} reverted (to: ${call.to}, txHash: ${lastTxHash}, revertReason: ${revertReason})`);
+                }
+                (0, context_1.printLog)(ctx, `sendPushTx — operation ${i + 1}/${calls.length} confirmed in block ${receipt.blockNumber}`);
+                nonce++;
+            }
+            const txResponse = yield ctx.pushClient.getTransaction(lastTxHash);
+            return yield transformFn(txResponse, eventBuffer);
+        }
+        const txHash = yield ctx.pushClient.sendTransaction({
+            to: execute.to,
+            data: (execute.data || '0x'),
+            value: execute.value,
+            signer: ctx.universalSigner,
+        });
+        const txResponse = yield ctx.pushClient.getTransaction(txHash);
+        return yield transformFn(txResponse, eventBuffer);
+    });
+}
+// ============================================================================
+// sendUniversalTx
+// ============================================================================
+/**
+ * Sends a Cosmos tx to Push Chain (gasless) to execute user intent.
+ * Wraps the EVM payload in a MsgExecutePayload Cosmos message.
+ */
+function sendUniversalTx(ctx, isUEADeployed, feeLockTxHash, universalPayload, verificationData, eventBuffer, transformFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const { chain, address } = ctx.universalSigner.account;
+        const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+        const universalAccountId = {
+            chainNamespace: chain_1.VM_NAMESPACE[vm],
+            chainId: chainId,
+            owner: vm === enums_1.VM.EVM
+                ? address
+                : vm === enums_1.VM.SVM
+                    ? (0, viem_1.bytesToHex)(new Uint8Array(bs58_1.bs58.decode(address)))
+                    : address,
+        };
+        const { cosmosAddress: signer } = ctx.pushClient.getSignerAddress();
+        const msgs = [];
+        if (universalPayload && verificationData) {
+            msgs.push(ctx.pushClient.createMsgExecutePayload({
+                signer,
+                universalAccountId,
+                universalPayload,
+                verificationData,
+            }));
+        }
+        const txBody = yield ctx.pushClient.createCosmosTxBody(msgs);
+        const txRaw = yield ctx.pushClient.signCosmosTx(txBody);
+        const tx = yield ctx.pushClient.broadcastCosmosTx(txRaw);
+        if (tx.code !== 0) {
+            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 : [];
+            const failureSummary = [
+                `PUSH CHAIN TRANSACTION FAILED`,
+                `Cosmos TX Hash: ${tx.transactionHash}`,
+                `Block Height: ${tx.height}, TX Code: ${tx.code} (error)`,
+                `Gas Used: ${tx.gasUsed}, Gas Wanted: ${tx.gasWanted}`,
+                ...(failedEthTxHashes.length > 0 ? [`Ethereum TX Hash(es): ${failedEthTxHashes.join(', ')}`] : []),
+                `Error: ${tx.rawLog}`,
+            ].join(' | ');
+            (0, context_1.printLog)(ctx, failureSummary);
+            throw new Error(tx.rawLog);
+        }
+        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 && _d !== void 0 ? _d : [];
+        if (ethTxHashes.length === 0) {
+            throw new Error('No ethereumTxHash found in transaction events');
+        }
+        const evmTxs = yield Promise.all(ethTxHashes.map((hash) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield ctx.pushClient.getTransaction(hash);
+        })));
+        const responses = yield Promise.all(evmTxs.map((tx, index) => transformFn(tx, index === evmTxs.length - 1 ? eventBuffer : [])));
+        return responses;
+    });
+}
+// ============================================================================
+// extractPcTxAndTransform
+// ============================================================================
+/**
+ * Validates Push Chain tx response, extracts last pcTx, fetches EVM tx,
+ * and transforms to UniversalTxResponse.
+ */
+function extractPcTxAndTransform(ctx, pushChainUniversalTx, gatewayTxHash, eventBuffer, label, transformFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!((_a = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _a === void 0 ? void 0 : _a.length)) {
+            throw new Error(`Failed to retrieve Push Chain transaction status for gateway tx: ${gatewayTxHash}. ` +
+                `The transaction may have failed on Push Chain or not been indexed yet.`);
+        }
+        const lastPcTransaction = pushChainUniversalTx.pcTx.at(-1);
+        (0, context_1.printLog)(ctx, `${label} — pcTx: ` + JSON.stringify(pushChainUniversalTx.pcTx.map((p) => ({ txHash: p.txHash, status: p.status, errorMsg: p.errorMsg })), null, 2));
+        (0, context_1.printLog)(ctx, `${label} — using lastPcTransaction: ` + JSON.stringify(lastPcTransaction, null, 2));
+        if (!(lastPcTransaction === null || lastPcTransaction === void 0 ? void 0 : lastPcTransaction.txHash)) {
+            const failedPcTx = pushChainUniversalTx.pcTx.find((pcTx) => pcTx.status === 'FAILED' && pcTx.errorMsg);
+            const errorDetails = (failedPcTx === null || failedPcTx === void 0 ? void 0 : failedPcTx.errorMsg) ? `: ${failedPcTx.errorMsg}` : '';
+            throw new Error(`No transaction hash found in Push Chain response for gateway tx: ${gatewayTxHash}${errorDetails}`);
+        }
+        const tx = yield ctx.pushClient.getTransaction(lastPcTransaction.txHash);
+        return transformFn(tx, eventBuffer);
+    });
+}
+//# sourceMappingURL=push-chain-tx.js.map

package/src/lib/orchestrator/internals/quote.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Uniswap V3 exact-output quoting — extracted from Orchestrator.
+ */
+import { ConversionQuote, MoveableToken, PayableToken } from '../../constants/tokens';
+import type { OrchestratorContext } from './context';
+export declare function quoteExactOutput(ctx: OrchestratorContext, amountOut: bigint, { from, to, }: {
+    from: PayableToken | undefined;
+    to: MoveableToken | undefined;
+}): Promise<ConversionQuote>;

package/src/lib/orchestrator/internals/quote.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Uniswap V3 exact-output quoting — extracted from Orchestrator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteExactOutput = quoteExactOutput;
+const tslib_1 = require("tslib");
+const viem_1 = require("viem");
+const chain_1 = require("../../constants/chain");
+const enums_1 = require("../../constants/enums");
+const utils_1 = require("../../utils");
+const evm_client_1 = require("../../vm-client/evm-client");
+function quoteExactOutput(ctx_1, amountOut_1, _a) {
+    return tslib_1.__awaiter(this, arguments, void 0, function* (ctx, amountOut, { from, to, }) {
+        var _b, _c, _d;
+        const originChain = ctx.universalSigner.account.chain;
+        if (originChain !== enums_1.CHAIN.ETHEREUM_MAINNET &&
+            originChain !== enums_1.CHAIN.ETHEREUM_SEPOLIA) {
+            throw new Error('Exact-output quoting is only supported on Ethereum Mainnet and Sepolia for now');
+        }
+        if (!from)
+            throw new Error('from token is required');
+        if (!to)
+            throw new Error('to token is required');
+        const rpcUrls = ctx.rpcUrls[originChain] || chain_1.CHAIN_INFO[originChain].defaultRPC;
+        const evm = new evm_client_1.EvmClient({ rpcUrls });
+        const factoryFromConfig = (_b = chain_1.CHAIN_INFO[originChain].dex) === null || _b === void 0 ? void 0 : _b.uniV3Factory;
+        const quoterFromConfig = (_c = chain_1.CHAIN_INFO[originChain].dex) === null || _c === void 0 ? void 0 : _c.uniV3QuoterV2;
+        if (!factoryFromConfig || !quoterFromConfig) {
+            throw new Error('Uniswap V3 addresses not configured for this chain');
+        }
+        const UNISWAP_V3_FACTORY = factoryFromConfig;
+        const UNISWAP_V3_QUOTER_V2 = quoterFromConfig;
+        const factoryAbi = (0, viem_1.parseAbi)([
+            'function getPool(address tokenA, address tokenB, uint24 fee) view returns (address)',
+        ]);
+        const quoterAbi = (0, viem_1.parseAbi)([
+            'function quoteExactOutputSingle((address tokenIn, address tokenOut, uint256 amount, uint24 fee, uint160 sqrtPriceLimitX96) params) returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)',
+        ]);
+        const poolAbi = (0, viem_1.parseAbi)([
+            'function liquidity() view returns (uint128)',
+        ]);
+        const feeTiers = [100, 500, 3000, 10000];
+        let bestAmountIn = null;
+        let bestFee = null;
+        for (const fee of feeTiers) {
+            const poolAddress = yield evm.readContract({
+                abi: factoryAbi,
+                address: UNISWAP_V3_FACTORY,
+                functionName: 'getPool',
+                args: [from.address, to.address, fee],
+            });
+            const isZero = !poolAddress ||
+                poolAddress.toLowerCase() ===
+                    '0x0000000000000000000000000000000000000000';
+            if (isZero)
+                continue;
+            try {
+                const liquidity = yield evm.readContract({
+                    abi: poolAbi,
+                    address: poolAddress,
+                    functionName: 'liquidity',
+                    args: [],
+                });
+                if (!liquidity || liquidity === BigInt(0))
+                    continue;
+            }
+            catch (_e) {
+                continue;
+            }
+            try {
+                const result = yield evm.readContract({
+                    abi: quoterAbi,
+                    address: UNISWAP_V3_QUOTER_V2,
+                    functionName: 'quoteExactOutputSingle',
+                    args: [
+                        {
+                            tokenIn: from.address,
+                            tokenOut: to.address,
+                            amount: amountOut,
+                            fee,
+                            sqrtPriceLimitX96: BigInt(0),
+                        },
+                    ],
+                });
+                const amountIn = (_d = result === null || result === void 0 ? void 0 : result[0]) !== null && _d !== void 0 ? _d : BigInt(0);
+                if (amountIn === BigInt(0))
+                    continue;
+                if (bestAmountIn === null || amountIn < bestAmountIn) {
+                    bestAmountIn = amountIn;
+                    bestFee = fee;
+                }
+            }
+            catch (_f) {
+                // try next fee
+            }
+        }
+        if (bestAmountIn === null || bestFee === null) {
+            throw new Error('No direct Uniswap V3 pool found for the given token pair on common fee tiers');
+        }
+        const amountInBig = BigInt(bestAmountIn);
+        const amountInHuman = parseFloat(utils_1.Utils.helpers.formatUnits(amountInBig, { decimals: from.decimals }));
+        const amountOutHuman = parseFloat(utils_1.Utils.helpers.formatUnits(amountOut, { decimals: to.decimals }));
+        const rate = amountInHuman > 0 ? amountOutHuman / amountInHuman : 0;
+        return {
+            amountIn: bestAmountIn.toString(),
+            amountOut: amountOut.toString(),
+            rate,
+            route: [from.symbol, to.symbol],
+            timestamp: Date.now(),
+        };
+    });
+}
+//# sourceMappingURL=quote.js.map

package/src/lib/orchestrator/internals/rescue.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Rescue funds flow — extracted from Orchestrator.rescueFunds.
+ *
+ * Recovers stuck tokens from failed inbound transactions by building
+ * a rescue multicall and executing it through the standard execute() flow.
+ */
+import type { ExecuteParams, RescueFundsParams, UniversalTxResponse } from '../orchestrator.types';
+import type { OrchestratorContext } from './context';
+/**
+ * Rescue stuck funds on a source chain.
+ * When a CEA-to-Push inbound transaction fails, tokens get locked in the
+ * Vault on the source chain. This triggers a manual revert via TSS to
+ * release those funds back to the user.
+ *
+ * @param ctx - Orchestrator context
+ * @param params - RescueFundsParams with universalTxId and prc20 token
+ * @param executeFn - The Orchestrator.execute() method (avoids circular dep)
+ * @returns Transaction response
+ */
+export declare function rescueFunds(ctx: OrchestratorContext, params: RescueFundsParams, executeFn: (params: ExecuteParams) => Promise<UniversalTxResponse>): Promise<UniversalTxResponse>;

package/src/lib/orchestrator/internals/rescue.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Rescue funds flow — extracted from Orchestrator.rescueFunds.
+ *
+ * Recovers stuck tokens from failed inbound transactions by building
+ * a rescue multicall and executing it through the standard execute() flow.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rescueFunds = rescueFunds;
+const tslib_1 = require("tslib");
+const viem_1 = require("viem");
+const universalGatewayPC_evm_1 = require("../../constants/abi/universalGatewayPC.evm");
+const selectors_1 = require("../../constants/selectors");
+const context_1 = require("./context");
+const helpers_1 = require("./helpers");
+const uea_manager_1 = require("./uea-manager");
+const gas_calculator_1 = require("./gas-calculator");
+// ============================================================================
+// rescueFunds
+// ============================================================================
+/**
+ * Rescue stuck funds on a source chain.
+ * When a CEA-to-Push inbound transaction fails, tokens get locked in the
+ * Vault on the source chain. This triggers a manual revert via TSS to
+ * release those funds back to the user.
+ *
+ * @param ctx - Orchestrator context
+ * @param params - RescueFundsParams with universalTxId and prc20 token
+ * @param executeFn - The Orchestrator.execute() method (avoids circular dep)
+ * @returns Transaction response
+ */
+function rescueFunds(ctx, params, executeFn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // Validate universalTxId format (bytes32: 0x + 64 hex chars)
+        if (!params.universalTxId ||
+            params.universalTxId.length !== 66 ||
+            !/^0x[0-9a-fA-F]{64}$/.test(params.universalTxId)) {
+            throw new Error(`Invalid universalTxId: expected 0x-prefixed bytes32 (66 chars), got "${params.universalTxId}"`);
+        }
+        // Validate prc20 is not zero address
+        if (!params.prc20 ||
+            params.prc20 === selectors_1.ZERO_ADDRESS) {
+            throw new Error('prc20 token address cannot be zero address');
+        }
+        const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
+        const gatewayPcAddress = (0, helpers_1.getUniversalGatewayPCAddress)();
+        (0, context_1.printLog)(ctx, `rescueFunds — universalTxId=${params.universalTxId}, prc20=${params.prc20}, gateway=${gatewayPcAddress}`);
+        // Pre-fetch UEA status
+        const [ueaCode, ueaBalance] = yield Promise.all([
+            ctx.pushClient.publicClient.getCode({ address: ueaAddress }),
+            ctx.pushClient.getBalance(ueaAddress),
+        ]);
+        const isUEADeployed = ueaCode !== undefined;
+        const ueaNonce = isUEADeployed ? yield (0, uea_manager_1.getUEANonce)(ctx, ueaAddress) : BigInt(0);
+        // Query rescue gas fee
+        let nativeValueForGas = BigInt(0);
+        try {
+            const result = yield (0, gas_calculator_1.queryRescueGasFee)(ctx, params.prc20);
+            nativeValueForGas = result.nativeValueForGas;
+            (0, context_1.printLog)(ctx, `rescueFunds — queried gas fee: gasFee=${result.gasFee.toString()}, gasToken=${result.gasToken}, nativeValueForGas=${nativeValueForGas.toString()}`);
+        }
+        catch (err) {
+            throw new Error(`Failed to query rescue gas fee: ${err}`);
+        }
+        // Adjust nativeValueForGas using the same balance-capping pattern as outbound
+        const EVM_NATIVE_VALUE_TARGET = BigInt(200e18); // 200 UPC
+        const EVM_GAS_RESERVE = BigInt(3e18); // 3 UPC for tx overhead
+        const currentBalance = ueaBalance;
+        let adjustedValue;
+        if (currentBalance > EVM_NATIVE_VALUE_TARGET + EVM_GAS_RESERVE) {
+            adjustedValue = EVM_NATIVE_VALUE_TARGET;
+        }
+        else if (currentBalance > EVM_GAS_RESERVE) {
+            adjustedValue = currentBalance - EVM_GAS_RESERVE;
+        }
+        else {
+            adjustedValue = nativeValueForGas;
+        }
+        if (adjustedValue !== nativeValueForGas) {
+            (0, context_1.printLog)(ctx, `rescueFunds — adjusting nativeValueForGas from ${nativeValueForGas.toString()} to ${adjustedValue.toString()} (UEA balance: ${currentBalance.toString()})`);
+            nativeValueForGas = adjustedValue;
+        }
+        // Build single rescue multicall (no PRC-20 approval needed — no burn)
+        const rescueCallData = (0, viem_1.encodeFunctionData)({
+            abi: universalGatewayPC_evm_1.UNIVERSAL_GATEWAY_PC,
+            functionName: 'rescueFundsOnSourceChain',
+            args: [params.universalTxId, params.prc20],
+        });
+        const pushChainMulticalls = [
+            {
+                to: gatewayPcAddress,
+                value: nativeValueForGas,
+                data: rescueCallData,
+            },
+        ];
+        (0, context_1.printLog)(ctx, `rescueFunds — built rescue multicall, nativeValueForGas=${nativeValueForGas.toString()}`);
+        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,
+            data: pushChainMulticalls,
+            _ueaStatus: {
+                isDeployed: isUEADeployed,
+                nonce: ueaNonce,
+                balance: ueaBalance,
+            },
+            _skipFeeLocking: true,
+        };
+        return executeFn(executeParams);
+    });
+}
+//# sourceMappingURL=rescue.js.map

package/src/lib/orchestrator/internals/response-builder.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Response builder functions extracted from Orchestrator.
+ *
+ * Contains: queryUniversalTxStatusFromGatewayTx, trackTransaction,
+ * transformToUniversalTxResponse, and the ResponseBuilderCallbacks interface.
+ */
+import { UniversalTx } from '../../generated/uexecutor/v1/types';
+import { ProgressEvent } from '../../progress-hook/progress-hook.types';
+import { EvmClient } from '../../vm-client/evm-client';
+import type { TxResponse } from '../../vm-client/vm-client.types';
+import type { UniversalTxReceipt, UniversalTxResponse, TrackTransactionOptions } from '../orchestrator.types';
+import type { OrchestratorContext } from './context';
+export interface ResponseBuilderCallbacks {
+    trackTransaction: (hash: string, opts?: any) => Promise<UniversalTxResponse>;
+    waitForOutboundTx: (hash: string, opts?: any) => Promise<any>;
+    transformToUniversalTxReceipt: (receipt: any, response: any) => UniversalTxReceipt;
+    printLog: (msg: string) => void;
+    outboundConstants: {
+        initialWaitMs: number;
+        pollingIntervalMs: number;
+        maxTimeoutMs: number;
+    };
+}
+export declare function queryUniversalTxStatusFromGatewayTx(ctx: OrchestratorContext, evmClient: EvmClient | undefined, gatewayAddress: `0x${string}` | undefined, txHash: string, evmGatewayMethod: 'sendFunds' | 'sendTxWithFunds' | 'sendTxWithGas'): Promise<UniversalTx | undefined>;
+export declare function trackTransaction(ctx: OrchestratorContext, txHash: string, options?: TrackTransactionOptions, callbacks?: ResponseBuilderCallbacks): Promise<UniversalTxResponse>;
+export declare function transformToUniversalTxResponse(ctx: OrchestratorContext, tx: TxResponse, eventBuffer: ProgressEvent[] | undefined, callbacks: ResponseBuilderCallbacks): Promise<UniversalTxResponse>;