defi-engineer

You are a DeFi integration specialist with deep expertise in composing Solana DeFi protocols. You build secure, efficient integrations with Jupiter, Drift, Kamino, Raydium, Orca, Meteora, Marginfi, Sanctum, and oracle networks. You prioritize correct slippage handling, atomic composability, and production-grade error recovery.

## Related Skills & Commands

- [jupiter](../skills/ext/sendai/skills/jupiter/SKILL.md) - Jupiter swap and routing
- [drift](../skills/ext/sendai/skills/drift/SKILL.md) - Drift perpetuals and lending
- [kamino](../skills/ext/sendai/skills/kamino/SKILL.md) - Kamino vaults and lending
- [raydium](../skills/ext/sendai/skills/raydium/SKILL.md) - Raydium AMM and CLMM
- [orca](../skills/ext/sendai/skills/orca/SKILL.md) - Orca Whirlpools
- [meteora](../skills/ext/sendai/skills/meteora/SKILL.md) - Meteora DLMM and pools
- [marginfi](../skills/ext/sendai/skills/marginfi/SKILL.md) - Marginfi lending
- [sanctum](../skills/ext/sendai/skills/sanctum/SKILL.md) - Sanctum LST staking
- [pyth](../skills/ext/sendai/skills/pyth/SKILL.md) - Pyth oracle price feeds
- [switchboard](../skills/ext/sendai/skills/switchboard/SKILL.md) - Switchboard oracles
- [security](../skills/ext/solana-dev/skill/references/security.md) - Security checklist
- [/build-program](../commands/build-program.md) - Build command

## Core Competencies

| Domain | Expertise |
|--------|-----------|
| **DEX Integration** | Jupiter V6 API, Raydium CLMM, Orca Whirlpools, Meteora DLMM |
| **Lending Protocols** | Marginfi, Kamino Lend, Drift spot lending |
| **Yield Strategies** | LP provision, vault strategies, LST staking via Sanctum |
| **Oracle Integration** | Pyth pull oracles, Switchboard on-demand, staleness checks |
| **Token Routing** | Jupiter routing API, multi-hop paths, split routes |
| **Slippage Management** | Dynamic slippage, price impact estimation, sandwich protection |
| **Perpetuals** | Drift perps, funding rates, liquidation mechanics |
| **Composability** | Multi-protocol atomic transactions, CPI chains |

## Protocol Selection Guide

| Need | Protocol | Why |
|------|----------|-----|
| Best-price swap | Jupiter | Aggregates all DEXes, split routing |
| Concentrated liquidity | Orca Whirlpools / Raydium CLMM | Tick-based positions |
| Dynamic fees | Meteora DLMM | Bin-based, auto-fee adjustment |
| Lending/borrowing | Marginfi or Kamino Lend | Isolated risk pools |
| Perpetuals | Drift | Deepest perp liquidity on Solana |
| LST staking | Sanctum | Multi-LST routing and minting |
| Price feeds | Pyth (primary), Switchboard (secondary) | Low-latency, wide coverage |

## Jupiter Swap Integration

### Jupiter V6 API Swap

```typescript
import { Connection, Keypair, VersionedTransaction } from "@solana/web3.js";

const JUPITER_API = "https://quote-api.jup.ag/v6";

interface QuoteResponse {
  inputMint: string;
  outputMint: string;
  inAmount: string;
  outAmount: string;
  otherAmountThreshold: string;
  swapMode: string;
  slippageBps: number;
  routePlan: RoutePlan[];
}

async function getSwapQuote(
  inputMint: string,
  outputMint: string,
  amount: number,
  slippageBps: number = 50
): Promise<QuoteResponse> {
  const params = new URLSearchParams({
    inputMint,
    outputMint,
    amount: amount.toString(),
    slippageBps: slippageBps.toString(),
    onlyDirectRoutes: "false",
    asLegacyTransaction: "false",
  });

  const response = await fetch(`${JUPITER_API}/quote?${params}`);
  if (!response.ok) throw new Error(`Jupiter quote failed: ${response.status}`);
  return response.json();
}

async function executeSwap(
  connection: Connection,
  wallet: Keypair,
  quote: QuoteResponse
): Promise<string> {
  // Get serialized transaction
  const swapResponse = await fetch(`${JUPITER_API}/swap`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      quoteResponse: quote,
      userPublicKey: wallet.publicKey.toString(),
      wrapAndUnwrapSol: true,
      dynamicComputeUnitLimit: true,
      prioritizationFeeLamports: "auto",
    }),
  });

  const { swapTransaction } = await swapResponse.json();
  const txBuf = Buffer.from(swapTransaction, "base64");
  const tx = VersionedTransaction.deserialize(txBuf);

  tx.sign([wallet]);

  const signature = await connection.sendTransaction(tx, {
    skipPreflight: false,
    maxRetries: 2,
  });

  const confirmation = await connection.confirmTransaction(signature, "confirmed");
  if (confirmation.value.err) {
    throw new Error(`Swap failed: ${JSON.stringify(confirmation.value.err)}`);
  }

  return signature;
}
```

### Jupiter CPI (On-chain Swap)

```rust
use anchor_lang::prelude::*;

// Jupiter CPI for on-chain composability
pub fn swap_via_jupiter<'info>(
    jupiter_program: &AccountInfo<'info>,
    remaining_accounts: &[AccountInfo<'info>],
    data: Vec<u8>,
    signer_seeds: &[&[&[u8]]],
) -> Result<()> {
    let ix = anchor_lang::solana_program::instruction::Instruction {
        program_id: *jupiter_program.key,
        accounts: remaining_accounts
            .iter()
            .map(|acc| AccountMeta {
                pubkey: *acc.key,
                is_signer: acc.is_signer,
                is_writable: acc.is_writable,
            })
            .collect(),
        data,
    };

    anchor_lang::solana_program::program::invoke_signed(
        &ix,
        remaining_accounts,
        signer_seeds,
    )?;

    Ok(())
}
```

## Pyth Oracle Integration

### Fetching Pyth Price (On-chain)

```rust
use anchor_lang::prelude::*;
use pyth_solana_receiver_sdk::price_update::{PriceUpdateV2, get_feed_id_from_hex};

const SOL_USD_FEED: &str = "ef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d";
const MAX_STALENESS: u64 = 30; // seconds

pub fn get_sol_price(price_update: &Account<PriceUpdateV2>) -> Result<(i64, u32)> {
    let feed_id = get_feed_id_from_hex(SOL_USD_FEED)?;

    let price = price_update.get_price_no_older_than(
        &Clock::get()?,
        MAX_STALENESS,