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

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,149 +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 { validateAttribute, validateExpiresIn } from "./validation"
+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) => {
-      validateExpiresIn(item.expiresIn)
-      item.attributes.forEach(validateAttribute)
-      return [
-        toHex(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) => {
-      validateExpiresIn(item.expiresIn)
-      item.attributes.forEach(validateAttribute)
-      return [
-        item.entityKey,
-        toHex(item.contentType),
-        toHex(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) => {
-      validateExpiresIn(item.expiresIn)
-      return [item.entityKey, toHex(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)
   }
 }

package/src/utils/entities.ts

@@ -1,8 +1,22 @@
-import { toBytes } from "viem"
+import { type Hex, toBytes } from "viem"
+import type { Attribute } from "../types/attributes"
 import { Entity } from "../types/entity"
 import type { RpcEntity } from "../types/rpcSchema"
+import { RpcAttributeValueType } from "../types/rpcSchema"
 import { getLogger } from "./logger"
 
+function decodeAttributeValue(value: string, valueType: RpcAttributeValueType): Attribute["value"] {
+  switch (valueType) {
+    case RpcAttributeValueType.Uint:
+      return Number(BigInt(value as Hex))
+    case RpcAttributeValueType.EntityKey:
+      return value as Hex
+    case RpcAttributeValueType.String:
+    default:
+      return value
+  }
+}
+
 const logger = getLogger("utils:entities")
 
 export async function entityFromRpcResult(rpcEntity: RpcEntity) {
@@ -24,13 +38,9 @@ export async function entityFromRpcResult(rpcEntity: RpcEntity) {
       : undefined,
     rpcEntity.value !== undefined ? toBytes(rpcEntity.value) : undefined,
     [
-      ...(rpcEntity.stringAttributes ?? []).map(({ key, value }) => ({
-        key,
-        value,
-      })),
-      ...(rpcEntity.numericAttributes ?? []).map(({ key, value }) => ({
+      ...(rpcEntity.attributes ?? []).map(({ key, value, valueType }) => ({
         key,
-        value: Number(value),
+        value: decodeAttributeValue(value, valueType),
       })),
     ],
   )

package/src/utils/payload.ts

@@ -1,9 +1,11 @@
-import { toBytes } from "viem"
+import { stringToBytes, toBytes } from "viem"
 
 export function jsonToPayload(json: object): Uint8Array {
   return toBytes(JSON.stringify(json))
 }
 
 export function stringToPayload(data: string): Uint8Array {
-  return toBytes(data)
+  // stringToBytes, not toBytes: toBytes hex-decodes hex-looking strings, which
+  // would corrupt payloads like "0xab" instead of UTF-8 encoding them
+  return stringToBytes(data)
 }

package/src/utils/validation.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "bun:test"
 import { BLOCK_TIME } from "../consts"
-import { InvalidAttributeError, InvalidExpirationError } from "../errors"
-import { validateAttribute, validateExpiresIn } from "./validation"
+import { InvalidAttributeError, InvalidAttributeKeyError, InvalidExpirationError } from "../errors"
+import { validateAttribute, validateAttributeKey, validateExpiresIn } from "./validation"
 
 describe("validateExpiresIn", () => {
   it("accepts positive integers that are a multiple of the block time", () => {
@@ -42,10 +42,9 @@ describe("validateAttribute", () => {
     expect(() => validateAttribute({ key: "k", value: "anything" })).not.toThrow()
   })
 
-  it("accepts integer numeric values", () => {
+  it("accepts non-negative integer numeric values", () => {
     expect(() => validateAttribute({ key: "k", value: 0 })).not.toThrow()
     expect(() => validateAttribute({ key: "k", value: 123 })).not.toThrow()
-    expect(() => validateAttribute({ key: "k", value: -5 })).not.toThrow()
   })
 
   it("throws for non-integer numeric values", () => {
@@ -53,8 +52,55 @@ describe("validateAttribute", () => {
     expect(() => validateAttribute({ key: "k", value: Number.NaN })).toThrow(InvalidAttributeError)
   })
 
+  it("throws for negative numeric values", () => {
+    expect(() => validateAttribute({ key: "k", value: -5 })).toThrow(InvalidAttributeError)
+    expect(() => validateAttribute({ key: "k", value: -0.5 })).toThrow(InvalidAttributeError)
+  })
+
   it("includes the attribute key and value in the error message", () => {
-    expect(() => validateAttribute({ key: "myKey", value: 1.5 })).toThrow(/myKey/)
-    expect(() => validateAttribute({ key: "myKey", value: 1.5 })).toThrow(/1\.5/)
+    expect(() => validateAttribute({ key: "my_key", value: 1.5 })).toThrow(/my_key/)
+    expect(() => validateAttribute({ key: "my_key", value: 1.5 })).toThrow(/1\.5/)
+  })
+})
+
+describe("validateAttributeKey", () => {
+  it("accepts valid Ident32 keys", () => {
+    expect(() => validateAttributeKey("a")).not.toThrow()
+    expect(() => validateAttributeKey("tag")).not.toThrow()
+    expect(() => validateAttributeKey("num_attr")).not.toThrow()
+    expect(() => validateAttributeKey("a.b-c_d9")).not.toThrow()
+    expect(() => validateAttributeKey("a".repeat(32))).not.toThrow()
+  })
+
+  it("throws for an empty key", () => {
+    expect(() => validateAttributeKey("")).toThrow(InvalidAttributeKeyError)
+  })
+
+  it("throws when the key does not start with a lowercase letter", () => {
+    expect(() => validateAttributeKey("Tag")).toThrow(InvalidAttributeKeyError)
+    expect(() => validateAttributeKey("1tag")).toThrow(InvalidAttributeKeyError)
+    expect(() => validateAttributeKey("_tag")).toThrow(InvalidAttributeKeyError)
+    expect(() => validateAttributeKey(".tag")).toThrow(InvalidAttributeKeyError)
+  })
+
+  it("throws for invalid characters after the first", () => {
+    expect(() => validateAttributeKey("strAttr")).toThrow(InvalidAttributeKeyError)
+    expect(() => validateAttributeKey("has space")).toThrow(InvalidAttributeKeyError)
+    expect(() => validateAttributeKey("has:colon")).toThrow(InvalidAttributeKeyError)
+    expect(() => validateAttributeKey("héllo")).toThrow(InvalidAttributeKeyError)
+  })
+
+  it("throws for keys longer than 32 bytes", () => {
+    expect(() => validateAttributeKey("a".repeat(33))).toThrow(InvalidAttributeKeyError)
+  })
+
+  it("names the offending character and position", () => {
+    expect(() => validateAttributeKey("strAttr")).toThrow(/"A" at position 3/)
+  })
+
+  it("is applied by validateAttribute", () => {
+    expect(() => validateAttribute({ key: "strAttr", value: "x" })).toThrow(
+      InvalidAttributeKeyError,
+    )
   })
 })

package/src/utils/validation.ts

@@ -1,7 +1,20 @@
+import type { Hex } from "viem"
+import { isHex } from "viem"
 import { BLOCK_TIME } from "../consts"
-import { InvalidAttributeError, InvalidExpirationError } from "../errors"
+import { InvalidAttributeError, InvalidAttributeKeyError, InvalidExpirationError } from "../errors"
 import type { Attribute } from "../types"
 
+/**
+ * True only for hex strings that are exactly 32 bytes (an entity key). This is
+ * the single rule deciding whether an attribute string value is stored as the
+ * on-chain `EntityKey` type or as a plain string — the query engine applies
+ * the same rule, so equality comparisons agree with storage on both paths.
+ * Hex-looking strings of any other length are treated as ordinary strings.
+ */
+export function isEntityKey(value: string): value is Hex {
+  return isHex(value) && value.length === 66
+}
+
 /**
  * Expiration on Arkiv is measured in blocks (1 block =
  * 2 seconds), so the value must be a positive integer that is
@@ -18,15 +31,50 @@ export function validateExpiresIn(expiresIn: number): void {
 }
 
 /**
- * Validates a single attribute. Arkiv supports string and number attribute
- * values, but numeric values must be integers.
+ * Validates an attribute key against the on-chain `Ident32` rules (mirrors
+ * `Ident32.sol` / `validate_ident32_bytes` in the node): non-empty, at most
+ * 32 bytes, leading character `a-z`, remaining characters `a-z 0-9 . - _`.
+ *
+ * @param key - The attribute key to validate.
+ * @throws {InvalidAttributeKeyError} If the key violates the `Ident32` rules.
+ */
+export function validateAttributeKey(key: string): void {
+  if (key.length === 0) {
+    throw new InvalidAttributeKeyError(key, "key is empty")
+  }
+  if (!/^[a-z]/.test(key)) {
+    throw new InvalidAttributeKeyError(key, `key starts with "${key[0]}"`)
+  }
+  const invalid = key.match(/[^a-z0-9._-]/)
+  if (invalid) {
+    throw new InvalidAttributeKeyError(
+      key,
+      `key contains "${invalid[0]}" at position ${invalid.index}`,
+    )
+  }
+  // The charset is ASCII-only, so string length equals byte length here.
+  if (key.length > 32) {
+    throw new InvalidAttributeKeyError(key, `key is ${key.length} bytes long`)
+  }
+}
+
+/**
+ * Validates a single attribute. Keys must follow the on-chain `Ident32` rules
+ * (see {@link validateAttributeKey}). Arkiv supports string and number
+ * attribute values, but numeric values must be non-negative integers — they
+ * are stored on-chain as unsigned 256-bit values.
  *
  * @param attribute - The attribute to validate.
- * @throws {InvalidAttributeError} If the attribute has a non-integer numeric
- * value.
+ * @throws {InvalidAttributeKeyError} If the key violates the `Ident32` rules.
+ * @throws {InvalidAttributeError} If the attribute has a non-integer or
+ * negative numeric value.
  */
 export function validateAttribute(attribute: Attribute): void {
-  if (typeof attribute.value === "number" && !Number.isInteger(attribute.value)) {
+  validateAttributeKey(attribute.key)
+  if (
+    typeof attribute.value === "number" &&
+    (!Number.isInteger(attribute.value) || attribute.value < 0)
+  ) {
     throw new InvalidAttributeError(attribute.key, attribute.value)
   }
 }

package/dist/consts-BV4PR-de.js

@@ -1,7 +0,0 @@
-//#region src/consts.ts
-const ARKIV_ADDRESS = "0x00000000000000000000000000000061726b6976";
-const BLOCK_TIME = 2;
-
-//#endregion
-export { BLOCK_TIME as n, ARKIV_ADDRESS as t };
-//# sourceMappingURL=consts-BV4PR-de.js.map

package/dist/consts-BV4PR-de.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"consts-BV4PR-de.js","names":[],"sources":["../src/consts.ts"],"sourcesContent":["export const ARKIV_ADDRESS = \"0x00000000000000000000000000000061726b6976\" as `0x${string}`\nexport const BLOCK_TIME = 2 // 2 seconds\n"],"mappings":";AAAA,MAAa,gBAAgB;AAC7B,MAAa,aAAa"}

package/dist/entity-B6g_EPm1.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entity-B6g_EPm1.d.cts","names":[],"sources":["../src/types/mimeTypes.ts","../src/types/rpcSchema.ts","../src/clients/baseClient.ts","../src/actions/public/getBlockTiming.ts","../src/actions/public/query.ts","../src/actions/wallet/changeOwnership.ts","../src/actions/wallet/createEntity.ts","../src/actions/wallet/deleteEntity.ts","../src/actions/wallet/extendEntity.ts","../src/actions/wallet/updateEntity.ts","../src/actions/wallet/mutateEntities.ts","../src/types/attributes.ts","../src/types/events.ts","../src/types/txParams.ts","../src/types/entity.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/entity-qoLMAuuk.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entity-qoLMAuuk.d.ts","names":[],"sources":["../src/types/mimeTypes.ts","../src/types/rpcSchema.ts","../src/clients/baseClient.ts","../src/actions/public/getBlockTiming.ts","../src/actions/public/query.ts","../src/actions/wallet/changeOwnership.ts","../src/actions/wallet/createEntity.ts","../src/actions/wallet/deleteEntity.ts","../src/actions/wallet/extendEntity.ts","../src/actions/wallet/updateEntity.ts","../src/actions/wallet/mutateEntities.ts","../src/types/attributes.ts","../src/types/events.ts","../src/types/txParams.ts","../src/types/entity.ts"],"sourcesContent":[],"mappings":"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"}