CoolRouter Documentation

use anchor_lang::prelude::*;
use coolrouter_cpi::{create_llm_request, Message};

#[program]
pub mod lending_protocol {
    use super::*;
    
    pub fn request_credit_assessment(
        ctx: Context<RequestCreditAssessment>,
        applicant: Pubkey,
        loan_amount: u64,
    ) -> Result<()> {
        let request_id = format!("credit_{}", applicant.to_string());
        
        // Gather on-chain data about the applicant
        let transaction_history = get_transaction_history(&applicant)?;
        let defi_activity = get_defi_positions(&applicant)?;
        
        // Create AI prompt with structured data
        let prompt = format!(
            "Analyze this loan application:\n             Requested Amount: {} SOL\n             Transaction History: {}\n             DeFi Positions: {}\n             \n             Provide a risk score (0-100) and recommended interest rate.",
            loan_amount as f64 / 1e9,
            transaction_history,
            defi_activity
        );
        
        let messages = vec![
            Message {
                role: "system".to_string(),
                content: "You are a DeFi credit analyst. Provide JSON:                          {\"risk_score\": <0-100>, \"interest_rate\": <percentage>}".to_string(),
            },
            Message {
                role: "user".to_string(),
                content: prompt,
            },
        ];
        
        // Request AI analysis with high consensus requirements
        create_llm_request(
            ctx.accounts.request_pda.to_account_info(),
            ctx.accounts.authority.to_account_info(),
            ctx.accounts.lending_program.to_account_info(),
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.coolrouter_program.key(),
            vec![ctx.accounts.loan_application.to_account_info()],
            request_id,
            "openai".to_string(),
            "gpt-4".to_string(),
            messages,
            5,  // Require 5 oracle votes for financial decisions
            80, // 80% consensus threshold for security
        )?;
        
        Ok(())
    }
    
    // Callback receives AI assessment
    pub fn llm_callback(
        ctx: Context<LLMCallback>,
        request_id: String,
        response: Vec<u8>,
    ) -> Result<()> {
        let loan_application = &mut ctx.accounts.loan_application;
        
        // Parse AI response
        let response_str = String::from_utf8(response)
            .map_err(|_| ErrorCode::InvalidResponse)?;
        let assessment: CreditAssessment = serde_json::from_str(&response_str)
            .map_err(|_| ErrorCode::InvalidJsonResponse)?;
        
        // Update loan application with AI-determined terms
        loan_application.risk_score = assessment.risk_score;
        loan_application.approved_interest_rate = assessment.interest_rate;
        loan_application.status = if assessment.risk_score < 60 {
            LoanStatus::Approved
        } else {
            LoanStatus::RequiresManualReview
        };
        
        msg!("Credit assessment complete: Risk={}, Rate={}%", 
             assessment.risk_score, assessment.interest_rate);
        
        Ok(())
    }
}

#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct CreditAssessment {
    pub risk_score: u8,
    pub interest_rate: u16, // Basis points
}

pub fn analyze_proposal(
    ctx: Context<AnalyzeProposal>,
    proposal_id: u64,
    proposal_text: String,
) -> Result<()> {
    let request_id = format!("dao_proposal_{}", proposal_id);
    
    // Get DAO context
    let dao_rules = get_dao_constitution(&ctx.accounts.dao_state)?;
    let past_proposals = get_recent_proposals(&ctx.accounts.dao_state, 10)?;
    
    let messages = vec![
        Message {
            role: "system".to_string(),
            content: format!(
                "You are a DAO governance analyst. DAO Rules: {}\n                 Recent Context: {}\n                 Provide analysis in JSON: {{\"summary\": string,                  \"conflicts\": [string], \"recommendation\": string,                  \"priority\": \"low|medium|high\"}}",
                dao_rules,
                past_proposals
            ),
        },
        Message {
            role: "user".to_string(),
            content: format!("Analyze this proposal:\n{}", proposal_text),
        },
    ];
    
    create_llm_request(
        ctx.accounts.request_pda.to_account_info(),
        ctx.accounts.authority.to_account_info(),
        ctx.accounts.dao_program.to_account_info(),
        ctx.accounts.system_program.to_account_info(),
        ctx.accounts.coolrouter_program.key(),
        vec![ctx.accounts.proposal_state.to_account_info()],
        request_id,
        "anthropic".to_string(),
        "claude-3-opus".to_string(),
        messages,
        3,
        66,
    )?;
    
    Ok(())
}

pub fn llm_callback(
    ctx: Context<DAOCallback>,
    request_id: String,
    response: Vec<u8>,
) -> Result<()> {
    let proposal = &mut ctx.accounts.proposal_state;
    
    let analysis: ProposalAnalysis = serde_json::from_slice(&response)
        .map_err(|_| ErrorCode::InvalidResponse)?;
    
    // Store AI analysis on-chain
    proposal.ai_summary = analysis.summary;
    proposal.potential_conflicts = analysis.conflicts;
    proposal.ai_recommendation = analysis.recommendation;
    proposal.priority_level = analysis.priority;
    proposal.analysis_complete = true;
    
    // Emit event for DAO members
    emit!(ProposalAnalyzed {
        proposal_id: proposal.id,
        priority: analysis.priority,
        has_conflicts: !analysis.conflicts.is_empty(),
    });
    
    Ok(())
}

pub fn moderate_content(
    ctx: Context<ModerateContent>,
    post_id: String,
    content: String,
) -> Result<()> {
    let request_id = format!("moderate_{}", post_id);
    
    let messages = vec![
        Message {
            role: "system".to_string(),
            content: "You are a content moderator. Classify content as:                      {\"safe\": bool, \"categories\": [string],                      \"confidence\": <0-100>}. Categories: spam, nsfw,                      hate_speech, scam, violence, none.".to_string(),
        },
        Message {
            role: "user".to_string(),
            content: format!("Moderate this post:\n{}", content),
        },
    ];
    
    create_llm_request(
        ctx.accounts.request_pda.to_account_info(),
        ctx.accounts.authority.to_account_info(),
        ctx.accounts.social_program.to_account_info(),
        ctx.accounts.system_program.to_account_info(),
        ctx.accounts.coolrouter_program.key(),
        vec![ctx.accounts.post_state.to_account_info()],
        request_id,
        "openai".to_string(),
        "gpt-4".to_string(),
        messages,
        4,  // Multiple oracles for accuracy
        75, // High consensus for moderation
    )?;
    
    Ok(())
}

pub fn llm_callback(
    ctx: Context<ModerationCallback>,
    request_id: String,
    response: Vec<u8>,
) -> Result<()> {
    let post = &mut ctx.accounts.post_state;
    
    let moderation: ModerationResult = serde_json::from_slice(&response)?;
    
    post.is_safe = moderation.safe;
    post.moderation_categories = moderation.categories;
    post.confidence_score = moderation.confidence;
    
    // Automatically hide unsafe content
    if !moderation.safe && moderation.confidence > 80 {
        post.visibility = Visibility::Hidden;
        emit!(ContentHidden {
            post_id: post.id.clone(),
            reason: moderation.categories[0].clone(),
        });
    }
    
    Ok(())
}

[dependencies]
coolrouter-cpi = "0.1.0"
anchor-lang = "0.29.0"

use anchor_lang::prelude::*;
use coolrouter_cpi::{create_llm_request, Message};

#[program]
pub mod my_program {
    use super::*;

    pub fn ask_ai(
        ctx: Context<AskAI>,
        request_id: String,
        prompt: String,
    ) -> Result<()> {
        let messages = vec![Message {
            role: "user".to_string(),
            content: prompt,
        }];
        
        create_llm_request(
            ctx.accounts.request_pda.to_account_info(),
            ctx.accounts.authority.to_account_info(),
            ctx.accounts.my_program.to_account_info(),
            ctx.accounts.system_program.to_account_info(),
            ctx.accounts.coolrouter_program.key(),
            vec![ctx.accounts.response_storage.to_account_info()],
            request_id,
            "openai".to_string(),
            "gpt-4".to_string(),
            messages,
            3,  // min_votes
            66, // approval_threshold (66%)
        )?;
        
        Ok(())
    }
    
    // CoolRouter will call this function automatically
    pub fn llm_callback(
        ctx: Context<LLMCallback>,
        request_id: String,
        response: Vec<u8>,
    ) -> Result<()> {
        // Handle the LLM response
        msg!("Received response: {:?}", response);
        Ok(())
    }
}

pub fn create_llm_request<'info>(
    request_pda: AccountInfo<'info>,
    authority: AccountInfo<'info>,
    caller_program: AccountInfo<'info>,
    system_program: AccountInfo<'info>,
    coolrouter_program: Pubkey,
    callback_accounts: Vec<AccountInfo<'info>>,
    request_id: String,
    provider: String,
    model_id: String,
    messages: Vec<Message>,
    min_votes: u8,
    approval_threshold: u8,
) -> Result<()>

use coolrouter_cpi::CoolRouterCPI;

// Create the builder
let cpi = CoolRouterCPI::new(
    request_pda,
    authority,
    caller_program,
    system_program,
    coolrouter_program_id,
);

// Add callback accounts
let cpi = cpi
    .add_callback_account(account1)
    .add_callback_account(account2)
    .add_callback_accounts(vec![account3, account4]);

// Create the request
cpi.create_request(
    request_id,
    provider,
    model_id,
    messages,
    min_votes,
    approval_threshold,
)?;

#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
pub struct Message {
    pub role: String,    // "system", "user", or "assistant"
    pub content: String, // The message content
}

let messages = vec![
    Message {
        role: "system".to_string(),
        content: "You are a helpful assistant for Solana developers.".to_string(),
    },
    Message {
        role: "user".to_string(),
        content: "How do I optimize my transaction for lower fees?".to_string(),
    },
];

pub fn create_request<'info>(
    ctx: Context<'_, '_, '_, 'info, CreateRequest<'info>>,
    request_id: String,
    provider: String,
    model_id: String,
    messages: Vec<Message>,
    min_votes: u8,
    approval_threshold: u8,
) -> Result<()>

pub fn submit_vote(
    ctx: Context<SubmitVote>,
    response_hash: [u8; 32],
) -> Result<()>

pub fn fulfill_request<'info>(
    ctx: Context<'_, '_, '_, 'info, FulfillRequest<'info>>,
    response: Vec<u8>,
) -> Result<()>

use anchor_lang::prelude::*;
use coolrouter_cpi::{create_llm_request, Message};

declare_id!("YourProgramIDHere");

const MAX_REQUEST_ID_LEN: usize = 60;
const MAX_RESPONSE_LEN: usize = 2000;

const ACCOUNT_SPACE: usize = 8 + (4 + MAX_REQUEST_ID_LEN) 
    + (4 + MAX_RESPONSE_LEN) + 1 + 32;

#[program]
pub mod my_consumer {
    use super::*;
    
    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        let state = &mut ctx.accounts.state;
        state.authority = ctx.accounts.authority.key();
        Ok(())
    }
}

pub fn request_llm_response(
    ctx: Context<RequestLLMResponse>,
    request_id: String,
    prompt: String,
    min_votes: u8,
    approval_threshold: u8,
) -> Result<()> {
    let consumer_state = &mut ctx.accounts.consumer_state;
    
    // Validate inputs
    require!(
        request_id.len() <= MAX_REQUEST_ID_LEN,
        ErrorCode::RequestIdTooLong
    );
    require!(min_votes > 0, ErrorCode::InvalidMinVotes);
    require!(
        approval_threshold > 0 && approval_threshold <= 100,
        ErrorCode::InvalidApprovalThreshold
    );
    
    // Initialize state
    consumer_state.request_id = request_id.clone();
    consumer_state.response = Vec::new();
    consumer_state.has_response = false;
    consumer_state.authority = ctx.accounts.authority.key();
    
    // Prepare messages
    let messages = vec![Message {
        role: "user".to_string(),
        content: prompt,
    }];
    
    // Specify callback accounts
    let callback_accounts = vec![
        ctx.accounts.consumer_state.to_account_info(),
    ];
    
    // Call CoolRouter
    create_llm_request(
        ctx.accounts.request_pda.to_account_info(),
        ctx.accounts.authority.to_account_info(),
        ctx.accounts.consumer_program.to_account_info(),
        ctx.accounts.system_program.to_account_info(),
        ctx.accounts.coolrouter_program.key(),
        callback_accounts,
        request_id,
        "openai".to_string(),
        "gpt-4".to_string(),
        messages,
        min_votes,
        approval_threshold,
    )?;
    
    msg!("LLM request created");
    Ok(())
}

pub fn llm_callback(
    ctx: Context<LLMCallback>,
    request_id: String,
    response: Vec<u8>,
) -> Result<()> {
    let consumer_state = &mut ctx.accounts.consumer_state;
    
    // Verify this is the expected request
    require!(
        consumer_state.request_id == request_id,
        ErrorCode::RequestIdMismatch
    );
    
    // Validate response size
    require!(
        response.len() <= MAX_RESPONSE_LEN,
        ErrorCode::ResponseTooLarge
    );
    
    // Store the response
    consumer_state.response = response.clone();
    consumer_state.has_response = true;
    
    // Emit event
    emit!(ResponseReceived {
        request_id,
        response_preview: String::from_utf8_lossy(&response[..100.min(response.len())]).to_string(),
    });
    
    msg!("LLM response received and stored");
    Ok(())
}

#[account]
pub struct ConsumerState {
    pub request_id: String,     // The unique request identifier
    pub response: Vec<u8>,      // The LLM response bytes
    pub has_response: bool,     // Whether response has been received
    pub authority: Pubkey,      // Owner of this request
}

#[derive(Accounts)]
#[instruction(request_id: String)]
pub struct RequestLLMResponse<'info> {
    #[account(
        init,
        payer = authority,
        space = ACCOUNT_SPACE,
        seeds = [b"consumer_state", authority.key().as_ref(), request_id.as_bytes()],
        bump
    )]
    pub consumer_state: Account<'info, ConsumerState>,
    
    #[account(mut)]
    pub authority: Signer<'info>,
    
    /// CHECK: PDA for the request in CoolRouter
    #[account(mut)]
    pub request_pda: AccountInfo<'info>,
    
    /// CHECK: This program's ID
    pub consumer_program: AccountInfo<'info>,
    
    /// CHECK: The CoolRouter program
    pub coolrouter_program: AccountInfo<'info>,
    
    pub system_program: Program<'info, System>,
}

pub fn get_response(ctx: Context<GetResponse>) -> Result<Vec<u8>> {
    let consumer_state = &ctx.accounts.consumer_state;
    
    // Verify authority
    require_keys_eq!(
        consumer_state.authority,
        ctx.accounts.authority.key(),
        ErrorCode::Unauthorized
    );
    
    // Check if response exists
    require!(consumer_state.has_response, ErrorCode::NoResponse);
    
    Ok(consumer_state.response.clone())
}

let callback_accounts = vec![
    ctx.accounts.consumer_state.to_account_info(),
    ctx.accounts.user_profile.to_account_info(),
    ctx.accounts.analytics.to_account_info(),
];

create_llm_request(
    // ... other params
    callback_accounts,
    // ... other params
)?;

#[derive(Accounts)]
pub struct LLMCallback<'info> {
    #[account(mut)]
    pub consumer_state: Account<'info, ConsumerState>,
    
    #[account(mut)]
    pub user_profile: Account<'info, UserProfile>,
    
    #[account(mut)]
    pub analytics: Account<'info, Analytics>,
}

#[error_code]
pub enum ErrorCode {
    #[msg("Request ID does not match")]
    RequestIdMismatch,
    
    #[msg("No response available yet")]
    NoResponse,
    
    #[msg("Request ID exceeds 60 bytes")]
    RequestIdTooLong,
    
    #[msg("Response exceeds 2000 bytes")]
    ResponseTooLarge,
    
    #[msg("Unauthorized: caller is not the request authority")]
    Unauthorized,
    
    #[msg("Minimum votes must be greater than 0")]
    InvalidMinVotes,
    
    #[msg("Approval threshold must be between 1 and 100")]
    InvalidApprovalThreshold,
}

let clock = Clock::get()?;
let request_id = format!(
    "req_{}_{}",
    ctx.accounts.authority.key(),
    clock.unix_timestamp
);

const MAX_RESPONSE_LEN: usize = 2000; // Adjust as needed

require!(
    response.len() <= MAX_RESPONSE_LEN,
    ErrorCode::ResponseTooLarge
);

#[event]
pub struct ResponseReceived {
    pub request_id: String,
    pub response_preview: String,
}

emit!(ResponseReceived {
    request_id,
    response_preview: preview_string,
});

let response_str = String::from_utf8(response.clone())
    .unwrap_or_else(|_| {
        format!("[Binary data: {} bytes]", response.len())
    });

const PRODUCTION_MIN_VOTES: u8 = 3;
const PRODUCTION_THRESHOLD: u8 = 66; // 66%

create_llm_request(
    // ... other params
    PRODUCTION_MIN_VOTES,
    PRODUCTION_THRESHOLD,
)?;

#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
pub struct Message {
    pub role: String,
    pub content: String,
}

#[account]
pub struct LLMRequest {
    pub id: String,
    pub caller_program: Pubkey,
    pub provider: String,
    pub model_id: String,
    pub callback_accounts: Vec<Pubkey>,
    pub callback_writable: Vec<bool>,
    pub status: RequestStatus,
    pub created_at: i64,
    pub min_votes: u8,
    pub approval_threshold: u8,
    pub votes: Vec<OracleVote>,
    pub winning_hash: Option<[u8; 32]>,
    pub total_votes_cast: u8,
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone, PartialEq)]
pub enum RequestStatus {
    Pending,           // Voting in progress
    VotingCompleted,   // Consensus reached, awaiting fulfillment
    Fulfilled,         // Response delivered to callback
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct OracleVote {
    pub oracle: Pubkey,
    pub response_hash: [u8; 32],
}

#[event]
pub struct RequestCreated {
    pub request_id: String,
    pub caller_program: Pubkey,
    pub provider: String,
    pub model_id: String,
    pub messages: Vec<Message>,
    pub min_votes: u8,
    pub approval_threshold: u8,
}

#[event]
pub struct VotingCompleted {
    pub request_id: String,
    pub winning_hash: [u8; 32],
    pub vote_count: u8,
    pub total_votes: u8,
}

#[event]
pub struct RequestFulfilled {
    pub request_id: String,
    pub response_length: u64,
}