@opendatalabs/vana-sdk 2.3.0 → 3.0.1

package/dist/utils/typedDataConverter.cjs

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

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

@@ -1,46 +0,0 @@
-/**
- * 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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,44 +0,0 @@
-"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 withEvents_exports = {};
-__export(withEvents_exports, {
-  txForRelayed: () => txForRelayed,
-  txWithEvents: () => txWithEvents,
-  withEvents: () => withEvents
-});
-module.exports = __toCommonJS(withEvents_exports);
-var import_transactionHelpers = require("./transactionHelpers");
-async function withEvents(waitFor, tx2, select) {
-  const result = await waitFor(tx2);
-  return select(result);
-}
-async function txWithEvents(waitFor, input, select) {
-  const txResult = (0, import_transactionHelpers.tx)(input);
-  return withEvents(waitFor, txResult, select);
-}
-function txForRelayed(input) {
-  return (0, import_transactionHelpers.tx)(input);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  txForRelayed,
-  txWithEvents,
-  withEvents
-});
-//# sourceMappingURL=withEvents.cjs.map

package/dist/utils/withEvents.cjs.map

@@ -1 +0,0 @@
-{"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,56 +0,0 @@
-/**
- * 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.
- *
- * @internal
- * @param waitFor - The waitForTransactionEvents function from context
- * @param tx - The transaction result POJO
- * @param select - Function to extract domain data from typed events
- * @returns The domain-specific result
- */
-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.
- *
- * @internal
- * @param waitFor - The waitForTransactionEvents function from context
- * @param input - Transaction details (hash, from, contract, fn)
- * @param input.hash - Transaction hash
- * @param input.from - Transaction sender address
- * @param input.contract - Contract name
- * @param input.fn - Function name
- * @param select - Function to extract domain data from typed events
- * @returns The domain-specific result
- */
-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;
-    fn: F;
-}, select: (result: TypedTransactionResult<C, F>) => Out): Promise<Out>;
-/**
- * Helper for methods that submit transactions via relayer.
- * Returns the TransactionResult POJO for two-step processing.
- *
- * @internal
- * @param input - Transaction details
- * @param input.hash - Transaction hash
- * @param input.from - Transaction sender address
- * @param input.contract - Contract name
- * @param input.fn - Function name
- * @returns TransactionResult POJO for external waiting
- */
-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>;

package/dist/utils/withEvents.js

@@ -1,18 +0,0 @@
-import { tx } from "./transactionHelpers";
-async function withEvents(waitFor, tx2, select) {
-  const result = await waitFor(tx2);
-  return select(result);
-}
-async function txWithEvents(waitFor, input, select) {
-  const txResult = tx(input);
-  return withEvents(waitFor, txResult, select);
-}
-function txForRelayed(input) {
-  return tx(input);
-}
-export {
-  txForRelayed,
-  txWithEvents,
-  withEvents
-};
-//# sourceMappingURL=withEvents.js.map