envio 3.2.0 → 3.3.0-alpha.0

package/src/SimulateItems.res

@@ -288,16 +288,18 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
           blockNumber,
           blockHash,
           logIndex,
-          event: {
-            contractName: eventConfig.contractName,
-            eventName: eventConfig.name,
-            params,
-            chainId,
-            srcAddress,
-            logIndex,
-            transaction,
-            block,
-          }->Internal.fromGenericEvent,
+          payload: (
+            {
+              contractName: eventConfig.contractName,
+              eventName: eventConfig.name,
+              params,
+              chainId,
+              srcAddress,
+              logIndex,
+              transaction,
+              block,
+            }: Evm.payload
+          )->Evm.fromPayload,
         }),
       )
       ->ignore

package/src/SimulateItems.res.mjs

@@ -241,7 +241,7 @@ function parse(simulateItems, config, chainConfig) {
       blockNumber: blockNumber,
       blockHash: match$3[3],
       logIndex: logIndex,
-      event: {
+      payload: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
         params: params,

package/src/TestIndexer.res

@@ -44,35 +44,42 @@ let toIndexingAddress = (dc: InternalTable.EnvioAddresses.t): Internal.indexingA
 }
 
 let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFilter.t): JSON.t => {
-  let entityDict = state.entities->Dict.get(tableName)->Option.getOr(Dict.make())
-  let entityConfig = state.entityConfigs->Dict.getUnsafe(tableName)
-  let results = []
-
-  // Field values arrive as JSON from the worker boundary, so parse them
-  // with the field's schema before comparing. This properly handles
-  // bigint and BigDecimal comparisons
-  let parseLeaf = (~fieldName, ~fieldValue: unknown, ~isArray): unknown => {
-    let queryField = switch entityConfig.table->Table.queryFields->Dict.get(fieldName) {
-    | Some(queryField) => queryField
-    | None => JsError.throwWithMessage(`Field ${fieldName} not found in entity ${tableName}`)
-    }
-    fieldValue->S.convertOrThrow(isArray ? queryField.arrayFieldSchema : queryField.fieldSchema)
-  }
-  let filter = filter->EntityFilter.mapValues(~mapValue=parseLeaf)
-
-  entityDict
-  ->Dict.valuesToArray
-  ->Array.forEach(entity => {
-    // Cast entity to dict of field values (same approach as InMemoryTable)
-    let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
-    if filter->EntityFilter.matches(~entity=entityAsDict) {
-      // Serialize entity back to JSON for worker thread
-      let jsonEntity = entity->S.reverseConvertToJsonOrThrow(entityConfig.schema)
-      results->Array.push(jsonEntity)->ignore
+  // Loads for non-entity tables (e.g. effect caches `envio_effect_<name>`) reach
+  // here too. TestIndexer never persists those, so there's nothing to return —
+  // an empty result makes the effect recompute instead of crashing on a missing
+  // entityConfig.
+  switch state.entityConfigs->Dict.get(tableName) {
+  | None => []->JSON.Encode.array
+  | Some(entityConfig) =>
+    let entityDict = state.entities->Dict.get(tableName)->Option.getOr(Dict.make())
+    let results = []
+
+    // Field values arrive as JSON from the worker boundary, so parse them
+    // with the field's schema before comparing. This properly handles
+    // bigint and BigDecimal comparisons
+    let parseLeaf = (~fieldName, ~fieldValue: unknown, ~isArray): unknown => {
+      let queryField = switch entityConfig.table->Table.queryFields->Dict.get(fieldName) {
+      | Some(queryField) => queryField
+      | None => JsError.throwWithMessage(`Field ${fieldName} not found in entity ${tableName}`)
+      }
+      fieldValue->S.convertOrThrow(isArray ? queryField.arrayFieldSchema : queryField.fieldSchema)
     }
-  })
+    let filter = filter->EntityFilter.mapValues(~mapValue=parseLeaf)
+
+    entityDict
+    ->Dict.valuesToArray
+    ->Array.forEach(entity => {
+      // Cast entity to dict of field values (same approach as InMemoryTable)
+      let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
+      if filter->EntityFilter.matches(~entity=entityAsDict) {
+        // Serialize entity back to JSON for worker thread
+        let jsonEntity = entity->S.reverseConvertToJsonOrThrow(entityConfig.schema)
+        results->Array.push(jsonEntity)->ignore
+      }
+    })
 
-  results->JSON.Encode.array
+    results->JSON.Encode.array
+  }
 }
 
 let handleWriteBatch = (

package/src/TestIndexer.res.mjs

@@ -33,8 +33,11 @@ function toIndexingAddress(dc) {
 }
 
 function handleLoad(state, tableName, filter) {
-  let entityDict = Stdlib_Option.getOr(state.entities[tableName], {});
   let entityConfig = state.entityConfigs[tableName];
+  if (entityConfig === undefined) {
+    return [];
+  }
+  let entityDict = Stdlib_Option.getOr(state.entities[tableName], {});
   let results = [];
   let parseLeaf = (fieldName, fieldValue, isArray) => {
     let queryField = Table.queryFields(entityConfig.table)[fieldName];

package/src/UserContext.res

@@ -1,7 +1,7 @@
 type contextParams = {
   item: Internal.item,
   checkpointId: Internal.checkpointId,
-  inMemoryStore: InMemoryStore.t,
+  indexerState: IndexerState.t,
   loadManager: LoadManager.t,
   persistence: Persistence.t,
   isPreload: bool,
@@ -22,7 +22,8 @@ Utils.Object.defineProperty(
   {
     // Wrap with toMethod so `this` binds to the EffectContext instance.
     get: Utils.toMethod(() => {
-      (paramsByThis->Utils.WeakMap.unsafeGet(%raw(`this`))).item->Logging.getUserLogger
+      let params = paramsByThis->Utils.WeakMap.unsafeGet(%raw(`this`))
+      Ecosystem.getItemUserLogger(params.item, ~ecosystem=params.config.ecosystem)
     }),
   },
 )
@@ -60,9 +61,10 @@ let initEffect = (params: contextParams) => {
       ~persistence=params.persistence,
       ~effect,
       ~effectArgs,
-      ~inMemoryStore=params.inMemoryStore,
+      ~indexerState=params.indexerState,
       ~shouldGroup=params.isPreload,
       ~item=params.item,
+      ~ecosystem=params.config.ecosystem,
     )
   }
   callEffect
@@ -82,9 +84,10 @@ let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>)
       ~loadManager=params.loadManager,
       ~persistence=params.persistence,
       ~entityConfig,
-      ~inMemoryStore=params.inMemoryStore,
+      ~indexerState=params.indexerState,
       ~shouldGroup=params.isPreload,
       ~item=params.item,
+      ~ecosystem=params.config.ecosystem,
       ~filter,
     )
 
@@ -121,10 +124,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
     let set = params.isPreload
       ? noopSet
       : (entity: Internal.entity) => {
-          params.inMemoryStore
+          params.indexerState
           ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.inMemoryStore.committedCheckpointId,
+            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
             Set({
               entityId: entity.id,
               checkpointId: params.checkpointId,
@@ -146,9 +149,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
-              ~inMemoryStore=params.inMemoryStore,
+              ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
+              ~ecosystem=params.config.ecosystem,
               ~entityId,
             )
         )->(Utils.magic: (string => promise<option<Internal.entity>>) => unknown)
@@ -177,9 +181,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
-              ~inMemoryStore=params.inMemoryStore,
+              ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
+              ~ecosystem=params.config.ecosystem,
               ~entityId,
             )->Promise.thenResolve(entity => {
               switch entity {
@@ -206,9 +211,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
-              ~inMemoryStore=params.inMemoryStore,
+              ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
+              ~ecosystem=params.config.ecosystem,
               ~entityId=entity.id,
             )->Promise.thenResolve(storageEntity => {
               switch storageEntity {
@@ -227,10 +233,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
         noopDeleteUnsafe
       } else {
         entityId => {
-          params.inMemoryStore
+          params.indexerState
           ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.inMemoryStore.committedCheckpointId,
+            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
             Delete({
               entityId,
               checkpointId: params.checkpointId,
@@ -250,13 +256,17 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
     if params.isResolved {
       Utils.Error.make(
         `Impossible to access context.${prop} after the handler is resolved. Make sure you didn't miss an await in the handler.`,
-      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
+      )->ErrorHandling.mkLogAndRaise(
+        ~logger=Ecosystem.getItemLogger(params.item, ~ecosystem=params.config.ecosystem),
+      )
     }
     switch prop {
     | "log" =>
-      (params.isPreload ? Logging.noopLogger : params.item->Logging.getUserLogger)->(
-        Utils.magic: Envio.logger => unknown
-      )
+      (
+        params.isPreload
+          ? Logging.noopLogger
+          : Ecosystem.getItemUserLogger(params.item, ~ecosystem=params.config.ecosystem)
+      )->(Utils.magic: Envio.logger => unknown)
 
     | "effect" =>
       initEffect((params :> contextParams))->(
@@ -277,7 +287,7 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
         {
           item: params.item,
           isPreload: params.isPreload,
-          inMemoryStore: params.inMemoryStore,
+          indexerState: params.indexerState,
           loadManager: params.loadManager,
           persistence: params.persistence,
           checkpointId: params.checkpointId,
@@ -300,101 +310,3 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
 let getHandlerContext = (params: contextParams): Internal.handlerContext => {
   params->Utils.Proxy.make(handlerTraps)->(Utils.magic: contextParams => Internal.handlerContext)
 }
-
-// Contract register context creation
-type contractRegisterParams = {
-  item: Internal.item,
-  onRegister: (~item: Internal.item, ~contractAddress: Address.t, ~contractName: string) => unit,
-  config: Config.t,
-  mutable isResolved: bool,
-}
-
-// Helper to create a validated add function for contract registration.
-// The isResolved check has to live inside the returned closure (not just in the
-// outer proxy trap) because users can capture `const add = context.chain.X.add`
-// before awaiting — a later call would otherwise bypass the resolved guard.
-let makeAddFunction = (~params: contractRegisterParams, ~contractName: string): (
-  Address.t => unit
-) => {
-  (contractAddress: Address.t) => {
-    if params.isResolved {
-      Utils.Error.make(`Impossible to access context.chain after the contract register is resolved. Make sure you didn't miss an await in the handler.`)->ErrorHandling.mkLogAndRaise(
-        ~logger=params.item->Logging.getItemLogger,
-      )
-    }
-    let validatedAddress = if params.config.ecosystem.name === Evm {
-      // The value is passed from the user-land,
-      // so we need to validate and checksum/lowercase the address.
-      if params.config.lowercaseAddresses {
-        contractAddress->Address.Evm.fromAddressLowercaseOrThrow
-      } else {
-        contractAddress->Address.Evm.fromAddressOrThrow
-      }
-    } else {
-      // TODO: Ideally we should do the same for other ecosystems
-      contractAddress
-    }
-
-    params.onRegister(~item=params.item, ~contractAddress=validatedAddress, ~contractName)
-  }
-}
-
-// Chain proxy for contractRegister context: context.chain.ContractName.add(address)
-let contractRegisterChainTraps: Utils.Proxy.traps<contractRegisterParams> = {
-  get: (~target as params, ~prop: unknown) => {
-    let prop = prop->(Utils.magic: unknown => string)
-    switch prop {
-    | "id" =>
-      let eventItem = params.item->Internal.castUnsafeEventItem
-      eventItem.chain->ChainMap.Chain.toChainId->(Utils.magic: int => unknown)
-    | _ =>
-      // Look up the contract name directly in config contracts across all chains.
-      let contractName = prop
-      let isValidContract =
-        params.config.chainMap
-        ->ChainMap.values
-        ->Array.some(chain => chain.contracts->Array.some(c => c.name === contractName))
-      if isValidContract {
-        let addFn = makeAddFunction(~params, ~contractName)
-        {"add": addFn}->(Utils.magic: {"add": Address.t => unit} => unknown)
-      } else {
-        JsError.throwWithMessage(
-          `Invalid contract name '${prop}' on context.chain. ${EntityFilter.codegenHelpMessage}`,
-        )
-      }
-    }
-  },
-}
-
-let contractRegisterTraps: Utils.Proxy.traps<contractRegisterParams> = {
-  get: (~target as params, ~prop: unknown) => {
-    let prop = prop->(Utils.magic: unknown => string)
-    if params.isResolved {
-      Utils.Error.make(
-        `Impossible to access context.${prop} after the contract register is resolved. Make sure you didn't miss an await in the handler.`,
-      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
-    }
-    switch prop {
-    | "log" => params.item->Logging.getUserLogger->(Utils.magic: Envio.logger => unknown)
-    | "chain" =>
-      params
-      ->Utils.Proxy.make(contractRegisterChainTraps)
-      ->(Utils.magic: contractRegisterParams => unknown)
-    | _ =>
-      JsError.throwWithMessage(
-        `Invalid context access by '${prop}' property. Use context.chain.ContractName.add(address) to register contracts. ${EntityFilter.codegenHelpMessage}`,
-      )
-    }
-  },
-}
-
-let getContractRegisterContext = (params: contractRegisterParams) => {
-  params
-  ->Utils.Proxy.make(contractRegisterTraps)
-  ->(Utils.magic: contractRegisterParams => Internal.contractRegisterContext)
-}
-
-let getContractRegisterArgs = (params: contractRegisterParams): Internal.contractRegisterArgs => {
-  event: (params.item->Internal.castUnsafeEventItem).event,
-  context: getContractRegisterContext(params),
-}

package/src/UserContext.res.mjs

@@ -1,12 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Address from "./Address.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as ChainMap from "./ChainMap.res.mjs";
 import * as Internal from "./Internal.res.mjs";
+import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as LoadLayer from "./LoadLayer.res.mjs";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
@@ -20,7 +20,8 @@ let effectContextPrototype = (Object.create(null));
 
 Object.defineProperty(effectContextPrototype, "log", {
   get: function () {
-    return Logging.getUserLogger(paramsByThis.get(this).item);
+    let params = paramsByThis.get(this);
+    return Ecosystem.getItemUserLogger(params.item, params.config.ecosystem);
   }
 });
 
@@ -43,7 +44,7 @@ function initEffect(params) {
       cacheKey: effectArgs_cacheKey,
       checkpointId: effectArgs_checkpointId
     };
-    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, params.inMemoryStore, params.isPreload, params.item);
+    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, params.indexerState, params.isPreload, params.item, params.config.ecosystem);
   };
   return callEffect;
 }
@@ -52,9 +53,9 @@ function getWhereHandler(params, filter) {
   let entityConfig = params.entityConfig;
   let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
   if (filters.length !== 1) {
-    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.inMemoryStore, params.isPreload, params.item, filter))).then(results => results.flat());
+    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter))).then(results => results.flat());
   } else {
-    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.inMemoryStore, params.isPreload, params.item, filters[0]);
+    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, filters[0]);
   }
 }
 
@@ -72,7 +73,7 @@ function throwClickHouseReadOnly(entityConfig, op) {
 
 let entityTraps_get = (params, prop) => {
   let isClickHouseOnly = !params.entityConfig.storage.postgres;
-  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), params.inMemoryStore.committedCheckpointId, {
+  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig), IndexerState.committedCheckpointId(params.indexerState), {
       type: "SET",
       entityId: entity.id,
       entity: entity,
@@ -83,7 +84,7 @@ let entityTraps_get = (params, prop) => {
       if (params.isPreload) {
         return noopDeleteUnsafe;
       } else {
-        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), params.inMemoryStore.committedCheckpointId, {
+        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig), IndexerState.committedCheckpointId(params.indexerState), {
           type: "DELETE",
           entityId: entityId,
           checkpointId: params.checkpointId
@@ -93,13 +94,13 @@ let entityTraps_get = (params, prop) => {
       if (isClickHouseOnly) {
         return _entityId => throwClickHouseReadOnly(params.entityConfig, "get");
       } else {
-        return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId);
+        return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId);
       }
     case "getOrCreate" :
       if (isClickHouseOnly) {
         return _entity => throwClickHouseReadOnly(params.entityConfig, "getOrCreate");
       } else {
-        return entity => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entity.id).then(storageEntity => {
+        return entity => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entity.id).then(storageEntity => {
           if (storageEntity !== undefined) {
             return storageEntity;
           } else {
@@ -112,7 +113,7 @@ let entityTraps_get = (params, prop) => {
       if (isClickHouseOnly) {
         return (_entityId, param) => throwClickHouseReadOnly(params.entityConfig, "getOrThrow");
       } else {
-        return (entityId, message) => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId).then(entity => {
+        return (entityId, message) => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId).then(entity => {
           if (entity !== undefined) {
             return entity;
           } else {
@@ -139,7 +140,7 @@ let entityTraps = {
 
 let handlerTraps_get = (params, prop) => {
   if (params.isResolved) {
-    ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error(`Impossible to access context.` + prop + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
+    ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access context.` + prop + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
   }
   switch (prop) {
     case "chain" :
@@ -153,7 +154,7 @@ let handlerTraps_get = (params, prop) => {
       if (params.isPreload) {
         return Logging.noopLogger;
       } else {
-        return Logging.getUserLogger(params.item);
+        return Ecosystem.getItemUserLogger(params.item, params.config.ecosystem);
       }
     default:
       let entityConfig = params.config.userEntitiesByName[prop];
@@ -161,7 +162,7 @@ let handlerTraps_get = (params, prop) => {
         return new Proxy({
           item: params.item,
           checkpointId: params.checkpointId,
-          inMemoryStore: params.inMemoryStore,
+          indexerState: params.indexerState,
           loadManager: params.loadManager,
           persistence: params.persistence,
           isPreload: params.isPreload,
@@ -184,65 +185,6 @@ function getHandlerContext(params) {
   return new Proxy(params, handlerTraps);
 }
 
-function makeAddFunction(params, contractName) {
-  return contractAddress => {
-    if (params.isResolved) {
-      ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error(`Impossible to access context.chain after the contract register is resolved. Make sure you didn't miss an await in the handler.`));
-    }
-    let validatedAddress = params.config.ecosystem.name === "evm" ? (
-        params.config.lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(contractAddress) : Address.Evm.fromAddressOrThrow(contractAddress)
-      ) : contractAddress;
-    params.onRegister(params.item, validatedAddress, contractName);
-  };
-}
-
-let contractRegisterChainTraps_get = (params, prop) => {
-  if (prop === "id") {
-    return params.item.chain;
-  }
-  let isValidContract = ChainMap.values(params.config.chainMap).some(chain => chain.contracts.some(c => c.name === prop));
-  if (isValidContract) {
-    return {
-      add: makeAddFunction(params, prop)
-    };
-  } else {
-    return Stdlib_JsError.throwWithMessage(`Invalid contract name '` + prop + `' on context.chain. ` + EntityFilter.codegenHelpMessage);
-  }
-};
-
-let contractRegisterChainTraps = {
-  get: contractRegisterChainTraps_get
-};
-
-let contractRegisterTraps_get = (params, prop) => {
-  if (params.isResolved) {
-    ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error(`Impossible to access context.` + prop + ` after the contract register is resolved. Make sure you didn't miss an await in the handler.`));
-  }
-  switch (prop) {
-    case "chain" :
-      return new Proxy(params, contractRegisterChainTraps);
-    case "log" :
-      return Logging.getUserLogger(params.item);
-    default:
-      return Stdlib_JsError.throwWithMessage(`Invalid context access by '` + prop + `' property. Use context.chain.ContractName.add(address) to register contracts. ` + EntityFilter.codegenHelpMessage);
-  }
-};
-
-let contractRegisterTraps = {
-  get: contractRegisterTraps_get
-};
-
-function getContractRegisterContext(params) {
-  return new Proxy(params, contractRegisterTraps);
-}
-
-function getContractRegisterArgs(params) {
-  return {
-    event: params.item.event,
-    context: new Proxy(params, contractRegisterTraps)
-  };
-}
-
 export {
   paramsByThis,
   effectContextPrototype,
@@ -254,10 +196,5 @@ export {
   entityTraps,
   handlerTraps,
   getHandlerContext,
-  makeAddFunction,
-  contractRegisterChainTraps,
-  contractRegisterTraps,
-  getContractRegisterContext,
-  getContractRegisterArgs,
 }
 /* paramsByThis Not a pure module */