Merge pull request #5 from weaveVM/dev

chore: backfill blobs in blobscan service

Author: charmful0x

src/main.rs

@@ -3,7 +3,7 @@ use {
  std::sync::Arc,
  tokio::sync::RwLock,
  utils::{
- blobscan::{get_block_by_id, insert_block},
+ blobscan::{get_block_by_id, insert_block}, // backfill_blobscan_blobs
  constants::FIRST_ETH_L1_EIP4844_BLOCK,
  eth::Ethereum,
  planetscale::get_latest_block_id,
@@ -31,6 +31,8 @@ async fn main(
  let reader_block_number = block_number.clone();
  let writer_block_number = block_number.clone();
 
+ // backfill_blobscan_blobs(3).await;
+
  let blobscan_insertion = tokio::spawn(async move {
  let mut latest_archived_block = get_latest_block_id().await;
  loop {

src/utils/blobscan.rs

@@ -1,6 +1,10 @@
 use {
  crate::utils::env_var::get_env_var,
- crate::utils::{planetscale::ps_archive_block, types::BlobInfo, wvm::send_wvm_calldata},
+ crate::utils::{
+ planetscale::{ps_archive_block, ps_get_all_versioned_hashes_paginated},
+ types::BlobInfo,
+ wvm::send_wvm_calldata,
+ },
  eyre::{eyre, Error, Result},
  foundry_blob_explorers::{BlockResponse, Client},
  reqwest, serde_json,
@@ -104,3 +108,42 @@ pub async fn send_blob_to_blobscan(blob_hash: &str) -> Result<(), Error> {
 
  Ok(())
 }
+
+// pub async fn send_blobs_to_blobscan(blob_hash: Vec<&str>) -> Result<(), Error> {
+// let client = reqwest::Client::new();
+// let key = get_env_var("blobscan_api_key").unwrap();
+// let response = client
+// .post("https://api.blobscan.com/blobs/weavevm-references")
+// .header("Authorization", key)
+// .json(&serde_json::json!({
+// "blobHashes": blob_hash
+// }))
+// .send()
+// .await?;
+
+// println!("Status: {}", response.status());
+// println!("Headers: {:?}", response.headers());
+
+// Ok(())
+// }
+
+// pub async fn backfill_blobscan_blobs(page: u32) {
+// for page in 0..page {
+// let mut temp_hashes: Vec<&str> = vec![];
+// let mut i = 0;
+// let batch = ps_get_all_versioned_hashes_paginated(page).await;
+
+// for el in &batch {
+// let hash = &el.versioned_hash;
+// temp_hashes.push(&hash);
+// }
+// println!("Fetched {} blobs", temp_hashes.len());
+// println!("sending blobs on 10ks to blobscan");
+
+// while i < 100_000 {
+// println!("{} {}", i, i + 10_000);
+// let _ = send_blobs_to_blobscan(temp_hashes[i..i + 10_000].to_vec()).await.unwrap();
+// i += 10_000;
+// }
+// }
+// }

src/utils/planetscale.rs

@@ -2,7 +2,7 @@ use {
  crate::utils::{
  constants::FIRST_ETH_L1_EIP4844_BLOCK,
  env_var::get_env_var,
- types::{PsGetBlockByVersionedHash, PsGetLatestArchivedBlock},
+ types::{PsGetBlockByVersionedHash, PsGetLatestArchivedBlock, VersionedHashOnly},
  },
  anyhow::Error,
  planetscale_driver::{query, PSConnection},
@@ -87,3 +87,20 @@ pub async fn ps_get_blob_data_by_versioned_hash(versioned_hash: &str) -> Value {
  let res = serde_json::json!(ps_result);
  res
 }
+
+pub async fn ps_get_all_versioned_hashes_paginated(page: u32) -> Vec<VersionedHashOnly> {
+ let conn = ps_init().await;
+ let offset = page * 100000;
+
+ let query_str = format!(
+ "SELECT VersionedHash FROM Blobscan LIMIT 100000 OFFSET {};",
+ offset
+ );
+
+ let ps_results: Vec<VersionedHashOnly> = match query(&query_str).fetch_all(&conn).await {
+ Ok(results) => results,
+ Err(e) => panic!("Database query failed: {}", e),
+ };
+
+ ps_results
+}

src/utils/types.rs

@@ -2,6 +2,12 @@ use {
  planetscale_driver::Database,
  serde::{Deserialize, Serialize},
 };
+
+#[derive(Debug, Serialize, Deserialize, Database)]
+pub struct VersionedHashOnly {
+ pub versioned_hash: String,
+}
+
 #[derive(Debug, Serialize, Deserialize, Database)]
 pub struct PsGetBlockByVersionedHash {
  pub ethereum_block_number: u64,