Drink backend: support runtime call

Cargo.toml

@@ -38,7 +38,7 @@ cargo_metadata = { version = "0.17.0" }
 cfg-if = { version = "1.0" }
 contract-build = { version = "3.2.0" }
 derive_more = { version = "0.99.17", default-features = false }
-drink = { version = "0.1.2" }
+drink = { version = "=0.1.3" }
 either = { version = "1.5", default-features = false }
 funty = { version = "2.0.0" }
 heck = { version = "0.4.0" }
@@ -66,6 +66,7 @@ sha2 = { version = "0.10" }
 sha3 = { version = "0.10" }
 static_assertions = { version = "1.1" }
 subxt = { version = "0.31.0" }
+subxt-metadata = { version = "0.31.0" }
 subxt-signer = { version = "0.31.0" }
 syn = { version = "2" }
 synstructure = { version = "0.13.0" }

crates/e2e/Cargo.toml

@@ -33,6 +33,7 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
 scale = { package = "parity-scale-codec", workspace = true }
 subxt = { workspace = true }
+subxt-metadata = { workspace = true }
 subxt-signer = { workspace = true, features = ["subxt", "sr25519"] }
 wasm-instrument = { workspace = true }
 

crates/e2e/src/backend.rs

@@ -73,6 +73,9 @@ pub trait ChainBackend {
     ///
     /// Returns when the transaction is included in a block. The return value contains all
     /// events that are associated with this transaction.
+    ///
+    /// Since we might run node with an arbitrary runtime, this method inherently must
+    /// support dynamic calls.
     async fn runtime_call<'a>(
         &mut self,
         origin: &Keypair,

crates/e2e/src/drink_client.rs

@@ -18,7 +18,10 @@ use crate::{
     UploadResult,
 };
 use drink::{
-    chain_api::ChainApi,
+    chain_api::{
+        ChainApi,
+        RuntimeCall,
+    },
     contract_api::ContractApi,
     runtime::{
         MinimalRuntime,
@@ -48,7 +51,10 @@ use std::{
     marker::PhantomData,
     path::PathBuf,
 };
-use subxt::dynamic::Value;
+use subxt::{
+    dynamic::Value,
+    tx::TxPayload,
+};
 use subxt_signer::sr25519::Keypair;
 
 pub struct Client<AccountId, Hash> {
@@ -121,12 +127,39 @@ impl<AccountId: AsRef<[u8; 32]> + Send, Hash> ChainBackend for Client<AccountId,
 
     async fn runtime_call<'a>(
         &mut self,
-        _origin: &Keypair,
-        _pallet_name: &'a str,
-        _call_name: &'a str,
-        _call_data: Vec<Value>,
+        origin: &Keypair,
+        pallet_name: &'a str,
+        call_name: &'a str,
+        call_data: Vec<Value>,
     ) -> Result<Self::EventLog, Self::Error> {
-        todo!("https://github.com/Cardinal-Cryptography/drink/issues/36")
+        // Since in general, `ChainBackend::runtime_call` must be dynamic, we have to
+        // perform some translation here in order to invoke strongly-typed drink!
+        // API.
+
+        // Get metadata of the drink! runtime, so that we can encode the call object.
+        // Panic on error - metadata of the static im-memory runtime should always be
+        // available.
+        let raw_metadata: Vec<u8> = MinimalRuntime::metadata().into();
+        let metadata = subxt_metadata::Metadata::decode(&mut raw_metadata.as_slice())
+            .expect("Failed to decode metadata");
+
+        // Encode the call object.
+        let call = subxt::dynamic::tx(pallet_name, call_name, call_data);
+        let encoded_call = call.encode_call_data(&metadata.into()).map_err(|_| ())?;
+
+        // Decode the call object.
+        // Panic on error - we just encoded a validated call object, so it should be
+        // decodable.
+        let decoded_call =
+            RuntimeCall::<MinimalRuntime>::decode(&mut encoded_call.as_slice())
+                .expect("Failed to decode runtime call");
+
+        // Execute the call.
+        self.sandbox
+            .runtime_call(decoded_call, Some(keypair_to_account(origin)).into())
+            .map_err(|_| ())?;
+
+        Ok(())
     }
 }
 

integration-tests/e2e-runtime-only-backend/lib.rs

@@ -31,20 +31,44 @@ pub mod flipper {
         pub fn get(&self) -> bool {
             self.value
         }
+
+        /// Returns the current balance of the Flipper.
+        #[ink(message)]
+        pub fn get_contract_balance(&self) -> Balance {
+            self.env().balance()
+        }
     }
 
     #[cfg(all(test, feature = "e2e-tests"))]
     mod e2e_tests {
         use super::*;
-        use ink_e2e::ContractsBackend;
+        use ink::env::DefaultEnvironment;
+        use ink_e2e::{
+            subxt::dynamic::Value,
+            ChainBackend,
+            ContractsBackend,
+            E2EBackend,
+            InstantiationResult,
+        };
 
         type E2EResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 
-        #[ink_e2e::test(backend = "runtime-only")]
-        async fn it_works<Client: E2EBackend>(mut client: Client) -> E2EResult<()> {
-            // given
-            let constructor = FlipperRef::new(false);
-            let contract = client
+        /// Deploys the flipper contract with `initial_value` and returns the contract
+        /// instantiation result.
+        ///
+        /// Uses `ink_e2e::alice()` as the caller.
+        async fn deploy<Client: E2EBackend>(
+            client: &mut Client,
+            initial_value: bool,
+        ) -> Result<
+            InstantiationResult<
+                DefaultEnvironment,
+                <Client as ContractsBackend<DefaultEnvironment>>::EventLog,
+            >,
+            <Client as ContractsBackend<DefaultEnvironment>>::Error,
+        > {
+            let constructor = FlipperRef::new(initial_value);
+            client
                 .instantiate(
                     "e2e-runtime-only-backend",
                     &ink_e2e::alice(),
@@ -53,11 +77,23 @@ pub mod flipper {
                     None,
                 )
                 .await
-                .expect("instantiate failed");
+        }
 
-            let mut call = contract.call::<Flipper>();
+        /// Tests standard flipper scenario:
+        /// - deploy the flipper contract with initial value `false`
+        /// - flip the flipper
+        /// - get the flipper's value
+        /// - assert that the value is `true`
+        #[ink_e2e::test(backend = "runtime-only")]
+        async fn it_works<Client: E2EBackend>(mut client: Client) -> E2EResult<()> {
+            // given
+            const INITIAL_VALUE: bool = false;
+            let contract = deploy(&mut client, INITIAL_VALUE)
+                .await
+                .expect("deploy failed");
 
             // when
+            let mut call = contract.call::<Flipper>();
             let _flip_res = client
                 .call(&ink_e2e::bob(), &call.flip(), 0, None)
                 .await
@@ -68,9 +104,49 @@ pub mod flipper {
                 .call(&ink_e2e::bob(), &call.get(), 0, None)
                 .await
                 .expect("get failed");
+            assert_eq!(get_res.return_value(), !INITIAL_VALUE);
 
-            assert!(matches!(get_res.return_value(), true));
+            Ok(())
+        }
+
+        /// Tests runtime call scenario:
+        /// - deploy the flipper contract
+        /// - get the contract's balance
+        /// - transfer some funds to the contract using runtime call
+        /// - get the contract's balance again
+        /// - assert that the contract's balance increased by the transferred amount
+        #[ink_e2e::test(backend = "runtime-only")]
+        async fn runtime_call_works() -> E2EResult<()> {
+            // given
+            let contract = deploy(&mut client, false).await.expect("deploy failed");
+            let call = contract.call::<Flipper>();
+
+            let old_balance = client
+                .call(&ink_e2e::alice(), &call.get_contract_balance(), 0, None)
+                .await
+                .expect("get_contract_balance failed")
+                .return_value();
+
+            const ENDOWMENT: u128 = 10;
+
+            // when
+            let call_data = vec![
+                Value::from_bytes(&contract.account_id),
+                Value::u128(ENDOWMENT),
+            ];
+            client
+                .runtime_call(&ink_e2e::alice(), "Balances", "transfer", call_data)
+                .await
+                .expect("runtime call failed");
+
+            // then
+            let new_balance = client
+                .call(&ink_e2e::alice(), &call.get_contract_balance(), 0, None)
+                .await
+                .expect("get_contract_balance failed")
+                .return_value();
 
+            assert_eq!(old_balance + ENDOWMENT, new_balance);
             Ok(())
         }
     }