diff --git a/crates/gem_hypercore/src/provider/transaction_state.rs b/crates/gem_hypercore/src/provider/transaction_state.rs index f55660f34..bb8f7b9dc 100644 --- a/crates/gem_hypercore/src/provider/transaction_state.rs +++ b/crates/gem_hypercore/src/provider/transaction_state.rs @@ -18,7 +18,7 @@ impl HyperCoreClient { pub async fn transaction_state(&self, request: TransactionStateRequest) -> Result> { match request.id.parse::() { Ok(oid) => { - let start_time = (request.created_at - 5) * 1000; + let start_time = request.created_at - 5_000; let fills = self.get_user_fills_by_time(&request.sender_address, start_time).await?; Ok(transaction_state_mapper::map_transaction_state_order(fills, oid, request.id)) } diff --git a/crates/primitives/src/job_configuration.rs b/crates/primitives/src/job_configuration.rs index 07fd1c574..847590f82 100644 --- a/crates/primitives/src/job_configuration.rs +++ b/crates/primitives/src/job_configuration.rs @@ -1,11 +1,22 @@ -use serde::{Deserialize, Serialize}; -use typeshare::typeshare; +use crate::Chain; -#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)] -#[typeshare(swift = "Sendable")] -#[serde(rename_all = "camelCase")] +const INITIAL_CAP_MS: u32 = 5_000; +const MAX_INTERVAL_MS: u32 = 15_000; +const STEP_FACTOR: f32 = 1.1; + +#[derive(Debug, Clone, Copy, PartialEq)] pub struct JobConfiguration { pub initial_interval_ms: u32, pub max_interval_ms: u32, pub step_factor: f32, } + +impl JobConfiguration { + pub fn transaction_state(chain: Chain) -> Self { + Self { + initial_interval_ms: chain.block_time().clamp(1, INITIAL_CAP_MS), + max_interval_ms: MAX_INTERVAL_MS, + step_factor: STEP_FACTOR, + } + } +} diff --git a/crates/primitives/src/transaction_state.rs b/crates/primitives/src/transaction_state.rs index f4a4528d8..fa7bbaa47 100644 --- a/crates/primitives/src/transaction_state.rs +++ b/crates/primitives/src/transaction_state.rs @@ -13,3 +13,26 @@ pub enum TransactionState { Failed, Reverted, } + +impl TransactionState { + pub fn is_completed(&self) -> bool { + match self { + Self::Confirmed | Self::Failed | Self::Reverted => true, + Self::Pending | Self::InTransit => false, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_is_completed() { + assert!(TransactionState::Confirmed.is_completed()); + assert!(TransactionState::Failed.is_completed()); + assert!(TransactionState::Reverted.is_completed()); + assert!(!TransactionState::Pending.is_completed()); + assert!(!TransactionState::InTransit.is_completed()); + } +} diff --git a/crates/primitives/src/transaction_update.rs b/crates/primitives/src/transaction_update.rs index eae84725d..a70c1b2db 100644 --- a/crates/primitives/src/transaction_update.rs +++ b/crates/primitives/src/transaction_update.rs @@ -1,4 +1,4 @@ -use crate::transaction_metadata_types::TransactionPerpetualMetadata; +use crate::transaction_metadata_types::{TransactionPerpetualMetadata, TransactionSwapMetadata}; use crate::transaction_state::TransactionState; use num_bigint::BigInt; use serde::{Deserialize, Serialize}; @@ -30,6 +30,7 @@ pub enum TransactionChange { #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] pub enum TransactionMetadata { Perpetual(TransactionPerpetualMetadata), + Swap(TransactionSwapMetadata), } #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] diff --git a/gemstone/src/gateway/chain_factory.rs b/gemstone/src/gateway/chain_factory.rs new file mode 100644 index 000000000..a9a79f470 --- /dev/null +++ b/gemstone/src/gateway/chain_factory.rs @@ -0,0 +1,103 @@ +use super::{GatewayError, GemPreferences, PreferencesWrapper}; +use crate::alien::{AlienProvider, new_alien_client}; +use crate::network::JsonRpcClient; +use chain_traits::ChainTraits; +use gem_algorand::rpc::AlgorandClientIndexer; +use gem_algorand::rpc::client::AlgorandClient; +use gem_aptos::rpc::client::AptosClient; +use gem_bitcoin::rpc::client::BitcoinClient; +use gem_cardano::rpc::client::CardanoClient; +use gem_cosmos::rpc::client::CosmosClient; +use gem_evm::rpc::EthereumClient; +use gem_hypercore::rpc::client::HyperCoreClient; +use gem_near::rpc::client::NearClient; +use gem_polkadot::rpc::client::PolkadotClient; +use gem_solana::rpc::client::SolanaClient; +use gem_stellar::rpc::client::StellarClient; +use gem_sui::rpc::client::SuiClient; +use gem_ton::rpc::client::TonClient; +use gem_tron::rpc::{client::TronClient, trongrid::client::TronGridClient}; +use gem_xrp::rpc::client::XRPClient; +use primitives::{BitcoinChain, Chain, EVMChain, chain_cosmos::CosmosChain}; +use std::sync::Arc; + +pub struct ChainClientFactory { + alien: Arc, + preferences: Arc, + secure_preferences: Arc, +} + +impl ChainClientFactory { + pub fn new(alien: Arc, preferences: Arc, secure_preferences: Arc) -> Self { + Self { + alien, + preferences, + secure_preferences, + } + } + + pub async fn create(&self, chain: Chain) -> Result, GatewayError> { + let url = self.alien.get_endpoint(chain).map_err(|e| GatewayError::PlatformError { msg: e.to_string() })?; + self.create_with_url(chain, url).await + } + + pub async fn create_with_url(&self, chain: Chain, url: String) -> Result, GatewayError> { + let alien_client = new_alien_client(url, self.alien.clone()); + match chain { + Chain::HyperCore => { + let preferences = Arc::new(PreferencesWrapper { + preferences: self.preferences.clone(), + }); + let secure_preferences = Arc::new(PreferencesWrapper { + preferences: self.secure_preferences.clone(), + }); + Ok(Arc::new(HyperCoreClient::new_with_preferences(alien_client, preferences, secure_preferences))) + } + Chain::Bitcoin | Chain::BitcoinCash | Chain::Litecoin | Chain::Doge | Chain::Zcash => { + Ok(Arc::new(BitcoinClient::new(alien_client, BitcoinChain::from_chain(chain).unwrap()))) + } + Chain::Cardano => Ok(Arc::new(CardanoClient::new(alien_client))), + Chain::Stellar => Ok(Arc::new(StellarClient::new(alien_client))), + Chain::Sui => Ok(Arc::new(SuiClient::new(JsonRpcClient::new(alien_client.clone())))), + Chain::Xrp => Ok(Arc::new(XRPClient::new(JsonRpcClient::new(alien_client.clone())))), + Chain::Algorand => Ok(Arc::new(AlgorandClient::new(alien_client.clone(), AlgorandClientIndexer::new(alien_client.clone())))), + Chain::Near => Ok(Arc::new(NearClient::new(JsonRpcClient::new(alien_client.clone())))), + Chain::Aptos => Ok(Arc::new(AptosClient::new(alien_client))), + Chain::Cosmos | Chain::Osmosis | Chain::Celestia | Chain::Thorchain | Chain::Injective | Chain::Sei | Chain::Noble => { + Ok(Arc::new(CosmosClient::new(CosmosChain::from_chain(chain).unwrap(), alien_client))) + } + Chain::Ton => Ok(Arc::new(TonClient::new(alien_client))), + Chain::Tron => Ok(Arc::new(TronClient::new(alien_client.clone(), TronGridClient::new(alien_client.clone(), String::new())))), + Chain::Polkadot => Ok(Arc::new(PolkadotClient::new(alien_client))), + Chain::Solana => Ok(Arc::new(SolanaClient::new(JsonRpcClient::new(alien_client.clone())))), + Chain::Ethereum + | Chain::Arbitrum + | Chain::SmartChain + | Chain::Polygon + | Chain::Optimism + | Chain::Base + | Chain::AvalancheC + | Chain::OpBNB + | Chain::Fantom + | Chain::Gnosis + | Chain::Manta + | Chain::Blast + | Chain::ZkSync + | Chain::Linea + | Chain::Mantle + | Chain::Celo + | Chain::World + | Chain::Sonic + | Chain::SeiEvm + | Chain::Abstract + | Chain::Berachain + | Chain::Ink + | Chain::Unichain + | Chain::Hyperliquid + | Chain::Plasma + | Chain::Monad + | Chain::XLayer + | Chain::Stable => Ok(Arc::new(EthereumClient::new(JsonRpcClient::new(alien_client), EVMChain::from_chain(chain).unwrap()))), + } + } +} diff --git a/gemstone/src/gateway/error.rs b/gemstone/src/gateway/error.rs index 20bcfeb22..56c33c1a8 100644 --- a/gemstone/src/gateway/error.rs +++ b/gemstone/src/gateway/error.rs @@ -1,4 +1,5 @@ use crate::alien::AlienError; +use crate::transaction_state::TransactionStatusError; use gem_jsonrpc::types::{ERROR_CLIENT_ERROR, JsonRpcError}; use std::{error::Error, fmt::Display}; @@ -29,6 +30,15 @@ impl From for GatewayError { } } +impl From for GatewayError { + fn from(err: TransactionStatusError) -> Self { + match err { + TransactionStatusError::NetworkError(msg) => Self::NetworkError { msg }, + TransactionStatusError::PlatformError(msg) => Self::PlatformError { msg }, + } + } +} + pub(crate) fn map_network_error(error: Box) -> GatewayError { if let Some(jsonrpc_error) = error.downcast_ref::() && jsonrpc_error.code == ERROR_CLIENT_ERROR diff --git a/gemstone/src/gateway/mod.rs b/gemstone/src/gateway/mod.rs index 90547114d..28ff77387 100644 --- a/gemstone/src/gateway/mod.rs +++ b/gemstone/src/gateway/mod.rs @@ -1,39 +1,26 @@ +mod chain_factory; mod error; mod preferences; +pub use chain_factory::ChainClientFactory; pub use error::GatewayError; use error::map_network_error; #[cfg(test)] pub use preferences::EmptyPreferences; pub use preferences::GemPreferences; -use preferences::PreferencesWrapper; +pub(crate) use preferences::PreferencesWrapper; -use crate::alien::{AlienProvider, AlienProviderWrapper, new_alien_client}; +use crate::alien::{AlienProvider, AlienProviderWrapper}; use crate::api_client::GemApiClient; use crate::models::*; -use crate::network::JsonRpcClient; +use crate::transaction_state::StatusProvider; use chain_traits::ChainTraits; -use gem_algorand::rpc::AlgorandClientIndexer; -use gem_algorand::rpc::client::AlgorandClient; -use gem_aptos::rpc::client::AptosClient; -use gem_bitcoin::rpc::client::BitcoinClient; -use gem_cardano::rpc::client::CardanoClient; -use gem_cosmos::rpc::client::CosmosClient; -use gem_evm::rpc::EthereumClient; -use gem_hypercore::rpc::client::HyperCoreClient; -use gem_near::rpc::client::NearClient; -use gem_polkadot::rpc::client::PolkadotClient; -use gem_solana::rpc::client::SolanaClient; -use gem_stellar::rpc::client::StellarClient; -use gem_sui::rpc::client::SuiClient; -use gem_ton::rpc::client::TonClient; -use gem_tron::rpc::{client::TronClient, trongrid::client::TronGridClient}; -use gem_xrp::rpc::client::XRPClient; +use swapper::swapper::GemSwapper as Swapper; use std::future::Future; use std::sync::Arc; use yielder::Yielder; -use primitives::{AssetId, BitcoinChain, Chain, ChartPeriod, EVMChain, ScanAddressTarget, ScanTransactionPayload, TransactionPreloadInput, chain_cosmos::CosmosChain}; +use primitives::{AssetId, Chain, ChartPeriod, ScanAddressTarget, ScanTransactionPayload, TransactionPreloadInput}; #[uniffi::export(with_foreign)] #[async_trait::async_trait] @@ -44,21 +31,15 @@ pub trait GemGatewayEstimateFee: Send + Sync { #[derive(uniffi::Object)] pub struct GemGateway { - pub provider: Arc, - pub preferences: Arc, - pub secure_preferences: Arc, pub api_client: GemApiClient, + chain_factory: Arc, yielder: Yielder, + status_provider: StatusProvider, } impl std::fmt::Debug for GemGateway { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("GemGateway") - .field("provider", &"") - .field("preferences", &"") - .field("secure_preferences", &"") - .field("api_client", &self.api_client) - .finish() + f.debug_struct("GemGateway").field("api_client", &self.api_client).finish() } } @@ -68,74 +49,9 @@ impl GemGateway { F: FnOnce(Arc) -> Fut, Fut: Future>>, { - let provider = self.provider(chain).await?; + let provider = self.chain_factory.create(chain).await?; call(provider).await.map_err(|e| GatewayError::NetworkError { msg: e.to_string() }) } - - pub async fn provider(&self, chain: Chain) -> Result, GatewayError> { - let url = self.provider.get_endpoint(chain).unwrap(); - self.provider_with_url(chain, url).await - } - - pub async fn provider_with_url(&self, chain: Chain, url: String) -> Result, GatewayError> { - let alien_client = new_alien_client(url.clone(), self.provider.clone()); - match chain { - Chain::HyperCore => { - let preferences = Arc::new(PreferencesWrapper { - preferences: self.preferences.clone(), - }); - let secure_preferences = Arc::new(PreferencesWrapper { - preferences: self.secure_preferences.clone(), - }); - Ok(Arc::new(HyperCoreClient::new_with_preferences(alien_client, preferences, secure_preferences))) - } - Chain::Bitcoin | Chain::BitcoinCash | Chain::Litecoin | Chain::Doge | Chain::Zcash => { - Ok(Arc::new(BitcoinClient::new(alien_client, BitcoinChain::from_chain(chain).unwrap()))) - } - Chain::Cardano => Ok(Arc::new(CardanoClient::new(alien_client))), - Chain::Stellar => Ok(Arc::new(StellarClient::new(alien_client))), - Chain::Sui => Ok(Arc::new(SuiClient::new(JsonRpcClient::new(alien_client.clone())))), - Chain::Xrp => Ok(Arc::new(XRPClient::new(JsonRpcClient::new(alien_client.clone())))), - Chain::Algorand => Ok(Arc::new(AlgorandClient::new(alien_client.clone(), AlgorandClientIndexer::new(alien_client.clone())))), - Chain::Near => Ok(Arc::new(NearClient::new(JsonRpcClient::new(alien_client.clone())))), - Chain::Aptos => Ok(Arc::new(AptosClient::new(alien_client))), - Chain::Cosmos | Chain::Osmosis | Chain::Celestia | Chain::Thorchain | Chain::Injective | Chain::Sei | Chain::Noble => { - Ok(Arc::new(CosmosClient::new(CosmosChain::from_chain(chain).unwrap(), alien_client))) - } - Chain::Ton => Ok(Arc::new(TonClient::new(alien_client))), - Chain::Tron => Ok(Arc::new(TronClient::new(alien_client.clone(), TronGridClient::new(alien_client.clone(), String::new())))), - Chain::Polkadot => Ok(Arc::new(PolkadotClient::new(alien_client))), - Chain::Solana => Ok(Arc::new(SolanaClient::new(JsonRpcClient::new(alien_client.clone())))), - Chain::Ethereum - | Chain::Arbitrum - | Chain::SmartChain - | Chain::Polygon - | Chain::Optimism - | Chain::Base - | Chain::AvalancheC - | Chain::OpBNB - | Chain::Fantom - | Chain::Gnosis - | Chain::Manta - | Chain::Blast - | Chain::ZkSync - | Chain::Linea - | Chain::Mantle - | Chain::Celo - | Chain::World - | Chain::Sonic - | Chain::SeiEvm - | Chain::Abstract - | Chain::Berachain - | Chain::Ink - | Chain::Unichain - | Chain::Hyperliquid - | Chain::Plasma - | Chain::Monad - | Chain::XLayer - | Chain::Stable => Ok(Arc::new(EthereumClient::new(JsonRpcClient::new(alien_client), EVMChain::from_chain(chain).unwrap()))), - } - } } #[async_trait::async_trait] @@ -154,13 +70,16 @@ impl GemGateway { #[uniffi::constructor] pub fn new(provider: Arc, preferences: Arc, secure_preferences: Arc, api_url: String) -> Self { let api_client = GemApiClient::new(api_url, provider.clone()); - let yielder = Yielder::new(Arc::new(AlienProviderWrapper::new(provider.clone()))); + let chain_factory = Arc::new(ChainClientFactory::new(provider.clone(), preferences, secure_preferences)); + let alien_wrapper = Arc::new(AlienProviderWrapper::new(provider)); + let yielder = Yielder::new(alien_wrapper.clone()); + let swapper = Swapper::new(alien_wrapper); + let status_provider = StatusProvider::new(chain_factory.clone(), swapper); Self { - provider, - preferences, - secure_preferences, api_client, + chain_factory, yielder, + status_provider, } } @@ -191,8 +110,7 @@ impl GemGateway { } pub async fn get_transaction_status(&self, chain: Chain, request: GemTransactionStateRequest) -> Result { - self.with_provider(chain, |provider| async move { provider.get_transaction_status(request.into()).await }) - .await + Ok(self.status_provider.get(chain, request).await?) } pub async fn get_chain_id(&self, chain: Chain) -> Result { @@ -301,7 +219,7 @@ impl GemGateway { } pub async fn get_is_token_address(&self, chain: Chain, token_id: String) -> Result { - Ok(self.provider(chain).await?.get_is_token_address(&token_id)) + Ok(self.chain_factory.create(chain).await?.get_is_token_address(&token_id)) } pub async fn get_balance_earn(&self, chain: Chain, address: String, token_ids: Vec) -> Result, GatewayError> { @@ -325,7 +243,7 @@ impl GemGateway { pub async fn get_node_status(&self, chain: Chain, url: &str) -> Result { let start_time = std::time::Instant::now(); - let provider = self.provider_with_url(chain, url.to_string()).await?; + let provider = self.chain_factory.create_with_url(chain, url.to_string()).await?; let (chain_id, latest_block_number) = futures::try_join!(provider.get_chain_id(), provider.get_block_latest_number()).map_err(map_network_error)?; diff --git a/gemstone/src/lib.rs b/gemstone/src/lib.rs index be402020e..cdc604749 100644 --- a/gemstone/src/lib.rs +++ b/gemstone/src/lib.rs @@ -16,6 +16,7 @@ pub mod perpetual; pub mod price_alert_formatter; pub mod signer; pub mod siwe; +pub mod transaction_state; pub mod wallet_connect; use alien::AlienError; diff --git a/gemstone/src/models/transaction.rs b/gemstone/src/models/transaction.rs index ca7eba13e..a23596871 100644 --- a/gemstone/src/models/transaction.rs +++ b/gemstone/src/models/transaction.rs @@ -4,12 +4,13 @@ use primitives::contract_call_data::ContractCallData; use primitives::{ AccountDataType, Asset, EarnType, FeeOption, GasPriceType, HyperliquidOrder, PerpetualConfirmData, PerpetualDirection, PerpetualMarginType, PerpetualProvider, PerpetualType, Resource, SignerInput, StakeType, TransactionChange, TransactionFee, TransactionInputType, TransactionLoadInput, TransactionLoadMetadata, TransactionMetadata, - TransactionPerpetualMetadata, TransactionState, TransactionStateRequest, TransactionType, TransactionUpdate, TransferDataExtra, TransferDataOutputAction, + TransactionPerpetualMetadata, TransactionState, TransactionStateRequest, TransactionSwapMetadata, TransactionType, TransactionUpdate, TransferDataExtra, TransferDataOutputAction, TransferDataOutputType, TronStakeData, TronUnfreeze, TronVote, UInt64, WalletConnectionSessionAppMetadata, perpetual::{CancelOrderData, PerpetualModifyConfirmData, PerpetualModifyPositionType, PerpetualReduceData, TPSLOrderData}, }; use std::collections::HashMap; use swap::{GemApprovalData, GemSwapData}; +use swapper::SwapperProvider; pub type GemPerpetualDirection = PerpetualDirection; pub type GemPerpetualProvider = PerpetualProvider; @@ -86,6 +87,7 @@ pub struct TransactionPerpetualMetadata { #[uniffi::remote(Enum)] pub enum TransactionMetadata { Perpetual(TransactionPerpetualMetadata), + Swap(TransactionSwapMetadata), } #[uniffi::remote(Enum)] @@ -146,6 +148,7 @@ pub struct GemTransactionStateRequest { pub sender_address: String, pub created_at: i64, pub block_number: i64, + pub swap_provider: Option, } pub type GemHyperliquidOrder = HyperliquidOrder; diff --git a/gemstone/src/transaction_state/config.rs b/gemstone/src/transaction_state/config.rs new file mode 100644 index 000000000..6a72af73e --- /dev/null +++ b/gemstone/src/transaction_state/config.rs @@ -0,0 +1,18 @@ +use primitives::{Chain, JobConfiguration}; + +#[derive(Debug, Clone, Copy, PartialEq, uniffi::Record)] +pub struct GemJobConfiguration { + pub initial_interval_ms: u32, + pub max_interval_ms: u32, + pub step_factor: f32, +} + +#[uniffi::export] +pub fn transaction_state_config(chain: Chain) -> GemJobConfiguration { + let config = JobConfiguration::transaction_state(chain); + GemJobConfiguration { + initial_interval_ms: config.initial_interval_ms, + max_interval_ms: config.max_interval_ms, + step_factor: config.step_factor, + } +} diff --git a/gemstone/src/transaction_state/error.rs b/gemstone/src/transaction_state/error.rs new file mode 100644 index 000000000..74714dee6 --- /dev/null +++ b/gemstone/src/transaction_state/error.rs @@ -0,0 +1,29 @@ +use std::error::Error; +use std::fmt::{self, Formatter}; + +use crate::gateway::GatewayError; + +#[derive(Debug, Clone)] +pub enum TransactionStatusError { + NetworkError(String), + PlatformError(String), +} + +impl fmt::Display for TransactionStatusError { + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + match self { + Self::NetworkError(msg) | Self::PlatformError(msg) => write!(f, "{msg}"), + } + } +} + +impl Error for TransactionStatusError {} + +impl From for TransactionStatusError { + fn from(err: GatewayError) -> Self { + match err { + GatewayError::NetworkError { msg } => Self::NetworkError(msg), + GatewayError::PlatformError { msg } => Self::PlatformError(msg), + } + } +} diff --git a/gemstone/src/transaction_state/mod.rs b/gemstone/src/transaction_state/mod.rs new file mode 100644 index 000000000..089bcb131 --- /dev/null +++ b/gemstone/src/transaction_state/mod.rs @@ -0,0 +1,7 @@ +mod config; +mod error; +mod status_provider; + +pub use status_provider::StatusProvider; +pub use config::transaction_state_config; +pub use error::TransactionStatusError; diff --git a/gemstone/src/transaction_state/status_provider.rs b/gemstone/src/transaction_state/status_provider.rs new file mode 100644 index 000000000..1154c2c69 --- /dev/null +++ b/gemstone/src/transaction_state/status_provider.rs @@ -0,0 +1,99 @@ +use chrono::Utc; +use primitives::{Chain, TransactionChange, TransactionMetadata, TransactionState, TransactionUpdate, chain_transaction_timeout}; +use std::sync::Arc; +use swapper::{SwapperProvider, swapper::GemSwapper}; + +use crate::gateway::ChainClientFactory; +use crate::models::GemTransactionStateRequest; + +use super::TransactionStatusError; + +pub struct StatusProvider { + chain_factory: Arc, + swapper: GemSwapper, +} + +impl StatusProvider { + pub fn new(chain_factory: Arc, swapper: GemSwapper) -> Self { + Self { chain_factory, swapper } + } + + pub async fn get(&self, chain: Chain, request: GemTransactionStateRequest) -> Result { + let created_at = request.created_at; + let result = match request.swap_provider { + Some(provider) => self.get_swap_status(chain, provider, &request.id).await, + None => self.get_chain_status(chain, request).await, + }; + get_transaction_update(chain, created_at, result) + } + + async fn get_chain_status(&self, chain: Chain, request: GemTransactionStateRequest) -> Result { + let provider = self.chain_factory.create(chain).await?; + provider + .get_transaction_status(request.into()) + .await + .map_err(|e| TransactionStatusError::NetworkError(e.to_string())) + } + + async fn get_swap_status(&self, chain: Chain, provider: SwapperProvider, transaction_hash: &str) -> Result { + let result = self + .swapper + .get_swap_result(chain, provider, transaction_hash) + .await + .map_err(|e| TransactionStatusError::NetworkError(e.to_string()))?; + + let state = result.status.transaction_state().unwrap_or(TransactionState::InTransit); + let changes = result + .metadata + .map(|m| vec![TransactionChange::Metadata(TransactionMetadata::Swap(m))]) + .unwrap_or_default(); + Ok(TransactionUpdate::new(state, changes)) + } +} + +fn get_transaction_update( + chain: Chain, + created_at: i64, + result: Result, +) -> Result { + let elapsed = Utc::now().timestamp_millis() - created_at; + let timeout = i64::from(chain_transaction_timeout(chain)); + let expired = elapsed > timeout; + + match result { + Ok(update) => Ok(if expired && !update.state.is_completed() { + TransactionUpdate::new_state(TransactionState::Failed) + } else { + update + }), + err @ Err(TransactionStatusError::NetworkError(_)) => err, + Err(_) if expired => Ok(TransactionUpdate::new_state(TransactionState::Failed)), + Err(err) => Err(err), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_get_transaction_update() { + let chain = Chain::Ethereum; + let now = || Utc::now().timestamp_millis(); + let pending = || Ok(TransactionUpdate::new_state(TransactionState::Pending)); + let confirmed = || Ok(TransactionUpdate::new_state(TransactionState::Confirmed)); + + assert_eq!( + get_transaction_update(chain, now(), pending()).unwrap().state, + TransactionState::Pending + ); + assert_eq!( + get_transaction_update(chain, 0, pending()).unwrap().state, + TransactionState::Failed + ); + assert_eq!( + get_transaction_update(chain, 0, confirmed()).unwrap().state, + TransactionState::Confirmed + ); + } +}