@effectstream/sm 0.100.11 → 0.100.13

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

@@ -0,0 +1,150 @@
+/**
+ * Cardano Pool Delegation Primitive
+ *
+ * Tracks stake pool delegation events from Dolos UTxORPC block data.
+ *
+ * Data source: Dolos streams raw Cardano blocks via gRPC. Each transaction contains
+ * a `certificates` array — delegation certificates include `stakeDelegation` (pre-Conway)
+ * and `stakeRegDelegCert`/`stakeVoteDelegCert` (Conway era). Each certificate carries
+ * a `stakeCredential` (key or script hash) and a `poolKeyhash` (target pool).
+ *
+ * Extraction: `getPayload()` iterates `tx.certificates`, filters for delegation-type
+ * certificates, extracts the staking credential hash and pool keyhash. The epoch is
+ * computed from `absoluteSlot` (passed from the fetcher via block headers) using
+ * network-specific era parameters (e.g., YACI: 600 slots/epoch, mainnet: 432000).
+ * Optionally filters by configured pool hashes.
+ *
+ * Predicate: uses `has_certificate: true` so Dolos only sends transactions containing
+ * certificates, filtering out the vast majority of transfer-only transactions.
+ *
+ * IVM: maintains a materialized view of current delegations per staking credential,
+ * using PostgreSQL triggers to UPSERT on each new delegation event.
+ */
+
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+} from "@effectstream/concise";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  ProtocolPrimitiveMap,
+} 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 { poolDelegationGrammar } from "./pool-delegation-grammar.ts";
+import {
+  POOL_DELEGATION_INTERMEDIATE_PREFIX,
+  POOL_DELEGATION_VIEW_PREFIX,
+  poolDelegationIvm,
+} from "./pool-delegation-ivm.ts";
+import { PrimitiveTypeCardanoPoolDelegation } from "../builtin.ts";
+import { slotToEpoch, stakeCredentialToHex } from "../cardano-utils/cardano-helpers.ts";
+
+type CardanoNetwork = "preview" | "preprod" | "mainnet" | "yaci";
+
+export class CardanoPoolDelegationPrimitive extends Primitive<
+  ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL,
+  typeof poolDelegationGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeCardanoPoolDelegation;
+  readonly pools: string[];
+  readonly network: CardanoNetwork;
+  override grammar = poolDelegationGrammar;
+
+  override dynamicTables = poolDelegationIvm;
+  override getIntermediatePrefix(): string[] {
+    return [POOL_DELEGATION_INTERMEDIATE_PREFIX];
+  }
+  override getViewPrefix(): string[] {
+    return [POOL_DELEGATION_VIEW_PREFIX];
+  }
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    stateMachinePrefix: string | undefined;
+    pools: string[];
+    network: CardanoNetwork;
+  }) {
+    super(config);
+    this.pools = config.pools.map((p) => p.toLowerCase());
+    this.network = config.network;
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      scheduledPrefix: this.stateMachinePrefix,
+      predicate: { match: { cardano: { has_certificate: true } } },
+    } as const;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL>,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload: StaticDecode<CommandTuple<string, typeof poolDelegationGrammar>> | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const tx = primitiveTransactionData.output.payload.tx;
+    const absoluteSlot = primitiveTransactionData.syncProtocol.absoluteSlot ?? 0;
+    const epoch = slotToEpoch(absoluteSlot, this.network);
+
+    const entries: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload: any;
+      accountingPayload: JsonObject;
+    }[] = [];
+
+    for (const cert of tx.certificates) {
+      const c = cert.certificate;
+      // Pre-Conway: stakeDelegation; Conway: stakeRegDelegCert, stakeVoteDelegCert
+      if (c.case !== "stakeDelegation" && c.case !== "stakeRegDelegCert" && c.case !== "stakeVoteDelegCert") continue;
+
+      const deleg = c.value;
+      if (!deleg.stakeCredential) continue;
+
+      const cred = stakeCredentialToHex(deleg.stakeCredential);
+      if (!cred) continue;
+
+      const poolKeyhash = uint8ArrayToHexString(deleg.poolKeyhash);
+
+      if (this.pools.length > 0 && !this.pools.includes(poolKeyhash.toLowerCase())) continue;
+
+      const address = cred.hash;
+      const pool = poolKeyhash;
+
+      const accountingPayload = { address, pool, epoch };
+
+      const stateMachinePayload: any = this.stateMachinePrefix
+        ? generateRawStmInput(this.grammar, this.stateMachinePrefix, {
+            address,
+            pool,
+            epoch: String(epoch),
+          })
+        : null;
+
+      entries.push({
+        fromAddressAndType: { type: AddressType.NONE, address: "0x0" },
+        accountingPayload,
+        stateMachinePayload,
+      });
+    }
+
+    return { isBatched: true, data: entries };
+  }
+}

package/primitives/src/cardano-projected-nft/projected-nft-datum.ts

@@ -0,0 +1,107 @@
+import { uint8ArrayToHexString } from "@effectstream/utils";
+import type { cardano } from "@utxorpc/spec";
+
+export type ProjectedNftStatus = "Lock" | "Unlocking" | "Claim";
+
+export interface ProjectedNftDatum {
+  owner: string;
+  status: ProjectedNftStatus;
+  forHowLong: string | null;
+}
+
+/**
+ * Parses the hololocker State datum: State { owner: Owner, status: Status }
+ * Owner: PKH(ByteArray) | NFT(PolicyId, AssetName) | Receipt(AssetName)
+ * Status: Locked | Unlocking { out_ref: OutputReference, for_how_long: Int }
+ *
+ * Note: policyId and assetName of locked assets come from the UTxO value, not the datum.
+ */
+export function parseProjectedNftDatum(datum: cardano.PlutusData | undefined): ProjectedNftDatum | null {
+  if (!datum) return null;
+
+  const pd = datum.plutusData;
+  if (pd.case !== "constr") return null;
+
+  const constr = pd.value;
+  if (constr.fields.length < 2) return null;
+
+  const ownerField = constr.fields[0];
+  const statusField = constr.fields[1];
+
+  const owner = parseOwner(ownerField);
+  if (owner == null) return null;
+
+  const statusParsed = parseStatus(statusField);
+  if (!statusParsed) return null;
+
+  return {
+    owner,
+    status: statusParsed.status,
+    forHowLong: statusParsed.forHowLong,
+  };
+}
+
+function extractBytes(field: cardano.PlutusData): string | null {
+  const inner = field.plutusData;
+  if (inner.case === "boundedBytes") {
+    return uint8ArrayToHexString(inner.value);
+  }
+  return null;
+}
+
+function parseOwner(field: cardano.PlutusData): string | null {
+  const inner = field.plutusData;
+  if (inner.case !== "constr") return null;
+
+  const tag = inner.value.tag;
+
+  // PKH(ByteArray) — constructor 0
+  if (tag === 0 || tag === 121) {
+    if (inner.value.fields.length < 1) return null;
+    return extractBytes(inner.value.fields[0]);
+  }
+
+  // NFT(PolicyId, AssetName) — constructor 1: use policyId as owner identifier
+  if (tag === 1 || tag === 122) {
+    if (inner.value.fields.length < 1) return null;
+    return extractBytes(inner.value.fields[0]);
+  }
+
+  // Receipt(AssetName) — constructor 2
+  if (tag === 2 || tag === 123) {
+    if (inner.value.fields.length < 1) return null;
+    return extractBytes(inner.value.fields[0]);
+  }
+
+  return null;
+}
+
+function parseStatus(field: cardano.PlutusData): { status: ProjectedNftStatus; forHowLong: string | null } | null {
+  const inner = field.plutusData;
+  if (inner.case !== "constr") return null;
+
+  const tag = inner.value.tag;
+
+  // Constructor 0 = Locked
+  if (tag === 0 || tag === 121) {
+    return { status: "Lock", forHowLong: null };
+  }
+
+  // Constructor 1 = Unlocking { out_ref: OutputReference, for_how_long: Int }
+  // fields[0] = OutputReference, fields[1] = for_how_long
+  if (tag === 1 || tag === 122) {
+    let forHowLong: string | null = null;
+    if (inner.value.fields.length > 1) {
+      const timefield = inner.value.fields[1].plutusData;
+      if (timefield.case === "bigInt") {
+        const bi = timefield.value.bigInt;
+        if (bi.case === "int") {
+          forHowLong = String(bi.value);
+        }
+      }
+    }
+    return { status: "Unlocking", forHowLong };
+  }
+
+  return null;
+}

package/primitives/src/cardano-projected-nft/projected-nft-grammar.ts

@@ -0,0 +1,13 @@
+import { Type } from "@sinclair/typebox";
+
+export const projectedNftGrammar = [
+  ["ownerAddress", Type.String()],
+  ["previousTxId", Type.String()],
+  ["previousOutputIndex", Type.String()],
+  ["currentTxId", Type.String()],
+  ["currentOutputIndex", Type.String()],
+  ["policyId", Type.String()],
+  ["assetName", Type.String()],
+  ["status", Type.String()],
+  ["forHowLong", Type.String()],
+] as const;

package/primitives/src/cardano-projected-nft/projected-nft-ivm.ts

@@ -0,0 +1,108 @@
+import { PrimitiveTypeCardanoProjectedNFT } from "../builtin.ts";
+
+export function projectedNftIvm(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_projected_nft_intermediate_${validSQLName}`;
+
+  return `
+    CREATE TABLE IF NOT EXISTS ${intermediateTable} (
+        primitive_name TEXT NOT NULL,
+        owner_address TEXT NOT NULL,
+        current_tx_id TEXT NOT NULL,
+        current_output_index INTEGER,
+        previous_tx_id TEXT,
+        previous_output_index INTEGER,
+        policy_id TEXT NOT NULL,
+        asset_name TEXT NOT NULL,
+        status TEXT NOT NULL,
+        for_how_long TEXT,
+        block_height INTEGER NOT NULL,
+        PRIMARY KEY (primitive_name, current_tx_id, current_output_index)
+    );
+
+    CREATE OR REPLACE FUNCTION update_projected_nft_${validSQLName}() RETURNS TRIGGER AS $$
+    DECLARE
+        v_status TEXT;
+    BEGIN
+        IF NEW.payload_type = '${PrimitiveTypeCardanoProjectedNFT}'
+           AND NEW.primitive_name = '${name}' THEN
+
+            v_status := NEW.payload->>'status';
+
+            IF v_status = 'Claim' THEN
+                DELETE FROM ${intermediateTable}
+                WHERE primitive_name = NEW.primitive_name
+                  AND current_tx_id = NEW.payload->>'previousTxId'
+                  AND current_output_index = (NEW.payload->>'previousOutputIndex')::INTEGER;
+            ELSE
+                IF NEW.payload->>'previousTxId' IS NOT NULL
+                   AND NEW.payload->>'previousTxId' != '' THEN
+                    DELETE FROM ${intermediateTable}
+                    WHERE primitive_name = NEW.primitive_name
+                      AND current_tx_id = NEW.payload->>'previousTxId'
+                      AND current_output_index = (NEW.payload->>'previousOutputIndex')::INTEGER;
+                END IF;
+
+                INSERT INTO ${intermediateTable} (
+                    primitive_name, owner_address, current_tx_id, current_output_index,
+                    previous_tx_id, previous_output_index, policy_id, asset_name,
+                    status, for_how_long, block_height
+                ) VALUES (
+                    NEW.primitive_name,
+                    NEW.payload->>'ownerAddress',
+                    NEW.payload->>'currentTxId',
+                    (NEW.payload->>'currentOutputIndex')::INTEGER,
+                    NULLIF(NEW.payload->>'previousTxId', ''),
+                    CASE WHEN NEW.payload->>'previousOutputIndex' IS NOT NULL
+                         AND NEW.payload->>'previousOutputIndex' != ''
+                         THEN (NEW.payload->>'previousOutputIndex')::INTEGER
+                         ELSE NULL END,
+                    NEW.payload->>'policyId',
+                    NEW.payload->>'assetName',
+                    v_status,
+                    NULLIF(NEW.payload->>'forHowLong', ''),
+                    NEW.effectstream_block_height
+                )
+                ON CONFLICT (primitive_name, current_tx_id, current_output_index) DO UPDATE SET
+                    owner_address = EXCLUDED.owner_address,
+                    previous_tx_id = EXCLUDED.previous_tx_id,
+                    previous_output_index = EXCLUDED.previous_output_index,
+                    status = EXCLUDED.status,
+                    for_how_long = EXCLUDED.for_how_long,
+                    block_height = EXCLUDED.block_height;
+            END IF;
+        END IF;
+
+        RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+
+    CREATE TRIGGER trigger_update_projected_nft_${validSQLName}
+        AFTER INSERT ON effectstream.primitive_accounting
+        FOR EACH ROW
+        EXECUTE FUNCTION update_projected_nft_${validSQLName}();
+
+    SELECT pgivm.create_immv('primitives.cardano_projected_nft_view_${validSQLName}',
+        'SELECT
+            primitive_name,
+            owner_address,
+            current_tx_id,
+            current_output_index,
+            previous_tx_id,
+            previous_output_index,
+            policy_id,
+            asset_name,
+            status,
+            for_how_long
+        FROM ${intermediateTable};
+    ');
+    `;
+}
+
+export const PROJECTED_NFT_VIEW_PREFIX = "cardano_projected_nft_view_" as const;
+export const PROJECTED_NFT_INTERMEDIATE_PREFIX = "cardano_projected_nft_intermediate_" as const;

package/primitives/src/cardano-projected-nft/projected-nft-primitive.ts

@@ -0,0 +1,242 @@
+/**
+ * Cardano Projected NFT Primitive
+ *
+ * Tracks the Lock → Unlock → Claim lifecycle of NFTs locked at a Plutus script
+ * (the "hololocker" from projected-nft-whirlpool). This enables "projecting" on-chain
+ * NFTs into off-chain game state while the NFT remains provably locked on Cardano.
+ *
+ * Data source: Dolos streams raw Cardano blocks via gRPC. Dolos resolves spent input
+ * references, so `tx.inputs[].asOutput` contains the full resolved UTxO including its
+ * inline datum (the hololocker State datum).
+ *
+ * Extraction: `getPayload()` performs three detection steps:
+ *   1. **Script inputs**: collects all `tx.inputs` whose resolved address contains the
+ *      configured `scriptHash`. These are UTxOs being consumed from the hololocker.
+ *   2. **Script outputs** (Lock / Unlocking): iterates `tx.outputs` at the script address,
+ *      parses the inline datum via `parseProjectedNftDatum()` to extract owner, status,
+ *      and forHowLong. Matches each output to a consumed input (state transition) or
+ *      treats it as a fresh Lock if no matching input exists.
+ *   3. **Claims**: any script inputs NOT matched to an output are Claims — the NFT left
+ *      the script and returned to the owner's wallet.
+ *
+ * Datum parsing: the hololocker State datum is CBOR-encoded PlutusData with structure:
+ *   State { owner: Owner(PKH|NFT|Receipt), status: Locked | Unlocking(out_ref, for_how_long) }
+ * The datum parser (`projected-nft-datum.ts`) walks the Constr tree to extract owner hash,
+ * status, and the time-lock expiry (forHowLong) for Unlocking states.
+ *
+ * Predicate: uses `has_address` with `payment_part: scriptHash`, so Dolos only sends
+ * transactions that interact with the hololocker script address.
+ *
+ * IVM: maintains a materialized view of NFT states at the script. The trigger UPSERTs
+ * on Lock/Unlocking events and DELETEs on Claim events, providing a real-time view of
+ * which NFTs are currently locked or unlocking.
+ */
+
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  type CommandTuple,
+  generateRawStmInput,
+} from "@effectstream/concise";
+import type {
+  ConfigSyncProtocolType,
+  FlattenSyncProtocolIOFor,
+  ProtocolPrimitiveMap,
+} 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 { projectedNftGrammar } from "./projected-nft-grammar.ts";
+import {
+  PROJECTED_NFT_INTERMEDIATE_PREFIX,
+  PROJECTED_NFT_VIEW_PREFIX,
+  projectedNftIvm,
+} from "./projected-nft-ivm.ts";
+import { PrimitiveTypeCardanoProjectedNFT } from "../builtin.ts";
+import { addressToHex } from "../cardano-utils/cardano-helpers.ts";
+import { parseProjectedNftDatum, type ProjectedNftDatum } from "./projected-nft-datum.ts";
+
+export class CardanoProjectedNftPrimitive extends Primitive<
+  ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL,
+  typeof projectedNftGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeCardanoProjectedNFT;
+  readonly scriptHash: string;
+  override grammar = projectedNftGrammar;
+
+  override dynamicTables = projectedNftIvm;
+  override getIntermediatePrefix(): string[] {
+    return [PROJECTED_NFT_INTERMEDIATE_PREFIX];
+  }
+  override getViewPrefix(): string[] {
+    return [PROJECTED_NFT_VIEW_PREFIX];
+  }
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    stateMachinePrefix: string | undefined;
+    scriptHash: string;
+  }) {
+    super(config);
+    this.scriptHash = config.scriptHash.toLowerCase();
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      scheduledPrefix: this.stateMachinePrefix,
+      predicate: {
+        match: { cardano: { has_address: { payment_part: this.scriptHash } } },
+      },
+    } as const;
+  }
+
+  private isScriptAddress(address: Uint8Array): boolean {
+    const hex = addressToHex(address);
+    return hex.includes(this.scriptHash);
+  }
+
+  private extractNativeAssets(output: { assets: { policyId: Uint8Array; assets: { name: Uint8Array }[] }[] }): { policyId: string; assetName: string }[] {
+    const assets: { policyId: string; assetName: string }[] = [];
+    for (const ma of output.assets) {
+      const policyId = uint8ArrayToHexString(ma.policyId);
+      for (const asset of ma.assets) {
+        const assetName = uint8ArrayToHexString(asset.name);
+        assets.push({ policyId, assetName });
+      }
+    }
+    return assets;
+  }
+
+  private emitEntry(
+    parsed: ProjectedNftDatum,
+    previousTxId: string | null,
+    previousOutputIndex: number | null,
+    currentTxId: string,
+    currentOutputIndex: number | string,
+    policyId: string,
+    assetName: string,
+    statusOverride?: "Claim",
+  ): {
+    fromAddressAndType: AddressAndType;
+    stateMachinePayload: any;
+    accountingPayload: JsonObject;
+  } {
+    const status = statusOverride ?? parsed.status;
+    const accountingPayload = {
+      ownerAddress: parsed.owner,
+      previousTxId: previousTxId ?? "",
+      previousOutputIndex: previousOutputIndex != null ? previousOutputIndex : "",
+      currentTxId,
+      currentOutputIndex,
+      policyId,
+      assetName,
+      status,
+      forHowLong: parsed.forHowLong ?? "",
+    };
+
+    const stateMachinePayload: any = this.stateMachinePrefix
+      ? generateRawStmInput(this.grammar, this.stateMachinePrefix, {
+          ownerAddress: parsed.owner,
+          previousTxId: previousTxId ?? "",
+          previousOutputIndex: previousOutputIndex != null ? String(previousOutputIndex) : "",
+          currentTxId,
+          currentOutputIndex: String(currentOutputIndex),
+          policyId,
+          assetName,
+          status,
+          forHowLong: parsed.forHowLong ?? "",
+        })
+      : null;
+
+    return {
+      fromAddressAndType: { type: AddressType.NONE, address: "0x0" },
+      accountingPayload,
+      stateMachinePayload,
+    };
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL>,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload: StaticDecode<CommandTuple<string, typeof projectedNftGrammar>> | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const tx = primitiveTransactionData.output.payload.tx;
+    const currentTxId = uint8ArrayToHexString(tx.hash);
+
+    const entries: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload: any;
+      accountingPayload: JsonObject;
+    }[] = [];
+
+    // Build a set of script inputs (previous UTxOs being consumed)
+    const scriptInputs: Map<string, { txHash: string; outputIndex: number; resolved: any }> = new Map();
+    for (const input of tx.inputs) {
+      if (input.asOutput && this.isScriptAddress(input.asOutput.address)) {
+        const key = `${uint8ArrayToHexString(input.txHash)}#${input.outputIndex}`;
+        scriptInputs.set(key, {
+          txHash: uint8ArrayToHexString(input.txHash),
+          outputIndex: input.outputIndex,
+          resolved: input.asOutput,
+        });
+      }
+    }
+
+    // Script outputs (new UTxOs at script address) — Lock or Unlocking events
+    for (let outputIndex = 0; outputIndex < tx.outputs.length; outputIndex++) {
+      const output = tx.outputs[outputIndex];
+      if (!this.isScriptAddress(output.address)) continue;
+
+      const parsed = parseProjectedNftDatum(output.datum?.payload);
+      if (!parsed) continue;
+
+      // Find a matching script input (state transition: Lock→Unlocking)
+      let previousTxId: string | null = null;
+      let previousOutputIndex: number | null = null;
+
+      for (const [key, inp] of scriptInputs) {
+        previousTxId = inp.txHash;
+        previousOutputIndex = inp.outputIndex;
+        scriptInputs.delete(key);
+        break;
+      }
+
+      // Extract policyId/assetName from the output's native assets
+      const assets = this.extractNativeAssets(output);
+      for (const { policyId, assetName } of assets) {
+        entries.push(
+          this.emitEntry(parsed, previousTxId, previousOutputIndex, currentTxId, outputIndex, policyId, assetName),
+        );
+      }
+    }
+
+    // Remaining script inputs with no corresponding output = Claims
+    for (const [, inp] of scriptInputs) {
+      const parsed = parseProjectedNftDatum(inp.resolved.datum?.payload);
+      if (!parsed) continue;
+
+      const assets = this.extractNativeAssets(inp.resolved);
+      for (const { policyId, assetName } of assets) {
+        entries.push(
+          this.emitEntry(parsed, inp.txHash, inp.outputIndex, currentTxId, "", policyId, assetName, "Claim"),
+        );
+      }
+    }
+
+    return { isBatched: true, data: entries };
+  }
+}

package/primitives/src/cardano-transfer/transfer-grammar.ts

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+
+export const transferGrammar = [
+  ["txId", Type.String()],
+  ["metadata", Type.String()],
+  ["inputCredentials", Type.String()],
+  ["outputs", Type.String()],
+] as const;