envio 3.2.1 → 3.3.0-alpha.0

package/src/Internal.res

@@ -269,12 +269,15 @@ type genericEvent<'params, 'block, 'transaction> = {
 // (blockNumber, timestamp, blockHash) live on the item instead.
 type event
 
-external fromGenericEvent: genericEvent<'a, 'b, 'c> => event = "%identity"
+// Opaque payload an item carries. A source builds an ecosystem-specific
+// concrete payload (see `Evm.payload` / `Fuel.payload`) and erases it to this
+// type; consumers never read it directly — the ecosystem converts it back to
+// its own payload to produce the user-facing `event`, a logger, or a raw
+// event. The concrete payload types deliberately live in the ecosystem
+// modules, not here, and are distinct per ecosystem.
+type eventPayload
 
-// Escape hatch for serialization boundaries (raw events, logging)
-// which genuinely need the runtime shape.
-external toGenericEvent: event => genericEvent<eventParams, eventBlock, eventTransaction> =
-  "%identity"
+external payloadToEvent: eventPayload => event = "%identity"
 
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
@@ -373,7 +376,7 @@ type eventConfig = private {
   // number, drops an event whose param-address isn't registered at/before that
   // block — the param-level analogue of EventRouter's srcAddress
   // `effectiveStartBlock` check. Absent otherwise.
-  clientAddressFilter?: (event, int, dict<indexingContract>) => bool,
+  clientAddressFilter?: (eventPayload, int, dict<indexingContract>) => bool,
   handler: option<handler>,
   contractRegister: option<contractRegister>,
   paramsRawEventSchema: S.schema<eventParams>,
@@ -499,7 +502,25 @@ type eventItem = private {
   blockNumber: int,
   blockHash: string,
   logIndex: int,
-  event: event,
+  payload: eventPayload,
+}
+
+// Row shape for the `raw_events` table. Defined here (rather than in
+// `InternalTable`) so the ecosystem's `toRawEvent` can reference it without
+// pulling in `InternalTable`'s dependency on `Config`.
+type rawEvent = {
+  chain_id: int,
+  event_id: bigint,
+  event_name: string,
+  contract_name: string,
+  block_number: int,
+  log_index: int,
+  src_address: Address.t,
+  block_hash: string,
+  block_timestamp: int,
+  block_fields: JSON.t,
+  transaction_fields: JSON.t,
+  params: JSON.t,
 }
 
 // Opaque type to support both EVM and other ecosystems
@@ -533,7 +554,7 @@ type item =
       blockNumber: int,
       blockHash: string,
       logIndex: int,
-      event: event,
+      payload: eventPayload,
     })
   | @as(1) Block({onBlockConfig: onBlockConfig, blockNumber: int, logIndex: int})
 

package/src/LoadLayer.res

@@ -2,19 +2,20 @@ let loadById = (
   ~loadManager,
   ~persistence: Persistence.t,
   ~entityConfig: Internal.entityConfig,
-  ~inMemoryStore,
+  ~indexerState,
   ~shouldGroup,
   ~item,
+  ~ecosystem,
   ~entityId,
 ) => {
   let key = `${entityConfig.name}.get`
-  let inMemTable = inMemoryStore->InMemoryStore.getInMemTable(~entityConfig)
+  let inMemTable = indexerState->InMemoryStore.getInMemTable(~entityConfig)
 
   let load = async (idsToLoad, ~onError as _) => {
     let storage = persistence->Persistence.getInitializedStorageOrThrow
     let timerRef = Prometheus.StorageLoad.startOperation(~storage=storage.name, ~operation=key)
 
-    // Since LoadManager.call prevents registerign entities already existing in the inMemoryStore,
+    // Since LoadManager.call prevents registering entities already in the in-memory store,
     // we can be sure that we load only the new ones.
     let dbEntities = try {
       (
@@ -28,7 +29,10 @@ let loadById = (
       )->(Utils.magic: array<unknown> => array<Internal.entity>)
     } catch {
     | Persistence.StorageError({message, reason}) =>
-      reason->ErrorHandling.mkLogAndRaise(~logger=item->Logging.getItemLogger, ~msg=message)
+      reason->ErrorHandling.mkLogAndRaise(
+        ~logger=Ecosystem.getItemLogger(item, ~ecosystem),
+        ~msg=message,
+      )
     }
 
     let entitiesMap = Dict.make()
@@ -40,7 +44,7 @@ let loadById = (
     }
     idsToLoad->Array.forEach(entityId => {
       inMemTable->InMemoryTable.Entity.initValue(
-        ~committedCheckpointId=inMemoryStore.committedCheckpointId,
+        ~committedCheckpointId=indexerState->IndexerState.committedCheckpointId,
         ~key=entityId,
         ~entity=entitiesMap->Utils.Dict.dangerouslyGetNonOption(entityId),
       )
@@ -68,7 +72,7 @@ let loadById = (
 let callEffect = (
   ~effect: Internal.effect,
   ~arg: Internal.effectArgs,
-  ~inMemTable: InMemoryStore.effectCacheInMemTable,
+  ~inMemTable: IndexerState.effectCacheInMemTable,
   ~timerRef,
   ~onError,
 ) => {
@@ -245,13 +249,14 @@ let loadEffect = (
   ~persistence: Persistence.t,
   ~effect: Internal.effect,
   ~effectArgs,
-  ~inMemoryStore,
+  ~indexerState,
   ~shouldGroup,
   ~item,
+  ~ecosystem,
 ) => {
   let effectName = effect.name
   let key = `${effectName}.effect`
-  let inMemTable = inMemoryStore->InMemoryStore.getEffectInMemTable(~effect)
+  let inMemTable = indexerState->InMemoryStore.getEffectInMemTable(~effect)
 
   let load = async (args, ~onError) => {
     let idsToLoad = args->Array.map((arg: Internal.effectArgs) => arg.cacheKey)
@@ -279,9 +284,7 @@ let loadEffect = (
         )->(Utils.magic: array<unknown> => array<Internal.effectCacheItem>)
       } catch {
       | exn =>
-        item
-        ->Logging.getItemLogger
-        ->Logging.childWarn({
+        Ecosystem.getItemLogger(item, ~ecosystem)->Logging.childWarn({
           "msg": `Failed to load cache effect cache. The indexer will continue working, but the effect will not be able to use the cache.`,
           "err": exn->Utils.prettifyExn,
           "effect": effectName,
@@ -298,9 +301,7 @@ let loadEffect = (
         | S.Raised(error) =>
           inMemTable.invalidationsCount = inMemTable.invalidationsCount + 1
           Prometheus.EffectCacheInvalidationsCount.increment(~effectName)
-          item
-          ->Logging.getItemLogger
-          ->Logging.childTrace({
+          Ecosystem.getItemLogger(item, ~ecosystem)->Logging.childTrace({
             "msg": "Invalidated effect cache",
             "input": dbEntity.id,
             "effect": effectName,
@@ -354,13 +355,14 @@ let loadByFilter = (
   ~loadManager,
   ~persistence: Persistence.t,
   ~entityConfig: Internal.entityConfig,
-  ~inMemoryStore,
+  ~indexerState,
   ~shouldGroup,
   ~item,
+  ~ecosystem,
   ~filter: EntityFilter.t,
 ) => {
   let key = filter->EntityFilter.toOperationKey(~entityName=entityConfig.name)
-  let inMemTable = inMemoryStore->InMemoryStore.getInMemTable(~entityConfig)
+  let inMemTable = indexerState->InMemoryStore.getInMemTable(~entityConfig)
 
   let load = async (filters: array<EntityFilter.t>, ~onError as _) => {
     let storage = persistence->Persistence.getInitializedStorageOrThrow
@@ -385,7 +387,7 @@ let loadByFilter = (
 
         entities->Array.forEach(entity => {
           inMemTable->InMemoryTable.Entity.initValue(
-            ~committedCheckpointId=inMemoryStore.committedCheckpointId,
+            ~committedCheckpointId=indexerState->IndexerState.committedCheckpointId,
             ~key=entity.id,
             ~entity=Some(entity),
           )
@@ -396,7 +398,7 @@ let loadByFilter = (
       | Persistence.StorageError({message, reason}) =>
         reason->ErrorHandling.mkLogAndRaise(
           ~logger=Logging.createChildFrom(
-            ~logger=item->Logging.getItemLogger,
+            ~logger=Ecosystem.getItemLogger(item, ~ecosystem),
             // The executed query might be merged from multiple getWhere
             // calls, so report it as the operation users write with the
             // values bound to its placeholders, instead of an internal

package/src/LoadLayer.res.mjs

@@ -4,10 +4,12 @@ import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as LoadManager from "./LoadManager.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
@@ -15,9 +17,9 @@ import * as InMemoryTable from "./InMemoryTable.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function loadById(loadManager, persistence, entityConfig, inMemoryStore, shouldGroup, item, entityId) {
+function loadById(loadManager, persistence, entityConfig, indexerState, shouldGroup, item, ecosystem, entityId) {
   let key = entityConfig.name + `.get`;
-  let inMemTable = InMemoryStore.getInMemTable(inMemoryStore, entityConfig);
+  let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig);
   let load = async (idsToLoad, param) => {
     let storage = Persistence.getInitializedStorageOrThrow(persistence);
     let timerRef = Prometheus.StorageLoad.startOperation(storage.name, key);
@@ -31,7 +33,7 @@ function loadById(loadManager, persistence, entityConfig, inMemoryStore, shouldG
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       if (exn.RE_EXN_ID === Persistence.StorageError) {
-        dbEntities = ErrorHandling.mkLogAndRaise(Logging.getItemLogger(item), exn.message, exn.reason);
+        dbEntities = ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(item, ecosystem), exn.message, exn.reason);
       } else {
         throw exn;
       }
@@ -41,7 +43,7 @@ function loadById(loadManager, persistence, entityConfig, inMemoryStore, shouldG
       let entity = dbEntities[idx];
       entitiesMap[entity.id] = entity;
     }
-    idsToLoad.forEach(entityId => InMemoryTable.Entity.initValue(inMemTable, inMemoryStore.committedCheckpointId, entityId, entitiesMap[entityId]));
+    idsToLoad.forEach(entityId => InMemoryTable.Entity.initValue(inMemTable, IndexerState.committedCheckpointId(indexerState), entityId, entitiesMap[entityId]));
     return Prometheus.StorageLoad.endOperation(timerRef, storage.name, key, idsToLoad.length, dbEntities.length);
   };
   return LoadManager.call(loadManager, entityId, key, load, LoadManager.noopHasher, shouldGroup, hash => hash in inMemTable.latestEntityChangeById, InMemoryTable.Entity.getUnsafe(inMemTable));
@@ -126,10 +128,10 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
   return Promise.all(promises);
 }
 
-function loadEffect(loadManager, persistence, effect, effectArgs, inMemoryStore, shouldGroup, item) {
+function loadEffect(loadManager, persistence, effect, effectArgs, indexerState, shouldGroup, item, ecosystem) {
   let effectName = effect.name;
   let key = effectName + `.effect`;
-  let inMemTable = InMemoryStore.getEffectInMemTable(inMemoryStore, effect);
+  let inMemTable = InMemoryStore.getEffectInMemTable(indexerState, effect);
   let load = async (args, onError) => {
     let idsToLoad = args.map(arg => arg.cacheKey);
     let idsFromCache = new Set();
@@ -150,7 +152,7 @@ function loadEffect(loadManager, persistence, effect, effectArgs, inMemoryStore,
         }, match$1.table);
       } catch (raw_exn) {
         let exn = Primitive_exceptions.internalToException(raw_exn);
-        Logging.childWarn(Logging.getItemLogger(item), {
+        Logging.childWarn(Ecosystem.getItemLogger(item, ecosystem), {
           msg: `Failed to load cache effect cache. The indexer will continue working, but the effect will not be able to use the cache.`,
           err: Utils.prettifyExn(exn),
           effect: effectName
@@ -167,7 +169,7 @@ function loadEffect(loadManager, persistence, effect, effectArgs, inMemoryStore,
           if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
             inMemTable.invalidationsCount = inMemTable.invalidationsCount + 1 | 0;
             Prometheus.EffectCacheInvalidationsCount.increment(effectName);
-            return Logging.childTrace(Logging.getItemLogger(item), {
+            return Logging.childTrace(Ecosystem.getItemLogger(item, ecosystem), {
               msg: "Invalidated effect cache",
               input: dbEntity.id,
               effect: effectName,
@@ -197,9 +199,9 @@ function loadEffect(loadManager, persistence, effect, effectArgs, inMemoryStore,
   return LoadManager.call(loadManager, effectArgs, key, load, args => args.cacheKey, shouldGroup, hash => InMemoryStore.hasEffectOutput(inMemTable, hash), hash => InMemoryStore.getEffectOutputUnsafe(inMemTable, hash));
 }
 
-function loadByFilter(loadManager, persistence, entityConfig, inMemoryStore, shouldGroup, item, filter) {
+function loadByFilter(loadManager, persistence, entityConfig, indexerState, shouldGroup, item, ecosystem, filter) {
   let key = EntityFilter.toOperationKey(filter, entityConfig.name);
-  let inMemTable = InMemoryStore.getInMemTable(inMemoryStore, entityConfig);
+  let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig);
   let load = async (filters, param) => {
     let storage = Persistence.getInitializedStorageOrThrow(persistence);
     let timerRef = Prometheus.StorageLoad.startOperation(storage.name, key);
@@ -211,13 +213,13 @@ function loadByFilter(loadManager, persistence, entityConfig, inMemoryStore, sho
     await Promise.all(queries.map(async filter => {
       try {
         let entities = await storage.loadOrThrow(filter, entityConfig.table);
-        entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, inMemoryStore.committedCheckpointId, entity.id, entity));
+        entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, IndexerState.committedCheckpointId(indexerState), entity.id, entity));
         size.contents = size.contents + entities.length | 0;
         return;
       } catch (raw_exn) {
         let exn = Primitive_exceptions.internalToException(raw_exn);
         if (exn.RE_EXN_ID === Persistence.StorageError) {
-          return ErrorHandling.mkLogAndRaise(Logging.createChildFrom(Logging.getItemLogger(item), {
+          return ErrorHandling.mkLogAndRaise(Logging.createChildFrom(Ecosystem.getItemLogger(item, ecosystem), {
             operation: key,
             params: EntityFilter.getParams(filter)
           }), exn.message, exn.reason);

package/src/LoadLayer.resi

@@ -2,9 +2,10 @@ let loadById: (
   ~loadManager: LoadManager.t,
   ~persistence: Persistence.t,
   ~entityConfig: Internal.entityConfig,
-  ~inMemoryStore: InMemoryStore.t,
+  ~indexerState: IndexerState.t,
   ~shouldGroup: bool,
   ~item: Internal.item,
+  ~ecosystem: Ecosystem.t,
   ~entityId: string,
 ) => promise<option<Internal.entity>>
 
@@ -12,9 +13,10 @@ let loadByFilter: (
   ~loadManager: LoadManager.t,
   ~persistence: Persistence.t,
   ~entityConfig: Internal.entityConfig,
-  ~inMemoryStore: InMemoryStore.t,
+  ~indexerState: IndexerState.t,
   ~shouldGroup: bool,
   ~item: Internal.item,
+  ~ecosystem: Ecosystem.t,
   ~filter: EntityFilter.t,
 ) => promise<array<Internal.entity>>
 
@@ -23,7 +25,8 @@ let loadEffect: (
   ~persistence: Persistence.t,
   ~effect: Internal.effect,
   ~effectArgs: Internal.effectArgs,
-  ~inMemoryStore: InMemoryStore.t,
+  ~indexerState: IndexerState.t,
   ~shouldGroup: bool,
   ~item: Internal.item,
+  ~ecosystem: Ecosystem.t,
 ) => promise<Internal.effectOutput>

package/src/Logging.res

@@ -155,46 +155,11 @@ let createChildFrom = (~logger: t, ~params: 'a) => {
   logger->child(params->createChildParams)
 }
 
-let getItemLogger = {
-  let cacheKey = "_logger"
-  (item: Internal.item) => {
-    switch item
-    ->(Utils.magic: Internal.item => dict<Pino.t>)
-    ->Utils.Dict.dangerouslyGetNonOption(cacheKey) {
-    | Some(l) => l
-    | None => {
-        let l = getLogger()->child(
-          switch item {
-          | Event({eventConfig, chain, blockNumber, logIndex, event}) =>
-            {
-              "contractName": eventConfig.contractName,
-              "eventName": eventConfig.name,
-              "chainId": chain->ChainMap.Chain.toChainId,
-              "block": blockNumber,
-              "logIndex": logIndex,
-              "address": (event->Internal.toGenericEvent).srcAddress,
-            }->createChildParams
-          | Block({blockNumber, onBlockConfig}) =>
-            {
-              "onBlock": onBlockConfig.name,
-              "chainId": onBlockConfig.chainId,
-              "block": blockNumber,
-            }->createChildParams
-          },
-        )
-        item->(Utils.magic: Internal.item => dict<Pino.t>)->Dict.set(cacheKey, l)
-        l
-      }
-    }
-  }
-}
-
 @inline
-let logForItem = (item, level: Pino.logLevel, message: string, ~params=?) => {
+let logAtLevel = (logger: t, level: Pino.logLevel, message: string, ~params=?) => {
   (
-    item
-    ->getItemLogger
-    ->(Utils.magic: Pino.t => dict<(option<'a>, string) => unit>)
+    logger
+    ->(Utils.magic: t => dict<(option<'a>, string) => unit>)
     ->Dict.getUnsafe((level :> string))
   )(params, message)
 }
@@ -207,11 +172,13 @@ let noopLogger: Envio.logger = {
   errorWithExn: (_message: string, _exn) => (),
 }
 
-let getUserLogger = (item): Envio.logger => {
-  info: (message: string, ~params=?) => item->logForItem(#uinfo, message, ~params?),
-  debug: (message: string, ~params=?) => item->logForItem(#udebug, message, ~params?),
-  warn: (message: string, ~params=?) => item->logForItem(#uwarn, message, ~params?),
-  error: (message: string, ~params=?) => item->logForItem(#uerror, message, ~params?),
+// Wrap a (child) logger as the user-facing `context.log`, routing through the
+// custom `u*` levels. The caller builds the per-item logger via the ecosystem.
+let userLogger = (logger: t): Envio.logger => {
+  info: (message: string, ~params=?) => logger->logAtLevel(#uinfo, message, ~params?),
+  debug: (message: string, ~params=?) => logger->logAtLevel(#udebug, message, ~params?),
+  warn: (message: string, ~params=?) => logger->logAtLevel(#uwarn, message, ~params?),
+  error: (message: string, ~params=?) => logger->logAtLevel(#uerror, message, ~params?),
   errorWithExn: (message: string, exn) =>
-    item->logForItem(#uerror, message, ~params={"err": exn->Utils.prettifyExn}),
+    logger->logAtLevel(#uerror, message, ~params={"err": exn->Utils.prettifyExn}),
 }

package/src/Logging.res.mjs

@@ -178,39 +178,8 @@ function createChildFrom(logger, params) {
   return logger.child(Pino.createChildParams(params));
 }
 
-let cacheKey = "_logger";
-
-function getItemLogger(item) {
-  let l = item[cacheKey];
-  if (l !== undefined) {
-    return l;
-  }
-  let tmp;
-  if (item.kind === 0) {
-    let eventConfig = item.eventConfig;
-    tmp = Pino.createChildParams({
-      contractName: eventConfig.contractName,
-      eventName: eventConfig.name,
-      chainId: item.chain,
-      block: item.blockNumber,
-      logIndex: item.logIndex,
-      address: item.event.srcAddress
-    });
-  } else {
-    let onBlockConfig = item.onBlockConfig;
-    tmp = Pino.createChildParams({
-      onBlock: onBlockConfig.name,
-      chainId: onBlockConfig.chainId,
-      block: item.blockNumber
-    });
-  }
-  let l$1 = getLogger().child(tmp);
-  item[cacheKey] = l$1;
-  return l$1;
-}
-
-function logForItem(item, level, message, params) {
-  getItemLogger(item)[level](params, message);
+function logAtLevel(logger, level, message, params) {
+  logger[level](params, message);
 }
 
 function noopLogger_debug(_message, param) {
@@ -241,17 +210,17 @@ let noopLogger = {
   errorWithExn: noopLogger_errorWithExn
 };
 
-function getUserLogger(item) {
+function userLogger(logger) {
   return {
-    debug: (message, params) => getItemLogger(item)["udebug"](params, message),
-    info: (message, params) => getItemLogger(item)["uinfo"](params, message),
-    warn: (message, params) => getItemLogger(item)["uwarn"](params, message),
-    error: (message, params) => getItemLogger(item)["uerror"](params, message),
+    debug: (message, params) => logger["udebug"](params, message),
+    info: (message, params) => logger["uinfo"](params, message),
+    warn: (message, params) => logger["uwarn"](params, message),
+    error: (message, params) => logger["uerror"](params, message),
     errorWithExn: (message, exn) => {
       let params = {
         err: Utils.prettifyExn(exn)
       };
-      getItemLogger(item)["uerror"](params, message);
+      logger["uerror"](params, message);
     }
   };
 }
@@ -278,9 +247,8 @@ export {
   childFatal,
   createChild,
   createChildFrom,
-  getItemLogger,
-  logForItem,
+  logAtLevel,
   noopLogger,
-  getUserLogger,
+  userLogger,
 }
 /* logLevels Not a pure module */