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

Add support for multiple params

This commit is contained in:
Michael Vines 2019-12-18 22:26:11 -07:00
parent 01f44f531e
commit fcda972cec
6 changed files with 69 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/src/generic_rpc_client_request.rs
View File

@ -1,12 +1,10 @@
use crate::{client_error::ClientError, rpc_request::RpcRequest};
use solana_sdk::commitment_config::CommitmentConfig;
pub(crate) trait GenericRpcClientRequest {
fn send(
&self,
request: &RpcRequest,
params: Option<serde_json::Value>,
params: serde_json::Value,
retries: usize,
commitment_config: Option<CommitmentConfig>,
) -> Result<serde_json::Value, ClientError>;
}

8
client/src/mock_rpc_client_request.rs
View File

@ -5,7 +5,6 @@ use crate::{
};
use serde_json::{Number, Value};
use solana_sdk::{
commitment_config::CommitmentConfig,
fee_calculator::FeeCalculator,
instruction::InstructionError,
transaction::{self, TransactionError},
@ -29,17 +28,16 @@ impl GenericRpcClientRequest for MockRpcClientRequest {
fn send(
&self,
request: &RpcRequest,
params: Option<serde_json::Value>,
params: serde_json::Value,
_retries: usize,
_commitment_config: Option<CommitmentConfig>,
) -> Result<serde_json::Value, ClientError> {
if self.url == "fails" {
return Ok(Value::Null);
}
let val = match request {
RpcRequest::ConfirmTransaction => {
if let Some(Value::Array(param_array)) = params {
if let Value::String(param_string) = &param_array[0] {
if let Some(params_array) = params.as_array() {
if let Value::String(param_string) = &params_array[0] {
Value::Bool(param_string == SIGNATURE)
} else {
Value::Null

99
client/src/rpc_client.rs
View File

@ -70,14 +70,12 @@ impl RpcClient {
signature: &str,
commitment_config: CommitmentConfig,
) -> RpcResponse<bool> {
let params = json!(signature);
let response = self
.client
.send(
&RpcRequest::ConfirmTransaction,
Some(params),
json!([signature, commitment_config]),
0,
Some(commitment_config),
)
.map_err(|err| {
io::Error::new(
@ -96,10 +94,9 @@ impl RpcClient {
pub fn send_transaction(&self, transaction: &Transaction) -> Result<String, ClientError> {
let serialized = serialize(transaction).unwrap();
let params = json!(serialized);
let signature = self
.client
.send(&RpcRequest::SendTransaction, Some(params), 5, None)?;
.send(&RpcRequest::SendTransaction, json!([serialized]), 5)?;
if signature.as_str().is_none() {
Err(io::Error::new(
io::ErrorKind::Other,
@ -123,12 +120,10 @@ impl RpcClient {
signature: &str,
commitment_config: CommitmentConfig,
) -> Result<Option<transaction::Result<()>>, ClientError> {
let params = json!(signature.to_string());
let signature_status = self.client.send(
&RpcRequest::GetSignatureStatus,
Some(params),
json!([signature.to_string(), commitment_config]),
5,
commitment_config.ok(),
)?;
let result: Option<transaction::Result<()>> =
serde_json::from_value(signature_status).unwrap();
@ -145,7 +140,7 @@ impl RpcClient {
) -> io::Result<Slot> {
let response = self
.client
.send(&RpcRequest::GetSlot, None, 0, commitment_config.ok())
.send(&RpcRequest::GetSlot, json!([commitment_config]), 0)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -164,7 +159,7 @@ impl RpcClient {
pub fn get_vote_accounts(&self) -> io::Result<RpcVoteAccountStatus> {
let response = self
.client
.send(&RpcRequest::GetVoteAccounts, None, 0, None)
.send(&RpcRequest::GetVoteAccounts, Value::Null, 0)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -183,7 +178,7 @@ impl RpcClient {
pub fn get_cluster_nodes(&self) -> io::Result<Vec<RpcContactInfo>> {
let response = self
.client
.send(&RpcRequest::GetClusterNodes, None, 0, None)
.send(&RpcRequest::GetClusterNodes, Value::Null, 0)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -200,10 +195,9 @@ impl RpcClient {
}
pub fn get_block_time(&self, slot: Slot) -> io::Result<UnixTimestamp> {
let params = json!(slot);
let response = self
.client
.send(&RpcRequest::GetBlockTime, Some(params), 0, None);
.send(&RpcRequest::GetBlockTime, json!([slot]), 0);
response
.map(|result_json| {
@ -235,7 +229,7 @@ impl RpcClient {
) -> io::Result<RpcEpochInfo> {
let response = self
.client
.send(&RpcRequest::GetEpochInfo, None, 0, commitment_config.ok())
.send(&RpcRequest::GetEpochInfo, json!([commitment_config]), 0)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -260,14 +254,12 @@ impl RpcClient {
slot: Option<Slot>,
commitment_config: CommitmentConfig,
) -> io::Result<Option<RpcLeaderSchedule>> {
let params = slot.map(|slot| json!(slot));
let response = self
.client
.send(
&RpcRequest::GetLeaderSchedule,
params,
json!([slot, commitment_config]),
0,
commitment_config.ok(),
)
.map_err(|err| {
io::Error::new(
@ -287,7 +279,7 @@ impl RpcClient {
pub fn get_epoch_schedule(&self) -> io::Result<EpochSchedule> {
let response = self
.client
.send(&RpcRequest::GetEpochSchedule, None, 0, None)
.send(&RpcRequest::GetEpochSchedule, Value::Null, 0)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -306,7 +298,7 @@ impl RpcClient {
pub fn get_inflation(&self) -> io::Result<Inflation> {
let response = self
.client
.send(&RpcRequest::GetInflation, None, 0, None)
.send(&RpcRequest::GetInflation, Value::Null, 0)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -325,7 +317,7 @@ impl RpcClient {
pub fn get_version(&self) -> io::Result<RpcVersionInfo> {
let response = self
.client
.send(&RpcRequest::GetVersion, None, 0, None)
.send(&RpcRequest::GetVersion, Value::Null, 0)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -478,10 +470,13 @@ impl RpcClient {
pubkey: &Pubkey,
retries: usize,
) -> Result<Option<u64>, Box<dyn error::Error>> {
let params = json!(format!("{}", pubkey));
let balance_json = self
.client
.send(&RpcRequest::GetBalance, Some(params), retries, None)
.send(
&RpcRequest::GetBalance,
json!([pubkey.to_string()]),
retries,
)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -517,12 +512,10 @@ impl RpcClient {
pubkey: &Pubkey,
commitment_config: CommitmentConfig,
) -> RpcResponse<Option<Account>> {
let params = json!(format!("{}", pubkey));
let response = self.client.send(
&RpcRequest::GetAccountInfo,
Some(params),
json!([pubkey.to_string(), commitment_config]),
0,
Some(commitment_config),
);
response
@ -550,14 +543,12 @@ impl RpcClient {
}
pub fn get_minimum_balance_for_rent_exemption(&self, data_len: usize) -> io::Result<u64> {
let params = json!(data_len);
let minimum_balance_json = self
.client
.send(
&RpcRequest::GetMinimumBalanceForRentExemption,
Some(params),
json!([data_len]),
0,
None,
)
.map_err(|err| {
io::Error::new(
@ -595,14 +586,12 @@ impl RpcClient {
pubkey: &Pubkey,
commitment_config: CommitmentConfig,
) -> RpcResponse<u64> {
let params = json!(pubkey.to_string());
let balance_json = self
.client
.send(
&RpcRequest::GetBalance,
Some(params),
json!([pubkey.to_string(), commitment_config]),
0,
Some(commitment_config),
)
.map_err(|err| {
io::Error::new(
@ -620,10 +609,13 @@ impl RpcClient {
}
pub fn get_program_accounts(&self, pubkey: &Pubkey) -> io::Result<Vec<(Pubkey, Account)>> {
let params = json!(format!("{}", pubkey));
let response = self
.client
.send(&RpcRequest::GetProgramAccounts, Some(params), 0, None)
.send(
&RpcRequest::GetProgramAccounts,
json!([pubkey.to_string()]),
0,
)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -665,9 +657,8 @@ impl RpcClient {
.client
.send(
&RpcRequest::GetTransactionCount,
None,
json!([commitment_config]),
0,
commitment_config.ok(),
)
.map_err(|err| {
io::Error::new(
@ -698,9 +689,8 @@ impl RpcClient {
.client
.send(
&RpcRequest::GetRecentBlockhash,
None,
json!([commitment_config]),
0,
commitment_config.ok(),
)
.map_err(|err| {
io::Error::new(
@ -763,7 +753,7 @@ impl RpcClient {
pub fn get_genesis_hash(&self) -> io::Result<Hash> {
let response = self
.client
.send(&RpcRequest::GetGenesisHash, None, 0, None)
.send(&RpcRequest::GetGenesisHash, Value::Null, 0)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -888,14 +878,12 @@ impl RpcClient {
/// Check a signature in the bank.
pub fn check_signature(&self, signature: &Signature) -> bool {
trace!("check_signature: {:?}", signature);
let params = json!(format!("{}", signature));
for _ in 0..30 {
let response = self.client.send(
&RpcRequest::ConfirmTransaction,
Some(params.clone()),
json!([signature.to_string(), CommitmentConfig::recent()]),
0,
Some(CommitmentConfig::recent()),
);
match response {
@ -982,16 +970,14 @@ impl RpcClient {
pub fn get_num_blocks_since_signature_confirmation(
&self,
sig: &Signature,
signature: &Signature,
) -> io::Result<usize> {
let params = json!(format!("{}", sig));
let response = self
.client
.send(
&RpcRequest::GetNumBlocksSinceSignatureConfirmation,
Some(params.clone()),
json!([signature.to_string(), CommitmentConfig::recent().ok()]),
1,
CommitmentConfig::recent().ok(),
)
.map_err(|err| {
io::Error::new(
@ -1016,7 +1002,7 @@ impl RpcClient {
pub fn validator_exit(&self) -> io::Result<bool> {
let response = self
.client
.send(&RpcRequest::ValidatorExit, None, 0, None)
.send(&RpcRequest::ValidatorExit, Value::Null, 0)
.map_err(|err| {
io::Error::new(
io::ErrorKind::Other,
@ -1034,11 +1020,11 @@ impl RpcClient {
pub fn send(
&self,
request: &RpcRequest,
params: Option<Value>,
params: Value,
retries: usize,
commitment: Option<CommitmentConfig>,
) -> Result<Value, ClientError> {
self.client.send(request, params, retries, commitment)
assert!(params.is_array() || params.is_null());
self.client.send(request, params, retries)
}
}
@ -1104,25 +1090,19 @@ mod tests {
let balance = rpc_client.send(
&RpcRequest::GetBalance,
Some(json!(["deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx"])),
json!(["deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx"]),
0,
None,
);
assert_eq!(balance.unwrap().as_u64().unwrap(), 50);
let blockhash = rpc_client.send(&RpcRequest::GetRecentBlockhash, None, 0, None);
let blockhash = rpc_client.send(&RpcRequest::GetRecentBlockhash, Value::Null, 0);
assert_eq!(
blockhash.unwrap().as_str().unwrap(),
"deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx"
);
// Send erroneous parameter
let blockhash = rpc_client.send(
&RpcRequest::GetRecentBlockhash,
Some(json!("parameter")),
0,
None,
);
let blockhash = rpc_client.send(&RpcRequest::GetRecentBlockhash, json!(["parameter"]), 0);
assert_eq!(blockhash.is_err(), true);
}
@ -1158,9 +1138,8 @@ mod tests {
let balance = rpc_client.send(
&RpcRequest::GetBalance,
Some(json!(["deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhw"])),
json!(["deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhw"]),
10,
None,
);
assert_eq!(balance.unwrap().as_u64().unwrap(), 5);
}

11
client/src/rpc_client_request.rs
View File

@ -5,10 +5,7 @@ use crate::{
};
use log::*;
use reqwest::{self, header::CONTENT_TYPE};
use solana_sdk::{
clock::{DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT},
commitment_config::CommitmentConfig,
};
use solana_sdk::clock::{DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT};
use std::{thread::sleep, time::Duration};
pub struct RpcClientRequest {
@ -38,14 +35,14 @@ impl GenericRpcClientRequest for RpcClientRequest {
fn send(
&self,
request: &RpcRequest,
params: Option<serde_json::Value>,
//params: Option<serde_json::Value>,
params: serde_json::Value,
mut retries: usize,
commitment_config: Option<CommitmentConfig>,
) -> Result<serde_json::Value, ClientError> {
// Concurrent requests are not supported so reuse the same request id for all requests
let request_id = 1;
let request_json = request.build_request_json(request_id, params, commitment_config);
let request_json = request.build_request_json(request_id, params);
loop {
match self

47
client/src/rpc_request.rs
View File

@ -2,7 +2,6 @@ use jsonrpc_core::Result as JsonResult;
use serde_json::{json, Value};
use solana_sdk::{
clock::{Epoch, Slot},
commitment_config::CommitmentConfig,
hash::Hash,
transaction::{Result, Transaction},
};
@ -149,12 +148,7 @@ pub enum RpcRequest {
}
impl RpcRequest {
pub(crate) fn build_request_json(
&self,
id: u64,
params: Option<Value>,
commitment_config: Option<CommitmentConfig>,
) -> Value {
pub(crate) fn build_request_json(&self, id: u64, params: Value) -> Value {
let jsonrpc = "2.0";
let method = match self {
RpcRequest::ConfirmTransaction => "confirmTransaction",
@ -190,21 +184,12 @@ impl RpcRequest {
RpcRequest::SignVote => "signVote",
RpcRequest::GetMinimumBalanceForRentExemption => "getMinimumBalanceForRentExemption",
};
let mut request = json!({
json!({
"jsonrpc": jsonrpc,
"id": id,
"method": method,
});
if let Some(param_string) = params {
if let Some(config) = commitment_config {
request["params"] = json!([param_string, config]);
} else {
request["params"] = json!([param_string]);
}
} else if let Some(config) = commitment_config {
request["params"] = json!([config]);
}
request
"params": params,
})
}
}
@ -233,46 +218,46 @@ impl error::Error for RpcError {
#[cfg(test)]
mod tests {
use super::*;
use solana_sdk::commitment_config::CommitmentLevel;
use solana_sdk::commitment_config::{CommitmentConfig, CommitmentLevel};
#[test]
fn test_build_request_json() {
let test_request = RpcRequest::GetAccountInfo;
let addr = json!("deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx");
let request = test_request.build_request_json(1, Some(addr.clone()), None);
let request = test_request.build_request_json(1, json!([addr.clone()]));
assert_eq!(request["method"], "getAccountInfo");
assert_eq!(request["params"], json!([addr]));
let test_request = RpcRequest::GetBalance;
let request = test_request.build_request_json(1, Some(addr), None);
let request = test_request.build_request_json(1, json!([addr]));
assert_eq!(request["method"], "getBalance");
let test_request = RpcRequest::GetEpochInfo;
let request = test_request.build_request_json(1, None, None);
let request = test_request.build_request_json(1, Value::Null);
assert_eq!(request["method"], "getEpochInfo");
let test_request = RpcRequest::GetInflation;
let request = test_request.build_request_json(1, None, None);
let request = test_request.build_request_json(1, Value::Null);
assert_eq!(request["method"], "getInflation");
let test_request = RpcRequest::GetRecentBlockhash;
let request = test_request.build_request_json(1, None, None);
let request = test_request.build_request_json(1, Value::Null);
assert_eq!(request["method"], "getRecentBlockhash");
let test_request = RpcRequest::GetSlot;
let request = test_request.build_request_json(1, None, None);
let request = test_request.build_request_json(1, Value::Null);
assert_eq!(request["method"], "getSlot");
let test_request = RpcRequest::GetTransactionCount;
let request = test_request.build_request_json(1, None, None);
let request = test_request.build_request_json(1, Value::Null);
assert_eq!(request["method"], "getTransactionCount");
let test_request = RpcRequest::RequestAirdrop;
let request = test_request.build_request_json(1, None, None);
let request = test_request.build_request_json(1, Value::Null);
assert_eq!(request["method"], "requestAirdrop");
let test_request = RpcRequest::SendTransaction;
let request = test_request.build_request_json(1, None, None);
let request = test_request.build_request_json(1, Value::Null);
assert_eq!(request["method"], "sendTransaction");
}
@ -285,13 +270,13 @@ mod tests {
// Test request with CommitmentConfig and no params
let test_request = RpcRequest::GetRecentBlockhash;
let request = test_request.build_request_json(1, None, Some(commitment_config.clone()));
let request = test_request.build_request_json(1, json!([commitment_config.clone()]));
assert_eq!(request["params"], json!([commitment_config.clone()]));
// Test request with CommitmentConfig and params
let test_request = RpcRequest::GetBalance;
let request =
test_request.build_request_json(1, Some(addr.clone()), Some(commitment_config.clone()));
test_request.build_request_json(1, json!([addr.clone(), commitment_config.clone()]));
assert_eq!(request["params"], json!([addr, commitment_config]));
}
}

9
core/src/archiver.rs
View File

@ -748,9 +748,8 @@ impl Archiver {
Ok(rpc_client
.send(
&RpcRequest::GetSlotsPerSegment,
None,
serde_json::json!([client_commitment]),
0,
Some(client_commitment),
)
.map_err(|err| {
warn!("Error while making rpc request {:?}", err);
@ -803,7 +802,11 @@ impl Archiver {
RpcClient::new_socket(rpc_peers[node_index].rpc)
};
let response = rpc_client
.send(&RpcRequest::GetStorageTurn, None, 0, None)
.send(
&RpcRequest::GetStorageTurn,
serde_json::value::Value::Null,
0,
)
.map_err(|err| {
warn!("Error while making rpc request {:?}", err);
Error::IO(io::Error::new(ErrorKind::Other, "rpc error"))