envio 3.6.1 → 3.7.0-subgraph

package/src/MemoryStorage.res.mjs

@@ -0,0 +1,623 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Table from "./db/Table.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as Config from "./Config.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
+import * as EntityId from "./EntityId.res.mjs";
+import * as Internal from "./Internal.res.mjs";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
+import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as InternalTable from "./db/InternalTable.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+
+function make() {
+  return {
+    entities: {},
+    entityConfigs: {},
+    history: {},
+    checkpoints: [],
+    chains: {},
+    cache: {},
+    effectCache: {},
+    envioInfo: undefined,
+    isInitialized: false
+  };
+}
+
+function rowKey(scope, entityId) {
+  if (scope === "crossChain") {
+    return EntityId.toKey(entityId);
+  } else {
+    return ChainId.toString(scope) + `|` + EntityId.toKey(entityId);
+  }
+}
+
+let historyKey = rowKey;
+
+function readChainId(entity, field) {
+  return entity[field.fieldName];
+}
+
+function copyEntity(entity) {
+  return Utils.Dict.shallowCopy(entity);
+}
+
+function getEntityDict(state, name) {
+  let dict = state.entities[name];
+  if (dict !== undefined) {
+    return dict;
+  }
+  let dict$1 = {};
+  state.entities[name] = dict$1;
+  return dict$1;
+}
+
+function getHistory(state, name) {
+  let rows = state.history[name];
+  if (rows !== undefined) {
+    return rows;
+  }
+  let rows$1 = [];
+  state.history[name] = rows$1;
+  return rows$1;
+}
+
+function registerEntities(state, entities) {
+  entities.forEach(entityConfig => {
+    state.entityConfigs[entityConfig.name] = entityConfig;
+    state.entityConfigs[entityConfig.table.tableName] = entityConfig;
+    getEntityDict(state, entityConfig.name);
+  });
+}
+
+function seedIndexingAddresses(state, chainConfigs) {
+  let dict = getEntityDict(state, Config.EnvioAddresses.name);
+  chainConfigs.forEach(chainConfig => {
+    chainConfig.contracts.forEach(contract => {
+      contract.addresses.forEach(address => {
+        let entity_id = Config.EnvioAddresses.makeId(chainConfig.id, address);
+        let entity_chain_id = chainConfig.id;
+        let entity_contract_name = contract.name;
+        let entity = {
+          id: entity_id,
+          chain_id: entity_chain_id,
+          registration_block: -1,
+          registration_log_index: -1,
+          contract_name: entity_contract_name
+        };
+        dict[entity_id] = entity;
+      });
+    });
+  });
+}
+
+function toIndexingAddress(dc) {
+  return {
+    address: Config.EnvioAddresses.getAddress(dc),
+    contractName: dc.contract_name,
+    registrationBlock: dc.registration_block
+  };
+}
+
+function getIndexingAddressesByChain(state) {
+  let byChain = {};
+  let dcDict = state.entities[Config.EnvioAddresses.name];
+  if (dcDict !== undefined) {
+    Object.values(dcDict).forEach(entity => {
+      let chainIdStr = ChainId.toString(entity.chain_id);
+      let arr = byChain[chainIdStr];
+      let contracts;
+      if (arr !== undefined) {
+        contracts = arr;
+      } else {
+        let arr$1 = [];
+        byChain[chainIdStr] = arr$1;
+        contracts = arr$1;
+      }
+      contracts.push(toIndexingAddress(entity));
+    });
+  }
+  return byChain;
+}
+
+function toInitialChainStates(state) {
+  let addressesByChain = getIndexingAddressesByChain(state);
+  return Object.values(state.chains).map(chain => ({
+    id: chain.id,
+    startBlock: chain.startBlock,
+    endBlock: chain.endBlock,
+    maxReorgDepth: chain.maxReorgDepth,
+    progressBlockNumber: chain.progressBlockNumber,
+    numEventsProcessed: chain.numEventsProcessed,
+    firstEventBlockNumber: chain.firstEventBlockNumber,
+    timestampCaughtUpToHeadOrEndblock: chain.timestampCaughtUpToHeadOrEndblock,
+    indexingAddresses: Stdlib_Option.getOr(addressesByChain[ChainId.toString(chain.id)], []),
+    sourceBlockNumber: chain.sourceBlockNumber
+  }));
+}
+
+function committedCheckpointId(state) {
+  return Stdlib_Array.reduce(state.checkpoints, InternalTable.Checkpoints.initialCheckpointId, (max, cp) => {
+    if (cp.id > max) {
+      return cp.id;
+    } else {
+      return max;
+    }
+  });
+}
+
+function reorgCheckpoints(state) {
+  return Stdlib_Array.filterMap(state.checkpoints, cp => {
+    let match = cp.blockHash;
+    let match$1 = state.chains[ChainId.toString(cp.chainId)];
+    if (match === undefined) {
+      return;
+    }
+    if (match$1 === undefined) {
+      return;
+    }
+    let safeBlock = match$1.sourceBlockNumber - match$1.maxReorgDepth | 0;
+    if (match$1.maxReorgDepth > 0 && match$1.progressBlockNumber > safeBlock && cp.blockNumber >= safeBlock) {
+      return {
+        id: cp.id,
+        chain_id: cp.chainId,
+        block_number: cp.blockNumber,
+        block_hash: match
+      };
+    }
+  });
+}
+
+function toInitialState(state, cleanRun) {
+  return {
+    cleanRun: cleanRun,
+    cache: state.cache,
+    chains: toInitialChainStates(state),
+    checkpointId: committedCheckpointId(state),
+    reorgCheckpoints: reorgCheckpoints(state),
+    envioInfo: state.envioInfo
+  };
+}
+
+function handleLoad(state, tableName, filter) {
+  let entityConfig = state.entityConfigs[tableName];
+  if (entityConfig !== undefined) {
+    let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
+    let matched = Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
+    let field = Table.getChainIdField(entityConfig.table);
+    if (field !== undefined) {
+      return matched.map(entity => {
+        let copy = Utils.Dict.shallowCopy(entity);
+        Utils.Dict.deleteInPlace(copy, field.fieldName);
+        return copy;
+      });
+    } else {
+      return matched;
+    }
+  }
+  let cacheDict = state.effectCache[tableName];
+  if (cacheDict !== undefined) {
+    return Object.values(cacheDict).filter(item => EntityFilter.matches(filter, item));
+  } else {
+    return [];
+  }
+}
+
+function backfillHistory(state, entityConfig, scope, entityId, rows) {
+  let key = rowKey(scope, entityId);
+  if (rows.some(row => rowKey(row.scope, row.entityId) === key)) {
+    return;
+  }
+  let entity = Stdlib_Option.flatMap(state.entities[entityConfig.name], dict => dict[rowKey(scope, entityId)]);
+  if (entity !== undefined) {
+    rows.push({
+      entityId: entityId,
+      scope: scope,
+      checkpointId: InternalTable.Checkpoints.initialCheckpointId,
+      action: "SET",
+      entity: entity
+    });
+    return;
+  }
+}
+
+function applyRollback(state, targetCheckpointId) {
+  state.checkpoints = state.checkpoints.filter(cp => cp.id <= targetCheckpointId);
+  Object.entries(state.history).forEach(param => {
+    state.history[param[0]] = param[1].filter(row => row.checkpointId <= targetCheckpointId);
+  });
+}
+
+function writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedEntities, updatedEffectsCache, chainMetaData) {
+  let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
+  if (rollback !== undefined) {
+    applyRollback(state, rollback.targetCheckpointId);
+  }
+  let diffCheckpointId = Stdlib_Option.map(rollback, param => param.diffCheckpointId);
+  let isDiff = change => {
+    if (diffCheckpointId !== undefined) {
+      return change.checkpointId === diffCheckpointId;
+    } else {
+      return false;
+    }
+  };
+  updatedEntities.forEach(param => {
+    let changes = param.changes;
+    let scope = param.scope;
+    let entityConfig = param.entityConfig;
+    let entityDict = getEntityDict(state, entityConfig.name);
+    let historyRows = getHistory(state, entityConfig.name);
+    let chainIdField = Table.getChainIdField(entityConfig.table);
+    let idsWithDiff = new Set();
+    changes.forEach(change => {
+      if (isDiff(change)) {
+        idsWithDiff.add(EntityId.toKey(change.entityId));
+        return;
+      }
+    });
+    changes.forEach(change => {
+      let entityId = change.entityId;
+      let shouldSaveChangeHistory = shouldSaveHistory && !isDiff(change);
+      if (shouldSaveHistory && !idsWithDiff.has(EntityId.toKey(entityId))) {
+        backfillHistory(state, entityConfig, scope, entityId, historyRows);
+      }
+      if (change.type === "SET") {
+        let entity = change.entity;
+        let match = Internal.chainScopeChainId(scope);
+        let storedEntity = chainIdField !== undefined && match !== undefined ? Internal.stampChainId(entity, chainIdField.fieldName, Primitive_option.valFromOption(match)) : entity;
+        entityDict[rowKey(scope, entityId)] = storedEntity;
+        if (shouldSaveChangeHistory) {
+          historyRows.push({
+            entityId: entityId,
+            scope: scope,
+            checkpointId: change.checkpointId,
+            action: "SET",
+            entity: storedEntity
+          });
+          return;
+        } else {
+          return;
+        }
+      }
+      Utils.Dict.deleteInPlace(entityDict, rowKey(scope, entityId));
+      if (shouldSaveChangeHistory) {
+        historyRows.push({
+          entityId: entityId,
+          scope: scope,
+          checkpointId: change.checkpointId,
+          action: "DELETE",
+          entity: undefined
+        });
+        return;
+      }
+    });
+  });
+  Object.values(batch.progressedChainsById).forEach(chainAfterBatch => {
+    let key = ChainId.toString(chainAfterBatch.fetchState.chainId);
+    let chain = state.chains[key];
+    if (chain !== undefined) {
+      chain.progressBlockNumber = chainAfterBatch.progressBlockNumber;
+      chain.sourceBlockNumber = chainAfterBatch.sourceBlockNumber;
+      chain.numEventsProcessed = chainAfterBatch.totalEventsProcessed;
+      return;
+    }
+  });
+  if (chainMetaData !== undefined) {
+    Object.entries(chainMetaData).forEach(param => {
+      let meta = param[1];
+      let chain = state.chains[param[0]];
+      if (chain !== undefined) {
+        chain.firstEventBlockNumber = Primitive_option.fromNull(meta.first_event_block);
+        chain.latestFetchedBlockNumber = meta.buffer_block;
+        chain.timestampCaughtUpToHeadOrEndblock = Primitive_option.fromNull(meta.ready_at);
+        return;
+      }
+    });
+  }
+  if (shouldSaveHistory) {
+    for (let i = 0, i_finish = batch.checkpointIds.length; i < i_finish; ++i) {
+      state.checkpoints.push({
+        id: batch.checkpointIds[i],
+        chainId: batch.checkpointChainIds[i],
+        blockNumber: batch.checkpointBlockNumbers[i],
+        blockHash: Primitive_option.fromNull(batch.checkpointBlockHashes[i]),
+        eventsProcessed: batch.checkpointEventsProcessed[i]
+      });
+    }
+  }
+  updatedEffectsCache.forEach(param => {
+    let table = param.table;
+    let dict = state.effectCache[table.tableName];
+    let cacheDict;
+    if (dict !== undefined) {
+      cacheDict = dict;
+    } else {
+      let dict$1 = {};
+      state.effectCache[table.tableName] = dict$1;
+      cacheDict = dict$1;
+    }
+    param.items.forEach(item => {
+      cacheDict[item.id] = item;
+    });
+    let record = state.cache[table.tableName];
+    if (record !== undefined) {
+      record.count = Object.keys(cacheDict).length;
+      return;
+    }
+  });
+}
+
+function getRollbackData(state, entityConfig, rollbackTargetCheckpointId) {
+  let rows = Stdlib_Option.getOr(state.history[entityConfig.name], []);
+  let changedKeys = {};
+  rows.forEach(row => {
+    if (row.checkpointId > rollbackTargetCheckpointId) {
+      changedKeys[rowKey(row.scope, row.entityId)] = row;
+      return;
+    }
+  });
+  let removals = [];
+  let restored = [];
+  Object.entries(changedKeys).forEach(param => {
+    let changedRow = param[1];
+    let key = param[0];
+    let preTarget = Stdlib_Array.reduce(rows, undefined, (latest, row) => {
+      if (rowKey(row.scope, row.entityId) === key && row.checkpointId <= rollbackTargetCheckpointId && !(latest !== undefined && latest.checkpointId >= row.checkpointId)) {
+        return row;
+      } else {
+        return latest;
+      }
+    });
+    if (preTarget !== undefined) {
+      if (preTarget.action === "SET") {
+        let entity = preTarget.entity;
+        if (entity !== undefined) {
+          restored.push(entity);
+          return;
+        } else {
+          return;
+        }
+      }
+      removals.push({
+        entityId: preTarget.entityId,
+        scope: preTarget.scope
+      });
+      return;
+    }
+    removals.push({
+      entityId: changedRow.entityId,
+      scope: changedRow.scope
+    });
+  });
+  return [
+    removals,
+    restored
+  ];
+}
+
+function getRollbackProgressDiff(state, rollbackTargetCheckpointId) {
+  let byChain = {};
+  state.checkpoints.forEach(cp => {
+    if (cp.id <= rollbackTargetCheckpointId) {
+      return;
+    }
+    let key = ChainId.toString(cp.chainId);
+    let acc = byChain[key];
+    if (acc !== undefined) {
+      acc.eventsProcessed = acc.eventsProcessed + cp.eventsProcessed | 0;
+      acc.newProgressBlockNumber = Math.min(acc.newProgressBlockNumber, cp.blockNumber - 1 | 0);
+    } else {
+      byChain[key] = {
+        chainId: cp.chainId,
+        eventsProcessed: cp.eventsProcessed,
+        newProgressBlockNumber: cp.blockNumber - 1 | 0
+      };
+    }
+  });
+  return Object.values(byChain).map(acc => ({
+    chain_id: acc.chainId,
+    events_processed_diff: acc.eventsProcessed.toString(),
+    new_progress_block_number: acc.newProgressBlockNumber
+  }));
+}
+
+function toStorage(state, config) {
+  return {
+    name: "memory",
+    isInitialized: async () => state.isInitialized,
+    initialize: async (chainConfigsOpt, entitiesOpt, $staropt$star, envioInfo) => {
+      let chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
+      let entities = entitiesOpt !== undefined ? entitiesOpt : [];
+      $staropt$star !== undefined;
+      registerEntities(state, entities);
+      seedIndexingAddresses(state, chainConfigs);
+      chainConfigs.forEach(chainConfig => {
+        state.chains[ChainId.toString(chainConfig.id)] = {
+          id: chainConfig.id,
+          startBlock: chainConfig.startBlock,
+          endBlock: chainConfig.endBlock,
+          maxReorgDepth: chainConfig.maxReorgDepth,
+          progressBlockNumber: -1,
+          sourceBlockNumber: 0,
+          numEventsProcessed: 0,
+          firstEventBlockNumber: undefined,
+          latestFetchedBlockNumber: 0,
+          timestampCaughtUpToHeadOrEndblock: undefined
+        };
+      });
+      state.envioInfo = envioInfo;
+      state.isInitialized = true;
+      return toInitialState(state, true);
+    },
+    resumeInitialState: async () => toInitialState(state, false),
+    loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
+    ensureQueryIndexes: async (param, param$1) => {},
+    ensureSchemaIndexes: async param => {},
+    finalizeBackfill: async (param, chainIds, readyAt) => {
+      chainIds.forEach(chainId => {
+        let chain = state.chains[ChainId.toString(chainId)];
+        if (chain !== undefined) {
+          chain.timestampCaughtUpToHeadOrEndblock = readyAt;
+          return;
+        }
+      });
+    },
+    dumpEffectCache: async () => {},
+    reset: async () => {
+      let clear = dict => {
+        Object.keys(dict).forEach(key => Utils.Dict.deleteInPlace(dict, key));
+      };
+      clear(state.entities);
+      clear(state.history);
+      clear(state.chains);
+      clear(state.effectCache);
+      clear(state.cache);
+      state.checkpoints = [];
+      state.envioInfo = undefined;
+      state.isInitialized = false;
+    },
+    setChainMeta: async chainsData => {
+      Object.entries(chainsData).forEach(param => {
+        let meta = param[1];
+        let chain = state.chains[param[0]];
+        if (chain !== undefined) {
+          chain.firstEventBlockNumber = Primitive_option.fromNull(meta.first_event_block);
+          chain.latestFetchedBlockNumber = meta.buffer_block;
+          chain.timestampCaughtUpToHeadOrEndblock = Primitive_option.fromNull(meta.ready_at);
+          return;
+        }
+      });
+      return undefined;
+    },
+    pruneStaleCheckpoints: async safeCheckpointId => {
+      state.checkpoints = state.checkpoints.filter(cp => cp.id >= safeCheckpointId);
+    },
+    pruneStaleEntityHistory: async (entityName, param, param$1, safeCheckpointId) => {
+      let rows = state.history[entityName];
+      if (rows === undefined) {
+        return;
+      }
+      let newestBelow = {};
+      rows.forEach(row => {
+        if (row.checkpointId >= safeCheckpointId) {
+          return;
+        }
+        let key = rowKey(row.scope, row.entityId);
+        let current = newestBelow[key];
+        if (current !== undefined && current.checkpointId >= row.checkpointId) {
+          return;
+        } else {
+          newestBelow[key] = row;
+          return;
+        }
+      });
+      state.history[entityName] = rows.filter(row => {
+        let key = rowKey(row.scope, row.entityId);
+        if (row.checkpointId >= safeCheckpointId) {
+          return true;
+        }
+        let kept = newestBelow[key];
+        if (kept !== undefined) {
+          return kept === row;
+        } else {
+          return false;
+        }
+      });
+    },
+    getRollbackTargetCheckpoint: async (reorgChainId, lastKnownValidBlockNumber) => Stdlib_Array.reduce(state.checkpoints, undefined, (target, cp) => {
+      if (Primitive_object.equal(cp.chainId, reorgChainId) && cp.blockNumber <= lastKnownValidBlockNumber && !(target !== undefined && target >= cp.id)) {
+        return cp.id;
+      } else {
+        return target;
+      }
+    }),
+    getRollbackProgressDiff: async rollbackTargetCheckpointId => getRollbackProgressDiff(state, rollbackTargetCheckpointId),
+    getRollbackData: async (entityConfig, rollbackTargetCheckpointId) => getRollbackData(state, entityConfig, rollbackTargetCheckpointId),
+    writeBatch: async (batch, rollback, isInReorgThreshold, param, param$1, updatedEffectsCache, updatedEntities, chainMetaData, param$2) => writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedEntities, updatedEffectsCache, chainMetaData),
+    close: async () => {}
+  };
+}
+
+function currentRows(state, entityConfig) {
+  return Object.values(Stdlib_Option.getOr(state.entities[entityConfig.name], {}));
+}
+
+function historyChanges(state, entityConfig) {
+  return Stdlib_Option.getOr(state.history[entityConfig.name], []).map(row => {
+    let match = row.action;
+    if (match === "SET") {
+      return {
+        type: "SET",
+        entityId: row.entityId,
+        entity: Stdlib_Option.getOr(row.entity, {}),
+        checkpointId: row.checkpointId
+      };
+    } else {
+      return {
+        type: "DELETE",
+        entityId: row.entityId,
+        checkpointId: row.checkpointId
+      };
+    }
+  }).toSorted((a, b) => {
+    let order = Primitive_string.compare(EntityId.toKey(a.entityId), EntityId.toKey(b.entityId));
+    if (order !== 0) {
+      return order;
+    } else {
+      return Primitive_float.compare(Number(a.checkpointId), Number(b.checkpointId));
+    }
+  });
+}
+
+function checkpointRows(state) {
+  return state.checkpoints.map(cp => ({
+    id: cp.id,
+    chain_id: cp.chainId,
+    block_number: cp.blockNumber,
+    block_hash: Stdlib_Null.fromOption(cp.blockHash),
+    events_processed: cp.eventsProcessed
+  }));
+}
+
+function effectCacheRows(state, tableName) {
+  return Object.values(Stdlib_Option.getOr(state.effectCache[tableName], {})).map(item => ({
+    id: item.id,
+    output: item.output
+  }));
+}
+
+export {
+  make,
+  rowKey,
+  historyKey,
+  readChainId,
+  copyEntity,
+  getEntityDict,
+  getHistory,
+  registerEntities,
+  seedIndexingAddresses,
+  toIndexingAddress,
+  getIndexingAddressesByChain,
+  toInitialChainStates,
+  committedCheckpointId,
+  reorgCheckpoints,
+  toInitialState,
+  handleLoad,
+  backfillHistory,
+  applyRollback,
+  writeBatch,
+  getRollbackData,
+  getRollbackProgressDiff,
+  toStorage,
+  currentRows,
+  historyChanges,
+  checkpointRows,
+  effectCacheRows,
+}
+/* Table Not a pure module */

package/src/Persistence.res

@@ -147,11 +147,13 @@ type storage = {
       "new_progress_block_number": int,
     }>,
   >,
-  // Get rollback data for entity
+  // Rollback data for an entity, as decoded entities rather than storage rows:
+  // only the storage knows how it encoded them, so each one decodes its own
+  // before handing them back.
   getRollbackData: (
     ~entityConfig: Internal.entityConfig,
     ~rollbackTargetCheckpointId: Internal.checkpointId,
-  ) => promise<(array<rollbackRemoval>, array<unknown>)>,
+  ) => promise<(array<rollbackRemoval>, array<Internal.entity>)>,
   // Write batch to storage
   writeBatch: (
     ~batch: Batch.t,