cilantro-sdk 0.0.31 → 0.0.33

package/README.md

@@ -1,6 +1,31 @@
 # Cilantro Smart SDK
 
-A TypeScript/JavaScript SDK for interacting with the Cilantro Smart API - A Solana wallet management system.
+A TypeScript/JavaScript SDK for interacting with the Cilantro Smart API - A Solana wallet management system with comprehensive signer management, passkey support, and multi-device capabilities.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [Complete API Reference](#complete-api-reference)
+  - [SDK Configuration](#sdk-configuration-cilantro-sdk)
+  - [Platform Module](#platform-module-cilantro-sdkplatform)
+  - [User Module](#user-module-cilantro-sdkuser)
+  - [Wallet Module](#wallet-module-cilantro-sdkwallet)
+  - [Auth Module](#auth-module-cilantro-sdkauth)
+  - [Subscriptions Module](#subscriptions-module-cilantro-sdksubscriptions)
+  - [Plans Module](#plans-module-cilantro-sdkplans)
+  - [Transactions Module](#transactions-module-cilantro-sdktransactions)
+  - [Delegated Keys Module](#delegated-keys-module-cilantro-sdkdelegated-keys)
+  - [Webhooks Module](#webhooks-module-cilantro-sdkwebhooks)
+  - [Helpers Module](#helpers-module-cilantro-sdkhelpers)
+  - [Utils Module](#utils-module-cilantro-sdkutils)
+- [Examples & Use Cases](#examples--use-cases)
+- [Error Handling](#error-handling)
+- [TypeScript Support](#typescript-support)
+- [Cross-Platform Support](#cross-platform-support)
+- [Best Practices](#best-practices)
+- [License](#license)
 
 ## Installation
 
@@ -133,189 +158,2656 @@ const keypair = await getEmailSignerKeypair(
 ### Available Helpers
 
 **Device Key Management:**
-- `getDevicePublicKey()` - Get or create device key with caching
 - `generateDeviceKeyPair()` - Generate new device key pair
-- `rotateDeviceKey()` - Rotate device keys
-- `clearDeviceKeyCache()` - Clear cache
-- `findDeviceKeyByPublicKey()` - Find device key by public key
-- `listAllDeviceKeys()` - List all device keys with metadata
+- `getOrCreateDeviceKeyPair(storage, keyId?)` - Get or create device key pair with caching
+- `getDevicePublicKey(storage, keyId)` - Get device public key
+- `getDevicePrivateKey(storage, keyId)` - Get device private key
+- `rotateDeviceKey(storage, keyId)` - Rotate device keys
+- `clearDeviceKeyCache(keyId?)` - Clear device key cache
+- `deleteDeviceKey(storage, keyId)` - Delete device key
+- `listDeviceKeys(storage)` - List all device key IDs
+- `findDeviceKeyByPublicKey(storage, publicKey)` - Find device key by public key
+- `listAllDeviceKeys(storage)` - List all device keys with metadata
 
 **Email Signer Helpers:**
-- `createEmailSignerHelper()` - Create email signer with automatic device key generation
-- `getEmailSignerKeypair()` - Get keypair with automatic device key resolution
-- `signWithEmailSigner()` - Sign messages with email signer
-- `getEmailSignerByEmail()` - Find email signer by email address
+- `createEmailSignerHelper(walletId, options)` - Create email signer with automatic device key generation
+- `getEmailSignerKeypair(walletId, signerId, options)` - Get keypair with automatic device key resolution
+- `signWithEmailSigner(walletId, signerId, message, options)` - Sign messages with email signer
+- `clearEmailSignerCache(walletId, signerId?)` - Clear email signer cache
+- `getEmailSignerByEmail(walletId, email)` - Find email signer by email address
 
 **Phone Signer Helpers:**
-- `createPhoneSignerHelper()` - Create phone signer with automatic device key generation
-- `getPhoneSignerKeypair()` - Get keypair with automatic device key resolution
-- `signWithPhoneSigner()` - Sign messages with phone signer
-- `getPhoneSignerByPhone()` - Find phone signer by phone number
+- `createPhoneSignerHelper(walletId, options)` - Create phone signer with automatic device key generation
+- `getPhoneSignerKeypair(walletId, signerId, options)` - Get keypair with automatic device key resolution
+- `signWithPhoneSigner(walletId, signerId, message, options)` - Sign messages with phone signer
+- `clearPhoneSignerCache(walletId, signerId?)` - Clear phone signer cache
+- `getPhoneSignerByPhone(walletId, phone)` - Find phone signer by phone number
+
+**Passkey (WebAuthn) Helpers:**
+- `isWebAuthnSupported()` - Check if WebAuthn is supported
+- `isPlatformAuthenticatorAvailable()` - Check if platform authenticator is available
+- `registerPasskey(walletId, options?)` - Register a new passkey
+- `authenticateWithPasskey(walletId, options?)` - Authenticate with existing passkey
+- `formatRegistrationResponse(response)` - Format passkey registration response
+- `formatAuthenticationResponse(response)` - Format passkey authentication response
+- `formatAuthenticationForVerification(response)` - Format authentication for verification
+- `findExistingPasskeySigner(walletId, credentialId?)` - Find existing passkey signer
+- `registerPasskeyComplete(walletId, registrationData, verificationData)` - Complete passkey registration
+- `signWithPasskeySigner(walletId, signerId, message, options)` - Sign with passkey signer
 
 **Device Key Validation & Resolution:**
-- `getSignerDeviceKeys()` - Get all device keys for a signer from API
-- `validateDeviceKey()` - Validate device key matches API
-- `resolveDeviceKey()` - Automatically find matching device key
-- `getBestDeviceIdentity()` - Get most recently used device identity
+- `getSignerDeviceKeys(walletId, signerId)` - Get all device keys for a signer from API
+- `validateDeviceKey(storage, keyId, expectedPublicKey)` - Validate device key matches API
+- `resolveDeviceKey(storage, walletId, signerId)` - Automatically find matching device key
+- `findAndValidateDeviceKey(storage, walletId, signerId, devicePublicKey)` - Find and validate device key
+- `getBestDeviceIdentity(walletId, signerId)` - Get most recently used device identity
 
 **Device Identity Management:**
-- `addDeviceIdentityToSigner()` - Add new device to existing signer
-- `replaceDeviceIdentity()` - Replace existing device identity
-- `addNewDeviceToSigner()` - Convenience function for adding new device
-- `canAddDeviceToSigner()` - Check if device can be added
+- `addDeviceIdentityToSigner(walletId, signerId, options)` - Add new device to existing signer
+- `replaceDeviceIdentity(walletId, signerId, options)` - Replace existing device identity
+- `addNewDeviceToSigner(walletId, signerId, options)` - Convenience function for adding new device
+- `canAddDeviceToSigner(walletId, signerId)` - Check if device can be added to signer
+
+**Signer Lifecycle:**
+- `createSigner(walletId, signerType, config)` - Create a new signer
+- `revokeSigner(walletId, signerId)` - Revoke a signer
+- `getSigners(walletId)` - Get all signers for a wallet
+
+**Multi-Device Management:**
+- `addDevice(walletId, signerId, devicePublicKey)` - Add device to signer
+- `replaceDevice(walletId, signerId, oldDeviceId, newDevicePublicKey)` - Replace device
+- `getDevices(walletId, signerId)` - Get all devices for a signer
+- `updateDevice(walletId, signerId, deviceId, data)` - Update device information
+
+**Core Signer Helpers:**
+- `deriveSignerKeypair(walletId, signerId, options)` - Derive signer keypair from encrypted secret
+- `signWithSigner(walletId, signerId, message, options)` - Sign message with signer
+- `parseSignerResponse(response)` - Parse signer API response to SignerInfo
+- `clearSignerCache(walletId?, signerId?)` - Clear signer keypair cache
+- `getCacheStats()` - Get cache statistics
+
+**Validation:**
+- `isValidEmail(email)` - Validate email format
+- `isValidPhone(phone)` - Validate phone number format
+- `isBrowserCompatible()` - Check if browser is compatible
+
+**External Wallet Adapter:**
+- `detectWallets()` - Detect available Solana wallets
+- `getWallet(name)` - Get wallet by name
+- `connectWallet(wallet)` - Connect to external wallet
+- `signTransaction(wallet, transaction)` - Sign transaction with external wallet
+- `signMessage(wallet, message)` - Sign message with external wallet
+
+**Wallet Transaction Helpers:**
+- `signTransactionWithEmailSigner(walletId, signerId, transaction, options)` - Sign transaction with email signer
+- `signTransactionWithPhoneSigner(walletId, signerId, transaction, options)` - Sign transaction with phone signer
+- `signTransactionWithPasskeySigner(walletId, signerId, transaction, options)` - Sign transaction with passkey signer
+- `signTransactionWithExternalWallet(wallet, transaction)` - Sign transaction with external wallet
+- `prepareSignAndSubmitTransaction(walletId, transaction, signerConfig)` - Prepare, sign, and submit transaction
+- `sendSOLWithSigner(walletId, recipientAddress, amountLamports, signerConfig)` - Send SOL using signer
+- `sendSPLWithSigner(walletId, recipientAddress, mintAddress, amount, signerConfig)` - Send SPL token using signer
 
 **Storage Adapters:**
-- `createLocalStorageAdapter()` - Browser localStorage adapter
-- `createFileSystemAdapter()` - Node.js filesystem adapter
-- `createMemoryAdapter()` - In-memory adapter (for testing)
-- `getDefaultStorageAdapter()` - Get platform-appropriate adapter
+- `createMemoryAdapter()` - Create in-memory storage adapter (for testing)
+- `createLocalStorageAdapter()` - Create browser localStorage adapter
+- `createFileSystemAdapter(basePath)` - Create Node.js filesystem adapter
+- `getDefaultStorageAdapter()` - Get platform-appropriate storage adapter
+
+**Key Format Utilities:**
+- `normalizeSPKI(spkiKey)` - Normalize SPKI key format
+- `base64ToPEM(base64Key, keyType)` - Convert base64 to PEM format
+- `pemToBase64(pemKey)` - Convert PEM to base64
+- `base64ToArrayBuffer(base64)` - Convert base64 to ArrayBuffer
+- `arrayBufferToBase64(buffer)` - Convert ArrayBuffer to base64
+- `importSPKIPublicKey(spkiBase64)` - Import SPKI public key
+- `exportToSPKI(key)` - Export key to SPKI format
+- `isValidBase64(str)` - Validate base64 string
 
 For detailed documentation on device key management, see [DEVICE_KEY_MANAGEMENT.md](./DEVICE_KEY_MANAGEMENT.md).
 
 ## Configuration
 
-### `configure(config)`
+### `configure(config: SDKConfig): void`
+
+Initialize the SDK with configuration options. This should be called once at the start of your application.
+
+**Parameters:**
+- `config` (`SDKConfig`): Configuration object
+  - `apiKey?` (`string`): API key for authentication (recommended for server-side)
+  - `jwt?` (`string`): JWT token for authentication (obtained from login)
+  - `baseURL?` (`string`): Custom API base URL (defaults to `https://api.cilantro.gg`)
+
+**Returns:** `void`
+
+**Example:**
+```typescript
+import { configure } from 'cilantro-sdk';
+
+// Configure with API key (server-side)
+configure({ 
+  apiKey: 'your-api-key',
+  baseURL: 'https://api.cilantro.gg'
+});
+
+// Configure with JWT (after login)
+configure({ 
+  jwt: 'your-jwt-token'
+});
+
+// Configure with both
+configure({ 
+  apiKey: 'your-api-key',
+  jwt: 'your-jwt-token'
+});
+```
+
+### `setAuth(auth: { jwt?: string; apiKey?: string }): void`
+
+Update authentication credentials after initialization. Useful when credentials change (e.g., after login or token refresh).
+
+**Parameters:**
+- `auth` (`object`): Authentication credentials
+  - `jwt?` (`string`): JWT token to set
+  - `apiKey?` (`string`): API key to set
+
+**Returns:** `void`
+
+**Example:**
+```typescript
+import { setAuth } from 'cilantro-sdk';
+import { login } from 'cilantro-sdk/auth';
+
+// Login and update auth
+const result = await login({
+  usernameOrEmail: 'user@example.com',
+  password: 'password123'
+});
+
+setAuth({ jwt: result.data.jwt });
+```
+
+### `clearAuth(): void`
+
+Clear all authentication credentials. Useful for logout or resetting authentication state.
+
+**Parameters:** None
+
+**Returns:** `void`
+
+**Example:**
+```typescript
+import { clearAuth } from 'cilantro-sdk';
+
+// Clear all authentication
+clearAuth();
+```
+
+### Authentication Types
+
+The SDK supports two types of authentication:
+
+1. **API Key Authentication**: For server-side applications and platform-level access
+   - Use when you have a platform API key
+   - Best for server-side operations
+   - Set via `configure({ apiKey: '...' })` or `setAuth({ apiKey: '...' })`
+
+2. **JWT Token Authentication**: For user-specific operations after login
+   - Use after user/platform login
+   - Best for user-scoped operations
+   - Set via `configure({ jwt: '...' })` or `setAuth({ jwt: '...' })`
+
+You can use either or both simultaneously. The SDK will automatically include the appropriate headers in all requests.
+
+## Documentation
+
+### Getting Started Guides
+
+- **[Complete Wallet & Transaction Flow Guide](./WALLET_TRANSACTION_FLOW.md)** - Comprehensive step-by-step guide covering:
+  - Wallet creation (platform-controlled vs user-controlled)
+  - Understanding and creating signers (email, phone, passkey, external, API key)
+  - Device key management and ECDH encryption
+  - Complete transaction flows (server-side and client-side signing)
+  - Real-world examples and best practices
+
+- **[Device Key Management Guide](./DEVICE_KEY_MANAGEMENT.md)** - Deep dive into device key architecture
+
+### Quick Links
+
+- [Examples](./examples/) - Code examples
+- [API Documentation](https://api.cilantro.gg/docs) - Complete API reference
+
+## Module Structure
+
+The SDK is organized into modules for better code organization:
+
+- **Platform** (`cilantro-sdk/platform`) - Platform management and user operations
+- **User** (`cilantro-sdk/user`) - User account operations
+- **Wallet** (`cilantro-sdk/wallet`) - Wallet and blockchain operations
+- **Auth** (`cilantro-sdk/auth`) - Universal authentication
+- **Subscriptions** (`cilantro-sdk/subscriptions`) - Subscription management operations
+- **Plans** (`cilantro-sdk/plans`) - Subscription plan management operations
+- **Transactions** (`cilantro-sdk/transactions`) - Transaction history and status queries
+- **Delegated Keys** (`cilantro-sdk/delegated-keys`) - Temporary key management for session-based signing
+- **Webhooks** (`cilantro-sdk/webhooks`) - Webhook endpoint management for event notifications
+- **Utils** (`cilantro-sdk/utils`) - Utility functions
+- **Helpers** (`cilantro-sdk/helpers`) - Device key management and signer helpers
+
+## Complete API Reference
+
+### SDK Configuration (`cilantro-sdk`)
+
+#### `configure(config: SDKConfig): void`
 
 Initialize the SDK with configuration options.
 
+**Parameters:**
+- `config` (`SDKConfig`): Configuration object
+  - `apiKey?` (`string`): API key for server-side authentication
+  - `jwt?` (`string`): JWT token for user authentication
+  - `baseURL?` (`string`): Custom API base URL (default: `https://api.cilantro.gg`)
+
+**Returns:** `void`
+
+**Example:**
+```typescript
+import { configure } from 'cilantro-sdk';
+
+configure({ 
+  apiKey: 'your-api-key',
+  baseURL: 'https://api.cilantro.gg'
+});
+```
+
+#### `setAuth(auth: { jwt?: string; apiKey?: string }): void`
+
+Update authentication credentials after initialization.
+
+**Parameters:**
+- `auth` (`object`): Authentication credentials
+  - `jwt?` (`string`): JWT token
+  - `apiKey?` (`string`): API key
+
+**Returns:** `void`
+
+**Example:**
+```typescript
+import { setAuth } from 'cilantro-sdk';
+
+setAuth({ jwt: 'your-jwt-token' });
+```
+
+#### `clearAuth(): void`
+
+Clear all authentication credentials.
+
+**Parameters:** None
+
+**Returns:** `void`
+
+**Example:**
+```typescript
+import { clearAuth } from 'cilantro-sdk';
+
+clearAuth();
+```
+
+#### `generateDevicePublicKey(): Promise<string>`
+
+Generate a device public key for ECDH (P-256) encryption. Works in both browser and Node.js environments.
+
+**Parameters:** None
+
+**Returns:** `Promise<string>` - Base64-encoded P-256 ECDH public key (65 bytes, uncompressed format)
+
+**Example:**
+```typescript
+import { generateDevicePublicKey } from 'cilantro-sdk';
+
+const devicePublicKey = await generateDevicePublicKey();
+// Use with createEmailSigner or createPhoneSigner
+```
+
+#### `updateDeviceIdentity(walletId: string, signerId: string, data: UpdateDeviceIdentityDto): Promise<WalletControllerUpdateDeviceIdentityResult>`
+
+Update device identity for a signer. Used to add or replace device keys associated with email/phone signers.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `signerId` (`string`): Signer ID
+- `data` (`UpdateDeviceIdentityDto`): Device identity data
+  - `devicePublicKey` (`string`): Base64-encoded device public key
+  - `deviceId?` (`string`): Optional device ID (for replacing existing device)
+  - `replace?` (`boolean`): Whether to replace existing device
+
+**Returns:** `Promise<WalletControllerUpdateDeviceIdentityResult>` - Updated device identity information
+
+**Example:**
+```typescript
+import { updateDeviceIdentity, generateDevicePublicKey } from 'cilantro-sdk';
+
+const devicePublicKey = await generateDevicePublicKey();
+await updateDeviceIdentity('wallet-id', 'signer-id', {
+  devicePublicKey,
+  replace: false
+});
+```
+
+### Platform Module (`cilantro-sdk/platform`)
+
+#### Platform Management
+
+##### `create(data: CreatePlatformDto): Promise<PlatformControllerCreateResult>`
+
+Create a new platform account.
+
+**Parameters:**
+- `data` (`CreatePlatformDto`): Platform creation data
+  - `platformName` (`string`): Platform name
+  - `email` (`string`): Platform email
+  - `password` (`string`): Platform password
+  - `billingCycle?` (`'monthly' | 'yearly'`): Billing cycle preference
+
+**Returns:** `Promise<PlatformControllerCreateResult>` - Created platform information
+
+**Example:**
+```typescript
+import { platform } from 'cilantro-sdk';
+
+const newPlatform = await platform.create({
+  platformName: 'My Platform',
+  email: 'platform@example.com',
+  password: 'SecurePass123!',
+  billingCycle: 'monthly'
+});
+```
+
+##### `findAll(params?: PlatformControllerFindAllParams): Promise<PlatformControllerFindAllResult>`
+
+Get all platforms with optional filters.
+
+**Parameters:**
+- `params?` (`PlatformControllerFindAllParams`): Optional query parameters
+  - `page?` (`number`): Page number for pagination
+  - `limit?` (`number`): Items per page
+  - `search?` (`string`): Search term
+
+**Returns:** `Promise<PlatformControllerFindAllResult>` - Paginated list of platforms
+
+**Example:**
+```typescript
+const platforms = await platform.findAll({
+  page: 1,
+  limit: 20,
+  search: 'example'
+});
+```
+
+##### `findOne(platformId: string): Promise<PlatformControllerFindOneResult>`
+
+Get platform by ID.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+
+**Returns:** `Promise<PlatformControllerFindOneResult>` - Platform details
+
+**Example:**
+```typescript
+const platformData = await platform.findOne('platform-id');
+```
+
+##### `update(platformId: string, data: UpdatePlatformDto): Promise<PlatformControllerUpdateResult>`
+
+Update platform information.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `data` (`UpdatePlatformDto`): Update data
+  - `platformName?` (`string`): New platform name
+  - `email?` (`string`): New email
+  - `isActive?` (`boolean`): Active status
+
+**Returns:** `Promise<PlatformControllerUpdateResult>` - Updated platform information
+
+**Example:**
+```typescript
+await platform.update('platform-id', {
+  platformName: 'Updated Name'
+});
+```
+
+##### `remove(platformId: string): Promise<PlatformControllerRemoveResult>`
+
+Remove (delete) a platform.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+
+**Returns:** `Promise<PlatformControllerRemoveResult>` - Removal confirmation
+
+**Example:**
+```typescript
+await platform.remove('platform-id');
+```
+
+##### `getOwnProfile(): Promise<PlatformControllerGetOwnProfileResult>`
+
+Get current platform's profile (authenticated platform).
+
+**Parameters:** None
+
+**Returns:** `Promise<PlatformControllerGetOwnProfileResult>` - Current platform profile
+
+**Example:**
+```typescript
+const profile = await platform.getOwnProfile();
+```
+
+##### `updateOwnProfile(data: UpdatePlatformDto): Promise<PlatformControllerUpdateOwnProfileResult>`
+
+Update current platform's profile.
+
+**Parameters:**
+- `data` (`UpdatePlatformDto`): Update data
+
+**Returns:** `Promise<PlatformControllerUpdateOwnProfileResult>` - Updated profile
+
+**Example:**
+```typescript
+await platform.updateOwnProfile({
+  platformName: 'New Name'
+});
+```
+
+##### `changePassword(data: ChangePasswordDto): Promise<PlatformControllerChangePasswordResult>`
+
+Change platform password.
+
+**Parameters:**
+- `data` (`ChangePasswordDto`): Password change data
+  - `currentPassword` (`string`): Current password
+  - `newPassword` (`string`): New password
+
+**Returns:** `Promise<PlatformControllerChangePasswordResult>` - Password change confirmation
+
+**Example:**
+```typescript
+await platform.changePassword({
+  currentPassword: 'old-password',
+  newPassword: 'new-secure-password'
+});
+```
+
+#### User Management
+
+##### `getUsers(platformId: string, params?: PlatformControllerGetUsersForPlatformParams): Promise<PlatformControllerGetUsersForPlatformResult>`
+
+Get all users for a platform.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `params?` (`object`): Optional query parameters
+  - `page?` (`number`): Page number
+  - `limit?` (`number`): Items per page
+  - `search?` (`string`): Search term
+  - `isActive?` (`boolean`): Filter by active status
+
+**Returns:** `Promise<PlatformControllerGetUsersForPlatformResult>` - Paginated list of users
+
+**Example:**
+```typescript
+const users = await platform.getUsers('platform-id', {
+  page: 1,
+  limit: 20,
+  isActive: true
+});
+```
+
+##### `createUser(platformId: string, data: CreateUserDto): Promise<PlatformControllerCreateUserForPlatformResult>`
+
+Create a new user for the platform.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `data` (`CreateUserDto`): User creation data
+  - `username` (`string`): Username
+  - `email` (`string`): Email address
+  - `password` (`string`): Password
+
+**Returns:** `Promise<PlatformControllerCreateUserForPlatformResult>` - Created user information
+
+**Example:**
+```typescript
+const user = await platform.createUser('platform-id', {
+  username: 'johndoe',
+  email: 'john@example.com',
+  password: 'SecurePass123!'
+});
+```
+
+##### `updateUser(platformId: string, userId: string, data: UpdateUserDto): Promise<PlatformControllerUpdateUserForPlatformResult>`
+
+Update user information.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `userId` (`string`): User ID
+- `data` (`UpdateUserDto`): Update data
+  - `username?` (`string`): New username
+  - `email?` (`string`): New email
+  - `isActive?` (`boolean`): Active status
+
+**Returns:** `Promise<PlatformControllerUpdateUserForPlatformResult>` - Updated user information
+
+**Example:**
+```typescript
+await platform.updateUser('platform-id', 'user-id', {
+  username: 'newusername'
+});
+```
+
+##### `removeUser(platformId: string, userId: string): Promise<PlatformControllerRemoveUserForPlatformResult>`
+
+Remove user from platform.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `userId` (`string`): User ID
+
+**Returns:** `Promise<PlatformControllerRemoveUserForPlatformResult>` - Removal confirmation
+
+**Example:**
+```typescript
+await platform.removeUser('platform-id', 'user-id');
+```
+
+##### `toggleUserActive(platformId: string, userId: string): Promise<PlatformControllerToggleUserActiveForPlatformResult>`
+
+Toggle user active status.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `userId` (`string`): User ID
+
+**Returns:** `Promise<PlatformControllerToggleUserActiveForPlatformResult>` - Updated user status
+
+**Example:**
+```typescript
+await platform.toggleUserActive('platform-id', 'user-id');
+```
+
+#### Wallet Management
+
+##### `getWallets(platformId: string, params?: PlatformControllerGetWalletsForPlatformParams): Promise<PlatformControllerGetWalletsForPlatformResult>`
+
+Get all wallets for a platform (read-only).
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `params?` (`object`): Optional query parameters
+  - `page?` (`number`): Page number
+  - `limit?` (`number`): Items per page
+
+**Returns:** `Promise<PlatformControllerGetWalletsForPlatformResult>` - Paginated list of wallets
+
+**Example:**
+```typescript
+const wallets = await platform.getWallets('platform-id', {
+  page: 1,
+  limit: 20
+});
+```
+
+#### Subscription Management
+
+##### `getSubscriptions(platformId: string, params?: PlatformControllerGetSubscriptionsForPlatformParams): Promise<PlatformControllerGetSubscriptionsForPlatformResult>`
+
+Get all subscriptions for a platform.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `params?` (`object`): Optional query parameters
+  - `status?` (`string`): Filter by status
+  - `page?` (`number`): Page number
+  - `limit?` (`number`): Items per page
+
+**Returns:** `Promise<PlatformControllerGetSubscriptionsForPlatformResult>` - Paginated list of subscriptions
+
+**Example:**
+```typescript
+const subscriptions = await platform.getSubscriptions('platform-id', {
+  status: 'active'
+});
+```
+
+##### `getSubscriptionById(platformId: string, subscriptionId: string): Promise<PlatformControllerGetSubscriptionByIdResult>`
+
+Get subscription by ID.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `subscriptionId` (`string`): Subscription ID
+
+**Returns:** `Promise<PlatformControllerGetSubscriptionByIdResult>` - Subscription details
+
+**Example:**
+```typescript
+const subscription = await platform.getSubscriptionById('platform-id', 'subscription-id');
+```
+
+##### `renewSubscription(platformId: string, subscriptionId: string, data: RenewSubscriptionDto): Promise<PlatformControllerRenewSubscriptionResult>`
+
+Renew a subscription.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `subscriptionId` (`string`): Subscription ID
+- `data` (`RenewSubscriptionDto`): Renewal data
+  - `extendByDays?` (`number`): Days to extend
+  - `extendByMonths?` (`number`): Months to extend
+
+**Returns:** `Promise<PlatformControllerRenewSubscriptionResult>` - Renewed subscription
+
+**Example:**
+```typescript
+await platform.renewSubscription('platform-id', 'subscription-id', {
+  extendByMonths: 1
+});
+```
+
+##### `upgradeSubscription(platformId: string, subscriptionId: string, data: UpgradeSubscriptionDto): Promise<PlatformControllerUpgradeSubscriptionResult>`
+
+Upgrade a subscription to a higher tier.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `subscriptionId` (`string`): Subscription ID
+- `data` (`UpgradeSubscriptionDto`): Upgrade data
+  - `newPlanId` (`string`): New plan ID
+  - `effectiveDate?` (`string`): Effective date (ISO 8601)
+
+**Returns:** `Promise<PlatformControllerUpgradeSubscriptionResult>` - Upgraded subscription
+
+**Example:**
+```typescript
+await platform.upgradeSubscription('platform-id', 'subscription-id', {
+  newPlanId: 'premium-plan-id',
+  effectiveDate: '2024-01-01T00:00:00Z'
+});
+```
+
+##### `downgradeSubscription(platformId: string, subscriptionId: string, data: DowngradeSubscriptionDto): Promise<PlatformControllerDowngradeSubscriptionResult>`
+
+Downgrade a subscription to a lower tier.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `subscriptionId` (`string`): Subscription ID
+- `data` (`DowngradeSubscriptionDto`): Downgrade data
+  - `newPlanId` (`string`): New plan ID
+
+**Returns:** `Promise<PlatformControllerDowngradeSubscriptionResult>` - Downgraded subscription
+
+**Example:**
+```typescript
+await platform.downgradeSubscription('platform-id', 'subscription-id', {
+  newPlanId: 'basic-plan-id'
+});
+```
+
+##### `cancelSubscription(platformId: string, subscriptionId: string, data: CancelSubscriptionDto): Promise<PlatformControllerCancelSubscriptionResult>`
+
+Cancel a subscription.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `subscriptionId` (`string`): Subscription ID
+- `data` (`CancelSubscriptionDto`): Cancellation data
+  - `cancelAtPeriodEnd?` (`boolean`): Cancel at period end
+
+**Returns:** `Promise<PlatformControllerCancelSubscriptionResult>` - Cancellation confirmation
+
+**Example:**
+```typescript
+await platform.cancelSubscription('platform-id', 'subscription-id', {
+  cancelAtPeriodEnd: true
+});
+```
+
+##### `getSubscriptionHistory(platformId: string, subscriptionId: string): Promise<PlatformControllerGetSubscriptionHistoryResult>`
+
+Get subscription history/audit trail.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `subscriptionId` (`string`): Subscription ID
+
+**Returns:** `Promise<PlatformControllerGetSubscriptionHistoryResult>` - Subscription history
+
+**Example:**
+```typescript
+const history = await platform.getSubscriptionHistory('platform-id', 'subscription-id');
+```
+
+#### Payment Management
+
+##### `confirmPayment(platformId: string, data: ConfirmPaymentDto): Promise<PlatformControllerConfirmPaymentResult>`
+
+Confirm a payment transaction.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `data` (`ConfirmPaymentDto`): Payment confirmation data
+  - `paymentId` (`string`): Payment ID
+  - `transactionId?` (`string`): Transaction ID
+
+**Returns:** `Promise<PlatformControllerConfirmPaymentResult>` - Payment confirmation
+
+**Example:**
+```typescript
+await platform.confirmPayment('platform-id', {
+  paymentId: 'payment-id',
+  transactionId: 'tx-id'
+});
+```
+
+##### `linkPayment(platformId: string, data: LinkPaymentDto): Promise<PlatformControllerLinkPaymentResult>`
+
+Link a payment method to the platform.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `data` (`LinkPaymentDto`): Payment method data
+  - `paymentMethodId` (`string`): Payment method ID
+  - `isDefault?` (`boolean`): Set as default
+
+**Returns:** `Promise<PlatformControllerLinkPaymentResult>` - Linked payment method
+
+**Example:**
+```typescript
+await platform.linkPayment('platform-id', {
+  paymentMethodId: 'pm-id',
+  isDefault: true
+});
+```
+
+##### `getPaymentHistory(platformId: string, params?: PlatformControllerGetPaymentHistoryParams): Promise<PlatformControllerGetPaymentHistoryResult>`
+
+Get payment history for a platform.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+- `params?` (`object`): Optional query parameters
+  - `page?` (`number`): Page number
+  - `limit?` (`number`): Items per page
+  - `startDate?` (`string`): Start date filter
+  - `endDate?` (`string`): End date filter
+
+**Returns:** `Promise<PlatformControllerGetPaymentHistoryResult>` - Paginated payment history
+
+**Example:**
+```typescript
+const payments = await platform.getPaymentHistory('platform-id', {
+  page: 1,
+  limit: 20
+});
+```
+
+### User Module (`cilantro-sdk/user`)
+
+#### `create(data: CreateUserDto): Promise<UserControllerCreateResult>`
+
+Create a new user account.
+
+**Parameters:**
+- `data` (`CreateUserDto`): User creation data
+  - `username` (`string`): Username
+  - `email` (`string`): Email address
+  - `password` (`string`): Password
+
+**Returns:** `Promise<UserControllerCreateResult>` - Created user information
+
+**Example:**
+```typescript
+import { user } from 'cilantro-sdk';
+
+const newUser = await user.create({
+  username: 'johndoe',
+  email: 'john@example.com',
+  password: 'SecurePass123!'
+});
+```
+
+#### `findOne(userId: string): Promise<UserControllerFindOneResult>`
+
+Get user by ID.
+
+**Parameters:**
+- `userId` (`string`): User ID
+
+**Returns:** `Promise<UserControllerFindOneResult>` - User details
+
+**Example:**
+```typescript
+const userData = await user.findOne('user-id');
+```
+
+#### `update(userId: string, data: UpdateUserDto): Promise<UserControllerUpdateResult>`
+
+Update user information.
+
+**Parameters:**
+- `userId` (`string`): User ID
+- `data` (`UpdateUserDto`): Update data
+  - `username?` (`string`): New username
+  - `email?` (`string`): New email
+  - `isActive?` (`boolean`): Active status
+
+**Returns:** `Promise<UserControllerUpdateResult>` - Updated user information
+
+**Example:**
+```typescript
+await user.update('user-id', {
+  username: 'newusername',
+  email: 'newemail@example.com'
+});
+```
+
+#### `changePassword(userId: string, data: ChangePasswordDto): Promise<UserControllerChangePasswordResult>`
+
+Change user password.
+
+**Parameters:**
+- `userId` (`string`): User ID
+- `data` (`ChangePasswordDto`): Password change data
+  - `currentPassword` (`string`): Current password
+  - `newPassword` (`string`): New password
+
+**Returns:** `Promise<UserControllerChangePasswordResult>` - Password change confirmation
+
+**Example:**
+```typescript
+await user.changePassword('user-id', {
+  currentPassword: 'old-password',
+  newPassword: 'new-secure-password'
+});
+```
+
+### Wallet Module (`cilantro-sdk/wallet`)
+
+#### Basic Operations
+
+##### `create(data: CreateWalletDto): Promise<WalletControllerCreateResult>`
+
+Create a new wallet.
+
+**Parameters:**
+- `data` (`CreateWalletDto`): Wallet creation data
+  - `name?` (`string`): Wallet name
+  - `userId?` (`string`): User ID (for user-controlled wallets)
+  - `walletMode?` (`'custodial' | 'nonCustodial'`): Wallet mode
+  - `walletType?` (`'standard' | 'multisig'`): Wallet type
+
+**Returns:** `Promise<WalletControllerCreateResult>` - Created wallet information
+  - `data.id` (`string`): Wallet ID
+  - `data.address` (`string`): Solana wallet address
+  - `data.publicKey` (`string`): Wallet public key
+
+**Example:**
+```typescript
+import { wallet } from 'cilantro-sdk';
+
+const newWallet = await wallet.create({
+  name: 'My Wallet',
+  userId: 'user-id',
+  walletMode: 'nonCustodial'
+});
+
+console.log('Wallet Address:', newWallet.data.address);
+```
+
+##### `findAll(params?: WalletControllerFindAllParams): Promise<WalletControllerFindAllResult>`
+
+Get all wallets with optional filters.
+
+**Parameters:**
+- `params?` (`WalletControllerFindAllParams`): Optional query parameters
+  - `page?` (`number`): Page number
+  - `limit?` (`number`): Items per page
+  - `userId?` (`string`): Filter by user ID
+  - `walletMode?` (`string`): Filter by wallet mode
+
+**Returns:** `Promise<WalletControllerFindAllResult>` - Paginated list of wallets
+
+**Example:**
+```typescript
+const wallets = await wallet.findAll({
+  page: 1,
+  limit: 20,
+  walletMode: 'nonCustodial'
+});
+```
+
+##### `findOne(walletId: string): Promise<WalletControllerFindOneResult>`
+
+Get wallet by ID.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+
+**Returns:** `Promise<WalletControllerFindOneResult>` - Wallet details
+
+**Example:**
+```typescript
+const walletData = await wallet.findOne('wallet-id');
+```
+
+##### `update(walletId: string, data: UpdateWalletDto): Promise<WalletControllerUpdateResult>`
+
+Update wallet information.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`UpdateWalletDto`): Update data
+  - `name?` (`string`): New wallet name
+  - `isActive?` (`boolean`): Active status
+
+**Returns:** `Promise<WalletControllerUpdateResult>` - Updated wallet information
+
+**Example:**
+```typescript
+await wallet.update('wallet-id', {
+  name: 'Updated Wallet Name'
+});
+```
+
+##### `remove(walletId: string): Promise<WalletControllerRemoveResult>`
+
+Remove (delete) a wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+
+**Returns:** `Promise<WalletControllerRemoveResult>` - Removal confirmation
+
+**Example:**
+```typescript
+await wallet.remove('wallet-id');
+```
+
+##### `findByAddress(address: string): Promise<WalletControllerFindByAddressResult>`
+
+Find wallet by Solana address.
+
+**Parameters:**
+- `address` (`string`): Solana wallet address
+
+**Returns:** `Promise<WalletControllerFindByAddressResult>` - Wallet details
+
+**Example:**
+```typescript
+const walletData = await wallet.findByAddress('DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK');
+```
+
+##### `getTotalBalance(walletId: string): Promise<WalletControllerGetTotalBalanceResult>`
+
+Get total balance across all wallets for a user.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID (used to identify user)
+
+**Returns:** `Promise<WalletControllerGetTotalBalanceResult>` - Total balance information
+  - `data.totalSOL` (`number`): Total SOL balance in lamports
+  - `data.totalTokens` (`number`): Total token balance
+
+**Example:**
+```typescript
+const balance = await wallet.getTotalBalance('wallet-id');
+console.log('Total SOL:', balance.data.totalSOL / 1e9); // Convert lamports to SOL
+```
+
+#### Status Management
+
+##### `activate(walletId: string): Promise<WalletControllerActivateWalletResult>`
+
+Activate a wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+
+**Returns:** `Promise<WalletControllerActivateWalletResult>` - Activation confirmation
+
+**Example:**
+```typescript
+await wallet.activate('wallet-id');
+```
+
+##### `deactivate(walletId: string): Promise<WalletControllerDeactivateWalletResult>`
+
+Deactivate a wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+
+**Returns:** `Promise<WalletControllerDeactivateWalletResult>` - Deactivation confirmation
+
+**Example:**
+```typescript
+await wallet.deactivate('wallet-id');
+```
+
+#### Transactions
+
+##### `sendSOL(walletId: string, data: SendSolDto): Promise<WalletControllerSendSOLResult>`
+
+Send SOL (custodial mode - server signs the transaction).
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`SendSolDto`): Transaction data
+  - `recipientAddress` (`string`): Recipient Solana address
+  - `amountLamports` (`number`): Amount in lamports (1 SOL = 1,000,000,000 lamports)
+
+**Returns:** `Promise<WalletControllerSendSOLResult>` - Transaction result
+  - `data.signature` (`string`): Transaction signature
+  - `data.status` (`string`): Transaction status
+
+**Example:**
+```typescript
+const result = await wallet.sendSOL('wallet-id', {
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  amountLamports: 1000000000 // 1 SOL
+});
+
+console.log('Transaction Signature:', result.data.signature);
+```
+
+##### `sendSOLNonCustodial(walletId: string, data: SendSolNonCustodialDto): Promise<WalletControllerSendSOLNonCustodialResult>`
+
+Send SOL (non-custodial mode - requires client-side signing).
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`SendSolNonCustodialDto`): Transaction data
+  - `recipientAddress` (`string`): Recipient address
+  - `amountLamports` (`number`): Amount in lamports
+  - `signedTransaction` (`string`): Base64-encoded signed transaction
+
+**Returns:** `Promise<WalletControllerSendSOLNonCustodialResult>` - Transaction result
+
+**Example:**
+```typescript
+// First prepare and sign transaction client-side, then submit
+const result = await wallet.sendSOLNonCustodial('wallet-id', {
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  amountLamports: 1000000000,
+  signedTransaction: signedTxBase64
+});
+```
+
+##### `sendSPL(walletId: string, data: SendSplDto): Promise<WalletControllerSendSPLResult>`
+
+Send SPL token (custodial mode).
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`SendSplDto`): Transaction data
+  - `recipientAddress` (`string`): Recipient address
+  - `mintAddress` (`string`): Token mint address
+  - `amount` (`number`): Token amount (in token's decimal places)
+
+**Returns:** `Promise<WalletControllerSendSPLResult>` - Transaction result
+
+**Example:**
+```typescript
+const result = await wallet.sendSPL('wallet-id', {
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  mintAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
+  amount: 1000000 // 1 USDC (6 decimals)
+});
+```
+
+##### `sendSPLNonCustodial(walletId: string, data: SendSplNonCustodialDto): Promise<WalletControllerSendSPLNonCustodialResult>`
+
+Send SPL token (non-custodial mode).
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`SendSplNonCustodialDto`): Transaction data
+  - `recipientAddress` (`string`): Recipient address
+  - `mintAddress` (`string`): Token mint address
+  - `amount` (`number`): Token amount
+  - `signedTransaction` (`string`): Base64-encoded signed transaction
+
+**Returns:** `Promise<WalletControllerSendSPLNonCustodialResult>` - Transaction result
+
+**Example:**
+```typescript
+const result = await wallet.sendSPLNonCustodial('wallet-id', {
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  mintAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+  amount: 1000000,
+  signedTransaction: signedTxBase64
+});
+```
+
+##### `executeInstructionNonCustodial(walletId: string, data: ExecuteInstructionNonCustodialDto): Promise<WalletControllerExecuteInstructionNonCustodialResult>`
+
+Execute a custom Solana instruction (non-custodial mode).
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`ExecuteInstructionNonCustodialDto`): Instruction data
+  - `programId` (`string`): Program ID
+  - `accounts` (`array`): Account keys
+  - `data` (`string`): Instruction data
+  - `signedTransaction` (`string`): Base64-encoded signed transaction
+
+**Returns:** `Promise<WalletControllerExecuteInstructionNonCustodialResult>` - Transaction result
+
+**Example:**
+```typescript
+const result = await wallet.executeInstructionNonCustodial('wallet-id', {
+  programId: 'program-id',
+  accounts: [...],
+  data: 'instruction-data',
+  signedTransaction: signedTxBase64
+});
+```
+
+##### `sendTransaction(walletId: string, data: SendTransactionDto): Promise<WalletControllerSendTransactionResult>`
+
+Send a custom transaction.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`SendTransactionDto`): Transaction data
+  - `transaction` (`string`): Base64-encoded transaction
+  - `signers?` (`array`): Signer public keys
+
+**Returns:** `Promise<WalletControllerSendTransactionResult>` - Transaction result
+
+**Example:**
+```typescript
+const result = await wallet.sendTransaction('wallet-id', {
+  transaction: transactionBase64
+});
+```
+
+##### `simulateTransaction(walletId: string, data: SimulateTransactionDto): Promise<WalletControllerSimulateTransactionResult>`
+
+Simulate a transaction without executing it.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`SimulateTransactionDto`): Transaction data
+  - `transaction` (`string`): Base64-encoded transaction
+
+**Returns:** `Promise<WalletControllerSimulateTransactionResult>` - Simulation result
+  - `data.logs` (`array`): Transaction logs
+  - `data.err` (`object | null`): Error if simulation failed
+  - `data.unitsConsumed` (`number`): Compute units consumed
+
+**Example:**
+```typescript
+const simulation = await wallet.simulateTransaction('wallet-id', {
+  transaction: transactionBase64
+});
+
+if (simulation.data.err) {
+  console.error('Simulation failed:', simulation.data.err);
+} else {
+  console.log('Units consumed:', simulation.data.unitsConsumed);
+}
+```
+
+##### `prepareTransaction(walletId: string, data: PrepareTransactionDto): Promise<WalletControllerPrepareTransactionResult>`
+
+Prepare a transaction for signing.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`PrepareTransactionDto`): Transaction preparation data
+  - `type` (`'transfer' | 'tokenTransfer' | 'custom'`): Transaction type
+  - `recipientAddress?` (`string`): Recipient address (for transfers)
+  - `amount?` (`number`): Amount
+  - `mintAddress?` (`string`): Token mint address (for token transfers)
+  - `instructions?` (`array`): Custom instructions
+
+**Returns:** `Promise<WalletControllerPrepareTransactionResult>` - Prepared transaction
+  - `data.transaction` (`string`): Base64-encoded unsigned transaction
+  - `data.message` (`string`): Transaction message for signing
+
+**Example:**
+```typescript
+const prepared = await wallet.prepareTransaction('wallet-id', {
+  type: 'transfer',
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  amount: 1000000000
+});
+
+// Sign the transaction client-side, then submit
+const signedTx = await signTransaction(prepared.data.transaction);
+await wallet.submitTransaction('wallet-id', {
+  signedTransaction: signedTx
+});
+```
+
+##### `submitTransaction(walletId: string, data: SubmitTransactionDto): Promise<WalletControllerSubmitTransactionResult>`
+
+Submit a signed transaction.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`SubmitTransactionDto`): Transaction data
+  - `signedTransaction` (`string`): Base64-encoded signed transaction
+
+**Returns:** `Promise<WalletControllerSubmitTransactionResult>` - Transaction result
+  - `data.signature` (`string`): Transaction signature
+  - `data.status` (`string`): Transaction status
+
+**Example:**
+```typescript
+const result = await wallet.submitTransaction('wallet-id', {
+  signedTransaction: signedTxBase64
+});
+
+console.log('Transaction Signature:', result.data.signature);
+```
+
+##### `signMessage(walletId: string, data: SignMessageDto): Promise<WalletControllerSignMessageResult>`
+
+Sign a message with the wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`SignMessageDto`): Message data
+  - `message` (`string`): Message to sign (will be base64 encoded)
+  - `signerId?` (`string`): Specific signer ID to use
+
+**Returns:** `Promise<WalletControllerSignMessageResult>` - Signature result
+  - `data.signature` (`string`): Message signature
+  - `data.publicKey` (`string`): Signer public key
+
+**Example:**
+```typescript
+const result = await wallet.signMessage('wallet-id', {
+  message: 'Hello, World!',
+  signerId: 'signer-id'
+});
+
+console.log('Signature:', result.data.signature);
+```
+
+#### Batch Operations
+
+##### `batchCreate(data: BatchCreateWalletDto): Promise<WalletControllerBatchCreateWalletsResult>`
+
+Create multiple wallets in batch.
+
+**Parameters:**
+- `data` (`BatchCreateWalletDto`): Batch creation data
+  - `wallets` (`array`): Array of wallet creation data
+    - `name?` (`string`): Wallet name
+    - `userId?` (`string`): User ID
+
+**Returns:** `Promise<WalletControllerBatchCreateWalletsResult>` - Created wallets
+
+**Example:**
+```typescript
+const result = await wallet.batchCreate({
+  wallets: [
+    { name: 'Wallet 1', userId: 'user-id' },
+    { name: 'Wallet 2', userId: 'user-id' }
+  ]
+});
+```
+
+##### `batchSendSOL(walletId: string, data: BatchSendSolDto): Promise<WalletControllerBatchSendSOLResult>`
+
+Send SOL to multiple recipients in a single transaction.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`BatchSendSolDto`): Batch send data
+  - `recipients` (`array`): Array of recipients
+    - `address` (`string`): Recipient address
+    - `amountLamports` (`number`): Amount in lamports
+
+**Returns:** `Promise<WalletControllerBatchSendSOLResult>` - Transaction result
+
+**Example:**
+```typescript
+const result = await wallet.batchSendSOL('wallet-id', {
+  recipients: [
+    { address: 'address1', amountLamports: 1000000000 },
+    { address: 'address2', amountLamports: 2000000000 }
+  ]
+});
+```
+
+##### `batchSendSPL(walletId: string, data: BatchSendSplDto): Promise<WalletControllerBatchSendSPLResult>`
+
+Send SPL tokens to multiple recipients.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`BatchSendSplDto`): Batch send data
+  - `mintAddress` (`string`): Token mint address
+  - `recipients` (`array`): Array of recipients
+    - `address` (`string`): Recipient address
+    - `amount` (`number`): Token amount
+
+**Returns:** `Promise<WalletControllerBatchSendSPLResult>` - Transaction result
+
+**Example:**
+```typescript
+const result = await wallet.batchSendSPL('wallet-id', {
+  mintAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+  recipients: [
+    { address: 'address1', amount: 1000000 },
+    { address: 'address2', amount: 2000000 }
+  ]
+});
+```
+
+#### NFTs & Tokens
+
+##### `mintNFT(walletId: string, data: MintNftDto): Promise<WalletControllerMintNFTResult>`
+
+Mint an NFT with full metadata.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`MintNftDto`): NFT minting data
+  - `name` (`string`): NFT name
+  - `symbol?` (`string`): NFT symbol
+  - `uri?` (`string`): Metadata URI
+  - `metadata?` (`object`): Full metadata object
+  - `recipientAddress?` (`string`): Recipient address (defaults to wallet address)
+
+**Returns:** `Promise<WalletControllerMintNFTResult>` - Minted NFT information
+  - `data.mintAddress` (`string`): NFT mint address
+  - `data.tokenAddress` (`string`): Token account address
+
+**Example:**
+```typescript
+const result = await wallet.mintNFT('wallet-id', {
+  name: 'My NFT',
+  symbol: 'MNFT',
+  uri: 'https://example.com/metadata.json',
+  metadata: {
+    description: 'My awesome NFT',
+    image: 'https://example.com/image.png'
+  }
+});
+
+console.log('NFT Mint Address:', result.data.mintAddress);
+```
+
+##### `mintNFTSimple(walletId: string, data: MintNftSimpleDto): Promise<WalletControllerMintNFTSimpleResult>`
+
+Mint an NFT with simplified parameters.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`MintNftSimpleDto`): Simplified NFT data
+  - `name` (`string`): NFT name
+  - `uri?` (`string`): Metadata URI
+
+**Returns:** `Promise<WalletControllerMintNFTSimpleResult>` - Minted NFT information
+
+**Example:**
+```typescript
+const result = await wallet.mintNFTSimple('wallet-id', {
+  name: 'Simple NFT',
+  uri: 'https://example.com/metadata.json'
+});
+```
+
+##### `mintToken(walletId: string, data: MintTokenDto): Promise<WalletControllerMintTokenResult>`
+
+Mint an SPL token.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`MintTokenDto`): Token minting data
+  - `decimals` (`number`): Token decimals (0-9)
+  - `amount` (`number`): Initial supply
+  - `tokenStandard?` (`'fungible' | 'nonFungible'`): Token standard
+  - `name?` (`string`): Token name
+  - `symbol?` (`string`): Token symbol
+
+**Returns:** `Promise<WalletControllerMintTokenResult>` - Minted token information
+  - `data.mintAddress` (`string`): Token mint address
+
+**Example:**
+```typescript
+const result = await wallet.mintToken('wallet-id', {
+  decimals: 9,
+  amount: 1000000000,
+  name: 'My Token',
+  symbol: 'MTK'
+});
+
+console.log('Token Mint Address:', result.data.mintAddress);
+```
+
+#### Assets
+
+##### `getAssets(walletId: string, params?: WalletControllerGetWalletAssetsParams): Promise<WalletControllerGetWalletAssetsResult>`
+
+Get wallet assets (tokens, NFTs, SOL).
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `params?` (`WalletControllerGetWalletAssetsParams`): Optional query parameters
+  - `assetType?` (`'sol' | 'token' | 'nft'`): Filter by asset type
+  - `page?` (`number`): Page number
+  - `limit?` (`number`): Items per page
+
+**Returns:** `Promise<WalletControllerGetWalletAssetsResult>` - Paginated list of assets
+  - `data.assets` (`array`): Array of asset objects
+    - `type` (`string`): Asset type
+    - `balance` (`number`): Asset balance
+    - `mintAddress?` (`string`): Mint address (for tokens/NFTs)
+
+**Example:**
+```typescript
+const assets = await wallet.getAssets('wallet-id', {
+  assetType: 'token',
+  page: 1,
+  limit: 20
+});
+
+console.log('Assets:', assets.data.assets);
+```
+
+##### `syncAssets(walletId: string): Promise<WalletControllerSyncWalletAssetsResult>`
+
+Sync wallet assets from blockchain.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+
+**Returns:** `Promise<WalletControllerSyncWalletAssetsResult>` - Sync result
+
+**Example:**
+```typescript
+await wallet.syncAssets('wallet-id');
+```
+
+#### Custody
+
+##### `getCustodyInfo(walletId: string): Promise<WalletControllerGetWalletCustodyInfoResult>`
+
+Get wallet custody information.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+
+**Returns:** `Promise<WalletControllerGetWalletCustodyInfoResult>` - Custody information
+  - `data.walletMode` (`string`): Wallet mode (custodial/nonCustodial)
+  - `data.signers` (`array`): List of signers
+
+**Example:**
+```typescript
+const custodyInfo = await wallet.getCustodyInfo('wallet-id');
+console.log('Wallet Mode:', custodyInfo.data.walletMode);
+```
+
+#### Signer Management
+
+##### `createEmailSigner(walletId: string, data: CreateEmailSignerDto): Promise<WalletControllerCreateEmailSignerResult>`
+
+Create an email signer for the wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`CreateEmailSignerDto`): Email signer data
+  - `email` (`string`): Email address
+  - `devicePublicKey` (`string`): Base64-encoded device public key (P-256 ECDH)
+
+**Returns:** `Promise<WalletControllerCreateEmailSignerResult>` - Created signer information
+  - `data.signerId` (`string`): Signer ID
+  - `data.deviceId` (`string`): Device ID
+
+**Example:**
+```typescript
+import { generateDevicePublicKey } from 'cilantro-sdk';
+
+const devicePublicKey = await generateDevicePublicKey();
+const signer = await wallet.createEmailSigner('wallet-id', {
+  email: 'user@example.com',
+  devicePublicKey
+});
+
+console.log('Signer ID:', signer.data.signerId);
+```
+
+##### `createPhoneSigner(walletId: string, data: CreatePhoneSignerDto): Promise<WalletControllerCreatePhoneSignerResult>`
+
+Create a phone signer for the wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`CreatePhoneSignerDto`): Phone signer data
+  - `phone` (`string`): Phone number (E.164 format)
+  - `devicePublicKey` (`string`): Base64-encoded device public key
+
+**Returns:** `Promise<WalletControllerCreatePhoneSignerResult>` - Created signer information
+
+**Example:**
+```typescript
+const devicePublicKey = await generateDevicePublicKey();
+const signer = await wallet.createPhoneSigner('wallet-id', {
+  phone: '+1234567890',
+  devicePublicKey
+});
+```
+
+##### `startPasskeyRegistration(walletId: string, data: StartPasskeyRegistrationDto): Promise<WalletControllerStartPasskeyRegistrationResult>`
+
+Start passkey (WebAuthn) registration process.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`StartPasskeyRegistrationDto`): Registration data
+  - `credentialName?` (`string`): Name for the passkey
+
+**Returns:** `Promise<WalletControllerStartPasskeyRegistrationResult>` - Registration options
+  - `data.options` (`object`): WebAuthn registration options (for browser)
+
+**Example:**
+```typescript
+const registration = await wallet.startPasskeyRegistration('wallet-id', {
+  credentialName: 'My Passkey'
+});
+
+// Use registration.data.options with WebAuthn API
+const credential = await navigator.credentials.create({
+  publicKey: registration.data.options
+});
+
+// Then verify the registration
+await wallet.verifyPasskeyRegistration('wallet-id', {
+  credential: credential
+});
+```
+
+##### `verifyPasskeyRegistration(walletId: string, data: PasskeyRegistrationDto): Promise<WalletControllerVerifyPasskeyRegistrationResult>`
+
+Verify and complete passkey registration.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`PasskeyRegistrationDto`): Registration verification data
+  - `credential` (`object`): WebAuthn credential from browser
+
+**Returns:** `Promise<WalletControllerVerifyPasskeyRegistrationResult>` - Verified signer information
+
+**Example:**
+```typescript
+// After creating credential with WebAuthn API
+await wallet.verifyPasskeyRegistration('wallet-id', {
+  credential: credentialResponse
+});
+```
+
+##### `startPasskeyAuthentication(walletId: string, data: StartPasskeyAuthenticationDto): Promise<WalletControllerStartPasskeyAuthenticationResult>`
+
+Start passkey authentication process.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`StartPasskeyAuthenticationDto`): Authentication data
+  - `credentialId?` (`string`): Specific credential ID to use
+
+**Returns:** `Promise<WalletControllerStartPasskeyAuthenticationResult>` - Authentication options
+
+**Example:**
+```typescript
+const auth = await wallet.startPasskeyAuthentication('wallet-id', {});
+
+// Use auth.data.options with WebAuthn API
+const assertion = await navigator.credentials.get({
+  publicKey: auth.data.options
+});
+
+// Then verify
+await wallet.verifyPasskeyAuthentication('wallet-id', {
+  credential: assertion
+});
+```
+
+##### `verifyPasskeyAuthentication(walletId: string, data: PasskeyAuthenticationDto): Promise<WalletControllerVerifyPasskeyAuthenticationResult>`
+
+Verify passkey authentication.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`PasskeyAuthenticationDto`): Authentication verification data
+  - `credential` (`object`): WebAuthn assertion from browser
+
+**Returns:** `Promise<WalletControllerVerifyPasskeyAuthenticationResult>` - Authentication result
+
+**Example:**
+```typescript
+await wallet.verifyPasskeyAuthentication('wallet-id', {
+  credential: assertionResponse
+});
+```
+
+##### `createExternalWalletSigner(walletId: string, data: CreateExternalWalletSignerDto): Promise<WalletControllerCreateExternalWalletSignerResult>`
+
+Create an external wallet signer (e.g., Phantom, Solflare).
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`CreateExternalWalletSignerDto`): External wallet data
+  - `publicKey` (`string`): External wallet public key
+  - `walletName?` (`string`): Wallet name (e.g., 'Phantom')
+
+**Returns:** `Promise<WalletControllerCreateExternalWalletSignerResult>` - Created signer information
+
+**Example:**
+```typescript
+// After connecting to external wallet
+const signer = await wallet.createExternalWalletSigner('wallet-id', {
+  publicKey: externalWallet.publicKey.toString(),
+  walletName: 'Phantom'
+});
+```
+
+##### `createApiKeySigner(walletId: string, data: CreateApiKeySignerDto): Promise<WalletControllerCreateApiKeySignerResult>`
+
+Create an API key signer for server-side operations.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`CreateApiKeySignerDto`): API key signer data
+  - `name?` (`string`): Signer name
+  - `permissions?` (`object`): Signer permissions
+
+**Returns:** `Promise<WalletControllerCreateApiKeySignerResult>` - Created signer information
+
+**Example:**
+```typescript
+const signer = await wallet.createApiKeySigner('wallet-id', {
+  name: 'Server Signer',
+  permissions: {
+    canTransfer: true,
+    maxAmount: 1000000000
+  }
+});
+```
+
+##### `getSignerById(walletId: string, signerId: string): Promise<WalletControllerGetSignerByIdResult>`
+
+Get signer by ID.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `signerId` (`string`): Signer ID
+
+**Returns:** `Promise<WalletControllerGetSignerByIdResult>` - Signer details
+
+**Example:**
+```typescript
+const signer = await wallet.getSignerById('wallet-id', 'signer-id');
+```
+
+##### `updateSigner(walletId: string, signerId: string, data: UpdateSignerDto): Promise<WalletControllerUpdateSignerResult>`
+
+Update signer information.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `signerId` (`string`): Signer ID
+- `data` (`UpdateSignerDto`): Update data
+  - `isActive?` (`boolean`): Active status
+  - `name?` (`string`): Signer name
+
+**Returns:** `Promise<WalletControllerUpdateSignerResult>` - Updated signer information
+
+**Example:**
+```typescript
+await wallet.updateSigner('wallet-id', 'signer-id', {
+  isActive: false,
+  name: 'Updated Name'
+});
+```
+
+##### `deleteSigner(walletId: string, signerId: string): Promise<WalletControllerDeleteSignerResult>`
+
+Delete a signer.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `signerId` (`string`): Signer ID
+
+**Returns:** `Promise<WalletControllerDeleteSignerResult>` - Deletion confirmation
+
+**Example:**
+```typescript
+await wallet.deleteSigner('wallet-id', 'signer-id');
+```
+
+##### `addSigner(walletId: string, data: AddSignerDto): Promise<WalletControllerAddSignerResult>`
+
+Add a signer to the wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`AddSignerDto`): Signer data
+  - `signerType` (`'email' | 'phone' | 'passkey' | 'external' | 'apiKey'`): Signer type
+  - `signerConfig` (`object`): Signer-specific configuration
+
+**Returns:** `Promise<WalletControllerAddSignerResult>` - Added signer information
+
+**Example:**
+```typescript
+await wallet.addSigner('wallet-id', {
+  signerType: 'email',
+  signerConfig: {
+    email: 'user@example.com',
+    devicePublicKey: await generateDevicePublicKey()
+  }
+});
+```
+
+##### `listSigners(walletId: string): Promise<WalletControllerListSignersResult>`
+
+List all signers for a wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+
+**Returns:** `Promise<WalletControllerListSignersResult>` - List of signers
+  - `data.authenticationSigners` (`array`): Email/phone/passkey signers
+  - `data.onChainSigners` (`array`): External/API key signers
+
+**Example:**
+```typescript
+const signers = await wallet.listSigners('wallet-id');
+console.log('Authentication Signers:', signers.data.authenticationSigners);
+console.log('On-Chain Signers:', signers.data.onChainSigners);
+```
+
+##### `removeSigner(walletId: string, signerId: string): Promise<WalletControllerRemoveSignerResult>`
+
+Remove a signer from the wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `signerId` (`string`): Signer ID
+
+**Returns:** `Promise<WalletControllerRemoveSignerResult>` - Removal confirmation
+
+**Example:**
+```typescript
+await wallet.removeSigner('wallet-id', 'signer-id');
+```
+
+##### `updateSignerPermissions(walletId: string, signerId: string, data: UpdateSignerPermissionsDto): Promise<WalletControllerUpdateSignerPermissionsResult>`
+
+Update signer permissions.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `signerId` (`string`): Signer ID
+- `data` (`UpdateSignerPermissionsDto`): Permission data
+  - `canTransfer?` (`boolean`): Can transfer funds
+  - `maxAmount?` (`number`): Maximum transfer amount
+  - `allowedPrograms?` (`array`): Allowed program IDs
+
+**Returns:** `Promise<WalletControllerUpdateSignerPermissionsResult>` - Updated permissions
+
+**Example:**
+```typescript
+await wallet.updateSignerPermissions('wallet-id', 'signer-id', {
+  canTransfer: true,
+  maxAmount: 1000000000,
+  allowedPrograms: ['program-id-1']
+});
+```
+
+##### `getDeviceEncryptedSecret(walletId: string, signerId: string, params: WalletControllerGetDeviceEncryptedSecretParams): Promise<WalletControllerGetDeviceEncryptedSecretResult>`
+
+Get device encrypted secret for deriving signer keypair.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `signerId` (`string`): Signer ID
+- `params` (`WalletControllerGetDeviceEncryptedSecretParams`): Query parameters
+  - `devicePublicKey` (`string`): Device public key
+  - `deviceId?` (`string`): Device ID
+
+**Returns:** `Promise<WalletControllerGetDeviceEncryptedSecretResult>` - Encrypted secret
+  - `data.encryptedSecret` (`string`): Encrypted secret (base64)
+  - `data.deviceId` (`string`): Device ID
+
+**Example:**
+```typescript
+const secret = await wallet.getDeviceEncryptedSecret('wallet-id', 'signer-id', {
+  devicePublicKey: devicePublicKey
+});
+
+// Use with helpers.deriveSignerKeypair() to get keypair
+```
+
+##### `updateDeviceIdentity(walletId: string, signerId: string, data: UpdateDeviceIdentityDto): Promise<WalletControllerUpdateDeviceIdentityResult>`
+
+Update device identity for a signer.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `signerId` (`string`): Signer ID
+- `data` (`UpdateDeviceIdentityDto`): Device identity data
+  - `devicePublicKey` (`string`): New device public key
+  - `deviceId?` (`string`): Device ID (for replacing)
+  - `replace?` (`boolean`): Replace existing device
+
+**Returns:** `Promise<WalletControllerUpdateDeviceIdentityResult>` - Updated device identity
+
+**Example:**
+```typescript
+const newDeviceKey = await generateDevicePublicKey();
+await wallet.updateDeviceIdentity('wallet-id', 'signer-id', {
+  devicePublicKey: newDeviceKey,
+  replace: true
+});
+```
+
+### Auth Module (`cilantro-sdk/auth`)
+
+#### `login(credentials: CommonLoginDto, options?: AuthRequestOptions): Promise<AuthControllerLoginResult>`
+
+Authenticate as platform or user. Returns user type and appropriate JWT token.
+
+**Parameters:**
+- `credentials` (`CommonLoginDto`): Login credentials
+  - `usernameOrEmail` (`string`): Username or email address
+  - `password` (`string`): Password
+- `options?` (`AuthRequestOptions`): Optional request options (axios config)
+
+**Returns:** `Promise<AuthControllerLoginResult>` - Login response with JWT token and user information
+  - `data.jwt` (`string`): JWT token for authentication
+  - `data.userType` (`string`): User type (platform or user)
+  - `data.user` (`object`): User information
+
+**Example:**
+```typescript
+import { login } from 'cilantro-sdk/auth';
+
+const result = await login({
+  usernameOrEmail: 'user@example.com',
+  password: 'SecurePass123!'
+});
+
+console.log('JWT Token:', result.data.jwt);
+console.log('User Type:', result.data.userType);
+```
+
+#### `loginAndSetAuth(credentials: CommonLoginDto, options?: AuthRequestOptions): Promise<AuthControllerLoginResult>`
+
+Login and automatically set authentication credentials. This is a convenience function that calls `login()` and `setAuth()` automatically.
+
+**Parameters:**
+- `credentials` (`CommonLoginDto`): Login credentials
+  - `usernameOrEmail` (`string`): Username or email address
+  - `password` (`string`): Password
+- `options?` (`AuthRequestOptions`): Optional request options
+
+**Returns:** `Promise<AuthControllerLoginResult>` - Login response (auth is automatically set)
+
+**Example:**
+```typescript
+import { loginAndSetAuth } from 'cilantro-sdk/auth';
+import { sendSOL } from 'cilantro-sdk/wallet';
+
+// Login and set auth in one step
+await loginAndSetAuth({
+  usernameOrEmail: 'user@example.com',
+  password: 'SecurePass123!'
+});
+
+// Now you can make authenticated requests immediately
+await sendSOL('wallet-id', {
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  amountLamports: 1000000000
+});
+```
+
+### Subscriptions Module (`cilantro-sdk/subscriptions`)
+
+#### `create(data: CreateSubscriptionDto): Promise<SubscriptionControllerCreateResult>`
+
+Create a new subscription.
+
+**Parameters:**
+- `data` (`CreateSubscriptionDto`): Subscription creation data
+  - `platformId` (`string`): Platform ID
+  - `planId` (`string`): Plan ID
+  - `billingCycle` (`'monthly' | 'yearly'`): Billing cycle
+  - `trialDays?` (`number`): Trial period in days
+
+**Returns:** `Promise<SubscriptionControllerCreateResult>` - Created subscription
+
+**Example:**
+```typescript
+import { subscriptions } from 'cilantro-sdk';
+
+const subscription = await subscriptions.create({
+  platformId: 'platform-id',
+  planId: 'plan-id',
+  billingCycle: 'monthly',
+  trialDays: 7
+});
+```
+
+#### `findAll(params?: SubscriptionControllerFindAllParams): Promise<SubscriptionControllerFindAllResult>`
+
+Get all subscriptions with optional filters.
+
+**Parameters:**
+- `params?` (`SubscriptionControllerFindAllParams`): Optional query parameters
+  - `status?` (`string`): Filter by status
+  - `platformId?` (`string`): Filter by platform ID
+  - `page?` (`number`): Page number
+  - `limit?` (`number`): Items per page
+
+**Returns:** `Promise<SubscriptionControllerFindAllResult>` - Paginated list of subscriptions
+
+**Example:**
+```typescript
+const allSubscriptions = await subscriptions.findAll({
+  status: 'active',
+  platformId: 'platform-id'
+});
+```
+
+#### `findOne(subscriptionId: string): Promise<SubscriptionControllerFindOneResult>`
+
+Get subscription by ID.
+
+**Parameters:**
+- `subscriptionId` (`string`): Subscription ID
+
+**Returns:** `Promise<SubscriptionControllerFindOneResult>` - Subscription details
+
+**Example:**
+```typescript
+const subscription = await subscriptions.findOne('subscription-id');
+```
+
+#### `getPlatformSubscription(platformId: string): Promise<SubscriptionControllerGetPlatformSubscriptionResult>`
+
+Get platform's active subscription.
+
+**Parameters:**
+- `platformId` (`string`): Platform ID
+
+**Returns:** `Promise<SubscriptionControllerGetPlatformSubscriptionResult>` - Active subscription
+
+**Example:**
+```typescript
+const subscription = await subscriptions.getPlatformSubscription('platform-id');
+```
+
+#### `upgrade(subscriptionId: string, data: UpgradeSubscriptionDto): Promise<SubscriptionControllerUpgradeResult>`
+
+Upgrade subscription to a higher tier.
+
+**Parameters:**
+- `subscriptionId` (`string`): Subscription ID
+- `data` (`UpgradeSubscriptionDto`): Upgrade data
+  - `newPlanId` (`string`): New plan ID
+  - `effectiveDate?` (`string`): Effective date (ISO 8601)
+
+**Returns:** `Promise<SubscriptionControllerUpgradeResult>` - Upgraded subscription
+
+**Example:**
+```typescript
+await subscriptions.upgrade('subscription-id', {
+  newPlanId: 'premium-plan-id',
+  effectiveDate: '2024-01-01T00:00:00Z'
+});
+```
+
+#### `downgrade(subscriptionId: string, data: DowngradeSubscriptionDto): Promise<SubscriptionControllerDowngradeResult>`
+
+Downgrade subscription to a lower tier.
+
+**Parameters:**
+- `subscriptionId` (`string`): Subscription ID
+- `data` (`DowngradeSubscriptionDto`): Downgrade data
+  - `newPlanId` (`string`): New plan ID
+
+**Returns:** `Promise<SubscriptionControllerDowngradeResult>` - Downgraded subscription
+
+**Example:**
+```typescript
+await subscriptions.downgrade('subscription-id', {
+  newPlanId: 'basic-plan-id'
+});
+```
+
+#### `cancel(subscriptionId: string, data: CancelSubscriptionDto): Promise<SubscriptionControllerCancelResult>`
+
+Cancel a subscription.
+
+**Parameters:**
+- `subscriptionId` (`string`): Subscription ID
+- `data` (`CancelSubscriptionDto`): Cancellation data
+  - `cancelAtPeriodEnd?` (`boolean`): Cancel at period end
+
+**Returns:** `Promise<SubscriptionControllerCancelResult>` - Cancellation confirmation
+
+**Example:**
+```typescript
+await subscriptions.cancel('subscription-id', {
+  cancelAtPeriodEnd: true
+});
+```
+
+#### `renew(subscriptionId: string, data: RenewSubscriptionDto): Promise<SubscriptionControllerRenewResult>`
+
+Renew a subscription.
+
+**Parameters:**
+- `subscriptionId` (`string`): Subscription ID
+- `data` (`RenewSubscriptionDto`): Renewal data
+  - `extendByDays?` (`number`): Days to extend
+  - `extendByMonths?` (`number`): Months to extend
+
+**Returns:** `Promise<SubscriptionControllerRenewResult>` - Renewed subscription
+
+**Example:**
+```typescript
+await subscriptions.renew('subscription-id', {
+  extendByMonths: 1
+});
+```
+
+#### `getHistory(subscriptionId: string): Promise<SubscriptionControllerGetHistoryResult>`
+
+Get subscription audit trail/history.
+
+**Parameters:**
+- `subscriptionId` (`string`): Subscription ID
+
+**Returns:** `Promise<SubscriptionControllerGetHistoryResult>` - Subscription history
+
+**Example:**
+```typescript
+const history = await subscriptions.getHistory('subscription-id');
+```
+
+### Plans Module (`cilantro-sdk/plans`)
+
+#### `findAll(): Promise<PlanControllerFindAllResult>`
+
+Get all subscription plans.
+
+**Parameters:** None
+
+**Returns:** `Promise<PlanControllerFindAllResult>` - List of all plans
+
+**Example:**
+```typescript
+import { plans } from 'cilantro-sdk';
+
+const allPlans = await plans.findAll();
+```
+
+#### `findOne(planId: string): Promise<PlanControllerFindOneResult>`
+
+Get plan by ID.
+
+**Parameters:**
+- `planId` (`string`): Plan ID
+
+**Returns:** `Promise<PlanControllerFindOneResult>` - Plan details
+
+**Example:**
+```typescript
+const plan = await plans.findOne('plan-id');
+```
+
+#### `update(planId: string, data: UpdatePlanDto): Promise<PlanControllerUpdateResult>`
+
+Update plan information.
+
+**Parameters:**
+- `planId` (`string`): Plan ID
+- `data` (`UpdatePlanDto`): Update data
+  - `planName?` (`string`): Plan name
+  - `description?` (`string`): Description
+  - `price?` (`number`): Price
+  - `isActive?` (`boolean`): Active status
+
+**Returns:** `Promise<PlanControllerUpdateResult>` - Updated plan
+
+**Example:**
+```typescript
+await plans.update('plan-id', {
+  planName: 'Updated Plan Name',
+  description: 'New description'
+});
+```
+
+#### `remove(planId: string): Promise<PlanControllerRemoveResult>`
+
+Remove (deactivate) a plan.
+
+**Parameters:**
+- `planId` (`string`): Plan ID
+
+**Returns:** `Promise<PlanControllerRemoveResult>` - Removal confirmation
+
+**Example:**
+```typescript
+await plans.remove('plan-id');
+```
+
+#### `assignToPlatform(planId: string, platformId: string, data: AssignPlanDto): Promise<PlanControllerAssignToPlatformResult>`
+
+Assign plan to platform.
+
+**Parameters:**
+- `planId` (`string`): Plan ID
+- `platformId` (`string`): Platform ID
+- `data` (`AssignPlanDto`): Assignment data
+  - `startDate?` (`string`): Start date (ISO 8601)
+  - `billingCycle?` (`string`): Billing cycle
+
+**Returns:** `Promise<PlanControllerAssignToPlatformResult>` - Assignment confirmation
+
+**Example:**
+```typescript
+await plans.assignToPlatform('plan-id', 'platform-id', {
+  startDate: '2024-01-01T00:00:00Z',
+  billingCycle: 'monthly'
+});
+```
+
+#### `assignToUser(planId: string, userId: string, data: AssignPlanDto): Promise<PlanControllerAssignToUserResult>`
+
+Assign plan to user.
+
+**Parameters:**
+- `planId` (`string`): Plan ID
+- `userId` (`string`): User ID
+- `data` (`AssignPlanDto`): Assignment data
+
+**Returns:** `Promise<PlanControllerAssignToUserResult>` - Assignment confirmation
+
+**Example:**
 ```typescript
-import { configure } from 'cilantro-sdk';
+await plans.assignToUser('plan-id', 'user-id', {
+  startDate: '2024-01-01T00:00:00Z',
+  billingCycle: 'monthly'
+});
+```
 
-configure({ 
-  apiKey: 'your-api-key',
-  jwt: 'your-jwt-token', // Optional
-  baseURL: 'https://api.cilantro.gg' // Optional: Custom API base URL
+### Transactions Module (`cilantro-sdk/transactions`)
+
+#### `getWalletTransactions(walletId: string, params?: TransactionControllerGetWalletTransactionsParams): Promise<TransactionControllerGetWalletTransactionsResult>`
+
+Get paginated transaction history for a wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `params?` (`TransactionControllerGetWalletTransactionsParams`): Optional query parameters
+  - `page?` (`number`): Page number
+  - `limit?` (`number`): Items per page
+  - `type?` (`TransactionType`): Filter by transaction type
+  - `status?` (`TransactionStatus`): Filter by status
+  - `startDate?` (`string`): Start date filter
+  - `endDate?` (`string`): End date filter
+
+**Returns:** `Promise<TransactionControllerGetWalletTransactionsResult>` - Paginated transaction history
+
+**Example:**
+```typescript
+import { getWalletTransactions } from 'cilantro-sdk/transactions';
+
+const transactions = await getWalletTransactions('wallet-id', {
+  page: 1,
+  limit: 20,
+  type: 'transfer',
+  status: 'confirmed'
 });
 ```
 
-### `setAuth(auth)`
+#### `getTransactionStatus(signature: string): Promise<TransactionControllerGetTransactionStatusResult>`
 
-Update authentication credentials after initialization.
+Get transaction status by Solana signature.
+
+**Parameters:**
+- `signature` (`string`): Transaction signature
 
+**Returns:** `Promise<TransactionControllerGetTransactionStatusResult>` - Transaction status
+  - `data.status` (`string`): Transaction status (pending, confirmed, failed)
+  - `data.confirmations?` (`number`): Number of confirmations
+  - `data.error?` (`string`): Error message if failed
+
+**Example:**
 ```typescript
-import { setAuth } from 'cilantro-sdk';
+import { getTransactionStatus } from 'cilantro-sdk/transactions';
+
+const status = await getTransactionStatus('transaction-signature-here');
+console.log('Status:', status.data.status);
+```
+
+#### `sendRawPasskeyTransaction(data: SendRawPasskeyTransactionDto): Promise<TransactionControllerSendRawPasskeyTransactionResult>`
+
+Send transaction signed with passkey.
+
+**Parameters:**
+- `data` (`SendRawPasskeyTransactionDto`): Transaction data
+  - `walletId` (`string`): Wallet ID
+  - `credentialId` (`string`): Passkey credential ID
+  - `unsignedTransaction` (`string`): Base64-encoded unsigned transaction
+  - `signature` (`string`): Transaction signature from passkey
 
-setAuth({ 
-  jwt: 'your-jwt-token',
-  apiKey: 'your-api-key' 
+**Returns:** `Promise<TransactionControllerSendRawPasskeyTransactionResult>` - Transaction result
+
+**Example:**
+```typescript
+import { sendRawPasskeyTransaction } from 'cilantro-sdk/transactions';
+
+const result = await sendRawPasskeyTransaction({
+  walletId: 'wallet-id',
+  credentialId: 'credential-id',
+  unsignedTransaction: unsignedTxBase64,
+  signature: signatureBase64
 });
 ```
 
-### `clearAuth()`
+#### `sendPasskeyTransaction(data: SendRawPasskeyTransactionDto): Promise<TransactionControllerSendRawPasskeyTransactionResult>`
 
-Clear all authentication credentials.
+Alias for `sendRawPasskeyTransaction`. Send transaction signed with passkey.
 
+**Parameters:** Same as `sendRawPasskeyTransaction`
+
+**Returns:** Same as `sendRawPasskeyTransaction`
+
+**Example:**
 ```typescript
-import { clearAuth } from 'cilantro-sdk';
+import { sendPasskeyTransaction } from 'cilantro-sdk/transactions';
 
-clearAuth();
+// Same as sendRawPasskeyTransaction
+await sendPasskeyTransaction({ ... });
 ```
 
-### Authentication Types
+#### `getTransactionHistory(walletId: string, options?: TransactionControllerGetWalletTransactionsParams): Promise<TransactionControllerGetWalletTransactionsResult>`
 
-The SDK supports two types of authentication:
+Alias for `getWalletTransactions`. Get transaction history for a wallet.
 
-1. **API Key Authentication**: For server-side applications and platform-level access
-2. **JWT Token Authentication**: For user-specific operations after login
+**Parameters:** Same as `getWalletTransactions`
 
-You can use either or both simultaneously. The SDK will automatically include the appropriate headers in all requests.
+**Returns:** Same as `getWalletTransactions`
 
-## Documentation
+**Example:**
+```typescript
+import { getTransactionHistory } from 'cilantro-sdk/transactions';
 
-### Getting Started Guides
+const history = await getTransactionHistory('wallet-id', {
+  page: 1,
+  limit: 20
+});
+```
 
-- **[Complete Wallet & Transaction Flow Guide](./WALLET_TRANSACTION_FLOW.md)** - Comprehensive step-by-step guide covering:
-  - Wallet creation (platform-controlled vs user-controlled)
-  - Understanding and creating signers (email, phone, passkey, external, API key)
-  - Device key management and ECDH encryption
-  - Complete transaction flows (server-side and client-side signing)
-  - Real-world examples and best practices
+#### `checkTransactionStatus(signature: string): Promise<TransactionControllerGetTransactionStatusResult>`
 
-- **[Device Key Management Guide](./DEVICE_KEY_MANAGEMENT.md)** - Deep dive into device key architecture
+Alias for `getTransactionStatus`. Check transaction status.
 
-### Quick Links
+**Parameters:** Same as `getTransactionStatus`
 
-- [Examples](./examples/) - Code examples
-- [API Documentation](https://api.cilantro.gg/docs) - Complete API reference
+**Returns:** Same as `getTransactionStatus`
 
-## Module Structure
+**Example:**
+```typescript
+import { checkTransactionStatus } from 'cilantro-sdk/transactions';
 
-The SDK is organized into modules for better code organization:
+const status = await checkTransactionStatus('signature');
+```
 
-- **Platform** (`cilantro-sdk/platform`) - Platform management and user operations
-- **User** (`cilantro-sdk/user`) - User account operations
-- **Wallet** (`cilantro-sdk/wallet`) - Wallet and blockchain operations
-- **Admin** (`cilantro-sdk/admin`) - Administrative operations
-- **Auth** (`cilantro-sdk/auth`) - Universal authentication
-- **Subscriptions** (`cilantro-sdk/subscriptions`) - Subscription management operations
-- **Plans** (`cilantro-sdk/plans`) - Subscription plan management operations
-- **Transactions** (`cilantro-sdk/transactions`) - Transaction history and status queries
-- **Delegated Keys** (`cilantro-sdk/delegated-keys`) - Temporary key management for session-based signing
-- **Webhooks** (`cilantro-sdk/webhooks`) - Webhook endpoint management for event notifications
-- **Utils** (`cilantro-sdk/utils`) - Utility functions
-- **Helpers** (`cilantro-sdk/helpers`) - Device key management and signer helpers
+### Delegated Keys Module (`cilantro-sdk/delegated-keys`)
+
+#### `create(walletId: string, data: CreateDelegatedKeyDto): Promise<DelegatedKeyControllerCreateResult>`
+
+Create a temporary delegated key for session-based signing.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `data` (`CreateDelegatedKeyDto`): Delegated key data
+  - `publicKey` (`string`): Delegated public key
+  - `expiresAt` (`string`): Expiration date (ISO 8601)
+  - `permissions?` (`DelegatedKeyPermissionsDto`): Key permissions
+    - `canTransfer?` (`boolean`): Can transfer funds
+    - `maxAmount?` (`number`): Maximum transfer amount
+    - `allowedPrograms?` (`array`): Allowed program IDs
+
+**Returns:** `Promise<DelegatedKeyControllerCreateResult>` - Created delegated key
+
+**Example:**
+```typescript
+import { create } from 'cilantro-sdk/delegated-keys';
+
+const delegatedKey = await create('wallet-id', {
+  publicKey: 'delegated-public-key',
+  expiresAt: '2024-12-31T23:59:59Z',
+  permissions: {
+    canTransfer: true,
+    maxAmount: 1000000000,
+    allowedPrograms: ['program-id-1']
+  }
+});
+```
+
+#### `findAll(walletId: string): Promise<DelegatedKeyControllerFindAllResult>`
+
+List all delegated keys for a wallet.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+
+**Returns:** `Promise<DelegatedKeyControllerFindAllResult>` - List of delegated keys
+
+**Example:**
+```typescript
+import { findAll } from 'cilantro-sdk/delegated-keys';
+
+const keys = await findAll('wallet-id');
+```
+
+#### `findOne(walletId: string, keyId: string): Promise<DelegatedKeyControllerFindOneResult>`
+
+Get delegated key by ID.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `keyId` (`string`): Delegated key ID
+
+**Returns:** `Promise<DelegatedKeyControllerFindOneResult>` - Delegated key details
+
+**Example:**
+```typescript
+import { findOne } from 'cilantro-sdk/delegated-keys';
+
+const key = await findOne('wallet-id', 'key-id');
+```
+
+#### `update(walletId: string, keyId: string, data: UpdateDelegatedKeyDto): Promise<DelegatedKeyControllerUpdateResult>`
+
+Update delegated key configuration.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `keyId` (`string`): Delegated key ID
+- `data` (`UpdateDelegatedKeyDto`): Update data
+  - `expiresAt?` (`string`): New expiration date
+  - `permissions?` (`DelegatedKeyPermissionsDto`): Updated permissions
+
+**Returns:** `Promise<DelegatedKeyControllerUpdateResult>` - Updated delegated key
+
+**Example:**
+```typescript
+import { update } from 'cilantro-sdk/delegated-keys';
+
+await update('wallet-id', 'key-id', {
+  permissions: {
+    canTransfer: false,
+    maxAmount: 500000000
+  }
+});
+```
+
+#### `remove(walletId: string, keyId: string): Promise<DelegatedKeyControllerRemoveResult>`
+
+Revoke a delegated key.
+
+**Parameters:**
+- `walletId` (`string`): Wallet ID
+- `keyId` (`string`): Delegated key ID
+
+**Returns:** `Promise<DelegatedKeyControllerRemoveResult>` - Revocation confirmation
+
+**Example:**
+```typescript
+import { remove } from 'cilantro-sdk/delegated-keys';
+
+await remove('wallet-id', 'key-id');
+```
+
+### Webhooks Module (`cilantro-sdk/webhooks`)
+
+#### `create(data: CreateWebhookDto): Promise<WebhookControllerCreateResult>`
+
+Register a new webhook endpoint.
+
+**Parameters:**
+- `data` (`CreateWebhookDto`): Webhook data
+  - `url` (`string`): Webhook endpoint URL
+  - `events` (`WebhookEvent[]`): Array of events to subscribe to
+  - `description?` (`string`): Webhook description
+  - `isActive?` (`boolean`): Active status (default: true)
+
+**Returns:** `Promise<WebhookControllerCreateResult>` - Created webhook
+
+**Example:**
+```typescript
+import { create } from 'cilantro-sdk/webhooks';
+
+const webhook = await create({
+  url: 'https://your-domain.com/webhooks/cilantro',
+  events: ['wallet.created', 'transaction.confirmed', 'transaction.failed'],
+  description: 'Production webhook',
+  isActive: true
+});
+```
+
+#### `findAll(): Promise<WebhookControllerFindAllResult>`
+
+List all webhooks for the platform.
+
+**Parameters:** None
+
+**Returns:** `Promise<WebhookControllerFindAllResult>` - List of webhooks
+
+**Example:**
+```typescript
+import { findAll } from 'cilantro-sdk/webhooks';
+
+const webhooks = await findAll();
+```
+
+#### `findOne(webhookId: string): Promise<WebhookControllerFindOneResult>`
+
+Get webhook by ID.
+
+**Parameters:**
+- `webhookId` (`string`): Webhook ID
+
+**Returns:** `Promise<WebhookControllerFindOneResult>` - Webhook details
+
+**Example:**
+```typescript
+import { findOne } from 'cilantro-sdk/webhooks';
+
+const webhook = await findOne('webhook-id');
+```
+
+#### `update(webhookId: string, data: UpdateWebhookDto): Promise<WebhookControllerUpdateResult>`
+
+Update webhook configuration.
+
+**Parameters:**
+- `webhookId` (`string`): Webhook ID
+- `data` (`UpdateWebhookDto`): Update data
+  - `url?` (`string`): New URL
+  - `events?` (`WebhookEvent[]`): Updated events
+  - `isActive?` (`boolean`): Active status
+  - `description?` (`string`): Description
+
+**Returns:** `Promise<WebhookControllerUpdateResult>` - Updated webhook
+
+**Example:**
+```typescript
+import { update } from 'cilantro-sdk/webhooks';
+
+await update('webhook-id', {
+  events: ['wallet.created', 'transaction.confirmed'],
+  isActive: false
+});
+```
+
+#### `remove(webhookId: string): Promise<WebhookControllerRemoveResult>`
+
+Delete a webhook.
+
+**Parameters:**
+- `webhookId` (`string`): Webhook ID
+
+**Returns:** `Promise<WebhookControllerRemoveResult>` - Deletion confirmation
+
+**Example:**
+```typescript
+import { remove } from 'cilantro-sdk/webhooks';
+
+await remove('webhook-id');
+```
+
+### Helpers Module (`cilantro-sdk/helpers`)
+
+**Device Key Management:**
+- `generateDeviceKeyPair()` - Generate new device key pair
+- `getOrCreateDeviceKeyPair(storage, keyId?)` - Get or create device key pair with caching
+- `getDevicePublicKey(storage, keyId)` - Get device public key
+- `getDevicePrivateKey(storage, keyId)` - Get device private key
+- `rotateDeviceKey(storage, keyId)` - Rotate device keys
+- `clearDeviceKeyCache(keyId?)` - Clear device key cache
+- `deleteDeviceKey(storage, keyId)` - Delete device key
+- `listDeviceKeys(storage)` - List all device key IDs
+- `findDeviceKeyByPublicKey(storage, publicKey)` - Find device key by public key
+- `listAllDeviceKeys(storage)` - List all device keys with metadata
+
+**Storage Adapters:**
+- `createMemoryAdapter()` - Create in-memory storage adapter (for testing)
+- `createLocalStorageAdapter()` - Create browser localStorage adapter
+- `createFileSystemAdapter(basePath)` - Create Node.js filesystem adapter
+- `getDefaultStorageAdapter()` - Get platform-appropriate storage adapter
+
+**Key Format Utilities:**
+- `normalizeSPKI(spkiKey)` - Normalize SPKI key format
+- `base64ToPEM(base64Key, keyType)` - Convert base64 to PEM format
+- `pemToBase64(pemKey)` - Convert PEM to base64
+- `base64ToArrayBuffer(base64)` - Convert base64 to ArrayBuffer
+- `arrayBufferToBase64(buffer)` - Convert ArrayBuffer to base64
+- `importSPKIPublicKey(spkiBase64)` - Import SPKI public key
+- `exportToSPKI(key)` - Export key to SPKI format
+- `isValidBase64(str)` - Validate base64 string
+
+**Core Signer Helpers:**
+- `deriveSignerKeypair(walletId, signerId, options)` - Derive signer keypair from encrypted secret
+- `signWithSigner(walletId, signerId, message, options)` - Sign message with signer
+- `parseSignerResponse(response)` - Parse signer API response to SignerInfo
+- `clearSignerCache(walletId?, signerId?)` - Clear signer keypair cache
+- `getCacheStats()` - Get cache statistics
+
+**Email Signer Helpers:**
+- `createEmailSignerHelper(walletId, options)` - Create email signer with automatic device key generation
+- `getEmailSignerKeypair(walletId, signerId, options)` - Get keypair with automatic device key resolution
+- `signWithEmailSigner(walletId, signerId, message, options)` - Sign messages with email signer
+- `clearEmailSignerCache(walletId, signerId?)` - Clear email signer cache
+- `getEmailSignerByEmail(walletId, email)` - Find email signer by email address
+
+**Phone Signer Helpers:**
+- `createPhoneSignerHelper(walletId, options)` - Create phone signer with automatic device key generation
+- `getPhoneSignerKeypair(walletId, signerId, options)` - Get keypair with automatic device key resolution
+- `signWithPhoneSigner(walletId, signerId, message, options)` - Sign messages with phone signer
+- `clearPhoneSignerCache(walletId, signerId?)` - Clear phone signer cache
+- `getPhoneSignerByPhone(walletId, phone)` - Find phone signer by phone number
+
+**Passkey (WebAuthn) Helpers:**
+- `isWebAuthnSupported()` - Check if WebAuthn is supported
+- `isPlatformAuthenticatorAvailable()` - Check if platform authenticator is available
+- `registerPasskey(walletId, options?)` - Register a new passkey
+- `authenticateWithPasskey(walletId, options?)` - Authenticate with existing passkey
+- `formatRegistrationResponse(response)` - Format passkey registration response
+- `formatAuthenticationResponse(response)` - Format passkey authentication response
+- `formatAuthenticationForVerification(response)` - Format authentication for verification
+- `findExistingPasskeySigner(walletId, credentialId?)` - Find existing passkey signer
+- `registerPasskeyComplete(walletId, registrationData, verificationData)` - Complete passkey registration
+- `signWithPasskeySigner(walletId, signerId, message, options)` - Sign with passkey signer
+
+**Device Key Validation & Resolution:**
+- `getSignerDeviceKeys(walletId, signerId)` - Get all device keys for a signer from API
+- `validateDeviceKey(storage, keyId, expectedPublicKey)` - Validate device key matches API
+- `resolveDeviceKey(storage, walletId, signerId)` - Automatically find matching device key
+- `findAndValidateDeviceKey(storage, walletId, signerId, devicePublicKey)` - Find and validate device key
+- `getBestDeviceIdentity(walletId, signerId)` - Get most recently used device identity
+
+**Device Identity Management:**
+- `addDeviceIdentityToSigner(walletId, signerId, options)` - Add new device to existing signer
+- `replaceDeviceIdentity(walletId, signerId, options)` - Replace existing device identity
+- `addNewDeviceToSigner(walletId, signerId, options)` - Convenience function for adding new device
+- `canAddDeviceToSigner(walletId, signerId)` - Check if device can be added to signer
+
+**Signer Lifecycle:**
+- `createSigner(walletId, signerType, config)` - Create a new signer
+- `revokeSigner(walletId, signerId)` - Revoke a signer
+- `getSigners(walletId)` - Get all signers for a wallet
+
+**Multi-Device Management:**
+- `addDevice(walletId, signerId, devicePublicKey)` - Add device to signer
+- `replaceDevice(walletId, signerId, oldDeviceId, newDevicePublicKey)` - Replace device
+- `getDevices(walletId, signerId)` - Get all devices for a signer
+- `updateDevice(walletId, signerId, deviceId, data)` - Update device information
+
+**Validation:**
+- `isValidEmail(email)` - Validate email format
+- `isValidPhone(phone)` - Validate phone number format
+- `isBrowserCompatible()` - Check if browser is compatible
+
+**External Wallet Adapter:**
+- `detectWallets()` - Detect available Solana wallets
+- `getWallet(name)` - Get wallet by name
+- `connectWallet(wallet)` - Connect to external wallet
+- `signTransaction(wallet, transaction)` - Sign transaction with external wallet
+- `signMessage(wallet, message)` - Sign message with external wallet
+
+**Wallet Transaction Helpers:**
+- `signTransactionWithEmailSigner(walletId, signerId, transaction, options)` - Sign transaction with email signer
+- `signTransactionWithPhoneSigner(walletId, signerId, transaction, options)` - Sign transaction with phone signer
+- `signTransactionWithPasskeySigner(walletId, signerId, transaction, options)` - Sign transaction with passkey signer
+- `signTransactionWithExternalWallet(wallet, transaction)` - Sign transaction with external wallet
+- `prepareSignAndSubmitTransaction(walletId, transaction, signerConfig)` - Prepare, sign, and submit transaction
+- `sendSOLWithSigner(walletId, recipientAddress, amountLamports, signerConfig)` - Send SOL using signer
+- `sendSPLWithSigner(walletId, recipientAddress, mintAddress, amount, signerConfig)` - Send SPL token using signer
+
+### Utils Module (`cilantro-sdk/utils`)
+
+#### `generateDevicePublicKey(): Promise<string>`
+
+Generate device public key for ECDH (P-256) encryption. Works in both browser and Node.js environments.
+
+**Parameters:** None
+
+**Returns:** `Promise<string>` - Base64-encoded P-256 ECDH public key (65 bytes, uncompressed format)
+
+**Example:**
+```typescript
+import { generateDevicePublicKey } from 'cilantro-sdk/utils';
 
-### Quick Reference
-
-**Platform Module:**
-- Basic: `create`, `findAll`, `findOne`, `update`, `remove`, `getOwnProfile`, `updateOwnProfile`
-- Users: `getUsers`, `createUser`, `updateUser`, `removeUser`, `toggleUserActive`
-- Wallets: `getWallets` (read-only)
-
-**User Module:**
-- `create`, `findOne`, `update`
-
-**Wallet Module:**
-- Basic: `create`, `findAll`, `findOne`, `update`, `remove`, `findByAddress`, `getTotalBalance`
-- Status: `activate`, `deactivate`
-- Transactions: `sendSOL`, `sendSPL`, `sendTransaction`, `simulateTransaction`
-- Batch: `batchCreate`, `batchSendSOL`, `batchSendSPL`
-- NFTs & Tokens: `mintNFT`, `mintNFTSimple`, `mintToken`
-- Assets: `getAssets`, `syncAssets`
-- Signers: Email, phone, external, API key, and passkey signer management
-
-**Auth Module:**
-- `login` - Login and get JWT token
-- `loginAndSetAuth` - Login and automatically set authentication
-
-**Subscriptions Module:**
-- Basic: `create`, `findAll`, `findOne`, `getPlatformSubscription`
-- Management: `upgrade`, `downgrade`, `cancel`, `renew`
-- History: `getHistory` - Get subscription audit trail
-
-**Plans Module:**
-- Basic: `findAll`, `findOne`, `update`, `remove`
-- Assignment: `assignToPlatform`, `assignToUser`
-
-**Subscriptions Module:**
-- Basic: `create`, `findAll`, `findOne`, `getPlatformSubscription`
-- Management: `upgrade`, `downgrade`, `cancel`, `renew`
-- History: `getHistory` - Get subscription audit trail
-
-**Plans Module:**
-- Basic: `findAll`, `findOne`, `update`, `remove`
-- Assignment: `assignToPlatform`, `assignToUser`
-
-**Transactions Module:**
-- `getWalletTransactions` - Get paginated transaction history for a wallet
-- `getTransactionStatus` - Get transaction status by Solana signature
-
-**Delegated Keys Module:**
-- `create` - Create temporary delegated key for wallet
-- `findAll` - List all delegated keys for a wallet
-- `findOne` - Get delegated key by ID
-- `update` - Update delegated key configuration
-- `remove` - Revoke delegated key
-
-**Webhooks Module:**
-- `create` - Register new webhook endpoint
-- `findAll` - List all webhooks for platform
-- `findOne` - Get webhook by ID
-- `update` - Update webhook configuration
-- `remove` - Delete webhook
-
-**Helpers Module:**
-- Device key management, signer helpers, validation, and storage adapters (see above)
+const devicePublicKey = await generateDevicePublicKey();
+// Use with createEmailSigner or createPhoneSigner
+```
+
+**Note:** This function automatically detects the environment (browser vs Node.js) and uses the appropriate crypto implementation.
 
 ## Examples
 
@@ -581,7 +3073,6 @@ import type {
 **Response Types:**
 - `WalletControllerCreateResult`, `WalletControllerFindAllResult`
 - `PlatformControllerCreateResult`, `UserControllerCreateResult`
-- `AdminControllerGetOverviewAnalyticsResult`
 - All API endpoints have corresponding response types
 
 **Helper Types:**
@@ -592,7 +3083,6 @@ import type {
 **Parameter Types:**
 - `WalletControllerGetWalletAssetsParams`
 - `TransactionControllerGetWalletTransactionsParams`
-- `AdminControllerFindAllParams`
 
 **Enum Types:**
 - `TransactionType`, `TransactionStatus`, `WebhookEvent`
@@ -718,6 +3208,204 @@ module.exports = {
 };
 ```
 
+## Best Practices
+
+### Security
+
+1. **Never expose API keys or JWT tokens in client-side code**
+   - Use API keys only on the server
+   - Store JWT tokens securely (httpOnly cookies, secure storage)
+   - Rotate API keys regularly
+
+2. **Protect device keys**
+   - Store device private keys securely (use provided storage adapters)
+   - Never log or expose private keys
+   - Use encryption for sensitive data
+
+3. **Validate inputs**
+   - Always validate user inputs before making API calls
+   - Use TypeScript types for compile-time safety
+   - Validate addresses and amounts
+
+4. **Handle errors gracefully**
+   - Always wrap API calls in try-catch blocks
+   - Check transaction status before considering operations complete
+   - Implement retry logic for transient failures
+
+### Performance
+
+1. **Cache device keys and signers**
+   - Use the built-in caching mechanisms in helpers
+   - Cache keypairs to avoid redundant derivations
+   - Clear cache when needed (e.g., after key rotation)
+
+2. **Batch operations when possible**
+   - Use `batchSendSOL` and `batchSendSPL` for multiple transfers
+   - Use `batchCreate` for creating multiple wallets
+
+3. **Optimize transaction preparation**
+   - Use `simulateTransaction` before submitting
+   - Check transaction status asynchronously
+   - Use pagination for large data sets
+
+### Error Handling
+
+```typescript
+import { 
+  SDKError,
+  DeviceKeyNotFoundError,
+  DeviceKeyMismatchError,
+  TransactionSigningError
+} from 'cilantro-sdk';
+
+try {
+  const result = await wallet.sendSOL('wallet-id', {
+    recipientAddress: 'address',
+    amountLamports: 1000000000
+  });
+} catch (error) {
+  if (error instanceof DeviceKeyNotFoundError) {
+    // Handle missing device key
+    console.error('Device key not found');
+  } else if (error instanceof TransactionSigningError) {
+    // Handle signing error
+    console.error('Transaction signing failed');
+  } else if (error instanceof SDKError) {
+    // Handle other SDK errors
+    console.error('SDK Error:', error.message);
+  } else {
+    // Handle unexpected errors
+    console.error('Unexpected error:', error);
+  }
+}
+```
+
+### Common Patterns
+
+#### Wallet Creation Flow
+
+```typescript
+// 1. Create wallet
+const wallet = await wallet.create({
+  name: 'My Wallet',
+  userId: 'user-id',
+  walletMode: 'nonCustodial'
+});
+
+// 2. Create signer
+const deviceKey = await generateDevicePublicKey();
+const signer = await wallet.createEmailSigner(wallet.data.id, {
+  email: 'user@example.com',
+  devicePublicKey: deviceKey
+});
+
+// 3. Store device key securely
+const storage = createLocalStorageAdapter();
+await storage.save(`device-${signer.data.deviceId}`, {
+  publicKey: deviceKey,
+  privateKey: devicePrivateKey, // Store securely
+  keyId: signer.data.deviceId,
+  createdAt: new Date()
+});
+```
+
+#### Transaction Flow (Non-Custodial)
+
+```typescript
+// 1. Prepare transaction
+const prepared = await wallet.prepareTransaction('wallet-id', {
+  type: 'transfer',
+  recipientAddress: 'recipient-address',
+  amount: 1000000000
+});
+
+// 2. Sign transaction client-side
+const keypair = await getEmailSignerKeypair('wallet-id', 'signer-id', {
+  deviceKeyManager: storage
+});
+const signedTx = await signTransaction(prepared.data.transaction, keypair);
+
+// 3. Submit transaction
+const result = await wallet.submitTransaction('wallet-id', {
+  signedTransaction: signedTx
+});
+
+// 4. Check status
+const status = await getTransactionStatus(result.data.signature);
+```
+
+#### Multi-Device Support
+
+```typescript
+// Add new device to existing signer
+const newDeviceKey = await generateDevicePublicKey();
+await wallet.updateDeviceIdentity('wallet-id', 'signer-id', {
+  devicePublicKey: newDeviceKey,
+  replace: false // Add new device, don't replace
+});
+
+// Store new device key
+await storage.save(`device-${newDeviceId}`, {
+  publicKey: newDeviceKey,
+  privateKey: newDevicePrivateKey,
+  keyId: newDeviceId,
+  createdAt: new Date()
+});
+```
+
+### TypeScript Best Practices
+
+1. **Use type imports for better tree-shaking**
+   ```typescript
+   import type { CreateWalletDto, WalletControllerCreateResult } from 'cilantro-sdk';
+   ```
+
+2. **Leverage type inference**
+   ```typescript
+   const wallet = await wallet.create({ ... });
+   // wallet is automatically typed as WalletControllerCreateResult
+   ```
+
+3. **Use const assertions for literal types**
+   ```typescript
+   const events = ['wallet.created', 'transaction.confirmed'] as const;
+   ```
+
+### Testing
+
+1. **Use memory adapter for tests**
+   ```typescript
+   import { createMemoryAdapter } from 'cilantro-sdk/helpers';
+   
+   const storage = createMemoryAdapter();
+   // Use in tests - no persistence
+   ```
+
+2. **Mock API calls in unit tests**
+   ```typescript
+   // Mock configure for tests
+   configure({ apiKey: 'test-key', baseURL: 'http://localhost:3000' });
+   ```
+
+3. **Test error handling**
+   ```typescript
+   await expect(wallet.sendSOL('invalid-id', { ... }))
+     .rejects.toThrow(SDKError);
+   ```
+
+### Production Checklist
+
+- [ ] Configure SDK with production API key
+- [ ] Set up proper error logging and monitoring
+- [ ] Implement retry logic for network failures
+- [ ] Set up webhooks for important events
+- [ ] Use secure storage for device keys
+- [ ] Implement proper authentication flow
+- [ ] Add transaction status polling
+- [ ] Set up rate limiting on client side
+- [ ] Monitor API usage and costs
+- [ ] Keep SDK updated to latest version
+
 ## License
 
 ISC