envio 2.20.1 → 2.21.1

package/src/Internal.gen.ts

@@ -3,6 +3,8 @@
 /* eslint-disable */
 /* tslint:disable */
 
+import type {GenericContractRegister as $$genericContractRegister} from './Types.ts';
+
 import type {Invalid as $$noEventFilters} from './Types.ts';
 
 import type {t as Address_t} from './Address.gen';
@@ -22,7 +24,7 @@ export type genericLoader<args,loaderReturn> = (_1:args) => Promise<loaderReturn
 
 export type genericContractRegisterArgs<event,context> = { readonly event: event; readonly context: context };
 
-export type genericContractRegister<args> = (_1:args) => void;
+export type genericContractRegister<args> = $$genericContractRegister<args>;
 
 export type genericHandlerArgs<event,context,loaderReturn> = {
   readonly event: event; 

package/src/Internal.res

@@ -35,8 +35,8 @@ type genericContractRegisterArgs<'event, 'context> = {
   event: 'event,
   context: 'context,
 }
-@genType
-type genericContractRegister<'args> = 'args => unit
+@genType.import(("./Types.ts", "GenericContractRegister"))
+type genericContractRegister<'args> = 'args => promise<unit>
 
 type contractRegisterContext
 type contractRegisterArgs = genericContractRegisterArgs<event, contractRegisterContext>

package/src/Logging.res

@@ -150,7 +150,8 @@ let getEventLogger = (eventItem: Internal.eventItem) => {
   | None => {
       let l = getLogger()->child(
         {
-          "context": `Event '${eventItem.eventConfig.name}' for contract '${eventItem.eventConfig.contractName}'`,
+          "contractName": eventItem.eventConfig.contractName,
+          "eventName": eventItem.eventConfig.name,
           "chainId": eventItem.chain->ChainMap.Chain.toChainId,
           "block": eventItem.blockNumber,
           "logIndex": eventItem.logIndex,
@@ -162,18 +163,16 @@ let getEventLogger = (eventItem: Internal.eventItem) => {
   }
 }
 
-let getUserLogger = {
-  @inline
-  let log = (eventItem, level: Pino.logLevelUser, message: string, ~params) => {
-    (eventItem->getEventLogger->Utils.magic->Js.Dict.unsafeGet((level :> string)))(params, message)
-  }
+@inline
+let logForItem = (eventItem, level: Pino.logLevel, message: string, ~params=?) => {
+  (eventItem->getEventLogger->Utils.magic->Js.Dict.unsafeGet((level :> string)))(params, message)
+}
 
-  (eventItem): Envio.logger => {
-    info: (message: string, ~params=?) => eventItem->log(#uinfo, message, ~params),
-    debug: (message: string, ~params=?) => eventItem->log(#udebug, message, ~params),
-    warn: (message: string, ~params=?) => eventItem->log(#uwarn, message, ~params),
-    error: (message: string, ~params=?) => eventItem->log(#uerror, message, ~params),
-    errorWithExn: (message: string, exn) =>
-      eventItem->log(#uerror, message, ~params={"err": exn->Internal.prettifyExn}),
-  }
+let getUserLogger = (eventItem): Envio.logger => {
+  info: (message: string, ~params=?) => eventItem->logForItem(#uinfo, message, ~params?),
+  debug: (message: string, ~params=?) => eventItem->logForItem(#udebug, message, ~params?),
+  warn: (message: string, ~params=?) => eventItem->logForItem(#uwarn, message, ~params?),
+  error: (message: string, ~params=?) => eventItem->logForItem(#uerror, message, ~params?),
+  errorWithExn: (message: string, exn) =>
+    eventItem->logForItem(#uerror, message, ~params={"err": exn->Internal.prettifyExn}),
 }

package/src/Prometheus.res

@@ -335,7 +335,7 @@ module IndexingMaxConcurrency = {
 module IndexingConcurrency = {
   let gauge = SafeGauge.makeOrThrow(
     ~name="envio_indexing_concurrency",
-    ~help="The current number of concurrent queries to the chain data-source.",
+    ~help="The number of executing concurrent queries to the chain data-source.",
     ~labelSchema=chainIdLabelsSchema,
   )
 
@@ -344,6 +344,18 @@ module IndexingConcurrency = {
   }
 }
 
+module IndexingPartitions = {
+  let gauge = SafeGauge.makeOrThrow(
+    ~name="envio_indexing_partitions",
+    ~help="The number of partitions used to split fetching logic by addresses and block ranges.",
+    ~labelSchema=chainIdLabelsSchema,
+  )
+
+  let set = (~partitionsCount, ~chainId) => {
+    gauge->SafeGauge.handleInt(~labels=chainId, ~value=partitionsCount)
+  }
+}
+
 module IndexingBufferSize = {
   let gauge = SafeGauge.makeOrThrow(
     ~name="envio_indexing_buffer_size",

package/src/Types.ts

@@ -45,3 +45,7 @@ export type EffectContext = {
    */
   readonly effect: EffectCaller;
 };
+
+export type GenericContractRegister<Args> = (
+  args: Args
+) => void | Promise<void>;

package/src/Utils.res

@@ -328,6 +328,8 @@ let unwrapResultExn = res =>
 external queueMicrotask: (unit => unit) => unit = "queueMicrotask"
 
 module Schema = {
+  let variantTag = S.union([S.string, S.object(s => s.field("TAG", S.string))])
+
   let getNonOptionalFieldNames = schema => {
     let acc = []
     switch schema->S.classify {
@@ -385,6 +387,10 @@ module Schema = {
   }
 }
 
+let getVariantsTags = variants => {
+  variants->Js.Array2.map(variant => variant->S.parseOrThrow(Schema.variantTag))
+}
+
 module Set = {
   type t<'value>
 

package/src/bindings/Promise.res

@@ -50,3 +50,5 @@ external done: promise<'a> => unit = "%ignore"
 
 external unsafe_async: 'a => promise<'a> = "%identity"
 external unsafe_await: promise<'a> => 'a = "?await"
+
+let isCatchable: 'any => bool = %raw(`value => value && typeof value.catch === 'function'`)

package/src/sources/HyperSyncClient.gen.ts

@@ -0,0 +1,19 @@
+/* TypeScript file generated from HyperSyncClient.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+import type {t as Address_t} from '../../src/Address.gen';
+
+export type ResponseTypes_accessList = { readonly address?: Address_t; readonly storageKeys?: string[] };
+
+export type ResponseTypes_authorizationList = {
+  readonly chainId: bigint; 
+  readonly address: Address_t; 
+  readonly nonce: number; 
+  readonly yParity: 
+    1
+  | 0; 
+  readonly r: string; 
+  readonly s: string
+};

package/src/sources/HyperSyncClient.res

@@ -75,6 +75,7 @@ module QueryTypes = {
     | L1GasUsed
     | L1FeeScalar
     | GasUsedForL1
+    | AuthorizationList
 
   type logField =
     | Removed
@@ -302,11 +303,36 @@ module ResponseTypes = {
     mixHash?: string,
   }
 
+  @genType
   type accessList = {
     address?: Address.t,
     storageKeys?: array<string>,
   }
 
+  let accessListSchema = S.object(s => {
+    address: ?s.field("address", S.option(Address.schema)),
+    storageKeys: ?s.field("storageKeys", S.option(S.array(S.string))),
+  })
+
+  @genType
+  type authorizationList = {
+    chainId: bigint,
+    address: Address.t,
+    nonce: int,
+    yParity: [#0 | #1],
+    r: string,
+    s: string,
+  }
+
+  let authorizationListSchema = S.object(s => {
+    chainId: s.field("chainId", S.bigint),
+    address: s.field("address", Address.schema),
+    nonce: s.field("nonce", S.int),
+    yParity: s.field("yParity", S.enum([#0, #1])),
+    r: s.field("r", S.string),
+    s: s.field("s", S.string),
+  })
+
   type transaction = {
     blockHash?: string,
     blockNumber?: int,
@@ -342,6 +368,7 @@ module ResponseTypes = {
     l1GasUsed?: bigint,
     l1FeeScalar?: int,
     gasUsedForL1?: bigint,
+    authorizationList?: array<authorizationList>,
   }
 
   type log = {

package/src/sources/Source.res

@@ -0,0 +1,59 @@
+/**
+A set of stats for logging about the block range fetch
+*/
+type blockRangeFetchStats = {
+  @as("total time elapsed (ms)") totalTimeElapsed: int,
+  @as("parsing time (ms)") parsingTimeElapsed?: int,
+  @as("page fetch time (ms)") pageFetchTime?: int,
+}
+
+/**
+Thes response returned from a block range fetch
+*/
+type blockRangeFetchResponse = {
+  currentBlockHeight: int,
+  reorgGuard: ReorgDetection.reorgGuard,
+  parsedQueueItems: array<Internal.eventItem>,
+  fromBlockQueried: int,
+  latestFetchedBlockNumber: int,
+  latestFetchedBlockTimestamp: int,
+  stats: blockRangeFetchStats,
+}
+
+type getItemsRetry =
+  | WithSuggestedToBlock({toBlock: int})
+  | WithBackoff({message: string, backoffMillis: int})
+
+type getItemsError =
+  | UnsupportedSelection({message: string})
+  | FailedGettingFieldSelection({exn: exn, blockNumber: int, logIndex: int, message: string})
+  | FailedParsingItems({exn: exn, blockNumber: int, logIndex: int, message: string})
+  | FailedGettingItems({exn: exn, attemptedToBlock: int, retry: getItemsRetry})
+
+exception GetItemsError(getItemsError)
+
+type sourceFor = Sync | Fallback
+type t = {
+  name: string,
+  sourceFor: sourceFor,
+  chain: ChainMap.Chain.t,
+  poweredByHyperSync: bool,
+  /* Frequency (in ms) used when polling for new events on this network. */
+  pollingInterval: int,
+  getBlockHashes: (
+    ~blockNumbers: array<int>,
+    ~logger: Pino.t,
+  ) => promise<result<array<ReorgDetection.blockDataWithTimestamp>, exn>>,
+  getHeightOrThrow: unit => promise<int>,
+  getItemsOrThrow: (
+    ~fromBlock: int,
+    ~toBlock: option<int>,
+    ~addressesByContractName: dict<array<Address.t>>,
+    ~indexingContracts: dict<FetchState.indexingContract>,
+    ~currentBlockHeight: int,
+    ~partitionId: string,
+    ~selection: FetchState.selection,
+    ~retry: int,
+    ~logger: Pino.t,
+  ) => promise<blockRangeFetchResponse>,
+}