[Core Protocol] <Question FPP Testing in Devnet>

[AaronLee22]

Did you check the documentation?

• Yes

Did you read the specs?

• Yes
• No

Did you check for duplicate questions?

• Yes

Issue Description

Hello,

I’ve been testing FPP on the Devnet, reading through the specifications, and reviewing the code, but there are still a few aspects I’m struggling to understand. I’d appreciate your clarification on the following points:

1. Depth of Game Split in L2 Blocks: As shown in the attached screenshot, the range of L2 blocks is 0 to 32, meaning the range covers 33 blocks. Given that the split depth is 14, which theoretically allows for the verification of up to 16,384 blocks (2^14), I’m curious about how the game can reach a depth of 14 when only 33 blocks are in play. My understanding is that with 33 blocks, a split depth of 5 should be sufficient to cover all blocks. Could you explain how the game manages to go down to a depth of 14?

2. Automated Verification and Attacks: During my tests, I manually used the op-program, cannon, and pre-state to identify incorrect claims and verified each step of the process as the proposer submitted the output root (dispute game creation). Is there currently a feature that automates this process? Specifically, does the challenger node automatically use op-program and cannon to monitor the output root and attack incorrect claims, continuing the game without requiring manual intervention(if yes, can it be tested within decent)?

3. Evidence for Attacks and Defense in Devnet: I might be mistaken due to testing on the Devnet, but I believe that when attacking or defending, one must provide proof through the VM for both the pre-state and post-state as evidence. However, I noticed that the commands in the op-challenger repo’s README don’t include such parameters—are these commands simplified? How can attacks and defenses be objectively proven and resolved? Additionally, is it possible to test this aspect within the Devnet environment?

Additionally, it appears that if an attack on a claim is not countered with a defense, the attacker automatically wins, and the claim is invalidated. Conversely, if a defense is made, the game continues, allowing further challenges. However, I believe there should be a more objective mechanism to validate these claims, possibly using data from the L1 chain.

Could you explain how the L1 chain is used to provide objective evidence for state transitions and ensure accurate resolution of disputes? Specifically, how does L1 chain data influence the outcome of the dispute game, and what is its role in validating attacks and defenses? Understanding this process would clarify how disputes are managed and resolved within the system.

Thank you for your assistance.

Additional Information

No response

Feedback

No response

[hash1go]

Hello. As it's the weekend now, I'll ask the OP team when the week starts.

[joohhnnn]

1. Could you explain how the game manages to go down to a depth of 14?

In the depth of 14, all data is initially aligned on the left side. After that, to fill the nodes, the data from the last block is duplicated as shown in the red part of the diagram. Each duplicate represents a repetition of the last valid data.

2. does the challenger node automatically use op-program and cannon to monitor the output root and attack incorrect claims

Yes It will monitor the new block in L1 and perform the action, also you can use --game-allowlist to play with the specific game

https://github.com/ethereum-optimism/optimism/tree/develop/op-challenger#usage

3. However, I noticed that the commands in the op-challenger repo’s README don’t include such parameters—are these commands simplified?

Yes the mechanism and proofs are embedded within the challenger system. For instance, when it progresses to a step, it retrieves the proof you mentioned, as referenced in (https://github.com/joohhnnn/The-book-of-optimism-fault-proof/blob/main/05-op-challenger.md#generating-action).

For other issues, you can refer to the entire document. "Defend" and "Attack" are abstract concepts used when there is no standard binary answer available.

[AaronLee22]

Thank you for your detailed explanations and the links you provided it really helped a lot !

However, there are still some points that are unclear to me:

"In the depth of 14, all data is initially aligned on the left side. After that, to fill the nodes, the data from the last block is duplicated as shown in the red part of the diagram. Each duplicate represents a repetition of the last valid data."

If the last block is duplicated, does that mean that out of the 16,384 blocks (2^14), 16,351 will be duplicates since there are only 33 blocks in range? If so, how can I manually target a specific block, given the difficulty of calculating which block (or claim at the lowest split depth) to attack? Is there another way to attack a claim?

Additionally, if an attacker wants to target a specific claim at the lowest split depth, the hash of the block should be listed in the dispute game to identify the claim to dispute. For example, if I reach depth 1 at index 2, I need to know which exact claim index 2 is pointing to and the hash of that claim to decide whether to dispute it.

"Yes, it will monitor the new block in L1 and perform the action. Also, you can use --game-allowlist to play with a specific game."

I have run the op-dispute-mon (which detects invalid output roots), but I could not find any function that automatically attacks a specific invalid claim until the resolution stage (after reaching MAX_GAME_DEPTH). Should attacking or defending be done manually, or is there a way for it to be done automatically? If it can be automated, including submitting _stateData and _proof in the ValidStep function (after reaching the split depth), can you explain how to do this? I couldn't find any manual or documentation on this.

Sorry for asking so many questions, but it's been difficult to grasp the whole concept just by going through the documentation.

[joohhnnn]

If the last block is duplicated, does that mean that out of the 16,384 blocks (2^14), 16,351 will be duplicates since there are only 33 blocks in range?

Yes, but in practical terms, because of the binary method, you only need to upload a small number of repeated data instances, like 14 times instead of 2^14 times.

how can I manually target a specific block, given the difficulty of calculating which block (or claim at the lowest split depth) to attack?

You can use 'attack' or 'defend' to further narrow it down until you reach the block you want to participate in.

I need to know which exact claim index 2 is pointing to and the hash of that claim to decide whether to dispute it.

https://github.com/joohhnnn/The-book-of-optimism-fault-proof/blob/main/03-cannon.md#execution

First, you need to calculate the trace index for your current node based on the trace index rules. Then, run the cannon up to the specified step and generate a claim based on the output.

Should attacking or defending be done manually, or is there a way for it to be done automatically?

You should run op-challenger, op-dispute-mon is only used for monitor.

If it can be automated, including submitting _stateData and _proof in the ValidStep function (after reaching the split depth), can you explain how to do this?

reference https://github.com/ethereum-optimism/optimism/blob/develop/op-challenger/game/fault/trace/vm/executor.go#L74 and https://github.com/joohhnnn/The-book-of-optimism-fault-proof/blob/main/05-op-challenger.md#generating-action

[AaronLee22]

Thank you for your answer it really helped a lot! specially https://github.com/joohhnnn/The-book-of-optimism-fault-proof/blob/main/03-cannon.md#execution -> this reference is excellent!