Merge branch 'master' of github.com:narodnik/sapvi

Cargo.toml

@@ -100,3 +100,5 @@ path = "src/bin/dfg.rs"
 name = "compile-shaders"
 path = "src/bin/compile-shaders.rs"
 
+[profile.release]
+debug = 1

lisp/examples/mint2.lisp

@@ -91,8 +91,8 @@
         `(def! ~T (alloc ~T (* (+ ~val1 ~val2) (+ ~val1 ~val2))))
         `(def! ~A (alloc ~A (* ~u ~v)))
         `(def! ~C (alloc ~C (* (square ~A) ~EDWARDS_D)))
-        `(def! ~u3 (alloc-input ~u3 (/ (double ~A) (+ scalar::one ~C))))
-        `(def! ~v3 (alloc-input ~v3 (/ (- ~T (double ~A)) (- scalar::one ~C))))
+        `(def! ~u3 (alloc ~u3 (/ (double ~A) (+ scalar::one ~C))))
+        `(def! ~v3 (alloc ~v3 (/ (- ~T (double ~A)) (- scalar::one ~C))))
         `(enforce  
             ((scalar::one ~u) (scalar::one ~v))
             ((scalar::one ~u) (scalar::one ~v))
@@ -128,8 +128,8 @@
             `(def! ~u (alloc ~u ~val1))
             `(def! ~v (alloc ~v ~val2))
             `(def! ~condition (alloc ~condition ~val3))
-            `(def! ~u-prime (alloc-input ~u-prime (* ~u ~condition)))
-            `(def! ~v-prime (alloc-input ~v-prime (* ~v ~condition)))
+            `(def! ~u-prime (alloc ~u-prime (* ~u ~condition)))
+            `(def! ~v-prime (alloc ~v-prime (* ~v ~condition)))
             `(enforce
                 (scalar::one ~u)
                 (scalar::one ~condition)
@@ -159,8 +159,8 @@
         `(def! ~A (alloc ~A (* ~v2 ~u1)))
         `(def! ~B (alloc ~B (* ~u2 ~v1)))
         `(def! ~C (alloc ~C (* ~EDWARDS_D (* ~A ~B))))
-        `(def! ~u3 (alloc-input ~u3 (/ (+ ~A ~B) (+ scalar::one ~C))))
-        `(def! ~v3 (alloc-input ~v3 (/ (- (- ~U ~A) ~B) (- scalar::one ~C))))        
+        `(def! ~u3 (alloc ~u3 (/ (+ ~A ~B) (+ scalar::one ~C))))
+        `(def! ~v3 (alloc ~v3 (/ (- (- ~U ~A) ~B) (- scalar::one ~C))))        
   `(enforce  
     ((scalar::one ~u1) (scalar::one ~v1))
     ((scalar::one ~u2) (scalar::one ~v2))
@@ -256,13 +256,11 @@
     (dotimes 322 (        
         (def! result (mimc-macro xl xr acc))
         (def! result-value (get (last (last result)) "left"))
-        (println acc)
-        (println xl xr)
-        (println result-value)
         (def! xr xl)
         (def! xl result-value)
         (def! acc (i+ acc 1))        
     ))
+    { "result" result-value }
 )))
 
 (defmacro! rangeproof-alloc (fn* [value value-digit] (
@@ -272,7 +270,7 @@
     `(def! ~digit (alloc-const ~digit ~value-digit))
     `(enforce 
         (scalar::one ~bit) 
-        (scalar::one::neg ~bit) 
+        ((scalar::one cs::one) (scalar::one::neg ~bit))
         () 
     )    
     { "lc" ((str digit) (str bit)) }
@@ -280,16 +278,20 @@
 
 (def! rangeproof (fn* [value] (    
     (def! values-bit (unpack-bits value))
-    (def! acc 0)
-    (def! digit scalar::one)    
+    (def! idx 0)
+    (def! digit (scalar 1))
     (def! value-result ())
     (dotimes 64 (
-        (def! bit (nth values-bit acc))    
+        (def! bit (nth values-bit idx))    
         (def! value-result 
-            (conj value-result (get (last (last (rangeproof-alloc bit digit))) "lc")))
+            (conj value-result 
+            (get (last (last 
+                (rangeproof-alloc bit digit))) "lc")))
+        (println 'digit digit 'bit bit)
         (def! digit (double digit))
-        (def! acc (i+ acc 1))
+        (def! idx (i+ idx 1))
     ))
+    (println 'value-result value-result)
     (def! value-alloc (alloc-input "value-alloc" value))
     (enforce 
         (value-result)
@@ -298,13 +300,48 @@
     )  
 )))
 
+;; mint contract
+(def! generator-coin-u (scalar "0d7b70a0c82cbabf8f59ee61a63b8e0adcff42e9f2da7bda84f9308b3531dd18"))
+(def! generator-coin-v (scalar "0d89cafb242b9e892153ac70335956e6f5c042997da77cf5e164233a9bbfb7b4"))
+(def! generator-value-commit-u (scalar "01ae4ea270f5c6a1c0cd1dd4e067a82110fa27409dfc0aa4edd18883897a4c6b"))
+(def! generator-value-commit-v (scalar "09d2a25018194750e9adacf78531ee3bfddbadd767671d517aa788c352641ff1"))
+(def! generator-value-random-u (scalar "002924d15ccf8014ce724a41753d17dce3a9f7382a3db18fba3c8e286bb77382"))
+(def! generator-value-random-v (scalar "0cb825b790b0601c4999e52d9added7d10d013b33fd95ca7d2ddd51691a09075"))
+(def! mint-contract (fn* [secret value serial rnd-coin rnd-value] (
+    (def! result-mul (last (last (jj-mul generator-coin-u generator-coin-v secret))) "lc")
+    (def! public-u (alloc "public-u" (get result-mul "u")))
+    (def! public-v (alloc "public-v" (get result-mul "v")))
+    (def! mimc-round-1 (get (last (mimc public-u public-v)) "result"))
+    (def! mimc-round-2 (get (last (mimc mimc-round-1 value)) "result"))
+    (def! mimc-round-3 (get (last (mimc mimc-round-2 serial)) "result"))
+    (def! coin (get (last (mimc mimc-round-3 rnd-coin)) "result"))
+    (rangeproof value)
+    (def! result-mul-value 
+        (last (last (jj-mul generator-value-commit-u generator-value-commit-v value))))
+    (def! result-mul-rnd-value 
+        (last (last (jj-mul generator-value-random-u generator-value-random-v rnd-value))))
+    (def! add-result (last 
+        (jj-add (get result-mul-value "u") (get result-mul-value "u") 
+            (get result-mul-rnd-value "u") (get result-mul-rnd-value "u"))))
+    (def! value-commit add-result)
+    (println 'value-commit value-commit)
+    (alloc-input "value-commit" value-commit)
+)))
+
+;; (def! spend-contract (fn* 
+;;     [secret-u secret-v serial coin-merkle-branch coin-merkle-is-right] (
+;; (def! nullifier (mimc secret serial))
+
+;; )))
+
 (prove 
   (            
-    (def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
-    (def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
-    (rangeproof param-u)
-    ;; (def! param3 (rnd-scalar))
-    ;; (jj-mul param-u param-v param3)
+    (def! secret (scalar 1))
+    (def! value (scalar 2))
+    (def! serial (scalar 3))
+    (def! rnd-coin (rnd-scalar))
+    (def! rnd-value (rnd-scalar))
+    (mint-contract secret value serial rnd-coin rnd-value)
   )
 )
 

lisp/lisp.rs

@@ -147,6 +147,8 @@ fn eval_ast(ast: &MalVal, env: &Env) -> MalRet {
 fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
     let ret: MalRet;
 
+    let start = Instant::now();
+
     'tco: loop {
         ret = match ast.clone() {
             List(l, _) => {
@@ -345,6 +347,7 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                     Sym(ref a0sym) if a0sym == "prove" => {
                         let a1 = l[1].clone();
                         eval(a1.clone(), env.clone())?;
+                        // TODO add debug param
                         prove(a1.clone(), env.clone())
                     }
                     Sym(ref a0sym) if a0sym == "alloc-const" => {
@@ -573,6 +576,8 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
         break;
     } // end 'tco loop
 
+    // println!("eval end \t {:?} \t {:?}", ast, start.elapsed());
+
     ret
 }
 
@@ -648,7 +653,7 @@ pub fn setup(_ast: MalVal, env: Env) -> Result<VerifyKeyParams, MalErr> {
     })
 }
 
-pub fn prove(_ast: MalVal, env: Env) -> MalRet {
+pub fn prove(_ast: MalVal, env: Env) -> MalRet {    
     let start = Instant::now();
     let allocs_input = get_allocations(&env, "AllocationsInput");
     let allocs = get_allocations(&env, "Allocations");
@@ -664,6 +669,7 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
         };
         groth16::generate_random_parameters::<Bls12, _, _>(circuit, &mut OsRng)?
     });
+
     let verifying_key = Some(groth16::prepare_verifying_key(&params.as_ref().unwrap().vk));
     // prove
     let circuit = LispCircuit {
@@ -672,7 +678,6 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
         alloc_inputs: allocs_input.borrow().clone(),
         constraints: enforce_allocs.clone(),
     };
-
     let proof = groth16::create_random_proof(circuit, params.as_ref().unwrap(), &mut OsRng)?;
     let mut vec_input = vec![];
     for (k, val) in allocs_input.borrow_mut().iter() {
@@ -686,10 +691,13 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
             _ => {}
         };
     }
+    println!("groth16::create_random_proof: {:?}", start.elapsed());
+    // verification process 
+    let start = Instant::now();
     let result = groth16::verify_proof(verifying_key.as_ref().unwrap(), &proof, &vec_input);
+    println!("groth16::verify_proof: {:?}", start.elapsed());
     println!("vec public {:?}", vec_input);
-    println!("result {:?}", result);
-    println!("Elapsed time: {:?}", start.elapsed());
+    println!("result {:?}", result);    
     Ok(MalVal::Nil)
 }
 
@@ -746,6 +754,7 @@ fn main() -> Result<(), ()> {
 }
 
 fn repl_load(file: String) -> Result<(), ()> {
+    let start = Instant::now();
     let repl_env = env_new(None);
     for (k, v) in core::ns() {
         env_sets(&repl_env, k, v);
@@ -756,10 +765,21 @@ fn repl_load(file: String) -> Result<(), ()> {
         &repl_env,
     );
     match rep(&format!("(load-file \"{}\")", file), &repl_env) {
-        Ok(_) => std::process::exit(0),
+        Ok(_) => {
+            println!("lisp end \t {:?}", start.elapsed());
+            std::process::exit(0) 
+        },
         Err(e) => {
             println!("Error: {}", format_error(e));
             std::process::exit(1);
         }
+    }    
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
     }
 }

lisp/types.rs

@@ -1,6 +1,6 @@
 use bellman::{gadgets::Assignment, groth16, Circuit, ConstraintSystem, SynthesisError};
 use sapvi::bls_extensions::BlsStringConversion;
-use std::ops::{Add, AddAssign, MulAssign, SubAssign};
+use std::{ops::{Add, AddAssign, MulAssign, SubAssign}, time::Instant};
 use std::rc::Rc;
 use std::{cell::RefCell, collections::HashMap};
 // use fnv::FnvHashMap;
@@ -71,8 +71,10 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
         cs: &mut CS,
     ) -> Result<(), SynthesisError> {
         let mut variables: HashMap<String, Variable> = HashMap::default();
-        let mut params_const = self.params;
+        let params_const = self.params;
 
+        let circuitTime = Instant::now();
+        let start = Instant::now();
         // println!("Allocations\n");
         for (k, v) in &self.allocs {
             match v {
@@ -96,7 +98,8 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 }
             }
         }
-
+        println!("circuit alloc \t {:?}", start.elapsed());
+        let start = Instant::now();        
         // println!("Allocations Input\n");
         for (k, v) in &self.alloc_inputs {
             match v {
@@ -116,10 +119,10 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 }
             }
         }
-
-        println!("Enforce Allocations\n");
+        println!("circuit alloc input \t {:?}", start.elapsed());        
+        let start = Instant::now();
         let mut enforce_sorted = self.constraints.clone();
-        enforce_sorted.sort_by(|a, b| a.idx.cmp(&b.idx));
+        // enforce_sorted.sort_by(|a, b| a.idx.cmp(&b.idx));
         for alloc_value in enforce_sorted.iter() {
             // println!("Enforce -> {:?}", alloc_value);
             let coeff = bls12_381::Scalar::one();
@@ -130,7 +133,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 let (a, b) = values;
                 let mut val_b = CS::one();
                 if b != "cs::one" {
-                    println!("{:?}", b);
+                    // println!("{:?}", b);
                     val_b = *variables.get(b).unwrap();
                 }
                 if a == "scalar::one" {
@@ -147,13 +150,20 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                                 let val = bls12_381::Scalar::from_string(&s.to_string());
                                 left = left + (val, val_b);
                             }
+                            MalVal::Func(_, _) => {
+                                if let MalVal::Vector(val, _) = value.apply(vec![]).unwrap() {
+                                    if let MalVal::ZKScalar(res) = val.to_vec()[0] {
+                                        left = left + (res, val_b);
+                                    }
+                                }
+                            }
                             _ => {
                                 println!("not a valid param {:?}", value)
                             }
                         }
                     }
                 }
-                println!("left: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                // println!("left: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             for values in alloc_value.right.iter() {
@@ -176,20 +186,27 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                                 let val = bls12_381::Scalar::from_string(&s.to_string());
                                 right = right + (val, val_b);
                             }
+                            MalVal::Func(_, _) => {
+                                if let MalVal::Vector(val, _) = value.apply(vec![]).unwrap() {
+                                    if let MalVal::ZKScalar(res) = val.to_vec()[0] {
+                                        right = right + (res, val_b);
+                                    }
+                                }
+                            }
                             _ => {
                                 println!("not a valid param {:?}", value)
                             }
                         }
                     }
                 }
-                println!("right: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                // println!("right: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             for values in alloc_value.output.iter() {
                 let (a, b) = values;
                 let mut val_b = CS::one();
                 if b != "cs::one" {
-                    println!("{:?}", b);
+                    // println!("{:?}", b);
                     val_b = *variables.get(b).unwrap();
                 }
                 if a == "scalar::one" {
@@ -206,24 +223,32 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                                 let val = bls12_381::Scalar::from_string(&s.to_string());
                                 output = output + (val, val_b);
                             }
+                            MalVal::Func(_, _) => {
+                                if let MalVal::Vector(val, _) = value.apply(vec![]).unwrap() {
+                                    if let MalVal::ZKScalar(res) = val.to_vec()[0] {
+                                        output = output + (res, val_b);
+                                    }
+                                }
+                            }
                             _ => {
                                 println!("not a valid param {:?}", value)
                             }
                         }
                     }
                 }
-                println!("output: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                // println!("output: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
-            println!("Enforcing ...");
+            // println!("Enforcing ...");
             cs.enforce(
                 || "constraint",
                 |_| left.clone(),
                 |_| right.clone(),
                 |_| output.clone(),
             );
-        }
-
+        }     
+        println!("circuit enforce \t {:?}", start.elapsed());        
+        println!("end circuit \t {:?}", circuitTime.elapsed());        
         Ok(())
     }
 }

src/net/acceptor.rs

@@ -10,8 +10,8 @@ use crate::system::{StoppableTask, StoppableTaskPtr, Subscriber, SubscriberPtr,
 /// Atomic pointer to Acceptor class.
 pub type AcceptorPtr = Arc<Acceptor>;
 
-/// Handles the acceptance of inbound socket connections. Used to start listening on a local socket
-/// address, to accept incoming connections and to handle network errors.
+/// Handles the acceptance of inbound socket connections. Used to start listening
+/// on a local socket address, to accept incoming connections and to handle network errors.
 pub struct Acceptor {
     channel_subscriber: SubscriberPtr<NetResult<ChannelPtr>>,
     task: StoppableTaskPtr,
@@ -25,9 +25,9 @@ impl Acceptor {
             task: StoppableTask::new(),
         })
     }
-    /// Start accepting inbound socket connections. Creates a listener to start listening on a
-    /// local socket address. Then runs an accept loop in a new thread, erroring if a connection
-    /// problem occurs.
+    /// Start accepting inbound socket connections. Creates a listener to start
+    /// listening on a local socket address. Then runs an accept loop in a new
+    /// thread, erroring if a connection problem occurs.
     pub fn start(
         self: Arc<Self>,
         accept_addr: SocketAddr,

src/net/message_subscriber.rs

@@ -17,8 +17,8 @@ use crate::serial::{Decodable, Encodable};
 pub type MessageSubscriptionID = u64;
 type MessageResult<M> = NetResult<Arc<M>>;
 
-/// Handles message subscriptions through a subscription ID and a receiver channel.
-/// Inherits from Message Dispatcher.
+/// Handles message subscriptions through a subscription ID and a receiver
+/// channel. Inherits from Message Dispatcher.
 pub struct MessageSubscription<M: Message> {
     id: MessageSubscriptionID,
     recv_queue: async_channel::Receiver<MessageResult<M>>,
@@ -160,8 +160,9 @@ impl<M: Message> MessageDispatcherInterface for MessageDispatcher<M> {
 }
 
 /// Generic publish/subscribe class that can dispatch any kind of message
-/// to a subscribed list of dispatchers. Dispatchers subscribe to a single message format of any
-/// type. This is a generalized version of the pub/sub model in system::Subscriber.
+/// to a subscribed list of dispatchers. Dispatchers subscribe to a single
+/// message format of any type. This is a generalized version of the pub/sub
+/// model in system::Subscriber.
 pub struct MessageSubsystem {
     dispatchers: Mutex<HashMap<&'static str, Arc<dyn MessageDispatcherInterface>>>,
 }

src/net/messages.rs

@@ -158,8 +158,8 @@ impl Decodable for VerackMessage {
     }
 }
 
-/// Packets are the base type read from the network. Converted to messages and passed to event
-/// loop.
+/// Packets are the base type read from the network. Converted to messages and
+/// passed to event loop.
 pub struct Packet {
     pub command: String,
     pub payload: Vec<u8>,

src/net/p2p.rs

@@ -80,6 +80,7 @@ impl P2p {
         Ok(())
     }
 
+    /// Broadcasts a message across all channels.
     pub async fn broadcast<M: Message + Clone>(&self, message: M) -> NetResult<()> {
         for channel in self.channels.lock().await.values() {
             channel.send(message.clone()).await?;

src/net/protocols/protocol_address.rs

@@ -21,8 +21,8 @@ pub struct ProtocolAddress {
 }
 
 impl ProtocolAddress {
-    /// Create a new address protocol. Makes an address and get-address subscription and adds them
-    /// to the address protocol instance.
+    /// Create a new address protocol. Makes an address and get-address subscription
+    /// and adds them to the address protocol instance.
     pub async fn new(channel: ChannelPtr, hosts: HostsPtr) -> Arc<Self> {
         // Creates a subscription to address message.
         let addrs_sub = channel
@@ -47,8 +47,8 @@ impl ProtocolAddress {
         })
     }
 
-    /// Starts the address protocol. Runs receive address and get address protocols on the protocol
-    /// task manager. Then sends get-address message.
+    /// Starts the address protocol. Runs receive address and get address protocols
+    /// on the protocol task manager. Then sends get-address message.
     pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) {
         debug!(target: "net", "ProtocolAddress::start() [START]");
         self.jobsman.clone().start(executor.clone());
@@ -67,8 +67,8 @@ impl ProtocolAddress {
         debug!(target: "net", "ProtocolAddress::start() [END]");
     }
 
-    /// Handles receiving the address message. Loops to continually recieve address messages on the
-    /// address subsciption. Adds the recieved addresses to the list of hosts.
+    /// Handles receiving the address message. Loops to continually recieve address
+    /// messages on the address subsciption. Adds the recieved addresses to the list of hosts.
     async fn handle_receive_addrs(self: Arc<Self>) -> NetResult<()> {
         debug!(target: "net", "ProtocolAddress::handle_receive_addrs() [START]");
         loop {
@@ -86,8 +86,8 @@ impl ProtocolAddress {
         }
     }
 
-    /// Handles receiving the get-address message. Continually recieves get-address messages on the
-    /// get-address subsciption. Then replies with an address message.
+    /// Handles receiving the get-address message. Continually recieves get-address
+    /// messages on the get-address subsciption. Then replies with an address message.
     async fn handle_receive_get_addrs(self: Arc<Self>) -> NetResult<()> {
         debug!(target: "net", "ProtocolAddress::handle_receive_get_addrs() [START]");
         loop {

src/net/protocols/protocol_jobs_manager.rs

@@ -41,8 +41,8 @@ impl ProtocolJobsManager {
         self.tasks.lock().await.push(executor.spawn(future))
     }
 
-    /// Waits for a stop signal, then closes all tasks. Insures that all tasks are stopped when a
-    /// channel closes. Called in start().
+    /// Waits for a stop signal, then closes all tasks. Insures that all tasks are
+    /// stopped when a channel closes. Called in start().
     async fn handle_stop(self: Arc<Self>) {
         let stop_sub = self.channel.clone().subscribe_stop().await;
 

src/net/protocols/protocol_ping.rs

@@ -28,9 +28,9 @@ impl ProtocolPing {
         })
     }
 
-    /// Starts ping-pong keep-alive messages exchange. Runs ping-pong in the protocol task manager,
-    /// then queues the reply. run_ping_pong() sends out a ping and waits for pong reply.
-    /// reply_to_ping() waits for ping and replies with a pong.
+    /// Starts ping-pong keep-alive messages exchange. Runs ping-pong in the protocol
+    /// task manager, then queues the reply. Sends out a ping and waits for pong
+    /// reply. Waits for ping and replies with a pong.
     pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) {
         debug!(target: "net", "ProtocolPing::start() [START]");
         self.jobsman.clone().start(executor.clone());
@@ -45,9 +45,10 @@ impl ProtocolPing {
         debug!(target: "net", "ProtocolPing::start() [END]");
     }
 
-    /// Runs ping-pong protocol. Creates a subscription to pong, then starts a loop. Loop sleeps
-    /// for the duration of the channel heartbeat, then sends a ping message with a random nonce.
-    /// Loop starts a timer, waits for the pong reply and insures the nonce is the same.
+    /// Runs ping-pong protocol. Creates a subscription to pong, then starts a loop.
+    /// Loop sleeps for the duration of the channel heartbeat, then sends a ping
+    /// message with a random nonce. Loop starts a timer, waits for the pong reply
+    /// and insures the nonce is the same.
     async fn run_ping_pong(self: Arc<Self>) -> NetResult<()> {
         debug!(target: "net", "ProtocolPing::run_ping_pong() [START]");
         // Creates a subscription to pong message.

src/net/protocols/protocol_seed.rs

@@ -6,8 +6,8 @@ use crate::net::error::NetResult;
 use crate::net::messages;
 use crate::net::{ChannelPtr, HostsPtr, SettingsPtr};
 
-/// Seed server protocol. Seed server is used when connecting to the network for the first time.
-/// Returns a list of IP addresses that nodes can connect to.
+/// Seed server protocol. Seed server is used when connecting to the network for
+/// the first time. Returns a list of IP addresses that nodes can connect to.
 pub struct ProtocolSeed {
     channel: ChannelPtr,
     hosts: HostsPtr,
@@ -24,8 +24,9 @@ impl ProtocolSeed {
         })
     }
 
-    /// Starts the seed protocol. Creates a subscription to the address message, then sends our
-    /// address to the seed server. Sends a get-address message and receives an address message.
+    /// Starts the seed protocol. Creates a subscription to the address message, then
+    /// sends our address to the seed server. Sends a get-address message and receives
+    /// an address message.
     pub async fn start(self: Arc<Self>, _executor: Arc<Executor<'_>>) -> NetResult<()> {
         debug!(target: "net", "ProtocolSeed::start() [START]");
         // Create a subscription to address message.
@@ -52,8 +53,8 @@ impl ProtocolSeed {
         Ok(())
     }
 
-    /// Sends own external address over a channel. Imports own external address from settings, then
-    /// adds that address to an address message and sends it out over the channel.
+    /// Sends own external address over a channel. Imports own external address from
+    /// settings, then adds that address to an address message and sends it out over the channel.
     pub async fn send_self_address(&self) -> NetResult<()> {
         match self.settings.external_addr {
             Some(addr) => {

src/net/protocols/protocol_version.rs

@@ -18,8 +18,8 @@ pub struct ProtocolVersion {
 }
 
 impl ProtocolVersion {
-    /// Create a new version protocol. Makes a version and version acknowledgement subscription,
-    /// then adds them to a version protocol instance.
+    /// Create a new version protocol. Makes a version and version acknowledgement
+    /// subscription, then adds them to a version protocol instance.
     pub async fn new(channel: ChannelPtr, settings: SettingsPtr) -> Arc<Self> {
         // Creates a version subscription.
         let version_sub = channel
@@ -42,8 +42,8 @@ impl ProtocolVersion {
             settings,
         })
     }
-    /// Start version information exchange. Start the timer. Send version info and wait for version
-    /// acknowledgement. Wait for version info and send version acknowledgement.
+    /// Start version information exchange. Start the timer. Send version info and
+    /// wait for version acknowledgement. Wait for version info and send version acknowledgement.
     pub async fn run(self: Arc<Self>, executor: Arc<Executor<'_>>) -> NetResult<()> {
         debug!(target: "net", "ProtocolVersion::run() [START]");
         // Start timer

src/net/sessions/inbound_session.rs

@@ -28,8 +28,8 @@ impl InboundSession {
             accept_task: StoppableTask::new(),
         })
     }
-    /// Starts the inbound session. Begins by accepting connections and fails if the address is not
-    /// configured. Then runs the channel subscription loop.
+    /// Starts the inbound session. Begins by accepting connections and fails if the
+    /// address is not configured. Then runs the channel subscription loop.
     pub fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> NetResult<()> {
         match self.p2p().settings().inbound {
             Some(accept_addr) => {
@@ -84,8 +84,8 @@ impl InboundSession {
         }
     }
 
-    /// Registers the channel. First performs a network handshake and starts the channel. Then starts
-    /// sending keep-alive and address messages across the channel.
+    /// Registers the channel. First performs a network handshake and starts the
+    /// channel. Then starts sending keep-alive and address messages across the channel.
     async fn setup_channel(
         self: Arc<Self>,
         channel: ChannelPtr,

src/net/sessions/outbound_session.rs

@@ -56,10 +56,10 @@ impl OutboundSession {
         }
     }
 
-    /// Start making outbound connections.
-    /// Creates a connector object, then starts a connect loop. Loads a valid address then tries to
-    /// connect. Once connected, registers the channel, removes it from the list of pending
-    /// channels, and starts sending messages across the channel. Otherwise returns a network error.
+    /// Start making outbound connections. Creates a connector object, then starts a
+    /// connect loop. Loads a valid address then tries to connect. Once connected,
+    /// registers the channel, removes it from the list of pending channels, and
+    /// starts sending messages across the channel. Otherwise returns a network error.
     pub async fn channel_connect_loop(
         self: Arc<Self>,
         slot_number: u32,
@@ -102,10 +102,10 @@ impl OutboundSession {
         }
     }
 
-    /// Loops through host addresses to find a outbound address that we can connect to.
-    /// Checks whether address is valid by making sure it isn't our own inbound address,
-    /// then checks whether it is already connected (exists) or connecting (pending).
-    /// Keeps looping until address is found that passes all checks.
+    /// Loops through host addresses to find a outbound address that we can connect
+    /// to. Checks whether address is valid by making sure it isn't our own inbound
+    /// address, then checks whether it is already connected (exists) or connecting
+    /// (pending). Keeps looping until address is found that passes all checks.
     async fn load_address(&self, slot_number: u32) -> NetResult<SocketAddr> {
         let p2p = self.p2p();
         let hosts = p2p.hosts();

src/net/sessions/session.rs

@@ -25,10 +25,12 @@ async fn remove_sub_on_stop(p2p: P2pPtr, channel: ChannelPtr) {
 }
 
 #[async_trait]
-/// Session trait. Defines methods that are used across sessions. Implements registering the channel
-/// and initializing the channel by performing a network handshake.
+/// Session trait. Defines methods that are used across sessions. Implements
+/// registering the channel and initializing the channel by performing a network
+/// handshake.
 pub trait Session: Sync {
-    /// Registers a new channel with the session. Performs a network handshake and starts the channel.
+    /// Registers a new channel with the session. Performs a network handshake and
+    /// starts the channel.
     async fn register_channel(
         self: Arc<Self>,
         channel: ChannelPtr,
@@ -49,8 +51,9 @@ pub trait Session: Sync {
         Ok(())
     }
 
-    /// Performs network handshake to initialize channel. Adds the channel to the list of connected
-    /// channels, and prepares to remove the channel when a stop signal is received.
+    /// Performs network handshake to initialize channel. Adds the channel to the
+    /// list of connected channels, and prepares to remove the channel when a stop
+    /// signal is received.
     async fn perform_handshake_protocols(
         &self,
         protocol_version: Arc<ProtocolVersion>,

src/net/settings.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 /// Atomic pointer to network settings.
 pub type SettingsPtr = Arc<Settings>;
 
-/// Default network configuration settings.
+/// Network configuration settings.
 #[derive(Clone)]
 pub struct Settings {
     pub inbound: Option<SocketAddr>,