Merge branch 'demo' into dev

Cargo.toml

@@ -7,17 +7,12 @@ edition = "2021"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-wasm-bindgen = "0.2.90"
+aes-gcm = "0.10.3"
+anyhow = "1.0"
+js-sys = "0.3.69"
+rand = "0.8.5"
 serde = { version = "1.0.193", features = ["derive"] }
 serde_json = "1.0.108"
-# sp_backend = { git = "https://github.com/Sosthene00/sp-backend.git", branch = "master" }
+sp_client = { git = "https://github.com/Sosthene00/sp-client.git", branch = "sp_client" }
-# silentPayments = { git = "https://github.com/Sosthene00/rust-silentPayments", branch = "utils" }
+tsify = { git = "https://github.com/Sosthene00/tsify", branch = "next" }
-rand = "0.8.5"
+wasm-bindgen = "0.2.91"
-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"] }

src/crypto.rs

@@ -0,0 +1,380 @@
+use std::collections::HashMap;
+
+use anyhow::{Error, Result};
+use serde::{Deserialize, Serialize};
+use sp_client::{
+    bitcoin::{
+        hex::{DisplayHex, FromHex}, key::constants::SECRET_KEY_SIZE, Txid
+    },
+    silentpayments::{
+        bitcoin_hashes::{sha256t_hash_newtype, Hash, HashEngine},
+        sending::SilentPaymentAddress,
+        secp256k1::PublicKey
+    },
+};
+use tsify::Tsify;
+
+use aes_gcm::aead::{Aead, Payload};
+pub use aes_gcm::{AeadCore, Aes256Gcm, KeyInit};
+use rand::thread_rng;
+
+const AAD: &[u8] = "4nk".as_bytes();
+
+const HALFKEYSIZE: usize = SECRET_KEY_SIZE / 2;
+
+const THIRTYTWO: usize = 32;
+
+#[derive(Debug)]
+pub struct SharedPoint([u8; 64]);
+
+impl SharedPoint {
+    pub fn as_inner(&self) -> &[u8; 64] {
+        &self.0
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Tsify, Clone, Default, PartialEq)]
+#[tsify(from_wasm_abi, into_wasm_abi)]
+pub struct AnkSharedSecret {
+    secret: String,
+}
+
+impl AnkSharedSecret {
+    pub fn new(shared_point: PublicKey) -> Self {
+        let mut shared_point_bin = [0u8;64];
+        shared_point_bin.copy_from_slice(&shared_point.serialize_uncompressed()[1..]);
+        let secret = AnkSharedSecretHash::from_shared_point(shared_point_bin).to_byte_array();
+        Self { secret: secret.to_lower_hex_string() }
+    }
+
+    pub fn to_byte_array(&self) -> [u8; 32] {
+        let bytes = Vec::from_hex(&self.secret).unwrap();
+        let mut buf = [0u8;32];
+        buf.copy_from_slice(&bytes);
+        buf
+    }
+}
+
+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: [u8; 64]) -> Self {
+        let mut eng = AnkSharedSecretHash::engine();
+        eng.input(&shared_point);
+        AnkSharedSecretHash::from_engine(eng)
+    }
+}
+
+pub struct HalfKey([u8; HALFKEYSIZE]);
+
+impl TryFrom<Vec<u8>> for HalfKey {
+    type Error = anyhow::Error;
+    fn try_from(value: Vec<u8>) -> std::prelude::v1::Result<Self, Error> {
+        if value.len() == HALFKEYSIZE {
+            let mut buf = [0u8; HALFKEYSIZE];
+            buf.copy_from_slice(&value);
+            Ok(HalfKey(buf))
+        } else {
+            Err(Error::msg("Invalid length for HalfKey"))
+        }
+    }
+}
+
+impl HalfKey {
+    pub fn as_slice(&self) -> &[u8] {
+        &self.0
+    }
+
+    pub fn to_inner(&self) -> Vec<u8> {
+        self.0.to_vec()
+    }
+}
+
+pub enum Purpose {
+    Login,
+    ThirtyTwoBytes,
+    Arbitrary,
+}
+
+pub type CipherText = Vec<u8>;
+
+pub type EncryptedKey = Vec<u8>;
+
+pub struct Aes256Decryption {
+    pub purpose: Purpose,
+    cipher_text: CipherText,
+    aes_key: [u8; 32],
+    nonce: [u8; 12],
+}
+
+impl Aes256Decryption {
+    pub fn new(
+        purpose: Purpose,
+        cipher_text: CipherText,
+        aes_key: [u8;32], 
+    ) -> Result<Self> {
+        if cipher_text.len() <= 12 {
+            return Err(Error::msg("cipher_text is shorter than nonce length"));
+        }
+        let (message_nonce, message_cipher) = cipher_text.split_at(12);
+        let mut nonce = [0u8; 12];
+        nonce.copy_from_slice(message_nonce);
+        Ok(Self {
+            purpose,
+            cipher_text: message_cipher.to_vec(),
+            aes_key,
+            nonce,
+        })
+    }
+
+    pub fn decrypt_with_key(&self) -> Result<Vec<u8>> {
+        match self.purpose {
+            Purpose::Login => {
+                let half_key = self.decrypt_login()?;
+                Ok(half_key.to_inner())
+            }
+            Purpose::ThirtyTwoBytes => {
+                let thirty_two_buf = self.decrypt_thirty_two()?;
+                Ok(thirty_two_buf.to_vec())
+            }
+            Purpose::Arbitrary => {
+                let arbitrary = self.decrypt_arbitrary()?;
+                Ok(arbitrary)
+            }
+        }
+    }
+
+    fn decrypt_login(&self) -> Result<HalfKey> {
+        let cipher = Aes256Gcm::new(&self.aes_key.into());
+        let plain = cipher
+            .decrypt(&self.nonce.into(), &*self.cipher_text)
+            .map_err(|e| Error::msg(format!("{}", e)))?;
+        if plain.len() != SECRET_KEY_SIZE / 2 {
+            return Err(Error::msg("Plain text of invalid lenght for a login"));
+        }
+        let mut key_half = [0u8; SECRET_KEY_SIZE / 2];
+        key_half.copy_from_slice(&plain);
+        Ok(HalfKey(key_half))
+    }
+
+    fn decrypt_thirty_two(&self) -> Result<[u8; THIRTYTWO]> {
+        let cipher = Aes256Gcm::new(&self.aes_key.into());
+        let plain = cipher
+            .decrypt(&self.nonce.into(), &*self.cipher_text)
+            .map_err(|e| Error::msg(format!("{}", e)))?;
+        if plain.len() != THIRTYTWO {
+            return Err(Error::msg("Plain text of invalid length, should be 32"));
+        }
+        let mut thirty_two = [0u8; THIRTYTWO];
+        thirty_two.copy_from_slice(&plain);
+        Ok(thirty_two)
+    }
+
+    fn decrypt_arbitrary(&self) -> Result<Vec<u8>> {
+        let cipher = Aes256Gcm::new(&self.aes_key.into());
+        let payload = Payload {
+            msg: &self.cipher_text,
+            aad: AAD,
+        };
+        let plain = cipher
+            .decrypt(&self.nonce.into(), payload)
+            .map_err(|e| Error::msg(format!("{}", e)))?;
+        Ok(plain)
+    }
+}
+
+pub struct Aes256Encryption {
+    pub purpose: Purpose,
+    plaintext: Vec<u8>,
+    aes_key: [u8; 32],
+    nonce: [u8; 12],
+    shared_secrets: HashMap<Txid, HashMap<SilentPaymentAddress, AnkSharedSecret>>,
+}
+
+impl Aes256Encryption {
+    pub fn new(purpose: Purpose, plaintext: Vec<u8>) -> Result<Self> {
+        let mut rng = thread_rng();
+        let aes_key: [u8; 32] = Aes256Gcm::generate_key(&mut rng).into();
+        let nonce: [u8; 12] = Aes256Gcm::generate_nonce(&mut rng).into();
+        Self::import_key(purpose, plaintext, aes_key, nonce)
+    }
+
+    pub fn set_shared_secret(
+        &mut self,
+        shared_secrets: HashMap<Txid, HashMap<SilentPaymentAddress, AnkSharedSecret>>,
+    ) {
+        self.shared_secrets = shared_secrets;
+    }
+
+    pub fn encrypt_keys_with_shared_secrets(
+        &self,
+    ) -> Result<HashMap<SilentPaymentAddress, EncryptedKey>> {
+        let mut res = HashMap::new();
+        let mut rng = thread_rng();
+
+        for (_, sp_address2shared_secret) in self.shared_secrets.iter() {
+            for (sp_address, shared_secret) in sp_address2shared_secret {
+                let cipher = Aes256Gcm::new_from_slice(&shared_secret.to_byte_array())
+                    .map_err(|e| Error::msg(format!("{}", e)))?;
+                let nonce = Aes256Gcm::generate_nonce(&mut rng);
+                let encrypted_key = cipher
+                    .encrypt(&nonce, self.aes_key.as_slice())
+                    .map_err(|e| Error::msg(format!("{}", e)))?;
+
+                let mut ciphertext = Vec::<u8>::with_capacity(nonce.len() + encrypted_key.len());
+                ciphertext.extend(nonce);
+                ciphertext.extend(encrypted_key);
+
+                res.insert(sp_address.to_owned(), ciphertext);
+            }
+        }
+        Ok(res)
+    }
+
+    pub fn import_key(
+        purpose: Purpose,
+        plaintext: Vec<u8>,
+        aes_key: [u8; 32],
+        nonce: [u8; 12],
+    ) -> Result<Self> {
+        if plaintext.len() == 0 {
+            return Err(Error::msg("Can't create encryption for an empty message"));
+        }
+        Ok(Self {
+            purpose,
+            plaintext,
+            aes_key,
+            nonce,
+            shared_secrets: HashMap::new(),
+        })
+    }
+
+    pub fn encrypt_with_aes_key(&self) -> Result<CipherText> {
+        match self.purpose {
+            Purpose::Login => self.encrypt_login(),
+            Purpose::ThirtyTwoBytes => self.encrypt_thirty_two(),
+            Purpose::Arbitrary => self.encrypt_arbitrary(),
+        }
+    }
+
+    fn encrypt_login(&self) -> Result<CipherText> {
+        let half_key: HalfKey = self.plaintext.clone().try_into()?;
+        let cipher = Aes256Gcm::new(&self.aes_key.into());
+        let cipher_text = cipher
+            .encrypt(&self.nonce.into(), half_key.as_slice())
+            .map_err(|e| Error::msg(format!("{}", e)))?;
+        let mut res = Vec::with_capacity(self.nonce.len() + cipher_text.len());
+        res.extend_from_slice(&self.nonce);
+        res.extend_from_slice(&cipher_text);
+        Ok(res)
+    }
+
+    fn encrypt_thirty_two(&self) -> Result<CipherText> {
+        if self.plaintext.len() != 32 {
+            return Err(Error::msg("Invalid length, should be 32"));
+        }
+        let mut thirty_two = [0u8; 32];
+        thirty_two.copy_from_slice(&self.plaintext);
+        let cipher = Aes256Gcm::new(&self.aes_key.into());
+        let cipher_text = cipher
+            .encrypt(&self.nonce.into(), thirty_two.as_slice())
+            .map_err(|e| Error::msg(format!("{}", e)))?;
+        let mut res = Vec::with_capacity(self.nonce.len() + cipher_text.len());
+        res.extend_from_slice(&self.nonce);
+        res.extend_from_slice(&cipher_text);
+        Ok(res)
+    }
+
+    fn encrypt_arbitrary(&self) -> Result<CipherText> {
+        let cipher = Aes256Gcm::new(&self.aes_key.into());
+        let payload = Payload {
+            msg: &self.plaintext,
+            aad: AAD,
+        };
+        let cipher_text = cipher
+            .encrypt(&self.nonce.into(), payload)
+            .map_err(|e| Error::msg(format!("{}", e)))?;
+        let mut res = Vec::with_capacity(self.nonce.len() + cipher_text.len());
+        res.extend_from_slice(&self.nonce);
+        res.extend_from_slice(&cipher_text);
+        Ok(res)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{io::Read, str::FromStr};
+
+    use sp_client::bitcoin::hex::FromHex;
+
+    use super::*;
+
+    const ALICE_SP_ADDRESS: &str = "tsp1qqw3lqr6xravz9nf8ntazgwwl0fqv47kfjdxsnxs6eutavqfwyv5q6qk97mmyf6dtkdyzqlu2zv6h9j2ggclk7vn705q5u2phglpq7yw3dg5rwpdz";
+    const BOB_SP_ADDRESS: &str = "tsp1qq2hlsgrj0gz8kcfkf9flqw5llz0u2vr04telqndku9mcqm6dl4fhvq60t8r78srrf56w9yr7w9e9dusc2wjqc30up6fjwnh9mw3e3veqegdmtf08";
+    const TRANSACTION: &str = "4e6d03dec558e1b6624f813bf2da7cd8d8fb1c2296684c08cf38724dcfd8d10b";
+    const ALICE_SHARED_SECRET: &str =
+        "ccf02d364c2641ca129a3fdf49de57b705896e233f7ba6d738991993ea7e2106";
+    const BOB_SHARED_SECRET: &str =
+        "15ef3e377fb842e81de52dbaaea8ba30aeb051a81043ee19264afd27353da521";
+
+    #[test]
+    fn new_aes_empty_plaintext() {
+        let plaintext = Vec::new();
+        let aes_enc = Aes256Encryption::new(Purpose::Login, plaintext);
+
+        assert!(aes_enc.is_err());
+    }
+
+    #[test]
+    fn aes_encrypt_login_invalid_length() {
+        let plaintext = "example";
+        let aes_enc_short = Aes256Encryption::new(Purpose::Login, plaintext.as_bytes().to_vec());
+
+        assert!(aes_enc_short.is_ok());
+
+        let cipher = aes_enc_short.unwrap().encrypt_with_aes_key();
+
+        assert!(cipher.is_err());
+
+        let plaintext = [1u8; 64];
+        let aes_enc_long = Aes256Encryption::new(Purpose::Login, plaintext.to_vec());
+
+        assert!(aes_enc_long.is_ok());
+
+        let cipher = aes_enc_long.unwrap().encrypt_with_aes_key();
+
+        assert!(cipher.is_err());
+    }
+
+    #[test]
+    fn aes_encrypt_login() {
+        let plaintext = [1u8; HALFKEYSIZE];
+        let aes_key = Aes256Gcm::generate_key(&mut thread_rng());
+        let nonce = Aes256Gcm::generate_nonce(&mut thread_rng());
+        let aes_enc = Aes256Encryption::import_key(
+            Purpose::Login,
+            plaintext.to_vec(),
+            aes_key.into(),
+            nonce.into(),
+        );
+
+        assert!(aes_enc.is_ok());
+
+        let cipher = aes_enc.unwrap().encrypt_with_aes_key();
+
+        assert!(cipher.is_ok());
+
+        let mut plain_key = [0u8; 32];
+        plain_key.copy_from_slice(&aes_key.to_vec());
+
+        let aes_dec =
+            Aes256Decryption::new(Purpose::Login, cipher.unwrap(), plain_key);
+
+        assert!(aes_dec.is_ok());
+    }
+}

src/error.rs

@@ -0,0 +1,41 @@
+use std::fmt;
+use std::error::Error;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, 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,4 @@
-pub mod models;
+pub mod crypto;
-pub mod wallet;
+pub mod network;
-pub mod workflows;
+pub mod silentpayments;
+pub mod error;

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,207 @@
+use anyhow::{Error, Result};
+use js_sys::Date;
+use rand::{thread_rng, RngCore};
+use serde::{Deserialize, Serialize};
+use sp_client::bitcoin::hex::{DisplayHex, FromHex};
+use sp_client::bitcoin::OutPoint;
+use tsify::Tsify;
+
+use crate::crypto::{Aes256Decryption, Purpose};
+use crate::error::AnkError;
+
+#[derive(Debug, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub enum AnkFlag {
+    NewTx,
+    Faucet,
+    Cipher,
+    Unknown,
+}
+
+impl From<&str> for AnkFlag {
+    fn from(value: &str) -> Self {
+        match value {
+            "NewTx" => Self::NewTx,
+            "Faucet" => Self::Faucet,
+            "Cipher" => Self::Cipher,
+            _ => 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,
+            _ => Self::Unknown,
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::NewTx => "NewTx",
+            Self::Faucet => "Faucet",
+            Self::Cipher => "Cipher",
+            Self::Unknown => "Unknown",
+        }
+    }
+}
+
+#[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;64];
+        thread_rng().fill_bytes(&mut buf);
+        Self { sp_address, commitment: buf.to_lower_hex_string(), error: None }
+    }
+}
+
+#[derive(Debug, 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,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct CipherMessage {
+    pub sender: String,
+    pub message: String,
+    pub error: Option<AnkError>,
+}
+
+impl CipherMessage {
+    pub fn new(sender: String, message: String) -> Self {
+        Self {
+            sender,
+            message,
+            error: None,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct AnkNetworkMsg {
+    pub flag: AnkFlag,
+    pub content: String,
+}
+
+impl AnkNetworkMsg {
+    pub fn new(flag: AnkFlag, raw: &str) -> Self {
+        Self {
+            flag,
+            content: raw.into(),
+        }
+    }
+}
+
+#[derive(Debug, Default, Serialize, Deserialize, PartialEq, Tsify, Clone)]
+pub enum CachedMessageStatus {
+    #[default]
+    NoStatus, 
+    FaucetWaiting,
+    FaucetComplete,
+    CipherWaitingTx,
+    TxWaitingCipher,
+    SentWaitingConfirmation, // we're sender and wait for commited_in to be spent
+    ReceivedMustConfirm, // we're receiver and we spend commited_in to sender
+    MustSpendConfirmation, // we're sender and we must spend confirmed_by
+    Complete,
+}
+
+/// Unique struct for both 3nk messages and notification/key exchange, both rust and ts
+/// 0. Faucet: commited_in with nothing else, status is NoStatus
+/// 1. notification:
+///     0. sender: ciphertext, plaintext, commited_in, sender, recipient, shared_secret, key
+///     1. receiver (without tx): ciphertext
+///     2. receiver (tx without msg): commited_in, commitment, recipient, shared_secret
+///     3. receiver (receive tx after msg): plaintext, key, sender, commited_in, commitment, recipient, shared_secret
+///     4. receiver (msg after tx): ciphertext, key, plaintext, sender
+/// 2. confirmation:
+///     0. receiver (spend the smallest vout that pays him in the first tx): confirmed_by
+///     1. sender (detect a transaction that pays him and spend commited_by): confirmed_by
+///     2. sender toggle status to complete when it spent confirmed_by, receiver when it detects the confirmed_by is spent
+#[derive(Debug, Default, Serialize, Deserialize, Tsify, Clone)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[allow(non_camel_case_types)]
+pub struct CachedMessage {
+    pub id: u32,
+    pub status: CachedMessageStatus,
+    pub ciphertext: Option<String>, // When we receive message we can't decrypt we only have this and commited_in_tx
+    pub plaintext: Option<String>,  // Never None when message sent
+    pub commited_in: Option<OutPoint>,
+    pub commitment: Option<String>,     // content of the op_return
+    pub sender: Option<String>,         // Never None when message sent
+    pub recipient: Option<String>,      // Never None when message sent
+    pub shared_secret: Option<String>,  // Never None when message sent
+    pub key: Option<String>,            // Never None when message sent
+    pub confirmed_by: Option<OutPoint>, // If this None, Sender keeps sending
+    pub timestamp: u64,
+    pub error: Option<AnkError>,
+}
+
+impl CachedMessage {
+    pub fn new() -> Self {
+        let mut new = Self::default();
+        let mut buf = [0u8;4];
+        thread_rng().fill_bytes(&mut buf);
+        new.id = u32::from_be_bytes(buf);
+        new.timestamp = Date::now().floor() as u64;
+        new
+    }
+
+    pub fn try_decrypt_cipher(&self, cipher: Vec<u8>) -> Result<Vec<u8>> {
+        if self.ciphertext.is_some() || self.shared_secret.is_none() {
+            return Err(Error::msg(
+                "Can't try decrypt this message, there's already a ciphertext or no shared secret"
+            ));
+        }
+        let mut shared_secret = [0u8; 32];
+        shared_secret
+            .copy_from_slice(&Vec::from_hex(self.shared_secret.as_ref().unwrap())?);
+        let aes_decrypt = Aes256Decryption::new(Purpose::Arbitrary, cipher, shared_secret)?;
+
+        aes_decrypt.decrypt_with_key()
+    }
+
+    pub fn try_decrypt_with_shared_secret(&self, shared_secret: [u8; 32]) -> Result<Vec<u8>> {
+        if self.ciphertext.is_none() || self.shared_secret.is_some() {
+            return Err(Error::msg(
+                "Can't try decrypt this message, ciphertext is none or shared_secret already found"
+            ));
+        }
+        let cipher_bin = Vec::from_hex(self.ciphertext.as_ref().unwrap())?;
+        let aes_decrypt =
+            Aes256Decryption::new(Purpose::Arbitrary, cipher_bin, shared_secret)?;
+
+        aes_decrypt.decrypt_with_key()
+    }
+}

src/silentpayments.rs

@@ -0,0 +1,215 @@
+use std::collections::HashMap;
+use std::io::Write;
+use std::str::FromStr;
+
+use anyhow::{Error, Result};
+
+use rand::{thread_rng, Rng};
+use sp_client::bitcoin::hashes::{sha256, Hash};
+use sp_client::bitcoin::hex::FromHex;
+use sp_client::bitcoin::psbt::raw;
+use sp_client::bitcoin::{Psbt, Transaction, Txid};
+use sp_client::bitcoin::{Amount, OutPoint};
+use sp_client::bitcoin::consensus::deserialize;
+use sp_client::silentpayments::sending::SilentPaymentAddress;
+use sp_client::spclient::{OwnedOutput, Recipient, SpClient, SpWallet};
+use sp_client::constants;
+
+pub fn create_transaction(sp_address: SilentPaymentAddress, sp_wallet: &SpWallet, fee_rate: Amount) -> Result<Transaction> {
+    let available_outpoints = sp_wallet.get_outputs().to_spendable_list();
+
+    // Here we need to add more heuristics about which outpoint we spend
+    // For now let's keep it simple
+
+    let mut inputs: HashMap<OutPoint, OwnedOutput> = HashMap::new();
+
+    let mut total_available = Amount::from_sat(0);
+    for (outpoint, output) in available_outpoints {
+        total_available += output.amount;
+        inputs.insert(outpoint, output);
+        if total_available > Amount::from_sat(1000) {
+            break;
+        }
+    }
+
+    if total_available < Amount::from_sat(1000) {
+        return Err(Error::msg("Not enough available funds"));
+    }
+
+    let recipient = Recipient {
+        address: sp_address.into(),
+        amount: Amount::from_sat(1000),
+        nb_outputs: 1,
+    };
+
+    let mut new_psbt = sp_wallet.get_client().create_new_psbt(
+        inputs,
+        vec![recipient],
+        None,
+    )?;
+
+    let change_addr = sp_wallet.get_client().sp_receiver.get_change_address();
+    SpClient::set_fees(&mut new_psbt, fee_rate, change_addr)?;
+
+    let partial_secret = sp_wallet
+        .get_client()
+        .get_partial_secret_from_psbt(&new_psbt)?;
+
+    // This wouldn't work with many recipients in the same transaction
+    // each address (or more precisely each scan public key) would have its own point
+    // let shared_point = shared_secret_point(&sp_address.get_scan_key(), &partial_secret);
+
+    sp_wallet
+        .get_client()
+        .fill_sp_outputs(&mut new_psbt, partial_secret)?;
+    let mut aux_rand = [0u8; 32];
+    rand::thread_rng().fill(&mut aux_rand);
+    let mut signed = sp_wallet.get_client().sign_psbt(new_psbt, &aux_rand)?;
+    SpClient::finalize_psbt(&mut signed)?;
+
+    let final_tx = signed.extract_tx()?;
+
+    Ok(final_tx)
+}
+
+pub fn create_transaction_spend_outpoint(
+    outpoint: &OutPoint,
+    sp_wallet: &SpWallet,
+    mut recipient: Recipient,
+    commited_in_txid: &Txid,
+    fee_rate: Amount
+) -> Result<Psbt> {
+    let available_outpoints = sp_wallet.get_outputs().to_spendable_list();
+
+    let mut inputs: HashMap<OutPoint, OwnedOutput> = HashMap::new();
+    let mut total_available = Amount::from_sat(0);
+    let (must_outpoint, must_output) = available_outpoints.get_key_value(outpoint).ok_or_else(|| Error::msg("Mandatory outpoint unknown"))?;
+    total_available += must_output.amount;
+    inputs.insert(*must_outpoint, must_output.clone());
+
+    for (outpoint, output) in available_outpoints {
+        if total_available > Amount::from_sat(1000) {
+            break;
+        }
+        total_available += output.amount;
+        inputs.insert(outpoint, output);
+    }
+
+    if total_available < Amount::from_sat(1000) {
+        return Err(Error::msg("Not enough available funds"));
+    }
+
+    // update the amount for the recipient
+    recipient.amount = total_available;
+
+    // Take the recipient address
+    let address = recipient.address.clone();
+
+    // create a dummy commitment that is H(b_scan | commited_in txid)
+    let mut buf = [0u8;64];
+    buf[..32].copy_from_slice(commited_in_txid.as_raw_hash().as_byte_array());
+    buf[32..].copy_from_slice(&sp_wallet.get_client().get_scan_key().secret_bytes());
+ 
+    let mut engine = sha256::HashEngine::default();
+    engine.write_all(&buf)?;
+    let hash = sha256::Hash::from_engine(engine);
+
+    let mut new_psbt = sp_wallet.get_client().create_new_psbt(
+        inputs,
+        vec![recipient],
+        Some(hash.as_byte_array()),
+    )?;
+
+    SpClient::set_fees(&mut new_psbt, fee_rate, address)?;
+
+    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 create_transaction_for_address_with_shared_secret(
+    recipient: Recipient,
+    sp_wallet: &SpWallet,
+    message: Option<&str>,
+    fee_rate: Amount,
+) -> Result<String> {
+    let available_outpoints = sp_wallet.get_outputs().to_spendable_list();
+
+    // Here we need to add more heuristics about which outpoint we spend
+    // For now let's keep it simple
+
+    let mut inputs: HashMap<OutPoint, OwnedOutput> = HashMap::new();
+
+    let mut total_available = Amount::from_sat(0);
+    for (outpoint, output) in available_outpoints {
+        total_available += output.amount;
+        inputs.insert(outpoint, output);
+        if total_available > Amount::from_sat(1000) {
+            break;
+        }
+    }
+
+    if total_available < Amount::from_sat(1000) {
+        return Err(Error::msg("Not enough available funds"));
+    }
+
+    let message_bin = if message.is_some() { Vec::from_hex(message.unwrap())? } else { vec![] };
+
+    let mut new_psbt = sp_wallet.get_client().create_new_psbt(
+        inputs,
+        vec![recipient],
+        if !message_bin.is_empty() { Some(&message_bin) } else { None },
+    )?;
+
+    let change_addr = sp_wallet.get_client().sp_receiver.get_change_address();
+    SpClient::set_fees(&mut new_psbt, fee_rate, change_addr)?;
+
+    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];
+    rand::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.to_string())
+}
+
+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)
+}

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
-        );
-    }
-}