noormohammedb/hacker-challenge-sgx-general
1
0
Fork 0
forked from general/hacker-challenge
Code Pull Requests Activity

async solana client

Browse Source 
remove blocking on actix handler
asynchronous mint method
fix clippy on node comparison
This commit is contained in:
Noor 2024-12-30 22:47:45 +00:00
parent 8226f03e7c
commit 5514f7b794
3 changed files with 18 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/datastore.rs
View File

@ -245,10 +245,8 @@ impl State {
pub async fn process_node_update(&self, (node_ip, node_info): (String, NodeInfo)) -> bool {
let is_update_mine = node_ip.eq(&self.my_ip);
let mut nodes = self.nodes.write().await;
let is_update_new = nodes
.get(&node_ip)
.map(|curr_info| node_info.is_newer_than(&curr_info))
.unwrap_or(true);
let is_update_new =
nodes.get(&node_ip).map(|curr_info| node_info.is_newer_than(curr_info)).unwrap_or(true);
if is_update_new {
println!("Inserting: {}, {}", node_ip, node_info.to_json());
let _ = nodes.insert(node_ip, node_info);

4
src/http_server.rs
View File

@ -66,10 +66,8 @@ async fn mint(
) -> impl Responder {
let recipient = req.into_inner().wallet;
state.increase_mint_requests().await;
let result =
web::block(move || sol_client.mint(&recipient).map_err(|e| e.to_string())).await.unwrap(); // TODO: check if this can get a BlockingError
match result {
match sol_client.mint(&recipient).await {
Ok(s) => {
state.increase_mints().await;
HttpResponse::Ok().body(format!(r#"{{" signature": "{s} "}}"#))

30
src/solana.rs
View File

@ -1,6 +1,6 @@
#![allow(dead_code)]
use crate::{grpc::challenge::Keys, persistence::KeysFile};
use solana_client::rpc_client::RpcClient;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_program::program_pack::Pack;
use solana_sdk::{
pubkey::Pubkey, signature::keypair::Keypair, signer::Signer, system_instruction,
@ -28,7 +28,7 @@ pub struct SolClient {
impl SolClient {
pub async fn create_new_token() -> Self {
let client = RpcClient::new(RPC_URL);
let client = RpcClient::new(RPC_URL.to_string());
let keypair = Keypair::new();
let token = create_token(&client, &keypair).await;
Self { client, keypair, token }
@ -42,10 +42,10 @@ impl SolClient {
self.get_keys().into()
}
pub fn mint(&self, recipient: &str) -> Result<String, Box<dyn std::error::Error>> {
pub async fn mint(&self, recipient: &str) -> Result<String, Box<dyn std::error::Error>> {
use std::str::FromStr;
let recipient = solana_sdk::pubkey::Pubkey::from_str(recipient)?;
let associated_token_address = self.create_token_account(&recipient)?;
let associated_token_address = self.create_token_account(&recipient).await?;
let mint_to_instruction = mint_to(
&spl_token::id(),
&self.token,
@ -59,32 +59,32 @@ impl SolClient {
&[mint_to_instruction],
Some(&self.keypair.pubkey()),
&[&self.keypair],
self.client.get_latest_blockhash()?,
self.client.get_latest_blockhash().await?,
);
let signature = self.client.send_and_confirm_transaction(&transaction)?;
let signature = self.client.send_and_confirm_transaction(&transaction).await?;
Ok(signature.to_string())
}
fn create_token_account(
async fn create_token_account(
&self,
recipient: &Pubkey,
) -> Result<Pubkey, Box<dyn std::error::Error>> {
let address = get_associated_token_address(recipient, &self.token);
if self.client.get_account(&address).is_err() {
if self.client.get_account(&address).await.is_err() {
let create_token_account_instruction = create_associated_token_account(
&self.keypair.pubkey(),
recipient,
&self.token,
&spl_token::id(),
);
let recent_blockhash = self.client.get_latest_blockhash()?;
let recent_blockhash = self.client.get_latest_blockhash().await?;
let tx = Transaction::new_signed_with_payer(
&[create_token_account_instruction],
Some(&self.keypair.pubkey()),
&[&self.keypair],
recent_blockhash,
);
self.client.send_and_confirm_transaction(&tx)?;
self.client.send_and_confirm_transaction(&tx).await?;
}
Ok(address)
}
@ -114,7 +114,7 @@ impl TryFrom<Keys> for SolClient {
};
let token = Pubkey::from_str(&keys.token_address)
.map_err(|_| "Could not parse wallet address.".to_string())?;
Ok(Self { client: RpcClient::new(RPC_URL), keypair, token })
Ok(Self { client: RpcClient::new(RPC_URL.to_string()), keypair, token })
}
}
@ -131,7 +131,7 @@ async fn wait_for_sol(client: &RpcClient, pubkey: &Pubkey) {
println!("Waiting to receive 0.01 SOL in address {pubkey}");
loop {
sleep(Duration::from_secs(30)).await;
match client.get_balance(pubkey) {
match client.get_balance(pubkey).await {
Ok(balance) => {
println!("Got {balance} lamports.");
if balance > 10_000_000 {
@ -148,7 +148,7 @@ async fn create_token(client: &RpcClient, keypair: &Keypair) -> Pubkey {
let mint_keypair = Keypair::new();
let payer = Keypair::from_base58_string(&keypair.to_base58_string());
let mint_rent = client.get_minimum_balance_for_rent_exemption(Mint::LEN).unwrap();
let mint_rent = client.get_minimum_balance_for_rent_exemption(Mint::LEN).await.unwrap();
let create_mint_account_ix = system_instruction::create_account(
&payer.pubkey(),
@ -162,7 +162,7 @@ async fn create_token(client: &RpcClient, keypair: &Keypair) -> Pubkey {
initialize_mint(&spl_token::id(), &mint_keypair.pubkey(), &payer.pubkey(), None, 9)
.unwrap();
let recent_blockhash = client.get_latest_blockhash().unwrap();
let recent_blockhash = client.get_latest_blockhash().await.unwrap();
let tx = Transaction::new_signed_with_payer(
&[create_mint_account_ix, init_mint_ix],
Some(&payer.pubkey()),
@ -170,7 +170,7 @@ async fn create_token(client: &RpcClient, keypair: &Keypair) -> Pubkey {
recent_blockhash,
);
let signature = client.send_and_confirm_transaction(&tx).unwrap();
let signature = client.send_and_confirm_transaction(&tx).await.unwrap();
println!("Mint created: {}", mint_keypair.pubkey());
println!("Transaction signature: {}", signature);