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

package/dist/server/handler.d.cts

@@ -1,282 +0,0 @@
-import { VanaCore } from '../core.cjs';
-import '../types.cjs';
-import '../types/external-apis.cjs';
-import '../generated/abi/index.cjs';
-import '../errors.cjs';
-import { b as PermissionGrantResult, c as PermissionRevokeResult, d as ServerTrustResult, e as ServerUntrustResult, G as GranteeRegisterResult, a as FileAddedResult } from '../permissions-DNKPu_G0.cjs';
-import '../controllers/data.cjs';
-import '../controllers/server.cjs';
-import '../controllers/protocol.cjs';
-import '../controllers/schemas.cjs';
-import '../contracts/contractController.cjs';
-import '../utils/encryption.cjs';
-import '../utils/formatters.cjs';
-import '../utils/grantFiles.cjs';
-import '../utils/grantValidation.cjs';
-import '../utils/grants.cjs';
-import '../utils/ipfs.cjs';
-import '../utils/schemaValidation.cjs';
-import '../utils/signatureCache.cjs';
-import '../types/storage.cjs';
-import '../storage/providers/google-drive.cjs';
-import '../storage/providers/ipfs.cjs';
-import '../storage/providers/pinata.cjs';
-import '../storage/providers/callback-storage.cjs';
-import '../storage/manager.cjs';
-import { VanaConfigWithStorage, VanaConfig, StorageRequiredMarker } from '../types/config.cjs';
-import '../config/addresses.cjs';
-import '../config/chains.cjs';
-import '../chains/definitions.cjs';
-import '../core/generics.cjs';
-import { Hash, Address } from 'viem';
-import { TransactionResult } from '../types/operations.cjs';
-import '../platform/node.cjs';
-import '../platform/browser.cjs';
-import '../platform/interface.cjs';
-import '../platform/utils.cjs';
-import '../platform/browser-safe.cjs';
-import '../core/apiClient.cjs';
-import '../types/chains.cjs';
-import '../types/contracts.cjs';
-import '../types/data.cjs';
-import { GenericTypedData } from '../types/permissions.cjs';
-import '../types/personal.cjs';
-import '../types/relayer.cjs';
-import '../types/utils.cjs';
-import '../types/generics.cjs';
-import '../generated/server/server.cjs';
-import '../generated/server/server-exports.cjs';
-import '../config/eventMappings.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';
-
-/** Union type of all possible transaction results from relayer operations */
-type RelayerTransactionResult = PermissionGrantResult | PermissionRevokeResult | ServerTrustResult | ServerUntrustResult | GranteeRegisterResult | FileAddedResult;
-/**
- * Payload structure for relayer requests.
- * Contains the EIP-712 typed data, signature, and optional expected user address for security verification.
- *
- * @category Server
- */
-interface RelayerRequestPayload {
-    /** EIP-712 typed data containing the transaction details */
-    typedData: GenericTypedData;
-    /** User's signature of the typed data */
-    signature: Hash;
-    /** Optional expected user address for security verification */
-    expectedUserAddress?: Address;
-}
-/**
- * Unified server-side handler for processing relayed transactions.
- *
- * This function encapsulates the complete relayer workflow:
- * 1. Verifies the signature against the typed data
- * 2. Optionally checks the signer matches the expected user address
- * 3. Routes to the appropriate SDK method based on primaryType
- * 4. Returns the transaction handle with hash and event parsing capability
- *
- * Supported transaction types:
- * - Permission: Permission grants
- * - PermissionRevoke: Permission revocations
- * - TrustServer: Trust server operations
- * - UntrustServer: Untrust server operations
- * - AddServer: Add and trust server operations
- * - RegisterGrantee: Register grantee operations
- * - ServerFilesAndPermission: Batch operation for server, files, and permissions
- *
- * @param sdk - Initialized Vana SDK instance
- * @param payload - Request payload containing typed data, signature, and optional security check
- * @returns Promise resolving to TransactionResult with hash and optional event data
- * @throws {SignatureError} When signature verification fails or signer mismatch occurs
- * @throws {Error} When primaryType is unsupported or SDK operations fail
- * @category Server
- * @example
- * ```typescript
- * import { handleRelayerRequest } from '@opendatalabs/vana-sdk';
- *
- * // In your relayer API endpoint:
- * export async function POST(request: NextRequest) {
- *   try {
- *     const body = await request.json();
- *     const vana = await createRelayerVana();
- *
- *     const tx = await handleRelayerRequest(vana, {
- *       typedData: body.typedData,
- *       signature: body.signature,
- *       expectedUserAddress: body.expectedUserAddress
- *     });
- *
- *     // Option 1: Return just the hash immediately
- *     return NextResponse.json({
- *       success: true,
- *       transactionHash: tx.hash
- *     });
- *
- *     // Option 2: Wait for transaction confirmation and return event data
- *     const eventData = await tx.waitForEvents();
- *     return NextResponse.json({
- *       success: true,
- *       transactionHash: tx.hash,
- *       ...eventData // Include parsed event data like permissionId, fileId, etc.
- *     });
- *   } catch (error) {
- *     return NextResponse.json({
- *       success: false,
- *       error: error.message
- *     }, { status: 500 });
- *   }
- * }
- * ```
- */
-declare function handleRelayerRequest(sdk: VanaInstance, payload: RelayerRequestPayload): Promise<TransactionResult & {
-    eventData?: RelayerTransactionResult;
-}>;
-
-/**
- * Internal implementation class for Node.js environments.
- * This class is not exported directly - use the Vana factory function instead.
- */
-declare class VanaNodeImpl extends VanaCore {
-    constructor(config: VanaConfig);
-}
-/**
- * Creates a new Vana SDK instance configured for Node.js environments.
- *
- * @remarks
- * This is the primary entry point for Node.js applications using the Vana SDK. The function
- * automatically detects your configuration type and provides compile-time type safety:
- * - **With storage configured**: All methods including file upload/download are available
- * - **Without storage**: Storage-dependent methods throw runtime errors and are excluded from TypeScript
- *
- * The Node.js version provides enhanced capabilities including native file system access,
- * server-side cryptographic operations, and support for personal server deployment.
- * It includes all browser capabilities plus Node.js-specific optimizations and utilities.
- *
- * @param config - Configuration object containing wallet, storage, and relayer settings
- * @returns A fully configured Vana SDK instance for Node.js use
- * @throws {InvalidConfigurationError} When configuration parameters are invalid or missing
- * @example
- * ```typescript
- * import { Vana } from '@opendatalabs/vana-sdk/node';
- * import { createWalletClient, http } from 'viem';
- * import { privateKeyToAccount } from 'viem/accounts';
- * import { IPFSStorage, PinataStorage } from '@opendatalabs/vana-sdk/node';
- * import { mokshaTestnet } from '@opendatalabs/vana-sdk/node';
- *
- * // Server setup with private key
- * const account = privateKeyToAccount('0x...');
- * const walletClient = createWalletClient({
- *   account,
- *   chain: mokshaTestnet,
- *   transport: http('https://rpc.moksha.vana.org')
- * });
- *
- * const vana = Vana({
- *   walletClient,
- *   storage: {
- *     providers: {
- *       ipfs: new IPFSStorage({
- *         gateway: 'https://gateway.pinata.cloud',
- *         timeout: 30000
- *       }),
- *       pinata: new PinataStorage({
- *         apiKey: process.env.PINATA_KEY,
- *         secretKey: process.env.PINATA_SECRET
- *       })
- *     },
- *     defaultProvider: 'pinata'
- *   },
- *   relayerCallbacks: {
- *     async submitPermissionGrant(typedData, signature) {
- *       // Server-side relayer implementation
- *       return await submitToCustomRelayer(typedData, signature);
- *     }
- *   }
- * });
- *
- * // Server operations
- * const uploadResult = await vana.data.upload({
- *   content: await fs.readFile('./user-data.json'),
- *   filename: 'user-data.json',
- *   schemaId: 1
- * });
- *
- * // Personal server setup
- * await vana.server.setupPersonalServer({
- *   serverUrl: 'https://my-server.example.com',
- *   capabilities: ['data_processing', 'ml_inference']
- * });
- * ```
- *
- * @example
- * ```typescript
- * // CLI tool or script usage
- * const vana = Vana({
- *   chainId: 14800, // Moksha testnet
- *   account: privateKeyToAccount(process.env.PRIVATE_KEY),
- *   rpcUrl: process.env.RPC_URL,
- *   storage: {
- *     providers: { ipfs: new IPFSStorage() },
- *     defaultProvider: 'ipfs'
- *   }
- * });
- *
- * // Batch operations for data processing
- * const userFiles = await vana.data.getUserFiles({
- *   owner: process.env.USER_ADDRESS
- * });
- *
- * for (const file of userFiles) {
- *   const decrypted = await vana.data.decryptFile(file);
- *   // Process file data...
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Express.js server integration
- * import express from 'express';
- * import { handleRelayerRequest } from '@opendatalabs/vana-sdk/node';
- *
- * const app = express();
- *
- * app.post('/api/relay/:operation', async (req, res) => {
- *   try {
- *     const result = await handleRelayerRequest(
- *       req.params.operation,
- *       req.body,
- *       vana
- *     );
- *     res.json({ success: true, result });
- *   } catch (error) {
- *     res.status(500).json({ error: error.message });
- *   }
- * });
- * ```
- *
- * @see {@link https://docs.vana.org/docs/sdk/server-setup | Server Setup Guide} for Node.js-specific features
- * @see {@link VanaCore} for the underlying implementation details
- * @category Core SDK
- */
-declare function Vana(config: VanaConfigWithStorage): VanaNodeImpl & StorageRequiredMarker;
-declare function Vana(config: VanaConfig): VanaNodeImpl;
-/**
- * The type of a Vana SDK instance in Node.js environments.
- *
- * @see {@link Vana}
- */
-type VanaInstance = VanaNodeImpl;
-
-export { type RelayerRequestPayload, Vana as V, VanaNodeImpl as a, type VanaInstance as b, handleRelayerRequest };

package/dist/storage/index.d.cts

@@ -1,10 +0,0 @@
-export { StorageError, StorageFile, StorageListOptions, StorageProvider, StorageProviderConfig, StorageUploadResult } from '../types/storage.cjs';
-export { GoogleDriveStorage } from './providers/google-drive.cjs';
-export { IpfsStorage } from './providers/ipfs.cjs';
-export { PinataStorage } from './providers/pinata.cjs';
-export { CallbackStorage } from './providers/callback-storage.cjs';
-export { StorageManager } from './manager.cjs';
-export { StorageCallbacks, StorageDownloadOptions, StorageListResult } from '../types/config.cjs';
-import 'viem';
-import '../types/chains.cjs';
-import '../types/permissions.cjs';

package/dist/storage/manager.d.cts

@@ -1,150 +0,0 @@
-import { StorageProvider, StorageUploadResult, StorageListOptions, StorageFile } from '../types/storage.cjs';
-
-/**
- * Manages multiple storage providers with a unified interface for file operations.
- *
- * @remarks
- * The StorageManager provides a consistent API for uploading, downloading, and managing
- * files across different storage backends including IPFS, Pinata, Google Drive, and
- * server-managed storage. It handles provider registration, default provider selection,
- * and automatic fallback scenarios for robust file operations.
- *
- * Used internally by DataController for encrypted file storage, but can also be used
- * directly for custom storage workflows. Each provider implements the `StorageProvider`
- * interface to ensure consistent behavior across different storage backends.
- *
- * The manager supports provider-specific configurations and features while maintaining
- * a uniform API surface for applications.
- * @example
- * ```typescript
- * import { StorageManager, IPFSStorage, PinataStorage } from '@opendatalabs/vana-sdk';
- *
- * const storage = new StorageManager();
- *
- * // Register multiple providers
- * storage.register('ipfs', new IPFSStorage({
- *   apiEndpoint: 'https://api.pinata.cloud/pinning/pinFileToIPFS'
- * }), true);
- * storage.register('pinata', new PinataStorage({
- *   jwt: 'your-pinata-jwt-token'
- * }));
- *
- * // Upload to default provider
- * const result = await storage.upload(fileBlob, 'myfile.json');
- *
- * // Upload to specific provider
- * const result2 = await storage.upload(fileBlob, 'myfile.json', 'pinata');
- * ```
- * @category Storage
- * @see {@link https://docs.vana.com/developer/vana-sdk-documentation/core-modules/storage-providers | Storage Providers Guide} for configuration details
- */
-declare class StorageManager {
-    private providers;
-    private defaultProvider;
-    /**
-     * Registers a storage provider with the manager.
-     *
-     * @remarks
-     * This method adds a new storage provider to the manager's registry and optionally
-     * sets it as the default provider for subsequent operations. If no default provider
-     * is currently set, the first registered provider automatically becomes the default.
-     * @param name - Unique identifier for the provider
-     * @param provider - The storage provider instance implementing the `StorageProvider` interface
-     * @param isDefault - Whether this provider should be set as the default (defaults to `false`)
-     * @example
-     * ```typescript
-     * const pinata = new PinataStorage({ jwt: 'your-jwt-token' });
-     * storage.register('pinata', pinata, true); // Set as default
-     *
-     * const ipfs = new IPFSStorage({ apiEndpoint: 'https://...' });
-     * storage.register('ipfs', ipfs); // Not default
-     * ```
-     */
-    register(name: string, provider: StorageProvider, isDefault?: boolean): void;
-    /**
-     * Get a registered storage provider
-     *
-     * @param name - Provider identifier, uses default if not specified
-     * @returns Storage provider instance
-     */
-    getProvider(name?: string): StorageProvider;
-    /**
-     * List all registered providers
-     *
-     * @returns Array of provider names
-     */
-    listProviders(): string[];
-    /**
-     * Get the default provider name
-     *
-     * @returns Default provider name or null
-     */
-    getDefaultProvider(): string | null;
-    /**
-     * Set the default provider
-     *
-     * @param name - Provider identifier
-     */
-    setDefaultProvider(name: string): void;
-    /**
-     * Uploads a file using the specified or default storage provider.
-     *
-     * @remarks
-     * This method uploads a file to the specified provider or falls back to the default
-     * provider if none is specified. The upload result includes the storage URL, file size,
-     * content type, and provider-specific metadata that can be used for subsequent operations.
-     * @param file - The file blob to upload
-     * @param filename - Optional custom filename (defaults to auto-generated name)
-     * @param providerName - Optional provider identifier (uses default if not specified)
-     * @returns A Promise that resolves to the storage upload result with URL and metadata
-     * @throws {StorageError} When no provider is available or upload fails
-     * @example
-     * ```typescript
-     * // Upload to default provider
-     * const result = await storage.upload(fileBlob, 'data.json');
-     * console.log(`Uploaded to: ${result.url}`);
-     *
-     * // Upload to specific provider
-     * const result2 = await storage.upload(fileBlob, 'data.json', 'pinata');
-     * ```
-     */
-    upload(file: Blob, filename?: string, providerName?: string): Promise<StorageUploadResult>;
-    /**
-     * Download a file using the specified or default provider
-     *
-     * @param url - The storage URL
-     * @param providerName - Optional provider to use
-     * @returns Promise with file blob
-     */
-    download(url: string, providerName?: string): Promise<Blob>;
-    /**
-     * List files using the specified or default provider
-     *
-     * @param options - Optional filtering and pagination
-     * @param providerName - Optional provider to use
-     * @returns Promise with file list
-     */
-    list(options?: StorageListOptions, providerName?: string): Promise<StorageFile[]>;
-    /**
-     * Delete a file using the specified or default provider
-     *
-     * @param url - The storage URL
-     * @param providerName - Optional provider to use
-     * @returns Promise with success status
-     */
-    delete(url: string, providerName?: string): Promise<boolean>;
-    /**
-     * Get list of registered storage provider names
-     *
-     * @returns Array of provider names
-     */
-    getStorageProviders(): string[];
-    /**
-     * Get the default storage provider name
-     *
-     * @returns Default provider name or undefined
-     */
-    getDefaultStorageProvider(): string | undefined;
-}
-
-export { StorageManager };

package/dist/storage/providers/callback-storage.d.cts

@@ -1,100 +0,0 @@
-import { StorageProvider, StorageUploadResult, StorageListOptions, StorageFile, StorageProviderConfig } from '../../types/storage.cjs';
-import { StorageCallbacks } from '../../types/config.cjs';
-import 'viem';
-import '../../types/chains.cjs';
-import '../../types/permissions.cjs';
-
-/**
- * Storage provider that delegates all operations to user-provided callbacks.
- *
- * This provider follows the same flexible pattern as relayer callbacks,
- * allowing users to implement storage operations in any way they choose
- * (HTTP, WebSocket, direct cloud APIs, local filesystem, etc.).
- *
- * @category Storage
- * @example
- * ```typescript
- * // HTTP-based implementation
- * const httpCallbacks: StorageCallbacks = {
- *   async upload(blob, filename) {
- *     const formData = new FormData();
- *     formData.append('file', blob, filename);
- *     const response = await fetch('/api/storage/upload', {
- *       method: 'POST',
- *       body: formData
- *     });
- *     const data = await response.json();
- *     return {
- *       url: data.url,
- *       size: blob.size,
- *       contentType: blob.type
- *     };
- *   },
- *   async download(identifier) {
- *     const response = await fetch(`/api/storage/download/${identifier}`);
- *     return response.blob();
- *   }
- * };
- *
- * const storage = new CallbackStorage(httpCallbacks);
- *
- * // Direct S3 implementation
- * const s3Callbacks: StorageCallbacks = {
- *   async upload(blob, filename) {
- *     const url = await getPresignedUploadUrl(filename);
- *     await fetch(url, { method: 'PUT', body: blob });
- *     return {
- *       url: `s3://my-bucket/${filename}`,
- *       size: blob.size,
- *       contentType: blob.type
- *     };
- *   },
- *   async download(identifier) {
- *     const url = await getPresignedDownloadUrl(identifier);
- *     const response = await fetch(url);
- *     return response.blob();
- *   }
- * };
- * ```
- */
-declare class CallbackStorage implements StorageProvider {
-    private readonly callbacks;
-    constructor(callbacks: StorageCallbacks);
-    /**
-     * Upload a file using the provided callback
-     *
-     * @param file - The blob to upload
-     * @param filename - Optional filename for the upload
-     * @returns The upload result with URL and metadata
-     */
-    upload(file: Blob, filename?: string): Promise<StorageUploadResult>;
-    /**
-     * Download a file using the provided callback
-     *
-     * @param url - The URL or identifier to download
-     * @returns The downloaded blob
-     */
-    download(url: string): Promise<Blob>;
-    /**
-     * List files using the provided callback (if available)
-     *
-     * @param options - Optional list options including filters and pagination
-     * @returns Array of storage files
-     */
-    list(options?: StorageListOptions): Promise<StorageFile[]>;
-    /**
-     * Delete a file using the provided callback (if available)
-     *
-     * @param url - The URL or identifier to delete
-     * @returns True if deletion succeeded
-     */
-    delete(url: string): Promise<boolean>;
-    /**
-     * Get provider configuration
-     *
-     * @returns Provider configuration metadata
-     */
-    getConfig(): StorageProviderConfig;
-}
-
-export { CallbackStorage };