envio 3.7.0 → 3.8.0

package/src/EventConfigBuilder.res.mjs

@@ -238,7 +238,7 @@ let alwaysIncludedBlockFields = [
 function resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet) {
   let selectedBlockFields = blockFields !== undefined ? new Set(alwaysIncludedBlockFields.concat(blockFields)) : globalBlockFieldsSet;
   let selectedTransactionFields = transactionFields !== undefined ? new Set(transactionFields) : globalTransactionFieldsSet;
-  return Internal.makeFieldSelection(selectedBlockFields, selectedTransactionFields, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
+  return Internal.makeFieldSelection(selectedBlockFields, selectedTransactionFields, undefined, undefined, undefined, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
 }
 
 let internalBlockFields = ["number"];
@@ -248,53 +248,76 @@ let rawEventBlockFields = [
   "timestamp"
 ];
 
-let selectionKinds = [
+let evmSelectionKinds = [
   "block",
   "transaction"
 ];
 
-function validateFieldsShapeOrThrow(fields, registration) {
+let svmSelectionKinds = [
+  "instruction",
+  "transaction",
+  "accountActivity",
+  "block",
+  "log"
+];
+
+function quotedJoin(names) {
+  return names.map(name => `"` + name + `"`).join(", ");
+}
+
+function validateFieldsShapeOrThrow(fields, registration, validKeys, shapeNoun) {
   if (typeof fields !== "object" || fields === null || Array.isArray(fields)) {
-    Stdlib_JsError.throwWithMessage(`The fields option of ` + registration + ` must be an object of block and transaction field names.`);
+    Stdlib_JsError.throwWithMessage(`The fields option of ` + registration + ` must be an object of ` + shapeNoun + ` field names.`);
   }
   Object.keys(fields).forEach(key => {
-    if (!selectionKinds.includes(key)) {
-      return Stdlib_JsError.throwWithMessage(`Invalid "` + key + `" key in the fields option of ` + registration + `. Valid keys: ` + selectionKinds.join(", ") + `.`);
+    if (!validKeys.includes(key)) {
+      return Stdlib_JsError.throwWithMessage(`Invalid "` + key + `" key in the fields option of ` + registration + `. Valid keys: ` + quotedJoin(validKeys) + `.`);
     }
   });
 }
 
+function selectionList(fields, key) {
+  let value = fields[key];
+  if (value !== undefined) {
+    return Primitive_option.valFromOption(value);
+  }
+}
+
 let validBlockFields = new Set(Evm.blockFields);
 
 let validTransactionFields = new Set(Evm.transactionFields);
 
-function parseFieldsOrThrow(fields, valid, kind, registration) {
+function parseFieldsOrThrow(fields, valid, kind, registration, rejectEmptyOpt) {
+  let rejectEmpty = rejectEmptyOpt !== undefined ? rejectEmptyOpt : false;
   let seen = new Set();
   let fields$1 = fields !== undefined ? (
       Array.isArray(fields) ? fields : Stdlib_JsError.throwWithMessage(`The fields.` + kind + ` option of ` + registration + ` must be an array of field names.`)
     ) : [];
   fields$1.forEach(name => {
     if (!valid.has(name)) {
-      Stdlib_JsError.throwWithMessage(`Invalid "` + name + `" field in the fields.` + kind + ` option of ` + registration + `. Valid ` + kind + ` fields: ` + Array.from(valid).join(", ") + `.`);
+      Stdlib_JsError.throwWithMessage(`Invalid "` + name + `" field in the fields.` + kind + ` option of ` + registration + `. Valid ` + kind + ` fields: ` + quotedJoin(Array.from(valid)) + `.`);
     }
     if (seen.has(name)) {
       Stdlib_JsError.throwWithMessage(`Duplicate "` + name + `" field in the fields.` + kind + ` option of ` + registration + `.`);
     }
     seen.add(name);
   });
+  if (rejectEmpty && fields$1.length === 0) {
+    Stdlib_JsError.throwWithMessage(`The fields.` + kind + ` option of ` + registration + ` must list at least one field.`);
+  }
   return seen;
 }
 
 function resolveInlineFieldSelection(fields, contractName, eventName, enableRawEvents) {
   let registration = `the "` + eventName + `" event registration on contract "` + contractName + `"`;
-  validateFieldsShapeOrThrow(fields, registration);
-  let blockFields = parseFieldsOrThrow(fields.block, validBlockFields, "block", registration);
-  let transactionFields = parseFieldsOrThrow(fields.transaction, validTransactionFields, "transaction", registration);
+  validateFieldsShapeOrThrow(fields, registration, evmSelectionKinds, "block and transaction");
+  let blockFields = parseFieldsOrThrow(selectionList(fields, "block"), validBlockFields, "block", registration, undefined);
+  let transactionFields = parseFieldsOrThrow(selectionList(fields, "transaction"), validTransactionFields, "transaction", registration, undefined);
   Utils.$$Set.addMany(blockFields, internalBlockFields);
   if (enableRawEvents) {
     Utils.$$Set.addMany(blockFields, rawEventBlockFields);
   }
-  return Internal.makeFieldSelection(blockFields, transactionFields, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
+  return Internal.makeFieldSelection(blockFields, transactionFields, undefined, undefined, undefined, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
 }
 
 function buildEvmEventConfig(contractName, eventName, sighash, params, blockFields, transactionFields, globalBlockFieldsSetOpt, globalTransactionFieldsSetOpt) {
@@ -342,20 +365,85 @@ function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractR
   };
 }
 
-let alwaysIncludedSvmBlockFields = [
+let alwaysIncludedSvmBlockFields = ["slot"];
+
+let validSvmInstructionFields = new Set([
+  "args",
+  "accounts",
+  "accountArguments",
+  "programId",
+  "data",
+  "path",
+  "isInner"
+]);
+
+let validSvmTransactionFields = new Set([
+  "transactionIndex",
+  "signature",
+  "feePayer",
+  "success",
+  "err",
+  "fee",
+  "computeUnitsConsumed",
+  "accountKeys",
+  "recentBlockhash",
+  "version",
+  "allSignatures"
+]);
+
+let validSvmAccountActivityFields = new Set([
+  "address",
+  "transactionAccountIndex",
+  "isSigner",
+  "isWritable",
+  "lamports",
+  "lamports.pre",
+  "lamports.post",
+  "token",
+  "token.mint",
+  "token.owner",
+  "token.decimals",
+  "token.preAmount",
+  "token.postAmount"
+]);
+
+let validSvmBlockFields = new Set([
   "slot",
   "time",
-  "hash"
-];
+  "hash",
+  "height",
+  "parentSlot",
+  "parentHash"
+]);
+
+let validSvmLogFields = new Set([
+  "kind",
+  "message"
+]);
 
-function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeLogs, transactionFieldsOpt, blockFieldsOpt, accountFilters, isInner, accountsOpt, argsOpt, definedTypesOpt) {
-  let transactionFields = transactionFieldsOpt !== undefined ? transactionFieldsOpt : [];
-  let blockFields = blockFieldsOpt !== undefined ? blockFieldsOpt : [];
+function resolveSvmInlineFieldSelection(fields, contractName, eventName) {
+  let registration = `the "` + eventName + `" event registration on contract "` + contractName + `"`;
+  validateFieldsShapeOrThrow(fields, registration, svmSelectionKinds, "instruction, transaction, accountActivity, block and log");
+  let accountActivity = selectionList(fields, "accountActivity");
+  let log = selectionList(fields, "log");
+  let instructionFields = parseFieldsOrThrow(selectionList(fields, "instruction"), validSvmInstructionFields, "instruction", registration, undefined);
+  let transactionFields = parseFieldsOrThrow(selectionList(fields, "transaction"), validSvmTransactionFields, "transaction", registration, undefined);
+  let accountActivityFields = parseFieldsOrThrow(accountActivity, validSvmAccountActivityFields, "accountActivity", registration, Stdlib_Option.isSome(accountActivity));
+  let blockFields = parseFieldsOrThrow(selectionList(fields, "block"), validSvmBlockFields, "block", registration, undefined);
+  let logFields = parseFieldsOrThrow(log, validSvmLogFields, "log", registration, Stdlib_Option.isSome(log));
+  Utils.$$Set.addMany(blockFields, alwaysIncludedSvmBlockFields);
+  if (accountActivityFields.size > 0) {
+    transactionFields.add("accountActivities");
+  }
+  return Internal.makeFieldSelection(blockFields, transactionFields, Primitive_option.some(instructionFields), Primitive_option.some(accountActivityFields), Primitive_option.some(logFields), Svm.eventBlockFieldMask, Svm.eventTransactionFieldMask);
+}
+
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, accountFilters, isInner, accountsOpt, argsOpt, definedTypesOpt) {
   let accounts = accountsOpt !== undefined ? accountsOpt : [];
   let args = argsOpt !== undefined ? argsOpt : null;
   let definedTypes = definedTypesOpt !== undefined ? definedTypesOpt : null;
   let paramsSchema = Utils.Schema.coerceToJsonPgType(S$RescriptSchema.json(false));
-  let fieldSelection = Internal.makeFieldSelection(new Set(alwaysIncludedSvmBlockFields.concat(blockFields)), new Set(transactionFields), Svm.eventBlockFieldMask, Svm.eventTransactionFieldMask);
+  let fieldSelection = Internal.makeFieldSelection(new Set(alwaysIncludedSvmBlockFields), new Set(), undefined, undefined, undefined, Svm.eventBlockFieldMask, Svm.eventTransactionFieldMask);
   return {
     id: discriminator !== undefined ? discriminator : "none",
     name: instructionName,
@@ -366,7 +454,6 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
     programId: programId,
     discriminator: discriminator,
     discriminatorByteLen: discriminatorByteLen,
-    includeLogs: includeLogs,
     accountFilters: accountFilters,
     isInner: isInner,
     accounts: accounts,
@@ -375,7 +462,7 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
   };
 }
 
-function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock) {
+function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, fieldSelection, startBlock) {
   return {
     index: -1,
     eventConfig: eventConfig,
@@ -385,7 +472,7 @@ function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractR
     filterByAddresses: false,
     dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
     startBlock: startBlock,
-    fieldSelection: eventConfig.fieldSelection
+    fieldSelection: fieldSelection !== undefined ? fieldSelection : eventConfig.fieldSelection
   };
 }
 
@@ -438,7 +525,7 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi) {
     contractName: contractName,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    fieldSelection: Internal.makeFieldSelection(new Set(Fuel.blockFields), new Set(Fuel.transactionFields), Fuel.eventBlockFieldMask, Fuel.eventTransactionFieldMask),
+    fieldSelection: Internal.makeFieldSelection(new Set(Fuel.blockFields), new Set(Fuel.transactionFields), undefined, undefined, undefined, Fuel.eventBlockFieldMask, Fuel.eventTransactionFieldMask),
     kind: fuelKind
   };
 }
@@ -474,8 +561,11 @@ export {
   resolveFieldSelection,
   internalBlockFields,
   rawEventBlockFields,
-  selectionKinds,
+  evmSelectionKinds,
+  svmSelectionKinds,
+  quotedJoin,
   validateFieldsShapeOrThrow,
+  selectionList,
   validBlockFields,
   validTransactionFields,
   parseFieldsOrThrow,
@@ -483,6 +573,12 @@ export {
   buildEvmEventConfig,
   buildEvmOnEventRegistration,
   alwaysIncludedSvmBlockFields,
+  validSvmInstructionFields,
+  validSvmTransactionFields,
+  validSvmAccountActivityFields,
+  validSvmBlockFields,
+  validSvmLogFields,
+  resolveSvmInlineFieldSelection,
   buildSvmInstructionEventConfig,
   buildSvmOnEventRegistration,
   buildFuelEventConfig,

package/src/HandlerRegister.res

@@ -154,6 +154,7 @@ let buildOnEventRegistrationWith = (
       ~isWildcard,
       ~handler,
       ~contractRegister,
+      ~fieldSelection?,
       ~startBlock?,
     ) :> Internal.onEventRegistration)
   | Evm =>
@@ -299,21 +300,29 @@ let addOnEventRegistration = (
   let fieldSelection = switch eventOptions->Option.flatMap(v => v.fields) {
   | None => None
   | Some(fields) =>
-    // Only EVM resolves a registration selection of its own; Fuel and SVM take
-    // theirs from the event config, so an inline one would be silently dropped.
-    if registration.config.ecosystem.name !== Evm {
+    switch registration.config.ecosystem.name {
+    | Evm =>
+      Some(
+        EventConfigBuilder.resolveInlineFieldSelection(
+          fields,
+          ~contractName,
+          ~eventName,
+          ~enableRawEvents=registration.config.enableRawEvents,
+        ),
+      )
+    | Svm =>
+      Some(
+        EventConfigBuilder.resolveSvmInlineFieldSelection(
+          fields,
+          ~contractName,
+          ~eventName,
+        ),
+      )
+    | Fuel =>
       JsError.throwWithMessage(
         `The fields option of the "${eventName}" event registration on contract "${contractName}" is only supported on EVM. Select the fields in your config instead.`,
       )
     }
-    Some(
-      EventConfigBuilder.resolveInlineFieldSelection(
-        fields,
-        ~contractName,
-        ~eventName,
-        ~enableRawEvents=registration.config.enableRawEvents,
-      ),
-    )
   }
   let matched = ref(false)
   registration.config.chainMap

package/src/HandlerRegister.res.mjs

@@ -102,7 +102,7 @@ function buildOnEventRegistrationWith(config, chainId, eventConfig, isWildcard,
     case "fuel" :
       return EventConfigBuilder.buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock);
     case "svm" :
-      return EventConfigBuilder.buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock);
+      return EventConfigBuilder.buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, fieldSelection, startBlock);
   }
 }
 
@@ -200,7 +200,24 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
   let isWildcard = Stdlib_Option.getOr(Stdlib_Option.flatMap(eventOptions, v => v.wildcard), false);
   let where = Stdlib_Option.flatMap(eventOptions, v => v.where);
   let fields = Stdlib_Option.flatMap(eventOptions, v => v.fields);
-  let fieldSelection = fields !== undefined ? (registration.config.ecosystem.name !== "evm" ? Stdlib_JsError.throwWithMessage(`The fields option of the "` + eventName + `" event registration on contract "` + contractName + `" is only supported on EVM. Select the fields in your config instead.`) : undefined, EventConfigBuilder.resolveInlineFieldSelection(fields, contractName, eventName, registration.config.enableRawEvents)) : undefined;
+  let fieldSelection;
+  if (fields !== undefined) {
+    let fields$1 = Primitive_option.valFromOption(fields);
+    let match = registration.config.ecosystem.name;
+    switch (match) {
+      case "evm" :
+        fieldSelection = EventConfigBuilder.resolveInlineFieldSelection(fields$1, contractName, eventName, registration.config.enableRawEvents);
+        break;
+      case "fuel" :
+        fieldSelection = Stdlib_JsError.throwWithMessage(`The fields option of the "` + eventName + `" event registration on contract "` + contractName + `" is only supported on EVM. Select the fields in your config instead.`);
+        break;
+      case "svm" :
+        fieldSelection = EventConfigBuilder.resolveSvmInlineFieldSelection(fields$1, contractName, eventName);
+        break;
+    }
+  } else {
+    fieldSelection = undefined;
+  }
   let matched = {
     contents: false
   };
@@ -220,8 +237,8 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
   if (matched.contents) {
     return;
   }
-  let match = describeConfigured(registration, contractName);
-  let eventNames = match[1];
+  let match$1 = describeConfigured(registration, contractName);
+  let eventNames = match$1[1];
   let listOr = (names, empty) => {
     if (Utils.$$Array.isEmpty(names)) {
       return empty;
@@ -230,7 +247,7 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
     }
   };
   if (Utils.$$Array.isEmpty(eventNames)) {
-    return Stdlib_JsError.throwWithMessage(`Contract "` + contractName + `" is not configured on any chain, so its handler for "` + eventName + `" would never run. Add it to your config, or remove the registration. Configured contracts: ` + listOr(match[0], "none") + `.`);
+    return Stdlib_JsError.throwWithMessage(`Contract "` + contractName + `" is not configured on any chain, so its handler for "` + eventName + `" would never run. Add it to your config, or remove the registration. Configured contracts: ` + listOr(match$1[0], "none") + `.`);
   } else {
     return Stdlib_JsError.throwWithMessage(`Event "` + eventName + `" is not configured on contract "` + contractName + `", so its handler would never run. Add it to your config, or remove the registration. Configured events on "` + contractName + `": ` + listOr(eventNames, "none") + `.`);
   }

package/src/Hasura.res

@@ -286,9 +286,7 @@ let createSelectPermission = async (
 // column joins alongside the id — without it the relationship would resolve to
 // another chain's row with the same id.
 let makeColumnMapping = (~relationalKey, ~isDerivedFrom, ~chainIdColumn) => {
-  let pairs = [
-    isDerivedFrom ? `"id": "${relationalKey}"` : `"${relationalKey}": "id"`,
-  ]
+  let pairs = [isDerivedFrom ? `"id": "${relationalKey}"` : `"${relationalKey}": "id"`]
   switch chainIdColumn {
   | Some(column) => pairs->Array.push(`"${column}": "${column}"`)->ignore
   | None => ()
@@ -309,7 +307,6 @@ let createEntityRelationship = async (
   ~chainIdColumn: option<string>,
   ~comment: option<string>=?,
 ) => {
-
   let tableJson = {
     "schema": pgSchema,
     "name": tableName,
@@ -347,15 +344,7 @@ let createEntityRelationship = async (
   )
 }
 
-let trackDatabase = async (
-  ~endpoint,
-  ~auth,
-  ~pgSchema,
-  ~userEntities: array<Internal.entityConfig>,
-  ~aggregateEntities,
-  ~responseLimit,
-  ~schema,
-) => {
+let makeTableConfigs = (~userEntities: array<Internal.entityConfig>) => {
   let exposedInternalTableConfigs = [
     {
       tableName: InternalTable.RawEvents.table.tableName,
@@ -373,12 +362,27 @@ let trackDatabase = async (
       columnConfigs: dict{},
     },
   ]
-  let userTableConfigs = userEntities->Array.map(entity => {
-    tableName: entity.table.tableName,
-    description: entity.table.description,
-    columnConfigs: entity.table->makeColumnConfigs,
-  })
-  let tableConfigs = [exposedInternalTableConfigs, userTableConfigs]->Array.flat
+  let userTableConfigs =
+    userEntities
+    ->Array.filter(entity => !entity.internal)
+    ->Array.map(entity => {
+      tableName: entity.table.tableName,
+      description: entity.table.description,
+      columnConfigs: entity.table->makeColumnConfigs,
+    })
+  [exposedInternalTableConfigs, userTableConfigs]->Array.flat
+}
+
+let trackDatabase = async (
+  ~endpoint,
+  ~auth,
+  ~pgSchema,
+  ~userEntities: array<Internal.entityConfig>,
+  ~aggregateEntities,
+  ~responseLimit,
+  ~schema,
+) => {
+  let tableConfigs = makeTableConfigs(~userEntities)
   let tableNames = tableConfigs->Array.map(c => c.tableName)
 
   Logging.info("Tracking tables in Hasura")
@@ -414,10 +418,14 @@ let trackDatabase = async (
     ->Option.flatMap(e => e.table->Table.getChainIdField)
     ->Option.map(Table.getPgDbFieldName)
 
-  for i in 0 to userEntities->Array.length - 1 {
-    let entityConfig = userEntities->Array.getUnsafe(i)
+  // Relationships to an @internal entity can't exist here: codegen rejects a
+  // reference from an exposed entity to an @internal one.
+  let exposedEntities = userEntities->Array.filter(e => !e.internal)
+  for i in 0 to exposedEntities->Array.length - 1 {
+    let entityConfig = exposedEntities->Array.getUnsafe(i)
     let {tableName} = entityConfig.table
-    let ownChainIdColumn = entityConfig.table->Table.getChainIdField->Option.map(Table.getPgDbFieldName)
+    let ownChainIdColumn =
+      entityConfig.table->Table.getChainIdField->Option.map(Table.getPgDbFieldName)
     let sharedChainIdColumn = mappedEntity =>
       switch (ownChainIdColumn, chainIdColumnOf(mappedEntity)) {
       | (Some(column), Some(_)) => Some(column)

package/src/Hasura.res.mjs

@@ -285,7 +285,7 @@ async function createEntityRelationship(endpoint, auth, pgSchema, tableName, rel
   });
 }
 
-async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEntities, responseLimit, schema) {
+function makeTableConfigs(userEntities) {
   let exposedInternalTableConfigs = [
     {
       tableName: InternalTable.RawEvents.table.tableName,
@@ -303,15 +303,19 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
       columnConfigs: {}
     }
   ];
-  let userTableConfigs = userEntities.map(entity => ({
+  let userTableConfigs = userEntities.filter(entity => !entity.internal).map(entity => ({
     tableName: entity.table.tableName,
     description: entity.table.description,
     columnConfigs: makeColumnConfigs(entity.table)
   }));
-  let tableConfigs = [
+  return [
     exposedInternalTableConfigs,
     userTableConfigs
   ].flat();
+}
+
+async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEntities, responseLimit, schema) {
+  let tableConfigs = makeTableConfigs(userEntities);
   let tableNames = tableConfigs.map(c => c.tableName);
   Logging.info("Tracking tables in Hasura");
   await clearHasuraMetadata(endpoint, auth);
@@ -322,8 +326,9 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
     await createSelectPermission(endpoint, auth, tableName, pgSchema, responseLimit, aggregateEntities);
   }
   let chainIdColumnOf = entityName => Stdlib_Option.map(Stdlib_Option.flatMap(userEntities.find(e => e.name === entityName), e => Table.getChainIdField(e.table)), Table.getPgDbFieldName);
-  for (let i$1 = 0, i_finish$1 = userEntities.length; i$1 < i_finish$1; ++i$1) {
-    let entityConfig = userEntities[i$1];
+  let exposedEntities = userEntities.filter(e => !e.internal);
+  for (let i$1 = 0, i_finish$1 = exposedEntities.length; i$1 < i_finish$1; ++i$1) {
+    let entityConfig = exposedEntities[i$1];
     let match = entityConfig.table;
     let tableName$1 = match.tableName;
     let ownChainIdColumn = Stdlib_Option.map(Table.getChainIdField(entityConfig.table), Table.getPgDbFieldName);
@@ -365,6 +370,7 @@ export {
   createSelectPermission,
   makeColumnMapping,
   createEntityRelationship,
+  makeTableConfigs,
   trackDatabase,
 }
 /* Rest Not a pure module */

package/src/InMemoryStore.res

@@ -148,7 +148,7 @@ let prepareRollbackDiff = async (
   let _ = await persistence.allEntities
   ->Array.filter(entityConfig => entityConfig.storage.postgres)
   ->Array.map(async entityConfig => {
-    let (removals, restoredEntitiesResult) = await persistence.storage.getRollbackData(
+    let (removals, restoredEntities) = await persistence.storage.getRollbackData(
       ~entityConfig,
       ~rollbackTargetCheckpointId,
     )
@@ -166,11 +166,6 @@ let prepareRollbackDiff = async (
       )
     })
 
-    let restoredEntities =
-      restoredEntitiesResult
-      ->S.parseOrThrow(entityConfig.table->Table.pgRowsSchema)
-      ->(Utils.magic: array<unknown> => array<Internal.entity>)
-
     restoredEntities->Array.forEach((entity: Internal.entity) => {
       let scope = entity->takeRowScope(~entityConfig)
       setEntities->Utils.Dict.push(entityConfig.name, entity.id)

package/src/InMemoryStore.res.mjs

@@ -12,7 +12,6 @@ import * as InMemoryTable from "./InMemoryTable.res.mjs";
 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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
 function getInMemTable(state, entityConfig, scope) {
   let tmp;
@@ -125,8 +124,7 @@ async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDi
         checkpointId: rollbackDiffCheckpointId
       });
     });
-    let restoredEntities = S$RescriptSchema.parseOrThrow(match[1], Table.pgRowsSchema(entityConfig.table));
-    restoredEntities.forEach(entity => {
+    match[1].forEach(entity => {
       let scope = takeRowScope(entity, entityConfig);
       Utils.Dict.push(setEntities, entityConfig.name, entity.id);
       InMemoryTable.Entity.set(getInMemTable(state, entityConfig, scope), committedCheckpointId, {

package/src/Internal.res

@@ -149,8 +149,8 @@ type svmTransactionField =
   | @as("accountKeys") AccountKeys
   | @as("recentBlockhash") RecentBlockhash
   | @as("version") Version
-  | @as("tokenBalances") TokenBalances
   | @as("allSignatures") AllSignatures
+  | @as("accountActivities") AccountActivities
 
 let allSvmTransactionFields: array<svmTransactionField> = [
   TransactionIndex,
@@ -163,13 +163,12 @@ let allSvmTransactionFields: array<svmTransactionField> = [
   AccountKeys,
   RecentBlockhash,
   Version,
-  TokenBalances,
   AllSignatures,
+  AccountActivities,
 ]
-let svmTransactionFieldSchema = S.enum(allSvmTransactionFields)
 
-// All SVM block fields. `slot`/`time`/`hash` are always included; the rest are
-// selectable via `field_selection.block_fields` (see `allSvmBlockFields`).
+// All SVM block fields. `slot` is always included (the item's key); the rest
+// are selectable via handler `fields.block`.
 type svmBlockField =
   | @as("slot") Slot
   | @as("time") Time
@@ -178,9 +177,6 @@ type svmBlockField =
   | @as("parentSlot") ParentSlot
   | @as("parentHash") ParentHash
 
-let allSvmBlockFields: array<svmBlockField> = [Height, ParentSlot, ParentHash]
-let svmBlockFieldSchema = S.enum(allSvmBlockFields)
-
 // Static sets of field names whose source schemas must be wrapped with S.nullable.
 let evmNullableBlockFields = Utils.Set.fromArray(
   (
@@ -427,6 +423,9 @@ type indexingContract = {
 type fieldSelection = {
   blockFields: Utils.Set.t<string>,
   transactionFields: Utils.Set.t<string>,
+  instructionFields: Utils.Set.t<string>,
+  accountActivityFields: Utils.Set.t<string>,
+  logFields: Utils.Set.t<string>,
   // The sets precompiled to the store selections `ChainState` materialises with.
   blockMask: float,
   transactionMask: float,
@@ -438,11 +437,17 @@ type fieldSelection = {
 let makeFieldSelection = (
   ~blockFields: Utils.Set.t<string>,
   ~transactionFields: Utils.Set.t<string>,
+  ~instructionFields: Utils.Set.t<string>=Utils.Set.make(),
+  ~accountActivityFields: Utils.Set.t<string>=Utils.Set.make(),
+  ~logFields: Utils.Set.t<string>=Utils.Set.make(),
   ~blockMaskFn: Utils.Set.t<string> => float,
   ~transactionMaskFn: Utils.Set.t<string> => float,
 ): fieldSelection => {
   blockFields,
   transactionFields,
+  instructionFields,
+  accountActivityFields,
+  logFields,
   blockMask: blockMaskFn(blockFields),
   transactionMask: transactionMaskFn(transactionFields),
 }
@@ -459,6 +464,9 @@ let unionFields = (a, b) => a === b ? a : a->Utils.Set.union(b)
 let unionFieldSelection = (a: fieldSelection, b: fieldSelection): fieldSelection => {
   blockFields: unionFields(a.blockFields, b.blockFields),
   transactionFields: unionFields(a.transactionFields, b.transactionFields),
+  instructionFields: unionFields(a.instructionFields, b.instructionFields),
+  accountActivityFields: unionFields(a.accountActivityFields, b.accountActivityFields),
+  logFields: unionFields(a.logFields, b.logFields),
   blockMask: FieldMask.orMask(a.blockMask, b.blockMask),
   transactionMask: FieldMask.orMask(a.transactionMask, b.transactionMask),
 }
@@ -569,7 +577,6 @@ type svmInstructionEventConfig = {
    `dN` selector at query time and the dispatch-key precomputation in the
    router. */
   discriminatorByteLen: int,
-  includeLogs: bool,
   /** Disjunctive normal form: outer array is OR of AND-groups, inner array is
    AND across positions. Empty outer array means "no account filter". */
   accountFilters: array<svmAccountFilterGroup>,
@@ -747,9 +754,8 @@ let getItemChainId = item =>
   | Block({onBlockRegistration: {chainId}}) => chainId
   }
 
-// The `fields` option of an EVM `onEvent`/`contractRegister` registration:
-// the block and transaction fields the handler reads. Replaces the config
-// `field_selection` for this registration.
+// EVM `fields` bag. Parsed from the JS object as `unknown` at registration;
+// this record exists so ReScript tests can construct a typed EVM selection.
 type evmFieldsSelection = {
   block?: array<string>,
   transaction?: array<string>,
@@ -758,7 +764,7 @@ type evmFieldsSelection = {
 type eventOptions<'where> = {
   wildcard?: bool,
   where?: 'where,
-  fields?: evmFieldsSelection,
+  fields?: unknown,
 }
 
 type fuelSupplyParams = {
@@ -782,12 +788,23 @@ let fuelTransferParamsSchema = S.schema(s => {
 
 type entity = private {id: string}
 
+// A data skipping index emitted into the history table DDL as
+// `INDEX <name> <expr> TYPE <type> GRANULARITY <granularity>`.
+type clickhouseSkippingIndex = {
+  name: string,
+  expr: string,
+  @as("type")
+  type_: string,
+  granularity?: int,
+}
+
 // Raw ClickHouse expressions/field names from the entity's
 // @storage(clickhouse: {...}) directive, applied to the history table DDL.
 type clickhouseTableOptions = {
   partitionBy?: string,
   orderBy?: array<string>,
   ttl?: string,
+  skippingIndexes?: array<clickhouseSkippingIndex>,
 }
 
 // Per-entity storage resolved at parse time against the global storage
@@ -808,6 +825,9 @@ type genericEntityConfig<'entity> = {
   // entity's `@crossChain`. When false the table carries a chain-id column in
   // its primary key and every row belongs to exactly one chain.
   crossChain: bool,
+  // `@internal` on the entity: stored and usable in handlers as normal, but
+  // never exposed through the GraphQL API (no Hasura tracking).
+  internal: bool,
 }
 type entityConfig = genericEntityConfig<entity>
 external fromGenericEntityConfig: genericEntityConfig<'entity> => entityConfig = "%identity"