waalge
/
aiken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tx simulate returns a vector of exbudgets now

This commit is contained in:
logicalmechanism 2023-08-16 12:00:23 -07:00 committed by Lucas
parent 8cf92ce8ed
commit 050c41c8dc
4 changed files with 126 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CHANGELOG.md
View File

@ -4,6 +4,8 @@
### Changed ### Changed
- **aiken-lang**: Tx Simulate now returns a list of execution budgets for each
redeemer instead of calculating the total units required to run all the scripts.
- **aiken-lang**: Now code gen uses a tree abstraction to build the Aiken - **aiken-lang**: Now code gen uses a tree abstraction to build the Aiken
Intermediary Representation. This now fixes quite a number of minor issues Intermediary Representation. This now fixes quite a number of minor issues
while making the code more maintainable. This is a large leap towards a stable while making the code more maintainable. This is a large leap towards a stable

12
crates/aiken/src/cmd/tx/simulate.rs
View File

@ -133,13 +133,15 @@ pub fn exec(
match result { match result {
Ok(redeemers) => { Ok(redeemers) => {
let total_budget_used = // this should allow N scripts to be
let total_budget_used: Vec<ExBudget> =
redeemers redeemers
.iter() .iter()
.fold(ExBudget { mem: 0, cpu: 0 }, |accum, curr| ExBudget { .map(|curr| ExBudget {
mem: accum.mem + curr.ex_units.mem as i64, mem: curr.ex_units.mem as i64,
cpu: accum.cpu + curr.ex_units.steps as i64, cpu: curr.ex_units.steps as i64,
}); })
.collect();
eprintln!("\n"); eprintln!("\n");
println!( println!(

3
crates/uplc/src/tx/eval.rs
View File

@ -377,7 +377,8 @@ fn get_tx_info_v2(
.map(|output| TxOut::V2(sort_tx_out_value(&output.into()))) .map(|output| TxOut::V2(sort_tx_out_value(&output.into())))
.collect(); .collect();
let fee = Value::Coin(body.fee); // let fee = Value::Coin(body.fee);
let fee = Value::Coin(0);
let mint = sort_mint(&body.mint.clone().unwrap_or(KeyValuePairs::Indef(vec![]))); let mint = sort_mint(&body.mint.clone().unwrap_or(KeyValuePairs::Indef(vec![])));

171
crates/uplc/src/tx/tests.rs
View File

@ -10,7 +10,7 @@ use crate::machine::cost_model::ExBudget;
use super::{eval_phase_two, ResolvedInput, SlotConfig}; use super::{eval_phase_two, ResolvedInput, SlotConfig};
#[test] #[test]
fn test_eval() { fn test_eval_0() {
/* /*
PlutusV2 PlutusV2
@ -252,23 +252,25 @@ fn test_eval() {
assert_eq!(redeemers.len(), 1); assert_eq!(redeemers.len(), 1);
let total_budget_used = let total_budget_used: Vec<ExBudget> =
redeemers redeemers
.iter() .iter()
.fold(ExBudget { mem: 0, cpu: 0 }, |accum, curr| ExBudget { .map(|curr| ExBudget {
mem: accum.mem + curr.ex_units.mem as i64, mem: curr.ex_units.mem as i64,
cpu: accum.cpu + curr.ex_units.steps as i64, cpu: curr.ex_units.steps as i64,
}); })
.collect();
println!("{total_budget_used:?}"); println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 747528, cpu: 217294271 },
];
assert_eq!( assert_eq!(
total_budget_used, total_budget_used,
// Numbers came uplc evaluate expected_budgets
ExBudget {
cpu: 217294271,
mem: 747528
}
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -523,23 +525,26 @@ fn test_eval_1() {
assert_eq!(redeemers.len(), 1); assert_eq!(redeemers.len(), 1);
let total_budget_used = let total_budget_used: Vec<ExBudget> =
redeemers redeemers
.iter() .iter()
.fold(ExBudget { mem: 0, cpu: 0 }, |accum, curr| ExBudget { .map(|curr| ExBudget {
mem: accum.mem + curr.ex_units.mem as i64, mem: curr.ex_units.mem as i64,
cpu: accum.cpu + curr.ex_units.steps as i64, cpu: curr.ex_units.steps as i64,
}); })
.collect();
println!("{total_budget_used:?}"); println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 738928, cpu: 215316271 },
];
assert_eq!( assert_eq!(
total_budget_used, total_budget_used,
// Numbers came uplc evaluate // Numbers came uplc evaluate
ExBudget { expected_budgets
cpu: 215316271,
mem: 738928
}
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -629,23 +634,26 @@ fn test_eval_2() {
assert_eq!(redeemers.len(), 1); assert_eq!(redeemers.len(), 1);
let total_budget_used = let total_budget_used: Vec<ExBudget> =
redeemers redeemers
.iter() .iter()
.fold(ExBudget { mem: 0, cpu: 0 }, |accum, curr| ExBudget { .map(|curr| ExBudget {
mem: accum.mem + curr.ex_units.mem as i64, mem: curr.ex_units.mem as i64,
cpu: accum.cpu + curr.ex_units.steps as i64, cpu: curr.ex_units.steps as i64,
}); })
.collect();
println!("{total_budget_used:?}"); println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 655782, cpu: 188449458 },
];
assert_eq!( assert_eq!(
total_budget_used, total_budget_used,
// Numbers came uplc evaluate // Numbers came uplc evaluate
ExBudget { expected_budgets
cpu: 188449458,
mem: 655782
}
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -894,23 +902,26 @@ fn test_eval_3() {
assert_eq!(redeemers.len(), 1); assert_eq!(redeemers.len(), 1);
let total_budget_used = let total_budget_used: Vec<ExBudget> =
redeemers redeemers
.iter() .iter()
.fold(ExBudget { mem: 0, cpu: 0 }, |accum, curr| ExBudget { .map(|curr| ExBudget {
mem: accum.mem + curr.ex_units.mem as i64, mem: curr.ex_units.mem as i64,
cpu: accum.cpu + curr.ex_units.steps as i64, cpu: curr.ex_units.steps as i64,
}); })
.collect();
println!("{total_budget_used:?}"); println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 583272, cpu: 182855351 },
];
assert_eq!( assert_eq!(
total_budget_used, total_budget_used,
// Numbers came uplc evaluate // Numbers came uplc evaluate
ExBudget { expected_budgets
cpu: 182855351,
mem: 583272
}
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -1080,23 +1091,26 @@ fn test_eval_5() {
assert_eq!(redeemers.len(), 1); assert_eq!(redeemers.len(), 1);
let total_budget_used = let total_budget_used: Vec<ExBudget> =
redeemers redeemers
.iter() .iter()
.fold(ExBudget { mem: 0, cpu: 0 }, |accum, curr| ExBudget { .map(|curr| ExBudget {
mem: accum.mem + curr.ex_units.mem as i64, mem: curr.ex_units.mem as i64,
cpu: accum.cpu + curr.ex_units.steps as i64, cpu: curr.ex_units.steps as i64,
}); })
.collect();
println!("{total_budget_used:?}"); println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 114126, cpu: 40098159 },
];
assert_eq!( assert_eq!(
total_budget_used, total_budget_used,
// Numbers came uplc evaluate // Numbers came uplc evaluate
ExBudget { expected_budgets
cpu: 40098159,
mem: 114126
}
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -1185,23 +1199,26 @@ fn test_eval_6() {
assert_eq!(redeemers.len(), 1); assert_eq!(redeemers.len(), 1);
let total_budget_used = let total_budget_used: Vec<ExBudget> =
redeemers redeemers
.iter() .iter()
.fold(ExBudget { mem: 0, cpu: 0 }, |accum, curr| ExBudget { .map(|curr| ExBudget {
mem: accum.mem + curr.ex_units.mem as i64, mem: curr.ex_units.mem as i64,
cpu: accum.cpu + curr.ex_units.steps as i64, cpu: curr.ex_units.steps as i64,
}); })
.collect();
println!("{total_budget_used:?}"); println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 4002, cpu: 6231248 },
];
assert_eq!( assert_eq!(
total_budget_used, total_budget_used,
// Numbers came uplc evaluate // Numbers came uplc evaluate
ExBudget { expected_budgets
cpu: 6231248,
mem: 4002
}
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -1290,23 +1307,26 @@ fn test_eval_7() {
assert_eq!(redeemers.len(), 1); assert_eq!(redeemers.len(), 1);
let total_budget_used = let total_budget_used: Vec<ExBudget> =
redeemers redeemers
.iter() .iter()
.fold(ExBudget { mem: 0, cpu: 0 }, |accum, curr| ExBudget { .map(|curr| ExBudget {
mem: accum.mem + curr.ex_units.mem as i64, mem: curr.ex_units.mem as i64,
cpu: accum.cpu + curr.ex_units.steps as i64, cpu: curr.ex_units.steps as i64,
}); })
.collect();
println!("{total_budget_used:?}"); println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 2954794, cpu: 1221507148 },
];
assert_eq!( assert_eq!(
total_budget_used, total_budget_used,
// Numbers came uplc evaluate // Numbers came uplc evaluate
ExBudget { expected_budgets
cpu: 1221507148,
mem: 2954794
}
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -1546,23 +1566,26 @@ fn test_eval_8() {
assert_eq!(redeemers.len(), 1); assert_eq!(redeemers.len(), 1);
let total_budget_used = let total_budget_used: Vec<ExBudget> =
redeemers redeemers
.iter() .iter()
.fold(ExBudget { mem: 0, cpu: 0 }, |accum, curr| ExBudget { .map(|curr| ExBudget {
mem: accum.mem + curr.ex_units.mem as i64, mem: curr.ex_units.mem as i64,
cpu: accum.cpu + curr.ex_units.steps as i64, cpu: curr.ex_units.steps as i64,
}); })
.collect();
println!("{total_budget_used:?}"); println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 2691678, cpu: 711173018 },
];
assert_eq!( assert_eq!(
total_budget_used, total_budget_used,
// Numbers came uplc evaluate // Numbers came uplc evaluate
ExBudget { expected_budgets
cpu: 711173018,
mem: 2691678
}
); );
} }
_ => unreachable!(), _ => unreachable!(),