allow_reentrancy attribute

.gitignore

@@ -14,5 +14,7 @@
 # More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
 Cargo.lock
 
+.idea
+
 # Ignore history files.
 **/.history/**

README.md

@@ -231,6 +231,7 @@ In a module annotated with `#[ink::contract]` these attributes are available:
 | `#[ink(anonymous)]` | Applicable to ink! events. | Tells the ink! codegen to treat the ink! event as anonymous which omits the event signature as topic upon emitting. Very similar to anonymous events in Solidity. |
 | `#[ink(topic)]` | Applicable on ink! event field. | Tells the ink! codegen to provide a topic hash for the given field. Every ink! event can only have a limited number of such topic fields. Similar semantics as to indexed event arguments in Solidity. |
 | `#[ink(payable)]` | Applicable to ink! messages. | Allows receiving value as part of the call of the ink! message. ink! constructors are implicitly payable. |
+| `#[ink(allow_reentrancy)]` | Applicable to ink! messages. | Allows the ink! message to be called reentrantly. |
 | `#[ink(selector = S:u32)]` | Applicable to ink! messages and ink! constructors. | Specifies a concrete dispatch selector for the flagged entity. This allows a contract author to precisely control the selectors of their APIs making it possible to rename their API without breakage. |
 | `#[ink(selector = _)]` | Applicable to ink! messages. | Specifies a fallback message that is invoked if no other ink! message matches a selector. |
 | `#[ink(namespace = N:string)]` | Applicable to ink! trait implementation blocks. | Changes the resulting selectors of all the ink! messages and ink! constructors within the trait implementation. Allows to disambiguate between trait implementations with overlapping message or constructor names. Use only with great care and consideration! |

crates/env/src/api.rs

@@ -768,3 +768,13 @@ where
         TypedEnvBackend::call_runtime::<E, _>(instance, call)
     })
 }
+
+/// Returns how many times caller exists on call stack.
+pub fn reentrance_count<E>() -> u32
+where
+    E: Environment,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        TypedEnvBackend::reentrance_count::<E>(instance)
+    })
+}

crates/env/src/backend.rs

@@ -62,14 +62,25 @@ impl ReturnFlags {
 
 /// The flags used to change the behavior of a contract call.
 #[must_use]
-#[derive(Copy, Clone, Debug, Default)]
+#[derive(Copy, Clone, Debug)]
 pub struct CallFlags {
     forward_input: bool,
     clone_input: bool,
     tail_call: bool,
     allow_reentry: bool,
 }
 
+impl Default for CallFlags {
+    fn default() -> Self {
+        Self {
+            forward_input: false,
+            clone_input: false,
+            tail_call: false,
+            allow_reentry: true,
+        }
+    }
+}
+
 impl CallFlags {
     /// Forwards the input for the current function to the callee.
     ///
@@ -109,13 +120,13 @@ impl CallFlags {
         self
     }
 
-    /// Allow the callee to reenter into the current contract.
+    /// Disallow the callee to reenter into the current contract.
     ///
     /// Without this flag any reentrancy into the current contract that originates from
-    /// the callee (or any of its callees) is denied. This includes the first callee:
+    /// the callee (or any of its callees) is allowed. This includes the first callee:
     /// You cannot call into yourself with this flag set.
-    pub const fn set_allow_reentry(mut self, allow_reentry: bool) -> Self {
-        self.allow_reentry = allow_reentry;
+    pub const fn set_deny_reentry(mut self, deny_reentry: bool) -> Self {
+        self.allow_reentry = !deny_reentry;
         self
     }
 
@@ -162,8 +173,8 @@ impl CallFlags {
     /// # Note
     ///
     /// See [`Self::set_allow_reentry`] for more information.
-    pub const fn allow_reentry(&self) -> bool {
-        self.allow_reentry
+    pub const fn deny_reentry(&self) -> bool {
+        !self.allow_reentry
     }
 }
 
@@ -520,4 +531,8 @@ pub trait TypedEnvBackend: EnvBackend {
     where
         E: Environment,
         Call: scale::Encode;
+
+    fn reentrance_count<E>(&mut self) -> u32
+    where
+        E: Environment;
 }

crates/env/src/engine/off_chain/impls.rs

@@ -550,4 +550,11 @@ impl TypedEnvBackend for EnvInstance {
     {
         unimplemented!("off-chain environment does not support `call_runtime`")
     }
+
+    fn reentrance_count<E>(&mut self) -> u32
+    where
+        E: Environment,
+    {
+        unimplemented!("off-chain environment does not support `reentrance_count`")
+    }
 }

crates/env/src/engine/on_chain/ext/riscv32.rs

@@ -372,6 +372,11 @@ pub fn ecdsa_to_eth_address(pubkey: &[u8; 33], output: &mut [u8; 20]) -> Result
     ret_code.into()
 }
 
+pub fn reentrance_count() -> u32 {
+    let ret_val = sys::call0(FUNC_ID);
+    ret_val.into_u32()
+}
+
 pub fn is_contract(account_id: &[u8]) -> bool {
     let ret_val = sys::call(FUNC_ID, Ptr32::from_slice(account_id));
     ret_val.into_bool()

crates/env/src/engine/on_chain/ext/wasm32.rs

@@ -155,6 +155,8 @@ mod sys {
 
         #[cfg(feature = "call-runtime")]
         pub fn call_runtime(call_ptr: Ptr32<[u8]>, call_len: u32) -> ReturnCode;
+
+        pub fn reentrance_count() -> ReturnCode;
     }
 
     #[link(wasm_import_module = "seal1")]
@@ -597,6 +599,11 @@ pub fn ecdsa_to_eth_address(pubkey: &[u8; 33], output: &mut [u8; 20]) -> Result
     ret_code.into()
 }
 
+pub fn reentrance_count() -> u32 {
+    let ret_code = unsafe { sys::reentrance_count() };
+    ret_code.into_u32()
+}
+
 pub fn is_contract(account_id: &[u8]) -> bool {
     let ret_val = unsafe { sys::is_contract(Ptr32::from_slice(account_id)) };
     ret_val.into_bool()

crates/env/src/engine/on_chain/impls.rs

@@ -588,4 +588,11 @@ impl TypedEnvBackend for EnvInstance {
         let enc_call = scope.take_encoded(call);
         ext::call_runtime(enc_call).map_err(Into::into)
     }
+
+    fn reentrance_count<E>(&mut self) -> u32
+    where
+        E: Environment,
+    {
+        ext::reentrance_count()
+    }
 }

crates/env/src/tests.rs

@@ -70,34 +70,34 @@ fn test_call_flags() {
     // enable each flag one after the other
     let flags = flags.set_forward_input(true);
     assert!(flags.forward_input());
-    assert_eq!(flags.into_u32(), 0b0000_0001);
+    assert_eq!(flags.into_u32(), 0b0000_1001);
 
     let flags = flags.set_clone_input(true);
     assert!(flags.clone_input());
-    assert_eq!(flags.into_u32(), 0b0000_0011);
+    assert_eq!(flags.into_u32(), 0b0000_1011);
 
     let flags = flags.set_tail_call(true);
     assert!(flags.tail_call());
-    assert_eq!(flags.into_u32(), 0b0000_0111);
-
-    let flags = flags.set_allow_reentry(true);
-    assert!(flags.allow_reentry());
     assert_eq!(flags.into_u32(), 0b0000_1111);
 
-    // disable each flag one after the other
-    let flags = flags.set_allow_reentry(false);
-    assert!(!flags.allow_reentry());
+    let flags = flags.set_deny_reentry(true);
+    assert!(flags.deny_reentry());
     assert_eq!(flags.into_u32(), 0b0000_0111);
 
+    // disable each flag one after the other
+    let flags = flags.set_deny_reentry(false);
+    assert!(!flags.deny_reentry());
+    assert_eq!(flags.into_u32(), 0b0000_1111);
+
     let flags = flags.set_tail_call(false);
     assert!(!flags.tail_call());
-    assert_eq!(flags.into_u32(), 0b0000_0011);
+    assert_eq!(flags.into_u32(), 0b0000_1011);
 
     let flags = flags.set_clone_input(false);
     assert!(!flags.clone_input());
-    assert_eq!(flags.into_u32(), 0b0000_0001);
+    assert_eq!(flags.into_u32(), 0b0000_1001);
 
     let flags = flags.set_forward_input(false);
     assert!(!flags.forward_input());
-    assert_eq!(flags.into_u32(), 0b0000_0000);
+    assert_eq!(flags.into_u32(), 0b0000_1000);
 }