Sulkta-OSS/pallas
3
0
Fork 0
Code Issues 1 Pull requests 4 Projects Releases Packages Wiki Activity Actions

refactor(applying): unify approach for protocol params access (#432)

Browse source
This commit is contained in:
Maico Leberle 2024-04-11 21:41:27 -03:00 • committed by GitHub
parent df3291bef5
commit fb8b7402fe
45 changed files with 2056 additions and 1520 deletions
Download patch file Download diff file Expand all files Collapse all files

25
pallas-applying/src/alonzo.rs
View file

@ -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));
}
}

25
pallas-applying/src/babbage.rs
View file

@ -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));
}
}

2
pallas-applying/src/byron.rs
View file

@ -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 {

11
pallas-applying/src/lib.rs
View file

@ -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,

16
pallas-applying/src/shelley_ma.rs
View file

@ -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(())

8
pallas-applying/src/utils.rs
View file

@ -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,
}
}

334
pallas-applying/src/utils/environment.rs
View file

@ -1,73 +1,289 @@
//! Types used for representing the environment required for validation in each
//! era.
use pallas_codec::minicbor::{self, Decode, Encode};
use pallas_primitives::{
alonzo::{
Coin, CostMdls, Epoch, ExUnitPrices, ExUnits, Nonce, ProtocolVersion, RationalNumber,
UnitInterval,
},
babbage::CostMdls as BabbageCostMdls,
};
#[derive(Debug, Clone, Encode, Decode)]
#[non_exhaustive]
pub enum MultiEraProtocolParameters {
#[n(0)]
Byron(#[n(1)] ByronProtParams),
#[n(2)]
Shelley(#[n(3)] ShelleyProtParams),
#[n(4)]
Alonzo(#[n(5)] AlonzoProtParams),
#[n(6)]
Babbage(#[n(7)] BabbageProtParams),
}
#[derive(Debug, Clone, Encode, Decode)]
pub struct ByronProtParams {
#[n(0)]
pub script_version: u16,
#[n(1)]
pub slot_duration: u64,
#[n(2)]
pub max_block_size: u64,
#[n(3)]
pub max_header_size: u64,
#[n(4)]
pub max_tx_size: u64,
#[n(5)]
pub max_proposal_size: u64,
#[n(6)]
pub mpc_thd: u64,
#[n(7)]
pub heavy_del_thd: u64,
#[n(8)]
pub update_vote_thd: u64,
#[n(9)]
pub update_proposal_thd: u64,
#[n(10)]
pub update_implicit: u64,
#[n(11)]
pub soft_fork_rule: (u64, u64, u64),
#[n(12)]
pub summand: u64,
#[n(13)]
pub multiplier: u64,
#[n(14)]
pub unlock_stake_epoch: u64,
}
#[derive(Debug, Clone, Encode, Decode)]
pub struct ShelleyProtParams {
#[n(0)]
pub minfee_a: u32,
#[n(1)]
pub minfee_b: u32,
#[n(2)]
pub max_block_body_size: u32,
#[n(3)]
pub max_transaction_size: u32,
#[n(4)]
pub max_block_header_size: u32,
#[n(5)]
pub key_deposit: Coin,
#[n(6)]
pub pool_deposit: Coin,
#[n(7)]
pub maximum_epoch: Epoch,
#[n(8)]
pub desired_number_of_stake_pools: u32,
#[n(9)]
pub pool_pledge_influence: RationalNumber,
#[n(10)]
pub expansion_rate: UnitInterval,
#[n(11)]
pub treasury_growth_rate: UnitInterval,
#[n(12)]
pub decentralization_constant: UnitInterval,
#[n(13)]
pub extra_entropy: Nonce,
#[n(14)]
pub protocol_version: ProtocolVersion,
#[n(15)]
pub min_utxo_value: Coin,
}
#[derive(Debug, Clone, Encode, Decode)]
pub struct AlonzoProtParams {
#[n(0)]
pub minfee_a: u32,
#[n(1)]
pub minfee_b: u32,
#[n(2)]
pub max_block_body_size: u32,
#[n(3)]
pub max_transaction_size: u32,
#[n(4)]
pub max_block_header_size: u32,
#[n(5)]
pub key_deposit: Coin,
#[n(6)]
pub pool_deposit: Coin,
#[n(7)]
pub maximum_epoch: Epoch,
#[n(8)]
pub desired_number_of_stake_pools: u32,
#[n(9)]
pub pool_pledge_influence: RationalNumber,
#[n(10)]
pub expansion_rate: UnitInterval,
#[n(11)]
pub treasury_growth_rate: UnitInterval,
#[n(12)]
pub decentralization_constant: UnitInterval,
#[n(13)]
pub extra_entropy: Nonce,
#[n(14)]
pub protocol_version: ProtocolVersion,
#[n(15)]
pub min_pool_cost: Coin,
#[n(16)]
pub ada_per_utxo_byte: Coin,
#[n(17)]
pub cost_models_for_script_languages: CostMdls,
#[n(18)]
pub execution_costs: ExUnitPrices,
#[n(19)]
pub max_tx_ex_units: ExUnits,
#[n(20)]
pub max_block_ex_units: ExUnits,
#[n(21)]
pub max_value_size: u32,
#[n(22)]
pub collateral_percentage: u32,
#[n(24)]
pub max_collateral_inputs: u32,
}
#[derive(Debug, Clone, Encode, Decode)]
pub struct BabbageProtParams {
#[n(0)]
pub minfee_a: u32,
#[n(1)]
pub minfee_b: u32,
#[n(2)]
pub max_block_body_size: u32,
#[n(3)]
pub max_transaction_size: u32,
#[n(4)]
pub max_block_header_size: u32,
#[n(5)]
pub key_deposit: Coin,
#[n(6)]
pub pool_deposit: Coin,
#[n(7)]
pub maximum_epoch: Epoch,
#[n(8)]
pub desired_number_of_stake_pools: u32,
#[n(9)]
pub pool_pledge_influence: RationalNumber,
#[n(10)]
pub expansion_rate: UnitInterval,
#[n(11)]
pub treasury_growth_rate: UnitInterval,
#[n(12)]
pub decentralization_constant: UnitInterval,
#[n(13)]
pub extra_entropy: Nonce,
#[n(14)]
pub protocol_version: ProtocolVersion,
#[n(15)]
pub min_pool_cost: Coin,
#[n(16)]
pub ada_per_utxo_byte: Coin,
#[n(17)]
pub cost_models_for_script_languages: BabbageCostMdls,
#[n(18)]
pub execution_costs: ExUnitPrices,
#[n(19)]
pub max_tx_ex_units: ExUnits,
#[n(20)]
pub max_block_ex_units: ExUnits,
#[n(21)]
pub max_value_size: u32,
#[n(22)]
pub collateral_percentage: u32,
#[n(24)]
pub max_collateral_inputs: u32,
}
#[derive(Debug)]
pub struct Environment {
pub prot_params: MultiEraProtParams,
pub prot_params: MultiEraProtocolParameters,
pub prot_magic: u32,
pub block_slot: u64,
pub network_id: u8,
}
// TODO: add variants for the other eras.
#[derive(Debug)]
#[non_exhaustive]
pub enum MultiEraProtParams {
Byron(ByronProtParams),
Shelley(ShelleyProtParams),
Alonzo(AlonzoProtParams),
Babbage(BabbageProtParams),
}
#[derive(Debug, Clone)]
pub struct ByronProtParams {
pub fee_policy: FeePolicy,
pub max_tx_size: u64,
}
#[derive(Debug, Clone)]
pub struct ShelleyProtParams {
pub fee_policy: FeePolicy,
pub max_tx_size: u64,
pub min_lovelace: u64,
}
#[derive(Debug, Clone)]
pub struct FeePolicy {
pub summand: u64,
pub multiplier: u64,
}
#[derive(Debug, Clone)]
pub struct AlonzoProtParams {
pub fee_policy: FeePolicy,
pub max_tx_size: u64,
pub max_block_ex_mem: u64,
pub max_block_ex_steps: u64,
pub max_tx_ex_mem: u32,
pub max_tx_ex_steps: u64,
pub max_val_size: u64,
pub collateral_percent: u64,
pub max_collateral_inputs: u64,
pub coins_per_utxo_word: u64,
}
#[derive(Debug, Clone)]
pub struct BabbageProtParams {
pub fee_policy: FeePolicy,
pub max_tx_size: u64,
pub max_block_ex_mem: u64,
pub max_block_ex_steps: u64,
pub max_tx_ex_mem: u32,
pub max_tx_ex_steps: u64,
pub max_val_size: u64,
pub collateral_percent: u64,
pub max_collateral_inputs: u64,
pub coins_per_utxo_word: u64,
}
impl Environment {
pub fn prot_params(&self) -> &MultiEraProtParams {
pub fn prot_params(&self) -> &MultiEraProtocolParameters {
&self.prot_params
}

1
pallas-applying/src/utils/validation.rs
View file

@ -4,6 +4,7 @@
#[non_exhaustive]
pub enum ValidationError {
TxAndProtParamsDiffer,
UnknownProtParams,
Byron(ByronError),
ShelleyMA(ShelleyMAError),
Alonzo(AlonzoError),