From e67c8870c572fa20e2a9fd9661d2630e7d4f7b67 Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Wed, 29 Apr 2026 22:44:44 +0300 Subject: [PATCH 01/10] Added chain_factory --- gemstone/src/gateway/chain_factory.rs | 103 +++++++++++++++++++++++ gemstone/src/gateway/mod.rs | 114 +++----------------------- 2 files changed, 116 insertions(+), 101 deletions(-) create mode 100644 gemstone/src/gateway/chain_factory.rs 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/mod.rs b/gemstone/src/gateway/mod.rs index 90547114d..b2f664fbc 100644 --- a/gemstone/src/gateway/mod.rs +++ b/gemstone/src/gateway/mod.rs @@ -1,39 +1,24 @@ +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 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 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 +29,14 @@ 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, } 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 +46,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,12 +67,11 @@ 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 yielder = Yielder::new(Arc::new(AlienProviderWrapper::new(provider))); Self { - provider, - preferences, - secure_preferences, api_client, + chain_factory, yielder, } } @@ -301,7 +213,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 +237,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)?; From 0eea08e8cf7667e671f89bdcc4fe43a06ddfa782 Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Wed, 29 Apr 2026 20:14:22 +0300 Subject: [PATCH 02/10] Add JobConfiguration struct and export Introduce a new JobConfiguration type for job backoff/timing settings. The struct (crates/primitives/src/job_configuration.rs) derives Debug/Clone/Copy/PartialEq and implements Serialize/Deserialize, uses serde camelCase and typeshare(swift = "Sendable"). Update crates/primitives/src/lib.rs to expose the new module and re-export JobConfiguration. --- crates/primitives/src/job_configuration.rs | 11 +++++++++++ crates/primitives/src/lib.rs | 2 ++ 2 files changed, 13 insertions(+) create mode 100644 crates/primitives/src/job_configuration.rs diff --git a/crates/primitives/src/job_configuration.rs b/crates/primitives/src/job_configuration.rs new file mode 100644 index 000000000..07fd1c574 --- /dev/null +++ b/crates/primitives/src/job_configuration.rs @@ -0,0 +1,11 @@ +use serde::{Deserialize, Serialize}; +use typeshare::typeshare; + +#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)] +#[typeshare(swift = "Sendable")] +#[serde(rename_all = "camelCase")] +pub struct JobConfiguration { + pub initial_interval_ms: u32, + pub max_interval_ms: u32, + pub step_factor: f32, +} diff --git a/crates/primitives/src/lib.rs b/crates/primitives/src/lib.rs index 82ac2f9a5..32aeb642f 100644 --- a/crates/primitives/src/lib.rs +++ b/crates/primitives/src/lib.rs @@ -112,6 +112,8 @@ pub mod time; pub use self::time::unix_timestamp; pub mod transaction_state; pub use self::transaction_state::TransactionState; +pub mod job_configuration; +pub use self::job_configuration::JobConfiguration; pub mod username_status; pub use self::username_status::UsernameStatus; pub mod recent_activity_type; From c660f94d20dc71869cc06f998f63d630182cd5b4 Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Wed, 29 Apr 2026 22:51:33 +0300 Subject: [PATCH 03/10] Add TransactionStatusClient with timeout-fail policy --- gemstone/src/gateway/error.rs | 10 ++++++ gemstone/src/gateway/mod.rs | 7 ++-- gemstone/src/lib.rs | 1 + gemstone/src/transaction_state/client.rs | 41 ++++++++++++++++++++++++ gemstone/src/transaction_state/config.rs | 22 +++++++++++++ gemstone/src/transaction_state/error.rs | 29 +++++++++++++++++ gemstone/src/transaction_state/mod.rs | 7 ++++ 7 files changed, 115 insertions(+), 2 deletions(-) create mode 100644 gemstone/src/transaction_state/client.rs create mode 100644 gemstone/src/transaction_state/config.rs create mode 100644 gemstone/src/transaction_state/error.rs create mode 100644 gemstone/src/transaction_state/mod.rs 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 b2f664fbc..d80e0ca11 100644 --- a/gemstone/src/gateway/mod.rs +++ b/gemstone/src/gateway/mod.rs @@ -13,6 +13,7 @@ pub(crate) use preferences::PreferencesWrapper; use crate::alien::{AlienProvider, AlienProviderWrapper}; use crate::api_client::GemApiClient; use crate::models::*; +use crate::transaction_state::TransactionStatusClient; use chain_traits::ChainTraits; use std::future::Future; use std::sync::Arc; @@ -32,6 +33,7 @@ pub struct GemGateway { pub api_client: GemApiClient, chain_factory: Arc, yielder: Yielder, + status_client: TransactionStatusClient, } impl std::fmt::Debug for GemGateway { @@ -69,10 +71,12 @@ impl GemGateway { let api_client = GemApiClient::new(api_url, provider.clone()); let chain_factory = Arc::new(ChainClientFactory::new(provider.clone(), preferences, secure_preferences)); let yielder = Yielder::new(Arc::new(AlienProviderWrapper::new(provider))); + let status_client = TransactionStatusClient::new(chain_factory.clone()); Self { api_client, chain_factory, yielder, + status_client, } } @@ -103,8 +107,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_client.status(chain, request.into()).await?) } pub async fn get_chain_id(&self, chain: Chain) -> Result { diff --git a/gemstone/src/lib.rs b/gemstone/src/lib.rs index 292831ee3..8e8d274ae 100644 --- a/gemstone/src/lib.rs +++ b/gemstone/src/lib.rs @@ -15,6 +15,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/transaction_state/client.rs b/gemstone/src/transaction_state/client.rs new file mode 100644 index 000000000..d629e6e43 --- /dev/null +++ b/gemstone/src/transaction_state/client.rs @@ -0,0 +1,41 @@ +use chrono::Utc; +use primitives::{Chain, TransactionState, TransactionStateRequest, TransactionUpdate, chain_transaction_timeout}; +use std::sync::Arc; + +use crate::gateway::ChainClientFactory; + +use super::TransactionStatusError; + +pub struct TransactionStatusClient { + chain_factory: Arc, +} + +impl TransactionStatusClient { + pub fn new(chain_factory: Arc) -> Self { + Self { chain_factory } + } + + pub async fn status(&self, chain: Chain, request: TransactionStateRequest) -> Result { + let elapsed = Utc::now().timestamp().saturating_sub(request.created_at).max(0) as u64; + let timeout = chain_transaction_timeout(chain) as u64 / 1000; + + let provider = self.chain_factory.create(chain).await?; + match provider.get_transaction_status(request).await { + Ok(update) => Ok(apply_timeout(update, elapsed, timeout)), + Err(_) if elapsed > timeout => Ok(TransactionUpdate::new_state(TransactionState::Failed)), + Err(err) => Err(TransactionStatusError::NetworkError(err.to_string())), + } + } +} + +fn apply_timeout(update: TransactionUpdate, elapsed_secs: u64, timeout_secs: u64) -> TransactionUpdate { + let still_running = match update.state { + TransactionState::Pending | TransactionState::InTransit => true, + TransactionState::Confirmed | TransactionState::Failed | TransactionState::Reverted => false, + }; + if still_running && elapsed_secs > timeout_secs { + TransactionUpdate::new_state(TransactionState::Failed) + } else { + update + } +} diff --git a/gemstone/src/transaction_state/config.rs b/gemstone/src/transaction_state/config.rs new file mode 100644 index 000000000..39a654750 --- /dev/null +++ b/gemstone/src/transaction_state/config.rs @@ -0,0 +1,22 @@ +use primitives::{Chain, JobConfiguration}; + +const INITIAL_CAP_MS: u32 = 5_000; +const MAX_INTERVAL_MS: u32 = 15_000; +const STEP_FACTOR: f32 = 1.1; + +#[uniffi::remote(Record)] +pub struct JobConfiguration { + pub initial_interval_ms: u32, + pub max_interval_ms: u32, + pub step_factor: f32, +} + +#[uniffi::export] +pub fn transaction_state_config(chain: Chain) -> JobConfiguration { + let block_time_ms = chain.block_time(); + JobConfiguration { + initial_interval_ms: block_time_ms.clamp(1, INITIAL_CAP_MS), + max_interval_ms: MAX_INTERVAL_MS, + step_factor: 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..c3a058bb4 --- /dev/null +++ b/gemstone/src/transaction_state/mod.rs @@ -0,0 +1,7 @@ +mod client; +mod config; +mod error; + +pub use client::TransactionStatusClient; +pub use config::transaction_state_config; +pub use error::TransactionStatusError; From 7b797078d1c951763007acc2f5513805137805b1 Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Thu, 30 Apr 2026 22:08:02 +0300 Subject: [PATCH 04/10] Support swap InTransit status and status provider Add InTransit transaction status across primitives and remote swap types, and wire swap-aware status resolution into the gateway. Introduces TransactionSwapMetadata to transaction metadata, adds Swapper/SwapperProvider usage, and replaces the old TransactionStatusClient with a new StatusProvider that delegates to chain providers or the swapper as appropriate. Includes timeout handling and mapping of swap results into TransactionUpdate, plus related model and import adjustments. --- crates/primitives/src/swap/approval.rs | 3 +- crates/primitives/src/transaction_update.rs | 3 +- gemstone/src/gateway/mod.rs | 15 ++-- gemstone/src/gem_swapper/remote_types.rs | 1 + gemstone/src/models/transaction.rs | 5 +- gemstone/src/transaction_state/client.rs | 41 --------- gemstone/src/transaction_state/mod.rs | 4 +- .../src/transaction_state/status_provider.rs | 83 +++++++++++++++++++ 8 files changed, 103 insertions(+), 52 deletions(-) delete mode 100644 gemstone/src/transaction_state/client.rs create mode 100644 gemstone/src/transaction_state/status_provider.rs diff --git a/crates/primitives/src/swap/approval.rs b/crates/primitives/src/swap/approval.rs index d91f64087..0607b4684 100644 --- a/crates/primitives/src/swap/approval.rs +++ b/crates/primitives/src/swap/approval.rs @@ -100,6 +100,7 @@ pub struct SwapProviderData { #[serde(rename_all = "camelCase")] pub enum SwapStatus { Pending, + InTransit, Completed, Failed, } @@ -109,7 +110,7 @@ impl SwapStatus { match self { SwapStatus::Completed => Some(TransactionState::Confirmed), SwapStatus::Failed => Some(TransactionState::Failed), - SwapStatus::Pending => None, + SwapStatus::Pending | SwapStatus::InTransit => None, } } } 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/mod.rs b/gemstone/src/gateway/mod.rs index d80e0ca11..28ff77387 100644 --- a/gemstone/src/gateway/mod.rs +++ b/gemstone/src/gateway/mod.rs @@ -13,8 +13,9 @@ pub(crate) use preferences::PreferencesWrapper; use crate::alien::{AlienProvider, AlienProviderWrapper}; use crate::api_client::GemApiClient; use crate::models::*; -use crate::transaction_state::TransactionStatusClient; +use crate::transaction_state::StatusProvider; use chain_traits::ChainTraits; +use swapper::swapper::GemSwapper as Swapper; use std::future::Future; use std::sync::Arc; use yielder::Yielder; @@ -33,7 +34,7 @@ pub struct GemGateway { pub api_client: GemApiClient, chain_factory: Arc, yielder: Yielder, - status_client: TransactionStatusClient, + status_provider: StatusProvider, } impl std::fmt::Debug for GemGateway { @@ -70,13 +71,15 @@ impl GemGateway { pub fn new(provider: Arc, preferences: Arc, secure_preferences: Arc, api_url: String) -> Self { let api_client = GemApiClient::new(api_url, provider.clone()); let chain_factory = Arc::new(ChainClientFactory::new(provider.clone(), preferences, secure_preferences)); - let yielder = Yielder::new(Arc::new(AlienProviderWrapper::new(provider))); - let status_client = TransactionStatusClient::new(chain_factory.clone()); + 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 { api_client, chain_factory, yielder, - status_client, + status_provider, } } @@ -107,7 +110,7 @@ impl GemGateway { } pub async fn get_transaction_status(&self, chain: Chain, request: GemTransactionStateRequest) -> Result { - Ok(self.status_client.status(chain, request.into()).await?) + Ok(self.status_provider.get(chain, request).await?) } pub async fn get_chain_id(&self, chain: Chain) -> Result { diff --git a/gemstone/src/gem_swapper/remote_types.rs b/gemstone/src/gem_swapper/remote_types.rs index 47d392c40..676f61976 100644 --- a/gemstone/src/gem_swapper/remote_types.rs +++ b/gemstone/src/gem_swapper/remote_types.rs @@ -167,6 +167,7 @@ pub struct SwapperQuoteAsset { #[uniffi::remote(Enum)] pub enum SwapperSwapStatus { Pending, + InTransit, Completed, Failed, } 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/client.rs b/gemstone/src/transaction_state/client.rs deleted file mode 100644 index d629e6e43..000000000 --- a/gemstone/src/transaction_state/client.rs +++ /dev/null @@ -1,41 +0,0 @@ -use chrono::Utc; -use primitives::{Chain, TransactionState, TransactionStateRequest, TransactionUpdate, chain_transaction_timeout}; -use std::sync::Arc; - -use crate::gateway::ChainClientFactory; - -use super::TransactionStatusError; - -pub struct TransactionStatusClient { - chain_factory: Arc, -} - -impl TransactionStatusClient { - pub fn new(chain_factory: Arc) -> Self { - Self { chain_factory } - } - - pub async fn status(&self, chain: Chain, request: TransactionStateRequest) -> Result { - let elapsed = Utc::now().timestamp().saturating_sub(request.created_at).max(0) as u64; - let timeout = chain_transaction_timeout(chain) as u64 / 1000; - - let provider = self.chain_factory.create(chain).await?; - match provider.get_transaction_status(request).await { - Ok(update) => Ok(apply_timeout(update, elapsed, timeout)), - Err(_) if elapsed > timeout => Ok(TransactionUpdate::new_state(TransactionState::Failed)), - Err(err) => Err(TransactionStatusError::NetworkError(err.to_string())), - } - } -} - -fn apply_timeout(update: TransactionUpdate, elapsed_secs: u64, timeout_secs: u64) -> TransactionUpdate { - let still_running = match update.state { - TransactionState::Pending | TransactionState::InTransit => true, - TransactionState::Confirmed | TransactionState::Failed | TransactionState::Reverted => false, - }; - if still_running && elapsed_secs > timeout_secs { - TransactionUpdate::new_state(TransactionState::Failed) - } else { - update - } -} diff --git a/gemstone/src/transaction_state/mod.rs b/gemstone/src/transaction_state/mod.rs index c3a058bb4..089bcb131 100644 --- a/gemstone/src/transaction_state/mod.rs +++ b/gemstone/src/transaction_state/mod.rs @@ -1,7 +1,7 @@ -mod client; mod config; mod error; +mod status_provider; -pub use client::TransactionStatusClient; +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..f74814fd0 --- /dev/null +++ b/gemstone/src/transaction_state/status_provider.rs @@ -0,0 +1,83 @@ +use chrono::Utc; +use primitives::{Chain, TransactionChange, TransactionMetadata, TransactionState, TransactionStateRequest, 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 result = match request.swap_provider { + Some(provider) => self.get_swap_status(chain, provider, &request.id).await, + None => self.get_chain_status(chain, &request).await, + }; + apply_timeout(chain, request.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(TransactionStateRequest { + id: request.id.clone(), + sender_address: request.sender_address.clone(), + created_at: request.created_at, + block_number: request.block_number, + }) + .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 apply_timeout( + chain: Chain, + created_at: i64, + result: Result, +) -> Result { + let elapsed = Utc::now().timestamp().saturating_sub(created_at).max(0) as u64; + let timeout = chain_transaction_timeout(chain) as u64 / 1000; + let expired = elapsed > timeout; + + match result { + Ok(update) => { + let running = match update.state { + TransactionState::Pending | TransactionState::InTransit => true, + TransactionState::Confirmed | TransactionState::Failed | TransactionState::Reverted => false, + }; + Ok(if expired && running { + 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), + } +} From 2a167cb3eabc69105aeb0f9bd6bba488d98fc7b3 Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Mon, 4 May 2026 12:24:29 +0300 Subject: [PATCH 05/10] Undo InTransit support for now --- crates/primitives/src/swap/approval.rs | 3 +-- gemstone/src/gem_swapper/remote_types.rs | 1 - 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/crates/primitives/src/swap/approval.rs b/crates/primitives/src/swap/approval.rs index 0607b4684..d91f64087 100644 --- a/crates/primitives/src/swap/approval.rs +++ b/crates/primitives/src/swap/approval.rs @@ -100,7 +100,6 @@ pub struct SwapProviderData { #[serde(rename_all = "camelCase")] pub enum SwapStatus { Pending, - InTransit, Completed, Failed, } @@ -110,7 +109,7 @@ impl SwapStatus { match self { SwapStatus::Completed => Some(TransactionState::Confirmed), SwapStatus::Failed => Some(TransactionState::Failed), - SwapStatus::Pending | SwapStatus::InTransit => None, + SwapStatus::Pending => None, } } } diff --git a/gemstone/src/gem_swapper/remote_types.rs b/gemstone/src/gem_swapper/remote_types.rs index 676f61976..47d392c40 100644 --- a/gemstone/src/gem_swapper/remote_types.rs +++ b/gemstone/src/gem_swapper/remote_types.rs @@ -167,7 +167,6 @@ pub struct SwapperQuoteAsset { #[uniffi::remote(Enum)] pub enum SwapperSwapStatus { Pending, - InTransit, Completed, Failed, } From c9d209dcca4721d55a8356ad28cbcb946d2c2d37 Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Mon, 4 May 2026 15:29:44 +0300 Subject: [PATCH 06/10] Update status_provider.rs --- gemstone/src/transaction_state/status_provider.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gemstone/src/transaction_state/status_provider.rs b/gemstone/src/transaction_state/status_provider.rs index f74814fd0..70f9459e3 100644 --- a/gemstone/src/transaction_state/status_provider.rs +++ b/gemstone/src/transaction_state/status_provider.rs @@ -23,7 +23,7 @@ impl StatusProvider { Some(provider) => self.get_swap_status(chain, provider, &request.id).await, None => self.get_chain_status(chain, &request).await, }; - apply_timeout(chain, request.created_at, result) + get_resolved_status(chain, request.created_at, result) } async fn get_chain_status(&self, chain: Chain, request: &GemTransactionStateRequest) -> Result { @@ -55,7 +55,7 @@ impl StatusProvider { } } -fn apply_timeout( +fn get_resolved_status( chain: Chain, created_at: i64, result: Result, From 3430604cfc717ae9b5097c516db1524d75332933 Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Mon, 4 May 2026 20:45:05 +0300 Subject: [PATCH 07/10] Add is_completed and use it in status provider Introduce TransactionState::is_completed() to centralize logic for which states are terminal. Replace a manual match in gemstone/src/transaction_state/status_provider.rs with a call to is_completed(), simplifying the expired->Failed decision and improving readability while preserving existing behavior. --- crates/primitives/src/transaction_state.rs | 9 +++++++++ .../src/transaction_state/status_provider.rs | 20 +++++++------------ 2 files changed, 16 insertions(+), 13 deletions(-) diff --git a/crates/primitives/src/transaction_state.rs b/crates/primitives/src/transaction_state.rs index f4a4528d8..916e619c5 100644 --- a/crates/primitives/src/transaction_state.rs +++ b/crates/primitives/src/transaction_state.rs @@ -13,3 +13,12 @@ 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, + } + } +} diff --git a/gemstone/src/transaction_state/status_provider.rs b/gemstone/src/transaction_state/status_provider.rs index 70f9459e3..34c795b03 100644 --- a/gemstone/src/transaction_state/status_provider.rs +++ b/gemstone/src/transaction_state/status_provider.rs @@ -23,7 +23,7 @@ impl StatusProvider { Some(provider) => self.get_swap_status(chain, provider, &request.id).await, None => self.get_chain_status(chain, &request).await, }; - get_resolved_status(chain, request.created_at, result) + get_transaction_update(chain, request.created_at, result) } async fn get_chain_status(&self, chain: Chain, request: &GemTransactionStateRequest) -> Result { @@ -55,7 +55,7 @@ impl StatusProvider { } } -fn get_resolved_status( +fn get_transaction_update( chain: Chain, created_at: i64, result: Result, @@ -65,17 +65,11 @@ fn get_resolved_status( let expired = elapsed > timeout; match result { - Ok(update) => { - let running = match update.state { - TransactionState::Pending | TransactionState::InTransit => true, - TransactionState::Confirmed | TransactionState::Failed | TransactionState::Reverted => false, - }; - Ok(if expired && running { - TransactionUpdate::new_state(TransactionState::Failed) - } else { - update - }) - } + 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), From 6647585d25854c9b93675a63b329cc4f4a7b4bb4 Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Mon, 4 May 2026 22:08:37 +0300 Subject: [PATCH 08/10] Use milliseconds end-to-end for transaction status timeout Switch status_provider to ms throughout: timestamp_millis() for now, no /1000 on chain_transaction_timeout, drop u64 casts. Update Hyperliquid start_time accordingly. Use existing From for the chain provider call. Add tests for get_transaction_update and TransactionState::is_completed. --- .../src/provider/transaction_state.rs | 2 +- crates/primitives/src/transaction_state.rs | 14 ++++++ .../src/transaction_state/status_provider.rs | 46 ++++++++++++++----- 3 files changed, 49 insertions(+), 13 deletions(-) diff --git a/crates/gem_hypercore/src/provider/transaction_state.rs b/crates/gem_hypercore/src/provider/transaction_state.rs index e1960dd84..14d3e3af1 100644 --- a/crates/gem_hypercore/src/provider/transaction_state.rs +++ b/crates/gem_hypercore/src/provider/transaction_state.rs @@ -19,7 +19,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/transaction_state.rs b/crates/primitives/src/transaction_state.rs index 916e619c5..fa7bbaa47 100644 --- a/crates/primitives/src/transaction_state.rs +++ b/crates/primitives/src/transaction_state.rs @@ -22,3 +22,17 @@ impl TransactionState { } } } + +#[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/gemstone/src/transaction_state/status_provider.rs b/gemstone/src/transaction_state/status_provider.rs index 34c795b03..1154c2c69 100644 --- a/gemstone/src/transaction_state/status_provider.rs +++ b/gemstone/src/transaction_state/status_provider.rs @@ -1,5 +1,5 @@ use chrono::Utc; -use primitives::{Chain, TransactionChange, TransactionMetadata, TransactionState, TransactionStateRequest, TransactionUpdate, chain_transaction_timeout}; +use primitives::{Chain, TransactionChange, TransactionMetadata, TransactionState, TransactionUpdate, chain_transaction_timeout}; use std::sync::Arc; use swapper::{SwapperProvider, swapper::GemSwapper}; @@ -19,22 +19,18 @@ impl StatusProvider { } 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, + None => self.get_chain_status(chain, request).await, }; - get_transaction_update(chain, request.created_at, result) + get_transaction_update(chain, created_at, result) } - async fn get_chain_status(&self, chain: Chain, request: &GemTransactionStateRequest) -> Result { + async fn get_chain_status(&self, chain: Chain, request: GemTransactionStateRequest) -> Result { let provider = self.chain_factory.create(chain).await?; provider - .get_transaction_status(TransactionStateRequest { - id: request.id.clone(), - sender_address: request.sender_address.clone(), - created_at: request.created_at, - block_number: request.block_number, - }) + .get_transaction_status(request.into()) .await .map_err(|e| TransactionStatusError::NetworkError(e.to_string())) } @@ -60,8 +56,8 @@ fn get_transaction_update( created_at: i64, result: Result, ) -> Result { - let elapsed = Utc::now().timestamp().saturating_sub(created_at).max(0) as u64; - let timeout = chain_transaction_timeout(chain) as u64 / 1000; + let elapsed = Utc::now().timestamp_millis() - created_at; + let timeout = i64::from(chain_transaction_timeout(chain)); let expired = elapsed > timeout; match result { @@ -75,3 +71,29 @@ fn get_transaction_update( 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 + ); + } +} From 8c81f2bd03d83a30113125a01636dda5535b142f Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Mon, 4 May 2026 22:29:11 +0300 Subject: [PATCH 09/10] Replace JobConfiguration with GemJobConfiguration Remove the shared JobConfiguration type from crates/primitives (deleted job_configuration.rs and removed its mod/use exports). Introduce a local GemJobConfiguration in gemstone/src/transaction_state/config.rs (derive uniffi::Record) and update transaction_state_config to return GemJobConfiguration instead of the removed shared type. Logic and constants are unchanged; this decouples the uniFFI-record type from the primitives crate. --- crates/primitives/src/job_configuration.rs | 11 ----------- crates/primitives/src/lib.rs | 2 -- gemstone/src/transaction_state/config.rs | 10 +++++----- 3 files changed, 5 insertions(+), 18 deletions(-) delete mode 100644 crates/primitives/src/job_configuration.rs diff --git a/crates/primitives/src/job_configuration.rs b/crates/primitives/src/job_configuration.rs deleted file mode 100644 index 07fd1c574..000000000 --- a/crates/primitives/src/job_configuration.rs +++ /dev/null @@ -1,11 +0,0 @@ -use serde::{Deserialize, Serialize}; -use typeshare::typeshare; - -#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)] -#[typeshare(swift = "Sendable")] -#[serde(rename_all = "camelCase")] -pub struct JobConfiguration { - pub initial_interval_ms: u32, - pub max_interval_ms: u32, - pub step_factor: f32, -} diff --git a/crates/primitives/src/lib.rs b/crates/primitives/src/lib.rs index 32aeb642f..82ac2f9a5 100644 --- a/crates/primitives/src/lib.rs +++ b/crates/primitives/src/lib.rs @@ -112,8 +112,6 @@ pub mod time; pub use self::time::unix_timestamp; pub mod transaction_state; pub use self::transaction_state::TransactionState; -pub mod job_configuration; -pub use self::job_configuration::JobConfiguration; pub mod username_status; pub use self::username_status::UsernameStatus; pub mod recent_activity_type; diff --git a/gemstone/src/transaction_state/config.rs b/gemstone/src/transaction_state/config.rs index 39a654750..e869564f0 100644 --- a/gemstone/src/transaction_state/config.rs +++ b/gemstone/src/transaction_state/config.rs @@ -1,20 +1,20 @@ -use primitives::{Chain, JobConfiguration}; +use primitives::Chain; const INITIAL_CAP_MS: u32 = 5_000; const MAX_INTERVAL_MS: u32 = 15_000; const STEP_FACTOR: f32 = 1.1; -#[uniffi::remote(Record)] -pub struct 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) -> JobConfiguration { +pub fn transaction_state_config(chain: Chain) -> GemJobConfiguration { let block_time_ms = chain.block_time(); - JobConfiguration { + GemJobConfiguration { initial_interval_ms: block_time_ms.clamp(1, INITIAL_CAP_MS), max_interval_ms: MAX_INTERVAL_MS, step_factor: STEP_FACTOR, From 449e5e23babd45f4d1414d5da3be8da6cb3af0b5 Mon Sep 17 00:00:00 2001 From: gemdev111 <171273137+gemdev111@users.noreply.github.com> Date: Tue, 5 May 2026 20:52:29 +0300 Subject: [PATCH 10/10] Centralize job configuration in primitives Move job timing constants and logic into primitives::JobConfiguration and add JobConfiguration::transaction_state(chain) to compute initial_interval_ms, max_interval_ms and step_factor. Remove duplicate constants and construction from gemstone::transaction_state::config, and make gemstone build GemJobConfiguration from the shared JobConfiguration. This reduces duplication and ensures consistent transaction-state timing behavior across crates. --- crates/primitives/src/job_configuration.rs | 21 ++++++++++++++++----- gemstone/src/transaction_state/config.rs | 14 +++++--------- 2 files changed, 21 insertions(+), 14 deletions(-) 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/gemstone/src/transaction_state/config.rs b/gemstone/src/transaction_state/config.rs index e869564f0..6a72af73e 100644 --- a/gemstone/src/transaction_state/config.rs +++ b/gemstone/src/transaction_state/config.rs @@ -1,8 +1,4 @@ -use primitives::Chain; - -const INITIAL_CAP_MS: u32 = 5_000; -const MAX_INTERVAL_MS: u32 = 15_000; -const STEP_FACTOR: f32 = 1.1; +use primitives::{Chain, JobConfiguration}; #[derive(Debug, Clone, Copy, PartialEq, uniffi::Record)] pub struct GemJobConfiguration { @@ -13,10 +9,10 @@ pub struct GemJobConfiguration { #[uniffi::export] pub fn transaction_state_config(chain: Chain) -> GemJobConfiguration { - let block_time_ms = chain.block_time(); + let config = JobConfiguration::transaction_state(chain); GemJobConfiguration { - initial_interval_ms: block_time_ms.clamp(1, INITIAL_CAP_MS), - max_interval_ms: MAX_INTERVAL_MS, - step_factor: STEP_FACTOR, + initial_interval_ms: config.initial_interval_ms, + max_interval_ms: config.max_interval_ms, + step_factor: config.step_factor, } }