Add DeployContract call to the NearClient

near-client/src/client.rs

     types::{
         crypto::{ED25519PublicKey, ED25519Signature, Keypair},
         near::{
-            Action, Chunks, FinalExecutionOutcomeView, FinalExecutionStatus, FunctionCallAction,
-            SignedTransaction, Transaction, ViewResult,
+            Action, Chunks, DeployContractAction, FinalExecutionOutcomeView, FinalExecutionStatus,
+            FunctionCallAction, SignedTransaction, Transaction, ViewResult,
         },
     },
     Error,
         serde_json::from_slice(&view_result.result).map_err(Error::DeserializeTxResp)
     }
 
-    pub fn call<'a>(
+    pub fn function_call<'a>(
         &'a self,
         signer: &'a mut Signer,
         contract_id: &'a AccountId,
         method: &'static str,
-    ) -> TransactionBuilder {
-        TransactionBuilder::new(self, signer, method, contract_id)
+    ) -> FunctionCallBuilder {
+        let transaction_info = TransactionInfo::new(self, signer, contract_id);
+        FunctionCallBuilder::new(transaction_info, method)
+    }
+
+    pub fn deploy_contract<'a>(
+        &'a self,
+        signer: &'a mut Signer,
+        contract_id: &'a AccountId,
+        wasm: Vec<u8>,
+    ) -> Call {
+        let transaction_info = TransactionInfo::new(self, signer, contract_id);
+
+        Call {
+            transaction_info,
+            action: Action::from(DeployContractAction { code: wasm }),
+        }
     }
 }
 
-pub struct Call<'a>(TransactionBuilder<'a>);
+pub struct Call<'a> {
+    transaction_info: TransactionInfo<'a>,
+    action: Action,
+}
 
 impl<'a> Call<'a> {
     pub async fn commit<T: DeserializeOwned>(self) -> Result<T> {
-        let transaction_bytes = serialize_transaction(&self.0).await?;
+        let transaction_bytes = serialize_transaction(&self.transaction_info, self.action).await?;
 
         let execution_outcome = self
-            .0
+            .transaction_info
             .client
             .rpc_client
             .request::<FinalExecutionOutcomeView>(
         match execution_outcome.status {
             FinalExecutionStatus::Failure(err) => Err(Error::TransactionExec(err)),
             FinalExecutionStatus::SuccessValue(data) => {
-                self.0.signer.key_nonce += 1;
+                self.transaction_info.signer.key_nonce += 1;
                 serde_json::from_slice::<T>(&data).map_err(Error::DeserializeTxResp)
             }
             _ => Err(Error::TxNotStarted),
     }
 
     pub async fn commit_async(self) -> Result<String> {
-        let transaction_bytes = serialize_transaction(&self.0).await?;
-        self.0
+        let transaction_bytes = serialize_transaction(&self.transaction_info, self.action).await?;
+        self.transaction_info
             .client
             .rpc_client
             .request::<String>(
     }
 }
 
-pub struct TransactionBuilder<'a> {
+pub struct TransactionInfo<'a> {
     client: &'a NearClient,
     signer: &'a mut Signer,
-    method: &'static str,
     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,
+        }
+    }
+}
+
+async fn serialize_transaction<'a>(
+    transaction_info: &'a TransactionInfo<'_>,
+    action: 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: vec![action],
+    };
+
+    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>,
     deposit: Balance,
     gas: Gas,
     args: Option<Value>,
+    method_name: &'a str,
 }
 
-impl<'a> TransactionBuilder<'a> {
-    fn new(
-        client: &'a NearClient,
-        signer: &'a mut Signer,
-        method: &'static str,
-        contract_id: &'a AccountId,
-    ) -> Self {
+impl<'a> FunctionCallBuilder<'a> {
+    fn new(transaction_info: TransactionInfo<'a>, method_name: &'a str) -> Self {
         Self {
-            client,
-            signer,
-            contract_id,
-            method,
-            deposit: Default::default(),
+            transaction_info,
+            method_name,
             gas: Default::default(),
             args: Default::default(),
+            deposit: Default::default(),
         }
     }
 
         self
     }
 
-    pub fn build(self) -> Call<'a> {
-        Call(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();
+
+        let action = Action::from(FunctionCallAction {
+            method_name: self.method_name.to_string(),
+            args,
+            gas: self.gas,
+            deposit: self.deposit,
+        });
+
+        Ok(Call {
+            transaction_info: self.transaction_info,
+            action,
+        })
     }
 }
 
-async fn serialize_transaction<'a>(builder: &TransactionBuilder<'a>) -> Result<Vec<u8>> {
-    let block_hash = builder.client.block().await?;
-    let args_bytes = builder
-        .args
-        .as_ref()
-        .map(serde_json::to_vec)
-        .transpose()
-        .map_err(Error::ArgsSerialize)?
-        .unwrap_or_default();
-
-    let transaction = Transaction {
-        signer_id: builder.signer.account().clone(),
-        public_key: builder.signer.public_key(),
-        nonce: builder.signer.nonce() + 1,
-        receiver_id: builder.contract_id.clone(),
-        block_hash,
-        actions: vec![Action::FunctionCall(FunctionCallAction {
-            method_name: builder.method.to_owned(),
-            args: args_bytes,
-            gas: builder.gas,
-            deposit: builder.deposit,
-        })],
-    };
-
-    let (hash, ..) = transaction.get_hash_and_size();
-    let signature = builder.signer.keypair.sign(hash.0.as_ref());
-    let signed_transaction = SignedTransaction::new(signature, transaction);
-
-    borsh::to_vec(&signed_transaction).map_err(Error::TransactionSerialize)
-}
-
 #[cfg(test)]
 mod tests {}

wasm-client/src/lib.rs

 
     console_log!("Call");
     let build = near_client
-        .call(&mut signer_acc, &contract_id, "add_key")
+        .function_call(&mut signer_acc, &contract_id, "add_key")
         .gas(near_units::parse_gas!("300 T") as u64)
         .args(json!({
             "id": "Some",
             "value": String::from(keypair.public_key)
         }))
-        .build();
+        .build()
+        .map_err(|err| JsValue::from_str(&format!("Error {err}")))?;
 
     console_log!("Build");
     let res = build