3ccfe735aa
* update license_header * run ./scripts/add_license.sh * update eip-152 license
246 lines
6.4 KiB
Rust
246 lines
6.4 KiB
Rust
// Copyright 2015-2020 Parity Technologies (UK) Ltd.
|
|
// This file is part of Open Ethereum.
|
|
|
|
// Open Ethereum is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// Open Ethereum is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Open Ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
//! Spec builtin deserialization.
|
|
|
|
use std::collections::BTreeMap;
|
|
|
|
use crate::uint::Uint;
|
|
use serde::Deserialize;
|
|
|
|
/// Linear pricing.
|
|
#[derive(Debug, PartialEq, Deserialize, Clone)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct Linear {
|
|
/// Base price.
|
|
pub base: u64,
|
|
/// Price for word.
|
|
pub word: u64,
|
|
}
|
|
|
|
/// Pricing for modular exponentiation.
|
|
#[derive(Debug, PartialEq, Deserialize, Clone)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct Modexp {
|
|
/// Price divisor.
|
|
pub divisor: u64,
|
|
}
|
|
|
|
/// Pricing for constant alt_bn128 operations (ECADD and ECMUL)
|
|
#[derive(Debug, PartialEq, Deserialize, Clone)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct AltBn128ConstOperations {
|
|
/// price
|
|
pub price: u64,
|
|
}
|
|
|
|
/// Pricing for alt_bn128_pairing.
|
|
#[derive(Debug, PartialEq, Deserialize, Clone)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct AltBn128Pairing {
|
|
/// Base price.
|
|
pub base: u64,
|
|
/// Price per point pair.
|
|
pub pair: u64,
|
|
}
|
|
|
|
/// Pricing variants.
|
|
#[derive(Debug, PartialEq, Deserialize, Clone)]
|
|
#[serde(deny_unknown_fields)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum Pricing {
|
|
/// Pricing for Blake2 compression function: each call costs the same amount per round.
|
|
Blake2F {
|
|
/// Price per round of Blake2 compression function.
|
|
gas_per_round: u64,
|
|
},
|
|
/// Linear pricing.
|
|
Linear(Linear),
|
|
/// Pricing for modular exponentiation.
|
|
Modexp(Modexp),
|
|
/// Pricing for alt_bn128_pairing exponentiation.
|
|
AltBn128Pairing(AltBn128Pairing),
|
|
/// Pricing for constant alt_bn128 operations
|
|
AltBn128ConstOperations(AltBn128ConstOperations),
|
|
}
|
|
|
|
/// Builtin compability layer
|
|
#[derive(Debug, PartialEq, Deserialize, Clone)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct BuiltinCompat {
|
|
/// Builtin name.
|
|
name: String,
|
|
/// Builtin pricing.
|
|
pricing: PricingCompat,
|
|
/// Activation block.
|
|
activate_at: Option<Uint>,
|
|
}
|
|
|
|
/// Spec builtin.
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub struct Builtin {
|
|
/// Builtin name.
|
|
pub name: String,
|
|
/// Builtin pricing.
|
|
pub pricing: BTreeMap<u64, PricingAt>,
|
|
}
|
|
|
|
impl From<BuiltinCompat> for Builtin {
|
|
fn from(legacy: BuiltinCompat) -> Self {
|
|
let pricing = match legacy.pricing {
|
|
PricingCompat::Single(pricing) => {
|
|
let mut map = BTreeMap::new();
|
|
let activate_at: u64 = legacy.activate_at.map_or(0, Into::into);
|
|
map.insert(activate_at, PricingAt { info: None, price: pricing });
|
|
map
|
|
}
|
|
PricingCompat::Multi(pricings) => {
|
|
pricings.into_iter().map(|(a, p)| (a.into(), p)).collect()
|
|
}
|
|
};
|
|
Self { name: legacy.name, pricing }
|
|
}
|
|
}
|
|
|
|
/// Compability layer for different pricings
|
|
#[derive(Debug, PartialEq, Deserialize, Clone)]
|
|
#[serde(rename_all = "snake_case")]
|
|
#[serde(deny_unknown_fields)]
|
|
#[serde(untagged)]
|
|
enum PricingCompat {
|
|
/// Single builtin
|
|
Single(Pricing),
|
|
/// Multiple builtins
|
|
Multi(BTreeMap<Uint, PricingAt>),
|
|
}
|
|
|
|
/// Price for a builtin, with the block number to activate it on
|
|
#[derive(Debug, PartialEq, Deserialize, Clone)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct PricingAt {
|
|
/// Description of the activation, e.g. "PunyPony HF, March 12, 2025".
|
|
pub info: Option<String>,
|
|
/// Builtin pricing.
|
|
pub price: Pricing,
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{Builtin, BuiltinCompat, Pricing, PricingAt, Linear, Modexp, AltBn128ConstOperations};
|
|
use maplit::btreemap;
|
|
|
|
#[test]
|
|
fn builtin_deserialization() {
|
|
let s = r#"{
|
|
"name": "ecrecover",
|
|
"pricing": { "linear": { "base": 3000, "word": 0 } }
|
|
}"#;
|
|
let builtin: Builtin = serde_json::from_str::<BuiltinCompat>(s).unwrap().into();
|
|
assert_eq!(builtin.name, "ecrecover");
|
|
assert_eq!(builtin.pricing, btreemap![
|
|
0 => PricingAt {
|
|
info: None,
|
|
price: Pricing::Linear(Linear { base: 3000, word: 0 })
|
|
}
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn deserialize_multiple_pricings() {
|
|
let s = r#"{
|
|
"name": "ecrecover",
|
|
"pricing": {
|
|
"0": {
|
|
"price": {"linear": { "base": 3000, "word": 0 }}
|
|
},
|
|
"500": {
|
|
"info": "enable fake EIP at block 500",
|
|
"price": {"linear": { "base": 10, "word": 0 }}
|
|
}
|
|
}
|
|
}"#;
|
|
let builtin: Builtin = serde_json::from_str::<BuiltinCompat>(s).unwrap().into();
|
|
assert_eq!(builtin.name, "ecrecover");
|
|
assert_eq!(builtin.pricing, btreemap![
|
|
0 => PricingAt {
|
|
info: None,
|
|
price: Pricing::Linear(Linear { base: 3000, word: 0 })
|
|
},
|
|
500 => PricingAt {
|
|
info: Some(String::from("enable fake EIP at block 500")),
|
|
price: Pricing::Linear(Linear { base: 10, word: 0 })
|
|
}
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn deserialization_blake2_f_builtin() {
|
|
let s = r#"{
|
|
"name": "blake2_f",
|
|
"activate_at": "0xffffff",
|
|
"pricing": { "blake2_f": { "gas_per_round": 123 } }
|
|
}"#;
|
|
let builtin: Builtin = serde_json::from_str::<BuiltinCompat>(s).unwrap().into();
|
|
assert_eq!(builtin.name, "blake2_f");
|
|
assert_eq!(builtin.pricing, btreemap![
|
|
0xffffff => PricingAt {
|
|
info: None,
|
|
price: Pricing::Blake2F { gas_per_round: 123 }
|
|
}
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn deserialization_alt_bn128_const_operations() {
|
|
let s = r#"{
|
|
"name": "alt_bn128_mul",
|
|
"pricing": {
|
|
"100500": {
|
|
"price": { "alt_bn128_const_operations": { "price": 123 }}
|
|
}
|
|
}
|
|
}"#;
|
|
let builtin: Builtin = serde_json::from_str::<BuiltinCompat>(s).unwrap().into();
|
|
assert_eq!(builtin.name, "alt_bn128_mul");
|
|
assert_eq!(builtin.pricing, btreemap![
|
|
100500 => PricingAt {
|
|
info: None,
|
|
price: Pricing::AltBn128ConstOperations(AltBn128ConstOperations {
|
|
price: 123,
|
|
}),
|
|
}
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn activate_at() {
|
|
let s = r#"{
|
|
"name": "late_start",
|
|
"activate_at": 100000,
|
|
"pricing": { "modexp": { "divisor": 5 } }
|
|
}"#;
|
|
|
|
let builtin: Builtin = serde_json::from_str::<BuiltinCompat>(s).unwrap().into();
|
|
assert_eq!(builtin.name, "late_start");
|
|
assert_eq!(builtin.pricing, btreemap![
|
|
100_000 => PricingAt {
|
|
info: None,
|
|
price: Pricing::Modexp(Modexp { divisor: 5 })
|
|
}
|
|
]);
|
|
}
|
|
}
|