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

package/dist/controllers/permissions.d.cts

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

package/dist/controllers/protocol.d.cts

@@ -1,167 +0,0 @@
-import { GetContractReturnType } from 'viem';
-import { ContractInfo } from '../types/contracts.cjs';
-import { C as ControllerContext } from '../permissions-DNKPu_G0.cjs';
-import { VanaContract, ContractAbis } from '../generated/abi/index.cjs';
-import { ContractFactory } from '../contracts/contractController.cjs';
-import '../types/operations.cjs';
-import '../generated/server/server-exports.cjs';
-import '../generated/server/server.cjs';
-import '../types/config.cjs';
-import '../types/chains.cjs';
-import '../types/storage.cjs';
-import '../types/permissions.cjs';
-import '../config/eventMappings.cjs';
-import '../storage/manager.cjs';
-import '../platform/interface.cjs';
-import '../generated/abi/DataPortabilityPermissionsImplementation.cjs';
-import '../generated/abi/DataPortabilityServersImplementation.cjs';
-import '../generated/abi/DataPortabilityGranteesImplementation.cjs';
-import '../generated/abi/VanaEpochImplementation.cjs';
-import '../generated/abi/DLPRegistryImplementation.cjs';
-import '../generated/abi/DLPTreasuryImplementation.cjs';
-import '../generated/abi/DLPRewardDeployerTreasuryImplementation.cjs';
-import '../generated/abi/DLPPerformanceImplementation.cjs';
-import '../generated/abi/DLPRewardDeployerImplementation.cjs';
-import '../generated/abi/DLPRootImplementation.cjs';
-import '../generated/abi/DataLiquidityPoolImplementation.cjs';
-import '../generated/abi/DLPRegistryTreasuryImplementation.cjs';
-import 'abitype';
-import '../core/client.cjs';
-import '../config/chains.cjs';
-
-/**
- * Provides direct, low-level access to all Vana protocol smart contracts.
- *
- * @remarks
- * This controller serves as the designated "escape hatch" for advanced developers who need
- * to interact directly with the underlying blockchain contracts. It provides access to
- * contract addresses, ABIs, and factory methods for creating typed contract instances.
- * Most developers should use the higher-level DataController and PermissionsController
- * instead of this advanced API.
- *
- * **Contract Selection:**
- * The controller automatically handles chain detection and provides only contracts that
- * are deployed on the current network. All contract instances are fully typed for
- * enhanced developer experience and type safety.
- *
- * **Method Selection:**
- * - `getContract()` retrieves contract address and ABI for manual interaction
- * - `createContract()` returns fully typed contract instance with read/write methods
- * - `getAvailableContracts()` lists all contracts deployed on current chain
- * - `isContractAvailable()` checks if specific contract exists on current chain
- * - `getChainId()` and `getChainName()` provide current network information
- *
- * **Usage Guidelines:**
- * Use this controller when high-level controllers don't provide needed functionality.
- * Most developers should use `vana.data.*` for files and `vana.permissions.*` for access control.
- *
- * **Type Safety:**
- * Use `as const` assertion with contract names for full TypeScript type inference.
- * Contract instances provide complete typing for all methods, parameters, and return values.
- *
- * @example
- * ```typescript
- * // Get contract info for direct interaction
- * const registry = vana.protocol.getContract("DataRegistry" as const);
- *
- * // Access contract address and ABI with full typing
- * console.log(registry.address); // Contract address on current chain
- * console.log(registry.abi);     // Fully typed contract ABI
- *
- * // Create a typed contract instance
- * const contract = vana.protocol.createContract("DataRegistry" as const);
- * const fileCount = await contract.read.filesCount();
- * ```
- * @category Advanced
- * @see {@link https://docs.vana.com/developer/protocol/contracts | Vana Protocol Contracts} for contract specifications
- */
-declare class ProtocolController {
-    private readonly context;
-    private readonly contractFactory;
-    constructor(context: ControllerContext);
-    /**
-     * Retrieves the address and ABI for a specific Vana protocol contract.
-     *
-     * @remarks
-     * This method provides direct access to contract addresses and ABIs for the current
-     * chain. It includes full TypeScript type inference when using const assertions,
-     * enabling type-safe contract interactions. The method only returns contracts that
-     * are actually deployed on the current network.
-     * @param contractName - The name of the Vana contract to retrieve (use const assertion for full typing)
-     * @returns An object containing the contract's address and fully typed ABI
-     * @throws {ContractNotFoundError} When the contract is not deployed on the current chain.
-     *   Verify contract name spelling and check current network with `getChainId()`.
-     * @example
-     * ```typescript
-     * // Get contract info with full type inference
-     * const dataRegistry = vana.protocol.getContract("DataRegistry" as const);
-     *
-     * // Now dataRegistry.abi is fully typed for the DataRegistry contract
-     * console.log(dataRegistry.address); // "0x123..."
-     * console.log(dataRegistry.abi.length); // Full ABI array
-     * ```
-     */
-    getContract<T extends VanaContract>(contractName: T): ContractInfo<ContractAbis[T]>;
-    /**
-     * Creates a fully typed contract instance ready for blockchain interaction.
-     *
-     * @remarks
-     * This method creates a contract instance with complete type safety for all contract
-     * methods including read operations, write operations, and event handling. The instance
-     * is pre-configured with the correct address, ABI, and wallet client for immediate use.
-     * All method parameters and return types are fully typed based on the contract ABI.
-     * @param contractName - The name of the Vana contract (use const assertion for full typing)
-     * @returns A fully typed contract instance with read/write methods and event handling
-     * @throws {ContractNotFoundError} When the contract is not deployed on the current chain
-     * @example
-     * ```typescript
-     * // Create typed contract instance
-     * const dataRegistry = vana.protocol.createContract("DataRegistry" as const);
-     *
-     * // Full type safety for all operations
-     * const fileCount = await dataRegistry.read.filesCount(); // Type: bigint
-     * const txHash = await dataRegistry.write.addFile(["ipfs://..."]); // Typed parameters
-     *
-     * // Listen to events with full typing
-     * const logs = await dataRegistry.getEvents.FileAdded();
-     * ```
-     */
-    createContract<T extends VanaContract>(contractName: T): GetContractReturnType<ContractAbis[T]>;
-    /**
-     * Gets all available contract names that can be used with getContract().
-     * Returns only contracts that are actually deployed on the current chain.
-     *
-     * @returns Array of all available contract names for the current chain
-     */
-    getAvailableContracts(): VanaContract[];
-    /**
-     * Checks if a specific contract is available on the current chain.
-     *
-     * @param contractName - The contract name to check
-     * @returns Whether the contract is deployed on the current chain
-     */
-    isContractAvailable(contractName: VanaContract): boolean;
-    /**
-     * Gets the contract factory instance for advanced usage.
-     * This provides access to additional contract management methods.
-     *
-     * @returns The contract factory instance
-     */
-    getContractFactory(): ContractFactory;
-    /**
-     * Gets the current chain ID from the wallet client.
-     *
-     * @returns The chain ID
-     * @throws {Error} When chain ID is not available from wallet client
-     */
-    getChainId(): number;
-    /**
-     * Gets the current chain name from the wallet client.
-     *
-     * @returns The chain name
-     * @throws {Error} When chain name is not available from wallet client
-     */
-    getChainName(): string;
-}
-
-export { ProtocolController };

package/dist/controllers/schemas.d.cts

@@ -1,272 +0,0 @@
-import { CompleteSchema, Schema, AddSchemaParams, AddSchemaResult } from '../types/data.cjs';
-import { C as ControllerContext } from '../permissions-DNKPu_G0.cjs';
-import 'viem';
-import '../types/operations.cjs';
-import '../generated/server/server-exports.cjs';
-import '../generated/server/server.cjs';
-import '../types/config.cjs';
-import '../types/chains.cjs';
-import '../types/storage.cjs';
-import '../types/permissions.cjs';
-import '../config/eventMappings.cjs';
-import '../generated/abi/index.cjs';
-import '../generated/abi/DataPortabilityPermissionsImplementation.cjs';
-import '../generated/abi/DataPortabilityServersImplementation.cjs';
-import '../generated/abi/DataPortabilityGranteesImplementation.cjs';
-import '../generated/abi/VanaEpochImplementation.cjs';
-import '../generated/abi/DLPRegistryImplementation.cjs';
-import '../generated/abi/DLPTreasuryImplementation.cjs';
-import '../generated/abi/DLPRewardDeployerTreasuryImplementation.cjs';
-import '../generated/abi/DLPPerformanceImplementation.cjs';
-import '../generated/abi/DLPRewardDeployerImplementation.cjs';
-import '../generated/abi/DLPRootImplementation.cjs';
-import '../generated/abi/DataLiquidityPoolImplementation.cjs';
-import '../generated/abi/DLPRegistryTreasuryImplementation.cjs';
-import '../storage/manager.cjs';
-import '../platform/interface.cjs';
-
-/**
- * Parameters for creating a new schema with automatic IPFS upload.
- *
- * @remarks
- * This interface is used with the high-level `schemas.create()` method which
- * automatically uploads the schema definition to IPFS and registers it on-chain.
- * @category Schema Management
- */
-interface CreateSchemaParams {
-    /** The name of the schema */
-    name: string;
-    /** The dialect of the schema (e.g., 'json' or 'sqlite') */
-    dialect: "json" | "sqlite";
-    /** The schema definition object or JSON string */
-    schema: object | string;
-}
-/**
- * Result of creating a new schema.
- *
- * @remarks
- * Returned by the `schemas.create()` method after successful upload and registration.
- * @category Schema Management
- */
-interface CreateSchemaResult {
-    /** The schema ID assigned by the contract */
-    schemaId: number;
-    /** The IPFS URL where the schema definition is stored */
-    definitionUrl: string;
-    /** The transaction hash of the schema registration */
-    transactionHash: string;
-}
-/**
- * Manages data schemas and refiners on the Vana network.
- *
- * @remarks
- * This controller handles the complete lifecycle of data schemas including creation,
- * validation, IPFS upload, and blockchain registration. It provides methods for managing
- * both schemas (data structure definitions) and refiners (data processing definitions).
- *
- * **Schema Storage:**
- * Schemas are stored unencrypted on IPFS for public access and reusability across the network.
- * Schema definitions use JSON Schema format for data validation and structure definition.
- *
- * **Method Selection:**
- * - `create()` validates, uploads to IPFS, and registers new schemas on blockchain
- * - `get()` retrieves existing schema metadata by ID from blockchain contracts
- * - `count()` returns total number of registered schemas for pagination
- * - `list()` provides paginated access to all schemas with optional filtering
- * - `addSchema()` provides lower-level schema registration with pre-uploaded URLs
- *
- * **Storage Requirements:**
- * Methods requiring storage configuration: `create()`
- * Methods working without storage: `get()`, `count()`, `list()`, `addSchema()`
- *
- * @example
- * ```typescript
- * // Create a new schema with automatic IPFS upload
- * const result = await vana.schemas.create({
- *   name: "User Profile",
- *   dialect: "json",
- *   schema: {
- *     type: "object",
- *     properties: {
- *       name: { type: "string" },
- *       age: { type: "number" }
- *     },
- *     required: ["name"]
- *   }
- * });
- *
- * // Get an existing schema
- * const schema = await vana.schemas.get(1);
- *
- * // List all schemas
- * const count = await vana.schemas.count();
- * ```
- * @category Schema Management
- */
-declare class SchemaController {
-    private readonly context;
-    constructor(context: ControllerContext);
-    /**
-     * Creates a new schema with automatic validation and IPFS upload.
-     *
-     * @remarks
-     * This is the primary method for creating schemas on the Vana network. It handles
-     * the complete workflow including schema validation, IPFS upload, and blockchain
-     * registration. The schema definition is stored unencrypted on IPFS to enable
-     * public access and reusability.
-     *
-     * The method automatically:
-     * - Validates the schema definition against the Vana metaschema
-     * - Uploads the definition to IPFS to generate a permanent URL
-     * - Registers the schema on the blockchain with the generated URL
-     *
-     * @param params - Schema creation parameters including name, dialect, and definition
-     * @returns Promise resolving to creation results with schema ID and transaction hash
-     * @throws {SchemaValidationError} When the schema definition is invalid
-     * @throws {Error} When IPFS upload or blockchain registration fails
-     * @example
-     * ```typescript
-     * // Create a JSON schema for user profiles
-     * const result = await vana.schemas.create({
-     *   name: "User Profile",
-     *   dialect: "json",
-     *   schema: {
-     *     type: "object",
-     *     properties: {
-     *       name: { type: "string" },
-     *       age: { type: "number", minimum: 0 }
-     *     },
-     *     required: ["name"]
-     *   }
-     * });
-     *
-     * console.log(`Schema created with ID: ${result.schemaId}`);
-     * ```
-     */
-    create(params: CreateSchemaParams): Promise<CreateSchemaResult>;
-    /**
-     * Retrieves a complete schema by its ID with definition fetched and flattened.
-     *
-     * @param schemaId - The ID of the schema to retrieve
-     * @param options - Optional parameters
-     * @param options.subgraphUrl - Custom subgraph URL to use instead of default
-     * @returns Promise resolving to the complete schema object with all fields populated
-     * @throws {Error} When the schema is not found, definition cannot be fetched, or chain is unavailable
-     * @example
-     * ```typescript
-     * const schema = await vana.schemas.get(1);
-     * console.log(`Schema: ${schema.name} (${schema.dialect})`);
-     * console.log(`Version: ${schema.version}`);
-     * console.log(`Description: ${schema.description}`);
-     * console.log('Schema:', schema.schema);
-     *
-     * // Use directly with validator (schema has all required fields)
-     * validator.validateDataAgainstSchema(data, schema);
-     * ```
-     */
-    get(schemaId: number, options?: {
-        subgraphUrl?: string;
-    }): Promise<CompleteSchema>;
-    /**
-     * Gets the total number of schemas registered on the network.
-     *
-     * @param options - Optional parameters
-     * @param options.subgraphUrl - Custom subgraph URL to use instead of default
-     * @returns Promise resolving to the total schema count
-     * @throws {Error} When the count cannot be retrieved
-     * @example
-     * ```typescript
-     * const count = await vana.schemas.count();
-     * console.log(`Total schemas: ${count}`);
-     *
-     * // With custom subgraph
-     * const count = await vana.schemas.count({
-     *   subgraphUrl: 'https://custom-subgraph.com/graphql'
-     * });
-     * ```
-     */
-    count(options?: {
-        subgraphUrl?: string;
-    }): Promise<number>;
-    /**
-     * Lists all schemas with pagination.
-     *
-     * @param options - Optional parameters for listing schemas
-     * @param options.limit - Maximum number of schemas to return
-     * @param options.offset - Number of schemas to skip
-     * @param options.subgraphUrl - Custom subgraph URL to use instead of default
-     * @param options.includeDefinitions - Whether to fetch and include schema definitions (default: false for performance)
-     * @returns Promise resolving to an array of schemas
-     * @example
-     * ```typescript
-     * // Get all schemas (without definitions for performance)
-     * const schemas = await vana.schemas.list();
-     *
-     * // Get schemas with definitions
-     * const schemas = await vana.schemas.list({ includeDefinitions: true });
-     *
-     * // Get schemas with pagination
-     * const schemas = await vana.schemas.list({ limit: 10, offset: 0 });
-     * ```
-     */
-    list(options?: {
-        limit?: number;
-        offset?: number;
-        subgraphUrl?: string;
-        includeDefinitions?: boolean;
-    }): Promise<Schema[]>;
-    /**
-     * Adds a schema using the legacy method (low-level API).
-     *
-     * @deprecated Use create() instead for the high-level API with automatic IPFS upload
-     * @param params - Schema parameters including pre-generated definition URL
-     * @returns Promise resolving to the add schema result
-     */
-    addSchema(params: AddSchemaParams): Promise<AddSchemaResult>;
-    /**
-     * Internal method: Query schema via subgraph
-     *
-     * @param params - Query parameters
-     * @param params.schemaId - The ID of the schema to retrieve
-     * @param params.subgraphUrl - The subgraph URL to query
-     * @returns Promise resolving to the schema object
-     * @private
-     */
-    private _getSchemaViaSubgraph;
-    /**
-     * Internal method: List schemas via subgraph
-     *
-     * @param params - Query parameters
-     * @param params.limit - Maximum number of schemas to return
-     * @param params.offset - Number of schemas to skip
-     * @param params.subgraphUrl - The subgraph URL to query
-     * @returns Promise resolving to an array of schemas
-     * @private
-     */
-    private _listSchemasViaSubgraph;
-    /**
-     * Internal method: Count schemas via subgraph
-     *
-     * @param params - Query parameters
-     * @param params.subgraphUrl - The subgraph URL to query
-     * @returns Promise resolving to the total schema count
-     * @private
-     */
-    private _countSchemasViaSubgraph;
-    /**
-     * Gets the user's wallet address.
-     *
-     * @private
-     * @returns Promise resolving to the user's address
-     */
-    private getUserAddress;
-    /**
-     * Fetches and attaches definitions to an array of schemas.
-     *
-     * @param schemas - Array of schemas to fetch definitions for
-     * @private
-     */
-    private _fetchDefinitionsForSchemas;
-}
-
-export { type CreateSchemaParams, type CreateSchemaResult, SchemaController };