Struct NodeBuilder 

pub struct NodeBuilder<B, S>
where
    B: Blockstore + 'static,
    S: Store + 'static,
{ /* private fields */ }

Node builder.

Implementations

impl NodeBuilder<InMemoryBlockstore, InMemoryStore>

pub fn new() -> Self

Creates a new NodeBuilder which uses in-memory stores.

After the creation you can call NodeBuilder::blockstore and NodeBuilder::store to use other stores.

Example

let node = NodeBuilder::new()
    .network(Network::Mainnet)
    .start()
    .await
    .unwrap();

impl<B, S> NodeBuilder<B, S>

where B: Blockstore + 'static, S: Store + 'static,

pub async fn start(self) -> Result<Node<B, S>>

Creates and starts a new Celestia Node.

pub async fn start_subscribed(self) -> Result<(Node<B, S>, EventSubscriber)>

Creates and starts a new Celestia Node.

Returns Node along with EventSubscriber. Use this to avoid missing any events that will be generated on the construction of the node.

pub fn blockstore<B2>(self, blockstore: B2) -> NodeBuilder<B2, S>

where B2: Blockstore + 'static,

Set the Blockstore for Bitswap.

Default: InMemoryBlockstore

pub fn store<S2>(self, store: S2) -> NodeBuilder<B, S2>

where S2: Store + 'static,

Set the Store for headers.

Default: InMemoryStore

pub fn network(self, network: Network) -> Self

The Network to connect to.

pub fn keypair(self, keypair: Keypair) -> Self

Set the keypair to be used as Nodes identity.

This enforces given libp2p identity to be used by the node.

By default, random identity is created by the store and persisted. Running more than one node with the same identiity is undefined behaviour, because all nodes with the same peer_id will be treated as a singular instance. Network can randomly choose a connection used to send a message to the node, so with multiple instances, each message from the network could be received by a random node with the same keypair. This can potentially lead to broken state and rejecting valid messages. Please make sure that when you use it, only one node has this keypair.

Special care needs to be taken in wasm, as there if your app has hardcoded key, user opening multiple tabs with it may lead to undefined behaviour.

pub fn bootnodes<I>(self, addrs: I) -> Self

where I: IntoIterator<Item = Multiaddr>,

Set the bootstrap nodes to connect and trust.

Default: Network::canonical_bootnodes

pub fn listen<I>(self, addrs: I) -> Self

where I: IntoIterator<Item = Multiaddr>,

Set the addresses where Node will listen for incoming connections.

pub fn sync_batch_size(self, batch_size: u64) -> Self

Maximum number of headers in batch while syncing.

Default: 512

pub fn pruning_window(self, dur: Duration) -> Self

Set pruning window.

Pruning window defines maximum age of a block for it to be retained in store.

If pruning window is smaller than sampling window, then blocks will be pruned right after they get sampled. This is useful when you want to keep low memory footprint but still validate the blockchain.

Default if InMemoryStore/InMemoryBlockstore are used: 0 seconds.
Default: 7 days plus 1 hour.\

Trait Implementations

impl Default for NodeBuilder<InMemoryBlockstore, InMemoryStore>

fn default() -> Self

Returns the “default value” for a type.