@effectstream/sm 0.100.0

package/primitives/src/mod.ts

@@ -0,0 +1,81 @@
+import {
+  PrimitiveTypeMidnightGeneric,
+  PrimitiveTypeMidnightNullifier,
+  PrimitiveTypeEVMEffectstreamL2,
+  PrimitiveTypeEVMERC721,
+  PrimitiveTypeEVMERC20,
+  PrimitiveTypeAvailGeneric,
+  PrimitiveTypeEVMERC1155,
+  PrimitiveTypeBitcoinAddress,
+  PrimitiveTypeUtxorpcGeneric,
+  PrimitiveTypeCelestiaGeneric,
+  PrimitiveTypeNEARNEP141,
+  PrimitiveTypeNEARNEP171,
+  PrimitiveTypeNEARNEP245,
+  PrimitiveTypeNEARIntent,
+  PrimitiveTypeNEARGeneric,
+  PrimitiveTypeNEARAccountWatch,
+//   PrimitiveTypeEVMGeneric,
+} from "./builtin.ts";
+
+import { MidnightGenericPrimitive } from "./midnight-generic/midnight-genetic.ts";
+import { MidnightNullifierPrimitive } from "./midnight-nullifier/midnight-nullifier.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";
+import { AvailGenericPrimitive } from "./avail-generic/avail-primitive.ts";
+import { Erc1155Primitive } from "./evm-erc1155/erc1155-primitive.ts";
+import { BitcoinAddressPrimitive } from "./bitcoin-address/bitcoin-primitive.ts";
+import { UtxorpcGenericPrimitive } from "./utxorpc-generic/utxorpc-generic.ts";
+import { CelestiaGenericPrimitive } from "./celestia-generic/celestia-primitive.ts";
+import { Nep141Primitive } from "./near-nep141/nep141-primitive.ts";
+import { Nep171Primitive } from "./near-nep171/nep171-primitive.ts";
+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 { EvmGenericPrimitive } from "./evm-generic/evm-generic-primitive.ts";
+
+const builtInPrimitivesMap = {
+  [PrimitiveTypeMidnightGeneric]: MidnightGenericPrimitive,
+  [PrimitiveTypeMidnightNullifier]: MidnightNullifierPrimitive,
+  [PrimitiveTypeEVMEffectstreamL2]: EffectstreamL2Primitive,
+  [PrimitiveTypeEVMERC721]: Erc721Primitive,
+  [PrimitiveTypeEVMERC20]: Erc20Primitive,
+  [PrimitiveTypeAvailGeneric]: AvailGenericPrimitive,
+  [PrimitiveTypeEVMERC1155]: Erc1155Primitive,
+  [PrimitiveTypeBitcoinAddress]: BitcoinAddressPrimitive,
+  [PrimitiveTypeUtxorpcGeneric]: UtxorpcGenericPrimitive,
+  [PrimitiveTypeCelestiaGeneric]: CelestiaGenericPrimitive,
+  [PrimitiveTypeNEARNEP141]: Nep141Primitive,
+  [PrimitiveTypeNEARNEP171]: Nep171Primitive,
+  [PrimitiveTypeNEARNEP245]: Nep245Primitive,
+  [PrimitiveTypeNEARIntent]: NearIntentPrimitive,
+  [PrimitiveTypeNEARGeneric]: NearGenericPrimitive,
+  [PrimitiveTypeNEARAccountWatch]: NearAccountWatchPrimitive,
+//   [PrimitiveTypeEVMGeneric]: EvmGenericPrimitive,
+} as const;
+
+export {
+  // Built-in Primitives Map
+  builtInPrimitivesMap,
+
+  // Built-in Primitives
+  MidnightGenericPrimitive,
+  MidnightNullifierPrimitive,
+  EffectstreamL2Primitive,
+  Erc721Primitive,
+  Erc20Primitive,
+  AvailGenericPrimitive,
+  Erc1155Primitive,
+  BitcoinAddressPrimitive,
+  UtxorpcGenericPrimitive,
+  CelestiaGenericPrimitive,
+  Nep141Primitive,
+  Nep171Primitive,
+  Nep245Primitive,
+  NearIntentPrimitive,
+  NearGenericPrimitive,
+  NearAccountWatchPrimitive,
+  // EvmGenericPrimitive,
+};

package/primitives/src/near-account-watch/near-account-watch-grammar.ts

@@ -0,0 +1,10 @@
+import { Type } from "@sinclair/typebox";
+
+export const nearAccountWatchGrammar = [
+  ['signer_id', Type.String()],
+  ['receiver_id', Type.String()],
+  ['method_name', Type.String()],
+  ['args', Type.String()],
+  ['deposit', Type.String()],
+  ['status', Type.String()],
+] as const;

package/primitives/src/near-account-watch/near-account-watch-primitive.ts

@@ -0,0 +1,106 @@
+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 { nearAccountWatchGrammar } from "./near-account-watch-grammar.ts";
+import { PrimitiveTypeNEARAccountWatch } from "../builtin.ts";
+
+export class NearAccountWatchPrimitive extends Primitive<
+  ConfigSyncProtocolType.NEAR_RPC_PARALLEL,
+  typeof nearAccountWatchGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeNEARAccountWatch;
+  override grammar = nearAccountWatchGrammar;
+  readonly contractId: string;
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    contractId: string;
+    stateMachinePrefix: string | undefined;
+  }) {
+    super(config);
+    this.contractId = config.contractId;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.NEAR_RPC_PARALLEL
+    >,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<CommandTuple<string, typeof nearAccountWatchGrammar>>
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload as Record<string, unknown>;
+    const signerId = String(payload.signer_id ?? "");
+    const receiverId = String(payload.receiver_id ?? "");
+    const methodName = String(payload.method_name ?? "");
+    const args = String(payload.args ?? "");
+    const deposit = String(payload.deposit ?? "0");
+    const status = String(payload.status ?? "unknown");
+
+    const accountingPayload: ParamToData<typeof nearAccountWatchGrammar> = {
+      signer_id: signerId,
+      receiver_id: receiverId,
+      method_name: methodName,
+      args,
+      deposit,
+      status,
+    };
+
+    const stateMachinePayload = this.stateMachinePrefix
+      ? generateRawStmInput(
+        this.grammar,
+        this.stateMachinePrefix,
+        accountingPayload,
+      )
+      : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.NEAR,
+            address: signerId,
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.NEAR_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      contractId: this.contractId,
+      scheduledPrefix: this.stateMachinePrefix,
+    };
+  }
+}

package/primitives/src/near-generic/near-generic-grammar.ts

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

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

@@ -0,0 +1,105 @@
+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 { nearGenericGrammar } from "./near-generic-grammar.ts";
+import { PrimitiveTypeNEARGeneric } from "../builtin.ts";
+
+export class NearGenericPrimitive extends Primitive<
+  ConfigSyncProtocolType.NEAR_RPC_PARALLEL,
+  typeof nearGenericGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeNEARGeneric;
+  override grammar = nearGenericGrammar;
+  readonly contractId: string;
+  readonly eventStandard: string;
+  readonly eventType: string;
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    contractId: string;
+    eventStandard: string;
+    eventType: string;
+    stateMachinePrefix: string | undefined;
+  }) {
+    super(config);
+    this.contractId = config.contractId;
+    this.eventStandard = config.eventStandard;
+    this.eventType = config.eventType;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.NEAR_RPC_PARALLEL
+    >,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<CommandTuple<string, typeof nearGenericGrammar>>
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload;
+
+    const accountingPayload: ParamToData<typeof nearGenericGrammar> = {
+      payload,
+    };
+
+    const stateMachinePayload = this.stateMachinePrefix
+      ? generateRawStmInput(
+        this.grammar,
+        this.stateMachinePrefix,
+        accountingPayload,
+      )
+      : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.NEAR,
+            address: String(
+              primitiveTransactionData.syncProtocol.contractAddress ?? "",
+            ),
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.NEAR_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      contractId: this.contractId,
+      eventStandard: this.eventStandard,
+      eventType: this.eventType,
+      scheduledPrefix: this.stateMachinePrefix,
+    };
+  }
+}

package/primitives/src/near-intent/near-intent-grammar.ts

@@ -0,0 +1,10 @@
+import { Type } from "@sinclair/typebox";
+
+export const nearIntentGrammar = [
+  ['account_id', Type.String()],
+  ['intent_hash', Type.String()],
+  ['token_diffs', Type.Array(Type.Object({
+    token_id: Type.String(),
+    amount: Type.String(),
+  }))],
+] as const;

package/primitives/src/near-intent/near-intent-ivm.ts

@@ -0,0 +1,71 @@
+import { PrimitiveTypeNEARIntent } from "../builtin.ts";
+
+export function nearIntentIvm(name: string) {
+  const lowerName = name.toLowerCase();
+  const validSQLName = lowerName.replace(/[^a-zA-Z0-9_]/g, "");
+  if (validSQLName !== lowerName) {
+    throw new Error(`Invalid name: ${name}`);
+  }
+
+  const settlementTable = `primitives.near_intent_settlement_intermediate_${validSQLName}`;
+
+  return `
+    CREATE TABLE IF NOT EXISTS ${settlementTable} (
+        primitive_name TEXT NOT NULL,
+        intent_hash TEXT NOT NULL,
+        account_id TEXT NOT NULL,
+        token_id TEXT NOT NULL,
+        amount numeric(78,0) DEFAULT 0,
+        block_height INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (primitive_name, intent_hash, account_id, token_id)
+    );
+
+    CREATE OR REPLACE FUNCTION update_near_intent_settlement_${validSQLName}() RETURNS TRIGGER AS $$
+    DECLARE
+        diff_item JSONB;
+    BEGIN
+        IF NEW.payload_type = '${PrimitiveTypeNEARIntent}'
+           AND NEW.primitive_name = '${name}'
+           AND (NEW.payload::jsonb)->'token_diffs' IS NOT NULL THEN
+
+         FOR diff_item IN SELECT * FROM jsonb_array_elements((NEW.payload::jsonb)->'token_diffs')
+         LOOP
+             INSERT INTO ${settlementTable} (primitive_name, intent_hash, account_id, token_id, amount, block_height)
+             VALUES (
+                 NEW.primitive_name,
+                 (NEW.payload::jsonb)->>'intent_hash',
+                 (NEW.payload::jsonb)->>'account_id',
+                 diff_item->>'token_id',
+                 (diff_item->>'amount')::numeric(78,0),
+                 NEW.effectstream_block_height
+             )
+             ON CONFLICT (primitive_name, intent_hash, account_id, token_id) DO UPDATE SET
+                 amount = (diff_item->>'amount')::numeric(78,0),
+                 block_height = NEW.effectstream_block_height;
+         END LOOP;
+        END IF;
+
+        RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+
+    CREATE TRIGGER trigger_update_near_intent_settlement_${validSQLName}
+        AFTER INSERT ON effectstream.primitive_accounting
+        FOR EACH ROW
+        EXECUTE FUNCTION update_near_intent_settlement_${validSQLName}();
+
+    SELECT pgivm.create_immv('primitives.near_intent_settlement_view_${validSQLName}',
+        'SELECT
+            primitive_name,
+            intent_hash,
+            account_id,
+            token_id,
+            amount,
+            block_height
+        FROM ${settlementTable};
+    ');
+    `;
+}
+
+export const NEAR_INTENT_VIEW_PREFIX = "near_intent_settlement_view_" as const;
+export const NEAR_INTENT_INTERMEDIATE_PREFIX = "near_intent_settlement_intermediate_" as const;

package/primitives/src/near-intent/near-intent-primitive.ts

@@ -0,0 +1,149 @@
+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 { nearIntentGrammar } from "./near-intent-grammar.ts";
+import {
+  NEAR_INTENT_INTERMEDIATE_PREFIX,
+  NEAR_INTENT_VIEW_PREFIX,
+  nearIntentIvm,
+} from "./near-intent-ivm.ts";
+import { PrimitiveTypeNEARIntent } from "../builtin.ts";
+import { matchesGlob } from "./near-intent-token-id-parser.ts";
+
+export class NearIntentPrimitive extends Primitive<
+  ConfigSyncProtocolType.NEAR_RPC_PARALLEL,
+  typeof nearIntentGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeNEARIntent;
+  override grammar = nearIntentGrammar;
+  readonly contractId: string;
+  readonly filterTokenIds: string[];
+  readonly filterAccountIds: string[];
+
+  override dynamicTables = nearIntentIvm;
+  override getIntermediatePrefix(): string[] {
+    return [NEAR_INTENT_INTERMEDIATE_PREFIX];
+  }
+  override getViewPrefix(): string[] {
+    return [NEAR_INTENT_VIEW_PREFIX];
+  }
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    contractId: string;
+    stateMachinePrefix: string | undefined;
+    filterTokenIds?: string[];
+    filterAccountIds?: string[];
+  }) {
+    super(config);
+    this.contractId = config.contractId;
+    this.filterTokenIds = config.filterTokenIds ?? [];
+    this.filterAccountIds = config.filterAccountIds ?? [];
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.NEAR_RPC_PARALLEL
+    >,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<CommandTuple<string, typeof nearIntentGrammar>>
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload as Record<string, unknown>;
+    const accountId = String(payload.account_id ?? "");
+    const intentHash = String(payload.intent_hash ?? "");
+
+    // Apply account filter
+    if (
+      this.filterAccountIds.length > 0 &&
+      !this.filterAccountIds.some((p) => matchesGlob(p, accountId))
+    ) {
+      return { isBatched: false, data: [] };
+    }
+
+    // Parse DIP-4 diff object into token_diffs array
+    const diff = (payload.diff ?? {}) as Record<string, string>;
+    const tokenDiffs: { token_id: string; amount: string }[] = [];
+    for (const [tokenId, amount] of Object.entries(diff)) {
+      // Apply token filter
+      if (
+        this.filterTokenIds.length > 0 &&
+        !this.filterTokenIds.some((p) => matchesGlob(p, tokenId))
+      ) {
+        continue;
+      }
+      tokenDiffs.push({ token_id: tokenId, amount: String(amount) });
+    }
+
+    if (tokenDiffs.length === 0) {
+      return { isBatched: false, data: [] };
+    }
+
+    const accountingPayload: ParamToData<typeof nearIntentGrammar> = {
+      account_id: accountId,
+      intent_hash: intentHash,
+      token_diffs: tokenDiffs,
+    };
+
+    const stateMachinePayload = this.stateMachinePrefix
+      ? generateRawStmInput(
+        this.grammar,
+        this.stateMachinePrefix,
+        accountingPayload,
+      )
+      : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.NEAR,
+            address: accountId,
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.NEAR_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      contractId: this.contractId,
+      eventStandard: "dip4",
+      eventType: "token_diff",
+      filterTokenIds: this.filterTokenIds,
+      filterAccountIds: this.filterAccountIds,
+      scheduledPrefix: this.stateMachinePrefix,
+    };
+  }
+}

package/primitives/src/near-intent/near-intent-token-id-parser.ts

@@ -0,0 +1,47 @@
+/**
+ * Parses a NEAR Intents Verifier namespaced token ID.
+ *
+ * Token IDs follow the format: `standard:contract[:localId]`
+ * Examples:
+ *   "nep141:wrap.near"           → { standard: "nep141", contract: "wrap.near", localId: null }
+ *   "nep171:nft.near:token42"    → { standard: "nep171", contract: "nft.near", localId: "token42" }
+ *   "nep245:game.near:sword"     → { standard: "nep245", contract: "game.near", localId: "sword" }
+ */
+export type ParsedTokenId = {
+  standard: string;
+  contract: string;
+  localId: string | null;
+};
+
+export function parseIntentTokenId(tokenId: string): ParsedTokenId {
+  const firstColon = tokenId.indexOf(":");
+  if (firstColon === -1) {
+    return { standard: "unknown", contract: tokenId, localId: null };
+  }
+
+  const standard = tokenId.slice(0, firstColon);
+  const rest = tokenId.slice(firstColon + 1);
+
+  const secondColon = rest.indexOf(":");
+  if (secondColon === -1) {
+    return { standard, contract: rest, localId: null };
+  }
+
+  return {
+    standard,
+    contract: rest.slice(0, secondColon),
+    localId: rest.slice(secondColon + 1),
+  };
+}
+
+/**
+ * Simple glob matcher supporting `*` (matches any characters except `.`)
+ * and `**` or trailing `*` (matches everything).
+ */
+export function matchesGlob(pattern: string, value: string): boolean {
+  const regex = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*\*/g, ".*")
+    .replace(/\*/g, "[^.]*");
+  return new RegExp(`^${regex}$`).test(value);
+}

package/primitives/src/near-nep141/nep141-grammar.ts

@@ -0,0 +1,7 @@
+import { Type } from "@sinclair/typebox";
+
+export const nep141Grammar = [
+  ['old_owner_id', Type.String()],
+  ['new_owner_id', Type.String()],
+  ['amount', Type.String()],
+] as const;

package/primitives/src/near-nep141/nep141-ivm.ts

@@ -0,0 +1,70 @@
+import { PrimitiveTypeNEARNEP141 } from "../builtin.ts";
+
+export function nep141Ivm(name: string) {
+  const lowerName = name.toLowerCase();
+  const validSQLName = lowerName.replace(/[^a-zA-Z0-9_]/g, "");
+  if (validSQLName !== lowerName) {
+    throw new Error(`Invalid name: ${name}`);
+  }
+
+  const balanceTable = `primitives.nep141_balance_intermediate_${validSQLName}`;
+
+  return `
+    CREATE TABLE IF NOT EXISTS ${balanceTable} (
+        primitive_name TEXT NOT NULL,
+        account_id TEXT NOT NULL,
+        balance numeric(78,0) DEFAULT 0,
+        PRIMARY KEY (primitive_name, account_id)
+    );
+
+    CREATE OR REPLACE FUNCTION update_nep141_balance_${validSQLName}() RETURNS TRIGGER AS $$
+    DECLARE
+        transfer_amount numeric(78,0);
+        from_account TEXT;
+        to_account TEXT;
+    BEGIN
+        IF NEW.payload_type = '${PrimitiveTypeNEARNEP141}'
+           AND NEW.primitive_name = '${name}'
+           AND NEW.payload->>'amount' IS NOT NULL THEN
+
+         transfer_amount := (NEW.payload->>'amount')::numeric(78,0);
+         from_account := NEW.payload->>'old_owner_id';
+         to_account := NEW.payload->>'new_owner_id';
+
+         IF from_account IS NOT NULL AND from_account != '' THEN
+             INSERT INTO ${balanceTable} (primitive_name, account_id, balance)
+             VALUES (NEW.primitive_name, from_account, -transfer_amount)
+             ON CONFLICT (primitive_name, account_id) DO UPDATE SET
+                 balance = ${balanceTable}.balance - transfer_amount;
+         END IF;
+
+         IF to_account IS NOT NULL AND to_account != '' THEN
+             INSERT INTO ${balanceTable} (primitive_name, account_id, balance)
+             VALUES (NEW.primitive_name, to_account, transfer_amount)
+             ON CONFLICT (primitive_name, account_id) DO UPDATE SET
+                 balance = ${balanceTable}.balance + transfer_amount;
+         END IF;
+        END IF;
+
+        RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+
+    CREATE TRIGGER trigger_update_nep141_balance_${validSQLName}
+        AFTER INSERT ON effectstream.primitive_accounting
+        FOR EACH ROW
+        EXECUTE FUNCTION update_nep141_balance_${validSQLName}();
+
+    SELECT pgivm.create_immv('primitives.nep141_balance_view_${validSQLName}',
+        'SELECT
+            primitive_name,
+            account_id,
+            balance
+        FROM ${balanceTable}
+        WHERE balance > 0;
+    ');
+    `;
+}
+
+export const NEP141_VIEW_PREFIX = "nep141_balance_view_" as const;
+export const NEP141_INTERMEDIATE_PREFIX = "nep141_balance_intermediate_" as const;