@celo/explorer/lib/log-explorer.js

Celo's block explorer consumer

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.LogExplorer = exports.newLogExplorer = void 0;
const base_1 = require("./base");
function newLogExplorer(kit) {
    return __awaiter(this, void 0, void 0, function* () {
        return new LogExplorer(kit, yield (0, base_1.obtainKitContractDetails)(kit));
    });
}
exports.newLogExplorer = newLogExplorer;
class LogExplorer {
    constructor(kit, contractDetails) {
        this.kit = kit;
        this.contractDetails = contractDetails;
        this.addressMapping = (0, base_1.mapFromPairs)(contractDetails.map((cd) => [
            cd.address,
            {
                details: cd,
                logMapping: (0, base_1.mapFromPairs)(cd.jsonInterface
                    .filter((ad) => ad.type === 'event')
                    .map((ad) => [ad.signature, ad])),
            },
        ]));
        for (const cd of contractDetails) {
            const fnMapping = new Map();
            for (const abiDef of cd.jsonInterface) {
                if (abiDef.type === 'event') {
                    fnMapping.set(abiDef.signature, abiDef);
                }
            }
            this.addressMapping.set(cd.address, {
                details: cd,
                logMapping: fnMapping,
            });
        }
    }
    fetchTxReceipt(txhash) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.kit.connection.getTransactionReceipt(txhash);
        });
    }
    getKnownLogs(tx) {
        const res = [];
        for (const log of tx.logs || []) {
            const event = this.tryParseLog(log);
            if (event != null) {
                res.push(event);
            }
        }
        return res;
    }
    tryParseLog(log) {
        if (log.topics.length === 0) {
            return null;
        }
        const contractMapping = this.addressMapping.get(log.address);
        if (contractMapping == null) {
            return null;
        }
        const logSignature = log.topics[0];
        const matchedAbi = contractMapping.logMapping.get(logSignature);
        if (matchedAbi == null) {
            return null;
        }
        const returnValues = this.kit.connection
            .getAbiCoder()
            .decodeLog(matchedAbi.inputs || [], log.data || '', log.topics.slice(1));
        delete returnValues.__length__;
        Object.keys(returnValues).forEach((key) => {
            if (Number.parseInt(key, 10) >= 0) {
                delete returnValues[key];
            }
        });
        const logEvent = {
            address: log.address,
            blockHash: log.blockHash,
            blockNumber: log.blockNumber,
            logIndex: log.logIndex,
            transactionIndex: log.transactionIndex,
            transactionHash: log.transactionHash,
            returnValues,
            event: matchedAbi.name,
            signature: logSignature,
            raw: {
                data: log.data || '',
                topics: log.topics || [],
            },
        };
        return logEvent;
    }
}
exports.LogExplorer = LogExplorer;
//# sourceMappingURL=log-explorer.js.map