From f848bad3f201cb98c5a84325576e32acb4e200d0 Mon Sep 17 00:00:00 2001 From: KtorZ Date: Fri, 9 Aug 2024 01:11:58 +0200 Subject: [PATCH] define UPLC machine default cost models for Plutus V3. --- crates/uplc/src/machine/cost_model.rs | 1046 ++++++++++++++++++++----- 1 file changed, 853 insertions(+), 193 deletions(-) diff --git a/crates/uplc/src/machine/cost_model.rs b/crates/uplc/src/machine/cost_model.rs index 2050c997..bd02cfb9 100644 --- a/crates/uplc/src/machine/cost_model.rs +++ b/crates/uplc/src/machine/cost_model.rs @@ -1,10 +1,7 @@ -use std::collections::HashMap; - -use pallas_primitives::conway::Language; - -use crate::builtins::DefaultFunction; - use super::Value; +use crate::builtins::DefaultFunction; +use pallas_primitives::conway::Language; +use std::collections::HashMap; macro_rules! hashmap { // map-like @@ -71,6 +68,20 @@ impl CostModel { builtin_costs: BuiltinCosts::v1(), } } + + pub fn v2() -> Self { + Self { + machine_costs: MachineCosts::v2(), + builtin_costs: BuiltinCosts::v2(), + } + } + + pub fn v3() -> Self { + Self { + machine_costs: MachineCosts::v3(), + builtin_costs: BuiltinCosts::v3(), + } + } } /// There's no entry for Error since we'll be exiting anyway; also, what would @@ -149,11 +160,8 @@ impl MachineCosts { }, } } -} -impl Default for MachineCosts { - /// Default is V2 - fn default() -> Self { + pub fn v2() -> Self { Self { startup: ExBudget { mem: 100, cpu: 100 }, var: ExBudget { @@ -195,6 +203,54 @@ impl Default for MachineCosts { }, } } + + pub fn v3() -> Self { + Self { + startup: ExBudget { mem: 100, cpu: 100 }, + var: ExBudget { + mem: 100, + cpu: 16000, + }, + constant: ExBudget { + mem: 100, + cpu: 16000, + }, + lambda: ExBudget { + mem: 100, + cpu: 16000, + }, + delay: ExBudget { + mem: 100, + cpu: 16000, + }, + force: ExBudget { + mem: 100, + cpu: 16000, + }, + apply: ExBudget { + mem: 100, + cpu: 16000, + }, + builtin: ExBudget { + mem: 100, + cpu: 16000, + }, + constr: ExBudget { + mem: 100, + cpu: 16000, + }, + case: ExBudget { + mem: 100, + cpu: 16000, + }, + } + } +} + +impl Default for MachineCosts { + fn default() -> Self { + MachineCosts::v3() + } } #[derive(Debug, PartialEq)] @@ -316,7 +372,6 @@ impl BuiltinCosts { intercept: 0, slope: 1, }), - cpu: TwoArguments::AddedSizes(AddedSizes { intercept: 69522, slope: 11687, @@ -669,7 +724,6 @@ impl BuiltinCosts { slope: 30000000000, }), }, - bls12_381_g1_add: CostingFun { cpu: TwoArguments::ConstantCost(30000000000), mem: TwoArguments::ConstantCost(30000000000), @@ -760,11 +814,8 @@ impl BuiltinCosts { }, } } -} -impl Default for BuiltinCosts { - /// Default is V2 - fn default() -> Self { + pub fn v2() -> Self { Self { add_integer: CostingFun { mem: TwoArguments::MaxSize(MaxSize { @@ -791,7 +842,6 @@ impl Default for BuiltinCosts { intercept: 0, slope: 1, }), - cpu: TwoArguments::AddedSizes(AddedSizes { intercept: 69522, slope: 11687, @@ -1242,6 +1292,540 @@ impl Default for BuiltinCosts { }, } } + + pub fn v3() -> Self { + Self { + add_integer: CostingFun { + mem: TwoArguments::MaxSize(MaxSize { + intercept: 1, + slope: 1, + }), + cpu: TwoArguments::MaxSize(MaxSize { + intercept: 100788, + slope: 420, + }), + }, + subtract_integer: CostingFun { + mem: TwoArguments::MaxSize(MaxSize { + intercept: 1, + slope: 1, + }), + cpu: TwoArguments::MaxSize(MaxSize { + intercept: 100788, + slope: 420, + }), + }, + multiply_integer: CostingFun { + mem: TwoArguments::AddedSizes(AddedSizes { + intercept: 0, + slope: 1, + }), + cpu: TwoArguments::AddedSizes(AddedSizes { + intercept: 90434, + slope: 519, + }), + }, + // FIXME: Costing function for divide_integer has changed in v3 + // + // "divideInteger-cpu-arguments-constant": 85848, + // "divideInteger-cpu-arguments-model-arguments-c00": 123203, + // "divideInteger-cpu-arguments-model-arguments-c01": 7305, + // "divideInteger-cpu-arguments-model-arguments-c02": -900, + // "divideInteger-cpu-arguments-model-arguments-c10": 1716, + // "divideInteger-cpu-arguments-model-arguments-c11": 549, + // "divideInteger-cpu-arguments-model-arguments-c20": 57, + // "divideInteger-cpu-arguments-model-arguments-minimum": 85848, + // "divideInteger-memory-arguments-intercept": 0, + // "divideInteger-memory-arguments-minimum": 1, + // "divideInteger-memory-arguments-slope": 1, + divide_integer: CostingFun { + mem: TwoArguments::SubtractedSizes(SubtractedSizes { + intercept: 0, + slope: 1, + minimum: 1, + }), + cpu: TwoArguments::ConstAboveDiagonal(ConstantOrTwoArguments { + constant: 196500, + model: Box::new(TwoArguments::MultipliedSizes(MultipliedSizes { + intercept: 453240, + slope: 220, + })), + }), + }, + // FIXME Costing function for quotient_integer has changed in v3 + // + // "quotientInteger-cpu-arguments-constant": 85848, + // "quotientInteger-cpu-arguments-model-arguments-c00": 123203, + // "quotientInteger-cpu-arguments-model-arguments-c01": 7305, + // "quotientInteger-cpu-arguments-model-arguments-c02": -900, + // "quotientInteger-cpu-arguments-model-arguments-c10": 1716, + // "quotientInteger-cpu-arguments-model-arguments-c11": 549, + // "quotientInteger-cpu-arguments-model-arguments-c20": 57, + // "quotientInteger-cpu-arguments-model-arguments-minimum": 85848, + // "quotientInteger-memory-arguments-intercept": 0, + // "quotientInteger-memory-arguments-minimum": 1, + // "quotientInteger-memory-arguments-slope": 1, + quotient_integer: CostingFun { + mem: TwoArguments::SubtractedSizes(SubtractedSizes { + intercept: 0, + slope: 1, + minimum: 1, + }), + cpu: TwoArguments::ConstAboveDiagonal(ConstantOrTwoArguments { + constant: 196500, + model: Box::new(TwoArguments::MultipliedSizes(MultipliedSizes { + intercept: 453240, + slope: 220, + })), + }), + }, + // FIXME Costing function for remainder_integer has changed in v3 + // + // "remainderInteger-cpu-arguments-constant": 85848, + // "remainderInteger-cpu-arguments-model-arguments-c00": 123203, + // "remainderInteger-cpu-arguments-model-arguments-c01": 7305, + // "remainderInteger-cpu-arguments-model-arguments-c02": -900, + // "remainderInteger-cpu-arguments-model-arguments-c10": 1716, + // "remainderInteger-cpu-arguments-model-arguments-c11": 549, + // "remainderInteger-cpu-arguments-model-arguments-c20": 57, + // "remainderInteger-cpu-arguments-model-arguments-minimum": 85848, + // "remainderInteger-memory-arguments-intercept": 0, + // "remainderInteger-memory-arguments-slope": 1, + remainder_integer: CostingFun { + mem: TwoArguments::SubtractedSizes(SubtractedSizes { + intercept: 0, + slope: 1, + minimum: 1, + }), + cpu: TwoArguments::ConstAboveDiagonal(ConstantOrTwoArguments { + constant: 196500, + model: Box::new(TwoArguments::MultipliedSizes(MultipliedSizes { + intercept: 453240, + slope: 220, + })), + }), + }, + // FIXME: Costing function for mod_integer has changed in v3 + // + // "modInteger-cpu-arguments-constant": 85848, + // "modInteger-cpu-arguments-model-arguments-c00": 123203, + // "modInteger-cpu-arguments-model-arguments-c01": 7305, + // "modInteger-cpu-arguments-model-arguments-c02": -900, + // "modInteger-cpu-arguments-model-arguments-c10": 1716, + // "modInteger-cpu-arguments-model-arguments-c11": 549, + // "modInteger-cpu-arguments-model-arguments-c20": 57, + // "modInteger-cpu-arguments-model-arguments-minimum": 85848, + // "modInteger-memory-arguments-intercept": 0, + // "modInteger-memory-arguments-slope": 1, + mod_integer: CostingFun { + mem: TwoArguments::SubtractedSizes(SubtractedSizes { + intercept: 0, + slope: 1, + minimum: 1, + }), + cpu: TwoArguments::ConstAboveDiagonal(ConstantOrTwoArguments { + constant: 196500, + model: Box::new(TwoArguments::MultipliedSizes(MultipliedSizes { + intercept: 453240, + slope: 220, + })), + }), + }, + equals_integer: CostingFun { + mem: TwoArguments::ConstantCost(1), + cpu: TwoArguments::MinSize(MinSize { + intercept: 51775, + slope: 558, + }), + }, + less_than_integer: CostingFun { + mem: TwoArguments::ConstantCost(1), + cpu: TwoArguments::MinSize(MinSize { + intercept: 44749, + slope: 541, + }), + }, + less_than_equals_integer: CostingFun { + mem: TwoArguments::ConstantCost(1), + cpu: TwoArguments::MinSize(MinSize { + intercept: 43285, + slope: 552, + }), + }, + append_byte_string: CostingFun { + mem: TwoArguments::AddedSizes(AddedSizes { + intercept: 0, + slope: 1, + }), + cpu: TwoArguments::AddedSizes(AddedSizes { + intercept: 1000, + slope: 173, + }), + }, + cons_byte_string: CostingFun { + mem: TwoArguments::AddedSizes(AddedSizes { + intercept: 0, + slope: 1, + }), + cpu: TwoArguments::LinearInY(LinearSize { + intercept: 72010, + slope: 178, + }), + }, + slice_byte_string: CostingFun { + mem: ThreeArguments::LinearInZ(LinearSize { + intercept: 4, + slope: 0, + }), + cpu: ThreeArguments::LinearInZ(LinearSize { + intercept: 20467, + slope: 0, + }), + }, + length_of_byte_string: CostingFun { + mem: OneArgument::ConstantCost(10), + cpu: OneArgument::ConstantCost(22100), + }, + index_byte_string: CostingFun { + mem: TwoArguments::ConstantCost(4), + cpu: TwoArguments::ConstantCost(13169), + }, + equals_byte_string: CostingFun { + mem: TwoArguments::ConstantCost(1), + cpu: TwoArguments::LinearOnDiagonal(ConstantOrLinear { + constant: 24548, + intercept: 29498, + slope: 38, + }), + }, + less_than_byte_string: CostingFun { + mem: TwoArguments::ConstantCost(1), + cpu: TwoArguments::MinSize(MinSize { + intercept: 28999, + slope: 74, + }), + }, + less_than_equals_byte_string: CostingFun { + mem: TwoArguments::ConstantCost(1), + cpu: TwoArguments::MinSize(MinSize { + intercept: 28999, + slope: 74, + }), + }, + sha2_256: CostingFun { + mem: OneArgument::ConstantCost(4), + cpu: OneArgument::LinearCost(LinearSize { + intercept: 270652, + slope: 22588, + }), + }, + sha3_256: CostingFun { + mem: OneArgument::ConstantCost(4), + cpu: OneArgument::LinearCost(LinearSize { + intercept: 1457325, + slope: 64566, + }), + }, + blake2b_256: CostingFun { + mem: OneArgument::ConstantCost(4), + cpu: OneArgument::LinearCost(LinearSize { + intercept: 201305, + slope: 8356, + }), + }, + verify_ed25519_signature: CostingFun { + mem: ThreeArguments::ConstantCost(10), + cpu: ThreeArguments::LinearInZ(LinearSize { + intercept: 53384111, + slope: 14333, + }), + }, + verify_ecdsa_secp256k1_signature: CostingFun { + mem: ThreeArguments::ConstantCost(10), + cpu: ThreeArguments::ConstantCost(43053543), + }, + verify_schnorr_secp256k1_signature: CostingFun { + mem: ThreeArguments::ConstantCost(10), + cpu: ThreeArguments::LinearInY(LinearSize { + intercept: 43574283, + slope: 26308, + }), + }, + append_string: CostingFun { + mem: TwoArguments::AddedSizes(AddedSizes { + intercept: 4, + slope: 1, + }), + cpu: TwoArguments::AddedSizes(AddedSizes { + intercept: 1000, + slope: 59957, + }), + }, + equals_string: CostingFun { + mem: TwoArguments::ConstantCost(1), + cpu: TwoArguments::LinearOnDiagonal(ConstantOrLinear { + constant: 39184, + intercept: 1000, + slope: 60594, + }), + }, + encode_utf8: CostingFun { + mem: OneArgument::LinearCost(LinearSize { + intercept: 4, + slope: 2, + }), + cpu: OneArgument::LinearCost(LinearSize { + intercept: 1000, + slope: 42921, + }), + }, + decode_utf8: CostingFun { + mem: OneArgument::LinearCost(LinearSize { + intercept: 4, + slope: 2, + }), + cpu: OneArgument::LinearCost(LinearSize { + intercept: 91189, + slope: 769, + }), + }, + if_then_else: CostingFun { + mem: ThreeArguments::ConstantCost(1), + cpu: ThreeArguments::ConstantCost(76049), + }, + choose_unit: CostingFun { + mem: TwoArguments::ConstantCost(4), + cpu: TwoArguments::ConstantCost(61462), + }, + trace: CostingFun { + mem: TwoArguments::ConstantCost(32), + cpu: TwoArguments::ConstantCost(59498), + }, + fst_pair: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(141895), + }, + snd_pair: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(141992), + }, + choose_list: CostingFun { + mem: ThreeArguments::ConstantCost(32), + cpu: ThreeArguments::ConstantCost(132994), + }, + mk_cons: CostingFun { + mem: TwoArguments::ConstantCost(32), + cpu: TwoArguments::ConstantCost(72362), + }, + head_list: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(83150), + }, + tail_list: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(81663), + }, + null_list: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(74433), + }, + choose_data: CostingFun { + mem: SixArguments::ConstantCost(32), + cpu: SixArguments::ConstantCost(94375), + }, + constr_data: CostingFun { + mem: TwoArguments::ConstantCost(32), + cpu: TwoArguments::ConstantCost(22151), + }, + map_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(68246), + }, + list_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(33852), + }, + i_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(15299), + }, + b_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(11183), + }, + un_constr_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(24588), + }, + un_map_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(24623), + }, + un_list_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(25933), + }, + un_i_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(20744), + }, + un_b_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(20142), + }, + equals_data: CostingFun { + mem: TwoArguments::ConstantCost(1), + cpu: TwoArguments::MinSize(MinSize { + intercept: 898148, + slope: 27279, + }), + }, + mk_pair_data: CostingFun { + mem: TwoArguments::ConstantCost(32), + cpu: TwoArguments::ConstantCost(11546), + }, + mk_nil_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(7243), + }, + mk_nil_pair_data: CostingFun { + mem: OneArgument::ConstantCost(32), + cpu: OneArgument::ConstantCost(7391), + }, + serialise_data: CostingFun { + mem: OneArgument::LinearCost(LinearSize { + intercept: 0, + slope: 2, + }), + cpu: OneArgument::LinearCost(LinearSize { + intercept: 955506, + slope: 213312, + }), + }, + blake2b_224: CostingFun { + cpu: OneArgument::LinearCost(LinearSize { + intercept: 207616, + slope: 8310, + }), + mem: OneArgument::ConstantCost(4), + }, + keccak_256: CostingFun { + cpu: OneArgument::LinearCost(LinearSize { + intercept: 2261318, + slope: 64571, + }), + mem: OneArgument::ConstantCost(4), + }, + bls12_381_g1_add: CostingFun { + cpu: TwoArguments::ConstantCost(962335), + mem: TwoArguments::ConstantCost(18), + }, + bls12_381_g1_neg: CostingFun { + cpu: OneArgument::ConstantCost(267929), + mem: OneArgument::ConstantCost(18), + }, + bls12_381_g1_scalar_mul: CostingFun { + cpu: TwoArguments::LinearInX(LinearSize { + intercept: 76433006, + slope: 8868, + }), + mem: TwoArguments::ConstantCost(18), + }, + bls12_381_g1_equal: CostingFun { + cpu: TwoArguments::ConstantCost(442008), + mem: TwoArguments::ConstantCost(1), + }, + bls12_381_g1_compress: CostingFun { + cpu: OneArgument::ConstantCost(2780678), + mem: OneArgument::ConstantCost(6), + }, + bls12_381_g1_uncompress: CostingFun { + cpu: OneArgument::ConstantCost(52948122), + mem: OneArgument::ConstantCost(18), + }, + bls12_381_g1_hash_to_group: CostingFun { + cpu: TwoArguments::LinearInX(LinearSize { + intercept: 52538055, + slope: 3756, + }), + mem: TwoArguments::ConstantCost(18), + }, + bls12_381_g2_add: CostingFun { + cpu: TwoArguments::ConstantCost(1995836), + mem: TwoArguments::ConstantCost(36), + }, + bls12_381_g2_neg: CostingFun { + cpu: OneArgument::ConstantCost(284546), + mem: OneArgument::ConstantCost(36), + }, + bls12_381_g2_scalar_mul: CostingFun { + cpu: TwoArguments::LinearInX(LinearSize { + intercept: 158221314, + slope: 26549, + }), + mem: TwoArguments::ConstantCost(36), + }, + bls12_381_g2_equal: CostingFun { + cpu: TwoArguments::ConstantCost(901022), + mem: TwoArguments::ConstantCost(1), + }, + bls12_381_g2_compress: CostingFun { + cpu: OneArgument::ConstantCost(3227919), + mem: OneArgument::ConstantCost(12), + }, + bls12_381_g2_uncompress: CostingFun { + cpu: OneArgument::ConstantCost(74698472), + mem: OneArgument::ConstantCost(36), + }, + bls12_381_g2_hash_to_group: CostingFun { + cpu: TwoArguments::LinearInX(LinearSize { + intercept: 166917843, + slope: 4307, + }), + mem: TwoArguments::ConstantCost(36), + }, + bls12_381_miller_loop: CostingFun { + cpu: TwoArguments::ConstantCost(254006273), + mem: TwoArguments::ConstantCost(72), + }, + bls12_381_mul_ml_result: CostingFun { + cpu: TwoArguments::ConstantCost(2174038), + mem: TwoArguments::ConstantCost(72), + }, + bls12_381_final_verify: CostingFun { + cpu: TwoArguments::ConstantCost(333849714), + mem: TwoArguments::ConstantCost(1), + }, + integer_to_byte_string: CostingFun { + cpu: ThreeArguments::QuadraticInZ(QuadraticFunction { + coeff_0: 1293828, + coeff_1: 28716, + coeff_2: 63, + }), + mem: ThreeArguments::LiteralInYorLinearInZ(LinearSize { + intercept: 0, + slope: 1, + }), + }, + byte_string_to_integer: CostingFun { + cpu: TwoArguments::QuadraticInY(QuadraticFunction { + coeff_0: 1006041, + coeff_1: 43623, + coeff_2: 251, + }), + mem: TwoArguments::LinearInY(LinearSize { + intercept: 0, + slope: 1, + }), + }, + } + } +} + +impl Default for BuiltinCosts { + fn default() -> Self { + BuiltinCosts::v3() + } } impl BuiltinCosts { @@ -2190,181 +2774,257 @@ pub fn initialize_cost_model(version: &Language, costs: &[i64]) -> CostModel { } 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] + "add_integer-cpu-arguments-intercept" => costs[0], + "add_integer-cpu-arguments-slope" => costs[1], + "add_integer-memory-arguments-intercept" => costs[2], + "add_integer-memory-arguments-slope" => costs[3], + "append_byte_string-cpu-arguments-intercept" => costs[4], + "append_byte_string-cpu-arguments-slope" => costs[5], + "append_byte_string-memory-arguments-intercept" => costs[6], + "append_byte_string-memory-arguments-slope" => costs[7], + "append_string-cpu-arguments-intercept" => costs[8], + "append_string-cpu-arguments-slope" => costs[9], + "append_string-memory-arguments-intercept" => costs[10], + "append_string-memory-arguments-slope" => costs[11], + "b_data-cpu-arguments" => costs[12], + "b_data-memory-arguments" => costs[13], + "blake2b_256-cpu-arguments-intercept" => costs[14], + "blake2b_256-cpu-arguments-slope" => costs[15], + "blake2b_256-memory-arguments" => costs[16], + "cek_apply_cost-exBudgetCPU" => costs[17], + "cek_apply_cost-exBudgetMemory" => costs[18], + "cek_builtin_cost-exBudgetCPU" => costs[19], + "cek_builtin_cost-exBudgetMemory" => costs[20], + "cek_const_cost-exBudgetCPU" => costs[21], + "cek_const_cost-exBudgetMemory" => costs[22], + "cek_delay_cost-exBudgetCPU" => costs[23], + "cek_delay_cost-exBudgetMemory" => costs[24], + "cek_force_cost-exBudgetCPU" => costs[25], + "cek_force_cost-exBudgetMemory" => costs[26], + "cek_lam_cost-exBudgetCPU" => costs[27], + "cek_lam_cost-exBudgetMemory" => costs[28], + "cek_startup_cost-exBudgetCPU" => costs[29], + "cek_startup_cost-exBudgetMemory" => costs[30], + "cek_var_cost-exBudgetCPU" => costs[31], + "cek_var_cost-exBudgetMemory" => costs[32], + "choose_data-cpu-arguments" => costs[33], + "choose_data-memory-arguments" => costs[34], + "choose_list-cpu-arguments" => costs[35], + "choose_list-memory-arguments" => costs[36], + "choose_unit-cpu-arguments" => costs[37], + "choose_unit-memory-arguments" => costs[38], + "cons_byte_string-cpu-arguments-intercept" => costs[39], + "cons_byte_string-cpu-arguments-slope" => costs[40], + "cons_byte_string-memory-arguments-intercept" => costs[41], + "cons_byte_string-memory-arguments-slope" => costs[42], + "constr_data-cpu-arguments" => costs[43], + "constr_data-memory-arguments" => costs[44], + "decode_utf8-cpu-arguments-intercept" => costs[45], + "decode_utf8-cpu-arguments-slope" => costs[46], + "decode_utf8-memory-arguments-intercept" => costs[47], + "decode_utf8-memory-arguments-slope" => costs[48], + "divide_integer-cpu-arguments-constant" => costs[49], + "divide_integer-cpu-arguments-model-arguments-c00" => costs[50], + "divide_integer-cpu-arguments-model-arguments-c01" => costs[51], + "divide_integer-cpu-arguments-model-arguments-c02" => costs[52], + "divide_integer-cpu-arguments-model-arguments-c10" => costs[53], + "divide_integer-cpu-arguments-model-arguments-c11" => costs[54], + "divide_integer-cpu-arguments-model-arguments-c20" => costs[55], + "divide_integer-cpu-arguments-model-arguments-minimum" => costs[56], + "divide_integer-memory-arguments-intercept" => costs[57], + "divide_integer-memory-arguments-minimum" => costs[58], + "divide_integer-memory-arguments-slope" => costs[59], + "encode_utf8-cpu-arguments-intercept" => costs[60], + "encode_utf8-cpu-arguments-slope" => costs[61], + "encode_utf8-memory-arguments-intercept" => costs[62], + "encode_utf8-memory-arguments-slope" => costs[63], + "equals_byte_string-cpu-arguments-constant" => costs[64], + "equals_byte_string-cpu-arguments-intercept" => costs[65], + "equals_byte_string-cpu-arguments-slope" => costs[66], + "equals_byte_string-memory-arguments" => costs[67], + "equals_data-cpu-arguments-intercept" => costs[68], + "equals_data-cpu-arguments-slope" => costs[69], + "equals_data-memory-arguments" => costs[70], + "equals_integer-cpu-arguments-intercept" => costs[71], + "equals_integer-cpu-arguments-slope" => costs[72], + "equals_integer-memory-arguments" => costs[73], + "equals_string-cpu-arguments-constant" => costs[74], + "equals_string-cpu-arguments-intercept" => costs[75], + "equals_string-cpu-arguments-slope" => costs[76], + "equals_string-memory-arguments" => costs[77], + "fst_pair-cpu-arguments" => costs[78], + "fst_pair-memory-arguments" => costs[79], + "head_list-cpu-arguments" => costs[80], + "head_list-memory-arguments" => costs[81], + "i_data-cpu-arguments" => costs[82], + "i_data-memory-arguments" => costs[83], + "if_then_else-cpu-arguments" => costs[84], + "if_then_else-memory-arguments" => costs[85], + "index_byte_string-cpu-arguments" => costs[86], + "index_byte_string-memory-arguments" => costs[87], + "length_of_byte_string-cpu-arguments" => costs[88], + "length_of_byte_string-memory-arguments" => costs[89], + "less_than_byte_string-cpu-arguments-intercept" => costs[90], + "less_than_byte_string-cpu-arguments-slope" => costs[91], + "less_than_byte_string-memory-arguments" => costs[92], + "less_than_equals_byte_string-cpu-arguments-intercept" => costs[93], + "less_than_equals_byte_string-cpu-arguments-slope" => costs[94], + "less_than_equals_byte_string-memory-arguments" => costs[95], + "less_than_equals_integer-cpu-arguments-intercept" => costs[96], + "less_than_equals_integer-cpu-arguments-slope" => costs[97], + "less_than_equals_integer-memory-arguments" => costs[98], + "less_than_integer-cpu-arguments-intercept" => costs[99], + "less_than_integer-cpu-arguments-slope" => costs[100], + "less_than_integer-memory-arguments" => costs[101], + "list_data-cpu-arguments" => costs[102], + "list_data-memory-arguments" => costs[103], + "map_data-cpu-arguments" => costs[104], + "map_data-memory-arguments" => costs[105], + "mk_cons-cpu-arguments" => costs[106], + "mk_cons-memory-arguments" => costs[107], + "mk_nil_data-cpu-arguments" => costs[108], + "mk_nil_data-memory-arguments" => costs[109], + "mk_nil_pair_data-cpu-arguments" => costs[110], + "mk_nil_pair_data-memory-arguments" => costs[111], + "mk_pair_data-cpu-arguments" => costs[112], + "mk_pair_data-memory-arguments" => costs[113], + "mod_integer-cpu-arguments-constant" => costs[114], + "mod_integer-cpu-arguments-model-arguments-c00" => costs[115], + "mod_integer-cpu-arguments-model-arguments-c01" => costs[116], + "mod_integer-cpu-arguments-model-arguments-c02" => costs[117], + "mod_integer-cpu-arguments-model-arguments-c10" => costs[118], + "mod_integer-cpu-arguments-model-arguments-c11" => costs[119], + "mod_integer-cpu-arguments-model-arguments-c20" => costs[120], + "mod_integer-cpu-arguments-model-arguments-minimum" => costs[121], + "mod_integer-memory-arguments-intercept" => costs[122], + "mod_integer-memory-arguments-slope" => costs[123], + "multiply_integer-cpu-arguments-intercept" => costs[124], + "multiply_integer-cpu-arguments-slope" => costs[125], + "multiply_integer-memory-arguments-intercept" => costs[126], + "multiply_integer-memory-arguments-slope" => costs[127], + "null_list-cpu-arguments" => costs[128], + "null_list-memory-arguments" => costs[129], + "quotient_integer-cpu-arguments-constant" => costs[130], + "quotient_integer-cpu-arguments-model-arguments-c00" => costs[131], + "quotient_integer-cpu-arguments-model-arguments-c01" => costs[132], + "quotient_integer-cpu-arguments-model-arguments-c02" => costs[133], + "quotient_integer-cpu-arguments-model-arguments-c10" => costs[134], + "quotient_integer-cpu-arguments-model-arguments-c11" => costs[135], + "quotient_integer-cpu-arguments-model-arguments-c20" => costs[136], + "quotient_integer-cpu-arguments-model-arguments-minimum" => costs[137], + "quotient_integer-memory-arguments-intercept" => costs[138], + "quotient_integer-memory-arguments-minimum" => costs[139], + "quotient_integer-memory-arguments-slope" => costs[140], + "remainder_integer-cpu-arguments-constant" => costs[141], + "remainder_integer-cpu-arguments-model-arguments-c00" => costs[142], + "remainder_integer-cpu-arguments-model-arguments-c01" => costs[143], + "remainder_integer-cpu-arguments-model-arguments-c02" => costs[144], + "remainder_integer-cpu-arguments-model-arguments-c10" => costs[145], + "remainder_integer-cpu-arguments-model-arguments-c11" => costs[146], + "remainder_integer-cpu-arguments-model-arguments-c20" => costs[147], + "remainder_integer-cpu-arguments-model-arguments-minimum" => costs[148], + "remainder_integer-memory-arguments-intercept" => costs[149], + "remainder_integer-memory-arguments-slope" => costs[150], + "serialise_data-cpu-arguments-intercept" => costs[151], + "serialise_data-cpu-arguments-slope" => costs[152], + "serialise_data-memory-arguments-intercept" => costs[153], + "serialise_data-memory-arguments-slope" => costs[154], + "sha2_256-cpu-arguments-intercept" => costs[155], + "sha2_256-cpu-arguments-slope" => costs[156], + "sha2_256-memory-arguments" => costs[157], + "sha3_256-cpu-arguments-intercept" => costs[158], + "sha3_256-cpu-arguments-slope" => costs[159], + "sha3_256-memory-arguments" => costs[160], + "slice_byte_string-cpu-arguments-intercept" => costs[161], + "slice_byte_string-cpu-arguments-slope" => costs[162], + "slice_byte_string-memory-arguments-intercept" => costs[163], + "slice_byte_string-memory-arguments-slope" => costs[164], + "snd_pair-cpu-arguments" => costs[165], + "snd_pair-memory-arguments" => costs[166], + "subtract_integer-cpu-arguments-intercept" => costs[167], + "subtract_integer-cpu-arguments-slope" => costs[168], + "subtract_integer-memory-arguments-intercept" => costs[169], + "subtract_integer-memory-arguments-slope" => costs[170], + "tail_list-cpu-arguments" => costs[171], + "tail_list-memory-arguments" => costs[172], + "trace-cpu-arguments" => costs[173], + "trace-memory-arguments" => costs[174], + "un_b_data-cpu-arguments" => costs[175], + "un_b_data-memory-arguments" => costs[176], + "un_constr_data-cpu-arguments" => costs[177], + "un_constr_data-memory-arguments" => costs[178], + "un_i_data-cpu-arguments" => costs[179], + "un_i_data-memory-arguments" => costs[180], + "un_list_data-cpu-arguments" => costs[181], + "un_list_data-memory-arguments" => costs[182], + "un_map_data-cpu-arguments" => costs[183], + "un_map_data-memory-arguments" => costs[184], + "verify_ecdsa_secp256k1_signature-cpu-arguments" => costs[185], + "verify_ecdsa_secp256k1_signature-memory-arguments" => costs[186], + "verify_ed25519_signature-cpu-arguments-intercept" => costs[187], + "verify_ed25519_signature-cpu-arguments-slope" => costs[188], + "verify_ed25519_signature-memory-arguments" => costs[189], + "verify_schnorr_secp256k1_signature-cpu-arguments-intercept" => costs[190], + "verify_schnorr_secp256k1_signature-cpu-arguments-slope" => costs[191], + "verify_schnorr_secp256k1_signature-memory-arguments" => costs[192], + "cek_constr_cost-exBudgetCPU" => costs[193], + "cek_constr_cost-exBudgetMemory" => costs[194], + "cek_case_cost-exBudgetCPU" => costs[195], + "cek_case_cost-exBudgetMemory" => costs[196], + "bls12_381_g1_add-cpu-arguments" => costs[197], + "bls12_381_g1_add-memory-arguments" => costs[198], + "bls12_381_g1_compress-cpu-arguments" => costs[199], + "bls12_381_g1_compress-memory-arguments" => costs[200], + "bls12_381_g1_equal-cpu-arguments" => costs[201], + "bls12_381_g1_equal-memory-arguments" => costs[202], + "bls12_381_g1_hash_to_group-cpu-arguments-intercept" => costs[203], + "bls12_381_g1_hash_to_group-cpu-arguments-slope" => costs[204], + "bls12_381_g1_hash_to_group-memory-arguments" => costs[205], + "bls12_381_g1_neg-cpu-arguments" => costs[206], + "bls12_381_g1_neg-memory-arguments" => costs[207], + "bls12_381_g1_scalar_mul-cpu-arguments-intercept" => costs[208], + "bls12_381_g1_scalar_mul-cpu-arguments-slope" => costs[209], + "bls12_381_g1_scalar_mul-memory-arguments" => costs[210], + "bls12_381_g1_uncompress-cpu-arguments" => costs[211], + "bls12_381_g1_uncompress-memory-arguments" => costs[212], + "bls12_381_g2_add-cpu-arguments" => costs[213], + "bls12_381_g2_add-memory-arguments" => costs[214], + "bls12_381_g2_compress-cpu-arguments" => costs[215], + "bls12_381_g2_compress-memory-arguments" => costs[216], + "bls12_381_g2_equal-cpu-arguments" => costs[217], + "bls12_381_g2_equal-memory-arguments" => costs[218], + "bls12_381_g2_hash_to_group-cpu-arguments-intercept" => costs[219], + "bls12_381_g2_hash_to_group-cpu-arguments-slope" => costs[220], + "bls12_381_g2_hash_to_group-memory-arguments" => costs[221], + "bls12_381_g2_neg-cpu-arguments" => costs[222], + "bls12_381_g2_neg-memory-arguments" => costs[223], + "bls12_381_g2_scalar_mul-cpu-arguments-intercept" => costs[224], + "bls12_381_g2_scalar_mul-cpu-arguments-slope" => costs[225], + "bls12_381_g2_scalar_mul-memory-arguments" => costs[226], + "bls12_381_g2_uncompress-cpu-arguments" => costs[227], + "bls12_381_g2_uncompress-memory-arguments" => costs[228], + "bls12_381_final_verify-cpu-arguments" => costs[229], + "bls12_381_final_verify-memory-arguments" => costs[230], + "bls12_381_miller_loop-cpu-arguments" => costs[231], + "bls12_381_miller_loop-memory-arguments" => costs[232], + "bls12_381_mul_ml_result-cpu-arguments" => costs[233], + "bls12_381_mul_ml_result-memory-arguments" => costs[234], + "keccak_256-cpu-arguments-intercept" => costs[235], + "keccak_256-cpu-arguments-slope" => costs[236], + "keccak_256-memory-arguments" => costs[237], + "blake2b_224-cpu-arguments-intercept" => costs[238], + "blake2b_224-cpu-arguments-slope" => costs[239], + "blake2b_224-memory-arguments" => costs[240], + "integer_to_byte_string-cpu-arguments-c0" => costs[241], + "integer_to_byte_string-cpu-arguments-c1" => costs[242], + "integer_to_byte_string-cpu-arguments-c2" => costs[243], + "integer_to_byte_string-memory-arguments-intercept" => costs[244], + "integer_to_byte_string-memory-arguments-slope" => costs[245], + "byte_string_to_integer-cpu-arguments-c0" => costs[246], + "byte_string_to_integer-cpu-arguments-c1" => costs[247], + "byte_string_to_integer-cpu-arguments-c2" => costs[248], + "byte_string_to_integer-memory-arguments-intercept" => costs[249], + "byte_string_to_integer-memory-arguments-slope" => costs[250] } } }; @@ -3801,6 +4461,6 @@ mod tests { let cost_model = initialize_cost_model(&Language::PlutusV2, &costs); - assert_eq!(::default(), cost_model); + assert_eq!(CostModel::v2(), cost_model); } }