envio/src/InMemoryStore.res.js

A latency and sync speed optimized, developer friendly blockchain data indexer.

// Generated by ReScript, PLEASE EDIT WITH CARE
'use strict';

var $$Array = require("rescript/lib/js/array.js");
var Utils = require("./Utils.res.js");
var Js_dict = require("rescript/lib/js/js_dict.js");
var Belt_Array = require("rescript/lib/js/belt_Array.js");
var EventUtils = require("./EventUtils.res.js");
var ErrorHandling = require("./ErrorHandling.res.js");
var InMemoryTable = require("./InMemoryTable.res.js");
var InternalTable = require("./db/InternalTable.res.js");
var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");

function hashRawEventsKey(key) {
  return EventUtils.getEventIdKeyString(key.chainId, key.eventId);
}

var UndefinedEntity = /* @__PURE__ */Caml_exceptions.create("InMemoryStore.EntityTables.UndefinedEntity");

function make(entities) {
  var init = {};
  Belt_Array.forEach(entities, (function (entityConfig) {
          init[entityConfig.name] = InMemoryTable.Entity.make();
        }));
  return init;
}

function get(self, entityName) {
  var table = self[entityName];
  if (table !== undefined) {
    return table;
  } else {
    return ErrorHandling.mkLogAndRaise(undefined, "Unexpected, entity InMemoryTable is undefined", {
                RE_EXN_ID: UndefinedEntity,
                entityName: entityName
              });
  }
}

function clone(self) {
  return Js_dict.fromArray(Belt_Array.map(Js_dict.entries(self), (function (param) {
                    return [
                            param[0],
                            InMemoryTable.Entity.clone(param[1])
                          ];
                  })));
}

var EntityTables = {
  UndefinedEntity: UndefinedEntity,
  make: make,
  get: get,
  clone: clone
};

function make$1(entities, rollbackTargetCheckpointId) {
  return {
          rawEvents: InMemoryTable.make(hashRawEventsKey),
          entities: make(entities),
          effects: {},
          rollbackTargetCheckpointId: rollbackTargetCheckpointId
        };
}

function clone$1(self) {
  return {
          rawEvents: InMemoryTable.clone(self.rawEvents),
          entities: clone(self.entities),
          effects: Js_dict.map((function (table) {
                  return {
                          idsToStore: $$Array.copy(table.idsToStore),
                          invalidationsCount: table.invalidationsCount,
                          dict: Utils.Dict.shallowCopy(table.dict),
                          effect: table.effect
                        };
                }), self.effects),
          rollbackTargetCheckpointId: self.rollbackTargetCheckpointId
        };
}

function getEffectInMemTable(inMemoryStore, effect) {
  var key = effect.name;
  var table = inMemoryStore.effects[key];
  if (table !== undefined) {
    return table;
  }
  var table$1 = {
    idsToStore: [],
    invalidationsCount: 0,
    dict: {},
    effect: effect
  };
  inMemoryStore.effects[key] = table$1;
  return table$1;
}

function getInMemTable(inMemoryStore, entityConfig) {
  return get(inMemoryStore.entities, entityConfig.name);
}

function isRollingBack(inMemoryStore) {
  return inMemoryStore.rollbackTargetCheckpointId !== undefined;
}

function setBatchDcs(inMemoryStore, batch, shouldSaveHistory) {
  var inMemTable = getInMemTable(inMemoryStore, InternalTable.DynamicContractRegistry.config);
  var itemIdx = 0;
  for(var checkpoint = 0 ,checkpoint_finish = batch.checkpointIds.length; checkpoint < checkpoint_finish; ++checkpoint){
    var checkpointId = batch.checkpointIds[checkpoint];
    var chainId = batch.checkpointChainIds[checkpoint];
    var checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpoint];
    for(var idx = 0; idx < checkpointEventsProcessed; ++idx){
      var item = batch.items[itemIdx + idx | 0];
      var dcs = item.dcs;
      if (dcs !== undefined) {
        for(var dcIdx = 0 ,dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx){
          var dc = dcs[dcIdx];
          var entity_id = InternalTable.DynamicContractRegistry.makeId(chainId, dc.address);
          var entity_registering_event_block_number = item.blockNumber;
          var entity_registering_event_log_index = item.logIndex;
          var entity_registering_event_block_timestamp = item.timestamp;
          var entity_registering_event_contract_name = item.eventConfig.contractName;
          var entity_registering_event_name = item.eventConfig.name;
          var entity_registering_event_src_address = item.event.srcAddress;
          var entity_contract_address = dc.address;
          var entity_contract_name = dc.contractName;
          var entity = {
            id: entity_id,
            chain_id: chainId,
            registering_event_block_number: entity_registering_event_block_number,
            registering_event_log_index: entity_registering_event_log_index,
            registering_event_block_timestamp: entity_registering_event_block_timestamp,
            registering_event_contract_name: entity_registering_event_contract_name,
            registering_event_name: entity_registering_event_name,
            registering_event_src_address: entity_registering_event_src_address,
            contract_address: entity_contract_address,
            contract_name: entity_contract_name
          };
          InMemoryTable.Entity.set(inMemTable, {
                entityId: entity_id,
                entityUpdateAction: {
                  TAG: "Set",
                  _0: entity
                },
                checkpointId: checkpointId
              }, shouldSaveHistory, undefined);
        }
      }
      
    }
    itemIdx = itemIdx + checkpointEventsProcessed | 0;
  }
}

exports.hashRawEventsKey = hashRawEventsKey;
exports.EntityTables = EntityTables;
exports.make = make$1;
exports.clone = clone$1;
exports.getEffectInMemTable = getEffectInMemTable;
exports.getInMemTable = getInMemTable;
exports.isRollingBack = isRollingBack;
exports.setBatchDcs = setBatchDcs;
/* Utils Not a pure module */