@effectstream/sm 0.100.12 → 0.100.14

package/package.json

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

package/primitives/src/builtin.ts

@@ -2,8 +2,14 @@
 // this list is exposed to the effectstream-sdk modules via the @effectstream/sm/builtin module
 export const PrimitiveTypeMidnightGeneric = "Midnight:Generic" as const;
 export const PrimitiveTypeMidnightNullifier = "Midnight:Nullifier" as const;
+export const PrimitiveTypeMidnightUnshieldedSpend = "Midnight:UnshieldedSpend" as const;
 
 export const PrimitiveTypeUtxorpcGeneric = "Utxorpc:Generic" as const;
+export const PrimitiveTypeCardanoMintBurn = "Cardano:MintBurn" as const;
+export const PrimitiveTypeCardanoTransfer = "Cardano:Transfer" as const;
+export const PrimitiveTypeCardanoPoolDelegation = "Cardano:PoolDelegation" as const;
+export const PrimitiveTypeCardanoDelayedAsset = "Cardano:DelayedAsset" as const;
+export const PrimitiveTypeCardanoProjectedNFT = "Cardano:ProjectedNFT" as const;
 
 export const PrimitiveTypeEVMEffectstreamL2 = "EVM:EffectstreamL2" as const;
 export const PrimitiveTypeEVMERC721 = "EVM:ERC721" as const;
@@ -27,12 +33,18 @@ export const PrimitiveTypeNEARAccountWatch = "NEAR:AccountWatch" as const;
 type BuiltInPrimitives =
     typeof PrimitiveTypeMidnightGeneric |
     typeof PrimitiveTypeMidnightNullifier |
+    typeof PrimitiveTypeMidnightUnshieldedSpend |
     typeof PrimitiveTypeEVMEffectstreamL2 |
     typeof PrimitiveTypeEVMERC721 |
     typeof PrimitiveTypeEVMERC20 |
     typeof PrimitiveTypeAvailGeneric |
     typeof PrimitiveTypeEVMERC1155 |
     typeof PrimitiveTypeUtxorpcGeneric |
+    typeof PrimitiveTypeCardanoMintBurn |
+    typeof PrimitiveTypeCardanoTransfer |
+    typeof PrimitiveTypeCardanoPoolDelegation |
+    typeof PrimitiveTypeCardanoDelayedAsset |
+    typeof PrimitiveTypeCardanoProjectedNFT |
     typeof PrimitiveTypeBitcoinAddress |
     typeof PrimitiveTypeCelestiaGeneric |
     typeof PrimitiveTypeNEARNEP141 |

package/primitives/src/cardano-delayed-asset/delayed-asset-grammar.ts

@@ -0,0 +1,11 @@
+import { Type } from "@sinclair/typebox";
+
+export const delayedAssetGrammar = [
+  ["address", Type.String()],
+  ["txId", Type.String()],
+  ["outputIndex", Type.String()],
+  ["cip14Fingerprint", Type.String()],
+  ["amount", Type.String()],
+  ["policyId", Type.String()],
+  ["assetName", Type.String()],
+] as const;

package/primitives/src/cardano-delayed-asset/delayed-asset-ivm.ts

@@ -0,0 +1,89 @@
+import { PrimitiveTypeCardanoDelayedAsset } from "../builtin.ts";
+
+export function delayedAssetIvm(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 intermediateTable = `primitives.cardano_asset_utxos_intermediate_${validSQLName}`;
+
+  return `
+    CREATE TABLE IF NOT EXISTS ${intermediateTable} (
+        primitive_name TEXT NOT NULL,
+        tx_id TEXT NOT NULL,
+        output_index INTEGER NOT NULL,
+        address TEXT NOT NULL,
+        cip14_fingerprint TEXT NOT NULL,
+        policy_id TEXT NOT NULL,
+        asset_name TEXT NOT NULL,
+        amount TEXT NOT NULL,
+        block_height INTEGER NOT NULL,
+        PRIMARY KEY (primitive_name, tx_id, output_index, cip14_fingerprint)
+    );
+
+    CREATE OR REPLACE FUNCTION update_delayed_asset_${validSQLName}() RETURNS TRIGGER AS $$
+    DECLARE
+        v_amount TEXT;
+    BEGIN
+        IF NEW.payload_type = '${PrimitiveTypeCardanoDelayedAsset}'
+           AND NEW.primitive_name = '${name}' THEN
+
+            v_amount := NEW.payload->>'amount';
+
+            IF v_amount IS NOT NULL AND v_amount != '' THEN
+                INSERT INTO ${intermediateTable} (
+                    primitive_name, tx_id, output_index, address,
+                    cip14_fingerprint, policy_id, asset_name, amount, block_height
+                ) VALUES (
+                    NEW.primitive_name,
+                    NEW.payload->>'txId',
+                    (NEW.payload->>'outputIndex')::INTEGER,
+                    NEW.payload->>'address',
+                    NEW.payload->>'cip14Fingerprint',
+                    NEW.payload->>'policyId',
+                    NEW.payload->>'assetName',
+                    v_amount,
+                    NEW.effectstream_block_height
+                )
+                ON CONFLICT (primitive_name, tx_id, output_index, cip14_fingerprint) DO UPDATE SET
+                    address = EXCLUDED.address,
+                    amount = EXCLUDED.amount,
+                    block_height = EXCLUDED.block_height;
+            ELSE
+                DELETE FROM ${intermediateTable}
+                WHERE primitive_name = NEW.primitive_name
+                  AND tx_id = NEW.payload->>'txId'
+                  AND output_index = (NEW.payload->>'outputIndex')::INTEGER
+                  AND cip14_fingerprint = NEW.payload->>'cip14Fingerprint';
+            END IF;
+        END IF;
+
+        RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+
+    CREATE TRIGGER trigger_update_delayed_asset_${validSQLName}
+        AFTER INSERT ON effectstream.primitive_accounting
+        FOR EACH ROW
+        EXECUTE FUNCTION update_delayed_asset_${validSQLName}();
+
+    SELECT pgivm.create_immv('primitives.cardano_asset_utxos_view_${validSQLName}',
+        'SELECT
+            primitive_name,
+            tx_id,
+            output_index,
+            address,
+            cip14_fingerprint,
+            policy_id,
+            asset_name,
+            amount,
+            block_height
+        FROM ${intermediateTable};
+    ');
+    `;
+}
+
+export const DELAYED_ASSET_VIEW_PREFIX = "cardano_asset_utxos_view_" as const;
+export const DELAYED_ASSET_INTERMEDIATE_PREFIX = "cardano_asset_utxos_intermediate_" as const;

package/primitives/src/cardano-delayed-asset/delayed-asset-primitive.ts

@@ -0,0 +1,228 @@
+/**
+ * Cardano Delayed Asset Primitive
+ *
+ * Tracks the lifecycle of native asset UTxOs — creation and spending — from Dolos
+ * UTxORPC block data. "Delayed" because asset ownership only becomes final after the
+ * UTxO is confirmed on-chain (unlike account-model chains where balances update instantly).
+ *
+ * Data source: Dolos streams raw Cardano blocks via gRPC. Dolos resolves input UTxO
+ * references via its ledger state (Pallas `LedgerContext` trait), so `tx.inputs[].asOutput`
+ * contains the full resolved output including address and native assets.
+ *
+ * Extraction: `getPayload()` performs two scans per transaction:
+ *   1. **Creations**: iterates `tx.outputs` — for each output containing native assets
+ *      matching configured `policyIds`, emits an entry with `amount = quantity`.
+ *   2. **Spendings**: iterates `tx.inputs` — for each resolved input (`asOutput`) with
+ *      matching assets, emits an entry with `amount = null` (signals UTxO consumed).
+ *
+ * Predicate: uses `moves_asset` with configured policy IDs, so Dolos only sends
+ * transactions that create or spend UTxOs containing those assets.
+ *
+ * IVM: maintains a materialized view of live (unspent) asset UTxOs. The trigger INSERTs
+ * on creation events (amount != null) and DELETEs the matching UTxO on spending events
+ * (amount = null), giving a real-time view of current asset holdings.
+ */
+
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+} from "@effectstream/concise";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  ProtocolPrimitiveMap,
+  UtxorpcTxPredicate,
+} from "@effectstream/config";
+import type { StateUpdateStream } from "@effectstream/coroutine";
+import { type JsonObject, Primitive } from "@effectstream/sm";
+import {
+  type AddressAndType,
+  AddressType,
+  type EffectstreamBlockNumber,
+  uint8ArrayToHexString,
+} from "@effectstream/utils";
+import { delayedAssetGrammar } from "./delayed-asset-grammar.ts";
+import {
+  DELAYED_ASSET_INTERMEDIATE_PREFIX,
+  DELAYED_ASSET_VIEW_PREFIX,
+  delayedAssetIvm,
+} from "./delayed-asset-ivm.ts";
+import { PrimitiveTypeCardanoDelayedAsset } from "../builtin.ts";
+import {
+  addressToHex,
+  assetQuantityToString,
+} from "../cardano-utils/cardano-helpers.ts";
+
+export class CardanoDelayedAssetPrimitive extends Primitive<
+  ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL,
+  typeof delayedAssetGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeCardanoDelayedAsset;
+  readonly policyIds: string[];
+  readonly fingerprints: string[] | undefined;
+  override grammar = delayedAssetGrammar;
+
+  override dynamicTables = delayedAssetIvm;
+  override getIntermediatePrefix(): string[] {
+    return [DELAYED_ASSET_INTERMEDIATE_PREFIX];
+  }
+  override getViewPrefix(): string[] {
+    return [DELAYED_ASSET_VIEW_PREFIX];
+  }
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    stateMachinePrefix: string | undefined;
+    policyIds: string[];
+    fingerprints?: string[];
+  }) {
+    super(config);
+    this.policyIds = config.policyIds.map((p) => p.toLowerCase());
+    this.fingerprints = config.fingerprints?.map((f) => f.toLowerCase());
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL] {
+    const predicate: UtxorpcTxPredicate =
+      this.policyIds.length === 1
+        ? { match: { cardano: { moves_asset: { policy_id: this.policyIds[0] } } } }
+        : {
+            any_of: this.policyIds.map((pid) => ({
+              match: { cardano: { moves_asset: { policy_id: pid } } },
+            })),
+          };
+
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      scheduledPrefix: this.stateMachinePrefix,
+      predicate,
+    } as const;
+  }
+
+  private computeFingerprint(policyId: string, assetName: string): string {
+    return `${policyId}.${assetName}`;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL>,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload: StaticDecode<CommandTuple<string, typeof delayedAssetGrammar>> | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const tx = primitiveTransactionData.output.payload.tx;
+    const txId = uint8ArrayToHexString(tx.hash);
+
+    const entries: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload: any;
+      accountingPayload: JsonObject;
+    }[] = [];
+
+    // Creations: scan tx.outputs
+    for (let outputIndex = 0; outputIndex < tx.outputs.length; outputIndex++) {
+      const output = tx.outputs[outputIndex];
+      const address = addressToHex(output.address);
+
+      for (const ma of output.assets) {
+        const policyId = uint8ArrayToHexString(ma.policyId);
+        if (!this.policyIds.includes(policyId.toLowerCase())) continue;
+
+        for (const asset of ma.assets) {
+          const assetName = uint8ArrayToHexString(asset.name);
+          const fingerprint = this.computeFingerprint(policyId, assetName);
+
+          if (this.fingerprints && !this.fingerprints.includes(fingerprint.toLowerCase())) continue;
+
+          const amount = assetQuantityToString(asset);
+
+          const accountingPayload = {
+            address,
+            txId,
+            outputIndex,
+            cip14Fingerprint: fingerprint,
+            amount,
+            policyId,
+            assetName,
+          };
+
+          const stateMachinePayload: any = this.stateMachinePrefix
+            ? generateRawStmInput(this.grammar, this.stateMachinePrefix, {
+                address,
+                txId,
+                outputIndex: String(outputIndex),
+                cip14Fingerprint: fingerprint,
+                amount,
+                policyId,
+                assetName,
+              })
+            : null;
+
+          entries.push({
+            fromAddressAndType: { type: AddressType.NONE, address: "0x0" },
+            accountingPayload,
+            stateMachinePayload,
+          });
+        }
+      }
+    }
+
+    // Spendings: scan tx.inputs (resolved via Dolos)
+    for (const input of tx.inputs) {
+      if (!input.asOutput) continue;
+      const resolved = input.asOutput;
+      const address = addressToHex(resolved.address);
+      const inputTxHash = uint8ArrayToHexString(input.txHash);
+      const inputOutputIndex = input.outputIndex;
+
+      for (const ma of resolved.assets) {
+        const policyId = uint8ArrayToHexString(ma.policyId);
+        if (!this.policyIds.includes(policyId.toLowerCase())) continue;
+
+        for (const asset of ma.assets) {
+          const assetName = uint8ArrayToHexString(asset.name);
+          const fingerprint = this.computeFingerprint(policyId, assetName);
+
+          if (this.fingerprints && !this.fingerprints.includes(fingerprint.toLowerCase())) continue;
+
+          const accountingPayload = {
+            address,
+            txId: inputTxHash,
+            outputIndex: inputOutputIndex,
+            cip14Fingerprint: fingerprint,
+            amount: null,
+            policyId,
+            assetName,
+          };
+
+          const stateMachinePayload: any = this.stateMachinePrefix
+            ? generateRawStmInput(this.grammar, this.stateMachinePrefix, {
+                address,
+                txId: inputTxHash,
+                outputIndex: String(inputOutputIndex),
+                cip14Fingerprint: fingerprint,
+                amount: "",
+                policyId,
+                assetName,
+              })
+            : null;
+
+          entries.push({
+            fromAddressAndType: { type: AddressType.NONE, address: "0x0" },
+            accountingPayload,
+            stateMachinePayload,
+          });
+        }
+      }
+    }
+
+    return { isBatched: true, data: entries };
+  }
+}

package/primitives/src/cardano-mint-burn/mint-burn-grammar.ts

@@ -0,0 +1,9 @@
+import { Type } from "@sinclair/typebox";
+
+export const mintBurnGrammar = [
+  ["txId", Type.String()],
+  ["metadata", Type.String()],
+  ["assets", Type.String()],
+  ["inputAddresses", Type.String()],
+  ["outputAddresses", Type.String()],
+] as const;

package/primitives/src/cardano-mint-burn/mint-burn-primitive.ts

@@ -0,0 +1,160 @@
+/**
+ * Cardano MintBurn Primitive
+ *
+ * Detects native token minting and burning events from Dolos UTxORPC block data.
+ *
+ * Data source: Dolos streams raw Cardano blocks via gRPC (UTxORPC protocol). Each
+ * block contains transactions, and each transaction has a `mint` field — a list of
+ * `Multiasset` entries, each with a `policyId` and a list of `Asset` entries (name +
+ * quantity). Positive quantities = mints, negative = burns.
+ *
+ * Extraction: for each transaction matched by the predicate, `getPayload()` iterates
+ * `tx.mint`, filters by configured `policyIds`, and collects `{policyId, assetName, amount}`.
+ * It also extracts input addresses from `tx.inputs[].asOutput.address` (resolved UTxOs
+ * provided by Dolos) and output addresses from `tx.outputs[].address`.
+ *
+ * Predicate: uses `mints_asset` with the configured policy IDs, so Dolos only sends
+ * transactions that actually mint/burn tokens under those policies.
+ */
+
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+} from "@effectstream/concise";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  ProtocolPrimitiveMap,
+  UtxorpcTxPredicate,
+} from "@effectstream/config";
+import type { StateUpdateStream } from "@effectstream/coroutine";
+import { type JsonObject, Primitive } from "@effectstream/sm";
+import {
+  type AddressAndType,
+  AddressType,
+  type EffectstreamBlockNumber,
+  uint8ArrayToHexString,
+} from "@effectstream/utils";
+import { mintBurnGrammar } from "./mint-burn-grammar.ts";
+import { PrimitiveTypeCardanoMintBurn } from "../builtin.ts";
+import {
+  addressToHex,
+  assetQuantityToString,
+  metadataToJson,
+} from "../cardano-utils/cardano-helpers.ts";
+
+export class CardanoMintBurnPrimitive extends Primitive<
+  ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL,
+  typeof mintBurnGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeCardanoMintBurn;
+  readonly policyIds: string[];
+  override grammar = mintBurnGrammar;
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    stateMachinePrefix: string | undefined;
+    policyIds: string[];
+  }) {
+    super(config);
+    this.policyIds = config.policyIds.map((p) => p.toLowerCase());
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL] {
+    const predicate: UtxorpcTxPredicate =
+      this.policyIds.length === 1
+        ? { match: { cardano: { mints_asset: { policy_id: this.policyIds[0] } } } }
+        : {
+            any_of: this.policyIds.map((pid) => ({
+              match: { cardano: { mints_asset: { policy_id: pid } } },
+            })),
+          };
+
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      scheduledPrefix: this.stateMachinePrefix,
+      predicate,
+    } as const;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL>,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload: StaticDecode<CommandTuple<string, typeof mintBurnGrammar>> | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const tx = primitiveTransactionData.output.payload.tx;
+
+    const assets: { amount: string; policyId: string; assetName: string }[] = [];
+    for (const ma of tx.mint) {
+      const policyId = uint8ArrayToHexString(ma.policyId);
+      if (!this.policyIds.includes(policyId.toLowerCase())) continue;
+      for (const asset of ma.assets) {
+        assets.push({
+          amount: assetQuantityToString(asset),
+          policyId,
+          assetName: uint8ArrayToHexString(asset.name),
+        });
+      }
+    }
+
+    if (assets.length === 0) {
+      return { isBatched: false, data: [] };
+    }
+
+    const inputAddresses: string[] = [];
+    for (const input of tx.inputs) {
+      if (input.asOutput) {
+        const addr = addressToHex(input.asOutput.address);
+        if (!inputAddresses.includes(addr)) inputAddresses.push(addr);
+      }
+    }
+
+    const outputAddresses: string[] = [];
+    for (const output of tx.outputs) {
+      const addr = addressToHex(output.address);
+      if (!outputAddresses.includes(addr)) outputAddresses.push(addr);
+    }
+
+    const txId = uint8ArrayToHexString(tx.hash);
+    const metadata = metadataToJson(tx.auxiliary?.metadata ?? []);
+
+    const accountingPayload = {
+      txId,
+      metadata: metadata ? JSON.stringify(metadata) : null,
+      assets,
+      inputAddresses,
+      outputAddresses,
+    };
+
+    const stateMachinePayload: any = this.stateMachinePrefix
+      ? generateRawStmInput(this.grammar, this.stateMachinePrefix, {
+          txId,
+          metadata: metadata ? JSON.stringify(metadata) : "",
+          assets: JSON.stringify(assets),
+          inputAddresses: JSON.stringify(inputAddresses),
+          outputAddresses: JSON.stringify(outputAddresses),
+        })
+      : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: { type: AddressType.NONE, address: "0x0" },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+}

package/primitives/src/cardano-pool-delegation/pool-delegation-grammar.ts

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

package/primitives/src/cardano-pool-delegation/pool-delegation-ivm.ts

@@ -0,0 +1,65 @@
+import { PrimitiveTypeCardanoPoolDelegation } from "../builtin.ts";
+
+export function poolDelegationIvm(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 intermediateTable = `primitives.cardano_pool_delegation_intermediate_${validSQLName}`;
+
+  return `
+    CREATE TABLE IF NOT EXISTS ${intermediateTable} (
+        primitive_name TEXT NOT NULL,
+        staking_credential TEXT NOT NULL,
+        pool_keyhash TEXT NOT NULL,
+        epoch INTEGER NOT NULL,
+        last_block_height INTEGER NOT NULL,
+        last_id INTEGER NOT NULL,
+        PRIMARY KEY (primitive_name, staking_credential)
+    );
+
+    CREATE OR REPLACE FUNCTION update_pool_delegation_${validSQLName}() RETURNS TRIGGER AS $$
+    BEGIN
+        IF NEW.payload_type = '${PrimitiveTypeCardanoPoolDelegation}'
+           AND NEW.primitive_name = '${name}' THEN
+
+            INSERT INTO ${intermediateTable} (
+                primitive_name, staking_credential, pool_keyhash, epoch, last_block_height, last_id
+            ) VALUES (
+                NEW.primitive_name,
+                NEW.payload->>'address',
+                NEW.payload->>'pool',
+                (NEW.payload->>'epoch')::INTEGER,
+                NEW.effectstream_block_height,
+                NEW.id
+            )
+            ON CONFLICT (primitive_name, staking_credential) DO UPDATE SET
+                pool_keyhash = EXCLUDED.pool_keyhash,
+                epoch = EXCLUDED.epoch,
+                last_block_height = EXCLUDED.last_block_height,
+                last_id = EXCLUDED.last_id;
+        END IF;
+
+        RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+
+    CREATE TRIGGER trigger_update_pool_delegation_${validSQLName}
+        AFTER INSERT ON effectstream.primitive_accounting
+        FOR EACH ROW
+        EXECUTE FUNCTION update_pool_delegation_${validSQLName}();
+
+    SELECT pgivm.create_immv('primitives.cardano_pool_delegation_view_${validSQLName}',
+        'SELECT
+            primitive_name,
+            staking_credential,
+            pool_keyhash
+        FROM ${intermediateTable};
+    ');
+    `;
+}
+
+export const POOL_DELEGATION_VIEW_PREFIX = "cardano_pool_delegation_view_" as const;
+export const POOL_DELEGATION_INTERMEDIATE_PREFIX = "cardano_pool_delegation_intermediate_" as const;