mev-inspect/lib/generalized/inspector.js

A JS port of 'mev-inspect-py' optimised for ease of use.

var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _Inspector_instances, _Inspector_getTxMev, _Inspector_getMev;
import Chain from '../chain.js';
import { groupBy } from '../utils.js';
import { getAssets, fetchAssetTypes, classify } from './mev.js';
import { getBlockTraces, getTransactionTrace } from './traces.js';
class Inspector {
    constructor(chainId, provider) {
        _Inspector_instances.add(this);
        Object.defineProperty(this, "chainId", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "provider", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "chain", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.chainId = chainId;
        this.provider = provider;
        this.chain = new Chain(provider);
    }
    async tx(hash) {
        const receipt = await this.chain.getReceipt(hash);
        if (!receipt) {
            return [];
        }
        return await __classPrivateFieldGet(this, _Inspector_instances, "m", _Inspector_getTxMev).call(this, this.provider, receipt, hash);
    }
    async block(number) {
        const logs = await this.chain.getBlockReceipts(number);
        return await __classPrivateFieldGet(this, _Inspector_instances, "m", _Inspector_getMev).call(this, this.provider, logs, number);
    }
    async receipts(receipts) {
        const receiptsByBlock = groupBy(receipts, (receipt) => receipt.blockNumber.toString());
        const mev = [];
        for (const block in receiptsByBlock) {
            const number = parseInt(block);
            const blockReceipts = receiptsByBlock[block];
            const blockMev = await __classPrivateFieldGet(this, _Inspector_instances, "m", _Inspector_getMev).call(this, this.provider, blockReceipts, number);
            for (const mevItem of blockMev) {
                mev.push(mevItem);
            }
        }
        return mev;
    }
}
_Inspector_instances = new WeakSet(), _Inspector_getTxMev = async function _Inspector_getTxMev(provider, receipt, hash) {
    const receiptMap = {
        [hash]: receipt,
    };
    const trace = await getTransactionTrace(provider, hash);
    if (!trace) {
        return [];
    }
    const traceMap = {
        [hash]: trace,
    };
    const assets = getAssets([receipt]);
    await fetchAssetTypes(provider, assets);
    return classify(traceMap, receiptMap);
}, _Inspector_getMev = async function _Inspector_getMev(provider, receipts, block) {
    if (receipts.length === 0) {
        return [];
    }
    const receiptMap = groupReceiptsByTransaction(receipts);
    const traces = await getBlockTraces(provider, block);
    if (!traces) {
        return [];
    }
    const assets = getAssets(receipts);
    await fetchAssetTypes(provider, assets);
    return classify(traces, receiptMap);
};
function groupReceiptsByTransaction(receipts) {
    const group = {};
    for (const receipt of receipts) {
        const hash = receipt.hash;
        group[hash] = receipt;
    }
    return group;
}
export default Inspector;
//# sourceMappingURL=inspector.js.map