Feat/party serialization into datum

crates/tx3-cardano/src/compile/mod.rs

@@ -73,20 +73,7 @@ fn compile_struct(ir: &ir::StructExpr) -> Result<primitives::PlutusData, Error>
 }
 
 fn compile_data_expr(ir: &ir::Expression) -> Result<primitives::PlutusData, Error> {
-    match ir {
-        ir::Expression::Bytes(x) => Ok(x.as_data()),
-        ir::Expression::Number(x) => Ok(x.as_data()),
-        ir::Expression::Bool(x) => Ok(x.as_data()),
-        ir::Expression::String(x) => Ok(x.as_str().as_data()),
-        ir::Expression::Struct(x) => compile_struct(x),
-        ir::Expression::Map(x) => x.try_as_data(),
-        ir::Expression::Address(x) => Ok(x.as_data()),
-        ir::Expression::List(x) => x.try_as_data(),
-        _ => Err(Error::CoerceError(
-            format!("{ir:?}"),
-            "DataExpr".to_string(),
-        )),
-    }
+    ir.try_as_data()
 }
 
 fn compile_native_asset_for_output(

crates/tx3-cardano/src/compile/plutus_data.rs

@@ -2,6 +2,8 @@ pub use pallas::codec::utils::Int;
 use pallas::codec::utils::KeyValuePairs;
 pub use pallas::ledger::primitives::{BigInt, BoundedBytes, Constr, MaybeIndefArray, PlutusData};
 use tx3_lang::ir;
+use std::collections::HashMap;
+
 
 pub trait IntoData {
     fn as_data(&self) -> PlutusData;
@@ -148,10 +150,27 @@ impl TryIntoData for ir::Expression {
             ir::Expression::Hash(x) => Ok(x.as_data()),
             ir::Expression::List(x) => x.try_as_data(),
             ir::Expression::Map(x) => x.try_as_data(),
-            x => Err(super::Error::CoerceError(
-                format!("{x:?}"),
+            ir::Expression::AdHocDirective(x) => match x.name.as_str() {
+                "cardano_payment_part" => Ok(extract_address_part(&x.data, 1..29)),
+                "cardano_staking_part" => Ok(extract_address_part(&x.data, 29..)),
+                _ => Ok(().as_data()),
+            },
+            _ => Err(super::Error::CoerceError(
+                format!("{self:?}"),
                 "PlutusData".to_string(),
             )),
         }
     }
 }
+
+fn extract_address_part<R>(data: &HashMap<String, ir::Expression>, range: R) -> PlutusData
+where
+    R: std::slice::SliceIndex<[u8], Output = [u8]>,
+{
+    data.get("address")
+        .and_then(|expr| match expr {
+            ir::Expression::Address(bytes) => bytes.get(range).map(|part| part.as_data()),
+            _ => None,
+        })
+        .unwrap_or_else(|| ().as_data())
+}

crates/tx3-lang/src/analyzing.rs

@@ -601,6 +601,7 @@ impl Analyzable for DataExpr {
             DataExpr::AnyAssetConstructor(x) => x.analyze(parent),
             DataExpr::MinUtxo(x) => x.analyze(parent),
             DataExpr::ConcatOp(x) => x.analyze(parent),
+            DataExpr::CardanoFunctions(x) => x.analyze(parent),
             _ => AnalyzeReport::default(),
         }
     }
@@ -619,6 +620,7 @@ impl Analyzable for DataExpr {
             DataExpr::AnyAssetConstructor(x) => x.is_resolved(),
             DataExpr::MinUtxo(x) => x.is_resolved(),
             DataExpr::ConcatOp(x) => x.is_resolved(),
+            DataExpr::CardanoFunctions(x) => x.is_resolved(),
             _ => true,
         }
     }

crates/tx3-lang/src/ast.rs

@@ -740,6 +740,7 @@ pub enum DataExpr {
     NegateOp(NegateOp),
     PropertyOp(PropertyOp),
     UtxoRef(UtxoRef),
+    CardanoFunctions(crate::cardano::CardanoFunctions),
 }
 
 impl DataExpr {
@@ -775,6 +776,7 @@ impl DataExpr {
             DataExpr::UtxoRef(_) => Some(Type::UtxoRef),
             DataExpr::MinUtxo(_) => Some(Type::AnyAsset),
             DataExpr::ComputeTipSlot => Some(Type::Int),
+            DataExpr::CardanoFunctions(_) => Some(Type::Bytes), // Payment/staking parts return bytes
         }
     }
 }

crates/tx3-lang/src/cardano.rs

@@ -724,6 +724,24 @@ impl IntoLower for CardanoPublishBlock {
     }
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct CardanoPaymentPart {
+    pub address: Box<DataExpr>,
+    pub span: Span,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct CardanoStakingPart {
+    pub address: Box<DataExpr>,
+    pub span: Span,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum CardanoFunctions {
+    PaymentPart(CardanoPaymentPart),
+    StakingPart(CardanoStakingPart),
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub enum CardanoBlock {
     VoteDelegationCertificate(VoteDelegationCertificate),
@@ -735,6 +753,38 @@ pub enum CardanoBlock {
     Publish(CardanoPublishBlock),
 }
 
+impl AstNode for CardanoPaymentPart {
+    const RULE: Rule = Rule::cardano_payment_part;
+
+    fn parse(pair: Pair<Rule>) -> Result<Self, Error> {
+        let span = pair.as_span().into();
+        let mut inner = pair.into_inner();
+        let address = DataExpr::parse(inner.next().unwrap())?.into();
+
+        Ok(CardanoPaymentPart { address, span })
+    }
+
+    fn span(&self) -> &Span {
+        &self.span
+    }
+}
+
+impl AstNode for CardanoStakingPart {
+    const RULE: Rule = Rule::cardano_staking_part;
+
+    fn parse(pair: Pair<Rule>) -> Result<Self, Error> {
+        let span = pair.as_span().into();
+        let mut inner = pair.into_inner();
+        let address = DataExpr::parse(inner.next().unwrap())?.into();
+
+        Ok(CardanoStakingPart { address, span })
+    }
+
+    fn span(&self) -> &Span {
+        &self.span
+    }
+}
+
 impl AstNode for CardanoBlock {
     const RULE: Rule = Rule::cardano_block;
 
@@ -781,6 +831,26 @@ impl AstNode for CardanoBlock {
     }
 }
 
+impl Analyzable for CardanoPaymentPart {
+    fn analyze(&mut self, parent: Option<Rc<Scope>>) -> AnalyzeReport {
+        self.address.analyze(parent)
+    }
+
+    fn is_resolved(&self) -> bool {
+        self.address.is_resolved()
+    }
+}
+
+impl Analyzable for CardanoStakingPart {
+    fn analyze(&mut self, parent: Option<Rc<Scope>>) -> AnalyzeReport {
+        self.address.analyze(parent)
+    }
+
+    fn is_resolved(&self) -> bool {
+        self.address.is_resolved()
+    }
+}
+
 impl Analyzable for CardanoBlock {
     fn analyze(&mut self, parent: Option<Rc<Scope>>) -> AnalyzeReport {
         match self {
@@ -807,6 +877,96 @@ impl Analyzable for CardanoBlock {
     }
 }
 
+impl IntoLower for CardanoPaymentPart {
+    type Output = ir::AdHocDirective;
+
+    fn into_lower(
+        &self,
+        ctx: &crate::lowering::Context,
+    ) -> Result<Self::Output, crate::lowering::Error> {
+        let address_expr = self.address.into_lower(ctx)?;
+        let mut data = std::collections::HashMap::new();
+        data.insert("address".to_string(), address_expr);
+        Ok(ir::AdHocDirective {
+            name: "cardano_payment_part".to_string(),
+            data,
+        })
+    }
+}
+
+impl IntoLower for CardanoStakingPart {
+    type Output = ir::AdHocDirective;
+
+    fn into_lower(
+        &self,
+        ctx: &crate::lowering::Context,
+    ) -> Result<Self::Output, crate::lowering::Error> {
+        let address_expr = self.address.into_lower(ctx)?;
+        let mut data = std::collections::HashMap::new();
+        data.insert("address".to_string(), address_expr);
+        Ok(ir::AdHocDirective {
+            name: "cardano_staking_part".to_string(),
+            data,
+        })
+    }
+}
+
+impl AstNode for CardanoFunctions {
+    const RULE: Rule = Rule::cardano_functions;
+
+    fn parse(pair: Pair<Rule>) -> Result<Self, Error> {
+        let mut inner = pair.into_inner();
+        let function_pair = inner.next().unwrap();
+
+        match function_pair.as_rule() {
+            Rule::cardano_payment_part => {
+                Ok(CardanoFunctions::PaymentPart(CardanoPaymentPart::parse(function_pair)?))
+            }
+            Rule::cardano_staking_part => {
+                Ok(CardanoFunctions::StakingPart(CardanoStakingPart::parse(function_pair)?))
+            }
+            x => unreachable!("Unexpected rule in cardano_functions: {:?}", x),
+        }
+    }
+
+    fn span(&self) -> &Span {
+        match self {
+            CardanoFunctions::PaymentPart(x) => x.span(),
+            CardanoFunctions::StakingPart(x) => x.span(),
+        }
+    }
+}
+
+impl Analyzable for CardanoFunctions {
+    fn analyze(&mut self, parent: Option<Rc<Scope>>) -> AnalyzeReport {
+        match self {
+            CardanoFunctions::PaymentPart(x) => x.analyze(parent),
+            CardanoFunctions::StakingPart(x) => x.analyze(parent),
+        }
+    }
+
+    fn is_resolved(&self) -> bool {
+        match self {
+            CardanoFunctions::PaymentPart(x) => x.is_resolved(),
+            CardanoFunctions::StakingPart(x) => x.is_resolved(),
+        }
+    }
+}
+
+impl IntoLower for CardanoFunctions {
+    type Output = ir::AdHocDirective;
+
+    fn into_lower(
+        &self,
+        ctx: &crate::lowering::Context,
+    ) -> Result<Self::Output, crate::lowering::Error> {
+        match self {
+            CardanoFunctions::PaymentPart(x) => x.into_lower(ctx),
+            CardanoFunctions::StakingPart(x) => x.into_lower(ctx),
+        }
+    }
+}
+
 impl IntoLower for CardanoBlock {
     type Output = ir::AdHocDirective;
 

crates/tx3-lang/src/lowering.rs

@@ -472,6 +472,7 @@ impl IntoLower for ast::DataExpr {
             ast::DataExpr::ComputeTipSlot => {
                 ir::Expression::EvalCompiler(Box::new(ir::CompilerOp::ComputeTipSlot))
             }
+            ast::DataExpr::CardanoFunctions(x) => ir::Expression::AdHocDirective(Box::new(x.into_lower(ctx)?)),
         };
 
         Ok(out)
@@ -935,4 +936,6 @@ mod tests {
     test_lowering!(donation);
 
     test_lowering!(list_concat);
+
+    test_lowering!(party_serialization);
 }

crates/tx3-lang/src/parsing.rs

@@ -14,7 +14,7 @@ use pest_derive::Parser;
 
 use crate::{
     ast::*,
-    cardano::{PlutusWitnessBlock, PlutusWitnessField},
+    cardano::{CardanoFunctions, PlutusWitnessBlock, PlutusWitnessField},
 };
 #[derive(Parser)]
 #[grammar = "tx3.pest"]
@@ -1227,6 +1227,7 @@ impl AstNode for DataExpr {
                 Rule::concat_constructor => DataExpr::concat_constructor_parse(x),
                 Rule::min_utxo => DataExpr::min_utxo_parse(x),
                 Rule::tip_slot => DataExpr::tip_slot_parse(x),
+                Rule::cardano_functions => Ok(DataExpr::CardanoFunctions(CardanoFunctions::parse(x)?)),
                 Rule::data_expr => DataExpr::parse(x),
                 x => unreachable!("unexpected rule as data primary: {:?}", x),
             })
@@ -1268,7 +1269,8 @@ impl AstNode for DataExpr {
             DataExpr::PropertyOp(x) => &x.span,
             DataExpr::UtxoRef(x) => x.span(),
             DataExpr::MinUtxo(x) => x.span(),
-            DataExpr::ComputeTipSlot => &Span::DUMMY, // TODO
+            DataExpr::ComputeTipSlot => &Span::DUMMY,
+            DataExpr::CardanoFunctions(x) => x.span(),
         }
     }
 }
@@ -2656,4 +2658,6 @@ mod tests {
     test_parsing!(donation);
 
     test_parsing!(list_concat);
+
+    test_parsing!(party_serialization);
 }

crates/tx3-lang/src/tx3.pest

@@ -152,6 +152,7 @@ data_expr = { data_prefix* ~ data_primary ~ data_postfix* ~ (data_infix ~ data_p
         string |
         min_utxo |
         tip_slot |
+        cardano_functions |
         struct_constructor |
         list_constructor |
         map_constructor |
@@ -390,6 +391,17 @@ cardano_publish_block = {
     "}"
 }
 
+cardano_payment_part = { "payment_part" ~ "(" ~ data_expr ~ ")" }
+cardano_staking_part = { "staking_part" ~ "(" ~ data_expr ~ ")" }
+
+cardano_functions = {
+    "cardano" ~ "::" ~ (
+        cardano_payment_part |
+        cardano_staking_part
+    )
+}
+
+
 cardano_block = {
     "cardano" ~ "::" ~ (
         cardano_stake_delegation_certificate |

examples/cardano_witness.mint_from_plutus.tir

@@ -201,9 +201,6 @@
     {
       "name": "plutus_witness",
       "data": {
-        "version": {
-          "Number": 3
-        },
         "script": {
           "Bytes": [
             81,
@@ -225,6 +222,9 @@
             174,
             105
           ]
+        },
+        "version": {
+          "Number": 3
         }
       }
     }