fix: Complete oracle refactor and fix config parsing

Author: shahnami

config/demo.toml

@@ -82,8 +82,21 @@ address = "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0"
 [settlement.implementations.direct]
 order = "eip7683"
 network_ids = [31337, 31338]
-oracle_addresses = { 31337 = "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9", 31338 = "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9" }
 dispute_period_seconds = 1
+# Oracle selection strategy when multiple oracles are available (First, RoundRobin, Random)
+oracle_selection_strategy = "First"
+
+# Oracle configuration with multiple oracle support
+[settlement.implementations.direct.oracles]
+# Input oracles (on origin chains)
+input = { 31337 = ["0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"], 31338 = ["0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"] }
+# Output oracles (on destination chains)
+output = { 31337 = ["0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"], 31338 = ["0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"] }
+
+# Valid routes: from origin chain -> to destination chains
+[settlement.implementations.direct.routes]
+31337 = [31338]  # Can go from chain 31337 to chain 31338
+31338 = [31337]  # Can go from chain 31338 to chain 31337
 
 
 # ============================================================================

config/example.toml

@@ -122,8 +122,21 @@ address = "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0"
 [settlement.implementations.direct]
 order = "eip7683"
 network_ids = [31337, 31338]
-oracle_addresses = { 31337 = "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9", 31338 = "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9" }
 dispute_period_seconds = 1
+# Oracle selection strategy when multiple oracles are available (First, RoundRobin, Random)
+oracle_selection_strategy = "First"
+
+# Oracle configuration with multiple oracle support
+[settlement.implementations.direct.oracles]
+# Input oracles (on origin chains) - can specify multiple oracles per chain
+input = { 31337 = ["0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"], 31338 = ["0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"] }
+# Output oracles (on destination chains) - can specify multiple oracles per chain
+output = { 31337 = ["0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"], 31338 = ["0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"] }
+
+# Valid routes: from origin chain -> to destination chains
+[settlement.implementations.direct.routes]
+31337 = [31338]  # Can go from chain 31337 to chain 31338
+31338 = [31337]  # Can go from chain 31338 to chain 31337
 
 # ============================================================================
 # API SERVER

crates/solver-core/src/builder/mod.rs

@@ -76,6 +76,7 @@ impl SolverBuilder {
 		OF: Fn(
 			&toml::Value,
 			&solver_types::NetworksConfig,
+			&solver_types::oracle::OracleRoutes,
 		) -> Result<Box<dyn OrderInterface>, OrderError>,
 		SEF: Fn(
 			&toml::Value,
@@ -313,11 +314,50 @@ impl SolverBuilder {
 
 		let discovery = Arc::new(DiscoveryService::new(discovery_implementations));
 
-		// Create order implementations
+		// Create settlement implementations first (needed for oracle routes)
+		let mut settlement_impls = HashMap::new();
+		for (name, config) in &self.config.settlement.implementations {
+			if let Some(factory) = factories.settlement_factories.get(name) {
+				match factory(config, &self.config.networks) {
+					Ok(implementation) => {
+						// Validation already happened in the factory
+						settlement_impls.insert(name.clone(), implementation);
+						tracing::info!(component = "settlement", implementation = %name, "Loaded");
+					},
+					Err(e) => {
+						tracing::error!(
+							component = "settlement",
+							implementation = %name,
+							error = %e,
+							"Failed to create settlement implementation"
+						);
+						return Err(BuilderError::Config(format!(
+							"Failed to create settlement implementation '{}': {}",
+							name, e
+						)));
+					},
+				}
+			}
+		}
+
+		if settlement_impls.is_empty() {
+			tracing::warn!("No settlement implementations available - solver will not be able to monitor and claim settlements");
+		}
+
+		let settlement = Arc::new(SettlementService::new(settlement_impls));
+
+		// Build oracle routes from settlement implementations
+		let oracle_routes = settlement.build_oracle_routes();
+		tracing::info!(
+			oracle_routes = %oracle_routes.supported_routes.len(),
+			"Built oracle routes from settlement implementations"
+		);
+
+		// Create order implementations (now with oracle routes)
 		let mut order_impls = HashMap::new();
 		for (name, config) in &self.config.order.implementations {
 			if let Some(factory) = factories.order_factories.get(name) {
-				match factory(config, &self.config.networks) {
+				match factory(config, &self.config.networks, &oracle_routes) {
 					Ok(implementation) => {
 						// Validation already happened in the factory
 						order_impls.insert(name.clone(), implementation);
@@ -386,38 +426,6 @@ impl SolverBuilder {
 
 		let order = Arc::new(OrderService::new(order_impls, strategy));
 
-		// Create settlement implementations
-		let mut settlement_impls = HashMap::new();
-		for (name, config) in &self.config.settlement.implementations {
-			if let Some(factory) = factories.settlement_factories.get(name) {
-				match factory(config, &self.config.networks) {
-					Ok(implementation) => {
-						// Validation already happened in the factory
-						settlement_impls.insert(name.clone(), implementation);
-						tracing::info!(component = "settlement", implementation = %name, "Loaded");
-					},
-					Err(e) => {
-						tracing::error!(
-							component = "settlement",
-							implementation = %name,
-							error = %e,
-							"Failed to create settlement implementation"
-						);
-						return Err(BuilderError::Config(format!(
-							"Failed to create settlement implementation '{}': {}",
-							name, e
-						)));
-					},
-				}
-			}
-		}
-
-		if settlement_impls.is_empty() {
-			tracing::warn!("No settlement implementations available - solver will not be able to monitor and claim settlements");
-		}
-
-		let settlement = Arc::new(SettlementService::new(settlement_impls));
-
 		// Create and initialize the TokenManager
 		let token_manager = Arc::new(crate::engine::token_manager::TokenManager::new(
 			self.config.networks.clone(),

crates/solver-order/src/implementations/standards/_7683.rs

@@ -9,8 +9,8 @@ use alloy_primitives::{Address as AlloyAddress, FixedBytes, U256};
 use alloy_sol_types::{sol, SolCall, SolValue};
 use async_trait::async_trait;
 use solver_types::{
-	Address, ConfigSchema, Eip7683OrderData, ExecutionParams, FillProof, Intent, NetworksConfig,
-	Order, OrderStatus, Schema, Transaction,
+	oracle::OracleRoutes, Address, ConfigSchema, Eip7683OrderData, ExecutionParams, FillProof,
+	Intent, NetworksConfig, Order, OrderStatus, Schema, Transaction,
 };
 
 // Solidity type definitions for EIP-7683 contract interactions.
@@ -82,9 +82,12 @@ sol! {
 /// # Fields
 ///
 /// * `networks` - Networks configuration containing settler addresses for each chain
+/// * `oracle_routes` - Oracle routes for validation of input/output oracle compatibility
 pub struct Eip7683OrderImpl {
 	/// Networks configuration for dynamic settler address lookups.
 	networks: NetworksConfig,
+	/// Oracle routes for validation of input/output oracle compatibility.
+	oracle_routes: OracleRoutes,
 }
 
 impl Eip7683OrderImpl {
@@ -93,15 +96,19 @@ impl Eip7683OrderImpl {
 	/// # Arguments
 	///
 	/// * `networks` - Networks configuration with settler addresses
-	pub fn new(networks: NetworksConfig) -> Result<Self, OrderError> {
+	/// * `oracle_routes` - Oracle routes for validation
+	pub fn new(networks: NetworksConfig, oracle_routes: OracleRoutes) -> Result<Self, OrderError> {
 		// Validate that networks config has at least 2 networks
 		if networks.len() < 2 {
 			return Err(OrderError::ValidationFailed(
 				"At least 2 networks must be configured".to_string(),
 			));
 		}
 
-		Ok(Self { networks })
+		Ok(Self {
+			networks,
+			oracle_routes,
+		})
 	}
 }
 
@@ -197,8 +204,81 @@ impl OrderInterface for Eip7683OrderImpl {
 			return Err(OrderError::ValidationFailed("Order expired".to_string()));
 		}
 
+		// Validate oracle routes
+		let origin_chain = order_data.origin_chain_id.to::<u64>();
+		let input_oracle = solver_types::utils::parse_address(&order_data.input_oracle)
+			.map_err(|e| OrderError::ValidationFailed(format!("Invalid input oracle: {}", e)))?;
+
+		let input_info = solver_types::oracle::OracleInfo {
+			chain_id: origin_chain,
+			oracle: input_oracle,
+		};
+
+		// Check if the input oracle is supported
+		if !self
+			.oracle_routes
+			.supported_routes
+			.contains_key(&input_info)
+		{
+			return Err(OrderError::ValidationFailed(format!(
+				"Input oracle {} on chain {} is not supported",
+				order_data.input_oracle, origin_chain
+			)));
+		}
+
+		// Get supported output oracles for this input oracle
+		let supported_outputs = self
+			.oracle_routes
+			.supported_routes
+			.get(&input_info)
+			.ok_or_else(|| {
+				OrderError::ValidationFailed(format!(
+					"No routes configured for input oracle {} on chain {}",
+					order_data.input_oracle, origin_chain
+				))
+			})?;
+
+		// Validate each output oracle
+		for output in &order_data.outputs {
+			let dest_chain = output.chain_id.to::<u64>();
+
+			// If output oracle is zero (0x00...), it means use any compatible oracle
+			// Otherwise, validate the specific oracle
+			if output.oracle != [0u8; 32] {
+				// Parse the oracle address from bytes32 (take first 20 bytes)
+				let output_oracle_bytes = &output.oracle[12..32]; // Last 20 bytes for address
+				let output_oracle = Address(output_oracle_bytes.into());
+
+				let output_info = solver_types::oracle::OracleInfo {
+					chain_id: dest_chain,
+					oracle: output_oracle,
+				};
+
+				// Check if this output oracle is in the supported list
+				if !supported_outputs.contains(&output_info) {
+					return Err(OrderError::ValidationFailed(format!(
+						"Output oracle {:?} on chain {} is not compatible with input oracle {} on chain {}",
+						output.oracle, dest_chain, order_data.input_oracle, origin_chain
+					)));
+				}
+			} else {
+				// Zero oracle means any oracle on the destination chain is acceptable
+				// Just verify that there's at least one oracle for this destination
+				let has_route_to_dest = supported_outputs
+					.iter()
+					.any(|info| info.chain_id == dest_chain);
+
+				if !has_route_to_dest {
+					return Err(OrderError::ValidationFailed(format!(
+						"No route available from chain {} to chain {}",
+						origin_chain, dest_chain
+					)));
+				}
+			}
+		}
+
 		// Extract chain IDs
-		let input_chain_ids = vec![order_data.origin_chain_id.to::<u64>()];
+		let input_chain_ids = vec![origin_chain];
 		let output_chain_ids = order_data
 			.outputs
 			.iter()
@@ -623,12 +703,13 @@ impl OrderInterface for Eip7683OrderImpl {
 pub fn create_order_impl(
 	config: &toml::Value,
 	networks: &NetworksConfig,
+	oracle_routes: &solver_types::oracle::OracleRoutes,
 ) -> Result<Box<dyn OrderInterface>, OrderError> {
 	// Validate configuration first
 	Eip7683OrderSchema::validate_config(config)
 		.map_err(|e| OrderError::InvalidOrder(format!("Invalid configuration: {}", e)))?;
 
-	let order_impl = Eip7683OrderImpl::new(networks.clone())?;
+	let order_impl = Eip7683OrderImpl::new(networks.clone(), oracle_routes.clone())?;
 	Ok(Box::new(order_impl))
 }
 

crates/solver-order/src/lib.rs

@@ -145,8 +145,11 @@ pub trait ExecutionStrategy: Send + Sync {
 ///
 /// This is the function signature that all order implementations must provide
 /// to create instances of their order interface.
-pub type OrderFactory =
-	fn(&toml::Value, &NetworksConfig) -> Result<Box<dyn OrderInterface>, OrderError>;
+pub type OrderFactory = fn(
+	&toml::Value,
+	&NetworksConfig,
+	&solver_types::oracle::OracleRoutes,
+) -> Result<Box<dyn OrderInterface>, OrderError>;
 
 /// Type alias for strategy factory functions.
 ///

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

@@ -177,12 +177,17 @@ impl QuoteGenerator {
 		let (settlement, selected_oracle) = self
 			.settlement_service
 			.get_any_settlement_for_chain(chain_id)
-			.ok_or_else(|| QuoteError::InvalidRequest(
-				format!("No settlement available 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, selected_oracle),
+			EscrowKind::Permit2 => {
+				self.generate_permit2_order(request, config, settlement, selected_oracle)
+			},
 			EscrowKind::Erc3009 => self.generate_erc3009_order(request, config),
 		}
 	}

crates/solver-service/src/factory_registry.rs

@@ -26,8 +26,11 @@ pub type DeliveryFactory = fn(
 ) -> Result<Box<dyn DeliveryInterface>, DeliveryError>;
 pub type DiscoveryFactory =
 	fn(&toml::Value, &NetworksConfig) -> Result<Box<dyn DiscoveryInterface>, DiscoveryError>;
-pub type OrderFactory =
-	fn(&toml::Value, &NetworksConfig) -> Result<Box<dyn OrderInterface>, OrderError>;
+pub type OrderFactory = fn(
+	&toml::Value,
+	&NetworksConfig,
+	&solver_types::oracle::OracleRoutes,
+) -> Result<Box<dyn OrderInterface>, OrderError>;
 pub type SettlementFactory =
 	fn(&toml::Value, &NetworksConfig) -> Result<Box<dyn SettlementInterface>, SettlementError>;
 pub type StrategyFactory = fn(&toml::Value) -> Result<Box<dyn ExecutionStrategy>, StrategyError>;

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

@@ -5,10 +5,7 @@
 //! readiness checks using simple transaction receipt verification without
 //! complex attestation mechanisms.
 
-use crate::{
-	utils::parse_oracle_config, OracleConfig, SettlementError,
-	SettlementInterface,
-};
+use crate::{utils::parse_oracle_config, OracleConfig, SettlementError, SettlementInterface};
 use alloy_primitives::{hex, FixedBytes};
 use alloy_provider::{Provider, RootProvider};
 use alloy_rpc_types::BlockTransactionsKind;