fix fee percentage, polish debugs&prints

Author: arnaucube

Cargo.lock

@@ -28,6 +28,11 @@ sqlx = { version="0.8.6", features = ["sqlite", "chrono", "runtime-tokio"] }
 warp = "0.3"
 hex = "0.4.3"
 
+# logging
+tracing = "0.1.19"
+tracing-subscriber = { version = "0.3", features = ["registry", "env-filter" ] }
+tracing-log = "0.1.1"
+
 # [patch."https://github.com/0xPARC/pod2"]
 # pod2 = { path = "../pod2" }
 

Cargo.toml

@@ -13,6 +13,9 @@ plonky2 = { workspace = true }
 pod2 = { workspace = true }
 dotenvy = { workspace = true }
 warp = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+tracing-log = { workspace = true }
 
 app = { path = "../app" }
 common = { path = "../common" }
@@ -21,6 +24,3 @@ itertools = "0.14.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.143"
 async-recursion = "1.1.1"
-
-# logging
-tracing = "0.1.19"

ad-server/Cargo.toml

@@ -8,6 +8,7 @@ use alloy::{
     signers::local::PrivateKeySigner,
 };
 use anyhow::{Result, anyhow};
+use tracing::{debug, info};
 
 use crate::Config;
 
@@ -23,12 +24,12 @@ pub async fn send_payload(cfg: Config, b: Vec<u8>) -> Result<TxHash> {
         .connect(&cfg.rpc_url)
         .await?;
     let latest_block = provider.get_block_number().await?;
-    println!("Latest block number: {latest_block}");
+    info!("Latest block number: {latest_block}");
 
     let sender = signer.address();
     let receiver = Address::from([0x42; 20]);
-    dbg!(&sender);
-    dbg!(&receiver);
+    debug!("{}", sender);
+    debug!("{}", receiver);
 
     let sidecar: SidecarBuilder<SimpleCoder> = SidecarBuilder::from_slice(&b);
     let sidecar = sidecar.build()?;
@@ -39,18 +40,10 @@ pub async fn send_payload(cfg: Config, b: Vec<u8>) -> Result<TxHash> {
     // for a new tx, increase gas price by 10% to reduce the chances of the
     // nodes rejecting it (in practice increase it by 11% to ensure it passes
     // the miner filter)
-    let (receipt, tx_hash) = send_tx(
-        cfg,
-        provider,
-        receiver,
-        sidecar,
-        fees,
-        blob_base_fee,
-        111 / 100,
-    )
-    .await?;
-
-    println!(
+    let (receipt, tx_hash) =
+        send_tx(cfg, provider, receiver, sidecar, fees, blob_base_fee, 11).await?;
+
+    info!(
         "Transaction included in block {}",
         receipt.block_number.expect("Failed to get block number")
     );
@@ -93,18 +86,20 @@ async fn send_tx<'async_recursion>(
     sidecar: alloy::eips::eip4844::BlobTransactionSidecar,
     fees: Eip1559Estimation,
     blob_base_fee: u128,
-    increase_ratio: u128,
+    increase_percentage: u128,
 ) -> Result<(TransactionReceipt, TxHash)> {
     let tx = TransactionRequest::default()
-        .with_max_fee_per_gas(fees.max_fee_per_gas * increase_ratio)
-        .with_max_priority_fee_per_gas(fees.max_priority_fee_per_gas * increase_ratio)
-        .with_max_fee_per_blob_gas(blob_base_fee * increase_ratio)
+        .with_max_fee_per_gas(fees.max_fee_per_gas * (100 + increase_percentage) / 100)
+        .with_max_priority_fee_per_gas(
+            fees.max_priority_fee_per_gas * (100 + increase_percentage) / 100,
+        )
+        .with_max_fee_per_blob_gas(blob_base_fee * (100 + increase_percentage) / 100)
         .with_to(receiver)
         .with_blob_sidecar(sidecar.clone());
 
-    dbg!(&tx.max_fee_per_gas.unwrap());
-    dbg!(&tx.max_priority_fee_per_gas.unwrap());
-    dbg!(&tx.max_fee_per_blob_gas.unwrap());
+    debug!("{}", tx.max_fee_per_gas.unwrap());
+    debug!("{}", tx.max_priority_fee_per_gas.unwrap());
+    debug!("{}", tx.max_fee_per_blob_gas.unwrap());
 
     let send_tx_result = provider.send_transaction(tx).await;
     let pending_tx_result = match send_tx_result {
@@ -115,62 +110,62 @@ async fn send_tx<'async_recursion>(
                 return Err(anyhow!("rpc-error: {}", e));
             }
 
-            println!("tx err: {}", e);
-            println!("sending tx again with 2x gas price");
+            info!("tx err: {}", e);
+            info!("sending tx again with 2x gas price");
             return send_tx(
                 cfg,
                 provider,
                 receiver,
                 sidecar,
                 fees,
                 blob_base_fee,
-                increase_ratio * 2,
+                increase_percentage + 100,
             )
             .await;
         }
     };
-    println!("watching pending tx, timeout of {}", cfg.tx_watch_timeout);
+    info!("watching pending tx, timeout of {}", cfg.tx_watch_timeout);
     let pending_tx_result = pending_tx_result
         .with_timeout(Some(std::time::Duration::from_secs(cfg.tx_watch_timeout)))
         .watch()
         .await;
 
-    dbg!("sent");
+    debug!("sent");
     let tx_hash = match pending_tx_result {
         Ok(pending_tx) => pending_tx,
         Err(e) => {
             if e.to_string().contains("Too Many Requests") {
                 panic!("error: {}", e);
             }
 
-            println!("tx err: {}", e);
-            println!("sending tx again with 2x gas price");
+            info!("tx err: {}", e);
+            info!("sending tx again with 2x gas price");
             return send_tx(
                 cfg,
                 provider,
                 receiver,
                 sidecar,
                 fees,
                 blob_base_fee,
-                increase_ratio * 2,
+                increase_percentage + 100,
             )
             .await;
         }
     };
-    println!("Pending transaction... tx hash: {}", tx_hash);
+    info!("Pending transaction... tx hash: {}", tx_hash);
 
     let receipt = match provider.get_transaction_receipt(tx_hash).await? {
         Some(receipt) => receipt,
         None => {
-            println!("get_transaction_receipt failed, resending tx");
+            info!("get_transaction_receipt failed, resending tx");
             return send_tx(
                 cfg,
                 provider,
                 receiver,
                 sidecar,
                 fees,
                 blob_base_fee,
-                increase_ratio * 2,
+                increase_percentage + 100,
             )
             .await;
         }
@@ -181,17 +176,16 @@ async fn send_tx<'async_recursion>(
 
 #[cfg(test)]
 mod tests {
-    use tracing::info;
-
     use super::*;
 
     // this test is mostly to check the send_payload method isolated from the
     // rest of the AD server logic
     #[tokio::test]
     async fn test_tx() -> anyhow::Result<()> {
+        crate::log_init();
         common::load_dotenv()?;
         let cfg = Config::from_env()?;
-        info!(?cfg, "Loaded config");
+        println!("Loaded config: {:?}", cfg);
 
         let tx_hash = send_payload(cfg, b"test".to_vec()).await?;
         dbg!(tx_hash);

ad-server/src/eth.rs

@@ -51,8 +51,17 @@ pub struct PodConfig {
     predicates: Predicates,
 }
 
+use tracing_subscriber::{EnvFilter, fmt, prelude::*};
+fn log_init() {
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
+    log_init();
     common::load_dotenv()?;
     let cfg = Config::from_env()?;
     info!(?cfg, "Loaded config");
@@ -66,9 +75,9 @@ async fn main() -> Result<()> {
 
     // initialize pod data
     let params = Params::default();
-    println!("Prebuilding circuits to calculate vd_set...");
+    info!("Prebuilding circuits to calculate vd_set...");
     let vd_set = &*DEFAULT_VD_SET;
-    println!("vd_set calculation complete");
+    info!("vd_set calculation complete");
     let predicates = build_predicates(&params);
     let shrunk_main_pod_build = Arc::new(ShrunkMainPodSetup::new(&params).build()?);
     let pod_config = PodConfig {
@@ -78,7 +87,7 @@ async fn main() -> Result<()> {
     };
 
     let routes = endpoints::routes(cfg, db_pool, pod_config, shrunk_main_pod_build);
-    println!("server at http://0.0.0.0:8000");
+    info!("server at http://0.0.0.0:8000");
     warp::serve(routes).run(([0, 0, 0, 0], 8000)).await;
 
     Ok(())

ad-server/src/main.rs

@@ -12,6 +12,8 @@ warp = { workspace = true }
 pod2 = { workspace = true }
 plonky2 = { workspace = true }
 itertools = "0.14.0"
+tracing = { workspace = true }
+tracing-log = { workspace = true }
 
 [dev-dependencies]
 app = { path = "../app" }

common/Cargo.toml

@@ -19,6 +19,7 @@ use pod2::{
     },
     middleware::{C, CommonCircuitData, D, F, Params, ToFields, VerifierCircuitData},
 };
+use tracing::info;
 
 pub struct ShrunkMainPodSetup {
     params: Params,
@@ -129,7 +130,7 @@ impl ShrunkMainPodBuild {
         self.shrunk_main_pod
             .set_targets(&mut pw, &pod_proof_with_pis)?;
         let proof = self.circuit_data.prove(pw)?;
-        println!("[TIME] shrunk MainPod proof took: {:?}", start.elapsed());
+        info!("[TIME] shrunk MainPod proof took: {:?}", start.elapsed());
 
         // sanity check: verify proof
         self.circuit_data.verify(proof.clone())?;
@@ -148,7 +149,7 @@ pub fn shrink_compress_pod(
     let start = Instant::now();
     let proof_with_pis = shrunk_main_pod_build.prove(pod)?;
     // let (verifier_data, common_circuit_data, proof_with_pis) = prove_pod(pod)?;
-    println!("[TIME] plonky2 (wrapper) proof took: {:?}", start.elapsed());
+    info!("[TIME] plonky2 (wrapper) proof took: {:?}", start.elapsed());
 
     // this next line performs the method `fri_query_indices`, which is not exposed
     let indices = proof_with_pis

common/src/circuits.rs

@@ -19,7 +19,7 @@ tmux split-window -v
 tmux select-layout even-vertical
 
 # run the AnchoredDatasystem server
-tmux send-keys -t fullflow:0.0 'cargo run --release -p ad-server' C-m
+tmux send-keys -t fullflow:0.0 'RUST_LOG=ad_server=debug cargo run --release -p ad-server' C-m
 
 # run the Synchronizer server
 tmux send-keys -t fullflow:0.1 'RUST_LOG=synchronizer=debug cargo run --release -p synchronizer' C-m

full-flow.sh

@@ -15,6 +15,9 @@ sqlx = { workspace = true }
 log = { workspace = true }
 warp = { workspace = true }
 hex = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+tracing-log = { workspace = true }
 
 common = { path = "../common" }
 
@@ -29,9 +32,5 @@ url = { version = "2.3.1", features = ["serde"] }
 # alloy-eips = { version = "1.0.30" }
 # alloy-network = { version = "1.0.30" }
 
-# logging
-tracing = "0.1.19"
-tracing-subscriber = { version = "0.3", features = ["registry", "env-filter" ] }
-tracing-log = "0.1.1"
 
 chrono = "0.4.42"