envio 3.8.0 → 3.9.0

package/src/PgStorage.res.mjs

@@ -15,6 +15,7 @@ import * as EntityId from "./EntityId.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import Postgres from "postgres";
 import * as ChainState from "./ChainState.res.mjs";
+import * as AddressRows from "./AddressRows.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as IndexCatalog from "./db/IndexCatalog.res.mjs";
@@ -26,6 +27,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Child_process from "child_process";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as ContractMapping from "./ContractMapping.res.mjs";
 import * as IndexDefinition from "./db/IndexDefinition.res.mjs";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -84,7 +86,7 @@ function getSchemaIndexes(entities) {
   });
 }
 
-function makeCreateTableQuery(table, pgSchema, isNumericArrayAsText, chainIdModeOpt) {
+function makeCreateTableQuery(table, pgSchema, isNumericArrayAsText, chainIdModeOpt, partitionByColumn) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let fieldsMapped = Table.getFields(table).map(field => {
     let defaultValue = field.defaultValue;
@@ -100,7 +102,14 @@ function makeCreateTableQuery(table, pgSchema, isNumericArrayAsText, chainIdMode
   let primaryKey = primaryKeyFieldNames.map(field => `"` + field + `"`).join(", ");
   return `CREATE TABLE IF NOT EXISTS "` + pgSchema + `"."` + table.tableName + `"(` + fieldsMapped + (
     primaryKeyFieldNames.length !== 0 ? `, PRIMARY KEY(` + primaryKey + `)` : ""
-  ) + `);`;
+  ) + `)` + (
+    partitionByColumn !== undefined ? ` PARTITION BY LIST ("` + partitionByColumn + `")` : ""
+  ) + `;`;
+}
+
+function partitionTableName(entityConfig, chainId) {
+  let chainIdStr = ChainId.toString(chainId);
+  return Table.fitPgTableName(entityConfig.table.tableName + `$` + chainIdStr, `$` + entityConfig.index.toString() + `$` + chainIdStr);
 }
 
 let rowSchemaCache = new WeakMap();
@@ -209,6 +218,15 @@ function getEntityHistory(entityConfig) {
   return cache$1;
 }
 
+function makeCreateEntityTableQueries(entityConfig, pgSchema, isNumericArrayAsText, chainIdModeOpt, chainIds) {
+  let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
+  let createTable = (table, partitionByColumn) => makeCreateTableQuery(table, pgSchema, isNumericArrayAsText, chainIdMode, partitionByColumn);
+  let chainIdField = Table.getChainIdField(entityConfig.table);
+  return (
+    chainIdField !== undefined ? [createTable(entityConfig.table, Table.getPgDbFieldName(chainIdField))].concat(chainIds.map(chainId => `CREATE TABLE IF NOT EXISTS "` + pgSchema + `"."` + partitionTableName(entityConfig, chainId) + `" PARTITION OF "` + pgSchema + `"."` + entityConfig.table.tableName + `" FOR VALUES IN (` + ChainId.toString(chainId) + `);`)) : [createTable(entityConfig.table, undefined)]
+  ).concat([createTable(getEntityHistory(entityConfig).table, undefined)]);
+}
+
 function makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigsOpt, entitiesOpt, enumsOpt, isEmptyPgSchemaOpt, deferSchemaIndexesOpt, chainIdModeOpt) {
   let chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
   let entities = entitiesOpt !== undefined ? entitiesOpt : [];
@@ -219,14 +237,13 @@ function makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfi
   let generalTables = [
     InternalTable.Chains.table,
     InternalTable.EnvioInfo.table,
+    InternalTable.EnvioContracts.table,
+    InternalTable.EnvioAddresses.table,
     InternalTable.Checkpoints.table,
     InternalTable.RawEvents.table
   ];
-  let allTables = generalTables.slice();
-  entities.forEach(entityConfig => {
-    allTables.push(entityConfig.table);
-    allTables.push(getEntityHistory(entityConfig).table);
-  });
+  let chainIds = chainConfigs.map(chainConfig => chainConfig.id);
+  let tableQueries = generalTables.map(table => makeCreateTableQuery(table, pgSchema, isHasuraEnabled, chainIdMode, undefined)).concat(entities.flatMap(entityConfig => makeCreateEntityTableQueries(entityConfig, pgSchema, isHasuraEnabled, chainIdMode, chainIds)));
   let schemaIndexes = getSchemaIndexes(entities);
   let query = {
     contents: (
@@ -239,8 +256,8 @@ GRANT ALL ON SCHEMA "` + pgSchema + `" TO public;`)
     let enumCreateQuery = `CREATE TYPE "` + pgSchema + `".` + enumConfig.name + ` AS ENUM(` + enumConfig.variants.map(v => `'` + v + `'`).join(", ") + `);`;
     query.contents = query.contents + "\n" + enumCreateQuery;
   });
-  allTables.forEach(table => {
-    query.contents = query.contents + "\n" + makeCreateTableQuery(table, pgSchema, isHasuraEnabled, chainIdMode);
+  tableQueries.forEach(tableQuery => {
+    query.contents = query.contents + "\n" + tableQuery;
   });
   if (!deferSchemaIndexes) {
     schemaIndexes.forEach(definition => {
@@ -298,15 +315,21 @@ function makeFilterCondition(filter, table, params) {
   };
   switch (filter.operator) {
     case "=" :
-      return scalarCondition(filter.fieldName, filter.fieldValue, "=");
+      let fieldValue = filter.fieldValue;
+      let fieldName = filter.fieldName;
+      if (getQueryFieldOrThrow(fieldName).isChainId) {
+        return `"` + getQueryFieldOrThrow(fieldName).pgDbFieldName + `" = ` + ChainId.toString(ChainId.normalizeOrThrow(fieldValue));
+      } else {
+        return scalarCondition(fieldName, fieldValue, "=");
+      }
     case ">" :
       return scalarCondition(filter.fieldName, filter.fieldValue, ">");
     case "<" :
       return scalarCondition(filter.fieldName, filter.fieldValue, "<");
     case "in" :
-      let fieldName = filter.fieldName;
-      let queryField = getQueryFieldOrThrow(fieldName);
-      return `"` + queryField.pgDbFieldName + `" = ANY(` + serializeParamOrThrow(queryField, fieldName, filter.fieldValue, true) + `)`;
+      let fieldName$1 = filter.fieldName;
+      let queryField = getQueryFieldOrThrow(fieldName$1);
+      return `"` + queryField.pgDbFieldName + `" = ANY(` + serializeParamOrThrow(queryField, fieldName$1, filter.fieldValue, true) + `)`;
     case "and" :
       let filters = filter.filters;
       if (filters.length !== 0) {
@@ -324,7 +347,7 @@ function makeFilterCondition(filter, table, params) {
 function makeChainIdCondition(table, chainId) {
   let match = Table.getChainIdField(table);
   if (match !== undefined && chainId !== undefined) {
-    return ` AND "` + Table.getPgDbFieldName(match) + `" = $2`;
+    return ` AND "` + Table.getPgDbFieldName(match) + `" = ` + ChainId.toString(Primitive_option.valFromOption(chainId));
   } else {
     return "";
   }
@@ -597,13 +620,10 @@ async function getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containe
 async function deleteByIdsOrThrow(sql, pgSchema, ids, table, chainIdOpt) {
   let chainId = chainIdOpt !== undefined ? Primitive_option.valFromOption(chainIdOpt) : undefined;
   let chainIdCondition = makeChainIdCondition(table, chainId);
-  let chainIdParams = chainId !== undefined ? (
-      chainIdCondition !== "" ? [Primitive_option.valFromOption(chainId)] : []
-    ) : [];
   let idsJson = Table.encodeIdsToJson(table, ids);
   try {
     await (
-      ids.length !== 1 ? sql.unsafe(makeDeleteByIdsQuery(pgSchema, table.tableName, Table.getIdPgFieldType(table, pgSchema), chainIdCondition), [idsJson].concat(chainIdParams), {prepare: true}) : sql.unsafe(makeDeleteByIdQuery(pgSchema, table.tableName, chainIdCondition), idsJson.concat(chainIdParams), {prepare: true})
+      ids.length !== 1 ? sql.unsafe(makeDeleteByIdsQuery(pgSchema, table.tableName, Table.getIdPgFieldType(table, pgSchema), chainIdCondition), [idsJson], {prepare: true}) : sql.unsafe(makeDeleteByIdQuery(pgSchema, table.tableName, chainIdCondition), idsJson, {prepare: true})
     );
     return;
   } catch (raw_exn) {
@@ -658,7 +678,7 @@ function executeSet(sql, items, dbFunction) {
   }
 }
 
-async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, escapeTables) {
+async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, updatedEntities, registeredAddresses, sinkPromise, chainMetaData, escapeTables) {
   try {
     let chainIdMode = config.chainIdMode;
     let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
@@ -815,10 +835,14 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     });
     let rollbackTables;
     if (rollback !== undefined) {
+      let rolledBackAddresses = rollback.rolledBackAddresses;
       let rollbackTargetCheckpointId = rollback.targetCheckpointId;
       rollbackTables = sql => {
         let promises = allEntities.filter(entityConfig => entityConfig.storage.postgres).map(entityConfig => EntityHistory.rollback(sql, pgSchema, entityConfig.name, entityConfig.index, rollbackTargetCheckpointId));
         promises.push(InternalTable.Checkpoints.rollback(sql, pgSchema, rollbackTargetCheckpointId));
+        if (Utils.$$Array.notEmpty(rolledBackAddresses)) {
+          promises.push(InternalTable.EnvioAddresses.$$delete(sql, pgSchema, rolledBackAddresses, chainIdMode));
+        }
         return Promise.all(promises);
       };
     } else {
@@ -842,6 +866,9 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
           if (chainMetaData !== undefined) {
             setOperations.push(sql => InternalTable.Chains.setMeta(sql, pgSchema, chainMetaData));
           }
+          if (Utils.$$Array.notEmpty(registeredAddresses)) {
+            setOperations.push(sql => InternalTable.EnvioAddresses.insert(sql, pgSchema, registeredAddresses.map(staged => staged.row), chainIdMode));
+          }
           if (shouldSaveHistory) {
             setOperations.push(sql => InternalTable.Checkpoints.insert(sql, pgSchema, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointBlockHashes, batch.checkpointEventsProcessed, chainIdMode));
           }
@@ -872,7 +899,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     if (exn$1.RE_EXN_ID === PgEncodingError) {
       let escapeTables$1 = escapeTables !== undefined ? Primitive_option.valFromOption(escapeTables) : new Set();
       escapeTables$1.add(exn$1.table);
-      return await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, Primitive_option.some(escapeTables$1));
+      return await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, updatedEntities, registeredAddresses, sinkPromise, chainMetaData, Primitive_option.some(escapeTables$1));
     }
     throw exn$1;
   }
@@ -937,7 +964,7 @@ let rollbackChainIdSchema = Utils.$$WeakMap.memoize(table => Stdlib_Option.map(T
 
 let rollbackRemovedIdSchema = Utils.$$WeakMap.memoize(table => S$RescriptSchema.object(s => s.f(Table.idFieldName, Table.getIdSchema(table))));
 
-function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isHasuraEnabled, chainIdModeOpt, sink, onInitialize, onNewTables) {
+function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isHasuraEnabled, chainIdModeOpt, ecosystem, sink, onInitialize, onNewTables) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let containerName = "envio-postgres";
   let psqlExecOptions_env = Object.fromEntries([
@@ -1040,7 +1067,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
           await Promise.all(entries.map(param => {
             let inputFile = param[1];
             let table = param[0];
-            return sql.unsafe(makeCreateTableQuery(table, pgSchema, false, undefined)).then(() => {
+            return sql.unsafe(makeCreateTableQuery(table, pgSchema, false, undefined, undefined)).then(() => {
               let command = psqlExec$1 + ` -c 'COPY "` + pgSchema + `"."` + table.tableName + `" FROM STDIN WITH (FORMAT text, HEADER);' < ` + inputFile;
               return new Promise((resolve, reject) => {
                 Child_process.exec(command, psqlExecOptions, (error, stdout, param) => {
@@ -1081,7 +1108,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     });
     return cache;
   };
-  let initialize = async (chainConfigsOpt, entitiesOpt, enumsOpt, envioInfo) => {
+  let initialize = async (chainConfigsOpt, entitiesOpt, enumsOpt, contractMapping, envioInfo) => {
     let chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
     let entities = entitiesOpt !== undefined ? entitiesOpt : [];
     let enums = enumsOpt !== undefined ? enumsOpt : [];
@@ -1095,31 +1122,16 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
       await sink.initialize(chainConfigs, chEntities, enums);
     }
     let queries = makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigs, pgEntities, enums, Utils.$$Array.isEmpty(schemaTableNames), true, chainIdMode);
+    let rowsByChain = chainConfigs.map(chainConfig => ChainState.configStorageRows(chainConfig, ecosystem, contractMapping));
+    let configAddressRows = rowsByChain.flat();
     await sql.begin(async sql => {
       await Promise.all(queries.map(query => sql.unsafe(query)));
-      return await InternalTable.EnvioInfo.write(sql, pgSchema, envioInfo);
-    });
-    let ids = [];
-    let addrChainIds = [];
-    let addrContractNames = [];
-    chainConfigs.forEach(chain => {
-      chain.contracts.forEach(contract => {
-        contract.addresses.forEach(address => {
-          ids.push(Config.EnvioAddresses.makeId(chain.id, address));
-          addrChainIds.push(chain.id);
-          addrContractNames.push(contract.name);
-        });
-      });
+      await InternalTable.EnvioInfo.write(sql, pgSchema, envioInfo);
+      await InternalTable.EnvioContracts.insert(sql, pgSchema, ContractMapping.names(contractMapping));
+      if (Utils.$$Array.notEmpty(configAddressRows)) {
+        return await InternalTable.EnvioAddresses.insert(sql, pgSchema, configAddressRows, chainIdMode);
+      }
     });
-    if (ids.length !== 0) {
-      let addrChainIdArrayType = Table.getPgFieldType("ChainId", pgSchema, true, false, false, chainIdMode);
-      await sql.unsafe(`INSERT INTO "` + pgSchema + `"."` + Config.EnvioAddresses.table.tableName + `" ("id", "chain_id", "registration_block", "registration_log_index", "contract_name")
-SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrChainIdArrayType + `,$3::text[]) AS t(id, chain_id, contract_name);`, [
-        ids,
-        addrChainIds,
-        addrContractNames
-      ]);
-    }
     let cache = await restoreEffectCache(true);
     await reloadIndexCatalog();
     if (onInitialize !== undefined) {
@@ -1127,8 +1139,10 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
     }
     return {
       cleanRun: true,
+      contractMapping: contractMapping,
+      envioInfo: envioInfo,
       cache: cache,
-      chains: chainConfigs.map(chainConfig => ({
+      chains: chainConfigs.map((chainConfig, idx) => ({
         id: chainConfig.id,
         startBlock: chainConfig.startBlock,
         endBlock: chainConfig.endBlock,
@@ -1137,12 +1151,11 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
         numEventsProcessed: 0,
         firstEventBlockNumber: undefined,
         timestampCaughtUpToHeadOrEndblock: undefined,
-        indexingAddresses: ChainState.configAddresses(chainConfig),
+        addressRows: AddressRows.seedRowsOf(rowsByChain[idx]),
         sourceBlockNumber: 0
       })),
       checkpointId: InternalTable.Checkpoints.initialCheckpointId,
-      reorgCheckpoints: [],
-      envioInfo: envioInfo
+      reorgCheckpoints: []
     };
   };
   let loadOrThrow = async (filter, table) => {
@@ -1331,7 +1344,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
   let setOrThrow$1 = (items, table, itemSchema) => setOrThrow(sql, items, table, itemSchema, pgSchema, setQueryCache, chainIdMode);
   let setEffectCacheOrThrow = async (table, itemSchema, items, initialize) => {
     if (initialize) {
-      await sql.unsafe(makeCreateTableQuery(table, pgSchema, false, undefined));
+      await sql.unsafe(makeCreateTableQuery(table, pgSchema, false, undefined, undefined));
       if (onNewTables !== undefined) {
         await onNewTables([table.tableName]);
       }
@@ -1397,13 +1410,31 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
         numEventsProcessed: rawInitialState.numEventsProcessed,
         firstEventBlockNumber: Primitive_option.fromNull(rawInitialState.firstEventBlockNumber),
         timestampCaughtUpToHeadOrEndblock: Primitive_option.fromNull(rawInitialState.timestampCaughtUpToHeadOrEndblock),
-        indexingAddresses: rawInitialState.indexingAddresses,
+        addressRows: rawInitialState.addressRows,
         sourceBlockNumber: rawInitialState.sourceBlockNumber
       }))),
       sql.unsafe(InternalTable.Checkpoints.makeCommitedCheckpointIdQuery(pgSchema)),
       sql.unsafe(InternalTable.Checkpoints.makeGetReorgCheckpointsQuery(pgSchema)),
-      InternalTable.EnvioInfo.read(sql, pgSchema)
+      Promise.all([
+        InternalTable.EnvioInfo.read(sql, pgSchema),
+        InternalTable.EnvioContracts.read(sql, pgSchema)
+      ]).then(param => {
+        let names = param[1];
+        let info = param[0];
+        if (info !== undefined && names !== undefined) {
+          return [
+            info,
+            ContractMapping.fromStoredNames(names)
+          ];
+        } else {
+          return [
+            undefined,
+            ContractMapping.empty
+          ];
+        }
+      })
     ]);
+    let match$1 = match[4];
     await reloadIndexCatalog();
     let checkpointId = BigInt(match[2][0].id);
     let reorgCheckpoints = match[3].map(raw => ({
@@ -1417,11 +1448,12 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
     }
     return {
       cleanRun: false,
+      contractMapping: match$1[1],
+      envioInfo: match$1[0],
       cache: match[0],
       chains: match[1],
       checkpointId: checkpointId,
-      reorgCheckpoints: reorgCheckpoints,
-      envioInfo: match[4]
+      reorgCheckpoints: reorgCheckpoints
     };
   };
   let reset = async () => {
@@ -1467,7 +1499,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
       S$RescriptSchema.parseOrThrow(restoredEntitiesResult, Table.pgRowsSchema(entityConfig.table))
     ];
   };
-  let writeBatchMethod = async (batch, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities, chainMetaData, onWrite) => {
+  let writeBatchMethod = async (batch, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities, registeredAddresses, chainMetaData, onWrite) => {
     let pgUpdates = [];
     let chUpdates = [];
     for (let i = 0, i_finish = updatedEntities.length; i < i_finish; ++i) {
@@ -1490,7 +1522,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
       sinkPromise = undefined;
     }
     let primaryTimerRef = Performance.now();
-    await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, pgUpdates, sinkPromise, chainMetaData, undefined);
+    await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, setQueryCache, updatedEffectsCache, pgUpdates, registeredAddresses, sinkPromise, chainMetaData, undefined);
     return onWrite(storageName, Performance.secondsSince(primaryTimerRef));
   };
   let close = () => sql.end();
@@ -1546,10 +1578,10 @@ function makeStorageFromEnv(config, sqlOpt, pgSchemaOpt, isHasuraEnabledOpt) {
   } else {
     tmp = undefined;
   }
-  return make(sql, Env.Db.host, pgSchema, Env.Db.port, Env.Db.user, Env.Db.database, Env.Db.password, isHasuraEnabled, config.chainIdMode, tmp, isHasuraEnabled ? () => Stdlib_Promise.$$catch(Hasura.trackDatabase(Env.Hasura.graphqlEndpoint, {
+  return make(sql, Env.Db.host, pgSchema, Env.Db.port, Env.Db.user, Env.Db.database, Env.Db.password, isHasuraEnabled, config.chainIdMode, config.ecosystem.name, tmp, isHasuraEnabled ? () => Stdlib_Promise.$$catch(Hasura.trackDatabase(Env.Hasura.graphqlEndpoint, {
       role: Env.Hasura.role,
       secret: Env.Hasura.secret
-    }, pgSchema, Config.getPgUserEntities(config), Env.Hasura.aggregateEntities, Env.Hasura.responseLimit, Schema.make(config.allEntities.map(e => e.table))), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking tables`))) : undefined, isHasuraEnabled ? tableNames => Stdlib_Promise.$$catch(Hasura.trackTables(Env.Hasura.graphqlEndpoint, {
+    }, pgSchema, Config.getPgUserEntities(config), Env.Hasura.aggregateEntities, Env.Hasura.responseLimit, Schema.make(config.userEntities.map(e => e.table))), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking tables`))) : undefined, isHasuraEnabled ? tableNames => Stdlib_Promise.$$catch(Hasura.trackTables(Env.Hasura.graphqlEndpoint, {
       role: Env.Hasura.role,
       secret: Env.Hasura.secret
     }, pgSchema, tableNames.map(tableName => ({
@@ -1572,10 +1604,12 @@ export {
   slowOnLargeDatabaseNotice,
   getSchemaIndexes,
   makeCreateTableQuery,
+  partitionTableName,
   rowSchemaCache,
   getRowSchema,
   entityHistoryCache,
   getEntityHistory,
+  makeCreateEntityTableQueries,
   makeInitializeTransaction,
   makeLoadQuery,
   makeFilterCondition,

package/src/Rollback.res

@@ -158,21 +158,24 @@ and executeRollback = async (
   }
 
   let rolledBackChains = []
+  let rolledBackAddresses = []
   state
   ->IndexerState.chainStates
   ->Utils.Dict.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
     let fromBlock = cs->ChainState.committedProgressBlockNumber
-    cs->ChainState.rollback(
-      ~newProgressBlockNumber=newProgressBlockNumberPerChain->ChainId.Dict.dangerouslyGetNonOption(
-        chainId,
-      ),
-      ~eventsProcessedDiff=eventsProcessedDiffByChain->ChainId.Dict.dangerouslyGetNonOption(
-        chainId,
-      ),
-      ~rollbackTargetBlockNumber,
-      ~isReorgChain=chainId === reorgChain,
-    )
+    let killedAddresses =
+      cs->ChainState.rollback(
+        ~newProgressBlockNumber=newProgressBlockNumberPerChain->ChainId.Dict.dangerouslyGetNonOption(
+          chainId,
+        ),
+        ~eventsProcessedDiff=eventsProcessedDiffByChain->ChainId.Dict.dangerouslyGetNonOption(
+          chainId,
+        ),
+        ~rollbackTargetBlockNumber,
+        ~isReorgChain=chainId === reorgChain,
+      )
+    rolledBackAddresses->Array.pushMany(killedAddresses)->ignore
     let toBlock = cs->ChainState.committedProgressBlockNumber
     if fromBlock !== toBlock {
       rolledBackChains
@@ -192,6 +195,7 @@ and executeRollback = async (
     ~rollbackTargetCheckpointId,
     ~rollbackDiffCheckpointId=state->IndexerState.committedCheckpointId->BigInt.add(1n),
     ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
+    ~rolledBackAddresses,
   )
 
   rolledBackChains->Array.forEach(rolledBack => {

package/src/Rollback.res.mjs

@@ -54,10 +54,12 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain ? Primitive_int.min(diff.new_progress_block_number, rollbackTargetBlockNumber) : diff.new_progress_block_number;
   }
   let rolledBackChains = [];
+  let rolledBackAddresses = [];
   Utils.Dict.forEach(IndexerState.chainStates(state), cs => {
     let chainId = ChainState.chainConfig(cs).id;
     let fromBlock = ChainState.committedProgressBlockNumber(cs);
-    ChainState.rollback(cs, newProgressBlockNumberPerChain[chainId], eventsProcessedDiffByChain[chainId], rollbackTargetBlockNumber, chainId === reorgChain);
+    let killedAddresses = ChainState.rollback(cs, newProgressBlockNumberPerChain[chainId], eventsProcessedDiffByChain[chainId], rollbackTargetBlockNumber, chainId === reorgChain);
+    rolledBackAddresses.push(...killedAddresses);
     let toBlock = ChainState.committedProgressBlockNumber(cs);
     if (fromBlock !== toBlock) {
       rolledBackChains.push({
@@ -69,7 +71,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
       return;
     }
   });
-  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain);
+  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain, rolledBackAddresses);
   rolledBackChains.forEach(rolledBack => Logging.childInfo(logger, {
     msg: "Rollbacked",
     chainId: rolledBack.chainId,

package/src/SimulateItems.res

@@ -372,18 +372,11 @@ let parse = (
         }
       }
       let data = item.data->Option.getOr(svmEventConfig.discriminator->Option.getOr("0x"))
-      let decoded = item.args->Option.map(args => (
-        {
-          SvmHyperSyncClient.ResponseTypes.name: instructionName,
-          argsJson: args->JSON.stringify,
-          accountsJson: "{}",
-          extraAccounts: [],
-        }: SvmHyperSyncClient.ResponseTypes.decodedInstruction
-      ))
+      let argsJson = item.args->Option.mapOr("{}", args => args->JSON.stringify)
       let logs = item.logs->Option.map(logs =>
         logs->Array.map((log): SvmHyperSyncClient.EventItems.log => {
-          kind: ?log.kind,
-          message: ?log.message,
+          kind: log.kind->Null.fromOption,
+          message: log.message->Null.fromOption,
         })
       )
 
@@ -463,8 +456,8 @@ let parse = (
             accounts: accountArguments,
             data,
             isInner: item.isInner->Option.getOr(false),
-            ?decoded,
-            ?logs,
+            argsJson,
+            logs: logs->Null.fromOption,
           },
           ~programName,
           ~instructionName,

package/src/SimulateItems.res.mjs

@@ -6,6 +6,7 @@ import * as Address from "./Address.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as BlockStore from "./sources/BlockStore.res.mjs";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
@@ -245,15 +246,10 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
             }) : [];
         }
         let data = Stdlib_Option.getOr(rawJson.data, Stdlib_Option.getOr(eventConfig.discriminator, "0x"));
-        let decoded = Stdlib_Option.map(rawJson.args, args => ({
-          name: match$2,
-          argsJson: JSON.stringify(args),
-          accountsJson: "{}",
-          extraAccounts: []
-        }));
+        let argsJson = Stdlib_Option.mapOr(rawJson.args, "{}", args => JSON.stringify(args));
         let logs = Stdlib_Option.map(rawJson.logs, logs => logs.map(log => ({
-          kind: log.kind,
-          message: log.message
+          kind: Stdlib_Null.fromOption(log.kind),
+          message: Stdlib_Null.fromOption(log.message)
         })));
         let liveRegistrations = liveRegistrationsFor(config, chainId, eventConfig);
         if (Utils.$$Array.isEmpty(liveRegistrations)) {
@@ -316,8 +312,8 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
             accounts: accountArguments,
             data: data,
             isInner: Stdlib_Option.getOr(rawJson.isInner, false),
-            decoded: decoded,
-            logs: logs
+            argsJson: argsJson,
+            logs: Stdlib_Null.fromOption(logs)
           }, match$1, match$2, eventConfig, newrecord.fieldSelection);
           payload["srcAddress"] = programId;
           items.push({