Bump up outdated dependencies

common-api/Cargo.toml

 
 [dependencies]
 borsh = "0.9"
-near-account-id = { version = "0.15" }
-near-client = "0.1"
+near-client = { git = "https://github.com/Relayz-io/near-client.git" }
 serde = { version = "1", default-features = false, features = ["derive"] }
 
 [dev-dependencies]

common-api/src/api.rs

 use borsh::{BorshDeserialize, BorshSerialize};
-use near_account_id::AccountId;
-use near_client::crypto::prelude::*;
+use near_client::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashSet, time::Duration};
 

common-api/src/headers.rs

-use near_account_id::AccountId;
-use near_client::crypto::prelude::*;
+use near_client::prelude::*;
 use serde::{Deserialize, Serialize};
 
 pub const SIGNATURE_HEADER_NAME: &str = "signature";

web-client/Cargo.toml

 [package]
 name = "web-client"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 authors = ["silvestr@relayz.io"]
 description = """
 [dependencies]
 aes-gcm = "0.10"
 blake3 = "1.3"
-base64 = "0.20"
+base64 = "0.21"
 console_error_panic_hook = "0.1"
 common-api = { path = "../common-api" }
 console_log = { version = "0.2", features = ["color"] }
 itertools = "0.10"
 js-sys = "0.3"
 log = "0.4"
-near-client = "0.1"
-near-primitives-core = "0.15"
-near-units = "0.2"
+near-client = { git = "https://github.com/Relayz-io/near-client.git" }
 rand = { version = "0.8" }
 rand_chacha = "0.3"
 reqwest = { version = "0.11", features = ["json"] }
-serde-wasm-bindgen = "0.4"
+serde-wasm-bindgen = "0.5"
 serde = { version = "1", default-features = false, features = ["derive"] }
 serde_json = { version = "1", default-features = false }
 uuid = { version = "1.1.2", features = ["v4", "serde", "js"] }

web-client/src/contract.rs

 use crate::{error::ApiError, Handler};
-use near_client::{crypto::prelude::*, prelude::*, Finality};
-use near_primitives_core::{hash::CryptoHash, types::AccountId};
-use near_units::parse_gas;
+use near_client::{core::hash::CryptoHash, near_units::parse_gas, prelude::*};
 use std::collections::HashSet;
 use uuid::Uuid;
 use wasm_bindgen::prelude::*;

web-client/src/error.rs

-use near_client::{crypto::Error as CryptoErr, Error};
-use near_primitives_core::account::id::ParseAccountError;
+use near_client::{core::account::id::ParseAccountError, crypto::Error as CryptoErr, Error};
 use reqwest::Error as ExchangeError;
 use serde::{Deserialize, Serialize};
 use serde_json::Error as SerializationError;

web-client/src/exchange_client.rs

 };
 
 use crate::{contract::view_server_key, error::ApiError, Handler};
+use base64::prelude::*;
 use near_client::prelude::*;
-use near_primitives_core::types::AccountId;
 use std::{collections::HashSet, time::Duration};
 use uuid::Uuid;
 use wasm_bindgen::JsValue;
 
             serde_json::to_vec(&header).map_err(|_| ApiError::CreateSignatureHeader.into())
         })
-        .map(base64::encode)
+        .map(|it| BASE64_STANDARD_NO_PAD.encode(it))
 }
 
 async fn verify_response(handler: &Handler, response: Response) -> Result<Vec<u8>> {
         .to_str()
         .map_err(|_| ApiError::VerifySignatureHeader)
         .and_then(|header_str| {
-            base64::decode(header_str).map_err(|_| ApiError::VerifySignatureHeader)
+            BASE64_STANDARD_NO_PAD
+                .decode(header_str)
+                .map_err(|_| ApiError::VerifySignatureHeader)
         })
         .and_then(|bytes| {
             serde_json::from_slice::<SignatureHeader>(&bytes)

web-client/src/lib.rs

     view_moderator_account,
 };
 
+use near_client::{
+    core::{hash::CryptoHash, types::Nonce},
+    prelude::*,
+};
+
+use base64::prelude::*;
 use common_api::api::{ApiResponse, Data, ExchangeMessage};
 use crypto::{decrypt, encrypt, secret};
 use error::ApiError;
 use itertools::Itertools;
 use js_sys::Promise;
 use log::{info, warn};
-use near_client::prelude::*;
-use near_primitives_core::{account::id::AccountId, hash::CryptoHash, types::Nonce};
 use serde::{Deserialize, Serialize};
 use std::{collections::HashSet, str::FromStr, sync::Arc};
 use url::Url;
     ///
     /// - participants_set - The [`js_sys::Set`] represents hash set of participants' keys
     /// - timeout_ms - The [`u32`] that represents milliseconds that were given not to be exceeded
+    #[wasm_bindgen(js_name = initMeeting)]
     pub fn init_meeting(&self, participants_set: js_sys::Set, timeout_ms: u32) -> Promise {
         let handler = self.handler();
         let signer = self.signer();
     ///
     /// - meeting_id - The [`String`] that indicates ID of the meeting room
     /// - timeout_ms - The [`u32`] that represents milliseconds that were given not to be exceeded
+    #[wasm_bindgen(js_name = sendKeys)]
     pub fn send_keys(&self, meeting_id: String, timeout_ms: u32) -> Promise {
         let handler = self.handler();
         let signer = self.signer();
                 exchange(&handler, &signer, meet_id, messages).await?;
             }
 
-            Ok(JsValue::from_str(&base64::encode(handler.secret)))
+            Ok(JsValue::from_str(
+                &BASE64_STANDARD_NO_PAD.encode(handler.secret),
+            ))
         };
 
         wasm_bindgen_futures::future_to_promise(async move {
     ///
     /// - meeting_id - The [`String`] that indicates ID of the meeting room
     /// - timeout_ms - The [`u32`] that represents milliseconds that were given not to be exceeded
+    #[wasm_bindgen(js_name = getKey)]
     pub fn get_key(&self, meeting_id: String, timeout_ms: u32) -> Promise {
         let handler = self.handler();
         let signer = self.signer();
                 if let ApiResponse::Success(data) = receive(&handler, &signer, meet_id).await? {
                     let secret =
                         decrypt(signer.secret_key(), data.moderator_pk, meet_id, data.data)?;
-                    return Ok(JsValue::from_str(&base64::encode(secret)));
+                    return Ok(JsValue::from_str(&BASE64_STANDARD_NO_PAD.encode(secret)));
                 }
             }
         };

web-client/tests/integration.rs

-use near_client::{crypto::prelude::*, prelude::*, Finality};
-use near_primitives_core::account::id::AccountId;
+use near_client::{near_units, prelude::*};
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 use url::Url;