@pushchain/core 5.1.3 → 5.1.4-alpha.1

package/src/lib/orchestrator/internals/outbound-sync.js

@@ -0,0 +1,357 @@
+"use strict";
+/**
+ * Outbound transaction sync: polling helpers that wait for outbound
+ * transactions to complete on external chains.
+ *
+ * Extracted from Orchestrator.waitForOutboundTx / waitForAllOutboundTxsV2.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTBOUND_MAX_TIMEOUT_MS = exports.OUTBOUND_POLL_INTERVAL_MS = exports.OUTBOUND_INITIAL_WAIT_MS = void 0;
+exports.waitForOutboundTx = waitForOutboundTx;
+exports.waitForAllOutboundTxsV2 = waitForAllOutboundTxsV2;
+const tslib_1 = require("tslib");
+const bs58_1 = require("../../internal/bs58");
+const chain_1 = require("../../constants/chain");
+const enums_1 = require("../../constants/enums");
+const types_1 = require("../../generated/uexecutor/v1/types");
+const types_2 = require("../../generated/uexecutor/v2/types");
+const context_1 = require("./context");
+const helpers_1 = require("./helpers");
+const outbound_tracker_1 = require("./outbound-tracker");
+// ============================================================================
+// Outbound sync configuration constants
+// ============================================================================
+/** Initial wait before the first poll (ms). */
+exports.OUTBOUND_INITIAL_WAIT_MS = 20000; // 20s
+/** Interval between consecutive polls (ms). */
+exports.OUTBOUND_POLL_INTERVAL_MS = 5000; // 5s
+/** Maximum total timeout for the polling loop (ms). */
+exports.OUTBOUND_MAX_TIMEOUT_MS = 180000; // 180s (3 min)
+// ============================================================================
+// waitForOutboundTx
+// ============================================================================
+/**
+ * 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 ctx - Orchestrator context
+ * @param pushChainTxHash - The Push Chain transaction hash
+ * @param options - Polling configuration options
+ * @returns External chain tx details
+ * @throws Error on timeout
+ */
+function waitForOutboundTx(ctx_1, pushChainTxHash_1) {
+    return tslib_1.__awaiter(this, arguments, void 0, function* (ctx, pushChainTxHash, options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const { initialWaitMs = exports.OUTBOUND_INITIAL_WAIT_MS, pollingIntervalMs = exports.OUTBOUND_POLL_INTERVAL_MS, timeout = exports.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();
+        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Starting | txHash: ${pushChainTxHash} | initialWait: ${initialWaitMs}ms | pollInterval: ${pollingIntervalMs}ms | timeout: ${timeout}ms`);
+        progressHook === null || progressHook === void 0 ? void 0 : progressHook({ status: 'waiting', elapsed: 0 });
+        (0, context_1.printLog)(ctx, `[waitForOutboundTx] Initial wait of ${initialWaitMs}ms...`);
+        yield new Promise((resolve) => setTimeout(resolve, initialWaitMs));
+        // Start polling
+        (0, context_1.printLog)(ctx, `[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();
+            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | Elapsed: ${pollStart - startTime}ms / ${timeout}ms`);
+            if (!cachedUniversalSubTxId) {
+                cachedUniversalSubTxId = (_a = (yield (0, outbound_tracker_1.extractUniversalSubTxIdFromTx)(ctx, pushChainTxHash))) !== null && _a !== void 0 ? _a : undefined;
+                if (!cachedUniversalSubTxId) {
+                    cachedUniversalSubTxId = (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, pushChainTxHash);
+                }
+                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Extracted & cached universalSubTxId: ${cachedUniversalSubTxId}`);
+            }
+            // Query with cached ID
+            const queryId = cachedUniversalSubTxId.startsWith('0x')
+                ? cachedUniversalSubTxId.slice(2)
+                : cachedUniversalSubTxId;
+            try {
+                const utxResponse = yield ctx.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) || [];
+                (0, context_1.printLog)(ctx, `[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)) {
+                    (0, context_1.printLog)(ctx, `[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) {
+                        (0, context_1.printLog)(ctx, `[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) {
+                            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} | outbound chain '${ob.destinationChain}' does not match expected '${_expectedDestinationChain}', skipping`);
+                            continue;
+                        }
+                        const chain = (0, helpers_1.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 = bs58_1.bs58.encode(Buffer.from(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,
+                            };
+                            (0, context_1.printLog)(ctx, `[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;
+                }
+                (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} ERROR: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            (0, context_1.printLog)(ctx, `[waitForOutboundTx] Poll #${pollCount} not ready yet (${Date.now() - pollStart}ms). Waiting ${pollingIntervalMs}ms...`);
+            // Wait before next poll
+            yield new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+        }
+        (0, context_1.printLog)(ctx, `[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.`);
+    });
+}
+// ============================================================================
+// waitForAllOutboundTxsV2
+// ============================================================================
+/**
+ * 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.
+ */
+function waitForAllOutboundTxsV2(ctx, 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()];
+        (0, context_1.printLog)(ctx, `[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);
+        (0, context_1.printLog)(ctx, `[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;
+            (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} | Elapsed: ${elapsed}ms / ${timeout}ms`);
+            // Resolve query ID on first poll
+            if (!cachedQueryId) {
+                const allSubTxIds = yield (0, outbound_tracker_1.extractAllUniversalSubTxIds)(ctx, pushChainTxHash);
+                const subTxId = allSubTxIds.length > 0 ? allSubTxIds[0] : (0, outbound_tracker_1.computeUniversalTxId)(ctx.pushNetwork, pushChainTxHash);
+                cachedQueryId = subTxId.startsWith('0x') ? subTxId.slice(2) : subTxId;
+                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Resolved queryId: ${cachedQueryId}`);
+            }
+            try {
+                const v2Response = yield ctx.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;
+                (0, context_1.printLog)(ctx, `[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';
+                                (0, context_1.printLog)(ctx, `[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 = (0, helpers_1.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 = bs58_1.bs58.encode(Buffer.from(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,
+                                };
+                                (0, context_1.printLog)(ctx, `[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')) {
+                    (0, context_1.printLog)(ctx, `[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';
+                                (0, context_1.printLog)(ctx, `[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
+                        (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] ${stillUnresolved.length} hop(s) unresolved, pending outbound txs in flight — continuing to poll`);
+                    }
+                }
+            }
+            catch (error) {
+                consecutiveErrors++;
+                (0, context_1.printLog)(ctx, `[waitForAllOutboundTxsV2] Poll #${pollCount} ERROR (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${error instanceof Error ? error.message : String(error)}`);
+                if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                    (0, context_1.printLog)(ctx, `[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) {
+            (0, context_1.printLog)(ctx, `[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 };
+    });
+}
+//# sourceMappingURL=outbound-sync.js.map

package/src/lib/orchestrator/internals/outbound-tracker.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Outbound transaction tracking and UTX ID extraction, extracted from Orchestrator.
+ */
+import type { PUSH_NETWORK } from '../../constants/enums';
+import type { OrchestratorContext } from './context';
+export declare function computeUniversalTxId(pushNetwork: PUSH_NETWORK, pushChainTxHash: string): string;
+export declare function extractAllUniversalSubTxIds(ctx: OrchestratorContext, pushChainTxHash: string): Promise<string[]>;
+export declare function extractUniversalSubTxIdFromTx(ctx: OrchestratorContext, pushChainTxHash: string): Promise<string | null>;

package/src/lib/orchestrator/internals/outbound-tracker.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Outbound transaction tracking and UTX ID extraction, extracted from Orchestrator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeUniversalTxId = computeUniversalTxId;
+exports.extractAllUniversalSubTxIds = extractAllUniversalSubTxIds;
+exports.extractUniversalSubTxIdFromTx = extractUniversalSubTxIdFromTx;
+const tslib_1 = require("tslib");
+const viem_1 = require("viem");
+const chain_1 = require("../../constants/chain");
+const context_1 = require("./context");
+const helpers_1 = require("./helpers");
+// ============================================================================
+// UTX ID Computation
+// ============================================================================
+function computeUniversalTxId(pushNetwork, pushChainTxHash) {
+    const pushChain = (0, helpers_1.getPushChainForNetwork)(pushNetwork);
+    const pushChainId = chain_1.CHAIN_INFO[pushChain].chainId;
+    const input = `eip155:${pushChainId}:${pushChainTxHash}`;
+    return (0, viem_1.keccak256)((0, viem_1.toBytes)(input));
+}
+// ============================================================================
+// UTX ID Extraction from Cosmos Events
+// ============================================================================
+function extractAllUniversalSubTxIds(ctx, pushChainTxHash) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        (0, context_1.printLog)(ctx, `[extractAllUniversalSubTxIds] Fetching Cosmos tx for: ${pushChainTxHash}`);
+        try {
+            const cosmosTx = yield ctx.pushClient.getCosmosTx(pushChainTxHash);
+            if (!(cosmosTx === null || cosmosTx === void 0 ? void 0 : cosmosTx.events)) {
+                (0, context_1.printLog)(ctx, `[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);
+                    }
+                }
+            }
+            (0, context_1.printLog)(ctx, `[extractAllUniversalSubTxIds] Found ${subTxIds.length} sub-tx IDs: ${subTxIds.join(', ')}`);
+            return subTxIds;
+        }
+        catch (error) {
+            (0, context_1.printLog)(ctx, `[extractAllUniversalSubTxIds] Error: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    });
+}
+function extractUniversalSubTxIdFromTx(ctx, pushChainTxHash) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const ids = yield extractAllUniversalSubTxIds(ctx, pushChainTxHash);
+        return (_a = ids[0]) !== null && _a !== void 0 ? _a : null;
+    });
+}
+//# sourceMappingURL=outbound-tracker.js.map

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

@@ -0,0 +1,24 @@
+/**
+ * Payload construction functions for the orchestrator.
+ *
+ * buildUniversalTxRequest:     Creates gateway request with revert instruction
+ * buildMulticallPayloadData:   Encodes UEA_MULTICALL selector + abi-encoded calls
+ * buildGatewayPayloadAndGas:   Constructs UniversalPayload + gateway request for fund flows
+ */
+import type { ExecuteParams, MultiCall, UniversalTxRequest } from '../orchestrator.types';
+import type { OrchestratorContext } from './context';
+export declare function buildUniversalTxRequest(signerAddress: `0x${string}`, { recipient, token, amount, payload, }: {
+    recipient: `0x${string}`;
+    token: `0x${string}`;
+    amount: bigint;
+    payload: `0x${string}`;
+}): UniversalTxRequest;
+export declare function buildMulticallPayloadData(ctx: OrchestratorContext, to: `0x${string}`, data: MultiCall[]): `0x${string}`;
+/**
+ * Builds the universal payload and gateway request for sendFunds / sendTxWithFunds flows.
+ */
+export declare function buildGatewayPayloadAndGas(ctx: OrchestratorContext, execute: ExecuteParams, nonce: bigint, type: 'sendFunds' | 'sendTxWithFunds', fundsValue?: bigint): Promise<{
+    payload: never;
+    gasAmount: bigint;
+    req: UniversalTxRequest;
+}>;

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

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Payload construction functions for the orchestrator.
+ *
+ * buildUniversalTxRequest:     Creates gateway request with revert instruction
+ * buildMulticallPayloadData:   Encodes UEA_MULTICALL selector + abi-encoded calls
+ * buildGatewayPayloadAndGas:   Constructs UniversalPayload + gateway request for fund flows
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUniversalTxRequest = buildUniversalTxRequest;
+exports.buildMulticallPayloadData = buildMulticallPayloadData;
+exports.buildGatewayPayloadAndGas = buildGatewayPayloadAndGas;
+const tslib_1 = require("tslib");
+const viem_1 = require("viem");
+const tx_1 = require("../../generated/v1/tx");
+const payload_builders_1 = require("../payload-builders");
+const context_1 = require("./context");
+const helpers_1 = require("./helpers");
+const signing_1 = require("./signing");
+const uea_manager_1 = require("./uea-manager");
+// ============================================================================
+// Universal Tx Request Builder
+// ============================================================================
+function buildUniversalTxRequest(signerAddress, { recipient, token, amount, payload, }) {
+    const revertInstruction = {
+        fundRecipient: signerAddress,
+        revertMsg: '0x',
+    };
+    return {
+        recipient,
+        token,
+        amount,
+        payload,
+        revertInstruction,
+        signatureData: '0x',
+    };
+}
+// ============================================================================
+// Multicall Encoding
+// ============================================================================
+function buildMulticallPayloadData(ctx, to, data) {
+    (0, context_1.printLog)(ctx, '_buildMulticallPayloadData — input: ' +
+        data.length +
+        ' calls: ' +
+        JSON.stringify(data, (_, v) => (typeof v === 'bigint' ? v.toString() : v), 2));
+    if (!helpers_1.SUPPORTED_GATEWAY_CHAINS.includes(ctx.universalSigner.account.chain)) {
+        throw new Error('Multicall is only enabled for Ethereum Sepolia, Arbitrum Sepolia, Base Sepolia, BNB Testnet and Solana Devnet');
+    }
+    // Normalize and validate calls
+    const normalizedCalls = data.map((c) => ({
+        to: (0, viem_1.getAddress)(c.to),
+        value: c.value,
+        data: c.data,
+    }));
+    // bytes4(keccak256("UEA_MULTICALL")) selector
+    const selector = (0, viem_1.keccak256)((0, viem_1.toBytes)('UEA_MULTICALL')).slice(0, 10);
+    // abi.encode(Call[]), where Call = { address to; uint256 value; bytes data; }
+    const encodedCalls = (0, viem_1.encodeAbiParameters)([
+        {
+            type: 'tuple[]',
+            components: [
+                { name: 'to', type: 'address' },
+                { name: 'value', type: 'uint256' },
+                { name: 'data', type: 'bytes' },
+            ],
+        },
+    ], [normalizedCalls]);
+    return (selector + encodedCalls.slice(2));
+}
+// ============================================================================
+// Gateway Payload + Gas Builder
+// ============================================================================
+/**
+ * Builds the universal payload and gateway request for sendFunds / sendTxWithFunds flows.
+ */
+function buildGatewayPayloadAndGas(ctx, execute, nonce, type, fundsValue) {
+    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, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6;
+        const gasEstimate = execute.gasLimit || BigInt(1e7);
+        const gasAmount = (_a = execute.value) !== null && _a !== void 0 ? _a : BigInt(0);
+        const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
+        if (type === 'sendTxWithFunds') {
+            if (!((_b = execute.funds) === null || _b === void 0 ? void 0 : _b.token))
+                throw new Error(`Invalid ${(_c = execute.funds) === null || _c === void 0 ? void 0 : _c.token}`);
+            const multicallData = (0, payload_builders_1.buildExecuteMulticall)({
+                execute,
+                ueaAddress,
+            });
+            const universalPayload = {
+                to: viem_1.zeroAddress,
+                value: (_d = execute.value) !== null && _d !== void 0 ? _d : BigInt(0),
+                data: buildMulticallPayloadData(ctx, execute.to, multicallData),
+                gasLimit: gasEstimate,
+                maxFeePerGas: execute.maxFeePerGas || BigInt(1e10),
+                maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(0),
+                nonce,
+                deadline: execute.deadline || BigInt(9999999999),
+                vType: tx_1.VerificationType.universalTxVerification,
+            };
+            (0, context_1.printLog)(ctx, '(universalPayload) ' + universalPayload);
+            let tokenAddress = (_f = (_e = execute.funds) === null || _e === void 0 ? void 0 : _e.token) === null || _f === void 0 ? void 0 : _f.address;
+            if (((_h = (_g = execute.funds) === null || _g === void 0 ? void 0 : _g.token) === null || _h === void 0 ? void 0 : _h.address) ===
+                '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
+                tokenAddress = viem_1.zeroAddress;
+            }
+            const req = buildUniversalTxRequest(ctx.universalSigner.account.address, {
+                recipient: viem_1.zeroAddress,
+                token: tokenAddress,
+                amount: (_j = execute.funds) === null || _j === void 0 ? void 0 : _j.amount,
+                payload: (0, signing_1.encodeUniversalPayload)(universalPayload),
+            });
+            return { payload: universalPayload, gasAmount, req };
+        }
+        else {
+            if (!fundsValue)
+                throw new Error('fundsValue property must not be empty');
+            const multicallData = (0, payload_builders_1.buildExecuteMulticall)({
+                execute,
+                ueaAddress,
+            });
+            (0, context_1.printLog)(ctx, 'sendFunds — execute params: ' + JSON.stringify({
+                to: execute.to,
+                value: (_l = (_k = execute.value) === null || _k === void 0 ? void 0 : _k.toString()) !== null && _l !== void 0 ? _l : 'undefined',
+                data: (_m = execute.data) !== null && _m !== void 0 ? _m : 'undefined',
+                fundsAmount: (_p = (_o = execute.funds) === null || _o === void 0 ? void 0 : _o.amount) === null || _p === void 0 ? void 0 : _p.toString(),
+                fundsToken: (_r = (_q = execute.funds) === null || _q === void 0 ? void 0 : _q.token) === null || _r === void 0 ? void 0 : _r.symbol,
+                tokenMechanism: (_t = (_s = execute.funds) === null || _s === void 0 ? void 0 : _s.token) === null || _t === void 0 ? void 0 : _t.mechanism,
+                tokenAddress: (_v = (_u = execute.funds) === null || _u === void 0 ? void 0 : _u.token) === null || _v === void 0 ? void 0 : _v.address,
+                gasLimit: (_x = (_w = execute.gasLimit) === null || _w === void 0 ? void 0 : _w.toString()) !== null && _x !== void 0 ? _x : 'undefined',
+            }, null, 2));
+            (0, context_1.printLog)(ctx, 'sendFunds — multicallData: ' + JSON.stringify(multicallData, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) + ' (length: ' + multicallData.length + ')');
+            const multicallPayloadData = buildMulticallPayloadData(ctx, execute.to, multicallData);
+            (0, context_1.printLog)(ctx, 'sendFunds — multicallPayloadData (first 66 chars): ' + multicallPayloadData.slice(0, 66) + ' (full length: ' + multicallPayloadData.length + ')');
+            const universalPayload = {
+                to: viem_1.zeroAddress,
+                value: (_y = execute.value) !== null && _y !== void 0 ? _y : BigInt(0),
+                data: multicallPayloadData,
+                gasLimit: gasEstimate,
+                maxFeePerGas: execute.maxFeePerGas || BigInt(1e10),
+                maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(0),
+                nonce,
+                deadline: execute.deadline || BigInt(9999999999),
+                vType: tx_1.VerificationType.universalTxVerification,
+            };
+            (0, context_1.printLog)(ctx, 'sendFunds — universalPayload (pre-encode): ' + JSON.stringify({
+                to: viem_1.zeroAddress,
+                value: ((_z = execute.value) !== null && _z !== void 0 ? _z : BigInt(0)).toString(),
+                data: multicallPayloadData,
+                gasLimit: gasEstimate.toString(),
+                maxFeePerGas: (execute.maxFeePerGas || BigInt(1e10)).toString(),
+                maxPriorityFeePerGas: (execute.maxPriorityFeePerGas || BigInt(0)).toString(),
+                nonce: nonce.toString(),
+                deadline: (execute.deadline || BigInt(9999999999)).toString(),
+            }, null, 2));
+            let tokenAddress = (_1 = (_0 = execute.funds) === null || _0 === void 0 ? void 0 : _0.token) === null || _1 === void 0 ? void 0 : _1.address;
+            if (((_3 = (_2 = execute.funds) === null || _2 === void 0 ? void 0 : _2.token) === null || _3 === void 0 ? void 0 : _3.address) ===
+                '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
+                tokenAddress = viem_1.zeroAddress;
+            }
+            const encodedPayload = (0, signing_1.encodeUniversalPayload)(universalPayload);
+            (0, context_1.printLog)(ctx, 'sendFunds — encodedPayload (first 66 chars): ' + encodedPayload.slice(0, 66) + ' (full length: ' + encodedPayload.length + ')');
+            const req = buildUniversalTxRequest(ctx.universalSigner.account.address, {
+                recipient: viem_1.zeroAddress,
+                token: tokenAddress,
+                amount: (_4 = execute.funds) === null || _4 === void 0 ? void 0 : _4.amount,
+                payload: encodedPayload,
+            });
+            (0, context_1.printLog)(ctx, 'sendFunds — final req: ' + JSON.stringify({
+                recipient: viem_1.zeroAddress,
+                token: tokenAddress,
+                amount: (_6 = (_5 = execute.funds) === null || _5 === void 0 ? void 0 : _5.amount) === null || _6 === void 0 ? void 0 : _6.toString(),
+                payloadLength: encodedPayload.length,
+            }, null, 2));
+            return { payload: universalPayload, gasAmount, req };
+        }
+    });
+}
+//# sourceMappingURL=payload-builder.js.map