@arkiv-network/sdk 0.0.36-dev.0 → 0.0.36-dev.4

package/src/query/queryResult.ts

@@ -1,46 +1,57 @@
 import type { Entity } from "../types/entity"
-import { NoMoreResultsError, NoOffsetOrLimitError, OffsetCannotBeLessThanZeroError } from "./errors"
+import { NoCursorOrLimitError, NoMoreResultsError } from "./errors"
 import type { QueryBuilder } from "./queryBuilder"
 
 export class QueryResult {
 	entities: Entity[]
-	private limit: number | undefined
-	private offset: number | undefined
-	private queryBuilder: QueryBuilder
+	private _endOfIteration: boolean
+	private _cursor: string | undefined
+	private _limit: number | undefined
+	private _validAtBlock: bigint | undefined
+	private _queryBuilder: QueryBuilder
+
+	// Public getters for internal state
+	get queryBuilder(): QueryBuilder {
+		return this._queryBuilder
+	}
+
+	get cursor(): string | undefined {
+		return this._cursor
+	}
 
 	constructor(
 		entities: Entity[],
 		queryBuilder: QueryBuilder,
-		limit: number | undefined = undefined,
-		offset: number | undefined = undefined,
+		cursor: string | undefined,
+		limit: number | undefined,
+		validAtBlock: bigint | undefined,
 	) {
 		this.entities = entities
-		this.limit = limit
-		this.offset = offset
-		this.queryBuilder = queryBuilder
+		this._queryBuilder = queryBuilder
+		this._endOfIteration = !limit || entities.length < limit
+		this._cursor = cursor
+		this._limit = limit
+		this._validAtBlock = validAtBlock
 	}
 
 	async next() {
-		if (this.offset === undefined || this.limit === undefined) {
-			throw new NoOffsetOrLimitError()
+		if (this._cursor === undefined || this._limit === undefined) {
+			throw new NoCursorOrLimitError()
 		}
-		if (this.limit < this.entities.length) {
+		if (this._endOfIteration) {
 			throw new NoMoreResultsError()
 		}
-		this.offset += this.limit
-		const result = await this.queryBuilder.offset(this.offset).fetch()
+		this._queryBuilder.cursor(this._cursor)
+		const result = await this._queryBuilder.fetch()
 		this.entities = result.entities
-	}
+		// Update the query builder reference
+		this._queryBuilder = result.queryBuilder
+		// Check if we've reached the end (no more cursor or we got fewer entities than limit)
+		this._endOfIteration = !result.cursor || result.entities.length < this._limit
+		// Update the cursor
+		this._cursor = result.cursor
 
-	async previous() {
-		if (this.offset === undefined || this.limit === undefined) {
-			throw new NoOffsetOrLimitError()
-		}
-		if (this.offset - this.limit < 0) {
-			throw new OffsetCannotBeLessThanZeroError()
-		}
-		this.offset -= this.limit
-		const result = await this.queryBuilder.offset(this.offset).fetch()
-		this.entities = result.entities
+		// TODO check current block height and if it is not too old
+		console.debug("Current block height for next page: ", this._validAtBlock)
 	}
 }

package/src/types/entity.ts

@@ -4,14 +4,14 @@ import type { Annotation } from "./annotation"
 export class Entity {
 	key: Hex
 	owner: Hex
-	expiresAtBlock: number
+	expiresAtBlock: bigint
 	payload: Uint8Array
 	annotations: Annotation[]
 
 	constructor(
 		key: Hex,
 		owner: Hex,
-		expiresAtBlock: number,
+		expiresAtBlock: bigint,
 		payload: Uint8Array,
 		annotations: Annotation[],
 	) {

package/src/types/rpcSchema.ts

@@ -1,5 +1,29 @@
 import type { Hex, PublicRpcSchema } from "viem"
 
+export type RpcEntity = {
+	key: Hex
+	value: string
+	expiresAt: bigint
+	owner: Hex
+	stringAnnotations?: [{ key: string; value: string }]
+	numericAnnotations?: [{ key: string; value: number }]
+}
+
+export type RpcQueryOptions = {
+	atBlock?: bigint
+	includeData?: RpcIncludeData
+	resultsPerPage?: number
+	cursor?: string
+}
+
+export type RpcIncludeData = {
+	key: boolean
+	annotations: boolean
+	payload: boolean
+	expiration: boolean
+	owner: boolean
+}
+
 export type ArkivRpcSchema = [
 	{
 		Method: "golembase_getStorageValue"
@@ -7,9 +31,13 @@ export type ArkivRpcSchema = [
 		ReturnType: string
 	},
 	{
-		Method: "golembase_queryEntities"
-		Parameters?: [query: string]
-		ReturnType: [{ key: Hex; value: string }]
+		Method: "arkiv_query"
+		Parameters?: [query: string, queryOptions?: RpcQueryOptions]
+		ReturnType: {
+			data: [RpcEntity]
+			blockNumber: bigint
+			cursor: string
+		}
 	},
 	{
 		Method: "golembase_getEntityMetaData"
@@ -30,6 +58,11 @@ export type ArkivRpcSchema = [
 			duration: number
 		}
 	},
+	{
+		Method: "arkiv_getEntityCount"
+		Parameters?: []
+		ReturnType: number
+	},
 ]
 
 export type PublicArkivRpcSchema = [...PublicRpcSchema, ...ArkivRpcSchema]

package/src/utils/entities.ts

@@ -1,20 +1,14 @@
-import type { Hex } from "viem"
-import type { ArkivClient } from "../clients/baseClient"
+import { toBytes } from "viem"
 import { Entity } from "../types/entity"
+import type { RpcEntity } from "../types/rpcSchema"
 
-export async function entityFromRpcResult(client: ArkivClient, key: Hex, payload: string) {
-	const metadata = await client.request({
-		method: "golembase_getEntityMetaData",
-		params: [key],
-	})
-	console.debug("Metadata", metadata)
-
-	return new Entity(key, metadata.owner, metadata.expiresAtBlock, Uint8Array.fromBase64(payload), [
-		...(metadata.stringAnnotations ?? []).map(({ key, value }) => ({
+export async function entityFromRpcResult(rpcEntity: RpcEntity) {
+	return new Entity(rpcEntity.key, rpcEntity.owner, rpcEntity.expiresAt, toBytes(rpcEntity.value), [
+		...(rpcEntity.stringAnnotations ?? []).map(({ key, value }) => ({
 			key,
 			value,
 		})),
-		...(metadata.numericAnnotations ?? []).map(({ key, value }) => ({
+		...(rpcEntity.numericAnnotations ?? []).map(({ key, value }) => ({
 			key,
 			value: value,
 		})),