feat(gclient): introduce gear general client

Cargo.toml

@@ -108,7 +108,7 @@ members = [
     "utils/runtime-fuzzer/fuzz",
     "utils/lazy-pages-fuzzer/fuzz",
     "ethexe/*",
-    "ethexe/runtime/common",
+    "ethexe/runtime/common", "gnc",
 ]
 
 [workspace.dependencies]

gclient/Cargo.toml

@@ -16,6 +16,7 @@ gsdk = { workspace = true, features = ["testing"] }
 gear-node-wrapper.workspace = true
 gear-core.workspace = true
 gear-core-errors.workspace = true
+gprimitives.workspace = true
 
 futures.workspace = true
 anyhow.workspace = true

gclient/src/api/mod.rs

@@ -29,7 +29,7 @@ use gear_node_wrapper::{Node, NodeInstance};
 use gsdk::{
     ext::{sp_core::sr25519, sp_runtime::AccountId32},
     signer::Signer,
-    Api,
+    Api, Blocks,
 };
 use std::{ffi::OsStr, sync::Arc};
 
@@ -127,8 +127,16 @@ impl GearApi {
     /// Create an [`EventListener`] to subscribe and handle continuously
     /// incoming events.
     pub async fn subscribe(&self) -> Result<EventListener> {
-        let events = self.0.api().subscribe_finalized_blocks().await?;
-        Ok(EventListener(events))
+        Ok(EventListener(self.subscribe_blocks().await?))
+    }
+
+    /// Subscribe new blocks with events without [`EventListener`] as wrapper.
+    pub async fn subscribe_blocks(&self) -> Result<Blocks> {
+        self.0
+            .api()
+            .subscribe_finalized_blocks()
+            .await
+            .map_err(Into::into)
     }
 
     /// Set the number used once (`nonce`) that will be used while sending
@@ -174,6 +182,18 @@ impl GearApi {
     pub fn account_id(&self) -> &AccountId32 {
         self.0.account_id()
     }
+
+    /// Change the singer of `GearApi`, see also [`GearApi::init_with`].
+    pub fn change_signer(&mut self, suri: impl AsRef<str>) -> Result<()> {
+        let mut suri = suri.as_ref().splitn(2, ':');
+        let new_signer = self
+            .0
+            .clone()
+            .change(suri.next().expect("Infallible"), suri.next())?;
+        self.0 = new_signer;
+
+        Ok(())
+    }
 }
 
 impl From<Signer> for GearApi {

gclient/src/lib.rs

@@ -129,6 +129,7 @@
 #![warn(missing_docs)]
 #![doc(html_logo_url = "https://docs.gear.rs/logo.svg")]
 #![doc(html_favicon_url = "https://gear-tech.io/favicons/favicon.ico")]
+#![allow(async_fn_in_trait)]
 
 mod api;
 mod utils;

gclient/src/ws.rs

@@ -21,6 +21,7 @@ use anyhow::anyhow;
 use std::{
     fmt,
     net::{AddrParseError, SocketAddrV4},
+    str::FromStr,
 };
 use url::Url;
 
@@ -184,6 +185,16 @@ impl From<SocketAddrV4> for WSAddress {
     }
 }
 
+impl FromStr for WSAddress {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        s.parse()
+            .map_err(|e: AddrParseError| Error::Anyhow(e.into()))
+            .map(|addr: SocketAddrV4| addr.into())
+    }
+}
+
 impl TryInto<SocketAddrV4> for WSAddress {
     type Error = Error;
 

gnc/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "gnc"
+description = "Gear next client"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+gclient.workspace = true
+gtest.workspace = true
+tokio.workspace = true
+tracing.workspace = true
+gear-core.workspace = true
+gprimitives.workspace = true
+anyhow.workspace = true
+parity-scale-codec.workspace = true
+gsdk.workspace = true
+
+[dev-dependencies]
+demo-proxy = { workspace = true, features = ["std"] }

gnc/src/backend/gclient.rs

@@ -0,0 +1,227 @@
+// This file is part of Gear.
+
+// Copyright (C) 2022-2024 Gear Technologies Inc.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use crate::{Backend, Code, Message, Program, TxResult, ALICE};
+use anyhow::{anyhow, Result};
+use gclient::{Event, GearApi, GearEvent};
+use gear_core::{
+    ids::ProgramId,
+    message::{UserMessage, UserStoredMessage},
+};
+use gprimitives::{ActorId, MessageId, H256};
+use gsdk::{
+    ext::sp_core::{sr25519, Pair},
+    metadata::runtime_types::gear_common::storage::primitives::Interval,
+    Blocks,
+};
+use std::{
+    collections::{BTreeMap, HashMap},
+    sync::Arc,
+    time::{Duration, SystemTime},
+};
+use tokio::sync::{Mutex, MutexGuard};
+
+const MESSAGES_DEPTH: usize = 16;
+const DEFAULT_TIMEOUT: u64 = 3000;
+
+/// GClient instance
+#[derive(Clone)]
+pub struct GClient {
+    inner: Arc<Mutex<GearApi>>,
+    pairs: HashMap<ActorId, String>,
+    messages: Arc<Mutex<BTreeMap<H256, Vec<UserMessage>>>>,
+    timeout: Duration,
+}
+
+impl GClient {
+    /// Create new gclient instance
+    pub async fn new(api: GearApi) -> Result<Self> {
+        let messages = Arc::new(Mutex::new(BTreeMap::new()));
+        Self::spawn(api.subscribe_blocks().await?, messages.clone());
+
+        Ok(Self {
+            inner: Arc::new(Mutex::new(api)),
+            pairs: HashMap::from_iter(vec![(ALICE, "//Alice".to_string())].into_iter()),
+            timeout: Duration::from_millis(DEFAULT_TIMEOUT),
+            messages,
+        })
+    }
+
+    /// Switch to the provided pair
+    async fn switch_pair(&self, address: ActorId) -> Result<()> {
+        let pair = self
+            .pairs
+            .get(&address)
+            .ok_or(anyhow!("Could not find pair {address}"))?;
+
+        self.inner.lock().await.change_signer(pair)?;
+        Ok(())
+    }
+
+    /// Get [`GearApi`]
+    async fn api(&self) -> MutexGuard<'_, GearApi> {
+        self.inner.lock().await
+    }
+
+    /// Get user sent messages by block hash
+    async fn logs(&self, hash: H256) -> Result<Vec<UserMessage>> {
+        let now = SystemTime::now();
+        loop {
+            if now.elapsed()? > self.timeout {
+                return Ok(vec![]);
+            }
+
+            if let Some(messages) = self.messages.lock().await.remove(&hash) {
+                return Ok(messages);
+            }
+        }
+    }
+
+    /// Spawn gear messages
+    fn spawn(mut sub: Blocks, gmessages: Arc<Mutex<BTreeMap<H256, Vec<UserMessage>>>>) {
+        tokio::spawn(async move {
+            while let Ok(Some(bevs)) = sub.next_events().await {
+                let messages = bevs
+                    .events()
+                    .unwrap_or_default()
+                    .into_iter()
+                    .filter_map(|e| {
+                        if let Event::Gear(GearEvent::UserMessageSent { message, .. }) = e {
+                            Some(message.into())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                if messages.is_empty() {
+                    continue;
+                }
+
+                let mut map = gmessages.lock().await;
+                while map.len() > MESSAGES_DEPTH {
+                    map.pop_first();
+                }
+
+                map.insert(bevs.block_hash(), messages);
+            }
+        });
+    }
+}
+
+impl Backend for GClient {
+    async fn program(&self, id: ProgramId) -> Result<Program<Self>> {
+        let _ = self.inner.lock().await.program_at(id, None).await?;
+
+        Ok(Program {
+            id,
+            backend: self.clone(),
+        })
+    }
+
+    async fn deploy<M>(&self, code: impl Code, message: M) -> Result<TxResult<Program<Self>>>
+    where
+        M: Into<Message> + Send,
+    {
+        let wasm = code.bytes()?;
+        let message = message.into();
+        self.switch_pair(message.signer).await?;
+
+        let api = self.api().await;
+        let (_, id, _) = api
+            .upload_program_bytes(
+                wasm,
+                message.salt,
+                message.payload,
+                message.gas_limit.unwrap_or(api.block_gas_limit()?),
+                message.value,
+            )
+            .await?;
+
+        Ok(TxResult {
+            result: Program {
+                id,
+                backend: self.clone(),
+            },
+            logs: vec![],
+        })
+    }
+
+    async fn send<M>(&self, id: ProgramId, message: M) -> Result<TxResult<MessageId>>
+    where
+        M: Into<Message> + Send,
+    {
+        let message = message.into();
+        self.switch_pair(message.signer).await?;
+
+        let api = self.api().await;
+        let (mid, hash) = api
+            .send_message_bytes(
+                id,
+                message.payload,
+                message.gas_limit.unwrap_or(api.block_gas_limit()?),
+                message.value,
+            )
+            .await?;
+
+        Ok(TxResult {
+            result: mid,
+            logs: self.logs(hash).await?,
+        })
+    }
+
+    async fn message(&self, mid: MessageId) -> Result<Option<(UserStoredMessage, Interval<u32>)>> {
+        self.inner
+            .lock()
+            .await
+            .get_mailbox_message(mid)
+            .await
+            .map_err(Into::into)
+    }
+
+    async fn transfer(&self, to: ActorId, value: u128) -> Result<TxResult<H256>> {
+        let hash = self
+            .inner
+            .lock()
+            .await
+            .transfer_keep_alive(to, value)
+            .await?;
+
+        Ok(TxResult {
+            result: hash,
+            logs: self.logs(hash).await?,
+        })
+    }
+
+    fn add_pair(&mut self, suri: impl AsRef<str>) -> Result<()> {
+        let mut patt = suri.as_ref().splitn(2, ':');
+        let pair = sr25519::Pair::from_string(
+            patt.next()
+                .ok_or(anyhow!("Invalid suri, failed to add pair"))?,
+            patt.next(),
+        )?;
+        self.pairs
+            .insert(pair.public().0.into(), suri.as_ref().to_string());
+
+        Ok(())
+    }
+
+    fn timeout(&mut self, timeout: Duration) {
+        self.timeout = timeout
+    }
+}