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

package/dist/index.js

@@ -1,19 +1,19 @@
 import { t as chains_exports } from "./chains-CrtkVbBh.js";
-import { a as entityFromRpcResult, c as NoEntityFoundError, l as NoMoreResultsError, o as EntityMutationError, s as NoCursorOrLimitError, t as QueryBuilder, u as getLogger } from "./queryBuilder-DonAg1aq.js";
-import { i as BLOCK_TIME, n as stringToPayload, r as ARKIV_ADDRESS, t as jsonToPayload } from "./payload-DKBYYjeA.js";
-import "./types-H-TSmRpm.js";
-import { TransactionExecutionError, bytesToHex, createClient, decodeEventLog, hexToBytes, hexToString, numberToHex, parseAbi, publicActions, toBytes, toHex, toRlp, walletActions } from "viem";
-
-export * from "viem"
+import { S as getLogger, _ as InvalidContentTypeError, b as NoEntityFoundError, c as isEntityKey, d as entityFromRpcResult, f as RpcAttributeValueType, g as InvalidAttributeKeyError, h as InvalidAttributeError, l as validateAttribute, m as EntityMutationError, n as QueryBuilder, p as DuplicateAttributeError, r as SelectQueryBuilder, u as validateExpiresIn, v as InvalidExpirationError, x as NoMoreResultsError, y as NoCursorOrLimitError } from "./queryBuilder-BE_XhLLa.js";
+import { n as BLOCK_TIME, t as ARKIV_ADDRESS } from "./consts-Bz0LZQZY.js";
+import { n as EntityOperationType } from "./entity-DGfVyB-a.js";
+import "./types-Ci4BRClw.js";
+import { n as stringToPayload, t as jsonToPayload } from "./payload-BpNUPOnY.js";
+import { ContractFunctionExecutionError, ContractFunctionRevertedError, TransactionExecutionError, bytesToHex, createClient, decodeEventLog, encodePacked, hexToBytes, keccak256, numberToHex, parseAbi, publicActions, stringToBytes, toBytes, toHex, walletActions } from "viem";
 
 //#region src/actions/public/getBlockTiming.ts
-const logger$9 = getLogger("actions:public:get-block-timing");
+const logger$8 = getLogger("actions:public:get-block-timing");
 async function getBlockTiming(client) {
 	const blockTiming = await client.request({
 		method: "arkiv_getBlockTiming",
 		params: []
 	});
-	logger$9("Block timing %o", blockTiming);
+	logger$8("Block timing %o", blockTiming);
 	return {
 		currentBlock: BigInt(blockTiming.current_block),
 		currentBlockTime: blockTiming.current_block_time,
@@ -99,78 +99,289 @@ async function query(client, query$1, queryOptions) {
 }
 
 //#endregion
-//#region src/actions/public/subscribeEntityEvents.ts
-const logger$8 = getLogger("actions:public:subscribe-entity-events");
-const arkivABI = 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)"
+//#region src/utils/arkivTransactions.ts
+const logger$7 = getLogger("utils:arkiv-transactions");
+const MIME_REGEX = /^[a-z][a-z0-9!#$&\-^_]*\/[a-z0-9][a-z0-9!#$&\-^_.+]*$/;
+function validateContentType(contentType) {
+	if (!MIME_REGEX.test(contentType)) throw new InvalidContentTypeError(contentType);
+}
+const ENTITY_EXECUTE_ABI = parseAbi(["function execute((uint8 operationType, bytes32 entityKey, bytes payload, (bytes32[4] data) contentType, (bytes32 name, uint8 valueType, bytes32[4] value)[] attributes, uint32 expiresIn, address newOwner)[] ops) external"]);
+const ENTITY_OPERATION_EVENT_ABI = parseAbi(["event EntityOperation(bytes32 indexed entityKey, uint8 indexed operationType, address indexed owner, uint32 expiresAt, bytes32 entityHash)"]);
+const ENTITY_ERRORS_ABI = parseAbi([
+	"error EmptyBatch()",
+	"error AttributesNotSorted()",
+	"error InvalidValueType(bytes32 name, uint8 valueType)",
+	"error InvalidOpType(uint8 operationType)",
+	"error ExpiryInPast(uint32 expiresAt, uint32 currentBlock)",
+	"error TooManyAttributes(uint256 count, uint256 maxCount)",
+	"error EntityNotFound(bytes32 entityKey)",
+	"error NotOwner(bytes32 entityKey, address caller, address owner)",
+	"error EntityExpired(bytes32 entityKey, uint32 expiresAt)",
+	"error ExpiryNotExtended(bytes32 entityKey, uint32 newExpiresAt, uint32 currentExpiresAt)",
+	"error TransferToZeroAddress(bytes32 entityKey)",
+	"error TransferToSelf(bytes32 entityKey)",
+	"error EntityNotExpired(bytes32 entityKey, uint32 expiresAt)",
+	"error Ident32Empty()",
+	"error Ident32TooLong(uint256 length)",
+	"error Ident32InvalidByte(uint256 position, bytes1 value)",
+	"error MimeEmpty()",
+	"error MimeTooLong(uint256 length, uint256 maxLength)",
+	"error MimeInvalidByte(uint256 position, bytes1 value)",
+	"error MimeIncomplete()"
 ]);
+const EXECUTE_ABI = [...ENTITY_EXECUTE_ABI, ...ENTITY_ERRORS_ABI];
+const ENTITY_NONCE_ABI = parseAbi(["function nonces(address owner) view returns (uint32)"]);
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+const ZERO_32 = `0x${"00".repeat(32)}`;
+const EMPTY_BYTES128 = [
+	ZERO_32,
+	ZERO_32,
+	ZERO_32,
+	ZERO_32
+];
+function encodeBytes128(data) {
+	const padded = new Uint8Array(128);
+	padded.set(data.slice(0, 128));
+	return [
+		toHex(padded.slice(0, 32)),
+		toHex(padded.slice(32, 64)),
+		toHex(padded.slice(64, 96)),
+		toHex(padded.slice(96, 128))
+	];
+}
+function encodeMime128(contentType) {
+	return { data: contentType ? encodeBytes128(stringToBytes(contentType)) : EMPTY_BYTES128 };
+}
+function encodeAttribute(attr) {
+	validateAttribute(attr);
+	const name = toHex(attr.key, { size: 32 });
+	if (typeof attr.value === "string") {
+		if (isEntityKey(attr.value)) return {
+			name,
+			valueType: RpcAttributeValueType.EntityKey,
+			value: [
+				toHex(toBytes(attr.value), { size: 32 }),
+				ZERO_32,
+				ZERO_32,
+				ZERO_32
+			]
+		};
+		return {
+			name,
+			valueType: RpcAttributeValueType.String,
+			value: encodeBytes128(stringToBytes(attr.value))
+		};
+	}
+	return {
+		name,
+		valueType: RpcAttributeValueType.Uint,
+		value: [
+			toHex(BigInt(attr.value), { size: 32 }),
+			ZERO_32,
+			ZERO_32,
+			ZERO_32
+		]
+	};
+}
+function encodeAttributes(attrs) {
+	const encoded = attrs.map((attr) => ({
+		key: attr.key,
+		...encodeAttribute(attr)
+	})).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+	for (let i = 1; i < encoded.length; i++) if (encoded[i].name === encoded[i - 1].name) throw new DuplicateAttributeError(encoded[i].key);
+	return encoded.map(({ key: _,...attr }) => attr);
+}
+function toBTL(expiresIn) {
+	validateExpiresIn(expiresIn);
+	return Math.ceil(expiresIn / BLOCK_TIME);
+}
+function deriveEntityKey(chainId, owner, nonce) {
+	return keccak256(encodePacked([
+		"uint256",
+		"address",
+		"address",
+		"uint32"
+	], [
+		BigInt(chainId),
+		ARKIV_ADDRESS,
+		owner,
+		Number(nonce)
+	]));
+}
+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;
+	const { creates, updates, deletes, extensions, ownershipChanges } = ops;
+	const owner = client.account.address;
+	const ownerNonce = creates?.length ? BigInt(await walletClient.readContract({
+		address: ARKIV_ADDRESS,
+		abi: ENTITY_NONCE_ABI,
+		functionName: "nonces",
+		args: [owner]
+	})) : 0n;
+	const createdEntityKeys = (creates ?? []).map((_, i) => deriveEntityKey(client.chain.id, owner, ownerNonce + BigInt(i)));
+	for (const item of creates ?? []) validateContentType(item.contentType);
+	for (const item of updates ?? []) validateContentType(item.contentType);
+	const operations = [
+		...(creates ?? []).map((item, i) => ({
+			operationType: EntityOperationType.Create,
+			entityKey: createdEntityKeys[i],
+			payload: toHex(item.payload),
+			contentType: encodeMime128(item.contentType),
+			attributes: encodeAttributes(item.attributes),
+			expiresIn: toBTL(item.expiresIn),
+			newOwner: ZERO_ADDRESS
+		})),
+		...(updates ?? []).map((item) => ({
+			operationType: EntityOperationType.Update,
+			entityKey: item.entityKey,
+			payload: toHex(item.payload),
+			contentType: encodeMime128(item.contentType),
+			attributes: encodeAttributes(item.attributes),
+			expiresIn: 0,
+			newOwner: ZERO_ADDRESS
+		})),
+		...(deletes ?? []).map((item) => ({
+			operationType: EntityOperationType.Delete,
+			entityKey: item.entityKey,
+			payload: "0x",
+			contentType: encodeMime128(""),
+			attributes: [],
+			expiresIn: 0,
+			newOwner: ZERO_ADDRESS
+		})),
+		...(extensions ?? []).map((item) => ({
+			operationType: EntityOperationType.Extend,
+			entityKey: item.entityKey,
+			payload: "0x",
+			contentType: encodeMime128(""),
+			attributes: [],
+			expiresIn: toBTL(item.expiresIn),
+			newOwner: ZERO_ADDRESS
+		})),
+		...(ownershipChanges ?? []).map((item) => ({
+			operationType: EntityOperationType.Transfer,
+			entityKey: item.entityKey,
+			payload: "0x",
+			contentType: encodeMime128(""),
+			attributes: [],
+			expiresIn: 0,
+			newOwner: item.newOwner
+		}))
+	];
+	logger$7("Sending execute with %d operations %s", operations.length, JSON.stringify(operations));
+	try {
+		const txHash = await walletClient.writeContract({
+			address: ARKIV_ADDRESS,
+			abi: EXECUTE_ABI,
+			functionName: "execute",
+			args: [operations],
+			account: client.account,
+			chain: client.chain,
+			...txParams
+		});
+		const receipt = await walletClient.waitForTransactionReceipt({ hash: txHash });
+		logger$7("Tx receipt %o", receipt);
+		if (receipt.status === "reverted") {
+			try {
+				await walletClient.simulateContract({
+					address: ARKIV_ADDRESS,
+					abi: EXECUTE_ABI,
+					functionName: "execute",
+					args: [operations],
+					account: client.account,
+					chain: client.chain
+				});
+			} catch (err) {
+				const error = err;
+				const reason = error.shortMessage ?? error.cause?.details ?? "No reason provided by backend.";
+				throw new EntityMutationError(`Transaction ${receipt.transactionHash} reverted. Reason: ${reason}`);
+			}
+			throw new EntityMutationError(`Transaction ${receipt.transactionHash} reverted. No reason provided by backend.`);
+		}
+		return {
+			receipt,
+			createdEntityKeys
+		};
+	} catch (error) {
+		let message = "Transaction failed";
+		if (error instanceof TransactionExecutionError) message += `: ${error.details}`;
+		else if (error instanceof ContractFunctionExecutionError) {
+			logger$7("Contract function execution error data:", error.shortMessage);
+			if (error.cause instanceof ContractFunctionRevertedError) message += `: ${error.cause.message}`;
+			else message += ": Execution error without revert data";
+		} else if (error instanceof EntityMutationError) throw error;
+		throw new EntityMutationError(message);
+	}
+}
+
+//#endregion
+//#region src/actions/public/subscribeEntityEvents.ts
+const logger$6 = getLogger("actions:public:subscribe-entity-events");
+const arkivABI = ENTITY_OPERATION_EVENT_ABI;
 async function subscribeEntityEvents(client, { onError, onEntityCreated, onEntityUpdated, onEntityDeleted, onEntityExpired, onEntityExpiresInExtended, onEntityOwnerChanged }, pollingInterval, fromBlock) {
 	return client.watchEvent({
 		pollingInterval: pollingInterval ?? 1e3,
 		fromBlock,
 		events: arkivABI,
 		onLogs: (logs) => {
-			logger$8("logs from subscribeEntityEvents %o", logs);
+			logger$6("logs from subscribeEntityEvents %o", logs);
 			for (const log of logs) {
 				const event = decodeEventLog({
 					abi: arkivABI,
 					topics: log.topics,
 					data: log.data
 				});
-				logger$8("event from subscribeEntityEvents %o", event);
-				switch (event.eventName) {
-					case "ArkivEntityCreated":
+				logger$6("event from subscribeEntityEvents %o", event);
+				if (event.eventName !== "EntityOperation") continue;
+				const entityKey = event.args.entityKey;
+				const owner = event.args.owner;
+				const expiresAt = event.args.expiresAt;
+				const entityHash = event.args.entityHash;
+				switch (Number(event.args.operationType)) {
+					case EntityOperationType.Create:
 						onEntityCreated?.({
-							entityKey: toHex(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress,
-							expirationBlock: Number(event.args.expirationBlock),
-							cost: event.args.cost
+							entityKey,
+							owner,
+							expiresAt,
+							entityHash
 						});
 						break;
-					case "ArkivEntityUpdated":
+					case EntityOperationType.Update:
 						onEntityUpdated?.({
-							entityKey: 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: toHex(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress
+							entityKey,
+							owner,
+							expiresAt,
+							entityHash
 						});
 						break;
-					case "ArkivEntityBTLExtended":
+					case EntityOperationType.Extend:
 						onEntityExpiresInExtended?.({
-							entityKey: toHex(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress,
-							oldExpirationBlock: Number(event.args.oldExpirationBlock),
-							newExpirationBlock: Number(event.args.newExpirationBlock),
-							cost: event.args.cost
+							entityKey,
+							owner,
+							expiresAt,
+							entityHash
 						});
 						break;
-					case "ArkivEntityExpired":
-						onEntityExpired?.({
-							entityKey: toHex(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress
+					case EntityOperationType.Transfer:
+						onEntityOwnerChanged?.({
+							entityKey,
+							owner,
+							entityHash
 						});
 						break;
-					case "ArkivEntityOwnerChanged":
-						onEntityOwnerChanged?.({
-							entityKey: toHex(event.args.entityKey, { size: 32 }),
-							oldOwner: event.args.oldOwnerAddress,
-							newOwner: event.args.newOwnerAddress
+					case EntityOperationType.Delete:
+						onEntityDeleted?.({
+							entityKey,
+							owner
 						});
 						break;
 					default:
-						console.warn("unknown event from subscribeEntityEvents", event);
+						onEntityExpired?.({
+							entityKey,
+							owner
+						});
 						break;
 				}
 			}
@@ -189,6 +400,7 @@ function publicArkivActions(client) {
 		getEntity: (key) => getEntity(client, key),
 		query: (rawQuery, queryOptions) => query(client, rawQuery, queryOptions),
 		buildQuery: () => new QueryBuilder(client),
+		select: (selection) => new SelectQueryBuilder(client, selection),
 		getBlockTiming: () => getBlockTiming(client),
 		getEntityCount: () => getEntityCount(client),
 		subscribeEntityEvents: ({ onError, onEntityCreated, onEntityUpdated, onEntityDeleted, onEntityExpired, onEntityExpiresInExtended }, pollingInterval, fromBlock) => subscribeEntityEvents(client, {
@@ -232,141 +444,12 @@ function createPublicClient(parameters) {
 	}).extend(publicActions).extend(publicArkivActions);
 }
 
-//#endregion
-//#region src/utils/compression.ts
-const logger$7 = 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;
-}
-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);
-		}
-	}
-	const brotliInstance = await getBrotli();
-	if (!brotliInstance) {
-		console.warn("Brotli instance not found, not compressing data");
-		return data;
-	}
-	const brotliCompressed = brotliInstance.compress(data);
-	logger$7("Brotli compressed with wasm size %d", brotliCompressed.length);
-	return brotliCompressed;
-}
-
-//#endregion
-//#region src/utils/arkivTransactions.ts
-const logger$6 = getLogger("utils:arkiv-transactions");
-function opsToTxData({ creates, updates, deletes, extensions, ownershipChanges }) {
-	function formatAttributes(attribute) {
-		return [toHex(attribute.key), toHex(typeof attribute.value === "number" && attribute.value === 0 ? "" : attribute.value)];
-	}
-	const payload = [
-		(creates ?? []).map((item) => [
-			toHex(Math.ceil(item.expiresIn / BLOCK_TIME)),
-			toHex(item.contentType),
-			toHex(item.payload),
-			item.attributes.filter((attribute) => typeof attribute.value === "string").map(formatAttributes),
-			item.attributes.filter((attribute) => typeof attribute.value === "number").map(formatAttributes)
-		]),
-		(updates ?? []).map((item) => [
-			item.entityKey,
-			toHex(item.contentType),
-			toHex(Math.ceil(item.expiresIn / BLOCK_TIME)),
-			toHex(item.payload),
-			item.attributes.filter((attribute) => typeof attribute.value === "string").map(formatAttributes),
-			item.attributes.filter((attribute) => typeof attribute.value === "number").map(formatAttributes)
-		]),
-		(deletes ?? []).map((item) => item.entityKey),
-		(extensions ?? []).map((item) => [item.entityKey, toHex(Math.ceil(item.expiresIn / BLOCK_TIME))]),
-		(ownershipChanges ?? []).map((item) => [item.entityKey, item.newOwner])
-	];
-	logger$6("txData to send as RLP %o length %d", payload, payload.length);
-	return toRlp(payload);
-}
-async function sendArkivTransaction(client, data, txParams) {
-	if (!client.account) throw new Error("Account required");
-	const walletClient = client;
-	logger$6("Sending transaction %o", {
-		account: client.account,
-		chain: client.chain,
-		to: ARKIV_ADDRESS,
-		value: 0n,
-		data,
-		...txParams
-	});
-	try {
-		const compressed = await compress(toBytes(data));
-		const txHash = await walletClient.sendTransaction({
-			account: client.account,
-			chain: client.chain,
-			to: ARKIV_ADDRESS,
-			value: 0n,
-			data: 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: ARKIV_ADDRESS,
-				value: 0n,
-				data: toHex(compressed),
-				...txParams
-			});
-			throw new EntityMutationError(`Transaction ${receipt.transactionHash} reverted. Please make sure the data for entities doesn't contain invalid characters or invalid data types.
-          Reason: ${callResult.data ? hexToString(callResult.data) : "No reason provided by backend."}`);
-		} catch (err) {
-			const 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 EntityMutationError(`Transaction ${receipt.transactionHash} reverted. Reason: ${reason}`);
-		}
-		return receipt;
-	} catch (error) {
-		let message = "Transaction failed";
-		if (error instanceof TransactionExecutionError) message += `: ${error.details}`;
-		else if (error instanceof EntityMutationError) throw error;
-		logger$6("%s Detailed error stack: %o", message, error);
-		throw new EntityMutationError(message);
-	}
-}
-
 //#endregion
 //#region src/actions/wallet/changeOwnership.ts
 const logger$5 = 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,
@@ -379,11 +462,11 @@ async function changeOwnership(client, data, txParams) {
 const logger$4 = 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 } = await sendArkivTransaction(client, { creates: [data] }, txParams);
 	logger$4("Receipt from createEntity %o", receipt);
 	return {
 		txHash: receipt.transactionHash,
-		entityKey: receipt.logs[0].topics[1]
+		entityKey: createdEntityKeys[0]
 	};
 }
 
@@ -392,7 +475,7 @@ async function createEntity(client, data, txParams) {
 const logger$3 = 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,
@@ -405,61 +488,28 @@ async function deleteEntity(client, data, txParams) {
 const logger$2 = 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 } = await sendArkivTransaction(client, { extensions: [data] }, txParams);
 	logger$2("Receipt from extendEntity %o", receipt);
 	return {
 		txHash: receipt.transactionHash,
-		entityKey: receipt.logs[0].topics[1]
+		entityKey: data.entityKey
 	};
 }
 
 //#endregion
 //#region src/actions/wallet/mutateEntities.ts
 const logger$1 = 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,
+		updatedEntities: (data.updates ?? []).map((u) => u.entityKey),
+		deletedEntities: (data.deletes ?? []).map((d) => d.entityKey),
+		extendedEntities: (data.extensions ?? []).map((e) => e.entityKey),
+		ownershipChanges: (data.ownershipChanges ?? []).map((o) => o.entityKey)
 	};
 }
 
@@ -468,11 +518,11 @@ async function mutateEntities(client, data, txParams) {
 const logger = getLogger("actions:wallet:update-entity");
 async function updateEntity(client, data, txParams) {
 	logger("updateEntity %o", data);
-	const receipt = await sendArkivTransaction(client, opsToTxData({ updates: [data] }), txParams);
+	const { receipt } = await sendArkivTransaction(client, { updates: [data] }, txParams);
 	logger("Receipt from updateEntity %o", receipt);
 	return {
 		txHash: receipt.transactionHash,
-		entityKey: receipt.logs[0].topics[1]
+		entityKey: data.entityKey
 	};
 }
 
@@ -535,5 +585,5 @@ function chainFromName(name) {
 }
 
 //#endregion
-export { EntityMutationError, NoCursorOrLimitError, NoEntityFoundError, NoMoreResultsError, chainFromName, createPublicClient, createWalletClient, jsonToPayload, stringToPayload };
+export { DuplicateAttributeError, EntityMutationError, EntityOperationType, InvalidAttributeError, InvalidAttributeKeyError, InvalidContentTypeError, InvalidExpirationError, NoCursorOrLimitError, NoEntityFoundError, NoMoreResultsError, chainFromName, createPublicClient, createWalletClient, jsonToPayload, stringToPayload };
 //# sourceMappingURL=index.js.map