envio 3.9.0 → 3.10.0

package/src/sources/SvmHyperSyncClient.res

@@ -14,19 +14,14 @@ module Registration = {
     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.
+  // One `onInstruction`/`contractRegister` binding of an instruction on a
+  // chain: the handler-specific routing state and the fetch state queries are
+  // built from. Chain-scoped `index` is echoed back on routed items.
   type input = {
-    // Chain-scoped sequential registration index, echoed back on routed items.
     index: int,
-    instructionName: string,
-    contractName: string,
-    programId: string,
     isWildcard: bool,
     // Earliest slot this registration accepts; `None` is unrestricted.
     startBlock: option<int>,
-    discriminator?: string,
     isInner?: bool,
     // DNF: outer array is OR of AND-groups.
     accountFilters: array<array<accountFilter>>,
@@ -36,28 +31,73 @@ module Registration = {
     accountActivityFields: array<string>,
     logFields: array<string>,
     instructionFields: array<string>,
-    // Borsh schema pieces; empty accounts + absent argsJson = no schema.
-    accounts: array<string>,
+  }
+
+  // One config instruction: its identity (data prefix of any length; absent
+  // matches every instruction of the program) and Borsh layout, shared by
+  // every registration bound to it.
+  type instruction = {
+    name: string,
+    discriminator?: string,
     argsJson?: string,
+    registrations: array<input>,
+  }
+
+  type program = {
+    // The config's program name.
+    name: string,
+    programId: string,
     definedTypesJson?: string,
+    instructions: array<instruction>,
   }
 
+  // Groups a chain's registrations under the config instruction each was
+  // built from, so the Rust client holds one layout per instruction rather
+  // than a copy per registration.
   let fromOnEventRegistrations = (
     onEventRegistrations: array<Internal.svmOnEventRegistration>,
-  ): array<input> =>
-    onEventRegistrations->Array.map(reg => {
+  ): array<program> => {
+    let programs: array<program> = []
+    onEventRegistrations->Array.forEach(reg => {
       let eventConfig =
         reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
-      {
+      let program = switch programs->Array.find(p => p.name === eventConfig.contractName) {
+      | Some(program) => program
+      | None =>
+        let program = {
+          name: eventConfig.contractName,
+          programId: eventConfig.programId->SvmTypes.Pubkey.toString,
+          definedTypesJson: ?switch eventConfig.definedTypes {
+          | JSON.Null => None
+          | definedTypes => Some(definedTypes->JSON.stringify)
+          },
+          instructions: [],
+        }
+        programs->Array.push(program)->ignore
+        program
+      }
+      let instruction = switch program.instructions->Array.find(i => i.name === eventConfig.name) {
+      | Some(instruction) => instruction
+      | None =>
+        let instruction = {
+          name: eventConfig.name,
+          discriminator: ?eventConfig.discriminator,
+          argsJson: ?switch eventConfig.args {
+          | JSON.Null => None
+          | args => Some(args->JSON.stringify)
+          },
+          registrations: [],
+        }
+        program.instructions->Array.push(instruction)->ignore
+        instruction
+      }
+      instruction.registrations
+      ->Array.push({
         index: reg.index,
-        instructionName: eventConfig.name,
-        contractName: eventConfig.contractName,
-        programId: eventConfig.programId->SvmTypes.Pubkey.toString,
         isWildcard: reg.isWildcard,
         startBlock: reg.startBlock,
-        discriminator: ?eventConfig.discriminator,
-        isInner: ?eventConfig.isInner,
-        accountFilters: eventConfig.accountFilters->Array.map(group =>
+        isInner: ?reg.isInner,
+        accountFilters: reg.accountFilters->Array.map(group =>
           group->Array.map(
             (filter): accountFilter => {
               position: filter.position,
@@ -70,71 +110,10 @@ module Registration = {
         accountActivityFields: reg.fieldSelection.accountActivityFields->Utils.Set.toArray,
         logFields: reg.fieldSelection.logFields->Utils.Set.toArray,
         instructionFields: reg.fieldSelection.instructionFields->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)
-        },
-      }
+      })
+      ->ignore
     })
-}
-
-module QueryTypes = {
-  type blockField =
-    | @as("slot") Slot
-    | @as("blockhash") Blockhash
-    | @as("parent_slot") ParentSlot
-    | @as("parent_blockhash") ParentBlockhash
-    | @as("block_time") BlockTime
-    | @as("block_height") BlockHeight
-
-  type transactionField =
-    | @as("slot") Slot
-    | @as("transaction_index") TransactionIndex
-    | @as("signatures") Signatures
-    | @as("fee_payer") FeePayer
-    | @as("success") Success
-    | @as("err") Err
-    | @as("fee") Fee
-    | @as("compute_units_consumed") ComputeUnitsConsumed
-    | @as("account_keys") AccountKeys
-    | @as("recent_blockhash") RecentBlockhash
-    | @as("version") Version
-    | @as("loaded_addresses_writable") LoadedAddressesWritable
-    | @as("loaded_addresses_readonly") LoadedAddressesReadonly
-
-  type fieldSelection = {block?: array<blockField>, transaction?: array<transactionField>}
-
-  /** Filter for selecting instruction calls. All non-empty fields are AND-ed:
-   an instruction must match at least one value in every non-empty field.
-
-   Discriminator filters (d1..d8) take hex-encoded byte prefixes ("0x" optional).
-   Account filters (a0..a9) take base58 pubkey strings. */
-  type instructionSelection = {
-    executingAccount?: array<string>,
-    d1?: array<string>,
-    d2?: array<string>,
-    d4?: array<string>,
-    d8?: array<string>,
-    isInner?: bool,
-    /** Success of the parent transaction; absent matches both. */
-    txSuccess?: bool,
-  }
-
-  // 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,
-    instructionCalls?: array<instructionSelection>,
-    includeAllBlocks?: bool,
-    fields?: fieldSelection,
-    maxNumBlocks?: int,
-    maxNumInstructions?: int,
+    programs
   }
 }
 
@@ -146,37 +125,6 @@ module ResponseTypes = {
     blockhash: string,
     blockTime: Null.t<int>,
   }
-
-  type instructionCall = {
-    slot: int,
-    transactionIndex: int,
-    instructionAddress: array<int>,
-    /** The invoked program's account. */
-    executingAccount: string,
-    accountArguments: array<string>,
-    data: string,
-    d1: Null.t<string>,
-    d2: Null.t<string>,
-    d4: Null.t<string>,
-    d8: Null.t<string>,
-    isInner: bool,
-    /** Success of the parent transaction, not of this invocation. */
-    txSuccess: bool,
-    /** Per-invocation failure reason (e.g. "custom program error: 0x1"). */
-    error: Null.t<string>,
-    computeUnitsConsumed: Null.t<bigint>,
-  }
-
-  type queryResponseData = {
-    blocks: array<block>,
-    instructionCalls: array<instructionCall>,
-  }
-
-  type queryResponse = {
-    nextSlot: int,
-    responseBytes: int,
-    data: queryResponseData,
-  }
 }
 
 module EventItems = {
@@ -213,12 +161,12 @@ module EventItems = {
     path: array<int>,
     programId: string,
     accounts: array<string>,
-    data: string,
+    data: Uint8Array.t,
     isInner: bool,
-    // Borsh-decoded args as a JSON object literal, `{}` when the routed
-    // registration reads no args. An instruction the schema rejects is dropped
-    // in Rust, so a selected `args` is always decoded.
-    argsJson: string,
+    // Borsh-decoded args as a JS value tree (wide integers as bigint).
+    // Non-null exactly when the routed registration selected `args`: an
+    // instruction its layout rejects is dropped in Rust.
+    args: Null.t<unknown>,
     // Non-null only when the routed registration selected `fields.log`.
     logs: Null.t<array<log>>,
   }
@@ -234,16 +182,11 @@ module EventItems = {
   }
 }
 
-type query = QueryTypes.query
-type queryResponse = ResponseTypes.queryResponse
-
 type t = {
   getHeight: unit => promise<int>,
   // Block-hash query construction, pagination, and cursor-backed skipped-slot
   // coverage live in Rust.
   getBlockHashes: (~blockNumbers: array<int>) => promise<(BlockStore.t, array<RequestStat.t>)>,
-  // 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.
@@ -258,7 +201,7 @@ external classFromConfig: (
   Core.svmHyperSyncClientCtor,
   cfg,
   string,
-  array<Registration.input>,
+  array<Registration.program>,
   AddressStore.t,
 ) => t = "fromConfig"
 
@@ -268,7 +211,7 @@ let make = (
   ~httpReqTimeoutMillis=?,
   ~retryBaseMs=?,
   ~retryCeilingMs=?,
-  ~eventRegistrations=[],
+  ~programs=[],
   ~addressStore,
 ) => {
   let envioVersion = Utils.EnvioPackage.value.version
@@ -281,7 +224,7 @@ let make = (
       ?retryCeilingMs,
     },
     `hyperindex/${envioVersion}`,
-    eventRegistrations,
+    programs,
     addressStore,
   )
 }

package/src/sources/SvmHyperSyncClient.res.mjs

@@ -4,24 +4,55 @@ import * as Core from "../Core.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 
 function fromOnEventRegistrations(onEventRegistrations) {
-  return onEventRegistrations.map(reg => {
+  let programs = [];
+  onEventRegistrations.forEach(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 {
+    let program = programs.find(p => p.name === eventConfig.contractName);
+    let program$1;
+    if (program !== undefined) {
+      program$1 = program;
+    } else {
+      let definedTypes = eventConfig.definedTypes;
+      let tmp;
+      tmp = definedTypes === null ? undefined : JSON.stringify(definedTypes);
+      let program_name = eventConfig.contractName;
+      let program_programId = eventConfig.programId;
+      let program_instructions = [];
+      let program$2 = {
+        name: program_name,
+        programId: program_programId,
+        definedTypesJson: tmp,
+        instructions: program_instructions
+      };
+      programs.push(program$2);
+      program$1 = program$2;
+    }
+    let instruction = program$1.instructions.find(i => i.name === eventConfig.name);
+    let instruction$1;
+    if (instruction !== undefined) {
+      instruction$1 = instruction;
+    } else {
+      let args = eventConfig.args;
+      let tmp$1;
+      tmp$1 = args === null ? undefined : JSON.stringify(args);
+      let instruction_name = eventConfig.name;
+      let instruction_discriminator = eventConfig.discriminator;
+      let instruction_registrations = [];
+      let instruction$2 = {
+        name: instruction_name,
+        discriminator: instruction_discriminator,
+        argsJson: tmp$1,
+        registrations: instruction_registrations
+      };
+      program$1.instructions.push(instruction$2);
+      instruction$1 = instruction$2;
+    }
+    instruction$1.registrations.push({
       index: reg.index,
-      instructionName: eventConfig.name,
-      contractName: eventConfig.contractName,
-      programId: eventConfig.programId,
       isWildcard: reg.isWildcard,
       startBlock: reg.startBlock,
-      discriminator: eventConfig.discriminator,
-      isInner: eventConfig.isInner,
-      accountFilters: eventConfig.accountFilters.map(group => group.map(filter => ({
+      isInner: reg.isInner,
+      accountFilters: reg.accountFilters.map(group => group.map(filter => ({
         position: filter.position,
         values: filter.values
       }))),
@@ -29,26 +60,22 @@ function fromOnEventRegistrations(onEventRegistrations) {
       blockFields: Array.from(reg.fieldSelection.blockFields),
       accountActivityFields: Array.from(reg.fieldSelection.accountActivityFields),
       logFields: Array.from(reg.fieldSelection.logFields),
-      instructionFields: Array.from(reg.fieldSelection.instructionFields),
-      accounts: eventConfig.accounts,
-      argsJson: tmp,
-      definedTypesJson: tmp$1
-    };
+      instructionFields: Array.from(reg.fieldSelection.instructionFields)
+    });
   });
+  return programs;
 }
 
 let Registration = {
   fromOnEventRegistrations: fromOnEventRegistrations
 };
 
-let QueryTypes = {};
-
 let ResponseTypes = {};
 
 let EventItems = {};
 
-function make(url, apiToken, httpReqTimeoutMillis, retryBaseMs, retryCeilingMs, eventRegistrationsOpt, addressStore) {
-  let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
+function make(url, apiToken, httpReqTimeoutMillis, retryBaseMs, retryCeilingMs, programsOpt, addressStore) {
+  let programs = programsOpt !== undefined ? programsOpt : [];
   let envioVersion = Utils.EnvioPackage.value.version;
   return Core.getAddon().SvmHyperSyncClient.fromConfig({
     url: url,
@@ -56,12 +83,11 @@ function make(url, apiToken, httpReqTimeoutMillis, retryBaseMs, retryCeilingMs,
     httpReqTimeoutMillis: httpReqTimeoutMillis,
     retryBaseMs: retryBaseMs,
     retryCeilingMs: retryCeilingMs
-  }, `hyperindex/` + envioVersion, eventRegistrations, addressStore);
+  }, `hyperindex/` + envioVersion, programs, addressStore);
 }
 
 export {
   Registration,
-  QueryTypes,
   ResponseTypes,
   EventItems,
   make,

package/src/sources/SvmHyperSyncSource.res

@@ -10,10 +10,9 @@ type options = {
   addressStore: AddressStore.t,
 }
 
-let namedAccounts = (
-  ~idlNames: array<string>,
-  ~accountArguments: array<string>,
-): dict<Envio.svmInstructionAccount> => {
+let namedAccounts = (~idlNames: array<string>, ~accountArguments: array<string>): dict<
+  Envio.svmInstructionAccount,
+> => {
   let out = Dict.make()
   idlNames->Array.forEachWithIndex((name, i) =>
     switch accountArguments->Array.get(i) {
@@ -32,7 +31,10 @@ let namedAccounts = (
   out
 }
 
-let selectedLog = (log: SvmHyperSyncClient.EventItems.log, ~logFields: Utils.Set.t<string>): Envio.svmLog => {
+let selectedLog = (
+  log: SvmHyperSyncClient.EventItems.log,
+  ~logFields: Utils.Set.t<string>,
+): Envio.svmLog => {
   let out = Dict.make()
   if logFields->Utils.Set.has("kind") {
     switch log.kind->Null.toOption {
@@ -63,9 +65,11 @@ let toSvmInstruction = (
   ~fieldSelection: Internal.fieldSelection,
 ): Envio.svmInstruction => {
   let hasSelection = name => fieldSelection.instructionFields->Utils.Set.has(name)
+  // A program-wide registration has no configured discriminator, so the whole
+  // data stands in, hex-encoded like a configured one would be.
   let discriminator = switch eventConfig.discriminator {
   | Some(d) => d
-  | None => item.data
+  | None => "0x" ++ item.data->NodeJs.Buffer.fromUint8Array->NodeJs.Buffer.toHex
   }
   let out = Dict.make()
   out->setField("programName", programName)
@@ -83,8 +87,9 @@ let toSvmInstruction = (
   if hasSelection("isInner") {
     out->setField("isInner", item.isInner)
   }
-  if hasSelection("args") {
-    out->setField("args", item.argsJson->JSON.parseOrThrow)
+  switch item.args->Null.toOption {
+  | Some(args) => out->setField("args", args)
+  | None => ()
   }
   if hasSelection("accounts") {
     out->setField(
@@ -125,9 +130,7 @@ let make = (
     ~url=endpointUrl,
     ~apiToken?,
     ~httpReqTimeoutMillis=clientTimeoutMillis,
-    ~eventRegistrations=SvmHyperSyncClient.Registration.fromOnEventRegistrations(
-      onEventRegistrations,
-    ),
+    ~programs=SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations),
     ~addressStore,
   )
 
@@ -198,7 +201,7 @@ let make = (
         ~fieldSelection=onEventRegistration.fieldSelection,
       )
       Internal.Event({
-        onEventRegistration,
+        onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
         chainId,
         blockNumber: item.slot,
         // A slot orders by `(transactionIndex, path)` — the
@@ -236,15 +239,15 @@ let make = (
 
   // Called through the client rather than passed as a value: the client is a
   // napi class, so a detached method reference loses the instance it belongs to.
-  let getBlockHashes = HyperSync.makeGetBlockHashes(
-    ~query=(~blockNumbers) => client.getBlockHashes(~blockNumbers),
+  let getBlockHashes = HyperSync.makeGetBlockHashes(~query=(~blockNumbers) =>
+    client.getBlockHashes(~blockNumbers)
   )
 
   {
     name,
     sourceFor: Sync,
     chainId,
-    pollingInterval: 1000,
+    pollingInterval: HyperSync.pollingInterval,
     poweredByHyperSync: true,
     getBlockHashes,
     getHeightOrThrow: async () => {

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -48,7 +48,7 @@ function setField(out, name, value) {
 
 function toSvmInstruction(item, programName, instructionName, eventConfig, fieldSelection) {
   let d = eventConfig.discriminator;
-  let discriminator = d !== undefined ? d : item.data;
+  let discriminator = d !== undefined ? d : "0x" + Buffer.from(item.data).toString("hex");
   let out = {};
   setField(out, "programName", programName);
   setField(out, "instructionName", instructionName);
@@ -65,8 +65,9 @@ function toSvmInstruction(item, programName, instructionName, eventConfig, field
   if (fieldSelection.instructionFields.has("isInner")) {
     setField(out, "isInner", item.isInner);
   }
-  if (fieldSelection.instructionFields.has("args")) {
-    setField(out, "args", JSON.parse(item.argsJson));
+  let args = item.args;
+  if (args !== null) {
+    setField(out, "args", args);
   }
   if (fieldSelection.instructionFields.has("accounts")) {
     setField(out, "accounts", namedAccounts(eventConfig.accounts, item.accounts));
@@ -163,7 +164,7 @@ function make(param) {
     sourceFor: "Sync",
     chainId: chainId,
     poweredByHyperSync: true,
-    pollingInterval: 1000,
+    pollingInterval: HyperSync.pollingInterval,
     getBlockHashes: getBlockHashes,
     getHeightOrThrow: async () => {
       let timer = Performance.now();

package/svm.schema.json

@@ -381,30 +381,12 @@
           "type": "string"
         },
         "discriminator": {
-          "description": "Hex-encoded instruction-data prefix used as the discriminator (\"0x\" optional). Must be 1, 2, 4, or 8 bytes after decoding. An 8-byte value matches the standard Anchor discriminator.",
+          "description": "Hex-encoded instruction-data prefix used as the discriminator (\"0x\" optional), of any whole number of bytes; an 8-byte value matches the standard Anchor discriminator. Omit it to match every instruction of the program. Every instruction whose prefix an on-chain call carries receives it, so a program-wide entry fires alongside a keyed one, and two entries may share a prefix (say, the layouts before and after a program upgrade): each decodes with its own `args`, and one whose layout rejects the data is skipped for that call.",
           "type": [
             "string",
             "null"
           ]
         },
-        "is_inner": {
-          "description": "Filter on inner-vs-outer instructions. None / absent matches both.",
-          "type": [
-            "boolean",
-            "null"
-          ]
-        },
-        "account_filters": {
-          "description": "Optional positional account filters. Two shapes are accepted: a flat list of `{position, values}` entries (AND across positions, OR within `values`); or `{any_of: [[...]] }`, a list of AND-groups that are OR-ed together. Positions must be in 0..=5; positions 6..=9 are reserved for a future extension.",
-          "anyOf": [
-            {
-              "$ref": "#/$defs/AccountFilters"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
         "accounts": {
           "description": "Optional positional account names. The Nth entry names account slot N on the dispatched instruction; surfaces as `instruction.accounts.<name>` when `fields.instruction` includes `accounts`.",
           "type": [
@@ -431,62 +413,6 @@
         "name"
       ]
     },
-    "AccountFilters": {
-      "anyOf": [
-        {
-          "type": "array",
-          "items": {
-            "$ref": "#/$defs/AccountFilter"
-          }
-        },
-        {
-          "$ref": "#/$defs/AnyOfAccountFilters"
-        }
-      ]
-    },
-    "AccountFilter": {
-      "type": "object",
-      "properties": {
-        "position": {
-          "description": "Account position within the instruction (0..=5).",
-          "type": "integer",
-          "format": "uint8",
-          "minimum": 0,
-          "maximum": 255
-        },
-        "values": {
-          "description": "Allowed base58 pubkeys for this account position.",
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      },
-      "additionalProperties": false,
-      "required": [
-        "position",
-        "values"
-      ]
-    },
-    "AnyOfAccountFilters": {
-      "type": "object",
-      "properties": {
-        "any_of": {
-          "description": "A non-empty list of AND-groups. Each group is itself a non-empty list of `{position, values}` entries that must all match the same instruction. An instruction matches `any_of` when any one group matches.",
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "$ref": "#/$defs/AccountFilter"
-            }
-          }
-        }
-      },
-      "additionalProperties": false,
-      "required": [
-        "any_of"
-      ]
-    },
     "ArgDef": {
       "description": "One named argument of an instruction. Mirrors\n`hypersync_client_solana::decode::NamedField`.",
       "type": "object",