enr

![Build Status] ![Doc Status] ![Crates Status]

Documentation at docs.rs

This crate contains an implementation of an Ethereum Node Record (ENR) as specified by EIP-778 extended to allow for the use of ed25519 keys.

An ENR is a signed, key-value record which has an associated NodeId (a 32-byte identifier). Updating/modifying an ENR requires an EnrKey in order to re-sign the record with the associated key-pair.

ENR's are identified by their sequence number. When updating an ENR, the sequence number is increased.

Different identity schemes can be used to define the node id and signatures. Currently only the "v4" identity is supported and is set by default.

Signing Algorithms

User's wishing to implement their own singing algorithms simply need to implement the EnrKey trait and apply it to an Enr.

By default, libsecp256k1::SecretKey implement EnrKey and can be used to sign and verify ENR records. This library also implements EnrKey for ed25519_dalek::Keypair via the ed25519 feature flag.

Furthermore, a CombinedKey is provided if the ed25519 feature flag is set, which provides an ENR type that can support both secp256k1 and ed25519 signed ENR records. Examples of the use of each of these key types is given below.

Additionally there is support for conversion of rust-libp2p Keypair to the CombinedKey type via the libp2p feature flag.

Features

This crate supports a number of features.

• serde: Allows for serde serialization and deserialization for ENRs.
• libp2p: Provides libp2p integration. Libp2p Keypair's can be converted to CombinedKey types which can be used to sign and modify ENRs. This feature also adds the peer_id() and multiaddr() functions to an ENR which provides an ENR's associated PeerId and list of MultiAddr's respectively.
• ed25519: Provides support for ed25519_dalek keypair types.

These can be enabled via adding the feature flag in your Cargo.toml

toml enr = { version = "*", features = ["serde", "libp2p", "ed25519"] }

Examples

To build an ENR, an EnrBuilder is provided.

Building an ENR with the default secp256k1 key type

```rust use enr::{EnrBuilder, secp256k1}; use std::net::Ipv4Addr; use rand::thread_rng;

// generate a random secp256k1 key let mut rng = thread_rng(); let key = secp256k1::SecretKey::random(&mut rng);

let ip = Ipv4Addr::new(192,168,0,1); let enr = EnrBuilder::new("v4").ip(ip.into()).tcp(8000).build(&key).unwrap();

asserteq!(enr.ip(), Some("192.168.0.1".parse().unwrap())); asserteq!(enr.id(), Some("v4".into())); ```

Building an ENR with the CombinedKey type (support for multiple signing algorithms).

Note the ed25519 feature flag must be set. This makes use of the EnrBuilder struct.

```rust use enr::{EnrBuilder, CombinedKey}; use std::net::Ipv4Addr;

// create a new secp256k1 key let key = CombinedKey::generate_secp256k1();

// or create a new ed25519 key let key = CombinedKey::generate_ed25519();

let ip = Ipv4Addr::new(192,168,0,1); let enr = EnrBuilder::new("v4").ip(ip.into()).tcp(8000).build(&key).unwrap();

asserteq!(enr.ip(), Some("192.168.0.1".parse().unwrap())); asserteq!(enr.id(), Some("v4".into())); ```

Modifying an ENR

Enr fields can be added and modified using the getters/setters on Enr. A custom field can be added using insert and retrieved with get.

```rust use enr::{EnrBuilder, secp256k1::SecretKey, Enr}; use std::net::Ipv4Addr; use rand::thread_rng;

// generate a random secp256k1 key let mut rng = thread_rng(); let key = SecretKey::random(&mut rng);

let ip = Ipv4Addr::new(192,168,0,1); let mut enr = EnrBuilder::new("v4").ip(ip.into()).tcp(8000).build(&key).unwrap();

enr.settcp(8001, &key); // set a custom key enr.insert("customkey", vec![0,0,1], &key);

// encode to base64 let base64string = enr.to_base64();

// decode from base64 let decodedenr: Enr = base64_string.parse().unwrap();

asserteq!(decodedenr.ip(), Some("192.168.0.1".parse().unwrap())); asserteq!(decodedenr.id(), Some("v4".into())); asserteq!(decodedenr.tcp(), Some(8001)); asserteq!(decodedenr.get("custom_key"), Some(&vec![0,0,1])); ```

Libp2p key conversion, with the libp2p feature flag

```rust use enr::{EnrBuilder, CombinedKey}; use std::net::Ipv4Addr; use std::convert::TryInto;

// with the libp2p feature flag, one can also use a libp2p key let libp2pkey = libp2pcore::identity::Keypair::generatesecp256k1(); let key: CombinedKey = libp2pkey.try_into().expect("supports secp256k1");

let ip = Ipv4Addr::new(192,168,0,1); let enr = EnrBuilder::new("v4").ip(ip.into()).tcp(8000).build(&key).unwrap();

asserteq!(enr.ip(), Some("192.168.0.1".parse().unwrap())); asserteq!(enr.id(), Some("v4".into())); ```

Encoding/Decoding ENR's of various key types

```rust use enr::{EnrBuilder, secp256k1::SecretKey, Enr, ed25519dalek::Keypair, CombinedKey}; use std::net::Ipv4Addr; use rand::threadrng; use rand::Rng;

// generate a random secp256k1 key let mut rng = threadrng(); let key = SecretKey::random(&mut rng); let ip = Ipv4Addr::new(192,168,0,1); let enrsecp256k1 = EnrBuilder::new("v4").ip(ip.into()).tcp(8000).build(&key).unwrap();

// encode to base64 let base64stringsecp256k1 = enrsecp256k1.tobase64();

// generate a random ed25519 key let key = Keypair::generate(&mut rng); let enr_ed25519 = EnrBuilder::new("v4").ip(ip.into()).tcp(8000).build(&key).unwrap();

// encode to base64 let base64stringed25519 = enred25519.tobase64();

// decode base64 strings of varying key types // decode the secp256k1 with default Enr let decodedenrsecp256k1: Enr = base64stringsecp256k1.parse().unwrap(); // decode ed25519 ENRs let decodedenred25519: Enr = base64stringed25519.parse().unwrap();

// use the combined key to be able to decode either let decodedenr: Enr = base64stringsecp256k1.parse().unwrap(); let decodedenr: Enr = base64stringed25519.parse().unwrap();