Blueprint imports with friendly aiken compiler

Cargo.toml

@@ -1,10 +1,13 @@
 [workspace]
 resolver = "2"
-members = ["bin/tx3c",
-    "crates/tx3-cardano",
-    "crates/tx3-lang",
-    "crates/tx3-resolver",
-    "crates/tx3-tir",
+
+members = [
+  "bin/tx3c",
+  "crates/tx3-cardano",
+  "crates/tx3-lang",
+  "crates/tx3-resolver",
+  "crates/tx3-tir",
+  "crates/cip-57",
 ]
 
 [workspace.package]

crates/cip-57/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "cip-57"
+description = "CIP-57 compatibility (JSON parsing and serialization)"
+publish.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+version.workspace = true
+keywords.workspace = true
+documentation.workspace = true
+homepage.workspace = true
+readme.workspace = true
+
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1.0.137"

crates/cip-57/src/lib.rs

@@ -0,0 +1,186 @@
+//! This module defines the structures for a Blueprint, including its preamble, validators, and definitions.
+
+use serde::{Deserialize, Serialize};
+use serde_json::Number;
+use std::collections::BTreeMap;
+/// Represents a blueprint containing preamble, validators, and optional definitions.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Blueprint {
+    pub preamble: Preamble,
+    pub validators: Vec<Validator>,
+    pub definitions: Option<Definitions>,
+}
+
+/// Represents the preamble of a blueprint, including metadata such as title, description, version, and compiler information.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Preamble {
+    pub title: String,
+    pub description: Option<String>,
+    pub version: String,
+    pub plutus_version: String,
+    pub compiler: Option<Compiler>,
+    pub license: Option<String>,
+}
+
+/// Represents the compiler information in the preamble.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Compiler {
+    pub name: String,
+    pub version: Option<String>,
+}
+
+/// Represents a validator in the blueprint, including its title, description, compiled code, hash, datum, redeemer, and parameters.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Validator {
+    pub title: String,
+    pub description: Option<String>,
+    pub compiled_code: Option<String>,
+    pub hash: Option<String>,
+    pub datum: Option<Argument>,
+    pub redeemer: Option<Argument>,
+    pub parameters: Option<Vec<Parameter>>,
+}
+
+/// Represents an argument in a validator, including its title, description, purpose, and schema reference.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Argument {
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub purpose: Option<PurposeArray>,
+    pub schema: Reference,
+}
+
+/// Represents a purpose which can be either a single purpose or an object with oneOf.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(untagged)]
+pub enum PurposeArray {
+    Single(Purpose),
+    OneOf(PurposeOneOf),
+}
+
+/// Represents a purpose object with a oneOf field containing an array of purposes.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct PurposeOneOf {
+    pub one_of: Vec<Purpose>,
+}
+
+/// Represents the purpose of an argument, which can be spend, mint, withdraw, or publish.
+#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum Purpose {
+    Spend,
+    Mint,
+    Withdraw,
+    Publish,
+}
+
+/// Represents a reference to a schema.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Reference {
+    #[serde(rename = "$ref")]
+    pub reference: Option<String>,
+}
+
+/// Represents a parameter in a validator, including its title, description, purpose, and schema reference.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Parameter {
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub purpose: Option<PurposeArray>,
+    pub schema: Reference,
+}
+
+/// Represents the definitions in a blueprint, which is a map of definition names to their corresponding definitions.
+#[derive(Debug, Default, Deserialize, Serialize, Clone)]
+pub struct Definitions {
+    #[serde(flatten, default)]
+    pub inner: BTreeMap<String, Definition>,
+}
+
+/// Represents a definition in the blueprint, including its title, description, data type, any_of schemas, items, keys, and values.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Definition {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data_type: Option<DataType>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub any_of: Option<Vec<Schema>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub items: Option<ReferencesArray>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keys: Option<Reference>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub values: Option<Reference>,
+}
+
+/// Represents an array of references which can be either a single reference or an array of references.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(untagged)]
+pub enum ReferencesArray {
+    Single(Reference),
+    Array(Vec<Reference>),
+}
+
+/// Represents a schema in a definition, including its title, description, data type, index, and fields.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Schema {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub data_type: DataType,
+    pub index: Number,
+    pub fields: Vec<Field>,
+}
+
+/// Represents the data type of a schema, which can be integer, bytes, list, map, or constructor.
+#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum DataType {
+    Integer,
+    Bytes,
+    List,
+    Map,
+    Constructor,
+}
+
+/// Represents a field in a schema, including its title and reference.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Field {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(rename = "$ref")]
+    pub reference: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::path::PathBuf;
+
+    #[test]
+    fn deserialize_plutus_json_into_blueprint() {
+        let manifest = env!("CARGO_MANIFEST_DIR");
+        let path = PathBuf::from(manifest).join("examples").join("plutus.json");
+
+        let failure_msg = format!("failed to read example file: {}", path.display());
+        let json = fs::read_to_string(&path).expect(&failure_msg);
+
+        let bp: Blueprint = serde_json::from_str(&json).expect("failed to deserialize blueprint");
+
+        assert!(
+            !bp.preamble.title.is_empty(),
+            "preamble.title should not be empty"
+        );
+        assert!(!bp.validators.is_empty(), "expected at least one validator");
+    }
+}

crates/tx3-lang/Cargo.toml

@@ -19,6 +19,8 @@ hex = { workspace = true }
 serde = { workspace = true }
 
 tx3-tir = { version = "0.15.1", path = "../tx3-tir" }
+cip-57 = { path = "../cip-57" }
+serde_json = "1.0.137"
 
 miette = { version = "7.4.0", features = ["fancy"] }
 pest = { version = "2.7.15", features = ["miette-error", "pretty-print"] }

crates/tx3-lang/src/analyzing.rs

@@ -645,6 +645,15 @@ impl Analyzable for StructConstructor {
             _ => unreachable!(),
         };
 
+        if type_def.cases.len() == 1 {
+            let only_case_name = type_def.cases[0].name.value.clone();
+            let requested_case = self.case.name.value.clone();
+
+            if requested_case == "Default" || requested_case == self.r#type.value {
+                self.case.name.value = only_case_name;
+            }
+        }
+
         for case in type_def.cases.iter() {
             scope.track_variant_case(case);
         }

crates/tx3-lang/src/ast.rs

@@ -173,6 +173,8 @@ impl AsRef<str> for Identifier {
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 pub struct Program {
+    #[serde(default)]
+    pub imports: Vec<ImportDef>,
     pub env: Option<EnvDef>,
     pub txs: Vec<TxDef>,
     pub types: Vec<TypeDef>,
@@ -187,6 +189,13 @@ pub struct Program {
     pub(crate) scope: Option<Rc<Scope>>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ImportDef {
+    pub path: StringLiteral,
+    pub alias: Option<Identifier>,
+    pub span: Span,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct EnvField {
     pub name: String,
@@ -934,6 +943,28 @@ impl TypeDef {
     pub(crate) fn find_case(&self, case: &str) -> Option<&VariantCase> {
         self.cases.iter().find(|x| x.name.value == case)
     }
+
+    pub fn to_tx3_source(&self) -> String {
+        let name = &self.name.value;
+        // Implicit cases don't have an explicit constructor on its usage
+        if self.cases.len() == 1 && self.cases[0].name.value == "Default" {
+            let fields = &self.cases[0].fields;
+            let fields_str = fields
+                .iter()
+                .map(|f| format!("{}: {}", f.name.value, f.r#type))
+                .collect::<Vec<_>>()
+                .join(", ");
+            format!("type {} {{ {} }}", name, fields_str)
+        } else {
+            let cases_str = self
+                .cases
+                .iter()
+                .map(VariantCase::to_tx3_source)
+                .collect::<Vec<_>>()
+                .join(", ");
+            format!("type {} {{ {} }}", name, cases_str)
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
@@ -953,6 +984,59 @@ impl VariantCase {
     pub(crate) fn find_field(&self, field: &str) -> Option<&RecordField> {
         self.fields.iter().find(|x| x.name.value == field)
     }
+
+    fn to_tx3_source(&self) -> String {
+        let name = &self.name.value;
+        if self.fields.is_empty() {
+            name.clone()
+        } else {
+            let fields_str = self
+                .fields
+                .iter()
+                .map(|f| format!("{}: {}", f.name.value, f.r#type))
+                .collect::<Vec<_>>()
+                .join(", ");
+            format!("{} {{ {} }}", name, fields_str)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn to_tx3_source_omits_braces_for_empty_default_case() {
+        let type_def = TypeDef {
+            name: Identifier::new("Data"),
+            cases: vec![VariantCase {
+                name: Identifier::new("Default"),
+                fields: vec![],
+                span: Span::DUMMY,
+            }],
+            span: Span::DUMMY,
+        };
+
+        assert_eq!(type_def.to_tx3_source(), "type Data");
+    }
+
+    #[test]
+    fn to_tx3_source_keeps_braces_for_default_with_fields() {
+        let type_def = TypeDef {
+            name: Identifier::new("OutputReference"),
+            cases: vec![VariantCase {
+                name: Identifier::new("Default"),
+                fields: vec![RecordField::new("transaction_id", Type::Bytes)],
+                span: Span::DUMMY,
+            }],
+            span: Span::DUMMY,
+        };
+
+        assert_eq!(
+            type_def.to_tx3_source(),
+            "type OutputReference { transaction_id: Bytes }"
+        );
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]

crates/tx3-lang/src/cardano.rs

@@ -845,10 +845,7 @@ impl IntoLower for CardanoBlock {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        analyzing::analyze,
-        ast::{self, *},
-    };
+    use crate::{analyzing::analyze, ast::*};
     use pest::Parser;
 
     macro_rules! input_to_ast_check {