@effectstream/sm 0.100.0

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

@@ -0,0 +1,117 @@
+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 { nep141Grammar } from "./nep141-grammar.ts";
+import {
+  NEP141_INTERMEDIATE_PREFIX,
+  NEP141_VIEW_PREFIX,
+  nep141Ivm,
+} from "./nep141-ivm.ts";
+import { PrimitiveTypeNEARNEP141 } from "../builtin.ts";
+
+export class Nep141Primitive extends Primitive<
+  ConfigSyncProtocolType.NEAR_RPC_PARALLEL,
+  typeof nep141Grammar
+> {
+  readonly internalTypeName = PrimitiveTypeNEARNEP141;
+  override grammar = nep141Grammar;
+  readonly contractId: string;
+
+  override dynamicTables = nep141Ivm;
+  override getIntermediatePrefix(): string[] {
+    return [NEP141_INTERMEDIATE_PREFIX];
+  }
+  override getViewPrefix(): string[] {
+    return [NEP141_VIEW_PREFIX];
+  }
+
+  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 nep141Grammar>>
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload as Record<string, unknown>;
+    const oldOwnerId = String(payload.old_owner_id ?? "");
+    const newOwnerId = String(payload.new_owner_id ?? "");
+    const amount = String(payload.amount ?? "0");
+
+    const accountingPayload: ParamToData<typeof nep141Grammar> = {
+      old_owner_id: oldOwnerId,
+      new_owner_id: newOwnerId,
+      amount,
+    };
+
+    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.NEAR,
+            address: oldOwnerId,
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.NEAR_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      contractId: this.contractId,
+      eventStandard: "nep141",
+      eventType: "ft_transfer",
+      scheduledPrefix: this.stateMachinePrefix,
+    };
+  }
+}

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

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+
+export const nep171Grammar = [
+  ['old_owner_id', Type.String()],
+  ['new_owner_id', Type.String()],
+  ['token_id', Type.String()],
+  ['isBurn', Type.Boolean()],
+] as const;

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

@@ -0,0 +1,71 @@
+import { PrimitiveTypeNEARNEP171 } from "../builtin.ts";
+
+export function nep171Ivm(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 ownerTable = `primitives.nep171_owner_intermediate_${validSQLName}`;
+
+  return `
+    CREATE TABLE IF NOT EXISTS ${ownerTable} (
+        primitive_name TEXT NOT NULL,
+        token_id TEXT NOT NULL,
+        current_owner TEXT NOT NULL,
+        last_transfer_block_height INTEGER NOT NULL,
+        last_transfer_id INTEGER NOT NULL,
+        PRIMARY KEY (primitive_name, token_id)
+    );
+
+    CREATE OR REPLACE FUNCTION update_nep171_owner_${validSQLName}() RETURNS TRIGGER AS $$
+    DECLARE
+        new_owner TEXT;
+        nft_token_id TEXT;
+        is_burn BOOLEAN;
+    BEGIN
+        IF NEW.payload_type = '${PrimitiveTypeNEARNEP171}'
+           AND NEW.primitive_name = '${name}' THEN
+
+         new_owner := NEW.payload->>'new_owner_id';
+         nft_token_id := NEW.payload->>'token_id';
+         is_burn := (NEW.payload->>'isBurn')::boolean;
+
+         IF nft_token_id IS NOT NULL AND NOT is_burn THEN
+             INSERT INTO ${ownerTable} (primitive_name, token_id, current_owner, last_transfer_block_height, last_transfer_id)
+             VALUES (NEW.primitive_name, nft_token_id, new_owner, NEW.effectstream_block_height, NEW.id)
+             ON CONFLICT (primitive_name, token_id) DO UPDATE SET
+                 current_owner = new_owner,
+                 last_transfer_block_height = NEW.effectstream_block_height,
+                 last_transfer_id = NEW.id
+             WHERE ${ownerTable}.last_transfer_block_height < NEW.effectstream_block_height
+                OR (${ownerTable}.last_transfer_block_height = NEW.effectstream_block_height
+                    AND ${ownerTable}.last_transfer_id < NEW.id);
+         ELSIF nft_token_id IS NOT NULL AND is_burn THEN
+             DELETE FROM ${ownerTable}
+             WHERE primitive_name = NEW.primitive_name AND token_id = nft_token_id;
+         END IF;
+        END IF;
+
+        RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+
+    CREATE TRIGGER trigger_update_nep171_owner_${validSQLName}
+        AFTER INSERT ON effectstream.primitive_accounting
+        FOR EACH ROW
+        EXECUTE FUNCTION update_nep171_owner_${validSQLName}();
+
+    SELECT pgivm.create_immv('primitives.nep171_owner_view_${validSQLName}',
+        'SELECT
+            primitive_name,
+            token_id,
+            current_owner
+        FROM ${ownerTable};
+    ');
+    `;
+}
+
+export const NEP171_VIEW_PREFIX = "nep171_owner_view_" as const;
+export const NEP171_INTERMEDIATE_PREFIX = "nep171_owner_intermediate_" as const;

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

@@ -0,0 +1,138 @@
+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 { nep171Grammar } from "./nep171-grammar.ts";
+import {
+  NEP171_INTERMEDIATE_PREFIX,
+  NEP171_VIEW_PREFIX,
+  nep171Ivm,
+} from "./nep171-ivm.ts";
+import { PrimitiveTypeNEARNEP171 } from "../builtin.ts";
+
+const BURN_RECEIVER = "system";
+
+export class Nep171Primitive extends Primitive<
+  ConfigSyncProtocolType.NEAR_RPC_PARALLEL,
+  typeof nep171Grammar
+> {
+  readonly internalTypeName = PrimitiveTypeNEARNEP171;
+  override grammar = nep171Grammar;
+  readonly contractId: string;
+
+  override dynamicTables = nep171Ivm;
+  override getIntermediatePrefix(): string[] {
+    return [NEP171_INTERMEDIATE_PREFIX];
+  }
+  override getViewPrefix(): string[] {
+    return [NEP171_VIEW_PREFIX];
+  }
+
+  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 nep171Grammar>>
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload as Record<string, unknown>;
+    const oldOwnerId = String(payload.old_owner_id ?? "");
+    const newOwnerId = String(payload.new_owner_id ?? "");
+    // NEP-171 events may have token_ids array — emit one per token
+    const tokenIds: string[] = Array.isArray(payload.token_ids)
+      ? (payload.token_ids as string[])
+      : [String(payload.token_ids ?? payload.token_id ?? "")];
+
+    const isBurn = newOwnerId === "" || newOwnerId === BURN_RECEIVER;
+
+    const result: {
+      isBatched: boolean;
+      data: {
+        fromAddressAndType: AddressAndType;
+        stateMachinePayload:
+          | StaticDecode<CommandTuple<string, typeof nep171Grammar>>
+          | null;
+        accountingPayload: JsonObject;
+      }[];
+    } = {
+      isBatched: tokenIds.length > 1,
+      data: [],
+    };
+
+    for (const tokenId of tokenIds) {
+      const accountingPayload: ParamToData<typeof nep171Grammar> = {
+        old_owner_id: oldOwnerId,
+        new_owner_id: newOwnerId,
+        token_id: tokenId,
+        isBurn,
+      };
+
+      const stateMachinePayload: StaticDecode<
+        CommandTuple<string, typeof nep171Grammar>
+      > | null = this.stateMachinePrefix
+        ? generateRawStmInput(
+          this.grammar,
+          this.stateMachinePrefix,
+          accountingPayload,
+        )
+        : null;
+
+      result.data.push({
+        fromAddressAndType: {
+          type: AddressType.NEAR,
+          address: oldOwnerId,
+        },
+        accountingPayload,
+        stateMachinePayload,
+      });
+    }
+
+    return result;
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.NEAR_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      contractId: this.contractId,
+      eventStandard: "nep171",
+      eventType: "nft_transfer",
+      scheduledPrefix: this.stateMachinePrefix,
+    };
+  }
+}

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

@@ -0,0 +1,11 @@
+import { Type } from "@sinclair/typebox";
+
+export const nep245Grammar = [
+  ['type', Type.String()],
+  ['old_owner_id', Type.String()],
+  ['new_owner_id', Type.String()],
+  ['token_id', Type.String()],
+  ['amount', Type.String()],
+  ['isMint', Type.Boolean()],
+  ['isBurn', Type.Boolean()],
+] as const;

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

@@ -0,0 +1,84 @@
+import { PrimitiveTypeNEARNEP245 } from "../builtin.ts";
+
+export function nep245Ivm(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.nep245_balance_intermediate_${validSQLName}`;
+
+  return `
+    CREATE TABLE IF NOT EXISTS ${balanceTable} (
+        primitive_name TEXT NOT NULL,
+        token_id TEXT NOT NULL,
+        account_id TEXT NOT NULL,
+        amount numeric(78,0) DEFAULT 0,
+        last_transfer_block_height INTEGER NOT NULL DEFAULT 0,
+        last_transfer_id INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (primitive_name, token_id, account_id)
+    );
+
+    CREATE OR REPLACE FUNCTION update_nep245_balance_${validSQLName}() RETURNS TRIGGER AS $$
+    DECLARE
+        transfer_amount numeric(78,0);
+        from_account TEXT;
+        to_account TEXT;
+        mt_token_id TEXT;
+        is_mint BOOLEAN;
+        is_burn BOOLEAN;
+    BEGIN
+        IF NEW.payload_type = '${PrimitiveTypeNEARNEP245}'
+           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';
+         mt_token_id := NEW.payload->>'token_id';
+         is_mint := COALESCE((NEW.payload->>'isMint')::boolean, false);
+         is_burn := COALESCE((NEW.payload->>'isBurn')::boolean, false);
+
+         IF from_account IS NOT NULL AND from_account != '' AND NOT is_mint THEN
+             INSERT INTO ${balanceTable} (primitive_name, token_id, account_id, amount, last_transfer_block_height, last_transfer_id)
+             VALUES (NEW.primitive_name, mt_token_id, from_account, -transfer_amount, NEW.effectstream_block_height, NEW.id)
+             ON CONFLICT (primitive_name, token_id, account_id) DO UPDATE SET
+                 amount = ${balanceTable}.amount - transfer_amount,
+                 last_transfer_block_height = NEW.effectstream_block_height,
+                 last_transfer_id = NEW.id;
+         END IF;
+
+         IF to_account IS NOT NULL AND to_account != '' AND NOT is_burn THEN
+             INSERT INTO ${balanceTable} (primitive_name, token_id, account_id, amount, last_transfer_block_height, last_transfer_id)
+             VALUES (NEW.primitive_name, mt_token_id, to_account, transfer_amount, NEW.effectstream_block_height, NEW.id)
+             ON CONFLICT (primitive_name, token_id, account_id) DO UPDATE SET
+                 amount = ${balanceTable}.amount + transfer_amount,
+                 last_transfer_block_height = NEW.effectstream_block_height,
+                 last_transfer_id = NEW.id;
+         END IF;
+        END IF;
+
+        RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+
+    CREATE TRIGGER trigger_update_nep245_balance_${validSQLName}
+        AFTER INSERT ON effectstream.primitive_accounting
+        FOR EACH ROW
+        EXECUTE FUNCTION update_nep245_balance_${validSQLName}();
+
+    SELECT pgivm.create_immv('primitives.nep245_balance_view_${validSQLName}',
+        'SELECT
+            primitive_name,
+            token_id,
+            account_id,
+            amount
+        FROM ${balanceTable}
+        WHERE amount > 0;
+    ');
+    `;
+}
+
+export const NEP245_VIEW_PREFIX = "nep245_balance_view_" as const;
+export const NEP245_INTERMEDIATE_PREFIX = "nep245_balance_intermediate_" as const;

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

@@ -0,0 +1,147 @@
+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 { nep245Grammar } from "./nep245-grammar.ts";
+import {
+  NEP245_INTERMEDIATE_PREFIX,
+  NEP245_VIEW_PREFIX,
+  nep245Ivm,
+} from "./nep245-ivm.ts";
+import { PrimitiveTypeNEARNEP245 } from "../builtin.ts";
+
+const ZERO_ACCOUNT = "";
+
+export class Nep245Primitive extends Primitive<
+  ConfigSyncProtocolType.NEAR_RPC_PARALLEL,
+  typeof nep245Grammar
+> {
+  readonly internalTypeName = PrimitiveTypeNEARNEP245;
+  override grammar = nep245Grammar;
+  readonly contractId: string;
+
+  override dynamicTables = nep245Ivm;
+  override getIntermediatePrefix(): string[] {
+    return [NEP245_INTERMEDIATE_PREFIX];
+  }
+  override getViewPrefix(): string[] {
+    return [NEP245_VIEW_PREFIX];
+  }
+
+  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 nep245Grammar>>
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload as Record<string, unknown>;
+    const eventType = String(payload._event ?? "mt_transfer");
+    const oldOwnerId = String(payload.old_owner_id ?? "");
+    const newOwnerId = String(payload.new_owner_id ?? "");
+
+    // NEP-245 events have parallel token_ids[] and amounts[]
+    const tokenIds: string[] = Array.isArray(payload.token_ids)
+      ? (payload.token_ids as string[])
+      : [String(payload.token_ids ?? payload.token_id ?? "")];
+    const amounts: string[] = Array.isArray(payload.amounts)
+      ? (payload.amounts as string[])
+      : [String(payload.amounts ?? payload.amount ?? "0")];
+
+    const isMint = oldOwnerId === ZERO_ACCOUNT || eventType === "mt_mint";
+    const isBurn = newOwnerId === ZERO_ACCOUNT || eventType === "mt_burn";
+
+    const result: {
+      isBatched: boolean;
+      data: {
+        fromAddressAndType: AddressAndType;
+        stateMachinePayload:
+          | StaticDecode<CommandTuple<string, typeof nep245Grammar>>
+          | null;
+        accountingPayload: JsonObject;
+      }[];
+    } = {
+      isBatched: tokenIds.length > 1,
+      data: [],
+    };
+
+    for (let i = 0; i < tokenIds.length; i++) {
+      const accountingPayload: ParamToData<typeof nep245Grammar> = {
+        type: eventType,
+        old_owner_id: oldOwnerId,
+        new_owner_id: newOwnerId,
+        token_id: tokenIds[i],
+        amount: amounts[i] ?? "0",
+        isMint,
+        isBurn,
+      };
+
+      const stateMachinePayload: StaticDecode<
+        CommandTuple<string, typeof nep245Grammar>
+      > | null = this.stateMachinePrefix
+        ? generateRawStmInput(
+          this.grammar,
+          this.stateMachinePrefix,
+          accountingPayload,
+        )
+        : null;
+
+      result.data.push({
+        fromAddressAndType: {
+          type: AddressType.NEAR,
+          address: oldOwnerId || newOwnerId,
+        },
+        accountingPayload,
+        stateMachinePayload,
+      });
+    }
+
+    return result;
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.NEAR_RPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      contractId: this.contractId,
+      eventStandard: "nep245",
+      eventType: "mt_transfer",
+      scheduledPrefix: this.stateMachinePrefix,
+    };
+  }
+}

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

@@ -0,0 +1,6 @@
+import { Type } from '@sinclair/typebox';
+
+export const utxorpcGenericGrammar = [
+  ["hash", Type.String()],
+  ["bytes", Type.String()],
+] as const;

package/primitives/src/utxorpc-generic/utxorpc-generic.ts

@@ -0,0 +1,88 @@
+import type { Static, StaticDecode, TSchema } from '@sinclair/typebox';
+import {
+  type CommandTuple,
+  generateRawStmInput,
+  type ParamToData,
+} 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 { utxorpcGenericGrammar } from './utxorpc-generic-grammar.ts';
+import { PrimitiveTypeUtxorpcGeneric } from '../builtin.ts';
+
+export class UtxorpcGenericPrimitive extends Primitive<
+  ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL,
+  typeof utxorpcGenericGrammar
+> {
+  readonly internalTypeName = PrimitiveTypeUtxorpcGeneric;
+  readonly predicate: UtxorpcTxPredicate;
+  override grammar = utxorpcGenericGrammar;
+
+  constructor(config: {
+    instanceName: string;
+    startBlockHeight: number;
+    stateMachinePrefix: string | undefined;
+    predicate: UtxorpcTxPredicate;
+  }) {
+    super(config);
+    this.predicate = config.predicate;
+  }
+
+  override getConfig(): ProtocolPrimitiveMap[
+    ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL
+  ] {
+    return {
+      name: this.instanceName,
+      type: this.internalTypeName,
+      startBlockHeight: this.startBlockHeight,
+      scheduledPrefix: this.stateMachinePrefix,
+      predicate: this.predicate,
+    } as const;
+  }
+
+  override *getPayload(
+    _: EffectstreamBlockNumber,
+    primitiveTransactionData: FlattenSyncProtocolIOFor<
+      ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL
+    >,
+  ): StateUpdateStream<{
+    isBatched: boolean;
+    data: {
+      fromAddressAndType: AddressAndType;
+      stateMachinePayload:
+        | StaticDecode<
+          CommandTuple<string, typeof utxorpcGenericGrammar>
+        >
+        | null;
+      accountingPayload: JsonObject;
+    }[];
+  }> {
+    const payload = primitiveTransactionData.output.payload;
+    const accountingPayload = {
+      hash: uint8ArrayToHexString(payload.tx.hash),
+      bytes: uint8ArrayToHexString(payload.tx.toBinary()),
+    };
+    const stateMachinePayload: any = this.stateMachinePrefix
+        ? generateRawStmInput(
+          this.grammar,
+          this.stateMachinePrefix,
+          accountingPayload,
+        )
+        : null;
+
+    return {
+      isBatched: false,
+      data: [
+        {
+          fromAddressAndType: {
+            type: AddressType.NONE,
+            address: "0x0",
+          },
+          accountingPayload,
+          stateMachinePayload,
+        },
+      ],
+    };
+  }
+}

package/primitives/types.ts

@@ -0,0 +1,14 @@
+/**
+ * Valid JSON Object, required for the db accounting.
+ */
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+export type JsonObject = {
+  [key: string]: JsonValue;
+};