@pushchain/core 5.1.5-alpha.1 → 5.1.5

package/src/lib/universal-tx-detector/auto-detect.d.ts

@@ -0,0 +1,37 @@
+import { CHAIN } from '../constants/enums';
+import type { DetectUniversalTxOptions, UniversalTxDetection } from './types';
+/**
+ * Every chain registered in CHAIN_INFO whose vm the detector supports
+ * (EVM + SVM), ordered Push-first.
+ */
+export declare function listAutoProbeChains(): CHAIN[];
+export interface DetectUniversalTxAutoOptions extends Omit<DetectUniversalTxOptions, 'rpcUrls'> {
+    /** Per-chain RPC overrides. Falls back to CHAIN_INFO defaults. */
+    rpcUrls?: Partial<Record<CHAIN, string[]>>;
+    /**
+     * Override the set of chains to probe. Defaults to every EVM chain in
+     * CHAIN_INFO with Push Chain first.
+     */
+    chains?: CHAIN[];
+    /**
+     * When true, continue probing all chains even after the first match and
+     * return every non-UNKNOWN detection. Default false (return first match).
+     */
+    exhaustive?: boolean;
+}
+export interface AutoDetectionResult {
+    /** The chosen detection — the first non-UNKNOWN result. `undefined` if no chain had a universal-tx event. */
+    detection?: UniversalTxDetection;
+    /** Every chain that was probed, whether or not it matched. */
+    attempts: Array<{
+        chain: CHAIN;
+        matched: boolean;
+        kind: UniversalTxDetection['kind'];
+        error?: string;
+    }>;
+}
+/**
+ * Probe every supported chain in parallel and return the first detection
+ * with a recognized universal-tx kind.
+ */
+export declare function detectUniversalTxAuto(txHash: `0x${string}`, opts?: DetectUniversalTxAutoOptions): Promise<AutoDetectionResult>;

package/src/lib/universal-tx-detector/auto-detect.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAutoProbeChains = listAutoProbeChains;
+exports.detectUniversalTxAuto = detectUniversalTxAuto;
+const tslib_1 = require("tslib");
+/**
+ * Stage 4a — chain auto-detection.
+ *
+ * When a user pastes a tx hash without knowing which chain it lives on,
+ * probe every registered EVM chain in parallel, classify the first one that
+ * contains a universal-tx event, and return the detection.
+ *
+ * Probe order:
+ *   1. Push Chain CAIPs (most common case for "PC Execution" hashes)
+ *   2. All other EVM chains from CHAIN_INFO, in parallel
+ *
+ * The function resolves as soon as a non-UNKNOWN detection is found. Other
+ * pending probes are abandoned via an AbortController-style race.
+ */
+const chain_1 = require("../constants/chain");
+const enums_1 = require("../constants/enums");
+const detector_1 = require("./detector");
+const PUSH_CHAIN_CAIPS = [
+    enums_1.CHAIN.PUSH_TESTNET_DONUT,
+    enums_1.CHAIN.PUSH_MAINNET,
+    enums_1.CHAIN.PUSH_LOCALNET,
+];
+/**
+ * Every chain registered in CHAIN_INFO whose vm the detector supports
+ * (EVM + SVM), ordered Push-first.
+ */
+function listAutoProbeChains() {
+    const supported = Object.keys(chain_1.CHAIN_INFO).filter((c) => {
+        var _a;
+        const vm = (_a = chain_1.CHAIN_INFO[c]) === null || _a === void 0 ? void 0 : _a.vm;
+        return vm === enums_1.VM.EVM || vm === enums_1.VM.SVM;
+    });
+    const push = [];
+    const rest = [];
+    for (const c of supported) {
+        if (PUSH_CHAIN_CAIPS.includes(c))
+            push.push(c);
+        else
+            rest.push(c);
+    }
+    return [...push, ...rest];
+}
+/**
+ * Probe every supported chain in parallel and return the first detection
+ * with a recognized universal-tx kind.
+ */
+function detectUniversalTxAuto(txHash_1) {
+    return tslib_1.__awaiter(this, arguments, void 0, function* (txHash, opts = {}) {
+        var _a, _b;
+        const chains = (_a = opts.chains) !== null && _a !== void 0 ? _a : listAutoProbeChains();
+        const exhaustive = (_b = opts.exhaustive) !== null && _b !== void 0 ? _b : false;
+        const attempts = [];
+        // Race probes. When a non-UNKNOWN detection lands, resolve early (unless
+        // `exhaustive` is set).
+        const seen = [];
+        yield new Promise((resolve) => {
+            let remaining = chains.length;
+            let resolved = false;
+            const finish = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                resolve();
+            };
+            if (chains.length === 0)
+                return finish();
+            for (const chain of chains) {
+                (0, detector_1.detectUniversalTx)(txHash, chain, {
+                    pushClient: opts.pushClient,
+                    rpcUrls: opts.rpcUrls,
+                    pushNetwork: opts.pushNetwork,
+                    skipPushChainLookup: opts.skipPushChainLookup,
+                })
+                    .then((d) => {
+                    const matched = d.kind !== 'UNKNOWN';
+                    attempts.push({ chain, matched, kind: d.kind });
+                    if (matched)
+                        seen.push(d);
+                    if (matched && !exhaustive)
+                        finish();
+                })
+                    .catch((err) => {
+                    attempts.push({
+                        chain,
+                        matched: false,
+                        kind: 'UNKNOWN',
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                })
+                    .finally(() => {
+                    remaining -= 1;
+                    if (remaining === 0)
+                        finish();
+                });
+            }
+        });
+        // Sort attempts so matched chains come first for deterministic caller UX.
+        attempts.sort((a, b) => (a.matched === b.matched ? 0 : a.matched ? -1 : 1));
+        // Prefer the first chain from the probe list that matched — preserves
+        // Push-first order when exhaustive=true.
+        const winner = chains
+            .map((c) => seen.find((d) => d.chain === c))
+            .find((d) => d !== undefined);
+        return { detection: winner, attempts };
+    });
+}
+//# sourceMappingURL=auto-detect.js.map

package/src/lib/universal-tx-detector/cascade.d.ts

@@ -0,0 +1,64 @@
+import { CHAIN, PUSH_NETWORK } from '../constants/enums';
+import type { PushClient } from '../push-client/push-client';
+import { type ChildInboundResolution } from './child-inbounds';
+import type { PushChainOutboundSummary, UniversalTxDetection } from './types';
+export interface PcRefundSummary {
+    /** Refund tx on Push Chain. */
+    txHash: string;
+    sender: string;
+    gasUsed: number;
+    blockHeight: number;
+    status: string;
+    errorMsg: string;
+    /** subTxId of the parent outbound — useful for UI correlation. */
+    parentOutboundId: string;
+}
+export interface CascadeEdge {
+    edgeKind: 'outbound' | 'child-inbound' | 'pc-refund';
+    /**
+     * Summary of the relationship.
+     *   - `outbound`       → PushChainOutboundSummary (cosmos outbound tuple)
+     *   - `child-inbound`  → ChildInboundResolution (destination → Push follow-up)
+     *   - `pc-refund`      → PcRefundSummary (gas-refund tx on Push)
+     */
+    relation: PushChainOutboundSummary | ChildInboundResolution | PcRefundSummary;
+    /**
+     * Expanded child node, or null when the target chain isn't supported /
+     * depth is exhausted / an RPC lookup failed.
+     */
+    node: CascadeNode | null;
+}
+export interface CascadeNode {
+    detection: UniversalTxDetection;
+    children: CascadeEdge[];
+    /** Depth from the starting node (0 = root). */
+    depth: number;
+    /** Set when we stopped expanding because of maxDepth or a cycle. */
+    truncated?: 'maxDepth' | 'cycle';
+}
+export interface TraceCascadeOptions {
+    /** Required — cosmos queries drive the cascade. */
+    pushClient: PushClient;
+    /** Default 4. Depth 0 is the root. */
+    maxDepth?: number;
+    /** Per-chain RPC overrides. Falls back to CHAIN_INFO defaultRPC. */
+    rpcUrls?: Partial<Record<CHAIN, string[]>>;
+    /**
+     * Which Push Chain CAIP to recurse into when walking child-inbounds.
+     * Defaults to CHAIN.PUSH_TESTNET_DONUT.
+     */
+    pushChain?: CHAIN;
+    /**
+     * Called with each node as it is resolved. Useful for progressive UI.
+     */
+    onNode?: (node: CascadeNode) => void;
+}
+/**
+ * Walk the universal-tx graph starting from `(startHash, startChain)` and
+ * return the full cascade tree.
+ */
+export declare function traceUniversalTxCascade(startHash: `0x${string}`, startChain: CHAIN, opts: TraceCascadeOptions): Promise<CascadeNode>;
+/** Flatten a cascade tree into depth-first linear node list (root first). */
+export declare function flattenCascade(root: CascadeNode): CascadeNode[];
+export type { PublicClient } from 'viem';
+export { PUSH_NETWORK };

package/src/lib/universal-tx-detector/cascade.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUSH_NETWORK = void 0;
+exports.traceUniversalTxCascade = traceUniversalTxCascade;
+exports.flattenCascade = flattenCascade;
+const tslib_1 = require("tslib");
+/**
+ * Stage 3 — recursive cascade walker.
+ *
+ * Starting from any universal-tx hash on a supported chain, walk forward
+ * across the universal-tx graph and return a tree:
+ *
+ *   Push root  ──outbound──▶  Destination finalize  ──child-inbound──▶  Follow-up Push tx  ─...
+ *
+ * Uses the chain-module key formulas (sha256-based; see
+ * push-chain/x/uexecutor/types/keys.go) to resolve:
+ *   - Push-initiated outbounds → destination external txs (via pcTx utx record)
+ *   - Destination CEA-originated inbounds → child Push txs (via inbound utx record)
+ *
+ * Cycle-safe via a `visited` set on (chain, txHash). Bounded by maxDepth.
+ */
+const viem_1 = require("viem");
+const chain_1 = require("../constants/chain");
+const enums_1 = require("../constants/enums");
+Object.defineProperty(exports, "PUSH_NETWORK", { enumerable: true, get: function () { return enums_1.PUSH_NETWORK; } });
+const child_inbounds_1 = require("./child-inbounds");
+const detector_1 = require("./detector");
+const PUSH_CHAIN_CAIPS = new Set([
+    enums_1.CHAIN.PUSH_MAINNET,
+    enums_1.CHAIN.PUSH_TESTNET_DONUT,
+    enums_1.CHAIN.PUSH_LOCALNET,
+]);
+/**
+ * Walk the universal-tx graph starting from `(startHash, startChain)` and
+ * return the full cascade tree.
+ */
+function traceUniversalTxCascade(startHash, startChain, opts) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const state = {
+            visited: new Set(),
+            pushChain: (_a = opts.pushChain) !== null && _a !== void 0 ? _a : enums_1.CHAIN.PUSH_TESTNET_DONUT,
+            maxDepth: (_b = opts.maxDepth) !== null && _b !== void 0 ? _b : 4,
+            notes: [],
+        };
+        const root = yield walk(startHash, startChain, 0, state, opts);
+        if (!root) {
+            // Should never happen for depth=0; return an empty detection node so the
+            // caller has something to render.
+            return {
+                detection: {
+                    txHash: startHash,
+                    chain: startChain,
+                    kind: 'UNKNOWN',
+                    emitters: [],
+                    decoded: {},
+                    matchingLogs: [],
+                    detections: [],
+                    notes: ['cascade: unable to fetch root'],
+                },
+                children: [],
+                depth: 0,
+            };
+        }
+        return root;
+    });
+}
+// ── Core recursion ────────────────────────────────────────────────────
+function walk(txHash, chain, depth, state, opts, knownUtxId) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const key = `${chain}::${txHash.toLowerCase()}`;
+        if (state.visited.has(key)) {
+            // Return a stub node representing the cycle — callers can detect via
+            // `truncated === 'cycle'`.
+            return null;
+        }
+        state.visited.add(key);
+        const chainInfo = chain_1.CHAIN_INFO[chain];
+        if (!chainInfo)
+            return null;
+        if (chainInfo.vm !== enums_1.VM.EVM && chainInfo.vm !== enums_1.VM.SVM)
+            return null;
+        const detection = yield (0, detector_1.detectUniversalTx)(txHash, chain, {
+            pushClient: opts.pushClient,
+            rpcUrls: opts.rpcUrls,
+            // We run our own cosmos queries below to build the cascade; skip the
+            // detector's built-in single-record lookup to avoid redundant traffic.
+            skipPushChainLookup: true,
+        });
+        const node = { detection, children: [], depth };
+        (_a = opts.onNode) === null || _a === void 0 ? void 0 : _a.call(opts, node);
+        if (depth >= state.maxDepth) {
+            node.truncated = 'maxDepth';
+            return node;
+        }
+        if (PUSH_CHAIN_CAIPS.has(chain)) {
+            // Push Chain node — walk outbounds from the pc utx record.
+            yield expandPushOutbounds(node, txHash, chain, state, opts, knownUtxId);
+        }
+        else {
+            // External chain — walk child inbounds (CEA-originated UniversalTx logs).
+            yield expandExternalChildInbounds(node, detection, state, opts);
+        }
+        return node;
+    });
+}
+function expandPushOutbounds(node, txHash, chain, state, opts, knownUtxId) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        // Prefer the caller-supplied utx id — this covers follow-up Push txs that
+        // were triggered by an external CEA inbound (their outbounds live under
+        // `sha256(externalCaip:externalHash:logIndex)`, not the PC-derived key).
+        // For root Push txs the caller omits it and we derive the PC key.
+        const pcUtxId = knownUtxId !== null && knownUtxId !== void 0 ? knownUtxId : (0, child_inbounds_1.derivePcUniversalTxId)(chain, txHash);
+        try {
+            const resp = yield opts.pushClient.getUniversalTxByIdV2(pcUtxId.slice(2));
+            const utx = resp === null || resp === void 0 ? void 0 : resp.universalTx;
+            if (!utx || !utx.outboundTx || utx.outboundTx.length === 0)
+                return;
+            for (const ob of utx.outboundTx) {
+                const destChainStr = (_a = ob.destinationChain) !== null && _a !== void 0 ? _a : '';
+                const externalTxHash = ((_b = ob.observedTx) === null || _b === void 0 ? void 0 : _b.txHash) || '';
+                const summary = {
+                    subTxId: (_c = ob.id) !== null && _c !== void 0 ? _c : '',
+                    status: outboundStatusName(ob.outboundStatus),
+                    destinationChain: destChainStr,
+                    externalTxHash: externalTxHash || undefined,
+                    amount: ob.amount,
+                    recipient: ob.recipient,
+                };
+                if (!externalTxHash || !isSupportedChainCaip(destChainStr)) {
+                    node.children.push({
+                        edgeKind: 'outbound',
+                        relation: summary,
+                        node: null,
+                    });
+                }
+                else {
+                    const childNode = yield walk(externalTxHash, destChainStr, node.depth + 1, state, opts);
+                    node.children.push({
+                        edgeKind: 'outbound',
+                        relation: summary,
+                        node: childNode,
+                    });
+                }
+                // Refund edges: the chain records two refund-tx fields on each outbound.
+                //   - pcRefundExecution (field 18) — gas refund tx after a successful
+                //     outbound (push-chain/x/uexecutor/keeper/outbound.go).
+                //   - pcRevertExecution — revert/refund tx when the outbound reverted.
+                // Surface both as pc-refund edges and recurse into the refund tx on
+                // Push Chain.
+                const refundTxs = [];
+                if (ob.pcRefundExecution)
+                    refundTxs.push(ob.pcRefundExecution);
+                if (ob.pcRevertExecution)
+                    refundTxs.push(ob.pcRevertExecution);
+                for (const refund of refundTxs) {
+                    if (!refund.txHash)
+                        continue;
+                    const refundSummary = {
+                        txHash: refund.txHash,
+                        sender: (_d = refund.sender) !== null && _d !== void 0 ? _d : '',
+                        gasUsed: typeof refund.gasUsed === 'bigint'
+                            ? Number(refund.gasUsed)
+                            : (_e = refund.gasUsed) !== null && _e !== void 0 ? _e : 0,
+                        blockHeight: typeof refund.blockHeight === 'bigint'
+                            ? Number(refund.blockHeight)
+                            : (_f = refund.blockHeight) !== null && _f !== void 0 ? _f : 0,
+                        status: (_g = refund.status) !== null && _g !== void 0 ? _g : '',
+                        errorMsg: (_h = refund.errorMsg) !== null && _h !== void 0 ? _h : '',
+                        parentOutboundId: (_j = ob.id) !== null && _j !== void 0 ? _j : '',
+                    };
+                    const refundNode = yield walk(refund.txHash, chain, node.depth + 1, state, opts);
+                    node.children.push({
+                        edgeKind: 'pc-refund',
+                        relation: refundSummary,
+                        node: refundNode,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            node.detection.notes.push(`cascade: pc outbound lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+}
+function expandExternalChildInbounds(node, detection, state, opts) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const resolutions = yield (0, child_inbounds_1.resolveChildInboundsFromDetection)(opts.pushClient, detection, node.detection.notes);
+        for (const res of resolutions) {
+            // Walk each Push follow-up tx produced by this inbound.
+            if (res.pcTxHashes.length === 0) {
+                node.children.push({
+                    edgeKind: 'child-inbound',
+                    relation: res,
+                    node: null,
+                });
+                continue;
+            }
+            for (const pcHash of res.pcTxHashes) {
+                const childNode = yield walk(pcHash, state.pushChain, node.depth + 1, state, opts, res.universalTxId);
+                node.children.push({
+                    edgeKind: 'child-inbound',
+                    relation: res,
+                    node: childNode,
+                });
+            }
+        }
+    });
+}
+// ── Utilities ─────────────────────────────────────────────────────────
+function isSupportedChainCaip(caip) {
+    if (!caip)
+        return false;
+    const info = chain_1.CHAIN_INFO[caip];
+    if (!info)
+        return false;
+    return info.vm === enums_1.VM.EVM || info.vm === enums_1.VM.SVM;
+}
+function outboundStatusName(n) {
+    switch (n) {
+        case 0:
+            return 'OUTBOUND_STATUS_UNSPECIFIED';
+        case 1:
+            return 'PENDING';
+        case 2:
+            return 'OBSERVED';
+        case 3:
+            return 'REVERTED';
+        default:
+            return `UNKNOWN(${n !== null && n !== void 0 ? n : '?'})`;
+    }
+}
+/** Flatten a cascade tree into depth-first linear node list (root first). */
+function flattenCascade(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const n = stack.pop();
+        out.push(n);
+        for (let i = n.children.length - 1; i >= 0; i--) {
+            const c = n.children[i].node;
+            if (c)
+                stack.push(c);
+        }
+    }
+    return out;
+}
+// silence unused-import warning for viem helpers not yet referenced
+void viem_1.createPublicClient;
+void viem_1.fallback;
+void viem_1.http;
+//# sourceMappingURL=cascade.js.map

package/src/lib/universal-tx-detector/child-inbounds.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Stage 2 — resolve child universal-txs spawned by the inbound legs of a
+ * destination-chain transaction.
+ *
+ * The chain derives a universalTxId per inbound log as:
+ *   utxId = sha256(`<sourceChainCaip>:<txHash>:<logIndex>`)
+ * See push-chain/x/uexecutor/types/keys.go:49-53 (GetInboundUniversalTxKey).
+ *
+ * For Push-initiated outbounds (pcTx entries) the formula drops the log index:
+ *   utxId = sha256(`<pcChainCaip>:<pcTxHash>`)
+ * See push-chain/x/uexecutor/types/keys.go:63-67 (GetPcUniversalTxKey).
+ *
+ * This module derives those ids deterministically and queries cosmos via
+ * `pushClient.getUniversalTxByIdV2`, no event-attribute predicate needed.
+ */
+import { toHex } from 'viem';
+import type { PushClient } from '../push-client/push-client';
+import type { MatchingLog, PushChainOutboundSummary, UniversalTxDetection } from './types';
+export interface ChildInboundResolution {
+    /** Deterministically derived universalTxId for this inbound log. */
+    universalTxId: `0x${string}`;
+    /** Log that triggered the child inbound. */
+    sourceLogIndex: number;
+    sourceEventName: string;
+    status: number;
+    statusName: string;
+    /** Push Chain tx hashes that ran the child inbound payload. */
+    pcTxHashes: string[];
+    /** Any grandchild outbounds spawned from the child inbound. */
+    outboundHashes: PushChainOutboundSummary[];
+    /** Cosmos has no record for this id (not yet observed / relayer-voted). */
+    notFound?: boolean;
+}
+/**
+ * Deterministic child universalTxId for an inbound event on an external chain.
+ * Mirrors `GetInboundUniversalTxKey` from the chain module.
+ */
+export declare function deriveChildUniversalTxId(sourceChainCaip: string, externalTxHash: string, logIndex: number | string): `0x${string}`;
+/**
+ * Deterministic universalTxId for a Push-Chain-initiated tx (no log index).
+ * Mirrors `GetPcUniversalTxKey` from the chain module.
+ */
+export declare function derivePcUniversalTxId(pushChainCaip: string, pushTxHash: string): `0x${string}`;
+/**
+ * Given a destination-chain detection, resolve each inbound-log leg by
+ * computing its deterministic universalTxId and querying cosmos.
+ *
+ * Returns one entry per inbound log present in the receipt.
+ */
+export declare function resolveChildInboundsFromDetection(pushClient: PushClient, detection: UniversalTxDetection, diagnostics?: string[]): Promise<ChildInboundResolution[]>;
+/**
+ * Lower-level variant — resolve children from an explicit list of inbound
+ * logs (each with a logIndex).
+ */
+export declare function resolveChildInboundsFromLogs(pushClient: PushClient, sourceChainCaip: string, externalTxHash: string, inboundLogs: Pick<MatchingLog, 'eventName' | 'logIndex'>[], diagnostics?: string[]): Promise<ChildInboundResolution[]>;
+export declare const __internal: {
+    toHex: typeof toHex;
+};

package/src/lib/universal-tx-detector/child-inbounds.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__internal = void 0;
+exports.deriveChildUniversalTxId = deriveChildUniversalTxId;
+exports.derivePcUniversalTxId = derivePcUniversalTxId;
+exports.resolveChildInboundsFromDetection = resolveChildInboundsFromDetection;
+exports.resolveChildInboundsFromLogs = resolveChildInboundsFromLogs;
+const tslib_1 = require("tslib");
+/**
+ * Stage 2 — resolve child universal-txs spawned by the inbound legs of a
+ * destination-chain transaction.
+ *
+ * The chain derives a universalTxId per inbound log as:
+ *   utxId = sha256(`<sourceChainCaip>:<txHash>:<logIndex>`)
+ * See push-chain/x/uexecutor/types/keys.go:49-53 (GetInboundUniversalTxKey).
+ *
+ * For Push-initiated outbounds (pcTx entries) the formula drops the log index:
+ *   utxId = sha256(`<pcChainCaip>:<pcTxHash>`)
+ * See push-chain/x/uexecutor/types/keys.go:63-67 (GetPcUniversalTxKey).
+ *
+ * This module derives those ids deterministically and queries cosmos via
+ * `pushClient.getUniversalTxByIdV2`, no event-attribute predicate needed.
+ */
+const viem_1 = require("viem");
+const STATUS_NAMES = {
+    0: 'UNIVERSAL_TX_STATUS_UNSPECIFIED',
+    1: 'INBOUND_SUCCESS',
+    2: 'PENDING_INBOUND_EXECUTION',
+    3: 'PC_EXECUTED_SUCCESS',
+    4: 'PC_EXECUTED_FAILED',
+    5: 'PC_PENDING_REVERT',
+    6: 'OUTBOUND_PENDING',
+    7: 'OUTBOUND_SUCCESS',
+    8: 'OUTBOUND_FAILED',
+    9: 'CANCELED',
+};
+const OUTBOUND_STATUS_NAMES = {
+    0: 'OUTBOUND_STATUS_UNSPECIFIED',
+    1: 'PENDING',
+    2: 'OBSERVED',
+    3: 'REVERTED',
+};
+const INBOUND_EVENT_NAMES = new Set([
+    'UniversalTx',
+    'RevertUniversalTx',
+]);
+/**
+ * Deterministic child universalTxId for an inbound event on an external chain.
+ * Mirrors `GetInboundUniversalTxKey` from the chain module.
+ */
+function deriveChildUniversalTxId(sourceChainCaip, externalTxHash, logIndex) {
+    const normHash = externalTxHash.startsWith('0x')
+        ? externalTxHash
+        : `0x${externalTxHash}`;
+    const input = `${sourceChainCaip}:${normHash}:${logIndex}`;
+    return (0, viem_1.sha256)((0, viem_1.toBytes)(input));
+}
+/**
+ * Deterministic universalTxId for a Push-Chain-initiated tx (no log index).
+ * Mirrors `GetPcUniversalTxKey` from the chain module.
+ */
+function derivePcUniversalTxId(pushChainCaip, pushTxHash) {
+    const normHash = pushTxHash.startsWith('0x') ? pushTxHash : `0x${pushTxHash}`;
+    const input = `${pushChainCaip}:${normHash}`;
+    return (0, viem_1.sha256)((0, viem_1.toBytes)(input));
+}
+/**
+ * Given a destination-chain detection, resolve each inbound-log leg by
+ * computing its deterministic universalTxId and querying cosmos.
+ *
+ * Returns one entry per inbound log present in the receipt.
+ */
+function resolveChildInboundsFromDetection(pushClient, detection, diagnostics) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const inboundLogs = detection.detections
+            .filter((d) => INBOUND_EVENT_NAMES.has(d.log.eventName))
+            .map((d) => d.log);
+        return resolveChildInboundsFromLogs(pushClient, detection.chain, detection.txHash, inboundLogs, diagnostics);
+    });
+}
+/**
+ * Lower-level variant — resolve children from an explicit list of inbound
+ * logs (each with a logIndex).
+ */
+function resolveChildInboundsFromLogs(pushClient, sourceChainCaip, externalTxHash, inboundLogs, diagnostics) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const out = [];
+        for (const log of inboundLogs) {
+            if (log.logIndex < 0) {
+                diagnostics === null || diagnostics === void 0 ? void 0 : diagnostics.push(`skipped log with negative logIndex (eventName=${log.eventName})`);
+                continue;
+            }
+            const utxIdHex = deriveChildUniversalTxId(sourceChainCaip, externalTxHash, log.logIndex);
+            try {
+                const resp = yield pushClient.getUniversalTxByIdV2(utxIdHex.slice(2));
+                const utx = resp === null || resp === void 0 ? void 0 : resp.universalTx;
+                if (!utx || !utx.id) {
+                    out.push({
+                        universalTxId: utxIdHex,
+                        sourceLogIndex: log.logIndex,
+                        sourceEventName: log.eventName,
+                        status: 0,
+                        statusName: STATUS_NAMES[0],
+                        pcTxHashes: [],
+                        outboundHashes: [],
+                        notFound: true,
+                    });
+                    continue;
+                }
+                const status = ((_a = utx.universalStatus) !== null && _a !== void 0 ? _a : 0);
+                const pcTxHashes = ((_b = utx.pcTx) !== null && _b !== void 0 ? _b : [])
+                    .map((p) => p === null || p === void 0 ? void 0 : p.txHash)
+                    .filter((h) => Boolean(h));
+                const outboundHashes = ((_c = utx.outboundTx) !== null && _c !== void 0 ? _c : []).map((ob) => {
+                    var _a, _b, _c, _d;
+                    return ({
+                        subTxId: (_a = ob.id) !== null && _a !== void 0 ? _a : '',
+                        status: (_b = OUTBOUND_STATUS_NAMES[ob.outboundStatus]) !== null && _b !== void 0 ? _b : `UNKNOWN(${ob.outboundStatus})`,
+                        destinationChain: (_c = ob.destinationChain) !== null && _c !== void 0 ? _c : '',
+                        externalTxHash: ((_d = ob.observedTx) === null || _d === void 0 ? void 0 : _d.txHash) || undefined,
+                        amount: ob.amount,
+                        recipient: ob.recipient,
+                    });
+                });
+                out.push({
+                    universalTxId: utxIdHex,
+                    sourceLogIndex: log.logIndex,
+                    sourceEventName: log.eventName,
+                    status,
+                    statusName: (_d = STATUS_NAMES[status]) !== null && _d !== void 0 ? _d : `UNKNOWN(${status})`,
+                    pcTxHashes,
+                    outboundHashes,
+                });
+            }
+            catch (err) {
+                diagnostics === null || diagnostics === void 0 ? void 0 : diagnostics.push(`getUniversalTxByIdV2(${utxIdHex}) failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return out;
+    });
+}
+// Debug-only re-export (avoid importing into production paths).
+exports.__internal = { toHex: viem_1.toHex };
+//# sourceMappingURL=child-inbounds.js.map