envio 3.0.1 → 3.0.2-svm-alpha.0

package/src/sources/HyperSyncSolanaSource.res.mjs

@@ -0,0 +1,441 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.res.mjs";
+import * as Hrtime from "../bindings/Hrtime.res.mjs";
+import * as Source from "./Source.res.mjs";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as Prometheus from "../Prometheus.res.mjs";
+import * as EventRouter from "./EventRouter.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as HyperSyncSolanaClient from "./HyperSyncSolanaClient.res.mjs";
+
+let EventRoutingFailed = /* @__PURE__ */Primitive_exceptions.create("HyperSyncSolanaSource.EventRoutingFailed");
+
+function buildInstructionSelections(eventConfigs) {
+  return Belt_Array.keepMap(eventConfigs, cfg => {
+    let programIdString = cfg.programId;
+    if (programIdString === "") {
+      return;
+    }
+    let match = cfg.discriminator;
+    let match$1 = cfg.discriminatorByteLen;
+    let match$2;
+    if (match !== undefined) {
+      switch (match$1) {
+        case 1 :
+          match$2 = [
+            [match],
+            undefined,
+            undefined,
+            undefined
+          ];
+          break;
+        case 2 :
+          match$2 = [
+            undefined,
+            [match],
+            undefined,
+            undefined
+          ];
+          break;
+        case 4 :
+          match$2 = [
+            undefined,
+            undefined,
+            [match],
+            undefined
+          ];
+          break;
+        case 8 :
+          match$2 = [
+            undefined,
+            undefined,
+            undefined,
+            [match]
+          ];
+          break;
+        default:
+          match$2 = [
+            undefined,
+            undefined,
+            undefined,
+            undefined
+          ];
+      }
+    } else {
+      match$2 = [
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      ];
+    }
+    let accountFilters = cfg.accountFilters;
+    let a0 = Belt_Array.get(Belt_Array.keepMap(accountFilters, f => {
+      if (f.position === 0) {
+        return f.values;
+      }
+    }), 0);
+    let a1 = Belt_Array.get(Belt_Array.keepMap(accountFilters, f => {
+      if (f.position === 1) {
+        return f.values;
+      }
+    }), 0);
+    let a2 = Belt_Array.get(Belt_Array.keepMap(accountFilters, f => {
+      if (f.position === 2) {
+        return f.values;
+      }
+    }), 0);
+    let a3 = Belt_Array.get(Belt_Array.keepMap(accountFilters, f => {
+      if (f.position === 3) {
+        return f.values;
+      }
+    }), 0);
+    let a4 = Belt_Array.get(Belt_Array.keepMap(accountFilters, f => {
+      if (f.position === 4) {
+        return f.values;
+      }
+    }), 0);
+    let a5 = Belt_Array.get(Belt_Array.keepMap(accountFilters, f => {
+      if (f.position === 5) {
+        return f.values;
+      }
+    }), 0);
+    return {
+      programId: [programIdString],
+      d1: match$2[0],
+      d2: match$2[1],
+      d4: match$2[2],
+      d8: match$2[3],
+      a0: a0,
+      a1: a1,
+      a2: a2,
+      a3: a3,
+      a4: a4,
+      a5: a5,
+      isInner: cfg.isInner,
+      includeTransaction: cfg.includeTransaction,
+      includeLogs: cfg.includeLogs
+    };
+  });
+}
+
+function synthLogIndex(instr) {
+  let tx = instr.transactionIndex;
+  let addrSum = Belt_Array.reduce(instr.instructionAddress, 0, (acc, n) => ((acc << 10) + n | 0) + 1 | 0);
+  return (tx << 16) + addrSum | 0;
+}
+
+function serializeInstructionAddress(addr) {
+  return addr.map(n => n.toString()).join(",");
+}
+
+function buildSchemaHandles(eventConfigs) {
+  let descriptorsByProgram = {};
+  Belt_Array.forEach(eventConfigs, ec => {
+    let programIdString = ec.programId;
+    if (programIdString === "") {
+      return;
+    }
+    let hasSchema = ec.accounts.length !== 0 || ec.args !== null;
+    let discriminator = Stdlib_Option.getOr(ec.discriminator, "");
+    if (!(hasSchema && discriminator !== "")) {
+      return;
+    }
+    let existing = descriptorsByProgram[programIdString];
+    let descriptor = existing !== undefined ? Primitive_option.valFromOption(existing) : ({
+        programId: programIdString,
+        definedTypes: ec.definedTypes,
+        instructions: []
+      });
+    let instruction = {
+      name: ec.name,
+      discriminator: discriminator,
+      accounts: ec.accounts,
+      args: ec.args
+    };
+    descriptorsByProgram[programIdString] = {
+      programId: descriptor.programId,
+      definedTypes: descriptor.definedTypes,
+      instructions: descriptor.instructions.concat([instruction])
+    };
+  });
+  let handles = {};
+  Belt_Array.forEach(Object.entries(descriptorsByProgram), param => {
+    let json = JSON.stringify(param[1]);
+    let handle = Core.getAddon().registerProgramSchema(json);
+    handles[param[0]] = handle;
+  });
+  return handles;
+}
+
+function decodeIfPossible(instr, schemaHandlesByProgram) {
+  let handle = schemaHandlesByProgram[instr.programId];
+  if (handle === undefined) {
+    return;
+  }
+  let decoded = Core.getAddon().decodeInstruction(handle, instr.data, instr.accounts);
+  if (decoded === null) {
+    return;
+  }
+  let args;
+  try {
+    args = JSON.parse(decoded.argsJson);
+  } catch (exn) {
+    args = {};
+  }
+  let accounts;
+  try {
+    accounts = JSON.parse(decoded.accountsJson);
+  } catch (exn$1) {
+    accounts = {};
+  }
+  return {
+    name: decoded.name,
+    args: args,
+    accounts: accounts,
+    extraAccounts: decoded.extraAccounts
+  };
+}
+
+function toSvmInstruction(instr, schemaHandlesByProgram) {
+  return {
+    programId: instr.programId,
+    data: instr.data,
+    accounts: instr.accounts,
+    instructionAddress: instr.instructionAddress,
+    isInner: instr.isInner,
+    d1: instr.d1,
+    d2: instr.d2,
+    d4: instr.d4,
+    d8: instr.d8,
+    decoded: decodeIfPossible(instr, schemaHandlesByProgram)
+  };
+}
+
+function toSvmTransaction(tx) {
+  return {
+    signatures: tx.signatures,
+    feePayer: Stdlib_Option.map(tx.feePayer, prim => prim),
+    success: tx.success,
+    err: tx.err,
+    fee: Stdlib_Option.map(tx.fee, prim => BigInt(prim)),
+    computeUnitsConsumed: Stdlib_Option.map(tx.computeUnitsConsumed, prim => BigInt(prim)),
+    accountKeys: tx.accountKeys,
+    recentBlockhash: tx.recentBlockhash,
+    version: tx.version
+  };
+}
+
+function probeRouter(router, programId, instr, byteLengthsDesc, contractAddress, indexingAddresses) {
+  let probe = dN => {
+    let tag = EventRouter.getSvmEventId(programId, dN);
+    return EventRouter.get(router, tag, contractAddress, instr.slot, indexingAddresses);
+  };
+  let result = Belt_Array.reduce(byteLengthsDesc, undefined, (acc, len) => {
+    if (acc !== undefined) {
+      return acc;
+    }
+    let candidate;
+    switch (len) {
+      case 1 :
+        candidate = instr.d1;
+        break;
+      case 2 :
+        candidate = instr.d2;
+        break;
+      case 4 :
+        candidate = instr.d4;
+        break;
+      case 8 :
+        candidate = instr.d8;
+        break;
+      default:
+        candidate = undefined;
+    }
+    if (candidate !== undefined) {
+      return probe(candidate);
+    }
+  });
+  if (result !== undefined) {
+    return result;
+  } else {
+    return probe(undefined);
+  }
+}
+
+function make(param) {
+  let eventConfigs = param.eventConfigs;
+  let chain = param.chain;
+  let name = "HyperSyncSolana";
+  let client = HyperSyncSolanaClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, param.clientMaxRetries, undefined, undefined);
+  let match = EventRouter.fromSvmEventConfigsOrThrow(eventConfigs, chain);
+  let eventRouter = match[0];
+  let orderingByProgram = {};
+  Belt_Array.forEach(match[1], o => {
+    orderingByProgram[o.programId] = o.byteLengthsDesc;
+  });
+  let schemaHandlesByProgram = buildSchemaHandles(eventConfigs);
+  let getItemsOrThrow = async (fromBlock, toBlock, param, indexingAddresses, knownHeight, param$1, param$2, retry, logger) => {
+    let totalTimeRef = Hrtime.makeTimer();
+    let pageFetchRef = Hrtime.makeTimer();
+    let instructionSelections = buildInstructionSelections(eventConfigs);
+    let query_instructions = instructionSelections;
+    let query = {
+      fromSlot: fromBlock,
+      toSlot: toBlock,
+      instructions: query_instructions
+    };
+    Prometheus.SourceRequestCount.increment(name, chain, "getInstructions");
+    let resp;
+    try {
+      resp = await client.get(query);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      throw {
+        RE_EXN_ID: Source.GetItemsError,
+        _1: {
+          TAG: "FailedGettingItems",
+          exn: exn,
+          attemptedToBlock: Stdlib_Option.getOr(toBlock, knownHeight),
+          retry: {
+            TAG: "WithBackoff",
+            message: `Unexpected issue while fetching instructions from HyperSync Solana. Attempt a retry.`,
+            backoffMillis: retry !== 0 ? 1000 * retry | 0 : 500
+          }
+        },
+        Error: new Error()
+      };
+    }
+    let pageFetchTime = Hrtime.toSecondsFloat(Hrtime.timeSince(pageFetchRef));
+    let parsingRef = Hrtime.makeTimer();
+    let txByKey = {};
+    Belt_Array.forEach(resp.data.transactions, tx => {
+      let key = tx.slot.toString() + ":" + tx.transactionIndex.toString();
+      txByKey[key] = tx;
+    });
+    let logsByKey = {};
+    Belt_Array.forEach(resp.data.logs, log => {
+      let match = log.transactionIndex;
+      let match$1 = log.instructionAddress;
+      if (match === undefined) {
+        return;
+      }
+      if (match$1 === undefined) {
+        return;
+      }
+      let key = log.slot.toString() + ":" + match.toString() + ":" + serializeInstructionAddress(match$1);
+      let existing = logsByKey[key];
+      if (existing !== undefined) {
+        existing.push(log);
+      } else {
+        logsByKey[key] = [log];
+      }
+    });
+    let parsedQueueItems = [];
+    Belt_Array.forEach(resp.data.instructions, instr => {
+      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);
+      if (maybeConfig !== undefined) {
+        let txKey = instr.slot.toString() + ":" + instr.transactionIndex.toString();
+        let maybeTx = Stdlib_Option.map(txByKey[txKey], toSvmTransaction);
+        let logKey = instr.slot.toString() + ":" + instr.transactionIndex.toString() + ":" + serializeInstructionAddress(instr.instructionAddress);
+        let maybeLogs = Stdlib_Option.map(logsByKey[logKey], logs => logs.map(log => ({
+          kind: Stdlib_Option.getOr(log.kind, ""),
+          message: Stdlib_Option.getOr(log.message, "")
+        })));
+        let payload_contractName = maybeConfig.contractName;
+        let payload_eventName = maybeConfig.name;
+        let payload_instruction = toSvmInstruction(instr, schemaHandlesByProgram);
+        let payload_transaction = maybeConfig.includeTransaction ? maybeTx : undefined;
+        let payload_logs = maybeConfig.includeLogs ? maybeLogs : undefined;
+        let payload_slot = instr.slot;
+        let payload_block = {
+          height: instr.slot,
+          time: 0,
+          hash: ""
+        };
+        let payload = {
+          contractName: payload_contractName,
+          eventName: payload_eventName,
+          instruction: payload_instruction,
+          transaction: payload_transaction,
+          logs: payload_logs,
+          slot: payload_slot,
+          blockTime: undefined,
+          block: payload_block
+        };
+        parsedQueueItems.push({
+          kind: 0,
+          eventConfig: maybeConfig,
+          timestamp: 0,
+          chain: chain,
+          blockNumber: instr.slot,
+          logIndex: synthLogIndex(instr),
+          event: payload
+        });
+      }
+    });
+    let parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingRef));
+    let heighestSlot = resp.nextSlot - 1 | 0;
+    let reorgGuard_rangeLastBlock = {
+      blockHash: "",
+      blockNumber: heighestSlot,
+      blockTimestamp: 0
+    };
+    let reorgGuard = {
+      rangeLastBlock: reorgGuard_rangeLastBlock,
+      prevRangeLastBlock: undefined
+    };
+    let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(totalTimeRef));
+    return {
+      knownHeight: knownHeight,
+      reorgGuard: reorgGuard,
+      parsedQueueItems: parsedQueueItems,
+      fromBlockQueried: fromBlock,
+      latestFetchedBlockNumber: heighestSlot,
+      latestFetchedBlockTimestamp: 0,
+      stats: {
+        "total time elapsed (s)": totalTimeElapsed,
+        "parsing time (s)": parsingTimeElapsed,
+        "page fetch time (s)": pageFetchTime
+      }
+    };
+  };
+  return {
+    name: name,
+    sourceFor: "Sync",
+    chain: chain,
+    poweredByHyperSync: true,
+    pollingInterval: 1000,
+    getBlockHashes: (param, param$1) => Stdlib_JsError.throwWithMessage("HyperSyncSolanaSource does not support getBlockHashes yet (reorg detection at finalized commitment is no-op in C2)"),
+    getHeightOrThrow: async () => {
+      let timer = Hrtime.makeTimer();
+      let h = await client.getHeight();
+      let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timer));
+      Prometheus.SourceRequestCount.increment(name, chain, "getHeight");
+      Prometheus.SourceRequestCount.addSeconds(name, chain, "getHeight", seconds);
+      return h;
+    },
+    getItemsOrThrow: getItemsOrThrow
+  };
+}
+
+export {
+  EventRoutingFailed,
+  buildInstructionSelections,
+  synthLogIndex,
+  serializeInstructionAddress,
+  buildSchemaHandles,
+  decodeIfPossible,
+  toSvmInstruction,
+  toSvmTransaction,
+  probeRouter,
+  make,
+}
+/* Core Not a pure module */

package/src/sources/HyperSyncSource.res

@@ -192,18 +192,15 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
     switch hscDecoder.contents {
     | Some(decoder) => decoder
     | None =>
-      switch HyperSyncClient.Decoder.fromSignatures(allEventSignatures) {
+      switch HyperSyncClient.Decoder.fromSignatures(
+        allEventSignatures,
+        ~checksumAddresses=!lowercaseAddresses,
+      ) {
       | exception exn =>
         exn->ErrorHandling.mkLogAndRaise(
           ~msg="Failed to instantiate a decoder from hypersync client, please double check your ABI",
         )
-      | decoder =>
-        if lowercaseAddresses {
-          decoder.disableChecksummedAddresses()
-        } else {
-          decoder.enableChecksummedAddresses()
-        }
-        decoder
+      | decoder => decoder
       }
     }
   }

package/src/sources/HyperSyncSource.res.mjs

@@ -135,19 +135,12 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
     if (decoder !== undefined) {
       return decoder;
     }
-    let decoder$1;
     try {
-      decoder$1 = HyperSyncClient.Decoder.fromSignatures(allEventSignatures);
+      return HyperSyncClient.Decoder.fromSignatures(allEventSignatures, !lowercaseAddresses);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       return ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate a decoder from hypersync client, please double check your ABI", exn);
     }
-    if (lowercaseAddresses) {
-      decoder$1.disableChecksummedAddresses();
-    } else {
-      decoder$1.enableChecksummedAddresses();
-    }
-    return decoder$1;
   };
   let UndefinedValue = /* @__PURE__ */Primitive_exceptions.create("UndefinedValue");
   let makeEventBatchQueueItem = (item, params, eventConfig) => {

package/src/sources/RpcSource.res.mjs

@@ -1022,7 +1022,7 @@ function make(param) {
     if (decoder !== undefined) {
       return decoder;
     } else {
-      return HyperSyncClient.Decoder.fromSignatures(allEventSignatures);
+      return HyperSyncClient.Decoder.fromSignatures(allEventSignatures, undefined);
     }
   };
   let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, indexingAddresses, knownHeight, partitionId, selection, param, param$1) => {

package/src/sources/Svm.res

@@ -39,7 +39,7 @@ module GetFinalizedSlot = {
   )
 }
 
-let makeRPCSource = (~chain, ~rpc: string): Source.t => {
+let makeRPCSource = (~chain, ~rpc: string, ~sourceFor: Source.sourceFor=Sync): Source.t => {
   let client = Rest.client(rpc)
   let chainId = chain->ChainMap.Chain.toChainId
 
@@ -54,7 +54,7 @@ let makeRPCSource = (~chain, ~rpc: string): Source.t => {
 
   {
     name,
-    sourceFor: Sync,
+    sourceFor,
     chain,
     poweredByHyperSync: false,
     pollingInterval: 10_000,

package/src/sources/Svm.res.mjs

@@ -60,14 +60,15 @@ let GetFinalizedSlot = {
   route: route
 };
 
-function makeRPCSource(chain, rpc) {
+function makeRPCSource(chain, rpc, sourceForOpt) {
+  let sourceFor = sourceForOpt !== undefined ? sourceForOpt : "Sync";
   let client = Rest.client(rpc, undefined);
   let host = Utils.Url.getHostFromUrl(rpc);
   let urlHost = host !== undefined ? host : Stdlib_JsError.throwWithMessage(`The RPC url for chain ` + String(chain) + ` is in incorrect format. The RPC url needs to start with either http:// or https://`);
   let name = `RPC (` + urlHost + `)`;
   return {
     name: name,
-    sourceFor: "Sync",
+    sourceFor: sourceFor,
     chain: chain,
     poweredByHyperSync: false,
     pollingInterval: 10000,

package/src/tui/Tui.res

@@ -13,6 +13,7 @@ module ChainLine = {
     ~endBlock,
     ~poweredByHyperSync,
     ~eventsProcessed,
+    ~blockUnit: string,
   ) => {
     let chainsWidth = Pervasives.min(stdoutColumns - 2, 60)
     let headerWidth = maxChainIdLength + 10 // 10 for additional text
@@ -27,9 +28,10 @@ module ChainLine = {
       let toBlockStr = toBlock->TuiData.formatLocaleString
       let eventsStr = eventsProcessed->TuiData.formatFloatLocaleString
 
+      let endLabel = blockUnit === "Slots" ? " (End Slot)" : " (End Block)"
       let blocksText =
-        `Blocks: ${progressBlockStr} / ${toBlockStr}` ++
-        (endBlock->Option.isSome ? " (End Block)" : "") ++ `  `
+        `${blockUnit}: ${progressBlockStr} / ${toBlockStr}` ++
+        (endBlock->Option.isSome ? endLabel : "") ++ `  `
       let eventsText = `Events: ${eventsStr}`
 
       let fitsSameLine = blocksText->String.length + eventsText->String.length <= chainsWidth
@@ -210,6 +212,10 @@ module App = {
             poweredByHyperSync: (
               cf.sourceManager->SourceManager.getActiveSource
             ).poweredByHyperSync,
+            blockUnit: switch state.ctx.config.ecosystem.name {
+            | Svm => "Slots"
+            | Evm | Fuel => "Blocks"
+            },
           }: TuiData.chain
         )
       })
@@ -249,6 +255,7 @@ module App = {
           stdoutColumns={stdoutColumns}
           poweredByHyperSync={chainData.poweredByHyperSync}
           eventsProcessed={chainData.eventsProcessed}
+          blockUnit={chainData.blockUnit}
         />
       })
       ->React.array}

package/src/tui/Tui.res.mjs

@@ -19,6 +19,7 @@ import * as JsxRuntime from "react/jsx-runtime";
 import * as BufferedProgressBar from "./components/BufferedProgressBar.res.mjs";
 
 function Tui$ChainLine(props) {
+  let blockUnit = props.blockUnit;
   let poweredByHyperSync = props.poweredByHyperSync;
   let endBlock = props.endBlock;
   let startBlock = props.startBlock;
@@ -33,8 +34,9 @@ function Tui$ChainLine(props) {
     let progressBlockStr = TuiData.formatLocaleString(progressBlock);
     let toBlockStr = TuiData.formatLocaleString(toBlock);
     let eventsStr = TuiData.formatFloatLocaleString(props.eventsProcessed);
-    let blocksText = `Blocks: ` + progressBlockStr + ` / ` + toBlockStr + (
-      Stdlib_Option.isSome(endBlock) ? " (End Block)" : ""
+    let endLabel = blockUnit === "Slots" ? " (End Slot)" : " (End Block)";
+    let blocksText = blockUnit + `: ` + progressBlockStr + ` / ` + toBlockStr + (
+      Stdlib_Option.isSome(endBlock) ? endLabel : ""
     ) + `  `;
     let eventsText = `Events: ` + eventsStr;
     let fitsSameLine = (blocksText.length + eventsText.length | 0) <= chainsWidth;
@@ -242,6 +244,17 @@ function Tui$App(props) {
             })
         ) : "SearchingForEvents";
     }
+    let match$1 = state.ctx.config.ecosystem.name;
+    let tmp;
+    switch (match$1) {
+      case "evm" :
+      case "fuel" :
+        tmp = "Blocks";
+        break;
+      case "svm" :
+        tmp = "Slots";
+        break;
+    }
     return {
       chainId: cf.chainConfig.id.toString(),
       eventsProcessed: numEventsProcessed,
@@ -254,7 +267,8 @@ function Tui$App(props) {
       poweredByHyperSync: SourceManager.getActiveSource(cf.sourceManager).poweredByHyperSync,
       progress: progress,
       latestFetchedBlockNumber: latestFetchedBlockNumber,
-      knownHeight: knownHeight
+      knownHeight: knownHeight,
+      blockUnit: tmp
     };
   });
   let totalEventsProcessed = Stdlib_Array.reduce(chains, 0, (acc, chain) => acc + chain.eventsProcessed);
@@ -292,7 +306,8 @@ function Tui$App(props) {
         startBlock: chainData.startBlock,
         endBlock: chainData.endBlock,
         poweredByHyperSync: chainData.poweredByHyperSync,
-        eventsProcessed: chainData.eventsProcessed
+        eventsProcessed: chainData.eventsProcessed,
+        blockUnit: chainData.blockUnit
       }, i.toString())),
       JsxRuntime.jsx(Tui$TotalEventsProcessed, {
         totalEventsProcessed: totalEventsProcessed,

package/src/tui/components/TuiData.res

@@ -30,6 +30,9 @@ type chain = {
   progress: progress,
   latestFetchedBlockNumber: int,
   knownHeight: int,
+  /** Localized unit noun for this chain's progress. `"Slots"` on SVM,
+   `"Blocks"` everywhere else. Drives the per-chain progress label. */
+  blockUnit: string,
 }
 
 let minOfOption: (int, option<int>) => int = (a: int, b: option<int>) => {