chore(sails): display slice as hex w/o alloc (#953)

Author: vobradovich

examples/demo/app/tests/gtest.rs

@@ -165,7 +165,14 @@ async fn ping_pong_low_level_works() {
     let demo_program = Program::from_file(&system, DEMO_WASM_PATH);
 
     // Use generated `io` module to create a program
-    demo_program.send_bytes(ADMIN_ID, demo_factory::io::Default::encode_call());
+    let message_id = demo_program.send_bytes(ADMIN_ID, demo_factory::io::Default::encode_call());
+    let run_result = system.run_next_block();
+    let gas_burned = *run_result
+        .gas_burned
+        .get(&message_id)
+        .expect("message not found");
+    let wasm_size = std::fs::metadata(DEMO_WASM_PATH).unwrap().len();
+    println!("[ping_pong_low_level_works] Init Gas: {gas_burned:>14}, Size: {wasm_size}");
 
     // Use generated `io` module for encoding/decoding calls and replies
     // and send/receive bytes using `gtest` native means
@@ -185,6 +192,12 @@ async fn ping_pong_low_level_works() {
     let ping_reply = ping_pong::io::Ping::decode_reply(ping_reply_payload).unwrap();
 
     assert_eq!(ping_reply, Ok("pong".to_string()));
+
+    let gas_burned = *run_result
+        .gas_burned
+        .get(&message_id)
+        .expect("message not found");
+    println!("[ping_pong_low_level_works] Handle Gas: {gas_burned:>14}, Size: {wasm_size}");
 }
 
 #[tokio::test]
@@ -479,6 +492,44 @@ async fn counter_add_works_via_manual_mode() {
     );
 }
 
+#[test]
+fn counter_add_low_level_works() {
+    let system = System::new();
+    system.init_logger_with_default_filter("gwasm=debug,gtest=info,sails_rs=debug");
+    system.mint_to(ADMIN_ID, 1_000_000_000_000_000);
+
+    let demo_program = Program::from_file(&system, DEMO_WASM_PATH);
+    let wasm_size = std::fs::metadata(DEMO_WASM_PATH).unwrap().len();
+
+    // Use generated `io` module to create a program
+    demo_program.send_bytes(ADMIN_ID, demo_factory::io::Default::encode_call());
+
+    // Use generated `io` module for encoding/decoding calls and replies
+    // and send/receive bytes using `gtest` native means
+    let call_payload = demo_client::counter::io::Add::encode_call(10);
+
+    let message_id = demo_program.send_bytes(ADMIN_ID, call_payload);
+    let run_result = system.run_next_block();
+
+    let reply_log_record = run_result
+        .log()
+        .iter()
+        .find(|entry| entry.reply_to() == Some(message_id))
+        .unwrap();
+
+    let reply_payload = reply_log_record.payload();
+
+    let reply = demo_client::counter::io::Add::decode_reply(reply_payload).unwrap();
+
+    assert_eq!(reply, 10);
+
+    let gas_burned = *run_result
+        .gas_burned
+        .get(&message_id)
+        .expect("message not found");
+    println!("[counter_add_low_level_works] Handle Gas: {gas_burned:>14}, Size: {wasm_size}");
+}
+
 #[tokio::test]
 async fn value_fee_works() {
     // Arrange

rs/ethexe/ethapp/tests/gtest.rs

@@ -39,6 +39,13 @@ async fn ethapp_sol_works() {
         Some(sails_rs::gear_core_errors::ReplyCode::Success(_))
     ));
 
+    let gas_burned = *run_result
+        .gas_burned
+        .get(&message_id)
+        .expect("message not found");
+    let wasm_size = std::fs::metadata(WASM_PATH).unwrap().len();
+    println!("[ethapp_sol_works] Init Gas: {gas_burned:>14}, Size: {wasm_size}");
+
     let do_this_sig = sails_rs::solidity::selector("svc1DoThis(uint128,bool,uint32,string)");
     let do_this_params = (0u128, false, 42, "hello").abi_encode_sequence();
     let payload = [do_this_sig.as_slice(), do_this_params.as_slice()].concat();
@@ -56,6 +63,12 @@ async fn ethapp_sol_works() {
     let reply = u32::abi_decode(reply_payload, true);
 
     assert_eq!(reply, Ok(42));
+
+    let gas_burned = *run_result
+        .gas_burned
+        .get(&message_id)
+        .expect("message not found");
+    println!("[ethapp_sol_works] Handle Gas: {gas_burned:>14}, Size: {wasm_size}");
 }
 
 #[tokio::test]

rs/ethexe/ethapp_with_events/tests/gtest.rs

@@ -43,6 +43,13 @@ async fn ethapp_with_events_low_level_works() {
         Some(sails_rs::gear_core_errors::ReplyCode::Success(_))
     ));
 
+    let gas_burned = *run_result
+        .gas_burned
+        .get(&message_id)
+        .expect("message not found");
+    let wasm_size = std::fs::metadata(WASM_PATH).unwrap().len();
+    println!("[ethapp_with_events_low_level_works] Init Gas: {gas_burned:>14}, Size: {wasm_size}");
+
     let do_this_sig = sails_rs::solidity::selector("svc1DoThis(uint128,bool,uint32,string)");
     let do_this_params = (0u128, false, 42, "hello").abi_encode_sequence();
     let payload = [do_this_sig.as_slice(), do_this_params.as_slice()].concat();
@@ -62,6 +69,14 @@ async fn ethapp_with_events_low_level_works() {
 
     assert_eq!(reply, Ok(42));
 
+    let gas_burned = *run_result
+        .gas_burned
+        .get(&message_id)
+        .expect("message not found");
+    println!(
+        "[ethapp_with_events_low_level_works] Handle Gas: {gas_burned:>14}, Size: {wasm_size}"
+    );
+
     // assert event
     const ETH_EVENT_ADDR: ActorId = ActorId::new([
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,

rs/src/gstd/mod.rs

@@ -67,18 +67,42 @@ impl<T> From<(T, ValueUnit)> for CommandReply<T> {
 
 pub fn unknown_input_panic(message: &str, input: &[u8]) -> ! {
     let mut __input = input;
-    let input: String = crate::Decode::decode(&mut __input).unwrap_or_else(|_| {
-        if input.len() <= 8 {
-            format!("0x{}", crate::hex::encode(input))
+    match String::decode(&mut __input) {
+        Ok(s) => panic!("{}: {}", message, s),
+        Err(_) => panic!("{}: {}", message, HexSlice(input)),
+    }
+}
+
+struct HexSlice<T: AsRef<[u8]>>(T);
+
+impl<T: AsRef<[u8]>> core::fmt::Display for HexSlice<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let slice = self.0.as_ref();
+        let len = slice.len();
+        let precision = f.precision().unwrap_or(4);
+
+        f.write_str("0x")?;
+        if len <= precision * 2 {
+            for byte in slice {
+                write!(f, "{:02x}", byte)?;
+            }
         } else {
-            format!(
-                "0x{}..{}",
-                crate::hex::encode(&input[..4]),
-                crate::hex::encode(&input[input.len() - 4..])
-            )
+            for byte in &slice[..precision] {
+                write!(f, "{:02x}", byte)?;
+            }
+            f.write_str("..")?;
+            for byte in &slice[len - precision..] {
+                write!(f, "{:02x}", byte)?;
+            }
         }
-    });
-    panic!("{}: {}", message, input)
+        Ok(())
+    }
+}
+
+impl<T: AsRef<[u8]>> core::fmt::Debug for HexSlice<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Display::fmt(self, f)
+    }
 }
 
 pub trait InvocationIo {