envio 3.6.1 → 3.7.0

package/src/MemoryStorage.res.mjs

@@ -0,0 +1,601 @@
+// 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) {
+    return [];
+  }
+  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;
+  }
+}
+
+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);
+  }
+  updatedEntities.forEach(param => {
+    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);
+    param.changes.forEach(change => {
+      let entityId = change.entityId;
+      if (shouldSaveHistory) {
+        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 (shouldSaveHistory) {
+          historyRows.push({
+            entityId: entityId,
+            scope: scope,
+            checkpointId: change.checkpointId,
+            action: "SET",
+            entity: storedEntity
+          });
+          return;
+        } else {
+          return;
+        }
+      }
+      Utils.Dict.deleteInPlace(entityDict, rowKey(scope, entityId));
+      if (shouldSaveHistory) {
+        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/PgStorage.res

@@ -630,14 +630,19 @@ let classifyWriteError = (~specificError: ref<option<exn>>, ~table: Table.table,
   }
 }
 
-// WeakMap for caching table batch set queries
-let setQueryCache = Utils.WeakMap.make()
+// Batch set queries, cached per table. The query text bakes in the schema and
+// the chain-id mode, so the cache belongs to the storage instance those came
+// from — `make` creates one and threads it down. A process-wide cache would
+// hand a second storage the first one's schema.
+let makeSetQueryCache = () => Utils.WeakMap.make()
+
 let setOrThrow = async (
   sql,
   ~items,
   ~table: Table.table,
   ~itemSchema,
   ~pgSchema,
+  ~setQueryCache,
   ~chainIdMode: ChainId.mode=Int32,
 ) => {
   if items->Array.length === 0 {
@@ -953,6 +958,7 @@ let rec writeBatch = async (
   ~config: Config.t,
   ~allEntities: array<Internal.entityConfig>,
   ~setEffectCacheOrThrow,
+  ~setQueryCache,
   ~updatedEffectsCache,
   ~updatedEntities: array<Persistence.updatedEntity>,
   ~sinkPromise: option<promise<option<exn>>>,
@@ -973,11 +979,8 @@ let rec writeBatch = async (
       let rows = batch.items->Array.filterMap(item =>
         switch item {
         | Internal.Event(_) =>
-          let coordinate = `${item
-            ->Internal.getItemChainId
-            ->ChainId.toString}-${item
-            ->Internal.getItemBlockNumber
-            ->Int.toString}-${item->Internal.getItemLogIndex->Int.toString}`
+          let eventItem = item->Internal.castUnsafeEventItem
+          let coordinate = `${eventItem.chainId->ChainId.toString}-${eventItem.blockNumber->Int.toString}-${eventItem.logIndex->Int.toString}`
           if seenLogCoordinates->Utils.Set.has(coordinate) {
             None
           } else {
@@ -1006,6 +1009,7 @@ let rec writeBatch = async (
             ~itemSchema=InternalTable.RawEvents.schema,
             ~pgSchema,
             ~chainIdMode,
+            ~setQueryCache,
           )
         }, ~items=rawEvents)
       } catch {
@@ -1161,6 +1165,7 @@ let rec writeBatch = async (
                   ~table=entityHistory.table,
                   ~pgSchema,
                   ~chainIdMode,
+                  ~setQueryCache,
                 ),
               )
               ->ignore
@@ -1178,6 +1183,7 @@ let rec writeBatch = async (
                 ~itemSchema=entityConfig->getRowSchema,
                 ~pgSchema,
                 ~chainIdMode,
+                ~setQueryCache,
               ),
             )
           }
@@ -1340,6 +1346,7 @@ let rec writeBatch = async (
       ~escapeTables,
       ~batch,
       ~pgSchema,
+      ~setQueryCache,
       ~rollback,
       ~isInReorgThreshold,
       ~config,
@@ -1483,6 +1490,7 @@ let make = (
   let storageName = "postgres"
 
   let indexManager = IndexManager.make()
+  let setQueryCache = makeSetQueryCache()
 
   let loadCatalogRows = (sql, ~indexName=?) =>
     sql
@@ -2064,6 +2072,8 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::${addrChai
       ~table,
       ~itemSchema=itemSchema->S.toUnknown,
       ~pgSchema,
+      ~setQueryCache,
+      ~chainIdMode,
     )
   }
 
@@ -2347,6 +2357,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::${addrChai
       sql,
       ~batch,
       ~pgSchema,
+      ~setQueryCache,
       ~rollback,
       ~isInReorgThreshold,
       ~config,