@opendatalabs/vana-sdk 0.1.0-alpha.276ea01 → 0.1.0-alpha.2b6935d

package/dist/utils/parseTransactionPojo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/parseTransactionPojo.ts"],"sourcesContent":["/**\n * Transaction parsing with POJO support and NO heuristics.\n *\n * @remarks\n * This is the new POJO-based parser that works with TransactionResult objects.\n * Principle: Explicit over implicit, guarantees over guesses.\n */\n\nimport { decodeEventLog, type TransactionReceipt } from \"viem\";\nimport type { TransactionResult } from \"../types/operations\";\nimport type {\n  TypedTransactionResult,\n  Contract,\n  Fn,\n  ExpectedEvents,\n} from \"../generated/event-types\";\nimport { EVENT_REGISTRY, TOPIC_TO_ABIS } from \"../generated/eventRegistry\";\n\n/**\n * Parses a transaction using TransactionResult POJO with ZERO heuristics.\n *\n * @remarks\n * - Uses function-scoped event registry for O(1) lookups\n * - Only expects events explicitly mapped for this contract.function\n * - Returns typed events matching the exact TypedTransactionResult interface\n *\n * @param transactionResult - The TransactionResult POJO with context\n * @param transactionResult.hash - Transaction hash\n * @param transactionResult.from - Transaction sender address\n * @param transactionResult.contract - Contract name\n * @param transactionResult.fn - Function name\n * @param transactionResult.chainId - Optional chain ID\n * @param transactionResult.value - Optional transaction value\n * @param transactionResult.nonce - Optional nonce\n * @param transactionResult.to - Optional recipient address\n * @param receipt - The transaction receipt from the blockchain\n * @returns Typed transaction result with parsed events\n */\nexport function parseTransaction<C extends Contract, F extends Fn<C>>(\n  transactionResult: TransactionResult<C, F>,\n  receipt: TransactionReceipt,\n): TypedTransactionResult<C, F> {\n  const { contract: contractName, fn: functionName } = transactionResult;\n\n  // Look up expected events from the function-specific registry\n  const registryKey = `${contractName}.${functionName}`;\n  const registry = EVENT_REGISTRY[registryKey];\n\n  // Initialize the expected events object with proper types\n  const expectedEvents: Record<string, unknown> = {};\n  const allEvents: Array<{\n    contractAddress: string;\n    eventName: string;\n    args: Record<string, unknown>;\n    logIndex: number;\n  }> = [];\n\n  let hasExpectedEvents = false;\n\n  if (receipt.logs) {\n    // Parse logs using the function-scoped registry\n    for (const log of receipt.logs) {\n      if (!log.topics || log.topics.length === 0) {\n        // Skip malformed logs\n        continue;\n      }\n\n      const eventTopic = log.topics[0] as `0x${string}`;\n\n      // Try to decode using TOPIC_TO_ABIS for O(1) lookup\n      const abiCandidates = TOPIC_TO_ABIS.get(eventTopic);\n\n      if (abiCandidates && abiCandidates.length > 0) {\n        // Try each ABI variant (handles collisions)\n        for (const abiEvent of abiCandidates) {\n          try {\n            const decoded = decodeEventLog({\n              abi: [abiEvent],\n              data: log.data,\n              topics: log.topics as [`0x${string}`, ...`0x${string}`[]],\n            });\n\n            // Add to allEvents\n            allEvents.push({\n              contractAddress: log.address || \"\",\n              eventName: decoded.eventName,\n              args: decoded.args as Record<string, unknown>,\n              logIndex: log.logIndex ?? 0,\n            });\n\n            // If this event is expected for this function, add to expectedEvents\n            if (registry && registry.eventNames.includes(decoded.eventName)) {\n              expectedEvents[decoded.eventName] = decoded.args;\n              hasExpectedEvents = true;\n            }\n\n            break; // Successfully decoded, don't try other variants\n          } catch {\n            // Try next ABI variant\n            continue;\n          }\n        }\n      } else {\n        // Event not decodable, add as unknown\n        allEvents.push({\n          contractAddress: log.address || \"\",\n          eventName: \"Unknown\",\n          args: { topic0: eventTopic, data: log.data },\n          logIndex: log.logIndex ?? 0,\n        });\n      }\n    }\n  }\n\n  // Return a properly typed TypedTransactionResult\n  return {\n    hash: transactionResult.hash,\n    from: transactionResult.from,\n    contract: contractName,\n    fn: functionName,\n    expectedEvents: expectedEvents as ExpectedEvents<C, F>,\n    allEvents,\n    hasExpectedEvents,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,kBAAwD;AAQxD,2BAA8C;AAsBvC,SAAS,iBACd,mBACA,SAC8B;AAC9B,QAAM,EAAE,UAAU,cAAc,IAAI,aAAa,IAAI;AAGrD,QAAM,cAAc,GAAG,YAAY,IAAI,YAAY;AACnD,QAAM,WAAW,oCAAe,WAAW;AAG3C,QAAM,iBAA0C,CAAC;AACjD,QAAM,YAKD,CAAC;AAEN,MAAI,oBAAoB;AAExB,MAAI,QAAQ,MAAM;AAEhB,eAAW,OAAO,QAAQ,MAAM;AAC9B,UAAI,CAAC,IAAI,UAAU,IAAI,OAAO,WAAW,GAAG;AAE1C;AAAA,MACF;AAEA,YAAM,aAAa,IAAI,OAAO,CAAC;AAG/B,YAAM,gBAAgB,mCAAc,IAAI,UAAU;AAElD,UAAI,iBAAiB,cAAc,SAAS,GAAG;AAE7C,mBAAW,YAAY,eAAe;AACpC,cAAI;AACF,kBAAM,cAAU,4BAAe;AAAA,cAC7B,KAAK,CAAC,QAAQ;AAAA,cACd,MAAM,IAAI;AAAA,cACV,QAAQ,IAAI;AAAA,YACd,CAAC;AAGD,sBAAU,KAAK;AAAA,cACb,iBAAiB,IAAI,WAAW;AAAA,cAChC,WAAW,QAAQ;AAAA,cACnB,MAAM,QAAQ;AAAA,cACd,UAAU,IAAI,YAAY;AAAA,YAC5B,CAAC;AAGD,gBAAI,YAAY,SAAS,WAAW,SAAS,QAAQ,SAAS,GAAG;AAC/D,6BAAe,QAAQ,SAAS,IAAI,QAAQ;AAC5C,kCAAoB;AAAA,YACtB;AAEA;AAAA,UACF,QAAQ;AAEN;AAAA,UACF;AAAA,QACF;AAAA,MACF,OAAO;AAEL,kBAAU,KAAK;AAAA,UACb,iBAAiB,IAAI,WAAW;AAAA,UAChC,WAAW;AAAA,UACX,MAAM,EAAE,QAAQ,YAAY,MAAM,IAAI,KAAK;AAAA,UAC3C,UAAU,IAAI,YAAY;AAAA,QAC5B,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAGA,SAAO;AAAA,IACL,MAAM,kBAAkB;AAAA,IACxB,MAAM,kBAAkB;AAAA,IACxB,UAAU;AAAA,IACV,IAAI;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/utils/parseTransactionPojo.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Transaction parsing with POJO support and NO heuristics.
+ *
+ * @remarks
+ * This is the new POJO-based parser that works with TransactionResult objects.
+ * Principle: Explicit over implicit, guarantees over guesses.
+ */
+import { type TransactionReceipt } from "viem";
+import type { TransactionResult } from "../types/operations";
+import type { TypedTransactionResult, Contract, Fn } from "../generated/event-types";
+/**
+ * Parses a transaction using TransactionResult POJO with ZERO heuristics.
+ *
+ * @remarks
+ * - Uses function-scoped event registry for O(1) lookups
+ * - Only expects events explicitly mapped for this contract.function
+ * - Returns typed events matching the exact TypedTransactionResult interface
+ *
+ * @param transactionResult - The TransactionResult POJO with context
+ * @param transactionResult.hash - Transaction hash
+ * @param transactionResult.from - Transaction sender address
+ * @param transactionResult.contract - Contract name
+ * @param transactionResult.fn - Function name
+ * @param transactionResult.chainId - Optional chain ID
+ * @param transactionResult.value - Optional transaction value
+ * @param transactionResult.nonce - Optional nonce
+ * @param transactionResult.to - Optional recipient address
+ * @param receipt - The transaction receipt from the blockchain
+ * @returns Typed transaction result with parsed events
+ */
+export declare function parseTransaction<C extends Contract, F extends Fn<C>>(transactionResult: TransactionResult<C, F>, receipt: TransactionReceipt): TypedTransactionResult<C, F>;

package/dist/utils/parseTransactionPojo.js

@@ -0,0 +1,63 @@
+import { decodeEventLog } from "viem";
+import { EVENT_REGISTRY, TOPIC_TO_ABIS } from "../generated/eventRegistry";
+function parseTransaction(transactionResult, receipt) {
+  const { contract: contractName, fn: functionName } = transactionResult;
+  const registryKey = `${contractName}.${functionName}`;
+  const registry = EVENT_REGISTRY[registryKey];
+  const expectedEvents = {};
+  const allEvents = [];
+  let hasExpectedEvents = false;
+  if (receipt.logs) {
+    for (const log of receipt.logs) {
+      if (!log.topics || log.topics.length === 0) {
+        continue;
+      }
+      const eventTopic = log.topics[0];
+      const abiCandidates = TOPIC_TO_ABIS.get(eventTopic);
+      if (abiCandidates && abiCandidates.length > 0) {
+        for (const abiEvent of abiCandidates) {
+          try {
+            const decoded = decodeEventLog({
+              abi: [abiEvent],
+              data: log.data,
+              topics: log.topics
+            });
+            allEvents.push({
+              contractAddress: log.address || "",
+              eventName: decoded.eventName,
+              args: decoded.args,
+              logIndex: log.logIndex ?? 0
+            });
+            if (registry && registry.eventNames.includes(decoded.eventName)) {
+              expectedEvents[decoded.eventName] = decoded.args;
+              hasExpectedEvents = true;
+            }
+            break;
+          } catch {
+            continue;
+          }
+        }
+      } else {
+        allEvents.push({
+          contractAddress: log.address || "",
+          eventName: "Unknown",
+          args: { topic0: eventTopic, data: log.data },
+          logIndex: log.logIndex ?? 0
+        });
+      }
+    }
+  }
+  return {
+    hash: transactionResult.hash,
+    from: transactionResult.from,
+    contract: contractName,
+    fn: functionName,
+    expectedEvents,
+    allEvents,
+    hasExpectedEvents
+  };
+}
+export {
+  parseTransaction
+};
+//# sourceMappingURL=parseTransactionPojo.js.map

package/dist/utils/parseTransactionPojo.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/parseTransactionPojo.ts"],"sourcesContent":["/**\n * Transaction parsing with POJO support and NO heuristics.\n *\n * @remarks\n * This is the new POJO-based parser that works with TransactionResult objects.\n * Principle: Explicit over implicit, guarantees over guesses.\n */\n\nimport { decodeEventLog, type TransactionReceipt } from \"viem\";\nimport type { TransactionResult } from \"../types/operations\";\nimport type {\n  TypedTransactionResult,\n  Contract,\n  Fn,\n  ExpectedEvents,\n} from \"../generated/event-types\";\nimport { EVENT_REGISTRY, TOPIC_TO_ABIS } from \"../generated/eventRegistry\";\n\n/**\n * Parses a transaction using TransactionResult POJO with ZERO heuristics.\n *\n * @remarks\n * - Uses function-scoped event registry for O(1) lookups\n * - Only expects events explicitly mapped for this contract.function\n * - Returns typed events matching the exact TypedTransactionResult interface\n *\n * @param transactionResult - The TransactionResult POJO with context\n * @param transactionResult.hash - Transaction hash\n * @param transactionResult.from - Transaction sender address\n * @param transactionResult.contract - Contract name\n * @param transactionResult.fn - Function name\n * @param transactionResult.chainId - Optional chain ID\n * @param transactionResult.value - Optional transaction value\n * @param transactionResult.nonce - Optional nonce\n * @param transactionResult.to - Optional recipient address\n * @param receipt - The transaction receipt from the blockchain\n * @returns Typed transaction result with parsed events\n */\nexport function parseTransaction<C extends Contract, F extends Fn<C>>(\n  transactionResult: TransactionResult<C, F>,\n  receipt: TransactionReceipt,\n): TypedTransactionResult<C, F> {\n  const { contract: contractName, fn: functionName } = transactionResult;\n\n  // Look up expected events from the function-specific registry\n  const registryKey = `${contractName}.${functionName}`;\n  const registry = EVENT_REGISTRY[registryKey];\n\n  // Initialize the expected events object with proper types\n  const expectedEvents: Record<string, unknown> = {};\n  const allEvents: Array<{\n    contractAddress: string;\n    eventName: string;\n    args: Record<string, unknown>;\n    logIndex: number;\n  }> = [];\n\n  let hasExpectedEvents = false;\n\n  if (receipt.logs) {\n    // Parse logs using the function-scoped registry\n    for (const log of receipt.logs) {\n      if (!log.topics || log.topics.length === 0) {\n        // Skip malformed logs\n        continue;\n      }\n\n      const eventTopic = log.topics[0] as `0x${string}`;\n\n      // Try to decode using TOPIC_TO_ABIS for O(1) lookup\n      const abiCandidates = TOPIC_TO_ABIS.get(eventTopic);\n\n      if (abiCandidates && abiCandidates.length > 0) {\n        // Try each ABI variant (handles collisions)\n        for (const abiEvent of abiCandidates) {\n          try {\n            const decoded = decodeEventLog({\n              abi: [abiEvent],\n              data: log.data,\n              topics: log.topics as [`0x${string}`, ...`0x${string}`[]],\n            });\n\n            // Add to allEvents\n            allEvents.push({\n              contractAddress: log.address || \"\",\n              eventName: decoded.eventName,\n              args: decoded.args as Record<string, unknown>,\n              logIndex: log.logIndex ?? 0,\n            });\n\n            // If this event is expected for this function, add to expectedEvents\n            if (registry && registry.eventNames.includes(decoded.eventName)) {\n              expectedEvents[decoded.eventName] = decoded.args;\n              hasExpectedEvents = true;\n            }\n\n            break; // Successfully decoded, don't try other variants\n          } catch {\n            // Try next ABI variant\n            continue;\n          }\n        }\n      } else {\n        // Event not decodable, add as unknown\n        allEvents.push({\n          contractAddress: log.address || \"\",\n          eventName: \"Unknown\",\n          args: { topic0: eventTopic, data: log.data },\n          logIndex: log.logIndex ?? 0,\n        });\n      }\n    }\n  }\n\n  // Return a properly typed TypedTransactionResult\n  return {\n    hash: transactionResult.hash,\n    from: transactionResult.from,\n    contract: contractName,\n    fn: functionName,\n    expectedEvents: expectedEvents as ExpectedEvents<C, F>,\n    allEvents,\n    hasExpectedEvents,\n  };\n}\n"],"mappings":"AAQA,SAAS,sBAA+C;AAQxD,SAAS,gBAAgB,qBAAqB;AAsBvC,SAAS,iBACd,mBACA,SAC8B;AAC9B,QAAM,EAAE,UAAU,cAAc,IAAI,aAAa,IAAI;AAGrD,QAAM,cAAc,GAAG,YAAY,IAAI,YAAY;AACnD,QAAM,WAAW,eAAe,WAAW;AAG3C,QAAM,iBAA0C,CAAC;AACjD,QAAM,YAKD,CAAC;AAEN,MAAI,oBAAoB;AAExB,MAAI,QAAQ,MAAM;AAEhB,eAAW,OAAO,QAAQ,MAAM;AAC9B,UAAI,CAAC,IAAI,UAAU,IAAI,OAAO,WAAW,GAAG;AAE1C;AAAA,MACF;AAEA,YAAM,aAAa,IAAI,OAAO,CAAC;AAG/B,YAAM,gBAAgB,cAAc,IAAI,UAAU;AAElD,UAAI,iBAAiB,cAAc,SAAS,GAAG;AAE7C,mBAAW,YAAY,eAAe;AACpC,cAAI;AACF,kBAAM,UAAU,eAAe;AAAA,cAC7B,KAAK,CAAC,QAAQ;AAAA,cACd,MAAM,IAAI;AAAA,cACV,QAAQ,IAAI;AAAA,YACd,CAAC;AAGD,sBAAU,KAAK;AAAA,cACb,iBAAiB,IAAI,WAAW;AAAA,cAChC,WAAW,QAAQ;AAAA,cACnB,MAAM,QAAQ;AAAA,cACd,UAAU,IAAI,YAAY;AAAA,YAC5B,CAAC;AAGD,gBAAI,YAAY,SAAS,WAAW,SAAS,QAAQ,SAAS,GAAG;AAC/D,6BAAe,QAAQ,SAAS,IAAI,QAAQ;AAC5C,kCAAoB;AAAA,YACtB;AAEA;AAAA,UACF,QAAQ;AAEN;AAAA,UACF;AAAA,QACF;AAAA,MACF,OAAO;AAEL,kBAAU,KAAK;AAAA,UACb,iBAAiB,IAAI,WAAW;AAAA,UAChC,WAAW;AAAA,UACX,MAAM,EAAE,QAAQ,YAAY,MAAM,IAAI,KAAK;AAAA,UAC3C,UAAU,IAAI,YAAY;AAAA,QAC5B,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAGA,SAAO;AAAA,IACL,MAAM,kBAAkB;AAAA,IACxB,MAAM,kBAAkB;AAAA,IACxB,UAAU;AAAA,IACV,IAAI;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/utils/schemaValidation.cjs

@@ -86,7 +86,7 @@ class SchemaValidator {
   validateDataSchemaAgainstMetaSchema(schema) {
     const isValid = this.dataSchemaValidator(schema);
     if (!isValid) {
-      const errors = this.dataSchemaValidator.errors || [];
+      const errors = this.dataSchemaValidator.errors ?? [];
       const errorMessage = `Data schema validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(", ")}`;
       throw new SchemaValidationError(errorMessage, errors);
     }
@@ -142,7 +142,7 @@ class SchemaValidator {
     const dataValidator = this.ajv.compile(schema.schema);
     const isValid = dataValidator(data);
     if (!isValid) {
-      const errors = dataValidator.errors || [];
+      const errors = dataValidator.errors ?? [];
       const errorMessage = `Data validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(", ")}`;
       throw new SchemaValidationError(errorMessage, errors);
     }
@@ -212,8 +212,8 @@ class SchemaValidator {
    */
   async fetchAndValidateSchema(url, downloadRelayer) {
     try {
-      const { fetchWithRelayer } = await import("./download");
-      const response = await fetchWithRelayer(url, downloadRelayer);
+      const { universalFetch } = await import("./download");
+      const response = await universalFetch(url, downloadRelayer);
       if (!response.ok) {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
@@ -241,7 +241,7 @@ function validateDataSchemaAgainstMetaSchema(schema) {
   return schema;
 }
 function validateDataAgainstSchema(data, schema) {
-  return schemaValidator.validateDataAgainstSchema(data, schema);
+  schemaValidator.validateDataAgainstSchema(data, schema);
 }
 function fetchAndValidateSchema(url, downloadRelayer) {
   return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);

package/dist/utils/schemaValidation.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/schemaValidation.ts"],"sourcesContent":["import Ajv, { type ValidateFunction } from \"ajv\";\nimport addFormats from \"ajv-formats\";\nimport dataSchemaSchema from \"../schemas/dataSchema.schema.json\";\nimport type { Schema } from \"../types/data\";\n\n/**\n * Data schema interface following the Vana schema specification\n *\n * @category Configuration\n */\nexport interface DataSchema {\n  /** The name of the data schema */\n  name: string;\n  /** The version of the data schema */\n  version: string;\n  /** Optional description of the data schema */\n  description?: string;\n  /** The dialect type - either SQLite or JSON */\n  dialect: \"sqlite\" | \"json\";\n  /** Optional version of the dialect */\n  dialectVersion?: string;\n  /** The actual schema definition as string or object */\n  schema: string | object;\n}\n\n/**\n * Error thrown when schema validation fails\n */\nexport class SchemaValidationError extends Error {\n  constructor(\n    message: string,\n    public errors: Array<{\n      instancePath: string;\n      schemaPath: string;\n      keyword: string;\n      params: Record<string, unknown>;\n      message?: string;\n    }>,\n  ) {\n    super(message);\n    this.name = \"SchemaValidationError\";\n  }\n}\n\n/**\n * Data schema validation utility class\n */\nexport class SchemaValidator {\n  private ajv: Ajv;\n  private dataSchemaValidator: ValidateFunction;\n\n  constructor() {\n    this.ajv = new Ajv({\n      allErrors: true,\n      verbose: true,\n      strict: false,\n    });\n\n    // Add format validation (e.g., date, email, uri)\n    addFormats(this.ajv);\n\n    // Compile the data schema meta-schema validator\n    this.dataSchemaValidator = this.ajv.compile(dataSchemaSchema);\n  }\n\n  /**\n   * Validates a data schema definition against the Vana meta-schema\n   *\n   * @param schema - The data schema definition to validate\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * const schema = {\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: {\n   *     type: \"object\",\n   *     properties: {\n   *       name: { type: \"string\" },\n   *       age: { type: \"number\" }\n   *     }\n   *   }\n   * };\n   *\n   * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid\n   * ```\n   */\n  validateDataSchemaAgainstMetaSchema(\n    schema: unknown,\n  ): asserts schema is DataSchema {\n    const isValid = this.dataSchemaValidator(schema);\n\n    if (!isValid) {\n      const errors = this.dataSchemaValidator.errors || [];\n      const errorMessage = `Data schema validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n\n    // Additional validation based on dialect\n    const typedSchema = schema as DataSchema;\n    if (\n      typedSchema.dialect === \"json\" &&\n      typeof typedSchema.schema === \"object\"\n    ) {\n      // Validate that the embedded JSON Schema is actually valid\n      try {\n        this.ajv.compile(typedSchema.schema);\n      } catch (error) {\n        const errorMessage = `Invalid JSON Schema in data schema: ${error instanceof Error ? error.message : \"Unknown schema compilation error\"}`;\n        throw new SchemaValidationError(errorMessage, []);\n      }\n    } else if (\n      typedSchema.dialect === \"sqlite\" &&\n      typeof typedSchema.schema === \"string\"\n    ) {\n      // Validate SQLite DDL syntax\n      this.validateSQLiteDDL(typedSchema.schema, typedSchema.dialectVersion);\n    }\n  }\n\n  /**\n   * Validates data against a JSON Schema\n   *\n   * @param data - The data to validate\n   * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * // Works with Schema from schemas.get()\n   * const schema = await vana.schemas.get(1);\n   * validator.validateDataAgainstSchema(userData, schema);\n   *\n   * // Also works with pre-validated DataSchema object\n   * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n   * });\n   * validator.validateDataAgainstSchema(userData, dataSchema);\n   * ```\n   */\n  validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void {\n    if (schema.dialect !== \"json\") {\n      console.warn(\n        `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. ` +\n          `Only JSON schemas can validate data structure.`,\n      );\n      return;\n    }\n\n    if (typeof schema.schema !== \"object\") {\n      throw new SchemaValidationError(\n        \"JSON dialect schemas must have an object schema\",\n        [],\n      );\n    }\n\n    // Compile and validate against the data schema\n    const dataValidator = this.ajv.compile(schema.schema);\n    const isValid = dataValidator(data);\n\n    if (!isValid) {\n      const errors = dataValidator.errors || [];\n      const errorMessage = `Data validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n  }\n\n  /**\n   * Validates a SQLite DDL string for basic syntax\n   * Note: This is a basic validation, full SQL parsing would require a proper SQL parser\n   *\n   * @param ddl - The DDL string to validate\n   * @param dialectVersion - Optional SQLite version (e.g., \"3\" for SQLite v3)\n   * @throws SchemaValidationError if invalid\n   */\n  validateSQLiteDDL(ddl: string, dialectVersion?: string): void {\n    if (typeof ddl !== \"string\" || ddl.trim().length === 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must be a non-empty string\",\n        [],\n      );\n    }\n\n    // Validate dialectVersion if provided\n    if (dialectVersion !== undefined) {\n      const supportedVersions = [\"3\"];\n      if (!supportedVersions.includes(dialectVersion)) {\n        throw new SchemaValidationError(\n          `Unsupported SQLite dialect version: ${dialectVersion}. Supported versions: ${supportedVersions.join(\", \")}`,\n          [],\n        );\n      }\n    }\n\n    // Basic validation - check for CREATE TABLE statements\n    const normalizedDDL = ddl.trim().toUpperCase();\n    if (!normalizedDDL.includes(\"CREATE TABLE\")) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must contain at least one CREATE TABLE statement\",\n        [],\n      );\n    }\n\n    // Check for balanced parentheses\n    let parenCount = 0;\n    for (const char of ddl) {\n      if (char === \"(\") parenCount++;\n      if (char === \")\") parenCount--;\n      if (parenCount < 0) {\n        throw new SchemaValidationError(\n          \"SQLite DDL has unbalanced parentheses\",\n          [],\n        );\n      }\n    }\n\n    if (parenCount !== 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL has unbalanced parentheses\",\n        [],\n      );\n    }\n  }\n\n  /**\n   * Fetches and validates a data schema from a URL\n   *\n   * @param url - The URL to fetch the data schema from\n   * @param downloadRelayer - Optional download relayer for CORS bypass\n   * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n   * @returns The validated data schema\n   * @throws SchemaValidationError if invalid or fetch fails\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   * const schema = await validator.fetchAndValidateSchema(\"https://example.com/schema.json\");\n   * ```\n   */\n  async fetchAndValidateSchema(\n    url: string,\n    downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n  ): Promise<DataSchema> {\n    try {\n      const { fetchWithRelayer } = await import(\"./download\");\n      const response = await fetchWithRelayer(url, downloadRelayer);\n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n\n      const schema = await response.json();\n      this.validateDataSchemaAgainstMetaSchema(schema);\n\n      // Additional validation based on dialect\n      if (schema.dialect === \"sqlite\" && typeof schema.schema === \"string\") {\n        this.validateSQLiteDDL(schema.schema, schema.dialectVersion);\n      }\n\n      return schema;\n    } catch (error) {\n      if (error instanceof SchemaValidationError) {\n        throw error;\n      }\n\n      throw new SchemaValidationError(\n        `Failed to fetch and validate schema from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n        [],\n      );\n    }\n  }\n}\n\n/**\n * Global schema validator instance\n */\nexport const schemaValidator = new SchemaValidator();\n\n/**\n * Convenience function to validate a data schema definition against the Vana meta-schema\n *\n * @param schema - The data schema definition to validate\n * @returns The validated DataSchema\n * @throws SchemaValidationError if invalid\n * @example\n * ```typescript\n * const schemaDefinition = {\n *   name: \"User Profile\",\n *   version: \"1.0.0\",\n *   dialect: \"json\",\n *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n * };\n *\n * const validatedSchema = validateDataSchemaAgainstMetaSchema(schemaDefinition);\n * ```\n */\nexport function validateDataSchemaAgainstMetaSchema(\n  schema: unknown,\n): DataSchema {\n  const validator: SchemaValidator = schemaValidator;\n  validator.validateDataSchemaAgainstMetaSchema(schema);\n  // If we get here, schema is valid and typed as DataSchema\n  return schema as DataSchema;\n}\n\n/**\n * Convenience function to validate data against a schema\n *\n * @param data - The data to validate\n * @param schema - The data schema containing the schema\n * @returns void - Function doesn't return a value\n * @throws SchemaValidationError if invalid\n */\nexport function validateDataAgainstSchema(\n  data: unknown,\n  schema: DataSchema | Schema,\n): void {\n  return schemaValidator.validateDataAgainstSchema(data, schema);\n}\n\n/**\n * Convenience function to fetch and validate a data schema from a URL\n *\n * @param url - The URL to fetch the data schema from\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns The validated data schema\n * @throws SchemaValidationError if invalid or fetch fails\n */\nexport function fetchAndValidateSchema(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<DataSchema> {\n  return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);\n}\n"],"mappings":"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","names":["Ajv","addFormats","dataSchemaSchema"]}
+{"version":3,"sources":["../../src/utils/schemaValidation.ts"],"sourcesContent":["import Ajv, { type ValidateFunction } from \"ajv\";\nimport addFormats from \"ajv-formats\";\nimport dataSchemaSchema from \"../schemas/dataSchema.schema.json\";\nimport type { Schema } from \"../types/data\";\n\n/**\n * Data schema interface following the Vana schema specification\n *\n * @category Configuration\n */\nexport interface DataSchema {\n  /** The name of the data schema */\n  name: string;\n  /** The version of the data schema */\n  version: string;\n  /** Optional description of the data schema */\n  description?: string;\n  /** The dialect type - either SQLite or JSON */\n  dialect: \"sqlite\" | \"json\";\n  /** Optional version of the dialect */\n  dialectVersion?: string;\n  /** The actual schema definition as string or object */\n  schema: string | object;\n}\n\n/**\n * Error thrown when schema validation fails\n */\nexport class SchemaValidationError extends Error {\n  constructor(\n    message: string,\n    public errors: Array<{\n      instancePath: string;\n      schemaPath: string;\n      keyword: string;\n      params: Record<string, unknown>;\n      message?: string;\n    }>,\n  ) {\n    super(message);\n    this.name = \"SchemaValidationError\";\n  }\n}\n\n/**\n * Data schema validation utility class\n */\nexport class SchemaValidator {\n  private ajv: Ajv;\n  private dataSchemaValidator: ValidateFunction;\n\n  constructor() {\n    this.ajv = new Ajv({\n      allErrors: true,\n      verbose: true,\n      strict: false,\n    });\n\n    // Add format validation (e.g., date, email, uri)\n    addFormats(this.ajv);\n\n    // Compile the data schema meta-schema validator\n    this.dataSchemaValidator = this.ajv.compile(dataSchemaSchema);\n  }\n\n  /**\n   * Validates a data schema definition against the Vana meta-schema\n   *\n   * @param schema - The data schema definition to validate\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * const schema = {\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: {\n   *     type: \"object\",\n   *     properties: {\n   *       name: { type: \"string\" },\n   *       age: { type: \"number\" }\n   *     }\n   *   }\n   * };\n   *\n   * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid\n   * ```\n   */\n  validateDataSchemaAgainstMetaSchema(\n    schema: unknown,\n  ): asserts schema is DataSchema {\n    const isValid = this.dataSchemaValidator(schema);\n\n    if (!isValid) {\n      const errors = this.dataSchemaValidator.errors ?? [];\n      const errorMessage = `Data schema validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n\n    // Additional validation based on dialect\n    const typedSchema = schema as DataSchema;\n    if (\n      typedSchema.dialect === \"json\" &&\n      typeof typedSchema.schema === \"object\"\n    ) {\n      // Validate that the embedded JSON Schema is actually valid\n      try {\n        this.ajv.compile(typedSchema.schema);\n      } catch (error) {\n        const errorMessage = `Invalid JSON Schema in data schema: ${error instanceof Error ? error.message : \"Unknown schema compilation error\"}`;\n        throw new SchemaValidationError(errorMessage, []);\n      }\n    } else if (\n      typedSchema.dialect === \"sqlite\" &&\n      typeof typedSchema.schema === \"string\"\n    ) {\n      // Validate SQLite DDL syntax\n      this.validateSQLiteDDL(typedSchema.schema, typedSchema.dialectVersion);\n    }\n  }\n\n  /**\n   * Validates data against a JSON Schema\n   *\n   * @param data - The data to validate\n   * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * // Works with Schema from schemas.get()\n   * const schema = await vana.schemas.get(1);\n   * validator.validateDataAgainstSchema(userData, schema);\n   *\n   * // Also works with pre-validated DataSchema object\n   * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n   * });\n   * validator.validateDataAgainstSchema(userData, dataSchema);\n   * ```\n   */\n  validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void {\n    if (schema.dialect !== \"json\") {\n      console.warn(\n        `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. ` +\n          `Only JSON schemas can validate data structure.`,\n      );\n      return;\n    }\n\n    if (typeof schema.schema !== \"object\") {\n      throw new SchemaValidationError(\n        \"JSON dialect schemas must have an object schema\",\n        [],\n      );\n    }\n\n    // Compile and validate against the data schema\n    const dataValidator = this.ajv.compile(schema.schema);\n    const isValid = dataValidator(data);\n\n    if (!isValid) {\n      const errors = dataValidator.errors ?? [];\n      const errorMessage = `Data validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n  }\n\n  /**\n   * Validates a SQLite DDL string for basic syntax\n   * Note: This is a basic validation, full SQL parsing would require a proper SQL parser\n   *\n   * @param ddl - The DDL string to validate\n   * @param dialectVersion - Optional SQLite version (e.g., \"3\" for SQLite v3)\n   * @throws SchemaValidationError if invalid\n   */\n  validateSQLiteDDL(ddl: string, dialectVersion?: string): void {\n    if (typeof ddl !== \"string\" || ddl.trim().length === 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must be a non-empty string\",\n        [],\n      );\n    }\n\n    // Validate dialectVersion if provided\n    if (dialectVersion !== undefined) {\n      const supportedVersions = [\"3\"];\n      if (!supportedVersions.includes(dialectVersion)) {\n        throw new SchemaValidationError(\n          `Unsupported SQLite dialect version: ${dialectVersion}. Supported versions: ${supportedVersions.join(\", \")}`,\n          [],\n        );\n      }\n    }\n\n    // Basic validation - check for CREATE TABLE statements\n    const normalizedDDL = ddl.trim().toUpperCase();\n    if (!normalizedDDL.includes(\"CREATE TABLE\")) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must contain at least one CREATE TABLE statement\",\n        [],\n      );\n    }\n\n    // Check for balanced parentheses\n    let parenCount = 0;\n    for (const char of ddl) {\n      if (char === \"(\") parenCount++;\n      if (char === \")\") parenCount--;\n      if (parenCount < 0) {\n        throw new SchemaValidationError(\n          \"SQLite DDL has unbalanced parentheses\",\n          [],\n        );\n      }\n    }\n\n    if (parenCount !== 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL has unbalanced parentheses\",\n        [],\n      );\n    }\n  }\n\n  /**\n   * Fetches and validates a data schema from a URL\n   *\n   * @param url - The URL to fetch the data schema from\n   * @param downloadRelayer - Optional download relayer for CORS bypass\n   * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n   * @returns The validated data schema\n   * @throws SchemaValidationError if invalid or fetch fails\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   * const schema = await validator.fetchAndValidateSchema(\"https://example.com/schema.json\");\n   * ```\n   */\n  async fetchAndValidateSchema(\n    url: string,\n    downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n  ): Promise<DataSchema> {\n    try {\n      const { universalFetch } = await import(\"./download\");\n      const response = await universalFetch(url, downloadRelayer);\n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n\n      const schema = await response.json();\n      this.validateDataSchemaAgainstMetaSchema(schema);\n\n      // Additional validation based on dialect\n      if (schema.dialect === \"sqlite\" && typeof schema.schema === \"string\") {\n        this.validateSQLiteDDL(schema.schema, schema.dialectVersion);\n      }\n\n      return schema;\n    } catch (error) {\n      if (error instanceof SchemaValidationError) {\n        throw error;\n      }\n\n      throw new SchemaValidationError(\n        `Failed to fetch and validate schema from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n        [],\n      );\n    }\n  }\n}\n\n/**\n * Global schema validator instance\n */\nexport const schemaValidator = new SchemaValidator();\n\n/**\n * Convenience function to validate a data schema definition against the Vana meta-schema\n *\n * @param schema - The data schema definition to validate\n * @returns The validated DataSchema\n * @throws SchemaValidationError if invalid\n * @example\n * ```typescript\n * const schemaDefinition = {\n *   name: \"User Profile\",\n *   version: \"1.0.0\",\n *   dialect: \"json\",\n *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n * };\n *\n * const validatedSchema = validateDataSchemaAgainstMetaSchema(schemaDefinition);\n * ```\n */\nexport function validateDataSchemaAgainstMetaSchema(\n  schema: unknown,\n): DataSchema {\n  const validator: SchemaValidator = schemaValidator;\n  validator.validateDataSchemaAgainstMetaSchema(schema);\n  // If we get here, schema is valid and typed as DataSchema\n  return schema;\n}\n\n/**\n * Convenience function to validate data against a schema\n *\n * @param data - The data to validate\n * @param schema - The data schema containing the schema\n * @returns void - Function doesn't return a value\n * @throws SchemaValidationError if invalid\n */\nexport function validateDataAgainstSchema(\n  data: unknown,\n  schema: DataSchema | Schema,\n): void {\n  schemaValidator.validateDataAgainstSchema(data, schema);\n}\n\n/**\n * Convenience function to fetch and validate a data schema from a URL\n *\n * @param url - The URL to fetch the data schema from\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns The validated data schema\n * @throws SchemaValidationError if invalid or fetch fails\n */\nexport function fetchAndValidateSchema(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<DataSchema> {\n  return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);\n}\n"],"mappings":"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","names":["Ajv","addFormats","dataSchemaSchema"]}

package/dist/utils/schemaValidation.d.ts

@@ -1,12 +1,10 @@
-import { Schema } from '../types/data.js';
-import 'viem';
-
+import type { Schema } from "../types/data";
 /**
  * Data schema interface following the Vana schema specification
  *
  * @category Configuration
  */
-interface DataSchema {
+export interface DataSchema {
     /** The name of the data schema */
     name: string;
     /** The version of the data schema */
@@ -23,7 +21,7 @@ interface DataSchema {
 /**
  * Error thrown when schema validation fails
  */
-declare class SchemaValidationError extends Error {
+export declare class SchemaValidationError extends Error {
     errors: Array<{
         instancePath: string;
         schemaPath: string;
@@ -42,7 +40,7 @@ declare class SchemaValidationError extends Error {
 /**
  * Data schema validation utility class
  */
-declare class SchemaValidator {
+export declare class SchemaValidator {
     private ajv;
     private dataSchemaValidator;
     constructor();
@@ -127,7 +125,7 @@ declare class SchemaValidator {
 /**
  * Global schema validator instance
  */
-declare const schemaValidator: SchemaValidator;
+export declare const schemaValidator: SchemaValidator;
 /**
  * Convenience function to validate a data schema definition against the Vana meta-schema
  *
@@ -146,7 +144,7 @@ declare const schemaValidator: SchemaValidator;
  * const validatedSchema = validateDataSchemaAgainstMetaSchema(schemaDefinition);
  * ```
  */
-declare function validateDataSchemaAgainstMetaSchema(schema: unknown): DataSchema;
+export declare function validateDataSchemaAgainstMetaSchema(schema: unknown): DataSchema;
 /**
  * Convenience function to validate data against a schema
  *
@@ -155,7 +153,7 @@ declare function validateDataSchemaAgainstMetaSchema(schema: unknown): DataSchem
  * @returns void - Function doesn't return a value
  * @throws SchemaValidationError if invalid
  */
-declare function validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void;
+export declare function validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void;
 /**
  * Convenience function to fetch and validate a data schema from a URL
  *
@@ -165,8 +163,6 @@ declare function validateDataAgainstSchema(data: unknown, schema: DataSchema | S
  * @returns The validated data schema
  * @throws SchemaValidationError if invalid or fetch fails
  */
-declare function fetchAndValidateSchema(url: string, downloadRelayer?: {
+export declare function fetchAndValidateSchema(url: string, downloadRelayer?: {
     proxyDownload: (url: string) => Promise<Blob>;
 }): Promise<DataSchema>;
-
-export { type DataSchema, SchemaValidationError, SchemaValidator, fetchAndValidateSchema, schemaValidator, validateDataAgainstSchema, validateDataSchemaAgainstMetaSchema };

package/dist/utils/schemaValidation.js

@@ -1,6 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
 import dataSchemaSchema from "../schemas/dataSchema.schema.json";
@@ -12,9 +9,9 @@ class SchemaValidationError extends Error {
   }
 }
 class SchemaValidator {
+  ajv;
+  dataSchemaValidator;
   constructor() {
-    __publicField(this, "ajv");
-    __publicField(this, "dataSchemaValidator");
     this.ajv = new Ajv({
       allErrors: true,
       verbose: true,
@@ -51,7 +48,7 @@ class SchemaValidator {
   validateDataSchemaAgainstMetaSchema(schema) {
     const isValid = this.dataSchemaValidator(schema);
     if (!isValid) {
-      const errors = this.dataSchemaValidator.errors || [];
+      const errors = this.dataSchemaValidator.errors ?? [];
       const errorMessage = `Data schema validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(", ")}`;
       throw new SchemaValidationError(errorMessage, errors);
     }
@@ -107,7 +104,7 @@ class SchemaValidator {
     const dataValidator = this.ajv.compile(schema.schema);
     const isValid = dataValidator(data);
     if (!isValid) {
-      const errors = dataValidator.errors || [];
+      const errors = dataValidator.errors ?? [];
       const errorMessage = `Data validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(", ")}`;
       throw new SchemaValidationError(errorMessage, errors);
     }
@@ -177,8 +174,8 @@ class SchemaValidator {
    */
   async fetchAndValidateSchema(url, downloadRelayer) {
     try {
-      const { fetchWithRelayer } = await import("./download");
-      const response = await fetchWithRelayer(url, downloadRelayer);
+      const { universalFetch } = await import("./download");
+      const response = await universalFetch(url, downloadRelayer);
       if (!response.ok) {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
@@ -206,7 +203,7 @@ function validateDataSchemaAgainstMetaSchema(schema) {
   return schema;
 }
 function validateDataAgainstSchema(data, schema) {
-  return schemaValidator.validateDataAgainstSchema(data, schema);
+  schemaValidator.validateDataAgainstSchema(data, schema);
 }
 function fetchAndValidateSchema(url, downloadRelayer) {
   return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);

package/dist/utils/schemaValidation.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/schemaValidation.ts"],"sourcesContent":["import Ajv, { type ValidateFunction } from \"ajv\";\nimport addFormats from \"ajv-formats\";\nimport dataSchemaSchema from \"../schemas/dataSchema.schema.json\";\nimport type { Schema } from \"../types/data\";\n\n/**\n * Data schema interface following the Vana schema specification\n *\n * @category Configuration\n */\nexport interface DataSchema {\n  /** The name of the data schema */\n  name: string;\n  /** The version of the data schema */\n  version: string;\n  /** Optional description of the data schema */\n  description?: string;\n  /** The dialect type - either SQLite or JSON */\n  dialect: \"sqlite\" | \"json\";\n  /** Optional version of the dialect */\n  dialectVersion?: string;\n  /** The actual schema definition as string or object */\n  schema: string | object;\n}\n\n/**\n * Error thrown when schema validation fails\n */\nexport class SchemaValidationError extends Error {\n  constructor(\n    message: string,\n    public errors: Array<{\n      instancePath: string;\n      schemaPath: string;\n      keyword: string;\n      params: Record<string, unknown>;\n      message?: string;\n    }>,\n  ) {\n    super(message);\n    this.name = \"SchemaValidationError\";\n  }\n}\n\n/**\n * Data schema validation utility class\n */\nexport class SchemaValidator {\n  private ajv: Ajv;\n  private dataSchemaValidator: ValidateFunction;\n\n  constructor() {\n    this.ajv = new Ajv({\n      allErrors: true,\n      verbose: true,\n      strict: false,\n    });\n\n    // Add format validation (e.g., date, email, uri)\n    addFormats(this.ajv);\n\n    // Compile the data schema meta-schema validator\n    this.dataSchemaValidator = this.ajv.compile(dataSchemaSchema);\n  }\n\n  /**\n   * Validates a data schema definition against the Vana meta-schema\n   *\n   * @param schema - The data schema definition to validate\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * const schema = {\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: {\n   *     type: \"object\",\n   *     properties: {\n   *       name: { type: \"string\" },\n   *       age: { type: \"number\" }\n   *     }\n   *   }\n   * };\n   *\n   * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid\n   * ```\n   */\n  validateDataSchemaAgainstMetaSchema(\n    schema: unknown,\n  ): asserts schema is DataSchema {\n    const isValid = this.dataSchemaValidator(schema);\n\n    if (!isValid) {\n      const errors = this.dataSchemaValidator.errors || [];\n      const errorMessage = `Data schema validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n\n    // Additional validation based on dialect\n    const typedSchema = schema as DataSchema;\n    if (\n      typedSchema.dialect === \"json\" &&\n      typeof typedSchema.schema === \"object\"\n    ) {\n      // Validate that the embedded JSON Schema is actually valid\n      try {\n        this.ajv.compile(typedSchema.schema);\n      } catch (error) {\n        const errorMessage = `Invalid JSON Schema in data schema: ${error instanceof Error ? error.message : \"Unknown schema compilation error\"}`;\n        throw new SchemaValidationError(errorMessage, []);\n      }\n    } else if (\n      typedSchema.dialect === \"sqlite\" &&\n      typeof typedSchema.schema === \"string\"\n    ) {\n      // Validate SQLite DDL syntax\n      this.validateSQLiteDDL(typedSchema.schema, typedSchema.dialectVersion);\n    }\n  }\n\n  /**\n   * Validates data against a JSON Schema\n   *\n   * @param data - The data to validate\n   * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * // Works with Schema from schemas.get()\n   * const schema = await vana.schemas.get(1);\n   * validator.validateDataAgainstSchema(userData, schema);\n   *\n   * // Also works with pre-validated DataSchema object\n   * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n   * });\n   * validator.validateDataAgainstSchema(userData, dataSchema);\n   * ```\n   */\n  validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void {\n    if (schema.dialect !== \"json\") {\n      console.warn(\n        `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. ` +\n          `Only JSON schemas can validate data structure.`,\n      );\n      return;\n    }\n\n    if (typeof schema.schema !== \"object\") {\n      throw new SchemaValidationError(\n        \"JSON dialect schemas must have an object schema\",\n        [],\n      );\n    }\n\n    // Compile and validate against the data schema\n    const dataValidator = this.ajv.compile(schema.schema);\n    const isValid = dataValidator(data);\n\n    if (!isValid) {\n      const errors = dataValidator.errors || [];\n      const errorMessage = `Data validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n  }\n\n  /**\n   * Validates a SQLite DDL string for basic syntax\n   * Note: This is a basic validation, full SQL parsing would require a proper SQL parser\n   *\n   * @param ddl - The DDL string to validate\n   * @param dialectVersion - Optional SQLite version (e.g., \"3\" for SQLite v3)\n   * @throws SchemaValidationError if invalid\n   */\n  validateSQLiteDDL(ddl: string, dialectVersion?: string): void {\n    if (typeof ddl !== \"string\" || ddl.trim().length === 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must be a non-empty string\",\n        [],\n      );\n    }\n\n    // Validate dialectVersion if provided\n    if (dialectVersion !== undefined) {\n      const supportedVersions = [\"3\"];\n      if (!supportedVersions.includes(dialectVersion)) {\n        throw new SchemaValidationError(\n          `Unsupported SQLite dialect version: ${dialectVersion}. Supported versions: ${supportedVersions.join(\", \")}`,\n          [],\n        );\n      }\n    }\n\n    // Basic validation - check for CREATE TABLE statements\n    const normalizedDDL = ddl.trim().toUpperCase();\n    if (!normalizedDDL.includes(\"CREATE TABLE\")) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must contain at least one CREATE TABLE statement\",\n        [],\n      );\n    }\n\n    // Check for balanced parentheses\n    let parenCount = 0;\n    for (const char of ddl) {\n      if (char === \"(\") parenCount++;\n      if (char === \")\") parenCount--;\n      if (parenCount < 0) {\n        throw new SchemaValidationError(\n          \"SQLite DDL has unbalanced parentheses\",\n          [],\n        );\n      }\n    }\n\n    if (parenCount !== 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL has unbalanced parentheses\",\n        [],\n      );\n    }\n  }\n\n  /**\n   * Fetches and validates a data schema from a URL\n   *\n   * @param url - The URL to fetch the data schema from\n   * @param downloadRelayer - Optional download relayer for CORS bypass\n   * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n   * @returns The validated data schema\n   * @throws SchemaValidationError if invalid or fetch fails\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   * const schema = await validator.fetchAndValidateSchema(\"https://example.com/schema.json\");\n   * ```\n   */\n  async fetchAndValidateSchema(\n    url: string,\n    downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n  ): Promise<DataSchema> {\n    try {\n      const { fetchWithRelayer } = await import(\"./download\");\n      const response = await fetchWithRelayer(url, downloadRelayer);\n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n\n      const schema = await response.json();\n      this.validateDataSchemaAgainstMetaSchema(schema);\n\n      // Additional validation based on dialect\n      if (schema.dialect === \"sqlite\" && typeof schema.schema === \"string\") {\n        this.validateSQLiteDDL(schema.schema, schema.dialectVersion);\n      }\n\n      return schema;\n    } catch (error) {\n      if (error instanceof SchemaValidationError) {\n        throw error;\n      }\n\n      throw new SchemaValidationError(\n        `Failed to fetch and validate schema from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n        [],\n      );\n    }\n  }\n}\n\n/**\n * Global schema validator instance\n */\nexport const schemaValidator = new SchemaValidator();\n\n/**\n * Convenience function to validate a data schema definition against the Vana meta-schema\n *\n * @param schema - The data schema definition to validate\n * @returns The validated DataSchema\n * @throws SchemaValidationError if invalid\n * @example\n * ```typescript\n * const schemaDefinition = {\n *   name: \"User Profile\",\n *   version: \"1.0.0\",\n *   dialect: \"json\",\n *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n * };\n *\n * const validatedSchema = validateDataSchemaAgainstMetaSchema(schemaDefinition);\n * ```\n */\nexport function validateDataSchemaAgainstMetaSchema(\n  schema: unknown,\n): DataSchema {\n  const validator: SchemaValidator = schemaValidator;\n  validator.validateDataSchemaAgainstMetaSchema(schema);\n  // If we get here, schema is valid and typed as DataSchema\n  return schema as DataSchema;\n}\n\n/**\n * Convenience function to validate data against a schema\n *\n * @param data - The data to validate\n * @param schema - The data schema containing the schema\n * @returns void - Function doesn't return a value\n * @throws SchemaValidationError if invalid\n */\nexport function validateDataAgainstSchema(\n  data: unknown,\n  schema: DataSchema | Schema,\n): void {\n  return schemaValidator.validateDataAgainstSchema(data, schema);\n}\n\n/**\n * Convenience function to fetch and validate a data schema from a URL\n *\n * @param url - The URL to fetch the data schema from\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns The validated data schema\n * @throws SchemaValidationError if invalid or fetch fails\n */\nexport function fetchAndValidateSchema(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<DataSchema> {\n  return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/utils/schemaValidation.ts"],"sourcesContent":["import Ajv, { type ValidateFunction } from \"ajv\";\nimport addFormats from \"ajv-formats\";\nimport dataSchemaSchema from \"../schemas/dataSchema.schema.json\";\nimport type { Schema } from \"../types/data\";\n\n/**\n * Data schema interface following the Vana schema specification\n *\n * @category Configuration\n */\nexport interface DataSchema {\n  /** The name of the data schema */\n  name: string;\n  /** The version of the data schema */\n  version: string;\n  /** Optional description of the data schema */\n  description?: string;\n  /** The dialect type - either SQLite or JSON */\n  dialect: \"sqlite\" | \"json\";\n  /** Optional version of the dialect */\n  dialectVersion?: string;\n  /** The actual schema definition as string or object */\n  schema: string | object;\n}\n\n/**\n * Error thrown when schema validation fails\n */\nexport class SchemaValidationError extends Error {\n  constructor(\n    message: string,\n    public errors: Array<{\n      instancePath: string;\n      schemaPath: string;\n      keyword: string;\n      params: Record<string, unknown>;\n      message?: string;\n    }>,\n  ) {\n    super(message);\n    this.name = \"SchemaValidationError\";\n  }\n}\n\n/**\n * Data schema validation utility class\n */\nexport class SchemaValidator {\n  private ajv: Ajv;\n  private dataSchemaValidator: ValidateFunction;\n\n  constructor() {\n    this.ajv = new Ajv({\n      allErrors: true,\n      verbose: true,\n      strict: false,\n    });\n\n    // Add format validation (e.g., date, email, uri)\n    addFormats(this.ajv);\n\n    // Compile the data schema meta-schema validator\n    this.dataSchemaValidator = this.ajv.compile(dataSchemaSchema);\n  }\n\n  /**\n   * Validates a data schema definition against the Vana meta-schema\n   *\n   * @param schema - The data schema definition to validate\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * const schema = {\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: {\n   *     type: \"object\",\n   *     properties: {\n   *       name: { type: \"string\" },\n   *       age: { type: \"number\" }\n   *     }\n   *   }\n   * };\n   *\n   * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid\n   * ```\n   */\n  validateDataSchemaAgainstMetaSchema(\n    schema: unknown,\n  ): asserts schema is DataSchema {\n    const isValid = this.dataSchemaValidator(schema);\n\n    if (!isValid) {\n      const errors = this.dataSchemaValidator.errors ?? [];\n      const errorMessage = `Data schema validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n\n    // Additional validation based on dialect\n    const typedSchema = schema as DataSchema;\n    if (\n      typedSchema.dialect === \"json\" &&\n      typeof typedSchema.schema === \"object\"\n    ) {\n      // Validate that the embedded JSON Schema is actually valid\n      try {\n        this.ajv.compile(typedSchema.schema);\n      } catch (error) {\n        const errorMessage = `Invalid JSON Schema in data schema: ${error instanceof Error ? error.message : \"Unknown schema compilation error\"}`;\n        throw new SchemaValidationError(errorMessage, []);\n      }\n    } else if (\n      typedSchema.dialect === \"sqlite\" &&\n      typeof typedSchema.schema === \"string\"\n    ) {\n      // Validate SQLite DDL syntax\n      this.validateSQLiteDDL(typedSchema.schema, typedSchema.dialectVersion);\n    }\n  }\n\n  /**\n   * Validates data against a JSON Schema\n   *\n   * @param data - The data to validate\n   * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * // Works with Schema from schemas.get()\n   * const schema = await vana.schemas.get(1);\n   * validator.validateDataAgainstSchema(userData, schema);\n   *\n   * // Also works with pre-validated DataSchema object\n   * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n   * });\n   * validator.validateDataAgainstSchema(userData, dataSchema);\n   * ```\n   */\n  validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void {\n    if (schema.dialect !== \"json\") {\n      console.warn(\n        `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. ` +\n          `Only JSON schemas can validate data structure.`,\n      );\n      return;\n    }\n\n    if (typeof schema.schema !== \"object\") {\n      throw new SchemaValidationError(\n        \"JSON dialect schemas must have an object schema\",\n        [],\n      );\n    }\n\n    // Compile and validate against the data schema\n    const dataValidator = this.ajv.compile(schema.schema);\n    const isValid = dataValidator(data);\n\n    if (!isValid) {\n      const errors = dataValidator.errors ?? [];\n      const errorMessage = `Data validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n  }\n\n  /**\n   * Validates a SQLite DDL string for basic syntax\n   * Note: This is a basic validation, full SQL parsing would require a proper SQL parser\n   *\n   * @param ddl - The DDL string to validate\n   * @param dialectVersion - Optional SQLite version (e.g., \"3\" for SQLite v3)\n   * @throws SchemaValidationError if invalid\n   */\n  validateSQLiteDDL(ddl: string, dialectVersion?: string): void {\n    if (typeof ddl !== \"string\" || ddl.trim().length === 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must be a non-empty string\",\n        [],\n      );\n    }\n\n    // Validate dialectVersion if provided\n    if (dialectVersion !== undefined) {\n      const supportedVersions = [\"3\"];\n      if (!supportedVersions.includes(dialectVersion)) {\n        throw new SchemaValidationError(\n          `Unsupported SQLite dialect version: ${dialectVersion}. Supported versions: ${supportedVersions.join(\", \")}`,\n          [],\n        );\n      }\n    }\n\n    // Basic validation - check for CREATE TABLE statements\n    const normalizedDDL = ddl.trim().toUpperCase();\n    if (!normalizedDDL.includes(\"CREATE TABLE\")) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must contain at least one CREATE TABLE statement\",\n        [],\n      );\n    }\n\n    // Check for balanced parentheses\n    let parenCount = 0;\n    for (const char of ddl) {\n      if (char === \"(\") parenCount++;\n      if (char === \")\") parenCount--;\n      if (parenCount < 0) {\n        throw new SchemaValidationError(\n          \"SQLite DDL has unbalanced parentheses\",\n          [],\n        );\n      }\n    }\n\n    if (parenCount !== 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL has unbalanced parentheses\",\n        [],\n      );\n    }\n  }\n\n  /**\n   * Fetches and validates a data schema from a URL\n   *\n   * @param url - The URL to fetch the data schema from\n   * @param downloadRelayer - Optional download relayer for CORS bypass\n   * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n   * @returns The validated data schema\n   * @throws SchemaValidationError if invalid or fetch fails\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   * const schema = await validator.fetchAndValidateSchema(\"https://example.com/schema.json\");\n   * ```\n   */\n  async fetchAndValidateSchema(\n    url: string,\n    downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n  ): Promise<DataSchema> {\n    try {\n      const { universalFetch } = await import(\"./download\");\n      const response = await universalFetch(url, downloadRelayer);\n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n\n      const schema = await response.json();\n      this.validateDataSchemaAgainstMetaSchema(schema);\n\n      // Additional validation based on dialect\n      if (schema.dialect === \"sqlite\" && typeof schema.schema === \"string\") {\n        this.validateSQLiteDDL(schema.schema, schema.dialectVersion);\n      }\n\n      return schema;\n    } catch (error) {\n      if (error instanceof SchemaValidationError) {\n        throw error;\n      }\n\n      throw new SchemaValidationError(\n        `Failed to fetch and validate schema from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n        [],\n      );\n    }\n  }\n}\n\n/**\n * Global schema validator instance\n */\nexport const schemaValidator = new SchemaValidator();\n\n/**\n * Convenience function to validate a data schema definition against the Vana meta-schema\n *\n * @param schema - The data schema definition to validate\n * @returns The validated DataSchema\n * @throws SchemaValidationError if invalid\n * @example\n * ```typescript\n * const schemaDefinition = {\n *   name: \"User Profile\",\n *   version: \"1.0.0\",\n *   dialect: \"json\",\n *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n * };\n *\n * const validatedSchema = validateDataSchemaAgainstMetaSchema(schemaDefinition);\n * ```\n */\nexport function validateDataSchemaAgainstMetaSchema(\n  schema: unknown,\n): DataSchema {\n  const validator: SchemaValidator = schemaValidator;\n  validator.validateDataSchemaAgainstMetaSchema(schema);\n  // If we get here, schema is valid and typed as DataSchema\n  return schema;\n}\n\n/**\n * Convenience function to validate data against a schema\n *\n * @param data - The data to validate\n * @param schema - The data schema containing the schema\n * @returns void - Function doesn't return a value\n * @throws SchemaValidationError if invalid\n */\nexport function validateDataAgainstSchema(\n  data: unknown,\n  schema: DataSchema | Schema,\n): void {\n  schemaValidator.validateDataAgainstSchema(data, schema);\n}\n\n/**\n * Convenience function to fetch and validate a data schema from a URL\n *\n * @param url - The URL to fetch the data schema from\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns The validated data schema\n * @throws SchemaValidationError if invalid or fetch fails\n */\nexport function fetchAndValidateSchema(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<DataSchema> {\n  return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);\n}\n"],"mappings":"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","names":[]}

package/dist/utils/signatureCache.cjs

@@ -24,7 +24,6 @@ __export(signatureCache_exports, {
 module.exports = __toCommonJS(signatureCache_exports);
 var import_viem = require("viem");
 var import_sha256 = require("@noble/hashes/sha256");
-var import_utils = require("@noble/hashes/utils");
 class SignatureCache {
   static PREFIX = "vana_sig_";
   static DEFAULT_TTL_HOURS = 2;
@@ -143,7 +142,7 @@ class SignatureCache {
   static hashMessage(message) {
     const jsonString = JSON.stringify(message, this.deterministicReplacer);
     const hashBytes = (0, import_sha256.sha256)(new TextEncoder().encode(jsonString));
-    return (0, import_utils.bytesToHex)(hashBytes);
+    return (0, import_viem.toHex)(hashBytes);
   }
   /**
    * Deterministic JSON replacer that handles BigInt values and sorts object keys

package/dist/utils/signatureCache.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/signatureCache.ts"],"sourcesContent":["import { Hash, getAddress } from \"viem\";\nimport type { VanaCacheAdapter } from \"../platform/interface\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { bytesToHex } from \"@noble/hashes/utils\";\n\ninterface CachedSignature {\n  signature: Hash;\n  expires: number;\n}\n\n/**\n * Simple signature cache using platform cache adapter to avoid repeated signing of identical messages.\n *\n * @remarks\n * This cache significantly improves UX by avoiding repeated wallet signature prompts\n * for identical operations. It's particularly useful for operations that may be\n * retried or called multiple times with the same parameters.\n *\n * Features:\n * - Platform-appropriate storage (sessionStorage in browser, memory in Node.js)\n * - Configurable TTL (default 2 hours)\n * - Automatic cleanup of expired entries\n * - Cache keys based on wallet address + message hash\n *\n * @example\n * ```typescript\n * // Check cache before requesting signature\n * const cached = SignatureCache.get(cache, walletAddress, messageHash);\n * if (cached) {\n *   return cached;\n * }\n *\n * // Request signature and cache it\n * const signature = await wallet.signTypedData(typedData);\n * SignatureCache.set(cache, walletAddress, messageHash, signature);\n * ```\n * @category Utilities\n */\nexport class SignatureCache {\n  private static readonly PREFIX = \"vana_sig_\";\n  private static readonly DEFAULT_TTL_HOURS = 2;\n\n  /**\n   * Get a cached signature if it exists and hasn't expired\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @returns The cached signature if valid, null if expired or not found\n   * @example\n   * ```typescript\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   * const cached = SignatureCache.get(cache, '0x123...', messageHash);\n   * if (cached) {\n   *   console.log('Using cached signature:', cached);\n   * }\n   * ```\n   */\n  static get(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n  ): Hash | null {\n    const key = this.getCacheKey(walletAddress, messageHash);\n\n    try {\n      const stored = cache.get(key);\n      if (!stored) return null;\n\n      const cached: CachedSignature = JSON.parse(stored);\n\n      // Check if expired\n      if (Date.now() > cached.expires) {\n        cache.delete(key);\n        return null;\n      }\n\n      return cached.signature;\n    } catch {\n      // Invalid JSON or storage error, clean up\n      try {\n        cache.delete(key);\n      } catch {\n        // Ignore cache cleanup errors\n      }\n      return null;\n    }\n  }\n\n  /**\n   * Store a signature in the cache with configurable TTL\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @param signature - The signature to cache\n   * @param ttlHours - Time to live in hours (default: 2)\n   * @example\n   * ```typescript\n   * const signature = await wallet.signTypedData(typedData);\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   *\n   * // Cache for default 2 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature);\n   *\n   * // Cache for 24 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature, 24);\n   * ```\n   */\n  static set(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n    signature: Hash,\n    ttlHours: number = this.DEFAULT_TTL_HOURS,\n  ): void {\n    const key = this.getCacheKey(walletAddress, messageHash);\n    const cached: CachedSignature = {\n      signature,\n      expires: Date.now() + ttlHours * 3600000, // Convert hours to milliseconds\n    };\n\n    try {\n      cache.set(key, JSON.stringify(cached));\n    } catch {\n      // Storage quota exceeded or other error, ignore silently\n      // Better to continue without caching than to fail\n    }\n  }\n\n  /**\n   * Clear all cached signatures (useful for testing or explicit cleanup)\n   *\n   * @param cache - Platform cache adapter instance\n   * @example\n   * ```typescript\n   * // Clear all signatures when user logs out\n   * SignatureCache.clear(cache);\n   *\n   * // Clear before running tests\n   * beforeEach(() => {\n   *   SignatureCache.clear(cache);\n   * });\n   * ```\n   */\n  static clear(cache: VanaCacheAdapter): void {\n    try {\n      cache.clear();\n    } catch {\n      // Ignore storage errors\n    }\n  }\n\n  private static getCacheKey(\n    walletAddress: string,\n    messageHash: string,\n  ): string {\n    return `${this.PREFIX}${getAddress(walletAddress)}:${messageHash}`;\n  }\n\n  /**\n   * Generate a deterministic hash of a message object for cache key generation\n   *\n   * @remarks\n   * Creates a cryptographically secure hash from complex objects including EIP-712 typed data.\n   * Uses SHA-256 for collision resistance and deterministic key generation.\n   * Handles BigInt serialization and sorts object keys for consistency.\n   *\n   * @param message - The message object to hash (typically EIP-712 typed data)\n   * @returns A hex string hash (SHA-256) suitable for cache keys\n   * @example\n   * ```typescript\n   * const typedData = {\n   *   domain: { name: 'Vana', version: '1' },\n   *   message: { nonce: 123n, grant: '...' }\n   * };\n   *\n   * const hash = SignatureCache.hashMessage(typedData);\n   * // Returns SHA-256 hash like: \"a1b2c3d4e5f6...\"\n   * ```\n   */\n  static hashMessage(message: object): string {\n    // Deterministically stringify the object with sorted keys\n    const jsonString = JSON.stringify(message, this.deterministicReplacer);\n\n    // Use SHA-256 for cryptographic hashing\n    const hashBytes = sha256(new TextEncoder().encode(jsonString));\n    return bytesToHex(hashBytes);\n  }\n\n  /**\n   * Deterministic JSON replacer that handles BigInt values and sorts object keys\n   * This ensures consistent cache key generation for EIP-712 typed data\n   *\n   * @param _key - The object key being serialized (unused)\n   * @param value - The value to serialize\n   * @returns The serialized value with sorted keys for objects\n   */\n  private static deterministicReplacer(_key: string, value: unknown): unknown {\n    if (typeof value === \"bigint\") {\n      return `__BIGINT__${value.toString()}`;\n    }\n    // Sort object keys for deterministic serialization\n    if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n      return Object.keys(value as Record<string, unknown>)\n        .sort()\n        .reduce(\n          (sorted, key) => {\n            sorted[key] = (value as Record<string, unknown>)[key];\n            return sorted;\n          },\n          {} as Record<string, unknown>,\n        );\n    }\n    return value;\n  }\n}\n\n/**\n * Wrapper function to cache signature operations\n *\n * @param cache - The cache adapter to use for storage\n * @param walletAddress - The wallet address signing the message\n * @param typedData - The EIP-712 typed data being signed\n * @param signFn - Function that performs the actual signing\n * @param ttlHours - Cache TTL in hours (default 2)\n * @returns The signature (cached or newly generated)\n */\nexport async function withSignatureCache(\n  cache: VanaCacheAdapter,\n  walletAddress: string,\n  typedData: Record<string, unknown>,\n  signFn: () => Promise<Hash>,\n  ttlHours?: number,\n): Promise<Hash> {\n  // Create a hash of the typed data for the cache key\n  const messageHash = SignatureCache.hashMessage(typedData);\n\n  // Try to get from cache first\n  const cached = SignatureCache.get(cache, walletAddress, messageHash);\n  if (cached) {\n    return cached;\n  }\n\n  // Not in cache, sign and store\n  const signature = await signFn();\n  SignatureCache.set(cache, walletAddress, messageHash, signature, ttlHours);\n\n  return signature;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/utils/signatureCache.ts"],"sourcesContent":["import type { Hash } from \"viem\";\nimport { getAddress, toHex } from \"viem\";\nimport type { VanaCacheAdapter } from \"../platform/interface\";\nimport { sha256 } from \"@noble/hashes/sha256\";\n\ninterface CachedSignature {\n  signature: Hash;\n  expires: number;\n}\n\n/**\n * Simple signature cache using platform cache adapter to avoid repeated signing of identical messages.\n *\n * @remarks\n * This cache significantly improves UX by avoiding repeated wallet signature prompts\n * for identical operations. It's particularly useful for operations that may be\n * retried or called multiple times with the same parameters.\n *\n * Features:\n * - Platform-appropriate storage (sessionStorage in browser, memory in Node.js)\n * - Configurable TTL (default 2 hours)\n * - Automatic cleanup of expired entries\n * - Cache keys based on wallet address + message hash\n *\n * @example\n * ```typescript\n * // Check cache before requesting signature\n * const cached = SignatureCache.get(cache, walletAddress, messageHash);\n * if (cached) {\n *   return cached;\n * }\n *\n * // Request signature and cache it\n * const signature = await wallet.signTypedData(typedData);\n * SignatureCache.set(cache, walletAddress, messageHash, signature);\n * ```\n * @category Utilities\n */\nexport class SignatureCache {\n  private static readonly PREFIX = \"vana_sig_\";\n  private static readonly DEFAULT_TTL_HOURS = 2;\n\n  /**\n   * Get a cached signature if it exists and hasn't expired\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @returns The cached signature if valid, null if expired or not found\n   * @example\n   * ```typescript\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   * const cached = SignatureCache.get(cache, '0x123...', messageHash);\n   * if (cached) {\n   *   console.log('Using cached signature:', cached);\n   * }\n   * ```\n   */\n  static get(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n  ): Hash | null {\n    const key = this.getCacheKey(walletAddress, messageHash);\n\n    try {\n      const stored = cache.get(key);\n      if (!stored) return null;\n\n      const cached: CachedSignature = JSON.parse(stored);\n\n      // Check if expired\n      if (Date.now() > cached.expires) {\n        cache.delete(key);\n        return null;\n      }\n\n      return cached.signature;\n    } catch {\n      // Invalid JSON or storage error, clean up\n      try {\n        cache.delete(key);\n      } catch {\n        // Ignore cache cleanup errors\n      }\n      return null;\n    }\n  }\n\n  /**\n   * Store a signature in the cache with configurable TTL\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @param signature - The signature to cache\n   * @param ttlHours - Time to live in hours (default: 2)\n   * @example\n   * ```typescript\n   * const signature = await wallet.signTypedData(typedData);\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   *\n   * // Cache for default 2 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature);\n   *\n   * // Cache for 24 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature, 24);\n   * ```\n   */\n  static set(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n    signature: Hash,\n    ttlHours: number = this.DEFAULT_TTL_HOURS,\n  ): void {\n    const key = this.getCacheKey(walletAddress, messageHash);\n    const cached: CachedSignature = {\n      signature,\n      expires: Date.now() + ttlHours * 3600000, // Convert hours to milliseconds\n    };\n\n    try {\n      cache.set(key, JSON.stringify(cached));\n    } catch {\n      // Storage quota exceeded or other error, ignore silently\n      // Better to continue without caching than to fail\n    }\n  }\n\n  /**\n   * Clear all cached signatures (useful for testing or explicit cleanup)\n   *\n   * @param cache - Platform cache adapter instance\n   * @example\n   * ```typescript\n   * // Clear all signatures when user logs out\n   * SignatureCache.clear(cache);\n   *\n   * // Clear before running tests\n   * beforeEach(() => {\n   *   SignatureCache.clear(cache);\n   * });\n   * ```\n   */\n  static clear(cache: VanaCacheAdapter): void {\n    try {\n      cache.clear();\n    } catch {\n      // Ignore storage errors\n    }\n  }\n\n  private static getCacheKey(\n    walletAddress: string,\n    messageHash: string,\n  ): string {\n    return `${this.PREFIX}${getAddress(walletAddress)}:${messageHash}`;\n  }\n\n  /**\n   * Generate a deterministic hash of a message object for cache key generation\n   *\n   * @remarks\n   * Creates a cryptographically secure hash from complex objects including EIP-712 typed data.\n   * Uses SHA-256 for collision resistance and deterministic key generation.\n   * Handles BigInt serialization and sorts object keys for consistency.\n   *\n   * @param message - The message object to hash (typically EIP-712 typed data)\n   * @returns A hex string hash (SHA-256) suitable for cache keys\n   * @example\n   * ```typescript\n   * const typedData = {\n   *   domain: { name: 'Vana', version: '1' },\n   *   message: { nonce: 123n, grant: '...' }\n   * };\n   *\n   * const hash = SignatureCache.hashMessage(typedData);\n   * // Returns SHA-256 hash like: \"a1b2c3d4e5f6...\"\n   * ```\n   */\n  static hashMessage(message: object): string {\n    // Deterministically stringify the object with sorted keys\n    const jsonString = JSON.stringify(message, this.deterministicReplacer);\n\n    // Use SHA-256 for cryptographic hashing\n    const hashBytes = sha256(new TextEncoder().encode(jsonString));\n    return toHex(hashBytes);\n  }\n\n  /**\n   * Deterministic JSON replacer that handles BigInt values and sorts object keys\n   * This ensures consistent cache key generation for EIP-712 typed data\n   *\n   * @param _key - The object key being serialized (unused)\n   * @param value - The value to serialize\n   * @returns The serialized value with sorted keys for objects\n   */\n  private static deterministicReplacer(_key: string, value: unknown): unknown {\n    if (typeof value === \"bigint\") {\n      return `__BIGINT__${value.toString()}`;\n    }\n    // Sort object keys for deterministic serialization\n    if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n      return Object.keys(value as Record<string, unknown>)\n        .sort()\n        .reduce(\n          (sorted, key) => {\n            sorted[key] = (value as Record<string, unknown>)[key];\n            return sorted;\n          },\n          {} as Record<string, unknown>,\n        );\n    }\n    return value;\n  }\n}\n\n/**\n * Wrapper function to cache signature operations\n *\n * @param cache - The cache adapter to use for storage\n * @param walletAddress - The wallet address signing the message\n * @param typedData - The EIP-712 typed data being signed\n * @param signFn - Function that performs the actual signing\n * @param ttlHours - Cache TTL in hours (default 2)\n * @returns The signature (cached or newly generated)\n */\nexport async function withSignatureCache(\n  cache: VanaCacheAdapter,\n  walletAddress: string,\n  typedData: Record<string, unknown>,\n  signFn: () => Promise<Hash>,\n  ttlHours?: number,\n): Promise<Hash> {\n  // Create a hash of the typed data for the cache key\n  const messageHash = SignatureCache.hashMessage(typedData);\n\n  // Try to get from cache first\n  const cached = SignatureCache.get(cache, walletAddress, messageHash);\n  if (cached) {\n    return cached;\n  }\n\n  // Not in cache, sign and store\n  const signature = await signFn();\n  SignatureCache.set(cache, walletAddress, messageHash, signature, ttlHours);\n\n  return signature;\n}\n"],"mappings":"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","names":[]}

package/dist/utils/signatureCache.d.ts

@@ -1,6 +1,5 @@
-import { Hash } from 'viem';
-import { VanaCacheAdapter } from '../platform/interface.js';
-
+import type { Hash } from "viem";
+import type { VanaCacheAdapter } from "../platform/interface";
 /**
  * Simple signature cache using platform cache adapter to avoid repeated signing of identical messages.
  *
@@ -29,7 +28,7 @@ import { VanaCacheAdapter } from '../platform/interface.js';
  * ```
  * @category Utilities
  */
-declare class SignatureCache {
+export declare class SignatureCache {
     private static readonly PREFIX;
     private static readonly DEFAULT_TTL_HOURS;
     /**
@@ -129,6 +128,4 @@ declare class SignatureCache {
  * @param ttlHours - Cache TTL in hours (default 2)
  * @returns The signature (cached or newly generated)
  */
-declare function withSignatureCache(cache: VanaCacheAdapter, walletAddress: string, typedData: Record<string, unknown>, signFn: () => Promise<Hash>, ttlHours?: number): Promise<Hash>;
-
-export { SignatureCache, withSignatureCache };
+export declare function withSignatureCache(cache: VanaCacheAdapter, walletAddress: string, typedData: Record<string, unknown>, signFn: () => Promise<Hash>, ttlHours?: number): Promise<Hash>;

package/dist/utils/signatureCache.js

@@ -1,10 +1,8 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { getAddress } from "viem";
+import { getAddress, toHex } from "viem";
 import { sha256 } from "@noble/hashes/sha256";
-import { bytesToHex } from "@noble/hashes/utils";
 class SignatureCache {
+  static PREFIX = "vana_sig_";
+  static DEFAULT_TTL_HOURS = 2;
   /**
    * Get a cached signature if it exists and hasn't expired
    *
@@ -120,7 +118,7 @@ class SignatureCache {
   static hashMessage(message) {
     const jsonString = JSON.stringify(message, this.deterministicReplacer);
     const hashBytes = sha256(new TextEncoder().encode(jsonString));
-    return bytesToHex(hashBytes);
+    return toHex(hashBytes);
   }
   /**
    * Deterministic JSON replacer that handles BigInt values and sorts object keys
@@ -146,8 +144,6 @@ class SignatureCache {
     return value;
   }
 }
-__publicField(SignatureCache, "PREFIX", "vana_sig_");
-__publicField(SignatureCache, "DEFAULT_TTL_HOURS", 2);
 async function withSignatureCache(cache, walletAddress, typedData, signFn, ttlHours) {
   const messageHash = SignatureCache.hashMessage(typedData);
   const cached = SignatureCache.get(cache, walletAddress, messageHash);

package/dist/utils/signatureCache.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/signatureCache.ts"],"sourcesContent":["import { Hash, getAddress } from \"viem\";\nimport type { VanaCacheAdapter } from \"../platform/interface\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { bytesToHex } from \"@noble/hashes/utils\";\n\ninterface CachedSignature {\n  signature: Hash;\n  expires: number;\n}\n\n/**\n * Simple signature cache using platform cache adapter to avoid repeated signing of identical messages.\n *\n * @remarks\n * This cache significantly improves UX by avoiding repeated wallet signature prompts\n * for identical operations. It's particularly useful for operations that may be\n * retried or called multiple times with the same parameters.\n *\n * Features:\n * - Platform-appropriate storage (sessionStorage in browser, memory in Node.js)\n * - Configurable TTL (default 2 hours)\n * - Automatic cleanup of expired entries\n * - Cache keys based on wallet address + message hash\n *\n * @example\n * ```typescript\n * // Check cache before requesting signature\n * const cached = SignatureCache.get(cache, walletAddress, messageHash);\n * if (cached) {\n *   return cached;\n * }\n *\n * // Request signature and cache it\n * const signature = await wallet.signTypedData(typedData);\n * SignatureCache.set(cache, walletAddress, messageHash, signature);\n * ```\n * @category Utilities\n */\nexport class SignatureCache {\n  private static readonly PREFIX = \"vana_sig_\";\n  private static readonly DEFAULT_TTL_HOURS = 2;\n\n  /**\n   * Get a cached signature if it exists and hasn't expired\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @returns The cached signature if valid, null if expired or not found\n   * @example\n   * ```typescript\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   * const cached = SignatureCache.get(cache, '0x123...', messageHash);\n   * if (cached) {\n   *   console.log('Using cached signature:', cached);\n   * }\n   * ```\n   */\n  static get(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n  ): Hash | null {\n    const key = this.getCacheKey(walletAddress, messageHash);\n\n    try {\n      const stored = cache.get(key);\n      if (!stored) return null;\n\n      const cached: CachedSignature = JSON.parse(stored);\n\n      // Check if expired\n      if (Date.now() > cached.expires) {\n        cache.delete(key);\n        return null;\n      }\n\n      return cached.signature;\n    } catch {\n      // Invalid JSON or storage error, clean up\n      try {\n        cache.delete(key);\n      } catch {\n        // Ignore cache cleanup errors\n      }\n      return null;\n    }\n  }\n\n  /**\n   * Store a signature in the cache with configurable TTL\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @param signature - The signature to cache\n   * @param ttlHours - Time to live in hours (default: 2)\n   * @example\n   * ```typescript\n   * const signature = await wallet.signTypedData(typedData);\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   *\n   * // Cache for default 2 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature);\n   *\n   * // Cache for 24 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature, 24);\n   * ```\n   */\n  static set(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n    signature: Hash,\n    ttlHours: number = this.DEFAULT_TTL_HOURS,\n  ): void {\n    const key = this.getCacheKey(walletAddress, messageHash);\n    const cached: CachedSignature = {\n      signature,\n      expires: Date.now() + ttlHours * 3600000, // Convert hours to milliseconds\n    };\n\n    try {\n      cache.set(key, JSON.stringify(cached));\n    } catch {\n      // Storage quota exceeded or other error, ignore silently\n      // Better to continue without caching than to fail\n    }\n  }\n\n  /**\n   * Clear all cached signatures (useful for testing or explicit cleanup)\n   *\n   * @param cache - Platform cache adapter instance\n   * @example\n   * ```typescript\n   * // Clear all signatures when user logs out\n   * SignatureCache.clear(cache);\n   *\n   * // Clear before running tests\n   * beforeEach(() => {\n   *   SignatureCache.clear(cache);\n   * });\n   * ```\n   */\n  static clear(cache: VanaCacheAdapter): void {\n    try {\n      cache.clear();\n    } catch {\n      // Ignore storage errors\n    }\n  }\n\n  private static getCacheKey(\n    walletAddress: string,\n    messageHash: string,\n  ): string {\n    return `${this.PREFIX}${getAddress(walletAddress)}:${messageHash}`;\n  }\n\n  /**\n   * Generate a deterministic hash of a message object for cache key generation\n   *\n   * @remarks\n   * Creates a cryptographically secure hash from complex objects including EIP-712 typed data.\n   * Uses SHA-256 for collision resistance and deterministic key generation.\n   * Handles BigInt serialization and sorts object keys for consistency.\n   *\n   * @param message - The message object to hash (typically EIP-712 typed data)\n   * @returns A hex string hash (SHA-256) suitable for cache keys\n   * @example\n   * ```typescript\n   * const typedData = {\n   *   domain: { name: 'Vana', version: '1' },\n   *   message: { nonce: 123n, grant: '...' }\n   * };\n   *\n   * const hash = SignatureCache.hashMessage(typedData);\n   * // Returns SHA-256 hash like: \"a1b2c3d4e5f6...\"\n   * ```\n   */\n  static hashMessage(message: object): string {\n    // Deterministically stringify the object with sorted keys\n    const jsonString = JSON.stringify(message, this.deterministicReplacer);\n\n    // Use SHA-256 for cryptographic hashing\n    const hashBytes = sha256(new TextEncoder().encode(jsonString));\n    return bytesToHex(hashBytes);\n  }\n\n  /**\n   * Deterministic JSON replacer that handles BigInt values and sorts object keys\n   * This ensures consistent cache key generation for EIP-712 typed data\n   *\n   * @param _key - The object key being serialized (unused)\n   * @param value - The value to serialize\n   * @returns The serialized value with sorted keys for objects\n   */\n  private static deterministicReplacer(_key: string, value: unknown): unknown {\n    if (typeof value === \"bigint\") {\n      return `__BIGINT__${value.toString()}`;\n    }\n    // Sort object keys for deterministic serialization\n    if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n      return Object.keys(value as Record<string, unknown>)\n        .sort()\n        .reduce(\n          (sorted, key) => {\n            sorted[key] = (value as Record<string, unknown>)[key];\n            return sorted;\n          },\n          {} as Record<string, unknown>,\n        );\n    }\n    return value;\n  }\n}\n\n/**\n * Wrapper function to cache signature operations\n *\n * @param cache - The cache adapter to use for storage\n * @param walletAddress - The wallet address signing the message\n * @param typedData - The EIP-712 typed data being signed\n * @param signFn - Function that performs the actual signing\n * @param ttlHours - Cache TTL in hours (default 2)\n * @returns The signature (cached or newly generated)\n */\nexport async function withSignatureCache(\n  cache: VanaCacheAdapter,\n  walletAddress: string,\n  typedData: Record<string, unknown>,\n  signFn: () => Promise<Hash>,\n  ttlHours?: number,\n): Promise<Hash> {\n  // Create a hash of the typed data for the cache key\n  const messageHash = SignatureCache.hashMessage(typedData);\n\n  // Try to get from cache first\n  const cached = SignatureCache.get(cache, walletAddress, messageHash);\n  if (cached) {\n    return cached;\n  }\n\n  // Not in cache, sign and store\n  const signature = await signFn();\n  SignatureCache.set(cache, walletAddress, messageHash, signature, ttlHours);\n\n  return signature;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/utils/signatureCache.ts"],"sourcesContent":["import type { Hash } from \"viem\";\nimport { getAddress, toHex } from \"viem\";\nimport type { VanaCacheAdapter } from \"../platform/interface\";\nimport { sha256 } from \"@noble/hashes/sha256\";\n\ninterface CachedSignature {\n  signature: Hash;\n  expires: number;\n}\n\n/**\n * Simple signature cache using platform cache adapter to avoid repeated signing of identical messages.\n *\n * @remarks\n * This cache significantly improves UX by avoiding repeated wallet signature prompts\n * for identical operations. It's particularly useful for operations that may be\n * retried or called multiple times with the same parameters.\n *\n * Features:\n * - Platform-appropriate storage (sessionStorage in browser, memory in Node.js)\n * - Configurable TTL (default 2 hours)\n * - Automatic cleanup of expired entries\n * - Cache keys based on wallet address + message hash\n *\n * @example\n * ```typescript\n * // Check cache before requesting signature\n * const cached = SignatureCache.get(cache, walletAddress, messageHash);\n * if (cached) {\n *   return cached;\n * }\n *\n * // Request signature and cache it\n * const signature = await wallet.signTypedData(typedData);\n * SignatureCache.set(cache, walletAddress, messageHash, signature);\n * ```\n * @category Utilities\n */\nexport class SignatureCache {\n  private static readonly PREFIX = \"vana_sig_\";\n  private static readonly DEFAULT_TTL_HOURS = 2;\n\n  /**\n   * Get a cached signature if it exists and hasn't expired\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @returns The cached signature if valid, null if expired or not found\n   * @example\n   * ```typescript\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   * const cached = SignatureCache.get(cache, '0x123...', messageHash);\n   * if (cached) {\n   *   console.log('Using cached signature:', cached);\n   * }\n   * ```\n   */\n  static get(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n  ): Hash | null {\n    const key = this.getCacheKey(walletAddress, messageHash);\n\n    try {\n      const stored = cache.get(key);\n      if (!stored) return null;\n\n      const cached: CachedSignature = JSON.parse(stored);\n\n      // Check if expired\n      if (Date.now() > cached.expires) {\n        cache.delete(key);\n        return null;\n      }\n\n      return cached.signature;\n    } catch {\n      // Invalid JSON or storage error, clean up\n      try {\n        cache.delete(key);\n      } catch {\n        // Ignore cache cleanup errors\n      }\n      return null;\n    }\n  }\n\n  /**\n   * Store a signature in the cache with configurable TTL\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @param signature - The signature to cache\n   * @param ttlHours - Time to live in hours (default: 2)\n   * @example\n   * ```typescript\n   * const signature = await wallet.signTypedData(typedData);\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   *\n   * // Cache for default 2 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature);\n   *\n   * // Cache for 24 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature, 24);\n   * ```\n   */\n  static set(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n    signature: Hash,\n    ttlHours: number = this.DEFAULT_TTL_HOURS,\n  ): void {\n    const key = this.getCacheKey(walletAddress, messageHash);\n    const cached: CachedSignature = {\n      signature,\n      expires: Date.now() + ttlHours * 3600000, // Convert hours to milliseconds\n    };\n\n    try {\n      cache.set(key, JSON.stringify(cached));\n    } catch {\n      // Storage quota exceeded or other error, ignore silently\n      // Better to continue without caching than to fail\n    }\n  }\n\n  /**\n   * Clear all cached signatures (useful for testing or explicit cleanup)\n   *\n   * @param cache - Platform cache adapter instance\n   * @example\n   * ```typescript\n   * // Clear all signatures when user logs out\n   * SignatureCache.clear(cache);\n   *\n   * // Clear before running tests\n   * beforeEach(() => {\n   *   SignatureCache.clear(cache);\n   * });\n   * ```\n   */\n  static clear(cache: VanaCacheAdapter): void {\n    try {\n      cache.clear();\n    } catch {\n      // Ignore storage errors\n    }\n  }\n\n  private static getCacheKey(\n    walletAddress: string,\n    messageHash: string,\n  ): string {\n    return `${this.PREFIX}${getAddress(walletAddress)}:${messageHash}`;\n  }\n\n  /**\n   * Generate a deterministic hash of a message object for cache key generation\n   *\n   * @remarks\n   * Creates a cryptographically secure hash from complex objects including EIP-712 typed data.\n   * Uses SHA-256 for collision resistance and deterministic key generation.\n   * Handles BigInt serialization and sorts object keys for consistency.\n   *\n   * @param message - The message object to hash (typically EIP-712 typed data)\n   * @returns A hex string hash (SHA-256) suitable for cache keys\n   * @example\n   * ```typescript\n   * const typedData = {\n   *   domain: { name: 'Vana', version: '1' },\n   *   message: { nonce: 123n, grant: '...' }\n   * };\n   *\n   * const hash = SignatureCache.hashMessage(typedData);\n   * // Returns SHA-256 hash like: \"a1b2c3d4e5f6...\"\n   * ```\n   */\n  static hashMessage(message: object): string {\n    // Deterministically stringify the object with sorted keys\n    const jsonString = JSON.stringify(message, this.deterministicReplacer);\n\n    // Use SHA-256 for cryptographic hashing\n    const hashBytes = sha256(new TextEncoder().encode(jsonString));\n    return toHex(hashBytes);\n  }\n\n  /**\n   * Deterministic JSON replacer that handles BigInt values and sorts object keys\n   * This ensures consistent cache key generation for EIP-712 typed data\n   *\n   * @param _key - The object key being serialized (unused)\n   * @param value - The value to serialize\n   * @returns The serialized value with sorted keys for objects\n   */\n  private static deterministicReplacer(_key: string, value: unknown): unknown {\n    if (typeof value === \"bigint\") {\n      return `__BIGINT__${value.toString()}`;\n    }\n    // Sort object keys for deterministic serialization\n    if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n      return Object.keys(value as Record<string, unknown>)\n        .sort()\n        .reduce(\n          (sorted, key) => {\n            sorted[key] = (value as Record<string, unknown>)[key];\n            return sorted;\n          },\n          {} as Record<string, unknown>,\n        );\n    }\n    return value;\n  }\n}\n\n/**\n * Wrapper function to cache signature operations\n *\n * @param cache - The cache adapter to use for storage\n * @param walletAddress - The wallet address signing the message\n * @param typedData - The EIP-712 typed data being signed\n * @param signFn - Function that performs the actual signing\n * @param ttlHours - Cache TTL in hours (default 2)\n * @returns The signature (cached or newly generated)\n */\nexport async function withSignatureCache(\n  cache: VanaCacheAdapter,\n  walletAddress: string,\n  typedData: Record<string, unknown>,\n  signFn: () => Promise<Hash>,\n  ttlHours?: number,\n): Promise<Hash> {\n  // Create a hash of the typed data for the cache key\n  const messageHash = SignatureCache.hashMessage(typedData);\n\n  // Try to get from cache first\n  const cached = SignatureCache.get(cache, walletAddress, messageHash);\n  if (cached) {\n    return cached;\n  }\n\n  // Not in cache, sign and store\n  const signature = await signFn();\n  SignatureCache.set(cache, walletAddress, messageHash, signature, ttlHours);\n\n  return signature;\n}\n"],"mappings":"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","names":[]}