// src/index.ts
import { MCPServer } from '@modelcontextprotocol/sdk';
import { SolanaAgentKit } from '@sendaifun/solana-agent-kit';
import * as dotenv from 'dotenv';

dotenv.config();

async function main() {
  // Initialize Solana Agent Kit
  const agent = new SolanaAgentKit({
    privateKey: process.env.SOLANA_PRIVATE_KEY!,
    rpcUrl: process.env.RPC_URL!
  });

  // Create MCP server
  const server = new MCPServer();

  // Register handlers
  server.registerFunction('jupiterSwap', async (params) => {
    const { inputMint, outputMint, amount } = params;
    return await agent.jupiterSwap(inputMint, outputMint, amount);
  });

  // Start server
  await server.start();
}

main().catch(console.error);

// src/handlers/jupiter.ts
import { SolanaAgentKit } from '@sendaifun/solana-agent-kit';

export async function handleJupiterSwap(
  agent: SolanaAgentKit,
  params: any
) {
  const { inputMint, outputMint, amount } = params;
  
  try {
    const txid = await agent.jupiterSwap(
      inputMint,
      outputMint,
      amount
    );
    
    return {
      success: true,
      transaction: txid
    };
  } catch (error) {
    return {
      success: false,
      error: error.message
    };
  }
}

// Register Jupiter swap handler
server.registerFunction('jupiterSwap', async (params) => {
  return await handleJupiterSwap(agent, params);
});

// Example Claude prompt:
"Swap 1 SOL for USDC using Jupiter"

// Register position management handler
server.registerFunction('manifestTrade', async (params) => {
  const { side, quantity, price, marketId } = params;
  return await agent.manifestLimitOrder(marketId, quantity, side, price);
});

// Example Claude prompt:
"Create a limit order to buy 5 SOL at $20 using Manifest"

// Add error handling for RPC connection
try {
  await agent.connection.getLatestBlockhash();
} catch (error) {
  console.error('RPC connection failed:', error);
  process.exit(1);
}

// Validate environment variables
if (!process.env.SOLANA_PRIVATE_KEY) {
  throw new Error('SOLANA_PRIVATE_KEY not found in environment');
}

// Add transaction retry logic
async function sendWithRetry(tx: Transaction, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await agent.sendTransaction(tx);
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }
}