From 3bc3792aa3ebe0d85fa1abebd198df875c921f2a Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 21 May 2024 17:01:09 -0400 Subject: [PATCH] feat: add plutus version to aiken.toml relates to #907 --- crates/aiken-lang/src/gen_uplc.rs | 5 + crates/aiken-lang/src/lib.rs | 1 + crates/aiken-lang/src/plutus_version.rs | 51 ++++++ crates/aiken-project/src/blueprint/mod.rs | 11 +- crates/aiken-project/src/config.rs | 8 +- crates/aiken-project/src/lib.rs | 23 ++- crates/aiken-project/src/test_framework.rs | 130 +++++++++------ crates/aiken-project/src/tests/mod.rs | 2 + crates/aiken/src/cmd/blueprint/convert.rs | 1 + crates/uplc/src/ast.rs | 15 +- crates/uplc/src/machine.rs | 2 +- crates/uplc/src/machine/cost_model.rs | 182 ++++++++++++++++++++- crates/uplc/src/machine/runtime.rs | 2 +- crates/uplc/src/tx/eval.rs | 14 +- 14 files changed, 366 insertions(+), 81 deletions(-) create mode 100644 crates/aiken-lang/src/plutus_version.rs diff --git a/crates/aiken-lang/src/gen_uplc.rs b/crates/aiken-lang/src/gen_uplc.rs index dfd9a093..68047ee7 100644 --- a/crates/aiken-lang/src/gen_uplc.rs +++ b/crates/aiken-lang/src/gen_uplc.rs @@ -29,6 +29,7 @@ use crate::{ }, }, line_numbers::LineNumbers, + plutus_version::PlutusVersion, tipo::{ check_replaceable_opaque_type, convert_opaque_type, find_and_replace_generics, get_arg_type_name, get_generic_id_and_type, lookup_data_type_by_tipo, @@ -51,6 +52,8 @@ use uplc::{ #[derive(Clone)] pub struct CodeGenerator<'a> { + #[allow(dead_code)] + plutus_version: PlutusVersion, /// immutable index maps functions: IndexMap<&'a FunctionAccessKey, &'a TypedFunction>, data_types: IndexMap<&'a DataTypeKey, &'a TypedDataType>, @@ -75,6 +78,7 @@ impl<'a> CodeGenerator<'a> { } pub fn new( + plutus_version: PlutusVersion, functions: IndexMap<&'a FunctionAccessKey, &'a TypedFunction>, data_types: IndexMap<&'a DataTypeKey, &'a TypedDataType>, module_types: IndexMap<&'a str, &'a TypeInfo>, @@ -82,6 +86,7 @@ impl<'a> CodeGenerator<'a> { tracing: Tracing, ) -> Self { CodeGenerator { + plutus_version, functions, data_types, module_types, diff --git a/crates/aiken-lang/src/lib.rs b/crates/aiken-lang/src/lib.rs index 7c041339..5f52ceb7 100644 --- a/crates/aiken-lang/src/lib.rs +++ b/crates/aiken-lang/src/lib.rs @@ -12,6 +12,7 @@ pub mod gen_uplc; pub mod levenshtein; pub mod line_numbers; pub mod parser; +pub mod plutus_version; pub mod pretty; pub mod tipo; diff --git a/crates/aiken-lang/src/plutus_version.rs b/crates/aiken-lang/src/plutus_version.rs new file mode 100644 index 00000000..1980499f --- /dev/null +++ b/crates/aiken-lang/src/plutus_version.rs @@ -0,0 +1,51 @@ +use pallas::ledger::primitives::conway::Language; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Default, Deserialize, Serialize, Clone, Copy, PartialEq)] +#[serde(rename_all = "camelCase")] +pub enum PlutusVersion { + V1, + #[default] + V2, + V3, +} + +impl From for Language { + fn from(value: PlutusVersion) -> Self { + match value { + PlutusVersion::V1 => Language::PlutusV1, + PlutusVersion::V2 => Language::PlutusV2, + PlutusVersion::V3 => Language::PlutusV3, + } + } +} + +impl From<&PlutusVersion> for Language { + fn from(value: &PlutusVersion) -> Self { + match value { + PlutusVersion::V1 => Language::PlutusV1, + PlutusVersion::V2 => Language::PlutusV2, + PlutusVersion::V3 => Language::PlutusV3, + } + } +} + +impl From for PlutusVersion { + fn from(value: Language) -> Self { + match value { + Language::PlutusV1 => PlutusVersion::V2, + Language::PlutusV2 => PlutusVersion::V2, + Language::PlutusV3 => PlutusVersion::V3, + } + } +} + +impl PlutusVersion { + pub fn cardano_cli_type(&self) -> String { + match self { + PlutusVersion::V1 => "PlutusScriptV1".to_string(), + PlutusVersion::V2 => "PlutusScriptV2".to_string(), + PlutusVersion::V3 => "PlutusScriptV3".to_string(), + } + } +} diff --git a/crates/aiken-project/src/blueprint/mod.rs b/crates/aiken-project/src/blueprint/mod.rs index 51abee58..bf52026e 100644 --- a/crates/aiken-project/src/blueprint/mod.rs +++ b/crates/aiken-project/src/blueprint/mod.rs @@ -8,7 +8,7 @@ pub mod validator; pub use error::Error; use crate::{ - config::{self, Config}, + config::{self, Config, PlutusVersion}, module::CheckedModules, }; use aiken_lang::gen_uplc::CodeGenerator; @@ -44,13 +44,6 @@ pub struct Preamble { pub license: Option, } -#[derive(Debug, PartialEq, Clone, serde::Serialize, serde::Deserialize)] -#[serde(rename_all = "camelCase")] -pub enum PlutusVersion { - V1, - V2, -} - #[derive(Debug, PartialEq, Clone, serde::Serialize, serde::Deserialize)] #[serde(rename_all = "camelCase")] pub struct Compiler { @@ -151,7 +144,7 @@ impl From<&Config> for Preamble { name: "Aiken".to_string(), version: config::compiler_version(true), }), - plutus_version: PlutusVersion::V2, + plutus_version: config.plutus_version, version: config.version.clone(), license: config.license.clone(), } diff --git a/crates/aiken-project/src/config.rs b/crates/aiken-project/src/config.rs index b1d8b10a..17486a93 100644 --- a/crates/aiken-project/src/config.rs +++ b/crates/aiken-project/src/config.rs @@ -1,13 +1,18 @@ +use std::{fmt::Display, fs, io, path::Path}; + use crate::{github::repo::LatestRelease, package_name::PackageName, paths, Error}; use aiken_lang::ast::Span; + use miette::NamedSource; use serde::{Deserialize, Serialize}; -use std::{fmt::Display, fs, io, path::Path}; + +pub use aiken_lang::plutus_version::PlutusVersion; #[derive(Deserialize, Serialize, Clone)] pub struct Config { pub name: PackageName, pub version: String, + pub plutus_version: PlutusVersion, pub license: Option, #[serde(default)] pub description: String, @@ -53,6 +58,7 @@ impl Config { Config { name: name.clone(), version: "0.0.0".to_string(), + plutus_version: PlutusVersion::default(), license: Some("Apache-2.0".to_string()), description: format!("Aiken contracts for project '{name}'"), repository: Some(Repository { diff --git a/crates/aiken-project/src/lib.rs b/crates/aiken-project/src/lib.rs index 816fa0a4..d8536de2 100644 --- a/crates/aiken-project/src/lib.rs +++ b/crates/aiken-project/src/lib.rs @@ -35,10 +35,11 @@ use aiken_lang::{ DataTypeKey, Definition, FunctionAccessKey, ModuleKind, Tracing, TypedDataType, TypedFunction, }, - builtins::{self}, + builtins, expr::UntypedExpr, gen_uplc::CodeGenerator, line_numbers::LineNumbers, + plutus_version::PlutusVersion, tipo::{Type, TypeInfo}, IdGenerator, }; @@ -49,7 +50,7 @@ use options::{CodeGenMode, Options}; use package_name::PackageName; use pallas::ledger::{ addresses::{Address, Network, ShelleyAddress, ShelleyDelegationPart, StakePayload}, - primitives::babbage::{self as cardano, PolicyId}, + primitives::conway::{self as cardano, PolicyId}, traverse::ComputeHash, }; use std::{ @@ -141,6 +142,7 @@ where pub fn new_generator(&'_ self, tracing: Tracing) -> CodeGenerator<'_> { CodeGenerator::new( + self.config.plutus_version, utils::indexmap::as_ref_values(&self.functions), utils::indexmap::as_ref_values(&self.data_types), utils::indexmap::as_str_ref_values(&self.module_types), @@ -422,6 +424,7 @@ where } let n = validator.parameters.len(); + if n > 0 { Err(blueprint::error::Error::ParameterizedValidator { n }.into()) } else { @@ -460,7 +463,13 @@ where Err(blueprint::error::Error::ParameterizedValidator { n }.into()) } else { let cbor = validator.program.to_cbor().unwrap(); - let validator_hash = cardano::PlutusV2Script(cbor.into()).compute_hash(); + + let validator_hash = match self.config.plutus_version { + PlutusVersion::V1 => cardano::PlutusV1Script(cbor.into()).compute_hash(), + PlutusVersion::V2 => cardano::PlutusV2Script(cbor.into()).compute_hash(), + PlutusVersion::V3 => cardano::PlutusV3Script(cbor.into()).compute_hash(), + }; + Ok(validator_hash) } }) @@ -842,11 +851,15 @@ where let data_types = utils::indexmap::as_ref_values(&self.data_types); + let plutus_version = &self.config.plutus_version; + tests .into_par_iter() .map(|test| match test { - Test::UnitTest(unit_test) => unit_test.run(), - Test::PropertyTest(property_test) => property_test.run(seed, property_max_success), + Test::UnitTest(unit_test) => unit_test.run(plutus_version), + Test::PropertyTest(property_test) => { + property_test.run(seed, property_max_success, plutus_version) + } }) .collect::), PlutusData>>>() .into_iter() diff --git a/crates/aiken-project/src/test_framework.rs b/crates/aiken-project/src/test_framework.rs index fe327ef8..b3e44052 100644 --- a/crates/aiken-project/src/test_framework.rs +++ b/crates/aiken-project/src/test_framework.rs @@ -4,6 +4,7 @@ use aiken_lang::{ expr::{TypedExpr, UntypedExpr}, format::Formatter, gen_uplc::CodeGenerator, + plutus_version::PlutusVersion, tipo::{convert_opaque_type, Type}, }; use cryptoxide::{blake2b::Blake2b, digest::Digest}; @@ -171,10 +172,10 @@ pub struct UnitTest { unsafe impl Send for UnitTest {} impl UnitTest { - pub fn run(self) -> TestResult<(Constant, Rc), T> { + pub fn run(self, plutus_version: &PlutusVersion) -> TestResult<(Constant, Rc), T> { let mut eval_result = Program::::try_from(self.program.clone()) .unwrap() - .eval(ExBudget::max()); + .eval_version(ExBudget::max(), &plutus_version.into()); let success = !eval_result.failed(self.can_error); @@ -226,31 +227,40 @@ impl PropertyTest { /// Run a property test from a given seed. The property is run at most DEFAULT_MAX_SUCCESS times. It /// may stops earlier on failure; in which case a 'counterexample' is returned. - pub fn run(self, seed: u32, n: usize) -> TestResult { + pub fn run( + self, + seed: u32, + n: usize, + plutus_version: &PlutusVersion, + ) -> TestResult { let mut labels = BTreeMap::new(); let mut remaining = n; - let (traces, counterexample, iterations) = - match self.run_n_times(&mut remaining, Prng::from_seed(seed), &mut labels) { - Ok(None) => (Vec::new(), Ok(None), n), - Ok(Some(counterexample)) => ( - self.eval(&counterexample.value) - .logs() - .into_iter() - .filter(|s| PropertyTest::extract_label(s).is_none()) - .collect(), - Ok(Some(counterexample.value)), - n - remaining + 1, - ), - Err(FuzzerError { traces, uplc_error }) => ( - traces - .into_iter() - .filter(|s| PropertyTest::extract_label(s).is_none()) - .collect(), - Err(uplc_error), - 0, - ), - }; + let (traces, counterexample, iterations) = match self.run_n_times( + &mut remaining, + Prng::from_seed(seed), + &mut labels, + plutus_version, + ) { + Ok(None) => (Vec::new(), Ok(None), n), + Ok(Some(counterexample)) => ( + self.eval(&counterexample.value, plutus_version) + .logs() + .into_iter() + .filter(|s| PropertyTest::extract_label(s).is_none()) + .collect(), + Ok(Some(counterexample.value)), + n - remaining + 1, + ), + Err(FuzzerError { traces, uplc_error }) => ( + traces + .into_iter() + .filter(|s| PropertyTest::extract_label(s).is_none()) + .collect(), + Err(uplc_error), + 0, + ), + }; TestResult::PropertyTestResult(PropertyTestResult { test: self, @@ -266,28 +276,30 @@ impl PropertyTest { remaining: &mut usize, initial_prng: Prng, labels: &mut BTreeMap, + plutus_version: &'a PlutusVersion, ) -> Result>, FuzzerError> { let mut prng = initial_prng; let mut counterexample = None; while *remaining > 0 && counterexample.is_none() { - (prng, counterexample) = self.run_once(prng, labels)?; + (prng, counterexample) = self.run_once(prng, labels, plutus_version)?; *remaining -= 1; } Ok(counterexample) } - fn run_once( - &self, + fn run_once<'a>( + &'a self, prng: Prng, labels: &mut BTreeMap, - ) -> Result<(Prng, Option>), FuzzerError> { + plutus_version: &'a PlutusVersion, + ) -> Result<(Prng, Option>), FuzzerError> { let (next_prng, value) = prng .sample(&self.fuzzer.program)? .expect("A seeded PRNG returned 'None' which indicates a fuzzer is ill-formed and implemented wrongly; please contact library's authors."); - let mut result = self.eval(&value); + let mut result = self.eval(&value, plutus_version); for s in result.logs() { // NOTE: There may be other log outputs that interefere with labels. So *by @@ -313,7 +325,7 @@ impl PropertyTest { Err(..) => Status::Invalid, Ok(None) => Status::Invalid, Ok(Some((_, value))) => { - let result = self.eval(&value); + let result = self.eval(&value, plutus_version); let is_failure = result.failed(self.can_error); @@ -341,12 +353,12 @@ impl PropertyTest { } } - pub fn eval(&self, value: &PlutusData) -> EvalResult { + pub fn eval(&self, value: &PlutusData, plutus_version: &PlutusVersion) -> EvalResult { let program = self.program.apply_data(value.clone()); Program::::try_from(program) .unwrap() - .eval(ExBudget::max()) + .eval_version(ExBudget::max(), &plutus_version.into()) } fn extract_label(s: &str) -> Option { @@ -1255,8 +1267,8 @@ mod test { builtins, format::Formatter, line_numbers::LineNumbers, - parser, - parser::extra::ModuleExtra, + parser::{self, extra::ModuleExtra}, + plutus_version::PlutusVersion, IdGenerator, }; use indoc::indoc; @@ -1323,6 +1335,7 @@ mod test { ); let mut generator = CodeGenerator::new( + PlutusVersion::default(), utils::indexmap::as_ref_values(&functions), utils::indexmap::as_ref_values(&data_types), utils::indexmap::as_str_ref_values(&module_types), @@ -1454,10 +1467,15 @@ mod test { } impl PropertyTest { - fn expect_failure(&self) -> Counterexample { + fn expect_failure<'a>(&'a self, plutus_version: &'a PlutusVersion) -> Counterexample<'a> { let mut labels = BTreeMap::new(); let mut remaining = PropertyTest::DEFAULT_MAX_SUCCESS; - match self.run_n_times(&mut remaining, Prng::from_seed(42), &mut labels) { + match self.run_n_times( + &mut remaining, + Prng::from_seed(42), + &mut labels, + plutus_version, + ) { Ok(Some(counterexample)) => counterexample, _ => panic!("expected property to fail but it didn't."), } @@ -1473,7 +1491,11 @@ mod test { "#}); assert!(prop - .run::<()>(42, PropertyTest::DEFAULT_MAX_SUCCESS) + .run::<()>( + 42, + PropertyTest::DEFAULT_MAX_SUCCESS, + &PlutusVersion::default() + ) .is_success()); } @@ -1496,7 +1518,11 @@ mod test { } "#}); - match prop.run::<()>(42, PropertyTest::DEFAULT_MAX_SUCCESS) { + match prop.run::<()>( + 42, + PropertyTest::DEFAULT_MAX_SUCCESS, + &PlutusVersion::default(), + ) { TestResult::UnitTestResult(..) => unreachable!("property returned unit-test result ?!"), TestResult::PropertyTestResult(result) => { assert!( @@ -1519,7 +1545,8 @@ mod test { } "#}); - let mut counterexample = prop.expect_failure(); + let plutus_version = PlutusVersion::default(); + let mut counterexample = prop.expect_failure(&plutus_version); counterexample.simplify(); @@ -1546,7 +1573,8 @@ mod test { } "#}); - let mut counterexample = prop.expect_failure(); + let plutus_version = PlutusVersion::default(); + let mut counterexample = prop.expect_failure(&plutus_version); counterexample.simplify(); @@ -1562,7 +1590,8 @@ mod test { } "#}); - let mut counterexample = prop.expect_failure(); + let plutus_version = PlutusVersion::default(); + let mut counterexample = prop.expect_failure(&plutus_version); counterexample.simplify(); @@ -1589,7 +1618,8 @@ mod test { } "#}); - let mut counterexample = prop.expect_failure(); + let plutus_version = PlutusVersion::default(); + let mut counterexample = prop.expect_failure(&plutus_version); counterexample.simplify(); @@ -1616,7 +1646,8 @@ mod test { } "#}); - let mut counterexample = prop.expect_failure(); + let plutus_version = PlutusVersion::default(); + let mut counterexample = prop.expect_failure(&plutus_version); counterexample.simplify(); @@ -1646,7 +1677,8 @@ mod test { } "#}); - let mut counterexample = prop.expect_failure(); + let plutus_version = PlutusVersion::default(); + let mut counterexample = prop.expect_failure(&plutus_version); counterexample.simplify(); @@ -1680,7 +1712,9 @@ mod test { } "#}); - let mut counterexample = prop.expect_failure(); + let plutus_version = PlutusVersion::default(); + + let mut counterexample = prop.expect_failure(&plutus_version); counterexample.simplify(); @@ -1714,7 +1748,8 @@ mod test { } "#}); - let mut counterexample = prop.expect_failure(); + let plutus_version = PlutusVersion::default(); + let mut counterexample = prop.expect_failure(&plutus_version); counterexample.simplify(); @@ -1748,7 +1783,8 @@ mod test { } "#}); - let mut counterexample = prop.expect_failure(); + let plutus_version = PlutusVersion::default(); + let mut counterexample = prop.expect_failure(&plutus_version); counterexample.simplify(); diff --git a/crates/aiken-project/src/tests/mod.rs b/crates/aiken-project/src/tests/mod.rs index 5486dc16..94ddf664 100644 --- a/crates/aiken-project/src/tests/mod.rs +++ b/crates/aiken-project/src/tests/mod.rs @@ -12,6 +12,7 @@ use aiken_lang::{ gen_uplc::CodeGenerator, line_numbers::LineNumbers, parser, + plutus_version::PlutusVersion, tipo::TypeInfo, IdGenerator, }; @@ -60,6 +61,7 @@ impl TestProject { pub fn new_generator(&'_ self, tracing: Tracing) -> CodeGenerator<'_> { CodeGenerator::new( + PlutusVersion::default(), utils::indexmap::as_ref_values(&self.functions), utils::indexmap::as_ref_values(&self.data_types), utils::indexmap::as_str_ref_values(&self.module_types), diff --git a/crates/aiken/src/cmd/blueprint/convert.rs b/crates/aiken/src/cmd/blueprint/convert.rs index 0522b14f..934e621f 100644 --- a/crates/aiken/src/cmd/blueprint/convert.rs +++ b/crates/aiken/src/cmd/blueprint/convert.rs @@ -5,6 +5,7 @@ use std::{env, fs::File, io::BufReader, path::PathBuf, process}; use aiken_project::{ blueprint::{error::Error as BlueprintError, Blueprint}, + config::Config, error::Error as ProjectError, }; diff --git a/crates/uplc/src/ast.rs b/crates/uplc/src/ast.rs index ac438e24..c32e79d4 100644 --- a/crates/uplc/src/ast.rs +++ b/crates/uplc/src/ast.rs @@ -15,7 +15,7 @@ use pallas::ledger::{ addresses::{Network, ShelleyAddress, ShelleyDelegationPart, ShelleyPaymentPart}, primitives::{ alonzo::{self, Constr, PlutusData}, - babbage::{self, Language}, + conway::{self, Language}, }, traverse::ComputeHash, }; @@ -118,7 +118,7 @@ impl Serialize for Program { let cbor = self.to_cbor().unwrap(); let mut s = serializer.serialize_struct("Program", 2)?; s.serialize_field("compiledCode", &hex::encode(&cbor))?; - s.serialize_field("hash", &babbage::PlutusV2Script(cbor.into()).compute_hash())?; + s.serialize_field("hash", &conway::PlutusV2Script(cbor.into()).compute_hash())?; s.end() } } @@ -749,14 +749,9 @@ impl Program { EvalResult::new(term, machine.ex_budget, initial_budget, machine.logs) } - /// Evaluate a Program as PlutusV1 - pub fn eval_version(self, version: &Language) -> EvalResult { - let mut machine = Machine::new( - version.clone(), - CostModel::default(), - ExBudget::default(), - 200, - ); + /// Evaluate a Program as a specific PlutusVersion + pub fn eval_version(self, initial_budget: ExBudget, version: &Language) -> EvalResult { + let mut machine = Machine::new(version.clone(), CostModel::default(), initial_budget, 200); let term = machine.run(self.term); diff --git a/crates/uplc/src/machine.rs b/crates/uplc/src/machine.rs index dcca572c..9a30548a 100644 --- a/crates/uplc/src/machine.rs +++ b/crates/uplc/src/machine.rs @@ -11,7 +11,7 @@ pub mod value; use cost_model::{ExBudget, StepKind}; pub use error::Error; -use pallas::ledger::primitives::babbage::Language; +use pallas::ledger::primitives::conway::Language; use self::{ cost_model::CostModel, diff --git a/crates/uplc/src/machine/cost_model.rs b/crates/uplc/src/machine/cost_model.rs index ee418b96..88eddf42 100644 --- a/crates/uplc/src/machine/cost_model.rs +++ b/crates/uplc/src/machine/cost_model.rs @@ -1,6 +1,6 @@ use std::collections::HashMap; -use pallas::ledger::primitives::babbage::Language; +use pallas::ledger::primitives::conway::Language; use crate::builtins::DefaultFunction; @@ -2188,7 +2188,187 @@ pub fn initialize_cost_model(version: &Language, costs: &[i64]) -> CostModel { "verify_schnorr_secp256k1_signature-mem-arguments"=> costs[174] } } + Language::PlutusV3 => { + hashmap! { + "add_integer-cpu-arguments-intercept"=> costs[0], + "add_integer-cpu-arguments-slope"=> costs[1], + "add_integer-mem-arguments-intercept"=> costs[2], + "add_integer-mem-arguments-slope"=> costs[3], + "append_byte_string-cpu-arguments-intercept"=> costs[4], + "append_byte_string-cpu-arguments-slope"=> costs[5], + "append_byte_string-mem-arguments-intercept"=> costs[6], + "append_byte_string-mem-arguments-slope"=> costs[7], + "append_string-cpu-arguments-intercept"=> costs[8], + "append_string-cpu-arguments-slope"=> costs[9], + "append_string-mem-arguments-intercept"=> costs[10], + "append_string-mem-arguments-slope"=> costs[11], + "b_data-cpu-arguments"=> costs[12], + "b_data-mem-arguments"=> costs[13], + "blake2b_256-cpu-arguments-intercept"=> costs[14], + "blake2b_256-cpu-arguments-slope"=> costs[15], + "blake2b_256-mem-arguments"=> costs[16], + "cek_apply_cost-exBudgetCPU"=> costs[17], + "cek_apply_cost-exBudgetmem"=> costs[18], + "cek_builtin_cost-exBudgetCPU"=> costs[19], + "cek_builtin_cost-exBudgetmem"=> costs[20], + "cek_const_cost-exBudgetCPU"=> costs[21], + "cek_const_cost-exBudgetmem"=> costs[22], + "cek_delay_cost-exBudgetCPU"=> costs[23], + "cek_delay_cost-exBudgetmem"=> costs[24], + "cek_force_cost-exBudgetCPU"=> costs[25], + "cek_force_cost-exBudgetmem"=> costs[26], + "cek_lam_cost-exBudgetCPU"=> costs[27], + "cek_lam_cost-exBudgetmem"=> costs[28], + "cek_startup_cost-exBudgetCPU"=> costs[29], + "cek_startup_cost-exBudgetmem"=> costs[30], + "cek_var_cost-exBudgetCPU"=> costs[31], + "cek_var_cost-exBudgetmem"=> costs[32], + "choose_data-cpu-arguments"=> costs[33], + "choose_data-mem-arguments"=> costs[34], + "choose_list-cpu-arguments"=> costs[35], + "choose_list-mem-arguments"=> costs[36], + "choose_unit-cpu-arguments"=> costs[37], + "choose_unit-mem-arguments"=> costs[38], + "cons_byte_string-cpu-arguments-intercept"=> costs[39], + "cons_byte_string-cpu-arguments-slope"=> costs[40], + "cons_byte_string-mem-arguments-intercept"=> costs[41], + "cons_byte_string-mem-arguments-slope"=> costs[42], + "constr_data-cpu-arguments"=> costs[43], + "constr_data-mem-arguments"=> costs[44], + "decode_utf8-cpu-arguments-intercept"=> costs[45], + "decode_utf8-cpu-arguments-slope"=> costs[46], + "decode_utf8-mem-arguments-intercept"=> costs[47], + "decode_utf8-mem-arguments-slope"=> costs[48], + "divide_integer-cpu-arguments-constant"=> costs[49], + "divide_integer-cpu-arguments-model-arguments-intercept"=> costs[50], + "divide_integer-cpu-arguments-model-arguments-slope"=> costs[51], + "divide_integer-mem-arguments-intercept"=> costs[52], + "divide_integer-mem-arguments-minimum"=> costs[53], + "divide_integer-mem-arguments-slope"=> costs[54], + "encode_utf8-cpu-arguments-intercept"=> costs[55], + "encode_utf8-cpu-arguments-slope"=> costs[56], + "encode_utf8-mem-arguments-intercept"=> costs[57], + "encode_utf8-mem-arguments-slope"=> costs[58], + "equals_byte_string-cpu-arguments-constant"=> costs[59], + "equals_byte_string-cpu-arguments-intercept"=> costs[60], + "equals_byte_string-cpu-arguments-slope"=> costs[61], + "equals_byte_string-mem-arguments"=> costs[62], + "equals_data-cpu-arguments-intercept"=> costs[63], + "equals_data-cpu-arguments-slope"=> costs[64], + "equals_data-mem-arguments"=> costs[65], + "equals_integer-cpu-arguments-intercept"=> costs[66], + "equals_integer-cpu-arguments-slope"=> costs[67], + "equals_integer-mem-arguments"=> costs[68], + "equals_string-cpu-arguments-constant"=> costs[69], + "equals_string-cpu-arguments-intercept"=> costs[70], + "equals_string-cpu-arguments-slope"=> costs[71], + "equals_string-mem-arguments"=> costs[72], + "fst_pair-cpu-arguments"=> costs[73], + "fst_pair-mem-arguments"=> costs[74], + "head_list-cpu-arguments"=> costs[75], + "head_list-mem-arguments"=> costs[76], + "i_data-cpu-arguments"=> costs[77], + "i_data-mem-arguments"=> costs[78], + "if_then_else-cpu-arguments"=> costs[79], + "if_then_else-mem-arguments"=> costs[80], + "index_byte_string-cpu-arguments"=> costs[81], + "index_byte_string-mem-arguments"=> costs[82], + "length_of_byte_string-cpu-arguments"=> costs[83], + "length_of_byte_string-mem-arguments"=> costs[84], + "less_than_byte_string-cpu-arguments-intercept"=> costs[85], + "less_than_byte_string-cpu-arguments-slope"=> costs[86], + "less_than_byte_string-mem-arguments"=> costs[87], + "less_than_equals_byte_string-cpu-arguments-intercept"=> costs[88], + "less_than_equals_byte_string-cpu-arguments-slope"=> costs[89], + "less_than_equals_byte_string-mem-arguments"=> costs[90], + "less_than_equals_integer-cpu-arguments-intercept"=> costs[91], + "less_than_equals_integer-cpu-arguments-slope"=> costs[92], + "less_than_equals_integer-mem-arguments"=> costs[93], + "less_than_integer-cpu-arguments-intercept"=> costs[94], + "less_than_integer-cpu-arguments-slope"=> costs[95], + "less_than_integer-mem-arguments"=> costs[96], + "list_data-cpu-arguments"=> costs[97], + "list_data-mem-arguments"=> costs[98], + "map_data-cpu-arguments"=> costs[99], + "map_data-mem-arguments"=> costs[100], + "mk_cons-cpu-arguments"=> costs[101], + "mk_cons-mem-arguments"=> costs[102], + "mk_nil_data-cpu-arguments"=> costs[103], + "mk_nil_data-mem-arguments"=> costs[104], + "mk_nil_pair_data-cpu-arguments"=> costs[105], + "mk_nil_pair_data-mem-arguments"=> costs[106], + "mk_pair_data-cpu-arguments"=> costs[107], + "mk_pair_data-mem-arguments"=> costs[108], + "mod_integer-cpu-arguments-constant"=> costs[109], + "mod_integer-cpu-arguments-model-arguments-intercept"=> costs[110], + "mod_integer-cpu-arguments-model-arguments-slope"=> costs[111], + "mod_integer-mem-arguments-intercept"=> costs[112], + "mod_integer-mem-arguments-minimum"=> costs[113], + "mod_integer-mem-arguments-slope"=> costs[114], + "multiply_integer-cpu-arguments-intercept"=> costs[115], + "multiply_integer-cpu-arguments-slope"=> costs[116], + "multiply_integer-mem-arguments-intercept"=> costs[117], + "multiply_integer-mem-arguments-slope"=> costs[118], + "null_list-cpu-arguments"=> costs[119], + "null_list-mem-arguments"=> costs[120], + "quotient_integer-cpu-arguments-constant"=> costs[121], + "quotient_integer-cpu-arguments-model-arguments-intercept"=> costs[122], + "quotient_integer-cpu-arguments-model-arguments-slope"=> costs[123], + "quotient_integer-mem-arguments-intercept"=> costs[124], + "quotient_integer-mem-arguments-minimum"=> costs[125], + "quotient_integer-mem-arguments-slope"=> costs[126], + "remainder_integer-cpu-arguments-constant"=> costs[127], + "remainder_integer-cpu-arguments-model-arguments-intercept"=> costs[128], + "remainder_integer-cpu-arguments-model-arguments-slope"=> costs[129], + "remainder_integer-mem-arguments-intercept"=> costs[130], + "remainder_integer-mem-arguments-minimum"=> costs[131], + "remainder_integer-mem-arguments-slope"=> costs[132], + "serialise_data-cpu-arguments-intercept"=> costs[133], + "serialise_data-cpu-arguments-slope"=> costs[134], + "serialise_data-mem-arguments-intercept"=> costs[135], + "serialise_data-mem-arguments-slope"=> costs[136], + "sha2_256-cpu-arguments-intercept"=> costs[137], + "sha2_256-cpu-arguments-slope"=> costs[138], + "sha2_256-mem-arguments"=> costs[139], + "sha3_256-cpu-arguments-intercept"=> costs[140], + "sha3_256-cpu-arguments-slope"=> costs[141], + "sha3_256-mem-arguments"=> costs[142], + "slice_byte_string-cpu-arguments-intercept"=> costs[143], + "slice_byte_string-cpu-arguments-slope"=> costs[144], + "slice_byte_string-mem-arguments-intercept"=> costs[145], + "slice_byte_string-mem-arguments-slope"=> costs[146], + "snd_pair-cpu-arguments"=> costs[147], + "snd_pair-mem-arguments"=> costs[148], + "subtract_integer-cpu-arguments-intercept"=> costs[149], + "subtract_integer-cpu-arguments-slope"=> costs[150], + "subtract_integer-mem-arguments-intercept"=> costs[151], + "subtract_integer-mem-arguments-slope"=> costs[152], + "tail_list-cpu-arguments"=> costs[153], + "tail_list-mem-arguments"=> costs[154], + "trace-cpu-arguments"=> costs[155], + "trace-mem-arguments"=> costs[156], + "un_b_data-cpu-arguments"=> costs[157], + "un_b_data-mem-arguments"=> costs[158], + "un_constr_data-cpu-arguments"=> costs[159], + "un_constr_data-mem-arguments"=> costs[160], + "un_i_data-cpu-arguments"=> costs[161], + "un_i_data-mem-arguments"=> costs[162], + "un_list_data-cpu-arguments"=> costs[163], + "un_list_data-mem-arguments"=> costs[164], + "un_map_data-cpu-arguments"=> costs[165], + "un_map_data-mem-arguments"=> costs[166], + "verify_ecdsa_secp256k1_signature-cpu-arguments"=> costs[167], + "verify_ecdsa_secp256k1_signature-mem-arguments"=> costs[168], + "verify_ed25519_signature-cpu-arguments-intercept"=> costs[169], + "verify_ed25519_signature-cpu-arguments-slope"=> costs[170], + "verify_ed25519_signature-mem-arguments"=> costs[171], + "verify_schnorr_secp256k1_signature-cpu-arguments-intercept"=> costs[172], + "verify_schnorr_secp256k1_signature-cpu-arguments-slope"=> costs[173], + "verify_schnorr_secp256k1_signature-mem-arguments"=> costs[174] + } + } }; + CostModel { machine_costs: MachineCosts { startup: ExBudget { diff --git a/crates/uplc/src/machine/runtime.rs b/crates/uplc/src/machine/runtime.rs index 0de93e88..f7ded319 100644 --- a/crates/uplc/src/machine/runtime.rs +++ b/crates/uplc/src/machine/runtime.rs @@ -4,7 +4,7 @@ use num_bigint::BigInt; use num_integer::Integer; use num_traits::{Signed, Zero}; use once_cell::sync::Lazy; -use pallas::ledger::primitives::babbage::{Language, PlutusData}; +use pallas::ledger::primitives::conway::{Language, PlutusData}; use crate::{ ast::{Constant, Data, Type}, diff --git a/crates/uplc/src/tx/eval.rs b/crates/uplc/src/tx/eval.rs index 75a3560d..b061fe96 100644 --- a/crates/uplc/src/tx/eval.rs +++ b/crates/uplc/src/tx/eval.rs @@ -9,15 +9,17 @@ use pallas::{ ledger::{ addresses::{Address, ScriptHash, StakePayload}, primitives::babbage::{ - Certificate, CostMdls, DatumHash, DatumOption, ExUnits, Language, Mint, MintedTx, - NativeScript, PlutusV1Script, PlutusV2Script, PolicyId, PseudoScript, Redeemer, - RedeemerTag, RewardAccount, StakeCredential, TransactionInput, TransactionOutput, - Value, Withdrawals, + Certificate, CostMdls, DatumHash, DatumOption, ExUnits, Mint, MintedTx, NativeScript, + PlutusV1Script, PlutusV2Script, PolicyId, PseudoScript, Redeemer, RedeemerTag, + RewardAccount, StakeCredential, TransactionInput, TransactionOutput, Value, + Withdrawals, }, traverse::{ComputeHash, OriginalHash}, }, }; +use pallas::ledger::primitives::conway::Language; + use std::{cmp::Ordering, collections::HashMap, convert::TryInto, ops::Deref, vec}; use super::{ @@ -761,7 +763,7 @@ pub fn eval_redeemer( program.eval_as(&Language::PlutusV1, costs, Some(initial_budget)) } else { - program.eval_version(&Language::PlutusV1) + program.eval_version(ExBudget::default(), &Language::PlutusV1) }; let cost = eval_result.cost(); @@ -861,7 +863,7 @@ pub fn eval_redeemer( program.eval_as(&Language::PlutusV1, costs, Some(initial_budget)) } else { - program.eval_version(&Language::PlutusV1) + program.eval_version(ExBudget::default(), &Language::PlutusV1) }; let cost = eval_result.cost();