feat: expose command for broker fee withdrawal

api/bin/chainflip-broker-api/src/main.rs

@@ -6,8 +6,9 @@ use chainflip_api::{
 	self, clean_foreign_chain_address,
 	primitives::{AccountRole, Asset, BasisPoints, BlockNumber, CcmChannelMetadata, ChannelId},
 	settings::StateChain,
-	BrokerApi, OperatorApi, StateChainApi,
+	BrokerApi, OperatorApi, StateChainApi, WithdrawFeesDetail,
 };
+
 use clap::Parser;
 use futures::FutureExt;
 use jsonrpsee::{
@@ -56,6 +57,13 @@ pub trait Rpc {
 		channel_metadata: Option<CcmChannelMetadata>,
 		boost_fee: Option<BasisPoints>,
 	) -> RpcResult<BrokerSwapDepositAddress>;
+
+	#[method(name = "withdraw_fees", aliases = ["broker_withdrawFees"])]
+	async fn withdraw_fees(
+		&self,
+		asset: Asset,
+		destination_address: String,
+	) -> RpcResult<WithdrawFeesDetail>;
 }
 
 pub struct RpcServerImpl {
@@ -108,6 +116,18 @@ impl RpcServer for RpcServerImpl {
 			.await
 			.map(BrokerSwapDepositAddress::from)?)
 	}
+
+	async fn withdraw_fees(
+		&self,
+		asset: Asset,
+		destination_address: String,
+	) -> RpcResult<WithdrawFeesDetail> {
+		Ok(self
+			.api
+			.broker_api()
+			.withdraw_fees(asset, clean_foreign_chain_address(asset.into(), &destination_address)?)
+			.await?)
+	}
 }
 
 #[derive(Parser, Debug, Clone, Default)]

api/bin/chainflip-cli/src/main.rs

@@ -75,6 +75,23 @@ async fn run_cli() -> Result<()> {
 						.await?;
 					println!("Deposit Address: {address}");
 				},
+				Broker(BrokerSubcommands::WithdrawFees(params)) => {
+					let withdraw_details = api
+						.broker_api()
+						.withdraw_fees(
+							params.asset,
+							chainflip_api::clean_foreign_chain_address(
+								params.asset.into(),
+								&params.destination_address,
+							)?,
+						)
+						.await?;
+					println!(
+						"Withdrawal request successfull submitted. Tx hash: {:#x}",
+						withdraw_details.tx_hash
+					);
+					println!("Egress id: {:?}", withdraw_details.egress_id);
+				},
 				LiquidityProvider(
 					LiquidityProviderSubcommands::RequestLiquidityDepositAddress {
 						asset,

api/bin/chainflip-cli/src/settings.rs

@@ -76,11 +76,18 @@ pub struct SwapRequestParams {
 	/// Commission to the booster in basis points
 	pub boost_fee: Option<u16>,
 }
-
+#[derive(Parser, Clone, Debug)]
+pub struct WithdrawFeesParams {
+	/// Asset to withdraw ("ETH"|"DOT")
+	pub asset: Asset,
+	/// Egress asset address to receive withdrawn funds
+	pub destination_address: String,
+}
 #[derive(clap::Subcommand, Clone, Debug)]
 pub enum BrokerSubcommands {
 	/// Request a swap deposit address.
 	RequestSwapDepositAddress(SwapRequestParams),
+	WithdrawFees(WithdrawFeesParams),
 }
 
 #[derive(clap::Subcommand, Clone, Debug)]

api/lib/src/lib.rs

@@ -10,7 +10,7 @@ use cf_primitives::{AccountRole, Asset, BasisPoints, ChannelId, SemVer};
 use futures::FutureExt;
 use pallet_cf_governance::ExecutionMode;
 use pallet_cf_validator::MAX_LENGTH_FOR_VANITY_NAME;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use sp_consensus_aura::sr25519::AuthorityId as AuraId;
 use sp_consensus_grandpa::AuthorityId as GrandpaId;
 pub use sp_core::crypto::AccountId32;
@@ -304,6 +304,11 @@ pub struct SwapDepositAddress {
 	pub channel_id: ChannelId,
 	pub source_chain_expiry_block: <AnyChain as cf_chains::Chain>::ChainBlockNumber,
 }
+#[derive(Serialize, Deserialize)]
+pub struct WithdrawFeesDetail {
+	pub tx_hash: H256,
+	pub egress_id: (ForeignChain, u64),
+}
 
 #[async_trait]
 pub trait BrokerApi: SignedExtrinsicApi {
@@ -356,6 +361,42 @@ pub trait BrokerApi: SignedExtrinsicApi {
 			bail!("No SwapDepositAddressReady event was found");
 		}
 	}
+	async fn withdraw_fees(
+		&self,
+		asset: Asset,
+		destination_address: EncodedAddress,
+	) -> Result<WithdrawFeesDetail> {
+		let (tx_hash, events, ..) = self
+			.submit_signed_extrinsic(RuntimeCall::from(pallet_cf_swapping::Call::withdraw {
+				asset,
+				destination_address,
+			}))
+			.await
+			.until_in_block()
+			.await
+			.context("Request to withdraw broker fee for ${asset} failed.")?;
+
+		if let Some(state_chain_runtime::RuntimeEvent::Swapping(
+			pallet_cf_swapping::Event::WithdrawalRequested {
+				egress_amount: _,
+				egress_fee: _,
+				destination_address: _,
+				egress_id,
+			},
+		)) = events.iter().find(|event| {
+			matches!(
+				event,
+				state_chain_runtime::RuntimeEvent::Swapping(
+					pallet_cf_swapping::Event::WithdrawalRequested { .. }
+				)
+			)
+		}) {
+			Ok(WithdrawFeesDetail { tx_hash, egress_id: *egress_id })
+		} else {
+			bail!("No WithdrawalRequested event was found");
+		}
+		// Ok(tx_hash)
+	}
 }
 
 /// Sanitize the given address (hex or base58) and turn it into a EncodedAddress of the given