Trading Solana

SOLANA_PRIVATE_KEY=base58_or_json_array    # Your Solana wallet private key
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com  # Optional: custom RPC

/sol swap <amount> <from> to <to>           # Swap tokens on Solana
/sol swap 1 SOL to USDC                     # Swap 1 SOL to USDC
/sol swap 100 USDC to JUP                   # Swap 100 USDC to JUP
/sol swap 0.5 SOL to BONK                   # Swap 0.5 SOL to BONK

/sol quote <amount> <from> to <to>          # Get swap quote without executing
/sol quote 1 SOL to USDC                    # Quote 1 SOL → USDC

/sol pools <token>                          # List liquidity pools for token
/sol pools SOL                              # All SOL pools
/sol pools BONK                             # All BONK pools

/sol balance                                # Check SOL and token balances
/sol address                                # Show wallet address

import {
  executeJupiterSwap,
  getJupiterQuote,
  createJupiterLimitOrder,
  cancelJupiterLimitOrder,
  listJupiterLimitOrders,
  createJupiterDCA,
  closeJupiterDCA,
  listJupiterDCAs,
} from 'clodds/solana/jupiter';

// Execute swap via Jupiter (best route)
const result = await executeJupiterSwap(connection, keypair, {
  inputMint: 'So11111111111111111111111111111111111111112',  // SOL
  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
  amount: '1000000000',  // 1 SOL in lamports
  slippageBps: 50,       // 0.5% slippage
});

console.log(`Swapped: ${result.inAmount} → ${result.outAmount}`);
console.log(`TX: ${result.signature}`);

// Create limit order - sell 1 SOL for minimum 250 USDC
const order = await createJupiterLimitOrder(connection, keypair, {
  inputMint: 'So11111111111111111111111111111111111111112',
  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
  inAmount: '1000000000',  // 1 SOL
  outAmount: '250000000',  // 250 USDC
  expiredAtMs: Date.now() + 7 * 24 * 60 * 60 * 1000, // 1 week expiry
});
console.log(`Order created: ${order.orderPubKey}`);

// List open orders
const orders = await listJupiterLimitOrders(connection, keypair.publicKey.toBase58());
console.log(`Open orders: ${orders.length}`);

// Cancel order
await cancelJupiterLimitOrder(connection, keypair, order.orderPubKey);

// Create DCA - swap 100 USDC to JUP, 10 USDC every hour
const dca = await createJupiterDCA(connection, keypair, {
  inputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
  outputMint: 'JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN', // JUP
  inAmount: '100000000',        // Total 100 USDC
  inAmountPerCycle: '10000000', // 10 USDC per swap
  cycleSecondsApart: 3600,      // Every hour (min 30 seconds)
});
console.log(`DCA created: ${dca.dcaPubKey}`);

// List active DCAs
const dcas = await listJupiterDCAs(connection, keypair.publicKey.toBase58());

// Close DCA and withdraw remaining funds
await closeJupiterDCA(connection, keypair, dca.dcaPubKey);

import {
  executeRaydiumSwap,
  getRaydiumQuote,
  listRaydiumPools,
  getClmmPositions,
  createClmmPosition,
  increaseClmmLiquidity,
  decreaseClmmLiquidity,
  closeClmmPosition,
  harvestClmmRewards,
  addAmmLiquidity,
  removeAmmLiquidity,
} from 'clodds/solana/raydium';

// Get quote
const quote = await getRaydiumQuote({
  inputMint: 'SOL',
  outputMint: 'USDC',
  amount: 1_000_000_000,
});
console.log(`Expected output: ${quote.outAmount}`);

// Execute swap
const result = await executeRaydiumSwap(connection, keypair, {
  inputMint: 'So11111111111111111111111111111111111111112',
  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
  amount: '1000000000',
  slippageBps: 50,
});

// List pools
const pools = await listRaydiumPools({ tokenMints: ['So11111111111111111111111111111111111111112'] });

// CLMM: Open concentrated liquidity position
const position = await createClmmPosition(connection, keypair, {
  poolId: 'POOL_ID_HERE',
  priceLower: 100,
  priceUpper: 200,
  baseAmount: '1000000000',
});

// CLMM: List positions
const positions = await getClmmPositions(connection, keypair);

// CLMM: Harvest rewards
const rewards = await harvestClmmRewards(connection, keypair);

// AMM: Add liquidity
await addAmmLiquidity(connection, keypair, {
  poolId: 'AMM_POOL_ID',
  amountA: '1000000000',
  fixedSide: 'a',
});

import { executeOrcaWhirlpoolSwap, getOrcaWhirlpoolQuote, listOrcaWhirlpoolPools } from 'clodds/solana/orca';

// Get quote
const quote = await getOrcaWhirlpoolQuote({
  inputMint: 'SOL',
  outputMint: 'USDC',
  amount: 1_000_000_000,
});

// Execute swap
const result = await executeOrcaWhirlpoolSwap({
  inputMint: 'SOL',
  outputMint: 'USDC',
  amount: 1_000_000_000,
  slippage: 0.5,
});

// List pools
const pools = await listOrcaWhirlpoolPools({ token: 'SOL' });

import { executeMeteoraDlmmSwap, getMeteoraDlmmQuote, listMeteoraDlmmPools } from 'clodds/solana/meteora';

// Get quote
const quote = await getMeteoraDlmmQuote({
  inputMint: 'SOL',
  outputMint: 'USDC',
  amount: 1_000_000_000,
});

// Execute swap
const result = await executeMeteoraDlmmSwap({
  inputMint: 'SOL',
  outputMint: 'USDC',
  amount: 1_000_000_000,
  slippage: 0.5,
});

// List pools
const pools = await listMeteoraDlmmPools({ token: 'SOL' });

import {
  executePumpFunTrade,
  getBondingCurveState,
  getTokenPriceInfo,
  calculateBuyQuote,
  calculateSellQuote,
  isGraduated,
  getTokenInfo,
  getPumpFunQuote,
} from 'clodds/solana/pumpapi';

// Buy token on Pump.fun
const result = await executePumpFunTrade(connection, keypair, {
  mint: 'token_mint_address',
  action: 'buy',
  amount: 0.1,           // SOL amount
  denominatedInSol: true,
  slippageBps: 500,      // 5% slippage for volatile tokens
});

// Sell token
const result = await executePumpFunTrade(connection, keypair, {
  mint: 'token_mint_address',
  action: 'sell',
  amount: 1000000,       // Token amount
  denominatedInSol: false,
  slippageBps: 500,
});

import BN from 'bn.js';

// Get bonding curve state directly from chain
const state = await getBondingCurveState(connection, 'token_mint');
if (state) {
  console.log(`Virtual SOL: ${state.virtualSolReserves.toString()}`);
  console.log(`Virtual Tokens: ${state.virtualTokenReserves.toString()}`);
  console.log(`Graduated: ${state.complete}`);
}

// Get comprehensive price info
const priceInfo = await getTokenPriceInfo(connection, 'token_mint', 200); // 200 = SOL price USD
console.log(`Price: ${priceInfo.priceInSol} SOL ($${priceInfo.priceInUsd})`);
console.log(`Market Cap: $${priceInfo.marketCapUsd}`);
console.log(`Bonding Progress: ${(priceInfo.bondingProgress * 100).toFixed(1)}%`);

// Calculate buy quote with price impact
const solAmount = new BN(0.5 * 1e9); // 0.5 SOL in lamports
const buyQuote = calculateBuyQuote(state, solAmount, 100); // 1% fee
console.log(`Tokens out: ${buyQuote.tokensOut.toNumber() / 1e6}`);
console.log(`Price impact: ${buyQuote.priceImpact.toFixed(2)}%`);

// Calculate sell quote
const tokenAmount = new BN(1000000 * 1e6); // 1M tokens
const sellQuote = calculateSellQuote(state, tokenAmount, 100);
console.log(`SOL out: ${sellQuote.solOut.toNumber() / 1e9}`);

// Check if token graduated to PumpSwap
const graduation = await isGraduated(connection, 'token_mint');
if (graduation.graduated) {
  console.log(`PumpSwap pool: ${graduation.pumpswapPool}`);
}

// Computed locally via the official SDK (fee-tier-aware) — no third-party relay call
const quote = await getPumpFunQuote({
  mint: 'token_mint',
  action: 'buy',
  amount: '0.5',  // 0.5 SOL
});
console.log(`Input: ${quote.inputAmount}, Output: ${quote.outputAmount}`);

import { resolveTokenMints, getTokenList } from 'clodds/solana/tokenlist';

// Resolve token symbols to mint addresses
const mints = await resolveTokenMints(['SOL', 'USDC', 'JUP', 'BONK']);
// ['So111...', 'EPjF...', '...', '...']

// Get full token list
const tokens = await getTokenList();

import { listAllPools, selectBestPool } from 'clodds/solana/pools';

// List all pools for a token pair
const pools = await listAllPools({
  inputMint: 'SOL',
  outputMint: 'USDC',
});

// Select best pool based on liquidity
const best = await selectBestPool({
  inputMint: 'SOL',
  outputMint: 'USDC',
  amount: 1_000_000_000,
});

import { loadSolanaKeypair, getSolanaConnection, signAndSendTransaction } from 'clodds/solana/wallet';

// Load keypair from env
const keypair = loadSolanaKeypair();

// Get connection
const connection = getSolanaConnection();

// Sign and send transaction
const signature = await signAndSendTransaction(connection, transaction, keypair);

import { SolanaSwapError, InsufficientBalanceError, SlippageExceededError } from 'clodds/solana';

try {
  await executeJupiterSwap({ ... });
} catch (error) {
  if (error instanceof InsufficientBalanceError) {
    console.log('Not enough balance');
  } else if (error instanceof SlippageExceededError) {
    console.log('Price moved too much, increase slippage');
  }
}