Update for new CDDL changes: (#193)

bounded bytes update:
IntersectMBO/cardano-ledger@a8e0953
The change to constr_data was actually the implementation by us
accidentally so we don't need to change for that part, only
bounded_bytes.

cost model representation update:
IntersectMBO/cardano-ledger@ecb2cec

Author: rooooooooob

rust/src/plutus.rs

@@ -84,32 +84,38 @@ impl ConstrPlutusData {
     const GENERAL_FORM_TAG: u64 = 102;
 }
 
+const COST_MODEL_OP_COUNT: usize = 166;
+
 #[wasm_bindgen]
 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub struct CostModel(std::collections::BTreeMap<String, BigInt>);
+pub struct CostModel(Vec<Int>);
 
 to_from_bytes!(CostModel);
 
 #[wasm_bindgen]
 impl CostModel {
     pub fn new() -> Self {
-        Self(std::collections::BTreeMap::new())
-    }
-
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn insert(&mut self, key: String, value: &BigInt) -> Option<BigInt> {
-        self.0.insert(key, value.clone())
+        let mut costs = Vec::with_capacity(COST_MODEL_OP_COUNT);
+        for _ in 0 .. COST_MODEL_OP_COUNT {
+            costs.push(Int::new_i32(0));
+        }
+        Self(costs)
     }
 
-    pub fn get(&self, key: String) -> Option<BigInt> {
-        self.0.get(&key).map(|v| v.clone())
+    pub fn set(&mut self, operation: usize, cost: &Int) -> Result<Int, JsError> {
+        if operation >= COST_MODEL_OP_COUNT {
+            return Err(JsError::from_str(&format!("CostModel operation {} out of bounds. Max is {}", operation, COST_MODEL_OP_COUNT)));
+        }
+        let old = self.0[operation].clone();
+        self.0[operation] = cost.clone();
+        Ok(old)
     }
 
-    pub fn keys(&self) -> Strings {
-        Strings(self.0.iter().map(|(k, _v)| k.clone()).collect::<Vec<_>>())
+    pub fn get(&self, operation: usize) -> Result<Int, JsError> {
+        if operation >= COST_MODEL_OP_COUNT {
+            return Err(JsError::from_str(&format!("CostModel operation {} out of bounds. Max is {}", operation, COST_MODEL_OP_COUNT)));
+        }
+        Ok(self.0[operation].clone())
     }
 }
 
@@ -295,8 +301,6 @@ enum PlutusDataEnum {
 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
 pub struct PlutusData(PlutusDataEnum);
 
-const PLUTUS_BYTES_MAX_LEN: usize = 64;
-
 to_from_bytes!(PlutusData);
 
 #[wasm_bindgen]
@@ -317,12 +321,8 @@ impl PlutusData {
         Self(PlutusDataEnum::Integer(integer.clone()))
     }
 
-    pub fn new_bytes(bytes: Vec<u8>) -> Result<PlutusData, JsError> {
-        if bytes.len() > PLUTUS_BYTES_MAX_LEN {
-            Err(JsError::from_str(&format!("Max Plutus bytes too long: {}, max = {}", bytes.len(), PLUTUS_BYTES_MAX_LEN)))
-        } else {
-            Ok(Self(PlutusDataEnum::Bytes(bytes)))
-        }
+    pub fn new_bytes(bytes: Vec<u8>) -> Self {
+        Self(PlutusDataEnum::Bytes(bytes))
     }
 
     pub fn kind(&self) -> PlutusDataKind {
@@ -628,34 +628,36 @@ impl Deserialize for ConstrPlutusData {
 
 impl cbor_event::se::Serialize for CostModel {
     fn serialize<'se, W: Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
-        serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
-        for (key, value) in &self.0 {
-            serializer.write_text(&key)?;
-            value.serialize(serializer)?;
+        serializer.write_map(cbor_event::Len::Len(COST_MODEL_OP_COUNT as u64))?;
+        for cost in &self.0 {
+            cost.serialize(serializer)?;
         }
         Ok(serializer)
     }
 }
 
 impl Deserialize for CostModel {
     fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
-        let mut table = std::collections::BTreeMap::new();
+        let mut arr = Vec::new();
         (|| -> Result<_, DeserializeError> {
-            let len = raw.map()?;
-            while match len { cbor_event::Len::Len(n) => table.len() < n as usize, cbor_event::Len::Indefinite => true, } {
+            let len = raw.array()?;
+            while match len { cbor_event::Len::Len(n) => arr.len() < n as usize, cbor_event::Len::Indefinite => true, } {
                 if raw.cbor_type()? == CBORType::Special {
                     assert_eq!(raw.special()?, CBORSpecial::Break);
                     break;
                 }
-                let key = String::deserialize(raw)?;
-                let value = BigInt::deserialize(raw)?;
-                if table.insert(key.clone(), value).is_some() {
-                    return Err(DeserializeFailure::DuplicateKey(Key::Str(key)).into());
-                }
+                arr.push(Int::deserialize(raw)?);
+            }
+            if arr.len() != COST_MODEL_OP_COUNT {
+                return Err(DeserializeFailure::OutOfRange{
+                    min: COST_MODEL_OP_COUNT,
+                    max: COST_MODEL_OP_COUNT,
+                    found: arr.len()
+                }.into());
             }
             Ok(())
         })().map_err(|e| e.annotate("CostModel"))?;
-        Ok(Self(table))
+        Ok(Self(arr.try_into().unwrap()))
     }
 }
 
@@ -862,7 +864,7 @@ impl cbor_event::se::Serialize for PlutusDataEnum {
                 x.serialize(serializer)
             },
             PlutusDataEnum::Bytes(x) => {
-                serializer.write_bytes(&x)
+                write_bounded_bytes(serializer, &x)
             },
         }
     }
@@ -901,18 +903,10 @@ impl Deserialize for PlutusDataEnum {
                 Err(_) => raw.as_mut_ref().seek(SeekFrom::Start(initial_position)).unwrap(),
             };
             match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
-                Ok(raw.bytes()?)
+                Ok(read_bounded_bytes(raw)?)
             })(raw)
             {
-                Ok(variant) => if variant.len() <= PLUTUS_BYTES_MAX_LEN {
-                    return Ok(PlutusDataEnum::Bytes(variant));
-                } else {
-                    return Err(DeserializeFailure::OutOfRange{
-                        min: 0,
-                        max: PLUTUS_BYTES_MAX_LEN,
-                        found: variant.len(),
-                    }.into());
-                }
+                Ok(variant) => return Ok(PlutusDataEnum::Bytes(variant)),
                 Err(_) => raw.as_mut_ref().seek(SeekFrom::Start(initial_position)).unwrap(),
             };
             Err(DeserializeError::new("PlutusDataEnum", DeserializeFailure::NoVariantMatched.into()))

rust/src/utils.rs

@@ -488,6 +488,87 @@ impl Deserialize for Int {
     }
 }
 
+const BOUNDED_BYTES_CHUNK_SIZE: usize = 64;
+
+pub (crate) fn write_bounded_bytes<'se, W: Write>(serializer: &'se mut Serializer<W>, bytes: &[u8]) -> cbor_event::Result<&'se mut Serializer<W>> {
+    if bytes.len() <= BOUNDED_BYTES_CHUNK_SIZE {
+        serializer.write_bytes(bytes)
+    } else {
+        // to get around not having access from outside the library we just write the raw CBOR indefinite byte string code here
+        serializer.write_raw_bytes(&[0x5f])?;
+        for chunk in bytes.chunks(BOUNDED_BYTES_CHUNK_SIZE) {
+            serializer.write_bytes(chunk)?;
+        }
+        serializer.write_special(CBORSpecial::Break)
+    }
+}
+
+pub (crate) fn read_bounded_bytes<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Vec<u8>, DeserializeError> {
+    use std::io::Read;
+    let t = raw.cbor_type()?;
+    if t != CBORType::Bytes {
+        return Err(cbor_event::Error::Expected(CBORType::Bytes, t).into());
+    }
+    let (len, len_sz) = raw.cbor_len()?;
+    match len {
+        cbor_event::Len::Len(_) => {
+            let bytes = raw.bytes()?;
+            if bytes.len() > BOUNDED_BYTES_CHUNK_SIZE {
+                return Err(DeserializeFailure::OutOfRange{
+                    min: 0,
+                    max: BOUNDED_BYTES_CHUNK_SIZE,
+                    found: bytes.len(),
+                }.into());
+            }
+            Ok(bytes)
+        },
+        cbor_event::Len::Indefinite => {
+            // this is CBOR indefinite encoding, but we must check that each chunk
+            // is at most 64 big so we can't just use cbor_event's implementation
+            // and check after the fact.
+            // This is a slightly adopted version of what I made internally in cbor_event
+            // but with the extra checks and not having access to non-pub methods.
+            let mut bytes = Vec::new();
+            raw.advance(1 + len_sz)?;
+            // TODO: also change this + check at end of loop to the following after we update cbor_event
+            //while raw.cbor_type()? != CBORType::Special || !raw.special_break()? {
+            while raw.cbor_type()? != CBORType::Special {
+                let chunk_t = raw.cbor_type()?;
+                if chunk_t != CBORType::Bytes {
+                    return Err(cbor_event::Error::Expected(CBORType::Bytes, chunk_t).into());
+                }
+                let (chunk_len, chunk_len_sz) = raw.cbor_len()?;
+                match chunk_len {
+                    // TODO: use this error instead once that PR is merged into cbor_event
+                    //cbor_event::Len::Indefinite => return Err(cbor_event::Error::InvalidIndefiniteString.into()),
+                    cbor_event::Len::Indefinite => return Err(cbor_event::Error::CustomError(String::from("Illegal CBOR: Indefinite string found inside indefinite string")).into()),
+                    cbor_event::Len::Len(len) => {
+                        if chunk_len_sz > BOUNDED_BYTES_CHUNK_SIZE {
+                            return Err(DeserializeFailure::OutOfRange{
+                                min: 0,
+                                max: BOUNDED_BYTES_CHUNK_SIZE,
+                                found: chunk_len_sz,
+                            }.into());
+                        }
+                        raw.advance(1 + chunk_len_sz)?;
+                        raw
+                            .as_mut_ref()
+                            .by_ref()
+                            .take(len)
+                            .read_to_end(&mut bytes)
+                            .map_err(|e| cbor_event::Error::IoError(e))?;
+                    }
+                }
+            }
+            if raw.special()? != CBORSpecial::Break {
+                return Err(DeserializeFailure::EndingBreakMissing.into());
+            }
+            Ok(bytes)
+        },
+    }
+
+}
+
 #[wasm_bindgen]
 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
 pub struct BigInt(num_bigint::BigInt);
@@ -538,15 +619,15 @@ impl cbor_event::se::Serialize for BigInt {
                 num_bigint::Sign::Plus |
                 num_bigint::Sign::NoSign => {
                     serializer.write_tag(2u64)?;
-                    serializer.write_bytes(bytes)?;
+                    write_bounded_bytes(serializer, &bytes)?;
                 },
                 // negative bigint
                 num_bigint::Sign::Minus => {
                     serializer.write_tag(3u64)?;
                     use std::ops::Neg;
                     // CBOR RFC defines this as the bytes of -n -1
                     let adjusted = self.0.clone().neg().checked_sub(&num_bigint::BigInt::from(1u32)).unwrap().to_biguint().unwrap();
-                    serializer.write_bytes(adjusted.to_bytes_be())?;
+                    write_bounded_bytes(serializer, &adjusted.to_bytes_be())?;
                 },
             }
         }
@@ -561,10 +642,7 @@ impl Deserialize for BigInt {
                 // bigint
                 CBORType::Tag => {
                     let tag = raw.tag()?;
-                    let bytes = raw.bytes()?;
-                    if bytes.len() > 64 {
-                        return Err(DeserializeFailure::OutOfRange{ found: bytes.len(), min: 0, max: 64}.into())
-                    }
+                    let bytes = read_bounded_bytes(raw)?;
                     match tag {
                         // positive bigint
                         2 => Ok(Self(num_bigint::BigInt::from_bytes_be(num_bigint::Sign::Plus, &bytes))),
@@ -1673,4 +1751,50 @@ mod tests {
         let x_rt = BigInt::from_bytes(x.to_bytes()).unwrap();
         assert_eq!(x.to_str(), x_rt.to_str());
     }
+
+    #[test]
+    fn bounded_bytes_read_chunked() {
+        use std::io::Cursor;
+        let chunks = vec![
+            vec![
+                0x52, 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x72, 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0x20, 0x73,
+                0x74, 0x72, 0x69, 0x6E, 0x67,
+            ],
+            vec![0x44, 0x01, 0x02, 0x03, 0x04],
+        ];
+        let mut expected = Vec::new();
+        for chunk in chunks.iter() {
+            expected.extend_from_slice(&chunk[1..]);
+        }
+        let mut vec = vec![0x5f];
+        for mut chunk in chunks {
+            vec.append(&mut chunk);
+        }
+        vec.push(0xff);
+        let mut raw = Deserializer::from(Cursor::new(vec.clone()));
+        let found = read_bounded_bytes(&mut raw).unwrap();
+        assert_eq!(found, expected);
+    }
+
+    #[test]
+    fn bounded_bytes_write_chunked() {
+        let mut chunk_64 = vec![0x58, BOUNDED_BYTES_CHUNK_SIZE as u8];
+        chunk_64.extend(std::iter::repeat(37).take(BOUNDED_BYTES_CHUNK_SIZE));
+        let chunks = vec![
+            chunk_64,
+            vec![0x44, 0x01, 0x02, 0x03, 0x04],
+        ];
+        let mut input = Vec::new();
+        input.extend_from_slice(&chunks[0][2..]);
+        input.extend_from_slice(&chunks[1][1..]);
+        let mut serializer = cbor_event::se::Serializer::new_vec();
+        write_bounded_bytes(&mut serializer, &input).unwrap();
+        let written = serializer.finalize();
+        let mut expected = vec![0x5f];
+        for mut chunk in chunks {
+            expected.append(&mut chunk);
+        }
+        expected.push(0xff);
+        assert_eq!(expected, written);
+    }
 }