Fix the instantiate command for Substrate 0.9.42-based chains

CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- Fix the `instantiate` command for Substrate `0.9.42` based chains - [#1546](https://github.com/paritytech/cargo-contract/pull/1564)
+
 ### Added
 - Verify raw Wasm in cargo contract verify - [#1551](https://github.com/paritytech/cargo-contract/pull/1551)
 - Specify prod chain URL with names and check for the verifiable build upon upload - [#1290](https://github.com/paritytech/cargo-contract/pull/1290)

crates/cargo-contract/src/cmd/instantiate.rs

@@ -190,7 +190,7 @@ impl InstantiateCommand {
                 }
                 Err(object) => {
                     if self.output_json() {
-                        return Err(object);
+                        return Err(object)
                     } else {
                         name_value_println!("Result", object, MAX_KEY_COL_WIDTH);
                         display_contract_exec_result::<_, MAX_KEY_COL_WIDTH, _>(&result)?;

crates/cargo-contract/src/cmd/mod.rs

@@ -145,7 +145,7 @@ pub const MAX_KEY_COL_WIDTH: usize = STORAGE_DEPOSIT_KEY.len() + 1;
 
 /// Print to stdout the fields of the result of a `instantiate` or `call` dry-run via RPC.
 pub fn display_contract_exec_result<R, const WIDTH: usize, Balance>(
-    result: &ContractResult<R, Balance, ()>,
+    result: &ContractResult<R, Balance>,
 ) -> Result<()>
 where
     Balance: Debug,
@@ -173,7 +173,7 @@ where
 }
 
 pub fn display_contract_exec_result_debug<R, const WIDTH: usize, Balance>(
-    result: &ContractResult<R, Balance, ()>,
+    result: &ContractResult<R, Balance>,
 ) -> Result<()> {
     let mut debug_message_lines = std::str::from_utf8(&result.debug_message)
         .context("Error decoding UTF8 debug message bytes")?

crates/cargo-contract/src/cmd/storage.rs

@@ -47,8 +47,13 @@ use super::parse_account;
 #[clap(name = "storage", about = "Inspect contract storage")]
 pub struct StorageCommand {
     /// The address of the contract to inspect storage of.
-    #[clap(name = "contract", long, env = "CONTRACT")]
-    contract: String,
+    #[clap(
+        name = "contract",
+        long,
+        env = "CONTRACT",
+        required_unless_present = "version"
+    )]
+    contract: Option<String>,
     /// Fetch the "raw" storage keys and values for the contract.
     #[clap(long)]
     raw: bool,
@@ -70,6 +75,9 @@ pub struct StorageCommand {
         default_value = "ws://localhost:9944"
     )]
     url: url::Url,
+    /// Fetch the storage version of the pallet contracts (pallet version).
+    #[clap(long, short)]
+    version: bool,
     /// The chain config to be used as part of the call.
     #[clap(name = "config", long, default_value = "Polkadot")]
     config: String,
@@ -90,55 +98,66 @@ impl StorageCommand {
     {
         let rpc = ContractStorageRpc::<C>::new(&self.url).await?;
         let storage_layout = ContractStorage::<C, C>::new(rpc);
-        let contract = parse_account(&self.contract)
-            .map_err(|e| anyhow::anyhow!("Failed to parse contract option: {}", e))?;
-
-        if self.raw {
-            let storage_data =
-                storage_layout.load_contract_storage_data(&contract).await?;
-            println!(
-                "{json}",
-                json = serde_json::to_string_pretty(&storage_data)?
-            );
-            return Ok(())
-        }
-
-        let contract_artifacts = ContractArtifacts::from_manifest_or_file(
-            self.manifest_path.as_ref(),
-            self.file.as_ref(),
-        );
-
-        match contract_artifacts {
-            Ok(contract_artifacts) => {
-                let transcoder = contract_artifacts.contract_transcoder()?;
-                let contract_storage = storage_layout
-                    .load_contract_storage_with_layout(&contract, &transcoder)
-                    .await?;
-                if self.output_json {
-                    println!(
-                        "{json}",
-                        json = serde_json::to_string_pretty(&contract_storage)?
-                    );
-                } else {
-                    let table = StorageDisplayTable::new(&contract_storage);
-                    table.display();
-                }
-            }
-            Err(_) => {
-                eprintln!(
-                    "{} Displaying raw storage: no valid contract metadata artifacts found",
-                    "Info:".cyan().bold(),
-                );
+        if self.version {
+            println!("{}", storage_layout.version().await?);
+            Ok(())
+        } else {
+            // Contract arg shall be always present in this case, it is enforced by
+            // clap configuration
+            let contract = self
+                .contract
+                .as_ref()
+                .map(|c| parse_account(c))
+                .transpose()?
+                .expect("Contract argument shall be present");
+
+            if self.raw {
                 let storage_data =
                     storage_layout.load_contract_storage_data(&contract).await?;
                 println!(
                     "{json}",
                     json = serde_json::to_string_pretty(&storage_data)?
                 );
+                return Ok(())
+            }
+
+            let contract_artifacts = ContractArtifacts::from_manifest_or_file(
+                self.manifest_path.as_ref(),
+                self.file.as_ref(),
+            );
+
+            match contract_artifacts {
+                Ok(contract_artifacts) => {
+                    let transcoder = contract_artifacts.contract_transcoder()?;
+                    let contract_storage = storage_layout
+                        .load_contract_storage_with_layout(&contract, &transcoder)
+                        .await?;
+                    if self.output_json {
+                        println!(
+                            "{json}",
+                            json = serde_json::to_string_pretty(&contract_storage)?
+                        );
+                    } else {
+                        let table = StorageDisplayTable::new(&contract_storage);
+                        table.display();
+                    }
+                }
+                Err(_) => {
+                    eprintln!(
+                    "{} Displaying raw storage: no valid contract metadata artifacts found",
+                    "Info:".cyan().bold(),
+                );
+                    let storage_data =
+                        storage_layout.load_contract_storage_data(&contract).await?;
+                    println!(
+                        "{json}",
+                        json = serde_json::to_string_pretty(&storage_data)?
+                    );
+                }
             }
-        }
 
-        Ok(())
+            Ok(())
+        }
     }
 }
 

crates/extrinsics/src/call.rs

@@ -178,7 +178,7 @@ where
     ///
     /// Returns the dry run simulation result of type [`ContractExecResult`], which
     /// includes information about the simulated call, or an error in case of failure.
-    pub async fn call_dry_run(&self) -> Result<ContractExecResult<E::Balance, ()>> {
+    pub async fn call_dry_run(&self) -> Result<ContractExecResult<E::Balance>> {
         let storage_deposit_limit = self.opts.storage_deposit_limit();
         let call_request = CallRequest {
             origin: self.opts.signer().account_id(),

crates/extrinsics/src/contract_storage.rs

@@ -46,8 +46,8 @@ use sp_core::{
 };
 use std::{
     collections::BTreeMap,
-    fmt,
     fmt::{
+        self,
         Display,
         Formatter,
     },
@@ -99,6 +99,20 @@ where
         }
     }
 
+    /// Fetch the storage version of the pallet contracts (pallet version)
+    pub async fn version(&self) -> Result<u16> {
+        self.rpc
+            .client
+            .storage()
+            .at_latest()
+            .await?
+            .storage_version("Contracts")
+            .await
+            .map_err(|e| {
+                anyhow!("The storage version for the contracts pallet could not be determined: {e}")
+            })
+    }
+
     /// Load the raw key/value storage for a given contract.
     pub async fn load_contract_storage_data(
         &self,

crates/extrinsics/src/instantiate.rs

@@ -276,7 +276,7 @@ where
     /// Returns the decoded dry run result, or an error in case of failure.
     pub async fn decode_instantiate_dry_run(
         &self,
-        result: &ContractInstantiateResult<C::AccountId, E::Balance, ()>,
+        result: &ContractInstantiateResult<C::AccountId, E::Balance>,
     ) -> Result<InstantiateDryRunResult<E::Balance>, ErrorVariant> {
         tracing::debug!("instantiate data {:?}", self.args.data);
         match result.result {
@@ -315,7 +315,7 @@ where
     /// Returns the dry run simulation result, or an error in case of failure.
     pub async fn instantiate_dry_run(
         &self,
-    ) -> Result<ContractInstantiateResult<C::AccountId, E::Balance, ()>> {
+    ) -> Result<ContractInstantiateResult<C::AccountId, E::Balance>> {
         let storage_deposit_limit = self.args.storage_deposit_limit;
         let call_request = InstantiateRequest::<C, E> {
             origin: self.opts.signer().account_id(),

crates/extrinsics/src/pallet_contracts_primitives.rs

@@ -40,7 +40,7 @@ use sp_weights::Weight;
 /// the `ContractsApi` version. Therefore when SCALE decoding a `ContractResult` its
 /// trailing data should be ignored to avoid any potential compatibility issues.
 #[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
-pub struct ContractResult<R, Balance, EventRecord> {
+pub struct ContractResult<R, Balance> {
     /// How much weight was consumed during execution.
     pub gas_consumed: Weight,
     /// How much weight is required as gas limit in order to execute this call.
@@ -78,21 +78,15 @@ pub struct ContractResult<R, Balance, EventRecord> {
     pub debug_message: Vec<u8>,
     /// The execution result of the wasm code.
     pub result: R,
-    /// The events that were emitted during execution. It is an option as event
-    /// collection is optional.
-    pub events: Option<Vec<EventRecord>>,
 }
 
 /// Result type of a `bare_call` call as well as `ContractsApi::call`.
-pub type ContractExecResult<Balance, EventRecord> =
-    ContractResult<Result<ExecReturnValue, DispatchError>, Balance, EventRecord>;
+pub type ContractExecResult<Balance> =
+    ContractResult<Result<ExecReturnValue, DispatchError>, Balance>;
 
 /// Result type of a `bare_instantiate` call as well as `ContractsApi::instantiate`.
-pub type ContractInstantiateResult<AccountId, Balance, EventRecord> = ContractResult<
-    Result<InstantiateReturnValue<AccountId>, DispatchError>,
-    Balance,
-    EventRecord,
->;
+pub type ContractInstantiateResult<AccountId, Balance> =
+    ContractResult<Result<InstantiateReturnValue<AccountId>, DispatchError>, Balance>;
 
 /// Result type of a `bare_code_upload` call.
 pub type CodeUploadResult<CodeHash, Balance> =