@eclesia/indexer-engine 2.3.1

package/dist/emitter/index.d.ts

@@ -0,0 +1,16 @@
+import { WithHeightAndUUID } from "../types";
+export declare class EclesiaEmitter {
+    private emitter;
+    handled: Map<string, number>;
+    constructor();
+    emit<EType extends keyof (WithHeightAndUUID<EventMap>) & string>(eventName: EType, eventArg: WithHeightAndUUID<EventMap>[EType] & {
+        uuid?: string;
+    }): void;
+    on<TEventName extends keyof WithHeightAndUUID<EventMap> & string | "_unhandled">(eventName: TEventName, handler: TEventName extends "_unhandled" ? (eventArg: {
+        type: string;
+        event: unknown;
+        uuid: string;
+    }) => void : (eventArg: TEventName extends keyof WithHeightAndUUID<EventMap> ? WithHeightAndUUID<EventMap>[TEventName] : never) => void): void;
+    off<TEventName extends keyof WithHeightAndUUID<EventMap> & string>(eventName: TEventName, handler: (eventArg: WithHeightAndUUID<EventMap>[TEventName]) => void): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/emitter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/emitter/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAsB;IAE9B,OAAO,sBAA6B;;IAM3C,IAAI,CAAC,KAAK,SAAS,MAAM,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,GAAG,MAAM,EAC7D,SAAS,EAAE,KAAK,EAChB,QAAQ,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;IAYlE,EAAE,CAAC,UAAU,SAAS,MAAM,iBAAiB,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,YAAY,EAAE,SAAS,EAAE,UAAU,EACpG,OAAO,EAAE,UAAU,SAAS,YAAY,GACpC,CAAC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAC1B,KAAK,EAAE,OAAO,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;KAAE,KAAK,IAAI,GACxB,CAAC,QAAQ,EAAE,UAAU,SAAS,MAAM,iBAAiB,CAAC,QAAQ,CAAC,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,GAAG,KAAK,KAAK,IAAI;IAwBhI,GAAG,CAAC,UAAU,SAAS,MAAM,iBAAiB,CAAC,QAAQ,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,UAAU,EACtF,OAAO,EAAE,CAAC,QAAQ,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,KAAK,IAAI;CASvE"}

package/dist/emitter/index.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EclesiaEmitter = void 0;
+const events_1 = __importDefault(require("events"));
+class EclesiaEmitter {
+    constructor() {
+        this.emitter = new events_1.default();
+        this.handled = new Map();
+        this.emitter.setMaxListeners(0);
+    }
+    emit(eventName, eventArg) {
+        if (this.handled.has(eventName)) {
+            this.emitter.emit(eventName, eventArg);
+        }
+        else {
+            this.emitter.emit("_unhandled", {
+                type: eventName,
+                event: eventArg,
+                uuid: eventArg.uuid
+            });
+        }
+    }
+    on(eventName, handler) {
+        const count = this.handled.get(eventName);
+        if (count) {
+            this.handled.set(eventName, count + 1);
+        }
+        else {
+            this.handled.set(eventName, 1);
+        }
+        this.emitter.on(eventName, async (eventData) => {
+            try {
+                await handler(eventData);
+                if (eventName !== "uuid" && eventName !== "_unhandled" && eventData.uuid) {
+                    this.emit("uuid", { status: true,
+                        uuid: eventData.uuid });
+                }
+            }
+            catch (error) {
+                if (eventName !== "uuid" && eventName !== "_unhandled" && eventData.uuid) {
+                    this.emit("uuid", { status: false,
+                        error: error,
+                        uuid: eventData.uuid });
+                }
+            }
+        });
+    }
+    off(eventName, handler) {
+        const count = this.handled.get(eventName);
+        if (count && count > 1) {
+            this.handled.set(eventName, count - 1);
+        }
+        else {
+            this.handled.delete(eventName);
+        }
+        this.emitter.off(eventName, handler);
+    }
+}
+exports.EclesiaEmitter = EclesiaEmitter;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./emitter";
+export * from "./indexer";
+export * from "./promise-queue";
+export * as Types from "./types";
+export * as Utils from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = exports.Types = void 0;
+__exportStar(require("./emitter"), exports);
+__exportStar(require("./indexer"), exports);
+__exportStar(require("./promise-queue"), exports);
+exports.Types = __importStar(require("./types"));
+exports.Utils = __importStar(require("./utils"));

package/dist/indexer/index.d.ts

@@ -0,0 +1,50 @@
+import { CometClient } from "@cosmjs/tendermint-rpc";
+import winston from "winston";
+import { EclesiaEmitter } from "../emitter";
+import { EcleciaIndexerConfig, EmitFunc, WithHeightAndUUID } from "../types";
+export declare const defaultIndexerConfig: {
+    startHeight: number;
+    batchSize: number;
+    modules: never[];
+    getNextHeight: () => number;
+    logLevel: EcleciaIndexerConfig["logLevel"];
+    usePolling: boolean;
+    pollingInterval: number;
+    processGenesis: boolean;
+    minimal: boolean;
+    init: () => Promise<void>;
+    beginTransaction: () => Promise<void>;
+    endTransaction: (_status: boolean) => Promise<void>;
+};
+export declare class EcleciaIndexer extends EclesiaEmitter {
+    private config;
+    private fastify;
+    private blockQueue;
+    private latestHeight;
+    private heightToProcess;
+    private initialized;
+    private retryCount;
+    client: CometClient;
+    log: winston.Logger;
+    private debugTime;
+    private healthCheck;
+    private subscription;
+    constructor(config: EcleciaIndexerConfig);
+    private setStatus;
+    private blockListener;
+    private isMinimal;
+    connect(): Promise<boolean>;
+    private debugTimes;
+    start(): Promise<void>;
+    asyncEmit: EmitFunc<keyof WithHeightAndUUID<EventMap>>;
+    private processBlock;
+    private fetcher;
+    callABCI(path: string, data: Uint8Array, height?: number): Promise<Uint8Array<ArrayBufferLike>>;
+    private newBlockReceived;
+    private pollForBlock;
+    private readGenesis;
+    private setArrayReader;
+    private setValueReader;
+    private parseGenesis;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/indexer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/indexer/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAuC,WAAW,EAA4B,MAAM,wBAAwB,CAAC;AAkBpH,OAAO,OAAO,MAAM,SAAS,CAAC;AAE9B,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAAc,oBAAoB,EAAE,QAAQ,EAAqB,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAI5G,eAAO,MAAM,oBAAoB;;;;;cAKX,oBAAoB,CAAC,UAAU,CAAC;;;;;;;8BAO1B,OAAO;CAClC,CAAC;AAEF,qBAAa,cAAe,SAAQ,cAAc;IAChD,OAAO,CAAC,MAAM,CAAuB;IAErC,OAAO,CAAC,OAAO,CAAkB;IAEjC,OAAO,CAAC,UAAU,CAAa;IAE/B,OAAO,CAAC,YAAY,CAAU;IAE9B,OAAO,CAAC,eAAe,CAAU;IAEjC,OAAO,CAAC,WAAW,CAAS;IAE5B,OAAO,CAAC,UAAU,CAAK;IAEhB,MAAM,EAAG,WAAW,CAAC;IAErB,GAAG,EAAE,OAAO,CAAC,MAAM,CAAC;IAE3B,OAAO,CAAC,SAAS,CAAiC;IAElD,OAAO,CAAC,WAAW,CAEjB;IAEF,OAAO,CAAC,YAAY,CAA6D;gBAErE,MAAM,EAAE,oBAAoB;IAyDxC,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,aAAa,CAInB;IAEF,OAAO,CAAC,SAAS;IAQJ,OAAO;IAYpB,OAAO,CAAC,UAAU;IAUL,KAAK;IAyIX,SAAS,EAAE,QAAQ,CAAC,MAAM,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAoC3D;YAEY,YAAY;YA6HZ,OAAO;IA2CR,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM;IAoBrE,OAAO,CAAC,gBAAgB;YAqCV,YAAY;IAY1B,OAAO,CAAC,WAAW;YAQL,cAAc;YAyBd,cAAc;YAuBd,YAAY;CAiD3B"}

package/dist/indexer/index.js

@@ -0,0 +1,629 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcleciaIndexer = exports.defaultIndexerConfig = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const tendermint_rpc_1 = require("@cosmjs/tendermint-rpc");
+const tendermint_rpc_2 = require("@cosmjs/tendermint-rpc");
+const tx_1 = require("cosmjs-types/cosmos/authz/v1beta1/tx");
+const query_1 = require("cosmjs-types/cosmos/staking/v1beta1/query");
+const tx_2 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+const fastify_1 = __importDefault(require("fastify"));
+const stream_chain_1 = require("stream-chain");
+const stream_json_1 = require("stream-json");
+const Pick_1 = require("stream-json/filters/Pick");
+const StreamArray_1 = require("stream-json/streamers/StreamArray");
+const StreamValues_1 = require("stream-json/streamers/StreamValues");
+const Batch_1 = require("stream-json/utils/Batch");
+const uuid_1 = require("uuid");
+const winston_1 = __importDefault(require("winston"));
+const emitter_1 = require("../emitter");
+const promise_queue_1 = require("../promise-queue");
+const utils_1 = require("../utils");
+exports.defaultIndexerConfig = {
+    startHeight: 1,
+    batchSize: 500,
+    modules: [],
+    getNextHeight: () => 1,
+    logLevel: "info",
+    usePolling: false,
+    pollingInterval: 5000,
+    processGenesis: false,
+    minimal: true,
+    init: () => Promise.resolve(),
+    beginTransaction: () => Promise.resolve(),
+    endTransaction: (_status) => Promise.resolve()
+};
+class EcleciaIndexer extends emitter_1.EclesiaEmitter {
+    constructor(config) {
+        super();
+        this.initialized = false;
+        this.retryCount = 0;
+        this.debugTime = null;
+        this.healthCheck = {
+            status: "CONNECTING"
+        };
+        this.subscription = null;
+        this.blockListener = {
+            next: (data) => {
+                this.newBlockReceived(data.header.height);
+            }
+        };
+        this.asyncEmit = async (type, event) => {
+            event.uuid = (0, uuid_1.v4)();
+            this.debugTimes();
+            // More than 1 listener can be registered for an event type
+            // Fortunately these are all set up during module init() so we have a consistent count
+            // so we can count responses to resolve when complete
+            // values are irrelevant as promise resolution is only used for flow control
+            let listenerCount = this.handled.get(type);
+            if (!listenerCount) {
+                // Setting listenerCount to 1 (the unhandled listener)
+                listenerCount = 1;
+            }
+            let listenersResponded = 0;
+            const prom = new Promise((resolve, reject) => {
+                const returnFunc = (ev) => {
+                    if (ev.uuid == event.uuid) {
+                        if (ev.status) {
+                            listenersResponded++;
+                            if (listenersResponded == listenerCount) {
+                                // All listeners have done their thing so we can remove listener, resolve and continue execution
+                                this.off("uuid", returnFunc);
+                                this.debugTimes(type);
+                                resolve();
+                            }
+                        }
+                        else {
+                            // At least 1 listener is reporting an error. Reject and handle exception at the original asyncEmit location
+                            reject(ev.error);
+                        }
+                    }
+                };
+                this.on("uuid", returnFunc);
+            });
+            this.emit(type, event);
+            return prom;
+        };
+        this.config = {
+            ...exports.defaultIndexerConfig,
+            ...config
+        };
+        if (!this.config.minimal) {
+            this.blockQueue = new promise_queue_1.PromiseQueue(this.config.batchSize);
+        }
+        else {
+            this.blockQueue = new promise_queue_1.PromiseQueue(this.config.batchSize);
+        }
+        const { printf } = winston_1.default.format;
+        const eclesiaFormat = printf(({ level, message, timestamp }) => {
+            return `${timestamp} [${level.toUpperCase()}]:\t${message}`;
+        });
+        this.log = winston_1.default.createLogger({
+            level: this.config.logLevel,
+            defaultMeta: { service: "Eclesia Indexer" },
+            transports: [
+                new winston_1.default.transports.File({
+                    filename: "error.log",
+                    level: "error"
+                }),
+                new winston_1.default.transports.File({ filename: "combined.log" }),
+                new winston_1.default.transports.Console({
+                    format: winston_1.default.format.combine(winston_1.default.format.splat(), winston_1.default.format.timestamp(), eclesiaFormat, winston_1.default.format.colorize({ all: true }))
+                })
+            ]
+        });
+        this.fastify = (0, fastify_1.default)({
+            logger: false
+        });
+        this.on("_unhandled", (msg) => {
+            if (msg.uuid) {
+                this.log.verbose("Unhandled event: " + msg.type);
+                this.emit("uuid", {
+                    status: true,
+                    uuid: msg.uuid
+                });
+            }
+        });
+        this.fastify.get("/health", async (_request, reply) => {
+            const code = this.healthCheck.status == "OK" ? 200 : 503;
+            reply.code(code).send(this.healthCheck);
+        });
+        this.fastify.listen({
+            port: 80,
+            host: "0.0.0.0"
+        }, (err) => {
+            if (err) {
+                this.log.error(err);
+                process.exit(1);
+            }
+        });
+    }
+    setStatus(status) {
+        this.healthCheck.status = status;
+    }
+    isMinimal(_blockqueue) {
+        if (this.config.minimal) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    async connect() {
+        try {
+            this.client = await (0, tendermint_rpc_2.connectComet)(this.config.rpcUrl);
+            this.log.info("Connected to RPC");
+            return true;
+        }
+        catch (error) {
+            this.log.error(error);
+            return false;
+        }
+    }
+    debugTimes(label) {
+        if (this.debugTime && this.config.logLevel == "debug") {
+            const hrTime = process.hrtime(this.debugTime);
+            this.log.debug("Process time for " + label + ": " + Number(hrTime[0] * 1000 + hrTime[1] / 1000000) + "ms");
+            this.debugTime = null;
+        }
+        else {
+            this.debugTime = process.hrtime();
+        }
+    }
+    async start() {
+        this.debugTime = null;
+        if (!this.initialized) {
+            try {
+                if (this.config.init) {
+                    await this.config.init();
+                }
+            }
+            catch (e) {
+                this.log.error("Failed to initialize indexer: " + e);
+                this.setStatus("FAILED");
+                throw e;
+            }
+            if (this.config.processGenesis) {
+                try {
+                    if (this.config.genesisPath) {
+                        await this.parseGenesis();
+                    }
+                }
+                catch (e) {
+                    this.log.error("Failed to parse genesis: " + e);
+                    this.setStatus("FAILED");
+                    throw e;
+                }
+            }
+            this.initialized = true;
+        }
+        this.subscription = this.client.subscribeNewBlock ? this.client.subscribeNewBlock() : null;
+        try {
+            await this.connect();
+            const status = await this.client.status();
+            this.latestHeight = status.syncInfo.latestBlockHeight;
+            this.blockQueue.clear();
+            this.log.info("Current chain height: " + this.latestHeight);
+            this.heightToProcess = await this.config.getNextHeight();
+            if (this.config.usePolling) {
+                this.pollForBlock();
+            }
+            else {
+                if (this.subscription) {
+                    this.subscription.addListener(this.blockListener);
+                }
+                else {
+                    throw new Error("Could not subscribe to new blocks");
+                }
+            }
+        }
+        catch (e) {
+            this.log.error("Failed to set up block listening: " + e);
+            this.setStatus("FAILED");
+            throw e;
+        }
+        this.fetcher().catch((e) => {
+            throw new Error("Error in fetching service: " + e);
+        });
+        const hrTime = process.hrtime();
+        let ms = hrTime[0] * 1000000 + hrTime[1] / 1000;
+        while (this.blockQueue.size() > 0) {
+            // await the dequeued promise is essentially awaiting fetched data for that block
+            try {
+                // Index block inside a db transaction to ensure data consistency
+                await this.config.beginTransaction();
+                this.log.silly("Started db tx");
+                let height, timestamp;
+                if (this.isMinimal(this.blockQueue)) {
+                    const toProcess = await this.blockQueue.dequeue();
+                    this.log.silly("Retrieved block data");
+                    if (!toProcess) {
+                        throw new Error("Could not fetch block");
+                    }
+                    height = toProcess[0].block.header.height;
+                    timestamp = (0, tendermint_rpc_1.toRfc3339WithNanoseconds)(toProcess[0].block.header.time);
+                    await this.processBlock(toProcess[0], toProcess[1]);
+                }
+                else {
+                    const toProcess = await this.blockQueue.dequeue();
+                    this.log.silly("Retrieved block data");
+                    if (!toProcess) {
+                        throw new Error("Could not fetch block");
+                    }
+                    this.log.silly("Decoded block");
+                    height = toProcess[0].block.header.height;
+                    timestamp = (0, tendermint_rpc_1.toRfc3339WithNanoseconds)(toProcess[0].block.header.time);
+                    await this.processBlock(toProcess[0], toProcess[1], query_1.QueryValidatorsResponse.decode(toProcess[2]).validators);
+                }
+                // Emit events to trigger periodic operations every 50, 100 and 1000 blocks
+                if (height % 1000 == 0) {
+                    const hrTime = process.hrtime();
+                    const newms = hrTime[0] * 1000000 + hrTime[1] / 1000;
+                    const duration = newms - ms;
+                    ms = newms;
+                    const rate = 1000000000 / duration;
+                    this.log.info("Processing:" + rate.toFixed(2) + "blocks/sec");
+                    await this.asyncEmit("periodic/1000", {
+                        value: null,
+                        height,
+                        timestamp
+                    });
+                }
+                if (height % 100 == 0) {
+                    await this.asyncEmit("periodic/100", {
+                        value: null,
+                        height,
+                        timestamp
+                    });
+                }
+                if (height % 50 == 0) {
+                    await this.asyncEmit("periodic/50", {
+                        value: null,
+                        height,
+                        timestamp
+                    });
+                }
+                this.log.silly("Handled periodic events");
+                await this.config.endTransaction(true);
+                this.log.silly("Committed db tx");
+            }
+            catch (e) {
+                this.log.error("" + e);
+                this.setStatus("FAILED");
+                await this.config.endTransaction(false);
+                if (this.subscription) {
+                    this.subscription.removeListener(this.blockListener);
+                }
+                this.retryCount++;
+                break;
+            }
+            this.retryCount = 0;
+            this.setStatus("OK");
+        }
+        if (this.retryCount < 3) {
+            this.log.debug("Indexer retryCount: " + this.retryCount);
+            this.log.info("Indexer is restarting");
+            this.start();
+        }
+    }
+    async processBlock(block, block_results, validators) {
+        const height = block.block.header.height;
+        this.log.debug("Processing block: %d", height);
+        this.log.silly("Started db tx");
+        // Initialize height & timestamp to be used for this block-processing run
+        const timestamp = (0, tendermint_rpc_1.toRfc3339WithNanoseconds)(block.block.header.time);
+        // Use & await asyncEmit to ensure db insertions in order
+        // Emit block information to any interested modules.
+        // Primarily the required block module listens to this
+        await this.asyncEmit("block", {
+            value: {
+                block,
+                block_results
+            },
+            height,
+            timestamp
+        });
+        this.log.silly("Modules handled block event");
+        // Deal with begin_block events first
+        await this.asyncEmit("begin_block", {
+            value: {
+                events: block_results.beginBlockEvents,
+                validators
+            },
+            height,
+            timestamp
+        });
+        this.log.silly("Modules handled begin_block events");
+        // Then individual tx_events
+        await this.asyncEmit("tx_events", {
+            value: block_results.results,
+            height,
+            timestamp
+        });
+        this.log.silly("Modules handled tx events");
+        // Emit details and result for each tx msg separately
+        for (let t = 0; t < block.block.txs.length; t++) {
+            const tx = tx_2.Tx.decode(block.block.txs[t]);
+            const result = block_results.results[t].code;
+            const txlog = block_results.results[t].log;
+            if (result != 0) {
+                //  Tx failed. Ignore
+                continue;
+            }
+            if (tx.body && tx.body.memo != "") {
+                const txHash = (0, node_crypto_1.createHash)("sha256").update(block.block.txs[t]).digest("hex");
+                await this.asyncEmit("tx_memo", {
+                    value: {
+                        txHash,
+                        txBody: tx.body
+                    },
+                    height,
+                    timestamp
+                });
+            }
+            // parsing log rather than using events directly in order to have msg_index available to filter appropriate events for each msg
+            const events = txlog
+                ? JSON.parse(txlog)
+                : [];
+            const msgs = tx.body?.messages;
+            if (msgs) {
+                for (let i = 0; i < msgs.length; i++) {
+                    this.log.silly("Indexer broadcasting msg for handling: " + msgs[i].typeUrl);
+                    const msgevents = msgs.length > 1
+                        ? events.find((x) => x.msg_index == i)?.events
+                        : events[0].events;
+                    await this.asyncEmit(msgs[i].typeUrl, {
+                        value: {
+                            tx: msgs[i].value,
+                            events: msgevents
+                        },
+                        height,
+                        timestamp
+                    });
+                    if (msgs[i].typeUrl == "/cosmos.authz.v1beta1.MsgExec") {
+                        const authzMsgs = tx_1.MsgExec.decode(msgs[i].value).msgs;
+                        if (authzMsgs) {
+                            for (let r = 0; r < authzMsgs.length; r++) {
+                                this.log.silly("Indexer broadcasting msg for handling: " + authzMsgs[i].typeUrl);
+                                const authzMsgEvents = msgevents?.reduce((events, evt) => {
+                                    if (evt.attributes.filter(x => (0, utils_1.decodeAttr)(x.key) == "authz_msg_index" && (0, utils_1.decodeAttr)(x.value) == "" + r).length > 0) {
+                                        events.push(evt);
+                                    }
+                                    return events;
+                                }, []);
+                                await this.asyncEmit(authzMsgs[i].typeUrl, {
+                                    value: {
+                                        tx: authzMsgs[i].value,
+                                        events: authzMsgEvents
+                                    },
+                                    height,
+                                    timestamp
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        this.log.silly("Modules handled msg events");
+        // Then deal with end_block events
+        await this.asyncEmit("end_block", {
+            value: block_results.endBlockEvents,
+            height,
+            timestamp
+        });
+        this.log.silly("Modules handled end_block events");
+    }
+    async fetcher() {
+        let error = false;
+        for (let i = this.heightToProcess; i <= this.latestHeight; i++) {
+            this.log.debug("Fetching: " + i);
+            try {
+                if (this.isMinimal(this.blockQueue)) {
+                    const toIndex = Promise.all([
+                        this.client.block(i),
+                        this.client.blockResults(i)
+                    ]).catch((_e) => {
+                        this.log.error("Error fetching block: " + i);
+                        return Promise.resolve([]);
+                    });
+                    this.blockQueue.enqueue(toIndex);
+                }
+                else {
+                    const q = query_1.QueryValidatorsRequest.fromPartial({ pagination: { limit: 1000n } });
+                    const vals = query_1.QueryValidatorsRequest.encode(q).finish();
+                    const toIndex = Promise.all([
+                        this.client.block(i),
+                        this.client.blockResults(i),
+                        this.callABCI("/cosmos.staking.v1beta1.Query/Validators", vals, i)
+                    ]).catch((_e) => {
+                        this.log.error("Error fetching block: " + i);
+                        return Promise.resolve([]);
+                    });
+                    this.blockQueue.enqueue(toIndex);
+                }
+                await this.blockQueue.continue();
+            }
+            catch (e) {
+                this.log.error(e);
+                error = true;
+                break;
+            }
+        }
+        if (!error) {
+            this.blockQueue.setSynced();
+            this.log.info("Synced to latest height");
+        }
+    }
+    async callABCI(path, data, height) {
+        const timeout = new Promise((resolve) => {
+            setTimeout(resolve, 30000);
+        });
+        const abciq = await Promise.race([
+            this.client.abciQuery({
+                path,
+                data,
+                height: height
+            }),
+            timeout
+        ]);
+        if (abciq) {
+            return abciq.value;
+        }
+        else {
+            this.setStatus("FAILED");
+            throw new Error("RPC not responding. Query at: " + path);
+        }
+    }
+    newBlockReceived(height) {
+        this.log.info("Received new block: %d", height);
+        // If we are synced, add to end of queue
+        if (this.blockQueue.synced) {
+            try {
+                if (this.isMinimal(this.blockQueue)) {
+                    this.blockQueue.enqueue(Promise.all([
+                        this.client.block(height),
+                        this.client.blockResults(height)
+                    ]).catch((_e) => {
+                        this.log.error("Error fetching block: " + height);
+                        return Promise.resolve([]);
+                    }));
+                }
+                else {
+                    const q = query_1.QueryValidatorsRequest.fromPartial({ pagination: { limit: 1000n } });
+                    const vals = query_1.QueryValidatorsRequest.encode(q).finish();
+                    this.blockQueue.enqueue(Promise.all([
+                        this.client.block(height),
+                        this.client.blockResults(height),
+                        this.callABCI("/cosmos.staking.v1beta1.Query/Validators", vals, height)
+                    ]).catch((_e) => {
+                        this.log.error("Error fetching block: " + height);
+                        return Promise.resolve([]);
+                    }));
+                }
+            }
+            catch (e) {
+                this.log.error("" + e);
+            }
+        }
+        else {
+            this.latestHeight = height;
+        }
+    }
+    async pollForBlock() {
+        const status = await this.client.status();
+        if (status.syncInfo.latestBlockHeight > this.latestHeight) {
+            while (this.latestHeight < status.syncInfo.latestBlockHeight) {
+                this.newBlockReceived(this.latestHeight + 1);
+            }
+        }
+        setTimeout(() => {
+            this.pollForBlock();
+        }, this.config.pollingInterval);
+    }
+    readGenesis() {
+        if (this.config.genesisPath) {
+            return node_fs_1.default.createReadStream(this.config.genesisPath).pipe((0, stream_json_1.parser)());
+        }
+        else {
+            throw new Error("Genesis path not set");
+        }
+    }
+    async setArrayReader(path, processor) {
+        const readPromise = new Promise((resolve, reject) => {
+            try {
+                const filters = path.split(".");
+                const pickers = filters.map((filter) => (0, Pick_1.pick)({ filter }));
+                let counter = 0;
+                (0, stream_chain_1.chain)([this.readGenesis(), ...pickers, (0, StreamArray_1.streamArray)(), (0, Batch_1.batch)({ batchSize: 1000 }), processor])
+                    .on("data", (data) => {
+                    if (data && Array.isArray(data)) {
+                        counter = counter + data.length;
+                    }
+                })
+                    .on("end", () => {
+                    this.log.info(`Processed ${counter} entries`);
+                    resolve(true);
+                });
+            }
+            catch (_e) {
+                this.log.verbose("Error in setArrayReader: " + _e);
+                reject();
+            }
+        });
+        return readPromise;
+    }
+    async setValueReader(path, processor) {
+        const readPromise = new Promise((resolve, reject) => {
+            try {
+                const filters = path.split(".");
+                const pickers = filters.map((filter) => (0, Pick_1.pick)({ filter }));
+                let counter = 0;
+                (0, stream_chain_1.chain)([this.readGenesis(), ...pickers, (0, StreamValues_1.streamValues)(), processor])
+                    .on("data", (_data) => {
+                    counter++;
+                })
+                    .on("end", () => {
+                    this.log.info(`Processed ${counter} entries`);
+                    resolve(true);
+                });
+            }
+            catch (_e) {
+                reject();
+            }
+        });
+        return readPromise;
+    }
+    async parseGenesis() {
+        this.log.info("Parsing genesis");
+        await this.config.beginTransaction();
+        try {
+            this.log.info("Starting genesis import");
+            this.log.debug("Importing genesis file...");
+            for (const [key, _value] of this.handled) {
+                if (key.startsWith("genesis/")) {
+                    const genesisEntry = key.split("/");
+                    this.log.verbose("Importing " + key + "...");
+                    if (genesisEntry[1] == "array") {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        await this.setArrayReader(genesisEntry[2], async (data) => {
+                            await this.asyncEmit(key, { value: data.map((x) => x.value) });
+                            return data;
+                        });
+                    }
+                    else {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        await this.setValueReader(genesisEntry[2], async (data) => {
+                            await this.asyncEmit(key, { value: data.value });
+                            return data;
+                        });
+                    }
+                }
+            }
+            this.log.info("Importing gen TXs...");
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await this.setArrayReader("app_state.genutil.gen_txs", async (data) => {
+                for (let j = 0; j < data.length; j++) {
+                    const gentx = data[j].value;
+                    for (let i = 0; i < gentx.body.messages.length; i++) {
+                        const msg = gentx.body.messages[i];
+                        await this.asyncEmit(("gentx" + msg["@type"]), { value: msg });
+                    }
+                }
+                return data;
+            });
+            await this.config.endTransaction(true);
+            this.log.info("Finished importing");
+        }
+        catch (e) {
+            await this.config.endTransaction(false);
+            this.log.error("Failed to import genesis");
+            throw e;
+        }
+    }
+}
+exports.EcleciaIndexer = EcleciaIndexer;

package/dist/promise-queue/index.d.ts

@@ -0,0 +1,17 @@
+export declare class PromiseQueue<T> {
+    private items;
+    private enqueuer;
+    private batcher;
+    synced: boolean;
+    private batchSize;
+    private continuePromise;
+    constructor(batchSize: number);
+    enqueue(item: T | PromiseLike<T>): void;
+    clear(): void;
+    dequeue(): Promise<T>;
+    continue(): Promise<boolean>;
+    setSynced(): void;
+    isEmpty(): boolean;
+    size(): number;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/promise-queue/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/promise-queue/index.ts"],"names":[],"mappings":"AAOA,qBAAa,YAAY,CAAC,CAAC;IACzB,OAAO,CAAC,KAAK,CAAoB;IAEjC,OAAO,CAAC,QAAQ,CAAqC;IAErD,OAAO,CAAC,OAAO,CAA0B;IAElC,MAAM,UAAS;IAEtB,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,eAAe,CAAmB;gBAE9B,SAAS,EAAE,MAAM;IAY7B,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAiBhC,KAAK;IAWL,OAAO,IAMU,OAAO,CAAC,CAAC,CAAC;IAG3B,QAAQ;IAIR,SAAS;IAIT,OAAO;IAQP,IAAI;CAGL"}

package/dist/promise-queue/index.js

@@ -0,0 +1,75 @@
+"use strict";
+/*
+  This implements an "infinite" FIFO queue of fixed size.
+  await `continue()` before enqueing items to ensure fixed size (as it only resolves when space available)
+  await `dequeue()` to pop an item  as it will only resolve if the next item is available
+  size() is always at minimum 1 item which is the promise that will resolve to the next item whenever it is enqueued
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseQueue = void 0;
+class PromiseQueue {
+    constructor(batchSize) {
+        this.synced = false;
+        const nextVal = new Promise((resolve, _reject) => {
+            this.enqueuer = resolve;
+        });
+        this.batchSize = batchSize;
+        this.continuePromise = new Promise((resolve, _reject) => {
+            this.batcher = resolve;
+        });
+        this.batcher(true);
+        this.items = [nextVal];
+    }
+    enqueue(item) {
+        try {
+            this.enqueuer(item);
+            const nextVal = new Promise((resolve, _reject) => {
+                this.enqueuer = resolve;
+            });
+            this.items.unshift(nextVal);
+            if (this.size() > this.batchSize) {
+                this.continuePromise = new Promise((resolve, _reject) => {
+                    this.batcher = resolve;
+                });
+            }
+        }
+        catch (e) {
+            console.error("Enqueing rejected data: " + e);
+        }
+    }
+    clear() {
+        const nextVal = new Promise((resolve, _reject) => {
+            this.enqueuer = resolve;
+        });
+        this.continuePromise = new Promise((resolve, _reject) => {
+            this.batcher = resolve;
+        });
+        this.batcher(true);
+        this.items = [nextVal];
+    }
+    dequeue() {
+        const item = this.items.pop();
+        if (this.size() <= this.batchSize) {
+            this.batcher(true);
+        }
+        return item;
+    }
+    continue() {
+        return this.continuePromise;
+    }
+    setSynced() {
+        this.synced = true;
+    }
+    isEmpty() {
+        if (this.items.length == 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    size() {
+        return this.items.length;
+    }
+}
+exports.PromiseQueue = PromiseQueue;

package/dist/types/index.d.ts

@@ -0,0 +1,97 @@
+import { BlockResponse, BlockResultsResponse } from "@cosmjs/tendermint-rpc";
+import { Event } from "@cosmjs/tendermint-rpc/build/comet38/responses";
+import { Validator } from "cosmjs-types/cosmos/staking/v1beta1/staking";
+import { TxBody } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { EcleciaIndexer } from "../indexer";
+import { PromiseQueue } from "../promise-queue";
+export type EcleciaIndexerConfig = {
+    startHeight?: number;
+    endHeight?: number;
+    batchSize: number;
+    modules: string[];
+    getNextHeight: () => number | PromiseLike<number>;
+    logLevel: "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly";
+    rpcUrl: string;
+    processGenesis?: boolean;
+    genesisPath?: string;
+    usePolling?: boolean;
+    pollingInterval?: number;
+    minimal?: boolean;
+    init?: () => Promise<void>;
+    beginTransaction: () => Promise<void>;
+    endTransaction: (status: boolean) => Promise<void>;
+};
+export type FullBlockQueue = PromiseQueue<[BlockResponse, BlockResultsResponse, Uint8Array]>;
+export type MinimalBlockQueue = PromiseQueue<[BlockResponse, BlockResultsResponse]>;
+export type BlockQueue = FullBlockQueue | MinimalBlockQueue;
+export type WithHeightAndUUID<T> = {
+    [K in keyof T]: T[K] & {
+        uuid?: string;
+        height?: number;
+        timestamp?: string;
+    };
+};
+export type EmitFunc<K extends keyof WithHeightAndUUID<EventMap>> = (t: K, e: WithHeightAndUUID<EventMap>[K]) => Promise<void | void[]>;
+export type LogEvent = {
+    type: "log" | "info" | "warning" | "error" | "verbose" | "transient";
+    message: string;
+};
+export type UUIDEvent = {
+    uuid: string;
+    error?: string;
+    status: boolean;
+};
+export type Events = {
+    log: LogEvent;
+    uuid: UUIDEvent;
+    begin_block: {
+        value: {
+            events: BlockResultsResponse["beginBlockEvents"];
+            validators: Validator[] | undefined;
+        };
+    };
+    block: {
+        value: {
+            block: BlockResponse;
+            block_results: BlockResultsResponse;
+        };
+    };
+    end_block: {
+        value: BlockResultsResponse["endBlockEvents"];
+    };
+    tx_events: {
+        value: BlockResultsResponse["results"];
+    };
+    tx_memo: {
+        value: {
+            txHash: string;
+            txBody: TxBody;
+        };
+    };
+    _unhandled: {
+        type: string;
+        event: unknown;
+    };
+    "periodic/50": {
+        value: null;
+    };
+    "periodic/100": {
+        value: null;
+    };
+    "periodic/1000": {
+        value: null;
+    };
+};
+export type TxResult<T> = {
+    tx: T;
+    events: Event[];
+};
+export interface IndexingModule {
+    indexer: EcleciaIndexer;
+    name: string;
+    depends: string[];
+    provides: string[];
+    setup: () => Promise<void>;
+    init: (...args: any[]) => void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/bech32.d.ts

@@ -0,0 +1,5 @@
+declare function toHexString(byteArray: number[]): string;
+declare function keyHashfromAddress(address: string): string;
+declare function chainAddressfromKeyhash(prefix: string, keyhash: string): string;
+export { chainAddressfromKeyhash, keyHashfromAddress, toHexString };
+//# sourceMappingURL=bech32.d.ts.map

package/dist/utils/bech32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bech32.d.ts","sourceRoot":"","sources":["../../src/utils/bech32.ts"],"names":[],"mappings":"AAEA,iBAAS,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,UAMvC;AACD,iBAAS,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAMnD;AACD,iBAAS,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAI/D;AAED,OAAO,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,WAAW,EAAE,CAAC"}

package/dist/utils/bech32.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainAddressfromKeyhash = chainAddressfromKeyhash;
+exports.keyHashfromAddress = keyHashfromAddress;
+exports.toHexString = toHexString;
+const bech32_1 = require("bech32");
+function toHexString(byteArray) {
+    return Array.prototype.map
+        .call(byteArray, (byte) => {
+        return ("0" + (byte & 0xff).toString(16)).slice(-2);
+    })
+        .join("");
+}
+function keyHashfromAddress(address) {
+    try {
+        return toHexString(bech32_1.bech32.fromWords(bech32_1.bech32.decode(address).words));
+    }
+    catch (_e) {
+        throw new Error("Could not decode address");
+    }
+}
+function chainAddressfromKeyhash(prefix, keyhash) {
+    const words = bech32_1.bech32.toWords(Buffer.from(keyhash, "hex"));
+    return keyhash !== "" ? bech32_1.bech32.encode(prefix, words) : "";
+}

package/dist/utils/bigint.d.ts

@@ -0,0 +1,3 @@
+declare const toPlainObject: (obj: unknown) => any;
+export { toPlainObject };
+//# sourceMappingURL=bigint.d.ts.map

package/dist/utils/bigint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigint.d.ts","sourceRoot":"","sources":["../../src/utils/bigint.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,aAAa,GAAI,KAAK,OAAO,QAGlC,CAAC;AACF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/utils/bigint.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPlainObject = void 0;
+const toPlainObject = (obj) => {
+    return JSON.parse(JSON.stringify(obj, (key, value) => typeof value === "bigint" ? value.toString() : value // return everything else unchanged
+    ));
+};
+exports.toPlainObject = toPlainObject;

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./bech32";
+export * from "./bigint";
+export * from "./text";
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bech32"), exports);
+__exportStar(require("./bigint"), exports);
+__exportStar(require("./text"), exports);

package/dist/utils/text.d.ts

@@ -0,0 +1,2 @@
+export declare const decodeAttr: (x: Uint8Array | string) => string | undefined;
+//# sourceMappingURL=text.d.ts.map

package/dist/utils/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/utils/text.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,GAAI,GAAG,UAAU,GAAG,MAAM,uBAOhD,CAAC"}

package/dist/utils/text.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAttr = void 0;
+const decodeAttr = (x) => {
+    if (typeof x === "string") {
+        return x;
+    }
+    if (x instanceof Uint8Array) {
+        return Buffer.from(x).toString();
+    }
+};
+exports.decodeAttr = decodeAttr;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@eclesia/indexer-engine",
+  "version": "2.3.1",
+  "description": "Core eclesia indexer engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "test": "vitest"
+  },
+  "files": [
+    "dist/",
+    "scripts/",
+    "templates"
+  ],
+  "keywords": [],
+  "contributors": [
+    "Alex M.<alex.megalokonomos@tendermint.com>"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@stylistic/eslint-plugin-ts": "^4.2.0",
+    "@types/node": "^22.14.0",
+    "@types/stream-chain": "^2.1.0",
+    "@types/stream-json": "^1.7.8",
+    "@types/uuid": "^10.0.0",
+    "eslint": "^9.24.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.29.0",
+    "vitest": "^3.1.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@cosmjs/tendermint-rpc": "^0.33.1",
+    "bech32": "^2.0.0",
+    "cosmjs-types": "^0.9.0",
+    "dayjs": "^1.11.13",
+    "fastify": "^5.2.2",
+    "stream-chain": "^3.4.0",
+    "stream-json": "^1.9.1",
+    "uuid": "^11.1.0",
+    "winston": "^3.17.0"
+  }
+}