envio 3.0.2 → 3.1.0-rc.1

package/src/sources/HyperSyncClient.res

@@ -28,6 +28,7 @@ type cfg = {
   serializationFormat?: serializationFormat,
   /** Whether to use query caching when using CapnProto serialization format. */
   enableQueryCaching?: bool,
+  logLevel?: string,
 }
 
 module QueryTypes = {
@@ -112,34 +113,10 @@ module QueryTypes = {
     | Topic2
     | Topic3
 
-  type traceField =
-    | From
-    | To
-    | CallType
-    | Gas
-    | Input
-    | Init
-    | Value
-    | Author
-    | RewardType
-    | BlockHash
-    | BlockNumber
-    | Address
-    | Code
-    | GasUsed
-    | Output
-    | Subtraces
-    | TraceAddress
-    | TransactionHash
-    | TransactionPosition
-    | Type
-    | Error
-
   type fieldSelection = {
     block?: array<blockField>,
     transaction?: array<transactionField>,
     log?: array<logField>,
-    trace?: array<traceField>,
   }
   type topicFilter = array<EvmTypes.Hex.t>
   type topic0 = topicFilter
@@ -155,138 +132,39 @@ module QueryTypes = {
   )
 
   type logFilter = {
-    /**
-     * Address of the contract, any logs that has any of these addresses will be returned.
-     * Empty means match all.
-     */
     address?: array<Address.t>,
-    /**
-     * Topics to match, each member of the top level array is another array, if the nth topic matches any
-     *  topic specified in topics[n] the log will be returned. Empty means match all.
-     */
     topics: topicSelection,
   }
 
   let makeLogSelection = (~address, ~topics) => {address, topics}
 
   type transactionFilter = {
-    /**
-     * Address the transaction should originate from. If transaction.from matches any of these, the transaction
-     *  will be returned. Keep in mind that this has an and relationship with to filter, so each transaction should
-     *  match both of them. Empty means match all.
-     */
     from?: array<Address.t>,
-    /**
-     * Address the transaction should go to. If transaction.to matches any of these, the transaction will
-     *  be returned. Keep in mind that this has an and relationship with from filter, so each transaction should
-     *  match both of them. Empty means match all.
-     */
-    @as("to")
-    to_?: array<Address.t>,
-    /** If first 4 bytes of transaction input matches any of these, transaction will be returned. Empty means match all. */
+    @as("to") to_?: array<Address.t>,
     sighash?: array<string>,
-    /** If tx.status matches this it will be returned. */
     status?: int,
-    /** If transaction.type matches any of these values, the transaction will be returned */
-    @as("type")
-    type_?: array<int>,
+    @as("type") type_?: array<int>,
     contractAddress?: array<Address.t>,
   }
 
-  type traceSelection = {
-    from?: array<Address.t>,
-    @as("to") to_?: array<Address.t>,
-    address?: array<Address.t>,
-    callType?: array<string>,
-    rewardType?: array<string>,
-    @as("type")
-    type_?: array<string>,
-    sighash?: array<string>,
-  }
-
   type blockSelection = {
-    /**
-     * Hash of a block, any blocks that have one of these hashes will be returned.
-     * Empty means match all.
-     */
     hash?: array<string>,
-    /**
-     * Miner address of a block, any blocks that have one of these miners will be returned.
-     * Empty means match all.
-     */
     miner?: array<Address.t>,
   }
 
   type joinMode = | @as(0) Default | @as(1) JoinAll | @as(2) JoinNothing
 
   type query = {
-    /** The block to start the query from */
     fromBlock: int,
-    /**
-     * The block to end the query at. If not specified, the query will go until the
-     *  end of data. Exclusive, the returned range will be [from_block..to_block).
-     *
-     * The query will return before it reaches this target block if it hits the time limit
-     *  configured on the server. The user should continue their query by putting the
-     *  next_block field in the response into from_block field of their next query. This implements
-     *  pagination.
-     */
-    @as("toBlock")
-    toBlockExclusive?: int,
-    /**
-     * List of log selections, these have an or relationship between them, so the query will return logs
-     * that match any of these selections.
-     */
+    @as("toBlock") toBlockExclusive?: int,
     logs?: array<logFilter>,
-    /**
-     * List of transaction selections, the query will return transactions that match any of these selections and
-     *  it will return transactions that are related to the returned logs.
-     */
     transactions?: array<transactionFilter>,
-    /**
-     * List of trace selections, the query will return traces that match any of these selections and
-     *  it will re turn traces that are related to the returned logs.
-     */
-    traces?: array<traceSelection>,
-    /** List of block selections, the query will return blocks that match any of these selections */
     blocks?: array<blockSelection>,
-    /**
-     * Field selection. The user can select which fields they are interested in, requesting less fields will improve
-     *  query execution time and reduce the payload size so the user should always use a minimal number of fields.
-     */
     fieldSelection: fieldSelection,
-    /**
-     * Maximum number of blocks that should be returned, the server might return more blocks than this number but
-     *  it won't overshoot by too much.
-     */
     maxNumBlocks?: int,
-    /**
-     * Maximum number of transactions that should be returned, the server might return more transactions than this number but
-     *  it won't overshoot by too much.
-     */
     maxNumTransactions?: int,
-    /**
-     * Maximum number of logs that should be returned, the server might return more logs than this number but
-     *  it won't overshoot by too much.
-     */
     maxNumLogs?: int,
-    /**
-     * Maximum number of traces that should be returned, the server might return more traces than this number but
-     *  it won't overshoot by too much.
-     */
-    maxNumTraces?: int,
-    /**
-     * Selects join mode for the query,
-     * Default: join in this order logs -> transactions -> traces -> blocks
-     * JoinAll: join everything to everything. For example if logSelection matches log0, we get the
-     * associated transaction of log0 and then we get associated logs of that transaction as well. Applites similarly
-     * to blocks, traces.
-     * JoinNothing: join nothing.
-     */
     joinMode?: joinMode,
-    /**
-     * If set to true, the server will return data for all blocks in the requested range [from_block, to_block).
-     */
     includeAllBlocks?: bool,
   }
 }
@@ -385,8 +263,7 @@ module ResponseTypes = {
     gasUsed?: bigint,
     contractAddress?: string,
     logsBloom?: string,
-    @as("type")
-    type_?: int,
+    @as("type") type_?: int,
     root?: string,
     status?: int,
     l1Fee?: bigint,
@@ -416,46 +293,15 @@ module ResponseTypes = {
   }
 
   type rollbackGuard = {
-    /** Block number of the last scanned block */
     blockNumber: int,
-    /** Block timestamp of the last scanned block */
     timestamp: int,
-    /** Block hash of the last scanned block */
     hash: string,
-    /**
-   * Block number of the first scanned block in memory.
-   *
-   * This might not be the first scanned block. It only includes blocks that are in memory (possible to be rolled back).
-   */
     firstBlockNumber: int,
-    /**
-   * Parent hash of the first scanned block in memory.
-   *
-   * This might not be the first scanned block. It only includes blocks that are in memory (possible to be rolled back).
-   */
     firstParentHash: string,
   }
-
-  type eventResponse = {
-    /** Current height of the source hypersync instance */
-    archiveHeight: option<int>,
-    /**
-     * Next block to query for, the responses are paginated so,
-     *  the caller should continue the query from this block if they
-     *  didn't get responses up to the to_block they specified in the Query.
-     */
-    nextBlock: int,
-    /** Total time it took the hypersync instance to execute the query. */
-    totalExecutionTime: int,
-    /** Response data */
-    data: array<event>,
-    /** Rollback guard, supposed to be used to detect rollbacks */
-    rollbackGuard: option<rollbackGuard>,
-  }
 }
 
 type query = QueryTypes.query
-type eventResponse = ResponseTypes.eventResponse
 
 type queryResponseData = {
   blocks: array<ResponseTypes.block>,
@@ -471,52 +317,85 @@ type queryResponse = {
   rollbackGuard: option<ResponseTypes.rollbackGuard>,
 }
 
-//Todo, add bindings for these types
-type streamConfig
-type queryResponseStream
-type eventStream
-
-@tag("type")
-type heightStreamEvent =
-  | Height({height: int})
-  | Connected
-  | Reconnecting({delayMillis: int, errorMsg: string})
-
-module HeightStream = {
-  type t = {
-    /** Close the height stream */
-    close: unit => promise<unit>,
-    /** Receive the next height stream event from the stream */
-    recv: unit => promise<heightStreamEvent>,
+module Decoder = {
+  type eventParamsInput = {
+    sighash: string,
+    topicCount: int,
+    eventName: string,
+    params: array<Internal.paramMeta>,
+  }
+
+  type tWithParams = {
+    decodeLogs: array<ResponseTypes.event> => promise<array<Nullable.t<Internal.eventParams>>>,
+  }
+
+  @send
+  external classFromParams: (
+    Core.decoderCtor,
+    array<eventParamsInput>,
+    ~checksumAddresses: bool=?,
+  ) => tWithParams = "fromParams"
+
+  let fromParams = (eventParams, ~checksumAddresses=?) =>
+    Core.getAddon().decoder->classFromParams(eventParams, ~checksumAddresses?)
+}
+
+module EventItems = {
+  type item = {
+    logIndex: int,
+    srcAddress: Address.t,
+    topic0: EvmTypes.Hex.t,
+    topicCount: int,
+    block: ResponseTypes.block,
+    transaction: ResponseTypes.transaction,
+    params: Nullable.t<Internal.eventParams>,
+  }
+
+  type response = {
+    archiveHeight: option<int>,
+    nextBlock: int,
+    items: array<item>,
+    rollbackGuard: option<ResponseTypes.rollbackGuard>,
   }
 }
 
 type t = {
-  getHeight: unit => promise<int>,
-  collect: (~query: query, ~config: streamConfig) => promise<queryResponse>,
-  collectEvents: (~query: query, ~config: streamConfig) => promise<eventResponse>,
-  collectParquet: (~path: string, ~query: query, ~config: streamConfig) => promise<unit>,
   get: (~query: query) => promise<queryResponse>,
-  getEvents: (~query: query) => promise<eventResponse>,
-  stream: (~query: query, ~config: streamConfig) => promise<queryResponseStream>,
-  streamEvents: (~query: query, ~config: streamConfig) => promise<eventStream>,
-  streamHeight: unit => promise<HeightStream.t>,
+  getEventItems: (~query: query) => promise<EventItems.response>,
+  getHeight: unit => promise<int>,
 }
 
-@module("@envio-dev/hypersync-client") @scope("HypersyncClient")
-external makeWithAgent: (cfg, ~userAgent: string) => t = "newWithAgent"
+@send
+external classNew: (Core.hypersyncClientCtor, cfg, string, array<Decoder.eventParamsInput>) => t =
+  "new"
+
+let makeWithAgent = (cfg, ~userAgent, ~eventParams) =>
+  Core.getAddon().hypersyncClient->classNew(cfg, userAgent, eventParams)
+
+type logLevel = [#trace | #debug | #info | #warn | #error]
+let logLevelSchema: S.t<logLevel> = S.enum([#trace, #debug, #info, #warn, #error])
+
+let logLevelToString = (level: logLevel) =>
+  switch level {
+  | #trace => "trace"
+  | #debug => "debug"
+  | #info => "info"
+  | #warn => "warn"
+  | #error => "error"
+  }
 
 let make = (
   ~url,
   ~apiToken,
   ~httpReqTimeoutMillis,
-  ~maxNumRetries,
+  ~eventParams,
   ~enableChecksumAddresses=true,
   ~serializationFormat=?,
   ~enableQueryCaching=?,
   ~retryBaseMs=?,
   ~retryBackoffMs=?,
   ~retryCeilingMs=?,
+  ~logLevel=#info,
 ) => {
   let envioVersion = Utils.EnvioPackage.value.version
   makeWithAgent(
@@ -525,72 +404,16 @@ let make = (
       enableChecksumAddresses,
       apiToken,
       httpReqTimeoutMillis,
-      maxNumRetries,
+      // Retries are handled internally by the indexer, not the binary client
+      maxNumRetries: 0,
       ?serializationFormat,
       ?enableQueryCaching,
       ?retryBaseMs,
       ?retryBackoffMs,
       ?retryCeilingMs,
+      logLevel: logLevelToString(logLevel),
     },
     ~userAgent=`hyperindex/${envioVersion}`,
+    ~eventParams,
   )
 }
-
-type logLevel = [#trace | #debug | #info | #warn | #error]
-let logLevelSchema: S.t<logLevel> = S.enum([#trace, #debug, #info, #warn, #error])
-
-/**
- * Set the log level for the underlying Rust logger in hypersync-client.
- * Must be called before creating any HypersyncClient.
- */
-@module("@envio-dev/hypersync-client")
-external setLogLevel: logLevel => unit = "setLogLevel"
-
-module Decoder = {
-  type rec decodedSolType<'a> = {val: 'a}
-
-  @unboxed
-  type rec decodedRaw =
-    | DecodedBool(bool)
-    | DecodedStr(string)
-    | DecodedNum(bigint)
-    | DecodedVal(decodedSolType<decodedRaw>)
-    | DecodedArr(array<decodedRaw>)
-
-  @unboxed
-  type rec decodedUnderlying =
-    | Bool(bool)
-    | Str(string)
-    | Num(bigint)
-    | Arr(array<decodedUnderlying>)
-
-  let rec toUnderlying = (d: decodedRaw): decodedUnderlying => {
-    switch d {
-    | DecodedVal(v) => v.val->toUnderlying
-    | DecodedBool(v) => Bool(v)
-    | DecodedStr(v) => Str(v)
-    | DecodedNum(v) => Num(v)
-    | DecodedArr(v) => v->Belt.Array.map(toUnderlying)->Arr
-    }
-  }
-
-  type decodedEvent = {
-    indexed: array<decodedRaw>,
-    body: array<decodedRaw>,
-  }
-
-  type log
-  type t = {
-    enableChecksummedAddresses: unit => unit,
-    disableChecksummedAddresses: unit => unit,
-    decodeLogs: array<log> => promise<array<Nullable.t<decodedEvent>>>,
-    decodeLogsSync: array<log> => array<Nullable.t<decodedEvent>>,
-    decodeEvents: array<ResponseTypes.event> => promise<array<Nullable.t<decodedEvent>>>,
-    decodeEventsSync: array<ResponseTypes.event> => array<Nullable.t<decodedEvent>>,
-  }
-
-  @module("@envio-dev/hypersync-client") @scope("Decoder")
-  external fromSignatures: array<string> => t = "fromSignatures"
-  // Keep the @envio-dev/hypersync-client import inside of the package
-  let fromSignatures = fromSignatures
-}

package/src/sources/HyperSyncClient.res.mjs

@@ -1,10 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Core from "../Core.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Address from "../Address.res.mjs";
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.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 HypersyncClient from "@envio-dev/hypersync-client";
 
 let serializationFormatSchema = S$RescriptSchema.$$enum([
   "Json",
@@ -58,23 +58,18 @@ let ResponseTypes = {
   authorizationListSchema: authorizationListSchema
 };
 
-let HeightStream = {};
+function fromParams(eventParams, checksumAddresses) {
+  return Core.getAddon().Decoder.fromParams(eventParams, checksumAddresses !== undefined ? Primitive_option.valFromOption(checksumAddresses) : undefined);
+}
 
-function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, enableChecksumAddressesOpt, serializationFormat, enableQueryCaching, retryBaseMs, retryBackoffMs, retryCeilingMs) {
-  let enableChecksumAddresses = enableChecksumAddressesOpt !== undefined ? enableChecksumAddressesOpt : true;
-  let envioVersion = Utils.EnvioPackage.value.version;
-  return HypersyncClient.HypersyncClient.newWithAgent({
-    url: url,
-    apiToken: apiToken,
-    httpReqTimeoutMillis: httpReqTimeoutMillis,
-    maxNumRetries: maxNumRetries,
-    retryBackoffMs: retryBackoffMs,
-    retryBaseMs: retryBaseMs,
-    retryCeilingMs: retryCeilingMs,
-    enableChecksumAddresses: enableChecksumAddresses,
-    serializationFormat: serializationFormat,
-    enableQueryCaching: enableQueryCaching
-  }, `hyperindex/` + envioVersion);
+let Decoder = {
+  fromParams: fromParams
+};
+
+let EventItems = {};
+
+function makeWithAgent(cfg, userAgent, eventParams) {
+  return Core.getAddon().HypersyncClient.new(cfg, userAgent, eventParams);
 }
 
 let logLevelSchema = S$RescriptSchema.$$enum([
@@ -85,42 +80,48 @@ let logLevelSchema = S$RescriptSchema.$$enum([
   "error"
 ]);
 
-function toUnderlying(_d) {
-  while (true) {
-    let d = _d;
-    if (Array.isArray(d)) {
-      return Belt_Array.map(d, toUnderlying);
-    }
-    switch (typeof d) {
-      case "boolean" :
-        return d;
-      case "string" :
-        return d;
-      case "bigint" :
-        return d;
-      case "object" :
-        _d = d.val;
-        continue;
-    }
-  };
+function logLevelToString(level) {
+  if (level === "warn") {
+    return "warn";
+  } else if (level === "debug") {
+    return "debug";
+  } else if (level === "error") {
+    return "error";
+  } else if (level === "trace") {
+    return "trace";
+  } else {
+    return "info";
+  }
 }
 
-function fromSignatures(prim) {
-  return HypersyncClient.Decoder.fromSignatures(prim);
+function make(url, apiToken, httpReqTimeoutMillis, eventParams, enableChecksumAddressesOpt, serializationFormat, enableQueryCaching, retryBaseMs, retryBackoffMs, retryCeilingMs, logLevelOpt) {
+  let enableChecksumAddresses = enableChecksumAddressesOpt !== undefined ? enableChecksumAddressesOpt : true;
+  let logLevel = logLevelOpt !== undefined ? logLevelOpt : "info";
+  let envioVersion = Utils.EnvioPackage.value.version;
+  return makeWithAgent({
+    url: url,
+    apiToken: apiToken,
+    httpReqTimeoutMillis: httpReqTimeoutMillis,
+    maxNumRetries: 0,
+    retryBackoffMs: retryBackoffMs,
+    retryBaseMs: retryBaseMs,
+    retryCeilingMs: retryCeilingMs,
+    enableChecksumAddresses: enableChecksumAddresses,
+    serializationFormat: serializationFormat,
+    enableQueryCaching: enableQueryCaching,
+    logLevel: logLevelToString(logLevel)
+  }, `hyperindex/` + envioVersion, eventParams);
 }
 
-let Decoder = {
-  toUnderlying: toUnderlying,
-  fromSignatures: fromSignatures
-};
-
 export {
   serializationFormatSchema,
   QueryTypes,
   ResponseTypes,
-  HeightStream,
-  make,
-  logLevelSchema,
   Decoder,
+  EventItems,
+  makeWithAgent,
+  logLevelSchema,
+  logLevelToString,
+  make,
 }
 /* serializationFormatSchema Not a pure module */