chore: combine do_binance_swap_sol_to_bsc and do_binance_swap_bsc_to_sol into do_binance_swap, combine do_payout_sol_to_bsc and do_payout_bsc_to_sol infodo_payout (#3510)

Co-authored-by: wli-pro <wli-pro>

Author: wli-pro

tee-worker/omni-executor/accounting-contract-client/Cargo.toml

@@ -6,7 +6,7 @@ edition.workspace = true
 [dependencies]
 accounting-contract = { workspace = true }
 alloy = { workspace = true, features = ["contract", "signer-local", "rpc", "rpc-types", "eips"] }
-anchor-client = { workspace = true }
+anchor-client = { workspace = true, features = ["async"] }
 async-trait = { workspace = true }
 bincode = { workspace = true }
 ethereum-rpc = { workspace = true }

tee-worker/omni-executor/accounting-contract-client/src/lib.rs

@@ -17,22 +17,52 @@ sol!(
 	"./abi/AccountingContract.json"
 );
 
+pub trait Plus<RHS = Self> {
+	type Output;
+
+	fn plus(self, rhs: RHS) -> Self::Output;
+}
+
+impl Plus<u64> for U256 {
+	type Output = U256;
+
+	fn plus(self, rhs: u64) -> Self::Output {
+		self + U256::from(rhs)
+	}
+}
+
+impl Plus<u64> for u64 {
+	type Output = u64;
+
+	fn plus(self, rhs: u64) -> Self::Output {
+		self + rhs
+	}
+}
+
 #[async_trait]
-pub trait AccountingContractApi: Send + Sync {
+pub trait AccountingContractApi<A, N>: Send + Sync
+where
+	A: Send + Sync,
+	N: Plus<u64, Output = N> + std::fmt::Debug,
+{
 	async fn execute_pay_out_request(
 		&self,
-		beneficiary: Address,
-		nonce: U256,
+		beneficiary: A,
+		nonce: N,
 		amount: U256,
 	) -> Result<(), ()>;
 
-	async fn get_nonce(&self, user: Address) -> Result<U256, ()>;
+	async fn get_nonce(&self, user: A) -> Result<N, ()>;
 
 	async fn get_balance(&self) -> Result<U256, ()>;
 
-	async fn get_address(&self) -> Address;
+	async fn get_address(&self) -> A {
+		unimplemented!("Please provide contract address in implementation")
+	}
 
-	async fn get_signer_address(&self) -> Address;
+	async fn get_signer_address(&self) -> A {
+		unimplemented!("Please provide signer address in implementation")
+	}
 }
 
 pub struct AccountingContractClient<P: RpcProvider<Transaction = TransactionRequest> + Send + Sync>
@@ -48,8 +78,8 @@ impl<P: RpcProvider<Transaction = TransactionRequest> + Send + Sync> AccountingC
 }
 
 #[async_trait]
-impl<P: RpcProvider<Transaction = TransactionRequest> + Send + Sync> AccountingContractApi
-	for AccountingContractClient<P>
+impl<P: RpcProvider<Transaction = TransactionRequest> + Send + Sync>
+	AccountingContractApi<Address, U256> for AccountingContractClient<P>
 {
 	async fn execute_pay_out_request(
 		&self,
@@ -120,7 +150,7 @@ pub mod mocks {
 		pub AccountingContractClient {}
 
 		#[async_trait]
-		impl AccountingContractApi for AccountingContractClient {
+		impl AccountingContractApi<Address, U256> for AccountingContractClient {
 
 			async fn execute_pay_out_request(
 				&self,

tee-worker/omni-executor/accounting-contract-client/src/solana.rs

@@ -1,6 +1,6 @@
 use std::str::FromStr;
-use std::sync::Arc;
 
+use crate::AccountingContractApi;
 use alloy::primitives::U256;
 use anchor_client::{
 	solana_sdk::{
@@ -14,22 +14,9 @@ use anchor_client::{
 };
 use async_trait::async_trait;
 use sp_core::ed25519;
+use std::sync::Arc;
 use tracing::{error, warn};
 
-#[async_trait]
-pub trait AccountingContractApi: Send + Sync {
-	async fn execute_pay_out_request(
-		&self,
-		beneficiary: Pubkey,
-		nonce: u64,
-		amount: U256,
-	) -> Result<(), ()>;
-
-	async fn get_nonce(&self, user: Pubkey) -> Result<u64, ()>;
-
-	async fn get_balance(&self) -> Result<U256, ()>;
-}
-
 pub struct AccountingContractClient {
 	pub payer: Keypair,
 	pub solana_url: String,
@@ -58,65 +45,48 @@ impl AccountingContractClient {
 }
 
 #[async_trait]
-impl AccountingContractApi for AccountingContractClient {
+impl AccountingContractApi<Pubkey, u64> for AccountingContractClient {
 	async fn execute_pay_out_request(
 		&self,
 		beneficiary: Pubkey,
 		nonce: u64,
 		amount: U256,
 	) -> Result<(), ()> {
 		let client = self.create_client()?;
-		let program = client.program(self.program_id).map_err(|e| {
-			error!("Failed to create program client: {:?}", e);
-		})?;
 
-		let result = tokio::task::spawn_blocking(move || {
-			program
-				.request()
-				.accounts(accounting_contract::accounts::CreatePayRequest {
-					pay_out_request: Pubkey::find_program_address(
-						&[beneficiary.to_bytes().as_ref(), &nonce.to_le_bytes(), b"payout_request"],
-						&program.id(),
-					)
-					.0,
-					account_nonce: Pubkey::find_program_address(
-						&[beneficiary.to_bytes().as_ref(), b"nonce"],
-						&program.id(),
-					)
-					.0,
-					signer: program.payer(),
-					worker: Pubkey::find_program_address(&[b"worker"], &program.id()).0,
-					treasury: Pubkey::find_program_address(&[b"treasury"], &program.id()).0,
-					beneficiary,
-					system_program: system_program::ID,
-				})
-				.args(accounting_contract::instruction::CreatePayRequest {
-					amount: amount.try_into().map_err(|_| {
-						error!("Failed to convert U256 to u64");
-						anchor_client::ClientError::from(std::io::Error::new(
-							std::io::ErrorKind::InvalidData,
-							"Failed to convert U256 to u64",
-						))
-					})?,
-					nonce,
-				})
-				.send()
-		})
-		.await;
-
-		match result {
-			Ok(anchor_result) => match anchor_result {
-				Ok(_) => Ok(()),
-				Err(e) => {
-					error!("Anchor client error: {:?}", e);
-					Err(())
-				},
-			},
-			Err(e) => {
+		let program = client.program(self.program_id).expect("Failed to create program client");
+
+		program
+			.request()
+			.accounts(accounting_contract::accounts::CreatePayRequest {
+				pay_out_request: Pubkey::find_program_address(
+					&[beneficiary.to_bytes().as_ref(), &nonce.to_le_bytes(), b"payout_request"],
+					&program.id(),
+				)
+				.0,
+				account_nonce: Pubkey::find_program_address(
+					&[beneficiary.to_bytes().as_ref(), b"nonce"],
+					&program.id(),
+				)
+				.0,
+				signer: self.payer.pubkey(),
+				worker: Pubkey::find_program_address(&[b"worker"], &program.id()).0,
+				treasury: Pubkey::find_program_address(&[b"treasury"], &program.id()).0,
+				beneficiary,
+				system_program: system_program::ID,
+			})
+			.args(accounting_contract::instruction::CreatePayRequest {
+				amount: amount.try_into().map_err(|_| {
+					error!("Failed to convert U256 amount to u64");
+				})?,
+				nonce,
+			})
+			.send()
+			.await
+			.map_err(|e| {
 				error!("Failed to execute pay out request: {:?}", e);
-				Err(())
-			},
-		}
+			})?;
+		Ok(())
 	}
 
 	async fn get_nonce(&self, user: Pubkey) -> Result<u64, ()> {
@@ -129,46 +99,29 @@ impl AccountingContractApi for AccountingContractClient {
 		let (account_pubkey, _bump) =
 			Pubkey::find_program_address(&[user.to_bytes().as_ref(), b"nonce"], &self.program_id);
 
-		match tokio::task::spawn_blocking(move || program.rpc().get_account(&account_pubkey)).await
-		{
+		match program.rpc().get_account(&account_pubkey).await {
 			// return default nonce 0 when fail to get nonce
-			Ok(result) => match result {
-				Ok(account) => {
-					match bincode::deserialize::<accounting_contract::Nonce>(&account.data[8..]) {
-						Ok(nonce) => Ok(nonce.nonce),
-						Err(e) => {
-							error!("Failed deserialize nonce from account {:?}: {:?}", account, e);
-							Ok(0)
-						},
-					}
-				},
-				Err(e) => {
-					error!("Failed to get_account {:?}", e);
-					Ok(0)
-				},
+			Ok(account) => {
+				match bincode::deserialize::<accounting_contract::Nonce>(&account.data[8..]) {
+					Ok(nonce) => Ok(nonce.nonce),
+					Err(e) => {
+						error!("Failed deserialize nonce from account {:?}: {:?}", account, e);
+						Ok(0)
+					},
+				}
 			},
 			Err(e) => {
-				error!("Failed to spawn blocking task: {:?}", e);
-				Err(())
+				error!("Failed to get_account {:?}", e);
+				Ok(0)
 			},
 		}
 	}
 
 	async fn get_balance(&self) -> Result<U256, ()> {
 		let client = self.create_client()?;
-		let program = client.program(self.program_id).map_err(|e| {
-			error!("Failed to create program client: {:?}", e);
-		})?;
 
-		let payer_pubkey = self.payer.pubkey();
-		let balance_result =
-			tokio::task::spawn_blocking(move || program.rpc().get_balance(&payer_pubkey))
-				.await
-				.map_err(|e| {
-					error!("Failed to spawn blocking task: {:?}", e);
-				})?;
-
-		match balance_result {
+		let program = client.program(self.program_id).expect("Failed to create program client");
+		match program.rpc().get_balance(&self.payer.pubkey()).await {
 			Ok(v) => {
 				let balance = U256::try_from(v).map_err(|err| {
 					warn!("Failed to convert balance to U256: {:?}", err);
@@ -185,17 +138,19 @@ impl AccountingContractApi for AccountingContractClient {
 
 #[cfg(feature = "mocks")]
 pub mod mocks {
-	use crate::solana::AccountingContractApi;
+	use crate::AccountingContractApi;
 	use crate::U256;
 	use anchor_client::solana_sdk::pubkey::Pubkey;
 	use async_trait::async_trait;
 	use mockall::mock;
 
 	mock! {
+
 		pub AccountingContractClient {}
 
 		#[async_trait]
-		impl AccountingContractApi for AccountingContractClient {
+		impl AccountingContractApi<Pubkey, u64> for AccountingContractClient {
+
 			async fn execute_pay_out_request(
 				&self,
 				beneficiary: Pubkey,

tee-worker/omni-executor/ethereum-rpc/src/signer.rs

@@ -7,6 +7,7 @@ use tracing::error;
 
 /// A remote signer implementation for EVM-compatible chains
 /// that delegates signing operations to a remote signing service
+#[derive(Clone)]
 pub struct RemoteSigner {
 	/// The client used to communicate with the remote signing service
 	signer_client: Arc<Box<dyn SignerClient>>,

tee-worker/omni-executor/intent/executors/cross-chain/src/lib.rs

@@ -26,10 +26,7 @@ use ::pumpx::methods::cross_fail::CrossFailBody;
 use ::pumpx::methods::send_order_tx::SendOrderTxBody;
 use ::pumpx::signer_client::PumpxChainId;
 use aa_contracts_client::calculate_omni_account_address;
-use accounting_contract_client::{
-	solana::AccountingContractApi as SolanaAccountingContractApi,
-	AccountingContractApi as EvmAccountingContractApi,
-};
+use accounting_contract_client::AccountingContractApi;
 use alloy::consensus::{SignableTransaction, TxLegacy};
 use alloy::network::TxSigner as AlloyTxSigner;
 use alloy::primitives::private::alloy_rlp::Decodable;
@@ -71,7 +68,6 @@ use rust_decimal::Decimal;
 use signer_client::{ChainType, SignerClient};
 use solana::{signer::RemoteSigner as RemoteSolanaSigner, SolanaClient as SolanaClientTrait};
 use solana_sdk::pubkey::Pubkey;
-use std::str::FromStr;
 use std::sync::Arc;
 use tokio::{
 	runtime::Handle,
@@ -113,8 +109,8 @@ pub struct CrossChainIntentExecutor<
 	binance_api: Arc<BinanceClient>,
 	bsc_client: Arc<EthereumClient>,
 	solana_client: Arc<SolanaClient>,
-	evm_accounting_contract_client: Arc<Box<dyn EvmAccountingContractApi>>,
-	solana_accounting_contract_client: Arc<Box<dyn SolanaAccountingContractApi>>,
+	evm_accounting_contract_client: Arc<Box<dyn AccountingContractApi<Address, U256>>>,
+	solana_accounting_contract_client: Arc<Box<dyn AccountingContractApi<Pubkey, u64>>>,
 	instant_payout_threshold: Decimal,
 	// AA contracts configuration
 	omni_account_factory_address: Address,
@@ -137,8 +133,8 @@ impl<
 		binance_api: Arc<BinanceClient>,
 		bsc_client: Arc<EthereumClient>,
 		solana_client: Arc<SolanaClient>,
-		evm_accounting_contract_client: Arc<Box<dyn EvmAccountingContractApi>>,
-		solana_accounting_contract_client: Arc<Box<dyn SolanaAccountingContractApi>>,
+		evm_accounting_contract_client: Arc<Box<dyn AccountingContractApi<Address, U256>>>,
+		solana_accounting_contract_client: Arc<Box<dyn AccountingContractApi<Pubkey, u64>>>,
 		instant_payout_threshold: Decimal,
 		omni_account_factory_address: Address,
 		omni_account_implementation_address: Address,
@@ -486,8 +482,8 @@ pub struct InstantFlowDetails {
 
 impl<
 		BinanceClient: BinanceApi,
-		EthereumClient: EthereumClientTrait,
-		SolanaClient: SolanaClientTrait,
+		EthereumClient: EthereumClientTrait + 'static,
+		SolanaClient: SolanaClientTrait + 'static,
 	> CrossChainIntentExecutor<BinanceClient, EthereumClient, SolanaClient>
 {
 	async fn do_omni_binance_deposit(
@@ -685,23 +681,6 @@ impl<
 		};
 		Ok((payout_amount, payout_amount_u256))
 	}
-
-	fn calculate_amount_decimal(
-		from_amount: Decimal,
-		binance_coin_name: &str,
-	) -> Result<Decimal, ()> {
-		let asset_decimal_multiplier = match binance_coin_name {
-			"USDC" => Decimal::from(1_000_000),    // 10^6
-			"USDT" => Decimal::from(1_000_000),    // 10^6
-			"SOL" => Decimal::from(1_000_000_000), // 10^9  TODO: double check this
-			"BNB" => Decimal::from_str("1_000_000_000_000_000_000").unwrap(), // 10^18
-			_ => {
-				error!("Unsupported asset: {:?}", binance_coin_name);
-				return Err(());
-			},
-		};
-		Ok(from_amount * asset_decimal_multiplier)
-	}
 }
 
 fn decimal_to_u256(decimal: Decimal) -> Result<U256, ParseError> {