Merge pull request #520 from Emurgo/evgenii/infromative_change_error

More informative error in add_change_if_needed

Author: vsubhuman

rust/src/crypto.rs

@@ -7,6 +7,8 @@ use crypto::bech32::Bech32 as _;
 use rand_os::OsRng;
 use std::io::{BufRead, Seek, Write};
 use std::str::FromStr;
+use std::fmt::Display;
+use std::fmt;
 
 use cryptoxide::blake2b::Blake2b;
 
@@ -1058,6 +1060,12 @@ macro_rules! impl_hash_type {
                 String::is_referenceable()
             }
         }
+
+        impl Display for $name {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                write!(f, "{}", self.to_hex())
+            }
+        }
     };
 }
 

rust/src/lib.rs

@@ -66,6 +66,8 @@ use plutus::*;
 use schemars::JsonSchema;
 use std::cmp::Ordering;
 use std::collections::BTreeSet;
+use std::fmt::Display;
+use std::fmt;
 use utils::*;
 
 type DeltaCoin = Int;
@@ -3153,6 +3155,12 @@ impl HeaderBody {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AssetName(Vec<u8>);
 
+impl Display for AssetName {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", hex::encode(&self.0))
+    }
+}
+
 impl Ord for AssetName {
     fn cmp(&self, other: &Self) -> Ordering {
         // Implementing canonical CBOR order for asset names,

rust/src/tx_builder.rs

@@ -1302,6 +1302,11 @@ impl TransactionBuilder {
         let input_total = self.get_total_input()?;
         let output_total = self.get_total_output()?;
 
+        let shortage = get_input_shortage(&input_total, &output_total, &fee)?;
+        if let Some(shortage) = shortage {
+            return Err(JsError::from_str(&format!("Insufficient input in transaction. {}", shortage)));
+        }
+
         use std::cmp::Ordering;
         match &input_total.partial_cmp(&output_total.checked_add(&Value::new(&fee))?) {
             Some(Ordering::Equal) => {
@@ -2926,6 +2931,196 @@ mod tests {
         );
     }
 
+    #[test]
+    fn change_with_input_and_mint_not_enough_ada() {
+        let mut tx_builder = create_tx_builder_with_fee(&create_linear_fee(1, 1));
+        let spend = root_key_15()
+            .derive(harden(1852))
+            .derive(harden(1815))
+            .derive(harden(0))
+            .derive(0)
+            .derive(0)
+            .to_public();
+        let change_key = root_key_15()
+            .derive(harden(1852))
+            .derive(harden(1815))
+            .derive(harden(0))
+            .derive(1)
+            .derive(0)
+            .to_public();
+        let stake = root_key_15()
+            .derive(harden(1852))
+            .derive(harden(1815))
+            .derive(harden(0))
+            .derive(2)
+            .derive(0)
+            .to_public();
+
+        let spend_cred = StakeCredential::from_keyhash(&spend.to_raw_key().hash());
+        let stake_cred = StakeCredential::from_keyhash(&stake.to_raw_key().hash());
+
+        let (min_script, policy_id) = mint_script_and_policy(0);
+        let asset_name = AssetName::new(vec![0u8, 1, 2, 3]).unwrap();
+
+        let amount_minted = to_bignum(1000);
+        let amount_sent = to_bignum(500);
+        let amount_input_amount = to_bignum(600);
+
+        let mut asset_input = Assets::new();
+        asset_input.insert(&asset_name, &amount_input_amount);
+        let mut mass_input = MultiAsset::new();
+        mass_input.insert(&policy_id, &asset_input);
+
+        // Input with 600 coins
+        tx_builder.add_input(
+            &EnterpriseAddress::new(NetworkInfo::testnet().network_id(), &spend_cred).to_address(),
+            &TransactionInput::new(&genesis_id(), 0),
+            &Value::new(&to_bignum(600)),
+        );
+
+        tx_builder.add_input(
+            &EnterpriseAddress::new(NetworkInfo::testnet().network_id(), &spend_cred).to_address(),
+            &TransactionInput::new(&genesis_id(), 1),
+            &Value::new_with_assets(&to_bignum(1), &mass_input),
+        );
+
+        let addr_net_0 = BaseAddress::new(
+            NetworkInfo::testnet().network_id(),
+            &spend_cred,
+            &stake_cred,
+        ).to_address();
+
+        // Adding mint of the asset - which should work as an input
+        tx_builder.add_mint_asset(&min_script, &asset_name, Int::new(&amount_minted));
+
+        let mut asset = Assets::new();
+        asset.insert(&asset_name, &amount_sent);
+        let mut mass = MultiAsset::new();
+        mass.insert(&policy_id, &asset);
+
+        // One coin and the minted asset goes into the output
+        let mut output_amount = Value::new(&to_bignum(400));
+        output_amount.set_multiasset(&mass);
+
+        tx_builder
+            .add_output(
+                &TransactionOutputBuilder::new()
+                    .with_address(&addr_net_0)
+                    .next()
+                    .unwrap()
+                    .with_value(&output_amount)
+                    .build()
+                    .unwrap(),
+            )
+            .unwrap();
+
+        let change_cred = StakeCredential::from_keyhash(&change_key.to_raw_key().hash());
+        let change_addr = BaseAddress::new(
+            NetworkInfo::testnet().network_id(),
+            &change_cred,
+            &stake_cred,
+        )
+            .to_address();
+
+        let added_change = tx_builder.add_change_if_needed(&change_addr);
+        assert!(added_change.is_err());
+    }
+
+    #[test]
+    fn change_with_input_and_mint_not_enough_assets() {
+        let mut tx_builder = create_tx_builder_with_fee(&create_linear_fee(1, 1));
+        let spend = root_key_15()
+            .derive(harden(1852))
+            .derive(harden(1815))
+            .derive(harden(0))
+            .derive(0)
+            .derive(0)
+            .to_public();
+        let change_key = root_key_15()
+            .derive(harden(1852))
+            .derive(harden(1815))
+            .derive(harden(0))
+            .derive(1)
+            .derive(0)
+            .to_public();
+        let stake = root_key_15()
+            .derive(harden(1852))
+            .derive(harden(1815))
+            .derive(harden(0))
+            .derive(2)
+            .derive(0)
+            .to_public();
+
+        let spend_cred = StakeCredential::from_keyhash(&spend.to_raw_key().hash());
+        let stake_cred = StakeCredential::from_keyhash(&stake.to_raw_key().hash());
+
+        let (min_script, policy_id) = mint_script_and_policy(0);
+        let asset_name = AssetName::new(vec![0u8, 1, 2, 3]).unwrap();
+
+        let amount_minted = to_bignum(1000);
+        let amount_sent = to_bignum(100000);
+        let amount_input_amount = to_bignum(600);
+
+        let mut asset_input = Assets::new();
+        asset_input.insert(&asset_name, &amount_input_amount);
+        let mut mass_input = MultiAsset::new();
+        mass_input.insert(&policy_id, &asset_input);
+
+        // Input with 600 coins
+        tx_builder.add_input(
+            &EnterpriseAddress::new(NetworkInfo::testnet().network_id(), &spend_cred).to_address(),
+            &TransactionInput::new(&genesis_id(), 0),
+            &Value::new(&to_bignum(100000)),
+        );
+
+        tx_builder.add_input(
+            &EnterpriseAddress::new(NetworkInfo::testnet().network_id(), &spend_cred).to_address(),
+            &TransactionInput::new(&genesis_id(), 1),
+            &Value::new_with_assets(&to_bignum(1), &mass_input),
+        );
+
+        let addr_net_0 = BaseAddress::new(
+            NetworkInfo::testnet().network_id(),
+            &spend_cred,
+            &stake_cred,
+        ).to_address();
+
+        // Adding mint of the asset - which should work as an input
+        tx_builder.add_mint_asset(&min_script, &asset_name, Int::new(&amount_minted));
+
+        let mut asset = Assets::new();
+        asset.insert(&asset_name, &amount_sent);
+        let mut mass = MultiAsset::new();
+        mass.insert(&policy_id, &asset);
+
+        // One coin and the minted asset goes into the output
+        let mut output_amount = Value::new(&to_bignum(400));
+        output_amount.set_multiasset(&mass);
+
+        tx_builder
+            .add_output(
+                &TransactionOutputBuilder::new()
+                    .with_address(&addr_net_0)
+                    .next()
+                    .unwrap()
+                    .with_value(&output_amount)
+                    .build()
+                    .unwrap(),
+            )
+            .unwrap();
+
+        let change_cred = StakeCredential::from_keyhash(&change_key.to_raw_key().hash());
+        let change_addr = BaseAddress::new(
+            NetworkInfo::testnet().network_id(),
+            &change_cred,
+            &stake_cred,
+        )
+            .to_address();
+
+        let added_change = tx_builder.add_change_if_needed(&change_addr);
+        assert!(added_change.is_err());
+    }
+
     #[ignore]
     #[test]
     fn build_tx_with_native_assets_change() {

rust/src/utils.rs

@@ -13,6 +13,7 @@ use std::{
     io::{BufRead, Seek, Write},
     ops::{Rem, Sub},
 };
+use std::fmt::Display;
 use itertools::Itertools;
 
 use super::*;
@@ -1702,6 +1703,63 @@ pub(crate) fn opt64<T>(o: &Option<T>) -> u64 {
     o.is_some() as u64
 }
 
+pub struct ValueShortage {
+    pub(crate) ada_shortage: Option<(Coin, Coin, Coin)>,
+    pub(crate) asset_shortage: Vec<(PolicyID, AssetName, Coin, Coin)>,
+}
+
+impl Display for ValueShortage {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "shortage: {{")?;
+        if let Some((input_data, out_data, fee)) = self.ada_shortage {
+            writeln!(f, "ada in inputs: {}, ada in outputs: {}, fee {}", input_data, out_data, fee)?;
+            writeln!(f, "NOTE! \"ada in inputs\" must be >= (\"ada in outputs\" + fee) before adding change")?;
+            writeln!(f, "and  \"ada in inputs\" must be == (\"ada in outputs\" + fee) after adding change")?;
+        }
+        for (policy_id, asset_name, asset_shortage, asset_available) in
+            &self.asset_shortage
+        {
+            write!(f, "policy id: \"{}\", asset name: \"{}\" ", policy_id, asset_name)?;
+            writeln!(f, "coins in inputs: {}, coins in outputs: {}", asset_shortage, asset_available)?;
+        }
+        write!(f, " }}")
+    }
+}
+
+pub(crate) fn get_input_shortage(all_inputs_value: &Value, all_outputs_value: &Value, fee: &Coin)
+    -> Result<Option<ValueShortage>, JsError> {
+    let mut shortage = ValueShortage{
+        ada_shortage: None,
+        asset_shortage: Vec::new()};
+    if all_inputs_value.coin < all_outputs_value.coin.checked_add(fee)? {
+        shortage.ada_shortage = Some((
+            all_inputs_value.coin.clone(),
+            all_outputs_value.coin.clone(),
+            fee.clone()));
+    }
+
+    if let Some(policies) = &all_outputs_value.multiasset {
+        for (policy_id, assets) in &policies.0 {
+            for (asset_name, coins) in &assets.0 {
+                let inputs_coins = match &all_inputs_value.multiasset {
+                    Some(multiasset) => multiasset.get_asset(policy_id, asset_name),
+                    None => Coin::zero()
+                };
+
+                if inputs_coins < *coins {
+                    shortage.asset_shortage.push((policy_id.clone(), asset_name.clone(), inputs_coins, coins.clone()));
+                }
+            }
+        }
+    }
+
+    if shortage.ada_shortage.is_some() || shortage.asset_shortage.len() > 0 {
+        Ok(Some(shortage))
+    } else {
+        Ok(None)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;