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 rand::{thread_rng, RngCore};
use serde::ser::SerializeStruct;
use serde::{Deserialize, Serialize, Serializer};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use sp_client::bitcoin::consensus::serialize;
use sp_client::bitcoin::hex::DisplayHex;
@ -11,8 +10,8 @@ use sp_client::bitcoin::{OutPoint, Transaction};
use tsify::Tsify;
use crate::error::AnkError;
use crate::pcd::{Member, RoleDefinition};
use crate::process::Process;
use crate::pcd::RoleDefinition;
use crate::serialization::{OutPointMemberMap, OutPointProcessMap};
use crate::signature::Proof;
#[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)]
pub struct HandshakeMessage {
pub sp_address: String,
pub peers_list: HashMap<Member, OutPoint>,
pub processes_list: HashMap<OutPoint, Process>,
}
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()
}
pub peers_list: OutPointMemberMap,
pub processes_list: OutPointProcessMap,
}
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 {
sp_address,
peers_list,

31
src/serialization.rs
View File

@ -3,10 +3,10 @@ use sp_client::bitcoin::OutPoint;
use std::collections::HashMap;
use crate::{pcd::Member, process::Process};
#[derive(Serialize, Deserialize)]
pub struct MemberOutPointMap(#[serde(with = "members_map")] pub HashMap<Member, OutPoint>);
#[derive(Debug, Serialize, Deserialize)]
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 mod members_map {
@ -16,41 +16,28 @@ pub mod members_map {
use sp_client::bitcoin::OutPoint;
pub fn serialize<S>(
map: &HashMap<Member, OutPoint>,
map: &HashMap<OutPoint, Member>,
serializer: S,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let map: HashMap<String, OutPoint> = map
let map: HashMap<OutPoint, Member> = map
.iter()
.map(|(k, v)| (k.to_string(), *v))
.map(|(k, v)| (*k, v.to_owned()))
.collect();
map.serialize(serializer)
}
pub fn deserialize<'de, D>(
deserializer: D,
) -> Result<HashMap<Member, OutPoint>, D::Error>
) -> Result<HashMap<OutPoint, Member>, D::Error>
where
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
.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
Ok(map)
}
}