@opendatalabs/vana-sdk 0.1.0-alpha.273dc39 → 0.1.0-alpha.276ea01

package/dist/server/handler.d.cts

@@ -0,0 +1,282 @@
+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/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":[]}