(
- transaction_xdr: Option<&String>,
- operations: Option<&Vec ::build_invoke_operation_standalone(
+ &fee_forwarder,
+ &fee_params,
+ vec![],
+ )
+ .map_err(|e| RelayerError::Internal(format!("Failed to build invoke operation: {e}")))?;
+
+ let envelope = build_soroban_transaction_envelope(
+ &self.relayer.address,
+ invoke_op,
+ base_fee_stroops as u32,
+ )?;
+
+ let sim_response = self
+ .provider
+ .simulate_transaction_envelope(&envelope)
+ .await
+ .map_err(|e| RelayerError::Internal(format!("Failed to simulate transaction: {e}")))?;
+
+ let total_fee = calculate_total_soroban_fee(&sim_response, 1)?;
+
+ let fee_quote = convert_xlm_fee_to_token(
+ self.dex_service.as_ref(),
+ &policy,
+ total_fee as u64,
+ ¶ms.fee_token,
+ )
+ .await
+ .map_err(crate::models::RelayerError::from)?;
+
+ debug!(
+ "Soroban fee estimate: {} stroops, {} token",
+ fee_quote.fee_in_stroops, fee_quote.fee_in_token
+ );
+
+ // Validate max fee
+ StellarTransactionValidator::validate_max_fee(fee_quote.fee_in_stroops, &policy)
+ .map_err(|e| RelayerError::ValidationError(e.to_string()))?;
+
+ // Validate token-specific max fee
+ StellarTransactionValidator::validate_token_max_fee(
+ ¶ms.fee_token,
+ fee_quote.fee_in_token,
+ &policy,
+ )
+ .map_err(|e| RelayerError::ValidationError(e.to_string()))?;
+
+ // Check user token balance using the original source envelope (user as source)
+ StellarTransactionValidator::validate_user_token_balance(
+ &source_envelope,
+ ¶ms.fee_token,
+ fee_quote.fee_in_token,
+ &self.provider,
+ )
+ .await
+ .map_err(|e| RelayerError::ValidationError(e.to_string()))?;
+
+ // Calculate max_fee with slippage buffer for Soroban
+ let max_fee_in_token = apply_max_fee_slippage(fee_quote.fee_in_token);
+ let token_decimals = policy
+ .get_allowed_token_decimals(¶ms.fee_token)
+ .unwrap_or(7);
+ let max_fee_in_token_ui = amount_to_ui_amount(max_fee_in_token as u64, token_decimals);
+
+ // Return using consolidated result struct
+ let result = StellarFeeEstimateResult {
+ fee_in_token_ui: fee_quote.fee_in_token_ui,
+ fee_in_token: fee_quote.fee_in_token.to_string(),
+ conversion_rate: fee_quote.conversion_rate.to_string(),
+ max_fee_in_token: Some(max_fee_in_token.to_string()),
+ max_fee_in_token_ui: Some(max_fee_in_token_ui),
+ };
+
+ Ok(SponsoredTransactionQuoteResponse::Stellar(result))
+ }
+
+ /// Build a Soroban sponsored transaction using FeeForwarder (XDR-based detection)
+ ///
+ /// Called when transaction_xdr contains an InvokeHostFunction operation.
+ /// Builds the FeeForwarder transaction wrapping the original contract call.
+ async fn build_soroban_sponsored(
+ &self,
+ params: &crate::models::StellarPrepareTransactionRequestParams,
+ soroban_info: &SorobanInvokeInfo,
+ ) -> Result ::build_invoke_operation_standalone(
+ &fee_forwarder,
+ &fee_params,
+ vec![], // Empty auth entries for simulation
+ )
+ .map_err(|e| RelayerError::Internal(format!("Failed to build invoke operation: {e}")))?;
+
+ let envelope = build_soroban_transaction_envelope(
+ &self.relayer.address,
+ invoke_op,
+ base_fee_stroops as u32,
+ )?;
+
+ let sim_response = self
+ .provider
+ .simulate_transaction_envelope(&envelope)
+ .await
+ .map_err(|e| RelayerError::Internal(format!("Failed to simulate transaction: {e}")))?;
+
+ let total_fee = calculate_total_soroban_fee(&sim_response, 1)?;
+
+ let fee_quote = convert_xlm_fee_to_token(
+ self.dex_service.as_ref(),
+ &policy,
+ total_fee as u64,
+ ¶ms.fee_token,
+ )
+ .await
+ .map_err(crate::models::RelayerError::from)?;
+
+ // Validate max fee
+ StellarTransactionValidator::validate_max_fee(fee_quote.fee_in_stroops, &policy)
+ .map_err(|e| RelayerError::ValidationError(e.to_string()))?;
+
+ // Validate token-specific max fee
+ StellarTransactionValidator::validate_token_max_fee(
+ ¶ms.fee_token,
+ fee_quote.fee_in_token,
+ &policy,
+ )
+ .map_err(|e| RelayerError::ValidationError(e.to_string()))?;
+
+ // Check user token balance using the original source envelope (user as source)
+ StellarTransactionValidator::validate_user_token_balance(
+ &source_envelope,
+ ¶ms.fee_token,
+ fee_quote.fee_in_token,
+ &self.provider,
+ )
+ .await
+ .map_err(|e| RelayerError::ValidationError(e.to_string()))?;
+
+ // Rebuild params with the final fee amounts
+ // Apply slippage buffer to max_fee_amount to allow for fee fluctuation
+ fee_params.fee_amount = fee_quote.fee_in_token as i128;
+ fee_params.max_fee_amount = apply_max_fee_slippage(fee_quote.fee_in_token);
+
+ // Build the user authorization entry for the user to sign
+ let user_auth_entry = FeeForwarderService:: ::build_user_auth_entry_standalone(
+ &fee_forwarder,
+ &fee_params,
+ true,
+ )
+ .map_err(|e| RelayerError::Internal(format!("Failed to build user auth entry: {e}")))?;
+
+ let user_auth_xdr = FeeForwarderService:: ::serialize_auth_entry(&user_auth_entry)
+ .map_err(|e| RelayerError::Internal(format!("Failed to serialize auth entry: {e}")))?;
+
+ // Build relayer auth entry - required by FeeForwarder contract
+ let relayer_auth_entry = FeeForwarderService:: ::build_relayer_auth_entry_standalone(
+ &fee_forwarder,
+ &fee_params,
+ )
+ .map_err(|e| RelayerError::Internal(format!("Failed to build relayer auth entry: {e}")))?;
+
+ // Build the final invoke operation WITH auth entries
+ // Note: We don't simulate again because the contract's custom auth verification
+ // would fail on empty signatures. We use the simulation data from the first
+ // simulation (without auth entries) to set the fee and resources.
+ let invoke_op = FeeForwarderService:: ::build_invoke_operation_standalone(
+ &fee_forwarder,
+ &fee_params,
+ vec![user_auth_entry, relayer_auth_entry],
+ )
+ .map_err(|e| RelayerError::Internal(format!("Failed to build invoke operation: {e}")))?;
+
+ let mut envelope = build_soroban_transaction_envelope(
+ &self.relayer.address,
+ invoke_op,
+ base_fee_stroops as u32,
+ )?;
+
+ // Apply simulation data from the first simulation (without auth entries)
+ // This sets the fee and Soroban resource data on the final envelope
+ // Also extends the footprint to include the relayer's account for require_auth
+ apply_simulation_to_soroban_envelope(&mut envelope, &sim_response, 1)?;
+
+ let transaction_xdr = envelope
+ .to_xdr_base64(Limits::none())
+ .map_err(|e| RelayerError::Internal(format!("Failed to serialize transaction: {e}")))?;
+
+ // Derive valid_until from expiration_ledger to ensure consistency
+ // Get current ledger to calculate time until expiration
+ let current_ledger =
+ self.provider.get_latest_ledger().await.map_err(|e| {
+ RelayerError::Internal(format!("Failed to get current ledger: {e}"))
+ })?;
+ let ledgers_until_expiration = expiration_ledger.saturating_sub(current_ledger.sequence);
+ let seconds_until_expiration =
+ ledgers_until_expiration as u64 * STELLAR_LEDGER_TIME_SECONDS;
+ let valid_until = Utc::now() + chrono::Duration::seconds(seconds_until_expiration as i64);
+
+ debug!(
+ "Soroban build complete: transaction_xdr length={}, auth_xdr length={}, expiration_ledger={}, valid_until={}",
+ transaction_xdr.len(),
+ user_auth_xdr.len(),
+ expiration_ledger,
+ valid_until.to_rfc3339()
+ );
+
+ // Calculate max_fee with slippage buffer for Soroban
+ let max_fee_in_token = fee_params.max_fee_amount;
+ let token_decimals = policy
+ .get_allowed_token_decimals(¶ms.fee_token)
+ .unwrap_or(7);
+ let max_fee_in_token_ui = amount_to_ui_amount(max_fee_in_token as u64, token_decimals);
+
+ // Return using consolidated result struct with Soroban-specific fields populated
+ let result = StellarPrepareTransactionResult {
+ transaction: transaction_xdr,
+ fee_in_token: fee_quote.fee_in_token.to_string(),
+ fee_in_token_ui: fee_quote.fee_in_token_ui,
+ fee_in_stroops: fee_quote.fee_in_stroops.to_string(),
+ fee_token: params.fee_token.clone(),
+ valid_until: valid_until.to_rfc3339(),
+ // Soroban-specific fields
+ user_auth_entry: Some(user_auth_xdr),
+ max_fee_in_token: Some(max_fee_in_token.to_string()),
+ max_fee_in_token_ui: Some(max_fee_in_token_ui),
+ };
+
+ Ok(SponsoredTransactionBuildResponse::Stellar(result))
}
}
-/// Add a fee payment operation to the transaction envelope
-fn add_fee_payment_operation(
+/// Build a Soroban transaction envelope with the given operation
+fn build_soroban_transaction_envelope(
+ source_address: &str,
+ operation: Operation,
+ fee: u32,
+) -> Result (
+ transaction_xdr: Option<&String>,
+ operations: Option<&Vec (
+ provider: &P,
+ validity_seconds: u64,
+) -> Result (
+ envelope: &mut TransactionEnvelope,
+ signed_auth_entries: &[SorobanAuthorizationEntry],
+ provider: &P,
+) -> Result<(), TransactionError>
+where
+ P: StellarProviderTrait + Send + Sync,
+{
+ debug!("Re-simulating transaction with signed auth entries for accurate footprint");
+
+ // Use the actual signed auth entries for simulation
+ // This allows the simulation to verify signatures and capture the correct footprint
+ // including all accounts accessed via require_auth/require_auth_for_args
+ let simulation_auth_entries: Vec (
+ envelope: &TransactionEnvelope,
+ provider: &P,
+) -> Result (
provider: &P,
account_id: &str,
@@ -255,64 +264,53 @@ async fn get_contract_token_balance (
where
P: StellarProviderTrait + Send + Sync,
{
- // Parse contract address and account ID
- let contract_hash = parse_contract_address(contract_address)?;
+ // Build the account address as ScVal::Address
let account_xdr_id = parse_account_id(account_id)?;
let account_sc_address = ScAddress::Account(account_xdr_id);
- // Create balance key (Soroban token standard uses "Balance" as the key)
- let balance_key = create_contract_data_key("Balance", Some(account_sc_address))?;
-
- // Query contract data with durability fallback
- let error_context = format!("contract {contract_address} balance for account {account_id}");
- let ledger_entries =
- query_contract_data_with_fallback(provider, contract_hash, balance_key, &error_context)
- .await?;
-
- // Extract balance from contract data entry
- let entries = match ledger_entries.entries {
- Some(entries) if !entries.is_empty() => entries,
- _ => {
- // No balance entry means balance is 0
- warn!(
- "No balance entry found for contract {} on account {}, assuming zero balance",
- contract_address, account_id
- );
- return Ok(0);
- }
- };
+ // Create the "balance" function name symbol
+ let function_name = ScSymbol::try_from("balance".as_bytes().to_vec()).map_err(|e| {
+ StellarTransactionUtilsError::SymbolCreationFailed("balance".into(), format!("{e:?}"))
+ })?;
- let entry_result = &entries[0];
- let entry = parse_ledger_entry_from_xdr(&entry_result.xdr, &error_context)?;
+ // Call balance(id: Address) -> i128 via simulation
+ debug!(
+ "Querying balance for account {} on contract {} via simulation",
+ account_id, contract_address
+ );
- match entry {
- LedgerEntryData::ContractData(ContractDataEntry { val, .. }) => match val {
- ScVal::I128(parts) => {
- if parts.hi != 0 {
- return Err(StellarTransactionUtilsError::BalanceTooLarge(
- parts.hi, parts.lo,
- ));
- }
- // Check if parts.lo represents a negative value when interpreted as i64
- // Similar to the I64 branch, we check for negative before casting to u64
- let lo_as_i64 = parts.lo as i64;
- if lo_as_i64 < 0 {
- return Err(StellarTransactionUtilsError::NegativeBalanceI128(parts.lo));
- }
- Ok(lo_as_i64 as u64)
+ let result = provider
+ .call_contract(
+ contract_address,
+ &function_name,
+ vec![ScVal::Address(account_sc_address)],
+ )
+ .await
+ .map_err(|e| StellarTransactionUtilsError::SimulationFailed(e.to_string()))?;
+
+ // Parse i128 result to u64
+ match result {
+ ScVal::I128(parts) => {
+ // Check for overflow (hi should be 0 for values that fit in u64)
+ if parts.hi != 0 {
+ return Err(StellarTransactionUtilsError::BalanceTooLarge(
+ parts.hi, parts.lo,
+ ));
}
- ScVal::U64(n) => Ok(n),
- ScVal::I64(n) => {
- if n < 0 {
- return Err(StellarTransactionUtilsError::NegativeBalanceI64(n));
- }
- Ok(n as u64)
+ // Check for negative balance
+ let lo_as_i64 = parts.lo as i64;
+ if lo_as_i64 < 0 {
+ return Err(StellarTransactionUtilsError::NegativeBalanceI128(parts.lo));
}
- other => Err(StellarTransactionUtilsError::UnexpectedBalanceType(
- format!("{other:?}"),
- )),
- },
- _ => Err(StellarTransactionUtilsError::UnexpectedContractDataEntryType),
+ debug!(
+ "Balance for account {} on contract {}: {}",
+ account_id, contract_address, lo_as_i64
+ );
+ Ok(lo_as_i64 as u64)
+ }
+ other => Err(StellarTransactionUtilsError::UnexpectedBalanceType(
+ format!("{other:?}"),
+ )),
}
}
@@ -1344,17 +1342,14 @@ mod tests {
#[tokio::test]
async fn test_get_token_balance_contract_token_no_balance_entry() {
+ use soroban_rs::xdr::Int128Parts;
+
let mut provider = create_mock_provider();
- // Mock empty response (no balance entry)
- provider.expect_get_ledger_entries().returning(|_| {
- Box::pin(ready(Ok(
- soroban_rs::stellar_rpc_client::GetLedgerEntriesResponse {
- entries: None,
- latest_ledger: 0,
- },
- )))
- });
+ // Mock call_contract to return 0 balance (contract returns 0 for non-existent balances)
+ provider
+ .expect_call_contract()
+ .returning(|_, _, _| Box::pin(ready(Ok(ScVal::I128(Int128Parts { hi: 0, lo: 0 })))));
let contract_addr = "CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA";
let account = TEST_PK;
@@ -1368,46 +1363,13 @@ mod tests {
#[tokio::test]
async fn test_get_token_balance_contract_token_i128_balance() {
- use soroban_rs::stellar_rpc_client::{GetLedgerEntriesResponse, LedgerEntryResult};
- use soroban_rs::xdr::{
- ContractDataDurability, ContractDataEntry, ExtensionPoint, Int128Parts, LedgerEntry,
- LedgerEntryData, LedgerEntryExt, ScVal, WriteXdr,
- };
+ use soroban_rs::xdr::Int128Parts;
let mut provider = create_mock_provider();
- // Mock response with I128 balance
- provider.expect_get_ledger_entries().returning(|_| {
- let balance_val = ScVal::I128(Int128Parts { hi: 0, lo: 1000000 });
-
- let contract_data = ContractDataEntry {
- ext: ExtensionPoint::V0,
- contract: ScAddress::Contract(ContractId(Hash([0u8; 32]))),
- key: ScVal::Vec(None),
- durability: ContractDataDurability::Persistent,
- val: balance_val,
- };
-
- let ledger_entry = LedgerEntry {
- last_modified_ledger_seq: 0,
- data: LedgerEntryData::ContractData(contract_data),
- ext: LedgerEntryExt::V0,
- };
-
- let xdr_base64 = ledger_entry
- .data
- .to_xdr_base64(soroban_rs::xdr::Limits::none())
- .unwrap();
-
- Box::pin(ready(Ok(GetLedgerEntriesResponse {
- entries: Some(vec![LedgerEntryResult {
- key: String::new(),
- xdr: xdr_base64,
- last_modified_ledger: 0,
- live_until_ledger_seq_ledger_seq: None,
- }]),
- latest_ledger: 0,
- })))
+ // Mock call_contract to return I128 balance
+ provider.expect_call_contract().returning(|_, _, _| {
+ Box::pin(ready(Ok(ScVal::I128(Int128Parts { hi: 0, lo: 1000000 }))))
});
let contract_addr = "CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA";
@@ -1420,49 +1382,16 @@ mod tests {
#[tokio::test]
async fn test_get_token_balance_contract_token_i128_balance_too_large() {
- use soroban_rs::stellar_rpc_client::{GetLedgerEntriesResponse, LedgerEntryResult};
- use soroban_rs::xdr::{
- ContractDataDurability, ContractDataEntry, ExtensionPoint, Int128Parts, LedgerEntry,
- LedgerEntryData, LedgerEntryExt, ScVal, WriteXdr,
- };
+ use soroban_rs::xdr::Int128Parts;
let mut provider = create_mock_provider();
- // Mock response with I128 balance where hi != 0
- provider.expect_get_ledger_entries().returning(|_| {
- let balance_val = ScVal::I128(Int128Parts {
+ // Mock call_contract to return I128 balance with hi != 0 (too large)
+ provider.expect_call_contract().returning(|_, _, _| {
+ Box::pin(ready(Ok(ScVal::I128(Int128Parts {
hi: 1, // Non-zero hi means balance is too large
lo: 1000000,
- });
-
- let contract_data = ContractDataEntry {
- ext: ExtensionPoint::V0,
- contract: ScAddress::Contract(ContractId(Hash([0u8; 32]))),
- key: ScVal::Vec(None),
- durability: ContractDataDurability::Persistent,
- val: balance_val,
- };
-
- let ledger_entry = LedgerEntry {
- last_modified_ledger_seq: 0,
- data: LedgerEntryData::ContractData(contract_data),
- ext: LedgerEntryExt::V0,
- };
-
- let xdr_base64 = ledger_entry
- .data
- .to_xdr_base64(soroban_rs::xdr::Limits::none())
- .unwrap();
-
- Box::pin(ready(Ok(GetLedgerEntriesResponse {
- entries: Some(vec![LedgerEntryResult {
- key: String::new(),
- xdr: xdr_base64,
- last_modified_ledger: 0,
- live_until_ledger_seq_ledger_seq: None,
- }]),
- latest_ledger: 0,
- })))
+ }))))
});
let contract_addr = "CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA";
@@ -1481,49 +1410,16 @@ mod tests {
#[tokio::test]
async fn test_get_token_balance_contract_token_i128_negative() {
- use soroban_rs::stellar_rpc_client::{GetLedgerEntriesResponse, LedgerEntryResult};
- use soroban_rs::xdr::{
- ContractDataDurability, ContractDataEntry, ExtensionPoint, Int128Parts, LedgerEntry,
- LedgerEntryData, LedgerEntryExt, ScVal, WriteXdr,
- };
+ use soroban_rs::xdr::Int128Parts;
let mut provider = create_mock_provider();
- // Mock response with negative I128 balance
- provider.expect_get_ledger_entries().returning(|_| {
- let balance_val = ScVal::I128(Int128Parts {
+ // Mock call_contract to return negative I128 balance
+ provider.expect_call_contract().returning(|_, _, _| {
+ Box::pin(ready(Ok(ScVal::I128(Int128Parts {
hi: 0,
lo: u64::MAX, // When cast to i64, this is negative
- });
-
- let contract_data = ContractDataEntry {
- ext: ExtensionPoint::V0,
- contract: ScAddress::Contract(ContractId(Hash([0u8; 32]))),
- key: ScVal::Vec(None),
- durability: ContractDataDurability::Persistent,
- val: balance_val,
- };
-
- let ledger_entry = LedgerEntry {
- last_modified_ledger_seq: 0,
- data: LedgerEntryData::ContractData(contract_data),
- ext: LedgerEntryExt::V0,
- };
-
- let xdr_base64 = ledger_entry
- .data
- .to_xdr_base64(soroban_rs::xdr::Limits::none())
- .unwrap();
-
- Box::pin(ready(Ok(GetLedgerEntriesResponse {
- entries: Some(vec![LedgerEntryResult {
- key: String::new(),
- xdr: xdr_base64,
- last_modified_ledger: 0,
- live_until_ledger_seq_ledger_seq: None,
- }]),
- latest_ledger: 0,
- })))
+ }))))
});
let contract_addr = "CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA";
@@ -1539,208 +1435,75 @@ mod tests {
#[tokio::test]
async fn test_get_token_balance_contract_token_u64_balance() {
- use soroban_rs::stellar_rpc_client::{GetLedgerEntriesResponse, LedgerEntryResult};
- use soroban_rs::xdr::{
- ContractDataDurability, ContractDataEntry, ExtensionPoint, LedgerEntry,
- LedgerEntryData, LedgerEntryExt, ScVal, WriteXdr,
- };
-
let mut provider = create_mock_provider();
- // Mock response with U64 balance
- provider.expect_get_ledger_entries().returning(|_| {
- let balance_val = ScVal::U64(5000000);
-
- let contract_data = ContractDataEntry {
- ext: ExtensionPoint::V0,
- contract: ScAddress::Contract(ContractId(Hash([0u8; 32]))),
- key: ScVal::Vec(None),
- durability: ContractDataDurability::Persistent,
- val: balance_val,
- };
-
- let ledger_entry = LedgerEntry {
- last_modified_ledger_seq: 0,
- data: LedgerEntryData::ContractData(contract_data),
- ext: LedgerEntryExt::V0,
- };
-
- let xdr_base64 = ledger_entry
- .data
- .to_xdr_base64(soroban_rs::xdr::Limits::none())
- .unwrap();
-
- Box::pin(ready(Ok(GetLedgerEntriesResponse {
- entries: Some(vec![LedgerEntryResult {
- key: String::new(),
- xdr: xdr_base64,
- last_modified_ledger: 0,
- live_until_ledger_seq_ledger_seq: None,
- }]),
- latest_ledger: 0,
- })))
- });
+ // Mock call_contract to return U64 balance - this is unexpected for balance() which returns i128
+ provider
+ .expect_call_contract()
+ .returning(|_, _, _| Box::pin(ready(Ok(ScVal::U64(5000000)))));
let contract_addr = "CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA";
let account = TEST_PK;
let result = get_token_balance(&provider, account, contract_addr).await;
- assert!(result.is_ok());
- assert_eq!(result.unwrap(), 5000000);
+ // U64 is not a valid return type for balance(), should return UnexpectedBalanceType
+ assert!(result.is_err());
+ match result.unwrap_err() {
+ StellarTransactionUtilsError::UnexpectedBalanceType(_) => {}
+ e => panic!("Expected UnexpectedBalanceType, got: {:?}", e),
+ }
}
#[tokio::test]
async fn test_get_token_balance_contract_token_i64_positive() {
- use soroban_rs::stellar_rpc_client::{GetLedgerEntriesResponse, LedgerEntryResult};
- use soroban_rs::xdr::{
- ContractDataDurability, ContractDataEntry, ExtensionPoint, LedgerEntry,
- LedgerEntryData, LedgerEntryExt, ScVal, WriteXdr,
- };
-
let mut provider = create_mock_provider();
- // Mock response with positive I64 balance
- provider.expect_get_ledger_entries().returning(|_| {
- let balance_val = ScVal::I64(3000000);
-
- let contract_data = ContractDataEntry {
- ext: ExtensionPoint::V0,
- contract: ScAddress::Contract(ContractId(Hash([0u8; 32]))),
- key: ScVal::Vec(None),
- durability: ContractDataDurability::Persistent,
- val: balance_val,
- };
-
- let ledger_entry = LedgerEntry {
- last_modified_ledger_seq: 0,
- data: LedgerEntryData::ContractData(contract_data),
- ext: LedgerEntryExt::V0,
- };
-
- let xdr_base64 = ledger_entry
- .data
- .to_xdr_base64(soroban_rs::xdr::Limits::none())
- .unwrap();
-
- Box::pin(ready(Ok(GetLedgerEntriesResponse {
- entries: Some(vec![LedgerEntryResult {
- key: String::new(),
- xdr: xdr_base64,
- last_modified_ledger: 0,
- live_until_ledger_seq_ledger_seq: None,
- }]),
- latest_ledger: 0,
- })))
- });
+ // Mock call_contract to return I64 balance - this is unexpected for balance() which returns i128
+ provider
+ .expect_call_contract()
+ .returning(|_, _, _| Box::pin(ready(Ok(ScVal::I64(3000000)))));
let contract_addr = "CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA";
let account = TEST_PK;
let result = get_token_balance(&provider, account, contract_addr).await;
- assert!(result.is_ok());
- assert_eq!(result.unwrap(), 3000000);
+ // I64 is not a valid return type for balance(), should return UnexpectedBalanceType
+ assert!(result.is_err());
+ match result.unwrap_err() {
+ StellarTransactionUtilsError::UnexpectedBalanceType(_) => {}
+ e => panic!("Expected UnexpectedBalanceType, got: {:?}", e),
+ }
}
#[tokio::test]
async fn test_get_token_balance_contract_token_i64_negative() {
- use soroban_rs::stellar_rpc_client::{GetLedgerEntriesResponse, LedgerEntryResult};
- use soroban_rs::xdr::{
- ContractDataDurability, ContractDataEntry, ExtensionPoint, LedgerEntry,
- LedgerEntryData, LedgerEntryExt, ScVal, WriteXdr,
- };
-
let mut provider = create_mock_provider();
- // Mock response with negative I64 balance
- provider.expect_get_ledger_entries().returning(|_| {
- let balance_val = ScVal::I64(-1000);
-
- let contract_data = ContractDataEntry {
- ext: ExtensionPoint::V0,
- contract: ScAddress::Contract(ContractId(Hash([0u8; 32]))),
- key: ScVal::Vec(None),
- durability: ContractDataDurability::Persistent,
- val: balance_val,
- };
-
- let ledger_entry = LedgerEntry {
- last_modified_ledger_seq: 0,
- data: LedgerEntryData::ContractData(contract_data),
- ext: LedgerEntryExt::V0,
- };
-
- let xdr_base64 = ledger_entry
- .data
- .to_xdr_base64(soroban_rs::xdr::Limits::none())
- .unwrap();
-
- Box::pin(ready(Ok(GetLedgerEntriesResponse {
- entries: Some(vec![LedgerEntryResult {
- key: String::new(),
- xdr: xdr_base64,
- last_modified_ledger: 0,
- live_until_ledger_seq_ledger_seq: None,
- }]),
- latest_ledger: 0,
- })))
- });
+ // Mock call_contract to return I64 balance - this is unexpected for balance() which returns i128
+ provider
+ .expect_call_contract()
+ .returning(|_, _, _| Box::pin(ready(Ok(ScVal::I64(-1000)))));
let contract_addr = "CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA";
let account = TEST_PK;
let result = get_token_balance(&provider, account, contract_addr).await;
+ // I64 is not a valid return type for balance(), should return UnexpectedBalanceType
assert!(result.is_err());
match result.unwrap_err() {
- StellarTransactionUtilsError::NegativeBalanceI64(n) => {
- assert_eq!(n, -1000);
- }
- e => panic!("Expected NegativeBalanceI64, got: {:?}", e),
+ StellarTransactionUtilsError::UnexpectedBalanceType(_) => {}
+ e => panic!("Expected UnexpectedBalanceType, got: {:?}", e),
}
}
#[tokio::test]
async fn test_get_token_balance_contract_token_unexpected_balance_type() {
- use soroban_rs::stellar_rpc_client::{GetLedgerEntriesResponse, LedgerEntryResult};
- use soroban_rs::xdr::{
- ContractDataDurability, ContractDataEntry, ExtensionPoint, LedgerEntry,
- LedgerEntryData, LedgerEntryExt, ScVal, WriteXdr,
- };
-
let mut provider = create_mock_provider();
- // Mock response with unexpected balance type (Bool)
- provider.expect_get_ledger_entries().returning(|_| {
- let balance_val = ScVal::Bool(true);
-
- let contract_data = ContractDataEntry {
- ext: ExtensionPoint::V0,
- contract: ScAddress::Contract(ContractId(Hash([0u8; 32]))),
- key: ScVal::Vec(None),
- durability: ContractDataDurability::Persistent,
- val: balance_val,
- };
-
- let ledger_entry = LedgerEntry {
- last_modified_ledger_seq: 0,
- data: LedgerEntryData::ContractData(contract_data),
- ext: LedgerEntryExt::V0,
- };
-
- let xdr_base64 = ledger_entry
- .data
- .to_xdr_base64(soroban_rs::xdr::Limits::none())
- .unwrap();
-
- Box::pin(ready(Ok(GetLedgerEntriesResponse {
- entries: Some(vec![LedgerEntryResult {
- key: String::new(),
- xdr: xdr_base64,
- last_modified_ledger: 0,
- live_until_ledger_seq_ledger_seq: None,
- }]),
- latest_ledger: 0,
- })))
- });
+ // Mock call_contract to return unexpected balance type (Bool)
+ provider
+ .expect_call_contract()
+ .returning(|_, _, _| Box::pin(ready(Ok(ScVal::Bool(true)))));
let contract_addr = "CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA";
let account = TEST_PK;
diff --git a/src/domain/transaction/stellar/utils.rs b/src/domain/transaction/stellar/utils.rs
index 6edb6255d..2ad8df821 100644
--- a/src/domain/transaction/stellar/utils.rs
+++ b/src/domain/transaction/stellar/utils.rs
@@ -67,6 +67,12 @@ pub enum StellarTransactionUtilsError {
#[error("Cannot set time bounds on fee-bump transactions")]
CannotSetTimeBoundsOnFeeBump,
+ #[error("V0 transactions are not supported")]
+ V0TransactionsNotSupported,
+
+ #[error("Cannot update sequence number on fee bump transaction")]
+ CannotUpdateSequenceOnFeeBump,
+
#[error("Invalid transaction format: {0}")]
InvalidTransactionFormat(String),
@@ -184,6 +190,14 @@ impl From
+where
+ P: StellarProviderTrait + Send + Sync + 'static,
+{
+ /// Soroswap router contract address
+ router_address: String,
+ /// Soroswap factory contract address (required for get_amounts_out)
+ factory_address: String,
+ /// Native XLM wrapper token address
+ native_wrapper_address: String,
+ /// Stellar provider for contract calls
+ provider: Arc ,
+ /// Network passphrase for signing (used for swap execution)
+ #[allow(dead_code)]
+ network_passphrase: String,
+}
+
+impl SoroswapService
+where
+ P: StellarProviderTrait + Send + Sync + 'static,
+{
+ /// Create a new SoroswapService instance
+ ///
+ /// # Arguments
+ ///
+ /// * `router_address` - Soroswap router contract address
+ /// * `factory_address` - Soroswap factory contract address (required for get_amounts_out)
+ /// * `native_wrapper_address` - Native XLM wrapper token address
+ /// * `provider` - Stellar provider for contract calls
+ /// * `network_passphrase` - Network passphrase
+ pub fn new(
+ router_address: String,
+ factory_address: String,
+ native_wrapper_address: String,
+ provider: Arc ,
+ network_passphrase: String,
+ ) -> Self {
+ Self {
+ router_address,
+ factory_address,
+ native_wrapper_address,
+ provider,
+ network_passphrase,
+ }
+ }
+
+ /// Parse a Soroban contract address (C...) to ScAddress
+ fn parse_contract_to_sc_address(address: &str) -> Result StellarDexServiceTrait for SoroswapService
+where
+ P: StellarProviderTrait + Send + Sync + 'static,
+{
+ fn supported_asset_types(&self) -> HashSet
+where
+ P: StellarProviderTrait + Send + Sync,
+{
+ /// FeeForwarder contract address
+ fee_forwarder_address: String,
+ /// Stellar provider for network queries
+ provider: Arc ,
+}
+
+impl FeeForwarderService
+where
+ P: StellarProviderTrait + Send + Sync,
+{
+ /// Create a new FeeForwarderService
+ ///
+ /// # Arguments
+ ///
+ /// * `fee_forwarder_address` - The deployed FeeForwarder contract address
+ /// * `provider` - Stellar provider for network queries
+ pub fn new(fee_forwarder_address: String, provider: Arc ) -> Self {
+ Self {
+ fee_forwarder_address,
+ provider,
+ }
+ }
+
+ /// Build a user authorization entry without requiring a FeeForwarderService instance
+ ///
+ /// This static method is useful when you don't have an `Arc ` provider
+ /// but still need to build authorization entries for the FeeForwarder.
+ pub fn build_user_auth_entry_standalone(
+ fee_forwarder_address: &str,
+ params: &FeeForwarderParams,
+ requires_target_auth: bool,
+ ) -> Result,
+ pub(crate) signer: Arc,
pub(crate) network: StellarNetwork,
pub(crate) provider: P,
pub(crate) relayer_repository: Arc