@arkiv-network/sdk 0.5.0-dev.3 → 0.5.0-dev.5

package/dist/index.d.ts

@@ -1,4 +1,398 @@
-import { $ as RpcIncludeData, A as CreateEntityParameters, C as MutateEntitiesReturnType, D as ExtendEntityReturnType, E as ExtendEntityParameters, J as QueryOptionsIncludeData, M as ChangeOwnershipParameters, N as ChangeOwnershipReturnType, O as DeleteEntityParameters, P as GetBlockTimingReturnType, Q as RpcEntity, S as MutateEntitiesParameters, T as UpdateEntityReturnType, X as ArkivClient, Y as QueryOptionsOrderBy, Z as ArkivRpcSchema, _ as OnEntityExpiredEvent, a as PublicArkivClient, b as OnEntityUpdatedEvent, et as RpcOrderByAttribute, g as OnEntityDeletedEvent, h as OnEntityCreatedEvent, i as WalletArkivActions, j as CreateEntityReturnType, k as DeleteEntityReturnType, m as TxParams, n as WalletArkivClient, nt as MimeType, o as createPublicClient, p as Entity, q as QueryOptions, r as createWalletClient, s as PublicArkivActions, t as chainFromName, tt as RpcQueryOptions, v as OnEntityExpiresInExtendedEvent, w as UpdateEntityParameters, x as Attribute, y as OnEntityOwnerChangedEvent } from "./index-B801JxcV.js";
-import { n as stringToPayload, t as jsonToPayload } from "./payload-BI2NXPDf.js";
+import { A as RpcIncludeData, C as CreateEntityReturnType, D as ArkivClient, E as GetBlockTimingReturnType, M as RpcQueryOptions, N as MimeType, O as ArkivRpcSchema, S as CreateEntityParameters, T as ChangeOwnershipReturnType, _ as UpdateEntityReturnType, a as Entity, b as DeleteEntityParameters, c as OnEntityDeletedEvent, d as OnEntityOwnerChangedEvent, f as OnEntityUpdatedEvent, g as UpdateEntityParameters, h as MutateEntitiesReturnType, i as QueryReturnType, j as RpcOrderByAttribute, k as RpcEntity, l as OnEntityExpiredEvent, m as MutateEntitiesParameters, n as QueryOptionsIncludeData, o as TxParams, p as Attribute, r as QueryOptionsOrderBy, s as OnEntityCreatedEvent, t as QueryOptions, u as OnEntityExpiresInExtendedEvent, v as ExtendEntityParameters, w as ChangeOwnershipParameters, x as DeleteEntityReturnType, y as ExtendEntityReturnType } from "./query-DybEplzd.js";
+import { n as QueryBuilder } from "./queryBuilder-XIln1aIM.js";
+import { n as stringToPayload, t as jsonToPayload } from "./payload-Da9gJMG5.js";
+import { Account, Address, Chain, Client, Hex, ParseAccount, Prettify, PublicActions, PublicClientConfig, RpcSchema, Transport, WalletActions, WalletClientConfig } from "viem";
 export * from "viem";
-export { ArkivClient, ArkivRpcSchema, Attribute, ChangeOwnershipParameters, ChangeOwnershipReturnType, CreateEntityParameters, CreateEntityReturnType, DeleteEntityParameters, DeleteEntityReturnType, Entity, ExtendEntityParameters, ExtendEntityReturnType, GetBlockTimingReturnType, MimeType, MutateEntitiesParameters, MutateEntitiesReturnType, OnEntityCreatedEvent, OnEntityDeletedEvent, OnEntityExpiredEvent, OnEntityExpiresInExtendedEvent, OnEntityOwnerChangedEvent, OnEntityUpdatedEvent, PublicArkivActions, PublicArkivClient, QueryOptions, QueryOptionsIncludeData, QueryOptionsOrderBy, RpcEntity, RpcIncludeData, RpcOrderByAttribute, RpcQueryOptions, TxParams, UpdateEntityParameters, UpdateEntityReturnType, WalletArkivActions, WalletArkivClient, chainFromName, createPublicClient, createWalletClient, jsonToPayload, stringToPayload };
+
+//#region src/clients/decorators/arkivPublic.d.ts
+type PublicArkivActions<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = Pick<PublicActions<transport, chain, account>, "getBalance" | "getBlock" | "getBlockNumber" | "getChainId" | "getLogs" | "getTransaction" | "getTransactionCount" | "getTransactionReceipt" | "waitForTransactionReceipt" | "watchEvent"> & {
+  /**
+   * Returns the entity with the given key.
+   *
+   * - Docs: https://docs.arkiv.network/ts-sdk/actions/public/getEntity
+   *
+   * @param key - The entity key (hex string)
+   * @returns The entity with the given key. {@link Entity}
+   *
+   * @example
+   * import { createPublicClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const entity = await client.getEntity("0x123")
+   * // {
+   * //   key: "0x123",
+   * //   value: "0x123",
+   * // }
+   */
+  getEntity: (key: Hex) => Promise<Entity>;
+  /**
+   * Returns a QueryBuilder instance for building and executing queries.
+   * The QueryBuilder object follows the Builder pattern, allowing you to chain methods to build a query and then execute it.
+   *
+   * - Docs: https://docs.arkiv.network/ts-sdk/actions/public/query
+   *
+   * @returns A QueryBuilder instance for building and executing queries. {@link QueryBuilder}
+   *
+   * @example
+   * import { createPublicClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const query = client.buildQuery()
+   * const entities = await query.where("key", "=", "value").ownedBy("0x123").fetch()
+   *
+   */
+  buildQuery: () => QueryBuilder;
+  /**
+   * Returns a QueryResult instance for fetching the results of a raw query.
+   * If no query options are provided, all payload is included, but no metadata (like owner, expiredAt, etc.) and attributes.
+   * @param query - The raw query string
+   * @param queryOptions - The optional query options - {@link QueryOptions}
+   * @returns A QueryReturnType instance - {@link QueryReturnType}
+   *
+   * @example
+   * import { createPublicClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const queryResult = client.query('key = value && $owner = 0x123')
+   * // queryResult = { entities: [{ key: "0x123", value: "0x123" }], cursor: undefined, blockNumber: undefined }
+   * const queryResultWithOptions = client.query('key = value && $owner = 0x123', {
+   *   includeData: {
+   *     attributes: false,
+   *     payload: true,
+   *     metadata: true,
+   *   },
+   *   orderBy: [{ name: "key", type: "string", desc: "asc" }],
+   *   resultsPerPage: 10,
+   *   cursor: undefined,
+   *   atBlock: undefined,
+   * })
+   * // queryResultWithOptions = { entities: [{ key: "0x123", value: "0x123" }], cursor: "...", blockNumber: 32223n }
+   */
+  query: (query: string, queryOptions?: QueryOptions) => Promise<QueryReturnType>;
+  /**
+   * Returns the number of entities in the DBChain.
+   * @returns The number of entities in the DBChain
+   *
+   * @example
+   * import { createPublicClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const entityCount = await client.getEntityCount()
+   * // entityCount = 0
+   */
+  getEntityCount: () => Promise<number>;
+  /**
+   * Returns the current block timing.
+   * @returns The current block timing. {@link GetBlockTimingReturnType}
+   *
+   * @example
+   * import { createPublicClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const blockTiming = await client.getBlockTiming()
+   * // {
+   * //   currentBlock: 10n, // block number
+   * //   currentBlockTime: 1234567890, // block timestamp
+   * //   blockDuration: 2, // in seconds
+   * // }
+   */
+  getBlockTiming: () => Promise<{
+    currentBlock: bigint;
+    currentBlockTime: number;
+    blockDuration: number;
+  }>;
+  /**
+   * Subscribes to entity events.
+   * Takes an object with event handlers: {onError, onEntityCreated, onEntityUpdated, onEntityDeleted, onEntityExpiresInExtended}
+   * @param pollingInterval - The polling interval in milliseconds
+   * @param fromBlock - The block number to start from
+   * @returns A function to unsubscribe from the events
+   *
+   * @example
+   * import { createPublicClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const unsubscribe = await client.subscribeEntityEvents({
+   *   onError: (error) => console.error("subscribeEntityEvents error", error),
+   * })
+   * unsubscribe() // unsubscribe from the events
+   */
+  subscribeEntityEvents: ({
+    onError,
+    onEntityCreated,
+    onEntityUpdated,
+    onEntityDeleted,
+    onEntityExpiresInExtended
+  }: {
+    onError?: (error: Error) => void;
+    onEntityCreated?: (event: OnEntityCreatedEvent) => void;
+    onEntityUpdated?: (event: OnEntityUpdatedEvent) => void;
+    onEntityDeleted?: (event: OnEntityDeletedEvent) => void;
+    onEntityExpired?: (event: OnEntityExpiredEvent) => void;
+    onEntityExpiresInExtended?: (event: OnEntityExpiresInExtendedEvent) => void;
+  }, pollingInterval?: number, fromBlock?: bigint) => Promise<() => void>;
+};
+//#endregion
+//#region src/clients/createPublicClient.d.ts
+type PublicArkivClient<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, accountOrAddress extends Account | undefined = undefined, rpcSchema extends RpcSchema | undefined = ArkivRpcSchema> = Prettify<Client<transport, chain, accountOrAddress, rpcSchema, PublicArkivActions<transport, chain>>>;
+/**
+ * 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.arkiv.network/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.arkiv.network/json-rpc/), and [Kaolin JSON-RPC API](https://kaolin.holesky.arkiv.network/rpc) methods such as retrieving block numbers, transactions, reading from smart contracts, etc through [Public Actions](/docs/actions/public/introduction).
+ *
+ * @param parameters - Configuration object for the public client (chain, transport, etc.)
+ * @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(),
+ * })
+ */
+declare function createPublicClient<transport extends Transport, chain extends Chain | undefined = undefined, accountOrAddress extends Account | Address | undefined = undefined, rpcSchema extends RpcSchema | undefined = ArkivRpcSchema>(parameters: PublicClientConfig<transport, chain, accountOrAddress, rpcSchema>): PublicArkivClient<transport, chain, ParseAccount<accountOrAddress>, rpcSchema>;
+//#endregion
+//#region src/clients/decorators/arkivWallet.d.ts
+type WalletArkivActions<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = Pick<PublicActions<transport, chain, account>, "waitForTransactionReceipt"> & Pick<WalletActions<chain, account>, "addChain" | "sendCalls" | "waitForCallsStatus" | "sendTransaction" | "sendRawTransaction" | "signMessage" | "signTransaction"> & {
+  /**
+   * Creates a new entity.
+   *
+   * - Docs: https://docs.arkiv.network/ts-sdk/actions/wallet/createEntity
+   * - JSON-RPC Methods: [`eth_sendRawTransaction`](https://docs.arkiv.network/dev/json-rpc-api/#mutateEntities)
+   *
+   * @param data - The entity creation parameters
+   * @param txParams - Optional transaction parameters
+   * @returns The created entity with transaction hash
+   *
+   * @example
+   * import { createPublicClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const { entityKey, txHash } = await client.createEntity({
+   *   payload: toBytes(JSON.stringify({ entity: { entityType: "testType", entityId: "testId" } })),
+   *   attributes: [{ key: "testKey", value: "testValue" }],
+   *   expiresIn: 1000,
+   * })
+   * console.log("entityKey", entityKey)
+   * console.log("txHash", txHash)
+   * // {
+   * //   entityKey: "0x123",
+   * //   txHash: "0x123",
+   * // }
+   */
+  createEntity: (data: CreateEntityParameters, txParams?: TxParams) => Promise<CreateEntityReturnType>;
+  /**
+   * Updates the entity with the given key.
+   *
+   * - Docs: https://docs.arkiv.network/ts-sdk/actions/wallet/updateEntity
+   * - JSON-RPC Methods: [`eth_sendRawTransaction`](https://docs.arkiv.network/dev/json-rpc-api/#mutateEntities)
+   *
+   * @param data - The entity update parameters
+   * @param txParams - Optional transaction parameters
+   * @returns The updated entity with transaction hash
+   *
+   * @example
+   * import { createWalletClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   */
+  updateEntity: (data: UpdateEntityParameters, txParams?: TxParams) => Promise<UpdateEntityReturnType>;
+  /**
+   * Deletes the entity with the given key.
+   *
+   * - Docs: https://docs.arkiv.network/ts-sdk/actions/wallet/deleteEntity
+   * - JSON-RPC Methods: [`eth_sendRawTransaction`](https://docs.arkiv.network/dev/json-rpc-api/#mutateEntities)
+   *
+   * @param data - The entity deletion parameters
+   * @param txParams - Optional transaction parameters
+   * @returns The deleted entity with transaction hash
+   *
+   * @example
+   * import { createWalletClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const { entityKey, txHash } = await client.deleteEntity({ entityKey: "0x123" })
+   * console.log("entityKey", entityKey)
+   * console.log("txHash", txHash)
+   * // {
+   * //   entityKey: "0x123",
+   * //   txHash: "0x123",
+   * // }
+   */
+  deleteEntity: (data: DeleteEntityParameters, txParams?: TxParams) => Promise<DeleteEntityReturnType>;
+  /**
+   * Extends the entity with the given key.
+   *
+   * - Docs: https://docs.arkiv.network/ts-sdk/actions/wallet/extendEntity
+   * - JSON-RPC Methods: [`eth_sendRawTransaction`](https://docs.arkiv.network/dev/json-rpc-api/#mutateEntities)
+   *
+   * @param data - The entity update parameters
+   * @param txParams - Optional transaction parameters
+   * @returns The updated entity with transaction hash
+   *
+   * @example
+   * import { createWalletClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const { entityKey, txHash } = await client.extendEntity("0x123", {
+   *   expiresIn: 1000,
+   * })
+   * console.log("entityKey", entityKey)
+   * console.log("txHash", txHash)
+   * // {
+   * //   entityKey: "0x123",
+   * //   txHash: "0x123",
+   * // }
+   */
+  extendEntity: (data: ExtendEntityParameters, txParams?: TxParams) => Promise<ExtendEntityReturnType>;
+  /**
+   * Changes the ownership of the entity with the given address.
+   *
+   * - Docs: https://docs.arkiv.network/ts-sdk/actions/wallet/changeOwnership
+   * - JSON-RPC Methods: [`eth_sendRawTransaction`](https://docs.arkiv.network/dev/json-rpc-api/#mutateEntities)
+   *
+   * @param data - The ownership change parameters
+   * @param txParams - Optional transaction parameters
+   * @returns The entity with updated ownership and transaction hash
+   */
+  changeOwnership: (data: ChangeOwnershipParameters, txParams?: TxParams) => Promise<ChangeOwnershipReturnType>;
+  /**
+   * Mutates the entities with the given keys.
+   *
+   * - Docs: https://docs.arkiv.network/ts-sdk/actions/wallet/mutateEntities
+   * - JSON-RPC Methods: [`eth_sendRawTransaction`](https://docs.arkiv.network/dev/json-rpc-api/#mutateEntities)
+   *
+   * @param data - The mutation parameters (creates, updates, deletes, extensions)
+   * @param txParams - Optional transaction parameters
+   * @returns The mutation result with transaction hash
+   *
+   * @example
+   * import { createWalletClient, http } from 'arkiv'
+   * import { kaolin } from 'arkiv/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: kaolin,
+   *   transport: http(),
+   * })
+   * const { entityKey, txHash } = await client.mutateEntities({
+   *   creates: [{
+   *     payload: toBytes(JSON.stringify({ entity: { entityType: "testType", entityId: "testId" } })),
+   *     attriubutes: [{ key: "testKey", value: "testValue" }],
+   *     expiresIn: 1000,
+   *   }],
+   *   updates: [{
+   *     entityKey: "0x123",
+   *     payload: toBytes(JSON.stringify({ entity: { entityType: "testType", entityId: "testId" } })),
+   *     attributes: [{ key: "testKey", value: "testValue" }],
+   *     expiresIn: 1000,
+   *   }],
+   *   deletes: [{
+   *     entityKey: "0x321",
+   *   }],
+   *   extensions: [{
+   *     entityKey: "0x1234",
+   *     expiresIn: 1000,
+   *   }],
+   * })
+   * console.log("entityKey", entityKey)
+   * console.log("txHash", txHash)
+   * // {
+   * //   entityKey: "0x123",
+   * //   txHash: "0x123",
+   * // }
+   */
+  mutateEntities: (data: MutateEntitiesParameters, txParams?: TxParams) => Promise<MutateEntitiesReturnType>;
+};
+//#endregion
+//#region src/clients/createWalletClient.d.ts
+type WalletArkivClient<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined, rpcSchema extends RpcSchema | undefined = ArkivRpcSchema> = Prettify<Client<transport, chain, account, rpcSchema, WalletArkivActions<transport, chain, account>>>;
+/**
+ * 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.arkiv.network/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.arkiv.network/json-rpc/), and [Kaolin JSON-RPC API](https://kaolin.holesky.arkiv.network/rpc) methods such as retrieving block numbers, transactions, reading from smart contracts, etc through [Public Actions](/docs/actions/public/introduction).
+ *
+ * @param parameters - Configuration object for the wallet client (chain, transport, account, etc.)
+ * @returns A Arkiv Wallet Client. {@link WalletArkivClient}
+ *
+ * @example
+ * import { createPublicClient, http } from 'arkiv'
+ * import { kaolin } from 'arkiv/chains'
+ *
+ * const client = createPublicClient({
+ *   chain: kaolin,
+ *   transport: http(),
+ * })
+ */
+declare function createWalletClient<transport extends Transport, chain extends Chain | undefined = undefined, accountOrAddress extends Account | Address | undefined = undefined, rpcSchema extends RpcSchema | undefined = ArkivRpcSchema>(parameters: WalletClientConfig<transport, chain, accountOrAddress, rpcSchema>): WalletArkivClient<transport, chain, ParseAccount<accountOrAddress>, rpcSchema>;
+//#endregion
+//#region src/errors.d.ts
+declare class EntityMutationError extends Error {
+  constructor(message: string);
+}
+declare class NoMoreResultsError extends Error {
+  constructor();
+}
+declare class NoCursorOrLimitError extends Error {
+  constructor();
+}
+declare class NoEntityFoundError extends Error {
+  constructor();
+}
+//#endregion
+//#region src/utils/chains.d.ts
+/**
+ * Get a chain from its name
+ * @param name - The name of the chain, case insensitive
+ * @returns The chain
+ * @throws An error if the chain is not found
+ */
+declare function chainFromName(name: string): Chain;
+//#endregion
+export { type ArkivClient, ArkivRpcSchema, Attribute, ChangeOwnershipParameters, ChangeOwnershipReturnType, CreateEntityParameters, CreateEntityReturnType, DeleteEntityParameters, DeleteEntityReturnType, Entity, EntityMutationError, ExtendEntityParameters, ExtendEntityReturnType, GetBlockTimingReturnType, MimeType, MutateEntitiesParameters, MutateEntitiesReturnType, NoCursorOrLimitError, NoEntityFoundError, NoMoreResultsError, OnEntityCreatedEvent, OnEntityDeletedEvent, OnEntityExpiredEvent, OnEntityExpiresInExtendedEvent, OnEntityOwnerChangedEvent, OnEntityUpdatedEvent, type PublicArkivActions, type PublicArkivClient, QueryOptions, QueryOptionsIncludeData, QueryOptionsOrderBy, QueryReturnType, RpcEntity, RpcIncludeData, RpcOrderByAttribute, RpcQueryOptions, TxParams, UpdateEntityParameters, UpdateEntityReturnType, type WalletArkivActions, type WalletArkivClient, chainFromName, createPublicClient, createWalletClient, jsonToPayload, stringToPayload };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/clients/decorators/arkivPublic.ts","../src/clients/createPublicClient.ts","../src/clients/decorators/arkivWallet.ts","../src/clients/createWalletClient.ts","../src/errors.ts","../src/utils/chains.ts"],"sourcesContent":[],"mappings":";;;;;;;KAgBY,qCACQ,YAAY,yBAChB,oBAAoB,mCAClB,sBAAsB,uBACpC,KACF,cAAc,WAAW,OAAO;;;AALlC;;;;;;;;;;;;;;;;;;;;EAmIwB,SAAA,EAAA,CAAA,GAAA,EA5FL,GA4FK,EAAA,GA5FG,OA4FH,CA5FW,MA4FX,CAAA;EA4BlB;;;;;;;;;;;;;;;;AChKN;;;;EAEoC,UAAA,EAAA,GAAA,GD4DhB,YC5DgB;EACT;;;;;;;;;;;;;AAyB3B;;;;;;;;;;;;;;;;;EAOG,KAAA,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,YAAA,CAAA,ED2DqC,YC3DrC,EAAA,GD2DsD,OC3DtD,CD2D8D,eC3D9D,CAAA;EAAiB;;;;ACjBpB;;;;;;;;;;;EAII,cAAA,EAAA,GAAA,GFyFoB,OEzFpB,CAAA,MAAA,CAAA;EAEc;;;;;;;;;;;;;;;;;;;EAkIT,cAAA,EAAA,GAAA,GFtBe,OEsBf,CAAA;IAaG,YAAA,EAAA,MAAA;IACK,gBAAA,EAAA,MAAA;IACA,aAAA,EAAA,MAAA;EAAR,CAAA,CAAA;EAgDG;;;;;;;;ACzNZ;;;;;;;;;;;;EAMoC,qBAAA,EAAA,CAAA;IAAA,OAAA;IAAA,eAAA;IAAA,eAAA;IAAA,eAAA;IAAA;EADxB,CACwB,EAAA;IAA8B,OAAA,CAAA,EAAA,CAAA,KAAA,EHgK1C,KGhK0C,EAAA,GAAA,IAAA;IAAW,eAAA,CAAA,EAAA,CAAA,KAAA,EHiK7C,oBGjK6C,EAAA,GAAA,IAAA;IAAO,eAAA,CAAA,EAAA,CAAA,KAAA,EHkKpD,oBGlKoD,EAAA,GAAA,IAAA;IAArC,eAAA,CAAA,EAAA,CAAA,KAAA,EHmKf,oBGnKe,EAAA,GAAA,IAAA;IAA7C,eAAA,CAAA,EAAA,CAAA,KAAA,EHoK8B,oBGpK9B,EAAA,GAAA,IAAA;IADE,yBAAA,CAAA,EAAA,CAAA,KAAA,EHsKsC,8BGtKtC,EAAA,GAAA,IAAA;EAAQ,CAAA,EAAA,eAAA,CAAA,EAAA,MAAA,EAAA,SAAA,CAAA,EAAA,MAAA,EAAA,GH0KL,OG1KK,CAAA,GAAA,GAAA,IAAA,CAAA;AAuBZ,CAAA;;;KF5BY,oCACQ,YAAY,yBAChB,oBAAoB,4CACT,mDACP,wBAAwB,kBACxC,SACF,OAAO,WAAW,OAAO,kBAAkB,WAAW,mBAAmB,WAAW;;;;;ADLtF;;;;;;;;;;;;;;;AA6DoB,iBClCJ,kBDkCI,CAAA,kBCjCA,SDiCA,EAAA,cChCJ,KDgCI,GAAA,SAAA,GAAA,SAAA,EAAA,yBC/BO,OD+BP,GC/BiB,OD+BjB,GAAA,SAAA,GAAA,SAAA,EAAA,kBC9BA,SD8BA,GAAA,SAAA,GC9BwB,cD8BxB,CAAA,CAAA,UAAA,EC5BN,kBD4BM,CC5Ba,SD4Bb,EC5BwB,KD4BxB,EC5B+B,gBD4B/B,EC5BiD,SD4BjD,CAAA,CAAA,EC3BjB,iBD2BiB,CC3BC,SD2BD,EC3BY,KD2BZ,EC3BmB,YD2BnB,CC3BgC,gBD2BhC,CAAA,EC3BmD,SD2BnD,CAAA;;;AA7DR,KEiBA,kBFjBkB,CAAA,kBEkBV,SFlBU,GEkBE,SFlBF,EAAA,cEmBd,KFnBc,GAAA,SAAA,GEmBM,KFnBN,GAAA,SAAA,EAAA,gBEoBZ,OFpBY,GAAA,SAAA,GEoBU,OFpBV,GAAA,SAAA,CAAA,GEqB1B,IFrB0B,CEqBrB,aFrBqB,CEqBP,SFrBO,EEqBI,KFrBJ,EEqBW,OFrBX,CAAA,EAAA,2BAAA,CAAA,GEsB5B,IFtB4B,CEuB1B,aFvB0B,CEuBZ,KFvBY,EEuBL,OFvBK,CAAA,EAAA,UAAA,GAAA,WAAA,GAAA,oBAAA,GAAA,iBAAA,GAAA,oBAAA,GAAA,aAAA,GAAA,iBAAA,CAAA,GAAA;EACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyKsB,YAAA,EAAA,CAAA,IAAA,EE3G9B,sBF2G8B,EAAA,QAAA,CAAA,EE1GzB,QF0GyB,EAAA,GEzGjC,OFyGiC,CEzGzB,sBFyGyB,CAAA;EAInC;;;;;AC/KP;;;;;;;;;;;;;;EAMwD,YAAA,EAAA,CAAA,IAAA,ECkF5C,sBDlF4C,EAAA,QAAA,CAAA,ECmFvC,QDnFuC,EAAA,GCoF/C,ODpF+C,CCoFvC,sBDpFuC,CAAA;EAAtD;;;AAsBF;;;;;;;;;;;;;;;;;;;;;;ACVA;EACoB,YAAA,EAAA,CAAA,IAAA,EAoGR,sBApGQ,EAAA,QAAA,CAAA,EAqGH,QArGG,EAAA,GAsGX,OAtGW,CAsGH,sBAtGG,CAAA;EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuIf,YAAA,EAAA,CAAA,IAAA,EAFL,sBAEK,EAAA,QAAA,CAAA,EADA,QACA,EAAA,GAAR,OAAQ,CAAA,sBAAA,CAAA;EAAR;;;;;;;;;;0BAaG,sCACK,aACR,QAAQ;;;ACzKjB;;;;;;;;;;;;;;;;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;AC3CA;EAOa,cAAA,EAAA,CAAA,IAAmB,EFiOpB,wBEjOiC,EAAA,QAAA,CAAA,EFkO5B,QElO4B,EAAA,GFmOpC,OEnOoC,CFmO5B,wBEnO4B,CAAA;AAO7C,CAAA;;;KDCY,oCACQ,YAAY,yBAChB,oBAAoB,mCAClB,sBAAsB,uCACpB,wBAAwB,kBACxC,SACF,OAAO,WAAW,OAAO,SAAS,WAAW,mBAAmB,WAAW,OAAO;;;;;AHLpF;;;;;;;;;;;;;;;AA6DoB,iBGlCJ,kBHkCI,CAAA,kBGjCA,SHiCA,EAAA,cGhCJ,KHgCI,GAAA,SAAA,GAAA,SAAA,EAAA,yBG/BO,OH+BP,GG/BiB,OH+BjB,GAAA,SAAA,GAAA,SAAA,EAAA,kBG9BA,SH8BA,GAAA,SAAA,GG9BwB,cH8BxB,CAAA,CAAA,UAAA,EG5BN,kBH4BM,CG5Ba,SH4Bb,EG5BwB,KH4BxB,EG5B+B,gBH4B/B,EG5BiD,SH4BjD,CAAA,CAAA,EG3BjB,iBH2BiB,CG3BC,SH2BD,EG3BY,KH2BZ,EG3BmB,YH2BnB,CG3BgC,gBH2BhC,CAAA,EG3BmD,SH2BnD,CAAA;;;cI7EP,mBAAA,SAA4B,KAAA;;;cAO5B,kBAAA,SAA2B,KAAA;;;cAO3B,oBAAA,SAA6B,KAAA;;AJE1C;AACoB,cIIP,kBAAA,SAA2B,KAAA,CJJpB;EAAY,WAAA,CAAA;;;;;;;;;;iBKLhB,aAAA,gBAA6B"}

package/dist/index.js

@@ -1,8 +1,8 @@
 import { t as chains_exports } from "./chains-BDsOtN2a.js";
-import { a as entityFromRpcResult, l as getLogger, s as NoEntityFoundError, t as QueryBuilder } from "./queryBuilder-DMzL_J5-.js";
+import { a as entityFromRpcResult, c as NoEntityFoundError, l as NoMoreResultsError, o as EntityMutationError, s as NoCursorOrLimitError, t as QueryBuilder, u as getLogger } from "./queryBuilder-BkWFLc3Y.js";
 import { i as BLOCK_TIME, n as stringToPayload, r as ARKIV_ADDRESS, t as jsonToPayload } from "./payload-DKBYYjeA.js";
 import "./types-H-TSmRpm.js";
-import { bytesToHex, createClient, decodeEventLog, hexToBytes, parseAbi, publicActions, toBytes, toHex, toRlp, walletActions } from "viem";
+import { TransactionExecutionError, bytesToHex, createClient, decodeEventLog, hexToBytes, parseAbi, publicActions, toBytes, toHex, toRlp, walletActions } from "viem";
 
 export * from "viem"
 
@@ -89,7 +89,11 @@ async function query(client, query$1, queryOptions) {
 		method: "arkiv_query",
 		params: [query$1, rpcQueryOptions]
 	});
-	return await Promise.all(result.data.map((entity) => entityFromRpcResult(entity)));
+	return {
+		entities: await Promise.all(result.data.map((entity) => entityFromRpcResult(entity))),
+		cursor: result.cursor,
+		blockNumber: BigInt(result.blockNumber)
+	};
 }
 
 //#endregion
@@ -282,7 +286,7 @@ async function compress(data) {
 const logger$6 = getLogger("utils:arkiv-transactions");
 function opsToTxData({ creates, updates, deletes, extensions, ownershipChanges }) {
 	function formatAttributes(attribute) {
-		return [toHex(attribute.key), toHex(attribute.value)];
+		return [toHex(attribute.key), toHex(typeof attribute.value === "number" && attribute.value === 0 ? "" : attribute.value)];
 	}
 	const payload = [
 		(creates ?? []).map((item) => [
@@ -318,18 +322,30 @@ async function sendArkivTransaction(client, data, txParams) {
 		data,
 		...txParams
 	});
-	const compressed = await compress(toBytes(data));
-	const txHash = await walletClient.sendTransaction({
-		account: client.account,
-		chain: client.chain,
-		to: ARKIV_ADDRESS,
-		value: 0n,
-		data: toHex(compressed),
-		...txParams
-	});
-	const receipt = await walletClient.waitForTransactionReceipt({ hash: txHash });
-	logger$6("Tx receipt %o", receipt);
-	return receipt;
+	try {
+		const compressed = await compress(toBytes(data));
+		const txHash = await walletClient.sendTransaction({
+			account: client.account,
+			chain: client.chain,
+			to: ARKIV_ADDRESS,
+			value: 0n,
+			data: toHex(compressed),
+			...txParams
+		});
+		const receipt = await walletClient.waitForTransactionReceipt({ hash: txHash });
+		logger$6("Tx receipt %o", receipt);
+		if (receipt.status === "reverted") {
+			logger$6("Reverted transaction %o", receipt);
+			throw new EntityMutationError(`Transaction ${receipt.transactionHash} reverted. Please make sure the data for entities doesn't contain invalid characters or invalid data types.`);
+		}
+		return receipt;
+	} catch (error) {
+		let message = "Transaction failed";
+		if (error instanceof TransactionExecutionError) message += `: ${error.details}`;
+		else if (error instanceof EntityMutationError) throw error;
+		logger$6("%s Detailed error stack: %o", message, error);
+		throw new EntityMutationError(message);
+	}
 }
 
 //#endregion
@@ -508,5 +524,5 @@ function chainFromName(name) {
 }
 
 //#endregion
-export { chainFromName, createPublicClient, createWalletClient, jsonToPayload, stringToPayload };
+export { EntityMutationError, NoCursorOrLimitError, NoEntityFoundError, NoMoreResultsError, chainFromName, createPublicClient, createWalletClient, jsonToPayload, stringToPayload };
 //# sourceMappingURL=index.js.map