@arkiv-network/sdk 0.0.36-dev.6 → 0.1.1-dev.0

package/dist/entity-Dgf1SSpi.d.cts

@@ -0,0 +1,41 @@
+import { Hex } from "viem";
+
+//#region src/types/mimeTypes.d.ts
+type MimeType = "text/plain" | "text/html" | "text/css" | "text/csv" | "text/xml" | "text/javascript" | "application/json" | "application/xml" | "application/pdf" | "application/zip" | "application/gzip" | "application/octet-stream" | "application/javascript" | "application/x-www-form-urlencoded" | "image/png" | "image/jpeg" | "image/webp" | "image/gif" | "image/svg+xml" | "audio/mpeg" | "audio/wav" | "audio/ogg" | "video/mp4" | "video/webm" | "video/ogg" | "multipart/form-data";
+//#endregion
+//#region src/types/attributes.d.ts
+type Attribute = {
+  key: string;
+  value: string | number;
+};
+//#endregion
+//#region src/types/txParams.d.ts
+type TxParams = {
+  gas?: bigint;
+  nonce?: number;
+  gasPrice?: bigint;
+  maxFeePerGas?: never;
+  maxPriorityFeePerGas?: never;
+} | {
+  gas?: bigint;
+  nonce?: number;
+  maxFeePerGas?: bigint;
+  maxPriorityFeePerGas?: bigint;
+  gasPrice?: never;
+};
+//#endregion
+//#region src/types/entity.d.ts
+declare class Entity {
+  key: Hex;
+  owner: Hex;
+  expiresAtBlock: bigint;
+  payload: Uint8Array;
+  attributes: Attribute[];
+  contentType: MimeType;
+  constructor(key: Hex, contentType: MimeType, owner: Hex, expiresAtBlock: bigint, payload: Uint8Array, attributes: Attribute[]);
+  toText(): string;
+  toJson(): any;
+}
+//#endregion
+export { MimeType as i, TxParams as n, Attribute as r, Entity as t };
+//# sourceMappingURL=entity-Dgf1SSpi.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entity-Dgf1SSpi.d.cts","names":[],"sources":["../src/types/mimeTypes.ts","../src/types/attributes.ts","../src/types/txParams.ts","../src/types/entity.ts"],"sourcesContent":[],"mappings":";;;KAAY,QAAA;;;KCAA,SAAA;;;ADAZ,CAAA;;;KEAY,QAAA;;;EFAA,QAAA,CAAA,EAAQ,MAAA;;;;ECAR,GAAA,CAAA,EAAA,MAAS;;;;ECAT,QAAA,CAAA,EAAQ,KAAA;;;;AFAR,cGIC,MAAA,CHJO;OGKb;SACE;;EFNG,OAAA,EEQD,UFRU;cESP;eACC;mBAGN,kBACQ,iBACN,sCAEE,wBACG;EDlBJ,MAAA,CAAA,CAAA,EAAA,MAAQ"}

package/dist/index.cjs

@@ -0,0 +1,438 @@
+const require_queryBuilder = require('./queryBuilder-n9ocnT4P.cjs');
+const require_consts = require('./consts-BV9DVKgE.cjs');
+let viem = require("viem");
+
+//#region src/actions/public/getBlockTiming.ts
+async function getBlockTiming(client) {
+	const blockTiming = await client.request({
+		method: "arkiv_getBlockTiming",
+		params: []
+	});
+	console.debug("Block timing", blockTiming);
+	return {
+		currentBlock: blockTiming.current_block,
+		currentBlockTime: blockTiming.current_block_time,
+		blockDuration: blockTiming.duration
+	};
+}
+
+//#endregion
+//#region src/actions/public/getEntity.ts
+async function getEntity(client, key) {
+	const result = await client.request({
+		method: "arkiv_query",
+		params: [`$key = ${key}`]
+	});
+	console.debug("GetEntity result", result);
+	if (!result.data) throw new require_queryBuilder.NoEntityFoundError();
+	return require_queryBuilder.entityFromRpcResult(result.data[0]);
+}
+
+//#endregion
+//#region src/actions/public/getEntityCount.ts
+async function getEntityCount(client) {
+	return await client.request({
+		method: "arkiv_getEntityCount",
+		params: []
+	});
+}
+
+//#endregion
+//#region src/actions/public/query.ts
+async function query(client, query$1) {
+	const result = await client.request({
+		method: "arkiv_query",
+		params: [query$1]
+	});
+	return await Promise.all(result.data.map((entity) => require_queryBuilder.entityFromRpcResult(entity)));
+}
+
+//#endregion
+//#region src/actions/public/subscribeEntityEvents.ts
+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)"
+]);
+async function subscribeEntityEvents(client, { onError, onEntityCreated, onEntityUpdated, onEntityDeleted, onEntityExpired, onEntityExpiresInExtended }, pollingInterval, fromBlock) {
+	return client.watchEvent({
+		pollingInterval: pollingInterval ?? 1e3,
+		fromBlock: fromBlock ?? 0n,
+		events: arkivABI,
+		onLogs: (logs) => {
+			console.debug("logs from subscribeEntityEvents", logs);
+			for (const log of logs) {
+				const event = (0, viem.decodeEventLog)({
+					abi: arkivABI,
+					topics: log.topics,
+					data: log.data
+				});
+				console.debug("event from subscribeEntityEvents", 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;
+					default:
+						console.warn("unknown event from subscribeEntityEvents", event);
+						break;
+				}
+			}
+		},
+		onError: (error) => {
+			console.error("error from subscribeEntityEvents", error);
+			onError?.(error);
+		}
+	});
+}
+
+//#endregion
+//#region src/clients/decorators/arkivPublic.ts
+function publicArkivActions(client) {
+	return {
+		getEntity: (key) => getEntity(client, key),
+		query: (rawQuery) => query(client, rawQuery),
+		buildQuery: () => new require_queryBuilder.QueryBuilder(client),
+		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)
+	};
+}
+
+//#endregion
+//#region src/clients/createPublicClient.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).
+*
+* - Docs: https://docs.golemdb.io/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.golemdb.io/json-rpc/), and [Kaolin JSON-RPC API](https://kaolin.holesky.golemdb.io/rpc) methods such as retrieving block numbers, transactions, reading from smart contracts, etc through [Public Actions](/docs/actions/public/introduction).
+*
+* @param config - {@link PublicClientConfig}
+* @returns A Arkiv Public Client. {@link PublicArkivClient}
+*
+* @example
+* import { createPublicClient, http } from 'arkiv'
+* import { kaolin } from 'arkiv/chains'
+*
+* const client = createPublicClient({
+*   chain: kaolin,
+*   transport: http(),
+* })
+*/
+function createPublicClient(parameters) {
+	const { key = "public", name = "Public Client" } = parameters;
+	return (0, viem.createClient)({
+		...parameters,
+		key,
+		name
+	}).extend(publicArkivActions).extend(viem.publicActions);
+}
+
+//#endregion
+//#region src/utils/compression.ts
+let brotli = null;
+let brotliPromise = null;
+async function getBrotli() {
+	if (brotli) return brotli;
+	if (!brotliPromise) try {
+		const module$1 = await import("brotli-wasm");
+		brotliPromise = Promise.resolve(module$1.default);
+		brotli = await brotliPromise;
+	} catch (error) {
+		console.error("Error importing brotli-wasm", error);
+		brotli = require("brotli-wasm");
+	}
+	brotli = await brotliPromise;
+	return brotli;
+}
+async function compress(data) {
+	const brotliInstance = await getBrotli();
+	console.debug(`Compressing data (size: ${data.length})`);
+	if (!brotliInstance) {
+		console.warn("Brotli instance not found, not compressing data");
+		return data;
+	}
+	const brotliCompressed = brotliInstance.compress(data);
+	console.debug(`Brotli compressed data (size: ${brotliCompressed.length})`);
+	return brotliCompressed;
+}
+
+//#endregion
+//#region src/utils/arkivTransactions.ts
+function opsToTxData({ creates, updates, deletes, extensions, ownershipChanges }) {
+	function formatAttributes(attribute) {
+		return [(0, viem.toHex)(attribute.key), (0, viem.toHex)(attribute.value)];
+	}
+	const payload = [
+		(creates ?? []).map((item) => [
+			(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) => [
+			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) => [item.entityKey, (0, viem.toHex)(item.expiresIn / require_consts.BLOCK_TIME)]),
+		(ownershipChanges ?? []).map((item) => [item.entityKey, item.newOwner])
+	];
+	console.debug("txData to send as RLP", 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;
+	console.debug("Sending transaction", {
+		account: client.account,
+		chain: client.chain,
+		to: require_consts.ARKIV_ADDRESS,
+		value: 0n,
+		data,
+		...txParams
+	});
+	const compressed = await compress((0, viem.toBytes)(data));
+	const txHash = await walletClient.sendTransaction({
+		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 });
+	console.debug("Tx receipt", receipt);
+	return receipt;
+}
+
+//#endregion
+//#region src/actions/wallet/changeOwnership.ts
+async function changeOwnership(client, data, txParams) {
+	console.debug("changeOwnership", data);
+	const receipt = await sendArkivTransaction(client, opsToTxData({ ownershipChanges: [data] }), txParams);
+	console.debug("Receipt from changeOwnership", receipt);
+	return {
+		txHash: receipt.transactionHash,
+		entityKey: data.entityKey
+	};
+}
+
+//#endregion
+//#region src/actions/wallet/createEntity.ts
+async function createEntity(client, data, txParams) {
+	console.debug("createEntity", data);
+	const receipt = await sendArkivTransaction(client, opsToTxData({ creates: [data] }), txParams);
+	console.debug("Receipt from createEntity", receipt);
+	return {
+		txHash: receipt.transactionHash,
+		entityKey: receipt.logs[0].topics[1]
+	};
+}
+
+//#endregion
+//#region src/actions/wallet/deleteEntity.ts
+async function deleteEntity(client, data, txParams) {
+	console.debug("deleteEntity", data);
+	const receipt = await sendArkivTransaction(client, opsToTxData({ deletes: [data] }), txParams);
+	console.debug("Receipt from deleteEntity", receipt);
+	return {
+		txHash: receipt.transactionHash,
+		entityKey: data.entityKey
+	};
+}
+
+//#endregion
+//#region src/actions/wallet/extendEntity.ts
+async function extendEntity(client, data, txParams) {
+	console.debug("extendEntity", data);
+	const receipt = await sendArkivTransaction(client, opsToTxData({ extensions: [data] }), txParams);
+	console.debug("Receipt from extendEntity", receipt);
+	return {
+		txHash: receipt.transactionHash,
+		entityKey: receipt.logs[0].topics[1]
+	};
+}
+
+//#endregion
+//#region src/actions/wallet/mutateEntities.ts
+function parseReceipt(receipt, params) {
+	const createdEntities = [];
+	const updatedEntities = [];
+	const deletedEntities = [];
+	const extendedEntities = [];
+	const totalCreates = params.creates?.length ?? 0;
+	const totalUpdates = params.updates?.length ?? 0;
+	const totalDeletes = params.deletes?.length ?? 0;
+	for (let i = 0; i < receipt.logs.length; i++) {
+		const log = receipt.logs[i];
+		if (i % 2 === 1) continue;
+		const index = i / 2;
+		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 extendedEntities.push(log.topics[1]);
+	}
+	return {
+		createdEntities,
+		updatedEntities,
+		deletedEntities,
+		extendedEntities
+	};
+}
+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 ?? []
+	}), txParams);
+	console.debug("Receipt from mutateEntities", receipt);
+	const { createdEntities, updatedEntities, deletedEntities, extendedEntities } = parseReceipt(receipt, data);
+	return {
+		txHash: receipt.transactionHash,
+		createdEntities,
+		updatedEntities,
+		deletedEntities,
+		extendedEntities
+	};
+}
+
+//#endregion
+//#region src/actions/wallet/updateEntity.ts
+async function updateEntity(client, data, txParams) {
+	console.debug("updateEntity", data);
+	const receipt = await sendArkivTransaction(client, opsToTxData({ updates: [data] }), txParams);
+	console.debug("Receipt from updateEntity", receipt);
+	return {
+		txHash: receipt.transactionHash,
+		entityKey: receipt.logs[0].topics[1]
+	};
+}
+
+//#endregion
+//#region src/clients/decorators/arkivWallet.ts
+function walletArkivActions(client) {
+	return {
+		createEntity: (data, txParams) => createEntity(client, data, txParams),
+		updateEntity: (data, txParams) => updateEntity(client, data, txParams),
+		deleteEntity: (data, txParams) => deleteEntity(client, data, txParams),
+		extendEntity: (data, txParams) => extendEntity(client, data, txParams),
+		changeOwnership: (data, txParams) => changeOwnership(client, data, txParams),
+		mutateEntities: (data, txParams) => mutateEntities(client, data, txParams)
+	};
+}
+
+//#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).
+*
+* - Docs: https://docs.golemdb.io/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.golemdb.io/json-rpc/), and [Kaolin JSON-RPC API](https://kaolin.holesky.golemdb.io/rpc) methods such as retrieving block numbers, transactions, reading from smart contracts, etc through [Public Actions](/docs/actions/public/introduction).
+*
+* @param config - {@link PublicClientConfig}
+* @returns A Arkiv Public Client. {@link PublicArkivClient}
+*
+* @example
+* import { createPublicClient, http } from 'arkiv'
+* import { kaolin } from 'arkiv/chains'
+*
+* const client = createPublicClient({
+*   chain: kaolin,
+*   transport: http(),
+* })
+*/
+function createWalletClient(parameters) {
+	const { key = "wallet", name = "Wallet Client" } = parameters;
+	return (0, viem.createClient)({
+		...parameters,
+		key,
+		name
+	}).extend(viem.walletActions).extend(viem.publicActions).extend(walletArkivActions).extend(publicArkivActions);
+}
+
+//#endregion
+exports.createPublicClient = createPublicClient;
+exports.createWalletClient = createWalletClient;
+Object.defineProperty(exports, 'http', {
+  enumerable: true,
+  get: function () {
+    return viem.http;
+  }
+});
+Object.defineProperty(exports, 'toBytes', {
+  enumerable: true,
+  get: function () {
+    return viem.toBytes;
+  }
+});
+Object.defineProperty(exports, 'toHex', {
+  enumerable: true,
+  get: function () {
+    return viem.toHex;
+  }
+});
+Object.defineProperty(exports, 'toRlp', {
+  enumerable: true,
+  get: function () {
+    return viem.toRlp;
+  }
+});
+Object.defineProperty(exports, 'webSocket', {
+  enumerable: true,
+  get: function () {
+    return viem.webSocket;
+  }
+});