From 6713e7c075ea8f15494f8c37834ee9ba4d65a699 Mon Sep 17 00:00:00 2001 From: Michael Vlasov Date: Mon, 19 Sep 2022 12:44:09 +0300 Subject: [PATCH 1/2] FIX: Do not retry in case of Authorization error (SDK-3780) --- Cargo.lock | 40 +++++++------- ton_client/src/error.rs | 5 ++ ton_client/src/net/endpoint.rs | 14 +++-- ton_client/src/net/errors.rs | 18 +++++-- ton_client/src/net/server_link.rs | 31 ++++++++--- ton_client/src/net/tests.rs | 18 +++++++ ton_client/src/tests/mod.rs | 88 +++++++++++++++++++++++++------ 7 files changed, 162 insertions(+), 52 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 41d8461de..397d5773d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -69,9 +69,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.64" +version = "1.0.65" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9a8f622bcf6ff3df478e9deba3e03e4e04b300f8e6a139e192c05fa3490afc7" +checksum = "98161a4e3e2184da77bb14f02184cdd111e83bbbcc9979dfee3c44b9a85f5602" [[package]] name = "api_derive" @@ -1039,9 +1039,9 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.47" +version = "0.1.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c495f162af0bf17656d0014a0eded5f3cd2f365fdd204548c2869db89359dc7" +checksum = "237a0714f28b1ee39ccec0770ccb544eb02c9ef2c82bb096230eefcffa6468b0" dependencies = [ "android_system_properties", "core-foundation-sys", @@ -1108,9 +1108,9 @@ checksum = "879d54834c8c76457ef4293a689b2a8c59b076067ad77b15efafbb05f92a592b" [[package]] name = "itertools" -version = "0.10.3" +version = "0.10.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3" +checksum = "d8bf247779e67a9082a4790b45e71ac7cfd1321331a5c856a74a9faebdab78d0" dependencies = [ "either", ] @@ -1747,7 +1747,7 @@ checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" dependencies = [ "libc", "rand_chacha 0.3.1", - "rand_core 0.6.3", + "rand_core 0.6.4", ] [[package]] @@ -1767,7 +1767,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" dependencies = [ "ppv-lite86", - "rand_core 0.6.3", + "rand_core 0.6.4", ] [[package]] @@ -1781,9 +1781,9 @@ dependencies = [ [[package]] name = "rand_core" -version = "0.6.3" +version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" dependencies = [ "getrandom 0.2.7", ] @@ -2110,9 +2110,9 @@ dependencies = [ [[package]] name = "signature" -version = "1.6.0" +version = "1.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0ea32af43239f0d353a7dd75a22d94c329c8cdaafdcb4c1c1335aa10c298a4a" +checksum = "e90531723b08e4d6d71b791108faf51f03e1b4a7784f96b2b87f852ebc247228" [[package]] name = "similar" @@ -2208,18 +2208,18 @@ checksum = "507e9898683b6c43a9aa55b64259b721b52ba226e0f3779137e50ad114a4c90b" [[package]] name = "thiserror" -version = "1.0.34" +version = "1.0.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c1b05ca9d106ba7d2e31a9dab4a64e7be2cce415321966ea3132c49a656e252" +checksum = "c53f98874615aea268107765aa1ed8f6116782501d18e53d08b471733bea6c85" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.34" +version = "1.0.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8f2591983642de85c921015f3f070c665a197ed69e417af436115e3a1407487" +checksum = "f8b463991b4eab2d801e724172285ec4195c650e8ec79b149e6c2a8e6dd3f783" dependencies = [ "proc-macro2", "quote", @@ -2284,9 +2284,9 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c" [[package]] name = "tokio" -version = "1.21.0" +version = "1.21.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89797afd69d206ccd11fb0ea560a44bbb87731d020670e79416d442919257d42" +checksum = "0020c875007ad96677dcc890298f4b942882c5d4eb7cc8f439fc3bf813dc9c95" dependencies = [ "autocfg", "bytes", @@ -2703,9 +2703,9 @@ checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992" [[package]] name = "unicode-ident" -version = "1.0.3" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf" +checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd" [[package]] name = "unicode-normalization" diff --git a/ton_client/src/error.rs b/ton_client/src/error.rs index e7d635c94..06ec82e36 100644 --- a/ton_client/src/error.rs +++ b/ton_client/src/error.rs @@ -2,6 +2,7 @@ use crate::client::core_version; use serde_json::Value; use std::fmt::Display; use chrono::TimeZone; +use crate::net; #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default, ApiType)] pub struct ClientError { @@ -151,6 +152,10 @@ impl ClientError { self.data["account_address"] = address.to_string().into(); self } + + pub fn is_unauthorized(&self) -> bool { + self.code == net::ErrorCode::Unauthorized as u32 + } } pub(crate) fn format_time(time: u32) -> String { diff --git a/ton_client/src/net/endpoint.rs b/ton_client/src/net/endpoint.rs index 96a394f31..186babdab 100644 --- a/ton_client/src/net/endpoint.rs +++ b/ton_client/src/net/endpoint.rs @@ -79,11 +79,12 @@ impl Endpoint { fn expand_address(base_url: &str) -> String { let mut base_url = base_url.trim_end_matches("/").to_lowercase(); if !base_url.starts_with(HTTP_PROTOCOL) && !base_url.starts_with(HTTPS_PROTOCOL) { - let protocol = if base_url == "localhost" || base_url == "127.0.0.1" || base_url == "0.0.0.0" { - HTTP_PROTOCOL - } else { - HTTPS_PROTOCOL - }; + let protocol = + if base_url == "localhost" || base_url == "127.0.0.1" || base_url == "0.0.0.0" { + HTTP_PROTOCOL + } else { + HTTPS_PROTOCOL + }; base_url = format!("{}{}", protocol, base_url); }; if base_url.ends_with("/graphql") { @@ -114,6 +115,9 @@ impl Endpoint { timeout, ) .await?; + if response.status == 401 { + return Err(Error::unauthorized()); + } let query_url = response.url.trim_end_matches(query).to_owned(); let info = response.body_as_json()?["data"]["info"].to_owned(); Ok((info, query_url, response.remote_address)) diff --git a/ton_client/src/net/errors.rs b/ton_client/src/net/errors.rs index ab086d5d9..77c999e00 100644 --- a/ton_client/src/net/errors.rs +++ b/ton_client/src/net/errors.rs @@ -1,4 +1,4 @@ -use crate::error::{ClientError, format_time}; +use crate::error::{format_time, ClientError}; use serde_json::Value; use std::fmt::Display; @@ -18,6 +18,7 @@ pub enum ErrorCode { NoEndpointsProvided = 612, GraphqlWebsocketInitError = 613, NetworkModuleResumed = 614, + Unauthorized = 615, } pub struct Error; @@ -27,6 +28,10 @@ fn error(code: ErrorCode, message: String) -> ClientError { } impl Error { + pub fn unauthorized() -> ClientError { + error(ErrorCode::Unauthorized, "Unauthorized".to_string()) + } + pub fn queries_query_failed(err: E) -> ClientError { error(ErrorCode::QueryFailed, format!("Query failed: {}", err)) } @@ -38,7 +43,11 @@ impl Error { ) } - pub fn queries_wait_for_failed(err: E, filter: Option, timestamp: u32) -> ClientError { + pub fn queries_wait_for_failed( + err: E, + filter: Option, + timestamp: u32, + ) -> ClientError { let mut err = error(ErrorCode::WaitForFailed, format!("WaitFor failed: {}", err)); err.data = json!({ "filter": filter, @@ -84,7 +93,10 @@ impl Error { fn try_get_message_and_code(server_errors: &[Value]) -> (Option, Option) { for error in server_errors.iter() { if let Some(message) = error["message"].as_str() { - return (Some(message.to_string()), error["extensions"]["exception"]["code"].as_i64()); + let code = error["extensions"]["exception"]["code"] + .as_i64() + .or_else(|| error["extensions"]["code"].as_i64()); + return (Some(message.to_string()), code); } } (None, None) diff --git a/ton_client/src/net/server_link.rs b/ton_client/src/net/server_link.rs index 7e335c9b1..cf8f3749a 100644 --- a/ton_client/src/net/server_link.rs +++ b/ton_client/src/net/server_link.rs @@ -31,7 +31,7 @@ use std::sync::atomic::{AtomicBool, AtomicU32, Ordering}; use std::sync::Arc; use tokio::sync::{watch, Mutex, RwLock}; -pub const MAX_TIMEOUT: u32 = std::i32::MAX as u32; +pub const MAX_TIMEOUT: u32 = i32::MAX as u32; pub const MIN_RESUME_TIMEOUT: u32 = 500; pub const MAX_RESUME_TIMEOUT: u32 = 3000; @@ -298,6 +298,7 @@ impl NetworkState { })); } let mut selected = Err(crate::client::Error::net_module_not_init()); + let mut unauthorised = true; while futures.len() != 0 { let (result, _, remain_futures) = futures::future::select_all(futures).await; if let Ok(endpoint) = &result { @@ -306,6 +307,11 @@ impl NetworkState { } } futures = remain_futures; + if let Err(err) = &result { + if !err.is_unauthorized() { + unauthorised = false; + } + } if is_better(&result, &selected) { selected = result; } @@ -313,6 +319,9 @@ impl NetworkState { if selected.is_ok() { return selected; } + if unauthorised { + return Err(Error::unauthorized()); + } retry_count += 1; if retry_count > self.config.network_retries_count { return selected; @@ -574,13 +583,19 @@ impl ServerLink { let result = match result { Err(err) => Err(err), - Ok(response) => match response.body_as_json() { - Err(err) => Err(err), - Ok(value) => match Self::try_extract_error(&value) { - Some(err) => Err(err), - None => Ok(value), - }, - }, + Ok(response) => { + if response.status == 401 { + Err(Error::unauthorized()) + } else { + match response.body_as_json() { + Err(err) => Err(err), + Ok(value) => match Self::try_extract_error(&value) { + Some(err) => Err(err), + None => Ok(value), + }, + } + } + } }; if let Err(err) = &result { diff --git a/ton_client/src/net/tests.rs b/ton_client/src/net/tests.rs index 7093e7f56..2ab6f124c 100644 --- a/ton_client/src/net/tests.rs +++ b/ton_client/src/net/tests.rs @@ -15,6 +15,24 @@ use std::collections::HashSet; use std::sync::Arc; use std::vec; +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn not_authorized() { + let client = TestClient::new_with_config(json!({ + "network": { + "endpoints": [TestClient::with_project("main")] + } + })); + let context = client.context().clone(); + let link = context.net.server_link.as_ref().unwrap(); + let result = link.query_http(&GraphQLQuery { + query: "query { info { version } }".to_string(), + timeout: None, + variables: None, + is_batch: false, + }, None).await; + println!("{:?}", result) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn auth_header() { let client = TestClient::new_with_config(json!({ diff --git a/ton_client/src/tests/mod.rs b/ton_client/src/tests/mod.rs index 3447311dd..51274f863 100644 --- a/ton_client/src/tests/mod.rs +++ b/ton_client/src/tests/mod.rs @@ -45,14 +45,53 @@ use tokio::sync::{ mod common; -const DEFAULT_TON_USE_SE: &str = "true"; -const DEFAULT_NETWORK_ADDRESS: &str = "http://localhost"; - const ROOT_CONTRACTS_PATH: &str = "src/tests/contracts/"; const LOG_CGF_PATH: &str = "src/tests/log_cfg.yaml"; -const GIVER_ADDRESS_VAR: &str = "TON_GIVER_ADDRESS"; -const GIVER_SECRET_VAR: &str = "TON_GIVER_SECRET"; +mod env { + fn str(name: &str, alt: Option<&str>) -> Option { + if let Ok(s) = std::env::var(name) { + Some(s) + } else if let Some(alt) = alt { + std::env::var(alt).ok() + } else { + None + } + } + + pub(crate) fn giver_address() -> Option { + str("EVERCLOUD_GIVER_ADDRESS", Some("TON_GIVER_ADDRESS")) + } + + pub(crate) fn giver_secret() -> Option { + str("EVERCLOUD_GIVER_SECRET", Some("TON_GIVER_SECRET")) + } + + pub(crate) fn auth_project() -> Option { + str("EVERCLOUD_AUTH_PROJECT", None) + } + + pub(crate) fn auth_secret() -> Option { + str("EVERCLOUD_AUTH_SECRET", None) + } + + pub(crate) fn endpoints() -> String { + str("EVERCLOUD_ENDPOINTS", Some("TON_NETWORK_ADDRESS")) + .unwrap_or_else(|| "http://localhost".into()) + } + + pub(crate) fn queries_protocol() -> String { + str("EVERCLOUD_QUERIES_PROTOCOL", Some("TON_QUERIES_PROTOCOL")).unwrap_or_else(|| "".into()) + } + + pub(crate) fn node_se() -> String { + str("EVERCLOUD_NODE_SE", Some("TON_USE_SE")).unwrap_or_else(|| "true".into()) + } + + pub(crate) fn abi_version() -> String { + str("EVERCLOUD_ABI_VERSION", Some("ABI_VERSION")).unwrap_or_else(|| "2".into()) + } +} struct SimpleLogger; @@ -260,7 +299,7 @@ impl TestClient { } pub async fn giver_address(&self) -> String { - if let Ok(address) = std::env::var(GIVER_ADDRESS_VAR) { + if let Some(address) = env::giver_address() { address } else { self.calc_giver_address(Self::giver_keys()).await @@ -268,7 +307,7 @@ impl TestClient { } pub fn giver_keys() -> KeyPair { - if let Ok(secret) = std::env::var(GIVER_SECRET_VAR) { + if let Some(secret) = env::giver_secret() { let secret_key = ed25519_dalek::SecretKey::from_bytes(&hex::decode(&secret).unwrap()).unwrap(); let public_key = ed25519_dalek::PublicKey::from(&secret_key); @@ -286,21 +325,38 @@ impl TestClient { } } + pub fn auth_project() -> Option { + env::auth_project() + } + + pub fn auth_secret() -> Option { + env::auth_secret() + } + + pub fn with_project(endpoint: &str) -> String { + match Self::auth_project() { + Some(project) => { + if endpoint.ends_with('/') { + format!("{}/{}", endpoint, project) + } else { + format!("{}{}", endpoint, project) + } + } + None => endpoint.to_string(), + } + } + pub fn endpoints() -> Vec { - std::env::var("TON_NETWORK_ADDRESS") - .unwrap_or(DEFAULT_NETWORK_ADDRESS.into()) + env::endpoints() .split(",") .map(|x| x.trim()) .filter(|x| !x.is_empty()) - .map(|x| x.to_string()) + .map(|x| Self::with_project(x)) .collect() } pub fn queries_protocol() -> Option { - let protocol = std::env::var("TON_QUERIES_PROTOCOL") - .unwrap_or("".into()) - .trim() - .to_string(); + let protocol = env::queries_protocol().trim().to_string(); if protocol.is_empty() { None } else { @@ -309,11 +365,11 @@ impl TestClient { } pub fn node_se() -> bool { - std::env::var("TON_USE_SE").unwrap_or(DEFAULT_TON_USE_SE.to_owned()) == "true".to_owned() + env::node_se() == "true" } pub fn abi_version() -> u8 { - u8::from_str_radix(&std::env::var("ABI_VERSION").unwrap_or("2".to_owned()), 10).unwrap() + u8::from_str_radix(&env::abi_version(), 10).unwrap() } pub fn contracts_path(abi_version: Option) -> String { From f61d3c34efa6a28f435ea7d334ce750f7148ba4a Mon Sep 17 00:00:00 2001 From: Michael Vlasov Date: Thu, 29 Sep 2022 16:01:28 +0300 Subject: [PATCH 2/2] FIX: Test with authorisation (SDK-3790) --- README.md | 1 + ton_client/src/debot/dengine.rs | 6 +- ton_client/src/net/tests.rs | 53 --- ton_client/src/proofs/tests/mod.rs | 505 ++++++++++++++++-------- ton_client/src/tests/common.rs | 2 +- ton_client/src/tests/mod.rs | 14 +- toncli/src/request.rs | 2 +- tools/update_trusted_blocks/src/main.rs | 10 +- 8 files changed, 352 insertions(+), 241 deletions(-) diff --git a/README.md b/README.md index ce3e9a067..be3681fab 100644 --- a/README.md +++ b/README.md @@ -199,6 +199,7 @@ TON_USE_SE: true/false - flag defining if tests run against Evernode SE or a rea TON_NETWORK_ADDRESS - Dapp server or Evernode SE addresses separated by comma. TON_GIVER_SECRET - Giver secret key. If not defined, default Evernode SE giver keys are used TON_GIVER_ADDRESS - Address of the giver to use for prepaying accounts before deploying test contracts. If not defined, the address is calculated using `GiverV2.tvc` and configured public key +EVERCLOUD_AUTH_PROJECT – Evercloud project id used to authorise tests that requires main net interaction ``` ## Download precompiled binaries diff --git a/ton_client/src/debot/dengine.rs b/ton_client/src/debot/dengine.rs index 71db297d8..2edce42d5 100644 --- a/ton_client/src/debot/dengine.rs +++ b/ton_client/src/debot/dengine.rs @@ -32,7 +32,7 @@ const EMPTY_CELL: &'static str = "te6ccgEBAQEAAgAAAA=="; fn create_client(url: &str) -> Result { let cli_conf = ClientConfig { network: NetworkConfig { - server_address: Some(url.to_owned()), + endpoints: Some(vec![url.to_string()]), ..Default::default() }, ..Default::default() @@ -159,7 +159,7 @@ impl DEngine { state.clone(), addr.clone(), abi.clone(), - "getDebotInfo", + "getDebotInfo", None ).await; let mut info: DInfo = match result { @@ -170,7 +170,7 @@ impl DEngine { info.interfaces = interfaces; info.dabi_version = dabi_version; - // TODO DEPRECATED + // TODO DEPRECATED // For compatibility with previous debots that returns abi in // getDebotOptions. Remove later. if info.dabi.is_none() { diff --git a/ton_client/src/net/tests.rs b/ton_client/src/net/tests.rs index 2ab6f124c..b3ab80507 100644 --- a/ton_client/src/net/tests.rs +++ b/ton_client/src/net/tests.rs @@ -1256,59 +1256,6 @@ async fn order_by_fallback() { assert!(result.is_err()); } -#[test] -fn test_endpoints_replacement() { - let client = TestClient::new_with_config(json!({ - "network": { - "endpoints": ["main.ton.dev", "net.ton.dev"], - } - })); - - let endpoints: ResultOfGetEndpoints = client.request("net.get_endpoints", json!({})).unwrap(); - - assert_eq!( - endpoints.endpoints, - vec![ - "eri01.main.everos.dev", - "gra01.main.everos.dev", - "gra02.main.everos.dev", - "lim01.main.everos.dev", - "rbx01.main.everos.dev", - "eri01.net.everos.dev", - "rbx01.net.everos.dev", - "gra01.net.everos.dev", - ] - ); - - let client = TestClient::new_with_config(json!({ - "network": { - "endpoints": [ - "https://main2.ton.dev", - "https://main.ton.dev/", - "http://main3.ton.dev", - "main2.ton.dev", - "https://lim01.main.everos.dev", - "gra02.main.everos.dev", - ], - } - })); - - let endpoints: ResultOfGetEndpoints = client.request("net.get_endpoints", json!({})).unwrap(); - - assert_eq!( - endpoints.endpoints, - vec![ - "https://main2.ton.dev", - "http://main3.ton.dev", - "https://lim01.main.everos.dev", - "gra02.main.everos.dev", - "eri01.main.everos.dev", - "gra01.main.everos.dev", - "rbx01.main.everos.dev", - ] - ); -} - #[test] fn test_subscription_gql() { let query = GraphQLQuery::with_collection_subscription("counterparties", &Value::Null, "id"); diff --git a/ton_client/src/proofs/tests/mod.rs b/ton_client/src/proofs/tests/mod.rs index 388375f41..805667eef 100644 --- a/ton_client/src/proofs/tests/mod.rs +++ b/ton_client/src/proofs/tests/mod.rs @@ -4,31 +4,47 @@ use std::sync::Arc; use failure::bail; use graphql_parser::schema::{Definition, ObjectType, Type, TypeDefinition}; use serde_json::Value; -use ton_block::{BinTreeType, Block, BlockIdExt, Deserializable, InRefValue, MASTERCHAIN_ID, ShardHashes, ShardIdent, ShardStateUnsplit}; +use ton_block::{ + BinTreeType, Block, BlockIdExt, Deserializable, InRefValue, ShardHashes, ShardIdent, + ShardStateUnsplit, MASTERCHAIN_ID, +}; use ton_types::{Result, UInt256}; use crate::client::storage::InMemoryKeyValueStorage; -use crate::ClientContext; -use crate::net::{ParamsOfQueryCollection, query_collection}; -use crate::proofs::{BlockProof, get_current_network_uid, INITIAL_TRUSTED_KEY_BLOCKS, is_transaction_refers_to_message, message_get_required_data, ParamsOfProofBlockData, ParamsOfProofMessageData, ParamsOfProofTransactionData, proof_message_data, proof_transaction_data, query_current_network_uid, resolve_initial_trusted_key_block, transaction_get_required_data}; +use crate::net::{query_collection, ParamsOfQueryCollection}; use crate::proofs::engine::ProofHelperEngineImpl; -use crate::proofs::validators::{calc_subset_for_workchain, calc_workchain_id, calc_workchain_id_by_adnl_id}; +use crate::proofs::validators::{ + calc_subset_for_workchain, calc_workchain_id, calc_workchain_id_by_adnl_id, +}; +use crate::proofs::{ + get_current_network_uid, is_transaction_refers_to_message, message_get_required_data, + proof_message_data, proof_transaction_data, query_current_network_uid, + resolve_initial_trusted_key_block, transaction_get_required_data, BlockProof, + ParamsOfProofBlockData, ParamsOfProofMessageData, ParamsOfProofTransactionData, + INITIAL_TRUSTED_KEY_BLOCKS, +}; use crate::tests::TestClient; +use crate::ClientContext; const GQL_SCHEMA: &str = include_str!("data/schema.graphql"); #[test] fn test_check_master_blocks_proof() -> Result<()> { let key_block_proof = BlockProof::read_from_file( - "src/proofs/tests/data/test_master_block_proof/key_proof__3082181" + "src/proofs/tests/data/test_master_block_proof/key_proof__3082181", )?; for seq_no in 3082182..=3082200 { - let block_proof = BlockProof::read_from_file( - format!("src/proofs/tests/data/test_master_block_proof/proof__{}", seq_no) - )?; + let block_proof = BlockProof::read_from_file(format!( + "src/proofs/tests/data/test_master_block_proof/proof__{}", + seq_no + ))?; let (virt_block, virt_block_info) = block_proof.pre_check_block_proof()?; - block_proof.check_with_prev_key_block_proof(&key_block_proof, &virt_block, &virt_block_info)?; + block_proof.check_with_prev_key_block_proof( + &key_block_proof, + &virt_block, + &virt_block_info, + )?; } Ok(()) @@ -37,16 +53,21 @@ fn test_check_master_blocks_proof() -> Result<()> { #[test] fn test_check_master_blocks_proof_shuffle() -> Result<()> { let key_block_proof = BlockProof::read_from_file( - "src/proofs/tests/data/test_master_block_proof_shuffle/key_proof__3236530" + "src/proofs/tests/data/test_master_block_proof_shuffle/key_proof__3236530", )?; for seq_no in 3236531..=3236550 { - let block_proof = BlockProof::read_from_file( - format!("src/proofs/tests/data/test_master_block_proof_shuffle/proof__{}", seq_no) - )?; + let block_proof = BlockProof::read_from_file(format!( + "src/proofs/tests/data/test_master_block_proof_shuffle/proof__{}", + seq_no + ))?; let (virt_block, virt_block_info) = block_proof.pre_check_block_proof()?; - block_proof.check_with_prev_key_block_proof(&key_block_proof, &virt_block, &virt_block_info)?; + block_proof.check_with_prev_key_block_proof( + &key_block_proof, + &virt_block, + &virt_block_info, + )?; } Ok(()) @@ -65,7 +86,10 @@ fn test_validator_set() -> Result<()> { let block = Block::construct_from_file("src/proofs/tests/data/key_block.boc")?; let custom = block.read_extra()?.read_custom()?.unwrap(); let config = custom.config().unwrap(); - assert!(config.prev_validator_set_present()?, "key block must be after elections"); + assert!( + config.prev_validator_set_present()?, + "key block must be after elections" + ); let vset = config.validator_set()?; assert_eq!(vset.list().len(), 21); @@ -83,9 +107,17 @@ fn test_validator_set() -> Result<()> { for workchain_id in -1..=1 { // println!("workchain_id: {}", workchain_id); let cc_config = config.catchain_config()?; - let subset = calc_subset_for_workchain(&vset, config, &cc_config, ton_block::SHARD_FULL, workchain_id, cc_seqno, 0.into())?; + let subset = calc_subset_for_workchain( + &vset, + config, + &cc_config, + ton_block::SHARD_FULL, + workchain_id, + cc_seqno, + 0.into(), + )?; assert_eq!(subset.0.len(), 7); - subset.0.iter().enumerate().for_each(|(_i,descr)| { + subset.0.iter().enumerate().for_each(|(_i, descr)| { let real_id = calc_workchain_id(descr); // println!("{}: pub_key: {} real_id: {}", i, hex::encode(descr.public_key.as_slice()), real_id); assert_eq!(real_id, workchain_id); @@ -106,7 +138,12 @@ fn get_top_blocks(shards: &ShardHashes, workchains: &[i32]) -> Result Result<()> { let count = config.workchains()?.len()? as i32; for workchain_id in -1..count { let shard_ids = match workchain_id { - MASTERCHAIN_ID => vec!(BlockIdExt::with_params(ShardIdent::masterchain(), 0, Default::default(), Default::default())), - workchain_id => get_top_blocks(custom.shards(), &[workchain_id])? + MASTERCHAIN_ID => vec![BlockIdExt::with_params( + ShardIdent::masterchain(), + 0, + Default::default(), + Default::default(), + )], + workchain_id => get_top_blocks(custom.shards(), &[workchain_id])?, }; for block_id in shard_ids { // println!("{}", block_id.shard()); @@ -148,7 +190,7 @@ fn check_any_keyblock_validator_set(file_name: &str) -> Result<()> { block_id.shard().shard_prefix_with_tag(), workchain_id, cc_seqno, - Default::default() + Default::default(), )?; assert_eq!(subset.0.len(), 7); subset.0.iter().enumerate().for_each(|(_i, descr)| { @@ -165,20 +207,23 @@ fn check_any_keyblock_validator_set(file_name: &str) -> Result<()> { const MAINNET_ZEROSTATE_ROOT_HASH: &str = "58ffca1a178daff705de54216e5433c9bd2e7d850070d334d38997847ab9e845"; -lazy_static! { - static ref MAINNET_CONFIG: Value = json!({ +fn mainnet_config() -> Value { + json!({ "network": { - "server_address": "main.ton.dev", + "endpoints": [TestClient::with_project("mainnet.evercloud.dev")], } - }); + }) } #[tokio::test] async fn test_query_current_network_zerostate_root_hash() -> Result<()> { - let client = TestClient::new_with_config(MAINNET_CONFIG.clone()); + let client = TestClient::new_with_config(mainnet_config()); assert_eq!( - query_current_network_uid(client.context()).await?.zerostate_root_hash.as_hex_string(), + query_current_network_uid(client.context()) + .await? + .zerostate_root_hash + .as_hex_string(), MAINNET_ZEROSTATE_ROOT_HASH, ); @@ -187,24 +232,38 @@ async fn test_query_current_network_zerostate_root_hash() -> Result<()> { #[tokio::test] async fn test_get_current_network_zerostate_root_hash() -> Result<()> { - let client = TestClient::new_with_config(MAINNET_CONFIG.clone()); + let client = TestClient::new_with_config(mainnet_config()); let context = client.context(); assert!(context.net.network_uid.read().await.is_none()); assert_eq!( - get_current_network_uid(&context).await?.zerostate_root_hash.as_hex_string(), + get_current_network_uid(&context) + .await? + .zerostate_root_hash + .as_hex_string(), MAINNET_ZEROSTATE_ROOT_HASH, ); assert_eq!( - context.net.network_uid.read().await.as_ref().unwrap().zerostate_root_hash.as_hex_string(), + context + .net + .network_uid + .read() + .await + .as_ref() + .unwrap() + .zerostate_root_hash + .as_hex_string(), MAINNET_ZEROSTATE_ROOT_HASH, ); // Second time in order to ensure that value wasn't broken after caching: assert_eq!( - get_current_network_uid(&context).await?.zerostate_root_hash.as_hex_string(), + get_current_network_uid(&context) + .await? + .zerostate_root_hash + .as_hex_string(), MAINNET_ZEROSTATE_ROOT_HASH, ); @@ -213,21 +272,23 @@ async fn test_get_current_network_zerostate_root_hash() -> Result<()> { #[tokio::test] async fn test_resolve_initial_trusted_key_block_main() -> Result<()> { - let client = TestClient::new_with_config(MAINNET_CONFIG.clone()); + let client = TestClient::new_with_config(mainnet_config()); let context = client.context(); let (seq_no, root_hash) = resolve_initial_trusted_key_block(&context, 100).await?; assert_eq!( (seq_no, *root_hash.as_array()), - INITIAL_TRUSTED_KEY_BLOCKS.get(UInt256::from_str(MAINNET_ZEROSTATE_ROOT_HASH)?.as_array()).unwrap()[0], + INITIAL_TRUSTED_KEY_BLOCKS + .get(UInt256::from_str(MAINNET_ZEROSTATE_ROOT_HASH)?.as_array()) + .unwrap()[0], ); Ok(()) } fn create_engine_mainnet() -> ProofHelperEngineImpl { - let client = TestClient::new_with_config(MAINNET_CONFIG.clone()); + let client = TestClient::new_with_config(mainnet_config()); let storage = Arc::new(InMemoryKeyValueStorage::new()); ProofHelperEngineImpl::with_values(client.context(), storage) } @@ -242,16 +303,34 @@ async fn test_metadata_storage() -> Result<()> { assert!(engine.read_metadata_value_u32(KEY).await?.is_none()); engine.write_metadata_value_u32(KEY, TEST1_VALUE).await?; - assert_eq!(engine.read_metadata_value_u32(KEY).await?, Some(TEST1_VALUE)); + assert_eq!( + engine.read_metadata_value_u32(KEY).await?, + Some(TEST1_VALUE) + ); - engine.update_metadata_value_u32(KEY, TEST2_VALUE, std::cmp::min).await?; - assert_eq!(engine.read_metadata_value_u32(KEY).await?, Some(TEST1_VALUE)); + engine + .update_metadata_value_u32(KEY, TEST2_VALUE, std::cmp::min) + .await?; + assert_eq!( + engine.read_metadata_value_u32(KEY).await?, + Some(TEST1_VALUE) + ); - engine.update_metadata_value_u32(KEY, TEST2_VALUE, std::cmp::max).await?; - assert_eq!(engine.read_metadata_value_u32(KEY).await?, Some(TEST2_VALUE)); + engine + .update_metadata_value_u32(KEY, TEST2_VALUE, std::cmp::max) + .await?; + assert_eq!( + engine.read_metadata_value_u32(KEY).await?, + Some(TEST2_VALUE) + ); - engine.update_metadata_value_u32(KEY, TEST1_VALUE, std::cmp::min).await?; - assert_eq!(engine.read_metadata_value_u32(KEY).await?, Some(TEST1_VALUE)); + engine + .update_metadata_value_u32(KEY, TEST1_VALUE, std::cmp::min) + .await?; + assert_eq!( + engine.read_metadata_value_u32(KEY).await?, + Some(TEST1_VALUE) + ); Ok(()) } @@ -274,7 +353,6 @@ async fn test_special_metadata_storage() -> Result<()> { engine.update_zs_right_bound(10).await?; assert_eq!(engine.read_zs_right_bound().await?, 300); - assert_eq!(engine.read_trusted_block_right_bound(10).await?, 10); engine.update_trusted_block_right_bound(10, 25).await?; @@ -306,12 +384,13 @@ async fn test_query_zerostate_boc() -> Result<()> { async fn test_query_file_hash() -> Result<()> { let engine = create_engine_mainnet(); - let file_hash_from_next = UInt256::from_str( - &engine.query_file_hash_from_next_block(1).await?.unwrap(), - )?; - let file_hash_from_boc = engine.download_block_boc_and_calc_file_hash( - "4bba527c0f5301ac01194020edb6c237158bae872348ba36b0137d523fadd864", - ).await?; + let file_hash_from_next = + UInt256::from_str(&engine.query_file_hash_from_next_block(1).await?.unwrap())?; + let file_hash_from_boc = engine + .download_block_boc_and_calc_file_hash( + "4bba527c0f5301ac01194020edb6c237158bae872348ba36b0137d523fadd864", + ) + .await?; assert_eq!(file_hash_from_boc, file_hash_from_next); assert_eq!( @@ -359,7 +438,10 @@ async fn test_add_file_hashes() -> Result<()> { engine.add_mc_blocks_file_hashes(&mut proofs).await?; for (seq_no, proof) in &proofs { - let file_hash = engine.query_file_hash_from_next_block(*seq_no).await?.unwrap(); + let file_hash = engine + .query_file_hash_from_next_block(*seq_no) + .await? + .unwrap(); assert_eq!(proof["file_hash"].as_str().unwrap(), file_hash); } @@ -379,9 +461,8 @@ async fn test_mc_proofs() -> Result<()> { assert_eq!(storage.count(), 1); assert_eq!(engine.read_zs_right_bound().await?, 0); - let (trusted_seq_no, _trusted_root_hash) = resolve_initial_trusted_key_block( - engine.context(), 10000000, - ).await?; + let (trusted_seq_no, _trusted_root_hash) = + resolve_initial_trusted_key_block(engine.context(), 10000000).await?; let proof = BlockProof::from_value(&engine.query_mc_block_proof(trusted_seq_no + 1000).await?)?; proof.check_proof(&engine).await?; @@ -390,7 +471,12 @@ async fn test_mc_proofs() -> Result<()> { assert_eq!(storage.count(), 2); assert_eq!(engine.read_zs_right_bound().await?, 0); - assert_eq!(engine.read_trusted_block_right_bound(trusted_seq_no).await?, trusted_seq_no); + assert_eq!( + engine + .read_trusted_block_right_bound(trusted_seq_no) + .await?, + trusted_seq_no + ); Ok(()) } @@ -398,27 +484,32 @@ async fn test_mc_proofs() -> Result<()> { #[tokio::test] async fn test_extract_top_shard_block() -> Result<()> { let engine = create_engine_mainnet(); - let boc = engine.download_block_boc( - "01872c85facaa85405518a759dfac2625bc94b9e85b965cf3875d2331db9ad95", - ).await?; + let boc = engine + .download_block_boc("01872c85facaa85405518a759dfac2625bc94b9e85b965cf3875d2331db9ad95") + .await?; let block = Block::construct_from_bytes(&boc)?; assert!(ProofHelperEngineImpl::extract_top_shard_block( &block, &ShardIdent::with_tagged_prefix(0, 0x8000000000000000)?, - ).is_err()); + ) + .is_err()); assert!(ProofHelperEngineImpl::extract_top_shard_block( &block, &ShardIdent::with_tagged_prefix(1, 0x2000000000000000)?, - ).is_err()); + ) + .is_err()); assert_eq!( ProofHelperEngineImpl::extract_top_shard_block( &block, &ShardIdent::with_tagged_prefix(0, 0x2000000000000000)?, )?, - (96, UInt256::from_str("e3db85d93d5d85670c261899cf56f7ef2876e0ea95cdcfc6b7e3837998242950")?), + ( + 96, + UInt256::from_str("e3db85d93d5d85670c261899cf56f7ef2876e0ea95cdcfc6b7e3837998242950")? + ), ); assert_eq!( @@ -426,7 +517,10 @@ async fn test_extract_top_shard_block() -> Result<()> { &block, &ShardIdent::with_tagged_prefix(0, 0xa000000000000000)?, )?, - (113, UInt256::from_str("845052457398c7a2f3f5ff74ebfd2b0f6567f9ceec510593be11c900ecb26cd1")?), + ( + 113, + UInt256::from_str("845052457398c7a2f3f5ff74ebfd2b0f6567f9ceec510593be11c900ecb26cd1")? + ), ); Ok(()) @@ -440,19 +534,25 @@ async fn test_query_closest_mc_block_for_shard_block() -> Result<()> { let mut first_mc_seq_no = 100; assert_eq!( - engine.query_closest_mc_block_for_shard_block(&mut first_mc_seq_no, &shard, 113).await?, + engine + .query_closest_mc_block_for_shard_block(&mut first_mc_seq_no, &shard, 113) + .await?, Some(100), ); first_mc_seq_no = 99; assert_eq!( - engine.query_closest_mc_block_for_shard_block(&mut first_mc_seq_no, &shard, 113).await?, + engine + .query_closest_mc_block_for_shard_block(&mut first_mc_seq_no, &shard, 113) + .await?, Some(99), ); first_mc_seq_no = 95; assert_eq!( - engine.query_closest_mc_block_for_shard_block(&mut first_mc_seq_no, &shard, 109).await?, + engine + .query_closest_mc_block_for_shard_block(&mut first_mc_seq_no, &shard, 109) + .await?, Some(96), ); @@ -496,8 +596,14 @@ async fn test_query_shard_block_bocs() -> Result<()> { let bocs = engine.query_shard_block_bocs(&shard, 99..102).await?; assert_eq!(bocs.len(), 3); - assert_eq!(bocs[0], base64::decode(SHARD_BLOCK_0_A000000000000000_99_BOC)?); - assert_eq!(bocs[2], base64::decode(SHARD_BLOCK_0_A000000000000000_101_BOC)?); + assert_eq!( + bocs[0], + base64::decode(SHARD_BLOCK_0_A000000000000000_99_BOC)? + ); + assert_eq!( + bocs[2], + base64::decode(SHARD_BLOCK_0_A000000000000000_101_BOC)? + ); Ok(()) } @@ -519,31 +625,37 @@ async fn test_check_shard_block() -> Result<()> { async fn test_check_mc_proof() -> Result<()> { let engine = create_engine_mainnet(); - engine.check_mc_block_proof( - 100, - &UInt256::from_str("01872c85facaa85405518a759dfac2625bc94b9e85b965cf3875d2331db9ad95")?, - ).await?; + engine + .check_mc_block_proof( + 100, + &UInt256::from_str("01872c85facaa85405518a759dfac2625bc94b9e85b965cf3875d2331db9ad95")?, + ) + .await?; // From cache: - engine.check_mc_block_proof( - 100, - &UInt256::from_str("01872c85facaa85405518a759dfac2625bc94b9e85b965cf3875d2331db9ad95")?, - ).await?; + engine + .check_mc_block_proof( + 100, + &UInt256::from_str("01872c85facaa85405518a759dfac2625bc94b9e85b965cf3875d2331db9ad95")?, + ) + .await?; - assert!( - engine.check_mc_block_proof( + assert!(engine + .check_mc_block_proof( 101, &UInt256::from_str("01872c85facaa85405518a759dfac2625bc94b9e85b965cf3875d2331db9ad95")?, - ).await.is_err(), - ); + ) + .await + .is_err(),); // From cache: - assert!( - engine.check_mc_block_proof( + assert!(engine + .check_mc_block_proof( 100, &UInt256::from_str("1111111111111111111111111111111111111111111111111111111111111111")?, - ).await.is_err(), - ); + ) + .await + .is_err(),); Ok(()) } @@ -552,7 +664,7 @@ async fn query_data( context: Arc, collection: &str, id: &str, - result: &str + result: &str, ) -> Result { Ok(query_collection( context, @@ -566,15 +678,22 @@ async fn query_data( })), limit: Some(1), ..Default::default() - } - ).await?.result.remove(0)) + }, + ) + .await? + .result + .remove(0)) } async fn query_block_data(context: Arc, id: &str, result: &str) -> Result { query_data(context, "blocks", id, result).await } -async fn query_transaction_data(context: Arc, id: &str, result: &str) -> Result { +async fn query_transaction_data( + context: Arc, + id: &str, + result: &str, +) -> Result { query_data(context, "transactions", id, result).await } @@ -598,7 +717,12 @@ fn print_object_type( ) { for i in 0..object_type.fields.len() { let field = &object_type.fields[i]; - if field.arguments.iter().find(|arg| arg.name == "when").is_some() { + if field + .arguments + .iter() + .find(|arg| arg.name == "when") + .is_some() + { continue; } let type_name = resolve_type_name(&field.field_type); @@ -612,7 +736,12 @@ fn print_object_type( output.push_str(&field.name); if let Some(typ) = known_types.get(&type_name) { output.push('{'); - print_object_type(typ, known_types, format!("{}{}/", path, field_ident), output); + print_object_type( + typ, + known_types, + format!("{}{}/", path, field_ident), + output, + ); output.push('}'); } } @@ -632,7 +761,12 @@ fn gen_full_schema_query(object_type: &str) -> Result { if let Definition::TypeDefinition(TypeDefinition::Object(obj_type)) = definition { if obj_type.name == object_type { let mut output = String::new(); - print_object_type(obj_type, &known_types, format!("/{}", obj_type.name), &mut output); + print_object_type( + obj_type, + &known_types, + format!("/{}", obj_type.name), + &mut output, + ); return Ok(output); } } @@ -643,46 +777,58 @@ fn gen_full_schema_query(object_type: &str) -> Result { #[tokio::test] async fn test_proof_block_data() -> Result<()> { - let client = TestClient::new_with_config(MAINNET_CONFIG.clone()); + let client = TestClient::new_with_config(mainnet_config()); let mut block_json = query_block_data( client.context(), "8bde590a572437332977e68bace66fa00f9cebac6baa57f6bf2d2f1276db2848", &gen_full_schema_query("Block")?, - ).await?; + ) + .await?; - client.request_async( - "proofs.proof_block_data", - ParamsOfProofBlockData { block: block_json.clone() }, - ).await?; + client + .request_async( + "proofs.proof_block_data", + ParamsOfProofBlockData { + block: block_json.clone(), + }, + ) + .await?; block_json["boc"] = Value::Null; - client.request_async( - "proofs.proof_block_data", - ParamsOfProofBlockData { block: block_json.clone() }, - ).await?; + client + .request_async( + "proofs.proof_block_data", + ParamsOfProofBlockData { + block: block_json.clone(), + }, + ) + .await?; block_json["boc"] = SHARD_BLOCK_0_A000000000000000_99_BOC.into(); - assert!( - client.request_async::<_, ()>( + assert!(client + .request_async::<_, ()>( "proofs.proof_block_data", - ParamsOfProofBlockData { block: block_json.clone() }, - ).await - .is_err() - ); + ParamsOfProofBlockData { + block: block_json.clone() + }, + ) + .await + .is_err()); block_json["boc"] = Value::Null; - block_json["prev_ref"]["root_hash"] = "0000000000000000000000000000000000000000000000000000000000000000".into(); + block_json["prev_ref"]["root_hash"] = + "0000000000000000000000000000000000000000000000000000000000000000".into(); - assert!( - client.request_async::<_, ()>( + assert!(client + .request_async::<_, ()>( "proofs.proof_block_data", ParamsOfProofBlockData { block: block_json }, - ).await - .is_err() - ); + ) + .await + .is_err()); let proof_json = query_block_data( client.context(), @@ -706,16 +852,17 @@ async fn test_proof_block_data() -> Result<()> { s } } - "# - ).await?; + "#, + ) + .await?; - assert!( - client.request_async::<_, ()>( + assert!(client + .request_async::<_, ()>( "proofs.proof_block_data", ParamsOfProofBlockData { block: proof_json }, - ).await - .is_err() - ); + ) + .await + .is_err()); let decimal_fields = r#" id @@ -845,24 +992,34 @@ async fn test_proof_block_data() -> Result<()> { client.context(), "9eee20c3a93ca93928d7dc4bbbe6570c492d09077f13ebf7b2f68f9e2e176433", decimal_fields, - ).await?; + ) + .await?; - client.request_async( - "proofs.proof_block_data", - ParamsOfProofBlockData { block: block_json.clone() }, - ).await?; + client + .request_async( + "proofs.proof_block_data", + ParamsOfProofBlockData { + block: block_json.clone(), + }, + ) + .await?; // Shardchain block let block_json = query_block_data( client.context(), "b38d6bdb4fab0e52a9165fe65aa373520ae8c7e422f93f20c9a2a5c8016d5e7d", decimal_fields, - ).await?; + ) + .await?; - client.request_async( - "proofs.proof_block_data", - ParamsOfProofBlockData { block: block_json.clone() }, - ).await?; + client + .request_async( + "proofs.proof_block_data", + ParamsOfProofBlockData { + block: block_json.clone(), + }, + ) + .await?; Ok(()) } @@ -878,16 +1035,14 @@ async fn test_transaction_get_required_data() -> Result<()> { ZW9pdoaxTsmbuXQ36fewBok3KaF+nc49AloFgjqbOapl+vKCOKiovtM8HJflgF0zlY3Eah3ZxAABIA=="; async fn test(engine: &ProofHelperEngineImpl, transaction_json: Value) -> Result<()> { - let (id, block_id, boc, transaction) = transaction_get_required_data( - &engine, - &transaction_json, - ).await?; + let (id, block_id, boc, transaction) = + transaction_get_required_data(&engine, &transaction_json).await?; + assert_eq!(id.as_hex_string(), ID,); assert_eq!( - id.as_hex_string(), - ID, + block_id, + "eb7c28f1d301dff2d6ec899fb5ee18d9478f397b10c16a6f6aabb6535686266e" ); - assert_eq!(block_id, "eb7c28f1d301dff2d6ec899fb5ee18d9478f397b10c16a6f6aabb6535686266e"); assert_eq!(boc, base64::decode(BOC)?); assert_eq!(transaction.logical_time(), 0x11d2d21e3781); @@ -901,32 +1056,38 @@ async fn test_transaction_get_required_data() -> Result<()> { json!({ "id": ID, }), - ).await?; + ) + .await?; test( &engine, json!({ "boc": BOC, }), - ).await?; + ) + .await?; Ok(()) } #[tokio::test] async fn test_proof_transaction_data() -> Result<()> { - let client = TestClient::new_with_config(MAINNET_CONFIG.clone()); + let client = TestClient::new_with_config(mainnet_config()); let transaction_json = query_transaction_data( client.context(), "0c7e395e8eb14c173d2dde7189200f28787a05df1fa188b19224f6e19a439dc6", &gen_full_schema_query("Transaction")?, - ).await?; + ) + .await?; proof_transaction_data( client.context(), - ParamsOfProofTransactionData { transaction: transaction_json }, - ).await?; + ParamsOfProofTransactionData { + transaction: transaction_json, + }, + ) + .await?; let transaction_json = query_transaction_data( client.context(), @@ -951,8 +1112,11 @@ async fn test_proof_transaction_data() -> Result<()> { proof_transaction_data( client.context(), - ParamsOfProofTransactionData { transaction: transaction_json }, - ).await?; + ParamsOfProofTransactionData { + transaction: transaction_json, + }, + ) + .await?; Ok(()) } @@ -967,22 +1131,15 @@ async fn test_message_get_required_data() -> Result<()> { message_trans_id: &str, dst_account_address: Option<&str>, ) -> Result<()> { - let (id, trans_id, boc, message) = message_get_required_data( - &engine, - &message_json, - ).await?; + let (id, trans_id, boc, message) = + message_get_required_data(&engine, &message_json).await?; - assert_eq!( - id.as_hex_string(), - message_id, - ); + assert_eq!(id.as_hex_string(), message_id,); assert_eq!(trans_id, message_trans_id); assert_eq!(boc, base64::decode(message_boc)?); assert_eq!( - message.dst_ref() - .map(|addr| addr.to_string()), - dst_account_address - .map(|str| str.to_string()), + message.dst_ref().map(|addr| addr.to_string()), + dst_account_address.map(|str| str.to_string()), ); Ok(()) @@ -1004,7 +1161,8 @@ async fn test_message_get_required_data() -> Result<()> { message_boc, trans_id, dst_account_address, - ).await?; + ) + .await?; test( &engine, @@ -1015,7 +1173,8 @@ async fn test_message_get_required_data() -> Result<()> { message_boc, trans_id, dst_account_address, - ).await + ) + .await } let engine = create_engine_mainnet(); @@ -1028,7 +1187,8 @@ async fn test_message_get_required_data() -> Result<()> { MzMzMzMzMzMzMzMzMzMzSH9xlJAAAACOlpFrzgMLHidRA", "2658e6c5371f73468b6d4afaaf2f681f8f39e256dc2f5b66362a9a8a002177a9", Some("-1:3333333333333333333333333333333333333333333333333333333333333333"), - ).await?; + ) + .await?; tests( &engine, @@ -1038,14 +1198,17 @@ async fn test_message_get_required_data() -> Result<()> { AAAAAAABA", "0c7e395e8eb14c173d2dde7189200f28787a05df1fa188b19224f6e19a439dc6", None, - ).await?; + ) + .await?; Ok(()) } #[test] fn test_is_transaction_refers_to_message() { - let id = Value::String("5b532e2ec17ac84b4efa92703192368dd4ed8a2729f2be2b0ee4e0665368f7c0".to_owned()); + let id = Value::String( + "5b532e2ec17ac84b4efa92703192368dd4ed8a2729f2be2b0ee4e0665368f7c0".to_owned(), + ); let json = json!({}); assert!(!is_transaction_refers_to_message(&json, &id)); @@ -1073,18 +1236,22 @@ fn test_is_transaction_refers_to_message() { #[tokio::test] async fn test_proof_message_data() -> Result<()> { - let client = TestClient::new_with_config(MAINNET_CONFIG.clone()); + let client = TestClient::new_with_config(mainnet_config()); let message_json = query_message_data( client.context(), "4a9389e2fa34a83db0c814674bc4c7569fd3e92042289e2b2d4802231ecabec9", &gen_full_schema_query("Message")?, - ).await?; + ) + .await?; proof_message_data( client.context(), - ParamsOfProofMessageData { message: message_json }, - ).await?; + ParamsOfProofMessageData { + message: message_json, + }, + ) + .await?; let message_json = query_message_data( client.context(), @@ -1099,12 +1266,16 @@ async fn test_proof_message_data() -> Result<()> { value(format:DEC) value_other{value(format:DEC)} "#, - ).await?; + ) + .await?; proof_message_data( client.context(), - ParamsOfProofMessageData { message: message_json }, - ).await?; + ParamsOfProofMessageData { + message: message_json, + }, + ) + .await?; Ok(()) } diff --git a/ton_client/src/tests/common.rs b/ton_client/src/tests/common.rs index 38bcedda9..d05c7e9bd 100644 --- a/ton_client/src/tests/common.rs +++ b/ton_client/src/tests/common.rs @@ -64,7 +64,7 @@ fn test_parallel_requests() { fn test_deferred_init() { let client = TestClient::new_with_config(json!({ "network": { - "server_address": "123" + "endpoints": ["123"] } })); diff --git a/ton_client/src/tests/mod.rs b/ton_client/src/tests/mod.rs index 51274f863..261ab1247 100644 --- a/ton_client/src/tests/mod.rs +++ b/ton_client/src/tests/mod.rs @@ -71,10 +71,6 @@ mod env { str("EVERCLOUD_AUTH_PROJECT", None) } - pub(crate) fn auth_secret() -> Option { - str("EVERCLOUD_AUTH_SECRET", None) - } - pub(crate) fn endpoints() -> String { str("EVERCLOUD_ENDPOINTS", Some("TON_NETWORK_ADDRESS")) .unwrap_or_else(|| "http://localhost".into()) @@ -329,17 +325,13 @@ impl TestClient { env::auth_project() } - pub fn auth_secret() -> Option { - env::auth_secret() - } - pub fn with_project(endpoint: &str) -> String { match Self::auth_project() { Some(project) => { if endpoint.ends_with('/') { - format!("{}/{}", endpoint, project) - } else { format!("{}{}", endpoint, project) + } else { + format!("{}/{}", endpoint, project) } } None => endpoint.to_string(), @@ -351,7 +343,7 @@ impl TestClient { .split(",") .map(|x| x.trim()) .filter(|x| !x.is_empty()) - .map(|x| Self::with_project(x)) + .map(|x| x.to_string()) .collect() } diff --git a/toncli/src/request.rs b/toncli/src/request.rs index 03751c6f6..0e5195722 100644 --- a/toncli/src/request.rs +++ b/toncli/src/request.rs @@ -194,7 +194,7 @@ pub fn command(args: &[String]) -> Result<(), CliError> { let config = serde_json::json!({ "network": { - "server_address": network + "endpoints": [network] } }); let context = unsafe { diff --git a/tools/update_trusted_blocks/src/main.rs b/tools/update_trusted_blocks/src/main.rs index 204d69de5..d868e1501 100644 --- a/tools/update_trusted_blocks/src/main.rs +++ b/tools/update_trusted_blocks/src/main.rs @@ -8,16 +8,16 @@ use ton_client::proofs::{ParamsOfProofBlockData, proof_block_data}; use ton_types::{Result, UInt256}; async fn query_network_keyblocks( - server_address: &'static str, + endpoint: &'static str, zs_root_hash: UInt256, trusted_blocks: Option>, ) -> Result> { - println!("*** [{}] ***", server_address); + println!("*** [{}] ***", endpoint); let context = Arc::new( ClientContext::new( serde_json::from_value(json!({ "network": { - "server_address": server_address, + "endpoints": [endpoint], } }))? )? @@ -60,7 +60,7 @@ async fn query_network_keyblocks( ).await?.result; if key_blocks.is_empty() { - println!("*** [{} done] ***", server_address); + println!("*** [{} done] ***", endpoint); return Ok(result); } @@ -111,7 +111,7 @@ async fn main() -> Result<()> { Err(_) => { println!("Creating new trusted blocks list in {}", &args[1]); HashMap::new() - } + } };