blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

RpcClient now returns Signatures instead of Strings (#9129)

This commit is contained in:
Michael Vines 2020-03-27 15:46:00 -07:00 committed by GitHub
parent 74aed5cb58
commit 4a8b1d9b2c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 44 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cli/src/cli.rs
View File

@ -1153,7 +1153,7 @@ fn process_balance(
}
fn process_confirm(rpc_client: &RpcClient, signature: &Signature) -> ProcessResult {
match rpc_client.get_signature_status(&signature.to_string()) {
match rpc_client.get_signature_status(&signature) {
Ok(status) => {
if let Some(result) = status {
match result {
@ -2165,7 +2165,7 @@ pub fn request_and_confirm_airdrop(
log_instruction_custom_error::<SystemError>(result)
}
pub fn log_instruction_custom_error<E>(result: ClientResult<String>) -> ProcessResult
pub fn log_instruction_custom_error<E>(result: ClientResult<Signature>) -> ProcessResult
where
E: 'static + std::error::Error + DecodeError<E> + FromPrimitive,
{
@ -2182,7 +2182,7 @@ where
}
Err(err.into())
}
Ok(sig) => Ok(sig),
Ok(sig) => Ok(sig.to_string()),
}
}

4
cli/src/storage.rs
View File

@ -266,8 +266,8 @@ pub fn process_claim_storage_reward(
&fee_calculator,
&tx.message,
)?;
let signature_str = rpc_client.send_and_confirm_transaction_with_spinner(&mut tx, &signers)?;
Ok(signature_str)
let signature = rpc_client.send_and_confirm_transaction_with_spinner(&mut tx, &signers)?;
Ok(signature.to_string())
}
pub fn process_show_storage_account(

79
client/src/rpc_client.rs
View File

@ -28,7 +28,6 @@ use solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY;
use std::{
error,
net::SocketAddr,
str::FromStr,
thread::sleep,
time::{Duration, Instant},
};
@ -67,7 +66,7 @@ impl RpcClient {
}
}
pub fn confirm_transaction(&self, signature: &str) -> ClientResult<bool> {
pub fn confirm_transaction(&self, signature: &Signature) -> ClientResult<bool> {
Ok(self
.confirm_transaction_with_commitment(signature, CommitmentConfig::default())?
.value)
@ -75,14 +74,14 @@ impl RpcClient {
pub fn confirm_transaction_with_commitment(
&self,
signature: &str,
signature: &Signature,
commitment_config: CommitmentConfig,
) -> RpcResult<bool> {
let response = self
.client
.send(
&RpcRequest::ConfirmTransaction,
json!([signature, commitment_config]),
json!([signature.to_string(), commitment_config]),
0,
)
.map_err(|err| err.into_with_command("ConfirmTransaction"))?;
@ -91,28 +90,32 @@ impl RpcClient {
.map_err(|err| ClientError::new_with_command(err.into(), "ConfirmTransaction"))
}
pub fn send_transaction(&self, transaction: &Transaction) -> ClientResult<String> {
pub fn send_transaction(&self, transaction: &Transaction) -> ClientResult<Signature> {
let serialized_encoded = bs58::encode(serialize(transaction).unwrap()).into_string();
let signature =
let response =
self.client
.send(&RpcRequest::SendTransaction, json!([serialized_encoded]), 5)?;
if signature.as_str().is_none() {
Err(RpcError::ForUser("Received result of an unexpected type".to_string()).into())
} else {
Ok(signature.as_str().unwrap().to_string())
match response.as_str() {
None => {
Err(RpcError::ForUser("Received result of an unexpected type".to_string()).into())
}
Some(signature_base58_str) => signature_base58_str
.parse::<Signature>()
.map_err(|err| RpcError::ParseError(err.to_string()).into()),
}
}
pub fn get_signature_status(
&self,
signature: &str,
signature: &Signature,
) -> ClientResult<Option<transaction::Result<()>>> {
self.get_signature_status_with_commitment(signature, CommitmentConfig::default())
}
pub fn get_signature_status_with_commitment(
&self,
signature: &str,
signature: &Signature,
commitment_config: CommitmentConfig,
) -> ClientResult<Option<transaction::Result<()>>> {
let signature_status = self.client.send(
@ -346,13 +349,13 @@ impl RpcClient {
&self,
transaction: &mut Transaction,
signer_keys: &T,
) -> ClientResult<String> {
) -> ClientResult<Signature> {
let mut send_retries = 20;
loop {
let mut status_retries = 15;
let signature_str = self.send_transaction(transaction)?;
let signature = self.send_transaction(transaction)?;
let status = loop {
let status = self.get_signature_status(&signature_str)?;
let status = self.get_signature_status(&signature)?;
if status.is_none() {
status_retries -= 1;
if status_retries == 0 {
@ -368,7 +371,7 @@ impl RpcClient {
};
send_retries = if let Some(result) = status.clone() {
match result {
Ok(_) => return Ok(signature_str),
Ok(_) => return Ok(signature),
Err(TransactionError::AccountInUse) => {
// Fetch a new blockhash and re-sign the transaction before sending it again
self.resign_transaction(transaction, signer_keys)?;
@ -830,10 +833,9 @@ impl RpcClient {
) -> ClientResult<()> {
let now = Instant::now();
loop {
if let Ok(Some(_)) = self.get_signature_status_with_commitment(
&signature.to_string(),
commitment_config.clone(),
) {
if let Ok(Some(_)) =
self.get_signature_status_with_commitment(&signature, commitment_config.clone())
{
break;
}
if now.elapsed().as_secs() > 15 {
@ -971,7 +973,7 @@ impl RpcClient {
&self,
transaction: &mut Transaction,
signer_keys: &T,
) -> ClientResult<String> {
) -> ClientResult<Signature> {
let mut confirmations = 0;
let progress_bar = new_spinner_progress_bar();
@ -982,23 +984,21 @@ impl RpcClient {
));
let mut send_retries = 20;
let signature_str = loop {
let signature = loop {
let mut status_retries = 15;
let (signature_str, status) = loop {
let signature_str = self.send_transaction(transaction)?;
let (signature, status) = loop {
let signature = self.send_transaction(transaction)?;
// Get recent commitment in order to count confirmations for successful transactions
let status = self.get_signature_status_with_commitment(
&signature_str,
CommitmentConfig::recent(),
)?;
let status = self
.get_signature_status_with_commitment(&signature, CommitmentConfig::recent())?;
if status.is_none() {
status_retries -= 1;
if status_retries == 0 {
break (signature_str, status);
break (signature, status);
}
} else {
break (signature_str, status);
break (signature, status);
}
if cfg!(not(test)) {
@ -1023,7 +1023,7 @@ impl RpcClient {
if let Some(result) = status {
match result {
Ok(_) => {
break signature_str;
break signature;
}
Err(err) => {
return Err(err.into());
@ -1036,19 +1036,13 @@ impl RpcClient {
}
}
};
let signature = Signature::from_str(&signature_str).map_err(|_| {
ClientError::from(ClientErrorKind::Custom(format!(
"Returned string {} cannot be parsed as a signature",
signature_str
)))
})?;
loop {
// Return when default (max) commitment is reached
// Failed transactions have already been eliminated, `is_some` check is sufficient
if self.get_signature_status(&signature_str)?.is_some() {
if self.get_signature_status(&signature)?.is_some() {
progress_bar.set_message("Transaction confirmed");
progress_bar.finish_and_clear();
return Ok(signature_str);
return Ok(signature);
}
progress_bar.set_message(&format!(
"[{}/{}] Waiting for confirmations",
@ -1210,7 +1204,7 @@ mod tests {
let tx = system_transaction::transfer(&key, &to, 50, blockhash);
let signature = rpc_client.send_transaction(&tx);
assert_eq!(signature.unwrap(), SIGNATURE.to_string());
assert_eq!(signature.unwrap(), SIGNATURE.parse().unwrap());
let rpc_client = RpcClient::new_mock("fails".to_string());
@ -1233,18 +1227,17 @@ mod tests {
#[test]
fn test_get_signature_status() {
let signature = Signature::default();
let rpc_client = RpcClient::new_mock("succeeds".to_string());
let signature = "good_signature";
let status = rpc_client.get_signature_status(&signature).unwrap();
assert_eq!(status, Some(Ok(())));
let rpc_client = RpcClient::new_mock("sig_not_found".to_string());
let signature = "sig_not_found";
let status = rpc_client.get_signature_status(&signature).unwrap();
assert_eq!(status, None);
let rpc_client = RpcClient::new_mock("account_in_use".to_string());
let signature = "account_in_use";
let status = rpc_client.get_signature_status(&signature).unwrap();
assert_eq!(status, Some(Err(TransactionError::AccountInUse)));
}

4
client/src/thin_client.rs
View File

@ -471,7 +471,7 @@ impl SyncClient for ThinClient {
) -> TransportResult<Option<transaction::Result<()>>> {
let status = self
.rpc_client()
.get_signature_status(&signature.to_string())
.get_signature_status(&signature)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -488,7 +488,7 @@ impl SyncClient for ThinClient {
) -> TransportResult<Option<transaction::Result<()>>> {
let status = self
.rpc_client()
.get_signature_status_with_commitment(&signature.to_string(), commitment_config)
.get_signature_status_with_commitment(&signature, commitment_config)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,

2
core/tests/client.rs
View File

@ -58,7 +58,7 @@ fn test_rpc_client() {
let now = Instant::now();
while now.elapsed().as_secs() <= 20 {
let response = client
.confirm_transaction_with_commitment(signature.as_str(), CommitmentConfig::default())
.confirm_transaction_with_commitment(&signature, CommitmentConfig::default())
.unwrap();
if response.value {