@pushchain/core 5.1.3 → 5.1.4-alpha.0

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/rescue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rescue.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/lib/orchestrator/internals/rescue.ts"],"names":[],"mappings":"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"}

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>;

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