Rust로 프로그램 개발하기

[lib]
crate-type = ["cdylib", "lib"]

[package]
name = "hello_world"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib", "lib"]

[dependencies]
solana-program = "2.2.0"

use solana_program::{
    account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, msg, pubkey::Pubkey,
};

entrypoint!(process_instruction);

pub fn process_instruction(
    _program_id: &Pubkey,
    _accounts: &[AccountInfo],
    _instruction_data: &[u8],
) -> ProgramResult {
    msg!("Hello, world!");
    Ok(())
}

cargo new hello_world --lib
cd hello_world

[package]
name = "hello_world"
version = "0.1.0"
edition = "2021"

[dependencies]
solana-program = "1.16.0"

[lib]
crate-type = ["cdylib", "lib"]

use solana_program::{
    account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, pubkey::Pubkey,
    msg,
};

entrypoint!(process_instruction);

pub fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    msg!("Hello, world!");
    Ok(())
}

[package]
name = "hello_world"
version = "0.1.0"
edition = "2021"

[dependencies]
solana-program = "1.16.0"

[dev-dependencies]
solana-program-test = "1.16.0"
solana-sdk = "1.16.0"

[lib]
crate-type = ["cdylib", "lib"]

#[cfg(test)]
mod test {
    use super::*;
    use solana_program::clock::Epoch;
    use solana_program_test::*;
    use solana_sdk::{account::Account, pubkey::Pubkey, signature::Signer, transaction::Transaction};

    #[tokio::test]
    async fn test_transaction() {
        let program_id = Pubkey::new_unique();
        let mut program_test = ProgramTest::new(
            "hello_world",
            program_id,
            processor!(process_instruction),
        );

        // 프로그램이 상호작용할 계정 추가
        let account_pubkey = Pubkey::new_unique();
        program_test.add_account(
            account_pubkey,
            Account {
                lamports: 5,
                data: vec![0, 0, 0, 0],
                owner: program_id,
                executable: false,
                rent_epoch: Epoch::default(),
            },
        );

        let (mut banks_client, payer, recent_blockhash) = program_test.start().await;

        // 트랜잭션 생성 및 전송
        let mut transaction = Transaction::new_with_payer(
            &[solana_program::instruction::Instruction::new_with_bincode(
                program_id,
                &[0],
                vec![],
            )],
            Some(&payer.pubkey()),
        );
        transaction.sign(&[&payer], recent_blockhash);

        banks_client.process_transaction(transaction).await.unwrap();
    }
}

$ cargo test
   Compiling hello_world v0.1.0 (/home/user/hello_world)
    Finished test [unoptimized + debuginfo] target(s) in 1.35s
     Running unittests src/lib.rs (target/debug/deps/hello_world-5fa5eb7852f21b88)

running 1 test
Program log: Hello, world!
test test::test_transaction ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.30s

solana config set --url localhost

Config File: /home/user/.config/solana/cli/config.yml
RPC URL: http://localhost:8899
WebSocket URL: ws://localhost:8900/ (computed)
Keypair Path: /home/user/.config/solana/id.json
Commitment: confirmed

solana-test-validator

Program Id: 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz
Signature:
5osMiNMiDZGM7L1e2tPHxU8wdB8gwG8fDnXLg5G7SbhwFz4dHshYgAijk4wSQL5cXiu8z1MMou5kLadAQuHp7ybH

[[example]]
name = "client"
path = "examples/client.rs"

use solana_client::rpc_client::RpcClient;
use solana_sdk::{
    commitment_config::CommitmentConfig,
    instruction::Instruction,
    pubkey::Pubkey,
    signature::{Keypair, Signer},
    transaction::Transaction,
};
use std::str::FromStr;

#[tokio::main]
async fn main() {
    // Program ID (replace with your actual program ID)
    let program_id = Pubkey::from_str("4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz").unwrap();

    // Connect to the Solana devnet
    let rpc_url = String::from("http://localhost:8899");
    let client = RpcClient::new_with_commitment(rpc_url, CommitmentConfig::confirmed());

    // Generate a new keypair for the payer
    let payer = Keypair::new();

    // Request airdrop
    let airdrop_amount = 1_000_000_000; // 1 SOL
    let signature = client
        .request_airdrop(&payer.pubkey(), airdrop_amount)
        .expect("Failed to request airdrop");

    // Wait for airdrop confirmation
    loop {
        let confirmed = client.confirm_transaction(&signature).unwrap();
        if confirmed {
            break;
        }
    }

    // Create the instruction
    let instruction = Instruction::new_with_borsh(
        program_id,
        &(),    // Empty instruction data
        vec![], // No accounts needed
    );

    // Add the instruction to new transaction
    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
    transaction.sign(&[&payer], client.get_latest_blockhash().unwrap());

    // Send and confirm the transaction
    match client.send_and_confirm_transaction(&transaction) {
        Ok(signature) => println!("Transaction Signature: {}", signature),
        Err(err) => eprintln!("Error sending transaction: {}", err),
    }
}

Transaction Signature: 54TWxKi3Jsi3UTeZbhLGUFX6JQH7TspRJjRRFZ8NFnwG5BXM9udxiX77bAACjKAS9fGnVeEazrXL4SfKrW7xZFYV

pub fn process_instruction(
    _program_id: &Pubkey,
    _accounts: &[AccountInfo],
    _instruction_data: &[u8],
) -> ProgramResult {
-
    msg!("Hello, world!");
+
    msg!("Hello, Solana!");
    Ok(())
}

running 1 test
Logs: [
    "Program 5y8bHrnwfq2dLDgLn3WoTHb9dDuyorj9gyapW6aeyrpV invoke [1]",
    "Program log: Hello, Solana!",
    "Program 5y8bHrnwfq2dLDgLn3WoTHb9dDuyorj9gyapW6aeyrpV consumed 211 of 200000 compute units",
    "Program 5y8bHrnwfq2dLDgLn3WoTHb9dDuyorj9gyapW6aeyrpV success",
]
test test::test_hello_world ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.08s

Closed Program Id 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz, 0.1350588 SOL
reclaimed

Error: Program 4Ujf5fXfLx2PAwRqcECCLtgDxHKPznoJpa43jUBxFfMz has been closed, use
a new Program Id