Fix broadcast metrics (#9461)

* Rework broadcast metrics to support multiple threads

* Update dashboards

Co-authored-by: Carl <carl@solana.com>

.gitbook.yaml

@@ -3,16 +3,3 @@ root: ./docs/src
 structure:
     readme: introduction.md
     summary: SUMMARY.md
-
-redirects:
-    wallet: ./wallet-guide/README.md
-    wallet/app-wallets: ./wallet-guide/apps.md
-    wallet/app-wallets/trust-wallet: ./wallet-guide/trust-wallet.md
-    wallet/app-wallets/ledger-live:  ./wallet-guide/ledger-live.md
-    wallet/cli-wallets:  ./wallet-guide/cli.md
-    wallet/cli-wallets/paper-wallet:  ./paper-wallet/README.md
-    wallet/cli-wallets/paper-wallet/paper-wallet-usage: ./paper-wallet/paper-wallet-usage.md
-    wallet/cli-wallets/remote-wallet: ./hardware-wallets/README.md
-    wallet/cli-wallets/remote-wallet/ledger: ./hardware-wallets/ledger.md
-    wallet/cli-wallets/file-system-wallet: ./file-system-wallet/README.md
-    wallet/support: ./wallet-guide/support.md

.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,21 +41,23 @@ 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",
-    "version",
     "vote-signer",
     "cli",
     "rayon-threadlimit",

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.1"
+version = "1.1.4"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -10,13 +10,10 @@ homepage = "https://solana.com/"
 [dependencies]
 log = "0.4.6"
 rayon = "1.3.0"
-solana-logger = { path = "../logger", version = "1.2.1" }
-solana-runtime = { path = "../runtime", version = "1.2.1" }
-solana-measure = { path = "../measure", version = "1.2.1" }
-solana-sdk = { path = "../sdk", version = "1.2.1" }
-rand = "0.7.0"
-clap = "2.33.1"
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-runtime = { path = "../runtime", version = "1.1.4" }
+solana-measure = { path = "../measure", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+rand = "0.6.5"
+clap = "2.33.0"
 crossbeam-channel = "0.4"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

accounts-bench/src/main.rs

@@ -1,11 +1,9 @@
 use clap::{value_t, App, Arg};
 use rayon::prelude::*;
 use solana_measure::measure::Measure;
-use solana_runtime::{
-    accounts::{create_test_accounts, update_accounts, Accounts},
-    accounts_index::Ancestors,
-};
+use solana_runtime::accounts::{create_test_accounts, update_accounts, Accounts};
 use solana_sdk::pubkey::Pubkey;
+use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
 
@@ -78,7 +76,7 @@ fn main() {
         num_slots,
         create_time
     );
-    let mut ancestors: Ancestors = vec![(0, 0)].into_iter().collect();
+    let mut ancestors: HashMap<u64, usize> = vec![(0, 0)].into_iter().collect();
     for i in 1..num_slots {
         ancestors.insert(i as u64, i - 1);
         accounts.add_root(i as u64);

archiver-lib/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "solana-archiver-lib"
+version = "1.1.4"
+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.1"
+log = "0.4.8"
+rand = "0.6.5"
+rand_chacha = "0.1.1"
+solana-client = { path = "../client", version = "1.1.4" }
+solana-storage-program = { path = "../programs/storage", version = "1.1.4" }
+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.4" }
+solana-chacha = { path = "../chacha", version = "1.1.4" }
+solana-chacha-sys = { path = "../chacha-sys", version = "1.1.4" }
+solana-ledger = { path = "../ledger", version = "1.1.4" }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-perf = { path = "../perf", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+solana-core = { path = "../core", version = "1.1.4" }
+solana-streamer = { path = "../streamer", version = "1.1.4" }
+solana-archiver-utils = { path = "../archiver-utils", version = "1.1.4" }
+solana-metrics = { path = "../metrics", version = "1.1.4" }
+
+[dev-dependencies]
+hex = "0.4.2"
+
+[lib]
+name = "solana_archiver_lib"

archiver-lib/src/archiver.rs

@@ -0,0 +1,943 @@
+use crate::result::ArchiverError;
+use crossbeam_channel::unbounded;
+use rand::{thread_rng, Rng, SeedableRng};
+use rand_chacha::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,
+    repair_service::{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, RwLock},
+    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 mut cluster_info = ClusterInfo::new(node.info.clone(), keypair.clone());
+        cluster_info.set_entrypoint(cluster_entrypoint.clone());
+        let cluster_info = Arc::new(RwLock::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, 1) {
+                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<RwLock<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: &Arc<RwLock<ClusterInfo>>,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+        client_commitment: CommitmentConfig,
+    ) {
+        let nodes = cluster_info.read().unwrap().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<RwLock<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<RwLock<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.read().unwrap().my_data().shred_version;
+        {
+            let mut cluster_info_w = cluster_info.write().unwrap();
+            cluster_info_w.insert_self(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: &Arc<RwLock<ClusterInfo>>,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+    ) {
+        // No point if we've got no storage account...
+        let nodes = cluster_info.read().unwrap().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: &Arc<RwLock<ClusterInfo>>,
+        client_commitment: CommitmentConfig,
+    ) -> Result<u64> {
+        let rpc_peers = {
+            let cluster_info = cluster_info.read().unwrap();
+            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(
+                    &RpcRequest::GetSlotsPerSegment,
+                    serde_json::json!([client_commitment]),
+                    0,
+                )
+                .map_err(|err| {
+                    warn!("Error while making rpc request {:?}", err);
+                    ArchiverError::ClientError(err)
+                })?
+                .as_u64()
+                .unwrap())
+        } else {
+            Err(ArchiverError::NoRpcPeers)
+        }
+    }
+
+    /// Waits until the first segment is ready, and returns the current segment
+    fn poll_for_segment(
+        cluster_info: &Arc<RwLock<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: &Arc<RwLock<ClusterInfo>>,
+        slots_per_segment: u64,
+        previous_blockhash: &Hash,
+        exit: &Arc<AtomicBool>,
+    ) -> Result<(Hash, u64)> {
+        info!("waiting for the next turn...");
+        loop {
+            let rpc_peers = {
+                let cluster_info = cluster_info.read().unwrap();
+                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 response = rpc_client
+                    .send(
+                        &RpcRequest::GetStorageTurn,
+                        serde_json::value::Value::Null,
+                        0,
+                    )
+                    .map_err(|err| {
+                        warn!("Error while making rpc request {:?}", err);
+                        ArchiverError::ClientError(err)
+                    })?;
+                let RpcStorageTurn {
+                    blockhash: storage_blockhash,
+                    slot: turn_slot,
+                } = serde_json::from_value::<RpcStorageTurn>(response)
+                    .map_err(ArchiverError::JsonError)?;
+                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)
+                            .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,48 @@
+use serde_json;
+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,25 @@
+[package]
+name = "solana-archiver-utils"
+version = "1.1.4"
+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.6.5"
+solana-chacha = { path = "../chacha", version = "1.1.4" }
+solana-chacha-sys = { path = "../chacha-sys", version = "1.1.4" }
+solana-ledger = { path = "../ledger", version = "1.1.4" }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-perf = { path = "../perf", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+
+[dev-dependencies]
+hex = "0.4.2"
+
+[lib]
+name = "solana_archiver_utils"

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,20 @@
+[package]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+edition = "2018"
+name = "solana-archiver"
+version = "1.1.4"
+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.4" }
+solana-core = { path = "../core", version = "1.1.4" }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-metrics = { path = "../metrics", version = "1.1.4" }
+solana-archiver-lib = { path = "../archiver-lib", version = "1.1.4" }
+solana-net-utils = { path = "../net-utils", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+

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,21 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-banking-bench"
-version = "1.2.1"
+version = "1.1.4"
 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.1" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.1" }
-solana-streamer = { path = "../streamer", version = "1.2.1" }
-solana-perf = { path = "../perf", version = "1.2.1" }
-solana-ledger = { path = "../ledger", version = "1.2.1" }
-solana-logger = { path = "../logger", version = "1.2.1" }
-solana-runtime = { path = "../runtime", version = "1.2.1" }
-solana-measure = { path = "../measure", version = "1.2.1" }
-solana-sdk = { path = "../sdk", version = "1.2.1" }
-solana-version = { path = "../version", version = "1.2.1" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+solana-core = { path = "../core", version = "1.1.4" }
+solana-streamer = { path = "../streamer", version = "1.1.4" }
+solana-perf = { path = "../perf", version = "1.1.4" }
+solana-ledger = { path = "../ledger", version = "1.1.4" }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-runtime = { path = "../runtime", version = "1.1.4" }
+solana-measure = { path = "../measure", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+rand = "0.6.5"
+crossbeam-channel = "0.4"

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};
@@ -29,7 +28,7 @@ use solana_sdk::{
     transaction::Transaction,
 };
 use std::{
-    sync::{atomic::Ordering, mpsc::Receiver, Arc, Mutex},
+    sync::{atomic::Ordering, mpsc::Receiver, Arc, Mutex, RwLock},
     thread::sleep,
     time::{Duration, Instant},
 };
@@ -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(
@@ -218,7 +152,7 @@ fn main() {
         let (exit, poh_recorder, poh_service, signal_receiver) =
             create_test_recorder(&bank, &blockstore, None);
         let cluster_info = ClusterInfo::new_with_invalid_keypair(Node::new_localhost().info);
-        let cluster_info = Arc::new(cluster_info);
+        let cluster_info = Arc::new(RwLock::new(cluster_info));
         let banking_stage = BankingStage::new(
             &cluster_info,
             &poh_recorder,
@@ -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(),
@@ -323,7 +253,7 @@ fn main() {
                 poh_recorder.lock().unwrap().set_bank(&bank);
                 assert!(poh_recorder.lock().unwrap().bank().is_some());
                 if bank.slot() > 32 {
-                    bank_forks.set_root(root, &None, None);
+                    bank_forks.set_root(root, &None);
                     root += 1;
                 }
                 debug!(
@@ -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,33 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-exchange"
-version = "1.2.1"
+version = "1.1.4"
 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"
+rand = "0.6.5"
 rayon = "1.3.0"
-serde_json = "1.0.53"
-serde_yaml = "0.8.12"
-solana-clap-utils = { path = "../clap-utils", version = "1.2.1" }
-solana-core = { path = "../core", version = "1.2.1" }
-solana-genesis = { path = "../genesis", version = "1.2.1" }
-solana-client = { path = "../client", version = "1.2.1" }
-solana-faucet = { path = "../faucet", version = "1.2.1" }
-solana-exchange-program = { path = "../programs/exchange", version = "1.2.1" }
-solana-logger = { path = "../logger", version = "1.2.1" }
-solana-metrics = { path = "../metrics", version = "1.2.1" }
-solana-net-utils = { path = "../net-utils", version = "1.2.1" }
-solana-runtime = { path = "../runtime", version = "1.2.1" }
-solana-sdk = { path = "../sdk", version = "1.2.1" }
-solana-version = { path = "../version", version = "1.2.1" }
+serde_json = "1.0.48"
+serde_yaml = "0.8.11"
+solana-clap-utils = { path = "../clap-utils", version = "1.1.4" }
+solana-core = { path = "../core", version = "1.1.4" }
+solana-genesis = { path = "../genesis", version = "1.1.4" }
+solana-client = { path = "../client", version = "1.1.4" }
+solana-faucet = { path = "../faucet", version = "1.1.4" }
+solana-exchange-program = { path = "../programs/exchange", version = "1.1.4" }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-metrics = { path = "../metrics", version = "1.1.4" }
+solana-net-utils = { path = "../net-utils", version = "1.1.4" }
+solana-runtime = { path = "../runtime", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
 
 [dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "1.2.1" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+solana-local-cluster = { path = "../local-cluster", version = "1.1.4" }

bench-exchange/src/bench.rs

@@ -449,7 +449,7 @@ fn swapper<T>(
             }
             account_group = (account_group + 1) % account_groups as usize;
 
-            let (blockhash, _fee_calculator, _last_valid_slot) = client
+            let (blockhash, _fee_calculator) = client
                 .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                 .expect("Failed to get blockhash");
             let to_swap_txs: Vec<_> = to_swap
@@ -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,
@@ -577,7 +577,7 @@ fn trader<T>(
         }
         account_group = (account_group + 1) % account_groups as usize;
 
-        let (blockhash, _fee_calculator, _last_valid_slot) = client
+        let (blockhash, _fee_calculator) = client
             .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
             .expect("Failed to get blockhash");
 
@@ -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",
@@ -776,7 +775,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
                     to_fund_txs.len(),
                 );
 
-                let (blockhash, _fee_calculator, _last_valid_slot) = client
+                let (blockhash, _fee_calculator) = client
                     .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("blockhash");
                 to_fund_txs.par_iter_mut().for_each(|(k, tx)| {
@@ -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",
@@ -868,7 +866,7 @@ pub fn create_token_accounts<T: Client>(
 
             let mut retries = 0;
             while !to_create_txs.is_empty() {
-                let (blockhash, _fee_calculator, _last_valid_slot) = client
+                let (blockhash, _fee_calculator) = client
                     .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("Failed to get blockhash");
                 to_create_txs
@@ -997,7 +995,7 @@ pub fn airdrop_lamports<T: Client>(
 
     let mut tries = 0;
     loop {
-        let (blockhash, _fee_calculator, _last_valid_slot) = client
+        let (blockhash, _fee_calculator) = client
             .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
             .expect("Failed to get blockhash");
         match request_airdrop_transaction(&faucet_addr, &id.pubkey(), amount_to_drop, blockhash) {

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_instruction_processor(id(), process_instruction);
     let clients = vec![BankClient::new(bank)];
 
     let mut config = Config::default();

bench-streamer/Cargo.toml

@@ -2,18 +2,14 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-streamer"
-version = "1.2.1"
+version = "1.1.4"
 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.1" }
-solana-streamer = { path = "../streamer", version = "1.2.1" }
-solana-logger = { path = "../logger", version = "1.2.1" }
-solana-net-utils = { path = "../net-utils", version = "1.2.1" }
-solana-version = { path = "../version", version = "1.2.1" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+clap = "2.33.0"
+solana-clap-utils = { path = "../clap-utils", version = "1.1.4" }
+solana-streamer = { path = "../streamer", version = "1.1.4" }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-net-utils = { path = "../net-utils", version = "1.1.4" }

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,36 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "1.2.1"
+version = "1.1.4"
 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.1" }
-solana-core = { path = "../core", version = "1.2.1" }
-solana-genesis = { path = "../genesis", version = "1.2.1" }
-solana-client = { path = "../client", version = "1.2.1" }
-solana-faucet = { path = "../faucet", version = "1.2.1" }
-solana-librapay = { path = "../programs/librapay", version = "1.2.1", optional = true }
-solana-logger = { path = "../logger", version = "1.2.1" }
-solana-metrics = { path = "../metrics", version = "1.2.1" }
-solana-measure = { path = "../measure", version = "1.2.1" }
-solana-net-utils = { path = "../net-utils", version = "1.2.1" }
-solana-runtime = { path = "../runtime", version = "1.2.1" }
-solana-sdk = { path = "../sdk", version = "1.2.1" }
-solana-move-loader-program = { path = "../programs/move_loader", version = "1.2.1", optional = true }
-solana-version = { path = "../version", version = "1.2.1" }
+serde_json = "1.0.48"
+serde_yaml = "0.8.11"
+solana-clap-utils = { path = "../clap-utils", version = "1.1.4" }
+solana-core = { path = "../core", version = "1.1.4" }
+solana-genesis = { path = "../genesis", version = "1.1.4" }
+solana-client = { path = "../client", version = "1.1.4" }
+solana-faucet = { path = "../faucet", version = "1.1.4" }
+solana-librapay = { path = "../programs/librapay", version = "1.1.4", optional = true }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-metrics = { path = "../metrics", version = "1.1.4" }
+solana-measure = { path = "../measure", version = "1.1.4" }
+solana-net-utils = { path = "../net-utils", version = "1.1.4" }
+solana-runtime = { path = "../runtime", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+solana-move-loader-program = { path = "../programs/move_loader", version = "1.1.4", optional = true }
 
 [dev-dependencies]
 serial_test = "0.4.0"
 serial_test_derive = "0.4.0"
-solana-local-cluster = { path = "../local-cluster", version = "1.2.1" }
+solana-local-cluster = { path = "../local-cluster", version = "1.1.4" }
 
 [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},
 };
 
@@ -55,9 +55,7 @@ type LibraKeys = (Keypair, Pubkey, Pubkey, Vec<Keypair>);
 fn get_recent_blockhash<T: Client>(client: &T) -> (Hash, FeeCalculator) {
     loop {
         match client.get_recent_blockhash_with_commitment(CommitmentConfig::recent()) {
-            Ok((blockhash, fee_calculator, _last_valid_slot)) => {
-                return (blockhash, fee_calculator)
-            }
+            Ok((blockhash, fee_calculator)) => return (blockhash, fee_calculator),
             Err(err) => {
                 info!("Couldn't get recent blockhash: {:?}", err);
                 sleep(Duration::from_secs(1));
@@ -66,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();
@@ -130,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],
@@ -166,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);
@@ -652,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();
@@ -691,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;
@@ -724,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
@@ -1025,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,24 @@
+[package]
+name = "solana-chacha-cuda"
+version = "1.1.4"
+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.4" }
+solana-chacha = { path = "../chacha", version = "1.1.4" }
+solana-ledger = { path = "../ledger", version = "1.1.4" }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-perf = { path = "../perf", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+
+[dev-dependencies]
+hex-literal = "0.2.1"
+
+[lib]
+name = "solana_chacha_cuda"

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/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "solana-chacha-sys"
+version = "1.1.4"
+description = "Solana chacha-sys"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+homepage = "https://solana.com/"
+license = "Apache-2.0"
+edition = "2018"
+
+[build-dependencies]
+cc = "1.0.49"

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,25 @@
+[package]
+name = "solana-chacha"
+version = "1.1.4"
+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.6.5"
+rand_chacha = "0.1.1"
+solana-chacha-sys = { path = "../chacha-sys", version = "1.1.4" }
+solana-ledger = { path = "../ledger", version = "1.1.4" }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-perf = { path = "../perf", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+
+[dev-dependencies]
+hex-literal = "0.2.1"
+
+[lib]
+name = "solana_chacha"

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-secondary.yml

@@ -2,16 +2,6 @@
 # Build steps that run after the primary pipeline on pushes and tags.
 # Pull requests to not run these steps.
 steps:
-  - command: "ci/publish-tarball.sh"
-    timeout_in_minutes: 60
-    name: "publish tarball"
-  - command: "ci/publish-docs.sh"
-    timeout_in_minutes: 15
-    name: "publish docs"
-  - command: "ci/publish-bpf-sdk.sh"
-    timeout_in_minutes: 5
-    name: "publish bpf sdk"
-  - wait
   - command: "sdk/docker-solana/build.sh"
     timeout_in_minutes: 60
     name: "publish docker"
@@ -19,6 +9,15 @@ steps:
     timeout_in_minutes: 240
     name: "publish crate"
     branches: "!master"
-    #  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-move.sh"
-    #    name: "move"
-    #    timeout_in_minutes: 20
+  - command: "ci/publish-bpf-sdk.sh"
+    timeout_in_minutes: 5
+    name: "publish bpf sdk"
+  - command: "ci/publish-tarball.sh"
+    timeout_in_minutes: 60
+    name: "publish tarball"
+  - command: "ci/publish-docs.sh"
+    timeout_in_minutes: 15
+    name: "publish docs"
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-move.sh"
+    name: "move"
+    timeout_in_minutes: 20

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/docker-run.sh

@@ -49,7 +49,7 @@ else
   # ~/.cargo
   ARGS+=(--volume "$PWD:/home")
 fi
-ARGS+=(--env "HOME=/home" --env "CARGO_HOME=/home/.cargo")
+ARGS+=(--env "CARGO_HOME=/home/.cargo")
 
 # kcov tries to set the personality of the binary which docker
 # doesn't allow by default.

ci/docker-rust-nightly/Dockerfile

@@ -1,4 +1,4 @@
-FROM solanalabs/rust:1.43.0
+FROM solanalabs/rust:1.42.0
 ARG date
 
 RUN set -x \

ci/docker-rust/Dockerfile

@@ -1,6 +1,6 @@
 # Note: when the rust version is changed also modify
 # ci/rust-version.sh to pick up the new image tag
-FROM rust:1.43.0
+FROM rust:1.42.0
 
 # Add Google Protocol Buffers for Libra's metrics library.
 ENV PROTOC_VERSION 3.8.0

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/publish-tarball.sh

@@ -71,7 +71,7 @@ echo --- Creating release tarball
   export CHANNEL
 
   source ci/rust-version.sh stable
-  scripts/cargo-install-all.sh +"$rust_stable" solana-release
+  scripts/cargo-install-all.sh +"$rust_stable" --use-move solana-release
 
   tar cvf solana-release-$TARGET.tar solana-release
   bzip2 solana-release-$TARGET.tar
@@ -95,8 +95,9 @@ fi
 source ci/upload-ci-artifact.sh
 
 for file in solana-release-$TARGET.tar.bz2 solana-release-$TARGET.yml solana-install-init-"$TARGET"* $MAYBE_TARBALLS; do
+  upload-ci-artifact "$file"
+
   if [[ -n $DO_NOT_PUBLISH_TAR ]]; then
-    upload-ci-artifact "$file"
     echo "Skipped $file due to DO_NOT_PUBLISH_TAR"
     continue
   fi

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 --url http://localhost:8899 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/rust-version.sh

@@ -1,30 +1,28 @@
 #
 # This file maintains the rust versions for use by CI.
 #
+# Build with stable rust, updating the stable toolchain if necessary:
+#   $ source ci/rust-version.sh stable
+#   $ cargo +"$rust_stable" build
+#
+# Build with nightly rust, updating the nightly toolchain if necessary:
+#   $ source ci/rust-version.sh nightly
+#   $ cargo +"$rust_nightly" build
+#
 # Obtain the environment variables without any automatic toolchain updating:
 #   $ source ci/rust-version.sh
 #
-# Obtain the environment variables updating both stable and nightly, only stable, or
-# only nightly:
-#   $ source ci/rust-version.sh all
-#   $ source ci/rust-version.sh stable
-#   $ source ci/rust-version.sh nightly
-
-# Then to build with either stable or nightly:
-#   $ cargo +"$rust_stable" build
-#   $ cargo +"$rust_nightly" build
-#
 
 if [[ -n $RUST_STABLE_VERSION ]]; then
   stable_version="$RUST_STABLE_VERSION"
 else
-  stable_version=1.43.0
+  stable_version=1.42.0
 fi
 
 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
   nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2020-04-23
+  nightly_version=2020-03-12
 fi
 
 
@@ -53,10 +51,6 @@ export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
   nightly)
      rustup_install "$rust_nightly"
     ;;
-  all)
-     rustup_install "$rust_stable"
-     rustup_install "$rust_nightly"
-    ;;
   *)
     echo "Note: ignoring unknown argument: $1"
     ;;

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-bench.sh

@@ -25,7 +25,7 @@ source ci/_
 source ci/upload-ci-artifact.sh
 
 eval "$(ci/channel-info.sh)"
-source ci/rust-version.sh all
+source ci/rust-version.sh nightly
 
 set -o pipefail
 export RUST_BACKTRACE=1

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

@@ -39,9 +39,9 @@ test -d target/release/bpf && find target/release/bpf -name '*.d' -delete
 rm -rf target/xargo # Issue #3105
 
 # Limit compiler jobs to reduce memory usage
-# on machines with 2gb/thread of memory
+# on machines with 1gb/thread of memory
 NPROC=$(nproc)
-NPROC=$((NPROC>14 ? 14 : NPROC))
+NPROC=$((NPROC>16 ? 16 : NPROC))
 
 echo "Executing $testName"
 case $testName in
@@ -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.1"
+version = "1.1.4"
 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.1" }
-solana-sdk = { path = "../sdk", version = "1.2.1" }
+solana-remote-wallet = { path = "../remote-wallet", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
 thiserror = "1.0.11"
 tiny-bip39 = "0.7.0"
 url = "2.1.0"
@@ -20,6 +20,3 @@ chrono = "0.4"
 
 [lib]
 name = "solana_clap_utils"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

clap-utils/src/commitment.rs

@@ -1,22 +0,0 @@
-use crate::ArgConstant;
-use clap::Arg;
-
-pub const COMMITMENT_ARG: ArgConstant<'static> = ArgConstant {
-    name: "commitment",
-    long: "commitment",
-    help: "Return information at the selected commitment level",
-};
-
-pub fn commitment_arg<'a, 'b>() -> Arg<'a, 'b> {
-    commitment_arg_with_default("recent")
-}
-
-pub fn commitment_arg_with_default<'a, 'b>(default_value: &'static str) -> Arg<'a, 'b> {
-    Arg::with_name(COMMITMENT_ARG.name)
-        .long(COMMITMENT_ARG.long)
-        .takes_value(true)
-        .possible_values(&["recent", "single", "root", "max"])
-        .default_value(default_value)
-        .value_name("COMMITMENT_LEVEL")
-        .help(COMMITMENT_ARG.help)
-}

clap-utils/src/input_parsers.rs

@@ -7,7 +7,6 @@ use clap::ArgMatches;
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
     clock::UnixTimestamp,
-    commitment_config::CommitmentConfig,
     native_token::sol_to_lamports,
     pubkey::Pubkey,
     signature::{read_keypair_file, Keypair, Signature, Signer},
@@ -117,7 +116,7 @@ pub fn pubkeys_sigs_of(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<(Pubk
 pub fn signer_of(
     matches: &ArgMatches<'_>,
     name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<(Option<Box<dyn Signer>>, Option<Pubkey>), Box<dyn std::error::Error>> {
     if let Some(location) = matches.value_of(name) {
         let signer = signer_from_path(matches, location, name, wallet_manager)?;
@@ -131,7 +130,7 @@ pub fn signer_of(
 pub fn pubkey_of_signer(
     matches: &ArgMatches<'_>,
     name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<Option<Pubkey>, Box<dyn std::error::Error>> {
     if let Some(location) = matches.value_of(name) {
         Ok(Some(pubkey_from_path(
@@ -148,7 +147,7 @@ pub fn pubkey_of_signer(
 pub fn pubkeys_of_multiple_signers(
     matches: &ArgMatches<'_>,
     name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<Option<Vec<Pubkey>>, Box<dyn std::error::Error>> {
     if let Some(pubkey_matches) = matches.values_of(name) {
         let mut pubkeys: Vec<Pubkey> = vec![];
@@ -164,7 +163,7 @@ pub fn pubkeys_of_multiple_signers(
 pub fn resolve_signer(
     matches: &ArgMatches<'_>,
     name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<Option<String>, Box<dyn std::error::Error>> {
     Ok(resolve_signer_from_path(
         matches,
@@ -178,16 +177,6 @@ pub fn lamports_of_sol(matches: &ArgMatches<'_>, name: &str) -> Option<u64> {
     value_of(matches, name).map(sol_to_lamports)
 }
 
-pub fn commitment_of(matches: &ArgMatches<'_>, name: &str) -> Option<CommitmentConfig> {
-    matches.value_of(name).map(|value| match value {
-        "max" => CommitmentConfig::max(),
-        "recent" => CommitmentConfig::recent(),
-        "root" => CommitmentConfig::root(),
-        "single" => CommitmentConfig::single(),
-        _ => CommitmentConfig::default(),
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -350,16 +339,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/keypair.rs

@@ -8,7 +8,7 @@ use clap::ArgMatches;
 use rpassword::prompt_password_stderr;
 use solana_remote_wallet::{
     remote_keypair::generate_remote_keypair,
-    remote_wallet::{maybe_wallet_manager, RemoteWalletError, RemoteWalletManager},
+    remote_wallet::{RemoteWalletError, RemoteWalletManager},
 };
 use solana_sdk::{
     pubkey::Pubkey,
@@ -47,6 +47,13 @@ pub fn parse_keypair_path(path: &str) -> KeypairUrl {
     }
 }
 
+pub fn check_for_usb<S>(mut items: impl Iterator<Item = S>) -> bool
+where
+    S: Into<String>,
+{
+    items.any(|arg| matches!(parse_keypair_path(&arg.into()), KeypairUrl::Usb(_)))
+}
+
 pub fn presigner_from_pubkey_sigs(
     pubkey: &Pubkey,
     signers: &[(Pubkey, Signature)],
@@ -64,7 +71,7 @@ pub fn signer_from_path(
     matches: &ArgMatches,
     path: &str,
     keypair_name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<Box<dyn Signer>, Box<dyn error::Error>> {
     match parse_keypair_path(path) {
         KeypairUrl::Ask => {
@@ -88,9 +95,6 @@ pub fn signer_from_path(
             Ok(Box::new(read_keypair(&mut stdin)?))
         }
         KeypairUrl::Usb(path) => {
-            if wallet_manager.is_none() {
-                *wallet_manager = maybe_wallet_manager()?;
-            }
             if let Some(wallet_manager) = wallet_manager {
                 Ok(Box::new(generate_remote_keypair(
                     path,
@@ -125,7 +129,7 @@ pub fn pubkey_from_path(
     matches: &ArgMatches,
     path: &str,
     keypair_name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<Pubkey, Box<dyn error::Error>> {
     match parse_keypair_path(path) {
         KeypairUrl::Pubkey(pubkey) => Ok(pubkey),
@@ -137,7 +141,7 @@ pub fn resolve_signer_from_path(
     matches: &ArgMatches,
     path: &str,
     keypair_name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<Option<String>, Box<dyn error::Error>> {
     match parse_keypair_path(path) {
         KeypairUrl::Ask => {
@@ -161,9 +165,6 @@ pub fn resolve_signer_from_path(
             read_keypair(&mut stdin).map(|_| None)
         }
         KeypairUrl::Usb(path) => {
-            if wallet_manager.is_none() {
-                *wallet_manager = maybe_wallet_manager()?;
-            }
             if let Some(wallet_manager) = wallet_manager {
                 let path = generate_remote_keypair(
                     path,
@@ -262,4 +263,20 @@ mod tests {
             sanitize_seed_phrase(seed_phrase)
         );
     }
+
+    #[test]
+    fn test_check_for_usb() {
+        let args: Vec<&str> = vec![];
+        assert_eq!(check_for_usb(args.into_iter()), false);
+        let args = vec!["usb://"];
+        assert_eq!(check_for_usb(args.into_iter()), true);
+        let args = vec!["other"];
+        assert_eq!(check_for_usb(args.into_iter()), false);
+        let args = vec!["other", "usb://", "another"];
+        assert_eq!(check_for_usb(args.into_iter()), true);
+        let args = vec!["other", "another"];
+        assert_eq!(check_for_usb(args.into_iter()), false);
+        let args = vec!["usb://", "usb://"];
+        assert_eq!(check_for_usb(args.into_iter()), true);
+    }
 }

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,
@@ -23,7 +42,6 @@ impl std::fmt::Debug for DisplayError {
     }
 }
 
-pub mod commitment;
 pub mod input_parsers;
 pub mod input_validators;
 pub mod keypair;

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.1"
+version = "1.1.4"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -11,10 +11,7 @@ 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]
-targets = ["x86_64-unknown-linux-gnu"]

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.1"
+version = "1.1.4"
 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,36 +24,33 @@ 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.1" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.1" }
-solana-cli-config = { path = "../cli-config", version = "1.2.1" }
-solana-client = { path = "../client", version = "1.2.1" }
-solana-config-program = { path = "../programs/config", version = "1.2.1" }
-solana-faucet = { path = "../faucet", version = "1.2.1" }
-solana-logger = { path = "../logger", version = "1.2.1" }
-solana-net-utils = { path = "../net-utils", version = "1.2.1" }
-solana-remote-wallet = { path = "../remote-wallet", version = "1.2.1" }
-solana-runtime = { path = "../runtime", version = "1.2.1" }
-solana-sdk = { path = "../sdk", version = "1.2.1" }
-solana-stake-program = { path = "../programs/stake", version = "1.2.1" }
-solana-transaction-status = { path = "../transaction-status", version = "1.2.1" }
-solana-version = { path = "../version", version = "1.2.1" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.1" }
-solana-vote-signer = { path = "../vote-signer", version = "1.2.1" }
-thiserror = "1.0.19"
+serde_json = "1.0.48"
+solana-budget-program = { path = "../programs/budget", version = "1.1.4" }
+solana-clap-utils = { path = "../clap-utils", version = "1.1.4" }
+solana-cli-config = { path = "../cli-config", version = "1.1.4" }
+solana-client = { path = "../client", version = "1.1.4" }
+solana-config-program = { path = "../programs/config", version = "1.1.4" }
+solana-faucet = { path = "../faucet", version = "1.1.4" }
+solana-logger = { path = "../logger", version = "1.1.4" }
+solana-net-utils = { path = "../net-utils", version = "1.1.4" }
+solana-remote-wallet = { path = "../remote-wallet", version = "1.1.4" }
+solana-runtime = { path = "../runtime", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+solana-stake-program = { path = "../programs/stake", version = "1.1.4" }
+solana-storage-program = { path = "../programs/storage", version = "1.1.4" }
+solana-transaction-status = { path = "../transaction-status", version = "1.1.4" }
+solana-vote-program = { path = "../programs/vote", version = "1.1.4" }
+solana-vote-signer = { path = "../vote-signer", version = "1.1.4" }
+thiserror = "1.0.13"
 url = "2.1.1"
 
 [dev-dependencies]
-solana-core = { path = "../core", version = "1.2.1" }
-solana-budget-program = { path = "../programs/budget", version = "1.2.1" }
+solana-core = { path = "../core", version = "1.1.4" }
+solana-budget-program = { path = "../programs/budget", version = "1.1.4" }
 tempfile = "3.1.0"
 
 [[bin]]
 name = "solana"
 path = "src/main.rs"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

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

@@ -4,13 +4,9 @@ use console::{style, Emoji};
 use inflector::cases::titlecase::to_title_case;
 use serde::Serialize;
 use serde_json::{Map, Value};
-use solana_client::rpc_response::{
-    RpcAccountBalance, RpcKeyedAccount, RpcSupply, RpcVoteAccountInfo,
-};
+use solana_client::rpc_response::{RpcEpochInfo, RpcKeyedAccount, RpcVoteAccountInfo};
 use solana_sdk::{
     clock::{self, Epoch, Slot, UnixTimestamp},
-    epoch_info::EpochInfo,
-    native_token::lamports_to_sol,
     stake_history::StakeHistoryEntry,
 };
 use solana_stake_program::stake_state::{Authorized, Lockup};
@@ -30,14 +26,20 @@ pub enum OutputFormat {
 }
 
 impl OutputFormat {
-    pub fn formatted_string<T>(&self, item: &T) -> String
+    pub fn formatted_print<T>(&self, item: &T)
     where
         T: Serialize + fmt::Display,
     {
         match self {
-            OutputFormat::Display => format!("{}", item),
-            OutputFormat::Json => serde_json::to_string_pretty(item).unwrap(),
-            OutputFormat::JsonCompact => serde_json::to_value(item).unwrap().to_string(),
+            OutputFormat::Display => {
+                println!("{}", item);
+            }
+            OutputFormat::Json => {
+                println!("{}", serde_json::to_string_pretty(item).unwrap());
+            }
+            OutputFormat::JsonCompact => {
+                println!("{}", serde_json::to_value(item).unwrap());
+            }
         }
     }
 }
@@ -187,11 +189,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 }
     }
 }
@@ -482,7 +484,7 @@ impl fmt::Display for CliKeyedStakeState {
 #[serde(rename_all = "camelCase")]
 pub struct CliStakeState {
     pub stake_type: CliStakeType,
-    pub account_balance: u64,
+    pub total_stake: u64,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub delegated_stake: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -497,16 +499,6 @@ pub struct CliStakeState {
     pub lockup: Option<CliLockup>,
     #[serde(skip_serializing)]
     pub use_lamports_unit: bool,
-    #[serde(skip_serializing)]
-    pub current_epoch: Epoch,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub rent_exempt_reserve: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub active_stake: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub activating_stake: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub deactivating_stake: Option<u64>,
 }
 
 impl fmt::Display for CliStakeState {
@@ -532,122 +524,52 @@ impl fmt::Display for CliStakeState {
             Ok(())
         }
 
-        writeln!(
-            f,
-            "Balance: {}",
-            build_balance_message(self.account_balance, self.use_lamports_unit, true)
-        )?;
-
-        if let Some(rent_exempt_reserve) = self.rent_exempt_reserve {
-            writeln!(
-                f,
-                "Rent Exempt Reserve: {}",
-                build_balance_message(rent_exempt_reserve, self.use_lamports_unit, true)
-            )?;
-        }
-
         match self.stake_type {
             CliStakeType::RewardsPool => writeln!(f, "Stake account is a rewards pool")?,
             CliStakeType::Uninitialized => writeln!(f, "Stake account is uninitialized")?,
             CliStakeType::Initialized => {
+                writeln!(
+                    f,
+                    "Total Stake: {}",
+                    build_balance_message(self.total_stake, self.use_lamports_unit, true)
+                )?;
                 writeln!(f, "Stake account is undelegated")?;
                 show_authorized(f, self.authorized.as_ref().unwrap())?;
                 show_lockup(f, self.lockup.as_ref().unwrap())?;
             }
             CliStakeType::Stake => {
-                let show_delegation = {
-                    self.active_stake.is_some()
-                        || self.activating_stake.is_some()
-                        || self.deactivating_stake.is_some()
-                        || self
-                            .deactivation_epoch
-                            .map(|de| de > self.current_epoch)
-                            .unwrap_or(true)
-                };
-                if show_delegation {
-                    let delegated_stake = self.delegated_stake.unwrap();
+                writeln!(
+                    f,
+                    "Total Stake: {}",
+                    build_balance_message(self.total_stake, self.use_lamports_unit, true)
+                )?;
+                writeln!(
+                    f,
+                    "Delegated Stake: {}",
+                    build_balance_message(
+                        self.delegated_stake.unwrap(),
+                        self.use_lamports_unit,
+                        true
+                    )
+                )?;
+                if let Some(delegated_vote_account_address) = &self.delegated_vote_account_address {
                     writeln!(
                         f,
-                        "Delegated Stake: {}",
-                        build_balance_message(delegated_stake, self.use_lamports_unit, true)
+                        "Delegated Vote Account Address: {}",
+                        delegated_vote_account_address
+                    )?;
+                }
+                writeln!(
+                    f,
+                    "Stake activates starting from epoch: {}",
+                    self.activation_epoch.unwrap()
+                )?;
+                if let Some(deactivation_epoch) = self.deactivation_epoch {
+                    writeln!(
+                        f,
+                        "Stake deactivates starting from epoch: {}",
+                        deactivation_epoch
                     )?;
-                    if self
-                        .deactivation_epoch
-                        .map(|d| self.current_epoch <= d)
-                        .unwrap_or(true)
-                    {
-                        let active_stake = self.active_stake.unwrap_or(0);
-                        writeln!(
-                            f,
-                            "Active Stake: {}",
-                            build_balance_message(active_stake, self.use_lamports_unit, true),
-                        )?;
-                        let activating_stake = self.activating_stake.or_else(|| {
-                            if self.active_stake.is_none() {
-                                Some(delegated_stake)
-                            } else {
-                                None
-                            }
-                        });
-                        if let Some(activating_stake) = activating_stake {
-                            writeln!(
-                                f,
-                                "Activating Stake: {}",
-                                build_balance_message(
-                                    activating_stake,
-                                    self.use_lamports_unit,
-                                    true
-                                ),
-                            )?;
-                            writeln!(
-                                f,
-                                "Stake activates starting from epoch: {}",
-                                self.activation_epoch.unwrap()
-                            )?;
-                        }
-                    }
-
-                    if let Some(deactivation_epoch) = self.deactivation_epoch {
-                        if self.current_epoch > deactivation_epoch {
-                            let deactivating_stake = self.deactivating_stake.or(self.active_stake);
-                            if let Some(deactivating_stake) = deactivating_stake {
-                                writeln!(
-                                    f,
-                                    "Inactive Stake: {}",
-                                    build_balance_message(
-                                        delegated_stake - deactivating_stake,
-                                        self.use_lamports_unit,
-                                        true
-                                    ),
-                                )?;
-                                writeln!(
-                                    f,
-                                    "Deactivating Stake: {}",
-                                    build_balance_message(
-                                        deactivating_stake,
-                                        self.use_lamports_unit,
-                                        true
-                                    ),
-                                )?;
-                            }
-                        }
-                        writeln!(
-                            f,
-                            "Stake deactivates starting from epoch: {}",
-                            deactivation_epoch
-                        )?;
-                    }
-                    if let Some(delegated_vote_account_address) =
-                        &self.delegated_vote_account_address
-                    {
-                        writeln!(
-                            f,
-                            "Delegated Vote Account Address: {}",
-                            delegated_vote_account_address
-                        )?;
-                    }
-                } else {
-                    writeln!(f, "Stake account is undelegated")?;
                 }
                 show_authorized(f, self.authorized.as_ref().unwrap())?;
                 show_lockup(f, self.lockup.as_ref().unwrap())?;
@@ -917,172 +839,3 @@ impl From<&Lockout> for CliLockout {
         }
     }
 }
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliBlockTime {
-    pub slot: Slot,
-    pub timestamp: UnixTimestamp,
-}
-
-impl fmt::Display for CliBlockTime {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln_name_value(f, "Block:", &self.slot.to_string())?;
-        writeln_name_value(
-            f,
-            "Date:",
-            &format!(
-                "{} (UnixTimestamp: {})",
-                DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(self.timestamp, 0), Utc)
-                    .to_rfc3339_opts(SecondsFormat::Secs, true),
-                self.timestamp
-            ),
-        )
-    }
-}
-
-#[derive(Serialize, Deserialize, Default)]
-#[serde(rename_all = "camelCase")]
-pub struct CliSignOnlyData {
-    pub blockhash: String,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub signers: Vec<String>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub absent: Vec<String>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub bad_sig: Vec<String>,
-}
-
-impl fmt::Display for CliSignOnlyData {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Blockhash:", &self.blockhash)?;
-        if !self.signers.is_empty() {
-            writeln!(f, "{}", style("Signers (Pubkey=Signature):").bold())?;
-            for signer in self.signers.iter() {
-                writeln!(f, " {}", signer)?;
-            }
-        }
-        if !self.absent.is_empty() {
-            writeln!(f, "{}", style("Absent Signers (Pubkey):").bold())?;
-            for pubkey in self.absent.iter() {
-                writeln!(f, " {}", pubkey)?;
-            }
-        }
-        if !self.bad_sig.is_empty() {
-            writeln!(f, "{}", style("Bad Signatures (Pubkey):").bold())?;
-            for pubkey in self.bad_sig.iter() {
-                writeln!(f, " {}", pubkey)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliSignature {
-    pub signature: String,
-}
-
-impl fmt::Display for CliSignature {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Signature:", &self.signature)?;
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliAccountBalances {
-    pub accounts: Vec<RpcAccountBalance>,
-}
-
-impl fmt::Display for CliAccountBalances {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(
-            f,
-            "{}",
-            style(format!("{:<44}  {}", "Address", "Balance",)).bold()
-        )?;
-        for account in &self.accounts {
-            writeln!(
-                f,
-                "{:<44}  {}",
-                account.address,
-                &format!("{} SOL", lamports_to_sol(account.lamports))
-            )?;
-        }
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliSupply {
-    pub total: u64,
-    pub circulating: u64,
-    pub non_circulating: u64,
-    pub non_circulating_accounts: Vec<String>,
-    #[serde(skip_serializing)]
-    pub print_accounts: bool,
-}
-
-impl From<RpcSupply> for CliSupply {
-    fn from(rpc_supply: RpcSupply) -> Self {
-        Self {
-            total: rpc_supply.total,
-            circulating: rpc_supply.circulating,
-            non_circulating: rpc_supply.non_circulating,
-            non_circulating_accounts: rpc_supply.non_circulating_accounts,
-            print_accounts: false,
-        }
-    }
-}
-
-impl fmt::Display for CliSupply {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln_name_value(f, "Total:", &format!("{} SOL", lamports_to_sol(self.total)))?;
-        writeln_name_value(
-            f,
-            "Circulating:",
-            &format!("{} SOL", lamports_to_sol(self.circulating)),
-        )?;
-        writeln_name_value(
-            f,
-            "Non-Circulating:",
-            &format!("{} SOL", lamports_to_sol(self.non_circulating)),
-        )?;
-        if self.print_accounts {
-            writeln!(f)?;
-            writeln_name_value(f, "Non-Circulating Accounts:", " ")?;
-            for account in &self.non_circulating_accounts {
-                writeln!(f, "  {}", account)?;
-            }
-        }
-        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,38 +1,32 @@
 use crate::{
-    cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
-    cli_output::*,
-    display::{new_spinner_progress_bar, println_name_value},
-    spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
+    cli::{check_account_for_fee, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
+    cli_output::{
+        CliBlockProduction, CliBlockProductionEntry, CliEpochInfo, CliKeyedStakeState,
+        CliSlotStatus, CliStakeVec, CliValidator, CliValidators,
+    },
+    display::println_name_value,
 };
-use clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand};
+use chrono::{DateTime, NaiveDateTime, SecondsFormat, Utc};
+use clap::{value_t, value_t_or_exit, App, Arg, ArgMatches, SubCommand};
 use console::{style, Emoji};
-use solana_clap_utils::{
-    commitment::{commitment_arg, COMMITMENT_ARG},
-    input_parsers::*,
-    input_validators::*,
-    keypair::signer_from_path,
-};
+use indicatif::{ProgressBar, ProgressStyle};
+use solana_clap_utils::{input_parsers::*, input_validators::*, keypair::signer_from_path};
 use solana_client::{
     pubsub_client::{PubsubClient, SlotInfoMessage},
     rpc_client::RpcClient,
-    rpc_config::{RpcLargestAccountsConfig, RpcLargestAccountsFilter},
-    rpc_request::MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS_SLOT_RANGE,
 };
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
     account_utils::StateMut,
-    clock::{self, Clock, Slot},
+    clock::{self, Slot},
     commitment_config::CommitmentConfig,
     epoch_schedule::Epoch,
+    hash::Hash,
     message::Message,
     native_token::lamports_to_sol,
-    pubkey::{self, Pubkey},
-    system_instruction, system_program,
-    sysvar::{
-        self,
-        stake_history::{self, StakeHistory},
-        Sysvar,
-    },
+    pubkey::Pubkey,
+    signature::{Keypair, Signer},
+    system_instruction,
     transaction::Transaction,
 };
 use std::{
@@ -59,11 +53,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")
@@ -73,17 +69,20 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                         .validator(is_url)
                         .help("JSON RPC URL for validator, which is useful for validators with a private RPC service")
                 )
+                .arg(
+                    Arg::with_name("confirmed")
+                        .long("confirmed")
+                        .takes_value(false)
+                        .help(
+                            "Return information at maximum-lockout commitment level",
+                        ),
+                )
                 .arg(
                     Arg::with_name("follow")
                         .long("follow")
                         .takes_value(false)
                         .help("Continue reporting progress even after the validator has caught up"),
-                )
-                .arg(commitment_arg()),
-        )
-        .subcommand(
-            SubCommand::with_name("cluster-date")
-                .about("Get current cluster date, computed from genesis creation time and network time")
+                ),
         )
         .subcommand(
             SubCommand::with_name("cluster-version")
@@ -98,6 +97,7 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                     .index(1)
                     .takes_value(true)
                     .value_name("SLOT")
+                    .required(true)
                     .help("Slot number of the block to query")
             )
         )
@@ -106,7 +106,14 @@ impl ClusterQuerySubCommands for App<'_, '_> {
             SubCommand::with_name("epoch-info")
             .about("Get information about the current epoch")
             .alias("get-epoch-info")
-            .arg(commitment_arg()),
+            .arg(
+                Arg::with_name("confirmed")
+                    .long("confirmed")
+                    .takes_value(false)
+                    .help(
+                        "Return information at maximum-lockout commitment level",
+                    ),
+            ),
         )
         .subcommand(
             SubCommand::with_name("genesis-hash")
@@ -116,48 +123,48 @@ impl ClusterQuerySubCommands for App<'_, '_> {
         .subcommand(
             SubCommand::with_name("slot").about("Get current slot")
             .alias("get-slot")
-            .arg(commitment_arg()),
+            .arg(
+                Arg::with_name("confirmed")
+                    .long("confirmed")
+                    .takes_value(false)
+                    .help(
+                        "Return slot at maximum-lockout commitment level",
+                    ),
+            ),
         )
         .subcommand(
             SubCommand::with_name("epoch").about("Get current epoch")
-            .arg(commitment_arg()),
-        )
-        .subcommand(
-            SubCommand::with_name("largest-accounts").about("Get addresses of largest cluster accounts")
             .arg(
-                Arg::with_name("circulating")
-                    .long("circulating")
+                Arg::with_name("confirmed")
+                    .long("confirmed")
                     .takes_value(false)
-                    .help("Filter address list to only circulating accounts")
-            )
-            .arg(
-                Arg::with_name("non_circulating")
-                    .long("non-circulating")
-                    .takes_value(false)
-                    .conflicts_with("circulating")
-                    .help("Filter address list to only non-circulating accounts")
-            )
-            .arg(commitment_arg()),
-        )
-        .subcommand(
-            SubCommand::with_name("supply").about("Get information about the cluster supply of SOL")
-            .arg(
-                Arg::with_name("print_accounts")
-                    .long("print-accounts")
-                    .takes_value(false)
-                    .help("Print list of non-circualting account addresses")
-            )
-            .arg(commitment_arg()),
+                    .help(
+                        "Return epoch at maximum-lockout commitment level",
+                    ),
+            ),
         )
         .subcommand(
             SubCommand::with_name("total-supply").about("Get total number of SOL")
-            .setting(AppSettings::Hidden)
-            .arg(commitment_arg()),
+            .arg(
+                Arg::with_name("confirmed")
+                    .long("confirmed")
+                    .takes_value(false)
+                    .help(
+                        "Return count at maximum-lockout commitment level",
+                    ),
+            ),
         )
         .subcommand(
             SubCommand::with_name("transaction-count").about("Get current transaction count")
             .alias("get-transaction-count")
-            .arg(commitment_arg()),
+            .arg(
+                Arg::with_name("confirmed")
+                    .long("confirmed")
+                    .takes_value(false)
+                    .help(
+                        "Return count at maximum-lockout commitment level",
+                    ),
+            ),
         )
         .subcommand(
             SubCommand::with_name("ping")
@@ -197,7 +204,14 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                         .default_value("15")
                         .help("Wait up to timeout seconds for transaction confirmation"),
                 )
-                .arg(commitment_arg()),
+                .arg(
+                    Arg::with_name("confirmed")
+                        .long("confirmed")
+                        .takes_value(false)
+                        .help(
+                            "Wait until the transaction is confirmed at maximum-lockout commitment level",
+                        ),
+                ),
         )
         .subcommand(
             SubCommand::with_name("live-slots")
@@ -229,11 +243,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")
@@ -246,45 +262,19 @@ impl ClusterQuerySubCommands for App<'_, '_> {
             SubCommand::with_name("validators")
                 .about("Show summary information about the current validators")
                 .alias("show-validators")
+                .arg(
+                    Arg::with_name("confirmed")
+                        .long("confirmed")
+                        .takes_value(false)
+                        .help(
+                            "Return information at maximum-lockout commitment level",
+                        ),
+                )
                 .arg(
                     Arg::with_name("lamports")
                         .long("lamports")
                         .takes_value(false)
                         .help("Display balance in lamports instead of SOL"),
-                )
-                .arg(commitment_arg()),
-        )
-        .subcommand(
-            SubCommand::with_name("transaction-history")
-                .about("Show historical transactions affecting the given address, \
-                       ordered based on the slot in which they were confirmed in \
-                       from lowest to highest slot")
-                .arg(
-                    pubkey!(Arg::with_name("address")
-                        .index(1)
-                        .value_name("ADDRESS")
-                        .required(true),
-                        "Account address"),
-                )
-                .arg(
-                    Arg::with_name("end_slot")
-                        .takes_value(false)
-                        .value_name("SLOT")
-                        .index(2)
-                        .validator(is_slot)
-                        .help(
-                            "Slot to start from [default: latest slot at maximum commitment]"
-                        ),
-                )
-                .arg(
-                    Arg::with_name("limit")
-                        .long("limit")
-                        .takes_value(true)
-                        .value_name("NUMBER OF SLOTS")
-                        .validator(is_slot)
-                        .help(
-                            "Limit the search to this many slots"
-                        ),
                 ),
         )
     }
@@ -292,11 +282,15 @@ impl ClusterQuerySubCommands for App<'_, '_> {
 
 pub fn parse_catchup(
     matches: &ArgMatches<'_>,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let node_pubkey = pubkey_of_signer(matches, "node_pubkey", wallet_manager)?.unwrap();
     let node_json_rpc_url = value_t!(matches, "node_json_rpc_url", String).ok();
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+    let commitment_config = if matches.is_present("confirmed") {
+        CommitmentConfig::default()
+    } else {
+        CommitmentConfig::recent()
+    };
     let follow = matches.is_present("follow");
     Ok(CliCommandInfo {
         command: CliCommand::Catchup {
@@ -312,7 +306,7 @@ pub fn parse_catchup(
 pub fn parse_cluster_ping(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let lamports = value_t_or_exit!(matches, "lamports", u64);
     let interval = Duration::from_secs(value_t_or_exit!(matches, "interval", u64));
@@ -322,7 +316,11 @@ pub fn parse_cluster_ping(
         None
     };
     let timeout = Duration::from_secs(value_t_or_exit!(matches, "timeout", u64));
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+    let commitment_config = if matches.is_present("confirmed") {
+        CommitmentConfig::default()
+    } else {
+        CommitmentConfig::recent()
+    };
     Ok(CliCommandInfo {
         command: CliCommand::Ping {
             lamports,
@@ -341,7 +339,7 @@ pub fn parse_cluster_ping(
 }
 
 pub fn parse_get_block_time(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let slot = value_of(matches, "slot");
+    let slot = value_t_or_exit!(matches, "slot", u64);
     Ok(CliCommandInfo {
         command: CliCommand::GetBlockTime { slot },
         signers: vec![],
@@ -349,7 +347,11 @@ pub fn parse_get_block_time(matches: &ArgMatches<'_>) -> Result<CliCommandInfo,
 }
 
 pub fn parse_get_epoch_info(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+    let commitment_config = if matches.is_present("confirmed") {
+        CommitmentConfig::default()
+    } else {
+        CommitmentConfig::recent()
+    };
     Ok(CliCommandInfo {
         command: CliCommand::GetEpochInfo { commitment_config },
         signers: vec![],
@@ -357,7 +359,11 @@ pub fn parse_get_epoch_info(matches: &ArgMatches<'_>) -> Result<CliCommandInfo,
 }
 
 pub fn parse_get_slot(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+    let commitment_config = if matches.is_present("confirmed") {
+        CommitmentConfig::default()
+    } else {
+        CommitmentConfig::recent()
+    };
     Ok(CliCommandInfo {
         command: CliCommand::GetSlot { commitment_config },
         signers: vec![],
@@ -365,45 +371,23 @@ pub fn parse_get_slot(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliErr
 }
 
 pub fn parse_get_epoch(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+    let commitment_config = if matches.is_present("confirmed") {
+        CommitmentConfig::default()
+    } else {
+        CommitmentConfig::recent()
+    };
     Ok(CliCommandInfo {
         command: CliCommand::GetEpoch { commitment_config },
         signers: vec![],
     })
 }
 
-pub fn parse_largest_accounts(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
-    let filter = if matches.is_present("circulating") {
-        Some(RpcLargestAccountsFilter::Circulating)
-    } else if matches.is_present("non_circulating") {
-        Some(RpcLargestAccountsFilter::NonCirculating)
-    } else {
-        None
-    };
-    Ok(CliCommandInfo {
-        command: CliCommand::LargestAccounts {
-            commitment_config,
-            filter,
-        },
-        signers: vec![],
-    })
-}
-
-pub fn parse_supply(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
-    let print_accounts = matches.is_present("print_accounts");
-    Ok(CliCommandInfo {
-        command: CliCommand::Supply {
-            commitment_config,
-            print_accounts,
-        },
-        signers: vec![],
-    })
-}
-
 pub fn parse_total_supply(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+    let commitment_config = if matches.is_present("confirmed") {
+        CommitmentConfig::default()
+    } else {
+        CommitmentConfig::recent()
+    };
     Ok(CliCommandInfo {
         command: CliCommand::TotalSupply { commitment_config },
         signers: vec![],
@@ -411,7 +395,11 @@ pub fn parse_total_supply(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, Cl
 }
 
 pub fn parse_get_transaction_count(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+    let commitment_config = if matches.is_present("confirmed") {
+        CommitmentConfig::default()
+    } else {
+        CommitmentConfig::recent()
+    };
     Ok(CliCommandInfo {
         command: CliCommand::GetTransactionCount { commitment_config },
         signers: vec![],
@@ -420,7 +408,7 @@ pub fn parse_get_transaction_count(matches: &ArgMatches<'_>) -> Result<CliComman
 
 pub fn parse_show_stakes(
     matches: &ArgMatches<'_>,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let use_lamports_unit = matches.is_present("lamports");
     let vote_account_pubkeys =
@@ -437,7 +425,11 @@ pub fn parse_show_stakes(
 
 pub fn parse_show_validators(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     let use_lamports_unit = matches.is_present("lamports");
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+    let commitment_config = if matches.is_present("confirmed") {
+        CommitmentConfig::default()
+    } else {
+        CommitmentConfig::recent()
+    };
 
     Ok(CliCommandInfo {
         command: CliCommand::ShowValidators {
@@ -448,22 +440,13 @@ pub fn parse_show_validators(matches: &ArgMatches<'_>) -> Result<CliCommandInfo,
     })
 }
 
-pub fn parse_transaction_history(
-    matches: &ArgMatches<'_>,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> 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();
-
-    Ok(CliCommandInfo {
-        command: CliCommand::TransactionHistory {
-            address,
-            end_slot,
-            slot_limit,
-        },
-        signers: vec![],
-    })
+/// Creates a new process bar for processing that will take an unknown amount of time
+fn new_spinner_progress_bar() -> ProgressBar {
+    let progress_bar = ProgressBar::new(42);
+    progress_bar
+        .set_style(ProgressStyle::default_spinner().template("{spinner:.green} {wide_msg}"));
+    progress_bar.enable_steady_tick(100);
+    progress_bar
 }
 
 pub fn process_catchup(
@@ -530,35 +513,25 @@ pub fn process_catchup(
         }
 
         let slot_distance = rpc_slot as i64 - node_slot as i64;
-        let slots_per_second =
-            (previous_slot_distance - slot_distance) as f64 / f64::from(sleep_interval);
-        let time_remaining = (slot_distance as f64 / slots_per_second).round();
-        let time_remaining = if !time_remaining.is_normal() || time_remaining <= 0.0 {
-            "".to_string()
-        } else {
-            format!(
-                ". Time remaining: {}",
-                humantime::format_duration(Duration::from_secs_f64(time_remaining))
-            )
-        };
-
         progress_bar.set_message(&format!(
-            "{} slots behind (us:{} them:{}){}",
+            "Validator is {} slots away (us:{} them:{}){}",
             slot_distance,
             node_slot,
             rpc_slot,
             if slot_distance == 0 || previous_rpc_slot == std::u64::MAX {
                 "".to_string()
             } else {
+                let slots_per_second =
+                    (previous_slot_distance - slot_distance) as f64 / f64::from(sleep_interval);
+
                 format!(
-                    ", {} at {:.1} slots/second{}",
+                    " and {} at {:.1} slots/second",
                     if slots_per_second < 0.0 {
                         "falling behind"
                     } else {
                         "gaining"
                     },
                     slots_per_second,
-                    time_remaining
                 )
             }
         ));
@@ -569,38 +542,18 @@ pub fn process_catchup(
     }
 }
 
-pub fn process_cluster_date(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
-    let result = rpc_client
-        .get_account_with_commitment(&sysvar::clock::id(), CommitmentConfig::default())?;
-    if let Some(clock_account) = result.value {
-        let clock: Clock = Sysvar::from_account(&clock_account).ok_or_else(|| {
-            CliError::RpcRequestError("Failed to deserialize clock sysvar".to_string())
-        })?;
-        let block_time = CliBlockTime {
-            slot: result.context.slot,
-            timestamp: clock.unix_timestamp,
-        };
-        Ok(config.output_format.formatted_string(&block_time))
-    } else {
-        Err(format!("AccountNotFound: pubkey={}", sysvar::clock::id()).into())
-    }
-}
-
 pub fn process_cluster_version(rpc_client: &RpcClient) -> ProcessResult {
     let remote_version = rpc_client.get_version()?;
     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 {
@@ -638,19 +591,15 @@ pub fn process_leader_schedule(rpc_client: &RpcClient) -> ProcessResult {
     Ok("".to_string())
 }
 
-pub fn process_get_block_time(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    slot: Option<Slot>,
-) -> ProcessResult {
-    let slot = if let Some(slot) = slot {
-        slot
-    } else {
-        rpc_client.get_slot()?
-    };
+pub fn process_get_block_time(rpc_client: &RpcClient, slot: Slot) -> ProcessResult {
     let timestamp = rpc_client.get_block_time(slot)?;
-    let block_time = CliBlockTime { slot, timestamp };
-    Ok(config.output_format.formatted_string(&block_time))
+    let result = format!(
+        "{} (UnixTimestamp: {})",
+        DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(timestamp, 0), Utc)
+            .to_rfc3339_opts(SecondsFormat::Secs, true),
+        timestamp
+    );
+    Ok(result)
 }
 
 pub fn process_get_epoch_info(
@@ -661,7 +610,8 @@ pub fn process_get_epoch_info(
     let epoch_info: CliEpochInfo = rpc_client
         .get_epoch_info_with_commitment(commitment_config.clone())?
         .into();
-    Ok(config.output_format.formatted_string(&epoch_info))
+    config.output_format.formatted_print(&epoch_info);
+    Ok("".to_string())
 }
 
 pub fn process_get_genesis_hash(rpc_client: &RpcClient) -> ProcessResult {
@@ -702,7 +652,7 @@ pub fn process_show_block_production(
     slot_limit: Option<u64>,
 ) -> ProcessResult {
     let epoch_schedule = rpc_client.get_epoch_schedule()?;
-    let epoch_info = rpc_client.get_epoch_info_with_commitment(CommitmentConfig::root())?;
+    let epoch_info = rpc_client.get_epoch_info_with_commitment(CommitmentConfig::max())?;
 
     let epoch = epoch.unwrap_or(epoch_info.epoch);
     if epoch > epoch_info.epoch {
@@ -761,7 +711,7 @@ pub fn process_show_block_production(
 
     progress_bar.set_message(&format!("Fetching leader schedule for epoch {}...", epoch));
     let leader_schedule = rpc_client
-        .get_leader_schedule_with_commitment(Some(start_slot), CommitmentConfig::root())?;
+        .get_leader_schedule_with_commitment(Some(start_slot), CommitmentConfig::max())?;
     if leader_schedule.is_none() {
         return Err(format!("Unable to fetch leader schedule for slot {}", start_slot).into());
     }
@@ -843,35 +793,8 @@ pub fn process_show_block_production(
         individual_slot_status,
         verbose: config.verbose,
     };
-    Ok(config.output_format.formatted_string(&block_production))
-}
-
-pub fn process_largest_accounts(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    commitment_config: CommitmentConfig,
-    filter: Option<RpcLargestAccountsFilter>,
-) -> ProcessResult {
-    let accounts = rpc_client
-        .get_largest_accounts_with_config(RpcLargestAccountsConfig {
-            commitment: Some(commitment_config),
-            filter,
-        })?
-        .value;
-    let largest_accounts = CliAccountBalances { accounts };
-    Ok(config.output_format.formatted_string(&largest_accounts))
-}
-
-pub fn process_supply(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    commitment_config: CommitmentConfig,
-    print_accounts: bool,
-) -> ProcessResult {
-    let supply_response = rpc_client.supply_with_commitment(commitment_config.clone())?;
-    let mut supply: CliSupply = supply_response.value.into();
-    supply.print_accounts = print_accounts;
-    Ok(config.output_format.formatted_string(&supply))
+    config.output_format.formatted_print(&block_production);
+    Ok("".to_string())
 }
 
 pub fn process_total_supply(
@@ -900,7 +823,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();
@@ -909,46 +835,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 {
@@ -1178,13 +1085,8 @@ pub fn process_show_stakes(
     let progress_bar = new_spinner_progress_bar();
     progress_bar.set_message("Fetching stake accounts...");
     let all_stake_accounts = rpc_client.get_program_accounts(&solana_stake_program::id())?;
-    let stake_history_account = rpc_client.get_account(&stake_history::id())?;
     progress_bar.finish_and_clear();
 
-    let stake_history = StakeHistory::from_account(&stake_history_account).ok_or_else(|| {
-        CliError::RpcRequestError("Failed to deserialize stake history".to_string())
-    })?;
-
     let mut stake_accounts: Vec<CliKeyedStakeState> = vec![];
     for (stake_pubkey, stake_account) in all_stake_accounts {
         if let Ok(stake_state) = stake_account.state() {
@@ -1197,7 +1099,6 @@ pub fn process_show_stakes(
                                 stake_account.lamports,
                                 &stake_state,
                                 use_lamports_unit,
-                                &stake_history,
                             ),
                         });
                     }
@@ -1214,7 +1115,6 @@ pub fn process_show_stakes(
                                 stake_account.lamports,
                                 &stake_state,
                                 use_lamports_unit,
-                                &stake_history,
                             ),
                         });
                     }
@@ -1223,9 +1123,10 @@ pub fn process_show_stakes(
             }
         }
     }
-    Ok(config
+    config
         .output_format
-        .formatted_string(&CliStakeVec::new(stake_accounts)))
+        .formatted_print(&CliStakeVec::new(stake_accounts));
+    Ok("".to_string())
 }
 
 pub fn process_show_validators(
@@ -1240,14 +1141,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;
@@ -1271,46 +1170,8 @@ pub fn process_show_validators(
         delinquent_validators,
         use_lamports_unit,
     };
-    Ok(config.output_format.formatted_string(&cli_validators))
-}
-
-pub fn process_transaction_history(
-    rpc_client: &RpcClient,
-    address: &Pubkey,
-    end_slot: Option<Slot>, // None == use latest slot
-    slot_limit: Option<u64>,
-) -> ProcessResult {
-    let end_slot = {
-        if let Some(end_slot) = end_slot {
-            end_slot
-        } else {
-            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()?,
-    };
-
-    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;
-    }
-    Ok(format!("{} transactions found", transaction_count))
+    config.output_format.formatted_print(&cli_validators);
+    Ok("".to_string())
 }
 
 #[cfg(test)]
@@ -1332,22 +1193,11 @@ mod tests {
         let (default_keypair_file, mut tmp_file) = make_tmp_file();
         write_keypair(&default_keypair, tmp_file.as_file_mut()).unwrap();
 
-        let test_cluster_version = test_commands
-            .clone()
-            .get_matches_from(vec!["test", "cluster-date"]);
-        assert_eq!(
-            parse_command(&test_cluster_version, &default_keypair_file, &mut None).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::ClusterDate,
-                signers: vec![],
-            }
-        );
-
         let test_cluster_version = test_commands
             .clone()
             .get_matches_from(vec!["test", "cluster-version"]);
         assert_eq!(
-            parse_command(&test_cluster_version, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_cluster_version, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::ClusterVersion,
                 signers: vec![],
@@ -1356,7 +1206,7 @@ mod tests {
 
         let test_fees = test_commands.clone().get_matches_from(vec!["test", "fees"]);
         assert_eq!(
-            parse_command(&test_fees, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_fees, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Fees,
                 signers: vec![],
@@ -1369,9 +1219,9 @@ mod tests {
                 .clone()
                 .get_matches_from(vec!["test", "block-time", &slot.to_string()]);
         assert_eq!(
-            parse_command(&test_get_block_time, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_get_block_time, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
-                command: CliCommand::GetBlockTime { slot: Some(slot) },
+                command: CliCommand::GetBlockTime { slot },
                 signers: vec![],
             }
         );
@@ -1380,7 +1230,7 @@ mod tests {
             .clone()
             .get_matches_from(vec!["test", "epoch-info"]);
         assert_eq!(
-            parse_command(&test_get_epoch_info, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_get_epoch_info, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::GetEpochInfo {
                     commitment_config: CommitmentConfig::recent(),
@@ -1393,7 +1243,7 @@ mod tests {
             .clone()
             .get_matches_from(vec!["test", "genesis-hash"]);
         assert_eq!(
-            parse_command(&test_get_genesis_hash, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_get_genesis_hash, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::GetGenesisHash,
                 signers: vec![],
@@ -1402,7 +1252,7 @@ mod tests {
 
         let test_get_slot = test_commands.clone().get_matches_from(vec!["test", "slot"]);
         assert_eq!(
-            parse_command(&test_get_slot, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_get_slot, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::GetSlot {
                     commitment_config: CommitmentConfig::recent(),
@@ -1415,7 +1265,7 @@ mod tests {
             .clone()
             .get_matches_from(vec!["test", "epoch"]);
         assert_eq!(
-            parse_command(&test_get_epoch, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_get_epoch, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::GetEpoch {
                     commitment_config: CommitmentConfig::recent(),
@@ -1428,7 +1278,7 @@ mod tests {
             .clone()
             .get_matches_from(vec!["test", "total-supply"]);
         assert_eq!(
-            parse_command(&test_total_supply, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_total_supply, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::TotalSupply {
                     commitment_config: CommitmentConfig::recent(),
@@ -1441,7 +1291,7 @@ mod tests {
             .clone()
             .get_matches_from(vec!["test", "transaction-count"]);
         assert_eq!(
-            parse_command(&test_transaction_count, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_transaction_count, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::GetTransactionCount {
                     commitment_config: CommitmentConfig::recent(),
@@ -1459,18 +1309,17 @@ mod tests {
             "2",
             "-t",
             "3",
-            "--commitment",
-            "max",
+            "--confirmed",
         ]);
         assert_eq!(
-            parse_command(&test_ping, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_ping, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Ping {
                     lamports: 1,
                     interval: Duration::from_secs(1),
                     count: Some(2),
                     timeout: Duration::from_secs(3),
-                    commitment_config: CommitmentConfig::max(),
+                    commitment_config: CommitmentConfig::default(),
                 },
                 signers: vec![default_keypair.into()],
             }

cli/src/display.rs

@@ -1,12 +1,11 @@
 use crate::cli::SettingType;
 use console::style;
-use indicatif::{ProgressBar, ProgressStyle};
 use solana_sdk::{
     hash::Hash, native_token::lamports_to_sol, program_utils::limited_deserialize,
     transaction::Transaction,
 };
 use solana_transaction_status::RpcTransactionStatusMeta;
-use std::{fmt, io};
+use std::fmt;
 
 // Pretty print a "name value"
 pub fn println_name_value(name: &str, value: &str) {
@@ -65,44 +64,33 @@ pub fn println_signers(
     println!();
 }
 
-pub fn write_transaction<W: io::Write>(
-    w: &mut W,
+pub fn println_transaction(
     transaction: &Transaction,
     transaction_status: &Option<RpcTransactionStatusMeta>,
     prefix: &str,
-) -> io::Result<()> {
+) {
     let message = &transaction.message;
-    writeln!(
-        w,
-        "{}Recent Blockhash: {:?}",
-        prefix, message.recent_blockhash
-    )?;
+    println!("{}Recent Blockhash: {:?}", prefix, message.recent_blockhash);
     for (signature_index, signature) in transaction.signatures.iter().enumerate() {
-        writeln!(
-            w,
-            "{}Signature {}: {:?}",
-            prefix, signature_index, signature
-        )?;
+        println!("{}Signature {}: {:?}", prefix, signature_index, signature);
     }
-    writeln!(w, "{}{:?}", prefix, message.header)?;
+    println!("{}{:?}", prefix, message.header);
     for (account_index, account) in message.account_keys.iter().enumerate() {
-        writeln!(w, "{}Account {}: {:?}", prefix, account_index, account)?;
+        println!("{}Account {}: {:?}", prefix, account_index, account);
     }
     for (instruction_index, instruction) in message.instructions.iter().enumerate() {
         let program_pubkey = message.account_keys[instruction.program_id_index as usize];
-        writeln!(w, "{}Instruction {}", prefix, instruction_index)?;
-        writeln!(
-            w,
+        println!("{}Instruction {}", prefix, instruction_index);
+        println!(
             "{}  Program: {} ({})",
             prefix, program_pubkey, instruction.program_id_index
-        )?;
+        );
         for (account_index, account) in instruction.accounts.iter().enumerate() {
             let account_pubkey = message.account_keys[*account as usize];
-            writeln!(
-                w,
+            println!(
                 "{}  Account {}: {} ({})",
                 prefix, account_index, account_pubkey, account
-            )?;
+            );
         }
 
         let mut raw = true;
@@ -111,7 +99,7 @@ pub fn write_transaction<W: io::Write>(
                 solana_vote_program::vote_instruction::VoteInstruction,
             >(&instruction.data)
             {
-                writeln!(w, "{}  {:?}", prefix, vote_instruction)?;
+                println!("{}  {:?}", prefix, vote_instruction);
                 raw = false;
             }
         } else if program_pubkey == solana_stake_program::id() {
@@ -119,7 +107,7 @@ pub fn write_transaction<W: io::Write>(
                 solana_stake_program::stake_instruction::StakeInstruction,
             >(&instruction.data)
             {
-                writeln!(w, "{}  {:?}", prefix, stake_instruction)?;
+                println!("{}  {:?}", prefix, stake_instruction);
                 raw = false;
             }
         } else if program_pubkey == solana_sdk::system_program::id() {
@@ -127,32 +115,26 @@ pub fn write_transaction<W: io::Write>(
                 solana_sdk::system_instruction::SystemInstruction,
             >(&instruction.data)
             {
-                writeln!(w, "{}  {:?}", prefix, system_instruction)?;
+                println!("{}  {:?}", prefix, system_instruction);
                 raw = false;
             }
         }
 
         if raw {
-            writeln!(w, "{}  Data: {:?}", prefix, instruction.data)?;
+            println!("{}  Data: {:?}", prefix, instruction.data);
         }
     }
 
     if let Some(transaction_status) = transaction_status {
-        writeln!(
-            w,
+        println!(
             "{}Status: {}",
             prefix,
             match &transaction_status.status {
                 Ok(_) => "Ok".into(),
                 Err(err) => err.to_string(),
             }
-        )?;
-        writeln!(
-            w,
-            "{}  Fee: {} SOL",
-            prefix,
-            lamports_to_sol(transaction_status.fee)
-        )?;
+        );
+        println!("{}  Fee: {}", prefix, transaction_status.fee);
         assert_eq!(
             transaction_status.pre_balances.len(),
             transaction_status.post_balances.len()
@@ -164,49 +146,23 @@ pub fn write_transaction<W: io::Write>(
             .enumerate()
         {
             if pre == post {
-                writeln!(
-                    w,
+                println!(
                     "{}  Account {} balance: {} SOL",
                     prefix,
                     i,
                     lamports_to_sol(*pre)
-                )?;
+                );
             } else {
-                writeln!(
-                    w,
+                println!(
                     "{}  Account {} balance: {} SOL -> {} SOL",
                     prefix,
                     i,
                     lamports_to_sol(*pre),
                     lamports_to_sol(*post)
-                )?;
+                );
             }
         }
     } else {
-        writeln!(w, "{}Status: Unavailable", prefix)?;
-    }
-
-    Ok(())
-}
-
-pub fn println_transaction(
-    transaction: &Transaction,
-    transaction_status: &Option<RpcTransactionStatusMeta>,
-    prefix: &str,
-) {
-    let mut w = Vec::new();
-    if write_transaction(&mut w, transaction, transaction_status, prefix).is_ok() {
-        if let Ok(s) = String::from_utf8(w) {
-            print!("{}", s);
-        }
+        println!("{}Status: Unavailable", prefix);
     }
 }
-
-/// Creates a new process bar for processing that will take an unknown amount of time
-pub fn new_spinner_progress_bar() -> ProgressBar {
-    let progress_bar = ProgressBar::new(42);
-    progress_bar
-        .set_style(ProgressStyle::default_spinner().template("{spinner:.green} {wide_msg}"));
-    progress_bar.enable_steady_tick(100);
-    progress_bar
-}

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

@@ -2,7 +2,10 @@ use clap::{crate_description, crate_name, AppSettings, Arg, ArgGroup, ArgMatches
 use console::style;
 
 use solana_clap_utils::{
-    input_validators::is_url, keypair::SKIP_SEED_PHRASE_VALIDATION_ARG, DisplayError,
+    input_validators::is_url,
+    keypair::{check_for_usb, SKIP_SEED_PHRASE_VALIDATION_ARG},
+    offline::SIGN_ONLY_ARG,
+    DisplayError,
 };
 use solana_cli::{
     cli::{app, parse_command, process_command, CliCommandInfo, CliConfig, CliSigners},
@@ -10,7 +13,7 @@ use solana_cli::{
     display::{println_name_value, println_name_value_or},
 };
 use solana_cli_config::{Config, CONFIG_FILE};
-use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_remote_wallet::remote_wallet::{maybe_wallet_manager, RemoteWalletManager};
 use std::{error, sync::Arc};
 
 fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error>> {
@@ -102,7 +105,7 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
 
 pub fn parse_args<'a>(
     matches: &ArgMatches<'_>,
-    mut wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<Arc<RemoteWalletManager>>,
 ) -> Result<(CliConfig<'a>, CliSigners), Box<dyn error::Error>> {
     let config = if let Some(config_file) = matches.value_of("config_file") {
         Config::load(config_file).unwrap_or_default()
@@ -125,7 +128,7 @@ pub fn parse_args<'a>(
     );
 
     let CliCommandInfo { command, signers } =
-        parse_command(&matches, &default_signer_path, &mut wallet_manager)?;
+        parse_command(&matches, &default_signer_path, wallet_manager.as_ref())?;
 
     let output_format = matches
         .value_of("output_format")
@@ -156,7 +159,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 +213,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)
@@ -252,17 +254,31 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     )
     .get_matches();
 
-    do_main(&matches).map_err(|err| DisplayError::new_as_boxed(err).into())
+    do_main(&matches, check_for_usb(std::env::args()))
+        .map_err(|err| DisplayError::new_as_boxed(err).into())
 }
 
-fn do_main(matches: &ArgMatches<'_>) -> Result<(), Box<dyn error::Error>> {
+fn do_main(
+    matches: &ArgMatches<'_>,
+    need_wallet_manager: bool,
+) -> Result<(), Box<dyn error::Error>> {
     if parse_settings(&matches)? {
-        let mut wallet_manager = None;
+        let wallet_manager = if need_wallet_manager {
+            maybe_wallet_manager()?
+        } else {
+            None
+        };
 
-        let (mut config, signers) = parse_args(&matches, &mut wallet_manager)?;
+        let (mut config, signers) = parse_args(&matches, wallet_manager)?;
         config.signers = signers.iter().map(|s| s.as_ref()).collect();
         let result = process_command(&config)?;
-        println!("{}", result);
+        let (_, submatches) = matches.subcommand();
+        let sign_only = submatches
+            .map(|m| m.is_present(SIGN_ONLY_ARG.name))
+            .unwrap_or(false);
+        if !sign_only {
+            println!("{}", result);
+        }
     };
     Ok(())
 }

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")
@@ -264,7 +279,7 @@ pub fn data_from_state(state: &State) -> Result<&Data, CliNonceError> {
 pub fn parse_authorize_nonce_account(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
     let new_authority = pubkey_of_signer(matches, "new_authority", wallet_manager)?.unwrap();
@@ -292,12 +307,12 @@ pub fn parse_authorize_nonce_account(
 pub fn parse_nonce_create_account(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     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,
     })
@@ -321,7 +336,7 @@ pub fn parse_nonce_create_account(
 
 pub fn parse_get_nonce(
     matches: &ArgMatches<'_>,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let nonce_account_pubkey =
         pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
@@ -335,7 +350,7 @@ pub fn parse_get_nonce(
 pub fn parse_new_nonce(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
     let (nonce_authority, nonce_authority_pubkey) =
@@ -360,7 +375,7 @@ pub fn parse_new_nonce(
 
 pub fn parse_show_nonce_account(
     matches: &ArgMatches<'_>,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let nonce_account_pubkey =
         pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
@@ -378,7 +393,7 @@ pub fn parse_show_nonce_account(
 pub fn parse_withdraw_from_nonce_account(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
     let destination_account_pubkey =
@@ -447,8 +462,8 @@ pub fn process_authorize_nonce_account(
         &fee_calculator,
         &tx.message,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<NonceError>(result, &config)
+    let result = rpc_client.send_and_confirm_transaction_with_spinner(&mut tx, &config.signers);
+    log_instruction_custom_error::<NonceError>(result)
 }
 
 pub fn process_create_nonce_account(
@@ -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,10 +507,40 @@ 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)?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<SystemError>(result, &config)
+
+    check_account_for_fee(
+        rpc_client,
+        &config.signers[0].pubkey(),
+        &fee_calculator,
+        &tx.message,
+    )?;
+    let result = rpc_client.send_and_confirm_transaction_with_spinner(&mut tx, &config.signers);
+    log_instruction_custom_error::<SystemError>(result)
 }
 
 pub fn process_get_nonce(rpc_client: &RpcClient, nonce_account_pubkey: &Pubkey) -> ProcessResult {
@@ -569,8 +580,9 @@ pub fn process_new_nonce(
         &fee_calculator,
         &tx.message,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<SystemError>(result, &config)
+    let result = rpc_client
+        .send_and_confirm_transaction_with_spinner(&mut tx, &[config.signers[0], nonce_authority]);
+    log_instruction_custom_error::<SystemError>(result)
 }
 
 pub fn process_show_nonce_account(
@@ -594,7 +606,8 @@ pub fn process_show_nonce_account(
             nonce_account.authority = Some(data.authority.to_string());
         }
 
-        Ok(config.output_format.formatted_string(&nonce_account))
+        config.output_format.formatted_print(&nonce_account);
+        Ok("".to_string())
     };
     match state_from_account(&nonce_account)? {
         State::Uninitialized => print_account(None),
@@ -628,8 +641,8 @@ pub fn process_withdraw_from_nonce_account(
         &fee_calculator,
         &tx.message,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<NonceError>(result, &config)
+    let result = rpc_client.send_and_confirm_transaction_with_spinner(&mut tx, &config.signers);
+    log_instruction_custom_error::<NonceError>(result)
 }
 
 #[cfg(test)]
@@ -675,12 +688,7 @@ mod tests {
             &Pubkey::default().to_string(),
         ]);
         assert_eq!(
-            parse_command(
-                &test_authorize_nonce_account,
-                &default_keypair_file,
-                &mut None
-            )
-            .unwrap(),
+            parse_command(&test_authorize_nonce_account, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::AuthorizeNonceAccount {
                     nonce_account: nonce_account_pubkey,
@@ -701,12 +709,7 @@ mod tests {
             &authority_keypair_file,
         ]);
         assert_eq!(
-            parse_command(
-                &test_authorize_nonce_account,
-                &default_keypair_file,
-                &mut None
-            )
-            .unwrap(),
+            parse_command(&test_authorize_nonce_account, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::AuthorizeNonceAccount {
                     nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
@@ -728,13 +731,13 @@ mod tests {
             "50",
         ]);
         assert_eq!(
-            parse_command(&test_create_nonce_account, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_create_nonce_account, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateNonceAccount {
                     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(),
@@ -753,13 +756,13 @@ mod tests {
             &authority_keypair_file,
         ]);
         assert_eq!(
-            parse_command(&test_create_nonce_account, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_create_nonce_account, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateNonceAccount {
                     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(),
@@ -775,7 +778,7 @@ mod tests {
             &nonce_account_string,
         ]);
         assert_eq!(
-            parse_command(&test_get_nonce, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_get_nonce, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::GetNonce(nonce_account_keypair.pubkey()),
                 signers: vec![],
@@ -789,7 +792,7 @@ mod tests {
                 .get_matches_from(vec!["test", "new-nonce", &keypair_file]);
         let nonce_account = read_keypair_file(&keypair_file).unwrap();
         assert_eq!(
-            parse_command(&test_new_nonce, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_new_nonce, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::NewNonce {
                     nonce_account: nonce_account.pubkey(),
@@ -809,7 +812,7 @@ mod tests {
         ]);
         let nonce_account = read_keypair_file(&keypair_file).unwrap();
         assert_eq!(
-            parse_command(&test_new_nonce, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_new_nonce, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::NewNonce {
                     nonce_account: nonce_account.pubkey(),
@@ -829,7 +832,7 @@ mod tests {
             &nonce_account_string,
         ]);
         assert_eq!(
-            parse_command(&test_show_nonce_account, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_show_nonce_account, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::ShowNonceAccount {
                     nonce_account_pubkey: nonce_account_keypair.pubkey(),
@@ -851,7 +854,7 @@ mod tests {
             parse_command(
                 &test_withdraw_from_nonce_account,
                 &default_keypair_file,
-                &mut None
+                None
             )
             .unwrap(),
             CliCommandInfo {
@@ -879,7 +882,7 @@ mod tests {
             parse_command(
                 &test_withdraw_from_nonce_account,
                 &default_keypair_file,
-                &mut None
+                None
             )
             .unwrap(),
             CliCommandInfo {
@@ -910,18 +913,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 +930,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 +941,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/offline/mod.rs

@@ -79,47 +79,32 @@ pub fn parse_sign_only_reply_string(reply: &str) -> SignOnly {
     let object: Value = serde_json::from_str(&reply).unwrap();
     let blockhash_str = object.get("blockhash").unwrap().as_str().unwrap();
     let blockhash = blockhash_str.parse::<Hash>().unwrap();
-    let mut present_signers: Vec<(Pubkey, Signature)> = Vec::new();
-    let signer_strings = object.get("signers");
-    if let Some(sig_strings) = signer_strings {
-        present_signers = sig_strings
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|signer_string| {
-                let mut signer = signer_string.as_str().unwrap().split('=');
-                let key = Pubkey::from_str(signer.next().unwrap()).unwrap();
-                let sig = Signature::from_str(signer.next().unwrap()).unwrap();
-                (key, sig)
-            })
-            .collect();
-    }
-    let mut absent_signers: Vec<Pubkey> = Vec::new();
-    let signer_strings = object.get("absent");
-    if let Some(sig_strings) = signer_strings {
-        absent_signers = sig_strings
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|val| {
-                let s = val.as_str().unwrap();
-                Pubkey::from_str(s).unwrap()
-            })
-            .collect();
-    }
-    let mut bad_signers: Vec<Pubkey> = Vec::new();
-    let signer_strings = object.get("badSig");
-    if let Some(sig_strings) = signer_strings {
-        bad_signers = sig_strings
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|val| {
-                let s = val.as_str().unwrap();
-                Pubkey::from_str(s).unwrap()
-            })
-            .collect();
-    }
+    let signer_strings = object.get("signers").unwrap().as_array().unwrap();
+    let present_signers = signer_strings
+        .iter()
+        .map(|signer_string| {
+            let mut signer = signer_string.as_str().unwrap().split('=');
+            let key = Pubkey::from_str(signer.next().unwrap()).unwrap();
+            let sig = Signature::from_str(signer.next().unwrap()).unwrap();
+            (key, sig)
+        })
+        .collect();
+    let signer_strings = object.get("absent").unwrap().as_array().unwrap();
+    let absent_signers = signer_strings
+        .iter()
+        .map(|val| {
+            let s = val.as_str().unwrap();
+            Pubkey::from_str(s).unwrap()
+        })
+        .collect();
+    let signer_strings = object.get("badSig").unwrap().as_array().unwrap();
+    let bad_signers = signer_strings
+        .iter()
+        .map(|val| {
+            let s = val.as_str().unwrap();
+            Pubkey::from_str(s).unwrap()
+        })
+        .collect();
     SignOnly {
         blockhash,
         present_signers,

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/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: 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: 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: 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: 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(&mut tx, &config.signers);
+    log_instruction_custom_error::<SystemError>(result)
+}
+
+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(&mut tx, &signers)?;
+    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,
+                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,
+                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, 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};
@@ -229,7 +228,7 @@ impl ValidatorInfoSubCommands for App<'_, '_> {
 pub fn parse_validator_info_command(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let info_pubkey = pubkey_of(matches, "info_pubkey");
     // Prepare validator info
@@ -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,60 +319,55 @@ 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)?;
-    let signature_str = rpc_client.send_and_confirm_transaction_with_spinner(&tx)?;
+    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(&mut tx, &signers)?;
 
     println!("Success! Validator info published at: {:?}", info_pubkey);
     println!("{}", signature_str);
@@ -418,9 +410,10 @@ pub fn process_get_validator_info(
             info: validator_info,
         });
     }
-    Ok(config
+    config
         .output_format
-        .formatted_string(&CliValidatorInfoVec::new(validator_info_list)))
+        .formatted_print(&CliValidatorInfoVec::new(validator_info_list));
+    Ok("".to_string())
 }
 
 #[cfg(test)]
@@ -508,7 +501,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 +540,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,18 +1,13 @@
 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::{
-    commitment::{commitment_arg, COMMITMENT_ARG},
-    input_parsers::*,
-    input_validators::*,
-};
+use solana_clap_utils::{input_parsers::*, input_validators::*};
 use solana_client::rpc_client::RpcClient;
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
@@ -61,16 +56,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 +83,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 +97,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 +127,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")
@@ -161,70 +170,54 @@ impl VoteSubCommands for App<'_, '_> {
                         .help("Authorized withdrawer keypair"),
                 )
         )
-        .subcommand(
-            SubCommand::with_name("vote-update-commission")
-                .about("Update the vote account's commission")
-                .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
-                        .index(1)
-                        .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account to update. "),
-                )
-                .arg(
-                    Arg::with_name("commission")
-                        .index(2)
-                        .value_name("PERCENTAGE")
-                        .takes_value(true)
-                        .required(true)
-                        .validator(is_valid_percentage)
-                        .help("The new commission")
-                )
-                .arg(
-                    Arg::with_name("authorized_withdrawer")
-                        .index(3)
-                        .value_name("AUTHORIZED_KEYPAIR")
-                        .takes_value(true)
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("Authorized withdrawer keypair"),
-                )
-        )
         .subcommand(
             SubCommand::with_name("vote-account")
                 .about("Show the contents of a vote account")
                 .alias("show-vote-account")
                 .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
+                    Arg::with_name("confirmed")
+                        .long("confirmed")
+                        .takes_value(false)
+                        .help(
+                            "Return information at maximum-lockout commitment level",
+                        ),
+                )
+                .arg(
+                    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")
                         .long("lamports")
                         .takes_value(false)
                         .help("Display balance in lamports instead of SOL"),
-                )
-                .arg(commitment_arg()),
+                ),
         )
         .subcommand(
             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")
@@ -250,7 +243,7 @@ impl VoteSubCommands for App<'_, '_> {
 pub fn parse_create_vote_account(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let (vote_account, _) = signer_of(matches, "vote_account", wallet_manager)?;
     let seed = matches.value_of("seed").map(|s| s.to_string());
@@ -283,7 +276,7 @@ pub fn parse_create_vote_account(
 pub fn parse_vote_authorize(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
     vote_authorize: VoteAuthorize,
 ) -> Result<CliCommandInfo, CliError> {
     let vote_account_pubkey =
@@ -313,7 +306,7 @@ pub fn parse_vote_authorize(
 pub fn parse_vote_update_validator(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let vote_account_pubkey =
         pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
@@ -338,41 +331,18 @@ pub fn parse_vote_update_validator(
     })
 }
 
-pub fn parse_vote_update_commission(
-    matches: &ArgMatches<'_>,
-    default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    let vote_account_pubkey =
-        pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
-    let (authorized_withdrawer, _) = signer_of(matches, "authorized_withdrawer", wallet_manager)?;
-    let commission = value_t_or_exit!(matches, "commission", u8);
-
-    let payer_provided = None;
-    let signer_info = generate_unique_signers(
-        vec![payer_provided, authorized_withdrawer],
-        matches,
-        default_signer_path,
-        wallet_manager,
-    )?;
-
-    Ok(CliCommandInfo {
-        command: CliCommand::VoteUpdateCommission {
-            vote_account_pubkey,
-            commission,
-        },
-        signers: signer_info.signers,
-    })
-}
-
 pub fn parse_vote_get_account_command(
     matches: &ArgMatches<'_>,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let vote_account_pubkey =
         pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
     let use_lamports_unit = matches.is_present("lamports");
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+    let commitment_config = if matches.is_present("confirmed") {
+        CommitmentConfig::default()
+    } else {
+        CommitmentConfig::recent()
+    };
     Ok(CliCommandInfo {
         command: CliCommand::ShowVoteAccount {
             pubkey: vote_account_pubkey,
@@ -386,7 +356,7 @@ pub fn parse_vote_get_account_command(
 pub fn parse_withdraw_from_vote_account(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let vote_account_pubkey =
         pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
@@ -443,39 +413,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)
@@ -488,20 +425,47 @@ 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)?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<SystemError>(result, &config)
+    check_account_for_fee(
+        rpc_client,
+        &config.signers[0].pubkey(),
+        &fee_calculator,
+        &tx.message,
+    )?;
+    let result = rpc_client.send_and_confirm_transaction_with_spinner(&mut tx, &config.signers);
+    log_instruction_custom_error::<SystemError>(result)
 }
 
 pub fn process_vote_authorize(
@@ -540,8 +504,9 @@ pub fn process_vote_authorize(
         &fee_calculator,
         &tx.message,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<VoteError>(result, &config)
+    let result =
+        rpc_client.send_and_confirm_transaction_with_spinner(&mut tx, &[config.signers[0]]);
+    log_instruction_custom_error::<VoteError>(result)
 }
 
 pub fn process_vote_update_validator(
@@ -573,35 +538,8 @@ pub fn process_vote_update_validator(
         &fee_calculator,
         &tx.message,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<VoteError>(result, &config)
-}
-
-pub fn process_vote_update_commission(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    vote_account_pubkey: &Pubkey,
-    commission: u8,
-) -> ProcessResult {
-    let authorized_withdrawer = config.signers[1];
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
-    let ixs = vec![vote_instruction::update_commission(
-        vote_account_pubkey,
-        &authorized_withdrawer.pubkey(),
-        commission,
-    )];
-
-    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::<VoteError>(result, &config)
+    let result = rpc_client.send_and_confirm_transaction_with_spinner(&mut tx, &config.signers);
+    log_instruction_custom_error::<VoteError>(result)
 }
 
 fn get_vote_account(
@@ -675,7 +613,8 @@ pub fn process_show_vote_account(
         use_lamports_unit,
     };
 
-    Ok(config.output_format.formatted_string(&vote_account_data))
+    config.output_format.formatted_print(&vote_account_data);
+    Ok("".to_string())
 }
 
 pub fn process_withdraw_from_vote_account(
@@ -705,8 +644,9 @@ pub fn process_withdraw_from_vote_account(
         &fee_calculator,
         &transaction.message,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&transaction);
-    log_instruction_custom_error::<VoteError>(result, &config)
+    let result =
+        rpc_client.send_and_confirm_transaction_with_spinner(&mut transaction, &config.signers);
+    log_instruction_custom_error::<VoteError>(result)
 }
 
 #[cfg(test)]
@@ -743,7 +683,7 @@ mod tests {
             &pubkey2_string,
         ]);
         assert_eq!(
-            parse_command(&test_authorize_voter, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_authorize_voter, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::VoteAuthorize {
                     vote_account_pubkey: pubkey,
@@ -766,7 +706,7 @@ mod tests {
             &pubkey2_string,
         ]);
         assert_eq!(
-            parse_command(&test_authorize_voter, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_authorize_voter, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::VoteAuthorize {
                     vote_account_pubkey: pubkey,
@@ -796,7 +736,7 @@ mod tests {
             "10",
         ]);
         assert_eq!(
-            parse_command(&test_create_vote_account, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_create_vote_account, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateVoteAccount {
                     seed: None,
@@ -824,7 +764,7 @@ mod tests {
             &identity_keypair_file,
         ]);
         assert_eq!(
-            parse_command(&test_create_vote_account2, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_create_vote_account2, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateVoteAccount {
                     seed: None,
@@ -856,7 +796,7 @@ mod tests {
             &authed.to_string(),
         ]);
         assert_eq!(
-            parse_command(&test_create_vote_account3, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_create_vote_account3, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateVoteAccount {
                     seed: None,
@@ -886,7 +826,7 @@ mod tests {
             &authed.to_string(),
         ]);
         assert_eq!(
-            parse_command(&test_create_vote_account4, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_create_vote_account4, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateVoteAccount {
                     seed: None,
@@ -911,7 +851,7 @@ mod tests {
             &keypair_file,
         ]);
         assert_eq!(
-            parse_command(&test_update_validator, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_update_validator, &default_keypair_file, None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::VoteUpdateValidator {
                     vote_account_pubkey: pubkey,
@@ -925,27 +865,6 @@ mod tests {
             }
         );
 
-        let test_update_commission = test_commands.clone().get_matches_from(vec![
-            "test",
-            "vote-update-commission",
-            &pubkey_string,
-            "42",
-            &keypair_file,
-        ]);
-        assert_eq!(
-            parse_command(&test_update_commission, &default_keypair_file, &mut None).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::VoteUpdateCommission {
-                    vote_account_pubkey: pubkey,
-                    commission: 42,
-                },
-                signers: vec![
-                    read_keypair_file(&default_keypair_file).unwrap().into(),
-                    Box::new(read_keypair_file(&keypair_file).unwrap()),
-                ],
-            }
-        );
-
         // Test WithdrawFromVoteAccount subcommand
         let test_withdraw_from_vote_account = test_commands.clone().get_matches_from(vec![
             "test",
@@ -958,7 +877,7 @@ mod tests {
             parse_command(
                 &test_withdraw_from_vote_account,
                 &default_keypair_file,
-                &mut None
+                None
             )
             .unwrap(),
             CliCommandInfo {
@@ -989,7 +908,7 @@ mod tests {
             parse_command(
                 &test_withdraw_from_vote_account,
                 &default_keypair_file,
-                &mut None
+                None
             )
             .unwrap(),
             CliCommandInfo {

cli/tests/nonce.rs

@@ -1,16 +1,12 @@
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
-    cli_output::OutputFormat,
     nonce,
     offline::{
         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 +15,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 +39,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 +61,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 +89,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 +96,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();
@@ -93,7 +119,6 @@ fn full_battery_tests(
         &faucet_addr,
         &config_payer.signers[0].pubkey(),
         2000,
-        &config_payer,
     )
     .unwrap();
     check_balance(2000, &rpc_client, &config_payer.signers[0].pubkey());
@@ -127,7 +152,7 @@ fn full_battery_tests(
         nonce_account: 1,
         seed,
         nonce_authority: optional_authority,
-        amount: SpendAmount::Some(1000),
+        lamports: 1000,
     };
 
     process_command(&config_payer).unwrap();
@@ -250,7 +275,6 @@ fn test_create_account_with_seed() {
     let offline_nonce_authority_signer = keypair_from_seed(&[1u8; 32]).unwrap();
     let online_nonce_creator_signer = keypair_from_seed(&[2u8; 32]).unwrap();
     let to_address = Pubkey::new(&[3u8; 32]);
-    let config = CliConfig::default();
 
     // Setup accounts
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
@@ -259,7 +283,6 @@ fn test_create_account_with_seed() {
         &faucet_addr,
         &offline_nonce_authority_signer.pubkey(),
         42,
-        &config,
     )
     .unwrap();
     request_and_confirm_airdrop(
@@ -267,7 +290,6 @@ fn test_create_account_with_seed() {
         &faucet_addr,
         &online_nonce_creator_signer.pubkey(),
         4242,
-        &config,
     )
     .unwrap();
     check_balance(42, &rpc_client, &offline_nonce_authority_signer.pubkey());
@@ -290,7 +312,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 +334,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,
@@ -322,7 +344,6 @@ fn test_create_account_with_seed() {
         nonce_authority: 0,
         fee_payer: 0,
     };
-    authority_config.output_format = OutputFormat::JsonCompact;
     let sign_only_reply = process_command(&authority_config).unwrap();
     let sign_only = parse_sign_only_reply_string(&sign_only_reply);
     let authority_presigner = sign_only.presigner_of(&authority_pubkey).unwrap();
@@ -334,7 +355,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,15 +1,12 @@
 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,
     nonce,
     offline::{
         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 +16,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() {
@@ -59,7 +69,6 @@ fn test_cli_timestamp_tx() {
         &faucet_addr,
         &config_payer.signers[0].pubkey(),
         50,
-        &config_witness,
     )
     .unwrap();
     check_balance(50, &rpc_client, &config_payer.signers[0].pubkey());
@@ -69,7 +78,6 @@ fn test_cli_timestamp_tx() {
         &faucet_addr,
         &config_witness.signers[0].pubkey(),
         1,
-        &config_witness,
     )
     .unwrap();
 
@@ -77,7 +85,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()),
@@ -146,7 +154,6 @@ fn test_cli_witness_tx() {
         &faucet_addr,
         &config_payer.signers[0].pubkey(),
         50,
-        &config_witness,
     )
     .unwrap();
     request_and_confirm_airdrop(
@@ -154,13 +161,12 @@ fn test_cli_witness_tx() {
         &faucet_addr,
         &config_witness.signers[0].pubkey(),
         1,
-        &config_witness,
     )
     .unwrap();
 
     // 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()
@@ -228,13 +234,12 @@ fn test_cli_cancel_tx() {
         &faucet_addr,
         &config_payer.signers[0].pubkey(),
         50,
-        &config_witness,
     )
     .unwrap();
 
     // 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,
@@ -302,7 +307,6 @@ fn test_offline_pay_tx() {
         &faucet_addr,
         &config_offline.signers[0].pubkey(),
         50,
-        &config_offline,
     )
     .unwrap();
 
@@ -311,7 +315,6 @@ fn test_offline_pay_tx() {
         &faucet_addr,
         &config_online.signers[0].pubkey(),
         50,
-        &config_offline,
     )
     .unwrap();
     check_balance(50, &rpc_client, &config_offline.signers[0].pubkey());
@@ -319,13 +322,12 @@ 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,
         ..PayCommand::default()
     });
-    config_offline.output_format = OutputFormat::JsonCompact;
     let sig_response = process_command(&config_offline).unwrap();
 
     check_balance(50, &rpc_client, &config_offline.signers[0].pubkey());
@@ -340,7 +342,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()
@@ -386,7 +388,6 @@ fn test_nonced_pay_tx() {
         &faucet_addr,
         &config.signers[0].pubkey(),
         50 + minimum_nonce_balance,
-        &config,
     )
     .unwrap();
     check_balance(
@@ -401,7 +402,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 +419,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,13 +1,10 @@
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
-    cli_output::OutputFormat,
     nonce,
     offline::{
         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 +19,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() {
@@ -49,7 +59,6 @@ fn test_stake_delegation_force() {
         &faucet_addr,
         &config.signers[0].pubkey(),
         100_000,
-        &config,
     )
     .unwrap();
 
@@ -74,7 +83,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,
@@ -146,7 +155,6 @@ fn test_seed_stake_delegation_and_deactivation() {
         &faucet_addr,
         &config_validator.signers[0].pubkey(),
         100_000,
-        &config_validator,
     )
     .unwrap();
     check_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
@@ -166,7 +174,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,
@@ -237,7 +245,6 @@ fn test_stake_delegation_and_deactivation() {
         &faucet_addr,
         &config_validator.signers[0].pubkey(),
         100_000,
-        &config_validator,
     )
     .unwrap();
     check_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
@@ -250,7 +257,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,
@@ -334,7 +341,6 @@ fn test_offline_stake_delegation_and_deactivation() {
         &faucet_addr,
         &config_validator.signers[0].pubkey(),
         100_000,
-        &config_offline,
     )
     .unwrap();
     check_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
@@ -344,7 +350,6 @@ fn test_offline_stake_delegation_and_deactivation() {
         &faucet_addr,
         &config_offline.signers[0].pubkey(),
         100_000,
-        &config_validator,
     )
     .unwrap();
     check_balance(100_000, &rpc_client, &config_offline.signers[0].pubkey());
@@ -354,10 +359,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,
@@ -380,7 +385,6 @@ fn test_offline_stake_delegation_and_deactivation() {
         nonce_authority: 0,
         fee_payer: 0,
     };
-    config_offline.output_format = OutputFormat::JsonCompact;
     let sig_response = process_command(&config_offline).unwrap();
     let sign_only = parse_sign_only_reply_string(&sig_response);
     assert!(sign_only.has_all_signers());
@@ -466,7 +470,6 @@ fn test_nonced_stake_delegation_and_deactivation() {
         &faucet_addr,
         &config.signers[0].pubkey(),
         100_000,
-        &config,
     )
     .unwrap();
 
@@ -479,7 +482,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 +499,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();
 
@@ -576,7 +579,6 @@ fn test_stake_authorize() {
         &faucet_addr,
         &config.signers[0].pubkey(),
         100_000,
-        &config,
     )
     .unwrap();
 
@@ -594,7 +596,6 @@ fn test_stake_authorize() {
         &faucet_addr,
         &config_offline.signers[0].pubkey(),
         100_000,
-        &config,
     )
     .unwrap();
 
@@ -608,7 +609,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,
@@ -702,7 +703,6 @@ fn test_stake_authorize() {
         nonce_authority: 0,
         fee_payer: 0,
     };
-    config_offline.output_format = OutputFormat::JsonCompact;
     let sign_reply = process_command(&config_offline).unwrap();
     let sign_only = parse_sign_only_reply_string(&sign_reply);
     assert!(sign_only.has_all_signers());
@@ -736,7 +736,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();
 
@@ -841,16 +841,13 @@ fn test_stake_authorize_with_fee_payer() {
     config_offline.command = CliCommand::ClusterVersion;
     process_command(&config_offline).unwrap_err();
 
-    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &default_pubkey, 100_000, &config)
-        .unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &default_pubkey, 100_000).unwrap();
     check_balance(100_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &payer_pubkey, 100_000, &config)
-        .unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &payer_pubkey, 100_000).unwrap();
     check_balance(100_000, &rpc_client, &payer_pubkey);
 
-    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
-        .unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000).unwrap();
     check_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create stake account, identity is authority
@@ -863,7 +860,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,
@@ -904,7 +901,6 @@ fn test_stake_authorize_with_fee_payer() {
         nonce_authority: 0,
         fee_payer: 0,
     };
-    config_offline.output_format = OutputFormat::JsonCompact;
     let sign_reply = process_command(&config_offline).unwrap();
     let sign_only = parse_sign_only_reply_string(&sign_reply);
     assert!(sign_only.has_all_signers());
@@ -970,13 +966,11 @@ fn test_stake_split() {
         &faucet_addr,
         &config.signers[0].pubkey(),
         500_000,
-        &config,
     )
     .unwrap();
     check_balance(500_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
-        .unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000).unwrap();
     check_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create stake account, identity is authority
@@ -992,7 +986,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 +1011,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 +1027,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),
@@ -1044,14 +1038,13 @@ fn test_stake_split() {
         lamports: 2 * minimum_stake_balance,
         fee_payer: 0,
     };
-    config_offline.output_format = OutputFormat::JsonCompact;
     let sig_response = process_command(&config_offline).unwrap();
     let sign_only = parse_sign_only_reply_string(&sig_response);
     assert!(sign_only.has_all_signers());
     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(
@@ -1121,13 +1114,11 @@ fn test_stake_set_lockup() {
         &faucet_addr,
         &config.signers[0].pubkey(),
         500_000,
-        &config,
     )
     .unwrap();
     check_balance(500_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
-        .unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000).unwrap();
     check_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create stake account, identity is authority
@@ -1148,7 +1139,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 +1156,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 +1190,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 +1207,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 +1238,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 +1265,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 +1278,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,
     };
@@ -1301,7 +1292,6 @@ fn test_stake_set_lockup() {
         nonce_authority: 0,
         fee_payer: 0,
     };
-    config_offline.output_format = OutputFormat::JsonCompact;
     let sig_response = process_command(&config_offline).unwrap();
     let sign_only = parse_sign_only_reply_string(&sig_response);
     assert!(sign_only.has_all_signers());
@@ -1374,13 +1364,11 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         &faucet_addr,
         &config.signers[0].pubkey(),
         200_000,
-        &config,
     )
     .unwrap();
     check_balance(200_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
-        .unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000).unwrap();
     check_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create nonce account
@@ -1394,7 +1382,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 +1402,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),
@@ -1422,7 +1410,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         fee_payer: 0,
         from: 0,
     };
-    config_offline.output_format = OutputFormat::JsonCompact;
     let sig_response = process_command(&config_offline).unwrap();
     let sign_only = parse_sign_only_reply_string(&sig_response);
     assert!(sign_only.has_all_signers());
@@ -1435,7 +1422,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),
@@ -1464,7 +1451,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         destination_account_pubkey: recipient_pubkey,
         lamports: 42,
         withdraw_authority: 0,
-        custodian: None,
         sign_only: true,
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_pubkey),
@@ -1480,7 +1466,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         destination_account_pubkey: recipient_pubkey,
         lamports: 42,
         withdraw_authority: 0,
-        custodian: None,
         sign_only: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_pubkey),
@@ -1508,7 +1493,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 +1509,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,13 +1,10 @@
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
-    cli_output::OutputFormat,
     nonce,
     offline::{
         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 +14,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() {
@@ -49,14 +59,13 @@ fn test_transfer() {
     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();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &sender_pubkey, 50_000).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::Some(10),
+        lamports: 10,
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -70,22 +79,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];
@@ -94,13 +87,13 @@ fn test_transfer() {
     process_command(&offline).unwrap_err();
 
     let offline_pubkey = offline.signers[0].pubkey();
-    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 50, &config).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 50).unwrap();
     check_balance(50, &rpc_client, &offline_pubkey);
 
     // 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,
@@ -110,14 +103,13 @@ fn test_transfer() {
         nonce_authority: 0,
         fee_payer: 0,
     };
-    offline.output_format = OutputFormat::JsonCompact;
     let sign_only_reply = process_command(&offline).unwrap();
     let sign_only = parse_sign_only_reply_string(&sign_only_reply);
     assert!(sign_only.has_all_signers());
     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 +133,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 +147,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 +188,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 +204,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,
@@ -255,24 +247,16 @@ fn test_transfer_multisession_signing() {
     let offline_from_signer = keypair_from_seed(&[2u8; 32]).unwrap();
     let offline_fee_payer_signer = keypair_from_seed(&[3u8; 32]).unwrap();
     let from_null_signer = NullSigner::new(&offline_from_signer.pubkey());
-    let config = CliConfig::default();
 
     // Setup accounts
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
-    request_and_confirm_airdrop(
-        &rpc_client,
-        &faucet_addr,
-        &offline_from_signer.pubkey(),
-        43,
-        &config,
-    )
-    .unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_from_signer.pubkey(), 43)
+        .unwrap();
     request_and_confirm_airdrop(
         &rpc_client,
         &faucet_addr,
         &offline_fee_payer_signer.pubkey(),
         3,
-        &config,
     )
     .unwrap();
     check_balance(43, &rpc_client, &offline_from_signer.pubkey());
@@ -289,7 +273,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,
@@ -299,7 +283,6 @@ fn test_transfer_multisession_signing() {
         nonce_authority: 0,
         fee_payer: 0,
     };
-    fee_payer_config.output_format = OutputFormat::JsonCompact;
     let sign_only_reply = process_command(&fee_payer_config).unwrap();
     let sign_only = parse_sign_only_reply_string(&sign_only_reply);
     assert!(!sign_only.has_all_signers());
@@ -315,7 +298,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,
@@ -325,7 +308,6 @@ fn test_transfer_multisession_signing() {
         nonce_authority: 0,
         fee_payer: 0,
     };
-    from_config.output_format = OutputFormat::JsonCompact;
     let sign_only_reply = process_command(&from_config).unwrap();
     let sign_only = parse_sign_only_reply_string(&sign_only_reply);
     assert!(sign_only.has_all_signers());
@@ -338,7 +320,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 +339,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() {
@@ -36,7 +48,6 @@ fn test_vote_authorize_and_withdraw() {
         &faucet_addr,
         &config.signers[0].pubkey(),
         100_000,
-        &config,
     )
     .unwrap();
 

client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-client"
-version = "1.2.1"
+version = "1.1.4"
 description = "Solana Client"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -10,28 +10,25 @@ 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.1" }
-solana-net-utils = { path = "../net-utils", version = "1.2.1" }
-solana-sdk = { path = "../sdk", version = "1.2.1" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.1" }
+serde_json = "1.0.48"
+solana-transaction-status = { path = "../transaction-status", version = "1.1.4" }
+solana-net-utils = { path = "../net-utils", version = "1.1.4" }
+solana-sdk = { path = "../sdk", version = "1.1.4" }
+solana-vote-program = { path = "../programs/vote", version = "1.1.4" }
 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.1" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+jsonrpc-core = "14.0.5"
+jsonrpc-http-server = "14.0.6"
+solana-logger = { path = "../logger", version = "1.1.4" }

client/src/client_error.rs

@@ -50,29 +50,29 @@ impl Into<TransportError> for ClientErrorKind {
 #[derive(Error, Debug)]
 #[error("{kind}")]
 pub struct ClientError {
-    request: Option<rpc_request::RpcRequest>,
-
+    command: Option<&'static str>,
     #[source]
+    #[error(transparent)]
     kind: ClientErrorKind,
 }
 
 impl ClientError {
-    pub fn new_with_request(kind: ClientErrorKind, request: rpc_request::RpcRequest) -> Self {
+    pub fn new_with_command(kind: ClientErrorKind, command: &'static str) -> Self {
         Self {
-            request: Some(request),
+            command: Some(command),
             kind,
         }
     }
 
-    pub fn into_with_request(self, request: rpc_request::RpcRequest) -> Self {
+    pub fn into_with_command(self, command: &'static str) -> Self {
         Self {
-            request: Some(request),
+            command: Some(command),
             ..self
         }
     }
 
-    pub fn request(&self) -> Option<&rpc_request::RpcRequest> {
-        self.request.as_ref()
+    pub fn command(&self) -> Option<&'static str> {
+        self.command
     }
 
     pub fn kind(&self) -> &ClientErrorKind {
@@ -83,7 +83,7 @@ impl ClientError {
 impl From<ClientErrorKind> for ClientError {
     fn from(kind: ClientErrorKind) -> Self {
         Self {
-            request: None,
+            command: None,
             kind,
         }
     }
@@ -92,7 +92,7 @@ impl From<ClientErrorKind> for ClientError {
 impl From<TransportError> for ClientError {
     fn from(err: TransportError) -> Self {
         Self {
-            request: None,
+            command: None,
             kind: err.into(),
         }
     }
@@ -107,7 +107,7 @@ impl Into<TransportError> for ClientError {
 impl From<std::io::Error> for ClientError {
     fn from(err: std::io::Error) -> Self {
         Self {
-            request: None,
+            command: None,
             kind: err.into(),
         }
     }
@@ -116,7 +116,7 @@ impl From<std::io::Error> for ClientError {
 impl From<reqwest::Error> for ClientError {
     fn from(err: reqwest::Error) -> Self {
         Self {
-            request: None,
+            command: None,
             kind: err.into(),
         }
     }
@@ -125,7 +125,7 @@ impl From<reqwest::Error> for ClientError {
 impl From<rpc_request::RpcError> for ClientError {
     fn from(err: rpc_request::RpcError) -> Self {
         Self {
-            request: None,
+            command: None,
             kind: err.into(),
         }
     }
@@ -134,7 +134,7 @@ impl From<rpc_request::RpcError> for ClientError {
 impl From<serde_json::error::Error> for ClientError {
     fn from(err: serde_json::error::Error) -> Self {
         Self {
-            request: None,
+            command: None,
             kind: err.into(),
         }
     }
@@ -143,7 +143,7 @@ impl From<serde_json::error::Error> for ClientError {
 impl From<SignerError> for ClientError {
     fn from(err: SignerError) -> Self {
         Self {
-            request: None,
+            command: None,
             kind: err.into(),
         }
     }
@@ -152,7 +152,7 @@ impl From<SignerError> for ClientError {
 impl From<TransactionError> for ClientError {
     fn from(err: TransactionError) -> Self {
         Self {
-            request: None,
+            command: None,
             kind: err.into(),
         }
     }

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>;
+}