cilantro-sdk 0.0.1

package/README.md

@@ -0,0 +1,1370 @@
+# Cilantro Smart SDK
+
+A TypeScript/JavaScript SDK for interacting with the Cilantro Smart API - A Solana wallet management system.
+
+## Installation
+
+```bash
+npm install cilantro-sdk
+```
+
+## Quick Start
+
+### Option 1: Using API Key (Recommended for Server-Side)
+
+```typescript
+import { configure } from 'cilantro-sdk';
+import { sendSOL } from 'cilantro-sdk/wallet';
+
+// Configure SDK with your API key
+configure({ 
+  apiKey: 'your-api-key-here'
+});
+
+// Make authenticated requests
+const result = await sendSOL('wallet-id', {
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  amountLamports: 1000000000
+});
+```
+
+### Option 2: Using Login (For User Authentication)
+
+```typescript
+import { loginAndSetAuth } from 'cilantro-sdk/auth';
+import { sendSOL } from 'cilantro-sdk/wallet';
+
+// Login and set authentication automatically
+await loginAndSetAuth({
+  usernameOrEmail: 'user@example.com',
+  password: 'SecurePass123!'
+});
+
+// Make authenticated requests
+const result = await sendSOL('wallet-id', {
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  amountLamports: 1000000000
+});
+```
+
+### Option 3: Manual Authentication Control
+
+```typescript
+import { setAuth } from 'cilantro-sdk';
+import { login } from 'cilantro-sdk/auth';
+import { sendSOL } from 'cilantro-sdk/wallet';
+
+// Login without automatically setting auth
+const authResult = await login({
+  usernameOrEmail: 'user@example.com',
+  password: 'password123'
+});
+
+// Manually set authentication
+setAuth({ jwt: authResult.data.jwt });
+
+// Make authenticated requests
+const result = await sendSOL('wallet-id', {
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  amountLamports: 1000000000
+});
+```
+
+### CommonJS
+
+```javascript
+const { configure } = require('cilantro-sdk');
+const { sendSOL } = require('cilantro-sdk/wallet');
+
+// Configure with API key
+configure({ apiKey: 'your-api-key' });
+
+// Make authenticated requests
+const result = await sendSOL('wallet-id', { ... });
+```
+
+## Configuration
+
+### SDK Configuration Functions
+
+The SDK provides several functions to manage authentication and settings:
+
+#### `configure(config)`
+
+Initialize the SDK with configuration options including API key, JWT token, or base URL.
+
+```typescript
+import { configure } from 'cilantro-sdk';
+
+configure({
+  apiKey: 'your-api-key',           // Optional: API key for authentication
+  jwt: 'your-jwt-token',             // Optional: JWT token for authentication
+  baseURL: 'https://api.cilantro.gg' // Optional: Custom API base URL
+});
+```
+
+#### `setAuth(auth)`
+
+Update authentication credentials after initialization.
+
+```typescript
+import { setAuth } from 'cilantro-sdk';
+
+setAuth({ 
+  jwt: 'your-jwt-token',
+  apiKey: 'your-api-key' 
+});
+```
+
+#### `clearAuth()`
+
+Clear all authentication credentials.
+
+```typescript
+import { clearAuth } from 'cilantro-sdk';
+
+clearAuth();
+```
+
+### Authentication Types
+
+The SDK supports two types of authentication:
+
+1. **API Key Authentication**: For server-side applications and platform-level access
+2. **JWT Token Authentication**: For user-specific operations after login
+
+You can use either or both simultaneously. The SDK will automatically include the appropriate headers in all requests.
+
+## 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
+- **Admin** (`cilantro-sdk/admin`) - Administrative operations
+- **Auth** (`cilantro-sdk/auth`) - Universal authentication
+
+---
+
+## Platform Module
+
+Platform management and user operations under a platform.
+
+**Note:** For authentication, use the universal `login` function from the `auth` module instead of platform-specific login endpoints.
+
+### `getOwnProfile(options?)`
+
+Retrieve the authenticated platform's own profile information. Requires platform JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerGetOwnProfileResult>`
+
+**Example:**
+```typescript
+import { getOwnProfile } from 'cilantro-sdk/platform';
+
+const profile = await getOwnProfile();
+```
+
+### `updateOwnProfile(updatePlatformDto, options?)`
+
+Update own platform profile. Requires platform JWT token.
+
+**Parameters:**
+- `updatePlatformDto: UpdatePlatformDto` - Platform update data
+  - `firstName?: string` - Platform first name
+  - `lastName?: string` - Platform last name
+  - `email?: string` - Platform email address
+  - `password?: string` - Platform password (minimum 8 characters)
+  - `isActive?: boolean` - Whether the platform account is active
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerUpdateOwnProfileResult>`
+
+**Example:**
+```typescript
+import { updateOwnProfile } from 'cilantro-sdk/platform';
+
+await updateOwnProfile({
+  firstName: 'John',
+  lastName: 'Doe',
+  email: 'newemail@example.com'
+});
+```
+
+### `findOne(id, options?)`
+
+Get platform by ID.
+
+**Parameters:**
+- `id: string` - Platform ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerFindOneResult>`
+
+**Example:**
+```typescript
+import { findOne } from 'cilantro-sdk/platform';
+
+const platform = await findOne('platform-id');
+```
+
+### `remove(id, options?)`
+
+Delete platform.
+
+**Parameters:**
+- `id: string` - Platform ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerRemoveResult>`
+
+### `getUsers(options?)`
+
+Retrieve all users that belong to the authenticated platform. Requires platform JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerGetUsersForPlatformResult>`
+
+**Example:**
+```typescript
+import { getUsers } from 'cilantro-sdk/platform';
+
+const users = await getUsers();
+```
+
+### `createUser(createUserDto, options?)`
+
+Create user under this platform. Requires platform JWT token.
+
+**Parameters:**
+- `createUserDto: CreateUserDto` - User creation data
+  - `username: string` - Username
+  - `email: string` - User email address
+  - `password: string` - User password (minimum 8 characters)
+  - `isActive?: boolean` - Whether the user account is active
+  - `platformId?: string` - Platform ID this user belongs to
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerCreateUserForPlatformResult>`
+
+**Example:**
+```typescript
+import { createUser } from 'cilantro-sdk/platform';
+
+const newUser = await createUser({
+  username: 'johndoe',
+  email: 'user@example.com',
+  password: 'SecurePass123!',
+  isActive: true
+});
+```
+
+### `updateUser(userId, updateUserDto, options?)`
+
+Update user under this platform. Requires platform JWT token.
+
+**Parameters:**
+- `userId: string` - User ID
+- `updateUserDto: UpdateUserDto` - User update data
+  - `username?: string` - Username
+  - `email?: string` - User email address
+  - `password?: string` - User password (minimum 8 characters)
+  - `isActive?: boolean` - Whether the user account is active
+  - `platformId?: string` - Platform ID this user belongs to
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerUpdateUserForPlatformResult>`
+
+**Example:**
+```typescript
+import { updateUser } from 'cilantro-sdk/platform';
+
+await updateUser('user-id', {
+  username: 'newusername',
+  email: 'newemail@example.com'
+});
+```
+
+### `removeUser(userId, options?)`
+
+Delete user under this platform. Requires platform JWT token.
+
+**Parameters:**
+- `userId: string` - User ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerRemoveUserForPlatformResult>`
+
+### `toggleUserActive(userId, options?)`
+
+Toggle user active status under this platform. Requires platform JWT token.
+
+**Parameters:**
+- `userId: string` - User ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerToggleUserActiveForPlatformResult>`
+
+### `getWallets(options?)`
+
+Retrieve all wallets belonging to users under the authenticated platform. Read-only access. Requires platform JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<PlatformControllerGetWalletsForPlatformResult>`
+
+**Example:**
+```typescript
+import { getWallets } from 'cilantro-sdk/platform';
+
+const wallets = await getWallets();
+```
+
+---
+
+## User Module
+
+User account operations.
+
+**Note:** For authentication, use the universal `login` function from the `auth` module instead of user-specific login endpoints.
+
+### `create(createUserDto, options?)`
+
+Register a new user.
+
+**Parameters:**
+- `createUserDto: CreateUserDto` - User creation data
+  - `username: string` - Username
+  - `email: string` - User email address
+  - `password: string` - User password (minimum 8 characters)
+  - `isActive?: boolean` - Whether the user account is active
+  - `platformId?: string` - Platform ID this user belongs to
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<UserControllerCreateResult>`
+
+**Example:**
+```typescript
+import { create } from 'cilantro-sdk/user';
+
+const newUser = await create({
+  username: 'johndoe',
+  email: 'user@example.com',
+  password: 'SecurePass123!'
+});
+```
+
+### `findOne(id, options?)`
+
+Retrieve user profile by ID. Users can only access their own profile. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - User ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<UserControllerFindOneResult>`
+
+**Example:**
+```typescript
+import { findOne } from 'cilantro-sdk/user';
+
+const user = await findOne('user-id');
+```
+
+### `update(id, updateUserDto, options?)`
+
+Update user profile by ID. Users can only update their own profile. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - User ID
+- `updateUserDto: UpdateUserDto` - User update data
+  - `username?: string` - Username
+  - `email?: string` - User email address
+  - `password?: string` - User password (minimum 8 characters)
+  - `isActive?: boolean` - Whether the user account is active
+  - `platformId?: string` - Platform ID this user belongs to
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<UserControllerUpdateResult>`
+
+**Example:**
+```typescript
+import { update } from 'cilantro-sdk/user';
+
+await update('user-id', {
+  username: 'newusername',
+  email: 'newemail@example.com'
+});
+```
+
+---
+
+## Wallet Module
+
+Wallet and blockchain operations on Solana.
+
+### `create(createWalletDto, options?)`
+
+Initialize a new wallet on-chain and store in database. Requires user JWT token.
+
+**Parameters:**
+- `createWalletDto: CreateWalletDto` - Wallet creation data
+  - `walletName: string` - Wallet name
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerCreateResult>`
+
+**Example:**
+```typescript
+import { create } from 'cilantro-sdk/wallet';
+
+const newWallet = await create({
+  walletName: 'My Solana Wallet'
+});
+```
+
+### `findAll(options?)`
+
+Get all wallets for authenticated user. Requires user JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerFindAllResult>`
+
+**Example:**
+```typescript
+import { findAll } from 'cilantro-sdk/wallet';
+
+const wallets = await findAll();
+```
+
+### `getTotalBalance(options?)`
+
+Get total balance across all user wallets. Requires user JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<number>` - Balance in lamports
+
+**Example:**
+```typescript
+import { getTotalBalance } from 'cilantro-sdk/wallet';
+
+const balance = await getTotalBalance();
+console.log(`Total balance: ${balance / 1e9} SOL`);
+```
+
+### `findOne(id, options?)`
+
+Get wallet by ID. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerFindOneResult>`
+
+**Example:**
+```typescript
+import { findOne } from 'cilantro-sdk/wallet';
+
+const wallet = await findOne('wallet-id');
+```
+
+### `update(id, updateWalletDto, options?)`
+
+Update wallet. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `updateWalletDto: UpdateWalletDto` - Wallet update data
+  - `walletName?: string` - Wallet name
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerUpdateResult>`
+
+**Example:**
+```typescript
+import { update } from 'cilantro-sdk/wallet';
+
+await update('wallet-id', {
+  walletName: 'Updated Wallet Name'
+});
+```
+
+### `remove(id, options?)`
+
+Delete wallet. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerRemoveResult>`
+
+### `findByAddress(address, options?)`
+
+Get wallet by address. Requires user JWT token.
+
+**Parameters:**
+- `address: string` - Solana wallet address
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerFindByAddressResult>`
+
+**Example:**
+```typescript
+import { findByAddress } from 'cilantro-sdk/wallet';
+
+const wallet = await findByAddress('DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK');
+```
+
+### `sendSOL(id, sendSolDto, options?)`
+
+Send SOL from wallet to recipient. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `sendSolDto: SendSolDto` - Send SOL data
+  - `recipientAddress: string` - Recipient Solana wallet address
+  - `amountLamports: number` - Amount to send in lamports (1 SOL = 1,000,000,000 lamports), minimum 1
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerSendSOL200>`
+
+**Example:**
+```typescript
+import { sendSOL } from 'cilantro-sdk/wallet';
+
+const result = await sendSOL('wallet-id', {
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  amountLamports: 1000000000 // 1 SOL
+});
+```
+
+### `sendSPL(id, sendSplDto, options?)`
+
+Send SPL tokens from wallet to recipient. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `sendSplDto: SendSplDto` - Send SPL data
+  - `mintAddress: string` - SPL token mint address
+  - `recipientAddress: string` - Recipient Solana wallet address
+  - `amount: number` - Token amount to send (in human-readable units, e.g., 100 for 100 tokens). Decimals are automatically fetched from on-chain. Minimum 0
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerSendSPL200>`
+
+**Example:**
+```typescript
+import { sendSPL } from 'cilantro-sdk/wallet';
+
+const result = await sendSPL('wallet-id', {
+  mintAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
+  recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+  amount: 100
+});
+```
+
+### `mintNFT(id, mintNftDto, options?)`
+
+Mint NFT using Metaplex via CPI (Advanced). Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `mintNftDto: MintNftDto` - Mint NFT data
+  - `metaplexInstructionData: string` - Metaplex instruction data encoded in base64
+  - `accounts: AccountMeta[]` - Array of account metadata for the transaction
+    - `pubkey: string` - Account public key
+    - `isWritable: boolean` - Whether the account is writable
+    - `isSigner: boolean` - Whether the account is a signer
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerMintNFT200>`
+
+### `mintNFTSimple(id, mintNftSimpleDto, options?)`
+
+Mint NFT with metadata - handles all logic internally using Metaplex Core. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `mintNftSimpleDto: MintNftSimpleDto` - Mint NFT simple data
+  - `name: string` - NFT name
+  - `symbol: string` - NFT symbol
+  - `description: string` - NFT description
+  - `imageUri: string` - Image URI (IPFS, Arweave, or HTTP URL)
+  - `externalUrl?: string` - External URL for the NFT
+  - `attributes?: NftAttribute[]` - NFT attributes/traits
+    - `trait_type: string` - Trait type/name
+    - `value: string` - Trait value
+  - `sellerFeeBasisPoints?: number` - Seller fee basis points (royalties: 100 = 1%), default 0, min 0, max 10000
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerMintNFTSimple200>`
+
+**Example:**
+```typescript
+import { mintNFTSimple } from 'cilantro-sdk/wallet';
+
+const result = await mintNFTSimple('wallet-id', {
+  name: 'My Awesome NFT',
+  symbol: 'MNFT',
+  description: 'A unique digital collectible',
+  imageUri: 'https://arweave.net/abc123...',
+  externalUrl: 'https://myproject.com/nft/1',
+  attributes: [
+    { trait_type: 'Color', value: 'Blue' },
+    { trait_type: 'Rarity', value: 'Legendary' }
+  ],
+  sellerFeeBasisPoints: 500 // 5% royalties
+});
+```
+
+### `mintToken(id, mintTokenDto, options?)`
+
+Mint fungible token (SPL or Token-2022) with initial supply to wallet. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `mintTokenDto: MintTokenDto` - Mint token data
+  - `name: string` - Token name
+  - `symbol: string` - Token symbol
+  - `decimals: number` - Number of decimal places, min 0, max 9
+  - `initialSupply: number` - Initial supply to mint to the wallet
+  - `tokenStandard: 'spl' | 'token-2022'` - Token standard to use
+  - `description?: string` - Token description (used for Token-2022 metadata)
+  - `imageUri?: string` - Image URI for token (used for Token-2022 metadata)
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerMintToken200>`
+
+**Example:**
+```typescript
+import { mintToken } from 'cilantro-sdk/wallet';
+
+const result = await mintToken('wallet-id', {
+  name: 'My Token',
+  symbol: 'MTK',
+  decimals: 9,
+  initialSupply: 1000000,
+  tokenStandard: 'spl'
+});
+```
+
+### `sendTransaction(id, sendTransactionDto, options?)`
+
+Execute arbitrary transaction via CPI to any Solana program. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `sendTransactionDto: SendTransactionDto` - Transaction data
+  - `targetProgramId: string` - Target program public key to execute instruction on
+  - `instructionData: string` - Instruction data encoded in base64
+  - `accounts: AccountMeta[]` - Array of account metadata for the transaction
+    - `pubkey: string` - Account public key
+    - `isWritable: boolean` - Whether the account is writable
+    - `isSigner: boolean` - Whether the account is a signer
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletControllerSendTransaction200>`
+
+**Example:**
+```typescript
+import { sendTransaction } from 'cilantro-sdk/wallet';
+
+const result = await sendTransaction('wallet-id', {
+  targetProgramId: 'ProgramIdHere...',
+  instructionData: 'base64EncodedData...',
+  accounts: [
+    {
+      pubkey: 'AccountPubkey...',
+      isWritable: true,
+      isSigner: false
+    }
+  ]
+});
+```
+
+### `getAssets(id, params?, options?)`
+
+Get all assets for a wallet (cached with auto-refresh). Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `params?: WalletControllerGetWalletAssetsParams` - Query parameters
+  - `assetType?: 'NFT' | 'SPL_TOKEN' | 'SOL'` - Filter by asset type
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletAssetResponseDto[]>`
+
+**Example:**
+```typescript
+import { getAssets } from 'cilantro-sdk/wallet';
+
+const assets = await getAssets('wallet-id', {
+  assetType: 'NFT'
+});
+```
+
+### `syncAssets(id, options?)`
+
+Force sync wallet balance and assets from blockchain immediately. Requires user JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<WalletAssetResponseDto[]>`
+
+**Example:**
+```typescript
+import { syncAssets } from 'cilantro-sdk/wallet';
+
+const assets = await syncAssets('wallet-id');
+```
+
+---
+
+## Admin Module
+
+Administrative operations for managing the system. All admin endpoints require admin JWT token.
+
+**Note:** For authentication, use the universal `login` function from the `auth` module instead of admin-specific login endpoints.
+
+### `create(createAdminDto, options?)`
+
+Register a new admin.
+
+**Parameters:**
+- `createAdminDto: CreateAdminDto` - Admin creation data
+  - `username: string` - Admin username
+  - `email: string` - Admin email address
+  - `password: string` - Admin password (min 8 characters)
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerCreateResult>`
+
+**Example:**
+```typescript
+import { create } from 'cilantro-sdk/admin';
+
+const newAdmin = await create({
+  username: 'admin',
+  email: 'admin@example.com',
+  password: 'SecurePass123!'
+});
+```
+
+### `findAll(params?, options?)`
+
+Get all admins. Requires admin JWT token.
+
+**Parameters:**
+- `params?: AdminControllerFindAllParams` - Query parameters
+  - `page?: number` - Page number for pagination
+  - `limit?: number` - Number of results per page
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerFindAllResult>`
+
+**Example:**
+```typescript
+import { findAll } from 'cilantro-sdk/admin';
+
+const admins = await findAll({ page: 1, limit: 10 });
+```
+
+### `getCurrentAdmin(options?)`
+
+Get current admin profile. Requires admin JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerGetCurrentAdminResult>`
+
+### `getAllApiKeys(options?)`
+
+Get all platform API keys. Requires admin JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerGetAllApiKeysResult>`
+
+### `getPlatformApiKey(platformId, options?)`
+
+Get specific platform API key. Requires admin JWT token.
+
+**Parameters:**
+- `platformId: string` - Platform ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerGetplatformApiKeyResult>`
+
+### `findOne(id, options?)`
+
+Get admin by ID. Requires admin JWT token.
+
+**Parameters:**
+- `id: string` - Admin ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerFindOneResult>`
+
+### `update(id, updateAdminDto, options?)`
+
+Update admin. Requires admin JWT token.
+
+**Parameters:**
+- `id: string` - Admin ID
+- `updateAdminDto: UpdateAdminDto` - Admin update data
+  - `username?: string` - Admin username
+  - `email?: string` - Admin email address
+  - `password?: string` - New password (min 8 characters)
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerUpdateResult>`
+
+### `remove(id, options?)`
+
+Delete admin. Requires admin JWT token.
+
+**Parameters:**
+- `id: string` - Admin ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerRemoveResult>`
+
+### `toggleActive(id, options?)`
+
+Toggle admin active status. Requires admin JWT token.
+
+**Parameters:**
+- `id: string` - Admin ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerToggleActiveResult>`
+
+### `findAllPlatforms(params?, options?)`
+
+View all platforms. Requires admin JWT token.
+
+**Parameters:**
+- `params?: AdminControllerFindAllPlatformsParams` - Query parameters
+  - `page?: number` - Page number for pagination
+  - `limit?: number` - Number of results per page
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerFindAllPlatformsResult>`
+
+**Example:**
+```typescript
+import { findAllPlatforms } from 'cilantro-sdk/admin';
+
+const platforms = await findAllPlatforms({ page: 1, limit: 20 });
+```
+
+### `findOnePlatform(id, options?)`
+
+View platform details. Requires admin JWT token.
+
+**Parameters:**
+- `id: string` - Platform ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerFindOnePlatformResult>`
+
+### `updatePlatform(id, updatePlatformDto, options?)`
+
+Update platform. Requires admin JWT token.
+
+**Parameters:**
+- `id: string` - Platform ID
+- `updatePlatformDto: UpdatePlatformDto` - Platform update data
+  - `firstName?: string` - Platform first name
+  - `lastName?: string` - Platform last name
+  - `email?: string` - Platform email address
+  - `password?: string` - Platform password (minimum 8 characters)
+  - `isActive?: boolean` - Whether the platform account is active
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerUpdatePlatformResult>`
+
+### `removePlatform(id, options?)`
+
+Delete platform. Requires admin JWT token.
+
+**Parameters:**
+- `id: string` - Platform ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerRemovePlatformResult>`
+
+### `findAllUsers(options?)`
+
+Retrieve all users in the system. Admin has read-only access to user data. Requires admin JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerFindAllUsersResult>`
+
+### `findOneUser(id, options?)`
+
+View user details. Requires admin JWT token.
+
+**Parameters:**
+- `id: string` - User ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerFindOneUserResult>`
+
+### `findAllWallets(options?)`
+
+Retrieve all wallets in the system. Admin has read-only access to wallet data. Requires admin JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerFindAllWalletsResult>`
+
+### `findWalletsByUserId(userId, options?)`
+
+View all wallets for a specific user (read-only). Requires admin JWT token.
+
+**Parameters:**
+- `userId: string` - User ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerFindWalletsByUserIdResult>`
+
+### `findOneWallet(id, options?)`
+
+View wallet details (read-only). Requires admin JWT token.
+
+**Parameters:**
+- `id: string` - Wallet ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerFindOneWalletResult>`
+
+### `getOverviewAnalytics(options?)`
+
+Get dashboard overview analytics. Requires admin JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerGetOverviewAnalyticsResult>`
+
+### `getWalletAnalytics(options?)`
+
+Get wallet analytics and statistics. Requires admin JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerGetWalletAnalyticsResult>`
+
+### `getRecentActivity(options?)`
+
+Get recent activity across all entities. Requires admin JWT token.
+
+**Parameters:**
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerGetRecentActivityResult>`
+
+### `regenerateApiKey(platformId, options?)`
+
+Regenerate platform API key. Requires admin JWT token.
+
+**Parameters:**
+- `platformId: string` - Platform ID
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerRegenerateApiKeyResult>`
+
+### `getPlatformsWithUsers(params?, options?)`
+
+Get platforms with their user counts. Requires admin JWT token.
+
+**Parameters:**
+- `params?: AdminControllerGetPlatformsWithUsersParams` - Query parameters
+  - `page?: number` - Page number for pagination
+  - `limit?: number` - Number of results per page
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerGetPlatformsWithUsersResult>`
+
+**Example:**
+```typescript
+import { getPlatformsWithUsers } from 'cilantro-sdk/admin';
+
+const data = await getPlatformsWithUsers({ page: 1, limit: 10 });
+```
+
+### `getUsersWithWallets(params?, options?)`
+
+Get users with their wallet counts and balances. Requires admin JWT token.
+
+**Parameters:**
+- `params?: AdminControllerGetUsersWithWalletsParams` - Query parameters
+  - `page?: number` - Page number for pagination
+  - `limit?: number` - Number of results per page
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerGetUsersWithWalletsResult>`
+
+**Example:**
+```typescript
+import { getUsersWithWallets } from 'cilantro-sdk/admin';
+
+const data = await getUsersWithWallets({ page: 1, limit: 10 });
+```
+
+### `getWalletAssets(params?, options?)`
+
+Get all wallet assets with filtering. Requires admin JWT token.
+
+**Parameters:**
+- `params?: AdminControllerGetWalletAssetsParams` - Query parameters
+  - `assetType?: 'NFT' | 'SPL_TOKEN' | 'SOL'` - Filter by asset type
+  - `page?: number` - Page number for pagination
+  - `limit?: number` - Number of results per page
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AdminControllerGetWalletAssetsResult>`
+
+**Example:**
+```typescript
+import { getWalletAssets } from 'cilantro-sdk/admin';
+
+const assets = await getWalletAssets({
+  assetType: 'NFT',
+  page: 1,
+  limit: 50
+});
+```
+
+---
+
+## Auth Module
+
+Universal authentication operations. **This is the only authentication endpoint you should use** - it works for admin, platform, and user authentication.
+
+### `login(commonLoginDto, options?)`
+
+Authenticate as admin, platform, or user. Returns user type and appropriate JWT token. This is the universal login endpoint that replaces the individual login endpoints in the user, platform, and admin modules.
+
+**Parameters:**
+- `commonLoginDto: CommonLoginDto` - Login credentials
+  - `usernameOrEmail: string` - Username or email address
+  - `password: string` - Password
+- `options?` - Optional axios request configuration
+
+**Returns:** `Promise<AuthControllerLogin200>` - Contains `data` object with:
+  - `userType?: 'admin' | 'platform' | 'user'` - Type of authenticated user
+  - `jwt?: string` - JWT token for authenticated user
+  - `user?: AuthControllerLogin200DataUser` - User data object
+  - `apiKey?: string` - API key (only for platform/user)
+
+**Example:**
+```typescript
+import { login } from 'cilantro-sdk/auth';
+
+const result = await login({
+  usernameOrEmail: 'user@example.com',
+  password: 'password123'
+});
+
+console.log(result.data.userType); // 'admin' | 'platform' | 'user'
+console.log(result.data.jwt); // JWT token
+if (result.data.apiKey) {
+  console.log(result.data.apiKey); // API key (for platform/user)
+}
+```
+
+---
+
+## TypeScript Support
+
+The SDK is written in TypeScript and includes full type definitions. All types are exported from the main package:
+
+```typescript
+import type {
+  CreatePlatformDto,
+  UpdatePlatformDto,
+  CreateUserDto,
+  UpdateUserDto,
+  CreateWalletDto,
+  UpdateWalletDto,
+  SendSolDto,
+  SendSplDto,
+  MintNftSimpleDto,
+  MintTokenDto,
+  SendTransactionDto,
+  WalletAssetResponseDto,
+  AccountMeta,
+  NftAttribute,
+  LoginPlatformDto,
+  LoginUserDto,
+  LoginAdminDto,
+  CommonLoginDto,
+  // ... and many more
+} from 'cilantro-sdk';
+```
+
+---
+
+## Authentication
+
+The SDK provides automatic authentication handling for both JWT tokens and API keys. After logging in, the SDK will automatically include the appropriate authentication headers in all subsequent requests.
+
+### Automatic Authentication (Recommended)
+
+The easiest way to authenticate is to use the `loginAndSetAuth` function, which automatically handles login and authentication setup:
+
+```typescript
+import { loginAndSetAuth } from 'cilantro-sdk/auth';
+import { findAll } from 'cilantro-sdk/wallet';
+
+// Login and set authentication automatically
+await loginAndSetAuth({
+  usernameOrEmail: 'user@example.com',
+  password: 'password123'
+});
+
+// Now all subsequent requests will include the authentication headers
+const wallets = await findAll();
+```
+
+### Manual Authentication
+
+You can manually set authentication credentials using the configuration functions:
+
+#### JWT Token Authentication
+
+```typescript
+import { setAuth } from 'cilantro-sdk';
+import { login } from 'cilantro-sdk/auth';
+
+// Login first
+const loginResult = await login({
+  usernameOrEmail: 'admin@example.com',
+  password: 'password123'
+});
+
+// Manually set JWT token
+setAuth({ jwt: loginResult.data.jwt });
+
+// All subsequent requests will include: Authorization: Bearer <token>
+```
+
+#### API Key Authentication
+
+For platform-level authentication, you can use API keys instead of JWT tokens:
+
+```typescript
+import { configure } from 'cilantro-sdk';
+
+// Set API key (received from platform settings)
+configure({ apiKey: 'your-api-key-here' });
+
+// All subsequent requests will include: X-API-Key: <api-key>
+```
+
+#### Using Both JWT and API Key
+
+The SDK supports using both JWT tokens and API keys simultaneously:
+
+```typescript
+import { setAuth } from 'cilantro-sdk';
+
+setAuth({ 
+  jwt: 'your-jwt-token',
+  apiKey: 'your-api-key'
+});
+
+// Both headers will be included in requests
+```
+
+### Authentication Management
+
+The SDK provides configuration functions for managing authentication:
+
+```typescript
+import { configure, setAuth, clearAuth } from 'cilantro-sdk';
+
+// Configure with both auth and settings
+configure({
+  jwt: 'your-jwt-token',
+  apiKey: 'your-api-key',
+  baseURL: 'https://api.cilantro.gg' // optional
+});
+
+// Or just update authentication
+setAuth({ 
+  jwt: 'your-jwt-token',
+  apiKey: 'your-api-key'
+});
+
+// Clear all authentication
+clearAuth(); // Removes both JWT token and API key
+```
+
+### Complete Authentication Example
+
+```typescript
+import { loginAndSetAuth } from 'cilantro-sdk/auth';
+import { clearAuth } from 'cilantro-sdk';
+import { findAll } from 'cilantro-sdk/wallet';
+import { getCurrentAdmin } from 'cilantro-sdk/admin';
+
+async function authenticateAndFetchData() {
+  try {
+    // Login and set authentication automatically
+    const loginResult = await loginAndSetAuth({
+      usernameOrEmail: 'user@example.com',
+      password: 'password123'
+    });
+    
+    console.log('Logged in as:', loginResult.data.userType);
+    
+    // Now you can make authenticated requests
+    const wallets = await findAll();
+    console.log('User wallets:', wallets);
+    
+    // Logout (clear authentication)
+    clearAuth();
+  } catch (error) {
+    console.error('Authentication failed:', error);
+  }
+}
+```
+
+### Advanced: Custom Base URL and Configuration
+
+You can customize the SDK configuration including base URL:
+
+```typescript
+import { configure } from 'cilantro-sdk';
+
+// Configure custom base URL and authentication
+configure({
+  apiKey: 'your-api-key',
+  baseURL: 'https://custom-api.example.com'
+});
+
+// Or update just the base URL
+configure({
+  baseURL: 'https://staging-api.example.com'
+});
+```
+
+---
+
+## Error Handling
+
+All API functions return promises that may reject with axios errors. You should handle errors appropriately:
+
+```typescript
+import { sendSOL } from 'cilantro-sdk/wallet';
+
+try {
+  const result = await sendSOL('wallet-id', {
+    recipientAddress: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
+    amountLamports: 1000000000
+  });
+  console.log('Transaction successful:', result);
+} catch (error) {
+  if (error.response) {
+    // The request was made and the server responded with a status code
+    // that falls out of the range of 2xx
+    console.error('Error status:', error.response.status);
+    console.error('Error data:', error.response.data);
+  } else if (error.request) {
+    // The request was made but no response was received
+    console.error('No response received:', error.request);
+  } else {
+    // Something happened in setting up the request that triggered an Error
+    console.error('Error:', error.message);
+  }
+}
+```
+
+---
+
+## API Reference
+
+### Configuration Functions
+
+```typescript
+// Configure SDK with authentication and settings
+configure(config: { 
+  apiKey?: string;
+  jwt?: string;
+  baseURL?: string;
+}): void
+
+// Update authentication credentials
+setAuth(auth: { 
+  jwt?: string;
+  apiKey?: string;
+}): void
+
+// Clear all authentication
+clearAuth(): void
+```
+
+### Authentication Functions
+
+```typescript
+// Login with credentials
+login(credentials: CommonLoginDto, options?): Promise<AuthControllerLoginResult>
+
+// Login and automatically set authentication (convenience function)
+loginAndSetAuth(credentials: CommonLoginDto, options?): Promise<AuthControllerLoginResult>
+```
+
+For complete API documentation of all endpoints, see the type definitions or refer to the inline documentation in your IDE.
+
+---
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+This will:
+- Generate API client code from OpenAPI specification
+- Compile TypeScript to CommonJS (`.cjs`) and ES Modules (`.mjs`)
+- Generate TypeScript declaration files (`.d.ts`)
+
+### Publishing
+
+```bash
+npm publish
+```
+
+The `prepublishOnly` script will automatically build the package before publishing.
+
+---
+
+## License
+
+ISC