Sync with Substrate RC6

alloc/src/handlers.rs

@@ -1,4 +1,4 @@
-// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,14 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#[panic_handler]
-pub fn panic(_info: &core::panic::PanicInfo) -> ! {
-    core::intrinsics::abort()
-}
-
-// `extern` fn uses type `core::alloc::Layout`, which is not FFI-safe
-#[allow(improper_ctypes)]
 #[alloc_error_handler]
-pub extern "C" fn oom(_: core::alloc::Layout) -> ! {
+fn oom(_: core::alloc::Layout) -> ! {
     core::intrinsics::abort()
 }

alloc/src/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,7 +15,8 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(not(feature = "std"), feature(alloc_error_handler, core_intrinsics))]
 
-// Use `wee_alloc` as the global allocator.
+// We use `wee_alloc` as the global allocator since it is optimized for binary file size
+// so that contracts compiled with it as allocator do not grow too much in size.
 #[cfg(not(feature = "std"))]
 #[global_allocator]
 static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;

core/Cargo.toml

@@ -73,6 +73,7 @@ std = [
     "blake2",
 ]
 ink-fuzz-tests = ["std"]
+ink-unstable-chain-extensions = []
 
 [[bench]]
 name = "bench_lazy"

core/src/env/api.rs

@@ -17,6 +17,7 @@
 use crate::env::{
     backend::{
         Env,
+        ReturnFlags,
         TypedEnv,
     },
     call::{
@@ -65,12 +66,12 @@ where
 /// # Errors
 ///
 /// If the returned value cannot be properly decoded.
-pub fn gas_price<T>(gas: u64) -> Result<T::Balance>
+pub fn weight_to_fee<T>(gas: u64) -> Result<T::Balance>
 where
     T: EnvTypes,
 {
     <EnvInstance as OnInstance>::on_instance(|instance| {
-        TypedEnv::gas_price::<T>(instance, gas)
+        TypedEnv::weight_to_fee::<T>(instance, gas)
     })
 }
 
@@ -208,6 +209,10 @@ where
 }
 
 /// Writes the value to the contract storage under the given key.
+///
+/// # Panics
+///
+/// - If the encode length of value exceeds the configured maximum value length of a storage entry.
 pub fn set_contract_storage<V>(key: &Key, value: &V)
 where
     V: scale::Encode,
@@ -221,8 +226,8 @@ where
 ///
 /// # Errors
 ///
-/// - If the decoding of the typed value failed
-pub fn get_contract_storage<R>(key: &Key) -> Option<Result<R>>
+/// - If the decoding of the typed value failed (`KeyNotFound`)
+pub fn get_contract_storage<R>(key: &Key) -> Result<Option<R>>
 where
     R: scale::Decode,
 {
@@ -238,25 +243,6 @@ pub fn clear_contract_storage(key: &Key) {
     })
 }
 
-/// Invokes a call to the runtime.
-///
-/// # Note
-///
-/// The call is not guaranteed to execute immediately but might be deferred
-/// to the end of the contract execution.
-///
-/// # Errors
-///
-/// - If the called runtime function does not exist.
-pub fn invoke_runtime<T>(params: &T::Call) -> Result<()>
-where
-    T: EnvTypes,
-{
-    <EnvInstance as OnInstance>::on_instance(|instance| {
-        TypedEnv::invoke_runtime::<T>(instance, params)
-    })
-}
-
 /// Invokes a contract message.
 ///
 /// # Note
@@ -268,7 +254,8 @@ where
 ///
 /// # Errors
 ///
-/// - If the called contract does not exist.
+/// - If the called account does not exist.
+/// - If the called account is not a contract.
 /// - If the called contract is a tombstone.
 /// - If arguments passed to the called contract message are invalid.
 /// - If the called contract execution has trapped.
@@ -292,7 +279,8 @@ where
 ///
 /// # Errors
 ///
-/// - If the called contract does not exist.
+/// - If the called account does not exist.
+/// - If the called account is not a contract.
 /// - If the called contract is a tombstone.
 /// - If arguments passed to the called contract message are invalid.
 /// - If the called contract execution has trapped.
@@ -424,7 +412,7 @@ where
 /// contract call or invoke a runtime function that performs the
 /// transaction.
 ///
-/// # Errors
+/// # Panics
 ///
 /// If the contract doesn't have sufficient funds.
 pub fn transfer<T>(destination: T::AccountId, value: T::Balance) -> Result<()>
@@ -436,6 +424,27 @@ where
     })
 }
 
+/// Calls the chain extension with the given ID and inputs.
+///
+/// Returns the given output type.
+///
+/// # Errors
+///
+/// - If the given function ID does not exist in the runtime.
+/// - If the given inputs cannot be properly decoded by the runtime.
+/// - If the given output type cannot be properly decoded by the contract.
+/// - If some chain extension specific conditions are not met.
+#[cfg(feature = "ink-unstable-chain-extensions")]
+pub fn call_chain_extension<I, O>(func_id: u32, input: &I) -> Result<O>
+where
+    I: scale::Codec + 'static,
+    O: scale::Codec + 'static,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        Env::call_chain_extension(instance, func_id, input)
+    })
+}
+
 /// Returns the execution input to the executed contract and decodes it as `T`.
 ///
 /// # Note
@@ -470,14 +479,13 @@ where
 ///
 /// # Note
 ///
-/// This call must be the last call to the contract
-/// environment for every contract execution.
-pub fn output<R>(return_value: &R)
+/// This function  stops the execution of the contract immediately.
+pub fn return_value<R>(return_flags: ReturnFlags, return_value: &R) -> !
 where
     R: scale::Encode,
 {
     <EnvInstance as OnInstance>::on_instance(|instance| {
-        Env::output::<R>(instance, return_value)
+        Env::return_value::<R>(instance, return_flags, return_value)
     })
 }
 
@@ -505,20 +513,6 @@ pub fn println(content: &str) {
     <EnvInstance as OnInstance>::on_instance(|instance| Env::println(instance, content))
 }
 
-/// Returns the value from the *runtime* storage at the position of the key if any.
-///
-/// # Errors
-///
-/// - If the decoding of the typed value failed
-pub fn get_runtime_storage<R>(runtime_key: &[u8]) -> Option<Result<R>>
-where
-    R: scale::Decode,
-{
-    <EnvInstance as OnInstance>::on_instance(|instance| {
-        Env::get_runtime_storage::<R>(instance, runtime_key)
-    })
-}
-
 /// Built-in efficient cryptographic hash functions.
 pub mod hash {
     use super::*;

core/src/env/backend.rs

@@ -24,6 +24,33 @@ use crate::env::{
 };
 use ink_primitives::Key;
 
+/// The flags to indicate further information about the end of a contract execution.
+pub struct ReturnFlags {
+    value: u32,
+}
+
+impl Default for ReturnFlags {
+    fn default() -> Self {
+        Self { value: 0 }
+    }
+}
+
+impl ReturnFlags {
+    /// Sets the bit to indicate that the execution is going to be reverted.
+    pub fn set_reverted(mut self, has_reverted: bool) -> Self {
+        match has_reverted {
+            true => self.value |= has_reverted as u32,
+            false => self.value &= !has_reverted as u32,
+        }
+        self
+    }
+
+    /// Returns the underlying `u32` representation.
+    pub(crate) fn into_u32(self) -> u32 {
+        self.value
+    }
+}
+
 /// Environmental contract functionality that does not require `EnvTypes`.
 pub trait Env {
     /// Writes the value to the contract storage under the given key.
@@ -36,22 +63,13 @@ pub trait Env {
     /// # Errors
     ///
     /// - If the decoding of the typed value failed
-    fn get_contract_storage<R>(&mut self, key: &Key) -> Option<Result<R>>
+    fn get_contract_storage<R>(&mut self, key: &Key) -> Result<Option<R>>
     where
         R: scale::Decode;
 
     /// Clears the contract's storage key entry.
     fn clear_contract_storage(&mut self, key: &Key);
 
-    /// Returns the value from the *runtime* storage at the position of the key if any.
-    ///
-    /// # Errors
-    ///
-    /// - If the decoding of the typed value failed
-    fn get_runtime_storage<R>(&mut self, runtime_key: &[u8]) -> Option<Result<R>>
-    where
-        R: scale::Decode;
-
     /// Returns the execution input to the executed contract and decodes it as `T`.
     ///
     /// # Note
@@ -83,10 +101,12 @@ pub trait Env {
     ///
     /// # Note
     ///
-    /// The setting of this property must be the last interaction between
-    /// the executed contract and its environment.
-    /// The environment access asserts this guarantee.
-    fn output<R>(&mut self, return_value: &R)
+    /// Calling this method will end contract execution immediately.
+    /// It will return the given return value back to its caller.
+    ///
+    /// The `flags` parameter can be used to revert the state changes of the
+    /// entire execution if necessary.
+    fn return_value<R>(&mut self, flags: ReturnFlags, return_value: &R) -> !
     where
         R: scale::Encode;
 
@@ -108,6 +128,22 @@ pub trait Env {
     /// Conducts the BLAKE2 128-bit hash of the input
     /// puts the result into the output buffer.
     fn hash_blake2_128(input: &[u8], output: &mut [u8; 16]);
+
+    /// Calls the chain extension with the given ID and inputs.
+    ///
+    /// Returns the output of the chain extension of the specified type.
+    ///
+    /// # Errors
+    ///
+    /// - If the chain extension with the given ID does not exist.
+    /// - If the inputs had an unexpected encoding.
+    /// - If the output could not be properly decoded.
+    /// - If some extension specific condition has not been met.
+    #[cfg(feature = "ink-unstable-chain-extensions")]
+    fn call_chain_extension<I, O>(&mut self, func_id: u32, input: &I) -> Result<O>
+    where
+        I: scale::Codec + 'static,
+        O: scale::Codec + 'static;
 }
 
 /// Environmental contract functionality.
@@ -131,7 +167,7 @@ pub trait TypedEnv: Env {
     /// # Note
     ///
     /// For more details visit: [`ink_core::env::gas_price`]
-    fn gas_price<T: EnvTypes>(&mut self, gas: u64) -> Result<T::Balance>;
+    fn weight_to_fee<T: EnvTypes>(&mut self, gas: u64) -> Result<T::Balance>;
 
     /// Returns the amount of gas left for the contract execution.
     ///
@@ -208,15 +244,6 @@ pub trait TypedEnv: Env {
     where
         T: EnvTypes;
 
-    /// Invokes a call of the runtime.
-    ///
-    /// # Note
-    ///
-    /// For more details visit: [`ink_core::env::invoke_runtime`]
-    fn invoke_runtime<T>(&mut self, call: &T::Call) -> Result<()>
-    where
-        T: EnvTypes;
-
     /// Invokes a contract message.
     ///
     /// # Note