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

chore: cargo fmt

This commit is contained in:
rvcas 2023-08-16 22:56:22 -04:00
parent b138cb0ccd
commit 2600937447
No known key found for this signature in database
GPG Key ID: C09B64E263F7D68C
2 changed files with 107 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -120,7 +120,7 @@ pub fn exec(
redeemer.index
)
};
let result = tx::eval_phase_two(
tx_babbage,
&resolved_inputs,
@ -134,14 +134,13 @@ pub fn exec(
match result {
Ok(redeemers) => {
// this should allow N scripts to be
let total_budget_used: Vec<ExBudget> =
redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
let total_budget_used: Vec<ExBudget> = redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
eprintln!("\n");
println!(

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

@ -251,27 +251,24 @@ fn test_eval_0() {
.unwrap();
assert_eq!(redeemers.len(), 1);
let total_budget_used: Vec<ExBudget> =
redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
let total_budget_used: Vec<ExBudget> = redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
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!(
total_budget_used,
expected_budgets
);
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![ExBudget {
mem: 747528,
cpu: 217294271,
}];
assert_eq!(total_budget_used, expected_budgets);
}
_ => unreachable!(),
};
@ -525,21 +522,21 @@ fn test_eval_1() {
assert_eq!(redeemers.len(), 1);
let total_budget_used: Vec<ExBudget> =
redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
let total_budget_used: Vec<ExBudget> = redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 738928, cpu: 215316271 },
];
let expected_budgets: Vec<ExBudget> = vec![ExBudget {
mem: 738928,
cpu: 215316271,
}];
assert_eq!(
total_budget_used,
@ -634,21 +631,21 @@ fn test_eval_2() {
assert_eq!(redeemers.len(), 1);
let total_budget_used: Vec<ExBudget> =
redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
let total_budget_used: Vec<ExBudget> = redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 655782, cpu: 188449458 },
];
let expected_budgets: Vec<ExBudget> = vec![ExBudget {
mem: 655782,
cpu: 188449458,
}];
assert_eq!(
total_budget_used,
@ -902,21 +899,21 @@ fn test_eval_3() {
assert_eq!(redeemers.len(), 1);
let total_budget_used: Vec<ExBudget> =
redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
let total_budget_used: Vec<ExBudget> = redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 583272, cpu: 182855351 },
];
let expected_budgets: Vec<ExBudget> = vec![ExBudget {
mem: 583272,
cpu: 182855351,
}];
assert_eq!(
total_budget_used,
@ -1091,21 +1088,21 @@ fn test_eval_5() {
assert_eq!(redeemers.len(), 1);
let total_budget_used: Vec<ExBudget> =
redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
let total_budget_used: Vec<ExBudget> = redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 114126, cpu: 40098159 },
];
let expected_budgets: Vec<ExBudget> = vec![ExBudget {
mem: 114126,
cpu: 40098159,
}];
assert_eq!(
total_budget_used,
@ -1199,21 +1196,21 @@ fn test_eval_6() {
assert_eq!(redeemers.len(), 1);
let total_budget_used: Vec<ExBudget> =
redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
let total_budget_used: Vec<ExBudget> = redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 4002, cpu: 6231248 },
];
let expected_budgets: Vec<ExBudget> = vec![ExBudget {
mem: 4002,
cpu: 6231248,
}];
assert_eq!(
total_budget_used,
@ -1307,21 +1304,21 @@ fn test_eval_7() {
assert_eq!(redeemers.len(), 1);
let total_budget_used: Vec<ExBudget> =
redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
let total_budget_used: Vec<ExBudget> = redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 2954794, cpu: 1221507148 },
];
let expected_budgets: Vec<ExBudget> = vec![ExBudget {
mem: 2954794,
cpu: 1221507148,
}];
assert_eq!(
total_budget_used,
@ -1566,21 +1563,21 @@ fn test_eval_8() {
assert_eq!(redeemers.len(), 1);
let total_budget_used: Vec<ExBudget> =
redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
let total_budget_used: Vec<ExBudget> = redeemers
.iter()
.map(|curr| ExBudget {
mem: curr.ex_units.mem as i64,
cpu: curr.ex_units.steps as i64,
})
.collect();
println!("{total_budget_used:?}");
// N scripts return an N length vector of ExBudgets
let expected_budgets: Vec<ExBudget> = vec![
ExBudget { mem: 2691678, cpu: 711173018 },
];
let expected_budgets: Vec<ExBudget> = vec![ExBudget {
mem: 2691678,
cpu: 711173018,
}];
assert_eq!(
total_budget_used,