@pushchain/core 6.0.20 → 6.0.21

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listAutoProbeChains = listAutoProbeChains;
 exports.detectUniversalTxAuto = detectUniversalTxAuto;
-const tslib_1 = require("tslib");
 /**
  * Stage 4a — chain auto-detection.
  *
@@ -31,8 +30,7 @@ const PUSH_CHAIN_CAIPS = [
  */
 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;
+        const vm = chain_1.CHAIN_INFO[c]?.vm;
         return vm === enums_1.VM.EVM || vm === enums_1.VM.SVM;
     });
     const push = [];
@@ -49,64 +47,61 @@ function listAutoProbeChains() {
  * 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();
+async function detectUniversalTxAuto(txHash, opts = {}) {
+    const chains = opts.chains ?? listAutoProbeChains();
+    const exhaustive = opts.exhaustive ?? false;
+    const attempts = [];
+    // Race probes. When a non-UNKNOWN detection lands, resolve early (unless
+    // `exhaustive` is set).
+    const seen = [];
+    await 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),
                 });
-            }
-        });
-        // 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 };
+            })
+                .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.js

@@ -3,7 +3,6 @@ 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.
  *
@@ -35,189 +34,178 @@ const PUSH_CHAIN_CAIPS = new Set([
  * 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. No outbound summaries → nothing to
-            // normalize, but we still pass through `normalizeCascadeNodeForUser`
-            // for symmetry with the happy path below.
-            return (0, normalize_1.normalizeCascadeNodeForUser)({
-                detection: {
-                    txHash: startHash,
-                    chain: startChain,
-                    kind: 'UNKNOWN',
-                    emitters: [],
-                    decoded: {},
-                    matchingLogs: [],
-                    detections: [],
-                    notes: ['cascade: unable to fetch root'],
-                },
-                children: [],
-                depth: 0,
-            });
-        }
-        // User-facing normalization pass — recursively rewrites every
-        // `PushChainOutboundSummary.externalTxHash` in the tree to base58 for SVM
-        // destinations. Each internal `detectUniversalTx` call (in `walk`) already
-        // produced a normalized detection; this final pass also normalizes the
-        // edge-level `relation` summaries inside `expandPushOutbounds` /
-        // `expandExternalChildInbounds` which build summaries DIRECTLY (without
-        // going through `detectUniversalTx`).
-        return (0, normalize_1.normalizeCascadeNodeForUser)(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,
+async function traceUniversalTxCascade(startHash, startChain, opts) {
+    const state = {
+        visited: new Set(),
+        pushChain: opts.pushChain ?? enums_1.CHAIN.PUSH_TESTNET_DONUT,
+        maxDepth: opts.maxDepth ?? 4,
+        notes: [],
+    };
+    const root = await 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. No outbound summaries → nothing to
+        // normalize, but we still pass through `normalizeCascadeNodeForUser`
+        // for symmetry with the happy path below.
+        return (0, normalize_1.normalizeCascadeNodeForUser)({
+            detection: {
+                txHash: startHash,
+                chain: startChain,
+                kind: 'UNKNOWN',
+                emitters: [],
+                decoded: {},
+                matchingLogs: [],
+                detections: [],
+                notes: ['cascade: unable to fetch root'],
+            },
+            children: [],
+            depth: 0,
         });
-        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;
-    });
+    }
+    // User-facing normalization pass — recursively rewrites every
+    // `PushChainOutboundSummary.externalTxHash` in the tree to base58 for SVM
+    // destinations. Each internal `detectUniversalTx` call (in `walk`) already
+    // produced a normalized detection; this final pass also normalizes the
+    // edge-level `relation` summaries inside `expandPushOutbounds` /
+    // `expandExternalChildInbounds` which build summaries DIRECTLY (without
+    // going through `detectUniversalTx`).
+    return (0, normalize_1.normalizeCascadeNodeForUser)(root);
 }
-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)}`);
-        }
+// ── Core recursion ────────────────────────────────────────────────────
+async function walk(txHash, chain, depth, state, opts, knownUtxId) {
+    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 = await (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 };
+    opts.onNode?.(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.
+        await expandPushOutbounds(node, txHash, chain, state, opts, knownUtxId);
+    }
+    else {
+        // External chain — walk child inbounds (CEA-originated UniversalTx logs).
+        await expandExternalChildInbounds(node, detection, state, opts);
+    }
+    return node;
 }
-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) {
+async function expandPushOutbounds(node, txHash, chain, state, opts, knownUtxId) {
+    // 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 ?? (0, child_inbounds_1.derivePcUniversalTxId)(chain, txHash);
+    try {
+        const resp = await opts.pushClient.getUniversalTxByIdV2(pcUtxId.slice(2));
+        const utx = resp?.universalTx;
+        if (!utx || !utx.outboundTx || utx.outboundTx.length === 0)
+            return;
+        for (const ob of utx.outboundTx) {
+            const destChainStr = ob.destinationChain ?? '';
+            const externalTxHash = ob.observedTx?.txHash || '';
+            const summary = {
+                subTxId: ob.id ?? '',
+                status: outboundStatusName(ob.outboundStatus),
+                destinationChain: destChainStr,
+                externalTxHash: externalTxHash || undefined,
+                amount: ob.amount,
+                recipient: ob.recipient,
+            };
+            if (!externalTxHash || !isSupportedChainCaip(destChainStr)) {
                 node.children.push({
-                    edgeKind: 'child-inbound',
-                    relation: res,
+                    edgeKind: 'outbound',
+                    relation: summary,
                     node: null,
                 });
-                continue;
             }
-            for (const pcHash of res.pcTxHashes) {
-                const childNode = yield walk(pcHash, state.pushChain, node.depth + 1, state, opts, res.universalTxId);
+            else {
+                const childNode = await walk(externalTxHash, destChainStr, node.depth + 1, state, opts);
                 node.children.push({
-                    edgeKind: 'child-inbound',
-                    relation: res,
+                    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: refund.sender ?? '',
+                    gasUsed: typeof refund.gasUsed === 'bigint'
+                        ? Number(refund.gasUsed)
+                        : refund.gasUsed ?? 0,
+                    blockHeight: typeof refund.blockHeight === 'bigint'
+                        ? Number(refund.blockHeight)
+                        : refund.blockHeight ?? 0,
+                    status: refund.status ?? '',
+                    errorMsg: refund.errorMsg ?? '',
+                    parentOutboundId: ob.id ?? '',
+                };
+                const refundNode = await 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)}`);
+    }
+}
+async function expandExternalChildInbounds(node, detection, state, opts) {
+    const resolutions = await (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 = await 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) {
@@ -239,7 +227,7 @@ function outboundStatusName(n) {
         case 3:
             return 'REVERTED';
         default:
-            return `UNKNOWN(${n !== null && n !== void 0 ? n : '?'})`;
+            return `UNKNOWN(${n ?? '?'})`;
     }
 }
 /** Flatten a cascade tree into depth-first linear node list (root first). */