feat:the proof of the Pois algorithm is partially completed

Cargo.toml

@@ -394,6 +394,7 @@ spin = { version = "0.9", default-features = false, features = [
 static_assertions = "1.1.0"
 subxt = { git = "https://github.com/CESSProject/subxt", branch = "polkadot-stable2412", default-features = false }
 syn = "2.0"
+sysinfo = { version = "0.34.2" }
 tempfile = "3.10"
 thiserror = "1.0"
 threadpool = "1.8.1"

crates/ces-pois/Cargo.toml

@@ -3,6 +3,10 @@ name = "ces-pois"
 version = "0.4.5"
 edition = "2021"
 
+[features]
+default = []
+use-sysinfo = []
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
@@ -19,4 +23,9 @@ prost = { workspace = true }
 rand = { workspace = true }
 rsa = { workspace = true, features = ["std"] }
 serde = { workspace = true, features = ["derive"] }
-sha2 = { workspace = true }
+serde_json = { workspace = true, features = ["std"] }
+sha2 = { workspace = true }
+tokio = { workspace = true, features = ["full"] }
+sysinfo = { workspace = true, optional = true }
+async-trait = { workspace = true }
+byteorder = { workspace = true }

crates/ces-pois/src/acc/file_manager.rs

@@ -0,0 +1,84 @@
+use super::multi_level_acc::{AccData, DEFAULT_BACKUP_NAME, DEFAULT_NAME};
+use crate::util;
+use anyhow::{Context, Result};
+use std::fs::{self, File};
+use std::io::Read;
+use std::path::Path;
+
+pub fn save_acc_data(dir: &str, index: i64, elems: Vec<Vec<u8>>, wits: Vec<Vec<u8>>) -> Result<()> {
+    let data = AccData { values: elems, wits };
+
+    let jbytes = serde_json::to_vec(&data)?;
+
+    let fpath = Path::new(dir).join(format!("{}-{}", DEFAULT_NAME, index));
+
+    util::save_file(&fpath, &jbytes)
+}
+
+pub fn read_acc_data(dir: &str, index: i64) -> Result<AccData> {
+    let fpath = format!("{}/{}-{}", dir, DEFAULT_NAME, index);
+    read_data(&fpath)
+}
+pub fn read_backup(dir: &str, index: i64) -> Result<AccData> {
+    let fpath = format!("{}/{}-{}", dir, DEFAULT_BACKUP_NAME, index);
+    read_data(&fpath)
+}
+
+pub fn read_data(fpath: &str) -> Result<AccData> {
+    let mut file = File::open(fpath).context("read element data error")?;
+    let mut data = Vec::new();
+    file.read_to_end(&mut data).context("read element data error")?;
+    serde_json::from_slice(&data).context("read element data error")
+}
+
+// deleteAccData delete from the given index
+pub fn delete_acc_data(dir: &str, last: i32) -> Result<()> {
+    let fs = fs::read_dir(dir).context("delete element data error")?;
+    for entry in fs {
+        let entry = entry.context("delete element data error")?;
+        let path = entry.path();
+        if let Some(file_name) = path.file_name() {
+            if let Some(file_name_str) = file_name.to_str() {
+                if let Some(index_str) = file_name_str.rsplit('-').next() {
+                    if let Ok(index) = index_str.parse::<i32>() {
+                        if index <= last {
+                            fs::remove_file(path).context("delete element data error")?;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+pub fn clean_backup(dir: &str, index: i64) -> Result<()> {
+    let backup = format!("{}/{}-{}", dir, DEFAULT_BACKUP_NAME, index);
+    fs::remove_file(backup).context("clean backup error")
+}
+
+pub fn backup_acc_data(dir: &str, index: i64) -> Result<()> {
+    let fpath = format!("{}/{}-{}", dir, DEFAULT_NAME, index);
+    let backup = format!("{}/{}-{}", dir, DEFAULT_BACKUP_NAME, index);
+    util::copy_file(&fpath, &backup).context("backup element data error")
+}
+
+pub fn backup_acc_data_for_chall(src: &str, des: &str, index: i64) -> Result<()> {
+    let fpath = Path::new(src).join(format!("{}-{}", DEFAULT_NAME, index));
+    let backup = Path::new(des).join(format!("{}-{}", DEFAULT_NAME, index));
+    util::copy_file(fpath.to_str().unwrap(), backup.to_str().unwrap())
+        .context("backup acc data for challenge error")?;
+    Ok(())
+}
+
+pub fn recovery_acc_data(dir: &str, index: i64) -> Result<()> {
+    let backup = Path::join(Path::new(dir), &format!("{}-{}", DEFAULT_BACKUP_NAME, index));
+    let fpath = Path::join(Path::new(dir), &format!("{}-{}", DEFAULT_NAME, index));
+
+    if !backup.exists() {
+        return Ok(());
+    }
+
+    fs::rename(&backup, &fpath).context("recovery acc data error")?;
+    Ok(())
+}