@effectstream/sm 0.101.1 → 0.103.0

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/midnight-unshielded-create/midnight-unshielded-create-grammar.ts

@@ -3,6 +3,19 @@ import { Type } from "@sinclair/typebox";
 export const midnightUnshieldedCreateGrammar = [
   [
     "payload",
-    Type.Any(),
+    Type.Object({
+      /** Bech32m owner address of the created UTXO */
+      owner: Type.String(),
+      /** Hex-encoded hash of the creating intent */
+      intentHash: Type.String(),
+      /** Output index within the creating intent's offer */
+      outputIndex: Type.Number(),
+      /** u128 value as a decimal string */
+      value: Type.String(),
+      /** Hex-encoded serialized token type */
+      tokenType: Type.String(),
+      /** Hash of the creating transaction */
+      txHash: Type.String(),
+    }),
   ],
 ] as const;

package/primitives/src/midnight-unshielded-create/midnight-unshielded-create.ts

@@ -77,7 +77,10 @@ export class MidnightUnshieldedCreatePrimitive extends Primitive<
       accountingPayload: ParamToData<typeof midnightUnshieldedCreateGrammar>;
     }[];
   }> {
-    const payload = primitiveTransactionData.output.payload;
+    // The sync-protocol payload map types Midnight payloads as Record<string, any>;
+    // the fetcher's fetchUnshieldedCreates builds exactly the grammar's payload shape.
+    const payload = primitiveTransactionData.output
+      .payload as ParamToData<typeof this.grammar>["payload"];
 
     const accountingPayload: ParamToData<typeof this.grammar> = {
       payload,

package/primitives/src/midnight-unshielded-spend/midnight-unshielded-spend-grammar.ts

@@ -3,6 +3,19 @@ import { Type } from "@sinclair/typebox";
 export const midnightUnshieldedSpendGrammar = [
   [
     "payload",
-    Type.Any(),
+    Type.Object({
+      /** Bech32m owner address of the spent UTXO */
+      owner: Type.String(),
+      /** Hex-encoded hash of the intent that CREATED the spent UTXO */
+      intentHash: Type.String(),
+      /** Output index within the creating intent's offer */
+      outputIndex: Type.Number(),
+      /** u128 value as a decimal string */
+      value: Type.String(),
+      /** Hex-encoded serialized token type */
+      tokenType: Type.String(),
+      /** Hash of the spending transaction */
+      txHash: Type.String(),
+    }),
   ],
 ] as const;

package/primitives/src/midnight-unshielded-spend/midnight-unshielded-spend.ts

@@ -71,7 +71,10 @@ export class MidnightUnshieldedSpendPrimitive extends Primitive<
       accountingPayload: ParamToData<typeof midnightUnshieldedSpendGrammar>;
     }[];
   }> {
-    const payload = primitiveTransactionData.output.payload;
+    // The sync-protocol payload map types Midnight payloads as Record<string, any>;
+    // the fetcher's fetchUnshieldedSpends builds exactly the grammar's payload shape.
+    const payload = primitiveTransactionData.output
+      .payload as ParamToData<typeof this.grammar>["payload"];
 
     const accountingPayload: ParamToData<typeof this.grammar> = {
       payload,

package/primitives/src/mod.ts

@@ -1,6 +1,6 @@
 import {
   PrimitiveTypeMidnightGeneric,
-  PrimitiveTypeMidnightNullifier,
+  PrimitiveTypeMidnightNullifierAndCommitment,
   PrimitiveTypeMidnightUnshieldedSpend,
   PrimitiveTypeMidnightUnshieldedCreate,
   PrimitiveTypeMidnightZswapRoot,
@@ -19,6 +19,9 @@ import {
   PrimitiveTypeNEARIntent,
   PrimitiveTypeNEARGeneric,
   PrimitiveTypeNEARAccountWatch,
+  PrimitiveTypeSolanaProgramLog,
+  PrimitiveTypeSolanaAccountBalance,
+  PrimitiveTypeSolanaTokenAccount,
   PrimitiveTypeCardanoMintBurn,
   PrimitiveTypeCardanoTransfer,
   PrimitiveTypeCardanoPoolDelegation,
@@ -28,7 +31,8 @@ import {
 } from "./builtin.ts";
 
 import { MidnightGenericPrimitive } from "./midnight-generic/midnight-genetic.ts";
-import { MidnightNullifierPrimitive } from "./midnight-nullifier/midnight-nullifier.ts";
+import { MidnightNullifierAndCommitmentPrimitive } from "./midnight-nullifier-and-commitment/midnight-nullifier-and-commitment.ts";
+export type { MidnightZswapCapture } from "./midnight-nullifier-and-commitment/midnight-nullifier-and-commitment.ts";
 import { MidnightUnshieldedSpendPrimitive } from "./midnight-unshielded-spend/midnight-unshielded-spend.ts";
 import { MidnightUnshieldedCreatePrimitive } from "./midnight-unshielded-create/midnight-unshielded-create.ts";
 import { MidnightZswapRootPrimitive } from "./midnight-zswap-root/midnight-zswap-root.ts";
@@ -47,6 +51,9 @@ 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 { SolanaTokenAccountPrimitive } from "./solana-token-account/solana-token-account-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";
@@ -56,7 +63,7 @@ import { CardanoProjectedNftPrimitive } from "./cardano-projected-nft/projected-
 
 const builtInPrimitivesMap = {
   [PrimitiveTypeMidnightGeneric]: MidnightGenericPrimitive,
-  [PrimitiveTypeMidnightNullifier]: MidnightNullifierPrimitive,
+  [PrimitiveTypeMidnightNullifierAndCommitment]: MidnightNullifierAndCommitmentPrimitive,
   [PrimitiveTypeMidnightUnshieldedSpend]: MidnightUnshieldedSpendPrimitive,
   [PrimitiveTypeMidnightUnshieldedCreate]: MidnightUnshieldedCreatePrimitive,
   [PrimitiveTypeMidnightZswapRoot]: MidnightZswapRootPrimitive,
@@ -75,6 +82,9 @@ const builtInPrimitivesMap = {
   [PrimitiveTypeNEARIntent]: NearIntentPrimitive,
   [PrimitiveTypeNEARGeneric]: NearGenericPrimitive,
   [PrimitiveTypeNEARAccountWatch]: NearAccountWatchPrimitive,
+  [PrimitiveTypeSolanaProgramLog]: SolanaProgramLogPrimitive,
+  [PrimitiveTypeSolanaAccountBalance]: SolanaAccountBalancePrimitive,
+  [PrimitiveTypeSolanaTokenAccount]: SolanaTokenAccountPrimitive,
   [PrimitiveTypeCardanoMintBurn]: CardanoMintBurnPrimitive,
   [PrimitiveTypeCardanoTransfer]: CardanoTransferPrimitive,
   [PrimitiveTypeCardanoPoolDelegation]: CardanoPoolDelegationPrimitive,
@@ -89,7 +99,7 @@ export {
 
   // Built-in Primitives
   MidnightGenericPrimitive,
-  MidnightNullifierPrimitive,
+  MidnightNullifierAndCommitmentPrimitive,
   MidnightUnshieldedSpendPrimitive,
   MidnightUnshieldedCreatePrimitive,
   MidnightZswapRootPrimitive,
@@ -108,6 +118,9 @@ export {
   NearIntentPrimitive,
   NearGenericPrimitive,
   NearAccountWatchPrimitive,
+  SolanaProgramLogPrimitive,
+  SolanaAccountBalancePrimitive,
+  SolanaTokenAccountPrimitive,
   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;