Update accounts whitelist (#10100) (#10104)

automerge

.mergify.yml

@@ -21,6 +21,7 @@ pull_request_rules:
           - automerge
   - name: v1.0 backport
     conditions:
+      - base=master
       - label=v1.0
     actions:
       backport:
@@ -29,6 +30,7 @@ pull_request_rules:
           - v1.0
   - name: v1.1 backport
     conditions:
+      - base=master
       - label=v1.1
     actions:
       backport:
@@ -37,6 +39,7 @@ pull_request_rules:
           - v1.1
   - name: v1.2 backport
     conditions:
+      - base=master
       - label=v1.2
     actions:
       backport:

Cargo.toml

@@ -5,6 +5,9 @@ members = [
     "bench-tps",
     "accounts-bench",
     "banking-bench",
+    "chacha",
+    "chacha-cuda",
+    "chacha-sys",
     "cli-config",
     "client",
     "core",
@@ -24,12 +27,10 @@ members = [
     "logger",
     "log-analyzer",
     "merkle-tree",
-    "stake-o-matic",
     "streamer",
     "measure",
     "metrics",
     "net-shaper",
-    "notifier",
     "programs/bpf_loader",
     "programs/budget",
     "programs/btc_spv",
@@ -40,17 +41,20 @@ members = [
     "programs/noop",
     "programs/ownable",
     "programs/stake",
+    "programs/storage",
     "programs/vest",
     "programs/vote",
+    "archiver",
+    "archiver-lib",
+    "archiver-utils",
     "remote-wallet",
-    "ramp-tps",
     "runtime",
     "sdk",
+    "sdk-c",
     "scripts",
     "stake-accounts",
     "stake-monitor",
     "sys-tuner",
-    "tokens",
     "transaction-status",
     "upload-perf",
     "net-utils",

README.md

@@ -1,17 +1,23 @@
-<p align="center">
-  <a href="https://solana.com">
-    <img alt="Solana" src="https://i.imgur.com/OMnvVEz.png" width="250" />
-  </a>
-</p>
-
 [![Solana crate](https://img.shields.io/crates/v/solana-core.svg)](https://crates.io/crates/solana-core)
 [![Solana documentation](https://docs.rs/solana-core/badge.svg)](https://docs.rs/solana-core)
 [![Build status](https://badge.buildkite.com/8cc350de251d61483db98bdfc895b9ea0ac8ffa4a32ee850ed.svg?branch=master)](https://buildkite.com/solana-labs/solana/builds?branch=master)
 [![codecov](https://codecov.io/gh/solana-labs/solana/branch/master/graph/badge.svg)](https://codecov.io/gh/solana-labs/solana)
 
-# Building
+Blockchain Rebuilt for Scale
+===
 
-## **1. Install rustc, cargo and rustfmt.**
+Solana&trade; is a new blockchain architecture built from the ground up for scale. The architecture supports
+up to 710 thousand transactions per second on a gigabit network.
+
+Read all about it at [Solana: Blockchain Rebuilt for Scale](https://docs.solana.com/v/master).
+
+Developing
+===
+
+Building
+---
+
+Install rustc, cargo and rustfmt:
 
 ```bash
 $ curl https://sh.rustup.rs -sSf | sh
@@ -32,39 +38,112 @@ $ sudo apt-get update
 $ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang
 ```
 
-## **2. Download the source code.**
+Download the source code:
 
 ```bash
 $ git clone https://github.com/solana-labs/solana.git
 $ cd solana
 ```
 
-## **3. Build.**
+Build
 
 ```bash
 $ cargo build
 ```
 
-## **4. Run a minimal local cluster.**
+Then to run a minimal local cluster
 ```bash
 $ ./run.sh
 ```
 
-# Testing
+Testing
+---
 
-**Run the test suite:**
+Run the test suite:
 
 ```bash
 $ cargo test
 ```
 
-### Starting a local testnet
-Start your own testnet locally, instructions are in the [online docs](https://docs.solana.com/bench-tps).
+Local Testnet
+---
+
+Start your own testnet locally, instructions are in the online docs [Solana: Blockchain Rebuild for Scale: Getting Started](https://docs.solana.com/building-from-source).
+
+Remote Testnets
+---
 
-### Accessing the remote testnet
 * `testnet` - public stable testnet accessible via devnet.solana.com. Runs 24/7
 
-# Benchmarking
+
+## Deploy process
+
+They are deployed with the `ci/testnet-manager.sh` script through a list of [scheduled
+buildkite jobs](https://buildkite.com/solana-labs/testnet-management/settings/schedules).
+Each testnet can be manually manipulated from buildkite as well.
+
+## How do I reset the testnet?
+Manually trigger the [testnet-management](https://buildkite.com/solana-labs/testnet-management) pipeline
+and when prompted select the desired testnet
+
+## How can I scale the tx generation rate?
+
+Increase the TX rate by increasing the number of cores on the client machine which is running
+`bench-tps` or run multiple clients. Decrease by lowering cores or using the rayon env
+variable `RAYON_NUM_THREADS=<xx>`
+
+## How can I test a change on the testnet?
+
+Currently, a merged PR is the only way to test a change on the testnet.  But you
+can run your own testnet using the scripts in the `net/` directory.
+
+## Adjusting the number of clients or validators on the testnet
+Edit `ci/testnet-manager.sh`
+
+
+## Metrics Server Maintenance
+Sometimes the dashboard becomes unresponsive. This happens due to glitch in the metrics server.
+The current solution is to reset the metrics server. Use the following steps.
+
+1. The server is hosted in a GCP VM instance. Check if the VM instance is down by trying to SSH
+ into it from the GCP console. The name of the VM is ```metrics-solana-com```.
+2. If the VM is inaccessible, reset it from the GCP console.
+3. Once VM is up (or, was already up), the metrics services can be restarted from build automation.
+    1. Navigate to https://buildkite.com/solana-labs/metrics-dot-solana-dot-com in your web browser
+    2. Click on ```New Build```
+    3. This will show a pop up dialog. Click on ```options``` drop down.
+    4. Type in ```FORCE_START=true``` in ```Environment Variables``` text box.
+    5. Click ```Create Build```
+    6. This will restart the metrics services, and the dashboards should be accessible afterwards.
+
+## Debugging Testnet
+Testnet may exhibit different symptoms of failures. Primary statistics to check are
+1. Rise in Confirmation Time
+2. Nodes are not voting
+3. Panics, and OOM notifications
+
+Check the following if there are any signs of failure.
+1. Did testnet deployment fail?
+    1. View buildkite logs for the last deployment: https://buildkite.com/solana-labs/testnet-management
+    2. Use the relevant branch
+    3. If the deployment failed, look at the build logs. The build artifacts for each remote node is uploaded.
+       It's a good first step to triage from these logs.
+2. You may have to log into remote node if the deployment succeeded, but something failed during runtime.
+    1. Get the private key for the testnet deployment from ```metrics-solana-com``` GCP instance.
+    2. SSH into ```metrics-solana-com``` using GCP console and do the following.
+    ```bash
+    sudo bash
+    cd ~buildkite-agent/.ssh
+    ls
+    ```
+    3. Copy the relevant private key to your local machine
+    4. Find the public IP address of the AWS instance for the remote node using AWS console
+    5. ```ssh -i <private key file> ubuntu@<ip address of remote node>```
+    6. The logs are in ```~solana\solana``` folder
+
+
+Benchmarking
+---
 
 First install the nightly build of rustc. `cargo bench` requires use of the
 unstable features only available in the nightly build.
@@ -79,11 +158,13 @@ Run the benchmarks:
 $ cargo +nightly bench
 ```
 
-# Release Process
-
+Release Process
+---
 The release process for this project is described [here](RELEASE.md).
 
-# Code coverage
+
+Code coverage
+---
 
 To generate code coverage statistics:
 
@@ -92,6 +173,7 @@ $ scripts/coverage.sh
 $ open target/cov/lcov-local/index.html
 ```
 
+
 Why coverage? While most see coverage as a code quality metric, we see it primarily as a developer
 productivity metric. When a developer makes a change to the codebase, presumably it's a *solution* to
 some problem.  Our unit-test suite is how we encode the set of *problems* the codebase solves. Running
@@ -104,6 +186,7 @@ better way to solve the same problem, a Pull Request with your solution would mo
 welcome! Likewise, if rewriting a test can better communicate what code it's protecting, please
 send us that patch!
 
-# Disclaimer
+Disclaimer
+===
 
 All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.

accounts-bench/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-accounts-bench"
-version = "1.2.0"
+version = "1.1.13"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -10,12 +10,12 @@ homepage = "https://solana.com/"
 [dependencies]
 log = "0.4.6"
 rayon = "1.3.0"
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-measure = { path = "../measure", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-runtime = { path = "../runtime", version = "1.1.13" }
+solana-measure = { path = "../measure", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
 rand = "0.7.0"
-clap = "2.33.1"
+clap = "2.33.0"
 crossbeam-channel = "0.4"
 
 [package.metadata.docs.rs]

archiver-lib/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "solana-archiver-lib"
+version = "1.1.13"
+description = "Solana Archiver Library"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+bincode = "1.2.1"
+crossbeam-channel = "0.4"
+ed25519-dalek = "=1.0.0-pre.3"
+log = "0.4.8"
+rand = "0.7.0"
+rand_chacha = "0.2.2"
+solana-client = { path = "../client", version = "1.1.13" }
+solana-storage-program = { path = "../programs/storage", version = "1.1.13" }
+thiserror = "1.0"
+serde = "1.0.105"
+serde_json = "1.0.48"
+serde_derive = "1.0.103"
+solana-net-utils = { path = "../net-utils", version = "1.1.13" }
+solana-chacha = { path = "../chacha", version = "1.1.13" }
+solana-chacha-sys = { path = "../chacha-sys", version = "1.1.13" }
+solana-ledger = { path = "../ledger", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-perf = { path = "../perf", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+solana-core = { path = "../core", version = "1.1.13" }
+solana-streamer = { path = "../streamer", version = "1.1.13" }
+solana-archiver-utils = { path = "../archiver-utils", version = "1.1.13" }
+solana-metrics = { path = "../metrics", version = "1.1.13" }
+
+[dev-dependencies]
+hex = "0.4.2"
+
+[lib]
+name = "solana_archiver_lib"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

archiver-lib/src/archiver.rs

@@ -0,0 +1,921 @@
+use crate::result::ArchiverError;
+use crossbeam_channel::unbounded;
+use rand::{thread_rng, Rng};
+use rand_chacha::{rand_core::SeedableRng, ChaChaRng};
+use solana_archiver_utils::sample_file;
+use solana_chacha::chacha::{chacha_cbc_encrypt_ledger, CHACHA_BLOCK_SIZE};
+use solana_client::{
+    rpc_client::RpcClient, rpc_request::RpcRequest, rpc_response::RpcStorageTurn,
+    thin_client::ThinClient,
+};
+use solana_core::{
+    cluster_info::{ClusterInfo, Node, VALIDATOR_PORT_RANGE},
+    cluster_slots::ClusterSlots,
+    contact_info::ContactInfo,
+    gossip_service::GossipService,
+    repair_service::{self, RepairService, RepairSlotRange, RepairStats, RepairStrategy},
+    serve_repair::ServeRepair,
+    shred_fetch_stage::ShredFetchStage,
+    sigverify_stage::{DisabledSigVerifier, SigVerifyStage},
+    storage_stage::NUM_STORAGE_SAMPLES,
+    window_service::WindowService,
+};
+use solana_ledger::{
+    blockstore::Blockstore, leader_schedule_cache::LeaderScheduleCache, shred::Shred,
+};
+use solana_net_utils::bind_in_range;
+use solana_perf::packet::Packets;
+use solana_perf::packet::{limited_deserialize, PACKET_DATA_SIZE};
+use solana_perf::recycler::Recycler;
+use solana_sdk::packet::Packet;
+use solana_sdk::{
+    account_utils::StateMut,
+    client::{AsyncClient, SyncClient},
+    clock::{get_complete_segment_from_slot, get_segment_from_slot, Slot},
+    commitment_config::CommitmentConfig,
+    hash::Hash,
+    message::Message,
+    signature::{Keypair, Signature, Signer},
+    timing::timestamp,
+    transaction::Transaction,
+    transport::TransportError,
+};
+use solana_storage_program::{
+    storage_contract::StorageContract,
+    storage_instruction::{self, StorageAccountType},
+};
+use solana_streamer::streamer::{receiver, responder, PacketReceiver};
+use std::{
+    io::{self, ErrorKind},
+    net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
+    path::{Path, PathBuf},
+    result,
+    sync::atomic::{AtomicBool, Ordering},
+    sync::mpsc::{channel, Receiver, Sender},
+    sync::Arc,
+    thread::{sleep, spawn, JoinHandle},
+    time::Duration,
+};
+
+type Result<T> = std::result::Result<T, ArchiverError>;
+
+static ENCRYPTED_FILENAME: &str = "ledger.enc";
+
+#[derive(Serialize, Deserialize)]
+pub enum ArchiverRequest {
+    GetSlotHeight(SocketAddr),
+}
+
+pub struct Archiver {
+    thread_handles: Vec<JoinHandle<()>>,
+    exit: Arc<AtomicBool>,
+}
+
+// Shared Archiver Meta struct used internally
+#[derive(Default)]
+struct ArchiverMeta {
+    slot: Slot,
+    slots_per_segment: u64,
+    ledger_path: PathBuf,
+    signature: Signature,
+    ledger_data_file_encrypted: PathBuf,
+    sampling_offsets: Vec<u64>,
+    blockhash: Hash,
+    sha_state: Hash,
+    num_chacha_blocks: usize,
+    client_commitment: CommitmentConfig,
+}
+
+fn get_slot_from_signature(
+    signature: &Signature,
+    storage_turn: u64,
+    slots_per_segment: u64,
+) -> u64 {
+    let signature_vec = signature.as_ref();
+    let mut segment_index = u64::from(signature_vec[0])
+        | (u64::from(signature_vec[1]) << 8)
+        | (u64::from(signature_vec[1]) << 16)
+        | (u64::from(signature_vec[2]) << 24);
+    let max_segment_index =
+        get_complete_segment_from_slot(storage_turn, slots_per_segment).unwrap();
+    segment_index %= max_segment_index as u64;
+    segment_index * slots_per_segment
+}
+
+fn create_request_processor(
+    socket: UdpSocket,
+    exit: &Arc<AtomicBool>,
+    slot_receiver: Receiver<u64>,
+) -> Vec<JoinHandle<()>> {
+    let mut thread_handles = vec![];
+    let (s_reader, r_reader) = channel();
+    let (s_responder, r_responder) = channel();
+    let storage_socket = Arc::new(socket);
+    let recycler = Recycler::default();
+    let t_receiver = receiver(storage_socket.clone(), exit, s_reader, recycler, "archiver");
+    thread_handles.push(t_receiver);
+
+    let t_responder = responder("archiver-responder", storage_socket, r_responder);
+    thread_handles.push(t_responder);
+
+    let exit = exit.clone();
+    let t_processor = spawn(move || {
+        let slot = poll_for_slot(slot_receiver, &exit);
+
+        loop {
+            if exit.load(Ordering::Relaxed) {
+                break;
+            }
+
+            let packets = r_reader.recv_timeout(Duration::from_secs(1));
+
+            if let Ok(packets) = packets {
+                for packet in &packets.packets {
+                    let req: result::Result<ArchiverRequest, Box<bincode::ErrorKind>> =
+                        limited_deserialize(&packet.data[..packet.meta.size]);
+                    match req {
+                        Ok(ArchiverRequest::GetSlotHeight(from)) => {
+                            let packet = Packet::from_data(&from, slot);
+                            let _ = s_responder.send(Packets::new(vec![packet]));
+                        }
+                        Err(e) => {
+                            info!("invalid request: {:?}", e);
+                        }
+                    }
+                }
+            }
+        }
+    });
+    thread_handles.push(t_processor);
+    thread_handles
+}
+
+fn poll_for_slot(receiver: Receiver<u64>, exit: &Arc<AtomicBool>) -> u64 {
+    loop {
+        let slot = receiver.recv_timeout(Duration::from_secs(1));
+        if let Ok(slot) = slot {
+            return slot;
+        }
+        if exit.load(Ordering::Relaxed) {
+            return 0;
+        }
+    }
+}
+
+impl Archiver {
+    /// Returns a Result that contains an archiver on success
+    ///
+    /// # Arguments
+    /// * `ledger_path` - path to where the ledger will be stored.
+    /// Causes panic if none
+    /// * `node` - The archiver node
+    /// * `cluster_entrypoint` - ContactInfo representing an entry into the network
+    /// * `keypair` - Keypair for this archiver
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new(
+        ledger_path: &Path,
+        node: Node,
+        cluster_entrypoint: ContactInfo,
+        keypair: Arc<Keypair>,
+        storage_keypair: Arc<Keypair>,
+        client_commitment: CommitmentConfig,
+    ) -> Result<Self> {
+        let exit = Arc::new(AtomicBool::new(false));
+
+        info!("Archiver: id: {}", keypair.pubkey());
+        info!("Creating cluster info....");
+        let cluster_info = ClusterInfo::new(node.info.clone(), keypair.clone());
+        cluster_info.set_entrypoint(cluster_entrypoint.clone());
+        let cluster_info = Arc::new(cluster_info);
+        let cluster_slots = Arc::new(ClusterSlots::default());
+        // Note for now, this ledger will not contain any of the existing entries
+        // in the ledger located at ledger_path, and will only append on newly received
+        // entries after being passed to window_service
+        let blockstore = Arc::new(
+            Blockstore::open(ledger_path).expect("Expected to be able to open database ledger"),
+        );
+
+        let gossip_service = GossipService::new(&cluster_info, None, node.sockets.gossip, &exit);
+
+        info!("Connecting to the cluster via {:?}", cluster_entrypoint);
+        let (nodes, _) =
+            match solana_core::gossip_service::discover_cluster(&cluster_entrypoint.gossip, 2) {
+                Ok(nodes_and_archivers) => nodes_and_archivers,
+                Err(e) => {
+                    //shutdown services before exiting
+                    exit.store(true, Ordering::Relaxed);
+                    gossip_service.join()?;
+                    return Err(e.into());
+                }
+            };
+        let client = solana_core::gossip_service::get_client(&nodes);
+
+        info!("Setting up mining account...");
+        if let Err(e) =
+            Self::setup_mining_account(&client, &keypair, &storage_keypair, client_commitment)
+        {
+            //shutdown services before exiting
+            exit.store(true, Ordering::Relaxed);
+            gossip_service.join()?;
+            return Err(e);
+        };
+
+        let repair_socket = Arc::new(node.sockets.repair);
+        let shred_sockets: Vec<Arc<UdpSocket>> =
+            node.sockets.tvu.into_iter().map(Arc::new).collect();
+        let shred_forward_sockets: Vec<Arc<UdpSocket>> = node
+            .sockets
+            .tvu_forwards
+            .into_iter()
+            .map(Arc::new)
+            .collect();
+        let (shred_fetch_sender, shred_fetch_receiver) = channel();
+        let fetch_stage = ShredFetchStage::new(
+            shred_sockets,
+            shred_forward_sockets,
+            repair_socket.clone(),
+            &shred_fetch_sender,
+            None,
+            &exit,
+        );
+        let (slot_sender, slot_receiver) = channel();
+        let request_processor =
+            create_request_processor(node.sockets.storage.unwrap(), &exit, slot_receiver);
+
+        let t_archiver = {
+            let exit = exit.clone();
+            let node_info = node.info.clone();
+            let mut meta = ArchiverMeta {
+                ledger_path: ledger_path.to_path_buf(),
+                client_commitment,
+                ..ArchiverMeta::default()
+            };
+            spawn(move || {
+                // setup archiver
+                let window_service = match Self::setup(
+                    &mut meta,
+                    cluster_info.clone(),
+                    &blockstore,
+                    &exit,
+                    &node_info,
+                    &storage_keypair,
+                    repair_socket,
+                    shred_fetch_receiver,
+                    slot_sender,
+                    cluster_slots,
+                ) {
+                    Ok(window_service) => window_service,
+                    Err(e) => {
+                        //shutdown services before exiting
+                        error!("setup failed {:?}; archiver thread exiting...", e);
+                        exit.store(true, Ordering::Relaxed);
+                        request_processor
+                            .into_iter()
+                            .for_each(|t| t.join().unwrap());
+                        fetch_stage.join().unwrap();
+                        gossip_service.join().unwrap();
+                        return;
+                    }
+                };
+
+                info!("setup complete");
+                // run archiver
+                Self::run(
+                    &mut meta,
+                    &blockstore,
+                    cluster_info,
+                    &keypair,
+                    &storage_keypair,
+                    &exit,
+                );
+                // wait until exit
+                request_processor
+                    .into_iter()
+                    .for_each(|t| t.join().unwrap());
+                fetch_stage.join().unwrap();
+                gossip_service.join().unwrap();
+                window_service.join().unwrap()
+            })
+        };
+
+        Ok(Self {
+            thread_handles: vec![t_archiver],
+            exit,
+        })
+    }
+
+    fn run(
+        meta: &mut ArchiverMeta,
+        blockstore: &Arc<Blockstore>,
+        cluster_info: Arc<ClusterInfo>,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+        exit: &Arc<AtomicBool>,
+    ) {
+        // encrypt segment
+        Self::encrypt_ledger(meta, blockstore).expect("ledger encrypt not successful");
+        let enc_file_path = meta.ledger_data_file_encrypted.clone();
+        // do replicate
+        loop {
+            if exit.load(Ordering::Relaxed) {
+                break;
+            }
+
+            // TODO check if more segments are available - based on space constraints
+            Self::create_sampling_offsets(meta);
+            let sampling_offsets = &meta.sampling_offsets;
+            meta.sha_state =
+                match Self::sample_file_to_create_mining_hash(&enc_file_path, sampling_offsets) {
+                    Ok(hash) => hash,
+                    Err(err) => {
+                        warn!("Error sampling file, exiting: {:?}", err);
+                        break;
+                    }
+                };
+
+            Self::submit_mining_proof(meta, &cluster_info, archiver_keypair, storage_keypair);
+
+            // TODO make this a lot more frequent by picking a "new" blockhash instead of picking a storage blockhash
+            // prep the next proof
+            let (storage_blockhash, _) = match Self::poll_for_blockhash_and_slot(
+                &cluster_info,
+                meta.slots_per_segment,
+                &meta.blockhash,
+                exit,
+            ) {
+                Ok(blockhash_and_slot) => blockhash_and_slot,
+                Err(e) => {
+                    warn!(
+                        "Error couldn't get a newer blockhash than {:?}. {:?}",
+                        meta.blockhash, e
+                    );
+                    break;
+                }
+            };
+            meta.blockhash = storage_blockhash;
+            Self::redeem_rewards(
+                &cluster_info,
+                archiver_keypair,
+                storage_keypair,
+                meta.client_commitment,
+            );
+        }
+        exit.store(true, Ordering::Relaxed);
+    }
+
+    fn redeem_rewards(
+        cluster_info: &ClusterInfo,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+        client_commitment: CommitmentConfig,
+    ) {
+        let nodes = cluster_info.tvu_peers();
+        let client = solana_core::gossip_service::get_client(&nodes);
+
+        if let Ok(Some(account)) =
+            client.get_account_with_commitment(&storage_keypair.pubkey(), client_commitment)
+        {
+            if let Ok(StorageContract::ArchiverStorage { validations, .. }) = account.state() {
+                if !validations.is_empty() {
+                    let ix = storage_instruction::claim_reward(
+                        &archiver_keypair.pubkey(),
+                        &storage_keypair.pubkey(),
+                    );
+                    let message = Message::new_with_payer(&[ix], Some(&archiver_keypair.pubkey()));
+                    if let Err(e) = client.send_message(&[archiver_keypair.as_ref()], message) {
+                        error!("unable to redeem reward, tx failed: {:?}", e);
+                    } else {
+                        info!(
+                            "collected mining rewards: Account balance {:?}",
+                            client.get_balance_with_commitment(
+                                &archiver_keypair.pubkey(),
+                                client_commitment
+                            )
+                        );
+                    }
+                }
+            }
+        } else {
+            info!("Redeem mining reward: No account data found");
+        }
+    }
+
+    // Find a segment to replicate and download it.
+    #[allow(clippy::too_many_arguments)]
+    fn setup(
+        meta: &mut ArchiverMeta,
+        cluster_info: Arc<ClusterInfo>,
+        blockstore: &Arc<Blockstore>,
+        exit: &Arc<AtomicBool>,
+        node_info: &ContactInfo,
+        storage_keypair: &Arc<Keypair>,
+        repair_socket: Arc<UdpSocket>,
+        shred_fetch_receiver: PacketReceiver,
+        slot_sender: Sender<u64>,
+        cluster_slots: Arc<ClusterSlots>,
+    ) -> Result<WindowService> {
+        let slots_per_segment =
+            match Self::get_segment_config(&cluster_info, meta.client_commitment) {
+                Ok(slots_per_segment) => slots_per_segment,
+                Err(e) => {
+                    error!("unable to get segment size configuration, exiting...");
+                    //shutdown services before exiting
+                    exit.store(true, Ordering::Relaxed);
+                    return Err(e);
+                }
+            };
+        let (segment_blockhash, segment_slot) = match Self::poll_for_segment(
+            &cluster_info,
+            slots_per_segment,
+            &Hash::default(),
+            exit,
+        ) {
+            Ok(blockhash_and_slot) => blockhash_and_slot,
+            Err(e) => {
+                //shutdown services before exiting
+                exit.store(true, Ordering::Relaxed);
+                return Err(e);
+            }
+        };
+        let signature = storage_keypair.sign_message(segment_blockhash.as_ref());
+        let slot = get_slot_from_signature(&signature, segment_slot, slots_per_segment);
+        info!("replicating slot: {}", slot);
+        slot_sender.send(slot)?;
+        meta.slot = slot;
+        meta.slots_per_segment = slots_per_segment;
+        meta.signature = signature;
+        meta.blockhash = segment_blockhash;
+
+        let mut repair_slot_range = RepairSlotRange::default();
+        repair_slot_range.end = slot + slots_per_segment;
+        repair_slot_range.start = slot;
+
+        let (retransmit_sender, _) = channel();
+
+        let (verified_sender, verified_receiver) = unbounded();
+
+        let _sigverify_stage = SigVerifyStage::new(
+            shred_fetch_receiver,
+            verified_sender,
+            DisabledSigVerifier::default(),
+        );
+
+        let window_service = WindowService::new(
+            blockstore.clone(),
+            cluster_info.clone(),
+            verified_receiver,
+            retransmit_sender,
+            repair_socket,
+            &exit,
+            RepairStrategy::RepairRange(repair_slot_range),
+            &Arc::new(LeaderScheduleCache::default()),
+            |_, _, _, _| true,
+            cluster_slots,
+        );
+        info!("waiting for ledger download");
+        Self::wait_for_segment_download(
+            slot,
+            slots_per_segment,
+            &blockstore,
+            &exit,
+            &node_info,
+            cluster_info,
+        );
+        Ok(window_service)
+    }
+
+    fn wait_for_segment_download(
+        start_slot: Slot,
+        slots_per_segment: u64,
+        blockstore: &Arc<Blockstore>,
+        exit: &Arc<AtomicBool>,
+        node_info: &ContactInfo,
+        cluster_info: Arc<ClusterInfo>,
+    ) {
+        info!(
+            "window created, waiting for ledger download starting at slot {:?}",
+            start_slot
+        );
+        let mut current_slot = start_slot;
+        'outer: loop {
+            while blockstore.is_full(current_slot) {
+                current_slot += 1;
+                info!("current slot: {}", current_slot);
+                if current_slot >= start_slot + slots_per_segment {
+                    break 'outer;
+                }
+            }
+            if exit.load(Ordering::Relaxed) {
+                break;
+            }
+            sleep(Duration::from_secs(1));
+        }
+
+        info!("Done receiving entries from window_service");
+
+        // Remove archiver from the data plane
+        let mut contact_info = node_info.clone();
+        contact_info.tvu = "0.0.0.0:0".parse().unwrap();
+        contact_info.wallclock = timestamp();
+        // copy over the adopted shred_version from the entrypoint
+        contact_info.shred_version = cluster_info.my_shred_version();
+        cluster_info.update_contact_info(|current| *current = contact_info);
+    }
+
+    fn encrypt_ledger(meta: &mut ArchiverMeta, blockstore: &Arc<Blockstore>) -> Result<()> {
+        meta.ledger_data_file_encrypted = meta.ledger_path.join(ENCRYPTED_FILENAME);
+
+        {
+            let mut ivec = [0u8; 64];
+            ivec.copy_from_slice(&meta.signature.as_ref());
+
+            let num_encrypted_bytes = chacha_cbc_encrypt_ledger(
+                blockstore,
+                meta.slot,
+                meta.slots_per_segment,
+                &meta.ledger_data_file_encrypted,
+                &mut ivec,
+            )?;
+
+            meta.num_chacha_blocks = num_encrypted_bytes / CHACHA_BLOCK_SIZE;
+        }
+
+        info!(
+            "Done encrypting the ledger: {:?}",
+            meta.ledger_data_file_encrypted
+        );
+        Ok(())
+    }
+
+    fn create_sampling_offsets(meta: &mut ArchiverMeta) {
+        meta.sampling_offsets.clear();
+        let mut rng_seed = [0u8; 32];
+        rng_seed.copy_from_slice(&meta.blockhash.as_ref());
+        let mut rng = ChaChaRng::from_seed(rng_seed);
+        for _ in 0..NUM_STORAGE_SAMPLES {
+            meta.sampling_offsets
+                .push(rng.gen_range(0, meta.num_chacha_blocks) as u64);
+        }
+    }
+
+    fn sample_file_to_create_mining_hash(
+        enc_file_path: &Path,
+        sampling_offsets: &[u64],
+    ) -> Result<Hash> {
+        let sha_state = sample_file(enc_file_path, sampling_offsets)?;
+        info!("sampled sha_state: {}", sha_state);
+        Ok(sha_state)
+    }
+
+    fn setup_mining_account(
+        client: &ThinClient,
+        keypair: &Keypair,
+        storage_keypair: &Keypair,
+        client_commitment: CommitmentConfig,
+    ) -> Result<()> {
+        // make sure archiver has some balance
+        info!("checking archiver keypair...");
+        if client.poll_balance_with_timeout_and_commitment(
+            &keypair.pubkey(),
+            &Duration::from_millis(100),
+            &Duration::from_secs(5),
+            client_commitment,
+        )? == 0
+        {
+            return Err(ArchiverError::EmptyStorageAccountBalance);
+        }
+
+        info!("checking storage account keypair...");
+        // check if the storage account exists
+        let balance =
+            client.poll_get_balance_with_commitment(&storage_keypair.pubkey(), client_commitment);
+        if balance.is_err() || balance.unwrap() == 0 {
+            let blockhash = match client.get_recent_blockhash_with_commitment(client_commitment) {
+                Ok((blockhash, _)) => blockhash,
+                Err(e) => {
+                    return Err(ArchiverError::TransportError(e));
+                }
+            };
+
+            let ix = storage_instruction::create_storage_account(
+                &keypair.pubkey(),
+                &keypair.pubkey(),
+                &storage_keypair.pubkey(),
+                1,
+                StorageAccountType::Archiver,
+            );
+            let tx = Transaction::new_signed_instructions(&[keypair], ix, blockhash);
+            let signature = client.async_send_transaction(tx)?;
+            client
+                .poll_for_signature_with_commitment(&signature, client_commitment)
+                .map_err(|err| match err {
+                    TransportError::IoError(e) => e,
+                    TransportError::TransactionError(_) => io::Error::new(
+                        ErrorKind::Other,
+                        "setup_mining_account: signature not found",
+                    ),
+                    TransportError::Custom(e) => io::Error::new(ErrorKind::Other, e),
+                })?;
+        }
+        Ok(())
+    }
+
+    fn submit_mining_proof(
+        meta: &ArchiverMeta,
+        cluster_info: &ClusterInfo,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+    ) {
+        // No point if we've got no storage account...
+        let nodes = cluster_info.tvu_peers();
+        let client = solana_core::gossip_service::get_client(&nodes);
+        let storage_balance = client
+            .poll_get_balance_with_commitment(&storage_keypair.pubkey(), meta.client_commitment);
+        if storage_balance.is_err() || storage_balance.unwrap() == 0 {
+            error!("Unable to submit mining proof, no storage account");
+            return;
+        }
+        // ...or no lamports for fees
+        let balance = client
+            .poll_get_balance_with_commitment(&archiver_keypair.pubkey(), meta.client_commitment);
+        if balance.is_err() || balance.unwrap() == 0 {
+            error!("Unable to submit mining proof, insufficient Archiver Account balance");
+            return;
+        }
+
+        let blockhash = match client.get_recent_blockhash_with_commitment(meta.client_commitment) {
+            Ok((blockhash, _)) => blockhash,
+            Err(_) => {
+                error!("unable to get recent blockhash, can't submit proof");
+                return;
+            }
+        };
+        let instruction = storage_instruction::mining_proof(
+            &storage_keypair.pubkey(),
+            meta.sha_state,
+            get_segment_from_slot(meta.slot, meta.slots_per_segment),
+            Signature::new(&meta.signature.as_ref()),
+            meta.blockhash,
+        );
+        let message = Message::new_with_payer(&[instruction], Some(&archiver_keypair.pubkey()));
+        let mut transaction = Transaction::new(
+            &[archiver_keypair.as_ref(), storage_keypair.as_ref()],
+            message,
+            blockhash,
+        );
+        if let Err(err) = client.send_and_confirm_transaction(
+            &[archiver_keypair.as_ref(), storage_keypair.as_ref()],
+            &mut transaction,
+            10,
+            0,
+        ) {
+            error!("Error: {:?}; while sending mining proof", err);
+        }
+    }
+
+    pub fn close(self) {
+        self.exit.store(true, Ordering::Relaxed);
+        self.join()
+    }
+
+    pub fn join(self) {
+        for handle in self.thread_handles {
+            handle.join().unwrap();
+        }
+    }
+
+    fn get_segment_config(
+        cluster_info: &ClusterInfo,
+        client_commitment: CommitmentConfig,
+    ) -> Result<u64> {
+        let rpc_peers = cluster_info.all_rpc_peers();
+        debug!("rpc peers: {:?}", rpc_peers);
+        if !rpc_peers.is_empty() {
+            let rpc_client = {
+                let node_index = thread_rng().gen_range(0, rpc_peers.len());
+                RpcClient::new_socket(rpc_peers[node_index].rpc)
+            };
+            Ok(rpc_client
+                .send::<u64>(
+                    RpcRequest::GetSlotsPerSegment,
+                    serde_json::json!([client_commitment]),
+                    0,
+                )
+                .unwrap())
+        } else {
+            Err(ArchiverError::NoRpcPeers)
+        }
+    }
+
+    /// Waits until the first segment is ready, and returns the current segment
+    fn poll_for_segment(
+        cluster_info: &ClusterInfo,
+        slots_per_segment: u64,
+        previous_blockhash: &Hash,
+        exit: &Arc<AtomicBool>,
+    ) -> Result<(Hash, u64)> {
+        loop {
+            let (blockhash, turn_slot) = Self::poll_for_blockhash_and_slot(
+                cluster_info,
+                slots_per_segment,
+                previous_blockhash,
+                exit,
+            )?;
+            if get_complete_segment_from_slot(turn_slot, slots_per_segment).is_some() {
+                return Ok((blockhash, turn_slot));
+            }
+        }
+    }
+
+    /// Poll for a different blockhash and associated max_slot than `previous_blockhash`
+    fn poll_for_blockhash_and_slot(
+        cluster_info: &ClusterInfo,
+        slots_per_segment: u64,
+        previous_blockhash: &Hash,
+        exit: &Arc<AtomicBool>,
+    ) -> Result<(Hash, u64)> {
+        info!("waiting for the next turn...");
+        loop {
+            let rpc_peers = cluster_info.all_rpc_peers();
+            debug!("rpc peers: {:?}", rpc_peers);
+            if !rpc_peers.is_empty() {
+                let rpc_client = {
+                    let node_index = thread_rng().gen_range(0, rpc_peers.len());
+                    RpcClient::new_socket(rpc_peers[node_index].rpc)
+                };
+                let RpcStorageTurn {
+                    blockhash: storage_blockhash,
+                    slot: turn_slot,
+                } = rpc_client.send(
+                    RpcRequest::GetStorageTurn,
+                    serde_json::value::Value::Null,
+                    0,
+                )?;
+                let turn_blockhash = storage_blockhash.parse().map_err(|err| {
+                    io::Error::new(
+                        io::ErrorKind::Other,
+                        format!(
+                            "Blockhash parse failure: {:?} on {:?}",
+                            err, storage_blockhash
+                        ),
+                    )
+                })?;
+                if turn_blockhash != *previous_blockhash {
+                    info!("turn slot: {}", turn_slot);
+                    if get_segment_from_slot(turn_slot, slots_per_segment) != 0 {
+                        return Ok((turn_blockhash, turn_slot));
+                    }
+                }
+            }
+            if exit.load(Ordering::Relaxed) {
+                return Err(ArchiverError::IO(io::Error::new(
+                    ErrorKind::Other,
+                    "exit signalled...",
+                )));
+            }
+            sleep(Duration::from_secs(5));
+        }
+    }
+
+    /// Ask an archiver to populate a given blockstore with its segment.
+    /// Return the slot at the start of the archiver's segment
+    ///
+    /// It is recommended to use a temporary blockstore for this since the download will not verify
+    /// shreds received and might impact the chaining of shreds across slots
+    pub fn download_from_archiver(
+        serve_repair: &ServeRepair,
+        archiver_info: &ContactInfo,
+        blockstore: &Arc<Blockstore>,
+        slots_per_segment: u64,
+    ) -> Result<u64> {
+        let ip_addr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
+        // Create a client which downloads from the archiver and see that it
+        // can respond with shreds.
+        let start_slot = Self::get_archiver_segment_slot(ip_addr, archiver_info.storage_addr);
+        info!("Archiver download: start at {}", start_slot);
+
+        let exit = Arc::new(AtomicBool::new(false));
+        let (s_reader, r_reader) = channel();
+        let repair_socket = Arc::new(bind_in_range(ip_addr, VALIDATOR_PORT_RANGE).unwrap().1);
+        let t_receiver = receiver(
+            repair_socket.clone(),
+            &exit,
+            s_reader,
+            Recycler::default(),
+            "archiver_reeciver",
+        );
+        let id = serve_repair.keypair().pubkey();
+        info!(
+            "Sending repair requests from: {} to: {}",
+            serve_repair.my_info().id,
+            archiver_info.gossip
+        );
+        let repair_slot_range = RepairSlotRange {
+            start: start_slot,
+            end: start_slot + slots_per_segment,
+        };
+        // try for upto 180 seconds //TODO needs tuning if segments are huge
+        for _ in 0..120 {
+            // Strategy used by archivers
+            let repairs = RepairService::generate_repairs_in_range(
+                blockstore,
+                repair_service::MAX_REPAIR_LENGTH,
+                &repair_slot_range,
+            );
+            let mut repair_stats = RepairStats::default();
+            //iter over the repairs and send them
+            if let Ok(repairs) = repairs {
+                let reqs: Vec<_> = repairs
+                    .into_iter()
+                    .filter_map(|repair_request| {
+                        serve_repair
+                            .map_repair_request(&repair_request, &mut repair_stats, Some(0))
+                            .map(|result| ((archiver_info.gossip, result), repair_request))
+                            .ok()
+                    })
+                    .collect();
+
+                for ((to, req), repair_request) in reqs {
+                    if let Ok(local_addr) = repair_socket.local_addr() {
+                        datapoint_info!(
+                            "archiver_download",
+                            ("repair_request", format!("{:?}", repair_request), String),
+                            ("to", to.to_string(), String),
+                            ("from", local_addr.to_string(), String),
+                            ("id", id.to_string(), String)
+                        );
+                    }
+                    repair_socket
+                        .send_to(&req, archiver_info.gossip)
+                        .unwrap_or_else(|e| {
+                            error!("{} repair req send_to({}) error {:?}", id, to, e);
+                            0
+                        });
+                }
+            }
+            let res = r_reader.recv_timeout(Duration::new(1, 0));
+            if let Ok(mut packets) = res {
+                while let Ok(mut more) = r_reader.try_recv() {
+                    packets.packets.append_pinned(&mut more.packets);
+                }
+                let shreds: Vec<Shred> = packets
+                    .packets
+                    .into_iter()
+                    .filter_map(|p| Shred::new_from_serialized_shred(p.data.to_vec()).ok())
+                    .collect();
+                blockstore.insert_shreds(shreds, None, false)?;
+            }
+            // check if all the slots in the segment are complete
+            if Self::segment_complete(start_slot, slots_per_segment, blockstore) {
+                break;
+            }
+            sleep(Duration::from_millis(500));
+        }
+        exit.store(true, Ordering::Relaxed);
+        t_receiver.join().unwrap();
+
+        // check if all the slots in the segment are complete
+        if !Self::segment_complete(start_slot, slots_per_segment, blockstore) {
+            return Err(ArchiverError::SegmentDownloadError);
+        }
+        Ok(start_slot)
+    }
+
+    fn segment_complete(
+        start_slot: Slot,
+        slots_per_segment: u64,
+        blockstore: &Arc<Blockstore>,
+    ) -> bool {
+        for slot in start_slot..(start_slot + slots_per_segment) {
+            if !blockstore.is_full(slot) {
+                return false;
+            }
+        }
+        true
+    }
+
+    fn get_archiver_segment_slot(bind_ip_addr: IpAddr, to: SocketAddr) -> u64 {
+        let (_port, socket) = bind_in_range(bind_ip_addr, VALIDATOR_PORT_RANGE).unwrap();
+        socket
+            .set_read_timeout(Some(Duration::from_secs(5)))
+            .unwrap();
+
+        let req = ArchiverRequest::GetSlotHeight(socket.local_addr().unwrap());
+        let serialized_req = bincode::serialize(&req).unwrap();
+        for _ in 0..10 {
+            socket.send_to(&serialized_req, to).unwrap();
+            let mut buf = [0; 1024];
+            if let Ok((size, _addr)) = socket.recv_from(&mut buf) {
+                // Ignore bad packet and try again
+                if let Ok(slot) = bincode::config()
+                    .limit(PACKET_DATA_SIZE as u64)
+                    .deserialize(&buf[..size])
+                {
+                    return slot;
+                }
+            }
+            sleep(Duration::from_millis(500));
+        }
+        panic!("Couldn't get segment slot from archiver!");
+    }
+}

archiver-lib/src/lib.rs

@@ -0,0 +1,11 @@
+#[macro_use]
+extern crate log;
+
+#[macro_use]
+extern crate serde_derive;
+
+#[macro_use]
+extern crate solana_metrics;
+
+pub mod archiver;
+mod result;

archiver-lib/src/result.rs

@@ -0,0 +1,47 @@
+use solana_client::client_error;
+use solana_ledger::blockstore;
+use solana_sdk::transport;
+use std::any::Any;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ArchiverError {
+    #[error("IO error")]
+    IO(#[from] std::io::Error),
+
+    #[error("blockstore error")]
+    BlockstoreError(#[from] blockstore::BlockstoreError),
+
+    #[error("crossbeam error")]
+    CrossbeamSendError(#[from] crossbeam_channel::SendError<u64>),
+
+    #[error("send error")]
+    SendError(#[from] std::sync::mpsc::SendError<u64>),
+
+    #[error("join error")]
+    JoinError(Box<dyn Any + Send + 'static>),
+
+    #[error("transport error")]
+    TransportError(#[from] transport::TransportError),
+
+    #[error("client error")]
+    ClientError(#[from] client_error::ClientError),
+
+    #[error("Json parsing error")]
+    JsonError(#[from] serde_json::error::Error),
+
+    #[error("Storage account has no balance")]
+    EmptyStorageAccountBalance,
+
+    #[error("No RPC peers..")]
+    NoRpcPeers,
+
+    #[error("Couldn't download full segment")]
+    SegmentDownloadError,
+}
+
+impl std::convert::From<Box<dyn Any + Send + 'static>> for ArchiverError {
+    fn from(e: Box<dyn Any + Send + 'static>) -> ArchiverError {
+        ArchiverError::JoinError(e)
+    }
+}

archiver-utils/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "solana-archiver-utils"
+version = "1.1.13"
+description = "Solana Archiver Utils"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+log = "0.4.8"
+rand = "0.7.0"
+solana-chacha = { path = "../chacha", version = "1.1.13" }
+solana-chacha-sys = { path = "../chacha-sys", version = "1.1.13" }
+solana-ledger = { path = "../ledger", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-perf = { path = "../perf", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+
+[dev-dependencies]
+hex = "0.4.2"
+
+[lib]
+name = "solana_archiver_utils"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

archiver-utils/src/lib.rs

@@ -0,0 +1,120 @@
+#[macro_use]
+extern crate log;
+
+use solana_sdk::hash::{Hash, Hasher};
+use std::fs::File;
+use std::io::{self, BufReader, ErrorKind, Read, Seek, SeekFrom};
+use std::mem::size_of;
+use std::path::Path;
+
+pub fn sample_file(in_path: &Path, sample_offsets: &[u64]) -> io::Result<Hash> {
+    let in_file = File::open(in_path)?;
+    let metadata = in_file.metadata()?;
+    let mut buffer_file = BufReader::new(in_file);
+
+    let mut hasher = Hasher::default();
+    let sample_size = size_of::<Hash>();
+    let sample_size64 = sample_size as u64;
+    let mut buf = vec![0; sample_size];
+
+    let file_len = metadata.len();
+    if file_len < sample_size64 {
+        return Err(io::Error::new(ErrorKind::Other, "file too short!"));
+    }
+    for offset in sample_offsets {
+        if *offset > (file_len - sample_size64) / sample_size64 {
+            return Err(io::Error::new(ErrorKind::Other, "offset too large"));
+        }
+        buffer_file.seek(SeekFrom::Start(*offset * sample_size64))?;
+        trace!("sampling @ {} ", *offset);
+        match buffer_file.read(&mut buf) {
+            Ok(size) => {
+                assert_eq!(size, buf.len());
+                hasher.hash(&buf);
+            }
+            Err(e) => {
+                warn!("Error sampling file");
+                return Err(e);
+            }
+        }
+    }
+
+    Ok(hasher.result())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rand::{thread_rng, Rng};
+    use std::fs::{create_dir_all, remove_file};
+    use std::io::Write;
+    use std::path::PathBuf;
+
+    extern crate hex;
+
+    fn tmp_file_path(name: &str) -> PathBuf {
+        use std::env;
+        let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
+        let mut rand_bits = [0u8; 32];
+        thread_rng().fill(&mut rand_bits[..]);
+
+        let mut path = PathBuf::new();
+        path.push(out_dir);
+        path.push("tmp");
+        create_dir_all(&path).unwrap();
+
+        path.push(format!("{}-{:?}", name, hex::encode(rand_bits)));
+        println!("path: {:?}", path);
+        path
+    }
+
+    #[test]
+    fn test_sample_file() {
+        solana_logger::setup();
+        let in_path = tmp_file_path("test_sample_file_input.txt");
+        let num_strings = 4096;
+        let string = "12foobar";
+        {
+            let mut in_file = File::create(&in_path).unwrap();
+            for _ in 0..num_strings {
+                in_file.write(string.as_bytes()).unwrap();
+            }
+        }
+        let num_samples = (string.len() * num_strings / size_of::<Hash>()) as u64;
+        let samples: Vec<_> = (0..num_samples).collect();
+        let res = sample_file(&in_path, samples.as_slice());
+        let ref_hash: Hash = Hash::new(&[
+            173, 251, 182, 165, 10, 54, 33, 150, 133, 226, 106, 150, 99, 192, 179, 1, 230, 144,
+            151, 126, 18, 191, 54, 67, 249, 140, 230, 160, 56, 30, 170, 52,
+        ]);
+        let res = res.unwrap();
+        assert_eq!(res, ref_hash);
+
+        // Sample just past the end
+        assert!(sample_file(&in_path, &[num_samples]).is_err());
+        remove_file(&in_path).unwrap();
+    }
+
+    #[test]
+    fn test_sample_file_invalid_offset() {
+        let in_path = tmp_file_path("test_sample_file_invalid_offset_input.txt");
+        {
+            let mut in_file = File::create(&in_path).unwrap();
+            for _ in 0..4096 {
+                in_file.write("123456foobar".as_bytes()).unwrap();
+            }
+        }
+        let samples = [0, 200000];
+        let res = sample_file(&in_path, &samples);
+        assert!(res.is_err());
+        remove_file(in_path).unwrap();
+    }
+
+    #[test]
+    fn test_sample_file_missing_file() {
+        let in_path = tmp_file_path("test_sample_file_that_doesnt_exist.txt");
+        let samples = [0, 5];
+        let res = sample_file(&in_path, &samples);
+        assert!(res.is_err());
+    }
+}

archiver/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+edition = "2018"
+name = "solana-archiver"
+version = "1.1.13"
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+
+[dependencies]
+clap = "2.33.0"
+console = "0.10.0"
+solana-clap-utils = { path = "../clap-utils", version = "1.1.13" }
+solana-core = { path = "../core", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-metrics = { path = "../metrics", version = "1.1.13" }
+solana-archiver-lib = { path = "../archiver-lib", version = "1.1.13" }
+solana-net-utils = { path = "../net-utils", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

archiver/src/main.rs

@@ -0,0 +1,131 @@
+use clap::{crate_description, crate_name, App, Arg};
+use console::style;
+use solana_archiver_lib::archiver::Archiver;
+use solana_clap_utils::{
+    input_parsers::keypair_of, input_validators::is_keypair_or_ask_keyword,
+    keypair::SKIP_SEED_PHRASE_VALIDATION_ARG,
+};
+use solana_core::{
+    cluster_info::{Node, VALIDATOR_PORT_RANGE},
+    contact_info::ContactInfo,
+};
+use solana_sdk::{
+    commitment_config::CommitmentConfig,
+    signature::{Keypair, Signer},
+};
+use std::{
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    path::PathBuf,
+    sync::Arc,
+};
+
+fn main() {
+    solana_logger::setup();
+
+    let matches = App::new(crate_name!())
+        .about(crate_description!())
+        .version(solana_clap_utils::version!())
+        .arg(
+            Arg::with_name("identity_keypair")
+                .short("i")
+                .long("identity")
+                .value_name("PATH")
+                .takes_value(true)
+                .validator(is_keypair_or_ask_keyword)
+                .help("File containing an identity (keypair)"),
+        )
+        .arg(
+            Arg::with_name("entrypoint")
+                .short("n")
+                .long("entrypoint")
+                .value_name("HOST:PORT")
+                .takes_value(true)
+                .required(true)
+                .validator(solana_net_utils::is_host_port)
+                .help("Rendezvous with the cluster at this entry point"),
+        )
+        .arg(
+            Arg::with_name("ledger")
+                .short("l")
+                .long("ledger")
+                .value_name("DIR")
+                .takes_value(true)
+                .required(true)
+                .help("use DIR as persistent ledger location"),
+        )
+        .arg(
+            Arg::with_name("storage_keypair")
+                .short("s")
+                .long("storage-keypair")
+                .value_name("PATH")
+                .takes_value(true)
+                .validator(is_keypair_or_ask_keyword)
+                .help("File containing the storage account keypair"),
+        )
+        .arg(
+            Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)
+                .long(SKIP_SEED_PHRASE_VALIDATION_ARG.long)
+                .help(SKIP_SEED_PHRASE_VALIDATION_ARG.help),
+        )
+        .get_matches();
+
+    let ledger_path = PathBuf::from(matches.value_of("ledger").unwrap());
+
+    let identity_keypair = keypair_of(&matches, "identity_keypair").unwrap_or_else(Keypair::new);
+
+    let storage_keypair = keypair_of(&matches, "storage_keypair").unwrap_or_else(|| {
+        clap::Error::with_description(
+            "The `storage-keypair` argument was not found",
+            clap::ErrorKind::ArgumentNotFound,
+        )
+        .exit();
+    });
+
+    let entrypoint_addr = matches
+        .value_of("entrypoint")
+        .map(|entrypoint| {
+            solana_net_utils::parse_host_port(entrypoint)
+                .expect("failed to parse entrypoint address")
+        })
+        .unwrap();
+
+    let gossip_addr = {
+        let ip = solana_net_utils::get_public_ip_addr(&entrypoint_addr).unwrap();
+        let mut addr = SocketAddr::new(ip, 0);
+        addr.set_ip(solana_net_utils::get_public_ip_addr(&entrypoint_addr).unwrap());
+        addr
+    };
+    let node = Node::new_archiver_with_external_ip(
+        &identity_keypair.pubkey(),
+        &gossip_addr,
+        VALIDATOR_PORT_RANGE,
+        IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
+    );
+
+    println!(
+        "{} version {} (branch={}, commit={})",
+        style(crate_name!()).bold(),
+        solana_clap_utils::version!(),
+        option_env!("CI_BRANCH").unwrap_or("unknown"),
+        option_env!("CI_COMMIT").unwrap_or("unknown")
+    );
+    solana_metrics::set_host_id(identity_keypair.pubkey().to_string());
+    println!(
+        "replicating the data with identity_keypair={:?} gossip_addr={:?}",
+        identity_keypair.pubkey(),
+        gossip_addr
+    );
+
+    let entrypoint_info = ContactInfo::new_gossip_entry_point(&entrypoint_addr);
+    let archiver = Archiver::new(
+        &ledger_path,
+        node,
+        entrypoint_info,
+        Arc::new(identity_keypair),
+        Arc::new(storage_keypair),
+        CommitmentConfig::recent(),
+    )
+    .unwrap();
+
+    archiver.join();
+}

banking-bench/Cargo.toml

@@ -2,27 +2,24 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-banking-bench"
-version = "1.2.0"
+version = "1.1.13"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
-clap = "2.33.1"
-crossbeam-channel = "0.4"
 log = "0.4.6"
-rand = "0.7.0"
 rayon = "1.3.0"
-solana-core = { path = "../core", version = "1.2.0" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-streamer = { path = "../streamer", version = "1.2.0" }
-solana-perf = { path = "../perf", version = "1.2.0" }
-solana-ledger = { path = "../ledger", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-measure = { path = "../measure", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
+solana-core = { path = "../core", version = "1.1.13" }
+solana-streamer = { path = "../streamer", version = "1.1.13" }
+solana-perf = { path = "../perf", version = "1.1.13" }
+solana-ledger = { path = "../ledger", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-runtime = { path = "../runtime", version = "1.1.13" }
+solana-measure = { path = "../measure", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+rand = "0.7.0"
+crossbeam-channel = "0.4"
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

banking-bench/src/main.rs

@@ -1,4 +1,3 @@
-use clap::{crate_description, crate_name, value_t, App, Arg};
 use crossbeam_channel::unbounded;
 use log::*;
 use rand::{thread_rng, Rng};
@@ -65,22 +64,15 @@ fn check_txs(
     no_bank
 }
 
-fn make_accounts_txs(
-    total_num_transactions: usize,
-    hash: Hash,
-    same_payer: bool,
-) -> Vec<Transaction> {
+fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec<Transaction> {
     let to_pubkey = Pubkey::new_rand();
-    let payer_key = Keypair::new();
-    let dummy = system_transaction::transfer(&payer_key, &to_pubkey, 1, hash);
-    (0..total_num_transactions)
+    let dummy = system_transaction::transfer(mint_keypair, &to_pubkey, 1, hash);
+    (0..txes)
         .into_par_iter()
         .map(|_| {
             let mut new = dummy.clone();
             let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-            if !same_payer {
-                new.message.account_keys[0] = Pubkey::new_rand();
-            }
+            new.message.account_keys[0] = Pubkey::new_rand();
             new.message.account_keys[1] = Pubkey::new_rand();
             new.signatures = vec![Signature::new(&sig[0..64])];
             new
@@ -104,61 +96,13 @@ fn bytes_as_usize(bytes: &[u8]) -> usize {
     bytes[0] as usize | (bytes[1] as usize) << 8
 }
 
-#[allow(clippy::cognitive_complexity)]
 fn main() {
     solana_logger::setup();
-
-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(solana_version::version!())
-        .arg(
-            Arg::with_name("num_chunks")
-                .long("num-chunks")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Number of transaction chunks."),
-        )
-        .arg(
-            Arg::with_name("packets_per_chunk")
-                .long("packets-per-chunk")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Packets per chunk"),
-        )
-        .arg(
-            Arg::with_name("skip_sanity")
-                .long("skip-sanity")
-                .takes_value(false)
-                .help("Skip transaction sanity execution"),
-        )
-        .arg(
-            Arg::with_name("same_payer")
-                .long("same-payer")
-                .takes_value(false)
-                .help("Use the same payer for transfers"),
-        )
-        .arg(
-            Arg::with_name("iterations")
-                .long("iterations")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .arg(
-            Arg::with_name("num_threads")
-                .long("num-threads")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .get_matches();
-
-    let num_threads =
-        value_t!(matches, "num_threads", usize).unwrap_or(BankingStage::num_threads() as usize);
+    let num_threads = BankingStage::num_threads() as usize;
     //   a multiple of packet chunk duplicates to avoid races
-    let num_chunks = value_t!(matches, "num_chunks", usize).unwrap_or(16);
-    let packets_per_chunk = value_t!(matches, "packets_per_chunk", usize).unwrap_or(192);
-    let iterations = value_t!(matches, "iterations", usize).unwrap_or(1000);
-
-    let total_num_transactions = num_chunks * num_threads * packets_per_chunk;
+    const CHUNKS: usize = 8 * 2;
+    const PACKETS_PER_BATCH: usize = 192;
+    let txes = PACKETS_PER_BATCH * num_threads * CHUNKS;
     let mint_total = 1_000_000_000_000;
     let GenesisConfigInfo {
         genesis_config,
@@ -172,44 +116,34 @@ fn main() {
     let mut bank_forks = BankForks::new(0, bank0);
     let mut bank = bank_forks.working_bank();
 
-    info!("threads: {} txs: {}", num_threads, total_num_transactions);
+    info!("threads: {} txs: {}", num_threads, txes);
 
-    let same_payer = matches.is_present("same_payer");
-    let mut transactions =
-        make_accounts_txs(total_num_transactions, genesis_config.hash(), same_payer);
+    let mut transactions = make_accounts_txs(txes, &mint_keypair, genesis_config.hash());
 
     // fund all the accounts
     transactions.iter().for_each(|tx| {
-        let mut fund = system_transaction::transfer(
+        let fund = system_transaction::transfer(
             &mint_keypair,
             &tx.message.account_keys[0],
-            mint_total / total_num_transactions as u64,
+            mint_total / txes as u64,
             genesis_config.hash(),
         );
-        // Ignore any pesky duplicate signature errors in the case we are using single-payer
-        let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-        fund.signatures = vec![Signature::new(&sig[0..64])];
         let x = bank.process_transaction(&fund);
         x.unwrap();
     });
-
-    let skip_sanity = matches.is_present("skip_sanity");
-    if !skip_sanity {
-        //sanity check, make sure all the transactions can execute sequentially
-        transactions.iter().for_each(|tx| {
-            let res = bank.process_transaction(&tx);
-            assert!(res.is_ok(), "sanity test transactions error: {:?}", res);
-        });
-        bank.clear_signatures();
-        //sanity check, make sure all the transactions can execute in parallel
-        let res = bank.process_transactions(&transactions);
-        for r in res {
-            assert!(r.is_ok(), "sanity parallel execution error: {:?}", r);
-        }
-        bank.clear_signatures();
+    //sanity check, make sure all the transactions can execute sequentially
+    transactions.iter().for_each(|tx| {
+        let res = bank.process_transaction(&tx);
+        assert!(res.is_ok(), "sanity test transactions");
+    });
+    bank.clear_signatures();
+    //sanity check, make sure all the transactions can execute in parallel
+    let res = bank.process_transactions(&transactions);
+    for r in res {
+        assert!(r.is_ok(), "sanity parallel execution");
     }
-
-    let mut verified: Vec<_> = to_packets_chunked(&transactions.clone(), packets_per_chunk);
+    bank.clear_signatures();
+    let mut verified: Vec<_> = to_packets_chunked(&transactions.clone(), PACKETS_PER_BATCH);
     let ledger_path = get_tmp_ledger_path!();
     {
         let blockstore = Arc::new(
@@ -228,7 +162,7 @@ fn main() {
         );
         poh_recorder.lock().unwrap().set_bank(&bank);
 
-        let chunk_len = verified.len() / num_chunks;
+        let chunk_len = verified.len() / CHUNKS;
         let mut start = 0;
 
         // This is so that the signal_receiver does not go out of scope after the closure.
@@ -237,17 +171,17 @@ fn main() {
         let signal_receiver = Arc::new(signal_receiver);
         let mut total_us = 0;
         let mut tx_total_us = 0;
-        let base_tx_count = bank.transaction_count();
         let mut txs_processed = 0;
         let mut root = 1;
         let collector = Pubkey::new_rand();
+        const ITERS: usize = 1_000;
         let config = Config {
-            packets_per_batch: packets_per_chunk,
+            packets_per_batch: PACKETS_PER_BATCH,
             chunk_len,
             num_threads,
         };
         let mut total_sent = 0;
-        for _ in 0..iterations {
+        for _ in 0..ITERS {
             let now = Instant::now();
             let mut sent = 0;
 
@@ -288,11 +222,7 @@ fn main() {
                     sleep(Duration::from_millis(5));
                 }
             }
-            if check_txs(
-                &signal_receiver,
-                total_num_transactions / num_chunks,
-                &poh_recorder,
-            ) {
+            if check_txs(&signal_receiver, txes / CHUNKS, &poh_recorder) {
                 debug!(
                     "resetting bank {} tx count: {} txs_proc: {}",
                     bank.slot(),
@@ -344,7 +274,7 @@ fn main() {
             debug!(
                 "time: {} us checked: {} sent: {}",
                 duration_as_us(&now.elapsed()),
-                total_num_transactions / num_chunks,
+                txes / CHUNKS,
                 sent,
             );
             total_sent += sent;
@@ -355,26 +285,20 @@ fn main() {
                     let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
                     tx.signatures[0] = Signature::new(&sig[0..64]);
                 }
-                verified = to_packets_chunked(&transactions.clone(), packets_per_chunk);
+                verified = to_packets_chunked(&transactions.clone(), PACKETS_PER_BATCH);
             }
 
             start += chunk_len;
             start %= verified.len();
         }
-        let txs_processed = bank_forks.working_bank().transaction_count();
-        debug!("processed: {} base: {}", txs_processed, base_tx_count);
         eprintln!(
-            "{{'name': 'banking_bench_total', 'median': '{:.2}'}}",
+            "{{'name': 'banking_bench_total', 'median': '{}'}}",
             (1000.0 * 1000.0 * total_sent as f64) / (total_us as f64),
         );
         eprintln!(
-            "{{'name': 'banking_bench_tx_total', 'median': '{:.2}'}}",
+            "{{'name': 'banking_bench_tx_total', 'median': '{}'}}",
             (1000.0 * 1000.0 * total_sent as f64) / (tx_total_us as f64),
         );
-        eprintln!(
-            "{{'name': 'banking_bench_success_tx_total', 'median': '{:.2}'}}",
-            (1000.0 * 1000.0 * (txs_processed - base_tx_count) as f64) / (total_us as f64),
-        );
 
         drop(verified_sender);
         drop(vote_sender);

bench-exchange/Cargo.toml

@@ -2,37 +2,36 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-exchange"
-version = "1.2.0"
+version = "1.1.13"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 publish = false
 
 [dependencies]
-clap = "2.33.1"
+clap = "2.32.0"
 itertools = "0.9.0"
 log = "0.4.8"
 num-derive = "0.3"
 num-traits = "0.2"
 rand = "0.7.0"
 rayon = "1.3.0"
-serde_json = "1.0.53"
-serde_yaml = "0.8.12"
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-core = { path = "../core", version = "1.2.0" }
-solana-genesis = { path = "../genesis", version = "1.2.0" }
-solana-client = { path = "../client", version = "1.2.0" }
-solana-faucet = { path = "../faucet", version = "1.2.0" }
-solana-exchange-program = { path = "../programs/exchange", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-metrics = { path = "../metrics", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
+serde_json = "1.0.48"
+serde_yaml = "0.8.11"
+solana-clap-utils = { path = "../clap-utils", version = "1.1.13" }
+solana-core = { path = "../core", version = "1.1.13" }
+solana-genesis = { path = "../genesis", version = "1.1.13" }
+solana-client = { path = "../client", version = "1.1.13" }
+solana-faucet = { path = "../faucet", version = "1.1.13" }
+solana-exchange-program = { path = "../programs/exchange", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-metrics = { path = "../metrics", version = "1.1.13" }
+solana-net-utils = { path = "../net-utils", version = "1.1.13" }
+solana-runtime = { path = "../runtime", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
 
 [dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "1.2.0" }
+solana-local-cluster = { path = "../local-cluster", version = "1.1.13" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-exchange/src/bench.rs

@@ -459,7 +459,7 @@ fn swapper<T>(
                     let owner = &signer.pubkey();
                     Transaction::new_signed_instructions(
                         &[s],
-                        &[exchange_instruction::swap_request(
+                        vec![exchange_instruction::swap_request(
                             owner,
                             &swap.0.pubkey,
                             &swap.1.pubkey,
@@ -590,7 +590,7 @@ fn trader<T>(
                     let space = mem::size_of::<ExchangeState>() as u64;
                     Transaction::new_signed_instructions(
                         &[owner.as_ref(), trade],
-                        &[
+                        vec![
                             system_instruction::create_account(
                                 owner_pubkey,
                                 trade_pubkey,
@@ -749,7 +749,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
                 .map(|(k, m)| {
                     (
                         k.clone(),
-                        Transaction::new_unsigned_instructions(&system_instruction::transfer_many(
+                        Transaction::new_unsigned_instructions(system_instruction::transfer_many(
                             &k.pubkey(),
                             &m,
                         )),
@@ -760,10 +760,9 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
             let mut retries = 0;
             let amount = chunk[0].1[0].1;
             while !to_fund_txs.is_empty() {
-                let receivers: usize = to_fund_txs
+                let receivers = to_fund_txs
                     .iter()
-                    .map(|(_, tx)| tx.message().instructions.len())
-                    .sum();
+                    .fold(0, |len, (_, tx)| len + tx.message().instructions.len());
 
                 debug!(
                     "  {} to {} in {} txs",
@@ -850,15 +849,14 @@ pub fn create_token_accounts<T: Client>(
                         exchange_instruction::account_request(owner_pubkey, &new_keypair.pubkey());
                     (
                         (from_keypair, new_keypair),
-                        Transaction::new_unsigned_instructions(&[create_ix, request_ix]),
+                        Transaction::new_unsigned_instructions(vec![create_ix, request_ix]),
                     )
                 })
                 .collect();
 
-            let accounts: usize = to_create_txs
+            let accounts = to_create_txs
                 .iter()
-                .map(|(_, tx)| tx.message().instructions.len() / 2)
-                .sum();
+                .fold(0, |len, (_, tx)| len + tx.message().instructions.len() / 2);
 
             debug!(
                 "  Creating {} accounts in {} txs",

bench-exchange/src/main.rs

@@ -11,7 +11,7 @@ fn main() {
     solana_logger::setup();
     solana_metrics::set_panic_hook("bench-exchange");
 
-    let matches = cli::build_args(solana_version::version!()).get_matches();
+    let matches = cli::build_args(solana_clap_utils::version!()).get_matches();
     let cli_config = cli::extract_args(&matches);
 
     let cli::Config {
@@ -54,9 +54,10 @@ fn main() {
         );
     } else {
         info!("Connecting to the cluster");
-        let nodes = discover_cluster(&entrypoint_addr, num_nodes).unwrap_or_else(|_| {
-            panic!("Failed to discover nodes");
-        });
+        let (nodes, _archivers) =
+            discover_cluster(&entrypoint_addr, num_nodes).unwrap_or_else(|_| {
+                panic!("Failed to discover nodes");
+            });
 
         let (client, num_clients) = get_multi_client(&nodes);
 

bench-exchange/tests/bench_exchange.rs

@@ -59,7 +59,7 @@ fn test_exchange_local_cluster() {
     let faucet_addr = addr_receiver.recv_timeout(Duration::from_secs(2)).unwrap();
 
     info!("Connecting to the cluster");
-    let nodes =
+    let (nodes, _) =
         discover_cluster(&cluster.entry_point_info.gossip, NUM_NODES).unwrap_or_else(|err| {
             error!("Failed to discover {} nodes: {:?}", NUM_NODES, err);
             exit(1);
@@ -86,7 +86,7 @@ fn test_exchange_bank_client() {
     solana_logger::setup();
     let (genesis_config, identity) = create_genesis_config(100_000_000_000_000);
     let mut bank = Bank::new(&genesis_config);
-    bank.add_builtin_program("exchange_program", id(), process_instruction);
+    bank.add_static_program("exchange_program", id(), process_instruction);
     let clients = vec![BankClient::new(bank)];
 
     let mut config = Config::default();

bench-streamer/Cargo.toml

@@ -2,18 +2,17 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-streamer"
-version = "1.2.0"
+version = "1.1.13"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
-clap = "2.33.1"
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-streamer = { path = "../streamer", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
+clap = "2.33.0"
+solana-clap-utils = { path = "../clap-utils", version = "1.1.13" }
+solana-streamer = { path = "../streamer", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-net-utils = { path = "../net-utils", version = "1.1.13" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-streamer/src/main.rs

@@ -52,7 +52,7 @@ fn main() -> Result<()> {
 
     let matches = App::new(crate_name!())
         .about(crate_description!())
-        .version(solana_version::version!())
+        .version(solana_clap_utils::version!())
         .arg(
             Arg::with_name("num-recv-sockets")
                 .long("num-recv-sockets")

bench-tps/Cargo.toml

@@ -2,40 +2,39 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "1.2.0"
+version = "1.1.13"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
 bincode = "1.2.1"
-clap = "2.33.1"
+clap = "2.33.0"
 log = "0.4.8"
 rayon = "1.3.0"
-serde_json = "1.0.53"
-serde_yaml = "0.8.12"
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-core = { path = "../core", version = "1.2.0" }
-solana-genesis = { path = "../genesis", version = "1.2.0" }
-solana-client = { path = "../client", version = "1.2.0" }
-solana-faucet = { path = "../faucet", version = "1.2.0" }
-solana-librapay = { path = "../programs/librapay", version = "1.2.0", optional = true }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-metrics = { path = "../metrics", version = "1.2.0" }
-solana-measure = { path = "../measure", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-move-loader-program = { path = "../programs/move_loader", version = "1.2.0", optional = true }
-solana-version = { path = "../version", version = "1.2.0" }
+serde_json = "1.0.48"
+serde_yaml = "0.8.11"
+solana-clap-utils = { path = "../clap-utils", version = "1.1.13" }
+solana-core = { path = "../core", version = "1.1.13" }
+solana-genesis = { path = "../genesis", version = "1.1.13" }
+solana-client = { path = "../client", version = "1.1.13" }
+solana-faucet = { path = "../faucet", version = "1.1.13" }
+#solana-librapay = { path = "../programs/librapay", version = "1.1.8", optional = true }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-metrics = { path = "../metrics", version = "1.1.13" }
+solana-measure = { path = "../measure", version = "1.1.13" }
+solana-net-utils = { path = "../net-utils", version = "1.1.13" }
+solana-runtime = { path = "../runtime", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+#solana-move-loader-program = { path = "../programs/move_loader", version = "1.1.8", optional = true }
 
 [dev-dependencies]
 serial_test = "0.4.0"
 serial_test_derive = "0.4.0"
-solana-local-cluster = { path = "../local-cluster", version = "1.2.0" }
+solana-local-cluster = { path = "../local-cluster", version = "1.1.13" }
 
-[features]
-move = ["solana-librapay", "solana-move-loader-program"]
+#[features]
+#move = ["solana-librapay", "solana-move-loader-program"]
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-tps/src/bench.rs

@@ -26,9 +26,9 @@ use std::{
     process::exit,
     sync::{
         atomic::{AtomicBool, AtomicIsize, AtomicUsize, Ordering},
-        Arc, Mutex, RwLock,
+        Arc, RwLock,
     },
-    thread::{sleep, Builder, JoinHandle},
+    thread::{sleep, Builder},
     time::{Duration, Instant},
 };
 
@@ -64,63 +64,105 @@ fn get_recent_blockhash<T: Client>(client: &T) -> (Hash, FeeCalculator) {
     }
 }
 
-fn wait_for_target_slots_per_epoch<T>(target_slots_per_epoch: u64, client: &Arc<T>)
-where
-    T: 'static + Client + Send + Sync,
-{
-    if target_slots_per_epoch != 0 {
-        info!(
-            "Waiting until epochs are {} slots long..",
-            target_slots_per_epoch
-        );
-        loop {
-            if let Ok(epoch_info) = client.get_epoch_info() {
-                if epoch_info.slots_in_epoch >= target_slots_per_epoch {
-                    info!("Done epoch_info: {:?}", epoch_info);
-                    break;
-                }
-                info!(
-                    "Waiting for epoch: {} now: {}",
-                    target_slots_per_epoch, epoch_info.slots_in_epoch
-                );
-            }
-            sleep(Duration::from_secs(3));
-        }
-    }
-}
-
-fn create_sampler_thread<T>(
-    client: &Arc<T>,
-    exit_signal: &Arc<AtomicBool>,
-    sample_period: u64,
-    maxes: &Arc<RwLock<Vec<(String, SampleStats)>>>,
-) -> JoinHandle<()>
-where
-    T: 'static + Client + Send + Sync,
-{
-    info!("Sampling TPS every {} second...", sample_period);
-    let exit_signal = exit_signal.clone();
-    let maxes = maxes.clone();
-    let client = client.clone();
-    Builder::new()
-        .name("solana-client-sample".to_string())
-        .spawn(move || {
-            sample_txs(&exit_signal, &maxes, sample_period, &client);
-        })
-        .unwrap()
-}
-
-fn generate_chunked_transfers(
-    recent_blockhash: Arc<RwLock<Hash>>,
-    shared_txs: &SharedTransactions,
-    shared_tx_active_thread_count: Arc<AtomicIsize>,
-    source_keypair_chunks: Vec<Vec<&Keypair>>,
-    dest_keypair_chunks: &mut Vec<VecDeque<&Keypair>>,
-    threads: usize,
-    duration: Duration,
-    sustained: bool,
+pub fn do_bench_tps<T>(
+    client: Arc<T>,
+    config: Config,
+    gen_keypairs: Vec<Keypair>,
     libra_args: Option<LibraKeys>,
-) {
+) -> u64
+where
+    T: 'static + Client + Send + Sync,
+{
+    let Config {
+        id,
+        threads,
+        thread_batch_sleep_ms,
+        duration,
+        tx_count,
+        sustained,
+        ..
+    } = config;
+
+    let mut source_keypair_chunks: Vec<Vec<&Keypair>> = Vec::new();
+    let mut dest_keypair_chunks: Vec<VecDeque<&Keypair>> = Vec::new();
+    assert!(gen_keypairs.len() >= 2 * tx_count);
+    for chunk in gen_keypairs.chunks_exact(2 * tx_count) {
+        source_keypair_chunks.push(chunk[..tx_count].iter().collect());
+        dest_keypair_chunks.push(chunk[tx_count..].iter().collect());
+    }
+
+    let first_tx_count = loop {
+        match client.get_transaction_count() {
+            Ok(count) => break count,
+            Err(err) => {
+                info!("Couldn't get transaction count: {:?}", err);
+                sleep(Duration::from_secs(1));
+            }
+        }
+    };
+    info!("Initial transaction count {}", first_tx_count);
+
+    let exit_signal = Arc::new(AtomicBool::new(false));
+
+    // Setup a thread per validator to sample every period
+    // collect the max transaction rate and total tx count seen
+    let maxes = Arc::new(RwLock::new(Vec::new()));
+    let sample_period = 1; // in seconds
+    info!("Sampling TPS every {} second...", sample_period);
+    let sample_thread = {
+        let exit_signal = exit_signal.clone();
+        let maxes = maxes.clone();
+        let client = client.clone();
+        Builder::new()
+            .name("solana-client-sample".to_string())
+            .spawn(move || {
+                sample_txs(&exit_signal, &maxes, sample_period, &client);
+            })
+            .unwrap()
+    };
+
+    let shared_txs: SharedTransactions = Arc::new(RwLock::new(VecDeque::new()));
+
+    let recent_blockhash = Arc::new(RwLock::new(get_recent_blockhash(client.as_ref()).0));
+    let shared_tx_active_thread_count = Arc::new(AtomicIsize::new(0));
+    let total_tx_sent_count = Arc::new(AtomicUsize::new(0));
+
+    let blockhash_thread = {
+        let exit_signal = exit_signal.clone();
+        let recent_blockhash = recent_blockhash.clone();
+        let client = client.clone();
+        let id = id.pubkey();
+        Builder::new()
+            .name("solana-blockhash-poller".to_string())
+            .spawn(move || {
+                poll_blockhash(&exit_signal, &recent_blockhash, &client, &id);
+            })
+            .unwrap()
+    };
+
+    let s_threads: Vec<_> = (0..threads)
+        .map(|_| {
+            let exit_signal = exit_signal.clone();
+            let shared_txs = shared_txs.clone();
+            let shared_tx_active_thread_count = shared_tx_active_thread_count.clone();
+            let total_tx_sent_count = total_tx_sent_count.clone();
+            let client = client.clone();
+            Builder::new()
+                .name("solana-client-sender".to_string())
+                .spawn(move || {
+                    do_tx_transfers(
+                        &exit_signal,
+                        &shared_txs,
+                        &shared_tx_active_thread_count,
+                        &total_tx_sent_count,
+                        thread_batch_sleep_ms,
+                        &client,
+                    );
+                })
+                .unwrap()
+        })
+        .collect();
+
     // generate and send transactions for the specified duration
     let start = Instant::now();
     let keypair_chunks = source_keypair_chunks.len();
@@ -128,7 +170,7 @@ fn generate_chunked_transfers(
     let mut chunk_index = 0;
     while start.elapsed() < duration {
         generate_txs(
-            shared_txs,
+            &shared_txs,
             &recent_blockhash,
             &source_keypair_chunks[chunk_index],
             &dest_keypair_chunks[chunk_index],
@@ -164,135 +206,6 @@ fn generate_chunked_transfers(
             reclaim_lamports_back_to_source_account = !reclaim_lamports_back_to_source_account;
         }
     }
-}
-
-fn create_sender_threads<T>(
-    client: &Arc<T>,
-    shared_txs: &SharedTransactions,
-    thread_batch_sleep_ms: usize,
-    total_tx_sent_count: &Arc<AtomicUsize>,
-    threads: usize,
-    exit_signal: &Arc<AtomicBool>,
-    shared_tx_active_thread_count: &Arc<AtomicIsize>,
-) -> Vec<JoinHandle<()>>
-where
-    T: 'static + Client + Send + Sync,
-{
-    (0..threads)
-        .map(|_| {
-            let exit_signal = exit_signal.clone();
-            let shared_txs = shared_txs.clone();
-            let shared_tx_active_thread_count = shared_tx_active_thread_count.clone();
-            let total_tx_sent_count = total_tx_sent_count.clone();
-            let client = client.clone();
-            Builder::new()
-                .name("solana-client-sender".to_string())
-                .spawn(move || {
-                    do_tx_transfers(
-                        &exit_signal,
-                        &shared_txs,
-                        &shared_tx_active_thread_count,
-                        &total_tx_sent_count,
-                        thread_batch_sleep_ms,
-                        &client,
-                    );
-                })
-                .unwrap()
-        })
-        .collect()
-}
-
-pub fn do_bench_tps<T>(
-    client: Arc<T>,
-    config: Config,
-    gen_keypairs: Vec<Keypair>,
-    libra_args: Option<LibraKeys>,
-) -> u64
-where
-    T: 'static + Client + Send + Sync,
-{
-    let Config {
-        id,
-        threads,
-        thread_batch_sleep_ms,
-        duration,
-        tx_count,
-        sustained,
-        target_slots_per_epoch,
-        ..
-    } = config;
-
-    let mut source_keypair_chunks: Vec<Vec<&Keypair>> = Vec::new();
-    let mut dest_keypair_chunks: Vec<VecDeque<&Keypair>> = Vec::new();
-    assert!(gen_keypairs.len() >= 2 * tx_count);
-    for chunk in gen_keypairs.chunks_exact(2 * tx_count) {
-        source_keypair_chunks.push(chunk[..tx_count].iter().collect());
-        dest_keypair_chunks.push(chunk[tx_count..].iter().collect());
-    }
-
-    let first_tx_count = loop {
-        match client.get_transaction_count() {
-            Ok(count) => break count,
-            Err(err) => {
-                info!("Couldn't get transaction count: {:?}", err);
-                sleep(Duration::from_secs(1));
-            }
-        }
-    };
-    info!("Initial transaction count {}", first_tx_count);
-
-    let exit_signal = Arc::new(AtomicBool::new(false));
-
-    // Setup a thread per validator to sample every period
-    // collect the max transaction rate and total tx count seen
-    let maxes = Arc::new(RwLock::new(Vec::new()));
-    let sample_period = 1; // in seconds
-    let sample_thread = create_sampler_thread(&client, &exit_signal, sample_period, &maxes);
-
-    let shared_txs: SharedTransactions = Arc::new(RwLock::new(VecDeque::new()));
-
-    let recent_blockhash = Arc::new(RwLock::new(get_recent_blockhash(client.as_ref()).0));
-    let shared_tx_active_thread_count = Arc::new(AtomicIsize::new(0));
-    let total_tx_sent_count = Arc::new(AtomicUsize::new(0));
-
-    let blockhash_thread = {
-        let exit_signal = exit_signal.clone();
-        let recent_blockhash = recent_blockhash.clone();
-        let client = client.clone();
-        let id = id.pubkey();
-        Builder::new()
-            .name("solana-blockhash-poller".to_string())
-            .spawn(move || {
-                poll_blockhash(&exit_signal, &recent_blockhash, &client, &id);
-            })
-            .unwrap()
-    };
-
-    let s_threads = create_sender_threads(
-        &client,
-        &shared_txs,
-        thread_batch_sleep_ms,
-        &total_tx_sent_count,
-        threads,
-        &exit_signal,
-        &shared_tx_active_thread_count,
-    );
-
-    wait_for_target_slots_per_epoch(target_slots_per_epoch, &client);
-
-    let start = Instant::now();
-
-    generate_chunked_transfers(
-        recent_blockhash,
-        &shared_txs,
-        shared_tx_active_thread_count,
-        source_keypair_chunks,
-        &mut dest_keypair_chunks,
-        threads,
-        duration,
-        sustained,
-        libra_args,
-    );
 
     // Stop the sampling threads so it will collect the stats
     exit_signal.store(true, Ordering::Relaxed);
@@ -650,9 +563,10 @@ impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
         let to_fund_txs: Vec<(&Keypair, Transaction)> = to_fund
             .par_iter()
             .map(|(k, t)| {
-                let tx = Transaction::new_unsigned_instructions(
-                    &system_instruction::transfer_many(&k.pubkey(), &t),
-                );
+                let tx = Transaction::new_unsigned_instructions(system_instruction::transfer_many(
+                    &k.pubkey(),
+                    &t,
+                ));
                 (*k, tx)
             })
             .collect();
@@ -689,9 +603,7 @@ impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
         let too_many_failures = Arc::new(AtomicBool::new(false));
         let loops = if starting_txs < 1000 { 3 } else { 1 };
         // Only loop multiple times for small (quick) transaction batches
-        let time = Arc::new(Mutex::new(Instant::now()));
         for _ in 0..loops {
-            let time = time.clone();
             let failed_verify = Arc::new(AtomicUsize::new(0));
             let client = client.clone();
             let verified_txs = &verified_txs;
@@ -722,15 +634,11 @@ impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
                             remaining_count, verified_txs, failed_verify
                         );
                     }
-                    if remaining_count > 0 {
-                        let mut time_l = time.lock().unwrap();
-                        if time_l.elapsed().as_secs() > 2 {
-                            info!(
-                                "Verifying transfers... {} remaining, {} verified, {} failures",
-                                remaining_count, verified_txs, failed_verify
-                            );
-                            *time_l = Instant::now();
-                        }
+                    if remaining_count % 100 == 0 {
+                        info!(
+                            "Verifying transfers... {} remaining, {} verified, {} failures",
+                            remaining_count, verified_txs, failed_verify
+                        );
                     }
 
                     verified
@@ -1023,7 +931,7 @@ fn fund_move_keys<T: Client>(
         .collect();
     let tx = Transaction::new_signed_instructions(
         &[funding_key],
-        &system_instruction::transfer_many(&funding_key.pubkey(), &pubkey_amounts),
+        system_instruction::transfer_many(&funding_key.pubkey(), &pubkey_amounts),
         blockhash,
     );
     client.send_message(&[funding_key], tx.message).unwrap();

bench-tps/src/cli.rs

@@ -25,7 +25,6 @@ pub struct Config {
     pub multi_client: bool,
     pub use_move: bool,
     pub num_lamports_per_account: u64,
-    pub target_slots_per_epoch: u64,
 }
 
 impl Default for Config {
@@ -48,7 +47,6 @@ impl Default for Config {
             multi_client: true,
             use_move: false,
             num_lamports_per_account: NUM_LAMPORTS_PER_ACCOUNT_DEFAULT,
-            target_slots_per_epoch: 0,
         }
     }
 }
@@ -174,15 +172,6 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
                     "Number of lamports per account.",
                 ),
         )
-        .arg(
-            Arg::with_name("target_slots_per_epoch")
-                .long("target-slots-per-epoch")
-                .value_name("SLOTS")
-                .takes_value(true)
-                .help(
-                    "Wait until epochs are this many slots long.",
-                ),
-        )
 }
 
 /// Parses a clap `ArgMatches` structure into a `Config`
@@ -270,12 +259,5 @@ pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
         args.num_lamports_per_account = v.to_string().parse().expect("can't parse lamports");
     }
 
-    if let Some(t) = matches.value_of("target_slots_per_epoch") {
-        args.target_slots_per_epoch = t
-            .to_string()
-            .parse()
-            .expect("can't parse target slots per epoch");
-    }
-
     args
 }

bench-tps/src/main.rs

@@ -15,7 +15,7 @@ fn main() {
     solana_logger::setup_with_default("solana=info");
     solana_metrics::set_panic_hook("bench-tps");
 
-    let matches = cli::build_args(solana_version::version!()).get_matches();
+    let matches = cli::build_args(solana_clap_utils::version!()).get_matches();
     let cli_config = cli::extract_args(&matches);
 
     let cli::Config {
@@ -67,10 +67,11 @@ fn main() {
     }
 
     info!("Connecting to the cluster");
-    let nodes = discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
-        eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
-        exit(1);
-    });
+    let (nodes, _archivers) =
+        discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
+            eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
+            exit(1);
+        });
 
     let client = if *multi_client {
         let (client, num_clients) = get_multi_client(&nodes);

chacha-cuda/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "solana-chacha-cuda"
+version = "1.1.13"
+description = "Solana Chacha Cuda APIs"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+log = "0.4.8"
+solana-archiver-utils = { path = "../archiver-utils", version = "1.1.13" }
+solana-chacha = { path = "../chacha", version = "1.1.13" }
+solana-ledger = { path = "../ledger", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-perf = { path = "../perf", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+
+[dev-dependencies]
+hex-literal = "0.2.1"
+
+[lib]
+name = "solana_chacha_cuda"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

chacha-cuda/src/chacha_cuda.rs

@@ -0,0 +1,280 @@
+// Module used by validators to approve storage mining proofs in parallel using the GPU
+
+use solana_chacha::chacha::{CHACHA_BLOCK_SIZE, CHACHA_KEY_SIZE};
+use solana_ledger::blockstore::Blockstore;
+use solana_perf::perf_libs;
+use solana_sdk::hash::Hash;
+use std::io;
+use std::mem::size_of;
+use std::sync::Arc;
+
+// Encrypt a file with multiple starting IV states, determined by ivecs.len()
+//
+// Then sample each block at the offsets provided by samples argument with sha256
+// and return the vec of sha states
+pub fn chacha_cbc_encrypt_file_many_keys(
+    blockstore: &Arc<Blockstore>,
+    segment: u64,
+    slots_per_segment: u64,
+    ivecs: &mut [u8],
+    samples: &[u64],
+) -> io::Result<Vec<Hash>> {
+    let api = perf_libs::api().expect("no perf libs");
+    if ivecs.len() % CHACHA_BLOCK_SIZE != 0 {
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            format!(
+                "bad IV length({}) not divisible by {} ",
+                ivecs.len(),
+                CHACHA_BLOCK_SIZE,
+            ),
+        ));
+    }
+
+    const BUFFER_SIZE: usize = 8 * 1024;
+    let mut buffer = [0; BUFFER_SIZE];
+    let num_keys = ivecs.len() / CHACHA_BLOCK_SIZE;
+    let mut sha_states = vec![0; num_keys * size_of::<Hash>()];
+    let mut int_sha_states = vec![0; num_keys * 112];
+    let keys: Vec<u8> = vec![0; num_keys * CHACHA_KEY_SIZE]; // keys not used ATM, uniqueness comes from IV
+    let mut current_slot = segment * slots_per_segment;
+    let mut start_index = 0;
+    let start_slot = current_slot;
+    let mut total_size = 0;
+    let mut time: f32 = 0.0;
+    unsafe {
+        (api.chacha_init_sha_state)(int_sha_states.as_mut_ptr(), num_keys as u32);
+    }
+    loop {
+        match blockstore.get_data_shreds(current_slot, start_index, std::u64::MAX, &mut buffer) {
+            Ok((last_index, mut size)) => {
+                debug!(
+                    "chacha_cuda: encrypting segment: {} num_shreds: {} data_len: {}",
+                    segment,
+                    last_index.saturating_sub(start_index),
+                    size
+                );
+
+                if size == 0 {
+                    if current_slot.saturating_sub(start_slot) < slots_per_segment {
+                        current_slot += 1;
+                        start_index = 0;
+                        continue;
+                    } else {
+                        break;
+                    }
+                }
+
+                if size < BUFFER_SIZE {
+                    // round to the nearest key_size boundary
+                    size = (size + CHACHA_KEY_SIZE - 1) & !(CHACHA_KEY_SIZE - 1);
+                }
+
+                unsafe {
+                    (api.chacha_cbc_encrypt_many_sample)(
+                        buffer[..size].as_ptr(),
+                        int_sha_states.as_mut_ptr(),
+                        size,
+                        keys.as_ptr(),
+                        ivecs.as_mut_ptr(),
+                        num_keys as u32,
+                        samples.as_ptr(),
+                        samples.len() as u32,
+                        total_size,
+                        &mut time,
+                    );
+                }
+
+                total_size += size as u64;
+                start_index = last_index + 1;
+            }
+            Err(e) => {
+                info!("Error encrypting file: {:?}", e);
+                break;
+            }
+        }
+    }
+    unsafe {
+        (api.chacha_end_sha_state)(
+            int_sha_states.as_ptr(),
+            sha_states.as_mut_ptr(),
+            num_keys as u32,
+        );
+    }
+    let mut res = Vec::new();
+    for x in 0..num_keys {
+        let start = x * size_of::<Hash>();
+        let end = start + size_of::<Hash>();
+        res.push(Hash::new(&sha_states[start..end]));
+    }
+    Ok(res)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use solana_archiver_utils::sample_file;
+    use solana_chacha::chacha::chacha_cbc_encrypt_ledger;
+    use solana_ledger::entry::create_ticks;
+    use solana_ledger::get_tmp_ledger_path;
+    use solana_sdk::clock::DEFAULT_SLOTS_PER_SEGMENT;
+    use solana_sdk::signature::Keypair;
+    use std::fs::{remove_dir_all, remove_file};
+    use std::path::Path;
+
+    #[test]
+    fn test_encrypt_file_many_keys_single() {
+        solana_logger::setup();
+        if perf_libs::api().is_none() {
+            info!("perf-libs unavailable, skipped");
+            return;
+        }
+
+        let slots_per_segment = 32;
+        let entries = create_ticks(slots_per_segment, 0, Hash::default());
+        let ledger_path = get_tmp_ledger_path!();
+        let ticks_per_slot = 16;
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+
+        blockstore
+            .write_entries(
+                0,
+                0,
+                0,
+                ticks_per_slot,
+                Some(0),
+                true,
+                &Arc::new(Keypair::new()),
+                entries,
+                0,
+            )
+            .unwrap();
+
+        let out_path = Path::new("test_chacha_encrypt_file_many_keys_single_output.txt.enc");
+
+        let samples = [0];
+        let mut ivecs = hex!(
+            "abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234
+                              abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234"
+        );
+
+        let mut cpu_iv = ivecs.clone();
+        chacha_cbc_encrypt_ledger(
+            &blockstore,
+            0,
+            slots_per_segment as u64,
+            out_path,
+            &mut cpu_iv,
+        )
+        .unwrap();
+
+        let ref_hash = sample_file(&out_path, &samples).unwrap();
+
+        let hashes = chacha_cbc_encrypt_file_many_keys(
+            &blockstore,
+            0,
+            slots_per_segment as u64,
+            &mut ivecs,
+            &samples,
+        )
+        .unwrap();
+
+        assert_eq!(hashes[0], ref_hash);
+
+        let _ignored = remove_dir_all(&ledger_path);
+        let _ignored = remove_file(out_path);
+    }
+
+    #[test]
+    fn test_encrypt_file_many_keys_multiple_keys() {
+        solana_logger::setup();
+        if perf_libs::api().is_none() {
+            info!("perf-libs unavailable, skipped");
+            return;
+        }
+
+        let ledger_path = get_tmp_ledger_path!();
+        let ticks_per_slot = 90;
+        let entries = create_ticks(2 * ticks_per_slot, 0, Hash::default());
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        blockstore
+            .write_entries(
+                0,
+                0,
+                0,
+                ticks_per_slot,
+                Some(0),
+                true,
+                &Arc::new(Keypair::new()),
+                entries,
+                0,
+            )
+            .unwrap();
+
+        let out_path = Path::new("test_chacha_encrypt_file_many_keys_multiple_output.txt.enc");
+
+        let samples = [0, 1, 3, 4, 5, 150];
+        let mut ivecs = Vec::new();
+        let mut ref_hashes: Vec<Hash> = vec![];
+        for i in 0..2 {
+            let mut ivec = hex!(
+                "abc123abc123abc123abc123abc123abc123abababababababababababababab
+                                 abc123abc123abc123abc123abc123abc123abababababababababababababab"
+            );
+            ivec[0] = i;
+            ivecs.extend(ivec.clone().iter());
+            chacha_cbc_encrypt_ledger(
+                &blockstore.clone(),
+                0,
+                DEFAULT_SLOTS_PER_SEGMENT,
+                out_path,
+                &mut ivec,
+            )
+            .unwrap();
+
+            ref_hashes.push(sample_file(&out_path, &samples).unwrap());
+            info!(
+                "ivec: {:?} hash: {:?} ivecs: {:?}",
+                ivec.to_vec(),
+                ref_hashes.last(),
+                ivecs
+            );
+        }
+
+        let hashes = chacha_cbc_encrypt_file_many_keys(
+            &blockstore,
+            0,
+            DEFAULT_SLOTS_PER_SEGMENT,
+            &mut ivecs,
+            &samples,
+        )
+        .unwrap();
+
+        assert_eq!(hashes, ref_hashes);
+
+        let _ignored = remove_dir_all(&ledger_path);
+        let _ignored = remove_file(out_path);
+    }
+
+    #[test]
+    fn test_encrypt_file_many_keys_bad_key_length() {
+        solana_logger::setup();
+        if perf_libs::api().is_none() {
+            info!("perf-libs unavailable, skipped");
+            return;
+        }
+
+        let mut keys = hex!("abc123");
+        let ledger_path = get_tmp_ledger_path!();
+        let samples = [0];
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        assert!(chacha_cbc_encrypt_file_many_keys(
+            &blockstore,
+            0,
+            DEFAULT_SLOTS_PER_SEGMENT,
+            &mut keys,
+            &samples,
+        )
+        .is_err());
+    }
+}

chacha-cuda/src/lib.rs

@@ -0,0 +1,8 @@
+#[macro_use]
+extern crate log;
+
+#[cfg(test)]
+#[macro_use]
+extern crate hex_literal;
+
+pub mod chacha_cuda;

chacha-sys/.gitignore

@@ -0,0 +1,2 @@
+/target/
+/farf/

chacha-sys/Cargo.toml

@@ -1,20 +1,15 @@
 [package]
-name = "solana-notifier"
-version = "1.2.0"
-description = "Solana Notifier"
+name = "solana-chacha-sys"
+version = "1.1.13"
+description = "Solana chacha-sys"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
 homepage = "https://solana.com/"
+license = "Apache-2.0"
 edition = "2018"
 
-[dependencies]
-log = "0.4.8"
-reqwest = { version = "0.10.4", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-serde_json = "1.0"
-
-[lib]
-name = "solana_notifier"
+[build-dependencies]
+cc = "1.0.49"
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

chacha-sys/build.rs

@@ -0,0 +1,8 @@
+extern crate cc;
+
+fn main() {
+    cc::Build::new()
+        .file("cpu-crypt/chacha20_core.c")
+        .file("cpu-crypt/chacha_cbc.c")
+        .compile("libcpu-crypt");
+}

chacha-sys/cpu-crypt/.gitignore

@@ -0,0 +1 @@
+release/

chacha-sys/cpu-crypt/Makefile

@@ -0,0 +1,25 @@
+V:=debug
+
+LIB:=cpu-crypt
+
+CFLAGS_common:=-Wall -Werror -pedantic -fPIC
+CFLAGS_release:=-march=native -O3 $(CFLAGS_common)
+CFLAGS_debug:=-g $(CFLAGS_common)
+CFLAGS:=$(CFLAGS_$V)
+
+all: $V/lib$(LIB).a
+
+$V/chacha20_core.o: chacha20_core.c chacha.h
+	@mkdir -p $(@D)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$V/chacha_cbc.o: chacha_cbc.c chacha.h
+	@mkdir -p $(@D)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$V/lib$(LIB).a: $V/chacha20_core.o $V/chacha_cbc.o
+	$(AR) rcs $@ $^
+
+.PHONY:clean
+clean:
+	rm -rf $V

chacha-sys/cpu-crypt/chacha.h

@@ -0,0 +1,35 @@
+#ifndef HEADER_CHACHA_H
+# define HEADER_CHACHA_H
+
+#include <string.h>
+#include <inttypes.h>
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+typedef unsigned int u32;
+
+#define CHACHA_KEY_SIZE 32
+#define CHACHA_NONCE_SIZE 12
+#define CHACHA_BLOCK_SIZE 64
+#define CHACHA_ROUNDS 500
+
+void chacha20_encrypt(const u32 input[16],
+                      unsigned char output[64],
+                      int num_rounds);
+
+void chacha20_encrypt_ctr(const uint8_t *in, uint8_t *out, size_t in_len,
+                          const uint8_t key[CHACHA_KEY_SIZE], const uint8_t nonce[CHACHA_NONCE_SIZE],
+                          uint32_t counter);
+
+void chacha20_cbc128_encrypt(const unsigned char* in, unsigned char* out,
+                             uint32_t len, const uint8_t* key,
+                             unsigned char* ivec);
+
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif

chacha-sys/cpu-crypt/chacha20_core.c

@@ -0,0 +1,102 @@
+#include "chacha.h"
+
+#define ROTL32(v, n) (((v) << (n)) | ((v) >> (32 - (n))))
+
+#define ROTATE(v, c) ROTL32((v), (c))
+
+#define XOR(v, w) ((v) ^ (w))
+
+#define PLUS(x, y) ((x) + (y))
+
+#define U32TO8_LITTLE(p, v) \
+{ (p)[0] = ((v)      ) & 0xff; (p)[1] = ((v) >>  8) & 0xff; \
+  (p)[2] = ((v) >> 16) & 0xff; (p)[3] = ((v) >> 24) & 0xff; }
+
+#define U8TO32_LITTLE(p)   \
+     (((u32)((p)[0])      ) | ((u32)((p)[1]) <<  8) | \
+      ((u32)((p)[2]) << 16) | ((u32)((p)[3]) << 24)   )
+
+#define QUARTERROUND(a,b,c,d) \
+  x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]),16); \
+  x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]),12); \
+  x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]), 8); \
+  x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]), 7);
+
+// sigma contains the ChaCha constants, which happen to be an ASCII string.
+static const uint8_t sigma[16] = { 'e', 'x', 'p', 'a', 'n', 'd', ' ', '3',
+                                   '2', '-', 'b', 'y', 't', 'e', ' ', 'k' };
+
+void chacha20_encrypt(const u32 input[16],
+                      unsigned char output[64],
+                      int num_rounds)
+{
+    u32 x[16];
+    int i;
+    memcpy(x, input, sizeof(u32) * 16);
+    for (i = num_rounds; i > 0; i -= 2) {
+        QUARTERROUND( 0, 4, 8,12)
+        QUARTERROUND( 1, 5, 9,13)
+        QUARTERROUND( 2, 6,10,14)
+        QUARTERROUND( 3, 7,11,15)
+        QUARTERROUND( 0, 5,10,15)
+        QUARTERROUND( 1, 6,11,12)
+        QUARTERROUND( 2, 7, 8,13)
+        QUARTERROUND( 3, 4, 9,14)
+    }
+    for (i = 0; i < 16; ++i) {
+        x[i] = PLUS(x[i], input[i]);
+    }
+    for (i = 0; i < 16; ++i) {
+        U32TO8_LITTLE(output + 4 * i, x[i]);
+    }
+}
+
+void chacha20_encrypt_ctr(const uint8_t *in, uint8_t *out, size_t in_len,
+                          const uint8_t key[CHACHA_KEY_SIZE],
+                          const uint8_t nonce[CHACHA_NONCE_SIZE],
+                          uint32_t counter)
+{
+  uint32_t input[16];
+  uint8_t buf[64];
+  size_t todo, i;
+
+  input[0] = U8TO32_LITTLE(sigma + 0);
+  input[1] = U8TO32_LITTLE(sigma + 4);
+  input[2] = U8TO32_LITTLE(sigma + 8);
+  input[3] = U8TO32_LITTLE(sigma + 12);
+
+  input[4] = U8TO32_LITTLE(key + 0);
+  input[5] = U8TO32_LITTLE(key + 4);
+  input[6] = U8TO32_LITTLE(key + 8);
+  input[7] = U8TO32_LITTLE(key + 12);
+
+  input[8] = U8TO32_LITTLE(key + 16);
+  input[9] = U8TO32_LITTLE(key + 20);
+  input[10] = U8TO32_LITTLE(key + 24);
+  input[11] = U8TO32_LITTLE(key + 28);
+
+  input[12] = counter;
+  input[13] = U8TO32_LITTLE(nonce + 0);
+  input[14] = U8TO32_LITTLE(nonce + 4);
+  input[15] = U8TO32_LITTLE(nonce + 8);
+
+  while (in_len > 0) {
+    todo = sizeof(buf);
+    if (in_len < todo) {
+      todo = in_len;
+    }
+
+    chacha20_encrypt(input, buf, 20);
+    for (i = 0; i < todo; i++) {
+      out[i] = in[i] ^ buf[i];
+    }
+
+    out += todo;
+    in += todo;
+    in_len -= todo;
+
+    input[12]++;
+  }
+}
+
+

chacha-sys/cpu-crypt/chacha_cbc.c

@@ -0,0 +1,72 @@
+#include "chacha.h"
+
+#if !defined(STRICT_ALIGNMENT) && !defined(PEDANTIC)
+# define STRICT_ALIGNMENT 0
+#endif
+
+void chacha20_cbc128_encrypt(const unsigned char* in, unsigned char* out,
+                             uint32_t len, const uint8_t* key,
+                             unsigned char* ivec)
+{
+    size_t n;
+    unsigned char *iv = ivec;
+    (void)key;
+
+    if (len == 0) {
+        return;
+    }
+
+#if !defined(OPENSSL_SMALL_FOOTPRINT)
+    if (STRICT_ALIGNMENT &&
+        ((size_t)in | (size_t)out | (size_t)ivec) % sizeof(size_t) != 0) {
+        while (len >= CHACHA_BLOCK_SIZE) {
+            for (n = 0; n < CHACHA_BLOCK_SIZE; ++n) {
+                out[n] = in[n] ^ iv[n];
+                //printf("%x ", out[n]);
+            }
+            chacha20_encrypt((const u32*)out, out, CHACHA_ROUNDS);
+            iv = out;
+            len -= CHACHA_BLOCK_SIZE;
+            in += CHACHA_BLOCK_SIZE;
+            out += CHACHA_BLOCK_SIZE;
+        }
+    } else {
+        while (len >= CHACHA_BLOCK_SIZE) {
+            for (n = 0; n < CHACHA_BLOCK_SIZE; n += sizeof(size_t)) {
+                *(size_t *)(out + n) =
+                    *(size_t *)(in + n) ^ *(size_t *)(iv + n);
+                //printf("%zu ", *(size_t *)(iv + n));
+            }
+            chacha20_encrypt((const u32*)out, out, CHACHA_ROUNDS);
+            iv = out;
+            len -= CHACHA_BLOCK_SIZE;
+            in += CHACHA_BLOCK_SIZE;
+            out += CHACHA_BLOCK_SIZE;
+        }
+    }
+#endif
+    while (len) {
+        for (n = 0; n < CHACHA_BLOCK_SIZE && n < len; ++n) {
+            out[n] = in[n] ^ iv[n];
+        }
+        for (; n < CHACHA_BLOCK_SIZE; ++n) {
+            out[n] = iv[n];
+        }
+        chacha20_encrypt((const u32*)out, out, CHACHA_ROUNDS);
+        iv = out;
+        if (len <= CHACHA_BLOCK_SIZE) {
+            break;
+        }
+        len -= CHACHA_BLOCK_SIZE;
+        in += CHACHA_BLOCK_SIZE;
+        out += CHACHA_BLOCK_SIZE;
+    }
+    memcpy(ivec, iv, CHACHA_BLOCK_SIZE);
+
+}
+
+void chacha20_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t in_len,
+                          const uint8_t key[CHACHA_KEY_SIZE], uint8_t* ivec)
+{
+    chacha20_cbc128_encrypt(in, out, in_len, key, ivec);
+}

chacha-sys/src/lib.rs

@@ -0,0 +1,21 @@
+extern "C" {
+    fn chacha20_cbc_encrypt(
+        input: *const u8,
+        output: *mut u8,
+        in_len: usize,
+        key: *const u8,
+        ivec: *mut u8,
+    );
+}
+
+pub fn chacha_cbc_encrypt(input: &[u8], output: &mut [u8], key: &[u8], ivec: &mut [u8]) {
+    unsafe {
+        chacha20_cbc_encrypt(
+            input.as_ptr(),
+            output.as_mut_ptr(),
+            input.len(),
+            key.as_ptr(),
+            ivec.as_mut_ptr(),
+        );
+    }
+}

chacha/.gitignore

@@ -0,0 +1 @@
+/farf/

chacha/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "solana-chacha"
+version = "1.1.13"
+description = "Solana Chacha APIs"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+log = "0.4.8"
+rand = "0.7.0"
+rand_chacha = "0.2.2"
+solana-chacha-sys = { path = "../chacha-sys", version = "1.1.13" }
+solana-ledger = { path = "../ledger", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-perf = { path = "../perf", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+
+[dev-dependencies]
+hex-literal = "0.2.1"
+
+[lib]
+name = "solana_chacha"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

chacha/src/chacha.rs

@@ -0,0 +1,185 @@
+use solana_ledger::blockstore::Blockstore;
+use solana_sdk::clock::Slot;
+use std::fs::File;
+use std::io;
+use std::io::{BufWriter, Write};
+use std::path::Path;
+use std::sync::Arc;
+
+pub use solana_chacha_sys::chacha_cbc_encrypt;
+
+pub const CHACHA_BLOCK_SIZE: usize = 64;
+pub const CHACHA_KEY_SIZE: usize = 32;
+
+pub fn chacha_cbc_encrypt_ledger(
+    blockstore: &Arc<Blockstore>,
+    start_slot: Slot,
+    slots_per_segment: u64,
+    out_path: &Path,
+    ivec: &mut [u8; CHACHA_BLOCK_SIZE],
+) -> io::Result<usize> {
+    let mut out_file =
+        BufWriter::new(File::create(out_path).expect("Can't open ledger encrypted data file"));
+    const BUFFER_SIZE: usize = 8 * 1024;
+    let mut buffer = [0; BUFFER_SIZE];
+    let mut encrypted_buffer = [0; BUFFER_SIZE];
+    let key = [0; CHACHA_KEY_SIZE];
+    let mut total_size = 0;
+    let mut current_slot = start_slot;
+    let mut start_index = 0;
+    loop {
+        match blockstore.get_data_shreds(current_slot, start_index, std::u64::MAX, &mut buffer) {
+            Ok((last_index, mut size)) => {
+                debug!(
+                    "chacha: encrypting slice: {} num_shreds: {} data_len: {}",
+                    current_slot,
+                    last_index.saturating_sub(start_index),
+                    size
+                );
+                debug!("read {} bytes", size);
+
+                if size == 0 {
+                    if current_slot.saturating_sub(start_slot) < slots_per_segment {
+                        current_slot += 1;
+                        start_index = 0;
+                        continue;
+                    } else {
+                        break;
+                    }
+                }
+
+                if size < BUFFER_SIZE {
+                    // round to the nearest key_size boundary
+                    size = (size + CHACHA_KEY_SIZE - 1) & !(CHACHA_KEY_SIZE - 1);
+                }
+                total_size += size;
+
+                chacha_cbc_encrypt(&buffer[..size], &mut encrypted_buffer[..size], &key, ivec);
+                if let Err(res) = out_file.write(&encrypted_buffer[..size]) {
+                    warn!("Error writing file! {:?}", res);
+                    return Err(res);
+                }
+
+                start_index = last_index + 1;
+            }
+            Err(e) => {
+                info!("Error encrypting file: {:?}", e);
+                break;
+            }
+        }
+    }
+    Ok(total_size)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::chacha::chacha_cbc_encrypt_ledger;
+    use rand::SeedableRng;
+    use rand_chacha::ChaChaRng;
+    use solana_ledger::blockstore::Blockstore;
+    use solana_ledger::entry::Entry;
+    use solana_ledger::get_tmp_ledger_path;
+    use solana_sdk::hash::{hash, Hash, Hasher};
+    use solana_sdk::pubkey::Pubkey;
+    use solana_sdk::signature::{Keypair, Signer};
+    use solana_sdk::system_transaction;
+    use std::fs::remove_file;
+    use std::fs::File;
+    use std::io::Read;
+    use std::sync::Arc;
+
+    fn make_tiny_deterministic_test_entries(num: usize) -> Vec<Entry> {
+        let zero = Hash::default();
+        let one = hash(&zero.as_ref());
+
+        let seed = [2u8; 32];
+
+        let mut generator = ChaChaRng::from_seed(seed);
+        let keypair = Keypair::generate(&mut generator);
+
+        let mut id = one;
+        let mut num_hashes = 0;
+        (0..num)
+            .map(|_| {
+                Entry::new_mut(
+                    &mut id,
+                    &mut num_hashes,
+                    vec![system_transaction::transfer(
+                        &keypair,
+                        &keypair.pubkey(),
+                        1,
+                        one,
+                    )],
+                )
+            })
+            .collect()
+    }
+
+    use std::{env, fs::create_dir_all, path::PathBuf};
+    fn tmp_file_path(name: &str) -> PathBuf {
+        let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
+        let mut path = PathBuf::new();
+        path.push(out_dir);
+        path.push("tmp");
+        create_dir_all(&path).unwrap();
+
+        path.push(format!("{}-{}", name, Pubkey::new_rand()));
+        path
+    }
+
+    #[test]
+    fn test_encrypt_ledger() {
+        solana_logger::setup();
+        let ledger_path = get_tmp_ledger_path!();
+        let ticks_per_slot = 16;
+        let slots_per_segment = 32;
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        let out_path = tmp_file_path("test_encrypt_ledger");
+
+        let seed = [2u8; 32];
+
+        let mut generator = ChaChaRng::from_seed(seed);
+        let keypair = Keypair::generate(&mut generator);
+
+        let entries = make_tiny_deterministic_test_entries(slots_per_segment);
+        blockstore
+            .write_entries(
+                0,
+                0,
+                0,
+                ticks_per_slot,
+                None,
+                true,
+                &Arc::new(keypair),
+                entries,
+                0,
+            )
+            .unwrap();
+
+        let mut key = hex!(
+            "abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234
+                            abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234"
+        );
+        chacha_cbc_encrypt_ledger(
+            &blockstore,
+            0,
+            slots_per_segment as u64,
+            &out_path,
+            &mut key,
+        )
+        .unwrap();
+        let mut out_file = File::open(&out_path).unwrap();
+        let mut buf = vec![];
+        let size = out_file.read_to_end(&mut buf).unwrap();
+        let mut hasher = Hasher::default();
+        hasher.hash(&buf[..size]);
+
+        //  golden needs to be updated if shred structure changes....
+        let golden: Hash = "2rq8nR6rns2T5zsbQAGBDZb41NVtacneLgkCH17CVxZm"
+            .parse()
+            .unwrap();
+
+        assert_eq!(hasher.result(), golden);
+        remove_file(&out_path).unwrap();
+    }
+}

chacha/src/lib.rs

@@ -0,0 +1,8 @@
+#[macro_use]
+extern crate log;
+
+#[cfg(test)]
+#[macro_use]
+extern crate hex_literal;
+
+pub mod chacha;

ci/README.md

@@ -2,7 +2,7 @@
 Our CI infrastructure is built around [BuildKite](https://buildkite.com) with some
 additional GitHub integration provided by https://github.com/mvines/ci-gate
 
-# Agent Queues
+## Agent Queues
 
 We define two [Agent Queues](https://buildkite.com/docs/agent/v3/queues):
 `queue=default` and `queue=cuda`.  The `default` queue should be favored and
@@ -12,52 +12,9 @@ be run on the `default` queue, and the [buildkite artifact
 system](https://buildkite.com/docs/builds/artifacts) used to transfer build
 products over to a GPU instance for testing.
 
-# Buildkite Agent Management
+## Buildkite Agent Management
 
-## Manual Node Setup for Colocated Hardware
-
-This section describes how to set up a new machine that does not have a
-pre-configured image with all the requirements installed.  Used for custom-built
-hardware at a colocation or office facility.  Also works for vanilla Ubuntu cloud
-instances.
-
-### Pre-Requisites
-
- - Install Ubuntu 18.04 LTS Server
- - Log in as a local or remote user with `sudo` privileges
-
-### Install Core Requirements
-
-##### Non-GPU enabled machines
-```bash
-sudo ./setup-new-buildkite-agent/setup-new-machine.sh
-```
-
-##### GPU-enabled machines
- - 1 or more NVIDIA GPUs should be installed in the machine (tested with 2080Ti)
-```bash
-sudo CUDA=1 ./setup-new-buildkite-agent/setup-new-machine.sh
-```
-
-### Configure Node for Buildkite-agent based CI
-
-- Install `buildkite-agent` and set up it user environment with:
-```bash
-sudo ./setup-new-buildkite-agent/setup-buildkite.sh
-```
-- Copy the pubkey contents from `~buildkite-agent/.ssh/id_ecdsa.pub` and
-add the pubkey as an authorized SSH key on github.
-- Edit `/etc/buildkite-agent/buildkite-agent.cfg` and/or `/etc/systemd/system/buildkite-agent@*` to the desired configuration of the agent(s)
-- Copy `ejson` keys from another CI node at `/opt/ejson/keys/`
-to the same location on the new node.
-- Start the new agent(s) with `sudo systemctl enable --now buildkite-agent`
-
-# Reference
-
-This section contains details regarding previous CI setups that have been used,
-and that we may return to one day.
-
-## Buildkite Azure Setup
+### Buildkite Azure Setup
 
 Create a new Azure-based "queue=default" agent by running the following command:
 ```
@@ -78,7 +35,7 @@ Creating a "queue=cuda" agent follows the same process but additionally:
 2. Edit the tags field in /etc/buildkite-agent/buildkite-agent.cfg to `tags="queue=cuda,queue=default"`
    and decrease the value of the priority field by one
 
-### Updating the CI Disk Image
+#### Updating the CI Disk Image
 
 1. Create a new VM Instance as described above
 1. Modify it as required
@@ -91,7 +48,12 @@ Creating a "queue=cuda" agent follows the same process but additionally:
 1. Goto the `ci` resource group in the Azure portal and remove all resources
    with the XYZ name in them
 
-## Buildkite AWS CloudFormation Setup
+## Reference
+
+This section contains details regarding previous CI setups that have been used,
+and that we may return to one day.
+
+### Buildkite AWS CloudFormation Setup
 
 **AWS CloudFormation is currently inactive, although it may be restored in the
 future**
@@ -100,7 +62,7 @@ AWS CloudFormation can be used to scale machines up and down based on the
 current CI load.  If no machine is currently running it can take up to 60
 seconds to spin up a new instance, please remain calm during this time.
 
-### AMI
+#### AMI
 We use a custom AWS AMI built via https://github.com/solana-labs/elastic-ci-stack-for-aws/tree/solana/cuda.
 
 Use the following process to update this AMI as dependencies change:
@@ -122,13 +84,13 @@ The new AMI should also now be visible in your EC2 Dashboard.  Go to the desired
 AWS CloudFormation stack, update the **ImageId** field to the new AMI id, and
 *apply* the stack changes.
 
-## Buildkite GCP Setup
+### Buildkite GCP Setup
 
 CI runs on Google Cloud Platform via two Compute Engine Instance groups:
 `ci-default` and `ci-cuda`.  Autoscaling is currently disabled and the number of
 VM Instances in each group is manually adjusted.
 
-### Updating a CI Disk Image
+#### Updating a CI Disk Image
 
 Each Instance group has its own disk image, `ci-default-vX` and
 `ci-cuda-vY`, where *X* and *Y* are incremented each time the image is changed.

ci/buildkite.yml

@@ -5,13 +5,6 @@
 # Release tags use buildkite-release.yml instead
 
 steps:
-  - command: "ci/dependabot-pr.sh"
-    name: "dependabot"
-    timeout_in_minutes: 5
-    if: build.env("GITHUB_USER") == "dependabot-preview[bot]"
-
-  - wait
-
   - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_nightly_docker_image ci/test-checks.sh"
     name: "checks"
     timeout_in_minutes: 20

ci/dependabot-pr.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-cd "$(dirname "$0")/.."
-
-if ! echo "$BUILDKITE_BRANCH" | grep -E '^pull/[0-9]+/head$'; then
-  echo "not pull request!?" >&2
-  exit 1
-fi
-
-source ci/rust-version.sh stable
-
-ci/docker-run.sh $rust_nightly_docker_image ci/dependabot-updater.sh
-
-if [[ $(git status --short :**/Cargo.lock | wc -l) -eq 0 ]]; then
-  echo --- ok
-  exit 0
-fi
-
-echo --- "(FAILING) Backpropagating dependabot-triggered Cargo.lock updates"
-
-name="dependabot-buildkite"
-api_base="https://api.github.com/repos/solana-labs/solana/pulls"
-pr_num=$(echo "$BUILDKITE_BRANCH" | grep -Eo '[0-9]+')
-branch=$(curl -s "$api_base/$pr_num" | python -c 'import json,sys;print json.load(sys.stdin)["head"]["ref"]')
-
-git add :**/Cargo.lock
-EMAIL="dependabot-buildkite@noreply.solana.com" \
-  GIT_AUTHOR_NAME="$name" \
-  GIT_COMMITTER_NAME="$name" \
-  git commit -m "[auto-commit] Update all Cargo lock files"
-git push origin "HEAD:$branch"
-
-echo "Source branch is updated; failing this build for the next"
-exit 1

ci/dependabot-updater.sh

@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-cd "$(dirname "$0")/.."
-source ci/_
-
-commit_range="$(git merge-base HEAD origin/master)..HEAD"
-parsed_update_args="$(
-  git log "$commit_range" --author "dependabot-preview" --oneline -n1 |
-    grep -o 'Bump.*$' |
-    sed -r 's/Bump ([^ ]+) from ([^ ]+) to ([^ ]+)/-p \1:\2 --precise \3/'
-)"
-# relaxed_parsed_update_args is temporal measure...
-relaxed_parsed_update_args="$(
-  git log "$commit_range" --author "dependabot-preview" --oneline -n1 |
-    grep -o 'Bump.*$' |
-    sed -r 's/Bump ([^ ]+) from [^ ]+ to ([^ ]+)/-p \1 --precise \2/'
-)"
-package=$(echo "$parsed_update_args" | awk '{print $2}' | grep -o "^[^:]*")
-if [[ -n $parsed_update_args ]]; then
-  # find other Cargo.lock files and update them, excluding the default Cargo.lock
-  # shellcheck disable=SC2086
-  for lock in $(git grep --files-with-matches '^name = "'$package'"$' :**/Cargo.lock); do
-    # it's possible our current versions are out of sync across lock files,
-    # in that case try to sync them up with $relaxed_parsed_update_args
-    _ scripts/cargo-for-all-lock-files.sh \
-      "$lock" -- \
-      update $parsed_update_args ||
-      _ scripts/cargo-for-all-lock-files.sh \
-        "$lock" -- \
-        update $relaxed_parsed_update_args
-  done
-fi
-
-echo --- ok

ci/iterations-localnet.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -e
+
+testCmd="$*"
+genPipeline=false
+
+cd "$(dirname "$0")/.."
+
+# Clear cached json keypair files
+rm -rf "$HOME/.config/solana"
+
+source ci/_
+export RUST_BACKTRACE=1
+export RUSTFLAGS="-D warnings"
+export PATH=$PWD/target/debug:$PATH
+export USE_INSTALL=1
+
+if [[ -n $BUILDKITE && -z $testCmd ]]; then
+  genPipeline=true
+  echo "
+steps:
+  "
+fi
+
+build() {
+  $genPipeline && return
+  source ci/rust-version.sh stable
+  source scripts/ulimit-n.sh
+  _ cargo +$rust_stable build
+}
+
+runTest() {
+  declare runTestName="$1"
+  declare runTestCmd="$2"
+  if $genPipeline; then
+    echo "
+  - command: \"$0 '$runTestCmd'\"
+    name: \"$runTestName\"
+    timeout_in_minutes: 45
+"
+    return
+  fi
+
+  if [[ -n $testCmd && "$testCmd" != "$runTestCmd" ]]; then
+    echo Skipped "$runTestName"...
+    return
+  fi
+  #shellcheck disable=SC2068 # Don't want to double quote $runTestCmd
+  $runTestCmd
+}
+
+build
+
+runTest "basic" \
+  "ci/localnet-sanity.sh -i 128"
+
+runTest "restart" \
+  "ci/localnet-sanity.sh -i 128 -k 16"
+
+runTest "incremental restart, extra node" \
+  "ci/localnet-sanity.sh -i 128 -k 16 -R -x"

ci/localnet-sanity.sh

@@ -73,15 +73,16 @@ source scripts/configure-metrics.sh
 source multinode-demo/common.sh
 
 nodes=(
+  "multinode-demo/faucet.sh"
   "multinode-demo/bootstrap-validator.sh \
     --no-restart \
-    --init-complete-file init-complete-node0.log \
+    --init-complete-file init-complete-node1.log \
     --dynamic-port-range 8000-8050"
   "multinode-demo/validator.sh \
     --enable-rpc-exit \
     --no-restart \
     --dynamic-port-range 8050-8100
-    --init-complete-file init-complete-node1.log \
+    --init-complete-file init-complete-node2.log \
     --rpc-port 18899"
 )
 
@@ -94,7 +95,7 @@ if [[ extraNodes -gt 0 ]]; then
         --no-restart \
         --dynamic-port-range $portStart-$portEnd
         --label dyn$i \
-        --init-complete-file init-complete-node$((1 + i)).log"
+        --init-complete-file init-complete-node$((2 + i)).log"
     )
   done
 fi
@@ -159,10 +160,11 @@ startNodes() {
   for i in $(seq 0 $((${#nodes[@]} - 1))); do
     declare cmd=${nodes[$i]}
 
-    declare initCompleteFile="init-complete-node$i.log"
-    rm -f "$initCompleteFile"
-    initCompleteFiles+=("$initCompleteFile")
-
+    if [[ "$i" -ne 0 ]]; then # 0 == faucet, skip it
+      declare initCompleteFile="init-complete-node$i.log"
+      rm -f "$initCompleteFile"
+      initCompleteFiles+=("$initCompleteFile")
+    fi
     startNode "$i" "$cmd $maybeExpectedGenesisHash"
     if $addLogs; then
       logs+=("$(getNodeLogFile "$i" "$cmd")")

ci/publish-docs.sh

@@ -3,22 +3,21 @@ set -e
 
 cd "$(dirname "$0")/.."
 
-echo --- build docs
-(
-  set -x
-  . ci/rust-version.sh stable
-  ci/docker-run.sh "$rust_stable_docker_image" docs/build.sh
-)
+me=$(basename "$0")
 
 echo --- update gitbook-cage
 if [[ -n $CI_BRANCH ]]; then
   (
-    # make a local commit for the svgs and generated/updated markdown
     set -x
+    (
+      . ci/rust-version.sh stable
+      ci/docker-run.sh "$rust_stable_docker_image" make -C docs
+    )
+    # make a local commit for the svgs and generated/updated markdown
     git add -f docs/src
     if ! git diff-index --quiet HEAD; then
       git config user.email maintainers@solana.com
-      git config user.name "$(basename "$0")"
+      git config user.name "$me"
       git commit -m "gitbook-cage update $(date -Is)"
       git push -f git@github.com:solana-labs/solana-gitbook-cage.git HEAD:refs/heads/"$CI_BRANCH"
       # pop off the local commit

ci/run-sanity.sh

@@ -2,10 +2,8 @@
 set -e
 
 cd "$(dirname "$0")/.."
-# shellcheck source=multinode-demo/common.sh
-source multinode-demo/common.sh
 
-rm -rf config/run/init-completed config/ledger config/snapshot-ledger
+rm -f config/run/init-completed
 
 timeout 15 ./run.sh &
 pid=$!
@@ -19,13 +17,6 @@ while [[ ! -f config/run/init-completed ]]; do
   fi
 done
 
-while [[ $($solana_cli slot --commitment recent) -eq 0 ]]; do
-  sleep 1
-done
 curl -X POST -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1, "method":"validatorExit"}' http://localhost:8899
 
 wait $pid
-
-$solana_ledger_tool create-snapshot --ledger config/ledger 1 config/snapshot-ledger
-cp config/ledger/genesis.tar.bz2 config/snapshot-ledger
-$solana_ledger_tool verify --ledger config/snapshot-ledger

ci/setup-new-buildkite-agent/enable-buildkite.sh

@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-
-sudo systemctl daemon-reload
-sudo systemctl enable --now buildkite-agent

ci/setup-new-buildkite-agent/setup-buildkite.sh

@@ -1,84 +0,0 @@
-#!/usr/bin/env bash
-
-HERE="$(dirname "$0")"
-
-# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
-source "$HERE"/utils.sh
-
-ensure_env || exit 1
-
-set -e
-
-# Install buildkite-agent
-echo "deb https://apt.buildkite.com/buildkite-agent stable main" | tee /etc/apt/sources.list.d/buildkite-agent.list
-apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 32A37959C2FA5C3C99EFBC32A79206696452D198
-apt-get update
-apt-get install -y buildkite-agent
-
-
-# Configure the installation
-echo "Go to https://buildkite.com/organizations/solana-labs/agents"
-echo "Click Reveal Agent Token"
-echo "Paste the Agent Token, then press Enter:"
-
-read -r agent_token
-sudo sed -i "s/xxx/$agent_token/g" /etc/buildkite-agent/buildkite-agent.cfg
-
-cat > /etc/buildkite-agent/hooks/environment <<EOF
-set -e
-
-export BUILDKITE_GIT_CLEAN_FLAGS="-ffdqx"
-
-# Hack for non-docker rust builds
-export PATH='$PATH':~buildkite-agent/.cargo/bin
-
-# Add path to snaps
-source /etc/profile.d/apps-bin-path.sh
-
-if [[ '$BUILDKITE_BRANCH' =~ pull/* ]]; then
-  export BUILDKITE_REFSPEC="+'$BUILDKITE_BRANCH':refs/remotes/origin/'$BUILDKITE_BRANCH'"
-fi
-EOF
-
-chown buildkite-agent:buildkite-agent /etc/buildkite-agent/hooks/environment
-
-# Create SSH key
-sudo -u buildkite-agent mkdir -p ~buildkite-agent/.ssh
-sudo -u buildkite-agent ssh-keygen -t ecdsa -q -N "" -f ~buildkite-agent/.ssh/id_ecdsa
-
-# Set buildkite-agent user's shell
-sudo usermod --shell /bin/bash buildkite-agent
-
-# Install Rust for buildkite-agent
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o /tmp/rustup-init.sh
-sudo -u buildkite-agent HOME=~buildkite-agent sh /tmp/rustup-init.sh -y
-
-# Add to docker and sudoers group
-addgroup buildkite-agent docker
-addgroup buildkite-agent sudo
-
-# Edit the systemd unit file to include LimitNOFILE
-cat > /lib/systemd/system/buildkite-agent.service <<EOF
-[Unit]
-Description=Buildkite Agent
-Documentation=https://buildkite.com/agent
-After=syslog.target
-After=network.target
-
-[Service]
-Type=simple
-User=buildkite-agent
-Environment=HOME=/var/lib/buildkite-agent
-ExecStart=/usr/bin/buildkite-agent start
-RestartSec=5
-Restart=on-failure
-RestartForceExitStatus=SIGPIPE
-TimeoutStartSec=10
-TimeoutStopSec=0
-KillMode=process
-LimitNOFILE=65536
-
-[Install]
-WantedBy=multi-user.target
-DefaultInstance=1
-EOF

ci/setup-new-buildkite-agent/setup-new-machine.sh

@@ -1,49 +0,0 @@
-#!/usr/bin/env bash
-
-HERE="$(dirname "$0")"
-SOLANA_ROOT="$HERE"/../..
-
-# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
-source "$HERE"/utils.sh
-
-ensure_env || exit 1
-
-set -ex
-
-apt update
-apt upgrade -y
-
-cat >/etc/apt/apt.conf.d/99-solana <<'EOF'
-// Set and persist extra caps on iftop binary
-Dpkg::Post-Invoke { "which iftop 2>&1 >/dev/null && setcap cap_net_raw=eip $(which iftop) || true"; };
-EOF
-
-apt install -y build-essential pkg-config clang cmake sysstat linux-tools-common \
-  linux-generic-hwe-18.04-edge linux-tools-generic-hwe-18.04-edge \
-  iftop heaptrack jq ruby python3-venv gcc-multilib libudev-dev
-
-gem install ejson ejson2env
-mkdir -p /opt/ejson/keys
-
-"$SOLANA_ROOT"/net/scripts/install-docker.sh
-usermod -aG docker "$SETUP_USER"
-"$SOLANA_ROOT"/net/scripts/install-certbot.sh
-"$HERE"/setup-sudoers.sh
-"$HERE"/setup-ssh.sh
-
-"$HERE"/disable-nouveau.sh
-"$HERE"/disable-networkd-wait.sh
-
-"$SOLANA_ROOT"/net/scripts/install-earlyoom.sh
-"$SOLANA_ROOT"/net/scripts/install-nodejs.sh
-"$SOLANA_ROOT"/net/scripts/localtime.sh
-"$SOLANA_ROOT"/net/scripts/install-redis.sh
-"$SOLANA_ROOT"/net/scripts/install-rsync.sh
-"$SOLANA_ROOT"/net/scripts/install-libssl-compatability.sh
-
-"$HERE"/setup-procfs-knobs.sh
-"$HERE"/setup-limits.sh
-
-[[ -n $CUDA ]] && "$HERE"/setup-cuda.sh
-
-exit 0

ci/test-checks.sh

@@ -13,22 +13,16 @@ export RUSTFLAGS="-D warnings"
 # Look for failed mergify.io backports
 _ git show HEAD --check --oneline
 
-if _ scripts/cargo-for-all-lock-files.sh +"$rust_nightly" check --locked --all-targets; then
-  true
-else
-  check_status=$?
-  echo "Some Cargo.lock is outdated; please update them as well"
-  echo "protip: you can use ./scripts/cargo-for-all-lock-files.sh update ..."
-  exit "$check_status"
-fi
-
 _ cargo +"$rust_stable" fmt --all -- --check
 
+# Clippy gets stuck for unknown reasons if sdk-c is included in the build, so check it separately.
+# See https://github.com/solana-labs/solana/issues/5503
 _ cargo +"$rust_stable" clippy --version
-_ cargo +"$rust_stable" clippy --workspace -- --deny=warnings
+_ cargo +"$rust_stable" clippy --all --exclude solana-sdk-c -- --deny=warnings
+_ cargo +"$rust_stable" clippy --manifest-path sdk-c/Cargo.toml -- --deny=warnings
 
 _ cargo +"$rust_stable" audit --version
-_ scripts/cargo-for-all-lock-files.sh +"$rust_stable" audit --ignore RUSTSEC-2020-0002 --ignore RUSTSEC-2020-0008
+_ cargo +"$rust_stable" audit --ignore RUSTSEC-2020-0002 --ignore RUSTSEC-2020-0008
 _ ci/nits.sh
 _ ci/order-crates-for-publishing.py
 _ docs/build.sh

ci/test-stable.sh

@@ -47,7 +47,7 @@ echo "Executing $testName"
 case $testName in
 test-stable)
   _ cargo +"$rust_stable" test --jobs "$NPROC" --all --exclude solana-local-cluster ${V:+--verbose} -- --nocapture
-  _ cargo +"$rust_stable" test --manifest-path bench-tps/Cargo.toml --features=move ${V:+--verbose} test_bench_tps_local_cluster_move -- --nocapture
+  #_ cargo +"$rust_stable" test --manifest-path bench-tps/Cargo.toml --features=move ${V:+--verbose} test_bench_tps_local_cluster_move -- --nocapture
   ;;
 test-stable-perf)
   ci/affects-files.sh \
@@ -91,7 +91,7 @@ test-stable-perf)
   fi
 
   _ cargo +"$rust_stable" build --bins ${V:+--verbose}
-  _ cargo +"$rust_stable" test --package solana-perf --package solana-ledger --package solana-core --lib ${V:+--verbose} -- --nocapture
+  _ cargo +"$rust_stable" test --package solana-chacha-cuda --package solana-perf --package solana-ledger --package solana-core --lib ${V:+--verbose} -- --nocapture
   ;;
 test-move)
   ci/affects-files.sh \

ci/testnet-deploy.sh

@@ -0,0 +1,429 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")"/..
+source ci/upload-ci-artifact.sh
+
+zone=
+bootstrapValidatorAddress=
+bootstrapValidatorMachineType=
+clientNodeCount=0
+idleClients=false
+additionalValidatorCount=10
+publicNetwork=false
+stopNetwork=false
+reuseLedger=false
+skipCreate=false
+skipStart=false
+externalNode=false
+failOnValidatorBootupFailure=true
+tarChannelOrTag=edge
+delete=false
+enableGpu=false
+bootDiskType=""
+blockstreamer=false
+fetchLogs=true
+maybeHashesPerTick=
+maybeDisableAirdrops=
+maybeInternalNodesStakeLamports=
+maybeInternalNodesLamports=
+maybeExternalPrimordialAccountsFile=
+maybeSlotsPerEpoch=
+maybeTargetLamportsPerSignature=
+maybeSlotsPerEpoch=
+maybeLetsEncrypt=
+maybeValidatorAdditionalDiskSize=
+maybeNoSnapshot=
+maybeLimitLedgerSize=
+
+usage() {
+  exitcode=0
+  if [[ -n "$1" ]]; then
+    exitcode=1
+    echo "Error: $*"
+  fi
+  cat <<EOF
+usage: $0 -p network-name -C cloud -z zone1 [-z zone2] ... [-z zoneN] [options...]
+
+Deploys a CD testnet
+
+  mandatory arguments:
+  -p [network-name]  - name of the network
+  -C [cloud] - cloud provider to use (gce, ec2)
+  -z [zone]  - cloud provider zone to deploy the network into.  Must specify at least one zone
+
+  options:
+   -t edge|beta|stable|vX.Y.Z  - Deploy the latest tarball release for the
+                                 specified release channel (edge|beta|stable) or release tag
+                                 (vX.Y.Z)
+                                 (default: $tarChannelOrTag)
+   -n [number]          - Number of additional validators (default: $additionalValidatorCount)
+   -c [number]          - Number of client bencher nodes (default: $clientNodeCount)
+   -u                   - Include a Blockstreamer (default: $blockstreamer)
+   -P                   - Use public network IP addresses (default: $publicNetwork)
+   -G                   - Enable GPU, and set count/type of GPUs to use (e.g n1-standard-16 --accelerator count=2,type=nvidia-tesla-v100)
+   -g                   - Enable GPU (default: $enableGpu)
+   -a [address]         - Set the bootstrap validator's external IP address to this GCE address
+   -d [disk-type]       - Specify a boot disk type (default None) Use pd-ssd to get ssd on GCE.
+   -D                   - Delete the network
+   -r                   - Reuse existing node/ledger configuration from a
+                          previous |start| (ie, don't run ./multinode-demo/setup.sh).
+   -x                   - External node.  Default: false
+   -e                   - Skip create.  Assume the nodes have already been created
+   -s                   - Skip start.  Nodes will still be created or configured, but network software will not be started.
+   -S                   - Stop network software without tearing down nodes.
+   -f                   - Discard validator nodes that didn't bootup successfully
+   --no-airdrop
+                        - If set, disables airdrops.  Nodes must be funded in genesis config when airdrops are disabled.
+   --internal-nodes-stake-lamports NUM_LAMPORTS
+                        - Amount to stake internal nodes.
+   --internal-nodes-lamports NUM_LAMPORTS
+                        - Amount to fund internal nodes in genesis config
+   --external-accounts-file FILE_PATH
+                        - Path to external Primordial Accounts file, if it exists.
+   --hashes-per-tick NUM_HASHES|sleep|auto
+                        - Override the default --hashes-per-tick for the cluster
+   --lamports NUM_LAMPORTS
+                        - Specify the number of lamports to mint (default 500000000000000000)
+   --skip-deploy-update
+                        - If set, will skip software update deployment
+   --skip-remote-log-retrieval
+                        - If set, will not fetch logs from remote nodes
+   --letsencrypt [dns name]
+                        - Attempt to generate a TLS certificate using this DNS name
+   --validator-additional-disk-size-gb [number]
+                        - Size of additional disk in GB for all validators
+   --no-snapshot-fetch
+                        - If set, disables booting validators from a snapshot
+
+   Note: the SOLANA_METRICS_CONFIG environment variable is used to configure
+         metrics
+EOF
+  exit $exitcode
+}
+
+zone=()
+
+shortArgs=()
+while [[ -n $1 ]]; do
+  if [[ ${1:0:2} = -- ]]; then
+    if [[ $1 = --hashes-per-tick ]]; then
+      maybeHashesPerTick="$1 $2"
+      shift 2
+    elif [[ $1 = --slots-per-epoch ]]; then
+      maybeSlotsPerEpoch="$1 $2"
+      shift 2
+    elif [[ $1 = --target-lamports-per-signature ]]; then
+      maybeTargetLamportsPerSignature="$1 $2"
+      shift 2
+    elif [[ $1 = --no-airdrop ]]; then
+      maybeDisableAirdrops=$1
+      shift 1
+    elif [[ $1 = --internal-nodes-stake-lamports ]]; then
+      maybeInternalNodesStakeLamports="$1 $2"
+      shift 2
+    elif [[ $1 = --internal-nodes-lamports ]]; then
+      maybeInternalNodesLamports="$1 $2"
+      shift 2
+    elif [[ $1 = --external-accounts-file ]]; then
+      maybeExternalPrimordialAccountsFile="$1 $2"
+      shift 2
+    elif [[ $1 = --skip-remote-log-retrieval ]]; then
+      fetchLogs=false
+      shift 1
+    elif [[ $1 = --letsencrypt ]]; then
+      maybeLetsEncrypt="$1 $2"
+      shift 2
+    elif [[ $1 = --validator-additional-disk-size-gb ]]; then
+      maybeValidatorAdditionalDiskSize="$1 $2"
+      shift 2
+    elif [[ $1 == --machine-type* ]]; then # Bypass quoted long args for GPUs
+      shortArgs+=("$1")
+      shift
+    elif [[ $1 = --no-snapshot-fetch ]]; then
+      maybeNoSnapshot=$1
+      shift 1
+    elif [[ $1 = --limit-ledger-size ]]; then
+      maybeLimitLedgerSize=$1
+      shift 1
+    elif [[ $1 = --idle-clients ]]; then
+      idleClients=true
+      shift 1
+    else
+      usage "Unknown long option: $1"
+    fi
+  else
+    shortArgs+=("$1")
+    shift
+  fi
+done
+
+while getopts "h?p:Pn:c:t:gG:a:Dd:rusxz:p:C:Sfe" opt "${shortArgs[@]}"; do
+  case $opt in
+  h | \?)
+    usage
+    ;;
+  p)
+    netName=$OPTARG
+    ;;
+  C)
+    cloudProvider=$OPTARG
+    ;;
+  z)
+    zone+=("$OPTARG")
+    ;;
+  P)
+    publicNetwork=true
+    ;;
+  n)
+    additionalValidatorCount=$OPTARG
+    ;;
+  c)
+    clientNodeCount=$OPTARG
+    ;;
+  t)
+    case $OPTARG in
+    edge|beta|stable|v*)
+      tarChannelOrTag=$OPTARG
+      ;;
+    *)
+      usage "Invalid release channel: $OPTARG"
+      ;;
+    esac
+    ;;
+  g)
+    enableGpu=true
+    ;;
+  G)
+    enableGpu=true
+    bootstrapValidatorMachineType=$OPTARG
+    ;;
+  a)
+    bootstrapValidatorAddress=$OPTARG
+    ;;
+  d)
+    bootDiskType=$OPTARG
+    ;;
+  D)
+    delete=true
+    ;;
+  r)
+    reuseLedger=true
+    ;;
+  e)
+    skipCreate=true
+    ;;
+  s)
+    skipStart=true
+    ;;
+  x)
+    externalNode=true
+    ;;
+  f)
+    failOnValidatorBootupFailure=false
+    ;;
+  u)
+    blockstreamer=true
+    ;;
+  S)
+    stopNetwork=true
+    ;;
+  *)
+    usage "Unknown option: $opt"
+    ;;
+  esac
+done
+
+[[ -n $netName ]] || usage
+[[ -n $cloudProvider ]] || usage "Cloud provider not specified"
+[[ -n ${zone[*]} ]] || usage "At least one zone must be specified"
+
+shutdown() {
+  exitcode=$?
+
+  set +e
+  if [[ -d net/log ]]; then
+    mv net/log net/log-deploy
+    for logfile in net/log-deploy/*; do
+      if [[ -f $logfile ]]; then
+        upload-ci-artifact "$logfile"
+        tail "$logfile"
+      fi
+    done
+  fi
+  exit $exitcode
+}
+rm -rf net/{log,-deploy}
+trap shutdown EXIT INT
+
+set -x
+
+# Fetch reusable testnet keypairs
+if [[ ! -d net/keypairs ]]; then
+  git clone git@github.com:solana-labs/testnet-keypairs.git net/keypairs
+fi
+
+# Build a string to pass zone opts to $cloudProvider.sh: "-z zone1 -z zone2 ..."
+zone_args=()
+for val in "${zone[@]}"; do
+  zone_args+=("-z $val")
+done
+
+if $stopNetwork; then
+  skipCreate=true
+fi
+
+if $delete; then
+  skipCreate=false
+fi
+
+# Create the network
+if ! $skipCreate; then
+  echo "--- $cloudProvider.sh delete"
+  # shellcheck disable=SC2068
+  time net/"$cloudProvider".sh delete ${zone_args[@]} -p "$netName" ${externalNode:+-x}
+  if $delete; then
+    exit 0
+  fi
+
+  echo "--- $cloudProvider.sh create"
+  create_args=(
+    -p "$netName"
+    -c "$clientNodeCount"
+    -n "$additionalValidatorCount"
+    --dedicated
+    --self-destruct-hours 0
+  )
+
+  if [[ -n $bootstrapValidatorAddress ]]; then
+    create_args+=(-a "$bootstrapValidatorAddress")
+  fi
+
+  # shellcheck disable=SC2206
+  create_args+=(${zone_args[@]})
+
+  if [[ -n $maybeLetsEncrypt ]]; then
+    # shellcheck disable=SC2206 # Do not want to quote $maybeLetsEncrypt
+    create_args+=($maybeLetsEncrypt)
+  fi
+
+  if $blockstreamer; then
+    create_args+=(-u)
+  fi
+
+  if [[ -n $bootDiskType ]]; then
+    create_args+=(-d "$bootDiskType")
+  fi
+
+  if $enableGpu; then
+    if [[ -z $bootstrapValidatorMachineType ]]; then
+      create_args+=(-g)
+    else
+      create_args+=(-G "$bootstrapValidatorMachineType")
+    fi
+  fi
+
+  if $publicNetwork; then
+    create_args+=(-P)
+  fi
+
+  if $externalNode; then
+    create_args+=(-x)
+  fi
+
+  if ! $failOnValidatorBootupFailure; then
+    create_args+=(-f)
+  fi
+
+  if [[ -n $maybeValidatorAdditionalDiskSize ]]; then
+    # shellcheck disable=SC2206 # Do not want to quote
+    create_args+=($maybeValidatorAdditionalDiskSize)
+  fi
+
+  time net/"$cloudProvider".sh create "${create_args[@]}"
+else
+  echo "--- $cloudProvider.sh config"
+  config_args=(
+    -p "$netName"
+  )
+  # shellcheck disable=SC2206
+  config_args+=(${zone_args[@]})
+  if $publicNetwork; then
+    config_args+=(-P)
+  fi
+
+  if $externalNode; then
+    config_args+=(-x)
+  fi
+
+  if ! $failOnValidatorBootupFailure; then
+    config_args+=(-f)
+  fi
+
+  time net/"$cloudProvider".sh config "${config_args[@]}"
+fi
+net/init-metrics.sh -e
+
+echo "+++ $cloudProvider.sh info"
+net/"$cloudProvider".sh info
+
+if $stopNetwork; then
+  echo --- net.sh stop
+  time net/net.sh stop
+  exit 0
+fi
+
+ok=true
+if ! $skipStart; then
+  (
+    if $skipCreate; then
+      op=restart
+    else
+      op=start
+    fi
+    echo "--- net.sh $op"
+    args=(
+      "$op"
+      -t "$tarChannelOrTag"
+    )
+
+    if ! $publicNetwork; then
+      args+=(-o rejectExtraNodes)
+    fi
+    if [[ -n $NO_INSTALL_CHECK ]]; then
+      args+=(-o noInstallCheck)
+    fi
+    if $reuseLedger; then
+      args+=(-r)
+    fi
+
+    if ! $failOnValidatorBootupFailure; then
+      args+=(-F)
+    fi
+
+    # shellcheck disable=SC2206 # Do not want to quote
+    args+=(
+      $maybeHashesPerTick
+      $maybeDisableAirdrops
+      $maybeInternalNodesStakeLamports
+      $maybeInternalNodesLamports
+      $maybeExternalPrimordialAccountsFile
+      $maybeSlotsPerEpoch
+      $maybeTargetLamportsPerSignature
+      $maybeNoSnapshot
+      $maybeLimitLedgerSize
+    )
+
+    if $idleClients; then
+      args+=(-c "idle=$clientNodeCount=")
+    fi
+
+    time net/net.sh "${args[@]}"
+  ) || ok=false
+
+  if $fetchLogs; then
+    net/net.sh logs
+  fi
+fi
+
+$ok

ci/testnet-manager.sh

@@ -0,0 +1,401 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")"/..
+
+if [[ -z $BUILDKITE ]]; then
+  echo BUILDKITE not defined
+  exit 1
+fi
+
+if [[ -z $SOLANA_METRICS_PARTIAL_CONFIG ]]; then
+  echo SOLANA_METRICS_PARTIAL_CONFIG not defined
+  exit 1
+fi
+
+if [[ -z $TESTNET ]]; then
+  TESTNET=$(buildkite-agent meta-data get "testnet" --default "")
+fi
+
+if [[ -z $TESTNET_OP ]]; then
+  TESTNET_OP=$(buildkite-agent meta-data get "testnet-operation" --default "")
+fi
+
+if [[ -z $TESTNET || -z $TESTNET_OP ]]; then
+  (
+    cat <<EOF
+steps:
+  - block: "Manage Testnet"
+    fields:
+      - select: "Network"
+        key: "testnet"
+        options:
+          - label: "testnet"
+            value: "testnet"
+          - label: "testnet-edge"
+            value: "testnet-edge"
+          - label: "testnet-beta"
+            value: "testnet-beta"
+      - select: "Operation"
+        key: "testnet-operation"
+        default: "sanity-or-restart"
+        options:
+          - label: "Create testnet and then start software.  If the testnet already exists it will be deleted and re-created"
+            value: "create-and-start"
+          - label: "Create testnet, but do not start software.  If the testnet already exists it will be deleted and re-created"
+            value: "create"
+          - label: "Start network software on an existing testnet.  If software is already running it will be restarted"
+            value: "start"
+          - label: "Stop network software without deleting testnet nodes"
+            value: "stop"
+          - label: "Update the network software.  Restart network software on failure"
+            value: "update-or-restart"
+          - label: "Sanity check.  Restart network software on failure"
+            value: "sanity-or-restart"
+          - label: "Sanity check only"
+            value: "sanity"
+          - label: "Delete the testnet"
+            value: "delete"
+          - label: "Enable/unlock the testnet"
+            value: "enable"
+          - label: "Delete and then lock the testnet from further operation until it is re-enabled"
+            value: "disable"
+  - command: "ci/$(basename "$0")"
+    agents:
+      - "queue=$BUILDKITE_AGENT_META_DATA_QUEUE"
+EOF
+  ) | buildkite-agent pipeline upload
+  exit 0
+fi
+
+ci/channel-info.sh
+eval "$(ci/channel-info.sh)"
+
+
+EC2_ZONES=(
+  us-west-1a
+  us-west-2a
+  us-east-1a
+  us-east-2a
+  sa-east-1a
+  eu-west-1a
+  eu-west-2a
+  eu-central-1a
+  ap-northeast-2a
+  ap-southeast-2a
+  ap-south-1a
+  ca-central-1a
+)
+
+# GCE zones with _lots_ of quota
+GCE_ZONES=(
+  us-west1-a
+  us-central1-a
+  us-east1-b
+  europe-west4-a
+
+  us-west1-b
+  us-central1-b
+  us-east1-c
+  europe-west4-b
+
+  us-west1-c
+  us-east1-d
+  europe-west4-c
+)
+
+# GCE zones with enough quota for one CPU-only validator
+GCE_LOW_QUOTA_ZONES=(
+  asia-east2-a
+  asia-northeast1-b
+  asia-northeast2-b
+  asia-south1-c
+  asia-southeast1-b
+  australia-southeast1-b
+  europe-north1-a
+  europe-west2-b
+  europe-west3-c
+  europe-west6-a
+  northamerica-northeast1-a
+  southamerica-east1-b
+)
+
+case $TESTNET in
+testnet-edge)
+  CHANNEL_OR_TAG=edge
+  CHANNEL_BRANCH=$EDGE_CHANNEL
+  ;;
+testnet-beta)
+  CHANNEL_OR_TAG=beta
+  CHANNEL_BRANCH=$BETA_CHANNEL
+  ;;
+testnet)
+  CHANNEL_OR_TAG=$STABLE_CHANNEL_LATEST_TAG
+  CHANNEL_BRANCH=$STABLE_CHANNEL
+  export CLOUDSDK_CORE_PROJECT=testnet-solana-com
+  ;;
+*)
+  echo "Error: Invalid TESTNET=$TESTNET"
+  exit 1
+  ;;
+esac
+
+EC2_ZONE_ARGS=()
+for val in "${EC2_ZONES[@]}"; do
+  EC2_ZONE_ARGS+=("-z $val")
+done
+GCE_ZONE_ARGS=()
+for val in "${GCE_ZONES[@]}"; do
+  GCE_ZONE_ARGS+=("-z $val")
+done
+GCE_LOW_QUOTA_ZONE_ARGS=()
+for val in "${GCE_LOW_QUOTA_ZONES[@]}"; do
+  GCE_LOW_QUOTA_ZONE_ARGS+=("-z $val")
+done
+
+if [[ -z $TESTNET_DB_HOST ]]; then
+  TESTNET_DB_HOST="https://metrics.solana.com:8086"
+fi
+
+export SOLANA_METRICS_CONFIG="db=$TESTNET,host=$TESTNET_DB_HOST,$SOLANA_METRICS_PARTIAL_CONFIG"
+echo "SOLANA_METRICS_CONFIG: $SOLANA_METRICS_CONFIG"
+source scripts/configure-metrics.sh
+
+if [[ -n $TESTNET_TAG ]]; then
+  CHANNEL_OR_TAG=$TESTNET_TAG
+else
+
+  if [[ $CI_BRANCH != "$CHANNEL_BRANCH" ]]; then
+    (
+      cat <<EOF
+steps:
+  - trigger: "$BUILDKITE_PIPELINE_SLUG"
+    async: true
+    build:
+      message: "$BUILDKITE_MESSAGE"
+      branch: "$CHANNEL_BRANCH"
+      env:
+        TESTNET: "$TESTNET"
+        TESTNET_OP: "$TESTNET_OP"
+        TESTNET_DB_HOST: "$TESTNET_DB_HOST"
+        GCE_NODE_COUNT: "$GCE_NODE_COUNT"
+        GCE_LOW_QUOTA_NODE_COUNT: "$GCE_LOW_QUOTA_NODE_COUNT"
+        RUST_LOG: "$RUST_LOG"
+EOF
+    ) | buildkite-agent pipeline upload
+    exit 0
+  fi
+fi
+
+maybe_deploy_software() {
+  declare arg=$1
+  declare ok=true
+  (
+    echo "--- net.sh restart"
+    set -x
+    time net/net.sh restart --skip-setup -t "$CHANNEL_OR_TAG" --skip-poh-verify "$arg"
+  ) || ok=false
+  if ! $ok; then
+    net/net.sh logs
+  fi
+  $ok
+}
+
+sanity() {
+  echo "--- sanity $TESTNET"
+  case $TESTNET in
+  testnet-edge)
+    (
+      set -x
+      NO_INSTALL_CHECK=1 \
+        ci/testnet-sanity.sh edge-devnet-solana-com gce -P us-west1-b
+      maybe_deploy_software
+    )
+    ;;
+  testnet-beta)
+    (
+      set -x
+      NO_INSTALL_CHECK=1 \
+        ci/testnet-sanity.sh beta-devnet-solana-com gce -P us-west1-b
+      maybe_deploy_software --deploy-if-newer
+    )
+    ;;
+  testnet)
+    (
+      set -x
+      ci/testnet-sanity.sh devnet-solana-com gce -P us-west1-b
+    )
+    ;;
+  *)
+    echo "Error: Invalid TESTNET=$TESTNET"
+    exit 1
+    ;;
+  esac
+}
+
+deploy() {
+  declare maybeCreate=$1
+  declare maybeStart=$2
+  declare maybeStop=$3
+  declare maybeDelete=$4
+
+  echo "--- deploy \"$maybeCreate\" \"$maybeStart\" \"$maybeStop\" \"$maybeDelete\""
+
+  # Create or recreate the nodes
+  if [[ -z $maybeCreate ]]; then
+    skipCreate=skip
+  else
+    skipCreate=""
+  fi
+
+  # Start or restart the network software on the nodes
+  if [[ -z $maybeStart ]]; then
+    skipStart=skip
+  else
+    skipStart=""
+  fi
+
+  case $TESTNET in
+  testnet-edge)
+    (
+      set -x
+      ci/testnet-deploy.sh -p edge-devnet-solana-com -C gce -z us-west1-b \
+        -t "$CHANNEL_OR_TAG" -n 3 -c 0 -u -P \
+        -a edge-devnet-solana-com --letsencrypt edge.devnet.solana.com \
+        --limit-ledger-size \
+        ${skipCreate:+-e} \
+        ${skipStart:+-s} \
+        ${maybeStop:+-S} \
+        ${maybeDelete:+-D}
+    )
+    ;;
+  testnet-beta)
+    (
+      set -x
+      ci/testnet-deploy.sh -p beta-devnet-solana-com -C gce -z us-west1-b \
+        -t "$CHANNEL_OR_TAG" -n 3 -c 0 -u -P \
+        -a beta-devnet-solana-com --letsencrypt beta.devnet.solana.com \
+        --limit-ledger-size \
+        ${skipCreate:+-e} \
+        ${skipStart:+-s} \
+        ${maybeStop:+-S} \
+        ${maybeDelete:+-D}
+    )
+    ;;
+  testnet)
+    (
+      set -x
+      ci/testnet-deploy.sh -p devnet-solana-com -C gce -z us-west1-b \
+        -t "$CHANNEL_OR_TAG" -n 0 -c 0 -u -P \
+        -a testnet-solana-com --letsencrypt devnet.solana.com \
+        --limit-ledger-size \
+        ${skipCreate:+-e} \
+        ${skipStart:+-s} \
+        ${maybeStop:+-S} \
+        ${maybeDelete:+-D}
+    )
+    (
+      echo "--- net.sh update"
+      set -x
+      time net/net.sh update -t "$CHANNEL_OR_TAG" --platform linux --platform osx #--platform windows
+    )
+    ;;
+  *)
+    echo "Error: Invalid TESTNET=$TESTNET"
+    exit 1
+    ;;
+  esac
+}
+
+ENABLED_LOCKFILE="${HOME}/${TESTNET}.is_enabled"
+
+create-and-start() {
+  deploy create start
+}
+create() {
+  deploy create
+}
+start() {
+  deploy "" start
+}
+stop() {
+  deploy "" ""
+}
+delete() {
+  deploy "" "" "" delete
+}
+enable_testnet() {
+  touch "${ENABLED_LOCKFILE}"
+  echo "+++ $TESTNET now enabled"
+}
+disable_testnet() {
+  rm -f "${ENABLED_LOCKFILE}"
+  echo "+++ $TESTNET now disabled"
+}
+is_testnet_enabled() {
+  if [[ ! -f ${ENABLED_LOCKFILE} ]]; then
+    echo "+++ ${TESTNET} is currently disabled.  Enable ${TESTNET} by running ci/testnet-manager.sh with \$TESTNET_OP=enable, then re-run with current settings."
+    exit 0
+  fi
+}
+
+case $TESTNET_OP in
+enable)
+  enable_testnet
+  ;;
+disable)
+  disable_testnet
+  delete
+  ;;
+create-and-start)
+  is_testnet_enabled
+  create-and-start
+  ;;
+create)
+  is_testnet_enabled
+  create
+  ;;
+start)
+  is_testnet_enabled
+  start
+  ;;
+stop)
+  is_testnet_enabled
+  stop
+  ;;
+sanity)
+  is_testnet_enabled
+  sanity
+  ;;
+delete)
+  is_testnet_enabled
+  delete
+  ;;
+update-or-restart)
+  is_testnet_enabled
+  if start; then
+    echo Update successful
+  else
+    echo "+++ Update failed, restarting the network"
+    $metricsWriteDatapoint "testnet-manager update-failure=1"
+    create-and-start
+  fi
+  ;;
+sanity-or-restart)
+  is_testnet_enabled
+  if sanity; then
+    echo Pass
+  else
+    echo "+++ Sanity failed, updating the network"
+    $metricsWriteDatapoint "testnet-manager sanity-failure=1"
+    create-and-start
+  fi
+  ;;
+*)
+  echo "Error: Invalid TESTNET_OP=$TESTNET_OP"
+  exit 1
+  ;;
+esac
+
+echo --- fin
+exit 0

ci/testnet-sanity.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")/.."
+source ci/upload-ci-artifact.sh
+
+usage() {
+  exitcode=0
+  if [[ -n "$1" ]]; then
+    exitcode=1
+    echo "Error: $*"
+  fi
+  cat <<EOF
+usage: $0 [name] [cloud] [zone1] ... [zoneN]
+
+Sanity check a testnet
+
+  name            - name of the network
+  cloud           - cloud provider to use (gce, ec2)
+  zone1 .. zoneN  - cloud provider zones to check
+
+  Note: the SOLANA_METRICS_CONFIG environment variable is used to configure
+        metrics
+EOF
+  exit $exitcode
+}
+
+netName=$1
+cloudProvider=$2
+[[ -n $netName ]] || usage ""
+[[ -n $cloudProvider ]] || usage "Cloud provider not specified"
+shift 2
+
+maybePublicNetwork=
+if [[ $1 = -P ]]; then
+  maybePublicNetwork=-P
+  shift
+fi
+[[ -n $1 ]] || usage "zone1 not specified"
+
+shutdown() {
+  exitcode=$?
+
+  set +e
+  if [[ -d net/log ]]; then
+    mv net/log net/log-sanity
+    for logfile in net/log-sanity/*; do
+      if [[ -f $logfile ]]; then
+        upload-ci-artifact "$logfile"
+        tail "$logfile"
+      fi
+    done
+  fi
+  exit $exitcode
+}
+rm -rf net/{log,-sanity}
+rm -f net/config/config
+trap shutdown EXIT INT
+
+set -x
+for zone in "$@"; do
+  echo "--- $cloudProvider config [$zone]"
+  timeout 5m net/"$cloudProvider".sh config $maybePublicNetwork -n 1 -p "$netName" -z "$zone"
+  net/init-metrics.sh -e
+  echo "+++ $cloudProvider.sh info"
+  net/"$cloudProvider".sh info
+  echo "--- net.sh sanity [$cloudProvider:$zone]"
+  ok=true
+  timeout 5m net/net.sh sanity \
+    ${REJECT_EXTRA_NODES:+-o rejectExtraNodes} \
+    ${NO_INSTALL_CHECK:+-o noInstallCheck} \
+    $zone || ok=false
+
+  if ! $ok; then
+    net/net.sh logs
+  fi
+  $ok
+done

clap-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-clap-utils"
-version = "1.2.0"
+version = "1.1.13"
 description = "Solana utilities for the clap"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -11,8 +11,8 @@ edition = "2018"
 [dependencies]
 clap = "2.33.0"
 rpassword = "4.0"
-solana-remote-wallet = { path = "../remote-wallet", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
+solana-remote-wallet = { path = "../remote-wallet", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
 thiserror = "1.0.11"
 tiny-bip39 = "0.7.0"
 url = "2.1.0"

clap-utils/src/commitment.rs

@@ -15,7 +15,7 @@ pub fn commitment_arg_with_default<'a, 'b>(default_value: &'static str) -> Arg<'
     Arg::with_name(COMMITMENT_ARG.name)
         .long(COMMITMENT_ARG.long)
         .takes_value(true)
-        .possible_values(&["recent", "single", "root", "max"])
+        .possible_values(&["recent", "root", "max"])
         .default_value(default_value)
         .value_name("COMMITMENT_LEVEL")
         .help(COMMITMENT_ARG.help)

clap-utils/src/input_parsers.rs

@@ -183,7 +183,6 @@ pub fn commitment_of(matches: &ArgMatches<'_>, name: &str) -> Option<CommitmentC
         "max" => CommitmentConfig::max(),
         "recent" => CommitmentConfig::recent(),
         "root" => CommitmentConfig::root(),
-        "single" => CommitmentConfig::single(),
         _ => CommitmentConfig::default(),
     })
 }
@@ -350,16 +349,16 @@ mod tests {
         let matches = app()
             .clone()
             .get_matches_from(vec!["test", "--single", "50"]);
-        assert_eq!(lamports_of_sol(&matches, "single"), Some(50_000_000_000));
+        assert_eq!(lamports_of_sol(&matches, "single"), Some(50000000000));
         assert_eq!(lamports_of_sol(&matches, "multiple"), None);
         let matches = app()
             .clone()
             .get_matches_from(vec!["test", "--single", "1.5"]);
-        assert_eq!(lamports_of_sol(&matches, "single"), Some(1_500_000_000));
+        assert_eq!(lamports_of_sol(&matches, "single"), Some(1500000000));
         assert_eq!(lamports_of_sol(&matches, "multiple"), None);
         let matches = app()
             .clone()
             .get_matches_from(vec!["test", "--single", "0.03"]);
-        assert_eq!(lamports_of_sol(&matches, "single"), Some(30_000_000));
+        assert_eq!(lamports_of_sol(&matches, "single"), Some(30000000));
     }
 }

clap-utils/src/input_validators.rs

@@ -147,17 +147,6 @@ pub fn is_amount(amount: String) -> Result<(), String> {
     }
 }
 
-pub fn is_amount_or_all(amount: String) -> Result<(), String> {
-    if amount.parse::<u64>().is_ok() || amount.parse::<f64>().is_ok() || amount == "ALL" {
-        Ok(())
-    } else {
-        Err(format!(
-            "Unable to parse input amount as integer or float, provided: {}",
-            amount
-        ))
-    }
-}
-
 pub fn is_rfc3339_datetime(value: String) -> Result<(), String> {
     DateTime::parse_from_rfc3339(&value)
         .map(|_| ())

clap-utils/src/lib.rs

@@ -1,5 +1,24 @@
 use thiserror::Error;
 
+#[macro_export]
+macro_rules! version {
+    () => {
+        &*format!(
+            "{}{}",
+            env!("CARGO_PKG_VERSION"),
+            if option_env!("CI_TAG").unwrap_or("").is_empty() {
+                format!(
+                    " [channel={} commit={}]",
+                    option_env!("CHANNEL").unwrap_or("unknown"),
+                    option_env!("CI_COMMIT").unwrap_or("unknown"),
+                )
+            } else {
+                "".to_string()
+            },
+        )
+    };
+}
+
 pub struct ArgConstant<'a> {
     pub long: &'a str,
     pub name: &'a str,

cli-config/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-cli-config"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.2.0"
+version = "1.1.13"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -11,9 +11,9 @@ homepage = "https://solana.com/"
 [dependencies]
 dirs = "2.0.2"
 lazy_static = "1.4.0"
-serde = "1.0.110"
+serde = "1.0.105"
 serde_derive = "1.0.103"
-serde_yaml = "0.8.12"
+serde_yaml = "0.8.11"
 url = "2.1.1"
 
 [package.metadata.docs.rs]

cli/Cargo.toml

@@ -3,19 +3,19 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-cli"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.2.0"
+version = "1.1.13"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
 bincode = "1.2.1"
-bs58 = "0.3.1"
+bs58 = "0.3.0"
 chrono = { version = "0.4.11", features = ["serde"] }
-clap = "2.33.1"
+clap = "2.33.0"
 criterion-stats = "0.3.0"
 ctrlc = { version = "3.1.4", features = ["termination"] }
-console = "0.10.1"
+console = "0.10.0"
 dirs = "2.0.2"
 log = "0.4.8"
 Inflector = "0.11.4"
@@ -24,31 +24,31 @@ humantime = "2.0.0"
 num-traits = "0.2"
 pretty-hex = "0.1.1"
 reqwest = { version = "0.10.4", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-serde = "1.0.110"
+serde = "1.0.105"
 serde_derive = "1.0.103"
-serde_json = "1.0.53"
-solana-budget-program = { path = "../programs/budget", version = "1.2.0" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-cli-config = { path = "../cli-config", version = "1.2.0" }
-solana-client = { path = "../client", version = "1.2.0" }
-solana-config-program = { path = "../programs/config", version = "1.2.0" }
-solana-faucet = { path = "../faucet", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-remote-wallet = { path = "../remote-wallet", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-stake-program = { path = "../programs/stake", version = "1.2.0" }
-solana-transaction-status = { path = "../transaction-status", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.0" }
-solana-vote-signer = { path = "../vote-signer", version = "1.2.0" }
-thiserror = "1.0.19"
+serde_json = "1.0.48"
+solana-budget-program = { path = "../programs/budget", version = "1.1.13" }
+solana-clap-utils = { path = "../clap-utils", version = "1.1.13" }
+solana-cli-config = { path = "../cli-config", version = "1.1.13" }
+solana-client = { path = "../client", version = "1.1.13" }
+solana-config-program = { path = "../programs/config", version = "1.1.13" }
+solana-faucet = { path = "../faucet", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-net-utils = { path = "../net-utils", version = "1.1.13" }
+solana-remote-wallet = { path = "../remote-wallet", version = "1.1.13" }
+solana-runtime = { path = "../runtime", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+solana-stake-program = { path = "../programs/stake", version = "1.1.13" }
+solana-storage-program = { path = "../programs/storage", version = "1.1.13" }
+solana-transaction-status = { path = "../transaction-status", version = "1.1.13" }
+solana-vote-program = { path = "../programs/vote", version = "1.1.13" }
+solana-vote-signer = { path = "../vote-signer", version = "1.1.13" }
+thiserror = "1.0.13"
 url = "2.1.1"
 
 [dev-dependencies]
-solana-core = { path = "../core", version = "1.2.0" }
-solana-budget-program = { path = "../programs/budget", version = "1.2.0" }
+solana-core = { path = "../core", version = "1.1.13" }
+solana-budget-program = { path = "../programs/budget", version = "1.1.13" }
 tempfile = "3.1.0"
 
 [[bin]]

cli/src/checks.rs

@@ -1,206 +0,0 @@
-use crate::cli::CliError;
-use solana_client::{
-    client_error::{ClientError, Result as ClientResult},
-    rpc_client::RpcClient,
-};
-use solana_sdk::{
-    fee_calculator::FeeCalculator, message::Message, native_token::lamports_to_sol, pubkey::Pubkey,
-};
-
-pub fn check_account_for_fee(
-    rpc_client: &RpcClient,
-    account_pubkey: &Pubkey,
-    fee_calculator: &FeeCalculator,
-    message: &Message,
-) -> Result<(), CliError> {
-    check_account_for_multiple_fees(rpc_client, account_pubkey, fee_calculator, &[message])
-}
-
-pub fn check_account_for_multiple_fees(
-    rpc_client: &RpcClient,
-    account_pubkey: &Pubkey,
-    fee_calculator: &FeeCalculator,
-    messages: &[&Message],
-) -> Result<(), CliError> {
-    let fee = calculate_fee(fee_calculator, messages);
-    if !check_account_for_balance(rpc_client, account_pubkey, fee)
-        .map_err(Into::<ClientError>::into)?
-    {
-        return Err(CliError::InsufficientFundsForFee(lamports_to_sol(fee)));
-    }
-    Ok(())
-}
-
-pub fn calculate_fee(fee_calculator: &FeeCalculator, messages: &[&Message]) -> u64 {
-    messages
-        .iter()
-        .map(|message| fee_calculator.calculate_fee(message))
-        .sum()
-}
-
-pub fn check_account_for_balance(
-    rpc_client: &RpcClient,
-    account_pubkey: &Pubkey,
-    balance: u64,
-) -> ClientResult<bool> {
-    let lamports = rpc_client.get_balance(account_pubkey)?;
-    if lamports != 0 && lamports >= balance {
-        return Ok(true);
-    }
-    Ok(false)
-}
-
-pub fn check_unique_pubkeys(
-    pubkey0: (&Pubkey, String),
-    pubkey1: (&Pubkey, String),
-) -> Result<(), CliError> {
-    if pubkey0.0 == pubkey1.0 {
-        Err(CliError::BadParameter(format!(
-            "Identical pubkeys found: `{}` and `{}` must be unique",
-            pubkey0.1, pubkey1.1
-        )))
-    } else {
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-    use solana_client::{
-        rpc_request::RpcRequest,
-        rpc_response::{Response, RpcResponseContext},
-    };
-    use solana_sdk::system_instruction;
-    use std::collections::HashMap;
-
-    #[test]
-    fn test_check_account_for_fees() {
-        let account_balance = 1;
-        let account_balance_response = json!(Response {
-            context: RpcResponseContext { slot: 1 },
-            value: json!(account_balance),
-        });
-        let pubkey = Pubkey::new_rand();
-        let fee_calculator = FeeCalculator::new(1);
-
-        let pubkey0 = Pubkey::new(&[0; 32]);
-        let pubkey1 = Pubkey::new(&[1; 32]);
-        let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
-        let message0 = Message::new(&[ix0]);
-
-        let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
-        let ix1 = system_instruction::transfer(&pubkey1, &pubkey0, 1);
-        let message1 = Message::new(&[ix0, ix1]);
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response.clone());
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-        check_account_for_fee(&rpc_client, &pubkey, &fee_calculator, &message0)
-            .expect("unexpected result");
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response.clone());
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-        assert!(check_account_for_fee(&rpc_client, &pubkey, &fee_calculator, &message1).is_err());
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response);
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-        assert!(check_account_for_multiple_fees(
-            &rpc_client,
-            &pubkey,
-            &fee_calculator,
-            &[&message0, &message0]
-        )
-        .is_err());
-
-        let account_balance = 2;
-        let account_balance_response = json!(Response {
-            context: RpcResponseContext { slot: 1 },
-            value: json!(account_balance),
-        });
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response);
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-
-        check_account_for_multiple_fees(
-            &rpc_client,
-            &pubkey,
-            &fee_calculator,
-            &[&message0, &message0],
-        )
-        .expect("unexpected result");
-    }
-
-    #[test]
-    fn test_check_account_for_balance() {
-        let account_balance = 50;
-        let account_balance_response = json!(Response {
-            context: RpcResponseContext { slot: 1 },
-            value: json!(account_balance),
-        });
-        let pubkey = Pubkey::new_rand();
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response);
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-
-        assert_eq!(
-            check_account_for_balance(&rpc_client, &pubkey, 1).unwrap(),
-            true
-        );
-        assert_eq!(
-            check_account_for_balance(&rpc_client, &pubkey, account_balance).unwrap(),
-            true
-        );
-        assert_eq!(
-            check_account_for_balance(&rpc_client, &pubkey, account_balance + 1).unwrap(),
-            false
-        );
-    }
-
-    #[test]
-    fn test_calculate_fee() {
-        let fee_calculator = FeeCalculator::new(1);
-        // No messages, no fee.
-        assert_eq!(calculate_fee(&fee_calculator, &[]), 0);
-
-        // No signatures, no fee.
-        let message = Message::default();
-        assert_eq!(calculate_fee(&fee_calculator, &[&message, &message]), 0);
-
-        // One message w/ one signature, a fee.
-        let pubkey0 = Pubkey::new(&[0; 32]);
-        let pubkey1 = Pubkey::new(&[1; 32]);
-        let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
-        let message0 = Message::new(&[ix0]);
-        assert_eq!(calculate_fee(&fee_calculator, &[&message0]), 1);
-
-        // Two messages, additive fees.
-        let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
-        let ix1 = system_instruction::transfer(&pubkey1, &pubkey0, 1);
-        let message1 = Message::new(&[ix0, ix1]);
-        assert_eq!(calculate_fee(&fee_calculator, &[&message0, &message1]), 3);
-    }
-
-    #[test]
-    fn test_check_unique_pubkeys() {
-        let pubkey0 = Pubkey::new_rand();
-        let pubkey_clone = pubkey0;
-        let pubkey1 = Pubkey::new_rand();
-
-        check_unique_pubkeys((&pubkey0, "foo".to_string()), (&pubkey1, "bar".to_string()))
-            .expect("unexpected result");
-        check_unique_pubkeys((&pubkey0, "foo".to_string()), (&pubkey1, "foo".to_string()))
-            .expect("unexpected result");
-
-        assert!(check_unique_pubkeys(
-            (&pubkey0, "foo".to_string()),
-            (&pubkey_clone, "bar".to_string())
-        )
-        .is_err());
-    }
-}

cli/src/cli_output.rs

@@ -5,11 +5,10 @@ use inflector::cases::titlecase::to_title_case;
 use serde::Serialize;
 use serde_json::{Map, Value};
 use solana_client::rpc_response::{
-    RpcAccountBalance, RpcKeyedAccount, RpcSupply, RpcVoteAccountInfo,
+    RpcAccountBalance, RpcEpochInfo, RpcKeyedAccount, RpcSupply, RpcVoteAccountInfo,
 };
 use solana_sdk::{
     clock::{self, Epoch, Slot, UnixTimestamp},
-    epoch_info::EpochInfo,
     native_token::lamports_to_sol,
     stake_history::StakeHistoryEntry,
 };
@@ -187,11 +186,11 @@ pub struct CliSlotStatus {
 #[serde(rename_all = "camelCase")]
 pub struct CliEpochInfo {
     #[serde(flatten)]
-    pub epoch_info: EpochInfo,
+    pub epoch_info: RpcEpochInfo,
 }
 
-impl From<EpochInfo> for CliEpochInfo {
-    fn from(epoch_info: EpochInfo) -> Self {
+impl From<RpcEpochInfo> for CliEpochInfo {
+    fn from(epoch_info: RpcEpochInfo) -> Self {
         Self { epoch_info }
     }
 }
@@ -900,7 +899,6 @@ impl fmt::Display for CliSignOnlyData {
 }
 
 #[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
 pub struct CliSignature {
     pub signature: String,
 }
@@ -914,7 +912,6 @@ impl fmt::Display for CliSignature {
 }
 
 #[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
 pub struct CliAccountBalances {
     pub accounts: Vec<RpcAccountBalance>,
 }
@@ -939,7 +936,6 @@ impl fmt::Display for CliAccountBalances {
 }
 
 #[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
 pub struct CliSupply {
     pub total: u64,
     pub circulating: u64,
@@ -984,25 +980,3 @@ impl fmt::Display for CliSupply {
         Ok(())
     }
 }
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliFees {
-    pub slot: Slot,
-    pub blockhash: String,
-    pub lamports_per_signature: u64,
-    pub last_valid_slot: Slot,
-}
-
-impl fmt::Display for CliFees {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln_name_value(f, "Blockhash:", &self.blockhash)?;
-        writeln_name_value(
-            f,
-            "Lamports per signature:",
-            &self.lamports_per_signature.to_string(),
-        )?;
-        writeln_name_value(f, "Last valid slot:", &self.last_valid_slot.to_string())?;
-        Ok(())
-    }
-}

cli/src/cluster_query.rs

@@ -1,8 +1,7 @@
 use crate::{
-    cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
+    cli::{check_account_for_fee, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
     cli_output::*,
     display::println_name_value,
-    spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
 };
 use clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand};
 use console::{style, Emoji};
@@ -25,10 +24,12 @@ use solana_sdk::{
     clock::{self, Clock, Slot},
     commitment_config::CommitmentConfig,
     epoch_schedule::Epoch,
+    hash::Hash,
     message::Message,
     native_token::lamports_to_sol,
-    pubkey::{self, Pubkey},
-    system_instruction, system_program,
+    pubkey::Pubkey,
+    signature::{Keypair, Signer},
+    system_instruction,
     sysvar::{self, Sysvar},
     transaction::Transaction,
 };
@@ -56,11 +57,13 @@ impl ClusterQuerySubCommands for App<'_, '_> {
             SubCommand::with_name("catchup")
                 .about("Wait for a validator to catch up to the cluster")
                 .arg(
-                    pubkey!(Arg::with_name("node_pubkey")
+                    Arg::with_name("node_pubkey")
                         .index(1)
+                        .takes_value(true)
                         .value_name("VALIDATOR_PUBKEY")
-                        .required(true),
-                        "Identity pubkey of the validator"),
+                        .validator(is_valid_pubkey)
+                        .required(true)
+                        .help("Identity pubkey of the validator"),
                 )
                 .arg(
                     Arg::with_name("node_json_rpc_url")
@@ -226,11 +229,13 @@ impl ClusterQuerySubCommands for App<'_, '_> {
             SubCommand::with_name("stakes")
                 .about("Show stake account information")
                 .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkeys")
+                    Arg::with_name("vote_account_pubkeys")
                         .index(1)
                         .value_name("VOTE_ACCOUNT_PUBKEYS")
-                        .multiple(true),
-                        "Only show stake accounts delegated to the provided vote accounts. "),
+                        .takes_value(true)
+                        .multiple(true)
+                        .validator(is_valid_pubkey)
+                        .help("Only show stake accounts delegated to the provided vote accounts"),
                 )
                 .arg(
                     Arg::with_name("lamports")
@@ -257,11 +262,12 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                        ordered based on the slot in which they were confirmed in \
                        from lowest to highest slot")
                 .arg(
-                    pubkey!(Arg::with_name("address")
+                    Arg::with_name("address")
                         .index(1)
                         .value_name("ADDRESS")
-                        .required(true),
-                        "Account address"),
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Account address"),
                 )
                 .arg(
                     Arg::with_name("end_slot")
@@ -451,7 +457,8 @@ pub fn parse_transaction_history(
 ) -> Result<CliCommandInfo, CliError> {
     let address = pubkey_of_signer(matches, "address", wallet_manager)?.unwrap();
     let end_slot = value_t!(matches, "end_slot", Slot).ok();
-    let slot_limit = value_t!(matches, "limit", u64).ok();
+    let slot_limit = value_t!(matches, "limit", u64)
+        .unwrap_or(MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS_SLOT_RANGE);
 
     Ok(CliCommandInfo {
         command: CliCommand::TransactionHistory {
@@ -597,16 +604,13 @@ pub fn process_cluster_version(rpc_client: &RpcClient) -> ProcessResult {
     Ok(remote_version.solana_core)
 }
 
-pub fn process_fees(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
-    let result = rpc_client.get_recent_blockhash_with_commitment(CommitmentConfig::default())?;
-    let (recent_blockhash, fee_calculator, last_valid_slot) = result.value;
-    let fees = CliFees {
-        slot: result.context.slot,
-        blockhash: recent_blockhash.to_string(),
-        lamports_per_signature: fee_calculator.lamports_per_signature,
-        last_valid_slot,
-    };
-    Ok(config.output_format.formatted_string(&fees))
+pub fn process_fees(rpc_client: &RpcClient) -> ProcessResult {
+    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+
+    Ok(format!(
+        "blockhash: {}\nlamports per signature: {}",
+        recent_blockhash, fee_calculator.lamports_per_signature
+    ))
 }
 
 pub fn process_leader_schedule(rpc_client: &RpcClient) -> ProcessResult {
@@ -906,7 +910,10 @@ pub fn process_ping(
     timeout: &Duration,
     commitment_config: CommitmentConfig,
 ) -> ProcessResult {
+    let to = Keypair::new().pubkey();
+
     println_name_value("Source Account:", &config.signers[0].pubkey().to_string());
+    println_name_value("Destination Account:", &to.to_string());
     println!();
 
     let (signal_sender, signal_receiver) = std::sync::mpsc::channel();
@@ -915,46 +922,27 @@ pub fn process_ping(
     })
     .expect("Error setting Ctrl-C handler");
 
+    let mut last_blockhash = Hash::default();
     let mut submit_count = 0;
     let mut confirmed_count = 0;
     let mut confirmation_time: VecDeque<u64> = VecDeque::with_capacity(1024);
 
-    let (mut blockhash, mut fee_calculator) = rpc_client.get_recent_blockhash()?;
-    let mut blockhash_transaction_count = 0;
-    let mut blockhash_acquired = Instant::now();
     'mainloop: for seq in 0..count.unwrap_or(std::u64::MAX) {
-        let now = Instant::now();
-        if now.duration_since(blockhash_acquired).as_secs() > 60 {
-            // Fetch a new blockhash every minute
-            let (new_blockhash, new_fee_calculator) = rpc_client.get_new_blockhash(&blockhash)?;
-            blockhash = new_blockhash;
-            fee_calculator = new_fee_calculator;
-            blockhash_transaction_count = 0;
-            blockhash_acquired = Instant::now();
-        }
+        let (recent_blockhash, fee_calculator) = rpc_client.get_new_blockhash(&last_blockhash)?;
+        last_blockhash = recent_blockhash;
 
-        let seed =
-            &format!("{}{}", blockhash_transaction_count, blockhash)[0..pubkey::MAX_SEED_LEN];
-        let to = Pubkey::create_with_seed(&config.signers[0].pubkey(), seed, &system_program::id())
-            .unwrap();
-        blockhash_transaction_count += 1;
-
-        let build_message = |lamports| {
-            let ix = system_instruction::transfer(&config.signers[0].pubkey(), &to, lamports);
-            Message::new(&[ix])
-        };
-        let (message, _) = resolve_spend_tx_and_check_account_balance(
+        let ix = system_instruction::transfer(&config.signers[0].pubkey(), &to, lamports);
+        let message = Message::new(&[ix]);
+        let mut transaction = Transaction::new_unsigned(message);
+        transaction.try_sign(&config.signers, recent_blockhash)?;
+        check_account_for_fee(
             rpc_client,
-            false,
-            SpendAmount::Some(lamports),
-            &fee_calculator,
             &config.signers[0].pubkey(),
-            build_message,
+            &fee_calculator,
+            &transaction.message,
         )?;
-        let mut tx = Transaction::new_unsigned(message);
-        tx.try_sign(&config.signers, blockhash)?;
 
-        match rpc_client.send_transaction(&tx) {
+        match rpc_client.send_transaction(&transaction) {
             Ok(signature) => {
                 let transaction_sent = Instant::now();
                 loop {
@@ -1239,14 +1227,12 @@ pub fn process_show_validators(
         .current
         .iter()
         .chain(vote_accounts.delinquent.iter())
-        .map(|vote_account| vote_account.activated_stake)
-        .sum();
+        .fold(0, |acc, vote_account| acc + vote_account.activated_stake);
 
     let total_deliquent_stake = vote_accounts
         .delinquent
         .iter()
-        .map(|vote_account| vote_account.activated_stake)
-        .sum();
+        .fold(0, |acc, vote_account| acc + vote_account.activated_stake);
     let total_current_stake = total_active_stake - total_deliquent_stake;
 
     let mut current = vote_accounts.current;
@@ -1277,7 +1263,7 @@ pub fn process_transaction_history(
     rpc_client: &RpcClient,
     address: &Pubkey,
     end_slot: Option<Slot>, // None == use latest slot
-    slot_limit: Option<u64>,
+    slot_limit: u64,
 ) -> ProcessResult {
     let end_slot = {
         if let Some(end_slot) = end_slot {
@@ -1286,30 +1272,18 @@ pub fn process_transaction_history(
             rpc_client.get_slot_with_commitment(CommitmentConfig::max())?
         }
     };
-    let mut start_slot = match slot_limit {
-        Some(slot_limit) => end_slot.saturating_sub(slot_limit),
-        None => rpc_client.minimum_ledger_slot()?,
-    };
+    let start_slot = end_slot.saturating_sub(slot_limit);
 
     println!(
         "Transactions affecting {} within slots [{},{}]",
         address, start_slot, end_slot
     );
-
-    let mut transaction_count = 0;
-    while start_slot < end_slot {
-        let signatures = rpc_client.get_confirmed_signatures_for_address(
-            address,
-            start_slot,
-            (start_slot + MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS_SLOT_RANGE).min(end_slot),
-        )?;
-        for signature in &signatures {
-            println!("{}", signature);
-        }
-        transaction_count += signatures.len();
-        start_slot += MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS_SLOT_RANGE;
+    let signatures =
+        rpc_client.get_confirmed_signatures_for_address(address, start_slot, end_slot)?;
+    for signature in &signatures {
+        println!("{}", signature);
     }
-    Ok(format!("{} transactions found", transaction_count))
+    Ok(format!("{} transactions found", signatures.len(),))
 }
 
 #[cfg(test)]

cli/src/lib.rs

@@ -1,35 +1,13 @@
-macro_rules! ACCOUNT_STRING {
-    () => {
-        r#", one of:
-  * a base58-encoded public key
-  * a path to a keypair file
-  * a hyphen; signals a JSON-encoded keypair on stdin
-  * the 'ASK' keyword; to recover a keypair via its seed phrase
-  * a hardware wallet keypair URL (i.e. usb://ledger)"#
-    };
-}
-
-#[macro_use]
-macro_rules! pubkey {
-    ($arg:expr, $help:expr) => {
-        $arg.takes_value(true)
-            .validator(is_valid_pubkey)
-            .help(concat!($help, ACCOUNT_STRING!()))
-    };
-}
-
 #[macro_use]
 extern crate serde_derive;
 
-pub mod checks;
 pub mod cli;
 pub mod cli_output;
 pub mod cluster_query;
 pub mod display;
 pub mod nonce;
 pub mod offline;
-pub mod spend_utils;
 pub mod stake;
-pub mod test_utils;
+pub mod storage;
 pub mod validator_info;
 pub mod vote;

cli/src/main.rs

@@ -156,7 +156,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     let matches = app(
         crate_name!(),
         crate_description!(),
-        solana_version::version!(),
+        solana_clap_utils::version!(),
     )
     .arg({
         let arg = Arg::with_name("config_file")
@@ -210,11 +210,10 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     .arg(
         Arg::with_name("output_format")
             .long("output")
-            .value_name("FORMAT")
             .global(true)
             .takes_value(true)
             .possible_values(&["json", "json-compact"])
-            .help("Return information in specified output format"),
+            .help("Return information in specified output format. Supports: json, json-compact"),
     )
     .arg(
         Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)

cli/src/nonce.rs

@@ -1,11 +1,10 @@
 use crate::{
-    checks::{check_account_for_fee, check_unique_pubkeys},
     cli::{
-        generate_unique_signers, log_instruction_custom_error, CliCommand, CliCommandInfo,
-        CliConfig, CliError, ProcessResult, SignerIndex,
+        check_account_for_fee, check_unique_pubkeys, generate_unique_signers,
+        log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
+        ProcessResult, SignerIndex,
     },
     cli_output::CliNonceAccount,
-    spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
 };
 use clap::{App, Arg, ArgMatches, SubCommand};
 use solana_clap_utils::{
@@ -96,18 +95,22 @@ impl NonceSubCommands for App<'_, '_> {
             SubCommand::with_name("authorize-nonce-account")
                 .about("Assign account authority to a new entity")
                 .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_pubkey")
                         .index(1)
                         .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Address of the nonce account. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Address of the nonce account"),
                 )
                 .arg(
-                    pubkey!(Arg::with_name("new_authority")
+                    Arg::with_name("new_authority")
                         .index(2)
                         .value_name("AUTHORITY_PUBKEY")
-                        .required(true),
-                        "Account to be granted authority of the nonce account. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Account to be granted authority of the nonce account"),
                 )
                 .arg(nonce_authority_arg()),
         )
@@ -129,14 +132,16 @@ impl NonceSubCommands for App<'_, '_> {
                         .value_name("AMOUNT")
                         .takes_value(true)
                         .required(true)
-                        .validator(is_amount_or_all)
-                        .help("The amount to load the nonce account with, in SOL; accepts keyword ALL"),
+                        .validator(is_amount)
+                        .help("The amount to load the nonce account with, in SOL"),
                 )
                 .arg(
-                    pubkey!(Arg::with_name(NONCE_AUTHORITY_ARG.name)
+                    Arg::with_name(NONCE_AUTHORITY_ARG.name)
                         .long(NONCE_AUTHORITY_ARG.long)
-                        .value_name("PUBKEY"),
-                        "Assign noncing authority to another entity. "),
+                        .takes_value(true)
+                        .value_name("PUBKEY")
+                        .validator(is_valid_pubkey)
+                        .help("Assign noncing authority to another entity"),
                 )
                 .arg(
                     Arg::with_name("seed")
@@ -151,22 +156,26 @@ impl NonceSubCommands for App<'_, '_> {
                 .about("Get the current nonce value")
                 .alias("get-nonce")
                 .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_pubkey")
                         .index(1)
                         .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Address of the nonce account to display. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Address of the nonce account to display"),
                 ),
         )
         .subcommand(
             SubCommand::with_name("new-nonce")
                 .about("Generate a new nonce, rendering the existing nonce useless")
                 .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_pubkey")
                         .index(1)
                         .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Address of the nonce account. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Address of the nonce account"),
                 )
                 .arg(nonce_authority_arg()),
         )
@@ -175,11 +184,13 @@ impl NonceSubCommands for App<'_, '_> {
                 .about("Show the contents of a nonce account")
                 .alias("show-nonce-account")
                 .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_pubkey")
                         .index(1)
                         .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Address of the nonce account to display. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Address of the nonce account to display"),
                 )
                 .arg(
                     Arg::with_name("lamports")
@@ -192,18 +203,22 @@ impl NonceSubCommands for App<'_, '_> {
             SubCommand::with_name("withdraw-from-nonce-account")
                 .about("Withdraw SOL from the nonce account")
                 .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_pubkey")
                         .index(1)
                         .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Nonce account to withdraw from. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Nonce account to withdraw from"),
                 )
                 .arg(
-                    pubkey!(Arg::with_name("destination_account_pubkey")
+                    Arg::with_name("destination_account_pubkey")
                         .index(2)
                         .value_name("RECIPIENT_ADDRESS")
-                        .required(true),
-                        "The account to which the SOL should be transferred. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("The account to which the SOL should be transferred"),
                 )
                 .arg(
                     Arg::with_name("amount")
@@ -297,7 +312,7 @@ pub fn parse_nonce_create_account(
     let (nonce_account, nonce_account_pubkey) =
         signer_of(matches, "nonce_account_keypair", wallet_manager)?;
     let seed = matches.value_of("seed").map(|s| s.to_string());
-    let amount = SpendAmount::new_from_matches(matches, "amount");
+    let lamports = lamports_of_sol(matches, "amount").unwrap();
     let nonce_authority = pubkey_of_signer(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
 
     let payer_provided = None;
@@ -313,7 +328,7 @@ pub fn parse_nonce_create_account(
             nonce_account: signer_info.index_of(nonce_account_pubkey).unwrap(),
             seed,
             nonce_authority,
-            amount,
+            lamports,
         },
         signers: signer_info.signers,
     })
@@ -457,11 +472,11 @@ pub fn process_create_nonce_account(
     nonce_account: SignerIndex,
     seed: Option<String>,
     nonce_authority: Option<Pubkey>,
-    amount: SpendAmount,
+    lamports: u64,
 ) -> ProcessResult {
     let nonce_account_pubkey = config.signers[nonce_account].pubkey();
-    let nonce_account_address = if let Some(ref seed) = seed {
-        Pubkey::create_with_seed(&nonce_account_pubkey, seed, &system_program::id())?
+    let nonce_account_address = if let Some(seed) = seed.clone() {
+        Pubkey::create_with_seed(&nonce_account_pubkey, &seed, &system_program::id())?
     } else {
         nonce_account_pubkey
     };
@@ -471,40 +486,6 @@ pub fn process_create_nonce_account(
         (&nonce_account_address, "nonce_account".to_string()),
     )?;
 
-    let nonce_authority = nonce_authority.unwrap_or_else(|| config.signers[0].pubkey());
-
-    let build_message = |lamports| {
-        let ixs = if let Some(seed) = seed.clone() {
-            create_nonce_account_with_seed(
-                &config.signers[0].pubkey(), // from
-                &nonce_account_address,      // to
-                &nonce_account_pubkey,       // base
-                &seed,                       // seed
-                &nonce_authority,
-                lamports,
-            )
-        } else {
-            create_nonce_account(
-                &config.signers[0].pubkey(),
-                &nonce_account_pubkey,
-                &nonce_authority,
-                lamports,
-            )
-        };
-        Message::new_with_payer(&ixs, Some(&config.signers[0].pubkey()))
-    };
-
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
-
-    let (message, lamports) = resolve_spend_tx_and_check_account_balance(
-        rpc_client,
-        false,
-        amount,
-        &fee_calculator,
-        &config.signers[0].pubkey(),
-        build_message,
-    )?;
-
     if let Ok(nonce_account) = get_account(rpc_client, &nonce_account_address) {
         let err_msg = if state_from_account(&nonce_account).is_ok() {
             format!("Nonce account {} already exists", nonce_account_address)
@@ -526,8 +507,38 @@ pub fn process_create_nonce_account(
         .into());
     }
 
+    let nonce_authority = nonce_authority.unwrap_or_else(|| config.signers[0].pubkey());
+
+    let ixs = if let Some(seed) = seed {
+        create_nonce_account_with_seed(
+            &config.signers[0].pubkey(), // from
+            &nonce_account_address,      // to
+            &nonce_account_pubkey,       // base
+            &seed,                       // seed
+            &nonce_authority,
+            lamports,
+        )
+    } else {
+        create_nonce_account(
+            &config.signers[0].pubkey(),
+            &nonce_account_pubkey,
+            &nonce_authority,
+            lamports,
+        )
+    };
+
+    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+
+    let message = Message::new_with_payer(&ixs, Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
+
+    check_account_for_fee(
+        rpc_client,
+        &config.signers[0].pubkey(),
+        &fee_calculator,
+        &tx.message,
+    )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
     log_instruction_custom_error::<SystemError>(result, &config)
 }
@@ -734,7 +745,7 @@ mod tests {
                     nonce_account: 1,
                     seed: None,
                     nonce_authority: None,
-                    amount: SpendAmount::Some(50_000_000_000),
+                    lamports: 50_000_000_000,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -759,7 +770,7 @@ mod tests {
                     nonce_account: 1,
                     seed: None,
                     nonce_authority: Some(nonce_authority_keypair.pubkey()),
-                    amount: SpendAmount::Some(50_000_000_000),
+                    lamports: 50_000_000_000,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -910,18 +921,16 @@ mod tests {
         assert!(check_nonce_account(&valid.unwrap(), &nonce_pubkey, &blockhash).is_ok());
 
         let invalid_owner = Account::new_data(1, &data, &Pubkey::new(&[1u8; 32]));
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_owner.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidAccountOwner,);
-        }
+        assert_eq!(
+            check_nonce_account(&invalid_owner.unwrap(), &nonce_pubkey, &blockhash),
+            Err(CliNonceError::InvalidAccountOwner.into()),
+        );
 
         let invalid_data = Account::new_data(1, &"invalid", &system_program::ID);
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_data.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidAccountData,);
-        }
+        assert_eq!(
+            check_nonce_account(&invalid_data.unwrap(), &nonce_pubkey, &blockhash),
+            Err(CliNonceError::InvalidAccountData.into()),
+        );
 
         let data = Versions::new_current(State::Initialized(nonce::state::Data {
             authority: nonce_pubkey,
@@ -929,11 +938,10 @@ mod tests {
             fee_calculator: FeeCalculator::default(),
         }));
         let invalid_hash = Account::new_data(1, &data, &system_program::ID);
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_hash.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidHash,);
-        }
+        assert_eq!(
+            check_nonce_account(&invalid_hash.unwrap(), &nonce_pubkey, &blockhash),
+            Err(CliNonceError::InvalidHash.into()),
+        );
 
         let data = Versions::new_current(State::Initialized(nonce::state::Data {
             authority: Pubkey::new_rand(),
@@ -941,19 +949,17 @@ mod tests {
             fee_calculator: FeeCalculator::default(),
         }));
         let invalid_authority = Account::new_data(1, &data, &system_program::ID);
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_authority.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidAuthority,);
-        }
+        assert_eq!(
+            check_nonce_account(&invalid_authority.unwrap(), &nonce_pubkey, &blockhash),
+            Err(CliNonceError::InvalidAuthority.into()),
+        );
 
         let data = Versions::new_current(State::Uninitialized);
         let invalid_state = Account::new_data(1, &data, &system_program::ID);
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_state.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidStateForOperation,);
-        }
+        assert_eq!(
+            check_nonce_account(&invalid_state.unwrap(), &nonce_pubkey, &blockhash),
+            Err(CliNonceError::InvalidStateForOperation.into()),
+        );
     }
 
     #[test]

cli/src/offline/blockhash_query.rs

@@ -303,19 +303,19 @@ mod tests {
         );
         mocks.insert(
             RpcRequest::GetFeeCalculatorForBlockhash,
-            get_fee_calculator_for_blockhash_response,
+            get_fee_calculator_for_blockhash_response.clone(),
         );
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::FeeCalculator(Source::Cluster, test_blockhash)
                 .get_blockhash_and_fee_calculator(&rpc_client)
                 .unwrap(),
-            (test_blockhash, rpc_fee_calc),
+            (test_blockhash, rpc_fee_calc.clone()),
         );
         let mut mocks = HashMap::new();
         mocks.insert(
             RpcRequest::GetRecentBlockhash,
-            get_recent_blockhash_response,
+            get_recent_blockhash_response.clone(),
         );
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
@@ -347,7 +347,7 @@ mod tests {
         let rpc_nonce_account = RpcAccount::encode(nonce_account);
         let get_account_response = json!(Response {
             context: RpcResponseContext { slot: 1 },
-            value: json!(Some(rpc_nonce_account)),
+            value: json!(Some(rpc_nonce_account.clone())),
         });
 
         let mut mocks = HashMap::new();
@@ -366,7 +366,7 @@ mod tests {
             BlockhashQuery::FeeCalculator(Source::NonceAccount(nonce_pubkey), nonce_blockhash)
                 .get_blockhash_and_fee_calculator(&rpc_client)
                 .unwrap(),
-            (nonce_blockhash, nonce_fee_calc),
+            (nonce_blockhash, nonce_fee_calc.clone()),
         );
         let mut mocks = HashMap::new();
         mocks.insert(RpcRequest::GetAccountInfo, get_account_response.clone());
@@ -377,7 +377,7 @@ mod tests {
                 .is_err()
         );
         let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetAccountInfo, get_account_response);
+        mocks.insert(RpcRequest::GetAccountInfo, get_account_response.clone());
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::None(nonce_blockhash)

cli/src/spend_utils.rs

@@ -1,158 +0,0 @@
-use crate::{
-    checks::{calculate_fee, check_account_for_balance},
-    cli::CliError,
-};
-use clap::ArgMatches;
-use solana_clap_utils::{input_parsers::lamports_of_sol, offline::SIGN_ONLY_ARG};
-use solana_client::rpc_client::RpcClient;
-use solana_sdk::{
-    fee_calculator::FeeCalculator, message::Message, native_token::lamports_to_sol, pubkey::Pubkey,
-};
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum SpendAmount {
-    All,
-    Some(u64),
-}
-
-impl Default for SpendAmount {
-    fn default() -> Self {
-        Self::Some(u64::default())
-    }
-}
-
-impl SpendAmount {
-    pub fn new(amount: Option<u64>, sign_only: bool) -> Self {
-        match amount {
-            Some(lamports) => Self::Some(lamports),
-            None if !sign_only => Self::All,
-            _ => panic!("ALL amount not supported for sign-only operations"),
-        }
-    }
-
-    pub fn new_from_matches(matches: &ArgMatches<'_>, name: &str) -> Self {
-        let amount = lamports_of_sol(matches, name);
-        let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
-        SpendAmount::new(amount, sign_only)
-    }
-}
-
-struct SpendAndFee {
-    spend: u64,
-    fee: u64,
-}
-
-pub fn resolve_spend_tx_and_check_account_balance<F>(
-    rpc_client: &RpcClient,
-    sign_only: bool,
-    amount: SpendAmount,
-    fee_calculator: &FeeCalculator,
-    from_pubkey: &Pubkey,
-    build_message: F,
-) -> Result<(Message, u64), CliError>
-where
-    F: Fn(u64) -> Message,
-{
-    resolve_spend_tx_and_check_account_balances(
-        rpc_client,
-        sign_only,
-        amount,
-        fee_calculator,
-        from_pubkey,
-        from_pubkey,
-        build_message,
-    )
-}
-
-pub fn resolve_spend_tx_and_check_account_balances<F>(
-    rpc_client: &RpcClient,
-    sign_only: bool,
-    amount: SpendAmount,
-    fee_calculator: &FeeCalculator,
-    from_pubkey: &Pubkey,
-    fee_pubkey: &Pubkey,
-    build_message: F,
-) -> Result<(Message, u64), CliError>
-where
-    F: Fn(u64) -> Message,
-{
-    if sign_only {
-        let (message, SpendAndFee { spend, fee: _ }) = resolve_spend_message(
-            amount,
-            fee_calculator,
-            0,
-            from_pubkey,
-            fee_pubkey,
-            build_message,
-        );
-        Ok((message, spend))
-    } else {
-        let from_balance = rpc_client.get_balance(&from_pubkey)?;
-        let (message, SpendAndFee { spend, fee }) = resolve_spend_message(
-            amount,
-            fee_calculator,
-            from_balance,
-            from_pubkey,
-            fee_pubkey,
-            build_message,
-        );
-        if from_pubkey == fee_pubkey {
-            if from_balance == 0 || from_balance < spend + fee {
-                return Err(CliError::InsufficientFundsForSpendAndFee(
-                    lamports_to_sol(spend),
-                    lamports_to_sol(fee),
-                ));
-            }
-        } else {
-            if from_balance < spend {
-                return Err(CliError::InsufficientFundsForSpend(lamports_to_sol(spend)));
-            }
-            if !check_account_for_balance(rpc_client, fee_pubkey, fee)? {
-                return Err(CliError::InsufficientFundsForFee(lamports_to_sol(fee)));
-            }
-        }
-        Ok((message, spend))
-    }
-}
-
-fn resolve_spend_message<F>(
-    amount: SpendAmount,
-    fee_calculator: &FeeCalculator,
-    from_balance: u64,
-    from_pubkey: &Pubkey,
-    fee_pubkey: &Pubkey,
-    build_message: F,
-) -> (Message, SpendAndFee)
-where
-    F: Fn(u64) -> Message,
-{
-    match amount {
-        SpendAmount::Some(lamports) => {
-            let message = build_message(lamports);
-            let fee = calculate_fee(fee_calculator, &[&message]);
-            (
-                message,
-                SpendAndFee {
-                    spend: lamports,
-                    fee,
-                },
-            )
-        }
-        SpendAmount::All => {
-            let dummy_message = build_message(0);
-            let fee = calculate_fee(fee_calculator, &[&dummy_message]);
-            let lamports = if from_pubkey == fee_pubkey {
-                from_balance.saturating_sub(fee)
-            } else {
-                from_balance
-            };
-            (
-                build_message(lamports),
-                SpendAndFee {
-                    spend: lamports,
-                    fee,
-                },
-            )
-        }
-    }
-}

cli/src/stake.rs

@@ -1,14 +1,12 @@
 use crate::{
-    checks::{check_account_for_fee, check_unique_pubkeys},
     cli::{
-        fee_payer_arg, generate_unique_signers, log_instruction_custom_error, nonce_authority_arg,
-        return_signers, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult,
-        SignerIndex, FEE_PAYER_ARG,
+        check_account_for_fee, check_unique_pubkeys, fee_payer_arg, generate_unique_signers,
+        log_instruction_custom_error, nonce_authority_arg, return_signers, CliCommand,
+        CliCommandInfo, CliConfig, CliError, ProcessResult, SignerIndex, FEE_PAYER_ARG,
     },
     cli_output::{CliStakeHistory, CliStakeHistoryEntry, CliStakeState, CliStakeType},
     nonce::{check_nonce_account, nonce_arg, NONCE_ARG, NONCE_AUTHORITY_ARG},
     offline::{blockhash_query::BlockhashQuery, *},
-    spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount},
 };
 use clap::{App, Arg, ArgGroup, ArgMatches, SubCommand};
 use solana_clap_utils::{input_parsers::*, input_validators::*, offline::*, ArgConstant};
@@ -85,15 +83,17 @@ impl StakeSubCommands for App<'_, '_> {
                         .index(2)
                         .value_name("AMOUNT")
                         .takes_value(true)
-                        .validator(is_amount_or_all)
+                        .validator(is_amount)
                         .required(true)
-                        .help("The amount to send to the stake account, in SOL; accepts keyword ALL")
+                        .help("The amount to send to the stake account, in SOL")
                 )
                 .arg(
-                    pubkey!(Arg::with_name("custodian")
+                    Arg::with_name("custodian")
                         .long("custodian")
-                        .value_name("PUBKEY"),
-                        "Authority to modify lockups. ")
+                        .value_name("PUBKEY")
+                        .takes_value(true)
+                        .validator(is_valid_pubkey)
+                        .help("Authority to modify lockups")
                 )
                 .arg(
                     Arg::with_name("seed")
@@ -157,18 +157,22 @@ impl StakeSubCommands for App<'_, '_> {
                         .help("Override vote account sanity checks (use carefully!)")
                 )
                 .arg(
-                    pubkey!(Arg::with_name("stake_account_pubkey")
+                    Arg::with_name("stake_account_pubkey")
                         .index(1)
                         .value_name("STAKE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Stake account to delegate")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Stake account to delegate")
                 )
                 .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
+                    Arg::with_name("vote_account_pubkey")
                         .index(2)
                         .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "The vote account to which the stake will be delegated")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("The vote account to which the stake will be delegated")
                 )
                 .arg(stake_authority_arg())
                 .offline_args()
@@ -180,25 +184,31 @@ impl StakeSubCommands for App<'_, '_> {
             SubCommand::with_name("stake-authorize")
                 .about("Authorize a new signing keypair for the given stake account")
                 .arg(
-                    pubkey!(Arg::with_name("stake_account_pubkey")
+                    Arg::with_name("stake_account_pubkey")
                         .required(true)
                         .index(1)
-                        .value_name("STAKE_ACCOUNT_ADDRESS"),
-                        "Stake account in which to set a new authority. ")
+                        .takes_value(true)
+                        .value_name("STAKE_ACCOUNT_ADDRESS")
+                        .validator(is_valid_pubkey)
+                        .help("Stake account in which to set a new authority")
                 )
                 .arg(
-                    pubkey!(Arg::with_name("new_stake_authority")
+                    Arg::with_name("new_stake_authority")
                         .long("new-stake-authority")
                         .required_unless("new_withdraw_authority")
-                        .value_name("PUBKEY"),
-                        "New authorized staker")
+                        .takes_value(true)
+                        .value_name("PUBKEY")
+                        .validator(is_valid_pubkey)
+                        .help("New authorized staker")
                 )
                 .arg(
-                    pubkey!(Arg::with_name("new_withdraw_authority")
+                    Arg::with_name("new_withdraw_authority")
                         .long("new-withdraw-authority")
                         .required_unless("new_stake_authority")
-                        .value_name("PUBKEY"),
-                        "New authorized withdrawer. ")
+                        .takes_value(true)
+                        .value_name("PUBKEY")
+                        .validator(is_valid_pubkey)
+                        .help("New authorized withdrawer")
                 )
                 .arg(stake_authority_arg())
                 .arg(withdraw_authority_arg())
@@ -211,11 +221,13 @@ impl StakeSubCommands for App<'_, '_> {
             SubCommand::with_name("deactivate-stake")
                 .about("Deactivate the delegated stake from the stake account")
                 .arg(
-                    pubkey!(Arg::with_name("stake_account_pubkey")
+                    Arg::with_name("stake_account_pubkey")
                         .index(1)
                         .value_name("STAKE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Stake account to be deactivated. ")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Stake account to be deactivated.")
                 )
                 .arg(stake_authority_arg())
                 .offline_args()
@@ -227,11 +239,13 @@ impl StakeSubCommands for App<'_, '_> {
             SubCommand::with_name("split-stake")
                 .about("Duplicate a stake account, splitting the tokens between the two")
                 .arg(
-                    pubkey!(Arg::with_name("stake_account_pubkey")
+                    Arg::with_name("stake_account_pubkey")
                         .index(1)
                         .value_name("STAKE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Stake account to split (or base of derived address if --seed is used). ")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Stake account to split (or base of derived address if --seed is used)")
                 )
                 .arg(
                     Arg::with_name("split_stake_account")
@@ -268,18 +282,22 @@ impl StakeSubCommands for App<'_, '_> {
             SubCommand::with_name("withdraw-stake")
                 .about("Withdraw the unstaked SOL from the stake account")
                 .arg(
-                    pubkey!(Arg::with_name("stake_account_pubkey")
+                    Arg::with_name("stake_account_pubkey")
                         .index(1)
                         .value_name("STAKE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Stake account from which to withdraw")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Stake account from which to withdraw")
                 )
                 .arg(
-                    pubkey!(Arg::with_name("destination_account_pubkey")
+                    Arg::with_name("destination_account_pubkey")
                         .index(2)
                         .value_name("RECIPIENT_ADDRESS")
-                        .required(true),
-                        "Recipient of withdrawn SOL")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Recipient of withdrawn SOL")
                 )
                 .arg(
                     Arg::with_name("amount")
@@ -308,11 +326,13 @@ impl StakeSubCommands for App<'_, '_> {
             SubCommand::with_name("stake-set-lockup")
                 .about("Set Lockup for the stake account")
                 .arg(
-                    pubkey!(Arg::with_name("stake_account_pubkey")
+                    Arg::with_name("stake_account_pubkey")
                         .index(1)
                         .value_name("STAKE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Stake account for which to set lockup parameters. ")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Stake account for which to set lockup parameters")
                 )
                 .arg(
                     Arg::with_name("lockup_epoch")
@@ -330,14 +350,15 @@ impl StakeSubCommands for App<'_, '_> {
                         .help("The date and time at which this account will be available for withdrawal")
                 )
                 .arg(
-                    pubkey!(Arg::with_name("new_custodian")
+                    Arg::with_name("new_custodian")
                         .long("new-custodian")
-                        .value_name("PUBKEY"),
-                        "Identity of a new lockup custodian. ")
+                        .value_name("PUBKEY")
+                        .takes_value(true)
+                        .validator(is_valid_pubkey)
+                        .help("Identity of a new lockup custodian")
                 )
                 .group(ArgGroup::with_name("lockup_details")
                     .args(&["lockup_epoch", "lockup_date", "new_custodian"])
-                    .multiple(true)
                     .required(true))
                 .arg(
                     Arg::with_name("custodian")
@@ -357,11 +378,13 @@ impl StakeSubCommands for App<'_, '_> {
                 .about("Show the contents of a stake account")
                 .alias("show-stake-account")
                 .arg(
-                    pubkey!(Arg::with_name("stake_account_pubkey")
+                    Arg::with_name("stake_account_pubkey")
                         .index(1)
                         .value_name("STAKE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "The stake account to display. ")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("The stake account to display")
                 )
                 .arg(
                     Arg::with_name("lamports")
@@ -395,7 +418,7 @@ pub fn parse_stake_create_account(
     let custodian = pubkey_of_signer(matches, "custodian", wallet_manager)?.unwrap_or_default();
     let staker = pubkey_of_signer(matches, STAKE_AUTHORITY_ARG.name, wallet_manager)?;
     let withdrawer = pubkey_of_signer(matches, WITHDRAW_AUTHORITY_ARG.name, wallet_manager)?;
-    let amount = SpendAmount::new_from_matches(matches, "amount");
+    let lamports = lamports_of_sol(matches, "amount").unwrap();
     let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
     let blockhash_query = BlockhashQuery::new_from_matches(matches);
     let nonce_account = pubkey_of_signer(matches, NONCE_ARG.name, wallet_manager)?;
@@ -424,7 +447,7 @@ pub fn parse_stake_create_account(
                 epoch,
                 unix_timestamp,
             },
-            amount,
+            lamports,
             sign_only,
             blockhash_query,
             nonce_account,
@@ -769,7 +792,7 @@ pub fn process_create_stake_account(
     staker: &Option<Pubkey>,
     withdrawer: &Option<Pubkey>,
     lockup: &Lockup,
-    amount: SpendAmount,
+    lamports: u64,
     sign_only: bool,
     blockhash_query: &BlockhashQuery,
     nonce_account: Option<&Pubkey>,
@@ -789,59 +812,6 @@ pub fn process_create_stake_account(
         (&stake_account_address, "stake_account".to_string()),
     )?;
 
-    let fee_payer = config.signers[fee_payer];
-    let nonce_authority = config.signers[nonce_authority];
-
-    let build_message = |lamports| {
-        let authorized = Authorized {
-            staker: staker.unwrap_or(from.pubkey()),
-            withdrawer: withdrawer.unwrap_or(from.pubkey()),
-        };
-
-        let ixs = if let Some(seed) = seed {
-            stake_instruction::create_account_with_seed(
-                &from.pubkey(),          // from
-                &stake_account_address,  // to
-                &stake_account.pubkey(), // base
-                seed,                    // seed
-                &authorized,
-                lockup,
-                lamports,
-            )
-        } else {
-            stake_instruction::create_account(
-                &from.pubkey(),
-                &stake_account.pubkey(),
-                &authorized,
-                lockup,
-                lamports,
-            )
-        };
-        if let Some(nonce_account) = &nonce_account {
-            Message::new_with_nonce(
-                ixs,
-                Some(&fee_payer.pubkey()),
-                nonce_account,
-                &nonce_authority.pubkey(),
-            )
-        } else {
-            Message::new_with_payer(&ixs, Some(&fee_payer.pubkey()))
-        }
-    };
-
-    let (recent_blockhash, fee_calculator) =
-        blockhash_query.get_blockhash_and_fee_calculator(rpc_client)?;
-
-    let (message, lamports) = resolve_spend_tx_and_check_account_balances(
-        rpc_client,
-        sign_only,
-        amount,
-        &fee_calculator,
-        &from.pubkey(),
-        &fee_payer.pubkey(),
-        build_message,
-    )?;
-
     if !sign_only {
         if let Ok(stake_account) = rpc_client.get_account(&stake_account_address) {
             let err_msg = if stake_account.owner == solana_stake_program::id() {
@@ -865,19 +835,65 @@ pub fn process_create_stake_account(
             ))
             .into());
         }
-
-        if let Some(nonce_account) = &nonce_account {
-            let nonce_account = rpc_client.get_account(nonce_account)?;
-            check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
-        }
     }
 
+    let authorized = Authorized {
+        staker: staker.unwrap_or(from.pubkey()),
+        withdrawer: withdrawer.unwrap_or(from.pubkey()),
+    };
+
+    let ixs = if let Some(seed) = seed {
+        stake_instruction::create_account_with_seed(
+            &from.pubkey(),          // from
+            &stake_account_address,  // to
+            &stake_account.pubkey(), // base
+            seed,                    // seed
+            &authorized,
+            lockup,
+            lamports,
+        )
+    } else {
+        stake_instruction::create_account(
+            &from.pubkey(),
+            &stake_account.pubkey(),
+            &authorized,
+            lockup,
+            lamports,
+        )
+    };
+    let (recent_blockhash, fee_calculator) =
+        blockhash_query.get_blockhash_and_fee_calculator(rpc_client)?;
+
+    let fee_payer = config.signers[fee_payer];
+    let nonce_authority = config.signers[nonce_authority];
+
+    let message = if let Some(nonce_account) = &nonce_account {
+        Message::new_with_nonce(
+            ixs,
+            Some(&fee_payer.pubkey()),
+            nonce_account,
+            &nonce_authority.pubkey(),
+        )
+    } else {
+        Message::new_with_payer(&ixs, Some(&fee_payer.pubkey()))
+    };
     let mut tx = Transaction::new_unsigned(message);
+
     if sign_only {
         tx.try_partial_sign(&config.signers, recent_blockhash)?;
         return_signers(&tx, &config)
     } else {
         tx.try_sign(&config.signers, recent_blockhash)?;
+        if let Some(nonce_account) = &nonce_account {
+            let nonce_account = rpc_client.get_account(nonce_account)?;
+            check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
+        }
+        check_account_for_fee(
+            rpc_client,
+            &tx.message.account_keys[0],
+            &fee_calculator,
+            &tx.message,
+        )?;
         let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
         log_instruction_custom_error::<SystemError>(result, &config)
     }
@@ -1482,7 +1498,6 @@ mod tests {
     }
 
     #[test]
-    #[allow(clippy::cognitive_complexity)]
     fn test_parse_command() {
         let test_commands = app("test", "desc", "version");
         let default_keypair = Keypair::new();
@@ -2035,7 +2050,7 @@ mod tests {
                         unix_timestamp: 0,
                         custodian,
                     },
-                    amount: SpendAmount::Some(50_000_000_000),
+                    lamports: 50_000_000_000,
                     sign_only: false,
                     blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
                     nonce_account: None,
@@ -2077,7 +2092,7 @@ mod tests {
                     staker: None,
                     withdrawer: None,
                     lockup: Lockup::default(),
-                    amount: SpendAmount::Some(50_000_000_000),
+                    lamports: 50_000_000_000,
                     sign_only: false,
                     blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
                     nonce_account: None,
@@ -2135,7 +2150,7 @@ mod tests {
                     staker: None,
                     withdrawer: None,
                     lockup: Lockup::default(),
-                    amount: SpendAmount::Some(50_000_000_000),
+                    lamports: 50_000_000_000,
                     sign_only: false,
                     blockhash_query: BlockhashQuery::FeeCalculator(
                         blockhash_query::Source::NonceAccount(nonce_account),
@@ -2862,7 +2877,7 @@ mod tests {
                         blockhash_query::Source::NonceAccount(nonce_account),
                         nonce_hash
                     ),
-                    nonce_account: Some(nonce_account),
+                    nonce_account: Some(nonce_account.into()),
                     nonce_authority: 1,
                     split_stake_account: 2,
                     seed: None,

cli/src/storage.rs

@@ -0,0 +1,398 @@
+use crate::cli::{
+    check_account_for_fee, check_unique_pubkeys, generate_unique_signers,
+    log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult,
+    SignerIndex,
+};
+use clap::{App, Arg, ArgMatches, SubCommand};
+use solana_clap_utils::{input_parsers::*, input_validators::*, keypair::signer_from_path};
+use solana_client::rpc_client::RpcClient;
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
+    account_utils::StateMut, message::Message, pubkey::Pubkey, system_instruction::SystemError,
+    transaction::Transaction,
+};
+use solana_storage_program::storage_instruction::{self, StorageAccountType};
+use std::sync::Arc;
+
+pub trait StorageSubCommands {
+    fn storage_subcommands(self) -> Self;
+}
+
+impl StorageSubCommands for App<'_, '_> {
+    fn storage_subcommands(self) -> Self {
+        self.subcommand(
+            SubCommand::with_name("create-archiver-storage-account")
+                .about("Create an archiver storage account")
+                .arg(
+                    Arg::with_name("storage_account_owner")
+                        .index(1)
+                        .value_name("AUTHORITY_PUBKEY")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey),
+                )
+                .arg(
+                    Arg::with_name("storage_account")
+                        .index(2)
+                        .value_name("ACCOUNT_KEYPAIR")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_signer),
+                ),
+        )
+        .subcommand(
+            SubCommand::with_name("create-validator-storage-account")
+                .about("Create a validator storage account")
+                .arg(
+                    Arg::with_name("storage_account_owner")
+                        .index(1)
+                        .value_name("AUTHORITY_PUBKEY")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey),
+                )
+                .arg(
+                    Arg::with_name("storage_account")
+                        .index(2)
+                        .value_name("ACCOUNT_KEYPAIR")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_signer),
+                ),
+        )
+        .subcommand(
+            SubCommand::with_name("claim-storage-reward")
+                .about("Redeem storage reward credits")
+                .arg(
+                    Arg::with_name("node_account_pubkey")
+                        .index(1)
+                        .value_name("NODE_ACCOUNT_ADDRESS")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("The node account to credit the rewards to"),
+                )
+                .arg(
+                    Arg::with_name("storage_account_pubkey")
+                        .index(2)
+                        .value_name("STORAGE_ACCOUNT_ADDRESS")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Storage account address to redeem credits for"),
+                ),
+        )
+        .subcommand(
+            SubCommand::with_name("storage-account")
+                .about("Show the contents of a storage account")
+                .alias("show-storage-account")
+                .arg(
+                    Arg::with_name("storage_account_pubkey")
+                        .index(1)
+                        .value_name("STORAGE_ACCOUNT_ADDRESS")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Storage account address"),
+                ),
+        )
+    }
+}
+
+pub fn parse_storage_create_archiver_account(
+    matches: &ArgMatches<'_>,
+    default_signer_path: &str,
+    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+) -> Result<CliCommandInfo, CliError> {
+    let account_owner =
+        pubkey_of_signer(matches, "storage_account_owner", wallet_manager)?.unwrap();
+    let (storage_account, storage_account_pubkey) =
+        signer_of(matches, "storage_account", wallet_manager)?;
+
+    let payer_provided = None;
+    let signer_info = generate_unique_signers(
+        vec![payer_provided, storage_account],
+        matches,
+        default_signer_path,
+        wallet_manager,
+    )?;
+
+    Ok(CliCommandInfo {
+        command: CliCommand::CreateStorageAccount {
+            account_owner,
+            storage_account: signer_info.index_of(storage_account_pubkey).unwrap(),
+            account_type: StorageAccountType::Archiver,
+        },
+        signers: signer_info.signers,
+    })
+}
+
+pub fn parse_storage_create_validator_account(
+    matches: &ArgMatches<'_>,
+    default_signer_path: &str,
+    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+) -> Result<CliCommandInfo, CliError> {
+    let account_owner =
+        pubkey_of_signer(matches, "storage_account_owner", wallet_manager)?.unwrap();
+    let (storage_account, storage_account_pubkey) =
+        signer_of(matches, "storage_account", wallet_manager)?;
+
+    let payer_provided = None;
+    let signer_info = generate_unique_signers(
+        vec![payer_provided, storage_account],
+        matches,
+        default_signer_path,
+        wallet_manager,
+    )?;
+
+    Ok(CliCommandInfo {
+        command: CliCommand::CreateStorageAccount {
+            account_owner,
+            storage_account: signer_info.index_of(storage_account_pubkey).unwrap(),
+            account_type: StorageAccountType::Validator,
+        },
+        signers: signer_info.signers,
+    })
+}
+
+pub fn parse_storage_claim_reward(
+    matches: &ArgMatches<'_>,
+    default_signer_path: &str,
+    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+) -> Result<CliCommandInfo, CliError> {
+    let node_account_pubkey =
+        pubkey_of_signer(matches, "node_account_pubkey", wallet_manager)?.unwrap();
+    let storage_account_pubkey =
+        pubkey_of_signer(matches, "storage_account_pubkey", wallet_manager)?.unwrap();
+    Ok(CliCommandInfo {
+        command: CliCommand::ClaimStorageReward {
+            node_account_pubkey,
+            storage_account_pubkey,
+        },
+        signers: vec![signer_from_path(
+            matches,
+            default_signer_path,
+            "keypair",
+            wallet_manager,
+        )?],
+    })
+}
+
+pub fn parse_storage_get_account_command(
+    matches: &ArgMatches<'_>,
+    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+) -> Result<CliCommandInfo, CliError> {
+    let storage_account_pubkey =
+        pubkey_of_signer(matches, "storage_account_pubkey", wallet_manager)?.unwrap();
+    Ok(CliCommandInfo {
+        command: CliCommand::ShowStorageAccount(storage_account_pubkey),
+        signers: vec![],
+    })
+}
+
+pub fn process_create_storage_account(
+    rpc_client: &RpcClient,
+    config: &CliConfig,
+    storage_account: SignerIndex,
+    account_owner: &Pubkey,
+    account_type: StorageAccountType,
+) -> ProcessResult {
+    let storage_account = config.signers[storage_account];
+    let storage_account_pubkey = storage_account.pubkey();
+    check_unique_pubkeys(
+        (&config.signers[0].pubkey(), "cli keypair".to_string()),
+        (
+            &storage_account_pubkey,
+            "storage_account_pubkey".to_string(),
+        ),
+    )?;
+
+    if let Ok(storage_account) = rpc_client.get_account(&storage_account_pubkey) {
+        let err_msg = if storage_account.owner == solana_storage_program::id() {
+            format!("Storage account {} already exists", storage_account_pubkey)
+        } else {
+            format!(
+                "Account {} already exists and is not a storage account",
+                storage_account_pubkey
+            )
+        };
+        return Err(CliError::BadParameter(err_msg).into());
+    }
+
+    use solana_storage_program::storage_contract::STORAGE_ACCOUNT_SPACE;
+    let required_balance = rpc_client
+        .get_minimum_balance_for_rent_exemption(STORAGE_ACCOUNT_SPACE as usize)?
+        .max(1);
+
+    let ixs = storage_instruction::create_storage_account(
+        &config.signers[0].pubkey(),
+        &account_owner,
+        &storage_account_pubkey,
+        required_balance,
+        account_type,
+    );
+    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+
+    let message = Message::new(&ixs);
+    let mut tx = Transaction::new_unsigned(message);
+    tx.try_sign(&config.signers, recent_blockhash)?;
+    check_account_for_fee(
+        rpc_client,
+        &config.signers[0].pubkey(),
+        &fee_calculator,
+        &tx.message,
+    )?;
+    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    log_instruction_custom_error::<SystemError>(result, &config)
+}
+
+pub fn process_claim_storage_reward(
+    rpc_client: &RpcClient,
+    config: &CliConfig,
+    node_account_pubkey: &Pubkey,
+    storage_account_pubkey: &Pubkey,
+) -> ProcessResult {
+    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+
+    let instruction =
+        storage_instruction::claim_reward(node_account_pubkey, storage_account_pubkey);
+    let signers = [config.signers[0]];
+    let message = Message::new_with_payer(&[instruction], Some(&signers[0].pubkey()));
+    let mut tx = Transaction::new_unsigned(message);
+    tx.try_sign(&signers, recent_blockhash)?;
+    check_account_for_fee(
+        rpc_client,
+        &config.signers[0].pubkey(),
+        &fee_calculator,
+        &tx.message,
+    )?;
+    let signature = rpc_client.send_and_confirm_transaction_with_spinner(&tx)?;
+    Ok(signature.to_string())
+}
+
+pub fn process_show_storage_account(
+    rpc_client: &RpcClient,
+    _config: &CliConfig,
+    storage_account_pubkey: &Pubkey,
+) -> ProcessResult {
+    let account = rpc_client.get_account(storage_account_pubkey)?;
+
+    if account.owner != solana_storage_program::id() {
+        return Err(CliError::RpcRequestError(format!(
+            "{:?} is not a storage account",
+            storage_account_pubkey
+        ))
+        .into());
+    }
+
+    use solana_storage_program::storage_contract::StorageContract;
+    let storage_contract: StorageContract = account.state().map_err(|err| {
+        CliError::RpcRequestError(format!("Unable to deserialize storage account: {}", err))
+    })?;
+    println!("{:#?}", storage_contract);
+    println!("Account Lamports: {}", account.lamports);
+    Ok("".to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cli::{app, parse_command};
+    use solana_sdk::signature::{read_keypair_file, write_keypair, Keypair, Signer};
+    use tempfile::NamedTempFile;
+
+    fn make_tmp_file() -> (String, NamedTempFile) {
+        let tmp_file = NamedTempFile::new().unwrap();
+        (String::from(tmp_file.path().to_str().unwrap()), tmp_file)
+    }
+
+    #[test]
+    fn test_parse_command() {
+        let test_commands = app("test", "desc", "version");
+        let pubkey = Pubkey::new_rand();
+        let pubkey_string = pubkey.to_string();
+
+        let default_keypair = Keypair::new();
+        let (default_keypair_file, mut tmp_file) = make_tmp_file();
+        write_keypair(&default_keypair, tmp_file.as_file_mut()).unwrap();
+
+        let (keypair_file, mut tmp_file) = make_tmp_file();
+        let storage_account_keypair = Keypair::new();
+        write_keypair(&storage_account_keypair, tmp_file.as_file_mut()).unwrap();
+
+        let test_create_archiver_storage_account = test_commands.clone().get_matches_from(vec![
+            "test",
+            "create-archiver-storage-account",
+            &pubkey_string,
+            &keypair_file,
+        ]);
+        assert_eq!(
+            parse_command(
+                &test_create_archiver_storage_account,
+                &default_keypair_file,
+                &mut None
+            )
+            .unwrap(),
+            CliCommandInfo {
+                command: CliCommand::CreateStorageAccount {
+                    account_owner: pubkey,
+                    storage_account: 1,
+                    account_type: StorageAccountType::Archiver,
+                },
+                signers: vec![
+                    read_keypair_file(&default_keypair_file).unwrap().into(),
+                    storage_account_keypair.into()
+                ],
+            }
+        );
+
+        let (keypair_file, mut tmp_file) = make_tmp_file();
+        let storage_account_keypair = Keypair::new();
+        write_keypair(&storage_account_keypair, tmp_file.as_file_mut()).unwrap();
+        let storage_account_pubkey = storage_account_keypair.pubkey();
+        let storage_account_string = storage_account_pubkey.to_string();
+
+        let test_create_validator_storage_account = test_commands.clone().get_matches_from(vec![
+            "test",
+            "create-validator-storage-account",
+            &pubkey_string,
+            &keypair_file,
+        ]);
+        assert_eq!(
+            parse_command(
+                &test_create_validator_storage_account,
+                &default_keypair_file,
+                &mut None
+            )
+            .unwrap(),
+            CliCommandInfo {
+                command: CliCommand::CreateStorageAccount {
+                    account_owner: pubkey,
+                    storage_account: 1,
+                    account_type: StorageAccountType::Validator,
+                },
+                signers: vec![
+                    read_keypair_file(&default_keypair_file).unwrap().into(),
+                    storage_account_keypair.into()
+                ],
+            }
+        );
+
+        let test_claim_storage_reward = test_commands.clone().get_matches_from(vec![
+            "test",
+            "claim-storage-reward",
+            &pubkey_string,
+            &storage_account_string,
+        ]);
+        assert_eq!(
+            parse_command(&test_claim_storage_reward, &default_keypair_file, &mut None).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::ClaimStorageReward {
+                    node_account_pubkey: pubkey,
+                    storage_account_pubkey,
+                },
+                signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
+            }
+        );
+    }
+}

cli/src/test_utils.rs

@@ -1,16 +0,0 @@
-use solana_client::rpc_client::RpcClient;
-use solana_sdk::pubkey::Pubkey;
-use std::{thread::sleep, time::Duration};
-
-pub fn check_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
-    (0..5).for_each(|tries| {
-        let balance = client.get_balance(pubkey).unwrap();
-        if balance == expected_balance {
-            return;
-        }
-        if tries == 4 {
-            assert_eq!(balance, expected_balance);
-        }
-        sleep(Duration::from_millis(500));
-    });
-}

cli/src/validator_info.rs

@@ -1,7 +1,6 @@
 use crate::{
-    cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
+    cli::{check_account_for_fee, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
     cli_output::{CliValidatorInfo, CliValidatorInfoVec},
-    spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
 };
 use bincode::deserialize;
 use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
@@ -311,10 +310,8 @@ pub fn process_set_validator_info(
         .poll_get_balance_with_commitment(&info_pubkey, CommitmentConfig::default())
         .unwrap_or(0);
 
-    let lamports =
-        rpc_client.get_minimum_balance_for_rent_exemption(ValidatorInfo::max_space() as usize)?;
-
-    let signers = if balance == 0 {
+    let keys = vec![(id(), false), (config.signers[0].pubkey(), true)];
+    let (message, signers): (Message, Vec<&dyn Signer>) = if balance == 0 {
         if info_pubkey != info_keypair.pubkey() {
             println!(
                 "Account {:?} does not exist. Generating new keypair...",
@@ -322,59 +319,54 @@ pub fn process_set_validator_info(
             );
             info_pubkey = info_keypair.pubkey();
         }
-        vec![config.signers[0], &info_keypair]
+        println!(
+            "Publishing info for Validator {:?}",
+            config.signers[0].pubkey()
+        );
+        let lamports = rpc_client
+            .get_minimum_balance_for_rent_exemption(ValidatorInfo::max_space() as usize)?;
+        let mut instructions = config_instruction::create_account::<ValidatorInfo>(
+            &config.signers[0].pubkey(),
+            &info_keypair.pubkey(),
+            lamports,
+            keys.clone(),
+        );
+        instructions.extend_from_slice(&[config_instruction::store(
+            &info_keypair.pubkey(),
+            true,
+            keys,
+            &validator_info,
+        )]);
+        let signers = vec![config.signers[0], &info_keypair];
+        let message = Message::new(&instructions);
+        (message, signers)
     } else {
-        vec![config.signers[0]]
-    };
-
-    let build_message = |lamports| {
-        let keys = vec![(id(), false), (config.signers[0].pubkey(), true)];
-        if balance == 0 {
-            println!(
-                "Publishing info for Validator {:?}",
-                config.signers[0].pubkey()
-            );
-            let mut instructions = config_instruction::create_account::<ValidatorInfo>(
-                &config.signers[0].pubkey(),
-                &info_pubkey,
-                lamports,
-                keys.clone(),
-            );
-            instructions.extend_from_slice(&[config_instruction::store(
-                &info_pubkey,
-                true,
-                keys,
-                &validator_info,
-            )]);
-            Message::new(&instructions)
-        } else {
-            println!(
-                "Updating Validator {:?} info at: {:?}",
-                config.signers[0].pubkey(),
-                info_pubkey
-            );
-            let instructions = vec![config_instruction::store(
-                &info_pubkey,
-                false,
-                keys,
-                &validator_info,
-            )];
-            Message::new_with_payer(&instructions, Some(&config.signers[0].pubkey()))
-        }
+        println!(
+            "Updating Validator {:?} info at: {:?}",
+            config.signers[0].pubkey(),
+            info_pubkey
+        );
+        let instructions = vec![config_instruction::store(
+            &info_pubkey,
+            false,
+            keys,
+            &validator_info,
+        )];
+        let message = Message::new_with_payer(&instructions, Some(&config.signers[0].pubkey()));
+        let signers = vec![config.signers[0]];
+        (message, signers)
     };
 
     // Submit transaction
     let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
-    let (message, _) = resolve_spend_tx_and_check_account_balance(
-        rpc_client,
-        false,
-        SpendAmount::Some(lamports),
-        &fee_calculator,
-        &config.signers[0].pubkey(),
-        build_message,
-    )?;
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&signers, recent_blockhash)?;
+    check_account_for_fee(
+        rpc_client,
+        &config.signers[0].pubkey(),
+        &fee_calculator,
+        &tx.message,
+    )?;
     let signature_str = rpc_client.send_and_confirm_transaction_with_spinner(&tx)?;
 
     println!("Success! Validator info published at: {:?}", info_pubkey);
@@ -508,7 +500,9 @@ mod tests {
         let mut info = Map::new();
         info.insert("name".to_string(), Value::String("Alice".to_string()));
         let info_string = serde_json::to_string(&Value::Object(info.clone())).unwrap();
-        let validator_info = ValidatorInfo { info: info_string };
+        let validator_info = ValidatorInfo {
+            info: info_string.clone(),
+        };
         let data = serialize(&(config, validator_info)).unwrap();
 
         assert_eq!(
@@ -545,7 +539,9 @@ mod tests {
         info.insert("details".to_string(), Value::String(max_long_string));
         let info_string = serde_json::to_string(&Value::Object(info)).unwrap();
 
-        let validator_info = ValidatorInfo { info: info_string };
+        let validator_info = ValidatorInfo {
+            info: info_string.clone(),
+        };
 
         assert_eq!(
             serialized_size(&validator_info).unwrap(),

cli/src/vote.rs

@@ -1,11 +1,10 @@
 use crate::{
-    checks::{check_account_for_fee, check_unique_pubkeys},
     cli::{
-        generate_unique_signers, log_instruction_custom_error, CliCommand, CliCommandInfo,
-        CliConfig, CliError, ProcessResult, SignerIndex,
+        check_account_for_fee, check_unique_pubkeys, generate_unique_signers,
+        log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
+        ProcessResult, SignerIndex,
     },
     cli_output::{CliEpochVotingHistory, CliLockout, CliVoteAccount},
-    spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
 };
 use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
 use solana_clap_utils::{
@@ -61,16 +60,20 @@ impl VoteSubCommands for App<'_, '_> {
                         .help("The commission taken on reward redemption (0-100)"),
                 )
                 .arg(
-                    pubkey!(Arg::with_name("authorized_voter")
+                    Arg::with_name("authorized_voter")
                         .long("authorized-voter")
-                        .value_name("VOTER_PUBKEY"),
-                        "Public key of the authorized voter [default: validator identity pubkey]. "),
+                        .value_name("VOTER_PUBKEY")
+                        .takes_value(true)
+                        .validator(is_valid_pubkey)
+                        .help("Public key of the authorized voter [default: validator identity pubkey]"),
                 )
                 .arg(
-                    pubkey!(Arg::with_name("authorized_withdrawer")
+                    Arg::with_name("authorized_withdrawer")
                         .long("authorized-withdrawer")
-                        .value_name("WITHDRAWER_PUBKEY"),
-                        "Public key of the authorized withdrawer [default: validator identity pubkey]. "),
+                        .value_name("WITHDRAWER_PUBKEY")
+                        .takes_value(true)
+                        .validator(is_valid_pubkey)
+                        .help("Public key of the authorized withdrawer [default: validator identity pubkey]"),
                 )
                 .arg(
                     Arg::with_name("seed")
@@ -84,11 +87,13 @@ impl VoteSubCommands for App<'_, '_> {
             SubCommand::with_name("vote-authorize-voter")
                 .about("Authorize a new vote signing keypair for the given vote account")
                 .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
+                    Arg::with_name("vote_account_pubkey")
                         .index(1)
                         .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account in which to set the authorized voter. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Vote account in which to set the authorized voter"),
                 )
                 .arg(
                     Arg::with_name("authorized")
@@ -96,25 +101,29 @@ impl VoteSubCommands for App<'_, '_> {
                         .value_name("AUTHORIZED_KEYPAIR")
                         .required(true)
                         .validator(is_valid_signer)
-                        .help("Current authorized vote signer."),
+                        .help("Current authorized vote signer"),
                 )
                 .arg(
-                    pubkey!(Arg::with_name("new_authorized_pubkey")
+                    Arg::with_name("new_authorized_pubkey")
                         .index(3)
-                        .value_name("NEW_AUTHORIZED_PUBKEY")
-                        .required(true),
-                        "New authorized vote signer. "),
+                        .value_name("AUTHORIZED_PUBKEY")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("New authorized vote signer"),
                 ),
         )
         .subcommand(
             SubCommand::with_name("vote-authorize-withdrawer")
                 .about("Authorize a new withdraw signing keypair for the given vote account")
                 .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
+                    Arg::with_name("vote_account_pubkey")
                         .index(1)
                         .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account in which to set the authorized withdrawer. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Vote account in which to set the authorized withdrawer"),
                 )
                 .arg(
                     Arg::with_name("authorized")
@@ -122,25 +131,29 @@ impl VoteSubCommands for App<'_, '_> {
                         .value_name("AUTHORIZED_KEYPAIR")
                         .required(true)
                         .validator(is_valid_signer)
-                        .help("Current authorized withdrawer."),
+                        .help("Current authorized withdrawer"),
                 )
                 .arg(
-                    pubkey!(Arg::with_name("new_authorized_pubkey")
+                    Arg::with_name("new_authorized_pubkey")
                         .index(3)
                         .value_name("AUTHORIZED_PUBKEY")
-                        .required(true),
-                        "New authorized withdrawer. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("New authorized withdrawer"),
                 ),
         )
         .subcommand(
             SubCommand::with_name("vote-update-validator")
                 .about("Update the vote account's validator identity")
                 .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
+                    Arg::with_name("vote_account_pubkey")
                         .index(1)
                         .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account to update. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Vote account to update"),
                 )
                 .arg(
                     Arg::with_name("new_identity_account")
@@ -166,11 +179,13 @@ impl VoteSubCommands for App<'_, '_> {
                 .about("Show the contents of a vote account")
                 .alias("show-vote-account")
                 .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
+                    Arg::with_name("vote_account_pubkey")
                         .index(1)
                         .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account pubkey. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Vote account pubkey"),
                 )
                 .arg(
                     Arg::with_name("lamports")
@@ -184,18 +199,22 @@ impl VoteSubCommands for App<'_, '_> {
             SubCommand::with_name("withdraw-from-vote-account")
                 .about("Withdraw lamports from a vote account into a specified account")
                 .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
+                    Arg::with_name("vote_account_pubkey")
                         .index(1)
                         .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account from which to withdraw. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("Vote account from which to withdraw"),
                 )
                 .arg(
-                    pubkey!(Arg::with_name("destination_account_pubkey")
+                    Arg::with_name("destination_account_pubkey")
                         .index(2)
                         .value_name("RECIPIENT_ADDRESS")
-                        .required(true),
-                        "The recipient of withdrawn SOL. "),
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_pubkey)
+                        .help("The recipient of withdrawn SOL"),
                 )
                 .arg(
                     Arg::with_name("amount")
@@ -387,39 +406,6 @@ pub fn process_create_vote_account(
         (&identity_pubkey, "identity_pubkey".to_string()),
     )?;
 
-    let required_balance = rpc_client
-        .get_minimum_balance_for_rent_exemption(VoteState::size_of())?
-        .max(1);
-    let amount = SpendAmount::Some(required_balance);
-
-    let build_message = |lamports| {
-        let vote_init = VoteInit {
-            node_pubkey: identity_pubkey,
-            authorized_voter: authorized_voter.unwrap_or(identity_pubkey),
-            authorized_withdrawer: authorized_withdrawer.unwrap_or(identity_pubkey),
-            commission,
-        };
-
-        let ixs = if let Some(seed) = seed {
-            vote_instruction::create_account_with_seed(
-                &config.signers[0].pubkey(), // from
-                &vote_account_address,       // to
-                &vote_account_pubkey,        // base
-                seed,                        // seed
-                &vote_init,
-                lamports,
-            )
-        } else {
-            vote_instruction::create_account(
-                &config.signers[0].pubkey(),
-                &vote_account_pubkey,
-                &vote_init,
-                lamports,
-            )
-        };
-        Message::new(&ixs)
-    };
-
     if let Ok(vote_account) = rpc_client.get_account(&vote_account_address) {
         let err_msg = if vote_account.owner == solana_vote_program::id() {
             format!("Vote account {} already exists", vote_account_address)
@@ -432,18 +418,45 @@ pub fn process_create_vote_account(
         return Err(CliError::BadParameter(err_msg).into());
     }
 
+    let required_balance = rpc_client
+        .get_minimum_balance_for_rent_exemption(VoteState::size_of())?
+        .max(1);
+
+    let vote_init = VoteInit {
+        node_pubkey: identity_pubkey,
+        authorized_voter: authorized_voter.unwrap_or(identity_pubkey),
+        authorized_withdrawer: authorized_withdrawer.unwrap_or(identity_pubkey),
+        commission,
+    };
+
+    let ixs = if let Some(seed) = seed {
+        vote_instruction::create_account_with_seed(
+            &config.signers[0].pubkey(), // from
+            &vote_account_address,       // to
+            &vote_account_pubkey,        // base
+            seed,                        // seed
+            &vote_init,
+            required_balance,
+        )
+    } else {
+        vote_instruction::create_account(
+            &config.signers[0].pubkey(),
+            &vote_account_pubkey,
+            &vote_init,
+            required_balance,
+        )
+    };
     let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
 
-    let (message, _) = resolve_spend_tx_and_check_account_balance(
-        rpc_client,
-        false,
-        amount,
-        &fee_calculator,
-        &config.signers[0].pubkey(),
-        build_message,
-    )?;
+    let message = Message::new(&ixs);
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
+    check_account_for_fee(
+        rpc_client,
+        &config.signers[0].pubkey(),
+        &fee_calculator,
+        &tx.message,
+    )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
     log_instruction_custom_error::<SystemError>(result, &config)
 }

cli/tests/nonce.rs

@@ -1,4 +1,3 @@
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     cli_output::OutputFormat,
@@ -7,10 +6,8 @@ use solana_cli::{
         blockhash_query::{self, BlockhashQuery},
         parse_sign_only_reply_string,
     },
-    spend_utils::SpendAmount,
 };
 use solana_client::rpc_client::RpcClient;
-use solana_core::contact_info::ContactInfo;
 use solana_core::validator::{TestValidator, TestValidatorOptions};
 use solana_faucet::faucet::run_local_faucet;
 use solana_sdk::{
@@ -19,11 +16,23 @@ use solana_sdk::{
     signature::{keypair_from_seed, Keypair, Signer},
     system_program,
 };
-use std::{fs::remove_dir_all, sync::mpsc::channel};
+use std::{fs::remove_dir_all, sync::mpsc::channel, thread::sleep, time::Duration};
+
+fn check_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
+    (0..5).for_each(|tries| {
+        let balance = client.retry_get_balance(pubkey, 1).unwrap().unwrap();
+        if balance == expected_balance {
+            return;
+        }
+        if tries == 4 {
+            assert_eq!(balance, expected_balance);
+        }
+        sleep(Duration::from_millis(500));
+    });
+}
 
 #[test]
 fn test_nonce() {
-    solana_logger::setup();
     let TestValidator {
         server,
         leader_data,
@@ -31,8 +40,14 @@ fn test_nonce() {
         ledger_path,
         ..
     } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    full_battery_tests(leader_data, alice, None, false);
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
+    let json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
+
+    full_battery_tests(&rpc_client, &faucet_addr, json_rpc_url, None, false);
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
@@ -47,8 +62,20 @@ fn test_nonce_with_seed() {
         ledger_path,
         ..
     } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    full_battery_tests(leader_data, alice, Some(String::from("seed")), false);
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
+    let json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
+
+    full_battery_tests(
+        &rpc_client,
+        &faucet_addr,
+        json_rpc_url,
+        Some(String::from("seed")),
+        false,
+    );
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
@@ -63,19 +90,6 @@ fn test_nonce_with_authority() {
         ledger_path,
         ..
     } = TestValidator::run();
-
-    full_battery_tests(leader_data, alice, None, true);
-
-    server.close().unwrap();
-    remove_dir_all(ledger_path).unwrap();
-}
-
-fn full_battery_tests(
-    leader_data: ContactInfo,
-    alice: Keypair,
-    seed: Option<String>,
-    use_nonce_authority: bool,
-) {
     let (sender, receiver) = channel();
     run_local_faucet(alice, sender, None);
     let faucet_addr = receiver.recv().unwrap();
@@ -83,6 +97,19 @@ fn full_battery_tests(
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
 
+    full_battery_tests(&rpc_client, &faucet_addr, json_rpc_url, None, true);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
+}
+
+fn full_battery_tests(
+    rpc_client: &RpcClient,
+    faucet_addr: &std::net::SocketAddr,
+    json_rpc_url: String,
+    seed: Option<String>,
+    use_nonce_authority: bool,
+) {
     let mut config_payer = CliConfig::default();
     config_payer.json_rpc_url = json_rpc_url.clone();
     let payer = Keypair::new();
@@ -127,7 +154,7 @@ fn full_battery_tests(
         nonce_account: 1,
         seed,
         nonce_authority: optional_authority,
-        amount: SpendAmount::Some(1000),
+        lamports: 1000,
     };
 
     process_command(&config_payer).unwrap();
@@ -290,7 +317,7 @@ fn test_create_account_with_seed() {
         nonce_account: 0,
         seed: Some(seed),
         nonce_authority: Some(authority_pubkey),
-        amount: SpendAmount::Some(241),
+        lamports: 241,
     };
     process_command(&creator_config).unwrap();
     check_balance(241, &rpc_client, &nonce_address);
@@ -312,7 +339,7 @@ fn test_create_account_with_seed() {
     authority_config.command = CliCommand::ClusterVersion;
     process_command(&authority_config).unwrap_err();
     authority_config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: to_address,
         from: 0,
         sign_only: true,
@@ -334,7 +361,7 @@ fn test_create_account_with_seed() {
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     submit_config.signers = vec![&authority_presigner];
     submit_config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: to_address,
         from: 0,
         sign_only: false,

cli/tests/pay.rs

@@ -1,6 +1,5 @@
 use chrono::prelude::*;
 use serde_json::Value;
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig, PayCommand},
     cli_output::OutputFormat,
@@ -9,7 +8,6 @@ use solana_cli::{
         blockhash_query::{self, BlockhashQuery},
         parse_sign_only_reply_string,
     },
-    spend_utils::SpendAmount,
 };
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::TestValidator;
@@ -19,7 +17,20 @@ use solana_sdk::{
     pubkey::Pubkey,
     signature::{Keypair, Signer},
 };
-use std::{fs::remove_dir_all, sync::mpsc::channel};
+use std::{fs::remove_dir_all, sync::mpsc::channel, thread::sleep, time::Duration};
+
+fn check_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
+    (0..5).for_each(|tries| {
+        let balance = client.retry_get_balance(pubkey, 1).unwrap().unwrap();
+        if balance == expected_balance {
+            return;
+        }
+        if tries == 4 {
+            assert_eq!(balance, expected_balance);
+        }
+        sleep(Duration::from_millis(500));
+    });
+}
 
 #[test]
 fn test_cli_timestamp_tx() {
@@ -77,7 +88,7 @@ fn test_cli_timestamp_tx() {
     let date_string = "\"2018-09-19T17:30:59Z\"";
     let dt: DateTime<Utc> = serde_json::from_str(&date_string).unwrap();
     config_payer.command = CliCommand::Pay(PayCommand {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: bob_pubkey,
         timestamp: Some(dt),
         timestamp_pubkey: Some(config_witness.signers[0].pubkey()),
@@ -160,7 +171,7 @@ fn test_cli_witness_tx() {
 
     // Make transaction (from config_payer to bob_pubkey) requiring witness signature from config_witness
     config_payer.command = CliCommand::Pay(PayCommand {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: bob_pubkey,
         witnesses: Some(vec![config_witness.signers[0].pubkey()]),
         ..PayCommand::default()
@@ -234,7 +245,7 @@ fn test_cli_cancel_tx() {
 
     // Make transaction (from config_payer to bob_pubkey) requiring witness signature from config_witness
     config_payer.command = CliCommand::Pay(PayCommand {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: bob_pubkey,
         witnesses: Some(vec![config_witness.signers[0].pubkey()]),
         cancelable: true,
@@ -319,7 +330,7 @@ fn test_offline_pay_tx() {
 
     let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
     config_offline.command = CliCommand::Pay(PayCommand {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: bob_pubkey,
         blockhash_query: BlockhashQuery::None(blockhash),
         sign_only: true,
@@ -340,7 +351,7 @@ fn test_offline_pay_tx() {
     let online_pubkey = config_online.signers[0].pubkey();
     config_online.signers = vec![&offline_presigner];
     config_online.command = CliCommand::Pay(PayCommand {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: bob_pubkey,
         blockhash_query: BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
         ..PayCommand::default()
@@ -401,7 +412,7 @@ fn test_nonced_pay_tx() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(config.signers[0].pubkey()),
-        amount: SpendAmount::Some(minimum_nonce_balance),
+        lamports: minimum_nonce_balance,
     };
     config.signers.push(&nonce_account);
     process_command(&config).unwrap();
@@ -418,7 +429,7 @@ fn test_nonced_pay_tx() {
     let bob_pubkey = Pubkey::new_rand();
     config.signers = vec![&default_signer];
     config.command = CliCommand::Pay(PayCommand {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: bob_pubkey,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_account.pubkey()),

cli/tests/request_airdrop.rs

@@ -35,7 +35,8 @@ fn test_cli_request_airdrop() {
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let balance = rpc_client
-        .get_balance(&bob_config.signers[0].pubkey())
+        .retry_get_balance(&bob_config.signers[0].pubkey(), 1)
+        .unwrap()
         .unwrap();
     assert_eq!(balance, 50);
 

cli/tests/stake.rs

@@ -1,4 +1,3 @@
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     cli_output::OutputFormat,
@@ -7,7 +6,6 @@ use solana_cli::{
         blockhash_query::{self, BlockhashQuery},
         parse_sign_only_reply_string,
     },
-    spend_utils::SpendAmount,
 };
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::{TestValidator, TestValidatorOptions};
@@ -22,7 +20,20 @@ use solana_stake_program::{
     stake_instruction::LockupArgs,
     stake_state::{Lockup, StakeAuthorize, StakeState},
 };
-use std::{fs::remove_dir_all, sync::mpsc::channel};
+use std::{fs::remove_dir_all, sync::mpsc::channel, thread::sleep, time::Duration};
+
+fn check_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
+    (0..5).for_each(|tries| {
+        let balance = client.retry_get_balance(pubkey, 1).unwrap().unwrap();
+        if balance == expected_balance {
+            return;
+        }
+        if tries == 4 {
+            assert_eq!(balance, expected_balance);
+        }
+        sleep(Duration::from_millis(500));
+    });
+}
 
 #[test]
 fn test_stake_delegation_force() {
@@ -74,7 +85,7 @@ fn test_stake_delegation_force() {
         staker: None,
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
@@ -166,7 +177,7 @@ fn test_seed_stake_delegation_and_deactivation() {
         staker: None,
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
@@ -250,7 +261,7 @@ fn test_stake_delegation_and_deactivation() {
         staker: None,
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
@@ -354,10 +365,10 @@ fn test_offline_stake_delegation_and_deactivation() {
     config_validator.command = CliCommand::CreateStakeAccount {
         stake_account: 1,
         seed: None,
-        staker: Some(config_offline.signers[0].pubkey()),
+        staker: Some(config_offline.signers[0].pubkey().into()),
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
@@ -479,7 +490,7 @@ fn test_nonced_stake_delegation_and_deactivation() {
         staker: None,
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
@@ -496,7 +507,7 @@ fn test_nonced_stake_delegation_and_deactivation() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(config.signers[0].pubkey()),
-        amount: SpendAmount::Some(minimum_nonce_balance),
+        lamports: minimum_nonce_balance,
     };
     process_command(&config).unwrap();
 
@@ -608,7 +619,7 @@ fn test_stake_authorize() {
         staker: None,
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
@@ -736,7 +747,7 @@ fn test_stake_authorize() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(offline_authority_pubkey),
-        amount: SpendAmount::Some(minimum_nonce_balance),
+        lamports: minimum_nonce_balance,
     };
     process_command(&config).unwrap();
 
@@ -863,7 +874,7 @@ fn test_stake_authorize_with_fee_payer() {
         staker: None,
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
@@ -992,7 +1003,7 @@ fn test_stake_split() {
         staker: Some(offline_pubkey),
         withdrawer: Some(offline_pubkey),
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(10 * minimum_stake_balance),
+        lamports: 10 * minimum_stake_balance,
         sign_only: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
@@ -1017,7 +1028,7 @@ fn test_stake_split() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(offline_pubkey),
-        amount: SpendAmount::Some(minimum_nonce_balance),
+        lamports: minimum_nonce_balance,
     };
     process_command(&config).unwrap();
     check_balance(minimum_nonce_balance, &rpc_client, &nonce_account.pubkey());
@@ -1033,7 +1044,7 @@ fn test_stake_split() {
     check_balance(0, &rpc_client, &split_account.pubkey());
     config_offline.signers.push(&split_account);
     config_offline.command = CliCommand::SplitStake {
-        stake_account_pubkey,
+        stake_account_pubkey: stake_account_pubkey,
         stake_authority: 0,
         sign_only: true,
         blockhash_query: BlockhashQuery::None(nonce_hash),
@@ -1051,7 +1062,7 @@ fn test_stake_split() {
     let offline_presigner = sign_only.presigner_of(&offline_pubkey).unwrap();
     config.signers = vec![&offline_presigner, &split_account];
     config.command = CliCommand::SplitStake {
-        stake_account_pubkey,
+        stake_account_pubkey: stake_account_pubkey,
         stake_authority: 0,
         sign_only: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
@@ -1148,7 +1159,7 @@ fn test_stake_set_lockup() {
         staker: Some(offline_pubkey),
         withdrawer: Some(offline_pubkey),
         lockup,
-        amount: SpendAmount::Some(10 * minimum_stake_balance),
+        lamports: 10 * minimum_stake_balance,
         sign_only: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
@@ -1165,7 +1176,7 @@ fn test_stake_set_lockup() {
 
     // Online set lockup
     let lockup = LockupArgs {
-        unix_timestamp: Some(1_581_534_570),
+        unix_timestamp: Some(1581534570),
         epoch: Some(200),
         custodian: None,
     };
@@ -1199,7 +1210,7 @@ fn test_stake_set_lockup() {
     let online_custodian_pubkey = online_custodian.pubkey();
 
     let lockup = LockupArgs {
-        unix_timestamp: Some(1_581_534_571),
+        unix_timestamp: Some(1581534571),
         epoch: Some(201),
         custodian: Some(online_custodian_pubkey),
     };
@@ -1216,7 +1227,7 @@ fn test_stake_set_lockup() {
     process_command(&config).unwrap();
 
     let lockup = LockupArgs {
-        unix_timestamp: Some(1_581_534_572),
+        unix_timestamp: Some(1581534572),
         epoch: Some(202),
         custodian: None,
     };
@@ -1247,7 +1258,7 @@ fn test_stake_set_lockup() {
 
     // Set custodian to offline pubkey
     let lockup = LockupArgs {
-        unix_timestamp: Some(1_581_534_573),
+        unix_timestamp: Some(1581534573),
         epoch: Some(203),
         custodian: Some(offline_pubkey),
     };
@@ -1274,7 +1285,7 @@ fn test_stake_set_lockup() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(offline_pubkey),
-        amount: SpendAmount::Some(minimum_nonce_balance),
+        lamports: minimum_nonce_balance,
     };
     process_command(&config).unwrap();
     check_balance(minimum_nonce_balance, &rpc_client, &nonce_account_pubkey);
@@ -1287,7 +1298,7 @@ fn test_stake_set_lockup() {
 
     // Nonced offline set lockup
     let lockup = LockupArgs {
-        unix_timestamp: Some(1_581_534_576),
+        unix_timestamp: Some(1581534576),
         epoch: Some(222),
         custodian: None,
     };
@@ -1394,7 +1405,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(offline_pubkey),
-        amount: SpendAmount::Some(minimum_nonce_balance),
+        lamports: minimum_nonce_balance,
     };
     process_command(&config).unwrap();
 
@@ -1414,7 +1425,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         staker: None,
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: true,
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_pubkey),
@@ -1435,7 +1446,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         staker: Some(offline_pubkey),
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_pubkey),
@@ -1508,7 +1519,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         staker: None,
         withdrawer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: true,
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_pubkey),
@@ -1524,10 +1535,10 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     config.command = CliCommand::CreateStakeAccount {
         stake_account: 1,
         seed: Some(seed.to_string()),
-        staker: Some(offline_pubkey),
-        withdrawer: Some(offline_pubkey),
+        staker: Some(offline_pubkey.into()),
+        withdrawer: Some(offline_pubkey.into()),
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
+        lamports: 50_000,
         sign_only: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_pubkey),

cli/tests/transfer.rs

@@ -1,4 +1,3 @@
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     cli_output::OutputFormat,
@@ -7,7 +6,6 @@ use solana_cli::{
         blockhash_query::{self, BlockhashQuery},
         parse_sign_only_reply_string,
     },
-    spend_utils::SpendAmount,
 };
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::{TestValidator, TestValidatorOptions};
@@ -17,7 +15,20 @@ use solana_sdk::{
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, NullSigner, Signer},
 };
-use std::{fs::remove_dir_all, sync::mpsc::channel};
+use std::{fs::remove_dir_all, sync::mpsc::channel, thread::sleep, time::Duration};
+
+fn check_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
+    (0..5).for_each(|tries| {
+        let balance = client.retry_get_balance(pubkey, 1).unwrap().unwrap();
+        if balance == expected_balance {
+            return;
+        }
+        if tries == 4 {
+            assert_eq!(balance, expected_balance);
+        }
+        sleep(Duration::from_millis(500));
+    });
+}
 
 #[test]
 fn test_transfer() {
@@ -56,7 +67,7 @@ fn test_transfer() {
 
     // Plain ole transfer
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -70,22 +81,6 @@ fn test_transfer() {
     check_balance(49_989, &rpc_client, &sender_pubkey);
     check_balance(10, &rpc_client, &recipient_pubkey);
 
-    // Plain ole transfer, failure due to InsufficientFundsForSpendAndFee
-    config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(49_989),
-        to: recipient_pubkey,
-        from: 0,
-        sign_only: false,
-        no_wait: false,
-        blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
-        nonce_account: None,
-        nonce_authority: 0,
-        fee_payer: 0,
-    };
-    assert!(process_command(&config).is_err());
-    check_balance(49_989, &rpc_client, &sender_pubkey);
-    check_balance(10, &rpc_client, &recipient_pubkey);
-
     let mut offline = CliConfig::default();
     offline.json_rpc_url = String::default();
     offline.signers = vec![&default_offline_signer];
@@ -100,7 +95,7 @@ fn test_transfer() {
     // Offline transfer
     let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
     offline.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: recipient_pubkey,
         from: 0,
         sign_only: true,
@@ -117,7 +112,7 @@ fn test_transfer() {
     let offline_presigner = sign_only.presigner_of(&offline_pubkey).unwrap();
     config.signers = vec![&offline_presigner];
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -141,7 +136,7 @@ fn test_transfer() {
         nonce_account: 1,
         seed: None,
         nonce_authority: None,
-        amount: SpendAmount::Some(minimum_nonce_balance),
+        lamports: minimum_nonce_balance,
     };
     process_command(&config).unwrap();
     check_balance(49_987 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
@@ -155,7 +150,7 @@ fn test_transfer() {
     // Nonced transfer
     config.signers = vec![&default_signer];
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -196,7 +191,7 @@ fn test_transfer() {
     // Offline, nonced transfer
     offline.signers = vec![&default_offline_signer];
     offline.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: recipient_pubkey,
         from: 0,
         sign_only: true,
@@ -212,7 +207,7 @@ fn test_transfer() {
     let offline_presigner = sign_only.presigner_of(&offline_pubkey).unwrap();
     config.signers = vec![&offline_presigner];
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10),
+        lamports: 10,
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -289,7 +284,7 @@ fn test_transfer_multisession_signing() {
     fee_payer_config.command = CliCommand::ClusterVersion;
     process_command(&fee_payer_config).unwrap_err();
     fee_payer_config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(42),
+        lamports: 42,
         to: to_pubkey,
         from: 1,
         sign_only: true,
@@ -315,7 +310,7 @@ fn test_transfer_multisession_signing() {
     from_config.command = CliCommand::ClusterVersion;
     process_command(&from_config).unwrap_err();
     from_config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(42),
+        lamports: 42,
         to: to_pubkey,
         from: 1,
         sign_only: true,
@@ -338,7 +333,7 @@ fn test_transfer_multisession_signing() {
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&fee_payer_presigner, &from_presigner];
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(42),
+        lamports: 42,
         to: to_pubkey,
         from: 1,
         sign_only: false,
@@ -357,57 +352,3 @@ fn test_transfer_multisession_signing() {
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
 }
-
-#[test]
-fn test_transfer_all() {
-    let TestValidator {
-        server,
-        leader_data,
-        alice: mint_keypair,
-        ledger_path,
-        ..
-    } = TestValidator::run_with_options(TestValidatorOptions {
-        fees: 1,
-        bootstrap_validator_lamports: 42_000,
-        ..TestValidatorOptions::default()
-    });
-
-    let (sender, receiver) = channel();
-    run_local_faucet(mint_keypair, sender, None);
-    let faucet_addr = receiver.recv().unwrap();
-
-    let rpc_client = RpcClient::new_socket(leader_data.rpc);
-
-    let default_signer = Keypair::new();
-
-    let mut config = CliConfig::default();
-    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
-    config.signers = vec![&default_signer];
-
-    let sender_pubkey = config.signers[0].pubkey();
-    let recipient_pubkey = Pubkey::new(&[1u8; 32]);
-
-    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &sender_pubkey, 50_000, &config)
-        .unwrap();
-    check_balance(50_000, &rpc_client, &sender_pubkey);
-    check_balance(0, &rpc_client, &recipient_pubkey);
-
-    // Plain ole transfer
-    config.command = CliCommand::Transfer {
-        amount: SpendAmount::All,
-        to: recipient_pubkey,
-        from: 0,
-        sign_only: false,
-        no_wait: false,
-        blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
-        nonce_account: None,
-        nonce_authority: 0,
-        fee_payer: 0,
-    };
-    process_command(&config).unwrap();
-    check_balance(0, &rpc_client, &sender_pubkey);
-    check_balance(49_999, &rpc_client, &recipient_pubkey);
-
-    server.close().unwrap();
-    remove_dir_all(ledger_path).unwrap();
-}

cli/tests/vote.rs

@@ -1,5 +1,4 @@
 use solana_cli::cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig};
-use solana_cli::test_utils::check_balance;
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::TestValidator;
 use solana_faucet::faucet::run_local_faucet;
@@ -9,7 +8,20 @@ use solana_sdk::{
     signature::{Keypair, Signer},
 };
 use solana_vote_program::vote_state::{VoteAuthorize, VoteState, VoteStateVersions};
-use std::{fs::remove_dir_all, sync::mpsc::channel};
+use std::{fs::remove_dir_all, sync::mpsc::channel, thread::sleep, time::Duration};
+
+fn check_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
+    (0..5).for_each(|tries| {
+        let balance = client.retry_get_balance(pubkey, 1).unwrap().unwrap();
+        if balance == expected_balance {
+            return;
+        }
+        if tries == 4 {
+            assert_eq!(balance, expected_balance);
+        }
+        sleep(Duration::from_millis(500));
+    });
+}
 
 #[test]
 fn test_vote_authorize_and_withdraw() {

client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-client"
-version = "1.2.0"
+version = "1.1.13"
 description = "Solana Client"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -10,28 +10,28 @@ edition = "2018"
 
 [dependencies]
 bincode = "1.2.1"
-bs58 = "0.3.1"
+bs58 = "0.3.0"
 indicatif = "0.14.0"
-jsonrpc-core = "14.1.0"
+jsonrpc-core = "14.0.5"
 log = "0.4.8"
 rayon = "1.3.0"
 reqwest = { version = "0.10.4", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-serde = "1.0.110"
+serde = "1.0.105"
 serde_derive = "1.0.103"
-serde_json = "1.0.53"
-solana-transaction-status = { path = "../transaction-status", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.0" }
+serde_json = "1.0.48"
+solana-transaction-status = { path = "../transaction-status", version = "1.1.13" }
+solana-net-utils = { path = "../net-utils", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+solana-vote-program = { path = "../programs/vote", version = "1.1.13" }
 thiserror = "1.0"
 tungstenite = "0.10.1"
 url = "2.1.1"
 
 [dev-dependencies]
 assert_matches = "1.3.0"
-jsonrpc-core = "14.1.0"
-jsonrpc-http-server = "14.1.0"
-solana-logger = { path = "../logger", version = "1.2.0" }
+jsonrpc-core = "14.0.5"
+jsonrpc-http-server = "14.0.6"
+solana-logger = { path = "../logger", version = "1.1.13" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

client/src/generic_rpc_client_request.rs

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

client/src/lib.rs

@@ -2,13 +2,13 @@
 extern crate serde_derive;
 
 pub mod client_error;
-pub mod http_sender;
-pub mod mock_sender;
+mod generic_rpc_client_request;
+pub mod mock_rpc_client_request;
 pub mod perf_utils;
 pub mod pubsub_client;
 pub mod rpc_client;
+pub mod rpc_client_request;
 pub mod rpc_config;
 pub mod rpc_request;
 pub mod rpc_response;
-pub mod rpc_sender;
 pub mod thin_client;

client/src/mock_rpc_client_request.rs

@@ -1,8 +1,8 @@
 use crate::{
     client_error::Result,
+    generic_rpc_client_request::GenericRpcClientRequest,
     rpc_request::RpcRequest,
     rpc_response::{Response, RpcResponseContext},
-    rpc_sender::RpcSender,
 };
 use serde_json::{Number, Value};
 use solana_sdk::{
@@ -19,12 +19,12 @@ pub const SIGNATURE: &str =
     "43yNSFC6fYTuPgTNFFhF4axw7AfWxB2BPdurme8yrsWEYwm8299xh8n6TAHjGymiSub1XtyxTNyd9GBfY2hxoBw8";
 
 pub type Mocks = HashMap<RpcRequest, Value>;
-pub struct MockSender {
+pub struct MockRpcClientRequest {
     mocks: RwLock<Mocks>,
     url: String,
 }
 
-impl MockSender {
+impl MockRpcClientRequest {
     pub fn new(url: String) -> Self {
         Self::new_with_mocks(url, Mocks::default())
     }
@@ -37,8 +37,13 @@ impl MockSender {
     }
 }
 
-impl RpcSender for MockSender {
-    fn send(&self, request: RpcRequest, params: serde_json::Value) -> Result<serde_json::Value> {
+impl GenericRpcClientRequest for MockRpcClientRequest {
+    fn send(
+        &self,
+        request: RpcRequest,
+        params: serde_json::Value,
+        _retries: usize,
+    ) -> Result<serde_json::Value> {
         if let Some(value) = self.mocks.write().unwrap().remove(&request) {
             return Ok(value);
         }
@@ -112,7 +117,7 @@ impl RpcSender for MockSender {
                 };
                 Value::String(signature)
             }
-            RpcRequest::GetMinimumBalanceForRentExemption => Value::Number(Number::from(20)),
+            RpcRequest::GetMinimumBalanceForRentExemption => Value::Number(Number::from(1234)),
             _ => Value::Null,
         };
         Ok(val)

client/src/rpc_client.rs

@@ -1,11 +1,11 @@
 use crate::{
     client_error::{ClientError, ClientErrorKind, Result as ClientResult},
-    http_sender::HttpSender,
-    mock_sender::{MockSender, Mocks},
+    generic_rpc_client_request::GenericRpcClientRequest,
+    mock_rpc_client_request::{MockRpcClientRequest, Mocks},
+    rpc_client_request::RpcClientRequest,
     rpc_config::RpcLargestAccountsConfig,
     rpc_request::{RpcError, RpcRequest},
     rpc_response::*,
-    rpc_sender::RpcSender,
 };
 use bincode::serialize;
 use indicatif::{ProgressBar, ProgressStyle};
@@ -18,7 +18,6 @@ use solana_sdk::{
         MAX_HASH_AGE_IN_SECONDS,
     },
     commitment_config::CommitmentConfig,
-    epoch_info::EpochInfo,
     epoch_schedule::EpochSchedule,
     fee_calculator::{FeeCalculator, FeeRateGovernor},
     hash::Hash,
@@ -40,26 +39,26 @@ use std::{
 };
 
 pub struct RpcClient {
-    sender: Box<dyn RpcSender + Send + Sync + 'static>,
+    client: Box<dyn GenericRpcClientRequest + Send + Sync>,
 }
 
 impl RpcClient {
-    pub fn new_sender<T: RpcSender + Send + Sync + 'static>(sender: T) -> Self {
+    pub fn new(url: String) -> Self {
         Self {
-            sender: Box::new(sender),
+            client: Box::new(RpcClientRequest::new(url)),
         }
     }
 
-    pub fn new(url: String) -> Self {
-        Self::new_sender(HttpSender::new(url))
-    }
-
     pub fn new_mock(url: String) -> Self {
-        Self::new_sender(MockSender::new(url))
+        Self {
+            client: Box::new(MockRpcClientRequest::new(url)),
+        }
     }
 
     pub fn new_mock_with_mocks(url: String, mocks: Mocks) -> Self {
-        Self::new_sender(MockSender::new_with_mocks(url, mocks))
+        Self {
+            client: Box::new(MockRpcClientRequest::new_with_mocks(url, mocks)),
+        }
     }
 
     pub fn new_socket(addr: SocketAddr) -> Self {
@@ -68,7 +67,9 @@ impl RpcClient {
 
     pub fn new_socket_with_timeout(addr: SocketAddr, timeout: Duration) -> Self {
         let url = get_rpc_request_str(addr, false);
-        Self::new_sender(HttpSender::new_with_timeout(url, timeout))
+        Self {
+            client: Box::new(RpcClientRequest::new_with_timeout(url, timeout)),
+        }
     }
 
     pub fn confirm_transaction(&self, signature: &Signature) -> ClientResult<bool> {
@@ -98,7 +99,7 @@ impl RpcClient {
         let serialized_encoded = bs58::encode(serialize(transaction).unwrap()).into_string();
 
         let signature_base58_str: String =
-            self.send(RpcRequest::SendTransaction, json!([serialized_encoded]))?;
+            self.send(RpcRequest::SendTransaction, json!([serialized_encoded]), 5)?;
 
         let signature = signature_base58_str
             .parse::<Signature>()
@@ -118,18 +119,6 @@ impl RpcClient {
         }
     }
 
-    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 }]),
-        )
-    }
-
     pub fn get_signature_status(
         &self,
         signature: &Signature,
@@ -142,7 +131,7 @@ impl RpcClient {
         signatures: &[Signature],
     ) -> RpcResult<Vec<Option<TransactionStatus>>> {
         let signatures: Vec<_> = signatures.iter().map(|s| s.to_string()).collect();
-        self.send(RpcRequest::GetSignatureStatuses, json!([signatures]))
+        self.send(RpcRequest::GetSignatureStatuses, json!([signatures]), 5)
     }
 
     pub fn get_signature_status_with_commitment(
@@ -153,6 +142,7 @@ impl RpcClient {
         let result: Response<Vec<Option<TransactionStatus>>> = self.send(
             RpcRequest::GetSignatureStatuses,
             json!([[signature.to_string()]]),
+            5,
         )?;
         Ok(result.value[0]
             .clone()
@@ -171,6 +161,7 @@ impl RpcClient {
             json!([[signature.to_string()], {
                 "searchTransactionHistory": search_transaction_history
             }]),
+            5,
         )?;
         Ok(result.value[0]
             .clone()
@@ -186,14 +177,14 @@ impl RpcClient {
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<Slot> {
-        self.send(RpcRequest::GetSlot, json!([commitment_config]))
+        self.send(RpcRequest::GetSlot, json!([commitment_config]), 0)
     }
 
     pub fn supply_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
     ) -> RpcResult<RpcSupply> {
-        self.send(RpcRequest::GetSupply, json!([commitment_config]))
+        self.send(RpcRequest::GetSupply, json!([commitment_config]), 0)
     }
 
     pub fn total_supply(&self) -> ClientResult<u64> {
@@ -204,14 +195,14 @@ impl RpcClient {
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<u64> {
-        self.send(RpcRequest::GetTotalSupply, json!([commitment_config]))
+        self.send(RpcRequest::GetTotalSupply, json!([commitment_config]), 0)
     }
 
     pub fn get_largest_accounts_with_config(
         &self,
         config: RpcLargestAccountsConfig,
     ) -> RpcResult<Vec<RpcAccountBalance>> {
-        self.send(RpcRequest::GetLargestAccounts, json!([config]))
+        self.send(RpcRequest::GetLargestAccounts, json!([config]), 0)
     }
 
     pub fn get_vote_accounts(&self) -> ClientResult<RpcVoteAccountStatus> {
@@ -222,11 +213,11 @@ impl RpcClient {
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<RpcVoteAccountStatus> {
-        self.send(RpcRequest::GetVoteAccounts, json!([commitment_config]))
+        self.send(RpcRequest::GetVoteAccounts, json!([commitment_config]), 0)
     }
 
     pub fn get_cluster_nodes(&self) -> ClientResult<Vec<RpcContactInfo>> {
-        self.send(RpcRequest::GetClusterNodes, Value::Null)
+        self.send(RpcRequest::GetClusterNodes, Value::Null, 0)
     }
 
     pub fn get_confirmed_block(&self, slot: Slot) -> ClientResult<ConfirmedBlock> {
@@ -238,7 +229,7 @@ impl RpcClient {
         slot: Slot,
         encoding: TransactionEncoding,
     ) -> ClientResult<ConfirmedBlock> {
-        self.send(RpcRequest::GetConfirmedBlock, json!([slot, encoding]))
+        self.send(RpcRequest::GetConfirmedBlock, json!([slot, encoding]), 0)
     }
 
     pub fn get_confirmed_blocks(
@@ -249,6 +240,7 @@ impl RpcClient {
         self.send(
             RpcRequest::GetConfirmedBlocks,
             json!([start_slot, end_slot]),
+            0,
         )
     }
 
@@ -261,6 +253,7 @@ impl RpcClient {
         let signatures_base58_str: Vec<String> = self.send(
             RpcRequest::GetConfirmedSignaturesForAddress,
             json!([address.to_string(), start_slot, end_slot]),
+            0,
         )?;
 
         let mut signatures = vec![];
@@ -282,12 +275,13 @@ impl RpcClient {
         self.send(
             RpcRequest::GetConfirmedTransaction,
             json!([signature.to_string(), encoding]),
+            0,
         )
     }
 
     pub fn get_block_time(&self, slot: Slot) -> ClientResult<UnixTimestamp> {
         let request = RpcRequest::GetBlockTime;
-        let response = self.sender.send(request, json!([slot]));
+        let response = self.client.send(request, json!([slot]), 0);
 
         response
             .map(|result_json| {
@@ -302,15 +296,15 @@ impl RpcClient {
             .map_err(|err| err.into_with_request(request))?
     }
 
-    pub fn get_epoch_info(&self) -> ClientResult<EpochInfo> {
+    pub fn get_epoch_info(&self) -> ClientResult<RpcEpochInfo> {
         self.get_epoch_info_with_commitment(CommitmentConfig::default())
     }
 
     pub fn get_epoch_info_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
-    ) -> ClientResult<EpochInfo> {
-        self.send(RpcRequest::GetEpochInfo, json!([commitment_config]))
+    ) -> ClientResult<RpcEpochInfo> {
+        self.send(RpcRequest::GetEpochInfo, json!([commitment_config]), 0)
     }
 
     pub fn get_leader_schedule(
@@ -328,15 +322,16 @@ impl RpcClient {
         self.send(
             RpcRequest::GetLeaderSchedule,
             json!([slot, commitment_config]),
+            0,
         )
     }
 
     pub fn get_epoch_schedule(&self) -> ClientResult<EpochSchedule> {
-        self.send(RpcRequest::GetEpochSchedule, Value::Null)
+        self.send(RpcRequest::GetEpochSchedule, Value::Null, 0)
     }
 
     pub fn get_identity(&self) -> ClientResult<Pubkey> {
-        let rpc_identity: RpcIdentity = self.send(RpcRequest::GetIdentity, Value::Null)?;
+        let rpc_identity: RpcIdentity = self.send(RpcRequest::GetIdentity, Value::Null, 0)?;
 
         rpc_identity.identity.parse::<Pubkey>().map_err(|_| {
             ClientError::new_with_request(
@@ -347,15 +342,15 @@ impl RpcClient {
     }
 
     pub fn get_inflation(&self) -> ClientResult<Inflation> {
-        self.send(RpcRequest::GetInflation, Value::Null)
+        self.send(RpcRequest::GetInflation, Value::Null, 0)
     }
 
     pub fn get_version(&self) -> ClientResult<RpcVersionInfo> {
-        self.send(RpcRequest::GetVersion, Value::Null)
+        self.send(RpcRequest::GetVersion, Value::Null, 0)
     }
 
     pub fn minimum_ledger_slot(&self) -> ClientResult<Slot> {
-        self.send(RpcRequest::MinimumLedgerSlot, Value::Null)
+        self.send(RpcRequest::MinimumLedgerSlot, Value::Null, 0)
     }
 
     pub fn send_and_confirm_transaction(
@@ -403,19 +398,17 @@ impl RpcClient {
         }
     }
 
-    pub fn send_and_confirm_transactions_with_spinner<T: Signers>(
+    pub fn send_and_confirm_transactions<T: Signers>(
         &self,
         mut transactions: Vec<Transaction>,
         signer_keys: &T,
     ) -> Result<(), Box<dyn error::Error>> {
-        let progress_bar = new_spinner_progress_bar();
         let mut send_retries = 5;
         loop {
             let mut status_retries = 15;
 
             // Send all transactions
             let mut transactions_signatures = vec![];
-            let num_transactions = transactions.len();
             for transaction in transactions {
                 if cfg!(not(test)) {
                     // Delay ~1 tick between write transactions in an attempt to reduce AccountInUse errors
@@ -425,25 +418,13 @@ impl RpcClient {
                 }
 
                 let signature = self.send_transaction(&transaction).ok();
-                transactions_signatures.push((transaction, signature));
-
-                progress_bar.set_message(&format!(
-                    "[{}/{}] Transactions sent",
-                    transactions_signatures.len(),
-                    num_transactions
-                ));
+                transactions_signatures.push((transaction, signature))
             }
 
             // Collect statuses for all the transactions, drop those that are confirmed
             while status_retries > 0 {
                 status_retries -= 1;
 
-                progress_bar.set_message(&format!(
-                    "[{}/{}] Transactions confirmed",
-                    num_transactions - transactions_signatures.len(),
-                    num_transactions
-                ));
-
                 if cfg!(not(test)) {
                     // Retry twice a second
                     sleep(Duration::from_millis(500));
@@ -454,18 +435,10 @@ impl RpcClient {
                     .filter(|(_transaction, signature)| {
                         if let Some(signature) = signature {
                             if let Ok(status) = self.get_signature_status(&signature) {
-                                if self
-                                    .get_num_blocks_since_signature_confirmation(&signature)
-                                    .unwrap_or(0)
-                                    > 1
-                                {
+                                if status.is_none() {
                                     return false;
-                                } else {
-                                    return match status {
-                                        None => true,
-                                        Some(result) => result.is_err(),
-                                    };
                                 }
+                                return status.unwrap().is_err();
                             }
                         }
                         true
@@ -504,6 +477,24 @@ impl RpcClient {
         Ok(())
     }
 
+    pub fn retry_get_balance(
+        &self,
+        pubkey: &Pubkey,
+        retries: usize,
+    ) -> Result<Option<u64>, Box<dyn error::Error>> {
+        let request = RpcRequest::GetBalance;
+        let balance_json = self
+            .client
+            .send(request, json!([pubkey.to_string()]), retries)
+            .map_err(|err| err.into_with_request(request))?;
+
+        Ok(Some(
+            serde_json::from_value::<Response<u64>>(balance_json)
+                .map_err(|err| ClientError::new_with_request(err.into(), request))?
+                .value,
+        ))
+    }
+
     pub fn get_account(&self, pubkey: &Pubkey) -> ClientResult<Account> {
         self.get_account_with_commitment(pubkey, CommitmentConfig::default())?
             .value
@@ -515,9 +506,10 @@ impl RpcClient {
         pubkey: &Pubkey,
         commitment_config: CommitmentConfig,
     ) -> RpcResult<Option<Account>> {
-        let response = self.sender.send(
+        let response = self.client.send(
             RpcRequest::GetAccountInfo,
             json!([pubkey.to_string(), commitment_config]),
+            0,
         );
 
         response
@@ -553,8 +545,8 @@ impl RpcClient {
     pub fn get_minimum_balance_for_rent_exemption(&self, data_len: usize) -> ClientResult<u64> {
         let request = RpcRequest::GetMinimumBalanceForRentExemption;
         let minimum_balance_json = self
-            .sender
-            .send(request, json!([data_len]))
+            .client
+            .send(request, json!([data_len]), 0)
             .map_err(|err| err.into_with_request(request))?;
 
         let minimum_balance: u64 = serde_json::from_value(minimum_balance_json)
@@ -582,12 +574,16 @@ impl RpcClient {
         self.send(
             RpcRequest::GetBalance,
             json!([pubkey.to_string(), commitment_config]),
+            0,
         )
     }
 
     pub fn get_program_accounts(&self, pubkey: &Pubkey) -> ClientResult<Vec<(Pubkey, Account)>> {
-        let accounts: Vec<RpcKeyedAccount> =
-            self.send(RpcRequest::GetProgramAccounts, json!([pubkey.to_string()]))?;
+        let accounts: Vec<RpcKeyedAccount> = self.send(
+            RpcRequest::GetProgramAccounts,
+            json!([pubkey.to_string()]),
+            0,
+        )?;
         let mut pubkey_accounts: Vec<(Pubkey, Account)> = Vec::new();
         for RpcKeyedAccount { pubkey, account } in accounts.into_iter() {
             let pubkey = pubkey.parse().map_err(|_| {
@@ -610,50 +606,35 @@ impl RpcClient {
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<u64> {
-        self.send(RpcRequest::GetTransactionCount, json!([commitment_config]))
+        self.send(
+            RpcRequest::GetTransactionCount,
+            json!([commitment_config]),
+            0,
+        )
     }
 
     pub fn get_recent_blockhash(&self) -> ClientResult<(Hash, FeeCalculator)> {
-        let (blockhash, fee_calculator, _last_valid_slot) = self
+        Ok(self
             .get_recent_blockhash_with_commitment(CommitmentConfig::default())?
-            .value;
-        Ok((blockhash, fee_calculator))
+            .value)
     }
 
     pub fn get_recent_blockhash_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
-    ) -> 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 {
+    ) -> RpcResult<(Hash, FeeCalculator)> {
+        let Response {
             context,
             value:
                 RpcBlockhashFeeCalculator {
                     blockhash,
                     fee_calculator,
                 },
-        }) = self.send::<Response<RpcBlockhashFeeCalculator>>(
+        } = self.send::<Response<RpcBlockhashFeeCalculator>>(
             RpcRequest::GetRecentBlockhash,
             json!([commitment_config]),
-        ) {
-            (context, blockhash, fee_calculator, 0)
-        } else {
-            return Err(ClientError::new_with_request(
-                RpcError::ParseError("RpcBlockhashFeeCalculator or RpcFees".to_string()).into(),
-                RpcRequest::GetRecentBlockhash,
-            ));
-        };
+            0,
+        )?;
 
         let blockhash = blockhash.parse().map_err(|_| {
             ClientError::new_with_request(
@@ -663,7 +644,7 @@ impl RpcClient {
         })?;
         Ok(Response {
             context,
-            value: (blockhash, fee_calculator, last_valid_slot),
+            value: (blockhash, fee_calculator),
         })
     }
 
@@ -674,6 +655,7 @@ impl RpcClient {
         let Response { value, .. } = self.send::<Response<Option<RpcFeeCalculator>>>(
             RpcRequest::GetFeeCalculatorForBlockhash,
             json!([blockhash.to_string()]),
+            0,
         )?;
 
         Ok(value.map(|rf| rf.fee_calculator))
@@ -683,8 +665,11 @@ impl RpcClient {
         let Response {
             context,
             value: RpcFeeRateGovernor { fee_rate_governor },
-        } =
-            self.send::<Response<RpcFeeRateGovernor>>(RpcRequest::GetFeeRateGovernor, Value::Null)?;
+        } = self.send::<Response<RpcFeeRateGovernor>>(
+            RpcRequest::GetFeeRateGovernor,
+            Value::Null,
+            0,
+        )?;
 
         Ok(Response {
             context,
@@ -719,7 +704,7 @@ impl RpcClient {
     }
 
     pub fn get_genesis_hash(&self) -> ClientResult<Hash> {
-        let hash_str: String = self.send(RpcRequest::GetGenesisHash, Value::Null)?;
+        let hash_str: String = self.send(RpcRequest::GetGenesisHash, Value::Null, 0)?;
         let hash = hash_str.parse().map_err(|_| {
             ClientError::new_with_request(
                 RpcError::ParseError("Hash".to_string()).into(),
@@ -915,6 +900,7 @@ impl RpcClient {
         let result: Response<Vec<Option<TransactionStatus>>> = self.send(
             RpcRequest::GetSignatureStatuses,
             json!([[signature.to_string()]]),
+            5,
         )?;
 
         let confirmations = result.value[0]
@@ -1026,17 +1012,17 @@ impl RpcClient {
     }
 
     pub fn validator_exit(&self) -> ClientResult<bool> {
-        self.send(RpcRequest::ValidatorExit, Value::Null)
+        self.send(RpcRequest::ValidatorExit, Value::Null, 0)
     }
 
-    pub fn send<T>(&self, request: RpcRequest, params: Value) -> ClientResult<T>
+    pub fn send<T>(&self, request: RpcRequest, params: Value, retries: usize) -> ClientResult<T>
     where
         T: serde::de::DeserializeOwned,
     {
         assert!(params.is_array() || params.is_null());
         let response = self
-            .sender
-            .send(request, params)
+            .client
+            .send(request, params, retries)
             .map_err(|err| err.into_with_request(request))?;
         serde_json::from_value(response)
             .map_err(|err| ClientError::new_with_request(err.into(), request))
@@ -1062,11 +1048,12 @@ pub fn get_rpc_request_str(rpc_addr: SocketAddr, tls: bool) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{client_error::ClientErrorKind, mock_sender::PUBKEY};
+    use crate::{client_error::ClientErrorKind, mock_rpc_client_request::PUBKEY};
     use assert_matches::assert_matches;
     use jsonrpc_core::{Error, IoHandler, Params};
     use jsonrpc_http_server::{AccessControlAllowOrigin, DomainsValidation, ServerBuilder};
     use serde_json::Number;
+    use solana_logger;
     use solana_sdk::{
         instruction::InstructionError, signature::Keypair, system_transaction,
         transaction::TransactionError,
@@ -1112,21 +1099,62 @@ mod tests {
             .send(
                 RpcRequest::GetBalance,
                 json!(["deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx"]),
+                0,
             )
             .unwrap();
         assert_eq!(balance, 50);
 
         let blockhash: String = rpc_client
-            .send(RpcRequest::GetRecentBlockhash, Value::Null)
+            .send(RpcRequest::GetRecentBlockhash, Value::Null, 0)
             .unwrap();
         assert_eq!(blockhash, "deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx");
 
         // Send erroneous parameter
         let blockhash: ClientResult<String> =
-            rpc_client.send(RpcRequest::GetRecentBlockhash, json!(["parameter"]));
+            rpc_client.send(RpcRequest::GetRecentBlockhash, json!(["parameter"]), 0);
         assert_eq!(blockhash.is_err(), true);
     }
 
+    #[test]
+    fn test_retry_send() {
+        solana_logger::setup();
+        let (sender, receiver) = channel();
+        thread::spawn(move || {
+            // 1. Pick a random port
+            // 2. Tell the client to start using it
+            // 3. Delay for 1.5 seconds before starting the server to ensure the client will fail
+            //    and need to retry
+            let rpc_addr: SocketAddr = "0.0.0.0:4242".parse().unwrap();
+            sender.send(rpc_addr.clone()).unwrap();
+            sleep(Duration::from_millis(1500));
+
+            let mut io = IoHandler::default();
+            io.add_method("getBalance", move |_params: Params| {
+                Ok(Value::Number(Number::from(5)))
+            });
+            let server = ServerBuilder::new(io)
+                .threads(1)
+                .cors(DomainsValidation::AllowOnly(vec![
+                    AccessControlAllowOrigin::Any,
+                ]))
+                .start_http(&rpc_addr)
+                .expect("Unable to start RPC server");
+            server.wait();
+        });
+
+        let rpc_addr = receiver.recv().unwrap();
+        let rpc_client = RpcClient::new_socket(rpc_addr);
+
+        let balance: u64 = rpc_client
+            .send(
+                RpcRequest::GetBalance,
+                json!(["deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhw"]),
+                10,
+            )
+            .unwrap();
+        assert_eq!(balance, 5);
+    }
+
     #[test]
     fn test_send_transaction() {
         let rpc_client = RpcClient::new_mock("succeeds".to_string());

client/src/rpc_client_request.rs

@@ -1,20 +1,21 @@
 use crate::{
     client_error::Result,
+    generic_rpc_client_request::GenericRpcClientRequest,
     rpc_request::{RpcError, RpcRequest},
-    rpc_sender::RpcSender,
 };
 use log::*;
-use reqwest::{self, header::CONTENT_TYPE, StatusCode};
+use reqwest::{self, header::CONTENT_TYPE};
+use solana_sdk::clock::{DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT};
 use std::{thread::sleep, time::Duration};
 
-pub struct HttpSender {
+pub struct RpcClientRequest {
     client: reqwest::blocking::Client,
     url: String,
 }
 
-impl HttpSender {
+impl RpcClientRequest {
     pub fn new(url: String) -> Self {
-        Self::new_with_timeout(url, Duration::from_secs(30))
+        Self::new_with_timeout(url, Duration::from_secs(20))
     }
 
     pub fn new_with_timeout(url: String, timeout: Duration) -> Self {
@@ -27,14 +28,18 @@ impl HttpSender {
     }
 }
 
-impl RpcSender for HttpSender {
-    fn send(&self, request: RpcRequest, params: serde_json::Value) -> Result<serde_json::Value> {
+impl GenericRpcClientRequest for RpcClientRequest {
+    fn send(
+        &self,
+        request: RpcRequest,
+        params: serde_json::Value,
+        mut retries: usize,
+    ) -> Result<serde_json::Value> {
         // 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);
 
-        let mut too_many_requests_retries = 5;
         loop {
             match self
                 .client
@@ -45,19 +50,6 @@ impl RpcSender for HttpSender {
             {
                 Ok(response) => {
                     if !response.status().is_success() {
-                        if response.status() == StatusCode::TOO_MANY_REQUESTS
-                            && too_many_requests_retries > 0
-                        {
-                            too_many_requests_retries -= 1;
-                            debug!(
-                                "Server responded with {:?}, {} retries left",
-                                response, too_many_requests_retries
-                            );
-
-                            // Sleep for 500ms to give the server a break
-                            sleep(Duration::from_millis(500));
-                            continue;
-                        }
                         return Err(response.error_for_status().unwrap_err().into());
                     }
 
@@ -71,8 +63,17 @@ impl RpcSender for HttpSender {
                     }
                     return Ok(json["result"].clone());
                 }
-                Err(err) => {
-                    return Err(err.into());
+                Err(e) => {
+                    info!("{:?} failed, {} retries left: {:?}", request, retries, e);
+                    if retries == 0 {
+                        return Err(e.into());
+                    }
+                    retries -= 1;
+
+                    // Sleep for approximately half a slot
+                    sleep(Duration::from_millis(
+                        500 * DEFAULT_TICKS_PER_SLOT / DEFAULT_TICKS_PER_SECOND,
+                    ));
                 }
             }
         }

client/src/rpc_config.rs

@@ -3,13 +3,10 @@ use solana_sdk::commitment_config::CommitmentConfig;
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcSignatureStatusConfig {
-    pub search_transaction_history: bool,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcSimulateTransactionConfig {
-    pub sig_verify: bool,
+    pub search_transaction_history: Option<bool>,
+    // DEPRECATED
+    #[serde(flatten)]
+    pub commitment: Option<CommitmentConfig>,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]

client/src/rpc_request.rs

@@ -16,17 +16,15 @@ pub enum RpcRequest {
     GetConfirmedTransaction,
     GetEpochInfo,
     GetEpochSchedule,
-    GetFeeCalculatorForBlockhash,
-    GetFeeRateGovernor,
-    GetFees,
     GetGenesisHash,
     GetIdentity,
     GetInflation,
     GetLargestAccounts,
     GetLeaderSchedule,
-    GetMinimumBalanceForRentExemption,
     GetProgramAccounts,
     GetRecentBlockhash,
+    GetFeeCalculatorForBlockhash,
+    GetFeeRateGovernor,
     GetSignatureStatuses,
     GetSlot,
     GetSlotLeader,
@@ -39,12 +37,12 @@ pub enum RpcRequest {
     GetTransactionCount,
     GetVersion,
     GetVoteAccounts,
-    MinimumLedgerSlot,
     RegisterNode,
     RequestAirdrop,
     SendTransaction,
-    SimulateTransaction,
     SignVote,
+    GetMinimumBalanceForRentExemption,
+    MinimumLedgerSlot,
 }
 
 impl fmt::Display for RpcRequest {
@@ -62,17 +60,15 @@ impl fmt::Display for RpcRequest {
             RpcRequest::GetConfirmedTransaction => "getConfirmedTransaction",
             RpcRequest::GetEpochInfo => "getEpochInfo",
             RpcRequest::GetEpochSchedule => "getEpochSchedule",
-            RpcRequest::GetFeeCalculatorForBlockhash => "getFeeCalculatorForBlockhash",
-            RpcRequest::GetFeeRateGovernor => "getFeeRateGovernor",
-            RpcRequest::GetFees => "getFees",
             RpcRequest::GetGenesisHash => "getGenesisHash",
             RpcRequest::GetIdentity => "getIdentity",
             RpcRequest::GetInflation => "getInflation",
             RpcRequest::GetLargestAccounts => "getLargestAccounts",
             RpcRequest::GetLeaderSchedule => "getLeaderSchedule",
-            RpcRequest::GetMinimumBalanceForRentExemption => "getMinimumBalanceForRentExemption",
             RpcRequest::GetProgramAccounts => "getProgramAccounts",
             RpcRequest::GetRecentBlockhash => "getRecentBlockhash",
+            RpcRequest::GetFeeCalculatorForBlockhash => "getFeeCalculatorForBlockhash",
+            RpcRequest::GetFeeRateGovernor => "getFeeRateGovernor",
             RpcRequest::GetSignatureStatuses => "getSignatureStatuses",
             RpcRequest::GetSlot => "getSlot",
             RpcRequest::GetSlotLeader => "getSlotLeader",
@@ -85,12 +81,12 @@ impl fmt::Display for RpcRequest {
             RpcRequest::GetTransactionCount => "getTransactionCount",
             RpcRequest::GetVersion => "getVersion",
             RpcRequest::GetVoteAccounts => "getVoteAccounts",
-            RpcRequest::MinimumLedgerSlot => "minimumLedgerSlot",
             RpcRequest::RegisterNode => "registerNode",
             RpcRequest::RequestAirdrop => "requestAirdrop",
             RpcRequest::SendTransaction => "sendTransaction",
-            RpcRequest::SimulateTransaction => "simulateTransaction",
             RpcRequest::SignVote => "signVote",
+            RpcRequest::GetMinimumBalanceForRentExemption => "getMinimumBalanceForRentExemption",
+            RpcRequest::MinimumLedgerSlot => "minimumLedgerSlot",
         };
 
         write!(f, "{}", method)
@@ -155,7 +151,7 @@ mod tests {
         assert_eq!(request["method"], "getRecentBlockhash");
 
         let test_request = RpcRequest::GetFeeCalculatorForBlockhash;
-        let request = test_request.build_request_json(1, json!([addr]));
+        let request = test_request.build_request_json(1, json!([addr.clone()]));
         assert_eq!(request["method"], "getFeeCalculatorForBlockhash");
 
         let test_request = RpcRequest::GetFeeRateGovernor;

client/src/rpc_response.rs

@@ -35,14 +35,6 @@ pub struct RpcBlockhashFeeCalculator {
     pub fee_calculator: FeeCalculator,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcFees {
-    pub blockhash: String,
-    pub fee_calculator: FeeCalculator,
-    pub last_valid_slot: Slot,
-}
-
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcFeeCalculator {
@@ -101,6 +93,7 @@ impl RpcAccount {
             })?,
             executable: self.executable,
             rent_epoch: self.rent_epoch,
+            ..Account::default()
         })
     }
 }
@@ -122,6 +115,22 @@ pub struct RpcContactInfo {
 /// Map of leader base58 identity pubkeys to the slot indices relative to the first epoch slot
 pub type RpcLeaderSchedule = HashMap<String, Vec<usize>>;
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcEpochInfo {
+    /// The current epoch
+    pub epoch: Epoch,
+
+    /// The current slot, relative to the start of the current epoch
+    pub slot_index: u64,
+
+    /// The number of slots in this epoch
+    pub slots_in_epoch: u64,
+
+    /// The absolute current slot
+    pub absolute_slot: Slot,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "kebab-case")]
 pub struct RpcVersionInfo {

client/src/rpc_sender.rs

@@ -1,5 +0,0 @@
-use crate::{client_error::Result, rpc_request::RpcRequest};
-
-pub trait RpcSender {
-    fn send(&self, request: RpcRequest, params: serde_json::Value) -> Result<serde_json::Value>;
-}

client/src/thin_client.rs

@@ -11,7 +11,6 @@ use solana_sdk::{
     client::{AsyncClient, Client, SyncClient},
     clock::MAX_PROCESSING_AGE,
     commitment_config::CommitmentConfig,
-    epoch_info::EpochInfo,
     fee_calculator::{FeeCalculator, FeeRateGovernor},
     hash::Hash,
     instruction::Instruction,
@@ -441,7 +440,7 @@ impl SyncClient for ThinClient {
         match recent_blockhash {
             Ok(Response { value, .. }) => {
                 self.optimizer.report(index, duration_as_ms(&now.elapsed()));
-                Ok((value.0, value.1))
+                Ok(value)
             }
             Err(e) => {
                 self.optimizer.report(index, std::u64::MAX);
@@ -519,10 +518,6 @@ impl SyncClient for ThinClient {
         Ok(slot)
     }
 
-    fn get_epoch_info(&self) -> TransportResult<EpochInfo> {
-        self.rpc_client().get_epoch_info().map_err(|e| e.into())
-    }
-
     fn get_transaction_count(&self) -> TransportResult<u64> {
         let index = self.optimizer.experiment();
         let now = Instant::now();

core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "solana-core"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.2.0"
+version = "1.1.13"
 documentation = "https://docs.rs/solana"
 homepage = "https://solana.com/"
 readme = "../README.md"
@@ -16,7 +16,7 @@ codecov = { repository = "solana-labs/solana", branch = "master", service = "git
 [dependencies]
 bincode = "1.2.1"
 bv = { version = "0.11.1", features = ["serde"] }
-bs58 = "0.3.1"
+bs58 = "0.3.0"
 byteorder = "1.3.4"
 chrono = { version = "0.4.11", features = ["serde"] }
 core_affinity = "0.5.10"
@@ -25,51 +25,53 @@ fs_extra = "1.1.0"
 flate2 = "1.0"
 indexmap = "1.3"
 itertools = "0.9.0"
-jsonrpc-core = "14.1.0"
-jsonrpc-core-client = { version = "14.1.0", features = ["ws"] }
-jsonrpc-derive = "14.1.0"
-jsonrpc-http-server = "14.1.0"
-jsonrpc-pubsub = "14.1.0"
-jsonrpc-ws-server = "14.1.0"
+jsonrpc-core = "14.0.5"
+jsonrpc-core-client = { version = "14.0.5", features = ["ws"] }
+jsonrpc-derive = "14.0.5"
+jsonrpc-http-server = "14.0.6"
+jsonrpc-pubsub = "14.0.6"
+jsonrpc-ws-server = "14.0.6"
 log = "0.4.8"
-num_cpus = "1.13.0"
+num_cpus = "1.0.0"
 num-traits = "0.2"
 rand = "0.7.0"
 rand_chacha = "0.2.2"
 rayon = "1.3.0"
-regex = "1.3.7"
-serde = "1.0.110"
+regex = "1.3.6"
+serde = "1.0.105"
 serde_derive = "1.0.103"
-serde_json = "1.0.53"
-solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "1.2.0" }
-solana-budget-program = { path = "../programs/budget", version = "1.2.0" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-client = { path = "../client", version = "1.2.0" }
-solana-transaction-status = { path = "../transaction-status", version = "1.2.0" }
-solana-faucet = { path = "../faucet", version = "1.2.0" }
+serde_json = "1.0.48"
+solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "1.1.13" }
+solana-budget-program = { path = "../programs/budget", version = "1.1.13" }
+solana-clap-utils = { path = "../clap-utils", version = "1.1.13" }
+solana-client = { path = "../client", version = "1.1.13" }
+solana-transaction-status = { path = "../transaction-status", version = "1.1.13" }
+solana-faucet = { path = "../faucet", version = "1.1.13" }
 ed25519-dalek = "=1.0.0-pre.3"
-solana-ledger = { path = "../ledger", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-merkle-tree = { path = "../merkle-tree", version = "1.2.0" }
-solana-metrics = { path = "../metrics", version = "1.2.0" }
-solana-measure = { path = "../measure", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-perf = { path = "../perf", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-stake-program = { path = "../programs/stake", version = "1.2.0" }
-solana-streamer = { path = "../streamer", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.0" }
-solana-vote-signer = { path = "../vote-signer", version = "1.2.0" }
-solana-sys-tuner = { path = "../sys-tuner", version = "1.2.0" }
+solana-ledger = { path = "../ledger", version = "1.1.13" }
+solana-logger = { path = "../logger", version = "1.1.13" }
+solana-merkle-tree = { path = "../merkle-tree", version = "1.1.13" }
+solana-metrics = { path = "../metrics", version = "1.1.13" }
+solana-measure = { path = "../measure", version = "1.1.13" }
+solana-net-utils = { path = "../net-utils", version = "1.1.13" }
+solana-chacha-cuda = { path = "../chacha-cuda", version = "1.1.13" }
+solana-perf = { path = "../perf", version = "1.1.13" }
+solana-runtime = { path = "../runtime", version = "1.1.13" }
+solana-sdk = { path = "../sdk", version = "1.1.13" }
+solana-stake-program = { path = "../programs/stake", version = "1.1.13" }
+solana-storage-program = { path = "../programs/storage", version = "1.1.13" }
+solana-streamer = { path = "../streamer", version = "1.1.13" }
+solana-version = { path = "../version", version = "1.1.13" }
+solana-vote-program = { path = "../programs/vote", version = "1.1.13" }
+solana-vote-signer = { path = "../vote-signer", version = "1.1.13" }
+solana-sys-tuner = { path = "../sys-tuner", version = "1.1.13" }
 tempfile = "3.1.0"
 thiserror = "1.0"
 tokio = "0.1"
 tokio-codec = "0.1"
 tokio-fs = "0.1"
 tokio-io = "0.1"
-solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "1.2.0" }
+solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "1.1.13" }
 trees = "0.2.1"
 
 [dev-dependencies]
@@ -100,5 +102,9 @@ name = "retransmit_stage"
 [[bench]]
 name = "cluster_info"
 
+[[bench]]
+name = "chacha"
+required-features = ["chacha"]
+
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

core/benches/banking_stage.rs

@@ -29,7 +29,7 @@ use solana_sdk::timing::{duration_as_us, timestamp};
 use solana_sdk::transaction::Transaction;
 use std::sync::atomic::Ordering;
 use std::sync::mpsc::Receiver;
-use std::sync::Arc;
+use std::sync::{Arc, RwLock};
 use std::time::{Duration, Instant};
 use test::Bencher;
 
@@ -117,7 +117,7 @@ fn make_programs_txs(txes: usize, hash: Hash) -> Vec<Transaction> {
                 let to_key = Pubkey::new_rand();
                 instructions.push(system_instruction::transfer(&from_key.pubkey(), &to_key, 1));
             }
-            let mut new = Transaction::new_unsigned_instructions(&instructions);
+            let mut new = Transaction::new_unsigned_instructions(instructions);
             new.sign(&[&from_key], hash);
             new
         })

core/benches/chacha.rs

@@ -0,0 +1,29 @@
+//#![feature(test)]
+//
+//extern crate solana_core;
+//extern crate test;
+//
+//use solana_core::chacha::chacha_cbc_encrypt_files;
+//use std::fs::remove_file;
+//use std::fs::File;
+//use std::io::Write;
+//use std::path::Path;
+//use test::Bencher;
+//
+//#[bench]
+//fn bench_chacha_encrypt(bench: &mut Bencher) {
+//    let in_path = Path::new("bench_chacha_encrypt_file_input.txt");
+//    let out_path = Path::new("bench_chacha_encrypt_file_output.txt.enc");
+//    {
+//        let mut in_file = File::create(in_path).unwrap();
+//        for _ in 0..1024 {
+//            in_file.write("123456foobar".as_bytes()).unwrap();
+//        }
+//    }
+//    bench.iter(move || {
+//        chacha_cbc_encrypt_files(in_path, out_path, "thetestkey".to_string()).unwrap();
+//    });
+//
+//    remove_file(in_path).unwrap();
+//    remove_file(out_path).unwrap();
+//}

core/benches/cluster_info.rs

@@ -6,9 +6,10 @@ use rand::{thread_rng, Rng};
 use solana_core::broadcast_stage::{broadcast_shreds, get_broadcast_peers};
 use solana_core::cluster_info::{ClusterInfo, Node};
 use solana_core::contact_info::ContactInfo;
-use solana_ledger::shred::Shred;
+use solana_ledger::shred::{Shred, NONCE_SHRED_PAYLOAD_SIZE};
 use solana_sdk::pubkey::Pubkey;
 use solana_sdk::timing::timestamp;
+use std::sync::RwLock;
 use std::{
     collections::HashMap,
     net::UdpSocket,
@@ -21,11 +22,11 @@ fn broadcast_shreds_bench(bencher: &mut Bencher) {
     solana_logger::setup();
     let leader_pubkey = Pubkey::new_rand();
     let leader_info = Node::new_localhost_with_pubkey(&leader_pubkey);
-    let cluster_info = ClusterInfo::new_with_invalid_keypair(leader_info.info.clone());
+    let mut cluster_info = ClusterInfo::new_with_invalid_keypair(leader_info.info.clone());
     let socket = UdpSocket::bind("0.0.0.0:0").unwrap();
 
     const NUM_SHREDS: usize = 32;
-    let shreds = vec![Shred::new_empty_data_shred(); NUM_SHREDS];
+    let shreds = vec![Shred::new_empty_data_shred(NONCE_SHRED_PAYLOAD_SIZE); NUM_SHREDS];
     let mut stakes = HashMap::new();
     const NUM_PEERS: usize = 200;
     for _ in 0..NUM_PEERS {