New C API features: svm_create_account, svm_increase_balance, etc.

crates/abi-decoder/src/decoder.rs

@@ -51,7 +51,7 @@ macro_rules! assert_no_eof {
 
 macro_rules! decode_fixed_primitive {
     ($self:expr, $ty:ident, $n:expr, $iter:expr) => {{
-        let ptr = safe_try!($self.read_bytes($iter, $n));
+        let ptr = $self.read_bytes($iter, $n)?;
         let value: $ty = ptr.as_ptr().into();
 
         let prim = Primitive::$ty(value);
@@ -75,7 +75,7 @@ impl Decoder {
     pub fn decode_value(&self, cursor: &mut Cursor) -> Result<Value, DecodeError> {
         assert_no_eof!(cursor);
 
-        let kind = safe_try!(self.peek_kind(cursor));
+        let kind = self.peek_kind(cursor)?;
 
         match kind {
             TypeKind::Array => self.decode_composite(cursor),
@@ -85,33 +85,33 @@ impl Decoder {
     }
 
     fn decode_primitive(&self, cursor: &mut Cursor) -> Result<Value, DecodeError> {
-        let kind = safe_try!(self.peek_kind(cursor));
+        let kind = self.peek_kind(cursor)?;
 
         let value = match kind {
-            TypeKind::None => safe_try!(self.decode_none(cursor)).into(),
-            TypeKind::Unit => safe_try!(self.decode_unit(cursor)).into(),
-            TypeKind::Bool => safe_try!(self.decode_bool(cursor)).into(),
-            TypeKind::Address => safe_try!(self.decode_addr(cursor)).into(),
-            TypeKind::Amount => safe_try!(self.decode_amount(cursor)).into(),
-            TypeKind::I8 => safe_try!(self.decode_i8(cursor)).into(),
-            TypeKind::U8 => safe_try!(self.decode_u8(cursor)).into(),
-            TypeKind::I16 => safe_try!(self.decode_i16(cursor)).into(),
-            TypeKind::U16 => safe_try!(self.decode_u16(cursor)).into(),
-            TypeKind::I32 => safe_try!(self.decode_i32(cursor)).into(),
-            TypeKind::U32 => safe_try!(self.decode_u32(cursor)).into(),
-            TypeKind::I64 => safe_try!(self.decode_i64(cursor)).into(),
-            TypeKind::U64 => safe_try!(self.decode_u64(cursor)).into(),
+            TypeKind::None => self.decode_none(cursor)?.into(),
+            TypeKind::Unit => self.decode_unit(cursor)?.into(),
+            TypeKind::Bool => self.decode_bool(cursor)?.into(),
+            TypeKind::Address => self.decode_addr(cursor)?.into(),
+            TypeKind::Amount => self.decode_amount(cursor)?.into(),
+            TypeKind::I8 => self.decode_i8(cursor)?.into(),
+            TypeKind::U8 => self.decode_u8(cursor)?.into(),
+            TypeKind::I16 => self.decode_i16(cursor)?.into(),
+            TypeKind::U16 => self.decode_u16(cursor)?.into(),
+            TypeKind::I32 => self.decode_i32(cursor)?.into(),
+            TypeKind::U32 => self.decode_u32(cursor)?.into(),
+            TypeKind::I64 => self.decode_i64(cursor)?.into(),
+            TypeKind::U64 => self.decode_u64(cursor)?.into(),
             _ => svm_sdk_std::panic(),
         };
 
         Result::Ok(value)
     }
 
     fn decode_composite(&self, cursor: &mut Cursor) -> Result<Value, DecodeError> {
-        let kind = safe_try!(self.peek_kind(cursor));
+        let kind = self.peek_kind(cursor)?;
 
         let value = match kind {
-            TypeKind::Array => safe_try!(self.decode_array(cursor)).into(),
+            TypeKind::Array => self.decode_array(cursor)?.into(),
 
             _ => svm_sdk_std::panic(),
         };
@@ -120,23 +120,23 @@ impl Decoder {
     }
 
     fn decode_none(&self, cursor: &mut Cursor) -> Result<Value, DecodeError> {
-        let byte = safe_try!(self.read_byte(cursor));
+        let byte = self.read_byte(cursor)?;
 
         debug_assert_eq!(byte, layout::NONE);
 
         Result::Ok(Value::none())
     }
 
     fn decode_unit(&self, cursor: &mut Cursor) -> Result<Value, DecodeError> {
-        let byte = safe_try!(self.read_byte(cursor));
+        let byte = self.read_byte(cursor)?;
 
         debug_assert_eq!(byte, layout::UNIT);
 
         Result::Ok(Value::unit())
     }
 
     fn decode_bool(&self, cursor: &mut Cursor) -> Result<Value, DecodeError> {
-        let byte = safe_try!(self.read_byte(cursor));
+        let byte = self.read_byte(cursor)?;
 
         let v = match byte {
             layout::BOOL_FALSE => false,
@@ -148,15 +148,15 @@ impl Decoder {
     }
 
     fn decode_addr(&self, cursor: &mut Cursor) -> Result<Value, DecodeError> {
-        let byte = safe_try!(self.read_byte(cursor));
+        let byte = self.read_byte(cursor)?;
 
         debug_assert_eq!(byte, layout::ADDRESS);
 
         decode_fixed_primitive!(self, Address, Address::len(), cursor)
     }
 
     fn decode_amount(&self, cursor: &mut Cursor) -> Result<Value, DecodeError> {
-        let byte = safe_try!(self.read_byte(cursor));
+        let byte = self.read_byte(cursor)?;
 
         let nbytes = match byte {
             layout::AMOUNT_1B => 1,
@@ -170,50 +170,50 @@ impl Decoder {
             _ => svm_sdk_std::panic(),
         };
 
-        let num = safe_try!(self.read_num(cursor, nbytes));
+        let num = self.read_num(cursor, nbytes)?;
         let amount = Amount(num);
 
         Result::Ok(amount.into())
     }
 
     fn decode_i8(&self, cursor: &mut Cursor) -> Result<i8, DecodeError> {
-        let byte = safe_try!(self.read_byte(cursor));
+        let byte = self.read_byte(cursor)?;
 
         debug_assert!(byte == layout::I8 || byte == layout::U8);
 
-        let num = safe_try!(self.read_num(cursor, 1)) as i8;
+        let num = self.read_num(cursor, 1)? as i8;
 
         Result::Ok(num)
     }
 
     fn decode_u8(&self, cursor: &mut Cursor) -> Result<u8, DecodeError> {
-        let num = safe_try!(self.decode_i8(cursor)) as u8;
+        let num = self.decode_i8(cursor)? as u8;
 
         Result::Ok(num)
     }
 
     fn decode_i16(&self, cursor: &mut Cursor) -> Result<i16, DecodeError> {
-        let byte = safe_try!(self.read_byte(cursor));
+        let byte = self.read_byte(cursor)?;
 
         let nbytes = match byte {
             layout::I16_1B | layout::U16_1B => 1,
             layout::I16_2B | layout::U16_2B => 2,
             _ => svm_sdk_std::panic(),
         };
 
-        let num = safe_try!(self.read_num(cursor, nbytes)) as i16;
+        let num = self.read_num(cursor, nbytes)? as i16;
 
         Result::Ok(num)
     }
 
     fn decode_u16(&self, cursor: &mut Cursor) -> Result<u16, DecodeError> {
-        let num = safe_try!(self.decode_i16(cursor)) as u16;
+        let num = self.decode_i16(cursor)? as u16;
 
         Result::Ok(num)
     }
 
     fn decode_i32(&self, cursor: &mut Cursor) -> Result<i32, DecodeError> {
-        let byte = safe_try!(self.read_byte(cursor));
+        let byte = self.read_byte(cursor)?;
 
         let nbytes = match byte {
             layout::I32_1B | layout::U32_1B => 1,
@@ -223,19 +223,19 @@ impl Decoder {
             _ => svm_sdk_std::panic(),
         };
 
-        let num = safe_try!(self.read_num(cursor, nbytes)) as i32;
+        let num = self.read_num(cursor, nbytes)? as i32;
 
         Result::Ok(num)
     }
 
     fn decode_u32(&self, cursor: &mut Cursor) -> Result<u32, DecodeError> {
-        let num = safe_try!(self.decode_i32(cursor)) as u32;
+        let num = self.decode_i32(cursor)? as u32;
 
         Result::Ok(num)
     }
 
     fn decode_i64(&self, cursor: &mut Cursor) -> Result<i64, DecodeError> {
-        let byte = safe_try!(self.read_byte(cursor));
+        let byte = self.read_byte(cursor)?;
 
         let nbytes = match byte {
             layout::I64_1B | layout::U64_1B => 1,
@@ -249,21 +249,21 @@ impl Decoder {
             _ => svm_sdk_std::panic(),
         };
 
-        let num = safe_try!(self.read_num(cursor, nbytes)) as i64;
+        let num = self.read_num(cursor, nbytes)? as i64;
 
         Result::Ok(num)
     }
 
     fn decode_u64(&self, cursor: &mut Cursor) -> Result<u64, DecodeError> {
-        let num = safe_try!(self.decode_i64(cursor)) as u64;
+        let num = self.decode_i64(cursor)? as u64;
 
         Result::Ok(num)
     }
 
     fn decode_array(&self, cursor: &mut Cursor) -> Result<Value, DecodeError> {
         assert_no_eof!(cursor);
 
-        let len = safe_try!(self.read_byte(cursor));
+        let len = self.read_byte(cursor)?;
 
         let mut values: Vec<Value> = Vec::with_capacity(len as usize);
 
@@ -283,7 +283,7 @@ impl Decoder {
         };
         seq_macro::seq!(n in 0..11 {
             if len > n {
-                let value = safe_try!(self.decode_primitive(cursor));
+                let value = self.decode_primitive(cursor)?;
                 values.push(value);
             }
         });
@@ -304,7 +304,7 @@ impl Decoder {
     fn read_num(&self, cursor: &mut Cursor, nbytes: usize) -> Result<u64, DecodeError> {
         debug_assert!(nbytes > 0 && nbytes <= 8);
 
-        let ptr = safe_try!(self.read_bytes(cursor, nbytes)).as_ptr();
+        let ptr = self.read_bytes(cursor, nbytes)?.as_ptr();
         let slice = unsafe { core::slice::from_raw_parts(ptr, nbytes) };
         let mut data = [0u8; 8];
 
@@ -337,7 +337,7 @@ impl Decoder {
 
     #[inline]
     fn peek_kind(&self, cursor: &mut Cursor) -> Result<TypeKind, DecodeError> {
-        let byte = safe_try!(self.peek(cursor));
+        let byte = self.peek(cursor)?;
 
         let kind = match byte {
             layout::NONE => TypeKind::None,

crates/runtime-ffi/src/api.rs

@@ -60,6 +60,7 @@ pub unsafe extern "C" fn svm_free_result(_result: svm_result_t) {}
 
 /// Creates an account at genesis with a given balance and nonce counter.
 #[no_mangle]
+#[must_use]
 pub unsafe extern "C" fn svm_create_account(
     runtime_ptr: *mut c_void,
     addr: *const u8,
@@ -79,6 +80,7 @@ pub unsafe extern "C" fn svm_create_account(
 
 /// Magically increases an account's balance by the given amount. Used for genesis setup.
 #[no_mangle]
+#[must_use]
 pub unsafe extern "C" fn svm_increase_balance(
     runtime_ptr: *mut c_void,
     addr: *const u8,
@@ -138,7 +140,7 @@ pub unsafe extern "C" fn svm_runtime_create(runtime_ptr: *mut *mut c_void) -> sv
 ///
 /// # Examples
 ///
-/// ```rust, no_run
+/// ```rust
 /// use svm_runtime_ffi::*;
 ///
 /// let mut runtime = std::ptr::null_mut();
@@ -176,7 +178,7 @@ pub unsafe extern "C" fn svm_runtimes_count(count: *mut u64) {
 ///
 /// # Examples
 ///
-/// ```rust, no_run
+/// ```rust
 /// use svm_runtime_ffi::*;
 ///
 /// let mut runtime = std::ptr::null_mut();
@@ -214,7 +216,7 @@ pub unsafe extern "C" fn svm_validate_deploy(
 ///
 /// # Examples
 ///
-/// ```rust, no_run
+/// ```rust
 /// use svm_runtime_ffi::*;
 ///
 /// let mut runtime = std::ptr::null_mut();
@@ -248,7 +250,7 @@ pub unsafe extern "C" fn svm_validate_spawn(
 ///
 /// # Examples
 ///
-/// ```rust, no_run
+/// ```rust
 /// use svm_runtime_ffi::*;
 ///
 /// let mut runtime = std::ptr::null_mut();
@@ -282,7 +284,7 @@ pub unsafe extern "C" fn svm_validate_call(
 ///
 /// # Examples
 ///
-/// ```rust, no_run
+/// ```rust
 /// use svm_runtime_ffi::*;
 ///
 /// let mut runtime = std::ptr::null_mut();
@@ -330,7 +332,7 @@ pub unsafe extern "C" fn svm_deploy(
 ///
 /// # Examples
 ///
-/// ```rust, no_run
+/// ```rust
 /// use svm_runtime_ffi::*;
 ///
 /// let mut runtime = std::ptr::null_mut();
@@ -382,7 +384,7 @@ pub unsafe extern "C" fn svm_spawn(
 ///
 /// # Examples
 ///
-/// ```rust, no_run
+/// ```rust
 /// use svm_runtime_ffi::*;
 ///
 /// let mut runtime = std::ptr::null_mut();
@@ -431,7 +433,7 @@ pub unsafe extern "C" fn svm_verify(
 ///
 /// # Examples
 ///
-/// ```rust, no_run
+/// ```rust
 /// use svm_runtime_ffi::*;
 ///
 /// let mut runtime = std::ptr::null_mut();
@@ -547,7 +549,7 @@ unsafe fn svm_runtime_action<F, C>(
     message_size: u32,
     context: *const u8,
     f: F,
-    f_name: &str,
+    _f_name: &str,
 ) -> svm_result_t
 where
     F: FnOnce(&mut Runtime, &Envelope, &[u8], &Context) -> C + UnwindSafe,
@@ -559,13 +561,10 @@ where
         let envelope = slice::from_raw_parts(envelope, Envelope::fixed_size().unwrap());
         let context = slice::from_raw_parts(context, Context::fixed_size().unwrap());
 
-        debug!("`{}` start", f_name);
-
         let envelope = Envelope::decode_bytes(envelope)?;
         let context = Context::decode_bytes(context)?;
         let receipt = f(runtime, &envelope, &message, &context);
 
-        debug!("`{}` returns `svm_result_t::OK`", f_name);
         svm_result_t::new_receipt(&receipt.encode_to_vec())
     })
 }
@@ -590,7 +589,7 @@ where
                 svm_result_t::OK
             }
             Err(e) => {
-                error!("`{}` returns `SVM_FAILURE`", f_name);
+                error!("`{}` returns an errors", f_name);
                 svm_result_t::new_error(e.to_string().as_bytes())
             }
         }

crates/runtime/tests/wasm/calldata/CallDataTemplate-meta.json

@@ -1 +1 @@
-{"api":[{"doc":"","is_ctor":false,"is_fundable":false,"name":"store_addr","signature":{"params":[{"name":"addr","type":"Address"}],"returns":{}},"wasm_name":"store_addr"},{"doc":"","is_ctor":false,"is_fundable":false,"name":"load_addr","signature":{"params":[],"returns":{"type":"Address"}},"wasm_name":"load_addr"},{"doc":"","is_ctor":true,"is_fundable":false,"name":"initialize","signature":{"params":[{"name":"init","type":"Address"},{"name":"should_store","type":"bool"}],"returns":{"type":"bool"}},"wasm_name":"initialize"}],"schema":[{"byte_count":20,"id":0,"name":"addr","offset":0,"type":"Address"}]}
+{"api":[{"doc":"","is_ctor":true,"is_fundable":false,"name":"initialize","signature":{"params":[{"name":"init","type":"Address"},{"name":"should_store","type":"bool"}],"returns":{"type":"bool"}},"wasm_name":"initialize"},{"doc":"","is_ctor":false,"is_fundable":false,"name":"store_addr","signature":{"params":[{"name":"addr","type":"Address"}],"returns":{}},"wasm_name":"store_addr"},{"doc":"","is_ctor":false,"is_fundable":false,"name":"load_addr","signature":{"params":[],"returns":{"type":"Address"}},"wasm_name":"load_addr"}],"schema":[{"byte_count":20,"id":0,"name":"addr","offset":0,"type":"Address"}]}

crates/sdk-std/src/lib.rs

@@ -22,6 +22,7 @@
 #![deny(unreachable_code)]
 #![deny(rustdoc::broken_intra_doc_links)]
 #![feature(core_intrinsics)]
+#![feature(try_trait_v2)]
 
 mod log;
 pub use log::log;