I can provide you with a sample article on how to airdrop Solana keys using a randomly generated key pair for testing purposes.
Airdropping Solana Keys: A Step-by-Step Guide
As a developer, it is essential to practice deploying and testing your blockchain applications. In this example, we will demonstrate how to create an airdrop on the Solana Testnet using a randomly generated key pair for testing purposes.
Prerequisites
- Install the Solana CLI (Command Line Interface) on your machine.
- Set up a Solana Testnet account with the required credentials.
Step 1: Create a New Wallet and Key Pair
Create a new wallet in the Solana CLI:
solana key create --output json
This will create a JSON file containing the private key and public address of your wallet. We will use this private key to release keys later.
Step 2: Generate Random Key Pairs for Airdrop
To generate random key pairs, we can use thesolana_sdk::keypairmodule.
use solana_sdk::signer::{Keyid, Signer};
use solana_sdk::sysvar::Pubkey;
use solana_sdk::transaction::{TransactionId, TransactionOutput};
use solana_sdk::keypair::{Keypair, KeypairBuilder};
fn generate_airdrop_keypair() -> (Keypair, Keypair) {
let key_pair = KeyPairBuilder::new().generate_keyid().unwrap();
while true {
match &*key_pair.public_key.as_ref() {
Pubkey::Random => break,
_ => (),
}
}
let wallet_id = Keyid::from_bytes(&key_pair.key.id).unwrap();
let wallet_out = TransactionOutput::new(
Key::from_bytes(&wallet_id).unwrap(),
SolanaId::default(),
vec![],
Vec::new(),
);
(key_pair, wallet_out)
}
This function generates a new random key pair and creates a transaction output with the public key of the key pair. We will use this result to release keys later.
Step 3: Create an Airdrop Transaction
Create an airdrop transaction using the Transactionstructure.
use solana_sdk::transaction::{Transaction, TransactionBuilder};
fn create_airdrop_transaction(
public_key_pair: Keypair,
airdrop_id: Pubkey,
) -> Transaction {
let mut tx = TransactionBuilder::new()
.set_system_instruction_id("airdrop")
.build();
tx.add_input_output_transaction(
TransactionOutput::new(
public_key_pair.public_key.as_ref(),
SolanaId::default(),
vec![],
Vec::new(),
),
);
tx.add_amount(1e18); // 1 ether
tx.sign(&public_key_pair)
}
This function creates a new transaction with the public key of the key pair, an input-output transaction to obtain the keys, and a single amount of 1 ether.
Step 4: Debit the account
To debit an account on the Solana Testnet, we need to use the solana_sdk::debitsmodule. You can find more information about debiting accounts in the [Solana SDK documentation](
For example:
“ rust
use solana_sdk::debits;
fn debit_account(key_pair: KeyPair, debit_amount: u64) -> Result<(), &'static str> {
let debit = DebitsBuilder::new();
debits.add_transaction(
TransactionBuilder::new()
.set_system_instruction_id(“debit”)
.build(),
);
debits.set_fee(1000); // 1 ETH
match &*key_pair.key.public_key.as_ref() {
Pubkey::Random => return Ok(()),
_ => (),
}
let amount = u64::from_debited_amount(debit_amount, 1e18);
debits.add_amount(amount);
let transaction_id = key_pair.public_key.as_ref().unwrap();
match debits.sign(&key_pair) {
Ok(_) => {
// Successful transaction
println!
Leave a Reply