@kasufinance/kasu-sdk 1.0.4 → 2.1.0

package/.claude/settings.local.json

@@ -0,0 +1,15 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx tsc:*)",
+      "Bash(npm run build:*)",
+      "Bash(npm test:*)",
+      "Bash(find:*)",
+      "Bash(npx jest:*)",
+      "Bash(npm run rollup-build:*)",
+      "Bash(npm publish:*)",
+      "Bash(npm whoami:*)",
+      "Bash(npm config get:*)"
+    ]
+  }
+}

package/CLAUDE.md

@@ -0,0 +1,410 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+`@kasufinance/kasu-sdk` is the shared TypeScript SDK for Kasu frontends. It provides:
+- Contract wrappers (ethers.js v5) for all Kasu smart contracts
+- Subgraph queries for pool data, user positions, and locking info
+- Directus CMS integration for pool descriptions and KPIs
+- Portfolio calculations (APY, yield, rewards)
+- Support for both Full (Base) and Lite (XDC, Plume) deployments
+
+**Current Version:** 2.0.0 (added Lite deployment support)
+
+## Build Commands
+
+```bash
+npm install          # Install dependencies
+npm run build-tc     # Regenerate typechain factories from ABIs
+npm run build        # Lint + TypeScript compile
+npm run rollup-build # Build distribution bundles
+npm test             # Run Jest tests
+npm run lint         # Fix lint issues
+```
+
+## Architecture
+
+### Directory Structure
+
+```
+src/
+├── contracts/           # Typechain-generated contract bindings
+│   ├── factories/       # Contract factory classes
+│   └── *.ts             # Contract type definitions
+├── services/
+│   ├── DataService/     # Pool data, subgraph queries, Directus
+│   ├── Locking/         # KSU locking, loyalty levels, rewards
+│   ├── Portfolio/       # User portfolio, balances, yields
+│   ├── Swapper/         # Token swap helpers
+│   └── UserLending/     # Deposit/withdraw, transaction history
+├── utils/
+│   └── deployment-mode.ts  # Lite/Full mode detection utility
+├── index.ts             # Main exports (KasuSdk class)
+└── sdk-config.ts        # Configuration types and SdkConfig class
+```
+
+### Key Files
+
+| File | Purpose |
+|------|---------|
+| `src/sdk-config.ts` | `SdkConfig` class and `ContractAddresses` interface |
+| `src/index.ts` | `KasuSdk` main class, exports all services |
+| `src/services/Locking/locking.ts` | KSU locking service with Lite mode guards |
+| `src/services/Portfolio/portfolio.ts` | Portfolio aggregation service |
+| `src/services/DataService/data-service.ts` | Subgraph + Directus data fetching |
+| `src/services/UserLending/user-lending.ts` | User deposit/withdraw operations |
+| `src/utils/deployment-mode.ts` | `isLiteDeployment()` utility |
+
+---
+
+## Multi-Chain Support
+
+### Supported Networks
+
+| Network | Chain ID | Deployment Type | Status | Subgraph |
+|---------|----------|-----------------|--------|----------|
+| Base Mainnet | 8453 | Full | Production | `kasu-base/v1.0.13` |
+| XDC Mainnet | 50 | Lite | WIP (frontend pending pools) | `kasu-xdc/v1.0.0` |
+| Plume Mainnet | 98866 | Lite | Future | `kasu-plume/prod` |
+
+### Full vs Lite Deployments
+
+**Full Deployment** (Base mainnet):
+- KSU token, locking, loyalty rewards enabled
+- `KSUToken` and `KasuNFTs` contract addresses required
+- `isLiteDeployment: false`
+
+**Lite Deployment** (XDC, Plume):
+- No KSU token or locking features
+- KYC/KYB deposits still work
+- `KSUToken` and `KasuNFTs` are `undefined`
+- `isLiteDeployment: true`
+- Locking methods return empty/zero values
+- Transaction methods throw descriptive errors
+
+### Feature Matrix
+
+| Feature | Full (Base) | Lite (XDC, Plume) |
+|---------|-------------|-------------------|
+| KSU Token | Yes | No |
+| KSU Locking | Yes | No |
+| Loyalty Levels | Yes | No |
+| APY Bonus | Yes | No |
+| NFT Boosts | Yes | No |
+| KYC/KYB Deposits | Yes | Yes |
+| Lending Pools | Yes | Yes |
+| Fixed Term Deposits | Yes | Yes |
+| Pool Descriptions | Yes (Directus) | Yes (Directus) |
+
+---
+
+## SDK Configuration
+
+### ContractAddresses Interface
+
+```typescript
+export interface ContractAddresses {
+    /** Only on Full deployments (Base) */
+    KSUToken?: string;
+    /** Only on Full deployments */
+    KasuNFTs?: string;
+
+    // Always required
+    IKSULocking: string;
+    IKSULockBonus: string;
+    UserManager: string;
+    LendingPoolManager: string;
+    KasuAllowList: string;
+    SystemVariables: string;
+    UserLoyaltyRewards: string;
+    KsuPrice: string;
+    ClearingCoordinator: string;
+    ExternalTVL: string;
+}
+```
+
+### SdkConfigOptions Interface
+
+```typescript
+export interface SdkConfigOptions {
+    subgraphUrl: string;
+    contracts: ContractAddresses;
+    directusUrl: string;
+    UNUSED_LENDING_POOL_IDS: string[];
+    isLiteDeployment?: boolean;  // default: false
+}
+```
+
+---
+
+## Contract Addresses by Chain
+
+### Base Mainnet (Chain ID: 8453)
+
+```
+USDC:                 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
+KSUToken:             0x... (see kasu-fe-next config)
+KSULocking:           0x...
+LendingPoolManager:   0x...
+UserManager:          0x...
+KasuAllowList:        0x...
+SystemVariables:      0x...
+KsuPrice:             0x...
+UserLoyaltyRewards:   0x...
+ClearingCoordinator:  0x...
+KasuNFTs:             0x...
+ExternalTVL:          0x...
+```
+
+See `kasu-fe-next/src/config/sdk/addresses-base-mainnet.json` for full addresses.
+
+### XDC Mainnet (Chain ID: 50)
+
+```
+USDC:                 0xfa2958cb79b0491cc627c1557f441ef849ca8eb1
+KasuController:       0xe81D1C0E031da0E357928ED19aA1EbF6A2f5C904
+KSULocking:           0x7fF469f8c5fba92A9051B8D28794CBb891760e81
+KsuPrice:             0x666b589933965bF8B378eD973f0404b6cae0eb52
+SystemVariables:      0x34d17c9DD1f31Fb34757DE923EC083601d0eDFFe
+LendingPoolManager:   0xa46143db92aBe5bB1f61d13d8C1cCd50fc40Ca10
+UserManager:          0x9b57dF89e59235f0481A5Fae942302c8831e1B81
+KasuAllowList:        0x32c1Ff5FbBe6D28503ddc46E5001C0D13d6E9B2A
+ClearingCoordinator:  0xAF0a66953Eba1c5353eB7425b398B213Bb2c6121
+UserLoyaltyRewards:   0xb95834C5610A178be9065Dd1EF78258D29879CDb
+ExternalTVL:          0xCCB4156964377CF36441f3775A2A800dbeCB8094
+FixedTermDeposit:     0xD498baBCF8D0eC89E129fB874DAB9e4C35cD2a52
+```
+
+See `kasu-fe-next/src/config/sdk/addresses-xdc.json` for full addresses.
+
+### Subgraph URLs
+
+| Chain | URL |
+|-------|-----|
+| Base | `https://api.goldsky.com/api/public/project_cmgzlpxm300765np2a19421om/subgraphs/kasu-base/v1.0.13/gn` |
+| XDC | `https://api.goldsky.com/api/public/project_cmgzlpxm300765np2a19421om/subgraphs/kasu-xdc/v1.0.0/gn` |
+| Plume | `https://api.goldsky.com/api/public/project_cmgzlpxm300765np2a19421om/subgraphs/kasu-plume/prod` |
+
+---
+
+## Lite Mode Implementation
+
+### Guard Pattern
+
+When modifying services, check for Lite mode before accessing KSU-related functionality:
+
+```typescript
+// In service constructor
+this._isLiteDeployment = config.isLiteDeployment;
+
+// In methods that return data (silent fallback)
+async getUserLockedAmount(address: string): Promise<string> {
+    if (this._isLiteDeployment) {
+        return '0';  // Return safe default
+    }
+    // ... normal implementation
+}
+
+// For transaction methods (throw error)
+async lockTokens(amount: BigNumber): Promise<TransactionResponse> {
+    if (this._isLiteDeployment) {
+        throw new Error('Locking is not available on Lite deployments');
+    }
+    // ... normal implementation
+}
+```
+
+### Lite Mode Behavior by Service
+
+**Locking Service** (47+ guard clauses):
+| Method | Lite Behavior |
+|--------|---------------|
+| `lockKSUTokens()` | Throws error |
+| `unlockKSU()` | Throws error |
+| `getUserLocks()` | Returns `[]` |
+| `getUserTotalLockedAmount()` | Returns `'0'` |
+| `getLoyaltyLevelAndApyBonusFromRatio()` | Returns `{ loyaltyLevel: 0, apyBonus: 0 }` |
+| `getClaimableRewards()` | Returns `BigNumber.from(0)` |
+| `getAvailableKsuBonus()` | Returns `'0'` |
+| `getKasuEpochTokenPrice()` | Returns `{ price: 0, decimals: 18 }` |
+
+**Portfolio Service** (6+ guard clauses):
+| Method | Lite Behavior |
+|--------|---------------|
+| `getUserNfts()` | Returns `[]` |
+| `getPortfolioRewards()` | Returns zeros for KSU-related fields |
+
+**UserLending Service** (0 guard clauses):
+- All lending operations work identically on all chains
+- KYC/KYB deposit flows supported
+
+**DataService** (0 guard clauses):
+- Pool data queries are chain-agnostic
+- Works on any subgraph
+
+**Swapper Service** (0 guard clauses):
+- Swap operations identical across chains
+
+---
+
+## Current Integration Status
+
+### SDK (This Repository)
+
+| Task | Status |
+|------|--------|
+| `isLiteDeployment` config flag | Done |
+| Optional `KSUToken` contract address | Done |
+| Optional `KasuNFTs` contract address | Done |
+| Locking service Lite mode guards | Done |
+| Portfolio service Lite mode guards | Done |
+| README multi-chain documentation | Done |
+
+### Frontend (kasu-fe-next)
+
+| Task | Status |
+|------|--------|
+| Chain configuration system | Done |
+| Chain context provider | Done |
+| Chain switcher UI | Done |
+| SDK provider chain awareness | Done |
+| Conditional UI rendering | Done |
+| SWR cache keys with chainId | Partial |
+| Block explorer links | TODO |
+
+### Blocking Issue: XDC Pools
+
+XDC chain integration in the frontend is blocked because:
+1. No lending pools are deployed on XDC yet
+2. Server-side data fetching always uses Base (DEFAULT_CHAIN_ID)
+3. Frontend shows "Coming Soon to XDC" when user switches to XDC
+
+**To enable XDC:**
+1. Deploy lending pools via kasu-contracts
+2. Remove `ChainAwareContent` wrapper in `kasu-fe-next/src/app/lending/()/layout.tsx`
+3. Test deposit/withdraw flows with Nexera KYC
+
+---
+
+## Contract ABIs
+
+ABIs are stored in `abis/*.json`. When contract interfaces change:
+
+1. Copy new ABI JSON files to `abis/`
+2. Run `npm run build-tc` to regenerate typechain bindings
+3. Update service code if method signatures changed
+
+### ABI Files (21 total)
+
+```
+Core Lending:
+├── ILendingPoolManager.abi.json
+├── ILendingPool.abi.json
+├── ILendingPoolTranche.abi.json
+├── ILendingPoolFactory.abi.json
+
+KSU Locking/Rewards:
+├── IKSULocking.abi.json
+├── KSULockBonus.abi.json
+├── IUserLoyaltyRewards.abi.json
+├── IKsuPrice.abi.json
+
+User Management:
+├── IUserManager.abi.json
+├── IKasuAllowList.abi.json
+
+System:
+├── ISystemVariables.abi.json
+├── IClearingCoordinator.abi.json
+
+Full Deployments Only:
+├── IKasuNFTs.abi.json
+
+Other:
+├── IERC20Metadata.abi.json
+├── Swapper.abi.json
+├── KasuPoolExternalTVL.abi.json
+└── IKasuController.abi.json
+```
+
+---
+
+## Testing
+
+```bash
+npm test                    # Run all tests
+npm test -- --watch         # Watch mode
+npm test -- --coverage      # Coverage report
+```
+
+Tests use Jest. Test files are in `src/tests/`.
+
+---
+
+## Publishing
+
+Version is in `package.json`. The SDK is published to npm as `@kasufinance/kasu-sdk`.
+
+```bash
+# Before publishing:
+npm run build-tc     # Regenerate typechain
+npm run build        # Type-check + lint
+npm run rollup-build # Build bundles
+npm test             # Run tests
+
+# Publish:
+npm version patch|minor|major
+npm publish
+```
+
+---
+
+## Related Repositories
+
+| Repository | Path | Relationship |
+|------------|------|--------------|
+| `kasu-fe-next` | `/Users/kirilivanov/DEV/Kasu/kasu-fe-next` | Main consumer - imports SDK for all contract/data interactions |
+| `kasu-contracts` | `/Users/kirilivanov/DEV/Kasu/kasu-contracts` | Source of ABIs and contract logic |
+| `kasu-subgraph` | `/Users/kirilivanov/DEV/Kasu/kasu-subgraph` | Source of subgraph schema and queries |
+
+---
+
+## Adding a New Chain
+
+1. **Determine deployment type**: Full (has KSU token) or Lite (no KSU token)
+
+2. **Deploy contracts** via kasu-contracts:
+   - For Lite: Deploy all contracts except KSU, KasuNFTs
+   - Record addresses in `.openzeppelin/<chain>-addresses.json`
+
+3. **Deploy subgraph** via kasu-subgraph:
+   - Create chain config in `src/config/<chain>.json`
+   - Deploy to Goldsky
+   - Note subgraph URL
+
+4. **No SDK changes needed** if contracts match existing ABIs:
+   - SDK already supports `isLiteDeployment` flag
+   - Just configure frontend with new chain config
+
+5. **Frontend changes** (in kasu-fe-next):
+   - Add chain to `src/config/chains/index.ts`
+   - Add contract addresses to `src/config/sdk/addresses-<chain>.json`
+   - Chain switcher will automatically include new chain
+
+6. **If new ABIs needed**:
+   - Copy ABIs to `abis/`
+   - Run `npm run build-tc`
+   - Update services if signatures changed
+   - Publish new SDK version
+
+---
+
+## XDC Multisig Addresses
+
+| Role | Address |
+|------|---------|
+| Kasu Multisig | `0x1E9ed74140DA7B81a1612AA5df33F98Eb5Ea0B4D` |
+| Pool Manager Multisig | `0x21567eA21b14BEd14657e9725C2FE11C7be942B1` |
+| Pool Admin Multisig | `0x880Aa2d6eEC5bD573059444cF1b3C09658f8c112` |

package/README.md

@@ -33,9 +33,92 @@ on it (or install it alongside the SDK).
   `Provider` for read-only usage. The SDK does not create its own provider,
   so you are free to reuse whatever the dapp already uses.
 
-## Configuring the SDK
+## Integrator Quick Start
 
-The `SdkConfig` object wires the SDK to the right contracts and backends:
+The simplest way to use the SDK is via the `Kasu` facade, which bundles built-in
+chain configs and provides three domain-specific interfaces:
+
+```ts
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { Kasu } from '@kasufinance/kasu-sdk';
+
+const provider = new JsonRpcProvider('https://mainnet.base.org');
+const kasu = Kasu.create({ chain: 'base', signerOrProvider: provider });
+
+// 1. Browse lending strategies
+const strategies = await kasu.strategies.getAll();
+for (const s of strategies) {
+  console.log(s.name, `${(s.apy * 100).toFixed(1)}% APY`, `TVL: $${s.tvl.total}`);
+}
+
+// 2. Get a single strategy and check deposit limits
+const strategy = await kasu.strategies.getById(poolId);
+const limits = kasu.strategies.calculateDepositLimits(strategy.tranches[0]);
+console.log(`Min: ${limits.min} USDC, Max: ${limits.max} USDC`);
+
+// 3. Deposit (requires a Signer and KYC signature from Nexera)
+const kycParams = kasu.deposits.buildKycParams('0xYourAddress...');
+// ... obtain kycSignature via your backend + Nexera signing service ...
+const tx = await kasu.deposits.deposit({
+  poolId: strategy.id,
+  trancheId: strategy.tranches[0].id,
+  amount: parseUnits('1000', 6), // 1000 USDC
+  kycSignature: { blockExpiration, signature },
+});
+
+// 4. Check user positions and yield
+const positions = await kasu.portfolio.getPositions('0xUserAddress...');
+console.log(positions.summary.current.totalLendingPoolInvestments);
+
+// 5. Withdraw
+const withdrawTx = await kasu.deposits.withdraw({
+  poolId: strategy.id,
+  trancheId: strategy.tranches[0].id,
+  amount: parseUnits('500', 6),
+});
+```
+
+### Supported chains
+
+| Chain | Usage | Deployment Type |
+|-------|-------|-----------------|
+| Base  | `Kasu.create({ chain: 'base', ... })` | Full (KSU + lending) |
+| XDC   | `Kasu.create({ chain: 'xdc', ... })` | Lite (lending only) |
+| Plume | `Kasu.create({ chain: 'plume', ... })` | Lite (lending only) |
+
+You can also provide a custom `ChainConfigEntry` instead of a chain name:
+
+```ts
+const kasu = Kasu.create({
+  chain: { chainId: 123, name: 'MyChain', isLiteDeployment: true, contracts: { ... }, ... },
+  signerOrProvider: provider,
+});
+```
+
+### Facade API overview
+
+| Facade | Methods | Purpose |
+|--------|---------|---------|
+| `kasu.strategies` | `getAll()`, `getById()`, `getPlatformStats()`, `calculateDepositLimits()` | Browse pools, APY, capacity |
+| `kasu.deposits` | `deposit()`, `withdraw()`, `withdrawMax()`, `buildKycParams()`, `isClearingPending()` | Submit transactions |
+| `kasu.portfolio` | `getPositions()`, `getTransactionHistory()` | User balances, yield, history |
+
+For advanced use cases (locking, swaps, NFTs), access the underlying services directly:
+
+```ts
+const locks = await kasu.services.Locking.getUserLocks('0x...');
+```
+
+---
+
+## Low-level SDK Configuration
+
+The sections below show how to configure the SDK manually using `SdkConfig` and
+`KasuSdk` directly. Most integrators should use the `Kasu` facade above instead.
+
+### Full Deployment (Base)
+
+Full deployments have all features including KSU token, locking, and loyalty rewards:
 
 ```ts
 import { JsonRpcProvider } from '@ethersproject/providers';
@@ -46,9 +129,9 @@ global.XMLHttpRequest = XMLHttpRequest; // required on Node runtimes
 
 const provider = new JsonRpcProvider(process.env.RPC_URL!, { skipFetchSetup: true });
 
-const config: SdkConfig = {
+const config = new SdkConfig({
   contracts: {
-    KSUToken: '0x…',
+    KSUToken: '0x…',         // Required for Full deployment
     IKSULocking: '0x…',
     IKSULockBonus: '0x…',
     UserManager: '0x…',
@@ -58,25 +141,84 @@ const config: SdkConfig = {
     UserLoyaltyRewards: '0x…',
     KsuPrice: '0x…',
     ClearingCoordinator: '0x…',
-    KasuNFTs: '0x…',
+    KasuNFTs: '0x…',         // Required for Full deployment
     ExternalTVL: '0x…',
   },
-  // If certain pools should be hidden from users, provide their ids. Empty string
-  // keeps the Graph queries happy when nothing is filtered out.
   UNUSED_LENDING_POOL_IDS: [''],
   directusUrl: 'https://kasu-finance.directus.app/',
-  subgraphUrl: 'https://subgraph.satsuma-prod.com/.../api',
-  plumeSubgraphUrl: 'https://api.goldsky.com/.../kasu-plume/prod/gn',
-};
+  subgraphUrl: 'https://api.goldsky.com/.../kasu-base/v1/gn',
+  isLiteDeployment: false,   // Full deployment (default)
+});
+
+export const kasuSdk = new KasuSdk(config, provider);
+```
+
+### Lite Deployment (XDC, Plume)
+
+Lite deployments don't have KSU token, locking, or loyalty features. They still support
+KYC/KYB gated deposits and all lending pool functionality:
+
+```ts
+const config = new SdkConfig({
+  contracts: {
+    // KSUToken: undefined,   // Not available on Lite
+    IKSULocking: '0x…',       // Lite version contract
+    IKSULockBonus: '0x…',     // Lite version contract
+    UserManager: '0x…',       // Lite version contract
+    LendingPoolManager: '0x…',
+    KasuAllowList: '0x…',
+    SystemVariables: '0x…',
+    UserLoyaltyRewards: '0x…', // Lite version contract
+    KsuPrice: '0x…',           // Lite version contract
+    ClearingCoordinator: '0x…',
+    // KasuNFTs: undefined,    // Not available on Lite
+    ExternalTVL: '0x…',
+  },
+  UNUSED_LENDING_POOL_IDS: [''],
+  directusUrl: 'https://kasu-finance.directus.app/',
+  subgraphUrl: 'https://api.goldsky.com/.../kasu-xdc/v1.0.0/gn',
+  isLiteDeployment: true,     // Lite deployment - disables KSU features
+});
 
 export const kasuSdk = new KasuSdk(config, provider);
 ```
 
+### Multi-Chain Configuration
+
+For frontends supporting multiple chains, create a config per chain:
+
+```ts
+// config/chains.ts
+const chainConfigs = {
+  base: {
+    chainId: 8453,
+    subgraphUrl: 'https://api.goldsky.com/.../kasu-base/v1/gn',
+    isLiteDeployment: false,
+    contracts: { /* Base contract addresses */ },
+  },
+  xdc: {
+    chainId: 50,
+    subgraphUrl: 'https://api.goldsky.com/.../kasu-xdc/v1.0.0/gn',
+    isLiteDeployment: true,
+    contracts: { /* XDC contract addresses */ },
+  },
+};
+
+// Create SDK for current chain
+const chainConfig = chainConfigs[currentChain];
+const config = new SdkConfig({
+  ...chainConfig,
+  directusUrl: 'https://kasu-finance.directus.app/',
+  UNUSED_LENDING_POOL_IDS: [''],
+});
+const sdk = new KasuSdk(config, provider);
+```
+
 See `kasu-fe-next/src/config/sdk` in the Kasu frontend repository for full
 mainnet and testnet examples, including how Kasu fetches unused pool ids before
 instantiating the SDK.
 
-## Quick start
+### Low-level Quick start
 
 ```ts
 import { JsonRpcProvider } from '@ethersproject/providers';
@@ -91,7 +233,7 @@ const userSummary = await sdk.Portfolio.getPortfolioSummary(userAddress);
 await sdk.Locking.lockKSUTokens(amountBn, lockPeriodBn); // signer required
 ```
 
-The SDK exposes services as properties on `KasuSdk`. Each service contains the
+`KasuSdk` exposes services as properties. Each service contains the
 methods for a single protocol facet:
 
 | Service       | Purpose                                                                                                      |
@@ -106,6 +248,23 @@ Every method is fully typed, so your editor can discover the shape of responses
 (`PoolOverview`, `LockPeriod`, `PortfolioRewards`, etc.) without digging into
 the implementation.
 
+## Lite Deployment Behavior
+
+When `isLiteDeployment: true` is set in the config, the SDK gracefully handles
+missing KSU-related functionality:
+
+| Service Method | Full Deployment | Lite Deployment |
+|----------------|-----------------|-----------------|
+| `Locking.lockKSUTokens()` | Works normally | Throws error |
+| `Locking.getUserTotalLockedAmount()` | Returns locked amount | Returns `'0'` |
+| `Locking.getLoyaltyLevelAndApyBonusFromRatio()` | Calculates level | Returns level 0, 0% bonus |
+| `Locking.getKasuEpochTokenPrice()` | Returns current price | Returns `{ price: 0, decimals: 18 }` |
+| `Portfolio.getUserNfts()` | Returns NFT ids | Returns `[]` |
+| `Portfolio.getPortfolioRewards()` | Returns rewards | Returns zeros |
+
+**UI Implications**: Frontends should hide KSU-related UI elements (locking panel,
+loyalty badges, KSU rewards) when `config.isLiteDeployment` is true.
+
 ### Working with pool filters
 
 Many queries accept a list of pool ids to ignore (see `UNUSED_LENDING_POOL_IDS`
@@ -136,6 +295,14 @@ npm test
 These are the same steps executed by the release workflow before publishing to
 npm.
 
+## Networks
+
+| Network | Chain ID | Deployment Type | Subgraph |
+|---------|----------|-----------------|----------|
+| Base    | 8453     | Full            | `kasu-base/v1` |
+| XDC     | 50       | Lite            | `kasu-xdc/v1.0.0` |
+| Plume   | 98866    | Lite            | `kasu-plume/prod` |
+
 ## Support
 For questions, issues, or contributions:
 - GitHub Issues: [Create an issue](https://github.com/kasufinance/kasu-sdk/issues)