Repository navigation
Expand file tree
/
Copy pathproposer.rs
More file actions
697 lines (597 loc) · 27 KB
/
Copy pathproposer.rs
File metadata and controls
697 lines (597 loc) · 27 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
use std::{env, sync::Arc, time::Duration};
use alloy_primitives::{Address, TxHash, U256};
use alloy_provider::{Provider, ProviderBuilder};
use alloy_sol_types::SolEvent;
use anyhow::{Context, Result};
use op_succinct_client_utils::boot::BootInfoStruct;
use op_succinct_elfs::AGGREGATION_ELF;
use op_succinct_host_utils::{
block_range::{split_range_based_on_safe_heads, split_range_basic, SpanBatchRange},
fetcher::OPSuccinctDataFetcher, get_agg_proof_stdin, host::OPSuccinctHost,
metrics::MetricsGauge, witness_generation::WitnessGenerator,
};
use op_succinct_proof_utils::get_range_elf_embedded;
use op_succinct_signer_utils::Signer;
use sp1_sdk::{
network::FulfillmentStrategy, NetworkProver, Prover, ProverClient, SP1ProofMode,
SP1ProofWithPublicValues, SP1ProvingKey, SP1VerifyingKey, SP1_CIRCUIT_VERSION,
};
use tokio::time;
use crate::{
config::RollupProposerConfig,
contract::Rollup::{RollupInstance, ProposalSubmitted, ProposalStatus},
prometheus::ProposerGauge,
Action, L1Provider, L2Provider, L2ProviderTrait, RollupTrait,
};
struct SP1Prover {
network_prover: Arc<NetworkProver>,
range_pk: Arc<SP1ProvingKey>,
range_vk: Arc<SP1VerifyingKey>,
agg_pk: Arc<SP1ProvingKey>,
}
pub struct RollupProposer<P, H: OPSuccinctHost>
where
P: Provider + Clone + Send + Sync,
{
pub config: RollupProposerConfig,
pub prover_address: Address,
pub signer: Signer,
pub l1_provider: L1Provider,
pub l2_provider: L2Provider,
pub rollup: Arc<RollupInstance<P>>,
pub safe_db_fallback: bool,
pub proposer_bond: U256,
pub challenger_bond: U256,
pub proposal_interval: u64,
prover: SP1Prover,
fetcher: Arc<OPSuccinctDataFetcher>,
host: Arc<H>,
}
impl<P, H: OPSuccinctHost> RollupProposer<P, H>
where
P: Provider + Clone + Send + Sync,
{
/// Creates a new proposer instance for the Rollup contract
pub async fn new(
prover_address: Address,
signer: Signer,
rollup: RollupInstance<P>,
fetcher: Arc<OPSuccinctDataFetcher>,
host: Arc<H>,
) -> Result<Self> {
let config = RollupProposerConfig::from_env()?;
// Set a default network private key to avoid an error in mock mode
let private_key = env::var("NETWORK_PRIVATE_KEY").unwrap_or_else(|_| {
tracing::warn!(
"Using default NETWORK_PRIVATE_KEY of 0x01. This is only valid in mock mode."
);
"0x0000000000000000000000000000000000000000000000000000000000000001".to_string()
});
let network_prover =
Arc::new(ProverClient::builder().network().private_key(&private_key).build());
let (range_pk, range_vk) = network_prover.setup(get_range_elf_embedded());
let (agg_pk, _) = network_prover.setup(AGGREGATION_ELF);
// Fetch bond constants from contract
let proposer_bond = rollup.PROPOSER_BOND().call().await?;
let challenger_bond = rollup.CHALLENGER_BOND().call().await?;
// Fetch proposal interval from contract to avoid config mismatch
let proposal_interval_u256 = rollup.PROPOSAL_INTERVAL().call().await?;
let proposal_interval: u64 = proposal_interval_u256.to::<u64>();
Ok(Self {
config: config.clone(),
prover_address,
signer,
l1_provider: ProviderBuilder::default().connect_http(config.l1_rpc.clone()),
l2_provider: ProviderBuilder::default().connect_http(config.l2_rpc),
rollup: Arc::new(rollup),
safe_db_fallback: config.safe_db_fallback,
proposer_bond,
challenger_bond,
proposal_interval,
prover: SP1Prover {
network_prover,
range_pk: Arc::new(range_pk),
range_vk: Arc::new(range_vk),
agg_pk: Arc::new(agg_pk),
},
fetcher: fetcher.clone(),
host,
})
}
/// Proves a proposal that has been challenged
pub async fn prove_proposal(&self, proposal_id: U256) -> Result<TxHash> {
// First check if the proposal exists and needs proving
let proposal = self.rollup.getProposal(proposal_id).call().await?;
let proposal_status = proposal.proposalStatus;
match proposal_status {
ProposalStatus::Challenged => {
tracing::info!("Proposal {} is challenged, proceeding with proof generation", proposal_id);
}
ProposalStatus::ChallengedAndValidProofProvided => {
return Err(anyhow::anyhow!("Proposal {} already has a valid proof", proposal_id));
}
ProposalStatus::Resolved => {
return Err(anyhow::anyhow!("Proposal {} is already resolved", proposal_id));
}
_ => {
return Err(anyhow::anyhow!("Proposal {} is not in a challenged state", proposal_id));
}
}
let l1_head_hash = proposal.l1Head;
tracing::debug!("L1 head hash: {:?}", hex::encode(l1_head_hash));
let l2_block_number = proposal.l2BlockNumber;
// Validate proposal data
tracing::info!("Proposal details:");
tracing::info!(" Proposal ID: {}", proposal_id);
tracing::info!(" L1 Head: 0x{}", hex::encode(l1_head_hash));
tracing::info!(" L2 Block Number: {}", l2_block_number);
tracing::info!(" Root Claim: 0x{}", hex::encode(proposal.rootClaim));
tracing::info!(" Proposer: 0x{}", hex::encode(proposal.proposer));
tracing::info!(" Deadline: {}", proposal.deadline);
// Step 3: Compute start/end blocks
// Retrieve parent proposal to determine start block
let parent_proposal = self
.rollup
.getProposal(U256::from(proposal.parentIndex))
.call()
.await?;
let l2_start = parent_proposal.l2BlockNumber as u64;
let l2_end = l2_block_number as u64;
tracing::info!("Block range: {} - {}", l2_start, l2_end);
tracing::info!("Range proof interval: {} blocks", self.config.range_proof_interval);
// Step 4: Split the span exactly like the estimator
let safe_db_activated = self.fetcher.is_safe_db_activated().await?;
let ranges: Vec<SpanBatchRange> = if safe_db_activated {
tracing::info!("Using safe head based range splitting");
split_range_based_on_safe_heads(l2_start, l2_end, self.config.range_proof_interval).await?
} else {
tracing::info!("Using basic range splitting");
split_range_basic(l2_start, l2_end, self.config.range_proof_interval)
};
tracing::info!("Split into {} ranges: {:?}", ranges.len(), ranges);
// Step 5: Generate range proofs per chunk (sequential)
let mut proofs = Vec::new();
let mut boot_infos = Vec::new();
for (i, range) in ranges.iter().enumerate() {
tracing::info!("Processing range {}/{}: blocks {} - {}", i + 1, ranges.len(), range.start, range.end);
let host_args = self
.host
.fetch(
range.start,
range.end,
Some(l1_head_hash.into()),
self.config.safe_db_fallback,
)
.await
.context(format!("Failed to fetch host args for range {} - {}", range.start, range.end))?;
let witness_data = self.host.run(&host_args).await
.context(format!("Failed to run host for range {} - {}", range.start, range.end))?;
let sp1_stdin = self.host.witness_generator().get_sp1_stdin(witness_data)
.context(format!("Failed to get SP1 stdin for range {} - {}", range.start, range.end))?;
tracing::info!("Generating range proof for blocks {} - {}", range.start, range.end);
let range_proof = if self.config.mock_mode {
let (public_values, _) =
self.prover.network_prover.execute(get_range_elf_embedded(), &sp1_stdin).run()?;
SP1ProofWithPublicValues::create_mock_proof(
&self.prover.range_pk,
public_values,
SP1ProofMode::Compressed,
SP1_CIRCUIT_VERSION,
)
} else {
self.prover
.network_prover
.prove(&self.prover.range_pk, &sp1_stdin)
.compressed()
.strategy(FulfillmentStrategy::Hosted)
.skip_simulation(true)
.cycle_limit(self.config.cycle_limit)
.run_async()
.await?
};
let mut public_values = range_proof.public_values.clone();
let boot_info: BootInfoStruct = public_values.read();
boot_infos.push(boot_info);
proofs.push(range_proof.proof);
}
tracing::info!("All {} range proofs generated successfully", ranges.len());
// Step 6: Aggregate once, exactly as you already do
tracing::info!("Preparing stdin for aggregation proof");
// Use the first boot info's l1Head for all header fetching (they should all be the same)
let l1_head = boot_infos[0].l1Head;
let headers = self.fetcher
.get_header_preimages(&boot_infos, l1_head)
.await
.context("Failed to get header preimages")?;
let agg_stdin = get_agg_proof_stdin(
proofs,
boot_infos,
headers,
&self.prover.range_vk,
l1_head,
self.prover_address,
)
.context("Failed to get aggregation proof stdin")?;
tracing::info!("Generating aggregation proof");
let agg_proof = if self.config.mock_mode {
tracing::info!("Using mock mode for aggregation proof generation");
let (public_values, _) = self
.prover
.network_prover
.execute(AGGREGATION_ELF, &agg_stdin)
.deferred_proof_verification(false)
.run()?;
SP1ProofWithPublicValues::create_mock_proof(
&self.prover.agg_pk,
public_values,
SP1ProofMode::Groth16,
SP1_CIRCUIT_VERSION,
)
} else {
self.prover
.network_prover
.prove(&self.prover.agg_pk, &agg_stdin)
.groth16()
.run_async()
.await?
};
let transaction_request = self.rollup.proveProposal(proposal_id, agg_proof.bytes().into()).into_transaction_request();
let receipt = self
.signer
.send_transaction_request(self.config.l1_rpc.clone(), transaction_request)
.await?;
Ok(receipt.transaction_hash)
}
/// Creates a new proposal
pub async fn create_proposal(
&self,
l2_block_number: U256,
parent_id: U256,
) -> Result<U256> {
tracing::info!("=== Proposal Creation Parameters ===");
tracing::info!("Config values:");
tracing::info!(" - Proposal interval: {:?} blocks", self.proposal_interval);
tracing::info!(" - Fast finality mode: {:?}", self.config.fast_finality_mode);
tracing::info!(" - Safe DB fallback: {:?}", self.config.safe_db_fallback);
tracing::info!(" - Mock mode: {:?}", self.config.mock_mode);
tracing::info!("Proposal parameters:");
tracing::info!(" - L2 block number: {:?}", l2_block_number);
tracing::info!(" - Parent ID: {:?}", parent_id);
tracing::info!(" - Prover address: {:?}", self.prover_address);
tracing::info!(" - Rollup address: {:?}", self.rollup.address());
let output_root = self.l2_provider.compute_output_root_at_block(l2_block_number).await?;
tracing::info!("Output root: 0x{}", hex::encode(output_root));
let transaction_request = self
.rollup
.submitProposal(
output_root,
l2_block_number.try_into().unwrap(),
parent_id.to::<u32>(),
)
.value(self.proposer_bond)
.into_transaction_request();
tracing::info!("Transaction details:");
tracing::info!(" - From address: {:?}", self.signer.address());
tracing::info!(" - To address: {:?}", self.rollup.address());
tracing::info!(" - Value (proposer bond): {} wei", self.proposer_bond);
tracing::info!("=== End Proposal Creation Parameters ===");
let receipt = self
.signer
.send_transaction_request(self.config.l1_rpc.clone(), transaction_request)
.await?;
tracing::info!("Transaction receipt:");
tracing::info!(" - Transaction hash: {:?}", receipt.transaction_hash);
tracing::info!(" - Block number: {:?}", receipt.block_number);
tracing::info!(" - Gas used: {:?}", receipt.gas_used);
let proposal_id = receipt
.inner
.logs()
.iter()
.find_map(|log| {
ProposalSubmitted::decode_log(&log.inner).ok().map(|event| event.proposalId)
})
.context("Could not find ProposalSubmitted event in transaction receipt logs")?;
tracing::info!(
"\x1b[1mNew proposal {} created for block {} with tx {:?}\x1b[0m",
proposal_id,
l2_block_number,
receipt.transaction_hash
);
if self.config.fast_finality_mode {
tracing::info!("Fast finality mode enabled: Generating proof for the proposal immediately");
let tx_hash = self.prove_proposal(proposal_id).await?;
tracing::info!(
"\x1b[1mProposal {} proved with tx {:?}\x1b[0m",
proposal_id,
tx_hash
);
}
Ok(proposal_id)
}
/// Handles the creation of a new proposal if conditions are met
pub async fn handle_proposal_creation(&self) -> Result<Option<U256>> {
let _span = tracing::info_span!("[[Proposing]]").entered();
// Determine the reference block for the next proposal using the latest *valid* proposal.
let (reference_block, reference_proposal_id) = match self.rollup.get_latest_valid_proposal(self.l2_provider.clone()).await? {
Some((block, id)) => (block, id),
None => {
// This should never happen in normal operation; treat as fatal.
return Err(anyhow::anyhow!("No valid proposals exist on-chain; deploy logic requires at least the genesis proposal."));
}
};
tracing::info!(
"Reference proposal ID: {}, L2 block: {}",
reference_proposal_id,
reference_block
);
// Calculate next L2 block number for proposal with overflow check
let next_l2_block_number = reference_block
.checked_add(U256::from(self.proposal_interval))
.ok_or_else(|| anyhow::anyhow!("Overflow calculating next L2 block number"))?;
let finalized_l2_head_block_number = self
.host
.get_finalized_l2_block_number(&self.fetcher, reference_block.to::<u64>())
.await?;
tracing::info!(
"Finalized L2 head block number: {:?}",
finalized_l2_head_block_number
);
// Only create a new proposal if the finalized L2 head block number is greater than the next L2 block number
if let Some(finalized_block) = finalized_l2_head_block_number {
tracing::info!(
"Comparing finalized block ({:?}) with next proposal block ({:?})",
finalized_block,
next_l2_block_number
);
if U256::from(finalized_block) > U256::from(next_l2_block_number) {
tracing::info!(
"Creating new proposal - Finalized block ({:?}) is ahead of next proposal block ({:?})",
finalized_block,
next_l2_block_number
);
let proposal_id = self
.create_proposal(U256::from(next_l2_block_number), reference_proposal_id)
.await?;
Ok(Some(proposal_id))
} else {
tracing::info!(
"Skipping proposal creation - Finalized block ({:?}) is not ahead of next proposal block ({:?})",
finalized_block,
next_l2_block_number
);
Ok(None)
}
} else {
tracing::info!(
"No finalized block number found since latest proposal block ({:?})",
reference_block
);
Ok(None)
}
}
/// Handles the resolution of eligible proposals
pub async fn handle_proposal_resolution(&self) -> Result<()> {
let _span = tracing::info_span!("[[Resolving]]").entered();
// Get the range of proposals to check
let proposals_length = self.rollup.get_proposals_length().await?;
let anchor_id = U256::from(self.rollup.anchorProposalId().call().await?);
let start_id = proposals_length.saturating_sub(U256::from(self.config.max_proposals_to_check_for_resolution));
let start_id = start_id.max(anchor_id);
let mut resolved_count = 0;
for i in 0..self.config.max_proposals_to_check_for_resolution {
let proposal_id = start_id + U256::from(i);
if proposal_id >= proposals_length {
break;
}
if proposal_id == U256::ZERO {
continue; // Skip genesis proposal
}
// Check if resolvable in a single call
let is_resolvable = match self.rollup.isResolvable(proposal_id).call().await {
Ok(resolvable) => resolvable,
Err(_) => continue,
};
if !is_resolvable {
continue;
}
// Try to resolve this proposal
let transaction_request = self.rollup.resolveProposal(proposal_id).into_transaction_request();
match self
.signer
.send_transaction_request(self.config.l1_rpc.clone(), transaction_request)
.await
{
Ok(receipt) => {
tracing::info!(
"\x1b[1mSuccessfully resolved proposal {} with tx {:?}\x1b[0m",
proposal_id,
receipt.transaction_hash
);
ProposerGauge::ProposalsResolved.increment(1.0);
resolved_count += 1;
}
Err(e) => {
tracing::debug!("Could not resolve proposal {}: {:?}", proposal_id, e);
}
}
}
if resolved_count == 0 {
tracing::debug!("No proposals were resolved");
} else {
tracing::info!("Resolved {} proposals", resolved_count);
}
Ok(())
}
/// Handles the defense of proposals by providing proofs
pub async fn handle_proposal_defense(&self) -> Result<()> {
let _span = tracing::info_span!("[[Defending]]").entered();
// Get the range of proposals to check
let proposals_length = self.rollup.get_proposals_length().await?;
let anchor_id = U256::from(self.rollup.anchorProposalId().call().await?);
let start_id = proposals_length.saturating_sub(U256::from(self.config.max_proposals_to_check_for_defense));
let start_id = start_id.max(anchor_id);
let mut defended_count = 0;
for i in 0..self.config.max_proposals_to_check_for_defense {
let proposal_id = start_id + U256::from(i);
if proposal_id >= proposals_length {
break;
}
if proposal_id == U256::ZERO {
continue; // Skip genesis proposal
}
// Check if needs defense in a single call
let needs_defense = match self.rollup.needsDefense(proposal_id).call().await {
Ok(needs) => needs,
Err(_) => continue,
};
if !needs_defense {
continue;
}
// Get the proposal details to check if it's ours
let proposal = match self.rollup.getProposal(proposal_id).call().await {
Ok(p) => p,
Err(_) => continue,
};
// Check if this is our proposal by verifying the output root
let output_root = match self.l2_provider.compute_output_root_at_block(U256::from(proposal.l2BlockNumber)).await {
Ok(root) => root,
Err(e) => {
tracing::warn!("Failed to compute output root for proposal {}: {:?}", proposal_id, e);
continue;
}
};
if output_root != proposal.rootClaim {
continue; // Not our proposal, skip defense
}
tracing::info!("Attempting to defend proposal {}", proposal_id);
match self.prove_proposal(proposal_id).await {
Ok(tx_hash) => {
tracing::info!(
"\x1b[1mSuccessfully defended proposal {} with tx {:?}\x1b[0m",
proposal_id,
tx_hash
);
defended_count += 1;
}
Err(e) => {
tracing::warn!("Failed to defend proposal {}: {:?}", proposal_id, e);
ProposerGauge::ProposalDefenseError.increment(1.0);
}
}
}
if defended_count == 0 {
tracing::debug!("No proposals were defended");
} else {
tracing::info!("Defended {} proposals", defended_count);
}
Ok(())
}
/// Handles claiming bonds from resolved proposals
pub async fn handle_bond_claiming(&self) -> Result<Action> {
let _span = tracing::info_span!("[[Claiming Bonds]]").entered();
// Check if we have any credit to claim
let credit = self.rollup.credit(self.prover_address).call().await?;
if credit == U256::ZERO {
tracing::info!("No credit to claim");
return Ok(Action::Skipped);
}
tracing::info!("Attempting to claim credit: {} wei", credit);
let transaction_request = self.rollup.claimCredit(self.prover_address).into_transaction_request();
match self
.signer
.send_transaction_request(self.config.l1_rpc.clone(), transaction_request)
.await
{
Ok(receipt) => {
tracing::info!(
"\x1b[1mSuccessfully claimed {} wei with tx {:?}\x1b[0m",
credit,
receipt.transaction_hash
);
ProposerGauge::BondsClaimed.increment(1.0);
Ok(Action::Performed)
}
Err(e) => Err(anyhow::anyhow!("Failed to claim credit: {:?}", e)),
}
}
/// Fetch the proposer metrics
async fn fetch_proposer_metrics(&self) -> Result<()> {
// Get the anchor proposal for metrics
let _anchor_proposal_id = self.rollup.anchorProposalId().call().await?;
let anchor_proposal = self
.rollup
.getProposal(U256::from(_anchor_proposal_id))
.call()
.await?;
// Update metrics for anchor L2 block number
ProposerGauge::AnchorProposalL2BlockNumber.set(anchor_proposal.l2BlockNumber as f64);
// Get the latest proposal
let proposals_length = self.rollup.get_proposals_length().await?;
let latest_proposal_id = if proposals_length > U256::ZERO {
proposals_length - U256::from(1)
} else {
U256::ZERO
};
if latest_proposal_id > U256::ZERO {
let latest_proposal = self.rollup.getProposal(latest_proposal_id).call().await?;
ProposerGauge::LatestProposalL2BlockNumber.set(latest_proposal.l2BlockNumber as f64);
// Update metrics for finalized L2 block number based on latest proposal's block
if let Some(finalized_l2_block_number) = self
.host
.get_finalized_l2_block_number(&self.fetcher, latest_proposal.l2BlockNumber as u64)
.await?
{
ProposerGauge::FinalizedL2BlockNumber.set(finalized_l2_block_number as f64);
}
}
Ok(())
}
/// Runs the proposer indefinitely
pub async fn run(&self) -> Result<()> {
tracing::info!("Rollup Proposer running...");
let mut interval = time::interval(Duration::from_secs(self.config.fetch_interval));
let mut metrics_interval = time::interval(Duration::from_secs(15));
loop {
tokio::select! {
_ = interval.tick() => {
match self.handle_proposal_creation().await {
Ok(Some(_)) => {
ProposerGauge::ProposalsCreated.increment(1.0);
}
Ok(None) => {}
Err(e) => {
tracing::warn!("Failed to handle proposal creation: {:?}", e);
ProposerGauge::ProposalCreationError.increment(1.0);
}
}
if let Err(e) = self.handle_proposal_defense().await {
tracing::warn!("Failed to handle proposal defense: {:?}", e);
ProposerGauge::ProposalDefenseError.increment(1.0);
}
if self.config.enable_proposal_resolution {
if let Err(e) = self.handle_proposal_resolution().await {
tracing::warn!("Failed to handle proposal resolution: {:?}", e);
ProposerGauge::ProposalResolutionError.increment(1.0);
}
}
match self.handle_bond_claiming().await {
Ok(Action::Performed) => {
ProposerGauge::BondsClaimed.increment(1.0);
}
Ok(Action::Skipped) => {}
Err(e) => {
tracing::warn!("Failed to handle bond claiming: {:?}", e);
ProposerGauge::BondClaimingError.increment(1.0);
}
}
}
_ = metrics_interval.tick() => {
if let Err(e) = self.fetch_proposer_metrics().await {
tracing::warn!("Failed to fetch metrics: {:?}", e);
ProposerGauge::MetricsError.increment(1.0);
}
}
}
}
}
}