Apply new path to serial crate throughout codebase.

bin/daod/Cargo.toml

@@ -3,11 +3,10 @@ name = "daod"
 version = "0.3.0"
 edition = "2021"
 
-[dependencies.darkfi]
-path = "../../"
-features = ["rpc", "crypto", "tx", "node"]
-
 [dependencies]
+darkfi = {path = "../../", features = ["rpc", "crypto", "tx", "node"]}
+darkfi-serial = {path = "../../src/serial"}
+
 # Async
 smol = "1.2.5"
 futures = "0.3.24"

bin/daod/src/dao_contract/exec/validate.rs

@@ -1,3 +1,4 @@
+use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use pasta_curves::{
     arithmetic::CurveAffine,
     group::{Curve, Group},
@@ -6,7 +7,6 @@ use pasta_curves::{
 
 use darkfi::{
     crypto::{coin::Coin, keypair::PublicKey, types::DrkCircuitField},
-    serial::{Encodable, SerialDecodable, SerialEncodable},
     Error as DarkFiError,
 };
 

bin/daod/src/dao_contract/mint/validate.rs

@@ -1,9 +1,7 @@
 use std::any::{Any, TypeId};
 
-use darkfi::{
-    crypto::{keypair::PublicKey, types::DrkCircuitField},
-    serial::{Encodable, SerialDecodable, SerialEncodable},
-};
+use darkfi::crypto::{keypair::PublicKey, types::DrkCircuitField};
+use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 
 use crate::{
     dao_contract::{DaoBulla, State, CONTRACT_ID},

bin/daod/src/dao_contract/propose/validate.rs

@@ -1,15 +1,17 @@
-use darkfi::{
-    crypto::{keypair::PublicKey, merkle_node::MerkleNode, types::DrkCircuitField},
-    serial::{Encodable, SerialDecodable, SerialEncodable},
-    Error as DarkFiError,
-};
+use std::any::{Any, TypeId};
+
+use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use log::error;
 use pasta_curves::{
     arithmetic::CurveAffine,
     group::{Curve, Group},
     pallas,
 };
-use std::any::{Any, TypeId};
+
+use darkfi::{
+    crypto::{keypair::PublicKey, merkle_node::MerkleNode, types::DrkCircuitField},
+    Error as DarkFiError,
+};
 
 use crate::{
     dao_contract,

bin/daod/src/dao_contract/propose/wallet.rs

@@ -1,3 +1,4 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_proofs::circuit::Value;
 use incrementalmerkletree::Hashable;
 use pasta_curves::{
@@ -14,7 +15,6 @@ use darkfi::{
         util::{pedersen_commitment_u64, poseidon_hash},
         Proof,
     },
-    serial::{SerialDecodable, SerialEncodable},
     zk::vm::{Witness, ZkCircuit},
 };
 

bin/daod/src/dao_contract/state.rs

@@ -1,12 +1,10 @@
 use std::{any::Any, collections::HashMap};
 
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use incrementalmerkletree::{bridgetree::BridgeTree, Tree};
 use pasta_curves::{group::Group, pallas};
 
-use darkfi::{
-    crypto::{constants::MERKLE_DEPTH, merkle_node::MerkleNode, nullifier::Nullifier},
-    serial::{SerialDecodable, SerialEncodable},
-};
+use darkfi::crypto::{constants::MERKLE_DEPTH, merkle_node::MerkleNode, nullifier::Nullifier};
 
 use crate::demo::HashableBase;
 

bin/daod/src/dao_contract/vote/validate.rs

@@ -1,17 +1,19 @@
-use darkfi::{
-    crypto::{
-        keypair::PublicKey, merkle_node::MerkleNode, nullifier::Nullifier, types::DrkCircuitField,
-    },
-    serial::{Encodable, SerialDecodable, SerialEncodable},
-    Error as DarkFiError,
-};
+use std::any::{Any, TypeId};
+
+use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use log::error;
 use pasta_curves::{
     arithmetic::CurveAffine,
     group::{Curve, Group},
     pallas,
 };
-use std::any::{Any, TypeId};
+
+use darkfi::{
+    crypto::{
+        keypair::PublicKey, merkle_node::MerkleNode, nullifier::Nullifier, types::DrkCircuitField,
+    },
+    Error as DarkFiError,
+};
 
 use crate::{
     dao_contract,

bin/daod/src/dao_contract/vote/wallet.rs

@@ -1,3 +1,14 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
+use halo2_proofs::circuit::Value;
+use incrementalmerkletree::Hashable;
+use log::debug;
+use pasta_curves::{
+    arithmetic::CurveAffine,
+    group::{ff::Field, Curve},
+    pallas,
+};
+use rand::rngs::OsRng;
+
 use darkfi::{
     crypto::{
         keypair::{Keypair, PublicKey, SecretKey},
@@ -6,17 +17,8 @@ use darkfi::{
         util::{pedersen_commitment_u64, poseidon_hash},
         Proof,
     },
-    serial::{SerialDecodable, SerialEncodable},
     zk::vm::{Witness, ZkCircuit},
 };
-use halo2_proofs::circuit::Value;
-use incrementalmerkletree::Hashable;
-use pasta_curves::{
-    arithmetic::CurveAffine,
-    group::{ff::Field, Curve},
-    pallas,
-};
-use rand::rngs::OsRng;
 
 use crate::{
     dao_contract::{
@@ -29,8 +31,6 @@ use crate::{
     money_contract, note,
 };
 
-use log::debug;
-
 #[derive(SerialEncodable, SerialDecodable)]
 pub struct Note {
     pub vote: Vote,

bin/daod/src/demo.rs

@@ -6,6 +6,7 @@ use std::{
     time::Instant,
 };
 
+use darkfi_serial::Encodable;
 use incrementalmerkletree::Tree;
 use log::debug;
 use pasta_curves::{
@@ -27,7 +28,6 @@ use darkfi::{
         util::{pedersen_commitment_u64, poseidon_hash},
         Proof,
     },
-    serial::Encodable,
     zk::{
         circuit::{BurnContract, MintContract},
         vm::ZkCircuit,

bin/daod/src/example_contract/foo/validate.rs

@@ -1,8 +1,8 @@
+use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use pasta_curves::pallas;
 
 use darkfi::{
     crypto::{keypair::PublicKey, types::DrkCircuitField},
-    serial::{Encodable, SerialDecodable, SerialEncodable},
     Error as DarkFiError,
 };
 

bin/daod/src/money_contract/transfer/validate.rs

@@ -1,8 +1,8 @@
 use std::any::{Any, TypeId};
 
+use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use incrementalmerkletree::Tree;
 use log::{debug, error};
-
 use pasta_curves::{group::Group, pallas};
 
 use darkfi::{
@@ -15,7 +15,6 @@ use darkfi::{
         util::{pedersen_commitment_base, pedersen_commitment_u64},
         BurnRevealedValues, MintRevealedValues,
     },
-    serial::{Encodable, SerialDecodable, SerialEncodable},
     Error as DarkFiError,
 };
 

bin/daod/src/money_contract/transfer/wallet.rs

@@ -1,3 +1,4 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use pasta_curves::group::ff::Field;
 use rand::rngs::OsRng;
 
@@ -12,7 +13,6 @@ use darkfi::{
             DrkValueBlind,
         },
     },
-    serial::{SerialDecodable, SerialEncodable},
     Result,
 };
 

bin/daod/src/note.rs

@@ -1,4 +1,5 @@
 use crypto_api_chachapoly::ChachaPolyIetf;
+use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable};
 use rand::rngs::OsRng;
 
 use darkfi::{
@@ -6,7 +7,6 @@ use darkfi::{
         diffie_hellman::{kdf_sapling, sapling_ka_agree},
         keypair::{PublicKey, SecretKey},
     },
-    serial::{Decodable, Encodable, SerialDecodable, SerialEncodable},
     Error, Result,
 };
 

bin/darkfid/Cargo.toml

@@ -16,6 +16,7 @@ bs58 = "0.4.0"
 chrono = "0.4.22"
 ctrlc = { version = "3.2.3", features = ["termination"] }
 darkfi = {path = "../../", features = ["blockchain", "wallet", "rpc", "net", "node"]}
+darkfi-serial = {path = "../../src/serial"}
 easy-parallel = "3.2.0"
 fxhash = "0.2.1"
 incrementalmerkletree = "0.3.0"

bin/darkfid/src/rpc_tx.rs

@@ -1,12 +1,12 @@
 use std::str::FromStr;
 
+use darkfi_serial::{deserialize, serialize};
 use log::{error, warn};
 use serde_json::{json, Value};
 
 use darkfi::{
     crypto::{address::Address, keypair::PublicKey, token_id},
     rpc::jsonrpc::{ErrorCode::InvalidParams, JsonError, JsonResponse, JsonResult},
-    serial::{deserialize, serialize},
     tx::Transaction,
 };
 

bin/darkfid/src/rpc_wallet.rs

@@ -1,3 +1,4 @@
+use darkfi_serial::{deserialize, serialize};
 use fxhash::FxHashMap;
 use incrementalmerkletree::Tree;
 use log::error;
@@ -15,7 +16,6 @@ use darkfi::{
         ErrorCode::{InternalError, InvalidParams, ParseError},
         JsonError, JsonResponse, JsonResult,
     },
-    serial::{deserialize, serialize},
 };
 
 use super::Darkfid;

bin/darkotc/Cargo.toml

@@ -13,6 +13,7 @@ async-std = {version = "1.12.0", features = ["attributes"]}
 bs58 = "0.4.0"
 clap = {version = "3.2.20", features = ["derive"]}
 darkfi = {path = "../../", features = ["crypto", "rpc", "util", "tx"]}
+darkfi-serial = {path = "../../src/serial"}
 halo2_proofs = "0.2.0"
 halo2_gadgets = "0.2.0"
 rand = "0.8.5"

bin/darkotc/src/main.rs

@@ -4,6 +4,7 @@ use std::{
 };
 
 use clap::{Parser, Subcommand};
+use darkfi_serial::{deserialize, serialize, SerialDecodable, SerialEncodable};
 use halo2_proofs::{arithmetic::Field, pasta::group::ff::PrimeField};
 use rand::rngs::OsRng;
 use url::Url;
@@ -27,7 +28,6 @@ use darkfi::{
         BurnRevealedValues, MintRevealedValues, Proof,
     },
     rpc::client::RpcClient,
-    serial::{deserialize, serialize, Encodable, SerialDecodable, SerialEncodable},
     tx::{
         partial::{PartialTransaction, PartialTransactionInput},
         Transaction, TransactionInput, TransactionOutput,
@@ -425,8 +425,7 @@ async fn join(endpoint: Url, d0: PartialSwapData, d1: PartialSwapData) -> Result
     let outputs = vec![output0, output1];
 
     let partial_tx = PartialTransaction { clear_inputs: vec![], inputs, outputs };
-    let mut unsigned_tx_data = vec![];
-    partial_tx.encode(&mut unsigned_tx_data)?;
+    let unsigned_tx_data = serialize(&partial_tx);
 
     let mut inputs = vec![];
     let mut signed: bool;

bin/darkotc/src/rpc.rs

@@ -1,5 +1,6 @@
 use std::{process::exit, str::FromStr};
 
+use darkfi_serial::{deserialize, serialize};
 use serde_json::json;
 
 use darkfi::{
@@ -10,7 +11,6 @@ use darkfi::{
         note::{EncryptedNote, Note},
     },
     rpc::{client::RpcClient, jsonrpc::JsonRequest},
-    serial::{deserialize, serialize},
     Result,
 };
 

bin/darkwiki/darkwikid/Cargo.toml

@@ -9,13 +9,12 @@ license = "AGPL-3.0-only"
 edition = "2021"
 
 [dependencies]
-async-channel = "1.7.1"
-async-executor = "1.4.1"
 async-std = "1.12.0"
 async-trait = "0.1.57"
 blake3 = "1.3.1"
 bs58 = "0.4.0"
 darkfi = {path = "../../../", features = ["raft", "rpc", "util"]}
+darkfi-serial = {path = "../../../src/serial"}
 dryoc = "0.3.14"
 easy-parallel = "3.2.0"
 futures = "0.3.24"

bin/darkwiki/darkwikid/src/jsonrpc.rs

@@ -13,8 +13,8 @@ use darkfi::{
 use crate::Patch;
 
 pub struct JsonRpcInterface {
-    sender: async_channel::Sender<(String, bool, Vec<String>)>,
-    receiver: async_channel::Receiver<Vec<Vec<Patch>>>,
+    sender: smol::channel::Sender<(String, bool, Vec<String>)>,
+    receiver: smol::channel::Receiver<Vec<Vec<Patch>>>,
 }
 
 #[async_trait]
@@ -54,8 +54,8 @@ fn printable_patches(
 
 impl JsonRpcInterface {
     pub fn new(
-        sender: async_channel::Sender<(String, bool, Vec<String>)>,
-        receiver: async_channel::Receiver<Vec<Vec<Patch>>>,
+        sender: smol::channel::Sender<(String, bool, Vec<String>)>,
+        receiver: smol::channel::Receiver<Vec<Vec<Patch>>>,
     ) -> Self {
         Self { sender, receiver }
     }

bin/darkwiki/darkwikid/src/main.rs

@@ -102,10 +102,10 @@ struct DarkWiki {
     settings: DarkWikiSettings,
     #[allow(clippy::type_complexity)]
     rpc: (
-        async_channel::Sender<Vec<Vec<Patch>>>,
-        async_channel::Receiver<(String, bool, Vec<String>)>,
+        smol::channel::Sender<Vec<Vec<Patch>>>,
+        smol::channel::Receiver<(String, bool, Vec<String>)>,
     ),
-    raft: (async_channel::Sender<EncryptedPatch>, async_channel::Receiver<EncryptedPatch>),
+    raft: (smol::channel::Sender<EncryptedPatch>, smol::channel::Receiver<EncryptedPatch>),
 }
 
 impl DarkWiki {
@@ -483,7 +483,7 @@ impl DarkWiki {
 async fn handle_signals(
     mut signals: Signals,
     cfg_path: PathBuf,
-    term_tx: async_channel::Sender<()>,
+    term_tx: smol::channel::Sender<()>,
 ) {
     debug!("Started signal handler");
     while let Some(signal) = signals.next().await {
@@ -558,7 +558,7 @@ async fn realmain(args: Args, executor: Arc<smol::Executor<'_>>) -> Result<()> {
     // Signal handling for config reload and graceful termination.
     let signals = Signals::new(&[SIGHUP, SIGTERM, SIGINT, SIGQUIT])?;
     let handle = signals.handle();
-    let (term_tx, term_rx) = async_channel::bounded::<()>(1);
+    let (term_tx, term_rx) = smol::channel::bounded::<()>(1);
     let signals_task = task::spawn(handle_signals(signals, cfg_path.clone(), term_tx));
     info!("Set up signal handling");
 
@@ -573,8 +573,8 @@ async fn realmain(args: Args, executor: Arc<smol::Executor<'_>>) -> Result<()> {
         }
     }
 
-    let (rpc_tx, rpc_rx) = async_channel::unbounded::<(String, bool, Vec<String>)>();
-    let (notify_tx, notify_rx) = async_channel::unbounded::<Vec<Vec<Patch>>>();
+    let (rpc_tx, rpc_rx) = smol::channel::unbounded::<(String, bool, Vec<String>)>();
+    let (notify_tx, notify_rx) = smol::channel::unbounded::<Vec<Vec<Patch>>>();
 
     // ===============
     // JSON-RPC server
@@ -597,7 +597,7 @@ async fn realmain(args: Args, executor: Arc<smol::Executor<'_>>) -> Result<()> {
     // =========
     let mut net_settings = args.net.clone();
     net_settings.app_version = Some(option_env!("CARGO_PKG_VERSION").unwrap_or("").to_string());
-    let (p2p_tx, p2p_rx) = async_channel::unbounded::<NetMsg>();
+    let (p2p_tx, p2p_rx) = smol::channel::unbounded::<NetMsg>();
     let p2p = net::P2p::new(net_settings.into()).await;
     let registry = p2p.protocol_registry();
 
@@ -627,7 +627,7 @@ async fn realmain(args: Args, executor: Arc<smol::Executor<'_>>) -> Result<()> {
         })
         .detach();
 
-    let (raft_term_tx, raft_term_rx) = async_channel::bounded::<()>(1);
+    let (raft_term_tx, raft_term_rx) = smol::channel::bounded::<()>(1);
     let _p2p = p2p.clone();
     let _ex = executor.clone();
     executor

bin/darkwiki/darkwikid/src/patch.rs

@@ -1,14 +1,12 @@
 use std::{cmp::Ordering, io};
 
+use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable, VarInt};
 use dryoc::constants::CRYPTO_SECRETBOX_NONCEBYTES;
 use serde::{Deserialize, Serialize};
 
-use darkfi::{
-    serial::{Decodable, Encodable, SerialDecodable, SerialEncodable, VarInt},
-    util::{
-        cli::{fg_green, fg_red},
-        time::Timestamp,
-    },
+use darkfi::util::{
+    cli::{fg_green, fg_red},
+    time::Timestamp,
 };
 
 use crate::util::str_to_chars;

bin/darkwiki/darkwikid/src/util.rs

@@ -3,6 +3,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use darkfi_serial::{deserialize, serialize};
 use dryoc::{
     classic::crypto_secretbox::{crypto_secretbox_easy, crypto_secretbox_open_easy, Key, Nonce},
     constants::CRYPTO_SECRETBOX_MACBYTES,
@@ -12,11 +13,7 @@ use fxhash::FxHashMap;
 use log::{error, info, warn};
 use unicode_segmentation::UnicodeSegmentation;
 
-use darkfi::{
-    serial::{deserialize, serialize},
-    util::path::expand_path,
-    Error, Result,
-};
+use darkfi::{util::path::expand_path, Error, Result};
 
 use crate::{Args, EncryptedPatch, Patch};
 

bin/faucetd/Cargo.toml

@@ -16,6 +16,7 @@ bs58 = "0.4.0"
 chrono = "0.4.22"
 ctrlc = { version = "3.2.3", features = ["termination"] }
 darkfi = {path = "../../", features = ["blockchain", "wallet", "rpc", "net", "node"]}
+darkfi-serial = {path = "../../src/serial"}
 easy-parallel = "3.2.0"
 hex = "0.4.3"
 lazy-init = "0.5.1"

bin/faucetd/src/main.rs

@@ -3,6 +3,7 @@ use std::{collections::HashMap, str::FromStr};
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
 use chrono::Utc;
+use darkfi_serial::serialize;
 use log::{debug, error, info};
 use serde_json::{json, Value};
 use structopt_toml::{serde::Deserialize, structopt::StructOpt, StructOptToml};
@@ -27,7 +28,6 @@ use darkfi::{
         },
         server::{listen_and_serve, RequestHandler},
     },
-    serial::serialize,
     util::{async_util::sleep, parse::decode_base10, path::expand_path},
     wallet::walletdb::init_wallet,
     Error, Result,

bin/fud/fud/Cargo.toml

@@ -12,6 +12,7 @@ categories = []
 
 [dependencies]
 darkfi = {path = "../../../", features = ["dht", "rpc"]}
+darkfi-serial = {path = "../../../src/serial"}
 
 # Async
 async-std = "1.12.0"

bin/fud/fud/src/main.rs

@@ -2,6 +2,7 @@ use std::{collections::HashSet, fs, path::PathBuf};
 
 use async_std::sync::Arc;
 use async_trait::async_trait;
+use darkfi_serial::serialize;
 use log::{debug, error, info, warn};
 use serde_json::{json, Value};
 use structopt_toml::{serde::Deserialize, structopt::StructOpt, StructOptToml};
@@ -18,7 +19,6 @@ use darkfi::{
         },
         server::{listen_and_serve, RequestHandler},
     },
-    serial::serialize,
     util::path::expand_path,
     Result,
 };

bin/ircd/Cargo.toml

@@ -12,6 +12,7 @@ categories = []
 
 [dependencies]
 darkfi = {path = "../../", features = ["net", "rpc", "bs58"]}
+darkfi-serial = {path = "../../src/serial"}
 
 # Async
 smol = "1.2.5"

bin/ircd/src/model.rs

@@ -1,13 +1,11 @@
 use std::{cmp::Ordering, fmt, io};
 
 use async_std::sync::Arc;
+use darkfi_serial::{Decodable, Encodable, ReadExt, SerialDecodable, SerialEncodable};
 use fxhash::FxHashMap;
 use ripemd::{Digest, Ripemd256};
 
-use darkfi::{
-    serial::{Decodable, Encodable, ReadExt, SerialDecodable, SerialEncodable},
-    Error, Result,
-};
+use darkfi::{Error, Result};
 
 use crate::settings::get_current_time;
 

bin/ircd/src/privmsg.rs

@@ -1,8 +1,7 @@
 use chrono::Utc;
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use rand::{rngs::OsRng, RngCore};
 
-use darkfi::serial::{SerialDecodable, SerialEncodable};
-
 pub type PrivmsgId = u64;
 
 #[derive(Debug, Clone, SerialEncodable, SerialDecodable, Eq, PartialEq)]

bin/ircd/src/protocol_privmsg.rs

@@ -1,13 +1,10 @@
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use log::debug;
 use smol::Executor;
 
-use darkfi::{
-    net,
-    serial::{SerialDecodable, SerialEncodable},
-    Result,
-};
+use darkfi::{net, Result};
 
 use crate::{buffers::SeenIds, Privmsg};
 

bin/ircd/src/protocol_privmsg2.rs

@@ -2,17 +2,13 @@ use std::collections::VecDeque;
 
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use fxhash::FxHashMap;
 use log::debug;
 use rand::{rngs::OsRng, RngCore};
 use smol::Executor;
 
-use darkfi::{
-    net,
-    serial::{SerialDecodable, SerialEncodable},
-    util::async_util::sleep,
-    Result,
-};
+use darkfi::{net, util::async_util::sleep, Result};
 
 use crate::{
     model::{Event, EventId, Model},

bin/ircd2/Cargo.toml

@@ -12,6 +12,7 @@ categories = []
 
 [dependencies]
 darkfi = {path = "../../", features = ["net", "rpc", "bs58"]}
+darkfi-serial = {path = "../../src/serial"}
 
 # Async
 smol = "1.2.5"

bin/ircd2/src/model.rs

@@ -1,11 +1,10 @@
 use std::{cmp::Ordering, fmt};
 
 use async_std::sync::{Arc, Mutex};
+use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use fxhash::FxHashMap;
 use ripemd::{Digest, Ripemd256};
 
-use darkfi::serial::{Encodable, SerialDecodable, SerialEncodable};
-
 use crate::{
     events_queue::EventsQueuePtr,
     privmsg::{EventAction, PrivMsgEvent},

bin/ircd2/src/privmsg.rs

@@ -1,6 +1,6 @@
 use std::io;
 
-use darkfi::serial::{Decodable, Encodable, ReadExt, SerialDecodable, SerialEncodable};
+use darkfi_serial::{Decodable, Encodable, ReadExt, SerialDecodable, SerialEncodable};
 
 #[derive(SerialEncodable, SerialDecodable, Clone)]
 pub struct PrivMsgEvent {

bin/ircd2/src/protocol_event.rs

@@ -2,16 +2,12 @@ use std::collections::VecDeque;
 
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use fxhash::FxHashMap;
 use log::debug;
 use rand::{rngs::OsRng, RngCore};
 
-use darkfi::{
-    net,
-    serial::{SerialDecodable, SerialEncodable},
-    util::async_util::sleep,
-    Result,
-};
+use darkfi::{net, util::async_util::sleep, Result};
 
 use crate::{
     model::{Event, EventId, ModelPtr},

bin/tau/taud/Cargo.toml

@@ -12,6 +12,7 @@ categories = []
 
 [dependencies]
 darkfi = { path = "../../../", features = ["rpc", "raft", "net", "bs58"]}
+darkfi-serial = { path = "../../../src/serial" }
 
 # Async
 smol = "1.2.5"

bin/tau/taud/src/main.rs

@@ -10,6 +10,7 @@ use crypto_box::{
     aead::{Aead, AeadCore},
     SalsaBox, SecretKey,
 };
+use darkfi_serial::{deserialize, serialize, SerialDecodable, SerialEncodable};
 use futures::{select, FutureExt};
 use fxhash::FxHashMap;
 use log::{debug, error, info, warn};
@@ -19,7 +20,6 @@ use darkfi::{
     async_daemonize, net,
     raft::{NetMsg, ProtocolRaft, Raft, RaftSettings},
     rpc::server::listen_and_serve,
-    serial::{deserialize, serialize, SerialDecodable, SerialEncodable},
     util::path::expand_path,
     Error, Result,
 };

bin/tau/taud/src/task_info.rs

@@ -1,15 +1,13 @@
 use std::path::{Path, PathBuf};
 
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use log::debug;
 use serde::{Deserialize, Serialize};
 
-use darkfi::{
-    serial::{SerialDecodable, SerialEncodable},
-    util::{
-        file::{load_json_file, save_json_file},
-        gen_id,
-        time::Timestamp,
-    },
+use darkfi::util::{
+    file::{load_json_file, save_json_file},
+    gen_id,
+    time::Timestamp,
 };
 
 use crate::{

src/blockchain/blockstore.rs

@@ -1,6 +1,7 @@
+use darkfi_serial::{deserialize, serialize};
+
 use crate::{
     consensus::{Block, Header},
-    serial::{deserialize, serialize},
     util::time::Timestamp,
     Error, Result,
 };

src/blockchain/metadatastore.rs

@@ -1,6 +1,7 @@
+use darkfi_serial::{deserialize, serialize};
+
 use crate::{
     consensus::{Block, Metadata},
-    serial::{deserialize, serialize},
     util::time::Timestamp,
     Error, Result,
 };

src/blockchain/nfstore.rs

@@ -1,8 +1,6 @@
-use crate::{
-    crypto::nullifier::Nullifier,
-    serial::{deserialize, serialize},
-    Result,
-};
+use darkfi_serial::{deserialize, serialize};
+
+use crate::{crypto::nullifier::Nullifier, Result};
 
 const SLED_NULLIFIER_TREE: &[u8] = b"_nullifiers";
 

src/blockchain/rootstore.rs

@@ -1,8 +1,6 @@
-use crate::{
-    crypto::merkle_node::MerkleNode,
-    serial::{deserialize, serialize},
-    Result,
-};
+use darkfi_serial::{deserialize, serialize};
+
+use crate::{crypto::merkle_node::MerkleNode, Result};
 
 const SLED_ROOTS_TREE: &[u8] = b"_merkleroots";
 

src/blockchain/statestore.rs

@@ -1,4 +1,6 @@
-use crate::{crypto::contract_id::ContractId, serial::serialize, Result};
+use darkfi_serial::serialize;
+
+use crate::{crypto::contract_id::ContractId, Result};
 
 const SLED_STATES_TREE: &[u8] = b"_states";
 

src/blockchain/txstore.rs

@@ -1,8 +1,6 @@
-use crate::{
-    serial::{deserialize, serialize},
-    tx::Transaction,
-    Error, Result,
-};
+use darkfi_serial::{deserialize, serialize};
+
+use crate::{tx::Transaction, Error, Result};
 
 const SLED_TX_TREE: &[u8] = b"_transactions";
 

src/consensus/block.rs

@@ -1,14 +1,14 @@
 use std::fmt;
 
-use super::{Metadata, BLOCK_MAGIC_BYTES, BLOCK_VERSION};
+use darkfi_serial::{serialize, SerialDecodable, SerialEncodable};
 use incrementalmerkletree::{bridgetree::BridgeTree, Tree};
 use log::debug;
 use pasta_curves::pallas;
 
+use super::{Metadata, BLOCK_MAGIC_BYTES, BLOCK_VERSION};
 use crate::{
     crypto::{constants::MERKLE_DEPTH, merkle_node::MerkleNode},
     net,
-    serial::{serialize, SerialDecodable, SerialEncodable},
     tx::Transaction,
     util::time::Timestamp,
 };

src/consensus/metadata.rs

@@ -1,6 +1,7 @@
-use super::Participant;
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use rand::rngs::OsRng;
 
+use super::Participant;
 use crate::{
     crypto::{
         address::Address,
@@ -11,7 +12,6 @@ use crate::{
         schnorr::Signature,
         types::*,
     },
-    serial::{SerialDecodable, SerialEncodable},
     VerifyResult,
 };
 

src/consensus/participant.rs

@@ -1,7 +1,8 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
+
 use crate::{
     crypto::{address::Address, keypair::PublicKey, schnorr::Signature},
     net,
-    serial::{SerialDecodable, SerialEncodable},
 };
 
 /// This struct represents a tuple of the form:

src/consensus/proto/protocol_keep_alive.rs

@@ -1,5 +1,4 @@
 use async_std::sync::Arc;
-
 use async_trait::async_trait;
 use log::{debug, error};
 use smol::Executor;

src/consensus/state.rs

@@ -7,6 +7,7 @@ use std::{
 
 use async_std::sync::{Arc, Mutex, RwLock};
 use chrono::{NaiveDateTime, Utc};
+use darkfi_serial::{serialize, SerialDecodable, SerialEncodable};
 use incrementalmerkletree::{bridgetree::BridgeTree, Tree};
 use lazy_init::Lazy;
 use log::{debug, error, info, warn};
@@ -31,7 +32,6 @@ use crate::{
         state::{state_transition, ProgramState, StateUpdate},
         Client, MemoryState, State,
     },
-    serial::{serialize, SerialDecodable, SerialEncodable},
     tx::Transaction,
     util::time::Timestamp,
     Result,

src/consensus/task/keep_alive.rs

@@ -1,4 +1,5 @@
 use async_std::sync::Arc;
+use darkfi_serial::serialize;
 use log::{debug, error};
 use rand::Rng;
 use smol::Executor;
@@ -7,7 +8,6 @@ use crate::{
     consensus::{state::QUARANTINE_DURATION, KeepAlive, ValidatorStatePtr},
     crypto::schnorr::SchnorrSecret,
     net::P2pPtr,
-    serial::serialize,
     util::async_util::sleep,
     Result,
 };

src/crypto/address.rs

@@ -1,12 +1,9 @@
 use std::str::FromStr;
 
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use sha2::Digest;
 
-use crate::{
-    crypto::keypair::PublicKey,
-    serial::{SerialDecodable, SerialEncodable},
-    Error, Result,
-};
+use crate::{crypto::keypair::PublicKey, Error, Result};
 
 enum AddressType {
     Payment = 0,

src/crypto/burn_proof.rs

@@ -1,9 +1,11 @@
+use std::time::Instant;
+
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_proofs::circuit::Value;
 use incrementalmerkletree::Hashable;
 use log::debug;
 use pasta_curves::{arithmetic::CurveAffine, group::Curve};
 use rand::rngs::OsRng;
-use std::time::Instant;
 
 use super::{
     nullifier::Nullifier,
@@ -20,7 +22,6 @@ use crate::{
         },
         util::poseidon_hash,
     },
-    serial::{SerialDecodable, SerialEncodable},
     zk::circuit::burn_contract::BurnContract,
     Result,
 };

src/crypto/coin.rs

@@ -1,7 +1,7 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use pasta_curves::{group::ff::PrimeField, pallas};
 
 use super::{keypair::SecretKey, note::Note, nullifier::Nullifier};
-use crate::serial::{SerialDecodable, SerialEncodable};
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, SerialEncodable, SerialDecodable)]
 pub struct Coin(pub pallas::Base);

src/crypto/contract_id.rs

@@ -1,10 +1,10 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use pasta_curves::pallas;
 
 use super::{
     keypair::{PublicKey, SecretKey},
     util::poseidon_hash,
 };
-use crate::serial::{SerialDecodable, SerialEncodable};
 
 /// Contract ID used to reference smart contracts on the ledger.
 #[repr(C)]

src/crypto/keypair.rs

@@ -1,5 +1,6 @@
-use std::{convert::TryFrom, io, str::FromStr};
+use std::{convert::TryFrom, str::FromStr};
 
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_gadgets::ecc::chip::FixedPoint;
 use pasta_curves::{
     arithmetic::CurveAffine,
@@ -13,13 +14,10 @@ use rand::RngCore;
 
 use crate::{
     crypto::{address::Address, constants::NullifierK, util::mod_r_p},
-    serial::{Decodable, Encodable, ReadExt, SerialDecodable, SerialEncodable, WriteExt},
     Error, Result,
 };
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-#[cfg(feature = "serde")]
-#[derive(serde::Deserialize, serde::Serialize)]
 pub struct Keypair {
     pub secret: SecretKey,
     pub public: PublicKey,
@@ -143,204 +141,3 @@ impl TryFrom<Address> for PublicKey {
         Self::from_bytes(&bytes)
     }
 }
-
-impl Encodable for pallas::Base {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        s.write_slice(&self.to_repr()[..])?;
-        Ok(32)
-    }
-}
-
-impl Decodable for pallas::Base {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let mut bytes = [0u8; 32];
-        d.read_slice(&mut bytes)?;
-        let result = pallas::Base::from_repr(bytes);
-        if result.is_some().into() {
-            Ok(result.unwrap())
-        } else {
-            Err(io::Error::new(io::ErrorKind::Other, "Failed to deserialize pallas::Base"))
-        }
-    }
-}
-
-impl Encodable for pallas::Scalar {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        s.write_slice(&self.to_repr()[..])?;
-        Ok(32)
-    }
-}
-
-impl Decodable for pallas::Scalar {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let mut bytes = [0u8; 32];
-        d.read_slice(&mut bytes)?;
-        let result = pallas::Scalar::from_repr(bytes);
-        if result.is_some().into() {
-            Ok(result.unwrap())
-        } else {
-            Err(io::Error::new(io::ErrorKind::Other, "Failed to deserialize pallas::Scalar"))
-        }
-    }
-}
-
-impl Encodable for pallas::Point {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        s.write_slice(&self.to_bytes()[..])?;
-        Ok(32)
-    }
-}
-
-impl Decodable for pallas::Point {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let mut bytes = [0u8; 32];
-        d.read_slice(&mut bytes)?;
-        let result = Self::from_bytes(&bytes);
-        if result.is_some().into() {
-            Ok(result.unwrap())
-        } else {
-            Err(io::Error::new(io::ErrorKind::Other, "Failed to deserialize pallas::Point"))
-        }
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for SecretKey {
-    fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut bytes = vec![];
-        self.encode(&mut bytes).unwrap();
-        let hex_repr = hex::encode(&bytes);
-        serializer.serialize_str(&hex_repr)
-    }
-}
-
-#[cfg(feature = "serde")]
-struct SecretKeyVisitor;
-
-#[cfg(feature = "serde")]
-impl<'de> serde::de::Visitor<'de> for SecretKeyVisitor {
-    type Value = SecretKey;
-
-    fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
-        formatter.write_str("hex string")
-    }
-
-    fn visit_str<E>(self, value: &str) -> core::result::Result<SecretKey, E>
-    where
-        E: serde::de::Error,
-    {
-        let bytes = hex::decode(value).unwrap();
-        let mut r = std::io::Cursor::new(bytes);
-        let decoded: SecretKey = SecretKey::decode(&mut r).unwrap();
-        Ok(decoded)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for SecretKey {
-    fn deserialize<D>(deserializer: D) -> core::result::Result<SecretKey, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let bytes = deserializer.deserialize_str(SecretKeyVisitor).unwrap();
-        Ok(bytes)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for PublicKey {
-    fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut bytes = vec![];
-        self.encode(&mut bytes).unwrap();
-        let hex_repr = hex::encode(&bytes);
-        serializer.serialize_str(&hex_repr)
-    }
-}
-
-#[cfg(feature = "serde")]
-struct PublicKeyVisitor;
-
-#[cfg(feature = "serde")]
-impl<'de> serde::de::Visitor<'de> for PublicKeyVisitor {
-    type Value = PublicKey;
-
-    fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
-        formatter.write_str("hex string")
-    }
-
-    fn visit_str<E>(self, value: &str) -> core::result::Result<PublicKey, E>
-    where
-        E: serde::de::Error,
-    {
-        let bytes = hex::decode(value).unwrap();
-        let mut r = std::io::Cursor::new(bytes);
-        let decoded: PublicKey = PublicKey::decode(&mut r).unwrap();
-        Ok(decoded)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for PublicKey {
-    fn deserialize<D>(deserializer: D) -> core::result::Result<PublicKey, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let bytes = deserializer.deserialize_str(PublicKeyVisitor).unwrap();
-        Ok(bytes)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{
-        crypto::util::pedersen_commitment_base,
-        serial::{deserialize, serialize},
-    };
-
-    #[test]
-    fn test_pasta_serialization() -> Result<()> {
-        let fifty_five = pallas::Base::from(55);
-        let serialized = serialize(&fifty_five);
-        assert_eq!(
-            serialized,
-            vec![
-                55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0
-            ]
-        );
-        assert_eq!(deserialize(&serialized).ok(), Some(fifty_five));
-
-        let fourtwenty = pallas::Scalar::from(42069);
-        let serialized = serialize(&fourtwenty);
-        assert_eq!(
-            serialized,
-            vec![
-                85, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0
-            ]
-        );
-        assert_eq!(deserialize(&serialized).ok(), Some(fourtwenty));
-
-        let a = pallas::Base::from(420);
-        let b = pallas::Scalar::from(69);
-        let pc: pallas::Point = pedersen_commitment_base(a, b);
-        let serialized = serialize(&pc);
-        assert_eq!(
-            serialized,
-            vec![
-                57, 232, 32, 239, 229, 119, 41, 70, 218, 174, 237, 25, 122, 81, 81, 252, 54, 192,
-                225, 207, 145, 124, 177, 46, 28, 37, 55, 70, 6, 33, 51, 42,
-            ]
-        );
-        assert_eq!(deserialize(&serialized).ok(), Some(pc));
-
-        Ok(())
-    }
-}

src/crypto/merkle_node.rs

@@ -1,5 +1,6 @@
-use std::{io, iter};
+use std::iter;
 
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_gadgets::sinsemilla::primitives::HashDomain;
 use incrementalmerkletree::{Altitude, Hashable};
 use lazy_static::lazy_static;
@@ -14,15 +15,12 @@ use serde::{
 };
 use subtle::{Choice, ConditionallySelectable};
 
-use crate::{
-    crypto::{
-        coin::Coin,
-        constants::{
-            sinsemilla::{i2lebsp_k, L_ORCHARD_MERKLE, MERKLE_CRH_PERSONALIZATION},
-            MERKLE_DEPTH_ORCHARD,
-        },
+use crate::crypto::{
+    coin::Coin,
+    constants::{
+        sinsemilla::{i2lebsp_k, L_ORCHARD_MERKLE, MERKLE_CRH_PERSONALIZATION},
+        MERKLE_DEPTH_ORCHARD,
     },
-    serial::{Decodable, Encodable, SerialDecodable, SerialEncodable},
 };
 
 lazy_static! {
@@ -120,163 +118,3 @@ impl Hashable for MerkleNode {
         EMPTY_ROOTS[<usize>::from(altitude)]
     }
 }
-
-impl Encodable for incrementalmerkletree::Position {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        u64::from(*self).encode(&mut s)
-    }
-}
-
-impl Decodable for incrementalmerkletree::Position {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let dec: u64 = Decodable::decode(&mut d)?;
-        Ok(Self::try_from(dec).unwrap())
-    }
-}
-
-impl Encodable for incrementalmerkletree::bridgetree::Leaf<MerkleNode> {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        let mut len = 0;
-
-        match self {
-            incrementalmerkletree::bridgetree::Leaf::Left(a) => {
-                len += false.encode(&mut s)?;
-                len += a.encode(&mut s)?;
-            }
-
-            incrementalmerkletree::bridgetree::Leaf::Right(a, b) => {
-                len += true.encode(&mut s)?;
-                len += a.encode(&mut s)?;
-                len += b.encode(&mut s)?;
-            }
-        }
-
-        Ok(len)
-    }
-}
-
-impl Decodable for incrementalmerkletree::bridgetree::Leaf<MerkleNode> {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let side: bool = Decodable::decode(&mut d)?;
-
-        match side {
-            false => {
-                let a: MerkleNode = Decodable::decode(&mut d)?;
-                Ok(Self::Left(a))
-            }
-            true => {
-                let a: MerkleNode = Decodable::decode(&mut d)?;
-                let b: MerkleNode = Decodable::decode(&mut d)?;
-                Ok(Self::Right(a, b))
-            }
-        }
-    }
-}
-
-impl Encodable for incrementalmerkletree::bridgetree::Checkpoint {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        let mut len = 0;
-        len += self.bridges_len().encode(&mut s)?;
-        len += self.is_witnessed().encode(&mut s)?;
-        len += self.witnessed().encode(&mut s)?;
-        len += self.forgotten().encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for incrementalmerkletree::bridgetree::Checkpoint {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let bridges_len = Decodable::decode(&mut d)?;
-        let is_witnessed = Decodable::decode(&mut d)?;
-        let witnessed = Decodable::decode(&mut d)?;
-        let forgotten = Decodable::decode(&mut d)?;
-        Ok(Self::from_parts(bridges_len, is_witnessed, witnessed, forgotten))
-    }
-}
-
-impl Encodable for incrementalmerkletree::bridgetree::NonEmptyFrontier<MerkleNode> {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        let mut len = 0;
-        len += self.position().encode(&mut s)?;
-        len += self.leaf().encode(&mut s)?;
-        len += self.ommers().to_vec().encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for incrementalmerkletree::bridgetree::NonEmptyFrontier<MerkleNode> {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let position = Decodable::decode(&mut d)?;
-        let leaf = Decodable::decode(&mut d)?;
-        let ommers = Decodable::decode(&mut d)?;
-
-        match Self::from_parts(position, leaf, ommers) {
-            Ok(v) => Ok(v),
-            Err(_) => Err(io::Error::new(io::ErrorKind::Other, "FrontierError")),
-        }
-    }
-}
-
-impl Encodable for incrementalmerkletree::bridgetree::AuthFragment<MerkleNode> {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        let mut len = 0;
-        len += self.position().encode(&mut s)?;
-        len += self.altitudes_observed().encode(&mut s)?;
-        len += self.values().to_vec().encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for incrementalmerkletree::bridgetree::AuthFragment<MerkleNode> {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let position = Decodable::decode(&mut d)?;
-        let altitudes_observed = Decodable::decode(&mut d)?;
-        let values = Decodable::decode(&mut d)?;
-        Ok(Self::from_parts(position, altitudes_observed, values))
-    }
-}
-
-impl Encodable for incrementalmerkletree::bridgetree::MerkleBridge<MerkleNode> {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        let mut len = 0;
-        len += self.prior_position().encode(&mut s)?;
-        len += self.auth_fragments().encode(&mut s)?;
-        len += self.frontier().encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for incrementalmerkletree::bridgetree::MerkleBridge<MerkleNode> {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let prior_position = Decodable::decode(&mut d)?;
-        let auth_fragments = Decodable::decode(&mut d)?;
-        let frontier = Decodable::decode(&mut d)?;
-        Ok(Self::from_parts(prior_position, auth_fragments, frontier))
-    }
-}
-
-impl Encodable for incrementalmerkletree::bridgetree::BridgeTree<MerkleNode, 32> {
-    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
-        let mut len = 0;
-        len += self.prior_bridges().to_vec().encode(&mut s)?;
-        len += self.current_bridge().encode(&mut s)?;
-        len += self.witnessed_indices().encode(&mut s)?;
-        len += self.checkpoints().to_vec().encode(&mut s)?;
-        len += self.max_checkpoints().encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for incrementalmerkletree::bridgetree::BridgeTree<MerkleNode, 32> {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let prior_bridges = Decodable::decode(&mut d)?;
-        let current_bridge = Decodable::decode(&mut d)?;
-        let saved = Decodable::decode(&mut d)?;
-        let checkpoints = Decodable::decode(&mut d)?;
-        let max_checkpoints = Decodable::decode(&mut d)?;
-        match Self::from_parts(prior_bridges, current_bridge, saved, checkpoints, max_checkpoints) {
-            Ok(v) => Ok(v),
-            Err(_) => Err(io::Error::new(io::ErrorKind::Other, "BridgeTreeError")),
-        }
-    }
-}

src/crypto/mint_proof.rs

@@ -1,5 +1,6 @@
 use std::time::Instant;
 
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_proofs::circuit::Value;
 use log::debug;
 use pasta_curves::{arithmetic::CurveAffine, group::Curve};
@@ -16,7 +17,6 @@ use crate::{
         },
         util::{pedersen_commitment_base, pedersen_commitment_u64, poseidon_hash},
     },
-    serial::{SerialDecodable, SerialEncodable},
     zk::circuit::mint_contract::MintContract,
     Result,
 };

src/crypto/note.rs

@@ -1,4 +1,5 @@
 use crypto_api_chachapoly::ChachaPolyIetf;
+use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable};
 use rand::rngs::OsRng;
 
 use crate::{
@@ -7,7 +8,6 @@ use crate::{
         keypair::{PublicKey, SecretKey},
         types::{DrkCoinBlind, DrkSerial, DrkTokenId, DrkValueBlind},
     },
-    serial::{Decodable, Encodable, SerialDecodable, SerialEncodable},
     Error, Result,
 };
 
@@ -58,6 +58,7 @@ impl EncryptedNote {
         let key = kdf_sapling(&shared_secret, &self.ephem_public);
 
         let mut plaintext = vec![0; self.ciphertext.len()];
+
         assert_eq!(
             ChachaPolyIetf::aead_cipher()
                 .open_to(&mut plaintext, &self.ciphertext, &[], key.as_ref(), &[0u8; 12])

src/crypto/nullifier.rs

@@ -1,7 +1,6 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use pasta_curves::{group::ff::PrimeField, pallas};
 
-use crate::serial::{SerialDecodable, SerialEncodable};
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, SerialEncodable, SerialDecodable)]
 pub struct Nullifier(pallas::Base);
 

src/crypto/proof.rs

@@ -1,3 +1,4 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_proofs::{
     plonk,
     plonk::{Circuit, SingleVerifier},
@@ -7,10 +8,7 @@ use halo2_proofs::{
 use pasta_curves::vesta;
 use rand::RngCore;
 
-use crate::{
-    crypto::types::DrkCircuitField,
-    serial::{SerialDecodable, SerialEncodable},
-};
+use crate::crypto::types::DrkCircuitField;
 
 // TODO: this API needs rework. It's not very good.
 // keygen_pk() takes a VerifyingKey by value,

src/crypto/schnorr.rs

@@ -1,3 +1,4 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_gadgets::ecc::chip::FixedPoint;
 use pasta_curves::{
     group::{ff::Field, Group, GroupEncoding},
@@ -5,13 +6,10 @@ use pasta_curves::{
 };
 use rand::rngs::OsRng;
 
-use crate::{
-    crypto::{
-        constants::{NullifierK, DRK_SCHNORR_DOMAIN},
-        keypair::{PublicKey, SecretKey},
-        util::{hash_to_scalar, mod_r_p},
-    },
-    serial::{Decodable, Encodable, SerialDecodable, SerialEncodable},
+use crate::crypto::{
+    constants::{NullifierK, DRK_SCHNORR_DOMAIN},
+    keypair::{PublicKey, SecretKey},
+    util::{hash_to_scalar, mod_r_p},
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, SerialEncodable, SerialDecodable)]
@@ -53,52 +51,6 @@ impl SchnorrPublic for PublicKey {
     }
 }
 
-#[cfg(feature = "serde")]
-impl serde::Serialize for Signature {
-    fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut bytes = vec![];
-        self.encode(&mut bytes).unwrap();
-        let hex_repr = hex::encode(&bytes);
-        serializer.serialize_str(&hex_repr)
-    }
-}
-
-#[cfg(feature = "serde")]
-struct SignatureVisitor;
-
-#[cfg(feature = "serde")]
-impl<'de> serde::de::Visitor<'de> for SignatureVisitor {
-    type Value = Signature;
-
-    fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
-        formatter.write_str("hex string")
-    }
-
-    fn visit_str<E>(self, value: &str) -> core::result::Result<Signature, E>
-    where
-        E: serde::de::Error,
-    {
-        let bytes = hex::decode(value).unwrap();
-        let mut r = std::io::Cursor::new(bytes);
-        let decoded: Signature = Signature::decode(&mut r).unwrap();
-        Ok(decoded)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for Signature {
-    fn deserialize<D>(deserializer: D) -> core::result::Result<Signature, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let bytes = deserializer.deserialize_str(SignatureVisitor).unwrap();
-        Ok(bytes)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/dht/messages.rs

@@ -1,11 +1,9 @@
-use fxhash::FxHashMap;
+use std::collections::{HashMap, HashSet};
+
+use darkfi_serial::{serialize, SerialDecodable, SerialEncodable};
 use rand::Rng;
-use std::collections::HashSet;
 
-use crate::{
-    net,
-    serial::{serialize, SerialDecodable, SerialEncodable},
-};
+use crate::net;
 
 /// This struct represents a DHT key request
 #[derive(Debug, Clone, SerialDecodable, SerialEncodable)]
@@ -127,11 +125,11 @@ pub struct LookupMapResponse {
     /// Request id
     pub id: blake3::Hash,
     /// Daemon lookup map, containing nodes that holds each key
-    pub lookup: FxHashMap<blake3::Hash, HashSet<blake3::Hash>>,
+    pub lookup: HashMap<blake3::Hash, HashSet<blake3::Hash>>,
 }
 
 impl LookupMapResponse {
-    pub fn new(lookup: FxHashMap<blake3::Hash, HashSet<blake3::Hash>>) -> Self {
+    pub fn new(lookup: HashMap<blake3::Hash, HashSet<blake3::Hash>>) -> Self {
         // Generate a random id
         let mut rng = rand::thread_rng();
         let n: u16 = rng.gen();

src/dht/mod.rs

@@ -1,9 +1,9 @@
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
 use async_std::sync::{Arc, RwLock};
 use chrono::Utc;
+use darkfi_serial::serialize;
 use futures::{select, FutureExt};
-use fxhash::FxHashMap;
 use log::{debug, error, warn};
 use rand::Rng;
 use smol::Executor;
@@ -11,7 +11,6 @@ use smol::Executor;
 use crate::{
     net,
     net::P2pPtr,
-    serial::serialize,
     util::async_util::sleep,
     Error::{NetworkNotConnected, UnknownKey},
     Result,
@@ -38,9 +37,9 @@ pub struct Dht {
     /// Daemon id
     pub id: blake3::Hash,
     /// Daemon hasmap
-    pub map: FxHashMap<blake3::Hash, Vec<u8>>,
+    pub map: HashMap<blake3::Hash, Vec<u8>>,
     /// Network lookup map, containing nodes that holds each key
-    pub lookup: FxHashMap<blake3::Hash, HashSet<blake3::Hash>>,
+    pub lookup: HashMap<blake3::Hash, HashSet<blake3::Hash>>,
     /// P2P network pointer
     pub p2p: P2pPtr,
     /// Channel to receive responses from P2P
@@ -49,12 +48,12 @@ pub struct Dht {
     stop_signal: smol::channel::Receiver<()>,
     /// Daemon seen requests/responses ids and timestamp,
     /// to prevent rebroadcasting and loops
-    pub seen: FxHashMap<blake3::Hash, i64>,
+    pub seen: HashMap<blake3::Hash, i64>,
 }
 
 impl Dht {
     pub async fn new(
-        initial: Option<FxHashMap<blake3::Hash, HashSet<blake3::Hash>>>,
+        initial: Option<HashMap<blake3::Hash, HashSet<blake3::Hash>>>,
         p2p_ptr: P2pPtr,
         stop_signal: smol::channel::Receiver<()>,
         ex: Arc<Executor<'_>>,
@@ -63,14 +62,14 @@ impl Dht {
         let mut rng = rand::thread_rng();
         let n: u16 = rng.gen();
         let id = blake3::hash(&serialize(&n));
-        let map = FxHashMap::default();
+        let map = HashMap::default();
         let lookup = match initial {
             Some(l) => l,
-            None => FxHashMap::default(),
+            None => HashMap::default(),
         };
         let p2p = p2p_ptr.clone();
         let (p2p_send_channel, p2p_recv_channel) = smol::channel::unbounded::<KeyResponse>();
-        let seen = FxHashMap::default();
+        let seen = HashMap::default();
 
         let dht = Arc::new(RwLock::new(Dht {
             id,

src/net/acceptor.rs

@@ -1,20 +1,19 @@
-use async_std::sync::{Arc, Mutex};
 use std::{env, fs};
 
+use async_std::sync::{Arc, Mutex};
 use log::{error, info};
 use smol::Executor;
 use url::Url;
 
+use super::{
+    transport::{TcpTransport, TorTransport, Transport, TransportListener, TransportName},
+    Channel, ChannelPtr, SessionWeakPtr,
+};
 use crate::{
     system::{StoppableTask, StoppableTaskPtr, Subscriber, SubscriberPtr, Subscription},
     Error, Result,
 };
 
-use super::{
-    Channel, ChannelPtr, SessionWeakPtr, TcpTransport, TorTransport, Transport, TransportListener,
-    TransportName,
-};
-
 /// Atomic pointer to Acceptor class.
 pub type AcceptorPtr = Arc<Acceptor>;
 

src/net/channel.rs

@@ -1,5 +1,4 @@
 use async_std::sync::{Arc, Mutex};
-
 use futures::{
     io::{ReadHalf, WriteHalf},
     AsyncReadExt,
@@ -10,18 +9,18 @@ use serde_json::json;
 use smol::Executor;
 use url::Url;
 
+use super::{
+    message,
+    message_subscriber::{MessageSubscription, MessageSubsystem},
+    transport::TransportStream,
+    Session, SessionBitflag, SessionWeakPtr,
+};
 use crate::{
     system::{StoppableTask, StoppableTaskPtr, Subscriber, SubscriberPtr, Subscription},
     util::time::NanoTimestamp,
     Error, Result,
 };
 
-use super::{
-    message,
-    message_subscriber::{MessageSubscription, MessageSubsystem},
-    Session, SessionBitflag, SessionWeakPtr, TransportStream,
-};
-
 /// Atomic pointer to async channel.
 pub type ChannelPtr = Arc<Channel>;
 

src/net/connector.rs

@@ -1,15 +1,14 @@
-use async_std::sync::Arc;
 use std::{env, time::Duration};
 
+use async_std::sync::Arc;
 use log::error;
 use url::Url;
 
-use crate::{Error, Result};
-
 use super::{
-    Channel, ChannelPtr, SessionWeakPtr, SettingsPtr, TcpTransport, TorTransport, Transport,
-    TransportName,
+    transport::{TcpTransport, TorTransport, Transport, TransportName},
+    Channel, ChannelPtr, SessionWeakPtr, SettingsPtr,
 };
+use crate::{Error, Result};
 
 /// Create outbound socket connections.
 pub struct Connector {

src/net/message.rs

@@ -1,11 +1,9 @@
+use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable, VarInt};
 use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use log::debug;
 use url::Url;
 
-use crate::{
-    serial::{Decodable, Encodable, SerialDecodable, SerialEncodable, VarInt},
-    Error, Result,
-};
+use crate::{Error, Result};
 
 const MAGIC_BYTES: [u8; 4] = [0xd9, 0xef, 0xb6, 0x7d];
 

src/net/mod.rs

@@ -104,30 +104,3 @@ pub use session::{
     SESSION_OUTBOUND, SESSION_SEED,
 };
 pub use settings::{Settings, SettingsPtr};
-pub use transport::{
-    TcpTransport, TorTransport, Transport, TransportListener, TransportName, TransportStream,
-    UnixTransport,
-};
-
-// Relevant serializations
-use crate::serial::{Decodable, Encodable};
-use std::io;
-
-impl Encodable for url::Url {
-    fn encode<S: io::Write>(&self, s: S) -> core::result::Result<usize, io::Error> {
-        let mut len = 0;
-        len += self.as_str().to_string().encode(s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for url::Url {
-    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
-        let url_str: String = Decodable::decode(&mut d)?;
-        let url = match url::Url::parse(&url_str) {
-            Ok(v) => v,
-            Err(e) => return Err(io::Error::new(io::ErrorKind::Other, e)),
-        };
-        Ok(url)
-    }
-}

src/net/session/manual_session.rs

@@ -7,7 +7,7 @@ use smol::Executor;
 use url::Url;
 
 use crate::{
-    net::TransportName,
+    net::transport::TransportName,
     system::{StoppableTask, StoppableTaskPtr, Subscriber, SubscriberPtr, Subscription},
     util::async_util::sleep,
     Error, Result,

src/net/session/outbound_session.rs

@@ -9,7 +9,7 @@ use smol::Executor;
 use url::Url;
 
 use crate::{
-    net::{message, TransportName},
+    net::{message, transport::TransportName},
     system::{StoppableTask, StoppableTaskPtr, Subscriber, SubscriberPtr, Subscription},
     util::async_util,
     Error, Result,

src/net/settings.rs

@@ -5,7 +5,7 @@ use structopt::StructOpt;
 use structopt_toml::StructOptToml;
 use url::Url;
 
-use crate::net::TransportName;
+use crate::net::transport::TransportName;
 
 /// Atomic pointer to network settings.
 pub type SettingsPtr = Arc<Settings>;

src/node/client.rs

@@ -15,7 +15,6 @@ use crate::{
         proof::ProvingKey,
         types::DrkTokenId,
     },
-    serial::Encodable,
     tx::{
         builder::{
             TransactionBuilder, TransactionBuilderClearInputInfo, TransactionBuilderInputInfo,
@@ -129,12 +128,10 @@ impl Client {
 
         outputs.push(TransactionBuilderOutputInfo { value, token_id, public: pubkey });
         let builder = TransactionBuilder { clear_inputs, inputs, outputs };
-        let mut tx_data = vec![];
 
         let mint_pk = self.mint_pk.get_or_create(Client::build_mint_pk);
         let burn_pk = self.burn_pk.get_or_create(Client::build_burn_pk);
         let tx = builder.build(mint_pk, burn_pk)?;
-        tx.encode(&mut tx_data)?;
 
         // Check if state transition is valid before broadcasting
         debug!("build_slab_from_tx(): Checking if state transition is valid");

src/raft/consensus.rs

@@ -5,18 +5,14 @@ use async_std::{
     task::sleep,
 };
 use chrono::Utc;
+use darkfi_serial::{deserialize, serialize, Decodable, Encodable};
 use futures::{select, FutureExt};
 use fxhash::FxHashMap;
 use log::{debug, error, warn};
 use rand::{rngs::OsRng, Rng, RngCore};
 use smol::Executor;
 
-use crate::{
-    net,
-    serial::{deserialize, serialize, Decodable, Encodable},
-    util::gen_id,
-    Error, Result,
-};
+use crate::{net, util::gen_id, Error, Result};
 
 use super::{
     p2p_send_loop,

src/raft/consensus_candidate.rs

@@ -1,10 +1,8 @@
 use chrono::Utc;
+use darkfi_serial::{serialize, Decodable, Encodable};
 use log::info;
 
-use crate::{
-    serial::{serialize, Decodable, Encodable},
-    Result,
-};
+use crate::Result;
 
 use super::{
     primitives::{NetMsgMethod, Role, VoteRequest, VoteResponse},

src/raft/consensus_follower.rs

@@ -1,16 +1,13 @@
 use std::cmp::min;
 
+use darkfi_serial::{serialize, Decodable, Encodable};
 use log::debug;
 
-use crate::{
-    serial::{serialize, Decodable, Encodable},
-    Result,
-};
-
 use super::{
     primitives::{LogRequest, LogResponse, Logs, NetMsgMethod, Role, VoteRequest, VoteResponse},
     Raft,
 };
+use crate::Result;
 
 impl<T: Decodable + Encodable + Clone> Raft<T> {
     pub(super) async fn receive_vote_request(&mut self, vr: VoteRequest) -> Result<()> {

src/raft/consensus_leader.rs

@@ -1,9 +1,7 @@
+use darkfi_serial::{serialize, Decodable, Encodable};
 use fxhash::FxHashMap;
 
-use crate::{
-    serial::{serialize, Decodable, Encodable},
-    Result,
-};
+use crate::Result;
 
 use super::{
     primitives::{LogRequest, LogResponse, Logs, NetMsgMethod, NodeId, Role},

src/raft/datastore.rs

@@ -1,12 +1,10 @@
 use std::marker::PhantomData;
 
+use darkfi_serial::{deserialize, serialize, Decodable, Encodable};
 use log::debug;
 use sled::Batch;
 
-use crate::{
-    serial::{deserialize, serialize, Decodable, Encodable},
-    Error, Result,
-};
+use crate::{Error, Result};
 
 use super::primitives::{Log, NodeId};
 

src/raft/primitives.rs

@@ -1,11 +1,9 @@
 use std::io;
 
+use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable};
 use fxhash::FxHashMap;
 
-use crate::{
-    serial::{Decodable, Encodable, SerialDecodable, SerialEncodable},
-    Error, Result,
-};
+use crate::{Error, Result};
 
 pub type Channel<T> = (smol::channel::Sender<T>, smol::channel::Receiver<T>);
 pub type Sender = (smol::channel::Sender<NetMsg>, smol::channel::Receiver<NetMsg>);

src/raft/protocol_raft.rs

@@ -1,13 +1,14 @@
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
 use chrono::Utc;
+use darkfi_serial::serialize;
 use fxhash::FxHashMap;
 use log::debug;
 use rand::{rngs::OsRng, RngCore};
 use smol::Executor;
 
 use super::primitives::{NetMsg, NetMsgMethod, NodeId, NodeIdMsg};
-use crate::{net, serial::serialize, Result};
+use crate::{net, Result};
 
 pub struct ProtocolRaft {
     id: NodeId,

src/rpc/client.rs

@@ -9,9 +9,8 @@ use url::Url;
 
 use super::jsonrpc::{ErrorCode, JsonError, JsonRequest, JsonResult};
 use crate::{
-    net::{
-        transport::Transport, TcpTransport, TorTransport, TransportName, TransportStream,
-        UnixTransport,
+    net::transport::{
+        TcpTransport, TorTransport, Transport, TransportName, TransportStream, UnixTransport,
     },
     Error, Result,
 };

src/rpc/server.rs

@@ -7,9 +7,9 @@ use url::Url;
 
 use super::jsonrpc::{JsonRequest, JsonResult};
 use crate::{
-    net::{
-        transport::Transport, TcpTransport, TorTransport, TransportListener, TransportName,
-        TransportStream, UnixTransport,
+    net::transport::{
+        TcpTransport, TorTransport, Transport, TransportListener, TransportName, TransportStream,
+        UnixTransport,
     },
     Error, Result,
 };

src/tx/builder.rs

@@ -1,3 +1,4 @@
+use darkfi_serial::serialize;
 use group::ff::Field;
 use rand::rngs::OsRng;
 
@@ -19,7 +20,6 @@ use crate::{
             DrkValueBlind,
         },
     },
-    serial::Encodable,
     Result,
 };
 
@@ -179,14 +179,12 @@ impl TransactionBuilder {
         }
 
         let partial_tx = PartialTransaction { clear_inputs, inputs, outputs };
-
-        let mut unsigned_tx_data = vec![];
-        partial_tx.encode(&mut unsigned_tx_data)?;
+        let unsigned_tx_data = serialize(&partial_tx);
 
         let mut clear_inputs = vec![];
         for (input, info) in partial_tx.clear_inputs.into_iter().zip(self.clear_inputs) {
             let secret = info.signature_secret;
-            let signature = secret.sign(&unsigned_tx_data[..]);
+            let signature = secret.sign(&unsigned_tx_data);
             let input = TransactionClearInput::from_partial(input, signature);
             clear_inputs.push(input);
         }
@@ -195,7 +193,7 @@ impl TransactionBuilder {
         for (input, signature_secret) in
             partial_tx.inputs.into_iter().zip(signature_secrets.into_iter())
         {
-            let signature = signature_secret.sign(&unsigned_tx_data[..]);
+            let signature = signature_secret.sign(&unsigned_tx_data);
             let input = TransactionInput::from_partial(input, signature);
             inputs.push(input);
         }

src/tx/mod.rs

@@ -1,5 +1,6 @@
 use std::io;
 
+use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable, VarInt};
 use group::Group;
 use log::error;
 
@@ -16,7 +17,6 @@ use crate::{
         util::{pedersen_commitment_base, pedersen_commitment_u64},
         BurnRevealedValues, MintRevealedValues, Proof,
     },
-    serial::{Encodable, SerialDecodable, SerialEncodable, VarInt},
     Result, VerifyFailed, VerifyResult,
 };
 

src/tx/partial.rs

@@ -1,11 +1,10 @@
+use darkfi_serial::{SerialDecodable, SerialEncodable};
+
 use super::TransactionOutput;
-use crate::{
-    crypto::{
-        keypair::PublicKey,
-        types::{DrkTokenId, DrkValueBlind},
-        BurnRevealedValues, Proof,
-    },
-    serial::{SerialDecodable, SerialEncodable},
+use crate::crypto::{
+    keypair::PublicKey,
+    types::{DrkTokenId, DrkValueBlind},
+    BurnRevealedValues, Proof,
 };
 
 #[derive(Clone, SerialEncodable, SerialDecodable)]

src/util/net_name.rs

@@ -1,9 +1,8 @@
 use std::{io, str::FromStr};
 
+use darkfi_serial::{Decodable, Encodable};
 use serde::{Deserialize, Serialize};
 
-use crate::serial::{Decodable, Encodable};
-
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
 pub enum NetworkName {
     DarkFi,

src/util/time.rs

@@ -1,12 +1,10 @@
 use std::time::UNIX_EPOCH;
 
 use chrono::{NaiveDateTime, Utc};
+use darkfi_serial::{SerialDecodable, SerialEncodable};
 use serde::{Deserialize, Serialize};
 
-use crate::{
-    serial::{SerialDecodable, SerialEncodable},
-    Result,
-};
+use crate::Result;
 
 /// Wrapper struct to represent [`chrono`] UTC timestamps.
 #[derive(

src/wallet/walletdb.rs

@@ -1,6 +1,7 @@
 use std::{fs::create_dir_all, path::Path, str::FromStr, time::Duration};
 
 use async_std::sync::Arc;
+use darkfi_serial::{deserialize, serialize};
 use group::ff::PrimeField;
 use incrementalmerkletree::bridgetree::BridgeTree;
 use log::{debug, error, info, LevelFilter};
@@ -21,7 +22,6 @@ use crate::{
         nullifier::Nullifier,
         types::DrkTokenId,
     },
-    serial::{deserialize, serialize},
     util::path::expand_path,
     Error::{WalletEmptyPassword, WalletTreeExists},
     Result,

src/zkas/compiler.rs

@@ -1,11 +1,12 @@
 use std::str::Chars;
 
+use darkfi_serial::{serialize, VarInt};
+
 use super::{
     ast::{Arg, Constant, Literal, Statement, StatementType, Witness},
     error::ErrorEmitter,
     types::StackType,
 };
-use crate::serial::{serialize, VarInt};
 
 /// Version of the binary
 pub const BINARY_VERSION: u8 = 2;

src/zkas/decoder.rs

@@ -1,9 +1,7 @@
+use darkfi_serial::{deserialize_partial, VarInt};
+
 use super::{compiler::MAGIC_BYTES, types::StackType, LitType, Opcode, VarType};
-use crate::{
-    serial::{deserialize_partial, VarInt},
-    Error::ZkasDecoderError as ZkasErr,
-    Result,
-};
+use crate::{Error::ZkasDecoderError as ZkasErr, Result};
 
 /// A ZkBinary decoded from compiled zkas code.
 /// This is used by the zkvm.