envio 3.3.0-alpha.7 → 3.3.0-alpha.9

package/src/sources/BlockStore.res.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.res.mjs";
+import * as FieldMask from "./FieldMask.res.mjs";
+
+function make(ecosystem, shouldChecksum) {
+  let ctor = Core.getAddon().BlockStore;
+  switch (ecosystem) {
+    case "evm" :
+      return ctor.newEvm(shouldChecksum);
+    case "fuel" :
+      return ctor.newFuel();
+    case "svm" :
+      return ctor.newSvm();
+  }
+}
+
+let makeMaskFn = FieldMask.makeMaskFn;
+
+export {
+  make,
+  makeMaskFn,
+}
+/* Core Not a pure module */

package/src/sources/EventRouter.res

@@ -96,16 +96,16 @@ let getEvmEventId = (~sighash, ~topicCount) => {
   sighash ++ "_" ++ topicCount->Int.toString
 }
 
-let fromEvmEventModsOrThrow = (events: array<Internal.evmEventConfig>, ~chain): t<
-  Internal.evmEventConfig,
+let fromEvmEventModsOrThrow = (events: array<Internal.evmOnEventRegistration>, ~chain): t<
+  Internal.evmOnEventRegistration,
 > => {
   let router = empty()
   events->Array.forEach(config => {
     router->addOrThrow(
-      config.id,
+      config.eventConfig.id,
       config,
-      ~contractName=config.contractName,
-      ~eventName=config.name,
+      ~contractName=config.eventConfig.contractName,
+      ~eventName=config.eventConfig.name,
       ~chain,
       ~isWildcard=config.isWildcard,
     )
@@ -131,21 +131,26 @@ type svmProgramOrdering = {
   byteLengthsDesc: array<int>,
 }
 
-let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConfig>, ~chain): (
-  t<Internal.svmInstructionEventConfig>,
+let fromSvmEventConfigsOrThrow = (events: array<Internal.svmOnEventRegistration>, ~chain): (
+  t<Internal.svmOnEventRegistration>,
   array<svmProgramOrdering>,
 ) => {
   let router = empty()
   events->Array.forEach(config => {
+    let eventConfig =
+      config.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
     // The router tag must include the programId so two programs declaring the
     // same discriminator coexist. The source-side lookup uses the same shape
     // via `getSvmEventId(~programId, ~discriminator)`.
-    let routerTag = getSvmEventId(~programId=config.programId, ~discriminator=config.discriminator)
+    let routerTag = getSvmEventId(
+      ~programId=eventConfig.programId,
+      ~discriminator=eventConfig.discriminator,
+    )
     router->addOrThrow(
       routerTag,
       config,
-      ~contractName=config.contractName,
-      ~eventName=config.name,
+      ~contractName=eventConfig.contractName,
+      ~eventName=eventConfig.name,
       ~chain,
       ~isWildcard=config.isWildcard,
     )
@@ -154,7 +159,9 @@ let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConf
   // Per-program list of declared discriminator byte lengths, sorted desc.
   let byProgram: dict<Utils.Set.t<int>> = Dict.make()
   events->Array.forEach(config => {
-    let key = config.programId->SvmTypes.Pubkey.toString
+    let eventConfig =
+      config.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+    let key = eventConfig.programId->SvmTypes.Pubkey.toString
     let set = switch byProgram->Utils.Dict.dangerouslyGetNonOption(key) {
     | Some(s) => s
     | None =>
@@ -162,7 +169,7 @@ let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConf
       byProgram->Dict.set(key, s)
       s
     }
-    let _ = set->Utils.Set.add(config.discriminatorByteLen)
+    let _ = set->Utils.Set.add(eventConfig.discriminatorByteLen)
   })
   let ordering =
     byProgram

package/src/sources/EventRouter.res.mjs

@@ -103,7 +103,7 @@ function getEvmEventId(sighash, topicCount) {
 
 function fromEvmEventModsOrThrow(events, chain) {
   let router = {};
-  events.forEach(config => addOrThrow$1(router, config.id, config, config.contractName, config.isWildcard, config.name, chain));
+  events.forEach(config => addOrThrow$1(router, config.eventConfig.id, config, config.eventConfig.contractName, config.isWildcard, config.eventConfig.name, chain));
   return router;
 }
 
@@ -118,12 +118,14 @@ function getSvmEventId(programId, discriminator) {
 function fromSvmEventConfigsOrThrow(events, chain) {
   let router = {};
   events.forEach(config => {
-    let routerTag = getSvmEventId(config.programId, config.discriminator);
-    addOrThrow$1(router, routerTag, config, config.contractName, config.isWildcard, config.name, chain);
+    let eventConfig = config.eventConfig;
+    let routerTag = getSvmEventId(eventConfig.programId, eventConfig.discriminator);
+    addOrThrow$1(router, routerTag, config, eventConfig.contractName, config.isWildcard, eventConfig.name, chain);
   });
   let byProgram = {};
   events.forEach(config => {
-    let key = config.programId;
+    let eventConfig = config.eventConfig;
+    let key = eventConfig.programId;
     let s = byProgram[key];
     let set;
     if (s !== undefined) {
@@ -133,7 +135,7 @@ function fromSvmEventConfigsOrThrow(events, chain) {
       byProgram[key] = s$1;
       set = s$1;
     }
-    set.add(config.discriminatorByteLen);
+    set.add(eventConfig.discriminatorByteLen);
   });
   let ordering = Object.entries(byProgram).map(param => {
     let sorted = Array.from(param[1]).toSorted((a, b) => b - a | 0);

package/src/sources/Evm.res

@@ -10,7 +10,9 @@ type payload = {
   srcAddress: Address.t,
   logIndex: int,
   transaction?: Internal.eventTransaction,
-  block: Internal.eventBlock,
+  // HyperSync omits `block` (it lives raw in the per-chain store and is written
+  // onto the payload at batch prep); RPC/simulate build it inline.
+  block?: Internal.eventBlock,
 }
 external fromPayload: payload => Internal.eventPayload = "%identity"
 external toPayload: Internal.eventPayload => payload = "%identity"
@@ -27,6 +29,42 @@ let transactionFields =
 // per event at config build and cached on the event config.
 let eventTransactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
 
+// Ordered block field names. The index of each is the field code shared with the
+// Rust store (`EvmBlockField`) — keep this order in sync.
+let blockFields = [
+  "number",
+  "timestamp",
+  "hash",
+  "parentHash",
+  "nonce",
+  "sha3Uncles",
+  "logsBloom",
+  "transactionsRoot",
+  "stateRoot",
+  "receiptsRoot",
+  "miner",
+  "difficulty",
+  "totalDifficulty",
+  "extraData",
+  "size",
+  "gasLimit",
+  "gasUsed",
+  "uncles",
+  "baseFeePerGas",
+  "blobGasUsed",
+  "excessBlobGas",
+  "parentBeaconBlockRoot",
+  "withdrawalsRoot",
+  "l1BlockNumber",
+  "sendCount",
+  "sendRoot",
+  "mixHash",
+]
+
+// One event's selected block fields → store selection bitmask. Computed per
+// event at config build and cached on the event config.
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields)
+
 let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.hash
     delete fields.number
@@ -52,8 +90,11 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // range chunk is validated by `eventBlockRangeSchema` in
   // `LogSelection.res` which rejects `_lte`/`_every` (use `onBlock` for
   // stride- and endBlock-based block handlers).
+  // `S.strict` on the inner object rejects unknown `block` fields (e.g. a
+  // `numbre` typo or `block: {timestamp: ...}`) instead of silently
+  // ignoring them.
   onEventBlockFilterSchema: S.object(s =>
-    s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))))
+    s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))->S.strict))
   ),
   logger,
   // The payload carries `transaction` by batch prep (HyperSync) or inline
@@ -63,8 +104,8 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     Logging.createChildFrom(
       ~logger,
       ~params={
-        "contract": eventItem.eventConfig.contractName,
-        "event": eventItem.eventConfig.name,
+        "contract": eventItem.onEventRegistration.eventConfig.contractName,
+        "event": eventItem.onEventRegistration.eventConfig.name,
         "chainId": eventItem.chain->ChainMap.Chain.toChainId,
         "block": eventItem.blockNumber,
         "logIndex": eventItem.logIndex,
@@ -74,7 +115,17 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   toRawEvent: eventItem => {
     let payload = eventItem.payload->toPayload
     let eventConfig =
-      eventItem.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
+      eventItem.onEventRegistration.eventConfig->(
+        Utils.magic: Internal.eventConfig => Internal.evmEventConfig
+      )
+    // Store-backed payloads get `block` written at batch prep and inline
+    // sources carry it from the start, with hash/timestamp always selected —
+    // so both are present by the time a raw event is built.
+    let header = switch payload.block {
+    | Some(block) => block->(Utils.magic: Internal.eventBlock => {"hash": string, "timestamp": int})
+    | None =>
+      JsError.throwWithMessage("Unexpected case: The event block is missing for a raw event")
+    }
     eventItem->RawEvent.make(
       ~block=payload.block,
       ~transaction=payload.transaction,
@@ -84,6 +135,8 @@ let make = (~logger: Pino.t): Ecosystem.t => {
         ? ()->(Utils.magic: unit => Internal.eventParams)
         : payload.params,
       ~srcAddress=payload.srcAddress,
+      ~blockHash=header["hash"],
+      ~blockTimestamp=header["timestamp"],
       ~cleanUpRawEventFieldsInPlace,
     )
   },

package/src/sources/Evm.res.mjs

@@ -3,11 +3,46 @@
 import * as Logging from "../Logging.res.mjs";
 import * as Internal from "../Internal.res.mjs";
 import * as RawEvent from "../RawEvent.res.mjs";
+import * as BlockStore from "./BlockStore.res.mjs";
+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";
 import * as TransactionStore from "./TransactionStore.res.mjs";
 
 let eventTransactionFieldMask = TransactionStore.makeMaskFn(Internal.allEvmTransactionFields);
 
+let blockFields = [
+  "number",
+  "timestamp",
+  "hash",
+  "parentHash",
+  "nonce",
+  "sha3Uncles",
+  "logsBloom",
+  "transactionsRoot",
+  "stateRoot",
+  "receiptsRoot",
+  "miner",
+  "difficulty",
+  "totalDifficulty",
+  "extraData",
+  "size",
+  "gasLimit",
+  "gasUsed",
+  "uncles",
+  "baseFeePerGas",
+  "blobGasUsed",
+  "excessBlobGas",
+  "parentBeaconBlockRoot",
+  "withdrawalsRoot",
+  "l1BlockNumber",
+  "sendCount",
+  "sendRoot",
+  "mixHash"
+];
+
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields);
+
 let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.hash
     delete fields.number
@@ -23,12 +58,12 @@ function make(logger) {
     cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
     onBlockMethodName: "onBlock",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
-    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
+    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown)))))),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {
-      contract: eventItem.eventConfig.contractName,
-      event: eventItem.eventConfig.name,
+      contract: eventItem.onEventRegistration.eventConfig.contractName,
+      event: eventItem.onEventRegistration.eventConfig.name,
       chainId: eventItem.chain,
       block: eventItem.blockNumber,
       logIndex: eventItem.logIndex,
@@ -36,8 +71,10 @@ function make(logger) {
     }),
     toRawEvent: eventItem => {
       let payload = eventItem.payload;
-      let eventConfig = eventItem.eventConfig;
-      return RawEvent.make(eventItem, payload.block, payload.transaction, eventConfig.paramsMetadata.length === 0 ? undefined : payload.params, payload.srcAddress, cleanUpRawEventFieldsInPlace);
+      let eventConfig = eventItem.onEventRegistration.eventConfig;
+      let block = payload.block;
+      let header = block !== undefined ? Primitive_option.valFromOption(block) : Stdlib_JsError.throwWithMessage("Unexpected case: The event block is missing for a raw event");
+      return RawEvent.make(eventItem, payload.block, payload.transaction, eventConfig.paramsMetadata.length === 0 ? undefined : payload.params, payload.srcAddress, header.hash, header.timestamp, cleanUpRawEventFieldsInPlace);
     }
   };
 }
@@ -47,6 +84,8 @@ let transactionFields = Internal.allEvmTransactionFields;
 export {
   transactionFields,
   eventTransactionFieldMask,
+  blockFields,
+  eventBlockFieldMask,
   cleanUpRawEventFieldsInPlace,
   make,
 }

package/src/sources/EvmChain.res

@@ -39,39 +39,35 @@ let getSyncConfig = (
   }
 }
 
-let collectEventParams = (contracts: array<Internal.evmContractConfig>): array<
+let collectEventParams = (onEventRegistrations: array<Internal.evmOnEventRegistration>): array<
   HyperSyncClient.Decoder.eventParamsInput,
 > => {
   let result = []
-  contracts->Array.forEach(contract => {
-    contract.events->Array.forEach(event => {
-      result
-      ->Array.push({
-        HyperSyncClient.Decoder.sighash: event.sighash,
-        topicCount: event.topicCount,
-        eventName: event.name,
-        contractName: contract.name,
-        params: event.paramsMetadata,
-      })
-      ->ignore
+  onEventRegistrations->Array.forEach(reg => {
+    let event = reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
+    result
+    ->Array.push({
+      HyperSyncClient.Decoder.sighash: event.sighash,
+      topicCount: event.topicCount,
+      eventName: event.name,
+      contractName: event.contractName,
+      params: event.paramsMetadata,
     })
+    ->ignore
   })
   result
 }
 
 let makeSources = (
   ~chain,
-  ~contracts: array<Internal.evmContractConfig>,
+  ~onEventRegistrations: array<Internal.evmOnEventRegistration>,
   ~hyperSync,
   ~rpcs: array<rpc>,
   ~lowercaseAddresses,
 ) => {
-  let eventRouter =
-    contracts
-    ->Array.flatMap(contract => contract.events)
-    ->EventRouter.fromEvmEventModsOrThrow(~chain)
+  let eventRouter = onEventRegistrations->EventRouter.fromEvmEventModsOrThrow(~chain)
 
-  let allEventParams = collectEventParams(contracts)
+  let allEventParams = collectEventParams(onEventRegistrations)
 
   let sources = switch hyperSync {
   | Some(endpointUrl) => [

package/src/sources/EvmChain.res.mjs

@@ -20,25 +20,24 @@ function getSyncConfig(param) {
   };
 }
 
-function collectEventParams(contracts) {
+function collectEventParams(onEventRegistrations) {
   let result = [];
-  contracts.forEach(contract => {
-    contract.events.forEach(event => {
-      result.push({
-        sighash: event.sighash,
-        topicCount: event.topicCount,
-        eventName: event.name,
-        contractName: contract.name,
-        params: event.paramsMetadata
-      });
+  onEventRegistrations.forEach(reg => {
+    let event = reg.eventConfig;
+    result.push({
+      sighash: event.sighash,
+      topicCount: event.topicCount,
+      eventName: event.name,
+      contractName: event.contractName,
+      params: event.paramsMetadata
     });
   });
   return result;
 }
 
-function makeSources(chain, contracts, hyperSync, rpcs, lowercaseAddresses) {
-  let eventRouter = EventRouter.fromEvmEventModsOrThrow(contracts.flatMap(contract => contract.events), chain);
-  let allEventParams = collectEventParams(contracts);
+function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses) {
+  let eventRouter = EventRouter.fromEvmEventModsOrThrow(onEventRegistrations, chain);
+  let allEventParams = collectEventParams(onEventRegistrations);
   let sources = hyperSync !== undefined ? [HyperSyncSource.make({
         chain: chain,
         endpointUrl: hyperSync,

package/src/sources/FieldMask.res

@@ -0,0 +1,39 @@
+// Selection-bitmask helpers shared by the per-chain field stores
+// (`TransactionStore`, `BlockStore`). A field's bit index is its position in the
+// ecosystem's ordered field-name array — the same code the Rust store uses.
+
+// Field-name → bit-index map from an ordered field-name array.
+let fieldCodes = (fields: array<string>): dict<int> => {
+  let codes = Dict.make()
+  fields->Array.forEachWithIndex((name, i) => codes->Dict.set(name, i))
+  codes
+}
+
+let pow2: int => float = %raw(`c => Math.pow(2, c)`)
+
+// One event's selected fields as a bitmask float (bit `code` set ⇔ selected).
+// Each field appears once, so summing `pow2(code)` sets distinct bits with no
+// overlap; the result stays exact in f64 (codes span 0..31, so a mask is at most
+// 2^32-1).
+let maskFromFields = (selectedFields: Utils.Set.t<string>, ~codes: dict<int>): float => {
+  let mask = ref(0.)
+  selectedFields->Utils.Set.forEach(name =>
+    switch codes->Utils.Dict.dangerouslyGetNonOption(name) {
+    | Some(code) => mask := mask.contents +. pow2(code)
+    | None => ()
+    }
+  )
+  mask.contents
+}
+
+// Build an ecosystem's per-event mask function from its ordered field-name
+// array. The field codes are derived once and closed over.
+let makeMaskFn = (fields: array<string>): (Utils.Set.t<string> => float) => {
+  let codes = fieldCodes(fields)
+  selectedFields => selectedFields->maskFromFields(~codes)
+}
+
+// Bitwise OR of two per-event masks. Masks fit in 32 bits (≤32 fields), so
+// `>>> 0` recovers the unsigned value that a plain `|` renders negative once bit
+// 31 is set.
+let orMask: (float, float) => float = %raw(`(a, b) => (a | b) >>> 0`)

package/src/sources/FieldMask.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function fieldCodes(fields) {
+  let codes = {};
+  fields.forEach((name, i) => {
+    codes[name] = i;
+  });
+  return codes;
+}
+
+let pow2 = (c => Math.pow(2, c));
+
+function maskFromFields(selectedFields, codes) {
+  let mask = {
+    contents: 0
+  };
+  selectedFields.forEach(name => {
+    let code = codes[name];
+    if (code !== undefined) {
+      mask.contents = mask.contents + pow2(code);
+      return;
+    }
+  });
+  return mask.contents;
+}
+
+function makeMaskFn(fields) {
+  let codes = fieldCodes(fields);
+  return selectedFields => maskFromFields(selectedFields, codes);
+}
+
+let orMask = ((a, b) => (a | b) >>> 0);
+
+export {
+  fieldCodes,
+  pow2,
+  maskFromFields,
+  makeMaskFn,
+  orMask,
+}
+/* No side effect */

package/src/sources/Fuel.res

@@ -35,8 +35,10 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // Analogous to EVM, but keyed by `block.height` instead of
   // `block.number`. See `Evm.res` for the rationale on the two-stage
   // parse and the `_lte`/`_every` rejection.
+  // `S.strict` on the inner object rejects unknown `block` fields — including
+  // `block.number`, which is EVM-only; Fuel filters by `block.height`.
   onEventBlockFilterSchema: S.object(s =>
-    s.field("block", S.option(S.object(s2 => s2.field("height", S.unknown))))
+    s.field("block", S.option(S.object(s2 => s2.field("height", S.unknown))->S.strict))
   ),
   logger,
   toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
@@ -44,8 +46,8 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     Logging.createChildFrom(
       ~logger,
       ~params={
-        "contract": eventItem.eventConfig.contractName,
-        "event": eventItem.eventConfig.name,
+        "contract": eventItem.onEventRegistration.eventConfig.contractName,
+        "event": eventItem.onEventRegistration.eventConfig.name,
         "chainId": eventItem.chain->ChainMap.Chain.toChainId,
         "block": eventItem.blockNumber,
         "logIndex": eventItem.logIndex,
@@ -54,11 +56,14 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     ),
   toRawEvent: eventItem => {
     let payload = eventItem.payload->toPayload
+    let header = payload.block->(Utils.magic: Internal.eventBlock => {"id": string, "time": int})
     eventItem->RawEvent.make(
       ~block=payload.block,
       ~transaction=payload.transaction,
       ~params=payload.params,
       ~srcAddress=payload.srcAddress,
+      ~blockHash=header["id"],
+      ~blockTimestamp=header["time"],
       ~cleanUpRawEventFieldsInPlace,
     )
   },

package/src/sources/Fuel.res.mjs

@@ -19,12 +19,12 @@ function make(logger) {
     cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
     onBlockMethodName: "onBlock",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown))))),
-    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown))))),
+    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown)))))),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {
-      contract: eventItem.eventConfig.contractName,
-      event: eventItem.eventConfig.name,
+      contract: eventItem.onEventRegistration.eventConfig.contractName,
+      event: eventItem.onEventRegistration.eventConfig.name,
       chainId: eventItem.chain,
       block: eventItem.blockNumber,
       logIndex: eventItem.logIndex,
@@ -32,7 +32,8 @@ function make(logger) {
     }),
     toRawEvent: eventItem => {
       let payload = eventItem.payload;
-      return RawEvent.make(eventItem, payload.block, payload.transaction, payload.params, payload.srcAddress, cleanUpRawEventFieldsInPlace);
+      let header = payload.block;
+      return RawEvent.make(eventItem, payload.block, payload.transaction, payload.params, payload.srcAddress, header.id, header.time, cleanUpRawEventFieldsInPlace);
     }
   };
 }