@opendatalabs/vana-sdk 0.1.0-alpha.ffe4659 → 2.1.0

package/dist/utils/typeGuards.js

@@ -0,0 +1,74 @@
+function assertDefined(value, message) {
+  if (value === void 0 || value === null) {
+    throw new Error(message);
+  }
+}
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function assertNonEmptyString(value, message) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(message);
+  }
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function safeGet(obj, key) {
+  return obj?.[key];
+}
+function ensureDefault(value, defaultValue) {
+  return isDefined(value) ? value : defaultValue;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function safeArrayAccess(array, index) {
+  if (!array || index < 0 || index >= array.length) {
+    return void 0;
+  }
+  return array[index];
+}
+function hasProperty(obj, prop) {
+  return isObject(obj) && prop in obj;
+}
+function assertHasProperties(obj, properties, message) {
+  if (!isObject(obj)) {
+    throw new Error(`${message}: Value is not an object`);
+  }
+  for (const prop of properties) {
+    if (!(prop in obj)) {
+      throw new Error(`${message}: Missing required property '${prop}'`);
+    }
+  }
+}
+function ensureError(error, fallbackMessage) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (isObject(error) && "message" in error && typeof error.message === "string") {
+    return new Error(error.message);
+  }
+  return new Error(fallbackMessage);
+}
+export {
+  assertDefined,
+  assertHasProperties,
+  assertNonEmptyString,
+  ensureDefault,
+  ensureError,
+  hasProperty,
+  isArray,
+  isDefined,
+  isNonEmptyString,
+  isObject,
+  safeArrayAccess,
+  safeGet
+};
+//# sourceMappingURL=typeGuards.js.map

package/dist/utils/typeGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/typeGuards.ts"],"sourcesContent":["/**\n * Type guard utilities for runtime type checking and assertions.\n * These utilities provide type-safe alternatives to non-null assertions (!).\n *\n * @module typeGuards\n */\n\n/**\n * Asserts that a value is defined (not null or undefined).\n * Throws an error with a descriptive message if the assertion fails.\n *\n * @param value - The value to check\n * @param message - Error message to throw if value is not defined\n * @throws {Error} If value is null or undefined\n *\n * @example\n * ```typescript\n * const wallet = getWallet();\n * assertDefined(wallet, 'Wallet must be initialized before use');\n * // TypeScript now knows wallet is defined\n * console.log(wallet.address);\n * ```\n */\nexport function assertDefined<T>(\n  value: T | undefined | null,\n  message: string,\n): asserts value is T {\n  if (value === undefined || value === null) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Type guard to check if a value is defined (not null or undefined).\n *\n * @param value - The value to check\n * @returns True if the value is defined, false otherwise\n *\n * @example\n * ```typescript\n * const values = [1, undefined, 3, null, 5];\n * const defined = values.filter(isDefined); // [1, 3, 5]\n * ```\n */\nexport function isDefined<T>(value: T | undefined | null): value is T {\n  return value !== undefined && value !== null;\n}\n\n/**\n * Asserts that a value is a non-empty string.\n *\n * @param value - The value to check\n * @param message - Error message if assertion fails\n * @throws {Error} If value is not a non-empty string\n */\nexport function assertNonEmptyString(\n  value: unknown,\n  message: string,\n): asserts value is string {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Type guard to check if a value is a non-empty string.\n *\n * @param value - The value to check\n * @returns True if value is a non-empty string\n */\nexport function isNonEmptyString(value: unknown): value is string {\n  return typeof value === \"string\" && value.trim().length > 0;\n}\n\n/**\n * Safely gets a property from an object, returning undefined if the property doesn't exist.\n *\n * @param obj - The object to get the property from\n * @param key - The property key\n * @returns The property value or undefined\n *\n * @example\n * ```typescript\n * const config = { wallet: { address: '0x123' } };\n * const address = safeGet(config, 'wallet')?.address;\n * ```\n */\nexport function safeGet<T, K extends keyof T>(\n  obj: T | undefined | null,\n  key: K,\n): T[K] | undefined {\n  return obj?.[key];\n}\n\n/**\n * Ensures a value is defined or returns a default value.\n *\n * @param value - The value to check\n * @param defaultValue - The default value to use if undefined\n * @returns The value if defined, otherwise the default\n *\n * @example\n * ```typescript\n * const timeout = ensureDefault(config.timeout, 5000);\n * ```\n */\nexport function ensureDefault<T>(\n  value: T | undefined | null,\n  defaultValue: T,\n): T {\n  return isDefined(value) ? value : defaultValue;\n}\n\n/**\n * Type guard for checking if a value is an object (and not null).\n *\n * @param value - The value to check\n * @returns True if value is an object\n */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n\n/**\n * Type guard for checking if a value is an array.\n *\n * @param value - The value to check\n * @returns True if value is an array\n */\nexport function isArray<T = unknown>(value: unknown): value is T[] {\n  return Array.isArray(value);\n}\n\n/**\n * Safely accesses an array element, returning undefined if out of bounds.\n *\n * @param array - The array to access\n * @param index - The index to access\n * @returns The element at the index or undefined\n *\n * @example\n * ```typescript\n * const items = [1, 2, 3];\n * const item = safeArrayAccess(items, 5); // undefined\n * ```\n */\nexport function safeArrayAccess<T>(\n  array: T[] | undefined | null,\n  index: number,\n): T | undefined {\n  if (!array || index < 0 || index >= array.length) {\n    return undefined;\n  }\n  return array[index];\n}\n\n/**\n * Type guard to check if a value has a specific property.\n *\n * @param obj - The object to check\n * @param prop - The property name\n * @returns True if the object has the property\n *\n * @example\n * ```typescript\n * if (hasProperty(response, 'error')) {\n *   console.error(response.error);\n * }\n * ```\n */\nexport function hasProperty<T extends string>(\n  obj: unknown,\n  prop: T,\n): obj is Record<T, unknown> {\n  return isObject(obj) && prop in obj;\n}\n\n/**\n * Asserts that an object has required properties.\n *\n * @param obj - The object to check\n * @param properties - Array of required property names\n * @param message - Error message if assertion fails\n * @throws {Error} If any required property is missing\n */\nexport function assertHasProperties<T extends string>(\n  obj: unknown,\n  properties: T[],\n  message: string,\n): asserts obj is Record<T, unknown> {\n  if (!isObject(obj)) {\n    throw new Error(`${message}: Value is not an object`);\n  }\n\n  for (const prop of properties) {\n    if (!(prop in obj)) {\n      throw new Error(`${message}: Missing required property '${prop}'`);\n    }\n  }\n}\n\n/**\n * Creates a type-safe error with a guaranteed message.\n *\n * @param error - The error or unknown value\n * @param fallbackMessage - Message to use if error doesn't have one\n * @returns An Error object with a message\n */\nexport function ensureError(error: unknown, fallbackMessage: string): Error {\n  if (error instanceof Error) {\n    return error;\n  }\n  if (typeof error === \"string\") {\n    return new Error(error);\n  }\n  if (\n    isObject(error) &&\n    \"message\" in error &&\n    typeof error.message === \"string\"\n  ) {\n    return new Error(error.message);\n  }\n  return new Error(fallbackMessage);\n}\n"],"mappings":"AAuBO,SAAS,cACd,OACA,SACoB;AACpB,MAAI,UAAU,UAAa,UAAU,MAAM;AACzC,UAAM,IAAI,MAAM,OAAO;AAAA,EACzB;AACF;AAcO,SAAS,UAAa,OAAyC;AACpE,SAAO,UAAU,UAAa,UAAU;AAC1C;AASO,SAAS,qBACd,OACA,SACyB;AACzB,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI,MAAM,OAAO;AAAA,EACzB;AACF;AAQO,SAAS,iBAAiB,OAAiC;AAChE,SAAO,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,SAAS;AAC5D;AAeO,SAAS,QACd,KACA,KACkB;AAClB,SAAO,MAAM,GAAG;AAClB;AAcO,SAAS,cACd,OACA,cACG;AACH,SAAO,UAAU,KAAK,IAAI,QAAQ;AACpC;AAQO,SAAS,SAAS,OAAkD;AACzE,SAAO,OAAO,UAAU,YAAY,UAAU;AAChD;AAQO,SAAS,QAAqB,OAA8B;AACjE,SAAO,MAAM,QAAQ,KAAK;AAC5B;AAeO,SAAS,gBACd,OACA,OACe;AACf,MAAI,CAAC,SAAS,QAAQ,KAAK,SAAS,MAAM,QAAQ;AAChD,WAAO;AAAA,EACT;AACA,SAAO,MAAM,KAAK;AACpB;AAgBO,SAAS,YACd,KACA,MAC2B;AAC3B,SAAO,SAAS,GAAG,KAAK,QAAQ;AAClC;AAUO,SAAS,oBACd,KACA,YACA,SACmC;AACnC,MAAI,CAAC,SAAS,GAAG,GAAG;AAClB,UAAM,IAAI,MAAM,GAAG,OAAO,0BAA0B;AAAA,EACtD;AAEA,aAAW,QAAQ,YAAY;AAC7B,QAAI,EAAE,QAAQ,MAAM;AAClB,YAAM,IAAI,MAAM,GAAG,OAAO,gCAAgC,IAAI,GAAG;AAAA,IACnE;AAAA,EACF;AACF;AASO,SAAS,YAAY,OAAgB,iBAAgC;AAC1E,MAAI,iBAAiB,OAAO;AAC1B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,IAAI,MAAM,KAAK;AAAA,EACxB;AACA,MACE,SAAS,KAAK,KACd,aAAa,SACb,OAAO,MAAM,YAAY,UACzB;AACA,WAAO,IAAI,MAAM,MAAM,OAAO;AAAA,EAChC;AACA,SAAO,IAAI,MAAM,eAAe;AAClC;","names":[]}

package/dist/utils/typedDataConverter.cjs

@@ -0,0 +1,43 @@
+"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 typedDataConverter_exports = {};
+__export(typedDataConverter_exports, {
+  toViemTypedDataDefinition: () => toViemTypedDataDefinition
+});
+module.exports = __toCommonJS(typedDataConverter_exports);
+function toViemTypedDataDefinition(typedData) {
+  const viemTypes = {};
+  for (const [typeName, typeArray] of Object.entries(typedData.types)) {
+    viemTypes[typeName] = typeArray.map((field) => ({
+      name: field.name,
+      type: field.type
+    }));
+  }
+  return {
+    domain: typedData.domain,
+    types: viemTypes,
+    primaryType: typedData.primaryType,
+    message: typedData.message
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toViemTypedDataDefinition
+});
+//# sourceMappingURL=typedDataConverter.cjs.map

package/dist/utils/typedDataConverter.cjs.map

@@ -0,0 +1 @@
+{"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":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;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/typedDataConverter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Provides type-safe conversion between Vana and viem typed data formats.
+ *
+ * @remarks
+ * This module bridges the gap between Vana's generic typed data structure
+ * and viem's strict TypedDataDefinition format, ensuring compatibility
+ * for EIP-712 signature operations.
+ *
+ * @category Utilities
+ * @module typedDataConverter
+ */
+import type { TypedDataDefinition } from "viem";
+import type { GenericTypedData } from "../types/permissions";
+/**
+ * Converts a GenericTypedData object to a viem-compatible TypedDataDefinition.
+ *
+ * @remarks
+ * Transforms Vana's flexible typed data format into viem's strict format
+ * with readonly arrays. This ensures type safety when passing typed data
+ * to viem's `signTypedData` method for EIP-712 signatures.
+ *
+ * @param typedData - The typed data object to convert.
+ *   Obtain from permission operations or server responses.
+ * @returns A properly typed TypedDataDefinition for use with viem
+ *
+ * @example
+ * ```typescript
+ * const vanTypedData: GenericTypedData = {
+ *   domain: { name: 'Vana', version: '1', chainId: 14800 },
+ *   types: {
+ *     Permission: [
+ *       { name: 'grantee', type: 'address' },
+ *       { name: 'operation', type: 'string' }
+ *     ]
+ *   },
+ *   primaryType: 'Permission',
+ *   message: { grantee: '0x...', operation: 'read' }
+ * };
+ *
+ * const viemTypedData = toViemTypedDataDefinition(vanaTypedData);
+ * const signature = await walletClient.signTypedData(viemTypedData);
+ * ```
+ *
+ * @category Utilities
+ */
+export declare function toViemTypedDataDefinition(typedData: GenericTypedData): TypedDataDefinition;

package/dist/utils/typedDataConverter.js

@@ -0,0 +1,19 @@
+function toViemTypedDataDefinition(typedData) {
+  const viemTypes = {};
+  for (const [typeName, typeArray] of Object.entries(typedData.types)) {
+    viemTypes[typeName] = typeArray.map((field) => ({
+      name: field.name,
+      type: field.type
+    }));
+  }
+  return {
+    domain: typedData.domain,
+    types: viemTypes,
+    primaryType: typedData.primaryType,
+    message: typedData.message
+  };
+}
+export {
+  toViemTypedDataDefinition
+};
+//# sourceMappingURL=typedDataConverter.js.map

package/dist/utils/typedDataConverter.js.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,62 @@
+"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 urlResolver_exports = {};
+__export(urlResolver_exports, {
+  UrlResolutionError: () => UrlResolutionError,
+  fetchFromUrl: () => fetchFromUrl
+});
+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;
+    this.cause = cause;
+    this.name = "UrlResolutionError";
+  }
+}
+async function fetchFromUrl(url, downloadRelayer) {
+  try {
+    const response = await (0, import_download.universalFetch)(url, downloadRelayer);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new UrlResolutionError(
+      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : "Unknown error"}`,
+      url,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UrlResolutionError,
+  fetchFromUrl
+});
+//# sourceMappingURL=urlResolver.cjs.map

package/dist/utils/urlResolver.cjs.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,56 @@
+/**
+ * Provides universal URL resolution across multiple protocols.
+ *
+ * @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
+ */
+/**
+ * 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
+ */
+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);
+}
+/**
+ * Fetches and parses JSON data from any supported URL protocol
+ *
+ * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)
+ * @param downloadRelayer - Optional download relayer for CORS bypass
+ * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server
+ * @returns Promise resolving to the parsed JSON data
+ * @throws {UrlResolutionError} When the URL cannot be resolved or parsed
+ *
+ * @example
+ * ```typescript
+ * // Fetch from IPFS
+ * const data = await fetchFromUrl("ipfs://QmXxx...");
+ *
+ * // Fetch from HTTPS
+ * const data = await fetchFromUrl("https://example.com/data.json");
+ *
+ * // Handles protocol conversion internally
+ * const schema = await fetchFromUrl(schemaDefinitionUrl);
+ * ```
+ */
+export declare function fetchFromUrl(url: string, downloadRelayer?: {
+    proxyDownload: (url: string) => Promise<Blob>;
+}): Promise<unknown>;

package/dist/utils/urlResolver.js

@@ -0,0 +1,37 @@
+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;
+    this.cause = cause;
+    this.name = "UrlResolutionError";
+  }
+}
+async function fetchFromUrl(url, downloadRelayer) {
+  try {
+    const response = await universalFetch(url, downloadRelayer);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new UrlResolutionError(
+      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : "Unknown error"}`,
+      url,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+export {
+  UrlResolutionError,
+  fetchFromUrl
+};
+//# sourceMappingURL=urlResolver.js.map

package/dist/utils/urlResolver.js.map

@@ -0,0 +1 @@
+{"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":[]}