/*
* Copyright (C) 2019-2024 EverX. All Rights Reserved.
*
* Licensed under the SOFTWARE EVALUATION License (the "License"); you may not use
* this file except in compliance with the License.
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific EVERX DEV software governing permissions and
* limitations under the License.
*/
use crate::{
define_HashmapE,
error::BlockError,
dictionary::hashmapaug::HashmapAugType,
shard::ShardIdent,
shard_accounts::ShardAccounts,
signature::{CryptoSignature, SigPubKey},
types::{ChildCell, ExtraCurrencyCollection, Grams, Number8, Number12, Number16, Number13, Number32},
validators::{ValidatorDescr, ValidatorSet},
Serializable, Deserializable,
BuilderData, Cell, error, fail, BlockIdExt,
HashmapE, HashmapType, IBitstring, Result, SliceData, UInt256, HashmapIterator,
};
#[cfg(test)]
#[path = "tests/test_config_params.rs"]
mod tests;
/*
1.6.3. Quick access through the header of masterchain blocks
_ config_addr:uint256
config:^(Hashmap 32 ^Cell) = ConfigParams;
*/
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ConfigParams {
pub config_addr: UInt256,
pub config_params: HashmapE // <u32, SliceData>
}
impl Default for ConfigParams {
fn default() -> ConfigParams {
Self {
config_addr: UInt256::default(),
config_params: HashmapE::with_bit_len(32)
}
}
}
impl ConfigParams {
/// create new instance ConfigParams
pub fn new() -> Self { Self::default() }
}
impl ConfigParams {
pub const fn with_root(data: Cell) -> Self {
Self {
config_addr: UInt256::ZERO,
config_params: HashmapE::with_hashmap(32, Some(data))
}
}
pub const fn with_address_and_root(config_addr: UInt256, data: Cell) -> Self {
Self {
config_addr,
config_params: HashmapE::with_hashmap(32, Some(data))
}
}
pub const fn with_address_and_params(config_addr: UInt256, data: Option<Cell>) -> Self {
Self {
config_addr,
config_params: HashmapE::with_hashmap(32, data)
}
}
/// get config by index
pub fn config(&self, index: u32) -> Result<Option<ConfigParamEnum>> {
let key = index.write_to_bitstring()?;
if let Some(slice) = self.config_params.get(key)? {
if let Some(cell) = slice.reference_opt(0) {
return Ok(Some(ConfigParamEnum::construct_from_slice_and_number(&mut SliceData::load_cell(cell)?, index)?));
}
}
Ok(None)
}
/// get config by index
pub fn config_present(&self, index: u32) -> Result<bool> {
let key = index.write_to_bitstring()?;
if let Some(slice) = self.config_params.get(key)? {
if slice.remaining_references() != 0 {
return Ok(true)
}
}
Ok(false)
}
/// set config
pub fn set_config(&mut self, config: ConfigParamEnum) -> Result<()> {
let mut value = BuilderData::new();
let index = config.write_to_cell(&mut value)?;
let key = index.write_to_bitstring()?;
self.config_params.set_builder(key, &value)?;
Ok(())
}
pub fn get_smc_tick_tock(&self, smc_addr: &UInt256, accounts: &ShardAccounts) -> Result<usize> {
let account = match accounts.get(smc_addr)? {
Some(shard_account) => shard_account.read_account()?,
None => fail!("Tick-tock smartcontract not found")
};
Ok(account.get_tick_tock().map(|tick_tock| tick_tock.as_usize()).unwrap_or_default())
}
pub fn special_ticktock_smartcontracts(&self, tick_tock: usize, accounts: &ShardAccounts) -> Result<Vec<(UInt256, usize)>> {
let mut vec = Vec::new();
self.fundamental_smc_addr()?.iterate_keys(|key: UInt256| {
let tt = self.get_smc_tick_tock(&key, accounts)?;
if (tick_tock & tt) != 0 {
vec.push((key, tt))
}
Ok(true)
})?;
Ok(vec)
}
//
// Wrappers
//
pub fn config_address(&self) -> Result<UInt256> {
match self.config(0)? {
Some(ConfigParamEnum::ConfigParam0(param)) => Ok(param.config_addr),
_ => fail!("no config smc address in config")
}
}
pub fn elector_address(&self) -> Result<UInt256> {
match self.config(1)? {
Some(ConfigParamEnum::ConfigParam1(param)) => Ok(param.elector_addr),
_ => fail!("no elector address in config")
}
}
pub fn minter_address(&self) -> Result<UInt256> {
let addr = match self.config(2)? {
Some(ConfigParamEnum::ConfigParam2(param)) => param.minter_addr,
_ => match self.config(0)? {
Some(ConfigParamEnum::ConfigParam0(param)) => param.config_addr,
_ => fail!("no minter address in config")
}
};
Ok(addr)
}
pub fn fee_collector_address(&self) -> Result<UInt256> {
let addr = match self.config(3)? {
Some(ConfigParamEnum::ConfigParam3(param)) => param.fee_collector_addr,
_ => match self.config(1)? {
Some(ConfigParamEnum::ConfigParam1(param)) => param.elector_addr,
_ => fail!("no fee collector address in config")
}
};
Ok(addr)
}
// TODO 4 dns_root_addr
pub fn mint_prices(&self) -> Result<ConfigParam6> {
match self.config(6)? {
Some(ConfigParamEnum::ConfigParam6(cp)) => Ok(cp),
_ => fail!("no config 6 (mint prices)")
}
}
pub fn to_mint(&self) -> Result<ExtraCurrencyCollection> {
match self.config(7)? {
Some(ConfigParamEnum::ConfigParam7(cp)) => Ok(cp.to_mint),
_ => fail!("no config 7 (to mint)")
}
}
pub fn get_global_version(&self) -> Result<GlobalVersion> {
match self.config(8)? {
Some(ConfigParamEnum::ConfigParam8(gb)) => Ok(gb.global_version),
_ => fail!("no global version in config")
}
}
pub fn mandatory_params(&self) -> Result<MandatoryParams> {
match self.config(9)? {
Some(ConfigParamEnum::ConfigParam9(mp)) => Ok(mp.mandatory_params),
_ => fail!("no mandatory params in config")
}
}
// TODO 11 ConfigVotingSetup
pub fn workchains(&self) -> Result<Workchains> {
match self.config(12)? {
Some(ConfigParamEnum::ConfigParam12(param)) => Ok(param.workchains),
_ => fail!("Workchains not found in config")
}
}
// TODO 13 compliant pricing
pub fn block_create_fees(&self, masterchain: bool) -> Result<Grams> {
match self.config(14)? {
Some(ConfigParamEnum::ConfigParam14(param)) => if masterchain {
Ok(param.block_create_fees.masterchain_block_fee)
} else {
Ok(param.block_create_fees.basechain_block_fee)
}
_ => fail!("no block create fee parameter")
}
}
pub fn elector_params(&self) -> Result<ConfigParam15> {
match self.config(15)? {
Some(ConfigParamEnum::ConfigParam15(param)) => Ok(param),
_ => fail!("no elector params in config")
}
}
pub fn validators_count(&self) -> Result<ConfigParam16> {
match self.config(16)? {
Some(ConfigParamEnum::ConfigParam16(param)) => Ok(param),
_ => fail!("no elector params in config")
}
}
pub fn stakes_config(&self) -> Result<ConfigParam17> {
match self.config(17)? {
Some(ConfigParamEnum::ConfigParam17(param)) => Ok(param),
_ => fail!("no stakes params in config")
}
}
// TODO 16 validators count
// TODO 17 stakes config
pub fn storage_prices(&self) -> Result<ConfigParam18> {
match self.config(18)? {
Some(ConfigParamEnum::ConfigParam18(param)) => Ok(param),
_ => fail!("Storage prices not found")
}
}
pub fn gas_prices(&self, is_masterchain: bool) -> Result<GasLimitsPrices> {
if is_masterchain {
if let Some(ConfigParamEnum::ConfigParam20(param)) = self.config(20)? {
return Ok(param)
}
} else if let Some(ConfigParamEnum::ConfigParam21(param)) = self.config(21)? {
return Ok(param)
}
fail!("Gas prices not found")
}
pub fn block_limits(&self, masterchain: bool) -> Result<BlockLimits> {
if masterchain {
if let Some(ConfigParamEnum::ConfigParam22(param)) = self.config(22)? {
return Ok(param)
}
} else if let Some(ConfigParamEnum::ConfigParam23(param)) = self.config(23)? {
return Ok(param)
}
fail!("BlockLimits not found")
}
pub fn fwd_prices(&self, is_masterchain: bool) -> Result<MsgForwardPrices> {
if is_masterchain {
if let Some(ConfigParamEnum::ConfigParam24(param)) = self.config(24)? {
return Ok(param)
}
} else if let Some(ConfigParamEnum::ConfigParam25(param)) = self.config(25)? {
return Ok(param)
}
fail!("Forward prices not found")
}
pub fn catchain_config(&self) -> Result<CatchainConfig> {
match self.config(28)? {
Some(ConfigParamEnum::ConfigParam28(ccc)) => Ok(ccc),
_ => fail!("no CatchainConfig in config_params")
}
}
pub fn consensus_config(&self) -> Result<ConsensusConfig> {
match self.config(29)? {
Some(ConfigParamEnum::ConfigParam29(ConfigParam29{ consensus_config})) => Ok(consensus_config),
_ => fail!("no ConsensusConfig in config_params")
}
}
// TODO 29 consensus config
pub fn fundamental_smc_addr(&self) -> Result<FundamentalSmcAddresses> {
match self.config(31)? {
Some(ConfigParamEnum::ConfigParam31(param)) => Ok(param.fundamental_smc_addr),
_ => fail!("fundamental_smc_addr not found in config")
}
}
pub fn delector_parameters(&self) -> Result<DelectorParams> {
match self.config(30)? {
Some(ConfigParamEnum::ConfigParam30(param)) => Ok(param),
_ => fail!("delector parameters not found in config")
}
}
pub fn prev_validator_set(&self) -> Result<ValidatorSet> {
let vset = match self.config(33)? {
Some(ConfigParamEnum::ConfigParam33(param)) => param.prev_temp_validators,
_ => match self.config(32)? {
Some(ConfigParamEnum::ConfigParam32(param)) => param.prev_validators,
_ => ValidatorSet::default()
}
};
Ok(vset)
}
pub fn prev_validator_set_present(&self) -> Result<bool> {
Ok(self.config_present(33)? || self.config_present(32)?)
}
pub fn validator_set(&self) -> Result<ValidatorSet> {
let vset = match self.config(35)? {
Some(ConfigParamEnum::ConfigParam35(param)) => param.cur_temp_validators,
_ => match self.config(34)? {
Some(ConfigParamEnum::ConfigParam34(param)) => param.cur_validators,
_ => fail!("no validator set in config")
}
};
Ok(vset)
}
pub fn next_validator_set(&self) -> Result<ValidatorSet> {
let vset = match self.config(37)? {
Some(ConfigParamEnum::ConfigParam37(param)) => param.next_temp_validators,
_ => match self.config(36)? {
Some(ConfigParamEnum::ConfigParam36(param)) => param.next_validators,
_ => ValidatorSet::default()
}
};
Ok(vset)
}
pub fn next_validator_set_present(&self) -> Result<bool> {
Ok(self.config_present(37)? || self.config_present(36)?)
}
pub fn read_cur_validator_set_and_cc_conf(&self) -> Result<(ValidatorSet, CatchainConfig)> {
Ok((
self.validator_set()?,
self.catchain_config()?
))
}
pub fn copyleft_config(&self) -> Result<ConfigCopyleft> {
match self.config(42)? {
Some(ConfigParamEnum::ConfigParam42(cp)) => Ok(cp),
_ => fail!("no config 42 (copyleft)")
}
}
pub fn suspended_addresses(&self) -> Result<Option<SuspendedAddresses>> {
match self.config(44)? {
Some(ConfigParamEnum::ConfigParam44(sa)) => Ok(Some(sa)),
None => Ok(None),
_ => fail!("wrong config 44 (suspended addresses)")
}
}
// TODO 39 validator signed temp keys
// ConfigParam58(MeshConfig),
pub fn mesh_config(&self) -> Result<Option<MeshConfig>> {
match self.config(58)? {
Some(ConfigParamEnum::ConfigParam58(mc)) => Ok(Some(mc)),
None => Ok(None),
_ => fail!("wrong config 58 (mesh config)")
}
}
pub fn mesh_config_for(&self, nw_id: i32) -> Result<ConnectedNwConfig> {
self.mesh_config()?
.ok_or_else(|| error!("no mesh config"))?
.get(&nw_id)?
.ok_or_else(|| error!("no mesh config for {}", nw_id))
}
pub fn fast_finality_config(&self) -> Result<FastFinalityConfig> {
match self.config(61)? {
Some(ConfigParamEnum::ConfigParam61(ff)) => Ok(ff),
_ => fail!("no fast finality config")
}
}
// ConfigParam62(SmftConfig)
pub fn smft_parameters(&self) -> Result<SmftParams> {
match self.config(62)? {
Some(ConfigParamEnum::ConfigParam62(param)) => Ok(param),
_ => fail!("smft parameters not found in config")
}
}
}
#[derive(Clone, Copy, Debug)]
#[repr(u64)]
pub enum GlobalCapabilities {
CapNone = 0,
CapIhrEnabled = 0x0000_0000_0001,
CapCreateStatsEnabled = 0x0000_0000_0002,
CapBounceMsgBody = 0x0000_0000_0004,
CapReportVersion = 0x0000_0000_0008,
CapSplitMergeTransactions = 0x0000_0000_0010,
CapShortDequeue = 0x0000_0000_0020,
CapMbppEnabled = 0x0000_0000_0040,
CapFastStorageStat = 0x0000_0000_0080,
CapInitCodeHash = 0x0000_0000_0100,
CapOffHypercube = 0x0000_0000_0200,
CapMycode = 0x0000_0000_0400,
CapSetLibCode = 0x0000_0000_0800,
CapFixTupleIndexBug = 0x0000_0000_1000,
CapRemp = 0x0000_0000_2000,
CapDelections = 0x0000_0000_4000,
CapFullBodyInBounced = 0x0000_0001_0000,
CapStorageFeeToTvm = 0x0000_0002_0000,
CapCopyleft = 0x0000_0004_0000,
CapIndexAccounts = 0x0000_0008_0000,
#[cfg(feature = "gosh")]
CapDiff = 0x0000_0010_0000,
CapsTvmBugfixes2022 = 0x0000_0020_0000, // popsave, exception handler, loops
CapWorkchains = 0x0000_0040_0000,
CapStcontNewFormat = 0x0000_0080_0000, // support old format continuation serialization
CapFastStorageStatBugfix = 0x0000_0100_0000, // calc cell datasize using fast storage stat
CapResolveMerkleCell = 0x0000_0200_0000,
#[cfg(feature = "signature_with_id")]
CapSignatureWithId = 0x0000_0400_0000, // use some predefined id during signature check
CapBounceAfterFailedAction= 0x0000_0800_0000,
#[cfg(feature = "groth")]
CapGroth16 = 0x0000_1000_0000,
CapFeeInGasUnits = 0x0000_2000_0000, // all fees in config are in gas units
CapBigCells = 0x0000_4000_0000,
CapSuspendedList = 0x0000_8000_0000,
CapFastFinality = 0x0001_0000_0000,
CapTvmV19 = 0x0002_0000_0000, // TVM v1.9.x improvemements
CapSmft = 0x0004_0000_0000,
CapNoSplitOutQueue = 0x0008_0000_0000, // Don't split out queue on shard splitting
CapUndeletableAccounts = 0x0010_0000_0000, // Don't delete frozen accounts
CapTvmV20 = 0x0020_0000_0000, // BLS instructions
CapDuePaymentFix = 0x0040_0000_0000, // No due payments on credit phase and add payed dues to storage fee in TVM
CapCommonMessage = 0x0080_0000_0000,
CapPipeline = 0x0100_0000_0000,
}
impl ConfigParams {
pub fn get_lt_align(&self) -> u64 {
1_000_000
}
pub fn get_max_lt_growth_fast_finality(&self) -> u64 {
100 * self.get_lt_align() - 1
}
pub fn get_max_lt_growth(&self) -> u64 {
10 * self.get_lt_align() - 1
}
pub fn get_next_block_lt(&self, prev_block_lt: u64) -> u64 {
(prev_block_lt / self.get_lt_align() + 1) * self.get_lt_align()
}
pub fn has_capabilities(&self) -> bool {
self.get_global_version().map_or(false, |gb| gb.capabilities != 0)
}
pub fn has_capability(&self, capability: GlobalCapabilities) -> bool {
self.get_global_version().map_or(false, |gb| gb.has_capability(capability))
}
pub fn capabilities(&self) -> u64 {
self.get_global_version().map_or(0, |gb| gb.capabilities)
}
pub fn global_version(&self) -> u32 {
self.get_global_version().map_or(0, |gb| gb.version)
}
}
impl ConfigParams {
pub fn compute_validator_set_cc(&self, shard: &ShardIdent, at: u32, cc_seqno: u32, cc_seqno_delta: &mut u32) -> Result<Vec<ValidatorDescr>> {
let (vset, ccc) = self.read_cur_validator_set_and_cc_conf()?;
if (*cc_seqno_delta & 0xfffffffe) != 0 {
fail!("seqno_delta>1 is not implemented yet");
}
*cc_seqno_delta += cc_seqno;
vset.calc_subset(&ccc, shard.shard_prefix_with_tag(), shard.workchain_id(), *cc_seqno_delta, at.into())
.map(|(set, _hash)| {
set
})
}
pub fn compute_validator_set(&self, shard: &ShardIdent, _at: u32, cc_seqno: u32) -> Result<Vec<ValidatorDescr>> {
let (vset, ccc) = self.read_cur_validator_set_and_cc_conf()?;
vset.calc_subset(&ccc, shard.shard_prefix_with_tag(), shard.workchain_id(), cc_seqno, _at.into())
.map(|(set, _seq_no)| set)
}
}
const MANDATORY_CONFIG_PARAMS: [u32; 9] = [18, 20, 21, 22, 23, 24, 25, 28, 34];
impl ConfigParams {
pub fn valid_config_data(&self, relax_par0: bool, mparams: Option<MandatoryParams>) -> Result<bool> {
if !relax_par0 {
match self.config(0) {
Ok(Some(ConfigParamEnum::ConfigParam0(param))) if param.config_addr == self.config_addr => (),
_ => return Ok(false)
}
}
// porting from Durov's code
// previously was not 9 parameter in config params
for index in &MANDATORY_CONFIG_PARAMS {
if self.config(*index)?.is_none() {
log::error!(target: "block", "configuration parameter #{} \
(hardcoded as mandatory) is missing)", index);
return Ok(false)
}
}
let result = match self.config(9) {
Ok(Some(ConfigParamEnum::ConfigParam9(param))) => self.config_params_present(Some(param.mandatory_params))?,
_ => {
log::error!(target: "block", "invalid mandatory parameters dictionary while checking \
existence of all mandatory configuration parameters");
false
}
};
Ok(result && self.config_params_present(mparams)?)
}
fn config_params_present(&self, params: Option<MandatoryParams>) -> Result<bool> {
match params {
Some(params) => params.iterate_keys(|index: u32| match self.config(index) {
Ok(Some(_)) => Ok(true),
_ => {
log::error!(target: "block", "configuration parameter #{} \
(declared as mandatory in configuration parameter #9) is missing)", index);
Ok(false)
}
}),
None => Ok(true)
}
}
// when these parameters change, the block must be marked as a key block
pub fn important_config_parameters_changed(&self, other: &ConfigParams, coarse: bool) -> Result<bool> {
if self.config_params == other.config_params {
return Ok(false)
}
if coarse {
return Ok(true)
}
// for now, all parameters are "important"
// at least the parameters affecting the computations of validator sets must be considered important
// ...
Ok(true)
}
}
impl Deserializable for ConfigParams {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.config_addr.read_from(cell)?;
*self.config_params.data_mut() = Some(cell.checked_drain_reference()?);
Ok(())
}
}
impl Serializable for ConfigParams {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.checked_append_reference(self.config_params.data().cloned().unwrap_or_default())?;
self.config_addr.write_to(cell)?;
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ConfigParamEnum {
ConfigParam0(ConfigParam0),
ConfigParam1(ConfigParam1),
ConfigParam2(ConfigParam2),
ConfigParam3(ConfigParam3),
ConfigParam4(ConfigParam4),
ConfigParam5(ConfigParam5),
ConfigParam6(ConfigParam6),
ConfigParam7(ConfigParam7),
ConfigParam8(ConfigParam8),
ConfigParam9(ConfigParam9),
ConfigParam10(ConfigParam10),
ConfigParam11(ConfigParam11),
ConfigParam12(ConfigParam12),
ConfigParam13(ConfigParam13),
ConfigParam14(ConfigParam14),
ConfigParam15(ConfigParam15),
ConfigParam16(ConfigParam16),
ConfigParam17(ConfigParam17),
ConfigParam18(ConfigParam18),
ConfigParam20(GasLimitsPrices),
ConfigParam21(GasLimitsPrices),
ConfigParam22(ConfigParam22),
ConfigParam23(ConfigParam23),
ConfigParam24(MsgForwardPrices),
ConfigParam25(MsgForwardPrices),
ConfigParam28(CatchainConfig),
ConfigParam29(ConfigParam29),
ConfigParam30(DelectorParams),
ConfigParam31(ConfigParam31),
ConfigParam32(ConfigParam32),
ConfigParam33(ConfigParam33),
ConfigParam34(ConfigParam34),
ConfigParam35(ConfigParam35),
ConfigParam36(ConfigParam36),
ConfigParam37(ConfigParam37),
ConfigParam39(ConfigParam39),
ConfigParam40(ConfigParam40),
ConfigParam42(ConfigCopyleft),
ConfigParam44(SuspendedAddresses),
ConfigParam58(MeshConfig),
ConfigParam61(FastFinalityConfig),
ConfigParam62(SmftParams),
ConfigParamAny(u32, SliceData),
}
macro_rules! read_config {
( $cpname:ident, $cname:ident, $slice:expr ) => {
{
let c = $cname::construct_from($slice)?;
Ok(ConfigParamEnum::$cpname(c))
}
}
}
impl ConfigParamEnum {
pub fn construct_from_cell_and_number(cell: Cell, index: u32) -> Result<ConfigParamEnum> {
Self::construct_from_slice_and_number(&mut SliceData::load_cell(cell)?, index)
}
/// read config from cell
pub fn construct_from_slice_and_number(slice: &mut SliceData, index: u32) -> Result<ConfigParamEnum> {
match index {
0 => { read_config!(ConfigParam0, ConfigParam0, slice) },
1 => { read_config!(ConfigParam1, ConfigParam1, slice) },
2 => { read_config!(ConfigParam2, ConfigParam2, slice) },
3 => { read_config!(ConfigParam3, ConfigParam3, slice) },
4 => { read_config!(ConfigParam4, ConfigParam4, slice) },
5 => { read_config!(ConfigParam5, ConfigParam5, slice) },
6 => { read_config!(ConfigParam6, ConfigParam6, slice) },
7 => { read_config!(ConfigParam7, ConfigParam7, slice) },
8 => { read_config!(ConfigParam8, ConfigParam8, slice) },
9 => { read_config!(ConfigParam9, ConfigParam9, slice) },
10 => { read_config!(ConfigParam10, ConfigParam10, slice) },
11 => { read_config!(ConfigParam11, ConfigParam11, slice) },
12 => { read_config!(ConfigParam12, ConfigParam12, slice) },
13 => { read_config!(ConfigParam13, ConfigParam13, slice) },
14 => { read_config!(ConfigParam14, ConfigParam14, slice) },
15 => { read_config!(ConfigParam15, ConfigParam15, slice) },
16 => { read_config!(ConfigParam16, ConfigParam16, slice) },
17 => { read_config!(ConfigParam17, ConfigParam17, slice) },
18 => { read_config!(ConfigParam18, ConfigParam18, slice) },
20 => { read_config!(ConfigParam20, GasLimitsPrices, slice) },
21 => { read_config!(ConfigParam21, GasLimitsPrices, slice) },
22 => { read_config!(ConfigParam22, ConfigParam22, slice) },
23 => { read_config!(ConfigParam23, ConfigParam23, slice) },
24 => { read_config!(ConfigParam24, MsgForwardPrices, slice) },
25 => { read_config!(ConfigParam25, MsgForwardPrices, slice) },
28 => { read_config!(ConfigParam28, CatchainConfig, slice) },
29 => { read_config!(ConfigParam29, ConfigParam29, slice) },
30 => { read_config!(ConfigParam30, DelectorParams, slice) },
31 => { read_config!(ConfigParam31, ConfigParam31, slice) },
32 => { read_config!(ConfigParam32, ConfigParam32, slice) },
33 => { read_config!(ConfigParam33, ConfigParam33, slice) },
34 => { read_config!(ConfigParam34, ConfigParam34, slice) },
35 => { read_config!(ConfigParam35, ConfigParam35, slice) },
36 => { read_config!(ConfigParam36, ConfigParam36, slice) },
37 => { read_config!(ConfigParam37, ConfigParam37, slice) },
39 => { read_config!(ConfigParam39, ConfigParam39, slice) },
40 => { read_config!(ConfigParam40, ConfigParam40, slice) },
42 => { read_config!(ConfigParam42, ConfigCopyleft, slice) },
44 => { read_config!(ConfigParam44, SuspendedAddresses, slice) },
58 => { read_config!(ConfigParam58, MeshConfig, slice) },
61 => { read_config!(ConfigParam61, FastFinalityConfig, slice) },
62 => { read_config!(ConfigParam62, SmftParams, slice) },
index => Ok(ConfigParamEnum::ConfigParamAny(index, slice.clone())),
}
}
/// Save config to cell
pub fn write_to_cell(&self, cell: &mut BuilderData) -> Result<u32> {
match self {
ConfigParamEnum::ConfigParam0(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(0)},
ConfigParamEnum::ConfigParam1(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(1)},
ConfigParamEnum::ConfigParam2(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(2)},
ConfigParamEnum::ConfigParam3(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(3)},
ConfigParamEnum::ConfigParam4(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(4)},
ConfigParamEnum::ConfigParam5(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(5)},
ConfigParamEnum::ConfigParam6(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(6)},
ConfigParamEnum::ConfigParam7(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(7)},
ConfigParamEnum::ConfigParam8(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(8)},
ConfigParamEnum::ConfigParam9(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(9)},
ConfigParamEnum::ConfigParam10(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(10)},
ConfigParamEnum::ConfigParam11(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(11)},
ConfigParamEnum::ConfigParam12(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(12)},
ConfigParamEnum::ConfigParam13(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(13)},
ConfigParamEnum::ConfigParam14(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(14)},
ConfigParamEnum::ConfigParam15(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(15)},
ConfigParamEnum::ConfigParam16(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(16)},
ConfigParamEnum::ConfigParam17(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(17)},
ConfigParamEnum::ConfigParam18(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(18)},
ConfigParamEnum::ConfigParam20(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(20)},
ConfigParamEnum::ConfigParam21(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(21)},
ConfigParamEnum::ConfigParam22(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(22)},
ConfigParamEnum::ConfigParam23(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(23)},
ConfigParamEnum::ConfigParam24(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(24)},
ConfigParamEnum::ConfigParam25(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(25)},
ConfigParamEnum::ConfigParam28(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(28)},
ConfigParamEnum::ConfigParam29(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(29)},
ConfigParamEnum::ConfigParam30(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(30)},
ConfigParamEnum::ConfigParam31(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(31)},
ConfigParamEnum::ConfigParam32(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(32)},
ConfigParamEnum::ConfigParam33(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(33)},
ConfigParamEnum::ConfigParam34(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(34)},
ConfigParamEnum::ConfigParam35(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(35)},
ConfigParamEnum::ConfigParam36(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(36)},
ConfigParamEnum::ConfigParam37(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(37)},
ConfigParamEnum::ConfigParam39(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(39)},
ConfigParamEnum::ConfigParam40(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(40)},
ConfigParamEnum::ConfigParam42(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(42)},
ConfigParamEnum::ConfigParam44(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(44)},
ConfigParamEnum::ConfigParam58(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(58)},
ConfigParamEnum::ConfigParam61(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(61)},
ConfigParamEnum::ConfigParam62(ref c) => { cell.checked_append_reference(c.serialize()?)?; Ok(62)},
ConfigParamEnum::ConfigParamAny(index, slice) => {
cell.checked_append_reference(slice.clone().into_cell())?;
Ok(*index)
},
}
}
}
/*
_ config_addr:bits256 = ConfigParam 0;
*/
///
/// Config Param 0 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam0 {
pub config_addr: UInt256,
}
impl ConfigParam0 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam0 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.config_addr.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam0 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.config_addr.write_to(cell)?;
Ok(())
}
}
/*
_ elector_addr:bits256 = ConfigParam 1;
*/
///
/// Config Param 1 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam1 {
pub elector_addr: UInt256,
}
impl ConfigParam1 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam1 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.elector_addr.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam1 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.elector_addr.write_to(cell)?;
Ok(())
}
}
///
/// Config Param 2 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam2 {
pub minter_addr: UInt256,
}
impl ConfigParam2 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam2 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.minter_addr.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam2 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.minter_addr.write_to(cell)?;
Ok(())
}
}
///
/// Config Param 3 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam3 {
pub fee_collector_addr: UInt256,
}
impl ConfigParam3 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam3 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.fee_collector_addr.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam3 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.fee_collector_addr.write_to(cell)?;
Ok(())
}
}
///
/// Config Param 4 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam4 {
pub dns_root_addr: UInt256,
}
impl ConfigParam4 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam4 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.dns_root_addr.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam4 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.dns_root_addr.write_to(cell)?;
Ok(())
}
}
///
/// Config Param 5 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam5 {
pub owner_addr: UInt256,
}
impl Deserializable for ConfigParam5 {
fn construct_from(slice: &mut SliceData) -> Result<Self> {
let owner_addr = Deserializable::construct_from(slice)?;
Ok(ConfigParam5 { owner_addr })
}
}
impl Serializable for ConfigParam5 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.owner_addr.write_to(cell)?;
Ok(())
}
}
///
/// Config Param 6 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam6 {
pub mint_new_price: Grams,
pub mint_add_price: Grams,
}
impl ConfigParam6 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam6 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.mint_new_price.read_from(cell)?;
self.mint_add_price.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam6 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.mint_new_price.write_to(cell)?;
self.mint_add_price.write_to(cell)?;
Ok(())
}
}
///
/// Config Param 7 structure
///
#[derive(Clone, Default, Debug, Eq, PartialEq)]
pub struct ConfigParam7 {
pub to_mint: ExtraCurrencyCollection,
}
impl ConfigParam7 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam7 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.to_mint.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam7 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.to_mint.write_to(cell)?;
Ok(())
}
}
///
/// Config Param 8 structure
///
// capabilities#c4 version:uint32 capabilities:uint64 = GlobalVersion;
// _ GlobalVersion = ConfigParam 8; // all zero if absent
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct GlobalVersion {
pub version: u32,
pub capabilities: u64,
}
impl GlobalVersion {
pub fn new() -> Self { Self::default() }
pub fn has_capability(&self, capability: GlobalCapabilities) -> bool {
(self.capabilities & (capability as u64)) != 0
}
}
const GLOBAL_VERSION_TAG: u8 = 0xC4;
impl Deserializable for GlobalVersion {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
let tag = cell.get_next_byte()?;
if tag != GLOBAL_VERSION_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.version.read_from(cell)?;
self.capabilities.read_from(cell)?;
Ok(())
}
}
impl Serializable for GlobalVersion {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(GLOBAL_VERSION_TAG)?;
self.version.write_to(cell)?;
self.capabilities.write_to(cell)?;
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam8 {
pub global_version: GlobalVersion
}
impl ConfigParam8 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam8 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.global_version.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam8 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.global_version.write_to(cell)?;
Ok(())
}
}
// _ mandatory_params:(Hashmap 32 True) = ConfigParam 9;
define_HashmapE!{MandatoryParams, 32, ()}
///
/// Config Param 9 structure
///
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ConfigParam9 {
pub mandatory_params: MandatoryParams,
}
impl ConfigParam9 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam9 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.mandatory_params.read_hashmap_root(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam9 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.mandatory_params.write_hashmap_root(cell)?;
Ok(())
}
}
///
/// Config Param 10 structure
///
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ConfigParam10 {
pub critical_params: MandatoryParams,
}
impl ConfigParam10 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam10 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.critical_params.read_hashmap_root(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam10 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.critical_params.write_hashmap_root(cell)?;
Ok(())
}
}
///
/// Config Param 14 structure
///
// block_grams_created#6b masterchain_block_fee:Grams basechain_block_fee:Grams
// = BlockCreateFees;
// _ BlockCreateFees = ConfigParam 14;
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct BlockCreateFees {
pub masterchain_block_fee: Grams,
pub basechain_block_fee: Grams,
}
impl BlockCreateFees {
pub fn new() -> Self { Self::default() }
}
const BLOCK_CREATE_FEES: u8 = 0x6b;
impl Deserializable for BlockCreateFees {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
let tag = cell.get_next_byte()?;
if tag != BLOCK_CREATE_FEES {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.masterchain_block_fee.read_from(cell)?;
self.basechain_block_fee.read_from(cell)?;
Ok(())
}
}
impl Serializable for BlockCreateFees {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(BLOCK_CREATE_FEES)?;
self.masterchain_block_fee.write_to(cell)?;
self.basechain_block_fee.write_to(cell)?;
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam14 {
pub block_create_fees: BlockCreateFees
}
impl ConfigParam14 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam14 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.block_create_fees.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam14 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.block_create_fees.write_to(cell)?;
Ok(())
}
}
///
/// Config Param 15 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam15 {
pub validators_elected_for: u32,
pub elections_start_before: u32,
pub elections_end_before: u32,
pub stake_held_for: u32,
}
impl ConfigParam15 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam15 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.validators_elected_for.read_from(cell)?;
self.elections_start_before.read_from(cell)?;
self.elections_end_before.read_from(cell)?;
self.stake_held_for.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam15 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.validators_elected_for.write_to(cell)?;
self.elections_start_before.write_to(cell)?;
self.elections_end_before.write_to(cell)?;
self.stake_held_for.write_to(cell)?;
Ok(())
}
}
/*
_ max_validators:(## 16) max_main_validators:(## 16) min_validators:(## 16)
{ max_validators >= max_main_validators }
{ max_main_validators >= min_validators }
{ min_validators >= 1 }
= ConfigParam 16;
*/
///
/// Config Param 16 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam16 {
pub max_validators: Number16,
pub max_main_validators: Number16,
pub min_validators: Number16,
}
impl ConfigParam16 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam16 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.max_validators.read_from(cell)?;
self.max_main_validators.read_from(cell)?;
self.min_validators.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam16 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.max_validators.write_to(cell)?;
self.max_main_validators.write_to(cell)?;
self.min_validators.write_to(cell)?;
Ok(())
}
}
/*
_
min_stake: Grams
max_stake: Grams
min_total_stake: Grams
max_stake_factor: uint32
= ConfigParam 17;
*/
///
/// Config Param 17 structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam17 {
pub min_stake: Grams,
pub max_stake: Grams,
pub min_total_stake: Grams,
pub max_stake_factor: u32,
}
impl ConfigParam17 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam17 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.min_stake.read_from(cell)?;
self.max_stake.read_from(cell)?;
self.min_total_stake.read_from(cell)?;
self.max_stake_factor.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam17 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.min_stake.write_to(cell)?;
self.max_stake.write_to(cell)?;
self.min_total_stake.write_to(cell)?;
self.max_stake_factor.write_to(cell)?;
Ok(())
}
}
/*
_#cc
utime_since:uint32
bit_price_ps:uint64
cell_price_ps:uint64
mc_bit_price_ps:uint64
mc_cell_price_ps:uint64
= StoragePrices;
_ (Hashmap 32 StoragePrices) = ConfigParam 18;
*/
///
/// StoragePrices structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct StoragePrices {
pub utime_since: u32,
pub bit_price_ps: u64,
pub cell_price_ps: u64,
pub mc_bit_price_ps: u64,
pub mc_cell_price_ps: u64,
}
impl StoragePrices {
pub fn new() -> Self { Self::default() }
}
const STORAGE_PRICES_TAG: u8 = 0xCC;
impl Deserializable for StoragePrices {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
let tag = cell.get_next_byte()?;
if tag != STORAGE_PRICES_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.utime_since.read_from(cell)?;
self.bit_price_ps.read_from(cell)?;
self.cell_price_ps.read_from(cell)?;
self.mc_bit_price_ps.read_from(cell)?;
self.mc_cell_price_ps.read_from(cell)?;
Ok(())
}
}
impl Serializable for StoragePrices {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(STORAGE_PRICES_TAG)?;
self.utime_since.write_to(cell)?;
self.bit_price_ps.write_to(cell)?;
self.cell_price_ps.write_to(cell)?;
self.mc_bit_price_ps.write_to(cell)?;
self.mc_cell_price_ps.write_to(cell)?;
Ok(())
}
}
define_HashmapE!(ConfigParam18Map, 32, StoragePrices);
///
/// ConfigParam 18 struct
///
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ConfigParam18 {
pub map: ConfigParam18Map,
}
impl ConfigParam18 {
/// get length
pub fn len(&self) -> Result<usize> {
self.map.len()
}
/// determine is empty
pub fn is_empty(&self) -> bool {
self.map.is_empty()
}
/// get value by index
pub fn get(&self, index: u32) -> Result<StoragePrices> {
self.map.get(&index)?.ok_or_else(|| error!(BlockError::InvalidIndex(index as usize)))
}
/// get all value as vector
pub fn prices(&self) -> Result<Vec<StoragePrices>> {
self.map.export_vector()
}
/// insert value
pub fn insert(&mut self, sp: &StoragePrices) -> Result<()> {
let index = match self.map.0.get_max(false, &mut 0)? {
Some((key, _value)) => u32::construct_from_bitstring(key)? + 1,
None => 0
};
self.map.set(&index, sp)
}
}
impl Deserializable for ConfigParam18 {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
self.map.read_hashmap_root(slice)?;
Ok(())
}
}
impl Serializable for ConfigParam18 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
if self.map.is_empty() {
fail!(BlockError::InvalidOperation("self.map is empty".to_string()))
}
self.map.write_hashmap_root(cell)?;
Ok(())
}
}
/*
gas_prices#dd
gas_price:uint64
gas_limit:uint64
gas_credit:uint64
block_gas_limit:uint64
freeze_due_limit:uint64
delete_due_limit:uint64
= GasLimitsPrices;
gas_prices_ext#de
gas_price:uint64
gas_limit:uint64
special_gas_limit:uint64
gas_credit:uint64
block_gas_limit:uint64
freeze_due_limit:uint64
delete_due_limit:uint64
= GasLimitsPrices;
gas_flat_pfx#d1
flat_gas_limit:uint64
flat_gas_price:uint64
other:GasLimitsPrices
= GasLimitsPrices;
*/
///
/// GasLimitsPrices
///
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct GasLimitsPrices {
pub gas_price: u64,
pub gas_limit: u64,
pub special_gas_limit: u64,
pub gas_credit: u64,
pub block_gas_limit: u64,
pub freeze_due_limit: u64,
pub delete_due_limit: u64,
pub flat_gas_limit: u64,
pub flat_gas_price: u64,
pub max_gas_threshold: u128,
}
impl GasLimitsPrices {
pub fn new() -> Self { Self::default() }
/// Calculate gas fee by gas used value
pub fn calc_gas_fee(&self, gas_used: u64) -> u128 {
// There is a flat_gas_limit value which is the minimum gas value possible and has fixed price.
// If actual gas value is less then flat_gas_limit then flat_gas_price paid.
// If actual gas value is bigger then flat_gas_limit then flat_gas_price paid for first
// flat_gas_limit gas and remaining value costs gas_price
if gas_used <= self.flat_gas_limit {
self.flat_gas_price as u128
} else {
// gas_price is pseudo value (shifted by 16 as forward and storage price)
// after calculation divide by 0xffff with ceil rounding
self.flat_gas_price as u128 + (((gas_used - self.flat_gas_limit) as u128 * self.gas_price as u128 + 0xffff) >> 16)
}
}
/// Get gas price in nanograms
pub fn get_real_gas_price(&self) -> u64 {
self.gas_price >> 16
}
/// Calculate gas by grams balance
pub fn calc_gas(&self, value: u128) -> u64 {
if value >= self.max_gas_threshold {
return self.gas_limit
}
if value < self.flat_gas_price as u128 {
return 0
}
let res = ((value - self.flat_gas_price as u128) << 16) / (self.gas_price as u128);
self.flat_gas_limit + res as u64
}
/// Calculate max gas threshold
pub fn calc_max_gas_threshold(&self) -> u128 {
let mut result = self.flat_gas_price as u128;
if self.gas_limit > self.flat_gas_limit {
result += ((self.gas_price as u128) * ((self.gas_limit - self.flat_gas_limit) as u128)) >> 16;
}
result
}
}
const GAS_PRICES_TAG: u8 = 0xDD;
const GAS_PRICES_EXT_TAG: u8 = 0xDE;
const GAS_FLAT_PFX_TAG: u8 = 0xD1;
impl Deserializable for GasLimitsPrices {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.flat_gas_limit = 0;
self.flat_gas_price = 0;
self.special_gas_limit = 0;
loop {
match cell.get_next_byte()? {
GAS_PRICES_TAG => {
self.gas_price.read_from(cell)?;
self.gas_limit.read_from(cell)?;
self.gas_credit.read_from(cell)?;
self.block_gas_limit.read_from(cell)?;
self.freeze_due_limit.read_from(cell)?;
self.delete_due_limit.read_from(cell)?;
break;
}
GAS_PRICES_EXT_TAG => {
self.gas_price.read_from(cell)?;
self.gas_limit.read_from(cell)?;
self.special_gas_limit.read_from(cell)?;
self.gas_credit.read_from(cell)?;
self.block_gas_limit.read_from(cell)?;
self.freeze_due_limit.read_from(cell)?;
self.delete_due_limit.read_from(cell)?;
break;
}
GAS_FLAT_PFX_TAG => {
self.flat_gas_limit.read_from(cell)?;
self.flat_gas_price.read_from(cell)?;
}
tag => {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
}
}
self.max_gas_threshold = self.calc_max_gas_threshold();
Ok(())
}
}
impl Serializable for GasLimitsPrices {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(GAS_FLAT_PFX_TAG)?;
self.flat_gas_limit.write_to(cell)?;
self.flat_gas_price.write_to(cell)?;
cell.append_u8(GAS_PRICES_EXT_TAG)?;
self.gas_price.write_to(cell)?;
self.gas_limit.write_to(cell)?;
self.special_gas_limit.write_to(cell)?;
self.gas_credit.write_to(cell)?;
self.block_gas_limit.write_to(cell)?;
self.freeze_due_limit.write_to(cell)?;
self.delete_due_limit.write_to(cell)?;
Ok(())
}
}
/*
config_mc_gas_prices#_ GasLimitsPrices = ConfigParam 20;
*/
/*
config_gas_prices#_ GasLimitsPrices = ConfigParam 21;
*/
/*
// msg_fwd_fees = (lump_price + ceil((bit_price * msg.bits + cell_price * msg.cells)/2^16)) nanograms
// ihr_fwd_fees = ceil((msg_fwd_fees * ihr_price_factor)/2^16) nanograms
// bits in the root cell of a message are not included in msg.bits (lump_price pays for them)
msg_forward_prices#ea
lump_price:uint64
bit_price:uint64
cell_price:uint64
ihr_price_factor:uint32
first_frac:uint16
next_frac:uint16
= MsgForwardPrices;
*/
///
/// MsgForwardPrices
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct MsgForwardPrices {
pub lump_price: u64,
pub bit_price: u64,
pub cell_price: u64,
pub ihr_price_factor: u32,
pub first_frac: u16,
pub next_frac: u16,
}
impl MsgForwardPrices {
pub fn new() -> Self { Self::default() }
}
const MSG_FWD_PRICES_TAG: u8 = 0xEA;
impl Deserializable for MsgForwardPrices {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
let tag = cell.get_next_byte()?;
if tag != MSG_FWD_PRICES_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.lump_price.read_from(cell)?;
self.bit_price.read_from(cell)?;
self.cell_price.read_from(cell)?;
self.ihr_price_factor.read_from(cell)?;
self.first_frac.read_from(cell)?;
self.next_frac.read_from(cell)?;
Ok(())
}
}
impl Serializable for MsgForwardPrices {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(MSG_FWD_PRICES_TAG)?;
self.lump_price.write_to(cell)?;
self.bit_price.write_to(cell)?;
self.cell_price.write_to(cell)?;
self.ihr_price_factor.write_to(cell)?;
self.first_frac.write_to(cell)?;
self.next_frac.write_to(cell)?;
Ok(())
}
}
/*
// used for messages to/from masterchain
config_mc_fwd_prices#_ MsgForwardPrices = ConfigParam 24;
// used for all other messages
config_fwd_prices#_ MsgForwardPrices = ConfigParam 25;
*/
/*
catchain_config#c1
mc_catchain_lifetime:uint32
shard_catchain_lifetime:uint32
shard_validators_lifetime:uint32
shard_validators_num:uint32
= CatchainConfig;
catchain_config_new#c2
flags: (## 7)
{ flags = 0 }
shuffle_mc_validators: Bool
mc_catchain_lifetime: uint3
shard_catchain_lifetime: uint32
shard_validators_lifetime: uint32
shard_validators_num: uint32
= CatchainConfig;
*/
///
/// MsgForwardPrices
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct CatchainConfig {
pub isolate_mc_validators: bool,
pub shuffle_mc_validators: bool,
pub mc_catchain_lifetime: u32,
pub shard_catchain_lifetime: u32,
pub shard_validators_lifetime: u32,
pub shard_validators_num: u32,
}
impl CatchainConfig {
pub fn new() -> Self { Self::default() }
}
const CATCHAIN_CONFIG_TAG_1: u8 = 0xC1;
const CATCHAIN_CONFIG_TAG_2: u8 = 0xC2;
impl Deserializable for CatchainConfig {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
let tag = cell.get_next_byte()?;
if (tag != CATCHAIN_CONFIG_TAG_1) && (tag != CATCHAIN_CONFIG_TAG_2) {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
if tag == CATCHAIN_CONFIG_TAG_2 {
let flags = u8::construct_from(cell)?;
self.isolate_mc_validators = flags & 0b10 != 0;
self.shuffle_mc_validators = flags & 0b01 != 0;
if flags >> 2 != 0 {
fail!(BlockError::InvalidArg("`flags` should be zero".to_string()))
}
}
self.mc_catchain_lifetime.read_from(cell)?;
self.shard_catchain_lifetime.read_from(cell)?;
self.shard_validators_lifetime.read_from(cell)?;
self.shard_validators_num.read_from(cell)?;
Ok(())
}
}
impl Serializable for CatchainConfig {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(CATCHAIN_CONFIG_TAG_2)?;
cell.append_bits(0, 6)?;
cell.append_bit_bool(self.isolate_mc_validators)?;
cell.append_bit_bool(self.shuffle_mc_validators)?;
self.mc_catchain_lifetime.write_to(cell)?;
self.shard_catchain_lifetime.write_to(cell)?;
self.shard_validators_lifetime.write_to(cell)?;
self.shard_validators_num.write_to(cell)?;
Ok(())
}
}
/*
_ CatchainConfig = ConfigParam 28;
*/
/*
_ fundamental_smc_addr:(HashmapE 256 True) = ConfigParam 31;
consensus_config#d6
round_candidates:# { round_candidates >= 1 }
next_candidate_delay_ms:uint32
consensus_timeout_ms:uint32
fast_attempts:uint32
attempt_duration:uint32
catchain_max_deps:uint32
max_block_bytes:uint32
max_collated_bytes:uint32
= ConsensusConfig;
consensus_config_new#d7
flags: (## 7)
{ flags = 0 }
new_catchain_ids: Bool
round_candidates: (## 8) { round_candidates >= 1 }
next_candidate_delay_ms: uint32
consensus_timeout_ms: uint32
fast_attempts: uint32
attempt_duration: uint32
catchain_max_deps: uint32
max_block_bytes: uint32
max_collated_bytes: uint32
= ConsensusConfig;
*/
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConsensusConfig {
pub new_catchain_ids: bool,
pub round_candidates: u32,
pub next_candidate_delay_ms: u32,
pub consensus_timeout_ms: u32,
pub fast_attempts: u32,
pub attempt_duration: u32,
pub catchain_max_deps: u32,
pub max_block_bytes: u32,
pub max_collated_bytes: u32,
}
impl ConsensusConfig {
pub fn new() -> Self { Self::default() }
}
const CONSENSUS_CONFIG_TAG_1: u8 = 0xD6;
const CONSENSUS_CONFIG_TAG_2: u8 = 0xD7;
impl Deserializable for ConsensusConfig {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
let tag = cell.get_next_byte()?;
if (tag != CONSENSUS_CONFIG_TAG_1) && (tag != CONSENSUS_CONFIG_TAG_2) {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
if tag == CONSENSUS_CONFIG_TAG_1 {
self.round_candidates.read_from(cell)?;
} else {
let flags = u8::construct_from(cell)?;
self.new_catchain_ids = flags == 1;
if flags >> 1 != 0 {
fail!(BlockError::InvalidArg("`flags` should be zero".to_string()))
}
self.round_candidates = u8::construct_from(cell)? as u32;
if self.round_candidates == 0 {
fail!(BlockError::InvalidArg("`round_candidates` should be positive".to_string()))
}
}
self.next_candidate_delay_ms.read_from(cell)?;
self.consensus_timeout_ms.read_from(cell)?;
self.fast_attempts.read_from(cell)?;
self.attempt_duration.read_from(cell)?;
self.catchain_max_deps.read_from(cell)?;
self.max_block_bytes.read_from(cell)?;
self.max_collated_bytes.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConsensusConfig {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
if self.round_candidates == 0 {
fail!(BlockError::InvalidArg("`round_candidates` should be positive".to_string()))
}
cell.append_u8(CONSENSUS_CONFIG_TAG_2)?;
cell.append_u8(self.new_catchain_ids as u8)?;
(self.round_candidates as u8).write_to(cell)?;
self.next_candidate_delay_ms.write_to(cell)?;
self.consensus_timeout_ms.write_to(cell)?;
self.fast_attempts.write_to(cell)?;
self.attempt_duration.write_to(cell)?;
self.catchain_max_deps.write_to(cell)?;
self.max_block_bytes.write_to(cell)?;
self.max_collated_bytes.write_to(cell)?;
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam29 {
pub consensus_config: ConsensusConfig,
}
impl ConfigParam29 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam29 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.consensus_config.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam29 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.consensus_config.write_to(cell)?;
Ok(())
}
}
/*
_ fundamental_smc_addr:(HashmapE 256 True) = ConfigParam 31;
*/
define_HashmapE!{FundamentalSmcAddresses, 256, ()}
impl IntoIterator for &FundamentalSmcAddresses {
type Item = <HashmapIterator<HashmapE> as std::iter::Iterator>::Item;
type IntoIter = HashmapIterator<HashmapE>;
fn into_iter(self) -> Self::IntoIter {
self.0.iter()
}
}
///
/// ConfigParam 30;
///
const DELECTOR_PARAMS_TAG: u8 = 0x1;
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct DelectorParams {
pub delections_step: u32,
pub validator_init_code_hash: UInt256,
pub staker_init_code_hash: UInt256,
}
impl Deserializable for DelectorParams {
fn construct_from(slice: &mut SliceData) -> Result<Self> {
let tag = slice.get_next_byte()?;
if tag != DELECTOR_PARAMS_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
let delections_step = Deserializable::construct_from(slice)?;
let validator_init_code_hash = Deserializable::construct_from(slice)?;
let staker_init_code_hash = Deserializable::construct_from(slice)?;
Ok(Self {
delections_step,
validator_init_code_hash,
staker_init_code_hash,
})
}
}
impl Serializable for DelectorParams {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
DELECTOR_PARAMS_TAG.write_to(cell)?; // tag
self.delections_step.write_to(cell)?;
self.validator_init_code_hash.write_to(cell)?;
self.staker_init_code_hash.write_to(cell)?;
Ok(())
}
}
///
/// ConfigParam 31;
///
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ConfigParam31 {
pub fundamental_smc_addr: FundamentalSmcAddresses,
}
impl ConfigParam31 {
pub fn new() -> Self { Self::default() }
pub fn add_address(&mut self, address: UInt256) {
self.fundamental_smc_addr.set(&address, &()).unwrap();
}
}
impl Deserializable for ConfigParam31 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.fundamental_smc_addr.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam31 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.fundamental_smc_addr.write_to(cell)?;
Ok(())
}
}
macro_rules! define_configparams {
( $cpname:ident, $pname:ident ) => {
///
/// $cpname structure
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct $cpname {
pub $pname: ValidatorSet,
}
impl $cpname {
/// create new instance of $cpname
pub fn new() -> Self { Self::default() }
}
impl Deserializable for $cpname {
fn construct_from(slice: &mut SliceData) -> Result<Self> {
let $pname = ValidatorSet::construct_from(slice)?;
Ok(Self { $pname })
}
}
impl Serializable for $cpname {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.$pname.write_to(cell)?;
Ok(())
}
}
}
}
// _ prev_validators:ValidatorSet = ConfigParam 32;
define_configparams!(ConfigParam32, prev_validators);
// _ prev_temp_validators: ValidatorSet = ConfigParam 33;
define_configparams!(ConfigParam33, prev_temp_validators);
// _ cur_validators:ValidatorSet = ConfigParam 34;
define_configparams!(ConfigParam34, cur_validators);
// _ cur_temp_validators: ValidatorSet = ConfigParam 35;
define_configparams!(ConfigParam35, cur_temp_validators);
//_ next_validators:ValidatorSet = ConfigParam 36;
define_configparams!(ConfigParam36, next_validators);
// _ next_temp_validators: ValidatorSet = ConfigParam 37;
define_configparams!(ConfigParam37, next_temp_validators);
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum WorkchainFormat {
Basic(WorkchainFormat1),
Extended(WorkchainFormat0),
}
impl Default for WorkchainFormat {
fn default() -> Self {
WorkchainFormat::Basic(WorkchainFormat1::default())
}
}
impl Deserializable for WorkchainFormat {
fn construct_from(slice: &mut SliceData) -> Result<Self> {
slice.get_next_bits(3)?;
match slice.get_next_bit()? {
true => {
Ok(WorkchainFormat::Basic(WorkchainFormat1::construct_from(slice)?))
}
false => {
Ok(WorkchainFormat::Extended(WorkchainFormat0::construct_from(slice)?))
}
}
}
}
impl Serializable for WorkchainFormat {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_bits(0, 3)?;
match self {
WorkchainFormat::Basic(ref val) => {
cell.append_bit_one()?;
val.write_to(cell)?;
},
WorkchainFormat::Extended(val) => {
cell.append_bit_zero()?;
val.write_to(cell)?;
}
}
Ok(())
}
}
/*
wfmt_basic#1
vm_version:int32
vm_mode:uint64
= WorkchainFormat 1;
*/
///
/// Workchain format basic
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct WorkchainFormat1 {
pub vm_version: i32,
pub vm_mode: u64,
}
impl WorkchainFormat1 {
///
/// Create empty intance of WorkchainFormat1
///
pub fn new() -> Self { Self::default() }
///
/// Create new instance of WorkchainFormat1
///
pub fn with_params(vm_version: i32, vm_mode: u64) -> Self {
WorkchainFormat1 {
vm_version,
vm_mode
}
}
}
impl Deserializable for WorkchainFormat1 {
fn construct_from(slice: &mut SliceData) -> Result<Self> {
let vm_version = Deserializable::construct_from(slice)?;
let vm_mode = Deserializable::construct_from(slice)?;
Ok(Self { vm_version, vm_mode })
}
}
impl Serializable for WorkchainFormat1 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.vm_version.write_to(cell)?;
self.vm_mode.write_to(cell)?;
Ok(())
}
}
/*
wfmt_ext#0
min_addr_len:(## 12)
max_addr_len:(## 12)
addr_len_step:(## 12)
{ min_addr_len >= 64 } { min_addr_len <= max_addr_len }
{ max_addr_len <= 1023 } { addr_len_step <= 1023 }
workchain_type_id:(## 32) { workchain_type_id >= 1 }
= WorkchainFormat 0;
*/
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct WorkchainFormat0 {
min_addr_len: Number12,
max_addr_len: Number12,
addr_len_step: Number12,
workchain_type_id: Number32,
}
impl Default for WorkchainFormat0 {
fn default() -> Self {
Self {
min_addr_len: Number12::from(64),
max_addr_len: Number12::from(64),
addr_len_step: Number12::from(0),
workchain_type_id: Number32::from(1)
}
}
}
impl WorkchainFormat0 {
///
/// Create empty new instance of WorkchainFormat0
///
pub fn new() -> Self { Self::default() }
///
/// Create new instance of WorkchainFormat0
///
pub fn with_params(min_addr_len: u16, max_addr_len: u16, addr_len_step: u16, workchain_type_id: u32 ) -> Result<WorkchainFormat0> {
if min_addr_len >= 64 && min_addr_len <= max_addr_len &&
max_addr_len <= 1023 && addr_len_step <= 1023 &&
workchain_type_id >= 1 {
Ok(
WorkchainFormat0 {
min_addr_len: Number12::new(min_addr_len as u32)?,
max_addr_len: Number12::new(max_addr_len as u32)?,
addr_len_step: Number12::new(addr_len_step as u32)?,
workchain_type_id: Number32::new(workchain_type_id)?,
}
)
}
else {
fail!(
BlockError::InvalidData(
"min_addr_len >= 64 && min_addr_len <= max_addr_len \
&& max_addr_len <= 1023 && addr_len_step <= 1023 \
&& workchain_type_id >= 1".to_string()
)
)
}
}
///
/// Getter for min_addr_len
///
pub fn min_addr_len(&self) -> u16 {
self.min_addr_len.as_u16()
}
///
/// Setter for min_addr_len
///
pub fn set_min_addr_len(&mut self, min_addr_len: u16) -> Result<()> {
if (64..=1023).contains(&min_addr_len) {
self.min_addr_len = Number12::new(min_addr_len as u32)?;
Ok(())
} else {
fail!(
BlockError::InvalidData(
"should: min_addr_len >= 64 && min_addr_len <= 1023".to_string()
)
)
}
}
///
/// Getter for min_addr_len
///
pub fn max_addr_len(&self) -> u16 {
self.max_addr_len.as_u16()
}
///
/// Setter for max_addr_len
///
pub fn set_max_addr_len(&mut self, max_addr_len: u16) -> Result<()> {
if (64..=1024).contains(&max_addr_len) && self.min_addr_len <= max_addr_len as u32 {
self.max_addr_len = Number12::new(max_addr_len as u32)?;
Ok(())
} else {
fail!(
BlockError::InvalidData(
"should: max_addr_len >= 64 && max_addr_len <= 1024 \
&& self.min_addr_len <= max_addr_len".to_string()
)
)
}
}
///
/// Getter for addr_len_step
///
pub fn addr_len_step(&self) -> u16 {
self.addr_len_step.as_u16()
}
///
/// Setter for min_addr_len
///
pub fn set_addr_len_step(&mut self, addr_len_step: u16) -> Result<()> {
if addr_len_step <= 1024 {
self.addr_len_step = Number12::new(addr_len_step as u32)?;
Ok(())
} else {
fail!(
BlockError::InvalidData("should: addr_len_step <= 1024".to_string())
)
}
}
///
/// Getter for workchain_type_id
///
pub fn workchain_type_id(&self) -> u32 {
self.workchain_type_id.as_u32()
}
///
/// Setter for min_addr_len
///
pub fn set_workchain_type_id(&mut self, workchain_type_id: u32) -> Result<()> {
if workchain_type_id >= 1 {
self.workchain_type_id = Number32::new(workchain_type_id)?;
Ok(())
} else {
fail!(
BlockError::InvalidData("should: workchain_type_id >= 1".to_string())
)
}
}
}
impl Deserializable for WorkchainFormat0 {
fn construct_from(slice: &mut SliceData) -> Result<Self> {
let min_addr_len = Number12::construct_from(slice)?;
let max_addr_len = Number12::construct_from(slice)?;
let addr_len_step = Number12::construct_from(slice)?;
let workchain_type_id = Number32::construct_from(slice)?;
if min_addr_len >= 64 && min_addr_len <= max_addr_len &&
max_addr_len <= 1023 && addr_len_step <= 1023 &&
workchain_type_id >= 1 {
Ok(Self {
min_addr_len,
max_addr_len,
addr_len_step,
workchain_type_id,
})
} else {
fail!(
BlockError::InvalidData(
"should: min_addr_len >= 64 && min_addr_len <= max_addr_len \
&& max_addr_len <= 1023 && addr_len_step <= 1023".to_string()
)
)
}
}
}
impl Serializable for WorkchainFormat0 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
if self.min_addr_len >= 64 && self.min_addr_len <= self.max_addr_len &&
self.max_addr_len <= 1023 && self.addr_len_step <= 1023 &&
self.workchain_type_id >= 1 {
self.min_addr_len.write_to(cell)?;
self.max_addr_len.write_to(cell)?;
self.addr_len_step.write_to(cell)?;
self.workchain_type_id.write_to(cell)?;
Ok(())
} else {
fail!(
BlockError::InvalidData(
"should: min_addr_len >= 64 && min_addr_len <= max_addr_len \
&& max_addr_len <= 1023 && addr_len_step <= 1023".to_string()
)
)
}
}
}
/*
workchain#a5
enabled_since:uint32
min_split:(## 8)
max_split:(## 8)
{ min_split <= max_split } { max_split <= 60 }
basic:(## 1)
active:Bool
accept_msgs:Bool
flags:(## 13) { flags = 0 }
zerostate_root_hash:bits256
zerostate_file_hash:bits256
version:uint32
format:(WorkchainFormat basic)
= WorkchainDescr;
*/
///
/// WorkchainDescr structure
///
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct WorkchainDescr {
pub enabled_since: u32,
actual_min_split: u8,
min_split: u8,
max_split: u8,
//basic: bool, // depends on format
pub active: bool,
pub accept_msgs: bool,
pub flags: u16, // 13 bit
pub zerostate_root_hash: UInt256,
pub zerostate_file_hash: UInt256,
pub version: u32,
pub format: WorkchainFormat
}
impl WorkchainDescr {
///
/// Create empty instance of WorkchainDescr
///
pub fn new() -> Self { Self::default() }
///
/// Getter for min_split
///
pub fn min_split(&self) -> u8 {
self.min_split
}
///
/// Setter for min_split
///
pub fn set_min_split(&mut self, min_split: u8) -> Result<()> {
if min_split <= 60 {
self.min_split = min_split;
Ok(())
} else {
fail!(
BlockError::InvalidData(
"should: min_split <= max_split && max_split <= 60".to_string()
)
)
}
}
///
/// Getter for actual_min_split
///
pub fn actual_min_split(&self) -> u8 {
self.actual_min_split
}
///
/// Getter for max_split
///
pub fn max_split(&self) -> u8 {
self.max_split
}
///
/// Setter for max_split
///
pub fn set_max_split(&mut self, max_split: u8) -> Result<()> {
if self.min_split <= max_split && max_split <= 60 {
self.max_split = max_split;
Ok(())
} else {
fail!(
BlockError::InvalidData(
"should: min_split <= max_split && max_split <= 60".to_string()
)
)
}
}
pub fn active(&self) -> bool {
self.active
}
pub fn basic(&self) -> bool {
matches!(self.format, WorkchainFormat::Basic(_))
}
}
const WORKCHAIN_DESCRIPTOR_TAG : u8 = 0xA6;
impl Deserializable for WorkchainDescr {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
let tag = cell.get_next_byte()?;
if tag != WORKCHAIN_DESCRIPTOR_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.enabled_since.read_from(cell)?;
let mut min = Number8::default();
min.read_from(cell)?;
self.actual_min_split = min.as_u8();
let mut min = Number8::default();
min.read_from(cell)?;
self.min_split = min.as_u8();
let mut max = Number8::default();
max.read_from(cell)?;
self.max_split = max.as_u8();
cell.get_next_bit()?; // basic
self.active = cell.get_next_bit()?;
self.accept_msgs = cell.get_next_bit()?;
let mut flags = Number13::default();
flags.read_from(cell)?;
self.flags = flags.as_u16();
self.zerostate_root_hash.read_from(cell)?;
self.zerostate_file_hash.read_from(cell)?;
self.version.read_from(cell)?;
self.format.read_from(cell)?;
Ok(())
}
}
impl Serializable for WorkchainDescr {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
if self.min_split <= self.max_split && self.max_split <= crate::shard::MAX_SPLIT_DEPTH {
cell.append_u8(WORKCHAIN_DESCRIPTOR_TAG)?;
self.enabled_since.write_to(cell)?;
let min = Number8::new(self.actual_min_split as u32)?;
min.write_to(cell)?;
let min = Number8::new(self.min_split as u32)?;
min.write_to(cell)?;
let max = Number8::new(self.max_split as u32)?;
max.write_to(cell)?;
if let WorkchainFormat::Basic(_) = self.format {
cell.append_bit_one()?;
} else {
cell.append_bit_zero()?;
}
if self.active {
cell.append_bit_one()?;
} else {
cell.append_bit_zero()?;
}
if self.accept_msgs {
cell.append_bit_one()?;
} else {
cell.append_bit_zero()?;
}
let flags = Number13::new(self.flags as u32)?;
flags.write_to(cell)?;
self.zerostate_root_hash.write_to(cell)?;
self.zerostate_file_hash.write_to(cell)?;
self.version.write_to(cell)?;
self.format.write_to(cell)?;
Ok(())
} else {
fail!(
BlockError::InvalidData(
"should: min_split <= max_split && max_split <= 60".to_string()
)
)
}
}
}
/*
cfg_vote_cfg#36
min_tot_rounds: uint8
max_tot_rounds: uint8
min_wins: uint8
max_losses: uint8
min_store_sec: uint32
max_store_sec: uint32
bit_price: uint32
cell_price: uint32
= ConfigProposalSetup;
cfg_vote_setup#91
normal_params: ^ConfigProposalSetup
critical_params: ^ConfigProposalSetup
= ConfigVotingSetup;
_ ConfigVotingSetup = ConfigParam 11;
*/
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ConfigProposalSetup {
pub min_tot_rounds: u8,
pub max_tot_rounds: u8,
pub min_wins: u8,
pub max_losses: u8,
pub min_store_sec: u32,
pub max_store_sec: u32,
pub bit_price: u32,
pub cell_price: u32,
}
const CONFIG_PROPOSAL_SETUP_TAG : u8 = 0x36;
impl Deserializable for ConfigProposalSetup {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
let tag = slice.get_next_byte()?;
if tag != CONFIG_PROPOSAL_SETUP_TAG {
fail!(BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
})
}
self.min_tot_rounds.read_from(slice)?;
self.max_tot_rounds.read_from(slice)?;
self.min_wins.read_from(slice)?;
self.max_losses.read_from(slice)?;
self.min_store_sec.read_from(slice)?;
self.max_store_sec.read_from(slice)?;
self.bit_price.read_from(slice)?;
self.cell_price.read_from(slice)?;
Ok(())
}
}
impl Serializable for ConfigProposalSetup {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(CONFIG_PROPOSAL_SETUP_TAG)?;
self.min_tot_rounds.write_to(cell)?;
self.max_tot_rounds.write_to(cell)?;
self.min_wins.write_to(cell)?;
self.max_losses.write_to(cell)?;
self.min_store_sec.write_to(cell)?;
self.max_store_sec.write_to(cell)?;
self.bit_price.write_to(cell)?;
self.cell_price.write_to(cell)?;
Ok(())
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ConfigVotingSetup {
normal_params: ChildCell<ConfigProposalSetup>,
critical_params: ChildCell<ConfigProposalSetup>,
}
impl ConfigVotingSetup {
pub fn new(normal_params: &ConfigProposalSetup, critical_params: &ConfigProposalSetup) -> Result<Self> {
Ok(
ConfigVotingSetup {
normal_params: ChildCell::with_struct(normal_params)?,
critical_params: ChildCell::with_struct(critical_params)?,
}
)
}
pub fn read_normal_params(&self) -> Result<ConfigProposalSetup> {
self.normal_params.read_struct()
}
pub fn write_normal_params(&mut self, value: &ConfigProposalSetup) -> Result<()> {
self.normal_params.write_struct(value)
}
pub fn normal_params_cell(&self)-> Cell {
self.normal_params.cell()
}
pub fn read_critical_params(&self) -> Result<ConfigProposalSetup> {
self.critical_params.read_struct()
}
pub fn write_critical_params(&mut self, value: &ConfigProposalSetup) -> Result<()> {
self.critical_params.write_struct(value)
}
pub fn critical_params_cell(&self)-> Cell {
self.critical_params.cell()
}
}
const CONFIG_VOTING_SETUP_TAG : u8 = 0x91;
impl Deserializable for ConfigVotingSetup {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
let tag = slice.get_next_byte()?;
if tag != CONFIG_VOTING_SETUP_TAG {
fail!(BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
})
}
self.normal_params.read_from(slice)?;
self.critical_params.read_from(slice)?;
Ok(())
}
}
impl Serializable for ConfigVotingSetup {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(CONFIG_VOTING_SETUP_TAG)?;
self.normal_params.write_to(cell)?;
self.critical_params.write_to(cell)?;
Ok(())
}
}
pub type ConfigParam11 = ConfigVotingSetup;
/*
_ workchains:(HashmapE 32 WorkchainDescr) = ConfigParam 12;
*/
define_HashmapE!{Workchains, 32, WorkchainDescr}
///
/// ConfigParam 12 struct
///
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ConfigParam12 {
pub workchains: Workchains,
}
impl ConfigParam12 {
/// new instance of ConfigParam12
pub fn new() -> Self { Self::default() }
/// get length
pub fn len(&self) -> Result<usize> {
self.workchains.len()
}
/// determine is empty
pub fn is_empty(&self) -> bool {
self.workchains.is_empty()
}
/// get value by index
pub fn get(&self, workchain_id: i32) -> Result<Option<WorkchainDescr>> {
self.workchains.get(&workchain_id)
}
/// insert value
pub fn insert(&mut self, workchain_id: i32, sp: &WorkchainDescr) -> Result<()> {
self.workchains.set(&workchain_id, sp)
}
}
impl Deserializable for ConfigParam12 {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
self.workchains.read_from(slice)?;
Ok(())
}
}
impl Serializable for ConfigParam12 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.workchains.write_to(cell)?;
Ok(())
}
}
///
/// ConfigParam 13 struct
///
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ConfigParam13 {
pub cell: Cell,
}
impl Deserializable for ConfigParam13 {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
self.cell = slice.clone().into_cell();
Ok(())
}
}
impl Serializable for ConfigParam13 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.checked_append_references_and_data(&SliceData::load_cell_ref(&self.cell)?)?;
Ok(())
}
}
// validator_temp_key#3
// adnl_addr:bits256
// temp_public_key:SigPubKey
// seqno:#
// valid_until:uint32
// = ValidatorTempKey;
const VALIDATOR_TEMP_KEY_TAG: u8 = 0x3;
#[derive(Clone, Default, Debug, Eq, PartialEq)]
pub struct ValidatorTempKey {
adnl_addr: UInt256,
temp_public_key: SigPubKey,
seqno: u32,
valid_until: u32
}
impl ValidatorTempKey {
/// new instance of ValidatorTempKey
pub fn new() -> Self { Self::default() }
pub fn with_params(adnl_addr: UInt256, temp_public_key: SigPubKey, seqno: u32, valid_until: u32)
-> Self {
Self {
adnl_addr,
temp_public_key,
seqno,
valid_until
}
}
pub fn set_adnl_addr(&mut self, adnl_addr: UInt256) {
self.adnl_addr = adnl_addr
}
pub fn adnl_addr(&self) -> &UInt256 {
&self.adnl_addr
}
pub fn set_key(&mut self, temp_public_key: SigPubKey) {
self.temp_public_key = temp_public_key
}
pub fn temp_public_key(&self) -> &SigPubKey {
&self.temp_public_key
}
pub fn set_seqno(&mut self, seqno: u32) {
self.seqno = seqno
}
pub fn seqno(&self) -> u32 {
self.seqno
}
pub fn set_valid_until(&mut self, valid_until: u32) {
self.valid_until = valid_until
}
pub fn valid_until(&self) -> u32 {
self.valid_until
}
}
impl Deserializable for ValidatorTempKey {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
let tag = slice.get_next_byte()?; // TODO what is tag length in bits???
if tag != VALIDATOR_TEMP_KEY_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.adnl_addr.read_from(slice)?;
self.temp_public_key.read_from(slice)?;
self.seqno.read_from(slice)?;
self.valid_until.read_from(slice)?;
Ok(())
}
}
impl Serializable for ValidatorTempKey {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(VALIDATOR_TEMP_KEY_TAG)?; // TODO what is tag length in bits???
self.adnl_addr.write_to(cell)?;
self.temp_public_key.write_to(cell)?;
self.seqno.write_to(cell)?;
self.valid_until.write_to(cell)?;
Ok(())
}
}
// signed_temp_key#4
// key:^ValidatorTempKey
// signature:CryptoSignature
// = ValidatorSignedTempKey;
const VALIDATOR_SIGNED_TEMP_KEY_TAG: u8 = 0x4;
#[derive(Clone, Default, Debug, Eq, PartialEq)]
pub struct ValidatorSignedTempKey {
key: ValidatorTempKey,
signature: CryptoSignature
}
impl ValidatorSignedTempKey {
/// new instance of
pub fn with_key_and_signature(key: ValidatorTempKey, signature: CryptoSignature) -> Self {
Self {key, signature}
}
pub fn key(&self) -> &ValidatorTempKey {
&self.key
}
pub fn signature(&self) -> &CryptoSignature {
&self.signature
}
}
impl Deserializable for ValidatorSignedTempKey {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
let tag = slice.get_next_byte()?; // TODO what is tag length in bits???
if tag != VALIDATOR_SIGNED_TEMP_KEY_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.signature.read_from(slice)?;
self.key.read_from_cell(slice.checked_drain_reference()?)?;
Ok(())
}
}
impl Serializable for ValidatorSignedTempKey {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(VALIDATOR_SIGNED_TEMP_KEY_TAG)?; // TODO what is tag length in bits???
self.signature.write_to(cell)?;
cell.checked_append_reference(self.key.serialize()?)?;
Ok(())
}
}
///
/// ConfigParam 39 struct
///
// _ (HashmapE 256 ValidatorSignedTempKey) = ConfigParam 39;
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ConfigParam39 {
pub validator_keys: ValidatorKeys,
}
define_HashmapE!(ValidatorKeys, 256, ValidatorSignedTempKey);
impl ConfigParam39 {
pub fn new() -> Self { Self::default() }
/// get length
pub fn len(&self) -> Result<usize> {
self.validator_keys.len()
}
/// determine is empty
pub fn is_empty(&self) -> bool {
self.validator_keys.is_empty()
}
/// get value by key
pub fn get(&self, key: &UInt256) -> Result<ValidatorSignedTempKey> {
self
.validator_keys
.get(key)?
.ok_or_else(|| error!(BlockError::InvalidArg(format!("{:x}", key))))
}
/// insert value
pub fn insert(&mut self, key: &UInt256, validator_key: &ValidatorSignedTempKey) -> Result<()> {
self.validator_keys.set(key, validator_key)
}
}
impl Deserializable for ConfigParam39 {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
self.validator_keys.read_from(slice)?;
Ok(())
}
}
impl Serializable for ConfigParam39 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.validator_keys.write_to(cell)?;
Ok(())
}
}
///
/// ConfigParam 40 struct
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigParam40 {
pub slashing_config: SlashingConfig,
}
impl ConfigParam40 {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigParam40 {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
self.slashing_config.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigParam40 {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.slashing_config.write_to(cell)?;
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SlashingConfig {
pub slashing_period_mc_blocks_count : u32, //number of MC blocks for one slashing iteration
pub resend_mc_blocks_count : u32, //number of MC blocks to resend slashing messages in case they have not been delivered
pub min_samples_count : u32, //minimal number of samples to compute statistics parameters
pub collations_score_weight : u32, //weight for collations score in total score
pub signing_score_weight : u32, //weight for signing score in total score
pub min_slashing_protection_score : u32, //minimal score to protect from any slashing [0..100]
pub z_param_numerator : u32, //numerator for Z param of confidence interval
pub z_param_denominator : u32, //numerator for Z param of confidence interval
}
impl SlashingConfig {
pub fn new() -> Self { Self::default() }
}
impl Default for SlashingConfig {
fn default() -> SlashingConfig {
Self {
slashing_period_mc_blocks_count : 100,
resend_mc_blocks_count : 4,
min_samples_count : 30,
collations_score_weight : 0,
signing_score_weight : 1,
min_slashing_protection_score : 70,
z_param_numerator : 2326, //98% confidence
z_param_denominator : 1000,
}
}
}
const SLASHING_VERSION1_TAG: u8 = 1;
impl Deserializable for SlashingConfig {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
match cell.get_next_byte()? {
SLASHING_VERSION1_TAG => {
self.slashing_period_mc_blocks_count.read_from(cell)?;
self.resend_mc_blocks_count.read_from(cell)?;
self.min_samples_count.read_from(cell)?;
self.collations_score_weight.read_from(cell)?;
self.signing_score_weight.read_from(cell)?;
self.min_slashing_protection_score.read_from(cell)?;
self.z_param_numerator.read_from(cell)?;
self.z_param_denominator.read_from(cell)?;
}
tag => {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
}
Ok(())
}
}
impl Serializable for SlashingConfig {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(SLASHING_VERSION1_TAG)?;
self.slashing_period_mc_blocks_count.write_to(cell)?;
self.resend_mc_blocks_count.write_to(cell)?;
self.min_samples_count.write_to(cell)?;
self.collations_score_weight.write_to(cell)?;
self.signing_score_weight.write_to(cell)?;
self.min_slashing_protection_score.write_to(cell)?;
self.z_param_numerator.write_to(cell)?;
self.z_param_denominator.write_to(cell)?;
Ok(())
}
}
#[derive(Debug, Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
pub enum ParamLimitIndex {
Underload = 0,
Normal,
Soft,
Medium,
Hard
}
const LIMIT_COUNT: usize = 4;
// param_limits#c3
// underload:#
// soft_limit:#
// { underload <= soft_limit }
// hard_limit:#
// { soft_limit <= hard_limit }
// = ParamLimits;
const PARAM_LIMITS_TAG: u8 = 0xc3;
#[derive(Clone, Default, Debug, Eq, PartialEq)]
pub struct ParamLimits {
// [ unerload , soft, (soft+hard)/2, hard ]
limits: [u32; LIMIT_COUNT],
}
impl ParamLimits {
pub fn with_limits(underload: u32, soft: u32, hard: u32) -> Result<Self> {
let mut limits = [0u32; LIMIT_COUNT];
Self::set_limits(&mut limits, underload, soft, hard)?;
Ok(Self{limits})
}
pub fn classify(&self, value: u32) -> ParamLimitIndex {
if value >= self.medium() {
if value >= self.hard_limit() {
ParamLimitIndex::Hard
} else {
ParamLimitIndex::Medium
}
} else if value >= self.underload() {
if value >= self.soft_limit() {
ParamLimitIndex::Soft
} else {
ParamLimitIndex::Normal
}
} else {
ParamLimitIndex::Underload
}
}
pub fn fits(&self, level: ParamLimitIndex, value: u32) -> bool {
// *level* *checks*
// Underload value < unerload
// Normal value < soft
// Soft value < medium
// Medium value < hard
// Hard always true
level == ParamLimitIndex::Hard || value < self.limits[level as usize]
}
pub fn fits_normal(&self, value: u32, percent: u32) -> bool {
value * 100 < self.soft_limit() * percent
}
pub fn underload(&self) -> u32 {
self.limits[ParamLimitIndex::Underload as usize]
}
pub fn soft_limit(&self) -> u32 {
self.limits[ParamLimitIndex::Soft as usize - 1]
}
pub fn medium(&self) -> u32 {
self.limits[ParamLimitIndex::Medium as usize - 1]
}
pub fn hard_limit(&self) -> u32 {
self.limits[ParamLimitIndex::Hard as usize - 1]
}
fn compute_medium_limit(soft: u32, hard: u32) -> u32 {
soft + ((hard - soft) >> 1)
}
fn set_limits(
limits: &mut [u32; LIMIT_COUNT],
underload: u32,
soft: u32,
hard: u32
) -> Result<()> {
if underload > soft {
fail!(
BlockError::InvalidArg(
"underload have to be less or equal to soft limit".to_string()
)
)
}
if soft > hard {
fail!(
BlockError::InvalidArg(
"soft limit have to be less or equal to hard one".to_string()
)
)
}
limits[ParamLimitIndex::Underload as usize] = underload;
limits[ParamLimitIndex::Soft as usize - 1] = soft;
limits[ParamLimitIndex::Medium as usize - 1] = Self::compute_medium_limit(soft, hard);
limits[ParamLimitIndex::Hard as usize - 1] = hard;
Ok(())
}
}
impl Deserializable for ParamLimits {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
let tag = slice.get_next_byte()?;
if tag != PARAM_LIMITS_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
let underload = u32::construct_from(slice)?;
let soft = u32::construct_from(slice)?;
let hard = u32::construct_from(slice)?;
Self::set_limits(&mut self.limits, underload, soft, hard)
}
}
impl Serializable for ParamLimits {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(PARAM_LIMITS_TAG)?;
self.underload().write_to(cell)?;
self.soft_limit().write_to(cell)?;
self.hard_limit().write_to(cell)?;
Ok(())
}
}
// block_limits#5d
// bytes:ParamLimits
// gas:ParamLimits
// lt_delta:ParamLimits
// = BlockLimits;
const BLOCK_LIMITS_TAG: u8 = 0x5d;
#[derive(Clone, Default, Debug, Eq, PartialEq)]
pub struct BlockLimits {
bytes: ParamLimits,
gas: ParamLimits,
lt_delta: ParamLimits,
}
impl BlockLimits {
pub fn with_limits(bytes: ParamLimits, gas: ParamLimits, lt_delta: ParamLimits) -> Self {
Self { bytes, gas, lt_delta }
}
pub fn bytes(&self) -> &ParamLimits {
&self.bytes
}
pub fn gas(&self) -> &ParamLimits {
&self.gas
}
pub fn lt_delta(&self) -> &ParamLimits {
&self.lt_delta
}
pub fn fits(&self, level: ParamLimitIndex, bytes: u32, gas: u32, lt_delta: u32) -> bool {
self.gas.fits(level, gas) &&
self.bytes.fits(level, bytes) &&
self.lt_delta.fits(level, lt_delta)
}
pub fn fits_normal(&self, bytes: u32, gas: u32, lt_delta: u32, percent: u32) -> bool {
self.gas.fits_normal(gas, percent) &&
self.bytes.fits_normal(bytes, percent) &&
self.lt_delta.fits_normal(lt_delta, percent)
}
}
impl Deserializable for BlockLimits {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
let tag = slice.get_next_byte()?;
if tag != BLOCK_LIMITS_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.bytes.read_from(slice)?;
self.gas.read_from(slice)?;
self.lt_delta.read_from(slice)?;
Ok(())
}
}
impl Serializable for BlockLimits {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(BLOCK_LIMITS_TAG)?;
self.bytes.write_to(cell)?;
self.gas.write_to(cell)?;
self.lt_delta.write_to(cell)?;
Ok(())
}
}
type ConfigParam22 = BlockLimits;
type ConfigParam23 = BlockLimits;
const COPYLEFT_TAG: u8 = 0x9A;
///
/// ConfigParam 42 struct
///
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConfigCopyleft {
pub copyleft_reward_threshold: Grams,
pub license_rates: LicenseRates,
}
define_HashmapE!(LicenseRates, 8, u8);
impl ConfigCopyleft {
pub fn new() -> Self { Self::default() }
}
impl Deserializable for ConfigCopyleft {
fn read_from(&mut self, cell: &mut SliceData) -> Result<()> {
let tag = cell.get_next_byte()?;
if tag != COPYLEFT_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.copyleft_reward_threshold.read_from(cell)?;
self.license_rates.read_from(cell)?;
Ok(())
}
}
impl Serializable for ConfigCopyleft {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_u8(COPYLEFT_TAG)?;
self.copyleft_reward_threshold.write_to(cell)?;
self.license_rates.write_to(cell)?;
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct SuspendedAddressesKey {
pub workchain_id: i32,
pub address: UInt256,
}
impl SuspendedAddressesKey {
pub fn new(workchain_id: i32, address: UInt256) -> Self {
Self { workchain_id, address }
}
}
impl Serializable for SuspendedAddressesKey {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
cell.append_i32(self.workchain_id)?;
cell.append_raw(self.address.as_slice(), 256)?;
Ok(())
}
}
impl Deserializable for SuspendedAddressesKey {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
self.workchain_id = slice.get_next_i32()?;
self.address = UInt256::construct_from(slice)?;
Ok(())
}
}
define_HashmapE!{SuspendedAddresses, 288, ()}
impl SuspendedAddresses {
pub fn is_suspended(&self, wc: i32, addr: UInt256) -> Result<bool> {
let key = SuspendedAddressesKey::new(wc, addr);
Ok(self.get(&key)?.is_some())
}
pub fn add_suspended_address(&mut self, wc: i32, addr: UInt256) -> Result<()> {
let key = SuspendedAddressesKey::new(wc, addr);
self.set(&key, &())
}
}
define_HashmapE!{MeshConfig, 32, ConnectedNwConfig}
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct ConnectedNwConfig {
// root cell
pub zerostate: BlockIdExt, // 1 + 4 + 8 + 4 + 32 + 32 = 81
pub is_active: bool, // 1
pub currency_id: u32, // 4
// 86
// cell1
pub init_block: BlockIdExt, // 81
pub emergency_guard_addr: UInt256, // 32
// 113
// cell2
pub pull_addr: UInt256, // The storage for native tokens of our network,
// which are wrapped in the connected network.
// 32
pub minter_addr: UInt256,// 32
// 64
// cell3
pub hardforks: Vec<BlockIdExt>, // 81 + chain
}
const MESH_INFO_TAG: u8 = 0x01;
impl Deserializable for ConnectedNwConfig {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
let tag = slice.get_next_byte()?;
if tag != MESH_INFO_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
self.zerostate.read_from(slice)?;
self.is_active.read_from(slice)?;
self.currency_id.read_from(slice)?;
let mut slice1 = SliceData::load_cell(slice.checked_drain_reference()?)?;
self.init_block.read_from(&mut slice1)?;
self.emergency_guard_addr.read_from(&mut slice1)?;
let mut slice2 = SliceData::load_cell(slice.checked_drain_reference()?)?;
self.pull_addr.read_from(&mut slice2)?;
self.minter_addr.read_from(&mut slice2)?;
if slice.get_next_bit()? {
let mut slice = slice.clone();
while let Ok(ref_cell) = slice.checked_drain_reference() {
let mut ref_slice = SliceData::load_cell(ref_cell)?;
self.hardforks.push(BlockIdExt::construct_from(&mut ref_slice)?);
slice = ref_slice;
}
}
Ok(())
}
}
impl Serializable for ConnectedNwConfig {
fn write_to(&self, builder: &mut BuilderData) -> Result<()> {
builder.append_u8(MESH_INFO_TAG)?;
self.zerostate.write_to(builder)?;
self.is_active.write_to(builder)?;
self.currency_id.write_to(builder)?;
let mut builder1 = BuilderData::new();
self.init_block.write_to(&mut builder1)?;
self.emergency_guard_addr.write_to(&mut builder1)?;
builder.checked_append_reference(builder1.into_cell()?)?;
let mut builder2 = BuilderData::new();
self.pull_addr.write_to(&mut builder2)?;
self.minter_addr.write_to(&mut builder2)?;
builder.checked_append_reference(builder2.into_cell()?)?;
let mut prev_builder: Option<BuilderData> = None;
for hardfork in self.hardforks.iter().rev() {
let mut builder = BuilderData::new();
hardfork.write_to(&mut builder)?;
if let Some(prev_builder) = prev_builder {
builder.checked_append_reference(prev_builder.into_cell()?)?;
}
prev_builder = Some(builder);
}
if let Some(prev_builder) = prev_builder {
builder.append_bit_one()?;
builder.checked_append_reference(prev_builder.into_cell()?)?;
} else {
builder.append_bit_zero()?;
}
Ok(())
}
}
#[cfg(test)]
pub(crate) fn dump_config(params: &HashmapE) {
params.iterate_slices(|ref mut key, ref mut slice| -> Result<bool> {
let key = key.get_next_u32()?;
match ConfigParamEnum::construct_from_slice_and_number(&mut SliceData::load_cell(slice.reference(0)?)?, key)? {
ConfigParamEnum::ConfigParam31(ref mut cfg) => {
println!("\tConfigParam31.fundamental_smc_addr");
cfg.fundamental_smc_addr.iterate_keys(|addr: UInt256| -> Result<bool> {
println!("\t\t{}", addr);
Ok(true)
})?;
}
ConfigParamEnum::ConfigParam34(ref mut cfg) => {
println!("\tConfigParam34.cur_validators");
for validator in cfg.cur_validators.list() {
println!("\t\t{:?}", validator);
};
}
x => println!("\t{:?}", x)
}
Ok(true)
}).unwrap();
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FastFinalityConfig {
pub split_merge_interval: u32,
pub collator_range_len: u32,
pub lost_collator_timeout: u32,
pub mempool_validators_count: u32,
pub mempool_rotated_count: u32, // How many validators are changed beetween sessions.
// Must be <= mempool_validators_count.
pub unreliability_fine: u16,
pub unreliability_weak_fading: u16,
pub unreliability_strong_fading: u16,
pub unreliability_max: u16,
pub unreliability_weight: u16,
pub familiarity_collator_fine: u16,
pub familiarity_msgpool_fine: u16,
pub familiarity_fading: u16,
pub familiarity_max: u16,
pub familiarity_weight: u16,
pub busyness_collator_fine: u16,
pub busyness_msgpool_fine: u16,
pub busyness_weight: u16,
pub candidates_percentile: u8,
}
impl Default for FastFinalityConfig {
fn default() -> Self {
Self {
split_merge_interval: 128,
collator_range_len: 5000,
lost_collator_timeout: 60,
mempool_validators_count: 3,
mempool_rotated_count: 1,
unreliability_fine: 100,
unreliability_weak_fading: 1,
unreliability_strong_fading: 10,
unreliability_max: u16::MAX,
unreliability_weight: 1,
familiarity_collator_fine: 2,
familiarity_msgpool_fine: 1,
familiarity_fading: 1,
familiarity_max: u16::MAX,
familiarity_weight: 2,
busyness_collator_fine: 4,
busyness_msgpool_fine: 1,
busyness_weight: 1,
candidates_percentile: 5,
}
}
}
impl Serializable for FastFinalityConfig {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
self.split_merge_interval.write_to(cell)?;
self.collator_range_len.write_to(cell)?;
self.lost_collator_timeout.write_to(cell)?;
self.mempool_validators_count.write_to(cell)?;
self.mempool_rotated_count.write_to(cell)?;
self.unreliability_fine.write_to(cell)?;
self.unreliability_weak_fading.write_to(cell)?;
self.unreliability_strong_fading.write_to(cell)?;
self.unreliability_max.write_to(cell)?;
self.unreliability_weight.write_to(cell)?;
self.familiarity_collator_fine.write_to(cell)?;
self.familiarity_msgpool_fine.write_to(cell)?;
self.familiarity_fading.write_to(cell)?;
self.familiarity_max.write_to(cell)?;
self.familiarity_weight.write_to(cell)?;
self.busyness_collator_fine.write_to(cell)?;
self.busyness_msgpool_fine.write_to(cell)?;
self.busyness_weight.write_to(cell)?;
self.candidates_percentile.write_to(cell)?;
Ok(())
}
}
impl Deserializable for FastFinalityConfig {
fn read_from(&mut self, slice: &mut SliceData) -> Result<()> {
self.split_merge_interval.read_from(slice)?;
self.collator_range_len.read_from(slice)?;
self.lost_collator_timeout.read_from(slice)?;
self.mempool_validators_count.read_from(slice)?;
self.mempool_rotated_count.read_from(slice)?;
if self.mempool_rotated_count > self.mempool_validators_count {
fail!(BlockError::InvalidData(
"mempool_rotated_count must be less or equal to mempool_validators_count".to_string()))
}
self.unreliability_fine.read_from(slice)?;
self.unreliability_weak_fading.read_from(slice)?;
self.unreliability_strong_fading.read_from(slice)?;
self.unreliability_max.read_from(slice)?;
self.unreliability_weight.read_from(slice)?;
self.familiarity_collator_fine.read_from(slice)?;
self.familiarity_msgpool_fine.read_from(slice)?;
self.familiarity_fading.read_from(slice)?;
self.familiarity_max.read_from(slice)?;
self.familiarity_weight.read_from(slice)?;
self.busyness_collator_fine.read_from(slice)?;
self.busyness_msgpool_fine.read_from(slice)?;
self.busyness_weight.read_from(slice)?;
self.candidates_percentile.read_from(slice)?;
Ok(())
}
}
///
/// ConfigParam 62;
///
const SMFT_PARAMS_TAG: u8 = 0x2;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SmftParams {
pub min_forwarding_neighbours_count: u32,
pub max_forwarding_neighbours_count: u32,
pub min_far_neighbours_count: u32,
pub max_far_neighbours_count: u32,
pub min_block_sync_period_ms: u32,
pub max_block_sync_period_ms: u32,
pub min_far_neighbours_sync_period_ms: u32,
pub max_far_neighbours_sync_period_ms: u32,
pub far_neighbours_resync_period_ms: u32,
pub block_sync_lifetime_period_ms: u32,
pub block_lifetime_period_ms: u32,
pub verification_obligation_cutoff_numerator: u32,
pub verification_obligation_cutoff_denominator: u32,
pub delivery_cutoff_numerator: u32,
pub delivery_cutoff_denominator: u32,
pub manual_candidate_loading_delay_ms: u32,
pub mc_allowed_force_delivery_delay_ms: u32,
pub mc_force_delivery_duplication_factor_numerator: u32,
pub mc_force_delivery_duplication_factor_denominator: u32,
pub mc_max_delivery_waiting_timeout_ms: u32, //0 - shadow mode
pub use_debug_bls_keys: bool, //true by default for insecure SMFT testing
}
impl SmftParams {
pub const fn new() -> Self {
Self {
min_forwarding_neighbours_count: 5,
max_forwarding_neighbours_count: 32,
min_far_neighbours_count: 2,
max_far_neighbours_count: 5,
min_block_sync_period_ms: 300,
max_block_sync_period_ms: 600,
min_far_neighbours_sync_period_ms: 1000,
max_far_neighbours_sync_period_ms: 2000,
far_neighbours_resync_period_ms: 1000,
block_sync_lifetime_period_ms: 10000,
block_lifetime_period_ms: 240000,
verification_obligation_cutoff_numerator: 1,
verification_obligation_cutoff_denominator: 5,
delivery_cutoff_numerator: 1,
delivery_cutoff_denominator: 2,
manual_candidate_loading_delay_ms: 4000,
mc_allowed_force_delivery_delay_ms: 4000,
mc_force_delivery_duplication_factor_numerator: 3,
mc_force_delivery_duplication_factor_denominator: 1,
mc_max_delivery_waiting_timeout_ms: 0, //by default network is working in shadow SMFT mode
use_debug_bls_keys: true,
}
}
}
impl Default for SmftParams {
fn default() -> SmftParams {
Self::new()
}
}
impl Deserializable for SmftParams {
fn construct_from(slice: &mut SliceData) -> Result<Self> {
let tag = slice.get_next_byte()?;
if tag != SMFT_PARAMS_TAG {
fail!(
BlockError::InvalidConstructorTag {
t: tag as u32,
s: std::any::type_name::<Self>().to_string()
}
)
}
let min_forwarding_neighbours_count = Deserializable::construct_from(slice)?;
let max_forwarding_neighbours_count = Deserializable::construct_from(slice)?;
let min_far_neighbours_count = Deserializable::construct_from(slice)?;
let max_far_neighbours_count = Deserializable::construct_from(slice)?;
let min_block_sync_period_ms = Deserializable::construct_from(slice)?;
let max_block_sync_period_ms = Deserializable::construct_from(slice)?;
let min_far_neighbours_sync_period_ms = Deserializable::construct_from(slice)?;
let max_far_neighbours_sync_period_ms = Deserializable::construct_from(slice)?;
let far_neighbours_resync_period_ms = Deserializable::construct_from(slice)?;
let block_sync_lifetime_period_ms = Deserializable::construct_from(slice)?;
let block_lifetime_period_ms = Deserializable::construct_from(slice)?;
let verification_obligation_cutoff_numerator = Deserializable::construct_from(slice)?;
let verification_obligation_cutoff_denominator = Deserializable::construct_from(slice)?;
let delivery_cutoff_numerator = Deserializable::construct_from(slice)?;
let delivery_cutoff_denominator = Deserializable::construct_from(slice)?;
let manual_candidate_loading_delay_ms = Deserializable::construct_from(slice)?;
let mc_allowed_force_delivery_delay_ms = Deserializable::construct_from(slice)?;
let mc_force_delivery_duplication_factor_numerator = Deserializable::construct_from(slice)?;
let mc_force_delivery_duplication_factor_denominator = Deserializable::construct_from(slice)?;
let mc_max_delivery_waiting_timeout_ms = Deserializable::construct_from(slice)?;
let use_debug_bls_keys = Deserializable::construct_from(slice)?;
Ok(Self {
min_forwarding_neighbours_count,
max_forwarding_neighbours_count,
min_far_neighbours_count,
max_far_neighbours_count,
min_block_sync_period_ms,
max_block_sync_period_ms,
min_far_neighbours_sync_period_ms,
max_far_neighbours_sync_period_ms,
far_neighbours_resync_period_ms,
block_sync_lifetime_period_ms,
block_lifetime_period_ms,
verification_obligation_cutoff_numerator,
verification_obligation_cutoff_denominator,
delivery_cutoff_numerator,
delivery_cutoff_denominator,
manual_candidate_loading_delay_ms,
mc_allowed_force_delivery_delay_ms,
mc_force_delivery_duplication_factor_numerator,
mc_force_delivery_duplication_factor_denominator,
mc_max_delivery_waiting_timeout_ms,
use_debug_bls_keys,
})
}
}
impl Serializable for SmftParams {
fn write_to(&self, cell: &mut BuilderData) -> Result<()> {
SMFT_PARAMS_TAG.write_to(cell)?; // tag
self.min_forwarding_neighbours_count.write_to(cell)?;
self.max_forwarding_neighbours_count.write_to(cell)?;
self.min_far_neighbours_count.write_to(cell)?;
self.max_far_neighbours_count.write_to(cell)?;
self.min_block_sync_period_ms.write_to(cell)?;
self.max_block_sync_period_ms.write_to(cell)?;
self.min_far_neighbours_sync_period_ms.write_to(cell)?;
self.max_far_neighbours_sync_period_ms.write_to(cell)?;
self.far_neighbours_resync_period_ms.write_to(cell)?;
self.block_sync_lifetime_period_ms.write_to(cell)?;
self.block_lifetime_period_ms.write_to(cell)?;
self.verification_obligation_cutoff_numerator.write_to(cell)?;
self.verification_obligation_cutoff_denominator.write_to(cell)?;
self.delivery_cutoff_numerator.write_to(cell)?;
self.delivery_cutoff_denominator.write_to(cell)?;
self.manual_candidate_loading_delay_ms.write_to(cell)?;
self.mc_allowed_force_delivery_delay_ms.write_to(cell)?;
self.mc_force_delivery_duplication_factor_numerator.write_to(cell)?;
self.mc_force_delivery_duplication_factor_denominator.write_to(cell)?;
self.mc_max_delivery_waiting_timeout_ms.write_to(cell)?;
self.use_debug_bls_keys.write_to(cell)?;
Ok(())
}
}