From 974e6dd2c1ac3c8f3eb055be34a7a80ce016bcdd Mon Sep 17 00:00:00 2001 From: Tyera Eulberg Date: Thu, 15 Apr 2021 17:00:14 -0600 Subject: [PATCH] Deprecate "confirmed" RpcClient methods (#16520) * Remove obsolete client methods * Deprecate GetConfirmed client methods * Rename Confirmed config structs, with appropriate deprecation * Fixup client apps * Map RpcRequest to deprecated when targeting older nodes --- cli/src/cli.rs | 6 +- cli/src/cluster_query.rs | 20 +-- client/src/lib.rs | 1 + client/src/rpc_client.rs | 244 ++++++++++++++++++++++------ client/src/rpc_config.rs | 35 ++-- client/src/rpc_deprecated_config.rs | 120 ++++++++++++++ client/src/rpc_request.rs | 37 +++-- core/src/rpc.rs | 32 ++-- ramp-tps/src/voters.rs | 2 +- stake-monitor/src/lib.rs | 5 +- 10 files changed, 398 insertions(+), 104 deletions(-) create mode 100644 client/src/rpc_deprecated_config.rs diff --git a/cli/src/cli.rs b/cli/src/cli.rs index bffb97cc80..9fc7c60bdb 100644 --- a/cli/src/cli.rs +++ b/cli/src/cli.rs @@ -28,7 +28,7 @@ use solana_client::{ nonce_utils, rpc_client::RpcClient, rpc_config::{ - RpcConfirmedTransactionConfig, RpcLargestAccountsFilter, RpcSendTransactionConfig, + RpcLargestAccountsFilter, RpcSendTransactionConfig, RpcTransactionConfig, RpcTransactionLogsFilter, }, rpc_response::RpcKeyedAccount, @@ -1033,9 +1033,9 @@ fn process_confirm( let mut transaction = None; let mut get_transaction_error = None; if config.verbose { - match rpc_client.get_confirmed_transaction_with_config( + match rpc_client.get_transaction_with_config( signature, - RpcConfirmedTransactionConfig { + RpcTransactionConfig { encoding: Some(UiTransactionEncoding::Base64), commitment: Some(CommitmentConfig::confirmed()), }, diff --git a/cli/src/cluster_query.rs b/cli/src/cluster_query.rs index cd08f98129..4892e22e14 100644 --- a/cli/src/cluster_query.rs +++ b/cli/src/cluster_query.rs @@ -24,9 +24,9 @@ use solana_client::{ pubsub_client::PubsubClient, rpc_client::{GetConfirmedSignaturesForAddress2Config, RpcClient}, rpc_config::{ - RpcAccountInfoConfig, RpcConfirmedBlockConfig, RpcConfirmedTransactionConfig, - RpcLargestAccountsConfig, RpcLargestAccountsFilter, RpcProgramAccountsConfig, - RpcTransactionLogsConfig, RpcTransactionLogsFilter, + RpcAccountInfoConfig, RpcBlockConfig, RpcLargestAccountsConfig, RpcLargestAccountsFilter, + RpcProgramAccountsConfig, RpcTransactionConfig, RpcTransactionLogsConfig, + RpcTransactionLogsFilter, }, rpc_filter, rpc_response::SlotInfo, @@ -975,12 +975,12 @@ pub fn process_get_block( }; let encoded_confirmed_block = rpc_client - .get_confirmed_block_with_config( + .get_block_with_config( slot, - RpcConfirmedBlockConfig { + RpcBlockConfig { encoding: Some(UiTransactionEncoding::Base64), commitment: Some(CommitmentConfig::confirmed()), - ..RpcConfirmedBlockConfig::default() + ..RpcBlockConfig::default() }, )? .into(); @@ -1108,7 +1108,7 @@ pub fn process_show_block_production( "Fetching confirmed blocks between slots {} and {}...", start_slot, end_slot )); - let confirmed_blocks = rpc_client.get_confirmed_blocks(start_slot, Some(end_slot))?; + let confirmed_blocks = rpc_client.get_blocks(start_slot, Some(end_slot))?; let start_slot_index = (start_slot - first_slot_in_epoch) as usize; let end_slot_index = (end_slot - first_slot_in_epoch) as usize; @@ -1829,7 +1829,7 @@ pub fn process_transaction_history( limit: usize, show_transactions: bool, ) -> ProcessResult { - let results = rpc_client.get_confirmed_signatures_for_address2_with_config( + let results = rpc_client.get_signatures_for_address_with_config( address, GetConfirmedSignaturesForAddress2Config { before, @@ -1868,9 +1868,9 @@ pub fn process_transaction_history( if show_transactions { if let Ok(signature) = result.signature.parse::() { - match rpc_client.get_confirmed_transaction_with_config( + match rpc_client.get_transaction_with_config( &signature, - RpcConfirmedTransactionConfig { + RpcTransactionConfig { encoding: Some(UiTransactionEncoding::Base64), commitment: Some(CommitmentConfig::confirmed()), }, diff --git a/client/src/lib.rs b/client/src/lib.rs index 119c46c134..18621f3b3e 100644 --- a/client/src/lib.rs +++ b/client/src/lib.rs @@ -13,6 +13,7 @@ pub mod rpc_cache; pub mod rpc_client; pub mod rpc_config; pub mod rpc_custom_error; +pub mod rpc_deprecated_config; pub mod rpc_filter; pub mod rpc_request; pub mod rpc_response; diff --git a/client/src/rpc_client.rs b/client/src/rpc_client.rs index f45acc3222..415efa4564 100644 --- a/client/src/rpc_client.rs +++ b/client/src/rpc_client.rs @@ -1,3 +1,8 @@ +#[allow(deprecated)] +use crate::rpc_deprecated_config::{ + RpcConfirmedBlockConfig, RpcConfirmedTransactionConfig, + RpcGetConfirmedSignaturesForAddress2Config, +}; use { crate::{ client_error::{ClientError, ClientErrorKind, Result as ClientResult}, @@ -5,10 +10,9 @@ use { mock_sender::{MockSender, Mocks}, rpc_config::RpcAccountInfoConfig, rpc_config::{ - RpcConfirmedBlockConfig, RpcConfirmedTransactionConfig, RpcEpochConfig, - RpcGetConfirmedSignaturesForAddress2Config, RpcLargestAccountsConfig, - RpcProgramAccountsConfig, RpcRequestAirdropConfig, RpcSendTransactionConfig, - RpcSimulateTransactionConfig, RpcTokenAccountsFilter, + RpcBlockConfig, RpcEpochConfig, RpcLargestAccountsConfig, RpcProgramAccountsConfig, + RpcRequestAirdropConfig, RpcSendTransactionConfig, RpcSignaturesForAddressConfig, + RpcSimulateTransactionConfig, RpcTokenAccountsFilter, RpcTransactionConfig, }, rpc_request::{RpcError, RpcRequest, RpcResponseErrorData, TokenAccountsFilter}, rpc_response::*, @@ -182,6 +186,23 @@ impl RpcClient { Ok(requested_commitment) } + #[allow(deprecated)] + fn maybe_map_request(&self, mut request: RpcRequest) -> Result { + if self.get_node_version()? < semver::Version::new(1, 7, 0) { + request = match request { + RpcRequest::GetBlock => RpcRequest::GetConfirmedBlock, + RpcRequest::GetBlocks => RpcRequest::GetConfirmedBlocks, + RpcRequest::GetBlocksWithLimit => RpcRequest::GetConfirmedBlocksWithLimit, + RpcRequest::GetSignaturesForAddress => { + RpcRequest::GetConfirmedSignaturesForAddress2 + } + RpcRequest::GetTransaction => RpcRequest::GetConfirmedTransaction, + _ => request, + }; + } + Ok(request) + } + pub fn confirm_transaction(&self, signature: &Signature) -> ClientResult { Ok(self .confirm_transaction_with_commitment(signature, self.commitment_config)? @@ -458,27 +479,6 @@ impl RpcClient { ) } - #[deprecated(since = "1.5.19", note = "Please use RpcClient::supply() instead")] - #[allow(deprecated)] - pub fn total_supply(&self) -> ClientResult { - self.total_supply_with_commitment(self.commitment_config) - } - - #[deprecated( - since = "1.5.19", - note = "Please use RpcClient::supply_with_commitment() instead" - )] - #[allow(deprecated)] - pub fn total_supply_with_commitment( - &self, - commitment_config: CommitmentConfig, - ) -> ClientResult { - self.send( - RpcRequest::GetTotalSupply, - json!([self.maybe_map_commitment(commitment_config)?]), - ) - } - pub fn get_largest_accounts_with_config( &self, config: RpcLargestAccountsConfig, @@ -542,10 +542,43 @@ impl RpcClient { self.send(RpcRequest::GetClusterNodes, Value::Null) } + pub fn get_block(&self, slot: Slot) -> ClientResult { + self.get_block_with_encoding(slot, UiTransactionEncoding::Json) + } + + pub fn get_block_with_encoding( + &self, + slot: Slot, + encoding: UiTransactionEncoding, + ) -> ClientResult { + self.send( + self.maybe_map_request(RpcRequest::GetBlock)?, + json!([slot, encoding]), + ) + } + + pub fn get_block_with_config( + &self, + slot: Slot, + config: RpcBlockConfig, + ) -> ClientResult { + self.send( + self.maybe_map_request(RpcRequest::GetBlock)?, + json!([slot, config]), + ) + } + + #[deprecated(since = "1.7.0", note = "Please use RpcClient::get_block() instead")] + #[allow(deprecated)] pub fn get_confirmed_block(&self, slot: Slot) -> ClientResult { self.get_confirmed_block_with_encoding(slot, UiTransactionEncoding::Json) } + #[deprecated( + since = "1.7.0", + note = "Please use RpcClient::get_block_with_encoding() instead" + )] + #[allow(deprecated)] pub fn get_confirmed_block_with_encoding( &self, slot: Slot, @@ -554,6 +587,11 @@ impl RpcClient { self.send(RpcRequest::GetConfirmedBlock, json!([slot, encoding])) } + #[deprecated( + since = "1.7.0", + note = "Please use RpcClient::get_block_with_config() instead" + )] + #[allow(deprecated)] pub fn get_confirmed_block_with_config( &self, slot: Slot, @@ -562,6 +600,56 @@ impl RpcClient { self.send(RpcRequest::GetConfirmedBlock, json!([slot, config])) } + pub fn get_blocks(&self, start_slot: Slot, end_slot: Option) -> ClientResult> { + self.send( + self.maybe_map_request(RpcRequest::GetBlocks)?, + json!([start_slot, end_slot]), + ) + } + + pub fn get_blocks_with_commitment( + &self, + start_slot: Slot, + end_slot: Option, + commitment_config: CommitmentConfig, + ) -> ClientResult> { + let json = if end_slot.is_some() { + json!([ + start_slot, + end_slot, + self.maybe_map_commitment(commitment_config)? + ]) + } else { + json!([start_slot, self.maybe_map_commitment(commitment_config)?]) + }; + self.send(self.maybe_map_request(RpcRequest::GetBlocks)?, json) + } + + pub fn get_blocks_with_limit(&self, start_slot: Slot, limit: usize) -> ClientResult> { + self.send( + self.maybe_map_request(RpcRequest::GetBlocksWithLimit)?, + json!([start_slot, limit]), + ) + } + + pub fn get_blocks_with_limit_and_commitment( + &self, + start_slot: Slot, + limit: usize, + commitment_config: CommitmentConfig, + ) -> ClientResult> { + self.send( + self.maybe_map_request(RpcRequest::GetBlocksWithLimit)?, + json!([ + start_slot, + limit, + self.maybe_map_commitment(commitment_config)? + ]), + ) + } + + #[deprecated(since = "1.7.0", note = "Please use RpcClient::get_blocks() instead")] + #[allow(deprecated)] pub fn get_confirmed_blocks( &self, start_slot: Slot, @@ -573,6 +661,11 @@ impl RpcClient { ) } + #[deprecated( + since = "1.7.0", + note = "Please use RpcClient::get_blocks_with_commitment() instead" + )] + #[allow(deprecated)] pub fn get_confirmed_blocks_with_commitment( &self, start_slot: Slot, @@ -591,6 +684,11 @@ impl RpcClient { self.send(RpcRequest::GetConfirmedBlocks, json) } + #[deprecated( + since = "1.7.0", + note = "Please use RpcClient::get_blocks_with_limit() instead" + )] + #[allow(deprecated)] pub fn get_confirmed_blocks_with_limit( &self, start_slot: Slot, @@ -602,6 +700,11 @@ impl RpcClient { ) } + #[deprecated( + since = "1.7.0", + note = "Please use RpcClient::get_blocks_with_limit_and_commitment() instead" + )] + #[allow(deprecated)] pub fn get_confirmed_blocks_with_limit_and_commitment( &self, start_slot: Slot, @@ -618,33 +721,41 @@ impl RpcClient { ) } - #[deprecated( - since = "1.5.19", - note = "Please use RpcClient::get_confirmed_signatures_for_address2() instead" - )] - #[allow(deprecated)] - pub fn get_confirmed_signatures_for_address( + pub fn get_signatures_for_address( &self, address: &Pubkey, - start_slot: Slot, - end_slot: Slot, - ) -> ClientResult> { - let signatures_base58_str: Vec = self.send( - RpcRequest::GetConfirmedSignaturesForAddress, - json!([address.to_string(), start_slot, end_slot]), - )?; - - let mut signatures = vec![]; - for signature_base58_str in signatures_base58_str { - signatures.push( - signature_base58_str.parse::().map_err(|err| { - Into::::into(RpcError::ParseError(err.to_string())) - })?, - ); - } - Ok(signatures) + ) -> ClientResult> { + self.get_signatures_for_address_with_config( + address, + GetConfirmedSignaturesForAddress2Config::default(), + ) } + pub fn get_signatures_for_address_with_config( + &self, + address: &Pubkey, + config: GetConfirmedSignaturesForAddress2Config, + ) -> ClientResult> { + let config = RpcSignaturesForAddressConfig { + before: config.before.map(|signature| signature.to_string()), + until: config.until.map(|signature| signature.to_string()), + limit: config.limit, + commitment: config.commitment, + }; + + let result: Vec = self.send( + self.maybe_map_request(RpcRequest::GetSignaturesForAddress)?, + json!([address.to_string(), config]), + )?; + + Ok(result) + } + + #[deprecated( + since = "1.7.0", + note = "Please use RpcClient::get_signatures_for_address() instead" + )] + #[allow(deprecated)] pub fn get_confirmed_signatures_for_address2( &self, address: &Pubkey, @@ -655,6 +766,11 @@ impl RpcClient { ) } + #[deprecated( + since = "1.7.0", + note = "Please use RpcClient::get_signatures_for_address_with_config() instead" + )] + #[allow(deprecated)] pub fn get_confirmed_signatures_for_address2_with_config( &self, address: &Pubkey, @@ -675,6 +791,33 @@ impl RpcClient { Ok(result) } + pub fn get_transaction( + &self, + signature: &Signature, + encoding: UiTransactionEncoding, + ) -> ClientResult { + self.send( + self.maybe_map_request(RpcRequest::GetTransaction)?, + json!([signature.to_string(), encoding]), + ) + } + + pub fn get_transaction_with_config( + &self, + signature: &Signature, + config: RpcTransactionConfig, + ) -> ClientResult { + self.send( + self.maybe_map_request(RpcRequest::GetTransaction)?, + json!([signature.to_string(), config]), + ) + } + + #[deprecated( + since = "1.7.0", + note = "Please use RpcClient::get_transaction() instead" + )] + #[allow(deprecated)] pub fn get_confirmed_transaction( &self, signature: &Signature, @@ -686,6 +829,11 @@ impl RpcClient { ) } + #[deprecated( + since = "1.7.0", + note = "Please use RpcClient::get_transaction_with_config() instead" + )] + #[allow(deprecated)] pub fn get_confirmed_transaction_with_config( &self, signature: &Signature, diff --git a/client/src/rpc_config.rs b/client/src/rpc_config.rs index fbd8ad0839..e753bbde63 100644 --- a/client/src/rpc_config.rs +++ b/client/src/rpc_config.rs @@ -113,7 +113,7 @@ pub struct RpcSignatureSubscribeConfig { #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct RpcGetConfirmedSignaturesForAddress2Config { +pub struct RpcSignaturesForAddressConfig { pub before: Option, // Signature as base-58 string pub until: Option, // Signature as base-58 string pub limit: Option, @@ -135,6 +135,17 @@ impl RpcEncodingConfigWrapper { RpcEncodingConfigWrapper::Current(config) => config.unwrap_or_default(), } } + + pub fn convert>(&self) -> RpcEncodingConfigWrapper { + match self { + RpcEncodingConfigWrapper::Deprecated(encoding) => { + RpcEncodingConfigWrapper::Deprecated(*encoding) + } + RpcEncodingConfigWrapper::Current(config) => { + RpcEncodingConfigWrapper::Current(config.map(|config| config.into())) + } + } + } } pub trait EncodingConfig { @@ -143,7 +154,7 @@ pub trait EncodingConfig { #[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct RpcConfirmedBlockConfig { +pub struct RpcBlockConfig { pub encoding: Option, pub transaction_details: Option, pub rewards: Option, @@ -151,7 +162,7 @@ pub struct RpcConfirmedBlockConfig { pub commitment: Option, } -impl EncodingConfig for RpcConfirmedBlockConfig { +impl EncodingConfig for RpcBlockConfig { fn new_with_encoding(encoding: &Option) -> Self { Self { encoding: *encoding, @@ -160,7 +171,7 @@ impl EncodingConfig for RpcConfirmedBlockConfig { } } -impl RpcConfirmedBlockConfig { +impl RpcBlockConfig { pub fn rewards_only() -> Self { Self { transaction_details: Some(TransactionDetails::None), @@ -177,21 +188,21 @@ impl RpcConfirmedBlockConfig { } } -impl From for RpcEncodingConfigWrapper { - fn from(config: RpcConfirmedBlockConfig) -> Self { +impl From for RpcEncodingConfigWrapper { + fn from(config: RpcBlockConfig) -> Self { RpcEncodingConfigWrapper::Current(Some(config)) } } #[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct RpcConfirmedTransactionConfig { +pub struct RpcTransactionConfig { pub encoding: Option, #[serde(flatten)] pub commitment: Option, } -impl EncodingConfig for RpcConfirmedTransactionConfig { +impl EncodingConfig for RpcTransactionConfig { fn new_with_encoding(encoding: &Option) -> Self { Self { encoding: *encoding, @@ -202,16 +213,16 @@ impl EncodingConfig for RpcConfirmedTransactionConfig { #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(untagged)] -pub enum RpcConfirmedBlocksConfigWrapper { +pub enum RpcBlocksConfigWrapper { EndSlotOnly(Option), CommitmentOnly(Option), } -impl RpcConfirmedBlocksConfigWrapper { +impl RpcBlocksConfigWrapper { pub fn unzip(&self) -> (Option, Option) { match &self { - RpcConfirmedBlocksConfigWrapper::EndSlotOnly(end_slot) => (*end_slot, None), - RpcConfirmedBlocksConfigWrapper::CommitmentOnly(commitment) => (None, *commitment), + RpcBlocksConfigWrapper::EndSlotOnly(end_slot) => (*end_slot, None), + RpcBlocksConfigWrapper::CommitmentOnly(commitment) => (None, *commitment), } } } diff --git a/client/src/rpc_deprecated_config.rs b/client/src/rpc_deprecated_config.rs new file mode 100644 index 0000000000..9062513ba5 --- /dev/null +++ b/client/src/rpc_deprecated_config.rs @@ -0,0 +1,120 @@ +#![allow(deprecated)] +use { + crate::rpc_config::{ + EncodingConfig, RpcBlockConfig, RpcEncodingConfigWrapper, RpcTransactionConfig, + }, + solana_sdk::{clock::Slot, commitment_config::CommitmentConfig}, + solana_transaction_status::{TransactionDetails, UiTransactionEncoding}, +}; + +#[deprecated( + since = "1.7.0", + note = "Please use RpcSignaturesForAddressConfig instead" +)] +#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct RpcGetConfirmedSignaturesForAddress2Config { + pub before: Option, // Signature as base-58 string + pub until: Option, // Signature as base-58 string + pub limit: Option, + #[serde(flatten)] + pub commitment: Option, +} + +#[deprecated(since = "1.7.0", note = "Please use RpcBlockConfig instead")] +#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct RpcConfirmedBlockConfig { + pub encoding: Option, + pub transaction_details: Option, + pub rewards: Option, + #[serde(flatten)] + pub commitment: Option, +} + +impl EncodingConfig for RpcConfirmedBlockConfig { + fn new_with_encoding(encoding: &Option) -> Self { + Self { + encoding: *encoding, + ..Self::default() + } + } +} + +impl RpcConfirmedBlockConfig { + pub fn rewards_only() -> Self { + Self { + transaction_details: Some(TransactionDetails::None), + ..Self::default() + } + } + + pub fn rewards_with_commitment(commitment: Option) -> Self { + Self { + transaction_details: Some(TransactionDetails::None), + commitment, + ..Self::default() + } + } +} + +impl From for RpcEncodingConfigWrapper { + fn from(config: RpcConfirmedBlockConfig) -> Self { + RpcEncodingConfigWrapper::Current(Some(config)) + } +} + +impl From for RpcBlockConfig { + fn from(config: RpcConfirmedBlockConfig) -> Self { + Self { + encoding: config.encoding, + transaction_details: config.transaction_details, + rewards: config.rewards, + commitment: config.commitment, + } + } +} + +#[deprecated(since = "1.7.0", note = "Please use RpcTransactionConfig instead")] +#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct RpcConfirmedTransactionConfig { + pub encoding: Option, + #[serde(flatten)] + pub commitment: Option, +} + +impl EncodingConfig for RpcConfirmedTransactionConfig { + fn new_with_encoding(encoding: &Option) -> Self { + Self { + encoding: *encoding, + ..Self::default() + } + } +} + +impl From for RpcTransactionConfig { + fn from(config: RpcConfirmedTransactionConfig) -> Self { + Self { + encoding: config.encoding, + commitment: config.commitment, + } + } +} + +#[deprecated(since = "1.7.0", note = "Please use RpcBlocksConfigWrapper instead")] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(untagged)] +pub enum RpcConfirmedBlocksConfigWrapper { + EndSlotOnly(Option), + CommitmentOnly(Option), +} + +impl RpcConfirmedBlocksConfigWrapper { + pub fn unzip(&self) -> (Option, Option) { + match &self { + RpcConfirmedBlocksConfigWrapper::EndSlotOnly(end_slot) => (*end_slot, None), + RpcConfirmedBlocksConfigWrapper::CommitmentOnly(commitment) => (None, *commitment), + } + } +} diff --git a/client/src/rpc_request.rs b/client/src/rpc_request.rs index c76cbc3e6f..110ecf8716 100644 --- a/client/src/rpc_request.rs +++ b/client/src/rpc_request.rs @@ -11,20 +11,32 @@ pub enum RpcRequest { DeregisterNode, GetAccountInfo, GetBalance, + GetBlock, + GetBlocks, + GetBlocksWithLimit, GetBlockTime, GetClusterNodes, + + #[deprecated(since = "1.7.0", note = "Please use RpcRequest::GetBlock instead")] GetConfirmedBlock, + #[deprecated(since = "1.7.0", note = "Please use RpcRequest::GetBlocks instead")] GetConfirmedBlocks, - GetConfirmedBlocksWithLimit, - #[deprecated( - since = "1.5.19", - note = "Please use RpcRequest::GetConfirmedSignaturesForAddress2 instead" + since = "1.7.0", + note = "Please use RpcRequest::GetBlocksWithLimit instead" + )] + GetConfirmedBlocksWithLimit, + #[deprecated( + since = "1.7.0", + note = "Please use RpcRequest::GetSignaturesForAddress instead" )] - GetConfirmedSignaturesForAddress, - GetConfirmedSignaturesForAddress2, + #[deprecated( + since = "1.7.0", + note = "Please use RpcRequest::GetTransaction instead" + )] GetConfirmedTransaction, + GetEpochInfo, GetEpochSchedule, GetFeeCalculatorForBlockhash, @@ -47,6 +59,7 @@ pub enum RpcRequest { GetRecentBlockhash, GetRecentPerformanceSamples, GetSnapshotSlot, + GetSignaturesForAddress, GetSignatureStatuses, GetSlot, GetSlotLeader, @@ -61,10 +74,7 @@ pub enum RpcRequest { GetTokenAccountsByDelegate, GetTokenAccountsByOwner, GetTokenSupply, - - #[deprecated(since = "1.5.19", note = "Please use RpcRequest::GetSupply instead")] - GetTotalSupply, - + GetTransaction, GetTransactionCount, GetVersion, GetVoteAccounts, @@ -83,12 +93,14 @@ impl fmt::Display for RpcRequest { RpcRequest::DeregisterNode => "deregisterNode", RpcRequest::GetAccountInfo => "getAccountInfo", RpcRequest::GetBalance => "getBalance", + RpcRequest::GetBlock => "getBlock", + RpcRequest::GetBlocks => "getBlocks", + RpcRequest::GetBlocksWithLimit => "getBlocksWithLimit", RpcRequest::GetBlockTime => "getBlockTime", RpcRequest::GetClusterNodes => "getClusterNodes", RpcRequest::GetConfirmedBlock => "getConfirmedBlock", RpcRequest::GetConfirmedBlocks => "getConfirmedBlocks", RpcRequest::GetConfirmedBlocksWithLimit => "getConfirmedBlocksWithLimit", - RpcRequest::GetConfirmedSignaturesForAddress => "getConfirmedSignaturesForAddress", RpcRequest::GetConfirmedSignaturesForAddress2 => "getConfirmedSignaturesForAddress2", RpcRequest::GetConfirmedTransaction => "getConfirmedTransaction", RpcRequest::GetEpochInfo => "getEpochInfo", @@ -113,6 +125,7 @@ impl fmt::Display for RpcRequest { RpcRequest::GetRecentBlockhash => "getRecentBlockhash", RpcRequest::GetRecentPerformanceSamples => "getRecentPerformanceSamples", RpcRequest::GetSnapshotSlot => "getSnapshotSlot", + RpcRequest::GetSignaturesForAddress => "getSignaturesForAddress", RpcRequest::GetSignatureStatuses => "getSignatureStatuses", RpcRequest::GetSlot => "getSlot", RpcRequest::GetSlotLeader => "getSlotLeader", @@ -127,7 +140,7 @@ impl fmt::Display for RpcRequest { RpcRequest::GetTokenAccountsByDelegate => "getTokenAccountsByDelegate", RpcRequest::GetTokenAccountsByOwner => "getTokenAccountsByOwner", RpcRequest::GetTokenSupply => "getTokenSupply", - RpcRequest::GetTotalSupply => "getTotalSupply", + RpcRequest::GetTransaction => "getTransaction", RpcRequest::GetTransactionCount => "getTransactionCount", RpcRequest::GetVersion => "getVersion", RpcRequest::GetVoteAccounts => "getVoteAccounts", diff --git a/core/src/rpc.rs b/core/src/rpc.rs index 6ae8057883..064185683b 100644 --- a/core/src/rpc.rs +++ b/core/src/rpc.rs @@ -25,6 +25,7 @@ use solana_client::{ rpc_cache::LargestAccountsCache, rpc_config::*, rpc_custom_error::RpcCustomError, + rpc_deprecated_config::*, rpc_filter::{Memcmp, MemcmpEncodedBytes, RpcFilterType}, rpc_request::{ TokenAccountsFilter, DELINQUENT_VALIDATOR_SLOT_DISTANCE, MAX_GET_CONFIRMED_BLOCKS_RANGE, @@ -423,7 +424,7 @@ impl JsonRpcRequestProcessor { let first_confirmed_block = if let Ok(Some(first_confirmed_block)) = self.get_block( first_confirmed_block_in_epoch, - Some(RpcConfirmedBlockConfig::rewards_with_commitment(config.commitment).into()), + Some(RpcBlockConfig::rewards_with_commitment(config.commitment).into()), ) { first_confirmed_block } else { @@ -817,7 +818,7 @@ impl JsonRpcRequestProcessor { pub fn get_block( &self, slot: Slot, - config: Option>, + config: Option>, ) -> Result> { if self.config.enable_rpc_transaction_history { let config = config @@ -1171,7 +1172,7 @@ impl JsonRpcRequestProcessor { pub fn get_transaction( &self, signature: Signature, - config: Option>, + config: Option>, ) -> Result> { let config = config .map(|config| config.convert_to_current()) @@ -2403,7 +2404,7 @@ pub mod rpc_full { &self, meta: Self::Metadata, slot: Slot, - config: Option>, + config: Option>, ) -> Result>; #[rpc(meta, name = "getBlockTime")] @@ -2415,7 +2416,7 @@ pub mod rpc_full { &self, meta: Self::Metadata, start_slot: Slot, - config: Option, + config: Option, commitment: Option, ) -> Result>; @@ -2433,7 +2434,7 @@ pub mod rpc_full { &self, meta: Self::Metadata, signature_str: String, - config: Option>, + config: Option>, ) -> Result>; #[rpc(meta, name = "getSignaturesForAddress")] @@ -2441,7 +2442,7 @@ pub mod rpc_full { &self, meta: Self::Metadata, address: String, - config: Option, + config: Option, ) -> Result>; #[rpc(meta, name = "getFirstAvailableBlock")] @@ -3006,7 +3007,7 @@ pub mod rpc_full { &self, meta: Self::Metadata, slot: Slot, - config: Option>, + config: Option>, ) -> Result> { debug!("get_block rpc request received: {:?}", slot); meta.get_block(slot, config) @@ -3016,7 +3017,7 @@ pub mod rpc_full { &self, meta: Self::Metadata, start_slot: Slot, - config: Option, + config: Option, commitment: Option, ) -> Result> { let (end_slot, maybe_commitment) = @@ -3054,7 +3055,7 @@ pub mod rpc_full { &self, meta: Self::Metadata, signature_str: String, - config: Option>, + config: Option>, ) -> Result> { debug!("get_transaction rpc request received: {:?}", signature_str); let signature = verify_signature(&signature_str)?; @@ -3065,7 +3066,7 @@ pub mod rpc_full { &self, meta: Self::Metadata, address: String, - config: Option, + config: Option, ) -> Result> { let address = verify_pubkey(address)?; @@ -3205,6 +3206,7 @@ pub mod rpc_full { // Deprecated RPC methods, collected for easy deactivation and removal in v1.8 pub mod rpc_deprecated_v1_7 { + #![allow(deprecated)] use super::*; #[rpc] pub trait DeprecatedV1_7 { @@ -3269,7 +3271,7 @@ pub mod rpc_deprecated_v1_7 { config: Option>, ) -> Result> { debug!("get_confirmed_block rpc request received: {:?}", slot); - meta.get_block(slot, config) + meta.get_block(slot, config.map(|config| config.convert())) } fn get_confirmed_blocks( @@ -3313,7 +3315,7 @@ pub mod rpc_deprecated_v1_7 { signature_str ); let signature = verify_signature(&signature_str)?; - meta.get_transaction(signature, config) + meta.get_transaction(signature, config.map(|config| config.convert())) } fn get_confirmed_signatures_for_address2( @@ -5593,7 +5595,7 @@ pub mod tests { let req = format!( r#"{{"jsonrpc":"2.0","id":1,"method":"getBlock","params":[0,{}]}}"#, - json!(RpcConfirmedBlockConfig { + json!(RpcBlockConfig { encoding: None, transaction_details: Some(TransactionDetails::Signatures), rewards: Some(false), @@ -5614,7 +5616,7 @@ pub mod tests { let req = format!( r#"{{"jsonrpc":"2.0","id":1,"method":"getBlock","params":[0,{}]}}"#, - json!(RpcConfirmedBlockConfig { + json!(RpcBlockConfig { encoding: None, transaction_details: Some(TransactionDetails::None), rewards: Some(true), diff --git a/ramp-tps/src/voters.rs b/ramp-tps/src/voters.rs index 32b453b598..5b8400da49 100644 --- a/ramp-tps/src/voters.rs +++ b/ramp-tps/src/voters.rs @@ -59,7 +59,7 @@ pub fn calculate_leader_records( let start_epoch = epoch_schedule.get_epoch(start_slot); let end_epoch = epoch_schedule.get_epoch(end_slot); let confirmed_blocks: HashSet<_> = rpc_client - .get_confirmed_blocks(start_slot, Some(end_slot))? + .get_blocks(start_slot, Some(end_slot))? .into_iter() .collect(); diff --git a/stake-monitor/src/lib.rs b/stake-monitor/src/lib.rs index 253b533a24..2b6f3fd558 100644 --- a/stake-monitor/src/lib.rs +++ b/stake-monitor/src/lib.rs @@ -290,12 +290,11 @@ fn load_blocks( start_slot, end_slot ); - let slots = rpc_client.get_confirmed_blocks(start_slot, Some(end_slot))?; + let slots = rpc_client.get_blocks(start_slot, Some(end_slot))?; let mut blocks = vec![]; for slot in slots.into_iter() { - let block = - rpc_client.get_confirmed_block_with_encoding(slot, UiTransactionEncoding::Base64)?; + let block = rpc_client.get_block_with_encoding(slot, UiTransactionEncoding::Base64)?; blocks.push((slot, block)); } Ok(blocks)