fix: Update dependencies and add cardano-node 10.5.1 compatibility

Author: AndrewWestberg

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cncli"
-version = "6.5.1"
+version = "6.6.0"
 authors = ["Andrew Westberg <andrewwestberg@gmail.com>"]
 edition = "2021"
 build = "build.rs"
@@ -10,42 +10,43 @@ build = "build.rs"
 [dependencies]
 async-std = "1.13"
 bech32 = "0.11"
-bincode = "1.3.3"
+bincode = "2"
 byteorder = "1.5"
-pallas-crypto = { git = "https://github.com/txpipe/pallas", rev = "b641c4e6862be447336429878f4e0a57a2281588" }
-pallas-math = { git = "https://github.com/txpipe/pallas", rev = "b641c4e6862be447336429878f4e0a57a2281588" }
-pallas-network = { git = "https://github.com/txpipe/pallas", rev = "b641c4e6862be447336429878f4e0a57a2281588" }
-pallas-traverse = { git = "https://github.com/txpipe/pallas", rev = "b641c4e6862be447336429878f4e0a57a2281588" }
-#pallas-crypto = "0.30"
-#pallas-math = "0.30"
-#pallas-network = "0.30"
-#pallas-traverse = "0.30"
+#pallas-crypto = { git = "https://github.com/txpipe/pallas", rev = "b641c4e6862be447336429878f4e0a57a2281588" }
+#pallas-math = { git = "https://github.com/txpipe/pallas", rev = "b641c4e6862be447336429878f4e0a57a2281588" }
+#pallas-network = { git = "https://github.com/txpipe/pallas", rev = "b641c4e6862be447336429878f4e0a57a2281588" }
+#pallas-traverse = { git = "https://github.com/txpipe/pallas", rev = "b641c4e6862be447336429878f4e0a57a2281588" }
+pallas-crypto = "0.32.1"
+pallas-math = "0.32.1"
+pallas-network = "0.32.1"
+pallas-traverse = "0.32.1"
+amaru-ouroboros = { git = "https://github.com/pragma-org/amaru", rev = "981381fb6bb980f27c244e9f80765f0d653bb212" }
 chrono = "0.4"
 chrono-tz = "0.10"
 futures = "0.3"
 hex = "0.4"
-malachite-base = "0.4.16"
-malachite = "0.4.16"
-minicbor = { version = "0.25", features = ["std"] }
-redb = "2.2.0"
+#malachite-base = "0.4.16"
+#malachite = "0.4.16"
+minicbor = { version = "0.26", features = ["std"] }
+redb = "2.6.1"
 regex = "1.11"
 reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls-webpki-roots", "rustls-tls", "json", "gzip", "deflate"] }
-rusqlite = { version = "0.32", features = ["bundled"] }
+rusqlite = { version = "0.37", features = ["bundled"] }
 serde = { version = "1.0", features = ["derive"] }
 serde-aux = "4.5"
 serde_cbor = "0.11"
 serde_json = "1.0"
-socket2 = "0.5"
+socket2 = "0.6"
 structopt = "0.3"
-rand = "0.8"
+rand = "0.9"
 rayon = "1.10"
-itertools = "0.13"
+itertools = "0.14"
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "net", "io-util", "time", "sync", "macros"] }
-thiserror = "1.0"
+thiserror = "2.0"
 tracing = "0.1"
 tracing-subscriber = "0.3"
 uuid = { version = "1", features = ["v7"] }
-log = "0.4.22"
+log = "0.4"
 
 [build-dependencies]
-built = { version = "0.7", features = ["git2"] }
+built = { version = "0.8", features = ["git2"] }

Cargo.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

rust-toolchain.toml

@@ -9,7 +9,7 @@ pub(crate) mod sqlite;
 #[derive(Error, Debug)]
 pub enum Error {
     #[error("Redb error: {0}")]
-    Redb(#[from] redb::Error),
+    Redb(Box<redb::Error>),
 
     #[error("Sqlite error: {0}")]
     Sqlite(#[from] sqlite::Error),
@@ -21,6 +21,12 @@ pub enum Error {
     Blockstore(String),
 }
 
+impl From<redb::Error> for Error {
+    fn from(err: redb::Error) -> Self {
+        Error::Redb(Box::new(err))
+    }
+}
+
 pub(crate) struct Block {
     pub(crate) block_number: u64,
     pub(crate) slot_number: u64,

src/nodeclient/blockstore/mod.rs

@@ -20,22 +20,22 @@ pub enum Error {
     Io(#[from] std::io::Error),
 
     #[error("Redb error: {0}")]
-    Redb(#[from] redb::Error),
+    Redb(Box<redb::Error>),
 
     #[error("Redb db error: {0}")]
-    RedbDb(#[from] redb::DatabaseError),
+    RedbDb(Box<redb::DatabaseError>),
 
     #[error("Redb commit error: {0}")]
-    RedbCommit(#[from] redb::CommitError),
+    RedbCommit(Box<redb::CommitError>),
 
     #[error("Redb transaction error: {0}")]
-    RedbTransaction(#[from] redb::TransactionError),
+    RedbTransaction(Box<redb::TransactionError>),
 
     #[error("Redb table error: {0}")]
-    RedbTable(#[from] redb::TableError),
+    RedbTable(Box<redb::TableError>),
 
     #[error("Redb storage error: {0}")]
-    RedbStorage(#[from] redb::StorageError),
+    RedbStorage(Box<redb::StorageError>),
 
     #[error("FromHex error: {0}")]
     FromHex(#[from] hex::FromHexError),
@@ -44,7 +44,43 @@ pub enum Error {
     DataNotFound,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+impl From<redb::Error> for Error {
+    fn from(err: redb::Error) -> Self {
+        Error::Redb(Box::new(err))
+    }
+}
+
+impl From<redb::DatabaseError> for Error {
+    fn from(err: redb::DatabaseError) -> Self {
+        Error::RedbDb(Box::new(err))
+    }
+}
+
+impl From<redb::CommitError> for Error {
+    fn from(err: redb::CommitError) -> Self {
+        Error::RedbCommit(Box::new(err))
+    }
+}
+
+impl From<redb::TransactionError> for Error {
+    fn from(err: redb::TransactionError) -> Self {
+        Error::RedbTransaction(Box::new(err))
+    }
+}
+
+impl From<redb::TableError> for Error {
+    fn from(err: redb::TableError) -> Self {
+        Error::RedbTable(Box::new(err))
+    }
+}
+
+impl From<redb::StorageError> for Error {
+    fn from(err: redb::StorageError) -> Self {
+        Error::RedbStorage(Box::new(err))
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, bincode::Encode, bincode::Decode)]
 struct ChainRecord {
     block_number: u64,
     slot_number: u64,
@@ -73,7 +109,8 @@ struct ChainRecord {
 
 impl Value for ChainRecord {
     type SelfType<'a> = Self;
-    type AsBytes<'a> = Vec<u8>
+    type AsBytes<'a>
+        = Vec<u8>
     where
         Self: 'a;
 
@@ -86,23 +123,23 @@ impl Value for ChainRecord {
     where
         Self: 'a,
     {
-        bincode::deserialize(data).unwrap()
+        bincode::decode_from_slice(data, bincode::config::legacy()).unwrap().0
     }
 
     fn as_bytes<'a, 'b: 'a>(value: &'a Self::SelfType<'b>) -> Self::AsBytes<'a>
     where
         Self: 'a,
         Self: 'b,
     {
-        bincode::serialize(value).unwrap()
+        bincode::encode_to_vec(value, bincode::config::legacy()).unwrap()
     }
 
     fn type_name() -> TypeName {
         TypeName::new(stringify!(ChainRecord))
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, bincode::Encode, bincode::Decode)]
 struct SlotsRecord {
     epoch: u64,
     pool_id: Vec<u8>,
@@ -113,7 +150,8 @@ struct SlotsRecord {
 
 impl Value for SlotsRecord {
     type SelfType<'a> = Self;
-    type AsBytes<'a> = Vec<u8>
+    type AsBytes<'a>
+        = Vec<u8>
     where
         Self: 'a;
 
@@ -126,15 +164,15 @@ impl Value for SlotsRecord {
     where
         Self: 'a,
     {
-        bincode::deserialize(data).unwrap()
+        bincode::decode_from_slice(data, bincode::config::legacy()).unwrap().0
     }
 
     fn as_bytes<'a, 'b: 'a>(value: &'a Self::SelfType<'b>) -> Self::AsBytes<'a>
     where
         Self: 'a,
         Self: 'b,
     {
-        bincode::serialize(value).unwrap()
+        bincode::encode_to_vec(value, bincode::config::legacy()).unwrap()
     }
 
     fn type_name() -> TypeName {

src/nodeclient/blockstore/redb.rs

@@ -1,26 +1,26 @@
-use std::fmt::Display;
-use std::fs::File;
-use std::io::{stdout, BufReader};
-use std::path::Path;
-use std::str::FromStr;
-
 use crate::nodeclient::blockstore;
 use crate::nodeclient::blockstore::redb::{is_redb_database, RedbBlockStore};
 use crate::nodeclient::blockstore::sqlite::SqLiteBlockStore;
 use crate::nodeclient::blockstore::BlockStore;
 use crate::nodeclient::leaderlog::deserialize::cbor_hex;
 use crate::nodeclient::leaderlog::ledgerstate::calculate_ledger_state_sigma_d_and_extra_entropy;
 use crate::{LedgerSet, PooltoolConfig};
+use amaru_ouroboros::vrf::{Input, Proof, SecretKey};
+use amaru_ouroboros::Hash;
 use chrono::{DateTime, NaiveDateTime, TimeDelta, TimeZone, Utc};
 use chrono_tz::Tz;
 use itertools::sorted;
-use pallas_crypto::hash::{Hash, Hasher};
+use pallas_crypto::hash::Hasher;
 use pallas_crypto::nonce::generate_epoch_nonce;
-use pallas_crypto::vrf::{VrfSecretKey, VRF_SECRET_KEY_SIZE};
 use pallas_math::math::{ExpOrdering, FixedDecimal, FixedPrecision, DEFAULT_PRECISION};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use serde_aux::prelude::deserialize_number_from_string;
+use std::fmt::Display;
+use std::fs::File;
+use std::io::{stdout, BufReader};
+use std::path::Path;
+use std::str::FromStr;
 use thiserror::Error;
 use tracing::{debug, error, info, span, trace, Level};
 
@@ -48,10 +48,10 @@ pub enum Error {
     Leaderlog(String),
 
     #[error("Blockstore error: {0}")]
-    Blockstore(#[from] blockstore::Error),
+    Blockstore(Box<blockstore::Error>),
 
     #[error("Redb error: {0}")]
-    Redb(#[from] blockstore::redb::Error),
+    Redb(Box<blockstore::redb::Error>),
 
     #[error("Sqlite error: {0}")]
     Sqlite(#[from] blockstore::sqlite::Error),
@@ -60,6 +60,18 @@ pub enum Error {
     ParseFloat(#[from] std::num::ParseFloatError),
 }
 
+impl From<blockstore::Error> for Error {
+    fn from(err: blockstore::Error) -> Self {
+        Error::Blockstore(Box::new(err))
+    }
+}
+
+impl From<blockstore::redb::Error> for Error {
+    fn from(err: blockstore::redb::Error) -> Self {
+        Error::Redb(Box::new(err))
+    }
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct LeaderLogError {
@@ -293,10 +305,12 @@ fn mk_input_vrf(slot: u64, eta0: &[u8]) -> Vec<u8> {
 }
 
 fn vrf_eval_certified(seed: &[u8], pool_vrf_skey: &[u8]) -> Result<Hash<64>, Error> {
-    let vrf_skey: [u8; VRF_SECRET_KEY_SIZE] = pool_vrf_skey[..VRF_SECRET_KEY_SIZE].try_into().expect("Infallible");
-    let vrf_skey: VrfSecretKey = VrfSecretKey::from(&vrf_skey);
-    let certified_proof = vrf_skey.prove(seed);
-    let certified_proof_hash = certified_proof.to_hash();
+    let vrf_skey: &[u8; SecretKey::SIZE] = pool_vrf_skey[..SecretKey::SIZE].try_into().expect("Infallible");
+    let vrf_skey = SecretKey::from(vrf_skey);
+    let input_bytes: &[u8; Input::SIZE] = seed[..Input::SIZE].try_into().expect("Infallible");
+    let input: Input = Input::from(input_bytes);
+    let certified_proof: Proof = vrf_skey.prove(&input);
+    let certified_proof_hash: Hash<{ Proof::HASH_SIZE }> = Hash::<{ Proof::HASH_SIZE }>::from(&certified_proof);
     trace!("certified_proof_hash: {}", hex::encode(certified_proof_hash));
     Ok(certified_proof_hash)
 }
@@ -578,10 +592,10 @@ pub(crate) fn calculate_leader_logs(
                 )));
             }
 
-            let nc: Hash<32> = block_store.get_eta_v_before_slot(stability_window_start)?;
+            let nc = block_store.get_eta_v_before_slot(stability_window_start)?;
             debug!("nc: {}", nc);
 
-            let nh: Hash<32> = block_store.get_prev_hash_before_slot(first_slot_of_prev_epoch)?;
+            let nh = block_store.get_prev_hash_before_slot(first_slot_of_prev_epoch)?;
             debug!("nh: {}", nh);
 
             debug!("extra_entropy: {:?}", &ledger_info.extra_entropy);

src/nodeclient/leaderlog/mod.rs

@@ -162,7 +162,7 @@ mod tests {
         let regex = Regex::new(regex_str);
         let ping_result = std::str::from_utf8(&stdout).unwrap();
         // println!("ping_result: {}", ping_result);
-        assert_eq!(regex.unwrap().is_match(ping_result), true);
+        assert!(regex.unwrap().is_match(ping_result));
     }
 
     #[tokio::test]
@@ -178,7 +178,7 @@ mod tests {
         let regex = Regex::new(regex_str);
         let ping_result = std::str::from_utf8(&stdout).unwrap();
         println!("ping_result: {}", ping_result);
-        assert_eq!(regex.unwrap().is_match(ping_result), true);
+        assert!(regex.unwrap().is_match(ping_result));
     }
 
     #[tokio::test]