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

Replace MemberOutpointMap with OutPointMemberMap

Browse Source
This commit is contained in:
NicolasCantu 2025-01-21 11:05:18 +01:00
parent 51531a0f44
commit a4a81f42f1
2 changed files with 16 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
src/network.rs
View File

@ -2,8 +2,7 @@ use std::collections::HashMap;
use anyhow::Result; use anyhow::Result;
use rand::{thread_rng, RngCore}; use rand::{thread_rng, RngCore};
use serde::ser::SerializeStruct; use serde::{Deserialize, Serialize};
use serde::{Deserialize, Serialize, Serializer};
use serde_json::Value; use serde_json::Value;
use sp_client::bitcoin::consensus::serialize; use sp_client::bitcoin::consensus::serialize;
use sp_client::bitcoin::hex::DisplayHex; use sp_client::bitcoin::hex::DisplayHex;
@ -11,8 +10,8 @@ use sp_client::bitcoin::{OutPoint, Transaction};
use tsify::Tsify; use tsify::Tsify;
use crate::error::AnkError; use crate::error::AnkError;
use crate::pcd::{Member, RoleDefinition}; use crate::pcd::RoleDefinition;
use crate::process::Process; use crate::serialization::{OutPointMemberMap, OutPointProcessMap};
use crate::signature::Proof; use crate::signature::Proof;
#[derive(Debug, Serialize, Deserialize, Tsify)] #[derive(Debug, Serialize, Deserialize, Tsify)]
@ -169,42 +168,16 @@ impl NewTxMessage {
} }
} }
#[derive(Debug, PartialEq, Deserialize, Tsify)] #[derive(Debug, Serialize, Deserialize, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)] #[tsify(into_wasm_abi, from_wasm_abi)]
pub struct HandshakeMessage { pub struct HandshakeMessage {
pub sp_address: String, pub sp_address: String,
pub peers_list: HashMap<Member, OutPoint>, pub peers_list: OutPointMemberMap,
pub processes_list: HashMap<OutPoint, Process>, pub processes_list: OutPointProcessMap,
}
impl Serialize for HandshakeMessage {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut state = serializer.serialize_struct("HandshakeMessage", 3)?;
state.serialize_field("sp_address", &self.sp_address)?;
let peers_list: HashMap<String, &OutPoint> = self
.peers_list
.iter()
.map(|(member, outpoint)| {
let member_str = serde_json::to_string(member).unwrap();
(member_str, outpoint)
})
.collect();
state.serialize_field("peers_list", &peers_list)?;
// Serialize `processes_list` normally
state.serialize_field("processes_list", &self.processes_list)?;
state.end()
}
} }
impl HandshakeMessage { impl HandshakeMessage {
pub fn new(sp_address: String, peers_list: HashMap<Member, OutPoint>, processes_list: HashMap<OutPoint, Process>) -> Self { pub fn new(sp_address: String, peers_list: OutPointMemberMap, processes_list: OutPointProcessMap) -> Self {
Self { Self {
sp_address, sp_address,
peers_list, peers_list,

31
src/serialization.rs
View File

@ -3,10 +3,10 @@ use sp_client::bitcoin::OutPoint;
use std::collections::HashMap; use std::collections::HashMap;
use crate::{pcd::Member, process::Process}; use crate::{pcd::Member, process::Process};
#[derive(Serialize, Deserialize)] #[derive(Debug, Serialize, Deserialize)]
pub struct MemberOutPointMap(#[serde(with = "members_map")] pub HashMap<Member, OutPoint>); pub struct OutPointMemberMap(#[serde(with = "members_map")] pub HashMap<OutPoint, Member>);
#[derive(Serialize, Deserialize)] #[derive(Debug, Serialize, Deserialize)]
pub struct OutPointProcessMap(#[serde(with = "outpoint_map")] pub HashMap<OutPoint, Process>); pub struct OutPointProcessMap(#[serde(with = "outpoint_map")] pub HashMap<OutPoint, Process>);
pub mod members_map { pub mod members_map {
@ -16,41 +16,28 @@ pub mod members_map {
use sp_client::bitcoin::OutPoint; use sp_client::bitcoin::OutPoint;
pub fn serialize<S>( pub fn serialize<S>(
map: &HashMap<Member, OutPoint>, map: &HashMap<OutPoint, Member>,
serializer: S, serializer: S,
) -> Result<S::Ok, S::Error> ) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
{ {
let map: HashMap<String, OutPoint> = map let map: HashMap<OutPoint, Member> = map
.iter() .iter()
.map(|(k, v)| (k.to_string(), *v)) .map(|(k, v)| (*k, v.to_owned()))
.collect(); .collect();
map.serialize(serializer) map.serialize(serializer)
} }
pub fn deserialize<'de, D>( pub fn deserialize<'de, D>(
deserializer: D, deserializer: D,
) -> Result<HashMap<Member, OutPoint>, D::Error> ) -> Result<HashMap<OutPoint, Member>, D::Error>
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
let map: HashMap<String, OutPoint> = HashMap::deserialize(deserializer)?; let map: HashMap<OutPoint, Member> = HashMap::deserialize(deserializer)?;
let result: Result<HashMap<Member, OutPoint>, D::Error> = map Ok(map)
.into_iter()
.map(|(k, v)| {
let member = k
.split(',')
.map(|s| s.try_into())
.collect::<Result<Vec<_>, _>>()
.map_err(serde::de::Error::custom)?;
let member = Member::new(member).map_err(serde::de::Error::custom)?;
Ok((member, v))
})
.collect();
result
} }
} }