@opendatalabs/vana-sdk 0.1.0-alpha.7ee7635 → 0.1.0-alpha.8117ac2

package/dist/utils/typedDataConverter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/typedDataConverter.ts"],"sourcesContent":["import type { TypedDataDefinition } from \"viem\";\nimport type { GenericTypedData } from \"../types/permissions\";\n\n/**\n * Converts a GenericTypedData object to a Viem-compatible TypedDataDefinition.\n * This function ensures type safety when passing typed data to viem's signTypedData method.\n *\n * @param typedData - The typed data object to convert\n * @returns A properly typed TypedDataDefinition for use with viem\n */\nexport function toViemTypedDataDefinition(\n  typedData: GenericTypedData,\n): TypedDataDefinition {\n  // Transform the types to match viem's expected format with readonly arrays\n  const viemTypes: Record<string, readonly { name: string; type: string }[]> =\n    {};\n\n  for (const [typeName, typeArray] of Object.entries(typedData.types)) {\n    // Create a new readonly array for each type\n    viemTypes[typeName] = typeArray.map((field) => ({\n      name: field.name,\n      type: field.type,\n    })) as readonly { name: string; type: string }[];\n  }\n\n  return {\n    domain: typedData.domain,\n    types: viemTypes as TypedDataDefinition[\"types\"],\n    primaryType: typedData.primaryType,\n    message: typedData.message,\n  };\n}\n"],"mappings":"AAUO,SAAS,0BACd,WACqB;AAErB,QAAM,YACJ,CAAC;AAEH,aAAW,CAAC,UAAU,SAAS,KAAK,OAAO,QAAQ,UAAU,KAAK,GAAG;AAEnE,cAAU,QAAQ,IAAI,UAAU,IAAI,CAAC,WAAW;AAAA,MAC9C,MAAM,MAAM;AAAA,MACZ,MAAM,MAAM;AAAA,IACd,EAAE;AAAA,EACJ;AAEA,SAAO;AAAA,IACL,QAAQ,UAAU;AAAA,IAClB,OAAO;AAAA,IACP,aAAa,UAAU;AAAA,IACvB,SAAS,UAAU;AAAA,EACrB;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/typedDataConverter.ts"],"sourcesContent":["/**\n * Provides type-safe conversion between Vana and viem typed data formats.\n *\n * @remarks\n * This module bridges the gap between Vana's generic typed data structure\n * and viem's strict TypedDataDefinition format, ensuring compatibility\n * for EIP-712 signature operations.\n *\n * @category Utilities\n * @module typedDataConverter\n */\n\nimport type { TypedDataDefinition } from \"viem\";\nimport type { GenericTypedData } from \"../types/permissions\";\n\n/**\n * Converts a GenericTypedData object to a viem-compatible TypedDataDefinition.\n *\n * @remarks\n * Transforms Vana's flexible typed data format into viem's strict format\n * with readonly arrays. This ensures type safety when passing typed data\n * to viem's `signTypedData` method for EIP-712 signatures.\n *\n * @param typedData - The typed data object to convert.\n *   Obtain from permission operations or server responses.\n * @returns A properly typed TypedDataDefinition for use with viem\n *\n * @example\n * ```typescript\n * const vanTypedData: GenericTypedData = {\n *   domain: { name: 'Vana', version: '1', chainId: 14800 },\n *   types: {\n *     Permission: [\n *       { name: 'grantee', type: 'address' },\n *       { name: 'operation', type: 'string' }\n *     ]\n *   },\n *   primaryType: 'Permission',\n *   message: { grantee: '0x...', operation: 'read' }\n * };\n *\n * const viemTypedData = toViemTypedDataDefinition(vanaTypedData);\n * const signature = await walletClient.signTypedData(viemTypedData);\n * ```\n *\n * @category Utilities\n */\nexport function toViemTypedDataDefinition(\n  typedData: GenericTypedData,\n): TypedDataDefinition {\n  // Transform the types to match viem's expected format with readonly arrays\n  const viemTypes: Record<string, readonly { name: string; type: string }[]> =\n    {};\n\n  for (const [typeName, typeArray] of Object.entries(typedData.types)) {\n    // Create a new readonly array for each type\n    viemTypes[typeName] = typeArray.map((field) => ({\n      name: field.name,\n      type: field.type,\n    })) as readonly { name: string; type: string }[];\n  }\n\n  return {\n    domain: typedData.domain,\n    types: viemTypes as TypedDataDefinition[\"types\"],\n    primaryType: typedData.primaryType,\n    message: typedData.message,\n  };\n}\n"],"mappings":"AA+CO,SAAS,0BACd,WACqB;AAErB,QAAM,YACJ,CAAC;AAEH,aAAW,CAAC,UAAU,SAAS,KAAK,OAAO,QAAQ,UAAU,KAAK,GAAG;AAEnE,cAAU,QAAQ,IAAI,UAAU,IAAI,CAAC,WAAW;AAAA,MAC9C,MAAM,MAAM;AAAA,MACZ,MAAM,MAAM;AAAA,IACd,EAAE;AAAA,EACJ;AAEA,SAAO;AAAA,IACL,QAAQ,UAAU;AAAA,IAClB,OAAO;AAAA,IACP,aAAa,UAAU;AAAA,IACvB,SAAS,UAAU;AAAA,EACrB;AACF;","names":[]}

package/dist/utils/urlResolver.cjs

@@ -24,6 +24,13 @@ __export(urlResolver_exports, {
 module.exports = __toCommonJS(urlResolver_exports);
 var import_download = require("./download");
 class UrlResolutionError extends Error {
+  /**
+   * Creates a new URL resolution error.
+   *
+   * @param message - Description of what went wrong
+   * @param url - The URL that failed to resolve
+   * @param cause - The underlying error that caused the failure
+   */
   constructor(message, url, cause) {
     super(message);
     this.url = url;
@@ -33,7 +40,7 @@ class UrlResolutionError extends Error {
 }
 async function fetchFromUrl(url, downloadRelayer) {
   try {
-    const response = await (0, import_download.fetchWithRelayer)(url, downloadRelayer);
+    const response = await (0, import_download.universalFetch)(url, downloadRelayer);
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }

package/dist/utils/urlResolver.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/urlResolver.ts"],"sourcesContent":["/**\n * Universal URL resolver for the Vana SDK\n *\n * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)\n * in a consistent, reliable way.\n */\n\nimport { fetchWithRelayer } from \"./download\";\n\n/**\n * Error thrown when URL resolution fails\n */\nexport class UrlResolutionError extends Error {\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await fetchWithRelayer(url, downloadRelayer);\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Parse JSON response\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    throw new UrlResolutionError(\n      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      url,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,sBAAiC;AAK1B,MAAM,2BAA2B,MAAM;AAAA,EAC5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,UAAM,kCAAiB,KAAK,eAAe;AAE5D,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU,EAAE;AAAA,IACnE;AAGA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,wBAAwB,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACxF;AAAA,MACA,iBAAiB,QAAQ,QAAQ;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/urlResolver.ts"],"sourcesContent":["/**\n * Provides universal URL resolution across multiple protocols.\n *\n * @remarks\n * This module enables fetching data from various protocols including IPFS,\n * HTTP/HTTPS, and Arweave through a unified interface. It handles protocol\n * conversion, gateway selection, and fallback strategies automatically.\n *\n * @category Utilities\n * @module utils/urlResolver\n */\n\nimport { universalFetch } from \"./download\";\n\n/**\n * Indicates that URL resolution or data fetching failed.\n *\n * @remarks\n * This error provides context about which URL failed and why,\n * making it easier to debug issues with external resources.\n *\n * @category Errors\n */\nexport class UrlResolutionError extends Error {\n  /**\n   * Creates a new URL resolution error.\n   *\n   * @param message - Description of what went wrong\n   * @param url - The URL that failed to resolve\n   * @param cause - The underlying error that caused the failure\n   */\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await universalFetch(url, downloadRelayer);\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Parse JSON response\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    throw new UrlResolutionError(\n      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      url,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,sBAA+B;AAWxB,MAAM,2BAA2B,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,UAAM,gCAAe,KAAK,eAAe;AAE1D,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU,EAAE;AAAA,IACnE;AAGA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,wBAAwB,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACxF;AAAA,MACA,iBAAiB,QAAQ,QAAQ;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}

package/dist/utils/urlResolver.d.ts

@@ -1,15 +1,33 @@
 /**
- * Universal URL resolver for the Vana SDK
+ * Provides universal URL resolution across multiple protocols.
  *
- * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)
- * in a consistent, reliable way.
+ * @remarks
+ * This module enables fetching data from various protocols including IPFS,
+ * HTTP/HTTPS, and Arweave through a unified interface. It handles protocol
+ * conversion, gateway selection, and fallback strategies automatically.
+ *
+ * @category Utilities
+ * @module utils/urlResolver
  */
 /**
- * Error thrown when URL resolution fails
+ * Indicates that URL resolution or data fetching failed.
+ *
+ * @remarks
+ * This error provides context about which URL failed and why,
+ * making it easier to debug issues with external resources.
+ *
+ * @category Errors
  */
-declare class UrlResolutionError extends Error {
+export declare class UrlResolutionError extends Error {
     readonly url: string;
     readonly cause?: Error | undefined;
+    /**
+     * Creates a new URL resolution error.
+     *
+     * @param message - Description of what went wrong
+     * @param url - The URL that failed to resolve
+     * @param cause - The underlying error that caused the failure
+     */
     constructor(message: string, url: string, cause?: Error | undefined);
 }
 /**
@@ -33,8 +51,6 @@ declare class UrlResolutionError extends Error {
  * const schema = await fetchFromUrl(schemaDefinitionUrl);
  * ```
  */
-declare function fetchFromUrl(url: string, downloadRelayer?: {
+export declare function fetchFromUrl(url: string, downloadRelayer?: {
     proxyDownload: (url: string) => Promise<Blob>;
 }): Promise<unknown>;
-
-export { UrlResolutionError, fetchFromUrl };

package/dist/utils/urlResolver.js

@@ -1,5 +1,12 @@
-import { fetchWithRelayer } from "./download";
+import { universalFetch } from "./download";
 class UrlResolutionError extends Error {
+  /**
+   * Creates a new URL resolution error.
+   *
+   * @param message - Description of what went wrong
+   * @param url - The URL that failed to resolve
+   * @param cause - The underlying error that caused the failure
+   */
   constructor(message, url, cause) {
     super(message);
     this.url = url;
@@ -9,7 +16,7 @@ class UrlResolutionError extends Error {
 }
 async function fetchFromUrl(url, downloadRelayer) {
   try {
-    const response = await fetchWithRelayer(url, downloadRelayer);
+    const response = await universalFetch(url, downloadRelayer);
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }

package/dist/utils/urlResolver.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/urlResolver.ts"],"sourcesContent":["/**\n * Universal URL resolver for the Vana SDK\n *\n * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)\n * in a consistent, reliable way.\n */\n\nimport { fetchWithRelayer } from \"./download\";\n\n/**\n * Error thrown when URL resolution fails\n */\nexport class UrlResolutionError extends Error {\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await fetchWithRelayer(url, downloadRelayer);\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Parse JSON response\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    throw new UrlResolutionError(\n      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      url,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n"],"mappings":"AAOA,SAAS,wBAAwB;AAK1B,MAAM,2BAA2B,MAAM;AAAA,EAC5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,MAAM,iBAAiB,KAAK,eAAe;AAE5D,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU,EAAE;AAAA,IACnE;AAGA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,wBAAwB,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACxF;AAAA,MACA,iBAAiB,QAAQ,QAAQ;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/urlResolver.ts"],"sourcesContent":["/**\n * Provides universal URL resolution across multiple protocols.\n *\n * @remarks\n * This module enables fetching data from various protocols including IPFS,\n * HTTP/HTTPS, and Arweave through a unified interface. It handles protocol\n * conversion, gateway selection, and fallback strategies automatically.\n *\n * @category Utilities\n * @module utils/urlResolver\n */\n\nimport { universalFetch } from \"./download\";\n\n/**\n * Indicates that URL resolution or data fetching failed.\n *\n * @remarks\n * This error provides context about which URL failed and why,\n * making it easier to debug issues with external resources.\n *\n * @category Errors\n */\nexport class UrlResolutionError extends Error {\n  /**\n   * Creates a new URL resolution error.\n   *\n   * @param message - Description of what went wrong\n   * @param url - The URL that failed to resolve\n   * @param cause - The underlying error that caused the failure\n   */\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await universalFetch(url, downloadRelayer);\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Parse JSON response\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    throw new UrlResolutionError(\n      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      url,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n"],"mappings":"AAYA,SAAS,sBAAsB;AAWxB,MAAM,2BAA2B,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,MAAM,eAAe,KAAK,eAAe;AAE1D,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU,EAAE;AAAA,IACnE;AAGA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,wBAAwB,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACxF;AAAA,MACA,iBAAiB,QAAQ,QAAQ;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}

package/dist/utils/wallet.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wallet_exports = {};
+__export(wallet_exports, {
+  extractAddress: () => extractAddress,
+  extractAddressSafe: () => extractAddressSafe,
+  hasAddress: () => hasAddress
+});
+module.exports = __toCommonJS(wallet_exports);
+function extractAddress(account) {
+  if (!account) {
+    throw new Error("No account provided");
+  }
+  if (typeof account === "string") {
+    return account;
+  }
+  if (typeof account === "object" && "address" in account && account.address) {
+    return account.address;
+  }
+  throw new Error("Unable to determine wallet address from account");
+}
+function extractAddressSafe(account) {
+  try {
+    return extractAddress(account);
+  } catch {
+    return void 0;
+  }
+}
+function hasAddress(account) {
+  if (!account) return false;
+  if (typeof account === "string") {
+    return /^0x[a-fA-F0-9]{40}$/.test(account);
+  }
+  if (typeof account === "object" && "address" in account) {
+    const accountWithAddress = account;
+    const addr = accountWithAddress.address;
+    return typeof addr === "string" && /^0x[a-fA-F0-9]{40}$/.test(addr);
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractAddress,
+  extractAddressSafe,
+  hasAddress
+});
+//# sourceMappingURL=wallet.cjs.map

package/dist/utils/wallet.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/wallet.ts"],"sourcesContent":["import type { Account, Address } from \"viem\";\n\n/**\n * Extracts an Ethereum address from various account formats.\n *\n * @remarks\n * Handles viem's polymorphic Account type which can be a string address,\n * an object with an address property, or a LocalAccount. This utility\n * provides consistent address extraction across the SDK, eliminating\n * duplicate logic and potential inconsistencies.\n *\n * @param account - The account to extract address from.\n *   Can be a hex string address, Account object, or LocalAccount.\n * @returns The extracted Ethereum address as a `0x`-prefixed string\n *\n * @throws {Error} When account is undefined or null.\n *   Provide a valid account from wallet connection.\n * @throws {Error} When address cannot be determined from account structure.\n *   Ensure account has a valid address property.\n *\n * @example\n * ```typescript\n * // String address\n * const addr1 = extractAddress('0x742d35Cc6634C0532925a3b844Bc9e7595f0b0Bb');\n *\n * // Account object\n * const addr2 = extractAddress({ address: '0x742d...' });\n *\n * // LocalAccount from viem\n * const account = privateKeyToAccount('0x...');\n * const addr3 = extractAddress(account);\n * ```\n *\n * @category Utilities\n */\nexport function extractAddress(\n  account: Account | Address | undefined | null,\n): Address {\n  if (!account) {\n    throw new Error(\"No account provided\");\n  }\n\n  // Handle string address directly\n  if (typeof account === \"string\") {\n    return account as Address;\n  }\n\n  // Handle object with address property\n  if (typeof account === \"object\" && \"address\" in account && account.address) {\n    return account.address;\n  }\n\n  throw new Error(\"Unable to determine wallet address from account\");\n}\n\n/**\n * Safely extracts an address without throwing errors.\n *\n * @remarks\n * Non-throwing version of `extractAddress` for optional address resolution.\n * Use when address extraction failure is acceptable and should be handled\n * gracefully without exception handling.\n *\n * @param account - The account to extract address from.\n *   Can be a hex string address, Account object, LocalAccount, or nullish.\n * @returns The extracted Ethereum address or `undefined` if extraction fails\n *\n * @example\n * ```typescript\n * const address = extractAddressSafe(potentialAccount);\n *\n * if (address) {\n *   console.log(`Using address: ${address}`);\n * } else {\n *   console.log('No valid address available');\n * }\n *\n * // Useful in optional chaining\n * const userAddress = extractAddressSafe(user?.wallet) ?? DEFAULT_ADDRESS;\n * ```\n *\n * @category Utilities\n */\nexport function extractAddressSafe(\n  account: Account | Address | undefined | null,\n): Address | undefined {\n  try {\n    return extractAddress(account);\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Validates whether a value contains a valid Ethereum address.\n *\n * @remarks\n * Type guard that performs runtime validation of Ethereum address format.\n * Checks for proper `0x` prefix and 40 hexadecimal characters. Works with\n * string addresses, Account objects, and LocalAccount instances.\n *\n * @param account - The value to validate for address presence\n * @returns `true` if account contains a valid Ethereum address, `false` otherwise\n *\n * @example\n * ```typescript\n * const maybeAccount: unknown = getUserInput();\n *\n * if (hasAddress(maybeAccount)) {\n *   // TypeScript knows maybeAccount is Account | Address\n *   const address = extractAddress(maybeAccount);\n *   await vana.data.getUserFiles({ owner: address });\n * } else {\n *   console.error('Invalid address format');\n * }\n *\n * // Filter valid addresses from mixed array\n * const addresses = mixedArray.filter(hasAddress).map(extractAddress);\n * ```\n *\n * @category Utilities\n */\nexport function hasAddress(account: unknown): account is Account | Address {\n  if (!account) return false;\n\n  if (typeof account === \"string\") {\n    // Basic check for Ethereum address format\n    return /^0x[a-fA-F0-9]{40}$/.test(account);\n  }\n\n  if (typeof account === \"object\" && \"address\" in account) {\n    const accountWithAddress = account as { address: unknown };\n    const addr = accountWithAddress.address;\n    return typeof addr === \"string\" && /^0x[a-fA-F0-9]{40}$/.test(addr);\n  }\n\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmCO,SAAS,eACd,SACS;AACT,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AAGA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,YAAY,YAAY,aAAa,WAAW,QAAQ,SAAS;AAC1E,WAAO,QAAQ;AAAA,EACjB;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;AA8BO,SAAS,mBACd,SACqB;AACrB,MAAI;AACF,WAAO,eAAe,OAAO;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AA+BO,SAAS,WAAW,SAAgD;AACzE,MAAI,CAAC,QAAS,QAAO;AAErB,MAAI,OAAO,YAAY,UAAU;AAE/B,WAAO,sBAAsB,KAAK,OAAO;AAAA,EAC3C;AAEA,MAAI,OAAO,YAAY,YAAY,aAAa,SAAS;AACvD,UAAM,qBAAqB;AAC3B,UAAM,OAAO,mBAAmB;AAChC,WAAO,OAAO,SAAS,YAAY,sBAAsB,KAAK,IAAI;AAAA,EACpE;AAEA,SAAO;AACT;","names":[]}

package/dist/utils/wallet.d.ts

@@ -0,0 +1,94 @@
+import type { Account, Address } from "viem";
+/**
+ * Extracts an Ethereum address from various account formats.
+ *
+ * @remarks
+ * Handles viem's polymorphic Account type which can be a string address,
+ * an object with an address property, or a LocalAccount. This utility
+ * provides consistent address extraction across the SDK, eliminating
+ * duplicate logic and potential inconsistencies.
+ *
+ * @param account - The account to extract address from.
+ *   Can be a hex string address, Account object, or LocalAccount.
+ * @returns The extracted Ethereum address as a `0x`-prefixed string
+ *
+ * @throws {Error} When account is undefined or null.
+ *   Provide a valid account from wallet connection.
+ * @throws {Error} When address cannot be determined from account structure.
+ *   Ensure account has a valid address property.
+ *
+ * @example
+ * ```typescript
+ * // String address
+ * const addr1 = extractAddress('0x742d35Cc6634C0532925a3b844Bc9e7595f0b0Bb');
+ *
+ * // Account object
+ * const addr2 = extractAddress({ address: '0x742d...' });
+ *
+ * // LocalAccount from viem
+ * const account = privateKeyToAccount('0x...');
+ * const addr3 = extractAddress(account);
+ * ```
+ *
+ * @category Utilities
+ */
+export declare function extractAddress(account: Account | Address | undefined | null): Address;
+/**
+ * Safely extracts an address without throwing errors.
+ *
+ * @remarks
+ * Non-throwing version of `extractAddress` for optional address resolution.
+ * Use when address extraction failure is acceptable and should be handled
+ * gracefully without exception handling.
+ *
+ * @param account - The account to extract address from.
+ *   Can be a hex string address, Account object, LocalAccount, or nullish.
+ * @returns The extracted Ethereum address or `undefined` if extraction fails
+ *
+ * @example
+ * ```typescript
+ * const address = extractAddressSafe(potentialAccount);
+ *
+ * if (address) {
+ *   console.log(`Using address: ${address}`);
+ * } else {
+ *   console.log('No valid address available');
+ * }
+ *
+ * // Useful in optional chaining
+ * const userAddress = extractAddressSafe(user?.wallet) ?? DEFAULT_ADDRESS;
+ * ```
+ *
+ * @category Utilities
+ */
+export declare function extractAddressSafe(account: Account | Address | undefined | null): Address | undefined;
+/**
+ * Validates whether a value contains a valid Ethereum address.
+ *
+ * @remarks
+ * Type guard that performs runtime validation of Ethereum address format.
+ * Checks for proper `0x` prefix and 40 hexadecimal characters. Works with
+ * string addresses, Account objects, and LocalAccount instances.
+ *
+ * @param account - The value to validate for address presence
+ * @returns `true` if account contains a valid Ethereum address, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * const maybeAccount: unknown = getUserInput();
+ *
+ * if (hasAddress(maybeAccount)) {
+ *   // TypeScript knows maybeAccount is Account | Address
+ *   const address = extractAddress(maybeAccount);
+ *   await vana.data.getUserFiles({ owner: address });
+ * } else {
+ *   console.error('Invalid address format');
+ * }
+ *
+ * // Filter valid addresses from mixed array
+ * const addresses = mixedArray.filter(hasAddress).map(extractAddress);
+ * ```
+ *
+ * @category Utilities
+ */
+export declare function hasAddress(account: unknown): account is Account | Address;

package/dist/utils/wallet.js

@@ -0,0 +1,37 @@
+function extractAddress(account) {
+  if (!account) {
+    throw new Error("No account provided");
+  }
+  if (typeof account === "string") {
+    return account;
+  }
+  if (typeof account === "object" && "address" in account && account.address) {
+    return account.address;
+  }
+  throw new Error("Unable to determine wallet address from account");
+}
+function extractAddressSafe(account) {
+  try {
+    return extractAddress(account);
+  } catch {
+    return void 0;
+  }
+}
+function hasAddress(account) {
+  if (!account) return false;
+  if (typeof account === "string") {
+    return /^0x[a-fA-F0-9]{40}$/.test(account);
+  }
+  if (typeof account === "object" && "address" in account) {
+    const accountWithAddress = account;
+    const addr = accountWithAddress.address;
+    return typeof addr === "string" && /^0x[a-fA-F0-9]{40}$/.test(addr);
+  }
+  return false;
+}
+export {
+  extractAddress,
+  extractAddressSafe,
+  hasAddress
+};
+//# sourceMappingURL=wallet.js.map

package/dist/utils/wallet.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/wallet.ts"],"sourcesContent":["import type { Account, Address } from \"viem\";\n\n/**\n * Extracts an Ethereum address from various account formats.\n *\n * @remarks\n * Handles viem's polymorphic Account type which can be a string address,\n * an object with an address property, or a LocalAccount. This utility\n * provides consistent address extraction across the SDK, eliminating\n * duplicate logic and potential inconsistencies.\n *\n * @param account - The account to extract address from.\n *   Can be a hex string address, Account object, or LocalAccount.\n * @returns The extracted Ethereum address as a `0x`-prefixed string\n *\n * @throws {Error} When account is undefined or null.\n *   Provide a valid account from wallet connection.\n * @throws {Error} When address cannot be determined from account structure.\n *   Ensure account has a valid address property.\n *\n * @example\n * ```typescript\n * // String address\n * const addr1 = extractAddress('0x742d35Cc6634C0532925a3b844Bc9e7595f0b0Bb');\n *\n * // Account object\n * const addr2 = extractAddress({ address: '0x742d...' });\n *\n * // LocalAccount from viem\n * const account = privateKeyToAccount('0x...');\n * const addr3 = extractAddress(account);\n * ```\n *\n * @category Utilities\n */\nexport function extractAddress(\n  account: Account | Address | undefined | null,\n): Address {\n  if (!account) {\n    throw new Error(\"No account provided\");\n  }\n\n  // Handle string address directly\n  if (typeof account === \"string\") {\n    return account as Address;\n  }\n\n  // Handle object with address property\n  if (typeof account === \"object\" && \"address\" in account && account.address) {\n    return account.address;\n  }\n\n  throw new Error(\"Unable to determine wallet address from account\");\n}\n\n/**\n * Safely extracts an address without throwing errors.\n *\n * @remarks\n * Non-throwing version of `extractAddress` for optional address resolution.\n * Use when address extraction failure is acceptable and should be handled\n * gracefully without exception handling.\n *\n * @param account - The account to extract address from.\n *   Can be a hex string address, Account object, LocalAccount, or nullish.\n * @returns The extracted Ethereum address or `undefined` if extraction fails\n *\n * @example\n * ```typescript\n * const address = extractAddressSafe(potentialAccount);\n *\n * if (address) {\n *   console.log(`Using address: ${address}`);\n * } else {\n *   console.log('No valid address available');\n * }\n *\n * // Useful in optional chaining\n * const userAddress = extractAddressSafe(user?.wallet) ?? DEFAULT_ADDRESS;\n * ```\n *\n * @category Utilities\n */\nexport function extractAddressSafe(\n  account: Account | Address | undefined | null,\n): Address | undefined {\n  try {\n    return extractAddress(account);\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Validates whether a value contains a valid Ethereum address.\n *\n * @remarks\n * Type guard that performs runtime validation of Ethereum address format.\n * Checks for proper `0x` prefix and 40 hexadecimal characters. Works with\n * string addresses, Account objects, and LocalAccount instances.\n *\n * @param account - The value to validate for address presence\n * @returns `true` if account contains a valid Ethereum address, `false` otherwise\n *\n * @example\n * ```typescript\n * const maybeAccount: unknown = getUserInput();\n *\n * if (hasAddress(maybeAccount)) {\n *   // TypeScript knows maybeAccount is Account | Address\n *   const address = extractAddress(maybeAccount);\n *   await vana.data.getUserFiles({ owner: address });\n * } else {\n *   console.error('Invalid address format');\n * }\n *\n * // Filter valid addresses from mixed array\n * const addresses = mixedArray.filter(hasAddress).map(extractAddress);\n * ```\n *\n * @category Utilities\n */\nexport function hasAddress(account: unknown): account is Account | Address {\n  if (!account) return false;\n\n  if (typeof account === \"string\") {\n    // Basic check for Ethereum address format\n    return /^0x[a-fA-F0-9]{40}$/.test(account);\n  }\n\n  if (typeof account === \"object\" && \"address\" in account) {\n    const accountWithAddress = account as { address: unknown };\n    const addr = accountWithAddress.address;\n    return typeof addr === \"string\" && /^0x[a-fA-F0-9]{40}$/.test(addr);\n  }\n\n  return false;\n}\n"],"mappings":"AAmCO,SAAS,eACd,SACS;AACT,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AAGA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,YAAY,YAAY,aAAa,WAAW,QAAQ,SAAS;AAC1E,WAAO,QAAQ;AAAA,EACjB;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;AA8BO,SAAS,mBACd,SACqB;AACrB,MAAI;AACF,WAAO,eAAe,OAAO;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AA+BO,SAAS,WAAW,SAAgD;AACzE,MAAI,CAAC,QAAS,QAAO;AAErB,MAAI,OAAO,YAAY,UAAU;AAE/B,WAAO,sBAAsB,KAAK,OAAO;AAAA,EAC3C;AAEA,MAAI,OAAO,YAAY,YAAY,aAAa,SAAS;AACvD,UAAM,qBAAqB;AAC3B,UAAM,OAAO,mBAAmB;AAChC,WAAO,OAAO,SAAS,YAAY,sBAAsB,KAAK,IAAI;AAAA,EACpE;AAEA,SAAO;AACT;","names":[]}

package/dist/utils/withEvents.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/withEvents.ts"],"sourcesContent":["/**\n * Internal helper for controllers to wait for transaction events and extract data.\n * This keeps the POJO system internal while providing simple return values to developers.\n * \n * @internal\n */\n\nimport type { Contract, Fn, TypedTransactionResult } from \"../generated/event-types\";\nimport type { TransactionResult } from \"../types/operations\";\nimport { tx } from \"./transactionHelpers\";\n\n/**\n * Waits for transaction events and transforms them into domain-specific results.\n * \n * @internal\n * @param waitFor - The waitForTransactionEvents function from context\n * @param tx - The transaction result POJO\n * @param select - Function to extract domain data from typed events\n * @returns The domain-specific result\n */\nexport async function withEvents<\n  C extends Contract,\n  F extends Fn<C>,\n  Out\n>(\n  waitFor: (tx: TransactionResult<C, F>) => Promise<TypedTransactionResult<C, F>>,\n  tx: TransactionResult<C, F>,\n  select: (result: TypedTransactionResult<C, F>) => Out\n): Promise<Out> {\n  const result = await waitFor(tx);\n  return select(result);\n}\n\n/**\n * Creates a transaction result POJO and immediately waits for events.\n * Convenience wrapper that combines tx() + withEvents() for cleaner controller code.\n * \n * @internal\n * @param waitFor - The waitForTransactionEvents function from context\n * @param input - Transaction details (hash, from, contract, fn)\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param select - Function to extract domain data from typed events\n * @returns The domain-specific result\n */\nexport async function txWithEvents<\n  C extends Contract,\n  F extends Fn<C>,\n  Out\n>(\n  waitFor: (tx: TransactionResult<C, F>) => Promise<TypedTransactionResult<C, F>>,\n  input: {\n    hash: `0x${string}`;\n    from: `0x${string}`;\n    contract: C;\n    fn: F;\n  },\n  select: (result: TypedTransactionResult<C, F>) => Out\n): Promise<Out> {\n  const txResult = tx(input);\n  return withEvents(waitFor, txResult, select);\n}\n\n/**\n * Helper for methods that submit transactions via relayer.\n * Returns the TransactionResult POJO for two-step processing.\n * \n * @internal\n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @returns TransactionResult POJO for external waiting\n */\nexport function txForRelayed<C extends Contract, F extends Fn<C>>(\n  input: {\n    hash: `0x${string}`;\n    from: `0x${string}`;\n    contract: C;\n    fn: F;\n  }\n): TransactionResult<C, F> {\n  return tx(input);\n}"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,gCAAmB;AAWnB,eAAsB,WAKpB,SACAA,KACA,QACc;AACd,QAAM,SAAS,MAAM,QAAQA,GAAE;AAC/B,SAAO,OAAO,MAAM;AACtB;AAgBA,eAAsB,aAKpB,SACA,OAMA,QACc;AACd,QAAM,eAAW,8BAAG,KAAK;AACzB,SAAO,WAAW,SAAS,UAAU,MAAM;AAC7C;AAcO,SAAS,aACd,OAMyB;AACzB,aAAO,8BAAG,KAAK;AACjB;","names":["tx"]}
+{"version":3,"sources":["../../src/utils/withEvents.ts"],"sourcesContent":["/**\n * Internal helper for controllers to wait for transaction events and extract data.\n * This keeps the POJO system internal while providing simple return values to developers.\n *\n * @internal\n */\n\nimport type {\n  Contract,\n  Fn,\n  TypedTransactionResult,\n} from \"../generated/event-types\";\nimport type { TransactionResult } from \"../types/operations\";\nimport { tx } from \"./transactionHelpers\";\n\n/**\n * Waits for transaction events and transforms them into domain-specific results.\n *\n * @internal\n * @param waitFor - The waitForTransactionEvents function from context\n * @param tx - The transaction result POJO\n * @param select - Function to extract domain data from typed events\n * @returns The domain-specific result\n */\nexport async function withEvents<C extends Contract, F extends Fn<C>, Out>(\n  waitFor: (\n    tx: TransactionResult<C, F>,\n  ) => Promise<TypedTransactionResult<C, F>>,\n  tx: TransactionResult<C, F>,\n  select: (result: TypedTransactionResult<C, F>) => Out,\n): Promise<Out> {\n  const result = await waitFor(tx);\n  return select(result);\n}\n\n/**\n * Creates a transaction result POJO and immediately waits for events.\n * Convenience wrapper that combines tx() + withEvents() for cleaner controller code.\n *\n * @internal\n * @param waitFor - The waitForTransactionEvents function from context\n * @param input - Transaction details (hash, from, contract, fn)\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param select - Function to extract domain data from typed events\n * @returns The domain-specific result\n */\nexport async function txWithEvents<C extends Contract, F extends Fn<C>, Out>(\n  waitFor: (\n    tx: TransactionResult<C, F>,\n  ) => Promise<TypedTransactionResult<C, F>>,\n  input: {\n    hash: `0x${string}`;\n    from: `0x${string}`;\n    contract: C;\n    fn: F;\n  },\n  select: (result: TypedTransactionResult<C, F>) => Out,\n): Promise<Out> {\n  const txResult = tx(input);\n  return withEvents(waitFor, txResult, select);\n}\n\n/**\n * Helper for methods that submit transactions via relayer.\n * Returns the TransactionResult POJO for two-step processing.\n *\n * @internal\n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @returns TransactionResult POJO for external waiting\n */\nexport function txForRelayed<C extends Contract, F extends Fn<C>>(input: {\n  hash: `0x${string}`;\n  from: `0x${string}`;\n  contract: C;\n  fn: F;\n}): TransactionResult<C, F> {\n  return tx(input);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,gCAAmB;AAWnB,eAAsB,WACpB,SAGAA,KACA,QACc;AACd,QAAM,SAAS,MAAM,QAAQA,GAAE;AAC/B,SAAO,OAAO,MAAM;AACtB;AAgBA,eAAsB,aACpB,SAGA,OAMA,QACc;AACd,QAAM,eAAW,8BAAG,KAAK;AACzB,SAAO,WAAW,SAAS,UAAU,MAAM;AAC7C;AAcO,SAAS,aAAkD,OAKtC;AAC1B,aAAO,8BAAG,KAAK;AACjB;","names":["tx"]}

package/dist/utils/withEvents.d.ts

@@ -1,16 +1,11 @@
-import { Contract, Fn, TypedTransactionResult } from '../generated/event-types.js';
-import { TransactionResult } from '../types/operations.js';
-import 'viem';
-import '../generated/server/server-exports.js';
-import '../generated/server/server.js';
-
 /**
  * Internal helper for controllers to wait for transaction events and extract data.
  * This keeps the POJO system internal while providing simple return values to developers.
  *
  * @internal
  */
-
+import type { Contract, Fn, TypedTransactionResult } from "../generated/event-types";
+import type { TransactionResult } from "../types/operations";
 /**
  * Waits for transaction events and transforms them into domain-specific results.
  *
@@ -20,7 +15,7 @@ import '../generated/server/server.js';
  * @param select - Function to extract domain data from typed events
  * @returns The domain-specific result
  */
-declare function withEvents<C extends Contract, F extends Fn<C>, Out>(waitFor: (tx: TransactionResult<C, F>) => Promise<TypedTransactionResult<C, F>>, tx: TransactionResult<C, F>, select: (result: TypedTransactionResult<C, F>) => Out): Promise<Out>;
+export declare function withEvents<C extends Contract, F extends Fn<C>, Out>(waitFor: (tx: TransactionResult<C, F>) => Promise<TypedTransactionResult<C, F>>, tx: TransactionResult<C, F>, select: (result: TypedTransactionResult<C, F>) => Out): Promise<Out>;
 /**
  * Creates a transaction result POJO and immediately waits for events.
  * Convenience wrapper that combines tx() + withEvents() for cleaner controller code.
@@ -35,7 +30,7 @@ declare function withEvents<C extends Contract, F extends Fn<C>, Out>(waitFor: (
  * @param select - Function to extract domain data from typed events
  * @returns The domain-specific result
  */
-declare function txWithEvents<C extends Contract, F extends Fn<C>, Out>(waitFor: (tx: TransactionResult<C, F>) => Promise<TypedTransactionResult<C, F>>, input: {
+export declare function txWithEvents<C extends Contract, F extends Fn<C>, Out>(waitFor: (tx: TransactionResult<C, F>) => Promise<TypedTransactionResult<C, F>>, input: {
     hash: `0x${string}`;
     from: `0x${string}`;
     contract: C;
@@ -53,11 +48,9 @@ declare function txWithEvents<C extends Contract, F extends Fn<C>, Out>(waitFor:
  * @param input.fn - Function name
  * @returns TransactionResult POJO for external waiting
  */
-declare function txForRelayed<C extends Contract, F extends Fn<C>>(input: {
+export declare function txForRelayed<C extends Contract, F extends Fn<C>>(input: {
     hash: `0x${string}`;
     from: `0x${string}`;
     contract: C;
     fn: F;
 }): TransactionResult<C, F>;
-
-export { txForRelayed, txWithEvents, withEvents };

package/dist/utils/withEvents.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/withEvents.ts"],"sourcesContent":["/**\n * Internal helper for controllers to wait for transaction events and extract data.\n * This keeps the POJO system internal while providing simple return values to developers.\n * \n * @internal\n */\n\nimport type { Contract, Fn, TypedTransactionResult } from \"../generated/event-types\";\nimport type { TransactionResult } from \"../types/operations\";\nimport { tx } from \"./transactionHelpers\";\n\n/**\n * Waits for transaction events and transforms them into domain-specific results.\n * \n * @internal\n * @param waitFor - The waitForTransactionEvents function from context\n * @param tx - The transaction result POJO\n * @param select - Function to extract domain data from typed events\n * @returns The domain-specific result\n */\nexport async function withEvents<\n  C extends Contract,\n  F extends Fn<C>,\n  Out\n>(\n  waitFor: (tx: TransactionResult<C, F>) => Promise<TypedTransactionResult<C, F>>,\n  tx: TransactionResult<C, F>,\n  select: (result: TypedTransactionResult<C, F>) => Out\n): Promise<Out> {\n  const result = await waitFor(tx);\n  return select(result);\n}\n\n/**\n * Creates a transaction result POJO and immediately waits for events.\n * Convenience wrapper that combines tx() + withEvents() for cleaner controller code.\n * \n * @internal\n * @param waitFor - The waitForTransactionEvents function from context\n * @param input - Transaction details (hash, from, contract, fn)\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param select - Function to extract domain data from typed events\n * @returns The domain-specific result\n */\nexport async function txWithEvents<\n  C extends Contract,\n  F extends Fn<C>,\n  Out\n>(\n  waitFor: (tx: TransactionResult<C, F>) => Promise<TypedTransactionResult<C, F>>,\n  input: {\n    hash: `0x${string}`;\n    from: `0x${string}`;\n    contract: C;\n    fn: F;\n  },\n  select: (result: TypedTransactionResult<C, F>) => Out\n): Promise<Out> {\n  const txResult = tx(input);\n  return withEvents(waitFor, txResult, select);\n}\n\n/**\n * Helper for methods that submit transactions via relayer.\n * Returns the TransactionResult POJO for two-step processing.\n * \n * @internal\n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @returns TransactionResult POJO for external waiting\n */\nexport function txForRelayed<C extends Contract, F extends Fn<C>>(\n  input: {\n    hash: `0x${string}`;\n    from: `0x${string}`;\n    contract: C;\n    fn: F;\n  }\n): TransactionResult<C, F> {\n  return tx(input);\n}"],"mappings":"AASA,SAAS,UAAU;AAWnB,eAAsB,WAKpB,SACAA,KACA,QACc;AACd,QAAM,SAAS,MAAM,QAAQA,GAAE;AAC/B,SAAO,OAAO,MAAM;AACtB;AAgBA,eAAsB,aAKpB,SACA,OAMA,QACc;AACd,QAAM,WAAW,GAAG,KAAK;AACzB,SAAO,WAAW,SAAS,UAAU,MAAM;AAC7C;AAcO,SAAS,aACd,OAMyB;AACzB,SAAO,GAAG,KAAK;AACjB;","names":["tx"]}
+{"version":3,"sources":["../../src/utils/withEvents.ts"],"sourcesContent":["/**\n * Internal helper for controllers to wait for transaction events and extract data.\n * This keeps the POJO system internal while providing simple return values to developers.\n *\n * @internal\n */\n\nimport type {\n  Contract,\n  Fn,\n  TypedTransactionResult,\n} from \"../generated/event-types\";\nimport type { TransactionResult } from \"../types/operations\";\nimport { tx } from \"./transactionHelpers\";\n\n/**\n * Waits for transaction events and transforms them into domain-specific results.\n *\n * @internal\n * @param waitFor - The waitForTransactionEvents function from context\n * @param tx - The transaction result POJO\n * @param select - Function to extract domain data from typed events\n * @returns The domain-specific result\n */\nexport async function withEvents<C extends Contract, F extends Fn<C>, Out>(\n  waitFor: (\n    tx: TransactionResult<C, F>,\n  ) => Promise<TypedTransactionResult<C, F>>,\n  tx: TransactionResult<C, F>,\n  select: (result: TypedTransactionResult<C, F>) => Out,\n): Promise<Out> {\n  const result = await waitFor(tx);\n  return select(result);\n}\n\n/**\n * Creates a transaction result POJO and immediately waits for events.\n * Convenience wrapper that combines tx() + withEvents() for cleaner controller code.\n *\n * @internal\n * @param waitFor - The waitForTransactionEvents function from context\n * @param input - Transaction details (hash, from, contract, fn)\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param select - Function to extract domain data from typed events\n * @returns The domain-specific result\n */\nexport async function txWithEvents<C extends Contract, F extends Fn<C>, Out>(\n  waitFor: (\n    tx: TransactionResult<C, F>,\n  ) => Promise<TypedTransactionResult<C, F>>,\n  input: {\n    hash: `0x${string}`;\n    from: `0x${string}`;\n    contract: C;\n    fn: F;\n  },\n  select: (result: TypedTransactionResult<C, F>) => Out,\n): Promise<Out> {\n  const txResult = tx(input);\n  return withEvents(waitFor, txResult, select);\n}\n\n/**\n * Helper for methods that submit transactions via relayer.\n * Returns the TransactionResult POJO for two-step processing.\n *\n * @internal\n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @returns TransactionResult POJO for external waiting\n */\nexport function txForRelayed<C extends Contract, F extends Fn<C>>(input: {\n  hash: `0x${string}`;\n  from: `0x${string}`;\n  contract: C;\n  fn: F;\n}): TransactionResult<C, F> {\n  return tx(input);\n}\n"],"mappings":"AAaA,SAAS,UAAU;AAWnB,eAAsB,WACpB,SAGAA,KACA,QACc;AACd,QAAM,SAAS,MAAM,QAAQA,GAAE;AAC/B,SAAO,OAAO,MAAM;AACtB;AAgBA,eAAsB,aACpB,SAGA,OAMA,QACc;AACd,QAAM,WAAW,GAAG,KAAK;AACzB,SAAO,WAAW,SAAS,UAAU,MAAM;AAC7C;AAcO,SAAS,aAAkD,OAKtC;AAC1B,SAAO,GAAG,KAAK;AACjB;","names":["tx"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendatalabs/vana-sdk",
-  "version": "0.1.0-alpha.7ee7635",
+  "version": "0.1.0-alpha.8117ac2",
   "description": "A TypeScript library for interacting with Vana Network smart contracts.",
   "publishConfig": {
     "access": "public"
@@ -79,23 +79,26 @@
     "LICENSE"
   ],
   "scripts": {
-    "clean": "rimraf dist",
-    "generate:types": "tsx scripts/generate-types.ts",
-    "generate:types:check": "tsx scripts/generate-types.ts --check",
-    "prebuild": "npm run generate:types:check",
-    "build:types": "tsup 'src/**/*.ts' 'src/**/*.json' '!src/**/*.test.ts' '!src/**/*.spec.ts' '!src/tests/**' --dts-only --out-dir dist --no-clean",
-    "build:node": "tsup 'src/**/*.ts' 'src/**/*.json' '!src/**/*.test.ts' '!src/**/*.spec.ts' '!src/tests/**' --platform node --format esm,cjs --target node18 --out-dir dist --no-clean --no-dts",
+    "clean": "rimraf dist .tsbuildinfo",
+    "validate:platform": "tsx scripts/validate-platform-separation.ts",
+    "validate:entries": "tsx scripts/validate-entry-points.ts",
+    "prebuild": "npm run generate:types:check && npm run validate:platform && npm run validate:entries && npm run validate:types",
+    "build:types": "tsc -p tsconfig.build.json --listEmittedFiles",
+    "build:node": "tsup --config tsup.config.ts",
     "build:browser": "tsup --config tsup-browser.config.ts",
     "build": "npm run clean && npm run build:types && npm run build:node && npm run build:browser",
     "dev": "npm run build -- --watch",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc -p tsconfig.json",
+    "validate:types": "rimraf test-dist && tsc -p tsconfig.build.json --outDir test-dist && test -f test-dist/index.node.d.ts && test -f test-dist/index.browser.d.ts && echo '✅ Type declarations can be generated' && rimraf test-dist || (echo '❌ Failed to generate type declarations' && rimraf test-dist && exit 1)",
     "test": "vitest",
     "test:verbose": "vitest --reporter=verbose",
     "test:coverage": "vitest run --coverage",
     "test:coverage:verbose": "vitest run --coverage --reporter=verbose --coverage.reporter=text",
     "fetch-abis": "tsx scripts/fetch-abis.ts",
+    "generate:types": "tsx scripts/generate-types.ts",
+    "generate:types:check": "tsx scripts/generate-types.ts --check",
     "generate": "npm run fetch-abis && npm run generate:types",
     "fetch-server-types": "tsx scripts/fetch-server-types.ts",
     "codegen:subgraph": "graphql-codegen --config codegen.ts",
@@ -113,29 +116,34 @@
   "dependencies": {
     "@noble/hashes": "^1.8.0",
     "@noble/secp256k1": "^2.3.0",
-    "abitype": "^1.0.8",
+    "abitype": "^1.0.9",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "eccrypto-js": "^5.4.0",
     "graphql": "^16.11.0",
     "openpgp": "^6.1.1",
-    "viem": "^2.31.7"
+    "uuid": "^13.0.0",
+    "viem": "^2.35.1"
   },
   "devDependencies": {
     "@graphql-codegen/cli": "^5.0.7",
     "@graphql-codegen/typed-document-node": "^5.1.2",
     "@graphql-codegen/typescript": "^4.1.6",
     "@graphql-codegen/typescript-operations": "^4.6.1",
-    "@types/node": "^24.0.10",
+    "@types/node": "^24.3.0",
     "@types/secp256k1": "^4.0.6",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
+    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.41.0",
+    "@typescript-eslint/parser": "^8.41.0",
     "@vitest/coverage-v8": "^3.2.4",
     "bundle-require": "^5.1.0",
     "consola": "^3.4.0",
-    "eslint": "^9.26.0",
+    "eslint": "^9.34.0",
     "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-prettier": "^5.4.0",
+    "eslint-plugin-tsdoc": "^0.4.0",
+    "eslint-plugin-unused-imports": "^4.2.0",
     "fix-dts-default-cjs-exports": "^1.0.1",
     "globals": "^16.3.0",
     "openapi-typescript": "^7.8.0",
@@ -143,7 +151,7 @@
     "rimraf": "^6.0.1",
     "tree-kill": "^1.2.2",
     "tsup": "^8.5.0",
-    "tsx": "^4.19.4",
+    "tsx": "^4.20.5",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },
@@ -151,7 +159,7 @@
     "secp256k1": "^5.0.1"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "repository": {
     "type": "git",

package/dist/browser.d.cts

@@ -1,2 +0,0 @@
-export { BrowserPlatformAdapter } from './platform/browser.cjs';
-import './platform/interface.cjs';

package/dist/chains/definitions.d.cts

@@ -1,53 +0,0 @@
-import { Chain } from 'viem';
-
-/**
- * Chain configuration definitions for Vana networks
- *
- * These provide default configurations for known Vana chains.
- * Applications can use these as-is or override specific values.
- */
-
-interface VanaChainConfig extends Chain {
-    /** URL for the subgraph API endpoint used to query on-chain data */
-    subgraphUrl: string;
-}
-/**
- * Vana Mainnet configuration
- */
-declare const vanaMainnet: VanaChainConfig;
-/**
- * Moksha Testnet configuration
- */
-declare const moksha: VanaChainConfig;
-/**
- * Retrieves the chain configuration for a given chain ID.
- *
- * @param chainId - The numeric chain ID to look up
- * @returns The chain configuration if found, undefined otherwise
- * @example
- * ```typescript
- * const config = getChainConfig(1480);
- * if (config) {
- *   console.log('Chain name:', config.name);
- *   console.log('Subgraph URL:', config.subgraphUrl);
- * }
- * ```
- */
-declare function getChainConfig(chainId: number): VanaChainConfig | undefined;
-declare const mokshaTestnet: VanaChainConfig;
-/**
- * Retrieves all available Vana chain configurations.
- *
- * @returns Array of all supported Vana chain configurations
- * @example
- * ```typescript
- * const chains = getAllChains();
- * console.log('Supported chains:');
- * chains.forEach(chain => {
- *   console.log(`- ${chain.name} (ID: ${chain.id})`);
- * });
- * ```
- */
-declare function getAllChains(): VanaChainConfig[];
-
-export { type VanaChainConfig, getAllChains, getChainConfig, moksha, mokshaTestnet, vanaMainnet };

package/dist/chains/index.d.cts

@@ -1,2 +0,0 @@
-export { VanaChainConfig, getAllChains, getChainConfig, moksha, mokshaTestnet, vanaMainnet } from './definitions.cjs';
-import 'viem';