@effectstream/sm 0.101.1 → 0.102.0

package/LICENSE-APACHE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024-2026 Midnight Foundation
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Midnight Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@effectstream/sm",
-  "version": "0.101.1",
-  "license": "MIT",
+  "version": "0.102.0",
+  "license": "(MIT OR Apache-2.0)",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
     "type": "git",
@@ -17,14 +17,14 @@
     "./grammar": "./primitives/src/grammar.ts"
   },
   "dependencies": {
-    "@effectstream/concise": "0.101.1",
-    "@effectstream/config": "0.101.1",
-    "@effectstream/coroutine": "0.101.1",
-    "@effectstream/crypto": "0.101.1",
-    "@effectstream/db": "0.101.1",
-    "@effectstream/event-client": "0.101.1",
-    "@effectstream/log": "0.101.1",
-    "@effectstream/utils": "0.101.1",
+    "@effectstream/concise": "0.102.0",
+    "@effectstream/config": "0.102.0",
+    "@effectstream/coroutine": "0.102.0",
+    "@effectstream/crypto": "0.102.0",
+    "@effectstream/db": "0.102.0",
+    "@effectstream/event-client": "0.102.0",
+    "@effectstream/log": "0.102.0",
+    "@effectstream/utils": "0.102.0",
     "pg": "8.21.0",
     "pg-tx": "^1.0.1",
     "@sinclair/typebox": "0.34.41",

package/primitives/Primitive.ts

@@ -50,9 +50,12 @@ export abstract class Primitive<
   // maintained `pg_ivm` view (when the extension is available) and a plain
   // SQL view fallback (when it isn't). All other DDL — intermediate table,
   // trigger function, trigger — is identical across strategies.
+  // May return `undefined` to emit no DDL — e.g. a primitive can gate its
+  // owned table behind a config flag. `getDynamicTables` already surfaces
+  // `string | undefined`, and `createDynamicTables` skips on undefined.
   dynamicTables:
     | undefined
-    | ((name: string, strategy: MaterializedViewStrategy) => string) =
+    | ((name: string, strategy: MaterializedViewStrategy) => string | undefined) =
       undefined;
   getIntermediatePrefix(): string[] {
     return [];

package/primitives/src/builtin.ts

@@ -33,6 +33,9 @@ export const PrimitiveTypeNEARIntent = "NEAR:Intent" as const;
 export const PrimitiveTypeNEARGeneric = "NEAR:Generic" as const;
 export const PrimitiveTypeNEARAccountWatch = "NEAR:AccountWatch" as const;
 
+export const PrimitiveTypeSolanaProgramLog = "SOLANA:ProgramLog" as const;
+export const PrimitiveTypeSolanaAccountBalance = "SOLANA:AccountBalance" as const;
+
 type BuiltInPrimitives =
     typeof PrimitiveTypeMidnightGeneric |
     typeof PrimitiveTypeMidnightNullifier |
@@ -58,7 +61,9 @@ type BuiltInPrimitives =
     typeof PrimitiveTypeNEARNEP245 |
     typeof PrimitiveTypeNEARIntent |
     typeof PrimitiveTypeNEARGeneric |
-    typeof PrimitiveTypeNEARAccountWatch // |
+    typeof PrimitiveTypeNEARAccountWatch |
+    typeof PrimitiveTypeSolanaProgramLog |
+    typeof PrimitiveTypeSolanaAccountBalance // |
     // typeof PrimitiveTypeEVMGeneric
 ;
 

package/primitives/src/grammar.ts

@@ -15,14 +15,18 @@ import { nep245Grammar } from "./near-nep245/nep245-grammar.ts";
 import { nearIntentGrammar } from "./near-intent/near-intent-grammar.ts";
 import { nearGenericGrammar } from "./near-generic/near-generic-grammar.ts";
 import { nearAccountWatchGrammar } from "./near-account-watch/near-account-watch-grammar.ts";
+import { solanaProgramLogGrammar } from "./solana-program-log/solana-program-log-grammar.ts";
+import { solanaAccountBalanceGrammar } from "./solana-account-balance/solana-account-balance-grammar.ts";
 import { mintBurnGrammar } from "./cardano-mint-burn/mint-burn-grammar.ts";
 import { transferGrammar } from "./cardano-transfer/transfer-grammar.ts";
 import { poolDelegationGrammar } from "./cardano-pool-delegation/pool-delegation-grammar.ts";
 import { delayedAssetGrammar } from "./cardano-delayed-asset/delayed-asset-grammar.ts";
 import { projectedNftGrammar } from "./cardano-projected-nft/projected-nft-grammar.ts";
+import { midnightTokenMintGrammar } from "./midnight-token-mint/midnight-token-mint-grammar.ts";
 
 export const builtinGrammars = {
   midnightGeneric: midnightGenericGrammar,
+  midnightTokenMint: midnightTokenMintGrammar,
   evmErc721: erc721Grammar,
   evmErc20: erc20Grammar,
   availGeneric: availGenericGrammar,
@@ -36,6 +40,8 @@ export const builtinGrammars = {
   nearIntent: nearIntentGrammar,
   nearGeneric: nearGenericGrammar,
   nearAccountWatch: nearAccountWatchGrammar,
+  solanaProgramLog: solanaProgramLogGrammar,
+  solanaAccountBalance: solanaAccountBalanceGrammar,
   cardanoMintBurn: mintBurnGrammar,
   cardanoTransfer: transferGrammar,
   cardanoPoolDelegation: poolDelegationGrammar,

package/primitives/src/midnight-token-mint/midnight-token-mint-grammar.ts

@@ -1,8 +1,16 @@
 import { Type } from "@sinclair/typebox";
 
+// Flat named fields (not a single `payload` blob) so the owned-table trigger
+// on effectstream.primitive_accounting can read each column directly via
+// `payload->>'field'` — mirrors the ERC20/NEP141 grammars. All strings;
+// `amount` is a decimal string (u64 mints exceed MAX_SAFE_INTEGER) cast to
+// numeric in SQL; `entryPoint` is informational (defaulted to "").
 export const midnightTokenMintGrammar = [
-  [
-    "payload",
-    Type.Any(),
-  ],
+  ["contractAddress", Type.String()],
+  ["domainSep", Type.String()],
+  ["rawTokenType", Type.String()],
+  ["kind", Type.String()],
+  ["amount", Type.String()],
+  ["txHash", Type.String()],
+  ["entryPoint", Type.String()],
 ] as const;

package/primitives/src/midnight-token-mint/midnight-token-mint-ivm.ts

@@ -0,0 +1,105 @@
+import { PrimitiveTypeMidnightTokenMint } from "../builtin.ts";
+import type { MaterializedViewStrategy } from "@effectstream/db";
+
+/**
+ * Owned-table DDL for the Midnight:TokenMint primitive — the registry
+ * `token_type → (contract_address, domain_sep, kind)` with an accumulating
+ * `total_minted`. Maintained entirely by a trigger on
+ * effectstream.primitive_accounting (which is written for every primitive
+ * event regardless of any state-machine prefix), so consumers get the table
+ * for free — no STM handler / migration required.
+ *
+ * Mirrors the ERC20/NEP141 IVM shape: intermediate table + trigger + a
+ * read-side view published per `strategy` (pg_ivm or plain VIEW).
+ */
+export function midnightTokenMintIvm(
+  name: string,
+  strategy: MaterializedViewStrategy,
+) {
+  // The instance name becomes part of an SQL identifier, so strip anything that
+  // isn't identifier-safe. The ERC20/NEP141 IVMs *throw* here instead, which
+  // makes the owned table reject the repo's own naming convention (hyphenated
+  // instance names like "Midnight-TokenMint") — and it throws at sync startup,
+  // taking the whole node down for what is only a naming concern. Names that
+  // were already safe are untouched, so no existing table/view name shifts.
+  const lowerName = name.toLowerCase();
+  const validSQLName = lowerName.replace(/[^a-zA-Z0-9_]/g, "");
+  if (validSQLName.length === 0) {
+    throw new Error(
+      `Primitive instance name "${name}" has no SQL-identifier-safe characters`,
+    );
+  }
+  // The name is also compared as a string literal inside the trigger body, and
+  // that use is not identifier-restricted — so escape quotes rather than strip
+  // them. Without this, a name containing `'` emits DDL that fails to parse.
+  const sqlLiteralName = name.replace(/'/g, "''");
+
+  const mintsTable =
+    `primitives.midnight_token_mint_intermediate_${validSQLName}`;
+  const viewName = `primitives.midnight_token_mint_view_${validSQLName}`;
+  const selectSql =
+    `SELECT primitive_name, token_type, kind, contract_address, domain_sep, total_minted, tx_hash, block_height FROM ${mintsTable}`;
+
+  return `
+    -- Token-mint registry (maintained by a trigger on primitive_accounting).
+    -- The mapping columns are immutable (token_type is a pure function of
+    -- (domain_sep, contract_address)); total_minted accumulates; tx_hash /
+    -- block_height keep first-mint provenance. kind is in the key because the
+    -- shielded and unshielded derivation formula is identical.
+    CREATE TABLE IF NOT EXISTS ${mintsTable} (
+        primitive_name TEXT NOT NULL,
+        token_type TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        contract_address TEXT NOT NULL,
+        domain_sep TEXT NOT NULL,
+        total_minted numeric(78,0) DEFAULT 0,
+        tx_hash TEXT,
+        block_height INTEGER,
+        PRIMARY KEY (primitive_name, token_type, kind)
+    );
+
+    CREATE OR REPLACE FUNCTION update_midnight_token_mint_${validSQLName}() RETURNS TRIGGER AS $$
+    DECLARE
+        mint_amount numeric(78,0);
+    BEGIN
+        IF NEW.payload_type = '${PrimitiveTypeMidnightTokenMint}'
+           AND NEW.primitive_name = '${sqlLiteralName}'
+           AND NEW.payload->>'rawTokenType' IS NOT NULL THEN
+
+         mint_amount := COALESCE((NEW.payload->>'amount')::numeric(78,0), 0);
+
+         INSERT INTO ${mintsTable} (
+             primitive_name, token_type, kind, contract_address, domain_sep,
+             total_minted, tx_hash, block_height
+         )
+         VALUES (
+             NEW.primitive_name,
+             NEW.payload->>'rawTokenType',
+             NEW.payload->>'kind',
+             NEW.payload->>'contractAddress',
+             NEW.payload->>'domainSep',
+             mint_amount,
+             NEW.payload->>'txHash',
+             NEW.effectstream_block_height
+         )
+         ON CONFLICT (primitive_name, token_type, kind) DO UPDATE SET
+             total_minted = ${mintsTable}.total_minted + EXCLUDED.total_minted;
+        END IF;
+
+        RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+
+    CREATE TRIGGER trigger_update_midnight_token_mint_${validSQLName}
+        AFTER INSERT ON effectstream.primitive_accounting
+        FOR EACH ROW
+        EXECUTE FUNCTION update_midnight_token_mint_${validSQLName}();
+
+    ${strategy.createView(viewName, selectSql)}
+    `;
+}
+
+export const MIDNIGHT_TOKEN_MINT_VIEW_PREFIX =
+  "midnight_token_mint_view_" as const;
+export const MIDNIGHT_TOKEN_MINT_INTERMEDIATE_PREFIX =
+  "midnight_token_mint_intermediate_" as const;

package/primitives/src/midnight-token-mint/midnight-token-mint.test.ts

@@ -0,0 +1,150 @@
+import { test, expect } from "bun:test";
+import { run } from "effection";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+} from "@effectstream/config";
+// Import via mod.ts (not the primitive file directly) to avoid the
+// primitive ⇄ @effectstream/sm ⇄ mod.ts init cycle — same as erc20-primitive.test.ts.
+import { MidnightTokenMintPrimitive } from "../mod.ts";
+import { PrimitiveRegistry } from "../../PrimitiveRegistry.ts";
+
+// Minimal view strategy — the IVM only calls strategy.createView(...).
+const STRATEGY = {
+  migrationSuffix: "",
+  createView: (name: string, sql: string) => `CREATE VIEW ${name} AS ${sql};`,
+} as any;
+
+const MOCK_TX_DATA = {
+  output: {
+    payload: {
+      contractAddress: "0200abcd",
+      domainSep: "ab".repeat(32),
+      rawTokenType: "cd".repeat(32),
+      kind: "shielded",
+      amount: "18446744073709551615", // u64 max — exceeds MAX_SAFE_INTEGER
+      txHash: "ef".repeat(32),
+      entryPoint: "mint",
+    },
+  },
+} as unknown as FlattenSyncProtocolIOFor<
+  ConfigSyncProtocolType.MIDNIGHT_PARALLEL
+>;
+
+function cleanup() {
+  // The base constructor registers `this` by instanceName and throws on dupes.
+  PrimitiveRegistry.primitives = {};
+}
+
+async function getPayloadOnce(p: MidnightTokenMintPrimitive) {
+  let item: any;
+  await run(function* () {
+    const result = p.getPayload(123, MOCK_TX_DATA).next().value;
+    if (!result || !("isBatched" in result)) {
+      throw new Error("No payload generated");
+    }
+    item = result.data[0];
+  });
+  return item;
+}
+
+test("MidnightTokenMint - persist defaults to true and owns its table", () => {
+  cleanup();
+  const p = new MidnightTokenMintPrimitive({
+    instanceName: "tok",
+    startBlockHeight: 1,
+    stateMachinePrefix: undefined,
+  });
+  expect(p.persist).toBe(true);
+
+  const ddl = p.getDynamicTables("tok", STRATEGY);
+  expect(ddl).toBeDefined();
+  // Owned intermediate table + the trigger on primitive_accounting.
+  expect(ddl).toContain("primitives.midnight_token_mint_intermediate_tok");
+  expect(ddl).toContain("trigger_update_midnight_token_mint_tok");
+  expect(ddl).toContain("effectstream.primitive_accounting");
+  expect(p.getViewPrefix()).toContain("midnight_token_mint_view_");
+});
+
+test("MidnightTokenMint - persist:false disables the owned table", () => {
+  cleanup();
+  const p = new MidnightTokenMintPrimitive({
+    instanceName: "tok",
+    startBlockHeight: 1,
+    stateMachinePrefix: undefined,
+    persist: false,
+  });
+  expect(p.persist).toBe(false);
+  // No DDL emitted → createDynamicTables skips it → no table/trigger.
+  expect(p.getDynamicTables("tok", STRATEGY)).toBeUndefined();
+});
+
+test("MidnightTokenMint - hyphenated instance names are sanitized, not rejected", () => {
+  cleanup();
+  // "Midnight-TokenMint" is the repo's own naming convention. Throwing here
+  // killed the sync node at startup ("Invalid name: Midnight-TokenMint").
+  const p = new MidnightTokenMintPrimitive({
+    instanceName: "Midnight-TokenMint",
+    startBlockHeight: 1,
+    stateMachinePrefix: "midnightTokenMintState",
+  });
+
+  const ddl = p.getDynamicTables("Midnight-TokenMint", STRATEGY)!;
+  expect(ddl).toContain(
+    "primitives.midnight_token_mint_view_midnighttokenmint",
+  );
+  expect(ddl).toContain(
+    "primitives.midnight_token_mint_intermediate_midnighttokenmint",
+  );
+  // No hyphen may survive into an SQL identifier.
+  expect(ddl).not.toContain("midnight_token_mint_view_midnight-tokenmint");
+});
+
+test("MidnightTokenMint - a quote in the name is escaped in the trigger literal", () => {
+  cleanup();
+  // The name is stripped for identifiers but compared as a string literal in
+  // the trigger body, where a bare `'` would emit unparseable DDL.
+  const p = new MidnightTokenMintPrimitive({
+    instanceName: "Bob's-Mints",
+    startBlockHeight: 1,
+    stateMachinePrefix: undefined,
+  });
+
+  const ddl = p.getDynamicTables("Bob's-Mints", STRATEGY)!;
+  expect(ddl).toContain("NEW.primitive_name = 'Bob''s-Mints'");
+  expect(ddl).toContain("midnight_token_mint_view_bobsmints");
+});
+
+test("MidnightTokenMint - owning a table does not suppress the STM input", async () => {
+  cleanup();
+  const p = new MidnightTokenMintPrimitive({
+    instanceName: "tok",
+    startBlockHeight: 1,
+    stateMachinePrefix: "midnightTokenMintState",
+  });
+
+  // Both paths are live at once: owned table DDL *and* an STM payload.
+  expect(p.getDynamicTables("tok", STRATEGY)).toBeDefined();
+  expect(p.getConfig().scheduledPrefix).toBe("midnightTokenMintState");
+
+  const item = await getPayloadOnce(p);
+  expect(Array.isArray(item.stateMachinePayload)).toBe(true);
+  expect(item.stateMachinePayload[0]).toBe("midnightTokenMintState");
+  // Flat fields, in grammar order, so the STM handler reads them by name.
+  expect(item.accountingPayload.rawTokenType).toBe("cd".repeat(32));
+  expect(item.accountingPayload.amount).toBe("18446744073709551615");
+});
+
+test("MidnightTokenMint - no prefix means accounting only (opt-out is explicit)", async () => {
+  cleanup();
+  const p = new MidnightTokenMintPrimitive({
+    instanceName: "tok",
+    startBlockHeight: 1,
+    stateMachinePrefix: undefined,
+  });
+
+  const item = await getPayloadOnce(p);
+  expect(item.stateMachinePayload).toBe(null);
+  // The accounting row (and therefore the owned table) is still written.
+  expect(item.accountingPayload.rawTokenType).toBe("cd".repeat(32));
+});

package/primitives/src/midnight-token-mint/midnight-token-mint.ts

@@ -18,31 +18,50 @@ import type {
 import type { SyncStateUpdateStream } from "@effectstream/coroutine";
 import { PrimitiveTypeMidnightTokenMint } from "../builtin.ts";
 import { midnightTokenMintGrammar } from "./midnight-token-mint-grammar.ts";
+import {
+  MIDNIGHT_TOKEN_MINT_INTERMEDIATE_PREFIX,
+  MIDNIGHT_TOKEN_MINT_VIEW_PREFIX,
+  midnightTokenMintIvm,
+} from "./midnight-token-mint-ivm.ts";
 
 /**
  * MidnightTokenMintPrimitive
  *
- * Watches custom token *mints* on the Midnight ledger. A contract call's
- * effects record minted tokens as `domain_sep → amount` maps (shielded and
- * unshielded), and the resulting token type ("color") is derived as
- * `rawTokenType(domain_sep, contract_address)` — so this primitive is the
- * only way for a consumer to map a wallet-visible token id back to the
- * contract that minted it. The fetcher deserializes each regular
- * transaction's raw bytes with ledger-v8, walks the contract calls, and
- * emits one state-machine input per `(tx, call, domainSep, kind)` — only
- * for effects that actually applied on chain (failed segments roll back).
+ * Watches custom token *mints* on the Midnight ledger and maps a token id
+ * ("color") back to the contract that minted it — the mapping wallets cannot
+ * provide. A contract call's effects record mints as `domain_sep → amount`
+ * maps (shielded and unshielded); the token type is
+ * `rawTokenType(domain_sep, contract_address)`. The fetcher deserializes each
+ * regular transaction with ledger-v8, walks the contract calls, and emits one
+ * event per `(tx, call, domainSep, kind)`.
  *
- * The mint nonce is NOT part of token identity (it only randomizes coin
- * commitments) and is never public for shielded mints, so it is not part
- * of the payload.
+ * The primitive OWNS its registry table: `dynamicTables` declares
+ * `primitives.midnight_token_mint_view_<instance>` (maintained by a trigger on
+ * effectstream.primitive_accounting), so a consumer gets the registry with
+ * only an `.addPrimitive(...)` line — no state-machine handler, grammar entry,
+ * or migration. Set `persist: false` in config to skip the owned table on a
+ * fresh database (the accounting row is still written; useful when a consumer
+ * wants to handle the data itself or skip it) — see the flag's own docs for why
+ * it does not tear down a table an earlier run already created.
  *
- * Usage:
+ * The owned table does NOT replace the state machine: the two paths are
+ * independent and run together. Whenever `stateMachinePrefix` is set the
+ * primitive still emits an STM input for every mint, exactly as it would
+ * without an owned table — the registry is the read model, the STM handler is
+ * where app-specific logic lives. Pass `stateMachinePrefix: undefined` to opt
+ * out explicitly (the flag is a required config key so the choice is never
+ * made by omission).
+ *
+ * Usage (STM path, in addition to the owned view):
+ *   grammar: { myPrefix: builtinGrammars.midnightTokenMint }
  *   stm.addStateTransition("myPrefix", function* (data) {
- *     const { payload } = data.parsedInput;
- *     // payload = { txHash, contractAddress, domainSep, rawTokenType,
- *     //             kind: "shielded" | "unshielded", amount, entryPoint }
+ *     const { rawTokenType, kind, contractAddress, domainSep, amount, txHash }
+ *       = data.parsedInput;
  *     // amount is a decimal string (u64 mints can exceed MAX_SAFE_INTEGER)
  *   });
+ *
+ * The mint nonce is NOT part of token identity (it only randomizes coin
+ * commitments) and is never public for shielded mints, so it is not recorded.
  */
 export class MidnightTokenMintPrimitive extends Primitive<
   ConfigSyncProtocolType.MIDNIGHT_PARALLEL,
@@ -51,20 +70,42 @@ export class MidnightTokenMintPrimitive extends Primitive<
   readonly internalTypeName = PrimitiveTypeMidnightTokenMint;
   override readonly grammar = midnightTokenMintGrammar;
 
-  override dynamicTables = undefined;
+  /**
+   * When true (default) the primitive owns + populates its registry table.
+   *
+   * Only affects whether the DDL is emitted, and the DDL is applied once per
+   * instance behind a migration row with no down path — so flipping this to
+   * `false` on a database that already ran with `true` leaves the table and its
+   * trigger in place, still accumulating. It skips the table on a fresh
+   * database; it is not a runtime off switch.
+   */
+  readonly persist: boolean;
+
+  // Owned table — gated by `persist`. When disabled, no DDL is emitted, so no
+  // table/trigger is created and nothing is consolidated (accounting only).
+  override dynamicTables = (
+    name: string,
+    strategy: Parameters<typeof midnightTokenMintIvm>[1],
+  ): string | undefined =>
+    this.persist ? midnightTokenMintIvm(name, strategy) : undefined;
+
   override getIntermediatePrefix(): string[] {
-    return [];
+    return [MIDNIGHT_TOKEN_MINT_INTERMEDIATE_PREFIX];
   }
   override getViewPrefix(): string[] {
-    return [];
+    return [MIDNIGHT_TOKEN_MINT_VIEW_PREFIX];
   }
 
   constructor(config: {
     instanceName: string;
     startBlockHeight: number;
-    stateMachinePrefix: string;
+    // Required key (may be `undefined`) like every other primitive: owning a
+    // table is not a reason to skip the STM, so opting out has to be deliberate.
+    stateMachinePrefix: string | undefined;
+    persist?: boolean;
   }) {
     super(config);
+    this.persist = config.persist ?? true;
   }
 
   override *getPayload(
@@ -82,10 +123,26 @@ export class MidnightTokenMintPrimitive extends Primitive<
       accountingPayload: ParamToData<typeof midnightTokenMintGrammar>;
     }[];
   }> {
-    const payload = primitiveTransactionData.output.payload;
+    const p = primitiveTransactionData.output.payload as {
+      contractAddress: string;
+      domainSep: string;
+      rawTokenType: string;
+      kind: string;
+      amount: string;
+      txHash: string;
+      entryPoint?: string;
+    };
 
+    // Flat accounting payload so the owned-table trigger reads columns via
+    // payload->>'field' (matches ERC20/NEP141).
     const accountingPayload: ParamToData<typeof this.grammar> = {
-      payload,
+      contractAddress: p.contractAddress,
+      domainSep: p.domainSep,
+      rawTokenType: p.rawTokenType,
+      kind: p.kind,
+      amount: p.amount,
+      txHash: p.txHash,
+      entryPoint: p.entryPoint ?? "",
     };
 
     const stateMachinePayload:
@@ -120,7 +177,7 @@ export class MidnightTokenMintPrimitive extends Primitive<
       name: this.instanceName,
       type: this.internalTypeName,
       startBlockHeight: this.startBlockHeight,
-      scheduledPrefix: this.stateMachinePrefix ?? "",
+      scheduledPrefix: this.stateMachinePrefix,
     } as const;
   }
 }

package/primitives/src/mod.ts

@@ -19,6 +19,8 @@ import {
   PrimitiveTypeNEARIntent,
   PrimitiveTypeNEARGeneric,
   PrimitiveTypeNEARAccountWatch,
+  PrimitiveTypeSolanaProgramLog,
+  PrimitiveTypeSolanaAccountBalance,
   PrimitiveTypeCardanoMintBurn,
   PrimitiveTypeCardanoTransfer,
   PrimitiveTypeCardanoPoolDelegation,
@@ -47,6 +49,8 @@ import { Nep245Primitive } from "./near-nep245/nep245-primitive.ts";
 import { NearIntentPrimitive } from "./near-intent/near-intent-primitive.ts";
 import { NearGenericPrimitive } from "./near-generic/near-generic-primitive.ts";
 import { NearAccountWatchPrimitive } from "./near-account-watch/near-account-watch-primitive.ts";
+import { SolanaProgramLogPrimitive } from "./solana-program-log/solana-program-log-primitive.ts";
+import { SolanaAccountBalancePrimitive } from "./solana-account-balance/solana-account-balance-primitive.ts";
 import { CardanoMintBurnPrimitive } from "./cardano-mint-burn/mint-burn-primitive.ts";
 import { CardanoTransferPrimitive } from "./cardano-transfer/transfer-primitive.ts";
 import { CardanoPoolDelegationPrimitive } from "./cardano-pool-delegation/pool-delegation-primitive.ts";
@@ -75,6 +79,8 @@ const builtInPrimitivesMap = {
   [PrimitiveTypeNEARIntent]: NearIntentPrimitive,
   [PrimitiveTypeNEARGeneric]: NearGenericPrimitive,
   [PrimitiveTypeNEARAccountWatch]: NearAccountWatchPrimitive,
+  [PrimitiveTypeSolanaProgramLog]: SolanaProgramLogPrimitive,
+  [PrimitiveTypeSolanaAccountBalance]: SolanaAccountBalancePrimitive,
   [PrimitiveTypeCardanoMintBurn]: CardanoMintBurnPrimitive,
   [PrimitiveTypeCardanoTransfer]: CardanoTransferPrimitive,
   [PrimitiveTypeCardanoPoolDelegation]: CardanoPoolDelegationPrimitive,
@@ -108,6 +114,8 @@ export {
   NearIntentPrimitive,
   NearGenericPrimitive,
   NearAccountWatchPrimitive,
+  SolanaProgramLogPrimitive,
+  SolanaAccountBalancePrimitive,
   CardanoMintBurnPrimitive,
   CardanoTransferPrimitive,
   CardanoPoolDelegationPrimitive,

package/primitives/src/solana-account-balance/solana-account-balance-grammar.ts

@@ -0,0 +1,7 @@
+import { Type } from "@sinclair/typebox";
+
+export const solanaAccountBalanceGrammar = [
+  ["address", Type.String()],
+  ["lamports", Type.Number()],
+  ["slot", Type.Number()],
+] as const;

package/primitives/src/solana-account-balance/solana-account-balance-primitive.ts

@@ -0,0 +1,108 @@
+import type { StaticDecode } from "@sinclair/typebox";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  ProtocolPrimitiveMap,
+} from "@effectstream/config";
+import {
+  type AddressAndType,
+  AddressType,
+  type EffectstreamBlockNumber,
+} from "@effectstream/utils";
+import { type JsonObject, Primitive } from "@effectstream/sm";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+  type ParamToData,
+} from "@effectstream/concise";
+import type { StateUpdateStream } from "@effectstream/coroutine";
+import { solanaAccountBalanceGrammar } from "./solana-account-balance-grammar.ts";
+import { PrimitiveTypeSolanaAccountBalance } from "../builtin.ts";
+
+/**
+ * Built-in primitive: tracks the lamport balance of a watched `address` per
+ * slot (derived from a transaction's postBalances by SolanaFetcher.readPrimitives).
+ */
+export class SolanaAccountBalancePrimitive extends Primitive<
+  ConfigSyncProtocolType.SOLANA_RPC_PARALLEL,
+  typeof solanaAccountBalanceGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeSolanaAccountBalance;
+  override grammar = solanaAccountBalanceGrammar;
+  readonly address: string;
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    address: string;
+    stateMachinePrefix: string | undefined;
+  }) {
+    super(config);
+    this.address = config.address;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.SOLANA_RPC_PARALLEL
+    >,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<CommandTuple<string, typeof solanaAccountBalanceGrammar>>
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload as {
+      address?: string;
+      lamports?: number;
+      slot?: number;
+    };
+    const address = String(payload.address ?? this.address);
+    const lamports = Number(payload.lamports ?? 0);
+    const slot = Number(payload.slot ?? 0);
+
+    const accountingPayload: ParamToData<typeof solanaAccountBalanceGrammar> = {
+      address,
+      lamports,
+      slot,
+    };
+
+    const stateMachinePayload = this.stateMachinePrefix
+      ? generateRawStmInput(
+        this.grammar,
+        this.stateMachinePrefix,
+        accountingPayload,
+      )
+      : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.SOLANA,
+            address,
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.SOLANA_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      address: this.address,
+      scheduledPrefix: this.stateMachinePrefix,
+    } as ProtocolPrimitiveMap[ConfigSyncProtocolType.SOLANA_RPC_PARALLEL];
+  }
+}

package/primitives/src/solana-program-log/solana-program-log-grammar.ts

@@ -0,0 +1,7 @@
+import { Type } from "@sinclair/typebox";
+
+export const solanaProgramLogGrammar = [
+  ["slot", Type.Number()],
+  ["programId", Type.String()],
+  ["logMessages", Type.Array(Type.String())],
+] as const;

package/primitives/src/solana-program-log/solana-program-log-primitive.test.ts

@@ -0,0 +1,128 @@
+import { test, expect } from "bun:test";
+import { run } from "effection";
+import type { ConfigSyncProtocolType, FlattenSyncProtocolIOFor } from "@effectstream/config";
+import { SolanaProgramLogPrimitive } from "./../mod.ts";
+import { PrimitiveRegistry } from "../../PrimitiveRegistry.ts";
+
+const PROGRAM_ID = "11111111111111111111111111111111";
+const PrimitiveTypeSolanaProgramLog = "SOLANA:ProgramLog";
+
+function cleanup() {
+  PrimitiveRegistry.primitives = {};
+}
+
+test("SolanaProgramLogPrimitive - initializes correctly", () => {
+  cleanup();
+  const primitive = new SolanaProgramLogPrimitive({
+    instanceName: "spl",
+    startBlockHeight: 0,
+    programId: PROGRAM_ID,
+    stateMachinePrefix: "solana-program-log",
+  });
+
+  expect(primitive.instanceName).toEqual("spl");
+  expect(primitive.startBlockHeight).toEqual(0);
+  expect(primitive.programId).toEqual(PROGRAM_ID);
+  expect(primitive.internalTypeName).toEqual(PrimitiveTypeSolanaProgramLog);
+
+  const config = primitive.getConfig();
+  expect(config.name).toEqual("spl");
+  expect(config.type).toEqual(PrimitiveTypeSolanaProgramLog);
+  expect(config.programId).toEqual(PROGRAM_ID);
+  expect(config.scheduledPrefix).toEqual("solana-program-log");
+});
+
+test("SolanaProgramLogPrimitive - getPayload generates correct state update", async () => {
+  cleanup();
+  const primitive = new SolanaProgramLogPrimitive({
+    instanceName: "spl",
+    startBlockHeight: 0,
+    programId: PROGRAM_ID,
+    stateMachinePrefix: "solana-program-log",
+  });
+
+  const mockTxData = {
+    syncProtocol: {
+      name: "parallelSolanaRPC",
+      blockNumber: 42,
+      transactionHash: "5x…signature",
+      contractAddress: PROGRAM_ID,
+    },
+    output: {
+      payloadType: "solana:transaction",
+      payload: {
+        programId: PROGRAM_ID,
+        slot: 42,
+        logMessages: ["Program log: hi", "Program log: bye"],
+      },
+    },
+  } as unknown as FlattenSyncProtocolIOFor<
+    ConfigSyncProtocolType.SOLANA_RPC_PARALLEL
+  >;
+
+  await run(function* () {
+    const generator = primitive.getPayload(123, mockTxData);
+    const result = generator.next().value;
+
+    if (!result) throw new Error("No payload generated");
+    if (!("isBatched" in result)) {
+      throw new Error("Result is not a SyncStateUpdate");
+    }
+
+    expect(result.isBatched).toEqual(false);
+    expect(result.data.length).toEqual(1);
+
+    const item = result.data[0];
+    expect(item.accountingPayload.slot).toEqual(42);
+    expect(item.accountingPayload.programId).toEqual(PROGRAM_ID);
+    expect(item.accountingPayload.logMessages).toEqual([
+      "Program log: hi",
+      "Program log: bye",
+    ]);
+
+    expect(Array.isArray(item.stateMachinePayload)).toEqual(true);
+    // @ts-ignore: safe to access
+    expect(item.stateMachinePayload?.[0]).toEqual("solana-program-log");
+  });
+});
+
+test("SolanaProgramLogPrimitive - getPayload skips state machine payload if no prefix", async () => {
+  cleanup();
+  const primitive = new SolanaProgramLogPrimitive({
+    instanceName: "spl",
+    startBlockHeight: 0,
+    programId: PROGRAM_ID,
+    stateMachinePrefix: undefined,
+  });
+
+  const mockTxData = {
+    syncProtocol: {
+      name: "parallelSolanaRPC",
+      blockNumber: 7,
+      transactionHash: "sig",
+      contractAddress: PROGRAM_ID,
+    },
+    output: {
+      payload: {
+        programId: PROGRAM_ID,
+        slot: 7,
+        logMessages: ["Program log: x"],
+      },
+    },
+  } as unknown as FlattenSyncProtocolIOFor<
+    ConfigSyncProtocolType.SOLANA_RPC_PARALLEL
+  >;
+
+  await run(function* () {
+    const generator = primitive.getPayload(123, mockTxData);
+    const result = generator.next().value;
+
+    if (!result) throw new Error("No payload generated");
+    if (!("isBatched" in result)) {
+      throw new Error("Result is not a SyncStateUpdate");
+    }
+
+    const item = result.data[0];
+    expect(item.stateMachinePayload).toEqual(null);
+  });
+});

package/primitives/src/solana-program-log/solana-program-log-primitive.ts

@@ -0,0 +1,108 @@
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  type ConfigSyncProtocolType,
+  type FlattenSyncProtocolIOFor,
+  type ProtocolPrimitiveMap,
+} from "@effectstream/config";
+import {
+  type AddressAndType,
+  AddressType,
+  type EffectstreamBlockNumber,
+} from "@effectstream/utils";
+import { type JsonObject, Primitive } from "@effectstream/sm";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+  type ParamToData,
+} from "@effectstream/concise";
+import type { StateUpdateStream } from "@effectstream/coroutine";
+import { solanaProgramLogGrammar } from "./solana-program-log-grammar.ts";
+import { PrimitiveTypeSolanaProgramLog } from "../builtin.ts";
+
+export class SolanaProgramLogPrimitive extends Primitive<
+  ConfigSyncProtocolType.SOLANA_RPC_PARALLEL,
+  typeof solanaProgramLogGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeSolanaProgramLog;
+  override grammar = solanaProgramLogGrammar;
+  readonly programId: string;
+  readonly eventType: string | undefined;
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    programId: string;
+    eventType?: string;
+    stateMachinePrefix: string | undefined;
+  }) {
+    super(config);
+    this.programId = config.programId;
+    this.eventType = config.eventType;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.SOLANA_RPC_PARALLEL
+    >,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<CommandTuple<string, typeof solanaProgramLogGrammar>>
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const { programId, slot, logMessages } =
+      primitiveTransactionData.output.payload as {
+        programId: string;
+        slot: number;
+        logMessages: string[];
+      };
+
+    const accountingPayload: ParamToData<typeof solanaProgramLogGrammar> = {
+      slot,
+      programId,
+      logMessages,
+    };
+
+    const stateMachinePayload = this.stateMachinePrefix
+      ? generateRawStmInput(
+        this.grammar,
+        this.stateMachinePrefix,
+        accountingPayload,
+      )
+      : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.SOLANA,
+            address: String(
+              primitiveTransactionData.syncProtocol.contractAddress ?? "",
+            ),
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.SOLANA_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      programId: this.programId,
+      eventType: this.eventType,
+      scheduledPrefix: this.stateMachinePrefix,
+    };
+  }
+}