@arkiv-network/sdk 0.1.0 → 0.1.2-dev.0

package/dist/queryBuilder-okYHE7jd.cjs

@@ -0,0 +1,382 @@
+const require_index = require('./index.cjs');
+let viem = require("viem");
+
+//#region src/query/errors.ts
+var NoMoreResultsError = class extends Error {
+	constructor() {
+		super("No more results");
+	}
+};
+var NoCursorOrLimitError = class extends Error {
+	constructor() {
+		super("Cursor and limit must be defined to fetch next");
+	}
+};
+var OffsetCannotBeLessThanZeroError = class extends Error {
+	constructor() {
+		super("Offset cannot be less than 0");
+	}
+};
+var NoEntityFoundError = class extends Error {
+	constructor() {
+		super("No entity found");
+	}
+};
+
+//#endregion
+//#region src/types/entity.ts
+var Entity = class {
+	key;
+	owner;
+	expiresAtBlock;
+	payload;
+	attributes;
+	contentType;
+	constructor(key, contentType, owner, expiresAtBlock, payload, attributes) {
+		this.key = key;
+		this.owner = owner;
+		this.expiresAtBlock = expiresAtBlock;
+		this.payload = payload;
+		this.attributes = attributes;
+		this.contentType = contentType;
+	}
+	toText() {
+		return (0, viem.bytesToString)(this.payload);
+	}
+	toJson() {
+		return JSON.parse((0, viem.bytesToString)(this.payload));
+	}
+};
+
+//#endregion
+//#region src/utils/entities.ts
+async function entityFromRpcResult(rpcEntity) {
+	return new Entity(rpcEntity.key, rpcEntity.contentType, rpcEntity.owner, rpcEntity.expiresAt, (0, viem.toBytes)(rpcEntity.value), [...(rpcEntity.stringAttributes ?? []).map(({ key, value }) => ({
+		key,
+		value
+	})), ...(rpcEntity.numericAttributes ?? []).map(({ key, value }) => ({
+		key,
+		value: Number(value)
+	}))]);
+}
+
+//#endregion
+//#region src/query/engine.ts
+function processPredicates(predicates) {
+	const processValue = (value) => {
+		if (typeof value === "string") return `"${value}"`;
+		return value;
+	};
+	return predicates.map((predicate) => {
+		switch (predicate.type) {
+			case "eq": return `${predicate.key} = ${processValue(predicate.value)}`;
+			case "neq": return `${predicate.key} != ${processValue(predicate.value)}`;
+			case "gt": return `${predicate.key} > ${processValue(predicate.value)}`;
+			case "gte": return `${predicate.key} >= ${processValue(predicate.value)}`;
+			case "lt": return `${predicate.key} < ${processValue(predicate.value)}`;
+			case "lte": return `${predicate.key} <= ${processValue(predicate.value)}`;
+			case "not": return `!${predicate.key}`;
+			case "or": return `(${predicate.predicates.map((predicate$1) => processPredicates([predicate$1])).join(" || ")})`;
+			case "and": return `(${predicate.predicates.map((predicate$1) => processPredicates([predicate$1])).join(" && ")})`;
+			default: return "";
+		}
+	}).join(" && ");
+}
+async function processQuery(client, queryParams) {
+	const { predicates, limit, cursor, ownedBy, validAtBlock, withAttributes, withMetadata, withPayload } = queryParams;
+	console.debug(`Processing query with params: predicates: ${predicates}, cursor: ${cursor}, limit: ${limit}, ownedBy: ${ownedBy}, validAtBlock: ${validAtBlock}, withAttributes: ${withAttributes}, withMetadata: ${withMetadata}, withPayload: ${withPayload}`);
+	let query = processPredicates(predicates);
+	if (ownedBy) query += ` && $owner=${ownedBy}`;
+	query = query.trim();
+	if (query.startsWith("&& ")) query = query.slice(3);
+	const queryOptions = { includeData: {
+		key: true,
+		attributes: withAttributes ?? false,
+		payload: withPayload ?? false,
+		contentType: withMetadata ?? false,
+		expiration: withMetadata ?? false,
+		owner: withMetadata ?? false
+	} };
+	if (validAtBlock !== void 0) queryOptions.atBlock = Number(validAtBlock);
+	if (limit !== void 0) queryOptions.resultsPerPage = limit;
+	if (cursor !== void 0) queryOptions.cursor = cursor;
+	console.debug(`Built query to send: ${query}, queryOptions: ${JSON.stringify({
+		includeData: queryOptions.includeData,
+		atBlock: queryOptions.atBlock?.toString(),
+		resultsPerPage: queryOptions.resultsPerPage,
+		cursor: queryOptions.cursor
+	})}`);
+	const result = await client.request({
+		method: "arkiv_query",
+		params: [query, queryOptions]
+	});
+	console.debug("Raw result from query: ", result);
+	return result;
+}
+
+//#endregion
+//#region src/query/queryResult.ts
+var QueryResult = class {
+	entities;
+	_endOfIteration;
+	_cursor;
+	_limit;
+	_validAtBlock;
+	_queryBuilder;
+	get queryBuilder() {
+		return this._queryBuilder;
+	}
+	get cursor() {
+		return this._cursor;
+	}
+	constructor(entities, queryBuilder, cursor, limit, validAtBlock) {
+		this.entities = entities;
+		this._queryBuilder = queryBuilder;
+		this._endOfIteration = !limit || entities.length < limit;
+		this._cursor = cursor;
+		this._limit = limit;
+		this._validAtBlock = validAtBlock;
+	}
+	async next() {
+		if (this._cursor === void 0 || this._limit === void 0) throw new NoCursorOrLimitError();
+		if (this._endOfIteration) throw new NoMoreResultsError();
+		this._queryBuilder.cursor(this._cursor);
+		const result = await this._queryBuilder.fetch();
+		this.entities = result.entities;
+		this._queryBuilder = result.queryBuilder;
+		this._endOfIteration = !result.cursor || result.entities.length < this._limit;
+		this._cursor = result.cursor;
+		console.debug("Current block height for next page: ", this._validAtBlock);
+	}
+	hasNextPage() {
+		return !this._endOfIteration;
+	}
+};
+
+//#endregion
+//#region src/query/queryBuilder.ts
+/**
+* QueryBuilder is a helper class to build queries to the Arkiv DBChains.
+* It can be used to fetch entities from the Arkiv DBChains. It follows the Builder pattern allowing chaining of methods.
+* @param client - The Arkiv client
+* @returns The QueryBuilder instance {@link QueryBuilder}
+*/
+var QueryBuilder = class {
+	_client;
+	_ownedBy;
+	_validAtBlock;
+	_withAttributes;
+	_withMetadata;
+	_withPayload;
+	_limit;
+	_cursor;
+	_predicates;
+	constructor(client) {
+		this._client = client;
+		this._predicates = [];
+	}
+	/**
+	* Sets the ownedBy filter
+	* @param ownedBy - The address of the owner
+	* @returns The QueryBuilder instance
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* builder.ownedBy("0x1234567890123456789012345678901234567890")
+	*/
+	ownedBy(ownedBy) {
+		this._ownedBy = ownedBy;
+		return this;
+	}
+	/**
+	* Sets the withAttributes flag which will return the attributes for the entities if true
+	* @param withAttributes - The boolean value to set
+	* @returns The QueryBuilder instance
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* builder.withAttributes(true)
+	*/
+	withAttributes(withAttributes = true) {
+		this._withAttributes = withAttributes;
+		return this;
+	}
+	/**
+	* Sets the withMetadata flag which will return the metadata (like owner, expiredAt, etc.) for the entities if true
+	* @param withMetadata - The boolean value to set
+	* @returns The QueryBuilder instance
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* builder.withMetadata(true)
+	*/
+	withMetadata(withMetadata = true) {
+		this._withMetadata = withMetadata;
+		return this;
+	}
+	/**
+	* Sets the withPayload flag which will return the payload for the entities if true
+	* @param withPayload - The boolean value to set
+	* @returns The QueryBuilder instance
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* builder.withPayload(true)
+	*/
+	withPayload(withPayload = true) {
+		this._withPayload = withPayload;
+		return this;
+	}
+	/**
+	* Sets the limit for the query
+	* @param limit - The number of entities to return
+	* @returns The QueryBuilder instance
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* builder.limit(10)
+	*/
+	limit(limit) {
+		this._limit = limit;
+		return this;
+	}
+	/**
+	* Sets the cursor for the query - it is advances setting which rather shouldn't be used manually but it is provided from query result if limit is used (pagination).
+	* @param cursor - The cursor to set which tells to RPC Query server where to start or continue the query.
+	* @returns The QueryBuilder instance
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* builder.offset(10)
+	*/
+	cursor(cursor) {
+		this._cursor = cursor;
+		return this;
+	}
+	/**
+	* Sets the validAtBlock for the query which tells at which block height the state we are intested.
+	* If not set, the latest block is  used.
+	* @param validAtBlock - The block number to set
+	* @returns The QueryBuilder instance
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* builder.validAtBlock(10000)
+	*/
+	validAtBlock(validAtBlock) {
+		this._validAtBlock = validAtBlock;
+		return this;
+	}
+	/**
+	* Sets the predicates for the query limiting the results. It can be a single predicate or an array of predicates combined with 'and'.
+	* Predicates can be nested using 'or' and 'and' predicates.
+	* @param predicates - The predicates to set
+	* @returns The QueryBuilder instance
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* builder.where(eq("name", "John"))
+	* builder.where([eq("name", "John"), eq("age", 30)])
+	* builder.where([eq("name", "John"), or([eq("age", 30), eq("age", 31)])])
+	* builder.where([eq("name", "John"), and([eq("age", 30), eq("age", 31)])])
+	* builder.where([eq("name", "John"), or([eq("age", 30), and([eq("age", 31), eq("age", 32)])])])
+	* builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), eq("age", 32)])])])
+	* builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), and([eq("age", 32), eq("age", 33)])])])])
+	*/
+	where(predicates) {
+		if (Array.isArray(predicates)) this._predicates.push(...predicates);
+		else this._predicates.push(predicates);
+		return this;
+	}
+	/**
+	* Fetches the entities from the query. Re
+	* It will return a QueryResult instance which can be used to fetch the next and previous pages.
+	* @returns The QueryResult instance {@link QueryResult}
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* const result = await builder.where(eq("name", "John")).fetch()
+	* // result = { entities: [Entity, Entity, Entity], next: async () => QueryResult, previous: async () => QueryResult }
+	*/
+	async fetch() {
+		const queryResult = await processQuery(this._client, {
+			predicates: this._predicates,
+			limit: this._limit,
+			cursor: this._cursor,
+			ownedBy: this._ownedBy,
+			validAtBlock: this._validAtBlock,
+			withAttributes: this._withAttributes,
+			withMetadata: this._withMetadata,
+			withPayload: this._withPayload
+		});
+		const entities = await Promise.all(queryResult.data.map((entity) => entityFromRpcResult(entity)));
+		this.cursor(queryResult.cursor);
+		this.validAtBlock(queryResult.blockNumber);
+		return new QueryResult(entities, this, this._cursor, this._limit, this._validAtBlock);
+	}
+	/**
+	* Counts the entities from the query.
+	* @returns The number of entities
+	*
+	* @example
+	* const builder = new QueryBuilder(client)
+	* const result = await builder.where(eq("name", "John")).count()
+	* // result = 10
+	*/
+	async count() {
+		return (await processQuery(this._client, {
+			predicates: this._predicates,
+			limit: this._limit,
+			cursor: this._cursor,
+			ownedBy: this._ownedBy,
+			validAtBlock: this._validAtBlock,
+			withAttributes: false,
+			withMetadata: false,
+			withPayload: false
+		})).data.length ?? 0;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'NoCursorOrLimitError', {
+  enumerable: true,
+  get: function () {
+    return NoCursorOrLimitError;
+  }
+});
+Object.defineProperty(exports, 'NoEntityFoundError', {
+  enumerable: true,
+  get: function () {
+    return NoEntityFoundError;
+  }
+});
+Object.defineProperty(exports, 'NoMoreResultsError', {
+  enumerable: true,
+  get: function () {
+    return NoMoreResultsError;
+  }
+});
+Object.defineProperty(exports, 'OffsetCannotBeLessThanZeroError', {
+  enumerable: true,
+  get: function () {
+    return OffsetCannotBeLessThanZeroError;
+  }
+});
+Object.defineProperty(exports, 'QueryBuilder', {
+  enumerable: true,
+  get: function () {
+    return QueryBuilder;
+  }
+});
+Object.defineProperty(exports, 'QueryResult', {
+  enumerable: true,
+  get: function () {
+    return QueryResult;
+  }
+});
+Object.defineProperty(exports, 'entityFromRpcResult', {
+  enumerable: true,
+  get: function () {
+    return entityFromRpcResult;
+  }
+});

package/dist/types/index.d.cts

@@ -0,0 +1,2 @@
+import { i as MimeType, n as TxParams, r as Attribute, t as Entity } from "../entity-Dgf1SSpi.cjs";
+export { Attribute, Entity, MimeType, TxParams };

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import { i as MimeType, n as TxParams, r as Attribute, t as Entity } from "../entity-CMRcjXBK.js";
+export { Attribute, Entity, MimeType, TxParams };

package/dist/utils/index.cjs

@@ -0,0 +1,37 @@
+const require_consts = require('../consts-BV9DVKgE.cjs');
+const require_index = require('../index.cjs');
+let viem = require("viem");
+
+//#region src/utils/expirationTime.ts
+const ExpirationTime = {
+	fromSeconds: (seconds) => seconds,
+	fromMinutes: (minutes) => minutes * 60,
+	fromHours: (hours) => hours * 60 * 60,
+	fromDays: (days) => days * 24 * 60 * 60,
+	fromWeeks: (weeks) => weeks * 7 * 24 * 60 * 60,
+	fromMonths: (months) => months * 30 * 24 * 60 * 60,
+	fromYears: (years) => years * 365 * 24 * 60 * 60,
+	fromBlocks: (blocks) => blocks * require_consts.BLOCK_TIME,
+	fromDate: (date) => Math.floor(date.getTime() / 1e3) - Math.floor(Date.now() / 1e3)
+};
+
+//#endregion
+//#region src/utils/payload.ts
+function jsonToPayload(json) {
+	return (0, viem.toBytes)(JSON.stringify(json));
+}
+function stringToPayload(data) {
+	return (0, viem.toBytes)(data);
+}
+
+//#endregion
+exports.ExpirationTime = ExpirationTime;
+exports.jsonToPayload = jsonToPayload;
+exports.stringToPayload = stringToPayload;
+var viem_utils = require("viem/utils");
+Object.keys(viem_utils).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return viem_utils[k]; }
+  });
+});

package/dist/utils/index.d.cts

@@ -0,0 +1,21 @@
+export * from "viem/utils";
+
+//#region src/utils/expirationTime.d.ts
+declare const ExpirationTime: {
+  fromSeconds: (seconds: number) => number;
+  fromMinutes: (minutes: number) => number;
+  fromHours: (hours: number) => number;
+  fromDays: (days: number) => number;
+  fromWeeks: (weeks: number) => number;
+  fromMonths: (months: number) => number;
+  fromYears: (years: number) => number;
+  fromBlocks: (blocks: number) => number;
+  fromDate: (date: Date) => number;
+};
+//#endregion
+//#region src/utils/payload.d.ts
+declare function jsonToPayload(json: object): Uint8Array;
+declare function stringToPayload(data: string): Uint8Array;
+//#endregion
+export { ExpirationTime, jsonToPayload, stringToPayload };
+//# sourceMappingURL=index.d.cts.map

package/dist/utils/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/utils/expirationTime.ts","../../src/utils/payload.ts"],"sourcesContent":[],"mappings":";;;cAEa;;;EAAA,SAAA,EAAA,CAAA,KAUZ,EAAA,MAAA,EAAA,GADkB,MAAI;;;;ECTP,SAAA,EAAA,CAAA,KAAa,EAAA,MAAA,EAAgB,GAAA,MAAA;EAI7B,UAAA,EAAA,CAAA,MAAe,EAAA,MAAA,EAAgB,GAAA,MAAA;mBDK5B;;;;iBCTH,aAAA,gBAA6B;iBAI7B,eAAA,gBAA+B"}

package/dist/utils/index.d.ts

@@ -0,0 +1,21 @@
+export * from "viem/utils";
+
+//#region src/utils/expirationTime.d.ts
+declare const ExpirationTime: {
+  fromSeconds: (seconds: number) => number;
+  fromMinutes: (minutes: number) => number;
+  fromHours: (hours: number) => number;
+  fromDays: (days: number) => number;
+  fromWeeks: (weeks: number) => number;
+  fromMonths: (months: number) => number;
+  fromYears: (years: number) => number;
+  fromBlocks: (blocks: number) => number;
+  fromDate: (date: Date) => number;
+};
+//#endregion
+//#region src/utils/payload.d.ts
+declare function jsonToPayload(json: object): Uint8Array;
+declare function stringToPayload(data: string): Uint8Array;
+//#endregion
+export { ExpirationTime, jsonToPayload, stringToPayload };
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/utils/expirationTime.ts","../../src/utils/payload.ts"],"sourcesContent":[],"mappings":";;;cAEa;;;EAAA,SAAA,EAAA,CAAA,KAUZ,EAAA,MAAA,EAAA,GADkB,MAAI;;;;ECTP,SAAA,EAAA,CAAA,KAAa,EAAA,MAAA,EAAA,GAAgB,MAAA;EAI7B,UAAA,EAAA,CAAA,MAAe,EAAA,MAAA,EAAA,GAAgB,MAAA;mBDK5B;;;;iBCTH,aAAA,gBAA6B;iBAI7B,eAAA,gBAA+B"}

package/dist/utils/index.js

@@ -0,0 +1,30 @@
+import { n as BLOCK_TIME } from "../consts-CHtLBwGd.js";
+import { toBytes } from "viem";
+
+export * from "viem/utils"
+
+//#region src/utils/expirationTime.ts
+const ExpirationTime = {
+	fromSeconds: (seconds) => seconds,
+	fromMinutes: (minutes) => minutes * 60,
+	fromHours: (hours) => hours * 60 * 60,
+	fromDays: (days) => days * 24 * 60 * 60,
+	fromWeeks: (weeks) => weeks * 7 * 24 * 60 * 60,
+	fromMonths: (months) => months * 30 * 24 * 60 * 60,
+	fromYears: (years) => years * 365 * 24 * 60 * 60,
+	fromBlocks: (blocks) => blocks * BLOCK_TIME,
+	fromDate: (date) => Math.floor(date.getTime() / 1e3) - Math.floor(Date.now() / 1e3)
+};
+
+//#endregion
+//#region src/utils/payload.ts
+function jsonToPayload(json) {
+	return toBytes(JSON.stringify(json));
+}
+function stringToPayload(data) {
+	return toBytes(data);
+}
+
+//#endregion
+export { ExpirationTime, jsonToPayload, stringToPayload };
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/utils/expirationTime.ts","../../src/utils/payload.ts"],"sourcesContent":["import { BLOCK_TIME } from \"../consts\"\n\nexport const ExpirationTime = {\n  fromSeconds: (seconds: number) => seconds,\n  fromMinutes: (minutes: number) => minutes * 60,\n  fromHours: (hours: number) => hours * 60 * 60,\n  fromDays: (days: number) => days * 24 * 60 * 60,\n  fromWeeks: (weeks: number) => weeks * 7 * 24 * 60 * 60,\n  fromMonths: (months: number) => months * 30 * 24 * 60 * 60,\n  fromYears: (years: number) => years * 365 * 24 * 60 * 60,\n  fromBlocks: (blocks: number) => blocks * BLOCK_TIME,\n  fromDate: (date: Date) => Math.floor(date.getTime() / 1000) - Math.floor(Date.now() / 1000),\n}\n","import { toBytes } from \"viem\"\n\nexport function jsonToPayload(json: object): Uint8Array {\n  return toBytes(JSON.stringify(json))\n}\n\nexport function stringToPayload(data: string): Uint8Array {\n  return toBytes(data)\n}\n"],"mappings":";;;;;;AAEA,MAAa,iBAAiB;CAC5B,cAAc,YAAoB;CAClC,cAAc,YAAoB,UAAU;CAC5C,YAAY,UAAkB,QAAQ,KAAK;CAC3C,WAAW,SAAiB,OAAO,KAAK,KAAK;CAC7C,YAAY,UAAkB,QAAQ,IAAI,KAAK,KAAK;CACpD,aAAa,WAAmB,SAAS,KAAK,KAAK,KAAK;CACxD,YAAY,UAAkB,QAAQ,MAAM,KAAK,KAAK;CACtD,aAAa,WAAmB,SAAS;CACzC,WAAW,SAAe,KAAK,MAAM,KAAK,SAAS,GAAG,IAAK,GAAG,KAAK,MAAM,KAAK,KAAK,GAAG,IAAK;CAC5F;;;;ACVD,SAAgB,cAAc,MAA0B;AACtD,QAAO,QAAQ,KAAK,UAAU,KAAK,CAAC;;AAGtC,SAAgB,gBAAgB,MAA0B;AACxD,QAAO,QAAQ,KAAK"}

package/package.json

@@ -1,43 +1,49 @@
 {
   "name": "@arkiv-network/sdk",
-  "version": "0.1.0",
+  "version": "0.1.2-dev.0",
   "description": "TypeScript-only client library for Arkiv blockchain interactions",
   "type": "module",
-  "main": "./dist/_cjs/index.js",
-  "module": "./dist/_esm/index.js",
-  "types": "./dist/_types/index.d.ts",
-  "typings": "./dist/_types/index.d.ts",
+  "target": "esnext",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
   "sideEffects": false,
   "exports": {
     ".": {
-      "source": "./src/index.ts",
-      "types": "./dist/_types/index.d.ts",
-      "import": "./dist/_esm/index.js",
-      "default": "./dist/_cjs/index.js"
-    },
-    "./chains": {
-      "source": "./src/chains/index.ts",
-      "types": "./dist/_types/chains/index.d.ts",
-      "import": "./dist/_esm/chains/index.js",
-      "default": "./dist/_cjs/chains/index.js"
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
     },
     "./accounts": {
-      "source": "./src/accounts/index.ts",
-      "types": "./dist/_types/accounts/index.d.ts",
-      "import": "./dist/_esm/accounts/index.js",
-      "default": "./dist/_cjs/accounts/index.js"
+      "bun": "./src/accounts/index.ts",
+      "import": "./dist/accounts/index.js",
+      "require": "./dist/accounts/index.cjs",
+      "default": "./dist/accounts/index.js"
     },
-    "./utils": {
-      "source": "./src/utils/index.ts",
-      "types": "./dist/_types/utils/index.d.ts",
-      "import": "./dist/_esm/utils/index.js",
-      "default": "./dist/_cjs/utils/index.js"
+    "./chains": {
+      "bun": "./src/chains/index.ts",
+      "import": "./dist/chains/index.js",
+      "require": "./dist/chains/index.cjs",
+      "default": "./dist/chains/index.js"
     },
     "./query": {
-      "source": "./src/query/index.ts",
-      "types": "./dist/_types/query/index.d.ts",
-      "import": "./dist/_esm/query/index.js",
-      "default": "./dist/_cjs/query/index.js"
+      "bun": "./src/query/index.ts",
+      "import": "./dist/query/index.js",
+      "require": "./dist/query/index.cjs",
+      "default": "./dist/query/index.js"
+    },
+    "./types": {
+      "bun": "./src/types/index.ts",
+      "import": "./dist/types/index.js",
+      "require": "./dist/types/index.cjs",
+      "default": "./dist/types/index.js"
+    },
+    "./utils": {
+      "bun": "./src/utils/index.ts",
+      "import": "./dist/utils/index.js",
+      "require": "./dist/utils/index.cjs",
+      "default": "./dist/utils/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -58,23 +64,15 @@
     }
   },
   "files": [
-    "dist/**/*.js",
-    "dist/**/*.js.map",
-    "dist/**/*.d.ts",
-    "dist/**/*.d.ts.map",
-    "src/**/*.ts",
-    "!src/**/*.test.ts",
-    "!src/**/*.spec.ts"
+    "dist",
+    "src"
   ],
   "scripts": {
-    "build": "rimraf dist && bun run build:cjs && bun run build:esm && bun run build:types",
-    "build:cjs": "tsc --project tsconfig.cjs.json",
-    "build:esm": "tsc --project tsconfig.esm.json",
-    "build:types": "tsc --project tsconfig.types.json",
-    "postbuild": "rimraf *.tsbuildinfo",
+    "build": "tsdown",
     "type-check": "tsc --noEmit",
     "lint": "biome check src/",
     "lint:fix": "biome check --write src/",
+    "test:unit": "bun test src/**/*",
     "package": "rimraf arkiv-network-sdk-*.tgz && bun run build && bun pm pack --no-cache",
     "package:test": "bun run package && mv arkiv-network-sdk-*.tgz arkiv-network-sdk-latest.tgz",
     "prepublishOnly": "bun run build && bun run package && mv arkiv-network-sdk-*.tgz arkiv-network-sdk-latest.tgz",
@@ -86,7 +84,8 @@
   "devDependencies": {
     "@biomejs/biome": "2.2.4",
     "@types/bun": "latest",
-    "rimraf": "^6.0.1"
+    "rimraf": "^6.0.1",
+    "tsdown": "^0.16.0"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
@@ -113,8 +112,7 @@
     "url": "https://github.com/Arkiv-Network/arkiv-sdk-js.git"
   },
   "dependencies": {
-    "@bokuweb/zstd-wasm": "^0.0.27",
-    "@oneidentity/zstd-js": "^1.0.3",
+    "brotli-wasm": "^3.0.1",
     "viem": "^2.38.2"
   }
 }

package/src/clients/createPublicClient.test.ts

@@ -0,0 +1,22 @@
+import { expect, test, vi } from "bun:test"
+import { createTransport, type EIP1193RequestFn } from "viem"
+import { createPublicClient } from "./createPublicClient"
+
+const mockTransport = () =>
+  createTransport({
+    key: "mock",
+    name: "Mock Transport",
+    request: vi.fn(() => null) as unknown as EIP1193RequestFn,
+    type: "mock",
+  })
+
+test("creates", () => {
+  const { uid, ...client } = createPublicClient({
+    transport: mockTransport,
+  })
+
+  expect(uid).toBeDefined()
+  expect(client.getEntity).toBeDefined()
+  expect(typeof client.getEntity).toBe("function")
+  expect(client.createEntity).not.toBeDefined()
+})