4nk/sdk_common
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: 4nk:dev
Branches Tags
4nk:main
4nk:dev
4nk:docker-support-v2
4nk:docker-support
4nk:docker-fixes
4nk:sync_blocks
4nk:update_build
4nk:wasm_compatibility
4nk:blindbit
4nk:fix_file_blob
4nk:temp
4nk:upgrade_spclient
4nk:update-sp-client
4nk:init-message
4nk:v0.1.1
4nk:docker-support-local-20250826-052353
..
compare: 4nk:main
Branches Tags
4nk:dev
4nk:docker-support-v2
4nk:docker-support
4nk:docker-fixes
4nk:sync_blocks
4nk:update_build
4nk:wasm_compatibility
4nk:blindbit
4nk:fix_file_blob
4nk:temp
4nk:upgrade_spclient
4nk:update-sp-client
4nk:init-message
4nk:main
4nk:v0.1.1
4nk:docker-support-local-20250826-052353

No commits in common. "dev" and "main" have entirely different histories.
dev ... main

76 changed files with 5506 additions and 4610 deletions
Show Stats Expand all files Collapse all files

39
Cargo.toml
View File

@ -6,31 +6,18 @@ edition = "2021"
[lib] [lib]
crate-type = ["cdylib", "rlib"] crate-type = ["cdylib", "rlib"]
[features]
default = []
parallel = ["sp-client/parallel"]
blindbit-backend = ["backend-blindbit-native"]
blindbit-wasm = ["backend-blindbit-wasm", "dep:js-sys", "dep:serde-wasm-bindgen", "dep:futures"]
[dependencies] [dependencies]
aes-gcm = "0.10.3" wasm-bindgen = "0.2.90"
anyhow = "1.0"
env_logger = "0.9"
log = "0.4.6"
rand = "0.8.5"
serde = { version = "1.0.193", features = ["derive"] } serde = { version = "1.0.193", features = ["derive"] }
serde_json = { version = "1.0.108" } serde_json = "1.0.108"
rs_merkle = "1.4.2" # sp_backend = { git = "https://github.com/Sosthene00/sp-backend.git", branch = "master" }
zstd = "0.13.3" # silentPayments = { git = "https://github.com/Sosthene00/rust-silentPayments", branch = "utils" }
getrandom = { version = "0.2", features = ["js"] } rand = "0.8.5"
sp-client = { git = "https://github.com/Sosthene00/sp-client.git", branch = "dev", default-features = false } hex = "0.4.3"
backend-blindbit-native = { git = "https://github.com/Sosthene00/sp-client.git", branch = "dev", optional = true } uuid = { version = "1.6.1", features = ["serde", "v4"] }
backend-blindbit-wasm = { git = "https://github.com/Sosthene00/sp-client.git", branch = "dev", optional = true } sha2 = "0.10.8"
tsify = { git = "https://github.com/Sosthene00/tsify", branch = "next" } chrono = "0.4.31"
wasm-bindgen = "0.2.91" aes-gcm = "0.10.3"
aes = "0.8.3"
# WASM-specific dependencies (optional) base64 = "0.21.7"
js-sys = { version = "0.3.69", optional = true } rocket = { version = "0.5.0", features = ["json"] }
serde-wasm-bindgen = { version = "0.6.5", optional = true }
futures = { version = "0.3", optional = true }

0
migrations.toml Normal file
View File

69
src/crypto.rs
View File

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

185
src/device.rs
View File

@ -1,185 +0,0 @@
use std::collections::HashMap;
use serde::{Deserialize, Serialize};
use tsify::Tsify;
use wasm_bindgen::prelude::*;
use sp_client::{
bitcoin::{
absolute::Height, hashes::Hash, secp256k1::PublicKey, Amount, OutPoint, Transaction,
XOnlyPublicKey,
},
silentpayments::{utils::receiving::calculate_ecdh_shared_secret, SilentPaymentAddress},
OutputSpendStatus, OwnedOutput, SpClient,
};
use crate::{pcd::Member, silentpayments::SpWallet};
#[derive(Debug, Serialize, Deserialize, Clone, Default, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct Device {
sp_wallet: SpWallet,
pairing_process_commitment: Option<OutPoint>,
paired_member: Member,
}
impl Device {
pub fn new(sp_client: SpClient) -> Self {
let local_address = sp_client.get_receiving_address();
let member = Member::new(vec![SilentPaymentAddress::try_from(local_address).unwrap()]);
Self {
sp_wallet: SpWallet::new(sp_client),
pairing_process_commitment: None,
paired_member: member,
}
}
pub fn get_sp_wallet(&self) -> &SpWallet {
&self.sp_wallet
}
pub fn get_mut_sp_wallet(&mut self) -> &mut SpWallet {
&mut self.sp_wallet
}
pub fn get_sp_client(&self) -> &SpClient {
self.sp_wallet.get_sp_client()
}
pub fn get_outputs(&self) -> &HashMap<OutPoint, OwnedOutput> {
self.sp_wallet.get_outputs()
}
pub fn get_mut_outputs(&mut self) -> &mut HashMap<OutPoint, OwnedOutput> {
self.sp_wallet.get_mut_outputs()
}
pub fn get_balance(&self) -> Amount {
self.sp_wallet
.get_outputs()
.values()
.filter(|output| output.spend_status == OutputSpendStatus::Unspent)
.fold(Amount::ZERO, |acc, x| acc + x.amount)
}
pub fn update_outputs_with_transaction(
&mut self,
tx: &Transaction,
blockheight: u32,
partial_tweak: PublicKey,
) -> anyhow::Result<HashMap<OutPoint, OwnedOutput>> {
// First check that we haven't already scanned this transaction
let txid = tx.txid();
for i in 0..tx.output.len() {
if self.sp_wallet.get_outputs().contains_key(&OutPoint {
txid,
vout: i as u32,
}) {
return Err(anyhow::Error::msg("Transaction already scanned"));
}
}
for input in tx.input.iter() {
if let Some(output) = self.sp_wallet.get_outputs().get(&input.previous_output) {
match &output.spend_status {
OutputSpendStatus::Spent(tx) => {
if *tx == txid.as_raw_hash().to_byte_array() {
return Err(anyhow::Error::msg("Transaction already scanned"));
}
}
OutputSpendStatus::Mined(_) => {
return Err(anyhow::Error::msg("Transaction already scanned"))
}
_ => continue,
}
}
}
let shared_secret = calculate_ecdh_shared_secret(
&partial_tweak,
&self.sp_wallet.get_sp_client().get_scan_key(),
);
let mut pubkeys_to_check: HashMap<XOnlyPublicKey, u32> = HashMap::new();
for (vout, output) in (0u32..).zip(tx.output.iter()) {
if output.script_pubkey.is_p2tr() {
let xonly = XOnlyPublicKey::from_slice(&output.script_pubkey.as_bytes()[2..])?;
pubkeys_to_check.insert(xonly, vout);
}
}
let ours = self
.sp_wallet
.get_sp_client()
.sp_receiver
.scan_transaction(&shared_secret, pubkeys_to_check.keys().cloned().collect())?;
let mut new_outputs: HashMap<OutPoint, OwnedOutput> = HashMap::new();
for (label, map) in ours.iter() {
for (key, scalar) in map {
let vout = pubkeys_to_check.get(&key).unwrap().to_owned();
let txout = tx.output.get(vout as usize).unwrap();
let outpoint = OutPoint::new(tx.txid(), vout);
let owned = OwnedOutput {
blockheight: Height::from_consensus(blockheight)?,
tweak: scalar.to_be_bytes(),
amount: txout.value,
script: txout.script_pubkey.to_bytes().try_into()?,
label: label.clone(),
spend_status: OutputSpendStatus::Unspent,
};
new_outputs.insert(outpoint, owned);
}
}
let mut res = new_outputs.clone();
self.sp_wallet.get_mut_outputs().extend(new_outputs);
let txid = tx.txid();
// update outputs that we own and that are spent
for input in tx.input.iter() {
if let Some(prevout) = self
.sp_wallet
.get_mut_outputs()
.get_mut(&input.previous_output)
{
// This is spent by this tx
prevout.spend_status = OutputSpendStatus::Spent(*txid.as_byte_array());
res.insert(input.previous_output, prevout.clone());
}
}
Ok(res)
}
pub fn get_pairing_commitment(&self) -> Option<OutPoint> {
self.pairing_process_commitment.clone()
}
pub fn pair(&mut self, commitment_outpoint: OutPoint, member: Member) {
self.pairing_process_commitment = Some(commitment_outpoint);
self.paired_member = member;
}
pub fn unpair(&mut self) {
let local_address = self.get_sp_client().get_receiving_address();
let member = Member::new(vec![SilentPaymentAddress::try_from(local_address).unwrap()]);
self.paired_member = member;
self.pairing_process_commitment = None;
}
pub fn to_member(&self) -> Member {
self.paired_member.clone()
}
pub fn get_address(&self) -> SilentPaymentAddress {
self.get_sp_client().get_receiving_address()
}
pub fn get_other_addresses(&self) -> Vec<String> {
let our_address: String = self.get_sp_client().get_receiving_address().into();
self.to_member()
.get_addresses()
.into_iter()
.filter(|a| *a != our_address)
.collect()
}
}

41
src/error.rs
View File

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

24
src/hash.rs
View File

@ -1,24 +0,0 @@
use sp_client::bitcoin::{
consensus::{serialize, Encodable},
hashes::{sha256t_hash_newtype, Hash, HashEngine},
OutPoint,
};
sha256t_hash_newtype! {
pub struct AnkPcdTag = hash_str("4nk/Pcd");
#[hash_newtype(forward)]
pub struct AnkPcdHash(_);
}
impl AnkPcdHash {
pub fn from_pcd_value(value: &[u8], label: &[u8], outpoint: &OutPoint) -> Self {
let mut eng = AnkPcdHash::engine();
eng.input(value);
eng.input(label);
serialize(outpoint)
.consensus_encode(&mut eng)
.expect("hash engine don't return errors");
AnkPcdHash::from_engine(eng)
}
}

135
src/lib.rs
View File

@ -1,132 +1,3 @@
use std::fmt::Debug; pub mod models;
use std::str::FromStr; pub mod wallet;
use std::sync::{Mutex, MutexGuard}; pub mod workflows;
pub use aes_gcm;
pub use env_logger;
pub use log;
pub use rand;
pub use serde;
pub use serde_json;
pub use sp_client;
pub use tsify;
pub use wasm_bindgen;
pub use zstd;
#[cfg(feature = "blindbit-wasm")]
pub use js_sys;
#[cfg(feature = "blindbit-wasm")]
pub use serde_wasm_bindgen;
#[cfg(feature = "blindbit-backend")]
pub use backend_blindbit_native;
#[cfg(feature = "blindbit-wasm")]
pub use backend_blindbit_wasm;
pub mod crypto;
pub mod device;
pub mod error;
pub mod hash;
pub mod network;
pub mod pcd;
pub mod prd;
pub mod process;
pub mod secrets;
pub mod serialization;
pub mod signature;
pub mod silentpayments;
pub mod updates;
pub const MAX_PRD_PAYLOAD_SIZE: usize = u16::MAX as usize; // 64KiB sounds reasonable for now
const DEMIURGE: &str = "demiurge";
const PAIRING: &str = "pairing";
const APOPHIS: &str = "apophis";
const MEMBERPUBLICNAME: &str = "memberPublicName";
const PAIREDADDRESSES: &str = "pairedAddresses";
const ROLESLABEL: &str = "roles";
#[derive(Debug, PartialEq, Eq)]
pub enum SpecialRoles {
Demiurge, // Only valid for the first state of a process
Pairing, // Special validation rules for pairing process
Apophis, // Users in this role have the power to destroy the process
}
impl std::fmt::Display for SpecialRoles {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", <&Self as Into<&str>>::into(self))
}
}
impl From<&SpecialRoles> for &str {
fn from(value: &SpecialRoles) -> Self {
match value {
SpecialRoles::Demiurge => DEMIURGE,
SpecialRoles::Pairing => PAIRING,
SpecialRoles::Apophis => APOPHIS,
}
}
}
impl FromStr for SpecialRoles {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
DEMIURGE => Ok(SpecialRoles::Demiurge),
PAIRING => Ok(SpecialRoles::Pairing),
APOPHIS => Ok(SpecialRoles::Apophis),
_ => Err(format!("Invalid special role: {}", s)),
}
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum ReservedFields {
PairedAddresses,
MemberPublicName,
}
impl From<&ReservedFields> for &str {
fn from(value: &ReservedFields) -> Self {
match value {
ReservedFields::MemberPublicName => MEMBERPUBLICNAME,
ReservedFields::PairedAddresses => PAIREDADDRESSES,
}
}
}
impl FromStr for ReservedFields {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
MEMBERPUBLICNAME => Ok(ReservedFields::MemberPublicName),
PAIREDADDRESSES => Ok(ReservedFields::PairedAddresses),
_ => Err(format!("Invalid field name: {}", s)),
}
}
}
pub trait MutexExt<T> {
fn lock_anyhow(&self) -> Result<MutexGuard<T>, anyhow::Error>;
}
impl<T: Debug> MutexExt<T> for Mutex<T> {
fn lock_anyhow(&self) -> Result<MutexGuard<T>, anyhow::Error> {
match self.lock() {
Ok(guard) => Ok(guard),
Err(poison_error) => {
let data = poison_error.into_inner();
log::debug!("Failed to lock Mutex (poisoned). Data was: {:?}", data);
Err(anyhow::anyhow!("Failed to lock Mutex (poisoned)"))
}
}
}
}

5
src/main.rs Normal file
View File

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

11
src/models/commitment_method.rs Normal file
View File

@ -0,0 +1,11 @@
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 }
}
}

25
src/models/condition_cap.rs Normal file
View File

@ -0,0 +1,25 @@
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
}
}

23
src/models/condition_commitment.rs Normal file
View File

@ -0,0 +1,23 @@
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
}
}

24
src/models/condition_deposit.rs Normal file
View File

@ -0,0 +1,24 @@
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
}
}

19
src/models/condition_orchestration.rs Normal file
View File

@ -0,0 +1,19 @@
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);
}
}

25
src/models/condition_payment.rs Normal file
View File

@ -0,0 +1,25 @@
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
}
}

141
src/models/condition_prd_address_set.rs Normal file
View File

@ -0,0 +1,141 @@
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.
}

49
src/models/condition_publish.rs Normal file
View File

@ -0,0 +1,49 @@
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);
}
}

8
src/models/deposit_method.rs Normal file
View File

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

94
src/models/item.rs Normal file
View File

@ -0,0 +1,94 @@
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
}

131
src/models/item_artefact.rs Normal file
View File

@ -0,0 +1,131 @@
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
);
}
}

239
src/models/item_commitment.rs Normal file
View File

@ -0,0 +1,239 @@
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`
}
}

277
src/models/item_deposit.rs Normal file
View File

@ -0,0 +1,277 @@
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
}
}

18
src/models/item_enum.rs Normal file
View File

@ -0,0 +1,18 @@
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),
}

374
src/models/item_member.rs Normal file
View File

@ -0,0 +1,374 @@
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
}
}

315
src/models/item_payment.rs Normal file
View File

@ -0,0 +1,315 @@
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
}
}

233
src/models/item_peer.rs Normal file
View File

@ -0,0 +1,233 @@
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
}
}

86
src/models/item_process.rs Normal file
View File

@ -0,0 +1,86 @@
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
}

248
src/models/key_encryption.rs Normal file
View File

@ -0,0 +1,248 @@
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)
}
}

108
src/models/message.rs Normal file
View File

@ -0,0 +1,108 @@
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
}
}

51
src/models/message_client.rs Normal file
View File

@ -0,0 +1,51 @@
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);
}
}

19
src/models/message_connect.rs Normal file
View File

@ -0,0 +1,19 @@
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
}
}

145
src/models/metadata.rs Normal file
View File

@ -0,0 +1,145 @@
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.
}

143
src/models/metadata_contract_public.rs Normal file
View File

@ -0,0 +1,143 @@
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;
}
}

143
src/models/metadata_private.rs Normal file
View File

@ -0,0 +1,143 @@
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;
}
}

152
src/models/metadata_role_confidential.rs Normal file
View File

@ -0,0 +1,152 @@
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
}

54
src/models/mod.rs Normal file
View File

@ -0,0 +1,54 @@
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;

25
src/models/pagination.rs Normal file
View File

@ -0,0 +1,25 @@
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);
}
}

8
src/models/payment_method.rs Normal file
View File

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

63
src/models/pcd_item_enc.rs Normal file
View File

@ -0,0 +1,63 @@
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
}

27
src/models/pcd_item_enc_attribute_private.rs Normal file
View File

@ -0,0 +1,27 @@
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
}

25
src/models/pcd_item_enc_attribute_public.rs Normal file
View File

@ -0,0 +1,25 @@
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
}

29
src/models/pcd_item_enc_attribute_role_confidential.rs Normal file
View File

@ -0,0 +1,29 @@
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();
}
}

63
src/models/pcd_item_generic_enc.rs Normal file
View File

@ -0,0 +1,63 @@
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
}

46
src/models/request.rs Normal file
View File

@ -0,0 +1,46 @@
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()),
)
}
}

143
src/models/request_pcd.rs Normal file
View File

@ -0,0 +1,143 @@
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,
)
}
}

108
src/models/request_prd.rs Normal file
View File

@ -0,0 +1,108 @@
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,
)
}
}

100
src/models/request_prd_confirm.rs Normal file
View File

@ -0,0 +1,100 @@
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
);
}
}

108
src/models/request_prd_key_backup.rs Normal file
View File

@ -0,0 +1,108 @@
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
)
}
}

98
src/models/request_prd_key_hello.rs Normal file
View File

@ -0,0 +1,98 @@
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
)
}
}

90
src/models/request_prd_list.rs Normal file
View File

@ -0,0 +1,90 @@
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)
}
}

89
src/models/request_prd_message.rs Normal file
View File

@ -0,0 +1,89 @@
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)
}
}

178
src/models/request_prd_response.rs Normal file
View File

@ -0,0 +1,178 @@
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()
)
}
}

127
src/models/request_prd_update.rs Normal file
View File

@ -0,0 +1,127 @@
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,
)
}
}

201
src/models/role.rs Normal file
View File

@ -0,0 +1,201 @@
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
}

20
src/models/role_artefact.rs Normal file
View File

@ -0,0 +1,20 @@
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)
}
}

20
src/models/role_commitment.rs Normal file
View File

@ -0,0 +1,20 @@
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)
}
}

20
src/models/role_deposit.rs Normal file
View File

@ -0,0 +1,20 @@
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)
}
}

18
src/models/role_member.rs Normal file
View File

@ -0,0 +1,18 @@
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)
}
}

20
src/models/role_payment.rs Normal file
View File

@ -0,0 +1,20 @@
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)
}
}

20
src/models/role_peer.rs Normal file
View File

@ -0,0 +1,20 @@
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)
}
}

18
src/models/role_process.rs Normal file
View File

@ -0,0 +1,18 @@
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)
}
}

129
src/models/roles_group.rs Normal file
View File

@ -0,0 +1,129 @@
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`
}
}
}

221
src/models/shared_peer.rs Normal file
View File

@ -0,0 +1,221 @@
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
}
}

35
src/models/shared_process.rs Normal file
View File

@ -0,0 +1,35 @@
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
);
}
}

216
src/network.rs
View File

@ -1,216 +0,0 @@
use anyhow::Result;
use rand::{thread_rng, RngCore};
use serde::{Deserialize, Serialize};
use sp_client::bitcoin::hex::DisplayHex;
use sp_client::bitcoin::OutPoint;
use tsify::Tsify;
use crate::error::AnkError;
use crate::pcd::{Pcd, PcdCommitments, Roles};
use crate::serialization::{OutPointMemberMap, OutPointProcessMap};
use crate::signature::Proof;
#[derive(Debug, Serialize, Deserialize, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub enum AnkFlag {
NewTx,
Faucet,
Cipher,
Commit,
Handshake,
Sync,
Unknown,
}
impl From<&str> for AnkFlag {
fn from(value: &str) -> Self {
match value {
"NewTx" => Self::NewTx,
"Faucet" => Self::Faucet,
"Cipher" => Self::Cipher,
"Commit" => Self::Commit,
"Handshake" => Self::Handshake,
"Sync" => Self::Sync,
_ => Self::Unknown,
}
}
}
impl From<String> for AnkFlag {
fn from(value: String) -> Self {
(&value[..]).into()
}
}
impl AnkFlag {
pub fn new_from_byte(byte: u8) -> Self {
match byte {
0 => Self::NewTx,
1 => Self::Faucet,
2 => Self::Cipher,
3 => Self::Commit,
4 => Self::Handshake,
5 => Self::Sync,
_ => Self::Unknown,
}
}
pub fn as_str(&self) -> &str {
match self {
Self::NewTx => "NewTx",
Self::Faucet => "Faucet",
Self::Cipher => "Cipher",
Self::Commit => "Commit",
Self::Handshake => "Handshake",
Self::Sync => "Sync",
Self::Unknown => "Unknown",
}
}
}
/// Message sent to the server to commit some state in a transaction
/// Client must first send a commit message with empty validation_tokens
/// Relay will ignore a commit message for an update he's not aware of that also bears validation_tokens
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct CommitMessage {
pub process_id: OutPoint,
pub pcd_commitment: PcdCommitments, // map of field <=> hash of the clear value
pub roles: Roles,
pub public_data: Pcd,
pub validation_tokens: Vec<Proof>,
pub error: Option<AnkError>,
}
impl CommitMessage {
/// Create a new commitment message for a creation/update transaction
pub fn new(
process_id: OutPoint,
pcd_commitment: PcdCommitments,
roles: Roles,
public_data: Pcd,
validation_tokens: Vec<Proof>,
) -> Self {
Self {
process_id,
pcd_commitment,
roles,
public_data,
validation_tokens,
error: None,
}
}
/// Add validation tokens for a pending commitment
pub fn add_validation_tokens(&mut self, validation_tokens: Vec<Proof>) {
self.validation_tokens.extend_from_slice(&validation_tokens);
self.validation_tokens.sort_unstable();
self.validation_tokens.dedup();
}
/// Remove all validation tokens
/// This should rarely be useful, and we'd rather let caller copy all he needs, sorts on its own
/// and clear here
pub fn clear_validation_tokens(&mut self) {
self.validation_tokens = vec![];
}
}
#[derive(Debug, Serialize, Deserialize, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct FaucetMessage {
pub sp_address: String,
pub commitment: String,
pub error: Option<AnkError>,
}
impl FaucetMessage {
pub fn new(sp_address: String) -> Self {
let mut buf = [0u8; 32];
thread_rng().fill_bytes(&mut buf);
Self {
sp_address,
commitment: buf.to_lower_hex_string(),
error: None,
}
}
pub fn to_string(&self) -> String {
serde_json::to_string(self).unwrap()
}
}
#[derive(Debug, PartialEq, Serialize, Deserialize, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct NewTxMessage {
pub transaction: String,
pub tweak_data: Option<String>,
pub error: Option<AnkError>,
}
impl NewTxMessage {
pub fn new(transaction: String, tweak_data: Option<String>) -> Self {
Self {
transaction,
tweak_data,
error: None,
}
}
pub fn to_string(&self) -> String {
serde_json::to_string(self).unwrap()
}
}
#[derive(Debug, Serialize, Deserialize, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct HandshakeMessage {
pub sp_address: String,
pub peers_list: OutPointMemberMap,
pub processes_list: OutPointProcessMap,
pub chain_tip: u32,
}
impl HandshakeMessage {
pub fn new(
sp_address: String,
peers_list: OutPointMemberMap,
processes_list: OutPointProcessMap,
chain_tip: u32,
) -> Self {
Self {
sp_address,
peers_list,
processes_list,
chain_tip,
}
}
pub fn to_string(&self) -> String {
serde_json::to_string(self).unwrap()
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Envelope {
pub flag: AnkFlag,
pub content: String,
}
impl Envelope {
pub fn new(flag: AnkFlag, raw: &str) -> Self {
Self {
flag,
content: raw.into(),
}
}
pub fn from_string(json: &str) -> Result<Self> {
let res: Self = serde_json::from_str(json)?;
Ok(res)
}
pub fn to_string(&self) -> String {
serde_json::to_string(self).unwrap()
}
}

1294
src/pcd.rs
View File

File diff suppressed because it is too large Load Diff

236
src/prd.rs
View File

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

1471
src/process.rs
View File

File diff suppressed because it is too large Load Diff

181
src/secrets.rs
View File

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

139
src/serialization.rs
View File

@ -1,139 +0,0 @@
use crate::{pcd::Member, process::Process};
use serde::de::Error;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use sp_client::bitcoin::hex::{DisplayHex, FromHex};
use sp_client::bitcoin::OutPoint;
use std::collections::{BTreeMap, HashMap};
use tsify::Tsify;
#[derive(Debug, Serialize, Deserialize, Tsify)]
#[tsify(from_wasm_abi)]
pub struct OutPointMemberMap(#[serde(with = "members_map")] pub HashMap<OutPoint, Member>);
#[derive(Debug, Serialize, Deserialize, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct OutPointProcessMap(#[serde(with = "outpoint_map")] pub HashMap<OutPoint, Process>);
// These helper functions convert a [u8; 32] to/from a hex string.
pub(crate) fn serialize_hex<S>(bytes: &[u8; 32], serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let hex_str = bytes.to_lower_hex_string();
serializer.serialize_str(&hex_str)
}
pub(crate) fn deserialize_hex<'de, D>(deserializer: D) -> Result<[u8; 32], D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let bytes = Vec::from_hex(&s).map_err(D::Error::custom)?;
if bytes.len() != 32 {
return Err(D::Error::custom("Invalid length for [u8;32]"));
}
let mut arr = [0u8; 32];
arr.copy_from_slice(&bytes);
Ok(arr)
}
pub mod members_map {
use super::*;
use crate::pcd::Member;
pub fn serialize<S>(map: &HashMap<OutPoint, Member>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let map: HashMap<OutPoint, Member> = map.iter().map(|(k, v)| (*k, v.to_owned())).collect();
map.serialize(serializer)
}
pub fn deserialize<'de, D>(deserializer: D) -> Result<HashMap<OutPoint, Member>, D::Error>
where
D: Deserializer<'de>,
{
let map: HashMap<OutPoint, Member> = HashMap::deserialize(deserializer)?;
Ok(map)
}
}
pub mod outpoint_map {
use super::*;
use crate::process::Process;
pub fn serialize<S>(map: &HashMap<OutPoint, Process>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
// Convert OutPoint keys to Strings
let map: HashMap<String, Process> = map
.into_iter()
.map(|(k, v)| (k.to_string(), v.clone()))
.collect();
// Serialize as HashMap<String, Process>
map.serialize(serializer)
}
pub fn deserialize<'de, D>(deserializer: D) -> Result<HashMap<OutPoint, Process>, D::Error>
where
D: Deserializer<'de>,
{
// Deserialize as HashMap<String, Process>
let map: HashMap<String, Process> = HashMap::deserialize(deserializer)?;
// Convert String keys back to OutPoint
let result: Result<HashMap<OutPoint, Process>, D::Error> = map
.into_iter()
.map(|(k, v)| {
let outpoint = k.parse().map_err(serde::de::Error::custom)?;
Ok((outpoint, v))
})
.collect();
result
}
}
// Custom module for converting a BTreeMap<String, [u8;32]> using hex conversion.
pub mod hex_array_btree {
use super::*;
// Serializes a BTreeMap<String, [u8; 32]> as a BTreeMap<String, String>
// where the value is a hex-encoded string.
pub fn serialize<S>(map: &BTreeMap<String, [u8; 32]>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
// Convert each [u8; 32] to a hex string.
let hex_map: BTreeMap<String, String> = map
.iter()
.map(|(k, v)| (k.clone(), v.to_lower_hex_string()))
.collect();
hex_map.serialize(serializer)
}
// Deserializes a BTreeMap<String, [u8; 32]> from a BTreeMap<String, String>
// where the value is expected to be a hex-encoded string.
pub fn deserialize<'de, D>(deserializer: D) -> Result<BTreeMap<String, [u8; 32]>, D::Error>
where
D: Deserializer<'de>,
{
// Deserialize into a temporary map with hex string values.
let hex_map: BTreeMap<String, String> = BTreeMap::deserialize(deserializer)?;
let mut map = BTreeMap::new();
// Convert each hex string back into a [u8; 32].
for (key, hex_str) in hex_map {
let bytes = Vec::from_hex(&hex_str).map_err(D::Error::custom)?;
if bytes.len() != 32 {
return Err(D::Error::custom("Invalid length for [u8;32]"));
}
let mut array = [0u8; 32];
array.copy_from_slice(&bytes);
map.insert(key, array);
}
Ok(map)
}
}

119
src/signature.rs
View File

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

230
src/silentpayments.rs
View File

@ -1,230 +0,0 @@
use std::collections::HashMap;
use anyhow::{Error, Result};
use serde::{Deserialize, Serialize};
use sp_client::bitcoin::absolute::Height;
use sp_client::bitcoin::hashes::Hash;
use sp_client::bitcoin::secp256k1::{PublicKey, SecretKey};
use tsify::Tsify;
use rand::{thread_rng, Rng};
use sp_client::bitcoin::{Amount, BlockHash, OutPoint, Transaction, TxOut, Txid, XOnlyPublicKey};
use sp_client::silentpayments::utils::receiving::calculate_ecdh_shared_secret;
use sp_client::{
FeeRate, OutputSpendStatus, OwnedOutput, Recipient, SilentPaymentUnsignedTransaction, SpClient,
};
#[derive(Debug, Default, Deserialize, Serialize, Clone)]
pub struct SpWallet {
sp_client: SpClient,
outputs: HashMap<OutPoint, OwnedOutput>,
birthday: u32,
last_scan: u32,
}
impl SpWallet {
pub fn new(sp_client: SpClient) -> Self {
Self {
sp_client,
..Default::default()
}
}
pub fn get_sp_client(&self) -> &SpClient {
&self.sp_client
}
pub fn get_outputs(&self) -> &HashMap<OutPoint, OwnedOutput> {
&self.outputs
}
pub fn get_mut_outputs(&mut self) -> &mut HashMap<OutPoint, OwnedOutput> {
&mut self.outputs
}
pub fn get_unspent_outputs(&self) -> HashMap<OutPoint, OwnedOutput> {
self.outputs
.iter()
.filter(|(_, output)| output.spend_status == OutputSpendStatus::Unspent)
.map(|(outpoint, output)| (*outpoint, output.clone()))
.collect()
}
pub fn get_balance(&self) -> Amount {
self.outputs
.values()
.filter(|output| output.spend_status == OutputSpendStatus::Unspent)
.fold(Amount::ZERO, |acc, x| acc + x.amount)
}
pub fn get_birthday(&self) -> u32 {
self.birthday
}
pub fn set_birthday(&mut self, birthday: u32) {
self.birthday = birthday;
}
pub fn get_last_scan(&self) -> u32 {
self.last_scan
}
pub fn set_last_scan(&mut self, last_scan: u32) {
self.last_scan = last_scan;
}
pub fn mark_output_spent(&mut self, outpoint: &OutPoint, txid: &Txid) {
if let Some(output) = self.outputs.get_mut(outpoint) {
output.spend_status = OutputSpendStatus::Spent(txid.to_byte_array());
}
}
pub fn mark_output_mined(&mut self, outpoint: &OutPoint, blk_hash: BlockHash) {
if let Some(output) = self.outputs.get_mut(outpoint) {
output.spend_status = OutputSpendStatus::Mined(blk_hash.to_byte_array());
}
}
fn check_inputs(&mut self, tx: &Transaction) {
for input in &tx.input {
if let Some(output) = self.outputs.get(&input.previous_output) {
if output.spend_status != OutputSpendStatus::Unspent {
log::debug!("Input is already spent: {:?}", input.previous_output);
continue;
} else {
self.mark_output_spent(&input.previous_output, &tx.txid());
}
}
}
}
pub fn update_with_transaction(
&mut self,
tx: &Transaction,
public_tweak: &PublicKey,
height: u32,
) -> Result<HashMap<OutPoint, OwnedOutput>> {
// Check if we have outputs that are spent by this transaction
self.check_inputs(tx);
let receiver = &self.get_sp_client().sp_receiver;
let p2tr_outs: Vec<(usize, &TxOut)> = tx
.output
.iter()
.enumerate()
.filter(|(_, o)| o.script_pubkey.is_p2tr())
.collect();
if p2tr_outs.is_empty() {
return Err(Error::msg("No taproot outputs"));
}; // That should never happen since we have a tweak_data, but anyway
// Now we can just run sp_receiver on all the p2tr outputs
let xonlykeys: Result<Vec<XOnlyPublicKey>> = p2tr_outs
.iter()
.map(|(_, o)| {
XOnlyPublicKey::from_slice(&o.script_pubkey.as_bytes()[2..]).map_err(Error::new)
})
.collect();
let tweak_data = calculate_ecdh_shared_secret(public_tweak, &self.sp_client.get_scan_key());
let ours = receiver.scan_transaction(&tweak_data, xonlykeys?)?;
let txid = tx.txid();
let height = Height::from_consensus(height)?;
let mut res = HashMap::new();
for (label, map) in ours.iter() {
res.extend(p2tr_outs.iter().filter_map(|(i, o)| {
match XOnlyPublicKey::from_slice(&o.script_pubkey.as_bytes()[2..]) {
Ok(key) => {
if let Some(scalar) = map.get(&key) {
match SecretKey::from_slice(&scalar.to_be_bytes()) {
Ok(tweak) => {
let outpoint = OutPoint {
txid,
vout: *i as u32,
};
return Some((
outpoint,
OwnedOutput {
blockheight: height,
tweak: tweak.secret_bytes(),
amount: o.value,
script: o.script_pubkey.clone(),
label: label.clone(),
spend_status: OutputSpendStatus::Unspent,
},
));
}
Err(_) => {
return None;
}
}
}
None
}
Err(_) => None,
}
}));
}
self.get_mut_outputs().extend(res.clone());
Ok(res)
}
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Tsify)]
#[tsify(from_wasm_abi)]
pub struct TsUnsignedTransaction(SilentPaymentUnsignedTransaction);
impl TsUnsignedTransaction {
pub fn new(unsigned_tx: SilentPaymentUnsignedTransaction) -> Self {
Self(unsigned_tx)
}
pub fn as_inner(&self) -> &SilentPaymentUnsignedTransaction {
&self.0
}
pub fn to_inner(self) -> SilentPaymentUnsignedTransaction {
self.0
}
}
pub fn create_transaction(
available_outpoints: Vec<(OutPoint, OwnedOutput)>,
sp_client: &SpClient,
mut recipients: Vec<Recipient>,
payload: Option<Vec<u8>>,
fee_rate: FeeRate,
) -> Result<SilentPaymentUnsignedTransaction> {
let mut commitment = [0u8; 32];
if let Some(ref p) = payload {
commitment.copy_from_slice(&p);
} else {
thread_rng().fill(&mut commitment);
}
recipients.push(Recipient {
address: sp_client::RecipientAddress::Data(commitment.to_vec()),
amount: Amount::ZERO,
});
let new_transaction = sp_client.create_new_transaction(
available_outpoints,
recipients,
fee_rate,
sp_client.get_network(),
)?;
let finalized_transaction = SpClient::finalize_transaction(new_transaction)?;
Ok(finalized_transaction)
}
pub fn sign_transaction(
sp_client: &SpClient,
unsigned_transaction: SilentPaymentUnsignedTransaction,
) -> Result<Transaction> {
let mut aux_rand = [0u8; 32];
thread_rng().fill(&mut aux_rand);
sp_client.sign_transaction(unsigned_transaction, &aux_rand)
}

247
src/updates.rs
View File

@ -1,247 +0,0 @@
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::mem;
use sp_client::{
bitcoin::{absolute::Height, BlockHash, OutPoint},
OwnedOutput, Updater,
};
use std::collections::{HashMap, HashSet};
#[derive(Debug, Serialize, Deserialize)]
pub struct ScanProgress {
pub start: u32,
pub current: u32,
pub end: u32,
}
#[derive(Debug, Serialize, Deserialize)]
pub enum StateUpdate {
NoUpdate {
blkheight: Height,
},
Update {
blkheight: Height,
blkhash: BlockHash,
found_outputs: HashMap<OutPoint, OwnedOutput>,
found_inputs: HashSet<OutPoint>,
},
}
#[cfg(all(not(target_arch = "wasm32"), not(feature = "blindbit-wasm")))]
use std::sync::{mpsc::{self, Receiver, Sender}};
#[cfg(all(not(target_arch = "wasm32"), not(feature = "blindbit-wasm")))]
pub trait UpdateSink: Send + Sync {
fn send_scan_progress(&self, progress: ScanProgress) -> Result<()>;
fn send_state_update(&self, update: StateUpdate) -> Result<()>;
}
#[cfg(all(target_arch = "wasm32", feature = "blindbit-wasm"))]
pub trait UpdateSink {
fn send_scan_progress(&self, progress: ScanProgress) -> Result<()>;
fn send_state_update(&self, update: StateUpdate) -> Result<()>;
}
#[cfg(all(not(target_arch = "wasm32"), not(feature = "blindbit-wasm")))]
pub struct NativeUpdateSink {
scan_tx: Sender<ScanProgress>,
state_tx: Sender<StateUpdate>,
}
#[cfg(all(not(target_arch = "wasm32"), not(feature = "blindbit-wasm")))]
impl NativeUpdateSink {
pub fn new() -> (Self, Receiver<ScanProgress>, Receiver<StateUpdate>) {
let (scan_tx, scan_rx) = mpsc::channel();
let (state_tx, state_rx) = mpsc::channel();
(Self { scan_tx, state_tx }, scan_rx, state_rx)
}
}
#[cfg(all(not(target_arch = "wasm32"), not(feature = "blindbit-wasm")))]
impl UpdateSink for NativeUpdateSink {
fn send_scan_progress(&self, progress: ScanProgress) -> Result<()> {
self.scan_tx.send(progress)?;
Ok(())
}
fn send_state_update(&self, update: StateUpdate) -> Result<()> {
self.state_tx.send(update)?;
Ok(())
}
}
#[cfg(all(target_arch = "wasm32", feature = "blindbit-wasm"))]
use futures::channel::mpsc::{unbounded, UnboundedSender, UnboundedReceiver};
#[cfg(all(target_arch = "wasm32", feature = "blindbit-wasm"))]
pub struct WasmUpdateSink {
scan_tx: UnboundedSender<ScanProgress>,
state_tx: UnboundedSender<StateUpdate>,
}
#[cfg(all(target_arch = "wasm32", feature = "blindbit-wasm"))]
impl WasmUpdateSink {
pub fn new() -> (Rc<Self>, UnboundedReceiver<ScanProgress>, UnboundedReceiver<StateUpdate>) {
let (scan_tx, scan_rx) = unbounded();
let (state_tx, state_rx) = unbounded();
(Rc::new(Self { scan_tx, state_tx }), scan_rx, state_rx)
}
}
#[cfg(all(target_arch = "wasm32", feature = "blindbit-wasm"))]
impl UpdateSink for WasmUpdateSink {
fn send_scan_progress(&self, progress: ScanProgress) -> Result<()> {
self.scan_tx.unbounded_send(progress)
.map_err(|e| anyhow::Error::msg(format!("Failed to send scan progress: {}", e)))?;
Ok(())
}
fn send_state_update(&self, update: StateUpdate) -> Result<()> {
self.state_tx.unbounded_send(update)
.map_err(|e| anyhow::Error::msg(format!("Failed to send state update: {}", e)))?;
Ok(())
}
}
#[cfg(all(not(target_arch = "wasm32"), not(feature = "blindbit-wasm")))]
use std::sync::{Arc, RwLock};
#[cfg(all(not(target_arch = "wasm32"), not(feature = "blindbit-wasm")))]
// Global sink instance
static UPDATE_SINK: RwLock<Option<Arc<dyn UpdateSink>>> = RwLock::new(None);
#[cfg(all(target_arch = "wasm32", feature = "blindbit-wasm"))]
use std::cell::RefCell;
use std::rc::Rc;
#[cfg(all(target_arch = "wasm32", feature = "blindbit-wasm"))]
thread_local! {
static UPDATE_SINK: RefCell<Option<Rc<dyn UpdateSink>>> = RefCell::new(None);
}
#[cfg(all(not(target_arch = "wasm32"), not(feature = "blindbit-wasm")))]
pub fn init_update_sink(sink: Arc<dyn UpdateSink>) {
let mut sink_guard = UPDATE_SINK.write().unwrap();
*sink_guard = Some(sink);
}
#[cfg(all(not(target_arch = "wasm32"), not(feature = "blindbit-wasm")))]
pub fn get_update_sink() -> Option<Arc<dyn UpdateSink>> {
UPDATE_SINK.read().unwrap().clone()
}
#[cfg(all(target_arch = "wasm32", feature = "blindbit-wasm"))]
pub fn init_update_sink(sink: Rc<dyn UpdateSink>) {
UPDATE_SINK.with(|cell| {
*cell.borrow_mut() = Some(sink);
});
}
#[cfg(all(target_arch = "wasm32", feature = "blindbit-wasm"))]
pub fn get_update_sink() -> Option<Rc<dyn UpdateSink>> {
UPDATE_SINK.with(|cell| cell.borrow().clone())
}
#[derive(Debug)]
pub struct StateUpdater {
update: bool,
blkhash: Option<BlockHash>,
blkheight: Option<Height>,
found_outputs: HashMap<OutPoint, OwnedOutput>,
found_inputs: HashSet<OutPoint>,
}
impl StateUpdater {
pub fn new() -> Self {
Self {
update: false,
blkheight: None,
blkhash: None,
found_outputs: HashMap::new(),
found_inputs: HashSet::new(),
}
}
pub fn to_update(&mut self) -> Result<StateUpdate> {
let blkheight = self
.blkheight
.ok_or(anyhow::Error::msg("blkheight not filled"))?;
if self.update {
self.update = false;
let blkhash = self.blkhash.ok_or(anyhow::Error::msg("blkhash not set"))?;
self.blkheight = None;
self.blkhash = None;
// take results, and insert new empty values
let found_inputs = mem::take(&mut self.found_inputs);
let found_outputs = mem::take(&mut self.found_outputs);
Ok(StateUpdate::Update {
blkheight,
blkhash,
found_outputs,
found_inputs,
})
} else {
Ok(StateUpdate::NoUpdate { blkheight })
}
}
}
impl Updater for StateUpdater {
fn record_scan_progress(&mut self, start: Height, current: Height, end: Height) -> Result<()> {
self.blkheight = Some(current);
if let Some(sink) = get_update_sink() {
sink.send_scan_progress(ScanProgress {
start: start.to_consensus_u32(),
current: current.to_consensus_u32(),
end: end.to_consensus_u32(),
})?;
}
Ok(())
}
fn record_block_outputs(
&mut self,
height: Height,
blkhash: BlockHash,
found_outputs: HashMap<OutPoint, OwnedOutput>,
) -> Result<()> {
// may have already been written by record_block_inputs
self.update = true;
self.found_outputs = found_outputs;
self.blkhash = Some(blkhash);
self.blkheight = Some(height);
Ok(())
}
fn record_block_inputs(
&mut self,
blkheight: Height,
blkhash: BlockHash,
found_inputs: HashSet<OutPoint>,
) -> Result<()> {
self.update = true;
self.blkheight = Some(blkheight);
self.blkhash = Some(blkhash);
self.found_inputs = found_inputs;
Ok(())
}
fn save_to_persistent_storage(&mut self) -> Result<()> {
if let Some(sink) = get_update_sink() {
sink.send_state_update(self.to_update()?)?;
}
Ok(())
}
}

27
src/wallet.rs Normal file
View File

@ -0,0 +1,27 @@
// 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,
}
}
}
*/

0
src/workflows/lib.rs Normal file
View File

1
src/workflows/mod.rs Normal file
View File

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

253
src/workflows/workflow_pcd_create_and_send_all.rs Normal file
View File

@ -0,0 +1,253 @@
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
);
}
}