@effectstream/sm 0.100.0

package/primitives/src/evm-erc721/erc721-primitive.ts

@@ -0,0 +1,149 @@
+import { Value } from "@sinclair/typebox/value";
+import { type StaticDecode, Type } from "@sinclair/typebox";
+import {
+  type ConfigSyncProtocolType,
+  type FlattenSyncProtocolIOFor,
+  getEvmEvent,
+  type ProtocolPrimitiveMap,
+} from "@effectstream/config";
+import {
+  type AddressAndType,
+  AddressType,
+  type EvmAddress,
+  type EffectstreamBlockNumber,
+  TypeboxHelpers,
+} 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 { ERC721_VIEW_PREFIX, erc721Ivm } from "./erc721-ivm.ts";
+import { ERC721_INTERMEDIATE_PREFIX } from "./erc721-ivm.ts";
+import { erc721 } from "./erc721-abi.ts";
+import { erc721Grammar } from "./erc721-grammar.ts";
+import { PrimitiveTypeEVMERC721 } from "../builtin.ts";
+
+/**
+ * Erc721 Primitive
+ *
+ * This is a concrete implementation of the Primitive class for ERC721.
+ */
+
+
+  export class Erc721Primitive extends Primitive<
+  ConfigSyncProtocolType.EVM_RPC_PARALLEL,
+  typeof erc721Grammar
+> {
+  // Primitive defined
+  readonly internalTypeName = PrimitiveTypeEVMERC721;
+  readonly abi = getEvmEvent(erc721.abi, "Transfer(address,address,uint256)");
+  override grammar = erc721Grammar;
+  readonly contractAddress: EvmAddress;
+  // Dynamic table to track the owner of each token.
+  override dynamicTables = erc721Ivm;
+  override getIntermediatePrefix(): string[] {
+    return [ERC721_INTERMEDIATE_PREFIX];
+  }
+  override getViewPrefix(): string[] {
+    return [ERC721_VIEW_PREFIX];
+  }
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    contractAddress: EvmAddress;
+    stateMachinePrefix: string | undefined;
+  }) {
+    super(config);
+    this.contractAddress = Value.Decode(
+      TypeboxHelpers.Evm.Address,
+      config.contractAddress,
+    );
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.EVM_RPC_PARALLEL
+    >,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<
+          CommandTuple<string, typeof erc721Grammar>
+        >
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const { to, from } = primitiveTransactionData.output.payload;
+    const toAddr = Value.Decode(TypeboxHelpers.Evm.Address, to.toLowerCase());
+    const fromAddr = Value.Decode(
+      TypeboxHelpers.Evm.Address,
+      from.toLowerCase(),
+    );
+    const isBurn = Boolean(toAddr.toLocaleLowerCase().match(/^0x0+(dead)?$/g));
+    const tokenId = Value.Decode(
+      TypeboxHelpers.Uint256,
+      primitiveTransactionData.output.payload.tokenId,
+    );
+
+    const isBatched = false;
+    const accountingPayload: ParamToData<typeof erc721Grammar> = {
+      to: toAddr,
+      from: fromAddr,
+      tokenId: tokenId,
+      isBurn: isBurn,
+    };
+    const stateMachinePayload:
+      | StaticDecode<
+        CommandTuple<string, typeof this.grammar>
+      >
+      | null = this.stateMachinePrefix
+        ? generateRawStmInput(
+          this.grammar,
+          this.stateMachinePrefix,
+          accountingPayload,
+        )
+        : null;
+
+    return {
+      isBatched,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.NONE,
+            address: "0x0",
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.EVM_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      contractAddress: this.contractAddress as EvmAddress,
+      abi: this.abi,
+      // TODO This should be optional.
+      scheduledPrefix: this.stateMachinePrefix ?? "",
+    } as const;
+  }
+}
+
+// declare module "@effectstream/sm" {
+//   interface PrimitiveGlobalDefinitions {
+//     Erc721Primitive: typeof Erc721Primitive;
+//   }
+// }

package/primitives/src/evm-generic/evm-generic-primitive.ts

@@ -0,0 +1,124 @@
+import type { StaticDecode, TSchema } from "@sinclair/typebox";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  getEvmEvent,
+  ProtocolPrimitiveMap,
+} from "@effectstream/config";
+import {
+  type AddressAndType,
+  AddressType,
+  type EvmAddress,
+  type EffectstreamBlockNumber,
+  TypeboxHelpers,
+} from "@effectstream/utils";
+import { type JsonObject, Primitive } from "@effectstream/sm";
+import { Value } from "@sinclair/typebox/value";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+  type ParamToData,
+} from "@effectstream/concise";
+import type { StateUpdateStream } from "@effectstream/coroutine";
+import { PrimitiveTypeEVMGeneric } from "../builtin.ts";
+
+/**
+ * Erc20 Primitive
+ *
+ * This is a concrete implementation of the Primitive class for ERC20.
+ */
+
+export class EvmGenericPrimitive extends Primitive<
+  ConfigSyncProtocolType.EVM_RPC_PARALLEL,
+  readonly [string, TSchema][]
+> {
+  // Primitive defined
+  readonly internalTypeName = PrimitiveTypeEVMGeneric;
+  readonly abi: ReturnType<typeof getEvmEvent>;
+  override grammar: readonly [string, TSchema][];
+  readonly contractAddress: EvmAddress;
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    contractAddress: EvmAddress;
+    stateMachinePrefix: string | undefined;
+    abi: ReturnType<typeof getEvmEvent>;
+    grammar: readonly [string, TSchema][];
+  }) {
+    super(config);
+    this.contractAddress = Value.Decode(
+      TypeboxHelpers.Evm.Address,
+      config.contractAddress,
+    );
+    this.abi = config.abi;
+    this.grammar = config.grammar;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.EVM_RPC_PARALLEL
+    >,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<
+          CommandTuple<string, any>
+        >
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload;
+    const accountingPayload = this.clearBigInts({
+      ...payload,
+    });
+    const stateMachinePayload: any = this.stateMachinePrefix
+        ? generateRawStmInput(
+          this.grammar,
+          this.stateMachinePrefix,
+          accountingPayload,
+        )
+        : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.NONE,
+            address: "0x0",
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  private clearBigInts<T>(value: T): T {
+    return JSON.parse(
+      JSON.stringify(
+        value,
+        (_, v) => typeof v === "bigint" ? v.toString() : v,
+      ),
+    );
+  }
+
+  
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.EVM_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      contractAddress: this.contractAddress as EvmAddress,
+      abi: this.abi,
+      scheduledPrefix: this.stateMachinePrefix,
+    } as const;
+  }
+}

package/primitives/src/grammar.ts

@@ -0,0 +1,34 @@
+// list of built-in grammars
+// this list is exposed to the effectstream-sdk modules via the @effectstream/sm/grammar module
+
+import { midnightGenericGrammar } from "./midnight-generic/midnight-genetic-grammar.ts";
+import { erc721Grammar } from "./evm-erc721/erc721-grammar.ts";
+import { erc20Grammar } from "./evm-erc20/erc20-grammar.ts";
+import { availGenericGrammar } from "./avail-generic/avail-generic-grammar.ts";
+import { erc1155Grammar } from "./evm-erc1155/erc1155-grammar.ts";
+import { bitcoinAddressGrammar } from "./bitcoin-address/bitcoin-grammar.ts";
+import { utxorpcGenericGrammar } from "./utxorpc-generic/utxorpc-generic-grammar.ts";
+import { celestiaGenericGrammar } from "./celestia-generic/celestia-generic-grammar.ts";
+import { nep141Grammar } from "./near-nep141/nep141-grammar.ts";
+import { nep171Grammar } from "./near-nep171/nep171-grammar.ts";
+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";
+
+export const builtinGrammars = {
+  midnightGeneric: midnightGenericGrammar,
+  evmErc721: erc721Grammar,
+  evmErc20: erc20Grammar,
+  availGeneric: availGenericGrammar,
+  evmErc1155: erc1155Grammar,
+  bitcoinAddress: bitcoinAddressGrammar,
+  utxorpcGeneric: utxorpcGenericGrammar,
+  celestiaGeneric: celestiaGenericGrammar,
+  nearNep141: nep141Grammar,
+  nearNep171: nep171Grammar,
+  nearNep245: nep245Grammar,
+  nearIntent: nearIntentGrammar,
+  nearGeneric: nearGenericGrammar,
+  nearAccountWatch: nearAccountWatchGrammar,
+} as const;

package/primitives/src/midnight-generic/midnight-genetic-grammar.ts

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

package/primitives/src/midnight-generic/midnight-genetic.ts

@@ -0,0 +1,271 @@
+import { Primitive } from "@effectstream/sm";
+import {
+  type AddressAndType,
+  AddressType,
+  type MidnightAddress,
+  type EffectstreamBlockNumber,
+  uint8ArrayToHexString,
+} from "@effectstream/utils";
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+  type ParamToData,
+} from "@effectstream/concise";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  LedgerFieldType,
+  LedgerSchema,
+  ProtocolPrimitiveMap,
+  StateValue,
+} from "@effectstream/config";
+import type { SyncStateUpdateStream } from "@effectstream/coroutine";
+import { PrimitiveTypeMidnightGeneric } from "../builtin.ts";
+import { midnightGenericGrammar } from "./midnight-genetic-grammar.ts"
+
+
+export class MidnightGenericPrimitive extends Primitive<
+  ConfigSyncProtocolType.MIDNIGHT_PARALLEL,
+  typeof midnightGenericGrammar
+> {
+  // Primitive defined
+  readonly internalTypeName = PrimitiveTypeMidnightGeneric;
+  override readonly grammar = midnightGenericGrammar;
+  readonly contractAddress: string;
+  readonly contract: {
+    ledger: (data: StateValue) => any;
+  };
+  readonly ledgerSchema?: LedgerSchema;
+  readonly networkId: string;
+  readonly genesisHash: string;
+  // No dynamic tables for midnight generic primitive
+  override dynamicTables = undefined;
+  override getIntermediatePrefix(): string[] {
+    return [];
+  }
+  override getViewPrefix(): string[] {
+    return [];
+  }
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    contractAddress: MidnightAddress;
+    stateMachinePrefix: string;
+    contract: {
+      ledger: (data: StateValue) => any;
+    };
+    ledgerSchema?: LedgerSchema;
+    networkId?: string;
+    genesisHash?: string;
+  }) {
+    super(config);
+    this.contractAddress = config.contractAddress;
+    this.contract = config.contract;
+    this.ledgerSchema = config.ledgerSchema;
+    this.networkId = config.networkId ?? "undeployed";
+    this.genesisHash = config.genesisHash || "";
+  }
+
+  /**
+   * Parses ledger fields from the raw Midnight StateValue using the `ledgerSchema`.
+   * The schema keys must be in Compact declaration order — the parser maps each key
+   * to the corresponding positional index in the state array.
+   */
+  parseAdditionalLedgerFields(stateValue: StateValue): Record<string, any> {
+    if (!this.ledgerSchema) return {};
+
+    const stateArray: StateValue[] = stateValue.asArray?.() ?? [];
+    const result: Record<string, any> = {};
+    const schemaEntries = Object.entries(this.ledgerSchema);
+
+    for (let i = 0; i < schemaEntries.length && i < stateArray.length; i++) {
+      const [fieldName, fieldType] = schemaEntries[i];
+      result[fieldName] = parseLedgerField(stateArray[i], fieldType);
+    }
+
+    return result;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.MIDNIGHT_PARALLEL
+    >,
+  ): SyncStateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<CommandTuple<string, typeof midnightGenericGrammar>>
+        | null;
+      accountingPayload: ParamToData<typeof midnightGenericGrammar>;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload;
+    try {
+      const isBatched = false;
+     
+      const accountingPayload: ParamToData<typeof this.grammar> = {
+        payload: makeJsonSafe(payload),
+      };
+     
+      const stateMachinePayload:
+        | StaticDecode<
+          CommandTuple<string, typeof this.grammar>
+        >
+        | null = this.stateMachinePrefix
+          ? generateRawStmInput(
+            this.grammar,
+            this.stateMachinePrefix,
+            accountingPayload,
+          )
+          : null;
+
+      return {
+        isBatched,
+        data: [
+          {
+            fromAddressAndType: {
+              type: AddressType.NONE,
+              address: "0x0",
+            },
+            accountingPayload,
+            stateMachinePayload,
+          },
+        ],
+      };
+    } catch (error) {
+      console.error(
+        "[ERROR] Decoding Midnight Generic Payload:",
+        JSON.stringify(payload),
+      );
+      throw error;
+    }
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.MIDNIGHT_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      contractAddress: this.contractAddress,
+      // TODO This should be optional
+      scheduledPrefix: this.stateMachinePrefix ?? "",
+      contract: this.contract,
+      parseAdditionalLedgerFields: this.ledgerSchema
+        ? this.parseAdditionalLedgerFields.bind(this)
+        : undefined,
+      // FIXME: historically we relied on NetworkId enum values, but
+      // the v1 runtime expects canonical string identifiers instead.
+      networkId: this.networkId,
+      // TODO This is unused for now.
+      genesisHash: this.genesisHash || "",
+    } as const;
+  }
+}
+
+function alignedValueToHex(value: { value: Uint8Array[] }): string {
+  return (
+    "0x" +
+    value.value
+      .map((chunk: Uint8Array) =>
+        Array.from(chunk)
+          .map((b: number) => b.toString(16).padStart(2, "0"))
+          .join("")
+      )
+      .join("")
+  );
+}
+
+function parseUintCellLittleEndian(chunks: Uint8Array[]): string {
+  let result = 0n;
+  let shift = 0n;
+  for (const chunk of chunks) {
+    for (const byte of chunk) {
+      result |= BigInt(byte) << shift;
+      shift += 8n;
+    }
+  }
+  return result.toString();
+}
+
+function parseLedgerField(sv: StateValue, type: LedgerFieldType): any {
+  if (typeof type === "object" && type.type === "option") {
+    if (sv.type() === "null") return null;
+    return parseLedgerField(sv, type.value);
+  }
+
+  if (typeof type === "object" && type.type === "map") {
+    const map = sv.asMap();
+    if (!map) return {};
+
+    const result: Record<string, any> = {};
+    for (const key of map.keys()) {
+      const val = map.get(key);
+      if (val !== undefined) {
+        result[alignedValueToHex(key as { value: Uint8Array[] })] = parseLedgerField(
+          val,
+          type.value,
+        );
+      }
+    }
+    return result;
+  }
+
+  if (sv.type() !== "cell") return null;
+  const cell = sv.asCell();
+
+  if (
+    type === "uint8" ||
+    type === "uint16" ||
+    type === "uint32" ||
+    type === "uint64" ||
+    type === "uint128"
+  ) {
+    return parseUintCellLittleEndian(cell.value as Uint8Array[]);
+  }
+
+  if (type === "bytes") {
+    return alignedValueToHex(cell as { value: Uint8Array[] });
+  }
+
+  if (type === "boolean") {
+    return (cell.value as Uint8Array[]).some((chunk: Uint8Array) =>
+      chunk.some((b: number) => b !== 0)
+    );
+  }
+
+  return null;
+}
+
+function makeJsonSafe(data: unknown): any {
+  if (typeof data === 'boolean' || typeof data === 'number' || typeof data === 'string') {
+    return data;
+  }
+  if (typeof data === 'bigint') {
+    return data.toString();
+  }
+  if (data === null || data === undefined) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map(makeJsonSafe);
+  }
+  if (data instanceof Uint8Array) {
+    return uint8ArrayToHexString(data);
+  }
+  if (typeof data === 'object') {
+    return Object.fromEntries(Object.entries(data).map(([k, v]) => [k, makeJsonSafe(v)]));
+  }
+  return data;
+}
+
+// declare module "@effectstream/sm" {
+//   interface PrimitiveGlobalDefinitions {
+//     MidnightGenericPrimitive: typeof MidnightGenericPrimitive;
+//   }
+// }

package/primitives/src/midnight-nullifier/midnight-nullifier-grammar.ts

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

package/primitives/src/midnight-nullifier/midnight-nullifier.ts

@@ -0,0 +1,114 @@
+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 { PrimitiveTypeMidnightNullifier } from "../builtin.ts";
+import { midnightNullifierGrammar } from "./midnight-nullifier-grammar.ts";
+
+/**
+ * MidnightNullifierPrimitive
+ *
+ * Watches all ZswapInput (nullifier-spend) events on the Midnight shielded
+ * ledger.  One state-machine input is emitted per nullifier event observed in
+ * a block, regardless of which contract produced it.
+ *
+ * Usage:
+ *   stm.addStateTransition("myPrefix", function* (data) {
+ *     const { payload } = data.parsedInput;
+ *     // payload = { nullifier, txHash, eventId, logicalSegment }
+ *   });
+ */
+export class MidnightNullifierPrimitive extends Primitive<
+  ConfigSyncProtocolType.MIDNIGHT_PARALLEL,
+  typeof midnightNullifierGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeMidnightNullifier;
+  override readonly grammar = midnightNullifierGrammar;
+
+  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 midnightNullifierGrammar>>
+        | null;
+      accountingPayload: ParamToData<typeof midnightNullifierGrammar>;
+    }[];
+  }> {
+    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;
+  }
+}