Fixed tx size calculation when required signers are used. Beta version bump.

Author: vsubhuman

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "cardano-serialization-lib",
-  "version": "10.2.0-beta.4",
+  "version": "10.2.0-beta.5",
   "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 = "10.2.0-beta.4"
+version = "10.2.0-beta.5"
 edition = "2018"
 authors = ["EMURGO"]
 license = "MIT"

rust/Cargo.lock

@@ -230,6 +230,15 @@ impl Certificates {
 pub type RequiredSigners = Ed25519KeyHashes;
 pub type RequiredSignersSet = BTreeSet<Ed25519KeyHash>;
 
+impl From<&Ed25519KeyHashes> for RequiredSignersSet {
+    fn from(keys: &Ed25519KeyHashes) -> Self {
+        keys.0.iter().fold(BTreeSet::new(), |mut set, k| {
+            set.insert(k.clone());
+            set
+        })
+    }
+}
+
 #[wasm_bindgen]
 #[derive(Clone)]
 pub struct TransactionBody {
@@ -614,10 +623,15 @@ to_from_bytes!(Ed25519KeyHashes);
 
 #[wasm_bindgen]
 impl Ed25519KeyHashes {
+
     pub fn new() -> Self {
         Self(Vec::new())
     }
 
+    pub(crate) fn from_vec(vec: Vec<Ed25519KeyHash>) -> Self {
+        Self(vec)
+    }
+
     pub fn len(&self) -> usize {
         self.0.len()
     }

rust/Cargo.toml

@@ -71,6 +71,7 @@ fn fake_raw_key_public() -> PublicKey {
 fn count_needed_vkeys(tx_builder: &TransactionBuilder) -> usize {
     let mut input_hashes: RequiredSignersSet = RequiredSignersSet::from(&tx_builder.inputs);
     input_hashes.extend(RequiredSignersSet::from(&tx_builder.collateral));
+    input_hashes.extend(RequiredSignersSet::from(&tx_builder.required_signers));
     if let Some(scripts) = &tx_builder.mint_scripts {
         input_hashes.extend(RequiredSignersSet::from(scripts));
     }
@@ -5221,5 +5222,49 @@ mod tests {
         assert_eq!(rs.get(1), s3);
         assert_eq!(rs.get(2), s2);
     }
+
+    #[test]
+    fn test_required_signers_are_added_to_the_witness_estimate() {
+
+        fn count_fake_witnesses_with_required_signers(keys: &Ed25519KeyHashes) -> usize {
+            let mut tx_builder = create_reallistic_tx_builder();
+            tx_builder.set_fee(&to_bignum(42));
+            tx_builder.add_input(
+                &create_base_address(0),
+                &TransactionInput::new(&fake_tx_hash(0), 0),
+                &Value::new(&to_bignum(10_000_000)),
+            );
+
+            keys.0.iter().for_each(|k| {
+                tx_builder.add_required_signer(k);
+            });
+
+            let tx: Transaction = fake_full_tx(&tx_builder, tx_builder.build().unwrap()).unwrap();
+            tx.witness_set.vkeys.unwrap().len()
+        }
+
+        assert_eq!(count_fake_witnesses_with_required_signers(
+            &Ed25519KeyHashes::new(),
+        ), 1);
+
+        assert_eq!(count_fake_witnesses_with_required_signers(
+            &Ed25519KeyHashes::from_vec(vec![fake_key_hash(1)]),
+        ), 2);
+
+        assert_eq!(count_fake_witnesses_with_required_signers(
+            &Ed25519KeyHashes::from_vec(vec![fake_key_hash(1), fake_key_hash(2)]),
+        ), 3);
+
+        // This case still produces only 3 fake signatures, because the same key is already used in the input address
+        assert_eq!(count_fake_witnesses_with_required_signers(
+            &Ed25519KeyHashes::from_vec(vec![fake_key_hash(1), fake_key_hash(2), fake_key_hash(0)]),
+        ), 3);
+
+        // When a different key is used - 4 fake witnesses are produced
+        assert_eq!(count_fake_witnesses_with_required_signers(
+            &Ed25519KeyHashes::from_vec(vec![fake_key_hash(1), fake_key_hash(2), fake_key_hash(3)]),
+        ), 4);
+    }
+
 }