From a7e9aefd40394dda4a97aa44ec9e201547f5db46 Mon Sep 17 00:00:00 2001 From: chriseth Date: Sat, 10 Dec 2022 19:46:28 +0100 Subject: [PATCH] Import from json. --- Cargo.toml | 4 +- src/lib.rs | 1 + src/safe_db/db.rs | 16 ++++++ src/safe_db/mod.rs | 2 + src/safe_db/safes_json.rs | 115 ++++++++++++++++++++++++++++++++++++++ src/types/mod.rs | 4 ++ src/types/safe.rs | 12 ++++ src/types/token.rs | 6 ++ 8 files changed, 159 insertions(+), 1 deletion(-) create mode 100644 src/safe_db/db.rs create mode 100644 src/safe_db/mod.rs create mode 100644 src/safe_db/safes_json.rs create mode 100644 src/types/safe.rs create mode 100644 src/types/token.rs diff --git a/Cargo.toml b/Cargo.toml index e2bc544..54c40bb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,4 +8,6 @@ default-run = "server" [dependencies] json = "^0.12.4" -num-bigint = "^0.4.3" \ No newline at end of file +num-bigint = "^0.4.3" +serde = { version = "1.0.149", features = ["serde_derive"] } +serde_json = "1.0.89" diff --git a/src/lib.rs b/src/lib.rs index 6e76e80..2cf0709 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,5 @@ pub mod graph; pub mod io; +pub mod safe_db; pub mod server; pub mod types; diff --git a/src/safe_db/db.rs b/src/safe_db/db.rs new file mode 100644 index 0000000..7fcef0f --- /dev/null +++ b/src/safe_db/db.rs @@ -0,0 +1,16 @@ +use std::collections::BTreeMap; + +use crate::types::{Address, Safe}; + +#[derive(Default, Debug)] +pub struct DB { + safes: BTreeMap, + token_owner: BTreeMap, +} + +impl DB { + pub fn new(safes: BTreeMap, token_owner: BTreeMap) -> DB { + println!("{} safes, {} tokens", safes.len(), token_owner.len()); + DB { safes, token_owner } + } +} diff --git a/src/safe_db/mod.rs b/src/safe_db/mod.rs new file mode 100644 index 0000000..d50cd0e --- /dev/null +++ b/src/safe_db/mod.rs @@ -0,0 +1,2 @@ +mod db; +mod safes_json; diff --git a/src/safe_db/safes_json.rs b/src/safe_db/safes_json.rs new file mode 100644 index 0000000..e70dce9 --- /dev/null +++ b/src/safe_db/safes_json.rs @@ -0,0 +1,115 @@ +use serde::Deserialize; +use std::collections::BTreeMap; +use std::fs::read_to_string; + +use crate::types::{Address, Safe}; + +use super::db::DB; + +pub fn import_from_safes_json(file: &str) -> DB { + let contents = read_to_string(file).unwrap(); + let db: Safes = serde_json::from_str(&contents).unwrap(); + + let mut safes: BTreeMap = Default::default(); + let mut token_owner: BTreeMap = Default::default(); + + for json_safe in &db.safes { + let address: Address = json_safe.id.into(); + let mut s = Safe { + organization: json_safe.organization, + ..Default::default() + }; + for balance in &json_safe.balances { + let token_address: Address = balance.token.id.into(); + let owner: Address = balance.token.owner.id.into(); + s.balances.insert(token_address, balance.amount.into()); + if owner == address { + s.token_address = token_address; + } + token_owner.insert(token_address, owner); + } + safes.insert(address, s); + } + + for json_safe in db.safes { + for connection in json_safe.outgoing.iter().chain(json_safe.incoming.iter()) { + let send_to: Address = connection.can_send_to_address.into(); + let user: Address = connection.user_address.into(); + let limit_percentage: u8 = connection.limit_percentage.parse().unwrap(); + assert!(limit_percentage <= 100); + if send_to != Address::default() + && user != Address::default() + && send_to != user + && limit_percentage > 0 + { + safes + .get_mut(&user) + .unwrap() + .limit_percentage + .insert(send_to, limit_percentage); + } + } + } + DB::new(safes, token_owner) +} + +#[derive(Deserialize, Debug)] +#[serde(deny_unknown_fields)] +#[serde(rename_all = "camelCase")] +struct Safes<'a> { + block_number: &'a str, + safes: Vec>, +} + +#[derive(Deserialize, Debug)] +#[serde(deny_unknown_fields)] +#[serde(rename_all = "camelCase")] +struct JsonSafe<'a> { + id: &'a str, + organization: bool, + outgoing: Vec>, + incoming: Vec>, + balances: Vec>, +} + +#[derive(Deserialize, Debug)] +#[serde(deny_unknown_fields)] +#[serde(rename_all = "camelCase")] +struct Edge<'a> { + limit: Option<&'a str>, + limit_percentage: &'a str, + can_send_to_address: &'a str, + user_address: &'a str, +} + +#[derive(Deserialize, Debug)] +#[serde(deny_unknown_fields)] +#[serde(rename_all = "camelCase")] +struct Balance<'a> { + amount: &'a str, + token: Token<'a>, +} + +#[derive(Deserialize, Debug)] +#[serde(deny_unknown_fields)] +#[serde(rename_all = "camelCase")] +struct Token<'a> { + id: &'a str, + owner: Owner<'a>, +} + +#[derive(Deserialize, Debug)] +#[serde(deny_unknown_fields)] +#[serde(rename_all = "camelCase")] +struct Owner<'a> { + id: &'a str, +} + +mod test { + use super::*; + + #[test] + pub fn t1() { + import_from_safes_json("/tmp/safes.json"); + } +} diff --git a/src/types/mod.rs b/src/types/mod.rs index 7a8914a..460dff8 100644 --- a/src/types/mod.rs +++ b/src/types/mod.rs @@ -1,7 +1,11 @@ pub mod address; pub mod edge; +pub mod safe; +pub mod token; pub mod u256; pub use address::Address; pub use edge::Edge; +pub use safe::Safe; +pub use token::Token; pub use u256::U256; diff --git a/src/types/safe.rs b/src/types/safe.rs new file mode 100644 index 0000000..4cb82df --- /dev/null +++ b/src/types/safe.rs @@ -0,0 +1,12 @@ +use std::collections::BTreeMap; + +use super::{Address, U256}; + +#[derive(Default, Debug)] +pub struct Safe { + pub token_address: Address, + pub balances: BTreeMap, + /// Limit percentage in "send to" direction + pub limit_percentage: BTreeMap, + pub organization: bool, +} diff --git a/src/types/token.rs b/src/types/token.rs new file mode 100644 index 0000000..1d74fc6 --- /dev/null +++ b/src/types/token.rs @@ -0,0 +1,6 @@ +use super::Address; + +pub struct Token { + address: Address, + owner: Address, +}