envio 3.15.0 → 3.16.0

package/src/Clock.res.mjs

@@ -0,0 +1,72 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Performance from "./bindings/Performance.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";
+
+let refuseReal = {
+  contents: false
+};
+
+function refused(what) {
+  return Stdlib_JsError.throwWithMessage(`Clock.real ` + what + ` on virtual time. Use the clock the code was given, so advanceTime can see and move it.`);
+}
+
+function real_now() {
+  if (refuseReal.contents) {
+    return refused("read the time");
+  } else {
+    return Performance.now();
+  }
+}
+
+function real_setTimeout(label, callback, millis) {
+  if (refuseReal.contents && millis > 0) {
+    return refused(`armed "` + label + `"`);
+  } else {
+    return setTimeout(callback, millis);
+  }
+}
+
+function real_clearTimeout(timer) {
+  clearTimeout(timer);
+}
+
+function real_random(prim) {
+  return Math.random();
+}
+
+let real = {
+  now: real_now,
+  setTimeout: real_setTimeout,
+  clearTimeout: real_clearTimeout,
+  random: real_random
+};
+
+function delay(clock, label, millis) {
+  return new Promise((resolve, _reject) => {
+    clock.setTimeout(label, () => resolve(), millis);
+  });
+}
+
+function jitter(clock, delay) {
+  return (delay / 2 | 0) + (clock.random() * (delay / 2 | 0) | 0) | 0;
+}
+
+function clearRef(clock, timer) {
+  let timer$1 = timer.contents;
+  if (timer$1 !== undefined) {
+    clock.clearTimeout(Primitive_option.valFromOption(timer$1));
+  }
+  timer.contents = undefined;
+}
+
+export {
+  refuseReal,
+  refused,
+  real,
+  delay,
+  jitter,
+  clearRef,
+}
+/* No side effect */

package/src/Config.res

@@ -65,6 +65,7 @@ type chain = {
   endBlock?: int,
   maxReorgDepth: int,
   blockLag: int,
+  blockThrottle: int,
   contracts: array<contract>,
   sourceConfig: sourceConfig,
 }
@@ -217,6 +218,7 @@ let publicConfigChainSchema = S.schema(s =>
     "endBlock": s.matches(S.option(S.int)),
     "maxReorgDepth": s.matches(S.option(S.int)),
     "blockLag": s.matches(S.option(S.int)),
+    "blockThrottle": s.matches(S.option(S.int)),
     // EVM/Fuel source config (hypersync for EVM, hyperfuel for Fuel)
     "hypersync": s.matches(S.option(S.string)),
     "rpcs": s.matches(S.option(S.array(rpcConfigSchema))),
@@ -1069,18 +1071,23 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         startBlock: publicChainConfig["startBlock"],
         endBlock: ?publicChainConfig["endBlock"],
         maxReorgDepth: switch ecosystemName {
-        | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getOr(200)
+        // One less than the 200 blocks behind the head a source checks for a
+        // lagging node, so the backfill, which stops one block below the window,
+        // ends exactly where those checks begin.
+        | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getOr(199)
         // Tower BFT roots a block once 32 votes lock it in (MAX_LOCKOUT_HISTORY
         // is 31, plus the slot itself), which is what `finalized` waits for — so
         // 32 is the protocol's own bound on how far a fork can be replaced. That
         // bound counts *blocks* while the threshold here is measured in slot
         // numbers, and skipped slots make the slot distance the larger of the
         // two, so the default keeps a wide margin over it. Slots are ~0.4s, so
-        // even this spans well under two minutes of chain.
-        | Ecosystem.Svm => publicChainConfig["maxReorgDepth"]->Option.getOr(200)
+        // even this spans well under two minutes of chain. One less than 200
+        // for the same reason as EVM: the backfill stops one slot below it.
+        | Ecosystem.Svm => publicChainConfig["maxReorgDepth"]->Option.getOr(199)
         | Ecosystem.Fuel => 0
         },
         blockLag: publicChainConfig["blockLag"]->Option.getOr(0),
+        blockThrottle: publicChainConfig["blockThrottle"]->Option.getOr(0),
         contracts,
         sourceConfig,
       }

package/src/Config.res.mjs

@@ -88,6 +88,7 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
   endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   maxReorgDepth: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   blockLag: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
+  blockThrottle: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   hypersync: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   rpcs: s.m(S$RescriptSchema.option(S$RescriptSchema.array(rpcConfigSchema))),
   contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(chainContractSchema)))
@@ -762,7 +763,7 @@ function fromPublic(publicConfigJson) {
         break;
       case "evm" :
       case "svm" :
-        tmp = Stdlib_Option.getOr(publicChainConfig.maxReorgDepth, 200);
+        tmp = Stdlib_Option.getOr(publicChainConfig.maxReorgDepth, 199);
         break;
     }
     return {
@@ -773,6 +774,7 @@ function fromPublic(publicConfigJson) {
       endBlock: publicChainConfig.endBlock,
       maxReorgDepth: tmp,
       blockLag: Stdlib_Option.getOr(publicChainConfig.blockLag, 0),
+      blockThrottle: Stdlib_Option.getOr(publicChainConfig.blockThrottle, 0),
       contracts: contracts,
       sourceConfig: sourceConfig
     };
@@ -972,7 +974,7 @@ function diffPaths(stored, current) {
         }
         return;
       }
-    } else {
+    } else if (s !== null) {
       switch (typeof s) {
         case "object" :
           if (typeof c === "object" && c !== null && !Array.isArray(c)) {

package/src/Core.res

@@ -18,6 +18,8 @@ type loggerCtor
 type mockHyperSyncServerCtor
 // Test-only: the ledger behind envio-tests' MockSource.
 type mockSourceCtor
+// Test-only: the virtual clock a scenario's source layer runs on.
+type virtualClockCtor
 type fromUserApiOptions = {
   schema?: string,
   env?: dict<string>,
@@ -31,46 +33,6 @@ type fromUserApiResult = {
   indexerCode: Null.t<string>,
 }
 
-// One column of a Postgres table, flattened for the boundary: napi carries no
-// tagged union, so the field type arrives as its name plus whichever of the
-// modifiers it takes.
-type pgColumnInput = {
-  // The database column name, renames already resolved.
-  name: string,
-  fieldType: string,
-  isArray: bool,
-  isNullable: bool,
-  isPrimaryKey: bool,
-  defaultValue?: string,
-  precision?: int,
-  scale?: int,
-  enumName?: string,
-}
-
-type pgTableInput = {
-  // In the order the table declares them.
-  columns: array<pgColumnInput>,
-  // The columns a batch's rows carry, in the order they are laid out.
-  writeColumns: array<string>,
-  partitionByColumn?: string,
-  appendOnly: bool,
-  // An entity's history table, and the column its chain is in when it is
-  // per-chain.
-  historyTable?: string,
-  chainIdColumn?: string,
-}
-
-type pgIndexColumnInput = {
-  name: string,
-  direction: string,
-}
-
-type pgIndexInput = {
-  tableName: string,
-  columns: array<pgIndexColumnInput>,
-  method: string,
-}
-
 type addon = {
   getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
   encodeIndexedTopic: (~abiType: string, ~value: unknown) => EvmTypes.Hex.t,
@@ -107,6 +69,8 @@ type addon = {
   mockHyperSyncServer: mockHyperSyncServerCtor,
   @as("MockSource")
   mockSource: mockSourceCtor,
+  @as("VirtualClock")
+  virtualClock: virtualClockCtor,
   encodeAddresses: (~ecosystem: string, ~addresses: array<Address.t>) => array<NodeJs.Buffer.t>,
   normalizeEvmAddress: (~address: string, ~shouldChecksum: bool) => Null.t<Address.t>,
   renderAddresses: (

package/src/EffectState.res

@@ -11,6 +11,8 @@ type effectRateLimitState = {
   mutable availableCalls: int,
   mutable windowStartTime: float,
   mutable nextWindowPromise: option<promise<unit>>,
+  // The run's clock: a test on virtual time opens the next window by advancing.
+  clock: Clock.t,
 }
 
 // Per-(effect, scope) counters rendered into the envio_effect_* metrics. Live
@@ -80,9 +82,14 @@ type t = {
   // rollback; stats and the rate-limit window survive because the table does.
   tables: dict<effectCacheInMemTable>,
   unregisteredCacheCounts: dict<unregisteredCacheCount>,
+  clock: Clock.t,
 }
 
-let make = (): t => {tables: Dict.make(), unregisteredCacheCounts: Dict.make()}
+let make = (~clock=Clock.real, ()): t => {
+  tables: Dict.make(),
+  unregisteredCacheCounts: Dict.make(),
+  clock,
+}
 
 let setUnregisteredCacheCount = (self: t, ~effectName, ~scope, ~count) => {
   let tableName = Internal.EffectCache.toTableName(~effectName, ~scope)
@@ -214,8 +221,9 @@ let getTable = (self: t, ~effect: Internal.effect, ~scope: Internal.chainScope)
         callsPerDuration,
         durationMs,
         availableCalls: callsPerDuration,
-        windowStartTime: Date.now(),
+        windowStartTime: self.clock.now(),
         nextWindowPromise: None,
+        clock: self.clock,
       })
     }
     let inMemTable: effectCacheInMemTable = {

package/src/EffectState.res.mjs

@@ -1,13 +1,16 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Clock from "./Clock.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 
-function make() {
+function make(clockOpt, param) {
+  let clock = clockOpt !== undefined ? clockOpt : Clock.real;
   return {
     tables: {},
-    unregisteredCacheCounts: {}
+    unregisteredCacheCounts: {},
+    clock: clock
   };
 }
 
@@ -130,8 +133,9 @@ function getTable(self, effect, scope) {
       callsPerDuration: callsPerDuration,
       durationMs: match$1.durationMs,
       availableCalls: callsPerDuration,
-      windowStartTime: Date.now(),
-      nextWindowPromise: undefined
+      windowStartTime: self.clock.now(),
+      nextWindowPromise: undefined,
+      clock: self.clock
     };
   } else {
     rateLimitState = undefined;

package/src/EffectState.resi

@@ -4,6 +4,8 @@ type effectRateLimitState = {
   mutable availableCalls: int,
   mutable windowStartTime: float,
   mutable nextWindowPromise: option<promise<unit>>,
+  // The run's clock: a test on virtual time opens the next window by advancing.
+  clock: Clock.t,
 }
 
 // Per-(effect, scope) metric counters. Survive rollback so they stay monotonic.
@@ -32,7 +34,7 @@ type effectCacheInMemTable = {
 // Opaque store of all per-(effect, scope) runtime state.
 type t
 
-let make: unit => t
+let make: (~clock: Clock.t=?, unit) => t
 // Get, or lazily create, the in-mem table for an (effect, scope). Reuses the
 // surviving rate-limit window when the table is recreated after a rollback.
 let getTable: (t, ~effect: Internal.effect, ~scope: Internal.chainScope) => effectCacheInMemTable

package/src/EntityId.res

@@ -1,15 +1,10 @@
 // Opaque representation of an entity id. The generated per-entity types expose
-// the real scalar (string / int / bigint); the generic storage and in-memory
+// the real scalar (string / int / bigint / Uint8Array); the generic storage and in-memory
 // layers work with any entity's id through this type without knowing which
 // scalar backs it. The runtime value is always the real id, never a stringified
-// form — `toKey` derives the string only where a JS object/dict key is needed.
+// form — a table's `entityIdToKey` derives the string only where a dict or Set key is needed.
 type t
 
 external unsafeOfAny: 'a => t = "%identity"
 external unsafeToAny: t => 'a = "%identity"
 external unsafeOfString: string => t = "%identity"
-
-// Stringified id used as a JS object/dict key. `String` matches how JS coerces
-// a value used as an object key, so an id indexes the same whether the raw
-// value or its key form is used for lookup, across string/int/bigint.
-let toKey: t => string = %raw(`String`)

package/src/EntityId.res.mjs

@@ -1,9 +1,2 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-let toKey = String;
-
-export {
-  toKey,
-}
-/* toKey Not a pure module */
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/EntityTables.res

@@ -6,7 +6,10 @@ type t = dict<InMemoryTable.Entity.t>
 let make = (entities: array<Internal.entityConfig>): t => {
   let init = Dict.make()
   entities->Array.forEach(entityConfig => {
-    init->Dict.set((entityConfig.name :> string), InMemoryTable.Entity.make())
+    init->Dict.set(
+      (entityConfig.name :> string),
+      InMemoryTable.Entity.make(~entityIdToKey=entityConfig.table.entityIdToKey),
+    )
   })
   init
 }

package/src/EntityTables.res.mjs

@@ -6,7 +6,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 function make(entities) {
   let init = {};
   entities.forEach(entityConfig => {
-    init[entityConfig.name] = InMemoryTable.Entity.make();
+    init[entityConfig.name] = InMemoryTable.Entity.make(entityConfig.table.entityIdToKey);
   });
   return init;
 }