Replace Init with Handshake

Cargo.toml

@@ -7,17 +7,16 @@ edition = "2021"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-wasm-bindgen = "0.2.90"
-serde = { version = "1.0.193", features = ["derive"] }
-serde_json = "1.0.108"
-# sp_backend = { git = "https://github.com/Sosthene00/sp-backend.git", branch = "master" }
-# silentPayments = { git = "https://github.com/Sosthene00/rust-silentPayments", branch = "utils" }
-rand = "0.8.5"
-hex = "0.4.3"
-uuid = { version = "1.6.1", features = ["serde", "v4"] }
-sha2 = "0.10.8"
-chrono = "0.4.31"
 aes-gcm = "0.10.3"
-aes = "0.8.3"
-base64 = "0.21.7"
-rocket = { version = "0.5.0", features = ["json"] }
+anyhow = "1.0"
+js-sys = "0.3.69"
+env_logger = "0.9"
+log = "0.4.6"
+rand = "0.8.5"
+serde = { version = "1.0.193", features = ["derive"] }
+serde_json = { version = "1.0.108", features = ["preserve_order"]}
+# sp_client = { path = "../sp-client" }
+sp_client = { git = "https://github.com/Sosthene00/sp-client.git", branch = "4nk" }
+tsify = { git = "https://github.com/Sosthene00/tsify", branch = "next" }
+wasm-bindgen = "0.2.91"
+rs_merkle = "1.4.2"

src/crypto.rs

@@ -0,0 +1,58 @@
+use anyhow::{Error, Result};
+use sp_client::silentpayments::{
+    bitcoin_hashes::{sha256t_hash_newtype, Hash, HashEngine},
+    secp256k1::PublicKey,
+};
+
+use aes_gcm::aead::{Aead, Payload};
+pub use aes_gcm::{AeadCore, Aes256Gcm, KeyInit};
+use rand::thread_rng;
+
+pub const AAD: &[u8] = "4nk".as_bytes();
+
+sha256t_hash_newtype! {
+    pub struct AnkSharedSecretTag = hash_str("4nk/AnkSharedSecret");
+
+    #[hash_newtype(forward)]
+    pub struct AnkSharedSecretHash(_);
+}
+
+impl AnkSharedSecretHash {
+    pub fn from_shared_point(shared_point: PublicKey) -> Self {
+        let mut eng = AnkSharedSecretHash::engine();
+        eng.input(&shared_point.serialize_uncompressed()[1..]);
+        AnkSharedSecretHash::from_engine(eng)
+    }
+}
+
+pub fn encrypt_with_key(key: &[u8; 32], plaintext: &[u8]) -> Result<Vec<u8>> {
+    let encryption_eng = Aes256Gcm::new(key.into());
+    let nonce = Aes256Gcm::generate_nonce(&mut thread_rng());
+    let payload = Payload {
+        msg: plaintext,
+        aad: AAD,
+    };
+    let ciphertext = encryption_eng
+        .encrypt(&nonce, payload)
+        .map_err(|e| anyhow::anyhow!(e))?;
+
+    let mut res: Vec<u8> = Vec::with_capacity(nonce.len() + ciphertext.len());
+    res.extend_from_slice(&nonce);
+    res.extend_from_slice(&ciphertext);
+
+    Ok(res)
+}
+
+pub fn decrypt_with_key(key: &[u8; 32], ciphertext: &[u8]) -> Result<Vec<u8>> {
+    let decryption_eng = Aes256Gcm::new(key.into());
+    let nonce = &ciphertext[..12];
+    let payload = Payload {
+        msg: &ciphertext[12..],
+        aad: AAD,
+    };
+    let plaintext = decryption_eng
+        .decrypt(nonce.into(), payload)
+        .map_err(|e| anyhow::anyhow!(e))?;
+
+    Ok(plaintext)
+}

src/device.rs

@@ -0,0 +1,66 @@
+use serde::{Deserialize, Serialize};
+use tsify::Tsify;
+use wasm_bindgen::prelude::*;
+
+use sp_client::{
+    bitcoin::OutPoint, silentpayments::utils::SilentPaymentAddress, spclient::SpWallet
+};
+
+use crate::pcd::Member;
+
+#[derive(Debug, Serialize, Deserialize, Clone, Default, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct Device {
+    sp_wallet: SpWallet,
+    pairing_process_commitment: Option<OutPoint>,
+    paired_member: Member,
+}
+
+impl Device {
+    pub fn new(sp_wallet: SpWallet) -> Self {
+        let local_address = sp_wallet.get_client().get_receiving_address();
+        let member = Member::new(vec![SilentPaymentAddress::try_from(local_address).unwrap()]).unwrap();
+        Self {
+            sp_wallet,
+            pairing_process_commitment: None,
+            paired_member: member,
+        }
+    }
+
+    pub fn get_wallet(&self) -> &SpWallet {
+        &self.sp_wallet
+    }
+
+    pub fn get_mut_wallet(&mut self) -> &mut SpWallet {
+        &mut self.sp_wallet
+    }
+
+    pub fn get_pairing_commitment(&self) -> Option<OutPoint> {
+        self.pairing_process_commitment.clone()
+    }
+
+    pub fn pair(&mut self, commitment_outpoint: OutPoint, member: Member) {
+        self.pairing_process_commitment = Some(commitment_outpoint);
+        self.paired_member = member;
+    }
+
+    pub fn unpair(&mut self) {
+        let local_address = self.get_wallet().get_client().get_receiving_address();
+        let member = Member::new(vec![SilentPaymentAddress::try_from(local_address).unwrap()]).unwrap();
+        self.paired_member = member;
+        self.pairing_process_commitment = None;
+    }
+
+    pub fn to_member(&self) -> Member {
+        self.paired_member.clone()
+    }
+
+    pub fn get_other_addresses(&self) -> Vec<String> {
+        let our_address = self.get_wallet().get_client().get_receiving_address();
+        self.to_member()
+            .get_addresses()
+            .into_iter()
+            .filter(|a| *a != our_address)
+            .collect()
+    }
+}

src/error.rs

@@ -0,0 +1,41 @@
+use std::error::Error;
+use std::fmt;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+pub enum AnkError {
+    GenericError(String),
+    FaucetError(String),
+    NewTxError(String),
+    CipherError(String),
+}
+
+impl fmt::Display for AnkError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            AnkError::GenericError(msg) => write!(f, "GenericError: {}", msg),
+            AnkError::FaucetError(msg) => write!(f, "FaucetError: {}", msg),
+            AnkError::NewTxError(msg) => write!(f, "NewTxError: {}", msg),
+            AnkError::CipherError(msg) => write!(f, "CipherError: {}", msg),
+        }
+    }
+}
+
+impl Error for AnkError {}
+
+impl From<anyhow::Error> for AnkError {
+    fn from(error: anyhow::Error) -> Self {
+        let error_message = error.to_string();
+
+        if error_message.contains("FaucetError") {
+            AnkError::FaucetError(error_message)
+        } else if error_message.contains("NewTxError") {
+            AnkError::NewTxError(error_message)
+        } else if error_message.contains("CipherError") {
+            AnkError::CipherError(error_message)
+        } else {
+            AnkError::GenericError(error_message)
+        }
+    }
+}

src/lib.rs

@@ -1,3 +1,31 @@
-pub mod models;
-pub mod wallet;
-pub mod workflows;
+use std::fmt::Debug;
+use std::sync::{Mutex, MutexGuard};
+
+pub use aes_gcm;
+pub use env_logger;
+pub use log;
+pub use sp_client;
+
+pub mod crypto;
+pub mod device;
+pub mod error;
+pub mod network;
+pub mod pcd;
+pub mod prd;
+pub mod process;
+pub mod secrets;
+pub mod signature;
+pub mod silentpayments;
+
+pub const MAX_PRD_PAYLOAD_SIZE: usize = u16::MAX as usize; // 64KiB sounds reasonable for now
+
+pub trait MutexExt<T> {
+    fn lock_anyhow(&self) -> Result<MutexGuard<T>, anyhow::Error>;
+}
+
+impl<T: Debug> MutexExt<T> for Mutex<T> {
+    fn lock_anyhow(&self) -> Result<MutexGuard<T>, anyhow::Error> {
+        self.lock()
+            .map_err(|e| anyhow::Error::msg(format!("Failed to lock: {}", e)))
+    }
+}

src/main.rs

@@ -1,5 +0,0 @@
-use sdk_common::models;
-use sdk_common::wallet;
-use sdk_common::workflows;
-
-fn main() {}

src/models/commitment_method.rs

@@ -1,11 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct commitMethod {
-    pub method: String,
-}
-impl commitMethod {
-    pub fn new(method: String) -> Self {
-        commitMethod { method }
-    }
-}

src/models/condition_cap.rs

@@ -1,25 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::TransactionMode;
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct ConditionCap {
-    pub role_deposit: String,
-    pub role_transaction: TransactionMode,
-}
-
-impl ConditionCap {
-    pub fn new(role_deposit: String, role_transaction: TransactionMode) -> Self {
-        ConditionCap {
-            role_deposit,
-            role_transaction,
-        }
-    }
-    // Affiche les informations de la structure
-    pub fn display_info(&self) {
-        println!("ConditionCap:");
-        println!("Role Deposit: {}", self.role_deposit);
-        println!("Role Transaction:");
-        self.role_transaction.display_info(); // Appelle display_info sur role_transaction
-    }
-}

src/models/condition_commitment.rs

@@ -1,23 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::TransactionMode;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Conditioncommit {
-    pub role_artefact: String,
-    pub role_transaction: TransactionMode,
-}
-
-impl Conditioncommit {
-    pub fn new(role_artefact: String, role_transaction: TransactionMode) -> Self {
-        Conditioncommit {
-            role_artefact,
-            role_transaction,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("Conditioncommit:");
-        println!("Role Artefact: {}", self.role_artefact);
-        println!("Role Transaction:");
-        self.role_transaction.display_info(); // Appelle display_info sur role_transaction
-    }
-}

src/models/condition_deposit.rs

@@ -1,24 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::TransactionMode;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct ConditionDeposit {
-    pub role_deposit: String,
-    pub role_transaction: TransactionMode,
-}
-
-impl ConditionDeposit {
-    pub fn new(role_deposit: String, role_transaction: TransactionMode) -> Self {
-        ConditionDeposit {
-            role_deposit,
-            role_transaction,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("ConditionDeposit:");
-        println!("Role Deposit: {}", self.role_deposit);
-        println!("Role Transaction:");
-        self.role_transaction.display_info(); // Appelle display_info sur role_transaction
-    }
-}

src/models/condition_orchestration.rs

@@ -1,19 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct ConditionOrchestration {
-    pub role_ok: String,
-    pub role_ko: String,
-}
-
-impl ConditionOrchestration {
-    pub fn new(role_ok: String, role_ko: String) -> Self {
-        ConditionOrchestration { role_ok, role_ko }
-    }
-    pub fn display_info(&self) {
-        println!("ConditionOrchestration:");
-        println!("Role OK: {}", self.role_ok);
-        println!("Role KO: {}", self.role_ko);
-    }
-}

src/models/condition_payment.rs

@@ -1,25 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::TransactionMode;
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct ConditionPayments {
-    pub role_Payments: String,
-    pub role_transaction: TransactionMode,
-}
-
-impl ConditionPayments {
-    pub fn new(role_Payments: String, role_transaction: TransactionMode) -> Self {
-        ConditionPayments {
-            role_Payments,
-            role_transaction,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("ConditionPayments:");
-        println!("Role Payments: {}", self.role_Payments);
-        println!("Role Transaction:");
-        self.role_transaction.display_info(); // Appelle display_info sur role_transaction
-    }
-}

src/models/condition_prd_address_set.rs

@@ -1,141 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct ConditionPrdAddressSet {
-    pub from_role: String,
-    pub prd_sp_address_list: Vec<String>,
-    pub prd_sp_address_required_list: Vec<String>,
-    pub prd_sp_address_quota: i32,
-    pub prd_prd_value_ok_list: Vec<String>,
-    pub prd_value_ko_list: Vec<String>,
-    pub prd_value_none_list: Vec<String>,
-    pub prd_sp_address_value_min: i64,
-    pub prd_sp_address_value_min_per: i64,
-    pub prd_sp_address_value_min_ok: bool,
-    pub prd_sp_adddress_value_ok_min_per: i64,
-    pub prd_sp_address_value_ok_max: i64,
-    pub prd_sp_adderss_value_ko_max_per: i64,
-    pub prd_sp_address_value_none_max: i64,
-    pub prd_sp_adderss_value_none_max_per: i64,
-    pub prd_sp_address_score_min: i32,
-    pub prd_sp_address_score_min_min_required: i32,
-    pub prd_sp_address_score_min_min_ok: bool,
-    pub prd_sp_address_score_min_min_per: i64,
-    pub prd_value_auto_ok: bool,
-    pub prd_value_auto_ko: bool,
-    pub prd_value_auto_none: bool,
-}
-
-impl ConditionPrdAddressSet {
-    // Constructor for PrdAddressSet with all fields
-    pub fn new(
-        from_role: String,
-        prd_sp_address_list: Vec<String>,
-        prd_sp_address_required_list: Vec<String>,
-        prd_sp_address_quota: i32,
-        prd_prd_value_ok_list: Vec<String>,
-        prd_value_ko_list: Vec<String>,
-        prd_value_none_list: Vec<String>,
-        prd_sp_address_value_min: i64,
-        prd_sp_address_value_min_per: i64,
-        prd_sp_address_value_min_ok: bool,
-        prd_sp_adddress_value_ok_min_per: i64,
-        prd_sp_address_value_ok_max: i64,
-        prd_sp_adderss_value_ko_max_per: i64,
-        prd_sp_address_value_none_max: i64,
-        prd_sp_adderss_value_none_max_per: i64,
-        prd_sp_address_score_min: i32,
-        prd_sp_address_score_min_min_required: i32,
-        prd_sp_address_score_min_min_ok: bool,
-        prd_sp_address_score_min_min_per: i64,
-        prd_value_auto_ok: bool,
-        prd_value_auto_ko: bool,
-        prd_value_auto_none: bool,
-    ) -> Self {
-        ConditionPrdAddressSet {
-            from_role,
-            prd_sp_address_list,
-            prd_sp_address_required_list,
-            prd_sp_address_quota,
-            prd_prd_value_ok_list,
-            prd_value_ko_list,
-            prd_value_none_list,
-            prd_sp_address_value_min,
-            prd_sp_address_value_min_per,
-            prd_sp_address_value_min_ok,
-            prd_sp_adddress_value_ok_min_per,
-            prd_sp_address_value_ok_max,
-            prd_sp_adderss_value_ko_max_per,
-            prd_sp_address_value_none_max,
-            prd_sp_adderss_value_none_max_per,
-            prd_sp_address_score_min,
-            prd_sp_address_score_min_min_required,
-            prd_sp_address_score_min_min_ok,
-            prd_sp_address_score_min_min_per,
-            prd_value_auto_ok,
-            prd_value_auto_ko,
-            prd_value_auto_none,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("ConditionPrdAddressSet:");
-        println!("From Role: {}", self.from_role);
-        println!("SP Address List: {:?}", self.prd_sp_address_list);
-        println!(
-            "SP Address Required List: {:?}",
-            self.prd_sp_address_required_list
-        );
-        println!("SP Address Quota: {}", self.prd_sp_address_quota);
-        println!("PRD Value OK List: {:?}", self.prd_prd_value_ok_list);
-        println!("Value KO List: {:?}", self.prd_value_ko_list);
-        println!("Value None List: {:?}", self.prd_value_none_list);
-        println!("SP Address Value Min: {}", self.prd_sp_address_value_min);
-        println!(
-            "SP Address Value Min Percentage: {}",
-            self.prd_sp_address_value_min_per
-        );
-        println!(
-            "SP Address Value Min OK: {}",
-            self.prd_sp_address_value_min_ok
-        );
-        println!(
-            "SP Address Value OK Min Percentage: {}",
-            self.prd_sp_adddress_value_ok_min_per
-        );
-        println!(
-            "SP Address Value OK Max: {}",
-            self.prd_sp_address_value_ok_max
-        );
-        println!(
-            "SP Address Value KO Max Percentage: {}",
-            self.prd_sp_adderss_value_ko_max_per
-        );
-        println!(
-            "SP Address Value None Max: {}",
-            self.prd_sp_address_value_none_max
-        );
-        println!(
-            "SP Address Value None Max Percentage: {}",
-            self.prd_sp_adderss_value_none_max_per
-        );
-        println!("SP Address Score Min: {}", self.prd_sp_address_score_min);
-        println!(
-            "SP Address Score Min Required: {}",
-            self.prd_sp_address_score_min_min_required
-        );
-        println!(
-            "SP Address Score Min OK: {}",
-            self.prd_sp_address_score_min_min_ok
-        );
-        println!(
-            "SP Address Score Min Percentage: {}",
-            self.prd_sp_address_score_min_min_per
-        );
-        println!("Value Auto OK: {}", self.prd_value_auto_ok);
-        println!("Value Auto KO: {}", self.prd_value_auto_ko);
-        println!("Value Auto None: {}", self.prd_value_auto_none);
-    }
-
-    // Methods for manipulating the struct can be added here as needed.
-}

src/models/condition_publish.rs

@@ -1,49 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::metadata::Amount;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct ConditionPublish {
-    pub pcd_data_size_max_unit: String,
-    pub pcd_data_size_max_total: i64,
-    pub pcd_number_min: i32,
-    pub pcd_number_max: i32,
-    pub pcd_amount_max_total: Amount,
-    pub Prd_waiting_timeout: u64,
-    pub pcd_waiting_timeout: u64,
-}
-
-impl ConditionPublish {
-    pub fn new(
-        pcd_data_size_max_unit: String,
-        pcd_data_size_max_total: i64,
-        pcd_number_min: i32,
-        pcd_number_max: i32,
-        pcd_amount_max_total: Amount,
-        Prd_waiting_timeout: u64,
-        pcd_waiting_timeout: u64,
-    ) -> Self {
-        ConditionPublish {
-            pcd_data_size_max_unit,
-            pcd_data_size_max_total,
-            pcd_number_min,
-            pcd_number_max,
-            pcd_amount_max_total,
-            Prd_waiting_timeout,
-            pcd_waiting_timeout,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("ConditionPublish:");
-        println!("PCD Data Size Max Unit: {}", self.pcd_data_size_max_unit);
-        println!("PCD Data Size Max Total: {}", self.pcd_data_size_max_total);
-        println!("PCD Number Min: {}", self.pcd_number_min);
-        println!("PCD Number Max: {}", self.pcd_number_max);
-        self.pcd_amount_max_total.display_info();
-        println!(
-            " Prd Waiting Timeout: {}",
-            self.Prd_waiting_timeout
-        );
-        println!("PCD Waiting Timeout: {}", self.pcd_waiting_timeout);
-    }
-}

src/models/deposit_method.rs

@@ -1,8 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct DepositMethod {
-    pub method: String,
-}
-impl DepositMethod {}

src/models/item.rs

@@ -1,94 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use uuid::Uuid;
-
-use super::{
-    key_encryption::KeyEncryption, metadata_contract_public::MetadataContractPublic,
-    metadata_private::MetadataPrivate, metadata_role_confidential::MetadataRoleConfidential,
-    pcd_item_enc::PcdItemEnc,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Item {
-    pub uuid: String,
-    pub version: i64,
-    pub hash: Option<String>,
-    pub item_type: String, // `type` is a reserved keyword in Rust, renamed to `item_type`
-    pub name: String,
-    pub pagination_number_per_pcd: u32,
-    pub metadata_contract_public: MetadataContractPublic,
-    pub metadata_role_confidential: MetadataRoleConfidential,
-    pub metadata_private: MetadataPrivate,
-}
-
-impl Item {
-    pub fn new(
-        version: i64,
-        item_type: String,
-        name: String,
-        pagination_number_per_pcd: u32,
-        metadata_contract_public: MetadataContractPublic,
-        metadata_role_confidential: MetadataRoleConfidential,
-        metadata_private: MetadataPrivate,
-    ) -> Self {
-        let uuid: String = Uuid::new_v4().to_string();
-        Item {
-            uuid,
-            version,
-            item_type,
-            name,
-            pagination_number_per_pcd,
-            metadata_contract_public,
-            metadata_role_confidential,
-            metadata_private,
-            hash: None,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("Item:");
-        println!("UUID: {}", self.uuid);
-        println!("Version: {}", self.version);
-        println!("Item Type: {}", self.item_type);
-        println!("Name: {}", self.name);
-        println!(
-            "Pagination Number Per PCD: {}",
-            self.pagination_number_per_pcd
-        );
-
-        println!("Metadata Contract Public:");
-        self.metadata_contract_public.display_info(); // Display information for `metadata_contract_public`
-
-        println!("Metadata Role Confidential:");
-        self.metadata_role_confidential.display_info(); // Display information for `metadata_role_confidential`
-
-        println!("Metadata Private:");
-        self.metadata_private.display_info(); // Display information for `metadata_private`
-    }
-
-    pub fn enc(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-    ) -> PcdItemEnc {
-        let enc_metadata_contract_public = self
-            .metadata_contract_public
-            .enc_list(process_public_enc_key);
-
-        let enc_metadata_role_confidential = self.metadata_role_confidential.enc_list();
-
-        let enc_metadata_private = self.metadata_private.enc_list(Member_private_enc_key);
-
-        PcdItemEnc::new(
-            self.version,
-            self.item_type.clone(),
-            self.name.clone(),
-            self.pagination_number_per_pcd,
-            enc_metadata_contract_public,
-            enc_metadata_role_confidential,
-            enc_metadata_private,
-        )
-    }
-
-    // Additional methods for Item can be added here
-}

src/models/item_artefact.rs

@@ -1,131 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::json;
-use std::hash::Hash;
-
-use super::item::Item;
-use super::key_encryption::KeyEncryption;
-use super::pcd_item_enc_attribute_private::PcdItemEncAttributePrivate;
-use super::pcd_item_enc_attribute_public::PcdItemEncAttributePublic;
-use super::pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential;
-use super::pcd_item_generic_enc::PcdItemGenericEnc;
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Artefact {
-    pub item: Item,
-    pub public_attribute_group: Vec<String>, // Assuming list of attributes
-    pub role_confidential_attribute_group: Vec<String>,
-    pub private_attribute_group: Vec<String>,
-}
-
-impl Artefact {
-    pub fn new(
-        item: Item,
-        public_attribute_group: Vec<String>,
-        role_confidential_attribute_group: Vec<String>,
-        private_attribute_group: Vec<String>,
-    ) -> Self {
-        Artefact {
-            item,
-            public_attribute_group,
-            role_confidential_attribute_group,
-            private_attribute_group,
-        }
-    }
-    pub fn enc_public_attribute_group(
-        &self,
-        process_public_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePublic> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();
-
-        let mut count = 0;
-        for public_attribute in &self.public_attribute_group {
-            let name = "index".to_owned() + &count.to_string();
-            let value = serde_json::to_value(public_attribute).unwrap_or_else(|_| json!({}));
-            let enc_attribute =
-                PcdItemEncAttributePublic::new(name, process_public_enc_key.enc(value));
-            enc_attribute_list.push(enc_attribute);
-            count += 1;
-        }
-
-        enc_attribute_list
-    }
-    pub fn enc_role_confidential_attribute_group(
-        &self,
-    ) -> Vec<PcdItemEncAttributeRoleConfidential> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributeRoleConfidential> = Vec::new();
-
-        let mut count = 0;
-        for role_confidential_attribute in &self.role_confidential_attribute_group {
-            let name = "index".to_owned() + &count.to_string();
-            let value =
-                serde_json::to_value(role_confidential_attribute).unwrap_or_else(|_| json!({}));
-            let mut role_confidential_attribute_key =
-                KeyEncryption::new(Some(name.clone()), None, None);
-            if let Ok(_new) = role_confidential_attribute_key.key_new_random() {
-                let enc_attribute = PcdItemEncAttributeRoleConfidential::new(
-                    name,
-                    role_confidential_attribute_key.enc(value),
-                    role_confidential_attribute_key,
-                );
-                enc_attribute_list.push(enc_attribute);
-            }
-            count += 1;
-        }
-
-        enc_attribute_list
-    }
-    pub fn enc_private_attribute_group(
-        &self,
-        Member_private_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePrivate> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();
-
-        let mut count = 0;
-        for private_attribute in &self.public_attribute_group {
-            let name = "index".to_owned() + &count.to_string();
-            let value = serde_json::to_value(private_attribute).unwrap_or_else(|_| json!({}));
-            let enc_attribute =
-                PcdItemEncAttributePrivate::new(name, Member_private_enc_key.enc(value));
-            enc_attribute_list.push(enc_attribute);
-            count += 1;
-        }
-
-        enc_attribute_list
-    }
-
-    pub fn enc(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-    ) -> PcdItemGenericEnc {
-        let enc_metadata_contract_public =
-            self.enc_public_attribute_group(process_public_enc_key.clone());
-
-        let enc_role_confidential_attribute_group = self.enc_role_confidential_attribute_group();
-
-        let enc_metadata_private = self.enc_private_attribute_group(Member_private_enc_key.clone());
-
-        PcdItemGenericEnc::new(
-            self.item
-                .enc(process_public_enc_key, Member_private_enc_key),
-            Some(enc_metadata_contract_public),
-            Some(enc_role_confidential_attribute_group),
-            Some(enc_metadata_private),
-        )
-    }
-    pub fn display_info(&self) {
-        println!("Artefact:");
-        println!("Item:");
-        self.item.display_info(); // Appelle display_info sur item
-
-        println!("Public Attribute Group: {:?}", self.public_attribute_group);
-        println!(
-            "Role Confidential Attribute Group: {:?}",
-            self.role_confidential_attribute_group
-        );
-        println!(
-            "Private Attribute Group: {:?}",
-            self.private_attribute_group
-        );
-    }
-}

src/models/item_commitment.rs

@@ -1,239 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    item::Item, key_encryption::KeyEncryption,
-    pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
-    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
-    pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential,
-    pcd_item_generic_enc::PcdItemGenericEnc,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct CommitPublicAttributeGroup {
-    pub for_sp_address_list: Vec<String>,
-    pub goal_list: Vec<String>,
-    pub provider_type: String,
-    pub commit_pcd_hash_list: Vec<String>,
-    pub ref_item_hash_list: Vec<String>,
-    pub ref_pcd_hash_list: Vec<String>,
-    pub payload_public_list: Vec<String>,
-}
-
-impl CommitPublicAttributeGroup {
-    pub fn new(
-        for_sp_address_list: Vec<String>,
-        goal_list: Vec<String>,
-        provider_type: String,
-        commit_pcd_hash_list: Vec<String>,
-        ref_item_hash_list: Vec<String>,
-        ref_pcd_hash_list: Vec<String>,
-        payload_public_list: Vec<String>,
-    ) -> Self {
-        CommitPublicAttributeGroup {
-            for_sp_address_list,
-            goal_list,
-            provider_type,
-            commit_pcd_hash_list,
-            ref_item_hash_list,
-            ref_pcd_hash_list,
-            payload_public_list,
-        }
-    }
-    pub fn enc_group(
-        &self,
-        process_public_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePublic> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();
-
-        let for_sp_address_list_enc = PcdItemEncAttributePublic::new(
-            "for_sp_address_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.for_sp_address_list.clone()),
-        );
-        enc_attribute_list.push(for_sp_address_list_enc);
-
-        let goal_list_enc = PcdItemEncAttributePublic::new(
-            "goal_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.goal_list.clone()),
-        );
-        enc_attribute_list.push(goal_list_enc);
-
-        let provider_type_enc = PcdItemEncAttributePublic::new(
-            "provider_type".to_owned(),
-            process_public_enc_key.enc_string(self.provider_type.clone()),
-        );
-        enc_attribute_list.push(provider_type_enc);
-
-        let commit_pcd_hash_list_enc = PcdItemEncAttributePublic::new(
-            "commit_pcd_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.commit_pcd_hash_list.clone()),
-        );
-        enc_attribute_list.push(commit_pcd_hash_list_enc);
-
-        let ref_item_hash_list_enc = PcdItemEncAttributePublic::new(
-            "ref_item_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.ref_item_hash_list.clone()),
-        );
-        enc_attribute_list.push(ref_item_hash_list_enc);
-
-        let ref_pcd_hash_list_enc = PcdItemEncAttributePublic::new(
-            "ref_pcd_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.ref_pcd_hash_list.clone()),
-        );
-        enc_attribute_list.push(ref_pcd_hash_list_enc);
-
-        let payload_public_list_enc = PcdItemEncAttributePublic::new(
-            "payload_public_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.payload_public_list.clone()),
-        );
-        enc_attribute_list.push(payload_public_list_enc);
-
-        enc_attribute_list
-    }
-    pub fn display_info(&self) {
-        println!("CommitPublicAttributeGroup:");
-        println!("For SP Address List: {:?}", self.for_sp_address_list);
-        println!("Goal List: {:?}", self.goal_list);
-        println!("Provider Type: {}", self.provider_type);
-        println!(
-            "commit PCD Hash List: {:?}",
-            self.commit_pcd_hash_list
-        );
-        println!("Ref Item Hash List: {:?}", self.ref_item_hash_list);
-        println!("Ref PCD Hash List: {:?}", self.ref_pcd_hash_list);
-        println!("Payload Public List: {:?}", self.payload_public_list);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct CommitRoleConfidentialAttributeGroup {
-    pub payload_list_confidential: Vec<String>,
-}
-
-impl CommitRoleConfidentialAttributeGroup {
-    pub fn new(payload_list_confidential: Vec<String>) -> Self {
-        CommitRoleConfidentialAttributeGroup {
-            payload_list_confidential,
-        }
-    }
-    pub fn enc_group(&self) -> Vec<PcdItemEncAttributeRoleConfidential> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributeRoleConfidential> = Vec::new();
-
-        let mut payload_list_confidential_key =
-            KeyEncryption::new(Some("payload_list_confidential".to_owned()), None, None);
-        if let Ok(_new) = payload_list_confidential_key.key_new_random() {
-            let payload_list_confidential_enc = PcdItemEncAttributeRoleConfidential::new(
-                "payload_list_confidential".to_owned(),
-                payload_list_confidential_key
-                    .enc_vec_string(self.payload_list_confidential.clone()),
-                payload_list_confidential_key,
-            );
-            enc_attribute_list.push(payload_list_confidential_enc);
-        }
-
-        return enc_attribute_list;
-    }
-    pub fn display_info(&self) {
-        println!("CommitRoleConfidentialAttributeGroup:");
-        for (index, payload) in self.payload_list_confidential.iter().enumerate() {
-            println!("Confidential Payload {}: {}", index + 1, payload);
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct CommitPrivateAttributeGroup {
-    pub payload_list_private: Vec<String>,
-}
-
-impl CommitPrivateAttributeGroup {
-    pub fn new(payload_list_private: Vec<String>) -> Self {
-        CommitPrivateAttributeGroup {
-            payload_list_private,
-        }
-    }
-    pub fn enc_group(&self, Member_enc_key: KeyEncryption) -> Vec<PcdItemEncAttributePrivate> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();
-
-        let payload_list_private_enc = PcdItemEncAttributePrivate::new(
-            "payload_list_private".to_owned(),
-            Member_enc_key.enc_vec_string(self.payload_list_private.clone()),
-        );
-        enc_attribute_list.push(payload_list_private_enc);
-
-        enc_attribute_list
-    }
-    pub fn display_info(&self) {
-        println!("CommitRoleConfidentialAttributeGroup:");
-        for (index, payload) in self.payload_list_private.iter().enumerate() {
-            println!("Private Payload {}: {}", index + 1, payload);
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Commit {
-    pub item: Item,
-    pub public_attribute_group: CommitPublicAttributeGroup,
-    pub role_confidential_attribute_group: CommitRoleConfidentialAttributeGroup,
-    pub private_attribute_group: CommitPrivateAttributeGroup,
-}
-
-impl Commit {
-    pub const ITEM_NAME: &'static str = "commit";
-    pub fn new(
-        mut item: Item,
-        public_attribute_group: CommitPublicAttributeGroup,
-        role_confidential_attribute_group: CommitRoleConfidentialAttributeGroup,
-        private_attribute_group: CommitPrivateAttributeGroup,
-    ) -> Self {
-        item.name = Self::ITEM_NAME.to_string();
-        Commit {
-            item,
-            public_attribute_group,
-            role_confidential_attribute_group,
-            private_attribute_group,
-        }
-    }
-    pub fn enc(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-    ) -> PcdItemGenericEnc {
-        let enc_metadata_contract_public = self
-            .public_attribute_group
-            .enc_group(process_public_enc_key.clone());
-
-        let enc_role_confidential_attribute_group =
-            self.role_confidential_attribute_group.enc_group();
-
-        let enc_metadata_private = self
-            .private_attribute_group
-            .enc_group(Member_private_enc_key.clone());
-
-        PcdItemGenericEnc::new(
-            self.item
-                .enc(process_public_enc_key, Member_private_enc_key),
-            Some(enc_metadata_contract_public),
-            Some(enc_role_confidential_attribute_group),
-            Some(enc_metadata_private),
-        )
-    }
-    pub fn display_info(&self) {
-        println!("Commit:");
-        println!("Item:");
-        self.item.display_info(); // Affiche les informations de `item`
-
-        println!("Public Attribute Group:");
-        self.public_attribute_group.display_info(); // Affiche les informations de `public_attribute_group`
-
-        println!("Role Confidential Attribute Group:");
-        self.role_confidential_attribute_group.display_info(); // Affiche les informations de `role_confidential_attribute_group`
-
-        println!("Private Attribute Group:");
-        self.private_attribute_group.display_info(); // Affiche les informations de `private_attribute_group`
-    }
-}

src/models/item_deposit.rs

@@ -1,277 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    item::Item, key_encryption::KeyEncryption,
-    pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
-    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
-    pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential,
-    pcd_item_generic_enc::PcdItemGenericEnc,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct DepositPublicAttributeGroup {
-    pub for_sp_address_list: Vec<String>,
-    pub for_address_list: Vec<String>,
-    pub goal_list: Vec<String>,
-    pub provider_type: String,
-    pub ref_item_hash_list: Vec<String>,
-    pub ref_pcd_hash_list: Vec<String>,
-    pub payload_list_public: Vec<String>,
-    pub audit_code_list_public: Vec<String>,
-}
-
-impl DepositPublicAttributeGroup {
-    pub fn new(
-        for_sp_address_list: Vec<String>,
-        for_address_list: Vec<String>,
-        goal_list: Vec<String>,
-        provider_type: String,
-        ref_item_hash_list: Vec<String>,
-        ref_pcd_hash_list: Vec<String>,
-        payload_list_public: Vec<String>,
-        audit_code_list_public: Vec<String>,
-    ) -> Self {
-        DepositPublicAttributeGroup {
-            for_sp_address_list,
-            for_address_list,
-            goal_list,
-            provider_type,
-            ref_item_hash_list,
-            ref_pcd_hash_list,
-            payload_list_public,
-            audit_code_list_public,
-        }
-    }
-    pub fn enc_group(
-        &self,
-        process_public_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePublic> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();
-
-        let for_sp_address_list_enc = PcdItemEncAttributePublic::new(
-            "for_sp_address_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.for_sp_address_list.clone()),
-        );
-        enc_attribute_list.push(for_sp_address_list_enc);
-
-        let for_address_list_enc = PcdItemEncAttributePublic::new(
-            "for_address_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.for_address_list.clone()),
-        );
-        enc_attribute_list.push(for_address_list_enc);
-
-        let goal_list_enc = PcdItemEncAttributePublic::new(
-            "goal_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.goal_list.clone()),
-        );
-        enc_attribute_list.push(goal_list_enc);
-
-        let provider_type_enc = PcdItemEncAttributePublic::new(
-            "provider_type".to_owned(),
-            process_public_enc_key.enc_string(self.provider_type.clone()),
-        );
-        enc_attribute_list.push(provider_type_enc);
-
-        let ref_item_hash_list_enc = PcdItemEncAttributePublic::new(
-            "ref_item_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.ref_item_hash_list.clone()),
-        );
-        enc_attribute_list.push(ref_item_hash_list_enc);
-
-        let ref_pcd_hash_list_enc = PcdItemEncAttributePublic::new(
-            "ref_pcd_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.ref_pcd_hash_list.clone()),
-        );
-        enc_attribute_list.push(ref_pcd_hash_list_enc);
-
-        let payload_list_public_enc = PcdItemEncAttributePublic::new(
-            "payload_list_public".to_owned(),
-            process_public_enc_key.enc_vec_string(self.payload_list_public.clone()),
-        );
-        enc_attribute_list.push(payload_list_public_enc);
-
-        let audit_code_list_public_enc = PcdItemEncAttributePublic::new(
-            "audit_code_list_public".to_owned(),
-            process_public_enc_key.enc_vec_string(self.audit_code_list_public.clone()),
-        );
-        enc_attribute_list.push(audit_code_list_public_enc);
-
-        enc_attribute_list
-    }
-    pub fn display_info(&self) {
-        println!("DepositPublicAttributeGroup:");
-        println!("For SP Address List: {:?}", self.for_sp_address_list);
-        println!("For Address List: {:?}", self.for_address_list);
-        println!("Goal List: {:?}", self.goal_list);
-        println!("Provider Type: {}", self.provider_type);
-        println!("Ref Item Hash List: {:?}", self.ref_item_hash_list);
-        println!("Ref PCD Hash List: {:?}", self.ref_pcd_hash_list);
-        println!("Payload List Public: {:?}", self.payload_list_public);
-        println!("Audit Code List Public: {:?}", self.audit_code_list_public);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct DepositRoleConfidentialAttributeGroup {
-    pub payload_list_confidential: Vec<String>,
-    pub audit_code_list_confidential: Vec<String>,
-}
-
-impl DepositRoleConfidentialAttributeGroup {
-    pub fn new(
-        payload_list_confidential: Vec<String>,
-        audit_code_list_confidential: Vec<String>,
-    ) -> Self {
-        DepositRoleConfidentialAttributeGroup {
-            payload_list_confidential,
-            audit_code_list_confidential,
-        }
-    }
-    pub fn enc_group(&self) -> Vec<PcdItemEncAttributeRoleConfidential> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributeRoleConfidential> = Vec::new();
-
-        let mut payload_list_confidential_key =
-            KeyEncryption::new(Some("payload_list_confidential".to_owned()), None, None);
-
-        if let Ok(_new) = payload_list_confidential_key.key_new_random() {
-            let payload_list_confidential_enc = PcdItemEncAttributeRoleConfidential::new(
-                "payload_list_confidential".to_owned(),
-                payload_list_confidential_key
-                    .enc_vec_string(self.payload_list_confidential.clone()),
-                payload_list_confidential_key,
-            );
-            enc_attribute_list.push(payload_list_confidential_enc);
-        }
-
-        let mut audit_code_list_confidential_key =
-            KeyEncryption::new(Some("audit_code_list_confidential".to_owned()), None, None);
-        if let Ok(_new) = audit_code_list_confidential_key.key_new_random() {
-            let audit_code_list_confidential_enc = PcdItemEncAttributeRoleConfidential::new(
-                "audit_code_list_confidential".to_owned(),
-                audit_code_list_confidential_key
-                    .enc_vec_string(self.audit_code_list_confidential.clone()),
-                audit_code_list_confidential_key,
-            );
-            enc_attribute_list.push(audit_code_list_confidential_enc);
-        }
-
-        return enc_attribute_list;
-    }
-    pub fn display_info(&self) {
-        println!("DepositRoleConfidentialAttributeGroup:");
-        println!(
-            "Confidential Payload List: {:?}",
-            self.payload_list_confidential
-        );
-        println!(
-            "Confidential Audit Code List: {:?}",
-            self.audit_code_list_confidential
-        );
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct DepositPrivateAttributeGroup {
-    pub payload_list_private: Vec<String>,
-    pub audit_code_private: String,
-}
-
-impl DepositPrivateAttributeGroup {
-    pub fn new(payload_list_private: Vec<String>, audit_code_private: String) -> Self {
-        DepositPrivateAttributeGroup {
-            payload_list_private,
-            audit_code_private,
-        }
-    }
-
-    pub fn enc_group(&self, Member_enc_key: KeyEncryption) -> Vec<PcdItemEncAttributePrivate> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();
-
-        let payload_list_private_enc = PcdItemEncAttributePrivate::new(
-            "payload_list_private".to_owned(),
-            Member_enc_key.enc_vec_string(self.payload_list_private.clone()),
-        );
-        enc_attribute_list.push(payload_list_private_enc);
-
-        let audit_code_private_enc = PcdItemEncAttributePrivate::new(
-            "audit_code_private".to_owned(),
-            Member_enc_key.enc_string(self.audit_code_private.clone()),
-        );
-        enc_attribute_list.push(audit_code_private_enc);
-
-        enc_attribute_list
-    }
-    pub fn display_info(&self) {
-        println!("DepositPrivateAttributeGroup:");
-        println!("Private Payload List: {:?}", self.payload_list_private);
-        println!("Private Audit Code: {}", self.audit_code_private);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Deposit {
-    pub item: Item,
-    pub public_attribute_group: DepositPublicAttributeGroup,
-    pub role_confidential_attribute_group: DepositRoleConfidentialAttributeGroup,
-    pub private_attribute_group: DepositPrivateAttributeGroup,
-}
-
-impl Deposit {
-    pub const ITEM_NAME: &'static str = "deposit";
-    pub fn new(
-        mut item: Item,
-        public_attribute_group: DepositPublicAttributeGroup,
-        role_confidential_attribute_group: DepositRoleConfidentialAttributeGroup,
-        private_attribute_group: DepositPrivateAttributeGroup,
-    ) -> Self {
-        item.name = Self::ITEM_NAME.to_string();
-        Deposit {
-            item,
-            public_attribute_group,
-            role_confidential_attribute_group,
-            private_attribute_group,
-        }
-    }
-    pub fn enc(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-    ) -> PcdItemGenericEnc {
-        let enc_metadata_contract_public = self
-            .public_attribute_group
-            .enc_group(process_public_enc_key.clone());
-
-        let enc_role_confidential_attribute_group =
-            self.role_confidential_attribute_group.enc_group();
-
-        let enc_metadata_private = self
-            .private_attribute_group
-            .enc_group(Member_private_enc_key.clone());
-
-        PcdItemGenericEnc::new(
-            self.item
-                .enc(process_public_enc_key, Member_private_enc_key),
-            Some(enc_metadata_contract_public),
-            Some(enc_role_confidential_attribute_group),
-            Some(enc_metadata_private),
-        )
-    }
-    pub fn display_info(&self) {
-        println!("Deposit:");
-        println!("Item:");
-        self.item.display_info(); // Affiche les informations de l'objet `item`
-
-        println!("Public Attribute Group:");
-        self.public_attribute_group.display_info(); // Affiche les informations du groupe d'attributs publics
-
-        println!("Role Confidential Attribute Group:");
-        self.role_confidential_attribute_group.display_info(); // Affiche les informations du groupe d'attributs confidentiels
-
-        println!("Private Attribute Group:");
-        self.private_attribute_group.display_info(); // Affiche les informations du groupe d'attributs privés
-    }
-}

src/models/item_enum.rs

@@ -1,18 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    item_artefact::Artefact, item_commit::Commit, item_deposit::Deposit,
-    item_Member::Member, item_Payments::Payments, item_peer::Peer,
-    item_process::Process,
-};
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum ItemEnum {
-    Process(Process),
-    Peer(Peer),
-    Member(Member),
-    Payments(Payments),
-    Deposit(Deposit),
-    Artefact(Artefact),
-    commit(Commit),
-}

src/models/item_member.rs

@@ -1,374 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    item::Item, key_encryption::KeyEncryption,
-    pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
-    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
-    pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential,
-    pcd_item_generic_enc::PcdItemGenericEnc,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct MemberPublicAttributeGroup {
-    pub sp_address_public: String,
-    pub sp_address_public_sig: String,
-    pub sp_address_revoke_public: String,
-    pub sp_address_revoke_public_sig: String,
-    pub third_sp_address_list_public: Vec<String>,
-    pub data_size_max: i64,
-    pub Payments_method_list_public: Vec<String>,
-    pub succession_process_hash: String,
-}
-
-impl MemberPublicAttributeGroup {
-    pub fn new(
-        sp_address_public: String,
-        sp_address_public_sig: String,
-        sp_address_revoke_public: String,
-        sp_address_revoke_public_sig: String,
-        third_sp_address_list_public: Vec<String>,
-        data_size_max: i64,
-        Payments_method_list_public: Vec<String>,
-        succession_process_hash: String,
-    ) -> Self {
-        MemberPublicAttributeGroup {
-            sp_address_public,
-            sp_address_public_sig,
-            sp_address_revoke_public,
-            sp_address_revoke_public_sig,
-            third_sp_address_list_public,
-            data_size_max,
-            Payments_method_list_public,
-            succession_process_hash,
-        }
-    }
-    pub fn enc_group(
-        &self,
-        process_public_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePublic> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();
-
-        let sp_address_public_enc = PcdItemEncAttributePublic::new(
-            "sp_address_public".to_owned(),
-            process_public_enc_key.enc_string(self.sp_address_public.clone()),
-        );
-        enc_attribute_list.push(sp_address_public_enc);
-
-        let sp_address_public_sig_enc = PcdItemEncAttributePublic::new(
-            "sp_address_public_sig".to_owned(),
-            process_public_enc_key.enc_string(self.sp_address_public_sig.clone()),
-        );
-        enc_attribute_list.push(sp_address_public_sig_enc);
-
-        let sp_address_revoke_public_enc = PcdItemEncAttributePublic::new(
-            "sp_address_revoke_public".to_owned(),
-            process_public_enc_key.enc_string(self.sp_address_revoke_public.clone()),
-        );
-        enc_attribute_list.push(sp_address_revoke_public_enc);
-
-        let sp_address_revoke_public_sig_enc = PcdItemEncAttributePublic::new(
-            "sp_address_revoke_public_sig".to_owned(),
-            process_public_enc_key.enc_string(self.sp_address_revoke_public_sig.clone()),
-        );
-        enc_attribute_list.push(sp_address_revoke_public_sig_enc);
-
-        let third_sp_address_list_public_enc = PcdItemEncAttributePublic::new(
-            "third_sp_address_list_public".to_owned(),
-            process_public_enc_key.enc_vec_string(self.third_sp_address_list_public.clone()),
-        );
-        enc_attribute_list.push(third_sp_address_list_public_enc);
-
-        let data_size_max_enc = PcdItemEncAttributePublic::new(
-            "data_size_max".to_owned(),
-            process_public_enc_key.enc_i64(self.data_size_max),
-        );
-        enc_attribute_list.push(data_size_max_enc);
-
-        let Payments_method_list_public_enc = PcdItemEncAttributePublic::new(
-            "Payments_method_list_public".to_owned(),
-            process_public_enc_key.enc_vec_string(self.Payments_method_list_public.clone()),
-        );
-        enc_attribute_list.push(Payments_method_list_public_enc);
-
-        let succession_process_hash_enc = PcdItemEncAttributePublic::new(
-            "succession_process_hash".to_owned(),
-            process_public_enc_key.enc_string(self.succession_process_hash.clone()),
-        );
-        enc_attribute_list.push(succession_process_hash_enc);
-
-        enc_attribute_list
-    }
-    pub fn display_info(&self) {
-        println!("MemberPublicAttributeGroup:");
-        println!("SP Address Public: {}", self.sp_address_public);
-        println!(
-            "SP Address Public Signature: {}",
-            self.sp_address_public_sig
-        );
-        println!(
-            "SP Address Revoke Public: {}",
-            self.sp_address_revoke_public
-        );
-        println!(
-            "SP Address Revoke Public Signature: {}",
-            self.sp_address_revoke_public_sig
-        );
-        println!(
-            "Third SP Address List Public: {:?}",
-            self.third_sp_address_list_public
-        );
-        println!("Data Size Max: {}", self.data_size_max);
-        println!(
-            "Payments Method List Public: {:?}",
-            self.Payments_method_list_public
-        );
-        println!("Succession Process Hash: {}", self.succession_process_hash);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct MemberRoleConfidentialAttributeGroup {
-    pub Payments_method_list_confidential: Vec<String>,
-    pub id_shard_info: String,
-}
-
-impl MemberRoleConfidentialAttributeGroup {
-    pub fn new(Payments_method_list_confidential: Vec<String>, id_shard_info: String) -> Self {
-        MemberRoleConfidentialAttributeGroup {
-            Payments_method_list_confidential,
-            id_shard_info,
-        }
-    }
-
-    pub fn enc_group(&self) -> Vec<PcdItemEncAttributeRoleConfidential> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributeRoleConfidential> = Vec::new();
-
-        let mut enc_Payments_method_list_confidential_key = KeyEncryption::new(
-            Some("Payments_method_list_confidential".to_owned()),
-            None,
-            None,
-        );
-        if let Ok(_new) = enc_Payments_method_list_confidential_key.key_new_random() {
-            let Payments_method_list_confidential_enc = PcdItemEncAttributeRoleConfidential::new(
-                "Payments_method_list_confidential".to_owned(),
-                enc_Payments_method_list_confidential_key
-                    .enc_vec_string(self.Payments_method_list_confidential.clone()),
-                enc_Payments_method_list_confidential_key,
-            );
-            enc_attribute_list.push(Payments_method_list_confidential_enc);
-        }
-
-        let mut enc_id_shard_info_key =
-            KeyEncryption::new(Some("id_shard_info".to_owned()), None, None);
-
-        if let Ok(_new) = enc_id_shard_info_key.key_new_random() {
-            let id_shard_info_enc = PcdItemEncAttributeRoleConfidential::new(
-                "id_shard_info".to_owned(),
-                enc_id_shard_info_key.enc_string(self.id_shard_info.clone()),
-                enc_id_shard_info_key,
-            );
-            enc_attribute_list.push(id_shard_info_enc);
-        }
-
-        return enc_attribute_list;
-    }
-    pub fn display_info(&self) {
-        println!("MemberRoleConfidentialAttributeGroup:");
-        println!(
-            "Confidential Payments Method List: {:?}",
-            self.Payments_method_list_confidential
-        );
-        println!("ID Shard Info: {}", self.id_shard_info);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct MemberPrivateAttributeGroup {
-    pub Payments_method_list_private: Vec<String>,
-    pub pcd_list: Vec<String>, // Assuming this is a list of strings
-    pub prd_list_list: Vec<String>,
-    pub prd_update_list: Vec<String>,
-    pub prd_response_list: Vec<String>,
-    pub prd_message_list: Vec<String>,
-    pub prd_confirm_list: Vec<String>,
-    pub prd_key_backup_list: Vec<String>,
-    pub prd_key_hello_list: Vec<String>,
-    pub tx_sp_list: Vec<String>,
-}
-
-impl MemberPrivateAttributeGroup {
-    pub fn new(
-        Payments_method_list_private: Vec<String>,
-        pcd_list: Vec<String>,
-        prd_list_list: Vec<String>,
-        prd_update_list: Vec<String>,
-        prd_response_list: Vec<String>,
-        prd_message_list: Vec<String>,
-        prd_confirm_list: Vec<String>,
-        prd_key_backup_list: Vec<String>,
-        prd_key_hello_list: Vec<String>,
-        tx_sp_list: Vec<String>,
-    ) -> Self {
-        MemberPrivateAttributeGroup {
-            Payments_method_list_private,
-            pcd_list,
-            prd_list_list,
-            prd_update_list,
-            prd_response_list,
-            prd_message_list,
-            prd_confirm_list,
-            prd_key_backup_list,
-            prd_key_hello_list,
-            tx_sp_list,
-        }
-    }
-
-    pub fn enc_group(&self, Member_enc_key: KeyEncryption) -> Vec<PcdItemEncAttributePrivate> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();
-
-        let Payments_method_list_private_enc = PcdItemEncAttributePrivate::new(
-            "Payments_method_list_private".to_owned(),
-            Member_enc_key.enc_vec_string(self.Payments_method_list_private.clone()),
-        );
-        enc_attribute_list.push(Payments_method_list_private_enc);
-
-        let pcd_list_enc = PcdItemEncAttributePrivate::new(
-            "pcd_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.pcd_list.clone()),
-        );
-        enc_attribute_list.push(pcd_list_enc);
-
-        let prd_list_list_enc = PcdItemEncAttributePrivate::new(
-            "prd_list_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.prd_list_list.clone()),
-        );
-        enc_attribute_list.push(prd_list_list_enc);
-
-        let prd_update_list_enc = PcdItemEncAttributePrivate::new(
-            "prd_update_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.prd_update_list.clone()),
-        );
-        enc_attribute_list.push(prd_update_list_enc);
-
-        let prd_response_list_enc = PcdItemEncAttributePrivate::new(
-            "prd_response_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.prd_response_list.clone()),
-        );
-        enc_attribute_list.push(prd_response_list_enc);
-
-        let prd_message_list_enc = PcdItemEncAttributePrivate::new(
-            "prd_message_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.prd_message_list.clone()),
-        );
-        enc_attribute_list.push(prd_message_list_enc);
-
-        let prd_confirm_list_enc = PcdItemEncAttributePrivate::new(
-            "prd_confirm_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.prd_confirm_list.clone()),
-        );
-        enc_attribute_list.push(prd_confirm_list_enc);
-
-        let prd_key_backup_list_enc = PcdItemEncAttributePrivate::new(
-            "prd_key_backup_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.prd_key_backup_list.clone()),
-        );
-        enc_attribute_list.push(prd_key_backup_list_enc);
-
-        let prd_key_hello_list_enc = PcdItemEncAttributePrivate::new(
-            "prd_key_hello_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.prd_key_hello_list.clone()),
-        );
-        enc_attribute_list.push(prd_key_hello_list_enc);
-
-        let tx_sp_list_enc = PcdItemEncAttributePrivate::new(
-            "tx_sp_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.tx_sp_list.clone()),
-        );
-        enc_attribute_list.push(tx_sp_list_enc);
-
-        enc_attribute_list
-    }
-    pub fn display_info(&self) {
-        println!("MemberPrivateAttributeGroup:");
-        println!(
-            "Private Payments Method List: {:?}",
-            self.Payments_method_list_private
-        );
-        println!("PCD List: {:?}", self.pcd_list);
-        println!("PRD List List: {:?}", self.prd_list_list);
-        println!("PRD Update List: {:?}", self.prd_update_list);
-        println!("PRD Response List: {:?}", self.prd_response_list);
-        println!("PRD `Envelope`  List: {:?}", self.prd_message_list);
-        println!("PRD Confirm List: {:?}", self.prd_confirm_list);
-        println!("PRD Key Backup List: {:?}", self.prd_key_backup_list);
-        println!("PRD Key Hello List: {:?}", self.prd_key_hello_list);
-        println!("TX SP List: {:?}", self.tx_sp_list);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Member {
-    pub item: Item,
-    pub public_attribute_group: MemberPublicAttributeGroup,
-    pub role_confidential_attribute_group: MemberRoleConfidentialAttributeGroup,
-    pub private_attribute_group: MemberPrivateAttributeGroup,
-}
-
-impl Member {
-    pub const ITEM_NAME: &'static str = "Member";
-    pub fn new(
-        mut item: Item,
-        public_attribute_group: MemberPublicAttributeGroup,
-        role_confidential_attribute_group: MemberRoleConfidentialAttributeGroup,
-        private_attribute_group: MemberPrivateAttributeGroup,
-    ) -> Self {
-        item.name = Self::ITEM_NAME.to_string();
-        Member {
-            item,
-            public_attribute_group,
-            role_confidential_attribute_group,
-            private_attribute_group,
-        }
-    }
-    pub fn enc(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-    ) -> PcdItemGenericEnc {
-        let enc_metadata_contract_public = self
-            .public_attribute_group
-            .enc_group(process_public_enc_key.clone());
-
-        let enc_role_confidential_attribute_group =
-            self.role_confidential_attribute_group.enc_group();
-
-        let enc_metadata_private = self
-            .private_attribute_group
-            .enc_group(Member_private_enc_key.clone());
-
-        PcdItemGenericEnc::new(
-            self.item
-                .enc(process_public_enc_key, Member_private_enc_key),
-            Some(enc_metadata_contract_public),
-            Some(enc_role_confidential_attribute_group),
-            Some(enc_metadata_private),
-        )
-    }
-    pub fn display_info(&self) {
-        println!("Member:");
-        println!("Item:");
-        self.item.display_info(); // Affiche les informations de l'objet `item`
-
-        println!("Member Public Attribute Group:");
-        self.public_attribute_group.display_info(); // Affiche les informations du groupe d'attributs publics
-
-        println!("Member Role Confidential Attribute Group:");
-        self.role_confidential_attribute_group.display_info(); // Affiche les informations du groupe d'attributs confidentiels
-
-        println!("Member Private Attribute Group:");
-        self.private_attribute_group.display_info(); // Affiche les informations du groupe d'attributs privés
-    }
-}

src/models/item_payment.rs

@@ -1,315 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    item::Item, key_encryption::KeyEncryption,
-    pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
-    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
-    pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential,
-    pcd_item_generic_enc::PcdItemGenericEnc,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PaymentsPublicAttributeGroup {
-    pub for_sp_address_list: Vec<String>,
-    pub goal_list: Vec<String>,
-    pub provider_type: String,
-    pub commit_pcd_hash_list: Vec<String>,
-    pub order_pcd_hash_list: Vec<String>,
-    pub invoice_pcd_hash_list: Vec<String>,
-    pub pay_pcd_hash_list: Vec<String>,
-    pub ref_item_hash_list: Vec<String>,
-    pub ref_pcd_hash_list: Vec<String>,
-    pub payload_list_public: Vec<String>,
-    pub audit_code_list_public: Vec<String>,
-}
-
-impl PaymentsPublicAttributeGroup {
-    pub fn new(
-        for_sp_address_list: Vec<String>,
-        goal_list: Vec<String>,
-        provider_type: String,
-        commit_pcd_hash_list: Vec<String>,
-        order_pcd_hash_list: Vec<String>,
-        invoice_pcd_hash_list: Vec<String>,
-        pay_pcd_hash_list: Vec<String>,
-        ref_item_hash_list: Vec<String>,
-        ref_pcd_hash_list: Vec<String>,
-        payload_list_public: Vec<String>,
-        audit_code_list_public: Vec<String>,
-    ) -> Self {
-        PaymentsPublicAttributeGroup {
-            for_sp_address_list,
-            goal_list,
-            provider_type,
-            commit_pcd_hash_list,
-            order_pcd_hash_list,
-            invoice_pcd_hash_list,
-            pay_pcd_hash_list,
-            ref_item_hash_list,
-            ref_pcd_hash_list,
-            payload_list_public,
-            audit_code_list_public,
-        }
-    }
-    pub fn enc_group(
-        &self,
-        process_public_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePublic> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();
-
-        let for_sp_address_list_enc = PcdItemEncAttributePublic::new(
-            "for_sp_address_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.for_sp_address_list.clone()),
-        );
-        enc_attribute_list.push(for_sp_address_list_enc);
-
-        let goal_list_enc = PcdItemEncAttributePublic::new(
-            "goal_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.goal_list.clone()),
-        );
-        enc_attribute_list.push(goal_list_enc);
-
-        let provider_type_enc = PcdItemEncAttributePublic::new(
-            "provider_type".to_owned(),
-            process_public_enc_key.enc_string(self.provider_type.clone()),
-        );
-        enc_attribute_list.push(provider_type_enc);
-
-        let commit_pcd_hash_list_enc = PcdItemEncAttributePublic::new(
-            "commit_pcd_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.commit_pcd_hash_list.clone()),
-        );
-        enc_attribute_list.push(commit_pcd_hash_list_enc);
-
-        let order_pcd_hash_list_enc = PcdItemEncAttributePublic::new(
-            "order_pcd_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.order_pcd_hash_list.clone()),
-        );
-        enc_attribute_list.push(order_pcd_hash_list_enc);
-
-        let invoice_pcd_hash_list_enc = PcdItemEncAttributePublic::new(
-            "invoice_pcd_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.invoice_pcd_hash_list.clone()),
-        );
-        enc_attribute_list.push(invoice_pcd_hash_list_enc);
-
-        let pay_pcd_hash_list_enc = PcdItemEncAttributePublic::new(
-            "pay_pcd_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.pay_pcd_hash_list.clone()),
-        );
-        enc_attribute_list.push(pay_pcd_hash_list_enc);
-
-        let ref_item_hash_list_enc = PcdItemEncAttributePublic::new(
-            "ref_item_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.ref_item_hash_list.clone()),
-        );
-        enc_attribute_list.push(ref_item_hash_list_enc);
-
-        let ref_pcd_hash_list_enc = PcdItemEncAttributePublic::new(
-            "ref_pcd_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.ref_pcd_hash_list.clone()),
-        );
-        enc_attribute_list.push(ref_pcd_hash_list_enc);
-
-        let payload_list_public_enc = PcdItemEncAttributePublic::new(
-            "payload_list_public".to_owned(),
-            process_public_enc_key.enc_vec_string(self.payload_list_public.clone()),
-        );
-        enc_attribute_list.push(payload_list_public_enc);
-
-        let audit_code_list_public_enc = PcdItemEncAttributePublic::new(
-            "audit_code_list_public".to_owned(),
-            process_public_enc_key.enc_vec_string(self.audit_code_list_public.clone()),
-        );
-        enc_attribute_list.push(audit_code_list_public_enc);
-
-        enc_attribute_list
-    }
-    pub fn display_info(&self) {
-        println!("PaymentsPublicAttributeGroup:");
-        println!("For SP Address List: {:?}", self.for_sp_address_list);
-        println!("Goal List: {:?}", self.goal_list);
-        println!("Provider Type: {}", self.provider_type);
-        println!(
-            "commit PCD Hash List: {:?}",
-            self.commit_pcd_hash_list
-        );
-        println!("Order PCD Hash List: {:?}", self.order_pcd_hash_list);
-        println!("Invoice PCD Hash List: {:?}", self.invoice_pcd_hash_list);
-        println!("Pay PCD Hash List: {:?}", self.pay_pcd_hash_list);
-        println!("Ref Item Hash List: {:?}", self.ref_item_hash_list);
-        println!("Ref PCD Hash List: {:?}", self.ref_pcd_hash_list);
-        println!("Payload List Public: {:?}", self.payload_list_public);
-        println!("Audit Code List Public: {:?}", self.audit_code_list_public);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PaymentsRoleConfidentialAttributeGroup {
-    pub payload_list_confidential: Vec<String>,
-    pub audit_code_list_confidential: Vec<String>,
-}
-
-impl PaymentsRoleConfidentialAttributeGroup {
-    pub fn new(
-        payload_list_confidential: Vec<String>,
-        audit_code_list_confidential: Vec<String>,
-    ) -> Self {
-        PaymentsRoleConfidentialAttributeGroup {
-            payload_list_confidential,
-            audit_code_list_confidential,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("PaymentsRoleConfidentialAttributeGroup:");
-        println!(
-            "Confidential Payload List: {:?}",
-            self.payload_list_confidential
-        );
-        println!(
-            "Confidential Audit Code List: {:?}",
-            self.audit_code_list_confidential
-        );
-    }
-
-    pub fn enc_group(&self) -> Vec<PcdItemEncAttributeRoleConfidential> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributeRoleConfidential> = Vec::new();
-
-        // tag_list
-        let mut enc_payload_list_confidential =
-            KeyEncryption::new(Some("payload_list_confidential".to_owned()), None, None);
-        if let Ok(_new) = enc_payload_list_confidential.key_new_random() {
-            let enc_attribute_payload_list_confidential = PcdItemEncAttributeRoleConfidential::new(
-                "payload_list_confidential".to_owned(),
-                enc_payload_list_confidential
-                    .enc_vec_string(self.payload_list_confidential.clone()),
-                enc_payload_list_confidential,
-            );
-            enc_attribute_list.push(enc_attribute_payload_list_confidential);
-        }
-
-        // zone_listaudit_code_list_confidential
-        let mut enc_attribute_audit_code_list_confidential_key =
-            KeyEncryption::new(Some("zone_list".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_audit_code_list_confidential_key.key_new_random() {
-            let enc_attribute_audit_code_list_confidential =
-                PcdItemEncAttributeRoleConfidential::new(
-                    "zone_list".to_owned(),
-                    enc_attribute_audit_code_list_confidential_key
-                        .enc_vec_string(self.audit_code_list_confidential.clone()),
-                    enc_attribute_audit_code_list_confidential_key,
-                );
-            enc_attribute_list.push(enc_attribute_audit_code_list_confidential);
-        }
-
-        return enc_attribute_list;
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PaymentsPrivateAttributeGroup {
-    pub payload_list_private: Vec<String>,
-    pub audit_code_private: String,
-}
-
-impl PaymentsPrivateAttributeGroup {
-    pub fn new(payload_list_private: Vec<String>, audit_code_private: String) -> Self {
-        PaymentsPrivateAttributeGroup {
-            payload_list_private,
-            audit_code_private,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("PaymentsRoleConfidentialAttributeGroup:");
-        println!("Confidential Payload List: {:?}", self.payload_list_private);
-        println!(
-            "Confidential Audit Code List: {:?}",
-            self.audit_code_private
-        );
-    }
-
-    pub fn enc_group(&self, Member_enc_key: KeyEncryption) -> Vec<PcdItemEncAttributePrivate> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();
-
-        let payload_list_private_enc = PcdItemEncAttributePrivate::new(
-            "payload_list".to_owned(),
-            Member_enc_key.enc_vec_string(self.payload_list_private.clone()),
-        );
-        enc_attribute_list.push(payload_list_private_enc);
-
-        let audit_code_private_enc = PcdItemEncAttributePrivate::new(
-            "audit_code_private".to_owned(),
-            Member_enc_key.enc_string(self.audit_code_private.clone()),
-        );
-        enc_attribute_list.push(audit_code_private_enc);
-
-        enc_attribute_list
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Payments {
-    pub item: Item,
-    pub public_attribute_group: PaymentsPublicAttributeGroup,
-    pub role_confidential_attribute_group: PaymentsRoleConfidentialAttributeGroup,
-    pub private_attribute_group: PaymentsPrivateAttributeGroup,
-}
-
-impl Payments {
-    pub const ITEM_NAME: &'static str = "Payments";
-    pub fn new(
-        mut item: Item,
-        public_attribute_group: PaymentsPublicAttributeGroup,
-        role_confidential_attribute_group: PaymentsRoleConfidentialAttributeGroup,
-        private_attribute_group: PaymentsPrivateAttributeGroup,
-    ) -> Self {
-        item.name = Self::ITEM_NAME.to_string();
-        Payments {
-            item,
-            public_attribute_group,
-            role_confidential_attribute_group,
-            private_attribute_group,
-        }
-    }
-    pub fn enc(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-    ) -> PcdItemGenericEnc {
-        let enc_metadata_contract_public = self
-            .public_attribute_group
-            .enc_group(process_public_enc_key.clone());
-
-        let enc_role_confidential_attribute_group =
-            self.role_confidential_attribute_group.enc_group();
-
-        let enc_metadata_private = self
-            .private_attribute_group
-            .enc_group(Member_private_enc_key.clone());
-
-        PcdItemGenericEnc::new(
-            self.item
-                .enc(process_public_enc_key, Member_private_enc_key),
-            Some(enc_metadata_contract_public),
-            Some(enc_role_confidential_attribute_group),
-            Some(enc_metadata_private),
-        )
-    }
-    pub fn display_info(&self) {
-        println!("Payments:");
-        println!("Item:");
-        self.item.display_info(); // Affiche les informations de l'objet `item`
-
-        println!("Public Attribute Group:");
-        self.public_attribute_group.display_info(); // Affiche les informations du groupe d'attributs publics
-
-        println!("Role Confidential Attribute Group:");
-        self.role_confidential_attribute_group.display_info(); // Affiche les informations du groupe d'attributs confidentiels
-
-        println!("Private Attribute Group:");
-        self.private_attribute_group.display_info(); // Affiche les informations du groupe d'attributs privés
-    }
-}

src/models/item_peer.rs

@@ -1,233 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    item::Item, key_encryption::KeyEncryption,
-    pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
-    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
-    pcd_item_generic_enc::PcdItemGenericEnc,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PeerPublicAttributeGroup {
-    pub sp_address: String,
-    pub domain: String,
-    pub ip_address: String,
-    pub pow_difficulty: u32,
-    pub pow_pattern: String,
-    pub pow_prefix: String,
-    pub data_size_max: i64,
-    pub timestamp_delay_max: u64,
-    pub daily_hash_list: Vec<String>,
-    pub daily_sp_tx_mine_list: Vec<String>,
-    pub daily_sp_tx_mine_reward_list: Vec<String>,
-}
-
-impl PeerPublicAttributeGroup {
-    pub fn new(
-        sp_address: String,
-        domain: String,
-        ip_address: String,
-        pow_difficulty: u32,
-        pow_pattern: String,
-        pow_prefix: String,
-        data_size_max: i64,
-        timestamp_delay_max: u64,
-        daily_hash_list: Vec<String>,
-        daily_sp_tx_mine_list: Vec<String>,
-        daily_sp_tx_mine_reward_list: Vec<String>,
-    ) -> Self {
-        PeerPublicAttributeGroup {
-            sp_address,
-            domain,
-            ip_address,
-            pow_difficulty,
-            pow_pattern,
-            pow_prefix,
-            data_size_max,
-            timestamp_delay_max,
-            daily_hash_list,
-            daily_sp_tx_mine_list,
-            daily_sp_tx_mine_reward_list,
-        }
-    }
-    pub fn enc_group(
-        &self,
-        process_public_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePublic> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();
-
-        let sp_address_enc = PcdItemEncAttributePublic::new(
-            "sp_address".to_owned(),
-            process_public_enc_key.enc_string(self.sp_address.clone()),
-        );
-        enc_attribute_list.push(sp_address_enc);
-
-        let domain_enc = PcdItemEncAttributePublic::new(
-            "domain".to_owned(),
-            process_public_enc_key.enc_string(self.domain.clone()),
-        );
-        enc_attribute_list.push(domain_enc);
-
-        let ip_address_enc = PcdItemEncAttributePublic::new(
-            "ip_address".to_owned(),
-            process_public_enc_key.enc_string(self.ip_address.clone()),
-        );
-        enc_attribute_list.push(ip_address_enc);
-
-        let pow_difficulty_enc = PcdItemEncAttributePublic::new(
-            "pow_difficulty".to_owned(),
-            process_public_enc_key.enc_u32(self.pow_difficulty),
-        );
-        enc_attribute_list.push(pow_difficulty_enc);
-
-        let pow_pattern_enc = PcdItemEncAttributePublic::new(
-            "pow_pattern".to_owned(),
-            process_public_enc_key.enc_string(self.pow_pattern.clone()),
-        );
-        enc_attribute_list.push(pow_pattern_enc);
-
-        let pow_prefix_enc = PcdItemEncAttributePublic::new(
-            "pow_prefix".to_owned(),
-            process_public_enc_key.enc_string(self.pow_prefix.clone()),
-        );
-        enc_attribute_list.push(pow_prefix_enc);
-
-        let data_size_max_enc = PcdItemEncAttributePublic::new(
-            "data_size_max".to_owned(),
-            process_public_enc_key.enc_i64(self.data_size_max),
-        );
-        enc_attribute_list.push(data_size_max_enc);
-
-        let timestamp_delay_max_enc = PcdItemEncAttributePublic::new(
-            "timestamp_delay_max".to_owned(),
-            process_public_enc_key.enc_u64(self.timestamp_delay_max),
-        );
-        enc_attribute_list.push(timestamp_delay_max_enc);
-
-        let daily_hash_list_enc = PcdItemEncAttributePublic::new(
-            "daily_hash_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.daily_hash_list.clone()),
-        );
-        enc_attribute_list.push(daily_hash_list_enc);
-
-        let daily_sp_tx_mine_list_enc = PcdItemEncAttributePublic::new(
-            "daily_sp_tx_mine_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.daily_sp_tx_mine_list.clone()),
-        );
-        enc_attribute_list.push(daily_sp_tx_mine_list_enc);
-
-        let daily_sp_tx_mine_reward_list_enc = PcdItemEncAttributePublic::new(
-            "daily_sp_tx_mine_reward_list".to_owned(),
-            process_public_enc_key.enc_vec_string(self.daily_sp_tx_mine_reward_list.clone()),
-        );
-        enc_attribute_list.push(daily_sp_tx_mine_reward_list_enc);
-
-        enc_attribute_list
-    }
-    pub fn display_info(&self) {
-        println!("PeerPublicAttributeGroup:");
-        println!("SP Address: {}", self.sp_address);
-        println!("Domain: {}", self.domain);
-        println!("IP Address: {}", self.ip_address);
-        println!("PoW Difficulty: {}", self.pow_difficulty);
-        println!("PoW Pattern: {}", self.pow_pattern);
-        println!("PoW Prefix: {}", self.pow_prefix);
-        println!("Data Size Max: {}", self.data_size_max);
-        println!("Timestamp Delay Max: {}", self.timestamp_delay_max);
-        println!("Daily Hash List: {:?}", self.daily_hash_list);
-        println!("Daily SP Tx Mine List: {:?}", self.daily_sp_tx_mine_list);
-        println!(
-            "Daily SP Tx Mine Reward List: {:?}",
-            self.daily_sp_tx_mine_reward_list
-        );
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PeerPrivateAttributeGroup {
-    pub config: String, // Assuming it's a simple string for now
-}
-
-impl PeerPrivateAttributeGroup {
-    pub fn new(config: String) -> Self {
-        PeerPrivateAttributeGroup { config }
-    }
-    pub fn display_info(&self) {
-        println!("PeerPrivateAttributeGroup:");
-        println!("Config: {}", self.config);
-    }
-
-    pub fn enc_group(&self, Member_enc_key: KeyEncryption) -> Vec<PcdItemEncAttributePrivate> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();
-
-        let config_enc = PcdItemEncAttributePrivate::new(
-            "config".to_owned(),
-            Member_enc_key.enc_string(self.config.clone()),
-        );
-        enc_attribute_list.push(config_enc);
-
-        enc_attribute_list
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Peer {
-    pub item: Item,
-    pub layer_list: Vec<String>,
-    pub public_attribute_group: PeerPublicAttributeGroup,
-    pub private_attribute_group: PeerPrivateAttributeGroup,
-}
-
-impl Peer {
-    pub const ITEM_NAME: &'static str = "peer";
-    pub fn new(
-        mut item: Item,
-        layer_list: Vec<String>,
-        public_attribute_group: PeerPublicAttributeGroup,
-        private_attribute_group: PeerPrivateAttributeGroup,
-    ) -> Self {
-        item.name = Self::ITEM_NAME.to_string();
-        Peer {
-            item,
-            layer_list,
-            public_attribute_group,
-            private_attribute_group,
-        }
-    }
-    pub fn enc(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-    ) -> PcdItemGenericEnc {
-        let enc_metadata_contract_public = self
-            .public_attribute_group
-            .enc_group(process_public_enc_key.clone());
-
-        let enc_metadata_private = self
-            .private_attribute_group
-            .enc_group(Member_private_enc_key.clone());
-
-        PcdItemGenericEnc::new(
-            self.item
-                .enc(process_public_enc_key, Member_private_enc_key),
-            Some(enc_metadata_contract_public),
-            None,
-            Some(enc_metadata_private),
-        )
-    }
-    pub fn display_info(&self) {
-        println!("Peer:");
-        println!("Item:");
-        self.item.display_info(); // Affiche les informations de l'objet `item`
-
-        println!("Layer List: {:?}", self.layer_list);
-
-        println!("Peer Public Attribute Group:");
-        self.public_attribute_group.display_info(); // Affiche les informations du groupe d'attributs publics
-
-        println!("Peer Private Attribute Group:");
-        self.private_attribute_group.display_info(); // Affiche les informations du groupe d'attributs privés
-    }
-}

src/models/item_process.rs

@@ -1,86 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    item::Item, key_encryption::KeyEncryption,
-    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
-    pcd_item_generic_enc::PcdItemGenericEnc, roles_group::RolesGroup,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct ProcessPublicAttributeGroup {
-    // Fields for public attributes
-    // Example field
-    pub roles_group: RolesGroup,
-}
-
-impl ProcessPublicAttributeGroup {
-    pub fn new(roles_group: RolesGroup) -> Self {
-        ProcessPublicAttributeGroup { roles_group }
-    }
-    pub fn display_info(&self) {
-        println!("ProcessPublicAttributeGroup:");
-        println!("Roles Group:");
-        self.roles_group.display_info(); // Display information for `roles_group`
-    }
-    pub fn enc_group(
-        &self,
-        process_public_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePublic> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();
-        let roles_group_enc = PcdItemEncAttributePublic::new(
-            "roles_group".to_owned(),
-            process_public_enc_key.enc_roles_group(self.roles_group.clone()),
-        );
-        enc_attribute_list.push(roles_group_enc);
-        enc_attribute_list
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Process {
-    pub item: Item,
-    pub item_process_public_attribute_group: ProcessPublicAttributeGroup,
-}
-
-impl Process {
-    pub const ITEM_NAME: &'static str = "process";
-    pub fn new(
-        mut item: Item,
-        item_process_public_attribute_group: ProcessPublicAttributeGroup,
-    ) -> Self {
-        item.name = Self::ITEM_NAME.to_string();
-        Process {
-            item,
-            item_process_public_attribute_group,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("Process:");
-        println!("Item:");
-        self.item.display_info(); // Display information for `item`
-
-        println!("Process Public Attribute Group:");
-        self.item_process_public_attribute_group.display_info(); // Display information for `item_process_public_attribute_group`
-    }
-    pub fn enc(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-    ) -> PcdItemGenericEnc {
-        let enc_metadata_contract_public = self
-            .item_process_public_attribute_group
-            .enc_group(process_public_enc_key.clone());
-
-        PcdItemGenericEnc::new(
-            self.item
-                .enc(process_public_enc_key, Member_private_enc_key),
-            Some(enc_metadata_contract_public),
-            None,
-            None,
-        )
-    }
-
-    // Additional methods for Process can be added here
-}

src/models/key_encryption.rs

@@ -1,248 +0,0 @@
-use rand::RngCore;
-
-use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
-
-use core::result::Result as CoreResult;
-
-use super::metadata::Amount;
-use super::metadata::Number;
-use super::request_pcd::Pcd;
-use super::request_prd_confirm::PrdConfirm;
-use super::request_prd_key_backup::PrdKeyBackup;
-use super::request_prd_key_hello::PrdKeyHello;
-use super::request_prd_list::PrdList;
-use super::request_prd_message::PrdMessage;
-use super::request_prd_response::PrdResponse;
-use super::request_prd_update::PrdUpdate;
-use super::roles_group::RolesGroup;
-
-use aes::cipher::consts::U32;
-use aes::cipher::generic_array::GenericArray;
-use aes_gcm::{
-    aead::{AeadInPlace, KeyInit},
-    Aes256Gcm,
-};
-use rand::rngs::OsRng;
-
-pub struct Aes256GcmIv96Bit {
-    pub key: GenericArray<u8, U32>,
-}
-
-impl Aes256GcmIv96Bit {
-    pub fn new() -> Self {
-        let mut key_bytes = [0u8; 32];
-        OsRng.fill_bytes(&mut key_bytes);
-        let key = GenericArray::from_slice(&key_bytes);
-        Aes256GcmIv96Bit { key: key.clone() }
-    }
-
-    pub fn encrypt(&self, data: &[u8]) -> CoreResult<Vec<u8>, aes_gcm::Error> {
-        let cipher = Aes256Gcm::new(&self.key);
-        let mut nonce = [0u8; 12];
-        OsRng.fill_bytes(&mut nonce);
-
-        let mut buffer = data.to_vec();
-        cipher.encrypt_in_place(GenericArray::from_slice(&nonce), b"", &mut buffer)?;
-
-        Ok([nonce.to_vec(), buffer].concat())
-    }
-
-    pub fn decrypt(&self, data: &[u8]) -> CoreResult<Vec<u8>, aes_gcm::Error> {
-        if data.len() < 12 {
-            return Err(aes_gcm::Error); // Remplacer par une erreur appropriée
-        }
-
-        let (nonce, encrypted_data) = data.split_at(12);
-        let mut buffer = encrypted_data.to_vec();
-        let cipher = Aes256Gcm::new(&self.key);
-        cipher.decrypt_in_place(GenericArray::from_slice(nonce), b"", &mut buffer)?;
-
-        Ok(buffer)
-    }
-    pub fn encrypt_string(&self, data: &str) -> CoreResult<String, String> {
-        match self.encrypt(data.as_bytes()) {
-            Ok(encrypted_data) => Ok(base64::encode(encrypted_data)),
-            Err(_) => Err("Erreur de chiffrement".to_string()),
-        }
-    }
-
-    pub fn decrypt_string(&self, data: &str) -> CoreResult<String, String> {
-        let decoded_data = match base64::decode(data) {
-            Ok(data) => data,
-            Err(_) => return Err("Erreur de décodage Base64".to_string()),
-        };
-
-        match self.decrypt(&decoded_data) {
-            Ok(decrypted_data) => match String::from_utf8(decrypted_data) {
-                Ok(text) => Ok(text),
-                Err(_) => Err("Erreur de conversion UTF-8".to_string()),
-            },
-            Err(_) => Err("Erreur de déchiffrement".to_string()),
-        }
-    }
-    pub fn export_key(&self) -> String {
-        base64::encode(&self.key)
-    }
-
-    pub fn import_key(encoded_key: &str) -> CoreResult<Self, String> {
-        match base64::decode(encoded_key) {
-            Ok(decoded_key) => {
-                if decoded_key.len() == 32 {
-                    let key = GenericArray::from_slice(&decoded_key);
-                    Ok(Aes256GcmIv96Bit { key: key.clone() })
-                } else {
-                    Err("La taille de la clé n'est pas valide".to_string())
-                }
-            }
-            Err(_) => Err("Échec du décodage de la clé".to_string()),
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct KeyEncryption {
-    pub attribute_name: Option<String>,
-    pub key: Option<String>,
-    pub algorithm: Option<String>,
-}
-
-impl KeyEncryption {
-    pub fn new(
-        attribute_name: Option<String>,
-        key: Option<String>,
-        algorithm: Option<String>,
-    ) -> Self {
-        KeyEncryption {
-            attribute_name,
-            key,
-            algorithm,
-        }
-    }
-    pub fn key_new_random(&mut self) -> CoreResult<String, String> {
-        let new_key = Aes256GcmIv96Bit::new().export_key();
-        self.key = Some(new_key.clone());
-        Ok(new_key)
-    }
-    pub fn encode(&self, data: String) -> CoreResult<String, String> {
-        if let Some(ref key) = self.key {
-            let decoded_key = Aes256GcmIv96Bit::import_key(key)?;
-            let encrypted_data = decoded_key.encrypt_string(&data)?;
-            Ok(encrypted_data)
-        } else {
-            Err("Aucune clé n'est définie".to_string())
-        }
-    }
-
-    pub fn decode(&self, encrypted_data: String) -> CoreResult<String, String> {
-        if let Some(ref key) = self.key {
-            let decoded_key = Aes256GcmIv96Bit::import_key(key)?;
-            let decrypted_data = decoded_key.decrypt_string(&encrypted_data)?;
-            Ok(decrypted_data)
-        } else {
-            Err("Aucune clé n'est définie".to_string())
-        }
-    }
-
-    pub fn display_info(&self) {
-        println!("KeyEncryption:");
-        println!("Attribute Name: {:?}", self.attribute_name);
-        println!("Key: {:?}", self.key);
-        println!("Algorithm: {:?}", self.algorithm);
-    }
-    pub fn enc(&self, data: Value) -> String {
-        let data_string = serde_json::to_string(&data).unwrap_or_else(|_| "".to_string());
-        self.encode(data_string).unwrap_or_else(|_| "".to_string())
-    }
-    pub fn enc_string(&self, data: String) -> String {
-        self.enc(Value::String(data))
-    }
-    pub fn enc_i64(&self, data: i64) -> String {
-        self.enc(Value::Number(data.into()))
-    }
-    pub fn enc_u64(&self, data: u64) -> String {
-        self.enc(Value::Number(data.into()))
-    }
-    pub fn enc_u32(&self, data: u32) -> String {
-        self.enc(Value::Number(data.into()))
-    }
-    pub fn enc_vec_string(&self, list: Vec<String>) -> String {
-        self.enc(Value::Array(list.into_iter().map(Value::String).collect()))
-    }
-    pub fn enc_vec_key_encryption(&self, list: Vec<KeyEncryption>) -> String {
-        // Utilisez `serde_json::to_value` pour convertir chaque `KeyEncryption` en `Value`
-        let json_list: Vec<Value> = list
-            .into_iter()
-            .map(|key_enc| serde_json::to_value(key_enc).unwrap_or_else(|_| json!({})))
-            .collect();
-
-        self.enc(Value::Array(json_list))
-    }
-    pub fn enc_amount(&self, amount: Amount) -> String {
-        let amount_value = serde_json::to_value(amount).unwrap_or_else(|_| json!({}));
-        self.enc(amount_value)
-    }
-    pub fn enc_number(&self, number: Number) -> String {
-        let number_value = serde_json::to_value(number).unwrap_or_else(|_| json!({}));
-        self.enc(number_value)
-    }
-    pub fn enc_bool(&self, data: bool) -> String {
-        self.enc(Value::Bool(data))
-    }
-    pub fn enc_vec_u32(&self, list: Vec<u32>) -> String {
-        let number_list: Vec<Value> = list
-            .into_iter()
-            .map(|num| Value::Number(serde_json::Number::from(num)))
-            .collect();
-
-        self.enc(Value::Array(number_list))
-    }
-
-    pub fn enc_vec_i64(&self, list: Vec<i64>) -> String {
-        let number_list: Vec<Value> = list
-            .into_iter()
-            .map(|num| Value::Number(serde_json::Number::from(num)))
-            .collect();
-
-        self.enc(Value::Array(number_list))
-    }
-    pub fn enc_vec_bool(&self, list: Vec<bool>) -> String {
-        self.enc(Value::Array(list.into_iter().map(Value::Bool).collect()))
-    }
-    pub fn enc_pcd(&self, pcd: Pcd) -> String {
-        let pcd_value = serde_json::to_value(pcd).unwrap_or_else(|_| json!({}));
-        self.enc(pcd_value)
-    }
-    pub fn enc_prd_update(&self, prd: PrdUpdate) -> String {
-        let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({}));
-        self.enc(prd_value)
-    }
-    pub fn enc_prd_list(&self, pcd: PrdList) -> String {
-        let prd_value = serde_json::to_value(pcd).unwrap_or_else(|_| json!({}));
-        self.enc(prd_value)
-    }
-    pub fn enc_prd_response(&self, prd: PrdResponse) -> String {
-        let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({}));
-        self.enc(prd_value)
-    }
-    pub fn enc_prd_confirm(&self, prd: PrdConfirm) -> String {
-        let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({}));
-        self.enc(prd_value)
-    }
-    pub fn enc_prd_message(&self, prd: PrdMessage) -> String {
-        let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({}));
-        self.enc(prd_value)
-    }
-    pub fn enc_prd_key_backup(&self, prd: PrdKeyBackup) -> String {
-        let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({}));
-        self.enc(prd_value)
-    }
-    pub fn enc_prd_key_hello(&self, prd: PrdKeyHello) -> String {
-        let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({}));
-        self.enc(prd_value)
-    }
-    pub fn enc_roles_group(&self, roles: RolesGroup) -> String {
-        let roles_value = serde_json::to_value(roles).unwrap_or_else(|_| json!({}));
-        self.enc(roles_value)
-    }
-}

src/models/message.rs

@@ -1,108 +0,0 @@
-use chrono::Utc;
-
-use sha2::{Digest, Sha256};
-
-use serde::{Deserialize, Serialize};
-
-use super::shared_peer::Peer;
-use super::shared_process::Process;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Pow {
-    pub data_hash: String,
-    timestamp: Option<u64>,
-    pub nonce: Option<u64>,
-    pub pathern: String,
-    pub difficulty: usize,
-}
-
-impl Pow {
-    pub fn new(data_hash: String, pathern: String, difficulty: usize) -> Self {
-        let mut pow = Pow {
-            data_hash,
-            nonce: None,
-            timestamp: None,
-            pathern,
-            difficulty,
-        };
-        pow.find();
-        return pow;
-    }
-    pub fn display_info(&self) {
-        println!("Pow:");
-        println!("Data Hash: {}", self.data_hash);
-        println!("Timestamp: {}", self.timestamp.as_ref().unwrap_or(&0));
-        println!("Nonce: {}", self.nonce.as_ref().unwrap_or(&0));
-        println!("Pathern: {}", self.pathern);
-        println!("Difficulty: {}", self.difficulty);
-    }
-    pub fn find(&mut self) {
-        let mut nonce: u64 = 0;
-        loop {
-            // Mise à jour du timestamp à chaque itération
-            let current_timestamp = Utc::now().timestamp() as u64;
-            self.timestamp = Some(current_timestamp);
-
-            // Créer une chaîne avec le hash actuel, le timestamp et le nonce
-            let data: String = format!("{}{}{}", self.data_hash, current_timestamp, nonce);
-
-            // Calculer le hash SHA-256
-            let mut hasher = Sha256::new();
-            hasher.update(data);
-            let result = hasher.finalize();
-            let hash_str: String = format!("{:x}", result);
-
-            // Vérifier si le hash correspond au motif de difficulté
-            if hash_str.starts_with(&"0".repeat(self.difficulty as usize)) {
-                self.nonce = Some(nonce);
-                break;
-            }
-
-            nonce += 1;
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct `Envelope`  {
-    pub shared_peer_list: Vec<Peer>,
-    pub shared_process_list: Vec<Process>,
-    pub faucet_sp_address: String,
-    pub pow: Pow, // Assuming Pow is a predefined struct
-}
-
-impl `Envelope`  {
-    pub fn new(
-        shared_peer_list: Vec<Peer>,
-        shared_process_list: Vec<Process>,
-        faucet_sp_address: String,
-        pow_data_hash: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> Self {
-        let pow: Pow = Pow::new(pow_data_hash, pow_pathern, pow_difficulty);
-        `Envelope`  {
-            shared_peer_list,
-            shared_process_list,
-            faucet_sp_address,
-            pow,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("Message:");
-        println!("Shared Peer List:");
-        for shared_peer in &self.shared_peer_list {
-            shared_peer.display_info(); // Assuming Peers has a display_info method
-        }
-
-        println!("Shared Process List:");
-        for shared_process in &self.shared_process_list {
-            shared_process.display_info(); // Assuming Process has a display_info method
-        }
-
-        println!("Faucet SP Address: {}", self.faucet_sp_address);
-        println!("PoW:");
-        self.pow.display_info(); // Assuming Pow has a display_info method
-    }
-}

src/models/message_client.rs

@@ -1,51 +0,0 @@
-use super::{message::Message, shared_peer::Peer, shared_process::Process};
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct `Envelope` Client {
-    pub `Envelope` : `Envelope` , // Assuming `Envelope`  is a predefined struct
-    pub request_enc: String,
-    pub request_hash: String,
-}
-
-impl `Envelope` Client {
-    pub fn new(
-        request_enc: String,
-        request_hash: String,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> Self {
-        let pow_data_hash = request_hash;
-        let `Envelope` : `Envelope`  = `Envelope` ::new(
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-            pow_data_hash.clone(),
-            pow_pathern,
-            pow_difficulty,
-        );
-        `Envelope` Client {
-            `Envelope` ,
-            request_enc,
-            request_hash: pow_data_hash,
-        }
-    }
-    pub fn send(&self) {
-        for shared_peer in &self.`Envelope`.shared_peer_list {
-            shared_peer.send_message_client(self.clone()); // Assuming Peers has a send method
-        }
-    }
-    pub fn display_info(&self) {
-        println!("EnvelopeClient:");
-        println!("Message:");
-        self.`Envelope`.display_info(); // Assuming `Envelope`  has a display_info method
-        println!("Envelope hash: {}", self.request_hash);
-
-        println!("Request Enc: {}", self.request_enc);
-    }
-}

src/models/message_connect.rs

@@ -1,19 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::message::Message;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct `Envelope` Connect {
-    pub `Envelope` : `Envelope` , // Assuming `Envelope`  is a predefined struct
-}
-
-impl `Envelope` Connect {
-    pub fn new(message: `Envelope` ) -> Self {
-        `Envelope` Connect { `Envelope`  }
-    }
-    pub fn display_info(&self) {
-        println!("EnvelopeConnect:");
-        println!("Message:");
-        self.`Envelope`.display_info(); // Assuming `Envelope`  has a display_info method
-    }
-}

src/models/metadata.rs

@@ -1,145 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::key_encryption::KeyEncryption;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Number {
-    pub fixed_state: bool,
-    pub number: i32,
-    pub number_unit: String,
-}
-
-impl Number {
-    // Constructor for Number struct
-    pub fn new(fixed_state: bool, number: i32, number_unit: String) -> Self {
-        Number {
-            fixed_state,
-            number,
-            number_unit,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("Number:");
-        println!("Fixed State: {}", self.fixed_state);
-        println!("Number: {}", self.number);
-        println!("Number Unit: {}", self.number_unit);
-    }
-
-    // Additional methods for Number can be added here.
-}
-
-// Struct for representing an amount with various attributes.
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Amount {
-    pub timestamp: u64,
-    pub change_source_list: Vec<String>,
-    pub amount_cent: i64,
-    pub amount_unit: String,
-    pub amount_unit_ref: String, // This can be a reference to an external unit system.
-}
-
-impl Amount {
-    // Constructor for Amount struct
-    pub fn new(
-        timestamp: u64,
-        change_source_list: Vec<String>,
-        amount_cent: i64,
-        amount_unit: String,
-        amount_unit_ref: String,
-    ) -> Self {
-        Amount {
-            timestamp,
-            change_source_list,
-            amount_cent,
-            amount_unit,
-            amount_unit_ref,
-        }
-    }
-    pub fn display(&self) -> String {
-        format!(
-            "Amount: {} {} {} {} {}",
-            self.timestamp,
-            self.change_source_list.join(","),
-            self.amount_cent,
-            self.amount_unit,
-            self.amount_unit_ref
-        )
-    }
-    pub fn display_info(&self) {
-        println!("Amount:");
-        println!("Timestamp: {}", self.timestamp);
-        println!("Change Source List: {:?}", self.change_source_list);
-        println!("Amount cent: {}", self.amount_cent);
-        println!("Amount Unit: {}", self.amount_unit);
-        println!("Amount Unit Reference: {}", self.amount_unit_ref);
-    }
-    // Additional methods for Amount can be added here.
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct MetaData {
-    pub tag_list: Vec<String>,
-    pub zone_list: Vec<String>,
-    pub label_list: Vec<String>,
-    pub ref_list: Vec<String>,
-    pub data_list: Vec<String>,
-    pub amount: Amount,
-    pub number: Number,
-    pub render_template_list: Vec<String>,
-    pub legal_text_list: Vec<String>,
-    pub key_list: Vec<KeyEncryption>,
-}
-
-impl MetaData {
-    pub fn new(
-        tag_list: Vec<String>,
-        zone_list: Vec<String>,
-        label_list: Vec<String>,
-        ref_list: Vec<String>,
-        data_list: Vec<String>,
-        amount: Amount,
-        number: Number,
-        render_template_list: Vec<String>,
-        legal_text_list: Vec<String>,
-        key_list: Vec<KeyEncryption>,
-    ) -> Self {
-        MetaData {
-            tag_list,
-            zone_list,
-            label_list,
-            ref_list,
-            data_list,
-            amount,
-            number,
-            render_template_list,
-            legal_text_list,
-            key_list,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("MetaData:");
-        println!("Tag List: {:?}", self.tag_list);
-        println!("Zone List: {:?}", self.zone_list);
-        println!("Label List: {:?}", self.label_list);
-        println!("Ref List: {:?}", self.ref_list);
-        println!("Data List: {:?}", self.data_list);
-
-        println!("Amount:");
-        self.amount.display_info(); // Assuming Amount has a display_info method
-
-        println!("Number:");
-        self.number.display_info(); // Assuming Number has a display_info method
-
-        println!("Render Template List: {:?}", self.render_template_list);
-        println!("Legal Text List: {:?}", self.legal_text_list);
-
-        println!("Key List:");
-        for key in &self.key_list {
-            key.display_info(); // Assuming KeyEncryption has a display_info method
-        }
-    }
-
-    // Methods for manipulating MetaData can be added here.
-}

src/models/metadata_contract_public.rs

@@ -1,143 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    key_encryption::KeyEncryption, metadata::MetaData,
-    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct MetadataContractPublic {
-    pub meta_data: MetaData,
-}
-
-impl MetadataContractPublic {
-    pub fn new(meta_data: MetaData) -> Self {
-        MetadataContractPublic { meta_data }
-    }
-    pub fn display_info(&self) {
-        println!("MetadataContractPublic:");
-        // Assuming MetaData has a display_info method
-        self.meta_data.display_info(); // Display information for `meta_data`
-    }
-    pub fn enc_list(
-        &self,
-        process_public_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePublic> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();
-
-        let enc_attribute_tag_list_key = KeyEncryption::new(
-            Some("tag_list".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_tag_list = PcdItemEncAttributePublic::new(
-            "tag_list".to_owned(),
-            enc_attribute_tag_list_key.enc_vec_string(self.meta_data.tag_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_tag_list);
-
-        let enc_attribute_zone_list_key = KeyEncryption::new(
-            Some("zone_list".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_zone_list = PcdItemEncAttributePublic::new(
-            "zone_list".to_owned(),
-            enc_attribute_zone_list_key.enc_vec_string(self.meta_data.zone_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_zone_list);
-
-        let enc_attribute_label_list_key = KeyEncryption::new(
-            Some("label_list".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_label_list = PcdItemEncAttributePublic::new(
-            "label_list".to_owned(),
-            enc_attribute_label_list_key.enc_vec_string(self.meta_data.label_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_label_list);
-
-        let enc_attribute_ref_list_key = KeyEncryption::new(
-            Some("ref_list".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_ref_list = PcdItemEncAttributePublic::new(
-            "ref_list".to_owned(),
-            enc_attribute_ref_list_key.enc_vec_string(self.meta_data.ref_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_ref_list);
-
-        let enc_attribute_data_list_key = KeyEncryption::new(
-            Some("data_list".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_data_list = PcdItemEncAttributePublic::new(
-            "data_list".to_owned(),
-            enc_attribute_data_list_key.enc_vec_string(self.meta_data.data_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_data_list);
-
-        let enc_attribute_amount_key = KeyEncryption::new(
-            Some("amount".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_amount = PcdItemEncAttributePublic::new(
-            "amount".to_owned(),
-            enc_attribute_amount_key.enc_amount(self.meta_data.amount.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_amount);
-
-        let enc_attribute_number_key = KeyEncryption::new(
-            Some("number".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_number = PcdItemEncAttributePublic::new(
-            "number".to_owned(),
-            enc_attribute_number_key.enc_number(self.meta_data.number.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_number);
-
-        let enc_attribute_render_template_list_key = KeyEncryption::new(
-            Some("render_template_list".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_render_template_list = PcdItemEncAttributePublic::new(
-            "render_template_list".to_owned(),
-            enc_attribute_render_template_list_key
-                .enc_vec_string(self.meta_data.render_template_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_render_template_list);
-
-        let enc_attribute_legal_text_list_key = KeyEncryption::new(
-            Some("legal_text_list".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_legal_text_list = PcdItemEncAttributePublic::new(
-            "legal_text_list".to_owned(),
-            enc_attribute_legal_text_list_key
-                .enc_vec_string(self.meta_data.legal_text_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_legal_text_list);
-
-        let enc_attribute_key_list_key = KeyEncryption::new(
-            Some("key_list".to_owned()),
-            process_public_enc_key.key.clone(),
-            process_public_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_key_list = PcdItemEncAttributePublic::new(
-            "key_list".to_owned(),
-            enc_attribute_key_list_key.enc_vec_key_encryption(self.meta_data.key_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_key_list);
-
-        return enc_attribute_list;
-    }
-}

src/models/metadata_private.rs

@@ -1,143 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    key_encryption::KeyEncryption, metadata::MetaData,
-    pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct MetadataPrivate {
-    pub meta_data: MetaData,
-}
-
-impl MetadataPrivate {
-    pub fn new(meta_data: MetaData) -> Self {
-        MetadataPrivate { meta_data }
-    }
-    pub fn display_info(&self) {
-        println!("MetadataPrivate:");
-        // Assuming MetaData has a display_info method
-        self.meta_data.display_info(); // Display information for `meta_data`
-    }
-    pub fn enc_list(
-        &self,
-        Member_private_enc_key: KeyEncryption,
-    ) -> Vec<PcdItemEncAttributePrivate> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();
-
-        let enc_attribute_tag_list_key = KeyEncryption::new(
-            Some("tag_list".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_tag_list = PcdItemEncAttributePrivate::new(
-            "tag_list".to_owned(),
-            enc_attribute_tag_list_key.enc_vec_string(self.meta_data.tag_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_tag_list);
-
-        let enc_attribute_zone_list_key = KeyEncryption::new(
-            Some("zone_list".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_zone_list = PcdItemEncAttributePrivate::new(
-            "zone_list".to_owned(),
-            enc_attribute_zone_list_key.enc_vec_string(self.meta_data.zone_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_zone_list);
-
-        let enc_attribute_label_list_key = KeyEncryption::new(
-            Some("label_list".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_label_list = PcdItemEncAttributePrivate::new(
-            "label_list".to_owned(),
-            enc_attribute_label_list_key.enc_vec_string(self.meta_data.label_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_label_list);
-
-        let enc_attribute_ref_list_key = KeyEncryption::new(
-            Some("ref_list".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_ref_list = PcdItemEncAttributePrivate::new(
-            "ref_list".to_owned(),
-            enc_attribute_ref_list_key.enc_vec_string(self.meta_data.ref_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_ref_list);
-
-        let enc_attribute_data_list_key = KeyEncryption::new(
-            Some("data_list".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_data_list = PcdItemEncAttributePrivate::new(
-            "data_list".to_owned(),
-            enc_attribute_data_list_key.enc_vec_string(self.meta_data.data_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_data_list);
-
-        let enc_attribute_amount_key = KeyEncryption::new(
-            Some("amount".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_amount = PcdItemEncAttributePrivate::new(
-            "amount".to_owned(),
-            enc_attribute_amount_key.enc_amount(self.meta_data.amount.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_amount);
-
-        let enc_attribute_number_key = KeyEncryption::new(
-            Some("number".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_number = PcdItemEncAttributePrivate::new(
-            "number".to_owned(),
-            enc_attribute_number_key.enc_number(self.meta_data.number.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_number);
-
-        let enc_attribute_render_template_list_key = KeyEncryption::new(
-            Some("render_template_list".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_render_template_list = PcdItemEncAttributePrivate::new(
-            "render_template_list".to_owned(),
-            enc_attribute_render_template_list_key
-                .enc_vec_string(self.meta_data.render_template_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_render_template_list);
-
-        let enc_attribute_legal_text_list_key = KeyEncryption::new(
-            Some("legal_text_list".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_legal_text_list = PcdItemEncAttributePrivate::new(
-            "legal_text_list".to_owned(),
-            enc_attribute_legal_text_list_key
-                .enc_vec_string(self.meta_data.legal_text_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_legal_text_list);
-
-        let enc_attribute_key_list_key = KeyEncryption::new(
-            Some("key_list".to_owned()),
-            Member_private_enc_key.key.clone(),
-            Member_private_enc_key.algorithm.clone(),
-        );
-        let enc_attribute_key_list = PcdItemEncAttributePrivate::new(
-            "key_list".to_owned(),
-            enc_attribute_key_list_key.enc_vec_key_encryption(self.meta_data.key_list.clone()),
-        );
-        enc_attribute_list.push(enc_attribute_key_list);
-
-        return enc_attribute_list;
-    }
-}

src/models/metadata_role_confidential.rs

@@ -1,152 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    key_encryption::KeyEncryption, metadata::MetaData,
-    pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct MetadataRoleConfidential {
-    pub meta_data: MetaData,
-}
-
-impl MetadataRoleConfidential {
-    pub fn new(meta_data: MetaData) -> Self {
-        MetadataRoleConfidential { meta_data }
-    }
-    pub fn display_info(&self) {
-        println!("MetadataRoleConfidential:");
-        // Assuming MetaData has a display_info method
-        self.meta_data.display_info(); // Display information for `meta_data`
-    }
-    pub fn enc_list(&self) -> Vec<PcdItemEncAttributeRoleConfidential> {
-        let mut enc_attribute_list: Vec<PcdItemEncAttributeRoleConfidential> = Vec::new();
-
-        // tag_list
-        let mut enc_attribute_tag_list_key =
-            KeyEncryption::new(Some("tag_list".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_tag_list_key.key_new_random() {
-            let enc_attribute_tag_list = PcdItemEncAttributeRoleConfidential::new(
-                "tag_list".to_owned(),
-                enc_attribute_tag_list_key.enc_vec_string(self.meta_data.tag_list.clone()),
-                enc_attribute_tag_list_key,
-            );
-            enc_attribute_list.push(enc_attribute_tag_list);
-        }
-
-        // zone_list
-        let mut enc_attribute_zone_list_key =
-            KeyEncryption::new(Some("zone_list".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_zone_list_key.key_new_random() {
-            let enc_attribute_zone_list = PcdItemEncAttributeRoleConfidential::new(
-                "zone_list".to_owned(),
-                enc_attribute_zone_list_key.enc_vec_string(self.meta_data.zone_list.clone()),
-                enc_attribute_zone_list_key,
-            );
-            enc_attribute_list.push(enc_attribute_zone_list);
-        }
-
-        // label_list
-        let mut enc_attribute_label_list_key =
-            KeyEncryption::new(Some("label_list".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_label_list_key.key_new_random() {
-            let enc_attribute_label_list = PcdItemEncAttributeRoleConfidential::new(
-                "label_list".to_owned(),
-                enc_attribute_label_list_key.enc_vec_string(self.meta_data.label_list.clone()),
-                enc_attribute_label_list_key,
-            );
-            enc_attribute_list.push(enc_attribute_label_list);
-        }
-
-        // ref_list
-        let mut enc_attribute_ref_list_key =
-            KeyEncryption::new(Some("ref_list".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_ref_list_key.key_new_random() {
-            let enc_attribute_ref_list = PcdItemEncAttributeRoleConfidential::new(
-                "ref_list".to_owned(),
-                enc_attribute_ref_list_key.enc_vec_string(self.meta_data.ref_list.clone()),
-                enc_attribute_ref_list_key,
-            );
-            enc_attribute_list.push(enc_attribute_ref_list);
-        }
-
-        // data_list
-        let mut enc_attribute_data_list_key =
-            KeyEncryption::new(Some("data_list".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_data_list_key.key_new_random() {
-            let enc_attribute_data_list = PcdItemEncAttributeRoleConfidential::new(
-                "data_list".to_owned(),
-                enc_attribute_data_list_key.enc_vec_string(self.meta_data.data_list.clone()),
-                enc_attribute_data_list_key,
-            );
-            enc_attribute_list.push(enc_attribute_data_list);
-        }
-
-        // amount
-        let mut enc_attribute_amount_key =
-            KeyEncryption::new(Some("amount".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_amount_key.key_new_random() {
-            let enc_attribute_amount = PcdItemEncAttributeRoleConfidential::new(
-                "amount".to_owned(),
-                enc_attribute_amount_key.enc_amount(self.meta_data.amount.clone()),
-                enc_attribute_amount_key,
-            );
-            enc_attribute_list.push(enc_attribute_amount);
-        }
-
-        // number
-        let mut enc_attribute_number_key =
-            KeyEncryption::new(Some("number".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_number_key.key_new_random() {
-            let enc_attribute_number = PcdItemEncAttributeRoleConfidential::new(
-                "number".to_owned(),
-                enc_attribute_number_key.enc_number(self.meta_data.number.clone()),
-                enc_attribute_number_key,
-            );
-            enc_attribute_list.push(enc_attribute_number);
-        }
-
-        // render_template_list
-        let mut enc_attribute_render_template_list_key =
-            KeyEncryption::new(Some("render_template_list".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_render_template_list_key.key_new_random() {
-            let enc_attribute_render_template_list = PcdItemEncAttributeRoleConfidential::new(
-                "render_template_list".to_owned(),
-                enc_attribute_render_template_list_key
-                    .enc_vec_string(self.meta_data.render_template_list.clone()),
-                enc_attribute_render_template_list_key,
-            );
-            enc_attribute_list.push(enc_attribute_render_template_list);
-        }
-
-        // legal_text_list
-        let mut enc_attribute_legal_text_list_key =
-            KeyEncryption::new(Some("legal_text_list".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_legal_text_list_key.key_new_random() {
-            let enc_attribute_legal_text_list = PcdItemEncAttributeRoleConfidential::new(
-                "legal_text_list".to_owned(),
-                enc_attribute_legal_text_list_key
-                    .enc_vec_string(self.meta_data.legal_text_list.clone()),
-                enc_attribute_legal_text_list_key,
-            );
-            enc_attribute_list.push(enc_attribute_legal_text_list);
-        }
-
-        // key_list
-        let mut enc_attribute_key_list_key =
-            KeyEncryption::new(Some("key_list".to_owned()), None, None);
-        if let Ok(_new) = enc_attribute_key_list_key.key_new_random() {
-            let enc_attribute_key_list = PcdItemEncAttributeRoleConfidential::new(
-                "key_list".to_owned(),
-                enc_attribute_key_list_key.enc_vec_key_encryption(self.meta_data.key_list.clone()),
-                enc_attribute_key_list_key,
-            );
-            enc_attribute_list.push(enc_attribute_key_list);
-        }
-
-        return enc_attribute_list;
-    }
-
-    // Additional
-}

src/models/mod.rs

@@ -1,54 +0,0 @@
-pub mod commit_method;
-pub mod condition_cap;
-pub mod condition_commit;
-pub mod condition_deposit;
-pub mod condition_orchestration;
-pub mod condition_Payments;
-pub mod condition_prd_address_set;
-pub mod condition_publish;
-pub mod deposit_method;
-pub mod item;
-pub mod item_artefact;
-pub mod item_commit;
-pub mod item_deposit;
-pub mod item_enum;
-pub mod item_Member;
-pub mod item_Payments;
-pub mod item_peer;
-pub mod item_process;
-pub mod key_encryption;
-pub mod `Envelope` ;
-pub mod `Envelope` _client;
-pub mod `Envelope` _connect;
-pub mod metadata;
-pub mod metadata_contract_public;
-pub mod metadata_private;
-pub mod metadata_role_confidential;
-pub mod pagination;
-pub mod Payments_method;
-pub mod pcd_item_enc;
-pub mod pcd_item_enc_attribute_private;
-pub mod pcd_item_enc_attribute_public;
-pub mod pcd_item_enc_attribute_role_confidential;
-pub mod pcd_item_generic_enc;
-pub mod request;
-pub mod request_pcd;
-pub mod request_prd;
-pub mod request_prd_confirm;
-pub mod request_prd_key_backup;
-pub mod request_prd_key_hello;
-pub mod request_prd_list;
-pub mod request_prd_message;
-pub mod request_prd_response;
-pub mod request_prd_update;
-pub mod role;
-pub mod role_artefact;
-pub mod role_commit;
-pub mod role_deposit;
-pub mod role_Member;
-pub mod role_Payments;
-pub mod role_peer;
-pub mod role_process;
-pub mod roles_group;
-pub mod shared_peer;
-pub mod shared_process;

src/models/pagination.rs

@@ -1,25 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Pagination {
-    pub start: usize,
-    pub number: usize,
-    pub page_index: usize,
-}
-
-impl Pagination {
-    pub fn new(start: usize, number: usize, page_index: usize) -> Self {
-        Pagination {
-            start,
-            number,
-            page_index,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("Pagination:");
-        println!("Start: {}", self.start);
-        println!("Number: {}", self.number);
-        println!("Page Index: {}", self.page_index);
-    }
-}

src/models/payment_method.rs

@@ -1,8 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PaymentsMethod {
-    pub method: String,
-}
-impl PaymentsMethod {}

src/models/pcd_item_enc.rs

@@ -1,63 +0,0 @@
-use std::hash::Hash;
-
-use serde::{Deserialize, Serialize};
-
-use super::{
-    pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
-    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
-    pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PcdItemEnc {
-    pub version: i64,
-    pub item_type: String,
-    pub name: String,
-    pub pagination_number_per_pcd: u32,
-    pub pcd_item_enc_attribute_public_list: Vec<PcdItemEncAttributePublic>,
-    pub pcd_item_enc_attribute_role_confidential_list: Vec<PcdItemEncAttributeRoleConfidential>,
-    pub pcd_item_enc_attribute_private_list: Vec<PcdItemEncAttributePrivate>,
-}
-
-impl PcdItemEnc {
-    pub fn new(
-        version: i64,
-        item_type: String,
-        name: String,
-        pagination_number_per_pcd: u32,
-        pcd_item_enc_attribute_public_list: Vec<PcdItemEncAttributePublic>,
-        pcd_item_enc_attribute_role_confidential_list: Vec<PcdItemEncAttributeRoleConfidential>,
-        pcd_item_enc_attribute_private_list: Vec<PcdItemEncAttributePrivate>,
-    ) -> Self {
-        PcdItemEnc {
-            version,
-            item_type,
-            name,
-            pagination_number_per_pcd,
-            pcd_item_enc_attribute_public_list,
-            pcd_item_enc_attribute_role_confidential_list,
-            pcd_item_enc_attribute_private_list,
-        }
-    }
-
-    pub fn display_info(&self) {
-        println!("PcdItemEnc:");
-        println!("Public Attributes:");
-        for attr in &self.pcd_item_enc_attribute_public_list {
-            attr.display_info();
-        }
-
-        println!("Role Confidential Attributes:");
-        for attr in &self.pcd_item_enc_attribute_role_confidential_list {
-            attr.display_info();
-        }
-
-        println!("Private Attributes:");
-        for attr in &self.pcd_item_enc_attribute_private_list {
-            attr.display_info();
-        }
-    }
-
-    // Additional methods for PcdItemEnc can be added here
-}

src/models/pcd_item_enc_attribute_private.rs

@@ -1,27 +0,0 @@
-use std::hash::Hash;
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PcdItemEncAttributePrivate {
-    pub attribute_name: String,
-    pub data_enc: String, // Assuming the encrypted data is represented as a String
-}
-
-impl PcdItemEncAttributePrivate {
-    pub fn new(attribute_name: String, data_enc: String) -> Self {
-        PcdItemEncAttributePrivate {
-            attribute_name,
-            data_enc,
-        }
-    }
-    // Method to display information
-    pub fn display_info(&self) {
-        println!("PcdItemEncAttributePrivate:");
-        println!("Attribute Name: {}", self.attribute_name);
-        println!("Data Enc: {}", self.data_enc);
-    }
-
-    // Additional methods for PcdItemEncAttributePrivate can be added here
-}

src/models/pcd_item_enc_attribute_public.rs

@@ -1,25 +0,0 @@
-use std::hash::Hash;
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PcdItemEncAttributePublic {
-    pub attribute_name: String,
-    pub data_enc: String, // Assuming the encrypted data is represented as a String
-}
-impl PcdItemEncAttributePublic {
-    pub fn new(attribute_name: String, data_enc: String) -> Self {
-        PcdItemEncAttributePublic {
-            attribute_name,
-            data_enc,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("PcdItemEncAttributePublic:");
-        println!("Attribute Name: {}", self.attribute_name);
-        println!("Data Enc: {}", self.data_enc);
-    }
-
-    // Additional methods for PcdItemEncAttributePublic can be added here
-}

src/models/pcd_item_enc_attribute_role_confidential.rs

@@ -1,29 +0,0 @@
-use std::hash::Hash;
-
-use serde::{Deserialize, Serialize};
-
-use super::key_encryption::KeyEncryption;
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PcdItemEncAttributeRoleConfidential {
-    pub attribute_name: String,
-    pub data_enc: String, // Assuming the encrypted data is represented as a String
-    pub key: KeyEncryption, // Assuming the encrypted data is represented as a String
-}
-
-impl PcdItemEncAttributeRoleConfidential {
-    pub fn new(attribute_name: String, data_enc: String, key: KeyEncryption) -> Self {
-        PcdItemEncAttributeRoleConfidential {
-            attribute_name,
-            data_enc,
-            key,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("PcdItemEncAttributeRoleConfidential:");
-        println!("Attribute Name: {}", self.attribute_name);
-        println!("Data Enc: {}", self.data_enc);
-        self.key.display_info();
-    }
-}

src/models/pcd_item_generic_enc.rs

@@ -1,63 +0,0 @@
-use std::hash::Hash;
-
-use serde::{Deserialize, Serialize};
-
-use super::{
-    pcd_item_enc::PcdItemEnc, pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
-    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
-    pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PcdItemGenericEnc {
-    pub item_enc: PcdItemEnc,
-    pub pcd_item_enc_attribute_public_list: Option<Vec<PcdItemEncAttributePublic>>,
-    pub pcd_item_enc_attribute_role_confidential_list:
-        Option<Vec<PcdItemEncAttributeRoleConfidential>>,
-    pub pcd_item_enc_attribute_private_list: Option<Vec<PcdItemEncAttributePrivate>>,
-}
-
-impl PcdItemGenericEnc {
-    pub fn new(
-        item_enc: PcdItemEnc,
-        pcd_item_enc_attribute_public_list: Option<Vec<PcdItemEncAttributePublic>>,
-        pcd_item_enc_attribute_role_confidential_list: Option<
-            Vec<PcdItemEncAttributeRoleConfidential>,
-        >,
-        pcd_item_enc_attribute_private_list: Option<Vec<PcdItemEncAttributePrivate>>,
-    ) -> Self {
-        PcdItemGenericEnc {
-            item_enc,
-            pcd_item_enc_attribute_public_list,
-            pcd_item_enc_attribute_role_confidential_list,
-            pcd_item_enc_attribute_private_list,
-        }
-    }
-
-    pub fn display_info(&self) {
-        println!("PcdItemEnc:");
-        println!("Public Attributes:");
-        for attr in &self.pcd_item_enc_attribute_public_list {
-            for attr_sub in attr {
-                attr_sub.display_info();
-            }
-        }
-
-        println!("Role Confidential Attributes:");
-        for attr in &self.pcd_item_enc_attribute_role_confidential_list {
-            for attr_sub in attr {
-                attr_sub.display_info();
-            }
-        }
-
-        println!("Private Attributes:");
-        for attr in &self.pcd_item_enc_attribute_private_list {
-            for attr_sub in attr {
-                attr_sub.display_info();
-            }
-        }
-    }
-
-    // Additional methods for PcdItemEnc can be added here
-}

src/models/request.rs

@@ -1,46 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Request {
-    pub item_name: Option<String>,
-    pub request_type: String, // `type` is a reserved keyword in Rust, renamed to `request_type`
-    pub version: i64,
-    pub process_hash: String,
-    pub pcd_reference_hash: Option<String>,
-    pub item_reference_hash: Option<String>,
-}
-
-impl Request {
-    pub fn new(
-        item_name: Option<String>,
-        request_type: String,
-        version: i64,
-        process_hash: String,
-        pcd_reference_hash: Option<String>,
-        item_reference_hash: Option<String>,
-    ) -> Self {
-        let req = Request {
-            item_name,
-            request_type,
-            version,
-            process_hash,
-            pcd_reference_hash,
-            item_reference_hash,
-        };
-        return req;
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!(
-            "Item Name: {}, Request Type: {}, Version: {}, Process Hash: {}, PCD Reference Hash: {}, Item Reference Hash: {}",
-            self.item_name.as_ref().unwrap_or(&"None".to_string()),
-            self.request_type,
-            self.version,
-            self.process_hash,
-            self.pcd_reference_hash.as_ref().unwrap_or(&"None".to_string()),
-            self.item_reference_hash.as_ref().unwrap_or(&"None".to_string()),
-        )
-    }
-}

src/models/request_pcd.rs

@@ -1,143 +0,0 @@
-use std::{
-    collections::hash_map::DefaultHasher,
-    hash::{Hash, Hasher},
-};
-
-use serde::{Deserialize, Serialize};
-
-use super::{
-    item_enum::ItemEnum, key_encryption::KeyEncryption, `Envelope` _client::EnvelopeClient,
-    pagination::Pagination, pcd_item_generic_enc::PcdItemGenericEnc, request::Request,
-    shared_peer::Peer, shared_process::Process,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Pcd {
-    pub request: Request, // Assuming Request is a predefined struct
-    pub item_list: Vec<PcdItemGenericEnc>,
-    pub pagination: Pagination, // Assuming Pagination is a predefined struct
-}
-
-impl Pcd {
-    pub const TYPE: &'static str = "pcd";
-    pub fn new(
-        request_item_name: Option<String>,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        item_list: Vec<ItemEnum>,
-        pagination: Pagination,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-    ) -> Self {
-        let request = Request::new(
-            request_item_name,
-            Self::TYPE.to_string(),
-            request_version,
-            request_process_hash,
-            request_pcd_reference_hash,
-            request_item_reference_hash,
-        );
-
-        // TODO: encrypt item_list
-        let mut item_enc_list: Vec<PcdItemGenericEnc> = Vec::new();
-
-        item_list.iter().for_each(|item| match item {
-            ItemEnum::Process(item_process) => {
-                let item_enc = item_process.enc(
-                    process_public_enc_key.clone(),
-                    Member_private_enc_key.clone(),
-                );
-                item_enc_list.push(item_enc);
-            }
-            ItemEnum::Member(item_Member) => {
-                let item_enc = item_Member.enc(
-                    process_public_enc_key.clone(),
-                    Member_private_enc_key.clone(),
-                );
-                item_enc_list.push(item_enc);
-            }
-            ItemEnum::Artefact(item_artefact) => {
-                let item_enc = item_artefact.enc(
-                    process_public_enc_key.clone(),
-                    Member_private_enc_key.clone(),
-                );
-                item_enc_list.push(item_enc);
-            }
-            ItemEnum::Peer(item_peer) => {
-                let item_enc = item_peer.enc(
-                    process_public_enc_key.clone(),
-                    Member_private_enc_key.clone(),
-                );
-                item_enc_list.push(item_enc);
-            }
-            ItemEnum::Payments(item_Payments) => {
-                let item_enc = item_Payments.enc(
-                    process_public_enc_key.clone(),
-                    Member_private_enc_key.clone(),
-                );
-                item_enc_list.push(item_enc);
-            }
-            ItemEnum::Deposit(item_deposit) => {
-                let item_enc = item_deposit.enc(
-                    process_public_enc_key.clone(),
-                    Member_private_enc_key.clone(),
-                );
-                item_enc_list.push(item_enc);
-            }
-            ItemEnum::commit(item_commit) => {
-                let item_enc = item_commit.enc(
-                    process_public_enc_key.clone(),
-                    Member_private_enc_key.clone(),
-                );
-                item_enc_list.push(item_enc);
-            }
-        });
-
-        Pcd {
-            request,
-            item_list: item_enc_list,
-            pagination,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("Pcd:");
-        println!("Request:");
-        self.request.display_info();
-
-        println!("Item List:");
-        for item in &self.item_list {
-            item.display_info();
-        }
-
-        println!("Pagination:");
-        self.pagination.display_info();
-    }
-
-    pub fn to_message(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> `Envelope` Client {
-        let mut hasher: DefaultHasher = DefaultHasher::new();
-        self.hash(&mut hasher);
-        let request_hash = hasher.finish().to_string();
-        let request_enc: String = process_public_enc_key.enc_pcd(self.clone()).to_string();
-
-        `Envelope` Client::new(
-            request_enc,
-            request_hash,
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-            pow_pathern,
-            pow_difficulty,
-        )
-    }
-}

src/models/request_prd.rs

@@ -1,108 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::hash::Hash;
-
-use super::{key_encryption::KeyEncryption, request::Request};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct KeyRoleConfidential {
-    pub attribute_name: String,
-    pub key: KeyEncryption,
-    pub algorithm_name: String,
-}
-
-impl KeyRoleConfidential {
-    pub fn new(attribute_name: String, key: KeyEncryption, algorithm_name: String) -> Self {
-        KeyRoleConfidential {
-            attribute_name,
-            key,
-            algorithm_name,
-        }
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!(
-            "Attribute Name: {}, Key: {:?}, Algorithm: {}",
-            self.attribute_name,
-            self.key, // Utilise {:?} si KeyEncryption implémente Debug
-            self.algorithm_name
-        )
-    }
-
-    // Additional methods for KeyRoleConfidential can be added here
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Prd {
-    pub request: Request, // Assuming Request is a predefined struct
-    pub pcd_keys_role_confidential_list_confidential: String,
-    pub `Envelope` _public: Option<String>,
-    pub `Envelope` _confidential: Option<String>,
-    pub `Envelope` _private: Option<String>,
-    pub sp_address_to: String,
-    pub sp_address_from: String,
-    pub sp_address_reply: String,
-    pub timestamp_declared: u64, // Assuming a Unix timestamp
-    pub role_name_from: String,
-    pub role_name_to: String,
-}
-
-impl Prd {
-    pub const TYPE: &'static str = "prd";
-    pub fn new(
-        request_item_name: Option<String>,
-        request_type: String,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        pcd_keys_role_confidential_list_confidential: String,
-        `Envelope` _public: Option<String>,
-        `Envelope` _confidential: Option<String>,
-        `Envelope` _private: Option<String>,
-        sp_address_to: String,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-    ) -> Self {
-        let request = Request::new(
-            request_item_name,
-            request_type,
-            request_version,
-            request_process_hash,
-            request_pcd_reference_hash,
-            request_item_reference_hash,
-        );
-        Prd {
-            request,
-            pcd_keys_role_confidential_list_confidential,
-            `Envelope` _public,
-            `Envelope` _confidential,
-            `Envelope` _private,
-            sp_address_to,
-            sp_address_from,
-            sp_address_reply,
-            timestamp_declared,
-            role_name_from,
-            role_name_to,
-        }
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!(
-            "Request: {:?}, PCD Keys Role Confidential: {:?}, `Envelope`  Public: {}, `Envelope`  Confidential: {}, `Envelope`  Private: {}, SP Address From: {}, SP Address Reply: {}, Timestamp Declared: {}, Role Name From: {}, Role Name To: {}",
-            self.request,
-            self.pcd_keys_role_confidential_list_confidential,
-            self.message_public.as_ref().unwrap(),
-            self.message_confidential.as_ref().unwrap(),
-            self.message_private.as_ref().unwrap(),
-            self.sp_address_from,
-            self.sp_address_reply,
-            self.timestamp_declared,
-            self.role_name_from,
-            self.role_name_to,
-        )
-    }
-}

src/models/request_prd_confirm.rs

@@ -1,100 +0,0 @@
-use std::{
-    collections::hash_map::DefaultHasher,
-    hash::{Hash, Hasher},
-};
-
-use serde::{Deserialize, Serialize};
-
-use super::{
-    key_encryption::KeyEncryption, `Envelope` _client::EnvelopeClient, request_prd::Prd,
-    shared_peer::Peer, shared_process::Process,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PrdConfirm {
-    pub prd: Prd,
-    pub code_confirm_confidential: String,
-}
-
-impl PrdConfirm {
-    pub const TYPE: &'static str = "prd_confirm";
-    pub fn new(
-        request_item_name: Option<String>,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        pcd_keys_role_confidential_list_confidential: String,
-        `Envelope` _public: Option<String>,
-        `Envelope` _confidential: Option<String>,
-        `Envelope` _private: Option<String>,
-        sp_address_to: String,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-        code_confirm_confidential: String,
-    ) -> Self {
-        let request_type = Self::TYPE.to_string();
-        let prd = Prd::new(
-            request_item_name,
-            request_type,
-            request_version,
-            request_process_hash,
-            request_pcd_reference_hash,
-            request_item_reference_hash,
-            pcd_keys_role_confidential_list_confidential,
-            `Envelope` _public,
-            `Envelope` _confidential,
-            `Envelope` _private,
-            sp_address_to,
-            sp_address_from,
-            sp_address_reply,
-            timestamp_declared,
-            role_name_from,
-            role_name_to,
-        );
-        PrdConfirm {
-            prd,
-            code_confirm_confidential,
-        }
-    }
-
-    pub fn to_message(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> `Envelope` Client {
-        let mut hasher: DefaultHasher = DefaultHasher::new();
-        self.hash(&mut hasher);
-        let request_hash = hasher.finish().to_string();
-        let request_enc: String = process_public_enc_key
-            .enc_prd_confirm(self.clone())
-            .to_string();
-
-        `Envelope` Client::new(
-            request_enc,
-            request_hash,
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-            pow_pathern,
-            pow_difficulty,
-        )
-    }
-    // display_info method
-    pub fn display_info(&self) {
-        println!("PrdConfirm:");
-        println!("PRD:");
-        self.prd.display_info(); // Display information of Prd
-        println!(
-            "Code Confirm (Encrypted by Shared Secret): {}",
-            self.code_confirm_confidential
-        );
-    }
-}

src/models/request_prd_key_backup.rs

@@ -1,108 +0,0 @@
-use std::{
-    collections::hash_map::DefaultHasher,
-    hash::{Hash, Hasher},
-};
-
-use serde::{Deserialize, Serialize};
-
-use super::{
-    key_encryption::KeyEncryption, `Envelope` _client::EnvelopeClient, request_prd::Prd,
-    shared_peer::Peer, shared_process::Process,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PrdKeyBackup {
-    pub prd: Prd,
-    pub device_footprint_enc_by_sp_shared_secret: String,
-    pub part_1_enc_hash_enc_by_sp_shared_secret: String,
-    pub shard_enc_by_sp_shared_secret: String,
-}
-
-impl PrdKeyBackup {
-    pub const TYPE: &'static str = "prd_key_backup";
-    pub fn new(
-        request_item_name: Option<String>,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        pcd_keys_role_confidential_list_confidential: String,
-        `Envelope` _public: Option<String>,
-        `Envelope` _confidential: Option<String>,
-        `Envelope` _private: Option<String>,
-        sp_address_to: String,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-
-        device_footprint_enc_by_sp_shared_secret: String,
-        part_1_enc_hash_enc_by_sp_shared_secret: String,
-        shard_enc_by_sp_shared_secret: String,
-    ) -> Self {
-        let request_type = Self::TYPE.to_string();
-        let prd = Prd::new(
-            request_item_name,
-            request_type,
-            request_version,
-            request_process_hash,
-            request_pcd_reference_hash,
-            request_item_reference_hash,
-            pcd_keys_role_confidential_list_confidential,
-            `Envelope` _public,
-            `Envelope` _confidential,
-            `Envelope` _private,
-            sp_address_to,
-            sp_address_from,
-            sp_address_reply,
-            timestamp_declared,
-            role_name_from,
-            role_name_to,
-        );
-        PrdKeyBackup {
-            prd,
-            device_footprint_enc_by_sp_shared_secret,
-            part_1_enc_hash_enc_by_sp_shared_secret,
-            shard_enc_by_sp_shared_secret,
-        }
-    }
-
-    pub fn to_message(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> `Envelope` Client {
-        let mut hasher: DefaultHasher = DefaultHasher::new();
-        self.hash(&mut hasher);
-        let request_hash = hasher.finish().to_string();
-        let request_enc: String = process_public_enc_key
-            .enc_prd_key_backup(self.clone())
-            .to_string();
-
-        `Envelope` Client::new(
-            request_enc,
-            request_hash,
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-            pow_pathern,
-            pow_difficulty,
-        )
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!(
-            "PRD: {:?}, Device Footprint Encrypted: {}, Part 1 Encrypted Hash: {}, Shard Encrypted: {}",
-            self.prd,
-            self.device_footprint_enc_by_sp_shared_secret,
-            self.part_1_enc_hash_enc_by_sp_shared_secret,
-            self.shard_enc_by_sp_shared_secret
-        )
-    }
-}

src/models/request_prd_key_hello.rs

@@ -1,98 +0,0 @@
-use std::{
-    collections::hash_map::DefaultHasher,
-    hash::{Hash, Hasher},
-};
-
-use serde::{Deserialize, Serialize};
-
-use super::{
-    key_encryption::KeyEncryption, `Envelope` _client::EnvelopeClient, request_prd::Prd,
-    shared_peer::Peer, shared_process::Process,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PrdKeyHello {
-    pub prd: Prd,
-    pub part_1_enc_hash_enc_by_sp_shared_secret: String,
-}
-
-impl PrdKeyHello {
-    pub const TYPE: &'static str = "prd_key_hello";
-    pub fn new(
-        request_item_name: Option<String>,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        pcd_keys_role_confidential_list_confidential: String,
-        `Envelope` _public: Option<String>,
-        `Envelope` _confidential: Option<String>,
-        `Envelope` _private: Option<String>,
-        sp_address_to: String,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-        part_1_enc_hash_enc_by_sp_shared_secret: String,
-    ) -> Self {
-        let request_type = Self::TYPE.to_string();
-        let prd = Prd::new(
-            request_item_name,
-            request_type,
-            request_version,
-            request_process_hash,
-            request_pcd_reference_hash,
-            request_item_reference_hash,
-            pcd_keys_role_confidential_list_confidential,
-            `Envelope` _public,
-            `Envelope` _confidential,
-            `Envelope` _private,
-            sp_address_to,
-            sp_address_from,
-            sp_address_reply,
-            timestamp_declared,
-            role_name_from,
-            role_name_to,
-        );
-        PrdKeyHello {
-            prd,
-            part_1_enc_hash_enc_by_sp_shared_secret,
-        }
-    }
-
-    pub fn to_message(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> `Envelope` Client {
-        let mut hasher: DefaultHasher = DefaultHasher::new();
-        self.hash(&mut hasher);
-        let request_hash = hasher.finish().to_string();
-        let request_enc: String = process_public_enc_key
-            .enc_prd_key_hello(self.clone())
-            .to_string();
-
-        `Envelope` Client::new(
-            request_enc,
-            request_hash,
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-            pow_pathern,
-            pow_difficulty,
-        )
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!(
-            "PRD: {:?}, Part 1 Encrypted Hash: {}",
-            self.prd, self.part_1_enc_hash_enc_by_sp_shared_secret
-        )
-    }
-}

src/models/request_prd_list.rs

@@ -1,90 +0,0 @@
-use std::{
-    collections::hash_map::DefaultHasher,
-    hash::{Hash, Hasher},
-};
-
-use serde::{Deserialize, Serialize};
-
-use super::{
-    key_encryption::KeyEncryption, `Envelope` _client::EnvelopeClient, request_prd::Prd,
-    shared_peer::Peer, shared_process::Process,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PrdList {
-    pub prd: Prd,
-}
-
-impl PrdList {
-    pub const TYPE: &'static str = "prd_list";
-    pub fn new(
-        request_item_name: Option<String>,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        pcd_keys_role_confidential_list_confidential: String,
-        `Envelope` _public: Option<String>,
-        `Envelope` _confidential: Option<String>,
-        `Envelope` _private: Option<String>,
-        sp_address_to: String,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-    ) -> Self {
-        let request_type = Self::TYPE.to_string();
-        let prd = Prd::new(
-            request_item_name,
-            request_type,
-            request_version,
-            request_process_hash,
-            request_pcd_reference_hash,
-            request_item_reference_hash,
-            pcd_keys_role_confidential_list_confidential,
-            `Envelope` _public,
-            `Envelope` _confidential,
-            `Envelope` _private,
-            sp_address_to,
-            sp_address_from,
-            sp_address_reply,
-            timestamp_declared,
-            role_name_from,
-            role_name_to,
-        );
-        PrdList { prd }
-    }
-
-    pub fn to_message(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> `Envelope` Client {
-        let mut hasher: DefaultHasher = DefaultHasher::new();
-        self.hash(&mut hasher);
-        let request_hash = hasher.finish().to_string();
-        let request_enc: String = process_public_enc_key
-            .enc_prd_list(self.clone())
-            .to_string();
-
-        `Envelope` Client::new(
-            request_enc,
-            request_hash,
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-            pow_pathern,
-            pow_difficulty,
-        )
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!("PRD: {:?}", self.prd)
-    }
-}

src/models/request_prd_message.rs

@@ -1,89 +0,0 @@
-use std::{
-    collections::hash_map::DefaultHasher,
-    hash::{Hash, Hasher},
-};
-
-use serde::{Deserialize, Serialize};
-
-use super::{
-    key_encryption::KeyEncryption, `Envelope` _client::EnvelopeClient, request_prd::Prd,
-    shared_peer::Peer, shared_process::Process,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PrdMessage {
-    pub prd: Prd,
-}
-
-impl PrdMessage {
-    pub const TYPE: &'static str = "prd_message";
-    pub fn new(
-        request_item_name: Option<String>,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        pcd_keys_role_confidential_list_confidential: String,
-        `Envelope` _public: Option<String>,
-        `Envelope` _confidential: Option<String>,
-        `Envelope` _private: Option<String>,
-        sp_address_to: String,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-    ) -> Self {
-        let request_type = Self::TYPE.to_string();
-        let prd = Prd::new(
-            request_item_name,
-            request_type,
-            request_version,
-            request_process_hash,
-            request_pcd_reference_hash,
-            request_item_reference_hash,
-            pcd_keys_role_confidential_list_confidential,
-            `Envelope` _public,
-            `Envelope` _confidential,
-            `Envelope` _private,
-            sp_address_to,
-            sp_address_from,
-            sp_address_reply,
-            timestamp_declared,
-            role_name_from,
-            role_name_to,
-        );
-        PrdMessage { prd }
-    }
-
-    pub fn to_message(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> `Envelope` Client {
-        let mut hasher: DefaultHasher = DefaultHasher::new();
-        self.hash(&mut hasher);
-        let request_hash = hasher.finish().to_string();
-        let request_enc: String = process_public_enc_key
-            .enc_prd_message(self.clone())
-            .to_string();
-
-        `Envelope` Client::new(
-            request_enc,
-            request_hash,
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-            pow_pathern,
-            pow_difficulty,
-        )
-    }
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!("PRD: {:?}", self.prd)
-    }
-}

src/models/request_prd_response.rs

@@ -1,178 +0,0 @@
-use serde_json::json;
-use std::{collections::hash_map::DefaultHasher, hash::Hash, hash::Hasher};
-
-use serde::{Deserialize, Serialize};
-
-use crate::workflows::workflow_pcd_create_and_send_all::PcdItemEncAttributeRoleConfidentialExportKey;
-
-use super::{
-    commit_method::commitMethod, deposit_method::DepositMethod,
-    key_encryption::KeyEncryption, `Envelope` _client::EnvelopeClient, Payments_method::PaymentsMethod,
-    request_prd::Prd, shared_peer::Peer, shared_process::Process,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PrdResponse {
-    pub prd: Prd,
-    pub sig_value: String,
-    pub pcd_origin_hash: Option<String>,
-    pub Payments_method_confidential: Option<String>,
-    pub deposit_method_confidential: Option<String>,
-    pub commit_method_confidential: Option<String>,
-    pub certif_key_confidential: Option<String>,
-    pub shared_secret_key: Option<KeyEncryption>,
-}
-
-impl PrdResponse {
-    pub const TYPE: &'static str = "prd_response";
-    pub fn new(
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-
-        request_item_name: Option<String>,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        pcd_keys_role_confidential_list: Vec<PcdItemEncAttributeRoleConfidentialExportKey>,
-
-        `Envelope` _public_string: Option<String>,
-        `Envelope` _confidential_string: Option<String>,
-        `Envelope` _private_string: Option<String>,
-
-        sp_address_to: String,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-
-        sig_value: String,
-        pcd_origin_hash: Option<String>,
-
-        Payments_method: Option<PaymentsMethod>,
-        deposit_method: Option<DepositMethod>,
-        commit_method: Option<commitMethod>,
-        certif_key: Option<String>,
-    ) -> Self {
-        let mut shared_secret_key =
-            KeyEncryption::new(Some("secret_shared".to_owned()), None, None);
-
-        if let Ok(_new) = shared_secret_key.key_new_random() {
-            let Payments_method_confidential = match Payments_method {
-                Some(ref _msg) => {
-                    Some(shared_secret_key.enc(serde_json::to_value(Payments_method).unwrap()))
-                }
-                None => None,
-            };
-
-            let deposit_method_confidential = match deposit_method {
-                Some(ref _msg) => {
-                    Some(shared_secret_key.enc(serde_json::to_value(deposit_method).unwrap()))
-                }
-                None => None,
-            };
-
-            let commit_method_confidential = match commit_method {
-                Some(ref _msg) => {
-                    Some(shared_secret_key.enc(serde_json::to_value(commit_method).unwrap()))
-                }
-                None => None,
-            };
-
-            let certif_key_confidential = match certif_key {
-                Some(ref _msg) => {
-                    Some(shared_secret_key.enc(serde_json::to_value(certif_key).unwrap()))
-                }
-                None => None,
-            };
-
-            let `Envelope` _confidential = `Envelope` _confidential_string
-                .as_ref()
-                .map(|msg| shared_secret_key.enc_string(msg.clone()));
-            let `Envelope` _public = `Envelope` _public_string
-                .as_ref()
-                .map(|msg| process_public_enc_key.enc_string(msg.clone()));
-            let `Envelope` _private = `Envelope` _private_string
-                .as_ref()
-                .map(|msg| Member_private_enc_key.enc_string(msg.clone()));
-
-            let pcd_keys_role_confidential_list_confidential = shared_secret_key.enc(
-                serde_json::to_value(pcd_keys_role_confidential_list).unwrap_or_else(|_| json!({})),
-            );
-
-            let request_type = Self::TYPE.to_string();
-            let prd = Prd::new(
-                request_item_name,
-                request_type,
-                request_version,
-                request_process_hash,
-                request_pcd_reference_hash,
-                request_item_reference_hash,
-                pcd_keys_role_confidential_list_confidential,
-                `Envelope` _public,
-                `Envelope` _confidential,
-                `Envelope` _private,
-                sp_address_to,
-                sp_address_from,
-                sp_address_reply,
-                timestamp_declared,
-                role_name_from,
-                role_name_to,
-            );
-            PrdResponse {
-                prd,
-                sig_value,
-                pcd_origin_hash,
-                Payments_method_confidential,
-                deposit_method_confidential,
-                commit_method_confidential,
-                certif_key_confidential,
-                shared_secret_key: Some(shared_secret_key),
-            }
-        } else {
-            panic!("Error: Could not create shared secret key");
-        }
-    }
-
-    pub fn to_message(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> `Envelope` Client {
-        let mut hasher: DefaultHasher = DefaultHasher::new();
-        self.hash(&mut hasher);
-        let request_hash = hasher.finish().to_string();
-        let request_enc: String = process_public_enc_key
-            .enc_prd_response(self.clone())
-            .to_string();
-
-        `Envelope` Client::new(
-            request_enc,
-            request_hash,
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-            pow_pathern,
-            pow_difficulty,
-        )
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!(
-            "PRD: {:?}, Sig Value: {}, PCD Origin Hash: {}, Payments Method Encrypted: {}, Deposit Method Encrypted: {}, commit Method Encrypted: {}, Certification Key Encrypted: {}",
-            self.prd,
-            self.sig_value,
-            self.pcd_origin_hash.as_ref().unwrap(),
-            self.Payments_method_confidential.as_ref().unwrap(),
-            self.deposit_method_confidential.as_ref().unwrap(),
-            self.commit_method_confidential.as_ref().unwrap(),
-            self.certif_key_confidential.as_ref().unwrap()
-        )
-    }
-}

src/models/request_prd_update.rs

@@ -1,127 +0,0 @@
-use std::{
-    collections::hash_map::DefaultHasher,
-    hash::{Hash, Hasher},
-};
-
-use super::{
-    key_encryption::KeyEncryption, `Envelope` _client::EnvelopeClient, request_prd::Prd,
-    shared_peer::Peer, shared_process::Process,
-};
-use serde::{Deserialize, Serialize};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PrdUpdate {
-    pub prd: Prd,
-    pub pcd_new_version_hash: String,
-    pub Payments_pcd_hash_list: Vec<String>,
-    pub cap_pcd_hash_list: Vec<String>,
-    pub deposit_pcd_hash_list: Vec<String>,
-    pub commit_pcd_hash_list: Vec<String>,
-    pub ask_Payments_method: String,
-    pub ask_deposit_method: String,
-    pub ask_commit_method: String,
-}
-
-impl PrdUpdate {
-    pub const TYPE: &'static str = "prd_update";
-    pub fn new(
-        request_item_name: Option<String>,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        pcd_keys_role_confidential_list_confidential: String,
-        `Envelope` _public: Option<String>,
-        `Envelope` _confidential: Option<String>,
-        `Envelope` _private: Option<String>,
-        sp_address_to: String,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-
-        pcd_new_version_hash: String,
-        Payments_pcd_hash_list: Vec<String>,
-        cap_pcd_hash_list: Vec<String>,
-        deposit_pcd_hash_list: Vec<String>,
-        commit_pcd_hash_list: Vec<String>,
-        ask_Payments_method: String,
-        ask_deposit_method: String,
-        ask_commit_method: String,
-    ) -> Self {
-        let request_type = Self::TYPE.to_string();
-        let prd = Prd::new(
-            request_item_name,
-            request_type,
-            request_version,
-            request_process_hash,
-            request_pcd_reference_hash,
-            request_item_reference_hash,
-            pcd_keys_role_confidential_list_confidential,
-            `Envelope` _public,
-            `Envelope` _confidential,
-            `Envelope` _private,
-            sp_address_to,
-            sp_address_from,
-            sp_address_reply,
-            timestamp_declared,
-            role_name_from,
-            role_name_to,
-        );
-        PrdUpdate {
-            prd,
-            pcd_new_version_hash,
-            Payments_pcd_hash_list,
-            cap_pcd_hash_list,
-            deposit_pcd_hash_list,
-            commit_pcd_hash_list,
-            ask_Payments_method,
-            ask_deposit_method,
-            ask_commit_method,
-        }
-    }
-
-    pub fn to_message(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        pow_pathern: String,
-        pow_difficulty: usize,
-    ) -> `Envelope` Client {
-        let mut hasher: DefaultHasher = DefaultHasher::new();
-        self.hash(&mut hasher);
-        let request_hash = hasher.finish().to_string();
-        let request_enc: String = process_public_enc_key
-            .enc_prd_update(self.clone())
-            .to_string();
-
-        `Envelope` Client::new(
-            request_enc,
-            request_hash,
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-            pow_pathern,
-            pow_difficulty,
-        )
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!(
-            "PRD: {:?}, PCD New Version Hash: {}, Payments PCD Hash List: {:?}, Cap PCD Hash List: {:?}, Deposit PCD Hash List: {:?}, commit PCD Hash List: {:?}, Ask Payments Method: {}, Ask Deposit Method: {}, Ask commit Method: {}",
-            self.prd,
-            self.pcd_new_version_hash,
-            self.Payments_pcd_hash_list,
-            self.cap_pcd_hash_list,
-            self.deposit_pcd_hash_list,
-            self.commit_pcd_hash_list,
-            self.ask_Payments_method,
-            self.ask_deposit_method,
-            self.ask_commit_method,
-        )
-    }
-}

src/models/role.rs

@@ -1,201 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::{
-    condition_cap::ConditionCap, condition_commit::Conditioncommit,
-    condition_orchestration::ConditionOrchestration, condition_Payments::ConditionPayments,
-    condition_prd_address_set::ConditionPrdAddressSet, condition_publish::ConditionPublish,
-    item::Item, metadata::Amount,
-};
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct TransactionModeDistribution {
-    pub from_prd_update_from: String,
-    pub from_role_list: Vec<String>,
-    pub to_role_list: Vec<String>,
-    pub from_prd_address_list: Vec<String>,
-    pub to_prd_address_list: Vec<String>,
-    pub method: String,
-}
-
-impl TransactionModeDistribution {
-    pub fn new(
-        from_prd_update_from: String,
-        from_role_list: Vec<String>,
-        to_role_list: Vec<String>,
-        from_prd_address_list: Vec<String>,
-        to_prd_address_list: Vec<String>,
-        method: String,
-    ) -> Self {
-        TransactionModeDistribution {
-            from_prd_update_from,
-            from_role_list,
-            to_role_list,
-            from_prd_address_list,
-            to_prd_address_list,
-            method,
-        }
-    }
-    // display_info method
-    pub fn display_info(&self) {
-        println!("TransactionModeDistribution:");
-        println!("From PRD Update From: {}", self.from_prd_update_from);
-        println!("From Role List: {:?}", self.from_role_list);
-        println!("To Role List: {:?}", self.to_role_list);
-        println!("From PRD Address List: {:?}", self.from_prd_address_list);
-        println!("To PRD Address List: {:?}", self.to_prd_address_list);
-        println!("Method: {}", self.method);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct TransactionModeDirect {
-    pub from_prd_update_from: String,
-    pub to_role_owner: String,
-}
-
-impl TransactionModeDirect {
-    pub fn new(from_prd_update_from: String, to_role_owner: String) -> Self {
-        TransactionModeDirect {
-            from_prd_update_from,
-            to_role_owner,
-        }
-    }
-
-    // display_info method
-    pub fn display_info(&self) {
-        println!("TransactionModeDirect:");
-        println!("From PRD Update From: {}", self.from_prd_update_from);
-        println!("To Role Owner: {}", self.to_role_owner);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct TransactionMode {
-    pub amount: Amount,
-    pub role_transaction_distribution: TransactionModeDistribution,
-    pub role_transaction_direct: TransactionModeDirect,
-}
-
-impl TransactionMode {
-    pub fn new(
-        amount: Amount,
-        role_transaction_distribution: TransactionModeDistribution,
-        role_transaction_direct: TransactionModeDirect,
-    ) -> Self {
-        TransactionMode {
-            amount,
-            role_transaction_distribution,
-            role_transaction_direct,
-        }
-    }
-
-    // display_info method
-    pub fn display_info(&self) {
-        println!("TransactionMode:");
-
-        println!("Amount:");
-        self.amount.display_info(); // Assuming Amount has a display_info method
-
-        println!("Role Transaction Distribution:");
-        self.role_transaction_distribution.display_info(); // Assuming TransactionModeDistribution has a display_info method
-
-        println!("Role Transaction Direct:");
-        self.role_transaction_direct.display_info(); // Assuming TransactionModeDirect has a display_info method
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Role {
-    pub item: Item,
-    pub required_2fa: bool,
-    pub validation_timeout: u64,
-    pub condition_prd_address_set_list: Vec<ConditionPrdAddressSet>, // Assuming ConditionPrdAddressSet is a predefined struct
-    pub condition_publish: ConditionPublish, // Assuming ConditionPublish is a predefined struct
-    pub condition_cap_list: Vec<ConditionCap>, // Assuming ConditionCap is a predefined struct
-    pub condition_Payments_list: Vec<ConditionPayments>, // Assuming ConditionPayments is a predefined struct
-    pub condition_commit_list: Vec<Conditioncommit>, // Assuming Conditioncommit is a predefined struct
-    pub condition_attribute_encryption_list: Vec<String>,
-    pub condition_orchestration: ConditionOrchestration, // Assuming ConditionOrchestration is a predefined struct
-    pub role_succession: Option<String>,
-    pub role_resolve: Option<String>,
-    pub role_renew: Option<String>,
-}
-
-impl Role {
-    pub fn new(
-        item: Item,
-        required_2fa: bool,
-        validation_timeout: u64,
-        condition_prd_address_set_list: Vec<ConditionPrdAddressSet>,
-        condition_publish: ConditionPublish,
-        condition_cap_list: Vec<ConditionCap>,
-        condition_Payments_list: Vec<ConditionPayments>,
-        condition_commit_list: Vec<Conditioncommit>,
-        condition_attribute_encryption_list: Vec<String>,
-        condition_orchestration: ConditionOrchestration,
-        role_succession: Option<String>,
-        role_resolve: Option<String>,
-        role_renew: Option<String>,
-    ) -> Self {
-        Role {
-            item,
-            required_2fa,
-            validation_timeout,
-            condition_prd_address_set_list,
-            condition_publish,
-            condition_cap_list,
-            condition_Payments_list,
-            condition_commit_list,
-            condition_attribute_encryption_list,
-            condition_orchestration,
-            role_succession,
-            role_resolve,
-            role_renew,
-        }
-    }
-    // display_info method
-    pub fn display_info(&self) {
-        println!("Role:");
-        println!("Item: {:?}", self.item); // Assuming `Item` implements Debug trait
-        println!("Validation Timeout: {}", self.validation_timeout);
-
-        println!("ConditionPrdAddressSet List:");
-        for condition in &self.condition_prd_address_set_list {
-            condition.display_info(); // Assuming `ConditionPrdAddressSet` has a display_info method
-        }
-
-        println!("ConditionPublish:");
-        self.condition_publish.display_info(); // Assuming `ConditionPublish` has a display_info method
-
-        println!("ConditionCap List:");
-        for condition in &self.condition_cap_list {
-            condition.display_info(); // Assuming `ConditionCap` has a display_info method
-        }
-
-        println!("ConditionPayments List:");
-        for condition in &self.condition_Payments_list {
-            condition.display_info(); // Assuming `ConditionPayments` has a display_info method
-        }
-
-        println!("Conditioncommit List:");
-        for condition in &self.condition_commit_list {
-            condition.display_info(); // Assuming `Conditioncommit` has a display_info method
-        }
-
-        println!("ConditionAttributeEncryption:");
-        for condition in &self.condition_attribute_encryption_list {
-            println!("ConditionAttributeEncryption: {:?}", condition);
-        }
-
-        println!("ConditionOrchestration:");
-        self.condition_orchestration.display_info(); // Assuming `ConditionOrchestration` has a display_info method
-
-        println!("Role Succession: {:?}", self.role_succession);
-        println!("Role Resolve: {:?}", self.role_resolve);
-        println!("Role Renew: {:?}", self.role_renew);
-    }
-
-    // Additional methods for Role can be added here
-}

src/models/role_artefact.rs

@@ -1,20 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::Role;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct RoleArtefact {
-    pub item_name: String,
-    pub role: Role,
-}
-
-impl RoleArtefact {
-    pub fn new(item_name: String, role: Role) -> Self {
-        RoleArtefact { item_name, role }
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!("Item Name: {}, Role: {:?}", self.item_name, self.role)
-    }
-}

src/models/role_commitment.rs

@@ -1,20 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::Role;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Rolecommit {
-    pub item_name: String,
-    pub role: Role,
-}
-
-impl Rolecommit {
-    pub fn new(item_name: String, role: Role) -> Self {
-        Rolecommit { item_name, role }
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!("Item Name: {}, Role: {:?}", self.item_name, self.role)
-    }
-}

src/models/role_deposit.rs

@@ -1,20 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::Role;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct RoleDeposit {
-    pub item_name: String,
-    pub role: Role,
-}
-
-impl RoleDeposit {
-    pub fn new(item_name: String, role: Role) -> Self {
-        RoleDeposit { item_name, role }
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!("Item Name: {}, Role: {:?}", self.item_name, self.role)
-    }
-}

src/models/role_member.rs

@@ -1,18 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::Role;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct RoleMember {
-    pub item_name: String,
-    pub role: Role,
-}
-
-impl RoleMember {
-    pub fn new(item_name: String, role: Role) -> Self {
-        RoleMember { item_name, role }
-    }
-    pub fn display_info(&self) -> String {
-        format!("Item Name: {}, Role: {:?}", self.item_name, self.role)
-    }
-}

src/models/role_payment.rs

@@ -1,20 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::Role;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct RolePayments {
-    pub item_name: String,
-    pub role: Role,
-}
-
-impl RolePayments {
-    pub fn new(item_name: String, role: Role) -> Self {
-        RolePayments { item_name, role }
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!("Item Name: {}, Role: {:?}", self.item_name, self.role)
-    }
-}

src/models/role_peer.rs

@@ -1,20 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::Role;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct RolePeer {
-    pub item_name: String,
-    pub role: Role,
-}
-
-impl RolePeer {
-    pub fn new(item_name: String, role: Role) -> Self {
-        RolePeer { item_name, role }
-    }
-
-    // Fonction pour afficher ou retourner les informations
-    pub fn display_info(&self) -> String {
-        format!("Item Name: {}, Role: {:?}", self.item_name, self.role)
-    }
-}

src/models/role_process.rs

@@ -1,18 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::role::Role;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct RoleProcess {
-    pub item_name: String,
-    pub role: Role,
-}
-
-impl RoleProcess {
-    pub fn new(item_name: String, role: Role) -> Self {
-        RoleProcess { item_name, role }
-    }
-    pub fn display_info(&self) -> String {
-        format!("Item Name: {}, Role: {:?}", self.item_name, self.role)
-    }
-}

src/models/roles_group.rs

@@ -1,129 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::workflows::workflow_pcd_create_and_send_all::PcdItemEncAttributeRoleConfidentialExportKey;
-
-use super::{
-    commit_method::commitMethod, deposit_method::DepositMethod,
-    key_encryption::KeyEncryption, Payments_method::PaymentsMethod,
-    request_prd_response::PrdResponse, role_artefact::RoleArtefact, role_Member::RoleMember,
-    role_peer::RolePeer, role_process::RoleProcess,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct RolesGroup {
-    pub role_peer: RolePeer,
-    pub role_Member: RoleMember,
-    pub role_process: RoleProcess,
-    pub role_artefact_list: Vec<RoleArtefact>,
-}
-
-impl RolesGroup {
-    pub fn new(
-        role_peer: RolePeer,
-        role_Member: RoleMember,
-        role_process: RoleProcess,
-        role_artefact_list: Vec<RoleArtefact>,
-    ) -> Self {
-        RolesGroup {
-            role_peer,
-            role_Member,
-            role_process,
-            role_artefact_list,
-        }
-    }
-    pub fn filter_keys(
-        condition_attribute_encryption: &Vec<String>,
-        pcd_keys_role_confidential_list: &mut Vec<PcdItemEncAttributeRoleConfidentialExportKey>,
-    ) {
-        for key_item in pcd_keys_role_confidential_list.iter_mut() {
-            if !condition_attribute_encryption.contains(&key_item.attribute_name) {
-                key_item.key = None;
-            }
-        }
-    }
-    pub fn to_prd_response_list(
-        &self,
-        process_public_enc_key: KeyEncryption,
-        Member_private_enc_key: KeyEncryption,
-        request_item_name: Option<String>,
-        request_version: i64,
-        request_process_hash: String,
-        request_pcd_reference_hash: Option<String>,
-        request_item_reference_hash: Option<String>,
-        pcd_keys_role_confidential_list: Vec<PcdItemEncAttributeRoleConfidentialExportKey>,
-        `Envelope` _public_string: Option<String>,
-        `Envelope` _confidential_string: Option<String>,
-        `Envelope` _private_string: Option<String>,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-        sig_value: String,
-        pcd_origin_hash: Option<String>,
-
-        Payments_method: Option<PaymentsMethod>,
-        deposit_method: Option<DepositMethod>,
-        commit_method: Option<commitMethod>,
-        certif_key: Option<String>,
-    ) -> Vec<PrdResponse> {
-        let mut request_prd_response_list: Vec<PrdResponse> = Vec::new();
-
-        for cond in &self.role_peer.role.condition_prd_address_set_list {
-            let mut pcd_keys_role_confidential_list_tmp = pcd_keys_role_confidential_list.clone();
-
-            RolesGroup::filter_keys(
-                &self.role_peer.role.condition_attribute_encryption_list,
-                &mut pcd_keys_role_confidential_list_tmp,
-            );
-
-            for address in &cond.prd_sp_address_list {
-                let prd_response = PrdResponse::new(
-                    process_public_enc_key.clone(),
-                    Member_private_enc_key.clone(),
-                    request_item_name.clone(),
-                    request_version.clone(),
-                    request_process_hash.clone(),
-                    request_pcd_reference_hash.clone(),
-                    request_item_reference_hash.clone(),
-                    pcd_keys_role_confidential_list.clone(),
-                    `Envelope` _public_string.clone(),
-                    `Envelope` _confidential_string.clone(),
-                    `Envelope` _private_string.clone(),
-                    address.to_string(),
-                    sp_address_from.clone(),
-                    sp_address_reply.clone(),
-                    timestamp_declared.clone(),
-                    role_name_from.clone(),
-                    role_name_to.clone(),
-                    sig_value.clone(),
-                    pcd_origin_hash.clone(),
-                    Payments_method.clone(),
-                    deposit_method.clone(),
-                    commit_method.clone(),
-                    certif_key.clone(),
-                );
-                request_prd_response_list.push(prd_response);
-            }
-        }
-        request_prd_response_list
-    }
-    pub fn display_info(&self) {
-        println!("RolesGroup:");
-        println!("Role Peer:");
-        self.role_peer.display_info(); // Affiche les informations de `role_peer`
-
-        println!("Role Member:");
-        self.role_Member.display_info(); // Affiche les informations de `role_Member`
-
-        println!("Role Process:");
-        self.role_process.display_info(); // Affiche les informations de `role_process`
-
-        println!("Role Artefact List:");
-        for (index, role_artefact) in self.role_artefact_list.iter().enumerate() {
-            println!("Artefact {}: ", index + 1);
-            role_artefact.display_info(); // Affiche les informations de chaque `role_artefact`
-        }
-    }
-}

src/models/shared_peer.rs

@@ -1,221 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::message_client::EnvelopeClient;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Relay {
-    pub address_port: u16,
-    pub data_max_size: usize,
-    pub pow_difficulty: u32,
-    pub pow_pattern: String,
-    pub pow_prefix: String,
-    pub pow_timeout: u32,
-    pub faucet_address: String,
-}
-
-impl Relay {
-    pub fn new(
-        address_port: u16,
-        data_max_size: usize,
-        pow_difficulty: u32,
-        pow_pattern: String,
-        pow_prefix: String,
-        pow_timeout: u32,
-        faucet_address: String,
-    ) -> Self {
-        Relay {
-            address_port,
-            data_max_size,
-            pow_difficulty,
-            pow_pattern,
-            pow_prefix,
-            pow_timeout,
-            faucet_address,
-        }
-    }
-    // display_info method
-    pub fn display_info(&self) {
-        println!("Relay:");
-        println!("Address Port: {}", self.address_port);
-        println!("Data Max Size: {}", self.data_max_size);
-        println!("PoW Difficulty: {}", self.pow_difficulty);
-        println!("PoW Pattern: {}", self.pow_pattern);
-        println!("PoW Prefix: {}", self.pow_prefix);
-        println!("PoW Timeout: {}", self.pow_timeout);
-        println!("Faucet Address: {}", self.faucet_address);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct L1Node {
-    pub address_port: u16,
-    pub explorer_base_url: String,
-    pub sp_address_anchorage: String,
-    pub sp_address_reward: String,
-}
-
-impl L1Node {
-    pub fn new(
-        address_port: u16,
-        explorer_base_url: String,
-        sp_address_anchorage: String,
-        sp_address_reward: String,
-    ) -> Self {
-        L1Node {
-            address_port,
-            explorer_base_url,
-            sp_address_anchorage,
-            sp_address_reward,
-        }
-    } // display_info method
-    pub fn display_info(&self) {
-        println!("L1Node:");
-        println!("Address Port: {}", self.address_port);
-        println!("Explorer Base URL: {}", self.explorer_base_url);
-        println!("SP Address Anchorage: {}", self.sp_address_anchorage);
-        println!("SP Address Reward: {}", self.sp_address_reward);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct L1Miner {
-    pub sp_address_rewarder: String,
-}
-
-impl L1Miner {
-    pub fn new(sp_address_rewarder: String) -> Self {
-        L1Miner {
-            sp_address_rewarder,
-        }
-    }
-
-    // display_info method
-    pub fn display_info(&self) {
-        println!("L1Miner:");
-        println!("SP Address Rewarder: {}", self.sp_address_rewarder);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct L2Node {
-    pub address_port: u16,
-    pub explorer_base_url: String,
-    pub sp_address_anchorage: String,
-    pub sp_address_reward: String,
-    pub nbits: u32,
-    pub magic_number: u32,
-    pub challenge: String,
-}
-
-impl L2Node {
-    pub fn new(
-        address_port: u16,
-        explorer_base_url: String,
-        sp_address_anchorage: String,
-        sp_address_reward: String,
-        nbits: u32,
-        magic_number: u32,
-        challenge: String,
-    ) -> Self {
-        L2Node {
-            address_port,
-            explorer_base_url,
-            sp_address_anchorage,
-            sp_address_reward,
-            nbits,
-            magic_number,
-            challenge,
-        }
-    }
-
-    // display_info method
-    pub fn display_info(&self) {
-        println!("L2Node:");
-        println!("Address Port: {}", self.address_port);
-        println!("Explorer Base URL: {}", self.explorer_base_url);
-        println!("SP Address Anchorage: {}", self.sp_address_anchorage);
-        println!("SP Address Reward: {}", self.sp_address_reward);
-        println!("Nbits: {}", self.nbits);
-        println!("Magic Number: {}", self.magic_number);
-        println!("Challenge: {}", self.challenge);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct L2Certif {
-    pub sp_address_certif: String,
-}
-
-impl L2Certif {
-    pub fn new(sp_address_certif: String) -> Self {
-        L2Certif { sp_address_certif }
-    }
-    // display_info method
-    pub fn display_info(&self) {
-        println!("L2Certif:");
-        println!("SP Address Certif: {}", self.sp_address_certif);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Peer {
-    pub domain: String,
-    pub address_ip: String,
-    pub relay: Relay,
-    pub l1_node: L1Node,
-    pub l1_miner: L1Miner,
-    pub l2_node: L2Node,
-    pub l2_certif: L2Certif,
-}
-
-impl Peer {
-    pub fn new(
-        domain: String,
-        address_ip: String,
-        relay: Relay,
-        l1_node: L1Node,
-        l1_miner: L1Miner,
-        l2_node: L2Node,
-        l2_certif: L2Certif,
-    ) -> Self {
-        Peer {
-            domain,
-            address_ip,
-            relay,
-            l1_node,
-            l1_miner,
-            l2_node,
-            l2_certif,
-        }
-    }
-    pub fn send_message_client(&self, _message_client: `Envelope` Client) {
-        // TODO
-    }
-
-    // display_info method
-    pub fn display_info(&self) {
-        println!("Peer:");
-        println!("Domain: {}", self.domain);
-        println!("IP Address: {}", self.address_ip);
-
-        println!("Relay:");
-        self.relay.display_info(); // Assuming Relay has a display_info method
-
-        println!("L1 Node:");
-        self.l1_node.display_info(); // Assuming L1Node has a display_info method
-
-        println!("L1 Miner:");
-        self.l1_miner.display_info(); // Assuming L1Miner has a display_info method
-
-        println!("L2 Node:");
-        self.l2_node.display_info(); // Assuming L2Node has a display_info method
-
-        println!("L2 Certif:");
-        self.l2_certif.display_info(); // Assuming L2Certif has a display_info method
-    }
-}

src/models/shared_process.rs

@@ -1,35 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use super::key_encryption::KeyEncryption;
-#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct Process {
-    pub hash: String,
-    pub key: KeyEncryption,
-    pub role_process_sp_address_list: Vec<String>,
-}
-
-impl Process {
-    pub fn new(
-        hash: String,
-        key: KeyEncryption,
-        role_process_sp_address_list: Vec<String>,
-    ) -> Self {
-        Process {
-            hash,
-            key,
-            role_process_sp_address_list,
-        }
-    }
-    // display_info method
-    pub fn display_info(&self) {
-        println!("Process:");
-        println!("Hash: {}", self.hash);
-        println!("Key Encryption:");
-        self.key.display_info(); // Assuming KeyEncryption has a display_info method
-        println!(
-            "Role Process SP Address List: {:?}",
-            self.role_process_sp_address_list
-        );
-    }
-}

src/network.rs

@@ -0,0 +1,215 @@
+use std::collections::HashMap;
+
+use anyhow::Result;
+use rand::{thread_rng, RngCore};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use sp_client::bitcoin::consensus::serialize;
+use sp_client::bitcoin::hex::DisplayHex;
+use sp_client::bitcoin::{OutPoint, Transaction};
+use tsify::Tsify;
+
+use crate::error::AnkError;
+use crate::pcd::{Member, RoleDefinition};
+use crate::process::Process;
+use crate::signature::Proof;
+
+#[derive(Debug, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub enum AnkFlag {
+    NewTx,
+    Faucet,
+    Cipher,
+    Commit,
+    Handshake,
+    Unknown,
+}
+
+impl From<&str> for AnkFlag {
+    fn from(value: &str) -> Self {
+        match value {
+            "NewTx" => Self::NewTx,
+            "Faucet" => Self::Faucet,
+            "Cipher" => Self::Cipher,
+            "Commit" => Self::Commit,
+            "Handshake" => Self::Handshake,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+impl From<String> for AnkFlag {
+    fn from(value: String) -> Self {
+        (&value[..]).into()
+    }
+}
+
+impl AnkFlag {
+    pub fn new_from_byte(byte: u8) -> Self {
+        match byte {
+            0 => Self::NewTx,
+            1 => Self::Faucet,
+            2 => Self::Cipher,
+            3 => Self::Commit,
+            4 => Self::Handshake,
+            _ => Self::Unknown,
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::NewTx => "NewTx",
+            Self::Faucet => "Faucet",
+            Self::Cipher => "Cipher",
+            Self::Commit => "Commit",
+            Self::Handshake => "Handshake",
+            Self::Unknown => "Unknown",
+        }
+    }
+}
+
+/// Message sent to the server to commit some state in a transaction
+/// Client must first send a commit message with empty validation_tokens
+/// Relay will ignore a commit message for an update he's not aware of that also bears validation_tokens
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct CommitMessage {
+    pub init_tx: String, // Can be tx or txid of the first transaction of the chain, which is maybe not ideal
+    pub pcd_commitment: Value, // map of field <=> hash of the clear value
+    pub roles: HashMap<String, RoleDefinition>, // Can be hashed and compared with the value above
+    pub validation_tokens: Vec<Proof>,
+    pub error: Option<AnkError>,
+}
+
+impl CommitMessage {
+    /// Create a new commitment message for the first transaction of the chain
+    /// init_tx must be the hex string of the transaction
+    /// validation_tokens must be empty
+    pub fn new_first_commitment(
+        transaction: Transaction,
+        pcd_commitment: Value,
+        roles: HashMap<String, RoleDefinition>,
+    ) -> Self {
+        Self {
+            init_tx: serialize(&transaction).to_lower_hex_string(),
+            pcd_commitment,
+            roles,
+            validation_tokens: vec![],
+            error: None,
+        }
+    }
+
+    /// Create a new commitment message for an update transaction
+    /// init_tx must be the hex string of the txid of the first commitment transaction
+    /// validation_tokens must be empty
+    pub fn new_update_commitment(
+        init_tx: OutPoint,
+        pcd_commitment: Value,
+        roles: HashMap<String, RoleDefinition>,
+    ) -> Self {
+        Self {
+            init_tx: init_tx.to_string(),
+            pcd_commitment,
+            roles,
+            validation_tokens: vec![],
+            error: None,
+        }
+    }
+
+    /// Set the validation tokens for a pending commitment
+    pub fn set_validation_tokens(&mut self, validation_tokens: Vec<Proof>) {
+        self.validation_tokens = validation_tokens;
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct FaucetMessage {
+    pub sp_address: String,
+    pub commitment: String,
+    pub error: Option<AnkError>,
+}
+
+impl FaucetMessage {
+    pub fn new(sp_address: String) -> Self {
+        let mut buf = [0u8; 32];
+        thread_rng().fill_bytes(&mut buf);
+        Self {
+            sp_address,
+            commitment: buf.to_lower_hex_string(),
+            error: None,
+        }
+    }
+
+    pub fn to_string(&self) -> String {
+        serde_json::to_string(self).unwrap()
+    }
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct NewTxMessage {
+    pub transaction: String,
+    pub tweak_data: Option<String>,
+    pub error: Option<AnkError>,
+}
+
+impl NewTxMessage {
+    pub fn new(transaction: String, tweak_data: Option<String>) -> Self {
+        Self {
+            transaction,
+            tweak_data,
+            error: None,
+        }
+    }
+
+    pub fn to_string(&self) -> String {
+        serde_json::to_string(self).unwrap()
+    }
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct HandshakeMessage {
+    pub sp_address: String,
+    pub peers_list: HashMap<Member, OutPoint>,
+    pub processes_list: HashMap<OutPoint, Process>,
+}
+
+impl HandshakeMessage {
+    pub fn new(sp_address: String, peers_list: HashMap<Member, OutPoint>, processes_list: HashMap<OutPoint, Process>) -> Self {
+        Self {
+            sp_address,
+            peers_list,
+            processes_list,
+        }
+    }
+
+    pub fn to_string(&self) -> String {
+        serde_json::to_string(self).unwrap()
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Envelope {
+    pub flag: AnkFlag,
+    pub content: String,
+}
+
+impl Envelope {
+    pub fn new(flag: AnkFlag, raw: &str) -> Self {
+        Self {
+            flag,
+            content: raw.into(),
+        }
+    }
+
+    pub fn from_string(json: &str) -> Result<Self> {
+        let res: Self = serde_json::from_str(json)?;
+        Ok(res)
+    }
+
+    pub fn to_string(&self) -> String {
+        serde_json::to_string(self).unwrap()
+    }
+}

src/prd.rs

@@ -0,0 +1,222 @@
+use std::collections::{HashMap, HashSet};
+
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+use serde_json::{Map, Value};
+use sp_client::bitcoin::hashes::{sha256t_hash_newtype, Hash, HashEngine};
+use sp_client::bitcoin::secp256k1::{PublicKey, SecretKey};
+use sp_client::bitcoin::OutPoint;
+use sp_client::silentpayments::utils::SilentPaymentAddress;
+use sp_client::spclient::SpWallet;
+use tsify::Tsify;
+
+use crate::pcd::{Member, RoleDefinition};
+use crate::signature::{AnkHash, AnkMessageHash, Proof};
+
+#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[allow(non_camel_case_types)]
+pub enum PrdType {
+    #[default]
+    None,
+    Connect,
+    Message,
+    Update, // Update an existing process
+    List,   // request a list of items
+    Response, // Validate (or disagree) with a prd update
+    Confirm, // Confirm we received an update
+    TxProposal, // Send a psbt asking for recipient signature
+    Request // asks for the prd update for some state,
+}
+
+sha256t_hash_newtype! {
+    pub struct AnkPrdTag = hash_str("4nk/Prd");
+
+    #[hash_newtype(forward)]
+    pub struct AnkPrdHash(_);
+}
+
+impl AnkPrdHash {
+    pub fn from_value(value: &Value) -> Self {
+        let mut eng = AnkPrdHash::engine();
+        eng.input(value.to_string().as_bytes());
+        AnkPrdHash::from_engine(eng)
+    }
+
+    pub fn from_map(map: &Map<String, Value>) -> Self {
+        let value = Value::Object(map.clone());
+        let mut eng = AnkPrdHash::engine();
+        eng.input(value.to_string().as_bytes());
+        AnkPrdHash::from_engine(eng)
+    }
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[allow(non_camel_case_types)]
+pub struct Prd {
+    pub prd_type: PrdType,
+    pub root_commitment: String,
+    pub sender: String,
+    pub keys: Map<String, Value>, // key is a key in pcd, value is the key to decrypt it
+    pub pcd_commitments: Value,
+    pub validation_tokens: Vec<Proof>,
+    pub payload: String,      // Additional information depending on the type
+    pub proof: Option<Proof>, // This must be None up to the creation of the network message
+}
+
+impl Prd {
+    /// We answer to ack we received a transaction and got the shared_secret
+    /// If validation_tokens is empty we put the proof into it and return it
+    /// If validation_tokens contains a valid proof signed by ourselves of empty prd, 
+    /// we confirm the secret if necessary and don't return anything
+    pub fn new_connect(sender: Member, secret_hash: AnkMessageHash, previous_proof: Option<Proof>) -> Self {
+        let validation_tokens = if let Some(proof) = previous_proof { vec![proof] } else { vec![] };
+        Self {
+            prd_type: PrdType::Connect,
+            root_commitment: String::default(),
+            pcd_commitments: Value::Null,
+            sender: serde_json::to_string(&sender).unwrap(),
+            validation_tokens,
+            keys: Map::new(),
+            payload: secret_hash.to_string(),
+            proof: None,
+        }
+    }
+
+    pub fn new_update(
+        root_commitment: OutPoint,
+        sender: Member,
+        roles: HashMap<String, RoleDefinition>,
+        keys: Map<String, Value>,
+        pcd_commitments: Value,
+    ) -> Self {
+        Self {
+            prd_type: PrdType::Update,
+            root_commitment: root_commitment.to_string(),
+            sender: serde_json::to_string(&sender).unwrap(),
+            validation_tokens: vec![],
+            keys,
+            pcd_commitments,
+            payload: serde_json::to_string(&roles).expect("We're confident it's serializable"),
+            proof: None,
+        }
+    }
+
+    pub fn new_response(
+        root_commitment: OutPoint,
+        sender: Member,
+        validation_tokens: Vec<Proof>,
+        pcd_commitments: Value,
+    ) -> Self {
+        Self {
+            prd_type: PrdType::Response,
+            root_commitment: root_commitment.to_string(),
+            sender: serde_json::to_string(&sender).unwrap(),
+            validation_tokens: validation_tokens,
+            keys: Map::new(),
+            pcd_commitments,
+            payload: String::default(),
+            proof: None,
+        }
+    }
+
+    pub fn new_confirm(
+        root_commitment: OutPoint,
+        sender: Member,
+        pcd_commitments: Value,
+    ) -> Self {
+        Self {
+            prd_type: PrdType::Confirm,
+            root_commitment: root_commitment.to_string(),
+            pcd_commitments,
+            sender: serde_json::to_string(&sender).unwrap(),
+            validation_tokens: vec![],
+            keys: Map::new(),
+            payload: String::default(),
+            proof: None,
+        }
+    }
+
+    pub fn new_request(root_commitment: OutPoint, sender: Member, state_ids: Vec<[u8; 32]>) -> Self {
+        Self {
+            prd_type: PrdType::Request,
+            root_commitment: root_commitment.to_string(),
+            sender: serde_json::to_string(&sender).unwrap(),
+            payload: serde_json::to_string(&state_ids).unwrap(),
+            ..Default::default()
+        }
+    }
+
+    pub fn extract_from_message(plain: &[u8], local_address: SilentPaymentAddress) -> Result<Self> {
+        let prd: Prd = serde_json::from_slice(plain)?;
+
+        // check that the proof is consistent
+        if let Some(proof) = prd.proof {
+            let proof_key = proof.get_key();
+            let local_spend_key = local_address.get_spend_key();
+            // If it's our own device key we abort
+            if proof_key == local_spend_key {
+                return Err(anyhow::Error::msg("Proof signed by ourselves, we are parsing our own message"));
+            }
+            // take the spending keys in sender
+            let sender: Member = serde_json::from_str(&prd.sender)?;
+            let addresses = sender.get_addresses();
+            let mut spend_keys: Vec<PublicKey> = vec![];
+            for address in addresses {
+                spend_keys.push(
+                    <SilentPaymentAddress>::try_from(address)?
+                        .get_spend_key()
+                );
+            }
+            // The key in proof must be one of the sender keys
+            let mut known_key = false;
+            for key in spend_keys {
+                if key == proof_key {
+                    known_key = true;
+                    break;
+                }
+            }
+            if !known_key {
+                return Err(anyhow::Error::msg("Proof signed with an unknown key"));
+            }
+            proof.verify()?;
+        } else {
+            log::warn!("No proof for prd with root_commitment {}", prd.root_commitment);
+        }
+        Ok(prd)
+    }
+
+    pub fn filter_keys(&mut self, to_keep: HashSet<String>) {
+        let current_keys = self.keys.clone();
+        let filtered_keys: Map<String, Value> = current_keys
+            .into_iter()
+            .filter(|(field, _)| to_keep.contains(field))
+            .collect();
+        self.keys = filtered_keys;
+    }
+
+    /// Generate the signed proof and serialize to send over the network
+    pub fn to_network_msg(&self, sp_wallet: &SpWallet) -> Result<String> {
+        let spend_sk: SecretKey = sp_wallet.get_client().get_spend_key().try_into()?;
+        let mut to_sign = self.clone(); // we sign the whole prd, incl the keys, for each recipient
+
+        let message_hash =
+            AnkHash::Message(AnkMessageHash::from_message(to_sign.to_string().as_bytes()));
+
+        let proof = Proof::new(message_hash, spend_sk);
+
+        to_sign.proof = Some(proof);
+
+        Ok(to_sign.to_string())
+    }
+
+    pub fn to_string(&self) -> String {
+        serde_json::to_string(self).unwrap()
+    }
+
+    pub fn to_value(&self) -> Value {
+        serde_json::to_value(self).unwrap()
+    }
+}

src/process.rs

@@ -0,0 +1,837 @@
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{Mutex, MutexGuard, OnceLock},
+};
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+use sp_client::bitcoin::{hex::{DisplayHex, FromHex}, OutPoint};
+use tsify::Tsify;
+
+use crate::{
+    pcd::{Member, Pcd, RoleDefinition},
+    signature::{AnkHash, AnkValidationNoHash, AnkValidationYesHash, Proof},
+    MutexExt,
+};
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi)]
+pub struct ProcessState {
+    pub commited_in: OutPoint,
+    #[tsify(type = "Record<string, string>")]
+    pub pcd_commitment: Value, // If we can't modify a field, we just copy the previous value
+    pub state_id: String, // the root of the tree created with all the commitments. Serves as an unique id for a state too
+    #[tsify(type = "Record<string, string>")]
+    pub encrypted_pcd: Value, // Some fields may be clear, if the owner of the process decides so
+    #[tsify(type = "Record<string, string>")]
+    pub keys: Map<String, Value>, // We may not always have all the keys
+    pub validation_tokens: Vec<Proof>, // Signature of the hash of the encrypted pcd tagged with some decision like "yes" or "no"
+    #[tsify(type = "Record<string, string>")]
+    pub descriptions: Map<String, Value>, // long descriptions that can be used for the ihm
+}
+
+impl ProcessState {
+    pub fn new(commited_in: OutPoint, clear_state: Map<String, Value>, descriptions: Map<String, Value>) -> anyhow::Result<Self> {
+        // Check all descriptions matches clear_state
+        for (key, _) in &descriptions {
+            clear_state.get(key).ok_or(anyhow::Error::msg("Missing field in descriptions"))?;
+        }
+
+        let mut keys = Map::new();
+        let mut encrypted = Map::new();
+
+        let clear_pcd = Value::Object(clear_state);
+        
+        let sorted_pcd = Value::Object(clear_pcd.to_sorted_key_values()?);
+
+        let pcd_commitment = Value::Object(sorted_pcd.hash_all_fields(commited_in)?);
+
+        let merkle_root = pcd_commitment.create_merkle_tree()?.root().ok_or(anyhow::Error::msg("Invalid merkle tree"))?.to_lower_hex_string();
+
+        let keys_to_encrypt: Vec<String> = pcd_commitment.as_object().unwrap().keys().map(|k| k.clone()).collect();
+        sorted_pcd.encrypt_fields(&keys_to_encrypt, &mut keys, &mut encrypted)?;
+
+        let res = Self {
+            commited_in,
+            pcd_commitment,
+            state_id: merkle_root,
+            encrypted_pcd: Value::Object(encrypted),
+            keys,
+            validation_tokens: vec![],
+            descriptions,
+        };
+        
+        Ok(res)
+    }
+
+    pub fn update_value(&mut self, key: &str, new_value: Value) -> anyhow::Result<()> {
+        // First decrypt values
+        let mut clear_pcd = self.decrypt_pcd()?;
+        if let Some(value) = clear_pcd.get_mut(key) {
+            // We can only update a value we can decrypt
+            if let None = self.keys.get(key) {
+                return Err(anyhow::Error::msg("Trying to update a value we can't access"));
+            }
+            // We replace the clear value by the new_value
+            *value = new_value;
+        } else {
+            return Err(anyhow::Error::msg(format!("{} doesn't exist", key)))
+        }
+
+        // Update the commitment
+        self.pcd_commitment = Value::Object(Value::Object(clear_pcd.clone()).hash_all_fields(self.commited_in)?);
+
+        // Todo for now we rehash everything, which is a bit wasteful but fine for a proto
+
+        // Update the encrypted value
+        Value::Object(clear_pcd).encrypt_fields(&[key.to_string()], &mut self.keys, self.encrypted_pcd.as_object_mut().unwrap())?;
+        
+        Ok(())
+    }
+
+    /// Return a decrypted version of the pcd in this state
+    /// 3 outputs possible for each field:
+    /// 1) We have the key and we return the decrypted value
+    /// 2) We don't have the key, we return the commitment
+    /// 3) the field is unencrypted, we leave it as sit is
+    pub fn decrypt_pcd(&self) -> anyhow::Result<Map<String, Value>> {
+        let mut fields2plain = Map::new();
+        let fields2commit = self.pcd_commitment.to_value_object()?;
+        self.encrypted_pcd.decrypt_all(self.commited_in, &fields2commit, &self.keys, &mut fields2plain)?;
+        Ok(fields2plain)
+    }
+
+    pub fn get_message_hash(&self, approval: bool) -> anyhow::Result<AnkHash> {
+        let merkle_root = <Value as Pcd>::create_merkle_tree(&self.pcd_commitment)?.root().unwrap();
+        if approval {
+            Ok(AnkHash::ValidationYes(AnkValidationYesHash::from_merkle_root(merkle_root)))
+        } else {
+            Ok(AnkHash::ValidationNo(AnkValidationNoHash::from_merkle_root(merkle_root)))
+        }
+    }
+
+    fn list_modified_fields(&self, previous_state: Option<&ProcessState>) -> Vec<String> {
+        let new_state = &self.pcd_commitment;
+
+        // Ensure the new state is a JSON object
+        let new_state_commitments = new_state
+            .as_object()
+            .expect("New state should be a JSON object");
+
+        if let Some(prev_state) = previous_state {
+            // Previous state exists; compute differences
+            let previous_state_commitments = prev_state
+                .pcd_commitment
+                .as_object()
+                .expect("Previous state should be a JSON object");
+
+            // Compute modified fields by comparing with previous state
+            new_state_commitments
+                .iter()
+                .filter_map(|(key, value)| {
+                    let previous_value = previous_state_commitments.get(key);
+                    if previous_value.is_none() || value != previous_value.unwrap() {
+                        Some(key.clone())
+                    } else {
+                        None
+                    }
+                })
+                .collect()
+        } else {
+            // No previous state; all fields are considered modified
+            new_state_commitments.keys().cloned().collect()
+        }
+    }
+
+    pub fn is_valid(&self, previous_state: Option<&ProcessState>) -> anyhow::Result<()> {
+        if self.validation_tokens.is_empty() {
+            return Err(anyhow::anyhow!(
+                "Can't validate a state with no proofs attached"
+            ));
+        }
+
+        // Compute modified fields
+        let modified_fields = self.list_modified_fields(previous_state);
+
+        if modified_fields.is_empty() {
+            return Err(anyhow::anyhow!("State is identical to the previous state"));
+        }
+
+        let roles2rules = match self.encrypted_pcd.extract_roles() {
+            Ok(roles) => roles,
+            Err(_) => {
+                let mut fields2plains = Map::new();
+                let fields2commit = self.pcd_commitment.as_object().ok_or(anyhow::Error::msg("pcd_commitment is not an object"))?;
+                self.encrypted_pcd
+                    .decrypt_all(self.commited_in, &fields2commit, &self.keys, &mut fields2plains)?;
+
+                Value::Object(fields2plains).extract_roles()?
+            }
+        };
+
+
+        // Check if each modified field satisfies at least one applicable rule across all roles
+        let all_fields_validated = modified_fields.iter().all(|field| {
+            // Collect applicable rules from all roles for the current field
+            let applicable_roles: Vec<RoleDefinition> = roles2rules
+                .iter()
+                .filter_map(|(_, role_def)| {
+                    let mut filtered_role_def = role_def.clone();
+                    let rules = filtered_role_def.get_applicable_rules(field);
+                    filtered_role_def.validation_rules =
+                        rules.into_iter().map(|r| r.clone()).collect();
+                    if filtered_role_def.validation_rules.is_empty() {
+                        None
+                    } else {
+                        Some(filtered_role_def)
+                    }
+                })
+                .collect();
+
+            if applicable_roles.is_empty() {
+                return false; // No rules apply to this field, consider it invalid
+            }
+
+            let mut merkle_root = [0u8; 32];
+            merkle_root.copy_from_slice(&Vec::from_hex(&self.state_id).unwrap());
+
+            applicable_roles.into_iter().any(|role_def| {
+                role_def.validation_rules.iter().any(|rule| {
+                    rule.is_satisfied(
+                        field,
+                        merkle_root,
+                        &self.validation_tokens,
+                        &role_def.members,
+                    ).is_ok()
+                })
+            })
+        });
+
+        if all_fields_validated {
+            Ok(())
+        } else {
+            Err(anyhow::anyhow!("Not enough valid proofs"))
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.encrypted_pcd == Value::Null || 
+            self.pcd_commitment == Value::Null
+    }
+
+    pub fn get_fields_to_validate_for_member(&self, member: &Member) -> anyhow::Result<Vec<String>> {
+        let decrypted = self.decrypt_pcd()?;
+
+        let roles = Value::Object(decrypted).extract_roles()?;
+
+        let mut res: HashSet<String> = HashSet::new();
+
+        // Are we in that role?
+        for (_, role_def) in roles {
+            if !role_def.members.contains(member) {
+                continue;
+            } else {
+                // what are the fields we can modify?
+                for rule in role_def.validation_rules {
+                    if rule.allows_modification() {
+                        res.extend(rule.fields.iter().map(|f| f.clone()));
+                    }
+                }
+            }
+        }
+
+        Ok(res.into_iter().collect())
+    }
+}
+
+/// A process is basically a succession of states
+/// The latest state MUST be an empty state with only the commited_in field set at the last unspent outpoint
+#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi)]
+pub struct Process {
+    states: Vec<ProcessState>,
+}
+
+impl Process {
+    pub fn new(
+        commited_in: OutPoint
+    ) -> Self {
+        let empty_state = ProcessState {
+            commited_in,
+            ..Default::default()
+        };
+        Self {
+            states: vec![empty_state],
+        }
+    }
+
+    pub fn get_process_id(&self) -> anyhow::Result<OutPoint> {
+        Ok(self.states.get(0).ok_or(anyhow::Error::msg("Empty state list"))?.commited_in)
+    }
+
+    pub fn get_last_unspent_outpoint(&self) -> anyhow::Result<OutPoint> {
+        if self.states.is_empty() { return Err(anyhow::Error::msg("Empty Process")); }
+        let last_state = self.states.last().unwrap();
+        Ok(last_state.commited_in)
+    }
+
+    pub fn update_states_tip(&mut self, new_commitment: OutPoint) -> anyhow::Result<()> {
+        if self.states.is_empty() { return Err(anyhow::Error::msg("Empty Process")); }
+        let last_value = self.states.last().unwrap();
+        if !last_value.is_empty() {
+            return Err(anyhow::Error::msg("Last value should be empty"));
+        }
+        if last_value.commited_in == new_commitment {
+            return Err(anyhow::Error::msg("new_commitment is the same than existing tip"));
+        }
+
+        // Before updating we make sure that we only have one concurrent state
+        let concurrent_states = self.get_latest_concurrent_states()?;
+        if concurrent_states.len() != 2 {
+            return Err(anyhow::Error::msg("We must have exactly one state for the current tip"));
+        }
+
+        // Replace the existing tip
+        let new_tip = ProcessState {
+            commited_in: new_commitment,
+            ..Default::default()
+        };
+        let _ = self.states.pop().unwrap();
+        self.states.push(new_tip);
+
+        Ok(())
+    }
+
+    /// We want to insert a new state that would be commited by the last UTXO
+    /// The new state *must* have the same commited_in than the last empty one
+    /// We want to always keep an empty state with only the latest unspent commited_in value at the last position
+    pub fn insert_concurrent_state(&mut self, new_state: ProcessState) -> anyhow::Result<()> {
+        if self.states.is_empty() { return Err(anyhow::Error::msg("Empty Process")); }
+        let last_value = self.states.last().unwrap();
+        if !last_value.is_empty() {
+            return Err(anyhow::Error::msg("Last value should be empty"));
+        }
+        if last_value.commited_in != new_state.commited_in {
+            return Err(anyhow::Error::msg("A concurrent state must have the same commited in than the tip of the states"));
+        }
+        let empty_state = self.states.pop().unwrap();
+        self.states.push(new_state);
+        // We always keep an empty state at the end
+        self.states.push(empty_state);
+        Ok(())
+    }
+
+    pub fn get_state_at(&self, index: usize) -> Option<&ProcessState> {
+        self.states.get(index)
+    }
+
+    pub fn get_state_at_mut(&mut self, index: usize) -> Option<&mut ProcessState> {
+        self.states.get_mut(index)
+    }
+
+    pub fn get_latest_state(&self) -> Option<&ProcessState> {
+        self.states.last()
+    }
+
+    pub fn get_latest_state_mut(&mut self) -> Option<&mut ProcessState> {
+        self.states.last_mut()
+    }
+
+    pub fn get_previous_state(&self, current_state: &ProcessState) -> Option<&ProcessState> {
+        // Find the index of the current state
+        let current_index = self
+            .states
+            .iter()
+            .position(|state| state == current_state)?;
+
+        // Check if there is a previous state
+        if current_index > 0 {
+            // Create a new Process with the previous state
+            let previous_state = self.get_state_at(current_index - 1).unwrap();
+            Some(&previous_state)
+        } else {
+            None // No previous state exists
+        }
+    }
+
+    pub fn get_state_for_id(&self, state_id: &str) -> anyhow::Result<&ProcessState> {
+        if self.get_number_of_states() == 0 {
+            // This should never happen, but we better get rid of it now
+            return Err(anyhow::Error::msg("process is empty".to_owned()));
+        }
+
+        for p in self.get_latest_concurrent_states()? {
+            if state_id == p.state_id.as_str() { 
+                return Ok(p);
+            }
+        }
+
+        return Err(anyhow::Error::msg("No state for this merkle root"));
+    }
+
+    pub fn get_state_for_id_mut(&mut self, state_id: &str) -> anyhow::Result<&mut ProcessState> {
+        if self.get_number_of_states() == 0 {
+            // This should never happen, but we better get rid of it now
+            return Err(anyhow::Error::msg("process is empty".to_owned()));
+        }
+
+        for p in self.get_latest_concurrent_states_mut()? {
+            if state_id == p.state_id.as_str() { 
+                return Ok(p);
+            }
+        }
+
+        return Err(anyhow::Error::msg("No state for this merkle root"));
+    }
+
+    /// This is useful when multiple unvalidated states are pending waiting for enough validations
+    /// It returns the latest state and all the previous states that have the same commited_in
+    /// It means that all the returned states are unvalidated and except for the one that get validated they will be pruned
+    pub fn get_latest_concurrent_states(&self) -> anyhow::Result<Vec<&ProcessState>> {
+        if self.get_number_of_states() == 0 {
+            // This should never happen, but we better get rid of it now
+            return Err(anyhow::Error::msg("process is empty".to_owned()));
+        }
+
+        let mut states = vec![];
+        let mut previous_commited_in = OutPoint::null();
+        // We iterate backwards until we find a state that has a different commited_in
+        for state in self.states.iter().rev() {
+            if previous_commited_in == OutPoint::null() {
+                previous_commited_in = state.commited_in;
+            } else if previous_commited_in != state.commited_in {
+                break;
+            }
+            states.push(state);
+        }
+
+        Ok(states)
+    }
+
+    pub fn get_latest_concurrent_states_mut(&mut self) -> anyhow::Result<Vec<&mut ProcessState>> {
+        if self.get_number_of_states() == 0 {
+            // This should never happen, but we better get rid of it now
+            return Err(anyhow::Error::msg("process is empty".to_owned()));
+        }
+
+        let mut states = vec![];
+        let mut previous_commited_in = OutPoint::null();
+        // We iterate backwards until we find a state that has a different commited_in
+        for state in self.states.iter_mut().rev() {
+            if previous_commited_in == OutPoint::null() {
+                previous_commited_in = state.commited_in;
+            } else if previous_commited_in != state.commited_in {
+                break;
+            }
+            states.push(state);
+        }
+
+        Ok(states)
+    }
+
+    pub fn remove_all_concurrent_states(&mut self) -> anyhow::Result<Vec<ProcessState>> {
+        if self.get_number_of_states() == 0 {
+            // This should never happen, but we better get rid of it now
+            return Err(anyhow::Error::msg("process is empty".to_owned()));
+        }
+
+        let empty_state = self.states.pop().unwrap();
+        let last_commitment_outpoint = empty_state.commited_in;
+        let split_index = self.states.iter().position(|state| state.commited_in == last_commitment_outpoint).unwrap();
+
+        let removed = self.states.split_off(split_index);
+
+        // We make sure we always have an empty state at the end
+        self.states.push(empty_state);
+
+        Ok(removed)
+    }
+
+    pub fn get_latest_commited_state(&self) -> Option<&ProcessState> {
+        if self.states.is_empty() {
+            return None;
+        }
+
+        let last_state = self.states.last().unwrap();
+
+        debug_assert!(last_state.is_empty()); // Last state must always be empty
+
+        // We look for the last commited in before all the pending states
+        let latest_outpoint = last_state.commited_in;
+
+        return self
+            .states
+            .iter()
+            .rev()
+            .find(|s| s.commited_in != latest_outpoint);
+    }
+
+    pub fn get_state_index(&self, state: &ProcessState) -> Option<usize> {
+        // Get the commited_in value of the provided state
+        let target_commited_in = state.commited_in;
+
+        // Find the index of the first state with the same commited_in value
+        self.states
+            .iter()
+            .position(|s| s.commited_in == target_commited_in)
+    }
+
+    pub fn get_number_of_states(&self) -> usize {
+        self.states.len()
+    }
+}
+
+pub static CACHEDPROCESSES: OnceLock<Mutex<HashMap<OutPoint, Process>>> = OnceLock::new();
+
+pub fn lock_processes() -> Result<MutexGuard<'static, HashMap<OutPoint, Process>>, anyhow::Error> {
+    CACHEDPROCESSES
+        .get_or_init(|| Mutex::new(HashMap::new()))
+        .lock_anyhow()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use serde_json::json;
+    use sp_client::{
+        bitcoin::{secp256k1::SecretKey, Network}, silentpayments::utils::SilentPaymentAddress, spclient::{SpClient, SpWallet, SpendKey}
+    };
+
+    use crate::pcd::{Member, ValidationRule};
+
+    use super::*;
+
+    fn create_alice_wallet() -> SpWallet {
+        SpWallet::new(
+            SpClient::new(
+                "default".to_owned(),
+                SecretKey::from_str(
+                    "a67fb6bf5639efd0aeb19c1c584dd658bceda87660ef1088d4a29d2e77846973",
+                )
+                .unwrap(),
+                SpendKey::Secret(
+                    SecretKey::from_str(
+                        "a1e4e7947accf33567e716c9f4d186f26398660e36cf6d2e711af64b3518e65c",
+                    )
+                    .unwrap(),
+                ),
+                None,
+                Network::Signet,
+            )
+            .unwrap(),
+            None,
+            vec![],
+        )
+        .unwrap()
+    }
+
+    fn create_bob_wallet() -> SpWallet {
+        SpWallet::new(
+            SpClient::new(
+                "default".to_owned(),
+                SecretKey::from_str(
+                    "4d9f62b2340de3f0bafd671b78b19edcfded918c4106baefd34512f12f520e9b",
+                )
+                .unwrap(),
+                SpendKey::Secret(
+                    SecretKey::from_str(
+                        "dafb99602721577997a6fe3da54f86fd113b1b58f0c9a04783d486f87083a32e",
+                    )
+                    .unwrap(),
+                ),
+                None,
+                Network::Signet,
+            )
+            .unwrap(),
+            None,
+            vec![],
+        )
+        .unwrap()
+    }
+
+    fn create_carol_wallet() -> SpWallet {
+        SpWallet::new(
+            SpClient::new(
+                "default".to_owned(),
+                SecretKey::from_str(
+                    "e4a5906eaa1a7ab24d5fc8d9b600d47f79caa6511c056c111677b7a33e62c5e9",
+                )
+                .unwrap(),
+                SpendKey::Secret(
+                    SecretKey::from_str(
+                        "e4c282e14668af1435e39df78403a7b406a791e3c6e666295496a6a865ade162",
+                    )
+                    .unwrap(),
+                ),
+                None,
+                Network::Signet,
+            )
+            .unwrap(),
+            None,
+            vec![],
+        )
+        .unwrap()
+    }
+
+    fn dummy_process_state() -> ProcessState {
+        let alice_wallet = create_alice_wallet();
+        let bob_wallet = create_bob_wallet();
+        let carol_wallet = create_carol_wallet();
+
+        let alice_address =
+            SilentPaymentAddress::try_from(alice_wallet.get_client().get_receiving_address())
+                .unwrap();
+        let bob_address =
+            SilentPaymentAddress::try_from(bob_wallet.get_client().get_receiving_address())
+                .unwrap();
+        let carol_address =
+            SilentPaymentAddress::try_from(carol_wallet.get_client().get_receiving_address())
+                .unwrap();
+
+        let alice_bob = Member::new(vec![alice_address, bob_address]).unwrap();
+        let carol = Member::new(vec![carol_address]).unwrap();
+
+        let validation_rule1 =
+            ValidationRule::new(1.0, vec!["field1".to_owned(), "roles".to_owned()], 0.5).unwrap();
+        let validation_rule2 = ValidationRule::new(1.0, vec!["field2".to_owned()], 0.5).unwrap();
+
+        let role_def1 = RoleDefinition {
+            members: vec![alice_bob],
+            validation_rules: vec![validation_rule1],
+            storages: vec![]
+        };
+        let role_def2 = RoleDefinition {
+            members: vec![carol],
+            validation_rules: vec![validation_rule2],
+            storages: vec![]
+        };
+
+        let clear_pcd = json!({
+            "field1": "value1",
+            "field2": "value2",
+            "roles": {
+                "role1": role_def1,
+                "role2": role_def2
+            }
+        });
+
+        let outpoint = OutPoint::null();
+
+        ProcessState::new(outpoint, clear_pcd.as_object().unwrap().clone(), Map::new()).unwrap()
+    }
+
+    #[test]
+    fn test_error_no_proofs() {
+        let state = dummy_process_state();
+        let result = state.is_valid(None);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Can't validate a state with no proofs attached"
+        );
+    }
+
+    #[test]
+    fn test_error_identical_previous_state() {
+        let mut state = dummy_process_state();
+        // We sign with a random key
+        let signing_key =
+            SecretKey::from_str("39b2a765dc93e02da04a0e9300224b4f99fa7b83cfae49036dff58613fd3277c")
+                .unwrap();
+        let message_hash = state.get_message_hash(true).unwrap();
+        state.validation_tokens.push(Proof::new(message_hash, signing_key));
+        let result = state.is_valid(Some(&state));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "State is identical to the previous state"
+        );
+    }
+
+    #[test]
+    /// We provide a proof signed with a key that is not the spending key for either alice or bob
+    fn test_error_invalid_proof() {
+        let mut state = dummy_process_state();
+        // We sign with a random key
+        let signing_key =
+            SecretKey::from_str("39b2a765dc93e02da04a0e9300224b4f99fa7b83cfae49036dff58613fd3277c")
+                .unwrap();
+        let message_hash = state.get_message_hash(true).unwrap();
+        state.validation_tokens.push(Proof::new(message_hash, signing_key));
+        let result = state.is_valid(None);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err().to_string(), "Not enough valid proofs");
+    }
+
+    #[test]
+    /// Carol signs alone for an init state
+    fn test_error_not_enough_signatures() {
+        let mut state = dummy_process_state();
+        // We sign with Carol key
+        let carol_key: SecretKey = create_carol_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let message_hash = state.get_message_hash(true).unwrap();
+        state.validation_tokens.push(Proof::new(message_hash, carol_key));
+        let result = state.is_valid(None);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err().to_string(), "Not enough valid proofs");
+    }
+
+    #[test]
+    /// Alice signs alone for her fields in an init state
+    fn test_valid_just_enough_signatures() {
+        let mut state = dummy_process_state();
+        // We sign with Alice and Carol keys
+        let alice_key: SecretKey = create_alice_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let carol_key: SecretKey = create_carol_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let message_hash = state.get_message_hash(true).unwrap();
+        state.validation_tokens.push(Proof::new(message_hash, alice_key));
+        state.validation_tokens.push(Proof::new(message_hash, carol_key));
+        let result = state.is_valid(None);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    /// everyone signs for everything
+    fn test_valid_all_signatures() {
+        let mut state = dummy_process_state();
+        let alice_key: SecretKey = create_alice_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let bob_key: SecretKey = create_bob_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let carol_key: SecretKey = create_carol_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let message_hash = state.get_message_hash(true).unwrap();
+        state.validation_tokens.push(Proof::new(message_hash, alice_key));
+        state.validation_tokens.push(Proof::new(message_hash, bob_key));
+        state.validation_tokens.push(Proof::new(message_hash, carol_key));
+        let result = state.is_valid(None);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    /// Carol refuses change for her part
+    fn test_error_carol_votes_no() {
+        let mut state = dummy_process_state();
+        let alice_key: SecretKey = create_alice_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let bob_key: SecretKey = create_bob_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let carol_key: SecretKey = create_carol_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let message_hash_yes = state.get_message_hash(true).unwrap();
+        let message_hash_no = state.get_message_hash(false).unwrap();
+        state.validation_tokens.push(Proof::new(message_hash_yes, alice_key));
+        state.validation_tokens.push(Proof::new(message_hash_yes, bob_key));
+        state.validation_tokens.push(Proof::new(message_hash_no, carol_key));
+        let result = state.is_valid(None);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err().to_string(), "Not enough valid proofs");
+    }
+
+    #[test]
+    /// Bob refuses change for his part, but Alice is enough to reach quorum
+    fn test_valid_bob_votes_no() {
+        let mut state = dummy_process_state();
+        let alice_key: SecretKey = create_alice_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let bob_key: SecretKey = create_bob_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let carol_key: SecretKey = create_carol_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let message_hash_yes = state.get_message_hash(true).unwrap();
+        let message_hash_no = state.get_message_hash(false).unwrap();
+        state.validation_tokens.push(Proof::new(message_hash_yes, alice_key));
+        state.validation_tokens.push(Proof::new(message_hash_no, bob_key));
+        state.validation_tokens.push(Proof::new(message_hash_yes, carol_key));
+        let result = state.is_valid(None);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    /// Everyone signs, and we have a previous state
+    fn test_valid_everyone_signs_with_prev_state() {
+        let state = dummy_process_state();
+        let mut new_state = state.clone();
+        let key_to_modify = state.encrypted_pcd.as_object().unwrap().keys().next().unwrap();
+        new_state.update_value(key_to_modify.as_str(), Value::String("new_value1".to_string())).unwrap();
+        let alice_key: SecretKey = create_alice_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let bob_key: SecretKey = create_bob_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let carol_key: SecretKey = create_carol_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let message_hash = new_state.get_message_hash(true).unwrap();
+        new_state.validation_tokens.push(Proof::new(message_hash, alice_key));
+        new_state.validation_tokens.push(Proof::new(message_hash, bob_key));
+        new_state.validation_tokens.push(Proof::new(message_hash, carol_key));
+        let result = new_state.is_valid(Some(&state));
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    /// Only Carol signs, but she doesn't have modification rights on modified field
+    fn test_error_not_right_signatures_with_prev_state() {
+        let state = dummy_process_state();
+        let mut new_state = state.clone();
+        let key_to_modify = state.encrypted_pcd.as_object().unwrap().keys().next().unwrap();
+        new_state.update_value(key_to_modify.as_str(), Value::String("new_value1".to_string())).unwrap();
+        let carol_key: SecretKey = create_carol_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let message_hash = new_state.get_message_hash(true).unwrap();
+        new_state.validation_tokens.push(Proof::new(message_hash, carol_key));
+        let result = new_state.is_valid(Some(&state));
+        assert!(result.is_err());
+    }
+}

src/secrets.rs

@@ -0,0 +1,173 @@
+use anyhow::{Result, Error};
+use tsify::Tsify;
+use crate::aes_gcm::aead::{Aead, Payload};
+use crate::aes_gcm::Nonce;
+use crate::sp_client::bitcoin::hashes::Hash;
+use crate::sp_client::silentpayments::utils::SilentPaymentAddress;
+use crate::crypto::{Aes256Gcm, AnkSharedSecretHash, KeyInit, AAD};
+use crate::log;
+use serde::ser::SerializeStruct;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::collections::HashMap;
+use std::str::FromStr;
+
+#[derive(Debug, Clone, Default, PartialEq, Tsify)]
+#[tsify(into_wasm_abi)]
+pub struct SecretsStore{
+    shared_secrets: HashMap<SilentPaymentAddress, AnkSharedSecretHash>,
+    unconfirmed_secrets: Vec<AnkSharedSecretHash>
+}
+
+impl Serialize for SecretsStore {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut temp_map = HashMap::with_capacity(self.shared_secrets.len());
+        for (key, value) in &self.shared_secrets {
+            let key_str = key.to_string(); 
+            let value_str = value.to_string();
+
+            temp_map.insert(key_str, value_str);
+        }
+
+        let mut state = serializer.serialize_struct("SecretsStore", 2)?;
+        state.serialize_field("shared_secrets", &temp_map)?;
+
+        let unconfirmed_secrets_hex: Vec<String> = self
+            .unconfirmed_secrets
+            .iter()
+            .map(|secret| secret.to_string())
+            .collect();
+        state.serialize_field("unconfirmed_secrets", &unconfirmed_secrets_hex)?;
+
+        state.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for SecretsStore {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        // Deserialize the structure as a map
+        #[derive(Deserialize)]
+        struct SecretsStoreHelper {
+            shared_secrets: HashMap<String, String>,
+            unconfirmed_secrets: Vec<String>,
+        }
+
+        let helper = SecretsStoreHelper::deserialize(deserializer)?;
+
+        let mut shared_secrets = HashMap::with_capacity(helper.shared_secrets.len());
+        for (key_str, value_str) in helper.shared_secrets {
+            let key = SilentPaymentAddress::try_from(key_str).map_err(serde::de::Error::custom)?; // Convert String to SilentPaymentAddress
+            let value = AnkSharedSecretHash::from_str(&value_str).map_err(serde::de::Error::custom)?; // Convert hex string back to Vec<u8>
+
+            shared_secrets.insert(key, value);
+        }
+
+        let mut unconfirmed_secrets = Vec::with_capacity(helper.unconfirmed_secrets.len());
+        for secret_str in helper.unconfirmed_secrets {
+            let secret_bytes = AnkSharedSecretHash::from_str(&secret_str).map_err(serde::de::Error::custom)?;
+            unconfirmed_secrets.push(secret_bytes);
+        }
+
+        Ok(SecretsStore {
+            shared_secrets,
+            unconfirmed_secrets,
+        })
+    }
+}
+
+impl SecretsStore {
+    pub fn new() -> Self {
+        Self { 
+            shared_secrets: HashMap::new(), 
+            unconfirmed_secrets: Vec::new() 
+        }
+    }
+
+    pub fn add_unconfirmed_secret(&mut self, new_secret: AnkSharedSecretHash) {
+        self.unconfirmed_secrets.push(new_secret);
+    }
+
+    /// Returns the previous secret for this address, if any
+    pub fn confirm_secret_for_address(&mut self, secret: AnkSharedSecretHash, address: SilentPaymentAddress) -> Option<AnkSharedSecretHash> {
+        if let Some(pos) = self.unconfirmed_secrets.iter()
+            .position(|s| *s == secret)
+        {
+            self.shared_secrets.insert(address, self.unconfirmed_secrets.swap_remove(pos))
+        } else {
+            // We didn't know about that secret, just add it
+            // TODO if we already had a secret for this address we just replace it for now
+            self.shared_secrets.insert(address, secret)
+        }
+    }
+
+    pub fn get_secret_for_address(&self, address: SilentPaymentAddress) -> Option<&AnkSharedSecretHash> {
+        self.shared_secrets.get(&address)
+    }
+
+    pub fn get_all_confirmed_secrets(&self) -> HashMap<SilentPaymentAddress, AnkSharedSecretHash> {
+        self.shared_secrets.clone()
+    }
+
+    pub fn get_all_unconfirmed_secrets(&self) -> Vec<AnkSharedSecretHash> {
+        self.unconfirmed_secrets.clone()
+    }
+
+    pub fn remove_secret_for_address(&mut self, address: SilentPaymentAddress) -> Result<(SilentPaymentAddress, AnkSharedSecretHash)> {
+        if let Some(removed_secret) = self.shared_secrets.remove(&address) {
+            return Ok((address, removed_secret));
+        } else {
+            return Err(Error::msg("Secret doesn't exist"));
+        }
+    }
+
+    pub fn remove_unconfirmed_secret(&mut self, secret: AnkSharedSecretHash) -> Result<()> {
+        if let Some(i) = self.unconfirmed_secrets.iter().position(|s| *s == secret) {
+            self.unconfirmed_secrets.swap_remove(i);
+            Ok(())
+        } else {
+            Err(Error::msg("Unknown secret"))
+        }
+    }
+
+    pub fn try_decrypt(&self, cipher: &[u8]) -> Result<(AnkSharedSecretHash, Vec<u8>)> {
+        let nonce = Nonce::from_slice(&cipher[..12]);
+
+        for (address, secret) in self.shared_secrets.iter() {
+            log::debug!("Attempting decryption with key {} for {}", secret, address);
+            let engine = Aes256Gcm::new(secret.as_byte_array().into());
+
+            if let Ok(plain) = engine.decrypt(
+                &nonce,
+                Payload {
+                    msg: &cipher[12..],
+                    aad: AAD,
+                },
+            ) {
+                return Ok((*secret, plain));
+            }
+        }
+
+        // We try unconfirmed secrets
+        for secret in self.unconfirmed_secrets.iter() {
+            log::debug!("Attempting decryption with unconfirmed key {}", secret);
+            let engine = Aes256Gcm::new(secret.as_byte_array().into());
+
+            if let Ok(plain) = engine.decrypt(
+                &nonce,
+                Payload {
+                    msg: &cipher[12..],
+                    aad: AAD,
+                },
+            ) {
+                return Ok((*secret, plain));
+            }
+        }
+
+        Err(Error::msg("Failed to decrypt message"))
+    }
+}

src/signature.rs

@@ -0,0 +1,119 @@
+use anyhow::Result;
+use rand::{thread_rng, RngCore};
+use serde::{Deserialize, Serialize};
+use sp_client::bitcoin::hashes::{sha256t_hash_newtype, Hash, HashEngine};
+use sp_client::bitcoin::key::Secp256k1;
+use sp_client::bitcoin::secp256k1::schnorr::Signature;
+use sp_client::bitcoin::secp256k1::{Keypair, Message, PublicKey, SecretKey};
+
+sha256t_hash_newtype! {
+    pub struct AnkMessageTag = hash_str("4nk/Message");
+
+    #[hash_newtype(forward)]
+    pub struct AnkMessageHash(_);
+
+    pub struct AnkValidationYesTag = hash_str("4nk/yes");
+
+    #[hash_newtype(forward)]
+    pub struct AnkValidationYesHash(_);
+
+    pub struct AnkValidationNoTag = hash_str("4nk/no");
+
+    #[hash_newtype(forward)]
+    pub struct AnkValidationNoHash(_);
+}
+
+impl AnkMessageHash {
+    pub fn from_message(message: &[u8]) -> Self {
+        let mut eng = AnkMessageHash::engine();
+        eng.input(&message);
+        AnkMessageHash::from_engine(eng)
+    }
+}
+
+impl AnkValidationYesHash {
+    pub fn from_merkle_root(merkle_root: [u8; 32]) -> Self {
+        let mut eng = AnkValidationYesHash::engine();
+        eng.input(&merkle_root);
+        AnkValidationYesHash::from_engine(eng)
+    }
+}
+
+impl AnkValidationNoHash {
+    pub fn from_merkle_root(merkle_root: [u8; 32]) -> Self {
+        let mut eng = AnkValidationNoHash::engine();
+        eng.input(&merkle_root);
+        AnkValidationNoHash::from_engine(eng)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub enum AnkHash {
+    Message(AnkMessageHash),
+    ValidationYes(AnkValidationYesHash),
+    ValidationNo(AnkValidationNoHash),
+}
+
+impl AnkHash {
+    pub fn to_byte_array(&self) -> [u8; 32] {
+        match self {
+            AnkHash::Message(hash) => hash.to_byte_array(),
+            AnkHash::ValidationYes(hash) => hash.to_byte_array(),
+            AnkHash::ValidationNo(hash) => hash.to_byte_array(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub struct Proof {
+    signature: Signature,
+    message: [u8; 32],
+    key: PublicKey,
+}
+
+impl Proof {
+    pub fn new(message_hash: AnkHash, signing_key: SecretKey) -> Self {
+        let secp = Secp256k1::signing_only();
+
+        let keypair = Keypair::from_secret_key(&secp, &signing_key);
+
+        let mut aux_rand = [0u8; 32];
+
+        thread_rng().fill_bytes(&mut aux_rand);
+
+        let sig = secp.sign_schnorr_with_aux_rand(
+            &Message::from_digest(message_hash.to_byte_array()),
+            &keypair,
+            &aux_rand,
+        );
+
+        Self {
+            signature: sig,
+            message: message_hash.to_byte_array(),
+            key: keypair.public_key(),
+        }
+    }
+
+    pub fn get_key(&self) -> PublicKey {
+        self.key
+    }
+
+    pub fn get_message(&self) -> [u8; 32] {
+        self.message
+    }
+
+    pub fn verify(&self) -> Result<()> {
+        let secp = Secp256k1::verification_only();
+        secp.verify_schnorr(
+            &self.signature,
+            &Message::from_digest(self.message),
+            &self.key.x_only_public_key().0,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn to_string(&self) -> String {
+        serde_json::to_string(self).unwrap()
+    }
+}

src/silentpayments.rs

@@ -0,0 +1,416 @@
+use std::collections::{HashMap, HashSet};
+use std::str::FromStr;
+
+use anyhow::{Error, Result};
+
+use rand::{thread_rng, Rng};
+use sp_client::bitcoin::consensus::deserialize;
+use sp_client::bitcoin::psbt::raw;
+use sp_client::bitcoin::{Amount, OutPoint, Psbt};
+use sp_client::constants::{
+    self, DUST_THRESHOLD, PSBT_SP_ADDRESS_KEY, PSBT_SP_PREFIX, PSBT_SP_SUBTYPE,
+};
+use sp_client::silentpayments::utils::SilentPaymentAddress;
+use sp_client::spclient::{OwnedOutput, Recipient, SpClient, SpWallet};
+
+pub fn create_transaction(
+    mandatory_inputs: Vec<OutPoint>,
+    freezed_utxos: &HashSet<OutPoint>,
+    sp_wallet: &SpWallet,
+    mut recipients: Vec<Recipient>,
+    payload: Option<Vec<u8>>,
+    fee_rate: Amount,
+    fee_payer: Option<String>, // None means sender pays everything
+) -> Result<Psbt> {
+    let mut available_outpoints: HashMap<OutPoint, OwnedOutput> = sp_wallet
+        .get_outputs()
+        .to_spendable_list()
+        // filter out freezed utxos
+        .into_iter()
+        .filter(|(outpoint, _)| !freezed_utxos.contains(outpoint))
+        .collect();
+
+    // if we have a payload, it means we are notifying, so let's add a revokation output
+    if payload.is_some() {
+        recipients.push(Recipient {
+            address: sp_wallet.get_client().get_receiving_address(),
+            amount: DUST_THRESHOLD,
+            nb_outputs: 1,
+        })
+    }
+
+    let sum_outputs = recipients
+        .iter()
+        .fold(Amount::from_sat(0), |acc, x| acc + x.amount);
+
+    let zero_value_recipient = recipients
+        .iter_mut()
+        .find(|r| r.amount == Amount::from_sat(0));
+
+    let mut inputs: HashMap<OutPoint, OwnedOutput> = HashMap::new();
+    let mut total_available = Amount::from_sat(0);
+    for outpoint in mandatory_inputs {
+        let (must_outpoint, must_output) = available_outpoints
+            .remove_entry(&outpoint)
+            .ok_or_else(|| Error::msg(format!("Mandatory outpoint unknown: {}", outpoint)))?;
+        total_available += must_output.amount;
+        inputs.insert(must_outpoint, must_output);
+    }
+
+    let fee_provision = sum_outputs.checked_div(10).unwrap();
+
+    for (outpoint, output) in available_outpoints {
+        if total_available > sum_outputs.checked_add(fee_provision).unwrap() {
+            break;
+        }
+        total_available += output.amount;
+        inputs.insert(outpoint, output);
+    }
+
+    if total_available <= sum_outputs.checked_add(fee_provision).unwrap() {
+        return Err(Error::msg("Not enough available funds"));
+    }
+
+    if let Some(recipient) = zero_value_recipient {
+        // update the amount for the recipient
+        recipient.amount = total_available;
+    }
+
+    let mut commitment = [0u8; 32];
+    if let Some(ref p) = payload {
+        commitment.copy_from_slice(&p);
+    } else {
+        thread_rng().fill(&mut commitment);
+    }
+
+    let mut new_psbt =
+        sp_wallet
+            .get_client()
+            .create_new_psbt(inputs, recipients, Some(&commitment))?;
+
+    let sender_address = sp_wallet.get_client().get_receiving_address();
+    let change_address = sp_wallet.get_client().sp_receiver.get_change_address();
+    if let Some(address) = fee_payer {
+        SpClient::set_fees(&mut new_psbt, fee_rate, address)?;
+    } else {
+        let candidates: Vec<Option<String>> = new_psbt
+            .outputs
+            .iter()
+            .map(|o| {
+                if let Some(value) = o.proprietary.get(&raw::ProprietaryKey {
+                    prefix: PSBT_SP_PREFIX.as_bytes().to_vec(),
+                    subtype: PSBT_SP_SUBTYPE,
+                    key: PSBT_SP_ADDRESS_KEY.as_bytes().to_vec(),
+                }) {
+                    let candidate: String =
+                        SilentPaymentAddress::try_from(deserialize::<String>(value).unwrap())
+                            .unwrap()
+                            .into();
+                    return Some(candidate);
+                } else {
+                    return None;
+                }
+            })
+            .collect();
+
+        let fee_set = candidates.iter().filter_map(|candidate_opt| {
+            candidate_opt.as_ref().and_then(|c| {
+                if *c == change_address {
+                    Some(SpClient::set_fees(&mut new_psbt, fee_rate, change_address.clone()))
+                } else if *c == sender_address {
+                    Some(SpClient::set_fees(&mut new_psbt, fee_rate, sender_address.clone()))
+                } else {
+                    None
+                }
+            })
+        }).find_map(|result| result.ok());
+
+        if fee_set.is_none() {
+            return Err(Error::msg("Must specify payer for fee"));
+        }
+    };
+
+    let partial_secret = sp_wallet
+        .get_client()
+        .get_partial_secret_from_psbt(&new_psbt)?;
+
+    sp_wallet
+        .get_client()
+        .fill_sp_outputs(&mut new_psbt, partial_secret)?;
+    let mut aux_rand = [0u8; 32];
+    thread_rng().fill(&mut aux_rand);
+    let mut signed = sp_wallet.get_client().sign_psbt(new_psbt, &aux_rand)?;
+    SpClient::finalize_psbt(&mut signed)?;
+
+    Ok(signed)
+}
+
+pub fn map_outputs_to_sp_address(psbt_str: &str) -> Result<HashMap<String, Vec<usize>>> {
+    let psbt = Psbt::from_str(&psbt_str)?;
+
+    let mut res: HashMap<String, Vec<usize>> = HashMap::new();
+    for (i, output) in psbt.outputs.iter().enumerate() {
+        if let Some(value) = output.proprietary.get(&raw::ProprietaryKey {
+            prefix: constants::PSBT_SP_PREFIX.as_bytes().to_vec(),
+            subtype: constants::PSBT_SP_SUBTYPE,
+            key: constants::PSBT_SP_ADDRESS_KEY.as_bytes().to_vec(),
+        }) {
+            let sp_address = SilentPaymentAddress::try_from(deserialize::<String>(value)?)?;
+            if let Some(vouts) = res.get_mut::<String>(&sp_address.into()) {
+                vouts.push(i);
+            } else {
+                res.insert(sp_address.into(), vec![i]);
+            }
+        } else {
+            // Not a sp output
+            continue;
+        }
+    }
+
+    Ok(res)
+}
+
+// #[cfg(test)]
+// mod tests {
+//     use std::io::Write;
+
+//     use crate::pcd::Pcd;
+//     use crate::prd::{Prd, PrdType};
+//     use crate::process::{Member, Process, Role, ValidationRules};
+
+//     use super::*;
+//     use serde_json::Value;
+//     use sp_client::bitcoin::hashes::{sha256, Hash};
+//     use sp_client::bitcoin::hex::FromHex;
+//     use sp_client::bitcoin::secp256k1::PublicKey;
+//     use sp_client::bitcoin::{ScriptBuf, Transaction, Txid};
+//     use sp_client::silentpayments::utils::receiving::{
+//         calculate_tweak_data, get_pubkey_from_input,
+//     };
+
+//     const ALICE_WALLET: &str = "{\"tx_history\": [],\"client\":{\"network\":\"regtest\",\"label\":\"default\",\"scan_sk\":\"e3d8922a41a7cb1a84a90f4334e987bb5ea2df6a1fdf44f789b5302de119f9e2\",\"spend_key\":{\"Secret\":\"93292e5b21042c6cfc742ba30e9d2a1e01609b12d154a1825184ed12c7b9631b\"},\"mnemonic\":null,\"sp_receiver\":{\"version\":0,\"network\":\"Regtest\",\"scan_pubkey\":[2,104,242,105,185,6,124,208,34,44,149,52,163,38,63,221,150,12,198,24,95,143,126,235,37,149,233,88,118,32,86,233,152],\"spend_pubkey\":[3,198,82,196,243,12,59,126,109,143,144,157,128,176,168,94,54,134,232,139,115,102,11,178,128,244,239,251,40,228,67,153,72],\"change_label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"labels\":[[\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",[2,244,223,255,57,50,216,27,133,112,138,69,120,126,85,110,6,242,141,33,136,191,82,164,241,54,179,115,84,161,145,174,154]]]}},\"outputs\":{\"wallet_fingerprint\":[187,119,108,230,171,125,106,11],\"birthday\":1620,\"last_scan\":2146,\"outputs\":{\"9a4a67cc5a40bf882d8b300d91024d7c97024b3b68b2df7745a5b9ea1df1888c:1\":{\"blockheight\":1620,\"tweak\":\"b8b63b3ed97d297b744135cfac2fb4a344c881a77543b71f1fcd16bc67514f26\",\"amount\":3938643,\"script\":\"51205b7b324bb71d411e32f2c61fda5d1db23f5c7d6d416a77fab87c913a1b120be1\",\"label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"spend_status\":\"Unspent\"}}}}";
+//     const BOB_WALLET: &str = "{\"tx_history\": [],\"client\":{\"network\":\"regtest\",\"label\":\"default\",\"scan_sk\":\"0de90b7195c1380d5fde13de3f1d66d53423a9896314839e36ba672653af60b4\",\"spend_key\":{\"Secret\":\"affe686075ecbe17b8ce7de45ec31314804259d0a4bc1c863de21ffd6dc598f8\"},\"mnemonic\":null,\"sp_receiver\":{\"version\":0,\"network\":\"Regtest\",\"scan_pubkey\":[2,85,96,92,243,247,237,192,205,9,178,146,101,237,132,232,15,2,69,138,31,118,76,140,142,207,90,13,192,94,254,150,133],\"spend_pubkey\":[3,5,157,91,250,169,41,61,190,37,30,98,152,253,180,138,250,86,162,102,82,148,130,220,44,153,127,83,43,246,93,17,232],\"change_label\":\"56572fc770b52096879662f97f98263d3e126f5a4a38f00f2895a9dde4c47c1c\",\"labels\":[[\"56572fc770b52096879662f97f98263d3e126f5a4a38f00f2895a9dde4c47c1c\",[2,237,237,247,213,154,87,34,239,168,235,87,122,152,94,41,35,101,184,201,58,201,6,185,58,157,52,208,129,167,2,224,198]]]}},\"outputs\":{\"wallet_fingerprint\":[203,200,4,248,139,36,241,232],\"birthday\":2146,\"last_scan\":2146,\"outputs\":{\"fbd9c63e0dd08c2569b51a0d6095a79ee2acfcac66acdb594328a095f1fadb63:1\":{\"blockheight\":2146,\"tweak\":\"678dbcbdb40cd3733c8dbbd508761a0937009cf75a9f466e3c98877e79037cbc\",\"amount\":99896595,\"script\":\"5120deab0c5a3d23de30477b0b5a95a261c96e29afdd9813c665d2bf025ad2b3f919\",\"label\":null,\"spend_status\":\"Unspent\"}}}}";
+//     const ALICE_WALLET_CONFIRMATION: &str = "{\"tx_history\": [],\"client\":{\"network\":\"regtest\",\"label\":\"default\",\"scan_sk\":\"e3d8922a41a7cb1a84a90f4334e987bb5ea2df6a1fdf44f789b5302de119f9e2\",\"spend_key\":{\"Secret\":\"93292e5b21042c6cfc742ba30e9d2a1e01609b12d154a1825184ed12c7b9631b\"},\"mnemonic\":null,\"sp_receiver\":{\"version\":0,\"network\":\"Regtest\",\"scan_pubkey\":[2,104,242,105,185,6,124,208,34,44,149,52,163,38,63,221,150,12,198,24,95,143,126,235,37,149,233,88,118,32,86,233,152],\"spend_pubkey\":[3,198,82,196,243,12,59,126,109,143,144,157,128,176,168,94,54,134,232,139,115,102,11,178,128,244,239,251,40,228,67,153,72],\"change_label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"labels\":[[\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",[2,244,223,255,57,50,216,27,133,112,138,69,120,126,85,110,6,242,141,33,136,191,82,164,241,54,179,115,84,161,145,174,154]]]}},\"outputs\":{\"wallet_fingerprint\":[187,119,108,230,171,125,106,11],\"birthday\":1620,\"last_scan\":2146,\"outputs\":{\"9a4a67cc5a40bf882d8b300d91024d7c97024b3b68b2df7745a5b9ea1df1888c:1\":{\"blockheight\":1620,\"tweak\":\"b8b63b3ed97d297b744135cfac2fb4a344c881a77543b71f1fcd16bc67514f26\",\"amount\":3938643,\"script\":\"51205b7b324bb71d411e32f2c61fda5d1db23f5c7d6d416a77fab87c913a1b120be1\",\"label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"spend_status\":{\"Spent\":\"148e0faa2f203b6e9488e2da696d8a49ebff4212946672f0bb072ced0909360d\"}},\"148e0faa2f203b6e9488e2da696d8a49ebff4212946672f0bb072ced0909360d:1\":{\"blockheight\":0,\"tweak\":\"28994b2f2ee8e5f35d6d2dcdee1580d0455fe3dc37f81e0a36864473ee86f5c4\",\"amount\":3937246,\"script\":\"51207d06144e982b6fd38a85d6152f1f95746b059553258a31e04df97fe6b5f19ea1\",\"label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"spend_status\":\"Unspent\"}}}}";
+//     const BOB_WALLET_CONFIRMATION: &str = "{\"tx_history\": [],\"client\":{\"network\":\"regtest\",\"label\":\"default\",\"scan_sk\":\"0de90b7195c1380d5fde13de3f1d66d53423a9896314839e36ba672653af60b4\",\"spend_key\":{\"Secret\":\"affe686075ecbe17b8ce7de45ec31314804259d0a4bc1c863de21ffd6dc598f8\"},\"mnemonic\":null,\"sp_receiver\":{\"version\":0,\"network\":\"Regtest\",\"scan_pubkey\":[2,85,96,92,243,247,237,192,205,9,178,146,101,237,132,232,15,2,69,138,31,118,76,140,142,207,90,13,192,94,254,150,133],\"spend_pubkey\":[3,5,157,91,250,169,41,61,190,37,30,98,152,253,180,138,250,86,162,102,82,148,130,220,44,153,127,83,43,246,93,17,232],\"change_label\":\"56572fc770b52096879662f97f98263d3e126f5a4a38f00f2895a9dde4c47c1c\",\"labels\":[[\"56572fc770b52096879662f97f98263d3e126f5a4a38f00f2895a9dde4c47c1c\",[2,237,237,247,213,154,87,34,239,168,235,87,122,152,94,41,35,101,184,201,58,201,6,185,58,157,52,208,129,167,2,224,198]]]}},\"outputs\":{\"wallet_fingerprint\":[203,200,4,248,139,36,241,232],\"birthday\":2146,\"last_scan\":2146,\"outputs\":{\"148e0faa2f203b6e9488e2da696d8a49ebff4212946672f0bb072ced0909360d:0\":{\"blockheight\":0,\"tweak\":\"0e3395ff27bde9187ffaeeb2521f6277d3b83911f16ccbaf59a1a68d99a0ab93\",\"amount\":1200,\"script\":\"512010f06f764cbc923ec3198db946307bf0c06a1b4f09206055e47a6fec0a33d52c\",\"label\":null,\"spend_status\":\"Unspent\"},\"fbd9c63e0dd08c2569b51a0d6095a79ee2acfcac66acdb594328a095f1fadb63:1\":{\"blockheight\":2146,\"tweak\":\"678dbcbdb40cd3733c8dbbd508761a0937009cf75a9f466e3c98877e79037cbc\",\"amount\":99896595,\"script\":\"5120deab0c5a3d23de30477b0b5a95a261c96e29afdd9813c665d2bf025ad2b3f919\",\"label\":null,\"spend_status\":\"Unspent\"}}}}";
+//     const ALICE_WALLET_ANSWER: &str = "{\"tx_history\": [],\"client\":{\"network\":\"regtest\",\"label\":\"default\",\"scan_sk\":\"e3d8922a41a7cb1a84a90f4334e987bb5ea2df6a1fdf44f789b5302de119f9e2\",\"spend_key\":{\"Secret\":\"93292e5b21042c6cfc742ba30e9d2a1e01609b12d154a1825184ed12c7b9631b\"},\"mnemonic\":null,\"sp_receiver\":{\"version\":0,\"network\":\"Regtest\",\"scan_pubkey\":[2,104,242,105,185,6,124,208,34,44,149,52,163,38,63,221,150,12,198,24,95,143,126,235,37,149,233,88,118,32,86,233,152],\"spend_pubkey\":[3,198,82,196,243,12,59,126,109,143,144,157,128,176,168,94,54,134,232,139,115,102,11,178,128,244,239,251,40,228,67,153,72],\"change_label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"labels\":[[\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",[2,244,223,255,57,50,216,27,133,112,138,69,120,126,85,110,6,242,141,33,136,191,82,164,241,54,179,115,84,161,145,174,154]]]}},\"outputs\":{\"wallet_fingerprint\":[187,119,108,230,171,125,106,11],\"birthday\":1620,\"last_scan\":2146,\"outputs\":{\"148e0faa2f203b6e9488e2da696d8a49ebff4212946672f0bb072ced0909360d:1\":{\"blockheight\":0,\"tweak\":\"28994b2f2ee8e5f35d6d2dcdee1580d0455fe3dc37f81e0a36864473ee86f5c4\",\"amount\":3937246,\"script\":\"51207d06144e982b6fd38a85d6152f1f95746b059553258a31e04df97fe6b5f19ea1\",\"label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"spend_status\":\"Unspent\"},\"bc207c02bc4f1d4359fcd604296c0938bf1e6ff827662a56410676b8cbd768d9:0\":{\"blockheight\":0,\"tweak\":\"3bf77beab9c053e1ed974288d5d246962376d2badddc623af1f2ef7af57067b7\",\"amount\":1046,\"script\":\"5120646bdb98d89a2573acc6064a5c806d00e34beb65588c91a32733b62255b4dafa\",\"label\":null,\"spend_status\":\"Unspent\"},\"9a4a67cc5a40bf882d8b300d91024d7c97024b3b68b2df7745a5b9ea1df1888c:1\":{\"blockheight\":1620,\"tweak\":\"b8b63b3ed97d297b744135cfac2fb4a344c881a77543b71f1fcd16bc67514f26\",\"amount\":3938643,\"script\":\"51205b7b324bb71d411e32f2c61fda5d1db23f5c7d6d416a77fab87c913a1b120be1\",\"label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"spend_status\":{\"Spent\":\"148e0faa2f203b6e9488e2da696d8a49ebff4212946672f0bb072ced0909360d\"}}}}}";
+//     const BOB_WALLET_ANSWER: &str = "{\"tx_history\": [],\"client\":{\"network\":\"regtest\",\"label\":\"default\",\"scan_sk\":\"0de90b7195c1380d5fde13de3f1d66d53423a9896314839e36ba672653af60b4\",\"spend_key\":{\"Secret\":\"affe686075ecbe17b8ce7de45ec31314804259d0a4bc1c863de21ffd6dc598f8\"},\"mnemonic\":null,\"sp_receiver\":{\"version\":0,\"network\":\"Regtest\",\"scan_pubkey\":[2,85,96,92,243,247,237,192,205,9,178,146,101,237,132,232,15,2,69,138,31,118,76,140,142,207,90,13,192,94,254,150,133],\"spend_pubkey\":[3,5,157,91,250,169,41,61,190,37,30,98,152,253,180,138,250,86,162,102,82,148,130,220,44,153,127,83,43,246,93,17,232],\"change_label\":\"56572fc770b52096879662f97f98263d3e126f5a4a38f00f2895a9dde4c47c1c\",\"labels\":[[\"56572fc770b52096879662f97f98263d3e126f5a4a38f00f2895a9dde4c47c1c\",[2,237,237,247,213,154,87,34,239,168,235,87,122,152,94,41,35,101,184,201,58,201,6,185,58,157,52,208,129,167,2,224,198]]]}},\"outputs\":{\"wallet_fingerprint\":[203,200,4,248,139,36,241,232],\"birthday\":2146,\"last_scan\":2146,\"outputs\":{\"fbd9c63e0dd08c2569b51a0d6095a79ee2acfcac66acdb594328a095f1fadb63:1\":{\"blockheight\":2146,\"tweak\":\"678dbcbdb40cd3733c8dbbd508761a0937009cf75a9f466e3c98877e79037cbc\",\"amount\":99896595,\"script\":\"5120deab0c5a3d23de30477b0b5a95a261c96e29afdd9813c665d2bf025ad2b3f919\",\"label\":null,\"spend_status\":\"Unspent\"},\"148e0faa2f203b6e9488e2da696d8a49ebff4212946672f0bb072ced0909360d:0\":{\"blockheight\":0,\"tweak\":\"0e3395ff27bde9187ffaeeb2521f6277d3b83911f16ccbaf59a1a68d99a0ab93\",\"amount\":1200,\"script\":\"512010f06f764cbc923ec3198db946307bf0c06a1b4f09206055e47a6fec0a33d52c\",\"label\":null,\"spend_status\":{\"Spent\":\"bc207c02bc4f1d4359fcd604296c0938bf1e6ff827662a56410676b8cbd768d9\"}}}}}";
+//     const ALICE_ADDRESS: &str = "sprt1qqf50y6deqe7dqg3vj562xf3lmktqe3sct78ha6e9jh54sa3q2m5esq7x2tz0xrpm0ekclyyaszc2sh3ksm5gkumxpwegpa80lv5wgsuefqaufx8q";
+//     const BOB_ADDRESS: &str = "sprt1qqf2kqh8n7lkupngfk2fxtmvyaq8sy3v2ramyeryweadqmsz7l6tg2qc9n4dl42ff8klz28nznr7mfzh6263xv555stwzextl2v4lvhg3aqq7ru8u";
+//     const FEE_RATE: Amount = Amount::from_sat(1);
+//     const KEY: &str = "442a5ea418921c4aa8ce3f7a95427d9450059a3ac11db3dced9abb709b2d9f42";
+//     const INITIAL_COMMIT_TX: &str = "bc7d2ef1820cf67edb900e4c59cae6c692663cd690e691a55df919f002ede841";
+
+//     fn helper_get_tweak_data(tx: &Transaction, spk: ScriptBuf) -> PublicKey {
+//         let prevout = tx.input.get(0).unwrap().to_owned();
+//         let outpoint_data = (
+//             prevout.previous_output.txid.to_string(),
+//             prevout.previous_output.vout,
+//         );
+//         let input_pubkey =
+//             get_pubkey_from_input(&vec![], &prevout.witness.to_vec(), spk.as_bytes()).unwrap();
+//         let tweak_data =
+//             calculate_tweak_data(&vec![&input_pubkey.unwrap()], &vec![outpoint_data]).unwrap();
+//         tweak_data
+//     }
+
+//     fn helper_create_commitment(payload_to_hash: String) -> sha256::Hash {
+//         let mut engine = sha256::HashEngine::default();
+//         engine.write_all(&payload_to_hash.as_bytes()).unwrap();
+//         let hash = sha256::Hash::from_engine(engine);
+//         hash
+//     }
+
+//     #[test]
+//     fn it_creates_notification_transaction() {
+//         let recipient = Recipient {
+//             address: BOB_ADDRESS.to_owned(),
+//             amount: Amount::from_sat(1200),
+//             nb_outputs: 1,
+//         };
+//         let mut alice_wallet: SpWallet = serde_json::from_str(ALICE_WALLET).unwrap();
+//         let mut bob_wallet: SpWallet = serde_json::from_str(BOB_WALLET).unwrap();
+//         let pcd = Pcd::new(Value::String("TEST".to_owned()));
+//         let pcd_hash = helper_create_commitment(pcd.to_string());
+//         let mut key = [0u8; 32];
+//         key.copy_from_slice(&Vec::from_hex(KEY).unwrap());
+
+//         let alice_member = Member::new(
+//             "alice".to_owned(), 
+//             alice_wallet.get_client().get_receiving_address().try_into().unwrap(), 
+//             alice_wallet.get_client().sp_receiver.get_change_address().try_into().unwrap(), 
+//             Role::Admin,
+//         );
+//         let bob_member = Member::new(
+//             "bob".to_owned(), 
+//             bob_wallet.get_client().get_receiving_address().try_into().unwrap(), 
+//             bob_wallet.get_client().sp_receiver.get_change_address().try_into().unwrap(), 
+//             Role::User,
+//         );
+
+//         let validation_rules = ValidationRules::new(0.5, Role::User);
+
+//         let pcd_template = serde_json::json!({
+//             "int": 0,
+//             "string": "exemple_data",
+//             "array": [
+//                 "element1",
+//                 "element2"
+//             ]
+//         });
+
+//         let process = Process::new(
+//             "default".to_owned(),
+//             vec![alice_member, bob_member],
+//             validation_rules,
+//             Txid::from_str(INITIAL_COMMIT_TX).unwrap(),
+//             "".to_owned(),
+//             "".to_owned(),
+//             "".to_owned(),
+//             pcd_template,
+//         );
+
+//         let prd = Prd::new(
+//             PrdType::Update,
+//             process,
+//             ALICE_ADDRESS.try_into().unwrap(),
+//             key,
+//             pcd_hash,
+//         ).unwrap();
+//         let commitment = helper_create_commitment(serde_json::to_string(&prd).unwrap());
+
+//         let psbt = create_transaction(
+//             &vec![],
+//             &HashSet::new(),
+//             &alice_wallet,
+//             vec![recipient],
+//             Some(commitment.as_byte_array().to_vec()),
+//             FEE_RATE,
+//             None,
+//         )
+//         .unwrap();
+
+//         let final_tx = psbt.extract_tx().unwrap();
+//         let spk = "51205b7b324bb71d411e32f2c61fda5d1db23f5c7d6d416a77fab87c913a1b120be1";
+
+//         let tweak_data = helper_get_tweak_data(&final_tx, ScriptBuf::from_hex(spk).unwrap());
+
+//         // Check that Alice and Bob are both able to find that transaction
+//         let alice_update = alice_wallet
+//             .update_wallet_with_transaction(&final_tx, 0, tweak_data)
+//             .unwrap();
+//         assert!(alice_update.len() > 0);
+//         let bob_update = bob_wallet
+//             .update_wallet_with_transaction(&final_tx, 0, tweak_data)
+//             .unwrap();
+//         assert!(bob_update.len() > 0);
+//         println!("{:?}", alice_wallet.get_outputs().to_outpoints_list());
+//         println!("{:?}", bob_wallet.get_outputs().to_outpoints_list());
+//     }
+
+//     #[test]
+//     fn it_creates_confirmation_transaction() {
+//         let mut alice_wallet: SpWallet = serde_json::from_str(ALICE_WALLET_CONFIRMATION).unwrap();
+//         let mut bob_wallet: SpWallet = serde_json::from_str(BOB_WALLET_CONFIRMATION).unwrap();
+
+//         // Bob must spend notification output
+//         let (confirmation_outpoint, _) = bob_wallet
+//             .get_outputs()
+//             .get_outpoint(
+//                 OutPoint::from_str(
+//                     "148e0faa2f203b6e9488e2da696d8a49ebff4212946672f0bb072ced0909360d:0",
+//                 )
+//                 .unwrap(),
+//             )
+//             .unwrap();
+
+//         let recipient = Recipient {
+//             address: ALICE_ADDRESS.to_owned(),
+//             amount: Amount::from_sat(0),
+//             nb_outputs: 1,
+//         };
+
+//         let psbt = create_transaction(
+//             &vec![&confirmation_outpoint],
+//             &HashSet::new(),
+//             &bob_wallet,
+//             vec![recipient],
+//             None,
+//             FEE_RATE,
+//             Some(ALICE_ADDRESS.to_owned()),
+//         )
+//         .unwrap();
+
+//         let final_tx = psbt.extract_tx().unwrap();
+//         // println!(
+//         //     "{}",
+//         //     serialize::<Transaction>(&final_tx).to_lower_hex_string()
+//         // );
+//         let spk = "512010f06f764cbc923ec3198db946307bf0c06a1b4f09206055e47a6fec0a33d52c";
+
+//         let tweak_data = helper_get_tweak_data(&final_tx, ScriptBuf::from_hex(spk).unwrap());
+
+//         // Check that Alice and Bob are both able to find that transaction
+//         let alice_update = alice_wallet
+//             .update_wallet_with_transaction(&final_tx, 0, tweak_data)
+//             .unwrap();
+//         assert!(alice_update.len() > 0);
+//         let bob_update = bob_wallet
+//             .update_wallet_with_transaction(&final_tx, 0, tweak_data)
+//             .unwrap();
+//         assert!(bob_update.len() > 0);
+//         println!("{:?}", alice_wallet.get_outputs().to_outpoints_list());
+//         println!("{:?}", bob_wallet.get_outputs().to_outpoints_list());
+//     }
+
+//     #[test]
+//     fn it_creates_answer_transaction() {
+//         let mut alice_wallet: SpWallet = serde_json::from_str(ALICE_WALLET_ANSWER).unwrap();
+//         let mut bob_wallet: SpWallet = serde_json::from_str(BOB_WALLET_ANSWER).unwrap();
+
+//         // Bob must spend notification output
+//         let (confirmation_outpoint, _) = alice_wallet
+//             .get_outputs()
+//             .get_outpoint(
+//                 OutPoint::from_str(
+//                     "bc207c02bc4f1d4359fcd604296c0938bf1e6ff827662a56410676b8cbd768d9:0",
+//                 )
+//                 .unwrap(),
+//             )
+//             .unwrap();
+
+//         let recipient = Recipient {
+//             address: BOB_ADDRESS.to_owned(),
+//             amount: Amount::from_sat(0),
+//             nb_outputs: 1,
+//         };
+
+//         let psbt = create_transaction(
+//             &vec![&confirmation_outpoint],
+//             &HashSet::new(),
+//             &alice_wallet,
+//             vec![recipient],
+//             None,
+//             FEE_RATE,
+//             Some(BOB_ADDRESS.to_owned()),
+//         )
+//         .unwrap();
+
+//         let final_tx = psbt.extract_tx().unwrap();
+//         // println!("{}", serialize::<Transaction>(&final_tx).to_lower_hex_string());
+//         let spk = "5120646bdb98d89a2573acc6064a5c806d00e34beb65588c91a32733b62255b4dafa";
+
+//         let tweak_data = helper_get_tweak_data(&final_tx, ScriptBuf::from_hex(spk).unwrap());
+
+//         // Check that Alice and Bob are both able to find that transaction
+//         let alice_update = alice_wallet
+//             .update_wallet_with_transaction(&final_tx, 0, tweak_data)
+//             .unwrap();
+//         assert!(alice_update.len() > 0);
+//         let bob_update = bob_wallet
+//             .update_wallet_with_transaction(&final_tx, 0, tweak_data)
+//             .unwrap();
+//         assert!(bob_update.len() > 0);
+//         println!("{:?}", alice_wallet.get_outputs().to_outpoints_list());
+//         println!("{:?}", bob_wallet.get_outputs().to_outpoints_list());
+//     }
+// }

src/wallet.rs

@@ -1,27 +0,0 @@
-// use rand::{rngs::ThreadRng, thread_rng};
-// use silentPayments::secp256k1::{self, Secp256k1, SecretKey};
-
-// use sp_backend::SpClient;
-/*
-pub struct Wallet {
-    pub client: SpClient,
-    pub secp: Secp256k1<secp256k1::All>,
-    pub seckey_spend: SecretKey,
-    pub seckey_scan: SecretKey,
-}
-
-impl Wallet {
-    pub fn new() -> Wallet {
-        let secp: Secp256k1<secp256k1::All> = Secp256k1::new();
-        let mut rng: ThreadRng = thread_rng();
-        let seckey_spend: SecretKey = SecretKey::new(rng);
-        let seckey_scan: SecretKey = SecretKey::new(rng);
-        Wallet {
-            client: SpClient::new(),
-            secp,
-            seckey_spend,
-            seckey_scan,
-        }
-    }
-}
-*/

src/workflows/mod.rs

@@ -1 +0,0 @@
-pub mod workflow_pcd_create_and_send_all;

src/workflows/workflow_pcd_create_and_send_all.rs

@@ -1,253 +0,0 @@
-use crate::models::{
-    commit_method::commitMethod, deposit_method::DepositMethod, item_enum::ItemEnum,
-    `Envelope` _client::EnvelopeClient, Payments_method::PaymentsMethod, roles_group::RolesGroup,
-};
-
-use serde::{Deserialize, Serialize};
-use std::hash::Hash;
-
-use crate::models::{
-    key_encryption::KeyEncryption, pagination::Pagination, request_pcd::Pcd,
-    shared_peer::Peer, shared_process::Process,
-};
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct ProcessRoleSpAddressGroup {
-    pub sp_address_list: Vec<String>,
-    pub role_name: String,
-}
-impl ProcessRoleSpAddressGroup {
-    pub fn new(sp_address_list: Vec<String>, role_name: String) -> Self {
-        ProcessRoleSpAddressGroup {
-            sp_address_list,
-            role_name,
-        }
-    }
-    pub fn display_info(&self) {
-        println!("ProcessRoleSpAddressGroup:");
-        println!("SP Address List: {:?}", self.sp_address_list);
-        println!("Role Name: {}", self.role_name);
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-
-pub struct PcdItemEncAttributeRoleConfidentialExportKey {
-    pub attribute_name: String,
-    pub key: Option<KeyEncryption>,
-    pub item_index: usize,
-}
-
-pub struct WorkflowPcdCreateAndSendAll {
-    pub item_name: String,
-    pub item_list: Vec<ItemEnum>,
-    pub pcd_pagination: Pagination,
-    pub pcd_version: i64,
-    pub process_hash: String,
-    pub pcd_reference_hash: Option<String>,
-    pub pcd_item_reference_hash: Option<String>,
-    pub Member_private_enc_key: KeyEncryption,
-    pub process_public_enc_key: KeyEncryption,
-    pub roles: RolesGroup,
-    pub pow_pathern: String,
-    pub pow_difficulty: usize,
-    pub `Envelope` _shared_peer_list: Vec<Peer>,
-    pub `Envelope` _shared_process_list: Vec<Process>,
-    pub `Envelope` _faucet_sp_address: String,
-
-    pub `Envelope` _public_string: Option<String>,
-    pub `Envelope` _confidential_string: Option<String>,
-    pub `Envelope` _private_string: Option<String>,
-    pub sp_address_from: String,
-    pub sp_address_reply: String,
-    pub timestamp_declared: u64,
-    pub role_name_from: String,
-    pub role_name_to: String,
-    pub sig_value: String,
-    pub pcd_origin_hash: Option<String>,
-
-    pub Payments_method: Option<PaymentsMethod>,
-    pub deposit_method: Option<DepositMethod>,
-    pub commit_method: Option<commitMethod>,
-    pub certif_key: Option<String>,
-}
-
-impl WorkflowPcdCreateAndSendAll {
-    pub fn new(
-        item_name: String,
-        item_list: Vec<ItemEnum>,
-        pcd_pagination: Pagination,
-        pcd_version: i64,
-        process_hash: String,
-        pcd_reference_hash: Option<String>,
-        pcd_item_reference_hash: Option<String>,
-        Member_private_enc_key: KeyEncryption,
-        process_public_enc_key: KeyEncryption,
-        roles: RolesGroup,
-        pow_pathern: String,
-        pow_difficulty: usize,
-        `Envelope` _shared_peer_list: Vec<Peer>,
-        `Envelope` _shared_process_list: Vec<Process>,
-        `Envelope` _faucet_sp_address: String,
-        `Envelope` _public_string: Option<String>,
-        `Envelope` _confidential_string: Option<String>,
-        `Envelope` _private_string: Option<String>,
-        sp_address_from: String,
-        sp_address_reply: String,
-        timestamp_declared: u64,
-        role_name_from: String,
-        role_name_to: String,
-        sig_value: String,
-        pcd_origin_hash: Option<String>,
-
-        Payments_method: Option<PaymentsMethod>,
-        deposit_method: Option<DepositMethod>,
-        commit_method: Option<commitMethod>,
-        certif_key: Option<String>,
-    ) -> Self {
-        WorkflowPcdCreateAndSendAll {
-            item_name,
-            item_list,
-            pcd_pagination,
-            pcd_version,
-            process_hash,
-            pcd_reference_hash,
-            pcd_item_reference_hash,
-            Member_private_enc_key,
-            process_public_enc_key,
-            roles,
-            pow_pathern,
-            pow_difficulty,
-            `Envelope` _shared_peer_list,
-            `Envelope` _shared_process_list,
-            `Envelope` _faucet_sp_address,
-
-            `Envelope` _public_string,
-            `Envelope` _confidential_string,
-            `Envelope` _private_string,
-            sp_address_from,
-            sp_address_reply,
-            timestamp_declared,
-            role_name_from,
-            role_name_to,
-            sig_value,
-            pcd_origin_hash,
-            Payments_method,
-            deposit_method,
-            commit_method,
-            certif_key,
-        }
-    }
-    pub fn run(&self) {
-        // walk item list and encrypt attributes
-
-        // create pcd
-        let pcd: Pcd = Pcd::new(
-            Some(self.item_name.clone()),
-            self.pcd_version,
-            self.process_hash.clone(),
-            self.pcd_reference_hash.clone(),
-            self.pcd_item_reference_hash.clone(),
-            self.item_list.clone(),
-            self.pcd_pagination.clone(),
-            self.process_public_enc_key.clone(),
-            self.Member_private_enc_key.clone(),
-        );
-
-        let pcd_message: `Envelope` Client = pcd.to_message(
-            self.process_public_enc_key.clone(),
-            self.message_shared_peer_list.clone(),
-            self.message_shared_process_list.clone(),
-            self.message_faucet_sp_address.clone(),
-            self.pow_pathern.clone(),
-            self.pow_difficulty,
-        );
-
-        let mut pcd_keys_role_confidential_list: Vec<PcdItemEncAttributeRoleConfidentialExportKey> =
-            Vec::new();
-
-        let mut item_index = 0;
-        for item in &pcd.item_list {
-            for enc_attribute_list in &item.pcd_item_enc_attribute_role_confidential_list {
-                for enc_attribute in enc_attribute_list {
-                    let exp = PcdItemEncAttributeRoleConfidentialExportKey {
-                        attribute_name: enc_attribute.attribute_name.clone(),
-                        key: Some(enc_attribute.key.clone()),
-                        item_index,
-                    };
-                    pcd_keys_role_confidential_list.push(exp);
-                }
-            }
-            item_index += 1;
-        }
-
-        let prd_list = self.roles.to_prd_response_list(
-            self.process_public_enc_key.clone(),
-            self.Member_private_enc_key.clone(),
-            Some(self.item_name.clone()),
-            0,
-            self.process_hash.clone(),
-            self.pcd_reference_hash.clone(),
-            self.pcd_item_reference_hash.clone(),
-            pcd_keys_role_confidential_list.clone(),
-            self.message_public_string.clone(),
-            self.message_confidential_string.clone(),
-            self.message_private_string.clone(),
-            self.sp_address_from.clone(),
-            self.sp_address_reply.clone(),
-            self.timestamp_declared.clone(),
-            self.role_name_from.clone(),
-            self.role_name_to.clone(),
-            self.sig_value.clone(),
-            Some(pcd_`Envelope`.request_hash),
-            self.Payments_method.clone(),
-            self.deposit_method.clone(),
-            self.commit_method.clone(),
-            self.certif_key.clone(),
-        );
-
-        for prd in prd_list {
-            let _prd_message_list = prd.to_message(
-                self.process_public_enc_key.clone(),
-                self.message_shared_peer_list.clone(),
-                self.message_shared_process_list.clone(),
-                self.message_faucet_sp_address.clone(),
-                self.pow_pathern.clone(),
-                self.pow_difficulty,
-            );
-        }
-        // todo
-        // send
-    }
-    pub fn display_info(&self) {
-        println!("PcdCreateAndSend:");
-        println!("Item Name: {}", self.item_name);
-        println!("Item List: {:?}", self.item_list);
-        println!("Pagination: {:?}", self.pcd_pagination);
-        println!("Version: {}", self.pcd_version);
-        println!("Process Hash: {}", self.process_hash);
-        println!("Reference Hash: {:?}", self.pcd_reference_hash);
-        println!("Item Reference Hash: {:?}", self.pcd_item_reference_hash);
-        println!(
-            "Member Private Encryption Key: {:?}",
-            self.Member_private_enc_key
-        );
-        println!(
-            "Process Public Encryption Key: {:?}",
-            self.process_public_enc_key
-        );
-        println!("Process roles: {:?}", self.roles);
-        println!(
-            "Message Shared Peer List: {:?}",
-            self.message_shared_peer_list
-        );
-        println!(
-            "Message Shared Process List: {:?}",
-            self.message_shared_process_list
-        );
-        println!(
-            "Message Faucet SP Address: {:?}",
-            self.message_faucet_sp_address
-        );
-    }
-}