no lockups for community (bp #7366) (#7367)

automerge

Cargo.toml

@@ -44,6 +44,7 @@ members = [
     "runtime",
     "sdk",
     "sdk-c",
+    "scripts",
     "upload-perf",
     "net-utils",
     "fixed-buf",

archiver/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-archiver"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -10,10 +10,10 @@ homepage = "https://solana.com/"
 [dependencies]
 clap = "2.33.0"
 console = "0.9.1"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-core = { path = "../core", version = "0.21.0" }
+solana-core = { path = "../core", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-metrics = { path = "../metrics", version = "0.21.0" }
+solana-metrics = { path = "../metrics", version = "0.21.2" }
-solana-net-utils = { path = "../net-utils", version = "0.21.0" }
+solana-net-utils = { path = "../net-utils", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 

banking-bench/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-banking-bench"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -10,11 +10,11 @@ homepage = "https://solana.com/"
 [dependencies]
 log = "0.4.6"
 rayon = "1.2.0"
-solana-core = { path = "../core", version = "0.21.0" }
+solana-core = { path = "../core", version = "0.21.2" }
-solana-ledger = { path = "../ledger", version = "0.21.0" }
+solana-ledger = { path = "../ledger", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-runtime = { path = "../runtime", version = "0.21.0" }
+solana-runtime = { path = "../runtime", version = "0.21.2" }
-solana-measure = { path = "../measure", version = "0.21.0" }
+solana-measure = { path = "../measure", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 rand = "0.6.5"
 crossbeam-channel = "0.3"

bench-exchange/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-exchange"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -23,19 +23,19 @@ serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
 serde_yaml = "0.8.11"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-core = { path = "../core", version = "0.21.0" }
+solana-core = { path = "../core", version = "0.21.2" }
-solana-genesis = { path = "../genesis", version = "0.21.0" }
+solana-genesis = { path = "../genesis", version = "0.21.2" }
-solana-client = { path = "../client", version = "0.21.0" }
+solana-client = { path = "../client", version = "0.21.2" }
-solana-drone = { path = "../drone", version = "0.21.0" }
+solana-drone = { path = "../drone", version = "0.21.2" }
-solana-exchange-program = { path = "../programs/exchange", version = "0.21.0" }
+solana-exchange-program = { path = "../programs/exchange", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-metrics = { path = "../metrics", version = "0.21.0" }
+solana-metrics = { path = "../metrics", version = "0.21.2" }
-solana-net-utils = { path = "../net-utils", version = "0.21.0" }
+solana-net-utils = { path = "../net-utils", version = "0.21.2" }
-solana-runtime = { path = "../runtime", version = "0.21.0" }
+solana-runtime = { path = "../runtime", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 untrusted = "0.7.0"
 ws = "0.9.1"
 
 [dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "0.21.0" }
+solana-local-cluster = { path = "../local-cluster", version = "0.21.2" }

bench-streamer/Cargo.toml

@@ -2,14 +2,14 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-streamer"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
 clap = "2.33.0"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-core = { path = "../core", version = "0.21.0" }
+solana-core = { path = "../core", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-net-utils = { path = "../net-utils", version = "0.21.0" }
+solana-net-utils = { path = "../net-utils", version = "0.21.2" }

bench-tps/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -16,24 +16,24 @@ serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
 serde_yaml = "0.8.11"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-core = { path = "../core", version = "0.21.0" }
+solana-core = { path = "../core", version = "0.21.2" }
-solana-genesis = { path = "../genesis", version = "0.21.0" }
+solana-genesis = { path = "../genesis", version = "0.21.2" }
-solana-client = { path = "../client", version = "0.21.0" }
+solana-client = { path = "../client", version = "0.21.2" }
-solana-drone = { path = "../drone", version = "0.21.0" }
+solana-drone = { path = "../drone", version = "0.21.2" }
-solana-librapay-api = { path = "../programs/librapay_api", version = "0.21.0", optional = true }
+solana-librapay-api = { path = "../programs/librapay_api", version = "0.21.2", optional = true }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-metrics = { path = "../metrics", version = "0.21.0" }
+solana-metrics = { path = "../metrics", version = "0.21.2" }
-solana-measure = { path = "../measure", version = "0.21.0" }
+solana-measure = { path = "../measure", version = "0.21.2" }
-solana-net-utils = { path = "../net-utils", version = "0.21.0" }
+solana-net-utils = { path = "../net-utils", version = "0.21.2" }
-solana-runtime = { path = "../runtime", version = "0.21.0" }
+solana-runtime = { path = "../runtime", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
-solana-move-loader-program = { path = "../programs/move_loader", version = "0.21.0", optional = true }
+solana-move-loader-program = { path = "../programs/move_loader", version = "0.21.2", optional = true }
 
 [dev-dependencies]
 serial_test = "0.2.0"
 serial_test_derive = "0.2.0"
-solana-local-cluster = { path = "../local-cluster", version = "0.21.0" }
+solana-local-cluster = { path = "../local-cluster", version = "0.21.2" }
 
 [features]
 move = ["solana-librapay-api", "solana-move-loader-program"]

book/src/SUMMARY.md

@@ -36,6 +36,10 @@
   * [Troubleshooting](running-validator/validator-troubleshoot.md)
   * [FAQ](running-validator/validator-faq.md)
 * [Running an Archiver](running-archiver.md)
+* [Paper Wallet](paper-wallet/README.md)
+  * [Installation](paper-wallet/installation.md)
+  * [Creating and Using a Seed Phrase](paper-wallet/keypair.md)
+  * [Paper Wallet Usage](paper-wallet/usage.md)
 * [API Reference](api-reference/README.md)
   * [Transaction](api-reference/transaction-api.md)
   * [Instruction](api-reference/instruction-api.md)

book/src/api-reference/cli.md

@@ -177,7 +177,7 @@ $ solana send-timestamp <PUBKEY> <PROCESS_ID> --date 2018-12-24T23:59:00
 ## Usage
 ### solana-cli
 ```text
-solana-cli 0.21.0
+solana-cli 0.21.2
 Blockchain, Rebuilt for Scale
 
 USAGE:
@@ -467,7 +467,7 @@ FLAGS:
 OPTIONS:
         --authorized-voter <PUBKEY>         Public key of the authorized voter (defaults to vote account)
         --authorized-withdrawer <PUBKEY>    Public key of the authorized withdrawer (defaults to cli config pubkey)
-        --commission <NUM>                  The commission taken on reward redemption (0-255), default: 0
+        --commission <NUM>                  The commission taken on reward redemption (0-100), default: 0
     -C, --config <PATH>                     Configuration file to use [default:
                                             ~/.config/solana/cli/config.yml]
     -u, --url <URL>                         JSON RPC URL for the solana cluster

book/src/api-reference/jsonrpc-api.md

@@ -18,6 +18,7 @@ To interact with a Solana node inside a JavaScript application, use the [solana-
 * [getAccountInfo](jsonrpc-api.md#getaccountinfo)
 * [getBalance](jsonrpc-api.md#getbalance)
 * [getBlockCommitment](jsonrpc-api.md#getblockcommitment)
+* [getBlockTime](jsonrpc-api.md#getblocktime)
 * [getClusterNodes](jsonrpc-api.md#getclusternodes)
 * [getConfirmedBlock](jsonrpc-api.md#getconfirmedblock)
 * [getEpochInfo](jsonrpc-api.md#getepochinfo)
@@ -155,7 +156,7 @@ The result value will be an RpcResponse JSON object containing an AccountInfo JS
 curl -X POST -H "Content-Type: application/json" -d '{"jsonrpc":"2.0", "id":1, "method":"getAccountInfo", "params":["2gVkYWexTHR5Hb2aLeQN3tnngvWzisFKXDUPrgMHpdST"]}' http://localhost:8899
 
 // Result
-{"jsonrpc":"2.0","result":{"context":{"slot":1},"value":{"executable":false,"owner":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"lamports":1,"data":[3,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0.21.0,0,0,0,0,0,0,50,48,53,48,45,48,49,45,48,49,84,48,48,58,48,48,58,48,48,90,252,10,7,28,246,140,88,177,98,82,10,227,89,81,18,30,194,101,199,16,11,73,133,20,246,62,114,39,20,113,189,32,50,0,0,0,0,0,0,0,247,15,36,102,167,83,225,42,133,127,82,34,36,224,207,130,109,230,224,188,163,33,213,13,5,117,211,251,65,159,197,51,0,0,0,0,0,0]}},"id":1}
+{"jsonrpc":"2.0","result":{"context":{"slot":1},"value":{"executable":false,"owner":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"lamports":1,"data":[3,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0.21.2,0,0,0,0,0,0,50,48,53,48,45,48,49,45,48,49,84,48,48,58,48,48,58,48,48,90,252,10,7,28,246,140,88,177,98,82,10,227,89,81,18,30,194,101,199,16,11,73,133,20,246,62,114,39,20,113,189,32,50,0,0,0,0,0,0,0,247,15,36,102,167,83,225,42,133,127,82,34,36,224,207,130,109,230,224,188,163,33,213,13,5,117,211,251,65,159,197,51,0,0,0,0,0,0]}},"id":1}
 ```
 
 ### getBalance
@@ -209,6 +210,31 @@ curl -X POST -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1, "m
 {"jsonrpc":"2.0","result":[{"commitment":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,32]},42],"id":1}
 ```
 
+### getBlockTime
+
+Returns the estimated production time of a block. Validators report their UTC
+time to the ledger on a regular interval. A block's time is calculated as an
+offset from the median value of the most recent validator time report.
+
+#### Parameters:
+
+* `u64` - block, identified by Slot
+
+#### Results:
+
+* `null` - block has not yet been produced
+* `i64` - estimated production time, as Unix timestamp (seconds since the Unix epoch)
+
+#### Example:
+
+```bash
+// Request
+curl -X POST -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1, "method":"getBlockTime","params":[5]}' http://localhost:8899
+
+// Result
+{"jsonrpc":"2.0","result":1574721591,"id":1}
+```
+
 ### getClusterNodes
 
 Returns information about all the nodes participating in the cluster
@@ -687,7 +713,7 @@ The result field will be a JSON object of `current` and `delinquent` accounts, e
 * `nodePubkey` - Node public key, as base-58 encoded string
 * `activatedStake` - the stake, in lamports, delegated to this vote account and active in this epoch
 * `epochVoteAccount` - bool, whether the vote account is staked for this epoch
-* `commission`, an 8-bit integer used as a fraction \(commission/MAX\_U8\) for rewards payout
+* `commission`, percentage (0-100) of rewards payout owed to the vote account
 * `lastVote` - Most recent slot voted on by this vote account
 
 #### Example:
@@ -798,7 +824,7 @@ Subscribe to an account to receive notifications when the lamports or data for a
 #### Notification Format:
 
 ```bash
-{"jsonrpc": "2.0","method": "accountNotification", "params": {"result": {"executable":false,"owner":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"lamports":1,"data":[3,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0.21.0,0,0,0,0,0,0,50,48,53,48,45,48,49,45,48,49,84,48,48,58,48,48,58,48,48,90,252,10,7,28,246,140,88,177,98,82,10,227,89,81,18,30,194,101,199,16,11,73,133,20,246,62,114,39,20,113,189,32,50,0,0,0,0,0,0,0,247,15,36,102,167,83,225,42,133,127,82,34,36,224,207,130,109,230,224,188,163,33,213,13,5,117,211,251,65,159,197,51,0,0,0,0,0,0]},"subscription":0}}
+{"jsonrpc": "2.0","method": "accountNotification", "params": {"result": {"executable":false,"owner":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"lamports":1,"data":[3,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0.21.2,0,0,0,0,0,0,50,48,53,48,45,48,49,45,48,49,84,48,48,58,48,48,58,48,48,90,252,10,7,28,246,140,88,177,98,82,10,227,89,81,18,30,194,101,199,16,11,73,133,20,246,62,114,39,20,113,189,32,50,0,0,0,0,0,0,0,247,15,36,102,167,83,225,42,133,127,82,34,36,224,207,130,109,230,224,188,163,33,213,13,5,117,211,251,65,159,197,51,0,0,0,0,0,0]},"subscription":0}}
 ```
 
 ### accountUnsubscribe
@@ -856,7 +882,7 @@ Subscribe to a program to receive notifications when the lamports or data for a
 * `object` - account info JSON object \(see [getAccountInfo](jsonrpc-api.md#getaccountinfo) for field details\)
 
   ```bash
-  {"jsonrpc":"2.0","method":"programNotification","params":{{"result":["8Rshv2oMkPu5E4opXTRyuyBeZBqQ4S477VG26wUTFxUM",{"executable":false,"lamports":1,"owner":[129,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"data":[1,1,1,0,0,0,0,0,0,0.21.0,0,0,0,0,0,0,50,48,49,56,45,49,50,45,50,52,84,50,51,58,53,57,58,48,48,90,235,233,39,152,15,44,117,176,41,89,100,86,45,61,2,44,251,46,212,37,35,118,163,189,247,84,27,235,178,62,55,89,0,0,0,0,50,0,0,0,0,0,0,0,235,233,39,152,15,44,117,176,41,89,100,86,45,61,2,44,251,46,212,37,35,118,163,189,247,84,27,235,178,62,45,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}],"subscription":0}}
+  {"jsonrpc":"2.0","method":"programNotification","params":{{"result":["8Rshv2oMkPu5E4opXTRyuyBeZBqQ4S477VG26wUTFxUM",{"executable":false,"lamports":1,"owner":[129,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"data":[1,1,1,0,0,0,0,0,0,0.21.2,0,0,0,0,0,0,50,48,49,56,45,49,50,45,50,52,84,50,51,58,53,57,58,48,48,90,235,233,39,152,15,44,117,176,41,89,100,86,45,61,2,44,251,46,212,37,35,118,163,189,247,84,27,235,178,62,55,89,0,0,0,0,50,0,0,0,0,0,0,0,235,233,39,152,15,44,117,176,41,89,100,86,45,61,2,44,251,46,212,37,35,118,163,189,247,84,27,235,178,62,45,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}],"subscription":0}}
   ```
 
 ### programUnsubscribe

book/src/cluster/stake-delegation-and-rewards.md

@@ -16,7 +16,7 @@ The total stake allocated to a Vote account can be calculated by the sum of all
 
 ## Vote and Stake accounts
 
-The rewards process is split into two on-chain programs. The Vote program solves the problem of making stakes slashable. The Stake account acts as custodian of the rewards pool, and provides passive delegation. The Stake program is responsible for paying out each staker once the staker proves to the Stake program that its delegate has participated in validating the ledger.
+The rewards process is split into two on-chain programs. The Vote program solves the problem of making stakes slashable. The Stake program acts as custodian of the rewards pool and provides for passive delegation. The Stake program is responsible for paying rewards to staker and voter when shown that a staker's delegate has participated in validating the ledger.
 
 ### VoteState
 
@@ -228,4 +228,4 @@ Only lamports in excess of effective+activating stake may be withdrawn at any ti
 
 ### Lock-up
 
-Stake accounts support the notion of lock-up, wherein the stake account balance is unavailable for withdrawal until a specified time. Lock-up is specified as a slot height, i.e. the minimum slot height that must be reached by the network before the stake account balance is available for withdrawal, except to a specified custodian. This information is gathered when the stake account is created.
+Stake accounts support the notion of lock-up, wherein the stake account balance is unavailable for withdrawal until a specified time. Lock-up is specified as an epoch height, i.e. the minimum epoch height that must be reached by the network before the stake account balance is available for withdrawal, unless the transaction is also signed by a specified custodian. This information is gathered when the stake account is created, and stored in the Lockup field of the stake account's state.

book/src/paper-wallet/README.md

@@ -0,0 +1,24 @@
+# Paper Wallet
+
+This document describes how to create and use a paper wallet with the Solana CLI
+tools.
+
+{% hint style="info" %}
+We do not intend to advise on how to *securely* create or manage paper wallets.
+Please research the security concerns carefully.
+{% endhint %}
+
+## Overview
+
+Solana provides a key generation tool to derive keys from BIP39 compliant seed
+phrases. Solana CLI commands for running a validator and staking tokens all
+support keypair input via seed phrases.
+
+To learn more about the BIP39 standard, visit the Bitcoin BIPs Github repository
+[here](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+
+{% page-ref page="installation.md" %}
+
+{% page-ref page="keypair.md" %}
+
+{% page-ref page="usage.md" %}

book/src/paper-wallet/installation.md

@@ -0,0 +1,51 @@
+# Installation Guide
+Follow this guide to setup Solana's key generation tool called `solana-keygen`
+
+{% hint style="warn" %}
+After installation, ensure your version is `0.21.2` or higher by running `solana-keygen -V`
+{% endhint %}
+
+## Download
+First, download the latest release tarball from GitHub.
+
+1. Setup download url
+
+  ```bash
+  solana_downloads=https://github.com/solana-labs/solana/releases/latest/download
+  ```
+
+2. Specify the download file based on your machine
+
+  **MacOS**
+  ```bash
+  solana_release=solana-release-x86_64-apple-darwin.tar.bz2
+  ```
+
+  **Linux**
+  ```bash
+  solana_release=solana-release-x86_64-unknown-linux-gnu.tar.bz2
+  ```
+
+3. Download
+
+  ```bash
+  curl -L -sSf -o solana-release.tar.bz2 $solana_downloads/$solana_release
+  ```
+
+## Extract
+Next, extract the tarball
+```bash
+tar xf solana-release.tar.bz2
+```
+
+## Add to "PATH"
+Now add the tool to your PATH environment variable with the following command
+```bash
+export PATH="$(pwd)/solana-release/bin:${PATH}"
+```
+
+## Check
+Finally, check that `solana-keygen` can be run by running
+```bash
+solana-keygen -V
+```

book/src/paper-wallet/keypair.md

@@ -0,0 +1,70 @@
+# Creating a Paper Wallet
+
+Using the `solana-keygen` tool, it is possible to generate new seed phrases as
+well as derive a keypair from an existing seed phrase and (optional) passphrase.
+The seed phrase and passphrase can be used together as a paper wallet. As long
+as you keep your seed phrase and passphrase stored safely, you can use them to
+access your account.
+
+{% hint style="info" %}
+For more information about how seed phrases work, review this
+[Bitcoin Wiki page](https://en.bitcoin.it/wiki/Seed_phrase).
+{% endhint %}
+
+## Seed Phrase Generation
+
+Generating a new keypair can be done using the `solana-keygen new` command. The
+command will generate a random seed phrase, ask you to enter an optional
+passphrase, and then will display the derived public key and the generated seed
+phrase for your paper wallet.
+
+```bash
+solana-keygen new --no-outfile
+```
+
+{% hint style="warning" %}
+If the `--no-outfile` flag is **omitted**, the default behavior is to write the
+keypair to `~/.config/solana/id.json`
+{% endhint %}
+
+{% hint style="info" %}
+For added security, increase the seed phrase word count using the `--word-count`
+argument
+{% endhint %}
+
+For full usage details run:
+
+```bash
+solana-keygen new --help
+```
+
+## Public Key Derivation
+
+Public keys can be derived from a seed phrase and a passphrase if you choose to
+use one. This is useful for using using an offline-generated seed phrase to
+derive a valid public key. The `solana-keygen pubkey` command will walk you
+through entering your seed phrase and a passphrase if you chose to use one.
+
+```bash
+solana-keygen pubkey ASK
+```
+
+{% hint style="info" %}
+Note that you could potentially use different passphrases for the same seed
+phrase. Each unique passphrase will yield a different keypair.
+{% endhint %}
+
+The `solana-keygen` tool assumes the use of the BIP39 standard English word
+list. If you chose to deviate from the word list or used a different language
+for your seed phrase, you can still derive a valid public key but will need to
+explicitly skip seed phrase validation.
+
+```bash
+solana-keygen pubkey ASK --skip-seed-phrase-validation
+```
+
+For full usage details run:
+
+```bash
+solana-keygen pubkey --help
+```

book/src/paper-wallet/usage.md

@@ -0,0 +1,73 @@
+# Paper Wallet Usage
+
+Solana commands can be run without ever saving a keypair to disk on a machine.
+If avoiding writing a private key to disk is a security concern of yours, you've
+come to the right place.
+
+{% hint style="warning" %}
+Even using this secure input method, it's still possible that a private key gets
+written to disk by unencrypted memory swaps. It is the user's responsibility to
+protect against this scenario.
+{% endhint %}
+
+## Running a Validator
+
+In order to run a validator, you will need to specify an "identity keypair"
+which will be used to fund all of the vote transactions signed by your validator.
+Rather than specifying a path with `--identity-keypair <PATH>` you can use the
+`--ask-seed-phrase` option.
+
+```bash
+solana-validator --ask-seed-phrase identity-keypair --ledger ...
+
+[identity-keypair] seed phrase: 🔒
+[identity-keypair] If this seed phrase has an associated passphrase, enter it now. Otherwise, press ENTER to continue:
+```
+
+The `--ask-seed-phrase` option accepts multiple keypairs. If you wish to use this
+input method for your voting keypair as well you can do the following:
+
+```bash
+solana-validator --ask-seed-phrase identity-keypair voting-keypair --ledger ...
+
+[identity-keypair] seed phrase: 🔒
+[identity-keypair] If this seed phrase has an associated passphrase, enter it now. Otherwise, press ENTER to continue:
+[voting-keypair] seed phrase: 🔒
+[voting-keypair] If this seed phrase has an associated passphrase, enter it now. Otherwise, press ENTER to continue:
+```
+
+Refer to the following page for a comprehensive guide on running a validator:
+{% page-ref page="../running-validator/README.md" %}
+
+## Delegating Stake
+
+Solana CLI tooling supports secure keypair input for stake delegation. To do so,
+first create a stake account with some SOL. Use the special `ASK` keyword to
+trigger a seed phrase input prompt for the stake account and use
+`--ask-seed-phrase keypair` to securely input the funding keypair.
+
+```bash
+solana create-stake-account ASK 1 SOL --ask-seed-phrase keypair
+
+[stake_account] seed phrase: 🔒
+[stake_account] If this seed phrase has an associated passphrase, enter it now. Otherwise, press ENTER to continue:
+[keypair] seed phrase: 🔒
+[keypair] If this seed phrase has an associated passphrase, enter it now. Otherwise, press ENTER to continue:
+```
+
+Then, to delegate that stake to a validator, use `--ask-seed-phrase keypair` to
+securely input the funding keypair.
+
+```bash
+solana delegate-stake --ask-seed-phrase keypair <STAKE_ACCOUNT_PUBKEY> <VOTE_ACCOUNT_PUBKEY>
+
+[keypair] seed phrase: 🔒
+[keypair] If this seed phrase has an associated passphrase, enter it now. Otherwise, press ENTER to continue:
+```
+
+Refer to the following page for a comprehensive guide on delegating stake:
+{% page-ref page="../running-validator/validator-stake.md" %}
+
+---
+
+{% page-ref page="../api-reference/cli.md" %}

chacha-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-chacha-sys"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana chacha-sys"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"

ci/localnet-sanity.sh

@@ -86,7 +86,8 @@ nodes=(
     --rpc-port 18899"
 )
 
-for i in $(seq 1 $extraNodes); do
+if [[ extraNodes -gt 0 ]]; then
+  for i in $(seq 1 $extraNodes); do
     portStart=$((8100 + i * 50))
     portEnd=$((portStart + 49))
     nodes+=(
@@ -96,7 +97,8 @@ for i in $(seq 1 $extraNodes); do
         --label dyn$i \
         --init-complete-file init-complete-node$((2 + i)).log"
     )
-done
+  done
+fi
 numNodes=$((2 + extraNodes))
 
 pids=()
@@ -313,7 +315,7 @@ flag_error() {
 
 if ! $skipSetup; then
   clear_config_dir "$SOLANA_CONFIG_DIR"
-  multinode-demo/setup.sh
+  multinode-demo/setup.sh --hashes-per-tick sleep
 else
   verifyLedger
 fi
@@ -365,7 +367,7 @@ while [[ $iteration -le $iterations ]]; do
   echo "--- Wallet sanity ($iteration)"
   (
     set -x
-    timeout 90s scripts/wallet-sanity.sh --url http://127.0.0.1"$walletRpcPort"
+    timeout 60s scripts/wallet-sanity.sh --url http://127.0.0.1"$walletRpcPort"
   ) || flag_error
 
   iteration=$((iteration + 1))

ci/testnet-manager.sh

@@ -246,7 +246,7 @@ sanity() {
     (
       set -x
       NO_INSTALL_CHECK=1 \
-        ci/testnet-sanity.sh beta-testnet-solana-com gce us-west1-b
+        ci/testnet-sanity.sh beta-testnet-solana-com gce -P us-west1-b
       maybe_deploy_software --deploy-if-newer
     )
     ;;
@@ -260,7 +260,7 @@ sanity() {
   testnet)
     (
       set -x
-      ci/testnet-sanity.sh testnet-solana-com gce us-west1-b
+      ci/testnet-sanity.sh testnet-solana-com gce -P us-west1-b
     )
     ;;
   testnet-perf)

clap-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-clap-utils"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana utilities for the clap"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,7 +12,7 @@ edition = "2018"
 clap = "2.33.0"
 rpassword = "4.0"
 semver = "0.9.0"
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 tiny-bip39 = "0.6.2"
 url = "2.1.0"
 

clap-utils/src/input_parsers.rs

@@ -3,8 +3,9 @@ use clap::ArgMatches;
 use solana_sdk::{
     native_token::sol_to_lamports,
     pubkey::Pubkey,
-    signature::{read_keypair_file, Keypair, KeypairUtil},
+    signature::{read_keypair_file, Keypair, KeypairUtil, Signature},
 };
+use std::str::FromStr;
 
 // Return parsed values from matches at `name`
 pub fn values_of<T>(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<T>>
@@ -35,7 +36,7 @@ pub fn keypair_of(matches: &ArgMatches<'_>, name: &str) -> Option<Keypair> {
     if let Some(value) = matches.value_of(name) {
         if value == ASK_KEYWORD {
             let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
-            keypair_from_seed_phrase(name, skip_validation).ok()
+            keypair_from_seed_phrase(name, skip_validation, true).ok()
         } else {
             read_keypair_file(value).ok()
         }
@@ -50,6 +51,20 @@ pub fn pubkey_of(matches: &ArgMatches<'_>, name: &str) -> Option<Pubkey> {
     value_of(matches, name).or_else(|| keypair_of(matches, name).map(|keypair| keypair.pubkey()))
 }
 
+// Return pubkey/signature pairs for a string of the form pubkey=signature
+pub fn pubkeys_sigs_of(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<(Pubkey, Signature)>> {
+    matches.values_of(name).map(|values| {
+        values
+            .map(|pubkey_signer_string| {
+                let mut signer = pubkey_signer_string.split('=');
+                let key = Pubkey::from_str(signer.next().unwrap()).unwrap();
+                let sig = Signature::from_str(signer.next().unwrap()).unwrap();
+                (key, sig)
+            })
+            .collect()
+    })
+}
+
 pub fn amount_of(matches: &ArgMatches<'_>, name: &str, unit: &str) -> Option<u64> {
     if matches.value_of(unit) == Some("lamports") {
         value_of(matches, name)
@@ -172,4 +187,25 @@ mod tests {
 
         fs::remove_file(&outfile).unwrap();
     }
+
+    #[test]
+    fn test_pubkeys_sigs_of() {
+        let key1 = Pubkey::new_rand();
+        let key2 = Pubkey::new_rand();
+        let sig1 = Keypair::new().sign_message(&[0u8]);
+        let sig2 = Keypair::new().sign_message(&[1u8]);
+        let signer1 = format!("{}={}", key1, sig1);
+        let signer2 = format!("{}={}", key2, sig2);
+        let matches = app().clone().get_matches_from(vec![
+            "test",
+            "--multiple",
+            &signer1,
+            "--multiple",
+            &signer2,
+        ]);
+        assert_eq!(
+            pubkeys_sigs_of(&matches, "multiple"),
+            Some(vec![(key1, sig1), (key2, sig2)])
+        );
+    }
 }

clap-utils/src/input_validators.rs

@@ -1,6 +1,8 @@
 use crate::keypair::ASK_KEYWORD;
+use solana_sdk::hash::Hash;
 use solana_sdk::pubkey::Pubkey;
-use solana_sdk::signature::read_keypair_file;
+use solana_sdk::signature::{read_keypair_file, Signature};
+use std::str::FromStr;
 
 // Return an error if a pubkey cannot be parsed.
 pub fn is_pubkey(string: String) -> Result<(), String> {
@@ -10,6 +12,14 @@ pub fn is_pubkey(string: String) -> Result<(), String> {
     }
 }
 
+// Return an error if a hash cannot be parsed.
+pub fn is_hash(string: String) -> Result<(), String> {
+    match string.parse::<Hash>() {
+        Ok(_) => Ok(()),
+        Err(err) => Err(format!("{:?}", err)),
+    }
+}
+
 // Return an error if a keypair file cannot be parsed.
 pub fn is_keypair(string: String) -> Result<(), String> {
     read_keypair_file(&string)
@@ -32,6 +42,28 @@ pub fn is_pubkey_or_keypair(string: String) -> Result<(), String> {
     is_pubkey(string.clone()).or_else(|_| is_keypair(string))
 }
 
+// Return an error if string cannot be parsed as pubkey=signature string
+pub fn is_pubkey_sig(string: String) -> Result<(), String> {
+    let mut signer = string.split('=');
+    match Pubkey::from_str(
+        signer
+            .next()
+            .ok_or_else(|| "Malformed signer string".to_string())?,
+    ) {
+        Ok(_) => {
+            match Signature::from_str(
+                signer
+                    .next()
+                    .ok_or_else(|| "Malformed signer string".to_string())?,
+            ) {
+                Ok(_) => Ok(()),
+                Err(err) => Err(format!("{:?}", err)),
+            }
+        }
+        Err(err) => Err(format!("{:?}", err)),
+    }
+}
+
 // Return an error if a url cannot be parsed.
 pub fn is_url(string: String) -> Result<(), String> {
     match url::Url::parse(&string) {
@@ -65,3 +97,24 @@ pub fn is_port(port: String) -> Result<(), String> {
         .map(|_| ())
         .map_err(|e| format!("{:?}", e))
 }
+
+pub fn is_valid_percentage(percentage: String) -> Result<(), String> {
+    percentage
+        .parse::<u8>()
+        .map_err(|e| {
+            format!(
+                "Unable to parse input percentage, provided: {}, err: {:?}",
+                percentage, e
+            )
+        })
+        .and_then(|v| {
+            if v > 100 {
+                Err(format!(
+                    "Percentage must be in range of 0 to 100, provided: {}",
+                    v
+                ))
+            } else {
+                Ok(())
+            }
+        })
+}

clap-utils/src/keypair.rs

@@ -2,11 +2,18 @@ use crate::ArgConstant;
 use bip39::{Language, Mnemonic, Seed};
 use clap::values_t;
 use rpassword::prompt_password_stderr;
-use solana_sdk::signature::{
+use solana_sdk::{
+    pubkey::Pubkey,
+    signature::{
         keypair_from_seed, keypair_from_seed_phrase_and_passphrase, read_keypair_file, Keypair,
         KeypairUtil,
+    },
+};
+use std::{
+    error,
+    io::{stdin, stdout, Write},
+    process::exit,
 };
-use std::error;
 
 // Keyword used to indicate that the user should be asked for a keypair seed phrase
 pub const ASK_KEYWORD: &str = "ASK";
@@ -41,10 +48,25 @@ impl KeypairWithSource {
     }
 }
 
+/// Prompts user for a passphrase and then asks for confirmirmation to check for mistakes
+pub fn prompt_passphrase(prompt: &str) -> Result<String, Box<dyn error::Error>> {
+    let passphrase = prompt_password_stderr(&prompt)?;
+    if !passphrase.is_empty() {
+        let confirmed = rpassword::prompt_password_stderr("Enter same passphrase again: ")?;
+        if confirmed != passphrase {
+            return Err("Passphrases did not match".into());
+        }
+    }
+    Ok(passphrase)
+}
+
 /// Reads user input from stdin to retrieve a seed phrase and passphrase for keypair derivation
+/// Optionally skips validation of seed phrase
+/// Optionally confirms recovered public key
 pub fn keypair_from_seed_phrase(
     keypair_name: &str,
     skip_validation: bool,
+    confirm_pubkey: bool,
 ) -> Result<Keypair, Box<dyn error::Error>> {
     let seed_phrase = prompt_password_stderr(&format!("[{}] seed phrase: ", keypair_name))?;
     let seed_phrase = seed_phrase.trim();
@@ -53,15 +75,30 @@ pub fn keypair_from_seed_phrase(
         keypair_name,
     );
 
-    if skip_validation {
+    let keypair = if skip_validation {
-        let passphrase = prompt_password_stderr(&passphrase_prompt)?;
+        let passphrase = prompt_passphrase(&passphrase_prompt)?;
-        keypair_from_seed_phrase_and_passphrase(&seed_phrase, &passphrase)
+        keypair_from_seed_phrase_and_passphrase(&seed_phrase, &passphrase)?
     } else {
-        let mnemonic = Mnemonic::from_phrase(seed_phrase, Language::English)?;
+        let sanitized = sanitize_seed_phrase(seed_phrase);
-        let passphrase = prompt_password_stderr(&passphrase_prompt)?;
+        let mnemonic = Mnemonic::from_phrase(sanitized, Language::English)?;
+        let passphrase = prompt_passphrase(&passphrase_prompt)?;
         let seed = Seed::new(&mnemonic, &passphrase);
-        keypair_from_seed(seed.as_bytes())
+        keypair_from_seed(seed.as_bytes())?
+    };
+
+    if confirm_pubkey {
+        let pubkey = Pubkey::new(keypair.public.as_ref());
+        print!("Recovered pubkey `{:?}`. Continue? (y/n): ", pubkey);
+        let _ignored = stdout().flush();
+        let mut input = String::new();
+        stdin().read_line(&mut input).expect("Unexpected input");
+        if input.to_lowercase().trim() != "y" {
+            println!("Exiting");
+            exit(1);
         }
+    }
+
+    Ok(keypair)
 }
 
 /// Checks CLI arguments to determine whether a keypair should be:
@@ -91,7 +128,7 @@ pub fn keypair_input(
         }
 
         let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
-        keypair_from_seed_phrase(keypair_name, skip_validation)
+        keypair_from_seed_phrase(keypair_name, skip_validation, true)
             .map(|keypair| KeypairWithSource::new(keypair, Source::SeedPhrase))
     } else if let Some(keypair_file) = matches.value_of(keypair_match_name) {
         read_keypair_file(keypair_file).map(|keypair| KeypairWithSource::new(keypair, Source::File))
@@ -100,6 +137,13 @@ pub fn keypair_input(
     }
 }
 
+fn sanitize_seed_phrase(seed_phrase: &str) -> String {
+    seed_phrase
+        .split_whitespace()
+        .collect::<Vec<&str>>()
+        .join(" ")
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -111,4 +155,13 @@ mod tests {
         let KeypairWithSource { source, .. } = keypair_input(&arg_matches, "").unwrap();
         assert_eq!(source, Source::Generated);
     }
+
+    #[test]
+    fn test_sanitize_seed_phrase() {
+        let seed_phrase = " Mary   had\ta\u{2009}little  \n\t lamb";
+        assert_eq!(
+            "Mary had a little lamb".to_owned(),
+            sanitize_seed_phrase(seed_phrase)
+        );
+    }
 }

cli/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-cli"
 description = "Blockchain, Rebuilt for Scale"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -27,24 +27,24 @@ serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
 serde_yaml = "0.8.11"
-solana-budget-program = { path = "../programs/budget", version = "0.21.0" }
+solana-budget-program = { path = "../programs/budget", version = "0.21.2" }
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-client = { path = "../client", version = "0.21.0" }
+solana-client = { path = "../client", version = "0.21.2" }
-solana-config-program = { path = "../programs/config", version = "0.21.0" }
+solana-config-program = { path = "../programs/config", version = "0.21.2" }
-solana-drone = { path = "../drone", version = "0.21.0" }
+solana-drone = { path = "../drone", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-net-utils = { path = "../net-utils", version = "0.21.0" }
+solana-net-utils = { path = "../net-utils", version = "0.21.2" }
-solana-runtime = { path = "../runtime", version = "0.21.0" }
+solana-runtime = { path = "../runtime", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
-solana-stake-program = { path = "../programs/stake", version = "0.21.0" }
+solana-stake-program = { path = "../programs/stake", version = "0.21.2" }
-solana-storage-program = { path = "../programs/storage", version = "0.21.0" }
+solana-storage-program = { path = "../programs/storage", version = "0.21.2" }
-solana-vote-program = { path = "../programs/vote", version = "0.21.0" }
+solana-vote-program = { path = "../programs/vote", version = "0.21.2" }
-solana-vote-signer = { path = "../vote-signer", version = "0.21.0" }
+solana-vote-signer = { path = "../vote-signer", version = "0.21.2" }
 url = "2.1.0"
 
 [dev-dependencies]
-solana-core = { path = "../core", version = "0.21.0" }
+solana-core = { path = "../core", version = "0.21.2" }
-solana-budget-program = { path = "../programs/budget", version = "0.21.0" }
+solana-budget-program = { path = "../programs/budget", version = "0.21.2" }
 tempfile = "3.1.0"
 
 [[bin]]

cli/src/cli.rs

@@ -1,5 +1,10 @@
 use crate::{
-    cluster_query::*, display::println_name_value, stake::*, storage::*, validator_info::*, vote::*,
+    cluster_query::*,
+    display::{println_name_value, println_signers},
+    stake::*,
+    storage::*,
+    validator_info::*,
+    vote::*,
 };
 use chrono::prelude::*;
 use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
@@ -15,6 +20,7 @@ use solana_drone::drone::request_airdrop_transaction;
 use solana_drone::drone_mock::request_airdrop_transaction;
 use solana_sdk::{
     bpf_loader,
+    clock::Slot,
     commitment_config::CommitmentConfig,
     fee_calculator::FeeCalculator,
     hash::Hash,
@@ -74,6 +80,9 @@ pub enum CliCommand {
     },
     ClusterVersion,
     Fees,
+    GetBlockTime {
+        slot: Slot,
+    },
     GetEpochInfo {
         commitment_config: CommitmentConfig,
     },
@@ -105,8 +114,20 @@ pub enum CliCommand {
         lockup: Lockup,
         lamports: u64,
     },
-    DeactivateStake(Pubkey),
+    DeactivateStake {
-    DelegateStake(Pubkey, Pubkey, bool),
+        stake_account_pubkey: Pubkey,
+        sign_only: bool,
+        signers: Option<Vec<(Pubkey, Signature)>>,
+        blockhash: Option<Hash>,
+    },
+    DelegateStake {
+        stake_account_pubkey: Pubkey,
+        vote_account_pubkey: Pubkey,
+        force: bool,
+        sign_only: bool,
+        signers: Option<Vec<(Pubkey, Signature)>>,
+        blockhash: Option<Hash>,
+    },
     RedeemVoteCredits(Pubkey, Pubkey),
     ShowStakeHistory {
         use_lamports_unit: bool,
@@ -174,6 +195,9 @@ pub enum CliCommand {
         timestamp_pubkey: Option<Pubkey>,
         witnesses: Option<Vec<Pubkey>>,
         cancelable: bool,
+        sign_only: bool,
+        signers: Option<Vec<(Pubkey, Signature)>>,
+        blockhash: Option<Hash>,
     },
     ShowAccount {
         pubkey: Pubkey,
@@ -266,6 +290,7 @@ pub fn parse_command(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, Box<dyn
             command: CliCommand::Fees,
             require_keypair: false,
         }),
+        ("get-block-time", Some(matches)) => parse_get_block_time(matches),
         ("get-epoch-info", Some(matches)) => parse_get_epoch_info(matches),
         ("get-genesis-hash", Some(_matches)) => Ok(CliCommandInfo {
             command: CliCommand::GetGenesisHash,
@@ -413,6 +438,9 @@ pub fn parse_command(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, Box<dyn
             let timestamp_pubkey = value_of(&matches, "timestamp_pubkey");
             let witnesses = values_of(&matches, "witness");
             let cancelable = matches.is_present("cancelable");
+            let sign_only = matches.is_present("sign_only");
+            let signers = pubkeys_sigs_of(&matches, "signer");
+            let blockhash = value_of(&matches, "blockhash");
 
             Ok(CliCommandInfo {
                 command: CliCommand::Pay {
@@ -422,8 +450,11 @@ pub fn parse_command(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, Box<dyn
                     timestamp_pubkey,
                     witnesses,
                     cancelable,
+                    sign_only,
+                    signers,
+                    blockhash,
                 },
-                require_keypair: true,
+                require_keypair: !sign_only,
             })
         }
         ("show-account", Some(matches)) => {
@@ -522,6 +553,48 @@ pub fn check_unique_pubkeys(
     }
 }
 
+pub fn get_blockhash_fee_calculator(
+    rpc_client: &RpcClient,
+    sign_only: bool,
+    blockhash: Option<Hash>,
+) -> Result<(Hash, FeeCalculator), Box<dyn std::error::Error>> {
+    Ok(if let Some(blockhash) = blockhash {
+        if sign_only {
+            (blockhash, FeeCalculator::default())
+        } else {
+            (blockhash, rpc_client.get_recent_blockhash()?.1)
+        }
+    } else {
+        rpc_client.get_recent_blockhash()?
+    })
+}
+
+pub fn return_signers(tx: &Transaction) -> ProcessResult {
+    println_signers(tx);
+    let signers: Vec<_> = tx
+        .signatures
+        .iter()
+        .zip(tx.message.account_keys.clone())
+        .map(|(signature, pubkey)| format!("{}={}", pubkey, signature))
+        .collect();
+
+    Ok(json!({
+        "blockhash": tx.message.recent_blockhash.to_string(),
+        "signers": &signers,
+    })
+    .to_string())
+}
+
+pub fn replace_signatures(tx: &mut Transaction, signers: &[(Pubkey, Signature)]) -> ProcessResult {
+    tx.replace_signatures(signers).map_err(|_| {
+        CliError::BadParameter(
+            "Transaction construction failed, incorrect signature or public key provided"
+                .to_string(),
+        )
+    })?;
+    Ok("".to_string())
+}
+
 fn process_airdrop(
     rpc_client: &RpcClient,
     config: &CliConfig,
@@ -694,6 +767,7 @@ fn process_deploy(
     .to_string())
 }
 
+#[allow(clippy::too_many_arguments)]
 fn process_pay(
     rpc_client: &RpcClient,
     config: &CliConfig,
@@ -703,12 +777,17 @@ fn process_pay(
     timestamp_pubkey: Option<Pubkey>,
     witnesses: &Option<Vec<Pubkey>>,
     cancelable: bool,
+    sign_only: bool,
+    signers: &Option<Vec<(Pubkey, Signature)>>,
+    blockhash: Option<Hash>,
 ) -> ProcessResult {
     check_unique_pubkeys(
         (&config.keypair.pubkey(), "cli keypair".to_string()),
         (to, "to".to_string()),
     )?;
-    let (blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+
+    let (blockhash, fee_calculator) =
+        get_blockhash_fee_calculator(rpc_client, sign_only, blockhash)?;
 
     let cancelable = if cancelable {
         Some(config.keypair.pubkey())
@@ -718,9 +797,17 @@ fn process_pay(
 
     if timestamp == None && *witnesses == None {
         let mut tx = system_transaction::transfer(&config.keypair, to, lamports, blockhash);
+        if let Some(signers) = signers {
+            replace_signatures(&mut tx, &signers)?;
+        }
+
+        if sign_only {
+            return_signers(&tx)
+        } else {
             check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
             let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair]);
             log_instruction_custom_error::<SystemError>(result)
+        }
     } else if *witnesses == None {
         let dt = timestamp.unwrap();
         let dt_pubkey = match timestamp_pubkey {
@@ -745,9 +832,15 @@ fn process_pay(
             ixs,
             blockhash,
         );
+        if let Some(signers) = signers {
+            replace_signatures(&mut tx, &signers)?;
+        }
+        if sign_only {
+            return_signers(&tx)
+        } else {
             check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
-        let result =
+            let result = rpc_client
-            rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair, &contract_state]);
+                .send_and_confirm_transaction(&mut tx, &[&config.keypair, &contract_state]);
             let signature_str = log_instruction_custom_error::<BudgetError>(result)?;
 
             Ok(json!({
@@ -755,9 +848,8 @@ fn process_pay(
                 "processId": format!("{}", contract_state.pubkey()),
             })
             .to_string())
+        }
     } else if timestamp == None {
-        let (blockhash, _fee_calculator) = rpc_client.get_recent_blockhash()?;
-
         let witness = if let Some(ref witness_vec) = *witnesses {
             witness_vec[0]
         } else {
@@ -783,8 +875,14 @@ fn process_pay(
             ixs,
             blockhash,
         );
-        let result =
+        if let Some(signers) = signers {
-            rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair, &contract_state]);
+            replace_signatures(&mut tx, &signers)?;
+        }
+        if sign_only {
+            return_signers(&tx)
+        } else {
+            let result = rpc_client
+                .send_and_confirm_transaction(&mut tx, &[&config.keypair, &contract_state]);
             check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
             let signature_str = log_instruction_custom_error::<BudgetError>(result)?;
 
@@ -793,6 +891,7 @@ fn process_pay(
                 "processId": format!("{}", contract_state.pubkey()),
             })
             .to_string())
+        }
     } else {
         Ok("Combo transactions not yet handled".to_string())
     }
@@ -870,6 +969,7 @@ pub fn process_command(config: &CliConfig) -> ProcessResult {
         CliCommand::Catchup { node_pubkey } => process_catchup(&rpc_client, node_pubkey),
         CliCommand::ClusterVersion => process_cluster_version(&rpc_client),
         CliCommand::Fees => process_fees(&rpc_client),
+        CliCommand::GetBlockTime { slot } => process_get_block_time(&rpc_client, *slot),
         CliCommand::GetGenesisHash => process_get_genesis_hash(&rpc_client),
         CliCommand::GetEpochInfo { commitment_config } => {
             process_get_epoch_info(&rpc_client, commitment_config)
@@ -926,18 +1026,36 @@ pub fn process_command(config: &CliConfig) -> ProcessResult {
             *lamports,
         ),
         // Deactivate stake account
-        CliCommand::DeactivateStake(stake_account_pubkey) => {
+        CliCommand::DeactivateStake {
-            process_deactivate_stake_account(&rpc_client, config, &stake_account_pubkey)
+            stake_account_pubkey,
-        }
+            sign_only,
-        CliCommand::DelegateStake(stake_account_pubkey, vote_account_pubkey, force) => {
+            ref signers,
-            process_delegate_stake(
+            blockhash,
+        } => process_deactivate_stake_account(
+            &rpc_client,
+            config,
+            &stake_account_pubkey,
+            *sign_only,
+            signers,
+            *blockhash,
+        ),
+        CliCommand::DelegateStake {
+            stake_account_pubkey,
+            vote_account_pubkey,
+            force,
+            sign_only,
+            ref signers,
+            blockhash,
+        } => process_delegate_stake(
             &rpc_client,
             config,
             &stake_account_pubkey,
             &vote_account_pubkey,
             *force,
-            )
+            *sign_only,
-        }
+            signers,
+            *blockhash,
+        ),
         CliCommand::RedeemVoteCredits(stake_account_pubkey, vote_account_pubkey) => {
             process_redeem_vote_credits(
                 &rpc_client,
@@ -1118,6 +1236,9 @@ pub fn process_command(config: &CliConfig) -> ProcessResult {
             timestamp_pubkey,
             ref witnesses,
             cancelable,
+            sign_only,
+            ref signers,
+            blockhash,
         } => process_pay(
             &rpc_client,
             config,
@@ -1127,6 +1248,9 @@ pub fn process_command(config: &CliConfig) -> ProcessResult {
             *timestamp_pubkey,
             witnesses,
             *cancelable,
+            *sign_only,
+            signers,
+            *blockhash,
         ),
         CliCommand::ShowAccount {
             pubkey,
@@ -1410,6 +1534,29 @@ pub fn app<'ab, 'v>(name: &str, about: &'ab str, version: &'v str) -> App<'ab, '
                     Arg::with_name("cancelable")
                         .long("cancelable")
                         .takes_value(false),
+                )
+                .arg(
+                    Arg::with_name("sign_only")
+                        .long("sign-only")
+                        .takes_value(false)
+                        .help("Sign the transaction offline"),
+                )
+                .arg(
+                    Arg::with_name("signer")
+                        .long("signer")
+                        .value_name("PUBKEY=BASE58_SIG")
+                        .takes_value(true)
+                        .validator(is_pubkey_sig)
+                        .multiple(true)
+                        .help("Provide a public-key/signature pair for the transaction"),
+                )
+                .arg(
+                    Arg::with_name("blockhash")
+                        .long("blockhash")
+                        .value_name("BLOCKHASH")
+                        .takes_value(true)
+                        .validator(is_hash)
+                        .help("Use the supplied blockhash"),
                 ),
         )
         .subcommand(
@@ -1667,6 +1814,9 @@ mod tests {
                     timestamp_pubkey: None,
                     witnesses: None,
                     cancelable: false,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: None,
                 },
                 require_keypair: true
             }
@@ -1694,6 +1844,9 @@ mod tests {
                     timestamp_pubkey: None,
                     witnesses: Some(vec![witness0, witness1]),
                     cancelable: false,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: None,
                 },
                 require_keypair: true
             }
@@ -1717,6 +1870,9 @@ mod tests {
                     timestamp_pubkey: None,
                     witnesses: Some(vec![witness0]),
                     cancelable: false,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: None,
                 },
                 require_keypair: true
             }
@@ -1744,6 +1900,130 @@ mod tests {
                     timestamp_pubkey: Some(witness0),
                     witnesses: None,
                     cancelable: false,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: None,
+                },
+                require_keypair: true
+            }
+        );
+
+        // Test Pay Subcommand w/ sign-only
+        let test_pay = test_commands.clone().get_matches_from(vec![
+            "test",
+            "pay",
+            &pubkey_string,
+            "50",
+            "lamports",
+            "--sign-only",
+        ]);
+        assert_eq!(
+            parse_command(&test_pay).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::Pay {
+                    lamports: 50,
+                    to: pubkey,
+                    timestamp: None,
+                    timestamp_pubkey: None,
+                    witnesses: None,
+                    cancelable: false,
+                    sign_only: true,
+                    signers: None,
+                    blockhash: None,
+                },
+                require_keypair: false
+            }
+        );
+
+        // Test Pay Subcommand w/ signer
+        let key1 = Pubkey::new_rand();
+        let sig1 = Keypair::new().sign_message(&[0u8]);
+        let signer1 = format!("{}={}", key1, sig1);
+        let test_pay = test_commands.clone().get_matches_from(vec![
+            "test",
+            "pay",
+            &pubkey_string,
+            "50",
+            "lamports",
+            "--signer",
+            &signer1,
+        ]);
+        assert_eq!(
+            parse_command(&test_pay).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::Pay {
+                    lamports: 50,
+                    to: pubkey,
+                    timestamp: None,
+                    timestamp_pubkey: None,
+                    witnesses: None,
+                    cancelable: false,
+                    sign_only: false,
+                    signers: Some(vec![(key1, sig1)]),
+                    blockhash: None,
+                },
+                require_keypair: true
+            }
+        );
+
+        // Test Pay Subcommand w/ signers
+        let key2 = Pubkey::new_rand();
+        let sig2 = Keypair::new().sign_message(&[1u8]);
+        let signer2 = format!("{}={}", key2, sig2);
+        let test_pay = test_commands.clone().get_matches_from(vec![
+            "test",
+            "pay",
+            &pubkey_string,
+            "50",
+            "lamports",
+            "--signer",
+            &signer1,
+            "--signer",
+            &signer2,
+        ]);
+        assert_eq!(
+            parse_command(&test_pay).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::Pay {
+                    lamports: 50,
+                    to: pubkey,
+                    timestamp: None,
+                    timestamp_pubkey: None,
+                    witnesses: None,
+                    cancelable: false,
+                    sign_only: false,
+                    signers: Some(vec![(key1, sig1), (key2, sig2)]),
+                    blockhash: None,
+                },
+                require_keypair: true
+            }
+        );
+
+        // Test Pay Subcommand w/ Blockhash
+        let blockhash = Hash::default();
+        let blockhash_string = format!("{}", blockhash);
+        let test_pay = test_commands.clone().get_matches_from(vec![
+            "test",
+            "pay",
+            &pubkey_string,
+            "50",
+            "lamports",
+            "--blockhash",
+            &blockhash_string,
+        ]);
+        assert_eq!(
+            parse_command(&test_pay).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::Pay {
+                    lamports: 50,
+                    to: pubkey,
+                    timestamp: None,
+                    timestamp_pubkey: None,
+                    witnesses: None,
+                    cancelable: false,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: Some(blockhash),
                 },
                 require_keypair: true
             }
@@ -1788,6 +2068,9 @@ mod tests {
                     timestamp_pubkey: Some(witness0),
                     witnesses: Some(vec![witness0, witness1]),
                     cancelable: false,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: None,
                 },
                 require_keypair: true
             }
@@ -1894,7 +2177,12 @@ mod tests {
         assert_eq!(signature.unwrap(), SIGNATURE.to_string());
 
         let stake_pubkey = Pubkey::new_rand();
-        config.command = CliCommand::DeactivateStake(stake_pubkey);
+        config.command = CliCommand::DeactivateStake {
+            stake_account_pubkey: stake_pubkey,
+            sign_only: false,
+            signers: None,
+            blockhash: None,
+        };
         let signature = process_command(&config);
         assert_eq!(signature.unwrap(), SIGNATURE.to_string());
 
@@ -1915,6 +2203,9 @@ mod tests {
             timestamp_pubkey: None,
             witnesses: None,
             cancelable: false,
+            sign_only: false,
+            signers: None,
+            blockhash: None,
         };
         let signature = process_command(&config);
         assert_eq!(signature.unwrap(), SIGNATURE.to_string());
@@ -1928,6 +2219,9 @@ mod tests {
             timestamp_pubkey: Some(config.keypair.pubkey()),
             witnesses: None,
             cancelable: false,
+            sign_only: false,
+            signers: None,
+            blockhash: None,
         };
         let result = process_command(&config);
         let json: Value = serde_json::from_str(&result.unwrap()).unwrap();
@@ -1949,6 +2243,9 @@ mod tests {
             timestamp_pubkey: None,
             witnesses: Some(vec![witness]),
             cancelable: true,
+            sign_only: false,
+            signers: None,
+            blockhash: None,
         };
         let result = process_command(&config);
         let json: Value = serde_json::from_str(&result.unwrap()).unwrap();
@@ -2056,6 +2353,9 @@ mod tests {
             timestamp_pubkey: None,
             witnesses: None,
             cancelable: false,
+            sign_only: false,
+            signers: None,
+            blockhash: None,
         };
         assert!(process_command(&config).is_err());
 
@@ -2066,6 +2366,9 @@ mod tests {
             timestamp_pubkey: Some(config.keypair.pubkey()),
             witnesses: None,
             cancelable: false,
+            sign_only: false,
+            signers: None,
+            blockhash: None,
         };
         assert!(process_command(&config).is_err());
 
@@ -2076,6 +2379,9 @@ mod tests {
             timestamp_pubkey: None,
             witnesses: Some(vec![witness]),
             cancelable: true,
+            sign_only: false,
+            signers: None,
+            blockhash: None,
         };
         assert!(process_command(&config).is_err());
 

cli/src/cluster_query.rs

@@ -11,7 +11,7 @@ use indicatif::{ProgressBar, ProgressStyle};
 use solana_clap_utils::{input_parsers::*, input_validators::*};
 use solana_client::{rpc_client::RpcClient, rpc_request::RpcVoteAccountInfo};
 use solana_sdk::{
-    clock,
+    clock::{self, Slot},
     commitment_config::CommitmentConfig,
     hash::Hash,
     pubkey::Pubkey,
@@ -53,6 +53,17 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                 .about("Get the version of the cluster entrypoint"),
         )
         .subcommand(SubCommand::with_name("fees").about("Display current cluster fees"))
+        .subcommand(SubCommand::with_name("get-block-time")
+            .about("Get estimated production time of a block")
+            .arg(
+                Arg::with_name("slot")
+                    .index(1)
+                    .takes_value(true)
+                    .value_name("SLOT")
+                    .required(true)
+                    .help("Slot number of the block to query")
+            )
+        )
         .subcommand(
             SubCommand::with_name("get-epoch-info")
             .about("Get information about the current epoch")
@@ -187,6 +198,14 @@ pub fn parse_cluster_ping(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, Cl
     })
 }
 
+pub fn parse_get_block_time(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
+    let slot = value_t_or_exit!(matches, "slot", u64);
+    Ok(CliCommandInfo {
+        command: CliCommand::GetBlockTime { slot },
+        require_keypair: false,
+    })
+}
+
 pub fn parse_get_epoch_info(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     let commitment_config = if matches.is_present("confirmed") {
         CommitmentConfig::default()
@@ -313,6 +332,11 @@ pub fn process_fees(rpc_client: &RpcClient) -> ProcessResult {
     ))
 }
 
+pub fn process_get_block_time(rpc_client: &RpcClient, slot: Slot) -> ProcessResult {
+    let timestamp = rpc_client.get_block_time(slot)?;
+    Ok(timestamp.to_string())
+}
+
 pub fn process_get_epoch_info(
     rpc_client: &RpcClient,
     commitment_config: &CommitmentConfig,
@@ -442,8 +466,7 @@ pub fn process_ping(
                     // Sleep for half a slot
                     if signal_receiver
                         .recv_timeout(Duration::from_millis(
-                            500 * solana_sdk::clock::DEFAULT_TICKS_PER_SLOT
+                            500 * clock::DEFAULT_TICKS_PER_SLOT / clock::DEFAULT_TICKS_PER_SECOND,
-                                / solana_sdk::clock::DEFAULT_TICKS_PER_SECOND,
                         ))
                         .is_ok()
                     {
@@ -568,7 +591,7 @@ pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool)
     println!(
         "{}",
         style(format!(
-            "  {:<44}  {:<44}  {:<11}  {:>10}  {:>11}  {}",
+            "  {:<44}  {:<44}  {}  {}  {}  {}",
             "Identity Pubkey",
             "Vote Account Pubkey",
             "Commission",
@@ -593,7 +616,7 @@ pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool)
             }
         }
         println!(
-            "{} {:<44}  {:<44}  {:>3} ({:>4.1}%)  {:>10}  {:>11}  {:>11}",
+            "{} {:<44}  {:<44}  {:>9}%   {:>8}  {:>10}  {:>12}",
             if delinquent {
                 WARNING.to_string()
             } else {
@@ -602,7 +625,6 @@ pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool)
             vote_account.node_pubkey,
             vote_account.vote_pubkey,
             vote_account.commission,
-            f64::from(vote_account.commission) * 100.0 / f64::from(std::u8::MAX),
             non_zero_or_dash(vote_account.last_vote),
             non_zero_or_dash(vote_account.root_slot),
             if vote_account.activated_stake > 0 {
@@ -656,6 +678,20 @@ mod tests {
             }
         );
 
+        let slot = 100;
+        let test_get_block_time = test_commands.clone().get_matches_from(vec![
+            "test",
+            "get-block-time",
+            &slot.to_string(),
+        ]);
+        assert_eq!(
+            parse_command(&test_get_block_time).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::GetBlockTime { slot },
+                require_keypair: false
+            }
+        );
+
         let test_get_epoch_info = test_commands
             .clone()
             .get_matches_from(vec!["test", "get-epoch-info"]);

cli/src/display.rs

@@ -1,4 +1,5 @@
 use console::style;
+use solana_sdk::transaction::Transaction;
 
 // Pretty print a "name value"
 pub fn println_name_value(name: &str, value: &str) {
@@ -22,3 +23,14 @@ pub fn println_name_value_or(name: &str, value: &str, default_value: &str) {
         println!("{} {}", style(name).bold(), style(value));
     };
 }
+
+pub fn println_signers(tx: &Transaction) {
+    println!();
+    println!("Blockhash: {}", tx.message.recent_blockhash);
+    println!("Signers (Pubkey=Signature):");
+    tx.signatures
+        .iter()
+        .zip(tx.message.account_keys.clone())
+        .for_each(|(signature, pubkey)| println!("  {:?}={:?}", pubkey, signature));
+    println!();
+}

cli/src/stake.rs

@@ -1,14 +1,16 @@
 use crate::cli::{
     build_balance_message, check_account_for_fee, check_unique_pubkeys,
-    log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult,
+    get_blockhash_fee_calculator, log_instruction_custom_error, replace_signatures, return_signers,
+    CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult,
 };
 use clap::{App, Arg, ArgMatches, SubCommand};
 use console::style;
 use solana_clap_utils::{input_parsers::*, input_validators::*};
 use solana_client::rpc_client::RpcClient;
-use solana_sdk::signature::Keypair;
+use solana_sdk::signature::{Keypair, Signature};
 use solana_sdk::{
     account_utils::State,
+    hash::Hash,
     pubkey::Pubkey,
     signature::KeypairUtil,
     system_instruction::SystemError,
@@ -120,6 +122,29 @@ impl StakeSubCommands for App<'_, '_> {
                         .validator(is_pubkey_or_keypair)
                         .help("The vote account to which the stake will be delegated")
                 )
+                .arg(
+                    Arg::with_name("sign_only")
+                        .long("sign-only")
+                        .takes_value(false)
+                        .help("Sign the transaction offline"),
+                )
+                .arg(
+                    Arg::with_name("signer")
+                        .long("signer")
+                        .value_name("PUBKEY=BASE58_SIG")
+                        .takes_value(true)
+                        .validator(is_pubkey_sig)
+                        .multiple(true)
+                        .help("Provide a public-key/signature pair for the transaction"),
+                )
+                .arg(
+                    Arg::with_name("blockhash")
+                        .long("blockhash")
+                        .value_name("BLOCKHASH")
+                        .takes_value(true)
+                        .validator(is_hash)
+                        .help("Use the supplied blockhash"),
+                ),
         )
         .subcommand(
             SubCommand::with_name("stake-authorize-staker")
@@ -176,6 +201,29 @@ impl StakeSubCommands for App<'_, '_> {
                         .required(true)
                         .help("Stake account to be deactivated.")
                 )
+                .arg(
+                    Arg::with_name("sign_only")
+                        .long("sign-only")
+                        .takes_value(false)
+                        .help("Sign the transaction offline"),
+                )
+                .arg(
+                    Arg::with_name("signer")
+                        .long("signer")
+                        .value_name("PUBKEY=BASE58_SIG")
+                        .takes_value(true)
+                        .validator(is_pubkey_sig)
+                        .multiple(true)
+                        .help("Provide a public-key/signature pair for the transaction"),
+                )
+                .arg(
+                    Arg::with_name("blockhash")
+                        .long("blockhash")
+                        .value_name("BLOCKHASH")
+                        .takes_value(true)
+                        .validator(is_hash)
+                        .help("Use the supplied blockhash"),
+                ),
         )
         .subcommand(
             SubCommand::with_name("withdraw-stake")
@@ -293,10 +341,20 @@ pub fn parse_stake_delegate_stake(matches: &ArgMatches<'_>) -> Result<CliCommand
     let stake_account_pubkey = pubkey_of(matches, "stake_account_pubkey").unwrap();
     let vote_account_pubkey = pubkey_of(matches, "vote_account_pubkey").unwrap();
     let force = matches.is_present("force");
+    let sign_only = matches.is_present("sign_only");
+    let signers = pubkeys_sigs_of(&matches, "signer");
+    let blockhash = value_of(matches, "blockhash");
 
     Ok(CliCommandInfo {
-        command: CliCommand::DelegateStake(stake_account_pubkey, vote_account_pubkey, force),
+        command: CliCommand::DelegateStake {
-        require_keypair: true,
+            stake_account_pubkey,
+            vote_account_pubkey,
+            force,
+            sign_only,
+            signers,
+            blockhash,
+        },
+        require_keypair: !sign_only,
     })
 }
 
@@ -328,9 +386,17 @@ pub fn parse_redeem_vote_credits(matches: &ArgMatches<'_>) -> Result<CliCommandI
 
 pub fn parse_stake_deactivate_stake(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     let stake_account_pubkey = pubkey_of(matches, "stake_account_pubkey").unwrap();
+    let sign_only = matches.is_present("sign_only");
+    let signers = pubkeys_sigs_of(&matches, "signer");
+    let blockhash = value_of(matches, "blockhash");
     Ok(CliCommandInfo {
-        command: CliCommand::DeactivateStake(stake_account_pubkey),
+        command: CliCommand::DeactivateStake {
-        require_keypair: true,
+            stake_account_pubkey,
+            sign_only,
+            signers,
+            blockhash,
+        },
+        require_keypair: !sign_only,
     })
 }
 
@@ -463,8 +529,12 @@ pub fn process_deactivate_stake_account(
     rpc_client: &RpcClient,
     config: &CliConfig,
     stake_account_pubkey: &Pubkey,
+    sign_only: bool,
+    signers: &Option<Vec<(Pubkey, Signature)>>,
+    blockhash: Option<Hash>,
 ) -> ProcessResult {
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator) =
+        get_blockhash_fee_calculator(rpc_client, sign_only, blockhash)?;
     let ixs = vec![stake_instruction::deactivate_stake(
         stake_account_pubkey,
         &config.keypair.pubkey(),
@@ -475,9 +545,16 @@ pub fn process_deactivate_stake_account(
         &[&config.keypair],
         recent_blockhash,
     );
+    if let Some(signers) = signers {
+        replace_signatures(&mut tx, &signers)?;
+    }
+    if sign_only {
+        return_signers(&tx)
+    } else {
         check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
         let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair]);
         log_instruction_custom_error::<StakeError>(result)
+    }
 }
 
 pub fn process_withdraw_stake(
@@ -644,6 +721,9 @@ pub fn process_delegate_stake(
     stake_account_pubkey: &Pubkey,
     vote_account_pubkey: &Pubkey,
     force: bool,
+    sign_only: bool,
+    signers: &Option<Vec<(Pubkey, Signature)>>,
+    blockhash: Option<Hash>,
 ) -> ProcessResult {
     check_unique_pubkeys(
         (&config.keypair.pubkey(), "cli keypair".to_string()),
@@ -690,7 +770,8 @@ pub fn process_delegate_stake(
         }
     }
 
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator) =
+        get_blockhash_fee_calculator(rpc_client, sign_only, blockhash)?;
 
     let ixs = vec![stake_instruction::delegate_stake(
         stake_account_pubkey,
@@ -704,9 +785,16 @@ pub fn process_delegate_stake(
         &[&config.keypair],
         recent_blockhash,
     );
+    if let Some(signers) = signers {
+        replace_signatures(&mut tx, &signers)?;
+    }
+    if sign_only {
+        return_signers(&tx)
+    } else {
         check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
         let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair]);
         log_instruction_custom_error::<StakeError>(result)
+    }
 }
 
 #[cfg(test)]
@@ -831,18 +919,25 @@ mod tests {
         );
 
         // Test DelegateStake Subcommand
-        let stake_pubkey = Pubkey::new_rand();
+        let vote_account_pubkey = Pubkey::new_rand();
-        let stake_pubkey_string = stake_pubkey.to_string();
+        let vote_account_string = vote_account_pubkey.to_string();
         let test_delegate_stake = test_commands.clone().get_matches_from(vec![
             "test",
             "delegate-stake",
-            &stake_pubkey_string,
             &stake_account_string,
+            &vote_account_string,
         ]);
         assert_eq!(
             parse_command(&test_delegate_stake).unwrap(),
             CliCommandInfo {
-                command: CliCommand::DelegateStake(stake_pubkey, stake_account_pubkey, false),
+                command: CliCommand::DelegateStake {
+                    stake_account_pubkey,
+                    vote_account_pubkey,
+                    force: false,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: None
+                },
                 require_keypair: true
             }
         );
@@ -851,13 +946,124 @@ mod tests {
             "test",
             "delegate-stake",
             "--force",
-            &stake_pubkey_string,
             &stake_account_string,
+            &vote_account_string,
         ]);
         assert_eq!(
             parse_command(&test_delegate_stake).unwrap(),
             CliCommandInfo {
-                command: CliCommand::DelegateStake(stake_pubkey, stake_account_pubkey, true),
+                command: CliCommand::DelegateStake {
+                    stake_account_pubkey,
+                    vote_account_pubkey,
+                    force: true,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: None
+                },
+                require_keypair: true
+            }
+        );
+
+        // Test Delegate Subcommand w/ Blockhash
+        let blockhash = Hash::default();
+        let blockhash_string = format!("{}", blockhash);
+        let test_delegate_stake = test_commands.clone().get_matches_from(vec![
+            "test",
+            "delegate-stake",
+            &stake_account_string,
+            &vote_account_string,
+            "--blockhash",
+            &blockhash_string,
+        ]);
+        assert_eq!(
+            parse_command(&test_delegate_stake).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::DelegateStake {
+                    stake_account_pubkey,
+                    vote_account_pubkey,
+                    force: false,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: Some(blockhash)
+                },
+                require_keypair: true
+            }
+        );
+
+        let test_delegate_stake = test_commands.clone().get_matches_from(vec![
+            "test",
+            "delegate-stake",
+            &stake_account_string,
+            &vote_account_string,
+            "--sign-only",
+        ]);
+        assert_eq!(
+            parse_command(&test_delegate_stake).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::DelegateStake {
+                    stake_account_pubkey,
+                    vote_account_pubkey,
+                    force: false,
+                    sign_only: true,
+                    signers: None,
+                    blockhash: None
+                },
+                require_keypair: false
+            }
+        );
+
+        // Test Delegate Subcommand w/ signer
+        let key1 = Pubkey::new_rand();
+        let sig1 = Keypair::new().sign_message(&[0u8]);
+        let signer1 = format!("{}={}", key1, sig1);
+        let test_delegate_stake = test_commands.clone().get_matches_from(vec![
+            "test",
+            "delegate-stake",
+            &stake_account_string,
+            &vote_account_string,
+            "--signer",
+            &signer1,
+        ]);
+        assert_eq!(
+            parse_command(&test_delegate_stake).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::DelegateStake {
+                    stake_account_pubkey,
+                    vote_account_pubkey,
+                    force: false,
+                    sign_only: false,
+                    signers: Some(vec![(key1, sig1)]),
+                    blockhash: None
+                },
+                require_keypair: true
+            }
+        );
+
+        // Test Delegate Subcommand w/ signers
+        let key2 = Pubkey::new_rand();
+        let sig2 = Keypair::new().sign_message(&[0u8]);
+        let signer2 = format!("{}={}", key2, sig2);
+        let test_delegate_stake = test_commands.clone().get_matches_from(vec![
+            "test",
+            "delegate-stake",
+            &stake_account_string,
+            &vote_account_string,
+            "--signer",
+            &signer1,
+            "--signer",
+            &signer2,
+        ]);
+        assert_eq!(
+            parse_command(&test_delegate_stake).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::DelegateStake {
+                    stake_account_pubkey,
+                    vote_account_pubkey,
+                    force: false,
+                    sign_only: false,
+                    signers: Some(vec![(key1, sig1), (key2, sig2)]),
+                    blockhash: None
+                },
                 require_keypair: true
             }
         );
@@ -866,7 +1072,7 @@ mod tests {
         let test_withdraw_stake = test_commands.clone().get_matches_from(vec![
             "test",
             "withdraw-stake",
-            &stake_pubkey_string,
+            &stake_account_string,
             &stake_account_string,
             "42",
             "lamports",
@@ -875,7 +1081,7 @@ mod tests {
         assert_eq!(
             parse_command(&test_withdraw_stake).unwrap(),
             CliCommandInfo {
-                command: CliCommand::WithdrawStake(stake_pubkey, stake_account_pubkey, 42),
+                command: CliCommand::WithdrawStake(stake_account_pubkey, stake_account_pubkey, 42),
                 require_keypair: true
             }
         );
@@ -884,12 +1090,109 @@ mod tests {
         let test_deactivate_stake = test_commands.clone().get_matches_from(vec![
             "test",
             "deactivate-stake",
-            &stake_pubkey_string,
+            &stake_account_string,
         ]);
         assert_eq!(
             parse_command(&test_deactivate_stake).unwrap(),
             CliCommandInfo {
-                command: CliCommand::DeactivateStake(stake_pubkey),
+                command: CliCommand::DeactivateStake {
+                    stake_account_pubkey,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: None
+                },
+                require_keypair: true
+            }
+        );
+
+        // Test Deactivate Subcommand w/ Blockhash
+        let blockhash = Hash::default();
+        let blockhash_string = format!("{}", blockhash);
+        let test_deactivate_stake = test_commands.clone().get_matches_from(vec![
+            "test",
+            "deactivate-stake",
+            &stake_account_string,
+            "--blockhash",
+            &blockhash_string,
+        ]);
+        assert_eq!(
+            parse_command(&test_deactivate_stake).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::DeactivateStake {
+                    stake_account_pubkey,
+                    sign_only: false,
+                    signers: None,
+                    blockhash: Some(blockhash)
+                },
+                require_keypair: true
+            }
+        );
+
+        let test_deactivate_stake = test_commands.clone().get_matches_from(vec![
+            "test",
+            "deactivate-stake",
+            &stake_account_string,
+            "--sign-only",
+        ]);
+        assert_eq!(
+            parse_command(&test_deactivate_stake).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::DeactivateStake {
+                    stake_account_pubkey,
+                    sign_only: true,
+                    signers: None,
+                    blockhash: None
+                },
+                require_keypair: false
+            }
+        );
+
+        // Test Deactivate Subcommand w/ signers
+        let key1 = Pubkey::new_rand();
+        let sig1 = Keypair::new().sign_message(&[0u8]);
+        let signer1 = format!("{}={}", key1, sig1);
+        let test_deactivate_stake = test_commands.clone().get_matches_from(vec![
+            "test",
+            "deactivate-stake",
+            &stake_account_string,
+            "--signer",
+            &signer1,
+        ]);
+        assert_eq!(
+            parse_command(&test_deactivate_stake).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::DeactivateStake {
+                    stake_account_pubkey,
+                    sign_only: false,
+                    signers: Some(vec![(key1, sig1)]),
+                    blockhash: None
+                },
+                require_keypair: true
+            }
+        );
+
+        // Test Deactivate Subcommand w/ signers
+        let key2 = Pubkey::new_rand();
+        let sig2 = Keypair::new().sign_message(&[0u8]);
+        let signer2 = format!("{}={}", key2, sig2);
+        let test_deactivate_stake = test_commands.clone().get_matches_from(vec![
+            "test",
+            "deactivate-stake",
+            &stake_account_string,
+            "--signer",
+            &signer1,
+            "--signer",
+            &signer2,
+        ]);
+        assert_eq!(
+            parse_command(&test_deactivate_stake).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::DeactivateStake {
+                    stake_account_pubkey,
+                    sign_only: false,
+                    signers: Some(vec![(key1, sig1), (key2, sig2)]),
+                    blockhash: None
+                },
                 require_keypair: true
             }
         );

cli/src/vote.rs

@@ -47,7 +47,7 @@ impl VoteSubCommands for App<'_, '_> {
                         .long("commission")
                         .value_name("NUM")
                         .takes_value(true)
-                        .help("The commission taken on reward redemption (0-255), default: 0"),
+                        .help("The commission taken on reward redemption (0-100), default: 0"),
                 )
                 .arg(
                     Arg::with_name("authorized_voter")
@@ -345,10 +345,7 @@ pub fn process_show_vote_account(
         vote_state.authorized_withdrawer
     );
     println!("credits: {}", vote_state.credits());
-    println!(
+    println!("commission: {}%", vote_state.commission);
-        "commission: {}%",
-        f64::from(vote_state.commission) / f64::from(std::u32::MAX)
-    );
     println!(
         "root slot: {}",
         match vote_state.root_slot {

cli/tests/pay.rs

@@ -3,9 +3,9 @@ use serde_json::Value;
 use solana_cli::cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig};
 use solana_client::rpc_client::RpcClient;
 use solana_drone::drone::run_local_drone;
-use solana_sdk::pubkey::Pubkey;
+use solana_sdk::{hash::Hash, pubkey::Pubkey, signature::KeypairUtil, signature::Signature};
-use solana_sdk::signature::KeypairUtil;
 use std::fs::remove_dir_all;
+use std::str::FromStr;
 use std::sync::mpsc::channel;
 
 #[cfg(test)]
@@ -71,6 +71,9 @@ fn test_cli_timestamp_tx() {
         timestamp_pubkey: Some(config_witness.keypair.pubkey()),
         witnesses: None,
         cancelable: false,
+        sign_only: false,
+        signers: None,
+        blockhash: None,
     };
     let sig_response = process_command(&config_payer);
 
@@ -138,6 +141,9 @@ fn test_cli_witness_tx() {
         timestamp_pubkey: None,
         witnesses: Some(vec![config_witness.keypair.pubkey()]),
         cancelable: false,
+        sign_only: false,
+        signers: None,
+        blockhash: None,
     };
     let sig_response = process_command(&config_payer);
 
@@ -198,6 +204,9 @@ fn test_cli_cancel_tx() {
         timestamp_pubkey: None,
         witnesses: Some(vec![config_witness.keypair.pubkey()]),
         cancelable: true,
+        sign_only: false,
+        signers: None,
+        blockhash: None,
     };
     let sig_response = process_command(&config_payer).unwrap();
 
@@ -223,3 +232,94 @@ fn test_cli_cancel_tx() {
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
 }
+
+#[test]
+fn test_offline_pay_tx() {
+    let (server, leader_data, alice, ledger_path) = new_validator_for_tests();
+    let bob_pubkey = Pubkey::new_rand();
+
+    let (sender, receiver) = channel();
+    run_local_drone(alice, sender, None);
+    let drone_addr = receiver.recv().unwrap();
+
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
+
+    let mut config_offline = CliConfig::default();
+    config_offline.json_rpc_url =
+        format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
+    let mut config_online = CliConfig::default();
+    config_online.json_rpc_url =
+        format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
+    assert_ne!(
+        config_offline.keypair.pubkey(),
+        config_online.keypair.pubkey()
+    );
+
+    request_and_confirm_airdrop(
+        &rpc_client,
+        &drone_addr,
+        &config_offline.keypair.pubkey(),
+        50,
+    )
+    .unwrap();
+
+    request_and_confirm_airdrop(
+        &rpc_client,
+        &drone_addr,
+        &config_online.keypair.pubkey(),
+        50,
+    )
+    .unwrap();
+    check_balance(50, &rpc_client, &config_offline.keypair.pubkey());
+    check_balance(50, &rpc_client, &config_online.keypair.pubkey());
+
+    config_offline.command = CliCommand::Pay {
+        lamports: 10,
+        to: bob_pubkey,
+        timestamp: None,
+        timestamp_pubkey: None,
+        witnesses: None,
+        cancelable: false,
+        sign_only: true,
+        signers: None,
+        blockhash: None,
+    };
+    let sig_response = process_command(&config_offline).unwrap();
+
+    check_balance(50, &rpc_client, &config_offline.keypair.pubkey());
+    check_balance(50, &rpc_client, &config_online.keypair.pubkey());
+    check_balance(0, &rpc_client, &bob_pubkey);
+
+    let object: Value = serde_json::from_str(&sig_response).unwrap();
+    let blockhash_str = object.get("blockhash").unwrap().as_str().unwrap();
+    let signer_strings = object.get("signers").unwrap().as_array().unwrap();
+    let signers: Vec<_> = signer_strings
+        .iter()
+        .map(|signer_string| {
+            let mut signer = signer_string.as_str().unwrap().split('=');
+            let key = Pubkey::from_str(signer.next().unwrap()).unwrap();
+            let sig = Signature::from_str(signer.next().unwrap()).unwrap();
+            (key, sig)
+        })
+        .collect();
+
+    config_online.command = CliCommand::Pay {
+        lamports: 10,
+        to: bob_pubkey,
+        timestamp: None,
+        timestamp_pubkey: None,
+        witnesses: None,
+        cancelable: false,
+        sign_only: false,
+        signers: Some(signers),
+        blockhash: Some(blockhash_str.parse::<Hash>().unwrap()),
+    };
+    process_command(&config_online).unwrap();
+
+    check_balance(40, &rpc_client, &config_offline.keypair.pubkey());
+    check_balance(50, &rpc_client, &config_online.keypair.pubkey());
+    check_balance(10, &rpc_client, &bob_pubkey);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
+}

client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-client"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Client"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -19,10 +19,10 @@ reqwest = { version = "0.9.22", default-features = false, features = ["rustls-tl
 serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
-solana-net-utils = { path = "../net-utils", version = "0.21.0" }
+solana-net-utils = { path = "../net-utils", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 
 [dev-dependencies]
 jsonrpc-core = "14.0.3"
 jsonrpc-http-server = "14.0.3"
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }

client/src/rpc_client.rs

@@ -11,7 +11,7 @@ use log::*;
 use serde_json::{json, Value};
 use solana_sdk::{
     account::Account,
-    clock::{Slot, DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT},
+    clock::{Slot, UnixTimestamp, DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT},
     commitment_config::CommitmentConfig,
     epoch_schedule::EpochSchedule,
     fee_calculator::FeeCalculator,
@@ -196,6 +196,32 @@ impl RpcClient {
         })
     }
 
+    pub fn get_block_time(&self, slot: Slot) -> io::Result<UnixTimestamp> {
+        let params = json!(slot);
+        let response = self
+            .client
+            .send(&RpcRequest::GetBlockTime, Some(params), 0, None);
+
+        response
+            .map(|result_json| {
+                if result_json.is_null() {
+                    return Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        format!("Block Not Found: slot={}", slot),
+                    ));
+                }
+                let result = serde_json::from_value(result_json)?;
+                trace!("Response block timestamp {:?} {:?}", slot, result);
+                Ok(result)
+            })
+            .map_err(|err| {
+                io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("GetBlockTime request failure: {:?}", err),
+                )
+            })?
+    }
+
     pub fn get_epoch_info(&self) -> io::Result<RpcEpochInfo> {
         self.get_epoch_info_with_commitment(CommitmentConfig::default())
     }

client/src/rpc_client_request.rs

@@ -56,6 +56,10 @@ impl GenericRpcClientRequest for RpcClientRequest {
                 .send()
             {
                 Ok(mut response) => {
+                    if !response.status().is_success() {
+                        return Err(response.error_for_status().unwrap_err().into());
+                    }
+
                     let json: serde_json::Value = serde_json::from_str(&response.text()?)?;
                     if json["error"].is_object() {
                         return Err(RpcError::RpcRequestError(format!(

client/src/rpc_request.rs

@@ -111,6 +111,7 @@ pub enum RpcRequest {
     ValidatorExit,
     GetAccountInfo,
     GetBalance,
+    GetBlockTime,
     GetClusterNodes,
     GetEpochInfo,
     GetEpochSchedule,
@@ -150,6 +151,7 @@ impl RpcRequest {
             RpcRequest::ValidatorExit => "validatorExit",
             RpcRequest::GetAccountInfo => "getAccountInfo",
             RpcRequest::GetBalance => "getBalance",
+            RpcRequest::GetBlockTime => "getBlockTime",
             RpcRequest::GetClusterNodes => "getClusterNodes",
             RpcRequest::GetEpochInfo => "getEpochInfo",
             RpcRequest::GetEpochSchedule => "getEpochSchedule",

core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "solana-core"
 description = "Blockchain, Rebuilt for Scale"
-version = "0.21.0"
+version = "0.21.2"
 documentation = "https://docs.rs/solana"
 homepage = "https://solana.com/"
 readme = "../README.md"
@@ -41,25 +41,25 @@ rayon = "1.2.0"
 serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
-solana-budget-program = { path = "../programs/budget", version = "0.21.0" }
+solana-budget-program = { path = "../programs/budget", version = "0.21.2" }
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-chacha-sys = { path = "../chacha-sys", version = "0.21.0" }
+solana-chacha-sys = { path = "../chacha-sys", version = "0.21.2" }
-solana-client = { path = "../client", version = "0.21.0" }
+solana-client = { path = "../client", version = "0.21.2" }
-solana-drone = { path = "../drone", version = "0.21.0" }
+solana-drone = { path = "../drone", version = "0.21.2" }
 ed25519-dalek = "1.0.0-pre.1"
-solana-ledger = { path = "../ledger", version = "0.21.0" }
+solana-ledger = { path = "../ledger", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-merkle-tree = { path = "../merkle-tree", version = "0.21.0" }
+solana-merkle-tree = { path = "../merkle-tree", version = "0.21.2" }
-solana-metrics = { path = "../metrics", version = "0.21.0" }
+solana-metrics = { path = "../metrics", version = "0.21.2" }
-solana-measure = { path = "../measure", version = "0.21.0" }
+solana-measure = { path = "../measure", version = "0.21.2" }
-solana-net-utils = { path = "../net-utils", version = "0.21.0" }
+solana-net-utils = { path = "../net-utils", version = "0.21.2" }
-solana-perf = { path = "../perf", version = "0.21.0" }
+solana-perf = { path = "../perf", version = "0.21.2" }
-solana-runtime = { path = "../runtime", version = "0.21.0" }
+solana-runtime = { path = "../runtime", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
-solana-stake-program = { path = "../programs/stake", version = "0.21.0" }
+solana-stake-program = { path = "../programs/stake", version = "0.21.2" }
-solana-storage-program = { path = "../programs/storage", version = "0.21.0" }
+solana-storage-program = { path = "../programs/storage", version = "0.21.2" }
-solana-vote-program = { path = "../programs/vote", version = "0.21.0" }
+solana-vote-program = { path = "../programs/vote", version = "0.21.2" }
-solana-vote-signer = { path = "../vote-signer", version = "0.21.0" }
+solana-vote-signer = { path = "../vote-signer", version = "0.21.2" }
 symlink = "0.1.0"
 sys-info = "0.5.8"
 tempfile = "3.1.0"
@@ -68,7 +68,7 @@ tokio-codec = "0.1"
 tokio-fs = "0.1"
 tokio-io = "0.1"
 untrusted = "0.7.0"
-solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "0.21.0" }
+solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "0.21.2" }
 reed-solomon-erasure = { package = "solana-reed-solomon-erasure", version = "4.0.1-3", features = ["simd-accel"] }
 
 [target."cfg(unix)".dependencies]

core/src/retransmit_stage.rs

@@ -295,7 +295,7 @@ mod tests {
             ..ProcessOptions::default()
         };
         let (bank_forks, _, cached_leader_schedule) =
-            process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
         let leader_schedule_cache = Arc::new(cached_leader_schedule);
         let bank_forks = Arc::new(RwLock::new(bank_forks));
 

core/src/rpc.rs

@@ -20,7 +20,7 @@ use solana_ledger::{bank_forks::BankForks, blocktree::Blocktree};
 use solana_runtime::bank::Bank;
 use solana_sdk::{
     account::Account,
-    clock::Slot,
+    clock::{Slot, UnixTimestamp},
     commitment_config::{CommitmentConfig, CommitmentLevel},
     epoch_schedule::EpochSchedule,
     fee_calculator::FeeCalculator,
@@ -28,6 +28,7 @@ use solana_sdk::{
     inflation::Inflation,
     pubkey::Pubkey,
     signature::Signature,
+    timing::slot_duration_from_slots_per_year,
     transaction::{self, Transaction},
 };
 use solana_vote_program::vote_state::{VoteState, MAX_LOCKOUT_HISTORY};
@@ -254,6 +255,10 @@ impl JsonRpcRequestProcessor {
                     last_vote,
                 }
             })
+            .filter(|vote_account_info| {
+                // Remove vote accounts with no delegated stake that have never voted
+                vote_account_info.last_vote != 0 || vote_account_info.activated_stake != 0
+            })
             .partition(|vote_account_info| {
                 if bank.slot() >= MAX_LOCKOUT_HISTORY as u64 {
                     vote_account_info.last_vote > bank.slot() - MAX_LOCKOUT_HISTORY as u64
@@ -304,6 +309,21 @@ impl JsonRpcRequestProcessor {
     pub fn get_confirmed_block(&self, slot: Slot) -> Result<Option<RpcConfirmedBlock>> {
         Ok(self.blocktree.get_confirmed_block(slot).ok())
     }
+
+    // The `get_block_time` method is not fully implemented. It currently returns `slot` *
+    // DEFAULT_MS_PER_SLOT offset from 0 for all requests, and null for any values that would
+    // overflow.
+    pub fn get_block_time(&self, slot: Slot) -> Result<Option<UnixTimestamp>> {
+        // This calculation currently assumes that bank.ticks_per_slot and bank.slots_per_year will
+        // remain unchanged after genesis. If these values will be variable in the future, those
+        // timing parameters will need to be stored persistently, and this calculation will likely
+        // need to be moved upstream into blocktree. Also, an explicit commitment level will need
+        // to be set.
+        let bank = self.bank(None);
+        let slot_duration = slot_duration_from_slots_per_year(bank.slots_per_year());
+
+        Ok(self.blocktree.get_block_time(slot, slot_duration))
+    }
 }
 
 fn get_tpu_addr(cluster_info: &Arc<RwLock<ClusterInfo>>) -> Result<SocketAddr> {
@@ -513,6 +533,9 @@ pub trait RpcSol {
         meta: Self::Metadata,
         slot: Slot,
     ) -> Result<Option<RpcConfirmedBlock>>;
+
+    #[rpc(meta, name = "getBlockTime")]
+    fn get_block_time(&self, meta: Self::Metadata, slot: Slot) -> Result<Option<UnixTimestamp>>;
 }
 
 pub struct RpcSolImpl;
@@ -967,6 +990,10 @@ impl RpcSol for RpcSolImpl {
             .unwrap()
             .get_confirmed_block(slot)
     }
+
+    fn get_block_time(&self, meta: Self::Metadata, slot: Slot) -> Result<Option<UnixTimestamp>> {
+        meta.request_processor.read().unwrap().get_block_time(slot)
+    }
 }
 
 #[cfg(test)]
@@ -987,13 +1014,14 @@ pub mod tests {
         system_transaction,
         transaction::TransactionError,
     };
+    use solana_vote_program::{vote_instruction, vote_state::VoteInit};
     use std::{
         collections::HashMap,
         sync::atomic::{AtomicBool, Ordering},
         thread,
     };
 
-    const TEST_MINT_LAMPORTS: u64 = 10_000;
+    const TEST_MINT_LAMPORTS: u64 = 1_000_000;
 
     struct RpcHandler {
         io: MetaIoHandler<Meta>,
@@ -1818,4 +1846,110 @@ pub mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_get_block_time() {
+        let bob_pubkey = Pubkey::new_rand();
+        let RpcHandler { io, meta, bank, .. } = start_rpc_handler_with_tx(&bob_pubkey);
+
+        let slot_duration = slot_duration_from_slots_per_year(bank.slots_per_year());
+
+        let slot = 100;
+        let req = format!(
+            r#"{{"jsonrpc":"2.0","id":1,"method":"getBlockTime","params":[{}]}}"#,
+            slot
+        );
+        let res = io.handle_request_sync(&req, meta.clone());
+        let expected = format!(
+            r#"{{"jsonrpc":"2.0","result":{},"id":1}}"#,
+            (slot * slot_duration).as_secs()
+        );
+        let expected: Response =
+            serde_json::from_str(&expected).expect("expected response deserialization");
+        let result: Response = serde_json::from_str(&res.expect("actual response"))
+            .expect("actual response deserialization");
+        assert_eq!(expected, result);
+
+        let slot = 12345;
+        let req = format!(
+            r#"{{"jsonrpc":"2.0","id":1,"method":"getBlockTime","params":[{}]}}"#,
+            slot
+        );
+        let res = io.handle_request_sync(&req, meta.clone());
+        let expected = format!(
+            r#"{{"jsonrpc":"2.0","result":{},"id":1}}"#,
+            (slot * slot_duration).as_secs()
+        );
+        let expected: Response =
+            serde_json::from_str(&expected).expect("expected response deserialization");
+        let result: Response = serde_json::from_str(&res.expect("actual response"))
+            .expect("actual response deserialization");
+        assert_eq!(expected, result);
+
+        let slot = 123450000000000000u64;
+        let req = format!(
+            r#"{{"jsonrpc":"2.0","id":1,"method":"getBlockTime","params":[{}]}}"#,
+            slot
+        );
+        let res = io.handle_request_sync(&req, meta);
+        let expected = format!(r#"{{"jsonrpc":"2.0","result":null,"id":1}}"#);
+        let expected: Response =
+            serde_json::from_str(&expected).expect("expected response deserialization");
+        let result: Response = serde_json::from_str(&res.expect("actual response"))
+            .expect("actual response deserialization");
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_get_vote_accounts() {
+        let RpcHandler {
+            io,
+            meta,
+            bank,
+            alice,
+            ..
+        } = start_rpc_handler_with_tx(&Pubkey::new_rand());
+
+        assert_eq!(bank.vote_accounts().len(), 1);
+
+        // Create a second vote account that has no stake.  It should not be included in the
+        // getVoteAccounts response
+        let vote_keypair = Keypair::new();
+        let instructions = vote_instruction::create_account(
+            &alice.pubkey(),
+            &vote_keypair.pubkey(),
+            &VoteInit {
+                node_pubkey: alice.pubkey(),
+                authorized_voter: vote_keypair.pubkey(),
+                authorized_withdrawer: vote_keypair.pubkey(),
+                commission: 0,
+            },
+            bank.get_minimum_balance_for_rent_exemption(VoteState::size_of()),
+        );
+
+        let transaction = Transaction::new_signed_instructions(
+            &[&alice, &vote_keypair],
+            instructions,
+            bank.last_blockhash(),
+        );
+        bank.process_transaction(&transaction)
+            .expect("process transaction");
+        assert_eq!(bank.vote_accounts().len(), 2);
+
+        let req = format!(r#"{{"jsonrpc":"2.0","id":1,"method":"getVoteAccounts"}}"#);
+        let res = io.handle_request_sync(&req, meta.clone());
+        let result: Value = serde_json::from_str(&res.expect("actual response"))
+            .expect("actual response deserialization");
+
+        let vote_account_status: RpcVoteAccountStatus =
+            serde_json::from_value(result["result"].clone()).unwrap();
+
+        // The bootstrap leader vote account will be delinquent as it has stake but has never
+        // voted.  The vote account with no stake should not be present.
+        assert!(vote_account_status.current.is_empty());
+        assert_eq!(vote_account_status.delinquent.len(), 1);
+        for vote_account_info in vote_account_status.delinquent {
+            assert_ne!(vote_account_info.activated_stake, 0);
+        }
+    }
 }

core/src/snapshot_packager_service.rs

@@ -87,7 +87,14 @@ impl SnapshotPackagerService {
 
             // `storage_path` - The file path where the AppendVec itself is located
             // `output_path` - The directory where the AppendVec will be placed in the staging directory.
-            symlink::symlink_dir(storage_path, output_path)?;
+            let storage_path =
+                fs::canonicalize(storage_path).expect("Could not get absolute path for accounts");
+            symlink::symlink_dir(storage_path, &output_path)?;
+            if !output_path.is_file() {
+                return Err(Self::get_io_error(
+                    "Error trying to generate snapshot archive: storage path symlink is invalid",
+                ));
+            }
         }
 
         // Tar the staging directory into the archive at `archive_path`
@@ -185,17 +192,42 @@ mod tests {
     use super::*;
     use solana_ledger::snapshot_utils;
     use solana_runtime::accounts_db::AccountStorageEntry;
-    use std::fs::OpenOptions;
+    use std::{
-    use std::io::Write;
+        fs::{remove_dir_all, OpenOptions},
+        io::Write,
+        path::{Path, PathBuf},
+    };
     use tempfile::TempDir;
 
+    // Create temporary placeholder directory for all test files
+    fn make_tmp_dir_path() -> PathBuf {
+        let out_dir = std::env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
+        let path = PathBuf::from(format!("{}/tmp/test_package_snapshots", out_dir));
+
+        // whack any possible collision
+        let _ignored = std::fs::remove_dir_all(&path);
+        // whack any possible collision
+        let _ignored = std::fs::remove_file(&path);
+
+        path
+    }
+
+    #[test]
+    fn test_package_snapshots_relative_ledger_path() {
+        let temp_dir = make_tmp_dir_path();
+        create_and_verify_snapshot(&temp_dir);
+        remove_dir_all(temp_dir).expect("should remove tmp dir");
+    }
+
     #[test]
     fn test_package_snapshots() {
-        // Create temporary placeholder directory for all test files
+        create_and_verify_snapshot(TempDir::new().unwrap().path())
-        let temp_dir = TempDir::new().unwrap();
+    }
-        let accounts_dir = temp_dir.path().join("accounts");
+
-        let snapshots_dir = temp_dir.path().join("snapshots");
+    fn create_and_verify_snapshot(temp_dir: &Path) {
-        let snapshot_package_output_path = temp_dir.path().join("snapshots_output");
+        let accounts_dir = temp_dir.join("accounts");
+        let snapshots_dir = temp_dir.join("snapshots");
+        let snapshot_package_output_path = temp_dir.join("snapshots_output");
         fs::create_dir_all(&snapshot_package_output_path).unwrap();
 
         // Create some storage entries
@@ -221,7 +253,7 @@ mod tests {
             .collect();
 
         // Create directory of hard links for snapshots
-        let link_snapshots_dir = tempfile::tempdir_in(temp_dir.path()).unwrap();
+        let link_snapshots_dir = tempfile::tempdir_in(&temp_dir).unwrap();
         for snapshots_path in snapshots_paths {
             let snapshot_file_name = snapshots_path.file_name().unwrap();
             let link_path = link_snapshots_dir.path().join(snapshot_file_name);

core/src/validator.rs

@@ -59,7 +59,7 @@ pub struct ValidatorConfig {
     pub transaction_status_service_disabled: bool,
     pub blockstream_unix_socket: Option<PathBuf>,
     pub storage_slots_per_turn: u64,
-    pub account_paths: Option<String>,
+    pub account_paths: Vec<PathBuf>,
     pub rpc_config: JsonRpcConfig,
     pub snapshot_config: Option<SnapshotConfig>,
     pub max_ledger_slots: Option<u64>,
@@ -78,7 +78,7 @@ impl Default for ValidatorConfig {
             blockstream_unix_socket: None,
             storage_slots_per_turn: DEFAULT_SLOTS_PER_TURN,
             max_ledger_slots: None,
-            account_paths: None,
+            account_paths: Vec::new(),
             rpc_config: JsonRpcConfig::default(),
             snapshot_config: None,
             broadcast_stage_type: BroadcastStageType::Standard,
@@ -465,7 +465,7 @@ impl Validator {
 pub fn new_banks_from_blocktree(
     expected_genesis_hash: Option<Hash>,
     blocktree_path: &Path,
-    account_paths: Option<String>,
+    account_paths: Vec<PathBuf>,
     snapshot_config: Option<SnapshotConfig>,
     poh_verify: bool,
     dev_halt_at_slot: Option<Slot>,

core/tests/bank_forks.rs

@@ -52,7 +52,7 @@ mod tests {
         let genesis_config_info = create_genesis_config(10_000);
         let bank0 = Bank::new_with_paths(
             &genesis_config_info.genesis_config,
-            Some(accounts_dir.path().to_str().unwrap().to_string()),
+            vec![accounts_dir.path().to_path_buf()],
         );
         bank0.freeze();
         let mut bank_forks = BankForks::new(0, bank0);
@@ -73,7 +73,7 @@ mod tests {
         }
     }
 
-    fn restore_from_snapshot(old_bank_forks: &BankForks, account_paths: String) {
+    fn restore_from_snapshot(old_bank_forks: &BankForks, account_paths: Vec<PathBuf>) {
         let (snapshot_path, snapshot_package_output_path) = old_bank_forks
             .snapshot_config
             .as_ref()
@@ -81,7 +81,7 @@ mod tests {
             .unwrap();
 
         let deserialized_bank = snapshot_utils::bank_from_archive(
-            account_paths,
+            &account_paths,
             &old_bank_forks
                 .snapshot_config
                 .as_ref()
@@ -151,10 +151,7 @@ mod tests {
         .unwrap();
         SnapshotPackagerService::package_snapshots(&snapshot_package).unwrap();
 
-        restore_from_snapshot(
+        restore_from_snapshot(bank_forks, vec![accounts_dir.path().to_path_buf()]);
-            bank_forks,
-            accounts_dir.path().to_str().unwrap().to_string(),
-        );
     }
 
     #[test]
@@ -237,7 +234,7 @@ mod tests {
             let key1 = Keypair::new().pubkey();
             let tx = system_transaction::transfer(&mint_keypair, &key1, 1, genesis_config.hash());
             assert_eq!(bank.process_transaction(&tx), Ok(()));
-            bank.freeze();
+            bank.squash();
             bank_forks.insert(bank);
 
             let package_sender = {

crate-features/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-crate-features"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Crate Features"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"

drone/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-drone"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Drone"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -19,10 +19,10 @@ clap = "2.33"
 log = "0.4.8"
 serde = "1.0.102"
 serde_derive = "1.0.102"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-metrics = { path = "../metrics", version = "0.21.0" }
+solana-metrics = { path = "../metrics", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 tokio = "0.1"
 tokio-codec = "0.1"
 

fixed-buf/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-fixed-buf"
-version = "0.21.0"
+version = "0.21.2"
 description = "A fixed-size byte array that supports bincode serde"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"

genesis-programs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-genesis-programs"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana genesis programs"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -10,16 +10,16 @@ edition = "2018"
 
 [dependencies]
 log = { version = "0.4.8" }
-solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "0.21.0" }
+solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "0.21.2" }
-solana-budget-program = { path = "../programs/budget", version = "0.21.0" }
+solana-budget-program = { path = "../programs/budget", version = "0.21.2" }
-solana-config-program = { path = "../programs/config", version = "0.21.0" }
+solana-config-program = { path = "../programs/config", version = "0.21.2" }
-solana-exchange-program = { path = "../programs/exchange", version = "0.21.0" }
+solana-exchange-program = { path = "../programs/exchange", version = "0.21.2" }
-solana-runtime = { path = "../runtime", version = "0.21.0" }
+solana-runtime = { path = "../runtime", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
-solana-stake-program = { path = "../programs/stake", version = "0.21.0" }
+solana-stake-program = { path = "../programs/stake", version = "0.21.2" }
-solana-storage-program = { path = "../programs/storage", version = "0.21.0" }
+solana-storage-program = { path = "../programs/storage", version = "0.21.2" }
-solana-vest-program = { path = "../programs/vest", version = "0.21.0" }
+solana-vest-program = { path = "../programs/vest", version = "0.21.2" }
-solana-vote-program = { path = "../programs/vote", version = "0.21.0" }
+solana-vote-program = { path = "../programs/vote", version = "0.21.2" }
 
 [lib]
 crate-type = ["lib"]

genesis/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-genesis"
 description = "Blockchain, Rebuilt for Scale"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -16,11 +16,11 @@ serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
 serde_yaml = "0.8.11"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-genesis-programs = { path = "../genesis-programs", version = "0.21.0" }
+solana-genesis-programs = { path = "../genesis-programs", version = "0.21.2" }
-solana-ledger = { path = "../ledger", version = "0.21.0" }
+solana-ledger = { path = "../ledger", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
-solana-stake-program = { path = "../programs/stake", version = "0.21.0" }
+solana-stake-program = { path = "../programs/stake", version = "0.21.2" }
-solana-storage-program = { path = "../programs/storage", version = "0.21.0" }
+solana-storage-program = { path = "../programs/storage", version = "0.21.2" }
-solana-vote-program = { path = "../programs/vote", version = "0.21.0" }
+solana-vote-program = { path = "../programs/vote", version = "0.21.2" }
 tempfile = "3.1.0"

genesis/src/address_generator.rs

@@ -24,6 +24,7 @@ impl AddressGenerator {
             .as_ref(),
         )
     }
+    #[allow(clippy::should_implement_trait)]
     pub fn next(&mut self) -> Pubkey {
         let nth = self.nth;
         self.nth += 1;

genesis/src/lib.rs

@@ -1,3 +1,9 @@
+pub mod address_generator;
+pub mod genesis_accounts;
+pub mod stakes;
+pub mod unlocks;
+pub mod validators;
+
 use serde::{Deserialize, Serialize};
 
 /// An account where the data is encoded as a Base64 string.

genesis/src/main.rs

@@ -1,14 +1,9 @@
 //! A command-line executable for generating the chain's genesis config.
 
-mod address_generator;
-mod genesis_accounts;
-mod stakes;
-mod unlocks;
-
-use crate::genesis_accounts::add_genesis_accounts;
 use clap::{crate_description, crate_name, value_t, value_t_or_exit, App, Arg, ArgMatches};
 use solana_clap_utils::input_parsers::pubkey_of;
-use solana_genesis::Base64Account;
+use solana_clap_utils::input_validators::is_valid_percentage;
+use solana_genesis::{genesis_accounts::add_genesis_accounts, Base64Account};
 use solana_ledger::{blocktree::create_new_ledger, poh::compute_hashes_per_tick};
 use solana_sdk::{
     account::Account,
@@ -27,7 +22,15 @@ use solana_sdk::{
 use solana_stake_program::stake_state;
 use solana_storage_program::storage_contract;
 use solana_vote_program::vote_state;
-use std::{collections::HashMap, error, fs::File, io, path::PathBuf, str::FromStr, time::Duration};
+use std::{
+    collections::{BTreeMap, HashMap},
+    error,
+    fs::File,
+    io,
+    path::PathBuf,
+    str::FromStr,
+    time::Duration,
+};
 
 pub enum AccountFileFormat {
     Pubkey,
@@ -116,7 +119,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         )
     };
     let default_target_tick_duration =
-        &timing::duration_as_ms(&PohConfig::default().target_tick_duration).to_string();
+        timing::duration_as_us(&PohConfig::default().target_tick_duration);
     let default_ticks_per_slot = &clock::DEFAULT_TICKS_PER_SLOT.to_string();
     let default_operating_mode = "softlaunch";
 
@@ -161,7 +164,6 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         )
         .arg(
             Arg::with_name("bootstrap_vote_pubkey_file")
-                .short("s")
                 .long("bootstrap-vote-pubkey")
                 .value_name("BOOTSTRAP VOTE PUBKEY")
                 .takes_value(true)
@@ -170,13 +172,19 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         )
         .arg(
             Arg::with_name("bootstrap_stake_pubkey_file")
-                .short("k")
                 .long("bootstrap-stake-pubkey")
                 .value_name("BOOTSTRAP STAKE PUBKEY")
                 .takes_value(true)
                 .required(true)
                 .help("Path to file containing the bootstrap leader's staking pubkey"),
         )
+        .arg(
+            Arg::with_name("bootstrap_stake_authorized_pubkey_file")
+                .long("bootstrap-stake-authorized-pubkey")
+                .value_name("BOOTSTRAP STAKE AUTHORIZED PUBKEY")
+                .takes_value(true)
+                .help("Path to file containing the pubkey authorized to manage the bootstrap leader's stake [default: --bootstrap-leader-pubkey]"),
+        )
         .arg(
             Arg::with_name("bootstrap_storage_pubkey_file")
                 .long("bootstrap-storage-pubkey")
@@ -241,7 +249,8 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                 .value_name("NUMBER")
                 .takes_value(true)
                 .default_value(default_rent_burn_percentage)
-                .help("amount of rent to burn, as a fraction of std::u8::MAX."),
+                .help("percentage of collected rent to burn")
+                .validator(is_valid_percentage),
         )
         .arg(
             Arg::with_name("target_signatures_per_slot")
@@ -261,7 +270,6 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                 .long("target-tick-duration")
                 .value_name("MILLIS")
                 .takes_value(true)
-                .default_value(default_target_tick_duration)
                 .help("The target tick rate of the cluster in milliseconds"),
         )
         .arg(
@@ -314,7 +322,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         )
         .get_matches();
 
-    let faucet_lamports = value_t!(matches, "faucet_lamports", u64);
+    let faucet_lamports = value_t!(matches, "faucet_lamports", u64).unwrap_or(0);
     let ledger_path = PathBuf::from(matches.value_of("ledger_path").unwrap());
     let bootstrap_leader_lamports = value_t_or_exit!(matches, "bootstrap_leader_lamports", u64);
     let bootstrap_leader_stake_lamports =
@@ -323,6 +331,8 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     let bootstrap_leader_pubkey = required_pubkey(&matches, "bootstrap_leader_pubkey_file")?;
     let bootstrap_vote_pubkey = required_pubkey(&matches, "bootstrap_vote_pubkey_file")?;
     let bootstrap_stake_pubkey = required_pubkey(&matches, "bootstrap_stake_pubkey_file")?;
+    let bootstrap_stake_authorized_pubkey =
+        pubkey_of(&matches, "bootstrap_stake_authorized_pubkey_file");
     let bootstrap_storage_pubkey = pubkey_of(&matches, "bootstrap_storage_pubkey_file");
     let faucet_pubkey = pubkey_of(&matches, "faucet_pubkey_file");
 
@@ -336,14 +346,16 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         vote_state::create_account(&bootstrap_vote_pubkey, &bootstrap_leader_pubkey, 0, 1);
 
     let bootstrap_leader_stake_account = stake_state::create_account(
-        &bootstrap_leader_pubkey,
+        bootstrap_stake_authorized_pubkey
+            .as_ref()
+            .unwrap_or(&bootstrap_leader_pubkey),
         &bootstrap_vote_pubkey,
         &bootstrap_leader_vote_account,
         &rent,
         bootstrap_leader_stake_lamports,
     );
 
-    let mut accounts = vec![
+    let mut accounts: BTreeMap<Pubkey, Account> = [
         // node needs an account to issue votes from
         (
             bootstrap_leader_pubkey,
@@ -353,13 +365,16 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         (bootstrap_vote_pubkey, bootstrap_leader_vote_account),
         // bootstrap leader stake
         (bootstrap_stake_pubkey, bootstrap_leader_stake_account),
-    ];
+    ]
+    .iter()
+    .cloned()
+    .collect();
 
     if let Some(bootstrap_storage_pubkey) = bootstrap_storage_pubkey {
-        accounts.push((
+        accounts.insert(
             bootstrap_storage_pubkey,
             storage_contract::create_validator_storage_account(bootstrap_leader_pubkey, 1),
-        ));
+        );
     }
 
     let ticks_per_slot = value_t_or_exit!(matches, "ticks_per_slot", u64);
@@ -370,8 +385,11 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     );
 
     let mut poh_config = PohConfig::default();
-    poh_config.target_tick_duration =
+    poh_config.target_tick_duration = if matches.is_present("target_tick_duration") {
-        Duration::from_millis(value_t_or_exit!(matches, "target_tick_duration", u64));
+        Duration::from_micros(value_t_or_exit!(matches, "target_tick_duration", u64))
+    } else {
+        Duration::from_micros(default_target_tick_duration)
+    };
 
     let operating_mode = if matches.value_of("operating_mode").unwrap() == "development" {
         OperatingMode::Development
@@ -429,7 +447,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     if let Some(faucet_pubkey) = faucet_pubkey {
         genesis_config.add_account(
             faucet_pubkey,
-            Account::new(faucet_lamports.unwrap(), 0, &system_program::id()),
+            Account::new(faucet_lamports, 0, &system_program::id()),
         );
     }
 
@@ -443,12 +461,19 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         }
     }
 
-    add_genesis_accounts(&mut genesis_config);
+    let issued_lamports = genesis_config
+        .accounts
+        .iter()
+        .map(|(_key, account)| account.lamports)
+        .sum::<u64>();
+
+    add_genesis_accounts(&mut genesis_config, issued_lamports - faucet_lamports);
 
     create_new_ledger(&ledger_path, &genesis_config)?;
 
     println!(
-        "Genesis mode: {:?} hashes per tick: {:?} slots_per_epoch: {} capitalization: {}SOL in {} accounts",
+        "Genesis hash: {}\nOperating mode: {:?}\nHashes per tick: {:?}\nSlots per epoch: {}\nCapitalization: {} SOL in {} accounts",
+        genesis_config.hash(),
         operating_mode,
         genesis_config.poh_config.hashes_per_tick,
         slots_per_epoch,
@@ -535,27 +560,28 @@ mod tests {
             assert_eq!(genesis_config.accounts.len(), genesis_accounts.len());
 
             // Test account data matches
-            (0..genesis_accounts.len()).for_each(|i| {
+            for (pubkey_str, b64_account) in genesis_accounts.iter() {
+                let pubkey = pubkey_str.parse().unwrap();
                 assert_eq!(
-                    genesis_accounts[&genesis_config.accounts[i].0.to_string()].owner,
+                    b64_account.owner,
-                    genesis_config.accounts[i].1.owner.to_string()
+                    genesis_config.accounts[&pubkey].owner.to_string()
                 );
 
                 assert_eq!(
-                    genesis_accounts[&genesis_config.accounts[i].0.to_string()].balance,
+                    b64_account.balance,
-                    genesis_config.accounts[i].1.lamports
+                    genesis_config.accounts[&pubkey].lamports
                 );
 
                 assert_eq!(
-                    genesis_accounts[&genesis_config.accounts[i].0.to_string()].executable,
+                    b64_account.executable,
-                    genesis_config.accounts[i].1.executable
+                    genesis_config.accounts[&pubkey].executable
                 );
 
                 assert_eq!(
-                    genesis_accounts[&genesis_config.accounts[i].0.to_string()].data,
+                    b64_account.data,
-                    base64::encode(&genesis_config.accounts[i].1.data)
+                    base64::encode(&genesis_config.accounts[&pubkey].data)
                 );
-            });
+            }
         }
 
         // Test more accounts can be appended
@@ -608,54 +634,37 @@ mod tests {
         );
 
         // Test old accounts are still there
-        (0..genesis_accounts.len()).for_each(|i| {
+        for (pubkey_str, b64_account) in genesis_accounts.iter() {
+            let pubkey = &pubkey_str.parse().unwrap();
             assert_eq!(
-                genesis_accounts[&genesis_config.accounts[i].0.to_string()].balance,
+                b64_account.balance,
-                genesis_config.accounts[i].1.lamports,
+                genesis_config.accounts[&pubkey].lamports,
             );
-        });
+        }
 
         // Test new account data matches
-        (0..genesis_accounts1.len()).for_each(|i| {
+        for (pubkey_str, b64_account) in genesis_accounts1.iter() {
+            let pubkey = pubkey_str.parse().unwrap();
             assert_eq!(
-                genesis_accounts1[&genesis_config.accounts[genesis_accounts.len() + i]
+                b64_account.owner,
-                    .0
+                genesis_config.accounts[&pubkey].owner.to_string()
-                    .to_string()]
-                    .owner,
-                genesis_config.accounts[genesis_accounts.len() + i]
-                    .1
-                    .owner
-                    .to_string(),
             );
 
             assert_eq!(
-                genesis_accounts1[&genesis_config.accounts[genesis_accounts.len() + i]
+                b64_account.balance,
-                    .0
+                genesis_config.accounts[&pubkey].lamports,
-                    .to_string()]
-                    .balance,
-                genesis_config.accounts[genesis_accounts.len() + i]
-                    .1
-                    .lamports,
             );
 
             assert_eq!(
-                genesis_accounts1[&genesis_config.accounts[genesis_accounts.len() + i]
+                b64_account.executable,
-                    .0
+                genesis_config.accounts[&pubkey].executable,
-                    .to_string()]
-                    .executable,
-                genesis_config.accounts[genesis_accounts.len() + i]
-                    .1
-                    .executable,
             );
 
             assert_eq!(
-                genesis_accounts1[&genesis_config.accounts[genesis_accounts.len() + i]
+                b64_account.data,
-                    .0
+                base64::encode(&genesis_config.accounts[&pubkey].data),
-                    .to_string()]
-                    .data,
-                base64::encode(&genesis_config.accounts[genesis_accounts.len() + i].1.data),
             );
-        });
+        }
 
         // Test accounts from keypairs can be appended
         let account_keypairs: Vec<_> = (0..3).map(|_| Keypair::new()).collect();
@@ -710,89 +719,60 @@ mod tests {
         );
 
         // Test old accounts are still there
-        (0..genesis_accounts.len()).for_each(|i| {
+        for (pubkey_str, b64_account) in genesis_accounts {
+            let pubkey = pubkey_str.parse().unwrap();
             assert_eq!(
-                genesis_accounts[&genesis_config.accounts[i].0.to_string()].balance,
+                b64_account.balance,
-                genesis_config.accounts[i].1.lamports,
+                genesis_config.accounts[&pubkey].lamports,
             );
-        });
+        }
 
         // Test new account data matches
-        (0..genesis_accounts1.len()).for_each(|i| {
+        for (pubkey_str, b64_account) in genesis_accounts1 {
+            let pubkey = pubkey_str.parse().unwrap();
             assert_eq!(
-                genesis_accounts1[&genesis_config.accounts[genesis_accounts.len() + i]
+                b64_account.owner,
-                    .0
+                genesis_config.accounts[&pubkey].owner.to_string(),
-                    .to_string()]
-                    .owner,
-                genesis_config.accounts[genesis_accounts.len() + i]
-                    .1
-                    .owner
-                    .to_string(),
             );
 
             assert_eq!(
-                genesis_accounts1[&genesis_config.accounts[genesis_accounts.len() + i]
+                b64_account.balance,
-                    .0
+                genesis_config.accounts[&pubkey].lamports,
-                    .to_string()]
-                    .balance,
-                genesis_config.accounts[genesis_accounts.len() + i]
-                    .1
-                    .lamports,
             );
 
             assert_eq!(
-                genesis_accounts1[&genesis_config.accounts[genesis_accounts.len() + i]
+                b64_account.executable,
-                    .0
+                genesis_config.accounts[&pubkey].executable,
-                    .to_string()]
-                    .executable,
-                genesis_config.accounts[genesis_accounts.len() + i]
-                    .1
-                    .executable,
             );
 
             assert_eq!(
-                genesis_accounts1[&genesis_config.accounts[genesis_accounts.len() + i]
+                b64_account.data,
-                    .0
+                base64::encode(&genesis_config.accounts[&pubkey].data),
-                    .to_string()]
-                    .data,
-                base64::encode(&genesis_config.accounts[genesis_accounts.len() + i].1.data),
             );
-        });
+        }
 
-        let offset = genesis_accounts.len() + genesis_accounts1.len();
         // Test account data for keypairs matches
         account_keypairs.iter().for_each(|keypair| {
-            let mut i = 0;
+            let keypair_str = serde_json::to_string(&keypair.to_bytes().to_vec()).unwrap();
-            (offset..(offset + account_keypairs.len())).for_each(|n| {
+            let pubkey = keypair.pubkey();
-                if keypair.pubkey() == genesis_config.accounts[n].0 {
-                    i = n;
-                }
-            });
-
-            assert_ne!(i, 0);
-
             assert_eq!(
-                genesis_accounts2[&serde_json::to_string(&keypair.to_bytes().to_vec()).unwrap()]
+                genesis_accounts2[&keypair_str].owner,
-                    .owner,
+                genesis_config.accounts[&pubkey].owner.to_string(),
-                genesis_config.accounts[i].1.owner.to_string(),
             );
 
             assert_eq!(
-                genesis_accounts2[&serde_json::to_string(&keypair.to_bytes().to_vec()).unwrap()]
+                genesis_accounts2[&keypair_str].balance,
-                    .balance,
+                genesis_config.accounts[&pubkey].lamports,
-                genesis_config.accounts[i].1.lamports,
             );
 
             assert_eq!(
-                genesis_accounts2[&serde_json::to_string(&keypair.to_bytes().to_vec()).unwrap()]
+                genesis_accounts2[&keypair_str].executable,
-                    .executable,
+                genesis_config.accounts[&pubkey].executable,
-                genesis_config.accounts[i].1.executable,
             );
 
             assert_eq!(
-                genesis_accounts2[&serde_json::to_string(&keypair.to_bytes().to_vec()).unwrap()]
+                genesis_accounts2[&keypair_str].data,
-                    .data,
+                base64::encode(&genesis_config.accounts[&pubkey].data),
-                base64::encode(&genesis_config.accounts[i].1.data),
             );
         });
     }

genesis/src/stakes.rs

@@ -8,27 +8,24 @@ use solana_sdk::{
     pubkey::Pubkey, system_program, timing::years_as_slots,
 };
 use solana_stake_program::stake_state::{
-    create_lockup_stake_account, get_stake_rent_exempt_reserve, Authorized, Lockup,
+    create_lockup_stake_account, Authorized, Lockup, StakeState,
 };
 
 #[derive(Debug)]
 pub struct StakerInfo {
     pub name: &'static str,
     pub staker: &'static str,
-    pub withdrawer: &'static str,
     pub sol: f64,
-    pub custodian: &'static str,
 }
 
 // lamports required to run staking operations for one year
-//  the staker account needs to be rent exempt *and* carry enough
+//  the staker account needs carry enough
 //  lamports to cover TX fees (delegation) for one year,
 //  and we support one delegation per epoch
-fn calculate_staker_lamports(genesis_config: &GenesisConfig) -> u64 {
+fn calculate_staker_fees(genesis_config: &GenesisConfig, years: f64) -> u64 {
-    genesis_config.rent.minimum_balance(0).max(1)
+    genesis_config.fee_calculator.max_lamports_per_signature
-        + genesis_config.fee_calculator.max_lamports_per_signature
         * genesis_config.epoch_schedule.get_epoch(years_as_slots(
-                1.0,
+            years,
             &genesis_config.poh_config.target_tick_duration,
             genesis_config.ticks_per_slot,
         ) as Slot)
@@ -45,27 +42,38 @@ pub fn create_and_add_stakes(
     // the largest each stake account should be, in lamports
     granularity: u64,
 ) -> u64 {
-    let authorized = Authorized {
+    let authorized = Authorized::auto(
-        staker: Pubkey::new(&hex::decode(staker_info.staker).expect("hex")),
+        &staker_info
-        withdrawer: Pubkey::new(&hex::decode(staker_info.withdrawer).expect("hex")),
+            .staker
-    };
+            .parse::<Pubkey>()
-    let custodian = Pubkey::new(&hex::decode(staker_info.custodian).expect("hex"));
+            .expect("invalid staker"),
+    );
+    let custodian = unlock_info
+        .custodian
+        .parse::<Pubkey>()
+        .expect("invalid custodian");
 
     let total_lamports = sol_to_lamports(staker_info.sol);
 
-    let staker_lamports = calculate_staker_lamports(genesis_config);
+    // staker is a system account
-    let staker_account = (
+    let staker_rent_reserve = genesis_config.rent.minimum_balance(0).max(1);
-        authorized.staker,
+    let staker_fees = calculate_staker_fees(genesis_config, 1.0);
-        Account::new(staker_lamports, 0, &system_program::id()),
-    );
 
-    let stakes_lamports = if !genesis_config.accounts.contains(&staker_account) {
+    let mut stakes_lamports = total_lamports - staker_fees;
-        genesis_config.accounts.push(staker_account);
 
-        total_lamports - staker_lamports
+    // lamports required to run staking operations for one year
-    } else {
+    //  the staker account needs to be rent exempt *and* carry enough
-        total_lamports
+    //  lamports to cover TX fees (delegation) for one year,
-    };
+    //  and we support one delegation per epoch
+    // a single staker may administer any number of accounts
+    genesis_config
+        .accounts
+        .entry(authorized.staker)
+        .or_insert_with(|| {
+            stakes_lamports -= staker_rent_reserve;
+            Account::new(staker_rent_reserve, 0, &system_program::id())
+        })
+        .lamports += staker_fees;
 
     // the staker account needs to be rent exempt *and* carry enough
     //  lamports to cover TX fees (delegation) for one year
@@ -82,7 +90,7 @@ pub fn create_and_add_stakes(
 
     let mut address_generator = AddressGenerator::new(&authorized.staker, staker_info.name);
 
-    let stake_rent_exempt_reserve = get_stake_rent_exempt_reserve(&genesis_config.rent);
+    let stake_rent_reserve = StakeState::get_rent_exempt_reserve(&genesis_config.rent);
 
     for unlock in unlocks {
         let lamports = unlock.amount(stakes_lamports);
@@ -108,7 +116,7 @@ pub fn create_and_add_stakes(
                 ),
             );
         }
-        if remainder <= stake_rent_exempt_reserve {
+        if remainder <= stake_rent_reserve {
             genesis_config.add_account(
                 address_generator.next(),
                 create_lockup_stake_account(
@@ -150,11 +158,10 @@ mod tests {
         granularity: u64,
         len: usize,
     ) {
-        assert!(
+        assert_eq!(
-            total_lamports
+            total_lamports,
-                == create_and_add_stakes(genesis_config, staker_info, unlock_info, granularity)
+            create_and_add_stakes(genesis_config, staker_info, unlock_info, granularity)
         );
-
         assert_eq!(genesis_config.accounts.len(), len);
         assert_eq!(
             genesis_config
@@ -169,9 +176,41 @@ mod tests {
             .iter()
             .all(|(_pubkey, account)| account.lamports <= granularity
                 || account.lamports - granularity
-                    < get_stake_rent_exempt_reserve(&genesis_config.rent)));
+                    <= StakeState::get_rent_exempt_reserve(&genesis_config.rent)));
     }
 
+    //    #[ignore]
+    //    #[test]
+    //    fn hex_test_keys_to_bs58() {
+    //    vec![
+    //        "ab22196afde08a090a3721eb20e3e1ea84d36e14d1a3f0815b236b300d9d33ef", // CX2sgoat51bnDgCN2YeesrTcscgVhnhWnwxtWEEEqBs4
+    //        "a2a7ae9098f862f4b3ba7d102d174de5e84a560444c39c035f3eeecce442eadc", // BwwM47pLHwUgjJXKQKVNiRfGhtPNWfNLH27na2HJQHhd
+    //        "6a56514c29f6b1de4d46164621d6bd25b337a711f569f9283c1143c7e8fb546e", // 8A6ZEEW2odkqXNjTWHNG6tUk7uj6zCzHueTyEr9pM1tH
+    //        "b420af728f58d9f269d6e07fbbaecf6ed6535e5348538e3f39f2710351f2b940", // D89HyaBmr2WmrTehsfkQrY23wCXcDfsFnN9gMfUXHaDd
+    //        "ddf2e4c81eafae2d68ac99171b066c87bddb168d6b7c07333cd951f36640163d", // FwPvDpvUmnco1CSfwXQDTbUbuhG5eP7h2vgCKYKVL7at
+    //        "312fa06ccf1b671b26404a34136161ed2aba9e66f248441b4fddb5c592fde560", // 4K16iBoC9kAQRT8pUEKeD2h9WEx1zsRgEmJFssXcXmqq
+    //        "0cbf98cd35ceff84ca72b752c32cc3eeee4f765ca1bef1140927ebf5c6e74339", // rmLpENW4V6QNeEhdJJVxo9Xt99oKgNUFZS4Y4375amW
+    //        "467e06fa25a9e06824eedc926ce431947ed99c728bed36be54561354c1330959", // 5kAztE3XtrpeyGZZxckSUt3ZWojNTmph1QSC9S2682z4
+    //        "ef1562bf9edfd0f5e62530cce4244e8de544a3a30075a2cd5c9074edfbcbe78a", // H6HMVuDR8XCw3EuhLvFG4EciVvGo76Agq1kSBL2ozoDs
+    //        "2ab26abb9d8131a30a4a63446125cf961ece4b926c31cce0eb84da4eac3f836e", // 3sfv8tk5ZSDBWbTkFkvFxCvJUyW5yDJUu6VMJcUARQWq
+    //    ]
+    //    .iter()
+    //    .for_each(|_hex| {
+    //        print(
+    //            "\n\"{}\", // {:?}",
+    //            hex,
+    //            Pubkey::new(&hex::decode(hex).unwrap())
+    //        );
+    //    });
+    //    println();
+    // println(
+    //     "{:?}",
+    //     "P1aceHo1derPubkey11111111111111111111111111"
+    //         .parse::<Pubkey>()
+    //         .unwrap()
+    // );
+    //}
+
     #[test]
     fn test_create_stakes() {
         // 2 unlocks
@@ -182,11 +221,12 @@ mod tests {
             ..Rent::default()
         };
 
-        let reserve = get_stake_rent_exempt_reserve(&rent);
+        let reserve = StakeState::get_rent_exempt_reserve(&rent);
+        let staker_reserve = rent.minimum_balance(0);
 
         // verify that a small remainder ends up in the last stake
         let granularity = reserve;
-        let total_lamports = reserve + reserve * 2 + 1;
+        let total_lamports = staker_reserve + reserve * 2 + 1;
         create_and_check_stakes(
             &mut GenesisConfig {
                 rent,
@@ -194,16 +234,15 @@ mod tests {
             },
             &StakerInfo {
                 name: "fun",
-                staker: "cafebabedeadbeef000000000000000000000000000000000000000000000000",
+                staker: "P1aceHo1derPubkey11111111111111111111111111",
-                withdrawer: "cafebabedeadbeef000000000000000000000000000000000000000000000000",
                 sol: lamports_to_sol(total_lamports),
-                custodian: "0000000000000000000000000000000000000000000000000000000000000000",
             },
             &UnlockInfo {
                 cliff_fraction: 0.5,
                 cliff_years: 0.5,
                 unlocks: 1,
                 unlock_years: 0.5,
+                custodian: "11111111111111111111111111111111",
             },
             total_lamports,
             granularity,
@@ -212,7 +251,7 @@ mod tests {
 
         // huge granularity doesn't blow up
         let granularity = std::u64::MAX;
-        let total_lamports = reserve + reserve * 2 + 1;
+        let total_lamports = staker_reserve + reserve * 2 + 1;
         create_and_check_stakes(
             &mut GenesisConfig {
                 rent,
@@ -220,25 +259,24 @@ mod tests {
             },
             &StakerInfo {
                 name: "fun",
-                staker: "cafebabedeadbeef000000000000000000000000000000000000000000000000",
+                staker: "P1aceHo1derPubkey11111111111111111111111111",
-                withdrawer: "cafebabedeadbeef000000000000000000000000000000000000000000000000",
                 sol: lamports_to_sol(total_lamports),
-                custodian: "0000000000000000000000000000000000000000000000000000000000000000",
             },
             &UnlockInfo {
                 cliff_fraction: 0.5,
                 cliff_years: 0.5,
                 unlocks: 1,
                 unlock_years: 0.5,
+                custodian: "11111111111111111111111111111111",
             },
             total_lamports,
             granularity,
             2 + 1,
         );
 
-        // exactly reserve as a remainder
+        // exactly reserve as a remainder, reserve gets folded in
         let granularity = reserve * 3;
-        let total_lamports = reserve + (granularity + reserve) * 2;
+        let total_lamports = staker_reserve + (granularity + reserve) * 2;
         create_and_check_stakes(
             &mut GenesisConfig {
                 rent,
@@ -246,16 +284,39 @@ mod tests {
             },
             &StakerInfo {
                 name: "fun",
-                staker: "cafebabedeadbeef000000000000000000000000000000000000000000000000",
+                staker: "P1aceHo1derPubkey11111111111111111111111111",
-                withdrawer: "cafebabedeadbeef000000000000000000000000000000000000000000000000",
                 sol: lamports_to_sol(total_lamports),
-                custodian: "0000000000000000000000000000000000000000000000000000000000000000",
             },
             &UnlockInfo {
                 cliff_fraction: 0.5,
                 cliff_years: 0.5,
                 unlocks: 1,
                 unlock_years: 0.5,
+                custodian: "11111111111111111111111111111111",
+            },
+            total_lamports,
+            granularity,
+            2 + 1,
+        );
+        // exactly reserve + 1 as a remainder, reserve + 1 gets its own stake
+        let granularity = reserve * 3;
+        let total_lamports = staker_reserve + (granularity + reserve + 1) * 2;
+        create_and_check_stakes(
+            &mut GenesisConfig {
+                rent,
+                ..GenesisConfig::default()
+            },
+            &StakerInfo {
+                name: "fun",
+                staker: "P1aceHo1derPubkey11111111111111111111111111",
+                sol: lamports_to_sol(total_lamports),
+            },
+            &UnlockInfo {
+                cliff_fraction: 0.5,
+                cliff_years: 0.5,
+                unlocks: 1,
+                unlock_years: 0.5,
+                custodian: "11111111111111111111111111111111",
             },
             total_lamports,
             granularity,

genesis/src/unlocks.rs

@@ -8,6 +8,7 @@ pub struct UnlockInfo {
     pub cliff_years: f64,
     pub unlocks: usize,
     pub unlock_years: f64,
+    pub custodian: &'static str,
 }
 
 #[derive(Debug, Default, Clone)]

genesis/src/validators.rs

@@ -0,0 +1,209 @@
+//! validators generator
+use solana_sdk::{
+    account::Account, genesis_config::GenesisConfig, native_token::sol_to_lamports, pubkey::Pubkey,
+    system_program, timing::years_as_slots,
+};
+use solana_vote_program::vote_state::{self, VoteState};
+
+#[derive(Debug)]
+pub struct ValidatorInfo {
+    pub name: &'static str,
+    pub node: &'static str,
+    pub node_sol: f64,
+    pub vote: &'static str,
+    pub commission: u8,
+}
+
+// the node's account needs carry enough
+//  lamports to cover TX fees for voting for one year,
+//  validators can vote once per slot
+fn calculate_voting_fees(genesis_config: &GenesisConfig, years: f64) -> u64 {
+    genesis_config.fee_calculator.max_lamports_per_signature
+        * years_as_slots(
+            years,
+            &genesis_config.poh_config.target_tick_duration,
+            genesis_config.ticks_per_slot,
+        ) as u64
+}
+
+/// create and add vote and node id accounts for a validator
+pub fn create_and_add_validator(
+    genesis_config: &mut GenesisConfig,
+    // information about this validator
+    validator_info: &ValidatorInfo,
+) -> u64 {
+    let node: Pubkey = validator_info.node.parse().expect("invalid node");
+    let vote: Pubkey = validator_info.vote.parse().expect("invalid vote");
+    let node_lamports = sol_to_lamports(validator_info.node_sol);
+
+    // node is the system account from which votes will be issued
+    let node_rent_reserve = genesis_config.rent.minimum_balance(0).max(1);
+    let node_voting_fees = calculate_voting_fees(genesis_config, 1.0);
+
+    let vote_rent_reserve = VoteState::get_rent_exempt_reserve(&genesis_config.rent).max(1);
+
+    let mut total_lamports = node_voting_fees + vote_rent_reserve + node_lamports;
+
+    genesis_config
+        .accounts
+        .entry(node)
+        .or_insert_with(|| {
+            total_lamports += node_rent_reserve;
+            Account::new(node_rent_reserve, 0, &system_program::id())
+        })
+        .lamports += node_voting_fees + node_lamports;
+
+    assert!(
+        genesis_config.accounts.get(&vote).is_none(),
+        "{} is already in genesis",
+        vote
+    );
+
+    genesis_config.add_account(
+        vote,
+        vote_state::create_account(&vote, &node, validator_info.commission, vote_rent_reserve),
+    );
+
+    total_lamports
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use solana_sdk::rent::Rent;
+
+    fn create_and_check_validators(
+        genesis_config: &mut GenesisConfig,
+        validator_infos: &[ValidatorInfo],
+        total_lamports: u64,
+        len: usize,
+    ) {
+        assert_eq!(
+            validator_infos
+                .iter()
+                .map(|validator_info| create_and_add_validator(genesis_config, validator_info))
+                .sum::<u64>(),
+            total_lamports
+        );
+        assert_eq!(genesis_config.accounts.len(), len);
+        assert_eq!(
+            genesis_config
+                .accounts
+                .iter()
+                .map(|(_pubkey, account)| account.lamports)
+                .sum::<u64>(),
+            total_lamports,
+        );
+        assert!(genesis_config
+            .accounts
+            .iter()
+            .all(|(_pubkey, account)| account.lamports
+                >= genesis_config.rent.minimum_balance(0).max(1)));
+    }
+
+    #[test]
+    fn test_create_one_validator() {
+        let rent = Rent {
+            lamports_per_byte_year: 1,
+            exemption_threshold: 1.0,
+            ..Rent::default()
+        };
+        let mut genesis_config = GenesisConfig {
+            rent,
+            ..GenesisConfig::default()
+        };
+
+        let total_lamports = VoteState::get_rent_exempt_reserve(&rent)
+            + calculate_voting_fees(&genesis_config, 1.0)
+            + rent.minimum_balance(0);
+
+        create_and_check_validators(
+            &mut genesis_config,
+            &[ValidatorInfo {
+                name: "fun",
+                node: "AiTDdNHW2vNtHt7PqWMHx3B8cMPRDNgc7kMiLPJM25QC", // random pubkeys
+                node_sol: 0.0,
+                vote: "77TQYZTHodhnxJcSuVjUvx8GYRCkykPyHtmFTFLjj1Rc",
+                commission: 50,
+            }],
+            total_lamports,
+            2,
+        );
+    }
+
+    #[test]
+    fn test_create_one_validator_two_votes() {
+        let rent = Rent {
+            lamports_per_byte_year: 1,
+            exemption_threshold: 1.0,
+            ..Rent::default()
+        };
+        let mut genesis_config = GenesisConfig {
+            rent,
+            ..GenesisConfig::default()
+        };
+        let total_lamports = VoteState::get_rent_exempt_reserve(&rent) * 2
+            + calculate_voting_fees(&genesis_config, 1.0) * 2 // two vote accounts
+            + rent.minimum_balance(0) // one node account
+            + sol_to_lamports(1.0); // 2nd vote account ask has SOL
+
+        // weird case, just wanted to verify that the duplicated node account gets double fees
+        create_and_check_validators(
+            &mut genesis_config,
+            &[
+                ValidatorInfo {
+                    name: "fun",
+                    node: "3VTm54dw8w6jTTsPH4BfoV5vo6mF985JAMtNDRYcaGFc", // random pubkeys
+                    node_sol: 0.0,
+                    vote: "GTKWbUoLw3Bv7Ld92crhyXcEk9zUu3VEKfzeuWJZdnfW",
+                    commission: 50,
+                },
+                ValidatorInfo {
+                    name: "unfun",
+                    node: "3VTm54dw8w6jTTsPH4BfoV5vo6mF985JAMtNDRYcaGFc", // random pubkeys, same node
+                    node_sol: 1.0,
+                    vote: "8XrFPRULg98kSm535kFaLV4GMnK5JQSuAymyrCHXsUcy",
+                    commission: 50,
+                },
+            ],
+            total_lamports,
+            3,
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_vote_collision() {
+        let rent = Rent {
+            lamports_per_byte_year: 1,
+            exemption_threshold: 1.0,
+            ..Rent::default()
+        };
+        let mut genesis_config = GenesisConfig {
+            rent,
+            ..GenesisConfig::default()
+        };
+
+        create_and_check_validators(
+            &mut genesis_config,
+            &[
+                ValidatorInfo {
+                    name: "fun",
+                    node: "3VTm54dw8w6jTTsPH4BfoV5vo6mF985JAMtNDRYcaGFc", // random pubkeys
+                    node_sol: 0.0,
+                    vote: "GTKWbUoLw3Bv7Ld92crhyXcEk9zUu3VEKfzeuWJZdnfW",
+                    commission: 50,
+                },
+                ValidatorInfo {
+                    name: "unfun",
+                    node: "3VTm54dw8w6jTTsPH4BfoV5vo6mF985JAMtNDRYcaGFc", // random pubkeys, same node
+                    node_sol: 0.0,
+                    vote: "GTKWbUoLw3Bv7Ld92crhyXcEk9zUu3VEKfzeuWJZdnfW", // duplicate vote, bad juju
+                    commission: 50,
+                },
+            ],
+            0,
+            0,
+        );
+    }
+}

gossip/Cargo.toml

@@ -3,19 +3,19 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-gossip"
 description = "Blockchain, Rebuilt for Scale"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
 clap = "2.33.0"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-core = { path = "../core", version = "0.21.0" }
+solana-core = { path = "../core", version = "0.21.2" }
-solana-client = { path = "../client", version = "0.21.0" }
+solana-client = { path = "../client", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-net-utils = { path = "../net-utils", version = "0.21.0" }
+solana-net-utils = { path = "../net-utils", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 
 
 

install/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-install"
 description = "The solana cluster software installer"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -26,11 +26,11 @@ reqwest = { version = "0.9.22", default-features = false, features = ["rustls-tl
 serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_yaml = "0.8.11"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-client = { path = "../client", version = "0.21.0" }
+solana-client = { path = "../client", version = "0.21.2" }
-solana-config-program = { path = "../programs/config", version = "0.21.0" }
+solana-config-program = { path = "../programs/config", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 tar = "0.4.26"
 tempdir = "0.3.7"
 url = "2.1.0"

keygen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-keygen"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana key generation utility"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -14,8 +14,8 @@ clap = "2.33"
 dirs = "2.0.2"
 num_cpus = "1.11.1"
 rpassword = "4.0"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 tiny-bip39 = "0.6.2"
 
 [[bin]]

keygen/src/keygen.rs

@@ -1,15 +1,18 @@
 use bip39::{Language, Mnemonic, MnemonicType, Seed};
 use bs58;
 use clap::{
-    crate_description, crate_name, values_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand,
+    crate_description, crate_name, value_t, values_t_or_exit, App, AppSettings, Arg, ArgMatches,
+    SubCommand,
 };
 use num_cpus;
-use solana_clap_utils::keypair::{keypair_from_seed_phrase, SKIP_SEED_PHRASE_VALIDATION_ARG};
+use solana_clap_utils::keypair::{
+    keypair_from_seed_phrase, prompt_passphrase, ASK_KEYWORD, SKIP_SEED_PHRASE_VALIDATION_ARG,
+};
 use solana_sdk::{
     pubkey::write_pubkey_file,
     signature::{
         keypair_from_seed, read_keypair, read_keypair_file, write_keypair, write_keypair_file,
-        Keypair, KeypairUtil,
+        Keypair, KeypairUtil, Signature,
     },
 };
 use std::{
@@ -35,6 +38,26 @@ fn check_for_overwrite(outfile: &str, matches: &ArgMatches) {
     }
 }
 
+fn get_keypair_from_matches(matches: &ArgMatches) -> Result<Keypair, Box<dyn error::Error>> {
+    let mut path = dirs::home_dir().expect("home directory");
+    let infile = if matches.is_present("infile") {
+        matches.value_of("infile").unwrap()
+    } else {
+        path.extend(&[".config", "solana", "id.json"]);
+        path.to_str().unwrap()
+    };
+
+    if infile == "-" {
+        let mut stdin = std::io::stdin();
+        read_keypair(&mut stdin)
+    } else if infile == ASK_KEYWORD {
+        let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
+        keypair_from_seed_phrase("pubkey recovery", skip_validation, false)
+    } else {
+        read_keypair_file(infile)
+    }
+}
+
 fn output_keypair(
     keypair: &Keypair,
     outfile: &str,
@@ -55,6 +78,24 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         .about(crate_description!())
         .version(solana_clap_utils::version!())
         .setting(AppSettings::SubcommandRequiredElseHelp)
+        .subcommand(
+            SubCommand::with_name("verify")
+                .about("Verify a keypair can sign and verify a message.")
+                .arg(
+                    Arg::with_name("infile")
+                        .index(1)
+                        .value_name("PATH")
+                        .takes_value(true)
+                        .help("Path to keypair file"),
+                )
+                .arg(
+                    Arg::with_name("pubkey")
+                        .index(2)
+                        .value_name("BASE58_PUBKEY")
+                        .takes_value(true)
+                        .help("Public key"),
+                )
+        )
         .subcommand(
             SubCommand::with_name("new")
                 .about("Generate new keypair file from a passphrase and random seed phrase")
@@ -73,11 +114,26 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                         .long("force")
                         .help("Overwrite the output file if it exists"),
                 )
+                .arg(
+                    Arg::with_name("word_count")
+                        .long("word-count")
+                        .possible_values(&["12", "15", "18", "21", "24"])
+                        .default_value("12")
+                        .value_name("NUM")
+                        .takes_value(true)
+                        .help("Specify the number of words that will be present in the generated seed phrase"),
+                )
                 .arg(
                     Arg::with_name("no_passphrase")
                         .long("no-passphrase")
                         .help("Do not prompt for a passphrase"),
                 )
+                .arg(
+                    Arg::with_name("no_outfile")
+                        .long("no-outfile")
+                        .conflicts_with_all(&["outfile", "silent"])
+                        .help("Only print a seed phrase and pubkey. Do not output a keypair file"),
+                )
                 .arg(
                     Arg::with_name("silent")
                         .short("s")
@@ -132,6 +188,11 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                         .takes_value(true)
                         .help("Path to keypair file"),
                 )
+                .arg(
+                    Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)
+                        .long(SKIP_SEED_PHRASE_VALIDATION_ARG.long)
+                        .help(SKIP_SEED_PHRASE_VALIDATION_ARG.help),
+                )
                 .arg(
                     Arg::with_name("outfile")
                         .short("o")
@@ -176,19 +237,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
 
     match matches.subcommand() {
         ("pubkey", Some(matches)) => {
-            let mut path = dirs::home_dir().expect("home directory");
+            let keypair = get_keypair_from_matches(matches)?;
-            let infile = if matches.is_present("infile") {
-                matches.value_of("infile").unwrap()
-            } else {
-                path.extend(&[".config", "solana", "id.json"]);
-                path.to_str().unwrap()
-            };
-            let keypair = if infile == "-" {
-                let mut stdin = std::io::stdin();
-                read_keypair(&mut stdin)?
-            } else {
-                read_keypair_file(infile)?
-            };
 
             if matches.is_present("outfile") {
                 let outfile = matches.value_of("outfile").unwrap();
@@ -201,29 +250,37 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         ("new", Some(matches)) => {
             let mut path = dirs::home_dir().expect("home directory");
             let outfile = if matches.is_present("outfile") {
-                matches.value_of("outfile").unwrap()
+                matches.value_of("outfile")
+            } else if matches.is_present("no_outfile") {
+                None
             } else {
                 path.extend(&[".config", "solana", "id.json"]);
-                path.to_str().unwrap()
+                Some(path.to_str().unwrap())
             };
 
-            if outfile != "-" {
+            match outfile {
-                check_for_overwrite(&outfile, &matches);
+                Some("-") => (),
+                Some(outfile) => check_for_overwrite(&outfile, &matches),
+                None => (),
             }
 
-            let mnemonic = Mnemonic::new(MnemonicType::Words12, Language::English);
+            let word_count = value_t!(matches.value_of("word_count"), usize).unwrap();
+            let mnemonic_type = MnemonicType::for_word_count(word_count)?;
+            let mnemonic = Mnemonic::new(mnemonic_type, Language::English);
             let passphrase = if matches.is_present("no_passphrase") {
                 NO_PASSPHRASE.to_string()
             } else {
                 eprintln!("Generating a new keypair");
-                rpassword::prompt_password_stderr(
+                prompt_passphrase(
-                    "For added security, enter a passphrase (empty for no passphrase):",
+                    "For added security, enter a passphrase (empty for no passphrase): ",
                 )?
             };
             let seed = Seed::new(&mnemonic, &passphrase);
             let keypair = keypair_from_seed(seed.as_bytes())?;
 
+            if let Some(outfile) = outfile {
                 output_keypair(&keypair, &outfile, "new")?;
+            }
 
             let silent = matches.is_present("silent");
             if !silent {
@@ -249,7 +306,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
             }
 
             let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
-            let keypair = keypair_from_seed_phrase("recover", skip_validation)?;
+            let keypair = keypair_from_seed_phrase("recover", skip_validation, true)?;
             output_keypair(&keypair, &outfile, "recovered")?;
         }
         ("grind", Some(matches)) => {
@@ -331,6 +388,19 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                 .collect::<Vec<_>>();
             thread::park();
         }
+        ("verify", Some(matches)) => {
+            let keypair = get_keypair_from_matches(matches)?;
+            let test_data = b"test";
+            let signature = Signature::new(&keypair.sign(test_data).to_bytes());
+            let pubkey_bs58 = matches.value_of("pubkey").unwrap();
+            let pubkey = bs58::decode(pubkey_bs58).into_vec().unwrap();
+            if signature.verify(&pubkey, test_data) {
+                println!("Verification for public key: {}: Success", pubkey_bs58);
+            } else {
+                println!("Verification for public key: {}: Failed", pubkey_bs58);
+                exit(1);
+            }
+        }
         _ => unreachable!(),
     }
 

ledger-tool/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-ledger-tool"
 description = "Blockchain, Rebuilt for Scale"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -15,12 +15,12 @@ serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
 serde_yaml = "0.8.11"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-ledger = { path = "../ledger", version = "0.21.0" }
+solana-ledger = { path = "../ledger", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-runtime = { path = "../runtime", version = "0.21.0" }
+solana-runtime = { path = "../runtime", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
-solana-vote-program = { path = "../programs/vote", version = "0.21.0" }
+solana-vote-program = { path = "../programs/vote", version = "0.21.2" }
 
 [dev-dependencies]
 assert_cmd = "0.11"

ledger-tool/src/main.rs

@@ -581,9 +581,9 @@ fn main() {
                 })
             };
             let account_paths = if let Some(account_paths) = matches.value_of("account_paths") {
-                Some(account_paths.to_string())
+                account_paths.split(',').map(PathBuf::from).collect()
             } else {
-                Some(ledger_path.join("accounts").to_str().unwrap().to_string())
+                vec![ledger_path.join("accounts")]
             };
 
             let process_options = blocktree_processor::ProcessOptions {

ledger/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-ledger"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana ledger"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -29,19 +29,19 @@ rayon = "1.2.0"
 reed-solomon-erasure = { package = "solana-reed-solomon-erasure", version = "4.0.1-3", features = ["simd-accel"] }
 serde = "1.0.102"
 serde_derive = "1.0.102"
-solana-client = { path = "../client", version = "0.21.0" }
+solana-client = { path = "../client", version = "0.21.2" }
-solana-genesis-programs = { path = "../genesis-programs", version = "0.21.0" }
+solana-genesis-programs = { path = "../genesis-programs", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-measure = { path = "../measure", version = "0.21.0" }
+solana-measure = { path = "../measure", version = "0.21.2" }
-solana-merkle-tree = { path = "../merkle-tree", version = "0.21.0" }
+solana-merkle-tree = { path = "../merkle-tree", version = "0.21.2" }
-solana-metrics = { path = "../metrics", version = "0.21.0" }
+solana-metrics = { path = "../metrics", version = "0.21.2" }
-solana-perf = { path = "../perf", version = "0.21.0" }
+solana-perf = { path = "../perf", version = "0.21.2" }
 ed25519-dalek = "1.0.0-pre.1"
-solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "0.21.0" }
+solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "0.21.2" }
-solana-runtime = { path = "../runtime", version = "0.21.0" }
+solana-runtime = { path = "../runtime", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
-solana-stake-program = { path = "../programs/stake", version = "0.21.0" }
+solana-stake-program = { path = "../programs/stake", version = "0.21.2" }
-solana-vote-program = { path = "../programs/vote", version = "0.21.0" }
+solana-vote-program = { path = "../programs/vote", version = "0.21.2" }
 sys-info = "0.5.8"
 tar = "0.4.26"
 tempfile = "3.1.0"
@@ -55,7 +55,7 @@ features = ["lz4"]
 
 [dev-dependencies]
 matches = "0.1.6"
-solana-budget-program = { path = "../programs/budget", version = "0.21.0" }
+solana-budget-program = { path = "../programs/budget", version = "0.21.2" }
 
 [lib]
 crate-type = ["lib"]

ledger/src/bank_forks_utils.rs

@@ -7,12 +7,12 @@ use crate::{
 };
 use log::*;
 use solana_sdk::genesis_config::GenesisConfig;
-use std::{fs, sync::Arc};
+use std::{fs, path::PathBuf, sync::Arc};
 
 pub fn load(
     genesis_config: &GenesisConfig,
     blocktree: &Blocktree,
-    account_paths: Option<String>,
+    account_paths: Vec<PathBuf>,
     snapshot_config: Option<&SnapshotConfig>,
     process_options: ProcessOptions,
 ) -> Result<(BankForks, Vec<BankForksInfo>, LeaderScheduleCache), BlocktreeProcessorError> {
@@ -30,10 +30,13 @@ pub fn load(
         if tar.exists() {
             info!("Loading snapshot package: {:?}", tar);
             // Fail hard here if snapshot fails to load, don't silently continue
+
+            if account_paths.is_empty() {
+                panic!("Account paths not present when booting from snapshot")
+            }
+
             let deserialized_bank = snapshot_utils::bank_from_archive(
-                account_paths
+                &account_paths,
-                    .clone()
-                    .expect("Account paths not present when booting from snapshot"),
                 &snapshot_config.snapshot_path,
                 &tar,
             )

ledger/src/blocktree.rs

@@ -16,6 +16,7 @@ pub use crate::{
     blocktree_meta::SlotMeta,
 };
 use bincode::deserialize;
+use chrono::{offset::TimeZone, Duration as ChronoDuration, Utc};
 use log::*;
 use rayon::{
     iter::{IntoParallelRefIterator, ParallelIterator},
@@ -27,17 +28,18 @@ use solana_measure::measure::Measure;
 use solana_metrics::{datapoint_debug, datapoint_error};
 use solana_rayon_threadlimit::get_thread_count;
 use solana_sdk::{
-    clock::{Slot, DEFAULT_TICKS_PER_SECOND},
+    clock::{Slot, UnixTimestamp, DEFAULT_TICKS_PER_SECOND},
     genesis_config::GenesisConfig,
     hash::Hash,
     signature::{Keypair, KeypairUtil, Signature},
-    timing::timestamp,
+    timing::{duration_as_ms, timestamp},
     transaction::Transaction,
 };
 use std::{
     cell::RefCell,
     cmp,
     collections::HashMap,
+    convert::TryFrom,
     fs,
     path::{Path, PathBuf},
     rc::Rc,
@@ -45,6 +47,7 @@ use std::{
         mpsc::{sync_channel, Receiver, SyncSender, TrySendError},
         Arc, Mutex, RwLock,
     },
+    time::Duration,
 };
 
 pub const BLOCKTREE_DIRECTORY: &str = "rocksdb";
@@ -154,7 +157,7 @@ impl Blocktree {
         adjust_ulimit_nofile();
 
         // Open the database
-        let measure = Measure::start("open");
+        let mut measure = Measure::start("open");
         let db = Database::open(&blocktree_path)?;
 
         // Create the metadata column family
@@ -185,6 +188,7 @@ impl Blocktree {
             .unwrap_or(0);
         let last_root = Arc::new(RwLock::new(max_root));
 
+        measure.stop();
         info!("{:?} {}", blocktree_path, measure);
         Ok(Blocktree {
             db,
@@ -1129,6 +1133,25 @@ impl Blocktree {
         }
     }
 
+    // The `get_block_time` method is not fully implemented (depends on validator timestamp
+    // transactions). It currently returns Some(`slot` * DEFAULT_MS_PER_SLOT) offset from 0 for all
+    // transactions, and None for any values that would overflow any step.
+    pub fn get_block_time(&self, slot: Slot, slot_duration: Duration) -> Option<UnixTimestamp> {
+        let ms_per_slot = duration_as_ms(&slot_duration);
+        let (offset_millis, overflow) = slot.overflowing_mul(ms_per_slot);
+        if !overflow {
+            i64::try_from(offset_millis)
+                .ok()
+                .and_then(|millis| {
+                    let median_datetime = Utc.timestamp(0, 0);
+                    median_datetime.checked_add_signed(ChronoDuration::milliseconds(millis))
+                })
+                .map(|dt| dt.timestamp())
+        } else {
+            None
+        }
+    }
+
     pub fn get_confirmed_block(&self, slot: Slot) -> Result<RpcConfirmedBlock> {
         if self.is_root(slot) {
             let slot_meta_cf = self.db.column::<cf::SlotMeta>();

ledger/src/blocktree_processor.rs

@@ -27,6 +27,7 @@ use solana_sdk::{
 };
 use std::{
     cell::RefCell,
+    path::PathBuf,
     result,
     sync::Arc,
     time::{Duration, Instant},
@@ -253,7 +254,7 @@ pub struct ProcessOptions {
 pub fn process_blocktree(
     genesis_config: &GenesisConfig,
     blocktree: &Blocktree,
-    account_paths: Option<String>,
+    account_paths: Vec<PathBuf>,
     opts: ProcessOptions,
 ) -> result::Result<(BankForks, Vec<BankForksInfo>, LeaderScheduleCache), BlocktreeProcessorError> {
     if let Some(num_threads) = opts.override_num_threads {
@@ -662,7 +663,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         assert_eq!(
-            process_blocktree(&genesis_config, &blocktree, None, opts).err(),
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).err(),
             Some(BlocktreeProcessorError::InvalidBlock(
                 BlockError::InvalidTickHashCount
             )),
@@ -703,7 +704,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         assert_eq!(
-            process_blocktree(&genesis_config, &blocktree, None, opts).err(),
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).err(),
             Some(BlocktreeProcessorError::InvalidBlock(
                 BlockError::InvalidTickCount
             )),
@@ -755,7 +756,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         assert_eq!(
-            process_blocktree(&genesis_config, &blocktree, None, opts).err(),
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).err(),
             Some(BlocktreeProcessorError::InvalidBlock(
                 BlockError::TrailingEntry
             )),
@@ -822,7 +823,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         let (mut _bank_forks, bank_forks_info, _) =
-            process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
 
         assert_eq!(bank_forks_info.len(), 1);
         assert_eq!(
@@ -884,7 +885,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         let (bank_forks, bank_forks_info, _) =
-            process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
 
         assert_eq!(bank_forks_info.len(), 1); // One fork, other one is ignored b/c not a descendant of the root
 
@@ -958,7 +959,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         let (bank_forks, bank_forks_info, _) =
-            process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
 
         assert_eq!(bank_forks_info.len(), 2); // There are two forks
         assert_eq!(
@@ -1022,8 +1023,12 @@ pub mod tests {
         blocktree.set_dead_slot(2).unwrap();
         fill_blocktree_slot_with_ticks(&blocktree, ticks_per_slot, 3, 1, slot1_blockhash);
 
-        let (bank_forks, bank_forks_info, _) =
+        let (bank_forks, bank_forks_info, _) = process_blocktree(
-            process_blocktree(&genesis_config, &blocktree, None, ProcessOptions::default())
+            &genesis_config,
+            &blocktree,
+            Vec::new(),
+            ProcessOptions::default(),
+        )
         .unwrap();
 
         assert_eq!(bank_forks_info.len(), 1);
@@ -1054,7 +1059,7 @@ pub mod tests {
             Blocktree::open(&ledger_path).expect("Expected to successfully open database ledger");
 
         // Let last_slot be the number of slots in the first two epochs
-        let epoch_schedule = get_epoch_schedule(&genesis_config, None);
+        let epoch_schedule = get_epoch_schedule(&genesis_config, Vec::new());
         let last_slot = epoch_schedule.get_last_slot_in_epoch(1);
 
         // Create a single chain of slots with all indexes in the range [0, last_slot + 1]
@@ -1081,7 +1086,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         let (bank_forks, bank_forks_info, _) =
-            process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
 
         assert_eq!(bank_forks_info.len(), 1); // There is one fork
         assert_eq!(
@@ -1229,7 +1234,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         let (bank_forks, bank_forks_info, _) =
-            process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
 
         assert_eq!(bank_forks_info.len(), 1);
         assert_eq!(bank_forks.root(), 0);
@@ -1258,7 +1263,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         let (bank_forks, bank_forks_info, _) =
-            process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
 
         assert_eq!(bank_forks_info.len(), 1);
         assert_eq!(bank_forks_info[0], BankForksInfo { bank_slot: 0 });
@@ -1276,7 +1281,7 @@ pub mod tests {
             override_num_threads: Some(1),
             ..ProcessOptions::default()
         };
-        process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+        process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
         PAR_THREAD_POOL.with(|pool| {
             assert_eq!(pool.borrow().current_num_threads(), 1);
         });
@@ -1293,7 +1298,7 @@ pub mod tests {
             ..ProcessOptions::default()
         };
         let (_bank_forks, _bank_forks_info, cached_leader_schedule) =
-            process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+            process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
         assert_eq!(cached_leader_schedule.max_schedules(), std::usize::MAX);
     }
 
@@ -1353,7 +1358,7 @@ pub mod tests {
             entry_callback: Some(entry_callback),
             ..ProcessOptions::default()
         };
-        process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
+        process_blocktree(&genesis_config, &blocktree, Vec::new(), opts).unwrap();
         assert_eq!(*callback_counter.write().unwrap(), 2);
     }
 
@@ -2188,7 +2193,7 @@ pub mod tests {
 
     fn get_epoch_schedule(
         genesis_config: &GenesisConfig,
-        account_paths: Option<String>,
+        account_paths: Vec<PathBuf>,
     ) -> EpochSchedule {
         let bank = Bank::new_with_paths(&genesis_config, account_paths);
         bank.epoch_schedule().clone()

ledger/src/snapshot_utils.rs

@@ -86,7 +86,7 @@ pub fn package_snapshot<P: AsRef<Path>, Q: AsRef<Path>>(
     // Get a reference to all the relevant AccountStorageEntries
     let account_storage_entries: Vec<_> = bank
         .rc
-        .get_storage_entries()
+        .get_rooted_storage_entries()
         .into_iter()
         .filter(|x| x.slot_id() <= bank.slot())
         .collect();
@@ -207,7 +207,7 @@ pub fn bank_slot_from_archive<P: AsRef<Path>>(snapshot_tar: P) -> Result<u64> {
 }
 
 pub fn bank_from_archive<P: AsRef<Path>>(
-    account_paths: String,
+    account_paths: &[PathBuf],
     snapshot_path: &PathBuf,
     snapshot_tar: P,
 ) -> Result<Bank> {
@@ -266,7 +266,7 @@ pub fn untar_snapshot_in<P: AsRef<Path>, Q: AsRef<Path>>(
 }
 
 fn rebuild_bank_from_snapshots<P>(
-    local_account_paths: String,
+    local_account_paths: &[PathBuf],
     unpacked_snapshots_dir: &PathBuf,
     append_vecs_path: P,
 ) -> Result<Bank>

local-cluster/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-local-cluster"
 description = "Blockchain, Rebuilt for Scale"
-version = "0.21.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -11,23 +11,23 @@ homepage = "https://solana.com/"
 [dependencies]
 log = "0.4.8"
 rand = "0.6.5"
-solana-config-program = { path = "../programs/config", version = "0.21.0" }
+solana-config-program = { path = "../programs/config", version = "0.21.2" }
-solana-core = { path = "../core", version = "0.21.0" }
+solana-core = { path = "../core", version = "0.21.2" }
-solana-client = { path = "../client", version = "0.21.0" }
+solana-client = { path = "../client", version = "0.21.2" }
-solana-drone = { path = "../drone", version = "0.21.0" }
+solana-drone = { path = "../drone", version = "0.21.2" }
-solana-exchange-program = { path = "../programs/exchange", version = "0.21.0" }
+solana-exchange-program = { path = "../programs/exchange", version = "0.21.2" }
-solana-genesis-programs = { path = "../genesis-programs", version = "0.21.0" }
+solana-genesis-programs = { path = "../genesis-programs", version = "0.21.2" }
-solana-ledger = { path = "../ledger", version = "0.21.0" }
+solana-ledger = { path = "../ledger", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-runtime = { path = "../runtime", version = "0.21.0" }
+solana-runtime = { path = "../runtime", version = "0.21.2" }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
-solana-stake-program = { path = "../programs/stake", version = "0.21.0" }
+solana-stake-program = { path = "../programs/stake", version = "0.21.2" }
-solana-storage-program = { path = "../programs/storage", version = "0.21.0" }
+solana-storage-program = { path = "../programs/storage", version = "0.21.2" }
-solana-vest-program = { path = "../programs/vest", version = "0.21.0" }
+solana-vest-program = { path = "../programs/vest", version = "0.21.2" }
-solana-vote-program = { path = "../programs/vote", version = "0.21.0" }
+solana-vote-program = { path = "../programs/vote", version = "0.21.2" }
 symlink = "0.1.0"
 tempfile = "3.1.0"
-solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "0.21.0" }
+solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "0.21.2" }
 
 [dev-dependencies]
 serial_test = "0.2.0"

local-cluster/src/local_cluster.rs

@@ -151,7 +151,10 @@ impl LocalCluster {
         match genesis_config.operating_mode {
             OperatingMode::SoftLaunch => {
                 genesis_config.native_instruction_processors =
-                    solana_genesis_programs::get_programs(genesis_config.operating_mode, 0).unwrap()
+                    solana_genesis_programs::get_programs(genesis_config.operating_mode, 0)
+                        .unwrap()
+                        .into_iter()
+                        .collect()
             }
             // create_genesis_config_with_leader() assumes OperatingMode::Development so do
             // nothing...
@@ -169,18 +172,13 @@ impl LocalCluster {
             .push(solana_storage_program!());
 
         let storage_keypair = Keypair::new();
-        genesis_config.accounts.push((
+        genesis_config.add_account(
             storage_keypair.pubkey(),
             storage_contract::create_validator_storage_account(leader_pubkey, 1),
-        ));
+        );
 
         // Replace staking config
-        genesis_config.accounts = genesis_config
+        genesis_config.add_account(
-            .accounts
-            .into_iter()
-            .filter(|(pubkey, _)| *pubkey != stake_config::id())
-            .collect();
-        genesis_config.accounts.push((
             stake_config::id(),
             stake_config::create_account(
                 1,
@@ -189,7 +187,7 @@ impl LocalCluster {
                     slash_penalty: std::u8::MAX,
                 },
             ),
-        ));
+        );
 
         let (leader_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
         let leader_contact_info = leader_node.info.clone();

local-cluster/tests/local_cluster.rs

@@ -14,7 +14,6 @@ use solana_local_cluster::{
     cluster_tests,
     local_cluster::{ClusterConfig, LocalCluster},
 };
-use solana_runtime::accounts_db::AccountsDB;
 use solana_sdk::timing::timestamp;
 use solana_sdk::{
     client::SyncClient,
@@ -648,7 +647,7 @@ fn test_snapshots_restart_validity() {
         let (new_account_storage_dirs, new_account_storage_paths) =
             generate_account_paths(num_account_paths);
         all_account_storage_dirs.push(new_account_storage_dirs);
-        snapshot_test_config.validator_config.account_paths = Some(new_account_storage_paths);
+        snapshot_test_config.validator_config.account_paths = new_account_storage_paths;
 
         // Restart node
         trace!("Restarting cluster from snapshot");
@@ -903,15 +902,14 @@ fn wait_for_next_snapshot<P: AsRef<Path>>(cluster: &LocalCluster, tar: P) {
     }
 }
 
-fn generate_account_paths(num_account_paths: usize) -> (Vec<TempDir>, String) {
+fn generate_account_paths(num_account_paths: usize) -> (Vec<TempDir>, Vec<PathBuf>) {
     let account_storage_dirs: Vec<TempDir> = (0..num_account_paths)
         .map(|_| TempDir::new().unwrap())
         .collect();
     let account_storage_paths: Vec<_> = account_storage_dirs
         .iter()
-        .map(|a| a.path().to_str().unwrap().to_string())
+        .map(|a| a.path().to_path_buf())
         .collect();
-    let account_storage_paths = AccountsDB::format_paths(account_storage_paths);
     (account_storage_dirs, account_storage_paths)
 }
 
@@ -942,7 +940,7 @@ fn setup_snapshot_validator_config(
     let mut validator_config = ValidatorConfig::default();
     validator_config.rpc_config.enable_validator_exit = true;
     validator_config.snapshot_config = Some(snapshot_config);
-    validator_config.account_paths = Some(account_storage_paths);
+    validator_config.account_paths = account_storage_paths;
 
     SnapshotValidatorConfig {
         _snapshot_dir: snapshot_dir,

log-analyzer/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-log-analyzer"
 description = "The solana cluster network analysis tool"
-version = "0.1.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -17,8 +17,8 @@ semver = "0.9.0"
 serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
 
 [[bin]]
 name = "solana-log-analyzer"

logger/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-logger"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Logger"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"

measure/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "solana-measure"
 description = "Blockchain, Rebuilt for Scale"
-version = "0.21.0"
+version = "0.21.2"
 documentation = "https://docs.rs/solana"
 homepage = "https://solana.com/"
 readme = "../README.md"
@@ -11,4 +11,4 @@ license = "Apache-2.0"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }

merkle-tree/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-merkle-tree"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Merkle Tree"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -9,7 +9,7 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 
 [dev-dependencies]
 hex = "0.4.0"

metrics/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-metrics"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Metrics"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -13,7 +13,7 @@ env_logger = "0.7.1"
 lazy_static = "1.4.0"
 log = "0.4.8"
 reqwest = { version = "0.9.22", default-features = false, features = ["rustls-tls"] }
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
 sys-info = "0.5.8"
 
 [dev-dependencies]

multinode-demo/validator.sh

@@ -262,7 +262,7 @@ setup_validator_accounts() {
     fi
 
     echo "Creating validator vote account"
-    wallet create-vote-account "$voting_keypair_path" "$identity_keypair_path" --commission 127 || return $?
+    wallet create-vote-account "$voting_keypair_path" "$identity_keypair_path" --commission 50 || return $?
   fi
   echo "Validator vote account configured"
 

net-shaper/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-net-shaper"
 description = "The solana cluster network shaping tool"
-version = "0.1.0"
+version = "0.21.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -16,8 +16,8 @@ semver = "0.9.0"
 serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
 rand = "0.6.5"
 
 [[bin]]

net-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-net-utils"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Network Utilities"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -18,8 +18,8 @@ rand = "0.6.1"
 serde = "1.0.102"
 serde_derive = "1.0.102"
 socket2 = "0.3.11"
-solana-clap-utils = { path = "../clap-utils", version = "0.21.0" }
+solana-clap-utils = { path = "../clap-utils", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
 tokio = "0.1"
 tokio-codec = "0.1"
 

net-utils/src/ip_echo_server.rs

@@ -42,35 +42,78 @@ pub fn ip_echo_server(tcp: std::net::TcpListener) -> IpEchoServer {
         .incoming()
         .map_err(|err| warn!("accept failed: {:?}", err))
         .for_each(move |socket| {
-            let ip = socket.peer_addr().expect("Expect peer_addr()").ip();
+            let peer_addr = socket.peer_addr().expect("Expect peer_addr()");
-            info!("connection from {:?}", ip);
+            info!("connection from {:?}", peer_addr);
 
             let framed = BytesCodec::new().framed(socket);
             let (writer, reader) = framed.split();
 
             let processor = reader
-                .and_then(move |bytes| {
+                .and_then(move |data| {
-                    bincode::deserialize::<IpEchoServerMessage>(&bytes).or_else(|err| {
+                    if data.len() < 4 {
+                        return Err(io::Error::new(
+                            io::ErrorKind::Other,
+                            format!("Request too short, received {} bytes", data.len()),
+                        ));
+                    }
+                    let request_header: String = data[0..4].iter().map(|b| *b as char).collect();
+                    if request_header != "\0\0\0\0" {
+                        // Explicitly check for HTTP GET/POST requests to more gracefully handle
+                        // the case where a user accidentally tried to use a gossip entrypoint in
+                        // place of a JSON RPC URL:
+                        if request_header == "GET " || request_header == "POST" {
+                            return Ok(None); // None -> Send HTTP error response
+                        }
+                        return Err(io::Error::new(
+                            io::ErrorKind::Other,
+                            format!("Bad request header: {}", request_header),
+                        ));
+                    }
+
+                    let expected_len =
+                        bincode::serialized_size(&IpEchoServerMessage::default()).unwrap() as usize;
+                    let actual_len = data[4..].len();
+                    if actual_len < expected_len {
+                        return Err(io::Error::new(
+                            io::ErrorKind::Other,
+                            format!(
+                                "Request too short, actual {} < expected {}",
+                                actual_len, expected_len
+                            ),
+                        ));
+                    }
+
+                    bincode::deserialize::<IpEchoServerMessage>(&data[4..])
+                        .map(Some)
+                        .or_else(|err| {
                             Err(io::Error::new(
                                 io::ErrorKind::Other,
                                 format!("Failed to deserialize IpEchoServerMessage: {:?}", err),
                             ))
                         })
                 })
-                .and_then(move |msg| {
+                .and_then(move |maybe_msg| {
+                    match maybe_msg {
+                        None => None, // Send HTTP error response
+                        Some(msg) => {
                             // Fire a datagram at each non-zero UDP port
                             if !msg.udp_ports.is_empty() {
                                 match std::net::UdpSocket::bind("0.0.0.0:0") {
                                     Ok(udp_socket) => {
                                         for udp_port in &msg.udp_ports {
                                             if *udp_port != 0 {
-                                        match udp_socket
+                                                match udp_socket.send_to(
-                                            .send_to(&[0], SocketAddr::from((ip, *udp_port)))
+                                                    &[0],
-                                        {
+                                                    SocketAddr::from((peer_addr.ip(), *udp_port)),
-                                            Ok(_) => debug!("Successful send_to udp/{}", udp_port),
+                                                ) {
-                                            Err(err) => {
+                                                    Ok(_) => debug!(
-                                                info!("Failed to send_to udp/{}: {}", udp_port, err)
+                                                        "Successful send_to udp/{}",
-                                            }
+                                                        udp_port
+                                                    ),
+                                                    Err(err) => info!(
+                                                        "Failed to send_to udp/{}: {}",
+                                                        udp_port, err
+                                                    ),
                                                 }
                                             }
                                         }
@@ -82,8 +125,8 @@ pub fn ip_echo_server(tcp: std::net::TcpListener) -> IpEchoServer {
                             }
 
                             // Try to connect to each non-zero TCP port
-                    let tcp_futures: Vec<_> = msg
+                            let tcp_futures: Vec<_> =
-                        .tcp_ports
+                                msg.tcp_ports
                                     .iter()
                                     .filter_map(|tcp_port| {
                                         let tcp_port = *tcp_port;
@@ -91,10 +134,17 @@ pub fn ip_echo_server(tcp: std::net::TcpListener) -> IpEchoServer {
                                             None
                                         } else {
                                             Some(
-                                    tokio::net::TcpStream::connect(&SocketAddr::new(ip, tcp_port))
+                                                tokio::net::TcpStream::connect(&SocketAddr::new(
+                                                    peer_addr.ip(),
+                                                    tcp_port,
+                                                ))
                                                 .and_then(move |tcp_stream| {
-                                            debug!("Connection established to tcp/{}", tcp_port);
+                                                    debug!(
-                                            let _ = tcp_stream.shutdown(std::net::Shutdown::Both);
+                                                        "Connection established to tcp/{}",
+                                                        tcp_port
+                                                    );
+                                                    let _ = tcp_stream
+                                                        .shutdown(std::net::Shutdown::Both);
                                                     Ok(())
                                                 })
                                                 .timeout(Duration::from_secs(5))
@@ -111,14 +161,26 @@ pub fn ip_echo_server(tcp: std::net::TcpListener) -> IpEchoServer {
                                         }
                                     })
                                     .collect();
-                    future::join_all(tcp_futures)
+                            Some(future::join_all(tcp_futures))
+                        }
+                    }
                 })
-                .and_then(move |_| {
+                .and_then(move |valid_request| {
-                    let ip = bincode::serialize(&ip).unwrap_or_else(|err| {
+                    if valid_request.is_none() {
-                        warn!("Failed to serialize: {:?}", err);
+                        Ok(Bytes::from(
-                        vec![]
+                            "HTTP/1.1 400 Bad Request\nContent-length: 0\n\n",
-                    });
+                        ))
-                    Ok(Bytes::from(ip))
+                    } else {
+                        // "\0\0\0\0" header is added to ensure a valid response will never
+                        // conflict with the first four bytes of a valid HTTP response.
+                        let mut bytes = vec![
+                            0;
+                            4 + bincode::serialized_size(&peer_addr.ip()).unwrap()
+                                as usize
+                        ];
+                        bincode::serialize_into(&mut bytes[4..], &peer_addr.ip()).unwrap();
+                        Ok(Bytes::from(bytes))
+                    }
                 });
 
             let connection = writer

net-utils/src/lib.rs

@@ -29,8 +29,15 @@ fn ip_echo_server_request(
     let timeout = Duration::new(5, 0);
     TcpStream::connect_timeout(ip_echo_server_addr, timeout)
         .and_then(|mut stream| {
-            let msg = bincode::serialize(&msg).expect("serialize IpEchoServerMessage");
+            let mut bytes = vec![0; 4]; // Start with 4 null bytes to avoid looking like an HTTP GET/POST request
-            stream.write_all(&msg)?;
+
+            bytes.append(&mut bincode::serialize(&msg).expect("serialize IpEchoServerMessage"));
+
+            // End with '\n' to make this request look HTTP-ish and tickle an error response back
+            // from an HTTP server
+            bytes.push(b'\n');
+
+            stream.write_all(&bytes)?;
             stream.shutdown(std::net::Shutdown::Write)?;
             stream
                 .set_read_timeout(Some(Duration::new(10, 0)))
@@ -38,7 +45,38 @@ fn ip_echo_server_request(
             stream.read_to_end(&mut data)
         })
         .and_then(|_| {
-            bincode::deserialize(&data).map_err(|err| {
+            // It's common for users to accidentally confuse the validator's gossip port and JSON
+            // RPC port.  Attempt to detect when this occurs by looking for the standard HTTP
+            // response header and provide the user with a helpful error message
+            if data.len() < 4 {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("Response too short, received {} bytes", data.len()),
+                ));
+            }
+
+            let response_header: String = data[0..4].iter().map(|b| *b as char).collect();
+            if response_header != "\0\0\0\0" {
+                if response_header == "HTTP" {
+                    let http_response = data.iter().map(|b| *b as char).collect::<String>();
+                    return Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        format!(
+                            "Invalid gossip entrypoint. {} looks to be an HTTP port: {}",
+                            ip_echo_server_addr, http_response
+                        ),
+                    ));
+                }
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    format!(
+                        "Invalid gossip entrypoint. {} provided an invalid response header: '{}'",
+                        ip_echo_server_addr, response_header
+                    ),
+                ));
+            }
+
+            bincode::deserialize(&data[4..]).map_err(|err| {
                 io::Error::new(
                     io::ErrorKind::Other,
                     format!("Failed to deserialize: {:?}", err),
@@ -102,7 +140,7 @@ pub fn verify_reachable_ports(
                 );
                 std::process::exit(1);
             });
-        info!("tdp/{} is reachable", port);
+        info!("tcp/{} is reachable", port);
     }
 
     // Wait for a datagram to arrive at each UDP port
@@ -435,6 +473,7 @@ mod tests {
 
     #[test]
     fn test_get_public_ip_addr() {
+        solana_logger::setup();
         let (_server_port, (server_udp_socket, server_tcp_listener)) =
             bind_common_in_range((3200, 3250)).unwrap();
         let (client_port, (client_udp_socket, client_tcp_listener)) =
@@ -443,7 +482,10 @@ mod tests {
         let _runtime = ip_echo_server(server_tcp_listener);
 
         let ip_echo_server_addr = server_udp_socket.local_addr().unwrap();
-        get_public_ip_addr(&ip_echo_server_addr).unwrap();
+        assert_eq!(
+            get_public_ip_addr(&ip_echo_server_addr),
+            parse_host("127.0.0.1"),
+        );
 
         verify_reachable_ports(
             &ip_echo_server_addr,

perf/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-perf"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Performance APIs"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -18,11 +18,11 @@ serde_derive = "1.0.102"
 dlopen_derive = "0.1.4"
 lazy_static = "1.4.0"
 log = "0.4.8"
-solana-sdk = { path = "../sdk", version = "0.21.0" }
+solana-sdk = { path = "../sdk", version = "0.21.2" }
-solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "0.21.0" }
+solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "0.21.2" }
-solana-budget-program = { path = "../programs/budget", version = "0.21.0" }
+solana-budget-program = { path = "../programs/budget", version = "0.21.2" }
-solana-logger = { path = "../logger", version = "0.21.0" }
+solana-logger = { path = "../logger", version = "0.21.2" }
-solana-metrics = { path = "../metrics", version = "0.21.0" }
+solana-metrics = { path = "../metrics", version = "0.21.2" }
 
 [lib]
 name = "solana_perf"

programs/bpf/Cargo.lock

@@ -245,12 +245,12 @@ dependencies = [
 
 [[package]]
 name = "chrono"
-version = "0.4.9"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "libc 0.2.65 (registry+https://github.com/rust-lang/crates.io-index)",
  "num-integer 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
  "num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
  "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -822,7 +822,7 @@ dependencies = [
 
 [[package]]
 name = "itertools"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "either 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1117,7 +1117,7 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "chrono 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "chrono 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -1585,156 +1585,157 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "solana-bpf-loader-program"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "bincode 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.65 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-logger 0.21.0",
+ "solana-logger 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
  "solana_rbpf 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "solana-bpf-programs"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "bincode 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "elf 0.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-bpf-loader-program 0.21.0",
+ "solana-bpf-loader-program 0.21.1",
- "solana-logger 0.21.0",
+ "solana-logger 0.21.1",
- "solana-runtime 0.21.0",
+ "solana-runtime 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
  "solana_rbpf 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
  "walkdir 2.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "solana-bpf-rust-128bit"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-bpf-rust-128bit-dep 0.21.0",
+ "solana-bpf-rust-128bit-dep 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-128bit-dep"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-alloc"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-dep-crate"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-external-spend"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-iter"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-many-args"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-bpf-rust-many-args-dep 0.21.0",
+ "solana-bpf-rust-many-args-dep 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-many-args-dep"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-noop"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-panic"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-param-passing"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-bpf-rust-param-passing-dep 0.21.0",
+ "solana-bpf-rust-param-passing-dep 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-param-passing-dep"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-bpf-rust-sysval"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-sdk-bpf-test 0.21.0",
+ "solana-sdk-bpf-test 0.21.1",
 ]
 
 [[package]]
 name = "solana-config-program"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "bincode 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "chrono 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-logger 0.21.0",
+ "solana-logger 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
 ]
 
 [[package]]
 name = "solana-crate-features"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "backtrace 0.3.37 (registry+https://github.com/rust-lang/crates.io-index)",
  "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1757,7 +1758,7 @@ dependencies = [
 
 [[package]]
 name = "solana-logger"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "env_logger 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1766,26 +1767,26 @@ dependencies = [
 
 [[package]]
 name = "solana-measure"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
 ]
 
 [[package]]
 name = "solana-metrics"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "env_logger 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "reqwest 0.9.22 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
  "sys-info 0.5.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "solana-rayon-threadlimit"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "sys-info 0.5.8 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1793,14 +1794,14 @@ dependencies = [
 
 [[package]]
 name = "solana-runtime"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "bincode 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bv 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "fs_extra 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "itertools 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "itertools 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.65 (registry+https://github.com/rust-lang/crates.io-index)",
  "libloading 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1811,22 +1812,22 @@ dependencies = [
  "serde 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_json 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-bpf-loader-program 0.21.0",
+ "solana-bpf-loader-program 0.21.1",
- "solana-logger 0.21.0",
+ "solana-logger 0.21.1",
- "solana-measure 0.21.0",
+ "solana-measure 0.21.1",
- "solana-metrics 0.21.0",
+ "solana-metrics 0.21.1",
- "solana-rayon-threadlimit 0.21.0",
+ "solana-rayon-threadlimit 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-stake-program 0.21.0",
+ "solana-stake-program 0.21.1",
- "solana-storage-program 0.21.0",
+ "solana-storage-program 0.21.1",
- "solana-vote-program 0.21.0",
+ "solana-vote-program 0.21.1",
  "sys-info 0.5.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "solana-sdk"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "assert_matches 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bincode 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1836,8 +1837,7 @@ dependencies = [
  "generic-array 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "hex 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "hmac 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "itertools 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "itertools 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "memmap 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "num-derive 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1850,17 +1850,28 @@ dependencies = [
  "serde_derive 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_json 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)",
  "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-crate-features 0.21.0",
+ "solana-crate-features 0.21.1",
- "solana-logger 0.21.0",
+ "solana-logger 0.21.1",
+ "solana-sdk-macro 0.21.1",
 ]
 
 [[package]]
 name = "solana-sdk-bpf-test"
-version = "0.21.0"
+version = "0.21.1"
+
+[[package]]
+name = "solana-sdk-macro"
+version = "0.21.1"
+dependencies = [
+ "bs58 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro2 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
 
 [[package]]
 name = "solana-stake-program"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "bincode 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1869,16 +1880,16 @@ dependencies = [
  "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-config-program 0.21.0",
+ "solana-config-program 0.21.1",
- "solana-logger 0.21.0",
+ "solana-logger 0.21.1",
- "solana-metrics 0.21.0",
+ "solana-metrics 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
- "solana-vote-program 0.21.0",
+ "solana-vote-program 0.21.1",
 ]
 
 [[package]]
 name = "solana-storage-program"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "bincode 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1887,13 +1898,13 @@ dependencies = [
  "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-logger 0.21.0",
+ "solana-logger 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
 ]
 
 [[package]]
 name = "solana-vote-program"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "bincode 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1901,9 +1912,9 @@ dependencies = [
  "num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.102 (registry+https://github.com/rust-lang/crates.io-index)",
- "solana-logger 0.21.0",
+ "solana-logger 0.21.1",
- "solana-metrics 0.21.0",
+ "solana-metrics 0.21.1",
- "solana-sdk 0.21.0",
+ "solana-sdk 0.21.1",
 ]
 
 [[package]]
@@ -2601,7 +2612,7 @@ dependencies = [
 "checksum cc 1.0.45 (registry+https://github.com/rust-lang/crates.io-index)" = "4fc9a35e1f4290eb9e5fc54ba6cf40671ed2a2514c3eeb2b2a908dda2ea5a1be"
 "checksum cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "b486ce3ccf7ffd79fdeb678eac06a9e6c09fc88d33836340becb8fffe87c5e33"
 "checksum cgmath 0.16.1 (registry+https://github.com/rust-lang/crates.io-index)" = "64a4b57c8f4e3a2e9ac07e0f6abc9c24b6fc9e1b54c3478cfb598f3d0023e51c"
-"checksum chrono 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e8493056968583b0193c1bb04d6f7684586f3726992d6c573261941a895dbd68"
+"checksum chrono 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "31850b4a4d6bae316f7a09e691c944c28299298837edc0a03f755618c23cbc01"
 "checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
 "checksum clear_on_drop 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "97276801e127ffb46b66ce23f35cc96bd454fa311294bced4bbace7baa8b1d17"
 "checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
@@ -2662,7 +2673,7 @@ dependencies = [
 "checksum indexmap 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a61202fbe46c4a951e9404a720a0180bcf3212c750d735cb5c4ba4dc551299f3"
 "checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08"
 "checksum itertools 0.7.11 (registry+https://github.com/rust-lang/crates.io-index)" = "0d47946d458e94a1b7bcabbf6521ea7c037062c81f534615abcad76e84d4970d"
-"checksum itertools 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "87fa75c9dea7b07be3138c49abbb83fd4bea199b5cdc76f9804458edc5da0d6e"
+"checksum itertools 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f56a2d0bc861f9165be4eb3442afd3c236d8a98afd426f65d92324ae1091a484"
 "checksum itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "501266b7edd0174f8530248f87f99c88fbe60ca4ef3dd486835b8d8d53136f7f"
 "checksum jobserver 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "f2b1d42ef453b30b7387e113da1c83ab1605d90c5b4e0eb8e96d016ed3b8c160"
 "checksum js-sys 0.3.27 (registry+https://github.com/rust-lang/crates.io-index)" = "1efc4f2a556c58e79c5500912e221dd826bec64ff4aabd8ce71ccef6da02d7d4"

programs/bpf/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "solana-bpf-programs"
 description = "Blockchain, Rebuilt for Scale"
-version = "0.21.0"
+version = "0.21.2"
 documentation = "https://docs.rs/solana"
 homepage = "https://solana.com/"
 readme = "README.md"
@@ -22,10 +22,10 @@ walkdir = "2"
 bincode = "1.1.4"
 byteorder = "1.3.2"
 elf = "0.0.10"
-solana-bpf-loader-program = { path = "../bpf_loader", version = "0.21.0" }
+solana-bpf-loader-program = { path = "../bpf_loader", version = "0.21.2" }
-solana-logger = { path = "../../logger", version = "0.21.0" }
+solana-logger = { path = "../../logger", version = "0.21.2" }
-solana-runtime = { path = "../../runtime", version = "0.21.0" }
+solana-runtime = { path = "../../runtime", version = "0.21.2" }
-solana-sdk = { path = "../../sdk", version = "0.21.0" }
+solana-sdk = { path = "../../sdk", version = "0.21.2" }
 solana_rbpf = "=0.1.19"
 
 [[bench]]

programs/bpf/rust/128bit/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-128bit"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,11 +12,11 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
-solana-bpf-rust-128bit-dep = { path = "../128bit_dep", version = "0.21.0" }
+solana-bpf-rust-128bit-dep = { path = "../128bit_dep", version = "0.21.2" }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/128bit_dep/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-128bit-dep"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,10 +12,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/alloc/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-alloc"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,10 +12,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/dep_crate/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-dep-crate"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -13,10 +13,10 @@ edition = "2018"
 
 [dependencies]
 byteorder = { version = "1", default-features = false }
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/external_spend/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-external-spend"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,10 +12,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/iter/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-iter"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,10 +12,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/many_args/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-many-args"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,11 +12,11 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
-solana-bpf-rust-many-args-dep = { path = "../many_args_dep", version = "0.21.0" }
+solana-bpf-rust-many-args-dep = { path = "../many_args_dep", version = "0.21.2" }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/many_args_dep/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-many-args-dep"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,10 +12,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/noop/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-noop"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,10 +12,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/panic/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-panic"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,10 +12,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/param_passing/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-param-passing"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,11 +12,11 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
-solana-bpf-rust-param-passing-dep = { path = "../param_passing_dep", version = "0.21.0" }
+solana-bpf-rust-param-passing-dep = { path = "../param_passing_dep", version = "0.21.2" }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/param_passing_dep/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-param-passing-dep"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,10 +12,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/sysval/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "solana-bpf-rust-sysval"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF test program written in Rust"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -12,10 +12,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-solana-sdk = { path = "../../../../sdk/", version = "0.21.0", default-features = false }
+solana-sdk = { path = "../../../../sdk/", version = "0.21.2", default-features = false }
 
 [dev_dependencies]
-solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.0" }
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "0.21.2" }
 
 [features]
 program = ["solana-sdk/program"]

programs/bpf/rust/sysval/src/lib.rs

@@ -6,10 +6,11 @@ use solana_sdk::{
     clock::{get_segment_from_slot, DEFAULT_SLOTS_PER_EPOCH, DEFAULT_SLOTS_PER_SEGMENT},
     entrypoint,
     entrypoint::SUCCESS,
+    info,
     pubkey::Pubkey,
     rent,
     sysvar::{
-        clock::Clock, fees::Fees, rent::Rent, rewards::Rewards, slot_hashes::SlotHashes,
+        self, clock::Clock, fees::Fees, rent::Rent, rewards::Rewards, slot_hashes::SlotHashes,
         stake_history::StakeHistory, Sysvar,
     },
 };
@@ -17,6 +18,8 @@ use solana_sdk::{
 entrypoint!(process_instruction);
 fn process_instruction(_program_id: &Pubkey, accounts: &mut [AccountInfo], _data: &[u8]) -> u32 {
     // Clock
+    info!("Clock identifier:");
+    sysvar::clock::id().log();
     let clock = Clock::from_account_info(&accounts[2]).expect("clock");
     assert_eq!(clock.slot, DEFAULT_SLOTS_PER_EPOCH + 1);
     assert_eq!(
@@ -25,18 +28,26 @@ fn process_instruction(_program_id: &Pubkey, accounts: &mut [AccountInfo], _data
     );
 
     // Fees
+    info!("Fees identifier:");
+    sysvar::fees::id().log();
     let fees = Fees::from_account_info(&accounts[3]).expect("fees");
     let burn = fees.fee_calculator.burn(42);
     assert_eq!(burn, (21, 21));
 
     // Rewards
+    info!("Rewards identifier:");
+    sysvar::rewards::id().log();
     let _rewards = Rewards::from_account_info(&accounts[4]).expect("rewards");
 
     // Slot Hashes
+    info!("SlotHashes identifier:");
+    sysvar::slot_hashes::id().log();
     let slot_hashes = SlotHashes::from_account_info(&accounts[5]).expect("slot_hashes");
     assert!(slot_hashes.len() >= 1);
 
     // Stake History
+    info!("StakeHistory identifier:");
+    sysvar::stake_history::id().log();
     let stake_history = StakeHistory::from_account_info(&accounts[6]).expect("stake_history");
     assert!(stake_history.len() >= 1);
 

programs/bpf_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-bpf-loader-program"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana BPF loader"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -14,8 +14,8 @@ byteorder = "1.3.2"
 libc = "0.2.65"
 log = "0.4.8"
 serde = "1.0.102"
-solana-logger = { path = "../../logger", version = "0.21.0" }
+solana-logger = { path = "../../logger", version = "0.21.2" }
-solana-sdk = { path = "../../sdk", version = "0.21.0" }
+solana-sdk = { path = "../../sdk", version = "0.21.2" }
 solana_rbpf = "=0.1.19"
 
 [lib]

programs/bpf_loader/src/lib.rs

@@ -7,7 +7,6 @@ use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
 use log::*;
 use solana_rbpf::{memory_region::MemoryRegion, EbpfVm};
 use solana_sdk::account::KeyedAccount;
-use solana_sdk::bpf_loader;
 use solana_sdk::instruction::InstructionError;
 use solana_sdk::instruction_processor_utils::{limited_deserialize, next_keyed_account};
 use solana_sdk::loader_instruction::LoaderInstruction;
@@ -19,7 +18,7 @@ use std::io::Error;
 use std::mem;
 
 solana_sdk::declare_program!(
-    bpf_loader::BS58_STRING,
+    solana_sdk::bpf_loader::ID,
     solana_bpf_loader_program,
     process_instruction
 );

programs/btc_spv/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-btc-spv-program"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Bitcoin spv parsing program"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -16,7 +16,7 @@ num-derive = "0.3"
 num-traits = "0.2"
 serde = "1.0.102"
 serde_derive = "1.0.102"
-solana-sdk = { path = "../../sdk", version = "0.21.0"}
+solana-sdk = { path = "../../sdk", version = "0.21.2"}
 hex = "0.3.2"
 
 [lib]

programs/btc_spv_bin/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "btc_spv_bin"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Bitcoin spv parsing program"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"

programs/budget/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-budget-program"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Budget program"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -16,10 +16,10 @@ num-derive = "0.3"
 num-traits = "0.2"
 serde = "1.0.102"
 serde_derive = "1.0.102"
-solana-sdk = { path = "../../sdk", version = "0.21.0" }
+solana-sdk = { path = "../../sdk", version = "0.21.2" }
 
 [dev-dependencies]
-solana-runtime = { path = "../../runtime", version = "0.21.0" }
+solana-runtime = { path = "../../runtime", version = "0.21.2" }
 
 [lib]
 crate-type = ["lib", "cdylib"]

programs/config/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-config-program"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Config program"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -14,8 +14,8 @@ chrono = { version = "0.4.10", features = ["serde"] }
 log = "0.4.8"
 serde = "1.0.102"
 serde_derive = "1.0.102"
-solana-logger = { path = "../../logger", version = "0.21.0" }
+solana-logger = { path = "../../logger", version = "0.21.2" }
-solana-sdk = { path = "../../sdk", version = "0.21.0" }
+solana-sdk = { path = "../../sdk", version = "0.21.2" }
 
 [lib]
 crate-type = ["lib", "cdylib"]

programs/config_tests/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-config-tests"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana config api tests"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -13,11 +13,11 @@ bincode = "1.2.0"
 log = "0.4.8"
 serde = "1.0.102"
 serde_derive = "1.0.102"
-solana-logger = { path = "../../logger", version = "0.21.0" }
+solana-logger = { path = "../../logger", version = "0.21.2" }
-solana-sdk = { path = "../../sdk", version = "0.21.0" }
+solana-sdk = { path = "../../sdk", version = "0.21.2" }
-solana-config-program = { path = "../config", version = "0.21.0" }
+solana-config-program = { path = "../config", version = "0.21.2" }
 
 
 [dev-dependencies]
-solana-runtime = { path = "../../runtime", version = "0.21.0" }
+solana-runtime = { path = "../../runtime", version = "0.21.2" }
 assert_matches = "1.3.0"

programs/exchange/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-exchange-program"
-version = "0.21.0"
+version = "0.21.2"
 description = "Solana Exchange program"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -13,12 +13,12 @@ bincode = "1.2.0"
 log = "0.4.8"
 serde = "1.0.102"
 serde_derive = "1.0.102"
-solana-logger = { path = "../../logger", version = "0.21.0" }
+solana-logger = { path = "../../logger", version = "0.21.2" }
-solana-metrics = { path = "../../metrics", version = "0.21.0" }
+solana-metrics = { path = "../../metrics", version = "0.21.2" }
-solana-sdk = { path = "../../sdk", version = "0.21.0" }
+solana-sdk = { path = "../../sdk", version = "0.21.2" }
 
 [dev-dependencies]
-solana-runtime = { path = "../../runtime", version = "0.21.0" }
+solana-runtime = { path = "../../runtime", version = "0.21.2" }
 
 [lib]
 crate-type = ["lib", "cdylib"]