start on refactoring validator to support multi-validators in blueprint

crates/aiken-project/src/blueprint/mod.rs

@@ -60,7 +60,7 @@ impl Blueprint<Reference, Annotated<Schema>> {
 
         let validators: Result<Vec<_>, Error> = modules
             .validators()
-            .map(|(validator, def)| {
+            .flat_map(|(validator, def)| {
                 Validator::from_checked_module(modules, generator, validator, def).map(
                     |mut schema| {
                         definitions.merge(&mut schema.definitions);

crates/aiken-project/src/blueprint/validator.rs

@@ -4,10 +4,13 @@ use super::{
     schema::{Annotated, Schema},
 };
 use crate::module::{CheckedModule, CheckedModules};
-use aiken_lang::{ast::TypedValidator, uplc::CodeGenerator};
+use aiken_lang::{
+    ast::{TypedArg, TypedFunction, TypedValidator},
+    uplc::CodeGenerator,
+};
 use miette::NamedSource;
 use serde;
-use uplc::ast::{DeBruijn, Program, Term};
+use uplc::ast::{DeBruijn, Name, Program, Term};
 
 #[derive(Debug, PartialEq, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Validator<R, S> {
@@ -47,19 +50,39 @@ impl Validator<Reference, Annotated<Schema>> {
         generator: &mut CodeGenerator,
         module: &CheckedModule,
         def: &TypedValidator,
-    ) -> Result<Validator<Reference, Annotated<Schema>>, Error> {
+    ) -> Vec<Result<Validator<Reference, Annotated<Schema>>, Error>> {
-        let mut args = def.fun.arguments.iter().rev();
+        let program: Program<Name> = generator.generate(def).try_into().unwrap();
-        let (_, redeemer, datum) = (args.next(), args.next().unwrap(), args.next());
-
-        let mut arguments = Vec::with_capacity(def.params.len() + def.fun.arguments.len());
-
-        arguments.extend(def.params.clone());
-        arguments.extend(def.fun.arguments.clone());
 
         let mut definitions = Definitions::new();
 
+        let mut validators = vec![Validator::create_validator_blueprint(
+            modules, def.params, def.fun,
+        )];
+
+        if let Some(other_func) = def.other_fun {
+            todo!()
+        } else {
+            todo!()
+        }
+
+        validators
+    }
+
+    fn create_validator_blueprint(
+        modules: &CheckedModules,
+        params: Vec<TypedArg>,
+        func: TypedFunction,
+    ) -> Result<Validator<Reference, Annotated<Schema>>, Error> {
+        let mut args = func.arguments.iter().rev();
+        let (_, redeemer, datum) = (args.next(), args.next().unwrap(), args.next());
+
+        let mut arguments = Vec::with_capacity(params.len() + func.arguments.len());
+
+        arguments.extend(params.clone());
+        arguments.extend(func.arguments.clone());
+
         Ok(Validator {
-            title: format!("{}.{}", &module.name, &def.fun.name),
+            title: format!("{}.{}", &module.name, &func.name),
             description: None,
             parameters: def
                 .params