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

package/src/query/queryBuilder.ts

@@ -1,209 +0,0 @@
-import type { Hex } from "viem"
-import type { ArkivClient } from "../clients/baseClient"
-import { entityFromRpcResult } from "../utils/entities"
-import { processQuery } from "./engine"
-import type { Predicate } from "./predicate"
-import { QueryResult } from "./queryResult"
-
-/**
- * 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}
- */
-export class QueryBuilder {
-	private _client: ArkivClient
-	private _ownedBy: Hex | undefined
-	private _validAtBlock: bigint | undefined
-	private _withAnnotations: boolean | undefined
-	private _withMetadata: boolean | undefined
-	private _withPayload: boolean | undefined
-	private _limit: number | undefined
-	private _cursor: string | undefined
-	private _predicates: Predicate[]
-
-	constructor(client: ArkivClient) {
-		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: Hex) {
-		this._ownedBy = ownedBy
-		return this
-	}
-
-	/**
-	 * Sets the withAnnotations flag which will return the annotations for the entities if true
-	 * @param withAnnotations - The boolean value to set
-	 * @returns The QueryBuilder instance
-	 *
-	 * @example
-	 * const builder = new QueryBuilder(client)
-	 * builder.withAnnotations(true)
-	 */
-	withAnnotations(withAnnotations: boolean = true) {
-		this._withAnnotations = withAnnotations
-		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: boolean = 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: boolean = 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: number) {
-		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: string) {
-		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: bigint) {
-		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: Predicate[] | Predicate) {
-		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,
-			withAnnotations: this._withAnnotations,
-			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() {
-		const queryResult = await processQuery(this._client, {
-			predicates: this._predicates,
-			limit: this._limit,
-			cursor: this._cursor,
-			ownedBy: this._ownedBy,
-			validAtBlock: this._validAtBlock,
-			withAnnotations: false,
-			withMetadata: false,
-			withPayload: false,
-		})
-
-		return queryResult.data.length ?? 0
-	}
-}

package/src/query/queryResult.ts

@@ -1,61 +0,0 @@
-import type { Entity } from "../types/entity"
-import { NoCursorOrLimitError, NoMoreResultsError } from "./errors"
-import type { QueryBuilder } from "./queryBuilder"
-
-export class QueryResult {
-	entities: Entity[]
-	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,
-		cursor: string | undefined,
-		limit: number | undefined,
-		validAtBlock: bigint | undefined,
-	) {
-		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 === undefined || this._limit === undefined) {
-			throw new NoCursorOrLimitError()
-		}
-		if (this._endOfIteration) {
-			throw new NoMoreResultsError()
-		}
-		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
-
-		// TODO check current block height and if it is not too old
-		console.debug("Current block height for next page: ", this._validAtBlock)
-	}
-
-	hasNextPage() {
-		return !this._endOfIteration
-	}
-}

package/src/types/annotation.ts

@@ -1,4 +0,0 @@
-export type Annotation = {
-	key: string
-	value: string | number
-}

package/src/types/entity.ts

@@ -1,32 +0,0 @@
-import { bytesToString, type Hex } from "viem"
-import type { Annotation } from "./annotation"
-
-export class Entity {
-	key: Hex
-	owner: Hex
-	expiresAtBlock: bigint
-	payload: Uint8Array
-	annotations: Annotation[]
-
-	constructor(
-		key: Hex,
-		owner: Hex,
-		expiresAtBlock: bigint,
-		payload: Uint8Array,
-		annotations: Annotation[],
-	) {
-		this.key = key
-		this.owner = owner
-		this.expiresAtBlock = expiresAtBlock
-		this.payload = payload
-		this.annotations = annotations
-	}
-
-	toText(): string {
-		return bytesToString(this.payload)
-	}
-
-	toJson(): any {
-		return JSON.parse(bytesToString(this.payload))
-	}
-}

package/src/types/events.ts

@@ -1,34 +0,0 @@
-import type { Hex } from "viem"
-
-export type OnEntityCreatedEvent = {
-	entityKey: Hex
-	owner: Hex
-	expirationBlock: number
-	cost: bigint
-}
-
-export type OnEntityUpdatedEvent = {
-	entityKey: Hex
-	owner: Hex
-	oldExpirationBlock: number
-	newExpirationBlock: number
-	cost: bigint
-}
-
-export type OnEntityDeletedEvent = {
-	entityKey: Hex
-	owner: Hex
-}
-
-export type OnEntityExpiredEvent = {
-	entityKey: Hex
-	owner: Hex
-}
-
-export type OnEntityExpiresInExtendedEvent = {
-	entityKey: Hex
-	owner: Hex
-	oldExpirationBlock: number
-	newExpirationBlock: number
-	cost: bigint
-}

package/src/types/index.ts

@@ -1,3 +0,0 @@
-export type { Annotation } from "./annotation"
-export type { Entity } from "./entity"
-export type { TxParams } from "./txParams"

package/src/types/rpcSchema.ts

@@ -1,68 +0,0 @@
-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?: number
-	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"
-		Parameters?: [entityId: Hex]
-		ReturnType: string
-	},
-	{
-		Method: "arkiv_query"
-		Parameters?: [query: string, queryOptions?: RpcQueryOptions]
-		ReturnType: {
-			data: [RpcEntity]
-			blockNumber: bigint
-			cursor: string
-		}
-	},
-	{
-		Method: "golembase_getEntityMetaData"
-		Parameters?: [entityId: Hex]
-		ReturnType: {
-			expiresAtBlock: number
-			owner: Hex
-			numericAnnotations: [{ key: string; value: number }]
-			stringAnnotations: [{ key: string; value: string }]
-		}
-	},
-	{
-		Method: "arkiv_getBlockTiming"
-		Parameters?: []
-		ReturnType: {
-			current_block: bigint
-			current_block_time: number
-			duration: number
-		}
-	},
-	{
-		Method: "arkiv_getEntityCount"
-		Parameters?: []
-		ReturnType: number
-	},
-]
-
-export type PublicArkivRpcSchema = [...PublicRpcSchema, ...ArkivRpcSchema]

package/src/types/txParams.ts

@@ -1,15 +0,0 @@
-export type TxParams =
-	| {
-			gas?: bigint
-			nonce?: number
-			gasPrice?: bigint
-			maxFeePerGas?: never
-			maxPriorityFeePerGas?: never
-	  }
-	| {
-			gas?: bigint
-			nonce?: number
-			maxFeePerGas?: bigint
-			maxPriorityFeePerGas?: bigint
-			gasPrice?: never
-	  }

package/src/utils/arkivTransactions.ts

@@ -1,91 +0,0 @@
-import { type Hex, toHex, toRlp } from "viem"
-import type { CreateEntityParameters } from "../actions/wallet/createEntity"
-import type { DeleteEntityParameters } from "../actions/wallet/deleteEntity"
-import type { ExtendEntityParameters } from "../actions/wallet/extendEntity"
-import type { UpdateEntityParameters } from "../actions/wallet/updateEntity"
-import type { ArkivClient } from "../clients/baseClient"
-import type { WalletArkivClient } from "../clients/createWalletClient"
-import { ARKIV_ADDRESS, BLOCK_TIME } from "../consts"
-import type { TxParams } from "../types"
-
-export function opsToTxData({
-	creates,
-	updates,
-	deletes,
-	extensions,
-}: {
-	creates?: CreateEntityParameters[]
-	updates?: UpdateEntityParameters[]
-	deletes?: DeleteEntityParameters[]
-	extensions?: ExtendEntityParameters[]
-}) {
-	function formatAnnotation<T extends string | number | bigint | boolean>(annotation: {
-		key: string
-		value: T
-	}): [Hex, Hex] {
-		return [toHex(annotation.key), toHex(annotation.value)]
-	}
-
-	const payload = [
-		//creates
-		(creates ?? []).map((item) => [
-			toHex(item.expiresIn / BLOCK_TIME),
-			toHex(item.payload),
-			item.annotations
-				.filter((annotation) => typeof annotation.value === "string")
-				.map(formatAnnotation),
-			item.annotations
-				.filter((annotation) => typeof annotation.value === "number")
-				.map(formatAnnotation),
-		]),
-		//updates
-		(updates ?? []).map((item) => [
-			item.entityKey,
-			toHex(item.expiresIn / BLOCK_TIME),
-			toHex(item.payload),
-			item.annotations
-				.filter((annotation) => typeof annotation.value === "string")
-				.map(formatAnnotation),
-			item.annotations
-				.filter((annotation) => typeof annotation.value === "number")
-				.map(formatAnnotation),
-		]),
-		//deletes
-		(deletes ?? []).map((item) => item.entityKey),
-		//extends
-		(extensions ?? []).map((item) => [item.entityKey, toHex(item.expiresIn / BLOCK_TIME)]),
-	]
-
-	console.debug("txData to send as RLP", payload)
-
-	return toRlp(payload)
-}
-
-export async function sendArkivTransaction(client: ArkivClient, data: Hex, txParams?: TxParams) {
-	if (!client.account) throw new Error("Account required")
-	const walletClient = client as WalletArkivClient
-
-	console.debug("Sending transaction", {
-		account: client.account,
-		chain: client.chain,
-		to: ARKIV_ADDRESS,
-		value: 0n,
-		data,
-		...txParams,
-	})
-
-	const txHash = await walletClient.sendTransaction({
-		account: client.account,
-		chain: client.chain,
-		to: ARKIV_ADDRESS,
-		value: 0n,
-		data,
-		...txParams,
-	})
-
-	const receipt = await walletClient.waitForTransactionReceipt({ hash: txHash })
-
-	console.debug("Tx receipt", receipt)
-
-	return receipt
-}

package/src/utils/entities.ts

@@ -1,16 +0,0 @@
-import { toBytes } from "viem"
-import { Entity } from "../types/entity"
-import type { RpcEntity } from "../types/rpcSchema"
-
-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,
-		})),
-		...(rpcEntity.numericAnnotations ?? []).map(({ key, value }) => ({
-			key,
-			value: value,
-		})),
-	])
-}

package/src/utils/expirationTime.ts

@@ -1,13 +0,0 @@
-import { BLOCK_TIME } from "../consts"
-
-export const ExpirationTime = {
-	fromSeconds: (seconds: number) => seconds,
-	fromMinutes: (minutes: number) => minutes * 60,
-	fromHours: (hours: number) => hours * 60 * 60,
-	fromDays: (days: number) => days * 24 * 60 * 60,
-	fromWeeks: (weeks: number) => weeks * 7 * 24 * 60 * 60,
-	fromMonths: (months: number) => months * 30 * 24 * 60 * 60,
-	fromYears: (years: number) => years * 365 * 24 * 60 * 60,
-	fromBlocks: (blocks: number) => blocks * BLOCK_TIME,
-	fromDate: (date: Date) => Math.floor(date.getTime() / 1000) - Math.floor(Date.now() / 1000),
-}

package/src/utils/index.ts

@@ -1,3 +0,0 @@
-export * from "viem/utils"
-export * from "./expirationTime"
-export * from "./payload"

package/src/utils/payload.ts

@@ -1,9 +0,0 @@
-import { toBytes } from "viem"
-
-export function jsonToPayload(json: object): Uint8Array {
-	return toBytes(JSON.stringify(json))
-}
-
-export function stringToPayload(data: string): Uint8Array {
-	return toBytes(data)
-}