envio 3.7.0 → 3.8.0

package/src/Config.res

@@ -33,13 +33,19 @@ type sourceConfig =
   // A `simulate` run: the items the test fed in, parsed against the chain's
   // registrations. The source itself is built with the chain's address store,
   // like every other source, so it can apply the same gates.
-  | SimulateSourceConfig({items: array<Internal.item>, endBlock: int})
+  | SimulateSourceConfig({
+      items: array<Internal.item>,
+      endBlock: int,
+      transactionStore?: TransactionStore.t,
+      blockStore?: BlockStore.t,
+    })
   // For tests: pass custom sources directly
   | CustomSources(array<Source.t>)
 
 type chain = {
   name: string,
   id: ChainId.t,
+  ecosystem: Ecosystem.name,
   startBlock: int,
   endBlock?: int,
   maxReorgDepth: int,
@@ -183,6 +189,7 @@ module EnvioAddresses = {
     // The table already keys rows by chain through the composite `id`, so the
     // per-chain mode must not append a second chain-id column to it.
     crossChain: true,
+    internal: true,
   }->Internal.fromGenericEntityConfig
 }
 
@@ -235,9 +242,6 @@ let svmEventDescriptorSchema = S.schema(s =>
   {
     "discriminator": s.matches(S.option(S.string)),
     "discriminatorByteLen": s.matches(S.int),
-    "transactionFields": s.matches(S.array(Internal.svmTransactionFieldSchema)),
-    "blockFields": s.matches(S.option(S.array(Internal.svmBlockFieldSchema))),
-    "includeLogs": s.matches(S.bool),
     // An array of AND-groups OR-ed together: the CLI normalizes both the flat
     // and `any_of` YAML shapes to `Vec<Vec<SvmAccountFilterJson>>`.
     "accountFilters": s.matches(
@@ -348,10 +352,18 @@ let propertySchema = S.schema(s =>
   }
 )
 
+let clickhouseSkippingIndexSchema: S.t<Internal.clickhouseSkippingIndex> = S.object(s => {
+  Internal.name: s.field("name", S.string),
+  expr: s.field("expr", S.string),
+  type_: s.field("type", S.string),
+  granularity: ?s.field("granularity", S.option(S.int)),
+})
+
 let clickhouseTableOptionsSchema: S.t<Internal.clickhouseTableOptions> = S.object(s => {
   Internal.partitionBy: ?s.field("partitionBy", S.option(S.string)),
   orderBy: ?s.field("orderBy", S.option(S.array(S.string))),
   ttl: ?s.field("ttl", S.option(S.string)),
+  skippingIndexes: ?s.field("skippingIndexes", S.option(S.array(clickhouseSkippingIndexSchema))),
 })
 
 // The entity's `clickhouse` storage arg mirrors the @storage directive:
@@ -377,6 +389,7 @@ let entityJsonSchema = S.schema(s =>
     "name": s.matches(S.string),
     "crossChain": s.matches(S.option(S.bool)),
     "storage": s.matches(S.option(entityStorageSchema)),
+    "internal": s.matches(S.option(S.bool)),
     "properties": s.matches(S.array(propertySchema)),
     "derivedFields": s.matches(S.option(S.array(derivedFieldSchema))),
     "compositeIndices": s.matches(S.option(S.array(S.array(compositeIndexFieldSchema)))),
@@ -580,6 +593,7 @@ let parseEntitiesFromJson = (
       table,
       storage,
       crossChain,
+      internal: entityJson["internal"]->Option.getOr(false),
     }->Internal.fromGenericEntityConfig
   })
 }
@@ -796,9 +810,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
                 "svm": option<{
                   "discriminator": option<string>,
                   "discriminatorByteLen": int,
-                  "transactionFields": array<Internal.svmTransactionField>,
-                  "blockFields": option<array<Internal.svmBlockField>>,
-                  "includeLogs": bool,
                   "accountFilters": option<
                     array<array<{"position": int, "values": array<string>}>>,
                   >,
@@ -832,9 +843,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
             ~programId,
             ~discriminator=svm["discriminator"],
             ~discriminatorByteLen=svm["discriminatorByteLen"],
-            ~transactionFields=svm["transactionFields"],
-            ~blockFields=?svm["blockFields"],
-            ~includeLogs=svm["includeLogs"],
             ~accountFilters,
             ~isInner=svm["isInner"],
             ~accounts=svm["accounts"]->Option.getOr([]),
@@ -1012,6 +1020,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
       {
         name: chainName,
         id: chainId,
+        ecosystem: ecosystemName,
         startBlock: publicChainConfig["startBlock"],
         endBlock: ?publicChainConfig["endBlock"],
         maxReorgDepth: switch ecosystemName {

package/src/Config.res.mjs

@@ -70,7 +70,8 @@ let entityConfig = {
   schema: schema,
   table: table,
   storage: entityConfig_storage,
-  crossChain: true
+  crossChain: true,
+  internal: true
 };
 
 let EnvioAddresses = {
@@ -124,9 +125,6 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
 let svmEventDescriptorSchema = S$RescriptSchema.schema(s => ({
   discriminator: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   discriminatorByteLen: s.m(S$RescriptSchema.int),
-  transactionFields: s.m(S$RescriptSchema.array(Internal.svmTransactionFieldSchema)),
-  blockFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.svmBlockFieldSchema))),
-  includeLogs: s.m(S$RescriptSchema.bool),
   accountFilters: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
     position: s.m(S$RescriptSchema.int),
     values: s.m(S$RescriptSchema.array(S$RescriptSchema.string))
@@ -204,10 +202,18 @@ let propertySchema = S$RescriptSchema.schema(s => ({
   description: s.m(S$RescriptSchema.option(S$RescriptSchema.string))
 }));
 
+let clickhouseSkippingIndexSchema = S$RescriptSchema.object(s => ({
+  name: s.f("name", S$RescriptSchema.string),
+  expr: s.f("expr", S$RescriptSchema.string),
+  type: s.f("type", S$RescriptSchema.string),
+  granularity: s.f("granularity", S$RescriptSchema.option(S$RescriptSchema.int))
+}));
+
 let clickhouseTableOptionsSchema = S$RescriptSchema.object(s => ({
   partitionBy: s.f("partitionBy", S$RescriptSchema.option(S$RescriptSchema.string)),
   orderBy: s.f("orderBy", S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
-  ttl: s.f("ttl", S$RescriptSchema.option(S$RescriptSchema.string))
+  ttl: s.f("ttl", S$RescriptSchema.option(S$RescriptSchema.string)),
+  skippingIndexes: s.f("skippingIndexes", S$RescriptSchema.option(S$RescriptSchema.array(clickhouseSkippingIndexSchema)))
 }));
 
 let entityClickhouseStorageJsonSchema = S$RescriptSchema.union([
@@ -230,6 +236,7 @@ let entityJsonSchema = S$RescriptSchema.schema(s => ({
   name: s.m(S$RescriptSchema.string),
   crossChain: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   storage: s.m(S$RescriptSchema.option(entityStorageSchema)),
+  internal: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   properties: s.m(S$RescriptSchema.array(propertySchema)),
   derivedFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(derivedFieldSchema))),
   compositeIndices: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.array(compositeIndexFieldSchema)))),
@@ -400,7 +407,8 @@ function parseEntitiesFromJson(entitiesJson, enumConfigsByName, globalStorage, d
       schema: schema,
       table: table,
       storage: storage,
-      crossChain: crossChain
+      crossChain: crossChain,
+      internal: Stdlib_Option.getOr(entityJson.internal, false)
     };
   });
 }
@@ -564,7 +572,7 @@ function fromPublic(publicConfigJson) {
               position: af.position,
               values: af.values
             })));
-            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, svm.includeLogs, svm.transactionFields, svm.blockFields, accountFilters, svm.isInner, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes);
+            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, accountFilters, svm.isInner, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes);
         }
       });
     } else {
@@ -696,6 +704,7 @@ function fromPublic(publicConfigJson) {
     return {
       name: chainName,
       id: chainId,
+      ecosystem: ecosystemName,
       startBlock: publicChainConfig.startBlock,
       endBlock: publicChainConfig.endBlock,
       maxReorgDepth: tmp,
@@ -1097,6 +1106,7 @@ export {
   compositeIndexFieldSchema,
   derivedFieldSchema,
   propertySchema,
+  clickhouseSkippingIndexSchema,
   clickhouseTableOptionsSchema,
   entityClickhouseStorageJsonSchema,
   entityStorageSchema,

package/src/Envio.res

@@ -20,58 +20,48 @@ type svmOnSlotArgs<'context> = {
   context: 'context,
 }
 
-/** Borsh-decoded instruction view. Present whenever a `ProgramSchema` was
- attached to the program (bundled schema, Anchor IDL, or hand-written YAML
- `accounts`/`args`). Absent (`None`) when no schema applied or the
- discriminator didn't match any registered instruction. */
-type svmInstructionParams = {
-  /** Schema-declared instruction name (matches the codegen module suffix). */
-  name: string,
-  /** Borsh-decoded args. `JSON.Object({})` for no-arg instructions
-   (e.g. `VerifyCollection`). POC types this as raw `JSON.t`; cast at the
-   handler with `(json :> MyArgsType)` until typed codegen lands. */
-  args: JSON.t,
-  /** Named accounts in schema order. Keys are exactly the schema-declared
-   names; values are base58 pubkey strings. */
-  accounts: dict<string>,
-  /** Accounts beyond the schema's named list (Anchor `remaining_accounts`,
-   IDL drift). `[]` when counts match. */
-  extraAccounts: array<string>,
+type svmLamports = {
+  pre: bigint,
+  post: bigint,
 }
 
-type svmTokenBalance = {
-  account?: SvmTypes.Pubkey.t,
-  mint?: SvmTypes.Pubkey.t,
-  /** Owner at the end of the transaction, falling back to the owner on entry
-   when the account was closed during it. Pre and post owners differ only when
-   a `SetAuthority(AccountOwner)` runs mid-transaction. */
-  owner?: SvmTypes.Pubkey.t,
-  /** Mint decimals, for scaling the raw amounts below. */
-  decimals?: int,
-  /** Raw amount in base units before the transaction. Absent when the token
-   account was created during it. */
+type svmAccountToken = {
+  mint: SvmTypes.Pubkey.t,
+  owner: SvmTypes.Pubkey.t,
+  decimals: int,
   preAmount?: bigint,
-  /** Raw amount in base units after the transaction. Absent when the token
-   account was closed during it. */
   postAmount?: bigint,
 }
 
+type svmAccountActivity = {
+  address: SvmTypes.Pubkey.t,
+  transactionAccountIndex?: int,
+  isSigner?: bool,
+  isWritable?: bool,
+  lamports?: svmLamports,
+  token?: svmAccountToken,
+}
+
+type svmInstructionAccount = {
+  address: SvmTypes.Pubkey.t,
+  accountName: string,
+  instructionAccountIndex: int,
+  activity?: svmAccountActivity,
+}
+
 type svmTransaction = {
   transactionIndex?: int,
-  /** The transaction's identifying signature (`allSignatures[0]`). */
-  signature: string,
+  signature?: string,
   feePayer?: SvmTypes.Pubkey.t,
   success?: bool,
   err?: string,
   fee?: bigint,
   computeUnitsConsumed?: bigint,
-  accountKeys: array<SvmTypes.Pubkey.t>,
+  accountKeys?: array<SvmTypes.Pubkey.t>,
   recentBlockhash?: string,
   version?: string,
-  /** Every signature on the transaction, in message order; the first is
-   `signature`. Longer than one element only for a multi-signer transaction. */
-  allSignatures: array<string>,
-  tokenBalances?: array<svmTokenBalance>,
+  allSignatures?: array<string>,
+  accountActivities?: array<svmAccountActivity>,
 }
 
 type svmLog = {
@@ -79,57 +69,29 @@ type svmLog = {
   message: string,
 }
 
-/** Block context for a matched instruction. `slot`/`hash` are always present;
- `time` can still be absent — HyperSync/Solana may not report a block time for
- every slot. Every other field is opt-in via `field_selection.block_fields`,
- materialised from the per-chain block store at batch prep. */
-type svmInstructionBlock = {
-  /** Slot this instruction's block was matched in. */
+type svmBlock = {
   slot: int,
-  /** Unix block time (seconds). */
   time?: int,
-  hash: string,
-  /** Block height (distinct from slot). Absent when not selected via
-   `field_selection.block_fields`. */
+  hash?: string,
   height?: int,
   parentSlot?: int,
   parentHash?: string,
 }
 
-/** The per-instruction payload handlers receive as their `instruction`
- argument. Carries the matched instruction's own fields plus the
- program/instruction names, parent transaction, scoped logs, and block. */
 type svmInstruction = {
-  /** Program name as declared under `programs[].name` in `config.yaml`. */
   programName: string,
-  /** Instruction name as declared under `instructions[].name` in
-   `config.yaml`. */
   instructionName: string,
-  programId: SvmTypes.Pubkey.t,
-  /** Raw instruction bytes as `0x`-prefixed hex. */
-  data: string,
-  accounts: array<SvmTypes.Pubkey.t>,
-  /** Path through the call tree: `[outerIndex]` for top-level instructions,
-   appended child indices for inner CPI calls. */
-  instructionAddress: array<int>,
-  isInner: bool,
-  /** Discriminator prefixes pre-extracted by HyperSync. Each is `Some` only
-   when the underlying instruction is at least that long. */
-  d1?: string,
-  d2?: string,
-  d4?: string,
-  d8?: string,
-  /** Borsh-decoded params view. See [[svmInstructionParams]]. */
-  params?: svmInstructionParams,
-  /** Parent transaction. Carries only the fields selected via
-   `field_selection.transaction_fields`; absent when none are selected. */
+  discriminator: string,
+  programId?: SvmTypes.Pubkey.t,
+  data?: string,
+  path?: array<int>,
+  isInner?: bool,
+  args?: JSON.t,
+  accounts?: dict<svmInstructionAccount>,
+  accountArguments?: array<SvmTypes.Pubkey.t>,
   transaction?: svmTransaction,
-  /** Program log entries scoped to this instruction. Absent when the
-   per-instruction `include_logs` flag is `false`. */
   logs?: array<svmLog>,
-  // Omitted on construction; materialised onto the payload at batch prep,
-  // before a handler ever reads it.
-  block?: svmInstructionBlock,
+  block?: svmBlock,
 }
 
 /** Arguments passed to handlers registered via `indexer.onInstruction`. */
@@ -315,6 +277,22 @@ type fuelSimulateItem = {
   transaction?: fuelTransactionInput,
 }
 
+type svmSimulateItem = {
+  program: string,
+  instruction: string,
+  slot?: int,
+  path?: array<int>,
+  programId?: string,
+  data?: string,
+  isInner?: bool,
+  args?: JSON.t,
+  accounts?: dict<{address: string}>,
+  accountArguments?: array<string>,
+  logs?: array<{kind?: string, message?: string}>,
+  block?: svmBlock,
+  transaction?: unknown,
+}
+
 // Detects contexts where a full-screen TUI is counter-productive: piped/redirected
 // stdout, CI, and coding agents. `CLAUDECODE` is set by Claude Code; `CI` is the
 // de-facto convention across CI providers; `TERM=dumb` is set by editors/tools

package/src/EventConfigBuilder.res

@@ -310,33 +310,47 @@ let internalBlockFields = ["number"]
 // selected.
 let rawEventBlockFields = ["hash", "timestamp"]
 
-let selectionKinds = ["block", "transaction"]
+let evmSelectionKinds = ["block", "transaction"]
+let svmSelectionKinds = ["instruction", "transaction", "accountActivity", "block", "log"]
 
 // A handler written in plain JS gets no type error for a `blocks`/`transactions`
 // typo, and an unrecognised key would read as an empty selection — silently
 // dropping every field `config.yaml` selected. Rejected here so the option is
 // held to the same shape whether or not the project type-checks it.
-let validateFieldsShapeOrThrow = (fields: Internal.evmFieldsSelection, ~registration: string) => {
-  let raw = fields->(Utils.magic: Internal.evmFieldsSelection => unknown)
-  if typeof(raw) !== #object || raw === %raw(`null`) || Array.isArray(raw) {
+let quotedJoin = (names: array<string>) =>
+  names->Array.map(name => `"${name}"`)->Array.joinUnsafe(", ")
+
+let validateFieldsShapeOrThrow = (
+  fields: unknown,
+  ~registration: string,
+  ~validKeys: array<string>,
+  ~shapeNoun: string,
+) => {
+  if typeof(fields) !== #object || fields === %raw(`null`) || Array.isArray(fields) {
     JsError.throwWithMessage(
-      `The fields option of ${registration} must be an object of block and transaction field names.`,
+      `The fields option of ${registration} must be an object of ${shapeNoun} field names.`,
     )
   }
-  raw
+  fields
   ->(Utils.magic: unknown => dict<unknown>)
   ->Dict.keysToArray
   ->Array.forEach(key =>
-    if !(selectionKinds->Array.includes(key)) {
+    if !(validKeys->Array.includes(key)) {
       JsError.throwWithMessage(
-        `Invalid "${key}" key in the fields option of ${registration}. Valid keys: ${selectionKinds->Array.joinUnsafe(
-            ", ",
+        `Invalid "${key}" key in the fields option of ${registration}. Valid keys: ${quotedJoin(
+            validKeys,
           )}.`,
       )
     }
   )
 }
 
+let selectionList = (fields: unknown, key: string): option<array<string>> =>
+  switch (fields->(Utils.magic: unknown => dict<unknown>))->Dict.get(key) {
+  | None => None
+  | Some(value) => Some(value->(Utils.magic: unknown => array<string>))
+  }
+
 let validBlockFields = Utils.Set.fromArray(Evm.blockFields)
 let validTransactionFields = Utils.Set.fromArray(Evm.transactionFields)
 
@@ -345,6 +359,7 @@ let parseFieldsOrThrow = (
   ~valid: Utils.Set.t<string>,
   ~kind: string,
   ~registration: string,
+  ~rejectEmpty=false,
 ) => {
   let seen = Utils.Set.make()
   let fields = switch fields {
@@ -358,9 +373,9 @@ let parseFieldsOrThrow = (
   fields->Array.forEach(name => {
     if !(valid->Utils.Set.has(name)) {
       JsError.throwWithMessage(
-        `Invalid "${name}" field in the fields.${kind} option of ${registration}. Valid ${kind} fields: ${valid
-          ->Utils.Set.toArray
-          ->Array.joinUnsafe(", ")}.`,
+        `Invalid "${name}" field in the fields.${kind} option of ${registration}. Valid ${kind} fields: ${quotedJoin(
+          valid->Utils.Set.toArray,
+        )}.`,
       )
     }
     if seen->Utils.Set.has(name) {
@@ -370,6 +385,11 @@ let parseFieldsOrThrow = (
     }
     seen->Utils.Set.add(name)->ignore
   })
+  if rejectEmpty && fields->Array.length === 0 {
+    JsError.throwWithMessage(
+      `The fields.${kind} option of ${registration} must list at least one field.`,
+    )
+  }
   seen
 }
 
@@ -377,21 +397,26 @@ let parseFieldsOrThrow = (
 // option itself (the names are for error messages), never on the chain, so one
 // `onEvent` call resolves once and shares the result across every chain.
 let resolveInlineFieldSelection = (
-  fields: Internal.evmFieldsSelection,
+  fields: unknown,
   ~contractName: string,
   ~eventName: string,
   ~enableRawEvents: bool,
 ): Internal.fieldSelection => {
   let registration = `the "${eventName}" event registration on contract "${contractName}"`
-  validateFieldsShapeOrThrow(fields, ~registration)
+  validateFieldsShapeOrThrow(
+    fields,
+    ~registration,
+    ~validKeys=evmSelectionKinds,
+    ~shapeNoun="block and transaction",
+  )
   let blockFields = parseFieldsOrThrow(
-    fields.block,
+    selectionList(fields, "block"),
     ~valid=validBlockFields,
     ~kind="block",
     ~registration,
   )
   let transactionFields = parseFieldsOrThrow(
-    fields.transaction,
+    selectionList(fields, "transaction"),
     ~valid=validTransactionFields,
     ~kind="transaction",
     ~registration,
@@ -498,9 +523,117 @@ let buildEvmOnEventRegistration = (
 
 // ============== Build SVM instruction event config ==============
 
-// Always-included block fields (slot, time, hash) are prepended at runtime so
-// they're always present regardless of config.
-let alwaysIncludedSvmBlockFields: array<Internal.svmBlockField> = [Slot, Time, Hash]
+// `block.slot` is the item's own key, so an inline selection carries it
+// whether or not the handler listed it.
+let alwaysIncludedSvmBlockFields = ["slot"]
+
+let validSvmInstructionFields = Utils.Set.fromArray([
+  "args",
+  "accounts",
+  "accountArguments",
+  "programId",
+  "data",
+  "path",
+  "isInner",
+])
+let validSvmTransactionFields = Utils.Set.fromArray([
+  "transactionIndex",
+  "signature",
+  "feePayer",
+  "success",
+  "err",
+  "fee",
+  "computeUnitsConsumed",
+  "accountKeys",
+  "recentBlockhash",
+  "version",
+  "allSignatures",
+])
+let validSvmAccountActivityFields = Utils.Set.fromArray([
+  "address",
+  "transactionAccountIndex",
+  "isSigner",
+  "isWritable",
+  "lamports",
+  "lamports.pre",
+  "lamports.post",
+  "token",
+  "token.mint",
+  "token.owner",
+  "token.decimals",
+  "token.preAmount",
+  "token.postAmount",
+])
+let validSvmBlockFields = Utils.Set.fromArray([
+  "slot",
+  "time",
+  "hash",
+  "height",
+  "parentSlot",
+  "parentHash",
+])
+let validSvmLogFields = Utils.Set.fromArray(["kind", "message"])
+
+let resolveSvmInlineFieldSelection = (
+  fields: unknown,
+  ~contractName: string,
+  ~eventName: string,
+): Internal.fieldSelection => {
+  let registration = `the "${eventName}" event registration on contract "${contractName}"`
+  validateFieldsShapeOrThrow(
+    fields,
+    ~registration,
+    ~validKeys=svmSelectionKinds,
+    ~shapeNoun="instruction, transaction, accountActivity, block and log",
+  )
+  let accountActivity = selectionList(fields, "accountActivity")
+  let log = selectionList(fields, "log")
+  let instructionFields = parseFieldsOrThrow(
+    selectionList(fields, "instruction"),
+    ~valid=validSvmInstructionFields,
+    ~kind="instruction",
+    ~registration,
+  )
+  let transactionFields = parseFieldsOrThrow(
+    selectionList(fields, "transaction"),
+    ~valid=validSvmTransactionFields,
+    ~kind="transaction",
+    ~registration,
+  )
+  let accountActivityFields = parseFieldsOrThrow(
+    accountActivity,
+    ~valid=validSvmAccountActivityFields,
+    ~kind="accountActivity",
+    ~registration,
+    ~rejectEmpty=accountActivity->Option.isSome,
+  )
+  let blockFields = parseFieldsOrThrow(
+    selectionList(fields, "block"),
+    ~valid=validSvmBlockFields,
+    ~kind="block",
+    ~registration,
+  )
+  let logFields = parseFieldsOrThrow(
+    log,
+    ~valid=validSvmLogFields,
+    ~kind="log",
+    ~registration,
+    ~rejectEmpty=log->Option.isSome,
+  )
+  blockFields->Utils.Set.addMany(alwaysIncludedSvmBlockFields)
+  if accountActivityFields->Utils.Set.size > 0 {
+    transactionFields->Utils.Set.add("accountActivities")->ignore
+  }
+  Internal.makeFieldSelection(
+    ~blockFields,
+    ~transactionFields,
+    ~instructionFields,
+    ~accountActivityFields,
+    ~logFields,
+    ~blockMaskFn=Svm.eventBlockFieldMask,
+    ~transactionMaskFn=Svm.eventTransactionFieldMask,
+  )
+}
 
 let buildSvmInstructionEventConfig = (
   ~contractName: string,
@@ -508,9 +641,6 @@ let buildSvmInstructionEventConfig = (
   ~programId: SvmTypes.Pubkey.t,
   ~discriminator: option<string>,
   ~discriminatorByteLen: int,
-  ~includeLogs: bool,
-  ~transactionFields: array<Internal.svmTransactionField>=[],
-  ~blockFields: array<Internal.svmBlockField>=[],
   ~accountFilters: array<Internal.svmAccountFilterGroup>,
   ~isInner: option<bool>,
   ~accounts: array<string>=[],
@@ -523,12 +653,8 @@ let buildSvmInstructionEventConfig = (
     ->(Utils.magic: S.t<JSON.t> => S.t<Internal.eventParams>)
 
   let fieldSelection = Internal.makeFieldSelection(
-    ~blockFields=Utils.Set.fromArray(Array.concat(alwaysIncludedSvmBlockFields, blockFields))->(
-      Utils.magic: Utils.Set.t<Internal.svmBlockField> => Utils.Set.t<string>
-    ),
-    ~transactionFields=Utils.Set.fromArray(transactionFields)->(
-      Utils.magic: Utils.Set.t<Internal.svmTransactionField> => Utils.Set.t<string>
-    ),
+    ~blockFields=Utils.Set.fromArray(alwaysIncludedSvmBlockFields),
+    ~transactionFields=Utils.Set.make(),
     ~blockMaskFn=Svm.eventBlockFieldMask,
     ~transactionMaskFn=Svm.eventTransactionFieldMask,
   )
@@ -544,7 +670,6 @@ let buildSvmInstructionEventConfig = (
     programId,
     discriminator,
     discriminatorByteLen,
-    includeLogs,
     fieldSelection,
     accountFilters,
     isInner,
@@ -561,6 +686,7 @@ let buildSvmOnEventRegistration = (
   ~isWildcard: bool,
   ~handler: option<Internal.handler>,
   ~contractRegister: option<Internal.contractRegister>,
+  ~fieldSelection: option<Internal.fieldSelection>=?,
   ~startBlock: option<int>=?,
 ): Internal.svmOnEventRegistration => {
   index: -1,
@@ -571,7 +697,10 @@ let buildSvmOnEventRegistration = (
   filterByAddresses: false,
   dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses=false),
   startBlock,
-  fieldSelection: eventConfig.fieldSelection,
+  fieldSelection: switch fieldSelection {
+  | Some(fieldSelection) => fieldSelection
+  | None => eventConfig.fieldSelection
+  },
 }
 
 // ============== Build Fuel event config ==============