rusk-wallet: Implement http contract query

rusk-wallet/src/bin/command.rs

@@ -545,8 +545,9 @@ impl Command {
                     .try_into()
                     .map_err(|_| Error::InvalidContractId)?;
 
-                let call = ContractCall::new(contract_id, fn_name, &fn_args)
-                    .map_err(|_| Error::Rkyv)?;
+                let call =
+                    ContractCall::new(contract_id, fn_name.clone(), &fn_args)
+                        .map_err(|_| Error::Rkyv)?;
 
                 let tx = match address {
                     Address::Shielded(_) => {
@@ -573,7 +574,13 @@ impl Command {
                     }
                 }?;
 
-                Ok(RunResult::Tx(tx.hash()))
+                let contract_id = hex::encode(contract_id);
+
+                let http_call = wallet
+                    .http_contract_call(contract_id, &fn_name, fn_args)
+                    .await?;
+
+                Ok(RunResult::ContractCall(tx.hash(), http_call))
             }
 
             Self::ContractDeploy {
@@ -664,6 +671,7 @@ pub enum RunResult<'a> {
     Profile((u8, &'a Profile)),
     Profiles(&'a Vec<Profile>),
     ContractId([u8; CONTRACT_ID_BYTES]),
+    ContractCall(BlsScalar, Vec<u8>),
     ExportedKeys(PathBuf, PathBuf),
     Create(),
     Restore(),
@@ -741,6 +749,12 @@ impl fmt::Display for RunResult<'_> {
             ContractId(bytes) => {
                 write!(f, "> Contract ID: {}", hex::encode(bytes))
             }
+            ContractCall(scalar, bytes) => {
+                let hash = hex::encode(scalar.to_bytes());
+                writeln!(f, "> Contract call transaction hash: {hash}",)?;
+
+                writeln!(f, "> Http contract query: {:?}", bytes)
+            }
             ExportedKeys(pk, kp) => {
                 let pk = pk.display();
                 let kp = kp.display();

rusk-wallet/src/bin/interactive.rs

@@ -92,22 +92,26 @@ pub(crate) async fn run_loop(
                         prompt::show_cursor()?;
                         // output results
                         println!("\r{}", res);
-                        if let RunResult::Tx(hash) = res {
-                            let tx_id = hex::encode(hash.to_bytes());
-
-                            // Wait for transaction confirmation
-                            // from network
-                            let gql = GraphQL::new(
-                                settings.state.to_string(),
-                                io::status::interactive,
-                            )?;
-                            gql.wait_for(&tx_id).await?;
-
-                            if let Some(explorer) = &settings.explorer {
-                                let url = format!("{explorer}{tx_id}");
-                                println!("> URL: {url}");
-                                prompt::launch_explorer(url)?;
+                        match res {
+                            RunResult::Tx(hash)
+                            | RunResult::ContractCall(hash, _) => {
+                                let tx_id = hex::encode(hash.to_bytes());
+
+                                // Wait for transaction confirmation
+                                // from network
+                                let gql = GraphQL::new(
+                                    settings.state.to_string(),
+                                    io::status::interactive,
+                                )?;
+                                gql.wait_for(&tx_id).await?;
+
+                                if let Some(explorer) = &settings.explorer {
+                                    let url = format!("{explorer}{tx_id}");
+                                    println!("> URL: {url}");
+                                    prompt::launch_explorer(url)?;
+                                }
                             }
+                            _ => (),
                         }
                     }
                 }

rusk-wallet/src/bin/main.rs

@@ -401,6 +401,17 @@ async fn exec() -> anyhow::Result<()> {
                 RunResult::ContractId(id) => {
                     println!("Contract ID: {:?}", id);
                 }
+                RunResult::ContractCall(scalar, result) => {
+                    let tx_id = hex::encode(scalar.to_bytes());
+
+                    // Wait for transaction confirmation from network
+                    let gql = GraphQL::new(settings.state, status::headless)?;
+                    gql.wait_for(&tx_id).await?;
+
+                    println!("{tx_id}");
+
+                    println!("HTTP call result: {:?}", result);
+                }
                 RunResult::Settings() => {}
                 RunResult::Create() | RunResult::Restore() => {}
             }

rusk-wallet/src/clients/sync.rs

@@ -46,7 +46,7 @@ pub(crate) async fn sync_db(
     let mut stream = client
         .call_raw(
             CONTRACTS_TARGET,
-            TRANSFER_CONTRACT,
+            Some(TRANSFER_CONTRACT.to_string()),
             "leaves_from_pos",
             &req,
             true,

rusk-wallet/src/gql.rs

@@ -175,7 +175,7 @@ impl GraphQL {
     /// Call the graphql endpoint of a node
     pub async fn query(&self, query: &str) -> Result<Vec<u8>, Error> {
         self.client
-            .call("graphql", None, "query", query.as_bytes())
+            .call("graphql", None::<String>, "query", query.as_bytes())
             .await
     }
 }

rusk-wallet/src/rues.rs

@@ -54,8 +54,11 @@ impl RuesHttpClient {
     {
         let data = rkyv::to_bytes(value).map_err(|_| Error::Rkyv)?.to_vec();
 
+        let contract: Option<&str> = contract.into();
+        let contract: Option<String> = contract.map(|e| e.to_owned());
+
         let response = self
-            .call_raw(CONTRACTS_TARGET, contract.into(), method, &data, false)
+            .call_raw(CONTRACTS_TARGET, contract, method, &data, false)
             .await?;
 
         Ok(response.bytes().await?.to_vec())
@@ -79,7 +82,7 @@ impl RuesHttpClient {
         request: &[u8],
     ) -> Result<Vec<u8>, Error>
     where
-        E: Into<Option<&'static str>>,
+        E: Into<Option<String>>,
     {
         let response =
             self.call_raw(target, entity, topic, request, false).await?;
@@ -97,7 +100,7 @@ impl RuesHttpClient {
         feed: bool,
     ) -> Result<Response, Error>
     where
-        E: Into<Option<&'static str>>,
+        E: Into<Option<String>>,
     {
         let uri = &self.uri;
         let entity = entity.into().map(|e| format!(":{e}")).unwrap_or_default();

rusk-wallet/src/wallet.rs

@@ -622,6 +622,23 @@ impl<F: SecureWalletFile + Debug> Wallet<F> {
 
         Ok(gas_prices)
     }
+
+    /// do a contract call over http
+    pub async fn http_contract_call(
+        &self,
+        contract_id: String,
+        fn_name: &str,
+        fn_args: Vec<u8>,
+    ) -> Result<Vec<u8>, Error> {
+        let client = self.state()?.client();
+
+        // query the rusk vm
+        let response = client
+            .call("contracts", Some(contract_id), fn_name, &fn_args)
+            .await?;
+
+        Ok(response)
+    }
 }
 
 /// This structs represent a Note decoded enriched with useful chain information