Accounting contract and binance client traits (#3435)

* accounting contract trait

* BinanceClient trait

Author: kziemianek

tee-worker/omni-executor/Cargo.lock

@@ -4,6 +4,7 @@ use alloy::{
 	sol,
 	sol_types::{SolInterface, SolValue},
 };
+use async_trait::async_trait;
 use ethereum_rpc::RpcProvider;
 use AccountingContract::AccountingContractCalls;
 
@@ -14,17 +15,37 @@ sol!(
 	"./abi/AccountingContract.json"
 );
 
-pub struct AccountingContractClient<P: RpcProvider<Transaction = TransactionRequest>> {
+#[async_trait]
+pub trait AccountingContractApi: Send + Sync {
+	async fn execute_pay_out_request(
+		&self,
+		beneficiary: Address,
+		nonce: U256,
+		amount: U256,
+	) -> Result<(), ()>;
+
+	async fn get_nonce(&self, user: Address) -> Result<U256, ()>;
+
+	async fn get_balance(&self) -> Result<U256, ()>;
+}
+
+pub struct AccountingContractClient<P: RpcProvider<Transaction = TransactionRequest> + Send + Sync>
+{
 	pub provider: P,
 	pub contract_address: Address,
 }
 
-impl<P: RpcProvider<Transaction = TransactionRequest>> AccountingContractClient<P> {
+impl<P: RpcProvider<Transaction = TransactionRequest> + Send + Sync> AccountingContractClient<P> {
 	pub fn new(provider: P, contract_address: Address) -> Self {
 		Self { provider, contract_address }
 	}
+}
 
-	pub async fn execute_pay_out_request(
+#[async_trait]
+impl<P: RpcProvider<Transaction = TransactionRequest> + Send + Sync> AccountingContractApi
+	for AccountingContractClient<P>
+{
+	async fn execute_pay_out_request(
 		&self,
 		beneficiary: Address,
 		nonce: U256,
@@ -43,7 +64,7 @@ impl<P: RpcProvider<Transaction = TransactionRequest>> AccountingContractClient<
 		self.provider.send_transaction(tx).await
 	}
 
-	pub async fn get_nonce(&self, user: Address) -> Result<U256, ()> {
+	async fn get_nonce(&self, user: Address) -> Result<U256, ()> {
 		let call = AccountingContractCalls::getNonce(AccountingContract::getNonceCall { user })
 			.abi_encode();
 		let tx = TransactionRequest {
@@ -57,7 +78,7 @@ impl<P: RpcProvider<Transaction = TransactionRequest>> AccountingContractClient<
 		})
 	}
 
-	pub async fn get_balance(&self) -> Result<U256, ()> {
+	async fn get_balance(&self) -> Result<U256, ()> {
 		let call =
 			AccountingContractCalls::getBalance(AccountingContract::getBalanceCall {}).abi_encode();
 		let tx = TransactionRequest {

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

@@ -5,6 +5,7 @@ authors = ['Trust Computing GmbH <info@litentry.com>']
 edition.workspace = true
 
 [dependencies]
+async-trait = { workspace = true }
 chrono = { workspace = true }
 hex = { workspace = true }
 hmac = { workspace = true }

tee-worker/omni-executor/binance-api/Cargo.toml

@@ -1,6 +1,7 @@
 mod types;
 
-use crate::{error::Error, traits::TryIntoParams, types::AssetSymbol, BinanceApi, Method};
+use crate::BinanceApi;
+use crate::{error::Error, traits::TryIntoParams, types::AssetSymbol, BinanceApiClient, Method};
 use log::error;
 use std::collections::HashMap;
 use types::{
@@ -14,11 +15,11 @@ const CONVERT_API: &str = "/sapi/v1/convert";
 const MAX_LIMIT: u16 = 1000;
 
 pub struct ConvertApi<'a> {
-	base_api: &'a BinanceApi,
+	base_api: &'a BinanceApiClient,
 }
 
 impl<'a> ConvertApi<'a> {
-	pub fn new(binance_api: &BinanceApi) -> ConvertApi {
+	pub fn new(binance_api: &BinanceApiClient) -> ConvertApi {
 		ConvertApi { base_api: binance_api }
 	}
 

tee-worker/omni-executor/binance-api/src/convert_api/mod.rs

@@ -5,6 +5,7 @@ mod traits;
 mod types;
 mod wallet_api;
 
+use async_trait::async_trait;
 use convert_api::ConvertApi;
 use error::Error;
 use hmac::{Hmac, Mac};
@@ -21,8 +22,34 @@ use wallet_api::WalletApi;
 
 const MAX_RECV_WINDOW: u32 = 60000;
 
+#[async_trait]
+pub trait BinanceApi: Send + Sync {
+	fn convert(&self) -> ConvertApi;
+	fn spot_trading(&self) -> SpotTradingApi;
+	fn wallet(&self) -> WalletApi;
+
+	fn sign_request(&self, query_string: &str) -> String;
+	async fn make_public_get_request<T>(
+		&self,
+		endpoint: &str,
+		parameters: Option<HashMap<String, String>>,
+	) -> Result<T, Error>
+	where
+		T: serde::de::DeserializeOwned;
+
+	async fn make_signed_request<T>(
+		&self,
+		endpoint: &str,
+		method: Method,
+		parameters: Option<HashMap<String, String>>,
+		recv_window: Option<u32>,
+	) -> Result<T, Error>
+	where
+		T: serde::de::DeserializeOwned;
+}
+
 #[derive(Debug, Clone)]
-pub struct BinanceApi {
+pub struct BinanceApiClient {
 	client: Client,
 	base_url: Url,
 	api_key: String,
@@ -36,33 +63,36 @@ pub enum BinanceApiResponse<T> {
 	Error { code: i32, msg: String },
 }
 
-impl BinanceApi {
-	pub fn new(api_key: String, api_secret: String, base_url: Option<String>) -> BinanceApi {
+impl BinanceApiClient {
+	pub fn new(api_key: String, api_secret: String, base_url: Option<String>) -> BinanceApiClient {
 		let base_url = match base_url {
 			Some(url) => Url::parse(&url).expect("Invalid base URL"),
 			None => Url::parse("https://api.binance.com").unwrap(),
 		};
 		let client = Client::new();
-		BinanceApi { client, base_url, api_key, api_secret }
+		BinanceApiClient { client, base_url, api_key, api_secret }
 	}
+}
 
+#[async_trait]
+impl BinanceApi for BinanceApiClient {
 	/// Create a new ConvertApi instance
-	pub fn convert(&self) -> ConvertApi {
+	fn convert(&self) -> ConvertApi {
 		ConvertApi::new(self)
 	}
 
 	/// Create a new SpotTradingApi instance
-	pub fn spot_trading(&self) -> SpotTradingApi {
+	fn spot_trading(&self) -> SpotTradingApi {
 		SpotTradingApi::new(self)
 	}
 
 	/// Create a new WalletApi instance
-	pub fn wallet(&self) -> WalletApi {
+	fn wallet(&self) -> WalletApi {
 		WalletApi::new(self)
 	}
 
 	/// Create HMAC SHA256 signature for request parameters
-	pub fn sign_request(&self, query_string: &str) -> String {
+	fn sign_request(&self, query_string: &str) -> String {
 		let mut mac = Hmac::<Sha256>::new_from_slice(self.api_secret.as_bytes())
 			.expect("HMAC can take key of any size");
 		mac.update(query_string.as_bytes());
@@ -72,7 +102,7 @@ impl BinanceApi {
 	}
 
 	/// Helper for making public API requests
-	pub async fn make_public_get_request<T>(
+	async fn make_public_get_request<T>(
 		&self,
 		endpoint: &str,
 		parameters: Option<HashMap<String, String>>,
@@ -109,7 +139,7 @@ impl BinanceApi {
 	}
 
 	/// Helper for making signed API requests
-	pub async fn make_signed_request<T>(
+	async fn make_signed_request<T>(
 		&self,
 		endpoint: &str,
 		method: Method,
@@ -200,7 +230,7 @@ mod tests {
 		let api_secret =
 			"NhqPtmdSJYdKjVHjA7PZj4Mge3R5YNiP1e3UZjInClVN65XAbvqqM6A7H5fATj0j".to_string();
 		let query_string = "symbol=LTCBTC&side=BUY&type=LIMIT&timeInForce=GTC&quantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559".to_string();
-		let binance_api = BinanceApi::new(api_key, api_secret, None);
+		let binance_api = BinanceApiClient::new(api_key, api_secret, None);
 		let signature = binance_api.sign_request(&query_string);
 
 		assert_eq!(signature, "c8db56825ae71d6d79447849e617115f4a920fa2acdcab2b053c4b2838bd6b71");

tee-worker/omni-executor/binance-api/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod types;
 
-use crate::{error::Error, traits::TryIntoParams, BinanceApi, Method};
+use crate::BinanceApi;
+use crate::{error::Error, traits::TryIntoParams, BinanceApiClient, Method};
 use std::collections::HashMap;
 use types::{
 	AccountInfo, CancelOrderRestrictions, CreateOrderParams, EmptyResponse, ExchangeInfo,
@@ -11,11 +12,11 @@ use types::{
 const SPOT_TRADING_API: &str = "/api/v3";
 
 pub struct SpotTradingApi<'a> {
-	base_api: &'a BinanceApi,
+	base_api: &'a BinanceApiClient,
 }
 
 impl<'a> SpotTradingApi<'a> {
-	pub fn new(binance_api: &BinanceApi) -> SpotTradingApi {
+	pub fn new(binance_api: &BinanceApiClient) -> SpotTradingApi {
 		SpotTradingApi { base_api: binance_api }
 	}
 

tee-worker/omni-executor/binance-api/src/spot_trading_api/mod.rs

@@ -2,18 +2,19 @@ mod types;
 
 use types::{CoinInfo, Deposit, DepositAddress, WithdrawOrder};
 
-use crate::{error::Error, BinanceApi, Method};
+use crate::BinanceApi;
+use crate::{error::Error, BinanceApiClient, Method};
 use std::collections::HashMap;
 
 /// https://developers.binance.com/docs/wallet/Introduction
 const WALLET_API: &str = "/sapi/v1";
 
 pub struct WalletApi<'a> {
-	base_api: &'a BinanceApi,
+	base_api: &'a BinanceApiClient,
 }
 
 impl<'a> WalletApi<'a> {
-	pub fn new(binance_api: &BinanceApi) -> WalletApi {
+	pub fn new(binance_api: &BinanceApiClient) -> WalletApi {
 		WalletApi { base_api: binance_api }
 	}
 

tee-worker/omni-executor/binance-api/src/wallet_api/mod.rs

@@ -44,7 +44,7 @@ impl RpcProviderFactory for AlloyRpcProviderFactory {
 }
 
 #[async_trait]
-pub trait RpcProvider {
+pub trait RpcProvider: Send + Sync {
 	type Addr;
 	type Transaction;
 

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

@@ -18,7 +18,7 @@ use crate::cli::Cli;
 use accounting_contract_client::AccountingContractClient;
 use alloy::network::EthereumWallet;
 use alloy::signers::local::PrivateKeySigner;
-use binance_api::BinanceApi;
+use binance_api::BinanceApiClient;
 use clap::Parser;
 use cli::*;
 use cross_chain_intent_executor::{Chain, CrossChainIntentExecutor, RpcEndpointRegistry};
@@ -199,7 +199,7 @@ async fn main() -> Result<(), ()> {
 			let binance_api_key = env::var("OE_BINANCE_API_KEY").unwrap_or("".to_string());
 			let binance_api_secret = env::var("OE_BINANCE_API_SECRET").unwrap_or("".to_string());
 			let binance_api_base_url = env::var("OE_BINANCE_API_BASE_URL").ok();
-			let binance_api = Arc::new(BinanceApi::new(
+			let binance_api = Arc::new(BinanceApiClient::new(
 				binance_api_key,
 				binance_api_secret,
 				binance_api_base_url,
@@ -229,7 +229,7 @@ async fn main() -> Result<(), ()> {
 				storage_db.clone(),
 				binance_api,
 				solana_client,
-				Arc::new(accounting_contract_client),
+				Arc::new(Box::new(accounting_contract_client)),
 			)?;
 
 			let task_handler_context = TaskHandlerContext::new(

tee-worker/omni-executor/executor-worker/src/main.rs

@@ -14,21 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with Litentry.  If not, see <https://www.gnu.org/licenses/>.
 
-use accounting_contract_client::AccountingContractClient;
-use alloy::{
-	primitives::{Address, U256},
-	rpc::types::TransactionRequest,
-};
+use alloy::primitives::{Address, U256};
 use async_trait::async_trait;
 use base58::ToBase58;
-use binance_api::{
-	spot_trading_api::types::{
-		CreateOrderParams as BinanceCreateOrderParams, OrderSide as BinanceOrderSide,
-		OrderStatus as BinanceOrderStatus, OrderType as BinanceOrderType,
-	},
-	BinanceApi,
+use binance_api::spot_trading_api::types::{
+	CreateOrderParams as BinanceCreateOrderParams, OrderSide as BinanceOrderSide,
+	OrderStatus as BinanceOrderStatus, OrderType as BinanceOrderType,
 };
-use ethereum_rpc::RpcProvider as EthereumRpcProvider;
 use executor_core::intent_executor::{IntentExecutionResult, IntentExecutor};
 use executor_primitives::Intent;
 use executor_primitives::IntentId;
@@ -66,6 +58,8 @@ use pumpx::{pubkey_to_evm_address, pubkey_to_solana_address};
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use accounting_contract_client::AccountingContractApi;
+use binance_api::BinanceApi;
 use executor_primitives::AccountId;
 use executor_primitives::ChainAsset;
 use parentchain_rpc_client::metadata::Metadata;
@@ -101,30 +95,27 @@ const SOLANA_USDC_MINT_ADDRESS: &str = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyT
 const SOLANA_USDT_MINT_ADDRESS: &str = "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB";
 
 // TODO: should we rename this to something like MultiChainIntentExecutor?
-pub struct CrossChainIntentExecutor<Provider: EthereumRpcProvider<Transaction = TransactionRequest>>
-{
+pub struct CrossChainIntentExecutor<BinanceClient: BinanceApi> {
 	// account_asset_lock: AccountAssetLocks<AlwaysUnlockedAssetsLock>,
 	// rpc_endpoint_registry: RpcEndpointRegistry,
 	pumpx_signer_client: Arc<Box<dyn SignerClient>>,
 	pumpx_api: Arc<Box<dyn PumpxApi>>,
 	storage_db: Arc<StorageDB>,
-	binance_api: Arc<BinanceApi>,
+	binance_api: Arc<BinanceClient>,
 	solana_client: Arc<Box<dyn SolanaClient>>,
-	accounting_contract_client: Arc<AccountingContractClient<Provider>>,
+	accounting_contract_client: Arc<Box<dyn AccountingContractApi>>,
 }
 
-impl<Provider: EthereumRpcProvider<Transaction = TransactionRequest>>
-	CrossChainIntentExecutor<Provider>
-{
+impl<BinanceClient: BinanceApi> CrossChainIntentExecutor<BinanceClient> {
 	#[allow(clippy::too_many_arguments)]
 	pub fn new(
 		_rpc_endpoint_registry: RpcEndpointRegistry,
 		pumpx_signer_client: Arc<Box<dyn SignerClient>>,
 		pumpx_api: Arc<Box<dyn PumpxApi>>,
 		storage_db: Arc<StorageDB>,
-		binance_api: Arc<BinanceApi>,
+		binance_api: Arc<BinanceClient>,
 		solana_client: Arc<Box<dyn SolanaClient>>,
-		accounting_contract_client: Arc<AccountingContractClient<Provider>>,
+		accounting_contract_client: Arc<Box<dyn AccountingContractApi>>,
 	) -> Result<Self, ()> {
 		// there is no need for account/assets locks if we guarantee the dest-chain payout happens after the source chain finalisation
 		// let account_asset_lock = AccountAssetLocks::<AlwaysUnlockedAssetsLock>::empty();
@@ -142,9 +133,7 @@ impl<Provider: EthereumRpcProvider<Transaction = TransactionRequest>>
 }
 
 #[async_trait]
-impl<Provider: EthereumRpcProvider<Transaction = TransactionRequest> + Send + Sync> IntentExecutor
-	for CrossChainIntentExecutor<Provider>
-{
+impl<BinanceClient: BinanceApi> IntentExecutor for CrossChainIntentExecutor<BinanceClient> {
 	#[allow(unused_assignments)]
 	async fn execute(
 		&self,
@@ -1127,8 +1116,8 @@ mod tests {
 	}
 }
 
-async fn estimate_bnb_amount(
-	binance_api: &Arc<BinanceApi>,
+async fn estimate_bnb_amount<BinanceClient: BinanceApi>(
+	binance_api: &Arc<BinanceClient>,
 	trade_symbol: &str,
 	binance_coin_name: &str,
 	from_amount_decimal: Decimal,