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

package/dist/index.cjs

@@ -1,9 +1,15 @@
-const require_chains = require('./chains-BifaY04V.cjs');
-const require_queryBuilder = require('./queryBuilder-UW2MCaX4.cjs');
-const require_consts = require('./consts-AUoL-v42.cjs');
-require('./types-o3zWarRp.cjs');
-const require_payload = require('./payload-DpA5PA-w.cjs');
+const require_chains = require('./chains-BYRTTipa.cjs');
+const require_attr = require('./attr-BvxHN99W.cjs');
+const require_queryBuilder = require('./queryBuilder-BXDvX1K_.cjs');
+const require_errors = require('./errors-D-eJkGVc.cjs');
+const require_flags = require('./flags-Ct8k0gpB.cjs');
+const require_entity = require('./entity-B0t6sN7F.cjs');
+const require_expiry = require('./expiry-BUYIXTGb.cjs');
+const require_entity$1 = require('./entity-wfBnZd91.cjs');
+require('./types-CKPddlfS.cjs');
+const require_payload = require('./payload-Bnw1hrvb.cjs');
 let viem = require("viem");
+let viem_actions = require("viem/actions");
 
 //#region src/actions/public/getBlockTiming.ts
 const logger$9 = require_queryBuilder.getLogger("actions:public:get-block-timing");
@@ -22,33 +28,26 @@ async function getBlockTiming(client) {
 
 //#endregion
 //#region src/actions/public/getEntity.ts
-async function getEntity(client, key) {
-	let bytes;
-	try {
-		bytes = (0, viem.hexToBytes)(key);
-	} catch {
-		throw new Error(`Invalid key format: ${key}. Key must be a valid hex string.`);
-	}
-	if (bytes.length !== 32) throw new Error(`Invalid key length: ${bytes.length} bytes. Key must be 32 bytes (64 hex characters) long.`);
-	const hexKey = (0, viem.bytesToHex)(bytes);
-	const result = await client.request({
-		method: "arkiv_query",
-		params: [`$key = ${hexKey}`, { includeData: {
-			key: true,
-			attributes: true,
-			payload: true,
-			contentType: true,
-			expiration: true,
-			owner: true,
-			creator: true,
-			createdAtBlock: true,
-			lastModifiedAtBlock: true,
-			transactionIndexInBlock: true,
-			operationIndexInTransaction: true
-		} }]
+/**
+* Reads one entity by key, with every field selected.
+*
+* Returns a {@link FullEntity} rather than an {@link Entity}: the selection is fixed at `"*"`, so
+* every field is populated and none of them needs a `?` at the call site. The bare `Entity` type
+* has every field optional because a `select()` result carries only what it asked for.
+*
+* @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.
+*/
+async function getEntity(client, entityKey) {
+	const { entities } = await require_queryBuilder.runQuery(client, {
+		query: require_queryBuilder.eq("$key", require_attr.key(entityKey)).toString(),
+		select: require_queryBuilder.toRpcSelect("*"),
+		limit: 1
 	});
-	if (!result.data.length) throw new require_queryBuilder.NoEntityFoundError();
-	return await require_queryBuilder.entityFromRpcResult(result.data[0]);
+	const entity = entities[0];
+	if (entity === void 0) throw new require_queryBuilder.NoEntityFoundError(entityKey);
+	return entity;
 }
 
 //#endregion
@@ -61,144 +60,360 @@ async function getEntityCount(client) {
 }
 
 //#endregion
-//#region src/actions/public/query.ts
-async function query(client, query$1, queryOptions) {
-	const rpcQueryOptions = {
-		includeData: {
-			key: true,
-			payload: queryOptions?.includeData?.payload ?? true,
-			attributes: queryOptions?.includeData?.attributes ?? false,
-			contentType: queryOptions?.includeData?.metadata ?? false,
-			expiration: queryOptions?.includeData?.metadata ?? false,
-			owner: queryOptions?.includeData?.metadata ?? false,
-			creator: queryOptions?.includeData?.metadata ?? false,
-			createdAtBlock: queryOptions?.includeData?.metadata ?? false,
-			lastModifiedAtBlock: queryOptions?.includeData?.metadata ?? false,
-			transactionIndexInBlock: queryOptions?.includeData?.metadata ?? false,
-			operationIndexInTransaction: queryOptions?.includeData?.metadata ?? false
-		},
-		...queryOptions?.atBlock !== void 0 && { atBlock: (0, viem.numberToHex)(queryOptions.atBlock) },
-		...queryOptions?.orderBy && { orderBy: queryOptions?.orderBy.map((order) => ({
-			name: order.name,
-			type: order.type,
-			desc: order.desc === "desc"
-		})) },
-		...queryOptions?.resultsPerPage !== void 0 && { resultsPerPage: (0, viem.numberToHex)(queryOptions.resultsPerPage) },
-		...queryOptions?.cursor !== void 0 && { cursor: queryOptions?.cursor }
+//#region src/entity/operations.ts
+/**
+* The one external entry point. A transaction is an ordered, **atomic** batch of entity operations:
+* all of them apply or none do, operation *n+1* observes operation *n*'s effects, and each applied
+* operation emits one event.
+*/
+const EXECUTE_ABI = (0, viem.parseAbi)(["function execute((uint8 operation, bytes operationData)[] ops) external returns (bytes32[] keys)"]);
+/**
+* The engine's one read-only view: an owner's entity-minting nonce, which is the input
+* {@link predictEntityKey} needs and the only part of the derivation the caller cannot know.
+*
+* It is a `view` on the same address `execute` is called on, so it answers over `eth_call` without
+* a transaction.
+*/
+const ENTITY_NONCE_ABI = (0, viem.parseAbi)(["function entityNonce(address owner) external view returns (uint64)"]);
+/**
+* The shared attribute shape, used by `create` (attributes) and `patch` (mutations). Written out
+* once and reused by every payload that carries attributes.
+*/
+const ATTRIBUTE_TUPLE = "(bytes32 name, uint8 typeId, bytes value)[]";
+/**
+* The payload struct for each operation tag. `operationData` is `abi.encode` of the struct the tag
+* selects — a tagged union, so a new operation is additive rather than a change to `execute`.
+*/
+const PAYLOAD_PARAMS = {
+	[require_expiry.OperationType.Create]: (0, viem.parseAbiParameters)(`(uint128 salt, uint64 expiresAt, uint64 minLifetime, uint8 creationFlags, ${ATTRIBUTE_TUPLE} attributes)`),
+	[require_expiry.OperationType.Patch]: (0, viem.parseAbiParameters)(`(bytes32 entityKey, ${ATTRIBUTE_TUPLE} mutations)`),
+	[require_expiry.OperationType.ExtendExpiry]: (0, viem.parseAbiParameters)("(bytes32 entityKey, uint64 expiresAt, uint64 minLifetime)"),
+	[require_expiry.OperationType.TransferOwnership]: (0, viem.parseAbiParameters)("(bytes32 entityKey, address newOwner)"),
+	[require_expiry.OperationType.Delete]: (0, viem.parseAbiParameters)("(bytes32 entityKey)")
+};
+/** Creates an entity. The key is derived by the engine; predict it with `predictEntityKey`. */
+function createOperation({ salt, expiry, creationFlags, attributes }) {
+	return {
+		operation: require_expiry.OperationType.Create,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.Create], [{
+			salt,
+			expiresAt: expiry.expiresAt,
+			minLifetime: expiry.minLifetime,
+			creationFlags,
+			attributes
+		}])
 	};
-	const result = await client.request({
-		method: "arkiv_query",
-		params: [query$1, rpcQueryOptions]
-	});
+}
+/** Applies a set of mutations to an existing entity. Tombstones unset attributes. */
+function patchOperation({ entityKey, mutations }) {
+	return {
+		operation: require_expiry.OperationType.Patch,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.Patch], [{
+			entityKey,
+			mutations
+		}])
+	};
+}
+/** Pushes an entity's expiry further out. Extending is allowed; shortening reverts. */
+function extendExpiryOperation({ entityKey, expiry }) {
+	return {
+		operation: require_expiry.OperationType.ExtendExpiry,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.ExtendExpiry], [{
+			entityKey,
+			expiresAt: expiry.expiresAt,
+			minLifetime: expiry.minLifetime
+		}])
+	};
+}
+/** Hands an entity to a new owner. */
+function transferOwnershipOperation({ entityKey, newOwner }) {
+	return {
+		operation: require_expiry.OperationType.TransferOwnership,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.TransferOwnership], [{
+			entityKey,
+			newOwner
+		}])
+	};
+}
+/** Deletes an entity before its expiry. */
+function deleteOperation({ entityKey }) {
 	return {
-		entities: await Promise.all(result.data.map((entity) => require_queryBuilder.entityFromRpcResult(entity))),
-		cursor: result.cursor,
-		blockNumber: BigInt(result.blockNumber)
+		operation: require_expiry.OperationType.Delete,
+		operationData: (0, viem.encodeAbiParameters)(PAYLOAD_PARAMS[require_expiry.OperationType.Delete], [{ entityKey }])
 	};
 }
 
 //#endregion
-//#region src/actions/public/subscribeEntityEvents.ts
-const logger$8 = require_queryBuilder.getLogger("actions:public:subscribe-entity-events");
-const arkivABI = (0, viem.parseAbi)([
-	"event ArkivEntityCreated(uint256 indexed entityKey, address indexed ownerAddress, uint256 expirationBlock, uint256 cost)",
-	"event ArkivEntityUpdated(uint256 indexed entityKey, address indexed ownerAddress, uint256 oldExpirationBlock, uint256 newExpirationBlock, uint256 cost)",
-	"event ArkivEntityExpired(uint256 indexed entityKey, address indexed ownerAddress)",
-	"event ArkivEntityDeleted(uint256 indexed entityKey, address indexed ownerAddress)",
-	"event ArkivEntityBTLExtended(uint256 indexed entityKey, address indexed ownerAddress, uint256 oldExpirationBlock, uint256 newExpirationBlock, uint256 cost)",
-	"event ArkivEntityOwnerChanged(uint256 indexed entityKey, address indexed oldOwnerAddress, address indexed newOwnerAddress)"
-]);
-async function subscribeEntityEvents(client, { onError, onEntityCreated, onEntityUpdated, onEntityDeleted, onEntityExpired, onEntityExpiresInExtended, onEntityOwnerChanged }, pollingInterval, fromBlock) {
-	return client.watchEvent({
-		pollingInterval: pollingInterval ?? 1e3,
-		fromBlock,
-		events: arkivABI,
+//#region src/actions/public/getEntityNonce.ts
+const logger$8 = require_queryBuilder.getLogger("actions:public:get-entity-nonce");
+/**
+* Reads an owner's entity-minting nonce — how many entities that account has created.
+*
+* This is not the account's transaction nonce. The engine keeps a separate counter per creator and
+* mixes it into every key it mints, which is what makes two identical creates from one account land
+* on different keys.
+*
+* @param owner - The account whose nonce to read.
+* @returns The number of entities `owner` has created so far, which is the nonce its next create
+* will use.
+*/
+async function getEntityNonce(client, owner) {
+	const nonce = await (0, viem_actions.readContract)(client, {
+		address: require_expiry.ARKIV_ADDRESS,
+		abi: ENTITY_NONCE_ABI,
+		functionName: "entityNonce",
+		args: [owner]
+	});
+	logger$8("entity nonce of %s is %s", owner, nonce);
+	return nonce;
+}
+
+//#endregion
+//#region src/actions/public/predictEntityKeys.ts
+/**
+* Works out the keys an account's next creates will be given, before sending them.
+*
+* A key is `keccak256(chainId ++ registry ++ owner ++ nonce ++ salt)`. Everything but the nonce is
+* known to the caller, and the nonce is read here — so a batch can reference a key it is about to
+* mint, storing it as a `key` attribute on a sibling entity created in the same transaction.
+*
+* Each key arrives paired with its salt, and the create must be given that salt: a create left to
+* pick its own salt picks a random one, which mints a different key.
+*
+* The prediction is valid only while nothing else from this owner is in flight. Every create that
+* lands first takes the nonce with it and moves these keys. For a key you can rely on
+* unconditionally, read it back from the create instead — `createEntity` and `mutateEntities`
+* report the keys the engine actually minted.
+*
+* @param parameters - Owner, and either a count or the salts. {@link PredictEntityKeysParameters}
+* @returns One `{ key, salt }` pair per create, in batch order. {@link PredictEntityKeysReturnType}
+*
+* @example A batch whose second entity points at its first.
+* import { key } from "@arkiv-network/sdk/attr"
+*
+* const [parent, child] = await client.predictEntityKeys({ owner: account.address, count: 2 })
+* await wallet.mutateEntities({
+*   creates: [
+*     { payload, contentType, expires, salt: parent.salt },
+*     {
+*       payload,
+*       contentType,
+*       expires,
+*       salt: child.salt,
+*       attributes: { parent: key(parent.key) },
+*     },
+*   ],
+* })
+*/
+async function predictEntityKeys(client, { owner, count, salts }) {
+	const resolvedSalts = resolveSalts(count, salts);
+	const chainId = client.chain?.id ?? await (0, viem_actions.getChainId)(client);
+	const nonce = await getEntityNonce(client, owner);
+	return resolvedSalts.map((salt, index) => ({
+		key: require_entity$1.predictEntityKey({
+			owner,
+			nonce: nonce + BigInt(index),
+			salt,
+			chainId
+		}),
+		salt
+	}));
+}
+/** The salts to derive from: the ones given, or `count` fresh random ones. */
+function resolveSalts(count, salts) {
+	if (salts !== void 0) {
+		if (salts.length === 0) throw new Error("predictEntityKeys: `salts` is empty — there is nothing to predict");
+		return salts.map(require_entity$1.validateSalt);
+	}
+	if (count === void 0) throw new Error("predictEntityKeys: pass either `count` or `salts`");
+	if (!Number.isInteger(count) || count <= 0) throw new Error(`predictEntityKeys: \`count\` must be a positive whole number, got ${count}`);
+	return Array.from({ length: count }, () => require_entity$1.randomSalt());
+}
+
+//#endregion
+//#region src/actions/public/query.ts
+/**
+* Runs a single query and returns one page, with no builder in between.
+*
+* Takes either an {@link Expression} or a raw query string. The string form is an escape hatch for
+* a query built elsewhere — it goes to the node exactly as written, with none of the name, type or
+* operator checks the expression combinators apply.
+*
+* @throws {QueryError} If the node rejects the query.
+*/
+function query(client, query$1, options = {}) {
+	return require_queryBuilder.runQuery(client, {
+		query: query$1.toString(),
+		select: require_queryBuilder.toRpcSelect(options.select),
+		limit: options.limit,
+		cursor: options.cursor,
+		atBlock: options.atBlock
+	});
+}
+
+//#endregion
+//#region src/actions/public/watchEntityEvents.ts
+const logger$7 = require_queryBuilder.getLogger("actions:public:watch-entity-events");
+/**
+* How often to poll, when the caller does not say.
+*
+* Half a block: fast enough that an event is never a whole block stale, slow enough not to hammer
+* the node. viem's own default is derived from a 12-second Ethereum block and is far too slow here.
+*/
+const DEFAULT_POLLING_INTERVAL = require_expiry.BLOCK_TIME * 1e3 / 2;
+/**
+* Watches entity events, calling the handlers you pass as they arrive.
+*
+* Every event here is decoded from a log the Arkiv operation address emitted, and carries the
+* block, transaction and log index it came from — so consuming them in order replays exactly what
+* the engine did.
+*
+* @param parameters - Handlers and options. {@link WatchEntityEventsParameters}
+* @returns A function that stops the watcher.
+*
+*
+* @example
+* import { createPublicClient } from "@arkiv-network/sdk"
+* import { cheesecake } from "@arkiv-network/sdk/chains"
+* import { http } from "viem"
+*
+* const client = createPublicClient({ chain: cheesecake, transport: http() })
+*
+* const unwatch = client.watchEntityEvents({
+*   onEntityCreated: ({ entityKey, owner, expiresAt }) =>
+*     console.log("created", entityKey, "by", owner, "until block", expiresAt),
+*   onEntityDeleted: ({ entityKey }) => console.log("deleted", entityKey),
+*   onError: (error) => console.error(error),
+* })
+*
+* unwatch()
+*/
+function watchEntityEvents(client, parameters) {
+	const { onEntityCreated, onEntityPatched, onExpiryExtended, onOwnershipTransferred, onEntityDeleted, onEvent, onError, fromBlock, pollingInterval = DEFAULT_POLLING_INTERVAL } = parameters;
+	const publicClient = client;
+	const reportError = onError ?? logToConsole;
+	function emit(event) {
+		deliver(onEvent, event);
+		switch (event.type) {
+			case "EntityCreated":
+				deliver(onEntityCreated, event);
+				break;
+			case "EntityPatched":
+				deliver(onEntityPatched, event);
+				break;
+			case "ExpiryExtended":
+				deliver(onExpiryExtended, event);
+				break;
+			case "OwnershipTransferred":
+				deliver(onOwnershipTransferred, event);
+				break;
+			case "EntityDeleted":
+				deliver(onEntityDeleted, event);
+				break;
+		}
+	}
+	/**
+	* Runs one handler, keeping its failure to itself.
+	*
+	* A handler that throws is the consumer's problem, not the watcher's: letting it escape would
+	* reject the poll, drop the rest of the batch, and take down every other handler with it.
+	*/
+	function deliver(handler, event) {
+		if (handler === void 0) return;
+		try {
+			handler(event);
+		} catch (error) {
+			reportError(asError(error));
+		}
+	}
+	return publicClient.watchEvent({
+		address: require_expiry.ARKIV_ADDRESS,
+		events: require_entity$1.ENTITY_EVENTS_ABI,
+		pollingInterval,
+		...fromBlock !== void 0 && { fromBlock },
 		onLogs: (logs) => {
-			logger$8("logs from subscribeEntityEvents %o", logs);
+			logger$7("logs %o", logs);
 			for (const log of logs) {
-				const event = (0, viem.decodeEventLog)({
-					abi: arkivABI,
-					topics: log.topics,
-					data: log.data
-				});
-				logger$8("event from subscribeEntityEvents %o", event);
-				switch (event.eventName) {
-					case "ArkivEntityCreated":
-						onEntityCreated?.({
-							entityKey: (0, viem.toHex)(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress,
-							expirationBlock: Number(event.args.expirationBlock),
-							cost: event.args.cost
-						});
-						break;
-					case "ArkivEntityUpdated":
-						onEntityUpdated?.({
-							entityKey: (0, viem.toHex)(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress,
-							oldExpirationBlock: Number(event.args.oldExpirationBlock),
-							newExpirationBlock: Number(event.args.newExpirationBlock),
-							cost: event.args.cost
-						});
-						break;
-					case "ArkivEntityDeleted":
-						onEntityDeleted?.({
-							entityKey: (0, viem.toHex)(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress
-						});
-						break;
-					case "ArkivEntityBTLExtended":
-						onEntityExpiresInExtended?.({
-							entityKey: (0, viem.toHex)(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress,
-							oldExpirationBlock: Number(event.args.oldExpirationBlock),
-							newExpirationBlock: Number(event.args.newExpirationBlock),
-							cost: event.args.cost
-						});
-						break;
-					case "ArkivEntityExpired":
-						onEntityExpired?.({
-							entityKey: (0, viem.toHex)(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress
-						});
-						break;
-					case "ArkivEntityOwnerChanged":
-						onEntityOwnerChanged?.({
-							entityKey: (0, viem.toHex)(event.args.entityKey, { size: 32 }),
-							oldOwner: event.args.oldOwnerAddress,
-							newOwner: event.args.newOwnerAddress
-						});
-						break;
-					default:
-						console.warn("unknown event from subscribeEntityEvents", event);
-						break;
+				if (log.blockNumber === null || log.transactionHash === null || log.logIndex === null) continue;
+				const context = {
+					blockNumber: log.blockNumber,
+					transactionHash: log.transactionHash,
+					logIndex: log.logIndex
+				};
+				let event;
+				try {
+					event = toEntityEvent(log.topics, log.data, context);
+				} catch (error) {
+					reportError(asError(error));
+					continue;
 				}
+				emit(event);
 			}
 		},
-		onError: (error) => {
-			console.error("error from subscribeEntityEvents", error);
-			onError?.(error);
-		}
+		onError: (error) => reportError(error)
 	});
 }
+/** The fallback when no `onError` was given — see {@link WatchEntityEventsParameters.onError}. */
+function logToConsole(error) {
+	console.error("watchEntityEvents error", error);
+}
+/** Handlers take an `Error`, and a `throw` can be anything. */
+function asError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+/**
+* Decodes one log into the {@link EntityEvent} it carries.
+*
+* @throws If the log does not decode against {@link ENTITY_EVENTS_ABI}.
+*/
+function toEntityEvent(topics, data, context) {
+	const decoded = (0, viem.decodeEventLog)({
+		abi: require_entity$1.ENTITY_EVENTS_ABI,
+		topics,
+		data
+	});
+	switch (decoded.eventName) {
+		case "EntityCreated": return {
+			type: "EntityCreated",
+			...context,
+			...decoded.args,
+			creationFlags: require_flags.decodeCreationFlags(decoded.args.creationFlags)
+		};
+		case "EntityPatched": return {
+			type: "EntityPatched",
+			...context,
+			...decoded.args
+		};
+		case "ExpiryExtended": return {
+			type: "ExpiryExtended",
+			...context,
+			...decoded.args
+		};
+		case "OwnershipTransferred": return {
+			type: "OwnershipTransferred",
+			...context,
+			...decoded.args
+		};
+		case "EntityDeleted": return {
+			type: "EntityDeleted",
+			...context,
+			...decoded.args
+		};
+	}
+}
 
 //#endregion
 //#region src/clients/decorators/arkivPublic.ts
 function publicArkivActions(client) {
 	return {
-		getEntity: (key) => getEntity(client, key),
+		getEntity: (key$1) => getEntity(client, key$1),
 		query: (rawQuery, queryOptions) => query(client, rawQuery, queryOptions),
-		buildQuery: () => new require_queryBuilder.QueryBuilder(client),
 		select: (selection) => new require_queryBuilder.SelectQueryBuilder(client, selection),
 		getBlockTiming: () => getBlockTiming(client),
 		getEntityCount: () => getEntityCount(client),
-		subscribeEntityEvents: ({ onError, onEntityCreated, onEntityUpdated, onEntityDeleted, onEntityExpired, onEntityExpiresInExtended }, pollingInterval, fromBlock) => subscribeEntityEvents(client, {
-			onError,
-			onEntityCreated,
-			onEntityUpdated,
-			onEntityDeleted,
-			onEntityExpired,
-			onEntityExpiresInExtended
-		}, pollingInterval, fromBlock)
+		getEntityNonce: (owner) => getEntityNonce(client, owner),
+		predictEntityKeys: (parameters) => predictEntityKeys(client, parameters),
+		watchEntityEvents: (parameters) => watchEntityEvents(client, parameters)
 	};
 }
 
@@ -209,201 +424,278 @@ function publicArkivActions(client) {
 *
 * - Docs: https://docs.arkiv.network/ts-sdk/clients/public
 *
-* A Public Client is an interface to "public" [Ethereum JSON-RPC API](https://ethereum.org/en/developers/docs/apis/json-rpc/), [Arkiv JSON-RPC API](https://docs.arkiv.network/json-rpc/), and [Braga JSON-RPC API](https://braga.holesky.arkiv.network/rpc) methods such as retrieving block numbers, transactions, reading from smart contracts, etc through [Public Actions](/docs/actions/public/introduction).
+* A Public Client is an interface to "public" [Ethereum JSON-RPC API](https://ethereum.org/en/developers/docs/apis/json-rpc/), [Arkiv JSON-RPC API](https://docs.arkiv.network/json-rpc/), and [Cheesecake JSON-RPC API](https://rpc.cheesecake.db-chain.devnet.gobas.me) methods such as retrieving block numbers, transactions, reading from smart contracts, etc through [Public Actions](/docs/actions/public/introduction).
 *
 * @param parameters - Configuration object for the public client (chain, transport, etc.)
 * @returns A Arkiv Public Client. {@link PublicArkivClient}
 *
 * @example
-* import { createPublicClient, http } from 'arkiv'
-* import { braga } from 'arkiv/chains'
+* import { createPublicClient } from "@arkiv-network/sdk"
+* import { cheesecake } from "@arkiv-network/sdk/chains"
+* import { http } from "viem"
 *
 * const client = createPublicClient({
-*   chain: braga,
+*   chain: cheesecake,
 *   transport: http(),
 * })
 */
 function createPublicClient(parameters) {
-	const { key = "public", name = "Public Client" } = parameters;
+	const { key: key$1 = "public", name = "Public Client" } = parameters;
 	return (0, viem.createClient)({
 		...parameters,
-		key,
+		key: key$1,
 		name
 	}).extend(viem.publicActions).extend(publicArkivActions);
 }
 
 //#endregion
-//#region src/utils/compression.ts
-const logger$7 = require_queryBuilder.getLogger("utils:compression");
-const isNode = typeof process !== "undefined" && process.versions?.node != null;
-let zlib = null;
-let brotli = null;
-async function getZlib() {
-	if (!isNode) return null;
-	if (!zlib) try {
-		zlib = await import("zlib");
-	} catch (error) {
-		console.error("Error importing zlib", error);
-		return null;
-	}
-	return zlib;
+//#region src/utils/revert.ts
+/**
+* Turns a decoded engine revert into a sentence that says what to change.
+*
+* viem decodes the error and then renders it positionally — `Ident32InvalidByte(uint256 position,
+* bytes1 value)` arrives as `(5, 0x41)`, which is the right data and no help at all. The engine's
+* errors carry enough to name the actual problem, so this spends the args rather than printing
+* them.
+*
+* @param error - Anything thrown by a write action.
+* @returns The explanation, or `undefined` if this was not a decodable engine revert — in which
+* case the caller should fall back to whatever the transport said.
+*/
+function describeEntityRevert(error) {
+	if (!(error instanceof viem.BaseError)) return void 0;
+	const reverted = error.walk((e) => e instanceof viem.ContractFunctionRevertedError);
+	if (!(reverted instanceof viem.ContractFunctionRevertedError)) return void 0;
+	const name = reverted.data?.errorName;
+	if (name === void 0) return void 0;
+	return explain(name, reverted.data?.args ?? []) ?? `the engine rejected the batch with ${name}`;
 }
-async function getBrotli() {
-	if (brotli) return brotli;
-	try {
-		const brotliModule = await import("brotli-wasm");
-		brotli = brotliModule.default ? await brotliModule.default : brotliModule;
-	} catch (error) {
-		console.error("Error importing brotli-wasm", error);
-		return null;
-	}
-	return brotli;
-}
-async function compress(data) {
-	logger$7("Compressing data size %d", data.length);
-	if (isNode) {
-		const zlibModule = await getZlib();
-		if (zlibModule) try {
-			const buffer = Buffer.from(data);
-			const compressed = zlibModule.brotliCompressSync(buffer);
-			const result = new Uint8Array(compressed);
-			logger$7("Brotli compressed with zlib size %d", result.length);
-			return result;
-		} catch (error) {
-			console.warn("zlib compression failed, falling back to brotli-wasm", error);
+/** The attribute-name charset, quoted the way an error message should read. */
+const CHARSET = "\"A\"-\"Z\", \"a\"-\"z\", \"0\"-\"9\", \".\", \"-\" and \"_\", with a letter first";
+function explain(name, args) {
+	switch (name) {
+		case "Ident32InvalidByte": {
+			const position = Number(args[0] ?? 0);
+			return `an attribute name holds ${printable(String(args[1] ?? "0x00"))} at byte ${position}, which is outside the name charset (${CHARSET})`;
 		}
+		case "Ident32Empty": return "an attribute name is empty";
+		case "SystemAttributeNotWritable": return `"${identName(args[0])}" is owned by the engine and cannot be written. Only $payload and \$contentType are yours to set`;
+		case "TombstoneInCreate": return `a create cannot unset "${identName(args[0])}" — nothing exists yet, so leave the name out instead`;
+		case "TombstoneValueNotEmpty": return `the tombstone for "${identName(args[0])}" carries a value; unsetting takes no value`;
+		case "InvalidValueType": return `"${identName(args[0])}" names type id ${String(args[1])}, which is not a known type`;
+		case "AttributesNotSorted": return "attributes must be strictly ascending by name, which also makes each name unique";
+		case "TooManyAttributes": return `${String(args[0])} attributes exceeds the limit of ${String(args[1])}`;
+		case "EmptyMutations": return `the patch of ${short(args[0])} has no mutations, so it would do nothing`;
+		case "EntityNotFound": return `no entity ${short(args[0])} — it may have been deleted, or have expired`;
+		case "EntityExpired": return `entity ${short(args[0])} expired at block ${String(args[1])}`;
+		case "NotOwner": return `entity ${short(args[0])} is owned by ${String(args[2])}, not ${String(args[1])}`;
+		case "ReadOnlyEntity": return `entity ${short(args[0])} was created readonly, so its contents can never change. Its expiry can still be extended, and it can be transferred or deleted`;
+		case "ReservedCreationFlags": return `creation flags 0b${Number(args[0] ?? 0).toString(2).padStart(8, "0")} set a reserved bit; only readonly and permissionlessExtension are defined`;
+		case "ExpiryDeadOnArrival": return `the expiry resolves to block ${String(args[0])}, which is not after the current block ${String(args[1])}`;
+		case "ExpiryNotExtended": return `entity ${short(args[0])} already expires at block ${String(args[2])}, so extending it to ${String(args[1])} would shorten its life`;
+		case "TransferToZeroAddress": return `entity ${short(args[0])} cannot be transferred to the zero address`;
+		case "TransferToSelf": return `entity ${short(args[0])} is already owned by that account`;
+		case "EmptyBatch": return "the batch has no operations";
+		case "InvalidOpType": return `operation tag ${String(args[0])} is not one the engine knows`;
+		case "NonCanonicalOperationData": return `the payload for operation tag ${String(args[0])} is not its canonical encoding, so the engine refused it rather than accept a second spelling of the same operation`;
+		default: return;
 	}
-	const brotliInstance = await getBrotli();
-	if (!brotliInstance) {
-		console.warn("Brotli instance not found, not compressing data");
-		return data;
+}
+/** A `bytes32` Ident32 cell as the name it holds — left-aligned, null-padded. */
+function identName(raw) {
+	if (typeof raw !== "string") return String(raw);
+	try {
+		return (0, viem.hexToString)(raw).split("\0")[0] ?? "";
+	} catch {
+		return raw;
 	}
-	const brotliCompressed = brotliInstance.compress(data);
-	logger$7("Brotli compressed with wasm size %d", brotliCompressed.length);
-	return brotliCompressed;
 }
-
-//#endregion
-//#region src/utils/validation.ts
-/**
-* Expiration on Arkiv is measured in blocks (1 block =
-* 2 seconds), so the value must be a positive integer that is
-* a multiple of the block time.
-*
-* @param expiresIn - The expiration in seconds.
-* @throws {InvalidExpirationError} If the value is not a positive integer that
-* is a multiple of the block time.
-*/
-function validateExpiresIn(expiresIn) {
-	if (!Number.isInteger(expiresIn) || expiresIn <= 0 || expiresIn % require_consts.BLOCK_TIME !== 0) throw new require_queryBuilder.InvalidExpirationError(expiresIn);
+/** An entity key, abbreviated */
+function short(raw) {
+	const text = String(raw);
+	return text.length > 18 ? `${text.slice(0, 10)}…${text.slice(-6)}` : text;
 }
-/**
-* Validates a single attribute. Arkiv supports string and number attribute
-* values, but numeric values must be integers.
-*
-* @param attribute - The attribute to validate.
-* @throws {InvalidAttributeError} If the attribute has a non-integer numeric
-* value.
-*/
-function validateAttribute(attribute) {
-	if (typeof attribute.value === "number" && !Number.isInteger(attribute.value)) throw new require_queryBuilder.InvalidAttributeError(attribute.key, attribute.value);
+/** A `bytes1` as something readable: the character it is, plus the byte it was. */
+function printable(byte) {
+	const code = Number.parseInt(byte.replace(/^0x/, ""), 16);
+	if (!Number.isFinite(code)) return `byte ${byte}`;
+	return code >= 33 && code <= 126 ? `"${String.fromCharCode(code)}" (${byte})` : `byte ${byte}`;
 }
 
 //#endregion
 //#region src/utils/arkivTransactions.ts
 const logger$6 = require_queryBuilder.getLogger("utils:arkiv-transactions");
-function opsToTxData({ creates, updates, deletes, extensions, ownershipChanges }) {
-	function formatAttributes(attribute) {
-		return [(0, viem.toHex)(attribute.key), (0, viem.toHex)(typeof attribute.value === "number" && attribute.value === 0 ? "" : attribute.value)];
-	}
-	const payload = [
-		(creates ?? []).map((item) => {
-			validateExpiresIn(item.expiresIn);
-			item.attributes.forEach(validateAttribute);
-			return [
-				(0, viem.toHex)(item.expiresIn / require_consts.BLOCK_TIME),
-				(0, viem.toHex)(item.contentType),
-				(0, viem.toHex)(item.payload),
-				item.attributes.filter((attribute) => typeof attribute.value === "string").map(formatAttributes),
-				item.attributes.filter((attribute) => typeof attribute.value === "number").map(formatAttributes)
-			];
-		}),
-		(updates ?? []).map((item) => {
-			validateExpiresIn(item.expiresIn);
-			item.attributes.forEach(validateAttribute);
-			return [
-				item.entityKey,
-				(0, viem.toHex)(item.contentType),
-				(0, viem.toHex)(item.expiresIn / require_consts.BLOCK_TIME),
-				(0, viem.toHex)(item.payload),
-				item.attributes.filter((attribute) => typeof attribute.value === "string").map(formatAttributes),
-				item.attributes.filter((attribute) => typeof attribute.value === "number").map(formatAttributes)
-			];
-		}),
-		(deletes ?? []).map((item) => item.entityKey),
-		(extensions ?? []).map((item) => {
-			validateExpiresIn(item.expiresIn);
-			return [item.entityKey, (0, viem.toHex)(item.expiresIn / require_consts.BLOCK_TIME)];
-		}),
-		(ownershipChanges ?? []).map((item) => [item.entityKey, item.newOwner])
-	];
-	logger$6("txData to send as RLP %o length %d", payload, payload.length);
-	return (0, viem.toRlp)(payload);
+const MIME_REGEX = /^[a-z][a-z0-9!#$&\-^_]*\/[a-z0-9][a-z0-9!#$&\-^_.+]*$/;
+function validateContentType(contentType) {
+	if (!MIME_REGEX.test(contentType)) throw new require_queryBuilder.InvalidContentTypeError(contentType);
 }
-async function sendArkivTransaction(client, data, txParams) {
+const ENTITY_ERRORS_ABI = (0, viem.parseAbi)([
+	"error EmptyBatch()",
+	"error InvalidOpType(uint8 operation)",
+	"error NonCanonicalOperationData(uint8 operation)",
+	"error AttributesNotSorted()",
+	"error TooManyAttributes(uint256 count, uint256 maxCount)",
+	"error EmptyMutations(bytes32 entityKey)",
+	"error TombstoneInCreate(bytes32 name)",
+	"error TombstoneValueNotEmpty(bytes32 name)",
+	"error SystemAttributeNotWritable(bytes32 name)",
+	"error InvalidValueType(bytes32 name, uint8 typeId)",
+	"error Ident32Empty()",
+	"error Ident32InvalidByte(uint256 position, bytes1 value)",
+	"error EntityNotFound(bytes32 entityKey)",
+	"error EntityExpired(bytes32 entityKey, uint64 expiresAt)",
+	"error NotOwner(bytes32 entityKey, address caller, address owner)",
+	"error ReadOnlyEntity(bytes32 entityKey)",
+	"error ReservedCreationFlags(uint8 creationFlags)",
+	"error ExpiryDeadOnArrival(uint64 target, uint64 currentBlock)",
+	"error ExpiryNotExtended(bytes32 entityKey, uint64 newExpiresAt, uint64 currentExpiresAt)",
+	"error TransferToZeroAddress(bytes32 entityKey)",
+	"error TransferToSelf(bytes32 entityKey)"
+]);
+const EXECUTE_ABI$1 = [...EXECUTE_ABI, ...ENTITY_ERRORS_ABI];
+async function sendArkivTransaction(client, ops, txParams) {
 	if (!client.account) throw new Error("Account required");
+	if (!client.chain) throw new Error("Chain required");
 	const walletClient = client;
-	logger$6("Sending transaction %o", {
-		account: client.account,
-		chain: client.chain,
-		to: require_consts.ARKIV_ADDRESS,
-		value: 0n,
-		data,
-		...txParams
+	const { creates, patches, deletes, extensions, ownershipChanges } = ops;
+	const expiryContext = { currentBlock: creates?.length || extensions?.length ? await walletClient.getBlockNumber() : 0n };
+	const createOps = (creates ?? []).map((item) => {
+		validateContentType(item.contentType);
+		return createOperation({
+			salt: item.salt === void 0 ? require_entity$1.randomSalt() : require_entity$1.validateSalt(item.salt),
+			expiry: require_expiry.resolveExpiry(item.expires, expiryContext),
+			creationFlags: require_flags.encodeCreationFlags(item.flags),
+			attributes: require_attr.encodeAttributes(item.attributes, {
+				payload: item.payload,
+				contentType: item.contentType
+			})
+		});
 	});
+	const patchOps = (patches ?? []).map((item) => {
+		if (item.contentType !== void 0) validateContentType(item.contentType);
+		const mutations = require_attr.encodeMutations(item);
+		if (mutations.length === 0) throw new require_queryBuilder.EmptyPatchError(item.entityKey);
+		return patchOperation({
+			entityKey: item.entityKey,
+			mutations
+		});
+	});
+	const extendOps = (extensions ?? []).map((item) => {
+		const expiry = require_expiry.resolveExpiry(item.expires, expiryContext);
+		return extendExpiryOperation({
+			entityKey: item.entityKey,
+			expiry
+		});
+	});
+	const operations = [
+		...createOps,
+		...patchOps,
+		...(deletes ?? []).map((item) => deleteOperation({ entityKey: item.entityKey })),
+		...extendOps,
+		...(ownershipChanges ?? []).map((item) => transferOwnershipOperation({
+			entityKey: item.entityKey,
+			newOwner: item.newOwner
+		}))
+	];
+	if (operations.length === 0) throw new Error("No operations to perform");
+	logger$6("Sending execute with %d operations %o", operations.length, operations);
 	try {
-		const compressed = await compress((0, viem.toBytes)(data));
-		const txHash = await walletClient.sendTransaction({
+		const txHash = await walletClient.writeContract({
+			address: require_expiry.ARKIV_ADDRESS,
+			abi: EXECUTE_ABI$1,
+			functionName: "execute",
+			args: [operations],
 			account: client.account,
 			chain: client.chain,
-			to: require_consts.ARKIV_ADDRESS,
-			value: 0n,
-			data: (0, viem.toHex)(compressed),
 			...txParams
 		});
 		const receipt = await walletClient.waitForTransactionReceipt({ hash: txHash });
 		logger$6("Tx receipt %o", receipt);
-		if (receipt.status === "reverted") try {
-			const callResult = await walletClient.call({
-				account: client.account,
-				to: require_consts.ARKIV_ADDRESS,
-				value: 0n,
-				data: (0, viem.toHex)(compressed),
-				...txParams
-			});
-			throw new require_queryBuilder.EntityMutationError(`Transaction ${receipt.transactionHash} reverted. Please make sure the data for entities doesn't contain invalid characters or invalid data types.
-          Reason: ${callResult.data ? (0, viem.hexToString)(callResult.data) : "No reason provided by backend."}`);
-		} catch (err) {
-			const reason = err.cause?.details ?? "No reason provided by backend.";
-			logger$6("Error while calling to get more details about reverted transaction. Reason: %s", reason);
-			throw new require_queryBuilder.EntityMutationError(`Transaction ${receipt.transactionHash} reverted. Reason: ${reason}`);
+		if (receipt.status === "reverted") {
+			try {
+				await walletClient.simulateContract({
+					address: require_expiry.ARKIV_ADDRESS,
+					abi: EXECUTE_ABI$1,
+					functionName: "execute",
+					args: [operations],
+					account: client.account,
+					chain: client.chain
+				});
+			} catch (err) {
+				const error = err;
+				const reason = describeEntityRevert(err) ?? error.shortMessage ?? error.cause?.details ?? "No reason provided by backend.";
+				throw new require_queryBuilder.EntityMutationError(`Transaction ${receipt.transactionHash} reverted. Reason: ${reason}`);
+			}
+			throw new require_queryBuilder.EntityMutationError(`Transaction ${receipt.transactionHash} reverted. No reason provided by backend.`);
 		}
-		return receipt;
+		return {
+			receipt,
+			...readAppliedOperations(receipt, {
+				creates: createOps.length,
+				extensions: extendOps.length
+			})
+		};
 	} catch (error) {
+		const described = error instanceof require_queryBuilder.EntityMutationError ? void 0 : describeEntityRevert(error);
+		if (described !== void 0) throw new require_queryBuilder.EntityMutationError(`Transaction failed: ${described}`, { cause: error });
 		let message = "Transaction failed";
 		if (error instanceof viem.TransactionExecutionError) message += `: ${error.details}`;
-		else if (error instanceof require_queryBuilder.EntityMutationError) throw error;
-		logger$6("%s Detailed error stack: %o", message, error);
-		throw new require_queryBuilder.EntityMutationError(message);
+		else if (error instanceof viem.ContractFunctionExecutionError) {
+			logger$6("Contract function execution error data:", error.shortMessage);
+			if (error.cause instanceof viem.ContractFunctionRevertedError) message += `: ${error.cause.message}`;
+			else message += ": Execution error without revert data";
+		} else if (error instanceof require_queryBuilder.EntityMutationError) throw error;
+		else if (error instanceof Error) message += `: ${error.message}`;
+		throw new require_queryBuilder.EntityMutationError(message, { cause: error });
+	}
+}
+/**
+* The keys and expiries the engine recorded, read back from the events the batch emitted.
+*/
+function readAppliedOperations(receipt, expected) {
+	const createdEntityKeys = [];
+	const createdExpiries = [];
+	const extendedExpiries = [];
+	for (const log of receipt.logs ?? []) {
+		if (log.address.toLowerCase() !== require_expiry.ARKIV_ADDRESS.toLowerCase()) continue;
+		const decoded = decodeEntityLog(log);
+		if (decoded === void 0) continue;
+		if (decoded.eventName === "EntityCreated") {
+			createdEntityKeys.push(decoded.args.entityKey);
+			createdExpiries.push(decoded.args.expiresAt);
+		} else if (decoded.eventName === "ExpiryExtended") extendedExpiries.push(decoded.args.expiresAt);
+	}
+	assertCount(receipt, "create", createdEntityKeys.length, expected.creates);
+	assertCount(receipt, "extension", extendedExpiries.length, expected.extensions);
+	return {
+		createdEntityKeys,
+		createdExpiries,
+		extendedExpiries
+	};
+}
+/** One log as an entity event, or `undefined` for anything this SDK has no name for. */
+function decodeEntityLog(log) {
+	try {
+		return (0, viem.decodeEventLog)({
+			abi: require_entity$1.ENTITY_EVENTS_ABI,
+			topics: log.topics,
+			data: log.data
+		});
+	} catch {
+		return;
 	}
 }
+function assertCount(receipt, what, got, want) {
+	if (got === want) return;
+	throw new require_queryBuilder.EntityMutationError(`Transaction ${receipt.transactionHash} succeeded — do not retry it — but emitted ${got} ${what} event(s) for ${want} ${what} operation(s). The batch was applied; the SDK cannot say which entity each operation produced, so read them back to find them.`);
+}
 
 //#endregion
 //#region src/actions/wallet/changeOwnership.ts
 const logger$5 = require_queryBuilder.getLogger("actions:wallet:change-ownership");
 async function changeOwnership(client, data, txParams) {
 	logger$5("changeOwnership %o", data);
-	const receipt = await sendArkivTransaction(client, opsToTxData({ ownershipChanges: [data] }), txParams);
+	const { receipt } = await sendArkivTransaction(client, { ownershipChanges: [data] }, txParams);
 	logger$5("Receipt from changeOwnership %o", receipt);
 	return {
 		txHash: receipt.transactionHash,
@@ -416,11 +708,15 @@ async function changeOwnership(client, data, txParams) {
 const logger$4 = require_queryBuilder.getLogger("actions:wallet:create-entity");
 async function createEntity(client, data, txParams) {
 	logger$4("createEntity %o", data);
-	const receipt = await sendArkivTransaction(client, opsToTxData({ creates: [data] }), txParams);
+	const { receipt, createdEntityKeys, createdExpiries } = await sendArkivTransaction(client, { creates: [data] }, txParams);
 	logger$4("Receipt from createEntity %o", receipt);
+	const [entityKey] = createdEntityKeys;
+	const [expiresAt] = createdExpiries;
+	if (entityKey === void 0 || expiresAt === void 0) throw new require_queryBuilder.EntityMutationError(`Transaction ${receipt.transactionHash} succeeded, but the receipt did not carry the expected entity key or expiry.`);
 	return {
 		txHash: receipt.transactionHash,
-		entityKey: receipt.logs[0].topics[1]
+		entityKey,
+		expiresAt
 	};
 }
 
@@ -429,7 +725,7 @@ async function createEntity(client, data, txParams) {
 const logger$3 = require_queryBuilder.getLogger("actions:wallet:delete-entity");
 async function deleteEntity(client, data, txParams) {
 	logger$3("deleteEntity %o", data);
-	const receipt = await sendArkivTransaction(client, opsToTxData({ deletes: [data] }), txParams);
+	const { receipt } = await sendArkivTransaction(client, { deletes: [data] }, txParams);
 	logger$3("Receipt from deleteEntity %o", receipt);
 	return {
 		txHash: receipt.transactionHash,
@@ -442,74 +738,43 @@ async function deleteEntity(client, data, txParams) {
 const logger$2 = require_queryBuilder.getLogger("actions:wallet:extend-entity");
 async function extendEntity(client, data, txParams) {
 	logger$2("extendEntity %o", data);
-	const receipt = await sendArkivTransaction(client, opsToTxData({ extensions: [data] }), txParams);
+	const { receipt, extendedExpiries } = await sendArkivTransaction(client, { extensions: [data] }, txParams);
 	logger$2("Receipt from extendEntity %o", receipt);
+	const [expiresAt] = extendedExpiries;
+	if (expiresAt === void 0) throw new require_queryBuilder.EntityMutationError(`Transaction ${receipt.transactionHash} succeeded, but the receipt did not carry the expected entity expiry.`);
 	return {
 		txHash: receipt.transactionHash,
-		entityKey: receipt.logs[0].topics[1]
+		entityKey: data.entityKey,
+		expiresAt
 	};
 }
 
 //#endregion
 //#region src/actions/wallet/mutateEntities.ts
 const logger$1 = require_queryBuilder.getLogger("actions:wallet:mutate-entities");
-function parseReceipt(receipt, params) {
-	const createdEntities = [];
-	const updatedEntities = [];
-	const deletedEntities = [];
-	const extendedEntities = [];
-	const ownershipChanges = [];
-	const totalCreates = params.creates?.length ?? 0;
-	const totalUpdates = params.updates?.length ?? 0;
-	const totalDeletes = params.deletes?.length ?? 0;
-	const totalExtensions = params.extensions?.length ?? 0;
-	for (let index = 0; index < receipt.logs.length; index++) {
-		const log = receipt.logs[index];
-		if (index < totalCreates) createdEntities.push(log.topics[1]);
-		else if (index < totalCreates + totalDeletes) deletedEntities.push(log.topics[1]);
-		else if (index < totalCreates + totalUpdates + totalDeletes) updatedEntities.push(log.topics[1]);
-		else if (index < totalCreates + totalUpdates + totalDeletes + totalExtensions) extendedEntities.push(log.topics[1]);
-		else ownershipChanges.push(log.topics[1]);
-	}
-	return {
-		createdEntities,
-		updatedEntities,
-		deletedEntities,
-		extendedEntities,
-		ownershipChanges
-	};
-}
 async function mutateEntities(client, data, txParams) {
-	if (!data.creates && !data.updates && !data.deletes && !data.extensions) throw new Error("No operations to perform");
-	const receipt = await sendArkivTransaction(client, opsToTxData({
-		creates: data.creates ?? [],
-		updates: data.updates ?? [],
-		deletes: data.deletes ?? [],
-		extensions: data.extensions ?? [],
-		ownershipChanges: data.ownershipChanges ?? []
-	}), txParams);
+	const { receipt, createdEntityKeys } = await sendArkivTransaction(client, data, txParams);
 	logger$1("Receipt from mutateEntities %o", receipt);
-	const { createdEntities, updatedEntities, deletedEntities, extendedEntities, ownershipChanges } = parseReceipt(receipt, data);
 	return {
 		txHash: receipt.transactionHash,
-		createdEntities,
-		updatedEntities,
-		deletedEntities,
-		extendedEntities,
-		ownershipChanges
+		createdEntities: createdEntityKeys,
+		patchedEntities: (data.patches ?? []).map((p) => p.entityKey),
+		deletedEntities: (data.deletes ?? []).map((d) => d.entityKey),
+		extendedEntities: (data.extensions ?? []).map((e) => e.entityKey),
+		ownershipChanges: (data.ownershipChanges ?? []).map((o) => o.entityKey)
 	};
 }
 
 //#endregion
-//#region src/actions/wallet/updateEntity.ts
-const logger = require_queryBuilder.getLogger("actions:wallet:update-entity");
-async function updateEntity(client, data, txParams) {
-	logger("updateEntity %o", data);
-	const receipt = await sendArkivTransaction(client, opsToTxData({ updates: [data] }), txParams);
-	logger("Receipt from updateEntity %o", receipt);
+//#region src/actions/wallet/patchEntity.ts
+const logger = require_queryBuilder.getLogger("actions:wallet:patch-entity");
+async function patchEntity(client, data, txParams) {
+	logger("patchEntity %o", data);
+	const { receipt } = await sendArkivTransaction(client, { patches: [data] }, txParams);
+	logger("Receipt from patchEntity %o", receipt);
 	return {
 		txHash: receipt.transactionHash,
-		entityKey: receipt.logs[0].topics[1]
+		entityKey: data.entityKey
 	};
 }
 
@@ -518,7 +783,7 @@ async function updateEntity(client, data, txParams) {
 function walletArkivActions(client) {
 	return {
 		createEntity: (data, txParams) => createEntity(client, data, txParams),
-		updateEntity: (data, txParams) => updateEntity(client, data, txParams),
+		patchEntity: (data, txParams) => patchEntity(client, data, txParams),
 		deleteEntity: (data, txParams) => deleteEntity(client, data, txParams),
 		extendEntity: (data, txParams) => extendEntity(client, data, txParams),
 		changeOwnership: (data, txParams) => changeOwnership(client, data, txParams),
@@ -529,36 +794,42 @@ function walletArkivActions(client) {
 //#endregion
 //#region src/clients/createWalletClient.ts
 /**
-* Creates a Public Client with a given [Transport](https://viem.sh/docs/clients/intro) configured for a [Chain](https://viem.sh/docs/clients/chains).
+* Creates a Wallet Client with a given [Transport](https://viem.sh/docs/clients/intro) configured
+* for a [Chain](https://viem.sh/docs/clients/chains) and an account.
 *
-* - Docs: https://docs.arkiv.network/ts-sdk/clients/public
+* - Docs: https://docs.arkiv.network/ts-sdk/clients/wallet
 *
-* A Public Client is an interface to "public" [Ethereum JSON-RPC API](https://ethereum.org/en/developers/docs/apis/json-rpc/), [Arkiv JSON-RPC API](https://docs.arkiv.network/json-rpc/), and [Braga JSON-RPC API](https://braga.holesky.arkiv.network/rpc) methods such as retrieving block numbers, transactions, reading from smart contracts, etc through [Public Actions](/docs/actions/public/introduction).
+* A Wallet Client signs and sends transactions, so it carries an `account` and exposes everything
+* that mutates state — `createEntity`, `patchEntity`, `deleteEntity`, `extendEntity`,
+* `changeOwnership` and `mutateEntities` — on top of the read actions a Public Client has.
 *
 * @param parameters - Configuration object for the wallet client (chain, transport, account, etc.)
 * @returns A Arkiv Wallet Client. {@link WalletArkivClient}
 *
 * @example
-* import { createPublicClient, http } from 'arkiv'
-* import { braga } from 'arkiv/chains'
+* import { createWalletClient } from "@arkiv-network/sdk"
+* import { cheesecake } from "@arkiv-network/sdk/chains"
+* import { http } from "viem"
+* import { privateKeyToAccount } from "viem/accounts"
 *
-* const client = createPublicClient({
-*   chain: braga,
+* const client = createWalletClient({
+*   chain: cheesecake,
 *   transport: http(),
+*   account: privateKeyToAccount("0x..."),
 * })
 */
 function createWalletClient(parameters) {
-	const { key = "wallet", name = "Wallet Client" } = parameters;
+	const { key: key$1 = "wallet", name = "Wallet Client" } = parameters;
 	return (0, viem.createClient)({
 		...parameters,
-		key,
+		key: key$1,
 		name
 	}).extend(viem.publicActions).extend(viem.walletActions).extend(walletArkivActions);
 }
 
 //#endregion
 //#region src/utils/chains.ts
-const chainMap = new Map(Object.entries(require_chains.chains_exports).map(([key, value]) => [key.toLowerCase(), value]));
+const chainMap = new Map(Object.entries(require_chains.chains_exports).map(([key$1, value]) => [key$1.toLowerCase(), value]));
 /**
 * Get a chain from its name
 * @param name - The name of the chain, case insensitive
@@ -572,14 +843,61 @@ function chainFromName(name) {
 }
 
 //#endregion
+exports.ConflictingMutationError = require_attr.ConflictingMutationError;
+exports.DECIMAL_SCALE = require_attr.DECIMAL_SCALE;
+exports.DECIMAL_UNIT = require_attr.DECIMAL_UNIT;
+exports.ENTITY_EVENTS_ABI = require_entity$1.ENTITY_EVENTS_ABI;
+exports.EmptyPatchError = require_queryBuilder.EmptyPatchError;
+exports.Entity = require_entity.Entity;
 exports.EntityMutationError = require_queryBuilder.EntityMutationError;
-exports.InvalidAttributeError = require_queryBuilder.InvalidAttributeError;
-exports.InvalidExpirationError = require_queryBuilder.InvalidExpirationError;
-exports.NoCursorOrLimitError = require_queryBuilder.NoCursorOrLimitError;
+exports.ExpirationTime = require_payload.ExpirationTime;
+exports.I32_MAX = require_attr.I32_MAX;
+exports.I32_MIN = require_attr.I32_MIN;
+exports.InvalidAttributeNameError = require_attr.InvalidAttributeNameError;
+exports.InvalidContentTypeError = require_queryBuilder.InvalidContentTypeError;
+exports.InvalidCreationFlagsError = require_errors.InvalidCreationFlagsError;
+exports.InvalidExpiryError = require_errors.InvalidExpiryError;
+exports.InvalidSaltError = require_errors.InvalidSaltError;
+exports.InvalidValueError = require_attr.InvalidValueError;
+exports.MAX_ATTRIBUTES = require_attr.MAX_ATTRIBUTES;
+exports.MAX_EXPIRES_AT = require_expiry.MAX_EXPIRES_AT;
+exports.MAX_NAME_BYTES = require_attr.MAX_NAME_BYTES;
+exports.MAX_PAYLOAD_BYTES = require_attr.MAX_PAYLOAD_BYTES;
+exports.MAX_SALT = require_entity$1.MAX_SALT;
+exports.MAX_STRING_BYTES = require_attr.MAX_STRING_BYTES;
+exports.MissingValueError = require_attr.MissingValueError;
 exports.NoEntityFoundError = require_queryBuilder.NoEntityFoundError;
 exports.NoMoreResultsError = require_queryBuilder.NoMoreResultsError;
+exports.NoRandomSourceError = require_errors.NoRandomSourceError;
+exports.OperationType = require_expiry.OperationType;
+exports.TooManyAttributesError = require_attr.TooManyAttributesError;
+exports.U256_MAX = require_attr.U256_MAX;
+exports.U64_MAX = require_attr.U64_MAX;
+exports.UnknownAttributeTypeError = require_attr.UnknownAttributeTypeError;
+exports.UntypedValueError = require_attr.UntypedValueError;
+exports.addr = require_attr.addr;
+exports.bool = require_attr.bool;
+exports.bytes32 = require_attr.bytes32;
 exports.chainFromName = chainFromName;
 exports.createPublicClient = createPublicClient;
 exports.createWalletClient = createWalletClient;
+exports.dec = require_attr.dec;
+exports.decFromUnits = require_attr.decFromUnits;
+exports.decUnits = require_attr.decUnits;
+exports.decodeCreationFlags = require_flags.decodeCreationFlags;
+exports.encodeCreationFlags = require_flags.encodeCreationFlags;
+exports.i32 = require_attr.i32;
+exports.isArkivValue = require_attr.isArkivValue;
+exports.isValidAttributeName = require_attr.isValidAttributeName;
 exports.jsonToPayload = require_payload.jsonToPayload;
-exports.stringToPayload = require_payload.stringToPayload;
+exports.key = require_attr.key;
+exports.predictEntityKey = require_entity$1.predictEntityKey;
+exports.randomSalt = require_entity$1.randomSalt;
+exports.resolveExpiry = require_expiry.resolveExpiry;
+exports.str = require_attr.str;
+exports.stringToPayload = require_payload.stringToPayload;
+exports.toBlocks = require_expiry.toBlocks;
+exports.toValue = require_attr.toValue;
+exports.u256 = require_attr.u256;
+exports.u64 = require_attr.u64;
+exports.validateAttributeName = require_attr.validateAttributeName;