lockupvault

Author: vans163

ex/build.Dockerfile

@@ -3,9 +3,9 @@
 FROM ubuntu:24.04
 ENV DEBIAN_FRONTEND noninteractive
 
-ENV SSL_VERSION=3.6.2
-ENV OTP_VERSION=OTP-28.5
-ENV ELIXIR_VERSION=v1.19.5
+ENV SSL_VERSION=3.6.3
+ENV OTP_VERSION=OTP-29.0.3
+ENV ELIXIR_VERSION=v1.20.2
 
 RUN apt-get update && apt-get install -y vim git curl locate wget apt-transport-https apt-utils locales
 ENV LANGUAGE en_US.UTF-8

ex/native/rdb/src/consensus/bic/epoch.rs

@@ -1,7 +1,7 @@
 use crate::consensus::aggsig::DST_MOTION;
 use crate::{bcat, consensus};
 use num_bigint::BigUint;
-use std::collections::HashSet;
+use std::collections::{BTreeMap, HashSet};
 use std::panic::panic_any;
 
 use crate::consensus::consensus_apply::ApplyEnv;
@@ -10,6 +10,18 @@ use crate::consensus::consensus_kv::{kv_delete, kv_exists, kv_get, kv_get_next,
 pub const EPOCH_EMISSION_BASE: i128 = 1_000_000_000_000_000;
 pub const EPOCH_INTERVAL: i128 = 100_000;
 
+pub const NETWORK_TAX_BPS: i128 = 2_500; //25%
+
+pub const SOLVER_PARTICIPATION_TARGET: i128 = 100;
+
+pub const PARTICIPATION_VAULT_EPOCH: u64 = 1150;
+
+//per-epoch emission not disbursed carries over in these pools: the vault pool feeds
+//back into future vault APY budgets (and funds the network tax); the solver pool
+//just accumulates for now (disposition TBD).
+pub const VAULT_ACCRUED_POOL_KEY: &[u8] = b"bic:epoch:vault_accrued_pool";
+pub const SOLVER_ACCRUED_POOL_KEY: &[u8] = b"bic:epoch:solver_accrued_pool";
+
 pub const TREASURY_DONATION_ADDRESS: &[u8; 48] = &[
     140, 71, 6, 83, 31, 185, 171, 240, 47, 5, 14, 246, 98, 23, 105, 24, 183, 118, 193, 92, 66, 82, 64, 5, 239, 255, 254, 87, 139, 252, 148, 176, 113, 6, 207,
     153, 51, 25, 202, 45, 48, 153, 223, 248, 219, 210, 80, 254,
@@ -611,11 +623,138 @@ pub fn next(env: &mut ApplyEnv) {
     clear_epoch_data(env);
 }
 
-fn distribute_emissions_to_trainers(env: &mut ApplyEnv, trainers_to_recv: &Vec<(Vec<u8>, i128)>, total_emission: i128, total_sols: i128) {
+//epoch boundary from VAULT_ACTIVATION_EPOCH on (and always on testnet): the vault
+//engine plus the reworked emission model. same backbone as next() — collect
+//leaders, set next epoch's validators, adjust difficulty, clear epoch data — with:
+//  * queued vault validator changes post once, first thing (the only promotion site)
+//  * emission split in half: vault APY vs solvers
+//  * vault APY paid from (this half + carried pool); leftover carries on
+//  * a 25% treasury tax on all payouts, FUNDED from the vault leftover (not minted
+//    on top) so issuance stays within the curve
+//  * emission curbed by participation (phash): below SOLVER_PARTICIPATION_TARGET only
+//    phash% pays, the rest accrues. always applies to the solver half; applies to
+//    vault APY too from PARTICIPATION_VAULT_EPOCH on
+//  * validator set = peddlebike67 + every >=1m-stake vault validator + top 33 solvers
+//  * no community-fund payout (peddlebike67 only enter the validator set)
+pub fn next2(env: &mut ApplyEnv) {
+    let epoch_cur = env.caller_env.entry_epoch;
+    let epoch_next = env.caller_env.entry_epoch + 1;
+
+    consensus::bic::lockup_vault::promote_pending_validators(env, epoch_next);
+
+    let peddlebike67_map: HashSet<Vec<u8>> = if env.testnet {
+        env.testnet_peddlebikes.iter().map(|pk| pk.to_vec()).collect()
+    } else {
+        PEDDLEBIKE67.iter().map(|pk| pk.to_vec()).collect()
+    };
+
+    let trainers = kv_get_trainers(env, env.caller_env.entry_height);
+    let trainers_map: HashSet<Vec<u8>> = trainers.into_iter().collect();
+    let trainers_removed = kv_get_trainers_removed(env);
+    let trainers_removed_map: HashSet<Vec<u8>> = trainers_removed.into_iter().collect();
+
+    //total_score_all sums EVERY sol submitter (matching the stats `score()` used by
+    //pflops); leaders excludes slashed (removed) trainers, as in next().
+    let mut leaders: Vec<(Vec<u8>, i128)> = Vec::new();
+    let mut total_score_all: i128 = 0;
+    let mut cursor: Vec<u8> = Vec::new();
+    while let Some((pk, val)) = kv_get_next(env, b"bic:epoch:solutions_count:", &cursor) {
+        let count = std::str::from_utf8(&val).ok().and_then(|s| s.parse::<i128>().ok()).unwrap_or_else(|| panic_any("invalid_solutions_count"));
+        total_score_all = total_score_all.checked_add(count).unwrap_or_else(|| panic_any("invalid_solutions_count"));
+        if !trainers_removed_map.contains(&pk) {
+            leaders.push((pk.clone(), count));
+        }
+        cursor = pk;
+    }
+    // sort descending; highest sol count first; tiebreak on PK
+    leaders.sort_unstable_by(|(ka, ca), (kb, cb)| match cb.cmp(ca) {
+        std::cmp::Ordering::Equal => kb.cmp(ka),
+        other => other,
+    });
+
+    //every sol-submitting solver in the set (not a peddlebike) is eligible — no cap
+    let solvers: Vec<(Vec<u8>, i128)> =
+        leaders.iter().cloned().filter(|(pk, _)| trainers_map.contains(pk) && !peddlebike67_map.contains(pk)).collect();
+    let total_sols: i128 = solvers.iter().map(|(_, count)| count).sum();
+
+    let epoch_total_emission = epoch_emission_active(epoch_cur);
+    let vault_half = epoch_total_emission / 2;
+    let solver_half = epoch_total_emission - vault_half;
+
+    //--- participation (phash) — computed up front so it can also curb vault APY ---
+    //at phash >= SOLVER_PARTICIPATION_TARGET (100 PFLOPS) full emission pays; below that
+    //only phash% pays and the shortfall accrues, so a low-participation (bear) period
+    //can't take the lion's share of easy emissions.
+    let height_in_epoch = (env.caller_env.entry_height % 100_000) as i128;
+    let phash = net_phash(env, total_score_all, height_in_epoch);
+    let participation = phash.clamp(0, SOLVER_PARTICIPATION_TARGET); //0..=100
+
+    //participation curbs the solver half always; it curbs vault APY only from
+    //PARTICIPATION_VAULT_EPOCH on. before that, vaults always pay full and only solvers
+    //are curbed; after it, low solver participation heavily reduces vault APY too.
+    let vault_reduction_pct: u64 = if epoch_cur >= PARTICIPATION_VAULT_EPOCH { participation as u64 } else { 100 };
+
+    //--- vault APY ---
+    let vault_pool = kv_get(env, VAULT_ACCRUED_POOL_KEY).and_then(|v| std::str::from_utf8(&v).ok().and_then(|s| s.parse::<i128>().ok())).unwrap_or(0);
+    let vault_budget = vault_half.checked_add(vault_pool).unwrap_or_else(|| panic_any("vault_budget_overflow"));
+    let vault_paid = consensus::bic::lockup_vault::pay_epoch_yield(env, &trainers_map, vault_reduction_pct, vault_budget);
+    let vault_leftover = vault_budget.checked_sub(vault_paid).unwrap_or_else(|| panic_any("vault_pool_underflow"));
+    let vault_stakes = consensus::bic::lockup_vault::validator_stakes(env);
+
+    //--- solver emission, curbed by participation ---
+    let solver_budget = solver_half.checked_mul(participation).unwrap_or_else(|| panic_any("emission_overflow")) / SOLVER_PARTICIPATION_TARGET;
+    let solver_paid = distribute_emissions_to_trainers(env, &solvers, solver_budget, total_sols);
+    //the part of the solver half not paid (participation shortfall + rounding) accrues
+    let solver_accrued = solver_half.checked_sub(solver_paid).unwrap_or_else(|| panic_any("emission_overflow"));
+    if solver_accrued > 0 {
+        let _ = kv_increment(env, SOLVER_ACCRUED_POOL_KEY, solver_accrued);
+    }
+
+    //--- 25% network tax, charged AFTER all participation reductions so it tracks what
+    //was actually paid (vault_paid and solver_paid are already reduced). funded from the
+    //vault leftover so it never exceeds emission; capped at the leftover — payouts are
+    //never cut, the tax yields first. remaining leftover rolls into the vault pool. ---
+    let taxable = vault_paid.checked_add(solver_paid).unwrap_or_else(|| panic_any("emission_overflow"));
+    let nominal_tax = taxable.checked_mul(NETWORK_TAX_BPS).unwrap_or_else(|| panic_any("emission_overflow")) / 10_000;
+    let tax = nominal_tax.min(vault_leftover);
+    if tax > 0 {
+        let _ = kv_increment(env, &bcat(&[b"account:", TREASURY_DONATION_ADDRESS.as_slice(), b":balance:AMA"]), tax);
+    }
+    let new_vault_pool = vault_leftover - tax;
+    kv_put(env, VAULT_ACCRUED_POOL_KEY, new_vault_pool.to_string().as_bytes());
+
+    //--- validators for next epoch: peddlebike67 + >=1m vault validators + top 33 solvers ---
+    let new_validators = build_and_shuffle_new_validators2(env, &leaders, &vault_stakes);
+    let new_validators = consensus::bic::list_of_binaries_to_vecpak(new_validators);
+    let height_next = format!("{:012}", env.caller_env.entry_height.saturating_add(1)).into_bytes();
+    let _ = kv_put(env, &bcat(&[b"bic:epoch:validators:height:", &height_next]), &new_validators);
+
+    update_difficulty_and_log_sols(env, epoch_cur, epoch_next, total_sols);
+    clear_epoch_data(env);
+}
+
+fn net_phash(env: &mut ApplyEnv, total_sols: i128, height_in_epoch: i128) -> i128 {
+    const OPS: i128 = 16 * 16 * 50_240 * 2; //25_722_880 (MACs x2, per pflops)
+
+    let diff_bits = kv_get(env, b"bic:epoch:diff_bits")
+        .and_then(|v| std::str::from_utf8(&v).ok().and_then(|s| s.parse::<u32>().ok()))
+        .unwrap_or(24);
+    let diff_multiplier: i128 = if diff_bits >= 127 { i128::MAX } else { 1i128 << diff_bits };
+
+    let total_calcs = total_sols.checked_mul(diff_multiplier).unwrap_or(i128::MAX);
+    let numer = total_calcs.checked_mul(OPS).unwrap_or(i128::MAX);
+    let denom = (height_in_epoch + 2).checked_mul(500_000_000_000_000).unwrap_or_else(|| panic_any("phash_denom_overflow"));
+    numer / denom
+}
+
+//distributes `total_emission` to solvers pro rata by sol count (paid in full);
+//returns the total actually paid, which the caller uses for tax accounting.
+fn distribute_emissions_to_trainers(env: &mut ApplyEnv, trainers_to_recv: &Vec<(Vec<u8>, i128)>, total_emission: i128, total_sols: i128) -> i128 {
     if total_sols == 0 {
-        return;
+        return 0;
     }
 
+    let mut paid: i128 = 0;
     for (trainer, trainer_sols) in trainers_to_recv {
         let coins = trainer_sols
             .checked_mul(total_emission)
@@ -627,9 +766,13 @@ fn distribute_emissions_to_trainers(env: &mut ApplyEnv, trainers_to_recv: &Vec<(
             if let Some(addr) = emission_address { bcat(&[b"account:", &addr, b":balance:AMA"]) } else { bcat(&[b"account:", trainer, b":balance:AMA"]) };
 
         let _ = kv_increment(env, &balance_key, coins);
+        paid = paid.checked_add(coins).unwrap_or_else(|| panic_any("emission_overflow"));
     }
+    paid
 }
 
+//legacy (pre-VAULT_ACTIVATION_EPOCH) community-fund split. from the fork on,
+//peddlebike67 receive no emission payout — they only enter the validator set.
 fn distribute_peddlebike67_community_fund(env: &mut ApplyEnv, total_emission: i128) {
     let n_count = PEDDLEBIKE67.len() as i128;
     let q = total_emission / n_count;
@@ -646,6 +789,10 @@ fn distribute_peddlebike67_community_fund(env: &mut ApplyEnv, total_emission: i1
     }
 }
 
+//number of top solvers admitted to the validator set from the fork on
+const SOLVER_VALIDATOR_SLOTS: usize = 33;
+
+//legacy (pre-fork) validator set: peddlebike67 + all leaders, capped at 99.
 fn build_and_shuffle_new_validators(env: &ApplyEnv, leaders: &Vec<(Vec<u8>, i128)>) -> Vec<Vec<u8>> {
     let PEDDLEBIKE_LOCAL: Vec<[u8; 48]> = if env.testnet {
         env.testnet_peddlebikes.iter().map(|pk| pk.as_slice().try_into().expect("Testnet key was not 48 bytes long")).collect()
@@ -660,12 +807,50 @@ fn build_and_shuffle_new_validators(env: &ApplyEnv, leaders: &Vec<(Vec<u8>, i128
     new_validators.extend(filtered_leaders);
     new_validators.truncate(99);
 
+    shuffle_validators(env, &mut new_validators);
+    new_validators
+}
+
+//fork validator set: peddlebike67 + every >=1m-stake vault validator + top 33 solvers,
+//deduped, no fixed size cap.
+fn build_and_shuffle_new_validators2(env: &ApplyEnv, leaders: &Vec<(Vec<u8>, i128)>, vault_stakes: &BTreeMap<Vec<u8>, i128>) -> Vec<Vec<u8>> {
+    let PEDDLEBIKE_LOCAL: Vec<[u8; 48]> = if env.testnet {
+        env.testnet_peddlebikes.iter().map(|pk| pk.as_slice().try_into().expect("Testnet key was not 48 bytes long")).collect()
+    } else {
+        PEDDLEBIKE67.to_vec()
+    };
+
+    let mut new_validators: Vec<Vec<u8>> = PEDDLEBIKE_LOCAL.iter().map(|p| p.to_vec()).collect();
+
+    //vault-backed validators with at least VALIDATOR_MIN_STAKE (1m AMA amount+accrued)
+    for (validator, stake) in vault_stakes {
+        if *stake >= consensus::bic::lockup_vault::VALIDATOR_MIN_STAKE {
+            new_validators.push(validator.clone());
+        }
+    }
+
+    //top SOLVER_VALIDATOR_SLOTS solvers (leaders are pre-sorted by sol count desc,
+    //so a low-sol solver only enters if fewer than 33 out-sol it)
+    let top_solvers = leaders
+        .iter()
+        .map(|(pk, _)| pk.clone())
+        .filter(|pk| !PEDDLEBIKE_LOCAL.iter().any(|p| p.as_slice() == pk.as_slice()))
+        .take(SOLVER_VALIDATOR_SLOTS);
+    new_validators.extend(top_solvers);
+
+    //a vault validator may also be a peddlebike or a top solver; keep first occurrence
+    let mut seen: HashSet<Vec<u8>> = HashSet::new();
+    new_validators.retain(|pk| seen.insert(pk.clone()));
+
+    shuffle_validators(env, &mut new_validators);
+    new_validators
+}
+
+fn shuffle_validators(env: &ApplyEnv, validators: &mut Vec<Vec<u8>>) {
     let seed_bytes = &env.caller_env.seed;
     let seed_array: [u8; 32] = seed_bytes.get(..32).and_then(|s| s.try_into().ok()).unwrap_or([0u8; 32]);
     let mut rng = crate::consensus::bic::exsss::Exsss::from_seed(&seed_array);
-    rng.shuffle(&mut new_validators);
-
-    new_validators
+    rng.shuffle(validators);
 }
 
 fn update_difficulty_and_log_sols(env: &mut ApplyEnv, epoch_cur: u64, epoch_next: u64, total_sols: i128) {