Merge branch 'master' into aj/e2e-call-dry-run

Author: ascjones

.rustfmt.toml

@@ -34,7 +34,7 @@ struct_field_align_threshold = 0
 enum_discrim_align_threshold = 0
 match_arm_blocks = true
 force_multiline_blocks = true # changed
-fn_args_layout = "Tall"
+fn_params_layout = "Tall"
 brace_style = "SameLineWhere"
 control_brace_style = "AlwaysSameLine"
 trailing_semicolon = false # changed

ARCHITECTURE.md

@@ -22,8 +22,7 @@ ink! is composed of a number of crates that are all found in the
 * [`env`](https://github.com/paritytech/ink/tree/master/crates/env):
   Serves two roles:
   * Exposes environmental functions, like information about the caller
-    of a contract call, getting random entropy, or e.g. self-terminating the
-    contract.
+    of a contract call or e.g. self-terminating the contract.
   * Provides the connection to the [`pallet-contracts`](https://github.com/paritytech/substrate/tree/master/frame/contracts),
     so anything that calls into the underlying execution engine of the smart contract.
     This includes getting and setting a smart contracts storage, as well

crates/e2e/Cargo.toml

@@ -21,6 +21,7 @@ ink_env = { version = "4.0.0-beta.1", path = "../env" }
 ink_primitives = { version = "4.0.0-beta.1", path = "../primitives" }
 
 contract-metadata = { version = "2.0.0-rc" }
+funty = "2.0.0"
 impl-serde = { version = "0.3.1", default-features = false }
 jsonrpsee = { version = "0.16.0", features = ["ws-client"] }
 serde = { version = "1.0.137", default-features = false, features = ["derive"] }
@@ -29,14 +30,14 @@ tokio = { version = "1.18.2", features = ["rt-multi-thread"] }
 log = { version = "0.4" }
 env_logger = { version = "0.10" }
 scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive", "full"] }
-subxt = "0.25.0"
+subxt = "0.26.0"
 
 # Substrate
-pallet-contracts-primitives = "7.0.0"
-sp-core = "7.0.0"
-sp-keyring = "7.0.0"
-sp-runtime = "7.0.0"
-sp-weights = "4.0.0"
+pallet-contracts-primitives = "12.0.0"
+sp-core = "11.0.0"
+sp-keyring = "12.0.0"
+sp-runtime = "12.0.0"
+sp-weights = "8.0.0"
 
 [dev-dependencies]
 # Required for the doctest of `MessageBuilder::call`

crates/e2e/macro/src/codegen.rs

@@ -186,7 +186,7 @@ fn build_contract(path_to_cargo_toml: &str) -> String {
     };
 
     let manifest_path = ManifestPath::new(path_to_cargo_toml).unwrap_or_else(|err| {
-        panic!("Invalid manifest path {}: {}", path_to_cargo_toml, err)
+        panic!("Invalid manifest path {path_to_cargo_toml}: {err}")
     });
     let args = ExecuteArgs {
         manifest_path,
@@ -216,7 +216,7 @@ fn build_contract(path_to_cargo_toml: &str) -> String {
                 .into()
         }
         Err(err) => {
-            panic!("contract build for {} failed: {}", path_to_cargo_toml, err)
+            panic!("contract build for {path_to_cargo_toml} failed: {err}")
         }
     }
 }

crates/e2e/src/client.rs

@@ -32,31 +32,23 @@ use ink_env::Environment;
 use ink_primitives::MessageResult;
 
 use sp_core::Pair;
-use sp_runtime::traits::{
-    IdentifyAccount,
-    Verify,
-};
 use std::{
     collections::BTreeMap,
     fmt::Debug,
     marker::PhantomData,
     path::Path,
 };
+
 use subxt::{
     blocks::ExtrinsicEvents,
+    config::ExtrinsicParams,
     events::EventDetails,
-    ext::{
-        bitvec::macros::internal::funty::Fundamental,
-        scale_value::{
-            Composite,
-            Value,
-            ValueDef,
-        },
-    },
-    tx::{
-        ExtrinsicParams,
-        PairSigner,
+    ext::scale_value::{
+        Composite,
+        Value,
+        ValueDef,
     },
+    tx::PairSigner,
 };
 
 /// Result of a contract instantiation.
@@ -104,6 +96,7 @@ where
 impl<C, E> core::fmt::Debug for InstantiationResult<C, E>
 where
     C: subxt::Config,
+    C::AccountId: Debug,
     E: Environment,
     <E as Environment>::AccountId: Debug,
     <E as Environment>::Balance: Debug,
@@ -270,7 +263,7 @@ where
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match &self {
             Error::ContractNotFound(name) => {
-                f.write_str(&format!("ContractNotFound: {}", name))
+                f.write_str(&format!("ContractNotFound: {name}"))
             }
             Error::InstantiateDryRun(res) => {
                 f.write_str(&format!(
@@ -283,7 +276,7 @@ where
             Error::UploadExtrinsic(_) => f.write_str("UploadExtrinsic"),
             Error::CallDryRun(_) => f.write_str("CallDryRun"),
             Error::CallExtrinsic(_) => f.write_str("CallExtrinsic"),
-            Error::Balance(msg) => write!(f, "Balance: {}", msg),
+            Error::Balance(msg) => write!(f, "Balance: {msg}"),
         }
     }
 }
@@ -336,14 +329,10 @@ where
 impl<C, E> Client<C, E>
 where
     C: subxt::Config,
-    C::AccountId: Into<C::Address> + serde::de::DeserializeOwned,
-    C::Address: From<C::AccountId>,
+    C::AccountId: serde::de::DeserializeOwned,
+    C::AccountId: scale::Codec + Debug,
     C::Signature: From<sr25519::Signature>,
-    <C::Signature as Verify>::Signer: From<sr25519::Public>,
     <C::ExtrinsicParams as ExtrinsicParams<C::Index, C::Hash>>::OtherParams: Default,
-    <C::Signature as Verify>::Signer:
-        From<sr25519::Public> + IdentifyAccount<AccountId = C::AccountId>,
-    sr25519::Signature: Into<C::Signature>,
 
     E: Environment,
     E::AccountId: Debug,
@@ -356,14 +345,14 @@ where
             .await
             .unwrap_or_else(|err| {
                 if let subxt::Error::Rpc(subxt::error::RpcError::ClientError(_)) = err {
-                    let error_msg = format!("Error establishing connection to a node at {}. Make sure you run a node behind the given url!", url);
+                    let error_msg = format!("Error establishing connection to a node at {url}. Make sure you run a node behind the given url!");
                     log_error(&error_msg);
                     panic!("{}", error_msg);
                 }
                 log_error(
                     "Unable to create client! Please check that your node is running.",
                 );
-                panic!("Unable to create client: {:?}", err);
+                panic!("Unable to create client: {err:?}");
             });
         let contracts = contracts
             .into_iter()
@@ -397,11 +386,12 @@ where
     ) -> Signer<C>
     where
         E::Balance: Clone,
-        C::AccountId: Clone + core::fmt::Display,
+        C::AccountId: Clone + core::fmt::Display + core::fmt::Debug,
+        C::AccountId: From<sp_core::crypto::AccountId32>,
     {
         let (pair, _, _) = <sr25519::Pair as Pair>::generate_with_phrase(None);
-        let account_id =
-            <C::Signature as Verify>::Signer::from(pair.public()).into_account();
+        let pair_signer = PairSigner::<C, _>::new(pair);
+        let account_id = pair_signer.account_id().to_owned();
 
         for _ in 0..6 {
             let transfer_result = self
@@ -429,7 +419,7 @@ where
             }
         }
 
-        PairSigner::new(pair)
+        pair_signer
     }
 
     /// This function extracts the metadata of the contract at the file path
@@ -478,7 +468,7 @@ where
         let contract_metadata = self
             .contracts
             .get(contract_name)
-            .unwrap_or_else(|| panic!("Unknown contract {}", contract_name));
+            .unwrap_or_else(|| panic!("Unknown contract {contract_name}"));
         let code = crate::utils::extract_wasm(contract_metadata);
         let data = constructor_exec_input(constructor);
 
@@ -547,13 +537,13 @@ where
         let mut account_id = None;
         for evt in tx_events.iter() {
             let evt = evt.unwrap_or_else(|err| {
-                panic!("unable to unwrap event: {:?}", err);
+                panic!("unable to unwrap event: {err:?}");
             });
 
             if let Some(instantiated) = evt
                 .as_event::<ContractInstantiatedEvent<E>>()
                 .unwrap_or_else(|err| {
-                    panic!("event conversion to `Instantiated` failed: {:?}", err);
+                    panic!("event conversion to `Instantiated` failed: {err:?}");
                 })
             {
                 log_info(&format!(
@@ -572,8 +562,7 @@ where
                     &metadata,
                 );
                 log_error(&format!(
-                    "extrinsic for instantiate failed: {:?}",
-                    dispatch_error
+                    "extrinsic for instantiate failed: {dispatch_error:?}"
                 ));
                 return Err(Error::InstantiateExtrinsic(dispatch_error))
             }
@@ -590,9 +579,11 @@ where
 
     /// Generate a unique salt based on the system time.
     fn salt() -> Vec<u8> {
+        use funty::Fundamental as _;
+
         std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
-            .unwrap_or_else(|err| panic!("unable to get unix time: {}", err))
+            .unwrap_or_else(|err| panic!("unable to get unix time: {err}"))
             .as_millis()
             .as_u128()
             .to_le_bytes()
@@ -636,7 +627,7 @@ where
             .api
             .upload_dry_run(signer, code.clone(), storage_deposit_limit)
             .await;
-        log_info(&format!("upload dry run: {:?}", dry_run));
+        log_info(&format!("upload dry run: {dry_run:?}"));
         if dry_run.is_err() {
             return Err(Error::UploadDryRun(dry_run))
         }
@@ -646,12 +637,12 @@ where
         let mut hash = None;
         for evt in tx_events.iter() {
             let evt = evt.unwrap_or_else(|err| {
-                panic!("unable to unwrap event: {:?}", err);
+                panic!("unable to unwrap event: {err:?}");
             });
 
             if let Some(uploaded) =
                 evt.as_event::<CodeStoredEvent<E>>().unwrap_or_else(|err| {
-                    panic!("event conversion to `Uploaded` failed: {:?}", err);
+                    panic!("event conversion to `Uploaded` failed: {err:?}");
                 })
             {
                 log_info(&format!(
@@ -666,10 +657,7 @@ where
                     evt.field_bytes(),
                     &metadata,
                 );
-                log_error(&format!(
-                    "extrinsic for upload failed: {:?}",
-                    dispatch_error
-                ));
+                log_error(&format!("extrinsic for upload failed: {dispatch_error:?}"));
                 return Err(Error::UploadExtrinsic(dispatch_error))
             }
         }
@@ -683,7 +671,7 @@ where
             None => {
                 dry_run
                     .as_ref()
-                    .unwrap_or_else(|err| panic!("must have worked: {:?}", err))
+                    .unwrap_or_else(|err| panic!("must have worked: {err:?}"))
                     .code_hash
             }
         };
@@ -731,7 +719,7 @@ where
 
         for evt in tx_events.iter() {
             let evt = evt.unwrap_or_else(|err| {
-                panic!("unable to unwrap event: {:?}", err);
+                panic!("unable to unwrap event: {err:?}");
             });
 
             if is_extrinsic_failed_event(&evt) {
@@ -740,7 +728,7 @@ where
                     evt.field_bytes(),
                     &metadata,
                 );
-                log_error(&format!("extrinsic for call failed: {:?}", dispatch_error));
+                log_error(&format!("extrinsic for call failed: {dispatch_error:?}"));
                 return Err(Error::CallExtrinsic(dispatch_error))
             }
         }
@@ -807,28 +795,32 @@ where
             .api
             .client
             .storage()
-            .fetch_or_default(&account_addr, None)
+            .at(None)
+            .await
+            .unwrap_or_else(|err| {
+                panic!("unable to fetch balance: {err:?}");
+            })
+            .fetch_or_default(&account_addr)
             .await
             .unwrap_or_else(|err| {
-                panic!("unable to fetch balance: {:?}", err);
+                panic!("unable to fetch balance: {err:?}");
             })
             .to_value()
             .unwrap_or_else(|err| {
-                panic!("unable to decode account info: {:?}", err);
+                panic!("unable to decode account info: {err:?}");
             });
 
         let account_data = get_composite_field_value(&account, "data")?;
         let balance = get_composite_field_value(account_data, "free")?;
         let balance = balance.as_u128().ok_or_else(|| {
-            Error::Balance(format!("{:?} should convert to u128", balance))
+            Error::Balance(format!("{balance:?} should convert to u128"))
         })?;
         let balance = E::Balance::try_from(balance).map_err(|_| {
-            Error::Balance(format!("{:?} failed to convert from u128", balance))
+            Error::Balance(format!("{balance:?} failed to convert from u128"))
         })?;
 
         log_info(&format!(
-            "balance of contract {:?} is {:?}",
-            account_id, balance
+            "balance of contract {account_id:?} is {balance:?}"
         ));
         Ok(balance)
     }
@@ -853,7 +845,7 @@ where
             .iter()
             .find(|(name, _)| name == field_name)
             .ok_or_else(|| {
-                Error::Balance(format!("No field named '{}' found", field_name))
+                Error::Balance(format!("No field named '{field_name}' found"))
             })?;
         Ok(field)
     } else {

crates/e2e/src/default_accounts.rs

@@ -16,9 +16,7 @@
 
 use super::{
     AccountKeyring,
-    IdentifyAccount,
     PairSigner,
-    Verify,
 };
 use sp_core::sr25519;
 
@@ -33,9 +31,8 @@ macro_rules! default_account {
         pub fn $fn_name<C>() -> PairSigner<C, sr25519::Pair>
         where
             C: subxt::Config,
-            <C::Signature as Verify>::Signer: From<sr25519::Public>,
             C::Signature: From<sr25519::Signature>,
-            <C::Signature as Verify>::Signer: IdentifyAccount<AccountId = C::AccountId>,
+            C::AccountId: From<sp_core::crypto::AccountId32>
         {
             PairSigner::new(AccountKeyring::$keyring_fn_name.pair())
         }