Updating to new subxt api

src/cmd/extrinsics/events.rs

@@ -15,18 +15,18 @@
 // along with cargo-contract.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::{
+    RuntimeEvent,
     runtime_api::api::contracts::events::ContractEmitted,
     transcode::{env_types, ContractMessageTranscoder, TranscoderBuilder},
 };
 use crate::{maybe_println, Verbosity, DEFAULT_KEY_COL_WIDTH};
 use colored::Colorize as _;
 
 use anyhow::Result;
-use scale::Input;
 use subxt::{self, DefaultConfig, Event, TransactionEvents};
 
 pub fn display_events(
-    result: &TransactionEvents<DefaultConfig>,
+    result: &TransactionEvents<DefaultConfig, RuntimeEvent>,
     transcoder: &ContractMessageTranscoder,
     subxt_metadata: &subxt::Metadata,
     verbosity: &Verbosity,
@@ -46,7 +46,7 @@ pub fn display_events(
 
     const EVENT_FIELD_INDENT: usize = DEFAULT_KEY_COL_WIDTH - 3;
 
-    for event in result.as_slice() {
+    for event in result.iter() {
         log::debug!("displaying event {}::{}", event.pallet, event.variant);
 
         let event_metadata = subxt_metadata.event(event.pallet_index, event.variant_index)?;

src/cmd/extrinsics/instantiate.rs

@@ -241,10 +241,10 @@ impl<'a> Exec<'a> {
         display_events(&result, &self.transcoder, metadata, &self.verbosity)?;
 
         let code_stored = result
-            .find_first_event::<api::contracts::events::CodeStored>()?
+            .find_first::<api::contracts::events::CodeStored>()?
             .ok_or(anyhow!("Failed to find CodeStored event"))?;
         let instantiated = result
-            .find_first_event::<api::contracts::events::Instantiated>()?
+            .find_first::<api::contracts::events::Instantiated>()?
             .ok_or(anyhow!("Failed to find Instantiated event"))?;
 
         Ok((code_stored.code_hash, instantiated.contract))
@@ -272,7 +272,7 @@ impl<'a> Exec<'a> {
         display_events(&result, &self.transcoder, metadata, &self.verbosity)?;
 
         let instantiated = result
-            .find_first_event::<api::contracts::events::Instantiated>()?
+            .find_first::<api::contracts::events::Instantiated>()?
             .ok_or(anyhow!("Failed to find Instantiated event"))?;
 
         Ok(instantiated.contract)

src/cmd/extrinsics/mod.rs

@@ -41,6 +41,7 @@ use subxt::{Config, DefaultConfig};
 pub use call::CallCommand;
 pub use instantiate::InstantiateCommand;
 pub use upload::UploadCommand;
+pub use runtime_api::api::{Event as RuntimeEvent, DispatchError as RuntimeDispatchError};
 
 type Balance = u128;
 type CodeHash = <DefaultConfig as Config>::Hash;
@@ -193,8 +194,8 @@ pub fn display_contract_exec_result<R>(result: &ContractResult<R, Balance>) -> R
 /// Currently this will report success once the transaction is included in a block. In the future
 /// there could be a flag to wait for finality before reporting success.
 async fn wait_for_success_and_handle_error<T>(
-    tx_progress: subxt::TransactionProgress<'_, T, runtime_api::api::DispatchError>,
-) -> Result<subxt::TransactionEvents<T>>
+    tx_progress: subxt::TransactionProgress<'_, T, RuntimeDispatchError, RuntimeEvent>,
+) -> Result<subxt::TransactionEvents<'_, T, RuntimeEvent>>
 where
     T: Config,
 {

src/cmd/extrinsics/upload.rs

@@ -25,7 +25,7 @@ use serde::Serialize;
 use sp_core::Bytes;
 use std::{fmt::Debug, path::PathBuf};
 use structopt::StructOpt;
-use subxt::{rpc::NumberOrHex, ClientBuilder, Config, DefaultConfig, Signer, TransactionEvents};
+use subxt::{rpc::NumberOrHex, ClientBuilder, Config, DefaultConfig, Signer};
 
 type CodeUploadResult = pallet_contracts_primitives::CodeUploadResult<CodeHash, Balance>;
 type CodeUploadReturnValue = pallet_contracts_primitives::CodeUploadReturnValue<CodeHash, Balance>;
@@ -65,11 +65,7 @@ impl UploadCommand {
 
                 Ok(())
             } else {
-                let result = self.upload_code(code, &signer, &transcoder).await?;
-
-                let code_stored = result
-                    .find_first_event::<api::contracts::events::CodeStored>()?
-                    .ok_or(anyhow::anyhow!("Failed to find CodeStored event"))?;
+                let code_stored = self.upload_code(code, &signer, &transcoder).await?;
 
                 name_value_println!("Code hash", format!("{:?}", code_stored.code_hash));
 
@@ -107,7 +103,7 @@ impl UploadCommand {
         code: Vec<u8>,
         signer: &PairSigner,
         transcoder: &ContractMessageTranscoder<'_>,
-    ) -> Result<TransactionEvents<DefaultConfig>> {
+    ) -> Result<api::contracts::events::CodeStored> {
         let url = self.extrinsic_opts.url.to_string();
         let api = ClientBuilder::new()
             .set_url(&url)
@@ -131,7 +127,11 @@ impl UploadCommand {
             &self.extrinsic_opts.verbosity()?,
         )?;
 
-        Ok(result)
+        let code_stored = result
+            .find_first::<api::contracts::events::CodeStored>()?
+            .ok_or(anyhow::anyhow!("Failed to find CodeStored event"))?;
+
+        Ok(code_stored)
     }
 }