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

package/dist/index.cjs

@@ -1,17 +1,19 @@
 const require_chains = require('./chains-BifaY04V.cjs');
-const require_queryBuilder = require('./queryBuilder-DM-YO1Y7.cjs');
-const require_payload = require('./payload-vwU3Rc6P.cjs');
-require('./types-o3zWarRp.cjs');
+const require_queryBuilder = require('./queryBuilder-J37buGCi.cjs');
+const require_consts = require('./consts-CxT1-RXU.cjs');
+const require_entity = require('./entity-BhSXaB23.cjs');
+require('./types-a8gm_IaQ.cjs');
+const require_payload = require('./payload-D8YLKcJj.cjs');
 let viem = require("viem");
 
 //#region src/actions/public/getBlockTiming.ts
-const logger$9 = require_queryBuilder.getLogger("actions:public:get-block-timing");
+const logger$8 = require_queryBuilder.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,
@@ -97,78 +99,289 @@ async function query(client, query$1, queryOptions) {
 }
 
 //#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)"
+//#region src/utils/arkivTransactions.ts
+const logger$7 = require_queryBuilder.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 require_queryBuilder.InvalidContentTypeError(contentType);
+}
+const ENTITY_EXECUTE_ABI = (0, viem.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 = (0, viem.parseAbi)(["event EntityOperation(bytes32 indexed entityKey, uint8 indexed operationType, address indexed owner, uint32 expiresAt, bytes32 entityHash)"]);
+const ENTITY_ERRORS_ABI = (0, viem.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 = (0, viem.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 [
+		(0, viem.toHex)(padded.slice(0, 32)),
+		(0, viem.toHex)(padded.slice(32, 64)),
+		(0, viem.toHex)(padded.slice(64, 96)),
+		(0, viem.toHex)(padded.slice(96, 128))
+	];
+}
+function encodeMime128(contentType) {
+	return { data: contentType ? encodeBytes128((0, viem.stringToBytes)(contentType)) : EMPTY_BYTES128 };
+}
+function encodeAttribute(attr) {
+	require_queryBuilder.validateAttribute(attr);
+	const name = (0, viem.toHex)(attr.key, { size: 32 });
+	if (typeof attr.value === "string") {
+		if (require_queryBuilder.isEntityKey(attr.value)) return {
+			name,
+			valueType: require_queryBuilder.RpcAttributeValueType.EntityKey,
+			value: [
+				(0, viem.toHex)((0, viem.toBytes)(attr.value), { size: 32 }),
+				ZERO_32,
+				ZERO_32,
+				ZERO_32
+			]
+		};
+		return {
+			name,
+			valueType: require_queryBuilder.RpcAttributeValueType.String,
+			value: encodeBytes128((0, viem.stringToBytes)(attr.value))
+		};
+	}
+	return {
+		name,
+		valueType: require_queryBuilder.RpcAttributeValueType.Uint,
+		value: [
+			(0, viem.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 require_queryBuilder.DuplicateAttributeError(encoded[i].key);
+	return encoded.map(({ key: _,...attr }) => attr);
+}
+function toBTL(expiresIn) {
+	require_queryBuilder.validateExpiresIn(expiresIn);
+	return Math.ceil(expiresIn / require_consts.BLOCK_TIME);
+}
+function deriveEntityKey(chainId, owner, nonce) {
+	return (0, viem.keccak256)((0, viem.encodePacked)([
+		"uint256",
+		"address",
+		"address",
+		"uint32"
+	], [
+		BigInt(chainId),
+		require_consts.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: require_consts.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: require_entity.EntityOperationType.Create,
+			entityKey: createdEntityKeys[i],
+			payload: (0, viem.toHex)(item.payload),
+			contentType: encodeMime128(item.contentType),
+			attributes: encodeAttributes(item.attributes),
+			expiresIn: toBTL(item.expiresIn),
+			newOwner: ZERO_ADDRESS
+		})),
+		...(updates ?? []).map((item) => ({
+			operationType: require_entity.EntityOperationType.Update,
+			entityKey: item.entityKey,
+			payload: (0, viem.toHex)(item.payload),
+			contentType: encodeMime128(item.contentType),
+			attributes: encodeAttributes(item.attributes),
+			expiresIn: 0,
+			newOwner: ZERO_ADDRESS
+		})),
+		...(deletes ?? []).map((item) => ({
+			operationType: require_entity.EntityOperationType.Delete,
+			entityKey: item.entityKey,
+			payload: "0x",
+			contentType: encodeMime128(""),
+			attributes: [],
+			expiresIn: 0,
+			newOwner: ZERO_ADDRESS
+		})),
+		...(extensions ?? []).map((item) => ({
+			operationType: require_entity.EntityOperationType.Extend,
+			entityKey: item.entityKey,
+			payload: "0x",
+			contentType: encodeMime128(""),
+			attributes: [],
+			expiresIn: toBTL(item.expiresIn),
+			newOwner: ZERO_ADDRESS
+		})),
+		...(ownershipChanges ?? []).map((item) => ({
+			operationType: require_entity.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: require_consts.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: require_consts.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 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,
+			createdEntityKeys
+		};
+	} catch (error) {
+		let message = "Transaction failed";
+		if (error instanceof viem.TransactionExecutionError) message += `: ${error.details}`;
+		else if (error instanceof viem.ContractFunctionExecutionError) {
+			logger$7("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;
+		throw new require_queryBuilder.EntityMutationError(message);
+	}
+}
+
+//#endregion
+//#region src/actions/public/subscribeEntityEvents.ts
+const logger$6 = require_queryBuilder.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 = (0, viem.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 require_entity.EntityOperationType.Create:
 						onEntityCreated?.({
-							entityKey: (0, viem.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 require_entity.EntityOperationType.Update:
 						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
+							entityKey,
+							owner,
+							expiresAt,
+							entityHash
 						});
 						break;
-					case "ArkivEntityBTLExtended":
+					case require_entity.EntityOperationType.Extend:
 						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
+							entityKey,
+							owner,
+							expiresAt,
+							entityHash
 						});
 						break;
-					case "ArkivEntityExpired":
-						onEntityExpired?.({
-							entityKey: (0, viem.toHex)(event.args.entityKey, { size: 32 }),
-							owner: event.args.ownerAddress
+					case require_entity.EntityOperationType.Transfer:
+						onEntityOwnerChanged?.({
+							entityKey,
+							owner,
+							entityHash
 						});
 						break;
-					case "ArkivEntityOwnerChanged":
-						onEntityOwnerChanged?.({
-							entityKey: (0, viem.toHex)(event.args.entityKey, { size: 32 }),
-							oldOwner: event.args.oldOwnerAddress,
-							newOwner: event.args.newOwnerAddress
+					case require_entity.EntityOperationType.Delete:
+						onEntityDeleted?.({
+							entityKey,
+							owner
 						});
 						break;
 					default:
-						console.warn("unknown event from subscribeEntityEvents", event);
+						onEntityExpired?.({
+							entityKey,
+							owner
+						});
 						break;
 				}
 			}
@@ -187,6 +400,7 @@ function publicArkivActions(client) {
 		getEntity: (key) => getEntity(client, key),
 		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, {
@@ -230,141 +444,12 @@ function createPublicClient(parameters) {
 	}).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;
-}
-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 = 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) => [
-			(0, viem.toHex)(Math.ceil(item.expiresIn / require_payload.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) => [
-			item.entityKey,
-			(0, viem.toHex)(item.contentType),
-			(0, viem.toHex)(Math.ceil(item.expiresIn / require_payload.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) => [item.entityKey, (0, viem.toHex)(Math.ceil(item.expiresIn / require_payload.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);
-}
-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: require_payload.ARKIV_ADDRESS,
-		value: 0n,
-		data,
-		...txParams
-	});
-	try {
-		const compressed = await compress((0, viem.toBytes)(data));
-		const txHash = await walletClient.sendTransaction({
-			account: client.account,
-			chain: client.chain,
-			to: require_payload.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_payload.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}`);
-		}
-		return receipt;
-	} catch (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);
-	}
-}
-
 //#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,
@@ -377,11 +462,11 @@ 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 } = 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]
 	};
 }
 
@@ -390,7 +475,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,
@@ -403,61 +488,28 @@ 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 } = 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 = 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,
+		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)
 	};
 }
 
@@ -466,11 +518,11 @@ async function mutateEntities(client, data, txParams) {
 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);
+	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
 	};
 }
 
@@ -533,7 +585,13 @@ function chainFromName(name) {
 }
 
 //#endregion
+exports.DuplicateAttributeError = require_queryBuilder.DuplicateAttributeError;
 exports.EntityMutationError = require_queryBuilder.EntityMutationError;
+exports.EntityOperationType = require_entity.EntityOperationType;
+exports.InvalidAttributeError = require_queryBuilder.InvalidAttributeError;
+exports.InvalidAttributeKeyError = require_queryBuilder.InvalidAttributeKeyError;
+exports.InvalidContentTypeError = require_queryBuilder.InvalidContentTypeError;
+exports.InvalidExpirationError = require_queryBuilder.InvalidExpirationError;
 exports.NoCursorOrLimitError = require_queryBuilder.NoCursorOrLimitError;
 exports.NoEntityFoundError = require_queryBuilder.NoEntityFoundError;
 exports.NoMoreResultsError = require_queryBuilder.NoMoreResultsError;
@@ -541,10 +599,4 @@ exports.chainFromName = chainFromName;
 exports.createPublicClient = createPublicClient;
 exports.createWalletClient = createWalletClient;
 exports.jsonToPayload = require_payload.jsonToPayload;
-exports.stringToPayload = require_payload.stringToPayload;
-Object.keys(viem).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return viem[k]; }
-  });
-});
+exports.stringToPayload = require_payload.stringToPayload;