@opendatalabs/vana-sdk 0.1.0-alpha.d6bebb0 → 0.1.0-alpha.d7fc764

package/dist/utils/signatureFormatter.cjs

@@ -0,0 +1,45 @@
+"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 signatureFormatter_exports = {};
+__export(signatureFormatter_exports, {
+  formatSignatureForContract: () => formatSignatureForContract
+});
+module.exports = __toCommonJS(signatureFormatter_exports);
+const V_OFFSET_FOR_ETHEREUM = 27;
+function formatSignatureForContract(signature) {
+  const cleanSig = signature.startsWith("0x") ? signature.slice(2) : signature;
+  if (cleanSig.length !== 130) {
+    return signature;
+  }
+  const vHex = cleanSig.slice(128, 130);
+  const v = parseInt(vHex, 16);
+  if (isNaN(v)) {
+    return signature;
+  }
+  if (v < 27) {
+    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, "0");
+    return `0x${cleanSig.slice(0, 128)}${adjustedV}`;
+  }
+  return signature;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatSignatureForContract
+});
+//# sourceMappingURL=signatureFormatter.cjs.map

package/dist/utils/signatureFormatter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/signatureFormatter.ts"],"sourcesContent":["import type { Hash } from \"viem\";\n\nconst V_OFFSET_FOR_ETHEREUM = 27;\n\n/**\n * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.\n *\n * @remarks\n * This function ensures signature compatibility with Ethereum smart contracts by adjusting\n * the v-value component of ECDSA signatures. Some wallet implementations and signing methods\n * produce signatures with v-values in the range [0, 1], while Ethereum smart contracts\n * expect v-values in the range [27, 28] for proper signature verification.\n *\n * The function automatically detects signatures with low v-values and applies the standard\n * Ethereum offset (+27) to ensure compatibility. This is particularly important for gasless\n * transactions and EIP-712 signature verification in smart contracts.\n *\n * **Technical Details:**\n * - Ethereum signatures consist of r (32 bytes) + s (32 bytes) + v (1 byte) = 65 bytes total\n * - Valid v-values for Ethereum are 27 or 28 (or 0/1 + chain-specific offset for EIP-155)\n * - This function handles the common case where v ∈ [0, 1] needs adjustment to [27, 28]\n *\n * @param signature - The ECDSA signature hash to format (65 bytes as hex string)\n * @returns The formatted signature with correct v-value for Ethereum contract verification\n * @example\n * ```typescript\n * // Signature with v-value that needs adjustment\n * const rawSignature = \"0x1234...5600\"; // v = 0 (last byte)\n * const formatted = formatSignatureForContract(rawSignature);\n * // Result: \"0x1234...561b\" // v = 27 (0x1b)\n *\n * // Already properly formatted signature remains unchanged\n * const goodSignature = \"0x1234...561b\"; // v = 27\n * const unchanged = formatSignatureForContract(goodSignature);\n * // Result: \"0x1234...561b\" (no change needed)\n * ```\n * @category Cryptography\n */\nexport function formatSignatureForContract(signature: Hash): Hash {\n  const cleanSig = signature.startsWith(\"0x\") ? signature.slice(2) : signature;\n\n  if (cleanSig.length !== 130) {\n    return signature;\n  }\n\n  const vHex = cleanSig.slice(128, 130);\n  const v = parseInt(vHex, 16);\n\n  if (isNaN(v)) {\n    return signature;\n  }\n\n  if (v < 27) {\n    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, \"0\");\n    return `0x${cleanSig.slice(0, 128)}${adjustedV}` as Hash;\n  }\n\n  return signature;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,MAAM,wBAAwB;AAoCvB,SAAS,2BAA2B,WAAuB;AAChE,QAAM,WAAW,UAAU,WAAW,IAAI,IAAI,UAAU,MAAM,CAAC,IAAI;AAEnE,MAAI,SAAS,WAAW,KAAK;AAC3B,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,SAAS,MAAM,KAAK,GAAG;AACpC,QAAM,IAAI,SAAS,MAAM,EAAE;AAE3B,MAAI,MAAM,CAAC,GAAG;AACZ,WAAO;AAAA,EACT;AAEA,MAAI,IAAI,IAAI;AACV,UAAM,aAAa,IAAI,uBAAuB,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1E,WAAO,KAAK,SAAS,MAAM,GAAG,GAAG,CAAC,GAAG,SAAS;AAAA,EAChD;AAEA,SAAO;AACT;","names":[]}

package/dist/utils/signatureFormatter.d.cts

@@ -0,0 +1,39 @@
+import { Hash } from 'viem';
+
+/**
+ * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.
+ *
+ * @remarks
+ * This function ensures signature compatibility with Ethereum smart contracts by adjusting
+ * the v-value component of ECDSA signatures. Some wallet implementations and signing methods
+ * produce signatures with v-values in the range [0, 1], while Ethereum smart contracts
+ * expect v-values in the range [27, 28] for proper signature verification.
+ *
+ * The function automatically detects signatures with low v-values and applies the standard
+ * Ethereum offset (+27) to ensure compatibility. This is particularly important for gasless
+ * transactions and EIP-712 signature verification in smart contracts.
+ *
+ * **Technical Details:**
+ * - Ethereum signatures consist of r (32 bytes) + s (32 bytes) + v (1 byte) = 65 bytes total
+ * - Valid v-values for Ethereum are 27 or 28 (or 0/1 + chain-specific offset for EIP-155)
+ * - This function handles the common case where v ∈ [0, 1] needs adjustment to [27, 28]
+ *
+ * @param signature - The ECDSA signature hash to format (65 bytes as hex string)
+ * @returns The formatted signature with correct v-value for Ethereum contract verification
+ * @example
+ * ```typescript
+ * // Signature with v-value that needs adjustment
+ * const rawSignature = "0x1234...5600"; // v = 0 (last byte)
+ * const formatted = formatSignatureForContract(rawSignature);
+ * // Result: "0x1234...561b" // v = 27 (0x1b)
+ *
+ * // Already properly formatted signature remains unchanged
+ * const goodSignature = "0x1234...561b"; // v = 27
+ * const unchanged = formatSignatureForContract(goodSignature);
+ * // Result: "0x1234...561b" (no change needed)
+ * ```
+ * @category Cryptography
+ */
+declare function formatSignatureForContract(signature: Hash): Hash;
+
+export { formatSignatureForContract };

package/dist/utils/signatureFormatter.d.ts

@@ -0,0 +1,39 @@
+import { Hash } from 'viem';
+
+/**
+ * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.
+ *
+ * @remarks
+ * This function ensures signature compatibility with Ethereum smart contracts by adjusting
+ * the v-value component of ECDSA signatures. Some wallet implementations and signing methods
+ * produce signatures with v-values in the range [0, 1], while Ethereum smart contracts
+ * expect v-values in the range [27, 28] for proper signature verification.
+ *
+ * The function automatically detects signatures with low v-values and applies the standard
+ * Ethereum offset (+27) to ensure compatibility. This is particularly important for gasless
+ * transactions and EIP-712 signature verification in smart contracts.
+ *
+ * **Technical Details:**
+ * - Ethereum signatures consist of r (32 bytes) + s (32 bytes) + v (1 byte) = 65 bytes total
+ * - Valid v-values for Ethereum are 27 or 28 (or 0/1 + chain-specific offset for EIP-155)
+ * - This function handles the common case where v ∈ [0, 1] needs adjustment to [27, 28]
+ *
+ * @param signature - The ECDSA signature hash to format (65 bytes as hex string)
+ * @returns The formatted signature with correct v-value for Ethereum contract verification
+ * @example
+ * ```typescript
+ * // Signature with v-value that needs adjustment
+ * const rawSignature = "0x1234...5600"; // v = 0 (last byte)
+ * const formatted = formatSignatureForContract(rawSignature);
+ * // Result: "0x1234...561b" // v = 27 (0x1b)
+ *
+ * // Already properly formatted signature remains unchanged
+ * const goodSignature = "0x1234...561b"; // v = 27
+ * const unchanged = formatSignatureForContract(goodSignature);
+ * // Result: "0x1234...561b" (no change needed)
+ * ```
+ * @category Cryptography
+ */
+declare function formatSignatureForContract(signature: Hash): Hash;
+
+export { formatSignatureForContract };

package/dist/utils/signatureFormatter.js

@@ -0,0 +1,21 @@
+const V_OFFSET_FOR_ETHEREUM = 27;
+function formatSignatureForContract(signature) {
+  const cleanSig = signature.startsWith("0x") ? signature.slice(2) : signature;
+  if (cleanSig.length !== 130) {
+    return signature;
+  }
+  const vHex = cleanSig.slice(128, 130);
+  const v = parseInt(vHex, 16);
+  if (isNaN(v)) {
+    return signature;
+  }
+  if (v < 27) {
+    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, "0");
+    return `0x${cleanSig.slice(0, 128)}${adjustedV}`;
+  }
+  return signature;
+}
+export {
+  formatSignatureForContract
+};
+//# sourceMappingURL=signatureFormatter.js.map

package/dist/utils/signatureFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/signatureFormatter.ts"],"sourcesContent":["import type { Hash } from \"viem\";\n\nconst V_OFFSET_FOR_ETHEREUM = 27;\n\n/**\n * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.\n *\n * @remarks\n * This function ensures signature compatibility with Ethereum smart contracts by adjusting\n * the v-value component of ECDSA signatures. Some wallet implementations and signing methods\n * produce signatures with v-values in the range [0, 1], while Ethereum smart contracts\n * expect v-values in the range [27, 28] for proper signature verification.\n *\n * The function automatically detects signatures with low v-values and applies the standard\n * Ethereum offset (+27) to ensure compatibility. This is particularly important for gasless\n * transactions and EIP-712 signature verification in smart contracts.\n *\n * **Technical Details:**\n * - Ethereum signatures consist of r (32 bytes) + s (32 bytes) + v (1 byte) = 65 bytes total\n * - Valid v-values for Ethereum are 27 or 28 (or 0/1 + chain-specific offset for EIP-155)\n * - This function handles the common case where v ∈ [0, 1] needs adjustment to [27, 28]\n *\n * @param signature - The ECDSA signature hash to format (65 bytes as hex string)\n * @returns The formatted signature with correct v-value for Ethereum contract verification\n * @example\n * ```typescript\n * // Signature with v-value that needs adjustment\n * const rawSignature = \"0x1234...5600\"; // v = 0 (last byte)\n * const formatted = formatSignatureForContract(rawSignature);\n * // Result: \"0x1234...561b\" // v = 27 (0x1b)\n *\n * // Already properly formatted signature remains unchanged\n * const goodSignature = \"0x1234...561b\"; // v = 27\n * const unchanged = formatSignatureForContract(goodSignature);\n * // Result: \"0x1234...561b\" (no change needed)\n * ```\n * @category Cryptography\n */\nexport function formatSignatureForContract(signature: Hash): Hash {\n  const cleanSig = signature.startsWith(\"0x\") ? signature.slice(2) : signature;\n\n  if (cleanSig.length !== 130) {\n    return signature;\n  }\n\n  const vHex = cleanSig.slice(128, 130);\n  const v = parseInt(vHex, 16);\n\n  if (isNaN(v)) {\n    return signature;\n  }\n\n  if (v < 27) {\n    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, \"0\");\n    return `0x${cleanSig.slice(0, 128)}${adjustedV}` as Hash;\n  }\n\n  return signature;\n}\n"],"mappings":"AAEA,MAAM,wBAAwB;AAoCvB,SAAS,2BAA2B,WAAuB;AAChE,QAAM,WAAW,UAAU,WAAW,IAAI,IAAI,UAAU,MAAM,CAAC,IAAI;AAEnE,MAAI,SAAS,WAAW,KAAK;AAC3B,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,SAAS,MAAM,KAAK,GAAG;AACpC,QAAM,IAAI,SAAS,MAAM,EAAE;AAE3B,MAAI,MAAM,CAAC,GAAG;AACZ,WAAO;AAAA,EACT;AAEA,MAAI,IAAI,IAAI;AACV,UAAM,aAAa,IAAI,uBAAuB,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1E,WAAO,KAAK,SAAS,MAAM,GAAG,GAAG,CAAC,GAAG,SAAS;AAAA,EAChD;AAEA,SAAO;AACT;","names":[]}

package/dist/utils/transactionParsing.cjs

@@ -0,0 +1,84 @@
+"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 transactionParsing_exports = {};
+__export(transactionParsing_exports, {
+  parseTransactionResult: () => parseTransactionResult
+});
+module.exports = __toCommonJS(transactionParsing_exports);
+var import_viem = require("viem");
+var import_eventMappings = require("../config/eventMappings");
+var import_abi = require("../generated/abi");
+var import_errors = require("../errors");
+async function parseTransactionResult(context, hash, operation) {
+  const mapping = import_eventMappings.EVENT_MAPPINGS[operation];
+  try {
+    console.debug(`\u{1F50D} Parsing ${operation} transaction: ${hash}`);
+    const receipt = await context.publicClient.waitForTransactionReceipt({
+      hash,
+      timeout: 3e4
+      // 30 second timeout
+    });
+    console.debug(`\u2705 Transaction confirmed in block ${receipt.blockNumber}`);
+    const abi = (0, import_abi.getAbi)(mapping.contract);
+    const events = (0, import_viem.parseEventLogs)({
+      logs: receipt.logs,
+      abi,
+      eventName: mapping.event,
+      strict: true
+      // Only return logs that conform to the ABI
+    });
+    if (events.length === 0) {
+      throw new import_errors.BlockchainError(
+        `No ${mapping.event} event found in transaction ${hash}. Transaction may have failed or reverted.`
+      );
+    }
+    if (events.length > 1) {
+      console.warn(
+        `\u26A0\uFE0F  Multiple ${mapping.event} events found in transaction ${hash}. Using the first one.`
+      );
+    }
+    const event = events[0];
+    console.debug(`\u{1F389} Found ${mapping.event} event with args:`, event.args);
+    return {
+      ...event.args,
+      transactionHash: hash,
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.gasUsed
+    };
+  } catch (error) {
+    if (error instanceof import_errors.BlockchainError || error instanceof import_errors.NetworkError) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.includes("timeout")) {
+      throw new import_errors.NetworkError(
+        `Transaction ${hash} confirmation timeout after 30 seconds. The transaction may still be pending.`,
+        error
+      );
+    }
+    throw new import_errors.BlockchainError(
+      `Failed to parse ${operation} transaction ${hash}: ${error instanceof Error ? error.message : "Unknown error"}`,
+      error
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseTransactionResult
+});
+//# sourceMappingURL=transactionParsing.cjs.map

package/dist/utils/transactionParsing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/transactionParsing.ts"],"sourcesContent":["import { parseEventLogs } from \"viem\";\nimport type { Hash } from \"viem\";\nimport {\n  EVENT_MAPPINGS,\n  type TransactionOperation,\n} from \"../config/eventMappings\";\nimport { getAbi } from \"../generated/abi\";\nimport type { ControllerContext } from \"../controllers/permissions\";\nimport { BlockchainError, NetworkError } from \"../errors\";\nimport type { TransactionResultMap } from \"../types/transactionResults\";\n\n/**\n * Base interface for all transaction results.\n * Contains the event data plus transaction metadata.\n */\nexport interface BaseTransactionResult {\n  transactionHash: Hash;\n  blockNumber: bigint;\n  gasUsed: bigint;\n}\n\n/**\n * Generic transaction result parser that extracts event data from transaction receipts.\n *\n * This utility provides a consistent way to parse blockchain events from completed\n * transactions across all SDK controllers. It handles receipt fetching, event parsing,\n * error handling, and result formatting automatically.\n *\n * @param context - Controller context containing blockchain clients\n * @param hash - Transaction hash to parse\n * @param operation - SDK operation name (maps to contract/event via EVENT_MAPPINGS)\n * @returns Promise resolving to event args plus transaction metadata\n * @throws {NetworkError} When transaction receipt cannot be fetched\n * @throws {BlockchainError} When expected event is not found in transaction\n *\n * @example\n * ```typescript\n * // Parse a permission grant transaction\n * const result = await parseTransactionResult(context, txHash, 'grant');\n * console.log(`Permission ${result.permissionId} granted to ${result.user}`);\n *\n * // Parse a file addition transaction\n * const result = await parseTransactionResult(context, txHash, 'addFile');\n * console.log(`File ${result.fileId} added at ${result.url}`);\n * ```\n */\nexport async function parseTransactionResult<K extends TransactionOperation>(\n  context: ControllerContext,\n  hash: Hash,\n  operation: K,\n): Promise<TransactionResultMap[K]> {\n  const mapping = EVENT_MAPPINGS[operation];\n\n  try {\n    // Wait for transaction confirmation\n    console.debug(`🔍 Parsing ${operation} transaction: ${hash}`);\n\n    const receipt = await context.publicClient.waitForTransactionReceipt({\n      hash,\n      timeout: 30_000, // 30 second timeout\n    });\n\n    console.debug(`✅ Transaction confirmed in block ${receipt.blockNumber}`);\n\n    // Get contract ABI for event parsing\n    const abi = getAbi(mapping.contract);\n\n    // Parse events using viem's parseEventLogs\n    const events = parseEventLogs({\n      logs: receipt.logs,\n      abi,\n      eventName: mapping.event,\n      strict: true, // Only return logs that conform to the ABI\n    });\n\n    // Validate we found the expected event\n    if (events.length === 0) {\n      throw new BlockchainError(\n        `No ${mapping.event} event found in transaction ${hash}. ` +\n          `Transaction may have failed or reverted.`,\n      );\n    }\n\n    if (events.length > 1) {\n      console.warn(\n        `⚠️  Multiple ${mapping.event} events found in transaction ${hash}. Using the first one.`,\n      );\n    }\n\n    const event = events[0];\n    console.debug(`🎉 Found ${mapping.event} event with args:`, event.args);\n\n    // Return event args plus transaction metadata\n    return {\n      ...event.args,\n      transactionHash: hash,\n      blockNumber: receipt.blockNumber,\n      gasUsed: receipt.gasUsed,\n    } as TransactionResultMap[K];\n  } catch (error) {\n    // Re-throw known Vana errors directly\n    if (error instanceof BlockchainError || error instanceof NetworkError) {\n      throw error;\n    }\n\n    // Handle timeout errors specifically\n    if (error instanceof Error && error.message.includes(\"timeout\")) {\n      throw new NetworkError(\n        `Transaction ${hash} confirmation timeout after 30 seconds. ` +\n          `The transaction may still be pending.`,\n        error,\n      );\n    }\n\n    // Wrap unknown errors\n    throw new BlockchainError(\n      `Failed to parse ${operation} transaction ${hash}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA+B;AAE/B,2BAGO;AACP,iBAAuB;AAEvB,oBAA8C;AAsC9C,eAAsB,uBACpB,SACA,MACA,WACkC;AAClC,QAAM,UAAU,oCAAe,SAAS;AAExC,MAAI;AAEF,YAAQ,MAAM,qBAAc,SAAS,iBAAiB,IAAI,EAAE;AAE5D,UAAM,UAAU,MAAM,QAAQ,aAAa,0BAA0B;AAAA,MACnE;AAAA,MACA,SAAS;AAAA;AAAA,IACX,CAAC;AAED,YAAQ,MAAM,yCAAoC,QAAQ,WAAW,EAAE;AAGvE,UAAM,UAAM,mBAAO,QAAQ,QAAQ;AAGnC,UAAM,aAAS,4BAAe;AAAA,MAC5B,MAAM,QAAQ;AAAA,MACd;AAAA,MACA,WAAW,QAAQ;AAAA,MACnB,QAAQ;AAAA;AAAA,IACV,CAAC;AAGD,QAAI,OAAO,WAAW,GAAG;AACvB,YAAM,IAAI;AAAA,QACR,MAAM,QAAQ,KAAK,+BAA+B,IAAI;AAAA,MAExD;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,GAAG;AACrB,cAAQ;AAAA,QACN,0BAAgB,QAAQ,KAAK,gCAAgC,IAAI;AAAA,MACnE;AAAA,IACF;AAEA,UAAM,QAAQ,OAAO,CAAC;AACtB,YAAQ,MAAM,mBAAY,QAAQ,KAAK,qBAAqB,MAAM,IAAI;AAGtE,WAAO;AAAA,MACL,GAAG,MAAM;AAAA,MACT,iBAAiB;AAAA,MACjB,aAAa,QAAQ;AAAA,MACrB,SAAS,QAAQ;AAAA,IACnB;AAAA,EACF,SAAS,OAAO;AAEd,QAAI,iBAAiB,iCAAmB,iBAAiB,4BAAc;AACrE,YAAM;AAAA,IACR;AAGA,QAAI,iBAAiB,SAAS,MAAM,QAAQ,SAAS,SAAS,GAAG;AAC/D,YAAM,IAAI;AAAA,QACR,eAAe,IAAI;AAAA,QAEnB;AAAA,MACF;AAAA,IACF;AAGA,UAAM,IAAI;AAAA,MACR,mBAAmB,SAAS,gBAAgB,IAAI,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MAC7G;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/utils/transactionParsing.d.cts

@@ -0,0 +1,25 @@
+import 'viem';
+import '../config/eventMappings.cjs';
+export { B as BaseTransactionResult, p as parseTransactionResult } from '../permissions-DNKPu_G0.cjs';
+import '../generated/abi/index.cjs';
+import '../generated/abi/DataPortabilityPermissionsImplementation.cjs';
+import '../generated/abi/DataPortabilityServersImplementation.cjs';
+import '../generated/abi/DataPortabilityGranteesImplementation.cjs';
+import '../generated/abi/VanaEpochImplementation.cjs';
+import '../generated/abi/DLPRegistryImplementation.cjs';
+import '../generated/abi/DLPTreasuryImplementation.cjs';
+import '../generated/abi/DLPRewardDeployerTreasuryImplementation.cjs';
+import '../generated/abi/DLPPerformanceImplementation.cjs';
+import '../generated/abi/DLPRewardDeployerImplementation.cjs';
+import '../generated/abi/DLPRootImplementation.cjs';
+import '../generated/abi/DataLiquidityPoolImplementation.cjs';
+import '../generated/abi/DLPRegistryTreasuryImplementation.cjs';
+import '../types/operations.cjs';
+import '../generated/server/server-exports.cjs';
+import '../generated/server/server.cjs';
+import '../types/config.cjs';
+import '../types/chains.cjs';
+import '../types/storage.cjs';
+import '../types/permissions.cjs';
+import '../storage/manager.cjs';
+import '../platform/interface.cjs';

package/dist/utils/transactionParsing.d.ts

@@ -0,0 +1,25 @@
+import 'viem';
+import '../config/eventMappings.js';
+export { B as BaseTransactionResult, p as parseTransactionResult } from '../permissions-eo8YeLGf.js';
+import '../generated/abi/index.js';
+import '../generated/abi/DataPortabilityPermissionsImplementation.js';
+import '../generated/abi/DataPortabilityServersImplementation.js';
+import '../generated/abi/DataPortabilityGranteesImplementation.js';
+import '../generated/abi/VanaEpochImplementation.js';
+import '../generated/abi/DLPRegistryImplementation.js';
+import '../generated/abi/DLPTreasuryImplementation.js';
+import '../generated/abi/DLPRewardDeployerTreasuryImplementation.js';
+import '../generated/abi/DLPPerformanceImplementation.js';
+import '../generated/abi/DLPRewardDeployerImplementation.js';
+import '../generated/abi/DLPRootImplementation.js';
+import '../generated/abi/DataLiquidityPoolImplementation.js';
+import '../generated/abi/DLPRegistryTreasuryImplementation.js';
+import '../types/operations.js';
+import '../generated/server/server-exports.js';
+import '../generated/server/server.js';
+import '../types/config.js';
+import '../types/chains.js';
+import '../types/storage.js';
+import '../types/permissions.js';
+import '../storage/manager.js';
+import '../platform/interface.js';

package/dist/utils/transactionParsing.js

@@ -0,0 +1,62 @@
+import { parseEventLogs } from "viem";
+import {
+  EVENT_MAPPINGS
+} from "../config/eventMappings";
+import { getAbi } from "../generated/abi";
+import { BlockchainError, NetworkError } from "../errors";
+async function parseTransactionResult(context, hash, operation) {
+  const mapping = EVENT_MAPPINGS[operation];
+  try {
+    console.debug(`\u{1F50D} Parsing ${operation} transaction: ${hash}`);
+    const receipt = await context.publicClient.waitForTransactionReceipt({
+      hash,
+      timeout: 3e4
+      // 30 second timeout
+    });
+    console.debug(`\u2705 Transaction confirmed in block ${receipt.blockNumber}`);
+    const abi = getAbi(mapping.contract);
+    const events = parseEventLogs({
+      logs: receipt.logs,
+      abi,
+      eventName: mapping.event,
+      strict: true
+      // Only return logs that conform to the ABI
+    });
+    if (events.length === 0) {
+      throw new BlockchainError(
+        `No ${mapping.event} event found in transaction ${hash}. Transaction may have failed or reverted.`
+      );
+    }
+    if (events.length > 1) {
+      console.warn(
+        `\u26A0\uFE0F  Multiple ${mapping.event} events found in transaction ${hash}. Using the first one.`
+      );
+    }
+    const event = events[0];
+    console.debug(`\u{1F389} Found ${mapping.event} event with args:`, event.args);
+    return {
+      ...event.args,
+      transactionHash: hash,
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.gasUsed
+    };
+  } catch (error) {
+    if (error instanceof BlockchainError || error instanceof NetworkError) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.includes("timeout")) {
+      throw new NetworkError(
+        `Transaction ${hash} confirmation timeout after 30 seconds. The transaction may still be pending.`,
+        error
+      );
+    }
+    throw new BlockchainError(
+      `Failed to parse ${operation} transaction ${hash}: ${error instanceof Error ? error.message : "Unknown error"}`,
+      error
+    );
+  }
+}
+export {
+  parseTransactionResult
+};
+//# sourceMappingURL=transactionParsing.js.map

package/dist/utils/transactionParsing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/transactionParsing.ts"],"sourcesContent":["import { parseEventLogs } from \"viem\";\nimport type { Hash } from \"viem\";\nimport {\n  EVENT_MAPPINGS,\n  type TransactionOperation,\n} from \"../config/eventMappings\";\nimport { getAbi } from \"../generated/abi\";\nimport type { ControllerContext } from \"../controllers/permissions\";\nimport { BlockchainError, NetworkError } from \"../errors\";\nimport type { TransactionResultMap } from \"../types/transactionResults\";\n\n/**\n * Base interface for all transaction results.\n * Contains the event data plus transaction metadata.\n */\nexport interface BaseTransactionResult {\n  transactionHash: Hash;\n  blockNumber: bigint;\n  gasUsed: bigint;\n}\n\n/**\n * Generic transaction result parser that extracts event data from transaction receipts.\n *\n * This utility provides a consistent way to parse blockchain events from completed\n * transactions across all SDK controllers. It handles receipt fetching, event parsing,\n * error handling, and result formatting automatically.\n *\n * @param context - Controller context containing blockchain clients\n * @param hash - Transaction hash to parse\n * @param operation - SDK operation name (maps to contract/event via EVENT_MAPPINGS)\n * @returns Promise resolving to event args plus transaction metadata\n * @throws {NetworkError} When transaction receipt cannot be fetched\n * @throws {BlockchainError} When expected event is not found in transaction\n *\n * @example\n * ```typescript\n * // Parse a permission grant transaction\n * const result = await parseTransactionResult(context, txHash, 'grant');\n * console.log(`Permission ${result.permissionId} granted to ${result.user}`);\n *\n * // Parse a file addition transaction\n * const result = await parseTransactionResult(context, txHash, 'addFile');\n * console.log(`File ${result.fileId} added at ${result.url}`);\n * ```\n */\nexport async function parseTransactionResult<K extends TransactionOperation>(\n  context: ControllerContext,\n  hash: Hash,\n  operation: K,\n): Promise<TransactionResultMap[K]> {\n  const mapping = EVENT_MAPPINGS[operation];\n\n  try {\n    // Wait for transaction confirmation\n    console.debug(`🔍 Parsing ${operation} transaction: ${hash}`);\n\n    const receipt = await context.publicClient.waitForTransactionReceipt({\n      hash,\n      timeout: 30_000, // 30 second timeout\n    });\n\n    console.debug(`✅ Transaction confirmed in block ${receipt.blockNumber}`);\n\n    // Get contract ABI for event parsing\n    const abi = getAbi(mapping.contract);\n\n    // Parse events using viem's parseEventLogs\n    const events = parseEventLogs({\n      logs: receipt.logs,\n      abi,\n      eventName: mapping.event,\n      strict: true, // Only return logs that conform to the ABI\n    });\n\n    // Validate we found the expected event\n    if (events.length === 0) {\n      throw new BlockchainError(\n        `No ${mapping.event} event found in transaction ${hash}. ` +\n          `Transaction may have failed or reverted.`,\n      );\n    }\n\n    if (events.length > 1) {\n      console.warn(\n        `⚠️  Multiple ${mapping.event} events found in transaction ${hash}. Using the first one.`,\n      );\n    }\n\n    const event = events[0];\n    console.debug(`🎉 Found ${mapping.event} event with args:`, event.args);\n\n    // Return event args plus transaction metadata\n    return {\n      ...event.args,\n      transactionHash: hash,\n      blockNumber: receipt.blockNumber,\n      gasUsed: receipt.gasUsed,\n    } as TransactionResultMap[K];\n  } catch (error) {\n    // Re-throw known Vana errors directly\n    if (error instanceof BlockchainError || error instanceof NetworkError) {\n      throw error;\n    }\n\n    // Handle timeout errors specifically\n    if (error instanceof Error && error.message.includes(\"timeout\")) {\n      throw new NetworkError(\n        `Transaction ${hash} confirmation timeout after 30 seconds. ` +\n          `The transaction may still be pending.`,\n        error,\n      );\n    }\n\n    // Wrap unknown errors\n    throw new BlockchainError(\n      `Failed to parse ${operation} transaction ${hash}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n"],"mappings":"AAAA,SAAS,sBAAsB;AAE/B;AAAA,EACE;AAAA,OAEK;AACP,SAAS,cAAc;AAEvB,SAAS,iBAAiB,oBAAoB;AAsC9C,eAAsB,uBACpB,SACA,MACA,WACkC;AAClC,QAAM,UAAU,eAAe,SAAS;AAExC,MAAI;AAEF,YAAQ,MAAM,qBAAc,SAAS,iBAAiB,IAAI,EAAE;AAE5D,UAAM,UAAU,MAAM,QAAQ,aAAa,0BAA0B;AAAA,MACnE;AAAA,MACA,SAAS;AAAA;AAAA,IACX,CAAC;AAED,YAAQ,MAAM,yCAAoC,QAAQ,WAAW,EAAE;AAGvE,UAAM,MAAM,OAAO,QAAQ,QAAQ;AAGnC,UAAM,SAAS,eAAe;AAAA,MAC5B,MAAM,QAAQ;AAAA,MACd;AAAA,MACA,WAAW,QAAQ;AAAA,MACnB,QAAQ;AAAA;AAAA,IACV,CAAC;AAGD,QAAI,OAAO,WAAW,GAAG;AACvB,YAAM,IAAI;AAAA,QACR,MAAM,QAAQ,KAAK,+BAA+B,IAAI;AAAA,MAExD;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,GAAG;AACrB,cAAQ;AAAA,QACN,0BAAgB,QAAQ,KAAK,gCAAgC,IAAI;AAAA,MACnE;AAAA,IACF;AAEA,UAAM,QAAQ,OAAO,CAAC;AACtB,YAAQ,MAAM,mBAAY,QAAQ,KAAK,qBAAqB,MAAM,IAAI;AAGtE,WAAO;AAAA,MACL,GAAG,MAAM;AAAA,MACT,iBAAiB;AAAA,MACjB,aAAa,QAAQ;AAAA,MACrB,SAAS,QAAQ;AAAA,IACnB;AAAA,EACF,SAAS,OAAO;AAEd,QAAI,iBAAiB,mBAAmB,iBAAiB,cAAc;AACrE,YAAM;AAAA,IACR;AAGA,QAAI,iBAAiB,SAAS,MAAM,QAAQ,SAAS,SAAS,GAAG;AAC/D,YAAM,IAAI;AAAA,QACR,eAAe,IAAI;AAAA,QAEnB;AAAA,MACF;AAAA,IACF;AAGA,UAAM,IAAI;AAAA,MACR,mBAAmB,SAAS,gBAAgB,IAAI,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MAC7G;AAAA,IACF;AAAA,EACF;AACF;","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":["import type { TypedDataDefinition } from \"viem\";\nimport type { GenericTypedData } from \"../types/permissions\";\n\n/**\n * Converts a GenericTypedData object to a Viem-compatible TypedDataDefinition.\n * This function ensures type safety when passing typed data to viem's signTypedData method.\n *\n * @param typedData - The typed data object to convert\n * @returns A properly typed TypedDataDefinition for use with viem\n */\nexport function toViemTypedDataDefinition(\n  typedData: GenericTypedData,\n): TypedDataDefinition {\n  // Transform the types to match viem's expected format with readonly arrays\n  const viemTypes: Record<string, readonly { name: string; type: string }[]> =\n    {};\n\n  for (const [typeName, typeArray] of Object.entries(typedData.types)) {\n    // Create a new readonly array for each type\n    viemTypes[typeName] = typeArray.map((field) => ({\n      name: field.name,\n      type: field.type,\n    })) as readonly { name: string; type: string }[];\n  }\n\n  return {\n    domain: typedData.domain,\n    types: viemTypes as TypedDataDefinition[\"types\"],\n    primaryType: typedData.primaryType,\n    message: typedData.message,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUO,SAAS,0BACd,WACqB;AAErB,QAAM,YACJ,CAAC;AAEH,aAAW,CAAC,UAAU,SAAS,KAAK,OAAO,QAAQ,UAAU,KAAK,GAAG;AAEnE,cAAU,QAAQ,IAAI,UAAU,IAAI,CAAC,WAAW;AAAA,MAC9C,MAAM,MAAM;AAAA,MACZ,MAAM,MAAM;AAAA,IACd,EAAE;AAAA,EACJ;AAEA,SAAO;AAAA,IACL,QAAQ,UAAU;AAAA,IAClB,OAAO;AAAA,IACP,aAAa,UAAU;AAAA,IACvB,SAAS,UAAU;AAAA,EACrB;AACF;","names":[]}

package/dist/utils/typedDataConverter.d.cts

@@ -0,0 +1,13 @@
+import { TypedDataDefinition } from 'viem';
+import { GenericTypedData } from '../types/permissions.cjs';
+
+/**
+ * Converts a GenericTypedData object to a Viem-compatible TypedDataDefinition.
+ * This function ensures type safety when passing typed data to viem's signTypedData method.
+ *
+ * @param typedData - The typed data object to convert
+ * @returns A properly typed TypedDataDefinition for use with viem
+ */
+declare function toViemTypedDataDefinition(typedData: GenericTypedData): TypedDataDefinition;
+
+export { toViemTypedDataDefinition };

package/dist/utils/typedDataConverter.d.ts

@@ -0,0 +1,13 @@
+import { TypedDataDefinition } from 'viem';
+import { GenericTypedData } from '../types/permissions.js';
+
+/**
+ * Converts a GenericTypedData object to a Viem-compatible TypedDataDefinition.
+ * This function ensures type safety when passing typed data to viem's signTypedData method.
+ *
+ * @param typedData - The typed data object to convert
+ * @returns A properly typed TypedDataDefinition for use with viem
+ */
+declare function toViemTypedDataDefinition(typedData: GenericTypedData): TypedDataDefinition;
+
+export { toViemTypedDataDefinition };

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":["import type { TypedDataDefinition } from \"viem\";\nimport type { GenericTypedData } from \"../types/permissions\";\n\n/**\n * Converts a GenericTypedData object to a Viem-compatible TypedDataDefinition.\n * This function ensures type safety when passing typed data to viem's signTypedData method.\n *\n * @param typedData - The typed data object to convert\n * @returns A properly typed TypedDataDefinition for use with viem\n */\nexport function toViemTypedDataDefinition(\n  typedData: GenericTypedData,\n): TypedDataDefinition {\n  // Transform the types to match viem's expected format with readonly arrays\n  const viemTypes: Record<string, readonly { name: string; type: string }[]> =\n    {};\n\n  for (const [typeName, typeArray] of Object.entries(typedData.types)) {\n    // Create a new readonly array for each type\n    viemTypes[typeName] = typeArray.map((field) => ({\n      name: field.name,\n      type: field.type,\n    })) as readonly { name: string; type: string }[];\n  }\n\n  return {\n    domain: typedData.domain,\n    types: viemTypes as TypedDataDefinition[\"types\"],\n    primaryType: typedData.primaryType,\n    message: typedData.message,\n  };\n}\n"],"mappings":"AAUO,SAAS,0BACd,WACqB;AAErB,QAAM,YACJ,CAAC;AAEH,aAAW,CAAC,UAAU,SAAS,KAAK,OAAO,QAAQ,UAAU,KAAK,GAAG;AAEnE,cAAU,QAAQ,IAAI,UAAU,IAAI,CAAC,WAAW;AAAA,MAC9C,MAAM,MAAM;AAAA,MACZ,MAAM,MAAM;AAAA,IACd,EAAE;AAAA,EACJ;AAEA,SAAO;AAAA,IACL,QAAQ,UAAU;AAAA,IAClB,OAAO;AAAA,IACP,aAAa,UAAU;AAAA,IACvB,SAAS,UAAU;AAAA,EACrB;AACF;","names":[]}

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.fetchWithRelayer)(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 { fetchWithRelayer } from \"./download\";\n\n/**\n * Error thrown when URL resolution fails\n */\nexport class UrlResolutionError extends Error {\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await fetchWithRelayer(url, downloadRelayer);\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Parse JSON response\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    throw new UrlResolutionError(\n      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      url,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,sBAAiC;AAK1B,MAAM,2BAA2B,MAAM;AAAA,EAC5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,UAAM,kCAAiB,KAAK,eAAe;AAE5D,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU,EAAE;AAAA,IACnE;AAGA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,wBAAwB,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACxF;AAAA,MACA,iBAAiB,QAAQ,QAAQ;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}

package/dist/utils/urlResolver.d.cts

@@ -0,0 +1,40 @@
+/**
+ * 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
+ */
+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);
+ * ```
+ */
+declare function fetchFromUrl(url: string, downloadRelayer?: {
+    proxyDownload: (url: string) => Promise<Blob>;
+}): Promise<unknown>;
+
+export { UrlResolutionError, fetchFromUrl };

package/dist/utils/urlResolver.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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
+ */
+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);
+ * ```
+ */
+declare function fetchFromUrl(url: string, downloadRelayer?: {
+    proxyDownload: (url: string) => Promise<Blob>;
+}): Promise<unknown>;
+
+export { UrlResolutionError, fetchFromUrl };