Merge pull request #144 from tonlabs/0.25.0-rc

0.25.0 rc

Author: melsomino

.gitignore

@@ -18,3 +18,6 @@ Cargo.lock
 .idea
 .vscode
 .DS_Store
+/ton_client/platforms/ton-client-react-native/build/
+/ton_client/platforms/ton-client-web/build/tonclient.wasm
+/ton_client/platforms/ton-client-web/build/index.js

CHANGELOG.md

@@ -1,13 +1,19 @@
 # Release Notes
 All notable changes to this project will be documented in this file.
 
-## Jun 05, 2020
-### New
-- time sync check while initializing
-
-## Jun 03, 2020
+## 0.25.0 Jul 8, 2020
 ### New
+- supports for core context in all platforms
 - local run functions return updated contract state when running with `full_run = true`
+- time sync check while initializing
+- parallel requests on different contexts don't block each other. Requests on the same context
+remain sequential
+- new transaction wait mechanism. All account's shard blocks are checked for transaction to 
+guarantee message expiration
+- `contracts.wait.transaction` function for awaiting previously sent message processing
+- `contracts.send.message` returns message processing state for `contracts.wait.transaction` function
+- `contracts.find.shard` function for account shard matching
+- added logging on warning messages
 
 ## May 28, 2020
 ### New

graphite/Cargo.toml

@@ -12,3 +12,4 @@ websocket = "0.22.4"
 serde_json = "1.0.41"
 futures = "0.3.4"
 reqwest = "0.10.4"
+failure = "0.1"

graphite/src/client.rs

@@ -28,7 +28,8 @@ impl GqlClient {
     pub fn new(queries_server: &str, subscriptions_server: &str) -> Result<Self, GraphiteError> {
         let client = ClientBuilder::new()  
             .build()
-            .map_err(|err| GraphiteError::new(err.to_string()))?;
+            .map_err(|err| GraphiteError::NetworkError(
+                format!("Can not create client: {}", err.to_string())))?;
 
         Ok(Self {
             client_htpp: client,
@@ -41,17 +42,18 @@ impl GqlClient {
     async fn process_response(response: Response) -> Result<serde_json::Value, GraphiteError> {
         match response.text().await {
             Ok(res_str) => {
-                if let Ok(value) = serde_json::from_str(res_str.as_str()) {
+                match serde_json::from_str(res_str.as_str()) {
+                Ok(value) => {
                     if let Some(error) = crate::types::try_extract_error(&value) {
                         return Err(error);
                     }
                     Ok(value)
-                } else {
-                    Err(GraphiteError::new(format!(
-                        "Invalid JSON: {}", res_str)))
+                },
+                Err(error) => Err(GraphiteError::SerdeError(error, res_str))
                 }
             },
-            Err(err) => Err(GraphiteError::new(err.to_string().clone()))
+            Err(err) => Err(GraphiteError::NetworkError(
+                format!("Can not get response text: {}", err.to_string())))
         }
     }
 
@@ -61,7 +63,7 @@ impl GqlClient {
             .send()
             .await
             .map_err(|err| 
-                GraphiteError::new(format!("Can't send request: {}", err)))?;
+                GraphiteError::NetworkError(format!("Can't send request: {}", err)))?;
 
         Self::process_response(response).await
     }
@@ -81,7 +83,7 @@ impl GqlClient {
             .send()
             .await
             .map_err(|err| 
-                GraphiteError::new(format!("Can't send request: {}", err)))?;
+                GraphiteError::NetworkError(format!("Can't send request: {}", err)))?;
 
         Self::process_response(response).await
     }
@@ -90,7 +92,7 @@ impl GqlClient {
         Ok(SubscribeStream::new(
             std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
-                .map_err(|err| GraphiteError::new(format!("Cannot get time: {}", err)))?
+                .map_err(|err| GraphiteError::Other(format!("Cannot get time: {}", err)))?
                 .subsec_nanos(),
             request,
             &self.graphql_socket_host)?)

graphite/src/types.rs

@@ -16,31 +16,27 @@ extern crate websocket;
 
 use futures::task::{Poll, Context};
 use futures::stream::Stream;
-use std::fmt;
 use serde_json::Value;
 use websocket::{ClientBuilder, OwnedMessage};
 use websocket::client::sync::Client;
 use websocket::stream::sync::NetworkStream;
 
 
-#[derive(Debug, Clone)]
-pub struct GraphiteError {
-    message: String,
-}
+#[derive(Debug, failure::Fail)]
+pub enum GraphiteError {
 
-impl GraphiteError {
-    pub fn new(message: String) -> Self {
-        Self { message: message }
-    }
-}
+    #[fail(display = "Network error: {}", 0)]
+    NetworkError(String),
 
-impl fmt::Display for GraphiteError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "({})", self.message)
-    }
-}
+    #[fail(display = "Grpahql server returned error: {}", 0)]
+    GraprhqlError(String),
 
-impl std::error::Error for GraphiteError {}
+    #[fail(display = "Server response parse error: {}\nresponse: {}", 0, 1)]
+    SerdeError(serde_json::Error, String),
+
+    #[fail(display = "{}", 0)]
+    Other(String)
+}
 
 pub struct VariableRequest {
     query: String,
@@ -73,12 +69,12 @@ impl SubscribeStream {
     pub fn new(id: u32, request: VariableRequest, host:&str) -> Result<Self, GraphiteError> {
         let client = ClientBuilder::new(host)
             .map_err(|err| 
-                GraphiteError::new(
+                GraphiteError::NetworkError(
                     format!("Can't create websocket client with address {}. Error {}", host, err)))?
             .add_protocol("graphql-ws")
             .connect(None)
             .map_err(|err|
-                GraphiteError::new(
+                GraphiteError::NetworkError(
                     format!("Can't connect to websocket server {}. Error {}", host, err)))?;
 
         let mut future = Self {
@@ -105,7 +101,7 @@ impl SubscribeStream {
         let msg = OwnedMessage::Text(request);
         self.client.send_message(&msg)
             .map_err(|err| 
-                GraphiteError::new(
+                GraphiteError::NetworkError(
                     format!("Sending message across stdin channel failed. Error: {}", err)))?;
 
         Ok(())
@@ -116,7 +112,7 @@ impl SubscribeStream {
         let msg = OwnedMessage::Text(query.to_string());
         self.client.send_message(&msg)
             .map_err(|err| 
-                GraphiteError::new(
+                GraphiteError::NetworkError(
                     format!("Sending message across stdin channel failed. Error: {}", err)))?;
 
         Ok(())
@@ -146,7 +142,7 @@ pub fn try_extract_error(value: &Value) -> Option<GraphiteError> {
                 if let Some(error) = errors.get(0) {
                     if let Some(message) = error.get("message") {
                         if let Some(string) = message.as_str() {
-                            return Some(GraphiteError::new(string.to_string()))
+                            return Some(GraphiteError::GraprhqlError(string.to_string()))
                         }
                     }
                 }
@@ -166,21 +162,27 @@ impl Stream for SubscribeStream {
                 Ok(message) => {
                     match message {
                         OwnedMessage::Text(text) => {
-                            if let Ok(value) = serde_json::from_str(text.as_str()) {
-                                if let Some(error) = try_extract_error(&value) {
-                                    return Poll::Ready(Some(Err(error)));
+                            match serde_json::from_str(text.as_str()) {
+                                Ok(value) => {
+                                    if let Some(error) = try_extract_error(&value) {
+                                        return Poll::Ready(Some(Err(error)));
+                                    }
+                                    Poll::Ready(Some(Ok(value)))
                                 }
-                                Poll::Ready(Some(Ok(value)))
-                            } else {
-                                Poll::Ready(Some(Err(GraphiteError::new(format!(
-                                        "Invalid JSON: {}", text)))))
+                                Err(error) => {
+                                    Poll::Ready(Some(Err(GraphiteError::SerdeError(error, text))))
+                                }
+                                
                             }
                         },
                         _ => Poll::Pending
                     }
-
-                } ,
-                Err(err) => Poll::Ready(Some(Err(GraphiteError::new(err.to_string())))),
+                },
+                Err(err) => Poll::Ready(
+                    Some(
+                        Err(
+                            GraphiteError::NetworkError(
+                                format!("Can not recieve next message: {}", err.to_string()))))),
             }
         } else {
             Poll::Pending

ton_client/client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ton_client"
-version = "0.24.0"
+version = "0.25.0"
 authors = ["Michael Vlasov"]
 edition = "2018"
 license = "Apache-2.0"
@@ -23,7 +23,7 @@ sha2 = "0.8"
 base64 = "0.10.0"
 lazy_static = "1.1.0"
 num-bigint = "0.2.2"
-sodalite = { version = "0.3.0", features = ["rand"] }
+sodalite = { git = "https://github.com/tonlabs/sodalite.git", features = ["rand"] }
 chrono = "0.4.6"
 scrypt = { version = "0.2.0", default-features = false }
 bip39 = { git = "https://github.com/tonlabs/bip39-rs.git" }
@@ -32,7 +32,7 @@ base58 = "0.1.0"
 pbkdf2 = { version = "0.3.0", default-features = false, features = [] }
 byteorder = "1.3.2"
 libsecp256k1 = "0.2.2"
-log = "0.4.6"
+log = "0.4.11"
 crc-any = "2.2.3"
 failure = "0.1"
 num-traits = "0.2"

ton_client/client/src/client.rs

@@ -15,7 +15,7 @@ use crate::dispatch::DispatchTable;
 use crate::types::{ApiResult, ApiError};
 use super::{JsonResponse, InteropContext};
 use std::collections::HashMap;
-use std::sync::{Mutex, MutexGuard};
+use std::sync::{Arc, Mutex, MutexGuard};
 use ton_sdk::NodeClient;
 
 #[cfg(feature = "node_interaction")]
@@ -50,7 +50,7 @@ pub(crate) struct ClientContext {
     pub client: Option<NodeClient>,
     #[cfg(feature = "node_interaction")]
     pub runtime: Option<Runtime>,
-    pub handle: u32
+    pub handle: InteropContext
 }
 
 impl ClientContext {
@@ -66,7 +66,7 @@ impl ClientContext {
 
 pub(crate) struct Client {
     next_context_handle: InteropContext,
-    contexts: HashMap<InteropContext, ClientContext>,
+    contexts: HashMap<InteropContext, Arc<Mutex<ClientContext>>>,
 }
 
 
@@ -93,39 +93,42 @@ impl Client {
         self.next_context_handle = handle.wrapping_add(1);
 
         #[cfg(feature = "node_interaction")]
-        self.contexts.insert(handle, ClientContext {
+        self.contexts.insert(handle, Arc::new(Mutex::new(ClientContext {
             handle,
             client: None,
             runtime: None,
-        });
+        })));
 
         #[cfg(not(feature = "node_interaction"))]
-        self.contexts.insert(handle, ClientContext {
+        self.contexts.insert(handle,  Arc::new(Mutex::new(ClientContext {
             handle,
             client: None,
-        });
+        })));
 
         handle
     }
 
     pub fn destroy_context(&mut self, handle: InteropContext) {
-        self.required_context(handle).unwrap();
-        if self.contexts.len() == 1 {
-            self.json_sync_request(handle, "uninit".to_owned(), "{}".to_owned());
+        if let Ok(context) = self.required_context(handle) {
+            let mut context = context.lock().unwrap();
+            sync_request(&mut context, "uninit".to_owned(), "{}".to_owned());
         }
         self.contexts.remove(&handle);
     }
 
-    pub fn required_context(&mut self, context: InteropContext) -> ApiResult<&mut ClientContext> {
-        self.contexts.get_mut(&context).ok_or(
-            ApiError::invalid_context_handle(context)
-        )
+    pub fn required_context(&mut self, context: InteropContext) -> ApiResult<Arc<Mutex<ClientContext>>> {
+        Ok(Arc::clone(self.contexts.get_mut(&context)
+            .ok_or(ApiError::invalid_context_handle(context))?))
     }
 
-    pub fn json_sync_request(&mut self, context: InteropContext, method_name: String, params_json: String) -> JsonResponse {
-        let context = self.required_context(context);
+    pub fn json_sync_request(handle: InteropContext, method_name: String, params_json: String) -> JsonResponse {
+        let context = Self::shared().required_context(handle);
         match context {
-            Ok(context) => sync_request(context, method_name, params_json),
+            Ok(context) => {
+                let mut context = context.lock().unwrap();
+                let result = sync_request(&mut context, method_name, params_json);
+                result
+            }
             Err(err) => JsonResponse::from_error(err)
         }
     }