refactor(gamma): big decimal

Author: cong-or

Cargo.lock

@@ -31,6 +31,17 @@ FRAGMENTS_STORAGE=/tmp/fund9-leader-1/persist/leader-1
 
 ```
 
+```bash
+
+OFFICIAL_RESULTS=/tmp/activevoteplans.json 
+BLOCK0=/tmp/fund9-leader-1/artifacts/block0.bin
+FRAGMENTS_STORAGE=/tmp/fund9-leader-1/persist/leader-1
+QUADRATIC_SCALE=0.1
+
+./target/release/offline --fragments $FRAGMENTS_STORAGE --block0 $BLOCK0 --official-results $OFFICIAL_RESULTS --quadratic_scaling $QUADRATIC_SCALE
+
+```
+
 This will create three files:
 - *ledger_after_tally.json* **(decrypted ledger state after tally)** *should match official results!*
 - *ledger_before_tally.json* **(encrypted ledger state before tally)** 

src/audit/README.md

@@ -19,6 +19,7 @@ use lib::offline::{
 
 use chain_core::packer::Codec;
 use color_eyre::{eyre::Context, Report};
+use std::env;
 use std::{error::Error, path::PathBuf};
 
 ///
@@ -36,6 +37,12 @@ pub struct Args {
     /// cross reference official results
     #[clap(short, long)]
     official_results: Option<String>,
+    /// Quadratic scaling
+    #[clap(short, long)]
+    gamma: Option<String>,
+    /// Quadratic scaling
+    #[clap(short, long)]
+    precision: Option<String>,
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
@@ -95,6 +102,16 @@ fn main() -> Result<(), Box<dyn Error>> {
     // use tally tool to validate decrypted results
     let shares_and_results = extract_decryption_shares_and_results(all_fragments);
 
+    if let Some(gamma) = args.gamma {
+        const SCALE_FACTOR: &str = "QUADRATIC_VOTING_SCALING_FACTOR";
+        std::env::set_var(SCALE_FACTOR, gamma);
+    }
+
+    if let Some(precision) = args.precision {
+        const PRECISION: &str = "QUADRATIC_VOTING_PRECISION";
+        std::env::set_var(PRECISION, precision);
+    }
+
     // Compare decrypted tallies with official results if provided
     if let Some(official_results) = args.official_results {
         // official catalyst results in json format

src/audit/src/offline/bin/main.rs

@@ -32,7 +32,7 @@ criterion = { version = "0.3.0", optional = true }
 rand = "0.8"
 cryptoxide = "0.4"
 tracing.workspace = true
-num-integer = "0.1"
+bigdecimal = "0.4.7"
 
 
 [features]

src/chain-libs/chain-impl-mockchain/Cargo.toml

@@ -3,8 +3,14 @@ use crate::{
     value::Value,
     vote::{Choice, Options},
 };
+use bigdecimal::BigDecimal;
+use bigdecimal::ToPrimitive;
 use chain_vote::EncryptedTally;
-use num_integer::Roots;
+use std::num::NonZeroI64;
+
+use std::str::FromStr;
+
+use std::env;
 use std::fmt;
 use thiserror::Error;
 
@@ -167,11 +173,22 @@ impl TallyResult {
         } else {
             let index = choice.as_byte() as usize;
 
-            // Returns the truncated principal square root of an integer – ⌊√x⌋
-            // This is solving for r in r² = x, rounding toward zero. The result will satisfy r² ≤ x < (r+1)²
-            let weight_gammad = weight.0.sqrt();
+            const SCALE_FACTOR: &str = "QUADRATIC_VOTING_SCALING_FACTOR";
+            const PRECISION: &str = "QUADRATIC_VOTING_PRECISION";
+
+            let scaling_factor = env::var(SCALE_FACTOR).unwrap_or(1.to_string());
+            let precision =
+                i64::from_str(&env::var(PRECISION).unwrap_or(1.to_string())).unwrap_or(1);
+
+            let gamma = BigDecimal::from_str(&scaling_factor).unwrap_or(BigDecimal::from(1));
+            let stake = BigDecimal::from(weight.0);
+
+            let weight = (gamma * stake)
+                .round(precision)
+                .to_u64()
+                .unwrap_or(weight.0);
 
-            self.results[index] = self.results[index].saturating_add(Weight(weight_gammad));
+            self.results[index] = self.results[index].saturating_add(Weight(weight));
 
             Ok(())
         }

src/chain-libs/chain-impl-mockchain/src/vote/tally.rs

@@ -15,7 +15,8 @@ cryptoxide = "^0.4.2"
 const_format = "0.2"
 base64 = "0.21.0"
 tracing = "0.1"
-num-integer = "0.1"
+bigdecimal = "0.4.7"
+
 
 
 [dev-dependencies]

src/chain-libs/chain-vote/Cargo.toml

@@ -1,5 +1,8 @@
+use std::num::NonZeroI64;
 use std::num::NonZeroU64;
 
+use std::str::FromStr;
+
 use crate::GroupElement;
 use crate::{
     committee::*,
@@ -9,9 +12,13 @@ use crate::{
     TallyOptimizationTable,
 };
 use base64::{engine::general_purpose, Engine as _};
+
+use bigdecimal::BigDecimal;
+use bigdecimal::ToPrimitive;
 use cryptoxide::blake2b::Blake2b;
 use cryptoxide::digest::Digest;
-use num_integer::Roots;
+
+use std::env;
 
 use rand_core::{CryptoRng, RngCore};
 
@@ -158,14 +165,21 @@ impl EncryptedTally {
         assert_eq!(ballot.vote().len(), self.r.len());
         assert_eq!(ballot.fingerprint(), &self.fingerprint);
 
-        // Returns the truncated principal square root of an integer – ⌊√x⌋
-        // This is solving for r in r² = x, rounding toward zero. The result will satisfy r² ≤ x < (r+1)²
-        let weight_gammad = weight.sqrt();
+        const SCALE_FACTOR: &str = "QUADRATIC_VOTING_SCALING_FACTOR";
+        const PRECISION: &str = "QUADRATIC_VOTING_PRECISION";
+
+        let scaling_factor = env::var(SCALE_FACTOR).unwrap_or(1.to_string());
+        let precision = i64::from_str(&env::var(PRECISION).unwrap_or(1.to_string())).unwrap_or(1);
+
+        let gamma = BigDecimal::from_str(&scaling_factor).unwrap_or(BigDecimal::from(1));
+        let stake = BigDecimal::from(weight);
+
+        let weight = (gamma * stake).round(precision).to_u64().unwrap_or(weight);
 
         for (ri, ci) in self.r.iter_mut().zip(ballot.vote().iter()) {
-            *ri = &*ri + &(ci * weight_gammad);
+            *ri = &*ri + &(ci * weight);
         }
-        self.max_stake += weight_gammad;
+        self.max_stake += weight;
     }
 
     /// Given a single committee member's `secret_key`, returns a partial decryption of