|
|
@@ -1,680 +0,0 @@
|
|
|
-pub mod mining;
|
|
|
-
|
|
|
-use std::error::Error;
|
|
|
-use std::fs;
|
|
|
-use std::path::Path;
|
|
|
-
|
|
|
-use clap::{arg, command, ArgAction, Parser};
|
|
|
-use libp2p::identity::Keypair;
|
|
|
-use libp2p::multiaddr::Multiaddr;
|
|
|
-use libp2p::{allow_block_list, connection_limits, memory_connection_limits, PeerId};
|
|
|
-use nockapp::driver::Operation;
|
|
|
-use nockapp::kernel::boot;
|
|
|
-use nockapp::wire::Wire;
|
|
|
-use nockapp::{one_punch_driver, NockApp, NounExt};
|
|
|
-use nockchain_bitcoin_sync::{bitcoin_watcher_driver, BitcoinRPCConnection, GenesisNodeType};
|
|
|
-use nockchain_libp2p_io::p2p::{
|
|
|
- MAX_ESTABLISHED_CONNECTIONS, MAX_ESTABLISHED_CONNECTIONS_PER_PEER,
|
|
|
- MAX_ESTABLISHED_INCOMING_CONNECTIONS, MAX_ESTABLISHED_OUTGOING_CONNECTIONS,
|
|
|
- MAX_PENDING_INCOMING_CONNECTIONS, MAX_PENDING_OUTGOING_CONNECTIONS,
|
|
|
-};
|
|
|
-use termcolor::{ColorChoice, StandardStream};
|
|
|
-use tokio::net::UnixListener;
|
|
|
-pub mod colors;
|
|
|
-use std::path::PathBuf;
|
|
|
-
|
|
|
-use clap::value_parser;
|
|
|
-use colors::*;
|
|
|
-use nockapp::noun::slab::NounSlab;
|
|
|
-use nockvm::jets::hot::HotEntry;
|
|
|
-use nockvm::noun::{D, T};
|
|
|
-use nockvm_macros::tas;
|
|
|
-use tracing::{debug, info, instrument};
|
|
|
-
|
|
|
-use crate::mining::MiningKeyConfig;
|
|
|
-
|
|
|
-/// Module for handling driver initialization signals
|
|
|
-pub mod driver_init {
|
|
|
- use nockapp::driver::{make_driver, IODriverFn, PokeResult};
|
|
|
- use nockapp::noun::slab::NounSlab;
|
|
|
- use nockapp::wire::{SystemWire, Wire};
|
|
|
- use nockvm::noun::{D, T};
|
|
|
- use nockvm_macros::tas;
|
|
|
- use tokio::sync::oneshot;
|
|
|
- use tracing::{debug, error, info};
|
|
|
-
|
|
|
- /// A collection of initialization signals for drivers
|
|
|
- #[derive(Default)]
|
|
|
- pub struct DriverInitSignals {
|
|
|
- /// Sender for the born signal
|
|
|
- pub born_tx: Option<oneshot::Sender<()>>,
|
|
|
- /// Receiver for the born signal
|
|
|
- pub born_rx: Option<oneshot::Receiver<()>>,
|
|
|
- /// Map of driver names to their initialization signal senders
|
|
|
- pub driver_signals: std::collections::HashMap<String, oneshot::Receiver<()>>,
|
|
|
- }
|
|
|
-
|
|
|
- impl DriverInitSignals {
|
|
|
- /// Create a new DriverInitSignals instance
|
|
|
- pub fn new() -> Self {
|
|
|
- let (born_tx, born_rx) = oneshot::channel();
|
|
|
- Self {
|
|
|
- born_tx: Some(born_tx),
|
|
|
- born_rx: Some(born_rx),
|
|
|
- driver_signals: std::collections::HashMap::new(),
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// Register a driver with an initialization signal
|
|
|
- pub fn register_driver(&mut self, name: &str) -> oneshot::Sender<()> {
|
|
|
- let (tx, rx) = oneshot::channel();
|
|
|
- self.driver_signals.insert(name.to_string(), rx);
|
|
|
- tx
|
|
|
- }
|
|
|
-
|
|
|
- /// Get the initialization signal sender for a driver
|
|
|
- pub fn get_signal_sender(&self, name: &str) -> Option<&oneshot::Receiver<()>> {
|
|
|
- self.driver_signals.get(name)
|
|
|
- }
|
|
|
-
|
|
|
- /// Create a task that waits for all registered drivers to initialize
|
|
|
- pub fn create_born_task(&mut self) -> tokio::task::JoinHandle<()> {
|
|
|
- let born_tx = self.born_tx.take().expect("Born signal already used");
|
|
|
- let driver_signals = std::mem::take(&mut self.driver_signals);
|
|
|
-
|
|
|
- tokio::spawn(async move {
|
|
|
- // Wait for all registered drivers to initialize concurrently
|
|
|
- let mut join_set = tokio::task::JoinSet::new();
|
|
|
- for (name, rx) in driver_signals {
|
|
|
- let name = name.clone();
|
|
|
- join_set.spawn(async move {
|
|
|
- let _ = rx.await;
|
|
|
- info!("driver '{}' initialized", name);
|
|
|
- });
|
|
|
- }
|
|
|
-
|
|
|
- // Wait for all tasks to complete
|
|
|
- while let Some(result) = join_set.join_next().await {
|
|
|
- result.expect("Task panicked");
|
|
|
- }
|
|
|
-
|
|
|
- // Send the born poke signal
|
|
|
- let _ = born_tx.send(());
|
|
|
- info!("all drivers initialized, born poke sent");
|
|
|
- })
|
|
|
- }
|
|
|
-
|
|
|
- /// Create the born driver that waits for the born signal
|
|
|
- pub fn create_born_driver(&mut self) -> IODriverFn {
|
|
|
- let born_rx = self.born_rx.take().expect("born signal already used");
|
|
|
-
|
|
|
- make_driver(move |handle| {
|
|
|
- Box::pin(async move {
|
|
|
- // Wait for the born signal
|
|
|
- let _ = born_rx.await;
|
|
|
-
|
|
|
- // Send the born poke
|
|
|
- let mut born_slab = NounSlab::new();
|
|
|
- let born = T(
|
|
|
- &mut born_slab,
|
|
|
- &[D(tas!(b"command")), D(tas!(b"born")), D(0)],
|
|
|
- );
|
|
|
- born_slab.set_root(born);
|
|
|
- let wire = SystemWire.to_wire();
|
|
|
- let result = handle.poke(wire, born_slab).await?;
|
|
|
-
|
|
|
- match result {
|
|
|
- PokeResult::Ack => debug!("born poke acknowledged"),
|
|
|
- PokeResult::Nack => error!("Born poke nacked"),
|
|
|
- }
|
|
|
-
|
|
|
- Ok(())
|
|
|
- })
|
|
|
- })
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-// TODO: command-line/configure
|
|
|
-/** Path to read current node's identity from */
|
|
|
-pub const IDENTITY_PATH: &str = ".nockchain_identity";
|
|
|
-
|
|
|
-/** Path to read current node's peer ID from */
|
|
|
-pub const PEER_ID_EXTENSION: &str = ".peer_id";
|
|
|
-
|
|
|
-// TODO: command-line/configure
|
|
|
-/** Extension for peer ID files */
|
|
|
-const PEER_ID_FILE_EXTENSION: &str = "peerid";
|
|
|
-
|
|
|
-// Libp2p multiaddrs don't support const construction, so we have to put strings literals and parse them at startup
|
|
|
-/** Backbone nodes for our testnet */
|
|
|
-const TESTNET_BACKBONE_NODES: &[&str] = &[];
|
|
|
-
|
|
|
-// Libp2p multiaddrs don't support const construction, so we have to put strings literals and parse them at startup
|
|
|
-// TODO: feature flag testnet/realnet
|
|
|
-/** Backbone nodes for our realnet */
|
|
|
-#[allow(dead_code)]
|
|
|
-const REALNET_BACKBONE_NODES: &[&str] = &[
|
|
|
- "/dnsaddr/nockchain-backbone.zorp.io",
|
|
|
- "/ip4/34.35.75.234/udp/30000/quic-v1",
|
|
|
- "/ip4/34.176.41.23/udp/30000/quic-v1",
|
|
|
- "/ip4/34.16.237.144/udp/30000/quic-v1",
|
|
|
- "/ip4/34.85.34.153/udp/30000/quic-v1",
|
|
|
- "/ip4/34.95.155.151/udp/30000/quic-v1",
|
|
|
- "/ip4/34.97.242.48/udp/30000/quic-v1",
|
|
|
- "/ip4/34.162.206.28/udp/30000/quic-v1",
|
|
|
- "/ip4/34.174.22.166/udp/30000/quic-v1",
|
|
|
- "/ip4/34.129.248.106/udp/30000/quic-v1",
|
|
|
- "/ip4/34.18.98.38/udp/30000/quic-v1"
|
|
|
-];
|
|
|
-
|
|
|
-/** How often we should affirmatively ask other nodes for their heaviest chain */
|
|
|
-const CHAIN_INTERVAL_SECS: u64 = 20;
|
|
|
-
|
|
|
-/// The height of the bitcoin block that we want to sync our genesis block to
|
|
|
-/// Currently, this is the height of an existing block for testing. It will be
|
|
|
-/// switched to a future block for launch.
|
|
|
-const GENESIS_HEIGHT: u64 = 897767;
|
|
|
-
|
|
|
-/// Command line arguments
|
|
|
-#[derive(Parser, Debug, Clone)]
|
|
|
-#[command(name = "nockchain")]
|
|
|
-pub struct NockchainCli {
|
|
|
- #[command(flatten)]
|
|
|
- pub nockapp_cli: nockapp::kernel::boot::Cli,
|
|
|
- #[arg(
|
|
|
- long,
|
|
|
- help = "npc socket path",
|
|
|
- default_value = ".socket/nockchain_npc.sock"
|
|
|
- )]
|
|
|
- pub npc_socket: String,
|
|
|
- #[arg(long, help = "Mine in-kernel", default_value = "false")]
|
|
|
- pub mine: bool,
|
|
|
- #[arg(
|
|
|
- long,
|
|
|
- help = "Pubkey to mine to (mutually exclusive with --mining-key-adv)"
|
|
|
- )]
|
|
|
- pub mining_pubkey: Option<String>,
|
|
|
- #[arg(
|
|
|
- long,
|
|
|
- help = "Advanced mining key configuration (mutually exclusive with --mining-pubkey). Format: share,m:key1,key2,key3",
|
|
|
- value_parser = value_parser!(MiningKeyConfig),
|
|
|
- num_args = 1..,
|
|
|
- value_delimiter = ',',
|
|
|
- )]
|
|
|
- pub mining_key_adv: Option<Vec<MiningKeyConfig>>,
|
|
|
- #[arg(long, help = "Watch for genesis block", default_value = "false")]
|
|
|
- pub genesis_watcher: bool,
|
|
|
- #[arg(long, help = "Mine genesis block", default_value = "false")]
|
|
|
- pub genesis_leader: bool,
|
|
|
- #[arg(long, help = "use fake genesis block", default_value = "false")]
|
|
|
- pub fakenet: bool,
|
|
|
- #[arg(long, help = "Genesis block message", default_value = "Hail Zorp")]
|
|
|
- pub genesis_message: String,
|
|
|
- #[arg(
|
|
|
- long,
|
|
|
- help = "URL for Bitcoin Core RPC",
|
|
|
- default_value = "http://100.98.183.39:8332"
|
|
|
- )]
|
|
|
- pub btc_node_url: String,
|
|
|
- #[arg(long, help = "Username for Bitcoin Core RPC")]
|
|
|
- pub btc_username: Option<String>,
|
|
|
- #[arg(long, help = "Password for Bitcoin Core RPC")]
|
|
|
- pub btc_password: Option<String>,
|
|
|
- #[arg(long, help = "Auth cookie path for Bitcoin Core RPC")]
|
|
|
- pub btc_auth_cookie: Option<String>,
|
|
|
- #[arg(long, short, help = "Initial peer", action = ArgAction::Append)]
|
|
|
- pub peer: Vec<String>,
|
|
|
- #[arg(long, help = "Allowed peer IDs file")]
|
|
|
- pub allowed_peers_path: Option<String>,
|
|
|
- #[arg(long, help = "Don't dial default peers")]
|
|
|
- pub no_default_peers: bool,
|
|
|
- #[arg(long, help = "Bind address", action = ArgAction::Append)]
|
|
|
- pub bind: Vec<String>,
|
|
|
- #[arg(
|
|
|
- long,
|
|
|
- help = "Generate a new peer ID, discarding the existing one",
|
|
|
- default_value = "false"
|
|
|
- )]
|
|
|
- pub new_peer_id: bool,
|
|
|
- #[arg(long, help = "Maximum established incoming connections")]
|
|
|
- pub max_established_incoming: Option<u32>,
|
|
|
- #[arg(long, help = "Maximum established outgoing connections")]
|
|
|
- pub max_established_outgoing: Option<u32>,
|
|
|
- #[arg(long, help = "Maximum pending incoming connections")]
|
|
|
- pub max_pending_incoming: Option<u32>,
|
|
|
- #[arg(long, help = "Maximum pending outgoing connections")]
|
|
|
- pub max_pending_outgoing: Option<u32>,
|
|
|
- #[arg(long, help = "Maximum established connections")]
|
|
|
- pub max_established: Option<u32>,
|
|
|
- #[arg(long, help = "Maximum established connections per peer")]
|
|
|
- pub max_established_per_peer: Option<u32>,
|
|
|
- #[arg(long, help = "Maximum system memory percentage for connection limits")]
|
|
|
- pub max_system_memory_fraction: Option<f64>,
|
|
|
- #[arg(long, help = "Maximum process memory for connection limits (bytes)")]
|
|
|
- pub max_system_memory_bytes: Option<usize>,
|
|
|
-}
|
|
|
-
|
|
|
-impl NockchainCli {
|
|
|
- pub fn validate(&self) -> Result<(), String> {
|
|
|
- if self.mine && !(self.mining_pubkey.is_some() || self.mining_key_adv.is_some()) {
|
|
|
- return Err(
|
|
|
- "Cannot specify mine without either mining_pubkey or mining_key_adv".to_string(),
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- if self.mining_pubkey.is_some() && self.mining_key_adv.is_some() {
|
|
|
- return Err(
|
|
|
- "Cannot specify both mining_pubkey and mining_key_adv at the same time".to_string(),
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- if self.genesis_leader && self.genesis_watcher {
|
|
|
- return Err(
|
|
|
- "Cannot specify both genesis_leader and genesis_watcher at the same time"
|
|
|
- .to_string(),
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- if !self.fakenet && (self.genesis_watcher || self.genesis_leader) {
|
|
|
- if self.btc_node_url.is_empty() {
|
|
|
- return Err(
|
|
|
- "Must specify --btc-node-url when using genesis_watcher or genesis_leader"
|
|
|
- .to_string(),
|
|
|
- );
|
|
|
- }
|
|
|
- if self.btc_auth_cookie.is_none() {
|
|
|
- if self.btc_username.is_none() && self.btc_password.is_none() {
|
|
|
- return Err("Must specify either --btc-username or --btc-password when using genesis_watcher or genesis_leader on livenet".to_string());
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- Ok(())
|
|
|
- }
|
|
|
-
|
|
|
- /// Helper function to create a BitcoinRPCConnection from CLI arguments
|
|
|
- fn create_bitcoin_connection(&self) -> BitcoinRPCConnection {
|
|
|
- let url = self.btc_node_url.clone();
|
|
|
- let height = GENESIS_HEIGHT;
|
|
|
- let auth = if let Some(username) = self.btc_username.clone() {
|
|
|
- let password = self.btc_password.clone().unwrap_or_else(|| {
|
|
|
- panic!(
|
|
|
- "Panicked at {}:{} (git sha: {:?})",
|
|
|
- file!(),
|
|
|
- line!(),
|
|
|
- option_env!("GIT_SHA")
|
|
|
- )
|
|
|
- });
|
|
|
- bitcoincore_rpc::Auth::UserPass(username, password)
|
|
|
- } else {
|
|
|
- let cookie_path_str = self.btc_auth_cookie.clone().unwrap_or_else(|| {
|
|
|
- panic!(
|
|
|
- "Panicked at {}:{} (git sha: {:?})",
|
|
|
- file!(),
|
|
|
- line!(),
|
|
|
- option_env!("GIT_SHA")
|
|
|
- )
|
|
|
- });
|
|
|
- let cookie_path = PathBuf::from(cookie_path_str);
|
|
|
- bitcoincore_rpc::Auth::CookieFile(cookie_path)
|
|
|
- };
|
|
|
- BitcoinRPCConnection::new(url, auth, height)
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-/// # Load a keypair from a file or create a new one if the file doesn't exist
|
|
|
-///
|
|
|
-/// This function attempts to read a keypair from a specified file. If the file exists, it reads the keypair from the file.
|
|
|
-/// If the file does not exist, it generates a new keypair, writes it to the file, and returns it.
|
|
|
-///
|
|
|
-/// # Arguments
|
|
|
-/// * `keypair_path` - A reference to a Path object representing the file path where the keypair should be stored
|
|
|
-/// * `force_new` - If true, generate a new keypair even if one already exists
|
|
|
-///
|
|
|
-/// # Returns
|
|
|
-/// A Result containing the Keypair or an error if any operation fails
|
|
|
-pub fn gen_keypair(keypair_path: &Path) -> Result<Keypair, Box<dyn Error>> {
|
|
|
- let new_keypair = libp2p::identity::Keypair::generate_ed25519();
|
|
|
- let new_keypair_bytes = new_keypair.to_protobuf_encoding()?;
|
|
|
- std::fs::write(keypair_path, new_keypair_bytes)?;
|
|
|
- let peer_id = new_keypair.public().to_peer_id();
|
|
|
- // write the peer_id encoded as base58 to a file
|
|
|
- std::fs::write(
|
|
|
- keypair_path.with_extension(PEER_ID_FILE_EXTENSION),
|
|
|
- peer_id.to_base58(),
|
|
|
- )?;
|
|
|
- info!("Generated new identity as peer {peer_id}");
|
|
|
- Ok(new_keypair)
|
|
|
-}
|
|
|
-
|
|
|
-fn load_keypair(keypair_path: &Path, force_new: bool) -> Result<Keypair, Box<dyn Error>> {
|
|
|
- if keypair_path.try_exists()? && !force_new {
|
|
|
- let keypair_bytes = std::fs::read(keypair_path)?;
|
|
|
- let keypair = libp2p::identity::Keypair::from_protobuf_encoding(&keypair_bytes[..])?;
|
|
|
- let peer_id = keypair.public().to_peer_id();
|
|
|
- info!("Loaded identity as peer {peer_id}");
|
|
|
- Ok(keypair)
|
|
|
- } else {
|
|
|
- if force_new && keypair_path.try_exists()? {
|
|
|
- info!("Discarding existing peer ID and generating a new one");
|
|
|
- std::fs::remove_file(keypair_path)?;
|
|
|
- }
|
|
|
- gen_keypair(keypair_path)
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-#[instrument(skip(kernel_jam, hot_state))]
|
|
|
-pub async fn init_with_kernel(
|
|
|
- cli: Option<NockchainCli>,
|
|
|
- kernel_jam: &[u8],
|
|
|
- hot_state: &[HotEntry],
|
|
|
-) -> Result<NockApp, Box<dyn Error>> {
|
|
|
- welcome();
|
|
|
-
|
|
|
- if let Some(cli) = &cli {
|
|
|
- cli.validate()?;
|
|
|
- }
|
|
|
-
|
|
|
- let mut nockapp = boot::setup(
|
|
|
- kernel_jam,
|
|
|
- cli.as_ref().map(|c| c.nockapp_cli.clone()),
|
|
|
- hot_state,
|
|
|
- "nockchain",
|
|
|
- None,
|
|
|
- )
|
|
|
- .await?;
|
|
|
-
|
|
|
- let keypair = {
|
|
|
- let keypair_path = Path::new(IDENTITY_PATH);
|
|
|
- load_keypair(
|
|
|
- keypair_path,
|
|
|
- cli.as_ref().map(|c| c.new_peer_id).unwrap_or(false),
|
|
|
- )?
|
|
|
- };
|
|
|
- eprintln!(
|
|
|
- "allowed_peers_path: {:?}",
|
|
|
- cli.as_ref().unwrap().allowed_peers_path
|
|
|
- );
|
|
|
- let allowed = cli.as_ref().and_then(|c| {
|
|
|
- c.allowed_peers_path.as_ref().map(|path| {
|
|
|
- let contents = fs::read_to_string(path).expect("failed to read allowed peers file: {}");
|
|
|
- let peer_ids: Vec<PeerId> = contents
|
|
|
- .lines()
|
|
|
- .map(|line| {
|
|
|
- let peer_id_bytes = bs58::decode(line)
|
|
|
- .into_vec()
|
|
|
- .expect("failed to decode peer ID bytes from base58");
|
|
|
- PeerId::from_bytes(&peer_id_bytes).expect("failed to decode peer ID from bytes")
|
|
|
- })
|
|
|
- .collect();
|
|
|
- let mut allow_behavior =
|
|
|
- allow_block_list::Behaviour::<allow_block_list::AllowedPeers>::default();
|
|
|
- for peer_id in peer_ids {
|
|
|
- allow_behavior.allow_peer(peer_id);
|
|
|
- }
|
|
|
- allow_behavior
|
|
|
- })
|
|
|
- });
|
|
|
-
|
|
|
- let bind_multiaddrs = cli
|
|
|
- .as_ref()
|
|
|
- .map_or(vec!["/ip4/0.0.0.0/udp/0/quic-v1".parse()?], |c| {
|
|
|
- c.bind
|
|
|
- .clone()
|
|
|
- .into_iter()
|
|
|
- .map(|addr_str| addr_str.parse().expect("could not parse bind multiaddr"))
|
|
|
- .collect()
|
|
|
- });
|
|
|
-
|
|
|
- let limits = connection_limits::ConnectionLimits::default()
|
|
|
- .with_max_established_incoming(
|
|
|
- cli.as_ref()
|
|
|
- .and_then(|c| c.max_established_incoming)
|
|
|
- .and(Some(MAX_ESTABLISHED_INCOMING_CONNECTIONS)),
|
|
|
- )
|
|
|
- .with_max_established_outgoing(
|
|
|
- cli.as_ref()
|
|
|
- .and_then(|c| c.max_established_outgoing)
|
|
|
- .and(Some(MAX_ESTABLISHED_OUTGOING_CONNECTIONS)),
|
|
|
- )
|
|
|
- .with_max_pending_incoming(
|
|
|
- cli.as_ref()
|
|
|
- .and_then(|c| c.max_pending_incoming)
|
|
|
- .and(Some(MAX_PENDING_INCOMING_CONNECTIONS)),
|
|
|
- )
|
|
|
- .with_max_pending_outgoing(
|
|
|
- cli.as_ref()
|
|
|
- .and_then(|c| c.max_pending_outgoing)
|
|
|
- .and(Some(MAX_PENDING_OUTGOING_CONNECTIONS)),
|
|
|
- )
|
|
|
- .with_max_established(
|
|
|
- cli.as_ref()
|
|
|
- .and_then(|c| c.max_established)
|
|
|
- .and(Some(MAX_ESTABLISHED_CONNECTIONS)),
|
|
|
- )
|
|
|
- .with_max_established_per_peer(
|
|
|
- cli.as_ref()
|
|
|
- .and_then(|c| c.max_established_per_peer)
|
|
|
- .and(Some(MAX_ESTABLISHED_CONNECTIONS_PER_PEER)),
|
|
|
- );
|
|
|
- let memory_limits = cli.as_ref().and_then(|c| {
|
|
|
- if c.max_system_memory_bytes.is_some() && c.max_system_memory_fraction.is_some() { panic!( "Must provide neither or one of --max-system-memory_bytes or --max-system-memory_percentage" )};
|
|
|
- if let Some(max_bytes) = c.max_system_memory_bytes {
|
|
|
- Some(memory_connection_limits::Behaviour::with_max_bytes(max_bytes))
|
|
|
- } else { c.max_system_memory_fraction.map(memory_connection_limits::Behaviour::with_max_percentage) }
|
|
|
- });
|
|
|
-
|
|
|
- let default_backbone_peers = if cli.as_ref().map(|c| c.fakenet).unwrap_or(false) {
|
|
|
- TESTNET_BACKBONE_NODES
|
|
|
- } else {
|
|
|
- REALNET_BACKBONE_NODES
|
|
|
- };
|
|
|
-
|
|
|
- let backbone_peers = default_backbone_peers
|
|
|
- .iter()
|
|
|
- .map(|multiaddr_str| {
|
|
|
- multiaddr_str
|
|
|
- .parse()
|
|
|
- .expect("could not parse multiaddr from built-in string")
|
|
|
- })
|
|
|
- .collect();
|
|
|
-
|
|
|
- // Set up initial peer addresses to connect to
|
|
|
- let mut peer_multiaddrs: Vec<Multiaddr> = if cli.as_ref().is_some_and(|c| c.no_default_peers) {
|
|
|
- Vec::new()
|
|
|
- } else {
|
|
|
- backbone_peers
|
|
|
- };
|
|
|
-
|
|
|
- if let Some(c) = cli.as_ref() {
|
|
|
- let v: Vec<Multiaddr> = c
|
|
|
- .peer
|
|
|
- .clone()
|
|
|
- .into_iter()
|
|
|
- .map(|multiaddr_str| {
|
|
|
- multiaddr_str
|
|
|
- .parse()
|
|
|
- .expect("could not parse multiaddr from string")
|
|
|
- })
|
|
|
- .collect();
|
|
|
- peer_multiaddrs.extend(v);
|
|
|
- }
|
|
|
-
|
|
|
- debug!("peer_multiaddrs: {:?}", peer_multiaddrs);
|
|
|
-
|
|
|
- let equix_builder = equix::EquiXBuilder::new();
|
|
|
-
|
|
|
- // Create driver initialization signals. the idea here is that we want to wait for
|
|
|
- // drivers that emit init pokes to complete before we send the born poke.
|
|
|
- let mut driver_signals = driver_init::DriverInitSignals::new();
|
|
|
-
|
|
|
- // Register drivers that need initialization signals
|
|
|
- let mining_init_tx = driver_signals.register_driver("mining");
|
|
|
- let libp2p_init_tx = driver_signals.register_driver("libp2p");
|
|
|
- let watcher_init_tx = driver_signals.register_driver("bitcoin_watcher");
|
|
|
-
|
|
|
- // Create the born task that waits for all drivers to initialize
|
|
|
- let _born_task = driver_signals.create_born_task();
|
|
|
-
|
|
|
- if cli.as_ref().map(|c| c.fakenet).unwrap_or(false) {
|
|
|
- let message = cli
|
|
|
- .as_ref()
|
|
|
- .map(|c| c.genesis_message.clone())
|
|
|
- .unwrap_or("".to_string());
|
|
|
- let node_type = if cli.as_ref().map(|c| c.genesis_leader).unwrap_or(false) {
|
|
|
- GenesisNodeType::Leader
|
|
|
- } else {
|
|
|
- GenesisNodeType::Watcher
|
|
|
- };
|
|
|
- let watcher_driver =
|
|
|
- bitcoin_watcher_driver(None, node_type, message, Some(watcher_init_tx));
|
|
|
- nockapp.add_io_driver(watcher_driver).await;
|
|
|
- } else if cli
|
|
|
- .as_ref()
|
|
|
- .map(|c| c.genesis_watcher || c.genesis_leader)
|
|
|
- .unwrap_or(false)
|
|
|
- {
|
|
|
- let message = cli
|
|
|
- .as_ref()
|
|
|
- .map(|c| c.genesis_message.clone())
|
|
|
- .unwrap_or("".to_string());
|
|
|
- let connection = cli.as_ref().unwrap().create_bitcoin_connection();
|
|
|
- let node_type = if cli.as_ref().map(|c| c.genesis_leader).unwrap_or(false) {
|
|
|
- GenesisNodeType::Leader
|
|
|
- } else {
|
|
|
- GenesisNodeType::Watcher
|
|
|
- };
|
|
|
- let watcher_driver =
|
|
|
- bitcoin_watcher_driver(Some(connection), node_type, message, Some(watcher_init_tx));
|
|
|
- nockapp.add_io_driver(watcher_driver).await;
|
|
|
- } else {
|
|
|
- // Realnet with no BTC node
|
|
|
- let mut poke_slab = NounSlab::new();
|
|
|
- let poke_noun = T(
|
|
|
- &mut poke_slab,
|
|
|
- &[D(tas!(b"command")), D(tas!(b"btc-data")), D(0)],
|
|
|
- );
|
|
|
- poke_slab.set_root(poke_noun);
|
|
|
- nockapp
|
|
|
- .poke(nockapp::wire::SystemWire.to_wire(), poke_slab)
|
|
|
- .await
|
|
|
- .expect("Failed to poke for no BTC hash");
|
|
|
- }
|
|
|
-
|
|
|
- let mining_config = cli.as_ref().and_then(|c| {
|
|
|
- if let Some(pubkey) = &c.mining_pubkey {
|
|
|
- Some(vec![MiningKeyConfig {
|
|
|
- share: 1,
|
|
|
- m: 1,
|
|
|
- keys: vec![pubkey.clone()],
|
|
|
- }])
|
|
|
- } else if let Some(mining_key_adv) = &c.mining_key_adv {
|
|
|
- Some(mining_key_adv.clone())
|
|
|
- } else {
|
|
|
- None
|
|
|
- }
|
|
|
- });
|
|
|
-
|
|
|
- let mine = cli.as_ref().map_or(false, |c| c.mine);
|
|
|
-
|
|
|
- let mining_driver =
|
|
|
- crate::mining::create_mining_driver(mining_config, mine, Some(mining_init_tx));
|
|
|
- nockapp.add_io_driver(mining_driver).await;
|
|
|
-
|
|
|
- let libp2p_driver = nockchain_libp2p_io::nc::make_libp2p_driver(
|
|
|
- keypair,
|
|
|
- bind_multiaddrs,
|
|
|
- allowed,
|
|
|
- limits,
|
|
|
- memory_limits,
|
|
|
- &peer_multiaddrs,
|
|
|
- equix_builder,
|
|
|
- Some(libp2p_init_tx),
|
|
|
- );
|
|
|
- nockapp.add_io_driver(libp2p_driver).await;
|
|
|
-
|
|
|
- // Create the born driver that waits for the born signal
|
|
|
- let born_driver = driver_signals.create_born_driver();
|
|
|
-
|
|
|
- // Add the born driver to the nockapp
|
|
|
- nockapp.add_io_driver(born_driver).await;
|
|
|
-
|
|
|
- // set up socket
|
|
|
- let socket_path = Path::new(
|
|
|
- &cli.as_ref()
|
|
|
- .unwrap_or_else(|| {
|
|
|
- panic!(
|
|
|
- "Panicked at {}:{} (git sha: {:?})",
|
|
|
- file!(),
|
|
|
- line!(),
|
|
|
- option_env!("GIT_SHA")
|
|
|
- )
|
|
|
- })
|
|
|
- .npc_socket,
|
|
|
- );
|
|
|
- nockapp.npc_socket_path = Some(socket_path.to_path_buf());
|
|
|
-
|
|
|
- if let Some(parent) = socket_path.parent() {
|
|
|
- fs::create_dir_all(parent)?;
|
|
|
- }
|
|
|
- let listener = UnixListener::bind(socket_path)?;
|
|
|
-
|
|
|
- nockapp
|
|
|
- .add_io_driver(nockapp::npc_listener_driver(listener))
|
|
|
- .await;
|
|
|
-
|
|
|
- // set up timer
|
|
|
- let mut timer_slab = NounSlab::new();
|
|
|
- let timer_noun = T(
|
|
|
- &mut timer_slab,
|
|
|
- &[D(tas!(b"command")), D(tas!(b"timer")), D(0)],
|
|
|
- );
|
|
|
- timer_slab.set_root(timer_noun);
|
|
|
- nockapp
|
|
|
- .add_io_driver(nockapp::timer_driver(CHAIN_INTERVAL_SECS, timer_slab))
|
|
|
- .await;
|
|
|
-
|
|
|
- nockapp.add_io_driver(nockapp::exit_driver()).await;
|
|
|
-
|
|
|
- Ok(nockapp)
|
|
|
-}
|
|
|
-
|
|
|
-fn welcome() {
|
|
|
- let mut stdout = StandardStream::stdout(ColorChoice::Auto);
|
|
|
-
|
|
|
- let banner = "
|
|
|
- _ _ _ _ _
|
|
|
- | \\ | | ___ ___| | _____| |__ __ _(_)_ __
|
|
|
- | \\| |/ _ \\ / __| |/ / __| '_ \\ / _` | | '_ \\
|
|
|
- | |\\ | (_) | (__| < (__| | | | (_| | | | | |
|
|
|
- |_| \\_|\\___/ \\___|_|\\_\\___|_| |_|\\__,_|_|_| |_|
|
|
|
- ";
|
|
|
-
|
|
|
- print_banner(&mut stdout, banner);
|
|
|
-
|
|
|
- let info = [
|
|
|
- ("Build label", env!("BUILD_EMBED_LABEL")),
|
|
|
- ("Build host", env!("BUILD_HOST")),
|
|
|
- ("Build user", env!("BUILD_USER")),
|
|
|
- ("Build timestamp", env!("BUILD_TIMESTAMP")),
|
|
|
- ("Build date", env!("FORMATTED_DATE")),
|
|
|
- // ("Git commit", env!("BAZEL_GIT_COMMIT")),
|
|
|
- // ("Build timestamp", env!("VERGEN_BUILD_TIMESTAMP")),
|
|
|
- // ("Cargo debug", env!("VERGEN_CARGO_DEBUG")),
|
|
|
- // ("Cargo features", env!("VERGEN_CARGO_FEATURES")),
|
|
|
- // ("Cargo opt level", env!("VERGEN_CARGO_OPT_LEVEL")),
|
|
|
- // ("Cargo target", env!("VERGEN_CARGO_TARGET_TRIPLE")),
|
|
|
- // ("Git branch", env!("VERGEN_GIT_BRANCH")),
|
|
|
- // ("Git commit date", env!("VERGEN_GIT_COMMIT_DATE")),
|
|
|
- // ("Git commit author", env!("VERGEN_GIT_COMMIT_AUTHOR_NAME")),
|
|
|
- // ("Git commit message", env!("VERGEN_GIT_COMMIT_MESSAGE")),
|
|
|
- // ("Git commit timestamp", env!("VERGEN_GIT_COMMIT_TIMESTAMP")),
|
|
|
- // ("Git commit SHA", env!("VERGEN_GIT_SHA")),
|
|
|
- // ("Rustc channel", env!("VERGEN_RUSTC_CHANNEL")),
|
|
|
- // ("Rustc host", env!("VERGEN_RUSTC_HOST_TRIPLE")),
|
|
|
- // ("Rustc LLVM version", env!("VERGEN_RUSTC_LLVM_VERSION")),
|
|
|
- ];
|
|
|
-
|
|
|
- print_version_info(&mut stdout, &info);
|
|
|
-}
|
lushdog@outlook.com