fix: multi era protocol parameters

pallas-applying/src/alonzo.rs

@@ -6,7 +6,7 @@ use crate::utils::{
  get_network_id_value, get_payment_part, get_shelley_address, get_val_size_in_words,
  mk_alonzo_vk_wits_check_list, values_are_equal, verify_signature,
  AlonzoError::*,
- AlonzoProtParams, FeePolicy, UTxOs,
+ AlonzoProtParams, UTxOs,
  ValidationError::{self, *},
  ValidationResult,
 };
@@ -36,7 +36,7 @@ pub fn validate_alonzo_tx(
  network_id: &u8,
 ) -> ValidationResult {
  let tx_body: &TransactionBody = &mtx.transaction_body;
- let size: &u64 = &get_alonzo_comp_tx_size(tx_body).ok_or(Alonzo(UnknownTxSize))?;
+ let size: &u32 = &get_alonzo_comp_tx_size(tx_body).ok_or(Alonzo(UnknownTxSize))?;
  check_ins_not_empty(tx_body)?;
  check_ins_and_collateral_in_utxos(tx_body, utxos)?;
  check_tx_validity_interval(tx_body, mtx, block_slot)?;
@@ -131,7 +131,7 @@ fn check_upper_bound(
 
 fn check_fee(
  tx_body: &TransactionBody,
- size: &u64,
+ size: &u32,
  mtx: &MintedTx,
  utxos: &UTxOs,
  prot_pps: &AlonzoProtParams,
@@ -147,11 +147,10 @@ fn check_fee(
 // minimum fee.
 fn check_min_fee(
  tx_body: &TransactionBody,
- size: &u64,
+ size: &u32,
  prot_pps: &AlonzoProtParams,
 ) -> ValidationResult {
- let fee_policy: &FeePolicy = &prot_pps.fee_policy;
- if tx_body.fee < fee_policy.summand + fee_policy.multiplier * size {
+ if tx_body.fee < (prot_pps.minfee_b + prot_pps.minfee_a * size) as u64 {
  return Err(Alonzo(FeeBelowMin));
  }
  Ok(())
@@ -185,7 +184,7 @@ fn check_collaterals_number(
  collaterals: &[TransactionInput],
  prot_pps: &AlonzoProtParams,
 ) -> ValidationResult {
- let number_collateral: u64 = collaterals.len() as u64;
+ let number_collateral: u32 = collaterals.len() as u32;
  if number_collateral == 0 {
  Err(Alonzo(CollateralMissing))
  } else if number_collateral > prot_pps.max_collateral_inputs {
@@ -222,7 +221,7 @@ fn check_collaterals_assets(
  utxos: &UTxOs,
  prot_pps: &AlonzoProtParams,
 ) -> ValidationResult {
- let fee_percentage: u64 = tx_body.fee * prot_pps.collateral_percent;
+ let fee_percentage: u64 = tx_body.fee * prot_pps.collateral_percentage as u64;
  match &tx_body.collateral {
  Some(collaterals) => {
  for collateral in collaterals {
@@ -317,7 +316,7 @@ fn compute_min_lovelace(output: &TransactionOutput, prot_pps: &AlonzoProtParams)
  Some(_) => 37, // utxoEntrySizeWithoutVal (27) + dataHashSize (10)
  None => 27, // utxoEntrySizeWithoutVal
  };
- prot_pps.coins_per_utxo_word * output_entry_size
+ prot_pps.ada_per_utxo_byte * output_entry_size
 }
 
 // The size of the value in each of the outputs should not be greater than the
@@ -327,7 +326,7 @@ fn check_output_val_size(
  prot_pps: &AlonzoProtParams,
 ) -> ValidationResult {
  for output in tx_body.outputs.iter() {
- if get_val_size_in_words(&output.amount) > prot_pps.max_val_size {
+ if get_val_size_in_words(&output.amount) > prot_pps.max_value_size as u64 {
  return Err(Alonzo(MaxValSizeExceeded));
  }
  }
@@ -364,8 +363,8 @@ fn check_tx_network_id(tx_body: &TransactionBody, network_id: &u8) -> Validation
 }
 
 // The transaction size does not exceed the protocol limit.
-fn check_tx_size(size: &u64, prot_pps: &AlonzoProtParams) -> ValidationResult {
- if *size > prot_pps.max_tx_size {
+fn check_tx_size(size: &u32, prot_pps: &AlonzoProtParams) -> ValidationResult {
+ if *size > prot_pps.max_transaction_size {
  return Err(Alonzo(MaxTxSizeExceeded));
  }
  Ok(())
@@ -384,7 +383,7 @@ fn check_tx_ex_units(mtx: &MintedTx, prot_pps: &AlonzoProtParams) -> ValidationR
  mem += ex_units.mem;
  steps += ex_units.steps;
  }
- if mem > prot_pps.max_tx_ex_mem || steps > prot_pps.max_tx_ex_steps {
+ if mem > prot_pps.max_tx_ex_units.mem || steps > prot_pps.max_tx_ex_units.steps {
  return Err(Alonzo(TxExUnitsExceeded));
  }
  }

pallas-applying/src/babbage.rs

@@ -7,7 +7,7 @@ use crate::utils::{
  get_val_size_in_words, is_byron_address, lovelace_diff_or_fail, mk_alonzo_vk_wits_check_list,
  values_are_equal, verify_signature,
  BabbageError::*,
- BabbageProtParams, FeePolicy, UTxOs,
+ BabbageProtParams, UTxOs,
  ValidationError::{self, *},
  ValidationResult,
 };
@@ -38,7 +38,7 @@ pub fn validate_babbage_tx(
  network_id: &u8,
 ) -> ValidationResult {
  let tx_body: &MintedTransactionBody = &mtx.transaction_body.clone();
- let size: &u64 = &get_babbage_tx_size(tx_body).ok_or(Babbage(UnknownTxSize))?;
+ let size: &u32 = &get_babbage_tx_size(tx_body).ok_or(Babbage(UnknownTxSize))?;
  check_ins_not_empty(tx_body)?;
  check_all_ins_in_utxos(tx_body, utxos)?;
  check_tx_validity_interval(tx_body, block_slot)?;
@@ -139,7 +139,7 @@ fn check_upper_bound(tx_body: &MintedTransactionBody, block_slot: u64) -> Valida
 
 fn check_fee(
  tx_body: &MintedTransactionBody,
- size: &u64,
+ size: &u32,
  mtx: &MintedTx,
  utxos: &UTxOs,
  prot_pps: &BabbageProtParams,
@@ -155,11 +155,10 @@ fn check_fee(
 // minimum fee.
 fn check_min_fee(
  tx_body: &MintedTransactionBody,
- size: &u64,
+ size: &u32,
  prot_pps: &BabbageProtParams,
 ) -> ValidationResult {
- let fee_policy: &FeePolicy = &prot_pps.fee_policy;
- if tx_body.fee < fee_policy.summand + fee_policy.multiplier * size {
+ if tx_body.fee < (prot_pps.minfee_b + prot_pps.minfee_a * size) as u64 {
  return Err(Babbage(FeeBelowMin));
  }
  Ok(())
@@ -200,7 +199,7 @@ fn check_collaterals_number(
 ) -> ValidationResult {
  if collaterals.is_empty() {
  Err(Babbage(CollateralMissing))
- } else if collaterals.len() > prot_pps.max_collateral_inputs as usize {
+ } else if collaterals.len() as u32 > prot_pps.max_collateral_inputs {
  Err(Babbage(TooManyCollaterals))
  } else {
  Ok(())
@@ -265,7 +264,7 @@ fn check_collaterals_assets(
  // The balance between collateral inputs and output contains only lovelace.
  let paid_collateral: u64 =
  lovelace_diff_or_fail(&coll_input, &coll_return, &Babbage(NonLovelaceCollateral))?;
- let fee_percentage: u64 = tx_body.fee * prot_pps.collateral_percent;
+ let fee_percentage: u64 = tx_body.fee * prot_pps.collateral_percentage as u64;
  // The balance is not lower than the minimum allowed.
  if paid_collateral * 100 < fee_percentage {
  return Err(Babbage(CollateralMinLovelace));
@@ -357,7 +356,7 @@ fn check_min_lovelace(
 }
 
 fn compute_min_lovelace(val: &Value, prot_pps: &BabbageProtParams) -> u64 {
- prot_pps.coins_per_utxo_word * (get_val_size_in_words(val) + 160)
+ prot_pps.ada_per_utxo_byte * (get_val_size_in_words(val) + 160)
 }
 
 // The size of the value in each of the outputs should not be greater than the
@@ -371,7 +370,7 @@ fn check_output_val_size(
  PseudoTransactionOutput::Legacy(output) => &output.amount,
  PseudoTransactionOutput::PostAlonzo(output) => &output.value,
  };
- if get_val_size_in_words(val) > prot_pps.max_val_size {
+ if get_val_size_in_words(val) > prot_pps.max_value_size as u64 {
  return Err(Babbage(MaxValSizeExceeded));
  }
  }
@@ -409,8 +408,8 @@ fn check_tx_network_id(tx_body: &MintedTransactionBody, network_id: &u8) -> Vali
  Ok(())
 }
 
-fn check_tx_size(size: &u64, prot_pps: &BabbageProtParams) -> ValidationResult {
- if *size > prot_pps.max_tx_size {
+fn check_tx_size(size: &u32, prot_pps: &BabbageProtParams) -> ValidationResult {
+ if *size > prot_pps.max_transaction_size {
  return Err(Babbage(MaxTxSizeExceeded));
  }
  Ok(())
@@ -427,7 +426,7 @@ fn check_tx_ex_units(mtx: &MintedTx, prot_pps: &BabbageProtParams) -> Validation
  mem += ex_units.mem;
  steps += ex_units.steps;
  }
- if mem > prot_pps.max_tx_ex_mem || steps > prot_pps.max_tx_ex_steps {
+ if mem > prot_pps.max_tx_ex_units.mem || steps > prot_pps.max_tx_ex_units.steps {
  return Err(Babbage(TxExUnitsExceeded));
  }
  }

pallas-applying/src/byron.rs

@@ -97,7 +97,7 @@ fn check_fees(tx: &Tx, size: &u64, utxos: &UTxOs, prot_pps: &ByronProtParams) ->
  outputs_balance += output.amount
  }
  let total_balance: u64 = inputs_balance - outputs_balance;
- let min_fees: u64 = prot_pps.fee_policy.summand + prot_pps.fee_policy.multiplier * size;
+ let min_fees: u64 = prot_pps.summand + prot_pps.multiplier * size;
  if total_balance < min_fees {
  Err(Byron(FeesBelowMin))
  } else {

pallas-applying/src/lib.rs

@@ -13,17 +13,18 @@ use pallas_traverse::{Era, MultiEraTx};
 use shelley_ma::validate_shelley_ma_tx;
 
 pub use utils::{
- Environment, MultiEraProtParams, UTxOs, ValidationError::TxAndProtParamsDiffer,
+ Environment, MultiEraProtocolParameters, UTxOs,
+ ValidationError::{TxAndProtParamsDiffer, UnknownProtParams},
  ValidationResult,
 };
 
 pub fn validate(metx: &MultiEraTx, utxos: &UTxOs, env: &Environment) -> ValidationResult {
  match env.prot_params() {
- MultiEraProtParams::Byron(bpp) => match metx {
+ MultiEraProtocolParameters::Byron(bpp) => match metx {
  MultiEraTx::Byron(mtxp) => validate_byron_tx(mtxp, utxos, bpp, env.prot_magic()),
  _ => Err(TxAndProtParamsDiffer),
  },
- MultiEraProtParams::Shelley(spp) => match metx {
+ MultiEraProtocolParameters::Shelley(spp) => match metx {
  MultiEraTx::AlonzoCompatible(mtx, Era::Shelley)
  | MultiEraTx::AlonzoCompatible(mtx, Era::Allegra)
  | MultiEraTx::AlonzoCompatible(mtx, Era::Mary) => validate_shelley_ma_tx(
@@ -36,13 +37,13 @@ pub fn validate(metx: &MultiEraTx, utxos: &UTxOs, env: &Environment) -> Validati
  ),
  _ => Err(TxAndProtParamsDiffer),
  },
- MultiEraProtParams::Alonzo(app) => match metx {
+ MultiEraProtocolParameters::Alonzo(app) => match metx {
  MultiEraTx::AlonzoCompatible(mtx, Era::Alonzo) => {
  validate_alonzo_tx(mtx, utxos, app, env.block_slot(), env.network_id())
  }
  _ => Err(TxAndProtParamsDiffer),
  },
- MultiEraProtParams::Babbage(bpp) => match metx {
+ MultiEraProtocolParameters::Babbage(bpp) => match metx {
  MultiEraTx::Babbage(mtx) => validate_babbage_tx(
  mtx,
  utxos,

pallas-applying/src/shelley_ma.rs

@@ -4,7 +4,6 @@ use crate::utils::{
  add_minted_value, add_values, aux_data_from_alonzo_minted_tx, empty_value,
  get_alonzo_comp_tx_size, get_lovelace_from_alonzo_val, get_payment_part, get_shelley_address,
  get_val_size_in_words, mk_alonzo_vk_wits_check_list, values_are_equal, verify_signature,
- FeePolicy,
  ShelleyMAError::*,
  ShelleyProtParams, UTxOs,
  ValidationError::{self, *},
@@ -32,7 +31,7 @@ pub fn validate_shelley_ma_tx(
 ) -> ValidationResult {
  let tx_body: &TransactionBody = &mtx.transaction_body;
  let tx_wits: &MintedWitnessSet = &mtx.transaction_witness_set;
- let size: &u64 = &get_alonzo_comp_tx_size(tx_body).ok_or(ShelleyMA(UnknownTxSize))?;
+ let size: &u32 = &get_alonzo_comp_tx_size(tx_body).ok_or(ShelleyMA(UnknownTxSize))?;
  check_ins_not_empty(tx_body)?;
  check_ins_in_utxos(tx_body, utxos)?;
  check_ttl(tx_body, block_slot)?;
@@ -75,8 +74,8 @@ fn check_ttl(tx_body: &TransactionBody, block_slot: &u64) -> ValidationResult {
  }
 }
 
-fn check_tx_size(size: &u64, prot_pps: &ShelleyProtParams) -> ValidationResult {
- if *size > prot_pps.max_tx_size {
+fn check_tx_size(size: &u32, prot_pps: &ShelleyProtParams) -> ValidationResult {
+ if *size > prot_pps.max_transaction_size {
  return Err(ShelleyMA(MaxTxSizeExceeded));
  }
  Ok(())
@@ -104,10 +103,10 @@ fn check_min_lovelace(
 
 fn compute_min_lovelace(output: &TransactionOutput, prot_pps: &ShelleyProtParams) -> u64 {
  match &output.amount {
- Value::Coin(_) => prot_pps.min_lovelace,
+ Value::Coin(_) => prot_pps.min_utxo_value,
  Value::Multiasset(lovelace, _) => {
  let utxo_entry_size: u64 = 27 + get_val_size_in_words(&output.amount);
- let coins_per_utxo_word: u64 = prot_pps.min_lovelace / 27;
+ let coins_per_utxo_word: u64 = prot_pps.min_utxo_value / 27;
  max(*lovelace, utxo_entry_size * coins_per_utxo_word)
  }
  }
@@ -174,11 +173,10 @@ fn get_produced(tx_body: &TransactionBody, era: &Era) -> Result<Value, Validatio
 
 fn check_fees(
  tx_body: &TransactionBody,
- size: &u64,
+ size: &u32,
  prot_pps: &ShelleyProtParams,
 ) -> ValidationResult {
- let fee_policy: &FeePolicy = &prot_pps.fee_policy;
- if tx_body.fee < fee_policy.summand + fee_policy.multiplier * size {
+ if tx_body.fee < (prot_pps.minfee_b + prot_pps.minfee_a * size) as u64 {
  return Err(ShelleyMA(FeesBelowMin));
  }
  Ok(())

pallas-applying/src/utils.rs

@@ -24,18 +24,18 @@ pub use validation::*;
 
 pub type UTxOs<'b> = HashMap<MultiEraInput<'b>, MultiEraOutput<'b>>;
 
-pub fn get_alonzo_comp_tx_size(tx_body: &TransactionBody) -> Option<u64> {
+pub fn get_alonzo_comp_tx_size(tx_body: &TransactionBody) -> Option<u32> {
  let mut buff: Vec<u8> = Vec::new();
  match encode(tx_body, &mut buff) {
- Ok(()) => Some(buff.len() as u64),
+ Ok(()) => Some(buff.len() as u32),
  Err(_) => None,
  }
 }
 
-pub fn get_babbage_tx_size(tx_body: &MintedTransactionBody) -> Option<u64> {
+pub fn get_babbage_tx_size(tx_body: &MintedTransactionBody) -> Option<u32> {
  let mut buff: Vec<u8> = Vec::new();
  match encode(tx_body, &mut buff) {
- Ok(()) => Some(buff.len() as u64),
+ Ok(()) => Some(buff.len() as u32),
  Err(_) => None,
  }
 }