quorum-sdk 0.1.0

Official Rust SDK for Quorum routing intelligence on Solana
Documentation
use solana_sdk::{
    instruction::Instruction,
    compute_budget::ComputeBudgetInstruction,
};

pub fn prepend_priority_fee(instructions: &mut Vec<Instruction>, micro_lamports: u64) {
    instructions.insert(0, set_priority_fee_ix(micro_lamports));
}

pub fn prepend_priority_fee_with_limit(
    instructions: &mut Vec<Instruction>,
    micro_lamports: u64,
    compute_units: u32,
) {
    instructions.insert(0, set_compute_unit_limit_ix(compute_units));
    instructions.insert(0, set_priority_fee_ix(micro_lamports));
}

pub fn set_priority_fee_ix(micro_lamports: u64) -> Instruction {
    ComputeBudgetInstruction::set_compute_unit_price(micro_lamports)
}

pub fn set_compute_unit_limit_ix(units: u32) -> Instruction {
    ComputeBudgetInstruction::set_compute_unit_limit(units)
}

#[cfg(test)]
mod tests {
    use super::*;
    use solana_sdk::pubkey::Pubkey;

    fn dummy_instruction() -> Instruction {
        Instruction {
            program_id: Pubkey::default(),
            accounts: vec![],
            data: vec![1, 2, 3],
        }
    }

    fn compute_budget_id() -> Pubkey {
        ComputeBudgetInstruction::set_compute_unit_price(0).program_id
    }

    #[test]
    fn prepend_inserts_at_front() {
        let mut instructions = vec![dummy_instruction(), dummy_instruction()];
        prepend_priority_fee(&mut instructions, 50_000);
        assert_eq!(instructions.len(), 3);
        assert_eq!(instructions[0].program_id, compute_budget_id());
    }

    #[test]
    fn prepend_with_limit_inserts_two_at_front() {
        let mut instructions = vec![dummy_instruction()];
        prepend_priority_fee_with_limit(&mut instructions, 50_000, 200_000);
        assert_eq!(instructions.len(), 3);
        let cb_id = compute_budget_id();
        assert_eq!(instructions[0].program_id, cb_id);
        assert_eq!(instructions[1].program_id, cb_id);
        assert_eq!(instructions[2].data, vec![1, 2, 3]);
    }

    #[test]
    fn prepend_on_empty_vec() {
        let mut instructions: Vec<Instruction> = vec![];
        prepend_priority_fee(&mut instructions, 100_000);
        assert_eq!(instructions.len(), 1);
        assert_eq!(instructions[0].program_id, compute_budget_id());
    }

    #[test]
    fn zero_fee_is_allowed() {
        let ix = set_priority_fee_ix(0);
        assert_eq!(ix.program_id, compute_budget_id());
    }
}