Dynamic Fraud Proof

Andrea Fortugno; Gabriele Picco

REVIEW 3 major objections 4 minor 19 references

Dynamic Fraud Proof

T0 review · 3 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Dynamic Fraud Proofs claim sub-second finality by requiring random verifier approvals instead of a fixed challenge window.

desk verdict A clear design sketch whose fast-finality claim rests on an unexamined random-sampling assumption; the probabilistic model computes the wrong probability. read the letter →

arxiv 2502.10321 v1 pith:YG4AACOP submitted 2025-02-14 cs.CR cs.DC

Gabriele Picco , Andrea Fortugno This is my paper · ORCID

classification cs.CRcs.DC

keywords fraudproofsoptimisticrollupsdynamicchallengeperiodfastfinalityEphemeralSolanaVirtualMachineverifierquorumwindowextension

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper proposes a fraud-proof mechanism that replaces the fixed seven-day challenge window of optimistic rollups with a dynamic window that, under ideal conditions, settles state in sub-seconds. The Dynamic Fraud Proof construction requires a configurable number of randomly selected active verifiers to sign off on a state commitment; if enough approve, the state finalizes, and if not, the window grows exponentially while the required number of approvers shrinks. The paper's motivation is that fast finality is what allows off-chain execution layers such as ephemeral rollups to support real-time interactive applications instead of waiting minutes or hours for state to surface on the base layer. The paper contends that the design preserves the traditional single-honest-node assumption by inverting the challenge process, and it formalizes a probabilistic model of the chance that a challenge is raised.

What carries the argument

The central object is the Dynamic Fraud Proof construction, an assert/challenge scheme in which finality depends on affirmative approvals rather than on the absence of challenges. The mechanism's two controls are the exponential challenge-window sequence $t_n = t_0 r_t^n$ and the exponential required-approver sequence $c_n = c_0 r_c^n$. These sequences allow the window to start near 500 ms and grow to roughly 6 days after ten steps, while the required number of active challengers decays from 100 to about 2. The probabilistic model $P(E) = P(F)P(D|F)P(T)(1-(1-P(C_i))^N)$ is the formal device used to estimate how often fast finality is achieved and to motivate bonding and slashing as ways to raise the detection and participation probabilities.

What would settle it

Compute the probability that a random $c_0$-sized committee drawn from $N$ verifiers contains at least one honest node under the paper's assumption that only one honest node exists. If that probability is materially below 1 for the proposed parameters, then a malicious quorum could approve a fraudulent state diff and the sub-second finality claim would not preserve the single-honest-node guarantee.

Watch

Extended reading notes

Core claim

The central claim is that the Dynamic Fraud Proof mechanism achieves fast finality by inverting the traditional optimistic challenge process. Rather than a fixed challenge window during which anyone may raise a challenge, a randomly selected set of active challengers must interactively approve the asserted state diff without raising a challenge. If the required number $c_0$ of approvals is reached by the end of the initial window $t_0$, the state settles; otherwise the window is extended by a factor $r_t$ and the required approvals are reduced by a factor $r_c$, until the window is long enough to behave like a classic fraud-proof system. The paper formalizes the challenge probability as $P(E) = P(F)P(D|F)P(T)(1-(1-P(C_i))^N)$ and argues that with bonding, slashing, and incentives this yields approximately 99.11% probability of achieving the target finality in its example.

Load-bearing premise

The load-bearing premise is that a randomly selected approval quorum of size $c_0$ is sufficiently likely to contain an honest actor who would block fraud, even though the analysis quantifies the probability that any node raises a challenge rather than the probability that the quorum's signers are honest.

Editorial extensions

If this is right

If the mechanism holds, optimistic rollups can target sub-second finality in ideal conditions while keeping a fallback to long challenge windows when the approval quorum is not met.
The exponential extension and approval-decay rules make the same construction tunable to different values at stake, participant sets, and bond sizes without a protocol-wide change.
Because finality requires affirmative sign-offs from a random set of verifiers, an attacker cannot simply censor challenges for a fixed duration to push through an invalid assertion.
Under the paper's example parameters, the model predicts about 99.11% of commitments would reach fast finality, with the remaining cases automatically delayed until a longer window restores classic fraud-proof safety.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A natural extension is to derive the probability that the randomly selected committee of $c_0$ verifiers contains at least one honest member as a function of $c_0$, $N$, and the honest-node fraction, since that probability would directly bound the safety of sub-second finality.
Because the commitment granularity is an account diff, the same dynamic-window construction could be applied beyond the paper's base-layer virtual machine, to any layer with fast block times and account-style state, and could also govern cross-chain message passing.
Pairing the approval quorum with data-availability sampling could let light clients serve as active challengers, lowering the hardware barrier to participation and making the ideal-condition assumption more realistic.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

First thing to know: the central security claim doesn't survive contact with the trust model. The paper says it keeps the single-honest-node assumption of traditional fraud proofs while letting c0 randomly selected active challengers approve a diff. With one honest node in the whole network, the chance that a random sample of 100 misses it is about (9999/10000)^100 ≈ 0.99. So the mechanism actually assumes at least one honest node in every approval sample, which is strictly stronger. Section 4.2's P(E) is the marginal probability that at least one node raises a challenge; it is not the conditional probability that a fraudulent diff is rejected before c0 sign-offs. And Example 4.2.1 sets P(T)=1 even though the target window is 500ms.

That said, the paper does useful work. Dynamic challenge periods are not new — the authors cite [18] — but the specific combination of an exponentially growing window with a shrinking required approval quorum, framed for the SVM account model, is a legitimate new variant. The system description is clear and the extension logic is easy to follow. The paper is honest that dispute resolution is out of scope and that DAS is future work.

The soft spots are in proportion: Section 4.2's model is the load-bearing part and it is mis-specified. It mixes P(F) and P(D|F) without conditioning on the actual selection of signers. The bonding/slashing discussion in 4.2.2 is asserted, not derived. The claim that the system can reach 'security level nearly equivalent to the base layer' is unsupported. There is no implementation or simulation, so the 99.11% finality figure in the example is just arithmetic from chosen parameters, not a measure of security.

Who this is for: someone working on rollup finality designs might read it as a design proposal and a cautionary example. It is not a validated mechanism. It deserves a serious referee if the venue is open to design papers that state open problems, because the flaw is precisely the kind a good referee can surface. I would not cite it as a security result, but I might point people to it as a clear statement of an approach that needs a proper sampling analysis.

My recommendation: send it to peer review as a position/design paper, but with a revision request that either proves the sampling guarantee, weakens the trust model, or removes the claim that the single-honest-node assumption is preserved.

Referee Report

3 major / 4 minor

Summary. The paper presents "Dynamic Fraud Proof" (DFP), a modification of optimistic fraud-proof mechanisms intended for Ephemeral Rollups on Solana. The core proposal is to let a state commitment be finalized at the end of a very short challenge window (t0 = 500ms in the running example) if a configurable number c0 of randomly selected "active challengers" sign off without raising a challenge; if the threshold is not met, the challenge window grows exponentially (t_n = t0 * rt^n) while the required number of signers decays (c_n = c0 * rc^n), eventually falling back to a traditional long challenge window with no active-challenger requirement. The paper claims this preserves the standard single-honest-node assumption of fraud proofs while enabling sub-second finality, and it presents a probabilistic model in Section 4.2 and an economic-incentive discussion in Section 4.2.2.

Significance. The goal of shortening optimistic-rollup finality from days to seconds with a dynamic, adversarial-awareness mechanism is a relevant research problem, and the paper contains an interesting design intuition (inverting the challenge process by requiring random sign-offs). The paper's central security claim, however, is not supported. The analysis in Section 4.2 computes the marginal probability that at least one node raises a challenge, which is a different quantity from the probability that a fraudulent commitment is denied approval by the randomly selected quorum. As a result, the paper does not establish that the mechanism preserves the single-honest-node assumption; in fact it requires a strictly stronger assumption. Since the security analysis is the foundation of the claimed contribution, the paper is not publishable in its current form.

major comments (3)

[Section 4.2, P(E) formula] The model computes P(E) = P(F) * P(D|F) * P(T) * (1 - (1 - P(Ci))^N), which is the unconditional probability that at least one of N nodes raises a challenge. To justify the fast-finality rule of Section 3 step 4a, the paper needs the probability that a fraudulent state diff is NOT approved by the c0 randomly selected signers (i.e., that at least one honest node is selected and challenges, or that the diff is otherwise prevented from finalizing). These are not the same event. With a single honest node among N=10^4 and c0=100, the chance the honest node is excluded from the sample is roughly (1 - 100/10^4)^100 ≈ 0.99, so the proposed mechanism actually assumes that every approval sample contains an honest, actively monitoring verifier, which is strictly stronger than the traditional any-honest-party-can-challenge model. No analysis of this selection probability is provided.
[Section 4.2.1, Example] The example sets P(T)=1 while the protocol's fast path uses t0=500 ms; this simply assumes away the detection challenge the paper is trying to solve. Consequently, the derived 99.11% figure is not a guarantee of secure finality; it is just 1 minus the probability that some node challenges, and it does not bound the probability that c0 colluding malicious signers approve an invalid diff. The paper never computes the probability of that bad event, which is the quantity that determines the security of the fast path.
[Section 4.1.2, fallback to traditional challenge model] The transition from the approval-based fast path to the traditional challenge model is unspecified. The text states that when the challenge window extends to 7+ days, the system operates like traditional fraud proofs and the number of active challengers can be zero, but it does not explain how the protocol determines that the fallback condition is reached, nor does it analyze whether an adversary can force acceptance of an invalid diff while the system is in the intermediate regime where both a shortened window and an approval requirement coexist. The exponential formulas t_n = t0 * rt^n and c_n = c0 * rc^n are asserted without a security argument for why this particular schedule is safe.

minor comments (4)

[Section 2, first bullet] The phrase "trough native delegation" contains a typo and should read "through native delegation."
[Section 4.2, model variables] The defined variable P(R) (participation rate) is never used in the P(E) formula; either remove it or incorporate it consistently into the model.
[Section 4.2, notation] The notation P(T) is defined as "the probability that a node detects fraud within the challenge window T," but T is also used to denote the challenge window itself; this dual use of T is confusing and should be disambiguated.
[Abstract and Section 1, 'ideal scenarios'] The paper repeatedly refers to "ideal scenarios" and "optimal conditions" for fast finality, but never formally defines what these conditions are; a precise definition (e.g., all active challengers are honest and monitoring) would make the claims more testable.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the security analysis is parametric and incomplete, but no claimed result is equivalent by construction to its inputs.

full rationale

The claimed fast finality is a protocol design (Section 3, step 4a settles when c0 randomly selected active challengers sign off), not a result derived from an independent premise; consequently there is no derivation chain that reduces to its inputs. The Section 4.2 formalization is an explicit parametric model: P(E) is defined as the probability that at least one node raises a challenge, and the 99.11% figure in Example 4.2.1 is a direct arithmetic consequence of the stated P(F)=0.01, P(D|F)=0.9, P(T)=1, N=100, and P(Ci)=0.1 values. That is a conditional illustration, not a fitted parameter renamed as a prediction. The real weakness is an omitted proof: Sections 3 and 4.1 assert that the c0-approval rule retains the traditional single-honest-node assumption, but Section 4.2 neither models the random selection of the c0 sample nor computes the probability that a fraudulent diff is approved by c0 malicious signers; this is a security-model gap, which is a correctness risk rather than circularity. The exponential extension formulas t_n = t0 * r_t^n and c_n = c0 * r_c^n are presented as design parameters, not derived results. The only self-citation ([12]) supplies architectural context for Ephemeral Rollups and is not load-bearing for the DFP security claim. Accordingly, no circular step meets the quoted-evidence bar.

Assumptions & free parameters 5 free parameters · 4 assumptions · 0 invented entities

The paper's central claims depend on several hand-chosen parameters (t0, rt, c0, rc) and on strong assumptions about the behavior and selection of active challengers. The probabilistic security model is not anchored to external data or to a formal adversarial model, so the claimed finality and security levels are essentially consequences of the assumed inputs.

free parameters (5)

t0 (initial challenge window) = 500 ms
Chosen by hand in Section 4.1.1; the sub-second finality claim directly depends on this value.
rt (time growth factor) = 4
Chosen by hand to illustrate exponential extension from 500 ms to 2 seconds.
c0 (initial number of required active challengers) = 100
Chosen by hand in Section 4.1.2; finality requires this many sign-offs, so security depends on it.
rc (challenger decay factor) = 0.7
Chosen by hand to reduce the required number of challengers over extensions.
P(F), P(D|F), P(T), N, P(Ci) in the example = 0.01, 0.9, 1, 100, 0.1
Assumed values in Section 4.2.1; the resulting 99.11% finality figure is arithmetic on these inputs.

assumptions (4)

domain assumption At least one honest party exists among all nodes, and the mechanism preserves the traditional single-honest-node assumption.
The paper claims this in Sections 3 and 4.2, but the approval quorum mechanism actually requires that the randomly selected set be trustworthy, which is a stronger condition.
domain assumption Active challengers verify state transitions in parallel, so P(T)=1 within the short window.
Sub-second finality is only possible if active challengers complete verification within the initial window; this is an assumption, not a measured or derived property stated in Section 4.1.
domain assumption Verifier nodes are sampled independently and uniformly at random.
The model in Section 4.2 states 'under the assumption that all nodes operates independently', and no concrete random selection scheme is specified.
ad hoc to paper Bonding and slashing can be tuned to reach the target values of P(F), P(D|F), and P(R).
Asserted in Section 4.2.2 without a formal economic model, and used to justify the claim that security can be made nearly equivalent to the base layer.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Dynamic Fraud Proof." pith.science (2026). https://pith.science/paper/YG4AACOP

@misc{pith2026250210321,
  author       = {Pith},
  title        = {Pith review of: Dynamic Fraud Proof},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YG4AACOP}},
  note         = {Machine review of arXiv:2502.10321}
}

read the original abstract

In this paper, we present a novel fraud-proof mechanism that achieves fast finality and, when combined with optimistic execution, enables real-time transaction processing. State-of-the-art optimistic rollups typically adopt a 7-day challenge window, during which any honest party can raise a challenge in case of fraud. We propose a new assert/challenge construction called "Dynamic Fraud Proofs" that achieves sub-second finality in ideal scenarios, while dynamically delaying settlement in the event of fraud detection and challenge resolution. The system relies on 1) a dynamic challenge period and 2) a configurable number of randomly selected verifier nodes who must interactively approve a state commitment without raising a challenge. If these conditions are not met, the state is not finalized, and the challenge period and approval criteria are dynamically adjusted. We provide a detailed analysis of the system's design, explaining how it maintains the assumption of a single honest node and addresses censorship attacks by inverting the traditional challenge process. Additionally, we formalize the system's probabilistic security model and discuss how bonding, incentives, and slashing mechanisms can encourage honest behavior, thereby increasing the likelihood of fast settlement in ideal scenarios.

Figures

Figures reproduced from arXiv: 2502.10321 by the authors.

**Figure 1.** The system is comprised of several key components: The Delegation Program manages account locking/unlocking, state commitments, and finalization on the base SVM. The Operator is a node running an Ephemeral SVM session, while the Provisioner listens for delegation events, selects operators, and manages runtime provisioning. The Security Committee verifies execution and data availability, supported by the Data Availab… view at source ↗

**Figure 2.** The process of state finalization in an ER involves multiple steps to ensure integrity and security. The ER node first submits a commitment of the state difference it intends to finalize. A challenge window is then initiated, allowing participants to raise challenges against any invalid state commitment. If a challenge is raised, a dispute resolution process begins, preventing the state from being finalized until th… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

19 extracted references · 18 canonical work pages

[18]

Why wait a week? Fast Finality Optimistic Rollups

Nick Sway. Why wait a week? Fast Finality Optimistic Rollups. https://ethresear. ch / t / why - wait - a - week - fast - finality - optimistic - rollups / 18868. Ac- cessed: 2024-08-01. 2024. 12

work page 2024
[1]

Building Scalable Decentralized Payment Systems

John Adler and Mikerah Quintyne-Collins. “Building Scalable Decentralized Pay- ment Systems”. In: CoRR abs/1904.06441 (2019). arXiv: 1904.06441. url: http: //arxiv.org/abs/1904.06441

work page Pith review arXiv 2019
[2]

BoLD: Fast and Cheap Dispute Resolution

Mario M. Alvarez et al. BoLD: Fast and Cheap Dispute Resolution. 2024. arXiv: 2404.10491 [cs.CR]. url: https://arxiv.org/abs/2404.10491

work page Pith review arXiv 2024
[3]

Scalable, transparent, and post-quantum secure computa- tional integrity

Eli Ben-Sasson et al. “Scalable, transparent, and post-quantum secure computa- tional integrity”. In: IACR Cryptol. ePrint Arch.2018 (2018), p. 46. url: https: //api.semanticscholar.org/CorpusID:44557939

work page 2018
[4]

A review of zk-SNARKs

Thomas Chen et al. “A review of zk-SNARKs”. In: arXiv preprint arXiv:2202.06877 (2022)

arXiv 2022
[5]

Challenging Periods Reimagined Series Part I - Road to a Dynamic Challenging Period

Andr´ e Pereira Daniel Fonseca. Challenging Periods Reimagined Series Part I - Road to a Dynamic Challenging Period. Accessed: 2024-07-07. url: https : / / threesigma.xyz/blog/optimistic-rollups-challenging-periods-reimagined- part-one

work page 2024
[6]

Optimizing challenge periods in rollup

Ed Felten. Optimizing challenge periods in rollup. Accessed: 2024-07-07. url: https : / / medium . com / offchainlabs / optimizing - challenge - periods - in - rollup-b61378c87277

work page 2024
[7]

Why is the Optimistic Rollup challenge period 7 days?Accessed: 2024-07-07

Kelvin Fichter. Why is the Optimistic Rollup challenge period 7 days?Accessed: 2024-07-07. url: https://kelvinfichter.com/pages/thoughts/challenge- periods/

work page 2024

Show all 19 references

[8]

Tinydancer: Diet Client v0 for the Solana Blockchain

Anoushk Kharangate Harsh Patel. Tinydancer: Diet Client v0 for the Solana Blockchain. Accessed: 2023-10-07. url: https://www.tinydancer.io/whitepaper. pdf

2023
[9]

Arbitrum: Scalable, private smart contracts

Harry A. Kalodner et al. “Arbitrum: Scalable, private smart contracts”. In: USENIX Security Symposium. 2018. url: https://api.semanticscholar.org/CorpusID: 52046120

2018
[10]

Announcing Jito Restaking

Jito Labs. Announcing Jito Restaking. https : / / www . jito . network / blog / announcing-jito-restaking/. Accessed: 2024-08-02. 2023

2024
[11]

Picasso Network: Connecting the Dots in DeFi

Picasso Network. Picasso Network: Connecting the Dots in DeFi. https://www. picasso.network/. Accessed: 2024-08-02. 2024

2024
[12]

Ephemeral Rollups are All you Need

Gabriele Picco and Andrea Fortugno. “Ephemeral Rollups are All you Need”. In: arXiv preprint arXiv:2311.02650(2023)

2023 arXiv
[13]

Plasma : Scalable Autonomous Smart Contracts

Joseph Poon. “Plasma : Scalable Autonomous Smart Contracts”. In: 2017. url: https://api.semanticscholar.org/CorpusID:13266881

2017
[14]

Inter-Blockchain Communica- tion (IBC) Protocol: Overview and Documentation

Inter-Blockchain Communication (IBC) Protocol. Inter-Blockchain Communica- tion (IBC) Protocol: Overview and Documentation. https://ibcprotocol.org/. Accessed: 2024-08-01. 2023

2024
[15]

Cryp- tology ePrint Archive, Paper 2023/1472

Istv´ an Andr´ as Seres, Noemi Glaeser, and Joseph Bonneau.Naysayer proofs. Cryp- tology ePrint Archive, Paper 2023/1472. https://eprint.iacr.org/2023/1472

2023
[16]

Solayer: Staking, Liquid Staking, Validator Performance

Solayer. Solayer: Staking, Liquid Staking, Validator Performance. https://solayer. org/. Accessed: 2024-08-02. 2023

2024
[17]

Validity Proofs vs

starkware. Validity Proofs vs. Fraud Proofs. Accessed: 2024-07-10. url: https: //starkware.co/blog/validity-proofs-vs-fraud-proofs/ . 11

2024
[2023]

url: https://eprint.iacr.org/2023/1472

2023

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [18]

Why wait a week? Fast Finality Optimistic Rollups

Nick Sway. Why wait a week? Fast Finality Optimistic Rollups. https://ethresear. ch / t / why - wait - a - week - fast - finality - optimistic - rollups / 18868. Ac- cessed: 2024-08-01. 2024. 12

work page 2024

[2] [1]

Building Scalable Decentralized Payment Systems

John Adler and Mikerah Quintyne-Collins. “Building Scalable Decentralized Pay- ment Systems”. In: CoRR abs/1904.06441 (2019). arXiv: 1904.06441. url: http: //arxiv.org/abs/1904.06441

work page Pith review arXiv 2019

[3] [2]

BoLD: Fast and Cheap Dispute Resolution

Mario M. Alvarez et al. BoLD: Fast and Cheap Dispute Resolution. 2024. arXiv: 2404.10491 [cs.CR]. url: https://arxiv.org/abs/2404.10491

work page Pith review arXiv 2024

[4] [3]

Scalable, transparent, and post-quantum secure computa- tional integrity

Eli Ben-Sasson et al. “Scalable, transparent, and post-quantum secure computa- tional integrity”. In: IACR Cryptol. ePrint Arch.2018 (2018), p. 46. url: https: //api.semanticscholar.org/CorpusID:44557939

work page 2018

[5] [4]

A review of zk-SNARKs

Thomas Chen et al. “A review of zk-SNARKs”. In: arXiv preprint arXiv:2202.06877 (2022)

arXiv 2022

[6] [5]

Challenging Periods Reimagined Series Part I - Road to a Dynamic Challenging Period

Andr´ e Pereira Daniel Fonseca. Challenging Periods Reimagined Series Part I - Road to a Dynamic Challenging Period. Accessed: 2024-07-07. url: https : / / threesigma.xyz/blog/optimistic-rollups-challenging-periods-reimagined- part-one

work page 2024

[7] [6]

Optimizing challenge periods in rollup

Ed Felten. Optimizing challenge periods in rollup. Accessed: 2024-07-07. url: https : / / medium . com / offchainlabs / optimizing - challenge - periods - in - rollup-b61378c87277

work page 2024

[8] [7]

Why is the Optimistic Rollup challenge period 7 days?Accessed: 2024-07-07

Kelvin Fichter. Why is the Optimistic Rollup challenge period 7 days?Accessed: 2024-07-07. url: https://kelvinfichter.com/pages/thoughts/challenge- periods/

work page 2024