refactor: Implement multi-oracle architecture with route validation

Author: shahnami

crates/solver-service/src/apis/quote/generation.rs

@@ -161,7 +161,7 @@ impl QuoteGenerator {
 	) -> Result<QuoteOrder, QuoteError> {
 		// Standard determined by business logic context
 		// Currently we only support EIP7683
-		let standard = "eip7683";
+		let _standard = "eip7683"; // Currently only supporting eip7683
 
 		// Extract chain from first output to find appropriate settlement
 		// TODO: Implement support for multiple destination chains
@@ -173,14 +173,16 @@ impl QuoteGenerator {
 			.ethereum_chain_id()
 			.map_err(|e| QuoteError::InvalidRequest(format!("Invalid chain ID: {}", e)))?;
 
-		// Lookup settlement for exact standard and network
-		let settlement = self
+		// Get settlement AND selected oracle for consistency
+		let (settlement, selected_oracle) = self
 			.settlement_service
-			.find_settlement_for_standard_and_network(standard, chain_id)
-			.map_err(|e| QuoteError::InvalidRequest(e.to_string()))?;
+			.get_any_settlement_for_chain(chain_id)
+			.ok_or_else(|| QuoteError::InvalidRequest(
+				format!("No settlement available for chain {}", chain_id)
+			))?;
 
 		match escrow_kind {
-			EscrowKind::Permit2 => self.generate_permit2_order(request, config, settlement),
+			EscrowKind::Permit2 => self.generate_permit2_order(request, config, settlement, selected_oracle),
 			EscrowKind::Erc3009 => self.generate_erc3009_order(request, config),
 		}
 	}
@@ -190,6 +192,7 @@ impl QuoteGenerator {
 		request: &GetQuoteRequest,
 		config: &Config,
 		settlement: &dyn SettlementInterface,
+		selected_oracle: solver_types::Address,
 	) -> Result<QuoteOrder, QuoteError> {
 		use alloy_primitives::hex;
 
@@ -201,7 +204,7 @@ impl QuoteGenerator {
 			})?;
 		let domain_address = permit2_domain_address_from_config(config, chain_id)?;
 		let (final_digest, message_obj) =
-			build_permit2_batch_witness_digest(request, config, settlement)?;
+			build_permit2_batch_witness_digest(request, config, settlement, selected_oracle)?;
 		let message = serde_json::json!({ "digest": with_0x_prefix(&hex::encode(final_digest)), "eip712": message_obj });
 		Ok(QuoteOrder {
 			signature_type: SignatureType::Eip712,

crates/solver-service/src/apis/quote/signing/payloads/permit2.rs

@@ -35,7 +35,8 @@ use solver_types::{
 pub fn build_permit2_batch_witness_digest(
 	request: &GetQuoteRequest,
 	config: &Config,
-	settlement: &dyn SettlementInterface,
+	_settlement: &dyn SettlementInterface, // Kept for potential future use
+	selected_oracle: solver_types::Address,
 ) -> Result<(B256, serde_json::Value), QuoteError> {
 	// TODO: Implement support for multi-input/outputs
 	let input = &request.available_inputs[0];
@@ -92,16 +93,8 @@ pub fn build_permit2_batch_witness_digest(
 			QuoteError::InvalidRequest(format!("Permit2 not deployed on chain {}", origin_chain_id))
 		})?;
 
-	// Oracle address (per origin chain) from the settlement implementation
-	let input_oracle = settlement
-		.get_oracle_address(origin_chain_id)
-		.ok_or_else(|| {
-			QuoteError::InvalidRequest(format!(
-				"No oracle configured for chain {}",
-				origin_chain_id
-			))
-		})?;
-	let input_oracle = bytes20_to_alloy_address(&input_oracle.0)
+	// Use the pre-selected oracle address
+	let input_oracle = bytes20_to_alloy_address(&selected_oracle.0)
 		.map_err(|e| QuoteError::InvalidRequest(format!("Invalid oracle address: {}", e)))?;
 
 	// Nonce and deadlines

crates/solver-settlement/src/implementations/direct.rs

@@ -5,14 +5,17 @@
 //! readiness checks using simple transaction receipt verification without
 //! complex attestation mechanisms.
 
-use crate::{SettlementError, SettlementInterface};
-use alloy_primitives::{hex, Address as AlloyAddress, FixedBytes};
+use crate::{
+	utils::parse_oracle_config, OracleConfig, SettlementError,
+	SettlementInterface,
+};
+use alloy_primitives::{hex, FixedBytes};
 use alloy_provider::{Provider, RootProvider};
 use alloy_rpc_types::BlockTransactionsKind;
 use alloy_transport_http::Http;
 use async_trait::async_trait;
 use solver_types::{
-	without_0x_prefix, ConfigSchema, Eip7683OrderData, Field, FieldType, FillProof, NetworksConfig,
+	with_0x_prefix, ConfigSchema, Eip7683OrderData, Field, FieldType, FillProof, NetworksConfig,
 	Order, Schema, TransactionHash,
 };
 use std::collections::HashMap;
@@ -22,35 +25,38 @@ use std::collections::HashMap;
 /// This implementation validates fills by checking transaction receipts
 /// and manages dispute periods before allowing claims.
 pub struct DirectSettlement {
-	/// The order type this implementation handles
-	order: String,
-	/// Supported network IDs
-	network_ids: Vec<u64>,
 	/// RPC providers for each supported network.
 	providers: HashMap<u64, RootProvider<Http<reqwest::Client>>>,
-	/// Oracle addresses for each network (network_id -> oracle_address).
-	oracle_addresses: HashMap<u64, String>,
+	/// Oracle configuration including addresses and routes
+	oracle_config: OracleConfig,
 	/// Dispute period duration in seconds.
 	dispute_period_seconds: u64,
 }
 
 impl DirectSettlement {
 	/// Creates a new DirectSettlement instance.
 	///
-	/// Configures settlement validation with multiple networks, oracle addresses,
+	/// Configures settlement validation with oracle configuration
 	/// and dispute period.
 	pub async fn new(
-		order: String,
-		network_ids: Vec<u64>,
 		networks: &NetworksConfig,
-		oracle_addresses: HashMap<u64, String>,
+		oracle_config: OracleConfig,
 		dispute_period_seconds: u64,
 	) -> Result<Self, SettlementError> {
-		// Create RPC providers for each supported network
+		// Create RPC providers for each network that has oracles configured
 		let mut providers = HashMap::new();
+		let mut all_network_ids = std::collections::HashSet::new();
 
-		for network_id in &network_ids {
-			let network = networks.get(network_id).ok_or_else(|| {
+		// Collect all network IDs from input and output oracles
+		for network_id in oracle_config.input_oracles.keys() {
+			all_network_ids.insert(*network_id);
+		}
+		for network_id in oracle_config.output_oracles.keys() {
+			all_network_ids.insert(*network_id);
+		}
+
+		for network_id in all_network_ids {
+			let network = networks.get(&network_id).ok_or_else(|| {
 				SettlementError::ValidationFailed(format!(
 					"Network {} not found in configuration",
 					network_id
@@ -70,26 +76,12 @@ impl DirectSettlement {
 				))
 			})?);
 
-			providers.insert(*network_id, provider);
-		}
-
-		// Validate oracle addresses
-		let mut validated_oracle_addresses = HashMap::new();
-		for (network_id, oracle_address) in oracle_addresses {
-			let oracle = oracle_address.parse::<AlloyAddress>().map_err(|e| {
-				SettlementError::ValidationFailed(format!(
-					"Invalid oracle address for network {}: {}",
-					network_id, e
-				))
-			})?;
-			validated_oracle_addresses.insert(network_id, oracle.to_string());
+			providers.insert(network_id, provider);
 		}
 
 		Ok(Self {
-			order,
-			network_ids: network_ids.clone(),
 			providers,
-			oracle_addresses: validated_oracle_addresses,
+			oracle_config,
 			dispute_period_seconds,
 		})
 	}
@@ -111,53 +103,27 @@ impl ConfigSchema for DirectSettlementSchema {
 		let schema = Schema::new(
 			// Required fields
 			vec![
-				Field::new("order", FieldType::String),
 				Field::new(
-					"network_ids",
-					FieldType::Array(Box::new(FieldType::Integer {
-						min: Some(1),
-						max: None,
-					})),
+					"dispute_period_seconds",
+					FieldType::Integer {
+						min: Some(0),
+						max: Some(86400),
+					},
 				),
 				Field::new(
-					"oracle_addresses",
+					"oracles",
 					FieldType::Table(Schema::new(
-						vec![], // No required fields - network IDs are dynamic
-						vec![], // No optional fields - all entries should be valid addresses
+						vec![
+							Field::new("input", FieldType::Table(Schema::new(vec![], vec![]))),
+							Field::new("output", FieldType::Table(Schema::new(vec![], vec![]))),
+						],
+						vec![],
 					)),
-				)
-				.with_validator(|value| {
-					// Validate that all values in the table are valid Ethereum addresses
-					if let Some(table) = value.as_table() {
-						for (network_id, address_value) in table {
-							if let Some(addr) = address_value.as_str() {
-								if addr.len() != 42 || !addr.starts_with("0x") {
-									return Err(format!(
-										"oracle_addresses.{} must be a valid Ethereum address",
-										network_id
-									));
-								}
-							} else {
-								return Err(format!(
-									"oracle_addresses.{} must be a string",
-									network_id
-								));
-							}
-						}
-						Ok(())
-					} else {
-						Err("oracle_addresses must be a table".to_string())
-					}
-				}),
+				),
+				Field::new("routes", FieldType::Table(Schema::new(vec![], vec![]))),
 			],
 			// Optional fields
-			vec![Field::new(
-				"dispute_period_seconds",
-				FieldType::Integer {
-					min: Some(0),
-					max: Some(86400),
-				},
-			)],
+			vec![Field::new("oracle_selection_strategy", FieldType::String)],
 		);
 
 		schema.validate(config)
@@ -166,39 +132,14 @@ impl ConfigSchema for DirectSettlementSchema {
 
 #[async_trait]
 impl SettlementInterface for DirectSettlement {
-	fn supported_order(&self) -> &str {
-		&self.order
-	}
-
-	fn supported_networks(&self) -> &[u64] {
-		&self.network_ids
+	fn oracle_config(&self) -> &OracleConfig {
+		&self.oracle_config
 	}
 
 	fn config_schema(&self) -> Box<dyn ConfigSchema> {
 		Box::new(DirectSettlementSchema)
 	}
 
-	/// Returns the oracle address configured for a specific chain.
-	///
-	/// This implementation stores oracle addresses per chain in its configuration.
-	/// The addresses are stored as hex strings and converted to the Address type on demand.
-	///
-	/// # Arguments
-	/// * `chain_id` - The chain ID to get the oracle address for
-	///
-	/// # Returns
-	/// * `Some(Address)` if an oracle is configured for this chain and the address is valid
-	/// * `None` if no oracle is configured or the address format is invalid
-	fn get_oracle_address(&self, chain_id: u64) -> Option<solver_types::Address> {
-		self.oracle_addresses.get(&chain_id).and_then(|addr_str| {
-			let hex_str = without_0x_prefix(addr_str);
-			hex::decode(hex_str)
-				.ok()
-				.filter(|bytes| bytes.len() == 20)
-				.map(solver_types::Address)
-		})
-	}
-
 	/// Gets attestation data for a filled order and generates a fill proof.
 	///
 	/// Since the transaction is already confirmed by the delivery service,
@@ -233,13 +174,25 @@ impl SettlementInterface for DirectSettlement {
 			))
 		})?;
 
-		// Get the oracle address for this chain
-		let oracle_address = self.oracle_addresses.get(&origin_chain_id).ok_or_else(|| {
-			SettlementError::ValidationFailed(format!(
-				"No oracle address configured for chain {}",
+		// Get the oracle address for this chain using the selection strategy
+		let oracle_addresses = self.get_input_oracles(origin_chain_id);
+		if oracle_addresses.is_empty() {
+			return Err(SettlementError::ValidationFailed(format!(
+				"No input oracle configured for chain {}",
 				origin_chain_id
-			))
-		})?;
+			)));
+		}
+
+		// Use selection strategy with order nonce as context for deterministic selection
+		let selection_context = order_data.nonce.to::<u64>();
+		let oracle_address = self
+			.select_oracle(&oracle_addresses, Some(selection_context))
+			.ok_or_else(|| {
+				SettlementError::ValidationFailed(format!(
+					"Failed to select oracle for chain {}",
+					origin_chain_id
+				))
+			})?;
 
 		// Convert tx hash
 		let hash = FixedBytes::<32>::from_slice(&tx_hash.0);
@@ -283,7 +236,7 @@ impl SettlementInterface for DirectSettlement {
 		Ok(FillProof {
 			tx_hash: tx_hash.clone(),
 			block_number: tx_block,
-			oracle_address: oracle_address.clone(),
+			oracle_address: with_0x_prefix(&hex::encode(&oracle_address.0)),
 			attestation_data: Some(order_data.order_id.to_vec()),
 			filled_timestamp: block_timestamp,
 		})
@@ -361,51 +314,8 @@ pub fn create_settlement(
 	DirectSettlementSchema::validate_config(config)
 		.map_err(|e| SettlementError::ValidationFailed(format!("Invalid configuration: {}", e)))?;
 
-	// Get order type
-	let order_standard = config
-		.get("order")
-		.and_then(|v| v.as_str())
-		.ok_or_else(|| SettlementError::ValidationFailed("order is required".to_string()))?
-		.to_string();
-
-	// Get network IDs
-	let network_ids = config
-		.get("network_ids")
-		.and_then(|v| v.as_array())
-		.ok_or_else(|| SettlementError::ValidationFailed("network_ids is required".to_string()))?
-		.iter()
-		.filter_map(|v| v.as_integer().map(|i| i as u64))
-		.collect::<Vec<_>>();
-
-	if network_ids.is_empty() {
-		return Err(SettlementError::ValidationFailed(
-			"network_ids cannot be empty".to_string(),
-		));
-	}
-
-	// Get oracle addresses table
-	let addresses_table = config
-		.get("oracle_addresses")
-		.and_then(|v| v.as_table())
-		.ok_or_else(|| {
-			SettlementError::ValidationFailed("oracle_addresses is required".to_string())
-		})?;
-
-	// Build oracle addresses map
-	let mut oracle_addresses = HashMap::new();
-	for network_id in &network_ids {
-		let network_id_str = network_id.to_string();
-		let address = addresses_table
-			.get(&network_id_str)
-			.and_then(|v| v.as_str())
-			.ok_or_else(|| {
-				SettlementError::ValidationFailed(format!(
-					"oracle_addresses missing entry for network {}",
-					network_id
-				))
-			})?;
-		oracle_addresses.insert(*network_id, address.to_string());
-	}
+	// Parse oracle configuration using common utilities
+	let oracle_config = parse_oracle_config(config)?;
 
 	let dispute_period_seconds = config
 		.get("dispute_period_seconds")
@@ -415,14 +325,7 @@ pub fn create_settlement(
 	// Create settlement service synchronously
 	let settlement = tokio::task::block_in_place(|| {
 		tokio::runtime::Handle::current().block_on(async {
-			DirectSettlement::new(
-				order_standard,
-				network_ids,
-				networks,
-				oracle_addresses,
-				dispute_period_seconds,
-			)
-			.await
+			DirectSettlement::new(networks, oracle_config, dispute_period_seconds).await
 		})
 	})?;