@arkiv-network/sdk 0.5.0-dev.2 → 0.5.0-dev.4

package/dist/utils/index.d.cts

@@ -1,4 +1,4 @@
-import { n as stringToPayload, t as jsonToPayload } from "../payload-D3fyOBWn.cjs";
+import { n as stringToPayload, t as jsonToPayload } from "../payload-CJN8fTvX.cjs";
 export * from "viem/utils";
 
 //#region src/utils/expirationTime.d.ts

package/dist/utils/index.d.ts

@@ -1,4 +1,4 @@
-import { n as stringToPayload, t as jsonToPayload } from "../payload-BI2NXPDf.js";
+import { n as stringToPayload, t as jsonToPayload } from "../payload-Da9gJMG5.js";
 export * from "viem/utils";
 
 //#region src/utils/expirationTime.d.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkiv-network/sdk",
-  "version": "0.5.0-dev.2",
+  "version": "0.5.0-dev.4",
   "description": "TypeScript client library for Arkiv's blockchains interactions",
   "type": "module",
   "target": "esnext",
@@ -87,7 +87,6 @@
   "devDependencies": {
     "@biomejs/biome": "2.2.4",
     "@types/bun": "latest",
-    "@types/debug": "^4.1.12",
     "rimraf": "^6.0.1",
     "tsdown": "^0.16.0",
     "typedoc": "^0.28.14"
@@ -119,7 +118,6 @@
   "homepage": "https://arkiv.network",
   "dependencies": {
     "brotli-wasm": "^3.0.1",
-    "debug": "^4.3.7",
     "typedoc-plugin-markdown": "^4.9.0",
     "viem": "^2.38.2"
   }

package/src/actions/public/getEntity.ts

@@ -1,6 +1,6 @@
 import { bytesToHex, type Hex, hexToBytes } from "viem"
 import type { ArkivClient } from "../../clients/baseClient"
-import { NoEntityFoundError } from "../../query/errors"
+import { NoEntityFoundError } from "../../errors"
 import { entityFromRpcResult } from "../../utils/entities"
 
 export async function getEntity(client: ArkivClient, key: Hex) {

package/src/actions/public/query.ts

@@ -1,4 +1,5 @@
 import type { ArkivClient } from "../../clients/baseClient"
+import type { Entity } from "../../types/entity"
 import type { RpcQueryOptions } from "../../types/rpcSchema"
 import { entityFromRpcResult } from "../../utils/entities"
 
@@ -21,6 +22,12 @@ export type QueryOptions = {
   cursor?: string | undefined
 }
 
+export type QueryReturnType = {
+  entities: Entity[]
+  cursor: string | undefined
+  blockNumber: bigint | undefined
+}
+
 export async function query(client: ArkivClient, query: string, queryOptions?: QueryOptions) {
   const rpcQueryOptions: RpcQueryOptions = {
     includeData: {
@@ -56,5 +63,9 @@ export async function query(client: ArkivClient, query: string, queryOptions?: Q
 
   const entities = await Promise.all(result.data.map((entity) => entityFromRpcResult(entity)))
 
-  return entities
+  return {
+    entities,
+    cursor: result.cursor,
+    blockNumber: BigInt(result.blockNumber),
+  }
 }

package/src/clients/decorators/arkivPublic.ts

@@ -2,7 +2,7 @@ import type { Account, Chain, Client, Hex, PublicActions, Transport } from "viem
 import { getBlockTiming } from "../../actions/public/getBlockTiming"
 import { getEntity } from "../../actions/public/getEntity"
 import { getEntityCount } from "../../actions/public/getEntityCount"
-import { type QueryOptions, query } from "../../actions/public/query"
+import { type QueryOptions, type QueryReturnType, query } from "../../actions/public/query"
 import { subscribeEntityEvents } from "../../actions/public/subscribeEntityEvents"
 import { QueryBuilder } from "../../query/queryBuilder"
 import type { Entity } from "../../types/entity"
@@ -82,7 +82,7 @@ export type PublicArkivActions<
    * 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 An array of entities matching the query. {@link Entity}
+   * @returns A QueryReturnType instance - {@link QueryReturnType}
    *
    * @example
    * import { createPublicClient, http } from 'arkiv'
@@ -93,7 +93,7 @@ export type PublicArkivActions<
    *   transport: http(),
    * })
    * const queryResult = client.query('key = value && $owner = 0x123')
-   * // queryResult = [{ key: "0x123", value: "0x123" }]
+   * // queryResult = { entities: [{ key: "0x123", value: "0x123" }], cursor: undefined, blockNumber: undefined }
    * const queryResultWithOptions = client.query('key = value && $owner = 0x123', {
    *   includeData: {
    *     attributes: false,
@@ -105,9 +105,9 @@ export type PublicArkivActions<
    *   cursor: undefined,
    *   atBlock: undefined,
    * })
-   * // queryResultWithOptions = [{ key: "0x123", value: "0x123" }]
+   * // queryResultWithOptions = { entities: [{ key: "0x123", value: "0x123" }], cursor: "...", blockNumber: 32223n }
    */
-  query: (query: string, queryOptions?: QueryOptions) => Promise<Entity[]>
+  query: (query: string, queryOptions?: QueryOptions) => Promise<QueryReturnType>
 
   /**
    * Returns the number of entities in the DBChain.

package/src/clients/decorators/arkivWallet.ts

@@ -39,10 +39,10 @@ export type WalletArkivActions<
   Pick<
     WalletActions<chain, account>,
     | "addChain"
+    | "sendCalls"
+    | "waitForCallsStatus"
     | "sendTransaction"
-    | "sendTransactionSync"
     | "sendRawTransaction"
-    | "sendRawTransactionSync"
     | "signMessage"
     | "signTransaction"
   > & {

package/src/{query/errors.ts → errors.ts}

@@ -1,17 +1,27 @@
+export class EntityMutationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "EntityMutationError"
+  }
+}
+
 export class NoMoreResultsError extends Error {
   constructor() {
     super("No more results")
+    this.name = "NoMoreResultsError"
   }
 }
 
 export class NoCursorOrLimitError extends Error {
   constructor() {
     super("Cursor and limit must be defined to fetch next")
+    this.name = "NoCursorOrLimitError"
   }
 }
 
 export class NoEntityFoundError extends Error {
   constructor() {
     super("No entity found")
+    this.name = "NoEntityFoundError"
   }
 }

package/src/index.ts

@@ -13,10 +13,10 @@ export type { WalletArkivClient } from "./clients/createWalletClient"
 export { createWalletClient } from "./clients/createWalletClient"
 export type { PublicArkivActions } from "./clients/decorators/arkivPublic"
 export type { WalletArkivActions } from "./clients/decorators/arkivWallet"
-
+// re-export errors
+export * from "./errors"
 // re-export arkiv types in main index file
 export * from "./types"
-
 // re-export chosen utils
 export { chainFromName } from "./utils/chains"
 export { jsonToPayload, stringToPayload } from "./utils/payload"

package/src/query/index.ts

@@ -1,4 +1,3 @@
-export * from "./errors"
 export * from "./predicate"
 export * from "./queryBuilder"
 export * from "./queryResult"

package/src/query/queryResult.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, jest, test } from "bun:test"
+import { NoCursorOrLimitError, NoMoreResultsError } from "../errors"
 import { Entity } from "../types/entity"
-import { NoCursorOrLimitError, NoMoreResultsError } from "./errors"
 import type { QueryBuilder } from "./queryBuilder"
 import { QueryResult } from "./queryResult"
 

package/src/query/queryResult.ts

@@ -1,6 +1,6 @@
+import { NoCursorOrLimitError, NoMoreResultsError } from "../errors"
 import type { Entity } from "../types/entity"
 import { getLogger } from "../utils/logger"
-import { NoCursorOrLimitError, NoMoreResultsError } from "./errors"
 import type { QueryBuilder } from "./queryBuilder"
 
 const logger = getLogger("query:result")

package/src/types/index.ts

@@ -3,6 +3,7 @@ export type {
   QueryOptions,
   QueryOptionsIncludeData,
   QueryOptionsOrderBy,
+  QueryReturnType,
 } from "../actions/public/query"
 export type {
   ChangeOwnershipParameters,

package/src/types/rpcSchema.ts

@@ -48,7 +48,7 @@ export type ArkivRpcSchema = [
     Parameters?: [query: string, queryOptions?: RpcQueryOptions]
     ReturnType: {
       data: RpcEntity[]
-      blockNumber: bigint
+      blockNumber: number
       cursor: string
     }
   },

package/src/utils/arkivTransactions.ts

@@ -1,4 +1,4 @@
-import { type Hex, toBytes, toHex, toRlp } from "viem"
+import { type Hex, TransactionExecutionError, toBytes, toHex, toRlp } from "viem"
 import type { ChangeOwnershipParameters } from "../actions/wallet/changeOwnership"
 import type { CreateEntityParameters } from "../actions/wallet/createEntity"
 import type { DeleteEntityParameters } from "../actions/wallet/deleteEntity"
@@ -7,6 +7,7 @@ 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 { EntityMutationError } from "../errors"
 import type { TxParams } from "../types"
 import { compress } from "./compression"
 import { getLogger } from "./logger"
@@ -85,19 +86,36 @@ export async function sendArkivTransaction(client: ArkivClient, data: Hex, txPar
     ...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,
-  })
+  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 })
+    const receipt = await walletClient.waitForTransactionReceipt({ hash: txHash })
+    logger("Tx receipt %o", receipt)
+    if (receipt.status === "reverted") {
+      logger("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.`,
+      )
+    }
 
-  logger("Tx receipt %o", receipt)
+    return receipt
+  } catch (error) {
+    let message = "Transaction failed"
+    if (error instanceof TransactionExecutionError) {
+      message += `: ${error.details}`
+    } else if (error instanceof EntityMutationError) {
+      throw error
+    }
 
-  return receipt
+    logger("%s Detailed error stack: %o", message, error)
+    throw new EntityMutationError(message)
+  }
 }

package/src/utils/logger.ts

@@ -1,13 +1,210 @@
-import createDebug from "debug"
-
 const ROOT_NAMESPACE = "arkiv"
 
-export const getLogger = (scope: string) => createDebug(`${ROOT_NAMESPACE}:${scope}`)
+// Debug logger type - returns a function that can be called to log messages
+type DebugLogger = (...args: unknown[]) => void
+
+// Get DEBUG environment variable (works in both Node.js and browser)
+function getDebugEnv(): string {
+  if (typeof process !== "undefined") {
+    const debugEnv = process?.env?.DEBUG
+    if (debugEnv) {
+      return debugEnv
+    }
+  }
+  // Browser: check localStorage
+  if (typeof globalThis !== "undefined" && "localStorage" in globalThis) {
+    try {
+      const storage = (globalThis as { localStorage?: Storage }).localStorage
+      return storage?.getItem("DEBUG") || ""
+    } catch {
+      // localStorage might not be available
+    }
+  }
+  return ""
+}
+
+// Parse debug patterns and check if a namespace matches
+function matchesPattern(namespace: string, pattern: string): boolean {
+  // Exact match
+  if (pattern === namespace) return true
+
+  // Wildcard match: "arkiv:*" matches "arkiv:query", "arkiv:rpc", etc.
+  if (pattern.endsWith("*")) {
+    const prefix = pattern.slice(0, -1)
+    return namespace.startsWith(prefix)
+  }
+
+  // Negative match: "-arkiv:query" excludes "arkiv:query"
+  if (pattern.startsWith("-")) {
+    const excludePattern = pattern.slice(1)
+    return !matchesPattern(namespace, excludePattern)
+  }
+
+  return false
+}
+
+// Check if a namespace is enabled for debugging
+function isEnabled(namespace: string): boolean {
+  const debugEnv = getDebugEnv()
+  if (!debugEnv) return false
+
+  // Split by comma/space and check each pattern
+  const patterns = debugEnv.split(/[\s,]+/).filter((p) => p.length > 0)
+
+  // If no patterns, nothing is enabled
+  if (patterns.length === 0) return false
+
+  // Check if any pattern matches (or if explicitly excluded)
+  let enabled = false
+  for (const pattern of patterns) {
+    if (pattern.startsWith("-")) {
+      // Exclude pattern - if it matches, disable
+      if (matchesPattern(namespace, pattern)) {
+        return false
+      }
+    } else if (matchesPattern(namespace, pattern)) {
+      enabled = true
+    }
+  }
+
+  return enabled
+}
+
+// Store enabled namespaces (for programmatic enable/disable)
+const enabledNamespaces: Set<string> = new Set()
+const disabledNamespaces: Set<string> = new Set()
+
+// Color palette for namespace coloring (distinct, readable colors)
+const COLOR_PALETTE = [
+  "#0000FF", // blue
+  "#008000", // green
+  "#FF0000", // red
+  "#FF00FF", // magenta
+  "#FFA500", // orange
+  "#800080", // purple
+  "#00CED1", // dark turquoise
+  "#FF1493", // deep pink
+  "#32CD32", // lime green
+  "#1E90FF", // dodger blue
+  "#FF4500", // orange red
+  "#9370DB", // medium purple
+  "#00FA9A", // medium spring green
+  "#FFD700", // gold
+  "#DC143C", // crimson
+  "#00BFFF", // deep sky blue
+  "#FF69B4", // hot pink
+  "#20B2AA", // light sea green
+  "#DA70D6", // orchid
+  "#4682B4", // steel blue
+]
+
+// Detect if we're in Node.js (for ANSI colors) or browser (for CSS colors)
+const isNode = typeof process !== "undefined" && process.versions?.node != null
+
+// ANSI color codes for Node.js (bright, distinct colors)
+const ANSI_COLORS = [
+  "\x1b[94m", // bright blue
+  "\x1b[92m", // bright green
+  "\x1b[91m", // bright red
+  "\x1b[95m", // bright magenta
+  "\x1b[93m", // bright yellow
+  "\x1b[96m", // bright cyan
+  "\x1b[35m", // magenta
+  "\x1b[36m", // cyan
+  "\x1b[32m", // green
+  "\x1b[34m", // blue
+  "\x1b[33m", // yellow
+  "\x1b[31m", // red
+  "\x1b[90m", // bright black (gray)
+  "\x1b[37m", // white
+  "\x1b[1m", // bold (as a color option)
+]
+
+const ANSI_RESET = "\x1b[0m"
+const ANSI_BOLD = "\x1b[1m"
+
+// Cache colors for namespaces (same namespace = same color)
+const namespaceColors = new Map<string, { css: string; ansi: string }>()
+
+// Generate a consistent color for a namespace based on its hash
+function getColorForNamespace(namespace: string): { css: string; ansi: string } {
+  // Check cache first
+  const cachedColor = namespaceColors.get(namespace)
+  if (cachedColor) {
+    return cachedColor
+  }
+
+  // Simple hash function to convert string to number
+  let hash = 0
+  for (let i = 0; i < namespace.length; i++) {
+    const char = namespace.charCodeAt(i)
+    hash = (hash << 5) - hash + char
+    hash = hash & hash // Convert to 32-bit integer
+  }
+
+  // Use absolute value and modulo to get index
+  const colorIndex = Math.abs(hash) % COLOR_PALETTE.length
+  const cssColor = COLOR_PALETTE[colorIndex]
+  const ansiColor = ANSI_COLORS[colorIndex % ANSI_COLORS.length]
+
+  const color = { css: cssColor, ansi: ansiColor }
+
+  // Cache the color
+  namespaceColors.set(namespace, color)
+
+  return color
+}
+
+// Create a debug logger function
+function createDebugLogger(namespace: string): DebugLogger {
+  // Get the color for this namespace (consistent across calls)
+  const colors = getColorForNamespace(namespace)
+
+  return (...args: unknown[]) => {
+    // Check if enabled via environment variable or programmatically
+    const envEnabled = isEnabled(namespace)
+    const progEnabled = enabledNamespaces.has(namespace) && !disabledNamespaces.has(namespace)
+
+    if (envEnabled || progEnabled) {
+      if (isNode) {
+        // Node.js: use ANSI color codes
+        const coloredNamespace = `${ANSI_BOLD}${colors.ansi}${namespace}${ANSI_RESET}`
+        console.log(coloredNamespace, ...args)
+      } else {
+        // Browser: use CSS styling with %c
+        // The format is: console.log("%cstyled%cnormal", style1, style2, ...args)
+        // This colors the namespace, then resets for the rest
+        const style1 = `color: ${colors.css}; font-weight: bold`
+        const style2 = "color: inherit; font-weight: normal"
+        // Combine namespace with a space, then log with styles
+        console.log(`%c${namespace}%c`, style1, style2, ...args)
+      }
+    }
+  }
+}
+
+export const getLogger = (scope: string): DebugLogger => {
+  const namespace = `${ROOT_NAMESPACE}:${scope}`
+  return createDebugLogger(namespace)
+}
 
 export const enableDebug = (namespaces: string): void => {
-  createDebug.enable(namespaces)
+  // Parse and add namespaces to enabled set
+  const patterns = namespaces.split(/[\s,]+/).filter((p) => p.length > 0)
+  for (const pattern of patterns) {
+    if (pattern.startsWith("-")) {
+      // Remove from enabled, add to disabled
+      const namespace = pattern.slice(1)
+      enabledNamespaces.delete(namespace)
+      disabledNamespaces.add(namespace)
+    } else {
+      enabledNamespaces.add(pattern)
+      disabledNamespaces.delete(pattern)
+    }
+  }
 }
 
 export const disableDebug = (): void => {
-  createDebug.disable()
+  enabledNamespaces.clear()
+  disabledNamespaces.clear()
 }

package/dist/chunk-pbleEpgJ.cjs

@@ -1,44 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (all) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-
-Object.defineProperty(exports, '__export', {
-  enumerable: true,
-  get: function () {
-    return __export;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});