WIP: Bankai daemon implementation

client-rs/Cargo.toml

@@ -3,6 +3,14 @@ name = "client-rs"
 version = "0.1.0"
 edition = "2021"
 
+[[bin]]
+name = "daemon"
+path = "src/daemon.rs"
+
+[[bin]]
+name = "cli"
+path = "src/main.rs"
+
 [dependencies]
 alloy-primitives = "0.8.13"
 ethereum_serde_utils = "0.7.0"
@@ -12,9 +20,9 @@ serde_derive = "1.0.215"
 serde_json = "1.0.133"
 tokio = { version = "1.0", features = ["full"] }
 beacon-state-proof = { git = "https://github.com/petscheit/beacon-state-proof" }
-types = { path = "../../lighthouse/consensus/types", package = "types" }
+types = { git = "https://github.com/petscheit/lighthouse.git", package = "types" }
 sha2 = "0.10.8"
-reqwest = { version = "0.12.9", features = ["json", "multipart"] }
+reqwest = { version = "0.12.9", features = ["json", "multipart", "stream"] }
 rand = "0.8.5"
 alloy-rpc-types-beacon = "0.7.2"
 itertools = "0.13.0"
@@ -24,5 +32,29 @@ starknet = "0.12.0"
 tree_hash_derive = "0.8.0"
 tree_hash = "0.8.0"
 dotenv = "0.15"
+tokio-postgres = { version = "0.7.12", features = [
+    "with-uuid-1",
+    "with-chrono-0_4",
+] }
+axum = "0.7.9"
+thiserror = "2.0.9"
+tracing = "0.1.41"
+tracing-subscriber = "0.3.19"
+tokio-stream = "0.1.17"
+futures = "0.3"
+uuid = { version = "1.11.0", features = [
+    "v4",
+    "fast-rng",
+    "macro-diagnostics",
+] }
+postgres-types = { version = "0.2.8", features = ["derive"] }
+num_cpus = "1.16.0"
+
+
 starknet-crypto = "0.7.3"
 glob = "0.3.2"
+num-traits = "0.2.19"
+tower = "0.5.2"
+tower-http = { version = "0.6.2", features = ["trace", "timeout"] }
+chrono = { version = "0.4.39", features = ["serde"] }
+tokio-util = "0.7.13"

client-rs/Dockerfile

@@ -0,0 +1,39 @@
+FROM rust:1.72 as builder
+
+WORKDIR /usr/src/app
+
+COPY Cargo.toml Cargo.lock ./
+
+COPY src ./src
+
+RUN cargo build --release --bin daemon
+
+FROM debian:bullseye
+
+RUN apt-get update && apt-get install -y \
+    libpq-dev \
+    postgresql \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir -p /usr/src/app/batches
+
+WORKDIR /usr/src/app
+
+COPY --from=builder /usr/src/app/target/release/daemon /usr/src/app/
+
+RUN mkdir -p /var/lib/postgresql/data && chown -R postgres:postgres /var/lib/postgresql
+
+COPY scripts/entrypoint.sh /usr/local/bin/entrypoint.sh
+RUN chmod +x /usr/local/bin/entrypoint.sh
+
+EXPOSE 5432
+
+USER postgres
+
+RUN /usr/lib/postgresql/14/bin/initdb -D /var/lib/postgresql/data
+
+USER root
+
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+
+CMD ["/usr/src/app/daemon"]

client-rs/db_structure.sql

@@ -0,0 +1,43 @@
+CREATE TABLE jobs (
+    job_uuid UUID PRIMARY KEY,
+    job_status TEXT NOT NULL,
+    atlantic_proof_generate_batch_id TEXT NULL,
+    atlantic_proof_wrapper_batch_id TEXT NULL,
+    slot BIGINT NOT NULL, -- Slot associated with the job
+    batch_range_begin_epoch BIGINT NULL,
+    batch_range_end_epoch BIGINT NULL,
+    type TEXT NOT NULL,
+    tx_hash TEXT NULL,
+    failed_at_step TEXT NULL,
+    retries_count BIGINT NULL,
+    last_failure_time TIMESTAMP NULL,
+    updated_at TIMESTAMP DEFAULT NOW (),
+    created_at TIMESTAMP DEFAULT NOW ()
+);
+
+CREATE TABLE epoch_merkle_paths (
+    epoch_id BIGINT NOT NULL,
+    path_index BIGINT NOT NULL,
+    merkle_path TEXT NOT NULL,
+    PRIMARY KEY (epoch_id, path_index) -- Ensures uniqueness of the combination
+);
+
+CREATE TABLE verified_epoch (
+    epoch_id UUID PRIMARY KEY,
+    header_root TEXT NOT NULL, -- Header root hash of the Beacon chain header
+    state_root TEXT NOT NULL, -- State root hash of the Beacon chain state
+    n_signers INTEGER NOT NULL, -- Number of epoch signers
+    execution_hash TEXT NOT NULL, -- Execution layer blockhash
+    execution_height BIGINT NOT NULL -- Execution layer height
+);
+
+CREATE TABLE verified_sync_committee (
+    sync_committee_id UUID PRIMARY KEY, -- Unique identifier for sync committee  (slot number/0x2000)
+    sync_committee_hash TEXT NOT NULL -- Sync committee hash that we are creating inside bankai
+);
+
+CREATE TABLE daemon_state (
+    latest_known_beacon_slot BIGINT NOT NULL,
+    latest_known_beacon_block BYTEA NOT NULL,
+    updated_at TIMESTAMP DEFAULT NOW ()
+);

client-rs/docker-compose.dev.yml

@@ -0,0 +1,31 @@
+services:
+  postgres:
+    image: postgres:14
+    container_name: postgres
+    environment:
+      POSTGRESQL_USER: ${POSTGRES_USER:-postgres}
+      POSTGRESQL_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
+      POSTGRESQL_DB_NAME: ${POSTGRES_DB:-bankai}
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    ports:
+      - ${POSTGRES_PORT:-5432}:${POSTGRES_PORT:-5432}
+
+  daemon:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: bankai-daemon
+    depends_on:
+      - postgres
+    env_file:
+      - .env.sepolia
+    #environment:
+    # POSTGRESQL_USER
+    volumes:
+      - ./batches:/usr/src/app/batches
+    ports:
+      - "3000:3000"
+
+volumes:
+  pgdata:

client-rs/scripts/entrypoint.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -e
+
+su postgres -c "/usr/lib/postgresql/14/bin/pg_ctl -D /var/lib/postgresql/data -l logfile start"
+
+sleep 5
+
+su postgres -c "psql -c \"CREATE USER postgres WITH SUPERUSER PASSWORD 'postgres';\"" || true
+su postgres -c "psql -c \"CREATE DATABASE bankai_sepolia;\"" || true
+
+# We need to do migration here, create initial DB structure form DB file
+
+echo "PostgreSQL is running. Starting the daemon..."
+
+exec "$@"

client-rs/scripts/wait-for-postgres.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+while ! nc -z localhost 5434; do sleep 1; done
+echo "Postgres ready"
+sleep 1
+exit 0

client-rs/src/bankai_client.rs

@@ -0,0 +1,96 @@
+use crate::constants;
+use crate::{
+    contract_init::ContractInitializationData,
+    epoch_update::EpochUpdate,
+    state::Error,
+    sync_committee::SyncCommitteeUpdate,
+    utils::{
+        atlantic_client::AtlanticClient, rpc::BeaconRpcClient, starknet_client::StarknetClient,
+        transactor_client::TransactorClient,
+    },
+    BankaiConfig,
+};
+use dotenv::from_filename;
+use std::env;
+use tracing::info;
+
+#[derive(Debug)]
+pub struct BankaiClient {
+    pub client: BeaconRpcClient,
+    pub starknet_client: StarknetClient,
+    pub config: BankaiConfig,
+    pub atlantic_client: AtlanticClient,
+    pub transactor_client: TransactorClient,
+}
+
+impl BankaiClient {
+    pub async fn new() -> Self {
+        from_filename(".env.sepolia").ok();
+        let config = BankaiConfig::default();
+        Self {
+            client: BeaconRpcClient::new(env::var("BEACON_RPC_URL").unwrap()),
+            starknet_client: StarknetClient::new(
+                env::var("STARKNET_RPC_URL").unwrap().as_str(),
+                env::var("STARKNET_ADDRESS").unwrap().as_str(),
+                env::var("STARKNET_PRIVATE_KEY").unwrap().as_str(),
+            )
+            .await
+            .unwrap(),
+            atlantic_client: AtlanticClient::new(
+                config.atlantic_endpoint.clone(),
+                env::var("ATLANTIC_API_KEY").unwrap(),
+            ),
+            transactor_client: TransactorClient::new(
+                config.transactor_endpoint.clone(),
+                env::var("TRANSACTOR_API_KEY").unwrap(),
+            ),
+            config,
+        }
+    }
+
+    pub async fn get_sync_committee_update(
+        &self,
+        mut slot: u64,
+    ) -> Result<SyncCommitteeUpdate, Error> {
+        let mut attempts = 0;
+
+        // Before we start generating the proof, we ensure the slot was not missed
+        let _header = loop {
+            match self.client.get_header(slot).await {
+                Ok(header) => break header,
+                Err(Error::EmptySlotDetected(_)) => {
+                    attempts += 1;
+                    if attempts >= constants::MAX_SKIPPED_SLOTS_RETRY_ATTEMPTS {
+                        return Err(Error::EmptySlotDetected(slot));
+                    }
+                    slot += 1;
+                    info!(
+                        "Empty slot detected! Attempt {}/{}. Fetching slot: {}",
+                        attempts,
+                        constants::MAX_SKIPPED_SLOTS_RETRY_ATTEMPTS,
+                        slot
+                    );
+                }
+                Err(e) => return Err(e), // Propagate other errors immediately
+            }
+        };
+
+        let proof: SyncCommitteeUpdate = SyncCommitteeUpdate::new(&self.client, slot).await?;
+
+        Ok(proof)
+    }
+
+    pub async fn get_epoch_proof(&self, slot: u64) -> Result<EpochUpdate, Error> {
+        let epoch_proof = EpochUpdate::new(&self.client, slot).await?;
+        Ok(epoch_proof)
+    }
+
+    pub async fn get_contract_initialization_data(
+        &self,
+        slot: u64,
+        config: &BankaiConfig,
+    ) -> Result<ContractInitializationData, Error> {
+        let contract_init = ContractInitializationData::new(&self.client, slot, config).await?;
+        Ok(contract_init)
+    }
+}

client-rs/src/config.rs

@@ -1,6 +1,11 @@
+use crate::constants::{
+    MAX_CONCURRENT_PIE_GENERATIONS, MAX_CONCURRENT_RPC_DATA_FETCH_JOBS, STARKNET_SEPOLIA,
+};
 use starknet::core::types::Felt;
+use std::sync::Arc;
+use tokio::sync::Semaphore;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct BankaiConfig {
     pub contract_class_hash: Felt,
     pub contract_address: Felt,
@@ -12,17 +17,21 @@ pub struct BankaiConfig {
     pub epoch_batch_circuit_path: String,
     pub committee_circuit_path: String,
     pub atlantic_endpoint: String,
+    pub transactor_endpoint: String,
+    pub pie_generation_semaphore: Arc<Semaphore>,
+    pub epoch_data_fetching_semaphore: Arc<Semaphore>,
+    pub proof_settlement_chain_id: Felt,
 }
 
 impl Default for BankaiConfig {
     fn default() -> Self {
         Self {
             contract_class_hash: Felt::from_hex(
-                "0x02b5b08b233132464c437cf15509338e65ae7acc20419a37a9449a1d8e927f46",
+                "0x00034b6d1cd9858aeabcee33ef5ec5cd04be155d79ca2bbf9036700cb6c7c287",
             )
             .unwrap(),
             contract_address: Felt::from_hex(
-                "0x440b622a97fab3f31a35e7e710a8a508f6693d61d74171b5c2304f5e37ccde8",
+                "0x1b7b70023bc2429d4453ce75d75f3e8b01b0730ca83068a82b4d17aa88a25e3",
             )
             .unwrap(),
             committee_update_program_hash: Felt::from_hex(
@@ -34,7 +43,7 @@ impl Default for BankaiConfig {
             )
             .unwrap(),
             epoch_batch_program_hash: Felt::from_hex(
-                "0x19bc492f1036c889939a5174e8f77ffbe89676c8d5f1adef0a825d2a6cc2a2f",
+                "0x5f4dad2d8549e91c25694875eb02fc2910eeead0e1a13d3061464a3eaa4bd8d",
             )
             .unwrap(),
             contract_path: "../contract/target/release/bankai_BankaiContract.contract_class.json"
@@ -43,6 +52,13 @@ impl Default for BankaiConfig {
             epoch_batch_circuit_path: "../cairo/build/epoch_batch.json".to_string(),
             committee_circuit_path: "../cairo/build/committee_update.json".to_string(),
             atlantic_endpoint: "https://atlantic.api.herodotus.cloud".to_string(),
+            transactor_endpoint: "https://staging.api.herodotus.cloud".to_string(),
+            // Set how many concurrent pie generation (trace generation) tasks are allowed
+            pie_generation_semaphore: Arc::new(Semaphore::new(MAX_CONCURRENT_PIE_GENERATIONS)), // 3 at once
+            epoch_data_fetching_semaphore: Arc::new(Semaphore::new(
+                MAX_CONCURRENT_RPC_DATA_FETCH_JOBS,
+            )), // 2 at once
+            proof_settlement_chain_id: Felt::from_hex(STARKNET_SEPOLIA).unwrap(),
         }
     }
 }

client-rs/src/constants.rs

@@ -0,0 +1,17 @@
+pub const SLOTS_PER_EPOCH: u64 = 32; // For mainnet
+pub const SLOTS_PER_SYNC_COMMITTEE: u64 = 8192; // For mainnet
+pub const TARGET_BATCH_SIZE: u64 = 32; // Defines how many epochs in one batch
+pub const EPOCHS_PER_SYNC_COMMITTEE: u64 = 256; // For mainnet
+pub const MAX_CONCURRENT_JOBS_IN_PROGRESS: u64 = 16; // Define the limit of how many jobs can be in state "in progress" concurrently
+pub const MAX_CONCURRENT_PIE_GENERATIONS: usize = 1; // Define how many concurrent trace (pie file) generation jobs are allowed to not exhaust resources
+pub const MAX_CONCURRENT_RPC_DATA_FETCH_JOBS: usize = 1; // Define how many data fetching jobs can be performed concurrently to not overload RPC
+pub const STARKNET_SEPOLIA: &str = "0x534e5f5345504f4c4941";
+pub const STARKNET_MAINNET: &str = "0x534e5f4d41494e";
+pub const USE_TRANSACTOR: bool = false;
+pub const MAX_JOB_RETRIES_COUNT: u64 = 10;
+pub const BEACON_CHAIN_LISTENER_ENABLED: bool = true;
+pub const JOBS_RETRY_ENABLED: bool = true;
+pub const JOBS_RESUME_ENABLED: bool = true;
+pub const RETRY_DELAY_MS: u64 = 300_0000;
+pub const MAX_SKIPPED_SLOTS_RETRY_ATTEMPTS: u64 = 5; // How many skipped slots in row can be on Beacon Chain before we throw error
+pub const JOBS_RETRY_CHECK_INTERVAL: u64 = 600; // In seconds