envio 3.7.0-svm-alpha.1 → 3.8.0

package/src/sources/SvmHyperSyncSource.res

@@ -10,50 +10,105 @@ type options = {
   addressStore: AddressStore.t,
 }
 
-// Parse the Rust-decoded instruction (args/accounts arrive as JSON strings to
-// side-step napi-rs's lack of native JSON passthrough) into the public shape.
-let parseDecoded = (
-  d: SvmHyperSyncClient.ResponseTypes.decodedInstruction,
-): Envio.svmInstructionParams => {
-  let args = try JSON.parseOrThrow(d.argsJson) catch {
+let parseArgs = (d: SvmHyperSyncClient.ResponseTypes.decodedInstruction): JSON.t =>
+  try JSON.parseOrThrow(d.argsJson) catch {
   | _ => JSON.Object(Dict.make())
   }
-  let accounts = try {
-    JSON.parseOrThrow(d.accountsJson)->(Utils.magic: JSON.t => dict<string>)
-  } catch {
-  | _ => Dict.make()
+
+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) {
+    | Some(address) =>
+      out->Dict.set(
+        name,
+        {
+          Envio.address: address->SvmTypes.Pubkey.fromStringUnsafe,
+          accountName: name,
+          instructionAccountIndex: i,
+        },
+      )
+    | None => ()
+    }
+  )
+  out
+}
+
+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 {
+    | Some(kind) => out->Dict.set("kind", kind)
+    | None => ()
+    }
   }
-  {
-    name: d.name,
-    args,
-    accounts,
-    extraAccounts: d.extraAccounts,
+  if logFields->Utils.Set.has("message") {
+    switch log.message {
+    | Some(message) => out->Dict.set("message", message)
+    | None => ()
+    }
   }
+  out->(Utils.magic: dict<string> => Envio.svmLog)
 }
 
-// `block` is omitted; it's materialised from the block store at batch prep.
+let setField = (out: dict<unknown>, name: string, value: 'a) =>
+  out->Dict.set(name, value->(Utils.magic: 'a => unknown))
+
+// `block` and `transaction` are omitted; they're materialised from the stores
+// at batch prep. Named-account `.activity` is attached then too.
+// Unselected instruction keys must be omitted, not assigned `undefined`.
 let toSvmInstruction = (
   item: SvmHyperSyncClient.EventItems.item,
   ~programName,
   ~instructionName,
+  ~eventConfig: Internal.svmInstructionEventConfig,
+  ~fieldSelection: Internal.fieldSelection,
 ): Envio.svmInstruction => {
-  programName,
-  instructionName,
-  programId: item.programId->SvmTypes.Pubkey.fromStringUnsafe,
-  data: item.data,
-  accounts: item.accounts->SvmTypes.Pubkey.fromStringsUnsafe,
-  instructionAddress: item.instructionAddress,
-  isInner: item.isInner,
-  d1: ?item.d1,
-  d2: ?item.d2,
-  d4: ?item.d4,
-  d8: ?item.d8,
-  params: ?(item.decoded->Option.map(parseDecoded)),
-  logs: ?(
-    item.logs->Option.map(logs =>
-      logs->Array.map((log): Envio.svmLog => {kind: log.kind, message: log.message})
+  let hasSelection = name => fieldSelection.instructionFields->Utils.Set.has(name)
+  let discriminator = switch eventConfig.discriminator {
+  | Some(d) => d
+  | None => item.data
+  }
+  let out = Dict.make()
+  out->setField("programName", programName)
+  out->setField("instructionName", instructionName)
+  out->setField("discriminator", discriminator)
+  if hasSelection("programId") {
+    out->setField("programId", item.programId->SvmTypes.Pubkey.fromStringUnsafe)
+  }
+  if hasSelection("data") {
+    out->setField("data", item.data)
+  }
+  if hasSelection("path") {
+    out->setField("path", item.path)
+  }
+  if hasSelection("isInner") {
+    out->setField("isInner", item.isInner)
+  }
+  if hasSelection("args") {
+    out->setField("args", item.decoded->Option.map(parseArgs))
+  }
+  if hasSelection("accounts") {
+    out->setField(
+      "accounts",
+      namedAccounts(~idlNames=eventConfig.accounts, ~accountArguments=item.accounts),
     )
-  ),
+  }
+  if hasSelection("accountArguments") {
+    out->setField("accountArguments", item.accounts->SvmTypes.Pubkey.fromStringsUnsafe)
+  }
+  if fieldSelection.logFields->Utils.Set.size > 0 {
+    out->setField(
+      "logs",
+      item.logs
+      ->Option.getOr([])
+      ->Array.map(log => selectedLog(log, ~logFields=fieldSelection.logFields)),
+    )
+  }
+  out->(Utils.magic: dict<unknown> => Envio.svmInstruction)
 }
 
 let make = (
@@ -144,18 +199,20 @@ let make = (
         item,
         ~programName=eventConfig.contractName,
         ~instructionName=eventConfig.name,
+        ~eventConfig,
+        ~fieldSelection=onEventRegistration.fieldSelection,
       )
       Internal.Event({
         onEventRegistration,
         chainId,
         blockNumber: item.slot,
-        // A slot orders by `(transactionIndex, instructionAddress)` — the
+        // A slot orders by `(transactionIndex, path)` — the
         // transaction, then the instruction's position in its CPI tree. Both
         // ride the item so the buffer comparator can order on the pair
         // directly; no single integer can hold it (Solana allows a CPI depth
         // of 5, which needs more bits than a JS integer is exact to).
         logIndex: item.transactionIndex,
-        orderPath: item.instructionAddress,
+        orderPath: item.path,
         // The parent transaction is materialised from the store at batch prep.
         transactionIndex: item.transactionIndex,
         payload: payload->(Utils.magic: Envio.svmInstruction => Internal.eventPayload),
@@ -182,7 +239,11 @@ let make = (
     }
   }
 
-  let getBlockHashes = HyperSync.makeGetBlockHashes(~query=client.getBlockHashes)
+  // 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),
+  )
 
   {
     name,

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -8,46 +8,83 @@ 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 parseDecoded(d) {
-  let args;
+function parseArgs(d) {
   try {
-    args = JSON.parse(d.argsJson);
+    return JSON.parse(d.argsJson);
   } catch (exn) {
-    args = {};
+    return {};
   }
-  let accounts;
-  try {
-    accounts = JSON.parse(d.accountsJson);
-  } catch (exn$1) {
-    accounts = {};
+}
+
+function namedAccounts(idlNames, accountArguments) {
+  let out = {};
+  idlNames.forEach((name, i) => {
+    let address = accountArguments[i];
+    if (address !== undefined) {
+      out[name] = {
+        address: address,
+        accountName: name,
+        instructionAccountIndex: i
+      };
+      return;
+    }
+  });
+  return out;
+}
+
+function selectedLog(log, logFields) {
+  let out = {};
+  if (logFields.has("kind")) {
+    let kind = log.kind;
+    if (kind !== undefined) {
+      out["kind"] = kind;
+    }
   }
-  return {
-    name: d.name,
-    args: args,
-    accounts: accounts,
-    extraAccounts: d.extraAccounts
-  };
+  if (logFields.has("message")) {
+    let message = log.message;
+    if (message !== undefined) {
+      out["message"] = message;
+    }
+  }
+  return out;
 }
 
-function toSvmInstruction(item, programName, instructionName) {
-  return {
-    programName: programName,
-    instructionName: instructionName,
-    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 setField(out, name, value) {
+  out[name] = value;
+}
+
+function toSvmInstruction(item, programName, instructionName, eventConfig, fieldSelection) {
+  let d = eventConfig.discriminator;
+  let discriminator = d !== undefined ? d : item.data;
+  let out = {};
+  setField(out, "programName", programName);
+  setField(out, "instructionName", instructionName);
+  setField(out, "discriminator", discriminator);
+  if (fieldSelection.instructionFields.has("programId")) {
+    setField(out, "programId", item.programId);
+  }
+  if (fieldSelection.instructionFields.has("data")) {
+    setField(out, "data", item.data);
+  }
+  if (fieldSelection.instructionFields.has("path")) {
+    setField(out, "path", item.path);
+  }
+  if (fieldSelection.instructionFields.has("isInner")) {
+    setField(out, "isInner", item.isInner);
+  }
+  if (fieldSelection.instructionFields.has("args")) {
+    setField(out, "args", Stdlib_Option.map(item.decoded, parseArgs));
+  }
+  if (fieldSelection.instructionFields.has("accounts")) {
+    setField(out, "accounts", namedAccounts(eventConfig.accounts, item.accounts));
+  }
+  if (fieldSelection.instructionFields.has("accountArguments")) {
+    setField(out, "accountArguments", item.accounts);
+  }
+  if (fieldSelection.logFields.size > 0) {
+    setField(out, "logs", Stdlib_Option.getOr(item.logs, []).map(log => selectedLog(log, fieldSelection.logFields)));
+  }
+  return out;
 }
 
 function make(param) {
@@ -97,14 +134,14 @@ function make(param) {
     let parsedQueueItems = resp.items.map(item => {
       let onEventRegistration = onEventRegistrations[item.onEventRegistrationIndex];
       let eventConfig = onEventRegistration.eventConfig;
-      let payload = toSvmInstruction(item, eventConfig.contractName, eventConfig.name);
+      let payload = toSvmInstruction(item, eventConfig.contractName, eventConfig.name, eventConfig, onEventRegistration.fieldSelection);
       return {
         kind: 0,
         onEventRegistration: onEventRegistration,
         chainId: chainId,
         blockNumber: item.slot,
         logIndex: item.transactionIndex,
-        orderPath: item.instructionAddress,
+        orderPath: item.path,
         transactionIndex: item.transactionIndex,
         payload: payload
       };
@@ -127,7 +164,7 @@ function make(param) {
       requestStats: requestStats
     };
   };
-  let getBlockHashes = HyperSync.makeGetBlockHashes(client.getBlockHashes);
+  let getBlockHashes = HyperSync.makeGetBlockHashes(blockNumbers => client.getBlockHashes(blockNumbers));
   return {
     name: "SvmHyperSync",
     sourceFor: "Sync",
@@ -152,7 +189,10 @@ function make(param) {
 }
 
 export {
-  parseDecoded,
+  parseArgs,
+  namedAccounts,
+  selectedLog,
+  setField,
   toSvmInstruction,
   make,
 }

package/src/sources/TransactionStore.res

@@ -31,6 +31,44 @@ let fieldCodes = FieldMask.fieldCodes
 // Drain another store (a fetch-response page) into this one.
 @send external merge: (t, t) => unit = "merge"
 
+type svmTxInput = {
+  slot: int,
+  transactionIndex: int,
+  signature?: string,
+  allSignatures?: array<string>,
+  feePayer?: string,
+  success?: bool,
+  err?: string,
+  fee?: bigint,
+  computeUnitsConsumed?: bigint,
+  accountKeys?: array<string>,
+  recentBlockhash?: string,
+  version?: string,
+}
+
+type svmActivityInput = {
+  slot: int,
+  transactionIndex: int,
+  account: string,
+  accountIndex?: int,
+  isSigner?: bool,
+  isWritable?: bool,
+  preBalance?: bigint,
+  postBalance?: bigint,
+  mint?: string,
+  owner?: string,
+  decimals?: int,
+  preAmount?: bigint,
+  postAmount?: bigint,
+}
+
+@send
+external fromJsSvm: (Core.transactionStoreCtor, array<svmTxInput>, array<svmActivityInput>) => t =
+  "fromJsSvm"
+
+let fromSvmJs = (transactions: array<svmTxInput>, activities: array<svmActivityInput>): t =>
+  Core.getAddon().transactionStore->fromJsSvm(transactions, activities)
+
 // Bulk-materialise transactions off the JS thread, one row per
 // (blockNumbers[i], transactionIndices[i]) key, decoding only the fields set in
 // that row's own masks[i]. Result is aligned with the input.

package/src/sources/TransactionStore.res.mjs

@@ -15,6 +15,10 @@ function make(ecosystem, shouldChecksum) {
   }
 }
 
+function fromSvmJs(transactions, activities) {
+  return Core.getAddon().TransactionStore.fromJsSvm(transactions, activities);
+}
+
 let makeMaskFn = FieldMask.makeMaskFn;
 
 let orMask = FieldMask.orMask;
@@ -26,5 +30,6 @@ export {
   makeMaskFn,
   orMask,
   fieldCodes,
+  fromSvmJs,
 }
 /* Core Not a pure module */

package/svm.schema.json

@@ -212,6 +212,10 @@
     "Chain": {
       "type": "object",
       "properties": {
+        "id": {
+          "description": "Identifies the Svm cluster: the label \"solana\" (7565164) or \"solana-devnet\" (7565165), or an explicit number of your choosing for other clusters (up to Number.MAX_SAFE_INTEGER). Svm has no native numeric chain id, so the label ids are assigned by Envio and match the ids used for HyperSync usage attribution.",
+          "$ref": "#/$defs/ChainId"
+        },
         "skip": {
           "description": "Excludes the chain from indexing and migrations. Code generation is unaffected. For testing, prefer using a test framework instead.",
           "type": [
@@ -264,9 +268,31 @@
       },
       "additionalProperties": false,
       "required": [
+        "id",
         "start_block"
       ]
     },
+    "ChainId": {
+      "description": "The chain id of an Svm chain: either a known cluster label or an\nexplicit number (for private chains, rollups, or custom clusters).",
+      "anyOf": [
+        {
+          "$ref": "#/$defs/ChainLabel"
+        },
+        {
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0,
+          "maximum": 9007199254740991
+        }
+      ]
+    },
+    "ChainLabel": {
+      "type": "string",
+      "enum": [
+        "solana",
+        "solana-devnet"
+      ]
+    },
     "Experimental": {
       "type": "object",
       "properties": {
@@ -373,19 +399,8 @@
             }
           ]
         },
-        "field_selection": {
-          "description": "Select which additional data to fetch for each matched instruction. Each key accepts `true` (include all fields) or a list of field names (per-field selection, not yet supported). When absent, only the instruction itself is included.",
-          "anyOf": [
-            {
-              "$ref": "#/$defs/SvmFieldSelection"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
         "accounts": {
-          "description": "Optional positional account names. The Nth entry names account slot N on the dispatched instruction; surfaces as `event.instruction.decoded.accounts.<name>`. Accounts beyond the named list become `extra_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": [
             "array",
             "null"
@@ -466,72 +481,6 @@
         "any_of"
       ]
     },
-    "SvmFieldSelection": {
-      "type": "object",
-      "properties": {
-        "transaction_fields": {
-          "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"
-          }
-        },
-        "block_fields": {
-          "description": "Block fields to include on each matched instruction's `block`, as a list of field names. `slot`/`time`/`hash` are always included; this adds `height`/`parentSlot`/`parentHash`.",
-          "type": [
-            "array",
-            "null"
-          ],
-          "items": {
-            "$ref": "#/$defs/SvmBlockField"
-          }
-        },
-        "log_fields": {
-          "description": "Set to `true` to include program logs scoped to each matched instruction.",
-          "type": [
-            "boolean",
-            "null"
-          ]
-        },
-        "token_balance_fields": {
-          "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
-    },
-    "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",
-        "signature",
-        "feePayer",
-        "success",
-        "err",
-        "fee",
-        "computeUnitsConsumed",
-        "accountKeys",
-        "recentBlockhash",
-        "version",
-        "allSignatures"
-      ]
-    },
-    "SvmBlockField": {
-      "description": "Selectable block field names (camelCase), matching the public\n`instruction.block` shape. `slot`/`time`/`hash` are always included,\nso everything here is opt-in on top of that trio.",
-      "type": "string",
-      "enum": [
-        "height",
-        "parentSlot",
-        "parentHash"
-      ]
-    },
     "ArgDef": {
       "description": "One named argument of an instruction. Mirrors\n`hypersync_client_solana::decode::NamedField`.",
       "type": "object",