feat: add error types for each sigma protocol

.buildkite/coverage-in-disk.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-#
-# This script is used to upload the full buildkite pipeline. The steps defined
-# in the buildkite UI should simply be:
-#
-#   steps:
-#    - command: ".buildkite/pipeline-upload.sh"
-#
-
-set -e
-cd "$(dirname "$0")"/..
-source ci/_
-sudo chmod 0777 ci/buildkite-pipeline-in-disk.sh
-
-_ ci/buildkite-pipeline-in-disk.sh pipeline.yml
-echo +++ pipeline
-cat pipeline.yml
-
-_ buildkite-agent pipeline upload pipeline.yml

.buildkite/hooks/pre-command

@@ -12,14 +12,7 @@ export PS4="++"
 # Restore target/ from the previous CI build on this machine
 #
 eval "$(ci/channel-info.sh)"
-eval "$(ci/sbf-tools-info.sh)"
-source "ci/rust-version.sh"
-HOST_RUST_VERSION="$rust_stable"
-pattern='^[0-9]+\.[0-9]+\.[0-9]+$'
-if [[ ${HOST_RUST_VERSION} =~ ${pattern} ]]; then
-    HOST_RUST_VERSION="${rust_stable%.*}"
-fi
-export CARGO_TARGET_CACHE=$HOME/cargo-target-cache/"$CHANNEL"-"$BUILDKITE_LABEL"-"$SBF_TOOLS_VERSION"-"$HOST_RUST_VERSION"
+export CARGO_TARGET_CACHE=$HOME/cargo-target-cache/"$CHANNEL"-"$BUILDKITE_LABEL"
 (
   set -x
   MAX_CACHE_SIZE=18 # gigabytes

.github/workflows/client-targets.yml

@@ -1,66 +0,0 @@
-name: client_targets
-
-on:
-  pull_request:
-    branches:
-     - master
-    paths:
-      - "client/**"
-      - "sdk/**"
-      - ".github/workflows/client-targets.yml"
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  check_compilation:
-    name: Client compilation
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        target: [aarch64-apple-ios, x86_64-apple-ios, aarch64-apple-darwin, x86_64-apple-darwin, aarch64-linux-android, armv7-linux-androideabi, i686-linux-android, x86_64-linux-android]
-        include:
-          - target: aarch64-apple-ios
-            platform: ios
-            os: macos-latest
-          - target: x86_64-apple-ios
-            platform: ios
-            os: macos-latest
-          - target: aarch64-apple-darwin
-            platform: ios
-            os: macos-latest
-          - target: x86_64-apple-darwin
-            platform: ios
-            os: macos-latest
-          - target: aarch64-linux-android
-            platform: android
-            os: ubuntu-latest
-          - target: armv7-linux-androideabi
-            platform: android
-            os: ubuntu-latest
-          - target: i686-linux-android
-            platform: android
-            os: ubuntu-latest
-          - target: x86_64-linux-android
-            platform: android
-            os: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          target: ${{ matrix.target }}
-      - name: Install cargo-ndk
-        if: ${{ matrix.platform == 'android' }}
-        run: cargo install cargo-ndk
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.platform == 'android' }}
-        with:
-          command: ndk
-          args: --target ${{ matrix.target }} build -p solana-client
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.platform == 'ios' }}
-        with:
-          command: build
-          args: -p solana-client --target ${{ matrix.target }}

.github/workflows/explorer_preview.yml

@@ -20,33 +20,3 @@ jobs:
           vercel-project-id: ${{ secrets.PROJECT_ID}} #Required 
           working-directory: ./explorer
           scope: ${{ secrets.TEAM_ID }}
-     
-      - name: vercel url
-        run : |
-              touch vercelfile.txt
-              vercel --token ${{secrets.VERCEL_TOKEN}}  ls explorer --scope team_8A2WD7p4uR7tmKX9M68loHXI > vercelfile.txt
-              touch vercelfile1.txt
-              head -n 2 vercelfile.txt > vercelfile1.txt
-              touch vercelfile2.txt
-              tail -n 1 vercelfile1.txt > vercelfile2.txt
-              filtered_url7=$(cut -f7 -d" " vercelfile2.txt)
-              echo "filtered_url7 is: $filtered_url7" 
-              touch .env.preview1
-              echo "$filtered_url7" > .env.preview1
-              #filtered_url=$(cat vercelfile2.txt )
-              #echo "$filtered_url" >> .env.preview1 
-
-
-      - name: Run tests
-        uses: mathiasvr/command-output@v1
-        id: tests2
-        with:
-          run: |
-               echo "$(cat .env.preview1)"
-      
-      - name: Slack Notification1
-        uses: rtCamp/action-slack-notify@master
-        env:
-         SLACK_MESSAGE: ${{ steps.tests2.outputs.stdout }}
-         SLACK_TITLE: Vercel "Explorer" Preview Deployment Link
-         SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}

.github/workflows/web3.yml

@@ -65,7 +65,20 @@ jobs:
           node-version: ${{ matrix.node }}
           cache: 'npm'
           cache-dependency-path: web3.js/package-lock.json
+      - run: npm i -g npm@7
+      - run: npm ci
+      - run: npm run lint
       - run: |
-          source .travis/before_install.sh
-          npm install
-          source .travis/script.sh
+          npm run build
+          ls -l lib
+          test -r lib/index.iife.js
+          test -r lib/index.cjs.js
+          test -r lib/index.esm.js
+      - run: npm run doc
+      - run: npm run codecov
+      - run: |
+          sh -c "$(curl -sSfL https://release.solana.com/edge/install)"
+          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
+          PATH="$HOME/.local/share/solana/install/active_release/bin:$PATH"
+          solana --version
+      - run: npm run test:live-with-test-validator

.mergify.yml

@@ -113,10 +113,3 @@ pull_request_rules:
         ignore_conflicts: true
         branches:
           - v1.9
-
-commands_restrictions:
-  # The author of copied PRs is the Mergify user.
-  # Restrict `copy` access to Core Contributors
-  copy:
-    conditions:
-    - author=@core-contributors

.travis.yml

@@ -78,24 +78,7 @@ jobs:
     #    - sudo apt-get install libssl-dev libudev-dev
 
     # docs pull request
-#     - name: "explorer"
-#       if: type = pull_request AND branch = master
-
-#       language: node_js
-#       node_js:
-#         - "lts/*"
-
-#       cache:
-#         directories:
-#           - ~/.npm
-
-#       before_install:
-#         - .travis/affects.sh explorer/ .travis || travis_terminate 0
-#         - cd explorer
-
-#       script:
-#         - npm run build
-#         - npm run format
+   
     - name: "docs"
       if: type IN (push, pull_request) OR tag IS present
       language: node_js

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "accountsdb-plugin-interface",
     "accountsdb-plugin-manager",
+    "accountsdb-plugin-postgres",
     "accounts-cluster-bench",
     "bench-streamer",
     "bench-tps",
@@ -11,7 +12,6 @@ members = [
     "banks-interface",
     "banks-server",
     "bucket_map",
-    "bloom",
     "clap-utils",
     "cli-config",
     "cli-output",
@@ -48,7 +48,6 @@ members = [
     "program-test",
     "programs/address-lookup-table",
     "programs/address-lookup-table-tests",
-    "programs/ed25519-tests",
     "programs/bpf_loader",
     "programs/bpf_loader/gen-syscall-list",
     "programs/compute-budget",

LICENSE

@@ -1,4 +1,4 @@
-Copyright 2022 Solana Foundation.
+Copyright 2020 Solana Foundation.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

account-decoder/Cargo.toml

@@ -16,15 +16,15 @@ bs58 = "0.4.0"
 bv = "0.11.1"
 Inflector = "0.11.4"
 lazy_static = "1.4.0"
-serde = "1.0.136"
+serde = "1.0.133"
 serde_derive = "1.0.103"
-serde_json = "1.0.78"
+serde_json = "1.0.74"
 solana-config-program = { path = "../programs/config", version = "=1.10.0" }
 solana-sdk = { path = "../sdk", version = "=1.10.0" }
 solana-vote-program = { path = "../programs/vote", version = "=1.10.0" }
 spl-token = { version = "=3.2.0", features = ["no-entrypoint"] }
 thiserror = "1.0"
-zstd = "0.10.0"
+zstd = "0.9.1"
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

account-decoder/src/lib.rs

@@ -136,13 +136,16 @@ impl UiAccount {
             UiAccountData::Binary(blob, encoding) => match encoding {
                 UiAccountEncoding::Base58 => bs58::decode(blob).into_vec().ok(),
                 UiAccountEncoding::Base64 => base64::decode(blob).ok(),
-                UiAccountEncoding::Base64Zstd => base64::decode(blob).ok().and_then(|zstd_data| {
-                    let mut data = vec![];
-                    zstd::stream::read::Decoder::new(zstd_data.as_slice())
-                        .and_then(|mut reader| reader.read_to_end(&mut data))
-                        .map(|_| data)
-                        .ok()
-                }),
+                UiAccountEncoding::Base64Zstd => base64::decode(blob)
+                    .ok()
+                    .map(|zstd_data| {
+                        let mut data = vec![];
+                        zstd::stream::read::Decoder::new(zstd_data.as_slice())
+                            .and_then(|mut reader| reader.read_to_end(&mut data))
+                            .map(|_| data)
+                            .ok()
+                    })
+                    .flatten(),
                 UiAccountEncoding::Binary | UiAccountEncoding::JsonParsed => None,
             },
         }?;

account-decoder/src/parse_account_data.rs

@@ -5,7 +5,7 @@ use {
         parse_nonce::parse_nonce,
         parse_stake::parse_stake,
         parse_sysvar::parse_sysvar,
-        parse_token::{parse_token, spl_token_ids},
+        parse_token::{parse_token, spl_token_id},
         parse_vote::parse_vote,
     },
     inflector::Inflector,
@@ -21,6 +21,7 @@ lazy_static! {
     static ref STAKE_PROGRAM_ID: Pubkey = stake::program::id();
     static ref SYSTEM_PROGRAM_ID: Pubkey = system_program::id();
     static ref SYSVAR_PROGRAM_ID: Pubkey = sysvar::id();
+    static ref TOKEN_PROGRAM_ID: Pubkey = spl_token_id();
     static ref VOTE_PROGRAM_ID: Pubkey = solana_vote_program::id();
     pub static ref PARSABLE_PROGRAM_IDS: HashMap<Pubkey, ParsableAccount> = {
         let mut m = HashMap::new();
@@ -30,9 +31,7 @@ lazy_static! {
         );
         m.insert(*CONFIG_PROGRAM_ID, ParsableAccount::Config);
         m.insert(*SYSTEM_PROGRAM_ID, ParsableAccount::Nonce);
-        for spl_token_id in spl_token_ids() {
-            m.insert(spl_token_id, ParsableAccount::SplToken);
-        }
+        m.insert(*TOKEN_PROGRAM_ID, ParsableAccount::SplToken);
         m.insert(*STAKE_PROGRAM_ID, ParsableAccount::Stake);
         m.insert(*SYSVAR_PROGRAM_ID, ParsableAccount::Sysvar);
         m.insert(*VOTE_PROGRAM_ID, ParsableAccount::Vote);

account-decoder/src/parse_token.rs

@@ -15,31 +15,16 @@ use {
 
 // A helper function to convert spl_token::id() as spl_sdk::pubkey::Pubkey to
 // solana_sdk::pubkey::Pubkey
-fn spl_token_id() -> Pubkey {
+pub fn spl_token_id() -> Pubkey {
     Pubkey::new_from_array(spl_token::id().to_bytes())
 }
 
-// Returns all known SPL Token program ids
-pub fn spl_token_ids() -> Vec<Pubkey> {
-    vec![spl_token_id()]
-}
-
-// Check if the provided program id as a known SPL Token program id
-pub fn is_known_spl_token_id(program_id: &Pubkey) -> bool {
-    *program_id == spl_token_id()
-}
-
 // A helper function to convert spl_token::native_mint::id() as spl_sdk::pubkey::Pubkey to
 // solana_sdk::pubkey::Pubkey
 pub fn spl_token_native_mint() -> Pubkey {
     Pubkey::new_from_array(spl_token::native_mint::id().to_bytes())
 }
 
-// The program id of the `spl_token_native_mint` account
-pub fn spl_token_native_mint_program_id() -> Pubkey {
-    spl_token_id()
-}
-
 // A helper function to convert a solana_sdk::pubkey::Pubkey to spl_sdk::pubkey::Pubkey
 pub fn spl_token_pubkey(pubkey: &Pubkey) -> SplTokenPubkey {
     SplTokenPubkey::new_from_array(pubkey.to_bytes())

accounts-cluster-bench/src/main.rs

@@ -116,7 +116,7 @@ fn make_create_message(
 
     let instructions: Vec<_> = (0..num_instructions)
         .into_iter()
-        .flat_map(|_| {
+        .map(|_| {
             let program_id = if mint.is_some() {
                 inline_spl_token::id()
             } else {
@@ -148,6 +148,7 @@ fn make_create_message(
 
             instructions
         })
+        .flatten()
         .collect();
 
     Message::new(&instructions, Some(&keypair.pubkey()))
@@ -673,7 +674,7 @@ pub mod test {
     #[test]
     fn test_accounts_cluster_bench() {
         solana_logger::setup();
-        let validator_config = ValidatorConfig::default_for_test();
+        let validator_config = ValidatorConfig::default();
         let num_nodes = 1;
         let mut config = ClusterConfig {
             cluster_lamports: 10_000_000,

accountsdb-plugin-manager/Cargo.toml

@@ -12,10 +12,11 @@ documentation = "https://docs.rs/solana-validator"
 [dependencies]
 bs58 = "0.4.0"
 crossbeam-channel = "0.5"
-json5 = "0.4.1"
-libloading = "0.7.3"
+libloading = "0.7.2"
 log = "0.4.11"
-serde_json = "1.0.78"
+serde = "1.0.133"
+serde_derive = "1.0.103"
+serde_json = "1.0.74"
 solana-accountsdb-plugin-interface = { path = "../accountsdb-plugin-interface", version = "=1.10.0" }
 solana-measure = { path = "../measure", version = "=1.10.0" }
 solana-metrics = { path = "../metrics", version = "=1.10.0" }

accountsdb-plugin-manager/src/accountsdb_plugin_service.rs

@@ -9,6 +9,7 @@ use {
     },
     crossbeam_channel::Receiver,
     log::*,
+    serde_json,
     solana_rpc::{
         optimistically_confirmed_bank_tracker::BankNotification,
         transaction_notifier_interface::TransactionNotifierLock,
@@ -155,12 +156,12 @@ impl AccountsDbPluginService {
             )));
         }
 
-        let result: serde_json::Value = match json5::from_str(&contents) {
+        let result: serde_json::Value = match serde_json::from_str(&contents) {
             Ok(value) => value,
             Err(err) => {
                 return Err(AccountsdbPluginServiceError::InvalidConfigFileFormat(
                     format!(
-                        "The config file {:?} is not in a valid Json5 format, error: {:?}",
+                        "The config file {:?} is not in a valid Json format, error: {:?}",
                         accountsdb_plugin_config_file, err
                     ),
                 ));
@@ -170,24 +171,13 @@ impl AccountsDbPluginService {
         let libpath = result["libpath"]
             .as_str()
             .ok_or(AccountsdbPluginServiceError::LibPathNotSet)?;
-        let mut libpath = PathBuf::from(libpath);
-        if libpath.is_relative() {
-            let config_dir = accountsdb_plugin_config_file.parent().ok_or_else(|| {
-                AccountsdbPluginServiceError::CannotOpenConfigFile(format!(
-                    "Failed to resolve parent of {:?}",
-                    accountsdb_plugin_config_file,
-                ))
-            })?;
-            libpath = config_dir.join(libpath);
-        }
-
         let config_file = accountsdb_plugin_config_file
             .as_os_str()
             .to_str()
             .ok_or(AccountsdbPluginServiceError::InvalidPluginPath)?;
 
         unsafe {
-            let result = plugin_manager.load_plugin(libpath.to_str().unwrap(), config_file);
+            let result = plugin_manager.load_plugin(libpath, config_file);
             if let Err(err) = result {
                 let msg = format!(
                     "Failed to load the plugin library: {:?}, error: {:?}",

accountsdb-plugin-manager/src/transaction_notifier.rs

@@ -8,6 +8,7 @@ use {
     solana_measure::measure::Measure,
     solana_metrics::*,
     solana_rpc::transaction_notifier_interface::TransactionNotifier,
+    solana_runtime::bank,
     solana_sdk::{clock::Slot, signature::Signature, transaction::SanitizedTransaction},
     solana_transaction_status::TransactionStatusMeta,
     std::sync::{Arc, RwLock},
@@ -84,7 +85,7 @@ impl TransactionNotifierImpl {
     ) -> ReplicaTransactionInfo<'a> {
         ReplicaTransactionInfo {
             signature,
-            is_vote: transaction.is_simple_vote_transaction(),
+            is_vote: bank::is_simple_vote_transaction(transaction),
             transaction,
             transaction_status_meta,
         }

accountsdb-plugin-postgres/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
+edition = "2021"
+name = "solana-accountsdb-plugin-postgres"
+description = "The Solana AccountsDb plugin for PostgreSQL database."
+version = "1.10.0"
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+documentation = "https://docs.rs/solana-validator"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+bs58 = "0.4.0"
+chrono = { version = "0.4.11", features = ["serde"] }
+crossbeam-channel = "0.5"
+log = "0.4.14"
+postgres = { version = "0.19.2", features = ["with-chrono-0_4"] }
+postgres-types = { version = "0.2.2", features = ["derive"] }
+serde = "1.0.133"
+serde_derive = "1.0.103"
+serde_json = "1.0.74"
+solana-accountsdb-plugin-interface = { path = "../accountsdb-plugin-interface", version = "=1.10.0" }
+solana-logger = { path = "../logger", version = "=1.10.0" }
+solana-measure = { path = "../measure", version = "=1.10.0" }
+solana-metrics = { path = "../metrics", version = "=1.10.0" }
+solana-runtime = { path = "../runtime", version = "=1.10.0" }
+solana-sdk = { path = "../sdk", version = "=1.10.0" }
+solana-transaction-status = { path = "../transaction-status", version = "=1.10.0" }
+thiserror = "1.0.30"
+tokio-postgres = "0.7.4"
+
+[dev-dependencies]
+solana-account-decoder = { path = "../account-decoder", version = "=1.10.0" }
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

accountsdb-plugin-postgres/README.md

@@ -0,0 +1,5 @@
+This is an example implementing the AccountsDb plugin for PostgreSQL database.
+Please see the `src/accountsdb_plugin_postgres.rs` for the format of the plugin's configuration file.
+
+To create the schema objects for the database, please use `scripts/create_schema.sql`.
+`scripts/drop_schema.sql` can be used to tear down the schema objects.

accountsdb-plugin-postgres/scripts/create_schema.sql

@@ -0,0 +1,195 @@
+/**
+ * This plugin implementation for PostgreSQL requires the following tables
+ */
+-- The table storing accounts
+
+
+CREATE TABLE account (
+    pubkey BYTEA PRIMARY KEY,
+    owner BYTEA,
+    lamports BIGINT NOT NULL,
+    slot BIGINT NOT NULL,
+    executable BOOL NOT NULL,
+    rent_epoch BIGINT NOT NULL,
+    data BYTEA,
+    write_version BIGINT NOT NULL,
+    updated_on TIMESTAMP NOT NULL
+);
+
+-- The table storing slot information
+CREATE TABLE slot (
+    slot BIGINT PRIMARY KEY,
+    parent BIGINT,
+    status VARCHAR(16) NOT NULL,
+    updated_on TIMESTAMP NOT NULL
+);
+
+-- Types for Transactions
+
+Create TYPE "TransactionErrorCode" AS ENUM (
+    'AccountInUse',
+    'AccountLoadedTwice',
+    'AccountNotFound',
+    'ProgramAccountNotFound',
+    'InsufficientFundsForFee',
+    'InvalidAccountForFee',
+    'AlreadyProcessed',
+    'BlockhashNotFound',
+    'InstructionError',
+    'CallChainTooDeep',
+    'MissingSignatureForFee',
+    'InvalidAccountIndex',
+    'SignatureFailure',
+    'InvalidProgramForExecution',
+    'SanitizeFailure',
+    'ClusterMaintenance',
+    'AccountBorrowOutstanding',
+    'WouldExceedMaxAccountCostLimit',
+    'WouldExceedMaxBlockCostLimit',
+    'UnsupportedVersion',
+    'InvalidWritableAccount',
+    'WouldExceedMaxAccountDataCostLimit'
+);
+
+CREATE TYPE "TransactionError" AS (
+    error_code "TransactionErrorCode",
+    error_detail VARCHAR(256)
+);
+
+CREATE TYPE "CompiledInstruction" AS (
+    program_id_index SMALLINT,
+    accounts SMALLINT[],
+    data BYTEA
+);
+
+CREATE TYPE "InnerInstructions" AS (
+    index SMALLINT,
+    instructions "CompiledInstruction"[]
+);
+
+CREATE TYPE "TransactionTokenBalance" AS (
+    account_index SMALLINT,
+    mint VARCHAR(44),
+    ui_token_amount DOUBLE PRECISION,
+    owner VARCHAR(44)
+);
+
+Create TYPE "RewardType" AS ENUM (
+    'Fee',
+    'Rent',
+    'Staking',
+    'Voting'
+);
+
+CREATE TYPE "Reward" AS (
+    pubkey VARCHAR(44),
+    lamports BIGINT,
+    post_balance BIGINT,
+    reward_type "RewardType",
+    commission SMALLINT
+);
+
+CREATE TYPE "TransactionStatusMeta" AS (
+    error "TransactionError",
+    fee BIGINT,
+    pre_balances BIGINT[],
+    post_balances BIGINT[],
+    inner_instructions "InnerInstructions"[],
+    log_messages TEXT[],
+    pre_token_balances "TransactionTokenBalance"[],
+    post_token_balances "TransactionTokenBalance"[],
+    rewards "Reward"[]
+);
+
+CREATE TYPE "TransactionMessageHeader" AS (
+    num_required_signatures SMALLINT,
+    num_readonly_signed_accounts SMALLINT,
+    num_readonly_unsigned_accounts SMALLINT
+);
+
+CREATE TYPE "TransactionMessage" AS (
+    header "TransactionMessageHeader",
+    account_keys BYTEA[],
+    recent_blockhash BYTEA,
+    instructions "CompiledInstruction"[]
+);
+
+CREATE TYPE "TransactionMessageAddressTableLookup" AS (
+    account_key BYTEA,
+    writable_indexes SMALLINT[],
+    readonly_indexes SMALLINT[]
+);
+
+CREATE TYPE "TransactionMessageV0" AS (
+    header "TransactionMessageHeader",
+    account_keys BYTEA[],
+    recent_blockhash BYTEA,
+    instructions "CompiledInstruction"[],
+    address_table_lookups "TransactionMessageAddressTableLookup"[]
+);
+
+CREATE TYPE "LoadedAddresses" AS (
+    writable BYTEA[],
+    readonly BYTEA[]
+);
+
+CREATE TYPE "LoadedMessageV0" AS (
+    message "TransactionMessageV0",
+    loaded_addresses "LoadedAddresses"
+);
+
+-- The table storing transactions
+CREATE TABLE transaction (
+    slot BIGINT NOT NULL,
+    signature BYTEA NOT NULL,
+    is_vote BOOL NOT NULL,
+    message_type SMALLINT, -- 0: legacy, 1: v0 message
+    legacy_message "TransactionMessage",
+    v0_loaded_message "LoadedMessageV0",
+    signatures BYTEA[],
+    message_hash BYTEA,
+    meta "TransactionStatusMeta",
+    updated_on TIMESTAMP NOT NULL,
+    CONSTRAINT transaction_pk PRIMARY KEY (slot, signature)
+);
+
+-- The table storing block metadata
+CREATE TABLE block (
+    slot BIGINT PRIMARY KEY,
+    blockhash VARCHAR(44),
+    rewards "Reward"[],
+    block_time BIGINT,
+    block_height BIGINT,
+    updated_on TIMESTAMP NOT NULL
+);
+
+/**
+ * The following is for keeping historical data for accounts and is not required for plugin to work.
+ */
+-- The table storing historical data for accounts
+CREATE TABLE account_audit (
+    pubkey BYTEA,
+    owner BYTEA,
+    lamports BIGINT NOT NULL,
+    slot BIGINT NOT NULL,
+    executable BOOL NOT NULL,
+    rent_epoch BIGINT NOT NULL,
+    data BYTEA,
+    write_version BIGINT NOT NULL,
+    updated_on TIMESTAMP NOT NULL
+);
+
+CREATE INDEX account_audit_account_key ON  account_audit (pubkey, write_version);
+
+CREATE FUNCTION audit_account_update() RETURNS trigger AS $audit_account_update$
+    BEGIN
+		INSERT INTO account_audit (pubkey, owner, lamports, slot, executable, rent_epoch, data, write_version, updated_on)
+            VALUES (OLD.pubkey, OLD.owner, OLD.lamports, OLD.slot,
+                    OLD.executable, OLD.rent_epoch, OLD.data, OLD.write_version, OLD.updated_on);
+        RETURN NEW;
+    END;
+
+$audit_account_update$ LANGUAGE plpgsql;
+
+CREATE TRIGGER account_update_trigger AFTER UPDATE OR DELETE ON account
+    FOR EACH ROW EXECUTE PROCEDURE audit_account_update();

accountsdb-plugin-postgres/scripts/drop_schema.sql

@@ -0,0 +1,26 @@
+/**
+ * Script for cleaning up the schema for PostgreSQL used for the AccountsDb plugin.
+ */
+
+DROP TRIGGER account_update_trigger ON account;
+DROP FUNCTION audit_account_update;
+DROP TABLE account_audit;
+DROP TABLE account;
+DROP TABLE slot;
+DROP TABLE transaction;
+DROP TABLE block;
+
+DROP TYPE "TransactionError" CASCADE;
+DROP TYPE "TransactionErrorCode" CASCADE;
+DROP TYPE "LoadedMessageV0" CASCADE;
+DROP TYPE "LoadedAddresses" CASCADE;
+DROP TYPE "TransactionMessageV0" CASCADE;
+DROP TYPE "TransactionMessage" CASCADE;
+DROP TYPE "TransactionMessageHeader" CASCADE;
+DROP TYPE "TransactionMessageAddressTableLookup" CASCADE;
+DROP TYPE "TransactionStatusMeta" CASCADE;
+DROP TYPE "RewardType" CASCADE;
+DROP TYPE "Reward" CASCADE;
+DROP TYPE "TransactionTokenBalance" CASCADE;
+DROP TYPE "InnerInstructions" CASCADE;
+DROP TYPE "CompiledInstruction" CASCADE;

accountsdb-plugin-postgres/scripts/postgresql.conf

@@ -0,0 +1,802 @@
+# This a reference configuration file for the PostgreSQL database version 14.
+
+# -----------------------------
+# PostgreSQL configuration file
+# -----------------------------
+#
+# This file consists of lines of the form:
+#
+#   name = value
+#
+# (The "=" is optional.)  Whitespace may be used.  Comments are introduced with
+# "#" anywhere on a line.  The complete list of parameter names and allowed
+# values can be found in the PostgreSQL documentation.
+#
+# The commented-out settings shown in this file represent the default values.
+# Re-commenting a setting is NOT sufficient to revert it to the default value;
+# you need to reload the server.
+#
+# This file is read on server startup and when the server receives a SIGHUP
+# signal.  If you edit the file on a running system, you have to SIGHUP the
+# server for the changes to take effect, run "pg_ctl reload", or execute
+# "SELECT pg_reload_conf()".  Some parameters, which are marked below,
+# require a server shutdown and restart to take effect.
+#
+# Any parameter can also be given as a command-line option to the server, e.g.,
+# "postgres -c log_connections=on".  Some parameters can be changed at run time
+# with the "SET" SQL command.
+#
+# Memory units:  B  = bytes            Time units:  us  = microseconds
+#                kB = kilobytes                     ms  = milliseconds
+#                MB = megabytes                     s   = seconds
+#                GB = gigabytes                     min = minutes
+#                TB = terabytes                     h   = hours
+#                                                   d   = days
+
+
+#------------------------------------------------------------------------------
+# FILE LOCATIONS
+#------------------------------------------------------------------------------
+
+# The default values of these variables are driven from the -D command-line
+# option or PGDATA environment variable, represented here as ConfigDir.
+
+data_directory = '/var/lib/postgresql/14/main'		# use data in another directory
+					# (change requires restart)
+
+hba_file = '/etc/postgresql/14/main/pg_hba.conf'	# host-based authentication file
+					# (change requires restart)
+ident_file = '/etc/postgresql/14/main/pg_ident.conf'	# ident configuration file
+					# (change requires restart)
+
+# If external_pid_file is not explicitly set, no extra PID file is written.
+external_pid_file = '/var/run/postgresql/14-main.pid'			# write an extra PID file
+					# (change requires restart)
+
+
+#------------------------------------------------------------------------------
+# CONNECTIONS AND AUTHENTICATION
+#------------------------------------------------------------------------------
+
+# - Connection Settings -
+
+#listen_addresses = 'localhost'		# what IP address(es) to listen on;
+					# comma-separated list of addresses;
+					# defaults to 'localhost'; use '*' for all
+					# (change requires restart)
+listen_addresses = '*'
+port = 5433				# (change requires restart)
+max_connections = 200			# (change requires restart)
+#superuser_reserved_connections = 3	# (change requires restart)
+unix_socket_directories = '/var/run/postgresql'	# comma-separated list of directories
+					# (change requires restart)
+#unix_socket_group = ''			# (change requires restart)
+#unix_socket_permissions = 0777		# begin with 0 to use octal notation
+					# (change requires restart)
+#bonjour = off				# advertise server via Bonjour
+					# (change requires restart)
+#bonjour_name = ''			# defaults to the computer name
+					# (change requires restart)
+
+# - TCP settings -
+# see "man tcp" for details
+
+#tcp_keepalives_idle = 0		# TCP_KEEPIDLE, in seconds;
+					# 0 selects the system default
+#tcp_keepalives_interval = 0		# TCP_KEEPINTVL, in seconds;
+					# 0 selects the system default
+#tcp_keepalives_count = 0		# TCP_KEEPCNT;
+					# 0 selects the system default
+#tcp_user_timeout = 0			# TCP_USER_TIMEOUT, in milliseconds;
+					# 0 selects the system default
+
+#client_connection_check_interval = 0	# time between checks for client
+					# disconnection while running queries;
+					# 0 for never
+
+# - Authentication -
+
+#authentication_timeout = 1min		# 1s-600s
+#password_encryption = scram-sha-256	# scram-sha-256 or md5
+#db_user_namespace = off
+
+# GSSAPI using Kerberos
+#krb_server_keyfile = 'FILE:${sysconfdir}/krb5.keytab'
+#krb_caseins_users = off
+
+# - SSL -
+
+ssl = on
+#ssl_ca_file = ''
+ssl_cert_file = '/etc/ssl/certs/ssl-cert-snakeoil.pem'
+#ssl_crl_file = ''
+#ssl_crl_dir = ''
+ssl_key_file = '/etc/ssl/private/ssl-cert-snakeoil.key'
+#ssl_ciphers = 'HIGH:MEDIUM:+3DES:!aNULL' # allowed SSL ciphers
+#ssl_prefer_server_ciphers = on
+#ssl_ecdh_curve = 'prime256v1'
+#ssl_min_protocol_version = 'TLSv1.2'
+#ssl_max_protocol_version = ''
+#ssl_dh_params_file = ''
+#ssl_passphrase_command = ''
+#ssl_passphrase_command_supports_reload = off
+
+
+#------------------------------------------------------------------------------
+# RESOURCE USAGE (except WAL)
+#------------------------------------------------------------------------------
+
+# - Memory -
+
+shared_buffers = 1GB			# min 128kB
+					# (change requires restart)
+#huge_pages = try			# on, off, or try
+					# (change requires restart)
+#huge_page_size = 0			# zero for system default
+					# (change requires restart)
+#temp_buffers = 8MB			# min 800kB
+#max_prepared_transactions = 0		# zero disables the feature
+					# (change requires restart)
+# Caution: it is not advisable to set max_prepared_transactions nonzero unless
+# you actively intend to use prepared transactions.
+#work_mem = 4MB				# min 64kB
+#hash_mem_multiplier = 1.0		# 1-1000.0 multiplier on hash table work_mem
+#maintenance_work_mem = 64MB		# min 1MB
+#autovacuum_work_mem = -1		# min 1MB, or -1 to use maintenance_work_mem
+#logical_decoding_work_mem = 64MB	# min 64kB
+#max_stack_depth = 2MB			# min 100kB
+#shared_memory_type = mmap		# the default is the first option
+					# supported by the operating system:
+					#   mmap
+					#   sysv
+					#   windows
+					# (change requires restart)
+dynamic_shared_memory_type = posix	# the default is the first option
+					# supported by the operating system:
+					#   posix
+					#   sysv
+					#   windows
+					#   mmap
+					# (change requires restart)
+#min_dynamic_shared_memory = 0MB	# (change requires restart)
+
+# - Disk -
+
+#temp_file_limit = -1			# limits per-process temp file space
+					# in kilobytes, or -1 for no limit
+
+# - Kernel Resources -
+
+#max_files_per_process = 1000		# min 64
+					# (change requires restart)
+
+# - Cost-Based Vacuum Delay -
+
+#vacuum_cost_delay = 0			# 0-100 milliseconds (0 disables)
+#vacuum_cost_page_hit = 1		# 0-10000 credits
+#vacuum_cost_page_miss = 2		# 0-10000 credits
+#vacuum_cost_page_dirty = 20		# 0-10000 credits
+#vacuum_cost_limit = 200		# 1-10000 credits
+
+# - Background Writer -
+
+#bgwriter_delay = 200ms			# 10-10000ms between rounds
+#bgwriter_lru_maxpages = 100		# max buffers written/round, 0 disables
+#bgwriter_lru_multiplier = 2.0		# 0-10.0 multiplier on buffers scanned/round
+#bgwriter_flush_after = 512kB		# measured in pages, 0 disables
+
+# - Asynchronous Behavior -
+
+#backend_flush_after = 0		# measured in pages, 0 disables
+effective_io_concurrency = 1000		# 1-1000; 0 disables prefetching
+#maintenance_io_concurrency = 10	# 1-1000; 0 disables prefetching
+#max_worker_processes = 8		# (change requires restart)
+#max_parallel_workers_per_gather = 2	# taken from max_parallel_workers
+#max_parallel_maintenance_workers = 2	# taken from max_parallel_workers
+#max_parallel_workers = 8		# maximum number of max_worker_processes that
+					# can be used in parallel operations
+#parallel_leader_participation = on
+#old_snapshot_threshold = -1		# 1min-60d; -1 disables; 0 is immediate
+					# (change requires restart)
+
+
+#------------------------------------------------------------------------------
+# WRITE-AHEAD LOG
+#------------------------------------------------------------------------------
+
+# - Settings -
+
+wal_level = minimal 			# minimal, replica, or logical
+					# (change requires restart)
+fsync = off				# flush data to disk for crash safety
+					# (turning this off can cause
+					# unrecoverable data corruption)
+synchronous_commit = off		# synchronization level;
+					# off, local, remote_write, remote_apply, or on
+#wal_sync_method = fsync		# the default is the first option
+					# supported by the operating system:
+					#   open_datasync
+					#   fdatasync (default on Linux and FreeBSD)
+					#   fsync
+					#   fsync_writethrough
+					#   open_sync
+full_page_writes = off			# recover from partial page writes
+#wal_log_hints = off			# also do full page writes of non-critical updates
+					# (change requires restart)
+#wal_compression = off			# enable compression of full-page writes
+#wal_init_zero = on			# zero-fill new WAL files
+#wal_recycle = on			# recycle WAL files
+#wal_buffers = -1			# min 32kB, -1 sets based on shared_buffers
+					# (change requires restart)
+#wal_writer_delay = 200ms		# 1-10000 milliseconds
+#wal_writer_flush_after = 1MB		# measured in pages, 0 disables
+#wal_skip_threshold = 2MB
+
+#commit_delay = 0			# range 0-100000, in microseconds
+#commit_siblings = 5			# range 1-1000
+
+# - Checkpoints -
+
+#checkpoint_timeout = 5min		# range 30s-1d
+#checkpoint_completion_target = 0.9	# checkpoint target duration, 0.0 - 1.0
+#checkpoint_flush_after = 256kB		# measured in pages, 0 disables
+#checkpoint_warning = 30s		# 0 disables
+max_wal_size = 1GB
+min_wal_size = 80MB
+
+# - Archiving -
+
+#archive_mode = off		# enables archiving; off, on, or always
+				# (change requires restart)
+#archive_command = ''		# command to use to archive a logfile segment
+				# placeholders: %p = path of file to archive
+				#               %f = file name only
+				# e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f'
+#archive_timeout = 0		# force a logfile segment switch after this
+				# number of seconds; 0 disables
+
+# - Archive Recovery -
+
+# These are only used in recovery mode.
+
+#restore_command = ''		# command to use to restore an archived logfile segment
+				# placeholders: %p = path of file to restore
+				#               %f = file name only
+				# e.g. 'cp /mnt/server/archivedir/%f %p'
+#archive_cleanup_command = ''	# command to execute at every restartpoint
+#recovery_end_command = ''	# command to execute at completion of recovery
+
+# - Recovery Target -
+
+# Set these only when performing a targeted recovery.
+
+#recovery_target = ''		# 'immediate' to end recovery as soon as a
+                                # consistent state is reached
+				# (change requires restart)
+#recovery_target_name = ''	# the named restore point to which recovery will proceed
+				# (change requires restart)
+#recovery_target_time = ''	# the time stamp up to which recovery will proceed
+				# (change requires restart)
+#recovery_target_xid = ''	# the transaction ID up to which recovery will proceed
+				# (change requires restart)
+#recovery_target_lsn = ''	# the WAL LSN up to which recovery will proceed
+				# (change requires restart)
+#recovery_target_inclusive = on # Specifies whether to stop:
+				# just after the specified recovery target (on)
+				# just before the recovery target (off)
+				# (change requires restart)
+#recovery_target_timeline = 'latest'	# 'current', 'latest', or timeline ID
+				# (change requires restart)
+#recovery_target_action = 'pause'	# 'pause', 'promote', 'shutdown'
+				# (change requires restart)
+
+
+#------------------------------------------------------------------------------
+# REPLICATION
+#------------------------------------------------------------------------------
+
+# - Sending Servers -
+
+# Set these on the primary and on any standby that will send replication data.
+
+max_wal_senders = 0		# max number of walsender processes
+				# (change requires restart)
+#max_replication_slots = 10	# max number of replication slots
+				# (change requires restart)
+#wal_keep_size = 0		# in megabytes; 0 disables
+#max_slot_wal_keep_size = -1	# in megabytes; -1 disables
+#wal_sender_timeout = 60s	# in milliseconds; 0 disables
+#track_commit_timestamp = off	# collect timestamp of transaction commit
+				# (change requires restart)
+
+# - Primary Server -
+
+# These settings are ignored on a standby server.
+
+#synchronous_standby_names = ''	# standby servers that provide sync rep
+				# method to choose sync standbys, number of sync standbys,
+				# and comma-separated list of application_name
+				# from standby(s); '*' = all
+#vacuum_defer_cleanup_age = 0	# number of xacts by which cleanup is delayed
+
+# - Standby Servers -
+
+# These settings are ignored on a primary server.
+
+#primary_conninfo = ''			# connection string to sending server
+#primary_slot_name = ''			# replication slot on sending server
+#promote_trigger_file = ''		# file name whose presence ends recovery
+#hot_standby = on			# "off" disallows queries during recovery
+					# (change requires restart)
+#max_standby_archive_delay = 30s	# max delay before canceling queries
+					# when reading WAL from archive;
+					# -1 allows indefinite delay
+#max_standby_streaming_delay = 30s	# max delay before canceling queries
+					# when reading streaming WAL;
+					# -1 allows indefinite delay
+#wal_receiver_create_temp_slot = off	# create temp slot if primary_slot_name
+					# is not set
+#wal_receiver_status_interval = 10s	# send replies at least this often
+					# 0 disables
+#hot_standby_feedback = off		# send info from standby to prevent
+					# query conflicts
+#wal_receiver_timeout = 60s		# time that receiver waits for
+					# communication from primary
+					# in milliseconds; 0 disables
+#wal_retrieve_retry_interval = 5s	# time to wait before retrying to
+					# retrieve WAL after a failed attempt
+#recovery_min_apply_delay = 0		# minimum delay for applying changes during recovery
+
+# - Subscribers -
+
+# These settings are ignored on a publisher.
+
+#max_logical_replication_workers = 4	# taken from max_worker_processes
+					# (change requires restart)
+#max_sync_workers_per_subscription = 2	# taken from max_logical_replication_workers
+
+
+#------------------------------------------------------------------------------
+# QUERY TUNING
+#------------------------------------------------------------------------------
+
+# - Planner Method Configuration -
+
+#enable_async_append = on
+#enable_bitmapscan = on
+#enable_gathermerge = on
+#enable_hashagg = on
+#enable_hashjoin = on
+#enable_incremental_sort = on
+#enable_indexscan = on
+#enable_indexonlyscan = on
+#enable_material = on
+#enable_memoize = on
+#enable_mergejoin = on
+#enable_nestloop = on
+#enable_parallel_append = on
+#enable_parallel_hash = on
+#enable_partition_pruning = on
+#enable_partitionwise_join = off
+#enable_partitionwise_aggregate = off
+#enable_seqscan = on
+#enable_sort = on
+#enable_tidscan = on
+
+# - Planner Cost Constants -
+
+#seq_page_cost = 1.0			# measured on an arbitrary scale
+#random_page_cost = 4.0			# same scale as above
+#cpu_tuple_cost = 0.01			# same scale as above
+#cpu_index_tuple_cost = 0.005		# same scale as above
+#cpu_operator_cost = 0.0025		# same scale as above
+#parallel_setup_cost = 1000.0	# same scale as above
+#parallel_tuple_cost = 0.1		# same scale as above
+#min_parallel_table_scan_size = 8MB
+#min_parallel_index_scan_size = 512kB
+#effective_cache_size = 4GB
+
+#jit_above_cost = 100000		# perform JIT compilation if available
+					# and query more expensive than this;
+					# -1 disables
+#jit_inline_above_cost = 500000		# inline small functions if query is
+					# more expensive than this; -1 disables
+#jit_optimize_above_cost = 500000	# use expensive JIT optimizations if
+					# query is more expensive than this;
+					# -1 disables
+
+# - Genetic Query Optimizer -
+
+#geqo = on
+#geqo_threshold = 12
+#geqo_effort = 5			# range 1-10
+#geqo_pool_size = 0			# selects default based on effort
+#geqo_generations = 0			# selects default based on effort
+#geqo_selection_bias = 2.0		# range 1.5-2.0
+#geqo_seed = 0.0			# range 0.0-1.0
+
+# - Other Planner Options -
+
+#default_statistics_target = 100	# range 1-10000
+#constraint_exclusion = partition	# on, off, or partition
+#cursor_tuple_fraction = 0.1		# range 0.0-1.0
+#from_collapse_limit = 8
+#jit = on				# allow JIT compilation
+#join_collapse_limit = 8		# 1 disables collapsing of explicit
+					# JOIN clauses
+#plan_cache_mode = auto			# auto, force_generic_plan or
+					# force_custom_plan
+
+
+#------------------------------------------------------------------------------
+# REPORTING AND LOGGING
+#------------------------------------------------------------------------------
+
+# - Where to Log -
+
+#log_destination = 'stderr'		# Valid values are combinations of
+					# stderr, csvlog, syslog, and eventlog,
+					# depending on platform.  csvlog
+					# requires logging_collector to be on.
+
+# This is used when logging to stderr:
+#logging_collector = off		# Enable capturing of stderr and csvlog
+					# into log files. Required to be on for
+					# csvlogs.
+					# (change requires restart)
+
+# These are only used if logging_collector is on:
+#log_directory = 'log'			# directory where log files are written,
+					# can be absolute or relative to PGDATA
+#log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'	# log file name pattern,
+					# can include strftime() escapes
+#log_file_mode = 0600			# creation mode for log files,
+					# begin with 0 to use octal notation
+#log_rotation_age = 1d			# Automatic rotation of logfiles will
+					# happen after that time.  0 disables.
+#log_rotation_size = 10MB		# Automatic rotation of logfiles will
+					# happen after that much log output.
+					# 0 disables.
+#log_truncate_on_rotation = off		# If on, an existing log file with the
+					# same name as the new log file will be
+					# truncated rather than appended to.
+					# But such truncation only occurs on
+					# time-driven rotation, not on restarts
+					# or size-driven rotation.  Default is
+					# off, meaning append to existing files
+					# in all cases.
+
+# These are relevant when logging to syslog:
+#syslog_facility = 'LOCAL0'
+#syslog_ident = 'postgres'
+#syslog_sequence_numbers = on
+#syslog_split_messages = on
+
+# This is only relevant when logging to eventlog (Windows):
+# (change requires restart)
+#event_source = 'PostgreSQL'
+
+# - When to Log -
+
+#log_min_messages = warning		# values in order of decreasing detail:
+					#   debug5
+					#   debug4
+					#   debug3
+					#   debug2
+					#   debug1
+					#   info
+					#   notice
+					#   warning
+					#   error
+					#   log
+					#   fatal
+					#   panic
+
+#log_min_error_statement = error	# values in order of decreasing detail:
+					#   debug5
+					#   debug4
+					#   debug3
+					#   debug2
+					#   debug1
+					#   info
+					#   notice
+					#   warning
+					#   error
+					#   log
+					#   fatal
+					#   panic (effectively off)
+
+#log_min_duration_statement = -1	# -1 is disabled, 0 logs all statements
+					# and their durations, > 0 logs only
+					# statements running at least this number
+					# of milliseconds
+
+#log_min_duration_sample = -1		# -1 is disabled, 0 logs a sample of statements
+					# and their durations, > 0 logs only a sample of
+					# statements running at least this number
+					# of milliseconds;
+					# sample fraction is determined by log_statement_sample_rate
+
+#log_statement_sample_rate = 1.0	# fraction of logged statements exceeding
+					# log_min_duration_sample to be logged;
+					# 1.0 logs all such statements, 0.0 never logs
+
+
+#log_transaction_sample_rate = 0.0	# fraction of transactions whose statements
+					# are logged regardless of their duration; 1.0 logs all
+					# statements from all transactions, 0.0 never logs
+
+# - What to Log -
+
+#debug_print_parse = off
+#debug_print_rewritten = off
+#debug_print_plan = off
+#debug_pretty_print = on
+#log_autovacuum_min_duration = -1	# log autovacuum activity;
+					# -1 disables, 0 logs all actions and
+					# their durations, > 0 logs only
+					# actions running at least this number
+					# of milliseconds.
+#log_checkpoints = off
+#log_connections = off
+#log_disconnections = off
+#log_duration = off
+#log_error_verbosity = default		# terse, default, or verbose messages
+#log_hostname = off
+log_line_prefix = '%m [%p] %q%u@%d '		# special values:
+					#   %a = application name
+					#   %u = user name
+					#   %d = database name
+					#   %r = remote host and port
+					#   %h = remote host
+					#   %b = backend type
+					#   %p = process ID
+					#   %P = process ID of parallel group leader
+					#   %t = timestamp without milliseconds
+					#   %m = timestamp with milliseconds
+					#   %n = timestamp with milliseconds (as a Unix epoch)
+					#   %Q = query ID (0 if none or not computed)
+					#   %i = command tag
+					#   %e = SQL state
+					#   %c = session ID
+					#   %l = session line number
+					#   %s = session start timestamp
+					#   %v = virtual transaction ID
+					#   %x = transaction ID (0 if none)
+					#   %q = stop here in non-session
+					#        processes
+					#   %% = '%'
+					# e.g. '<%u%%%d> '
+#log_lock_waits = off			# log lock waits >= deadlock_timeout
+#log_recovery_conflict_waits = off	# log standby recovery conflict waits
+					# >= deadlock_timeout
+#log_parameter_max_length = -1		# when logging statements, limit logged
+					# bind-parameter values to N bytes;
+					# -1 means print in full, 0 disables
+#log_parameter_max_length_on_error = 0	# when logging an error, limit logged
+					# bind-parameter values to N bytes;
+					# -1 means print in full, 0 disables
+#log_statement = 'none'			# none, ddl, mod, all
+#log_replication_commands = off
+#log_temp_files = -1			# log temporary files equal or larger
+					# than the specified size in kilobytes;
+					# -1 disables, 0 logs all temp files
+log_timezone = 'Etc/UTC'
+
+
+#------------------------------------------------------------------------------
+# PROCESS TITLE
+#------------------------------------------------------------------------------
+
+cluster_name = '14/main'			# added to process titles if nonempty
+					# (change requires restart)
+#update_process_title = on
+
+
+#------------------------------------------------------------------------------
+# STATISTICS
+#------------------------------------------------------------------------------
+
+# - Query and Index Statistics Collector -
+
+#track_activities = on
+#track_activity_query_size = 1024	# (change requires restart)
+#track_counts = on
+#track_io_timing = off
+#track_wal_io_timing = off
+#track_functions = none			# none, pl, all
+stats_temp_directory = '/var/run/postgresql/14-main.pg_stat_tmp'
+
+
+# - Monitoring -
+
+#compute_query_id = auto
+#log_statement_stats = off
+#log_parser_stats = off
+#log_planner_stats = off
+#log_executor_stats = off
+
+
+#------------------------------------------------------------------------------
+# AUTOVACUUM
+#------------------------------------------------------------------------------
+
+#autovacuum = on			# Enable autovacuum subprocess?  'on'
+					# requires track_counts to also be on.
+#autovacuum_max_workers = 3		# max number of autovacuum subprocesses
+					# (change requires restart)
+#autovacuum_naptime = 1min		# time between autovacuum runs
+#autovacuum_vacuum_threshold = 50	# min number of row updates before
+					# vacuum
+#autovacuum_vacuum_insert_threshold = 1000	# min number of row inserts
+					# before vacuum; -1 disables insert
+					# vacuums
+#autovacuum_analyze_threshold = 50	# min number of row updates before
+					# analyze
+#autovacuum_vacuum_scale_factor = 0.2	# fraction of table size before vacuum
+#autovacuum_vacuum_insert_scale_factor = 0.2	# fraction of inserts over table
+					# size before insert vacuum
+#autovacuum_analyze_scale_factor = 0.1	# fraction of table size before analyze
+#autovacuum_freeze_max_age = 200000000	# maximum XID age before forced vacuum
+					# (change requires restart)
+#autovacuum_multixact_freeze_max_age = 400000000	# maximum multixact age
+					# before forced vacuum
+					# (change requires restart)
+#autovacuum_vacuum_cost_delay = 2ms	# default vacuum cost delay for
+					# autovacuum, in milliseconds;
+					# -1 means use vacuum_cost_delay
+#autovacuum_vacuum_cost_limit = -1	# default vacuum cost limit for
+					# autovacuum, -1 means use
+					# vacuum_cost_limit
+
+
+#------------------------------------------------------------------------------
+# CLIENT CONNECTION DEFAULTS
+#------------------------------------------------------------------------------
+
+# - Statement Behavior -
+
+#client_min_messages = notice		# values in order of decreasing detail:
+					#   debug5
+					#   debug4
+					#   debug3
+					#   debug2
+					#   debug1
+					#   log
+					#   notice
+					#   warning
+					#   error
+#search_path = '"$user", public'	# schema names
+#row_security = on
+#default_table_access_method = 'heap'
+#default_tablespace = ''		# a tablespace name, '' uses the default
+#default_toast_compression = 'pglz'	# 'pglz' or 'lz4'
+#temp_tablespaces = ''			# a list of tablespace names, '' uses
+					# only default tablespace
+#check_function_bodies = on
+#default_transaction_isolation = 'read committed'
+#default_transaction_read_only = off
+#default_transaction_deferrable = off
+#session_replication_role = 'origin'
+#statement_timeout = 0			# in milliseconds, 0 is disabled
+#lock_timeout = 0			# in milliseconds, 0 is disabled
+#idle_in_transaction_session_timeout = 0	# in milliseconds, 0 is disabled
+#idle_session_timeout = 0		# in milliseconds, 0 is disabled
+#vacuum_freeze_table_age = 150000000
+#vacuum_freeze_min_age = 50000000
+#vacuum_failsafe_age = 1600000000
+#vacuum_multixact_freeze_table_age = 150000000
+#vacuum_multixact_freeze_min_age = 5000000
+#vacuum_multixact_failsafe_age = 1600000000
+#bytea_output = 'hex'			# hex, escape
+#xmlbinary = 'base64'
+#xmloption = 'content'
+#gin_pending_list_limit = 4MB
+
+# - Locale and Formatting -
+
+datestyle = 'iso, mdy'
+#intervalstyle = 'postgres'
+timezone = 'Etc/UTC'
+#timezone_abbreviations = 'Default'     # Select the set of available time zone
+					# abbreviations.  Currently, there are
+					#   Default
+					#   Australia (historical usage)
+					#   India
+					# You can create your own file in
+					# share/timezonesets/.
+#extra_float_digits = 1			# min -15, max 3; any value >0 actually
+					# selects precise output mode
+#client_encoding = sql_ascii		# actually, defaults to database
+					# encoding
+
+# These settings are initialized by initdb, but they can be changed.
+lc_messages = 'C.UTF-8'			# locale for system error message
+					# strings
+lc_monetary = 'C.UTF-8'			# locale for monetary formatting
+lc_numeric = 'C.UTF-8'			# locale for number formatting
+lc_time = 'C.UTF-8'				# locale for time formatting
+
+# default configuration for text search
+default_text_search_config = 'pg_catalog.english'
+
+# - Shared Library Preloading -
+
+#local_preload_libraries = ''
+#session_preload_libraries = ''
+#shared_preload_libraries = ''	# (change requires restart)
+#jit_provider = 'llvmjit'		# JIT library to use
+
+# - Other Defaults -
+
+#dynamic_library_path = '$libdir'
+#extension_destdir = ''			# prepend path when loading extensions
+					# and shared objects (added by Debian)
+#gin_fuzzy_search_limit = 0
+
+
+#------------------------------------------------------------------------------
+# LOCK MANAGEMENT
+#------------------------------------------------------------------------------
+
+#deadlock_timeout = 1s
+#max_locks_per_transaction = 64		# min 10
+					# (change requires restart)
+#max_pred_locks_per_transaction = 64	# min 10
+					# (change requires restart)
+#max_pred_locks_per_relation = -2	# negative values mean
+					# (max_pred_locks_per_transaction
+					#  / -max_pred_locks_per_relation) - 1
+#max_pred_locks_per_page = 2            # min 0
+
+
+#------------------------------------------------------------------------------
+# VERSION AND PLATFORM COMPATIBILITY
+#------------------------------------------------------------------------------
+
+# - Previous PostgreSQL Versions -
+
+#array_nulls = on
+#backslash_quote = safe_encoding	# on, off, or safe_encoding
+#escape_string_warning = on
+#lo_compat_privileges = off
+#quote_all_identifiers = off
+#standard_conforming_strings = on
+#synchronize_seqscans = on
+
+# - Other Platforms and Clients -
+
+#transform_null_equals = off
+
+
+#------------------------------------------------------------------------------
+# ERROR HANDLING
+#------------------------------------------------------------------------------
+
+#exit_on_error = off			# terminate session on any error?
+#restart_after_crash = on		# reinitialize after backend crash?
+#data_sync_retry = off			# retry or panic on failure to fsync
+					# data?
+					# (change requires restart)
+#recovery_init_sync_method = fsync	# fsync, syncfs (Linux 5.8+)
+
+
+#------------------------------------------------------------------------------
+# CONFIG FILE INCLUDES
+#------------------------------------------------------------------------------
+
+# These options allow settings to be loaded from files other than the
+# default postgresql.conf.  Note that these are directives, not variable
+# assignments, so they can usefully be given more than once.
+
+include_dir = 'conf.d'			# include files ending in '.conf' from
+					# a directory, e.g., 'conf.d'
+#include_if_exists = '...'		# include file only if it exists
+#include = '...'			# include file
+
+
+#------------------------------------------------------------------------------
+# CUSTOMIZED OPTIONS
+#------------------------------------------------------------------------------
+
+# Add settings for extensions here

accountsdb-plugin-postgres/src/accounts_selector.rs

@@ -0,0 +1,74 @@
+use {log::*, std::collections::HashSet};
+
+#[derive(Debug)]
+pub(crate) struct AccountsSelector {
+    pub accounts: HashSet<Vec<u8>>,
+    pub owners: HashSet<Vec<u8>>,
+    pub select_all_accounts: bool,
+}
+
+impl AccountsSelector {
+    pub fn default() -> Self {
+        AccountsSelector {
+            accounts: HashSet::default(),
+            owners: HashSet::default(),
+            select_all_accounts: true,
+        }
+    }
+
+    pub fn new(accounts: &[String], owners: &[String]) -> Self {
+        info!(
+            "Creating AccountsSelector from accounts: {:?}, owners: {:?}",
+            accounts, owners
+        );
+
+        let select_all_accounts = accounts.iter().any(|key| key == "*");
+        if select_all_accounts {
+            return AccountsSelector {
+                accounts: HashSet::default(),
+                owners: HashSet::default(),
+                select_all_accounts,
+            };
+        }
+        let accounts = accounts
+            .iter()
+            .map(|key| bs58::decode(key).into_vec().unwrap())
+            .collect();
+        let owners = owners
+            .iter()
+            .map(|key| bs58::decode(key).into_vec().unwrap())
+            .collect();
+        AccountsSelector {
+            accounts,
+            owners,
+            select_all_accounts,
+        }
+    }
+
+    pub fn is_account_selected(&self, account: &[u8], owner: &[u8]) -> bool {
+        self.select_all_accounts || self.accounts.contains(account) || self.owners.contains(owner)
+    }
+
+    /// Check if any account is of interested at all
+    pub fn is_enabled(&self) -> bool {
+        self.select_all_accounts || !self.accounts.is_empty() || !self.owners.is_empty()
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_accounts_selector() {
+        AccountsSelector::new(
+            &["9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin".to_string()],
+            &[],
+        );
+
+        AccountsSelector::new(
+            &[],
+            &["9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin".to_string()],
+        );
+    }
+}

accountsdb-plugin-postgres/src/accountsdb_plugin_postgres.rs

@@ -0,0 +1,466 @@
+use solana_measure::measure::Measure;
+/// Main entry for the PostgreSQL plugin
+use {
+    crate::{
+        accounts_selector::AccountsSelector,
+        postgres_client::{ParallelPostgresClient, PostgresClientBuilder},
+        transaction_selector::TransactionSelector,
+    },
+    bs58,
+    log::*,
+    serde_derive::{Deserialize, Serialize},
+    serde_json,
+    solana_accountsdb_plugin_interface::accountsdb_plugin_interface::{
+        AccountsDbPlugin, AccountsDbPluginError, ReplicaAccountInfoVersions,
+        ReplicaBlockInfoVersions, ReplicaTransactionInfoVersions, Result, SlotStatus,
+    },
+    solana_metrics::*,
+    std::{fs::File, io::Read},
+    thiserror::Error,
+};
+
+#[derive(Default)]
+pub struct AccountsDbPluginPostgres {
+    client: Option<ParallelPostgresClient>,
+    accounts_selector: Option<AccountsSelector>,
+    transaction_selector: Option<TransactionSelector>,
+}
+
+impl std::fmt::Debug for AccountsDbPluginPostgres {
+    fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AccountsDbPluginPostgresConfig {
+    pub host: Option<String>,
+    pub user: Option<String>,
+    pub port: Option<u16>,
+    pub connection_str: Option<String>,
+    pub threads: Option<usize>,
+    pub batch_size: Option<usize>,
+    pub panic_on_db_errors: Option<bool>,
+    /// Indicates if to store historical data for accounts
+    pub store_account_historical_data: Option<bool>,
+}
+
+#[derive(Error, Debug)]
+pub enum AccountsDbPluginPostgresError {
+    #[error("Error connecting to the backend data store. Error message: ({msg})")]
+    DataStoreConnectionError { msg: String },
+
+    #[error("Error preparing data store schema. Error message: ({msg})")]
+    DataSchemaError { msg: String },
+
+    #[error("Error preparing data store schema. Error message: ({msg})")]
+    ConfigurationError { msg: String },
+}
+
+impl AccountsDbPlugin for AccountsDbPluginPostgres {
+    fn name(&self) -> &'static str {
+        "AccountsDbPluginPostgres"
+    }
+
+    /// Do initialization for the PostgreSQL plugin.
+    ///
+    /// # Format of the config file:
+    /// * The `accounts_selector` section allows the user to controls accounts selections.
+    /// "accounts_selector" : {
+    ///     "accounts" : \["pubkey-1", "pubkey-2", ..., "pubkey-n"\],
+    /// }
+    /// or:
+    /// "accounts_selector" = {
+    ///     "owners" : \["pubkey-1", "pubkey-2", ..., "pubkey-m"\]
+    /// }
+    /// Accounts either satisyfing the accounts condition or owners condition will be selected.
+    /// When only owners is specified,
+    /// all accounts belonging to the owners will be streamed.
+    /// The accounts field supports wildcard to select all accounts:
+    /// "accounts_selector" : {
+    ///     "accounts" : \["*"\],
+    /// }
+    /// * "host", optional, specifies the PostgreSQL server.
+    /// * "user", optional, specifies the PostgreSQL user.
+    /// * "port", optional, specifies the PostgreSQL server's port.
+    /// * "connection_str", optional, the custom PostgreSQL connection string.
+    /// Please refer to https://docs.rs/postgres/0.19.2/postgres/config/struct.Config.html for the connection configuration.
+    /// When `connection_str` is set, the values in "host", "user" and "port" are ignored. If `connection_str` is not given,
+    /// `host` and `user` must be given.
+    /// "store_account_historical_data", optional, set it to 'true', to store historical account data to account_audit
+    /// table.
+    /// * "threads" optional, specifies the number of worker threads for the plugin. A thread
+    /// maintains a PostgreSQL connection to the server. The default is '10'.
+    /// * "batch_size" optional, specifies the batch size of bulk insert when the AccountsDb is created
+    /// from restoring a snapshot. The default is '10'.
+    /// * "panic_on_db_errors", optional, contols if to panic when there are errors replicating data to the
+    /// PostgreSQL database. The default is 'false'.
+    /// * "transaction_selector", optional, controls if and what transaction to store. If this field is missing
+    /// None of the transction is stored.
+    /// "transaction_selector" : {
+    ///     "mentions" : \["pubkey-1", "pubkey-2", ..., "pubkey-n"\],
+    /// }
+    /// The `mentions` field support wildcard to select all transaction or all 'vote' transactions:
+    /// For example, to select all transactions:
+    /// "transaction_selector" : {
+    ///     "mentions" : \["*"\],
+    /// }
+    /// To select all vote transactions:
+    /// "transaction_selector" : {
+    ///     "mentions" : \["all_votes"\],
+    /// }
+    /// # Examples
+    ///
+    /// {
+    ///    "libpath": "/home/solana/target/release/libsolana_accountsdb_plugin_postgres.so",
+    ///    "host": "host_foo",
+    ///    "user": "solana",
+    ///    "threads": 10,
+    ///    "accounts_selector" : {
+    ///       "owners" : ["9oT9R5ZyRovSVnt37QvVoBttGpNqR3J7unkb567NP8k3"]
+    ///    }
+    /// }
+
+    fn on_load(&mut self, config_file: &str) -> Result<()> {
+        solana_logger::setup_with_default("info");
+        info!(
+            "Loading plugin {:?} from config_file {:?}",
+            self.name(),
+            config_file
+        );
+        let mut file = File::open(config_file)?;
+        let mut contents = String::new();
+        file.read_to_string(&mut contents)?;
+
+        let result: serde_json::Value = serde_json::from_str(&contents).unwrap();
+        self.accounts_selector = Some(Self::create_accounts_selector_from_config(&result));
+        self.transaction_selector = Some(Self::create_transaction_selector_from_config(&result));
+
+        let result: serde_json::Result<AccountsDbPluginPostgresConfig> =
+            serde_json::from_str(&contents);
+        match result {
+            Err(err) => {
+                return Err(AccountsDbPluginError::ConfigFileReadError {
+                    msg: format!(
+                        "The config file is not in the JSON format expected: {:?}",
+                        err
+                    ),
+                })
+            }
+            Ok(config) => {
+                let client = PostgresClientBuilder::build_pararallel_postgres_client(&config)?;
+                self.client = Some(client);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn on_unload(&mut self) {
+        info!("Unloading plugin: {:?}", self.name());
+
+        match &mut self.client {
+            None => {}
+            Some(client) => {
+                client.join().unwrap();
+            }
+        }
+    }
+
+    fn update_account(
+        &mut self,
+        account: ReplicaAccountInfoVersions,
+        slot: u64,
+        is_startup: bool,
+    ) -> Result<()> {
+        let mut measure_all = Measure::start("accountsdb-plugin-postgres-update-account-main");
+        match account {
+            ReplicaAccountInfoVersions::V0_0_1(account) => {
+                let mut measure_select =
+                    Measure::start("accountsdb-plugin-postgres-update-account-select");
+                if let Some(accounts_selector) = &self.accounts_selector {
+                    if !accounts_selector.is_account_selected(account.pubkey, account.owner) {
+                        return Ok(());
+                    }
+                } else {
+                    return Ok(());
+                }
+                measure_select.stop();
+                inc_new_counter_debug!(
+                    "accountsdb-plugin-postgres-update-account-select-us",
+                    measure_select.as_us() as usize,
+                    100000,
+                    100000
+                );
+
+                debug!(
+                    "Updating account {:?} with owner {:?} at slot {:?} using account selector {:?}",
+                    bs58::encode(account.pubkey).into_string(),
+                    bs58::encode(account.owner).into_string(),
+                    slot,
+                    self.accounts_selector.as_ref().unwrap()
+                );
+
+                match &mut self.client {
+                    None => {
+                        return Err(AccountsDbPluginError::Custom(Box::new(
+                            AccountsDbPluginPostgresError::DataStoreConnectionError {
+                                msg: "There is no connection to the PostgreSQL database."
+                                    .to_string(),
+                            },
+                        )));
+                    }
+                    Some(client) => {
+                        let mut measure_update =
+                            Measure::start("accountsdb-plugin-postgres-update-account-client");
+                        let result = { client.update_account(account, slot, is_startup) };
+                        measure_update.stop();
+
+                        inc_new_counter_debug!(
+                            "accountsdb-plugin-postgres-update-account-client-us",
+                            measure_update.as_us() as usize,
+                            100000,
+                            100000
+                        );
+
+                        if let Err(err) = result {
+                            return Err(AccountsDbPluginError::AccountsUpdateError {
+                                msg: format!("Failed to persist the update of account to the PostgreSQL database. Error: {:?}", err)
+                            });
+                        }
+                    }
+                }
+            }
+        }
+
+        measure_all.stop();
+
+        inc_new_counter_debug!(
+            "accountsdb-plugin-postgres-update-account-main-us",
+            measure_all.as_us() as usize,
+            100000,
+            100000
+        );
+
+        Ok(())
+    }
+
+    fn update_slot_status(
+        &mut self,
+        slot: u64,
+        parent: Option<u64>,
+        status: SlotStatus,
+    ) -> Result<()> {
+        info!("Updating slot {:?} at with status {:?}", slot, status);
+
+        match &mut self.client {
+            None => {
+                return Err(AccountsDbPluginError::Custom(Box::new(
+                    AccountsDbPluginPostgresError::DataStoreConnectionError {
+                        msg: "There is no connection to the PostgreSQL database.".to_string(),
+                    },
+                )));
+            }
+            Some(client) => {
+                let result = client.update_slot_status(slot, parent, status);
+
+                if let Err(err) = result {
+                    return Err(AccountsDbPluginError::SlotStatusUpdateError{
+                        msg: format!("Failed to persist the update of slot to the PostgreSQL database. Error: {:?}", err)
+                    });
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn notify_end_of_startup(&mut self) -> Result<()> {
+        info!("Notifying the end of startup for accounts notifications");
+        match &mut self.client {
+            None => {
+                return Err(AccountsDbPluginError::Custom(Box::new(
+                    AccountsDbPluginPostgresError::DataStoreConnectionError {
+                        msg: "There is no connection to the PostgreSQL database.".to_string(),
+                    },
+                )));
+            }
+            Some(client) => {
+                let result = client.notify_end_of_startup();
+
+                if let Err(err) = result {
+                    return Err(AccountsDbPluginError::SlotStatusUpdateError{
+                        msg: format!("Failed to notify the end of startup for accounts notifications. Error: {:?}", err)
+                    });
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn notify_transaction(
+        &mut self,
+        transaction_info: ReplicaTransactionInfoVersions,
+        slot: u64,
+    ) -> Result<()> {
+        match &mut self.client {
+            None => {
+                return Err(AccountsDbPluginError::Custom(Box::new(
+                    AccountsDbPluginPostgresError::DataStoreConnectionError {
+                        msg: "There is no connection to the PostgreSQL database.".to_string(),
+                    },
+                )));
+            }
+            Some(client) => match transaction_info {
+                ReplicaTransactionInfoVersions::V0_0_1(transaction_info) => {
+                    if let Some(transaction_selector) = &self.transaction_selector {
+                        if !transaction_selector.is_transaction_selected(
+                            transaction_info.is_vote,
+                            transaction_info.transaction.message().account_keys_iter(),
+                        ) {
+                            return Ok(());
+                        }
+                    } else {
+                        return Ok(());
+                    }
+
+                    let result = client.log_transaction_info(transaction_info, slot);
+
+                    if let Err(err) = result {
+                        return Err(AccountsDbPluginError::SlotStatusUpdateError{
+                                msg: format!("Failed to persist the transaction info to the PostgreSQL database. Error: {:?}", err)
+                            });
+                    }
+                }
+            },
+        }
+
+        Ok(())
+    }
+
+    fn notify_block_metadata(&mut self, block_info: ReplicaBlockInfoVersions) -> Result<()> {
+        match &mut self.client {
+            None => {
+                return Err(AccountsDbPluginError::Custom(Box::new(
+                    AccountsDbPluginPostgresError::DataStoreConnectionError {
+                        msg: "There is no connection to the PostgreSQL database.".to_string(),
+                    },
+                )));
+            }
+            Some(client) => match block_info {
+                ReplicaBlockInfoVersions::V0_0_1(block_info) => {
+                    let result = client.update_block_metadata(block_info);
+
+                    if let Err(err) = result {
+                        return Err(AccountsDbPluginError::SlotStatusUpdateError{
+                                msg: format!("Failed to persist the update of block metadata to the PostgreSQL database. Error: {:?}", err)
+                            });
+                    }
+                }
+            },
+        }
+
+        Ok(())
+    }
+
+    /// Check if the plugin is interested in account data
+    /// Default is true -- if the plugin is not interested in
+    /// account data, please return false.
+    fn account_data_notifications_enabled(&self) -> bool {
+        self.accounts_selector
+            .as_ref()
+            .map_or_else(|| false, |selector| selector.is_enabled())
+    }
+
+    /// Check if the plugin is interested in transaction data
+    fn transaction_notifications_enabled(&self) -> bool {
+        self.transaction_selector
+            .as_ref()
+            .map_or_else(|| false, |selector| selector.is_enabled())
+    }
+}
+
+impl AccountsDbPluginPostgres {
+    fn create_accounts_selector_from_config(config: &serde_json::Value) -> AccountsSelector {
+        let accounts_selector = &config["accounts_selector"];
+
+        if accounts_selector.is_null() {
+            AccountsSelector::default()
+        } else {
+            let accounts = &accounts_selector["accounts"];
+            let accounts: Vec<String> = if accounts.is_array() {
+                accounts
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .map(|val| val.as_str().unwrap().to_string())
+                    .collect()
+            } else {
+                Vec::default()
+            };
+            let owners = &accounts_selector["owners"];
+            let owners: Vec<String> = if owners.is_array() {
+                owners
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .map(|val| val.as_str().unwrap().to_string())
+                    .collect()
+            } else {
+                Vec::default()
+            };
+            AccountsSelector::new(&accounts, &owners)
+        }
+    }
+
+    fn create_transaction_selector_from_config(config: &serde_json::Value) -> TransactionSelector {
+        let transaction_selector = &config["transaction_selector"];
+
+        if transaction_selector.is_null() {
+            TransactionSelector::default()
+        } else {
+            let accounts = &transaction_selector["mentions"];
+            let accounts: Vec<String> = if accounts.is_array() {
+                accounts
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .map(|val| val.as_str().unwrap().to_string())
+                    .collect()
+            } else {
+                Vec::default()
+            };
+            TransactionSelector::new(&accounts)
+        }
+    }
+
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+#[no_mangle]
+#[allow(improper_ctypes_definitions)]
+/// # Safety
+///
+/// This function returns the AccountsDbPluginPostgres pointer as trait AccountsDbPlugin.
+pub unsafe extern "C" fn _create_plugin() -> *mut dyn AccountsDbPlugin {
+    let plugin = AccountsDbPluginPostgres::new();
+    let plugin: Box<dyn AccountsDbPlugin> = Box::new(plugin);
+    Box::into_raw(plugin)
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use {super::*, serde_json};
+
+    #[test]
+    fn test_accounts_selector_from_config() {
+        let config = "{\"accounts_selector\" : { \
+           \"owners\" : [\"9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin\"] \
+        }}";
+
+        let config: serde_json::Value = serde_json::from_str(config).unwrap();
+        AccountsDbPluginPostgres::create_accounts_selector_from_config(&config);
+    }
+}

accountsdb-plugin-postgres/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod accounts_selector;
+pub mod accountsdb_plugin_postgres;
+pub mod postgres_client;
+pub mod transaction_selector;

accountsdb-plugin-postgres/src/postgres_client/postgres_client_block_metadata.rs

@@ -0,0 +1,97 @@
+use {
+    crate::{
+        accountsdb_plugin_postgres::{
+            AccountsDbPluginPostgresConfig, AccountsDbPluginPostgresError,
+        },
+        postgres_client::{
+            postgres_client_transaction::DbReward, SimplePostgresClient, UpdateBlockMetadataRequest,
+        },
+    },
+    chrono::Utc,
+    log::*,
+    postgres::{Client, Statement},
+    solana_accountsdb_plugin_interface::accountsdb_plugin_interface::{
+        AccountsDbPluginError, ReplicaBlockInfo,
+    },
+};
+
+#[derive(Clone, Debug)]
+pub struct DbBlockInfo {
+    pub slot: i64,
+    pub blockhash: String,
+    pub rewards: Vec<DbReward>,
+    pub block_time: Option<i64>,
+    pub block_height: Option<i64>,
+}
+
+impl<'a> From<&ReplicaBlockInfo<'a>> for DbBlockInfo {
+    fn from(block_info: &ReplicaBlockInfo) -> Self {
+        Self {
+            slot: block_info.slot as i64,
+            blockhash: block_info.blockhash.to_string(),
+            rewards: block_info.rewards.iter().map(DbReward::from).collect(),
+            block_time: block_info.block_time,
+            block_height: block_info
+                .block_height
+                .map(|block_height| block_height as i64),
+        }
+    }
+}
+
+impl SimplePostgresClient {
+    pub(crate) fn build_block_metadata_upsert_statement(
+        client: &mut Client,
+        config: &AccountsDbPluginPostgresConfig,
+    ) -> Result<Statement, AccountsDbPluginError> {
+        let stmt =
+            "INSERT INTO block (slot, blockhash, rewards, block_time, block_height, updated_on) \
+        VALUES ($1, $2, $3, $4, $5, $6)";
+
+        let stmt = client.prepare(stmt);
+
+        match stmt {
+            Err(err) => {
+                return Err(AccountsDbPluginError::Custom(Box::new(AccountsDbPluginPostgresError::DataSchemaError {
+                    msg: format!(
+                        "Error in preparing for the block metadata update PostgreSQL database: ({}) host: {:?} user: {:?} config: {:?}",
+                        err, config.host, config.user, config
+                    ),
+                })));
+            }
+            Ok(stmt) => Ok(stmt),
+        }
+    }
+
+    pub(crate) fn update_block_metadata_impl(
+        &mut self,
+        block_info: UpdateBlockMetadataRequest,
+    ) -> Result<(), AccountsDbPluginError> {
+        let client = self.client.get_mut().unwrap();
+        let statement = &client.update_block_metadata_stmt;
+        let client = &mut client.client;
+        let updated_on = Utc::now().naive_utc();
+
+        let block_info = block_info.block_info;
+        let result = client.query(
+            statement,
+            &[
+                &block_info.slot,
+                &block_info.blockhash,
+                &block_info.rewards,
+                &block_info.block_time,
+                &block_info.block_height,
+                &updated_on,
+            ],
+        );
+
+        if let Err(err) = result {
+            let msg = format!(
+                "Failed to persist the update of block metadata to the PostgreSQL database. Error: {:?}",
+                err);
+            error!("{}", msg);
+            return Err(AccountsDbPluginError::AccountsUpdateError { msg });
+        }
+
+        Ok(())
+    }
+}

accountsdb-plugin-postgres/src/transaction_selector.rs

@@ -0,0 +1,194 @@
+/// The transaction selector is responsible for filtering transactions
+/// in the plugin framework.
+use {log::*, solana_sdk::pubkey::Pubkey, std::collections::HashSet};
+
+pub(crate) struct TransactionSelector {
+    pub mentioned_addresses: HashSet<Vec<u8>>,
+    pub select_all_transactions: bool,
+    pub select_all_vote_transactions: bool,
+}
+
+#[allow(dead_code)]
+impl TransactionSelector {
+    pub fn default() -> Self {
+        Self {
+            mentioned_addresses: HashSet::default(),
+            select_all_transactions: false,
+            select_all_vote_transactions: false,
+        }
+    }
+
+    /// Create a selector based on the mentioned addresses
+    /// To select all transactions use ["*"] or ["all"]
+    /// To select all vote transactions, use ["all_votes"]
+    /// To select transactions mentioning specific addresses use ["<pubkey1>", "<pubkey2>", ...]
+    pub fn new(mentioned_addresses: &[String]) -> Self {
+        info!(
+            "Creating TransactionSelector from addresses: {:?}",
+            mentioned_addresses
+        );
+
+        let select_all_transactions = mentioned_addresses
+            .iter()
+            .any(|key| key == "*" || key == "all");
+        if select_all_transactions {
+            return Self {
+                mentioned_addresses: HashSet::default(),
+                select_all_transactions,
+                select_all_vote_transactions: true,
+            };
+        }
+        let select_all_vote_transactions = mentioned_addresses.iter().any(|key| key == "all_votes");
+        if select_all_vote_transactions {
+            return Self {
+                mentioned_addresses: HashSet::default(),
+                select_all_transactions,
+                select_all_vote_transactions: true,
+            };
+        }
+
+        let mentioned_addresses = mentioned_addresses
+            .iter()
+            .map(|key| bs58::decode(key).into_vec().unwrap())
+            .collect();
+
+        Self {
+            mentioned_addresses,
+            select_all_transactions: false,
+            select_all_vote_transactions: false,
+        }
+    }
+
+    /// Check if a transaction is of interest.
+    pub fn is_transaction_selected(
+        &self,
+        is_vote: bool,
+        mentioned_addresses: Box<dyn Iterator<Item = &Pubkey> + '_>,
+    ) -> bool {
+        if !self.is_enabled() {
+            return false;
+        }
+
+        if self.select_all_transactions || (self.select_all_vote_transactions && is_vote) {
+            return true;
+        }
+        for address in mentioned_addresses {
+            if self.mentioned_addresses.contains(address.as_ref()) {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Check if any transaction is of interest at all
+    pub fn is_enabled(&self) -> bool {
+        self.select_all_transactions
+            || self.select_all_vote_transactions
+            || !self.mentioned_addresses.is_empty()
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    #[test]
+    fn test_select_transaction() {
+        let pubkey1 = Pubkey::new_unique();
+        let pubkey2 = Pubkey::new_unique();
+
+        let selector = TransactionSelector::new(&[pubkey1.to_string()]);
+
+        assert!(selector.is_enabled());
+
+        let addresses = [pubkey1];
+
+        assert!(selector.is_transaction_selected(false, Box::new(addresses.iter())));
+
+        let addresses = [pubkey2];
+        assert!(!selector.is_transaction_selected(false, Box::new(addresses.iter())));
+
+        let addresses = [pubkey1, pubkey2];
+        assert!(selector.is_transaction_selected(false, Box::new(addresses.iter())));
+    }
+
+    #[test]
+    fn test_select_all_transaction_using_wildcard() {
+        let pubkey1 = Pubkey::new_unique();
+        let pubkey2 = Pubkey::new_unique();
+
+        let selector = TransactionSelector::new(&["*".to_string()]);
+
+        assert!(selector.is_enabled());
+
+        let addresses = [pubkey1];
+
+        assert!(selector.is_transaction_selected(false, Box::new(addresses.iter())));
+
+        let addresses = [pubkey2];
+        assert!(selector.is_transaction_selected(false, Box::new(addresses.iter())));
+
+        let addresses = [pubkey1, pubkey2];
+        assert!(selector.is_transaction_selected(false, Box::new(addresses.iter())));
+    }
+
+    #[test]
+    fn test_select_all_transaction_all() {
+        let pubkey1 = Pubkey::new_unique();
+        let pubkey2 = Pubkey::new_unique();
+
+        let selector = TransactionSelector::new(&["all".to_string()]);
+
+        assert!(selector.is_enabled());
+
+        let addresses = [pubkey1];
+
+        assert!(selector.is_transaction_selected(false, Box::new(addresses.iter())));
+
+        let addresses = [pubkey2];
+        assert!(selector.is_transaction_selected(false, Box::new(addresses.iter())));
+
+        let addresses = [pubkey1, pubkey2];
+        assert!(selector.is_transaction_selected(false, Box::new(addresses.iter())));
+    }
+
+    #[test]
+    fn test_select_all_vote_transaction() {
+        let pubkey1 = Pubkey::new_unique();
+        let pubkey2 = Pubkey::new_unique();
+
+        let selector = TransactionSelector::new(&["all_votes".to_string()]);
+
+        assert!(selector.is_enabled());
+
+        let addresses = [pubkey1];
+
+        assert!(!selector.is_transaction_selected(false, Box::new(addresses.iter())));
+
+        let addresses = [pubkey2];
+        assert!(selector.is_transaction_selected(true, Box::new(addresses.iter())));
+
+        let addresses = [pubkey1, pubkey2];
+        assert!(selector.is_transaction_selected(true, Box::new(addresses.iter())));
+    }
+
+    #[test]
+    fn test_select_no_transaction() {
+        let pubkey1 = Pubkey::new_unique();
+        let pubkey2 = Pubkey::new_unique();
+
+        let selector = TransactionSelector::new(&[]);
+
+        assert!(!selector.is_enabled());
+
+        let addresses = [pubkey1];
+
+        assert!(!selector.is_transaction_selected(false, Box::new(addresses.iter())));
+
+        let addresses = [pubkey2];
+        assert!(!selector.is_transaction_selected(true, Box::new(addresses.iter())));
+
+        let addresses = [pubkey1, pubkey2];
+        assert!(!selector.is_transaction_selected(true, Box::new(addresses.iter())));
+    }
+}

banking-bench/src/main.rs

@@ -1,17 +1,16 @@
 #![allow(clippy::integer_arithmetic)]
 use {
     clap::{crate_description, crate_name, value_t, App, Arg},
-    crossbeam_channel::{unbounded, Receiver},
+    crossbeam_channel::unbounded,
     log::*,
     rand::{thread_rng, Rng},
     rayon::prelude::*,
-    solana_core::banking_stage::BankingStage,
+    solana_core::{banking_stage::BankingStage, packet_deduper::PacketDeduper},
     solana_gossip::cluster_info::{ClusterInfo, Node},
     solana_ledger::{
         blockstore::Blockstore,
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
         get_tmp_ledger_path,
-        leader_schedule_cache::LeaderScheduleCache,
     },
     solana_measure::measure::Measure,
     solana_perf::packet::to_packet_batches,
@@ -29,7 +28,7 @@ use {
     },
     solana_streamer::socket::SocketAddrSpace,
     std::{
-        sync::{atomic::Ordering, Arc, Mutex, RwLock},
+        sync::{atomic::Ordering, mpsc::Receiver, Arc, Mutex, RwLock},
         thread::sleep,
         time::{Duration, Instant},
     },
@@ -175,11 +174,6 @@ fn main() {
     let mut bank_forks = BankForks::new(bank0);
     let mut bank = bank_forks.working_bank();
 
-    // set cost tracker limits to MAX so it will not filter out TXs
-    bank.write_cost_tracker()
-        .unwrap()
-        .set_limits(std::u64::MAX, std::u64::MAX, std::u64::MAX);
-
     info!("threads: {} txs: {}", num_threads, total_num_transactions);
 
     let same_payer = matches.is_present("same_payer");
@@ -224,19 +218,15 @@ fn main() {
         let blockstore = Arc::new(
             Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"),
         );
-        let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
-        let (exit, poh_recorder, poh_service, signal_receiver) = create_test_recorder(
-            &bank,
-            &blockstore,
-            None,
-            Some(leader_schedule_cache.clone()),
-        );
+        let (exit, poh_recorder, poh_service, signal_receiver) =
+            create_test_recorder(&bank, &blockstore, None);
         let cluster_info = ClusterInfo::new(
             Node::new_localhost().info,
             Arc::new(Keypair::new()),
             SocketAddrSpace::Unspecified,
         );
         let cluster_info = Arc::new(cluster_info);
+        let packet_deduper = PacketDeduper::default();
         let banking_stage = BankingStage::new(
             &cluster_info,
             &poh_recorder,
@@ -246,6 +236,7 @@ fn main() {
             None,
             replay_vote_sender,
             Arc::new(RwLock::new(CostModel::default())),
+            packet_deduper.clone(),
         );
         poh_recorder.lock().unwrap().set_bank(&bank);
 
@@ -340,17 +331,9 @@ fn main() {
                 bank = bank_forks.working_bank();
                 insert_time.stop();
 
-                // set cost tracker limits to MAX so it will not filter out TXs
-                bank.write_cost_tracker().unwrap().set_limits(
-                    std::u64::MAX,
-                    std::u64::MAX,
-                    std::u64::MAX,
-                );
-
                 poh_recorder.lock().unwrap().set_bank(&bank);
                 assert!(poh_recorder.lock().unwrap().bank().is_some());
                 if bank.slot() > 32 {
-                    leader_schedule_cache.set_root(&bank);
                     bank_forks.set_root(root, &AbsRequestSender::default(), None);
                     root += 1;
                 }
@@ -368,6 +351,7 @@ fn main() {
             // in this chunk, but since we rotate between CHUNKS then
             // we should clear them by the time we come around again to re-use that chunk.
             bank.clear_signatures();
+            packet_deduper.reset();
             total_us += duration_as_us(&now.elapsed());
             debug!(
                 "time: {} us checked: {} sent: {}",

banks-client/Cargo.toml

@@ -10,7 +10,7 @@ documentation = "https://docs.rs/solana-banks-client"
 edition = "2021"
 
 [dependencies]
-borsh = "0.9.3"
+borsh = "0.9.1"
 futures = "0.3"
 solana-banks-interface = { path = "../banks-interface", version = "=1.10.0" }
 solana-program = { path = "../sdk/program", version = "=1.10.0" }

banks-client/src/lib.rs

@@ -5,11 +5,9 @@
 //! but they are undocumented, may change over time, and are generally more
 //! cumbersome to use.
 
-pub use {
-    crate::error::BanksClientError,
-    solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus},
-};
+pub use solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus};
 use {
+    crate::error::BanksClientError,
     borsh::BorshDeserialize,
     futures::{future::join_all, Future, FutureExt, TryFutureExt},
     solana_banks_interface::{BanksRequest, BanksResponse, BanksTransactionResultWithSimulation},

banks-interface/Cargo.toml

@@ -10,7 +10,7 @@ documentation = "https://docs.rs/solana-banks-interface"
 edition = "2021"
 
 [dependencies]
-serde = { version = "1.0.136", features = ["derive"] }
+serde = { version = "1.0.133", features = ["derive"] }
 solana-sdk = { path = "../sdk", version = "=1.10.0" }
 tarpc = { version = "0.27.2", features = ["full"] }
 

banks-server/Cargo.toml

@@ -11,7 +11,6 @@ edition = "2021"
 
 [dependencies]
 bincode = "1.3.3"
-crossbeam-channel = "0.5"
 futures = "0.3"
 solana-banks-interface = { path = "../banks-interface", version = "=1.10.0" }
 solana-runtime = { path = "../runtime", version = "=1.10.0" }

banks-server/src/banks_server.rs

@@ -1,6 +1,5 @@
 use {
     bincode::{deserialize, serialize},
-    crossbeam_channel::{unbounded, Receiver, Sender},
     futures::{future, prelude::stream::StreamExt},
     solana_banks_interface::{
         Banks, BanksRequest, BanksResponse, BanksTransactionResultWithSimulation,
@@ -31,7 +30,10 @@ use {
         convert::TryFrom,
         io,
         net::{Ipv4Addr, SocketAddr},
-        sync::{Arc, RwLock},
+        sync::{
+            mpsc::{channel, Receiver, Sender},
+            Arc, RwLock,
+        },
         thread::Builder,
         time::Duration,
     },
@@ -94,7 +96,7 @@ impl BanksServer {
         block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
         poll_signature_status_sleep_duration: Duration,
     ) -> Self {
-        let (transaction_sender, transaction_receiver) = unbounded();
+        let (transaction_sender, transaction_receiver) = channel();
         let bank = bank_forks.read().unwrap().working_bank();
         let slot = bank.slot();
         {
@@ -390,7 +392,7 @@ pub async fn start_tcp_server(
         // serve is generated by the service attribute. It takes as input any type implementing
         // the generated Banks trait.
         .map(move |chan| {
-            let (sender, receiver) = unbounded();
+            let (sender, receiver) = channel();
 
             SendTransactionService::new::<NullTpuInfo>(
                 tpu_addr,

bench-streamer/Cargo.toml

@@ -9,7 +9,6 @@ homepage = "https://solana.com/"
 publish = false
 
 [dependencies]
-crossbeam-channel = "0.5"
 clap = "2.33.1"
 solana-streamer = { path = "../streamer", version = "=1.10.0" }
 solana-net-utils = { path = "../net-utils", version = "=1.10.0" }

bench-streamer/src/main.rs

@@ -1,7 +1,6 @@
 #![allow(clippy::integer_arithmetic)]
 use {
-    clap::{crate_description, crate_name, value_t, App, Arg},
-    crossbeam_channel::unbounded,
+    clap::{crate_description, crate_name, App, Arg},
     solana_streamer::{
         packet::{Packet, PacketBatch, PacketBatchRecycler, PACKET_DATA_SIZE},
         streamer::{receiver, PacketBatchReceiver},
@@ -11,6 +10,7 @@ use {
         net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
         sync::{
             atomic::{AtomicBool, AtomicUsize, Ordering},
+            mpsc::channel,
             Arc,
         },
         thread::{sleep, spawn, JoinHandle, Result},
@@ -67,22 +67,13 @@ fn main() -> Result<()> {
                 .takes_value(true)
                 .help("Use NUM receive sockets"),
         )
-        .arg(
-            Arg::with_name("num-producers")
-                .long("num-producers")
-                .value_name("NUM")
-                .takes_value(true)
-                .help("Use this many producer threads."),
-        )
         .get_matches();
 
     if let Some(n) = matches.value_of("num-recv-sockets") {
         num_sockets = max(num_sockets, n.to_string().parse().expect("integer"));
     }
 
-    let num_producers = value_t!(matches, "num_producers", u64).unwrap_or(4);
-
-    let port = 0;
+    let mut port = 0;
     let ip_addr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
     let mut addr = SocketAddr::new(ip_addr, 0);
 
@@ -91,17 +82,14 @@ fn main() -> Result<()> {
     let mut read_channels = Vec::new();
     let mut read_threads = Vec::new();
     let recycler = PacketBatchRecycler::default();
-    let (_port, read_sockets) = solana_net_utils::multi_bind_in_range(
-        ip_addr,
-        (port, port + num_sockets as u16),
-        num_sockets,
-    )
-    .unwrap();
-    for read in read_sockets {
+    for _ in 0..num_sockets {
+        let read = solana_net_utils::bind_to(ip_addr, port, false).unwrap();
         read.set_read_timeout(Some(Duration::new(1, 0))).unwrap();
 
         addr = read.local_addr().unwrap();
-        let (s_reader, r_reader) = unbounded();
+        port = addr.port();
+
+        let (s_reader, r_reader) = channel();
         read_channels.push(r_reader);
         read_threads.push(receiver(
             Arc::new(read),
@@ -114,10 +102,9 @@ fn main() -> Result<()> {
         ));
     }
 
-    let producer_threads: Vec<_> = (0..num_producers)
-        .into_iter()
-        .map(|_| producer(&addr, exit.clone()))
-        .collect();
+    let t_producer1 = producer(&addr, exit.clone());
+    let t_producer2 = producer(&addr, exit.clone());
+    let t_producer3 = producer(&addr, exit.clone());
 
     let rvs = Arc::new(AtomicUsize::new(0));
     let sink_threads: Vec<_> = read_channels
@@ -137,9 +124,9 @@ fn main() -> Result<()> {
     for t_reader in read_threads {
         t_reader.join()?;
     }
-    for t_producer in producer_threads {
-        t_producer.join()?;
-    }
+    t_producer1.join()?;
+    t_producer2.join()?;
+    t_producer3.join()?;
     for t_sink in sink_threads {
         t_sink.join()?;
     }

bench-tps/Cargo.toml

@@ -10,10 +10,9 @@ publish = false
 
 [dependencies]
 clap = "2.33.1"
-crossbeam-channel = "0.5"
 log = "0.4.14"
 rayon = "1.5.1"
-serde_json = "1.0.78"
+serde_json = "1.0.74"
 serde_yaml = "0.8.23"
 solana-core = { path = "../core", version = "=1.10.0" }
 solana-genesis = { path = "../genesis", version = "=1.10.0" }
@@ -30,7 +29,7 @@ solana-streamer = { path = "../streamer", version = "=1.10.0" }
 solana-version = { path = "../version", version = "=1.10.0" }
 
 [dev-dependencies]
-serial_test = "0.6.0"
+serial_test = "0.5.1"
 solana-local-cluster = { path = "../local-cluster", version = "=1.10.0" }
 
 [package.metadata.docs.rs]

bench-tps/src/bench.rs

@@ -110,7 +110,7 @@ fn generate_chunked_transfers(
     shared_txs: &SharedTransactions,
     shared_tx_active_thread_count: Arc<AtomicIsize>,
     source_keypair_chunks: Vec<Vec<&Keypair>>,
-    dest_keypair_chunks: &mut [VecDeque<&Keypair>],
+    dest_keypair_chunks: &mut Vec<VecDeque<&Keypair>>,
     threads: usize,
     duration: Duration,
     sustained: bool,

bench-tps/src/main.rs

@@ -21,7 +21,7 @@ pub const NUM_SIGNATURES_FOR_TXS: u64 = 100_000 * 60 * 60 * 24 * 7;
 
 fn main() {
     solana_logger::setup_with_default("solana=info");
-    solana_metrics::set_panic_hook("bench-tps", /*version:*/ None);
+    solana_metrics::set_panic_hook("bench-tps");
 
     let matches = cli::build_args(solana_version::version!()).get_matches();
     let cli_config = cli::extract_args(&matches);

bench-tps/tests/bench_tps.rs

@@ -1,6 +1,5 @@
 #![allow(clippy::integer_arithmetic)]
 use {
-    crossbeam_channel::unbounded,
     serial_test::serial,
     solana_bench_tps::{
         bench::{do_bench_tps, generate_and_fund_keypairs},
@@ -16,7 +15,10 @@ use {
     },
     solana_sdk::signature::{Keypair, Signer},
     solana_streamer::socket::SocketAddrSpace,
-    std::{sync::Arc, time::Duration},
+    std::{
+        sync::{mpsc::channel, Arc},
+        time::Duration,
+    },
 };
 
 fn test_bench_tps_local_cluster(config: Config) {
@@ -29,7 +31,7 @@ fn test_bench_tps_local_cluster(config: Config) {
             node_stakes: vec![999_990; NUM_NODES],
             cluster_lamports: 200_000_000,
             validator_configs: make_identical_validator_configs(
-                &ValidatorConfig::default_for_test(),
+                &ValidatorConfig::default(),
                 NUM_NODES,
             ),
             native_instruction_processors,
@@ -50,7 +52,7 @@ fn test_bench_tps_local_cluster(config: Config) {
         VALIDATOR_PORT_RANGE,
     ));
 
-    let (addr_sender, addr_receiver) = unbounded();
+    let (addr_sender, addr_receiver) = channel();
     run_local_faucet_with_port(faucet_keypair, addr_sender, None, 0);
     let faucet_addr = addr_receiver
         .recv_timeout(Duration::from_secs(2))

bloom/Cargo.toml

@@ -1,32 +0,0 @@
-[package]
-name = "solana-bloom"
-version = "1.10.0"
-description = "Solana bloom filter"
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-bloom"
-edition = "2021"
-
-[dependencies]
-bv = { version = "0.11.1", features = ["serde"] }
-fnv = "1.0.7"
-rand = "0.7.0"
-serde = { version = "1.0.136", features = ["rc"] }
-rayon = "1.5.1"
-serde_derive = "1.0.103"
-solana-frozen-abi = { path = "../frozen-abi", version = "=1.10.0" }
-solana-frozen-abi-macro = { path = "../frozen-abi/macro", version = "=1.10.0" }
-solana-sdk = { path = "../sdk", version = "=1.10.0" }
-log = "0.4.14"
-
-[lib]
-crate-type = ["lib"]
-name = "solana_bloom"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
-
-[build-dependencies]
-rustc_version = "0.4"

bloom/build.rs

@@ -1 +0,0 @@
-../frozen-abi/build.rs

bloom/src/lib.rs

@@ -1,5 +0,0 @@
-#![cfg_attr(RUSTC_WITH_SPECIALIZATION, feature(min_specialization))]
-pub mod bloom;
-
-#[macro_use]
-extern crate solana_frozen_abi_macro;

bucket_map/Cargo.toml

@@ -12,12 +12,11 @@ edition = "2021"
 
 [dependencies]
 solana-sdk = { path = "../sdk", version = "=1.10.0" }
-memmap2 = "0.5.2"
+memmap2 = "0.5.0"
 log = { version = "0.4.11" }
 solana-measure = { path = "../measure", version = "=1.10.0" }
 rand = "0.7.0"
-tempfile = "3.3.0"
-modular-bitfield = "0.11.2"
+tempfile = "3.2.0"
 
 [dev-dependencies]
 fs_extra = "1.2.0"

bucket_map/src/index_entry.rs

@@ -1,11 +1,9 @@
-#![allow(dead_code)]
 use {
     crate::{
         bucket::Bucket,
         bucket_storage::{BucketStorage, Uid},
         RefCount,
     },
-    modular_bitfield::prelude::*,
     solana_sdk::{clock::Slot, pubkey::Pubkey},
     std::{
         collections::hash_map::DefaultHasher,
@@ -21,25 +19,18 @@ use {
 pub struct IndexEntry {
     pub key: Pubkey, // can this be smaller if we have reduced the keys into buckets already?
     pub ref_count: RefCount, // can this be smaller? Do we ever need more than 4B refcounts?
-    storage_cap_and_offset: PackedStorage,
+    storage_offset: u64, // smaller? since these are variably sized, this could get tricky. well, actually accountinfo is not variable sized...
     // if the bucket doubled, the index can be recomputed using create_bucket_capacity_pow2
+    storage_capacity_when_created_pow2: u8, // see data_location
     pub num_slots: Slot, // can this be smaller? epoch size should ~ be the max len. this is the num elements in the slot list
 }
 
-/// Pack the storage offset and capacity-when-crated-pow2 fields into a single u64
-#[bitfield(bits = 64)]
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
-struct PackedStorage {
-    capacity_when_created_pow2: B8,
-    offset: B56,
-}
-
 impl IndexEntry {
     pub fn init(&mut self, pubkey: &Pubkey) {
         self.key = *pubkey;
         self.ref_count = 0;
-        self.storage_cap_and_offset = PackedStorage::default();
+        self.storage_offset = 0;
+        self.storage_capacity_when_created_pow2 = 0;
         self.num_slots = 0;
     }
 
@@ -47,14 +38,11 @@ impl IndexEntry {
         &mut self,
         storage_capacity_when_created_pow2: u8,
     ) {
-        self.storage_cap_and_offset
-            .set_capacity_when_created_pow2(storage_capacity_when_created_pow2)
+        self.storage_capacity_when_created_pow2 = storage_capacity_when_created_pow2;
     }
 
     pub fn set_storage_offset(&mut self, storage_offset: u64) {
-        self.storage_cap_and_offset
-            .set_offset_checked(storage_offset)
-            .expect("New storage offset must fit into 7 bytes!")
+        self.storage_offset = storage_offset;
     }
 
     pub fn data_bucket_from_num_slots(num_slots: Slot) -> u64 {
@@ -69,18 +57,10 @@ impl IndexEntry {
         self.ref_count
     }
 
-    fn storage_capacity_when_created_pow2(&self) -> u8 {
-        self.storage_cap_and_offset.capacity_when_created_pow2()
-    }
-
-    fn storage_offset(&self) -> u64 {
-        self.storage_cap_and_offset.offset()
-    }
-
     // This function maps the original data location into an index in the current bucket storage.
     // This is coupled with how we resize bucket storages.
     pub fn data_loc(&self, storage: &BucketStorage) -> u64 {
-        self.storage_offset() << (storage.capacity_pow2 - self.storage_capacity_when_created_pow2())
+        self.storage_offset << (storage.capacity_pow2 - self.storage_capacity_when_created_pow2)
     }
 
     pub fn read_value<'a, T>(&self, bucket: &'a Bucket<T>) -> Option<(&'a [T], RefCount)> {
@@ -98,59 +78,9 @@ impl IndexEntry {
         };
         Some((slice, self.ref_count))
     }
-
     pub fn key_uid(key: &Pubkey) -> Uid {
         let mut s = DefaultHasher::new();
         key.hash(&mut s);
         s.finish().max(1u64)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    impl IndexEntry {
-        pub fn new(key: Pubkey) -> Self {
-            IndexEntry {
-                key,
-                ref_count: 0,
-                storage_cap_and_offset: PackedStorage::default(),
-                num_slots: 0,
-            }
-        }
-    }
-
-    /// verify that accessors for storage_offset and capacity_when_created are
-    /// correct and independent
-    #[test]
-    fn test_api() {
-        for offset in [0, 1, u32::MAX as u64] {
-            let mut index = IndexEntry::new(solana_sdk::pubkey::new_rand());
-            if offset != 0 {
-                index.set_storage_offset(offset);
-            }
-            assert_eq!(index.storage_offset(), offset);
-            assert_eq!(index.storage_capacity_when_created_pow2(), 0);
-            for pow in [1, 255, 0] {
-                index.set_storage_capacity_when_created_pow2(pow);
-                assert_eq!(index.storage_offset(), offset);
-                assert_eq!(index.storage_capacity_when_created_pow2(), pow);
-            }
-        }
-    }
-
-    #[test]
-    fn test_size() {
-        assert_eq!(std::mem::size_of::<PackedStorage>(), 1 + 7);
-        assert_eq!(std::mem::size_of::<IndexEntry>(), 32 + 8 + 8 + 8);
-    }
-
-    #[test]
-    #[should_panic(expected = "New storage offset must fit into 7 bytes!")]
-    fn test_set_storage_offset_value_too_large() {
-        let too_big = 1 << 56;
-        let mut index = IndexEntry::new(Pubkey::new_unique());
-        index.set_storage_offset(too_big);
-    }
-}

ci/buildkite-pipeline-in-disk.sh

@@ -1,365 +0,0 @@
-#!/usr/bin/env bash
-#
-# Builds a buildkite pipeline based on the environment variables
-#
-
-set -e
-cd "$(dirname "$0")"/..
-
-output_file=${1:-/dev/stderr}
-
-if [[ -n $CI_PULL_REQUEST ]]; then
-  IFS=':' read -ra affected_files <<< "$(buildkite-agent meta-data get affected_files)"
-  if [[ ${#affected_files[*]} -eq 0 ]]; then
-    echo "Unable to determine the files affected by this PR"
-    exit 1
-  fi
-else
-  affected_files=()
-fi
-
-annotate() {
-  if [[ -n $BUILDKITE ]]; then
-    buildkite-agent annotate "$@"
-  fi
-}
-
-# Checks if a CI pull request affects one or more path patterns.  Each
-# pattern argument is checked in series. If one of them found to be affected,
-# return immediately as such.
-#
-# Bash regular expressions are permitted in the pattern:
-#     affects .rs$    -- any file or directory ending in .rs
-#     affects .rs     -- also matches foo.rs.bar
-#     affects ^snap/  -- anything under the snap/ subdirectory
-#     affects snap/   -- also matches foo/snap/
-# Any pattern starting with the ! character will be negated:
-#     affects !^docs/  -- anything *not* under the docs/ subdirectory
-#
-affects() {
-  if [[ -z $CI_PULL_REQUEST ]]; then
-    # affected_files metadata is not currently available for non-PR builds so assume
-    # the worse (affected)
-    return 0
-  fi
-  # Assume everyting needs to be tested when any Dockerfile changes
-  for pattern in ^ci/docker-rust/Dockerfile ^ci/docker-rust-nightly/Dockerfile "$@"; do
-    if [[ ${pattern:0:1} = "!" ]]; then
-      for file in "${affected_files[@]}"; do
-        if [[ ! $file =~ ${pattern:1} ]]; then
-          return 0 # affected
-        fi
-      done
-    else
-      for file in "${affected_files[@]}"; do
-        if [[ $file =~ $pattern ]]; then
-          return 0 # affected
-        fi
-      done
-    fi
-  done
-
-  return 1 # not affected
-}
-
-
-# Checks if a CI pull request affects anything other than the provided path patterns
-#
-# Syntax is the same as `affects()` except that the negation prefix is not
-# supported
-#
-affects_other_than() {
-  if [[ -z $CI_PULL_REQUEST ]]; then
-    # affected_files metadata is not currently available for non-PR builds so assume
-    # the worse (affected)
-    return 0
-  fi
-
-  for file in "${affected_files[@]}"; do
-    declare matched=false
-    for pattern in "$@"; do
-        if [[ $file =~ $pattern ]]; then
-          matched=true
-        fi
-    done
-    if ! $matched; then
-      return 0 # affected
-    fi
-  done
-
-  return 1 # not affected
-}
-
-
-start_pipeline() {
-  echo "# $*" > "$output_file"
-  echo "steps:" >> "$output_file"
-}
-
-command_step() {
-  cat >> "$output_file" <<EOF
-  - name: "$1"
-    command: "$2"
-    timeout_in_minutes: $3
-    artifact_paths: "log-*.txt"
-EOF
-}
-
-
-trigger_secondary_step() {
-  cat  >> "$output_file" <<"EOF"
-  - trigger: "solana-secondary"
-    branches: "!pull/*"
-    async: true
-    build:
-      message: "${BUILDKITE_MESSAGE}"
-      commit: "${BUILDKITE_COMMIT}"
-      branch: "${BUILDKITE_BRANCH}"
-      env:
-        TRIGGERED_BUILDKITE_TAG: "${BUILDKITE_TAG}"
-EOF
-}
-
-wait_step() {
-  echo "  - wait" >> "$output_file"
-}
-
-all_test_steps() {
-  command_step checks ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_nightly_docker_image ci/test-checks.sh" 20
-  wait_step
-
-  # Coverage...
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-coverage.sh \
-             ^scripts/coverage.sh \
-      ; then
-    command_step coverage ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_nightly_docker_image ci/test-coverage.sh" 40
-    wait_step
-  else
-    annotate --style info --context test-coverage \
-      "Coverage skipped as no .rs files were modified"
-  fi
- # Coverage in disk...
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-coverage.sh \
-             ^scripts/coverage-in-disk.sh \
-      ; then
-    command_step coverage-in-disk ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_nightly_docker_image ci/test-coverage.sh" 40
-    wait_step
-  else
-    annotate --style info --context test-coverage \
-      "Coverage skipped as no .rs files were modified"
-  fi
-  # Full test suite
-  command_step stable ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_stable_docker_image ci/test-stable.sh" 60
-  wait_step
-
-  # BPF test suite
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-stable-bpf.sh \
-             ^ci/test-stable.sh \
-             ^ci/test-local-cluster.sh \
-             ^core/build.rs \
-             ^fetch-perf-libs.sh \
-             ^programs/ \
-             ^sdk/ \
-      ; then
-    cat >> "$output_file" <<"EOF"
-  - command: "ci/test-stable-bpf.sh"
-    name: "stable-bpf"
-    timeout_in_minutes: 20
-    artifact_paths: "bpf-dumps.tar.bz2"
-    agents:
-      - "queue=default"
-EOF
-  else
-    annotate --style info \
-      "Stable-BPF skipped as no relevant files were modified"
-  fi
-
-  # Perf test suite
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-stable-perf.sh \
-             ^ci/test-stable.sh \
-             ^ci/test-local-cluster.sh \
-             ^core/build.rs \
-             ^fetch-perf-libs.sh \
-             ^programs/ \
-             ^sdk/ \
-      ; then
-    cat >> "$output_file" <<"EOF"
-  - command: "ci/test-stable-perf.sh"
-    name: "stable-perf"
-    timeout_in_minutes: 20
-    artifact_paths: "log-*.txt"
-    agents:
-      - "queue=cuda"
-EOF
-  else
-    annotate --style info \
-      "Stable-perf skipped as no relevant files were modified"
-  fi
-
-  # Downstream backwards compatibility
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-stable-perf.sh \
-             ^ci/test-stable.sh \
-             ^ci/test-local-cluster.sh \
-             ^core/build.rs \
-             ^fetch-perf-libs.sh \
-             ^programs/ \
-             ^sdk/ \
-             ^scripts/build-downstream-projects.sh \
-      ; then
-    cat >> "$output_file" <<"EOF"
-  - command: "scripts/build-downstream-projects.sh"
-    name: "downstream-projects"
-    timeout_in_minutes: 30
-EOF
-  else
-    annotate --style info \
-      "downstream-projects skipped as no relevant files were modified"
-  fi
-
-  # Downstream Anchor projects backwards compatibility
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-stable-perf.sh \
-             ^ci/test-stable.sh \
-             ^ci/test-local-cluster.sh \
-             ^core/build.rs \
-             ^fetch-perf-libs.sh \
-             ^programs/ \
-             ^sdk/ \
-             ^scripts/build-downstream-anchor-projects.sh \
-      ; then
-    cat >> "$output_file" <<"EOF"
-  - command: "scripts/build-downstream-anchor-projects.sh"
-    name: "downstream-anchor-projects"
-    timeout_in_minutes: 10
-EOF
-  else
-    annotate --style info \
-      "downstream-anchor-projects skipped as no relevant files were modified"
-  fi
-
-  # Wasm support
-  if affects \
-             ^ci/test-wasm.sh \
-             ^ci/test-stable.sh \
-             ^sdk/ \
-      ; then
-    command_step wasm ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_stable_docker_image ci/test-wasm.sh" 20
-  else
-    annotate --style info \
-      "wasm skipped as no relevant files were modified"
-  fi
-
-  # Benches...
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-coverage.sh \
-             ^ci/test-bench.sh \
-      ; then
-    command_step bench "ci/test-bench.sh" 30
-  else
-    annotate --style info --context test-bench \
-      "Bench skipped as no .rs files were modified"
-  fi
-
-  command_step "local-cluster" \
-    ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_stable_docker_image ci/test-local-cluster.sh" \
-    40
-
-  command_step "local-cluster-flakey" \
-    ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_stable_docker_image ci/test-local-cluster-flakey.sh" \
-    10
-
-  command_step "local-cluster-slow" \
-    ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_stable_docker_image ci/test-local-cluster-slow.sh" \
-    30
-}
-
-pull_or_push_steps() {
-  command_step sanity "ci/test-sanity.sh" 5
-  wait_step
-
-  # Check for any .sh file changes
-  if affects .sh$; then
-    command_step shellcheck "ci/shellcheck.sh" 5
-    wait_step
-  fi
-
-  # Run the full test suite by default, skipping only if modifications are local
-  # to some particular areas of the tree
-  if affects_other_than ^.buildkite ^.mergify .md$ ^docs/ ^web3.js/ ^explorer/ ^.gitbook; then
-    all_test_steps
-  fi
-
-  # web3.js, explorer and docs changes run on Travis or Github actions...
-}
-
-
-if [[ -n $BUILDKITE_TAG ]]; then
-  start_pipeline "Tag pipeline for $BUILDKITE_TAG"
-
-  annotate --style info --context release-tag \
-    "https://github.com/solana-labs/solana/releases/$BUILDKITE_TAG"
-
-  # Jump directly to the secondary build to publish release artifacts quickly
-  trigger_secondary_step
-  exit 0
-fi
-
-
-if [[ $BUILDKITE_BRANCH =~ ^pull ]]; then
-  echo "+++ Affected files in this PR"
-  for file in "${affected_files[@]}"; do
-    echo "- $file"
-  done
-
-  start_pipeline "Pull request pipeline for $BUILDKITE_BRANCH"
-
-  # Add helpful link back to the corresponding Github Pull Request
-  annotate --style info --context pr-backlink \
-    "Github Pull Request: https://github.com/solana-labs/solana/$BUILDKITE_BRANCH"
-
-  if [[ $GITHUB_USER = "dependabot[bot]" ]]; then
-    command_step dependabot "ci/dependabot-pr.sh" 5
-    wait_step
-  fi
-  pull_or_push_steps
-  exit 0
-fi
-
-start_pipeline "Push pipeline for ${BUILDKITE_BRANCH:-?unknown branch?}"
-pull_or_push_steps
-wait_step
-trigger_secondary_step
-exit 0

ci/buildkite-pipeline.sh

@@ -102,8 +102,6 @@ command_step() {
     command: "$2"
     timeout_in_minutes: $3
     artifact_paths: "log-*.txt"
-    agents:
-      - "queue=solana"
 EOF
 }
 
@@ -170,7 +168,7 @@ all_test_steps() {
     timeout_in_minutes: 20
     artifact_paths: "bpf-dumps.tar.bz2"
     agents:
-      - "queue=solana"
+      - "queue=default"
 EOF
   else
     annotate --style info \
@@ -223,41 +221,12 @@ EOF
   - command: "scripts/build-downstream-projects.sh"
     name: "downstream-projects"
     timeout_in_minutes: 30
-    agents:
-      - "queue=solana"
 EOF
   else
     annotate --style info \
       "downstream-projects skipped as no relevant files were modified"
   fi
 
-  # Downstream Anchor projects backwards compatibility
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-stable-perf.sh \
-             ^ci/test-stable.sh \
-             ^ci/test-local-cluster.sh \
-             ^core/build.rs \
-             ^fetch-perf-libs.sh \
-             ^programs/ \
-             ^sdk/ \
-             ^scripts/build-downstream-anchor-projects.sh \
-      ; then
-    cat >> "$output_file" <<"EOF"
-  - command: "scripts/build-downstream-anchor-projects.sh"
-    name: "downstream-anchor-projects"
-    timeout_in_minutes: 10
-    agents:
-      - "queue=solana"
-EOF
-  else
-    annotate --style info \
-      "downstream-anchor-projects skipped as no relevant files were modified"
-  fi
-
   # Wasm support
   if affects \
              ^ci/test-wasm.sh \
@@ -295,7 +264,7 @@ EOF
 
   command_step "local-cluster-slow" \
     ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_stable_docker_image ci/test-local-cluster-slow.sh" \
-    30
+    25
 }
 
 pull_or_push_steps() {

ci/buildkite-secondary.yml

@@ -19,8 +19,3 @@ steps:
     timeout_in_minutes: 240
     name: "publish crate"
     branches: "!master"
-  - command: "ci/publish-tarball.sh"
-    agents:
-      - "queue=release-build-aarch64-apple-darwin"
-    timeout_in_minutes: 60
-    name: "publish tarball (aarch64-apple-darwin)"

ci/do-audit.sh

@@ -8,6 +8,11 @@ src_root="$(readlink -f "${here}/..")"
 cd "${src_root}"
 
 cargo_audit_ignores=(
+  # failure is officially deprecated/unmaintained
+  #
+  # Blocked on multiple upstream crates removing their `failure` dependency.
+  --ignore RUSTSEC-2020-0036
+
   # `net2` crate has been deprecated; use `socket2` instead
   #
   # Blocked on https://github.com/paritytech/jsonrpc/issues/575
@@ -25,10 +30,22 @@ cargo_audit_ignores=(
 
   # generic-array: arr! macro erases lifetimes
   #
-  # Blocked on new spl dependencies on solana-program v1.9
-  # due to curve25519-dalek dependency
+  # Blocked on libsecp256k1 releasing with upgraded dependencies
+  # https://github.com/paritytech/libsecp256k1/issues/66
   --ignore RUSTSEC-2020-0146
 
+  # hyper: Lenient `hyper` header parsing of `Content-Length` could allow request smuggling
+  #
+  # Blocked on jsonrpc removing dependency on unmaintained `websocket`
+  # https://github.com/paritytech/jsonrpc/issues/605
+  --ignore RUSTSEC-2021-0078
+
+  # hyper: Integer overflow in `hyper`'s parsing of the `Transfer-Encoding` header leads to data loss
+  #
+  # Blocked on jsonrpc removing dependency on unmaintained `websocket`
+  # https://github.com/paritytech/jsonrpc/issues/605
+  --ignore RUSTSEC-2021-0079
+
   # chrono: Potential segfault in `localtime_r` invocations
   #
   # Blocked due to no safe upgrade

ci/docker-rust-nightly/Dockerfile

@@ -1,4 +1,4 @@
-FROM solanalabs/rust:1.59.0
+FROM solanalabs/rust:1.57.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.59.0
+FROM rust:1.57.0
 
 # Add Google Protocol Buffers for Libra's metrics library.
 ENV PROTOC_VERSION 3.8.0

ci/publish-tarball.sh

@@ -150,7 +150,7 @@ elif [[ -n $BUILDKITE ]]; then
   cat > release.solana.com-install <<EOF
 SOLANA_RELEASE=$CHANNEL_OR_TAG
 SOLANA_INSTALL_INIT_ARGS=$CHANNEL_OR_TAG
-SOLANA_DOWNLOAD_ROOT=https://release.solana.com
+SOLANA_DOWNLOAD_ROOT=http://release.solana.com
 EOF
   cat install/solana-install-init.sh >> release.solana.com-install
 

ci/run-sanity.sh

@@ -7,7 +7,7 @@ source multinode-demo/common.sh
 
 rm -rf config/run/init-completed config/ledger config/snapshot-ledger
 
-SOLANA_RUN_SH_VALIDATOR_ARGS="--full-snapshot-interval-slots 200" timeout 120 ./scripts/run.sh &
+SOLANA_RUN_SH_VALIDATOR_ARGS="--snapshot-interval-slots 200" timeout 120 ./scripts/run.sh &
 pid=$!
 
 attempts=20

ci/rust-version.sh

@@ -18,13 +18,13 @@
 if [[ -n $RUST_STABLE_VERSION ]]; then
   stable_version="$RUST_STABLE_VERSION"
 else
-  stable_version=1.59.0
+  stable_version=1.57.0
 fi
 
 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
   nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2022-02-24
+  nightly_version=2021-12-03
 fi
 
 

ci/sbf-tools-info.sh

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-#
-# Finds the version of sbf-tools used by this source tree.
-#
-# stdout of this script may be eval-ed.
-#
-
-here="$(dirname "$0")"
-
-SBF_TOOLS_VERSION=unknown
-
-cargo_build_bpf_main="${here}/../sdk/cargo-build-bpf/src/main.rs"
-if [[ -f "${cargo_build_bpf_main}" ]]; then
-    version=$(sed -e 's/^.*bpf_tools_version\s*=\s*"\(v[0-9.]\+\)".*/\1/;t;d' "${cargo_build_bpf_main}")
-    if [[ ${version} != '' ]]; then
-        SBF_TOOLS_VERSION="${version}"
-    else
-        echo '--- unable to parse SBF_TOOLS_VERSION'
-    fi
-else
-    echo "--- '${cargo_build_bpf_main}' not present"
-fi
-
-echo SBF_TOOLS_VERSION="${SBF_TOOLS_VERSION}"

ci/test-checks.sh

@@ -69,14 +69,20 @@ _ ci/order-crates-for-publishing.py
 # run nightly clippy for `sdk/` as there's a moderate amount of nightly-only code there
 _ "$cargo" nightly clippy -Zunstable-options --workspace --all-targets -- --deny=warnings --deny=clippy::integer_arithmetic
 
-_ "$cargo" nightly fmt --all -- --check
+_ "$cargo" stable fmt --all -- --check
 
 _ ci/do-audit.sh
 
 {
   cd programs/bpf
-  _ "$cargo" nightly clippy --all -- --deny=warnings --allow=clippy::missing_safety_doc
-  _ "$cargo" nightly fmt --all -- --check
+  for project in rust/*/ ; do
+    echo "+++ do_bpf_checks $project"
+    (
+      cd "$project"
+      _ "$cargo" nightly clippy -- --deny=warnings --allow=clippy::missing_safety_doc
+      _ "$cargo" stable fmt -- --check
+    )
+  done
 }
 
 echo --- ok

ci/test-stable.sh

@@ -21,16 +21,15 @@ export RUST_BACKTRACE=1
 export RUSTFLAGS="-D warnings"
 source scripts/ulimit-n.sh
 
-# limit jobs to 4gb/thread
-JOBS=$(grep MemTotal /proc/meminfo | awk '{printf "%.0f", ($2 / (4 * 1024 * 1024))}')
+# Limit compiler jobs to reduce memory usage
+# on machines with 2gb/thread of memory
 NPROC=$(nproc)
-JOBS=$((JOBS>NPROC ? NPROC : JOBS))
-
+NPROC=$((NPROC>14 ? 14 : NPROC))
 
 echo "Executing $testName"
 case $testName in
 test-stable)
-  _ "$cargo" stable test --jobs "$JOBS" --all --exclude solana-local-cluster ${V:+--verbose} -- --nocapture
+  _ "$cargo" stable test --jobs "$NPROC" --all --exclude solana-local-cluster ${V:+--verbose} -- --nocapture
   ;;
 test-stable-bpf)
   # Clear the C dependency files, if dependency moves these files are not regenerated

clap-utils/Cargo.toml

@@ -13,7 +13,7 @@ edition = "2021"
 clap = "2.33.0"
 rpassword = "5.0"
 solana-perf = { path = "../perf", version = "=1.10.0" }
-solana-remote-wallet = { path = "../remote-wallet", version = "=1.10.0", default-features = false}
+solana-remote-wallet = { path = "../remote-wallet", version = "=1.10.0" }
 solana-sdk = { path = "../sdk", version = "=1.10.0" }
 thiserror = "1.0.30"
 tiny-bip39 = "0.8.2"
@@ -22,7 +22,7 @@ url = "2.2.2"
 chrono = "0.4"
 
 [dev-dependencies]
-tempfile = "3.3.0"
+tempfile = "3.2.0"
 
 [lib]
 name = "solana_clap_utils"

clap-utils/src/input_validators.rs

@@ -328,7 +328,7 @@ pub fn is_derivation<T>(value: T) -> Result<(), String>
 where
     T: AsRef<str> + Display,
 {
-    let value = value.as_ref().replace('\'', "");
+    let value = value.as_ref().replace("'", "");
     let mut parts = value.split('/');
     let account = parts.next().unwrap();
     account

cli-config/Cargo.toml

@@ -12,13 +12,13 @@ documentation = "https://docs.rs/solana-cli-config"
 [dependencies]
 dirs-next = "2.0.0"
 lazy_static = "1.4.0"
-serde = "1.0.136"
+serde = "1.0.133"
 serde_derive = "1.0.103"
 serde_yaml = "0.8.23"
 url = "2.2.2"
 
 [dev-dependencies]
-anyhow = "1.0.55"
+anyhow = "1.0.52"
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

cli-output/Cargo.toml

@@ -17,8 +17,8 @@ console = "0.15.0"
 humantime = "2.0.1"
 Inflector = "0.11.4"
 indicatif = "0.16.2"
-serde = "1.0.136"
-serde_json = "1.0.78"
+serde = "1.0.133"
+serde_json = "1.0.74"
 solana-account-decoder = { path = "../account-decoder", version = "=1.10.0" }
 solana-clap-utils = { path = "../clap-utils", version = "=1.10.0" }
 solana-client = { path = "../client", version = "=1.10.0" }

cli-output/src/cli_output.rs

@@ -46,8 +46,6 @@ use {
     },
 };
 
-static CHECK_MARK: Emoji = Emoji("✅ ", "");
-static CROSS_MARK: Emoji = Emoji("❌ ", "");
 static WARNING: Emoji = Emoji("⚠️", "!");
 
 #[derive(PartialEq, Debug)]
@@ -393,19 +391,19 @@ impl fmt::Display for CliValidators {
         ) -> fmt::Result {
             fn non_zero_or_dash(v: u64, max_v: u64) -> String {
                 if v == 0 {
-                    "        -      ".into()
+                    "-         ".into()
                 } else if v == max_v {
-                    format!("{:>9} (  0)", v)
+                    format!("{:>8} (  0)", v)
                 } else if v > max_v.saturating_sub(100) {
-                    format!("{:>9} ({:>3})", v, -(max_v.saturating_sub(v) as isize))
+                    format!("{:>8} ({:>3})", v, -(max_v.saturating_sub(v) as isize))
                 } else {
-                    format!("{:>9}      ", v)
+                    format!("{:>8}      ", v)
                 }
             }
 
             writeln!(
                 f,
-                "{} {:<44}  {:<44}  {:>3}%  {:>14}  {:>14} {:>7} {:>8}  {:>7}  {:>22} ({:.2}%)",
+                "{} {:<44}  {:<44}  {:>3}%  {:>14}  {:>14} {:>7} {:>8}  {:>7}  {}",
                 if validator.delinquent {
                     WARNING.to_string()
                 } else {
@@ -419,19 +417,19 @@ impl fmt::Display for CliValidators {
                 if let Some(skip_rate) = validator.skip_rate {
                     format!("{:.2}%", skip_rate)
                 } else {
-                    "-   ".to_string()
+                    "- ".to_string()
                 },
                 validator.epoch_credits,
                 validator.version,
-                build_balance_message_with_config(
-                    validator.activated_stake,
-                    &BuildBalanceMessageConfig {
-                        use_lamports_unit,
-                        trim_trailing_zeros: false,
-                        ..BuildBalanceMessageConfig::default()
-                    }
-                ),
-                100. * validator.activated_stake as f64 / total_active_stake as f64,
+                if validator.activated_stake > 0 {
+                    format!(
+                        "{} ({:.2}%)",
+                        build_balance_message(validator.activated_stake, use_lamports_unit, true),
+                        100. * validator.activated_stake as f64 / total_active_stake as f64,
+                    )
+                } else {
+                    "-".into()
+                },
             )
         }
 
@@ -441,13 +439,13 @@ impl fmt::Display for CliValidators {
             0
         };
         let header = style(format!(
-            "{:padding$} {:<44}  {:<38}  {}  {}  {} {}  {}  {}    {}",
+            "{:padding$} {:<44}  {:<38}  {}  {}  {} {}  {}  {}  {}",
             " ",
             "Identity",
             "Vote Account",
             "Commission",
-            "Last Vote      ",
-            "Root Slot    ",
+            "Last Vote     ",
+            "Root Slot   ",
             "Skip Rate",
             "Credits",
             "Version",
@@ -2287,7 +2285,6 @@ impl fmt::Display for CliBlock {
                 let sign = if reward.lamports < 0 { "-" } else { "" };
 
                 total_rewards += reward.lamports;
-                #[allow(clippy::format_in_format_args)]
                 writeln!(
                     f,
                     "  {:<44}  {:^15}  {:>15}  {}  {}",
@@ -2451,8 +2448,6 @@ pub struct CliGossipNode {
     pub rpc_host: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub version: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub feature_set: Option<u32>,
 }
 
 impl CliGossipNode {
@@ -2465,7 +2460,6 @@ impl CliGossipNode {
             tpu_port: info.tpu.map(|addr| addr.port()),
             rpc_host: info.rpc.map(|addr| addr.to_string()),
             version: info.version,
-            feature_set: info.feature_set,
         }
     }
 }
@@ -2491,7 +2485,7 @@ impl fmt::Display for CliGossipNode {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "{:15} | {:44} | {:6} | {:5} | {:21} | {:8}| {}",
+            "{:15} | {:44} | {:6} | {:5} | {:21} | {}",
             unwrap_to_string_or_none(self.ip_address.as_ref()),
             self.identity_label
                 .as_ref()
@@ -2500,7 +2494,6 @@ impl fmt::Display for CliGossipNode {
             unwrap_to_string_or_none(self.tpu_port.as_ref()),
             unwrap_to_string_or_none(self.rpc_host.as_ref()),
             unwrap_to_string_or_default(self.version.as_ref(), "unknown"),
-            unwrap_to_string_or_default(self.feature_set.as_ref(), "unknown"),
         )
     }
 }
@@ -2515,10 +2508,10 @@ impl fmt::Display for CliGossipNodes {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(
             f,
-            "IP Address      | Identity                                     \
-             | Gossip | TPU   | RPC Address           | Version | Feature Set\n\
+            "IP Address      | Node identifier                              \
+             | Gossip | TPU   | RPC Address           | Version\n\
              ----------------+----------------------------------------------+\
-             --------+-------+-----------------------+---------+----------------",
+             --------+-------+-----------------------+----------------",
         )?;
         for node in self.0.iter() {
             writeln!(f, "{}", node)?;
@@ -2530,172 +2523,6 @@ impl fmt::Display for CliGossipNodes {
 impl QuietDisplay for CliGossipNodes {}
 impl VerboseDisplay for CliGossipNodes {}
 
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliPing {
-    pub source_pubkey: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub fixed_blockhash: Option<String>,
-    #[serde(skip_serializing)]
-    pub blockhash_from_cluster: bool,
-    pub pings: Vec<CliPingData>,
-    pub transaction_stats: CliPingTxStats,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub confirmation_stats: Option<CliPingConfirmationStats>,
-}
-
-impl fmt::Display for CliPing {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Source Account:", &self.source_pubkey)?;
-        if let Some(fixed_blockhash) = &self.fixed_blockhash {
-            let blockhash_origin = if self.blockhash_from_cluster {
-                "fetched from cluster"
-            } else {
-                "supplied from cli arguments"
-            };
-            writeln!(
-                f,
-                "Fixed blockhash is used: {} ({})",
-                fixed_blockhash, blockhash_origin
-            )?;
-        }
-        writeln!(f)?;
-        for ping in &self.pings {
-            write!(f, "{}", ping)?;
-        }
-        writeln!(f)?;
-        writeln!(f, "--- transaction statistics ---")?;
-        write!(f, "{}", self.transaction_stats)?;
-        if let Some(confirmation_stats) = &self.confirmation_stats {
-            write!(f, "{}", confirmation_stats)?;
-        }
-        Ok(())
-    }
-}
-
-impl QuietDisplay for CliPing {}
-impl VerboseDisplay for CliPing {}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliPingData {
-    pub success: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub signature: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ms: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error: Option<String>,
-    #[serde(skip_serializing)]
-    pub print_timestamp: bool,
-    pub timestamp: String,
-    pub sequence: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub lamports: Option<u64>,
-}
-impl fmt::Display for CliPingData {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let (mark, msg) = if let Some(signature) = &self.signature {
-            if self.success {
-                (
-                    CHECK_MARK,
-                    format!(
-                        "{} lamport(s) transferred: seq={:<3} time={:>4}ms signature={}",
-                        self.lamports.unwrap(),
-                        self.sequence,
-                        self.ms.unwrap(),
-                        signature
-                    ),
-                )
-            } else if let Some(error) = &self.error {
-                (
-                    CROSS_MARK,
-                    format!(
-                        "Transaction failed:    seq={:<3} error={:?} signature={}",
-                        self.sequence, error, signature
-                    ),
-                )
-            } else {
-                (
-                    CROSS_MARK,
-                    format!(
-                        "Confirmation timeout:  seq={:<3}             signature={}",
-                        self.sequence, signature
-                    ),
-                )
-            }
-        } else {
-            (
-                CROSS_MARK,
-                format!(
-                    "Submit failed:         seq={:<3} error={:?}",
-                    self.sequence,
-                    self.error.as_ref().unwrap(),
-                ),
-            )
-        };
-
-        writeln!(
-            f,
-            "{}{}{}",
-            if self.print_timestamp {
-                &self.timestamp
-            } else {
-                ""
-            },
-            mark,
-            msg
-        )
-    }
-}
-
-impl QuietDisplay for CliPingData {}
-impl VerboseDisplay for CliPingData {}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliPingTxStats {
-    pub num_transactions: u32,
-    pub num_transaction_confirmed: u32,
-}
-impl fmt::Display for CliPingTxStats {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(
-            f,
-            "{} transactions submitted, {} transactions confirmed, {:.1}% transaction loss",
-            self.num_transactions,
-            self.num_transaction_confirmed,
-            (100.
-                - f64::from(self.num_transaction_confirmed) / f64::from(self.num_transactions)
-                    * 100.)
-        )
-    }
-}
-
-impl QuietDisplay for CliPingTxStats {}
-impl VerboseDisplay for CliPingTxStats {}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliPingConfirmationStats {
-    pub min: f64,
-    pub mean: f64,
-    pub max: f64,
-    pub std_dev: f64,
-}
-impl fmt::Display for CliPingConfirmationStats {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(
-            f,
-            "confirmation min/mean/max/stddev = {:.0}/{:.0}/{:.0}/{:.0} ms",
-            self.min, self.mean, self.max, self.std_dev,
-        )
-    }
-}
-impl QuietDisplay for CliPingConfirmationStats {}
-impl VerboseDisplay for CliPingConfirmationStats {}
-
 #[cfg(test)]
 mod tests {
     use {

cli/Cargo.toml

@@ -17,16 +17,15 @@ criterion-stats = "0.3.0"
 ctrlc = { version = "3.2.1", features = ["termination"] }
 console = "0.15.0"
 const_format = "0.2.22"
-crossbeam-channel = "0.5"
 log = "0.4.14"
 humantime = "2.0.1"
 num-traits = "0.2"
 pretty-hex = "0.2.1"
-reqwest = { version = "0.11.9", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-semver = "1.0.6"
-serde = "1.0.136"
+reqwest = { version = "0.11.6", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+semver = "1.0.4"
+serde = "1.0.133"
 serde_derive = "1.0.103"
-serde_json = "1.0.78"
+serde_json = "1.0.74"
 solana-account-decoder = { path = "../account-decoder", version = "=1.10.0" }
 solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "=1.10.0" }
 solana-clap-utils = { path = "../clap-utils", version = "=1.10.0" }
@@ -37,7 +36,7 @@ solana-config-program = { path = "../programs/config", version = "=1.10.0" }
 solana-faucet = { path = "../faucet", version = "=1.10.0" }
 solana-logger = { path = "../logger", version = "=1.10.0" }
 solana-program-runtime = { path = "../program-runtime", version = "=1.10.0" }
-solana_rbpf = "=0.2.24"
+solana_rbpf = "=0.2.21"
 solana-remote-wallet = { path = "../remote-wallet", version = "=1.10.0" }
 solana-sdk = { path = "../sdk", version = "=1.10.0" }
 solana-transaction-status = { path = "../transaction-status", version = "=1.10.0" }
@@ -50,7 +49,7 @@ tiny-bip39 = "0.8.2"
 [dev-dependencies]
 solana-streamer = { path = "../streamer", version = "=1.10.0" }
 solana-test-validator = { path = "../test-validator", version = "=1.10.0" }
-tempfile = "3.3.0"
+tempfile = "3.2.0"
 
 [[bin]]
 name = "solana"

cli/src/cli.rs

@@ -83,6 +83,7 @@ pub enum CliCommand {
         filter: RpcTransactionLogsFilter,
     },
     Ping {
+        lamports: u64,
         interval: Duration,
         count: Option<u64>,
         timeout: Duration,
@@ -972,6 +973,7 @@ pub fn process_command(config: &CliConfig) -> ProcessResult {
         CliCommand::LiveSlots => process_live_slots(config),
         CliCommand::Logs { filter } => process_logs(config, filter),
         CliCommand::Ping {
+            lamports,
             interval,
             count,
             timeout,
@@ -980,6 +982,7 @@ pub fn process_command(config: &CliConfig) -> ProcessResult {
         } => process_ping(
             &rpc_client,
             config,
+            *lamports,
             interval,
             count,
             timeout,
@@ -1706,7 +1709,7 @@ mod tests {
         serde_json::{json, Value},
         solana_client::{
             blockhash_query,
-            mock_sender_for_cli::SIGNATURE,
+            mock_sender::SIGNATURE,
             rpc_request::RpcRequest,
             rpc_response::{Response, RpcResponseContext},
         },

cli/src/cluster_query.rs

@@ -4,8 +4,7 @@ use {
         spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
     },
     clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand},
-    console::style,
-    crossbeam_channel::unbounded,
+    console::{style, Emoji},
     serde::{Deserialize, Serialize},
     solana_clap_utils::{
         input_parsers::*,
@@ -16,7 +15,7 @@ use {
     solana_cli_output::{
         display::{
             build_balance_message, format_labeled_address, new_spinner_progress_bar,
-            println_transaction, unix_timestamp_to_string, writeln_name_value,
+            println_name_value, println_transaction, unix_timestamp_to_string, writeln_name_value,
         },
         *,
     },
@@ -44,13 +43,13 @@ use {
         message::Message,
         native_token::lamports_to_sol,
         nonce::State as NonceState,
-        pubkey::Pubkey,
+        pubkey::{self, Pubkey},
         rent::Rent,
         rpc_port::DEFAULT_RPC_PORT_STR,
         signature::Signature,
         slot_history,
         stake::{self, state::StakeState},
-        system_instruction,
+        system_instruction, system_program,
         sysvar::{
             self,
             slot_history::SlotHistory,
@@ -75,6 +74,9 @@ use {
     thiserror::Error,
 };
 
+static CHECK_MARK: Emoji = Emoji("✅ ", "");
+static CROSS_MARK: Emoji = Emoji("❌ ", "");
+
 pub trait ClusterQuerySubCommands {
     fn cluster_query_subcommands(self) -> Self;
 }
@@ -260,6 +262,15 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                         .takes_value(false)
                         .help("Print timestamp (unix time + microseconds as in gettimeofday) before each line"),
                 )
+                .arg(
+                    Arg::with_name("lamports")
+                        .long("lamports")
+                        .value_name("NUMBER")
+                        .takes_value(true)
+                        .default_value("1")
+                        .validator(is_amount)
+                        .help("Number of lamports to transfer for each transaction"),
+                )
                 .arg(
                     Arg::with_name("timeout")
                         .short("t")
@@ -504,6 +515,7 @@ pub fn parse_cluster_ping(
     default_signer: &DefaultSigner,
     wallet_manager: &mut 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));
     let count = if matches.is_present("count") {
         Some(value_t_or_exit!(matches, "count", u64))
@@ -515,6 +527,7 @@ pub fn parse_cluster_ping(
     let print_timestamp = matches.is_present("print_timestamp");
     Ok(CliCommandInfo {
         command: CliCommand::Ping {
+            lamports,
             interval,
             count,
             timeout,
@@ -1345,34 +1358,40 @@ pub fn process_get_transaction_count(rpc_client: &RpcClient, _config: &CliConfig
 pub fn process_ping(
     rpc_client: &RpcClient,
     config: &CliConfig,
+    lamports: u64,
     interval: &Duration,
     count: &Option<u64>,
     timeout: &Duration,
     fixed_blockhash: &Option<Hash>,
     print_timestamp: bool,
 ) -> ProcessResult {
-    let (signal_sender, signal_receiver) = unbounded();
+    println_name_value("Source Account:", &config.signers[0].pubkey().to_string());
+    println!();
+
+    let (signal_sender, signal_receiver) = std::sync::mpsc::channel();
     ctrlc::set_handler(move || {
         let _ = signal_sender.send(());
     })
     .expect("Error setting Ctrl-C handler");
 
-    let mut cli_pings = vec![];
-
     let mut submit_count = 0;
     let mut confirmed_count = 0;
     let mut confirmation_time: VecDeque<u64> = VecDeque::with_capacity(1024);
 
     let mut blockhash = rpc_client.get_latest_blockhash()?;
-    let mut lamports = 0;
+    let mut blockhash_transaction_count = 0;
     let mut blockhash_acquired = Instant::now();
-    let mut blockhash_from_cluster = false;
     if let Some(fixed_blockhash) = fixed_blockhash {
-        if *fixed_blockhash != Hash::default() {
+        let blockhash_origin = if *fixed_blockhash != Hash::default() {
             blockhash = *fixed_blockhash;
+            "supplied from cli arguments"
         } else {
-            blockhash_from_cluster = true;
-        }
+            "fetched from cluster"
+        };
+        println!(
+            "Fixed blockhash is used: {} ({})",
+            blockhash, blockhash_origin
+        );
     }
     'mainloop: for seq in 0..count.unwrap_or(std::u64::MAX) {
         let now = Instant::now();
@@ -1380,12 +1399,15 @@ pub fn process_ping(
             // Fetch a new blockhash every minute
             let new_blockhash = rpc_client.get_new_latest_blockhash(&blockhash)?;
             blockhash = new_blockhash;
-            lamports = 0;
+            blockhash_transaction_count = 0;
             blockhash_acquired = Instant::now();
         }
 
-        let to = config.signers[0].pubkey();
-        lamports += 1;
+        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);
@@ -1408,7 +1430,11 @@ pub fn process_ping(
                 .duration_since(UNIX_EPOCH)
                 .unwrap()
                 .as_micros();
-            format!("[{}.{:06}] ", micros / 1_000_000, micros % 1_000_000)
+            if print_timestamp {
+                format!("[{}.{:06}] ", micros / 1_000_000, micros % 1_000_000)
+            } else {
+                String::new()
+            }
         };
 
         match rpc_client.send_transaction(&tx) {
@@ -1422,51 +1448,35 @@ pub fn process_ping(
                             Ok(()) => {
                                 let elapsed_time_millis = elapsed_time.as_millis() as u64;
                                 confirmation_time.push_back(elapsed_time_millis);
-                                let cli_ping_data = CliPingData {
-                                    success: true,
-                                    signature: Some(signature.to_string()),
-                                    ms: Some(elapsed_time_millis),
-                                    error: None,
-                                    timestamp: timestamp(),
-                                    print_timestamp,
-                                    sequence: seq,
-                                    lamports: Some(lamports),
-                                };
-                                eprint!("{}", cli_ping_data);
-                                cli_pings.push(cli_ping_data);
+                                println!(
+                                    "{}{}{} lamport(s) transferred: seq={:<3} time={:>4}ms signature={}",
+                                    timestamp(),
+                                    CHECK_MARK, lamports, seq, elapsed_time_millis, signature
+                                );
                                 confirmed_count += 1;
                             }
                             Err(err) => {
-                                let cli_ping_data = CliPingData {
-                                    success: false,
-                                    signature: Some(signature.to_string()),
-                                    ms: None,
-                                    error: Some(err.to_string()),
-                                    timestamp: timestamp(),
-                                    print_timestamp,
-                                    sequence: seq,
-                                    lamports: None,
-                                };
-                                eprint!("{}", cli_ping_data);
-                                cli_pings.push(cli_ping_data);
+                                println!(
+                                    "{}{}Transaction failed:    seq={:<3} error={:?} signature={}",
+                                    timestamp(),
+                                    CROSS_MARK,
+                                    seq,
+                                    err,
+                                    signature
+                                );
                             }
                         }
                         break;
                     }
 
                     if elapsed_time >= *timeout {
-                        let cli_ping_data = CliPingData {
-                            success: false,
-                            signature: Some(signature.to_string()),
-                            ms: None,
-                            error: None,
-                            timestamp: timestamp(),
-                            print_timestamp,
-                            sequence: seq,
-                            lamports: None,
-                        };
-                        eprint!("{}", cli_ping_data);
-                        cli_pings.push(cli_ping_data);
+                        println!(
+                            "{}{}Confirmation timeout:  seq={:<3}             signature={}",
+                            timestamp(),
+                            CROSS_MARK,
+                            seq,
+                            signature
+                        );
                         break;
                     }
 
@@ -1480,18 +1490,13 @@ pub fn process_ping(
                 }
             }
             Err(err) => {
-                let cli_ping_data = CliPingData {
-                    success: false,
-                    signature: None,
-                    ms: None,
-                    error: Some(err.to_string()),
-                    timestamp: timestamp(),
-                    print_timestamp,
-                    sequence: seq,
-                    lamports: None,
-                };
-                eprint!("{}", cli_ping_data);
-                cli_pings.push(cli_ping_data);
+                println!(
+                    "{}{}Submit failed:         seq={:<3} error={:?}",
+                    timestamp(),
+                    CROSS_MARK,
+                    seq,
+                    err
+                );
             }
         }
         submit_count += 1;
@@ -1501,34 +1506,28 @@ pub fn process_ping(
         }
     }
 
-    let transaction_stats = CliPingTxStats {
-        num_transactions: submit_count,
-        num_transaction_confirmed: confirmed_count,
-    };
-    let confirmation_stats = if !confirmation_time.is_empty() {
+    println!();
+    println!("--- transaction statistics ---");
+    println!(
+        "{} transactions submitted, {} transactions confirmed, {:.1}% transaction loss",
+        submit_count,
+        confirmed_count,
+        (100. - f64::from(confirmed_count) / f64::from(submit_count) * 100.)
+    );
+    if !confirmation_time.is_empty() {
         let samples: Vec<f64> = confirmation_time.iter().map(|t| *t as f64).collect();
         let dist = criterion_stats::Distribution::from(samples.into_boxed_slice());
         let mean = dist.mean();
-        Some(CliPingConfirmationStats {
-            min: dist.min(),
+        println!(
+            "confirmation min/mean/max/stddev = {:.0}/{:.0}/{:.0}/{:.0} ms",
+            dist.min(),
             mean,
-            max: dist.max(),
-            std_dev: dist.std_dev(Some(mean)),
-        })
-    } else {
-        None
-    };
+            dist.max(),
+            dist.std_dev(Some(mean))
+        );
+    }
 
-    let cli_ping = CliPing {
-        source_pubkey: config.signers[0].pubkey().to_string(),
-        fixed_blockhash: fixed_blockhash.map(|_| blockhash.to_string()),
-        blockhash_from_cluster,
-        pings: cli_pings,
-        transaction_stats,
-        confirmation_stats,
-    };
-
-    Ok(config.output_format.formatted_string(&cli_ping))
+    Ok("".to_string())
 }
 
 pub fn parse_logs(
@@ -2129,7 +2128,7 @@ pub fn process_calculate_rent(
         timing::years_as_slots(1.0, &seconds_per_tick, clock::DEFAULT_TICKS_PER_SLOT);
     let slots_per_epoch = epoch_schedule.slots_per_epoch as f64;
     let years_per_epoch = slots_per_epoch / slots_per_year;
-    let lamports_per_epoch = rent.due(0, data_length, years_per_epoch).lamports();
+    let (lamports_per_epoch, _) = rent.due(0, data_length, years_per_epoch);
     let cli_rent_calculation = CliRentCalculation {
         lamports_per_byte_year: rent.lamports_per_byte_year,
         lamports_per_epoch,
@@ -2305,6 +2304,7 @@ mod tests {
             parse_command(&test_ping, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Ping {
+                    lamports: 1,
                     interval: Duration::from_secs(1),
                     count: Some(2),
                     timeout: Duration::from_secs(3),

cli/src/nonce.rs

@@ -334,17 +334,9 @@ pub fn check_nonce_account(
     match state_from_account(nonce_account)? {
         State::Initialized(ref data) => {
             if &data.blockhash != nonce_hash {
-                Err(Error::InvalidHash {
-                    provided: *nonce_hash,
-                    expected: data.blockhash,
-                }
-                .into())
+                Err(Error::InvalidHash.into())
             } else if nonce_authority != &data.authority {
-                Err(Error::InvalidAuthority {
-                    provided: *nonce_authority,
-                    expected: data.authority,
-                }
-                .into())
+                Err(Error::InvalidAuthority.into())
             } else {
                 Ok(())
             }
@@ -954,22 +946,15 @@ mod tests {
             hash(b"invalid"),
             0,
         )));
-        let invalid_hash = Account::new_data(1, &data, &system_program::ID).unwrap();
+        let invalid_hash = Account::new_data(1, &data, &system_program::ID);
         if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_hash, &nonce_pubkey, &blockhash).unwrap_err()
+            check_nonce_account(&invalid_hash.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
         {
-            assert_eq!(
-                err,
-                Error::InvalidHash {
-                    provided: blockhash,
-                    expected: hash(b"invalid"),
-                }
-            );
+            assert_eq!(err, Error::InvalidHash,);
         }
 
-        let new_nonce_authority = solana_sdk::pubkey::new_rand();
         let data = Versions::new_current(State::Initialized(nonce::state::Data::new(
-            new_nonce_authority,
+            solana_sdk::pubkey::new_rand(),
             blockhash,
             0,
         )));
@@ -977,13 +962,7 @@ mod tests {
         if let CliError::InvalidNonce(err) =
             check_nonce_account(&invalid_authority.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
         {
-            assert_eq!(
-                err,
-                Error::InvalidAuthority {
-                    provided: nonce_pubkey,
-                    expected: new_nonce_authority,
-                }
-            );
+            assert_eq!(err, Error::InvalidAuthority,);
         }
 
         let data = Versions::new_current(State::Uninitialized);

cli/src/program.rs

@@ -1991,7 +1991,7 @@ fn read_and_verify_elf(program_location: &str) -> Result<Vec<u8>, Box<dyn std::e
     let mut program_data = Vec::new();
     file.read_to_end(&mut program_data)
         .map_err(|err| format!("Unable to read program file: {}", err))?;
-    let mut transaction_context = TransactionContext::new(Vec::new(), 1, 1);
+    let mut transaction_context = TransactionContext::new(Vec::new(), 1);
     let mut invoke_context = InvokeContext::new_mock(&mut transaction_context, &[]);
 
     // Verify the program
@@ -1999,7 +1999,10 @@ fn read_and_verify_elf(program_location: &str) -> Result<Vec<u8>, Box<dyn std::e
         &program_data,
         Some(verifier::check),
         Config {
-            reject_broken_elfs: true,
+            reject_unresolved_syscalls: true,
+            verify_mul64_imm_nonzero: false,
+            verify_shift32_imm: true,
+            reject_section_virtual_address_file_offset_mismatch: true,
             ..Config::default()
         },
         register_syscalls(&mut invoke_context).unwrap(),

cli/src/stake.rs

@@ -1384,13 +1384,7 @@ pub fn process_stake_authorize(
             if let Some(authorized) = authorized {
                 match authorization_type {
                     StakeAuthorize::Staker => {
-                        // first check authorized withdrawer
-                        check_current_authority(&authorized.withdrawer, &authority.pubkey())
-                            .or_else(|_| {
-                                // ...then check authorized staker. If neither matches, error will
-                                // print the stake key as `expected`
-                                check_current_authority(&authorized.staker, &authority.pubkey())
-                            })?;
+                        check_current_authority(&authorized.staker, &authority.pubkey())?;
                     }
                     StakeAuthorize::Withdrawer => {
                         check_current_authority(&authorized.withdrawer, &authority.pubkey())?;

cli/src/test_utils.rs

@@ -1,29 +1,23 @@
 use {
     solana_client::rpc_client::RpcClient,
-    solana_sdk::{clock::DEFAULT_MS_PER_SLOT, commitment_config::CommitmentConfig},
+    solana_sdk::{clock::DEFAULT_MS_PER_SLOT, commitment_config::CommitmentConfig, pubkey::Pubkey},
     std::{thread::sleep, time::Duration},
 };
 
-#[macro_export]
-macro_rules! check_balance {
-    ($expected_balance:expr, $client:expr, $pubkey:expr) => {
-        (0..5).for_each(|tries| {
-            let balance = $client
-                .get_balance_with_commitment($pubkey, CommitmentConfig::processed())
-                .unwrap()
-                .value;
-            if balance == $expected_balance {
-                return;
-            }
-            if tries == 4 {
-                assert_eq!(balance, $expected_balance);
-            }
-            std::thread::sleep(std::time::Duration::from_millis(500));
-        });
-    };
-    ($expected_balance:expr, $client:expr, $pubkey:expr,) => {
-        check_balance!($expected_balance, $client, $pubkey)
-    };
+pub fn check_recent_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
+    (0..5).for_each(|tries| {
+        let balance = client
+            .get_balance_with_commitment(pubkey, CommitmentConfig::processed())
+            .unwrap()
+            .value;
+        if balance == expected_balance {
+            return;
+        }
+        if tries == 4 {
+            assert_eq!(balance, expected_balance);
+        }
+        sleep(Duration::from_millis(500));
+    });
 }
 
 pub fn check_ready(rpc_client: &RpcClient) {

cli/src/vote.rs

@@ -35,8 +35,7 @@ use {
         transaction::Transaction,
     },
     solana_vote_program::{
-        vote_error::VoteError,
-        vote_instruction::{self, withdraw},
+        vote_instruction::{self, withdraw, VoteError},
         vote_state::{VoteAuthorize, VoteInit, VoteState},
     },
     std::sync::Arc,

cli/src/wallet.rs

@@ -273,14 +273,11 @@ impl WalletSubCommands for App<'_, '_> {
 }
 
 fn resolve_derived_address_program_id(matches: &ArgMatches<'_>, arg_name: &str) -> Option<Pubkey> {
-    matches.value_of(arg_name).and_then(|v| {
-        let upper = v.to_ascii_uppercase();
-        match upper.as_str() {
-            "NONCE" | "SYSTEM" => Some(system_program::id()),
-            "STAKE" => Some(stake::program::id()),
-            "VOTE" => Some(solana_vote_program::id()),
-            _ => pubkey_of(matches, arg_name),
-        }
+    matches.value_of(arg_name).and_then(|v| match v {
+        "NONCE" => Some(system_program::id()),
+        "STAKE" => Some(stake::program::id()),
+        "VOTE" => Some(solana_vote_program::id()),
+        _ => pubkey_of(matches, arg_name),
     })
 }
 

cli/tests/nonce.rs

@@ -1,10 +1,8 @@
-#![allow(clippy::integer_arithmetic)]
 use {
     solana_cli::{
-        check_balance,
         cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
         spend_utils::SpendAmount,
-        test_utils::check_ready,
+        test_utils::{check_ready, check_recent_balance},
     },
     solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
     solana_client::{
@@ -16,7 +14,6 @@ use {
     solana_sdk::{
         commitment_config::CommitmentConfig,
         hash::Hash,
-        native_token::sol_to_lamports,
         pubkey::Pubkey,
         signature::{keypair_from_seed, Keypair, Signer},
         system_program,
@@ -76,14 +73,10 @@ fn full_battery_tests(
         &rpc_client,
         &config_payer,
         &config_payer.signers[0].pubkey(),
-        sol_to_lamports(2000.0),
+        2000,
     )
     .unwrap();
-    check_balance!(
-        sol_to_lamports(2000.0),
-        &rpc_client,
-        &config_payer.signers[0].pubkey(),
-    );
+    check_recent_balance(2000, &rpc_client, &config_payer.signers[0].pubkey());
 
     let mut config_nonce = CliConfig::recent_for_tests();
     config_nonce.json_rpc_url = json_rpc_url;
@@ -115,16 +108,12 @@ fn full_battery_tests(
         seed,
         nonce_authority: optional_authority,
         memo: None,
-        amount: SpendAmount::Some(sol_to_lamports(1000.0)),
+        amount: SpendAmount::Some(1000),
     };
 
     process_command(&config_payer).unwrap();
-    check_balance!(
-        sol_to_lamports(1000.0),
-        &rpc_client,
-        &config_payer.signers[0].pubkey(),
-    );
-    check_balance!(sol_to_lamports(1000.0), &rpc_client, &nonce_account);
+    check_recent_balance(1000, &rpc_client, &config_payer.signers[0].pubkey());
+    check_recent_balance(1000, &rpc_client, &nonce_account);
 
     // Get nonce
     config_payer.signers.pop();
@@ -172,16 +161,12 @@ fn full_battery_tests(
         nonce_authority: index,
         memo: None,
         destination_account_pubkey: payee_pubkey,
-        lamports: sol_to_lamports(100.0),
+        lamports: 100,
     };
     process_command(&config_payer).unwrap();
-    check_balance!(
-        sol_to_lamports(1000.0),
-        &rpc_client,
-        &config_payer.signers[0].pubkey(),
-    );
-    check_balance!(sol_to_lamports(900.0), &rpc_client, &nonce_account);
-    check_balance!(sol_to_lamports(100.0), &rpc_client, &payee_pubkey);
+    check_recent_balance(1000, &rpc_client, &config_payer.signers[0].pubkey());
+    check_recent_balance(900, &rpc_client, &nonce_account);
+    check_recent_balance(100, &rpc_client, &payee_pubkey);
 
     // Show nonce account
     config_payer.command = CliCommand::ShowNonceAccount {
@@ -223,22 +208,17 @@ fn full_battery_tests(
         nonce_authority: 1,
         memo: None,
         destination_account_pubkey: payee_pubkey,
-        lamports: sol_to_lamports(100.0),
+        lamports: 100,
     };
     process_command(&config_payer).unwrap();
-    check_balance!(
-        sol_to_lamports(1000.0),
-        &rpc_client,
-        &config_payer.signers[0].pubkey(),
-    );
-    check_balance!(sol_to_lamports(800.0), &rpc_client, &nonce_account);
-    check_balance!(sol_to_lamports(200.0), &rpc_client, &payee_pubkey);
+    check_recent_balance(1000, &rpc_client, &config_payer.signers[0].pubkey());
+    check_recent_balance(800, &rpc_client, &nonce_account);
+    check_recent_balance(200, &rpc_client, &payee_pubkey);
 }
 
 #[test]
 #[allow(clippy::redundant_closure)]
 fn test_create_account_with_seed() {
-    const ONE_SIG_FEE: f64 = 0.000005;
     solana_logger::setup();
     let mint_keypair = Keypair::new();
     let mint_pubkey = mint_keypair.pubkey();
@@ -261,27 +241,19 @@ fn test_create_account_with_seed() {
         &rpc_client,
         &CliConfig::recent_for_tests(),
         &offline_nonce_authority_signer.pubkey(),
-        sol_to_lamports(42.0),
+        42,
     )
     .unwrap();
     request_and_confirm_airdrop(
         &rpc_client,
         &CliConfig::recent_for_tests(),
         &online_nonce_creator_signer.pubkey(),
-        sol_to_lamports(4242.0),
+        4242,
     )
     .unwrap();
-    check_balance!(
-        sol_to_lamports(42.0),
-        &rpc_client,
-        &offline_nonce_authority_signer.pubkey(),
-    );
-    check_balance!(
-        sol_to_lamports(4242.0),
-        &rpc_client,
-        &online_nonce_creator_signer.pubkey(),
-    );
-    check_balance!(0, &rpc_client, &to_address);
+    check_recent_balance(42, &rpc_client, &offline_nonce_authority_signer.pubkey());
+    check_recent_balance(4242, &rpc_client, &online_nonce_creator_signer.pubkey());
+    check_recent_balance(0, &rpc_client, &to_address);
 
     check_ready(&rpc_client);
 
@@ -291,7 +263,7 @@ fn test_create_account_with_seed() {
     let seed = authority_pubkey.to_string()[0..32].to_string();
     let nonce_address =
         Pubkey::create_with_seed(&creator_pubkey, &seed, &system_program::id()).unwrap();
-    check_balance!(0, &rpc_client, &nonce_address);
+    check_recent_balance(0, &rpc_client, &nonce_address);
 
     let mut creator_config = CliConfig::recent_for_tests();
     creator_config.json_rpc_url = test_validator.rpc_url();
@@ -301,21 +273,13 @@ fn test_create_account_with_seed() {
         seed: Some(seed),
         nonce_authority: Some(authority_pubkey),
         memo: None,
-        amount: SpendAmount::Some(sol_to_lamports(241.0)),
+        amount: SpendAmount::Some(241),
     };
     process_command(&creator_config).unwrap();
-    check_balance!(sol_to_lamports(241.0), &rpc_client, &nonce_address);
-    check_balance!(
-        sol_to_lamports(42.0),
-        &rpc_client,
-        &offline_nonce_authority_signer.pubkey(),
-    );
-    check_balance!(
-        sol_to_lamports(4001.0 - ONE_SIG_FEE),
-        &rpc_client,
-        &online_nonce_creator_signer.pubkey(),
-    );
-    check_balance!(0, &rpc_client, &to_address);
+    check_recent_balance(241, &rpc_client, &nonce_address);
+    check_recent_balance(42, &rpc_client, &offline_nonce_authority_signer.pubkey());
+    check_recent_balance(4000, &rpc_client, &online_nonce_creator_signer.pubkey());
+    check_recent_balance(0, &rpc_client, &to_address);
 
     // Fetch nonce hash
     let nonce_hash = nonce_utils::get_account_with_commitment(
@@ -335,7 +299,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(sol_to_lamports(10.0)),
+        amount: SpendAmount::Some(10),
         to: to_address,
         from: 0,
         sign_only: true,
@@ -361,7 +325,7 @@ fn test_create_account_with_seed() {
     submit_config.json_rpc_url = test_validator.rpc_url();
     submit_config.signers = vec![&authority_presigner];
     submit_config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(sol_to_lamports(10.0)),
+        amount: SpendAmount::Some(10),
         to: to_address,
         from: 0,
         sign_only: false,
@@ -380,16 +344,8 @@ fn test_create_account_with_seed() {
         derived_address_program_id: None,
     };
     process_command(&submit_config).unwrap();
-    check_balance!(sol_to_lamports(241.0), &rpc_client, &nonce_address);
-    check_balance!(
-        sol_to_lamports(32.0 - ONE_SIG_FEE),
-        &rpc_client,
-        &offline_nonce_authority_signer.pubkey(),
-    );
-    check_balance!(
-        sol_to_lamports(4001.0 - ONE_SIG_FEE),
-        &rpc_client,
-        &online_nonce_creator_signer.pubkey(),
-    );
-    check_balance!(sol_to_lamports(10.0), &rpc_client, &to_address);
+    check_recent_balance(241, &rpc_client, &nonce_address);
+    check_recent_balance(31, &rpc_client, &offline_nonce_authority_signer.pubkey());
+    check_recent_balance(4000, &rpc_client, &online_nonce_creator_signer.pubkey());
+    check_recent_balance(10, &rpc_client, &to_address);
 }

cli/tests/program.rs

@@ -1,4 +1,3 @@
-#![allow(clippy::integer_arithmetic)]
 use {
     serde_json::Value,
     solana_cli::{
@@ -78,7 +77,7 @@ fn test_cli_program_deploy_non_upgradeable() {
     assert_eq!(account0.lamports, minimum_balance_for_rent_exemption);
     assert_eq!(account0.owner, bpf_loader::id());
     assert!(account0.executable);
-    let mut file = File::open(noop_path.to_str().unwrap()).unwrap();
+    let mut file = File::open(noop_path.to_str().unwrap().to_string()).unwrap();
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
     assert_eq!(account0.data, elf);

cli/tests/request_airdrop.rs

@@ -1,11 +1,9 @@
-#![allow(clippy::integer_arithmetic)]
 use {
     solana_cli::cli::{process_command, CliCommand, CliConfig},
     solana_client::rpc_client::RpcClient,
     solana_faucet::faucet::run_local_faucet,
     solana_sdk::{
         commitment_config::CommitmentConfig,
-        native_token::sol_to_lamports,
         signature::{Keypair, Signer},
     },
     solana_streamer::socket::SocketAddrSpace,
@@ -24,7 +22,7 @@ fn test_cli_request_airdrop() {
     bob_config.json_rpc_url = test_validator.rpc_url();
     bob_config.command = CliCommand::Airdrop {
         pubkey: None,
-        lamports: sol_to_lamports(50.0),
+        lamports: 50,
     };
     let keypair = Keypair::new();
     bob_config.signers = vec![&keypair];
@@ -38,5 +36,5 @@ fn test_cli_request_airdrop() {
     let balance = rpc_client
         .get_balance(&bob_config.signers[0].pubkey())
         .unwrap();
-    assert_eq!(balance, sol_to_lamports(50.0));
+    assert_eq!(balance, 50);
 }

cli/tests/stake.rs

@@ -1,12 +1,10 @@
-#![allow(clippy::integer_arithmetic)]
 #![allow(clippy::redundant_closure)]
 use {
     solana_cli::{
-        check_balance,
         cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
         spend_utils::SpendAmount,
         stake::StakeAuthorizationIndexed,
-        test_utils::check_ready,
+        test_utils::{check_ready, check_recent_balance},
     },
     solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
     solana_client::{
@@ -18,7 +16,6 @@ use {
     solana_sdk::{
         account_utils::StateMut,
         commitment_config::CommitmentConfig,
-        fee::FeeStructure,
         nonce::State as NonceState,
         pubkey::Pubkey,
         signature::{keypair_from_seed, Keypair, Signer},
@@ -153,7 +150,7 @@ fn test_seed_stake_delegation_and_deactivation() {
         100_000,
     )
     .unwrap();
-    check_balance!(100_000, &rpc_client, &config_validator.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
 
     let stake_address = Pubkey::create_with_seed(
         &config_validator.signers[0].pubkey(),
@@ -242,7 +239,7 @@ fn test_stake_delegation_and_deactivation() {
         100_000,
     )
     .unwrap();
-    check_balance!(100_000, &rpc_client, &config_validator.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
 
     // Create stake account
     config_validator.signers.push(&stake_keypair);
@@ -336,7 +333,7 @@ fn test_offline_stake_delegation_and_deactivation() {
         100_000,
     )
     .unwrap();
-    check_balance!(100_000, &rpc_client, &config_validator.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
 
     request_and_confirm_airdrop(
         &rpc_client,
@@ -345,7 +342,7 @@ fn test_offline_stake_delegation_and_deactivation() {
         100_000,
     )
     .unwrap();
-    check_balance!(100_000, &rpc_client, &config_offline.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_offline.signers[0].pubkey());
 
     // Create stake account
     config_validator.signers.push(&stake_keypair);
@@ -877,15 +874,14 @@ fn test_stake_authorize() {
 #[test]
 fn test_stake_authorize_with_fee_payer() {
     solana_logger::setup();
-    let fee_one_sig = FeeStructure::default().get_max_fee(1, 0);
-    let fee_two_sig = FeeStructure::default().get_max_fee(2, 0);
+    const SIG_FEE: u64 = 42;
 
     let mint_keypair = Keypair::new();
     let mint_pubkey = mint_keypair.pubkey();
     let faucet_addr = run_local_faucet(mint_keypair, None);
     let test_validator = TestValidator::with_custom_fees(
         mint_pubkey,
-        1,
+        SIG_FEE,
         Some(faucet_addr),
         SocketAddrSpace::Unspecified,
     );
@@ -914,14 +910,14 @@ fn test_stake_authorize_with_fee_payer() {
     config_offline.command = CliCommand::ClusterVersion;
     process_command(&config_offline).unwrap_err();
 
-    request_and_confirm_airdrop(&rpc_client, &config, &default_pubkey, 5_000_000).unwrap();
-    check_balance!(5_000_000, &rpc_client, &config.signers[0].pubkey());
+    request_and_confirm_airdrop(&rpc_client, &config, &default_pubkey, 100_000).unwrap();
+    check_recent_balance(100_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &config_payer, &payer_pubkey, 5_000_000).unwrap();
-    check_balance!(5_000_000, &rpc_client, &payer_pubkey);
+    request_and_confirm_airdrop(&rpc_client, &config_payer, &payer_pubkey, 100_000).unwrap();
+    check_recent_balance(100_000, &rpc_client, &payer_pubkey);
 
-    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 5_000_000).unwrap();
-    check_balance!(5_000_000, &rpc_client, &offline_pubkey);
+    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 100_000).unwrap();
+    check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     check_ready(&rpc_client);
 
@@ -936,7 +932,7 @@ fn test_stake_authorize_with_fee_payer() {
         withdrawer: None,
         withdrawer_signer: None,
         lockup: Lockup::default(),
-        amount: SpendAmount::Some(1_000_000),
+        amount: SpendAmount::Some(50_000),
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
@@ -947,7 +943,8 @@ fn test_stake_authorize_with_fee_payer() {
         from: 0,
     };
     process_command(&config).unwrap();
-    check_balance!(4_000_000 - fee_two_sig, &rpc_client, &default_pubkey);
+    // `config` balance should be 50,000 - 1 stake account sig - 1 fee sig
+    check_recent_balance(50_000 - SIG_FEE - SIG_FEE, &rpc_client, &default_pubkey);
 
     // Assign authority with separate fee payer
     config.signers = vec![&default_signer, &payer_keypair];
@@ -971,10 +968,10 @@ fn test_stake_authorize_with_fee_payer() {
     };
     process_command(&config).unwrap();
     // `config` balance has not changed, despite submitting the TX
-    check_balance!(4_000_000 - fee_two_sig, &rpc_client, &default_pubkey);
+    check_recent_balance(50_000 - SIG_FEE - SIG_FEE, &rpc_client, &default_pubkey);
     // `config_payer` however has paid `config`'s authority sig
     // and `config_payer`'s fee sig
-    check_balance!(5_000_000 - fee_two_sig, &rpc_client, &payer_pubkey);
+    check_recent_balance(100_000 - SIG_FEE - SIG_FEE, &rpc_client, &payer_pubkey);
 
     // Assign authority with offline fee payer
     let blockhash = rpc_client.get_latest_blockhash().unwrap();
@@ -1022,10 +1019,10 @@ fn test_stake_authorize_with_fee_payer() {
     };
     process_command(&config).unwrap();
     // `config`'s balance again has not changed
-    check_balance!(4_000_000 - fee_two_sig, &rpc_client, &default_pubkey);
+    check_recent_balance(50_000 - SIG_FEE - SIG_FEE, &rpc_client, &default_pubkey);
     // `config_offline` however has paid 1 sig due to being both authority
     // and fee payer
-    check_balance!(5_000_000 - fee_one_sig, &rpc_client, &offline_pubkey);
+    check_recent_balance(100_000 - SIG_FEE, &rpc_client, &offline_pubkey);
 }
 
 #[test]
@@ -1059,17 +1056,12 @@ fn test_stake_split() {
     config_offline.command = CliCommand::ClusterVersion;
     process_command(&config_offline).unwrap_err();
 
-    request_and_confirm_airdrop(
-        &rpc_client,
-        &config,
-        &config.signers[0].pubkey(),
-        50_000_000,
-    )
-    .unwrap();
-    check_balance!(50_000_000, &rpc_client, &config.signers[0].pubkey());
+    request_and_confirm_airdrop(&rpc_client, &config, &config.signers[0].pubkey(), 500_000)
+        .unwrap();
+    check_recent_balance(500_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 1_000_000).unwrap();
-    check_balance!(1_000_000, &rpc_client, &offline_pubkey);
+    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 100_000).unwrap();
+    check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create stake account, identity is authority
     let minimum_stake_balance = rpc_client
@@ -1096,7 +1088,7 @@ fn test_stake_split() {
         from: 0,
     };
     process_command(&config).unwrap();
-    check_balance!(
+    check_recent_balance(
         10 * minimum_stake_balance,
         &rpc_client,
         &stake_account_pubkey,
@@ -1116,7 +1108,7 @@ fn test_stake_split() {
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
-    check_balance!(minimum_nonce_balance, &rpc_client, &nonce_account.pubkey());
+    check_recent_balance(minimum_nonce_balance, &rpc_client, &nonce_account.pubkey());
 
     // Fetch nonce hash
     let nonce_hash = nonce_utils::get_account_with_commitment(
@@ -1130,7 +1122,7 @@ fn test_stake_split() {
 
     // Nonced offline split
     let split_account = keypair_from_seed(&[2u8; 32]).unwrap();
-    check_balance!(0, &rpc_client, &split_account.pubkey());
+    check_recent_balance(0, &rpc_client, &split_account.pubkey());
     config_offline.signers.push(&split_account);
     config_offline.command = CliCommand::SplitStake {
         stake_account_pubkey,
@@ -1170,12 +1162,12 @@ fn test_stake_split() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance!(
+    check_recent_balance(
         8 * minimum_stake_balance,
         &rpc_client,
         &stake_account_pubkey,
     );
-    check_balance!(
+    check_recent_balance(
         2 * minimum_stake_balance,
         &rpc_client,
         &split_account.pubkey(),
@@ -1213,12 +1205,12 @@ fn test_stake_set_lockup() {
     config_offline.command = CliCommand::ClusterVersion;
     process_command(&config_offline).unwrap_err();
 
-    request_and_confirm_airdrop(&rpc_client, &config, &config.signers[0].pubkey(), 5_000_000)
+    request_and_confirm_airdrop(&rpc_client, &config, &config.signers[0].pubkey(), 500_000)
         .unwrap();
-    check_balance!(5_000_000, &rpc_client, &config.signers[0].pubkey());
+    check_recent_balance(500_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 1_000_000).unwrap();
-    check_balance!(1_000_000, &rpc_client, &offline_pubkey);
+    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 100_000).unwrap();
+    check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create stake account, identity is authority
     let minimum_stake_balance = rpc_client
@@ -1252,12 +1244,7 @@ fn test_stake_set_lockup() {
         from: 0,
     };
     process_command(&config).unwrap();
-    check_balance!(
-        10 * minimum_stake_balance,
-        &rpc_client,
-        &stake_account_pubkey,
-    );
-    check_balance!(
+    check_recent_balance(
         10 * minimum_stake_balance,
         &rpc_client,
         &stake_account_pubkey,
@@ -1390,7 +1377,7 @@ fn test_stake_set_lockup() {
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
-    check_balance!(minimum_nonce_balance, &rpc_client, &nonce_account_pubkey);
+    check_recent_balance(minimum_nonce_balance, &rpc_client, &nonce_account_pubkey);
 
     // Fetch nonce hash
     let nonce_hash = nonce_utils::get_account_with_commitment(
@@ -1486,10 +1473,10 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
 
     request_and_confirm_airdrop(&rpc_client, &config, &config.signers[0].pubkey(), 200_000)
         .unwrap();
-    check_balance!(200_000, &rpc_client, &config.signers[0].pubkey());
+    check_recent_balance(200_000, &rpc_client, &config.signers[0].pubkey());
 
     request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 100_000).unwrap();
-    check_balance!(100_000, &rpc_client, &offline_pubkey);
+    check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create nonce account
     let minimum_nonce_balance = rpc_client
@@ -1566,7 +1553,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         from: 0,
     };
     process_command(&config).unwrap();
-    check_balance!(50_000, &rpc_client, &stake_pubkey);
+    check_recent_balance(50_000, &rpc_client, &stake_pubkey);
 
     // Fetch nonce hash
     let nonce_hash = nonce_utils::get_account_with_commitment(
@@ -1585,7 +1572,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     config_offline.command = CliCommand::WithdrawStake {
         stake_account_pubkey: stake_pubkey,
         destination_account_pubkey: recipient_pubkey,
-        amount: SpendAmount::Some(50_000),
+        amount: SpendAmount::Some(42),
         withdraw_authority: 0,
         custodian: None,
         sign_only: true,
@@ -1604,7 +1591,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     config.command = CliCommand::WithdrawStake {
         stake_account_pubkey: stake_pubkey,
         destination_account_pubkey: recipient_pubkey,
-        amount: SpendAmount::Some(50_000),
+        amount: SpendAmount::Some(42),
         withdraw_authority: 0,
         custodian: None,
         sign_only: false,
@@ -1620,7 +1607,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance!(50_000, &rpc_client, &recipient_pubkey);
+    check_recent_balance(42, &rpc_client, &recipient_pubkey);
 
     // Fetch nonce hash
     let nonce_hash = nonce_utils::get_account_with_commitment(
@@ -1680,7 +1667,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     process_command(&config).unwrap();
     let seed_address =
         Pubkey::create_with_seed(&stake_pubkey, seed, &stake::program::id()).unwrap();
-    check_balance!(50_000, &rpc_client, &seed_address);
+    check_recent_balance(50_000, &rpc_client, &seed_address);
 }
 
 #[test]

cli/tests/transfer.rs

@@ -1,11 +1,9 @@
-#![allow(clippy::integer_arithmetic)]
 #![allow(clippy::redundant_closure)]
 use {
     solana_cli::{
-        check_balance,
         cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
         spend_utils::SpendAmount,
-        test_utils::check_ready,
+        test_utils::{check_ready, check_recent_balance},
     },
     solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
     solana_client::{
@@ -16,8 +14,6 @@ use {
     solana_faucet::faucet::run_local_faucet,
     solana_sdk::{
         commitment_config::CommitmentConfig,
-        fee::FeeStructure,
-        native_token::sol_to_lamports,
         nonce::State as NonceState,
         pubkey::Pubkey,
         signature::{keypair_from_seed, Keypair, NullSigner, Signer},
@@ -30,8 +26,6 @@ use {
 #[test]
 fn test_transfer() {
     solana_logger::setup();
-    let fee_one_sig = FeeStructure::default().get_max_fee(1, 0);
-    let fee_two_sig = FeeStructure::default().get_max_fee(2, 0);
     let mint_keypair = Keypair::new();
     let mint_pubkey = mint_keypair.pubkey();
     let faucet_addr = run_local_faucet(mint_keypair, None);
@@ -55,16 +49,15 @@ fn test_transfer() {
     let sender_pubkey = config.signers[0].pubkey();
     let recipient_pubkey = Pubkey::new(&[1u8; 32]);
 
-    request_and_confirm_airdrop(&rpc_client, &config, &sender_pubkey, sol_to_lamports(5.0))
-        .unwrap();
-    check_balance!(sol_to_lamports(5.0), &rpc_client, &sender_pubkey);
-    check_balance!(0, &rpc_client, &recipient_pubkey);
+    request_and_confirm_airdrop(&rpc_client, &config, &sender_pubkey, 50_000).unwrap();
+    check_recent_balance(50_000, &rpc_client, &sender_pubkey);
+    check_recent_balance(0, &rpc_client, &recipient_pubkey);
 
     check_ready(&rpc_client);
 
     // Plain ole transfer
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(sol_to_lamports(1.0)),
+        amount: SpendAmount::Some(10),
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -80,16 +73,12 @@ fn test_transfer() {
         derived_address_program_id: None,
     };
     process_command(&config).unwrap();
-    check_balance!(
-        sol_to_lamports(4.0) - fee_one_sig,
-        &rpc_client,
-        &sender_pubkey
-    );
-    check_balance!(sol_to_lamports(1.0), &rpc_client, &recipient_pubkey);
+    check_recent_balance(49_989, &rpc_client, &sender_pubkey);
+    check_recent_balance(10, &rpc_client, &recipient_pubkey);
 
     // Plain ole transfer, failure due to InsufficientFundsForSpendAndFee
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(sol_to_lamports(4.0)),
+        amount: SpendAmount::Some(49_989),
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -105,12 +94,8 @@ fn test_transfer() {
         derived_address_program_id: None,
     };
     assert!(process_command(&config).is_err());
-    check_balance!(
-        sol_to_lamports(4.0) - fee_one_sig,
-        &rpc_client,
-        &sender_pubkey
-    );
-    check_balance!(sol_to_lamports(1.0), &rpc_client, &recipient_pubkey);
+    check_recent_balance(49_989, &rpc_client, &sender_pubkey);
+    check_recent_balance(10, &rpc_client, &recipient_pubkey);
 
     let mut offline = CliConfig::recent_for_tests();
     offline.json_rpc_url = String::default();
@@ -120,14 +105,13 @@ fn test_transfer() {
     process_command(&offline).unwrap_err();
 
     let offline_pubkey = offline.signers[0].pubkey();
-    request_and_confirm_airdrop(&rpc_client, &offline, &offline_pubkey, sol_to_lamports(1.0))
-        .unwrap();
-    check_balance!(sol_to_lamports(1.0), &rpc_client, &offline_pubkey);
+    request_and_confirm_airdrop(&rpc_client, &offline, &offline_pubkey, 50).unwrap();
+    check_recent_balance(50, &rpc_client, &offline_pubkey);
 
     // Offline transfer
     let blockhash = rpc_client.get_latest_blockhash().unwrap();
     offline.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(sol_to_lamports(0.5)),
+        amount: SpendAmount::Some(10),
         to: recipient_pubkey,
         from: 0,
         sign_only: true,
@@ -149,7 +133,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(sol_to_lamports(0.5)),
+        amount: SpendAmount::Some(10),
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -165,12 +149,8 @@ fn test_transfer() {
         derived_address_program_id: None,
     };
     process_command(&config).unwrap();
-    check_balance!(
-        sol_to_lamports(0.5) - fee_one_sig,
-        &rpc_client,
-        &offline_pubkey
-    );
-    check_balance!(sol_to_lamports(1.5), &rpc_client, &recipient_pubkey);
+    check_recent_balance(39, &rpc_client, &offline_pubkey);
+    check_recent_balance(20, &rpc_client, &recipient_pubkey);
 
     // Create nonce account
     let nonce_account = keypair_from_seed(&[3u8; 32]).unwrap();
@@ -186,11 +166,7 @@ fn test_transfer() {
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
-    check_balance!(
-        sol_to_lamports(4.0) - fee_one_sig - fee_two_sig - minimum_nonce_balance,
-        &rpc_client,
-        &sender_pubkey,
-    );
+    check_recent_balance(49_987 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
 
     // Fetch nonce hash
     let nonce_hash = nonce_utils::get_account_with_commitment(
@@ -205,7 +181,7 @@ fn test_transfer() {
     // Nonced transfer
     config.signers = vec![&default_signer];
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(sol_to_lamports(1.0)),
+        amount: SpendAmount::Some(10),
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -224,12 +200,8 @@ fn test_transfer() {
         derived_address_program_id: None,
     };
     process_command(&config).unwrap();
-    check_balance!(
-        sol_to_lamports(3.0) - 2 * fee_one_sig - fee_two_sig - minimum_nonce_balance,
-        &rpc_client,
-        &sender_pubkey,
-    );
-    check_balance!(sol_to_lamports(2.5), &rpc_client, &recipient_pubkey);
+    check_recent_balance(49_976 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
+    check_recent_balance(30, &rpc_client, &recipient_pubkey);
     let new_nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
@@ -249,11 +221,7 @@ fn test_transfer() {
         new_authority: offline_pubkey,
     };
     process_command(&config).unwrap();
-    check_balance!(
-        sol_to_lamports(3.0) - 3 * fee_one_sig - fee_two_sig - minimum_nonce_balance,
-        &rpc_client,
-        &sender_pubkey,
-    );
+    check_recent_balance(49_975 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
 
     // Fetch nonce hash
     let nonce_hash = nonce_utils::get_account_with_commitment(
@@ -268,7 +236,7 @@ fn test_transfer() {
     // Offline, nonced transfer
     offline.signers = vec![&default_offline_signer];
     offline.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(sol_to_lamports(0.4)),
+        amount: SpendAmount::Some(10),
         to: recipient_pubkey,
         from: 0,
         sign_only: true,
@@ -289,7 +257,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(sol_to_lamports(0.4)),
+        amount: SpendAmount::Some(10),
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -308,18 +276,13 @@ fn test_transfer() {
         derived_address_program_id: None,
     };
     process_command(&config).unwrap();
-    check_balance!(
-        sol_to_lamports(0.1) - 2 * fee_one_sig,
-        &rpc_client,
-        &offline_pubkey
-    );
-    check_balance!(sol_to_lamports(2.9), &rpc_client, &recipient_pubkey);
+    check_recent_balance(28, &rpc_client, &offline_pubkey);
+    check_recent_balance(40, &rpc_client, &recipient_pubkey);
 }
 
 #[test]
 fn test_transfer_multisession_signing() {
     solana_logger::setup();
-    let fee = FeeStructure::default().get_max_fee(2, 0);
     let mint_keypair = Keypair::new();
     let mint_pubkey = mint_keypair.pubkey();
     let faucet_addr = run_local_faucet(mint_keypair, None);
@@ -342,27 +305,19 @@ fn test_transfer_multisession_signing() {
         &rpc_client,
         &CliConfig::recent_for_tests(),
         &offline_from_signer.pubkey(),
-        sol_to_lamports(43.0),
+        43,
     )
     .unwrap();
     request_and_confirm_airdrop(
         &rpc_client,
         &CliConfig::recent_for_tests(),
         &offline_fee_payer_signer.pubkey(),
-        sol_to_lamports(1.0) + 2 * fee,
+        3,
     )
     .unwrap();
-    check_balance!(
-        sol_to_lamports(43.0),
-        &rpc_client,
-        &offline_from_signer.pubkey(),
-    );
-    check_balance!(
-        sol_to_lamports(1.0) + 2 * fee,
-        &rpc_client,
-        &offline_fee_payer_signer.pubkey(),
-    );
-    check_balance!(0, &rpc_client, &to_pubkey);
+    check_recent_balance(43, &rpc_client, &offline_from_signer.pubkey());
+    check_recent_balance(3, &rpc_client, &offline_fee_payer_signer.pubkey());
+    check_recent_balance(0, &rpc_client, &to_pubkey);
 
     check_ready(&rpc_client);
 
@@ -376,7 +331,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(sol_to_lamports(42.0)),
+        amount: SpendAmount::Some(42),
         to: to_pubkey,
         from: 1,
         sign_only: true,
@@ -407,7 +362,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(sol_to_lamports(42.0)),
+        amount: SpendAmount::Some(42),
         to: to_pubkey,
         from: 1,
         sign_only: true,
@@ -435,7 +390,7 @@ fn test_transfer_multisession_signing() {
     config.json_rpc_url = test_validator.rpc_url();
     config.signers = vec![&fee_payer_presigner, &from_presigner];
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(sol_to_lamports(42.0)),
+        amount: SpendAmount::Some(42),
         to: to_pubkey,
         from: 1,
         sign_only: false,
@@ -452,23 +407,14 @@ fn test_transfer_multisession_signing() {
     };
     process_command(&config).unwrap();
 
-    check_balance!(
-        sol_to_lamports(1.0),
-        &rpc_client,
-        &offline_from_signer.pubkey(),
-    );
-    check_balance!(
-        sol_to_lamports(1.0) + fee,
-        &rpc_client,
-        &offline_fee_payer_signer.pubkey(),
-    );
-    check_balance!(sol_to_lamports(42.0), &rpc_client, &to_pubkey);
+    check_recent_balance(1, &rpc_client, &offline_from_signer.pubkey());
+    check_recent_balance(1, &rpc_client, &offline_fee_payer_signer.pubkey());
+    check_recent_balance(42, &rpc_client, &to_pubkey);
 }
 
 #[test]
 fn test_transfer_all() {
     solana_logger::setup();
-    let fee = FeeStructure::default().get_max_fee(1, 0);
     let mint_keypair = Keypair::new();
     let mint_pubkey = mint_keypair.pubkey();
     let faucet_addr = run_local_faucet(mint_keypair, None);
@@ -491,9 +437,9 @@ fn test_transfer_all() {
     let sender_pubkey = config.signers[0].pubkey();
     let recipient_pubkey = Pubkey::new(&[1u8; 32]);
 
-    request_and_confirm_airdrop(&rpc_client, &config, &sender_pubkey, 500_000).unwrap();
-    check_balance!(500_000, &rpc_client, &sender_pubkey);
-    check_balance!(0, &rpc_client, &recipient_pubkey);
+    request_and_confirm_airdrop(&rpc_client, &config, &sender_pubkey, 50_000).unwrap();
+    check_recent_balance(50_000, &rpc_client, &sender_pubkey);
+    check_recent_balance(0, &rpc_client, &recipient_pubkey);
 
     check_ready(&rpc_client);
 
@@ -515,8 +461,8 @@ fn test_transfer_all() {
         derived_address_program_id: None,
     };
     process_command(&config).unwrap();
-    check_balance!(0, &rpc_client, &sender_pubkey);
-    check_balance!(500_000 - fee, &rpc_client, &recipient_pubkey);
+    check_recent_balance(0, &rpc_client, &sender_pubkey);
+    check_recent_balance(49_999, &rpc_client, &recipient_pubkey);
 }
 
 #[test]
@@ -545,8 +491,8 @@ fn test_transfer_unfunded_recipient() {
     let recipient_pubkey = Pubkey::new(&[1u8; 32]);
 
     request_and_confirm_airdrop(&rpc_client, &config, &sender_pubkey, 50_000).unwrap();
-    check_balance!(50_000, &rpc_client, &sender_pubkey);
-    check_balance!(0, &rpc_client, &recipient_pubkey);
+    check_recent_balance(50_000, &rpc_client, &sender_pubkey);
+    check_recent_balance(0, &rpc_client, &recipient_pubkey);
 
     check_ready(&rpc_client);
 
@@ -575,7 +521,6 @@ fn test_transfer_unfunded_recipient() {
 #[test]
 fn test_transfer_with_seed() {
     solana_logger::setup();
-    let fee = FeeStructure::default().get_max_fee(1, 0);
     let mint_keypair = Keypair::new();
     let mint_pubkey = mint_keypair.pubkey();
     let faucet_addr = run_local_faucet(mint_keypair, None);
@@ -606,19 +551,17 @@ fn test_transfer_with_seed() {
     )
     .unwrap();
 
-    request_and_confirm_airdrop(&rpc_client, &config, &sender_pubkey, sol_to_lamports(1.0))
-        .unwrap();
-    request_and_confirm_airdrop(&rpc_client, &config, &derived_address, sol_to_lamports(5.0))
-        .unwrap();
-    check_balance!(sol_to_lamports(1.0), &rpc_client, &sender_pubkey);
-    check_balance!(sol_to_lamports(5.0), &rpc_client, &derived_address);
-    check_balance!(0, &rpc_client, &recipient_pubkey);
+    request_and_confirm_airdrop(&rpc_client, &config, &sender_pubkey, 1).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &config, &derived_address, 50_000).unwrap();
+    check_recent_balance(1, &rpc_client, &sender_pubkey);
+    check_recent_balance(50_000, &rpc_client, &derived_address);
+    check_recent_balance(0, &rpc_client, &recipient_pubkey);
 
     check_ready(&rpc_client);
 
     // Transfer with seed
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(sol_to_lamports(5.0)),
+        amount: SpendAmount::Some(50_000),
         to: recipient_pubkey,
         from: 0,
         sign_only: false,
@@ -634,7 +577,7 @@ fn test_transfer_with_seed() {
         derived_address_program_id: Some(derived_address_program_id),
     };
     process_command(&config).unwrap();
-    check_balance!(sol_to_lamports(1.0) - fee, &rpc_client, &sender_pubkey);
-    check_balance!(sol_to_lamports(5.0), &rpc_client, &recipient_pubkey);
-    check_balance!(0, &rpc_client, &derived_address);
+    check_recent_balance(0, &rpc_client, &sender_pubkey);
+    check_recent_balance(50_000, &rpc_client, &recipient_pubkey);
+    check_recent_balance(0, &rpc_client, &derived_address);
 }

cli/tests/vote.rs

@@ -1,9 +1,8 @@
-#![allow(clippy::integer_arithmetic)]
 use {
     solana_cli::{
-        check_balance,
         cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
         spend_utils::SpendAmount,
+        test_utils::check_recent_balance,
     },
     solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
     solana_client::{
@@ -70,12 +69,12 @@ fn test_vote_authorize_and_withdraw() {
         .get_minimum_balance_for_rent_exemption(VoteState::size_of())
         .unwrap()
         .max(1);
-    check_balance!(expected_balance, &rpc_client, &vote_account_pubkey);
+    check_recent_balance(expected_balance, &rpc_client, &vote_account_pubkey);
 
     // Transfer in some more SOL
     config.signers = vec![&default_signer];
     config.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10_000),
+        amount: SpendAmount::Some(1_000),
         to: vote_account_pubkey,
         from: 0,
         sign_only: false,
@@ -91,8 +90,8 @@ fn test_vote_authorize_and_withdraw() {
         derived_address_program_id: None,
     };
     process_command(&config).unwrap();
-    let expected_balance = expected_balance + 10_000;
-    check_balance!(expected_balance, &rpc_client, &vote_account_pubkey);
+    let expected_balance = expected_balance + 1_000;
+    check_recent_balance(expected_balance, &rpc_client, &vote_account_pubkey);
 
     // Authorize vote account withdrawal to another signer
     let first_withdraw_authority = Keypair::new();
@@ -170,7 +169,7 @@ fn test_vote_authorize_and_withdraw() {
     config.command = CliCommand::WithdrawFromVoteAccount {
         vote_account_pubkey,
         withdraw_authority: 1,
-        withdraw_amount: SpendAmount::Some(1_000),
+        withdraw_amount: SpendAmount::Some(100),
         destination_account_pubkey: destination_account,
         sign_only: false,
         dump_transaction_message: false,
@@ -181,9 +180,9 @@ fn test_vote_authorize_and_withdraw() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let expected_balance = expected_balance - 1_000;
-    check_balance!(expected_balance, &rpc_client, &vote_account_pubkey);
-    check_balance!(1_000, &rpc_client, &destination_account);
+    let expected_balance = expected_balance - 100;
+    check_recent_balance(expected_balance, &rpc_client, &vote_account_pubkey);
+    check_recent_balance(100, &rpc_client, &destination_account);
 
     // Re-assign validator identity
     let new_identity_keypair = Keypair::new();
@@ -213,8 +212,8 @@ fn test_vote_authorize_and_withdraw() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance!(0, &rpc_client, &vote_account_pubkey);
-    check_balance!(expected_balance, &rpc_client, &destination_account);
+    check_recent_balance(0, &rpc_client, &vote_account_pubkey);
+    check_recent_balance(expected_balance, &rpc_client, &destination_account);
 }
 
 #[test]
@@ -248,7 +247,7 @@ fn test_offline_vote_authorize_and_withdraw() {
         100_000,
     )
     .unwrap();
-    check_balance!(100_000, &rpc_client, &config_payer.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_payer.signers[0].pubkey());
 
     request_and_confirm_airdrop(
         &rpc_client,
@@ -257,7 +256,7 @@ fn test_offline_vote_authorize_and_withdraw() {
         100_000,
     )
     .unwrap();
-    check_balance!(100_000, &rpc_client, &config_offline.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_offline.signers[0].pubkey());
 
     // Create vote account with specific withdrawer
     let vote_account_keypair = Keypair::new();
@@ -289,12 +288,12 @@ fn test_offline_vote_authorize_and_withdraw() {
         .get_minimum_balance_for_rent_exemption(VoteState::size_of())
         .unwrap()
         .max(1);
-    check_balance!(expected_balance, &rpc_client, &vote_account_pubkey);
+    check_recent_balance(expected_balance, &rpc_client, &vote_account_pubkey);
 
     // Transfer in some more SOL
     config_payer.signers = vec![&default_signer];
     config_payer.command = CliCommand::Transfer {
-        amount: SpendAmount::Some(10_000),
+        amount: SpendAmount::Some(1_000),
         to: vote_account_pubkey,
         from: 0,
         sign_only: false,
@@ -310,8 +309,8 @@ fn test_offline_vote_authorize_and_withdraw() {
         derived_address_program_id: None,
     };
     process_command(&config_payer).unwrap();
-    let expected_balance = expected_balance + 10_000;
-    check_balance!(expected_balance, &rpc_client, &vote_account_pubkey);
+    let expected_balance = expected_balance + 1_000;
+    check_recent_balance(expected_balance, &rpc_client, &vote_account_pubkey);
 
     // Authorize vote account withdrawal to another signer, offline
     let withdraw_authority = Keypair::new();
@@ -368,7 +367,7 @@ fn test_offline_vote_authorize_and_withdraw() {
     config_offline.command = CliCommand::WithdrawFromVoteAccount {
         vote_account_pubkey,
         withdraw_authority: 1,
-        withdraw_amount: SpendAmount::Some(1_000),
+        withdraw_amount: SpendAmount::Some(100),
         destination_account_pubkey: destination_account,
         sign_only: true,
         dump_transaction_message: false,
@@ -388,7 +387,7 @@ fn test_offline_vote_authorize_and_withdraw() {
     config_payer.command = CliCommand::WithdrawFromVoteAccount {
         vote_account_pubkey,
         withdraw_authority: 1,
-        withdraw_amount: SpendAmount::Some(1_000),
+        withdraw_amount: SpendAmount::Some(100),
         destination_account_pubkey: destination_account,
         sign_only: false,
         dump_transaction_message: false,
@@ -399,9 +398,9 @@ fn test_offline_vote_authorize_and_withdraw() {
         fee_payer: 0,
     };
     process_command(&config_payer).unwrap();
-    let expected_balance = expected_balance - 1_000;
-    check_balance!(expected_balance, &rpc_client, &vote_account_pubkey);
-    check_balance!(1_000, &rpc_client, &destination_account);
+    let expected_balance = expected_balance - 100;
+    check_recent_balance(expected_balance, &rpc_client, &vote_account_pubkey);
+    check_recent_balance(100, &rpc_client, &destination_account);
 
     // Re-assign validator identity offline
     let blockhash = rpc_client.get_latest_blockhash().unwrap();
@@ -484,7 +483,9 @@ fn test_offline_vote_authorize_and_withdraw() {
         memo: None,
         fee_payer: 0,
     };
-    process_command(&config_payer).unwrap();
-    check_balance!(0, &rpc_client, &vote_account_pubkey);
-    check_balance!(expected_balance, &rpc_client, &destination_account);
+    let result = process_command(&config_payer).unwrap();
+    println!("{:?}", result);
+    check_recent_balance(0, &rpc_client, &vote_account_pubkey);
+    println!("what");
+    check_recent_balance(expected_balance, &rpc_client, &destination_account);
 }

client-test/Cargo.toml

@@ -10,9 +10,8 @@ documentation = "https://docs.rs/solana-client-test"
 edition = "2021"
 
 [dependencies]
-futures-util = "0.3.21"
-serde_json = "1.0.78"
-serial_test = "0.6.0"
+serde_json = "1.0.74"
+serial_test = "0.5.1"
 solana-client = { path = "../client", version = "=1.10.0" }
 solana-ledger = { path = "../ledger", version = "=1.10.0" }
 solana-measure = { path = "../measure", version = "=1.10.0" }
@@ -28,7 +27,6 @@ solana-test-validator = { path = "../test-validator", version = "=1.10.0" }
 solana-transaction-status = { path = "../transaction-status", version = "=1.10.0" }
 solana-version = { path = "../version", version = "=1.10.0" }
 systemstat = "0.1.10"
-tokio = { version = "1", features = ["full"] }
 
 [dev-dependencies]
 solana-logger = { path = "../logger", version = "=1.10.0" }

client-test/tests/client.rs

@@ -1,16 +1,14 @@
 use {
-    futures_util::StreamExt,
     serde_json::{json, Value},
     serial_test::serial,
     solana_client::{
-        nonblocking,
         pubsub_client::PubsubClient,
         rpc_client::RpcClient,
         rpc_config::{
             RpcAccountInfoConfig, RpcBlockSubscribeConfig, RpcBlockSubscribeFilter,
             RpcProgramAccountsConfig,
         },
-        rpc_response::SlotInfo,
+        rpc_response::{RpcBlockUpdate, SlotInfo},
     },
     solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path},
     solana_rpc::{
@@ -36,7 +34,7 @@ use {
     },
     solana_streamer::socket::SocketAddrSpace,
     solana_test_validator::TestValidator,
-    solana_transaction_status::{ConfirmedBlock, TransactionDetails, UiTransactionEncoding},
+    solana_transaction_status::{TransactionDetails, UiTransactionEncoding},
     std::{
         collections::HashSet,
         net::{IpAddr, SocketAddr},
@@ -214,7 +212,6 @@ fn test_block_subscription() {
         ..
     } = create_genesis_config(10_000);
     let bank = Bank::new_for_tests(&genesis_config);
-    let rent_exempt_amount = bank.get_minimum_balance_for_rent_exemption(0);
     let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
 
     // setup Blockstore
@@ -228,8 +225,6 @@ fn test_block_subscription() {
     let keypair2 = Keypair::new();
     let keypair3 = Keypair::new();
     let max_complete_transaction_status_slot = Arc::new(AtomicU64::new(blockstore.max_root()));
-    bank.transfer(rent_exempt_amount, &alice, &keypair2.pubkey())
-        .unwrap();
     let _confirmed_block_signatures = create_test_transactions_and_populate_blockstore(
         vec![&alice, &keypair1, &keypair2, &keypair3],
         0,
@@ -280,16 +275,23 @@ fn test_block_subscription() {
     let maybe_actual = receiver.recv_timeout(Duration::from_millis(400));
     match maybe_actual {
         Ok(actual) => {
-            let versioned_block = blockstore.get_complete_block(slot, false).unwrap();
-            let legacy_block = ConfirmedBlock::from(versioned_block)
-                .into_legacy_block()
-                .unwrap();
-            let block = legacy_block.configure(
+            let complete_block = blockstore.get_complete_block(slot, false).unwrap();
+            let block = complete_block.clone().configure(
                 UiTransactionEncoding::Json,
                 TransactionDetails::Signatures,
                 false,
             );
-            assert_eq!(actual.value.slot, slot);
+            let expected = RpcBlockUpdate {
+                slot,
+                block: Some(block),
+                err: None,
+            };
+            let block = complete_block.configure(
+                UiTransactionEncoding::Json,
+                TransactionDetails::Signatures,
+                false,
+            );
+            assert_eq!(actual.value.slot, expected.slot);
             assert!(block.eq(&actual.value.block.unwrap()));
         }
         Err(e) => {
@@ -511,86 +513,3 @@ fn test_slot_subscription() {
 
     assert_eq!(errors, [].to_vec());
 }
-
-#[tokio::test]
-#[serial]
-async fn test_slot_subscription_async() {
-    let sync_service = Arc::new(AtomicU64::new(0));
-    let sync_client = Arc::clone(&sync_service);
-    fn wait_until(atomic: &Arc<AtomicU64>, value: u64) {
-        while atomic.load(Ordering::Relaxed) != value {
-            sleep(Duration::from_millis(1))
-        }
-    }
-
-    let pubsub_addr = SocketAddr::new(
-        IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
-        rpc_port::DEFAULT_RPC_PUBSUB_PORT,
-    );
-
-    tokio::task::spawn_blocking(move || {
-        let exit = Arc::new(AtomicBool::new(false));
-        let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
-        let bank = Bank::new_for_tests(&genesis_config);
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-        let optimistically_confirmed_bank =
-            OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
-        let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
-        let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
-            &exit,
-            max_complete_transaction_status_slot,
-            bank_forks,
-            Arc::new(RwLock::new(BlockCommitmentCache::default())),
-            optimistically_confirmed_bank,
-        ));
-        let (trigger, pubsub_service) =
-            PubSubService::new(PubSubConfig::default(), &subscriptions, pubsub_addr);
-        sleep(Duration::from_millis(100));
-        sync_service.store(1, Ordering::Relaxed);
-
-        wait_until(&sync_service, 2);
-        subscriptions.notify_slot(1, 0, 0);
-        sync_service.store(3, Ordering::Relaxed);
-
-        wait_until(&sync_service, 4);
-        subscriptions.notify_slot(2, 1, 1);
-        sync_service.store(5, Ordering::Relaxed);
-
-        wait_until(&sync_service, 6);
-        exit.store(true, Ordering::Relaxed);
-        trigger.cancel();
-        pubsub_service.close().unwrap();
-    });
-
-    wait_until(&sync_client, 1);
-    let url = format!("ws://0.0.0.0:{}/", pubsub_addr.port());
-    let pubsub_client = nonblocking::pubsub_client::PubsubClient::new(&url)
-        .await
-        .unwrap();
-    let (mut notifications, unsubscribe) = pubsub_client.slot_subscribe().await.unwrap();
-    sync_client.store(2, Ordering::Relaxed);
-
-    wait_until(&sync_client, 3);
-    assert_eq!(
-        tokio::time::timeout(Duration::from_millis(25), notifications.next()).await,
-        Ok(Some(SlotInfo {
-            slot: 1,
-            parent: 0,
-            root: 0,
-        }))
-    );
-    sync_client.store(4, Ordering::Relaxed);
-
-    wait_until(&sync_client, 5);
-    assert_eq!(
-        tokio::time::timeout(Duration::from_millis(25), notifications.next()).await,
-        Ok(Some(SlotInfo {
-            slot: 2,
-            parent: 1,
-            root: 1,
-        }))
-    );
-    sync_client.store(6, Ordering::Relaxed);
-
-    unsubscribe().await;
-}

client/Cargo.toml

@@ -10,22 +10,19 @@ license = "Apache-2.0"
 edition = "2021"
 
 [dependencies]
-async-trait = "0.1.52"
 base64 = "0.13.0"
 bincode = "1.3.3"
 bs58 = "0.4.0"
 clap = "2.33.0"
-crossbeam-channel = "0.5"
-futures-util = "0.3.21"
 indicatif = "0.16.2"
 jsonrpc-core = "18.0.0"
 log = "0.4.14"
 rayon = "1.5.1"
-reqwest = { version = "0.11.9", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-semver = "1.0.6"
-serde = "1.0.136"
+reqwest = { version = "0.11.6", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+semver = "1.0.4"
+serde = "1.0.133"
 serde_derive = "1.0.103"
-serde_json = "1.0.78"
+serde_json = "1.0.74"
 solana-account-decoder = { path = "../account-decoder", version = "=1.10.0" }
 solana-clap-utils = { path = "../clap-utils", version = "=1.10.0" }
 solana-faucet = { path = "../faucet", version = "=1.10.0" }
@@ -37,9 +34,7 @@ solana-version = { path = "../version", version = "=1.10.0" }
 solana-vote-program = { path = "../programs/vote", version = "=1.10.0" }
 thiserror = "1.0"
 tokio = { version = "1", features = ["full"] }
-tokio-stream = "0.1.8"
-tokio-tungstenite = { version = "0.17.1", features = ["rustls-tls-webpki-roots"] }
-tungstenite = { version = "0.17.2", features = ["rustls-tls-webpki-roots"] }
+tungstenite = { version = "0.16.0", features = ["rustls-tls-webpki-roots"] }
 url = "2.2.2"
 
 [dev-dependencies]

client/src/http_sender.rs

@@ -1,4 +1,4 @@
-//! Nonblocking [`RpcSender`] over HTTP.
+//! The standard [`RpcSender`] over HTTP.
 
 use {
     crate::{
@@ -8,7 +8,6 @@ use {
         rpc_response::RpcSimulateTransactionResult,
         rpc_sender::*,
     },
-    async_trait::async_trait,
     log::*,
     reqwest::{
         self,
@@ -26,36 +25,40 @@ use {
 };
 
 pub struct HttpSender {
-    client: Arc<reqwest::Client>,
+    client: Arc<reqwest::blocking::Client>,
     url: String,
     request_id: AtomicU64,
     stats: RwLock<RpcTransportStats>,
 }
 
-/// Nonblocking [`RpcSender`] over HTTP.
+/// The standard [`RpcSender`] over HTTP.
 impl HttpSender {
     /// Create an HTTP RPC sender.
     ///
     /// The URL is an HTTP URL, usually for port 8899, as in
     /// "http://localhost:8899". The sender has a default timeout of 30 seconds.
-    pub fn new<U: ToString>(url: U) -> Self {
+    pub fn new(url: String) -> Self {
         Self::new_with_timeout(url, Duration::from_secs(30))
     }
 
     /// Create an HTTP RPC sender.
     ///
     /// The URL is an HTTP URL, usually for port 8899.
-    pub fn new_with_timeout<U: ToString>(url: U, timeout: Duration) -> Self {
+    pub fn new_with_timeout(url: String, timeout: Duration) -> Self {
+        // `reqwest::blocking::Client` panics if run in a tokio async context.  Shuttle the
+        // request to a different tokio thread to avoid this
         let client = Arc::new(
-            reqwest::Client::builder()
-                .timeout(timeout)
-                .build()
-                .expect("build rpc client"),
+            tokio::task::block_in_place(move || {
+                reqwest::blocking::Client::builder()
+                    .timeout(timeout)
+                    .build()
+            })
+            .expect("build rpc client"),
         );
 
         Self {
             client,
-            url: url.to_string(),
+            url,
             request_id: AtomicU64::new(0),
             stats: RwLock::new(RpcTransportStats::default()),
         }
@@ -63,9 +66,9 @@ impl HttpSender {
 }
 
 #[derive(Deserialize, Debug)]
-pub(crate) struct RpcErrorObject {
-    pub code: i64,
-    pub message: String,
+struct RpcErrorObject {
+    code: i64,
+    message: String,
 }
 
 struct StatsUpdater<'a> {
@@ -97,17 +100,12 @@ impl<'a> Drop for StatsUpdater<'a> {
     }
 }
 
-#[async_trait]
 impl RpcSender for HttpSender {
     fn get_transport_stats(&self) -> RpcTransportStats {
         self.stats.read().unwrap().clone()
     }
 
-    async fn send(
-        &self,
-        request: RpcRequest,
-        params: serde_json::Value,
-    ) -> Result<serde_json::Value> {
+    fn send(&self, request: RpcRequest, params: serde_json::Value) -> Result<serde_json::Value> {
         let mut stats_updater = StatsUpdater::new(&self.stats);
 
         let request_id = self.request_id.fetch_add(1, Ordering::Relaxed);
@@ -115,15 +113,18 @@ impl RpcSender for HttpSender {
 
         let mut too_many_requests_retries = 5;
         loop {
+            // `reqwest::blocking::Client` panics if run in a tokio async context.  Shuttle the
+            // request to a different tokio thread to avoid this
             let response = {
                 let client = self.client.clone();
                 let request_json = request_json.clone();
-                client
-                    .post(&self.url)
-                    .header(CONTENT_TYPE, "application/json")
-                    .body(request_json)
-                    .send()
-                    .await
+                tokio::task::block_in_place(move || {
+                    client
+                        .post(&self.url)
+                        .header(CONTENT_TYPE, "application/json")
+                        .body(request_json)
+                        .send()
+                })
             }?;
 
             if !response.status().is_success() {
@@ -154,7 +155,8 @@ impl RpcSender for HttpSender {
                 return Err(response.error_for_status().unwrap_err().into());
             }
 
-            let mut json = response.json::<serde_json::Value>().await?;
+            let mut json =
+                tokio::task::block_in_place(move || response.json::<serde_json::Value>())?;
             if json["error"].is_object() {
                 return match serde_json::from_value::<RpcErrorObject>(json["error"].clone()) {
                     Ok(rpc_error_object) => {
@@ -206,16 +208,14 @@ mod tests {
     #[tokio::test(flavor = "multi_thread")]
     async fn http_sender_on_tokio_multi_thread() {
         let http_sender = HttpSender::new("http://localhost:1234".to_string());
-        let _ = http_sender
-            .send(RpcRequest::GetVersion, serde_json::Value::Null)
-            .await;
+        let _ = http_sender.send(RpcRequest::GetVersion, serde_json::Value::Null);
     }
 
     #[tokio::test(flavor = "current_thread")]
-    async fn http_sender_on_tokio_current_thread() {
-        let http_sender = HttpSender::new("http://localhost:1234".to_string());
-        let _ = http_sender
-            .send(RpcRequest::GetVersion, serde_json::Value::Null)
-            .await;
+    #[should_panic(expected = "can call blocking only when running on the multi-threaded runtime")]
+    async fn http_sender_ontokio_current_thread_should_panic() {
+        // RpcClient::new() will panic in the tokio current-thread runtime due to `tokio::task::block_in_place()` usage, and there
+        // doesn't seem to be a way to detect whether the tokio runtime is multi_thread or current_thread...
+        let _ = HttpSender::new("http://localhost:1234".to_string());
     }
 }

client/src/lib.rs

@@ -4,9 +4,8 @@ extern crate serde_derive;
 
 pub mod blockhash_query;
 pub mod client_error;
-pub(crate) mod http_sender;
-pub(crate) mod mock_sender;
-pub mod nonblocking;
+pub mod http_sender;
+pub mod mock_sender;
 pub mod nonce_utils;
 pub mod perf_utils;
 pub mod pubsub_client;
@@ -18,15 +17,8 @@ pub mod rpc_deprecated_config;
 pub mod rpc_filter;
 pub mod rpc_request;
 pub mod rpc_response;
-pub(crate) mod rpc_sender;
+pub mod rpc_sender;
 pub mod spinner;
 pub mod thin_client;
 pub mod tpu_client;
 pub mod transaction_executor;
-
-pub mod mock_sender_for_cli {
-    /// Magic `SIGNATURE` value used by `solana-cli` unit tests.
-    /// Please don't use this constant.
-    pub const SIGNATURE: &str =
-        "43yNSFC6fYTuPgTNFFhF4axw7AfWxB2BPdurme8yrsWEYwm8299xh8n6TAHjGymiSub1XtyxTNyd9GBfY2hxoBw8";
-}

client/src/mock_sender.rs

@@ -1,4 +1,4 @@
-//! A nonblocking [`RpcSender`] used for unit testing [`RpcClient`](crate::rpc_client::RpcClient).
+//! An [`RpcSender`] used for unit testing [`RpcClient`](crate::rpc_client::RpcClient).
 
 use {
     crate::{
@@ -15,7 +15,6 @@ use {
         },
         rpc_sender::*,
     },
-    async_trait::async_trait,
     serde_json::{json, Number, Value},
     solana_account_decoder::{UiAccount, UiAccountEncoding},
     solana_sdk::{
@@ -41,6 +40,8 @@ use {
 };
 
 pub const PUBKEY: &str = "7RoSF9fUmdphVCpabEoefH81WwrW7orsWonXWqTXkKV8";
+pub const SIGNATURE: &str =
+    "43yNSFC6fYTuPgTNFFhF4axw7AfWxB2BPdurme8yrsWEYwm8299xh8n6TAHjGymiSub1XtyxTNyd9GBfY2hxoBw8";
 
 pub type Mocks = HashMap<RpcRequest, Value>;
 pub struct MockSender {
@@ -74,29 +75,24 @@ pub struct MockSender {
 ///    from [`RpcRequest`] to a JSON [`Value`] response, Any entries in this map
 ///    override the default behavior for the given request.
 impl MockSender {
-    pub fn new<U: ToString>(url: U) -> Self {
+    pub fn new(url: String) -> Self {
         Self::new_with_mocks(url, Mocks::default())
     }
 
-    pub fn new_with_mocks<U: ToString>(url: U, mocks: Mocks) -> Self {
+    pub fn new_with_mocks(url: String, mocks: Mocks) -> Self {
         Self {
-            url: url.to_string(),
+            url,
             mocks: RwLock::new(mocks),
         }
     }
 }
 
-#[async_trait]
 impl RpcSender for MockSender {
     fn get_transport_stats(&self) -> RpcTransportStats {
         RpcTransportStats::default()
     }
 
-    async fn send(
-        &self,
-        request: RpcRequest,
-        params: serde_json::Value,
-    ) -> Result<serde_json::Value> {
+    fn send(&self, request: RpcRequest, params: serde_json::Value) -> Result<serde_json::Value> {
         if let Some(value) = self.mocks.write().unwrap().remove(&request) {
             return Ok(value);
         }
@@ -390,7 +386,7 @@ impl RpcSender for MockSender {
             "getBlocksWithLimit" => serde_json::to_value(vec![1, 2, 3])?,
             "getSignaturesForAddress" => {
                 serde_json::to_value(vec![RpcConfirmedTransactionStatusWithSignature {
-                    signature: crate::mock_sender_for_cli::SIGNATURE.to_string(),
+                    signature: SIGNATURE.to_string(),
                     slot: 123,
                     err: None,
                     memo: None,
@@ -439,7 +435,7 @@ impl RpcSender for MockSender {
                 value: vec![Value::Null, Value::Null]
             })?,
             "getProgramAccounts" => {
-                let pubkey = Pubkey::from_str(PUBKEY).unwrap();
+                let pubkey = Pubkey::from_str(&PUBKEY.to_string()).unwrap();
                 let account = Account {
                     lamports: 1_000_000,
                     data: vec![],

client/src/nonblocking/mod.rs

@@ -1,2 +0,0 @@
-pub mod pubsub_client;
-pub mod rpc_client;

client/src/nonblocking/pubsub_client.rs

@@ -1,341 +0,0 @@
-use {
-    crate::{
-        http_sender::RpcErrorObject,
-        rpc_config::{
-            RpcAccountInfoConfig, RpcBlockSubscribeConfig, RpcBlockSubscribeFilter,
-            RpcProgramAccountsConfig, RpcSignatureSubscribeConfig, RpcTransactionLogsConfig,
-            RpcTransactionLogsFilter,
-        },
-        rpc_response::{
-            Response as RpcResponse, RpcBlockUpdate, RpcKeyedAccount, RpcLogsResponse,
-            RpcSignatureResult, RpcVote, SlotInfo, SlotUpdate,
-        },
-    },
-    futures_util::{
-        future::{ready, BoxFuture, FutureExt},
-        sink::SinkExt,
-        stream::{BoxStream, StreamExt},
-    },
-    log::*,
-    serde::de::DeserializeOwned,
-    serde_json::{json, Map, Value},
-    solana_account_decoder::UiAccount,
-    solana_sdk::{clock::Slot, pubkey::Pubkey, signature::Signature},
-    std::collections::BTreeMap,
-    thiserror::Error,
-    tokio::{
-        net::TcpStream,
-        sync::{mpsc, oneshot},
-        task::JoinHandle,
-        time::{sleep, Duration},
-    },
-    tokio_stream::wrappers::UnboundedReceiverStream,
-    tokio_tungstenite::{
-        connect_async,
-        tungstenite::{
-            protocol::frame::{coding::CloseCode, CloseFrame},
-            Message,
-        },
-        MaybeTlsStream, WebSocketStream,
-    },
-    url::Url,
-};
-
-pub type PubsubClientResult<T = ()> = Result<T, PubsubClientError>;
-
-#[derive(Debug, Error)]
-pub enum PubsubClientError {
-    #[error("url parse error")]
-    UrlParseError(#[from] url::ParseError),
-
-    #[error("unable to connect to server")]
-    ConnectionError(tokio_tungstenite::tungstenite::Error),
-
-    #[error("websocket error")]
-    WsError(#[from] tokio_tungstenite::tungstenite::Error),
-
-    #[error("connection closed (({0})")]
-    ConnectionClosed(String),
-
-    #[error("json parse error")]
-    JsonParseError(#[from] serde_json::error::Error),
-
-    #[error("subscribe failed: {reason}")]
-    SubscribeFailed { reason: String, message: String },
-}
-
-type UnsubscribeFn = Box<dyn FnOnce() -> BoxFuture<'static, ()> + Send>;
-type SubscribeResponseMsg =
-    Result<(mpsc::UnboundedReceiver<Value>, UnsubscribeFn), PubsubClientError>;
-type SubscribeRequestMsg = (String, Value, oneshot::Sender<SubscribeResponseMsg>);
-type SubscribeResult<'a, T> = PubsubClientResult<(BoxStream<'a, T>, UnsubscribeFn)>;
-
-#[derive(Debug)]
-pub struct PubsubClient {
-    subscribe_tx: mpsc::UnboundedSender<SubscribeRequestMsg>,
-    shutdown_tx: oneshot::Sender<()>,
-    ws: JoinHandle<PubsubClientResult>,
-}
-
-impl PubsubClient {
-    pub async fn new(url: &str) -> PubsubClientResult<Self> {
-        let url = Url::parse(url)?;
-        let (ws, _response) = connect_async(url)
-            .await
-            .map_err(PubsubClientError::ConnectionError)?;
-
-        let (subscribe_tx, subscribe_rx) = mpsc::unbounded_channel();
-        let (shutdown_tx, shutdown_rx) = oneshot::channel();
-
-        Ok(Self {
-            subscribe_tx,
-            shutdown_tx,
-            ws: tokio::spawn(PubsubClient::run_ws(ws, subscribe_rx, shutdown_rx)),
-        })
-    }
-
-    pub async fn shutdown(self) -> PubsubClientResult {
-        let _ = self.shutdown_tx.send(());
-        self.ws.await.unwrap() // WS future should not be cancelled or panicked
-    }
-
-    async fn subscribe<'a, T>(&self, operation: &str, params: Value) -> SubscribeResult<'a, T>
-    where
-        T: DeserializeOwned + Send + 'a,
-    {
-        let (response_tx, response_rx) = oneshot::channel();
-        self.subscribe_tx
-            .send((operation.to_string(), params, response_tx))
-            .map_err(|err| PubsubClientError::ConnectionClosed(err.to_string()))?;
-
-        let (notifications, unsubscribe) = response_rx
-            .await
-            .map_err(|err| PubsubClientError::ConnectionClosed(err.to_string()))??;
-        Ok((
-            UnboundedReceiverStream::new(notifications)
-                .filter_map(|value| ready(serde_json::from_value::<T>(value).ok()))
-                .boxed(),
-            unsubscribe,
-        ))
-    }
-
-    pub async fn account_subscribe(
-        &self,
-        pubkey: &Pubkey,
-        config: Option<RpcAccountInfoConfig>,
-    ) -> SubscribeResult<'_, RpcResponse<UiAccount>> {
-        let params = json!([pubkey.to_string(), config]);
-        self.subscribe("account", params).await
-    }
-
-    pub async fn block_subscribe(
-        &self,
-        filter: RpcBlockSubscribeFilter,
-        config: Option<RpcBlockSubscribeConfig>,
-    ) -> SubscribeResult<'_, RpcResponse<RpcBlockUpdate>> {
-        self.subscribe("block", json!([filter, config])).await
-    }
-
-    pub async fn logs_subscribe(
-        &self,
-        filter: RpcTransactionLogsFilter,
-        config: RpcTransactionLogsConfig,
-    ) -> SubscribeResult<'_, RpcResponse<RpcLogsResponse>> {
-        self.subscribe("logs", json!([filter, config])).await
-    }
-
-    pub async fn program_subscribe(
-        &self,
-        pubkey: &Pubkey,
-        config: Option<RpcProgramAccountsConfig>,
-    ) -> SubscribeResult<'_, RpcResponse<RpcKeyedAccount>> {
-        let params = json!([pubkey.to_string(), config]);
-        self.subscribe("program", params).await
-    }
-
-    pub async fn vote_subscribe(&self) -> SubscribeResult<'_, RpcVote> {
-        self.subscribe("vote", json!([])).await
-    }
-
-    pub async fn root_subscribe(&self) -> SubscribeResult<'_, Slot> {
-        self.subscribe("root", json!([])).await
-    }
-
-    pub async fn signature_subscribe(
-        &self,
-        signature: &Signature,
-        config: Option<RpcSignatureSubscribeConfig>,
-    ) -> SubscribeResult<'_, RpcResponse<RpcSignatureResult>> {
-        let params = json!([signature.to_string(), config]);
-        self.subscribe("signature", params).await
-    }
-
-    pub async fn slot_subscribe(&self) -> SubscribeResult<'_, SlotInfo> {
-        self.subscribe("slot", json!([])).await
-    }
-
-    pub async fn slot_updates_subscribe(&self) -> SubscribeResult<'_, SlotUpdate> {
-        self.subscribe("slotsUpdates", json!([])).await
-    }
-
-    async fn run_ws(
-        mut ws: WebSocketStream<MaybeTlsStream<TcpStream>>,
-        mut subscribe_rx: mpsc::UnboundedReceiver<SubscribeRequestMsg>,
-        mut shutdown_rx: oneshot::Receiver<()>,
-    ) -> PubsubClientResult {
-        let mut request_id: u64 = 0;
-
-        let mut requests_subscribe = BTreeMap::new();
-        let mut requests_unsubscribe = BTreeMap::<u64, oneshot::Sender<()>>::new();
-        let mut subscriptions = BTreeMap::new();
-        let (unsubscribe_tx, mut unsubscribe_rx) = mpsc::unbounded_channel();
-
-        loop {
-            tokio::select! {
-                // Send close on shutdown signal
-                _ = (&mut shutdown_rx) => {
-                    let frame = CloseFrame { code: CloseCode::Normal, reason: "".into() };
-                    ws.send(Message::Close(Some(frame))).await?;
-                    ws.flush().await?;
-                    break;
-                },
-                // Send `Message::Ping` each 10s if no any other communication
-                () = sleep(Duration::from_secs(10)) => {
-                    ws.send(Message::Ping(Vec::new())).await?;
-                },
-                // Read message for subscribe
-                Some((operation, params, response_tx)) = subscribe_rx.recv() => {
-                    request_id += 1;
-                    let method = format!("{}Subscribe", operation);
-                    let text = json!({"jsonrpc":"2.0","id":request_id,"method":method,"params":params}).to_string();
-                    ws.send(Message::Text(text)).await?;
-                    requests_subscribe.insert(request_id, (operation, response_tx));
-                },
-                // Read message for unsubscribe
-                Some((operation, sid, response_tx)) = unsubscribe_rx.recv() => {
-                    subscriptions.remove(&sid);
-                    request_id += 1;
-                    let method = format!("{}Unsubscribe", operation);
-                    let text = json!({"jsonrpc":"2.0","id":request_id,"method":method,"params":[sid]}).to_string();
-                    ws.send(Message::Text(text)).await?;
-                    requests_unsubscribe.insert(request_id, response_tx);
-                },
-                // Read incoming WebSocket message
-                next_msg = ws.next() => {
-                    let msg = match next_msg {
-                        Some(msg) => msg?,
-                        None => break,
-                    };
-                    trace!("ws.next(): {:?}", &msg);
-
-                    // Get text from the message
-                    let text = match msg {
-                        Message::Text(text) => text,
-                        Message::Binary(_data) => continue, // Ignore
-                        Message::Ping(data) => {
-                            ws.send(Message::Pong(data)).await?;
-                            continue
-                        },
-                        Message::Pong(_data) => continue,
-                        Message::Close(_frame) => break,
-                        Message::Frame(_frame) => continue,
-                    };
-
-
-                    let mut json: Map<String, Value> = serde_json::from_str(&text)?;
-
-                    // Subscribe/Unsubscribe response, example:
-                    // `{"jsonrpc":"2.0","result":5308752,"id":1}`
-                    if let Some(id) = json.get("id") {
-                        let id = id.as_u64().ok_or_else(|| {
-                            PubsubClientError::SubscribeFailed { reason: "invalid `id` field".into(), message: text.clone() }
-                        })?;
-
-                        let err = json.get("error").map(|error_object| {
-                            match serde_json::from_value::<RpcErrorObject>(error_object.clone()) {
-                                Ok(rpc_error_object) => {
-                                    format!("{} ({})",  rpc_error_object.message, rpc_error_object.code)
-                                }
-                                Err(err) => format!(
-                                    "Failed to deserialize RPC error response: {} [{}]",
-                                    serde_json::to_string(error_object).unwrap(),
-                                    err
-                                )
-                            }
-                        });
-
-                        if let Some(response_tx) = requests_unsubscribe.remove(&id) {
-                            let _ = response_tx.send(()); // do not care if receiver is closed
-                        } else if let Some((operation, response_tx)) = requests_subscribe.remove(&id) {
-                            match err {
-                                Some(reason) => {
-                                    let _ = response_tx.send(Err(PubsubClientError::SubscribeFailed { reason, message: text.clone()}));
-                                },
-                                None => {
-                                    // Subscribe Id
-                                    let sid = json.get("result").and_then(Value::as_u64).ok_or_else(|| {
-                                        PubsubClientError::SubscribeFailed { reason: "invalid `result` field".into(), message: text.clone() }
-                                    })?;
-
-                                    // Create notifications channel and unsubscribe function
-                                    let (notifications_tx, notifications_rx) = mpsc::unbounded_channel();
-                                    let unsubscribe_tx = unsubscribe_tx.clone();
-                                    let unsubscribe = Box::new(move || async move {
-                                        let (response_tx, response_rx) = oneshot::channel();
-                                        // do nothing if ws already closed
-                                        if unsubscribe_tx.send((operation, sid, response_tx)).is_ok() {
-                                            let _ = response_rx.await; // channel can be closed only if ws is closed
-                                        }
-                                    }.boxed());
-
-                                    if response_tx.send(Ok((notifications_rx, unsubscribe))).is_err() {
-                                        break;
-                                    }
-                                    subscriptions.insert(sid, notifications_tx);
-                                }
-                            }
-                        } else {
-                            error!("Unknown request id: {}", id);
-                            break;
-                        }
-                        continue;
-                    }
-
-                    // Notification, example:
-                    // `{"jsonrpc":"2.0","method":"logsNotification","params":{"result":{...},"subscription":3114862}}`
-                    if let Some(Value::Object(params)) = json.get_mut("params") {
-                        if let Some(sid) = params.get("subscription").and_then(Value::as_u64) {
-                            let mut unsubscribe_required = false;
-
-                            if let Some(notifications_tx) = subscriptions.get(&sid) {
-                                if let Some(result) = params.remove("result") {
-                                    if notifications_tx.send(result).is_err() {
-                                        unsubscribe_required = true;
-                                    }
-                                }
-                            } else {
-                                unsubscribe_required = true;
-                            }
-
-                            if unsubscribe_required {
-                                if let Some(Value::String(method)) = json.remove("method") {
-                                    if let Some(operation) = method.strip_suffix("Notification") {
-                                        let (response_tx, _response_rx) = oneshot::channel();
-                                        let _ = unsubscribe_tx.send((operation.to_string(), sid, response_tx));
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    // see client-test/test/client.rs
-}

client/src/nonce_utils.rs

@@ -4,7 +4,6 @@ use {
         account::{Account, ReadableAccount},
         account_utils::StateMut,
         commitment_config::CommitmentConfig,
-        hash::Hash,
         nonce::{
             state::{Data, Versions},
             State,
@@ -22,10 +21,10 @@ pub enum Error {
     InvalidAccountData,
     #[error("unexpected account data size")]
     UnexpectedDataSize,
-    #[error("provided hash ({provided}) does not match nonce hash ({expected})")]
-    InvalidHash { provided: Hash, expected: Hash },
-    #[error("provided authority ({provided}) does not match nonce authority ({expected})")]
-    InvalidAuthority { provided: Pubkey, expected: Pubkey },
+    #[error("query hash does not match stored hash")]
+    InvalidHash,
+    #[error("query authority does not match account authority")]
+    InvalidAuthority,
     #[error("invalid state for requested operation")]
     InvalidStateForOperation,
     #[error("client error: {0}")]

client/src/perf_utils.rs

@@ -43,16 +43,18 @@ pub fn sample_txs<T>(
         total_elapsed = start_time.elapsed();
         let elapsed = now.elapsed();
         now = Instant::now();
-        let mut txs =
-            match client.get_transaction_count_with_commitment(CommitmentConfig::processed()) {
-                Err(e) => {
-                    // ThinClient with multiple options should pick a better one now.
-                    info!("Couldn't get transaction count {:?}", e);
-                    sleep(Duration::from_secs(sample_period));
-                    continue;
-                }
-                Ok(tx_count) => tx_count,
-            };
+        let mut txs;
+        match client.get_transaction_count_with_commitment(CommitmentConfig::processed()) {
+            Err(e) => {
+                // ThinClient with multiple options should pick a better one now.
+                info!("Couldn't get transaction count {:?}", e);
+                sleep(Duration::from_secs(sample_period));
+                continue;
+            }
+            Ok(tx_count) => {
+                txs = tx_count;
+            }
+        }
 
         if txs < last_txs {
             info!("Expected txs({}) >= last_txs({})", txs, last_txs);

client/src/pubsub_client.rs

@@ -10,7 +10,6 @@ use {
             RpcSignatureResult, RpcVote, SlotInfo, SlotUpdate,
         },
     },
-    crossbeam_channel::{unbounded, Receiver, Sender},
     log::*,
     serde::de::DeserializeOwned,
     serde_json::{
@@ -25,6 +24,7 @@ use {
         net::TcpStream,
         sync::{
             atomic::{AtomicBool, Ordering},
+            mpsc::{channel, Receiver, Sender},
             Arc, RwLock,
         },
         thread::{sleep, JoinHandle},
@@ -242,7 +242,7 @@ impl PubsubClient {
     ) -> Result<AccountSubscription, PubsubClientError> {
         let url = Url::parse(url)?;
         let socket = connect_with_retry(url)?;
-        let (sender, receiver) = unbounded();
+        let (sender, receiver) = channel();
 
         let socket = Arc::new(RwLock::new(socket));
         let socket_clone = socket.clone();
@@ -283,7 +283,7 @@ impl PubsubClient {
     ) -> Result<BlockSubscription, PubsubClientError> {
         let url = Url::parse(url)?;
         let socket = connect_with_retry(url)?;
-        let (sender, receiver) = unbounded();
+        let (sender, receiver) = channel();
 
         let socket = Arc::new(RwLock::new(socket));
         let socket_clone = socket.clone();
@@ -305,7 +305,7 @@ impl PubsubClient {
 
         let result = PubsubClientSubscription {
             message_type: PhantomData,
-            operation: "block",
+            operation: "blocks",
             socket,
             subscription_id,
             t_cleanup: Some(t_cleanup),
@@ -322,7 +322,7 @@ impl PubsubClient {
     ) -> Result<LogsSubscription, PubsubClientError> {
         let url = Url::parse(url)?;
         let socket = connect_with_retry(url)?;
-        let (sender, receiver) = unbounded();
+        let (sender, receiver) = channel();
 
         let socket = Arc::new(RwLock::new(socket));
         let socket_clone = socket.clone();
@@ -361,7 +361,7 @@ impl PubsubClient {
     ) -> Result<ProgramSubscription, PubsubClientError> {
         let url = Url::parse(url)?;
         let socket = connect_with_retry(url)?;
-        let (sender, receiver) = unbounded();
+        let (sender, receiver) = channel();
 
         let socket = Arc::new(RwLock::new(socket));
         let socket_clone = socket.clone();
@@ -398,7 +398,7 @@ impl PubsubClient {
     pub fn vote_subscribe(url: &str) -> Result<VoteSubscription, PubsubClientError> {
         let url = Url::parse(url)?;
         let socket = connect_with_retry(url)?;
-        let (sender, receiver) = unbounded();
+        let (sender, receiver) = channel();
 
         let socket = Arc::new(RwLock::new(socket));
         let socket_clone = socket.clone();
@@ -431,7 +431,7 @@ impl PubsubClient {
     pub fn root_subscribe(url: &str) -> Result<RootSubscription, PubsubClientError> {
         let url = Url::parse(url)?;
         let socket = connect_with_retry(url)?;
-        let (sender, receiver) = unbounded();
+        let (sender, receiver) = channel();
 
         let socket = Arc::new(RwLock::new(socket));
         let socket_clone = socket.clone();
@@ -468,7 +468,7 @@ impl PubsubClient {
     ) -> Result<SignatureSubscription, PubsubClientError> {
         let url = Url::parse(url)?;
         let socket = connect_with_retry(url)?;
-        let (sender, receiver) = unbounded();
+        let (sender, receiver) = channel();
 
         let socket = Arc::new(RwLock::new(socket));
         let socket_clone = socket.clone();
@@ -506,7 +506,7 @@ impl PubsubClient {
     pub fn slot_subscribe(url: &str) -> Result<SlotsSubscription, PubsubClientError> {
         let url = Url::parse(url)?;
         let socket = connect_with_retry(url)?;
-        let (sender, receiver) = unbounded::<SlotInfo>();
+        let (sender, receiver) = channel::<SlotInfo>();
 
         let socket = Arc::new(RwLock::new(socket));
         let socket_clone = socket.clone();
@@ -615,5 +615,5 @@ impl PubsubClient {
 
 #[cfg(test)]
 mod tests {
-    // see client-test/test/client.rs
+    // see core/tests/client.rs#test_slot_subscription()
 }

client/src/rpc_custom_error.rs

@@ -20,7 +20,6 @@ pub const JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: i64 = -32011;
 pub const JSON_RPC_SCAN_ERROR: i64 = -32012;
 pub const JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: i64 = -32013;
 pub const JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: i64 = -32014;
-pub const JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: i64 = -32015;
 
 #[derive(Error, Debug)]
 pub enum RpcCustomError {
@@ -58,8 +57,6 @@ pub enum RpcCustomError {
     TransactionSignatureLenMismatch,
     #[error("BlockStatusNotAvailableYet")]
     BlockStatusNotAvailableYet { slot: Slot },
-    #[error("UnsupportedTransactionVersion")]
-    UnsupportedTransactionVersion,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -172,11 +169,6 @@ impl From<RpcCustomError> for Error {
                 message: format!("Block status not yet available for slot {}", slot),
                 data: None,
             },
-            RpcCustomError::UnsupportedTransactionVersion => Self {
-                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION),
-                message: "Versioned transactions are not supported".to_string(),
-                data: None,
-            },
         }
     }
 }

client/src/rpc_response.rs

@@ -290,8 +290,6 @@ pub struct RpcIdentity {
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcVote {
-    /// Vote account address, as base-58 encoded string
-    pub vote_pubkey: String,
     pub slots: Vec<Slot>,
     pub hash: String,
     pub timestamp: Option<UnixTimestamp>,
@@ -431,9 +429,6 @@ pub struct RpcInflationReward {
 pub enum RpcBlockUpdateError {
     #[error("block store error")]
     BlockStoreError,
-
-    #[error("unsupported transaction version")]
-    UnsupportedTransactionVersion,
 }
 
 #[derive(Serialize, Deserialize, Debug)]

client/src/rpc_sender.rs

@@ -1,7 +1,7 @@
 //! A transport for RPC calls.
+
 use {
     crate::{client_error::Result, rpc_request::RpcRequest},
-    async_trait::async_trait,
     std::time::Duration,
 };
 
@@ -26,14 +26,10 @@ pub struct RpcTransportStats {
 /// It is typically implemented by [`HttpSender`] in production, and
 /// [`MockSender`] in unit tests.
 ///
+/// [`RpcClient`]: crate::rpc_client::RpcClient
 /// [`HttpSender`]: crate::http_sender::HttpSender
 /// [`MockSender`]: crate::mock_sender::MockSender
-#[async_trait]
 pub trait RpcSender {
-    async fn send(
-        &self,
-        request: RpcRequest,
-        params: serde_json::Value,
-    ) -> Result<serde_json::Value>;
+    fn send(&self, request: RpcRequest, params: serde_json::Value) -> Result<serde_json::Value>;
     fn get_transport_stats(&self) -> RpcTransportStats;
 }

core/Cargo.toml

@@ -20,8 +20,8 @@ bincode = "1.3.3"
 bs58 = "0.4.0"
 chrono = { version = "0.4.11", features = ["serde"] }
 crossbeam-channel = "0.5"
-dashmap = { version = "4.0.2", features = ["rayon", "raw-api"] }
-etcd-client = { version = "0.8.3", features = ["tls"]}
+dashmap = { version = "5.0.0", features = ["rayon", "raw-api"] }
+etcd-client = { version = "0.8.2", features = ["tls"]}
 fs_extra = "1.2.0"
 histogram = "0.6.9"
 itertools = "0.10.3"
@@ -31,10 +31,8 @@ rand = "0.7.0"
 rand_chacha = "0.2.2"
 rayon = "1.5.1"
 retain_mut = "0.1.5"
-serde = "1.0.136"
+serde = "1.0.133"
 serde_derive = "1.0.103"
-solana-address-lookup-table-program = { path = "../programs/address-lookup-table", version = "=1.10.0" }
-solana-bloom = { path = "../bloom", version = "=1.10.0" }
 solana-accountsdb-plugin-manager = { path = "../accountsdb-plugin-manager", version = "=1.10.0" }
 solana-client = { path = "../client", version = "=1.10.0" }
 solana-entry = { path = "../entry", version = "=1.10.0" }
@@ -56,7 +54,7 @@ solana-send-transaction-service = { path = "../send-transaction-service", versio
 solana-streamer = { path = "../streamer", version = "=1.10.0" }
 solana-transaction-status = { path = "../transaction-status", version = "=1.10.0" }
 solana-vote-program = { path = "../programs/vote", version = "=1.10.0" }
-tempfile = "3.3.0"
+tempfile = "3.2.0"
 thiserror = "1.0"
 solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "=1.10.0" }
 sys-info = "0.9.1"
@@ -64,11 +62,15 @@ tokio = { version = "1", features = ["full"] }
 trees = "0.4.2"
 
 [dev-dependencies]
+jsonrpc-core = "18.0.0"
+jsonrpc-core-client = { version = "18.0.0", features = ["ipc", "ws"] }
+jsonrpc-derive = "18.0.0"
+jsonrpc-pubsub = "18.0.0"
 matches = "0.1.9"
-raptorq = "1.6.5"
-reqwest = { version = "0.11.9", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-serde_json = "1.0.78"
-serial_test = "0.6.0"
+raptorq = "1.6.4"
+reqwest = { version = "0.11.6", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+serde_json = "1.0.74"
+serial_test = "0.5.1"
 solana-logger = { path = "../logger", version = "=1.10.0" }
 solana-program-runtime = { path = "../program-runtime", version = "=1.10.0" }
 solana-stake-program = { path = "../programs/stake", version = "=1.10.0" }
@@ -76,9 +78,6 @@ solana-version = { path = "../version", version = "=1.10.0" }
 static_assertions = "1.1.0"
 systemstat = "0.1.10"
 
-[target."cfg(unix)".dependencies]
-sysctl = "0.4.3"
-
 [build-dependencies]
 rustc_version = "0.4"
 

core/benches/banking_stage.rs

@@ -4,13 +4,13 @@
 extern crate test;
 
 use {
-    crossbeam_channel::{unbounded, Receiver},
+    crossbeam_channel::unbounded,
     log::*,
     rand::{thread_rng, Rng},
     rayon::prelude::*,
     solana_core::{
         banking_stage::{BankingStage, BankingStageStats},
-        leader_slot_banking_stage_metrics::LeaderSlotMetricsTracker,
+        packet_deduper::PacketDeduper,
         qos_service::QosService,
     },
     solana_entry::entry::{next_hash, Entry},
@@ -37,7 +37,7 @@ use {
     solana_streamer::socket::SocketAddrSpace,
     std::{
         collections::VecDeque,
-        sync::{atomic::Ordering, Arc, RwLock},
+        sync::{atomic::Ordering, mpsc::Receiver, Arc, RwLock},
         time::{Duration, Instant},
     },
     test::Bencher,
@@ -71,7 +71,7 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
             Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"),
         );
         let (exit, poh_recorder, poh_service, _signal_receiver) =
-            create_test_recorder(&bank, &blockstore, None, None);
+            create_test_recorder(&bank, &blockstore, None);
 
         let recorder = poh_recorder.lock().unwrap().recorder();
 
@@ -99,7 +99,6 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
                 &BankingStageStats::default(),
                 &recorder,
                 &QosService::new(Arc::new(RwLock::new(CostModel::default())), 1),
-                &mut LeaderSlotMetricsTracker::new(0),
             );
         });
 
@@ -170,13 +169,13 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
     let (vote_sender, vote_receiver) = unbounded();
     let mut bank = Bank::new_for_benches(&genesis_config);
     // Allow arbitrary transaction processing time for the purposes of this bench
-    bank.ns_per_slot = u128::MAX;
-    let bank = Arc::new(bank);
+    bank.ns_per_slot = std::u128::MAX;
+    let bank = Arc::new(Bank::new_for_benches(&genesis_config));
 
     // set cost tracker limits to MAX so it will not filter out TXs
     bank.write_cost_tracker()
         .unwrap()
-        .set_limits(std::u64::MAX, std::u64::MAX, std::u64::MAX);
+        .set_limits(std::u64::MAX, std::u64::MAX);
 
     debug!("threads: {} txs: {}", num_threads, txes);
 
@@ -215,7 +214,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
             Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"),
         );
         let (exit, poh_recorder, poh_service, signal_receiver) =
-            create_test_recorder(&bank, &blockstore, None, None);
+            create_test_recorder(&bank, &blockstore, None);
         let cluster_info = ClusterInfo::new(
             Node::new_localhost().info,
             Arc::new(Keypair::new()),
@@ -223,6 +222,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
         );
         let cluster_info = Arc::new(cluster_info);
         let (s, _r) = unbounded();
+        let packet_deduper = PacketDeduper::default();
         let _banking_stage = BankingStage::new(
             &cluster_info,
             &poh_recorder,
@@ -232,6 +232,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
             None,
             s,
             Arc::new(RwLock::new(CostModel::default())),
+            packet_deduper.clone(),
         );
         poh_recorder.lock().unwrap().set_bank(&bank);
 
@@ -266,6 +267,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
             // in this chunk, but since we rotate between CHUNKS then
             // we should clear them by the time we come around again to re-use that chunk.
             bank.clear_signatures();
+            packet_deduper.reset();
             trace!(
                 "time: {} checked: {} sent: {}",
                 duration_as_us(&now.elapsed()),

core/benches/cluster_nodes.rs

@@ -1,112 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-
-use {
-    rand::{seq::SliceRandom, Rng},
-    solana_core::{
-        cluster_nodes::{make_test_cluster, new_cluster_nodes, ClusterNodes},
-        retransmit_stage::RetransmitStage,
-    },
-    solana_gossip::contact_info::ContactInfo,
-    solana_sdk::{clock::Slot, hash::hashv, pubkey::Pubkey, signature::Signature},
-    test::Bencher,
-};
-
-const NUM_SIMULATED_SHREDS: usize = 4;
-
-fn make_cluster_nodes<R: Rng>(
-    rng: &mut R,
-    unstaked_ratio: Option<(u32, u32)>,
-) -> (Vec<ContactInfo>, ClusterNodes<RetransmitStage>) {
-    let (nodes, stakes, cluster_info) = make_test_cluster(rng, 5_000, unstaked_ratio);
-    let cluster_nodes = new_cluster_nodes::<RetransmitStage>(&cluster_info, &stakes);
-    (nodes, cluster_nodes)
-}
-
-fn get_retransmit_peers_deterministic(
-    cluster_nodes: &ClusterNodes<RetransmitStage>,
-    slot: &Slot,
-    slot_leader: &Pubkey,
-    num_simulated_shreds: usize,
-) {
-    for i in 0..num_simulated_shreds {
-        // see Shred::seed
-        let shred_seed = hashv(&[
-            &slot.to_le_bytes(),
-            &(i as u32).to_le_bytes(),
-            &slot_leader.to_bytes(),
-        ])
-        .to_bytes();
-
-        let (_neighbors, _children) = cluster_nodes.get_retransmit_peers_deterministic(
-            shred_seed,
-            solana_gossip::cluster_info::DATA_PLANE_FANOUT,
-            *slot_leader,
-        );
-    }
-}
-
-fn get_retransmit_peers_compat(
-    cluster_nodes: &ClusterNodes<RetransmitStage>,
-    slot_leader: &Pubkey,
-    signatures: &[Signature],
-) {
-    for signature in signatures.iter() {
-        // see Shred::seed
-        let signature = signature.as_ref();
-        let offset = signature.len().checked_sub(32).unwrap();
-        let shred_seed = signature[offset..].try_into().unwrap();
-
-        let (_neighbors, _children) = cluster_nodes.get_retransmit_peers_compat(
-            shred_seed,
-            solana_gossip::cluster_info::DATA_PLANE_FANOUT,
-            *slot_leader,
-        );
-    }
-}
-
-fn get_retransmit_peers_deterministic_wrapper(b: &mut Bencher, unstaked_ratio: Option<(u32, u32)>) {
-    let mut rng = rand::thread_rng();
-    let (nodes, cluster_nodes) = make_cluster_nodes(&mut rng, unstaked_ratio);
-    let slot_leader = nodes[1..].choose(&mut rng).unwrap().id;
-    let slot = rand::random::<u64>();
-    b.iter(|| {
-        get_retransmit_peers_deterministic(
-            &cluster_nodes,
-            &slot,
-            &slot_leader,
-            NUM_SIMULATED_SHREDS,
-        )
-    });
-}
-
-fn get_retransmit_peers_compat_wrapper(b: &mut Bencher, unstaked_ratio: Option<(u32, u32)>) {
-    let mut rng = rand::thread_rng();
-    let (nodes, cluster_nodes) = make_cluster_nodes(&mut rng, unstaked_ratio);
-    let slot_leader = nodes[1..].choose(&mut rng).unwrap().id;
-    let signatures: Vec<_> = std::iter::repeat_with(Signature::new_unique)
-        .take(NUM_SIMULATED_SHREDS)
-        .collect();
-    b.iter(|| get_retransmit_peers_compat(&cluster_nodes, &slot_leader, &signatures));
-}
-
-#[bench]
-fn bench_get_retransmit_peers_deterministic_unstaked_ratio_1_2(b: &mut Bencher) {
-    get_retransmit_peers_deterministic_wrapper(b, Some((1, 2)));
-}
-
-#[bench]
-fn bench_get_retransmit_peers_compat_unstaked_ratio_1_2(b: &mut Bencher) {
-    get_retransmit_peers_compat_wrapper(b, Some((1, 2)));
-}
-
-#[bench]
-fn bench_get_retransmit_peers_deterministic_unstaked_ratio_1_32(b: &mut Bencher) {
-    get_retransmit_peers_deterministic_wrapper(b, Some((1, 32)));
-}
-
-#[bench]
-fn bench_get_retransmit_peers_compat_unstaked_ratio_1_32(b: &mut Bencher) {
-    get_retransmit_peers_compat_wrapper(b, Some((1, 32)));
-}

core/benches/retransmit_stage.rs

@@ -4,7 +4,6 @@ extern crate solana_core;
 extern crate test;
 
 use {
-    crossbeam_channel::unbounded,
     log::*,
     solana_core::retransmit_stage::retransmitter,
     solana_entry::entry::Entry,
@@ -31,6 +30,7 @@ use {
         net::UdpSocket,
         sync::{
             atomic::{AtomicUsize, Ordering},
+            mpsc::channel,
             Arc, RwLock,
         },
         thread::{sleep, Builder},
@@ -77,7 +77,7 @@ fn bench_retransmitter(bencher: &mut Bencher) {
     let bank_forks = BankForks::new(bank0);
     let bank = bank_forks.working_bank();
     let bank_forks = Arc::new(RwLock::new(bank_forks));
-    let (shreds_sender, shreds_receiver) = unbounded();
+    let (shreds_sender, shreds_receiver) = channel();
     const NUM_THREADS: usize = 2;
     let sockets = (0..NUM_THREADS)
         .map(|_| UdpSocket::bind("0.0.0.0:0").unwrap())

core/benches/sigverify_stage.rs

@@ -1,5 +1,4 @@
 #![feature(test)]
-#![allow(clippy::integer_arithmetic)]
 
 extern crate solana_core;
 extern crate test;
@@ -9,21 +8,22 @@ use {
     log::*,
     rand::{thread_rng, Rng},
     solana_core::{sigverify::TransactionSigVerifier, sigverify_stage::SigVerifyStage},
-    solana_perf::{
-        packet::{to_packet_batches, PacketBatch},
-        test_tx::test_tx,
-    },
+    solana_perf::{packet::to_packet_batches, test_tx::test_tx},
     solana_sdk::{
         hash::Hash,
         signature::{Keypair, Signer},
         system_transaction,
         timing::duration_as_ms,
     },
-    std::time::{Duration, Instant},
+    std::{
+        sync::mpsc::channel,
+        time::{Duration, Instant},
+    },
     test::Bencher,
 };
 
-fn run_bench_packet_discard(num_ips: usize, bencher: &mut Bencher) {
+#[bench]
+fn bench_packet_discard(bencher: &mut Bencher) {
     solana_logger::setup();
     let len = 30 * 1000;
     let chunk_size = 1024;
@@ -32,7 +32,7 @@ fn run_bench_packet_discard(num_ips: usize, bencher: &mut Bencher) {
 
     let mut total = 0;
 
-    let ips: Vec<_> = (0..num_ips)
+    let ips: Vec<_> = (0..10_000)
         .into_iter()
         .map(|_| {
             let mut addr = [0u16; 8];
@@ -52,70 +52,27 @@ fn run_bench_packet_discard(num_ips: usize, bencher: &mut Bencher) {
 
     bencher.iter(move || {
         SigVerifyStage::discard_excess_packets(&mut batches, 10_000);
-        let mut num_packets = 0;
         for batch in batches.iter_mut() {
             for p in batch.packets.iter_mut() {
-                if !p.meta.discard() {
-                    num_packets += 1;
-                }
                 p.meta.set_discard(false);
             }
         }
-        assert_eq!(num_packets, 10_000);
     });
 }
 
 #[bench]
-fn bench_packet_discard_many_senders(bencher: &mut Bencher) {
-    run_bench_packet_discard(1000, bencher);
-}
+fn bench_sigverify_stage(bencher: &mut Bencher) {
+    solana_logger::setup();
+    let (packet_s, packet_r) = channel();
+    let (verified_s, verified_r) = unbounded();
+    let verifier = TransactionSigVerifier::default();
+    let stage = SigVerifyStage::new(packet_r, verified_s, verifier);
 
-#[bench]
-fn bench_packet_discard_single_sender(bencher: &mut Bencher) {
-    run_bench_packet_discard(1, bencher);
-}
-
-#[bench]
-fn bench_packet_discard_mixed_senders(bencher: &mut Bencher) {
-    const SIZE: usize = 30 * 1000;
-    const CHUNK_SIZE: usize = 1024;
-    fn new_rand_addr<R: Rng>(rng: &mut R) -> std::net::IpAddr {
-        let mut addr = [0u16; 8];
-        rng.fill(&mut addr);
-        std::net::IpAddr::from(addr)
-    }
-    let mut rng = thread_rng();
-    let mut batches = to_packet_batches(&vec![test_tx(); SIZE], CHUNK_SIZE);
-    let spam_addr = new_rand_addr(&mut rng);
-    for batch in batches.iter_mut() {
-        for packet in batch.packets.iter_mut() {
-            // One spam address, ~1000 unique addresses.
-            packet.meta.addr = if rng.gen_ratio(1, 30) {
-                new_rand_addr(&mut rng)
-            } else {
-                spam_addr
-            }
-        }
-    }
-    bencher.iter(move || {
-        SigVerifyStage::discard_excess_packets(&mut batches, 10_000);
-        let mut num_packets = 0;
-        for batch in batches.iter_mut() {
-            for packet in batch.packets.iter_mut() {
-                if !packet.meta.discard() {
-                    num_packets += 1;
-                }
-                packet.meta.set_discard(false);
-            }
-        }
-        assert_eq!(num_packets, 10_000);
-    });
-}
-
-fn gen_batches(use_same_tx: bool) -> Vec<PacketBatch> {
+    let now = Instant::now();
     let len = 4096;
+    let use_same_tx = true;
     let chunk_size = 1024;
-    if use_same_tx {
+    let mut batches = if use_same_tx {
         let tx = test_tx();
         to_packet_batches(&vec![tx; len], chunk_size)
     } else {
@@ -133,28 +90,14 @@ fn gen_batches(use_same_tx: bool) -> Vec<PacketBatch> {
             })
             .collect();
         to_packet_batches(&txs, chunk_size)
-    }
-}
+    };
 
-#[bench]
-fn bench_sigverify_stage(bencher: &mut Bencher) {
-    solana_logger::setup();
-    trace!("start");
-    let (packet_s, packet_r) = unbounded();
-    let (verified_s, verified_r) = unbounded();
-    let verifier = TransactionSigVerifier::default();
-    let stage = SigVerifyStage::new(packet_r, verified_s, verifier);
-
-    let use_same_tx = true;
+    trace!(
+        "starting... generation took: {} ms batches: {}",
+        duration_as_ms(&now.elapsed()),
+        batches.len()
+    );
     bencher.iter(move || {
-        let now = Instant::now();
-        let mut batches = gen_batches(use_same_tx);
-        trace!(
-            "starting... generation took: {} ms batches: {}",
-            duration_as_ms(&now.elapsed()),
-            batches.len()
-        );
-
         let mut sent_len = 0;
         for _ in 0..batches.len() {
             if let Some(batch) = batches.pop() {
@@ -170,7 +113,7 @@ fn bench_sigverify_stage(bencher: &mut Bencher) {
                     received += v.packets.len();
                     batches.push(v);
                 }
-                if use_same_tx || received >= sent_len {
+                if received >= sent_len {
                     break;
                 }
             }