# How CloddsBot Integrates with Jupiter, Raydium, and Pump.fun on Solana

> Discover how CloddsBot seamlessly integrates Jupiter, Raydium, and Pump.fun on Solana. Learn about its unified approach to DeFi aggregation, liquidity, and swap execution.

- Repository: [AL/CloddsBot](https://github.com/alsk1992/CloddsBot)
- Tags: how-to-guide
- Published: 2026-09-11

---

**CloddsBot unifies Jupiter's aggregation engine, Raydium's concentrated liquidity markets, and Pump.fun's PumpSwap AMM through modular adapters in [`src/solana/jupiter.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/jupiter.ts), [`raydium.ts`](https://github.com/alsk1992/CloddsBot/blob/main/raydium.ts), and [`pumpswap.ts`](https://github.com/alsk1992/CloddsBot/blob/main/pumpswap.ts), exposing quote generation, swap execution, and liquidity management through a consistent TypeScript API.**

CloddsBot's Solana DeFi integration abstracts three major liquidity sources into a single execution layer. According to the alsk1992/CloddsBot source code, the bot implements dedicated modules for Jupiter, Raydium, and Pump.fun that handle everything from price discovery to transaction signing. Traders can route through the optimal venue without managing separate SDK implementations or manual transaction construction.

## Jupiter Integration via [`src/solana/jupiter.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/jupiter.ts)

The Jupiter adapter in [`src/solana/jupiter.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/jupiter.ts) provides access to Solana's dominant swap aggregator, handling both simple swaps and advanced order types.

### Quote Generation and Swap Execution

The module exposes **`getJupiterQuote`** for price discovery and **`executeJupiterSwap`** for transaction submission. All trade-skill commands (`/jup`, `/sol`) import these functions to build a **`JupiterSwapParams`** object from user requests, retrieve routing data, and submit signed transactions. The integration respects optional environment variables **`JUPITER_SWAP_BASE_URL`** and **`JUPITER_API_KEY`** for custom endpoints or authenticated API access.

### Advanced Order Types

Beyond standard swaps, the Jupiter module supports:

- **Limit orders** – creation, cancellation, and listing
- **Dollar-Cost Averaging (DCA)** – create, close, deposit, withdraw, and history retrieval
- **Batch and advanced-instruction APIs** for complex trading strategies

```typescript
import { Connection, Keypair } from '@solana/web3.js';
import {
  getJupiterQuote,
  executeJupiterSwap,
  JupiterSwapParams,
} from './solana/jupiter';

// Build a connection & wallet
const conn = new Connection('https://api.mainnet-beta.solana.com');
const wallet = Keypair.fromSecretKey(/* Uint8Array secret */);

// Prepare swap parameters (USDC → SOL)
const params: JupiterSwapParams = {
  inputMint:  'EPjFWdd5AufqSSqeM2qZ1T8Gd3bDgDEgG4wWg5d7x6a', // USDC
  outputMint: 'So11111111111111111111111111111111111111112', // WSOL
  amount:     '5000000', // 5 USDC (6 decimals)
  slippageBps: 50,
};

// Quote the trade
const quote = await getJupiterQuote(params);
console.log('Estimated out:', quote.outAmount);

// Execute the trade
const result = await executeJupiterSwap(conn, wallet, params);
console.log('Tx signature:', result.signature);

```

## Raydium Integration via [`src/solana/raydium.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/raydium.ts)

The Raydium adapter supports both legacy AMM pools and modern concentrated liquidity markets through a hybrid REST and SDK approach.

### Legacy REST API and SDK Abstraction

For standard swaps, the module provides **`executeRaydiumSwap`** and **`getRaydiumQuote`** using the legacy REST API, alongside **`listRaydiumPools`** for pool enumeration. The newer **`executeRaydiumSwapSdk`** function internally forwards to the REST implementation for reliability while maintaining SDK compatibility. The **`@raydium-io/raydium-sdk-v2`** package is loaded on demand to minimize cold-start latency. Environment variables **`RAYDIUM_SWAP_BASE_URL`** and **`RAYDIUM_POOL_LIST_URL`** allow overriding default API endpoints for testnet or private node configurations.

### Concentrated Liquidity Management

For CLMM-specific operations, the module exposes functions to create positions, add or remove liquidity, and harvest rewards. Pool discovery implements resilience through a paginated API fallback to `api-v3.raydium.io`, avoiding the massive legacy dump that can overwhelm the connection.

```typescript
import { Connection, Keypair } from '@solana/web3.js';
import {
  createClmmPosition,
  CreateClmmPositionParams,
} from './solana/raydium';

const conn = new Connection('https://api.mainnet-beta.solana.com');
const wallet = Keypair.fromSecretKey(/* secret */);

const clmmParams: CreateClmmPositionParams = {
  poolId:      'CLMM_POOL_ID',      // from listRaydiumPoolsSdk()
  priceLower:  0.98,
  priceUpper:  1.02,
  baseAmount:  '1000000',           // 1 TOKEN (6 decimals)
  slippage:    0.005,
};

const res = await createClmmPosition(conn, wallet, clmmParams);
console.log('Position NFT mint:', res.nftMint);

```

## Pump.fun PumpSwap Integration via [`src/solana/pumpswap.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/pumpswap.ts)

The PumpSwap adapter specifically targets Pump.fun's AMM, implementing custom pool discovery and fee-tier resolution logic.

### Pool Discovery and Smart Routing

The module uses **`findPumpSwapPools`** to discover all pools for a mint pair, then selects the optimal venue via **`findBestPumpSwapState`**, which identifies the highest-liquidity pool. To prevent performance degradation, the lookup caps candidates at **`MAX_POOL_CANDIDATES = 10`** and gracefully skips malformed accounts. The SDK **`@pump-fun/pump-swap-sdk`** is instantiated per RPC endpoint and cached in **`onlinePumpAmmSdkCache`** for reuse. Fee tiers are automatically resolved via the pool's **`creator`** field, ensuring accurate pricing calculations.

### Quote Calculation and Priority Fee Execution

Quoting relies on pure functions **`buyQuoteInput`** and **`sellBaseInput`** that calculate prices using on-chain reserves. Execution via **`executePumpSwapTrade`** builds the complete instruction set, including Associated Token Account (ATA) creation, WSOL wrapping, and optional priority-fee compute budget instructions. The function accepts a **`priorityFeeLamports`** parameter to accelerate transaction inclusion during network congestion.

```typescript
import { Connection, Keypair } from '@solana/web3.js';
import {
  executePumpSwapTrade,
  PumpSwapTradeParams,
} from './solana/pumpswap';

const conn = new Connection('https://api.mainnet-beta.solana.com');
const wallet = Keypair.fromSecretKey(/* secret */);

const trade: PumpSwapTradeParams = {
  mint:          'PuMPiNkEy...123', // Pump.fun token
  side:          'buy',
  amountIn:      '2000000',         // 2 PUMP (6 decimals)
  slippageBps:   30,
  priorityFeeLamports: 5000,      // optional compute-budget boost
};

const result = await executePumpSwapTrade(conn, wallet, trade);
if (result.success) {
  console.log('Swap tx:', result.txHash);
} else {
  console.error('Swap failed:', result.error);
}

```

## Unified Trading Architecture

CloddsBot's DeFi layer follows a consistent architectural pattern across all three integrations.

### Orchestration Flow

The **[`src/trading/orchestrator.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/trading/orchestrator.ts)** module coordinates the entire trading pipeline. When a user initiates a request (e.g., "swap 5 USDC for SOL"), the orchestrator:

1. Determines the target DEX based on token pair or explicit flags
2. Fetches quotes via **`getJupiterQuote`**, **`getRaydiumQuote`**, or **`getPumpSwapQuote`**
3. Presents the quote to the user
4. Upon confirmation, executes via **`executeJupiterSwap`**, **`executeRaydiumSwapSdk`** (forwarding to the REST implementation), or **`executePumpSwapTrade`**
5. Returns transaction signatures or error details

All three modules expose a uniform interface accepting a Solana **`Connection`**, a **`Keypair`**, and a typed parameter object, making them composable with the bot's command handlers.

### Resilience and Configuration

The integration emphasizes operational flexibility through:

- **Lazy SDK loading** – Raydium and PumpSwap SDKs import only when needed, reducing cold-start latency
- **Environment-driven endpoints** – All modules read `process.env` for base URLs and API keys, enabling seamless testnet or private-node deployments without code changes
- **Robust error handling** – Pool discovery includes fallback mechanisms and malformed account filtering
- **Shared signing utilities** – **[`src/solana/wallet.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/wallet.ts)** provides generic **`signAndSendTransaction`** and **`signAndSendVersionedTransaction`** helpers used uniformly across Jupiter, Raydium, and PumpSwap operations

## Summary

- CloddsBot implements dedicated TypeScript modules in **[`src/solana/jupiter.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/jupiter.ts)**, **[`raydium.ts`](https://github.com/alsk1992/CloddsBot/blob/main/raydium.ts)**, and **[`pumpswap.ts`](https://github.com/alsk1992/CloddsBot/blob/main/pumpswap.ts)** to abstract Jupiter, Raydium, and Pump.fun operations.
- The Jupiter integration supports aggregation routing, limit orders, and DCA strategies with configurable base URLs via **`JUPITER_SWAP_BASE_URL`**.
- Raydium support combines legacy REST APIs with SDK-based CLMM position management, loading **`@raydium-io/raydium-sdk-v2`** on demand.
- PumpSwap integration handles pool discovery (capped at 10 candidates), creator-based fee resolution, and priority-fee execution through **`@pump-fun/pump-swap-sdk`**.
- **[`src/trading/orchestrator.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/trading/orchestrator.ts)** unifies the three DEXs under a consistent quote-and-execute flow, while **[`src/solana/wallet.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/wallet.ts)** provides shared transaction signing.

## Frequently Asked Questions

### Which DEX does CloddsBot prioritize for Solana swaps?

CloddsBot does not hardcode a single priority. Instead, **[`src/trading/orchestrator.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/trading/orchestrator.ts)** selects the optimal venue based on the specific token pair, user flags, or liquidity depth. Jupiter typically handles general aggregation, Raydium manages concentrated liquidity positions, and PumpSwap routes trades for Pump.fun launchpad tokens.

### How does CloddsBot handle Raydium's concentrated liquidity positions?

The **`createClmmPosition`** function in **[`src/solana/raydium.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/raydium.ts)** interacts with Raydium's CLMM pools using the v2 SDK. It accepts parameters for price bounds, token amounts, and slippage, then returns the NFT mint representing the position. The module also supports adding liquidity, removing liquidity, and harvesting rewards from existing positions.

### Can I configure custom RPC endpoints for Jupiter?

Yes. The Jupiter module reads the optional environment variables **`JUPITER_SWAP_BASE_URL`** and **`JUPITER_API_KEY`**. Setting these allows you to redirect quote and swap requests to private Jupiter endpoints or authenticated infrastructure without modifying the TypeScript source code.

### Does PumpSwap integration support priority fees?

Yes. The **`executePumpSwapTrade`** function in **[`src/solana/pumpswap.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/pumpswap.ts)** accepts a **`priorityFeeLamports`** parameter. When provided, the function prepends compute-budget instructions to the transaction, increasing the likelihood of inclusion during periods of Solana network congestion.