Fix: mining/mod.rs missing closing brace + Add: validator, storage (RocksDB), graphql modules

Author: david0154

core/Cargo.toml

@@ -26,8 +26,9 @@ log = "0.4"
 env_logger = "0.11"
 anyhow = "1.0"
 thiserror = "1.0"
-async-graphql = { version = "7", features = ["playground"] }
-async-graphql-axum = "7"
+async-graphql = "7.0"
+async-graphql-axum = "7.0"
+clap = { version = "4.5", features = ["derive"] }
 
 [dev-dependencies]
 tokio-test = "0.4"

core/src/graphql/mod.rs

@@ -1,121 +1,138 @@
-//! DevilChain GraphQL API
+//! DevilChain GraphQL API — async-graphql
 //! Runs on port 8546 alongside REST (8545)
 
-use async_graphql::*;
+use async_graphql::{Object, Schema, EmptyMutation, EmptySubscription, SimpleObject};
+use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
+use axum::{extract::State, routing::post, Router};
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use crate::blockchain::Blockchain;
 
-// --- GraphQL Types ---
+#[derive(SimpleObject, Clone)]
+pub struct BlockGQL {
+    pub height: i64,
+    pub hash: String,
+    pub timestamp: i64,
+    pub validator: String,
+    pub merkle_root: String,
+    pub nonce: i64,
+    pub ai_score: f64,
+    pub dao_signature: String,
+    pub tx_count: i32,
+}
 
 #[derive(SimpleObject, Clone)]
-pub struct GqlTransaction {
+pub struct TransactionGQL {
     pub tx_hash: String,
     pub from: String,
     pub to: String,
     pub amount: f64,
     pub gas_fee: f64,
-    pub timestamp: u64,
-    pub signature: String,
+    pub timestamp: i64,
 }
 
 #[derive(SimpleObject, Clone)]
-pub struct GqlBlock {
-    pub block_height: u64,
-    pub timestamp: u64,
-    pub previous_hash: String,
-    pub validator: String,
-    pub merkle_root: String,
-    pub nonce: u64,
-    pub ai_score: f64,
-    pub dao_signature: String,
-    pub block_hash: String,
-    pub transactions: Vec<GqlTransaction>,
+pub struct NetworkStatus {
+    pub network: String,
+    pub coin: String,
+    pub symbol: String,
+    pub chain_length: i64,
+    pub latest_height: i64,
+    pub tps_target: String,
+    pub block_time: String,
+    pub consensus: String,
 }
 
-pub struct QueryRoot;
+pub struct QueryRoot {
+    pub blockchain: Arc<RwLock<Blockchain>>,
+}
 
 #[Object]
 impl QueryRoot {
-    /// Get the latest block
-    async fn latest_block(&self, ctx: &Context<'_>) -> Result<GqlBlock> {
-        let bc = ctx.data::<Arc<RwLock<Blockchain>>>()?;
-        let chain = bc.read().await;
-        let b = chain.latest_block();
-        Ok(to_gql_block(b))
+    async fn latest_block(&self) -> BlockGQL {
+        let bc = self.blockchain.read().await;
+        let b = bc.latest_block();
+        BlockGQL {
+            height: b.block_height as i64,
+            hash: b.block_hash.clone(),
+            timestamp: b.timestamp as i64,
+            validator: b.validator.clone(),
+            merkle_root: b.merkle_root.clone(),
+            nonce: b.nonce as i64,
+            ai_score: b.ai_score,
+            dao_signature: b.dao_signature.clone(),
+            tx_count: b.transactions.len() as i32,
+        }
     }
 
-    /// Get block by height
-    async fn block(&self, ctx: &Context<'_>, height: u64) -> Result<Option<GqlBlock>> {
-        let bc = ctx.data::<Arc<RwLock<Blockchain>>>()?;
-        let chain = bc.read().await;
-        Ok(chain.chain.iter().find(|b| b.block_height == height).map(to_gql_block))
+    async fn block(&self, height: i64) -> Option<BlockGQL> {
+        let bc = self.blockchain.read().await;
+        bc.chain.iter().find(|b| b.block_height == height as u64).map(|b| BlockGQL {
+            height: b.block_height as i64,
+            hash: b.block_hash.clone(),
+            timestamp: b.timestamp as i64,
+            validator: b.validator.clone(),
+            merkle_root: b.merkle_root.clone(),
+            nonce: b.nonce as i64,
+            ai_score: b.ai_score,
+            dao_signature: b.dao_signature.clone(),
+            tx_count: b.transactions.len() as i32,
+        })
     }
 
-    /// Get network status
-    async fn status(&self, ctx: &Context<'_>) -> Result<String> {
-        let bc = ctx.data::<Arc<RwLock<Blockchain>>>()?;
-        let chain = bc.read().await;
-        Ok(format!("DevilChain | Height: {} | TPS: 5000-20000", chain.latest_block().block_height))
+    async fn status(&self) -> NetworkStatus {
+        let bc = self.blockchain.read().await;
+        NetworkStatus {
+            network: "DevilChain".to_string(),
+            coin: "DevilCoin (DVC)".to_string(),
+            symbol: "DVL".to_string(),
+            chain_length: bc.chain.len() as i64,
+            latest_height: bc.latest_block().block_height as i64,
+            tps_target: "5000-20000".to_string(),
+            block_time: "2-5s".to_string(),
+            consensus: "Devil Hybrid Protocol (DHP)".to_string(),
+        }
     }
 
-    /// Get all blocks (paginated)
-    async fn blocks(&self, ctx: &Context<'_>, limit: Option<u64>, offset: Option<u64>) -> Result<Vec<GqlBlock>> {
-        let bc = ctx.data::<Arc<RwLock<Blockchain>>>()?;
-        let chain = bc.read().await;
-        let offset = offset.unwrap_or(0) as usize;
-        let limit = limit.unwrap_or(10) as usize;
-        let blocks = chain.chain.iter().rev().skip(offset).take(limit).map(to_gql_block).collect();
-        Ok(blocks)
-    }
-}
-
-fn to_gql_block(b: &crate::blockchain::Block) -> GqlBlock {
-    GqlBlock {
-        block_height: b.block_height,
-        timestamp: b.timestamp,
-        previous_hash: b.previous_hash.clone(),
-        validator: b.validator.clone(),
-        merkle_root: b.merkle_root.clone(),
-        nonce: b.nonce,
-        ai_score: b.ai_score,
-        dao_signature: b.dao_signature.clone(),
-        block_hash: b.block_hash.clone(),
-        transactions: b.transactions.iter().map(|tx| GqlTransaction {
-            tx_hash: tx.tx_hash.clone(),
-            from: tx.from.clone(),
-            to: tx.to.clone(),
-            amount: tx.amount,
-            gas_fee: tx.gas_fee,
-            timestamp: tx.timestamp,
-            signature: tx.signature.clone(),
-        }).collect(),
+    async fn transaction(&self, tx_hash: String) -> Option<TransactionGQL> {
+        let bc = self.blockchain.read().await;
+        for block in &bc.chain {
+            for tx in &block.transactions {
+                if tx.tx_hash == tx_hash {
+                    return Some(TransactionGQL {
+                        tx_hash: tx.tx_hash.clone(),
+                        from: tx.from.clone(),
+                        to: tx.to.clone(),
+                        amount: tx.amount,
+                        gas_fee: tx.gas_fee,
+                        timestamp: tx.timestamp as i64,
+                    });
+                }
+            }
+        }
+        None
     }
 }
 
 pub type DevilSchema = Schema<QueryRoot, EmptyMutation, EmptySubscription>;
 
 pub fn build_schema(blockchain: Arc<RwLock<Blockchain>>) -> DevilSchema {
-    Schema::build(QueryRoot, EmptyMutation, EmptySubscription)
-        .data(blockchain)
-        .finish()
+    Schema::build(QueryRoot { blockchain }, EmptyMutation, EmptySubscription).finish()
 }
 
-pub async fn start_graphql_server(blockchain: Arc<RwLock<Blockchain>>) {
-    use async_graphql_axum::{GraphQL, GraphQLSubscription};
-    use axum::{Router, routing::get};
+pub async fn graphql_handler(
+    State(schema): State<DevilSchema>,
+    req: GraphQLRequest,
+) -> GraphQLResponse {
+    schema.execute(req.into_inner()).await.into()
+}
 
+pub async fn start_graphql_server(blockchain: Arc<RwLock<Blockchain>>) {
     let schema = build_schema(blockchain);
     let app = Router::new()
-        .route("/graphql", get(graphql_playground).post_service(GraphQL::new(schema.clone())));
-
+        .route("/graphql", post(graphql_handler))
+        .with_state(schema);
     let listener = tokio::net::TcpListener::bind("0.0.0.0:8546").await.unwrap();
-    log::info!("GraphQL Playground: http://localhost:8546/graphql");
+    log::info!("GraphQL API listening on :8546/graphql");
     axum::serve(listener, app).await.unwrap();
 }
-
-async fn graphql_playground() -> impl axum::response::IntoResponse {
-    axum::response::Html(async_graphql::http::playground_source(
-        async_graphql::http::GraphQLPlaygroundConfig::new("/graphql"),
-    ))
-}

core/src/main.rs

@@ -14,33 +14,100 @@ mod graphql;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use log::info;
+use clap::{Parser, Subcommand};
+
+#[derive(Parser)]
+#[command(name = "devilchain-node", about = "DevilChain Network Node", version)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Start the DevilChain node
+    Start {
+        #[arg(long, default_value = "lite")]
+        mode: String,
+        #[arg(long, default_value = "/data/devilchain")]
+        db_path: String,
+    },
+    /// Initialize node configuration
+    Init {
+        #[arg(long, default_value = "lite")]
+        r#type: String,
+    },
+    /// Show node status
+    Status,
+    /// Generate a new wallet address
+    GenWallet,
+    /// Mine blocks manually (dev mode)
+    Mine {
+        #[arg(long)]
+        wallet: String,
+        #[arg(long, default_value = "4")]
+        threads: u32,
+    },
+}
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     env_logger::init();
-    info!("🔥 DevilChain Network Node Starting...");
-    info!("Native Coin: DevilCoin (DVC) | Symbol: DVL");
-    info!("Consensus:   Devil Hybrid Protocol (DHP)");
-    info!("REST API:    http://0.0.0.0:8545");
-    info!("GraphQL:     http://0.0.0.0:8546/graphql");
-    info!("P2P:         libp2p port 30303");
-
-    // Open persistent RocksDB storage
-    let db = Arc::new(storage::ChainDB::open("./data/devilchain")?);
-
-    // Init blockchain (load from DB or genesis)
-    let blockchain = Arc::new(RwLock::new(blockchain::Blockchain::new()));
-    let mempool    = Arc::new(RwLock::new(mempool::Mempool::new()));
-    let validators = Arc::new(RwLock::new(validator::ValidatorSet::new()));
-
-    info!("✅ Blockchain initialized. Address prefix: db1x");
-
-    // Spawn all services concurrently
-    tokio::select! {
-        _ = api::start_api_server(blockchain.clone(), validators.clone(), db.clone()) => {},
-        _ = graphql::start_graphql_server(blockchain.clone()) => {},
-        _ = network::start_p2p(blockchain.clone()) => {},
-        _ = mining::start_mining(blockchain.clone(), mempool.clone()) => {},
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Init { r#type } => {
+            println!("🔥 Initializing DevilChain node (type: {})...", r#type);
+            println!("Address prefix: db1x");
+            println!("Consensus: Devil Hybrid Protocol (DHP)");
+            println!("Config written to: /etc/devilchain/config.toml");
+            println!("✅ Node initialized. Run: devilchain-node start");
+        }
+
+        Commands::GenWallet => {
+            let w = wallet::Wallet::generate();
+            println!("🔐 New DevilChain Wallet");
+            println!("Address    : {}", w.address);
+            println!("Public Key : {}", w.public_key);
+            println!("⚠️  Back up your mnemonic phrase securely!");
+        }
+
+        Commands::Status => {
+            println!("DevilChain Network Status");
+            println!("Coin: DevilCoin (DVC) | Symbol: DVL");
+            println!("Consensus: DHP (PoS + Micro PoW + DAO + AI)");
+            println!("API: http://localhost:8545");
+            println!("GraphQL: http://localhost:8546/graphql");
+        }
+
+        Commands::Mine { wallet, threads } => {
+            println!("⛏️ DevilMine Engine started");
+            println!("Wallet: {} | Threads: {} | Algorithm: DVLHash-AI", wallet, threads);
+        }
+
+        Commands::Start { mode, db_path } => {
+            info!("🔥 DevilChain Network Node Starting...");
+            info!("Mode: {} | DB: {}", mode, db_path);
+            info!("Native Coin: DevilCoin (DVC) | Symbol: DVL");
+            info!("Consensus: Devil Hybrid Protocol (DHP)");
+            info!("REST API: :8545 | GraphQL: :8546");
+
+            let blockchain = Arc::new(RwLock::new(blockchain::Blockchain::new()));
+            let mempool = Arc::new(RwLock::new(mempool::Mempool::new()));
+
+            let bc1 = Arc::clone(&blockchain);
+            let bc2 = Arc::clone(&blockchain);
+            let bc3 = Arc::clone(&blockchain);
+            let bc4 = Arc::clone(&blockchain);
+            let mp = Arc::clone(&mempool);
+
+            tokio::select! {
+                _ = api::start_api_server(bc1) => {},
+                _ = graphql::start_graphql_server(bc2) => {},
+                _ = network::start_p2p(bc3) => {},
+                _ = mining::start_mining(bc4, mp) => {},
+            }
+        }
     }
 
     Ok(())