Merge pull request #33 from Relayz-io/kyrylo/implement-tests-for-rpc

We've implemented the initial design for integration tests, using reqwest as a .wasm getter

near-client/Cargo.toml

 name = "near-client"
 version = "0.1.0"
 edition = "2021"
-authors = ["silvestr@relayz.io"]
+authors = ["silvestr@relayz.io", "kyrylo@relayz.io"]
 description = """
 """
 
 serde_json = { version = "1", default-features = false }
 thiserror = "1"
 url = "2"
+
+[dev-dependencies]
+anyhow = "1"
+reqwest = { version = "0.11", features = ["json"] }
+rand = "0.8.5"
+rand_chacha = "0.3"
+tokio = { version = "1.2.1", features = ["full"] }
+workspaces = { version = "0.5", features = ["unstable"] }

near-client/src/client.rs

         crypto::{ED25519PublicKey, ED25519Signature, Keypair},
         near::{
             Action, Chunks, DeployContractAction, FinalExecutionOutcomeView, FinalExecutionStatus,
-            FunctionCallAction, SignedTransaction, Transaction, ViewResult,
+            FunctionCallAction, SignedTransaction, Transaction, ViewAccessKeyResult, ViewResult,
         },
     },
     Error,
         serde_json::from_slice(&view_result.result).map_err(Error::DeserializeTxResp)
     }
 
+    pub async fn view_access_key<'a>(
+        &'a self,
+        account_id: &'a AccountId,
+        public_key: &'a ED25519PublicKey,
+    ) -> Result<ViewAccessKeyResult> {
+        let result = self
+            .rpc_client
+            .request::<ViewAccessKeyResult>(
+                "query",
+                Some(json!({
+                    "request_type": "view_access_key",
+                    "finality": "optimistic",
+                    "account_id": account_id,
+                    "public_key": public_key,
+                })),
+            )
+            .await
+            .map_err(|error| Error::Rpc {
+                error,
+                method: "query",
+            })?;
+
+        Ok(result)
+    }
+
     pub fn function_call<'a>(
         &'a self,
         signer: &'a mut Signer,
         match execution_outcome.status {
             FinalExecutionStatus::Failure(err) => Err(Error::TransactionExec(err)),
             FinalExecutionStatus::SuccessValue(mut data) => {
-                self.transaction_info.signer.key_nonce += 1;
+                let nonce = execution_outcome.transaction.nonce;
+                self.transaction_info.signer.key_nonce = nonce;
                 if data.is_empty() {
                     data = serde_json::to_vec(&()).unwrap();
                 }
         }
     }
 
+    pub async fn commit_empty(self) -> Result<()> {
+        let transaction_bytes = serialize_transaction(&self.transaction_info, self.action).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.action).await?;
         self.transaction_info

near-client/src/types/near.rs

     pub result: Vec<u8>,
     pub logs: Vec<String>,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ViewAccessKeyResult {
+    pub nonce: u64,
+}

near-client/tests/rpc.rs

+use itertools::Itertools;
+use near_account_id::AccountId;
+use near_client::{
+    client::{NearClient, Signer},
+    types::crypto::{ED25519PublicKey, ED25519SecretKey, Key},
+};
+use rand::{RngCore, SeedableRng};
+use rand_chacha::ChaChaRng;
+use reqwest::Url;
+use serde_json::json;
+use std::{
+    fs::{create_dir, File},
+    io::{copy, Cursor, Read},
+    path::Path,
+    str::FromStr,
+};
+use workspaces::{network::Sandbox, types::SecretKey, Worker};
+
+// auxiliary structs and methods
+struct InitMeta {
+    worker: Worker<Sandbox>,
+    client: NearClient,
+    wasm: Vec<u8>,
+    signer_account_id: AccountId,
+}
+
+impl InitMeta {
+    async fn new() -> anyhow::Result<Self> {
+        let worker = workspaces::sandbox().await?;
+        let wasm = download_contract().await?;
+        let rpc_url = Url::parse(format!("http://localhost:{}", worker.rpc_port()).as_str())?;
+        let client = NearClient::new(rpc_url)?;
+        let signer_account_id = AccountId::from_str("alice.test.near")?;
+
+        Ok(InitMeta {
+            worker,
+            client,
+            wasm,
+            signer_account_id,
+        })
+    }
+}
+
+async fn create_signer(meta: &InitMeta) -> 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 _ = meta
+        .worker
+        .create_tla(meta.signer_account_id.clone(), ws_sk)
+        .await?;
+
+    let access_key_nonce = meta
+        .client
+        .view_access_key(&meta.signer_account_id, &pk)
+        .await?
+        .nonce;
+
+    let signer_acc = Signer::new(
+        &ws_secret_key_str,
+        meta.signer_account_id.clone(),
+        access_key_nonce,
+    )?;
+
+    Ok(signer_acc)
+}
+
+async fn download_contract() -> anyhow::Result<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);
+
+    if !Path::new(target_path).exists() {
+        create_dir(target_path)?;
+    }
+
+    if !Path::new(&full_dest).exists() {
+        let response = reqwest::get(target).await?;
+        let mut file = File::create(&full_dest)?;
+        let mut content = Cursor::new(response.bytes().await?);
+        copy(&mut content, &mut file)?;
+    }
+
+    let mut file = File::open(full_dest)?;
+    let mut data = Vec::new();
+    file.read_to_end(&mut data)?;
+
+    Ok(data)
+}
+
+fn random_bits() -> [u8; 32] {
+    let mut chacha = ChaChaRng::from_entropy();
+    let mut secret_bytes = [0_u8; 32];
+    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 meta = InitMeta::new().await?;
+    let mut signer = create_signer(&meta).await?;
+
+    let call = meta
+        .client
+        .deploy_contract(&mut signer, &meta.signer_account_id, meta.wasm);
+
+    call.commit_empty().await?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn contract_function_call() -> anyhow::Result<()> {
+    let meta = InitMeta::new().await?;
+    let mut signer = create_signer(&meta).await?;
+
+    let call = meta
+        .client
+        .deploy_contract(&mut signer, &meta.signer_account_id, meta.wasm);
+    call.commit_empty().await?;
+
+    let call = meta
+        .client
+        .function_call(&mut signer, &meta.signer_account_id, "new_default_meta")
+        .args(json!({
+            "owner_id": &meta.signer_account_id,
+            "total_supply": "100",
+        }))
+        .gas(near_units::parse_gas!("300 T") as u64)
+        .build()?;
+    call.commit_empty().await?;
+
+    Ok(())
+}