envio 3.3.0-alpha.2 → 3.3.0-alpha.3

package/src/sources/Svm.res

@@ -20,16 +20,10 @@ let transactionFields = [
   "tokenBalances",
 ]
 
-// Field name → bit index (the code shared with the Rust store), built once.
-let transactionFieldCodes = TransactionStore.fieldCodes(transactionFields)
-
-let transactionFieldMask = (eventConfigs: array<Internal.eventConfig>): float =>
-  eventConfigs->TransactionStore.mask(~codes=transactionFieldCodes)
+let transactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
 
 let make = (~logger: Pino.t): Ecosystem.t => {
   name: Svm,
-  blockFields: ["slot"],
-  transactionFields,
   blockNumberName: "height",
   blockTimestampName: "time",
   blockHashName: "hash",
@@ -94,9 +88,9 @@ let makeRPCSource = (~chain, ~rpc: string, ~sourceFor: Source.sourceFor=Sync): S
     getBlockHashes: (~blockNumbers as _, ~logger as _) =>
       JsError.throwWithMessage("Svm does not support getting block hashes"),
     getHeightOrThrow: async () => {
-      let timerRef = Hrtime.makeTimer()
+      let timerRef = Performance.now()
       let height = await GetFinalizedSlot.route->Rest.fetch((), ~client)
-      let seconds = timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+      let seconds = timerRef->Performance.secondsSince
       Prometheus.SourceRequestCount.increment(~sourceName=name, ~chainId, ~method="getSlot")
       Prometheus.SourceRequestCount.addSeconds(
         ~sourceName=name,
@@ -110,7 +104,7 @@ let makeRPCSource = (~chain, ~rpc: string, ~sourceFor: Source.sourceFor=Sync): S
       ~fromBlock as _,
       ~toBlock as _,
       ~addressesByContractName as _,
-      ~indexingAddresses as _,
+      ~contractNameByAddress as _,
       ~knownHeight as _,
       ~partitionId as _,
       ~selection as _,

package/src/sources/Svm.res.mjs

@@ -3,9 +3,9 @@
 import * as Rpc from "./Rpc.res.mjs";
 import * as Rest from "../vendored/Rest.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as TransactionStore from "./TransactionStore.res.mjs";
@@ -30,17 +30,11 @@ let transactionFields = [
   "tokenBalances"
 ];
 
-let transactionFieldCodes = TransactionStore.fieldCodes(transactionFields);
-
-function transactionFieldMask(eventConfigs) {
-  return TransactionStore.mask(eventConfigs, transactionFieldCodes);
-}
+let transactionFieldMask = TransactionStore.makeMaskFn(transactionFields);
 
 function make(logger) {
   return {
     name: "svm",
-    blockFields: ["slot"],
-    transactionFields: transactionFields,
     blockNumberName: "height",
     blockTimestampName: "time",
     blockHashName: "hash",
@@ -89,9 +83,9 @@ function makeRPCSource(chain, rpc, sourceForOpt) {
     pollingInterval: 10000,
     getBlockHashes: (param, param$1) => Stdlib_JsError.throwWithMessage("Svm does not support getting block hashes"),
     getHeightOrThrow: async () => {
-      let timerRef = Hrtime.makeTimer();
+      let timerRef = Performance.now();
       let height = await Rest.fetch(route, undefined, client);
-      let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
+      let seconds = Performance.secondsSince(timerRef);
       Prometheus.SourceRequestCount.increment(name, chain, "getSlot");
       Prometheus.SourceRequestCount.addSeconds(name, chain, "getSlot", seconds);
       return height;
@@ -103,10 +97,9 @@ function makeRPCSource(chain, rpc, sourceForOpt) {
 export {
   cleanUpRawEventFieldsInPlace,
   transactionFields,
-  transactionFieldCodes,
   transactionFieldMask,
   make,
   GetFinalizedSlot,
   makeRPCSource,
 }
-/* transactionFieldCodes Not a pure module */
+/* transactionFieldMask Not a pure module */

package/src/sources/SvmHyperSyncSource.res

@@ -216,11 +216,11 @@ let probeRouter = (
   instr: SvmHyperSyncClient.ResponseTypes.instruction,
   byteLengthsDesc: array<int>,
   ~contractAddress,
-  ~indexingAddresses,
+  ~contractNameByAddress,
 ) => {
   let probe = (dN: option<string>) => {
     let tag = EventRouter.getSvmEventId(~programId, ~discriminator=dN)
-    router->EventRouter.get(~tag, ~contractAddress, ~blockNumber=instr.slot, ~indexingAddresses)
+    router->EventRouter.get(~tag, ~contractAddress, ~contractNameByAddress)
   }
 
   let result = byteLengthsDesc->Array.reduce(None, (acc, len) =>
@@ -319,26 +319,32 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
     )
     fields
   }
-  // Every selected field except `tokenBalances` (its own table) is read off a
-  // stored transaction record, so the transaction table must be fetched to
-  // populate the store — even when only `transactionIndex` (a key column) is
-  // selected.
-  let txFieldCount = selectedTxFields->Utils.Set.size
-  let needsTransactions = txFieldCount > 1 || (txFieldCount === 1 && !needsTokenBalances)
+  // The transaction table is fetched only when a selected field is actually read
+  // off a stored transaction record. `transactionIndex` materialises from the
+  // store key and `tokenBalances` lives in its own table, so neither requires it.
+  let needsTransactions =
+    selectedTxFields
+    ->Utils.Set.toArray
+    ->Array.some(field =>
+      switch field {
+      | Internal.TransactionIndex | Internal.TokenBalances => false
+      | _ => true
+      }
+    )
 
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
     ~addressesByContractName as _,
-    ~indexingAddresses,
+    ~contractNameByAddress,
     ~knownHeight,
     ~partitionId as _,
     ~selection as _,
     ~retry,
     ~logger,
   ) => {
-    let totalTimeRef = Hrtime.makeTimer()
-    let pageFetchRef = Hrtime.makeTimer()
+    let totalTimeRef = Performance.now()
+    let pageFetchRef = Performance.now()
 
     let instructionSelections = buildInstructionSelections(eventConfigs)
     // Under the server's default merge mode, requesting a table's columns is
@@ -384,9 +390,9 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
         ),
       )
     }
-    let pageFetchTime = pageFetchRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+    let pageFetchTime = pageFetchRef->Performance.secondsSince
 
-    let parsingRef = Hrtime.makeTimer()
+    let parsingRef = Performance.now()
 
     // Per-slot unix timestamp lookup from the response's `blocks` table. Slots
     // without a block row (rare; usually skipped slots) fall back to `None`.
@@ -434,7 +440,7 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
         instr,
         byteLengths,
         ~contractAddress,
-        ~indexingAddresses,
+        ~contractNameByAddress,
       )
 
       switch maybeConfig {
@@ -492,7 +498,7 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
       let _ = logger
     })
 
-    let parsingTimeElapsed = parsingRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+    let parsingTimeElapsed = parsingRef->Performance.secondsSince
     let highestSlot = resp.nextSlot - 1
     let latestBlockTime =
       blockTimeBySlot
@@ -507,7 +513,7 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
       blockHash: b.blockhash,
     })
 
-    let totalTimeElapsed = totalTimeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+    let totalTimeElapsed = totalTimeRef->Performance.secondsSince
 
     {
       latestFetchedBlockTimestamp: latestBlockTime,
@@ -597,9 +603,9 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
     poweredByHyperSync: true,
     getBlockHashes,
     getHeightOrThrow: async () => {
-      let timer = Hrtime.makeTimer()
+      let timer = Performance.now()
       let h = await client.getHeight()
-      let seconds = timer->Hrtime.timeSince->Hrtime.toSecondsFloat
+      let seconds = timer->Performance.secondsSince
       Prometheus.SourceRequestCount.increment(~sourceName=name, ~chainId, ~method="getHeight")
       Prometheus.SourceRequestCount.addSeconds(
         ~sourceName=name,

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -1,9 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
 import * as EventRouter from "./EventRouter.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -185,10 +185,10 @@ function toSvmInstruction(instr, programName, instructionName, logs, block) {
   };
 }
 
-function probeRouter(router, programId, instr, byteLengthsDesc, contractAddress, indexingAddresses) {
+function probeRouter(router, programId, instr, byteLengthsDesc, contractAddress, contractNameByAddress) {
   let probe = dN => {
     let tag = EventRouter.getSvmEventId(programId, dN);
-    return EventRouter.get(router, tag, contractAddress, instr.slot, indexingAddresses);
+    return EventRouter.get(router, tag, contractAddress, contractNameByAddress);
   };
   let result = Stdlib_Array.reduce(byteLengthsDesc, undefined, (acc, len) => {
     if (acc !== undefined) {
@@ -279,11 +279,18 @@ function make(param) {
       return;
     }
   });
-  let txFieldCount = selectedTxFields.size;
-  let needsTransactions = txFieldCount > 1 || txFieldCount === 1 && !needsTokenBalances;
-  let getItemsOrThrow = async (fromBlock, toBlock, param, indexingAddresses, knownHeight, param$1, param$2, retry, logger) => {
-    let totalTimeRef = Hrtime.makeTimer();
-    let pageFetchRef = Hrtime.makeTimer();
+  let needsTransactions = Array.from(selectedTxFields).some(field => {
+    switch (field) {
+      case "transactionIndex" :
+      case "tokenBalances" :
+        return false;
+      default:
+        return true;
+    }
+  });
+  let getItemsOrThrow = async (fromBlock, toBlock, param, contractNameByAddress, knownHeight, param$1, param$2, retry, logger) => {
+    let totalTimeRef = Performance.now();
+    let pageFetchRef = Performance.now();
     let instructionSelections = buildInstructionSelections(eventConfigs);
     let fields_block = [
       "slot",
@@ -344,8 +351,8 @@ function make(param) {
       };
     }
     let resp = match[0];
-    let pageFetchTime = Hrtime.toSecondsFloat(Hrtime.timeSince(pageFetchRef));
-    let parsingRef = Hrtime.makeTimer();
+    let pageFetchTime = Performance.secondsSince(pageFetchRef);
+    let parsingRef = Performance.now();
     let blockTimeBySlot = {};
     resp.data.blocks.forEach(b => {
       let t = b.blockTime;
@@ -377,7 +384,7 @@ function make(param) {
       let programId = instr.programId;
       let byteLengths = Stdlib_Option.getOr(orderingByProgram[instr.programId], []);
       let contractAddress = instr.programId;
-      let maybeConfig = probeRouter(eventRouter, programId, instr, byteLengths, contractAddress, indexingAddresses);
+      let maybeConfig = probeRouter(eventRouter, programId, instr, byteLengths, contractAddress, contractNameByAddress);
       if (maybeConfig !== undefined) {
         let logKey = instr.slot.toString() + ":" + instr.transactionIndex.toString() + ":" + serializeInstructionAddress(instr.instructionAddress);
         let maybeLogs = Stdlib_Option.map(logsByKey[logKey], logs => logs.map(log => ({
@@ -404,14 +411,14 @@ function make(param) {
         });
       }
     });
-    let parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingRef));
+    let parsingTimeElapsed = Performance.secondsSince(parsingRef);
     let highestSlot = resp.nextSlot - 1 | 0;
     let latestBlockTime = Stdlib_Option.getOr(blockTimeBySlot[highestSlot.toString()], 0);
     let blockHashes = resp.data.blocks.map(b => ({
       blockHash: b.blockhash,
       blockNumber: b.slot
     }));
-    let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(totalTimeRef));
+    let totalTimeElapsed = Performance.secondsSince(totalTimeRef);
     return {
       knownHeight: knownHeight,
       blockHashes: blockHashes,
@@ -513,9 +520,9 @@ function make(param) {
     pollingInterval: 1000,
     getBlockHashes: getBlockHashes,
     getHeightOrThrow: async () => {
-      let timer = Hrtime.makeTimer();
+      let timer = Performance.now();
       let h = await client.getHeight();
-      let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timer));
+      let seconds = Performance.secondsSince(timer);
       Prometheus.SourceRequestCount.increment(name, chain, "getHeight");
       Prometheus.SourceRequestCount.addSeconds(name, chain, "getHeight", seconds);
       return h;

package/src/sources/TransactionStore.res

@@ -34,6 +34,13 @@ let mask = (eventConfigs: array<Internal.eventConfig>, ~codes: dict<int>): float
   selected->Utils.Set.toArray->Array.reduce(0., (mask, code) => mask +. pow2(code))
 }
 
+// Build an ecosystem's mask function from its ordered field-name array. The
+// field codes are derived once and closed over.
+let makeMaskFn = (fields: array<string>): (array<Internal.eventConfig> => float) => {
+  let codes = fieldCodes(fields)
+  eventConfigs => eventConfigs->mask(~codes)
+}
+
 // Drain another store (a fetch-response page) into this one.
 @send external merge: (t, t) => unit = "merge"
 
@@ -60,52 +67,62 @@ external materialize: (
 // selected none — so `event.transaction` is never `undefined` (matching the
 // inline sources). Deduped per (blockNumber, transactionIndex).
 let materializeItems = async (store: t, ~items: array<Internal.item>, ~mask: float) => {
-  // Store-backed items arrive in (block, logIndex) order, and a transaction's
-  // logs are contiguous within a block, so events sharing a (blockNumber,
-  // transactionIndex) are adjacent. Group them by extending the current run
-  // rather than hashing a string key per item. A key recurring non-adjacently
-  // just splits into two groups (one redundant decode) — never incorrect.
-  let blockNumbers = []
-  let transactionIndices = []
-  let payloadGroups = []
+  if mask == 0. {
+    // No fields selected: there's nothing to decode and no reason to group by
+    // key, but each store-backed item still gets an empty transaction object so
+    // `event.transaction` is never undefined (matching the inline sources).
+    items->Array.forEach(item =>
+      switch item {
+      | Internal.Event(_) =>
+        let payload = (item->Internal.castUnsafeEventItem).payload
+        switch payload->Internal.getPayloadTransaction->Nullable.toOption {
+        | Some(_) => () // RPC/simulate/Fuel carry the transaction inline.
+        | None => payload->Internal.setPayloadTransaction(%raw(`{}`))
+        }
+      | Internal.Block(_) => ()
+      }
+    )
+  } else {
+    // Store-backed items arrive in (block, logIndex) order, and a transaction's
+    // logs are contiguous within a block, so events sharing a (blockNumber,
+    // transactionIndex) are adjacent. Group them by extending the current run
+    // rather than hashing a string key per item. A key recurring non-adjacently
+    // just splits into two groups (one redundant decode) — never incorrect.
+    let blockNumbers = []
+    let transactionIndices = []
+    let payloadGroups = []
 
-  items->Array.forEach(item =>
-    switch item {
-    | Internal.Event(_) =>
-      let eventItem = item->Internal.castUnsafeEventItem
-      switch eventItem.payload->Internal.getPayloadTransaction->Nullable.toOption {
-      | Some(_) => () // RPC/simulate/Fuel carry the transaction inline.
-      | None =>
-        let {blockNumber, transactionIndex} = eventItem
-        let last = payloadGroups->Array.length - 1
-        if (
-          last >= 0 &&
-          blockNumbers->Array.getUnsafe(last) == blockNumber &&
-          transactionIndices->Array.getUnsafe(last) == transactionIndex
-        ) {
-          payloadGroups->Array.getUnsafe(last)->Array.push(eventItem.payload)
-        } else {
-          blockNumbers->Array.push(blockNumber)
-          transactionIndices->Array.push(transactionIndex)
-          payloadGroups->Array.push([eventItem.payload])
+    items->Array.forEach(item =>
+      switch item {
+      | Internal.Event(_) =>
+        let eventItem = item->Internal.castUnsafeEventItem
+        switch eventItem.payload->Internal.getPayloadTransaction->Nullable.toOption {
+        | Some(_) => () // RPC/simulate/Fuel carry the transaction inline.
+        | None =>
+          let {blockNumber, transactionIndex} = eventItem
+          let last = payloadGroups->Array.length - 1
+          if (
+            last >= 0 &&
+            blockNumbers->Array.getUnsafe(last) == blockNumber &&
+            transactionIndices->Array.getUnsafe(last) == transactionIndex
+          ) {
+            payloadGroups->Array.getUnsafe(last)->Array.push(eventItem.payload)
+          } else {
+            blockNumbers->Array.push(blockNumber)
+            transactionIndices->Array.push(transactionIndex)
+            payloadGroups->Array.push([eventItem.payload])
+          }
         }
+      | Internal.Block(_) => ()
       }
-    | Internal.Block(_) => ()
-    }
-  )
+    )
 
-  if payloadGroups->Utils.Array.notEmpty {
-    // A zero mask selects no fields, so there's nothing to decode — each
-    // store-backed item still gets an empty transaction object, so
-    // `event.transaction` is never undefined (matching the inline sources).
-    let txs = if mask == 0. {
-      payloadGroups->Array.map((_): Internal.eventTransaction => %raw(`{}`))
-    } else {
-      await store->materialize(~blockNumbers, ~transactionIndices, ~mask)
+    if payloadGroups->Utils.Array.notEmpty {
+      let txs = await store->materialize(~blockNumbers, ~transactionIndices, ~mask)
+      payloadGroups->Array.forEachWithIndex((payloads, i) => {
+        let tx = txs->Array.getUnsafe(i)
+        payloads->Array.forEach(payload => payload->Internal.setPayloadTransaction(tx))
+      })
     }
-    payloadGroups->Array.forEachWithIndex((payloads, i) => {
-      let tx = txs->Array.getUnsafe(i)
-      payloads->Array.forEach(payload => payload->Internal.setPayloadTransaction(tx))
-    })
   }
 }

package/src/sources/TransactionStore.res.mjs

@@ -32,7 +32,26 @@ function mask(eventConfigs, codes) {
   return Stdlib_Array.reduce(Array.from(selected), 0, (mask, code) => mask + pow2(code));
 }
 
+function makeMaskFn(fields) {
+  let codes = fieldCodes(fields);
+  return eventConfigs => mask(eventConfigs, codes);
+}
+
 async function materializeItems(store, items, mask) {
+  if (mask === 0) {
+    items.forEach(item => {
+      if (item.kind !== 0) {
+        return;
+      }
+      let payload = item.payload;
+      let match = payload.transaction;
+      if (match == null) {
+        payload.transaction = {};
+        return;
+      }
+    });
+    return;
+  }
   let blockNumbers = [];
   let transactionIndices = [];
   let payloadGroups = [];
@@ -58,7 +77,7 @@ async function materializeItems(store, items, mask) {
   if (!Utils.$$Array.notEmpty(payloadGroups)) {
     return;
   }
-  let txs = mask === 0 ? payloadGroups.map(param => ({})) : await store.materialize(blockNumbers, transactionIndices, mask);
+  let txs = await store.materialize(blockNumbers, transactionIndices, mask);
   payloadGroups.forEach((payloads, i) => {
     let tx = txs[i];
     payloads.forEach(payload => {
@@ -72,6 +91,7 @@ export {
   fieldCodes,
   pow2,
   mask,
+  makeMaskFn,
   materializeItems,
 }
 /* Core Not a pure module */

package/svm.schema.json

@@ -463,53 +463,46 @@
       "type": "object",
       "properties": {
         "transaction_fields": {
-          "description": "Include the parent transaction for each matched instruction. Use `true` to include all fields.",
-          "anyOf": [
-            {
-              "$ref": "#/$defs/FieldSelectionValue"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "description": "Parent-transaction fields to include on each matched instruction, as a list of field names. Omit (or pass an empty list) to include no transaction.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/$defs/SvmTransactionField"
+          }
         },
         "log_fields": {
-          "description": "Include program logs scoped to each matched instruction. Use `true` to include all fields.",
-          "anyOf": [
-            {
-              "$ref": "#/$defs/FieldSelectionValue"
-            },
-            {
-              "type": "null"
-            }
+          "description": "Set to `true` to include program logs scoped to each matched instruction.",
+          "type": [
+            "boolean",
+            "null"
           ]
         },
         "token_balance_fields": {
-          "description": "Include SPL Token / Token-2022 balance snapshots for the parent transaction. Implies transaction_fields: true. Use `true` to include all fields.",
-          "anyOf": [
-            {
-              "$ref": "#/$defs/FieldSelectionValue"
-            },
-            {
-              "type": "null"
-            }
+          "description": "Set to `true` to include SPL Token / Token-2022 balance snapshots for the parent transaction, exposed as `transaction.tokenBalances`. Independent of `transaction_fields`.",
+          "type": [
+            "boolean",
+            "null"
           ]
         }
       },
       "additionalProperties": false
     },
-    "FieldSelectionValue": {
-      "description": "Value for a field-selection entry. `true` includes all fields;\na list of field names enables per-field selection (not yet supported).",
-      "anyOf": [
-        {
-          "type": "boolean"
-        },
-        {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
+    "SvmTransactionField": {
+      "description": "Selectable parent-transaction field names (camelCase), matching the\npublic `svmTransaction` shape. `tokenBalances` is selected via the\nseparate `token_balance_fields` toggle, so it isn't listed here.",
+      "type": "string",
+      "enum": [
+        "transactionIndex",
+        "signatures",
+        "feePayer",
+        "success",
+        "err",
+        "fee",
+        "computeUnitsConsumed",
+        "accountKeys",
+        "recentBlockhash",
+        "version"
       ]
     },
     "ArgDef": {

package/src/bindings/Hrtime.res

@@ -1,58 +0,0 @@
-type seconds = float
-type milliseconds = float
-type nanoseconds = float
-
-type timeTuple = (seconds, nanoseconds)
-
-type timeRef = timeTuple
-
-type timeElapsed = timeTuple
-
-@val @scope("process") external makeTimer: unit => timeRef = "hrtime"
-
-@val @scope("process") external timeSince: timeRef => timeElapsed = "hrtime"
-
-let nanoToMilli = (nano: nanoseconds): milliseconds => nano /. 1_000_000.
-let secToMilli = (sec: seconds): milliseconds => sec *. 1_000.
-
-let nanoToTimeTuple = (nano: nanoseconds): timeTuple => {
-  let factor = 1_000_000_000.
-  let seconds = Math.floor(nano /. factor)
-  let nanos = Float.mod(nano, factor)
-  (seconds, nanos)
-}
-
-let timeElapsedToNewRef = (elapsed: timeElapsed, ref: timeRef): timeRef => {
-  let (elapsedSeconds, elapsedNano) = elapsed
-  let (refSeconds, refNano) = ref
-
-  let (nanoExtraSeconds, remainderNanos) = nanoToTimeTuple(elapsedNano +. refNano)
-  (elapsedSeconds +. refSeconds +. nanoExtraSeconds, remainderNanos)
-}
-
-let toMillis = ((sec, nano): timeElapsed): milliseconds => {
-  sec->secToMilli +. nano->nanoToMilli
-}
-
-let toSeconds = ((sec, nano): timeElapsed): seconds => {
-  sec +. nano /. 1_000_000_000.
-}
-
-let toSecondsFloat = (elapsed: timeElapsed): float => {
-  elapsed->toSeconds->(Utils.magic: seconds => float)
-}
-
-let toInt = float => float->Int.fromFloat
-let intFromMillis = toInt
-let intFromNanos = toInt
-let intFromSeconds = toInt
-let floatFromMillis: milliseconds => float = v => v->(Utils.magic: milliseconds => float)
-let floatFromSeconds: seconds => float = v => v->(Utils.magic: seconds => float)
-
-let millisBetween = (~from: timeRef, ~to: timeRef): int => {
-  to->toMillis->intFromMillis - from->toMillis->intFromMillis
-}
-
-let secondsBetween = (~from: timeRef, ~to: timeRef): float => {
-  to->toSecondsFloat -. from->toSecondsFloat
-}