Merge pull request #5 from bobanetwork/upstream-v1.0.1

Upstream v1.0.1 Merge

Author: boyuan-chen

book.toml

@@ -1,17 +1,20 @@
 [book]
-authors = ["Uma Roy"]
+authors = ["Uma Roy", "ratankaliani"]
 language = "en"
 multilingual = false
 src = "book"
-title = "OP Succinct"
+title = "OP Succinct book"
 description = "A book on all things SP1"
 
 [build]
 build-dir = "target/book"
 
+[output.html]
+git-repository-url = "https://github.com/succinctlabs/op-succinct"
+
 [preprocessor.template]
 before = ["links"]
 
 [preprocessor.index]
 
-[preprocessor.links]
+[preprocessor.links]

book/advanced/node-setup.md

@@ -3,17 +3,12 @@
 This guide will show you how to set up an L2 execution node (`op-geth`) and a rollup node (`op-node`) for your OP Stack chain.
 
 ## Instructions
-1. Clone [ops-anton](https://github.com/anton-rs/ops-anton) and follow the instructions in the README to set up your rollup.
-2. Go to [op-node.sh](https://github.com/anton-rs/ops-anton/blob/main/L2/op-mainnet/op-node/op-node.sh#L4-L6) and set the `L2_RPC` to your rollup RPC. Modify the `l1` and `l1.beacon` to your L1 and L1 Beacon RPCs. Note: Your L1 node should be an archive node.
-3. If you are starting a node for a different chain, you will need to modify `op-network` in `op-geth.sh` [here](https://github.com/anton-rs/ops-anton/blob/main/L2/op-mainnet/op-geth/op-geth.sh#L18) and `network` in `op-node.sh` [here](https://github.com/anton-rs/ops-anton/blob/main/L2/op-mainnet/op-node/op-node.sh#L10).
-4. In `/L2/op-mainnet` (or the directory you chose):
-   1. Generate a JWT secret `./generate_jwt.sh`
-   2. `docker network create anton-net` (Creates a Docker network for the nodes to communicate on).
-   3. `just up` (Starts all the services).
+1. Clone [simple-optimism-node](https://github.com/smartcontracts/simple-optimism-node) and follow the instructions in the README to set up your rollup.
+2. Ensure you configure the rollup with `NODE_TYPE`=`archive` and `OP_GETH__SYNCMODE`=snap. With this, you will be able to prove blocks in OP Succcinct using blocks after the snap sync.
 
-Your `op-geth` endpoint will be available at the RPC port chosen [here](https://github.com/anton-rs/ops-anton/blob/main/L2/op-mainnet/op-geth/op-geth.sh#L7), which in this case is `8547` (e.g. `http://localhost:8547`).
+Your `op-geth` endpoint will be available at the RPC port chosen [here](https://github.com/smartcontracts/simple-optimism-node/blob/main/scripts/start-op-geth.sh#L39), which in this case is `8545` (e.g. `http://localhost:8545`).
 
-Your `op-node` endpoint (rollup node) will be available at the RPC port chosen [here](https://github.com/anton-rs/ops-anton/blob/main/L2/op-mainnet/op-node/op-node.sh#L13), which in this case is `5058` (e.g. `http://localhost:5058`).
+Your `op-node` endpoint (rollup node) will be available at the RPC port chosen [here](https://github.com/smartcontracts/simple-optimism-node/blob/main/scripts/start-op-node.sh#L21), which in this case is `9545` (e.g. `http://localhost:9545`).
 
 ## Check Sync Status
 
@@ -24,11 +19,11 @@ To check your node's sync status, you can run the following commands:
 **op-geth:**
 
 ```bash
-curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' http://localhost:8547
+curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' http://localhost:8545
 ```
 
 **op-node:**
 
 ```bash
-curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"optimism_syncStatus","params":[],"id":1}' http://localhost:5058
-```
+curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"optimism_syncStatus","params":[],"id":1}' http://localhost:9545
+```

book/architecture.md

@@ -34,11 +34,11 @@ OP Succinct enables OP Stack blocks to be proven with SP1 through a lightweight
 
 ### Core Components
 
-1. <!-- mdbook-link-ignore --> **[Range Program](/programs/range/src/main.rs)**
+1. **[Range Program](https://github.com/succinctlabs/op-succinct/tree/main/programs/range/src/main.rs)**
    - Derives and executes batches of blocks
    - Generates proofs of correct execution
 
-2. <!-- mdbook-link-ignore -->**[Aggregation Program](/programs/aggregation/src/main.rs)**
+2. **[Aggregation Program](https://github.com/succinctlabs/op-succinct/tree/main/programs/aggregation/src/main.rs)**
    - Aggregates multiple range program proofs
    - Reduces on-chain verification costs
 

book/book.toml

@@ -443,3 +443,19 @@ func (db *ProofDB) GetConsecutiveSpanProofs(start, end uint64) ([][]byte, error)
 
 	return result, nil
 }
+
+// Get the proofs with start block and end block of a specific status.
+func (db *ProofDB) GetProofRequestsWithBlockRangeAndStatus(proofType proofrequest.Type, startBlock, endBlock uint64, status proofrequest.Status) ([]*ent.ProofRequest, error) {
+	proofs, err := db.readClient.ProofRequest.Query().
+		Where(
+			proofrequest.TypeEQ(proofType),
+			proofrequest.StartBlockEQ(startBlock), 
+			proofrequest.EndBlockEQ(endBlock),
+			proofrequest.StatusEQ(status),
+		).
+		All(context.Background())
+	if err != nil {
+		return nil, fmt.Errorf("failed to query proofs with block range and status: %w", err)
+	}
+	return proofs, nil
+}

proposer/op/proposer/db/db.go

@@ -81,7 +81,7 @@ func (l *L2OutputSubmitter) ProcessWitnessgenRequests() error {
 
 // Retry a proof request. Sets the status of a proof to FAILED and retries the proof based on the optional proof status response.
 // If an error response is received:
-// - Range Proof: Split in two if the block range is > 1. Retry the same request if range is 1 block.
+// - Range Proof: Split in two if the block range is > 1 AND the proof is unexecutable OR has failed before. Retry the same request if range is 1 block.
 // - Agg Proof: Retry the same request.
 func (l *L2OutputSubmitter) RetryRequest(req *ent.ProofRequest, status ProofStatusResponse) error {
 	err := l.db.UpdateProofStatus(req.ID, proofrequest.StatusFAILED)
@@ -90,11 +90,30 @@ func (l *L2OutputSubmitter) RetryRequest(req *ent.ProofRequest, status ProofStat
 		return err
 	}
 
-	// If there's an execution error AND the request is a SPAN proof AND the block range is > 1, split the request into two requests.
-	// This is likely caused by an SP1 OOM due to a large block range with many transactions.
-	// TODO: This solution can be removed once the embedded allocator is used, because then the programs
-	// will never OOM.
-	if req.Type == proofrequest.TypeSPAN && status.ExecutionStatus == SP1ExecutionStatusUnexecutable && req.EndBlock-req.StartBlock > 1 {
+	unexecutable := status.ExecutionStatus == SP1ExecutionStatusUnexecutable
+	spanProof := req.Type == proofrequest.TypeSPAN
+	multiBlockRange := req.EndBlock-req.StartBlock > 1
+
+	// Get the number of failed requests with the same block range and status.
+	prevFailedReq, err := l.db.GetProofRequestsWithBlockRangeAndStatus(req.Type, req.StartBlock, req.EndBlock, proofrequest.StatusFAILED)
+	if err != nil {
+		l.Log.Error("failed to check for previous failures", "err", err)
+		return err
+	}
+
+	// Check if there is another proof (besides the one marked as failed above) with the same block range that also failed.
+	severalFailedRequests := len(prevFailedReq) > 1
+
+	// If there's an execution error OR several failed requests AND the request is a SPAN proof AND the block range is > 1,
+	// split the request into two requests.
+	//
+	// If the embedded allocator is enabled, the proof will never be unexecutable. Instead, the issue is because there's a limit on the number
+	// of shards in V4. This will be fixed in V5 when the cycle limit is removed.
+	// 
+	// If the embedded allocator is not enabled, the trigger for unexecutable is the SP1 OOM.
+	//
+	// The reason why we only split with multiple failed requests is to avoid transient errors causing unnecessary splits.
+	if spanProof && (unexecutable || severalFailedRequests) && multiBlockRange {
 		// Split the request into two requests.
 		midBlock := (req.StartBlock + req.EndBlock) / 2
 		err = l.db.NewEntry(req.Type, req.StartBlock, midBlock)

proposer/op/proposer/prove.go

@@ -31,7 +31,11 @@ use sp1_sdk::{
     utils, HashableKey, Prover, ProverClient, SP1Proof, SP1ProofMode, SP1ProofWithPublicValues,
     SP1_CIRCUIT_VERSION,
 };
-use std::{env, fs, str::FromStr, time::Instant};
+use std::{
+    env, fs,
+    str::FromStr,
+    time::{Instant, SystemTime, UNIX_EPOCH},
+};
 use tower_http::limit::RequestBodyLimitLayer;
 
 pub const RANGE_ELF: &[u8] = include_bytes!("../../../elf/range-elf");
@@ -546,7 +550,12 @@ async fn get_proof_status(
     };
 
     // Check the deadline.
-    if status.deadline < Instant::now().elapsed().as_secs() {
+    if status.deadline
+        < SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs()
+    {
         error!(
             "Proof request timed out on the server. Default timeout is set to 4 hours. Returning status as Unfulfillable."
         );