Update api-client to tag v0.9.0 (#1263)

* update to v0.9.0 tag

* fix api-types

* some more changes

* fix metadata

* fix it all

* fix submit extrinsic

* fix palletteerex api

* one step further

* some more uptadates

* seems to work

* oh yes

* and compiled

* readd comment

* add comment

* cargo fmt

* taplo fmt

* fix rpc-client mock

* fix tests

* fix clippy

* fix clippy

* fix teeracle

* fix teeracel

* fix clippy

* lets try

* lets try that

* simplify account.rs

* simplfy pallet teerex

* simplify signedblock

* remove clone

* fmt

* fix clippy

* clean SignedBlock

cli/Cargo.toml

@@ -25,8 +25,8 @@ ws = { version = "0.9.1", features = ["ssl"] }
 # scs / integritee
 my-node-runtime = { package = "integritee-node-runtime", git = "https://github.com/integritee-network/integritee-node.git", branch = "polkadot-v0.9.39" }
 pallet-evm = { optional = true, git = "https://github.com/integritee-network/frontier.git", branch = "polkadot-v0.9.39" }
-substrate-api-client = { features = ["ws-client"], git = "https://github.com/scs/substrate-api-client.git", branch = "polkadot-v0.9.39-tag-v0.7.0" }
-substrate-client-keystore = { git = "https://github.com/scs/substrate-api-client.git", branch = "polkadot-v0.9.39-tag-v0.7.0" }
+substrate-api-client = { features = ["ws-client"], git = "https://github.com/scs/substrate-api-client.git", branch = "polkadot-v0.9.39-tag-v0.9.0" }
+substrate-client-keystore = { git = "https://github.com/scs/substrate-api-client.git", branch = "polkadot-v0.9.39-tag-v0.9.0" }
 teerex-primitives = { git = "https://github.com/integritee-network/pallets.git", branch = "polkadot-v0.9.39" }
 
 # substrate dependencies

cli/src/base_cli/commands/balance.rs

@@ -19,6 +19,7 @@ use crate::{
 	command_utils::{get_accountid_from_str, get_chain_api},
 	Cli,
 };
+use substrate_api_client::GetAccountInformation;
 
 #[derive(Parser)]
 pub struct BalanceCommand {

cli/src/base_cli/commands/faucet.rs

@@ -19,11 +19,12 @@ use crate::{
 	command_utils::{get_accountid_from_str, get_chain_api},
 	Cli,
 };
+use codec::Encode;
 use my_node_runtime::{BalancesCall, RuntimeCall};
 use sp_keyring::AccountKeyring;
 use sp_runtime::MultiAddress;
 use std::vec::Vec;
-use substrate_api_client::{compose_extrinsic_offline, UncheckedExtrinsicV4, XtStatus};
+use substrate_api_client::{compose_extrinsic_offline, SubmitExtrinsic, UncheckedExtrinsicV4};
 
 const PREFUNDING_AMOUNT: u128 = 1_000_000_000;
 
@@ -36,13 +37,14 @@ pub struct FaucetCommand {
 
 impl FaucetCommand {
 	pub(crate) fn run(&self, cli: &Cli) {
-		let api = get_chain_api(cli).set_signer(AccountKeyring::Alice.pair());
+		let mut api = get_chain_api(cli);
+		api.set_signer(AccountKeyring::Alice.pair());
 		let mut nonce = api.get_nonce().unwrap();
 		for account in &self.accounts {
 			let to = get_accountid_from_str(account);
 			#[allow(clippy::redundant_clone)]
 			let xt: UncheckedExtrinsicV4<_, _> = compose_extrinsic_offline!(
-				api.clone().signer.unwrap(),
+				api.signer().unwrap(),
 				RuntimeCall::Balances(BalancesCall::transfer {
 					dest: MultiAddress::Id(to.clone()),
 					value: PREFUNDING_AMOUNT
@@ -51,7 +53,7 @@ impl FaucetCommand {
 			);
 			// send and watch extrinsic until finalized
 			println!("Faucet drips to {} (Alice's nonce={})", to, nonce);
-			let _blockh = api.send_extrinsic(xt.hex_encode(), XtStatus::Ready).unwrap();
+			let _blockh = api.submit_extrinsic(xt.encode()).unwrap();
 			nonce += 1;
 		}
 	}

cli/src/base_cli/commands/listen.rs

@@ -20,8 +20,8 @@ use base58::ToBase58;
 use codec::{Decode, Encode};
 use log::*;
 use my_node_runtime::{Hash, RuntimeEvent};
-use std::{sync::mpsc::channel, vec::Vec};
-use substrate_api_client::utils::FromHexString;
+use std::vec::Vec;
+use substrate_api_client::{rpc::HandleSubscription, SubscribeFrameSystem};
 
 #[derive(Parser)]
 pub struct ListenCommand {
@@ -39,10 +39,9 @@ impl ListenCommand {
 		println!("{:?} {:?}", self.events, self.blocks);
 		let api = get_chain_api(cli);
 		info!("Subscribing to events");
-		let (events_in, events_out) = channel();
 		let mut count = 0u32;
 		let mut blocks = 0u32;
-		api.subscribe_events(events_in).unwrap();
+		let mut subscription = api.subscribe_system_events().unwrap();
 		loop {
 			if let Some(e) = self.events {
 				if count >= e {
@@ -54,13 +53,13 @@ impl ListenCommand {
 					return
 				}
 			};
-			let event_str = events_out.recv().unwrap();
-			let _unhex = Vec::from_hex(event_str).unwrap();
-			let mut _er_enc = _unhex.as_slice();
-			let _events =
-				Vec::<frame_system::EventRecord<RuntimeEvent, Hash>>::decode(&mut _er_enc);
+
+			let event_bytes = subscription.next().unwrap().unwrap().changes[0].1.clone().unwrap().0;
+			let events_result = Vec::<frame_system::EventRecord<RuntimeEvent, Hash>>::decode(
+				&mut event_bytes.as_slice(),
+			);
 			blocks += 1;
-			match _events {
+			match events_result {
 				Ok(evts) =>
 					for evr in &evts {
 						println!("decoded: phase {:?} event {:?}", evr.phase, evr.event);

cli/src/base_cli/commands/shield_funds.rs

@@ -27,7 +27,7 @@ use itp_stf_primitives::types::ShardIdentifier;
 use log::*;
 use my_node_runtime::Balance;
 use sp_core::sr25519 as sr25519_core;
-use substrate_api_client::{compose_extrinsic, UncheckedExtrinsicV4, XtStatus};
+use substrate_api_client::{compose_extrinsic, SubmitAndWatch, UncheckedExtrinsicV4, XtStatus};
 
 #[derive(Parser)]
 pub struct ShieldFundsCommand {
@@ -46,7 +46,7 @@ pub struct ShieldFundsCommand {
 
 impl ShieldFundsCommand {
 	pub(crate) fn run(&self, cli: &Cli) {
-		let chain_api = get_chain_api(cli);
+		let mut chain_api = get_chain_api(cli);
 
 		let shard_opt = match self.shard.from_base58() {
 			Ok(s) => ShardIdentifier::decode(&mut &s[..]),
@@ -60,7 +60,7 @@ impl ShieldFundsCommand {
 
 		// get the sender
 		let from = get_pair_from_str(&self.from);
-		let chain_api = chain_api.set_signer(sr25519_core::Pair::from(from));
+		chain_api.set_signer(sr25519_core::Pair::from(from));
 
 		// get the recipient
 		let to = get_accountid_from_str(&self.to);
@@ -78,7 +78,9 @@ impl ShieldFundsCommand {
 			shard
 		);
 
-		let tx_hash = chain_api.send_extrinsic(xt.hex_encode(), XtStatus::Finalized).unwrap();
+		let tx_hash = chain_api
+			.submit_and_watch_extrinsic_until(xt.encode(), XtStatus::Finalized)
+			.unwrap();
 		println!("[+] TrustedOperation got finalized. Hash: {:?}\n", tx_hash);
 	}
 }

cli/src/base_cli/commands/transfer.rs

@@ -19,10 +19,11 @@ use crate::{
 	command_utils::{get_accountid_from_str, get_chain_api, *},
 	Cli,
 };
+use codec::Encode;
 use log::*;
 use my_node_runtime::Balance;
 use sp_core::{crypto::Ss58Codec, sr25519 as sr25519_core, Pair};
-use substrate_api_client::{GenericAddress, XtStatus};
+use substrate_api_client::{GenericAddress, GetAccountInformation, SubmitAndWatch, XtStatus};
 
 #[derive(Parser)]
 pub struct TransferCommand {
@@ -42,9 +43,10 @@ impl TransferCommand {
 		let to_account = get_accountid_from_str(&self.to);
 		info!("from ss58 is {}", from_account.public().to_ss58check());
 		info!("to ss58 is {}", to_account.to_ss58check());
-		let api = get_chain_api(cli).set_signer(sr25519_core::Pair::from(from_account));
+		let mut api = get_chain_api(cli);
+		api.set_signer(sr25519_core::Pair::from(from_account));
 		let xt = api.balance_transfer(GenericAddress::Id(to_account.clone()), self.amount);
-		let tx_hash = api.send_extrinsic(xt.hex_encode(), XtStatus::InBlock).unwrap();
+		let tx_hash = api.submit_and_watch_extrinsic_until(xt.encode(), XtStatus::InBlock).unwrap();
 		println!("[+] TrustedOperation got finalized. Hash: {:?}\n", tx_hash);
 		let result = api.get_account_data(&to_account).unwrap().unwrap();
 		println!("balance for {} is now {}", to_account, result.free);

cli/src/base_cli/mod.rs

@@ -110,14 +110,15 @@ fn list_accounts() {
 }
 
 fn print_metadata(cli: &Cli) {
-	let meta = get_chain_api(cli).get_metadata().unwrap();
-	println!("Metadata:\n {}", Metadata::pretty_format(&meta).unwrap());
+	let api = get_chain_api(cli);
+	let meta = api.metadata();
+	println!("Metadata:\n {}", Metadata::pretty_format(&meta.runtime_metadata()).unwrap());
 }
 
 fn print_sgx_metadata(cli: &Cli) {
 	let worker_api_direct = get_worker_api_direct(cli);
 	let metadata = worker_api_direct.get_state_metadata().unwrap();
-	println!("Metadata:\n {}", Metadata::pretty_format(&metadata).unwrap());
+	println!("Metadata:\n {}", Metadata::pretty_format(metadata.runtime_metadata()).unwrap());
 }
 
 fn list_workers(cli: &Cli) {

cli/src/command_utils.rs

@@ -40,7 +40,7 @@ pub(crate) fn get_shielding_key(cli: &Cli) -> Result<Rsa3072PubKey, String> {
 pub(crate) fn get_chain_api(cli: &Cli) -> ParentchainApi {
 	let url = format!("{}:{}", cli.node_url, cli.node_port);
 	info!("connecting to {}", url);
-	ParentchainApi::new(WsRpcClient::new(&url)).unwrap()
+	ParentchainApi::new(WsRpcClient::new(&url).unwrap()).unwrap()
 }
 
 pub(crate) fn get_accountid_from_str(account: &str) -> AccountId {

cli/src/oracle/commands/add_to_whitelist.rs

@@ -19,8 +19,11 @@ use crate::{
 	command_utils::{get_chain_api, get_pair_from_str, mrenclave_from_base58},
 	Cli,
 };
+use codec::Encode;
 use itp_node_api::api_client::{ADD_TO_WHITELIST, TEERACLE};
-use substrate_api_client::{compose_call, compose_extrinsic, UncheckedExtrinsicV4, XtStatus};
+use substrate_api_client::{
+	compose_call, compose_extrinsic, SubmitAndWatch, UncheckedExtrinsicV4, XtStatus,
+};
 
 /// Add a trusted market data source to the on-chain whitelist.
 #[derive(Debug, Clone, Parser)]
@@ -39,21 +42,27 @@ pub struct AddToWhitelistCmd {
 
 impl AddToWhitelistCmd {
 	pub fn run(&self, cli: &Cli) {
-		let api = get_chain_api(cli);
+		let mut api = get_chain_api(cli);
 		let mrenclave = mrenclave_from_base58(&self.mrenclave);
 		let from = get_pair_from_str(&self.from);
 
 		let market_data_source = self.source.clone();
 
-		let api = api.set_signer(from.into());
+		api.set_signer(from.into());
 
-		let call =
-			compose_call!(api.metadata, TEERACLE, ADD_TO_WHITELIST, market_data_source, mrenclave);
+		let call = compose_call!(
+			api.metadata(),
+			TEERACLE,
+			ADD_TO_WHITELIST,
+			market_data_source,
+			mrenclave
+		);
 
 		// compose the extrinsic
 		let xt: UncheckedExtrinsicV4<_, _> = compose_extrinsic!(api, "Sudo", "sudo", call);
 
-		let tx_hash = api.send_extrinsic(xt.hex_encode(), XtStatus::Finalized).unwrap();
-		println!("[+] Add to whitelist got finalized. Hash: {:?}\n", tx_hash);
+		let report =
+			api.submit_and_watch_extrinsic_until(xt.encode(), XtStatus::Finalized).unwrap();
+		println!("[+] Add to whitelist got finalized. Hash: {:?}\n", report.extrinsic_hash);
 	}
 }

cli/src/oracle/commands/listen_to_exchange.rs

@@ -21,8 +21,8 @@ use itp_node_api::api_client::ParentchainApi;
 use itp_time_utils::{duration_now, remaining_time};
 use log::{debug, info, trace};
 use my_node_runtime::{Hash, RuntimeEvent};
-use std::{sync::mpsc::channel, time::Duration};
-use substrate_api_client::FromHexString;
+use std::time::Duration;
+use substrate_api_client::{rpc::HandleSubscription, SubscribeFrameSystem};
 
 /// Listen to exchange rate events.
 #[derive(Debug, Clone, Parser)]
@@ -47,16 +47,13 @@ pub fn count_exchange_rate_update_events(api: &ParentchainApi, duration: Duratio
 	let stop = duration_now() + duration;
 
 	//subscribe to events
-	let (events_in, events_out) = channel();
-	api.subscribe_events(events_in).unwrap();
+	let mut subscription = api.subscribe_system_events().unwrap();
 	let mut count = 0;
 
 	while remaining_time(stop).unwrap_or_default() > Duration::ZERO {
-		let event_str = events_out.recv().unwrap();
-		let unhex = Vec::from_hex(event_str).unwrap();
-		let mut event_records_encoded = unhex.as_slice();
+		let event_bytes = subscription.next().unwrap().unwrap().changes[0].1.clone().unwrap().0;
 		let events_result = Vec::<frame_system::EventRecord<RuntimeEvent, Hash>>::decode(
-			&mut event_records_encoded,
+			&mut event_bytes.as_slice(),
 		);
 		if let Ok(events) = events_result {
 			for event_record in &events {

cli/src/oracle/commands/listen_to_oracle.rs

@@ -21,8 +21,8 @@ use itp_node_api::api_client::ParentchainApi;
 use itp_time_utils::{duration_now, remaining_time};
 use log::{debug, info};
 use my_node_runtime::{Hash, RuntimeEvent};
-use std::{sync::mpsc::channel, time::Duration};
-use substrate_api_client::FromHexString;
+use std::time::Duration;
+use substrate_api_client::{rpc::HandleSubscription, SubscribeFrameSystem};
 
 /// Listen to exchange rate events.
 #[derive(Debug, Clone, Parser)]
@@ -47,14 +47,12 @@ fn count_oracle_update_events(api: &ParentchainApi, duration: Duration) -> Event
 	let stop = duration_now() + duration;
 
 	//subscribe to events
-	let (events_in, events_out) = channel();
-	api.subscribe_events(events_in).unwrap();
+	let mut subscription = api.subscribe_system_events().unwrap();
 	let mut count = 0;
 
 	while remaining_time(stop).unwrap_or_default() > Duration::ZERO {
-		let events_str = events_out.recv().unwrap();
-		let events_vec_bytes = Vec::from_hex(events_str).unwrap();
-		count += report_event_count(&events_vec_bytes);
+		let event_bytes = subscription.next().unwrap().unwrap().changes[0].1.clone().unwrap().0;
+		count += report_event_count(&event_bytes);
 	}
 	debug!("Received {} ExchangeRateUpdated event(s) in total", count);
 	count

cli/src/trusted_operation.rs

@@ -28,7 +28,7 @@ use itp_node_api::api_client::TEEREX;
 use itp_rpc::{RpcRequest, RpcResponse, RpcReturnValue};
 use itp_sgx_crypto::ShieldingCryptoEncrypt;
 use itp_stf_primitives::types::ShardIdentifier;
-use itp_types::{BlockNumber, DirectRequestStatus, Header, TrustedOperationStatus};
+use itp_types::{BlockNumber, DirectRequestStatus, TrustedOperationStatus};
 use itp_utils::{FromHexPrefixed, ToHexPrefixed};
 use log::*;
 use my_node_runtime::{AccountId, Hash};
@@ -38,7 +38,10 @@ use std::{
 	sync::mpsc::{channel, Receiver},
 	time::Instant,
 };
-use substrate_api_client::{compose_extrinsic, StaticEvent, XtStatus};
+use substrate_api_client::{
+	compose_extrinsic, GetHeader, StaticEvent, SubmitAndWatch, SubscribeEvents,
+	SubscribeFrameSystem, XtStatus,
+};
 use teerex_primitives::Request;
 
 pub(crate) fn perform_trusted_operation(
@@ -107,38 +110,40 @@ fn send_request(
 	trusted_args: &TrustedCli,
 	trusted_operation: &TrustedOperation,
 ) -> Option<Vec<u8>> {
-	let chain_api = get_chain_api(cli);
+	let mut chain_api = get_chain_api(cli);
 	let encryption_key = get_shielding_key(cli).unwrap();
 	let call_encrypted = encryption_key.encrypt(&trusted_operation.encode()).unwrap();
 
 	let shard = read_shard(trusted_args).unwrap();
 
 	let arg_signer = &trusted_args.xt_signer;
 	let signer = get_pair_from_str(arg_signer);
-	let _chain_api = chain_api.set_signer(sr25519_core::Pair::from(signer));
+	chain_api.set_signer(sr25519_core::Pair::from(signer));
 
 	let request = Request { shard, cyphertext: call_encrypted };
-	let xt = compose_extrinsic!(_chain_api, TEEREX, "call_worker", request);
+	let xt = compose_extrinsic!(&chain_api, TEEREX, "call_worker", request);
 
 	// send and watch extrinsic until block is executed
-	let block_hash =
-		_chain_api.send_extrinsic(xt.hex_encode(), XtStatus::InBlock).unwrap().unwrap();
+	let block_hash = chain_api
+		.submit_and_watch_extrinsic_until(xt.encode(), XtStatus::InBlock)
+		.unwrap()
+		.block_hash
+		.unwrap();
 
 	info!(
 		"Trusted call extrinsic sent and successfully included in parentchain block with hash {:?}.",
 		block_hash
 	);
 	info!("Waiting for execution confirmation from enclave...");
-	let (events_in, events_out) = channel();
-	_chain_api.subscribe_events(events_in).unwrap();
+	let mut subscription = chain_api.subscribe_system_events().unwrap();
 
 	loop {
 		let ret: ProcessedParentchainBlockArgs =
-			_chain_api.wait_for_event::<ProcessedParentchainBlockArgs>(&events_out).unwrap();
+			chain_api.wait_for_event(&mut subscription).unwrap();
 		info!("Confirmation of ProcessedParentchainBlock received");
 		debug!("Expected block Hash: {:?}", block_hash);
 		debug!("Confirmed stf block Hash: {:?}", ret.block_hash);
-		match _chain_api.get_header::<Header>(Some(block_hash)) {
+		match chain_api.get_header(Some(block_hash)) {
 			Ok(option) => {
 				match option {
 					None => {

core-primitives/extrinsics-factory/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 # sgx dependencies
 sgx_tstd = { branch = "master", git = "https://github.com/apache/teaclave-sgx-sdk.git", optional = true }
 sgx_types = { branch = "master", git = "https://github.com/apache/teaclave-sgx-sdk.git" }
-substrate-api-client = { default-features = false, git = "https://github.com/scs/substrate-api-client.git", branch = "polkadot-v0.9.39-tag-v0.7.0" }
+substrate-api-client = { default-features = false, git = "https://github.com/scs/substrate-api-client.git", branch = "polkadot-v0.9.39-tag-v0.9.0" }
 
 # local dependencies
 itp-node-api = { path = "../node-api", default-features = false }

core-primitives/node-api/api-client-extensions/Cargo.toml

@@ -15,9 +15,10 @@ sp-finality-grandpa = { git = "https://github.com/paritytech/substrate.git", bra
 sp-runtime = { git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.39" }
 
 # scs
-substrate-api-client = { git = "https://github.com/scs/substrate-api-client.git", branch = "polkadot-v0.9.39-tag-v0.7.0" }
+substrate-api-client = { git = "https://github.com/scs/substrate-api-client.git", branch = "polkadot-v0.9.39-tag-v0.9.0" }
 
 # local deps
+itp-api-client-types = { path = "../api-client-types" }
 itp-types = { path = "../../types" }
 
 [features]