feat(euclid): default fallback for transactions

src/euclid/ast.rs

@@ -148,6 +148,7 @@ pub enum RoutingType {
     Priority,
     VolumeSplit,
     VolumeSplitPriority,
+    DefaultFallback,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -164,6 +165,7 @@ pub enum Output {
     Priority(Vec<ConnectorInfo>),
     VolumeSplit(Vec<VolumeSplit<ConnectorInfo>>),
     VolumeSplitPriority(Vec<VolumeSplit<Vec<ConnectorInfo>>>),
+    DefaultFallback(Vec<ConnectorInfo>),
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]

src/euclid/handlers/routing_rules.rs

@@ -518,7 +518,7 @@ pub async fn routing_evaluate(
                         StaticRoutingAlgorithm::Single(conn.clone()).to_string()
                     ))
                 }) {
-                    Ok((_, eval)) => (out_enum, eval, Some("straight_through_rule".into())),
+                    Ok((_, eval)) => (out_enum, eval, Some("straight_through".into())),
                     Err(e) => {
                         API_REQUEST_COUNTER
                             .with_label_values(&["routing_evaluate", "failure"])
@@ -537,7 +537,7 @@ pub async fn routing_evaluate(
                         StaticRoutingAlgorithm::Priority(connectors.clone()).to_string()
                     ))
                 }) {
-                    Ok((_, eval)) => (out_enum, eval, Some("priority_rule".into())),
+                    Ok((_, eval)) => (out_enum, eval, Some("priority".into())),
                     Err(e) => {
                         API_REQUEST_COUNTER
                             .with_label_values(&["routing_evaluate", "failure"])
@@ -556,7 +556,7 @@ pub async fn routing_evaluate(
                         StaticRoutingAlgorithm::VolumeSplit(splits.clone()).to_string()
                     ))
                 }) {
-                    Ok((_, eval)) => (out_enum, eval, Some("volume_split_rule".into())),
+                    Ok((_, eval)) => (out_enum, eval, Some("volume_split".into())),
                     Err(e) => {
                         API_REQUEST_COUNTER
                             .with_label_values(&["routing_evaluate", "failure"])
@@ -584,6 +584,25 @@ pub async fn routing_evaluate(
                     }
                 }
             }
+
+            StaticRoutingAlgorithm::DefaultFallback(connectors) => {
+                let out_enum = Output::DefaultFallback(connectors.clone());
+                match evaluate_output(&out_enum).map_err(|_| {
+                    EuclidErrors::FailedToEvaluateOutput(format!(
+                        "{}",
+                        StaticRoutingAlgorithm::DefaultFallback(connectors.clone()).to_string()
+                    ))
+                }) {
+                    Ok((_, eval)) => (out_enum, eval, Some("default_fallback".into())),
+                    Err(e) => {
+                        API_REQUEST_COUNTER
+                            .with_label_values(&["routing_evaluate", "failure"])
+                            .inc();
+                        timer.observe_duration();
+                        return Err(e.into());
+                    }
+                }
+            }
         };
 
     let eligible_connectors = if let Some(ref cfg) = state.config.routing_config {
@@ -626,6 +645,12 @@ fn format_output(output: &Output) -> Value {
                 "connectors": connectors
             })
         }
+        Output::DefaultFallback(connectors) => {
+            json!({
+                "type": "default_fallback",
+                "connectors": connectors
+            })
+        }
         Output::VolumeSplit(splits) => {
             let formatted_splits: Vec<Value> = splits
                 .iter()

src/euclid/interpreter.rs

@@ -248,6 +248,7 @@ pub fn evaluate_output(output: &Output) -> RoutingResult<(Vec<ConnectorInfo>, Ve
                 vec![first_connector.unwrap_or_default()],
             ))
         }
+        Output::DefaultFallback(connectors) => Ok((connectors.clone(), connectors.to_vec())),
         Output::VolumeSplit(splits) => {
             let selected_connector = perform_volume_split(splits.clone())?;
             Ok((vec![selected_connector.clone()], vec![selected_connector]))

src/euclid/types.rs

@@ -47,6 +47,7 @@ pub enum StaticRoutingAlgorithm {
     Priority(Vec<ConnectorInfo>),
     VolumeSplit(Vec<super::ast::VolumeSplit<ConnectorInfo>>),
     Advanced(Program),
+    DefaultFallback(Vec<ConnectorInfo>),
 }
 
 #[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize, strum::Display)]

src/euclid/utils.rs

@@ -74,6 +74,7 @@ pub fn validate_routing_rule(
     match &rule.algorithm {
         StaticRoutingAlgorithm::Single(_)
         | StaticRoutingAlgorithm::Priority(_)
+        | StaticRoutingAlgorithm::DefaultFallback(_)
         | StaticRoutingAlgorithm::VolumeSplit(_) => return Ok(()),
         StaticRoutingAlgorithm::Advanced(program) => {
             let mut errors = Vec::new();