2018-03-03 13:41:36 -08:00
|
|
|
//! A command-line executable for generating the chain's genesis block.
|
2019-05-13 14:17:44 -07:00
|
|
|
#[macro_use]
|
2019-06-12 08:49:59 -07:00
|
|
|
extern crate solana_bpf_loader_program;
|
2019-06-11 10:27:22 -07:00
|
|
|
#[macro_use]
|
2019-05-13 14:17:44 -07:00
|
|
|
extern crate solana_vote_program;
|
|
|
|
#[macro_use]
|
|
|
|
extern crate solana_stake_program;
|
2019-05-14 10:44:16 -07:00
|
|
|
#[macro_use]
|
|
|
|
extern crate solana_budget_program;
|
|
|
|
#[macro_use]
|
|
|
|
extern crate solana_token_program;
|
|
|
|
#[macro_use]
|
|
|
|
extern crate solana_config_program;
|
|
|
|
#[macro_use]
|
|
|
|
extern crate solana_exchange_program;
|
2019-06-11 10:27:22 -07:00
|
|
|
#[macro_use]
|
|
|
|
extern crate solana_storage_program;
|
2018-03-03 13:41:36 -08:00
|
|
|
|
2019-03-13 20:54:30 -07:00
|
|
|
use clap::{crate_description, crate_name, crate_version, value_t_or_exit, App, Arg};
|
2019-02-07 20:52:39 -08:00
|
|
|
use solana::blocktree::create_new_ledger;
|
2019-05-07 11:16:22 -07:00
|
|
|
use solana_sdk::account::Account;
|
2019-05-07 20:28:41 -07:00
|
|
|
use solana_sdk::fee_calculator::FeeCalculator;
|
2019-06-19 15:40:39 -07:00
|
|
|
use solana_sdk::genesis_block::Builder;
|
2019-05-18 14:01:36 -07:00
|
|
|
use solana_sdk::hash::{hash, Hash};
|
|
|
|
use solana_sdk::poh_config::PohConfig;
|
2019-06-06 19:24:09 -07:00
|
|
|
use solana_sdk::pubkey::Pubkey;
|
2019-06-11 18:47:35 -07:00
|
|
|
use solana_sdk::signature::{read_keypair, Keypair, KeypairUtil};
|
2019-05-07 11:16:22 -07:00
|
|
|
use solana_sdk::system_program;
|
2019-05-18 14:01:36 -07:00
|
|
|
use solana_sdk::timing;
|
2019-05-08 12:56:11 -07:00
|
|
|
use solana_stake_api::stake_state;
|
2019-06-11 10:27:22 -07:00
|
|
|
use solana_storage_api::storage_contract;
|
2019-05-07 11:16:22 -07:00
|
|
|
use solana_vote_api::vote_state;
|
2019-06-10 19:42:49 -07:00
|
|
|
use std::collections::HashMap;
|
2018-07-01 08:04:41 -07:00
|
|
|
use std::error;
|
2019-06-06 19:24:09 -07:00
|
|
|
use std::fs::File;
|
|
|
|
use std::io;
|
2019-06-10 19:42:49 -07:00
|
|
|
use std::str::FromStr;
|
2019-05-18 14:01:36 -07:00
|
|
|
use std::time::{Duration, Instant};
|
2018-03-03 13:41:36 -08:00
|
|
|
|
2019-05-07 11:16:22 -07:00
|
|
|
pub const BOOTSTRAP_LEADER_LAMPORTS: u64 = 42;
|
2018-11-15 17:05:31 -08:00
|
|
|
|
2019-06-11 18:47:35 -07:00
|
|
|
pub enum AccountFileFormat {
|
|
|
|
Pubkey,
|
|
|
|
Keypair,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn append_primordial_accounts(
|
|
|
|
file: &str,
|
|
|
|
file_format: AccountFileFormat,
|
2019-06-19 15:40:39 -07:00
|
|
|
mut builder: Builder,
|
|
|
|
) -> io::Result<(Builder)> {
|
2019-06-06 19:24:09 -07:00
|
|
|
let accounts_file = File::open(file.to_string())?;
|
|
|
|
|
2019-06-10 19:42:49 -07:00
|
|
|
let primordial_accounts: HashMap<String, u64> = serde_yaml::from_reader(accounts_file)
|
2019-06-06 19:24:09 -07:00
|
|
|
.map_err(|err| io::Error::new(io::ErrorKind::Other, format!("{:?}", err)))?;
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
for (account, balance) in primordial_accounts {
|
|
|
|
let pubkey = match file_format {
|
|
|
|
AccountFileFormat::Pubkey => Pubkey::from_str(account.as_str()).unwrap(),
|
|
|
|
AccountFileFormat::Keypair => {
|
|
|
|
let bytes: Vec<u8> = serde_json::from_str(account.as_str()).unwrap();
|
|
|
|
Keypair::from_bytes(&bytes).unwrap().pubkey()
|
|
|
|
}
|
|
|
|
};
|
2019-06-06 19:24:09 -07:00
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
builder = builder.account(pubkey, Account::new(balance, 0, &system_program::id()));
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(builder)
|
2019-06-06 19:24:09 -07:00
|
|
|
}
|
|
|
|
|
2018-12-08 21:44:20 -08:00
|
|
|
fn main() -> Result<(), Box<dyn error::Error>> {
|
2019-04-16 13:03:01 -07:00
|
|
|
let default_bootstrap_leader_lamports = &BOOTSTRAP_LEADER_LAMPORTS.to_string();
|
2019-06-10 22:18:32 -07:00
|
|
|
let default_target_lamports_per_signature = &FeeCalculator::default()
|
|
|
|
.target_lamports_per_signature
|
|
|
|
.to_string();
|
|
|
|
let default_target_signatures_per_slot = &FeeCalculator::default()
|
|
|
|
.target_signatures_per_slot
|
|
|
|
.to_string();
|
2019-05-18 14:01:36 -07:00
|
|
|
let default_target_tick_duration =
|
|
|
|
&timing::duration_as_ms(&PohConfig::default().target_tick_duration).to_string();
|
|
|
|
let default_ticks_per_slot = &timing::DEFAULT_TICKS_PER_SLOT.to_string();
|
|
|
|
let default_slots_per_epoch = &timing::DEFAULT_SLOTS_PER_EPOCH.to_string();
|
2019-05-07 20:28:41 -07:00
|
|
|
|
2019-03-13 20:54:30 -07:00
|
|
|
let matches = App::new(crate_name!())
|
|
|
|
.about(crate_description!())
|
2018-08-06 20:51:12 -07:00
|
|
|
.version(crate_version!())
|
2019-01-24 12:04:04 -08:00
|
|
|
.arg(
|
|
|
|
Arg::with_name("bootstrap_leader_keypair_file")
|
|
|
|
.short("b")
|
|
|
|
.long("bootstrap-leader-keypair")
|
|
|
|
.value_name("BOOTSTRAP LEADER KEYPAIR")
|
|
|
|
.takes_value(true)
|
|
|
|
.required(true)
|
|
|
|
.help("Path to file containing the bootstrap leader's keypair"),
|
|
|
|
)
|
|
|
|
.arg(
|
|
|
|
Arg::with_name("ledger_path")
|
|
|
|
.short("l")
|
|
|
|
.long("ledger")
|
|
|
|
.value_name("DIR")
|
|
|
|
.takes_value(true)
|
|
|
|
.required(true)
|
|
|
|
.help("Use directory as persistent ledger location"),
|
|
|
|
)
|
2018-07-12 14:42:01 -07:00
|
|
|
.arg(
|
2019-03-05 17:01:57 -08:00
|
|
|
Arg::with_name("lamports")
|
2018-07-12 14:42:01 -07:00
|
|
|
.short("t")
|
2019-03-05 17:01:57 -08:00
|
|
|
.long("lamports")
|
|
|
|
.value_name("LAMPORTS")
|
2018-07-12 14:42:01 -07:00
|
|
|
.takes_value(true)
|
|
|
|
.required(true)
|
2019-03-05 17:01:57 -08:00
|
|
|
.help("Number of lamports to create in the mint"),
|
2018-12-07 19:01:28 -08:00
|
|
|
)
|
|
|
|
.arg(
|
2019-01-24 12:04:04 -08:00
|
|
|
Arg::with_name("mint_keypair_file")
|
2018-11-02 14:32:05 -07:00
|
|
|
.short("m")
|
|
|
|
.long("mint")
|
|
|
|
.value_name("MINT")
|
|
|
|
.takes_value(true)
|
|
|
|
.required(true)
|
|
|
|
.help("Path to file containing keys of the mint"),
|
2018-12-07 19:01:28 -08:00
|
|
|
)
|
2019-04-10 12:51:25 -07:00
|
|
|
.arg(
|
2019-04-10 17:52:47 -07:00
|
|
|
Arg::with_name("bootstrap_vote_keypair_file")
|
2019-04-10 12:51:25 -07:00
|
|
|
.short("s")
|
2019-04-10 17:52:47 -07:00
|
|
|
.long("bootstrap-vote-keypair")
|
|
|
|
.value_name("BOOTSTRAP VOTE KEYPAIR")
|
2019-04-10 12:51:25 -07:00
|
|
|
.takes_value(true)
|
|
|
|
.required(true)
|
2019-05-08 12:56:11 -07:00
|
|
|
.help("Path to file containing the bootstrap leader's voting keypair"),
|
|
|
|
)
|
|
|
|
.arg(
|
|
|
|
Arg::with_name("bootstrap_stake_keypair_file")
|
|
|
|
.short("k")
|
|
|
|
.long("bootstrap-stake-keypair")
|
|
|
|
.value_name("BOOTSTRAP STAKE KEYPAIR")
|
|
|
|
.takes_value(true)
|
|
|
|
.required(true)
|
2019-04-10 12:51:25 -07:00
|
|
|
.help("Path to file containing the bootstrap leader's staking keypair"),
|
|
|
|
)
|
2019-05-20 19:46:15 -07:00
|
|
|
.arg(
|
|
|
|
Arg::with_name("bootstrap_storage_keypair_file")
|
|
|
|
.long("bootstrap-storage-keypair")
|
|
|
|
.value_name("BOOTSTRAP STORAGE KEYPAIR")
|
|
|
|
.takes_value(true)
|
|
|
|
.required(true)
|
|
|
|
.help("Path to file containing the bootstrap leader's storage keypair"),
|
|
|
|
)
|
2019-04-16 13:03:01 -07:00
|
|
|
.arg(
|
|
|
|
Arg::with_name("bootstrap_leader_lamports")
|
|
|
|
.long("bootstrap-leader-lamports")
|
|
|
|
.value_name("LAMPORTS")
|
|
|
|
.takes_value(true)
|
|
|
|
.default_value(default_bootstrap_leader_lamports)
|
|
|
|
.required(true)
|
|
|
|
.help("Number of lamports to assign to the bootstrap leader"),
|
|
|
|
)
|
2019-05-31 19:58:52 -07:00
|
|
|
.arg(
|
|
|
|
Arg::with_name("bootstrap_leader_stake_lamports")
|
|
|
|
.long("bootstrap-leader-stake-lamports")
|
|
|
|
.value_name("LAMPORTS")
|
|
|
|
.takes_value(true)
|
|
|
|
.default_value(default_bootstrap_leader_lamports)
|
|
|
|
.required(true)
|
|
|
|
.help("Number of lamports to assign to the bootstrap leader's stake account"),
|
|
|
|
)
|
2019-05-07 20:28:41 -07:00
|
|
|
.arg(
|
2019-06-10 22:18:32 -07:00
|
|
|
Arg::with_name("target_lamports_per_signature")
|
|
|
|
.long("target-lamports-per-signature")
|
2019-05-07 20:28:41 -07:00
|
|
|
.value_name("LAMPORTS")
|
|
|
|
.takes_value(true)
|
2019-06-10 22:18:32 -07:00
|
|
|
.default_value(default_target_lamports_per_signature)
|
|
|
|
.help(
|
|
|
|
"The cost in lamports that the cluster will charge for signature \
|
|
|
|
verification when the cluster is operating at target-signatures-per-slot",
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.arg(
|
|
|
|
Arg::with_name("target_signatures_per_slot")
|
|
|
|
.long("target-signatures-per-slot")
|
|
|
|
.value_name("NUMBER")
|
|
|
|
.takes_value(true)
|
|
|
|
.default_value(default_target_signatures_per_slot)
|
|
|
|
.help(
|
|
|
|
"Used to estimate the desired processing capacity of the cluster.
|
|
|
|
When the latest slot processes fewer/greater signatures than this \
|
|
|
|
value, the lamports-per-signature fee will decrease/increase for \
|
|
|
|
the next slot. A value of 0 disables signature-based fee adjustments",
|
|
|
|
),
|
2019-05-07 20:28:41 -07:00
|
|
|
)
|
2019-05-18 14:01:36 -07:00
|
|
|
.arg(
|
|
|
|
Arg::with_name("target_tick_duration")
|
|
|
|
.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(
|
|
|
|
Arg::with_name("hashes_per_tick")
|
|
|
|
.long("hashes-per-tick")
|
|
|
|
.value_name("NUM_HASHES|\"auto\"|\"sleep\"")
|
|
|
|
.takes_value(true)
|
|
|
|
.default_value("auto")
|
|
|
|
.help(
|
|
|
|
"How many PoH hashes to roll before emitting the next tick. \
|
|
|
|
If \"auto\", determine based on --target-tick-duration \
|
|
|
|
and the hash rate of this computer. If \"sleep\", for development \
|
|
|
|
sleep for --target-tick-duration instead of hashing",
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.arg(
|
|
|
|
Arg::with_name("ticks_per_slot")
|
|
|
|
.long("ticks-per-slot")
|
|
|
|
.value_name("TICKS")
|
|
|
|
.takes_value(true)
|
|
|
|
.default_value(default_ticks_per_slot)
|
|
|
|
.help("The number of ticks in a slot"),
|
|
|
|
)
|
|
|
|
.arg(
|
|
|
|
Arg::with_name("slots_per_epoch")
|
|
|
|
.long("slots-per-epoch")
|
|
|
|
.value_name("SLOTS")
|
|
|
|
.takes_value(true)
|
|
|
|
.default_value(default_slots_per_epoch)
|
|
|
|
.help("The number of slots in an epoch"),
|
|
|
|
)
|
2019-06-06 19:24:09 -07:00
|
|
|
.arg(
|
|
|
|
Arg::with_name("primordial_accounts_file")
|
|
|
|
.long("primordial-accounts-file")
|
|
|
|
.value_name("FILENAME")
|
|
|
|
.takes_value(true)
|
|
|
|
.help("The location of pubkey for primordial accounts and balance"),
|
|
|
|
)
|
2019-06-11 18:47:35 -07:00
|
|
|
.arg(
|
|
|
|
Arg::with_name("primordial_keypairs_file")
|
|
|
|
.long("primordial-keypairs-file")
|
|
|
|
.value_name("FILENAME")
|
|
|
|
.takes_value(true)
|
|
|
|
.help("The location of keypairs for primordial accounts and balance"),
|
|
|
|
)
|
2018-12-07 19:01:28 -08:00
|
|
|
.get_matches();
|
2018-07-12 14:42:01 -07:00
|
|
|
|
2019-01-24 12:04:04 -08:00
|
|
|
let bootstrap_leader_keypair_file = matches.value_of("bootstrap_leader_keypair_file").unwrap();
|
2019-04-10 17:52:47 -07:00
|
|
|
let bootstrap_vote_keypair_file = matches.value_of("bootstrap_vote_keypair_file").unwrap();
|
2019-05-08 12:56:11 -07:00
|
|
|
let bootstrap_stake_keypair_file = matches.value_of("bootstrap_stake_keypair_file").unwrap();
|
2019-05-20 19:46:15 -07:00
|
|
|
let bootstrap_storage_keypair_file =
|
|
|
|
matches.value_of("bootstrap_storage_keypair_file").unwrap();
|
2019-01-24 12:04:04 -08:00
|
|
|
let mint_keypair_file = matches.value_of("mint_keypair_file").unwrap();
|
2019-05-08 12:56:11 -07:00
|
|
|
let ledger_path = matches.value_of("ledger_path").unwrap();
|
2019-03-05 17:01:57 -08:00
|
|
|
let lamports = value_t_or_exit!(matches, "lamports", u64);
|
2019-05-31 19:58:52 -07:00
|
|
|
let bootstrap_leader_lamports = value_t_or_exit!(matches, "bootstrap_leader_lamports", u64);
|
2019-05-08 12:56:11 -07:00
|
|
|
let bootstrap_leader_stake_lamports =
|
2019-05-31 19:58:52 -07:00
|
|
|
value_t_or_exit!(matches, "bootstrap_leader_stake_lamports", u64);
|
2018-07-12 14:42:01 -07:00
|
|
|
|
2019-01-24 12:04:04 -08:00
|
|
|
let bootstrap_leader_keypair = read_keypair(bootstrap_leader_keypair_file)?;
|
2019-04-10 17:52:47 -07:00
|
|
|
let bootstrap_vote_keypair = read_keypair(bootstrap_vote_keypair_file)?;
|
2019-05-08 12:56:11 -07:00
|
|
|
let bootstrap_stake_keypair = read_keypair(bootstrap_stake_keypair_file)?;
|
2019-05-20 19:46:15 -07:00
|
|
|
let bootstrap_storage_keypair = read_keypair(bootstrap_storage_keypair_file)?;
|
2019-01-24 12:04:04 -08:00
|
|
|
let mint_keypair = read_keypair(mint_keypair_file)?;
|
2018-12-12 20:42:12 -08:00
|
|
|
|
2019-05-08 12:56:11 -07:00
|
|
|
let (vote_account, vote_state) = vote_state::create_bootstrap_leader_account(
|
|
|
|
&bootstrap_vote_keypair.pubkey(),
|
|
|
|
&bootstrap_leader_keypair.pubkey(),
|
|
|
|
0,
|
2019-06-03 14:48:01 -07:00
|
|
|
1,
|
2019-05-08 12:56:11 -07:00
|
|
|
);
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
let mut builder = Builder::new()
|
|
|
|
.accounts(&[
|
2019-05-08 12:56:11 -07:00
|
|
|
// the mint
|
2019-05-07 11:16:22 -07:00
|
|
|
(
|
|
|
|
mint_keypair.pubkey(),
|
2019-05-08 12:56:11 -07:00
|
|
|
Account::new(lamports, 0, &system_program::id()),
|
2019-05-07 11:16:22 -07:00
|
|
|
),
|
2019-05-08 12:56:11 -07:00
|
|
|
// node needs an account to issue votes from
|
2019-05-07 11:16:22 -07:00
|
|
|
(
|
2019-05-08 12:56:11 -07:00
|
|
|
bootstrap_leader_keypair.pubkey(),
|
2019-05-31 19:58:52 -07:00
|
|
|
Account::new(bootstrap_leader_lamports, 0, &system_program::id()),
|
2019-05-08 12:56:11 -07:00
|
|
|
),
|
|
|
|
// where votes go to
|
|
|
|
(bootstrap_vote_keypair.pubkey(), vote_account),
|
2019-06-03 14:48:01 -07:00
|
|
|
// passive bootstrap leader stake
|
2019-05-08 12:56:11 -07:00
|
|
|
(
|
|
|
|
bootstrap_stake_keypair.pubkey(),
|
2019-06-10 12:17:29 -07:00
|
|
|
stake_state::create_stake_account(
|
2019-05-07 11:16:22 -07:00
|
|
|
&bootstrap_vote_keypair.pubkey(),
|
2019-05-08 12:56:11 -07:00
|
|
|
&vote_state,
|
|
|
|
bootstrap_leader_stake_lamports,
|
|
|
|
),
|
2019-05-07 11:16:22 -07:00
|
|
|
),
|
2019-06-11 10:27:22 -07:00
|
|
|
(
|
|
|
|
bootstrap_storage_keypair.pubkey(),
|
|
|
|
storage_contract::create_validator_storage_account(
|
|
|
|
bootstrap_leader_keypair.pubkey(),
|
|
|
|
1,
|
|
|
|
),
|
|
|
|
),
|
2019-06-19 15:40:39 -07:00
|
|
|
])
|
|
|
|
.native_instruction_processors(&[
|
2019-06-12 08:49:59 -07:00
|
|
|
solana_bpf_loader_program!(),
|
2019-05-13 14:17:44 -07:00
|
|
|
solana_vote_program!(),
|
|
|
|
solana_stake_program!(),
|
2019-05-14 10:44:16 -07:00
|
|
|
solana_budget_program!(),
|
|
|
|
solana_token_program!(),
|
|
|
|
solana_config_program!(),
|
|
|
|
solana_exchange_program!(),
|
2019-06-11 10:27:22 -07:00
|
|
|
solana_storage_program!(),
|
2019-06-19 15:40:39 -07:00
|
|
|
])
|
|
|
|
.ticks_per_slot(value_t_or_exit!(matches, "ticks_per_slot", u64))
|
|
|
|
.slots_per_epoch(value_t_or_exit!(matches, "slots_per_epoch", u64));
|
2019-06-11 18:47:35 -07:00
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
let mut fee_calculator = FeeCalculator::default();
|
|
|
|
fee_calculator.target_lamports_per_signature =
|
2019-06-10 22:18:32 -07:00
|
|
|
value_t_or_exit!(matches, "target_lamports_per_signature", u64);
|
2019-06-19 15:40:39 -07:00
|
|
|
fee_calculator.target_signatures_per_slot =
|
2019-06-10 22:18:32 -07:00
|
|
|
value_t_or_exit!(matches, "target_signatures_per_slot", usize);
|
2019-06-26 10:13:21 -07:00
|
|
|
builder = builder.fee_calculator(FeeCalculator::new_derived(&fee_calculator, 0));
|
2019-06-10 22:18:32 -07:00
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
let mut poh_config = PohConfig::default();
|
|
|
|
poh_config.target_tick_duration =
|
2019-05-18 14:01:36 -07:00
|
|
|
Duration::from_millis(value_t_or_exit!(matches, "target_tick_duration", u64));
|
|
|
|
|
|
|
|
match matches.value_of("hashes_per_tick").unwrap() {
|
|
|
|
"auto" => {
|
|
|
|
let mut v = Hash::default();
|
|
|
|
println!("Running 1 million hashes...");
|
|
|
|
let start = Instant::now();
|
|
|
|
for _ in 0..1_000_000 {
|
|
|
|
v = hash(&v.as_ref());
|
|
|
|
}
|
|
|
|
let end = Instant::now();
|
|
|
|
let elapsed = end.duration_since(start).as_millis();
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
let hashes_per_tick =
|
|
|
|
(poh_config.target_tick_duration.as_millis() * 1_000_000 / elapsed) as u64;
|
2019-05-18 14:01:36 -07:00
|
|
|
println!("Hashes per tick: {}", hashes_per_tick);
|
2019-06-19 15:40:39 -07:00
|
|
|
poh_config.hashes_per_tick = Some(hashes_per_tick);
|
2019-05-18 14:01:36 -07:00
|
|
|
}
|
|
|
|
"sleep" => {
|
2019-06-19 15:40:39 -07:00
|
|
|
poh_config.hashes_per_tick = None;
|
2019-05-18 14:01:36 -07:00
|
|
|
}
|
|
|
|
_ => {
|
2019-06-19 15:40:39 -07:00
|
|
|
poh_config.hashes_per_tick = Some(value_t_or_exit!(matches, "hashes_per_tick", u64));
|
2019-05-18 14:01:36 -07:00
|
|
|
}
|
|
|
|
}
|
2019-06-26 10:13:21 -07:00
|
|
|
builder = builder.poh_config(poh_config);
|
2019-06-19 15:40:39 -07:00
|
|
|
|
|
|
|
if let Some(file) = matches.value_of("primordial_accounts_file") {
|
|
|
|
builder = append_primordial_accounts(file, AccountFileFormat::Pubkey, builder)?;
|
|
|
|
}
|
2018-08-03 11:06:06 -07:00
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
if let Some(file) = matches.value_of("primordial_keypairs_file") {
|
|
|
|
builder = append_primordial_accounts(file, AccountFileFormat::Keypair, builder)?;
|
|
|
|
}
|
|
|
|
|
2019-06-26 13:51:17 -07:00
|
|
|
// add the reward pools
|
|
|
|
builder = solana_storage_api::rewards_pools::genesis(builder);
|
|
|
|
builder = solana_stake_api::rewards_pools::genesis(builder);
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
create_new_ledger(ledger_path, &builder.build())?;
|
2018-07-01 08:04:41 -07:00
|
|
|
Ok(())
|
2018-03-03 13:41:36 -08:00
|
|
|
}
|
2019-03-12 11:44:41 -07:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2019-06-06 19:24:09 -07:00
|
|
|
use super::*;
|
2019-03-12 11:44:41 -07:00
|
|
|
use hashbrown::HashSet;
|
2019-06-19 15:40:39 -07:00
|
|
|
use solana_sdk::genesis_block::Builder;
|
2019-06-06 19:24:09 -07:00
|
|
|
use solana_sdk::pubkey::Pubkey;
|
2019-06-10 19:42:49 -07:00
|
|
|
use std::collections::HashMap;
|
2019-06-06 19:24:09 -07:00
|
|
|
use std::fs::remove_file;
|
|
|
|
use std::io::Write;
|
|
|
|
use std::path::Path;
|
2019-03-12 11:44:41 -07:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_program_id_uniqueness() {
|
|
|
|
let mut unique = HashSet::new();
|
|
|
|
let ids = vec![
|
|
|
|
solana_sdk::system_program::id(),
|
|
|
|
solana_sdk::native_loader::id(),
|
|
|
|
solana_sdk::bpf_loader::id(),
|
|
|
|
solana_budget_api::id(),
|
|
|
|
solana_storage_api::id(),
|
|
|
|
solana_token_api::id(),
|
|
|
|
solana_vote_api::id(),
|
2019-05-07 11:16:22 -07:00
|
|
|
solana_stake_api::id(),
|
2019-03-14 07:55:41 -07:00
|
|
|
solana_config_api::id(),
|
2019-03-22 21:07:36 -07:00
|
|
|
solana_exchange_api::id(),
|
2019-03-12 11:44:41 -07:00
|
|
|
];
|
|
|
|
assert!(ids.into_iter().all(move |id| unique.insert(id)));
|
|
|
|
}
|
2019-06-06 19:24:09 -07:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_append_primordial_accounts_to_genesis() {
|
|
|
|
// Test invalid file returns error
|
2019-06-11 18:47:35 -07:00
|
|
|
assert!(append_primordial_accounts(
|
|
|
|
"unknownfile",
|
|
|
|
AccountFileFormat::Pubkey,
|
2019-06-19 15:40:39 -07:00
|
|
|
Builder::new()
|
2019-06-11 18:47:35 -07:00
|
|
|
)
|
|
|
|
.is_err());
|
2019-06-06 19:24:09 -07:00
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
let mut builder = Builder::new();
|
|
|
|
|
2019-06-10 19:42:49 -07:00
|
|
|
let mut primordial_accounts = HashMap::new();
|
|
|
|
primordial_accounts.insert(Pubkey::new_rand().to_string(), 2 as u64);
|
|
|
|
primordial_accounts.insert(Pubkey::new_rand().to_string(), 1 as u64);
|
|
|
|
primordial_accounts.insert(Pubkey::new_rand().to_string(), 3 as u64);
|
2019-06-06 19:24:09 -07:00
|
|
|
|
|
|
|
let serialized = serde_yaml::to_string(&primordial_accounts).unwrap();
|
|
|
|
let path = Path::new("test_append_primordial_accounts_to_genesis.yml");
|
|
|
|
let mut file = File::create(path).unwrap();
|
|
|
|
file.write_all(&serialized.into_bytes()).unwrap();
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
builder = append_primordial_accounts(
|
2019-06-06 19:24:09 -07:00
|
|
|
"test_append_primordial_accounts_to_genesis.yml",
|
2019-06-11 18:47:35 -07:00
|
|
|
AccountFileFormat::Pubkey,
|
2019-06-19 15:40:39 -07:00
|
|
|
builder,
|
2019-06-06 19:24:09 -07:00
|
|
|
)
|
2019-06-19 15:40:39 -07:00
|
|
|
.expect("test_append_primordial_accounts_to_genesis.yml");
|
|
|
|
// Test valid file returns ok
|
2019-06-06 19:24:09 -07:00
|
|
|
|
|
|
|
remove_file(path).unwrap();
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
{
|
|
|
|
let genesis_block = builder.clone().build();
|
|
|
|
// Test all accounts were added
|
|
|
|
assert_eq!(genesis_block.accounts.len(), primordial_accounts.len());
|
|
|
|
|
|
|
|
// Test account data matches
|
|
|
|
(0..primordial_accounts.len()).for_each(|i| {
|
|
|
|
assert_eq!(
|
|
|
|
primordial_accounts[&genesis_block.accounts[i].0.to_string()],
|
|
|
|
genesis_block.accounts[i].1.lamports,
|
|
|
|
);
|
|
|
|
});
|
|
|
|
}
|
2019-06-06 19:24:09 -07:00
|
|
|
|
|
|
|
// Test more accounts can be appended
|
2019-06-10 19:42:49 -07:00
|
|
|
let mut primordial_accounts1 = HashMap::new();
|
|
|
|
primordial_accounts1.insert(Pubkey::new_rand().to_string(), 6 as u64);
|
|
|
|
primordial_accounts1.insert(Pubkey::new_rand().to_string(), 5 as u64);
|
|
|
|
primordial_accounts1.insert(Pubkey::new_rand().to_string(), 10 as u64);
|
2019-06-06 19:24:09 -07:00
|
|
|
|
|
|
|
let serialized = serde_yaml::to_string(&primordial_accounts1).unwrap();
|
|
|
|
let path = Path::new("test_append_primordial_accounts_to_genesis.yml");
|
|
|
|
let mut file = File::create(path).unwrap();
|
|
|
|
file.write_all(&serialized.into_bytes()).unwrap();
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
builder = append_primordial_accounts(
|
2019-06-06 19:24:09 -07:00
|
|
|
"test_append_primordial_accounts_to_genesis.yml",
|
2019-06-11 18:47:35 -07:00
|
|
|
AccountFileFormat::Pubkey,
|
2019-06-19 15:40:39 -07:00
|
|
|
builder,
|
2019-06-06 19:24:09 -07:00
|
|
|
)
|
2019-06-19 15:40:39 -07:00
|
|
|
.expect("test_append_primordial_accounts_to_genesis.yml");
|
2019-06-06 19:24:09 -07:00
|
|
|
|
|
|
|
remove_file(path).unwrap();
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
let genesis_block = builder.clone().build();
|
2019-06-06 19:24:09 -07:00
|
|
|
// Test total number of accounts is correct
|
|
|
|
assert_eq!(
|
|
|
|
genesis_block.accounts.len(),
|
|
|
|
primordial_accounts.len() + primordial_accounts1.len()
|
|
|
|
);
|
|
|
|
|
|
|
|
// Test old accounts are still there
|
|
|
|
(0..primordial_accounts.len()).for_each(|i| {
|
|
|
|
assert_eq!(
|
2019-06-10 19:42:49 -07:00
|
|
|
primordial_accounts[&genesis_block.accounts[i].0.to_string()],
|
2019-06-06 19:24:09 -07:00
|
|
|
genesis_block.accounts[i].1.lamports,
|
|
|
|
);
|
|
|
|
});
|
|
|
|
|
|
|
|
// Test new account data matches
|
|
|
|
(0..primordial_accounts1.len()).for_each(|i| {
|
|
|
|
assert_eq!(
|
2019-06-10 19:42:49 -07:00
|
|
|
primordial_accounts1[&genesis_block.accounts[primordial_accounts.len() + i]
|
|
|
|
.0
|
|
|
|
.to_string()],
|
2019-06-06 19:24:09 -07:00
|
|
|
genesis_block.accounts[primordial_accounts.len() + i]
|
|
|
|
.1
|
|
|
|
.lamports,
|
|
|
|
);
|
|
|
|
});
|
2019-06-11 18:47:35 -07:00
|
|
|
|
|
|
|
// Test accounts from keypairs can be appended
|
|
|
|
let account_keypairs: Vec<_> = (0..3).map(|_| Keypair::new()).collect();
|
|
|
|
let mut primordial_accounts2 = HashMap::new();
|
|
|
|
primordial_accounts2.insert(
|
|
|
|
serde_json::to_string(&account_keypairs[0].to_bytes().to_vec()).unwrap(),
|
|
|
|
20 as u64,
|
|
|
|
);
|
|
|
|
primordial_accounts2.insert(
|
|
|
|
serde_json::to_string(&account_keypairs[1].to_bytes().to_vec()).unwrap(),
|
|
|
|
15 as u64,
|
|
|
|
);
|
|
|
|
primordial_accounts2.insert(
|
|
|
|
serde_json::to_string(&account_keypairs[2].to_bytes().to_vec()).unwrap(),
|
|
|
|
30 as u64,
|
|
|
|
);
|
|
|
|
|
|
|
|
let serialized = serde_yaml::to_string(&primordial_accounts2).unwrap();
|
|
|
|
let path = Path::new("test_append_primordial_accounts_to_genesis.yml");
|
|
|
|
let mut file = File::create(path).unwrap();
|
|
|
|
file.write_all(&serialized.into_bytes()).unwrap();
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
builder = append_primordial_accounts(
|
2019-06-11 18:47:35 -07:00
|
|
|
"test_append_primordial_accounts_to_genesis.yml",
|
|
|
|
AccountFileFormat::Keypair,
|
2019-06-19 15:40:39 -07:00
|
|
|
builder,
|
2019-06-11 18:47:35 -07:00
|
|
|
)
|
2019-06-19 15:40:39 -07:00
|
|
|
.expect("builder");
|
2019-06-11 18:47:35 -07:00
|
|
|
|
2019-06-22 17:18:35 -07:00
|
|
|
builder = solana_storage_api::rewards_pools::genesis(builder);
|
|
|
|
|
2019-06-11 18:47:35 -07:00
|
|
|
remove_file(path).unwrap();
|
|
|
|
|
2019-06-19 15:40:39 -07:00
|
|
|
let genesis_block = builder.clone().build();
|
2019-06-11 18:47:35 -07:00
|
|
|
// Test total number of accounts is correct
|
|
|
|
assert_eq!(
|
|
|
|
genesis_block.accounts.len(),
|
|
|
|
primordial_accounts.len() + primordial_accounts1.len() + primordial_accounts2.len()
|
|
|
|
);
|
|
|
|
|
|
|
|
// Test old accounts are still there
|
|
|
|
(0..primordial_accounts.len()).for_each(|i| {
|
|
|
|
assert_eq!(
|
|
|
|
primordial_accounts[&genesis_block.accounts[i].0.to_string()],
|
|
|
|
genesis_block.accounts[i].1.lamports,
|
|
|
|
);
|
|
|
|
});
|
|
|
|
|
|
|
|
// Test new account data matches
|
|
|
|
(0..primordial_accounts1.len()).for_each(|i| {
|
|
|
|
assert_eq!(
|
|
|
|
primordial_accounts1[&genesis_block.accounts[primordial_accounts.len() + i]
|
|
|
|
.0
|
|
|
|
.to_string()],
|
|
|
|
genesis_block.accounts[primordial_accounts.len() + i]
|
|
|
|
.1
|
|
|
|
.lamports,
|
|
|
|
);
|
|
|
|
});
|
|
|
|
|
|
|
|
let offset = primordial_accounts.len() + primordial_accounts1.len();
|
|
|
|
// Test account data for keypairs matches
|
|
|
|
account_keypairs.iter().for_each(|keypair| {
|
|
|
|
let mut i = 0;
|
|
|
|
(offset..(offset + account_keypairs.len())).for_each(|n| {
|
|
|
|
if keypair.pubkey() == genesis_block.accounts[n].0 {
|
|
|
|
i = n;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
assert_ne!(i, 0);
|
|
|
|
assert_eq!(
|
|
|
|
primordial_accounts2[&serde_json::to_string(&keypair.to_bytes().to_vec()).unwrap()],
|
|
|
|
genesis_block.accounts[i].1.lamports,
|
|
|
|
);
|
|
|
|
});
|
2019-06-06 19:24:09 -07:00
|
|
|
}
|
2019-03-12 11:44:41 -07:00
|
|
|
}
|