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

package/src/query/queryResult.test.ts

@@ -0,0 +1,270 @@
+import { beforeEach, describe, expect, jest, test } from "bun:test"
+import { Entity } from "../types/entity"
+import { NoCursorOrLimitError, NoMoreResultsError } from "./errors"
+import type { QueryBuilder } from "./queryBuilder"
+import { QueryResult } from "./queryResult"
+
+describe("QueryResult", () => {
+  let mockQueryBuilder: QueryBuilder
+  let mockEntities: Entity[]
+
+  beforeEach(() => {
+    // Create mock entities
+    mockEntities = [
+      new Entity("0x1" as const, "0xowner1" as const, 1000n, new Uint8Array([1]), []),
+      new Entity("0x2" as const, "0xowner2" as const, 2000n, new Uint8Array([2]), []),
+      new Entity("0x3" as const, "0xowner3" as const, 3000n, new Uint8Array([3]), []),
+    ]
+
+    // Create mock query builder
+    mockQueryBuilder = {
+      cursor: jest.fn().mockReturnThis(),
+      fetch: jest.fn(),
+    } as unknown as QueryBuilder
+  })
+
+  describe("constructor", () => {
+    test("creates QueryResult with entities and query builder", () => {
+      const result = new QueryResult(
+        mockEntities,
+        mockQueryBuilder,
+        undefined,
+        undefined,
+        undefined,
+      )
+
+      expect(result.entities).toEqual(mockEntities)
+      expect(result.entities).toHaveLength(3)
+    })
+
+    test("creates QueryResult with limit and cursor", () => {
+      const result = new QueryResult(mockEntities, mockQueryBuilder, "0xABC123", 10, undefined)
+
+      expect(result.entities).toEqual(mockEntities)
+    })
+
+    test("creates QueryResult with undefined limit and cursor", () => {
+      const result = new QueryResult(
+        mockEntities,
+        mockQueryBuilder,
+        undefined,
+        undefined,
+        undefined,
+      )
+
+      expect(result.entities).toEqual(mockEntities)
+    })
+
+    test("creates QueryResult with empty entities array", () => {
+      const result = new QueryResult([], mockQueryBuilder, "0xABC123", 10, undefined)
+
+      expect(result.entities).toEqual([])
+      expect(result.entities).toHaveLength(0)
+    })
+  })
+
+  describe("next()", () => {
+    test("throws NoCursorOrLimitError when cursor is undefined", async () => {
+      const result = new QueryResult(mockEntities, mockQueryBuilder, undefined, 10, undefined)
+
+      await expect(result.next()).rejects.toThrow(NoCursorOrLimitError)
+      await expect(result.next()).rejects.toThrow("Cursor and limit must be defined to fetch next")
+    })
+
+    test("throws NoCursorOrLimitError when limit is undefined", async () => {
+      const result = new QueryResult(
+        mockEntities,
+        mockQueryBuilder,
+        "0xABC123",
+        undefined,
+        undefined,
+      )
+
+      await expect(result.next()).rejects.toThrow(NoCursorOrLimitError)
+      await expect(result.next()).rejects.toThrow("Cursor and limit must be defined to fetch next")
+    })
+
+    test("throws NoCursorOrLimitError when both cursor and limit are undefined", async () => {
+      const result = new QueryResult(
+        mockEntities,
+        mockQueryBuilder,
+        undefined,
+        undefined,
+        undefined,
+      )
+
+      await expect(result.next()).rejects.toThrow(NoCursorOrLimitError)
+    })
+
+    test("throws NoMoreResultsError when limit > entities.length", async () => {
+      // limit is 4 but we have 3 entities, so limit > entities.length triggers error
+      const result = new QueryResult(mockEntities, mockQueryBuilder, "0xABC123", 4, 123n)
+
+      await expect(result.next()).rejects.toThrow(NoMoreResultsError)
+    })
+
+    test("fetches next page when limit equals entities length", async () => {
+      const newEntities = [
+        new Entity("0x4" as const, "0xowner4" as const, 4000n, new Uint8Array([4]), []),
+        new Entity("0x5" as const, "0xowner5" as const, 5000n, new Uint8Array([5]), []),
+        new Entity("0x6" as const, "0xowner6" as const, 6000n, new Uint8Array([6]), []),
+      ]
+
+      const mockFetch = jest.fn().mockResolvedValue({
+        entities: newEntities,
+      })
+
+      mockQueryBuilder.fetch = mockFetch
+      mockQueryBuilder.cursor = jest.fn().mockReturnValue(mockQueryBuilder)
+
+      // limit is 3 and we have 3 entities, so there might be more
+      const result = new QueryResult(mockEntities, mockQueryBuilder, "0xABC123", 3, undefined)
+
+      await result.next()
+
+      expect(mockQueryBuilder.cursor).toHaveBeenCalledWith("0xABC123")
+      expect(mockFetch).toHaveBeenCalled()
+      expect(result.entities).toEqual(newEntities)
+    })
+
+    test("updates offset correctly for multiple next calls", async () => {
+      const initialEntities = [
+        new Entity("0x1" as const, "0xowner1" as const, 1000n, new Uint8Array([1]), []),
+        new Entity("0x2" as const, "0xowner2" as const, 2000n, new Uint8Array([2]), []),
+        new Entity("0x3" as const, "0xowner3" as const, 3000n, new Uint8Array([3]), []),
+      ]
+
+      const newEntities1 = [
+        new Entity("0x4" as const, "0xowner4" as const, 4000n, new Uint8Array([4]), []),
+        new Entity("0x5" as const, "0xowner5" as const, 5000n, new Uint8Array([5]), []),
+        new Entity("0x6" as const, "0xowner6" as const, 6000n, new Uint8Array([6]), []),
+      ]
+
+      const newEntities2 = [
+        new Entity("0x7" as const, "0xowner7" as const, 7000n, new Uint8Array([7]), []),
+        new Entity("0x8" as const, "0xowner8" as const, 8000n, new Uint8Array([8]), []),
+        new Entity("0x9" as const, "0xowner9" as const, 9000n, new Uint8Array([9]), []),
+      ]
+
+      const mockCursor = jest.fn().mockReturnValue(mockQueryBuilder)
+      const mockFetch = jest
+        .fn()
+        .mockResolvedValueOnce({
+          entities: newEntities1,
+          queryBuilder: mockQueryBuilder,
+          cursor: "0xABC123",
+        })
+        .mockResolvedValueOnce({
+          entities: newEntities2,
+          queryBuilder: mockQueryBuilder,
+          cursor: "0xABC123",
+        })
+
+      mockQueryBuilder.cursor = mockCursor
+      mockQueryBuilder.fetch = mockFetch
+
+      // limit = 3, entities.length = 3, so 3 < 3 is false (won't throw)
+      const result = new QueryResult(initialEntities, mockQueryBuilder, "0xABC123", 3, undefined)
+
+      // First next call - offset should be 0 + 3 = 3
+      await result.next()
+      expect(mockCursor).toHaveBeenCalledWith("0xABC123")
+      expect(result.entities).toEqual(newEntities1)
+
+      // Second next call - offset should be 3 + 3 = 6
+      await result.next()
+      expect(mockCursor).toHaveBeenCalledWith("0xABC123")
+      expect(result.entities).toEqual(newEntities2)
+    })
+
+    test("fetches next page when limit is greater than entities length", async () => {
+      // limit is 5 but only 3 entities (5 > 3) so there is no more results
+      // so NoMoreResultsError is thrown
+      const result = new QueryResult(mockEntities, mockQueryBuilder, "0xABC123", 5, undefined)
+
+      await expect(result.next()).rejects.toThrow(NoMoreResultsError)
+    })
+  })
+
+  describe("pagination flow", () => {
+    test("simulates complete pagination: next -> next -> previous -> previous", async () => {
+      const page1 = [
+        new Entity("0x1" as const, "0xowner1" as const, 1000n, new Uint8Array([1]), []),
+      ]
+      const page2 = [
+        new Entity("0x2" as const, "0xowner2" as const, 2000n, new Uint8Array([2]), []),
+      ]
+      const page3 = [
+        new Entity("0x3" as const, "0xowner3" as const, 3000n, new Uint8Array([3]), []),
+      ]
+
+      const mockCursor = jest.fn().mockReturnValue(mockQueryBuilder)
+      const mockFetch = jest
+        .fn()
+        .mockResolvedValueOnce({
+          entities: page2,
+          queryBuilder: mockQueryBuilder,
+          cursor: "0xABC123",
+        }) // first next
+        .mockResolvedValueOnce({
+          entities: page3,
+          queryBuilder: mockQueryBuilder,
+          cursor: "0xABC123",
+        }) // second next
+        .mockResolvedValueOnce({
+          entities: page2,
+          queryBuilder: mockQueryBuilder,
+          cursor: "0xABC123",
+        }) // first previous
+        .mockResolvedValueOnce({
+          entities: page1,
+          queryBuilder: mockQueryBuilder,
+          cursor: "0xABC123",
+        }) // second previous
+
+      mockQueryBuilder.cursor = mockCursor
+      mockQueryBuilder.fetch = mockFetch
+
+      const result = new QueryResult(page1, mockQueryBuilder, "0xABC123", 1, undefined)
+
+      // Start at page 1 (offset 0)
+      expect(result.entities).toEqual(page1)
+
+      // Next to page 2 (offset 1)
+      await result.next()
+      expect(mockCursor).toHaveBeenCalledWith("0xABC123")
+      expect(result.entities).toEqual(page2)
+
+      // Next to page 3 (offset 2)
+      await result.next()
+      expect(mockCursor).toHaveBeenCalledWith("0xABC123")
+      expect(result.entities).toEqual(page3)
+    })
+
+    test("There is another page to fetch when limit < entities.length", async () => {
+      // limit is 2 but 3 entities, so 2 < 3 there is another page to fetch
+      const mockCursor = jest.fn().mockReturnValue(mockQueryBuilder)
+      const mockFetch = jest
+        .fn()
+        .mockResolvedValueOnce({
+          entities: mockEntities,
+          queryBuilder: mockQueryBuilder,
+          cursor: "0xABC123",
+        })
+        .mockResolvedValueOnce({
+          entities: mockEntities,
+          queryBuilder: mockQueryBuilder,
+          cursor: "0xABC123",
+        })
+
+      mockQueryBuilder.cursor = mockCursor
+      mockQueryBuilder.fetch = mockFetch
+
+      const result = new QueryResult(mockEntities, mockQueryBuilder, "0xABC123", 2, undefined)
+
+      await result.next()
+      expect(mockCursor).toHaveBeenCalledWith("0xABC123")
+      expect(result.entities).toEqual(mockEntities)
+    })
+  })
+})

package/src/utils/compression.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "bun:test"
+import { compress, decompress } from "./compression"
+
+describe("compression", () => {
+  it("should compress data", async () => {
+    const originalData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    const compressed = await compress(originalData)
+
+    expect(compressed).toBeInstanceOf(Uint8Array)
+    expect(compressed.length).toBeGreaterThan(0)
+    // Compressed data should be different from original
+    expect(compressed).not.toEqual(originalData)
+  })
+
+  it("should compress data with large payload into smaller size", async () => {
+    const originalData = new Uint8Array(1000).fill(1)
+    const compressed = await compress(originalData)
+
+    expect(compressed).toBeInstanceOf(Uint8Array)
+    expect(compressed.length).toBeGreaterThan(0)
+    expect(compressed.length).toBeLessThan(originalData.length)
+  })
+
+  it("should decompress data", async () => {
+    const originalData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    const compressed = await compress(originalData)
+    const decompressed = await decompress(compressed)
+
+    expect(decompressed).toBeInstanceOf(Uint8Array)
+    expect(decompressed).toEqual(originalData)
+  })
+})

package/src/utils/compression.ts

@@ -1,21 +1,48 @@
-import { init, compress as zstdCompress, decompress as zstdDecompress } from "@bokuweb/zstd-wasm"
+// src/utils/compression.ts
 
-let initialized = false
-export async function compress(data: Uint8Array): Promise<Uint8Array> {
-  if (!initialized) {
-    await init()
-    initialized = true
+import type { BrotliWasmType } from "brotli-wasm"
+import brotliPromise from "brotli-wasm"
+
+let brotli: BrotliWasmType | null = null
+
+async function getBrotli(): Promise<BrotliWasmType | null> {
+  if (brotli) return brotli
+
+  if (!brotliPromise) {
+    console.debug("Importing brotli-wasm")
+    try {
+      console.debug("Importing brotli-wasm as module")
+      brotli = await brotliPromise
+      console.debug("Imported brotli-wasm as module", brotli)
+    } catch (error) {
+      console.error("Error importing brotli-wasm", error)
+      console.debug("Importing brotli-wasm as require")
+      brotli = require("brotli-wasm")
+      console.debug("Imported brotli-wasm as require", brotli)
+    }
   }
+
+  brotli = await brotliPromise
+  return brotli
+}
+
+export async function compress(data: Uint8Array): Promise<Uint8Array> {
+  const brotliInstance = await getBrotli()
   console.debug(`Compressing data (size: ${data.length})`)
-  const compressed = await zstdCompress(data)
-  console.debug(`Compressed data (size: ${compressed.length})`)
-  return new Uint8Array(compressed)
+  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
 }
 
 export async function decompress(data: Uint8Array): Promise<Uint8Array> {
-  if (!initialized) {
-    await init()
-    initialized = true
+  const brotliInstance = await getBrotli()
+  if (!brotliInstance) {
+    console.warn("Brotli instance not found, not decompressing data")
+    return data
   }
-  return await zstdDecompress(data)
+  return brotliInstance.decompress(data)
 }

package/dist/_cjs/accounts/index.d.ts

@@ -1,2 +0,0 @@
-export * from "viem/accounts";
-//# sourceMappingURL=index.d.ts.map

package/dist/_cjs/accounts/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/accounts/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/_cjs/accounts/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("viem/accounts"), exports);
-//# sourceMappingURL=index.js.map

package/dist/_cjs/accounts/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/accounts/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gDAA6B"}

package/dist/_cjs/actions/public/buildQuery.d.ts

@@ -1,4 +0,0 @@
-import type { ArkivClient } from "../../clients/baseClient";
-import { QueryBuilder } from "../../query/queryBuilder";
-export declare function buildQuery(client: ArkivClient): Promise<QueryBuilder>;
-//# sourceMappingURL=buildQuery.d.ts.map

package/dist/_cjs/actions/public/buildQuery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildQuery.d.ts","sourceRoot":"","sources":["../../../../src/actions/public/buildQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAEvD,wBAAsB,UAAU,CAAC,MAAM,EAAE,WAAW,yBAEnD"}

package/dist/_cjs/actions/public/buildQuery.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildQuery = buildQuery;
-const queryBuilder_1 = require("../../query/queryBuilder");
-async function buildQuery(client) {
-    return new queryBuilder_1.QueryBuilder(client);
-}
-//# sourceMappingURL=buildQuery.js.map

package/dist/_cjs/actions/public/buildQuery.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildQuery.js","sourceRoot":"","sources":["../../../../src/actions/public/buildQuery.ts"],"names":[],"mappings":";;AAGA,gCAEC;AAJD,2DAAuD;AAEhD,KAAK,UAAU,UAAU,CAAC,MAAmB;IAClD,OAAO,IAAI,2BAAY,CAAC,MAAM,CAAC,CAAA;AACjC,CAAC"}

package/dist/_cjs/actions/public/getBlockTiming.d.ts

@@ -1,12 +0,0 @@
-import type { ArkivClient } from "../../clients/baseClient";
-export type GetBlockTimingReturnType = {
-    currentBlock: bigint;
-    currentBlockTime: number;
-    blockDuration: number;
-};
-export declare function getBlockTiming(client: ArkivClient): Promise<{
-    currentBlock: bigint;
-    currentBlockTime: number;
-    blockDuration: number;
-}>;
-//# sourceMappingURL=getBlockTiming.d.ts.map

package/dist/_cjs/actions/public/getBlockTiming.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getBlockTiming.d.ts","sourceRoot":"","sources":["../../../../src/actions/public/getBlockTiming.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAE3D,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW;;;;GAWvD"}

package/dist/_cjs/actions/public/getBlockTiming.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBlockTiming = getBlockTiming;
-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,
-    };
-}
-//# sourceMappingURL=getBlockTiming.js.map

package/dist/_cjs/actions/public/getBlockTiming.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getBlockTiming.js","sourceRoot":"","sources":["../../../../src/actions/public/getBlockTiming.ts"],"names":[],"mappings":";;AAQA,wCAWC;AAXM,KAAK,UAAU,cAAc,CAAC,MAAmB;IACtD,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QACvC,MAAM,EAAE,sBAAsB;QAC9B,MAAM,EAAE,EAAE;KACX,CAAC,CAAA;IACF,OAAO,CAAC,KAAK,CAAC,cAAc,EAAE,WAAW,CAAC,CAAA;IAC1C,OAAO;QACL,YAAY,EAAE,WAAW,CAAC,aAAa;QACvC,gBAAgB,EAAE,WAAW,CAAC,kBAAkB;QAChD,aAAa,EAAE,WAAW,CAAC,QAAQ;KACpC,CAAA;AACH,CAAC"}

package/dist/_cjs/actions/public/getEntity.d.ts

@@ -1,4 +0,0 @@
-import type { Hex } from "viem";
-import type { ArkivClient } from "../../clients/baseClient";
-export declare function getEntity(client: ArkivClient, key: Hex): Promise<import("../..").Entity>;
-//# sourceMappingURL=getEntity.d.ts.map

package/dist/_cjs/actions/public/getEntity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEntity.d.ts","sourceRoot":"","sources":["../../../../src/actions/public/getEntity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAI3D,wBAAsB,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,GAAG,mCAY5D"}

package/dist/_cjs/actions/public/getEntity.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEntity = getEntity;
-const errors_1 = require("../../query/errors");
-const entities_1 = require("../../utils/entities");
-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 errors_1.NoEntityFoundError();
-    }
-    return (0, entities_1.entityFromRpcResult)(result.data[0]);
-}
-//# sourceMappingURL=getEntity.js.map

package/dist/_cjs/actions/public/getEntity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEntity.js","sourceRoot":"","sources":["../../../../src/actions/public/getEntity.ts"],"names":[],"mappings":";;AAKA,8BAYC;AAfD,+CAAuD;AACvD,mDAA0D;AAEnD,KAAK,UAAU,SAAS,CAAC,MAAmB,EAAE,GAAQ;IAC3D,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAClC,MAAM,EAAE,aAAa;QACrB,MAAM,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC;KAC1B,CAAC,CAAA;IACF,OAAO,CAAC,KAAK,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAA;IAEzC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACjB,MAAM,IAAI,2BAAkB,EAAE,CAAA;IAChC,CAAC;IAED,OAAO,IAAA,8BAAmB,EAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;AAC5C,CAAC"}

package/dist/_cjs/actions/public/getEntityCount.d.ts

@@ -1,3 +0,0 @@
-import type { ArkivClient } from "../../clients/baseClient";
-export declare function getEntityCount(client: ArkivClient): Promise<number>;
-//# sourceMappingURL=getEntityCount.d.ts.map

package/dist/_cjs/actions/public/getEntityCount.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEntityCount.d.ts","sourceRoot":"","sources":["../../../../src/actions/public/getEntityCount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAE3D,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW,mBAOvD"}

package/dist/_cjs/actions/public/getEntityCount.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEntityCount = getEntityCount;
-async function getEntityCount(client) {
-    const count = await client.request({
-        method: "arkiv_getEntityCount",
-        params: [],
-    });
-    return count;
-}
-//# sourceMappingURL=getEntityCount.js.map

package/dist/_cjs/actions/public/getEntityCount.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEntityCount.js","sourceRoot":"","sources":["../../../../src/actions/public/getEntityCount.ts"],"names":[],"mappings":";;AAEA,wCAOC;AAPM,KAAK,UAAU,cAAc,CAAC,MAAmB;IACtD,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QACjC,MAAM,EAAE,sBAAsB;QAC9B,MAAM,EAAE,EAAE;KACX,CAAC,CAAA;IAEF,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/_cjs/actions/public/query.d.ts

@@ -1,3 +0,0 @@
-import type { ArkivClient } from "../../clients/baseClient";
-export declare function query(client: ArkivClient, query: string): Promise<import("../..").Entity[]>;
-//# sourceMappingURL=query.d.ts.map

package/dist/_cjs/actions/public/query.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../src/actions/public/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAG3D,wBAAsB,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,qCAS7D"}

package/dist/_cjs/actions/public/query.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.query = query;
-const entities_1 = require("../../utils/entities");
-async function query(client, query) {
-    const result = await client.request({
-        method: "arkiv_query",
-        params: [query],
-    });
-    const entities = await Promise.all(result.data.map((entity) => (0, entities_1.entityFromRpcResult)(entity)));
-    return entities;
-}
-//# sourceMappingURL=query.js.map

package/dist/_cjs/actions/public/query.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.js","sourceRoot":"","sources":["../../../../src/actions/public/query.ts"],"names":[],"mappings":";;AAGA,sBASC;AAXD,mDAA0D;AAEnD,KAAK,UAAU,KAAK,CAAC,MAAmB,EAAE,KAAa;IAC5D,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAClC,MAAM,EAAE,aAAa;QACrB,MAAM,EAAE,CAAC,KAAK,CAAC;KAChB,CAAC,CAAA;IAEF,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAA,8BAAmB,EAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IAE5F,OAAO,QAAQ,CAAA;AACjB,CAAC"}

package/dist/_cjs/actions/public/subscribeEntityEvents.d.ts

@@ -1,96 +0,0 @@
-import type { ArkivClient } from "../../clients/baseClient";
-import type { OnEntityCreatedEvent, OnEntityDeletedEvent, OnEntityExpiredEvent, OnEntityExpiresInExtendedEvent, OnEntityUpdatedEvent } from "../../types/events";
-export declare const arkivABI: readonly [{
-    readonly name: "ArkivEntityCreated";
-    readonly type: "event";
-    readonly inputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "entityKey";
-        readonly indexed: true;
-    }, {
-        readonly type: "address";
-        readonly name: "ownerAddress";
-        readonly indexed: true;
-    }, {
-        readonly type: "uint256";
-        readonly name: "expirationBlock";
-    }, {
-        readonly type: "uint256";
-        readonly name: "cost";
-    }];
-}, {
-    readonly name: "ArkivEntityUpdated";
-    readonly type: "event";
-    readonly inputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "entityKey";
-        readonly indexed: true;
-    }, {
-        readonly type: "address";
-        readonly name: "ownerAddress";
-        readonly indexed: true;
-    }, {
-        readonly type: "uint256";
-        readonly name: "oldExpirationBlock";
-    }, {
-        readonly type: "uint256";
-        readonly name: "newExpirationBlock";
-    }, {
-        readonly type: "uint256";
-        readonly name: "cost";
-    }];
-}, {
-    readonly name: "ArkivEntityExpired";
-    readonly type: "event";
-    readonly inputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "entityKey";
-        readonly indexed: true;
-    }, {
-        readonly type: "address";
-        readonly name: "ownerAddress";
-        readonly indexed: true;
-    }];
-}, {
-    readonly name: "ArkivEntityDeleted";
-    readonly type: "event";
-    readonly inputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "entityKey";
-        readonly indexed: true;
-    }, {
-        readonly type: "address";
-        readonly name: "ownerAddress";
-        readonly indexed: true;
-    }];
-}, {
-    readonly name: "ArkivEntityBTLExtended";
-    readonly type: "event";
-    readonly inputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "entityKey";
-        readonly indexed: true;
-    }, {
-        readonly type: "address";
-        readonly name: "ownerAddress";
-        readonly indexed: true;
-    }, {
-        readonly type: "uint256";
-        readonly name: "oldExpirationBlock";
-    }, {
-        readonly type: "uint256";
-        readonly name: "newExpirationBlock";
-    }, {
-        readonly type: "uint256";
-        readonly name: "cost";
-    }];
-}];
-export declare function subscribeEntityEvents(client: ArkivClient, { onError, onEntityCreated, onEntityUpdated, onEntityDeleted, onEntityExpired, onEntityExpiresInExtended, }: {
-    onError: ((error: Error) => void) | undefined;
-    onEntityCreated?: ((event: OnEntityCreatedEvent) => void) | undefined;
-    onEntityUpdated?: ((event: OnEntityUpdatedEvent) => void) | undefined;
-    onEntityDeleted?: ((event: OnEntityDeletedEvent) => void) | undefined;
-    onEntityExpired?: ((event: OnEntityExpiredEvent) => void) | undefined;
-    onEntityExpiresInExtended?: ((event: OnEntityExpiresInExtendedEvent) => void) | undefined;
-}, pollingInterval?: number, fromBlock?: bigint): Promise<() => void>;
-//# sourceMappingURL=subscribeEntityEvents.d.ts.map

package/dist/_cjs/actions/public/subscribeEntityEvents.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"subscribeEntityEvents.d.ts","sourceRoot":"","sources":["../../../../src/actions/public/subscribeEntityEvents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAE3D,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,8BAA8B,EAC9B,oBAAoB,EACrB,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMnB,CAAA;AAEF,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,WAAW,EACnB,EACE,OAAO,EACP,eAAe,EACf,eAAe,EACf,eAAe,EACf,eAAe,EACf,yBAAyB,GAC1B,EAAE;IACD,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAC7C,eAAe,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IACrE,eAAe,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IACrE,eAAe,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IACrE,eAAe,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IACrE,yBAAyB,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAA8B,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;CAC1F,EACD,eAAe,CAAC,EAAE,MAAM,EACxB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,IAAI,CAAC,CAkErB"}