Update csl

Author: szg251

plutus-ledger-api/Cargo.lock

@@ -21,7 +21,7 @@ linked-hash-map = "~0.5.6"
 num-traits = "~0.2.17"
 impl_ops = "0.1.1"
 chrono = { version = "0.4.34", optional = true }
-cardano-serialization-lib = "11.5.0"
+cardano-serialization-lib = "12.1.0"
 anyhow = "1.0.86"
 
 [features]

plutus-ledger-api/Cargo.toml

@@ -52,8 +52,8 @@ where
     }
 }
 
-impl FromCSL<csl::utils::BigNum> for BigInt {
-    fn from_csl(value: &csl::utils::BigNum) -> Self {
+impl FromCSL<csl::BigNum> for BigInt {
+    fn from_csl(value: &csl::BigNum) -> Self {
         let x: u64 = From::from(*value);
         BigInt::from(x)
     }
@@ -65,30 +65,18 @@ impl FromCSL<u32> for BigInt {
     }
 }
 
-impl TryFromCSL<csl::utils::BigInt> for BigInt {
-    fn try_from_csl(value: &csl::utils::BigInt) -> Result<Self, TryFromCSLError> {
+impl TryFromCSL<csl::BigInt> for BigInt {
+    fn try_from_csl(value: &csl::BigInt) -> Result<Self, TryFromCSLError> {
         BigInt::from_str(&value.to_str()).map_err(TryFromCSLError::InvalidBigInt)
     }
 }
 
-impl FromCSL<csl::utils::Int> for BigInt {
-    fn from_csl(value: &csl::utils::Int) -> Self {
+impl FromCSL<csl::Int> for BigInt {
+    fn from_csl(value: &csl::Int) -> Self {
         if value.is_positive() {
             BigInt::from_csl(&value.as_positive().unwrap())
         } else {
             BigInt::from_csl(&value.as_negative().unwrap()).neg()
         }
     }
 }
-
-impl FromCSL<csl::NativeScripts> for Vec<csl::NativeScript> {
-    fn from_csl(value: &csl::NativeScripts) -> Self {
-        (0..value.len()).map(|idx| value.get(idx)).collect()
-    }
-}
-
-impl FromCSL<csl::plutus::PlutusScripts> for Vec<csl::plutus::PlutusScript> {
-    fn from_csl(value: &csl::plutus::PlutusScripts) -> Self {
-        (0..value.len()).map(|idx| value.get(idx)).collect()
-    }
-}

plutus-ledger-api/src/csl/csl_to_pla.rs

@@ -5,10 +5,10 @@ use num_traits::sign::Signed;
 #[derive(Debug, thiserror::Error)]
 pub enum TryFromPLAError {
     #[error("{0}")]
-    CSLDeserializeError(csl::error::DeserializeError),
+    CSLDeserializeError(csl::DeserializeError),
 
     #[error("{0}")]
-    CSLJsError(csl::error::JsError),
+    CSLJsError(csl::JsError),
 
     #[error("Unable to cast BigInt {0} into type {1}: value is out of bound")]
     BigIntOutOfRange(BigInt, String),
@@ -48,15 +48,15 @@ where
     }
 }
 
-impl TryFromPLA<u64> for csl::utils::BigNum {
+impl TryFromPLA<u64> for csl::BigNum {
     fn try_from_pla(val: &u64) -> Result<Self, TryFromPLAError> {
         // BigNum(s) are u64 under the hood.
 
-        Ok(csl::utils::BigNum::from(*val))
+        Ok(csl::BigNum::from(*val))
     }
 }
 
-impl TryFromPLA<BigInt> for csl::utils::BigNum {
+impl TryFromPLA<BigInt> for csl::BigNum {
     fn try_from_pla(val: &BigInt) -> Result<Self, TryFromPLAError> {
         // BigNum(s) are u64 under the hood.
         let x: u64 = val
@@ -70,30 +70,30 @@ impl TryFromPLA<BigInt> for csl::utils::BigNum {
     }
 }
 
-impl TryFromPLA<BigInt> for csl::utils::BigInt {
+impl TryFromPLA<BigInt> for csl::BigInt {
     fn try_from_pla(val: &BigInt) -> Result<Self, TryFromPLAError> {
         Ok(val.to_owned().into())
     }
 }
 
-impl TryFromPLA<BigInt> for csl::utils::Int {
+impl TryFromPLA<BigInt> for csl::Int {
     fn try_from_pla(val: &BigInt) -> Result<Self, TryFromPLAError> {
         if val.is_negative() {
-            Ok(csl::utils::Int::new_negative(&(val.abs()).try_to_csl()?))
+            Ok(csl::Int::new_negative(&(val.abs()).try_to_csl()?))
         } else {
-            Ok(csl::utils::Int::new(&val.try_to_csl()?))
+            Ok(csl::Int::new(&val.try_to_csl()?))
         }
     }
 }
 
-impl TryFromPLA<i64> for csl::utils::Int {
+impl TryFromPLA<i64> for csl::Int {
     fn try_from_pla(val: &i64) -> Result<Self, TryFromPLAError> {
         if val.is_negative() {
-            Ok(csl::utils::Int::new_negative(&csl::utils::to_bignum(
+            Ok(csl::Int::new_negative(&csl::BigNum::from(
                 val.unsigned_abs(),
             )))
         } else {
-            Ok(csl::utils::Int::new(&csl::utils::to_bignum(*val as u64)))
+            Ok(csl::Int::new(&csl::BigNum::from(*val as u64)))
         }
     }
 }

plutus-ledger-api/src/csl/pla_to_csl.rs

@@ -558,79 +558,86 @@ where
     }
 }
 
-impl TryFromCSL<csl::plutus::PlutusData> for PlutusData {
-    fn try_from_csl(value: &csl::plutus::PlutusData) -> Result<Self, TryFromCSLError> {
+impl TryFromCSL<csl::PlutusData> for PlutusData {
+    fn try_from_csl(value: &csl::PlutusData) -> Result<Self, TryFromCSLError> {
         Ok(match value.kind() {
-            csl::plutus::PlutusDataKind::ConstrPlutusData => {
+            csl::PlutusDataKind::ConstrPlutusData => {
                 let constr_data = value.as_constr_plutus_data().unwrap();
                 let tag = BigInt::from_csl(&constr_data.alternative());
                 let args = constr_data.data().try_to_pla()?;
                 PlutusData::Constr(tag, args)
             }
-            csl::plutus::PlutusDataKind::Map => {
-                PlutusData::Map(value.as_map().unwrap().try_to_pla()?)
-            }
-            csl::plutus::PlutusDataKind::List => {
-                PlutusData::List(value.as_list().unwrap().try_to_pla()?)
-            }
-            csl::plutus::PlutusDataKind::Integer => {
+            csl::PlutusDataKind::Map => PlutusData::Map(value.as_map().unwrap().try_to_pla()?),
+            csl::PlutusDataKind::List => PlutusData::List(value.as_list().unwrap().try_to_pla()?),
+            csl::PlutusDataKind::Integer => {
                 PlutusData::Integer(value.as_integer().unwrap().try_to_pla()?)
             }
-            csl::plutus::PlutusDataKind::Bytes => PlutusData::Bytes(value.as_bytes().unwrap()),
+            csl::PlutusDataKind::Bytes => PlutusData::Bytes(value.as_bytes().unwrap()),
         })
     }
 }
 
-impl TryFromCSL<csl::plutus::PlutusList> for Vec<PlutusData> {
-    fn try_from_csl(value: &csl::plutus::PlutusList) -> Result<Self, TryFromCSLError> {
+impl TryFromCSL<csl::PlutusList> for Vec<PlutusData> {
+    fn try_from_csl(value: &csl::PlutusList) -> Result<Self, TryFromCSLError> {
         (0..value.len())
             .map(|idx| value.get(idx).try_to_pla())
             .collect()
     }
 }
 
-impl TryFromCSL<csl::plutus::PlutusMap> for Vec<(PlutusData, PlutusData)> {
-    fn try_from_csl(c_map: &csl::plutus::PlutusMap) -> Result<Self, TryFromCSLError> {
+impl TryFromCSL<csl::PlutusMap> for Vec<(PlutusData, PlutusData)> {
+    fn try_from_csl(c_map: &csl::PlutusMap) -> Result<Self, TryFromCSLError> {
         let keys = c_map.keys();
-        (0..keys.len())
-            .map(|idx| {
-                let key = keys.get(idx);
-                let value = c_map.get(&key).unwrap();
-                Ok((key.try_to_pla()?, value.try_to_pla()?))
-            })
-            .collect()
+        (0..keys.len()).try_fold(Vec::new(), |mut vector, idx| {
+            let key = keys.get(idx);
+            let values = c_map.get(&key).unwrap();
+
+            for value_idx in 0..values.len() {
+                vector.push((
+                    key.clone().try_to_pla()?,
+                    values.get(value_idx).unwrap().try_to_pla()?,
+                ))
+            }
+
+            Ok(vector)
+        })
     }
 }
 
-impl TryFromPLA<PlutusData> for csl::plutus::PlutusData {
+impl TryFromPLA<PlutusData> for csl::PlutusData {
     fn try_from_pla(val: &PlutusData) -> Result<Self, TryFromPLAError> {
         match val {
-            PlutusData::Constr(tag, args) => Ok(csl::plutus::PlutusData::new_constr_plutus_data(
-                &csl::plutus::ConstrPlutusData::new(&tag.try_to_csl()?, &args.try_to_csl()?),
+            PlutusData::Constr(tag, args) => Ok(csl::PlutusData::new_constr_plutus_data(
+                &csl::ConstrPlutusData::new(&tag.try_to_csl()?, &args.try_to_csl()?),
             )),
-            PlutusData::Map(l) => Ok(csl::plutus::PlutusData::new_map(&l.try_to_csl()?)),
-            PlutusData::List(l) => Ok(csl::plutus::PlutusData::new_list(&l.try_to_csl()?)),
-            PlutusData::Integer(i) => Ok(csl::plutus::PlutusData::new_integer(&i.try_to_csl()?)),
-            PlutusData::Bytes(b) => Ok(csl::plutus::PlutusData::new_bytes(b.to_owned())),
+            PlutusData::Map(l) => Ok(csl::PlutusData::new_map(&l.try_to_csl()?)),
+            PlutusData::List(l) => Ok(csl::PlutusData::new_list(&l.try_to_csl()?)),
+            PlutusData::Integer(i) => Ok(csl::PlutusData::new_integer(&i.try_to_csl()?)),
+            PlutusData::Bytes(b) => Ok(csl::PlutusData::new_bytes(b.to_owned())),
         }
     }
 }
 
-impl TryFromPLA<Vec<PlutusData>> for csl::plutus::PlutusList {
+impl TryFromPLA<Vec<PlutusData>> for csl::PlutusList {
     fn try_from_pla(val: &Vec<PlutusData>) -> Result<Self, TryFromPLAError> {
         val.iter()
             // traverse
             .map(|x| x.try_to_csl())
-            .collect::<Result<Vec<csl::plutus::PlutusData>, TryFromPLAError>>()
+            .collect::<Result<Vec<csl::PlutusData>, TryFromPLAError>>()
             .map(|x| x.into())
     }
 }
 
-impl TryFromPLA<Vec<(PlutusData, PlutusData)>> for csl::plutus::PlutusMap {
+impl TryFromPLA<Vec<(PlutusData, PlutusData)>> for csl::PlutusMap {
     fn try_from_pla(val: &Vec<(PlutusData, PlutusData)>) -> Result<Self, TryFromPLAError> {
         val.iter()
-            .try_fold(csl::plutus::PlutusMap::new(), |mut acc, (k, v)| {
-                acc.insert(&k.try_to_csl()?, &v.try_to_csl()?);
+            .try_fold(csl::PlutusMap::new(), |mut acc, (k, v)| {
+                let mut values = match acc.get(&k.try_to_csl()?) {
+                    Some(existing_values) => existing_values,
+                    None => csl::PlutusMapValues::new(),
+                };
+                values.add(&v.try_to_csl()?);
+                acc.insert(&k.try_to_csl()?, &values);
                 Ok(acc)
             })
     }