@opendatalabs/vana-sdk 0.1.0-alpha.db07fe1 → 0.1.0-alpha.dc68f39

package/dist/contracts/contractController.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var contractController_exports = {};
+__export(contractController_exports, {
+  ContractFactory: () => ContractFactory,
+  clearContractCache: () => clearContractCache,
+  contractCacheForTesting: () => contractCacheForTesting,
+  getContractController: () => getContractController,
+  getContractInfo: () => getContractInfo
+});
+module.exports = __toCommonJS(contractController_exports);
+var import_viem = require("viem");
+var import_abi = require("../generated/abi");
+var import_addresses = require("../config/addresses");
+var import_client = require("../core/client");
+var import_chains = require("../config/chains");
+const contractCache = /* @__PURE__ */ new Map();
+const contractCacheForTesting = contractCache;
+function createCacheKey(contract, chainId) {
+  return `${contract}:${chainId}`;
+}
+function getContractController(contract, client = (0, import_client.createClient)()) {
+  const chainId = client.chain?.id ?? import_chains.vanaMainnet.id;
+  const cacheKey = createCacheKey(contract, chainId);
+  let controller = contractCache.get(cacheKey);
+  if (!controller) {
+    controller = (0, import_viem.getContract)({
+      address: (0, import_addresses.getContractAddress)(chainId, contract),
+      abi: (0, import_abi.getAbi)(contract),
+      client
+    });
+    contractCache.set(cacheKey, controller);
+  }
+  return controller;
+}
+function getContractInfo(contract, chainId = import_chains.vanaMainnet.id) {
+  return {
+    address: (0, import_addresses.getContractAddress)(chainId, contract),
+    abi: (0, import_abi.getAbi)(contract)
+  };
+}
+class ContractFactory {
+  client;
+  chainId;
+  constructor(client) {
+    this.client = client;
+    try {
+      this.chainId = client.chain?.id ?? import_chains.vanaMainnet.id;
+    } catch {
+      this.chainId = import_chains.vanaMainnet.id;
+    }
+  }
+  /**
+   * Creates a typed contract instance
+   *
+   * @param contract - Contract name (use const assertion for full typing)
+   * @returns Fully typed contract instance
+   */
+  create(contract) {
+    return getContractController(contract, this.client);
+  }
+  /**
+   * Gets contract information without creating an instance
+   *
+   * @param contract - Contract name
+   * @returns Contract information with typed ABI
+   */
+  getInfo(contract) {
+    return getContractInfo(contract, this.chainId);
+  }
+  /**
+   * Lists all available contracts for the current chain
+   *
+   * @returns Array of contract names available on this chain
+   */
+  getAvailableContracts() {
+    const chainAddresses = import_addresses.CONTRACT_ADDRESSES[this.chainId];
+    if (!chainAddresses) return [];
+    return Object.keys(chainAddresses);
+  }
+}
+function clearContractCache(contract, chainId) {
+  if (contract && chainId) {
+    const cacheKey = createCacheKey(contract, chainId);
+    contractCache.delete(cacheKey);
+  } else if (contract) {
+    for (const key of contractCache.keys()) {
+      if (key.startsWith(`${contract}:`)) {
+        contractCache.delete(key);
+      }
+    }
+  } else if (chainId) {
+    for (const key of contractCache.keys()) {
+      if (key.endsWith(`:${chainId}`)) {
+        contractCache.delete(key);
+      }
+    }
+  } else {
+    contractCache.clear();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContractFactory,
+  clearContractCache,
+  contractCacheForTesting,
+  getContractController,
+  getContractInfo
+});
+//# sourceMappingURL=contractController.cjs.map

package/dist/contracts/contractController.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/contracts/contractController.ts"],"sourcesContent":["import type { Abi } from \"abitype\";\nimport {\n  getContract,\n  type GetContractReturnType,\n  type PublicClient,\n  type WalletClient,\n} from \"viem\";\nimport { type ContractAbis, getAbi, type VanaContract } from \"../generated/abi\";\nimport type { VanaChainId, ContractInfo } from \"../types/index\";\nimport { getContractAddress, CONTRACT_ADDRESSES } from \"../config/addresses\";\nimport { createClient } from \"../core/client\";\nimport { vanaMainnet } from \"../config/chains\";\n\n// Cache for contract instances - keyed by contract name and chain ID\nconst contractCache = new Map<string, GetContractReturnType<Abi>>();\n\n// Export cache for testing\nexport const contractCacheForTesting = contractCache;\n\n/**\n * Creates a cache key for contract instances\n *\n * @param contract - The contract name to create a cache key for\n * @param chainId - The chain ID to include in the cache key\n * @returns A string cache key combining contract name and chain ID\n */\nfunction createCacheKey(contract: VanaContract, chainId: number): string {\n  return `${contract}:${chainId}`;\n}\n\n/**\n * Gets a typed contract instance for the specified contract name with full type inference.\n * This function provides complete type safety following viem's patterns.\n *\n * @param contract - Name of the contract to instantiate (must be a const assertion for full typing)\n * @param client - Optional viem client instance\n * @returns A fully typed contract instance with methods corresponding to the contract's ABI\n * @example\n * ```typescript\n * // Full type inference with const assertion\n * const dataRegistry = getContractController(\"DataRegistry\" as const, client);\n *\n * // Now dataRegistry has full type inference for all methods\n * const result = await dataRegistry.read.getFileCount(); // Type: bigint\n * await dataRegistry.write.addFile([url, proof]); // Typed parameters\n * ```\n */\nexport function getContractController<T extends VanaContract>(\n  contract: T,\n  client:\n    | PublicClient\n    | WalletClient\n    | ReturnType<typeof createClient> = createClient(),\n): GetContractReturnType<ContractAbis[T]> {\n  const chainId = client.chain?.id ?? vanaMainnet.id;\n  const cacheKey = createCacheKey(contract, chainId);\n\n  let controller = contractCache.get(cacheKey);\n\n  if (!controller) {\n    controller = getContract({\n      address: getContractAddress(chainId, contract),\n      abi: getAbi(contract),\n      client,\n    }) as GetContractReturnType<ContractAbis[T]>;\n\n    contractCache.set(cacheKey, controller);\n  }\n\n  return controller as GetContractReturnType<ContractAbis[T]>;\n}\n\n/**\n * Gets contract information (address and ABI) without creating a contract instance.\n * Useful for cases where you need contract details but don't want to create a client connection.\n *\n * @param contract - Name of the contract\n * @param chainId - Chain ID (defaults to Vana mainnet)\n * @returns Contract information with typed ABI\n * @example\n * ```typescript\n * const info = getContractInfo(\"DataRegistry\" as const, 14800);\n * console.log(info.address); // Typed as Address\n * console.log(info.abi); // Fully typed ABI\n * ```\n */\nexport function getContractInfo<T extends VanaContract>(\n  contract: T,\n  chainId: VanaChainId = vanaMainnet.id as VanaChainId,\n): ContractInfo<ContractAbis[T]> {\n  return {\n    address: getContractAddress(chainId, contract),\n    abi: getAbi(contract),\n  };\n}\n\n/**\n * Type-safe contract factory that creates contract instances with full type inference.\n * This provides an alternative API that's more explicit about typing.\n */\nexport class ContractFactory {\n  private readonly client:\n    | PublicClient\n    | WalletClient\n    | ReturnType<typeof createClient>;\n  private readonly chainId: number;\n\n  constructor(\n    client: PublicClient | WalletClient | ReturnType<typeof createClient>,\n  ) {\n    this.client = client;\n    try {\n      this.chainId = client.chain?.id ?? vanaMainnet.id;\n    } catch {\n      this.chainId = vanaMainnet.id;\n    }\n  }\n\n  /**\n   * Creates a typed contract instance\n   *\n   * @param contract - Contract name (use const assertion for full typing)\n   * @returns Fully typed contract instance\n   */\n  create<T extends VanaContract>(\n    contract: T,\n  ): GetContractReturnType<ContractAbis[T]> {\n    return getContractController(contract, this.client);\n  }\n\n  /**\n   * Gets contract information without creating an instance\n   *\n   * @param contract - Contract name\n   * @returns Contract information with typed ABI\n   */\n  getInfo<T extends VanaContract>(contract: T): ContractInfo<ContractAbis[T]> {\n    return getContractInfo(contract, this.chainId as VanaChainId);\n  }\n\n  /**\n   * Lists all available contracts for the current chain\n   *\n   * @returns Array of contract names available on this chain\n   */\n  getAvailableContracts(): VanaContract[] {\n    // Return all contract names that have addresses on this chain\n    const chainAddresses = CONTRACT_ADDRESSES[this.chainId];\n    if (!chainAddresses) return [];\n\n    return Object.keys(chainAddresses) as VanaContract[];\n  }\n}\n\n/**\n * Clears the contract cache. Useful for testing or when chain configurations change.\n *\n * @param contract - Optional specific contract to clear, or clear all if not provided\n * @param chainId - Optional specific chain to clear, or clear all if not provided\n */\nexport function clearContractCache(\n  contract?: VanaContract,\n  chainId?: number,\n): void {\n  if (contract && chainId) {\n    const cacheKey = createCacheKey(contract, chainId);\n    contractCache.delete(cacheKey);\n  } else if (contract) {\n    // Clear all instances of this contract across all chains\n    for (const key of contractCache.keys()) {\n      if (key.startsWith(`${contract}:`)) {\n        contractCache.delete(key);\n      }\n    }\n  } else if (chainId) {\n    // Clear all contracts for this chain\n    for (const key of contractCache.keys()) {\n      if (key.endsWith(`:${chainId}`)) {\n        contractCache.delete(key);\n      }\n    }\n  } else {\n    // Clear entire cache\n    contractCache.clear();\n  }\n}\n\n// Function is already exported above, no need for redundant export\n\n// Type-only exports for enhanced type safety\nexport type { GetContractReturnType } from \"viem\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAKO;AACP,iBAA6D;AAE7D,uBAAuD;AACvD,oBAA6B;AAC7B,oBAA4B;AAG5B,MAAM,gBAAgB,oBAAI,IAAwC;AAG3D,MAAM,0BAA0B;AASvC,SAAS,eAAe,UAAwB,SAAyB;AACvE,SAAO,GAAG,QAAQ,IAAI,OAAO;AAC/B;AAmBO,SAAS,sBACd,UACA,aAGsC,4BAAa,GACX;AACxC,QAAM,UAAU,OAAO,OAAO,MAAM,0BAAY;AAChD,QAAM,WAAW,eAAe,UAAU,OAAO;AAEjD,MAAI,aAAa,cAAc,IAAI,QAAQ;AAE3C,MAAI,CAAC,YAAY;AACf,qBAAa,yBAAY;AAAA,MACvB,aAAS,qCAAmB,SAAS,QAAQ;AAAA,MAC7C,SAAK,mBAAO,QAAQ;AAAA,MACpB;AAAA,IACF,CAAC;AAED,kBAAc,IAAI,UAAU,UAAU;AAAA,EACxC;AAEA,SAAO;AACT;AAgBO,SAAS,gBACd,UACA,UAAuB,0BAAY,IACJ;AAC/B,SAAO;AAAA,IACL,aAAS,qCAAmB,SAAS,QAAQ;AAAA,IAC7C,SAAK,mBAAO,QAAQ;AAAA,EACtB;AACF;AAMO,MAAM,gBAAgB;AAAA,EACV;AAAA,EAIA;AAAA,EAEjB,YACE,QACA;AACA,SAAK,SAAS;AACd,QAAI;AACF,WAAK,UAAU,OAAO,OAAO,MAAM,0BAAY;AAAA,IACjD,QAAQ;AACN,WAAK,UAAU,0BAAY;AAAA,IAC7B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OACE,UACwC;AACxC,WAAO,sBAAsB,UAAU,KAAK,MAAM;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,QAAgC,UAA4C;AAC1E,WAAO,gBAAgB,UAAU,KAAK,OAAsB;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,wBAAwC;AAEtC,UAAM,iBAAiB,oCAAmB,KAAK,OAAO;AACtD,QAAI,CAAC,eAAgB,QAAO,CAAC;AAE7B,WAAO,OAAO,KAAK,cAAc;AAAA,EACnC;AACF;AAQO,SAAS,mBACd,UACA,SACM;AACN,MAAI,YAAY,SAAS;AACvB,UAAM,WAAW,eAAe,UAAU,OAAO;AACjD,kBAAc,OAAO,QAAQ;AAAA,EAC/B,WAAW,UAAU;AAEnB,eAAW,OAAO,cAAc,KAAK,GAAG;AACtC,UAAI,IAAI,WAAW,GAAG,QAAQ,GAAG,GAAG;AAClC,sBAAc,OAAO,GAAG;AAAA,MAC1B;AAAA,IACF;AAAA,EACF,WAAW,SAAS;AAElB,eAAW,OAAO,cAAc,KAAK,GAAG;AACtC,UAAI,IAAI,SAAS,IAAI,OAAO,EAAE,GAAG;AAC/B,sBAAc,OAAO,GAAG;AAAA,MAC1B;AAAA,IACF;AAAA,EACF,OAAO;AAEL,kBAAc,MAAM;AAAA,EACtB;AACF;","names":[]}

package/dist/contracts/contractController.d.ts

@@ -0,0 +1,79 @@
+import type { Abi } from "abitype";
+import { type GetContractReturnType, type PublicClient, type WalletClient } from "viem";
+import { type ContractAbis, type VanaContract } from "../generated/abi";
+import type { VanaChainId, ContractInfo } from "../types/index";
+import { createClient } from "../core/client";
+export declare const contractCacheForTesting: Map<string, {
+    address: `0x${string}`;
+    abi: Abi;
+}>;
+/**
+ * Gets a typed contract instance for the specified contract name with full type inference.
+ * This function provides complete type safety following viem's patterns.
+ *
+ * @param contract - Name of the contract to instantiate (must be a const assertion for full typing)
+ * @param client - Optional viem client instance
+ * @returns A fully typed contract instance with methods corresponding to the contract's ABI
+ * @example
+ * ```typescript
+ * // Full type inference with const assertion
+ * const dataRegistry = getContractController("DataRegistry" as const, client);
+ *
+ * // Now dataRegistry has full type inference for all methods
+ * const result = await dataRegistry.read.getFileCount(); // Type: bigint
+ * await dataRegistry.write.addFile([url, proof]); // Typed parameters
+ * ```
+ */
+export declare function getContractController<T extends VanaContract>(contract: T, client?: PublicClient | WalletClient | ReturnType<typeof createClient>): GetContractReturnType<ContractAbis[T]>;
+/**
+ * Gets contract information (address and ABI) without creating a contract instance.
+ * Useful for cases where you need contract details but don't want to create a client connection.
+ *
+ * @param contract - Name of the contract
+ * @param chainId - Chain ID (defaults to Vana mainnet)
+ * @returns Contract information with typed ABI
+ * @example
+ * ```typescript
+ * const info = getContractInfo("DataRegistry" as const, 14800);
+ * console.log(info.address); // Typed as Address
+ * console.log(info.abi); // Fully typed ABI
+ * ```
+ */
+export declare function getContractInfo<T extends VanaContract>(contract: T, chainId?: VanaChainId): ContractInfo<ContractAbis[T]>;
+/**
+ * Type-safe contract factory that creates contract instances with full type inference.
+ * This provides an alternative API that's more explicit about typing.
+ */
+export declare class ContractFactory {
+    private readonly client;
+    private readonly chainId;
+    constructor(client: PublicClient | WalletClient | ReturnType<typeof createClient>);
+    /**
+     * Creates a typed contract instance
+     *
+     * @param contract - Contract name (use const assertion for full typing)
+     * @returns Fully typed contract instance
+     */
+    create<T extends VanaContract>(contract: T): GetContractReturnType<ContractAbis[T]>;
+    /**
+     * Gets contract information without creating an instance
+     *
+     * @param contract - Contract name
+     * @returns Contract information with typed ABI
+     */
+    getInfo<T extends VanaContract>(contract: T): ContractInfo<ContractAbis[T]>;
+    /**
+     * Lists all available contracts for the current chain
+     *
+     * @returns Array of contract names available on this chain
+     */
+    getAvailableContracts(): VanaContract[];
+}
+/**
+ * Clears the contract cache. Useful for testing or when chain configurations change.
+ *
+ * @param contract - Optional specific contract to clear, or clear all if not provided
+ * @param chainId - Optional specific chain to clear, or clear all if not provided
+ */
+export declare function clearContractCache(contract?: VanaContract, chainId?: number): void;
+export type { GetContractReturnType } from "viem";

package/dist/contracts/contractController.js

@@ -0,0 +1,100 @@
+import {
+  getContract
+} from "viem";
+import { getAbi } from "../generated/abi";
+import { getContractAddress, CONTRACT_ADDRESSES } from "../config/addresses";
+import { createClient } from "../core/client";
+import { vanaMainnet } from "../config/chains";
+const contractCache = /* @__PURE__ */ new Map();
+const contractCacheForTesting = contractCache;
+function createCacheKey(contract, chainId) {
+  return `${contract}:${chainId}`;
+}
+function getContractController(contract, client = createClient()) {
+  const chainId = client.chain?.id ?? vanaMainnet.id;
+  const cacheKey = createCacheKey(contract, chainId);
+  let controller = contractCache.get(cacheKey);
+  if (!controller) {
+    controller = getContract({
+      address: getContractAddress(chainId, contract),
+      abi: getAbi(contract),
+      client
+    });
+    contractCache.set(cacheKey, controller);
+  }
+  return controller;
+}
+function getContractInfo(contract, chainId = vanaMainnet.id) {
+  return {
+    address: getContractAddress(chainId, contract),
+    abi: getAbi(contract)
+  };
+}
+class ContractFactory {
+  client;
+  chainId;
+  constructor(client) {
+    this.client = client;
+    try {
+      this.chainId = client.chain?.id ?? vanaMainnet.id;
+    } catch {
+      this.chainId = vanaMainnet.id;
+    }
+  }
+  /**
+   * Creates a typed contract instance
+   *
+   * @param contract - Contract name (use const assertion for full typing)
+   * @returns Fully typed contract instance
+   */
+  create(contract) {
+    return getContractController(contract, this.client);
+  }
+  /**
+   * Gets contract information without creating an instance
+   *
+   * @param contract - Contract name
+   * @returns Contract information with typed ABI
+   */
+  getInfo(contract) {
+    return getContractInfo(contract, this.chainId);
+  }
+  /**
+   * Lists all available contracts for the current chain
+   *
+   * @returns Array of contract names available on this chain
+   */
+  getAvailableContracts() {
+    const chainAddresses = CONTRACT_ADDRESSES[this.chainId];
+    if (!chainAddresses) return [];
+    return Object.keys(chainAddresses);
+  }
+}
+function clearContractCache(contract, chainId) {
+  if (contract && chainId) {
+    const cacheKey = createCacheKey(contract, chainId);
+    contractCache.delete(cacheKey);
+  } else if (contract) {
+    for (const key of contractCache.keys()) {
+      if (key.startsWith(`${contract}:`)) {
+        contractCache.delete(key);
+      }
+    }
+  } else if (chainId) {
+    for (const key of contractCache.keys()) {
+      if (key.endsWith(`:${chainId}`)) {
+        contractCache.delete(key);
+      }
+    }
+  } else {
+    contractCache.clear();
+  }
+}
+export {
+  ContractFactory,
+  clearContractCache,
+  contractCacheForTesting,
+  getContractController,
+  getContractInfo
+};
+//# sourceMappingURL=contractController.js.map

package/dist/contracts/contractController.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/contracts/contractController.ts"],"sourcesContent":["import type { Abi } from \"abitype\";\nimport {\n  getContract,\n  type GetContractReturnType,\n  type PublicClient,\n  type WalletClient,\n} from \"viem\";\nimport { type ContractAbis, getAbi, type VanaContract } from \"../generated/abi\";\nimport type { VanaChainId, ContractInfo } from \"../types/index\";\nimport { getContractAddress, CONTRACT_ADDRESSES } from \"../config/addresses\";\nimport { createClient } from \"../core/client\";\nimport { vanaMainnet } from \"../config/chains\";\n\n// Cache for contract instances - keyed by contract name and chain ID\nconst contractCache = new Map<string, GetContractReturnType<Abi>>();\n\n// Export cache for testing\nexport const contractCacheForTesting = contractCache;\n\n/**\n * Creates a cache key for contract instances\n *\n * @param contract - The contract name to create a cache key for\n * @param chainId - The chain ID to include in the cache key\n * @returns A string cache key combining contract name and chain ID\n */\nfunction createCacheKey(contract: VanaContract, chainId: number): string {\n  return `${contract}:${chainId}`;\n}\n\n/**\n * Gets a typed contract instance for the specified contract name with full type inference.\n * This function provides complete type safety following viem's patterns.\n *\n * @param contract - Name of the contract to instantiate (must be a const assertion for full typing)\n * @param client - Optional viem client instance\n * @returns A fully typed contract instance with methods corresponding to the contract's ABI\n * @example\n * ```typescript\n * // Full type inference with const assertion\n * const dataRegistry = getContractController(\"DataRegistry\" as const, client);\n *\n * // Now dataRegistry has full type inference for all methods\n * const result = await dataRegistry.read.getFileCount(); // Type: bigint\n * await dataRegistry.write.addFile([url, proof]); // Typed parameters\n * ```\n */\nexport function getContractController<T extends VanaContract>(\n  contract: T,\n  client:\n    | PublicClient\n    | WalletClient\n    | ReturnType<typeof createClient> = createClient(),\n): GetContractReturnType<ContractAbis[T]> {\n  const chainId = client.chain?.id ?? vanaMainnet.id;\n  const cacheKey = createCacheKey(contract, chainId);\n\n  let controller = contractCache.get(cacheKey);\n\n  if (!controller) {\n    controller = getContract({\n      address: getContractAddress(chainId, contract),\n      abi: getAbi(contract),\n      client,\n    }) as GetContractReturnType<ContractAbis[T]>;\n\n    contractCache.set(cacheKey, controller);\n  }\n\n  return controller as GetContractReturnType<ContractAbis[T]>;\n}\n\n/**\n * Gets contract information (address and ABI) without creating a contract instance.\n * Useful for cases where you need contract details but don't want to create a client connection.\n *\n * @param contract - Name of the contract\n * @param chainId - Chain ID (defaults to Vana mainnet)\n * @returns Contract information with typed ABI\n * @example\n * ```typescript\n * const info = getContractInfo(\"DataRegistry\" as const, 14800);\n * console.log(info.address); // Typed as Address\n * console.log(info.abi); // Fully typed ABI\n * ```\n */\nexport function getContractInfo<T extends VanaContract>(\n  contract: T,\n  chainId: VanaChainId = vanaMainnet.id as VanaChainId,\n): ContractInfo<ContractAbis[T]> {\n  return {\n    address: getContractAddress(chainId, contract),\n    abi: getAbi(contract),\n  };\n}\n\n/**\n * Type-safe contract factory that creates contract instances with full type inference.\n * This provides an alternative API that's more explicit about typing.\n */\nexport class ContractFactory {\n  private readonly client:\n    | PublicClient\n    | WalletClient\n    | ReturnType<typeof createClient>;\n  private readonly chainId: number;\n\n  constructor(\n    client: PublicClient | WalletClient | ReturnType<typeof createClient>,\n  ) {\n    this.client = client;\n    try {\n      this.chainId = client.chain?.id ?? vanaMainnet.id;\n    } catch {\n      this.chainId = vanaMainnet.id;\n    }\n  }\n\n  /**\n   * Creates a typed contract instance\n   *\n   * @param contract - Contract name (use const assertion for full typing)\n   * @returns Fully typed contract instance\n   */\n  create<T extends VanaContract>(\n    contract: T,\n  ): GetContractReturnType<ContractAbis[T]> {\n    return getContractController(contract, this.client);\n  }\n\n  /**\n   * Gets contract information without creating an instance\n   *\n   * @param contract - Contract name\n   * @returns Contract information with typed ABI\n   */\n  getInfo<T extends VanaContract>(contract: T): ContractInfo<ContractAbis[T]> {\n    return getContractInfo(contract, this.chainId as VanaChainId);\n  }\n\n  /**\n   * Lists all available contracts for the current chain\n   *\n   * @returns Array of contract names available on this chain\n   */\n  getAvailableContracts(): VanaContract[] {\n    // Return all contract names that have addresses on this chain\n    const chainAddresses = CONTRACT_ADDRESSES[this.chainId];\n    if (!chainAddresses) return [];\n\n    return Object.keys(chainAddresses) as VanaContract[];\n  }\n}\n\n/**\n * Clears the contract cache. Useful for testing or when chain configurations change.\n *\n * @param contract - Optional specific contract to clear, or clear all if not provided\n * @param chainId - Optional specific chain to clear, or clear all if not provided\n */\nexport function clearContractCache(\n  contract?: VanaContract,\n  chainId?: number,\n): void {\n  if (contract && chainId) {\n    const cacheKey = createCacheKey(contract, chainId);\n    contractCache.delete(cacheKey);\n  } else if (contract) {\n    // Clear all instances of this contract across all chains\n    for (const key of contractCache.keys()) {\n      if (key.startsWith(`${contract}:`)) {\n        contractCache.delete(key);\n      }\n    }\n  } else if (chainId) {\n    // Clear all contracts for this chain\n    for (const key of contractCache.keys()) {\n      if (key.endsWith(`:${chainId}`)) {\n        contractCache.delete(key);\n      }\n    }\n  } else {\n    // Clear entire cache\n    contractCache.clear();\n  }\n}\n\n// Function is already exported above, no need for redundant export\n\n// Type-only exports for enhanced type safety\nexport type { GetContractReturnType } from \"viem\";\n"],"mappings":"AACA;AAAA,EACE;AAAA,OAIK;AACP,SAA4B,cAAiC;AAE7D,SAAS,oBAAoB,0BAA0B;AACvD,SAAS,oBAAoB;AAC7B,SAAS,mBAAmB;AAG5B,MAAM,gBAAgB,oBAAI,IAAwC;AAG3D,MAAM,0BAA0B;AASvC,SAAS,eAAe,UAAwB,SAAyB;AACvE,SAAO,GAAG,QAAQ,IAAI,OAAO;AAC/B;AAmBO,SAAS,sBACd,UACA,SAGsC,aAAa,GACX;AACxC,QAAM,UAAU,OAAO,OAAO,MAAM,YAAY;AAChD,QAAM,WAAW,eAAe,UAAU,OAAO;AAEjD,MAAI,aAAa,cAAc,IAAI,QAAQ;AAE3C,MAAI,CAAC,YAAY;AACf,iBAAa,YAAY;AAAA,MACvB,SAAS,mBAAmB,SAAS,QAAQ;AAAA,MAC7C,KAAK,OAAO,QAAQ;AAAA,MACpB;AAAA,IACF,CAAC;AAED,kBAAc,IAAI,UAAU,UAAU;AAAA,EACxC;AAEA,SAAO;AACT;AAgBO,SAAS,gBACd,UACA,UAAuB,YAAY,IACJ;AAC/B,SAAO;AAAA,IACL,SAAS,mBAAmB,SAAS,QAAQ;AAAA,IAC7C,KAAK,OAAO,QAAQ;AAAA,EACtB;AACF;AAMO,MAAM,gBAAgB;AAAA,EACV;AAAA,EAIA;AAAA,EAEjB,YACE,QACA;AACA,SAAK,SAAS;AACd,QAAI;AACF,WAAK,UAAU,OAAO,OAAO,MAAM,YAAY;AAAA,IACjD,QAAQ;AACN,WAAK,UAAU,YAAY;AAAA,IAC7B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OACE,UACwC;AACxC,WAAO,sBAAsB,UAAU,KAAK,MAAM;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,QAAgC,UAA4C;AAC1E,WAAO,gBAAgB,UAAU,KAAK,OAAsB;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,wBAAwC;AAEtC,UAAM,iBAAiB,mBAAmB,KAAK,OAAO;AACtD,QAAI,CAAC,eAAgB,QAAO,CAAC;AAE7B,WAAO,OAAO,KAAK,cAAc;AAAA,EACnC;AACF;AAQO,SAAS,mBACd,UACA,SACM;AACN,MAAI,YAAY,SAAS;AACvB,UAAM,WAAW,eAAe,UAAU,OAAO;AACjD,kBAAc,OAAO,QAAQ;AAAA,EAC/B,WAAW,UAAU;AAEnB,eAAW,OAAO,cAAc,KAAK,GAAG;AACtC,UAAI,IAAI,WAAW,GAAG,QAAQ,GAAG,GAAG;AAClC,sBAAc,OAAO,GAAG;AAAA,MAC1B;AAAA,IACF;AAAA,EACF,WAAW,SAAS;AAElB,eAAW,OAAO,cAAc,KAAK,GAAG;AACtC,UAAI,IAAI,SAAS,IAAI,OAAO,EAAE,GAAG;AAC/B,sBAAc,OAAO,GAAG;AAAA,MAC1B;AAAA,IACF;AAAA,EACF,OAAO;AAEL,kBAAc,MAAM;AAAA,EACtB;AACF;","names":[]}

package/dist/contracts/tests/contractController.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/controllers/__tests__/schemas-edge-cases.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/controllers/base.cjs

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_exports = {};
+__export(base_exports, {
+  BaseController: () => BaseController
+});
+module.exports = __toCommonJS(base_exports);
+var import_errors = require("../errors");
+class BaseController {
+  /**
+   * Creates a new controller instance with the provided context.
+   *
+   * @param context - The controller context containing clients and configuration
+   */
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Asserts that a wallet client with an account is available for operations requiring signing.
+   *
+   * @remarks
+   * This method uses TypeScript assertion signatures to narrow the type of
+   * `this.context` to guarantee that `walletClient` with an account is available
+   * after the call succeeds. This provides compile-time safety for wallet operations
+   * while enabling clear error messages for read-only scenarios.
+   *
+   * The assertion signature ensures that after calling this method,
+   * TypeScript knows that `this.context.walletClient` is definitely available
+   * with a configured account.
+   *
+   * @throws {ReadOnlyError} When no wallet client is configured
+   * @throws {Error} When wallet client exists but no account is configured
+   *
+   * @example
+   * ```typescript
+   * async performWalletOperation() {
+   *   this.assertWallet(); // Type assertion + runtime check
+   *
+   *   // TypeScript now knows walletClient and account are available
+   *   const account = this.context.walletClient.account;
+   *   const address = typeof account === 'string' ? account : account.address;
+   * }
+   * ```
+   */
+  assertWallet() {
+    if (!this.context.walletClient) {
+      const stack = new Error().stack;
+      const callingMethod = stack?.split("\n")[2]?.match(/at \w+\.(\w+)/)?.[1] ?? "this operation";
+      throw new import_errors.ReadOnlyError(
+        callingMethod,
+        "Initialize the SDK with a walletClient to perform this operation"
+      );
+    }
+    if (!this.context.walletClient.account) {
+      const stack = new Error().stack;
+      const callingMethod = stack?.split("\n")[2]?.match(/at \w+\.(\w+)/)?.[1] ?? "this operation";
+      throw new Error(
+        `No wallet account connected. Cannot perform ${callingMethod} without an account.`
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseController
+});
+//# sourceMappingURL=base.cjs.map

package/dist/controllers/base.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/controllers/base.ts"],"sourcesContent":["/**\n * Base controller class providing common functionality for all controllers.\n *\n * @remarks\n * This abstract class establishes the foundation for all Vana SDK controllers,\n * providing shared utilities like wallet validation and context management.\n * All controllers should extend this base class to ensure consistency and\n * shared behavior across the SDK.\n *\n * The class follows the Single Responsibility Principle by handling only\n * the core controller concerns while leaving specific functionality to\n * implementing classes.\n *\n * @category Controllers\n */\n\nimport type { WalletClient } from \"viem\";\nimport type { ControllerContext } from \"../types/controller-context\";\nimport { ReadOnlyError } from \"../errors\";\n\n/**\n * Abstract base controller that all Vana SDK controllers extend.\n *\n * @remarks\n * Provides common functionality and patterns used across all controllers,\n * including wallet validation and context management. This ensures\n * consistency and reduces code duplication throughout the SDK.\n *\n * Key features:\n * - Wallet client validation with TypeScript assertion signatures\n * - Consistent error handling for read-only scenarios\n * - Shared context management patterns\n * - Type-safe wallet operations\n *\n * @example\n * ```typescript\n * class MyController extends BaseController {\n *   async performWalletOperation() {\n *     this.assertWallet(); // Ensures wallet is available\n *     // Now this.context.walletClient is guaranteed to be available\n *     const address = await this.context.walletClient.getAddresses();\n *     return address[0];\n *   }\n * }\n * ```\n */\nexport abstract class BaseController {\n  /**\n   * Creates a new controller instance with the provided context.\n   *\n   * @param context - The controller context containing clients and configuration\n   */\n  constructor(protected readonly context: ControllerContext) {}\n\n  /**\n   * Asserts that a wallet client with an account is available for operations requiring signing.\n   *\n   * @remarks\n   * This method uses TypeScript assertion signatures to narrow the type of\n   * `this.context` to guarantee that `walletClient` with an account is available\n   * after the call succeeds. This provides compile-time safety for wallet operations\n   * while enabling clear error messages for read-only scenarios.\n   *\n   * The assertion signature ensures that after calling this method,\n   * TypeScript knows that `this.context.walletClient` is definitely available\n   * with a configured account.\n   *\n   * @throws {ReadOnlyError} When no wallet client is configured\n   * @throws {Error} When wallet client exists but no account is configured\n   *\n   * @example\n   * ```typescript\n   * async performWalletOperation() {\n   *   this.assertWallet(); // Type assertion + runtime check\n   *\n   *   // TypeScript now knows walletClient and account are available\n   *   const account = this.context.walletClient.account;\n   *   const address = typeof account === 'string' ? account : account.address;\n   * }\n   * ```\n   */\n  protected assertWallet(): asserts this is {\n    context: ControllerContext & { walletClient: WalletClient };\n  } {\n    if (!this.context.walletClient) {\n      // Get the calling method name from the stack trace for better error messages\n      const stack = new Error().stack;\n      const callingMethod =\n        stack?.split(\"\\n\")[2]?.match(/at \\w+\\.(\\w+)/)?.[1] ?? \"this operation\";\n\n      throw new ReadOnlyError(\n        callingMethod,\n        \"Initialize the SDK with a walletClient to perform this operation\",\n      );\n    }\n\n    if (!this.context.walletClient.account) {\n      // Get the calling method name from the stack trace for better error messages\n      const stack = new Error().stack;\n      const callingMethod =\n        stack?.split(\"\\n\")[2]?.match(/at \\w+\\.(\\w+)/)?.[1] ?? \"this operation\";\n\n      throw new Error(\n        `No wallet account connected. Cannot perform ${callingMethod} without an account.`,\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBA,oBAA8B;AA4BvB,MAAe,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMnC,YAA+B,SAA4B;AAA5B;AAAA,EAA6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA6BlD,eAER;AACA,QAAI,CAAC,KAAK,QAAQ,cAAc;AAE9B,YAAM,QAAQ,IAAI,MAAM,EAAE;AAC1B,YAAM,gBACJ,OAAO,MAAM,IAAI,EAAE,CAAC,GAAG,MAAM,eAAe,IAAI,CAAC,KAAK;AAExD,YAAM,IAAI;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,QAAI,CAAC,KAAK,QAAQ,aAAa,SAAS;AAEtC,YAAM,QAAQ,IAAI,MAAM,EAAE;AAC1B,YAAM,gBACJ,OAAO,MAAM,IAAI,EAAE,CAAC,GAAG,MAAM,eAAe,IAAI,CAAC,KAAK;AAExD,YAAM,IAAI;AAAA,QACR,+CAA+C,aAAa;AAAA,MAC9D;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/controllers/base.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Base controller class providing common functionality for all controllers.
+ *
+ * @remarks
+ * This abstract class establishes the foundation for all Vana SDK controllers,
+ * providing shared utilities like wallet validation and context management.
+ * All controllers should extend this base class to ensure consistency and
+ * shared behavior across the SDK.
+ *
+ * The class follows the Single Responsibility Principle by handling only
+ * the core controller concerns while leaving specific functionality to
+ * implementing classes.
+ *
+ * @category Controllers
+ */
+import type { WalletClient } from "viem";
+import type { ControllerContext } from "../types/controller-context";
+/**
+ * Abstract base controller that all Vana SDK controllers extend.
+ *
+ * @remarks
+ * Provides common functionality and patterns used across all controllers,
+ * including wallet validation and context management. This ensures
+ * consistency and reduces code duplication throughout the SDK.
+ *
+ * Key features:
+ * - Wallet client validation with TypeScript assertion signatures
+ * - Consistent error handling for read-only scenarios
+ * - Shared context management patterns
+ * - Type-safe wallet operations
+ *
+ * @example
+ * ```typescript
+ * class MyController extends BaseController {
+ *   async performWalletOperation() {
+ *     this.assertWallet(); // Ensures wallet is available
+ *     // Now this.context.walletClient is guaranteed to be available
+ *     const address = await this.context.walletClient.getAddresses();
+ *     return address[0];
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class BaseController {
+    protected readonly context: ControllerContext;
+    /**
+     * Creates a new controller instance with the provided context.
+     *
+     * @param context - The controller context containing clients and configuration
+     */
+    constructor(context: ControllerContext);
+    /**
+     * Asserts that a wallet client with an account is available for operations requiring signing.
+     *
+     * @remarks
+     * This method uses TypeScript assertion signatures to narrow the type of
+     * `this.context` to guarantee that `walletClient` with an account is available
+     * after the call succeeds. This provides compile-time safety for wallet operations
+     * while enabling clear error messages for read-only scenarios.
+     *
+     * The assertion signature ensures that after calling this method,
+     * TypeScript knows that `this.context.walletClient` is definitely available
+     * with a configured account.
+     *
+     * @throws {ReadOnlyError} When no wallet client is configured
+     * @throws {Error} When wallet client exists but no account is configured
+     *
+     * @example
+     * ```typescript
+     * async performWalletOperation() {
+     *   this.assertWallet(); // Type assertion + runtime check
+     *
+     *   // TypeScript now knows walletClient and account are available
+     *   const account = this.context.walletClient.account;
+     *   const address = typeof account === 'string' ? account : account.address;
+     * }
+     * ```
+     */
+    protected assertWallet(): asserts this is {
+        context: ControllerContext & {
+            walletClient: WalletClient;
+        };
+    };
+}

package/dist/controllers/base.js

@@ -0,0 +1,59 @@
+import { ReadOnlyError } from "../errors";
+class BaseController {
+  /**
+   * Creates a new controller instance with the provided context.
+   *
+   * @param context - The controller context containing clients and configuration
+   */
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Asserts that a wallet client with an account is available for operations requiring signing.
+   *
+   * @remarks
+   * This method uses TypeScript assertion signatures to narrow the type of
+   * `this.context` to guarantee that `walletClient` with an account is available
+   * after the call succeeds. This provides compile-time safety for wallet operations
+   * while enabling clear error messages for read-only scenarios.
+   *
+   * The assertion signature ensures that after calling this method,
+   * TypeScript knows that `this.context.walletClient` is definitely available
+   * with a configured account.
+   *
+   * @throws {ReadOnlyError} When no wallet client is configured
+   * @throws {Error} When wallet client exists but no account is configured
+   *
+   * @example
+   * ```typescript
+   * async performWalletOperation() {
+   *   this.assertWallet(); // Type assertion + runtime check
+   *
+   *   // TypeScript now knows walletClient and account are available
+   *   const account = this.context.walletClient.account;
+   *   const address = typeof account === 'string' ? account : account.address;
+   * }
+   * ```
+   */
+  assertWallet() {
+    if (!this.context.walletClient) {
+      const stack = new Error().stack;
+      const callingMethod = stack?.split("\n")[2]?.match(/at \w+\.(\w+)/)?.[1] ?? "this operation";
+      throw new ReadOnlyError(
+        callingMethod,
+        "Initialize the SDK with a walletClient to perform this operation"
+      );
+    }
+    if (!this.context.walletClient.account) {
+      const stack = new Error().stack;
+      const callingMethod = stack?.split("\n")[2]?.match(/at \w+\.(\w+)/)?.[1] ?? "this operation";
+      throw new Error(
+        `No wallet account connected. Cannot perform ${callingMethod} without an account.`
+      );
+    }
+  }
+}
+export {
+  BaseController
+};
+//# sourceMappingURL=base.js.map

package/dist/controllers/base.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/controllers/base.ts"],"sourcesContent":["/**\n * Base controller class providing common functionality for all controllers.\n *\n * @remarks\n * This abstract class establishes the foundation for all Vana SDK controllers,\n * providing shared utilities like wallet validation and context management.\n * All controllers should extend this base class to ensure consistency and\n * shared behavior across the SDK.\n *\n * The class follows the Single Responsibility Principle by handling only\n * the core controller concerns while leaving specific functionality to\n * implementing classes.\n *\n * @category Controllers\n */\n\nimport type { WalletClient } from \"viem\";\nimport type { ControllerContext } from \"../types/controller-context\";\nimport { ReadOnlyError } from \"../errors\";\n\n/**\n * Abstract base controller that all Vana SDK controllers extend.\n *\n * @remarks\n * Provides common functionality and patterns used across all controllers,\n * including wallet validation and context management. This ensures\n * consistency and reduces code duplication throughout the SDK.\n *\n * Key features:\n * - Wallet client validation with TypeScript assertion signatures\n * - Consistent error handling for read-only scenarios\n * - Shared context management patterns\n * - Type-safe wallet operations\n *\n * @example\n * ```typescript\n * class MyController extends BaseController {\n *   async performWalletOperation() {\n *     this.assertWallet(); // Ensures wallet is available\n *     // Now this.context.walletClient is guaranteed to be available\n *     const address = await this.context.walletClient.getAddresses();\n *     return address[0];\n *   }\n * }\n * ```\n */\nexport abstract class BaseController {\n  /**\n   * Creates a new controller instance with the provided context.\n   *\n   * @param context - The controller context containing clients and configuration\n   */\n  constructor(protected readonly context: ControllerContext) {}\n\n  /**\n   * Asserts that a wallet client with an account is available for operations requiring signing.\n   *\n   * @remarks\n   * This method uses TypeScript assertion signatures to narrow the type of\n   * `this.context` to guarantee that `walletClient` with an account is available\n   * after the call succeeds. This provides compile-time safety for wallet operations\n   * while enabling clear error messages for read-only scenarios.\n   *\n   * The assertion signature ensures that after calling this method,\n   * TypeScript knows that `this.context.walletClient` is definitely available\n   * with a configured account.\n   *\n   * @throws {ReadOnlyError} When no wallet client is configured\n   * @throws {Error} When wallet client exists but no account is configured\n   *\n   * @example\n   * ```typescript\n   * async performWalletOperation() {\n   *   this.assertWallet(); // Type assertion + runtime check\n   *\n   *   // TypeScript now knows walletClient and account are available\n   *   const account = this.context.walletClient.account;\n   *   const address = typeof account === 'string' ? account : account.address;\n   * }\n   * ```\n   */\n  protected assertWallet(): asserts this is {\n    context: ControllerContext & { walletClient: WalletClient };\n  } {\n    if (!this.context.walletClient) {\n      // Get the calling method name from the stack trace for better error messages\n      const stack = new Error().stack;\n      const callingMethod =\n        stack?.split(\"\\n\")[2]?.match(/at \\w+\\.(\\w+)/)?.[1] ?? \"this operation\";\n\n      throw new ReadOnlyError(\n        callingMethod,\n        \"Initialize the SDK with a walletClient to perform this operation\",\n      );\n    }\n\n    if (!this.context.walletClient.account) {\n      // Get the calling method name from the stack trace for better error messages\n      const stack = new Error().stack;\n      const callingMethod =\n        stack?.split(\"\\n\")[2]?.match(/at \\w+\\.(\\w+)/)?.[1] ?? \"this operation\";\n\n      throw new Error(\n        `No wallet account connected. Cannot perform ${callingMethod} without an account.`,\n      );\n    }\n  }\n}\n"],"mappings":"AAkBA,SAAS,qBAAqB;AA4BvB,MAAe,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMnC,YAA+B,SAA4B;AAA5B;AAAA,EAA6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA6BlD,eAER;AACA,QAAI,CAAC,KAAK,QAAQ,cAAc;AAE9B,YAAM,QAAQ,IAAI,MAAM,EAAE;AAC1B,YAAM,gBACJ,OAAO,MAAM,IAAI,EAAE,CAAC,GAAG,MAAM,eAAe,IAAI,CAAC,KAAK;AAExD,YAAM,IAAI;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,QAAI,CAAC,KAAK,QAAQ,aAAa,SAAS;AAEtC,YAAM,QAAQ,IAAI,MAAM,EAAE;AAC1B,YAAM,gBACJ,OAAO,MAAM,IAAI,EAAE,CAAC,GAAG,MAAM,eAAe,IAAI,CAAC,KAAK;AAExD,YAAM,IAAI;AAAA,QACR,+CAA+C,aAAa;AAAA,MAC9D;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/controllers/data-error-handling.test.d.ts

@@ -0,0 +1 @@
+export {};