added is_valid to transaction

Alessandro Konrad · Alessandro Konrad · commit c065577229cc · 2021-09-20T11:21:16.000+02:00
diff --git a/rust/src/error.rs b/rust/src/error.rs
@@ -30,6 +30,7 @@ pub enum DeserializeFailure {
     DuplicateKey(Key),
     EndingBreakMissing,
     ExpectedNull,
+    ExpectedBool,
     FixedValueMismatch{
         found: Key,
         expected: Key,
@@ -95,6 +96,7 @@ impl std::fmt::Display for DeserializeError {
             DeserializeFailure::DuplicateKey(key) => write!(f, "Duplicate key: {}", key),
             DeserializeFailure::EndingBreakMissing => write!(f, "Missing ending CBOR Break"),
             DeserializeFailure::ExpectedNull => write!(f, "Expected null, found other type"),
+            DeserializeFailure::ExpectedBool => write!(f, "Expected bool, found other type"),
             DeserializeFailure::FixedValueMismatch{ found, expected } => write!(f, "Expected fixed value {} found {}", expected, found),
             DeserializeFailure::MandatoryFieldMissing(key) => write!(f, "Mandatory field {} not found", key),
             DeserializeFailure::Metadata(e) => write!(f, "Metadata error: {:?}", e),
diff --git a/rust/src/fees.rs b/rust/src/fees.rs
@@ -76,17 +76,18 @@ mod tests {
         let signed_tx = Transaction::new(
             &body,
             &w,
+            true,
             None,
         );
 
         let linear_fee = LinearFee::new(&to_bignum(500), &to_bignum(2));
         assert_eq!(
             hex::encode(signed_tx.to_bytes()),
-            "83a400818258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b700018182581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c01021a00016f32030aa10081825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee5840fae5de40c94d759ce13bf9886262159c4f26a289fd192e165995b785259e503f6887bf39dfa23a47cf163784c6eee23f61440e749bc1df3c73975f5231aeda0ff6"
+            "83a400818258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b700018182581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c01021a00016f32030aa10081825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee5840fae5de40c94d759ce13bf9886262159c4f26a289fd192e165995b785259e503f6887bf39dfa23a47cf163784c6eee23f61440e749bc1df3c73975f5231aeda0ff5f6"
         );
         assert_eq!(
             min_fee(&signed_tx, &linear_fee).unwrap().to_str(),
-            "94002" // todo: compare to Haskell fee to make sure the diff is not too big
+            "94502" // todo: compare to Haskell fee to make sure the diff is not too big
         );
     }
 
@@ -122,17 +123,18 @@ mod tests {
         let signed_tx = Transaction::new(
             &body,
             &w,
+            true,
             None,
         );
 
         let linear_fee = LinearFee::new(&to_bignum(500), &to_bignum(2));
         assert_eq!(
             hex::encode(signed_tx.to_bytes()),
-            "83a400818258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b700018182581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c01021a0001b582030aa10281845820473811afd4d939b337c9be1a2ceeb2cb2c75108bddf224c5c21c51592a7b204a5840f0b04a852353eb23b9570df80b2aa6a61b723341ab45a2024a05b07cf58be7bdfbf722c09040db6cee61a0d236870d6ad1e1349ac999ec0db28f9471af25fb0c5820c8b95d0d35fe75a70f9f5633a3e2439b2994b9e2bc851c49e9f91d1a5dcbb1a341a0f6"
+            "83a400818258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b700018182581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c01021a0001b582030aa10281845820473811afd4d939b337c9be1a2ceeb2cb2c75108bddf224c5c21c51592a7b204a5840f0b04a852353eb23b9570df80b2aa6a61b723341ab45a2024a05b07cf58be7bdfbf722c09040db6cee61a0d236870d6ad1e1349ac999ec0db28f9471af25fb0c5820c8b95d0d35fe75a70f9f5633a3e2439b2994b9e2bc851c49e9f91d1a5dcbb1a341a0f5f6"
         );
         assert_eq!(
             min_fee(&signed_tx, &linear_fee).unwrap().to_str(),
-            "112002" // todo: compare to Haskell fee to make sure the diff is not too big
+            "112502" // todo: compare to Haskell fee to make sure the diff is not too big
         );
     }
 
@@ -192,17 +194,18 @@ mod tests {
         let signed_tx = Transaction::new(
             &body,
             &w,
+            true,
             None,
         );
 
         let linear_fee = LinearFee::new(&to_bignum(500), &to_bignum(2));
         assert_eq!(
             hex::encode(signed_tx.to_bytes()),
-            "83a400828258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b7182a82582082839f8200d81858248258203b40265111d8bb3c3c608d95b3a0bf83461ace3207018282581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c19012182581d61bcd18fcffa797c16c007014e2b8553b8b9b1e94c507688726243d6111a3420989c021a0002ccce031903e7a10082825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee58401ec3e56008650282ba2e1f8a20e81707810b2d0973c4d42a1b4df65b732bda81567c7824904840b2554d2f33861da5d70588a29d33b2b61042e3c3445301d8008258206872b0a874acfe1cace12b20ea348559a7ecc912f2fc7f674f43481df973d92c5840a0718fb5b37d89ddf926c08e456d3f4c7f749e91f78bb3e370751d5b632cbd20d38d385805291b1ef2541b02543728a235e01911f4b400bfb50e5fce589de907f6"
+            "83a400828258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b7182a82582082839f8200d81858248258203b40265111d8bb3c3c608d95b3a0bf83461ace3207018282581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c19012182581d61bcd18fcffa797c16c007014e2b8553b8b9b1e94c507688726243d6111a3420989c021a0002ccce031903e7a10082825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee58401ec3e56008650282ba2e1f8a20e81707810b2d0973c4d42a1b4df65b732bda81567c7824904840b2554d2f33861da5d70588a29d33b2b61042e3c3445301d8008258206872b0a874acfe1cace12b20ea348559a7ecc912f2fc7f674f43481df973d92c5840a0718fb5b37d89ddf926c08e456d3f4c7f749e91f78bb3e370751d5b632cbd20d38d385805291b1ef2541b02543728a235e01911f4b400bfb50e5fce589de907f5f6"
         );
         assert_eq!(
             min_fee(&signed_tx, &linear_fee).unwrap().to_str(),
-            "183502" // todo: compare to Haskell fee to make sure the diff is not too big
+            "184002" // todo: compare to Haskell fee to make sure the diff is not too big
         );
     }
 
@@ -288,17 +291,18 @@ mod tests {
         let signed_tx = Transaction::new(
             &body,
             &w,
+            true,
             None,
         );
 
         let linear_fee = LinearFee::new(&to_bignum(500), &to_bignum(2));
         assert_eq!(
             hex::encode(signed_tx.to_bytes()),
-            "83a500818258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b700018182581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c01021a00040f12030a04818a03581c1c13374874c68016df54b1339b6cacdd801098431e7659b24928efc15820bd0000f498ccacdc917c28274cba51c415f3f21931ff41ca8dc1197499f8e1241a000f42401a000f4240d81e82031864581de151df9ba1b74a1c9608a487e114184556801e927d31d96425cb80af7081581c51df9ba1b74a1c9608a487e114184556801e927d31d96425cb80af7080f6a10083825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee5840a7f305d7e46abfe0f7bea6098bdf853ab9ce8e7aa381be5a991a871852f895a718e20614e22be43494c4dc3a8c78c56cd44fd38e0e5fff3e2fbd19f70402fc02825820b24c040e65994bd5b0621a060166d32d356ef4be3cc1f848426a4cf386887089584013c372f82f1523484eab273241d66d92e1402507760e279480912aa5f0d88d656d6f25d41e65257f2f38c65ac5c918a6735297741adfc718394994f20a1cfd0082582054d1a9c5ad69586ceeb839c438400c376c0bd34825fb4c17cc2f58c54e1437f35840d326b993dfec21b9b3e1bd2f80adadc2cd673a1d8d033618cc413b0b02bc3b7efbb23d1ff99138abd05c398ce98e7983a641b50dcf0f64ed33f26c6e636b0b0ff6"
+            "83a500818258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b700018182581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c01021a00040f12030a04818a03581c1c13374874c68016df54b1339b6cacdd801098431e7659b24928efc15820bd0000f498ccacdc917c28274cba51c415f3f21931ff41ca8dc1197499f8e1241a000f42401a000f4240d81e82031864581de151df9ba1b74a1c9608a487e114184556801e927d31d96425cb80af7081581c51df9ba1b74a1c9608a487e114184556801e927d31d96425cb80af7080f6a10083825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee5840a7f305d7e46abfe0f7bea6098bdf853ab9ce8e7aa381be5a991a871852f895a718e20614e22be43494c4dc3a8c78c56cd44fd38e0e5fff3e2fbd19f70402fc02825820b24c040e65994bd5b0621a060166d32d356ef4be3cc1f848426a4cf386887089584013c372f82f1523484eab273241d66d92e1402507760e279480912aa5f0d88d656d6f25d41e65257f2f38c65ac5c918a6735297741adfc718394994f20a1cfd0082582054d1a9c5ad69586ceeb839c438400c376c0bd34825fb4c17cc2f58c54e1437f35840d326b993dfec21b9b3e1bd2f80adadc2cd673a1d8d033618cc413b0b02bc3b7efbb23d1ff99138abd05c398ce98e7983a641b50dcf0f64ed33f26c6e636b0b0ff5f6"
         );
         assert_eq!(
             min_fee(&signed_tx, &linear_fee).unwrap().to_str(),
-            "269002" // todo: compare to Haskell fee to make sure the diff is not too big
+            "269502" // todo: compare to Haskell fee to make sure the diff is not too big
         );
     }
 
@@ -482,17 +486,18 @@ mod tests {
         let signed_tx = Transaction::new(
             &body,
             &w,
+            true,
             None,
         );
 
         let linear_fee = LinearFee::new(&to_bignum(500), &to_bignum(2));
         assert_eq!(
             hex::encode(signed_tx.to_bytes()),
-            "83a500818258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b700018182581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c01021a00027ac6030a05a1581de151df9ba1b74a1c9608a487e114184556801e927d31d96425cb80af70190539a10082825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee5840fc0493f7121efe385d72830680e735ccdef99c3a31953fe877b89ad3a97fcdb871cc7f2cdd6a8104e52f6963bd9e10d814d4fabdbcdc8475bc63e872dcc94d0a82582054d1a9c5ad69586ceeb839c438400c376c0bd34825fb4c17cc2f58c54e1437f35840a051ba927582004aedab736b9f1f9330ff867c260f4751135d480074256e83cd23d2a4bb109f955c43afdcdc5d1841b28d5c1ea2148dfbb6252693590692bb00f6"
+            "83a500818258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b700018182581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c01021a00027ac6030a05a1581de151df9ba1b74a1c9608a487e114184556801e927d31d96425cb80af70190539a10082825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee5840fc0493f7121efe385d72830680e735ccdef99c3a31953fe877b89ad3a97fcdb871cc7f2cdd6a8104e52f6963bd9e10d814d4fabdbcdc8475bc63e872dcc94d0a82582054d1a9c5ad69586ceeb839c438400c376c0bd34825fb4c17cc2f58c54e1437f35840a051ba927582004aedab736b9f1f9330ff867c260f4751135d480074256e83cd23d2a4bb109f955c43afdcdc5d1841b28d5c1ea2148dfbb6252693590692bb00f5f6"
         );
         assert_eq!(
             min_fee(&signed_tx, &linear_fee).unwrap().to_str(),
-            "162502" // todo: compare to Haskell fee to make sure the diff is not too big
+            "163002" // todo: compare to Haskell fee to make sure the diff is not too big
         );
     }
 }
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
@@ -97,6 +97,7 @@ type Slot = u32;
 pub struct Transaction {
     body: TransactionBody,
     witness_set: TransactionWitnessSet,
+    is_valid: bool,
     auxiliary_data: Option<AuxiliaryData>,
 }
 
@@ -112,18 +113,24 @@ impl Transaction {
         self.witness_set.clone()
     }
 
+    pub fn is_valid(&self) -> bool {
+        self.is_valid.clone()
+    }
+
     pub fn auxiliary_data(&self) -> Option<AuxiliaryData> {
         self.auxiliary_data.clone()
     }
 
     pub fn new(
         body: &TransactionBody,
         witness_set: &TransactionWitnessSet,
+        is_valid: bool,
         auxiliary_data: Option<AuxiliaryData>,
     ) -> Self {
         Self {
             body: body.clone(),
             witness_set: witness_set.clone(),
+            is_valid: is_valid.clone(),
             auxiliary_data: auxiliary_data.clone(),
         }
     }
diff --git a/rust/src/serialization.rs b/rust/src/serialization.rs
@@ -59,6 +59,7 @@ impl cbor_event::se::Serialize for Transaction {
         serializer.write_array(cbor_event::Len::Len(3))?;
         self.body.serialize(serializer)?;
         self.witness_set.serialize(serializer)?;
+        serializer.write_special(CBORSpecial::Bool(self.is_valid))?;
         match &self.auxiliary_data {
             Some(x) => {
                 x.serialize(serializer)
@@ -94,6 +95,17 @@ impl DeserializeEmbeddedGroup for Transaction {
         let witness_set = (|| -> Result<_, DeserializeError> {
             Ok(TransactionWitnessSet::deserialize(raw)?)
         })().map_err(|e| e.annotate("witness_set"))?;
+        let is_valid = (|| -> Result<_, DeserializeError> {
+            Ok(match raw.cbor_type()? == CBORType::Special {
+                true => {
+                    if let CBORSpecial::Bool(b) = raw.special()? {
+                        return Ok(b);
+                    }
+                    return Err(DeserializeFailure::ExpectedBool.into());
+                },
+                _ => return Err(DeserializeFailure::ExpectedBool.into())
+            })
+        })().map_err(|e| e.annotate("is_valid"))?;
         let auxiliary_data = (|| -> Result<_, DeserializeError> {
             Ok(match raw.cbor_type()? != CBORType::Special {
                 true => {
@@ -110,6 +122,7 @@ impl DeserializeEmbeddedGroup for Transaction {
         Ok(Transaction {
             body,
             witness_set,
+            is_valid,
             auxiliary_data,
         })
     }
diff --git a/rust/src/tx_builder.rs b/rust/src/tx_builder.rs
@@ -96,6 +96,7 @@ fn fake_full_tx(tx_builder: &TransactionBuilder, body: TransactionBody) -> Resul
     Ok(Transaction {
         body,
         witness_set,
+        is_valid: true,
         auxiliary_data: tx_builder.auxiliary_data.clone(),
     })
 }
@@ -662,7 +663,7 @@ mod tests {
             tx_builder.get_explicit_input().unwrap().checked_add(&tx_builder.get_implicit_input().unwrap()).unwrap(),
             tx_builder.get_explicit_output().unwrap().checked_add(&Value::new(&tx_builder.get_fee_if_set().unwrap())).unwrap()
         );
-        assert_eq!(tx_builder.full_size().unwrap(), 283);
+        assert_eq!(tx_builder.full_size().unwrap(), 284);
         assert_eq!(tx_builder.output_sizes(), vec![61, 65]);
         let _final_tx = tx_builder.build(); // just test that it doesn't throw
     }
@@ -782,8 +783,8 @@ mod tests {
         tx_builder.add_change_if_needed(
             &change_addr
         ).unwrap();
-        assert_eq!(tx_builder.min_fee().unwrap().to_str(), "213502");
-        assert_eq!(tx_builder.get_fee_if_set().unwrap().to_str(), "213502");
+        assert_eq!(tx_builder.min_fee().unwrap().to_str(), "214002");
+        assert_eq!(tx_builder.get_fee_if_set().unwrap().to_str(), "214002");
         assert_eq!(tx_builder.get_deposit().unwrap().to_str(), "1000000");
         assert_eq!(tx_builder.outputs.len(), 1);
         assert_eq!(

Original file line number	Diff line number	Diff line change
`@@ -97,6 +97,7 @@ type Slot = u32;`
`97`	`97`	`pub struct Transaction {`
`98`	`98`	`body: TransactionBody,`
`99`	`99`	`witness_set: TransactionWitnessSet,`
	`100`	`+ is_valid: bool,`
`100`	`101`	`auxiliary_data: Option<AuxiliaryData>,`
`101`	`102`	`}`
`102`	`103`
`@@ -112,18 +113,24 @@ impl Transaction {`
`112`	`113`	`self.witness_set.clone()`
`113`	`114`	`}`
`114`	`115`
	`116`	`+ pub fn is_valid(&self) -> bool {`
	`117`	`+ self.is_valid.clone()`
	`118`	`+ }`
	`119`	`+`
`115`	`120`	`pub fn auxiliary_data(&self) -> Option<AuxiliaryData> {`
`116`	`121`	`self.auxiliary_data.clone()`
`117`	`122`	`}`
`118`	`123`
`119`	`124`	`pub fn new(`
`120`	`125`	`body: &TransactionBody,`
`121`	`126`	`witness_set: &TransactionWitnessSet,`
	`127`	`+ is_valid: bool,`
`122`	`128`	`auxiliary_data: Option<AuxiliaryData>,`
`123`	`129`	`) -> Self {`
`124`	`130`	`Self {`
`125`	`131`	`body: body.clone(),`
`126`	`132`	`witness_set: witness_set.clone(),`
	`133`	`+ is_valid: is_valid.clone(),`
`127`	`134`	`auxiliary_data: auxiliary_data.clone(),`
`128`	`135`	`}`
`129`	`136`	`}`