Refactor to continuous background preimage generation and L1 finality caching

.github/workflows/ci.yaml

@@ -51,7 +51,7 @@ jobs:
       - name: Install Foundry
         uses: foundry-rs/foundry-toolchain@v1
         with:
-            version: 'v1.0.0'
+          version: 'v1.0.0'
       - name: Install kurtosis
         run: |
           sudo apt-get install jq

.gitignore

@@ -25,4 +25,6 @@ target/
 /.data
 *.bin
 *.json
-chain
+chain
+.preimage
+.finalized_l1

Makefile

@@ -37,6 +37,8 @@ wait:
 
 .PHONY: server-up
 server-up:
+	mkdir -p .preimage && true
+	mkdir -p .finalized_l1 && true
 	@L2_ROLLUP_PORT=$$(jq -r '.l2RollupPort' hostPort.json);\
 	L2_GETH_PORT=$$(jq -r '.l2GethPort' hostPort.json);\
 	L1_GETH_PORT=$$(jq -r '.l1GethPort' hostPort.json);\
@@ -47,19 +49,21 @@ server-up:
 		--l2=http://localhost:$$L2_GETH_PORT \
 		--l1=http://localhost:$$L1_GETH_PORT \
 		--beacon=http://localhost:$$L1_BEACON_PORT \
-		--l1-chain-config=$$L1_CHAIN_CONFIG
+		--l1-chain-config=$$L1_CHAIN_CONFIG \
+		--initial-claimed-l2=103 \
+		--ttl=1800 \
+		--max-preimage-distance=100 \
+		--purger-interval-seconds=100
 
 .PHONY: test
 test:
 	@L2_ROLLUP_PORT=$$(jq -r '.l2RollupPort' hostPort.json);\
 	L2_GETH_PORT=$$(jq -r '.l2GethPort' hostPort.json);\
-	L2_ROLLUP_PORT=$$L2_ROLLUP_PORT L2_GETH_PORT=$$L2_GETH_PORT cargo test --manifest-path=./server/Cargo.toml
+	L2_ROLLUP_ADDR=http://localhost:$$L2_ROLLUP_PORT L2_GETH_ADDR=http://localhost:$$L2_GETH_PORT cargo test --manifest-path=./server/Cargo.toml
 
-.PHONY: test-ignored
-test-ignored:
-	@L2_ROLLUP_PORT=$$(jq -r '.l2RollupPort' hostPort.json);\
-	L2_GETH_PORT=$$(jq -r '.l2GethPort' hostPort.json);\
-	REQUEST_PATH=$(CURDIR)/tool/body.json L2_ROLLUP_PORT=$$L2_ROLLUP_PORT L2_GETH_PORT=$$L2_GETH_PORT cargo test --manifest-path=./server/Cargo.toml -- --ignored
+.PHONY: inspect
+inspect:
+	cargo test --manifest-path=./server/Cargo.toml -- --ignored
 
 .PHONY: devnet-down
 devnet-down:

server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "optimism-preimage-maker"
-version = "0.1.3"
+version = "0.2.0"
 edition = "2021"
 
 [dependencies]
@@ -15,6 +15,7 @@ tracing = { version = "0.1", default-features = false }
 tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
 axum = "0.7.9"
 tokio = { version="1.41", features=["full"] }
+base64 = "0.22.1"
 
 # Kona
 kona-client = { workspace = true }
@@ -29,7 +30,6 @@ alloy-primitives = { workspace = true, features = ["map", "serde"] }
 
 # optimism derivation
 optimism-derivation = { git = "https://github.com/datachainlab/optimism-elc", rev = "v0.1.10", default-features = false }
-base64 = "0.22.1"
 
 [dev-dependencies]
 prost = "0.11.9"

server/src/client/beacon_client.rs

@@ -0,0 +1,126 @@
+use alloy_primitives::B256;
+use axum::async_trait;
+use reqwest::Response;
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct LightClientFinalityUpdateResponse {
+    pub data: LightClientFinalityUpdate,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct LightClientFinalityUpdate {
+    pub finalized_header: LightClientHeader,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct LightClientHeader {
+    pub execution: ExecutionPayloadHeader,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ExecutionPayloadHeader {
+    pub block_hash: B256,
+    #[serde(deserialize_with = "deserialize_u64_from_str")]
+    pub block_number: u64,
+}
+
+// serde helper to allow numbers encoded as strings
+fn deserialize_u64_from_str<'de, D>(deserializer: D) -> Result<u64, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    struct U64StringOrNumber;
+
+    impl<'de> serde::de::Visitor<'de> for U64StringOrNumber {
+        type Value = u64;
+
+        fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+            write!(f, "a u64 as number or string")
+        }
+
+        fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> {
+            Ok(v)
+        }
+
+        fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            if v < 0 {
+                return Err(E::custom("negative value for u64"));
+            }
+            Ok(v as u64)
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            v.parse::<u64>()
+                .map_err(|e| E::custom(format!("invalid u64 string: {e}")))
+        }
+
+        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            self.visit_str(&v)
+        }
+    }
+
+    deserializer.deserialize_any(U64StringOrNumber)
+}
+
+#[async_trait]
+pub trait BeaconClient: Send + Sync + 'static {
+    async fn get_raw_light_client_finality_update(&self) -> anyhow::Result<String>;
+}
+
+#[derive(Debug, Clone)]
+pub struct HttpBeaconClient {
+    beacon_addr: String,
+    client: reqwest::Client,
+}
+
+impl HttpBeaconClient {
+    pub fn new(beacon_addr: String, timeout: std::time::Duration) -> Self {
+        Self {
+            beacon_addr,
+            client: reqwest::Client::builder()
+                .timeout(timeout)
+                .build()
+                .expect("failed to build reqwest client"),
+        }
+    }
+
+    async fn check_response(&self, response: Response) -> anyhow::Result<Response> {
+        if response.status().is_success() {
+            Ok(response)
+        } else {
+            Err(anyhow::anyhow!(
+                "Request failed with status: {} body={:?}",
+                response.status(),
+                response.text().await
+            ))
+        }
+    }
+}
+
+#[async_trait]
+impl BeaconClient for HttpBeaconClient {
+    async fn get_raw_light_client_finality_update(&self) -> anyhow::Result<String> {
+        let response = self
+            .client
+            .get(format!(
+                "{}/eth/v1/beacon/light_client/finality_update",
+                self.beacon_addr
+            ))
+            .send()
+            .await?;
+        let response = self.check_response(response).await?;
+        response
+            .text()
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to get finality update: {e:?}"))
+    }
+}