@opendatalabs/vana-sdk 0.1.0-alpha.f54fafd → 0.1.0-alpha.fd33fc9

package/dist/utils/urlResolver.cjs

@@ -0,0 +1,55 @@
+"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 {
+  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 * Universal URL resolver for the Vana SDK\n *\n * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)\n * in a consistent, reliable way.\n */\n\nimport { universalFetch } from \"./download\";\n\n/**\n * Error thrown when URL resolution fails\n */\nexport class UrlResolutionError extends Error {\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await 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;AAOA,sBAA+B;AAKxB,MAAM,2BAA2B,MAAM;AAAA,EAC5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,UAAM,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,38 @@
+/**
+ * Universal URL resolver for the Vana SDK
+ *
+ * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)
+ * in a consistent, reliable way.
+ */
+/**
+ * Error thrown when URL resolution fails
+ */
+export declare class UrlResolutionError extends Error {
+    readonly url: string;
+    readonly cause?: Error | undefined;
+    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,30 @@
+import { universalFetch } from "./download";
+class UrlResolutionError extends Error {
+  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 * Universal URL resolver for the Vana SDK\n *\n * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)\n * in a consistent, reliable way.\n */\n\nimport { universalFetch } from \"./download\";\n\n/**\n * Error thrown when URL resolution fails\n */\nexport class UrlResolutionError extends Error {\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await 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":"AAOA,SAAS,sBAAsB;AAKxB,MAAM,2BAA2B,MAAM;AAAA,EAC5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,MAAM,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 * Viem's Account type can be:\n * - A string address directly\n * - An object with an address property\n * - A LocalAccount with address property\n *\n * This utility provides a single source of truth for address extraction,\n * eliminating duplicate logic throughout the codebase.\n *\n * @param account - The account to extract address from\n * @returns The extracted Ethereum address\n * @throws Error if account is undefined or address cannot be determined\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, returning undefined instead of throwing.\n * Useful for optional address resolution.\n *\n * @param account - The account to extract address from\n * @returns The extracted address or undefined\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 * Type guard to check if an account has a valid address.\n *\n * @param account - The account to check\n * @returns True if account has a valid address\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;AAiBO,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;AASO,SAAS,mBACd,SACqB;AACrB,MAAI;AACF,WAAO,eAAe,OAAO;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAQO,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,32 @@
+import type { Account, Address } from "viem";
+/**
+ * Extracts an Ethereum address from various account formats.
+ *
+ * Viem's Account type can be:
+ * - A string address directly
+ * - An object with an address property
+ * - A LocalAccount with address property
+ *
+ * This utility provides a single source of truth for address extraction,
+ * eliminating duplicate logic throughout the codebase.
+ *
+ * @param account - The account to extract address from
+ * @returns The extracted Ethereum address
+ * @throws Error if account is undefined or address cannot be determined
+ */
+export declare function extractAddress(account: Account | Address | undefined | null): Address;
+/**
+ * Safely extracts an address, returning undefined instead of throwing.
+ * Useful for optional address resolution.
+ *
+ * @param account - The account to extract address from
+ * @returns The extracted address or undefined
+ */
+export declare function extractAddressSafe(account: Account | Address | undefined | null): Address | undefined;
+/**
+ * Type guard to check if an account has a valid address.
+ *
+ * @param account - The account to check
+ * @returns True if account has a valid address
+ */
+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 * Viem's Account type can be:\n * - A string address directly\n * - An object with an address property\n * - A LocalAccount with address property\n *\n * This utility provides a single source of truth for address extraction,\n * eliminating duplicate logic throughout the codebase.\n *\n * @param account - The account to extract address from\n * @returns The extracted Ethereum address\n * @throws Error if account is undefined or address cannot be determined\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, returning undefined instead of throwing.\n * Useful for optional address resolution.\n *\n * @param account - The account to extract address from\n * @returns The extracted address or undefined\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 * Type guard to check if an account has a valid address.\n *\n * @param account - The account to check\n * @returns True if account has a valid address\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":"AAiBO,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;AASO,SAAS,mBACd,SACqB;AACrB,MAAI;AACF,WAAO,eAAe,OAAO;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAQO,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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/withEvents.ts"],"sourcesContent":["/**\n * Internal helper for controllers to wait for transaction events and extract data.\n * This keeps the POJO system internal while providing simple return values to developers.\n *\n * @internal\n */\n\nimport type {\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

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

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

package/dist/utils/withEvents.js.map

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

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@opendatalabs/vana-sdk",
-  "version": "0.1.0-alpha.f54fafd",
+  "version": "0.1.0-alpha.fd33fc9",
   "description": "A TypeScript library for interacting with Vana Network smart contracts.",
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
+  "sideEffects": false,
   "main": "dist/index.node.js",
   "types": "dist/index.node.d.ts",
   "exports": {
+    ".": {
+      "browser": {
+        "types": "./dist/index.browser.d.ts",
+        "import": "./dist/index.browser.js"
+      },
+      "types": "./dist/index.node.d.ts",
+      "import": "./dist/index.node.js",
+      "require": "./dist/index.node.cjs"
+    },
     "./browser": {
       "types": "./dist/index.browser.d.ts",
       "import": "./dist/index.browser.js"
@@ -19,15 +29,15 @@
       "require": "./dist/index.node.cjs"
     },
     "./chains": {
+      "browser": {
+        "types": "./dist/chains.browser.d.ts",
+        "import": "./dist/chains.browser.js"
+      },
       "node": {
         "types": "./dist/chains.node.d.ts",
         "import": "./dist/chains.node.js",
         "require": "./dist/chains.node.cjs"
       },
-      "browser": {
-        "import": "./dist/chains.browser.js",
-        "types": "./dist/chains.browser.d.ts"
-      },
       "default": {
         "types": "./dist/chains.node.d.ts",
         "import": "./dist/chains.node.js",
@@ -35,45 +45,61 @@
       }
     },
     "./platform": {
+      "browser": {
+        "types": "./dist/platform.browser.d.ts",
+        "import": "./dist/platform.browser.js"
+      },
       "node": {
         "types": "./dist/platform.node.d.ts",
         "import": "./dist/platform.node.js",
         "require": "./dist/platform.node.cjs"
       },
-      "browser": {
-        "import": "./dist/platform.browser.js",
-        "types": "./dist/platform.browser.d.ts"
-      },
       "default": {
         "types": "./dist/platform.node.d.ts",
         "import": "./dist/platform.node.js",
         "require": "./dist/platform.node.cjs"
       }
+    },
+    "./*": {
+      "browser": {
+        "types": "./dist/*.d.ts",
+        "import": "./dist/*.js"
+      },
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js"
     }
   },
+  "browser": {
+    "secp256k1": false,
+    "crypto": false
+  },
   "files": [
     "dist",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "clean": "rimraf dist",
-    "build:types": "tsup src/index.ts --dts-only --out-dir dist --no-clean",
-    "build:node": "tsup src/index.node.ts --platform node --format esm,cjs --target node18 --out-dir dist --no-clean",
-    "build:browser": "tsup src/index.browser.ts --platform browser --format esm --target es2020 --out-dir dist --dts --no-clean",
-    "build:chains": "tsup src/chains.ts src/chains.node.ts src/chains.browser.ts --platform node --format esm,cjs --target node18 --out-dir dist --dts --no-clean",
-    "build:platform": "tsup src/platform.ts src/platform.node.ts src/node.ts --platform node --format esm,cjs --target node18 --out-dir dist --dts --no-clean && tsup src/platform.browser.ts src/browser.ts --platform browser --format esm --target es2020 --out-dir dist --dts --no-clean",
-    "build": "npm run clean && npm run build:types && npm run build:node && npm run build:browser && npm run build:chains && npm run build:platform",
-    "prepare": "npm run build",
+    "clean": "rimraf dist .tsbuildinfo",
+    "validate:platform": "tsx scripts/validate-platform-separation.ts",
+    "validate:entries": "tsx scripts/validate-entry-points.ts",
+    "prebuild": "npm run generate:types:check && npm run validate:platform && npm run validate:entries && npm run validate:types",
+    "build:types": "tsc -p tsconfig.build.json --listEmittedFiles",
+    "build:node": "tsup --config tsup.config.ts",
+    "build:browser": "tsup --config tsup-browser.config.ts",
+    "build": "npm run clean && npm run build:types && npm run build:node && npm run build:browser",
     "dev": "npm run build -- --watch",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc -p tsconfig.json",
+    "validate:types": "rimraf test-dist && tsc -p tsconfig.build.json --outDir test-dist && test -f test-dist/index.node.d.ts && test -f test-dist/index.browser.d.ts && echo '✅ Type declarations can be generated' && rimraf test-dist || (echo '❌ Failed to generate type declarations' && rimraf test-dist && exit 1)",
     "test": "vitest",
     "test:verbose": "vitest --reporter=verbose",
     "test:coverage": "vitest run --coverage",
     "test:coverage:verbose": "vitest run --coverage --reporter=verbose --coverage.reporter=text",
     "fetch-abis": "tsx scripts/fetch-abis.ts",
+    "generate:types": "tsx scripts/generate-types.ts",
+    "generate:types:check": "tsx scripts/generate-types.ts --check",
+    "generate": "npm run fetch-abis && npm run generate:types",
     "fetch-server-types": "tsx scripts/fetch-server-types.ts",
     "codegen:subgraph": "graphql-codegen --config codegen.ts",
     "codegen:subgraph:moksha": "VANA_CODEGEN_NETWORK=moksha graphql-codegen --config codegen.ts",
@@ -88,31 +114,34 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "abitype": "^1.0.8",
+    "@noble/hashes": "^1.8.0",
+    "@noble/secp256k1": "^2.3.0",
+    "abitype": "^1.0.9",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
-    "eccrypto": "^1.1.6",
     "eccrypto-js": "^5.4.0",
     "graphql": "^16.11.0",
     "openpgp": "^6.1.1",
-    "viem": "^2.31.7"
+    "viem": "^2.35.1"
   },
   "devDependencies": {
     "@graphql-codegen/cli": "^5.0.7",
     "@graphql-codegen/typed-document-node": "^5.1.2",
     "@graphql-codegen/typescript": "^4.1.6",
     "@graphql-codegen/typescript-operations": "^4.6.1",
-    "@types/eccrypto": "^1.1.6",
-    "@types/node": "^24.0.10",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
+    "@types/node": "^24.3.0",
+    "@types/secp256k1": "^4.0.6",
+    "@typescript-eslint/eslint-plugin": "^8.41.0",
+    "@typescript-eslint/parser": "^8.41.0",
     "@vitest/coverage-v8": "^3.2.4",
     "bundle-require": "^5.1.0",
     "consola": "^3.4.0",
-    "eccrypto": "^1.1.6",
-    "eslint": "^9.26.0",
+    "eslint": "^9.34.0",
     "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-prettier": "^5.4.0",
+    "eslint-plugin-tsdoc": "^0.4.0",
+    "eslint-plugin-unused-imports": "^4.2.0",
     "fix-dts-default-cjs-exports": "^1.0.1",
     "globals": "^16.3.0",
     "openapi-typescript": "^7.8.0",
@@ -120,12 +149,15 @@
     "rimraf": "^6.0.1",
     "tree-kill": "^1.2.2",
     "tsup": "^8.5.0",
-    "tsx": "^4.19.4",
+    "tsx": "^4.20.5",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },
+  "optionalDependencies": {
+    "secp256k1": "^5.0.1"
+  },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "repository": {
     "type": "git",