@arkiv-network/sdk 0.6.8 → 0.7.0-dev.1

package/src/utils/arkivTransactions.test.ts

@@ -0,0 +1,260 @@
+import { describe, expect, it, vi } from "bun:test"
+import { stringToBytes, toBytes, toHex } from "viem"
+import type { ArkivClient } from "../clients/baseClient"
+import { DuplicateAttributeError, InvalidAttributeError, InvalidExpirationError } from "../errors"
+import { sendArkivTransaction } from "./arkivTransactions"
+
+const ZERO_32 = `0x${"00".repeat(32)}`
+
+function encodeStringTo128(str: string): string[] {
+  const padded = new Uint8Array(128)
+  // stringToBytes, not toBytes — mirrors encodeAttribute: string values are always
+  // UTF-8 encoded, never hex-decoded, even when they look like hex
+  padded.set(stringToBytes(str).slice(0, 128))
+  return [
+    toHex(padded.slice(0, 32)),
+    toHex(padded.slice(32, 64)),
+    toHex(padded.slice(64, 96)),
+    toHex(padded.slice(96, 128)),
+  ]
+}
+
+function makeClient() {
+  const writeContract = vi.fn().mockResolvedValue("0xdeadbeef")
+  const waitForTransactionReceipt = vi.fn().mockResolvedValue({
+    status: "success",
+    transactionHash: "0xdeadbeef",
+  })
+  return {
+    client: {
+      account: { address: "0x1111111111111111111111111111111111111111" },
+      chain: { id: 1 },
+      getBlockNumber: vi.fn().mockResolvedValue(100n),
+      readContract: vi.fn().mockResolvedValue(0),
+      writeContract,
+      waitForTransactionReceipt,
+    } as unknown as ArkivClient,
+    writeContract,
+  }
+}
+
+const BASE_CREATE = {
+  payload: new Uint8Array([1, 2, 3]),
+  contentType: "application/octet-stream",
+  expiresIn: 3600,
+}
+
+async function captureAttributes(attributes: { key: string; value: string | number }[]) {
+  const { client, writeContract } = makeClient()
+  await sendArkivTransaction(client, {
+    creates: [{ ...BASE_CREATE, attributes }],
+  })
+  const callArgs = writeContract.mock.calls[0][0]
+  return callArgs.args[0][0].attributes as { name: string; valueType: number; value: string[] }[]
+}
+
+const validCreate = {
+  payload: new Uint8Array([1, 2, 3]),
+  contentType: "text/plain",
+  attributes: [{ key: "k", value: "v" as string | number }],
+  expiresIn: 1000,
+}
+
+describe("sendArkivTransaction expiration validation", () => {
+  it("sends a transaction for a valid create", async () => {
+    const { client, writeContract } = makeClient()
+    const result = await sendArkivTransaction(client, { creates: [validCreate] })
+    expect(writeContract).toHaveBeenCalledTimes(1)
+    expect(result.receipt.status).toBe("success")
+  })
+
+  it("rejects when a create expiresIn is not a multiple of the block time", async () => {
+    const { client } = makeClient()
+    await expect(
+      sendArkivTransaction(client, { creates: [{ ...validCreate, expiresIn: 51 }] }),
+    ).rejects.toThrow(InvalidExpirationError)
+  })
+
+  it("rejects when a create expiresIn is not an integer", async () => {
+    const { client } = makeClient()
+    await expect(
+      sendArkivTransaction(client, { creates: [{ ...validCreate, expiresIn: 51.5 }] }),
+    ).rejects.toThrow(InvalidExpirationError)
+  })
+
+  it("rejects when an extension expiresIn is not a multiple of the block time", async () => {
+    const { client } = makeClient()
+    await expect(
+      sendArkivTransaction(client, { extensions: [{ entityKey: "0x123", expiresIn: 999 }] }),
+    ).rejects.toThrow(InvalidExpirationError)
+  })
+})
+
+describe("sendArkivTransaction attribute validation", () => {
+  it("rejects when a numeric attribute value is not an integer", async () => {
+    const { client } = makeClient()
+    await expect(
+      sendArkivTransaction(client, {
+        creates: [{ ...validCreate, attributes: [{ key: "n", value: 1.5 }] }],
+      }),
+    ).rejects.toThrow(InvalidAttributeError)
+  })
+
+  it("accepts integer numeric attribute values", async () => {
+    const { client, writeContract } = makeClient()
+    await sendArkivTransaction(client, {
+      creates: [{ ...validCreate, attributes: [{ key: "n", value: 123 }] }],
+    })
+    expect(writeContract).toHaveBeenCalledTimes(1)
+  })
+
+  it("accepts string attribute values that look like non-integers", async () => {
+    const { client, writeContract } = makeClient()
+    await sendArkivTransaction(client, {
+      creates: [{ ...validCreate, attributes: [{ key: "n", value: "1.5" }] }],
+    })
+    expect(writeContract).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe("encodeAttribute", () => {
+  it("encodes a plain string as STRING (valueType 2) left-aligned across 128 bytes", async () => {
+    const [attr] = await captureAttributes([{ key: "name", value: "hello world" }])
+
+    expect(attr.name).toBe(toHex("name", { size: 32 }))
+    expect(attr.valueType).toBe(2)
+    expect(attr.value).toEqual(encodeStringTo128("hello world"))
+  })
+
+  it("encodes an empty string as STRING with all-zero value", async () => {
+    const [attr] = await captureAttributes([{ key: "tag", value: "" }])
+
+    expect(attr.valueType).toBe(2)
+    expect(attr.value).toEqual([ZERO_32, ZERO_32, ZERO_32, ZERO_32])
+  })
+
+  it("encodes a hex string as ENTITY_KEY (valueType 3) in first slot, rest zero", async () => {
+    const entityKey = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"
+    const [attr] = await captureAttributes([{ key: "ref", value: entityKey }])
+
+    expect(attr.name).toBe(toHex("ref", { size: 32 }))
+    expect(attr.valueType).toBe(3)
+    expect(attr.value).toEqual([entityKey, ZERO_32, ZERO_32, ZERO_32])
+  })
+
+  it("treats hex strings that are not 32 bytes as STRING, not ENTITY_KEY", async () => {
+    // only exact entity keys get the hex type — everything else must round-trip
+    // as a string and stay matchable by quoted string queries
+    for (const value of ["0x", "0xab", "0x6186b0dba9652262942d5a465d49686eb560834c"]) {
+      const [attr] = await captureAttributes([{ key: "x", value }])
+      expect(attr.valueType).toBe(2)
+      expect(attr.value).toEqual(encodeStringTo128(value))
+    }
+
+    // the encoded bytes are the UTF-8 text, not a hex-decode: "0xab" is the
+    // four characters 0, x, a, b
+    const [attr] = await captureAttributes([{ key: "x", value: "0xab" }])
+    expect(attr.value[0].startsWith("0x30786162")).toBe(true)
+  })
+
+  it("encodes a number as UINT (valueType 1) big-endian in first slot, rest zero", async () => {
+    const [attr] = await captureAttributes([{ key: "count", value: 42 }])
+
+    expect(attr.name).toBe(toHex("count", { size: 32 }))
+    expect(attr.valueType).toBe(1)
+    expect(attr.value).toEqual([toHex(42n, { size: 32 }), ZERO_32, ZERO_32, ZERO_32])
+  })
+
+  it("encodes zero as UINT", async () => {
+    const [attr] = await captureAttributes([{ key: "n", value: 0 }])
+
+    expect(attr.valueType).toBe(1)
+    expect(attr.value).toEqual([ZERO_32, ZERO_32, ZERO_32, ZERO_32])
+  })
+
+  it("encodes a large number as UINT", async () => {
+    const large = Number.MAX_SAFE_INTEGER
+    const [attr] = await captureAttributes([{ key: "big", value: large }])
+
+    expect(attr.valueType).toBe(1)
+    expect(attr.value[0]).toBe(toHex(BigInt(large), { size: 32 }))
+  })
+
+  it("encodes multiple mixed-type attributes preserving order", async () => {
+    const entityKey = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"
+    const attrs = await captureAttributes([
+      { key: "count", value: 7 },
+      { key: "label", value: "test" },
+      { key: "ref", value: entityKey },
+    ])
+
+    expect(attrs).toHaveLength(3)
+    expect(attrs[0]).toMatchObject({ valueType: 1, name: toHex("count", { size: 32 }) })
+    expect(attrs[1]).toMatchObject({ valueType: 2, name: toHex("label", { size: 32 }) })
+    expect(attrs[2]).toMatchObject({ valueType: 3, name: toHex("ref", { size: 32 }) })
+  })
+
+  it("encodes a UTF-8 string longer than 32 bytes spanning multiple chunks", async () => {
+    const long = "a".repeat(40)
+    const [attr] = await captureAttributes([{ key: "body", value: long }])
+
+    expect(attr.valueType).toBe(2)
+    const [chunk0, chunk1] = attr.value
+    expect(chunk0).toBe(toHex(new Uint8Array(32).fill(0x61))) // 32 × 'a'
+    expect(chunk1.startsWith("0x6161616161616161")).toBe(true) // next 8 × 'a', then zeros
+  })
+})
+
+describe("attribute sorting", () => {
+  it("sorts attributes ascending by their bytes32 name before encoding", async () => {
+    const attrs = await captureAttributes([
+      { key: "tag", value: "zz" },
+      { key: "status", value: "active" },
+      { key: "score", value: 30 },
+    ])
+
+    expect(attrs.map((a) => a.name)).toEqual([
+      toHex("score", { size: 32 }),
+      toHex("status", { size: 32 }),
+      toHex("tag", { size: 32 }),
+    ])
+  })
+
+  it("sorts a shorter key before a longer key sharing its prefix", async () => {
+    const attrs = await captureAttributes([
+      { key: "abc", value: 1 },
+      { key: "ab", value: 2 },
+    ])
+
+    expect(attrs.map((a) => a.name)).toEqual([
+      toHex("ab", { size: 32 }),
+      toHex("abc", { size: 32 }),
+    ])
+  })
+
+  it("does not mutate the caller's attributes array", async () => {
+    const input = [
+      { key: "b", value: 1 },
+      { key: "a", value: 2 },
+    ]
+    await captureAttributes(input)
+    expect(input.map((a) => a.key)).toEqual(["b", "a"])
+  })
+
+  it("rejects duplicate attribute keys", async () => {
+    const { client } = makeClient()
+    await expect(
+      sendArkivTransaction(client, {
+        creates: [
+          {
+            ...BASE_CREATE,
+            attributes: [
+              { key: "tag", value: "one" },
+              { key: "tag", value: "two" },
+            ],
+          },
+        ],
+      }),
+    ).rejects.toThrow(DuplicateAttributeError)
+  })
+})

package/src/utils/arkivTransactions.ts

@@ -1,4 +1,17 @@
-import { type Hex, hexToString, TransactionExecutionError, toBytes, toHex, toRlp } from "viem"
+import {
+  type Address,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  encodePacked,
+  type Hex,
+  keccak256,
+  parseAbi,
+  stringToBytes,
+  TransactionExecutionError,
+  type TransactionReceipt,
+  toBytes,
+  toHex,
+} from "viem"
 import type { ChangeOwnershipParameters } from "../actions/wallet/changeOwnership"
 import type { CreateEntityParameters } from "../actions/wallet/createEntity"
 import type { DeleteEntityParameters } from "../actions/wallet/deleteEntity"
@@ -7,140 +20,290 @@ import type { UpdateEntityParameters } from "../actions/wallet/updateEntity"
 import type { ArkivClient } from "../clients/baseClient"
 import type { WalletArkivClient } from "../clients/createWalletClient"
 import { ARKIV_ADDRESS, BLOCK_TIME } from "../consts"
-import { EntityMutationError } from "../errors"
+import { DuplicateAttributeError, EntityMutationError, InvalidContentTypeError } from "../errors"
 import type { TxParams } from "../types"
-import { compress } from "./compression"
+import { EntityOperationType } from "../types/entity"
+import { RpcAttributeValueType as AttributeValueType } from "../types/rpcSchema"
+
 import { getLogger } from "./logger"
+import { isEntityKey, validateAttribute, validateExpiresIn } from "./validation"
 
 const logger = getLogger("utils:arkiv-transactions")
 
-export function opsToTxData({
-  creates,
-  updates,
-  deletes,
-  extensions,
-  ownershipChanges,
-}: {
-  creates?: CreateEntityParameters[]
-  updates?: UpdateEntityParameters[]
-  deletes?: DeleteEntityParameters[]
-  extensions?: ExtendEntityParameters[]
-  ownershipChanges?: ChangeOwnershipParameters[]
-}) {
-  function formatAttributes<T extends string | number | bigint | boolean>(attribute: {
-    key: string
-    value: T
-  }): [Hex, Hex] {
-    return [
-      toHex(attribute.key),
-      toHex(typeof attribute.value === "number" && attribute.value === 0 ? "" : attribute.value),
-    ]
+// RFC 2045 token chars, lowercase only. Rejects uppercase to prevent text/plain vs Text/Plain ambiguity.
+const MIME_REGEX = /^[a-z][a-z0-9!#$&\-^_]*\/[a-z0-9][a-z0-9!#$&\-^_.+]*$/
+
+function validateContentType(contentType: string): void {
+  if (!MIME_REGEX.test(contentType)) {
+    throw new InvalidContentTypeError(contentType)
   }
+}
+
+// Mime128 = struct { bytes32[4] data }  (128-byte fixed MIME type container)
+// Attribute = struct { bytes32 name, uint8 valueType, bytes32[4] value }
+// BlockNumber = type BlockNumber is uint32
+export const ENTITY_EXECUTE_ABI = parseAbi([
+  "function execute((uint8 operationType, bytes32 entityKey, bytes payload, (bytes32[4] data) contentType, (bytes32 name, uint8 valueType, bytes32[4] value)[] attributes, uint32 expiresIn, address newOwner)[] ops) external",
+])
+
+export const ENTITY_OPERATION_EVENT_ABI = parseAbi([
+  "event EntityOperation(bytes32 indexed entityKey, uint8 indexed operationType, address indexed owner, uint32 expiresAt, bytes32 entityHash)",
+])
 
-  const payload = [
-    //creates
-    (creates ?? []).map((item) => [
-      toHex(Math.ceil(item.expiresIn / BLOCK_TIME)),
-      toHex(item.contentType),
-      toHex(item.payload),
-      item.attributes
-        .filter((attribute) => typeof attribute.value === "string")
-        .map(formatAttributes),
-      item.attributes
-        .filter((attribute) => typeof attribute.value === "number")
-        .map(formatAttributes),
-    ]),
-    //updates
-    (updates ?? []).map((item) => [
-      item.entityKey,
-      toHex(item.contentType),
-      toHex(Math.ceil(item.expiresIn / BLOCK_TIME)),
-      toHex(item.payload),
-      item.attributes
-        .filter((attribute) => typeof attribute.value === "string")
-        .map(formatAttributes),
-      item.attributes
-        .filter((attribute) => typeof attribute.value === "number")
-        .map(formatAttributes),
-    ]),
-    //deletes
-    (deletes ?? []).map((item) => item.entityKey),
-    //extends
-    (extensions ?? []).map((item) => [
-      item.entityKey,
-      toHex(Math.ceil(item.expiresIn / BLOCK_TIME)),
-    ]),
-    //ownershipChanges TODO
-    (ownershipChanges ?? []).map((item) => [item.entityKey, item.newOwner]),
+export const ENTITY_ERRORS_ABI = parseAbi([
+  "error EmptyBatch()",
+  "error AttributesNotSorted()",
+  "error InvalidValueType(bytes32 name, uint8 valueType)",
+  "error InvalidOpType(uint8 operationType)",
+  "error ExpiryInPast(uint32 expiresAt, uint32 currentBlock)",
+  "error TooManyAttributes(uint256 count, uint256 maxCount)",
+  "error EntityNotFound(bytes32 entityKey)",
+  "error NotOwner(bytes32 entityKey, address caller, address owner)",
+  "error EntityExpired(bytes32 entityKey, uint32 expiresAt)",
+  "error ExpiryNotExtended(bytes32 entityKey, uint32 newExpiresAt, uint32 currentExpiresAt)",
+  "error TransferToZeroAddress(bytes32 entityKey)",
+  "error TransferToSelf(bytes32 entityKey)",
+  "error EntityNotExpired(bytes32 entityKey, uint32 expiresAt)",
+  "error Ident32Empty()",
+  "error Ident32TooLong(uint256 length)",
+  "error Ident32InvalidByte(uint256 position, bytes1 value)",
+  "error MimeEmpty()",
+  "error MimeTooLong(uint256 length, uint256 maxLength)",
+  "error MimeInvalidByte(uint256 position, bytes1 value)",
+  "error MimeIncomplete()",
+])
+
+const EXECUTE_ABI = [...ENTITY_EXECUTE_ABI, ...ENTITY_ERRORS_ABI]
+
+const ENTITY_NONCE_ABI = parseAbi(["function nonces(address owner) view returns (uint32)"])
+
+const ZERO_ADDRESS: Address = "0x0000000000000000000000000000000000000000"
+const ZERO_32 = `0x${"00".repeat(32)}` as Hex
+const EMPTY_BYTES128 = [ZERO_32, ZERO_32, ZERO_32, ZERO_32] as const
+
+// Encode a string or bytes into a bytes32[4] (128-byte) container, left-aligned.
+function encodeBytes128(data: Uint8Array): readonly [Hex, Hex, Hex, Hex] {
+  const padded = new Uint8Array(128)
+  padded.set(data.slice(0, 128))
+  return [
+    toHex(padded.slice(0, 32)),
+    toHex(padded.slice(32, 64)),
+    toHex(padded.slice(64, 96)),
+    toHex(padded.slice(96, 128)),
   ]
+}
 
-  logger("txData to send as RLP %o length %d", payload, payload.length)
+// Mime128 struct: bytes32[4] data, string packed left-aligned into 128 bytes.
+function encodeMime128(contentType: string): { data: readonly [Hex, Hex, Hex, Hex] } {
+  return { data: contentType ? encodeBytes128(stringToBytes(contentType)) : EMPTY_BYTES128 }
+}
+
+function encodeAttribute(attr: { key: string; value: Hex | string | number }) {
+  validateAttribute(attr)
+  const name = toHex(attr.key, { size: 32 })
+
+  if (typeof attr.value === "string") {
+    // Only exact 32-byte hex (an entity key) gets the EntityKey type; shorter or
+    // longer hex-looking strings are stored as plain strings so they round-trip
+    // unchanged and stay matchable by quoted string queries.
+    if (isEntityKey(attr.value)) {
+      return {
+        name,
+        valueType: AttributeValueType.EntityKey,
+        value: [toHex(toBytes(attr.value), { size: 32 }), ZERO_32, ZERO_32, ZERO_32] as const,
+      }
+    }
+    return {
+      name,
+      valueType: AttributeValueType.String,
+      // stringToBytes, not toBytes: toBytes hex-decodes hex-looking strings, which
+      // would corrupt string values like "0xab" instead of UTF-8 encoding them
+      value: encodeBytes128(stringToBytes(attr.value)),
+    }
+  }
 
-  return toRlp(payload)
+  return {
+    name,
+    valueType: AttributeValueType.Uint,
+    value: [toHex(BigInt(attr.value), { size: 32 }), ZERO_32, ZERO_32, ZERO_32] as const,
+  }
 }
 
-export async function sendArkivTransaction(client: ArkivClient, data: Hex, txParams?: TxParams) {
+// The registry requires attributes strictly ascending by their bytes32 name — the
+// canonical serialization hashes into the state root, and strict ordering doubles as
+// the uniqueness check (AttributesNotSorted). Sort here so callers can pass any order;
+// duplicates would revert on-chain, so reject them client-side with a clear error.
+function encodeAttributes(attrs: { key: string; value: Hex | string | number }[]) {
+  const encoded = attrs
+    .map((attr) => ({ key: attr.key, ...encodeAttribute(attr) }))
+    .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+  for (let i = 1; i < encoded.length; i++) {
+    if (encoded[i].name === encoded[i - 1].name) {
+      throw new DuplicateAttributeError(encoded[i].key)
+    }
+  }
+  return encoded.map(({ key: _, ...attr }) => attr)
+}
+
+function toBTL(expiresIn: number): number {
+  validateExpiresIn(expiresIn)
+  return Math.ceil(expiresIn / BLOCK_TIME)
+}
+
+// entityKey = keccak256(chainId || registryAddress || ownerAddress || nonce)
+function deriveEntityKey(chainId: number, owner: Address, nonce: bigint): Hex {
+  return keccak256(
+    encodePacked(
+      ["uint256", "address", "address", "uint32"],
+      [BigInt(chainId), ARKIV_ADDRESS, owner, Number(nonce)],
+    ),
+  )
+}
+
+export type SendArkivTransactionResult = {
+  receipt: TransactionReceipt
+  createdEntityKeys: Hex[]
+}
+
+export async function sendArkivTransaction(
+  client: ArkivClient,
+  ops: {
+    creates?: CreateEntityParameters[]
+    updates?: UpdateEntityParameters[]
+    deletes?: DeleteEntityParameters[]
+    extensions?: ExtendEntityParameters[]
+    ownershipChanges?: ChangeOwnershipParameters[]
+  },
+  txParams?: TxParams,
+): Promise<SendArkivTransactionResult> {
   if (!client.account) throw new Error("Account required")
+  if (!client.chain) throw new Error("Chain required")
   const walletClient = client as WalletArkivClient
 
-  logger("Sending transaction %o", {
-    account: client.account,
-    chain: client.chain,
-    to: ARKIV_ADDRESS,
-    value: 0n,
-    data,
-    ...txParams,
-  })
+  const { creates, updates, deletes, extensions, ownershipChanges } = ops
+  const owner = client.account.address as Address
+
+  const ownerNonce: bigint = creates?.length
+    ? BigInt(
+        await walletClient.readContract({
+          address: ARKIV_ADDRESS,
+          abi: ENTITY_NONCE_ABI,
+          functionName: "nonces",
+          args: [owner],
+        }),
+      )
+    : 0n
+
+  const createdEntityKeys: Hex[] = (creates ?? []).map((_, i) =>
+    deriveEntityKey(client.chain!.id, owner, ownerNonce + BigInt(i)),
+  )
+
+  for (const item of creates ?? []) validateContentType(item.contentType)
+  for (const item of updates ?? []) validateContentType(item.contentType)
+
+  const operations = [
+    ...(creates ?? []).map((item, i) => ({
+      operationType: EntityOperationType.Create,
+      entityKey: createdEntityKeys[i],
+      payload: toHex(item.payload),
+      contentType: encodeMime128(item.contentType),
+      attributes: encodeAttributes(item.attributes),
+      expiresIn: toBTL(item.expiresIn),
+      newOwner: ZERO_ADDRESS,
+    })),
+    ...(updates ?? []).map((item) => ({
+      operationType: EntityOperationType.Update,
+      entityKey: item.entityKey,
+      payload: toHex(item.payload),
+      contentType: encodeMime128(item.contentType),
+      attributes: encodeAttributes(item.attributes),
+      expiresIn: 0, // contract ignores expiresAt on UPDATE
+      newOwner: ZERO_ADDRESS,
+    })),
+    ...(deletes ?? []).map((item) => ({
+      operationType: EntityOperationType.Delete,
+      entityKey: item.entityKey,
+      payload: "0x" as Hex,
+      contentType: encodeMime128(""),
+      attributes: [] as never[],
+      expiresIn: 0,
+      newOwner: ZERO_ADDRESS,
+    })),
+    ...(extensions ?? []).map((item) => ({
+      operationType: EntityOperationType.Extend,
+      entityKey: item.entityKey,
+      payload: "0x" as Hex,
+      contentType: encodeMime128(""),
+      attributes: [] as never[],
+      expiresIn: toBTL(item.expiresIn),
+      newOwner: ZERO_ADDRESS,
+    })),
+    ...(ownershipChanges ?? []).map((item) => ({
+      operationType: EntityOperationType.Transfer,
+      entityKey: item.entityKey,
+      payload: "0x" as Hex,
+      contentType: encodeMime128(""),
+      attributes: [] as never[],
+      expiresIn: 0,
+      newOwner: item.newOwner as Address,
+    })),
+  ]
+
+  logger("Sending execute with %d operations %s", operations.length, JSON.stringify(operations))
 
   try {
-    const compressed = await compress(toBytes(data))
-    const txHash = await walletClient.sendTransaction({
+    const txHash = await walletClient.writeContract({
+      address: ARKIV_ADDRESS,
+      abi: EXECUTE_ABI,
+      functionName: "execute",
+      args: [operations],
       account: client.account,
       chain: client.chain,
-      to: ARKIV_ADDRESS,
-      value: 0n,
-      data: toHex(compressed),
       ...txParams,
     })
 
     const receipt = await walletClient.waitForTransactionReceipt({ hash: txHash })
     logger("Tx receipt %o", receipt)
+
     if (receipt.status === "reverted") {
       try {
-        const callResult = await walletClient.call({
+        await walletClient.simulateContract({
+          address: ARKIV_ADDRESS,
+          abi: EXECUTE_ABI,
+          functionName: "execute",
+          args: [operations],
           account: client.account,
-          to: ARKIV_ADDRESS,
-          value: 0n,
-          data: toHex(compressed),
-          ...txParams,
+          chain: client.chain,
         })
-        throw new EntityMutationError(
-          `Transaction ${receipt.transactionHash} reverted. Please make sure the data for entities doesn't contain invalid characters or invalid data types.
-          Reason: ${callResult.data ? hexToString(callResult.data) : "No reason provided by backend."}`,
-        )
       } catch (err) {
-        const error = err as { cause?: { details?: string } }
-        const reason = error.cause?.details ?? "No reason provided by backend."
-        logger(
-          "Error while calling to get more details about reverted transaction. Reason: %s",
-          reason,
-        )
+        const error = err as { shortMessage?: string; cause?: { details?: string } }
+        const reason =
+          error.shortMessage ?? error.cause?.details ?? "No reason provided by backend."
         throw new EntityMutationError(
           `Transaction ${receipt.transactionHash} reverted. Reason: ${reason}`,
         )
       }
+      throw new EntityMutationError(
+        `Transaction ${receipt.transactionHash} reverted. No reason provided by backend.`,
+      )
     }
 
-    return receipt
+    return { receipt, createdEntityKeys }
   } catch (error) {
     let message = "Transaction failed"
     if (error instanceof TransactionExecutionError) {
       message += `: ${error.details}`
+    } else if (error instanceof ContractFunctionExecutionError) {
+      logger("Contract function execution error data:", error.shortMessage)
+      if (error.cause instanceof ContractFunctionRevertedError) {
+        message += `: ${error.cause.message}`
+      } else {
+        message += ": Execution error without revert data"
+      }
     } else if (error instanceof EntityMutationError) {
       throw error
     }
 
-    logger("%s Detailed error stack: %o", message, error)
     throw new EntityMutationError(message)
   }
 }