Feat: EVM Vault swaps support for Broker and affiliates

bouncer/package.json

@@ -6,7 +6,7 @@
     "prettier:write": "prettier --write ."
   },
   "dependencies": {
-    "@chainflip/cli": "1.8.0-rc.2",
+    "@chainflip/cli": "1.8.0-rc.6",
     "@chainflip/utils": "^0.4.0",
     "@coral-xyz/anchor": "^0.30.1",
     "@iarna/toml": "^2.2.5",

bouncer/shared/evm_vault_swap.ts

@@ -14,6 +14,7 @@ import { HDNodeWallet } from 'ethers';
 import { randomBytes } from 'crypto';
 import { PublicKey, sendAndConfirmTransaction, Keypair } from '@solana/web3.js';
 import { getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import Keyring from '../polkadot/keyring';
 import {
   observeBalanceIncrease,
   getContractAddress,
@@ -54,6 +55,10 @@ export async function executeVaultSwap(
   fillOrKillParams?: FillOrKillParamsX128,
   dcaParams?: DcaParams,
   wallet?: HDNodeWallet,
+  brokerFees?: {
+    account: string;
+    commissionBps: number;
+  },
 ): ReturnType<typeof executeSwap> {
   const srcChain = chainFromAsset(sourceAsset);
   const destChain = chainFromAsset(destAsset);
@@ -68,6 +73,11 @@ export async function executeVaultSwap(
 
   const evmWallet = wallet ?? (await createEvmWalletAndFund(sourceAsset));
 
+  const brokerComission = brokerFees ?? {
+    account: new Keyring({ type: 'sr25519' }).createFromUri('//BROKER_1').address,
+    commissionBps: 1,
+  };
+
   if (erc20Assets.includes(sourceAsset)) {
     // Doing effectively infinite approvals to make sure it doesn't fail.
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
@@ -104,12 +114,13 @@ export async function executeVaultSwap(
         message: messageMetadata.message,
         ccmAdditionalData: messageMetadata.ccmAdditionalData,
       },
+      brokerFees: brokerComission,
       // The SDK will encode these parameters and the ccmAdditionalData
       // into the `cfParameters` field for the vault swap.
       boostFeeBps,
       fillOrKillParams: fokParams,
       dcaParams,
-      beneficiaries: undefined,
+      affiliateFees: undefined,
     } as ExecuteSwapParams,
     networkOptions,
     txOptions,

bouncer/tests/evm_deposits.ts

@@ -97,8 +97,8 @@ async function testTxMultipleVaultSwaps(sourceAsset: Asset, destAsset: Asset) {
       assetContractId(destAsset),
       getContractAddress(chainFromAsset(sourceAsset), sourceAsset),
       amount,
-      // Encoded EVM refund address and no other swap parameters.
-      '0x0000000000000e879c89cad7076b347bde13c99cf2c33e7299b60000000000000000000000000000000000000000000000000000000000000000000000',
+      // Dummy encoded data containing a refund address and a broker accountId.
+      '0x000001000000000202020202020202020202020202020202020202000000000000000000000000000000000000000000000000000000000000000000000303030303030303030303030303030303030303030303030303030303030303040000',
       numSwaps,
     )
     .encodeABI();

engine/src/witness/arb.rs

@@ -2,10 +2,14 @@ mod chain_tracking;
 
 use std::{collections::HashMap, sync::Arc};
 
-use cf_chains::{assets::arb::Asset as ArbAsset, evm::DepositDetails, Arbitrum};
-use cf_primitives::{AffiliateShortId, EpochIndex};
+use cf_chains::{address::EncodedAddress, evm::DepositDetails, Arbitrum, CcmDepositMetadata};
+use cf_primitives::{
+	chains::assets::arb::Asset as ArbAsset, Asset, AssetAmount, Beneficiary, EpochIndex,
+	TransactionHash,
+};
 use cf_utilities::task_scope::Scope;
 use futures_core::Future;
+use itertools::Itertools;
 use sp_core::H160;
 
 use crate::{
@@ -18,7 +22,7 @@ use crate::{
 		stream_api::{StreamApi, FINALIZED},
 		STATE_CHAIN_CONNECTION,
 	},
-	witness::evm::erc20_deposits::usdc::UsdcEvents,
+	witness::{common::cf_parameters::VaultSwapParameters, evm::erc20_deposits::usdc::UsdcEvents},
 };
 
 use super::{
@@ -81,11 +85,10 @@ where
 		.get(&ArbAsset::ArbUsdc)
 		.context("ArbitrumSupportedAssets does not include USDC")?;
 
-	let supported_arb_erc20_assets: HashMap<H160, cf_primitives::Asset> =
-		supported_arb_erc20_assets
-			.into_iter()
-			.map(|(asset, address)| (address, asset.into()))
-			.collect();
+	let supported_arb_erc20_assets: HashMap<H160, Asset> = supported_arb_erc20_assets
+		.into_iter()
+		.map(|(asset, address)| (address, asset.into()))
+		.collect();
 
 	let arb_source = EvmSource::<_, Arbitrum>::new(arb_client.clone())
 		.strictly_monotonic()
@@ -162,7 +165,7 @@ where
 			process_call,
 			arb_client.clone(),
 			vault_address,
-			cf_primitives::Asset::ArbEth,
+			Asset::ArbEth,
 			cf_primitives::ForeignChain::Arbitrum,
 			supported_arb_erc20_assets,
 		)
@@ -175,11 +178,6 @@ where
 
 struct ArbCallBuilder {}
 
-use cf_chains::{address::EncodedAddress, CcmDepositMetadata, ChannelRefundParameters};
-use cf_primitives::{
-	Asset, AssetAmount, BasisPoints, Beneficiaries, DcaParameters, TransactionHash,
-};
-
 impl super::evm::vault::IngressCallBuilder for ArbCallBuilder {
 	type Chain = Arbitrum;
 
@@ -190,11 +188,7 @@ impl super::evm::vault::IngressCallBuilder for ArbCallBuilder {
 		destination_address: EncodedAddress,
 		deposit_metadata: Option<CcmDepositMetadata>,
 		tx_hash: TransactionHash,
-		_broker_fees: Beneficiaries<AffiliateShortId>,
-		refund_params: Option<ChannelRefundParameters>,
-		dca_params: Option<DcaParameters>,
-		// This is only to be checked in the pre-witnessed version
-		boost_fee: Option<BasisPoints>,
+		vault_swap_parameters: VaultSwapParameters,
 	) -> state_chain_runtime::RuntimeCall {
 		state_chain_runtime::RuntimeCall::ArbitrumIngressEgress(
 			pallet_cf_ingress_egress::Call::vault_swap_request {
@@ -205,15 +199,17 @@ impl super::evm::vault::IngressCallBuilder for ArbCallBuilder {
 				deposit_metadata,
 				tx_hash,
 				deposit_details: Box::new(DepositDetails { tx_hashes: Some(vec![tx_hash.into()]) }),
-				// Defaulting to no broker fees until PRO-1743 is completed.
-				broker_fee: cf_primitives::Beneficiary {
-					account: sp_runtime::AccountId32::new([0; 32]),
-					bps: 0,
-				},
-				affiliate_fees: Default::default(),
-				boost_fee: boost_fee.unwrap_or_default(),
-				dca_params,
-				refund_params: refund_params.map(Box::new),
+				broker_fee: vault_swap_parameters.broker_fee,
+				affiliate_fees: vault_swap_parameters
+					.affiliate_fees
+					.into_iter()
+					.map(|entry| Beneficiary { account: entry.affiliate.into(), bps: entry.fee.into() })
+					.collect_vec()
+					.try_into()
+					.expect("runtime supports at least as many affiliates as we allow in cf_parameters encoding"),
+				boost_fee: vault_swap_parameters.boost_fee.into(),
+				dca_params: vault_swap_parameters.dca_params,
+				refund_params: Box::new(vault_swap_parameters.refund_params),
 			},
 		)
 	}

engine/src/witness/btc/vault_swaps.rs

@@ -154,11 +154,11 @@ pub fn try_extract_vault_swap_call(
 			.collect_vec()
 			.try_into()
 			.expect("runtime supports at least as many affiliates as we allow in UTXO encoding"),
-		refund_params: Some(Box::new(ChannelRefundParameters {
+		refund_params: Box::new(ChannelRefundParameters {
 			retry_duration: data.parameters.retry_duration.into(),
 			refund_address: ForeignChainAddress::Btc(refund_address),
 			min_price,
-		})),
+		}),
 		dca_params: Some(DcaParameters {
 			number_of_chunks: data.parameters.number_of_chunks.into(),
 			chunk_interval: data.parameters.chunk_interval.into(),
@@ -201,7 +201,7 @@ mod tests {
 			chunk_interval: 2,
 			boost_fee: 5,
 			broker_fee: 10,
-			affiliates: bounded_vec![AffiliateAndFee { affiliate: 17, fee: 7 }],
+			affiliates: bounded_vec![cf_primitives::AffiliateAndFee { affiliate: 17, fee: 7 }],
 		},
 	});
 
@@ -306,14 +306,14 @@ mod tests {
 					bps: MOCK_SWAP_PARAMS.parameters.affiliates[0].fee.into(),
 				}],
 				deposit_metadata: None,
-				refund_params: Some(Box::new(ChannelRefundParameters {
+				refund_params: Box::new(ChannelRefundParameters {
 					retry_duration: MOCK_SWAP_PARAMS.parameters.retry_duration.into(),
 					refund_address: ForeignChainAddress::Btc(refund_pubkey),
 					min_price: sqrt_price_to_price(bounded_sqrt_price(
 						MOCK_SWAP_PARAMS.parameters.min_output_amount.into(),
 						DEPOSIT_AMOUNT.into(),
 					)),
-				})),
+				}),
 				dca_params: Some(DcaParameters {
 					number_of_chunks: MOCK_SWAP_PARAMS.parameters.number_of_chunks.into(),
 					chunk_interval: MOCK_SWAP_PARAMS.parameters.chunk_interval.into(),

engine/src/witness/common/cf_parameters.rs

@@ -1,7 +1,9 @@
 use cf_chains::{CcmAdditionalData, ChannelRefundParameters};
-use cf_primitives::{AffiliateShortId, BasisPoints, Beneficiaries, DcaParameters};
+use cf_primitives::{AccountId, AffiliateAndFee, Beneficiary, DcaParameters, MAX_AFFILIATES};
 use codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
+use sp_core::ConstU32;
+use sp_runtime::BoundedVec;
 
 #[derive(Encode, Decode, MaxEncodedLen, TypeInfo, Clone, PartialEq, Debug)]
 pub enum VersionedCfParameters<CcmData = ()> {
@@ -21,19 +23,27 @@ pub type VersionedCcmCfParameters = VersionedCfParameters<CcmAdditionalData>;
 pub struct VaultSwapParameters {
 	pub refund_params: ChannelRefundParameters,
 	pub dca_params: Option<DcaParameters>,
-	pub boost_fee: Option<BasisPoints>,
-	pub broker_fees: Beneficiaries<AffiliateShortId>,
+	pub boost_fee: u8,
+	pub broker_fee: Beneficiary<AccountId>,
+	pub affiliate_fees: BoundedVec<AffiliateAndFee, ConstU32<MAX_AFFILIATES>>,
 }
 
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use cf_chains::MAX_CCM_ADDITIONAL_DATA_LENGTH;
+	use cf_chains::{ChannelRefundParameters, ForeignChainAddress, MAX_CCM_ADDITIONAL_DATA_LENGTH};
 
 	const MAX_VAULT_SWAP_PARAMETERS_LENGTH: u32 = 1_000;
 	const MAX_CF_PARAM_LENGTH: u32 =
 		MAX_CCM_ADDITIONAL_DATA_LENGTH + MAX_VAULT_SWAP_PARAMETERS_LENGTH;
 
+	const REFERENCE_EXPECTED_ENCODED: &[u8] = &[
+		0, 1, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+		3, 3, 4, 0, 0,
+	];
+
 	#[test]
 	fn test_cf_parameters_max_length() {
 		assert!(
@@ -44,4 +54,40 @@ mod tests {
 			MAX_VAULT_SWAP_PARAMETERS_LENGTH as usize >= VaultSwapParameters::max_encoded_len()
 		);
 	}
+
+	#[test]
+	fn test_versioned_cf_parameters() {
+		let vault_swap_parameters = VaultSwapParameters {
+			refund_params: ChannelRefundParameters {
+				retry_duration: 1,
+				refund_address: ForeignChainAddress::Eth(sp_core::H160::from([2; 20])),
+				min_price: Default::default(),
+			},
+			dca_params: None,
+			boost_fee: 0,
+			broker_fee: Beneficiary { account: AccountId::new([3; 32]), bps: 4 },
+			affiliate_fees: sp_core::bounded_vec![],
+		};
+
+		let cf_parameters = CfParameters::<()> {
+			ccm_additional_data: (),
+			vault_swap_parameters: vault_swap_parameters.clone(),
+		};
+
+		let mut encoded = VersionedCfParameters::V0(cf_parameters).encode();
+
+		assert_eq!(encoded, REFERENCE_EXPECTED_ENCODED);
+
+		let ccm_cf_parameters = CfParameters {
+			ccm_additional_data: CcmAdditionalData::default(),
+			vault_swap_parameters,
+		};
+
+		encoded = VersionedCcmCfParameters::V0(ccm_cf_parameters).encode();
+
+		// Extra byte for the empty ccm metadata
+		let expected_encoded = [vec![0], Vec::from(REFERENCE_EXPECTED_ENCODED)].concat();
+
+		assert_eq!(encoded, expected_encoded);
+	}
 }