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

package/dist/server/handler.d.ts

@@ -0,0 +1,282 @@
+import { VanaCore } from '../core.js';
+import '../types.js';
+import '../types/external-apis.js';
+import '../generated/abi/index.js';
+import '../errors.js';
+import { b as PermissionGrantResult, c as PermissionRevokeResult, d as ServerTrustResult, e as ServerUntrustResult, G as GranteeRegisterResult, a as FileAddedResult } from '../permissions-eo8YeLGf.js';
+import '../controllers/data.js';
+import '../controllers/server.js';
+import '../controllers/protocol.js';
+import '../controllers/schemas.js';
+import '../contracts/contractController.js';
+import '../utils/encryption.js';
+import '../utils/formatters.js';
+import '../utils/grantFiles.js';
+import '../utils/grantValidation.js';
+import '../utils/grants.js';
+import '../utils/ipfs.js';
+import '../utils/schemaValidation.js';
+import '../utils/signatureCache.js';
+import '../types/storage.js';
+import '../storage/providers/google-drive.js';
+import '../storage/providers/ipfs.js';
+import '../storage/providers/pinata.js';
+import '../storage/providers/callback-storage.js';
+import '../storage/manager.js';
+import { VanaConfigWithStorage, VanaConfig, StorageRequiredMarker } from '../types/config.js';
+import '../config/addresses.js';
+import '../config/chains.js';
+import '../chains/definitions.js';
+import '../core/generics.js';
+import { Hash, Address } from 'viem';
+import { TransactionResult } from '../types/operations.js';
+import '../platform/node.js';
+import '../platform/browser.js';
+import '../platform/interface.js';
+import '../platform/utils.js';
+import '../platform/browser-safe.js';
+import '../core/apiClient.js';
+import '../types/chains.js';
+import '../types/contracts.js';
+import '../types/data.js';
+import { GenericTypedData } from '../types/permissions.js';
+import '../types/personal.js';
+import '../types/relayer.js';
+import '../types/utils.js';
+import '../types/generics.js';
+import '../generated/server/server.js';
+import '../generated/server/server-exports.js';
+import '../config/eventMappings.js';
+import '../generated/abi/DataPortabilityPermissionsImplementation.js';
+import '../generated/abi/DataPortabilityServersImplementation.js';
+import '../generated/abi/DataPortabilityGranteesImplementation.js';
+import '../generated/abi/VanaEpochImplementation.js';
+import '../generated/abi/DLPRegistryImplementation.js';
+import '../generated/abi/DLPTreasuryImplementation.js';
+import '../generated/abi/DLPRewardDeployerTreasuryImplementation.js';
+import '../generated/abi/DLPPerformanceImplementation.js';
+import '../generated/abi/DLPRewardDeployerImplementation.js';
+import '../generated/abi/DLPRootImplementation.js';
+import '../generated/abi/DataLiquidityPoolImplementation.js';
+import '../generated/abi/DLPRegistryTreasuryImplementation.js';
+import 'abitype';
+import '../core/client.js';
+
+/** 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/server/handler.js

@@ -0,0 +1,77 @@
+import { recoverTypedDataAddress, getAddress } from "viem";
+import { SignatureError } from "../errors";
+async function handleRelayerRequest(sdk, payload) {
+  const { typedData, signature, expectedUserAddress } = payload;
+  console.debug({
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    message: typedData.message,
+    signature
+  });
+  const signerAddress = await recoverTypedDataAddress({
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    message: typedData.message,
+    signature
+  });
+  if (!signerAddress) {
+    throw new SignatureError(
+      "Invalid signature - could not recover signer address"
+    );
+  }
+  if (expectedUserAddress) {
+    const normalizedSigner = getAddress(signerAddress);
+    const normalizedExpected = getAddress(expectedUserAddress);
+    if (normalizedSigner !== normalizedExpected) {
+      throw new SignatureError(
+        `Security verification failed: Recovered signer address (${normalizedSigner}) does not match expected user address (${normalizedExpected}). This may be due to incorrect EIP-712 domain configuration.`
+      );
+    }
+  }
+  const primaryType = typedData.primaryType;
+  switch (primaryType) {
+    case "Permission":
+      return sdk.permissions.submitSignedGrant(
+        typedData,
+        signature
+      );
+    case "RevokePermission":
+      return sdk.permissions.submitSignedRevoke(
+        typedData,
+        signature
+      );
+    case "TrustServer":
+      return sdk.permissions.submitSignedTrustServer(
+        typedData,
+        signature
+      );
+    case "AddServer":
+      return sdk.permissions.submitSignedAddAndTrustServer(
+        typedData,
+        signature
+      );
+    case "UntrustServer":
+      return sdk.permissions.submitSignedUntrustServer(
+        typedData,
+        signature
+      );
+    case "RegisterGrantee":
+      return sdk.permissions.submitSignedRegisterGrantee(
+        typedData,
+        signature
+      );
+    case "ServerFilesAndPermission":
+      return sdk.permissions.submitSignedAddServerFilesAndPermissions(
+        typedData,
+        signature
+      );
+    default:
+      throw new Error(`Unsupported operation type: ${typedData.primaryType}`);
+  }
+}
+export {
+  handleRelayerRequest
+};
+//# sourceMappingURL=handler.js.map

package/dist/server/handler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/server/handler.ts"],"sourcesContent":["import { Address, Hash, recoverTypedDataAddress, getAddress } from \"viem\";\nimport type { VanaInstance } from \"../index.node\";\nimport type {\n  GenericTypedData,\n  PermissionGrantTypedData,\n  RevokePermissionTypedData,\n  RegisterGranteeTypedData,\n  TrustServerTypedData,\n  AddAndTrustServerTypedData,\n  ServerFilesAndPermissionTypedData,\n  TypedDataPrimaryType,\n} from \"../types\";\nimport { SignatureError } from \"../errors\";\nimport type { TransactionResult } from \"../types/operations\";\nimport type {\n  PermissionGrantResult,\n  PermissionRevokeResult,\n  ServerTrustResult,\n  ServerUntrustResult,\n  GranteeRegisterResult,\n  FileAddedResult,\n} from \"../types/transactionResults\";\n\n/** Union type of all possible transaction results from relayer operations */\ntype RelayerTransactionResult =\n  | PermissionGrantResult\n  | PermissionRevokeResult\n  | ServerTrustResult\n  | ServerUntrustResult\n  | GranteeRegisterResult\n  | FileAddedResult;\n\n/**\n * Payload structure for relayer requests.\n * Contains the EIP-712 typed data, signature, and optional expected user address for security verification.\n *\n * @category Server\n */\nexport interface RelayerRequestPayload {\n  /** EIP-712 typed data containing the transaction details */\n  typedData: GenericTypedData;\n  /** User's signature of the typed data */\n  signature: Hash;\n  /** Optional expected user address for security verification */\n  expectedUserAddress?: Address;\n}\n\n/**\n * Unified server-side handler for processing relayed transactions.\n *\n * This function encapsulates the complete relayer workflow:\n * 1. Verifies the signature against the typed data\n * 2. Optionally checks the signer matches the expected user address\n * 3. Routes to the appropriate SDK method based on primaryType\n * 4. Returns the transaction handle with hash and event parsing capability\n *\n * Supported transaction types:\n * - Permission: Permission grants\n * - PermissionRevoke: Permission revocations\n * - TrustServer: Trust server operations\n * - UntrustServer: Untrust server operations\n * - AddServer: Add and trust server operations\n * - RegisterGrantee: Register grantee operations\n * - ServerFilesAndPermission: Batch operation for server, files, and permissions\n *\n * @param sdk - Initialized Vana SDK instance\n * @param payload - Request payload containing typed data, signature, and optional security check\n * @returns Promise resolving to TransactionResult with hash and optional event data\n * @throws {SignatureError} When signature verification fails or signer mismatch occurs\n * @throws {Error} When primaryType is unsupported or SDK operations fail\n * @category Server\n * @example\n * ```typescript\n * import { handleRelayerRequest } from '@opendatalabs/vana-sdk';\n *\n * // In your relayer API endpoint:\n * export async function POST(request: NextRequest) {\n *   try {\n *     const body = await request.json();\n *     const vana = await createRelayerVana();\n *\n *     const tx = await handleRelayerRequest(vana, {\n *       typedData: body.typedData,\n *       signature: body.signature,\n *       expectedUserAddress: body.expectedUserAddress\n *     });\n *\n *     // Option 1: Return just the hash immediately\n *     return NextResponse.json({\n *       success: true,\n *       transactionHash: tx.hash\n *     });\n *\n *     // Option 2: Wait for transaction confirmation and return event data\n *     const eventData = await tx.waitForEvents();\n *     return NextResponse.json({\n *       success: true,\n *       transactionHash: tx.hash,\n *       ...eventData // Include parsed event data like permissionId, fileId, etc.\n *     });\n *   } catch (error) {\n *     return NextResponse.json({\n *       success: false,\n *       error: error.message\n *     }, { status: 500 });\n *   }\n * }\n * ```\n */\nexport async function handleRelayerRequest(\n  sdk: VanaInstance,\n  payload: RelayerRequestPayload,\n): Promise<TransactionResult & { eventData?: RelayerTransactionResult }> {\n  const { typedData, signature, expectedUserAddress } = payload;\n\n  console.debug({\n    domain: typedData.domain,\n    types: typedData.types,\n    primaryType: typedData.primaryType,\n    message: typedData.message as unknown as Record<string, unknown>,\n    signature,\n  });\n\n  // Step 1: Verify signature and recover signer address\n  const signerAddress = await recoverTypedDataAddress({\n    domain: typedData.domain,\n    types: typedData.types,\n    primaryType: typedData.primaryType,\n    message: typedData.message as unknown as Record<string, unknown>,\n    signature,\n  });\n\n  if (!signerAddress) {\n    throw new SignatureError(\n      \"Invalid signature - could not recover signer address\",\n    );\n  }\n\n  // Step 2: Security check - verify signer matches expected user address if provided\n  if (expectedUserAddress) {\n    const normalizedSigner = getAddress(signerAddress);\n    const normalizedExpected = getAddress(expectedUserAddress);\n\n    if (normalizedSigner !== normalizedExpected) {\n      throw new SignatureError(\n        `Security verification failed: Recovered signer address (${normalizedSigner}) does not match expected user address (${normalizedExpected}). This may be due to incorrect EIP-712 domain configuration.`,\n      );\n    }\n  }\n\n  // Step 3: Route to appropriate SDK method based on primaryType\n  // Route to appropriate SDK method and return TransactionResult directly\n  const primaryType = typedData.primaryType as TypedDataPrimaryType;\n  switch (primaryType) {\n    case \"Permission\":\n      return sdk.permissions.submitSignedGrant(\n        typedData as unknown as PermissionGrantTypedData,\n        signature,\n      );\n\n    case \"RevokePermission\":\n      return sdk.permissions.submitSignedRevoke(\n        typedData as unknown as RevokePermissionTypedData,\n        signature,\n      );\n\n    case \"TrustServer\":\n      return sdk.permissions.submitSignedTrustServer(\n        typedData as unknown as TrustServerTypedData,\n        signature,\n      );\n\n    case \"AddServer\":\n      return sdk.permissions.submitSignedAddAndTrustServer(\n        typedData as unknown as AddAndTrustServerTypedData,\n        signature,\n      );\n\n    case \"UntrustServer\":\n      return sdk.permissions.submitSignedUntrustServer(\n        typedData as unknown as GenericTypedData,\n        signature,\n      );\n\n    case \"RegisterGrantee\":\n      return sdk.permissions.submitSignedRegisterGrantee(\n        typedData as unknown as RegisterGranteeTypedData,\n        signature,\n      );\n\n    case \"ServerFilesAndPermission\":\n      return sdk.permissions.submitSignedAddServerFilesAndPermissions(\n        typedData as unknown as ServerFilesAndPermissionTypedData,\n        signature,\n      );\n\n    default:\n      throw new Error(`Unsupported operation type: ${typedData.primaryType}`);\n  }\n}\n"],"mappings":"AAAA,SAAwB,yBAAyB,kBAAkB;AAYnE,SAAS,sBAAsB;AAiG/B,eAAsB,qBACpB,KACA,SACuE;AACvE,QAAM,EAAE,WAAW,WAAW,oBAAoB,IAAI;AAEtD,UAAQ,MAAM;AAAA,IACZ,QAAQ,UAAU;AAAA,IAClB,OAAO,UAAU;AAAA,IACjB,aAAa,UAAU;AAAA,IACvB,SAAS,UAAU;AAAA,IACnB;AAAA,EACF,CAAC;AAGD,QAAM,gBAAgB,MAAM,wBAAwB;AAAA,IAClD,QAAQ,UAAU;AAAA,IAClB,OAAO,UAAU;AAAA,IACjB,aAAa,UAAU;AAAA,IACvB,SAAS,UAAU;AAAA,IACnB;AAAA,EACF,CAAC;AAED,MAAI,CAAC,eAAe;AAClB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAGA,MAAI,qBAAqB;AACvB,UAAM,mBAAmB,WAAW,aAAa;AACjD,UAAM,qBAAqB,WAAW,mBAAmB;AAEzD,QAAI,qBAAqB,oBAAoB;AAC3C,YAAM,IAAI;AAAA,QACR,2DAA2D,gBAAgB,2CAA2C,kBAAkB;AAAA,MAC1I;AAAA,IACF;AAAA,EACF;AAIA,QAAM,cAAc,UAAU;AAC9B,UAAQ,aAAa;AAAA,IACnB,KAAK;AACH,aAAO,IAAI,YAAY;AAAA,QACrB;AAAA,QACA;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO,IAAI,YAAY;AAAA,QACrB;AAAA,QACA;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO,IAAI,YAAY;AAAA,QACrB;AAAA,QACA;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO,IAAI,YAAY;AAAA,QACrB;AAAA,QACA;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO,IAAI,YAAY;AAAA,QACrB;AAAA,QACA;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO,IAAI,YAAY;AAAA,QACrB;AAAA,QACA;AAAA,MACF;AAAA,IAEF,KAAK;AACH,aAAO,IAAI,YAAY;AAAA,QACrB;AAAA,QACA;AAAA,MACF;AAAA,IAEF;AACE,YAAM,IAAI,MAAM,+BAA+B,UAAU,WAAW,EAAE;AAAA,EAC1E;AACF;","names":[]}

package/dist/storage/index.cjs

@@ -0,0 +1,44 @@
+"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 storage_exports = {};
+__export(storage_exports, {
+  CallbackStorage: () => import_callback_storage.CallbackStorage,
+  GoogleDriveStorage: () => import_google_drive.GoogleDriveStorage,
+  IpfsStorage: () => import_ipfs.IpfsStorage,
+  PinataStorage: () => import_pinata.PinataStorage,
+  StorageError: () => import_storage.StorageError,
+  StorageManager: () => import_manager.StorageManager
+});
+module.exports = __toCommonJS(storage_exports);
+var import_storage = require("../types/storage");
+var import_google_drive = require("./providers/google-drive");
+var import_ipfs = require("./providers/ipfs");
+var import_pinata = require("./providers/pinata");
+var import_callback_storage = require("./providers/callback-storage");
+var import_manager = require("./manager");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CallbackStorage,
+  GoogleDriveStorage,
+  IpfsStorage,
+  PinataStorage,
+  StorageError,
+  StorageManager
+});
+//# sourceMappingURL=index.cjs.map

package/dist/storage/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/storage/index.ts"],"sourcesContent":["/**\n * Storage API for Vana SDK\n *\n * Provides unified interface for different storage providers\n * to upload, download, and manage user data files.\n *\n * ## Storage Provider Decision Tree\n *\n * Choose your storage provider based on your needs:\n *\n * **Need full CRUD operations and metadata?**\n * - ✅ Use `PinataStorage` - Managed IPFS with listing, deletion, and rich metadata\n *\n * **Want to use your own IPFS infrastructure?**\n * - ✅ Use `IpfsStorage.forInfura()` - Connect to Infura IPFS service\n * - ✅ Use `IpfsStorage.forLocalNode()` - Connect to local IPFS node\n * - ✅ Use `new IpfsStorage()` - Connect to any IPFS-compatible service\n *\n * **Want flexible callback-based storage?**\n * - ✅ Use `CallbackStorage` - Implement storage via custom callbacks (HTTP, WebSocket, etc.)\n *\n * **Need Google Drive integration?**\n * - ✅ Use `GoogleDriveStorage` - Direct Google Drive API with folder management\n *\n * @example\n * ```typescript\n * // Managed IPFS with full features\n * const pinata = new PinataStorage({ jwt: \"your-jwt\" });\n *\n * // Standard IPFS with Infura\n * const ipfs = IpfsStorage.forInfura({ projectId: \"...\", projectSecret: \"...\" });\n *\n * // Callback-based storage (flexible)\n * const storage = new CallbackStorage({\n *   async upload(blob, filename) {\n *     // Your custom upload logic\n *     const response = await fetch('/api/upload', { method: 'POST', body: blob });\n *     const data = await response.json();\n *     return { url: data.url, size: blob.size, contentType: blob.type };\n *   },\n *   async download(identifier) {\n *     // Your custom download logic\n *     const response = await fetch(`/api/download/${identifier}`);\n *     return response.blob();\n *   }\n * });\n * ```\n */\n\n// Re-export storage types from types module to avoid circular dependencies\nexport type {\n  StorageProvider,\n  StorageUploadResult,\n  StorageFile,\n  StorageListOptions,\n  StorageProviderConfig,\n} from \"../types/storage\";\n\nexport { StorageError } from \"../types/storage\";\n\n// Export storage providers\nexport { GoogleDriveStorage } from \"./providers/google-drive\";\nexport { IpfsStorage } from \"./providers/ipfs\";\nexport { PinataStorage } from \"./providers/pinata\";\nexport { CallbackStorage } from \"./providers/callback-storage\";\n\n// Export storage manager\nexport { StorageManager } from \"./manager\";\n\n// Export storage callback types\nexport type {\n  StorageCallbacks,\n  StorageDownloadOptions,\n  StorageListResult,\n} from \"../types/config\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0DA,qBAA6B;AAG7B,0BAAmC;AACnC,kBAA4B;AAC5B,oBAA8B;AAC9B,8BAAgC;AAGhC,qBAA+B;","names":[]}

package/dist/storage/index.d.cts

@@ -0,0 +1,10 @@
+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/index.d.ts

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

package/dist/storage/index.js

@@ -0,0 +1,15 @@
+import { StorageError } from "../types/storage";
+import { GoogleDriveStorage } from "./providers/google-drive";
+import { IpfsStorage } from "./providers/ipfs";
+import { PinataStorage } from "./providers/pinata";
+import { CallbackStorage } from "./providers/callback-storage";
+import { StorageManager } from "./manager";
+export {
+  CallbackStorage,
+  GoogleDriveStorage,
+  IpfsStorage,
+  PinataStorage,
+  StorageError,
+  StorageManager
+};
+//# sourceMappingURL=index.js.map

package/dist/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/storage/index.ts"],"sourcesContent":["/**\n * Storage API for Vana SDK\n *\n * Provides unified interface for different storage providers\n * to upload, download, and manage user data files.\n *\n * ## Storage Provider Decision Tree\n *\n * Choose your storage provider based on your needs:\n *\n * **Need full CRUD operations and metadata?**\n * - ✅ Use `PinataStorage` - Managed IPFS with listing, deletion, and rich metadata\n *\n * **Want to use your own IPFS infrastructure?**\n * - ✅ Use `IpfsStorage.forInfura()` - Connect to Infura IPFS service\n * - ✅ Use `IpfsStorage.forLocalNode()` - Connect to local IPFS node\n * - ✅ Use `new IpfsStorage()` - Connect to any IPFS-compatible service\n *\n * **Want flexible callback-based storage?**\n * - ✅ Use `CallbackStorage` - Implement storage via custom callbacks (HTTP, WebSocket, etc.)\n *\n * **Need Google Drive integration?**\n * - ✅ Use `GoogleDriveStorage` - Direct Google Drive API with folder management\n *\n * @example\n * ```typescript\n * // Managed IPFS with full features\n * const pinata = new PinataStorage({ jwt: \"your-jwt\" });\n *\n * // Standard IPFS with Infura\n * const ipfs = IpfsStorage.forInfura({ projectId: \"...\", projectSecret: \"...\" });\n *\n * // Callback-based storage (flexible)\n * const storage = new CallbackStorage({\n *   async upload(blob, filename) {\n *     // Your custom upload logic\n *     const response = await fetch('/api/upload', { method: 'POST', body: blob });\n *     const data = await response.json();\n *     return { url: data.url, size: blob.size, contentType: blob.type };\n *   },\n *   async download(identifier) {\n *     // Your custom download logic\n *     const response = await fetch(`/api/download/${identifier}`);\n *     return response.blob();\n *   }\n * });\n * ```\n */\n\n// Re-export storage types from types module to avoid circular dependencies\nexport type {\n  StorageProvider,\n  StorageUploadResult,\n  StorageFile,\n  StorageListOptions,\n  StorageProviderConfig,\n} from \"../types/storage\";\n\nexport { StorageError } from \"../types/storage\";\n\n// Export storage providers\nexport { GoogleDriveStorage } from \"./providers/google-drive\";\nexport { IpfsStorage } from \"./providers/ipfs\";\nexport { PinataStorage } from \"./providers/pinata\";\nexport { CallbackStorage } from \"./providers/callback-storage\";\n\n// Export storage manager\nexport { StorageManager } from \"./manager\";\n\n// Export storage callback types\nexport type {\n  StorageCallbacks,\n  StorageDownloadOptions,\n  StorageListResult,\n} from \"../types/config\";\n"],"mappings":"AA0DA,SAAS,oBAAoB;AAG7B,SAAS,0BAA0B;AACnC,SAAS,mBAAmB;AAC5B,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAGhC,SAAS,sBAAsB;","names":[]}

package/dist/storage/manager.cjs

@@ -0,0 +1,189 @@
+"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 manager_exports = {};
+__export(manager_exports, {
+  StorageManager: () => StorageManager
+});
+module.exports = __toCommonJS(manager_exports);
+var import_index = require("./index");
+class StorageManager {
+  providers = /* @__PURE__ */ new Map();
+  defaultProvider = null;
+  /**
+   * 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, provider, isDefault = false) {
+    this.providers.set(name, provider);
+    if (isDefault || this.defaultProvider === null) {
+      this.defaultProvider = name;
+    }
+  }
+  /**
+   * Get a registered storage provider
+   *
+   * @param name - Provider identifier, uses default if not specified
+   * @returns Storage provider instance
+   */
+  getProvider(name) {
+    const providerName = name || this.defaultProvider;
+    if (!providerName) {
+      throw new import_index.StorageError(
+        "No storage provider specified and no default provider set",
+        "NO_PROVIDER",
+        "manager"
+      );
+    }
+    const provider = this.providers.get(providerName);
+    if (!provider) {
+      throw new import_index.StorageError(
+        `Storage provider '${providerName}' not found`,
+        "PROVIDER_NOT_FOUND",
+        "manager"
+      );
+    }
+    return provider;
+  }
+  /**
+   * List all registered providers
+   *
+   * @returns Array of provider names
+   */
+  listProviders() {
+    return Array.from(this.providers.keys());
+  }
+  /**
+   * Get the default provider name
+   *
+   * @returns Default provider name or null
+   */
+  getDefaultProvider() {
+    return this.defaultProvider;
+  }
+  /**
+   * Set the default provider
+   *
+   * @param name - Provider identifier
+   */
+  setDefaultProvider(name) {
+    if (!this.providers.has(name)) {
+      throw new import_index.StorageError(
+        `Cannot set default provider '${name}': provider not registered`,
+        "PROVIDER_NOT_FOUND",
+        "manager"
+      );
+    }
+    this.defaultProvider = name;
+  }
+  /**
+   * 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');
+   * ```
+   */
+  async upload(file, filename, providerName) {
+    const provider = this.getProvider(providerName);
+    return provider.upload(file, filename);
+  }
+  /**
+   * 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
+   */
+  async download(url, providerName) {
+    const provider = this.getProvider(providerName);
+    return provider.download(url);
+  }
+  /**
+   * 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
+   */
+  async list(options, providerName) {
+    const provider = this.getProvider(providerName);
+    return provider.list(options);
+  }
+  /**
+   * 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
+   */
+  async delete(url, providerName) {
+    const provider = this.getProvider(providerName);
+    return provider.delete(url);
+  }
+  /**
+   * Get list of registered storage provider names
+   *
+   * @returns Array of provider names
+   */
+  getStorageProviders() {
+    return Array.from(this.providers.keys());
+  }
+  /**
+   * Get the default storage provider name
+   *
+   * @returns Default provider name or undefined
+   */
+  getDefaultStorageProvider() {
+    return this.defaultProvider || void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StorageManager
+});
+//# sourceMappingURL=manager.cjs.map