client: implement initial commands

Author: dr-orlovsky

Cargo.lock

@@ -21,7 +21,7 @@ name = "rgbclient"
 
 [dependencies]
 amplify.workspace = true
-strict_encoding.workspace = true
+bp-std = { workspace = true, optional = true }
 rgb-rpc = { version = "0.12.0-alpha.1", path = "../rpc" }
 io-reactor.workspace = true
 netservices.workspace = true
@@ -40,5 +40,5 @@ rgb-rpc = { version = "0.12.0-alpha.1", path = "../rpc" }
 [features]
 default = ["cli"]
 all = ["log", "cli"]
-cli = ["log", "dep:clap", "dep:shellexpand", "dep:serde_yaml"]
+cli = ["dep:bp-std", "log", "dep:clap", "dep:shellexpand", "dep:serde_yaml"]
 log = ["dep:log", "dep:loglevel", "io-reactor/log", "netservices/log"]

client/Cargo.toml

@@ -21,7 +21,7 @@
 
 use rgbrpc::RemoteAddr;
 
-/// Command-line tool for working with store daemon
+/// Command-line tool for working with the RGB daemon
 #[derive(Parser, Clone, PartialEq, Eq, Debug)]
 #[command(name = "bp-cli", bin_name = "bp-cli", author, version)]
 pub struct Args {
@@ -43,6 +43,15 @@ pub struct Args {
 /// Command-line commands:
 #[derive(Subcommand, Clone, PartialEq, Eq, Debug, Display)]
 pub enum Command {
-    #[display("ping")]
-    Ping,
+    /// Get RGB node status information
+    #[display("status")]
+    Status,
+
+    /// List wallets known to the RGB node
+    #[display("wallets")]
+    Wallets,
+
+    /// List contracts known to the RGB node
+    #[display("contracts")]
+    Contracts,
 }

client/src/args.rs

@@ -36,14 +36,14 @@ pub struct Delegate {
     cb: fn(RgbRpcResp),
 }
 
-pub struct BpClient {
+pub struct RgbClient {
     inner: Client<RgbRpcReq>,
 }
 
-impl BpClient {
+impl RgbClient {
     pub fn new(remote: RemoteAddr, cb: fn(RgbRpcResp)) -> io::Result<Self> {
         let delegate = Delegate { cb };
-        let inner = Client::new(delegate, remote)?;
+        let inner = Client::new::<_, Session, _>(delegate, remote)?;
         Ok(Self { inner })
     }
 
@@ -52,6 +52,10 @@ impl BpClient {
         self.inner.send(RgbRpcReq::Ping(noise))
     }
 
+    pub fn status(&self) -> io::Result<()> { self.inner.send(RgbRpcReq::Status) }
+    pub fn contracts(&self) -> io::Result<()> { self.inner.send(RgbRpcReq::Contracts) }
+    pub fn wallets(&self) -> io::Result<()> { self.inner.send(RgbRpcReq::Wallets) }
+
     pub fn join(self) -> Result<(), Box<dyn Any + Send>> { self.inner.join() }
 }
 
@@ -61,8 +65,8 @@ impl ConnectionDelegate<RemoteAddr, Session> for Delegate {
     fn connect(&mut self, remote: &RemoteAddr) -> Session {
         TcpStream::connect(remote).unwrap_or_else(|err| {
             #[cfg(feature = "log")]
-            log::error!("Unable to connect BP Node {remote} due to {err}");
-            eprintln!("Unable to connect BP Node {remote}");
+            log::error!("Unable to connect RGB Node {remote} due to {err}");
+            eprintln!("Unable to connect RGB Node {remote}");
             exit(1);
         })
     }

client/src/client.rs

@@ -22,7 +22,7 @@
 use std::io;
 
 use crate::Command;
-use crate::client::BpClient;
+use crate::client::RgbClient;
 
 #[derive(Debug, Display, Error, From)]
 #[non_exhaustive]
@@ -33,11 +33,13 @@ pub enum ExecError {
 }
 
 impl Command {
-    pub fn exec(self, mut client: BpClient) -> Result<(), ExecError> {
+    pub fn exec(self, client: RgbClient) -> Result<(), ExecError> {
         match self {
-            Command::Ping => {
-                client.ping()?;
+            Command::Status => {
+                client.status()?;
             }
+            Command::Wallets => client.wallets()?,
+            Command::Contracts => client.contracts()?,
         }
         client.join().expect("Client thread panicked");
         Ok(())

client/src/command.rs

@@ -19,12 +19,7 @@
 // or implied. See the License for the specific language governing permissions and limitations under
 // the License.
 
-#[macro_use]
-extern crate amplify;
-#[macro_use]
-extern crate strict_encoding;
-
 pub use ::rgbrpc as rpc;
 mod client;
 
-pub use client::{BpClient, Delegate};
+pub use client::{Delegate, RgbClient};

client/src/lib.rs

@@ -32,20 +32,23 @@ mod args;
 mod client;
 mod command;
 
+use std::process::exit;
+
+use bpstd::Descriptor;
 use clap::Parser;
 use loglevel::LogLevel;
 use rgbrpc::RgbRpcResp;
 
 pub use crate::args::{Args, Command};
-use crate::client::BpClient;
+use crate::client::RgbClient;
 use crate::command::ExecError;
 
 fn main() -> Result<(), ExecError> {
     let args = Args::parse();
     LogLevel::from_verbosity_flag_count(args.verbose).apply();
     trace!("Command-line arguments: {:#?}", &args);
 
-    let client = BpClient::new(args.remote, cb)?;
+    let client = RgbClient::new(args.remote, cb)?;
 
     args.command.exec(client)
 }
@@ -55,13 +58,31 @@ fn cb(reply: RgbRpcResp) {
         RgbRpcResp::Failure(failure) => {
             println!("Failure: {failure}");
         }
+        RgbRpcResp::Message(msg) => {
+            println!("Message from RGB Node: {msg}");
+        }
         RgbRpcResp::Pong(_noise) => {}
         RgbRpcResp::Status(status) => {
             println!("{}", serde_yaml::to_string(&status).unwrap());
         }
-        RgbRpcResp::ContractState(contract_id, ..) => {
-            println!("Contract status for {contract_id}:");
+        RgbRpcResp::Contracts(contracts) => {
+            for contract in contracts {
+                println!("---");
+                println!("{}", serde_yaml::to_string(&contract).expect("Unable to generate YAML"));
+            }
+        }
+        RgbRpcResp::ContractState(contract_id, state) => {
+            println!("Contract state for {contract_id}:");
+            println!("{}", serde_yaml::to_string(&state).expect("Unable to generate YAML"));
+        }
+        RgbRpcResp::Wallets(wallets) => {
+            println!("Wallets:");
+            println!("Id\tName\tDescriptor class");
+            for wallet in wallets {
+                println!("{}\t{}\t{}", wallet.id, wallet.name, wallet.descriptor.class())
+            }
         }
         _ => todo!(),
     }
+    exit(0)
 }

client/src/main.rs

@@ -19,7 +19,7 @@
 // or implied. See the License for the specific language governing permissions and limitations under
 // the License.
 
-use std::io::{Read, Write};
+use std::io::{ErrorKind, Read, Write};
 
 use amplify::confinement::{SmallBlob, TinyBlob};
 use bpstd::{DescrId, Network};
@@ -30,7 +30,6 @@ use sonicapi::{CodexId, ContractId};
 use crate::CiboriumError;
 
 #[derive(Clone, Debug, Display)]
-#[display(UPPERCASE)]
 #[derive(Serialize, Deserialize)]
 pub enum RgbRpcReq {
     #[display("HELLO({0})")]
@@ -39,8 +38,10 @@ pub enum RgbRpcReq {
     #[display("PING")]
     Ping(TinyBlob),
 
+    #[display("STATUS")]
     Status,
 
+    #[display("WALLETS")]
     Wallets,
 
     #[display("WALLET({0})")]
@@ -52,8 +53,10 @@ pub enum RgbRpcReq {
     #[display("DELETE({0})")]
     Delete(DescrId),
 
+    #[display("ISSUERS")]
     Issuers,
 
+    #[display("CONTRACTS")]
     Contracts,
 
     #[display("ISSUER({0})")]
@@ -83,11 +86,43 @@ impl Frame for RgbRpcReq {
     type Error = CiboriumError;
 
     fn unmarshall(reader: impl Read) -> Result<Option<Self>, Self::Error> {
-        ciborium::from_reader(reader).map_err(CiboriumError::from)
+        match ciborium::from_reader(reader) {
+            Ok(msg) => Ok(Some(msg)),
+            Err(ciborium::de::Error::Io(e)) if e.kind() == ErrorKind::UnexpectedEof => Ok(None),
+            Err(e) => Err(CiboriumError::from(e)),
+        }
     }
 
     fn marshall(&self, writer: impl Write) -> Result<(), Self::Error> {
         ciborium::into_writer(self, writer)?;
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+
+    use super::*;
+
+    #[test]
+    fn serialization() {
+        let mut buf = Vec::new();
+        RgbRpcReq::Wallets.marshall(&mut buf).unwrap();
+        assert_eq!(buf, *b"\x67Wallets");
+        let deser = RgbRpcReq::unmarshall(&mut buf.as_slice()).unwrap().unwrap();
+        assert!(matches!(deser, RgbRpcReq::Wallets));
+    }
+
+    #[test]
+    fn stream_serialization() {
+        let mut buf = Vec::new();
+        RgbRpcReq::Wallets.marshall(&mut buf).unwrap();
+        assert_eq!(buf, *b"\x67Wallets");
+        let mut cursor = Cursor::new(&mut buf);
+        let deser = RgbRpcReq::unmarshall(&mut cursor).unwrap().unwrap();
+        assert!(matches!(deser, RgbRpcReq::Wallets));
+        let nothing = RgbRpcReq::unmarshall(&mut cursor).unwrap();
+        assert!(matches!(nothing, None));
+    }
+}

rpc/src/request.rs

@@ -20,7 +20,7 @@
 // the License.
 
 use std::collections::BTreeMap;
-use std::io::{Read, Write};
+use std::io::{ErrorKind, Read, Write};
 
 use amplify::confinement::{SmallBlob, TinyBlob};
 use bpstd::DescrId;
@@ -50,7 +50,7 @@ pub enum RgbRpcResp {
     #[display("STATUS")]
     Status(Status),
 
-    #[display("STATUS")]
+    #[display("WALLETS(...)")]
     Wallets(Vec<WalletInfo>),
 
     #[display("WALLET_STATE({0}, ...)")]
@@ -92,7 +92,11 @@ impl Frame for RgbRpcResp {
     type Error = CiboriumError;
 
     fn unmarshall(reader: impl Read) -> Result<Option<Self>, Self::Error> {
-        ciborium::from_reader(reader).map_err(CiboriumError::from)
+        match ciborium::from_reader(reader) {
+            Ok(msg) => Ok(Some(msg)),
+            Err(ciborium::de::Error::Io(e)) if e.kind() == ErrorKind::UnexpectedEof => Ok(None),
+            Err(e) => Err(CiboriumError::from(e)),
+        }
     }
 
     fn marshall(&self, writer: impl Write) -> Result<(), Self::Error> {
@@ -118,3 +122,33 @@ pub struct WalletState {
     pub aggregated: BTreeMap<ContractStateName, StrictVal>,
     pub confirmations: BTreeMap<Opid, WitnessStatus>,
 }
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+
+    use super::*;
+
+    #[test]
+    fn serialization() {
+        let mut buf = Vec::new();
+        RgbRpcResp::Message(s!("Test")).marshall(&mut buf).unwrap();
+        assert_eq!(buf, *b"\xA1\x67Message\x64Test");
+        let deser = RgbRpcResp::unmarshall(&mut buf.as_slice())
+            .unwrap()
+            .unwrap();
+        assert!(matches!(deser, RgbRpcResp::Message(m) if m == "Test"));
+    }
+
+    #[test]
+    fn stream_serialization() {
+        let mut buf = Vec::new();
+        RgbRpcResp::Message(s!("Test")).marshall(&mut buf).unwrap();
+        assert_eq!(buf, *b"\xA1\x67Message\x64Test");
+        let mut cursor = Cursor::new(&mut buf);
+        let deser = RgbRpcResp::unmarshall(&mut cursor).unwrap().unwrap();
+        assert!(matches!(deser, RgbRpcResp::Message(m) if m == "Test"));
+        let nothing = RgbRpcResp::unmarshall(&mut cursor).unwrap();
+        assert!(matches!(nothing, None));
+    }
+}