0g-storage-node/version-meld/discv5
peilun-conflux 4eb2a50b0e
Use inner lock in storage and use async lock. (#92)
* Use inner lock in storage.

* Remove mut.

* Remove async lock for storage.

* Fix tests and warnings.

* Use spawn_blocking for storage task.

* Fix clippy.

* Finalize the new tx at last.

* Revert "Finalize the new tx at last."

This reverts commit b56ad5582d.

* Wait for old same-root txs to finalize.

* Use async storage in miner.

* Update rust version to 1.79.0.

* Use Vec to avoid stack overflow.

* Fix unused warning.

* Fix clippy.

* Fix test warning.

* Fix test.

* fmt.

* Use async storage in pruner.

* nit.
2024-06-29 17:08:02 +08:00
..
examples Initial commit 2024-01-04 18:05:32 +08:00
src Use inner lock in storage and use async lock. (#92) 2024-06-29 17:08:02 +08:00
.cargo_vcs_info.json Initial commit 2024-01-04 18:05:32 +08:00
.cargo-ok Initial commit 2024-01-04 18:05:32 +08:00
Cargo.lock Initial commit 2024-01-04 18:05:32 +08:00
Cargo.toml Initial commit 2024-01-04 18:05:32 +08:00
Cargo.toml.orig Initial commit 2024-01-04 18:05:32 +08:00
LICENSE Initial commit 2024-01-04 18:05:32 +08:00
README.md Initial commit 2024-01-04 18:05:32 +08:00

discv5

Build Status Doc Status Crates
Status

Documentation at docs.rs

Overview

This is a rust implementation of the Discovery v5 peer discovery protocol.

Discovery v5 is a protocol designed for encrypted peer discovery and topic advertisement. Each peer/node on the network is identified via it's ENR (Ethereum Node Record), which is essentially a signed key-value store containing the node's public key and optionally IP address and port.

Discv5 employs a kademlia-like routing table to store and manage discovered peers and topics. The protocol allows for external IP discovery in NAT environments through regular PING/PONG's with discovered nodes. Nodes return the external IP address that they have received and a simple majority is chosen as our external IP address. If an external IP address is updated, this is produced as an event to notify the swarm (if one is used for this behaviour).

For a simple CLI discovery service see discv5-cli

Usage

A simple example of creating this service is as follows:

   use discv5::{enr, enr::{CombinedKey, NodeId}, TokioExecutor, Discv5, Discv5ConfigBuilder};
   use std::net::SocketAddr;

   // listening address and port
   let listen_addr = "0.0.0.0:9000".parse::<SocketAddr>().unwrap();

   // construct a local ENR
   let enr_key = CombinedKey::generate_secp256k1();
   let enr = enr::EnrBuilder::new("v4").build(&enr_key).unwrap();

   // build the tokio executor
   let mut runtime = tokio::runtime::Builder::new_multi_thread()
       .thread_name("Discv5-example")
       .enable_all()
       .build()
       .unwrap();

   // default configuration
   let config = Discv5ConfigBuilder::new().build();

   // construct the discv5 server
   let mut discv5 = Discv5::new(enr, enr_key, config).unwrap();

   // In order to bootstrap the routing table an external ENR should be added
   // This can be done via add_enr. I.e.:
   // discv5.add_enr(<ENR>)

   // start the discv5 server
   runtime.block_on(discv5.start(listen_addr));

   // run a find_node query
   runtime.block_on(async {
      let found_nodes = discv5.find_node(NodeId::random()).await.unwrap();
      println!("Found nodes: {:?}", found_nodes);
   });