Add BigNumber Type and syscalls for BPF programs

accounts-bench/src/main.rs

@@ -6,7 +6,8 @@ use rayon::prelude::*;
 use solana_measure::measure::Measure;
 use solana_runtime::{
     accounts::{create_test_accounts, update_accounts_bench, Accounts},
-    accounts_index::{AccountSecondaryIndexes, Ancestors},
+    accounts_index::AccountSecondaryIndexes,
+    ancestors::Ancestors,
 };
 use solana_sdk::{genesis_config::ClusterType, pubkey::Pubkey};
 use std::{env, fs, path::PathBuf};

cli/Cargo.toml

@@ -38,7 +38,7 @@ solana-config-program = { path = "../programs/config", version = "=1.7.0" }
 solana-faucet = { path = "../faucet", version = "=1.7.0" }
 solana-logger = { path = "../logger", version = "=1.7.0" }
 solana-net-utils = { path = "../net-utils", version = "=1.7.0" }
-solana_rbpf = "=0.2.8"
+solana_rbpf = "=0.2.9"
 solana-remote-wallet = { path = "../remote-wallet", version = "=1.7.0" }
 solana-sdk = { path = "../sdk", version = "=1.7.0" }
 solana-stake-program = { path = "../programs/stake", version = "=1.7.0" }

core/src/cluster_info.rs

@@ -2564,7 +2564,7 @@ impl ClusterInfo {
         thread_pool: &ThreadPool,
         recycler: &PacketsRecycler,
         response_sender: &PacketSender,
-        stakes: HashMap<Pubkey, u64>,
+        stakes: &HashMap<Pubkey, u64>,
         feature_set: Option<&FeatureSet>,
         epoch_time_ms: u64,
         should_check_duplicate_instance: bool,
@@ -2637,13 +2637,13 @@ impl ClusterInfo {
         self.stats
             .packets_received_prune_messages_count
             .add_relaxed(prune_messages.len() as u64);
-        let require_stake_for_gossip = self.require_stake_for_gossip(feature_set, &stakes);
+        let require_stake_for_gossip = self.require_stake_for_gossip(feature_set, stakes);
         if require_stake_for_gossip {
             for (_, data) in &mut pull_responses {
-                retain_staked(data, &stakes);
+                retain_staked(data, stakes);
             }
             for (_, data) in &mut push_messages {
-                retain_staked(data, &stakes);
+                retain_staked(data, stakes);
             }
             pull_responses.retain(|(_, data)| !data.is_empty());
             push_messages.retain(|(_, data)| !data.is_empty());
@@ -2654,18 +2654,18 @@ impl ClusterInfo {
             push_messages,
             thread_pool,
             recycler,
-            &stakes,
+            stakes,
             response_sender,
             require_stake_for_gossip,
         );
-        self.handle_batch_pull_responses(pull_responses, thread_pool, &stakes, epoch_time_ms);
-        self.trim_crds_table(CRDS_UNIQUE_PUBKEY_CAPACITY, &stakes);
+        self.handle_batch_pull_responses(pull_responses, thread_pool, stakes, epoch_time_ms);
+        self.trim_crds_table(CRDS_UNIQUE_PUBKEY_CAPACITY, stakes);
         self.handle_batch_pong_messages(pong_messages, Instant::now());
         self.handle_batch_pull_requests(
             pull_requests,
             thread_pool,
             recycler,
-            &stakes,
+            stakes,
             response_sender,
             require_stake_for_gossip,
         );
@@ -2684,6 +2684,7 @@ impl ClusterInfo {
         should_check_duplicate_instance: bool,
     ) -> Result<()> {
         const RECV_TIMEOUT: Duration = Duration::from_secs(1);
+        const SUBMIT_GOSSIP_STATS_INTERVAL: Duration = Duration::from_secs(2);
         let packets: Vec<_> = requests_receiver.recv_timeout(RECV_TIMEOUT)?.packets.into();
         let mut packets = VecDeque::from(packets);
         while let Ok(packet) = requests_receiver.try_recv() {
@@ -2714,13 +2715,13 @@ impl ClusterInfo {
             thread_pool,
             recycler,
             response_sender,
-            stakes,
+            &stakes,
             feature_set.as_deref(),
             epoch_time_ms,
             should_check_duplicate_instance,
         )?;
-        if last_print.elapsed().as_millis() > 2000 {
-            submit_gossip_stats(&self.stats, &self.gossip);
+        if last_print.elapsed() > SUBMIT_GOSSIP_STATS_INTERVAL {
+            submit_gossip_stats(&self.stats, &self.gossip, &stakes);
             *last_print = Instant::now();
         }
         Ok(())

core/src/cluster_info_metrics.rs

@@ -1,6 +1,8 @@
 use crate::crds_gossip::CrdsGossip;
 use solana_measure::measure::Measure;
+use solana_sdk::pubkey::Pubkey;
 use std::{
+    collections::HashMap,
     sync::{
         atomic::{AtomicU64, Ordering},
         RwLock,
@@ -116,15 +118,21 @@ pub(crate) struct GossipStats {
     pub(crate) tvu_peers: Counter,
 }
 
-pub(crate) fn submit_gossip_stats(stats: &GossipStats, gossip: &RwLock<CrdsGossip>) {
-    let (table_size, purged_values_size, failed_inserts_size) = {
+pub(crate) fn submit_gossip_stats(
+    stats: &GossipStats,
+    gossip: &RwLock<CrdsGossip>,
+    stakes: &HashMap<Pubkey, u64>,
+) {
+    let (table_size, num_nodes, purged_values_size, failed_inserts_size) = {
         let gossip = gossip.read().unwrap();
         (
             gossip.crds.len(),
+            gossip.crds.num_nodes(),
             gossip.pull.purged_values.len(),
             gossip.pull.failed_inserts.len(),
         )
     };
+    let num_nodes_staked = stakes.values().filter(|stake| **stake > 0).count();
     datapoint_info!(
         "cluster_info_stats",
         ("entrypoint", stats.entrypoint.clear(), i64),
@@ -142,6 +150,8 @@ pub(crate) fn submit_gossip_stats(stats: &GossipStats, gossip: &RwLock<CrdsGossi
         ("table_size", table_size as i64, i64),
         ("purged_values_size", purged_values_size as i64, i64),
         ("failed_inserts_size", failed_inserts_size as i64, i64),
+        ("num_nodes", num_nodes as i64, i64),
+        ("num_nodes_staked", num_nodes_staked as i64, i64),
     );
     datapoint_info!(
         "cluster_info_stats2",

core/src/contact_info.rs

@@ -6,11 +6,10 @@ use solana_sdk::sanitize::{Sanitize, SanitizeError};
 #[cfg(test)]
 use solana_sdk::signature::{Keypair, Signer};
 use solana_sdk::timing::timestamp;
-use std::cmp::{Ord, Ordering, PartialEq, PartialOrd};
 use std::net::{IpAddr, SocketAddr};
 
 /// Structure representing a node on the network
-#[derive(Serialize, Deserialize, Clone, Debug, AbiExample)]
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, AbiExample, Deserialize, Serialize)]
 pub struct ContactInfo {
     pub id: Pubkey,
     /// gossip address
@@ -48,34 +47,13 @@ impl Sanitize for ContactInfo {
     }
 }
 
-impl Ord for ContactInfo {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.id.cmp(&other.id)
-    }
-}
-
-impl PartialOrd for ContactInfo {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl PartialEq for ContactInfo {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-    }
-}
-
-impl Eq for ContactInfo {}
-
 #[macro_export]
 macro_rules! socketaddr {
     ($ip:expr, $port:expr) => {
         std::net::SocketAddr::from((std::net::Ipv4Addr::from($ip), $port))
     };
     ($str:expr) => {{
-        let a: std::net::SocketAddr = $str.parse().unwrap();
-        a
+        $str.parse::<std::net::SocketAddr>().unwrap()
     }};
 }
 #[macro_export]

core/src/crds.rs

@@ -19,7 +19,7 @@
 //! CrdsValue enums.
 //!
 //! Merge strategy is implemented in:
-//!     impl PartialOrd for VersionedCrdsValue
+//!     fn overrides(value: &CrdsValue, other: &VersionedCrdsValue) -> bool
 //!
 //! A value is updated to a new version if the labels match, and the value
 //! wallclock is later, or the value hash is greater.
@@ -66,8 +66,6 @@ pub enum CrdsError {
 }
 
 /// This structure stores some local metadata associated with the CrdsValue
-/// The implementation of PartialOrd ensures that the "highest" version is always picked to be
-/// stored in the Crds
 #[derive(PartialEq, Debug, Clone)]
 pub struct VersionedCrdsValue {
     /// Ordinal index indicating insert order.

core/src/crds_gossip_push.rs

@@ -753,36 +753,32 @@ mod test {
     #[test]
     fn test_personalized_push_messages() {
         let now = timestamp();
+        let mut rng = rand::thread_rng();
         let mut crds = Crds::default();
         let mut push = CrdsGossipPush::default();
-        let peer_1 = CrdsValue::new_unsigned(CrdsData::ContactInfo(ContactInfo::new_localhost(
-            &solana_sdk::pubkey::new_rand(),
-            0,
-        )));
-        assert_eq!(crds.insert(peer_1.clone(), now), Ok(None));
-        let peer_2 = CrdsValue::new_unsigned(CrdsData::ContactInfo(ContactInfo::new_localhost(
-            &solana_sdk::pubkey::new_rand(),
-            0,
-        )));
-        assert_eq!(crds.insert(peer_2.clone(), now), Ok(None));
-        let peer_3 = CrdsValue::new_unsigned(CrdsData::ContactInfo(ContactInfo::new_localhost(
-            &solana_sdk::pubkey::new_rand(),
-            now,
-        )));
+        let peers: Vec<_> = vec![0, 0, now]
+            .into_iter()
+            .map(|wallclock| {
+                let mut peer = ContactInfo::new_rand(&mut rng, /*pubkey=*/ None);
+                peer.wallclock = wallclock;
+                CrdsValue::new_unsigned(CrdsData::ContactInfo(peer))
+            })
+            .collect();
+        assert_eq!(crds.insert(peers[0].clone(), now), Ok(None));
+        assert_eq!(crds.insert(peers[1].clone(), now), Ok(None));
         assert_eq!(
-            push.process_push_message(&mut crds, &Pubkey::default(), peer_3.clone(), now),
+            push.process_push_message(&mut crds, &Pubkey::default(), peers[2].clone(), now),
             Ok(None)
         );
         push.refresh_push_active_set(&crds, &HashMap::new(), None, &Pubkey::default(), 0, 1, 1);
 
         // push 3's contact info to 1 and 2 and 3
-        let new_msg = CrdsValue::new_unsigned(CrdsData::ContactInfo(ContactInfo::new_localhost(
-            &peer_3.pubkey(),
-            0,
-        )));
-        let mut expected = HashMap::new();
-        expected.insert(peer_1.pubkey(), vec![new_msg.clone()]);
-        expected.insert(peer_2.pubkey(), vec![new_msg]);
+        let expected: HashMap<_, _> = vec![
+            (peers[0].pubkey(), vec![peers[2].clone()]),
+            (peers[1].pubkey(), vec![peers[2].clone()]),
+        ]
+        .into_iter()
+        .collect();
         assert_eq!(push.active_set.len(), 3);
         assert_eq!(push.new_push_messages(&crds, now), expected);
     }

docs/src/cli/conventions.md

@@ -46,7 +46,7 @@ on your wallet type.
 #### Paper Wallet
 
 In a paper wallet, the keypair is securely derived from the seed words and
-optional passphrase you entered when the wallet was create. To use a paper
+optional passphrase you entered when the wallet was created. To use a paper
 wallet keypair anywhere the `<KEYPAIR>` text is shown in examples or help
 documents, enter the uri scheme `prompt://` and the program will prompt you to
 enter your seed words when you run the command.