Merge pull request #478 from Emurgo/ruslan/language-encoding-fix

Release / Babbage 11.0.0-rc.6

Author: vsubhuman

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "cardano-serialization-lib",
-  "version": "11.0.0-rc.1",
+  "version": "11.0.0-rc.6",
   "description": "(De)serialization functions for the Cardano blockchain along with related utility functions",
   "scripts": {
     "rust:build-nodejs": "(rimraf ./rust/pkg && cd rust; wasm-pack build --target=nodejs; wasm-pack pack) && npm run js:flowgen",

package.json

@@ -1,6 +1,6 @@
 [package]
 name = "cardano-serialization-lib"
-version = "11.0.0-rc.1"
+version = "11.0.0-rc.6"
 edition = "2018"
 authors = ["EMURGO"]
 license = "MIT"

rust/Cargo.lock

@@ -5953,6 +5953,9 @@ declare export class TransactionBuilder {
    * in the builder to be used when building the tx body.
    * In case there are no plutus input witnesses present - nothing will change
    * You can set specific hash value using `.set_script_data_hash`
+   * NOTE: this function will check which language versions are used in the present scripts
+   * and will assert and require for a corresponding cost-model to be present in the passed map.
+   * Only the cost-models for the present language versions will be used in the hash calculation.
    * @param {Costmdls} cost_models
    */
   calc_script_data_hash(cost_models: Costmdls): void;

rust/Cargo.toml

@@ -279,25 +279,39 @@ impl Costmdls {
 
     pub(crate) fn language_views_encoding(&self) -> Vec<u8> {
         let mut serializer = Serializer::new_vec();
-        let mut keys_bytes: Vec<(Language, Vec<u8>)> = self.0.iter().map(|(k, _v)| (k.clone(), k.to_bytes())).collect();
+        fn key_len(l: &Language) -> usize {
+            if l.kind() == LanguageKind::PlutusV1 {
+                let mut serializer = Serializer::new_vec();
+                serializer.write_bytes(l.to_bytes()).unwrap();
+                serializer.finalize().len()
+            } else {
+                l.to_bytes().len()
+            }
+        }
+        let mut keys: Vec<Language> = self.0.iter().map(|(k, _v)| k.clone()).collect();
         // keys must be in canonical ordering first
-        keys_bytes.sort_by(|lhs, rhs| match lhs.1.len().cmp(&rhs.1.len()) {
-            std::cmp::Ordering::Equal => lhs.1.cmp(&rhs.1),
+        keys.sort_by(|lhs, rhs| match key_len(lhs).cmp(&key_len(rhs)) {
+            std::cmp::Ordering::Equal => lhs.cmp(&rhs),
             len_order => len_order,
         });
         serializer.write_map(cbor_event::Len::Len(self.0.len() as u64)).unwrap();
-        for (key, key_bytes) in keys_bytes.iter() {
-            serializer.write_bytes(key_bytes).unwrap();
-            let cost_model = self.0.get(&key).unwrap();
-            // Due to a bug in the cardano-node input-output-hk/cardano-ledger-specs/issues/2512
-            // we must use indefinite length serialization in this inner bytestring to match it
-            let mut cost_model_serializer = Serializer::new_vec();
-            cost_model_serializer.write_array(cbor_event::Len::Indefinite).unwrap();
-            for cost in &cost_model.0 {
-                cost.serialize(&mut cost_model_serializer).unwrap();
+        for key in keys.iter() {
+            if key.kind() == LanguageKind::PlutusV1 {
+                serializer.write_bytes(key.to_bytes()).unwrap();
+                let cost_model = self.0.get(&key).unwrap();
+                // Due to a bug in the cardano-node input-output-hk/cardano-ledger-specs/issues/2512
+                // we must use indefinite length serialization in this inner bytestring to match it
+                let mut cost_model_serializer = Serializer::new_vec();
+                cost_model_serializer.write_array(cbor_event::Len::Indefinite).unwrap();
+                for cost in &cost_model.0 {
+                    cost.serialize(&mut cost_model_serializer).unwrap();
+                }
+                cost_model_serializer.write_special(cbor_event::Special::Break).unwrap();
+                serializer.write_bytes(cost_model_serializer.finalize()).unwrap();
+            } else {
+                serializer.serialize(key).unwrap();
+                serializer.serialize(self.0.get(&key).unwrap()).unwrap();
             }
-            cost_model_serializer.write_special(cbor_event::Special::Break).unwrap();
-            serializer.write_bytes(cost_model_serializer.finalize()).unwrap();
         }
         let out = serializer.finalize();
         println!("language_views = {}", hex::encode(out.clone()));
@@ -400,7 +414,7 @@ impl Language {
 
 #[wasm_bindgen]
 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub struct Languages(Vec<Language>);
+pub struct Languages(pub(crate) Vec<Language>);
 
 #[wasm_bindgen]
 impl Languages {
@@ -419,6 +433,10 @@ impl Languages {
     pub fn add(&mut self, elem: Language) {
         self.0.push(elem);
     }
+
+    pub(crate) fn list() -> Languages {
+        Languages(vec![Language::new_plutus_v1(), Language::new_plutus_v2()])
+    }
 }
 
 #[wasm_bindgen]

rust/pkg/cardano_serialization_lib.js.flow

@@ -1420,12 +1420,27 @@ impl TransactionBuilder {
     /// in the builder to be used when building the tx body.
     /// In case there are no plutus input witnesses present - nothing will change
     /// You can set specific hash value using `.set_script_data_hash`
-    pub fn calc_script_data_hash(&mut self, cost_models: &Costmdls) {
+    /// NOTE: this function will check which language versions are used in the present scripts
+    /// and will assert and require for a corresponding cost-model to be present in the passed map.
+    /// Only the cost-models for the present language versions will be used in the hash calculation.
+    pub fn calc_script_data_hash(&mut self, cost_models: &Costmdls) -> Result<(), JsError> {
+        let mut retained_cost_models = Costmdls::new();
         if let Some(pw) = self.inputs.get_plutus_input_scripts() {
-            let (_, datums, redeemers) = pw.collect();
+            let (scripts, datums, redeemers) = pw.collect();
+            for lang in Languages::list().0 {
+                if scripts.has_version(&lang) {
+                    match cost_models.get(&lang) {
+                        Some(cost) => { retained_cost_models.insert(&lang, &cost); },
+                        _ => return Err(JsError::from_str(
+                            &format!("Missing cost model for language version: {:?}", lang)
+                        )),
+                    }
+                }
+            }
             self.script_data_hash =
-                Some(hash_script_data(&redeemers, cost_models, Some(datums)));
+                Some(hash_script_data(&redeemers, &retained_cost_models, Some(datums)));
         }
+        Ok(())
     }
 
     /// Sets the specified hash value.
@@ -5033,7 +5048,7 @@ mod tests {
         // Setting script data hash removes the error
         tx_builder.calc_script_data_hash(
             &TxBuilderConstants::plutus_default_cost_models(),
-        );
+        ).unwrap();
 
         // Using SAFE `.build_tx`
         let res2 = tx_builder.build_tx();
@@ -5094,7 +5109,7 @@ mod tests {
         // Calc the script data hash
         tx_builder.calc_script_data_hash(
             &TxBuilderConstants::plutus_default_cost_models(),
-        );
+        ).unwrap();
 
         let tx: Transaction = tx_builder.build_tx().unwrap();
         assert!(tx.witness_set.redeemers.is_some());
@@ -5190,7 +5205,7 @@ mod tests {
 
         tx_builder.calc_script_data_hash(
             &TxBuilderConstants::plutus_default_cost_models(),
-        );
+        ).unwrap();
 
         let tx: Transaction = tx_builder.build_tx().unwrap();
 
@@ -5335,7 +5350,7 @@ mod tests {
 
         tx_builder.calc_script_data_hash(
             &TxBuilderConstants::plutus_default_cost_models(),
-        );
+        ).unwrap();
 
         let w: &TransactionWitnessSet = &tx_builder.build_tx().unwrap().witness_set;
 
@@ -5998,5 +6013,77 @@ mod tests {
         assert!(tx_builder.total_collateral.is_none());
         assert!(tx_builder.collateral_return.is_none());
     }
+
+    #[test]
+    fn test_costmodel_retaining_for_v1() {
+        let mut tx_builder = create_reallistic_tx_builder();
+        tx_builder.set_fee(&to_bignum(42));
+        tx_builder.set_collateral(&create_collateral());
+
+        let (script1, _) = plutus_script_and_hash(0);
+        let datum = PlutusData::new_integer(&BigInt::from_str("42").unwrap());
+        let redeemer = Redeemer::new(
+            &RedeemerTag::new_spend(),
+            &to_bignum(0),
+            &datum,
+            &ExUnits::new(&to_bignum(1700), &to_bignum(368100)),
+        );
+        tx_builder.add_plutus_script_input(
+            &PlutusWitness::new(&script1, &datum, &redeemer),
+            &TransactionInput::new(&genesis_id(), 0),
+            &Value::new(&to_bignum(1_000_000)),
+        );
+
+        // Setting script data hash removes the error
+        tx_builder.calc_script_data_hash(
+            &TxBuilderConstants::plutus_vasil_cost_models(),
+        ).unwrap();
+
+        // Using SAFE `.build_tx`
+        let res2 = tx_builder.build_tx();
+        assert!(res2.is_ok());
+
+        let v1 = Language::new_plutus_v1();
+        let v1_costmodel = TxBuilderConstants::plutus_vasil_cost_models().get(&v1).unwrap();
+        let mut retained_cost_models = Costmdls::new();
+        retained_cost_models.insert(&v1, &v1_costmodel);
+
+        let data_hash = hash_script_data(
+            &Redeemers::from(vec![redeemer.clone()]),
+            &retained_cost_models,
+            Some(PlutusList::from(vec![datum])),
+        );
+        assert_eq!(tx_builder.script_data_hash.unwrap(), data_hash);
+    }
+
+    #[test]
+    fn test_costmodel_retaining_fails_on_missing_costmodel() {
+        let mut tx_builder = create_reallistic_tx_builder();
+        tx_builder.set_fee(&to_bignum(42));
+        tx_builder.set_collateral(&create_collateral());
+
+        let (script1, _) = plutus_script_and_hash(0);
+        let datum = PlutusData::new_integer(&BigInt::from_str("42").unwrap());
+        let redeemer = Redeemer::new(
+            &RedeemerTag::new_spend(),
+            &to_bignum(0),
+            &datum,
+            &ExUnits::new(&to_bignum(1700), &to_bignum(368100)),
+        );
+        tx_builder.add_plutus_script_input(
+            &PlutusWitness::new(&script1, &datum, &redeemer),
+            &TransactionInput::new(&genesis_id(), 0),
+            &Value::new(&to_bignum(1_000_000)),
+        );
+
+        let v2 = Language::new_plutus_v2();
+        let v2_costmodel = TxBuilderConstants::plutus_vasil_cost_models().get(&v2).unwrap();
+        let mut retained_cost_models = Costmdls::new();
+        retained_cost_models.insert(&v2, &v2_costmodel);
+
+        // Setting script data hash removes the error
+        let calc_result = tx_builder.calc_script_data_hash(&retained_cost_models);
+        assert!(calc_result.is_err());
+    }
 }
 

rust/src/plutus.rs

@@ -62,7 +62,7 @@ mod tests {
         );
         assert_eq!(
             hex::encode(TxBuilderConstants::plutus_vasil_cost_models().language_views_encoding()),
-            "a241005901b69f1a0003236119032c01011903e819023b00011903e8195e7104011903e818201a0001ca761928eb041959d818641959d818641959d818641959d818641959d818641959d81864186418641959d81864194c5118201a0002acfa182019b551041a000363151901ff00011a00015c3518201a000797751936f404021a0002ff941a0006ea7818dc0001011903e8196ff604021a0003bd081a00034ec5183e011a00102e0f19312a011a00032e801901a5011a0002da781903e819cf06011a00013a34182019a8f118201903e818201a00013aac0119e143041903e80a1a00030219189c011a00030219189c011a0003207c1901d9011a000330001901ff0119ccf3182019fd40182019ffd5182019581e18201940b318201a00012adf18201a0002ff941a0006ea7818dc0001011a00010f92192da7000119eabb18201a0002ff941a0006ea7818dc0001011a0002ff941a0006ea7818dc0001011a000c504e197712041a001d6af61a0001425b041a00040c660004001a00014fab18201a0003236119032c010119a0de18201a00033d7618201979f41820197fb8182019a95d1820197df718201995aa18201a009063b91903fd0aff41015901d19f1a0003236119032c01011903e819023b00011903e8195e7104011903e818201a0001ca761928eb041959d818641959d818641959d818641959d818641959d818641959d81864186418641959d81864194c5118201a0002acfa182019b551041a000363151901ff00011a00015c3518201a000797751936f404021a0002ff941a0006ea7818dc0001011903e8196ff604021a0003bd081a00034ec5183e011a00102e0f19312a011a00032e801901a5011a0002da781903e819cf06011a00013a34182019a8f118201903e818201a00013aac0119e143041903e80a1a00030219189c011a00030219189c011a0003207c1901d9011a000330001901ff0119ccf3182019fd40182019ffd5182019581e18201940b318201a00012adf18201a0002ff941a0006ea7818dc0001011a00010f92192da7000119eabb18201a0002ff941a0006ea7818dc0001011a0002ff941a0006ea7818dc0001011a0011b22c1a0005fdde00021a000c504e197712041a001d6af61a0001425b041a00040c660004001a00014fab18201a0003236119032c010119a0de18201a00033d7618201979f41820197fb8182019a95d1820197df718201995aa18201a0223accc0a1a009063b91903fd0a1a02515e841980b30aff",
+            "a20198af1a0003236119032c01011903e819023b00011903e8195e7104011903e818201a0001ca761928eb041959d818641959d818641959d818641959d818641959d818641959d81864186418641959d81864194c5118201a0002acfa182019b551041a000363151901ff00011a00015c3518201a000797751936f404021a0002ff941a0006ea7818dc0001011903e8196ff604021a0003bd081a00034ec5183e011a00102e0f19312a011a00032e801901a5011a0002da781903e819cf06011a00013a34182019a8f118201903e818201a00013aac0119e143041903e80a1a00030219189c011a00030219189c011a0003207c1901d9011a000330001901ff0119ccf3182019fd40182019ffd5182019581e18201940b318201a00012adf18201a0002ff941a0006ea7818dc0001011a00010f92192da7000119eabb18201a0002ff941a0006ea7818dc0001011a0002ff941a0006ea7818dc0001011a0011b22c1a0005fdde00021a000c504e197712041a001d6af61a0001425b041a00040c660004001a00014fab18201a0003236119032c010119a0de18201a00033d7618201979f41820197fb8182019a95d1820197df718201995aa18201a0223accc0a1a009063b91903fd0a1a02515e841980b30a41005901b69f1a0003236119032c01011903e819023b00011903e8195e7104011903e818201a0001ca761928eb041959d818641959d818641959d818641959d818641959d818641959d81864186418641959d81864194c5118201a0002acfa182019b551041a000363151901ff00011a00015c3518201a000797751936f404021a0002ff941a0006ea7818dc0001011903e8196ff604021a0003bd081a00034ec5183e011a00102e0f19312a011a00032e801901a5011a0002da781903e819cf06011a00013a34182019a8f118201903e818201a00013aac0119e143041903e80a1a00030219189c011a00030219189c011a0003207c1901d9011a000330001901ff0119ccf3182019fd40182019ffd5182019581e18201940b318201a00012adf18201a0002ff941a0006ea7818dc0001011a00010f92192da7000119eabb18201a0002ff941a0006ea7818dc0001011a0002ff941a0006ea7818dc0001011a000c504e197712041a001d6af61a0001425b041a00040c660004001a00014fab18201a0003236119032c010119a0de18201a00033d7618201979f41820197fb8182019a95d1820197df718201995aa18201a009063b91903fd0aff",
         );
     }
 }

rust/src/tx_builder.rs

@@ -1367,6 +1367,7 @@ pub(crate) fn opt64<T>(o: &Option<T>) -> u64 {
 
 #[cfg(test)]
 mod tests {
+    use crate::tx_builder_constants::TxBuilderConstants;
     use super::*;
 
     // this is what is used in mainnet
@@ -2446,4 +2447,28 @@ mod tests {
             to_bignum(0),
         );
     }
+
+    #[test]
+    fn test_vasil_v1_costmodel_hashing() {
+        let v1 = Language::new_plutus_v1();
+        let v1_cost_model = TxBuilderConstants::plutus_vasil_cost_models()
+            .get(&v1).unwrap();
+        let mut costmodels = Costmdls::new();
+        costmodels.insert(&v1, &v1_cost_model);
+        let hash = hash_script_data(
+            &Redeemers(vec![
+                Redeemer::new(
+                    &RedeemerTag::new_spend(),
+                    &BigNum::zero(),
+                    &PlutusData::new_integer(&BigInt::from_str("42").unwrap()),
+                    &ExUnits::new(&to_bignum(1700), &to_bignum(368100)),
+                )
+            ]),
+            &costmodels,
+            Some(PlutusList::from(vec![
+                PlutusData::new_integer(&BigInt::from_str("42").unwrap())
+            ])),
+        );
+        assert_eq!(hex::encode(hash.to_bytes()), "f4e4522ff98b6ba0ab5042d44da2458cd5fa6f97dc42aca1def58193f17a1375");
+    }
 }