Fix ccsp (#3567)

* feat: add bsc token FC for ccsp

* fix: fix wrong logic of get_nonce in solana cotract client

* fix: fix wrong logic of get_nonce in solana cotract client and add trade_symbol for token FC

---------

Signed-off-by: wli <120463031+wli-pro@users.noreply.github.com>
Co-authored-by: wli-pro <wli-pro>

Author: wli-pro

tee-worker/omni-executor/Cargo.lock

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

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

@@ -3,7 +3,6 @@ use std::sync::Arc;
 
 use alloy::primitives::U256;
 use anchor_client::{
-	anchor_lang::AccountDeserialize,
 	solana_sdk::{
 		commitment_config::CommitmentConfig,
 		pubkey::Pubkey,
@@ -15,34 +14,7 @@ use anchor_client::{
 };
 use async_trait::async_trait;
 use sp_core::ed25519;
-use tracing::{error, info, warn};
-
-#[derive(Debug)]
-pub struct NonceAccount {
-	pub nonce: u64,
-}
-
-impl AccountDeserialize for NonceAccount {
-	fn try_deserialize_unchecked(buf: &mut &[u8]) -> anchor_client::anchor_lang::Result<Self> {
-		if buf.len() < 8 {
-			return Ok(NonceAccount { nonce: 0 });
-		}
-
-		let data = &buf[8..];
-
-		if data.len() < 8 {
-			return Ok(NonceAccount { nonce: 0 });
-		}
-
-		let nonce = u64::from_le_bytes(data[..8].try_into().map_err(|_| {
-			anchor_client::anchor_lang::error::Error::from(
-				anchor_client::anchor_lang::error::ErrorCode::AccountDidNotDeserialize,
-			)
-		})?);
-
-		Ok(NonceAccount { nonce })
-	}
-}
+use tracing::{error, warn};
 
 #[async_trait]
 pub trait AccountingContractApi: Send + Sync {
@@ -150,28 +122,36 @@ impl AccountingContractApi for AccountingContractClient {
 	async fn get_nonce(&self, user: Pubkey) -> Result<u64, ()> {
 		let client = self.create_client()?;
 
-		let (account_nonce, _bump) =
-			Pubkey::find_program_address(&[user.to_bytes().as_ref(), b"nonce"], &self.program_id);
-
 		let program = client.program(self.program_id).map_err(|e| {
 			error!("Failed to create program client: {:?}", e);
 		})?;
 
-		let nonce_account: NonceAccount =
-			tokio::task::spawn_blocking(move || program.account(account_nonce))
-				.await
-				.map_err(|e| {
-					error!("Failed to spawn blocking task: {:?}", e);
-				})?
-				.map_err(|e| {
-					if e.to_string().contains("AccountNotFound") {
-						info!("Nonce account {} not found, returning 0", account_nonce);
-					} else {
-						error!("Failed to get nonce account {}: {:?}", account_nonce, e);
-					}
-				})?;
+		let (account_pubkey, _bump) =
+			Pubkey::find_program_address(&[user.to_bytes().as_ref(), b"nonce"], &self.program_id);
 
-		Ok(nonce_account.nonce)
+		match tokio::task::spawn_blocking(move || 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)
+				},
+			},
+			Err(e) => {
+				error!("Failed to spawn blocking task: {:?}", e);
+				Err(())
+			},
+		}
 	}
 
 	async fn get_balance(&self) -> Result<U256, ()> {

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

@@ -878,6 +878,9 @@ pub(crate) fn determine_trade_symbol_and_order_side(
 	to_network: BinanceNetwork,
 ) -> Result<(String, BinanceOrderSide), ()> {
 	match (binance_network.clone(), binance_coin.clone(), to_network.clone()) {
+		(BinanceNetwork::Sol, BinanceCoin::Fc, BinanceNetwork::Bsc) => {
+			Ok(("BNBFC".to_string(), BinanceOrderSide::BUY))
+		},
 		(BinanceNetwork::Sol, BinanceCoin::Usdc, BinanceNetwork::Bsc) => {
 			Ok(("BNBUSDC".to_string(), BinanceOrderSide::BUY))
 		},

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

@@ -42,6 +42,7 @@ impl BinanceNetwork {
 pub enum BinanceCoin {
 	Bnb,
 	Sol,
+	Fc,
 	Usdc,
 	Usdt,
 }
@@ -50,21 +51,23 @@ impl BinanceCoin {
 	// Biannce coin names
 	const BNB: &'static str = "BNB";
 	const SOL: &'static str = "SOL";
+	const FC: &'static str = "FC";
 	const USDC: &'static str = "USDC";
 	const USDT: &'static str = "USDT";
 
 	pub fn name(&self) -> &'static str {
 		match self {
 			Self::Bnb => Self::BNB,
 			Self::Sol => Self::SOL,
+			Self::Fc => Self::FC,
 			Self::Usdc => Self::USDC,
 			Self::Usdt => Self::USDT,
 		}
 	}
 
 	pub fn decimals(&self) -> u32 {
 		match self {
-			BinanceCoin::Bnb => 18,
+			BinanceCoin::Fc | BinanceCoin::Bnb => 18,
 			BinanceCoin::Sol => 9,
 			BinanceCoin::Usdc | BinanceCoin::Usdt => 6,
 		}
@@ -77,6 +80,7 @@ impl BinanceCoin {
 
 pub trait FromBscTokenAddress {
 	// Bsc token addresss
+	const BSC_TOKEN_ADDRESS_FC: &'static str = "4C3617A56a5E0Ca1D8CDd629695b0a8BE669971A";
 	const BSC_TOKEN_ADDRESS_USDC: &'static str = "8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d";
 	const BSC_TOKEN_ADDRESS_USDT: &'static str = "55d398326f99059fF775485246999027B3197955";
 
@@ -86,6 +90,7 @@ pub trait FromBscTokenAddress {
 impl FromBscTokenAddress for BinanceCoin {
 	fn from_bsc_token_address(address: &str) -> Result<BinanceCoin, ()> {
 		match address {
+			Self::BSC_TOKEN_ADDRESS_FC => Ok(Self::Fc),
 			Self::BSC_TOKEN_ADDRESS_USDC => Ok(Self::Usdc),
 			Self::BSC_TOKEN_ADDRESS_USDT => Ok(Self::Usdt),
 			_ => {