2019-11-06 13:15:00 -08:00
|
|
|
use crate::{
|
2020-03-17 16:58:02 -07:00
|
|
|
client_error::{ClientError, ClientErrorKind, Result as ClientResult},
|
2020-05-20 18:40:45 -07:00
|
|
|
http_sender::HttpSender,
|
|
|
|
mock_sender::{MockSender, Mocks},
|
2020-05-31 21:54:12 -07:00
|
|
|
rpc_config::{RpcLargestAccountsConfig, RpcSendTransactionConfig},
|
2020-03-12 23:20:49 -07:00
|
|
|
rpc_request::{RpcError, RpcRequest},
|
2020-03-24 05:05:38 -07:00
|
|
|
rpc_response::*,
|
2020-05-20 18:40:45 -07:00
|
|
|
rpc_sender::RpcSender,
|
2019-11-06 13:15:00 -08:00
|
|
|
};
|
2019-03-16 17:17:44 -07:00
|
|
|
use bincode::serialize;
|
2020-03-17 16:58:02 -07:00
|
|
|
use indicatif::{ProgressBar, ProgressStyle};
|
2019-03-16 22:37:20 -07:00
|
|
|
use log::*;
|
|
|
|
use serde_json::{json, Value};
|
2019-09-27 22:00:30 -07:00
|
|
|
use solana_sdk::{
|
|
|
|
account::Account,
|
2020-04-29 13:12:38 -07:00
|
|
|
clock::{
|
|
|
|
Slot, UnixTimestamp, DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT,
|
|
|
|
MAX_HASH_AGE_IN_SECONDS,
|
|
|
|
},
|
2019-11-06 13:15:00 -08:00
|
|
|
commitment_config::CommitmentConfig,
|
2020-05-20 16:42:46 -07:00
|
|
|
epoch_info::EpochInfo,
|
2019-10-22 13:41:18 -07:00
|
|
|
epoch_schedule::EpochSchedule,
|
2020-02-28 12:27:01 -08:00
|
|
|
fee_calculator::{FeeCalculator, FeeRateGovernor},
|
2019-09-27 22:00:30 -07:00
|
|
|
hash::Hash,
|
|
|
|
pubkey::Pubkey,
|
2020-02-20 12:13:23 -08:00
|
|
|
signature::Signature,
|
2020-05-09 09:06:32 -07:00
|
|
|
transaction::{self, Transaction},
|
2019-09-27 22:00:30 -07:00
|
|
|
};
|
2020-04-15 20:51:05 -07:00
|
|
|
use solana_transaction_status::{
|
|
|
|
ConfirmedBlock, ConfirmedTransaction, TransactionEncoding, TransactionStatus,
|
|
|
|
};
|
2020-03-17 16:58:02 -07:00
|
|
|
use solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY;
|
2019-09-27 22:00:30 -07:00
|
|
|
use std::{
|
|
|
|
net::SocketAddr,
|
|
|
|
thread::sleep,
|
|
|
|
time::{Duration, Instant},
|
|
|
|
};
|
2019-03-16 22:37:20 -07:00
|
|
|
|
|
|
|
pub struct RpcClient {
|
2020-05-20 18:40:45 -07:00
|
|
|
sender: Box<dyn RpcSender + Send + Sync + 'static>,
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
impl RpcClient {
|
2020-05-20 18:40:45 -07:00
|
|
|
pub fn new_sender<T: RpcSender + Send + Sync + 'static>(sender: T) -> Self {
|
2019-03-16 22:37:20 -07:00
|
|
|
Self {
|
2020-05-20 18:40:45 -07:00
|
|
|
sender: Box::new(sender),
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-20 18:40:45 -07:00
|
|
|
pub fn new(url: String) -> Self {
|
|
|
|
Self::new_sender(HttpSender::new(url))
|
|
|
|
}
|
|
|
|
|
2019-03-16 22:37:20 -07:00
|
|
|
pub fn new_mock(url: String) -> Self {
|
2020-05-20 18:40:45 -07:00
|
|
|
Self::new_sender(MockSender::new(url))
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
|
2019-12-27 12:35:49 -08:00
|
|
|
pub fn new_mock_with_mocks(url: String, mocks: Mocks) -> Self {
|
2020-05-20 18:40:45 -07:00
|
|
|
Self::new_sender(MockSender::new_with_mocks(url, mocks))
|
2019-12-27 12:35:49 -08:00
|
|
|
}
|
|
|
|
|
2019-03-16 22:37:20 -07:00
|
|
|
pub fn new_socket(addr: SocketAddr) -> Self {
|
|
|
|
Self::new(get_rpc_request_str(addr, false))
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn new_socket_with_timeout(addr: SocketAddr, timeout: Duration) -> Self {
|
|
|
|
let url = get_rpc_request_str(addr, false);
|
2020-05-20 18:40:45 -07:00
|
|
|
Self::new_sender(HttpSender::new_with_timeout(url, timeout))
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
|
2020-03-27 15:46:00 -07:00
|
|
|
pub fn confirm_transaction(&self, signature: &Signature) -> ClientResult<bool> {
|
2019-11-12 11:49:41 -08:00
|
|
|
Ok(self
|
|
|
|
.confirm_transaction_with_commitment(signature, CommitmentConfig::default())?
|
|
|
|
.value)
|
2019-11-06 19:08:03 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn confirm_transaction_with_commitment(
|
|
|
|
&self,
|
2020-03-27 15:46:00 -07:00
|
|
|
signature: &Signature,
|
2019-11-06 19:08:03 -08:00
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> RpcResult<bool> {
|
2020-04-06 03:04:54 -07:00
|
|
|
let Response { context, value } = self.get_signature_statuses(&[*signature])?;
|
2019-11-12 11:49:41 -08:00
|
|
|
|
2020-04-04 23:31:24 -07:00
|
|
|
Ok(Response {
|
|
|
|
context,
|
|
|
|
value: value[0]
|
|
|
|
.as_ref()
|
2020-04-06 03:04:54 -07:00
|
|
|
.filter(|result| result.satisfies_commitment(commitment_config))
|
2020-04-04 23:31:24 -07:00
|
|
|
.map(|result| result.status.is_ok())
|
|
|
|
.unwrap_or_default(),
|
|
|
|
})
|
2019-11-06 19:08:03 -08:00
|
|
|
}
|
|
|
|
|
2020-03-27 15:46:00 -07:00
|
|
|
pub fn send_transaction(&self, transaction: &Transaction) -> ClientResult<Signature> {
|
2020-05-31 21:54:12 -07:00
|
|
|
self.send_transaction_with_config(transaction, RpcSendTransactionConfig::default())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn send_transaction_with_config(
|
|
|
|
&self,
|
|
|
|
transaction: &Transaction,
|
|
|
|
config: RpcSendTransactionConfig,
|
|
|
|
) -> ClientResult<Signature> {
|
2020-01-21 21:16:07 -08:00
|
|
|
let serialized_encoded = bs58::encode(serialize(transaction).unwrap()).into_string();
|
2020-03-27 15:46:00 -07:00
|
|
|
|
2020-05-31 21:54:12 -07:00
|
|
|
let signature_base58_str: String = self.send(
|
|
|
|
RpcRequest::SendTransaction,
|
|
|
|
json!([serialized_encoded, config]),
|
|
|
|
)?;
|
2020-05-10 08:51:53 -07:00
|
|
|
|
|
|
|
let signature = signature_base58_str
|
|
|
|
.parse::<Signature>()
|
|
|
|
.map_err(|err| Into::<ClientError>::into(RpcError::ParseError(err.to_string())))?;
|
|
|
|
// A mismatching RPC response signature indicates an issue with the RPC node, and
|
|
|
|
// should not be passed along to confirmation methods. The transaction may or may
|
|
|
|
// not have been submitted to the cluster, so callers should verify the success of
|
|
|
|
// the correct transaction signature independently.
|
|
|
|
if signature != transaction.signatures[0] {
|
|
|
|
Err(RpcError::RpcRequestError(format!(
|
|
|
|
"RPC node returned mismatched signature {:?}, expected {:?}",
|
|
|
|
signature, transaction.signatures[0]
|
|
|
|
))
|
|
|
|
.into())
|
|
|
|
} else {
|
|
|
|
Ok(transaction.signatures[0])
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-19 12:08:19 -07:00
|
|
|
pub fn simulate_transaction(
|
|
|
|
&self,
|
|
|
|
transaction: &Transaction,
|
|
|
|
sig_verify: bool,
|
|
|
|
) -> RpcResult<TransactionStatus> {
|
|
|
|
let serialized_encoded = bs58::encode(serialize(transaction).unwrap()).into_string();
|
|
|
|
self.send(
|
|
|
|
RpcRequest::SimulateTransaction,
|
|
|
|
json!([serialized_encoded, { "sigVerify": sig_verify }]),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2019-03-16 17:17:44 -07:00
|
|
|
pub fn get_signature_status(
|
|
|
|
&self,
|
2020-03-27 15:46:00 -07:00
|
|
|
signature: &Signature,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<Option<transaction::Result<()>>> {
|
2019-11-06 13:15:00 -08:00
|
|
|
self.get_signature_status_with_commitment(signature, CommitmentConfig::default())
|
|
|
|
}
|
|
|
|
|
2020-04-06 03:04:54 -07:00
|
|
|
pub fn get_signature_statuses(
|
2020-04-04 23:31:24 -07:00
|
|
|
&self,
|
|
|
|
signatures: &[Signature],
|
|
|
|
) -> RpcResult<Vec<Option<TransactionStatus>>> {
|
|
|
|
let signatures: Vec<_> = signatures.iter().map(|s| s.to_string()).collect();
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetSignatureStatuses, json!([signatures]))
|
2020-04-04 23:31:24 -07:00
|
|
|
}
|
|
|
|
|
2019-11-06 13:15:00 -08:00
|
|
|
pub fn get_signature_status_with_commitment(
|
|
|
|
&self,
|
2020-03-27 15:46:00 -07:00
|
|
|
signature: &Signature,
|
2019-11-06 13:15:00 -08:00
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<Option<transaction::Result<()>>> {
|
2020-05-10 08:51:53 -07:00
|
|
|
let result: Response<Vec<Option<TransactionStatus>>> = self.send(
|
|
|
|
RpcRequest::GetSignatureStatuses,
|
2020-04-06 03:04:54 -07:00
|
|
|
json!([[signature.to_string()]]),
|
2019-11-06 13:15:00 -08:00
|
|
|
)?;
|
2020-03-26 18:21:01 -07:00
|
|
|
Ok(result.value[0]
|
|
|
|
.clone()
|
2020-04-06 03:04:54 -07:00
|
|
|
.filter(|result| result.satisfies_commitment(commitment_config))
|
2020-03-26 18:21:01 -07:00
|
|
|
.map(|status_meta| status_meta.status))
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
|
|
|
|
2020-04-15 20:51:05 -07:00
|
|
|
pub fn get_signature_status_with_commitment_and_history(
|
|
|
|
&self,
|
|
|
|
signature: &Signature,
|
|
|
|
commitment_config: CommitmentConfig,
|
|
|
|
search_transaction_history: bool,
|
|
|
|
) -> ClientResult<Option<transaction::Result<()>>> {
|
2020-05-10 08:51:53 -07:00
|
|
|
let result: Response<Vec<Option<TransactionStatus>>> = self.send(
|
|
|
|
RpcRequest::GetSignatureStatuses,
|
2020-04-15 20:51:05 -07:00
|
|
|
json!([[signature.to_string()], {
|
|
|
|
"searchTransactionHistory": search_transaction_history
|
|
|
|
}]),
|
|
|
|
)?;
|
|
|
|
Ok(result.value[0]
|
|
|
|
.clone()
|
|
|
|
.filter(|result| result.satisfies_commitment(commitment_config))
|
|
|
|
.map(|status_meta| status_meta.status))
|
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_slot(&self) -> ClientResult<Slot> {
|
2019-11-06 13:15:00 -08:00
|
|
|
self.get_slot_with_commitment(CommitmentConfig::default())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_slot_with_commitment(
|
|
|
|
&self,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<Slot> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetSlot, json!([commitment_config]))
|
2019-08-27 15:17:03 -07:00
|
|
|
}
|
|
|
|
|
2020-05-10 11:05:14 -07:00
|
|
|
pub fn supply_with_commitment(
|
|
|
|
&self,
|
|
|
|
commitment_config: CommitmentConfig,
|
|
|
|
) -> RpcResult<RpcSupply> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetSupply, json!([commitment_config]))
|
2020-05-10 11:05:14 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn total_supply(&self) -> ClientResult<u64> {
|
2020-03-09 01:28:44 -07:00
|
|
|
self.total_supply_with_commitment(CommitmentConfig::default())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn total_supply_with_commitment(
|
|
|
|
&self,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<u64> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetTotalSupply, json!([commitment_config]))
|
2020-03-09 01:28:44 -07:00
|
|
|
}
|
|
|
|
|
2020-05-12 20:05:05 -07:00
|
|
|
pub fn get_largest_accounts_with_config(
|
|
|
|
&self,
|
|
|
|
config: RpcLargestAccountsConfig,
|
|
|
|
) -> RpcResult<Vec<RpcAccountBalance>> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetLargestAccounts, json!([config]))
|
2020-05-12 20:05:05 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_vote_accounts(&self) -> ClientResult<RpcVoteAccountStatus> {
|
2020-03-03 16:53:30 -08:00
|
|
|
self.get_vote_accounts_with_commitment(CommitmentConfig::default())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_vote_accounts_with_commitment(
|
|
|
|
&self,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<RpcVoteAccountStatus> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetVoteAccounts, json!([commitment_config]))
|
2019-10-06 20:30:22 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_cluster_nodes(&self) -> ClientResult<Vec<RpcContactInfo>> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetClusterNodes, Value::Null)
|
2019-11-13 14:58:14 -08:00
|
|
|
}
|
|
|
|
|
2020-03-26 13:29:30 -07:00
|
|
|
pub fn get_confirmed_block(&self, slot: Slot) -> ClientResult<ConfirmedBlock> {
|
|
|
|
self.get_confirmed_block_with_encoding(slot, TransactionEncoding::Json)
|
2020-03-24 05:05:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_confirmed_block_with_encoding(
|
|
|
|
&self,
|
|
|
|
slot: Slot,
|
2020-03-26 13:29:30 -07:00
|
|
|
encoding: TransactionEncoding,
|
|
|
|
) -> ClientResult<ConfirmedBlock> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetConfirmedBlock, json!([slot, encoding]))
|
2019-12-18 21:31:38 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_confirmed_blocks(
|
|
|
|
&self,
|
|
|
|
start_slot: Slot,
|
|
|
|
end_slot: Option<Slot>,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<Vec<Slot>> {
|
2020-05-10 08:51:53 -07:00
|
|
|
self.send(
|
|
|
|
RpcRequest::GetConfirmedBlocks,
|
|
|
|
json!([start_slot, end_slot]),
|
|
|
|
)
|
2019-12-18 21:31:38 -08:00
|
|
|
}
|
|
|
|
|
2020-04-15 20:51:05 -07:00
|
|
|
pub fn get_confirmed_signatures_for_address(
|
|
|
|
&self,
|
|
|
|
address: &Pubkey,
|
|
|
|
start_slot: Slot,
|
|
|
|
end_slot: Slot,
|
|
|
|
) -> ClientResult<Vec<Signature>> {
|
2020-05-10 08:51:53 -07:00
|
|
|
let signatures_base58_str: Vec<String> = self.send(
|
|
|
|
RpcRequest::GetConfirmedSignaturesForAddress,
|
|
|
|
json!([address.to_string(), start_slot, end_slot]),
|
|
|
|
)?;
|
2020-04-20 22:01:09 -07:00
|
|
|
|
|
|
|
let mut signatures = vec![];
|
|
|
|
for signature_base58_str in signatures_base58_str {
|
|
|
|
signatures.push(
|
|
|
|
signature_base58_str.parse::<Signature>().map_err(|err| {
|
|
|
|
Into::<ClientError>::into(RpcError::ParseError(err.to_string()))
|
|
|
|
})?,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Ok(signatures)
|
2020-04-15 20:51:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_confirmed_transaction(
|
|
|
|
&self,
|
|
|
|
signature: &Signature,
|
|
|
|
encoding: TransactionEncoding,
|
|
|
|
) -> ClientResult<ConfirmedTransaction> {
|
2020-05-10 08:51:53 -07:00
|
|
|
self.send(
|
|
|
|
RpcRequest::GetConfirmedTransaction,
|
|
|
|
json!([signature.to_string(), encoding]),
|
|
|
|
)
|
2020-04-15 20:51:05 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_block_time(&self, slot: Slot) -> ClientResult<UnixTimestamp> {
|
2020-05-10 08:51:53 -07:00
|
|
|
let request = RpcRequest::GetBlockTime;
|
2020-05-22 08:53:53 -07:00
|
|
|
let response = self.sender.send(request, json!([slot]));
|
2019-11-25 23:40:36 -08:00
|
|
|
|
|
|
|
response
|
|
|
|
.map(|result_json| {
|
|
|
|
if result_json.is_null() {
|
2020-03-12 23:20:49 -07:00
|
|
|
return Err(RpcError::ForUser(format!("Block Not Found: slot={}", slot)).into());
|
2019-11-25 23:40:36 -08:00
|
|
|
}
|
2020-03-12 23:20:49 -07:00
|
|
|
let result = serde_json::from_value(result_json)
|
2020-05-10 08:51:53 -07:00
|
|
|
.map_err(|err| ClientError::new_with_request(err.into(), request))?;
|
2019-11-25 23:40:36 -08:00
|
|
|
trace!("Response block timestamp {:?} {:?}", slot, result);
|
|
|
|
Ok(result)
|
|
|
|
})
|
2020-05-10 08:51:53 -07:00
|
|
|
.map_err(|err| err.into_with_request(request))?
|
2019-11-25 23:40:36 -08:00
|
|
|
}
|
|
|
|
|
2020-05-20 16:42:46 -07:00
|
|
|
pub fn get_epoch_info(&self) -> ClientResult<EpochInfo> {
|
2019-11-24 16:34:18 -08:00
|
|
|
self.get_epoch_info_with_commitment(CommitmentConfig::default())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_epoch_info_with_commitment(
|
|
|
|
&self,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-05-20 16:42:46 -07:00
|
|
|
) -> ClientResult<EpochInfo> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetEpochInfo, json!([commitment_config]))
|
2019-12-17 15:26:31 -08:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_leader_schedule(
|
|
|
|
&self,
|
|
|
|
slot: Option<Slot>,
|
|
|
|
) -> ClientResult<Option<RpcLeaderSchedule>> {
|
2019-12-17 15:26:31 -08:00
|
|
|
self.get_leader_schedule_with_commitment(slot, CommitmentConfig::default())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_leader_schedule_with_commitment(
|
|
|
|
&self,
|
|
|
|
slot: Option<Slot>,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<Option<RpcLeaderSchedule>> {
|
2020-05-10 08:51:53 -07:00
|
|
|
self.send(
|
|
|
|
RpcRequest::GetLeaderSchedule,
|
|
|
|
json!([slot, commitment_config]),
|
|
|
|
)
|
2019-09-27 22:00:30 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_epoch_schedule(&self) -> ClientResult<EpochSchedule> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetEpochSchedule, Value::Null)
|
2019-10-22 13:41:18 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_identity(&self) -> ClientResult<Pubkey> {
|
2020-05-22 08:53:53 -07:00
|
|
|
let rpc_identity: RpcIdentity = self.send(RpcRequest::GetIdentity, Value::Null)?;
|
2020-03-04 14:44:21 -08:00
|
|
|
|
2020-05-10 08:51:53 -07:00
|
|
|
rpc_identity.identity.parse::<Pubkey>().map_err(|_| {
|
|
|
|
ClientError::new_with_request(
|
|
|
|
RpcError::ParseError("Pubkey".to_string()).into(),
|
|
|
|
RpcRequest::GetIdentity,
|
|
|
|
)
|
|
|
|
})
|
2020-03-04 14:44:21 -08:00
|
|
|
}
|
|
|
|
|
2020-05-29 11:50:25 -07:00
|
|
|
pub fn get_inflation_governor(&self) -> ClientResult<RpcInflationGovernor> {
|
|
|
|
self.send(RpcRequest::GetInflationGovernor, Value::Null)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_inflation_rate(&self) -> ClientResult<RpcInflationRate> {
|
|
|
|
self.send(RpcRequest::GetInflationRate, Value::Null)
|
2019-06-12 16:43:05 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_version(&self) -> ClientResult<RpcVersionInfo> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetVersion, Value::Null)
|
2019-08-08 10:13:06 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn minimum_ledger_slot(&self) -> ClientResult<Slot> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::MinimumLedgerSlot, Value::Null)
|
2020-01-21 12:05:04 -08:00
|
|
|
}
|
|
|
|
|
2020-05-09 09:06:32 -07:00
|
|
|
pub fn send_and_confirm_transaction(
|
2019-03-16 17:17:44 -07:00
|
|
|
&self,
|
2020-05-09 09:06:32 -07:00
|
|
|
transaction: &Transaction,
|
2020-03-27 15:46:00 -07:00
|
|
|
) -> ClientResult<Signature> {
|
2019-10-08 13:04:27 -07:00
|
|
|
let mut send_retries = 20;
|
2019-03-16 17:17:44 -07:00
|
|
|
loop {
|
2019-11-06 13:15:00 -08:00
|
|
|
let mut status_retries = 15;
|
2020-03-27 15:46:00 -07:00
|
|
|
let signature = self.send_transaction(transaction)?;
|
2019-03-16 17:17:44 -07:00
|
|
|
let status = loop {
|
2020-03-27 15:46:00 -07:00
|
|
|
let status = self.get_signature_status(&signature)?;
|
2019-04-05 19:56:17 -07:00
|
|
|
if status.is_none() {
|
2019-03-16 17:17:44 -07:00
|
|
|
status_retries -= 1;
|
|
|
|
if status_retries == 0 {
|
|
|
|
break status;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
break status;
|
|
|
|
}
|
|
|
|
if cfg!(not(test)) {
|
2019-11-06 13:15:00 -08:00
|
|
|
// Retry twice a second
|
|
|
|
sleep(Duration::from_millis(500));
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
|
|
|
};
|
2019-04-05 19:56:17 -07:00
|
|
|
send_retries = if let Some(result) = status.clone() {
|
|
|
|
match result {
|
2020-03-27 15:46:00 -07:00
|
|
|
Ok(_) => return Ok(signature),
|
2019-04-05 19:56:17 -07:00
|
|
|
Err(_) => 0,
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
2019-04-05 19:56:17 -07:00
|
|
|
} else {
|
|
|
|
send_retries - 1
|
|
|
|
};
|
2019-03-16 17:17:44 -07:00
|
|
|
if send_retries == 0 {
|
2019-12-09 19:35:34 -08:00
|
|
|
if let Some(err) = status {
|
|
|
|
return Err(err.unwrap_err().into());
|
|
|
|
} else {
|
2020-03-12 23:20:49 -07:00
|
|
|
return Err(
|
2020-05-09 09:06:32 -07:00
|
|
|
RpcError::ForUser("unable to confirm transaction. \
|
|
|
|
This can happen in situations such as transaction expiration \
|
|
|
|
and insufficient fee-payer funds".to_string()).into(),
|
2020-03-12 23:20:49 -07:00
|
|
|
);
|
2019-12-09 19:35:34 -08:00
|
|
|
}
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_account(&self, pubkey: &Pubkey) -> ClientResult<Account> {
|
2019-11-13 13:41:54 -08:00
|
|
|
self.get_account_with_commitment(pubkey, CommitmentConfig::default())?
|
|
|
|
.value
|
2020-03-12 23:20:49 -07:00
|
|
|
.ok_or_else(|| RpcError::ForUser(format!("AccountNotFound: pubkey={}", pubkey)).into())
|
2019-11-06 13:15:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_account_with_commitment(
|
|
|
|
&self,
|
|
|
|
pubkey: &Pubkey,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> RpcResult<Option<Account>> {
|
2020-05-20 18:40:45 -07:00
|
|
|
let response = self.sender.send(
|
2020-05-10 08:51:53 -07:00
|
|
|
RpcRequest::GetAccountInfo,
|
2019-12-18 21:26:11 -08:00
|
|
|
json!([pubkey.to_string(), commitment_config]),
|
2019-11-06 13:15:00 -08:00
|
|
|
);
|
2019-03-16 22:37:20 -07:00
|
|
|
|
|
|
|
response
|
2019-11-12 11:49:41 -08:00
|
|
|
.map(|result_json| {
|
|
|
|
if result_json.is_null() {
|
2020-03-12 23:20:49 -07:00
|
|
|
return Err(
|
|
|
|
RpcError::ForUser(format!("AccountNotFound: pubkey={}", pubkey)).into(),
|
|
|
|
);
|
2019-11-12 11:49:41 -08:00
|
|
|
}
|
2020-01-15 14:33:53 -08:00
|
|
|
let Response {
|
|
|
|
context,
|
|
|
|
value: rpc_account,
|
|
|
|
} = serde_json::from_value::<Response<Option<RpcAccount>>>(result_json)?;
|
|
|
|
trace!("Response account {:?} {:?}", pubkey, rpc_account);
|
|
|
|
let account = rpc_account.and_then(|rpc_account| rpc_account.decode().ok());
|
|
|
|
Ok(Response {
|
|
|
|
context,
|
|
|
|
value: account,
|
|
|
|
})
|
2019-03-16 22:37:20 -07:00
|
|
|
})
|
2019-05-13 12:49:37 -07:00
|
|
|
.map_err(|err| {
|
2020-03-12 23:20:49 -07:00
|
|
|
Into::<ClientError>::into(RpcError::ForUser(format!(
|
|
|
|
"AccountNotFound: pubkey={}: {}",
|
|
|
|
pubkey, err
|
|
|
|
)))
|
2019-11-12 11:49:41 -08:00
|
|
|
})?
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_account_data(&self, pubkey: &Pubkey) -> ClientResult<Vec<u8>> {
|
2019-11-13 13:41:54 -08:00
|
|
|
Ok(self.get_account(pubkey)?.data)
|
2019-05-08 15:50:23 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_minimum_balance_for_rent_exemption(&self, data_len: usize) -> ClientResult<u64> {
|
2020-05-10 08:51:53 -07:00
|
|
|
let request = RpcRequest::GetMinimumBalanceForRentExemption;
|
2019-09-26 10:57:13 -07:00
|
|
|
let minimum_balance_json = self
|
2020-05-20 18:40:45 -07:00
|
|
|
.sender
|
2020-05-22 08:53:53 -07:00
|
|
|
.send(request, json!([data_len]))
|
2020-05-10 08:51:53 -07:00
|
|
|
.map_err(|err| err.into_with_request(request))?;
|
2019-09-26 10:57:13 -07:00
|
|
|
|
2020-05-10 08:51:53 -07:00
|
|
|
let minimum_balance: u64 = serde_json::from_value(minimum_balance_json)
|
|
|
|
.map_err(|err| ClientError::new_with_request(err.into(), request))?;
|
2019-09-26 10:57:13 -07:00
|
|
|
trace!(
|
|
|
|
"Response minimum balance {:?} {:?}",
|
|
|
|
data_len,
|
|
|
|
minimum_balance
|
|
|
|
);
|
|
|
|
Ok(minimum_balance)
|
|
|
|
}
|
|
|
|
|
2019-11-06 13:15:00 -08:00
|
|
|
/// Request the balance of the account `pubkey`.
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_balance(&self, pubkey: &Pubkey) -> ClientResult<u64> {
|
2019-11-12 11:49:41 -08:00
|
|
|
Ok(self
|
|
|
|
.get_balance_with_commitment(pubkey, CommitmentConfig::default())?
|
|
|
|
.value)
|
2019-11-06 13:15:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_balance_with_commitment(
|
|
|
|
&self,
|
|
|
|
pubkey: &Pubkey,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> RpcResult<u64> {
|
2020-05-10 08:51:53 -07:00
|
|
|
self.send(
|
|
|
|
RpcRequest::GetBalance,
|
|
|
|
json!([pubkey.to_string(), commitment_config]),
|
|
|
|
)
|
2019-05-08 15:50:23 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_program_accounts(&self, pubkey: &Pubkey) -> ClientResult<Vec<(Pubkey, Account)>> {
|
2020-05-22 08:53:53 -07:00
|
|
|
let accounts: Vec<RpcKeyedAccount> =
|
|
|
|
self.send(RpcRequest::GetProgramAccounts, json!([pubkey.to_string()]))?;
|
2019-07-11 11:38:52 -07:00
|
|
|
let mut pubkey_accounts: Vec<(Pubkey, Account)> = Vec::new();
|
2020-01-15 14:33:53 -08:00
|
|
|
for RpcKeyedAccount { pubkey, account } in accounts.into_iter() {
|
2020-03-12 23:20:49 -07:00
|
|
|
let pubkey = pubkey.parse().map_err(|_| {
|
2020-05-10 08:51:53 -07:00
|
|
|
ClientError::new_with_request(
|
2020-03-12 23:20:49 -07:00
|
|
|
RpcError::ParseError("Pubkey".to_string()).into(),
|
2020-05-10 08:51:53 -07:00
|
|
|
RpcRequest::GetProgramAccounts,
|
2019-07-11 11:38:52 -07:00
|
|
|
)
|
|
|
|
})?;
|
2020-01-15 14:33:53 -08:00
|
|
|
pubkey_accounts.push((pubkey, account.decode().unwrap()));
|
2019-07-11 11:38:52 -07:00
|
|
|
}
|
|
|
|
Ok(pubkey_accounts)
|
|
|
|
}
|
|
|
|
|
2019-11-06 13:15:00 -08:00
|
|
|
/// Request the transaction count.
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_transaction_count(&self) -> ClientResult<u64> {
|
2019-11-06 13:15:00 -08:00
|
|
|
self.get_transaction_count_with_commitment(CommitmentConfig::default())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_transaction_count_with_commitment(
|
|
|
|
&self,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<u64> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::GetTransactionCount, json!([commitment_config]))
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_recent_blockhash(&self) -> ClientResult<(Hash, FeeCalculator)> {
|
2020-05-26 12:06:21 -07:00
|
|
|
let (blockhash, fee_calculator, _last_valid_slot) = self
|
2019-11-12 11:49:41 -08:00
|
|
|
.get_recent_blockhash_with_commitment(CommitmentConfig::default())?
|
2020-05-26 12:06:21 -07:00
|
|
|
.value;
|
|
|
|
Ok((blockhash, fee_calculator))
|
2019-11-06 13:15:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_recent_blockhash_with_commitment(
|
|
|
|
&self,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-05-26 12:06:21 -07:00
|
|
|
) -> RpcResult<(Hash, FeeCalculator, Slot)> {
|
|
|
|
let (context, blockhash, fee_calculator, last_valid_slot) = if let Ok(Response {
|
|
|
|
context,
|
|
|
|
value:
|
|
|
|
RpcFees {
|
|
|
|
blockhash,
|
|
|
|
fee_calculator,
|
|
|
|
last_valid_slot,
|
|
|
|
},
|
|
|
|
}) =
|
|
|
|
self.send::<Response<RpcFees>>(RpcRequest::GetFees, json!([commitment_config]))
|
|
|
|
{
|
|
|
|
(context, blockhash, fee_calculator, last_valid_slot)
|
|
|
|
} else if let Ok(Response {
|
2019-11-12 11:49:41 -08:00
|
|
|
context,
|
2020-01-14 23:25:45 -08:00
|
|
|
value:
|
|
|
|
RpcBlockhashFeeCalculator {
|
|
|
|
blockhash,
|
|
|
|
fee_calculator,
|
|
|
|
},
|
2020-05-26 12:06:21 -07:00
|
|
|
}) = self.send::<Response<RpcBlockhashFeeCalculator>>(
|
2020-05-10 08:51:53 -07:00
|
|
|
RpcRequest::GetRecentBlockhash,
|
|
|
|
json!([commitment_config]),
|
2020-05-26 12:06:21 -07:00
|
|
|
) {
|
|
|
|
(context, blockhash, fee_calculator, 0)
|
|
|
|
} else {
|
|
|
|
return Err(ClientError::new_with_request(
|
|
|
|
RpcError::ParseError("RpcBlockhashFeeCalculator or RpcFees".to_string()).into(),
|
|
|
|
RpcRequest::GetRecentBlockhash,
|
|
|
|
));
|
|
|
|
};
|
2020-05-10 08:51:53 -07:00
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
let blockhash = blockhash.parse().map_err(|_| {
|
2020-05-10 08:51:53 -07:00
|
|
|
ClientError::new_with_request(
|
2020-03-12 23:20:49 -07:00
|
|
|
RpcError::ParseError("Hash".to_string()).into(),
|
2020-05-10 08:51:53 -07:00
|
|
|
RpcRequest::GetRecentBlockhash,
|
2019-05-13 12:49:37 -07:00
|
|
|
)
|
|
|
|
})?;
|
2019-11-12 11:49:41 -08:00
|
|
|
Ok(Response {
|
|
|
|
context,
|
2020-05-26 12:06:21 -07:00
|
|
|
value: (blockhash, fee_calculator, last_valid_slot),
|
2019-11-12 11:49:41 -08:00
|
|
|
})
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
|
2020-03-06 16:01:31 -08:00
|
|
|
pub fn get_fee_calculator_for_blockhash(
|
|
|
|
&self,
|
|
|
|
blockhash: &Hash,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<Option<FeeCalculator>> {
|
2020-05-26 16:23:58 -07:00
|
|
|
Ok(self
|
|
|
|
.get_fee_calculator_for_blockhash_with_commitment(
|
|
|
|
blockhash,
|
|
|
|
CommitmentConfig::default(),
|
|
|
|
)?
|
|
|
|
.value)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_fee_calculator_for_blockhash_with_commitment(
|
|
|
|
&self,
|
|
|
|
blockhash: &Hash,
|
|
|
|
commitment_config: CommitmentConfig,
|
|
|
|
) -> RpcResult<Option<FeeCalculator>> {
|
|
|
|
let Response { context, value } = self.send::<Response<Option<RpcFeeCalculator>>>(
|
2020-05-10 08:51:53 -07:00
|
|
|
RpcRequest::GetFeeCalculatorForBlockhash,
|
2020-05-26 16:23:58 -07:00
|
|
|
json!([blockhash.to_string(), commitment_config]),
|
2020-05-10 08:51:53 -07:00
|
|
|
)?;
|
|
|
|
|
2020-05-26 16:23:58 -07:00
|
|
|
Ok(Response {
|
|
|
|
context,
|
|
|
|
value: value.map(|rf| rf.fee_calculator),
|
|
|
|
})
|
2020-03-06 16:01:31 -08:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_fee_rate_governor(&self) -> RpcResult<FeeRateGovernor> {
|
2020-02-28 12:27:01 -08:00
|
|
|
let Response {
|
|
|
|
context,
|
|
|
|
value: RpcFeeRateGovernor { fee_rate_governor },
|
2020-05-22 08:53:53 -07:00
|
|
|
} =
|
|
|
|
self.send::<Response<RpcFeeRateGovernor>>(RpcRequest::GetFeeRateGovernor, Value::Null)?;
|
2020-05-10 08:51:53 -07:00
|
|
|
|
2020-02-28 12:27:01 -08:00
|
|
|
Ok(Response {
|
|
|
|
context,
|
|
|
|
value: fee_rate_governor,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_new_blockhash(&self, blockhash: &Hash) -> ClientResult<(Hash, FeeCalculator)> {
|
2019-09-27 10:36:38 -07:00
|
|
|
let mut num_retries = 0;
|
2019-09-20 15:50:43 -07:00
|
|
|
let start = Instant::now();
|
2019-09-27 10:36:38 -07:00
|
|
|
while start.elapsed().as_secs() < 5 {
|
2019-05-13 12:49:37 -07:00
|
|
|
if let Ok((new_blockhash, fee_calculator)) = self.get_recent_blockhash() {
|
2019-03-16 17:17:44 -07:00
|
|
|
if new_blockhash != *blockhash {
|
2019-05-13 12:49:37 -07:00
|
|
|
return Ok((new_blockhash, fee_calculator));
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
debug!("Got same blockhash ({:?}), will retry...", blockhash);
|
2019-03-16 17:17:44 -07:00
|
|
|
|
|
|
|
// Retry ~twice during a slot
|
|
|
|
sleep(Duration::from_millis(
|
2019-08-19 23:22:56 -07:00
|
|
|
500 * DEFAULT_TICKS_PER_SLOT / DEFAULT_TICKS_PER_SECOND,
|
2019-03-16 17:17:44 -07:00
|
|
|
));
|
2019-09-27 10:36:38 -07:00
|
|
|
num_retries += 1;
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
2020-03-12 23:20:49 -07:00
|
|
|
Err(RpcError::ForUser(format!(
|
|
|
|
"Unable to get new blockhash after {}ms (retried {} times), stuck at {}",
|
|
|
|
start.elapsed().as_millis(),
|
|
|
|
num_retries,
|
|
|
|
blockhash
|
2019-03-16 17:17:44 -07:00
|
|
|
))
|
2020-03-12 23:20:49 -07:00
|
|
|
.into())
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn get_genesis_hash(&self) -> ClientResult<Hash> {
|
2020-05-22 08:53:53 -07:00
|
|
|
let hash_str: String = self.send(RpcRequest::GetGenesisHash, Value::Null)?;
|
2020-05-10 08:51:53 -07:00
|
|
|
let hash = hash_str.parse().map_err(|_| {
|
|
|
|
ClientError::new_with_request(
|
2020-03-12 23:20:49 -07:00
|
|
|
RpcError::ParseError("Hash".to_string()).into(),
|
2020-05-10 08:51:53 -07:00
|
|
|
RpcRequest::GetGenesisHash,
|
2019-08-21 18:16:40 -07:00
|
|
|
)
|
|
|
|
})?;
|
2019-11-08 20:56:57 -08:00
|
|
|
Ok(hash)
|
2019-08-21 18:16:40 -07:00
|
|
|
}
|
|
|
|
|
2019-11-06 13:15:00 -08:00
|
|
|
pub fn poll_balance_with_timeout_and_commitment(
|
2019-03-16 22:37:20 -07:00
|
|
|
&self,
|
|
|
|
pubkey: &Pubkey,
|
|
|
|
polling_frequency: &Duration,
|
|
|
|
timeout: &Duration,
|
2019-11-06 13:15:00 -08:00
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<u64> {
|
2019-03-16 22:37:20 -07:00
|
|
|
let now = Instant::now();
|
|
|
|
loop {
|
2019-11-06 13:15:00 -08:00
|
|
|
match self.get_balance_with_commitment(&pubkey, commitment_config.clone()) {
|
2019-03-16 22:37:20 -07:00
|
|
|
Ok(bal) => {
|
2019-11-12 11:49:41 -08:00
|
|
|
return Ok(bal.value);
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
sleep(*polling_frequency);
|
|
|
|
if now.elapsed() > *timeout {
|
|
|
|
return Err(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-06 13:15:00 -08:00
|
|
|
pub fn poll_get_balance_with_commitment(
|
|
|
|
&self,
|
|
|
|
pubkey: &Pubkey,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<u64> {
|
2019-11-06 13:15:00 -08:00
|
|
|
self.poll_balance_with_timeout_and_commitment(
|
|
|
|
pubkey,
|
|
|
|
&Duration::from_millis(100),
|
|
|
|
&Duration::from_secs(1),
|
|
|
|
commitment_config,
|
|
|
|
)
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
|
2019-11-06 13:15:00 -08:00
|
|
|
pub fn wait_for_balance_with_commitment(
|
|
|
|
&self,
|
|
|
|
pubkey: &Pubkey,
|
|
|
|
expected_balance: Option<u64>,
|
|
|
|
commitment_config: CommitmentConfig,
|
|
|
|
) -> Option<u64> {
|
2019-03-16 23:29:11 -07:00
|
|
|
const LAST: usize = 30;
|
|
|
|
for run in 0..LAST {
|
2019-11-06 13:15:00 -08:00
|
|
|
let balance_result =
|
|
|
|
self.poll_get_balance_with_commitment(pubkey, commitment_config.clone());
|
2019-03-16 23:29:11 -07:00
|
|
|
if expected_balance.is_none() {
|
|
|
|
return balance_result.ok();
|
|
|
|
}
|
|
|
|
trace!(
|
2020-05-10 08:51:53 -07:00
|
|
|
"wait_for_balance_with_commitment [{}] {:?} {:?}",
|
2019-03-16 23:29:11 -07:00
|
|
|
run,
|
|
|
|
balance_result,
|
|
|
|
expected_balance
|
|
|
|
);
|
|
|
|
if let (Some(expected_balance), Ok(balance_result)) = (expected_balance, balance_result)
|
|
|
|
{
|
|
|
|
if expected_balance == balance_result {
|
|
|
|
return Some(balance_result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
None
|
|
|
|
}
|
|
|
|
|
2019-03-16 22:37:20 -07:00
|
|
|
/// Poll the server to confirm a transaction.
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn poll_for_signature(&self, signature: &Signature) -> ClientResult<()> {
|
2019-11-06 13:15:00 -08:00
|
|
|
self.poll_for_signature_with_commitment(signature, CommitmentConfig::default())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Poll the server to confirm a transaction.
|
|
|
|
pub fn poll_for_signature_with_commitment(
|
|
|
|
&self,
|
|
|
|
signature: &Signature,
|
|
|
|
commitment_config: CommitmentConfig,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<()> {
|
2019-03-16 22:37:20 -07:00
|
|
|
let now = Instant::now();
|
2019-11-06 13:15:00 -08:00
|
|
|
loop {
|
2020-03-27 15:46:00 -07:00
|
|
|
if let Ok(Some(_)) =
|
|
|
|
self.get_signature_status_with_commitment(&signature, commitment_config.clone())
|
|
|
|
{
|
2019-11-06 13:15:00 -08:00
|
|
|
break;
|
|
|
|
}
|
2019-03-16 22:37:20 -07:00
|
|
|
if now.elapsed().as_secs() > 15 {
|
2020-03-12 23:20:49 -07:00
|
|
|
return Err(RpcError::ForUser(format!(
|
|
|
|
"signature not found after {} seconds",
|
|
|
|
now.elapsed().as_secs()
|
|
|
|
))
|
|
|
|
.into());
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
sleep(Duration::from_millis(250));
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2019-04-08 10:32:22 -07:00
|
|
|
/// Check a signature in the bank.
|
2019-03-16 22:37:20 -07:00
|
|
|
pub fn check_signature(&self, signature: &Signature) -> bool {
|
|
|
|
trace!("check_signature: {:?}", signature);
|
|
|
|
|
2019-04-08 10:32:22 -07:00
|
|
|
for _ in 0..30 {
|
2020-04-04 23:31:24 -07:00
|
|
|
let response =
|
|
|
|
self.confirm_transaction_with_commitment(signature, CommitmentConfig::recent());
|
2019-03-16 22:37:20 -07:00
|
|
|
match response {
|
2020-04-04 23:31:24 -07:00
|
|
|
Ok(Response {
|
|
|
|
value: signature_status,
|
|
|
|
..
|
|
|
|
}) => {
|
2019-03-16 22:37:20 -07:00
|
|
|
if signature_status {
|
|
|
|
trace!("Response found signature");
|
|
|
|
} else {
|
|
|
|
trace!("Response signature not found");
|
|
|
|
}
|
|
|
|
|
|
|
|
return signature_status;
|
|
|
|
}
|
|
|
|
Err(err) => {
|
|
|
|
debug!("check_signature request failed: {:?}", err);
|
|
|
|
}
|
|
|
|
};
|
2019-04-08 10:32:22 -07:00
|
|
|
sleep(Duration::from_millis(250));
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
2019-04-08 10:32:22 -07:00
|
|
|
|
|
|
|
panic!("Couldn't check signature of {}", signature);
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
2019-03-21 07:43:21 -07:00
|
|
|
|
|
|
|
/// Poll the server to confirm a transaction.
|
|
|
|
pub fn poll_for_signature_confirmation(
|
|
|
|
&self,
|
|
|
|
signature: &Signature,
|
|
|
|
min_confirmed_blocks: usize,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<usize> {
|
2019-03-21 07:43:21 -07:00
|
|
|
let mut now = Instant::now();
|
|
|
|
let mut confirmed_blocks = 0;
|
|
|
|
loop {
|
|
|
|
let response = self.get_num_blocks_since_signature_confirmation(signature);
|
|
|
|
match response {
|
|
|
|
Ok(count) => {
|
|
|
|
if confirmed_blocks != count {
|
|
|
|
info!(
|
2019-07-01 13:21:00 -07:00
|
|
|
"signature {} confirmed {} out of {} after {} ms",
|
|
|
|
signature,
|
|
|
|
count,
|
|
|
|
min_confirmed_blocks,
|
|
|
|
now.elapsed().as_millis()
|
2019-03-21 07:43:21 -07:00
|
|
|
);
|
|
|
|
now = Instant::now();
|
|
|
|
confirmed_blocks = count;
|
|
|
|
}
|
|
|
|
if count >= min_confirmed_blocks {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(err) => {
|
|
|
|
debug!("check_confirmations request failed: {:?}", err);
|
|
|
|
}
|
|
|
|
};
|
2019-11-06 13:15:00 -08:00
|
|
|
if now.elapsed().as_secs() > 20 {
|
2019-07-01 13:21:00 -07:00
|
|
|
info!(
|
|
|
|
"signature {} confirmed {} out of {} failed after {} ms",
|
|
|
|
signature,
|
|
|
|
confirmed_blocks,
|
|
|
|
min_confirmed_blocks,
|
|
|
|
now.elapsed().as_millis()
|
|
|
|
);
|
2019-07-02 20:56:10 -07:00
|
|
|
if confirmed_blocks > 0 {
|
|
|
|
return Ok(confirmed_blocks);
|
|
|
|
} else {
|
2020-03-12 23:20:49 -07:00
|
|
|
return Err(RpcError::ForUser(format!(
|
|
|
|
"signature not found after {} seconds",
|
|
|
|
now.elapsed().as_secs()
|
|
|
|
))
|
|
|
|
.into());
|
2019-07-02 20:56:10 -07:00
|
|
|
}
|
2019-03-21 07:43:21 -07:00
|
|
|
}
|
2019-09-24 16:01:18 -07:00
|
|
|
sleep(Duration::from_millis(250));
|
2019-03-21 07:43:21 -07:00
|
|
|
}
|
2019-07-02 20:56:10 -07:00
|
|
|
Ok(confirmed_blocks)
|
2019-03-21 07:43:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get_num_blocks_since_signature_confirmation(
|
|
|
|
&self,
|
2019-12-18 21:26:11 -08:00
|
|
|
signature: &Signature,
|
2020-03-12 23:20:49 -07:00
|
|
|
) -> ClientResult<usize> {
|
2020-05-10 08:51:53 -07:00
|
|
|
let result: Response<Vec<Option<TransactionStatus>>> = self.send(
|
|
|
|
RpcRequest::GetSignatureStatuses,
|
|
|
|
json!([[signature.to_string()]]),
|
|
|
|
)?;
|
2020-03-26 18:21:01 -07:00
|
|
|
|
|
|
|
let confirmations = result.value[0]
|
|
|
|
.clone()
|
|
|
|
.ok_or_else(|| {
|
2020-05-10 08:51:53 -07:00
|
|
|
ClientError::new_with_request(
|
2020-03-26 18:21:01 -07:00
|
|
|
ClientErrorKind::Custom("signature not found".to_string()),
|
2020-05-10 08:51:53 -07:00
|
|
|
RpcRequest::GetSignatureStatuses,
|
2020-03-26 18:21:01 -07:00
|
|
|
)
|
|
|
|
})?
|
|
|
|
.confirmations
|
|
|
|
.unwrap_or(MAX_LOCKOUT_HISTORY + 1);
|
|
|
|
Ok(confirmations)
|
2019-03-21 07:43:21 -07:00
|
|
|
}
|
|
|
|
|
2020-05-09 09:06:32 -07:00
|
|
|
pub fn send_and_confirm_transaction_with_spinner(
|
2020-03-17 16:58:02 -07:00
|
|
|
&self,
|
2020-05-09 09:06:32 -07:00
|
|
|
transaction: &Transaction,
|
2020-05-31 23:00:51 -07:00
|
|
|
) -> ClientResult<Signature> {
|
|
|
|
self.send_and_confirm_transaction_with_spinner_and_config(
|
|
|
|
transaction,
|
|
|
|
RpcSendTransactionConfig::default(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn send_and_confirm_transaction_with_spinner_and_config(
|
|
|
|
&self,
|
|
|
|
transaction: &Transaction,
|
|
|
|
config: RpcSendTransactionConfig,
|
2020-03-27 15:46:00 -07:00
|
|
|
) -> ClientResult<Signature> {
|
2020-03-19 11:10:35 -07:00
|
|
|
let mut confirmations = 0;
|
|
|
|
|
|
|
|
let progress_bar = new_spinner_progress_bar();
|
|
|
|
|
2020-03-17 16:58:02 -07:00
|
|
|
let mut send_retries = 20;
|
2020-03-27 15:46:00 -07:00
|
|
|
let signature = loop {
|
2020-04-13 22:04:20 -07:00
|
|
|
progress_bar.set_message(&format!(
|
|
|
|
"[{}/{}] Finalizing transaction {}",
|
|
|
|
confirmations,
|
|
|
|
MAX_LOCKOUT_HISTORY + 1,
|
|
|
|
transaction.signatures[0],
|
|
|
|
));
|
2020-03-17 16:58:02 -07:00
|
|
|
let mut status_retries = 15;
|
2020-03-27 15:46:00 -07:00
|
|
|
let (signature, status) = loop {
|
2020-05-31 23:00:51 -07:00
|
|
|
let signature = self.send_transaction_with_config(transaction, config.clone())?;
|
2020-03-17 16:58:02 -07:00
|
|
|
|
|
|
|
// Get recent commitment in order to count confirmations for successful transactions
|
2020-03-27 15:46:00 -07:00
|
|
|
let status = self
|
|
|
|
.get_signature_status_with_commitment(&signature, CommitmentConfig::recent())?;
|
2020-03-17 16:58:02 -07:00
|
|
|
if status.is_none() {
|
|
|
|
status_retries -= 1;
|
|
|
|
if status_retries == 0 {
|
2020-03-27 15:46:00 -07:00
|
|
|
break (signature, status);
|
2020-03-17 16:58:02 -07:00
|
|
|
}
|
|
|
|
} else {
|
2020-03-27 15:46:00 -07:00
|
|
|
break (signature, status);
|
2020-03-17 16:58:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if cfg!(not(test)) {
|
|
|
|
sleep(Duration::from_millis(500));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
send_retries = if let Some(result) = status.clone() {
|
|
|
|
match result {
|
|
|
|
Ok(_) => 0,
|
|
|
|
// If transaction errors, return right away; no point in counting confirmations
|
|
|
|
Err(_) => 0,
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
send_retries - 1
|
|
|
|
};
|
|
|
|
if send_retries == 0 {
|
|
|
|
if let Some(result) = status {
|
|
|
|
match result {
|
|
|
|
Ok(_) => {
|
2020-03-27 15:46:00 -07:00
|
|
|
break signature;
|
2020-03-17 16:58:02 -07:00
|
|
|
}
|
|
|
|
Err(err) => {
|
|
|
|
return Err(err.into());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2020-05-09 09:06:32 -07:00
|
|
|
return Err(RpcError::ForUser(
|
|
|
|
"unable to confirm transaction. \
|
|
|
|
This can happen in situations such as transaction \
|
|
|
|
expiration and insufficient fee-payer funds"
|
|
|
|
.to_string(),
|
|
|
|
)
|
|
|
|
.into());
|
2020-03-17 16:58:02 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
2020-04-29 13:12:38 -07:00
|
|
|
let now = Instant::now();
|
2020-03-17 16:58:02 -07:00
|
|
|
loop {
|
|
|
|
// Return when default (max) commitment is reached
|
|
|
|
// Failed transactions have already been eliminated, `is_some` check is sufficient
|
2020-03-27 15:46:00 -07:00
|
|
|
if self.get_signature_status(&signature)?.is_some() {
|
2020-03-17 16:58:02 -07:00
|
|
|
progress_bar.set_message("Transaction confirmed");
|
|
|
|
progress_bar.finish_and_clear();
|
2020-03-27 15:46:00 -07:00
|
|
|
return Ok(signature);
|
2020-03-17 16:58:02 -07:00
|
|
|
}
|
|
|
|
progress_bar.set_message(&format!(
|
2020-04-13 22:04:20 -07:00
|
|
|
"[{}/{}] Finalizing transaction {}",
|
2020-03-19 11:10:35 -07:00
|
|
|
confirmations + 1,
|
|
|
|
MAX_LOCKOUT_HISTORY + 1,
|
2020-04-13 22:04:20 -07:00
|
|
|
signature,
|
2020-03-17 16:58:02 -07:00
|
|
|
));
|
|
|
|
sleep(Duration::from_millis(500));
|
2020-04-29 13:12:38 -07:00
|
|
|
confirmations = self
|
|
|
|
.get_num_blocks_since_signature_confirmation(&signature)
|
|
|
|
.unwrap_or(confirmations);
|
|
|
|
if now.elapsed().as_secs() >= MAX_HASH_AGE_IN_SECONDS as u64 {
|
|
|
|
return Err(
|
2020-05-09 09:06:32 -07:00
|
|
|
RpcError::ForUser("transaction not finalized. \
|
|
|
|
This can happen when a transaction lands in an abandoned fork. \
|
|
|
|
Please retry.".to_string()).into(),
|
2020-04-29 13:12:38 -07:00
|
|
|
);
|
|
|
|
}
|
2020-03-17 16:58:02 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-12 23:20:49 -07:00
|
|
|
pub fn validator_exit(&self) -> ClientResult<bool> {
|
2020-05-22 08:53:53 -07:00
|
|
|
self.send(RpcRequest::ValidatorExit, Value::Null)
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
|
2020-05-22 08:53:53 -07:00
|
|
|
pub fn send<T>(&self, request: RpcRequest, params: Value) -> ClientResult<T>
|
2020-05-10 08:51:53 -07:00
|
|
|
where
|
|
|
|
T: serde::de::DeserializeOwned,
|
|
|
|
{
|
2019-12-18 21:26:11 -08:00
|
|
|
assert!(params.is_array() || params.is_null());
|
2020-05-10 08:51:53 -07:00
|
|
|
let response = self
|
2020-05-20 18:40:45 -07:00
|
|
|
.sender
|
2020-05-22 08:53:53 -07:00
|
|
|
.send(request, params)
|
2020-05-10 08:51:53 -07:00
|
|
|
.map_err(|err| err.into_with_request(request))?;
|
|
|
|
serde_json::from_value(response)
|
|
|
|
.map_err(|err| ClientError::new_with_request(err.into(), request))
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-17 16:58:02 -07:00
|
|
|
fn new_spinner_progress_bar() -> ProgressBar {
|
|
|
|
let progress_bar = ProgressBar::new(42);
|
|
|
|
progress_bar
|
|
|
|
.set_style(ProgressStyle::default_spinner().template("{spinner:.green} {wide_msg}"));
|
|
|
|
progress_bar.enable_steady_tick(100);
|
|
|
|
progress_bar
|
|
|
|
}
|
|
|
|
|
2019-03-16 22:37:20 -07:00
|
|
|
pub fn get_rpc_request_str(rpc_addr: SocketAddr, tls: bool) -> String {
|
|
|
|
if tls {
|
|
|
|
format!("https://{}", rpc_addr)
|
|
|
|
} else {
|
|
|
|
format!("http://{}", rpc_addr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2020-05-20 18:40:45 -07:00
|
|
|
use crate::{client_error::ClientErrorKind, mock_sender::PUBKEY};
|
2019-12-09 19:35:34 -08:00
|
|
|
use assert_matches::assert_matches;
|
2019-03-16 22:37:20 -07:00
|
|
|
use jsonrpc_core::{Error, IoHandler, Params};
|
|
|
|
use jsonrpc_http_server::{AccessControlAllowOrigin, DomainsValidation, ServerBuilder};
|
|
|
|
use serde_json::Number;
|
2019-11-06 13:15:00 -08:00
|
|
|
use solana_sdk::{
|
2020-02-12 13:15:12 -08:00
|
|
|
instruction::InstructionError, signature::Keypair, system_transaction,
|
2019-11-06 13:15:00 -08:00
|
|
|
transaction::TransactionError,
|
|
|
|
};
|
2020-03-12 23:20:49 -07:00
|
|
|
use std::{io, sync::mpsc::channel, thread};
|
2019-03-16 22:37:20 -07:00
|
|
|
|
|
|
|
#[test]
|
2019-11-13 08:43:15 -08:00
|
|
|
fn test_send() {
|
2019-03-16 22:37:20 -07:00
|
|
|
let (sender, receiver) = channel();
|
|
|
|
thread::spawn(move || {
|
|
|
|
let rpc_addr = "0.0.0.0:0".parse().unwrap();
|
|
|
|
let mut io = IoHandler::default();
|
|
|
|
// Successful request
|
|
|
|
io.add_method("getBalance", |_params: Params| {
|
|
|
|
Ok(Value::Number(Number::from(50)))
|
|
|
|
});
|
|
|
|
// Failed request
|
|
|
|
io.add_method("getRecentBlockhash", |params: Params| {
|
|
|
|
if params != Params::None {
|
|
|
|
Err(Error::invalid_request())
|
|
|
|
} else {
|
|
|
|
Ok(Value::String(
|
|
|
|
"deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx".to_string(),
|
|
|
|
))
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
let server = ServerBuilder::new(io)
|
|
|
|
.threads(1)
|
|
|
|
.cors(DomainsValidation::AllowOnly(vec![
|
|
|
|
AccessControlAllowOrigin::Any,
|
|
|
|
]))
|
|
|
|
.start_http(&rpc_addr)
|
|
|
|
.expect("Unable to start RPC server");
|
|
|
|
sender.send(*server.address()).unwrap();
|
|
|
|
server.wait();
|
|
|
|
});
|
|
|
|
|
|
|
|
let rpc_addr = receiver.recv().unwrap();
|
|
|
|
let rpc_client = RpcClient::new_socket(rpc_addr);
|
|
|
|
|
2020-05-10 08:51:53 -07:00
|
|
|
let balance: u64 = rpc_client
|
|
|
|
.send(
|
|
|
|
RpcRequest::GetBalance,
|
|
|
|
json!(["deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx"]),
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
assert_eq!(balance, 50);
|
2019-03-16 22:37:20 -07:00
|
|
|
|
2020-05-10 08:51:53 -07:00
|
|
|
let blockhash: String = rpc_client
|
2020-05-22 08:53:53 -07:00
|
|
|
.send(RpcRequest::GetRecentBlockhash, Value::Null)
|
2020-05-10 08:51:53 -07:00
|
|
|
.unwrap();
|
|
|
|
assert_eq!(blockhash, "deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx");
|
2019-03-16 22:37:20 -07:00
|
|
|
|
|
|
|
// Send erroneous parameter
|
2020-05-10 08:51:53 -07:00
|
|
|
let blockhash: ClientResult<String> =
|
2020-05-22 08:53:53 -07:00
|
|
|
rpc_client.send(RpcRequest::GetRecentBlockhash, json!(["parameter"]));
|
2019-03-16 22:37:20 -07:00
|
|
|
assert_eq!(blockhash.is_err(), true);
|
|
|
|
}
|
|
|
|
|
2019-03-16 17:17:44 -07:00
|
|
|
#[test]
|
|
|
|
fn test_send_transaction() {
|
|
|
|
let rpc_client = RpcClient::new_mock("succeeds".to_string());
|
|
|
|
|
|
|
|
let key = Keypair::new();
|
2019-03-30 20:37:33 -07:00
|
|
|
let to = Pubkey::new_rand();
|
2019-03-16 17:17:44 -07:00
|
|
|
let blockhash = Hash::default();
|
2019-10-23 22:01:22 -07:00
|
|
|
let tx = system_transaction::transfer(&key, &to, 50, blockhash);
|
2019-03-16 17:17:44 -07:00
|
|
|
|
|
|
|
let signature = rpc_client.send_transaction(&tx);
|
2020-04-06 18:27:37 -07:00
|
|
|
assert_eq!(signature.unwrap(), tx.signatures[0]);
|
2019-03-16 17:17:44 -07:00
|
|
|
|
|
|
|
let rpc_client = RpcClient::new_mock("fails".to_string());
|
|
|
|
|
|
|
|
let signature = rpc_client.send_transaction(&tx);
|
|
|
|
assert!(signature.is_err());
|
2020-04-06 18:27:37 -07:00
|
|
|
|
|
|
|
// Test bad signature returned from rpc node
|
|
|
|
let rpc_client = RpcClient::new_mock("malicious".to_string());
|
|
|
|
let signature = rpc_client.send_transaction(&tx);
|
|
|
|
assert!(signature.is_err());
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
|
|
|
#[test]
|
|
|
|
fn test_get_recent_blockhash() {
|
|
|
|
let rpc_client = RpcClient::new_mock("succeeds".to_string());
|
|
|
|
|
2019-05-16 21:43:18 -07:00
|
|
|
let expected_blockhash: Hash = PUBKEY.parse().unwrap();
|
2019-03-16 17:17:44 -07:00
|
|
|
|
2019-05-13 12:49:37 -07:00
|
|
|
let (blockhash, _fee_calculator) = rpc_client.get_recent_blockhash().expect("blockhash ok");
|
2019-03-16 17:17:44 -07:00
|
|
|
assert_eq!(blockhash, expected_blockhash);
|
|
|
|
|
|
|
|
let rpc_client = RpcClient::new_mock("fails".to_string());
|
|
|
|
|
2019-05-13 12:49:37 -07:00
|
|
|
assert!(rpc_client.get_recent_blockhash().is_err());
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_get_signature_status() {
|
2020-03-27 15:46:00 -07:00
|
|
|
let signature = Signature::default();
|
|
|
|
|
2019-03-16 17:17:44 -07:00
|
|
|
let rpc_client = RpcClient::new_mock("succeeds".to_string());
|
2019-04-05 19:56:17 -07:00
|
|
|
let status = rpc_client.get_signature_status(&signature).unwrap();
|
|
|
|
assert_eq!(status, Some(Ok(())));
|
2019-03-16 17:17:44 -07:00
|
|
|
|
2019-04-05 19:56:17 -07:00
|
|
|
let rpc_client = RpcClient::new_mock("sig_not_found".to_string());
|
|
|
|
let status = rpc_client.get_signature_status(&signature).unwrap();
|
|
|
|
assert_eq!(status, None);
|
2019-03-16 17:17:44 -07:00
|
|
|
|
2019-04-05 19:56:17 -07:00
|
|
|
let rpc_client = RpcClient::new_mock("account_in_use".to_string());
|
|
|
|
let status = rpc_client.get_signature_status(&signature).unwrap();
|
|
|
|
assert_eq!(status, Some(Err(TransactionError::AccountInUse)));
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_send_and_confirm_transaction() {
|
|
|
|
let rpc_client = RpcClient::new_mock("succeeds".to_string());
|
|
|
|
|
|
|
|
let key = Keypair::new();
|
2019-03-30 20:37:33 -07:00
|
|
|
let to = Pubkey::new_rand();
|
2019-03-16 17:17:44 -07:00
|
|
|
let blockhash = Hash::default();
|
2020-05-09 09:06:32 -07:00
|
|
|
let tx = system_transaction::transfer(&key, &to, 50, blockhash);
|
|
|
|
let result = rpc_client.send_and_confirm_transaction(&tx);
|
2019-03-16 17:17:44 -07:00
|
|
|
result.unwrap();
|
|
|
|
|
|
|
|
let rpc_client = RpcClient::new_mock("account_in_use".to_string());
|
2020-05-09 09:06:32 -07:00
|
|
|
let result = rpc_client.send_and_confirm_transaction(&tx);
|
2019-03-16 17:17:44 -07:00
|
|
|
assert!(result.is_err());
|
|
|
|
|
2019-12-09 19:35:34 -08:00
|
|
|
let rpc_client = RpcClient::new_mock("instruction_error".to_string());
|
2020-05-09 09:06:32 -07:00
|
|
|
let result = rpc_client.send_and_confirm_transaction(&tx);
|
2019-12-09 19:35:34 -08:00
|
|
|
assert_matches!(
|
2020-03-12 23:20:49 -07:00
|
|
|
result.unwrap_err().kind(),
|
|
|
|
ClientErrorKind::TransactionError(TransactionError::InstructionError(
|
2019-12-09 19:35:34 -08:00
|
|
|
0,
|
|
|
|
InstructionError::UninitializedAccount
|
|
|
|
))
|
|
|
|
);
|
|
|
|
|
|
|
|
let rpc_client = RpcClient::new_mock("sig_not_found".to_string());
|
2020-05-09 09:06:32 -07:00
|
|
|
let result = rpc_client.send_and_confirm_transaction(&tx);
|
2020-03-12 23:20:49 -07:00
|
|
|
if let ClientErrorKind::Io(err) = result.unwrap_err().kind() {
|
2019-12-09 19:35:34 -08:00
|
|
|
assert_eq!(err.kind(), io::ErrorKind::Other);
|
|
|
|
}
|
2019-03-16 17:17:44 -07:00
|
|
|
}
|
|
|
|
|
2019-04-19 07:54:21 -07:00
|
|
|
#[test]
|
|
|
|
fn test_rpc_client_thread() {
|
|
|
|
let rpc_client = RpcClient::new_mock("succeeds".to_string());
|
|
|
|
thread::spawn(move || rpc_client);
|
|
|
|
}
|
2019-03-16 22:37:20 -07:00
|
|
|
}
|