Refactor `NearClient` and add documentation

	* Improve `NearClient` errors. For now, each action has its own distinguished error
	* Remove `commit_empty` and add `Output for function call.
	* Split RPC calls with an deserialization stage`

near-client/Cargo.toml

@@ -4,16 +4,14 @@ version = "0.1.0"
 edition = "2021"
 authors = ["silvestr@relayz.io", "kyrylo@relayz.io"]
 description = """
+The basic implementation of NEAR RPC.
 """
 
-[lib]
-crate-type = ["cdylib", "rlib"]
-
 [dependencies]
 base64 = { version = "0.13" }
 bs58 = "0.4"
 borsh = "0.9"
-ed25519-dalek = "1"
+common-api = { path = "../common-api" }
 itertools = "0.10"
 near-account-id = "0.15"
 near-primitives = { version = "0.15", package = "near-primitives-core" }
@@ -25,7 +23,6 @@ thiserror = "1"
 url = "2"
 
 [dev-dependencies]
-anyhow = "1"
 git2 = "0.15.0"
 reqwest = { version = "0.11", features = ["json"] }
 rand = "0.8.5"

near-client/src/client.rs

@@ -5,168 +5,248 @@ use near_primitives::{
 };
 
 use crate::{
-    rpc::client::RpcClient,
-    types::{
-        crypto::{ED25519PublicKey, ED25519SecretKey, ED25519Signature, Key, Keypair},
-        near::{
-            Action, AddKeyAction, Chunks, CreateAccountAction, DeleteAccountAction,
-            DeployContractAction, FinalExecutionOutcomeView, FinalExecutionStatus,
-            FunctionCallAction, SignedTransaction, Transaction, TransferAction, ViewAccessKey,
-            ViewResult,
-        },
+    near::{
+        Action, AddKeyAction, Chunks, CreateAccountAction, DeleteAccountAction,
+        DeployContractAction, FinalExecutionOutcomeView, FinalExecutionStatus, FunctionCallAction,
+        TransferAction, ViewAccessKey, ViewResult,
     },
-    Error,
+    rpc::client::RpcClient,
+    utils::{serialize_arguments, serialize_transaction, TransactionInfo},
+    Error, Result,
 };
 
-use serde::de::DeserializeOwned;
+use common_api::crypto::prelude::*;
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use serde_json::{json, Value};
 use url::Url;
 
-type Result<T> = std::result::Result<T, Error>;
+use std::sync::{Arc, Mutex};
+
+type AtomicNonce = Arc<Mutex<Nonce>>;
+
+/// The finality param has two options: optimistic and final.
+#[derive(Serialize, Deserialize)]
+pub enum Finality {
+    /// Optimistic uses the latest block recorded on the node
+    /// that responded to your query (<1 second delay after the transaction is submitted)
+    #[serde(rename = "optimistic")]
+    Optimistic,
+    /// Final is for a block that has been validated on at least 66% of the nodes
+    /// in the network (usually takes 2 blocks / approx. 2 second delay)
+    #[serde(rename = "final")]
+    Final,
+}
 
+/// Used for signing transactions
 pub struct Signer {
     keypair: Keypair,
-    signer_acc: AccountId,
-    pub key_nonce: Nonce,
+    account_id: AccountId,
+    nonce: AtomicNonce,
 }
 
 impl Signer {
-    pub fn new(secret_key: &str, signer_acc: AccountId, key_nonce: Nonce) -> Result<Self> {
+    pub fn from_secret_str(secret_key: &str, account_id: AccountId, nonce: Nonce) -> Result<Self> {
         Ok(Self {
-            keypair: Keypair::from_encoded(secret_key)?,
-            signer_acc,
-            key_nonce,
+            keypair: Keypair::from_expanded_secret(secret_key).map_err(Error::CreateSigner)?,
+            account_id,
+            nonce: AtomicNonce::new(Mutex::new(nonce)),
         })
     }
 
-    // Temporary implementation
-    // TODO: refactor [`Signer`]
-    pub fn new_v1(
-        secret_key: &ED25519SecretKey,
-        signer_acc: AccountId,
-        key_nonce: Nonce,
-    ) -> Result<Self> {
-        let sk = ED25519SecretKey::from_bytes(&secret_key.to_bytes())?;
-        Ok(Self {
-            keypair: Keypair::new(sk),
-            signer_acc,
-            key_nonce,
-        })
+    pub fn from_secret(secret_key: Ed25519SecretKey, account_id: AccountId, nonce: Nonce) -> Self {
+        Self {
+            keypair: Keypair::new(secret_key),
+            account_id,
+            nonce: AtomicNonce::new(Mutex::new(nonce)),
+        }
     }
 
-    pub fn sign(&self, data: &[u8]) -> ED25519Signature {
+    /// Sign a transaction
+    ///
+    /// Arguments
+    ///
+    /// - data - Serialized transaction with a [Borsh](https://borsh.io/)
+    pub fn sign(&self, data: &[u8]) -> Ed25519Signature {
         self.keypair.sign(data)
     }
 
-    pub fn public_key(&self) -> ED25519PublicKey {
-        self.keypair.public_key
+    pub fn public_key(&self) -> &Ed25519PublicKey {
+        self.keypair.public_key()
     }
 
-    pub fn secret_key(&self) -> &ED25519SecretKey {
-        &self.keypair.secret_key
+    pub fn secret_key(&self) -> &Ed25519SecretKey {
+        self.keypair.secret_key()
     }
 
     pub fn account(&self) -> &AccountId {
-        &self.signer_acc
+        &self.account_id
     }
 
     pub fn nonce(&self) -> Nonce {
-        self.key_nonce
+        *self.nonce.lock().unwrap()
+    }
+
+    pub fn update_nonce(&self, nonce: Nonce) {
+        *self.nonce.lock().unwrap() = nonce;
+    }
+
+    pub fn increment_nonce(&self, value: u64) {
+        *self.nonce.lock().unwrap() += value;
     }
 }
 
 pub struct NearClient {
-    rpc_client: RpcClient,
+    pub(crate) rpc_client: RpcClient,
 }
 
 impl NearClient {
     pub fn new(url: Url) -> Result<Self> {
         Ok(Self {
-            rpc_client: RpcClient::new(url).map_err(|error| Error::Rpc {
-                error,
-                method: "create_new_near_client",
-            })?,
+            rpc_client: RpcClient::new(url).map_err(Error::CreateClient)?,
         })
     }
 
-    pub async fn block(&self) -> Result<CryptoHash> {
-        let chunks = self
-            .rpc_client
-            .request::<Chunks>("block", Some(json!({"finality": "optimistic"})))
+    /// Queries network and returns block for given height or hash
+    pub async fn block(&self, finality: Finality) -> Result<CryptoHash> {
+        self.rpc_client
+            .request("block", Some(json!({ "finality": finality })))
             .await
-            .map_err(|error| Error::Rpc {
-                error,
-                method: "block",
-            })?;
-
-        Ok(chunks
-            .chunks
-            .into_iter()
-            .next()
-            .ok_or(Error::EmptyBlock)?
-            .prev_block_hash)
+            .map_err(Error::BlockCall)
+            .and_then(|block_res| {
+                serde_json::from_value::<Chunks>(block_res).map_err(Error::DeserializeBlockChunks)
+            })
+            .and_then(|chunks| {
+                Ok(chunks
+                    .chunks
+                    .into_iter()
+                    .next()
+                    .ok_or(Error::EmptyBlock)?
+                    .prev_block_hash)
+            })
     }
 
+    /// Allows you to call a contract method as a view function.
+    ///
+    /// Arguments
+    ///
+    /// - contract_id - The [`AccountId`] where smart contract is located
+    /// - finality - [`Finality`]
+    /// - method - Function that is declared in a smart contract
+    /// - args - Function arguments, could be empty
     pub async fn view<'a, T: DeserializeOwned>(
         &'a self,
         contract_id: &'a AccountId,
+        finality: Finality,
         method: &'static str,
         args: Option<Value>,
     ) -> Result<T> {
-        let view_result = self
-            .rpc_client
-            .request::<ViewResult>(
+        self.rpc_client
+            .request(
                 "query",
                 Some(json!({
                     "request_type": "call_function",
-                    "finality": "optimistic",
+                    "finality": finality,
                     "account_id": contract_id,
                     "method_name": method,
-                    "args_base64": args
-                        .map(|value| serde_json::to_vec(&value))
-                        .transpose()
-                        .map_err(Error::ArgsSerialize)?
-                        .map(base64::encode)
-                        .unwrap_or_default()
+                    "args_base64": base64::encode(serialize_arguments(args)?)
                 })),
             )
             .await
-            .map_err(|error| Error::Rpc {
-                error,
-                method: "query",
-            })?;
-
-        serde_json::from_slice(&view_result.result).map_err(Error::DeserializeTxResp)
+            .map_err(Error::ViewCall)
+            .and_then(|it| {
+                serde_json::from_value::<ViewResult>(it).map_err(Error::DeserializeViewCall)
+            })
+            .and_then(|view_res| {
+                serde_json::from_slice(&view_res.result).map_err(Error::DeserializeViewResponse)
+            })
     }
 
+    /// Returns information about a single access key for given account
+    ///
+    /// Arguments
+    ///
+    /// - account_id - The user [`AccountId`] in a Near network
+    /// - public_key - The user [`Ed25519PublicKey`] in a Near network
     pub async fn view_access_key<'a>(
         &'a self,
         account_id: &'a AccountId,
-        public_key: &'a ED25519PublicKey,
+        public_key: &'a Ed25519PublicKey,
+        finality: Finality,
     ) -> Result<ViewAccessKey> {
-        let result = self
-            .rpc_client
-            .request::<ViewAccessKey>(
+        self.rpc_client
+            .request(
                 "query",
                 Some(json!({
                     "request_type": "view_access_key",
-                    "finality": "optimistic",
+                    "finality": finality,
                     "account_id": account_id,
                     "public_key": public_key,
                 })),
             )
             .await
-            .map_err(|error| Error::Rpc {
-                error,
-                method: "query",
+            .map_err(Error::ViewAccessKeyCall)
+            .and_then(|it| {
+                serde_json::from_value::<ViewAccessKey>(it)
+                    .map_err(Error::DeserializeViewAccessCall)
+            })
+    }
+
+    /// Queries status of a transaction by hash,
+    /// returning the final transaction result and details of all receipts.
+    ///
+    /// Arguments
+    ///
+    /// - transaction_id - Transaction [`CryptoHash`]
+    /// - signer - [`Signer`] that contain information regarding user [`Keypair`]
+    ///
+    /// Return
+    ///
+    /// If a transaction still processing will be returned an error [`Error::ViewTransaction`],
+    /// in this case can try to execute [`view_transaction`] one more time, or a several times.
+    /// If an error differs from [`Error::ViewTransaction`] that something goes totally wrong and
+    /// you should stop to try executing [`view_transaction`] with the same arguments/signer
+    pub async fn view_transaction<'a>(
+        &'a self,
+        transaction_id: &'a CryptoHash,
+        signer: &'a Signer,
+    ) -> Result<Output> {
+        let params = Value::Array(vec![
+            serde_json::to_value(transaction_id)
+                .map_err(|err| Error::SerializeTxViewArg("transaction_id", err))?,
+            serde_json::to_value(signer.account())
+                .map_err(|err| Error::SerializeTxViewArg("signer_acc_id", err))?,
+        ]);
+
+        let execution_outcome = self
+            .rpc_client
+            .request("EXPERIMENTAL_tx_status", Some(params))
+            .await
+            .map_err(Error::ViewTransaction)
+            .and_then(|execution_outcome| {
+                serde_json::from_value::<FinalExecutionOutcomeView>(execution_outcome)
+                    .map_err(Error::DeserializeExecutionOutcome)
             })?;
 
-        Ok(result)
+        match execution_outcome.status {
+            FinalExecutionStatus::Failure(err) => Err(Error::TxExecution(err)),
+            FinalExecutionStatus::SuccessValue(data) => {
+                signer.update_nonce(execution_outcome.transaction.nonce);
+                Ok(Output(data))
+            }
+            _ => Err(Error::TxNotStarted),
+        }
     }
 
+    /// Execute a transaction with a function call to the smart contract
+    ///
+    /// Arguments
+    ///
+    /// - signer - Transaction [`Signer`]
+    /// - contract_id - The [`AccountId`] where smart contract is located
+    /// - method - Function that is declared in a smart contract (Arguments fir function call provided later in a [`FunctionCallBuilder`])
     pub fn function_call<'a>(
         &'a self,
-        signer: &'a mut Signer,
+        signer: &'a Signer,
         contract_id: &'a AccountId,
         method: &'static str,
     ) -> FunctionCallBuilder {
@@ -176,26 +256,24 @@ impl NearClient {
 
     pub fn deploy_contract<'a>(
         &'a self,
-        signer: &'a mut Signer,
+        signer: &'a Signer,
         contract_id: &'a AccountId,
         wasm: Vec<u8>,
-    ) -> Call {
-        let transaction_info = TransactionInfo::new(self, signer, contract_id);
-
-        Call {
-            transaction_info,
+    ) -> FunctionCall {
+        FunctionCall {
+            info: TransactionInfo::new(self, signer, contract_id),
             actions: vec![Action::from(DeployContractAction { code: wasm })],
         }
     }
 
     pub fn create_account<'a>(
         &'a self,
-        signer: &'a mut Signer,
+        signer: &'a Signer,
         new_account_id: &'a AccountId,
-        new_account_pk: ED25519PublicKey,
+        new_account_pk: Ed25519PublicKey,
         amount: Balance,
-    ) -> Call {
-        let transaction_info = TransactionInfo::new(self, signer, new_account_id);
+    ) -> FunctionCall {
+        let info = TransactionInfo::new(self, signer, new_account_id);
         let actions = vec![
             CreateAccountAction {}.into(),
             AddKeyAction {
@@ -209,153 +287,38 @@ impl NearClient {
             TransferAction { deposit: amount }.into(),
         ];
 
-        Call {
-            transaction_info,
-            actions,
-        }
+        FunctionCall { info, actions }
     }
 
     pub fn delete_account<'a>(
         &'a self,
-        signer: &'a mut Signer,
+        signer: &'a Signer,
         account_id: &'a AccountId,
         beneficiary_acc_id: &'a AccountId,
-    ) -> Call {
-        let transaction_info = TransactionInfo::new(self, signer, account_id);
+    ) -> FunctionCall {
+        let info = TransactionInfo::new(self, signer, account_id);
         let actions = vec![DeleteAccountAction {
             beneficiary_id: beneficiary_acc_id.clone(),
         }
         .into()];
 
-        Call {
-            transaction_info,
-            actions,
-        }
+        FunctionCall { info, actions }
     }
 }
 
-pub struct Call<'a> {
-    transaction_info: TransactionInfo<'a>,
-    actions: Vec<Action>,
-}
-
-impl<'a> Call<'a> {
-    pub async fn commit<T: DeserializeOwned>(self) -> Result<T> {
-        let transaction_bytes = serialize_transaction(&self.transaction_info, self.actions).await?;
-
-        let execution_outcome = self
-            .transaction_info
-            .client
-            .rpc_client
-            .request::<FinalExecutionOutcomeView>(
-                "broadcast_tx_commit",
-                Some(json!(vec![base64::encode(transaction_bytes)])),
-            )
-            .await
-            .map_err(|error| Error::Rpc {
-                error,
-                method: "broadcast_tx_commit",
-            })?;
+/// Function call output.
+pub struct Output(Vec<u8>);
 
-        match execution_outcome.status {
-            FinalExecutionStatus::Failure(err) => Err(Error::TransactionExec(err)),
-            FinalExecutionStatus::SuccessValue(mut data) => {
-                let nonce = execution_outcome.transaction.nonce;
-                self.transaction_info.signer.key_nonce = nonce;
-                if data.is_empty() {
-                    data = serde_json::to_vec(&()).unwrap();
-                }
-                serde_json::from_slice::<T>(&data).map_err(Error::DeserializeTxResp)
-            }
-            _ => Err(Error::TxNotStarted),
-        }
-    }
-
-    pub async fn commit_empty(self) -> Result<()> {
-        let transaction_bytes = serialize_transaction(&self.transaction_info, self.actions).await?;
-        let execution_outcome = self
-            .transaction_info
-            .client
-            .rpc_client
-            .request::<FinalExecutionOutcomeView>(
-                "broadcast_tx_commit",
-                Some(json!(vec![base64::encode(transaction_bytes)])),
-            )
-            .await
-            .map_err(|error| Error::Rpc {
-                error,
-                method: "broadcast_tx_commit",
-            })?;
-        match execution_outcome.status {
-            FinalExecutionStatus::Failure(err) => Err(Error::TransactionExec(err)),
-            FinalExecutionStatus::SuccessValue(_) => {
-                let nonce = execution_outcome.transaction.nonce;
-                self.transaction_info.signer.key_nonce = nonce;
-                Ok(())
-            }
-            _ => Err(Error::TxNotStarted),
-        }
-    }
-
-    pub async fn commit_async(self) -> Result<String> {
-        let transaction_bytes = serialize_transaction(&self.transaction_info, self.actions).await?;
-        self.transaction_info
-            .client
-            .rpc_client
-            .request::<String>(
-                "broadcast_tx_async",
-                Some(json!(vec![base64::encode(transaction_bytes)])),
-            )
-            .await
-            .map_err(|error| Error::Rpc {
-                error,
-                method: "broadcast_tx_async",
-            })
-    }
-}
-
-pub struct TransactionInfo<'a> {
-    client: &'a NearClient,
-    signer: &'a mut Signer,
-    contract_id: &'a AccountId,
-}
-impl<'a> TransactionInfo<'a> {
-    fn new(client: &'a NearClient, signer: &'a mut Signer, contract_id: &'a AccountId) -> Self {
-        Self {
-            client,
-            signer,
-            contract_id,
-        }
+impl Output {
+    /// If function don't return anything it will return [`Error::DeserializeTransactionOutput`]
+    /// Or if you miss matching a return type
+    pub fn output<T: DeserializeOwned>(&self) -> Result<T> {
+        serde_json::from_slice::<T>(&self.0).map_err(Error::DeserializeTransactionOutput)
     }
 }
 
-async fn serialize_transaction<'a>(
-    transaction_info: &'a TransactionInfo<'_>,
-    actions: Vec<Action>,
-) -> Result<Vec<u8>> {
-    let block_hash = transaction_info.client.block().await?;
-
-    let transaction = Transaction {
-        signer_id: transaction_info.signer.account().clone(),
-        public_key: transaction_info.signer.public_key(),
-        nonce: transaction_info.signer.nonce() + 1,
-        receiver_id: transaction_info.contract_id.clone(),
-        block_hash,
-        actions,
-    };
-
-    let signed_transaction = sign_transaction(transaction_info.signer, transaction);
-    borsh::to_vec(&signed_transaction).map_err(Error::TransactionSerialize)
-}
-
-fn sign_transaction(signer: &Signer, transaction: Transaction) -> SignedTransaction {
-    let (hash, ..) = transaction.get_hash_and_size();
-    let signature = signer.keypair.sign(hash.0.as_ref());
-    SignedTransaction::new(signature, transaction)
-}
-
 pub struct FunctionCallBuilder<'a> {
-    transaction_info: TransactionInfo<'a>,
+    info: TransactionInfo<'a>,
     deposit: Balance,
     gas: Gas,
     args: Option<Value>,
@@ -363,9 +326,9 @@ pub struct FunctionCallBuilder<'a> {
 }
 
 impl<'a> FunctionCallBuilder<'a> {
-    fn new(transaction_info: TransactionInfo<'a>, method_name: &'a str) -> Self {
+    fn new(info: TransactionInfo<'a>, method_name: &'a str) -> Self {
         Self {
-            transaction_info,
+            info,
             method_name,
             gas: Default::default(),
             args: Default::default(),
@@ -378,6 +341,7 @@ impl<'a> FunctionCallBuilder<'a> {
         self
     }
 
+    /// Amount of gas that will be hold for function execution
     pub fn gas(mut self, gas: Gas) -> Self {
         self.gas = gas;
         self
@@ -388,28 +352,73 @@ impl<'a> FunctionCallBuilder<'a> {
         self
     }
 
-    pub fn build(self) -> Result<Call<'a>> {
-        let args = self
-            .args
-            .as_ref()
-            .map(serde_json::to_vec)
-            .transpose()
-            .map_err(Error::ArgsSerialize)?
-            .unwrap_or_default();
-
+    pub fn build(self) -> Result<FunctionCall<'a>> {
         let action = Action::from(FunctionCallAction {
             method_name: self.method_name.to_string(),
-            args,
+            args: serialize_arguments(self.args)?,
             gas: self.gas,
             deposit: self.deposit,
         });
 
-        Ok(Call {
-            transaction_info: self.transaction_info,
+        Ok(FunctionCall {
+            info: self.info,
             actions: vec![action],
         })
     }
 }
 
-#[cfg(test)]
-mod tests {}
+pub struct FunctionCall<'a> {
+    info: TransactionInfo<'a>,
+    actions: Vec<Action>,
+}
+
+impl<'a> FunctionCall<'a> {
+    /// Sends a transaction and waits until transaction is fully complete. (Has a 10 second timeout)
+    pub async fn commit(self, block_finality: Finality) -> Result<Output> {
+        let transaction_bytes =
+            serialize_transaction(&self.info, self.actions, block_finality).await?;
+
+        let execution_outcome = self
+            .info
+            .rpc()
+            .request(
+                "broadcast_tx_commit",
+                Some(json!(vec![base64::encode(transaction_bytes)])),
+            )
+            .await
+            .map_err(Error::CommitTransaction)
+            .and_then(|execution_outcome| {
+                serde_json::from_value::<FinalExecutionOutcomeView>(execution_outcome)
+                    .map_err(Error::DeserializeExecutionOutcome)
+            })?;
+
+        match execution_outcome.status {
+            FinalExecutionStatus::Failure(err) => Err(Error::TxExecution(err)),
+            FinalExecutionStatus::SuccessValue(data) => {
+                self.info
+                    .signer()
+                    .update_nonce(execution_outcome.transaction.nonce);
+
+                Ok(Output(data))
+            }
+            _ => Err(Error::TxNotStarted),
+        }
+    }
+
+    /// Sends a transaction and immediately returns transaction hash.
+    pub async fn commit_async(self, block_finality: Finality) -> Result<CryptoHash> {
+        let transaction_bytes =
+            serialize_transaction(&self.info, self.actions, block_finality).await?;
+        self.info
+            .rpc()
+            .request(
+                "broadcast_tx_async",
+                Some(json!(vec![base64::encode(transaction_bytes)])),
+            )
+            .await
+            .map_err(Error::CommitAsyncTransaction)
+            .and_then(|id| {
+                serde_json::from_value::<CryptoHash>(id).map_err(Error::DeserializeTransactionId)
+            })
+    }
+}

near-client/src/lib.rs

@@ -1,59 +1,53 @@
-use prelude::TxExecutionError;
+mod rpc;
+mod utils;
 
 pub mod client;
-pub mod rpc;
-pub mod types;
+pub mod near;
 
-pub mod prelude {
-    pub use super::types::{
-        self,
-        crypto::{ED25519PublicKey, ED25519Signature, Keypair},
-        near::TxExecutionError,
-    };
-}
+type Result<T> = std::result::Result<T, Error>;
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("{0}")]
-    Type(types::Error),
-    #[error("Rpc request failed for [\"{method}\"] with {error}")]
-    Rpc {
-        error: rpc::Error,
-        method: &'static str,
-    },
+    #[error("Failed to create a signer, cause [\"{0}\"]")]
+    CreateSigner(common_api::crypto::Error),
+    #[error("Transaction not started")]
+    TxNotStarted,
+    #[error("Transaction failed during execution, cause [\"{0:?}\"]")]
+    TxExecution(near::TxExecutionError),
+    #[error("Transaction serialization error: [\"{0}\"]")]
+    TxSerialization(std::io::Error),
+    #[error("Couldn't serialize an argument [\"{0}\"] to view a transaction, cause: [\"{1}\"]")]
+    SerializeTxViewArg(&'static str, serde_json::Error),
+    #[error("Couldn't serialize arguments for view or function call, cause: [\"{0}\"]")]
+    ArgsSerialization(serde_json::Error),
+    #[error("Client creation failed, cause: [\"{0}\"]")]
+    CreateClient(rpc::Error),
+    #[error("Can't view a transaction, cause: [\"{0}\"]")]
+    ViewTransaction(rpc::Error),
+    #[error("Transaction commit failed with an error, cause: [\"{0}\"]")]
+    CommitTransaction(rpc::Error),
+    #[error("Transaction async commit failed with an error, cause: [\"{0}\"]")]
+    CommitAsyncTransaction(rpc::Error),
+    #[error("Block call failed with an error: \"{0}\"")]
+    BlockCall(rpc::Error),
     #[error("Couldn't get a previous block hash")]
     EmptyBlock,
-    #[error("Couldn't serialize function arguments {0}")]
-    ArgsSerialize(serde_json::Error),
-    #[error("Couldn't deserialize tx response {0}")]
-    DeserializeTxResp(serde_json::Error),
-    #[error("Borsh can't serialize transaction {0}")]
-    TransactionSerialize(std::io::Error),
-    #[error("Execution of transaction failed {0:?}")]
-    TransactionExec(TxExecutionError),
-    #[error("Transaction not started yet")]
-    TxNotStarted,
-    #[error("Rpc:")]
-    NoSigner,
-}
-
-impl From<types::Error> for Error {
-    fn from(err: types::Error) -> Self {
-        Self::Type(err)
-    }
-}
-
-pub fn add(left: usize, right: usize) -> usize {
-    left + right
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
+    #[error("Access key call failed with an error: \"{0}\"")]
+    ViewAccessKeyCall(rpc::Error),
+    #[error("View call failed with an error: \"{0}\"")]
+    ViewCall(rpc::Error),
+    #[error("Couldn't deserialize a transaction function output, cause: [\"{0}\"]")]
+    DeserializeTransactionOutput(serde_json::Error),
+    #[error("Couldn't deserialize a transaction outcome, cause: [\"{0}\"]")]
+    DeserializeExecutionOutcome(serde_json::Error),
+    #[error("Couldn't deserialize a transaction id, cause: [\"{0}\"]")]
+    DeserializeTransactionId(serde_json::Error),
+    #[error("Couldn't deserialize a view call result, cause [\"{0}\"]")]
+    DeserializeViewCall(serde_json::Error),
+    #[error("Couldn't deserialize a view response, cause [\"{0}\"]")]
+    DeserializeViewResponse(serde_json::Error),
+    #[error("Couldn't deserialize a block chunks, cause: [\"{0}\"]")]
+    DeserializeBlockChunks(serde_json::Error),
+    #[error("Can't deserialize an access key response, cause: [\"{0}\"]")]
+    DeserializeViewAccessCall(serde_json::Error),
 }

near-client/src/types/near.rs → near-client/src/near.rs

@@ -1,4 +1,9 @@
-use crate::types::crypto::{ED25519PublicKey, ED25519Signature};
+//! ### Near RPC types
+//! ---
+//! Mostly it's a copy-paste from a [`nearcore`](https://github.com/near/nearcore)
+//! with a some additional tunning for a Relayz requirements
+
+use common_api::crypto::prelude::*;
 
 use borsh::{BorshDeserialize, BorshSerialize};
 use near_account_id::AccountId;
@@ -27,7 +32,7 @@ pub struct Transaction {
     pub signer_id: AccountId,
     /// A public key of the access key which was used to sign an account.
     /// Access key holds permissions for calling certain kinds of actions.
-    pub public_key: ED25519PublicKey,
+    pub public_key: Ed25519PublicKey,
     /// Nonce is used to determine order of transaction in the pool.
     /// It increments for a combination of `signer_id` and `public_key`
     pub nonce: Nonce,
@@ -163,7 +168,7 @@ pub struct StakeAction {
     #[serde(with = "dec_format")]
     pub stake: Balance,
     /// Validator key which will be used to sign transactions on behalf of singer_id
-    pub public_key: ED25519PublicKey,
+    pub public_key: Ed25519PublicKey,
 }
 
 impl From<StakeAction> for Action {
@@ -175,7 +180,7 @@ impl From<StakeAction> for Action {
 #[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
 pub struct AddKeyAction {
     /// A public key which will be associated with an access_key
-    pub public_key: ED25519PublicKey,
+    pub public_key: Ed25519PublicKey,
     /// An access key with the permission
     pub access_key: AccessKey,
 }
@@ -189,7 +194,7 @@ impl From<AddKeyAction> for Action {
 #[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
 pub struct DeleteKeyAction {
     /// A public key associated with the access_key to be deleted.
-    pub public_key: ED25519PublicKey,
+    pub public_key: Ed25519PublicKey,
 }
 
 impl From<DeleteKeyAction> for Action {
@@ -213,7 +218,7 @@ impl From<DeleteAccountAction> for Action {
 #[borsh_init(init)]
 pub struct SignedTransaction {
     pub transaction: Transaction,
-    pub signature: ED25519Signature,
+    pub signature: Ed25519Signature,
     #[borsh_skip]
     hash: CryptoHash,
     #[borsh_skip]
@@ -221,7 +226,7 @@ pub struct SignedTransaction {
 }
 
 impl SignedTransaction {
-    pub fn new(signature: ED25519Signature, transaction: Transaction) -> Self {
+    pub fn new(signature: Ed25519Signature, transaction: Transaction) -> Self {
         let mut signed_tx = Self {
             signature,
             transaction,
@@ -268,11 +273,11 @@ impl Borrow<CryptoHash> for SignedTransaction {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SignedTransactionView {
     pub signer_id: AccountId,
-    pub public_key: ED25519PublicKey,
+    pub public_key: Ed25519PublicKey,
     pub nonce: Nonce,
     pub receiver_id: AccountId,
     pub actions: Vec<ActionView>,
-    pub signature: ED25519Signature,
+    pub signature: Ed25519Signature,
     pub hash: CryptoHash,
 }
 
@@ -387,14 +392,14 @@ pub enum ActionView {
     Stake {
         #[serde(with = "dec_format")]
         stake: Balance,
-        public_key: ED25519PublicKey,
+        public_key: Ed25519PublicKey,
     },
     AddKey {
-        public_key: ED25519PublicKey,
+        public_key: Ed25519PublicKey,
         access_key: AccessKeyView,
     },
     DeleteKey {
-        public_key: ED25519PublicKey,
+        public_key: Ed25519PublicKey,
     },
     DeleteAccount {
         beneficiary_id: AccountId,

near-client/src/rpc/client.rs

@@ -1,6 +1,6 @@
 use reqwest::{
     header::{HeaderMap, CONTENT_TYPE},
-    Client, ClientBuilder,
+    Client, ClientBuilder, Response as Resp,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -11,13 +11,19 @@ use url::Url;
 
 type Result<T> = std::result::Result<T, Error>;
 
-pub struct RpcClient {
+pub(crate) struct RpcClient {
     client: Client,
     url: Url,
 }
 
 impl RpcClient {
-    pub fn new(url: Url) -> Result<Self> {
+    /// Creates a [`reqwest`] client with headers:
+    /// [`CONTENT_TYPE`]: "application/json"
+    ///
+    /// Arguments
+    ///
+    /// - url - It's an RPC endpoint [`Url`]
+    pub(crate) fn new(url: Url) -> Result<Self> {
         let mut headers = HeaderMap::new();
         // It can't panic
         headers.insert(CONTENT_TYPE, "application/json".parse().unwrap());
@@ -29,11 +35,23 @@ impl RpcClient {
         Ok(Self { client, url })
     }
 
-    pub async fn request<T: serde::de::DeserializeOwned>(
-        &self,
-        method: &str,
-        params: Option<Value>,
-    ) -> Result<T> {
+    /// RPC call to the NEAR network
+    ///
+    /// Arguments
+    ///
+    /// - method - RPC method
+    /// - params - method arguments, could be empty
+    ///
+    /// Response example:
+    /// ```json
+    /// {
+    ///   "id": "dontcare",
+    ///   "jsonrpc": "2.0",
+    ///   "result": "...",
+    /// }
+    ///
+    /// ```
+    pub(crate) async fn request(&self, method: &str, params: Option<Value>) -> Result<Value> {
         let resp = self
             .client
             .post(self.url.clone())
@@ -43,11 +61,11 @@ impl RpcClient {
             )
             .send()
             .await
-            .and_then(reqwest::Response::error_for_status)
+            .and_then(Resp::error_for_status)
             .map_err(Error::RpcRequest)?;
 
         match resp
-            .json::<Response<T>>()
+            .json::<Response>()
             .await
             .map_err(Error::DeserializeRpcResponse)?
         {
@@ -88,21 +106,21 @@ impl<'a> Request<'a> {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-struct Response<T> {
+struct Response {
     /// JSON-RPC version.
     pub jsonrpc: String,
     /// Result.
     #[serde(flatten)]
-    pub result: RpcResult<T>,
+    pub result: RpcResult,
     /// Request ID
     pub id: String,
 }
 
 /// Near result format
 #[derive(Debug, Serialize, Deserialize)]
-enum RpcResult<T> {
+enum RpcResult {
     #[serde(rename = "result")]
-    Ok(T),
+    Ok(Value),
     #[serde(rename = "error")]
     Err(NearError),
 }
@@ -113,15 +131,21 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test() {
+    fn response_sample() {
         let resp = Response {
-            jsonrpc: "some".to_owned(),
-            result: RpcResult::Ok("wef".to_owned()),
+            jsonrpc: "2.0".to_owned(),
+            result: RpcResult::Ok(Value::String("some value".to_owned())),
             id: "dontcare".to_owned(),
         };
 
-        let r = serde_json::to_string_pretty(&resp).unwrap();
-
-        println!("{}", r);
+        assert_eq!(
+            serde_json::to_value(&resp).unwrap(),
+            serde_json::to_value(&serde_json::json!({
+                "id": "dontcare",
+                "jsonrpc": "2.0",
+                "result": "some value",
+            }))
+            .unwrap()
+        );
     }
 }

near-client/src/rpc/mod.rs

@@ -1,4 +1,4 @@
-pub mod client;
+pub(crate) mod client;
 
 use std::fmt::Display;
 
@@ -7,15 +7,15 @@ use serde_json::Value;
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("Couldn't create a RpcClient: {0}")]
+    #[error("Couldn't create a RpcClient: [\"{0}\"]")]
     RpcClientCreate(reqwest::Error),
-    #[error("Rpc request failed with: {0}")]
+    #[error("Rpc request failed with: [\"{0}\"]")]
     RpcRequest(reqwest::Error),
-    #[error("Failed to serialize an RPC request: {0}")]
+    #[error("Failed to serialize an RPC request: [\"{0}\"]")]
     SerializeRpcRequest(serde_json::Error),
-    #[error("Failed to serialize an RPC request: {0}")]
+    #[error("Failed to deserialize an RPC response: [\"{0}\"]")]
     DeserializeRpcResponse(reqwest::Error),
-    #[error("Near protocol error: {0}")]
+    #[error("Near protocol error: [\"{0}\"]")]
     NearProtocol(NearError),
 }
 
@@ -38,7 +38,7 @@ impl Display for NearError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "Name: {} Msg: {} Cause: {} descr: {}",
+            "Name: {}, Message: {}, Cause: {}, Descr: {}",
             self.name, self.message, self.cause, self.data
         )
     }

near-client/src/types/crypto.rs

@@ -1,317 +0,0 @@
-use borsh::{BorshDeserialize, BorshSerialize};
-use ed25519_dalek::{
-    ExpandedSecretKey, PublicKey, SecretKey, Signature, Verifier, PUBLIC_KEY_LENGTH,
-    SECRET_KEY_LENGTH, SIGNATURE_LENGTH,
-};
-use itertools::Itertools;
-use serde::{Deserialize, Serialize};
-use std::{
-    fmt::{Debug, Display},
-    hash::{Hash, Hasher},
-    io::{Error as IoError, ErrorKind},
-    str::FromStr,
-};
-
-use crate::types::Error;
-
-type Result<T> = std::result::Result<T, Error>;
-
-pub trait Key<T, const KEY_LENGTH: usize> {
-    fn from_string(key: &str) -> Result<T> {
-        let bs58_encoded = split_encoded_str(key)?;
-        let bytes = bs58::decode(bs58_encoded)
-            .into_vec()
-            .map_err(|err| Error::from_string::<T>(bs58_encoded.to_owned(), err.to_string()))?;
-        Self::from_bytes(&bytes)
-    }
-
-    fn to_string(&self) -> String {
-        format!("ed25519:{}", bs58::encode(self.to_bytes()).into_string())
-    }
-
-    fn from_bytes(bytes: &[u8]) -> Result<T>;
-    fn to_bytes(&self) -> [u8; KEY_LENGTH];
-}
-
-#[derive(Copy, Clone, Default, Eq, PartialEq)]
-pub struct ED25519PublicKey(PublicKey);
-
-impl ED25519PublicKey {
-    pub fn verify(&self, data: &[u8], signature: &ED25519Signature) -> Result<()> {
-        self.0
-            .verify(data, &signature.0)
-            .map_err(|_| Error::Verification(*signature))
-    }
-
-    #[inline]
-    pub fn as_bytes(&self) -> &[u8; PUBLIC_KEY_LENGTH] {
-        self.0.as_bytes()
-    }
-}
-
-impl Key<ED25519PublicKey, PUBLIC_KEY_LENGTH> for ED25519PublicKey {
-    fn from_bytes(bytes: &[u8]) -> Result<ED25519PublicKey> {
-        PublicKey::from_bytes(bytes)
-            .map(Self)
-            .map_err(|err| Error::from_bytes::<ED25519PublicKey>(bytes, err.to_string()))
-    }
-
-    #[inline]
-    fn to_bytes(&self) -> [u8; PUBLIC_KEY_LENGTH] {
-        self.0.to_bytes()
-    }
-}
-
-impl BorshDeserialize for ED25519PublicKey {
-    fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
-        if buf.len() != PUBLIC_KEY_LENGTH {
-            return Err(IoError::new(ErrorKind::InvalidData, format!("Couldn't deserialize a ED25519PublicKey, input buffer {} is greater or less than required", buf.len())));
-        }
-
-        // The first byte is a key type, let's skip it because currently is used ed25519 only
-        let temp_buf = std::mem::take(buf);
-        Ok(Self(PublicKey::from_bytes(&temp_buf[1..]).map_err(
-            |err| {
-                IoError::new(
-                    ErrorKind::InvalidData,
-                    format!("Couldn't deserialize a ED25519PublicKey because of: {err}"),
-                )
-            },
-        )?))
-    }
-}
-
-impl BorshSerialize for ED25519PublicKey {
-    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
-        BorshSerialize::serialize(&0_u8, writer)?;
-        writer.write_all(self.0.as_bytes())
-    }
-}
-
-impl From<&ED25519SecretKey> for ED25519PublicKey {
-    fn from(sk: &ED25519SecretKey) -> Self {
-        Self(PublicKey::from(&sk.0))
-    }
-}
-
-// This `Hash` implementation is safe since it retains the property
-// `k1 == k2 ⇒ hash(k1) == hash(k2)`.
-#[allow(clippy::derive_hash_xor_eq)]
-impl Hash for ED25519PublicKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        state.write_u8(0u8);
-        state.write(self.0.as_bytes());
-    }
-}
-
-impl Debug for ED25519PublicKey {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
-        write!(f, "{}", self)
-    }
-}
-
-impl Display for ED25519PublicKey {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", Key::to_string(self))
-    }
-}
-
-pub struct ED25519SecretKey(SecretKey);
-
-impl ED25519SecretKey {
-    pub fn sign(&self, data: &[u8], public_key: &ED25519PublicKey) -> ED25519Signature {
-        let expanded_key = ExpandedSecretKey::from(&self.0);
-        ED25519Signature(expanded_key.sign(data, &public_key.0))
-    }
-
-    #[inline]
-    pub fn as_bytes(&self) -> &[u8; PUBLIC_KEY_LENGTH] {
-        self.0.as_bytes()
-    }
-
-    pub fn from_encoded_expanded(key: &str) -> Result<Self> {
-        let bs58_encoded = split_encoded_str(key)?;
-        let expanded_key_bytes = bs58::decode(bs58_encoded).into_vec().map_err(|err| {
-            Error::from_string::<ED25519SecretKey>(bs58_encoded.to_owned(), err.to_string())
-        })?;
-        Self::from_bytes(&expanded_key_bytes[..32])
-    }
-}
-
-impl Key<ED25519SecretKey, SECRET_KEY_LENGTH> for ED25519SecretKey {
-    fn from_bytes(bytes: &[u8]) -> Result<ED25519SecretKey> {
-        SecretKey::from_bytes(bytes)
-            .map(Self)
-            .map_err(|err| Error::from_bytes::<ED25519SecretKey>(bytes, err.to_string()))
-    }
-
-    #[inline]
-    fn to_bytes(&self) -> [u8; SECRET_KEY_LENGTH] {
-        self.0.to_bytes()
-    }
-}
-
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub struct ED25519Signature(Signature);
-
-impl Key<ED25519Signature, SIGNATURE_LENGTH> for ED25519Signature {
-    fn from_bytes(bytes: &[u8]) -> Result<ED25519Signature> {
-        Signature::from_bytes(bytes)
-            .map(Self)
-            .map_err(|err| Error::from_bytes::<ED25519Signature>(bytes, err.to_string()))
-    }
-
-    fn to_bytes(&self) -> [u8; SIGNATURE_LENGTH] {
-        self.0.to_bytes()
-    }
-}
-
-impl BorshSerialize for ED25519Signature {
-    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
-        BorshSerialize::serialize(&0_u8, writer)?;
-        writer.write_all(&self.to_bytes())
-    }
-}
-
-impl BorshDeserialize for ED25519Signature {
-    fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
-        if buf.len() != SIGNATURE_LENGTH + 1 {
-            return Err(IoError::new(ErrorKind::InvalidData, format!("Couldn't deserialize a ED25519Signature, input buffer {} is greater or less than required", buf.len())));
-        }
-
-        // The first byte is a key type, let's skip it because currently is used ed25519 only
-        let temp_buf = std::mem::take(buf);
-        Self::from_bytes(&temp_buf[1..]).map_err(|err| {
-            IoError::new(
-                ErrorKind::InvalidData,
-                format!("Couldn't deserialize a ED25519Signature because of: {err}"),
-            )
-        })
-    }
-}
-
-#[allow(clippy::derive_hash_xor_eq)]
-impl Hash for ED25519Signature {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.to_bytes().hash(state);
-    }
-}
-
-impl Debug for ED25519Signature {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
-        write!(f, "{}", self)
-    }
-}
-
-impl Display for ED25519Signature {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", Key::to_string(self))
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Keypair {
-    pub public_key: ED25519PublicKey,
-    pub secret_key: ED25519SecretKey,
-}
-
-impl Keypair {
-    pub fn new(secret_key: ED25519SecretKey) -> Self {
-        let public_key = ED25519PublicKey::from(&secret_key);
-        Self {
-            public_key,
-            secret_key,
-        }
-    }
-
-    pub fn from_encoded(encoded: &str) -> Result<Self> {
-        let secret_key = ED25519SecretKey::from_encoded_expanded(encoded)?;
-        let public_key = ED25519PublicKey::from(&secret_key);
-        Ok(Self {
-            public_key,
-            secret_key,
-        })
-    }
-
-    pub fn sign(&self, data: &[u8]) -> ED25519Signature {
-        self.secret_key.sign(data, &self.public_key)
-    }
-
-    pub fn verify(&self, data: &[u8], signature: &ED25519Signature) -> Result<()> {
-        self.public_key.verify(data, signature)
-    }
-}
-
-macro_rules! util_impl {
-    ($key_type: ty) => {
-        impl From<$key_type> for String {
-            fn from(key: $key_type) -> Self {
-                Key::to_string(&key)
-            }
-        }
-
-        impl FromStr for $key_type {
-            type Err = Error;
-
-            fn from_str(s: &str) -> Result<Self> {
-                Self::from_string(s)
-            }
-        }
-    };
-}
-
-macro_rules! serde_impl {
-    ($key_type: ty) => {
-        impl serde::Serialize for $key_type {
-            fn serialize<S>(
-                &self,
-                serializer: S,
-            ) -> std::result::Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
-            where
-                S: serde::Serializer,
-            {
-                serializer.serialize_str(&Key::to_string(self))
-            }
-        }
-
-        impl<'de> serde::Deserialize<'de> for $key_type {
-            fn deserialize<D>(
-                deserializer: D,
-            ) -> std::result::Result<Self, <D as serde::Deserializer<'de>>::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                let s = <String as serde::Deserialize>::deserialize(deserializer)?;
-                s.parse().map_err(|err| {
-                    serde::de::Error::custom(format!("Deserialization failed: `{}`", err))
-                })
-            }
-        }
-    };
-}
-
-fn split_encoded_str(encoded: &str) -> Result<&str> {
-    match encoded.split(':').next_tuple() {
-        Some((key_type, bs58_encoded)) => {
-            if key_type != "ed25519" {
-                return Err(Error::UnknownKeyType(key_type.to_owned()));
-            }
-            Ok(bs58_encoded)
-        }
-        _ => Err(Error::UnknownKeyType(encoded.to_owned())),
-    }
-}
-
-serde_impl!(ED25519PublicKey);
-util_impl!(ED25519PublicKey);
-serde_impl!(ED25519SecretKey);
-util_impl!(ED25519SecretKey);
-serde_impl!(ED25519Signature);
-util_impl!(ED25519Signature);
-
-#[cfg(test)]
-mod tests {
-
-    #[test]
-    fn test() {}
-}

near-client/src/types/mod.rs

@@ -1,50 +0,0 @@
-pub mod crypto;
-pub mod near;
-
-#[derive(thiserror::Error, Debug)]
-pub enum Error {
-    #[error(
-        "Couldn't convert key from bytes `{key_string}` into `{key_name}`, because of: {cause}"
-    )]
-    ConvertFromBytes {
-        key_name: &'static str,
-        key_string: String,
-        cause: String,
-    },
-    #[error(
-        "Couldn't convert key from string `{key_string}` into `{key_name}`, because of: {cause}"
-    )]
-    ConvertFromString {
-        key_name: &'static str,
-        key_string: String,
-        cause: String,
-    },
-    #[error("The key format `{0}` seems different from ed25519 format")]
-    UnknownKeyType(String),
-    #[error("Signature `{0}` verification failed")]
-    Verification(crypto::ED25519Signature),
-}
-
-impl Error {
-    pub(crate) fn from_string<T>(key_string: String, cause: String) -> Self {
-        Self::ConvertFromString {
-            key_name: std::any::type_name::<T>()
-                .rsplit("::")
-                .next()
-                .unwrap_or_default(),
-            key_string,
-            cause,
-        }
-    }
-
-    pub(crate) fn from_bytes<T>(data: &[u8], cause: String) -> Self {
-        Self::ConvertFromBytes {
-            key_name: std::any::type_name::<T>()
-                .rsplit("::")
-                .next()
-                .unwrap_or_default(),
-            key_string: bs58::encode(data).into_string(),
-            cause,
-        }
-    }
-}

near-client/src/utils.rs

@@ -0,0 +1,74 @@
+use crate::{
+    client::{Finality, NearClient, Signer},
+    near::{Action, SignedTransaction, Transaction},
+    rpc::client::RpcClient,
+    Error, Result,
+};
+
+use near_primitives::account::id::AccountId;
+use serde_json::Value;
+
+pub(crate) struct TransactionInfo<'a> {
+    client: &'a NearClient,
+    signer: &'a Signer,
+    contract_id: &'a AccountId,
+}
+
+impl<'a> TransactionInfo<'a> {
+    pub(crate) fn new(
+        client: &'a NearClient,
+        signer: &'a Signer,
+        contract_id: &'a AccountId,
+    ) -> Self {
+        Self {
+            client,
+            signer,
+            contract_id,
+        }
+    }
+
+    pub(crate) fn rpc(&self) -> &RpcClient {
+        &self.client.rpc_client
+    }
+
+    pub(crate) fn signer(&self) -> &Signer {
+        self.signer
+    }
+}
+
+/// Serialize and sign a transaction
+/// During call it requests the most recent block [`CryptoHash`]
+pub(crate) async fn serialize_transaction<'a>(
+    info: &'a TransactionInfo<'_>,
+    actions: Vec<Action>,
+    block_finality: Finality,
+) -> Result<Vec<u8>> {
+    let block_hash = info.client.block(block_finality).await?;
+
+    let transaction = Transaction {
+        signer_id: info.signer.account().clone(),
+        public_key: *info.signer.public_key(),
+        nonce: info.signer.nonce() + 1,
+        receiver_id: info.contract_id.clone(),
+        block_hash,
+        actions,
+    };
+
+    let signed_transaction = sign_transaction(info.signer, transaction);
+    borsh::to_vec(&signed_transaction).map_err(Error::TxSerialization)
+}
+
+pub(crate) fn serialize_arguments(args: Option<Value>) -> Result<Vec<u8>> {
+    Ok(args
+        .as_ref()
+        .map(serde_json::to_vec)
+        .transpose()
+        .map_err(Error::ArgsSerialization)?
+        .unwrap_or_default())
+}
+
+pub(crate) fn sign_transaction(signer: &Signer, transaction: Transaction) -> SignedTransaction {
+    let (hash, ..) = transaction.get_hash_and_size();
+    let signature = signer.sign(hash.0.as_ref());
+    SignedTransaction::new(signature, transaction)
+}

near-client/tests/rpc.rs

@@ -1,11 +1,8 @@
+use common_api::crypto::prelude::*;
 use git2::{Cred, RemoteCallbacks};
-use itertools::Itertools;
 use near_client::{
-    client::{NearClient, Signer},
-    types::{
-        crypto::{ED25519PublicKey, ED25519SecretKey, Key},
-        near::{ViewAccessKey, ViewAccessKeyResult},
-    },
+    client::{Finality, NearClient, Signer},
+    near::{ViewAccessKey, ViewAccessKeyResult},
 };
 use rand::{RngCore, SeedableRng};
 use rand_chacha::ChaChaRng;
@@ -19,57 +16,58 @@ use std::{
 use workspaces::{network::Sandbox, types::SecretKey, AccountId, Worker};
 
 // auxiliary structs and methods
-fn near_client(worker: &Worker<Sandbox>) -> anyhow::Result<NearClient> {
-    let rpc_url = Url::parse(format!("http://localhost:{}", worker.rpc_port()).as_str())?;
-    let client = NearClient::new(rpc_url)?;
-    Ok(client)
+fn near_client(worker: &Worker<Sandbox>) -> NearClient {
+    let rpc_url = Url::parse(format!("http://localhost:{}", worker.rpc_port()).as_str()).unwrap();
+    NearClient::new(rpc_url).unwrap()
 }
 
 async fn create_signer(
     worker: &Worker<Sandbox>,
     client: &NearClient,
     signer_acc_id: &AccountId,
-) -> anyhow::Result<Signer> {
-    let secret_key = ED25519SecretKey::from_bytes(&random_bits())?;
-    let ws_secret_key_str = to_workspaces_sk(&secret_key);
-    let pk = ED25519PublicKey::from(&secret_key);
-    let ws_sk = SecretKey::from_str(&ws_secret_key_str)?;
-    let _ = worker.create_tla(signer_acc_id.clone(), ws_sk).await?;
+) -> Signer {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let pk = Ed25519PublicKey::from(&sk);
+    let keypair = Keypair::new(sk).to_string();
+    let workspaces_sk = SecretKey::from_str(&keypair).unwrap();
+    let _ = worker
+        .create_tla(signer_acc_id.clone(), workspaces_sk)
+        .await
+        .unwrap();
 
-    client
-        .view_access_key(signer_acc_id, &pk)
+    let view_access_key = client
+        .view_access_key(signer_acc_id, &pk, Finality::Optimistic)
         .await
-        .map(|access_key_view| match access_key_view.result {
-            ViewAccessKeyResult::Ok { nonce, .. } => {
-                let signer_acc = Signer::new(&ws_secret_key_str, signer_acc_id.clone(), nonce)?;
-                Ok(signer_acc)
-            }
-            ViewAccessKeyResult::Err { error, .. } => Err(anyhow::anyhow!(error)),
-        })?
+        .unwrap();
+
+    match view_access_key.result {
+        ViewAccessKeyResult::Ok { nonce, .. } => {
+            Signer::from_secret_str(&keypair, signer_acc_id.clone(), nonce).unwrap()
+        }
+        ViewAccessKeyResult::Err { error, .. } => panic!("{error}"),
+    }
 }
 
-async fn download_contract() -> anyhow::Result<Vec<u8>> {
+async fn download_contract() -> Vec<u8> {
     let target = "https://github.com/near-examples/FT/raw/master/res/fungible_token.wasm";
     let target_path = "../target/tmp-contracts";
     let fname = "contract.wasm";
     let full_dest = format!("{}/{}", target_path, fname);
 
-    let contract_bytes = if !Path::new(&full_dest).exists() {
+    if !Path::new(&full_dest).exists() {
         if !Path::new(&target_path).exists() {
-            create_dir(target_path)?;
+            create_dir(target_path).unwrap();
         };
 
-        let contract_bytes = reqwest::get(target).await?.bytes().await?;
-        write(full_dest, &contract_bytes)?;
+        let contract_bytes = reqwest::get(target).await.unwrap().bytes().await.unwrap();
+        write(full_dest, &contract_bytes).unwrap();
         contract_bytes.to_vec()
     } else {
-        read(&full_dest)?
-    };
-
-    Ok(contract_bytes)
+        read(&full_dest).unwrap()
+    }
 }
 
-async fn clone_and_compile_wasm() -> anyhow::Result<Vec<u8>> {
+async fn clone_and_compile_wasm() -> Vec<u8> {
     let tmp_path = "../target/tmp-contracts";
     let repo_path = format!("{}/near-smartcontracts", tmp_path);
     let target_path = format!("{}/test-contract", repo_path);
@@ -77,14 +75,15 @@ async fn clone_and_compile_wasm() -> anyhow::Result<Vec<u8>> {
 
     if !Path::new(&target_path).exists() {
         if !Path::new(&tmp_path).exists() {
-            create_dir(tmp_path)?;
+            create_dir(tmp_path).unwrap();
         }
 
         // Prepare callbacks.
         let mut callbacks = RemoteCallbacks::new();
         callbacks.credentials(|_, username_from_url, _| {
             let username = username_from_url
-                .ok_or_else(|| git2::Error::from_str("Parsing the given URL is failed"))?;
+                .ok_or_else(|| git2::Error::from_str("Parsing the given URL is failed"))
+                .unwrap();
             Cred::ssh_key_from_agent(username)
         });
 
@@ -98,195 +97,235 @@ async fn clone_and_compile_wasm() -> anyhow::Result<Vec<u8>> {
         builder.branch("main");
 
         // Clone the project.
-        builder.clone(repo_url, Path::new(&repo_path))?;
+        builder.clone(repo_url, Path::new(&repo_path)).unwrap();
     }
-    let wasm = workspaces::compile_project(&target_path).await?;
 
-    Ok(wasm)
+    workspaces::compile_project(&target_path).await.unwrap()
 }
 
-fn random_bits() -> [u8; 32] {
+fn random_bits() -> [u8; ED25519_SECRET_KEY_LENGTH] {
     let mut chacha = ChaChaRng::from_entropy();
-    let mut secret_bytes = [0_u8; 32];
+    let mut secret_bytes = [0_u8; ED25519_SECRET_KEY_LENGTH];
     chacha.fill_bytes(&mut secret_bytes);
     secret_bytes
 }
 
-fn to_workspaces_sk(sk: &ED25519SecretKey) -> String {
-    let pk = ED25519PublicKey::from(sk);
-    let keypair = sk
-        .as_bytes()
-        .iter()
-        .chain(pk.as_bytes().iter())
-        .copied()
-        .collect_vec();
-    format!("ed25519:{}", bs58::encode(keypair).into_string())
-}
-
 // tests themselves
 #[tokio::test]
-async fn contract_creation() -> anyhow::Result<()> {
-    let worker = workspaces::sandbox().await?;
-    let client = near_client(&worker)?;
+async fn contract_creation() {
+    let worker = workspaces::sandbox().await.unwrap();
+    let client = near_client(&worker);
     let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let mut signer = create_signer(&worker, &client, &signer_account_id).await?;
-    let wasm = download_contract().await?;
+    let signer = create_signer(&worker, &client, &signer_account_id).await;
+    let wasm = download_contract().await;
 
     client
-        .deploy_contract(&mut signer, &signer_account_id, wasm)
-        .commit_empty()
-        .await?;
-
-    Ok(())
+        .deploy_contract(&signer, &signer_account_id, wasm)
+        .commit(Finality::Optimistic)
+        .await
+        .unwrap();
 }
 
 #[tokio::test]
-async fn contract_function_call() -> anyhow::Result<()> {
-    let worker = workspaces::sandbox().await?;
-    let client = near_client(&worker)?;
+async fn contract_function_call() {
+    let worker = workspaces::sandbox().await.unwrap();
+    let client = near_client(&worker);
     let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let mut signer = create_signer(&worker, &client, &signer_account_id).await?;
-    let wasm = download_contract().await?;
+    let signer = create_signer(&worker, &client, &signer_account_id).await;
+    let wasm = download_contract().await;
 
     client
-        .deploy_contract(&mut signer, &signer_account_id, wasm)
-        .commit_empty()
-        .await?;
+        .deploy_contract(&signer, &signer_account_id, wasm)
+        .commit(Finality::Optimistic)
+        .await
+        .unwrap();
 
     client
-        .function_call(&mut signer, &signer_account_id, "new_default_meta")
+        .function_call(&signer, &signer_account_id, "new_default_meta")
         .args(json!({
             "owner_id": &signer_account_id,
             "total_supply": "100",
         }))
         .gas(near_units::parse_gas!("300 T") as u64)
-        .build()?
-        .commit_empty()
-        .await?;
-
-    Ok(())
+        .build()
+        .unwrap()
+        .commit(Finality::Optimistic)
+        .await
+        .unwrap();
 }
 
 #[tokio::test]
-async fn multiple_tests() -> anyhow::Result<()> {
-    let worker = workspaces::sandbox().await?;
-    let client = near_client(&worker)?;
+async fn multiple_tests() {
+    let worker = workspaces::sandbox().await.unwrap();
+    let client = near_client(&worker);
     let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let mut signer = create_signer(&worker, &client, &signer_account_id).await?;
-
-    let wasm = clone_and_compile_wasm().await?;
-
-    init_contract(&client, &signer_account_id, &mut signer, wasm).await?;
+    let signer = create_signer(&worker, &client, &signer_account_id).await;
 
-    fc_no_params(&client, &signer_account_id, &mut signer).await?;
-    fc_with_one_param_and_result(&client, &signer_account_id, &mut signer).await?;
-    fc_with_param_and_result(&client, &signer_account_id, &mut signer).await?;
+    let wasm = clone_and_compile_wasm().await;
 
-    view_no_params(&client, &signer_account_id).await?;
-    view_with_params(&client, &signer_account_id).await?;
-
-    Ok(())
+    init_contract(&client, &signer_account_id, &signer, wasm).await;
+    fc_no_params(&client, &signer_account_id, &signer).await;
+    fc_with_one_param_and_result(&client, &signer_account_id, &signer).await;
+    fc_with_param_and_result(&client, &signer_account_id, &signer).await;
+    view_no_params(&client, &signer_account_id).await;
+    view_with_params(&client, &signer_account_id).await;
 }
 
 async fn init_contract(
     client: &NearClient,
     contract_id: &AccountId,
-    signer: &mut Signer,
+    signer: &Signer,
     wasm: Vec<u8>,
-) -> anyhow::Result<()> {
+) {
     client
         .deploy_contract(signer, contract_id, wasm)
-        .commit_empty()
-        .await?;
-
-    Ok(())
+        .commit(Finality::Optimistic)
+        .await
+        .unwrap();
 }
 
-async fn view_no_params(client: &NearClient, contract_id: &AccountId) -> anyhow::Result<()> {
-    client.view::<u64>(contract_id, "show_id", None).await?;
-
-    Ok(())
+async fn view_no_params(client: &NearClient, contract_id: &AccountId) {
+    client
+        .view::<u64>(contract_id, Finality::Optimistic, "show_id", None)
+        .await
+        .unwrap();
 }
 
-async fn view_with_params(client: &NearClient, contract_id: &AccountId) -> anyhow::Result<()> {
+async fn view_with_params(client: &NearClient, contract_id: &AccountId) {
     client
-        .view::<String>(contract_id, "show_type", Some(json!({"is_message": true})))
-        .await?;
-
-    Ok(())
+        .view::<String>(
+            contract_id,
+            Finality::Optimistic,
+            "show_type",
+            Some(json!({"is_message": true})),
+        )
+        .await
+        .unwrap();
 }
 
 // fc = function call
-async fn fc_no_params(
-    client: &NearClient,
-    contract_id: &AccountId,
-    signer: &mut Signer,
-) -> anyhow::Result<()> {
+async fn fc_no_params(client: &NearClient, contract_id: &AccountId, signer: &Signer) {
     client
         .function_call(signer, contract_id, "increment")
         .gas(near_units::parse_gas!("300 T") as u64)
-        .build()?
-        .commit_empty()
-        .await?;
-
-    Ok(())
+        .build()
+        .unwrap()
+        .commit(Finality::Optimistic)
+        .await
+        .unwrap();
 }
 
 async fn fc_with_one_param_and_result(
     client: &NearClient,
     contract_id: &AccountId,
-    signer: &mut Signer,
-) -> anyhow::Result<()> {
+    signer: &Signer,
+) {
     let expected_result = "change message";
     let message = client
         .function_call(signer, contract_id, "change_message")
         .args(json!({ "message": expected_result }))
         .gas(near_units::parse_gas!("300 T") as u64)
-        .build()?
-        .commit::<String>()
-        .await?;
+        .build()
+        .unwrap()
+        .commit(Finality::Final)
+        .await
+        .unwrap()
+        .output::<String>()
+        .unwrap();
 
     assert_eq!(message, expected_result);
-
-    Ok(())
 }
 
-async fn fc_with_param_and_result(
-    client: &NearClient,
-    contract_id: &AccountId,
-    signer: &mut Signer,
-) -> anyhow::Result<()> {
+async fn fc_with_param_and_result(client: &NearClient, contract_id: &AccountId, signer: &Signer) {
     let expected_id = 666u64;
     let id = client
         .function_call(signer, contract_id, "change_id")
         .args(json!({ "id": expected_id }))
         .gas(near_units::parse_gas!("300 T") as u64)
-        .build()?
-        .commit::<u64>()
-        .await?;
+        .build()
+        .unwrap()
+        .commit(Finality::Final)
+        .await
+        .unwrap()
+        .output::<u64>()
+        .unwrap();
 
     assert_eq!(id, expected_id);
+}
+
+#[tokio::test]
+async fn async_transaction() {
+    let worker = workspaces::sandbox().await.unwrap();
+    let client = near_client(&worker);
+    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
+    let signer = create_signer(&worker, &client, &signer_account_id).await;
+
+    let wasm = clone_and_compile_wasm().await;
+
+    client
+        .deploy_contract(&signer, &signer_account_id, wasm)
+        .commit(Finality::Optimistic)
+        .await
+        .unwrap();
+
+    let expected_result = "change message";
+    let transaction_id = client
+        .function_call(&signer, &signer_account_id, "change_message")
+        .args(json!({ "message": expected_result }))
+        .gas(near_units::parse_gas!("300 T") as u64)
+        .build()
+        .unwrap()
+        .commit_async(Finality::Final)
+        .await
+        .unwrap();
+
+    let (tx, rx) = tokio::sync::oneshot::channel::<()>();
+
+    tokio::spawn(async move {
+        tokio::time::timeout(std::time::Duration::from_secs(2), rx)
+            .await
+            .expect("Wait async transaction timeout")
+    });
+
+    loop {
+        let res = client.view_transaction(&transaction_id, &signer).await;
+
+        if let Err(near_client::Error::ViewTransaction(_)) = &res {
+            // try one more time
+            continue;
+        }
+
+        // cancel timeout
+        tx.send(()).unwrap();
+        let msg = res.unwrap().output::<String>().unwrap();
 
-    Ok(())
+        assert_eq!(msg, expected_result);
+        break;
+    }
 }
 
 #[tokio::test]
-async fn view_access_key_success() -> anyhow::Result<()> {
-    let worker = workspaces::sandbox().await?;
-    let client = near_client(&worker)?;
+async fn view_access_key_success() {
+    let worker = workspaces::sandbox().await.unwrap();
+    let client = near_client(&worker);
     let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let mut signer = create_signer(&worker, &client, &signer_account_id).await?;
+    let signer = create_signer(&worker, &client, &signer_account_id).await;
 
-    let new_acc = AccountId::from_str("one.alice.test.near")?;
-    let secret_key = ED25519SecretKey::from_bytes(&random_bits())?;
-    let pk = ED25519PublicKey::from(&secret_key);
+    let new_acc = AccountId::from_str("one.alice.test.near").unwrap();
+    let secret_key = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let pk = Ed25519PublicKey::from(&secret_key);
 
     let _ = client
-        .create_account(&mut signer, &new_acc, pk, near_units::parse_near!("3 N"))
-        .commit::<serde_json::Value>()
-        .await?;
+        .create_account(&signer, &new_acc, pk, near_units::parse_near!("3 N"))
+        .commit(Finality::Optimistic)
+        .await
+        .unwrap()
+        .output::<serde_json::Value>();
 
-    let access_key = client.view_access_key(&new_acc, &pk).await?;
+    let access_key = client
+        .view_access_key(&new_acc, &pk, Finality::Optimistic)
+        .await
+        .unwrap();
     assert!(matches!(
         access_key,
         ViewAccessKey {
@@ -294,20 +333,21 @@ async fn view_access_key_success() -> anyhow::Result<()> {
             ..
         }
     ));
-
-    Ok(())
 }
 
 #[tokio::test]
-async fn view_access_key_failure() -> anyhow::Result<()> {
-    let worker = workspaces::sandbox().await?;
-    let client = near_client(&worker)?;
+async fn view_access_key_failure() {
+    let worker = workspaces::sandbox().await.unwrap();
+    let client = near_client(&worker);
 
-    let new_acc = AccountId::from_str("one.alice.test.near")?;
-    let secret_key = ED25519SecretKey::from_bytes(&random_bits())?;
-    let pk = ED25519PublicKey::from(&secret_key);
+    let new_acc = AccountId::from_str("one.alice.test.near").unwrap();
+    let secret_key = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let pk = Ed25519PublicKey::from(&secret_key);
 
-    let access_key = client.view_access_key(&new_acc, &pk).await?;
+    let access_key = client
+        .view_access_key(&new_acc, &pk, Finality::Optimistic)
+        .await
+        .unwrap();
     assert!(matches!(
         access_key,
         ViewAccessKey {
@@ -315,27 +355,30 @@ async fn view_access_key_failure() -> anyhow::Result<()> {
             ..
         }
     ));
-
-    Ok(())
 }
 
 #[tokio::test]
-async fn create_account() -> anyhow::Result<()> {
-    let worker = workspaces::sandbox().await?;
-    let client = near_client(&worker)?;
+async fn create_account() {
+    let worker = workspaces::sandbox().await.unwrap();
+    let client = near_client(&worker);
     let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let mut signer = create_signer(&worker, &client, &signer_account_id).await?;
+    let signer = create_signer(&worker, &client, &signer_account_id).await;
 
-    let new_acc = AccountId::from_str("one.alice.test.near")?;
-    let secret_key = ED25519SecretKey::from_bytes(&random_bits())?;
-    let pk = ED25519PublicKey::from(&secret_key);
+    let new_acc = AccountId::from_str("one.alice.test.near").unwrap();
+    let secret_key = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let pk = Ed25519PublicKey::from(&secret_key);
 
     let _ = client
-        .create_account(&mut signer, &new_acc, pk, near_units::parse_near!("3 N"))
-        .commit::<serde_json::Value>()
-        .await?;
+        .create_account(&signer, &new_acc, pk, near_units::parse_near!("3 N"))
+        .commit(Finality::Final)
+        .await
+        .unwrap()
+        .output::<serde_json::Value>();
 
-    let access_key = client.view_access_key(&new_acc, &pk).await?;
+    let access_key = client
+        .view_access_key(&new_acc, &pk, Finality::Optimistic)
+        .await
+        .unwrap();
     assert!(matches!(
         access_key,
         ViewAccessKey {
@@ -343,27 +386,29 @@ async fn create_account() -> anyhow::Result<()> {
             ..
         }
     ));
-
-    Ok(())
 }
 
 #[tokio::test]
-async fn delete_account() -> anyhow::Result<()> {
-    let worker = workspaces::sandbox().await?;
-    let client = near_client(&worker)?;
+async fn delete_account() {
+    let worker = workspaces::sandbox().await.unwrap();
+    let client = near_client(&worker);
     let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let mut signer = create_signer(&worker, &client, &signer_account_id).await?;
+    let signer = create_signer(&worker, &client, &signer_account_id).await;
 
-    let new_acc = AccountId::from_str("one.alice.test.near")?;
-    let secret_key = ED25519SecretKey::from_bytes(&random_bits())?;
-    let pk = ED25519PublicKey::from(&secret_key);
+    let new_acc = AccountId::from_str("one.alice.test.near").unwrap();
+    let secret_key = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let pk = Ed25519PublicKey::from(&secret_key);
 
     client
-        .create_account(&mut signer, &new_acc, pk, near_units::parse_near!("3 N"))
-        .commit_empty()
-        .await?;
+        .create_account(&signer, &new_acc, pk, near_units::parse_near!("3 N"))
+        .commit(Finality::Final)
+        .await
+        .unwrap();
 
-    let access_key = client.view_access_key(&new_acc, &pk).await?;
+    let access_key = client
+        .view_access_key(&new_acc, &pk, Finality::Optimistic)
+        .await
+        .unwrap();
 
     let nonce = if let ViewAccessKey {
         result: ViewAccessKeyResult::Ok { nonce, .. },
@@ -375,13 +420,18 @@ async fn delete_account() -> anyhow::Result<()> {
         panic!("Can't view access key for just created account")
     };
 
-    let mut acc_signer = Signer::new(&secret_key.to_string(), new_acc.clone(), nonce)?;
+    let acc_signer = Signer::from_secret(secret_key, new_acc.clone(), nonce);
+
     client
-        .delete_account(&mut acc_signer, &new_acc, &signer_account_id)
-        .commit_empty()
-        .await?;
+        .delete_account(&acc_signer, &new_acc, &signer_account_id)
+        .commit(Finality::Final)
+        .await
+        .unwrap();
 
-    let access_key = client.view_access_key(&new_acc, &pk).await?;
+    let access_key = client
+        .view_access_key(&new_acc, &pk, Finality::Optimistic)
+        .await
+        .unwrap();
     assert!(matches!(
         access_key,
         ViewAccessKey {
@@ -389,6 +439,4 @@ async fn delete_account() -> anyhow::Result<()> {
             ..
         }
     ));
-
-    Ok(())
 }

web-client/src/errors.rs

@@ -38,68 +38,15 @@ impl From<JsValue> for ApiError {
 #[wasm_bindgen]
 #[derive(Clone, Copy, Debug)]
 pub enum ErrorType {
-    Type,
-    Rpc,
-    EmptyBlock,
-    ArgsSerialize,
-    DeserializeTxResp,
-    TransactionSerialize,
-    TransactionExec,
-    TxNotStarted,
-    NoSigner,
-    ParseRpcUrl,
-    BadContractId,
+    NearClient,
     Other,
 }
 
 impl From<Error> for ApiError {
     fn from(error: Error) -> Self {
-        match error {
-            Error::Type(type_err) => Self {
-                r#type: ErrorType::Type,
-                msg: type_err.to_string(),
-            },
-            Error::Rpc { error, method } => Self {
-                r#type: ErrorType::Rpc,
-                msg: format!("Method: [\"{method}\"], Cause: \"{error}\""),
-            },
-            Error::EmptyBlock => Self {
-                r#type: ErrorType::EmptyBlock,
-                msg: error.to_string(),
-            },
-            Error::ArgsSerialize(err) => Self {
-                r#type: ErrorType::ArgsSerialize,
-                msg: err.to_string(),
-            },
-            Error::DeserializeTxResp(err) => Self {
-                r#type: ErrorType::DeserializeTxResp,
-                msg: err.to_string(),
-            },
-            Error::TransactionSerialize(err) => Self {
-                r#type: ErrorType::TransactionSerialize,
-                msg: err.to_string(),
-            },
-            Error::TransactionExec(err) => Self {
-                r#type: ErrorType::TransactionExec,
-                msg: format!("{err:?}"),
-            },
-            Error::TxNotStarted => Self {
-                r#type: ErrorType::TxNotStarted,
-                msg: error.to_string(),
-            },
-            Error::NoSigner => Self {
-                r#type: ErrorType::NoSigner,
-                msg: error.to_string(),
-            },
-        }
-    }
-}
-
-impl From<near_client::types::Error> for ApiError {
-    fn from(err: near_client::types::Error) -> Self {
-        Self {
-            r#type: ErrorType::Type,
-            msg: err.to_string(),
+        ApiError {
+            r#type: ErrorType::NearClient,
+            msg: error.to_string(),
         }
     }
 }
@@ -107,7 +54,7 @@ impl From<near_client::types::Error> for ApiError {
 impl From<ParseAccountError> for ApiError {
     fn from(err: ParseAccountError) -> Self {
         Self::new(
-            ErrorType::BadContractId,
+            ErrorType::NearClient,
             format!("AccountId has wrong format. Cause: {err}"),
         )
     }

web-client/src/lib.rs

@@ -9,7 +9,7 @@ use rand::{RngCore, SeedableRng};
 use serde_json::json;
 use wasm_bindgen::prelude::*;
 
-use near_client::client::{NearClient, Signer};
+use near_client::client::{Finality, NearClient, Signer};
 
 use js_sys::Promise;
 use near_primitives::types::Nonce;
@@ -65,9 +65,9 @@ impl ProvisionerConfig {
         exchange_url: &str,
     ) -> Result<ProvisionerConfig> {
         let rpc_url = url::Url::from_str(rpc_url)
-            .map_err(|err| ApiError::new(ErrorType::ParseRpcUrl, err.to_string()))?;
+            .map_err(|err| ApiError::new(ErrorType::NearClient, err.to_string()))?;
         let key_exchange_url = url::Url::from_str(exchange_url)
-            .map_err(|err| ApiError::new(ErrorType::ParseRpcUrl, err.to_string()))?;
+            .map_err(|err| ApiError::new(ErrorType::NearClient, err.to_string()))?;
         let contract_id = AccountId::from_str(&contract_id).map_err(Into::<ApiError>::into)?;
 
         Ok(Self {
@@ -111,7 +111,7 @@ impl KeyProvisioner {
     ) -> Result<KeyProvisioner> {
         let client = Arc::new(NearClient::new(config.rpc_url).map_err(ApiError::from)?);
         let signer = Arc::new(Mutex::new(
-            Signer::new(
+            Signer::from_secret_str(
                 &keypair_str,
                 AccountId::from_str(&account_id).map_err(Into::<ApiError>::into)?,
                 nonce,
@@ -178,7 +178,7 @@ impl KeyProvisioner {
                 }))
                 .build()
                 .map_err(ApiError::from)?
-                .commit::<()>()
+                .commit(Finality::Final)
                 .await
                 .map_err(ApiError::from)?;
 
@@ -210,6 +210,7 @@ impl KeyProvisioner {
                             let resp = client_cp
                                 .view::<Option<String>>(
                                     &contract_cp,
+                                    Finality::Optimistic,
                                     "public_key",
                                     Some(json!({
                                         "id": meeting_id_cp,
@@ -324,6 +325,7 @@ impl KeyProvisioner {
                 let owner_pub_key = client
                     .view::<Option<String>>(
                         &contract_id,
+                        Finality::Optimistic,
                         "owner_key",
                         Some(serde_json::json!({
                             "id": meeting_id.to_string()
@@ -370,7 +372,7 @@ impl KeyProvisioner {
                 }))
                 .build()
                 .map_err(|err| ApiError::new(ErrorType::Other, err.to_string()))?
-                .commit::<()>()
+                .commit(Finality::Optimistic)
                 .await
                 .map_err(|err| ApiError::new(ErrorType::Other, err.to_string()))?;
 

web-client/tests/integration.rs

@@ -1,7 +1,5 @@
-use near_client::{
-    client::{NearClient, Signer},
-    types::crypto::*,
-};
+use common_api::crypto::prelude::*;
+use near_client::client::{Finality, NearClient, Signer};
 use near_primitives::{account::id::AccountId, types::Balance};
 use rand::{RngCore, SeedableRng};
 use rand_chacha::ChaChaRng;
@@ -19,7 +17,7 @@ wasm_bindgen_test_configure!(run_in_browser);
 #[derive(Serialize, Deserialize)]
 struct ValidatorKey {
     account_id: AccountId,
-    public_key: ED25519PublicKey,
+    public_key: Ed25519PublicKey,
     secret_key: String,
 }
 
@@ -32,41 +30,46 @@ fn random_bits() -> [u8; 32] {
 
 async fn create_account(
     client: &NearClient,
-    validator: &mut Signer,
+    validator: &Signer,
     account_id_str: &str,
     amount: Balance,
 ) -> anyhow::Result<Signer> {
     let id = AccountId::from_str(account_id_str)?;
-    let sk = ED25519SecretKey::from_bytes(&random_bits())?;
-    let pk = ED25519PublicKey::from(&sk);
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+    let pk = Ed25519PublicKey::from(&sk);
 
     client
         .create_account(validator, &id, pk, amount)
-        .commit_empty()
+        .commit(Finality::Final)
         .await?;
 
-    let nonce = Result::from(client.view_access_key(&id, &pk).await.unwrap())
-        .map_err(|err| anyhow::anyhow!(err))?;
+    let nonce = Result::from(
+        client
+            .view_access_key(&id, &pk, Finality::Optimistic)
+            .await
+            .unwrap(),
+    )
+    .map_err(|err| anyhow::anyhow!(err))?;
 
-    Ok(Signer::new_v1(&sk, id, nonce)?)
+    Ok(Signer::from_secret(sk, id, nonce))
 }
 
 async fn delete_account(
     client: &NearClient,
-    signer: &mut Signer,
+    signer: &Signer,
     beneficiary_acc_id: &AccountId,
 ) -> anyhow::Result<()> {
     let id = signer.account().clone();
     let pk = signer.public_key();
 
-    let nonce = Result::from(client.view_access_key(&id, &pk).await?)
+    let nonce = Result::from(client.view_access_key(&id, pk, Finality::Final).await?)
         .map_err(|err| anyhow::anyhow!(err))?;
 
-    signer.key_nonce = nonce;
+    signer.update_nonce(nonce);
 
     client
         .delete_account(signer, &id, beneficiary_acc_id)
-        .commit_empty()
+        .commit(Finality::Final)
         .await?;
     Ok(())
 }
@@ -86,12 +89,16 @@ async fn validator_account(
 ) -> anyhow::Result<Signer> {
     let key_nonce = Result::from(
         client
-            .view_access_key(&validator_key.account_id, &validator_key.public_key)
+            .view_access_key(
+                &validator_key.account_id,
+                &validator_key.public_key,
+                Finality::Final,
+            )
             .await?,
     )
     .map_err(|err| anyhow::anyhow!(err))?;
 
-    let signer = Signer::new(
+    let signer = Signer::from_secret_str(
         &validator_key.secret_key,
         validator_key.account_id.clone(),
         key_nonce,
@@ -121,40 +128,40 @@ async fn key_exchange() {
     let client = NearClient::new(rpc_url).unwrap();
 
     let validator_key = validator_key().await.unwrap();
-    let mut validator = validator_account(&client, validator_key).await.unwrap();
+    let validator = validator_account(&client, validator_key).await.unwrap();
 
     // create account for key-exchange
     // Alice is an initiator account
-    let mut alice_sg = create_account(
+    let alice_sg = create_account(
         &client,
-        &mut validator,
+        &validator,
         "alice.test.near",
         near_units::near::parse("10 N").unwrap(),
     )
     .await
     .unwrap();
 
-    let mut bob_sg = create_account(
+    let bob_sg = create_account(
         &client,
-        &mut validator,
+        &validator,
         "bob.test.near",
         near_units::near::parse("10 N").unwrap(),
     )
     .await
     .unwrap();
 
-    let mut karl_sg = create_account(
+    let karl_sg = create_account(
         &client,
-        &mut validator,
+        &validator,
         "karl.test.near",
         near_units::near::parse("10 N").unwrap(),
     )
     .await
     .unwrap();
 
-    let mut mike_sg = create_account(
+    let mike_sg = create_account(
         &client,
-        &mut validator,
+        &validator,
         "mike.test.near",
         near_units::near::parse("10 N").unwrap(),
     )
@@ -162,9 +169,9 @@ async fn key_exchange() {
     .unwrap();
 
     // Create an contract account
-    let mut contract_sg = create_account(
+    let contract_sg = create_account(
         &client,
-        &mut validator,
+        &validator,
         "contract.test.near",
         near_units::near::parse("200 N").unwrap(),
     )
@@ -176,8 +183,8 @@ async fn key_exchange() {
     let contract_id = contract_sg.account().clone();
 
     client
-        .deploy_contract(&mut contract_sg, &contract_id, contract_wasm)
-        .commit_empty()
+        .deploy_contract(&contract_sg, &contract_id, contract_wasm)
+        .commit(Finality::Final)
         .await
         .unwrap();
 
@@ -190,7 +197,7 @@ async fn key_exchange() {
     .unwrap();
 
     // Create provisioners for each user
-    let keypair_str = alice_sg.secret_key().to_string();
+    let keypair_str = alice_sg.secret_key().string();
     let provisioner = KeyProvisioner::new(
         keypair_str,
         alice_sg.nonce(),
@@ -220,7 +227,7 @@ async fn key_exchange() {
         .unwrap();
 
     // Then each user push own key to blockchain
-    let keypair_str = bob_sg.secret_key().to_string();
+    let keypair_str = bob_sg.secret_key().string();
     let provisioner_bob = KeyProvisioner::new(
         keypair_str,
         bob_sg.nonce(),
@@ -233,7 +240,7 @@ async fn key_exchange() {
         .await
         .unwrap();
 
-    let keypair_str = karl_sg.secret_key().to_string();
+    let keypair_str = karl_sg.secret_key().string();
     let provisioner_karl = KeyProvisioner::new(
         keypair_str,
         karl_sg.nonce(),
@@ -246,7 +253,7 @@ async fn key_exchange() {
         .await
         .unwrap();
 
-    let keypair_str = mike_sg.secret_key().to_string();
+    let keypair_str = mike_sg.secret_key().string();
     let provisioner_mike = KeyProvisioner::new(
         keypair_str,
         mike_sg.nonce(),
@@ -290,19 +297,19 @@ async fn key_exchange() {
         .all(|key| key == alice_key));
 
     // delete all accounts
-    delete_account(&client, &mut contract_sg, validator.account())
+    delete_account(&client, &contract_sg, validator.account())
         .await
         .unwrap();
-    delete_account(&client, &mut alice_sg, validator.account())
+    delete_account(&client, &alice_sg, validator.account())
         .await
         .unwrap();
-    delete_account(&client, &mut bob_sg, validator.account())
+    delete_account(&client, &bob_sg, validator.account())
         .await
         .unwrap();
-    delete_account(&client, &mut karl_sg, validator.account())
+    delete_account(&client, &karl_sg, validator.account())
         .await
         .unwrap();
-    delete_account(&client, &mut mike_sg, validator.account())
+    delete_account(&client, &mike_sg, validator.account())
         .await
         .unwrap();
 }