@arkiv-network/sdk 0.8.1-dev.1 → 0.9.0-next.2

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { A as i32, B as Bytes32Value, C as ValueInput, D as dec, E as bytes32, F as u64, G as StrValue, H as DecValue, I as AddrValue, J as U64Value, K as TypeTag, L as AnyArkivValue, M as str, N as toValue, O as decFromUnits, P as u256, R as ArkivValue, S as U64_MAX, T as bool, U as I32Value, V as BytesValue, W as KeyValue, X as isArkivValue, Y as UserTypeTag, _ as MAX_PAYLOAD_BYTES, a as InvalidAttributeNameError, b as MAX_STRING_BYTES, c as TooManyAttributesError, d as DECIMAL_SCALE, f as DECIMAL_UNIT, g as MAX_ATTRIBUTES, h as Attributes, i as ConflictingMutationError, j as key, k as decUnits, l as UnknownAttributeTypeError, m as AttributeSchema, n as isValidAttributeName, o as InvalidValueError, p as AttributeInputs, q as U256Value, r as validateAttributeName, s as MissingValueError, t as MAX_NAME_BYTES, u as UntypedValueError, v as I32_MAX, w as addr, x as U256_MAX, y as I32_MIN, z as BoolValue } from "./index-Cd2aaWme.js";
-import { _ as NoRandomSourceError, a as SaltInput, c as CreationFlags, d as encodeCreationFlags, f as ENTITY_EVENTS_ABI, g as InvalidSaltError, h as InvalidExpiryError, i as NO_SALT, l as ResolvedCreationFlags, m as InvalidCreationFlagsError, n as OperationType, o as predictEntityKey, p as EntityEventName, r as MAX_SALT, s as randomSalt, t as MAX_EXPIRES_AT, u as decodeCreationFlags } from "./index-BkqSnGJH.js";
-import { a as ResolvedExpiry, i as Lifetime, n as Expiry, o as resolveExpiry, r as ExpiryContext, s as toBlocks, t as EncodedExpiry } from "./expiry-BxOlvVWC.js";
-import { C as QueryOptions, D as ProjectedEntity, E as FullEntity, L as Expression, M as EntityFields, O as SelectArg, S as OwnershipTransferredEvent, T as EntitySelection, _ as EntityDeletedEvent, a as PatchEntityParameters, at as ArkivClient, b as EntityPatchedEvent, c as ExtendEntityReturnType, ct as RpcAttributeSchemaEntry, d as CreateEntityParameters, dt as RpcQueryOptions, f as CreateEntityReturnType, ft as RpcSelect, g as EntityCreatedEvent, h as WatchEntityEventsParameters, i as ExecuteBatchReturnType, it as GetBlockTimingReturnType, j as Entity, l as DeleteEntityParameters, lt as RpcCreationFlags, m as ChangeOwnershipReturnType, n as MimeType, nt as PredictEntityKeysReturnType, o as PatchEntityReturnType, ot as ArkivRpcSchema, p as ChangeOwnershipParameters, r as ExecuteBatchParameters, rt as PredictedEntityKey, s as ExtendEntityParameters, st as RpcAttribute, t as TxParams, tt as PredictEntityKeysParameters, u as DeleteEntityReturnType, ut as RpcEntity, v as EntityEvent, w as QueryReturnType, x as ExpiryExtendedEvent, y as EntityEventContext } from "./index-DaNeJUw8.js";
-import { n as QueryResult, t as SelectQueryBuilder } from "./index-Cq6fa8AI.js";
-import { i as ExpirationTime, n as stringToPayload, r as DeadlineOptions, t as jsonToPayload } from "./payload-AfUfSctb.js";
+import { a as predictEntityKey, c as ResolvedCreationFlags, d as InvalidCreationFlagsError, f as InvalidExpiryError, i as SaltInput, l as ENTITY_EVENTS_ABI, m as NoRandomSourceError, n as MAX_SALT, o as randomSalt, p as InvalidSaltError, r as NO_SALT, s as CreationFlags, t as MAX_EXPIRES_AT, u as EntityEventName } from "./index-C4zZqJ9S.js";
+import { n as Lifetime, t as Expiry } from "./expiry-S2PUL8Hg.js";
+import { A as FullRow, At as ArkivClient, B as Selection, C as OwnershipTransferredEvent, Dt as PredictEntityKeysReturnType, E as QueryRow, Et as PredictEntityKeysParameters, F as ResultOf, Ft as RpcEntity, H as SelectionOf, I as Row, It as RpcQueryOptions, J as Entity, L as SYSTEM_FIELDS, Lt as RpcSelect, M as NonEmptySelection, Mt as RpcAttribute, N as PartialRow, Nt as RpcAttributeSchemaEntry, O as DynamicSelection, Ot as PredictedEntityKey, Pt as RpcCreationFlags, R as SelectArg, S as ExpiryExtendedEvent, T as QueryReturnType, U as SystemField, Y as EntityFields, Z as AttributeRef, _ as EntityCreatedEvent, a as ExecuteBatchReturnType, b as EntityEventContext, c as PatchEntityReturnType, d as DeleteEntityParameters, f as DeleteEntityReturnType, g as WatchEntityEventsParameters, h as CreateEntityReturnType, i as ExecuteBatchParameters, j as KnownSystemFields, jt as ArkivRpcSchema, k as FullEntity, kt as GetBlockTimingReturnType, l as ExtendEntityParameters, m as CreateEntityParameters, n as ChangeOwnershipReturnType, nt as Expression, o as PatchEntityChanges, p as CreateEntityOptions, r as TxParams, s as PatchEntityParameters, st as SchemaRef, t as ChangeOwnershipParameters, u as ExtendEntityReturnType, v as EntityDeletedEvent, w as QueryOptions, x as EntityPatchedEvent, y as EntityEvent, z as Selected } from "./changeOwnership-gXf-lBqI.js";
+import { $ as u256, A as describeColumns, B as U64_MAX, C as IndexedColumnName, D as SCHEMA_ATTRIBUTE, E as PatchEntityValues, F as I32_MIN, G as bytes32, H as addr, I as MAX_BYTES_LENGTH, J as decUnits, K as dec, L as MAX_STRING_BYTES, M as lookupColumn, N as BareOf, O as Schema, P as I32_MAX, Q as toValue, R as TagOf, S as CreateEntityValues, T as OptionalColumnName, U as bool, V as ValueInput, W as bytes, X as key, Y as i32, Z as str, _ as Attributes, _t as TypeTag, a as EntityTooLargeError, at as AddrValue, b as Columns, bt as ValueOf, c as MissingValueError, ct as Bytes32Value, d as TooManyAttributesError, dt as I32Value, et as u64, f as UnknownAttributeTypeError, ft as INDEXED_FLAG, g as AttributeSchema, gt as StrValue, h as DECIMAL_UNIT, ht as KeyValue, i as ConflictingMutationError, it as isColumn, j as isSchema, k as defineSchema, l as SchemaDefinitionError, lt as BytesValue, m as DECIMAL_SCALE, mt as IndexableValue, n as isValidAttributeName, nt as Column, o as InvalidAttributeNameError, ot as ArkivValue, p as UntypedValueError, pt as IndexableTypeTag, q as decFromUnits, r as validateAttributeName, rt as ValueArgument, s as InvalidValueError, st as BoolValue, t as MAX_NAME_BYTES, tt as AnyColumn, u as SchemaMismatchError, ut as DecValue, v as MAX_ENTITY_BYTES, vt as U256Value, w as MAX_ATTRIBUTES, x as ColumnsOf, xt as isArkivValue, y as ColumnInput, yt as U64Value, z as U256_MAX } from "./index-DLb7BfIw.js";
+import { d as QueryResult, f as CountQueryBuilder, l as FromOptions, p as QueryBuilderBase, u as SelectQueryBuilder } from "./index-DCx2XC6S.js";
+import { n as ExpirationTime, t as DeadlineOptions } from "./expirationTime-C7PZK49K.js";
 import { Account, Address, Chain, Client, Hex, ParseAccount, Prettify, PublicActions, PublicClientConfig, RpcSchema, Transport, WalletActions, WalletClientConfig } from "viem";
 
 //#region src/clients/decorators/arkivPublic.d.ts
@@ -12,14 +12,21 @@ type PublicArkivActions<transport extends Transport = Transport, chain extends C
   /**
    * Returns the entity with the given key.
    *
-   * - JSON-RPC Methods: `arkiv_query`
+   * Given a schema, it is read through it: the result is a flat row of every entity field and
+   * every column, each typed as the schema declares and checked against it.
+   *
+   * - JSON-RPC Methods: `arkiv_getEntity`
    *
    * @param key - The entity key (hex string)
-   * @returns The entity with the given key, with every field populated. {@link FullEntity}
+   * @param schema - Optionally, the schema to read the entity through.
+   * @returns The entity with the given key, with every field populated — a {@link FullEntity}, or
+   * a {@link FullRow} through a schema.
    *
    * @throws {InvalidValueError} If the key is not 32 bytes.
    * @throws {NoEntityFoundError} If no live entity has that key — it never existed, or it was
    * deleted or has expired.
+   * @throws {SchemaMismatchError} If, given a schema, the entity does not fit it.
+   * @throws {SchemaDefinitionError} If the schema given was not built with `defineSchema`.
    *
    * @example
    * import { createPublicClient } from "@arkiv-network/sdk"
@@ -31,83 +38,115 @@ type PublicArkivActions<transport extends Transport = Transport, chain extends C
    *   transport: http(),
    * })
    * const entity = await client.getEntity(entityKey)
-   * // Entity {
-   * //   key: "0x9f2c…",
-   * //   owner: "0xabc…",
-   * //   contentType: "application/json",
-   * //   payload: Uint8Array,          // entity.toJson() / entity.toText() decode it
-   * //   attributes: { category: { type: "str", value: "docs" } },
-   * //   expiresAt: 1_297_000n,
+   * // {
+   * //   $key: "0x9f2c…",
+   * //   $owner: "0xabc…",
+   * //   $expiresAt: 1_297_000n,
+   * //   $attributes: { category: { type: "str", value: "docs" } },
+   * //   ...
    * // }
+   *
+   * const post = await client.getEntity(entityKey, Posts)
+   * // { $key: "0x9f2c…", $owner: "0xabc…", ..., category: { type: "str", value: "docs" }, ... }
    */
-  getEntity: (key: Hex) => Promise<FullEntity>;
+  getEntity: {
+    (key: Hex): Promise<FullEntity>;
+    <S extends Schema>(key: Hex, schema: S): Promise<FullRow<S>>;
+  };
   /**
    * Returns a SelectQueryBuilder for building and executing queries — the recommended way to
    * read entities. You declare up front which parts of an entity you want returned, so results
    * always contain exactly the data you asked for.
    *
+   * The selection names entity fields and attributes side by side, and each result is a flat row.
+   * Chain `.from(schema)` to read through a schema: the selection keeps its meaning, but each
+   * attribute comes back typed and checked as the schema declares, and `where` may only filter on
+   * the schema's indexed columns.
+   *
    * - JSON-RPC Methods: `arkiv_query`
    *
    * @param selection - What to include in the results. Omit it (or pass `"*"`) to select everything,
    *   or pass an object to select specific parts (at least one field is required). Every part is
-   *   opt-in, including the `key`. The selection is flat — each field maps to an entity field.
+   *   opt-in, including the `$key`. The selection is flat — each field maps to a field of the result.
    *   {@link SelectArg}
    * @returns A SelectQueryBuilder instance for building and executing queries. {@link SelectQueryBuilder}
    *
    * @example
    * import { createPublicClient } from "@arkiv-network/sdk"
    * import { tiramisu } from "@arkiv-network/sdk/chains"
-   * import { eq } from "@arkiv-network/sdk/query"
+   * import { and, eq, gt } from "@arkiv-network/sdk/query"
+   * import { dec } from "@arkiv-network/sdk/schema"
    * import { http } from "viem"
    *
    * const client = createPublicClient({
    *   chain: tiramisu,
    *   transport: http(),
    * })
-   * // select everything
-   * await client.select().where(eq("category", "docs")).fetch()
-   * await client.select("*").where(eq("category", "docs")).fetch()
-   * // only the key
-   * await client.select({ key: true }).where(eq("category", "docs")).fetch()
-   * // select specific fields — result typed { owner: Hex; attributes: Attributes }
-   * await client.select({ owner: true, attributes: true }).fetch()
-   * // a single field — result typed { owner: Hex }
-   * await client.select({ owner: true }).fetch()
+   * // through a schema — rows typed { $key: Hex; author: AddrValue; title: StrValue }
+   * await client
+   *   .select({ $key: true, author: true, title: true })
+   *   .from(Posts)
+   *   .where(and(eq("category", "docs"), gt("score", dec("4.0"))))
+   *   .fetch()
+   * // every field and column
+   * await client.select().from(Posts).where(eq("category", "docs")).fetch()
+   *
+   * // the same selection without a schema — rows typed
+   * // { $key: Hex; author: ArkivValue | undefined; title: ArkivValue | undefined }
+   * await client.select({ $key: true, author: true, title: true }).where(eq("category", "docs")).fetch()
    */
   select: {
-    /** Select every field. Pass nothing or `"*"`; the returned entities contain all fields. */
-    (selection?: "*"): SelectQueryBuilder<FullEntity>;
     /**
-     * Pick the entity fields to return. Set the ones you want to `true` (at least one is required);
-     * the result is typed to exactly those fields, so reading anything else is a compile error.
-     *
-     * Available fields: `key`, `owner`, `creator`, `createdAt`, `updatedAt`, `expiresAt`,
-     * `creationFlags`, `contentType`, `payload`, `attributeSchema` and `attributes`.
+     * Select every field — and every column through a schema, or the `$attributes` map without
+     * one. Pass nothing or `"*"`. The `$attributeSchema` is not included: select it by name.
+     */
+    (selection?: "*"): SelectQueryBuilder<"*">;
+    /**
+     * Pick the fields to return. Set the ones you want to `true` (at least one is required); the
+     * result is typed to exactly those fields, so reading anything else is a compile error.
      *
-     * `attributes` also takes a map of names, to fetch only those:
-     * `select({ key: true, attributes: { projectId: true } })`.
+     * Entity fields start with `$`: `$key`, `$owner`, `$creator`, `$createdAt`, `$updatedAt`,
+     * `$expiresAt` and `$creationFlags`. `$attributes` reads every attribute as a map, and
+     * `$attributeSchema` their names, types and indexing without the values — a cheap way to find
+     * out what entities hold before fetching values that may be too large for one response. Any
+     * other name is an attribute, read as a field
+     * of its own: untyped without a schema, and through one typed and checked as the column it
+     * must be. An attribute name cannot start with `$`, so the two never collide.
      *
      * Pass the selection inline so its fields stay literal `true`. A selection stored in a `let`/
-     * `const` variable widens to `boolean` and the result type can no longer be narrowed — annotate
-     * it `as const` (e.g. `const sel = { owner: true } as const`) in that case.
+     * `const` variable widens to `boolean`, and one typed {@link SelectArg} is only known at
+     * runtime: which fields come back is then decided at runtime, so every field of the result is
+     * optional — a {@link PartialRow}. Annotate a stored selection `as const` to keep it narrow.
      *
      * @example
-     * client.select({ owner: true, attributes: true }) // entities typed { owner, attributes }
-     * client.select({ key: true, payload: true })      // includes payload → toText()/toJson() too
-     * client.select({ key: true, attributeSchema: true }) // what shape is the data?
+     * client.select({ $key: true, title: true })               // { $key: Hex; title: ArkivValue | undefined }
+     * client.select({ $key: true, title: true }).from(Posts)  // { $key: Hex; title: StrValue }
+     * client.select({ $owner: true, $attributes: true })      // { $owner: Hex; $attributes: Attributes }
+     * client.select({ $key: true, $attributeSchema: true })   // what do they hold? no values
      */
-    <const S extends EntitySelection>(selection: S): SelectQueryBuilder<ProjectedEntity<S>>;
-    /**
-     * Dynamic selection: accepts a value typed {@link SelectArg} (e.g. built at runtime). The
-     * result cannot be narrowed in this case, so the entities are typed as the full entity.
-     */
-    (selection: SelectArg): SelectQueryBuilder<FullEntity>;
+    <const S extends SelectArg>(selection: S & NonEmptySelection<S> & KnownSystemFields<S>): SelectQueryBuilder<SelectionOf<S>>;
   };
+  /**
+   * Returns a CountQueryBuilder: counts the entities a query matches, without fetching any of them.
+   *
+   * It filters exactly as {@link select} does — `.from(schema)`, `.where(...)`, `.ownedBy(...)`,
+   * `.createdBy(...)` and `.atBlock(...)` — and `.fetch()` resolves to a `bigint`. To show the total
+   * next to a page of rows, use `select(...).withCount()` instead.
+   *
+   * - JSON-RPC Methods: `arkiv_query`, with the `count` projection
+   *
+   * @example
+   * const total = await client.count().from(Posts).ownedBy(account.address).fetch()
+   * const news = await client.count().from(Posts).where(eq("category", "news")).fetch()
+   */
+  count: () => CountQueryBuilder;
   /**
    * Runs one query and returns one page, with no builder in between.
    *
-   * Use {@link PublicArkivActions.select} for anything typed — this returns full {@link Entity} objects whatever the
-   * selection, and takes a raw string as an escape hatch for a query built elsewhere. A raw string
+   * The selection means what it does in {@link PublicArkivActions.select}, and the results are the
+   * same flat rows a query without a schema returns, typed from the selection. Use `select()` to
+   * read through a schema. This also takes a raw string as an escape hatch for a query built
+   * elsewhere. A raw string
    * goes to the node exactly as written, with none of the name, type or operator checks the
    * expression combinators apply.
    *
@@ -119,7 +158,7 @@ type PublicArkivActions<transport extends Transport = Transport, chain extends C
    * import { createPublicClient } from "@arkiv-network/sdk"
    * import { tiramisu } from "@arkiv-network/sdk/chains"
    * import { and, eq, gte } from "@arkiv-network/sdk/query"
-   * import { i32 } from "@arkiv-network/sdk/attr"
+   * import { i32 } from "@arkiv-network/sdk/schema"
    * import { http } from "viem"
    *
    * const client = createPublicClient({
@@ -127,32 +166,15 @@ type PublicArkivActions<transport extends Transport = Transport, chain extends C
    *   transport: http(),
    * })
    * const page = await client.query(and(eq("category", "docs"), gte("level", i32(10))), {
-   *   select: { key: true, attributes: true },
+   *   select: { $key: true, title: true },
    *   limit: 100,
    * })
-   * // { entities: [Entity], cursor: "b64:…", blockNumber: 32223n }
+   * // { entities: [{ $key: Hex; title: ArkivValue | undefined }], cursor: "b64:…", blockNumber: 32223n }
    *
    * // The raw form, unchecked:
    * await client.query("category = str('docs') AND level >= i32(10)")
    */
-  query: (query: Expression | string, queryOptions?: QueryOptions) => Promise<QueryReturnType>;
-  /**
-   * Returns the total number of entities on the chain.
-   * @returns The number of entities currently stored
-   *
-   * @example
-   * import { createPublicClient } from "@arkiv-network/sdk"
-   * import { tiramisu } from "@arkiv-network/sdk/chains"
-   * import { http } from "viem"
-   *
-   * const client = createPublicClient({
-   *   chain: tiramisu,
-   *   transport: http(),
-   * })
-   * const entityCount = await client.getEntityCount()
-   * // entityCount = 0
-   */
-  getEntityCount: () => Promise<number>;
+  query: <const S extends SelectArg = "*">(query: Expression | string, queryOptions?: QueryOptions<S>) => Promise<QueryReturnType<QueryRow<S>>>;
   /**
    * Returns how many entities an account has created — its entity-minting nonce.
    *
@@ -194,18 +216,19 @@ type PublicArkivActions<transport extends Transport = Transport, chain extends C
    *   {@link PredictEntityKeysReturnType}
    *
    * @example A batch whose second entity points at its first.
-   * import { key } from "@arkiv-network/sdk/attr"
+   * import { defineSchema, key, str } from "@arkiv-network/sdk/schema"
+   *
+   * const Nodes = defineSchema("nodes", { name: str(), parent: key().indexed().optional() })
    *
    * const [parent, child] = await client.predictEntityKeys({ owner: account.address, count: 2 })
    * await wallet.executeBatch({
    *   creates: [
-   *     { payload, contentType, expires, salt: parent.salt },
+   *     { schema: Nodes, values: { name: "root" }, expiration, salt: parent.salt },
    *     {
-   *       payload,
-   *       contentType,
-   *       expires,
+   *       schema: Nodes,
+   *       values: { name: "leaf", parent: key(parent.key) },
+   *       expiration,
    *       salt: child.salt,
-   *       attributes: { parent: key(parent.key) },
    *     },
    *   ],
    * })
@@ -288,76 +311,90 @@ declare function createPublicClient<transport extends Transport, chain extends C
 //#region src/clients/decorators/arkivWallet.d.ts
 type WalletArkivActions<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = Pick<PublicActions<transport, chain, account>, "waitForTransactionReceipt" | "call" | "simulateContract" | "readContract" | "getBlockNumber"> & Pick<WalletActions<chain, account>, "addChain" | "sendCalls" | "waitForCallsStatus" | "sendTransaction" | "sendRawTransaction" | "signMessage" | "signTransaction" | "writeContract"> & {
   /**
-   * Creates a new entity.
+   * Creates a new entity through a schema: each column becomes an attribute, written with the
+   * type and indexed flag the schema declares.
    *
    * - JSON-RPC Methods: `eth_sendRawTransaction`
    *
-   * @param data - The entity creation parameters
+   * @param schema - The schema the entity is written through, built with `defineSchema`.
+   * @param values - The entity's values, keyed by column. Required columns must be given;
+   * defaulted ones left out are written with their default. {@link CreateEntityValues}
+   * @param options - The entity's lifetime, plus its flags and salt. {@link CreateEntityOptions}
    * @param txParams - Optional transaction parameters
-   * @returns The new entity's key, the transaction hash, and the block it is expected to
-   * expire at. {@link CreateEntityReturnType}
+   * @returns The new entity's key, the transaction hash, and the block it expires at, as the
+   * engine recorded it. {@link CreateEntityReturnType}
    *
    * @throws {InvalidExpiryError} If the expiry exceeds a protocol bound or would leave the
    * entity dead on arrival.
-   * @throws {InvalidValueError} If an attribute value does not fit the type it names.
-   * @throws {InvalidAttributeNameError} If a name violates the attribute-name grammar.
+   * @throws {SchemaMismatchError} If the values do not fit the schema.
+   * @throws {InvalidValueError} If a value does not fit its type.
+   * @throws {EntityTooLargeError} If the `bytes` values add up to more than `MAX_ENTITY_BYTES`.
+   * @throws {EntityMutationError} If the transaction fails or reverts.
    *
    * @example
-   * import { createWalletClient, ExpirationTime, jsonToPayload } from "@arkiv-network/sdk"
-   * import { i32 } from "@arkiv-network/sdk/attr"
+   * import { createWalletClient, ExpirationTime } from "@arkiv-network/sdk"
+   * import { addr, bytes, dec, defineSchema, str } from "@arkiv-network/sdk/schema"
    * import { tiramisu } from "@arkiv-network/sdk/chains"
    * import { http } from "viem"
    * import { privateKeyToAccount } from "viem/accounts"
    *
+   * const Posts = defineSchema("posts", {
+   *   author:    addr().indexed(),
+   *   category:  str().indexed(),
+   *   score:     dec().indexed(),
+   *   title:     str(),
+   *   body:      bytes(),
+   *   thumbnail: bytes().optional(),
+   *   mimeType:  str().default("text/markdown"),
+   * })
+   *
    * const client = createWalletClient({
    *   account: privateKeyToAccount("0x..."),
    *   chain: tiramisu,
    *   transport: http(),
    * })
-   * const { entityKey, txHash, expiresAt } = await client.createEntity({
-   *   payload: jsonToPayload({ entityType: "testType", entityId: "testId" }),
-   *   contentType: "application/json",
-   *   attributes: { testKey: "testValue", level: i32(3) },
-   *   expires: ExpirationTime.fromDays(30),
-   * })
+   * const { entityKey, txHash, expiresAt } = await client.createEntity(
+   *   Posts,
+   *   {
+   *     author: addr(client.account.address),
+   *     category: "docs",
+   *     score: dec("4.1"),
+   *     title: "Cells, not entities",
+   *     body: new TextEncoder().encode("# Hello"),
+   *   },
+   *   { expiration: ExpirationTime.fromDays(30) },
+   * )
    */
-  createEntity: (data: CreateEntityParameters, txParams?: TxParams) => Promise<CreateEntityReturnType>;
+  createEntity: <S extends Schema>(schema: S, values: CreateEntityValues<S>, options: CreateEntityOptions, txParams?: TxParams) => Promise<CreateEntityReturnType>;
   /**
-   * Applies a patch to the entity with the given key: sets some fields, unsets others, and leaves
-   * everything it does not name alone.
+   * Patches the entity with the given key through a schema: sets some columns, unsets optional
+   * ones, and leaves everything it does not name alone.
    *
    * - JSON-RPC Methods: `eth_sendRawTransaction`
    *
-   * @param data - The entity key and the mutations to apply
+   * @param schema - The schema the changes are typed by.
+   * @param entityKey - The entity to patch.
+   * @param changes - The columns to set and the optional columns to unset. {@link PatchEntityChanges}
    * @param txParams - Optional transaction parameters
    * @returns The patched entity's key and the transaction hash. {@link PatchEntityReturnType}
    *
    * @throws {EmptyPatchError} If the patch has nothing to apply.
    * @throws {ConflictingMutationError} If a name appears in both `set` and `unset`.
-   * @throws {InvalidValueError} If an attribute value does not fit the type it names.
-   * @throws {InvalidAttributeNameError} If a name violates the attribute-name grammar.
+   * @throws {SchemaMismatchError} If the changes do not fit the schema.
+   * @throws {InvalidValueError} If a value does not fit its type.
+   * @throws {EntityTooLargeError} If the `bytes` values in `set` add up to more than
+   * `MAX_ENTITY_BYTES`.
+   * @throws {EntityMutationError} If the transaction fails or reverts.
    *
    * @example
-   * import { createWalletClient, jsonToPayload } from "@arkiv-network/sdk"
-   * import { i32 } from "@arkiv-network/sdk/attr"
-   * import { tiramisu } from "@arkiv-network/sdk/chains"
-   * import { http } from "viem"
-   * import { privateKeyToAccount } from "viem/accounts"
-   *
-   * const client = createWalletClient({
-   *   account: privateKeyToAccount("0x..."),
-   *   chain: tiramisu,
-   *   transport: http(),
-   * })
-   * // Publish the entity: one attribute changes, one goes away, the payload is replaced.
-   * const { txHash } = await client.patchEntity({
-   *   entityKey,
-   *   set: { status: "published", revision: i32(2) },
-   *   unset: ["draft"],
-   *   payload: jsonToPayload({ title: "Hello" }),
+   * // Posts is the schema from the createEntity example.
+   * // One column changes, an optional one goes away.
+   * const { txHash } = await client.patchEntity(Posts, entityKey, {
+   *   set: { score: dec("4.5") },
+   *   unset: ["thumbnail"],
    * })
    */
-  patchEntity: (data: PatchEntityParameters, txParams?: TxParams) => Promise<PatchEntityReturnType>;
+  patchEntity: <S extends Schema>(schema: S, entityKey: Hex, changes: PatchEntityChanges<S>, txParams?: TxParams) => Promise<PatchEntityReturnType>;
   /**
    * Deletes the entity with the given key.
    *
@@ -387,14 +424,15 @@ type WalletArkivActions<transport extends Transport = Transport, chain extends C
    *
    * The new lifetime is resolved the same way a create's is: a duration counts from now rather
    * than adding to what the entity has left, and `atBlock` / `atDate` pin an absolute deadline.
-   * The engine rejects an extension that would not move the expiry later.
+   * The engine rejects an extension that would move the expiry earlier; one that resolves to the
+   * current expiry changes nothing.
    *
    * - JSON-RPC Methods: `eth_sendRawTransaction`
    *
    * @param data - The entity key and its new lifetime
    * @param txParams - Optional transaction parameters
-   * @returns The entity's key, the transaction hash, and the block it is now expected to expire
-   * at. {@link ExtendEntityReturnType}
+   * @returns The entity's key, the transaction hash, and the block it now expires at, as the
+   * engine recorded it. {@link ExtendEntityReturnType}
    *
    * @throws {InvalidExpiryError} If the expiry is malformed, exceeds a protocol bound, or would
    * leave the entity dead on arrival.
@@ -412,7 +450,7 @@ type WalletArkivActions<transport extends Transport = Transport, chain extends C
    * })
    * const { txHash, expiresAt } = await client.extendEntity({
    *   entityKey,
-   *   expires: ExpirationTime.fromDays(30),
+   *   expiration: ExpirationTime.fromDays(30),
    * })
    */
   extendEntity: (data: ExtendEntityParameters, txParams?: TxParams) => Promise<ExtendEntityReturnType>;
@@ -433,19 +471,28 @@ type WalletArkivActions<transport extends Transport = Transport, chain extends C
    * - JSON-RPC Methods: `eth_sendRawTransaction`
    *
    * Every operation lands in one transaction, so the whole batch applies or none of it does.
-   * At least one operation is required.
+   * At least one operation is required. Each create and patch names its own schema and is typed
+   * by it, so one batch can write entities of several schemas.
    *
    * @param data - The batch parameters (creates, patches, deletes, extensions, ownershipChanges)
    * @param txParams - Optional transaction parameters
    * @returns The transaction hash, plus the keys touched by each kind of operation.
    * {@link ExecuteBatchReturnType}
    *
+   * @throws {Error} If the batch has no operations.
    * @throws {InvalidExpiryError} If an expiry exceeds a protocol bound or would leave the entity
    * dead on arrival.
-   * @throws {InvalidValueError} If an attribute value does not fit the type it names.
+   * @throws {SchemaMismatchError} If a create's or patch's values do not fit its schema.
+   * @throws {InvalidValueError} If a value does not fit its type.
+   * @throws {EmptyPatchError} If a patch has nothing to apply.
+   * @throws {ConflictingMutationError} If a patch names a column in both `set` and `unset`.
+   * @throws {EntityTooLargeError} If the `bytes` values of one create or patch add up to more
+   * than `MAX_ENTITY_BYTES`.
+   * @throws {EntityMutationError} If the transaction fails or reverts.
    *
    * @example
-   * import { createWalletClient, ExpirationTime, jsonToPayload } from "@arkiv-network/sdk"
+   * import { createWalletClient, ExpirationTime } from "@arkiv-network/sdk"
+   * import { dec } from "@arkiv-network/sdk/schema"
    * import { tiramisu } from "@arkiv-network/sdk/chains"
    * import { http } from "viem"
    * import { privateKeyToAccount } from "viem/accounts"
@@ -455,23 +502,23 @@ type WalletArkivActions<transport extends Transport = Transport, chain extends C
    *   chain: tiramisu,
    *   transport: http(),
    * })
+   * // Posts is the schema from the createEntity example.
    * const { txHash, createdEntities } = await client.executeBatch({
    *   creates: [{
-   *     payload: jsonToPayload({ entityType: "testType", entityId: "testId" }),
-   *     contentType: "application/json",
-   *     attributes: { testKey: "testValue" },
-   *     expires: ExpirationTime.fromDays(30),
+   *     schema: Posts,
+   *     values: { author, category: "docs", score: dec("4.1"), title: "Hi", body: new Uint8Array() },
+   *     expiration: ExpirationTime.fromDays(30),
    *   }],
-   *   patches: [{ entityKey: keyToRevise, set: { status: "archived" }, unset: ["draft"] }],
+   *   patches: [{ schema: Posts, entityKey: keyToRevise, set: { category: "archive" } }],
    *   deletes: [{ entityKey: staleKey }],
    *   extensions: [{
    *     entityKey: keyToKeepAlive,
-   *     expires: ExpirationTime.atBlock(1_200_000n),
+   *     expiration: ExpirationTime.atBlock(1_200_000n),
    *   }],
    *   ownershipChanges: [{ entityKey: keyToHandOver, newOwner }],
    * })
    */
-  executeBatch: (data: ExecuteBatchParameters, txParams?: TxParams) => Promise<ExecuteBatchReturnType>;
+  executeBatch: <const TCreates extends readonly Schema[] = [], const TPatches extends readonly Schema[] = []>(data: ExecuteBatchParameters<TCreates, TPatches>, txParams?: TxParams) => Promise<ExecuteBatchReturnType>;
 };
 //#endregion
 //#region src/clients/createWalletClient.d.ts
@@ -482,7 +529,10 @@ type WalletArkivClient<transport extends Transport = Transport, chain extends Ch
  *
  * A Wallet Client signs and sends transactions, so it carries an `account` and exposes everything
  * that mutates state — `createEntity`, `patchEntity`, `deleteEntity`, `extendEntity`,
- * `changeOwnership` and `executeBatch` — on top of the read actions a Public Client has.
+ * `changeOwnership` and `executeBatch` — alongside the viem actions those need, such as
+ * `getBlockNumber`, `readContract` and `waitForTransactionReceipt`. It does not have the Arkiv
+ * read actions (`getEntity`, `query`, `select`, `watchEntityEvents`, `predictEntityKeys`); read
+ * through a Public Client from `createPublicClient` for those.
  *
  * @param parameters - Configuration object for the wallet client (chain, transport, account, etc.)
  * @returns An Arkiv Wallet Client. {@link WalletArkivClient}
@@ -521,9 +571,6 @@ declare class EmptyPatchError extends Error {
   readonly entityKey: string;
   constructor(entityKey: string);
 }
-declare class InvalidContentTypeError extends Error {
-  constructor(contentType: string);
-}
 //#endregion
 //#region src/utils/chains.d.ts
 /**
@@ -534,5 +581,5 @@ declare class InvalidContentTypeError extends Error {
  */
 declare function chainFromName(name: string): Chain;
 //#endregion
-export { AddrValue, AnyArkivValue, type ArkivClient, ArkivRpcSchema, ArkivValue, AttributeInputs, AttributeSchema, Attributes, BoolValue, Bytes32Value, BytesValue, ChangeOwnershipParameters, ChangeOwnershipReturnType, ConflictingMutationError, CreateEntityParameters, CreateEntityReturnType, CreationFlags, DECIMAL_SCALE, DECIMAL_UNIT, type DeadlineOptions, DecValue, DeleteEntityParameters, DeleteEntityReturnType, ENTITY_EVENTS_ABI, EmptyPatchError, EncodedExpiry, Entity, EntityCreatedEvent, EntityDeletedEvent, EntityEvent, EntityEventContext, EntityEventName, EntityFields, EntityMutationError, EntityPatchedEvent, type EntitySelection, ExecuteBatchParameters, ExecuteBatchReturnType, ExpirationTime, Expiry, ExpiryContext, ExpiryExtendedEvent, type Expression, ExtendEntityParameters, ExtendEntityReturnType, type FullEntity, GetBlockTimingReturnType, I32Value, I32_MAX, I32_MIN, InvalidAttributeNameError, InvalidContentTypeError, InvalidCreationFlagsError, InvalidExpiryError, InvalidSaltError, InvalidValueError, KeyValue, Lifetime, MAX_ATTRIBUTES, MAX_EXPIRES_AT, MAX_NAME_BYTES, MAX_PAYLOAD_BYTES, MAX_SALT, MAX_STRING_BYTES, MimeType, MissingValueError, NO_SALT, NoEntityFoundError, NoMoreResultsError, NoRandomSourceError, OperationType, OwnershipTransferredEvent, PatchEntityParameters, PatchEntityReturnType, PredictEntityKeysParameters, PredictEntityKeysReturnType, PredictedEntityKey, type ProjectedEntity, type PublicArkivActions, type PublicArkivClient, QueryOptions, type QueryResult, QueryReturnType, ResolvedCreationFlags, ResolvedExpiry, RpcAttribute, RpcAttributeSchemaEntry, RpcCreationFlags, RpcEntity, RpcQueryOptions, RpcSelect, SaltInput, type SelectArg, SelectQueryBuilder, StrValue, TooManyAttributesError, TxParams, TypeTag, U256Value, U256_MAX, U64Value, U64_MAX, UnknownAttributeTypeError, UntypedValueError, UserTypeTag, ValueInput, type WalletArkivActions, type WalletArkivClient, WatchEntityEventsParameters, addr, bool, bytes32, chainFromName, createPublicClient, createWalletClient, dec, decFromUnits, decUnits, decodeCreationFlags, encodeCreationFlags, i32, isArkivValue, isValidAttributeName, jsonToPayload, key, predictEntityKey, randomSalt, resolveExpiry, str, stringToPayload, toBlocks, toValue, u256, u64, validateAttributeName };
+export { AddrValue, AnyColumn, type ArkivClient, ArkivRpcSchema, ArkivValue, type AttributeRef, AttributeSchema, Attributes, BareOf, BoolValue, Bytes32Value, BytesValue, ChangeOwnershipParameters, ChangeOwnershipReturnType, Column, ColumnInput, Columns, ColumnsOf, ConflictingMutationError, CountQueryBuilder, CreateEntityOptions, CreateEntityParameters, CreateEntityReturnType, CreateEntityValues, CreationFlags, DECIMAL_SCALE, DECIMAL_UNIT, type DeadlineOptions, DecValue, DeleteEntityParameters, DeleteEntityReturnType, type DynamicSelection, ENTITY_EVENTS_ABI, EmptyPatchError, Entity, EntityCreatedEvent, EntityDeletedEvent, EntityEvent, EntityEventContext, EntityEventName, EntityFields, EntityMutationError, EntityPatchedEvent, EntityTooLargeError, ExecuteBatchParameters, ExecuteBatchReturnType, ExpirationTime, Expiry, ExpiryExtendedEvent, type Expression, ExtendEntityParameters, ExtendEntityReturnType, type FromOptions, type FullEntity, type FullRow, GetBlockTimingReturnType, I32Value, I32_MAX, I32_MIN, INDEXED_FLAG, IndexableTypeTag, IndexableValue, IndexedColumnName, InvalidAttributeNameError, InvalidCreationFlagsError, InvalidExpiryError, InvalidSaltError, InvalidValueError, KeyValue, type KnownSystemFields, Lifetime, MAX_ATTRIBUTES, MAX_BYTES_LENGTH, MAX_ENTITY_BYTES, MAX_EXPIRES_AT, MAX_NAME_BYTES, MAX_SALT, MAX_STRING_BYTES, MissingValueError, NO_SALT, NoEntityFoundError, NoMoreResultsError, NoRandomSourceError, type NonEmptySelection, OptionalColumnName, OwnershipTransferredEvent, type PartialRow, PatchEntityChanges, PatchEntityParameters, PatchEntityReturnType, PatchEntityValues, PredictEntityKeysParameters, PredictEntityKeysReturnType, PredictedEntityKey, type PublicArkivActions, type PublicArkivClient, type QueryBuilderBase, QueryOptions, type QueryResult, QueryReturnType, QueryRow, ResolvedCreationFlags, type ResultOf, type Row, RpcAttribute, RpcAttributeSchemaEntry, RpcCreationFlags, RpcEntity, RpcQueryOptions, RpcSelect, SCHEMA_ATTRIBUTE, SYSTEM_FIELDS, SaltInput, Schema, SchemaDefinitionError, SchemaMismatchError, type SchemaRef, type SelectArg, SelectQueryBuilder, type Selected, type Selection, type SelectionOf, StrValue, type SystemField, TagOf, TooManyAttributesError, TxParams, TypeTag, U256Value, U256_MAX, U64Value, U64_MAX, UnknownAttributeTypeError, UntypedValueError, ValueArgument, ValueInput, ValueOf, type WalletArkivActions, type WalletArkivClient, WatchEntityEventsParameters, addr, bool, bytes, bytes32, chainFromName, createPublicClient, createWalletClient, dec, decFromUnits, decUnits, defineSchema, describeColumns, i32, isArkivValue, isColumn, isSchema, isValidAttributeName, key, lookupColumn, predictEntityKey, randomSalt, str, toValue, u256, u64, validateAttributeName };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/clients/decorators/arkivPublic.ts","../src/clients/createPublicClient.ts","../src/clients/decorators/arkivWallet.ts","../src/clients/createWalletClient.ts","../src/errors.ts","../src/utils/chains.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/clients/decorators/arkivPublic.ts","../src/clients/createPublicClient.ts","../src/clients/decorators/arkivWallet.ts","../src/clients/createWalletClient.ts","../src/errors.ts","../src/utils/chains.ts"],"sourcesContent":[],"mappings":"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"}