envio 3.7.0 → 3.9.0

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,115 @@ 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.pre",
+  "lamports.post",
+  "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 +639,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 +651,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 +668,6 @@ let buildSvmInstructionEventConfig = (
     programId,
     discriminator,
     discriminatorByteLen,
-    includeLogs,
     fieldSelection,
     accountFilters,
     isInner,
@@ -561,6 +684,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 +695,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 ==============

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,83 @@ 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.pre",
+  "lamports.post",
+  "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 +452,6 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
     programId: programId,
     discriminator: discriminator,
     discriminatorByteLen: discriminatorByteLen,
-    includeLogs: includeLogs,
     accountFilters: accountFilters,
     isInner: isInner,
     accounts: accounts,
@@ -375,7 +460,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 +470,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 +523,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 +559,11 @@ export {
   resolveFieldSelection,
   internalBlockFields,
   rawEventBlockFields,
-  selectionKinds,
+  evmSelectionKinds,
+  svmSelectionKinds,
+  quotedJoin,
   validateFieldsShapeOrThrow,
+  selectionList,
   validBlockFields,
   validTransactionFields,
   parseFieldsOrThrow,
@@ -483,6 +571,12 @@ export {
   buildEvmEventConfig,
   buildEvmOnEventRegistration,
   alwaysIncludedSvmBlockFields,
+  validSvmInstructionFields,
+  validSvmTransactionFields,
+  validSvmAccountActivityFields,
+  validSvmBlockFields,
+  validSvmLogFields,
+  resolveSvmInlineFieldSelection,
   buildSvmInstructionEventConfig,
   buildSvmOnEventRegistration,
   buildFuelEventConfig,