Support call_runtime

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+### Added
+- `call-runtime` support
+
 ## Version 4.0.0-rc
 
 The first release candidate is here! This is the first release which could become the final 

crates/env/Cargo.toml

@@ -70,5 +70,6 @@ std = [
     "sha3",
     "blake2",
 ]
+call-runtime = []
 # Enable contract debug messages via `debug_print!` and `debug_println!`.
 ink-debug = []

crates/env/src/api.rs

@@ -700,3 +700,21 @@ where
 pub fn set_code_hash(code_hash: &[u8; 32]) -> Result<()> {
     <EnvInstance as OnInstance>::on_instance(|instance| instance.set_code_hash(code_hash))
 }
+
+/// Tries to dispatch a pallet call.
+///
+/// # Errors
+///
+/// - If the call cannot be properly decoded on the pallet contracts side.
+/// - If the runtime doesn't allow for the contract unstable feature.
+/// - If the runtime doesn't allow for dispatching this call from a contract.
+#[cfg(feature = "call-runtime")]
+pub fn call_runtime<E, Call>(call: &Call) -> Result<()>
+where
+    E: Environment,
+    Call: scale::Encode,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        TypedEnvBackend::call_runtime::<E, _>(instance, call)
+    })
+}

crates/env/src/backend.rs

@@ -510,4 +510,10 @@ pub trait TypedEnvBackend: EnvBackend {
     fn own_code_hash<E>(&mut self) -> Result<E::Hash>
     where
         E: Environment;
+
+    #[cfg(feature = "call-runtime")]
+    fn call_runtime<E, Call>(&mut self, call: &Call) -> Result<()>
+    where
+        E: Environment,
+        Call: scale::Encode;
 }

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

@@ -541,4 +541,12 @@ impl TypedEnvBackend for EnvInstance {
     {
         unimplemented!("off-chain environment does not support `own_code_hash`")
     }
+
+    #[cfg(feature = "call-runtime")]
+    fn call_runtime<E, Call>(&mut self, _call: &Call) -> Result<()>
+    where
+        E: Environment,
+    {
+        unimplemented!("off-chain environment does not support `call runtime`")
+    }
 }

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

@@ -76,6 +76,8 @@ define_error_codes! {
      /// The call to `debug_message` had no effect because debug message
     /// recording was disabled.
     LoggingDisabled = 9,
+    /// The call dispatched by `call_runtime` was executed but returned an error.
+    CallRuntimeReturned = 10,
     /// ECDSA public key recovery failed. Most probably wrong recovery id or signature.
     EcdsaRecoveryFailed = 11,
 }
@@ -325,6 +327,9 @@ mod sys {
             out_ptr: Ptr32Mut<[u8]>,
             out_len_ptr: Ptr32Mut<u32>,
         ) -> ReturnCode;
+
+        #[cfg(feature = "call-runtime")]
+        pub fn call_runtime(call_ptr: Ptr32<[u8]>, call_len: u32) -> ReturnCode;
     }
 
     #[link(wasm_import_module = "seal1")]
@@ -639,6 +644,13 @@ pub fn return_value(flags: ReturnFlags, return_value: &[u8]) -> ! {
     }
 }
 
+#[cfg(feature = "call-runtime")]
+pub fn call_runtime(call: &[u8]) -> Result {
+    let ret_code =
+        unsafe { sys::call_runtime(Ptr32::from_slice(call), call.len() as u32) };
+    ret_code.into()
+}
+
 macro_rules! impl_wrapper_for {
     ( $( $name:ident, )* ) => {
         $(

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

@@ -111,6 +111,7 @@ impl From<ext::Error> for Error {
             ext::Error::CodeNotFound => Self::CodeNotFound,
             ext::Error::NotCallable => Self::NotCallable,
             ext::Error::LoggingDisabled => Self::LoggingDisabled,
+            ext::Error::CallRuntimeReturned => Self::CallRuntimeReturned,
             ext::Error::EcdsaRecoveryFailed => Self::EcdsaRecoveryFailed,
         }
     }
@@ -575,4 +576,15 @@ impl TypedEnvBackend for EnvInstance {
         let hash = scale::Decode::decode(&mut &output[..])?;
         Ok(hash)
     }
+
+    #[cfg(feature = "call-runtime")]
+    fn call_runtime<E, Call>(&mut self, call: &Call) -> Result<()>
+    where
+        E: Environment,
+        Call: scale::Encode,
+    {
+        let mut scope = self.scoped_buffer();
+        let enc_call = scope.take_encoded(call);
+        ext::call_runtime(enc_call).map_err(Into::into)
+    }
 }

crates/env/src/error.rs

@@ -47,6 +47,8 @@ pub enum Error {
     /// The call to `debug_message` had no effect because debug message
     /// recording was disabled.
     LoggingDisabled,
+    /// The call dispatched by `call_runtime` was executed but returned an error.
+    CallRuntimeReturned,
     /// ECDSA pubkey recovery failed. Most probably wrong recovery id or signature.
     EcdsaRecoveryFailed,
 }

crates/ink/Cargo.toml

@@ -49,4 +49,5 @@ std = [
 ink-debug = [
     "ink_env/ink-debug",
 ]
+call-runtime = ["ink_env/call-runtime"]
 show-codegen-docs = []

crates/ink/src/env_access.rs

@@ -969,4 +969,9 @@ where
     pub fn own_code_hash(self) -> Result<E::Hash> {
         ink_env::own_code_hash::<E>()
     }
+
+    #[cfg(feature = "call-runtime")]
+    pub fn call_runtime<Call: scale::Encode>(self, call: &Call) -> Result<()> {
+        ink_env::call_runtime::<E, _>(call)
+    }
 }

examples/call-runtime/.gitignore

@@ -0,0 +1,9 @@
+# Ignore build artifacts from the local tests sub-crate.
+/target/
+
+# Ignore backup files creates by cargo fmt.
+**/*.rs.bk
+
+# Remove Cargo.lock when creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

examples/call-runtime/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "call-runtime"
+version = "4.0.0-rc"
+authors = ["Parity Technologies <[email protected]>"]
+edition = "2021"
+publish = false
+
+[dependencies]
+ink = { path = "../../crates/ink", default-features = false, features = ["call-runtime"] }
+
+scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
+scale-info = { version = "2.3", default-features = false, features = ["derive"], optional = true }
+sp-io = { version = "12.0.0", default-features = false, features = ["disable_panic_handler", "disable_oom", "disable_allocator"] }
+sp-runtime = { version = "12.0.0", default-features = false }
+
+[dev-dependencies]
+ink_e2e = { path = "../../crates/e2e" }
+
+[lib]
+name = "call_runtime"
+path = "lib.rs"
+crate-type = ["cdylib"]
+
+[features]
+default = ["std"]
+std = [
+    "ink/std",
+    "scale/std",
+    "scale-info/std",
+    "sp-runtime/std",
+    "sp-io/std",
+]
+ink-as-dependency = []
+e2e-tests = []

examples/call-runtime/README.md

@@ -0,0 +1,19 @@
+# `call-runtime` example
+
+## What is this example about?
+
+It demonstrates how to call a runtime dispatchable from an ink! contract.
+
+## Chain-side configuration
+
+To integrate this example into Substrate you need to adjust pallet contracts configuration in your runtime:
+  `pallet_contracts::Config`:
+  ```rust
+  impl pallet_contracts::Config for Runtime {
+    …
+    // `Everything` or anything that will allow for Balances::transfer extrinsic
+    type CallFilter = frame_support::traits::Everything; 
+    type UnsafeUnstableInterface = ConstBool<true>;
+    …
+  }
+  ```

examples/call-runtime/lib.rs

@@ -0,0 +1,155 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use ink::primitives::AccountId;
+use sp_runtime::MultiAddress;
+
+#[derive(scale::Encode)]
+enum RuntimeCall {
+    #[codec(index = 4)]
+    Balances(BalancesCall),
+}
+
+#[derive(scale::Encode)]
+enum BalancesCall {
+    #[codec(index = 0)]
+    Transfer {
+        dest: MultiAddress<AccountId, ()>,
+        #[codec(compact)]
+        value: u128,
+    },
+}
+
+#[ink::contract]
+mod runtime_call {
+    use crate::{
+        BalancesCall,
+        RuntimeCall,
+    };
+
+    #[ink(storage)]
+    #[derive(Default)]
+    pub struct RuntimeCaller;
+
+    impl RuntimeCaller {
+        #[ink(constructor, payable)]
+        pub fn new() -> Self {
+            Self {}
+        }
+
+        #[ink(message)]
+        pub fn make_transfer_through_runtime(
+            &mut self,
+            receiver: AccountId,
+            value: Balance,
+        ) {
+            self.env()
+                .call_runtime(&RuntimeCall::Balances(BalancesCall::Transfer {
+                    dest: receiver.into(),
+                    value,
+                }))
+                .expect("Should succeed");
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+        use ink::env::{
+            test::default_accounts,
+            DefaultEnvironment,
+        };
+
+        #[ink::test]
+        #[should_panic(
+            expected = "off-chain environment does not support `call runtime`"
+        )]
+        fn cannot_call_runtime_off_chain() {
+            let mut contract = RuntimeCaller::new();
+            contract.make_transfer_through_runtime(
+                default_accounts::<DefaultEnvironment>().bob,
+                10,
+            );
+        }
+    }
+
+    #[cfg(all(test, feature = "e2e-tests"))]
+    mod e2e_tests {
+        use super::*;
+        use ink::{
+            env::{
+                test::default_accounts,
+                DefaultEnvironment,
+            },
+            primitives::AccountId,
+        };
+        use ink_e2e::build_message;
+
+        type E2EResult<T> = Result<T, Box<dyn std::error::Error>>;
+
+        const CONTRACT_BALANCE: Balance = 1_000_000_000_000_000;
+        const TRANSFER_VALUE: Balance = 1_000_000_000;
+
+        #[ink_e2e::test]
+        #[ignore = "Requires that the pallet contract is configured with:\
+            - `CallFilter` allowing for a transfer, e.g. `frame_support::traits::Everything`,\
+            - `UnsafeUnstableInterface = ConstBool<true>`"]
+        async fn it_works(mut client: Client<C, E>) -> E2EResult<()> {
+            // given
+            let constructor = RuntimeCallerRef::new();
+            let contract_acc_id = client
+                .instantiate(
+                    "call-runtime",
+                    &ink_e2e::alice(),
+                    constructor,
+                    CONTRACT_BALANCE,
+                    None,
+                )
+                .await
+                .expect("instantiate failed")
+                .account_id;
+
+            let receiver: AccountId = default_accounts::<DefaultEnvironment>().bob;
+
+            let contract_balance_before = client
+                .balance(contract_acc_id)
+                .await
+                .expect("Failed to get account balance");
+            let receiver_balance_before = client
+                .balance(receiver)
+                .await
+                .expect("Failed to get account balance");
+
+            // when
+            let transfer_message = build_message::<RuntimeCallerRef>(contract_acc_id)
+                .call(|caller| {
+                    caller.make_transfer_through_runtime(receiver, TRANSFER_VALUE)
+                });
+
+            let _call_res = client
+                .call(&ink_e2e::alice(), transfer_message, 0, None)
+                .await
+                .expect("call failed");
+
+            // then
+            let contract_balance_after = client
+                .balance(contract_acc_id)
+                .await
+                .expect("Failed to get account balance");
+            let receiver_balance_after = client
+                .balance(receiver)
+                .await
+                .expect("Failed to get account balance");
+
+            assert_eq!(
+                contract_balance_before,
+                contract_balance_after + TRANSFER_VALUE
+            );
+            assert_eq!(
+                receiver_balance_before + TRANSFER_VALUE,
+                receiver_balance_after
+            );
+
+            Ok(())
+        }
+    }
+}