envio 3.3.2 → 3.5.0-alpha.0

package/src/sources/SvmHyperSyncClient.res

@@ -7,10 +7,78 @@ type cfg = {
   maxNumRetries?: int,
   retryBaseMs?: int,
   retryCeilingMs?: int,
-  /// Per-program Borsh schema descriptors (JSON, one per program). The Rust
-  /// client builds these into decoders at creation and decodes matching
-  /// instructions inline on `get`.
-  programSchemas?: array<string>,
+}
+
+module Registration = {
+  type accountFilter = {
+    position: int,
+    values: array<string>,
+  }
+
+  // The full per-(instruction, chain) registration passed to the Rust client
+  // at construction: routing identity, the fetch state queries are built
+  // from, and the Borsh schema pieces the client builds decoders from.
+  type input = {
+    // Chain-scoped sequential registration index, echoed back on routed items.
+    index: int,
+    instructionName: string,
+    contractName: string,
+    programId: string,
+    isWildcard: bool,
+    discriminator?: string,
+    discriminatorByteLen: int,
+    isInner?: bool,
+    includeLogs: bool,
+    // DNF: outer array is OR of AND-groups.
+    accountFilters: array<array<accountFilter>>,
+    // camelCase Internal.svmTransactionField / svmBlockField names.
+    transactionFields: array<string>,
+    blockFields: array<string>,
+    // Borsh schema pieces; empty accounts + absent argsJson = no schema.
+    accounts: array<string>,
+    argsJson?: string,
+    definedTypesJson?: string,
+  }
+
+  let fromOnEventRegistrations = (
+    onEventRegistrations: array<Internal.svmOnEventRegistration>,
+  ): array<input> =>
+    onEventRegistrations->Array.map(reg => {
+      let eventConfig =
+        reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+      {
+        index: reg.index,
+        instructionName: eventConfig.name,
+        contractName: eventConfig.contractName,
+        programId: eventConfig.programId->SvmTypes.Pubkey.toString,
+        isWildcard: reg.isWildcard,
+        discriminator: ?eventConfig.discriminator,
+        discriminatorByteLen: eventConfig.discriminatorByteLen,
+        isInner: ?eventConfig.isInner,
+        includeLogs: eventConfig.includeLogs,
+        accountFilters: eventConfig.accountFilters->Array.map(group =>
+          group->Array.map(
+            (filter): accountFilter => {
+              position: filter.position,
+              values: filter.values->SvmTypes.Pubkey.toStrings,
+            },
+          )
+        ),
+        transactionFields: eventConfig.selectedTransactionFields->Utils.Set.toArray,
+        blockFields: eventConfig.selectedBlockFields
+        ->(Utils.magic: Utils.Set.t<Internal.svmBlockField> => Utils.Set.t<string>)
+        ->Utils.Set.toArray,
+        accounts: eventConfig.accounts,
+        argsJson: ?switch eventConfig.args {
+        | JSON.Null => None
+        | args => Some(args->JSON.stringify)
+        },
+        definedTypesJson: ?switch eventConfig.definedTypes {
+        | JSON.Null => None
+        | definedTypes => Some(definedTypes->JSON.stringify)
+        },
+      }
+    })
 }
 
 module QueryTypes = {
@@ -37,54 +105,7 @@ module QueryTypes = {
     | @as("loaded_addresses_writable") LoadedAddressesWritable
     | @as("loaded_addresses_readonly") LoadedAddressesReadonly
 
-  type instructionField =
-    | @as("slot") Slot
-    | @as("transaction_index") TransactionIndex
-    | @as("instruction_address") InstructionAddress
-    | @as("program_id") ProgramId
-    | @as("accounts") Accounts
-    | @as("data") Data
-    | @as("d1") D1
-    | @as("d2") D2
-    | @as("d4") D4
-    | @as("d8") D8
-    | @as("a0") A0
-    | @as("a1") A1
-    | @as("a2") A2
-    | @as("a3") A3
-    | @as("a4") A4
-    | @as("a5") A5
-    | @as("a6") A6
-    | @as("a7") A7
-    | @as("a8") A8
-    | @as("a9") A9
-    | @as("is_inner") IsInner
-    | @as("is_committed") IsCommitted
-
-  type logField =
-    | @as("slot") Slot
-    | @as("transaction_index") TransactionIndex
-    | @as("instruction_address") InstructionAddress
-    | @as("program_id") ProgramId
-    | @as("kind") Kind
-    | @as("message") Message
-
-  type tokenBalanceField =
-    | @as("slot") Slot
-    | @as("transaction_index") TransactionIndex
-    | @as("account") Account
-    | @as("mint") Mint
-    | @as("owner") Owner
-    | @as("pre_amount") PreAmount
-    | @as("post_amount") PostAmount
-
-  type fieldSelection = {
-    block?: array<blockField>,
-    transaction?: array<transactionField>,
-    instruction?: array<instructionField>,
-    log?: array<logField>,
-    tokenBalance?: array<tokenBalanceField>,
-  }
+  type fieldSelection = {block?: array<blockField>, transaction?: array<transactionField>}
 
   /** Filter for selecting instructions. All non-empty fields are AND-ed: an
    instruction must match at least one value in every non-empty field.
@@ -97,43 +118,19 @@ module QueryTypes = {
     d2?: array<string>,
     d4?: array<string>,
     d8?: array<string>,
-    a0?: array<string>,
-    a1?: array<string>,
-    a2?: array<string>,
-    a3?: array<string>,
-    a4?: array<string>,
-    a5?: array<string>,
-    a6?: array<string>,
-    a7?: array<string>,
-    a8?: array<string>,
-    a9?: array<string>,
     isInner?: bool,
   }
 
-  type transactionSelection = {
-    feePayer?: array<string>,
-    success?: bool,
-  }
-
-  type logSelection = {
-    programId?: array<string>,
-    kind?: array<string>,
-  }
-
+  // The `get` query surface, used only for block-data range queries; event
+  // fetching goes through `getEventItems`, which builds its query in Rust.
   type query = {
     fromSlot: int,
     toSlot?: int,
     instructions?: array<instructionSelection>,
-    transactions?: array<transactionSelection>,
-    logs?: array<logSelection>,
     includeAllBlocks?: bool,
-    includeTokenBalances?: bool,
     fields?: fieldSelection,
     maxNumBlocks?: int,
-    maxNumTransactions?: int,
     maxNumInstructions?: int,
-    maxNumLogs?: int,
-    maxNumTokenBalances?: int,
   }
 }
 
@@ -148,13 +145,6 @@ module ResponseTypes = {
 
   /// Borsh-decoded view attached by the Rust client. `argsJson`/`accountsJson`
   /// are stringified to side-step napi-rs's lack of native JSON passthrough.
-  /** Solana instruction record.
-
-   `data` is the raw instruction byte buffer, hex-encoded with a `0x` prefix.
-   `d1`..`d8` are the same byte prefix as `data` but truncated to N bytes
-   (only `Some` when the instruction is at least that long), exposed for
-   handler-dispatch convenience.
-   `accounts` is the full positional account list in base58. */
   type decodedInstruction = {
     name: string,
     argsJson: string,
@@ -175,22 +165,11 @@ module ResponseTypes = {
     d8?: string,
     isInner: bool,
     isCommitted: bool,
-    decoded?: decodedInstruction,
-  }
-
-  type log = {
-    slot: int,
-    transactionIndex?: int,
-    instructionAddress?: array<int>,
-    programId?: string,
-    kind?: string,
-    message?: string,
   }
 
   type queryResponseData = {
     blocks: array<block>,
     instructions: array<instruction>,
-    logs: array<log>,
   }
 
   type queryResponse = {
@@ -200,18 +179,76 @@ module ResponseTypes = {
   }
 }
 
+module EventItems = {
+  // The whole per-query input: slot range, the partition's registration
+  // selection (by index), and its current addresses (program ids per program
+  // name). Instruction selections, field selection, and routing are derived
+  // on the Rust side.
+  type query = {
+    fromSlot: int,
+    // Inclusive; None queries to the end of available data.
+    toSlot: option<int>,
+    maxNumInstructions: int,
+    registrationIndexes: array<int>,
+    addressesByContractName: dict<array<Address.t>>,
+  }
+
+  type log = {
+    kind: string,
+    message: string,
+  }
+
+  // One routed instruction; `block` and `transaction` are materialised from
+  // the per-chain stores at batch prep.
+  type item = {
+    onEventRegistrationIndex: int,
+    slot: int,
+    transactionIndex: int,
+    instructionAddress: array<int>,
+    programId: string,
+    accounts: array<string>,
+    data: string,
+    d1?: string,
+    d2?: string,
+    d4?: string,
+    d8?: string,
+    isInner: bool,
+    decoded?: ResponseTypes.decodedInstruction,
+    // Present only when the routed registration opted in via `includeLogs`.
+    logs?: array<log>,
+  }
+
+  type response = {
+    nextSlot: int,
+    // One lean header per slot referenced by `items`; the full blocks live in
+    // the block store returned alongside.
+    blocks: array<ResponseTypes.block>,
+    items: array<item>,
+  }
+}
+
 type query = QueryTypes.query
 type queryResponse = ResponseTypes.queryResponse
 
 type t = {
   getHeight: unit => promise<int>,
-  // Returns the response plus pages of raw transactions and blocks (kept in
-  // Rust), keyed by (slot, transactionIndex) / slot, materialised at batch prep.
+  // Block-data range queries only; the store pages it returns are empty.
   get: (~query: query) => promise<(queryResponse, TransactionStore.t, BlockStore.t)>,
+  // Returns the routed items plus pages of raw transactions and blocks (kept
+  // in Rust), keyed by (slot, transactionIndex) / slot, materialised at batch
+  // prep.
+  getEventItems: (
+    ~query: EventItems.query,
+  ) => promise<(EventItems.response, TransactionStore.t, BlockStore.t)>,
 }
 
 @send
-external classFromConfig: (Core.svmHypersyncClientCtor, cfg, string) => t = "fromConfig"
+external classFromConfig: (
+  Core.svmHyperSyncClientCtor,
+  cfg,
+  string,
+  array<Registration.input>,
+) => t = "fromConfig"
 
 let make = (
   ~url,
@@ -220,10 +257,10 @@ let make = (
   ~maxNumRetries=?,
   ~retryBaseMs=?,
   ~retryCeilingMs=?,
-  ~programSchemas=?,
+  ~eventRegistrations=[],
 ) => {
   let envioVersion = Utils.EnvioPackage.value.version
-  Core.getAddon().svmHypersyncClient->classFromConfig(
+  Core.getAddon().svmHyperSyncClient->classFromConfig(
     {
       url,
       ?apiToken,
@@ -231,8 +268,8 @@ let make = (
       ?maxNumRetries,
       ?retryBaseMs,
       ?retryCeilingMs,
-      ?programSchemas,
     },
     `hyperindex/${envioVersion}`,
+    eventRegistrations,
   )
 }

package/src/sources/SvmHyperSyncClient.res.mjs

@@ -3,26 +3,66 @@
 import * as Core from "../Core.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 
+function fromOnEventRegistrations(onEventRegistrations) {
+  return onEventRegistrations.map(reg => {
+    let eventConfig = reg.eventConfig;
+    let args = eventConfig.args;
+    let tmp;
+    tmp = args === null ? undefined : JSON.stringify(args);
+    let definedTypes = eventConfig.definedTypes;
+    let tmp$1;
+    tmp$1 = definedTypes === null ? undefined : JSON.stringify(definedTypes);
+    return {
+      index: reg.index,
+      instructionName: eventConfig.name,
+      contractName: eventConfig.contractName,
+      programId: eventConfig.programId,
+      isWildcard: reg.isWildcard,
+      discriminator: eventConfig.discriminator,
+      discriminatorByteLen: eventConfig.discriminatorByteLen,
+      isInner: eventConfig.isInner,
+      includeLogs: eventConfig.includeLogs,
+      accountFilters: eventConfig.accountFilters.map(group => group.map(filter => ({
+        position: filter.position,
+        values: filter.values
+      }))),
+      transactionFields: Array.from(eventConfig.selectedTransactionFields),
+      blockFields: Array.from(eventConfig.selectedBlockFields),
+      accounts: eventConfig.accounts,
+      argsJson: tmp,
+      definedTypesJson: tmp$1
+    };
+  });
+}
+
+let Registration = {
+  fromOnEventRegistrations: fromOnEventRegistrations
+};
+
 let QueryTypes = {};
 
 let ResponseTypes = {};
 
-function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, retryBaseMs, retryCeilingMs, programSchemas) {
+let EventItems = {};
+
+function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, retryBaseMs, retryCeilingMs, eventRegistrationsOpt) {
+  let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
   let envioVersion = Utils.EnvioPackage.value.version;
-  return Core.getAddon().SvmHypersyncClient.fromConfig({
+  return Core.getAddon().SvmHyperSyncClient.fromConfig({
     url: url,
     apiToken: apiToken,
     httpReqTimeoutMillis: httpReqTimeoutMillis,
     maxNumRetries: maxNumRetries,
     retryBaseMs: retryBaseMs,
-    retryCeilingMs: retryCeilingMs,
-    programSchemas: programSchemas
-  }, `hyperindex/` + envioVersion);
+    retryCeilingMs: retryCeilingMs
+  }, `hyperindex/` + envioVersion, eventRegistrations);
 }
 
 export {
+  Registration,
   QueryTypes,
   ResponseTypes,
+  EventItems,
   make,
 }
 /* Core Not a pure module */