@opendatalabs/vana-sdk 0.1.0-alpha.7ee7635 → 0.1.0-alpha.80df35f

package/dist/core/apiClient.d.cts

@@ -1,165 +0,0 @@
-import { RetryConfig, RateLimiterConfig, Middleware, GenericResponse } from '../types/generics.cjs';
-import 'viem';
-
-/**
- * Configuration for the generic API client
- */
-interface ApiClientConfig {
-    /** Base URL for all requests */
-    baseUrl?: string;
-    /** Default headers */
-    headers?: Record<string, string>;
-    /** Request timeout in milliseconds */
-    timeout?: number;
-    /** Retry configuration */
-    retry?: RetryConfig;
-    /** Rate limiting configuration */
-    rateLimit?: RateLimiterConfig;
-    /** Circuit breaker configuration */
-    circuitBreaker?: {
-        failureThreshold: number;
-        recoveryTimeout: number;
-        halfOpenMaxAttempts?: number;
-    };
-}
-/**
- * HTTP method types
- */
-type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-/**
- * Request options for API calls
- */
-interface RequestOptions {
-    /** HTTP method */
-    method?: HttpMethod;
-    /** Request headers */
-    headers?: Record<string, string>;
-    /** Query parameters */
-    params?: Record<string, unknown>;
-    /** Request timeout */
-    timeout?: number;
-    /** Skip retry for this request */
-    skipRetry?: boolean;
-    /** Skip rate limiting for this request */
-    skipRateLimit?: boolean;
-}
-/**
- * Generic API client with middleware, retry, rate limiting, and circuit breaker support
- */
-declare class ApiClient {
-    private readonly config;
-    private readonly middleware;
-    private readonly rateLimiter?;
-    private readonly circuitBreaker?;
-    constructor(config?: ApiClientConfig);
-    /**
-     * Add middleware to the request pipeline
-     *
-     * @param middleware - The middleware function to add to the pipeline
-     */
-    use(middleware: Middleware): void;
-    /**
-     * Make a generic HTTP request
-     *
-     * @param url - The URL to make the request to
-     * @param options - Request options including method, headers, body, etc.
-     * @returns Promise resolving to the response data
-     */
-    request<TData = unknown>(url: string, options?: RequestOptions): Promise<GenericResponse<TData>>;
-    /**
-     * Make a GET request
-     *
-     * @param url - The URL to make the GET request to
-     * @param options - Request options (excluding method)
-     * @returns Promise resolving to the response data
-     */
-    get<TData = unknown>(url: string, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
-    /**
-     * Make a POST request
-     *
-     * @param url - The URL to make the POST request to
-     * @param data - The data to send in the request body
-     * @param options - Request options (excluding method)
-     * @returns Promise resolving to the response data
-     */
-    post<TData = unknown>(url: string, data?: unknown, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
-    /**
-     * Make a PUT request
-     *
-     * @param url - The URL to make the PUT request to
-     * @param data - The data to send in the request body
-     * @param options - Request options (excluding method)
-     * @returns Promise resolving to the response data
-     */
-    put<TData = unknown>(url: string, data?: unknown, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
-    /**
-     * Make a DELETE request
-     *
-     * @param url - The URL to make the DELETE request to
-     * @param options - Request options (excluding method)
-     * @returns Promise resolving to the response data
-     */
-    delete<TData = unknown>(url: string, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
-    /**
-     * Make a PATCH request
-     *
-     * @param url - The URL to make the PATCH request to
-     * @param data - The data to send in the request body
-     * @param options - Request options (excluding method)
-     * @returns Promise resolving to the response data
-     */
-    patch<TData = unknown>(url: string, data?: unknown, options?: Omit<RequestOptions, "method">): Promise<GenericResponse<TData>>;
-    /**
-     * Execute the actual HTTP request with middleware and retry
-     *
-     * @param request - The generic request object containing URL and options
-     * @returns Promise resolving to the generic response with data
-     */
-    private executeRequest;
-    /**
-     * Make the actual HTTP request using fetch API
-     *
-     * @param url - The URL to make the request to
-     * @param options - The request options including method, headers, body, etc.
-     * @returns Promise resolving to the generic response with data
-     */
-    private makeHttpRequest;
-    /**
-     * Build the full URL
-     *
-     * @param url - The URL or path to build the full URL from
-     * @returns The complete URL string
-     */
-    private buildUrl;
-    /**
-     * Build request options with defaults
-     *
-     * @param options - The request options to merge with defaults
-     * @returns The merged request options with defaults applied
-     */
-    private buildRequestOptions;
-    /**
-     * Get client statistics
-     *
-     * @returns Object containing client statistics and performance metrics
-     */
-    getStats(): {
-        rateLimiter: {
-            remaining: number;
-            resetTime: number;
-        } | null;
-        circuitBreaker: {
-            state: string;
-            failures: number;
-        } | null;
-        middleware: {
-            count: number;
-        };
-    };
-    /**
-     * Reset client state
-     */
-    reset(): void;
-}
-
-export { ApiClient, type ApiClientConfig, type HttpMethod, type RequestOptions };

package/dist/core/client.d.cts

@@ -1,92 +0,0 @@
-import { PublicClient, Chain, Account, WalletClient } from 'viem';
-import { chains } from '../config/chains.cjs';
-
-/**
- * Default starting block numbers for querying blockchain events and data per chain.
- *
- * @remarks
- * These block numbers represent the earliest deployment of Vana protocol contracts
- * on each network. Using these as starting points for event queries significantly
- * improves performance by avoiding unnecessary queries of blocks before the
- * protocol existed.
- *
- * - Moksha Testnet (14800): Block 732312 - DataRegistry deployment
- * - Vana Mainnet (1480): Block 758584 - DataRegistry deployment
- *
- * @category Blockchain
- */
-declare const defaultFromBlocks: Record<number, bigint>;
-/**
- * Gets the default starting block for a specific chain.
- *
- * @param chainId - The chain ID to get the default from block for
- * @returns The default starting block for the chain, or 0n if not configured
- * @category Blockchain
- */
-declare function getDefaultFromBlock(chainId: number): bigint;
-/**
- * Creates or retrieves a cached public client for blockchain read operations.
- *
- * @remarks
- * This function provides an optimized way to access blockchain data by maintaining
- * a cached client instance per chain. The client is used for reading contract state,
- * querying events, and other read-only blockchain operations. It automatically
- * handles HTTP transport configuration and chain switching.
- *
- * @param chainId - The chain ID to connect to (defaults to Moksha testnet)
- * @returns A public client configured for the specified chain with caching optimization
- * @throws {Error} When the specified chain ID is not supported by the SDK
- * @example
- * ```typescript
- * // Get client for default chain (Moksha testnet)
- * const client = createClient();
- *
- * // Get client for specific chain
- * const mainnetClient = createClient(14800);
- *
- * // Use client for blockchain reads
- * const blockNumber = await client.getBlockNumber();
- * ```
- * @category Blockchain
- */
-declare const createClient: (chainId?: keyof typeof chains) => PublicClient & {
-    chain: Chain;
-};
-/**
- * Creates a wallet client for blockchain transaction signing and submission.
- *
- * @remarks
- * This function creates a wallet client configured for transaction signing and
- * submission on the specified chain. Unlike the public client, wallet clients
- * are not cached and require an account for transaction signing. The client
- * handles HTTP transport configuration and provides access to wallet-specific
- * operations like signing transactions and messages.
- *
- * @param chainId - The chain ID to connect to (defaults to Moksha testnet)
- * @param account - Optional account for transaction signing (can be set later)
- * @returns A wallet client configured for the specified chain
- * @throws {Error} When the specified chain ID is not supported by the SDK
- * @example
- * ```typescript
- * import { privateKeyToAccount } from 'viem/accounts';
- *
- * // Create wallet client for default chain
- * const account = privateKeyToAccount('0x...');
- * const walletClient = createWalletClient(mokshaTestnet.id, account);
- *
- * // Use for transaction signing
- * const txHash = await walletClient.writeContract({
- *   address: contractAddress,
- *   abi: contractAbi,
- *   functionName: 'someFunction',
- *   args: []
- * });
- *
- * // Create without account (account can be set later)
- * const client = createWalletClient();
- * ```
- * @category Blockchain
- */
-declare const createWalletClient: (chainId?: keyof typeof chains, account?: Account) => WalletClient;
-
-export { createClient, createWalletClient, defaultFromBlocks, getDefaultFromBlock };

package/dist/core/generics.d.cts

@@ -1,120 +0,0 @@
-import { ControllerContext, Controller, GenericRequest, Middleware, GenericResponse, RetryConfig, RateLimiterConfig, Cache, Observable, Observer } from '../types/generics.cjs';
-import 'viem';
-
-/**
- * Base controller class with common functionality
- */
-declare abstract class BaseController<TContext extends ControllerContext = ControllerContext> implements Controller<TContext> {
-    readonly context: TContext;
-    constructor(context: TContext);
-    /**
-     * Execute a request with optional middleware pipeline
-     *
-     * @param request - The generic request object containing parameters and metadata
-     * @param handler - The function that processes the request parameters
-     * @param middleware - Optional array of middleware functions to apply
-     * @returns Promise resolving to a generic response object
-     */
-    protected executeRequest<TParams, TResponse>(request: GenericRequest<TParams>, handler: (params: TParams) => Promise<TResponse>, middleware?: Middleware[]): Promise<GenericResponse<TResponse>>;
-    /**
-     * Validate parameters with optional custom validator
-     *
-     * @param params - The parameters to validate
-     * @param validator - Optional function to validate parameter types
-     * @throws Error if validation fails, asserts type if successful
-     */
-    protected validateParams<T>(params: unknown, validator?: (params: unknown) => params is T): asserts params is T;
-}
-/**
- * Generic retry utility with exponential backoff
- */
-declare class RetryUtility {
-    private static delay;
-    static withRetry<T>(operation: () => Promise<T>, config: RetryConfig): Promise<T>;
-}
-/**
- * Generic rate limiter
- */
-declare class RateLimiter {
-    private config;
-    private requests;
-    constructor(config: RateLimiterConfig);
-    checkLimit(): Promise<boolean>;
-    waitForSlot(): Promise<void>;
-    getRemainingRequests(): number;
-    getResetTime(): number;
-}
-/**
- * Generic in-memory cache implementation
- */
-declare class MemoryCache<TKey = string, TValue = unknown> implements Cache<TKey, TValue> {
-    private cache;
-    get(key: TKey): Promise<TValue | undefined>;
-    set(key: TKey, value: TValue, ttl?: number): Promise<void>;
-    delete(key: TKey): Promise<boolean>;
-    clear(): Promise<void>;
-    has(key: TKey): Promise<boolean>;
-    size(): number;
-    keys(): TKey[];
-}
-/**
- * Generic event emitter implementation
- */
-declare class EventEmitter<TEvent = unknown> implements Observable<TEvent> {
-    private observers;
-    subscribe(observer: Observer<TEvent>): () => void;
-    unsubscribe(observer: Observer<TEvent>): void;
-    emit(event: TEvent): void;
-    getObserverCount(): number;
-    removeAllObservers(): void;
-}
-/**
- * Generic middleware pipeline
- */
-declare class MiddlewarePipeline {
-    private middleware;
-    use(middleware: Middleware<any, any>): void;
-    processRequest<TRequest>(request: TRequest): Promise<TRequest>;
-    processResponse<TResponse>(response: TResponse): Promise<TResponse>;
-    handleError<TRequest, TResponse>(error: Error, request: TRequest): Promise<TResponse | void>;
-    getMiddleware(): Middleware<any, any>[];
-    clear(): void;
-}
-/**
- * Generic async queue for managing concurrent operations
- */
-declare class AsyncQueue<T = unknown> {
-    private concurrency;
-    private queue;
-    private running;
-    constructor(concurrency?: number);
-    add<R>(operation: () => Promise<R>): Promise<R>;
-    private processQueue;
-    get pending(): number;
-    get active(): number;
-    get size(): number;
-    clear(): void;
-}
-/**
- * Generic circuit breaker pattern
- */
-declare class CircuitBreaker {
-    private config;
-    private state;
-    private failures;
-    private lastFailureTime;
-    private successes;
-    constructor(config: {
-        failureThreshold: number;
-        recoveryTimeout: number;
-        halfOpenMaxAttempts?: number;
-    });
-    execute<TResult>(operation: () => Promise<TResult>): Promise<TResult>;
-    private onSuccess;
-    private onFailure;
-    getState(): string;
-    getFailures(): number;
-    reset(): void;
-}
-
-export { AsyncQueue, BaseController, CircuitBreaker, EventEmitter, MemoryCache, MiddlewarePipeline, RateLimiter, RetryUtility };