Add new API `create_account` and `delete_account`

	Also, update an access key representation.
	Added an error option for it.

near-client/src/client.rs

 use near_primitives::{
-    account::id::AccountId,
+    account::{id::AccountId, AccessKey, AccessKeyPermission},
     hash::CryptoHash,
     types::{Balance, Gas, Nonce},
 };
 use crate::{
     rpc::client::RpcClient,
     types::{
-        crypto::{ED25519PublicKey, ED25519Signature, Keypair},
+        crypto::{ED25519PublicKey, ED25519SecretKey, ED25519Signature, Key, Keypair},
         near::{
-            Action, Chunks, DeployContractAction, FinalExecutionOutcomeView, FinalExecutionStatus,
-            FunctionCallAction, SignedTransaction, Transaction, ViewAccessKeyResult, ViewResult,
+            Action, AddKeyAction, Chunks, CreateAccountAction, DeleteAccountAction,
+            DeployContractAction, FinalExecutionOutcomeView, FinalExecutionStatus,
+            FunctionCallAction, SignedTransaction, Transaction, TransferAction, ViewAccessKey,
+            ViewResult,
         },
     },
     Error,
 pub struct Signer {
     keypair: Keypair,
     signer_acc: AccountId,
-    key_nonce: Nonce,
+    pub key_nonce: Nonce,
 }
 
 impl Signer {
         })
     }
 
+    // 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 sign(&self, data: &[u8]) -> ED25519Signature {
         self.keypair.sign(data)
     }
         self.keypair.public_key
     }
 
+    pub fn secret_key(&self) -> &ED25519SecretKey {
+        &self.keypair.secret_key
+    }
+
     pub fn account(&self) -> &AccountId {
         &self.signer_acc
     }
         &'a self,
         account_id: &'a AccountId,
         public_key: &'a ED25519PublicKey,
-    ) -> Result<ViewAccessKeyResult> {
+    ) -> Result<ViewAccessKey> {
         let result = self
             .rpc_client
-            .request::<ViewAccessKeyResult>(
+            .request::<ViewAccessKey>(
                 "query",
                 Some(json!({
                     "request_type": "view_access_key",
 
         Call {
             transaction_info,
-            action: Action::from(DeployContractAction { code: wasm }),
+            actions: vec![Action::from(DeployContractAction { code: wasm })],
+        }
+    }
+
+    pub fn create_account<'a>(
+        &'a self,
+        signer: &'a mut Signer,
+        new_account_id: &'a AccountId,
+        new_account_pk: ED25519PublicKey,
+        amount: Balance,
+    ) -> Call {
+        let transaction_info = TransactionInfo::new(self, signer, new_account_id);
+        let actions = vec![
+            CreateAccountAction {}.into(),
+            AddKeyAction {
+                public_key: new_account_pk,
+                access_key: AccessKey {
+                    nonce: 0,
+                    permission: AccessKeyPermission::FullAccess,
+                },
+            }
+            .into(),
+            TransferAction { deposit: amount }.into(),
+        ];
+
+        Call {
+            transaction_info,
+            actions,
+        }
+    }
+
+    pub fn delete_account<'a>(
+        &'a self,
+        signer: &'a mut Signer,
+        account_id: &'a AccountId,
+        beneficiary_acc_id: &'a AccountId,
+    ) -> Call {
+        let transaction_info = TransactionInfo::new(self, signer, account_id);
+        let actions = vec![DeleteAccountAction {
+            beneficiary_id: beneficiary_acc_id.clone(),
+        }
+        .into()];
+
+        Call {
+            transaction_info,
+            actions,
         }
     }
 }
 
 pub struct Call<'a> {
     transaction_info: TransactionInfo<'a>,
-    action: Action,
+    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.action).await?;
+        let transaction_bytes = serialize_transaction(&self.transaction_info, self.actions).await?;
 
         let execution_outcome = self
             .transaction_info
     }
 
     pub async fn commit_empty(self) -> Result<()> {
-        let transaction_bytes = serialize_transaction(&self.transaction_info, self.action).await?;
+        let transaction_bytes = serialize_transaction(&self.transaction_info, self.actions).await?;
         let execution_outcome = self
             .transaction_info
             .client
     }
 
     pub async fn commit_async(self) -> Result<String> {
-        let transaction_bytes = serialize_transaction(&self.transaction_info, self.action).await?;
+        let transaction_bytes = serialize_transaction(&self.transaction_info, self.actions).await?;
         self.transaction_info
             .client
             .rpc_client
 
 async fn serialize_transaction<'a>(
     transaction_info: &'a TransactionInfo<'_>,
-    action: Action,
+    actions: Vec<Action>,
 ) -> Result<Vec<u8>> {
     let block_hash = transaction_info.client.block().await?;
 
         nonce: transaction_info.signer.nonce() + 1,
         receiver_id: transaction_info.contract_id.clone(),
         block_hash,
-        actions: vec![action],
+        actions,
     };
 
     let signed_transaction = sign_transaction(transaction_info.signer, transaction);
 
         Ok(Call {
             transaction_info: self.transaction_info,
-            action,
+            actions: vec![action],
         })
     }
 }

near-client/src/types/near.rs

 use near_account_id::AccountId;
 
 use near_primitives::{
-    account::AccessKey,
+    account::{AccessKey, AccessKeyPermission},
     hash::{hash, CryptoHash},
     logging,
     serialize::{base64_format, u128_dec_format_compatible},
-    types::{Balance, Gas, Nonce},
+    types::{Balance, BlockHeight, Gas, Nonce},
+};
+use serde::{
+    de::{self, Visitor},
+    Deserialize, Serialize,
 };
-use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::{
     borrow::Borrow,
     pub logs: Vec<String>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ViewAccessKeyResult {
-    pub nonce: u64,
+#[derive(Debug, Clone)]
+pub struct ViewAccessKey {
+    pub block_hash: CryptoHash,
+    pub block_height: BlockHeight,
+    pub result: ViewAccessKeyResult,
+}
+
+#[derive(Debug, Clone)]
+pub enum ViewAccessKeyResult {
+    Ok {
+        nonce: Nonce,
+        permission: AccessKeyPermissionView,
+    },
+    Err {
+        error: String,
+        logs: Vec<String>,
+    },
+}
+
+impl From<ViewAccessKey> for Result<Nonce, String> {
+    fn from(view: ViewAccessKey) -> Self {
+        match view.result {
+            ViewAccessKeyResult::Ok { nonce, .. } => Ok(nonce),
+            ViewAccessKeyResult::Err { error, .. } => Err(error),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ViewAccessKey {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visit;
+
+        impl<'de> Visitor<'de> for Visit {
+            type Value = ViewAccessKey;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                write!(formatter, "Expecting an key-value map")
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                let block_hash = map
+                    .next_entry::<String, CryptoHash>()?
+                    .ok_or_else(|| de::Error::missing_field("block_hash"))
+                    .and_then(|(key, block_hash)| {
+                        if key != "block_hash" {
+                            Err(serde::de::Error::unknown_field(&key, &["block_hash"]))
+                        } else {
+                            Ok(block_hash)
+                        }
+                    })?;
+
+                let block_height = map
+                    .next_entry::<String, BlockHeight>()?
+                    .ok_or_else(|| de::Error::missing_field("block_height"))
+                    .and_then(|(key, block_hash)| {
+                        if key != "block_height" {
+                            Err(serde::de::Error::unknown_field(&key, &["block_height"]))
+                        } else {
+                            Ok(block_hash)
+                        }
+                    })?;
+
+                let next_key = map.next_key::<String>()?;
+
+                match next_key.as_deref() {
+                    Some("nonce") => {
+                        let nonce = map.next_value::<Nonce>()?;
+                        let permission = map
+                            .next_entry::<String, AccessKeyPermissionView>()?
+                            .ok_or_else(|| de::Error::missing_field("permission"))
+                            .and_then(|(key, permission)| {
+                                if key != "permission" {
+                                    Err(serde::de::Error::unknown_field(&key, &["permission"]))
+                                } else {
+                                    Ok(permission)
+                                }
+                            })?;
+
+                        Ok(ViewAccessKey {
+                            block_hash,
+                            block_height,
+                            result: ViewAccessKeyResult::Ok { nonce, permission },
+                        })
+                    }
+                    Some("error") => {
+                        let error = map.next_value::<String>()?;
+                        let logs = map
+                            .next_entry::<String, Vec<String>>()?
+                            .ok_or_else(|| serde::de::Error::missing_field("logs"))
+                            .and_then(|(key, logs)| {
+                                if key != "logs" {
+                                    Err(serde::de::Error::unknown_field(&key, &["logs"]))
+                                } else {
+                                    Ok(logs)
+                                }
+                            })?;
+
+                        Ok(ViewAccessKey {
+                            block_hash,
+                            block_height,
+                            result: ViewAccessKeyResult::Err { error, logs },
+                        })
+                    }
+                    Some(field) => Err(serde::de::Error::unknown_field(field, &["nonce", "error"])),
+                    None => Err(serde::de::Error::missing_field("nonce or error")),
+                }
+            }
+        }
+
+        deserializer.deserialize_map(Visit)
+    }
 }

near-client/tests/rpc.rs

 use git2::{Cred, RemoteCallbacks};
 use itertools::Itertools;
-use near_account_id::AccountId;
 use near_client::{
     client::{NearClient, Signer},
-    types::crypto::{ED25519PublicKey, ED25519SecretKey, Key},
+    types::{
+        crypto::{ED25519PublicKey, ED25519SecretKey, Key},
+        near::{ViewAccessKey, ViewAccessKeyResult},
+    },
 };
 use rand::{RngCore, SeedableRng};
 use rand_chacha::ChaChaRng;
     path::Path,
     str::FromStr,
 };
-use workspaces::{network::Sandbox, types::SecretKey, Worker};
+use workspaces::{network::Sandbox, types::SecretKey, AccountId, Worker};
 
 // auxiliary structs and methods
 fn near_client(worker: &Worker<Sandbox>) -> anyhow::Result<NearClient> {
     let ws_sk = SecretKey::from_str(&ws_secret_key_str)?;
     let _ = worker.create_tla(signer_acc_id.clone(), ws_sk).await?;
 
-    let access_key_nonce = client.view_access_key(signer_acc_id, &pk).await?.nonce;
-
-    let signer_acc = Signer::new(&ws_secret_key_str, signer_acc_id.clone(), access_key_nonce)?;
-
-    Ok(signer_acc)
+    client
+        .view_access_key(signer_acc_id, &pk)
+        .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)),
+        })?
 }
 
 async fn download_contract() -> anyhow::Result<Vec<u8>> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn view_access_key_success() -> anyhow::Result<()> {
+    let worker = workspaces::sandbox().await?;
+    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 new_acc = AccountId::from_str("one.alice.test.near")?;
+    let secret_key = ED25519SecretKey::from_bytes(&random_bits())?;
+    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?;
+
+    let access_key = client.view_access_key(&new_acc, &pk).await?;
+    assert!(matches!(
+        access_key,
+        ViewAccessKey {
+            result: ViewAccessKeyResult::Ok { .. },
+            ..
+        }
+    ));
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn view_access_key_failure() -> anyhow::Result<()> {
+    let worker = workspaces::sandbox().await?;
+    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 access_key = client.view_access_key(&new_acc, &pk).await?;
+    assert!(matches!(
+        access_key,
+        ViewAccessKey {
+            result: ViewAccessKeyResult::Err { .. },
+            ..
+        }
+    ));
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn create_account() -> anyhow::Result<()> {
+    let worker = workspaces::sandbox().await?;
+    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 new_acc = AccountId::from_str("one.alice.test.near")?;
+    let secret_key = ED25519SecretKey::from_bytes(&random_bits())?;
+    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?;
+
+    let access_key = client.view_access_key(&new_acc, &pk).await?;
+    assert!(matches!(
+        access_key,
+        ViewAccessKey {
+            result: ViewAccessKeyResult::Ok { .. },
+            ..
+        }
+    ));
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn delete_account() -> anyhow::Result<()> {
+    let worker = workspaces::sandbox().await?;
+    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 new_acc = AccountId::from_str("one.alice.test.near")?;
+    let secret_key = ED25519SecretKey::from_bytes(&random_bits())?;
+    let pk = ED25519PublicKey::from(&secret_key);
+
+    client
+        .create_account(&mut signer, &new_acc, pk, near_units::parse_near!("3 N"))
+        .commit_empty()
+        .await?;
+
+    let access_key = client.view_access_key(&new_acc, &pk).await?;
+
+    let nonce = if let ViewAccessKey {
+        result: ViewAccessKeyResult::Ok { nonce, .. },
+        ..
+    } = access_key
+    {
+        nonce
+    } else {
+        panic!("Can't view access key for just created account")
+    };
+
+    let mut acc_signer = Signer::new(&secret_key.to_string(), new_acc.clone(), nonce)?;
+    client
+        .delete_account(&mut acc_signer, &new_acc, &signer_account_id)
+        .commit_empty()
+        .await?;
+
+    let access_key = client.view_access_key(&new_acc, &pk).await?;
+    assert!(matches!(
+        access_key,
+        ViewAccessKey {
+            result: ViewAccessKeyResult::Err { .. },
+            ..
+        }
+    ));
+
+    Ok(())
+}