github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-01-09 14:48:08 -05:00
Code Issues Packages Projects Releases Wiki Activity

fmt, fixed broken imports, general cleanup

Browse Source
This commit is contained in:
aggstam
2023-01-12 13:52:26 +02:00
parent 7241827a37
commit 4dadf292ec
11 changed files with 136 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
bin/darkfid/src/main.rs
View File

@@ -30,9 +30,8 @@ use darkfi::{
consensus::{
constants::{
MAINNET_BOOTSTRAP_TIMESTAMP, MAINNET_GENESIS_HASH_BYTES, MAINNET_GENESIS_TIMESTAMP,
MAINNET_INITIAL_DISTRIBUTION, TESTNET_GENESIS_HASH_BYTES,
TESTNET_INITIAL_DISTRIBUTION, TESTNET_GENESIS_TIMESTAMP,
TESTNET_BOOTSTRAP_TIMESTAMP,
MAINNET_INITIAL_DISTRIBUTION, TESTNET_BOOTSTRAP_TIMESTAMP, TESTNET_GENESIS_HASH_BYTES,
TESTNET_GENESIS_TIMESTAMP, TESTNET_INITIAL_DISTRIBUTION,
},
proto::{ProtocolProposal, ProtocolSync, ProtocolSyncConsensus, ProtocolTx},
task::{block_sync_task, proposal_task},
@@ -49,7 +48,7 @@ use darkfi::{
},
server::{listen_and_serve, RequestHandler},
},
util::{path::expand_path},
util::path::expand_path,
wallet::{walletdb::init_wallet, WalletPtr},
Error, Result,
};

8
example/zk.rs
View File

@@ -28,15 +28,11 @@ use darkfi::{
Result,
};
use darkfi_sdk::{
crypto::{
pedersen::pedersen_commitment_u64, poseidon_hash, MerkleNode, PublicKey, SecretKey, TokenId,
},
incrementalmerkletree,
incrementalmerkletree::{bridgetree::BridgeTree, Hashable, Tree},
crypto::pedersen::pedersen_commitment_u64,
pasta::{
arithmetic::CurveAffine,
group::{
ff::{Field, PrimeField},
ff::Field,
Curve,
},
pallas,

6
src/consensus/constants.rs
View File

@@ -124,6 +124,6 @@ pub const PI_SIGMA1_INDEX: usize = 12;
pub const PI_SIGMA2_INDEX: usize = 13;
pub const GENESIS_TOTAL_STAKE: u64 = 1;
pub const LEADER_HISTORY_LOG : &str = "/tmp/lead_history.log";
pub const F_HISTORY_LOG : &str = "/tmp/f_history.log";
pub const LOTTERY_HISTORY_LOG : &str = "/tmp/lottery_history.log";
pub const LEADER_HISTORY_LOG: &str = "/tmp/lead_history.log";
pub const F_HISTORY_LOG: &str = "/tmp/f_history.log";
pub const LOTTERY_HISTORY_LOG: &str = "/tmp/lottery_history.log";

62
src/consensus/leadcoin.rs
View File

@@ -42,8 +42,10 @@ use crate::{
Result,
};
use std::io::{prelude::*, BufWriter};
use std::fs::File;
use std::{
fs::File,
io::{prelude::*, BufWriter},
};
pub const MERKLE_DEPTH_LEADCOIN: usize = 32;
pub const MERKLE_DEPTH: u8 = 32;
@@ -130,10 +132,10 @@ impl LeadCoin {
//info!("coin2_seed[{}]: {:?}", slot, coin2_seed);
// Create commitment to coin2
//let coin2_commitment = Self::commitment(
//pk,
//pallas::Base::from(value + constants::REWARD),
//coin2_seed,
//coin2_blind,
//pk,
//pallas::Base::from(value + constants::REWARD),
//coin2_seed,
//coin2_blind,
//);
// Derive election seeds
//let (y_mu, rho_mu) = Self::election_seeds_u64(eta, slot);
@@ -187,12 +189,13 @@ impl LeadCoin {
/// Create a vector of `pallas::Base` elements from the `LeadCoin` to be
/// used as public inputs for the ZK proof.
pub fn public_inputs(&self,
sigma1: pallas::Base,
sigma2: pallas::Base,
current_eta: pallas::Base,
current_slot: pallas::Base,
derived_blind: pallas::Scalar,
pub fn public_inputs(
&self,
sigma1: pallas::Base,
sigma2: pallas::Base,
current_eta: pallas::Base,
current_slot: pallas::Base,
derived_blind: pallas::Scalar,
) -> Vec<pallas::Base> {
// pk
let pk = self.pk();
@@ -200,11 +203,8 @@ impl LeadCoin {
let c1_cm_coord = self.coin1_commitment.to_affine().coordinates().unwrap();
let c2_cm_coord = self.derived_commitment(derived_blind).to_affine().coordinates().unwrap();
// lottery seed
let seed_msg = [pallas::Base::from(PREFIX_SEED),
self.coin1_sk_root.inner(),
self.nonce,
ZERO
];
let seed_msg =
[pallas::Base::from(PREFIX_SEED), self.coin1_sk_root.inner(), self.nonce, ZERO];
let seed = poseidon_hash(seed_msg);
// y
let (y_mu, rho_mu) = Self::election_seeds(current_eta, current_slot);
@@ -282,16 +282,15 @@ impl LeadCoin {
}
*/
pub fn is_leader(&self, sigma1: pallas::Base,
sigma2: pallas::Base,
current_eta: pallas::Base,
current_slot: pallas::Base,
pub fn is_leader(
&self,
sigma1: pallas::Base,
sigma2: pallas::Base,
current_eta: pallas::Base,
current_slot: pallas::Base,
) -> bool {
let y_seed = [pallas::Base::from(PREFIX_SEED),
self.coin1_sk_root.inner(),
self.nonce,
ZERO
];
let y_seed =
[pallas::Base::from(PREFIX_SEED), self.coin1_sk_root.inner(), self.nonce, ZERO];
let y_seed_hash = poseidon_hash(y_seed);
let (y_mu, _) = Self::election_seeds(current_eta, current_slot);
let y_msg = [y_seed_hash, y_mu];
@@ -299,9 +298,9 @@ impl LeadCoin {
let value = pallas::Base::from(self.value);
let target = sigma1 * value + sigma2 * value * value;
let target = sigma1 * value + sigma2 * value * value;
let y_t_str = format!("{:?},{:?}\n", y,target);
let y_t_str = format!("{:?},{:?}\n", y, target);
let f = File::options().append(true).open(constants::LOTTERY_HISTORY_LOG).unwrap();
{
@@ -447,7 +446,12 @@ impl LeadCoin {
Witness::Base(Value::known(xferval)),
];
let circuit = ZkCircuit::new(witnesses, zkbin);
let proof = Proof::create(pk, &[circuit], &self.public_inputs(sigma1, sigma2, current_eta, current_slot, derived_blind), &mut OsRng)?;
let proof = Proof::create(
pk,
&[circuit],
&self.public_inputs(sigma1, sigma2, current_eta, current_slot, derived_blind),
&mut OsRng,
)?;
let cm3_msg_in = [
pallas::Base::from(PREFIX_CM),
change_pk,

6
src/consensus/proto/protocol_proposal.rs
View File

@@ -31,11 +31,9 @@ use crate::{
Result,
};
use darkfi_sdk::{
pasta::{pallas},
};
use rand::rngs::OsRng;
use darkfi_sdk::pasta::pallas;
use halo2_proofs::arithmetic::Field;
use rand::rngs::OsRng;
pub struct ProtocolProposal {
proposal_sub: MessageSubscription<BlockProposal>,

93
src/consensus/state.rs
View File

@@ -36,8 +36,10 @@ use super::{
};
use crate::{blockchain::Blockchain, net, tx::Transaction, util::time::Timestamp, Error, Result};
use std::io::{prelude::*, BufWriter};
use std::fs::File;
use std::{
fs::File,
io::{prelude::*, BufWriter},
};
/// This struct represents the information required by the consensus algorithm
pub struct ConsensusState {
@@ -110,8 +112,7 @@ impl ConsensusState {
slot_checkpoints: vec![],
leaders_history: vec![0],
f_history: vec![constants::FLOAT10_ZERO.clone()],
err_history: vec![constants::FLOAT10_ZERO.clone(),
constants::FLOAT10_ZERO.clone()],
err_history: vec![constants::FLOAT10_ZERO.clone(), constants::FLOAT10_ZERO.clone()],
coins: vec![],
coins_tree: BridgeTree::<MerkleNode, MERKLE_DEPTH>::new(constants::EPOCH_LENGTH * 100),
nullifiers: vec![],
@@ -261,20 +262,16 @@ impl ConsensusState {
let neg_one = constants::FLOAT10_NEG_ONE.clone();
let two = constants::FLOAT10_TWO.clone();
let field_p = Float10::try_from(constants::P).unwrap();
let x = one - f;
let c = x.ln();
let neg_c = neg_one * c;
let sigma1_fbig = neg_c.clone() / total_sigma.clone() * field_p.clone();
let sigma1_fbig = neg_c.clone() / total_sigma.clone() * field_p.clone();
println!("sigma1_fbig: {:}", sigma1_fbig);
let sigma1 = fbig2base(sigma1_fbig);
let sigma2_fbig = (neg_c / total_sigma).powf(two.clone()) * (field_p / two);
println!("sigma2_fbig: {:}", sigma2_fbig);
let sigma2 = fbig2base(sigma2_fbig);
@@ -282,12 +279,12 @@ impl ConsensusState {
(sigma1, sigma2)
}
/// Generate coins for provided sigmas.
/// NOTE: The strategy here is having a single competing coin per slot.
// TODO: DRK coin need to be burned, and consensus coin to be minted.
async fn create_coins(&mut self,
//eta: pallas::Base,
async fn create_coins(
&mut self,
//eta: pallas::Base,
) -> Result<Vec<LeadCoin>> {
let slot = self.current_slot();
@@ -311,7 +308,6 @@ impl ConsensusState {
// must sum to initial distribution total coins.
//let stake = self.initial_distribution;
let coin = LeadCoin::new(
200,
slot,
epoch_secrets.secret_keys[0].inner(),
@@ -399,7 +395,7 @@ impl ConsensusState {
self.leaders_history.push(count);
info!("extend_leaders_history(): Current leaders history: {:?}", self.leaders_history);
let mut count_str : String = count.to_string();
let mut count_str: String = count.to_string();
count_str.push_str(",");
let f = File::options().append(true).open(constants::LEADER_HISTORY_LOG).unwrap();
{
@@ -408,35 +404,31 @@ impl ConsensusState {
}
Float10::try_from(count as i64).unwrap()
}
fn f_err(&mut self) -> Float10 {
let len = self.leaders_history.len();
let feedback = Float10::try_from(self.leaders_history[len-1] as i64).unwrap();
let feedback = Float10::try_from(self.leaders_history[len - 1] as i64).unwrap();
let target = constants::FLOAT10_ONE.clone();
target - feedback
}
fn discrete_pid(&mut self) -> Float10 {
let k1 = constants::KP.clone() +
constants::KI.clone() +
constants::KD.clone();
let k2 = constants::FLOAT10_NEG_ONE.clone() * constants::KP.clone() + constants::FLOAT10_NEG_TWO.clone() * constants::KD.clone();
let k1 = constants::KP.clone() + constants::KI.clone() + constants::KD.clone();
let k2 = constants::FLOAT10_NEG_ONE.clone() * constants::KP.clone() +
constants::FLOAT10_NEG_TWO.clone() * constants::KD.clone();
let k3 = constants::KD.clone();
let f_len = self.f_history.len();
let err = self.f_err();
let err_len = self.err_history.len();
let ret = self.f_history[f_len-1].clone() +
let ret = self.f_history[f_len - 1].clone() +
k1.clone() * err.clone() +
k2.clone() * self.err_history[err_len-1].clone() +
k3.clone() * self.err_history[err_len-2].clone();
info!("pid::f-1: {:}", self.f_history[f_len-1].clone());
k2.clone() * self.err_history[err_len - 1].clone() +
k3.clone() * self.err_history[err_len - 2].clone();
info!("pid::f-1: {:}", self.f_history[f_len - 1].clone());
info!("pid::err: {:}", err);
info!("pid::err-1: {}", self.err_history[err_len-1].clone());
info!("pid::err-2: {}", self.err_history[err_len-2].clone());
info!("pid::err-1: {}", self.err_history[err_len - 1].clone());
info!("pid::err-2: {}", self.err_history[err_len - 2].clone());
info!("pid::k1: {}", k1.clone());
info!("pid::k2: {}", k2.clone());
info!("pid::k3: {}", k3.clone());
@@ -493,15 +485,16 @@ impl ConsensusState {
let mut highest_stake_idx = 0;
let total_stake = self.total_stake();
for (winning_idx, coin) in competing_coins.iter().enumerate() {
info!("is_slot_leader: coin stake: {:?}", coin.value);
info!("is_slot_leader: total stake: {}", total_stake);
info!("is_slot_leader: relative stake: {}", (coin.value as f64) / total_stake as f64);
let first_winning = coin.is_leader(sigma1,
sigma2,
self.get_eta(),
pallas::Base::from(self.current_slot()));
let first_winning = coin.is_leader(
sigma1,
sigma2,
self.get_eta(),
pallas::Base::from(self.current_slot()),
);
if first_winning && !won {
highest_stake_idx = winning_idx;
@@ -942,36 +935,28 @@ impl From<ForkInfo> for Fork {
#[cfg(test)]
mod tests {
use darkfi_sdk::{
pasta::{group::ff::PrimeField, pallas},
};
use log::info;
use crate::consensus::{
constants,
state::ConsensusState,
utils::fbig2base,
Float10,
};
use crate::{ Error, Result};
use dashu::base::Abs;
use std::io::{prelude::*, BufWriter};
use std::fs::File;
use crate::consensus::{state::ConsensusState, utils::fbig2base, Float10};
#[test]
fn calc_sigmas_test() {
let giga_epsilon = Float10::try_from("10000000000000000000000000000000000000000000000000000000000").unwrap();
let giga_epsilon =
Float10::try_from("10000000000000000000000000000000000000000000000000000000000")
.unwrap();
let giga_epsilon_base = fbig2base(giga_epsilon);
let f = Float10::try_from("0.5").unwrap();
let total_stake = Float10::try_from("1000").unwrap();
let (sigma1, sigma2) = ConsensusState::calc_sigmas(f, total_stake);
let sigma1_rhs = Float10::try_from("20065240046497827749443820209808913616958821867408735207193448041041362944").unwrap();
let sigma1_rhs = Float10::try_from(
"20065240046497827749443820209808913616958821867408735207193448041041362944",
)
.unwrap();
let sigma1_rhs_base = fbig2base(sigma1_rhs);
let sigma2_rhs = Float10::try_from("6954082282744237239883318512759812991231744634473746668074299461468160").unwrap();
let sigma2_rhs = Float10::try_from(
"6954082282744237239883318512759812991231744634473746668074299461468160",
)
.unwrap();
let sigma2_rhs_base = fbig2base(sigma2_rhs);
let sigma1_delta = if sigma1_rhs_base>sigma1 {
let sigma1_delta = if sigma1_rhs_base > sigma1 {
sigma1_rhs_base - sigma1
} else {
sigma1 - sigma1_rhs_base

33
src/consensus/task/proposal.rs
View File

@@ -28,11 +28,9 @@ use crate::{
util::{async_util::sleep, time::Timestamp},
};
use darkfi_sdk::{
pasta::{pallas},
};
use rand::rngs::OsRng;
use darkfi_sdk::pasta::pallas;
use halo2_proofs::arithmetic::Field;
use rand::rngs::OsRng;
/// async task used for participating in the consensus protocol
pub async fn proposal_task(
@@ -186,9 +184,10 @@ async fn consensus_loop(
/// - Generate slot sigmas and checkpoint
/// - Check if slot leader to generate and broadcast proposal
/// Returns flag in case node needs to resync.
async fn propose_period(consensus_p2p: P2pPtr,
state: ValidatorStatePtr,
derived_blind: pallas::Scalar,
async fn propose_period(
consensus_p2p: P2pPtr,
state: ValidatorStatePtr,
derived_blind: pallas::Scalar,
) -> bool {
// Node sleeps until next slot
let seconds_next_slot = state.read().await.consensus.next_n_slot_start(1).as_secs();
@@ -219,12 +218,13 @@ async fn propose_period(consensus_p2p: P2pPtr,
let (won, fork_index, coin_index) =
state.write().await.consensus.is_slot_leader(sigma1, sigma2);
let result = if won {
state.write().await.propose(processing_slot,
fork_index,
coin_index,
sigma1,
sigma2,
derived_blind
state.write().await.propose(
processing_slot,
fork_index,
coin_index,
sigma1,
sigma2,
derived_blind,
)
} else {
Ok(None)
@@ -258,7 +258,12 @@ async fn propose_period(consensus_p2p: P2pPtr,
info!("consensus: Node is the slot leader: Proposed block: {}", proposal);
debug!("consensus: Full proposal: {:?}", proposal);
match state.write().await.receive_proposal(&proposal, Some((coin_index, coin)), derived_blind).await {
match state
.write()
.await
.receive_proposal(&proposal, Some((coin_index, coin)), derived_blind)
.await
{
Ok(_) => {
// Here we don't have to check to broadcast, because the flag
// will always be true, since the node is able to produce proposals

24
src/consensus/utils.rs
View File

@@ -16,11 +16,9 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use darkfi_sdk::pasta::pallas;
use dashu::integer::{IBig, Sign};
use darkfi_sdk::pasta::{group::ff::PrimeField, pallas};
use dashu::integer::{IBig, Sign, UBig};
use log::debug;
use dashu::integer::UBig;
use darkfi_sdk::pasta::group::ff::PrimeField;
use super::Float10;
@@ -71,9 +69,11 @@ pub fn base2ibig(base: pallas::Base) -> IBig {
mod tests {
use dashu::integer::IBig;
use darkfi_sdk::pasta::{pallas, group::ff::PrimeField};
use crate::consensus::{constants::RADIX_BITS, types::Float10, utils::{fbig2ibig, fbig2base, base2ibig}};
use crate::consensus::{
types::Float10,
utils::{base2ibig, fbig2base, fbig2ibig},
};
use darkfi_sdk::pasta::pallas;
#[test]
fn dashu_fbig2ibig() {
@@ -86,7 +86,10 @@ mod tests {
#[test]
fn dashu_test_base2ibig() {
//
let fbig: Float10 = Float10::from_str_native("289480223093290488558927462521719769633630564819415607159546767643499676303").unwrap().with_precision(RADIX_BITS).value();
let fbig: Float10 = Float10::try_from(
"289480223093290488558927462521719769633630564819415607159546767643499676303",
)
.unwrap();
let ibig = fbig2ibig(fbig.clone());
let res_base: pallas::Base = fbig2base(fbig.clone());
let res_ibig: IBig = base2ibig(res_base);
@@ -96,7 +99,10 @@ mod tests {
#[test]
fn dashu_test2_base2ibig() {
//assert that field wrapping for negative values won't hold during conversions.
let fbig: Float10 = Float10::from_str_native("-20065240046497827215558476051577517633529246907153511707181011345840062564.87").unwrap().with_precision(RADIX_BITS).value();
let fbig: Float10 = Float10::try_from(
"-20065240046497827215558476051577517633529246907153511707181011345840062564.87",
)
.unwrap();
let ibig = fbig2ibig(fbig.clone());
let res_base: pallas::Base = fbig2base(fbig.clone());
let res_ibig: IBig = base2ibig(res_base);

28
src/consensus/validator.rs
View File

@@ -264,7 +264,7 @@ impl ValidatorState {
coin_index: usize,
sigma1: pallas::Base,
sigma2: pallas::Base,
derived_blind: pallas::Scalar
derived_blind: pallas::Scalar,
) -> Result<Option<(BlockProposal, LeadCoin)>> {
let eta = self.consensus.get_eta();
// Check if node can produce proposals
@@ -292,12 +292,13 @@ impl ValidatorState {
};
// Generating leader proof
let (proof, public_inputs) = coin.create_lead_proof(sigma1,
sigma2,
eta.clone(),
pallas::Base::from(self.consensus.current_slot()),
self.lead_proving_key.as_ref().unwrap(),
derived_blind,
let (proof, public_inputs) = coin.create_lead_proof(
sigma1,
sigma2,
eta.clone(),
pallas::Base::from(self.consensus.current_slot()),
self.lead_proving_key.as_ref().unwrap(),
derived_blind,
);
// Signing using coin
@@ -475,8 +476,8 @@ impl ValidatorState {
info!(target: "consensus::validator", "receive_proposal(): Leader proof verified successfully!");
// Validate proposal public value against coin creation slot checkpoint
let (mu_y, mu_rho) = LeadCoin::election_seeds_u64(self.consensus.get_eta(),
self.consensus.current_slot());
let (mu_y, mu_rho) =
LeadCoin::election_seeds_u64(self.consensus.get_eta(), self.consensus.current_slot());
// y
let prop_mu_y = lf.public_inputs[constants::PI_MU_Y_INDEX];
@@ -501,7 +502,6 @@ impl ValidatorState {
return Err(Error::ProposalPublicValuesMismatched)
}
// Validate proposal coin sigmas against current slot checkpoint
let checkpoint = self.consensus.get_slot_checkpoint(current)?;
// sigma1
@@ -567,7 +567,8 @@ impl ValidatorState {
// If proposal came fromself, we derive new coin
if let Some((idx, c)) = coin {
state_checkpoint.coins[idx] = c.derive_coin(&mut state_checkpoint.coins_tree, derived_blind);
state_checkpoint.coins[idx] =
c.derive_coin(&mut state_checkpoint.coins_tree, derived_blind);
}
// Store proposal coins nullifiers
state_checkpoint.nullifiers.push(prop_sn);
@@ -647,12 +648,11 @@ impl ValidatorState {
return Ok((vec![], vec![]))
}
_ => info!("chain_finalization(): Chain {} can be finalized!", fork_index),
}
if max_length==0 {
if max_length == 0 {
return Ok((vec![], vec![]))
}
if max_length==0 {
if max_length == 0 {
return Ok((vec![], vec![]))
}

2
src/contract/money/src/client.rs
View File

@@ -1061,7 +1061,6 @@ pub fn build_stake_tx(
burn_zkbin: &ZkBinary,
burn_pk: &ProvingKey,
slot_index: u64,
eta: pallas::Base,
) -> Result<(MoneyStakeParams, Vec<Proof>, Vec<LeadCoin>, Vec<ValueBlind>, Vec<ValueBlind>)> {
// convert owncoins to leadcoins.
// TODO: verify this token blind usage
@@ -1117,7 +1116,6 @@ pub fn build_stake_tx(
let sk_root = sk_tree.root(0).unwrap();
let sk_merkle_path = sk_tree.authentication_path(sk_pos, &sk_root).unwrap();
let leadcoin = LeadCoin::new(
eta, // randomness from last finalized block.
coin.note.value,
slot_index, // tau
coin.secret.inner(), // coin secret key

6
src/contract/money/tests/verification_bench.rs
View File

@@ -100,6 +100,9 @@ async fn alice2alice_random_amounts() -> Result<()> {
&th.alice_kp.public,
amount,
token_id,
pallas::Base::zero(),
pallas::Base::zero(),
pallas::Base::random(&mut OsRng),
&owncoins,
&th.alice_merkle_tree,
&th.mint_zkbin,
@@ -239,6 +242,9 @@ async fn alice2alice_random_amounts_multiplecoins() -> Result<()> {
&th.alice_kp.public,
amount,
token_id,
pallas::Base::zero(),
pallas::Base::zero(),
pallas::Base::random(&mut OsRng),
&coins,
&th.alice_merkle_tree,
&th.mint_zkbin,