@effectstream/sm 0.100.21 → 0.100.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectstream/sm",
-  "version": "0.100.21",
+  "version": "0.100.23",
   "license": "MIT",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
@@ -17,14 +17,14 @@
     "./grammar": "./primitives/src/grammar.ts"
   },
   "dependencies": {
-    "@effectstream/concise": "0.100.21",
-    "@effectstream/config": "0.100.21",
-    "@effectstream/coroutine": "0.100.21",
-    "@effectstream/crypto": "0.100.21",
-    "@effectstream/db": "0.100.21",
-    "@effectstream/event-client": "0.100.21",
-    "@effectstream/log": "0.100.21",
-    "@effectstream/utils": "0.100.21",
+    "@effectstream/concise": "0.100.23",
+    "@effectstream/config": "0.100.23",
+    "@effectstream/coroutine": "0.100.23",
+    "@effectstream/crypto": "0.100.23",
+    "@effectstream/db": "0.100.23",
+    "@effectstream/event-client": "0.100.23",
+    "@effectstream/log": "0.100.23",
+    "@effectstream/utils": "0.100.23",
     "pg": "8.21.0",
     "pg-tx": "^1.0.1",
     "@sinclair/typebox": "0.34.41",

package/primitives/src/builtin.ts

@@ -3,6 +3,9 @@
 export const PrimitiveTypeMidnightGeneric = "Midnight:Generic" as const;
 export const PrimitiveTypeMidnightNullifier = "Midnight:Nullifier" as const;
 export const PrimitiveTypeMidnightUnshieldedSpend = "Midnight:UnshieldedSpend" as const;
+export const PrimitiveTypeMidnightUnshieldedCreate = "Midnight:UnshieldedCreate" as const;
+export const PrimitiveTypeMidnightZswapRoot = "Midnight:ZswapRoot" as const;
+export const PrimitiveTypeMidnightTokenMint = "Midnight:TokenMint" as const;
 
 export const PrimitiveTypeUtxorpcGeneric = "Utxorpc:Generic" as const;
 export const PrimitiveTypeCardanoMintBurn = "Cardano:MintBurn" as const;
@@ -34,6 +37,9 @@ type BuiltInPrimitives =
     typeof PrimitiveTypeMidnightGeneric |
     typeof PrimitiveTypeMidnightNullifier |
     typeof PrimitiveTypeMidnightUnshieldedSpend |
+    typeof PrimitiveTypeMidnightUnshieldedCreate |
+    typeof PrimitiveTypeMidnightZswapRoot |
+    typeof PrimitiveTypeMidnightTokenMint |
     typeof PrimitiveTypeEVMEffectstreamL2 |
     typeof PrimitiveTypeEVMERC721 |
     typeof PrimitiveTypeEVMERC20 |

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

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+
+export const midnightTokenMintGrammar = [
+  [
+    "payload",
+    Type.Any(),
+  ],
+] as const;

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

@@ -0,0 +1,126 @@
+import { Primitive } from "@effectstream/sm";
+import {
+  type AddressAndType,
+  AddressType,
+  type EffectstreamBlockNumber,
+} from "@effectstream/utils";
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+  type ParamToData,
+} from "@effectstream/concise";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  ProtocolPrimitiveMap,
+} from "@effectstream/config";
+import type { SyncStateUpdateStream } from "@effectstream/coroutine";
+import { PrimitiveTypeMidnightTokenMint } from "../builtin.ts";
+import { midnightTokenMintGrammar } from "./midnight-token-mint-grammar.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).
+ *
+ * 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.
+ *
+ * Usage:
+ *   stm.addStateTransition("myPrefix", function* (data) {
+ *     const { payload } = data.parsedInput;
+ *     // payload = { txHash, contractAddress, domainSep, rawTokenType,
+ *     //             kind: "shielded" | "unshielded", amount, entryPoint }
+ *     // amount is a decimal string (u64 mints can exceed MAX_SAFE_INTEGER)
+ *   });
+ */
+export class MidnightTokenMintPrimitive extends Primitive<
+  ConfigSyncProtocolType.MIDNIGHT_PARALLEL,
+  typeof midnightTokenMintGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeMidnightTokenMint;
+  override readonly grammar = midnightTokenMintGrammar;
+
+  override dynamicTables = undefined;
+  override getIntermediatePrefix(): string[] {
+    return [];
+  }
+  override getViewPrefix(): string[] {
+    return [];
+  }
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    stateMachinePrefix: string;
+  }) {
+    super(config);
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.MIDNIGHT_PARALLEL
+    >,
+  ): SyncStateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<CommandTuple<string, typeof midnightTokenMintGrammar>>
+        | null;
+      accountingPayload: ParamToData<typeof midnightTokenMintGrammar>;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload;
+
+    const accountingPayload: ParamToData<typeof this.grammar> = {
+      payload,
+    };
+
+    const stateMachinePayload:
+      | StaticDecode<CommandTuple<string, typeof this.grammar>>
+      | null = this.stateMachinePrefix
+      ? generateRawStmInput(
+        this.grammar,
+        this.stateMachinePrefix,
+        accountingPayload,
+      )
+      : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.NONE,
+            address: "0x0",
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.MIDNIGHT_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      scheduledPrefix: this.stateMachinePrefix ?? "",
+    } as const;
+  }
+}

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

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+
+export const midnightUnshieldedCreateGrammar = [
+  [
+    "payload",
+    Type.Any(),
+  ],
+] as const;

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

@@ -0,0 +1,121 @@
+import { Primitive } from "@effectstream/sm";
+import {
+  type AddressAndType,
+  AddressType,
+  type EffectstreamBlockNumber,
+} from "@effectstream/utils";
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+  type ParamToData,
+} from "@effectstream/concise";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  ProtocolPrimitiveMap,
+} from "@effectstream/config";
+import type { SyncStateUpdateStream } from "@effectstream/coroutine";
+import { PrimitiveTypeMidnightUnshieldedCreate } from "../builtin.ts";
+import { midnightUnshieldedCreateGrammar } from "./midnight-unshielded-create-grammar.ts";
+
+/**
+ * MidnightUnshieldedCreatePrimitive
+ *
+ * Watches all unshielded UTXO *creation* events on the Midnight ledger — the
+ * mirror of MidnightUnshieldedSpendPrimitive. The indexer's GraphQL
+ * `transactions.unshieldedCreatedOutputs` field reports the
+ * `(owner, intentHash, outputIndex)` triple for each unshielded UTXO created
+ * in a block (by regular AND system transactions — rewards/bridge mint
+ * unshielded UTXOs). One state-machine input is emitted per created output.
+ *
+ * Lets a node maintain a persistent set of UTXOs that have actually been
+ * created on chain, so an offer referencing a never-created unshielded UTXO
+ * can be rejected (existence check).
+ *
+ * Usage:
+ *   stm.addStateTransition("myPrefix", function* (data) {
+ *     const { payload } = data.parsedInput;
+ *     // payload = { owner, intentHash, outputIndex, txHash }
+ *   });
+ */
+export class MidnightUnshieldedCreatePrimitive extends Primitive<
+  ConfigSyncProtocolType.MIDNIGHT_PARALLEL,
+  typeof midnightUnshieldedCreateGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeMidnightUnshieldedCreate;
+  override readonly grammar = midnightUnshieldedCreateGrammar;
+
+  override dynamicTables = undefined;
+  override getIntermediatePrefix(): string[] {
+    return [];
+  }
+  override getViewPrefix(): string[] {
+    return [];
+  }
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    stateMachinePrefix: string;
+  }) {
+    super(config);
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.MIDNIGHT_PARALLEL
+    >,
+  ): SyncStateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<CommandTuple<string, typeof midnightUnshieldedCreateGrammar>>
+        | null;
+      accountingPayload: ParamToData<typeof midnightUnshieldedCreateGrammar>;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload;
+
+    const accountingPayload: ParamToData<typeof this.grammar> = {
+      payload,
+    };
+
+    const stateMachinePayload:
+      | StaticDecode<CommandTuple<string, typeof this.grammar>>
+      | null = this.stateMachinePrefix
+      ? generateRawStmInput(
+        this.grammar,
+        this.stateMachinePrefix,
+        accountingPayload,
+      )
+      : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.NONE,
+            address: "0x0",
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.MIDNIGHT_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      scheduledPrefix: this.stateMachinePrefix ?? "",
+    } as const;
+  }
+}

package/primitives/src/midnight-zswap-root/midnight-zswap-root-grammar.ts

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+
+export const midnightZswapRootGrammar = [
+  [
+    "payload",
+    Type.Any(),
+  ],
+] as const;

package/primitives/src/midnight-zswap-root/midnight-zswap-root.ts

@@ -0,0 +1,121 @@
+import { Primitive } from "@effectstream/sm";
+import {
+  type AddressAndType,
+  AddressType,
+  type EffectstreamBlockNumber,
+} from "@effectstream/utils";
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+  type ParamToData,
+} from "@effectstream/concise";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  ProtocolPrimitiveMap,
+} from "@effectstream/config";
+import type { SyncStateUpdateStream } from "@effectstream/coroutine";
+import { PrimitiveTypeMidnightZswapRoot } from "../builtin.ts";
+import { midnightZswapRootGrammar } from "./midnight-zswap-root-grammar.ts";
+
+/**
+ * MidnightZswapRootPrimitive
+ *
+ * Emits the zswap coin-commitment Merkle tree root as it advances on chain.
+ * The indexer's `RegularTransaction.zswapMerkleTreeRoot` is the tree root
+ * *after* that transaction; this primitive surfaces the latest such root per
+ * block (the last regular transaction's root), with the block timestamp.
+ *
+ * A node can accumulate these into a windowed "known roots" set (mirroring the
+ * ledger's `past_roots`, retained for the on-chain root window) and reject an
+ * offer that proves against a root the chain never held or that has aged out —
+ * the root-known liveness check. Blocks with no regular transactions emit
+ * nothing (the root is unchanged).
+ *
+ * Usage:
+ *   stm.addStateTransition("myPrefix", function* (data) {
+ *     const { payload } = data.parsedInput;
+ *     // payload = { root, txHash } ; data.blockTimestamp is the window key
+ *   });
+ */
+export class MidnightZswapRootPrimitive extends Primitive<
+  ConfigSyncProtocolType.MIDNIGHT_PARALLEL,
+  typeof midnightZswapRootGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeMidnightZswapRoot;
+  override readonly grammar = midnightZswapRootGrammar;
+
+  override dynamicTables = undefined;
+  override getIntermediatePrefix(): string[] {
+    return [];
+  }
+  override getViewPrefix(): string[] {
+    return [];
+  }
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    stateMachinePrefix: string;
+  }) {
+    super(config);
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.MIDNIGHT_PARALLEL
+    >,
+  ): SyncStateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<CommandTuple<string, typeof midnightZswapRootGrammar>>
+        | null;
+      accountingPayload: ParamToData<typeof midnightZswapRootGrammar>;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload;
+
+    const accountingPayload: ParamToData<typeof this.grammar> = {
+      payload,
+    };
+
+    const stateMachinePayload:
+      | StaticDecode<CommandTuple<string, typeof this.grammar>>
+      | null = this.stateMachinePrefix
+      ? generateRawStmInput(
+        this.grammar,
+        this.stateMachinePrefix,
+        accountingPayload,
+      )
+      : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.NONE,
+            address: "0x0",
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.MIDNIGHT_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      scheduledPrefix: this.stateMachinePrefix ?? "",
+    } as const;
+  }
+}

package/primitives/src/mod.ts

@@ -2,6 +2,9 @@ import {
   PrimitiveTypeMidnightGeneric,
   PrimitiveTypeMidnightNullifier,
   PrimitiveTypeMidnightUnshieldedSpend,
+  PrimitiveTypeMidnightUnshieldedCreate,
+  PrimitiveTypeMidnightZswapRoot,
+  PrimitiveTypeMidnightTokenMint,
   PrimitiveTypeEVMEffectstreamL2,
   PrimitiveTypeEVMERC721,
   PrimitiveTypeEVMERC20,
@@ -27,6 +30,9 @@ import {
 import { MidnightGenericPrimitive } from "./midnight-generic/midnight-genetic.ts";
 import { MidnightNullifierPrimitive } from "./midnight-nullifier/midnight-nullifier.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";
+import { MidnightTokenMintPrimitive } from "./midnight-token-mint/midnight-token-mint.ts";
 import { EffectstreamL2Primitive } from "./evm-effectstream-l2/effectstream-l2-primitive.ts";
 import { Erc721Primitive } from "./evm-erc721/erc721-primitive.ts";
 import { Erc20Primitive } from "./evm-erc20/erc20-primitive.ts";
@@ -52,6 +58,9 @@ const builtInPrimitivesMap = {
   [PrimitiveTypeMidnightGeneric]: MidnightGenericPrimitive,
   [PrimitiveTypeMidnightNullifier]: MidnightNullifierPrimitive,
   [PrimitiveTypeMidnightUnshieldedSpend]: MidnightUnshieldedSpendPrimitive,
+  [PrimitiveTypeMidnightUnshieldedCreate]: MidnightUnshieldedCreatePrimitive,
+  [PrimitiveTypeMidnightZswapRoot]: MidnightZswapRootPrimitive,
+  [PrimitiveTypeMidnightTokenMint]: MidnightTokenMintPrimitive,
   [PrimitiveTypeEVMEffectstreamL2]: EffectstreamL2Primitive,
   [PrimitiveTypeEVMERC721]: Erc721Primitive,
   [PrimitiveTypeEVMERC20]: Erc20Primitive,
@@ -82,6 +91,9 @@ export {
   MidnightGenericPrimitive,
   MidnightNullifierPrimitive,
   MidnightUnshieldedSpendPrimitive,
+  MidnightUnshieldedCreatePrimitive,
+  MidnightZswapRootPrimitive,
+  MidnightTokenMintPrimitive,
   EffectstreamL2Primitive,
   Erc721Primitive,
   Erc20Primitive,