igneum-network/igneum
1
0
Fork 0
Code Issues Pull requests Releases Activity

prover: a segment record the chain rule refuses is held and offered again every pass until the segment's deadline (the fresh-record window on the 0.3.11 rule is one segment length in DAA); the tile counts held records; the fast-time file sets the fresh-rule switch

Browse source 
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
igneum-labs 2026-10-06 08:03:46 +00:00
parent 8649259dde
commit 71c41f791c
4 changed files with 108 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

114
app/igneum-app/src/prover.rs
View file

@ -350,6 +350,10 @@ fn loop_forever(shared: Arc<Shared>, bin_dir: PathBuf) {
// proving v1 segment path: (first, last, aggregator wei) of the segment records this machine submitted
let mut submitted_segments: Vec<(u64, u64, u128)> = Vec::new();
let mut last_segment_secs: Option<f64> = None;
// segment records the node refused by the chain rule ("does not chain to ... pending"): held and offered again
// every pass until the segment's deadline (the fresh-record window of spec 7.8 is the segment length in DAA on
// the rule as shipped, 6 October 2026; from the fresh-rule switch the first retry lands)
let mut held_segments: Vec<HeldSegment> = Vec::new();
let mut last_verifier_read = Instant::now() - Duration::from_secs(600);
let mut asked_restart = false;
// macOS and Linux: the host sits next to the engine, so its pinned ids are read at once, proving on or off
@ -483,6 +487,37 @@ fn loop_forever(shared: Arc<Shared>, bin_dir: PathBuf) {
});
}
}
// held segment records: offered again, dropped past the deadline
if !held_segments.is_empty() {
let tip_daa = evm_rpc(&shared, "igneum_getProvingStatus", json!([]), Duration::from_secs(10)).ok().and_then(|st| st["tipDaa"].as_str().and_then(|x| u64::from_str_radix(x.trim_start_matches("0x"), 16).ok())).unwrap_or(0);
let mut keep = Vec::new();
for h in held_segments.drain(..) {
match retry_held(&shared, &h, tip_daa) {
Retry::Accepted => {
shared.event("proving", &format!("segment {}..{} record accepted on retry {} (held {} s)", h.first, h.last, h.tries + 1, h.since.elapsed().as_secs()));
submitted_segments.push((h.first, h.last, h.agg_wei));
set(&shared, |p| {
p.segments_submitted += 1;
p.aggregated += 1;
p.segment_note = format!("segment {}..{} accepted on retry", h.first, h.last);
});
}
Retry::Expired(why) => {
shared.log(&format!("prover: segment {}..{} record dropped after {} tries: {why}", h.first, h.last, h.tries));
}
Retry::Again(why) => {
let mut h = h;
h.tries += 1;
if h.tries % 30 == 1 {
shared.log(&format!("prover: segment {}..{} record held (try {}): {why}", h.first, h.last, h.tries));
}
keep.push(h);
}
}
}
held_segments = keep;
set(&shared, |p| p.segments_held = held_segments.len() as u32);
}
// paid segments among what we submitted
for (first, last, wei) in submitted_segments.clone() {
let paid = evm_rpc(&shared, "igneum_getSegmentRecords", json!([format!("{first:#x}")]), Duration::from_secs(10))
@ -525,7 +560,21 @@ fn loop_forever(shared: Arc<Shared>, bin_dir: PathBuf) {
attempted_segments.insert(seg.first);
let started = Instant::now();
match prove_segment(&shared, t, &seg, &keys[0].0, &payout, prev_file.as_deref(), &expected_pv, &mut submitted) {
Ok(agg_wei) => {
Ok(SegmentOutcome::Held(h)) => {
let secs = started.elapsed().as_secs_f64();
last_segment_secs = Some(secs);
shared.event("proving", &format!("segment {}..{}: {} shards proven and submitted in {secs:.0} s; the segment record is held ({})", seg.first, seg.last, seg.shards.len(), h.why));
set(&shared, |p| {
p.segment_last_s = secs;
p.status = "submitted".into();
p.message = format!("segment {}..{}: shards submitted, the segment record waits for the chain rule", seg.first, seg.last);
p.segment_note = format!("segment {}..{} proven whole in {secs:.0} s; its record is held: {}", seg.first, seg.last, h.why);
p.current = String::new();
});
held_segments.push(h);
set(&shared, |p| p.segments_held = held_segments.len() as u32);
}
Ok(SegmentOutcome::Submitted(agg_wei)) => {
let secs = started.elapsed().as_secs_f64();
last_segment_secs = Some(secs);
submitted_segments.push((seg.first, seg.last, agg_wei));
@ -649,6 +698,44 @@ fn loop_forever(shared: Arc<Shared>, bin_dir: PathBuf) {
}
}
/// A segment record the node refused by the chain rule, kept with its proof for another offer.
pub struct HeldSegment {
pub first: u64,
pub last: u64,
pub deadline_daa: u64,
pub record: String,
pub proof_path: PathBuf,
pub agg_wei: u128,
pub why: String,
pub tries: u32,
pub since: Instant,
}
pub enum SegmentOutcome {
Submitted(u128),
Held(HeldSegment),
}
pub enum Retry {
Accepted,
Again(String),
Expired(String),
}
/// Offers a held segment record again: accepted, held for another pass, or dropped past the segment's deadline.
fn retry_held(shared: &Shared, h: &HeldSegment, tip_daa: u64) -> Retry {
if tip_daa > 0 && tip_daa + 1 > h.deadline_daa {
return Retry::Expired(format!("past the deadline DAA {} at tip DAA {tip_daa}", h.deadline_daa));
}
let Ok(proof) = std::fs::read(&h.proof_path) else { return Retry::Expired(format!("proof file {} gone", h.proof_path.display())) };
let proof_hex = format!("0x{}", proof.iter().map(|b| format!("{b:02x}")).collect::<String>());
match evm_rpc(shared, "igneum_submitSegmentRecord", json!([{ "record": h.record, "proof": proof_hex }]), Duration::from_secs(60)) {
Ok(r) if r["accepted"].as_bool().unwrap_or(false) => Retry::Accepted,
Ok(r) => Retry::Again(r["reason"].as_str().unwrap_or("?").to_string()),
Err(e) => Retry::Again(e),
}
}
/// Proving v1 segment path, the choice: the node's v1 status (active, the grid start, the segment length, the
/// deadline clock), the work list grouped into whole untouched segments (`segments::whole_segments`), the
/// candidates inside the deadline ranked for this key, then for the best three the node's segment statement:
@ -714,7 +801,7 @@ fn pick_segment(shared: &Shared, work: &[Work], key_hash: &str, attempted: &mut
/// one host run (`--mode chain --save-shards`, `--prev` when the chain continues) that proves every shard and
/// aggregates the segment, then every shard record signed and submitted (the shard payouts) and the segment
/// record signed and submitted (the aggregator share). Returns the segment's aggregator wei.
fn prove_segment(shared: &Shared, t: &Tools, seg: &crate::segments::SegmentWork, label: &str, payout: &str, prev_file: Option<&str>, expected_pv: &str, submitted: &mut Vec<(u64, String, u32, u128)>) -> Result<u128, String> {
fn prove_segment(shared: &Shared, t: &Tools, seg: &crate::segments::SegmentWork, label: &str, payout: &str, prev_file: Option<&str>, expected_pv: &str, submitted: &mut Vec<(u64, String, u32, u128)>) -> Result<SegmentOutcome, String> {
let (first, last) = (seg.first, seg.last);
let dir = shared.runtime.app_dir.join("proving").join(format!("seg-{first}"));
let _ = std::fs::create_dir_all(&dir);
@ -802,18 +889,25 @@ fn prove_segment(shared: &Shared, t: &Tools, seg: &crate::segments::SegmentWork,
let proof = std::fs::read(to_win(&proof_file)).map_err(|e| format!("segment proof file {proof_file}: {e}"))?;
let proof_hex = format!("0x{}", proof.iter().map(|b| format!("{b:02x}")).collect::<String>());
let r = evm_rpc(shared, "igneum_submitSegmentRecord", json!([{ "record": record, "proof": proof_hex }]), Duration::from_secs(60))?;
if !r["accepted"].as_bool().unwrap_or(false) {
return Err(format!("segment record refused: {}", r["reason"].as_str().unwrap_or("?")));
}
set(shared, |p| p.aggregated += 1);
let hexu = |x: &Value| x.as_str().and_then(|s| u128::from_str_radix(s.trim_start_matches("0x"), 16).ok()).unwrap_or(0);
let agg_wei = evm_rpc(shared, "igneum_getSegmentStatement", json!([format!("{first:#x}")]), Duration::from_secs(10)).map(|s| hexu(&s["aggregatorWei"])).unwrap_or(0);
// the shard proofs stay for the aggregator of the next segment (the chain link is the segment proof, read back
// from the pool); the fixtures and the export go
let stmt = evm_rpc(shared, "igneum_getSegmentStatement", json!([format!("{first:#x}")]), Duration::from_secs(10)).unwrap_or(Value::Null);
let agg_wei = hexu(&stmt["aggregatorWei"]);
// the fixtures and the export go; the proofs stay (the next segment's chain link, and a held record's offer)
for b in first..=last {
let _ = std::fs::remove_file(dir.join(format!("block-{b}.json")));
}
Ok(agg_wei)
if !r["accepted"].as_bool().unwrap_or(false) {
let why = r["reason"].as_str().unwrap_or("?").to_string();
// the chain rule's refusal ("does not chain to ... pending until DAA ..."): held, not failed; anything else
// (a bad statement, a late carrier) is an error
if why.contains("does not chain") {
let deadline = hexu(&stmt["status"]["deadline_daa"]) as u64;
return Ok(SegmentOutcome::Held(HeldSegment { first, last, deadline_daa: if deadline > 0 { deadline } else { u64::MAX }, record, proof_path: to_win(&proof_file), agg_wei, why, tries: 0, since: Instant::now() }));
}
return Err(format!("segment record refused: {why}"));
}
set(shared, |p| p.aggregated += 1);
Ok(SegmentOutcome::Submitted(agg_wei))
}
/// Proving v1 (spec 7.8): one aggregation attempt. When the node reports v1 active, takes the newest executed

2
app/igneum-app/src/state.rs
View file

@ -211,6 +211,8 @@ pub struct ProvingState {
#[serde(serialize_with = "u128_string")]
pub segment_paid_wei: u128,
pub segment_last_s: f64,
/// segment records the node refused by the chain rule and this machine offers again each pass
pub segments_held: u32,
}
#[derive(Clone, Serialize, Default)]

2
app/igneum-app/ui/app.js
View file

@ -1013,7 +1013,7 @@ if (typeof document !== 'undefined') (function () {
setText('pv-paid-sub', pv.paid_wei ? (Number(pv.paid_wei) / 1e18).toFixed(4) + ' IGN earned' : 'shards paid out');
// proving v1 segments (6 October 2026): whole segments this machine proved, and the segment path's last line
var segLine = '';
if (pv.segments_submitted) segLine = 'Segments: ' + pv.segments_submitted + ' proven whole, ' + (pv.segments_paid || 0) + ' paid' + (pv.segment_paid_wei && Number(pv.segment_paid_wei) ? ' (' + (Number(pv.segment_paid_wei) / 1e18).toFixed(4) + ' IGN to the aggregator)' : '') + (pv.segment_last_s ? ', the last in ' + Math.round(pv.segment_last_s) + ' s' : '') + '.';
if (pv.segments_submitted) segLine = 'Segments: ' + pv.segments_submitted + ' proven whole, ' + (pv.segments_paid || 0) + ' paid' + (pv.segment_paid_wei && Number(pv.segment_paid_wei) ? ' (' + (Number(pv.segment_paid_wei) / 1e18).toFixed(4) + ' IGN to the aggregator)' : '') + (pv.segment_last_s ? ', the last in ' + Math.round(pv.segment_last_s) + ' s' : '') + (pv.segments_held ? ', ' + pv.segments_held + ' record' + (pv.segments_held > 1 ? 's' : '') + ' held for the chain rule' : '') + '.';
if (pv.segment_note && enabled) segLine += (segLine ? ' ' : '') + pv.segment_note + '.';
$('pv-seg-note').hidden = !segLine; setText('pv-seg-note', segLine);
var v = View.verifierWords(pv);

1
infra/fast-time/override-60x.json
View file

@ -58,6 +58,7 @@
"proving_v1_activation_daa": 18446744073709551615,
"proving_v1_segment_blocks": 8,
"proving_v1_unproven_daa": 10,
"proving_v1_fresh_rule_daa": 0,
"proving_v1_aggregator_share_bps": 1000,
"fees": {"pgas": {"version": 1, "cycles_per_pgas": 1000, "intrinsic_pgas_per_tx": 300, "modexp_base": 10, "modexp_per_byte_numer": 1, "modexp_per_byte_denom": 10}, "block_proving_gas_limit": 120000, "shard_proving_gas_budget": 30000, "min_execution_base_fee_wei": 100000000000, "min_proving_base_fee_wei": 10000000000000, "initial_execution_base_fee_wei": 100000000000, "initial_proving_base_fee_wei": 10000000000000, "base_fee_change_denominator": 8}
}