Solana: How to get Raydium swap instruction account keys using a Mint address in Rust without making an API call?

I can’t help you build an application that uses the Solana blockchain’s Raydium Swap feature without first understanding how your smart contracts are structured.

Here’s a simple example of creating a mint in Solana using Rust:

MintExample.rs


use std::collections::{HashMap, VecDeque};
const MINT_NAME: &str = "RaydiumSwap";
const MINT_ADDRESS: &str = "1..."; // Replace with the desired mint address
#[output (debug)]
struct MintInfo {
Pub name: String,
pub token: String,
}
fn create_mint() -> (MintInfo, Vec) {
let mut info = MintInfo {
name: MINT_NAME.to_string(),
symbol: MINT_ADDRESS.to_string(),
};
let mint_info: Vec = vec![];
info
}

MainExample.rs


use std::collections::{HashMap, VecDeque};
const MAINLINK_MINT_NAME: &str = "Raydium Swap";
const MAIN_chain_MINT_ADDRESS: &str = "1..."; // Replace with desired mint address
fn main() {
let (mint_info, mint_data) = create_mint();
println!("Mint information:");
println!("{:?}", mint_info);
println!("Mint data:");
man 0..10 {
print!("{}: {}", mint_info.name, mint_info.symbol);
}
}

To get the account keys for a Mint address using a Mint address in Rust without making an API call, you can use this method:

get_instruction_account_keys.rs


use solana_program::{
account_info:: AccountInfo,
entrypoint::ProgramResult,
program_error::PrintProgramError,
pubkey::Pubkey,
};
Use std::collections::{HashMap, VecDeque};
const MAIN_chain_MINT_ADDRESS: &Pubkey = Pubkey::new("1..."); // Replace with the desired Mint address
fn get_instruction_account_keys(
account_info: AccountInfo,
key_info_map: &mut HashMap,
) -> ProgramResult {
mut instruction_keys = VecDeque::new();
while let Some(info) = account_info.next() {
if info.key == MAIN_chain_MINT_ADDRESS {
a break;
}
match key_info_map.get_mut(&info.key) {
some(key_info) => {
if !instruction_keys.is_empty() && instruction_keys.last().unwrap().key != info.key {
return Err (
PrintProgramError::new("Multiple instructions found with the same key".to_string()),
);
}
instruction_keys.push_back(info.key);
}
No => {}
}
}
key_info_map.insert(Pubkey::new(MAIN_chain_MINT_ADDRESS), KeyInfo {
pub_key: info.key.to_bytes(),
..Default::default()
}) {
OK (_) => println! ("Keys found"),
Err(err) => eprintln!("Failed to get instruction keys: {}", error),
}
instruction_keys
}
fn main() -> ProgramResult {
let mut key_info_map = HashMap::new();
for account solana_program::test_accounts() {
let info = solana_program::account_info::get_account_info(&account.key)?;
if let Some(key_info) = key_info_map.get_mut(&info.key) {
get_instruction_account_keys(info, &mut key_info_map)?;
}
}
OK (())
}

Note that this example assumes you are using Solana rust-SDK 1.6.0 or later and the “solana-program” package.

For more information about working with Rust and Solana, see the [official documentation](

Leave a Comment Cancel Reply