@pushchain/core 6.0.20 → 6.0.21

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

@@ -5,7 +5,6 @@ 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.
@@ -86,83 +85,35 @@ function derivePcUniversalTxId(pushChainCaip, pushTxHash) {
  *
  * 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);
-        const resolutions = yield resolveChildInboundsFromLogs(pushClient, detection.chain, detection.txHash, inboundLogs, diagnostics);
-        // User-facing normalization pass: rewrites nested
-        // `outboundHashes[n].externalTxHash` to base58 for SVM destinations.
-        // `pcTxHashes` is Push Chain (EVM) and stays hex by chain type. The lower-
-        // level `resolveChildInboundsFromLogs` is left producing raw hex so
-        // internal callers (`findChildUtxIdFromExternalTx` via the detector path)
-        // that go through it directly still see the canonical form.
-        return resolutions.map(normalize_1.normalizeChildInboundResolutionForUser);
-    });
+async function resolveChildInboundsFromDetection(pushClient, detection, diagnostics) {
+    const inboundLogs = detection.detections
+        .filter((d) => INBOUND_EVENT_NAMES.has(d.log.eventName))
+        .map((d) => d.log);
+    const resolutions = await resolveChildInboundsFromLogs(pushClient, detection.chain, detection.txHash, inboundLogs, diagnostics);
+    // User-facing normalization pass: rewrites nested
+    // `outboundHashes[n].externalTxHash` to base58 for SVM destinations.
+    // `pcTxHashes` is Push Chain (EVM) and stays hex by chain type. The lower-
+    // level `resolveChildInboundsFromLogs` is left producing raw hex so
+    // internal callers (`findChildUtxIdFromExternalTx` via the detector path)
+    // that go through it directly still see the canonical form.
+    return resolutions.map(normalize_1.normalizeChildInboundResolutionForUser);
 }
 /**
  * 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)}`);
-                // Cosmos lookup failed (commonly NotFound while the indexer is still
-                // catching up). The utxId is deterministically derived from the source
-                // log, so surface it as notFound rather than dropping the entry —
-                // otherwise callers like inbound-tracker repeatedly re-run the full
-                // detector pass instead of advancing to lightweight status polling.
+async function resolveChildInboundsFromLogs(pushClient, sourceChainCaip, externalTxHash, inboundLogs, diagnostics) {
+    const out = [];
+    for (const log of inboundLogs) {
+        if (log.logIndex < 0) {
+            diagnostics?.push(`skipped log with negative logIndex (eventName=${log.eventName})`);
+            continue;
+        }
+        const utxIdHex = deriveChildUniversalTxId(sourceChainCaip, externalTxHash, log.logIndex);
+        try {
+            const resp = await pushClient.getUniversalTxByIdV2(utxIdHex.slice(2));
+            const utx = resp?.universalTx;
+            if (!utx || !utx.id) {
                 out.push({
                     universalTxId: utxIdHex,
                     sourceLogIndex: log.logIndex,
@@ -173,10 +124,51 @@ function resolveChildInboundsFromLogs(pushClient, sourceChainCaip, externalTxHas
                     outboundHashes: [],
                     notFound: true,
                 });
+                continue;
             }
+            const status = (utx.universalStatus ?? 0);
+            const pcTxHashes = (utx.pcTx ?? [])
+                .map((p) => p?.txHash)
+                .filter((h) => Boolean(h));
+            const outboundHashes = (utx.outboundTx ?? []).map((ob) => ({
+                subTxId: ob.id ?? '',
+                status: OUTBOUND_STATUS_NAMES[ob.outboundStatus] ??
+                    `UNKNOWN(${ob.outboundStatus})`,
+                destinationChain: ob.destinationChain ?? '',
+                externalTxHash: ob.observedTx?.txHash || undefined,
+                amount: ob.amount,
+                recipient: ob.recipient,
+            }));
+            out.push({
+                universalTxId: utxIdHex,
+                sourceLogIndex: log.logIndex,
+                sourceEventName: log.eventName,
+                status,
+                statusName: STATUS_NAMES[status] ?? `UNKNOWN(${status})`,
+                pcTxHashes,
+                outboundHashes,
+            });
+        }
+        catch (err) {
+            diagnostics?.push(`getUniversalTxByIdV2(${utxIdHex}) failed: ${err instanceof Error ? err.message : String(err)}`);
+            // Cosmos lookup failed (commonly NotFound while the indexer is still
+            // catching up). The utxId is deterministically derived from the source
+            // log, so surface it as notFound rather than dropping the entry —
+            // otherwise callers like inbound-tracker repeatedly re-run the full
+            // detector pass instead of advancing to lightweight status polling.
+            out.push({
+                universalTxId: utxIdHex,
+                sourceLogIndex: log.logIndex,
+                sourceEventName: log.eventName,
+                status: 0,
+                statusName: STATUS_NAMES[0],
+                pcTxHashes: [],
+                outboundHashes: [],
+                notFound: true,
+            });
         }
-        return out;
-    });
+    }
+    return out;
 }
 // Debug-only re-export (avoid importing into production paths).
 exports.__internal = { toHex: viem_1.toHex };

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

@@ -152,7 +152,7 @@ function asBigint(v) {
         try {
             return BigInt(v);
         }
-        catch (_a) {
+        catch {
             return undefined;
         }
     }
@@ -164,7 +164,6 @@ function assignHex(out, key, v) {
     }
 }
 function setTxType(out, raw) {
-    var _a;
     const n = typeof raw === 'number'
         ? raw
         : typeof raw === 'bigint'
@@ -173,7 +172,7 @@ function setTxType(out, raw) {
     if (n === undefined)
         return;
     out.txType = n;
-    out.txTypeName = (_a = TX_TYPE_NAMES[n]) !== null && _a !== void 0 ? _a : 'UNKNOWN';
+    out.txTypeName = TX_TYPE_NAMES[n] ?? 'UNKNOWN';
 }
 function setPayload(out, raw) {
     if (typeof raw !== 'string' || !raw.startsWith('0x'))

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

@@ -37,158 +37,152 @@ const INBOUND_KINDS = new Set([
  * consumer (classify, cascade, child-inbounds, inbound-tracker) can treat
  * EVM and SVM results uniformly.
  */
-function detectUniversalTxSvm(signature_1, chain_2) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (signature, chain, opts = {}) {
-        var _a;
-        const notes = [];
-        const chainInfo = chain_1.CHAIN_INFO[chain];
-        const castHash = signature; // intentional — we widen downstream
-        if (!chainInfo) {
-            throw new Error(`detectUniversalTxSvm: unknown chain ${chain}`);
-        }
-        const connection = yield resolveConnection(chain, opts);
-        // The cascade (and cosmos) stores Solana signatures as 0x-prefixed hex of
-        // the 64-byte signature bytes. Solana RPC needs base58 — normalize here
-        // so callers can pass either form interchangeably.
-        const rpcSig = normalizeSolanaSignature(signature);
-        let tx;
+async function detectUniversalTxSvm(signature, chain, opts = {}) {
+    const notes = [];
+    const chainInfo = chain_1.CHAIN_INFO[chain];
+    const castHash = signature; // intentional — we widen downstream
+    if (!chainInfo) {
+        throw new Error(`detectUniversalTxSvm: unknown chain ${chain}`);
+    }
+    const connection = await resolveConnection(chain, opts);
+    // The cascade (and cosmos) stores Solana signatures as 0x-prefixed hex of
+    // the 64-byte signature bytes. Solana RPC needs base58 — normalize here
+    // so callers can pass either form interchangeably.
+    const rpcSig = normalizeSolanaSignature(signature);
+    let tx;
+    try {
+        tx = await connection.getTransaction(rpcSig, {
+            commitment: 'confirmed',
+            maxSupportedTransactionVersion: 0,
+        });
+    }
+    catch (err) {
+        notes.push(`svm tx fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+        return emptyDetection(castHash, chain, notes);
+    }
+    if (!tx || !tx.meta) {
+        notes.push('no svm tx returned by RPC');
+        return emptyDetection(castHash, chain, notes);
+    }
+    // Reverted with no logs — same early-out as EVM path.
+    const err = tx.meta.err;
+    const logMessages = (tx.meta.logMessages ?? []);
+    if (err && logMessages.length === 0) {
+        notes.push('svm tx reverted with no logs');
+        return emptyDetection(castHash, chain, notes);
+    }
+    // Emitter for SVM is the gateway program id from CHAIN_INFO.
+    // Encoded as 0x-prefixed 32-byte hex so MatchingLog.address stays
+    // assignable to the `0x${string}` type without widening.
+    const emitterBase58 = chainInfo.lockerContract || '';
+    let emitter = '0x';
+    if (emitterBase58 && emitterBase58 !== 'TBD') {
         try {
-            tx = yield connection.getTransaction(rpcSig, {
-                commitment: 'confirmed',
-                maxSupportedTransactionVersion: 0,
-            });
+            emitter = (0, viem_1.bytesToHex)(new web3_js_1.PublicKey(emitterBase58).toBytes());
         }
-        catch (err) {
-            notes.push(`svm tx fetch failed: ${err instanceof Error ? err.message : String(err)}`);
-            return emptyDetection(castHash, chain, notes);
+        catch {
+            emitter = '0x';
         }
-        if (!tx || !tx.meta) {
-            notes.push('no svm tx returned by RPC');
-            return emptyDetection(castHash, chain, notes);
+    }
+    const eventCoder = new anchor_1.BorshEventCoder(universalGatewayV0_json_1.default);
+    const matchingLogs = [];
+    // Walk logMessages for `Program data:` entries. Each matched event keeps
+    // the actual Solana log-message index because that is the value validators
+    // submit as the inbound log_index and the keeper uses for the UTX key.
+    for (let logIndex = 0; logIndex < logMessages.length; logIndex++) {
+        const rawLog = logMessages[logIndex];
+        if (typeof rawLog !== 'string')
+            continue;
+        const prefix = 'Program data: ';
+        if (!rawLog.startsWith(prefix))
+            continue;
+        const base64Data = rawLog.slice(prefix.length).trim();
+        // Fast discriminator check — skip non-universal events without running
+        // the full Borsh decode.
+        let bytes;
+        try {
+            bytes = new Uint8Array(Buffer.from(base64Data, 'base64'));
         }
-        // Reverted with no logs — same early-out as EVM path.
-        const err = tx.meta.err;
-        const logMessages = ((_a = tx.meta.logMessages) !== null && _a !== void 0 ? _a : []);
-        if (err && logMessages.length === 0) {
-            notes.push('svm tx reverted with no logs');
-            return emptyDetection(castHash, chain, notes);
+        catch {
+            continue;
         }
-        // Emitter for SVM is the gateway program id from CHAIN_INFO.
-        // Encoded as 0x-prefixed 32-byte hex so MatchingLog.address stays
-        // assignable to the `0x${string}` type without widening.
-        const emitterBase58 = chainInfo.lockerContract || '';
-        let emitter = '0x';
-        if (emitterBase58 && emitterBase58 !== 'TBD') {
-            try {
-                emitter = (0, viem_1.bytesToHex)(new web3_js_1.PublicKey(emitterBase58).toBytes());
-            }
-            catch (_b) {
-                emitter = '0x';
-            }
+        const disc = (0, svm_events_1.discriminatorHex)(bytes);
+        const eventName = svm_events_1.SVM_EVENT_DISCRIMINATORS[disc];
+        if (!eventName)
+            continue;
+        // BorshEventCoder can throw when the on-chain layout drifts from the
+        // bundled IDL (seen with older UniversalTx emissions). Isolate the
+        // failure to this event so the rest of the matching logs still surface.
+        let decoded = null;
+        try {
+            decoded = eventCoder.decode(base64Data);
         }
-        const eventCoder = new anchor_1.BorshEventCoder(universalGatewayV0_json_1.default);
-        const matchingLogs = [];
-        // Walk logMessages for `Program data:` entries. Each matched event keeps
-        // the actual Solana log-message index because that is the value validators
-        // submit as the inbound log_index and the keeper uses for the UTX key.
-        for (let logIndex = 0; logIndex < logMessages.length; logIndex++) {
-            const rawLog = logMessages[logIndex];
-            if (typeof rawLog !== 'string')
-                continue;
-            const prefix = 'Program data: ';
-            if (!rawLog.startsWith(prefix))
-                continue;
-            const base64Data = rawLog.slice(prefix.length).trim();
-            // Fast discriminator check — skip non-universal events without running
-            // the full Borsh decode.
-            let bytes;
-            try {
-                bytes = new Uint8Array(Buffer.from(base64Data, 'base64'));
-            }
-            catch (_c) {
-                continue;
-            }
-            const disc = (0, svm_events_1.discriminatorHex)(bytes);
-            const eventName = svm_events_1.SVM_EVENT_DISCRIMINATORS[disc];
-            if (!eventName)
-                continue;
-            // BorshEventCoder can throw when the on-chain layout drifts from the
-            // bundled IDL (seen with older UniversalTx emissions). Isolate the
-            // failure to this event so the rest of the matching logs still surface.
-            let decoded = null;
-            try {
-                decoded = eventCoder.decode(base64Data);
-            }
-            catch (e) {
-                notes.push(`svm: borsh decode threw for ${eventName}: ${e instanceof Error ? e.message : String(e)}`);
-                continue;
-            }
-            if (!decoded || decoded.name !== eventName) {
-                notes.push(`svm: discriminator matched ${eventName} but borsh decode failed`);
-                continue;
-            }
-            const args = normalizeSvmEventArgs(eventName, decoded.data);
-            matchingLogs.push({
-                eventName,
-                address: emitter,
-                logIndex,
-                args,
-            });
+        catch (e) {
+            notes.push(`svm: borsh decode threw for ${eventName}: ${e instanceof Error ? e.message : String(e)}`);
+            continue;
         }
-        if (matchingLogs.length === 0) {
-            notes.push('svm tx has no decoded universal-tx events');
-            return emptyDetection(castHash, chain, notes);
+        if (!decoded || decoded.name !== eventName) {
+            notes.push(`svm: discriminator matched ${eventName} but borsh decode failed`);
+            continue;
         }
-        const classified = (0, classify_1.classify)(matchingLogs);
-        notes.push(...classified.notes);
-        const decoded = Object.assign({}, classified.decoded);
-        // Inbound fallback for universalTxId: same formula the EVM branch uses,
-        // with the canonical 0x-hex Solana signature and log-message index.
-        if (!decoded.universalTxId) {
-            const caip = chain;
-            if (INBOUND_KINDS.has(classified.kind) &&
-                classified.primaryLog &&
-                classified.primaryLog.logIndex >= 0) {
-                // Use the hex form (matches cosmos keeper's on-chain storage).
-                const hexSig = solanaSigToHex(rpcSig);
-                const input = `${caip}:${hexSig}:${classified.primaryLog.logIndex}`;
-                decoded.universalTxId = (0, viem_1.sha256)((0, viem_1.toBytes)(input));
-                notes.push(`universalTxId derived via sha256("${caip}:<hexSig>:${classified.primaryLog.logIndex}") — svm`);
-            }
+        const args = normalizeSvmEventArgs(eventName, decoded.data);
+        matchingLogs.push({
+            eventName,
+            address: emitter,
+            logIndex,
+            args,
+        });
+    }
+    if (matchingLogs.length === 0) {
+        notes.push('svm tx has no decoded universal-tx events');
+        return emptyDetection(castHash, chain, notes);
+    }
+    const classified = (0, classify_1.classify)(matchingLogs);
+    notes.push(...classified.notes);
+    const decoded = { ...classified.decoded };
+    // Inbound fallback for universalTxId: same formula the EVM branch uses,
+    // with the canonical 0x-hex Solana signature and log-message index.
+    if (!decoded.universalTxId) {
+        const caip = chain;
+        if (INBOUND_KINDS.has(classified.kind) &&
+            classified.primaryLog &&
+            classified.primaryLog.logIndex >= 0) {
+            // Use the hex form (matches cosmos keeper's on-chain storage).
+            const hexSig = solanaSigToHex(rpcSig);
+            const input = `${caip}:${hexSig}:${classified.primaryLog.logIndex}`;
+            decoded.universalTxId = (0, viem_1.sha256)((0, viem_1.toBytes)(input));
+            notes.push(`universalTxId derived via sha256("${caip}:<hexSig>:${classified.primaryLog.logIndex}") — svm`);
         }
-        const detections = (0, classify_1.classifyAll)(classified.matchingLogs);
-        return {
-            txHash: castHash,
-            chain,
-            kind: classified.kind,
-            emitters: classified.emitters,
-            decoded,
-            matchingLogs: classified.matchingLogs,
-            detections,
-            // SVM detector doesn't do the cosmos cross-reference itself; upstream
-            // (orchestrator / cascade) already does its own lookup when needed.
-            notes,
-        };
-    });
+    }
+    const detections = (0, classify_1.classifyAll)(classified.matchingLogs);
+    return {
+        txHash: castHash,
+        chain,
+        kind: classified.kind,
+        emitters: classified.emitters,
+        decoded,
+        matchingLogs: classified.matchingLogs,
+        detections,
+        // SVM detector doesn't do the cosmos cross-reference itself; upstream
+        // (orchestrator / cascade) already does its own lookup when needed.
+        notes,
+    };
 }
 // ── Helpers ───────────────────────────────────────────────────────────
-function resolveConnection(chain, opts) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        if (opts.connection)
-            return opts.connection;
-        const info = chain_1.CHAIN_INFO[chain];
-        const rpcUrls = ((_a = opts.rpcUrls) === null || _a === void 0 ? void 0 : _a[chain]) && opts.rpcUrls[chain].length > 0
-            ? opts.rpcUrls[chain]
-            : ((_b = info === null || info === void 0 ? void 0 : info.defaultRPC) !== null && _b !== void 0 ? _b : []).filter((r) => r && r.length > 0);
-        if (rpcUrls.length === 0) {
-            throw new Error(`detectUniversalTxSvm: no RPC URL configured for ${chain}`);
-        }
-        // Lazy import to avoid a top-level dependency cycle through @solana/web3.js
-        // for consumers of the EVM-only path.
-        const { Connection } = yield Promise.resolve().then(() => tslib_1.__importStar(require('@solana/web3.js')));
-        return new Connection(rpcUrls[0], 'confirmed');
-    });
+async function resolveConnection(chain, opts) {
+    if (opts.connection)
+        return opts.connection;
+    const info = chain_1.CHAIN_INFO[chain];
+    const rpcUrls = opts.rpcUrls?.[chain] && opts.rpcUrls[chain].length > 0
+        ? opts.rpcUrls[chain]
+        : (info?.defaultRPC ?? []).filter((r) => r && r.length > 0);
+    if (rpcUrls.length === 0) {
+        throw new Error(`detectUniversalTxSvm: no RPC URL configured for ${chain}`);
+    }
+    // Lazy import to avoid a top-level dependency cycle through @solana/web3.js
+    // for consumers of the EVM-only path.
+    const { Connection } = await Promise.resolve().then(() => tslib_1.__importStar(require('@solana/web3.js')));
+    return new Connection(rpcUrls[0], 'confirmed');
 }
 function emptyDetection(txHash, chain, notes) {
     return {
@@ -215,14 +209,13 @@ function emptyDetection(txHash, chain, notes) {
  *    the expected keys.
  */
 function normalizeSvmEventArgs(eventName, raw) {
-    var _a, _b;
     const src = raw;
     const out = {};
     for (const [srcKey, value] of Object.entries(src)) {
-        const renamed = (_a = svm_events_1.SVM_FIELD_RENAMES[srcKey]) !== null && _a !== void 0 ? _a : srcKey;
+        const renamed = svm_events_1.SVM_FIELD_RENAMES[srcKey] ?? srcKey;
         out[renamed] = coerceArgValue(srcKey, renamed, value);
     }
-    const aliases = (_b = svm_events_1.SVM_EVENT_FIELD_ALIASES[eventName]) !== null && _b !== void 0 ? _b : [];
+    const aliases = svm_events_1.SVM_EVENT_FIELD_ALIASES[eventName] ?? [];
     for (const { from, to } of aliases) {
         if (out[to] === undefined && out[from] !== undefined) {
             out[to] = out[from];
@@ -231,7 +224,6 @@ function normalizeSvmEventArgs(eventName, raw) {
     return out;
 }
 function coerceArgValue(srcKey, renamedKey, value) {
-    var _a;
     // Anchor returns PublicKey instances for `pubkey` types. Normalize to
     // `0x${hex}` so asAddress() in classify.ts accepts them.
     if (value && typeof value === 'object' && value instanceof web3_js_1.PublicKey) {
@@ -255,12 +247,12 @@ function coerceArgValue(srcKey, renamedKey, value) {
     // BN from anchor — has toString().
     if (value && typeof value === 'object' && typeof value.toString === 'function') {
         const proto = Object.getPrototypeOf(value);
-        const ctorName = (_a = proto === null || proto === void 0 ? void 0 : proto.constructor) === null || _a === void 0 ? void 0 : _a.name;
+        const ctorName = proto?.constructor?.name;
         if (ctorName === 'BN') {
             try {
                 return BigInt(value.toString(10));
             }
-            catch (_b) {
+            catch {
                 return undefined;
             }
         }