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

package/dist/types/eccrypto-js.d.d.ts

@@ -1,13 +0,0 @@
-declare module 'eccrypto-js' {
-  export interface Encrypted {
-    iv: Buffer;
-    ephemPublicKey: Buffer;
-    ciphertext: Buffer;
-    mac: Buffer;
-  }
-
-  export function encrypt(publicKey: Buffer, message: Buffer): Promise<Encrypted>;
-  export function decrypt(privateKey: Buffer, encrypted: Encrypted): Promise<Buffer>;
-  export function generatePrivate(): Buffer;
-  export function getPublic(privateKey: Buffer): Buffer;
-}

package/dist/types/external-apis.d.cts

@@ -1,186 +0,0 @@
-/**
- * Types for external API responses used by the Vana SDK
- * These types help ensure type safety when interacting with third-party services
- */
-/**
- * Replicate API Response Types
- * Documentation: https://replicate.com/docs/reference/http
- */
-/** Status values for Replicate predictions */
-type ReplicateStatus = "starting" | "processing" | "succeeded" | "failed" | "canceled";
-/** Base Replicate API prediction response */
-interface ReplicateAPIResponse {
-    /** Unique identifier for the prediction */
-    id: string;
-    /** Model version identifier */
-    version: string;
-    /** Current status of the prediction */
-    status: ReplicateStatus;
-    /** Input parameters sent to the model */
-    input: Record<string, unknown>;
-    /** Output from the model (if completed successfully) */
-    output?: unknown;
-    /** Error message (if failed) */
-    error?: string | null;
-    /** Logs from the prediction run */
-    logs?: string;
-    /** Whether data has been removed due to content policy */
-    data_removed?: boolean;
-    /** Timestamp when prediction was created */
-    created_at: string;
-    /** Timestamp when prediction started processing */
-    started_at?: string;
-    /** Timestamp when prediction completed */
-    completed_at?: string;
-    /** URLs for interacting with the prediction */
-    urls: {
-        /** URL to get prediction status/results */
-        get: string;
-        /** URL to cancel the prediction */
-        cancel: string;
-        /** Web interface URL */
-        web?: string;
-    };
-    /** Performance metrics */
-    metrics?: {
-        /** Time spent in prediction (seconds) */
-        predict_time?: number;
-        /** Total time including setup (seconds) */
-        total_time?: number;
-    };
-}
-/**
- * Storage Provider API Types
- */
-/** Pinata IPFS upload response */
-interface PinataUploadResponse {
-    /** IPFS hash of the uploaded content */
-    IpfsHash: string;
-    /** Size of the pinned content in bytes */
-    PinSize: number;
-    /** Timestamp of when content was pinned */
-    Timestamp: string;
-    /** Whether this content was already pinned */
-    isDuplicate?: boolean;
-}
-/** Pinata pin information */
-interface PinataPin {
-    /** IPFS hash */
-    ipfs_pin_hash: string;
-    /** Pin size in bytes */
-    size: number;
-    /** User ID */
-    user_id: string;
-    /** Date pinned */
-    date_pinned: string;
-    /** Date unpinned (if applicable) */
-    date_unpinned?: string;
-    /** Additional metadata */
-    metadata?: {
-        name?: string;
-        keyvalues?: Record<string, string>;
-    };
-}
-/** Pinata list response */
-interface PinataListResponse {
-    /** Total count of pins */
-    count: number;
-    /** Array of pin information */
-    rows: PinataPin[];
-}
-/**
- * Generic API Response Wrapper
- * Used for internal API routes in the demo application
- */
-/** Standard API response wrapper */
-interface APIResponse<T = unknown> {
-    /** Whether the request was successful */
-    success: boolean;
-    /** Response data (if successful) */
-    data?: T;
-    /** Error message (if unsuccessful) */
-    error?: string;
-}
-/**
- * Type Guards for Runtime Validation
- */
-/**
- * Validates whether a value is a valid ReplicateAPIResponse.
- *
- * @param value - The value to check
- * @returns True if the value matches the ReplicateAPIResponse structure
- * @example
- * ```typescript
- * const response = await fetch('/api/replicate');
- * const data = await response.json();
- *
- * if (isReplicateAPIResponse(data)) {
- *   console.log('Status:', data.status);
- *   console.log('Output:', data.output);
- * }
- * ```
- */
-declare function isReplicateAPIResponse(value: unknown): value is ReplicateAPIResponse;
-/**
- * Validates whether a value is a valid APIResponse.
- *
- * @param value - The value to check
- * @returns True if the value matches the APIResponse structure
- * @example
- * ```typescript
- * const response = await fetch('/api/data');
- * const data = await response.json();
- *
- * if (isAPIResponse(data)) {
- *   if (data.success) {
- *     console.log('Data:', data.data);
- *   } else {
- *     console.error('Error:', data.error);
- *   }
- * }
- * ```
- */
-declare function isAPIResponse<T>(value: unknown): value is APIResponse<T>;
-/**
- * Utility Functions for Safe JSON Parsing
- */
-/**
- * Safely parses JSON string with type validation.
- *
- * @param jsonString - The JSON string to parse
- * @param typeGuard - Type guard function to validate the parsed value
- * @returns The parsed and validated value, or null if parsing/validation fails
- * @example
- * ```typescript
- * const jsonStr = '{"user_address": "0x123...", "identity": {}}';
- * const result = safeParseJSON(jsonStr, isAPIResponse);
- *
- * if (result) {
- *   console.log('Parsed server output:', result.user_address);
- * } else {
- *   console.log('Invalid JSON or type mismatch');
- * }
- * ```
- */
-declare function safeParseJSON<T>(jsonString: string, typeGuard: (value: unknown) => value is T): T | null;
-/**
- * Parses Replicate API response output with type safety.
- *
- * @param response - The Replicate API response
- * @param typeGuard - Type guard function to validate the output
- * @returns The parsed and validated output, or null if validation fails
- * @example
- * ```typescript
- * const response = await replicateClient.get(predictionId);
- * const output = parseReplicateOutput(response, isReplicateAPIResponse);
- *
- * if (output) {
- *   console.log('Identity server result:', output.user_address);
- * } else {
- *   console.log('Output not available or invalid format');
- * }
- * ```
- */
-declare function parseReplicateOutput<T>(response: ReplicateAPIResponse, typeGuard: (value: unknown) => value is T): T | null;
-
-export { type APIResponse, type PinataListResponse, type PinataPin, type PinataUploadResponse, type ReplicateAPIResponse, type ReplicateStatus, isAPIResponse, isReplicateAPIResponse, parseReplicateOutput, safeParseJSON };

package/dist/types/generics.d.cts

@@ -1,450 +0,0 @@
-import { Hash, Address } from 'viem';
-
-/**
- * Generic request pattern for all SDK operations
- *
- * @category Reference
- */
-interface GenericRequest<TParams = unknown, TOptions = unknown> {
-    /** Request parameters */
-    params: TParams;
-    /** Additional request options */
-    options?: TOptions;
-}
-/**
- * Generic response pattern for all SDK operations
- *
- * @category Reference
- */
-interface GenericResponse<TData = unknown, TMeta = unknown> {
-    /** Response data */
-    data: TData;
-    /** Response metadata */
-    meta?: TMeta;
-    /** Success status */
-    success: boolean;
-    /** Error information if not successful */
-    error?: {
-        code: string;
-        message: string;
-        details?: unknown;
-    };
-}
-/**
- * Generic async operation result
- *
- * @category Reference
- */
-interface AsyncResult<T> {
-    /** Operation result */
-    result: T;
-    /** Transaction hash if applicable */
-    transactionHash?: Hash;
-    /** Block number if applicable */
-    blockNumber?: bigint;
-    /** Gas used if applicable */
-    gasUsed?: bigint;
-}
-/**
- * Generic contract interaction parameters
- *
- * @category Reference
- */
-interface ContractCall<TArgs extends readonly unknown[] = readonly unknown[]> {
-    /** Contract method name */
-    method: string;
-    /** Method arguments */
-    args: TArgs;
-    /** Call options */
-    options?: {
-        /** Gas limit */
-        gasLimit?: bigint;
-        /** Gas price */
-        gasPrice?: bigint;
-        /** Value to send */
-        value?: bigint;
-    };
-}
-/**
- * Generic contract event filter
- *
- * @category Reference
- */
-interface EventFilter<TEventArgs = unknown> {
-    /** Event name */
-    event: string;
-    /** Event arguments filter */
-    args?: TEventArgs;
-    /** From block */
-    fromBlock?: bigint;
-    /** To block */
-    toBlock?: bigint;
-    /** Address filter */
-    address?: Address | Address[];
-}
-/**
- * Generic event log
- *
- * @category Reference
- */
-interface EventLog<TArgs = unknown> {
-    /** Event name */
-    event: string;
-    /** Event arguments */
-    args: TArgs;
-    /** Block number */
-    blockNumber: bigint;
-    /** Transaction hash */
-    transactionHash: Hash;
-    /** Log index */
-    logIndex: number;
-    /** Transaction index */
-    transactionIndex: number;
-    /** Contract address */
-    address: Address;
-}
-/**
- * Generic controller context for dependency injection
- *
- * @category Reference
- */
-interface ControllerContext<TClient = unknown, TConfig = unknown> {
-    /** Client instance */
-    client: TClient;
-    /** Configuration */
-    config?: TConfig;
-    /** Additional context */
-    [key: string]: unknown;
-}
-/**
- * Generic controller interface
- *
- * @category Reference
- */
-interface Controller<TContext = unknown> {
-    /** Controller context */
-    readonly context: TContext;
-}
-/**
- * Generic storage provider interface
- *
- * @category Reference
- */
-interface StorageProvider<TConfig = unknown, TOptions = unknown> {
-    /** Provider name */
-    readonly name: string;
-    /** Provider configuration */
-    readonly config: TConfig;
-    /** Upload data */
-    upload(data: Uint8Array, options?: TOptions): Promise<{
-        url: string;
-        size: number;
-        checksum?: string;
-    }>;
-    /** Download data */
-    download(url: string, options?: TOptions): Promise<{
-        data: Uint8Array;
-        size: number;
-        checksum?: string;
-    }>;
-    /** Delete data */
-    delete?(url: string, options?: TOptions): Promise<boolean>;
-    /** Check if data exists */
-    exists?(url: string, options?: TOptions): Promise<boolean>;
-}
-/**
- * Generic cache interface
- *
- * @category Reference
- */
-interface Cache<TKey = string, TValue = unknown> {
-    /** Get value from cache */
-    get(key: TKey): Promise<TValue | undefined>;
-    /** Set value in cache */
-    set(key: TKey, value: TValue, ttl?: number): Promise<void>;
-    /** Delete value from cache */
-    delete(key: TKey): Promise<boolean>;
-    /** Clear all cache */
-    clear(): Promise<void>;
-    /** Check if key exists */
-    has(key: TKey): Promise<boolean>;
-}
-/**
- * Generic retry configuration
- *
- * @category Reference
- */
-interface RetryConfig<TError = Error> {
-    /** Maximum retry attempts */
-    maxAttempts: number;
-    /** Base delay in milliseconds */
-    baseDelay: number;
-    /** Backoff multiplier */
-    backoffMultiplier?: number;
-    /** Maximum delay */
-    maxDelay?: number;
-    /** Jitter factor */
-    jitter?: number;
-    /** Retry condition */
-    shouldRetry?: (error: TError, attempt: number) => boolean;
-}
-/**
- * Generic rate limiter configuration
- *
- * @category Reference
- */
-interface RateLimiterConfig {
-    /** Requests per time window */
-    requestsPerWindow: number;
-    /** Time window in milliseconds */
-    windowMs: number;
-    /** Burst allowance */
-    burstLimit?: number;
-}
-/**
- * Generic middleware interface
- *
- * @category Reference
- */
-interface Middleware<TRequest = unknown, TResponse = unknown> {
-    /** Middleware name */
-    readonly name: string;
-    /** Process request */
-    request?(req: TRequest): Promise<TRequest>;
-    /** Process response */
-    response?(res: TResponse): Promise<TResponse>;
-    /** Handle errors */
-    error?(error: Error, req: TRequest): Promise<TResponse | void>;
-}
-/**
- * Generic plugin interface
- *
- * @category Reference
- */
-interface Plugin<TConfig = unknown> {
-    /** Plugin name */
-    readonly name: string;
-    /** Plugin version */
-    readonly version: string;
-    /** Plugin configuration */
-    readonly config: TConfig;
-    /** Initialize plugin */
-    init?(): Promise<void>;
-    /** Cleanup plugin */
-    cleanup?(): Promise<void>;
-}
-/**
- * Generic factory interface
- *
- * @category Reference
- */
-interface Factory<T, TParams = unknown> {
-    /** Create instance */
-    create(params: TParams): T;
-    /** Create multiple instances */
-    createMany?(params: TParams[]): T[];
-    /** Validate parameters */
-    validate?(params: TParams): boolean;
-}
-/**
- * Generic repository interface for data access
- *
- * @category Reference
- */
-interface Repository<TEntity, TKey = string | number> {
-    /** Find by ID */
-    findById(id: TKey): Promise<TEntity | undefined>;
-    /** Find all entities */
-    findAll(options?: {
-        limit?: number;
-        offset?: number;
-        filter?: Partial<TEntity>;
-        sort?: Array<{
-            field: keyof TEntity;
-            direction: "asc" | "desc";
-        }>;
-    }): Promise<{
-        entities: TEntity[];
-        total: number;
-        hasMore: boolean;
-    }>;
-    /** Create entity */
-    create(entity: Omit<TEntity, "id">): Promise<TEntity>;
-    /** Update entity */
-    update(id: TKey, updates: Partial<TEntity>): Promise<TEntity>;
-    /** Delete entity */
-    delete(id: TKey): Promise<boolean>;
-    /** Check if entity exists */
-    exists(id: TKey): Promise<boolean>;
-}
-/**
- * Generic validator interface
- *
- * @category Reference
- */
-interface Validator<T> {
-    /** Validate value */
-    validate(value: unknown): value is T;
-    /** Get validation errors */
-    getErrors?(value: unknown): string[];
-    /** Get validation schema */
-    getSchema?(): unknown;
-}
-/**
- * Generic transformer interface
- *
- * @category Reference
- */
-interface Transformer<TInput, TOutput> {
-    /** Transform input to output */
-    transform(input: TInput): TOutput | Promise<TOutput>;
-    /** Reverse transform output to input */
-    reverse?(output: TOutput): TInput | Promise<TInput>;
-}
-/**
- * Generic service interface
- *
- * @category Reference
- */
-interface Service<TConfig = unknown> {
-    /** Service name */
-    readonly name: string;
-    /** Service configuration */
-    readonly config: TConfig;
-    /** Service status */
-    readonly status: "idle" | "starting" | "running" | "stopping" | "stopped" | "error";
-    /** Start service */
-    start(): Promise<void>;
-    /** Stop service */
-    stop(): Promise<void>;
-    /** Restart service */
-    restart?(): Promise<void>;
-    /** Get health status */
-    getHealth?(): Promise<{
-        healthy: boolean;
-        details?: Record<string, unknown>;
-    }>;
-}
-/**
- * Generic observer pattern
- *
- * @category Reference
- */
-interface Observer<TEvent = unknown> {
-    /** Handle event */
-    notify(event: TEvent): void | Promise<void>;
-}
-/**
- * Generic observable pattern
- *
- * @category Reference
- */
-interface Observable<TEvent = unknown> {
-    /** Subscribe to events */
-    subscribe(observer: Observer<TEvent>): () => void;
-    /** Unsubscribe from events */
-    unsubscribe(observer: Observer<TEvent>): void;
-    /** Emit event */
-    emit(event: TEvent): void;
-}
-/**
- * Generic state machine interface
- *
- * @category Reference
- */
-interface StateMachine<TState, TEvent> {
-    /** Current state */
-    readonly currentState: TState;
-    /** Transition to new state */
-    transition(event: TEvent): TState;
-    /** Check if transition is valid */
-    canTransition(event: TEvent): boolean;
-    /** Get available transitions */
-    getAvailableTransitions(): TEvent[];
-}
-/**
- * Helper type to make properties optional conditionally
- *
- * @category Reference
- */
-type ConditionalOptional<T, K extends keyof T, Condition extends boolean> = Condition extends true ? Omit<T, K> & Partial<Pick<T, K>> : T;
-/**
- * Helper type to extract promise result type
- *
- * @category Reference
- */
-type PromiseResult<T> = T extends Promise<infer U> ? U : T;
-/**
- * Helper type to create a union of all possible keys
- *
- * @category Reference
- */
-type AllKeys<T> = T extends unknown ? keyof T : never;
-/**
- * Helper type to create a deep partial type
- *
- * @category Reference
- */
-type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
-};
-/**
- * Helper type to create a deep readonly type
- *
- * @category Reference
- */
-type DeepReadonly<T> = {
-    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
-};
-/**
- * Helper type to create a required type with specific keys
- *
- * @category Reference
- */
-type RequireKeys<T, K extends keyof T> = Required<Pick<T, K>> & Omit<T, K>;
-/**
- * Helper type to create an optional type with specific keys
- *
- * @category Reference
- */
-type OptionalKeys<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
-/**
- * Helper type to exclude null and undefined
- *
- * @category Reference
- */
-type NonNullable<T> = T extends null | undefined ? never : T;
-/**
- * Helper type to create a type with only specific keys
- *
- * @category Reference
- */
-type PickByType<T, U> = {
-    [K in keyof T as T[K] extends U ? K : never]: T[K];
-};
-/**
- * Helper type to omit keys by type
- *
- * @category Reference
- */
-type OmitByType<T, U> = {
-    [K in keyof T as T[K] extends U ? never : K]: T[K];
-};
-/**
- * Helper type for branded types
- *
- * @category Reference
- */
-type Brand<T, B> = T & {
-    readonly __brand: B;
-};
-/**
- * Helper type for nominal types
- *
- * @category Reference
- */
-type Nominal<T, N extends string> = T & {
-    readonly __nominal: N;
-};
-
-export type { AllKeys, AsyncResult, Brand, Cache, ConditionalOptional, ContractCall, Controller, ControllerContext, DeepPartial, DeepReadonly, EventFilter, EventLog, Factory, GenericRequest, GenericResponse, Middleware, Nominal, NonNullable, Observable, Observer, OmitByType, OptionalKeys, PickByType, Plugin, PromiseResult, RateLimiterConfig, Repository, RequireKeys, RetryConfig, Service, StateMachine, StorageProvider, Transformer, Validator };

package/dist/types/index.d.cts

@@ -1,22 +0,0 @@
-export { BaseConfig, BaseConfigWithStorage, ChainConfig, ChainConfigWithStorage, ConfigValidationOptions, ConfigValidationResult, DownloadRelayerCallbacks, RelayerCallbacks, RuntimeConfig, StorageConfig, StorageRequiredMarker, VanaConfig, VanaConfigWithStorage, WalletConfig, WalletConfigWithStorage, hasStorageConfig, isChainConfig, isWalletConfig } from './config.cjs';
-export { VanaChain, VanaChainId, isVanaChain, isVanaChainId } from './chains.cjs';
-export { ContractAddresses, ContractDeployment, ContractInfo, ContractMethodParams, ContractMethodReturnType, VanaContractInstance, VanaContractName } from './contracts.cjs';
-export { StorageError, StorageFile, StorageListOptions, StorageProvider, StorageProviderConfig, StorageUploadResult } from './storage.cjs';
-export { AddRefinerParams, AddRefinerResult, AddSchemaParams, AddSchemaResult, BatchUploadParams, BatchUploadResult, CompleteSchema, DeleteFileParams, DeleteFileResult, DownloadFileParams, DownloadFileResult, EncryptedUploadParams, EncryptionInfo, FileAccessPermissions, FileMetadata, FilePermissionParams, FileSharingConfig, GetFileParams, GetUserFilesParams, GetUserTrustedServersParams, LegacyPermissionParams, Refiner, Schema, SchemaMetadata, TrustedServer, UnencryptedUploadParams, UpdateSchemaIdParams, UpdateSchemaIdResult, UploadEncryptedFileResult, UploadFileParams, UploadFileResult, UploadParams, UploadResult, UserFile } from './data.cjs';
-export { CreateSchemaParams, CreateSchemaResult } from '../controllers/schemas.cjs';
-export { DataSchema, SchemaValidationError, SchemaValidator, fetchAndValidateSchema, validateDataAgainstSchema, validateDataSchemaAgainstMetaSchema } from '../utils/schemaValidation.cjs';
-export { AddAndTrustServerInput, AddAndTrustServerParams, AddAndTrustServerTypedData, BatchServerInfoResult, CheckPermissionParams, GenericTypedData, GetUserPermissionsOptions, GrantFile, GrantPermissionParams, GrantedPermission, Grantee, GranteeInfo, GranteeQueryOptions, OnChainPermissionGrant, PaginatedGrantees, PaginatedTrustedServers, Permission, PermissionAnalytics, PermissionCheckResult, PermissionEvent, PermissionGrantDomain, PermissionGrantMessage, PermissionGrantTypedData, PermissionInfo, PermissionInputMessage, PermissionOperation, PermissionQueryResult, PermissionStatus, QueryPermissionsParams, RegisterGranteeInput, RegisterGranteeParams, RegisterGranteeTypedData, RevokePermissionInput, RevokePermissionParams, RevokePermissionTypedData, Server, ServerFilesAndPermissionParams, ServerFilesAndPermissionTypedData, ServerInfo, ServerTrustStatus, SimplifiedPermissionMessage, SpecificTypedData, TrustServerInput, TrustServerParams, TrustServerTypedData, TrustedServerInfo, TrustedServerQueryOptions, TypedDataPrimaryType, UntrustServerInput, UntrustServerParams, UntrustServerTypedData } from './permissions.cjs';
-export { CreateOperationParams, InitPersonalServerParams, PersonalServerIdentity, PostRequestParams } from './personal.cjs';
-export { AuthenticationErrorResponse, BlockchainErrorResponse, ComputeErrorResponse, CreateOperationRequest, CreateOperationResponse, DecryptionErrorResponse, ErrorResponse, FileAccessErrorResponse, GetOperationResponse, GrantValidationErrorResponse, IdentityResponseModel, InternalServerErrorResponse, NotFoundErrorResponse, OperationErrorResponse, PersonalServerModel, ValidationErrorResponse } from '../generated/server/server-exports.cjs';
-export { APIResponse, PinataListResponse, PinataPin, PinataUploadResponse, ReplicateAPIResponse, ReplicateStatus, isAPIResponse, isReplicateAPIResponse, parseReplicateOutput, safeParseJSON } from './external-apis.cjs';
-export { RelayerConfig, RelayerErrorResponse, RelayerMetrics, RelayerQueueInfo, RelayerRequestOptions, RelayerStatus, RelayerStorageResponse, RelayerStoreParams, RelayerSubmitParams, RelayerTransactionResponse, RelayerTransactionStatus, RelayerWebhookConfig, RelayerWebhookPayload } from './relayer.cjs';
-export { ApiResponse, Awaited, BlockRange, CacheConfig, GasEstimate, MaybeArray, MaybePromise, NetworkInfo, PaginationParams, PaginationResult, PartialExcept, RateLimitInfo, RequiredExcept, StatusInfo, TimeRange, TransactionOptions, TransactionReceipt, UploadProgress, ValidationResult } from './utils.cjs';
-export { AllKeys, AsyncResult, Brand, Cache, ConditionalOptional, ContractCall, Controller, ControllerContext, DeepPartial, DeepReadonly, EventFilter, EventLog, Factory, GenericRequest, GenericResponse, Middleware, Nominal, NonNullable, Observable, Observer, OmitByType, OptionalKeys, PickByType, Plugin, PromiseResult, RateLimiterConfig, Repository, RequireKeys, RetryConfig, Service, StateMachine, Transformer, Validator } from './generics.cjs';
-export { Abi, Account, Address, Chain, GetContractReturnType, Hash, PublicClient, WalletClient } from 'viem';
-export { $defs, components as ServerComponents, $defs as ServerDefs, operations as ServerOperations, paths as ServerPaths, webhooks as ServerWebhooks, components, operations, paths, webhooks } from '../generated/server/server.cjs';
-import './transactionResults.cjs';
-import './controller-context.cjs';
-import '../platform/interface.cjs';
-import '../storage/manager.cjs';
-import './operations.cjs';
-import '../generated/event-types.cjs';