envio 3.3.2 → 3.4.0

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Source from "./Source.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";
@@ -9,139 +8,9 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as SvmHyperSyncClient from "./SvmHyperSyncClient.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function buildInstructionSelections(eventConfigs) {
-  return eventConfigs.flatMap(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 d8 = match$2[3];
-    let d4 = match$2[2];
-    let d2 = match$2[1];
-    let d1 = match$2[0];
-    let gs = cfg.accountFilters;
-    let groups = gs.length !== 0 ? gs : [[]];
-    return groups.map(group => {
-      let pick = position => Stdlib_Array.filterMap(group, f => {
-          if (f.position === position) {
-            return f.values;
-          }
-        })[0];
-      return {
-        programId: [programIdString],
-        d1: d1,
-        d2: d2,
-        d4: d4,
-        d8: d8,
-        a0: pick(0),
-        a1: pick(1),
-        a2: pick(2),
-        a3: pick(3),
-        a4: pick(4),
-        a5: pick(5),
-        isInner: cfg.isInner
-      };
-    });
-  });
-}
-
-function synthLogIndex(instr) {
-  let tx = instr.transactionIndex;
-  let addrSum = Stdlib_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 buildProgramSchemas(eventConfigs) {
-  let descriptorsByProgram = {};
-  eventConfigs.forEach(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 other = ec.definedTypes;
-    let definedTypes;
-    definedTypes = other === null ? ({}) : other;
-    let existing = descriptorsByProgram[programIdString];
-    let descriptor = existing !== undefined ? Primitive_option.valFromOption(existing) : ({
-        programId: programIdString,
-        definedTypes: 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])
-    };
-  });
-  return Object.values(descriptorsByProgram).map(descriptor => JSON.stringify(descriptor));
+function synthLogIndex(transactionIndex, instructionAddress) {
+  let addrSum = Stdlib_Array.reduce(instructionAddress, 0, (acc, n) => ((acc << 10) + n | 0) + 1 | 0);
+  return (transactionIndex << 16) + addrSum | 0;
 }
 
 function parseDecoded(d) {
@@ -165,200 +34,45 @@ function parseDecoded(d) {
   };
 }
 
-function toSvmInstruction(instr, programName, instructionName, logs) {
+function toSvmInstruction(item, programName, instructionName) {
   return {
     programName: programName,
     instructionName: instructionName,
-    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,
-    params: Stdlib_Option.map(instr.decoded, parseDecoded),
-    logs: logs
+    programId: item.programId,
+    data: item.data,
+    accounts: item.accounts,
+    instructionAddress: item.instructionAddress,
+    isInner: item.isInner,
+    d1: item.d1,
+    d2: item.d2,
+    d4: item.d4,
+    d8: item.d8,
+    params: Stdlib_Option.map(item.decoded, parseDecoded),
+    logs: Stdlib_Option.map(item.logs, logs => logs.map(log => ({
+      kind: log.kind,
+      message: log.message
+    })))
   };
 }
 
-function probeRouter(router, programId, instr, byteLengthsDesc, contractAddress, contractNameByAddress) {
-  let probe = dN => {
-    let tag = EventRouter.getSvmEventId(programId, dN);
-    return EventRouter.get(router, tag, contractAddress, contractNameByAddress);
-  };
-  let result = Stdlib_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 toQueryTxField(field) {
-  switch (field) {
-    case "signatures" :
-      return "signatures";
-    case "feePayer" :
-      return "fee_payer";
-    case "success" :
-      return "success";
-    case "err" :
-      return "err";
-    case "fee" :
-      return "fee";
-    case "computeUnitsConsumed" :
-      return "compute_units_consumed";
-    case "accountKeys" :
-      return "account_keys";
-    case "recentBlockhash" :
-      return "recent_blockhash";
-    case "version" :
-      return "version";
-    case "transactionIndex" :
-    case "tokenBalances" :
-      return;
-  }
-}
-
-function toQueryBlockField(field) {
-  switch (field) {
-    case "height" :
-      return "block_height";
-    case "parentSlot" :
-      return "parent_slot";
-    case "parentHash" :
-      return "parent_blockhash";
-    default:
-      return;
-  }
-}
-
 function make(param) {
   let onEventRegistrations = param.onEventRegistrations;
   let chain = param.chain;
-  let eventConfigs = onEventRegistrations.map(reg => reg.eventConfig);
-  let programSchemas = buildProgramSchemas(eventConfigs);
-  let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, undefined, programSchemas.length !== 0 ? programSchemas : undefined);
-  let match = EventRouter.fromSvmEventConfigsOrThrow(onEventRegistrations, chain);
-  let eventRouter = match[0];
-  let orderingByProgram = {};
-  match[1].forEach(o => {
-    orderingByProgram[o.programId] = o.byteLengthsDesc;
-  });
-  let needsLogs = eventConfigs.some(cfg => cfg.includeLogs);
-  let selectedTxFields = new Set();
-  eventConfigs.forEach(cfg => {
-    cfg.selectedTransactionFields.forEach(field => {
-      selectedTxFields.add(field);
-    });
-  });
-  let needsTokenBalances = selectedTxFields.has("tokenBalances");
-  let fields = [
-    "slot",
-    "transaction_index"
-  ];
-  Array.from(selectedTxFields).forEach(field => {
-    let queryField = toQueryTxField(field);
-    if (queryField !== undefined) {
-      fields.push(queryField);
-      return;
-    }
-  });
-  let needsTransactions = Array.from(selectedTxFields).some(field => {
-    switch (field) {
-      case "transactionIndex" :
-      case "tokenBalances" :
-        return false;
-      default:
-        return true;
-    }
-  });
-  let fields$1 = [
-    "slot",
-    "blockhash",
-    "block_time"
-  ];
-  let selected = new Set();
-  eventConfigs.forEach(cfg => {
-    cfg.selectedBlockFields.forEach(field => {
-      selected.add(field);
-    });
-  });
-  selected.forEach(field => {
-    let queryField = toQueryBlockField(field);
-    if (queryField !== undefined) {
-      fields$1.push(queryField);
-      return;
-    }
-  });
-  let getItemsOrThrow = async (fromBlock, toBlock, param, contractNameByAddress, knownHeight, param$1, param$2, itemsTarget, retry, logger) => {
+  let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, undefined, SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations));
+  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, param, knownHeight, param$1, selection, itemsTarget, retry, param$2) => {
     let totalTimeRef = Performance.now();
     let pageFetchRef = Performance.now();
-    let instructionSelections = buildInstructionSelections(eventConfigs);
-    let fields_block = fields$1;
-    let fields_transaction = needsTransactions ? fields : undefined;
-    let fields_log = needsLogs ? [
-        "slot",
-        "transaction_index",
-        "instruction_address",
-        "kind",
-        "message"
-      ] : undefined;
-    let fields_tokenBalance = needsTokenBalances ? [
-        "slot",
-        "transaction_index",
-        "account",
-        "mint",
-        "owner",
-        "pre_amount",
-        "post_amount"
-      ] : undefined;
-    let fields$2 = {
-      block: fields_block,
-      transaction: fields_transaction,
-      log: fields_log,
-      tokenBalance: fields_tokenBalance
-    };
-    let query_toSlot = Stdlib_Option.map(toBlock, toBlock => toBlock + 1 | 0);
-    let query_instructions = instructionSelections;
-    let query_fields = fields$2;
-    let query_maxNumInstructions = itemsTarget;
+    let query_registrationIndexes = selection.onEventRegistrations.map(reg => reg.index);
     let query = {
       fromSlot: fromBlock,
-      toSlot: query_toSlot,
-      instructions: query_instructions,
-      fields: query_fields,
-      maxNumInstructions: query_maxNumInstructions
+      toSlot: toBlock,
+      maxNumInstructions: itemsTarget,
+      registrationIndexes: query_registrationIndexes,
+      addressesByContractName: addressesByContractName
     };
     let match;
     try {
-      match = await client.get(query);
+      match = await client.getEventItems(query);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {
@@ -384,60 +98,31 @@ function make(param) {
       }];
     let parsingRef = Performance.now();
     let blockTimeBySlot = {};
-    resp.data.blocks.forEach(b => {
+    resp.blocks.forEach(b => {
       let t = b.blockTime;
       if (t !== undefined) {
         blockTimeBySlot[b.slot.toString()] = t;
         return;
       }
     });
-    let logsByKey = {};
-    resp.data.logs.forEach(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 = [];
-    resp.data.instructions.forEach(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, contractNameByAddress);
-      if (maybeConfig !== undefined && instr.isCommitted) {
-        let eventConfig = maybeConfig.eventConfig;
-        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 = toSvmInstruction(instr, eventConfig.contractName, eventConfig.name, eventConfig.includeLogs ? maybeLogs : undefined);
-        parsedQueueItems.push({
-          kind: 0,
-          onEventRegistration: maybeConfig,
-          chain: chain,
-          blockNumber: instr.slot,
-          logIndex: synthLogIndex(instr),
-          transactionIndex: instr.transactionIndex,
-          payload: payload
-        });
-      }
+    let parsedQueueItems = resp.items.map(item => {
+      let onEventRegistration = onEventRegistrations[item.onEventRegistrationIndex];
+      let eventConfig = onEventRegistration.eventConfig;
+      let payload = toSvmInstruction(item, eventConfig.contractName, eventConfig.name);
+      return {
+        kind: 0,
+        onEventRegistration: onEventRegistration,
+        chain: chain,
+        blockNumber: item.slot,
+        logIndex: synthLogIndex(item.transactionIndex, item.instructionAddress),
+        transactionIndex: item.transactionIndex,
+        payload: payload
+      };
     });
     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 => ({
+    let blockHashes = resp.blocks.map(b => ({
       blockHash: b.blockhash,
       blockNumber: b.slot
     }));
@@ -578,15 +263,9 @@ function make(param) {
 }
 
 export {
-  buildInstructionSelections,
   synthLogIndex,
-  serializeInstructionAddress,
-  buildProgramSchemas,
   parseDecoded,
   toSvmInstruction,
-  probeRouter,
-  toQueryTxField,
-  toQueryBlockField,
   make,
 }
-/* EventRouter Not a pure module */
+/* SvmHyperSyncClient Not a pure module */

package/src/TestIndexerProxyStorage.res

@@ -1,196 +0,0 @@
-// Message types for communication between worker and main thread
-type requestId = int
-
-// Serializable change with entity as JSON (for worker thread messaging)
-@tag("type")
-type serializableChange =
-  | @as("SET") Set({entityId: string, entity: JSON.t, checkpointId: bigint})
-  | @as("DELETE") Delete({entityId: string, checkpointId: bigint})
-
-type serializableUpdatedEntity = {
-  entityName: string,
-  changes: array<serializableChange>,
-}
-
-// Worker -> Main thread payloads
-@tag("type")
-type workerPayload =
-  | @as("load")
-  Load({
-      tableName: string,
-      // Leaf field values are JSON-serialized with the table's field schemas
-      filter: EntityFilter.t,
-    })
-  | @as("writeBatch")
-  WriteBatch({
-      updatedEntities: array<serializableUpdatedEntity>,
-      checkpointIds: array<bigint>,
-      checkpointChainIds: array<int>,
-      checkpointBlockNumbers: array<int>,
-      checkpointBlockHashes: array<Null.t<string>>,
-      checkpointEventsProcessed: array<int>,
-    })
-
-// Main thread -> Worker payloads
-@tag("type")
-type mainPayload =
-  | @as("response") Response({data: JSON.t})
-  | @as("error") Error({message: string})
-
-// Message wrapper with id
-type message<'payload> = {id: requestId, payload: 'payload}
-type workerMessage = message<workerPayload>
-type mainMessage = message<mainPayload>
-
-// Pending request tracker
-type pendingRequest = {
-  resolve: JSON.t => unit,
-  reject: exn => unit,
-}
-
-type t = {
-  parentPort: NodeJs.WorkerThreads.messagePort,
-  initialState: Persistence.initialState,
-  pendingRequests: dict<pendingRequest>,
-  mutable requestCounter: int,
-}
-
-let make = (~parentPort, ~initialState): t => {
-  let proxy = {
-    parentPort,
-    initialState,
-    pendingRequests: Dict.make(),
-    requestCounter: 0,
-  }
-
-  // Set up message listener for responses from main thread
-  parentPort->NodeJs.WorkerThreads.onPortMessage((msg: mainMessage) => {
-    let idStr = msg.id->Int.toString
-    let {resolve, reject} = switch proxy.pendingRequests->Utils.Dict.dangerouslyGetNonOption(
-      idStr,
-    ) {
-    | Some(pending) => pending
-    | None => JsError.throwWithMessage(`TestIndexer: No pending request found for id ${idStr}`)
-    }
-    Dict.delete(proxy.pendingRequests->Obj.magic, idStr)
-
-    switch msg.payload {
-    | Response({data}) => resolve(data)
-    | Error({message}) => reject(Utils.Error.make(message))
-    }
-  })
-
-  proxy
-}
-
-let nextRequestId = (proxy: t): requestId => {
-  proxy.requestCounter = proxy.requestCounter + 1
-  proxy.requestCounter
-}
-
-let sendRequest = (proxy: t, ~payload: workerPayload): promise<JSON.t> => {
-  Promise.make((resolve, reject) => {
-    let id = proxy->nextRequestId
-    proxy.pendingRequests->Dict.set(id->Int.toString, {resolve, reject})
-    proxy.parentPort->NodeJs.WorkerThreads.postMessage({id, payload})
-  })
-}
-
-let makeStorage = (proxy: t): Persistence.storage => {
-  name: "test-proxy",
-  isInitialized: async () => true,
-  initialize: async (~chainConfigs as _=?, ~entities as _=?, ~enums as _=?, ~envioInfo as _) => {
-    JsError.throwWithMessage(
-      "TestIndexer: initialize should not be called. Use resumeInitialState instead.",
-    )
-  },
-  resumeInitialState: async () => proxy.initialState,
-  loadOrThrow: async (~filter, ~table: Table.table) => {
-    let serializeLeafOrThrow = (~fieldName, ~fieldValue: unknown, ~isArray) => {
-      let queryField = switch table->Table.queryFields->Dict.get(fieldName) {
-      | Some(queryField) => queryField
-      | None =>
-        JsError.throwWithMessage(
-          `TestIndexer: The table "${table.tableName}" doesn't have the field "${fieldName}"`,
-        )
-      }
-      fieldValue
-      ->S.reverseConvertToJsonOrThrow(
-        isArray ? queryField.arrayFieldSchema : queryField.fieldSchema,
-      )
-      ->(Utils.magic: JSON.t => unknown)
-    }
-    let response = await proxy->sendRequest(
-      ~payload=Load({
-        tableName: table.tableName,
-        // Field values must be JSON-safe to survive the worker thread boundary
-        filter: filter->EntityFilter.mapValues(~mapValue=serializeLeafOrThrow),
-      }),
-    )
-    response->S.parseOrThrow(table->Table.rowsSchema)
-  },
-  writeBatch: async (
-    ~batch,
-    ~rollback as _,
-    ~isInReorgThreshold as _,
-    ~config as _,
-    ~allEntities as _,
-    ~updatedEffectsCache as _,
-    ~updatedEntities,
-    ~chainMetaData as _,
-    ~onWrite as _,
-  ) => {
-    // Encode entities to JSON for serialization across worker boundary
-    let serializableEntities = updatedEntities->Array.map((
-      {entityConfig, changes}: Persistence.updatedEntity,
-    ) => {
-      let encodeChange = (change: Change.t<Internal.entity>): serializableChange => {
-        switch change {
-        | Set({entityId, entity, checkpointId}) =>
-          Set({
-            entityId,
-            entity: entity->S.reverseConvertToJsonOrThrow(entityConfig.schema),
-            checkpointId,
-          })
-        | Delete({entityId, checkpointId}) => Delete({entityId, checkpointId})
-        }
-      }
-      {
-        entityName: entityConfig.name,
-        changes: changes->Array.map(encodeChange),
-      }
-    })
-    let _ = await proxy->sendRequest(
-      ~payload=WriteBatch({
-        updatedEntities: serializableEntities,
-        checkpointIds: batch.checkpointIds,
-        checkpointChainIds: batch.checkpointChainIds,
-        checkpointBlockNumbers: batch.checkpointBlockNumbers,
-        checkpointBlockHashes: batch.checkpointBlockHashes,
-        checkpointEventsProcessed: batch.checkpointEventsProcessed,
-      }),
-    )
-  },
-  dumpEffectCache: async () => (),
-  reset: async () => (),
-  setChainMeta: async _ => Obj.magic(),
-  pruneStaleCheckpoints: async (~safeCheckpointId as _) => (),
-  pruneStaleEntityHistory: async (~entityName as _, ~entityIndex as _, ~safeCheckpointId as _) =>
-    (),
-  getRollbackTargetCheckpoint: async (~reorgChainId as _, ~lastKnownValidBlockNumber as _) => {
-    JsError.throwWithMessage(
-      "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
-    )
-  },
-  getRollbackProgressDiff: async (~rollbackTargetCheckpointId as _) => {
-    JsError.throwWithMessage(
-      "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
-    )
-  },
-  getRollbackData: async (~entityConfig as _, ~rollbackTargetCheckpointId as _) => {
-    JsError.throwWithMessage(
-      "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
-    )
-  },
-  close: async () => (),
-}