feat: Rebrand Polkadot/Substrate references to PezkuwiChain
This commit systematically rebrands various references from Parity Technologies' Polkadot/Substrate ecosystem to PezkuwiChain within the kurdistan-sdk. Key changes include: - Updated external repository URLs (zombienet-sdk, parity-db, parity-scale-codec, wasm-instrument) to point to pezkuwichain forks. - Modified internal documentation and code comments to reflect PezkuwiChain naming and structure. - Replaced direct references to with or specific paths within the for XCM, Pezkuwi, and other modules. - Cleaned up deprecated issue and PR references in various and files, particularly in and modules. - Adjusted image and logo URLs in documentation to point to PezkuwiChain assets. - Removed or rephrased comments related to external Polkadot/Substrate PRs and issues. This is a significant step towards fully customizing the SDK for the PezkuwiChain ecosystem.
This commit is contained in:
@@ -0,0 +1,63 @@
|
||||
[package]
|
||||
name = "pezpallet-timestamp"
|
||||
version = "27.0.0"
|
||||
authors.workspace = true
|
||||
edition.workspace = true
|
||||
license = "Apache-2.0"
|
||||
homepage.workspace = true
|
||||
repository.workspace = true
|
||||
description = "FRAME Timestamp Module"
|
||||
documentation = "https://docs.rs/pezpallet-timestamp"
|
||||
readme = "README.md"
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
targets = ["x86_64-unknown-linux-gnu"]
|
||||
|
||||
[dependencies]
|
||||
codec = { features = ["derive", "max-encoded-len"], workspace = true }
|
||||
pezframe-benchmarking = { optional = true, workspace = true }
|
||||
pezframe-support = { workspace = true }
|
||||
pezframe-system = { workspace = true }
|
||||
log = { workspace = true }
|
||||
scale-info = { features = ["derive"], workspace = true }
|
||||
pezsp-inherents = { workspace = true }
|
||||
pezsp-runtime = { workspace = true }
|
||||
pezsp-storage = { workspace = true }
|
||||
pezsp-timestamp = { workspace = true }
|
||||
|
||||
docify = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
pezsp-io = { workspace = true, default-features = true }
|
||||
|
||||
[features]
|
||||
default = ["std"]
|
||||
std = [
|
||||
"codec/std",
|
||||
"pezframe-benchmarking?/std",
|
||||
"pezframe-support/std",
|
||||
"pezframe-system/std",
|
||||
"log/std",
|
||||
"scale-info/std",
|
||||
"pezsp-inherents/std",
|
||||
"pezsp-runtime/std",
|
||||
"pezsp-storage/std",
|
||||
"pezsp-timestamp/std",
|
||||
]
|
||||
runtime-benchmarks = [
|
||||
"pezframe-benchmarking/runtime-benchmarks",
|
||||
"pezframe-support/runtime-benchmarks",
|
||||
"pezframe-system/runtime-benchmarks",
|
||||
"pezsp-inherents/runtime-benchmarks",
|
||||
"pezsp-io/runtime-benchmarks",
|
||||
"pezsp-runtime/runtime-benchmarks",
|
||||
"pezsp-timestamp/runtime-benchmarks",
|
||||
]
|
||||
try-runtime = [
|
||||
"pezframe-support/try-runtime",
|
||||
"pezframe-system/try-runtime",
|
||||
"pezsp-runtime/try-runtime",
|
||||
]
|
||||
@@ -0,0 +1,83 @@
|
||||
# Timestamp Module
|
||||
|
||||
The Timestamp module provides functionality to get and set the on-chain time.
|
||||
|
||||
- [`timestamp::Config`](https://docs.rs/pezpallet-timestamp/latest/pallet_timestamp/pallet/trait.Config.html)
|
||||
- [`Call`](https://docs.rs/pezpallet-timestamp/latest/pallet_timestamp/pallet/enum.Call.html)
|
||||
- [`Pallet`](https://docs.rs/pezpallet-timestamp/latest/pallet_timestamp/pallet/struct.Pallet.html)
|
||||
|
||||
## Overview
|
||||
|
||||
The Timestamp module allows the validators to set and validate a timestamp with each block.
|
||||
|
||||
It uses inherents for timestamp data, which is provided by the block author and validated/verified
|
||||
by other validators. The timestamp can be set only once per block and must be set each block.
|
||||
There could be a constraint on how much time must pass before setting the new timestamp.
|
||||
|
||||
**NOTE:** The Timestamp module is the recommended way to query the on-chain time instead of using
|
||||
an approach based on block numbers. The block number based time measurement can cause issues
|
||||
because of cumulative calculation errors and hence should be avoided.
|
||||
|
||||
## Interface
|
||||
|
||||
### Dispatchable Functions
|
||||
|
||||
- `set` - Sets the current time.
|
||||
|
||||
### Public functions
|
||||
|
||||
- `get` - Gets the current time for the current block. If this function is called prior to
|
||||
setting the timestamp, it will return the timestamp of the previous block.
|
||||
|
||||
### Config Getters
|
||||
|
||||
- `MinimumPeriod` - Gets the minimum (and advised) period between blocks for the chain.
|
||||
|
||||
## Usage
|
||||
|
||||
The following example shows how to use the Timestamp module in your custom module to query the current timestamp.
|
||||
|
||||
### Prerequisites
|
||||
|
||||
Import the Timestamp module into your custom module and derive the module configuration
|
||||
trait from the timestamp trait.
|
||||
|
||||
### Get current timestamp
|
||||
|
||||
```rust
|
||||
use pallet_timestamp::{self as timestamp};
|
||||
|
||||
#[frame_support::pallet]
|
||||
pub mod pallet {
|
||||
use super::*;
|
||||
use frame_support::pallet_prelude::*;
|
||||
use frame_system::pallet_prelude::*;
|
||||
|
||||
#[pallet::pallet]
|
||||
pub struct Pallet<T>(_);
|
||||
|
||||
#[pallet::config]
|
||||
pub trait Config: frame_system::Config + timestamp::Config {}
|
||||
|
||||
#[pallet::call]
|
||||
impl<T: Config> Pallet<T> {
|
||||
#[pallet::weight(0)]
|
||||
pub fn get_time(origin: OriginFor<T>) -> DispatchResult {
|
||||
let _sender = ensure_signed(origin)?;
|
||||
let _now = <timestamp::Pallet<T>>::get();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Example from the FRAME
|
||||
|
||||
The [Session module](https://github.com/pezkuwichain/pezkuwi-sdk/blob/master/bizinikiwi/pezframe/session/src/lib.rs) uses
|
||||
the Timestamp module for session management.
|
||||
|
||||
## Related Modules
|
||||
|
||||
- [Session](https://docs.rs/pezpallet-session/latest/pallet_session/)
|
||||
|
||||
License: Apache-2.0
|
||||
@@ -0,0 +1,76 @@
|
||||
// This file is part of Bizinikiwi.
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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 language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Timestamp pallet benchmarking.
|
||||
|
||||
#![cfg(feature = "runtime-benchmarks")]
|
||||
|
||||
use pezframe_benchmarking::{benchmarking::add_to_whitelist, v2::*};
|
||||
use pezframe_support::traits::OnFinalize;
|
||||
use pezframe_system::RawOrigin;
|
||||
use pezsp_storage::TrackedStorageKey;
|
||||
|
||||
use crate::*;
|
||||
|
||||
const MAX_TIME: u32 = 100;
|
||||
|
||||
#[benchmarks]
|
||||
mod benchmarks {
|
||||
use super::*;
|
||||
|
||||
#[benchmark]
|
||||
fn set() {
|
||||
let t = MAX_TIME;
|
||||
// Ignore write to `DidUpdate` since it transient.
|
||||
let did_update_key = DidUpdate::<T>::hashed_key().to_vec();
|
||||
add_to_whitelist(TrackedStorageKey {
|
||||
key: did_update_key,
|
||||
reads: 0,
|
||||
writes: 1,
|
||||
whitelisted: false,
|
||||
});
|
||||
|
||||
#[extrinsic_call]
|
||||
_(RawOrigin::None, t.into());
|
||||
|
||||
assert_eq!(Now::<T>::get(), t.into(), "Time was not set.");
|
||||
}
|
||||
|
||||
#[benchmark]
|
||||
fn on_finalize() {
|
||||
let t = MAX_TIME;
|
||||
Pallet::<T>::set(RawOrigin::None.into(), t.into()).unwrap();
|
||||
assert!(DidUpdate::<T>::exists(), "Time was not set.");
|
||||
|
||||
// Ignore read/write to `DidUpdate` since it is transient.
|
||||
let did_update_key = DidUpdate::<T>::hashed_key().to_vec();
|
||||
add_to_whitelist(did_update_key.into());
|
||||
|
||||
#[block]
|
||||
{
|
||||
Pallet::<T>::on_finalize(t.into());
|
||||
}
|
||||
|
||||
assert!(!DidUpdate::<T>::exists(), "Time was not removed.");
|
||||
}
|
||||
|
||||
impl_benchmark_test_suite! {
|
||||
Pallet,
|
||||
mock::new_test_ext(),
|
||||
mock::Test
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,380 @@
|
||||
// This file is part of Bizinikiwi.
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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 language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! > Made with *Bizinikiwi*, for *Pezkuwi*.
|
||||
//!
|
||||
//! [![github]](https://github.com/pezkuwichain/pezkuwi-sdk/bizinikiwi/pezframe/timestamp)
|
||||
//! [![pezkuwi]](https://pezkuwichain.io)
|
||||
//!
|
||||
//! [pezkuwi]: https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white
|
||||
//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
|
||||
//!
|
||||
//! # Timestamp Pallet
|
||||
//!
|
||||
//! A pallet that provides a way for consensus systems to set and check the onchain time.
|
||||
//!
|
||||
//! ## Pallet API
|
||||
//!
|
||||
//! See the [`pallet`] module for more information about the interfaces this pallet exposes,
|
||||
//! including its configuration trait, dispatchables, storage items, events and errors.
|
||||
//!
|
||||
//! ## Overview
|
||||
//!
|
||||
//! The Timestamp pallet is designed to create a consensus-based time source. This helps ensure that
|
||||
//! nodes maintain a synchronized view of time that all network participants can agree on.
|
||||
//!
|
||||
//! It defines an _acceptable range_ using a configurable constant to specify how much time must
|
||||
//! pass before setting the new timestamp. Validator nodes in the network must verify that the
|
||||
//! timestamp falls within this acceptable range and reject blocks that do not.
|
||||
//!
|
||||
//! > **Note:** The timestamp set by this pallet is the recommended way to query the onchain time
|
||||
//! > instead of using block numbers alone. Measuring time with block numbers can cause cumulative
|
||||
//! > calculation errors if depended upon in time critical operations and hence should generally be
|
||||
//! > avoided.
|
||||
//!
|
||||
//! ## Example
|
||||
//!
|
||||
//! To get the current time for the current block in another pallet:
|
||||
//!
|
||||
//! ```
|
||||
//! use pezpallet_timestamp::{self as timestamp};
|
||||
//!
|
||||
//! #[pezframe_support::pallet]
|
||||
//! pub mod pallet {
|
||||
//! use super::*;
|
||||
//! use pezframe_support::pezpallet_prelude::*;
|
||||
//! use pezframe_system::pezpallet_prelude::*;
|
||||
//!
|
||||
//! #[pallet::pallet]
|
||||
//! pub struct Pallet<T>(_);
|
||||
//!
|
||||
//! #[pallet::config]
|
||||
//! pub trait Config: pezframe_system::Config + timestamp::Config {}
|
||||
//!
|
||||
//! #[pallet::call]
|
||||
//! impl<T: Config> Pallet<T> {
|
||||
//! #[pallet::weight(0)]
|
||||
//! pub fn get_time(origin: OriginFor<T>) -> DispatchResult {
|
||||
//! let _sender = ensure_signed(origin)?;
|
||||
//! let _now = timestamp::Pallet::<T>::get();
|
||||
//! Ok(())
|
||||
//! }
|
||||
//! }
|
||||
//! }
|
||||
//! # fn main() {}
|
||||
//! ```
|
||||
//!
|
||||
//! If [`Pallet::get`] is called prior to setting the timestamp, it will return the timestamp of
|
||||
//! the previous block.
|
||||
//!
|
||||
//! ## Low Level / Implementation Details
|
||||
//!
|
||||
//! A timestamp is added to the chain using an _inherent extrinsic_ that only a block author can
|
||||
//! submit. Inherents are a special type of extrinsic in Bizinikiwi chains that will always be
|
||||
//! included in a block.
|
||||
//!
|
||||
//! To provide inherent data to the runtime, this pallet implements
|
||||
//! [`ProvideInherent`](pezframe_support::inherent::ProvideInherent). It will only create an inherent
|
||||
//! if the [`Call::set`] dispatchable is called, using the
|
||||
//! [`inherent`](pezframe_support::pezpallet_macros::inherent) macro which enables validator nodes to call
|
||||
//! into the runtime to check that the timestamp provided is valid.
|
||||
//! The implementation of [`ProvideInherent`](pezframe_support::inherent::ProvideInherent) specifies a
|
||||
//! constant called `MAX_TIMESTAMP_DRIFT_MILLIS` which is used to determine the acceptable range for
|
||||
//! a valid timestamp. If a block author sets a timestamp to anything that is more than this
|
||||
//! constant, a validator node will reject the block.
|
||||
//!
|
||||
//! The pallet also ensures that a timestamp is set at the start of each block by running an
|
||||
//! assertion in the `on_finalize` runtime hook. See [`pezframe_support::traits::Hooks`] for more
|
||||
//! information about how hooks work.
|
||||
//!
|
||||
//! Because inherents are applied to a block in the order they appear in the runtime
|
||||
//! construction, the index of this pallet in
|
||||
//! [`construct_runtime`](pezframe_support::construct_runtime) must always be less than any other
|
||||
//! pallet that depends on it.
|
||||
//!
|
||||
//! The [`Config::OnTimestampSet`] configuration trait can be set to another pallet we want to
|
||||
//! notify that the timestamp has been updated, as long as it implements [`OnTimestampSet`].
|
||||
//! Examples are the Babe and Aura pallets.
|
||||
//! This pallet also implements [`Time`] and [`UnixTime`] so it can be used to configure other
|
||||
//! pallets that require these types (e.g. in Staking pallet).
|
||||
//!
|
||||
//! ## Panics
|
||||
//!
|
||||
//! There are 3 cases where this pallet could cause the runtime to panic.
|
||||
//!
|
||||
//! 1. If no timestamp is set at the end of a block.
|
||||
//!
|
||||
//! 2. If a timestamp is set more than once per block:
|
||||
#![doc = docify::embed!("src/tests.rs", double_timestamp_should_fail)]
|
||||
//!
|
||||
//! 3. If a timestamp is set before the [`Config::MinimumPeriod`] is elapsed:
|
||||
#![doc = docify::embed!("src/tests.rs", block_period_minimum_enforced)]
|
||||
#![deny(missing_docs)]
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
mod benchmarking;
|
||||
#[cfg(test)]
|
||||
mod mock;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
pub mod weights;
|
||||
|
||||
use core::{cmp, result};
|
||||
use pezframe_support::traits::{OnTimestampSet, Time, UnixTime};
|
||||
use pezsp_runtime::traits::{AtLeast32Bit, SaturatedConversion, Scale, Zero};
|
||||
use pezsp_timestamp::{InherentError, InherentType, INHERENT_IDENTIFIER};
|
||||
pub use weights::WeightInfo;
|
||||
|
||||
pub use pallet::*;
|
||||
|
||||
#[pezframe_support::pallet]
|
||||
pub mod pallet {
|
||||
use super::*;
|
||||
use pezframe_support::{derive_impl, pezpallet_prelude::*};
|
||||
use pezframe_system::pezpallet_prelude::*;
|
||||
|
||||
/// Default preludes for [`Config`].
|
||||
pub mod config_preludes {
|
||||
use super::*;
|
||||
|
||||
/// Default prelude sensible to be used in a testing environment.
|
||||
pub struct TestDefaultConfig;
|
||||
|
||||
#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig, no_aggregated_types)]
|
||||
impl pezframe_system::DefaultConfig for TestDefaultConfig {}
|
||||
|
||||
#[pezframe_support::register_default_impl(TestDefaultConfig)]
|
||||
impl DefaultConfig for TestDefaultConfig {
|
||||
type Moment = u64;
|
||||
type OnTimestampSet = ();
|
||||
type MinimumPeriod = ConstUint<1>;
|
||||
type WeightInfo = ();
|
||||
}
|
||||
}
|
||||
|
||||
/// The pallet configuration trait
|
||||
#[pallet::config(with_default)]
|
||||
pub trait Config: pezframe_system::Config {
|
||||
/// Type used for expressing a timestamp.
|
||||
#[pallet::no_default_bounds]
|
||||
type Moment: Parameter
|
||||
+ Default
|
||||
+ AtLeast32Bit
|
||||
+ Scale<BlockNumberFor<Self>, Output = Self::Moment>
|
||||
+ Copy
|
||||
+ MaxEncodedLen
|
||||
+ scale_info::StaticTypeInfo;
|
||||
|
||||
/// Something which can be notified (e.g. another pallet) when the timestamp is set.
|
||||
///
|
||||
/// This can be set to `()` if it is not needed.
|
||||
type OnTimestampSet: OnTimestampSet<Self::Moment>;
|
||||
|
||||
/// The minimum period between blocks.
|
||||
///
|
||||
/// Be aware that this is different to the *expected* period that the block production
|
||||
/// apparatus provides. Your chosen consensus system will generally work with this to
|
||||
/// determine a sensible block time. For example, in the Aura pallet it will be double this
|
||||
/// period on default settings.
|
||||
#[pallet::constant]
|
||||
type MinimumPeriod: Get<Self::Moment>;
|
||||
|
||||
/// Weight information for extrinsics in this pallet.
|
||||
type WeightInfo: WeightInfo;
|
||||
}
|
||||
|
||||
#[pallet::pallet]
|
||||
pub struct Pallet<T>(_);
|
||||
|
||||
/// The current time for the current block.
|
||||
#[pallet::storage]
|
||||
pub type Now<T: Config> = StorageValue<_, T::Moment, ValueQuery>;
|
||||
|
||||
/// Whether the timestamp has been updated in this block.
|
||||
///
|
||||
/// This value is updated to `true` upon successful submission of a timestamp by a node.
|
||||
/// It is then checked at the end of each block execution in the `on_finalize` hook.
|
||||
#[pallet::storage]
|
||||
pub(super) type DidUpdate<T: Config> = StorageValue<_, bool, ValueQuery>;
|
||||
|
||||
#[pallet::hooks]
|
||||
impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
|
||||
/// A dummy `on_initialize` to return the amount of weight that `on_finalize` requires to
|
||||
/// execute.
|
||||
fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
|
||||
// weight of `on_finalize`
|
||||
T::WeightInfo::on_finalize()
|
||||
}
|
||||
|
||||
/// At the end of block execution, the `on_finalize` hook checks that the timestamp was
|
||||
/// updated. Upon success, it removes the boolean value from storage. If the value resolves
|
||||
/// to `false`, the pallet will panic.
|
||||
///
|
||||
/// ## Complexity
|
||||
/// - `O(1)`
|
||||
fn on_finalize(_n: BlockNumberFor<T>) {
|
||||
assert!(DidUpdate::<T>::take(), "Timestamp must be updated once in the block");
|
||||
}
|
||||
}
|
||||
|
||||
#[pallet::call]
|
||||
impl<T: Config> Pallet<T> {
|
||||
/// Set the current time.
|
||||
///
|
||||
/// This call should be invoked exactly once per block. It will panic at the finalization
|
||||
/// phase, if this call hasn't been invoked by that time.
|
||||
///
|
||||
/// The timestamp should be greater than the previous one by the amount specified by
|
||||
/// [`Config::MinimumPeriod`].
|
||||
///
|
||||
/// The dispatch origin for this call must be _None_.
|
||||
///
|
||||
/// This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be aware
|
||||
/// that changing the complexity of this call could result exhausting the resources in a
|
||||
/// block to execute any other calls.
|
||||
///
|
||||
/// ## Complexity
|
||||
/// - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)
|
||||
/// - 1 storage read and 1 storage mutation (codec `O(1)` because of `DidUpdate::take` in
|
||||
/// `on_finalize`)
|
||||
/// - 1 event handler `on_timestamp_set`. Must be `O(1)`.
|
||||
#[pallet::call_index(0)]
|
||||
#[pallet::weight((
|
||||
T::WeightInfo::set(),
|
||||
DispatchClass::Mandatory
|
||||
))]
|
||||
pub fn set(origin: OriginFor<T>, #[pallet::compact] now: T::Moment) -> DispatchResult {
|
||||
ensure_none(origin)?;
|
||||
assert!(!DidUpdate::<T>::exists(), "Timestamp must be updated only once in the block");
|
||||
let prev = Now::<T>::get();
|
||||
assert!(
|
||||
prev.is_zero() || now >= prev + T::MinimumPeriod::get(),
|
||||
"Timestamp must increment by at least <MinimumPeriod> between sequential blocks"
|
||||
);
|
||||
Now::<T>::put(now);
|
||||
DidUpdate::<T>::put(true);
|
||||
|
||||
<T::OnTimestampSet as OnTimestampSet<_>>::on_timestamp_set(now);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// To check the inherent is valid, we simply take the max value between the current timestamp
|
||||
/// and the current timestamp plus the [`Config::MinimumPeriod`].
|
||||
/// We also check that the timestamp has not already been set in this block.
|
||||
///
|
||||
/// ## Errors:
|
||||
/// - [`InherentError::TooFarInFuture`]: If the timestamp is larger than the current timestamp +
|
||||
/// minimum drift period.
|
||||
/// - [`InherentError::TooEarly`]: If the timestamp is less than the current + minimum period.
|
||||
#[pallet::inherent]
|
||||
impl<T: Config> ProvideInherent for Pallet<T> {
|
||||
type Call = Call<T>;
|
||||
type Error = InherentError;
|
||||
const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
|
||||
|
||||
fn create_inherent(data: &InherentData) -> Option<Self::Call> {
|
||||
let inherent_data = data
|
||||
.get_data::<InherentType>(&INHERENT_IDENTIFIER)
|
||||
.expect("Timestamp inherent data not correctly encoded")
|
||||
.expect("Timestamp inherent data must be provided");
|
||||
let data = (*inherent_data).saturated_into::<T::Moment>();
|
||||
|
||||
let next_time = cmp::max(data, Now::<T>::get() + T::MinimumPeriod::get());
|
||||
Some(Call::set { now: next_time })
|
||||
}
|
||||
|
||||
fn check_inherent(
|
||||
call: &Self::Call,
|
||||
data: &InherentData,
|
||||
) -> result::Result<(), Self::Error> {
|
||||
const MAX_TIMESTAMP_DRIFT_MILLIS: pezsp_timestamp::Timestamp =
|
||||
pezsp_timestamp::Timestamp::new(30 * 1000);
|
||||
|
||||
let t: u64 = match call {
|
||||
Call::set { ref now } => (*now).saturated_into::<u64>(),
|
||||
_ => return Ok(()),
|
||||
};
|
||||
|
||||
let data = data
|
||||
.get_data::<InherentType>(&INHERENT_IDENTIFIER)
|
||||
.expect("Timestamp inherent data not correctly encoded")
|
||||
.expect("Timestamp inherent data must be provided");
|
||||
|
||||
let minimum = (Now::<T>::get() + T::MinimumPeriod::get()).saturated_into::<u64>();
|
||||
if t > *(data + MAX_TIMESTAMP_DRIFT_MILLIS) {
|
||||
Err(InherentError::TooFarInFuture)
|
||||
} else if t < minimum {
|
||||
Err(InherentError::TooEarly)
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn is_inherent(call: &Self::Call) -> bool {
|
||||
matches!(call, Call::set { .. })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config> Pallet<T> {
|
||||
/// Get the current time for the current block.
|
||||
///
|
||||
/// NOTE: if this function is called prior to setting the timestamp,
|
||||
/// it will return the timestamp of the previous block.
|
||||
pub fn get() -> T::Moment {
|
||||
Now::<T>::get()
|
||||
}
|
||||
|
||||
/// Set the timestamp to something in particular. Only used for tests.
|
||||
#[cfg(any(feature = "runtime-benchmarks", feature = "std"))]
|
||||
pub fn set_timestamp(now: T::Moment) {
|
||||
Now::<T>::put(now);
|
||||
DidUpdate::<T>::put(true);
|
||||
<T::OnTimestampSet as OnTimestampSet<_>>::on_timestamp_set(now);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config> Time for Pallet<T> {
|
||||
/// A type that represents a unit of time.
|
||||
type Moment = T::Moment;
|
||||
|
||||
fn now() -> Self::Moment {
|
||||
Now::<T>::get()
|
||||
}
|
||||
}
|
||||
|
||||
/// Before the timestamp inherent is applied, it returns the time of previous block.
|
||||
///
|
||||
/// On genesis the time returned is not valid.
|
||||
impl<T: Config> UnixTime for Pallet<T> {
|
||||
fn now() -> core::time::Duration {
|
||||
// now is duration since unix epoch in millisecond as documented in
|
||||
// `pezsp_timestamp::InherentDataProvider`.
|
||||
let now = Now::<T>::get();
|
||||
|
||||
if now == T::Moment::zero() {
|
||||
log::error!(
|
||||
target: "runtime::timestamp",
|
||||
"`pezpallet_timestamp::UnixTime::now` is called at genesis, invalid value returned: 0",
|
||||
);
|
||||
}
|
||||
|
||||
core::time::Duration::from_millis(now.saturated_into::<u64>())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
// This file is part of Bizinikiwi.
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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 language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Tests Utilities.
|
||||
|
||||
use super::*;
|
||||
use crate as pezpallet_timestamp;
|
||||
|
||||
use pezframe_support::{derive_impl, parameter_types, traits::ConstU64};
|
||||
use pezsp_io::TestExternalities;
|
||||
use pezsp_runtime::BuildStorage;
|
||||
|
||||
type Block = pezframe_system::mocking::MockBlock<Test>;
|
||||
type Moment = u64;
|
||||
|
||||
pezframe_support::construct_runtime!(
|
||||
pub enum Test
|
||||
{
|
||||
System: pezframe_system,
|
||||
Timestamp: pezpallet_timestamp,
|
||||
}
|
||||
);
|
||||
|
||||
#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
|
||||
impl pezframe_system::Config for Test {
|
||||
type Block = Block;
|
||||
}
|
||||
|
||||
parameter_types! {
|
||||
pub static CapturedMoment: Option<Moment> = None;
|
||||
}
|
||||
|
||||
pub struct MockOnTimestampSet;
|
||||
impl OnTimestampSet<Moment> for MockOnTimestampSet {
|
||||
fn on_timestamp_set(moment: Moment) {
|
||||
CapturedMoment::mutate(|x| *x = Some(moment));
|
||||
}
|
||||
}
|
||||
|
||||
impl Config for Test {
|
||||
type Moment = Moment;
|
||||
type OnTimestampSet = MockOnTimestampSet;
|
||||
type MinimumPeriod = ConstU64<5>;
|
||||
type WeightInfo = ();
|
||||
}
|
||||
|
||||
pub(crate) fn clear_captured_moment() {
|
||||
CapturedMoment::mutate(|x| *x = None);
|
||||
}
|
||||
|
||||
pub(crate) fn get_captured_moment() -> Option<Moment> {
|
||||
CapturedMoment::get()
|
||||
}
|
||||
|
||||
pub(crate) fn new_test_ext() -> TestExternalities {
|
||||
let t = pezframe_system::GenesisConfig::<Test>::default().build_storage().unwrap();
|
||||
clear_captured_moment();
|
||||
TestExternalities::new(t)
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
// This file is part of Bizinikiwi.
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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 language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Tests for the Timestamp module.
|
||||
|
||||
use crate::mock::*;
|
||||
use pezframe_support::assert_ok;
|
||||
|
||||
#[test]
|
||||
fn timestamp_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
crate::Now::<Test>::put(46);
|
||||
assert_ok!(Timestamp::set(RuntimeOrigin::none(), 69));
|
||||
assert_eq!(crate::Now::<Test>::get(), 69);
|
||||
assert_eq!(Some(69), get_captured_moment());
|
||||
});
|
||||
}
|
||||
|
||||
#[docify::export]
|
||||
#[test]
|
||||
#[should_panic(expected = "Timestamp must be updated only once in the block")]
|
||||
fn double_timestamp_should_fail() {
|
||||
new_test_ext().execute_with(|| {
|
||||
Timestamp::set_timestamp(42);
|
||||
assert_ok!(Timestamp::set(RuntimeOrigin::none(), 69));
|
||||
});
|
||||
}
|
||||
|
||||
#[docify::export]
|
||||
#[test]
|
||||
#[should_panic(
|
||||
expected = "Timestamp must increment by at least <MinimumPeriod> between sequential blocks"
|
||||
)]
|
||||
fn block_period_minimum_enforced() {
|
||||
new_test_ext().execute_with(|| {
|
||||
crate::Now::<Test>::put(44);
|
||||
let _ = Timestamp::set(RuntimeOrigin::none(), 46);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
// This file is part of Bizinikiwi.
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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 language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// This file is part of Bizinikiwi.
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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 language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Autogenerated weights for `pezpallet_timestamp`
|
||||
//!
|
||||
//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
|
||||
//! DATE: 2025-02-21, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
|
||||
//! WORST CASE MAP SIZE: `1000000`
|
||||
//! HOSTNAME: `4563561839a5`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
|
||||
//! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024`
|
||||
|
||||
// Executed Command:
|
||||
// frame-omni-bencher
|
||||
// v1
|
||||
// benchmark
|
||||
// pallet
|
||||
// --extrinsic=*
|
||||
// --runtime=target/production/wbuild/kitchensink-runtime/kitchensink_runtime.wasm
|
||||
// --pallet=pezpallet_timestamp
|
||||
// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/HEADER-APACHE2
|
||||
// --output=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/pezframe/timestamp/src/weights.rs
|
||||
// --wasm-execution=compiled
|
||||
// --steps=50
|
||||
// --repeat=20
|
||||
// --heap-pages=4096
|
||||
// --template=bizinikiwi/.maintain/frame-weight-template.hbs
|
||||
// --no-storage-info
|
||||
// --no-min-squares
|
||||
// --no-median-slopes
|
||||
// --genesis-builder-policy=none
|
||||
// --exclude-pallets=pezpallet_xcm,pezpallet_xcm_benchmarks::fungible,pezpallet_xcm_benchmarks::generic,pezpallet_nomination_pools,pezpallet_remark,pezpallet_transaction_storage,pezpallet_election_provider_multi_block,pezpallet_election_provider_multi_block::signed,pezpallet_election_provider_multi_block::unsigned,pezpallet_election_provider_multi_block::verifier
|
||||
|
||||
#![cfg_attr(rustfmt, rustfmt_skip)]
|
||||
#![allow(unused_parens)]
|
||||
#![allow(unused_imports)]
|
||||
#![allow(missing_docs)]
|
||||
#![allow(dead_code)]
|
||||
|
||||
use pezframe_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
|
||||
use core::marker::PhantomData;
|
||||
|
||||
/// Weight functions needed for `pezpallet_timestamp`.
|
||||
pub trait WeightInfo {
|
||||
fn set() -> Weight;
|
||||
fn on_finalize() -> Weight;
|
||||
}
|
||||
|
||||
/// Weights for `pezpallet_timestamp` using the Bizinikiwi node and recommended hardware.
|
||||
pub struct BizinikiwiWeight<T>(PhantomData<T>);
|
||||
impl<T: pezframe_system::Config> WeightInfo for BizinikiwiWeight<T> {
|
||||
/// Storage: `Timestamp::Now` (r:1 w:1)
|
||||
/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Babe::CurrentSlot` (r:1 w:0)
|
||||
/// Proof: `Babe::CurrentSlot` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
|
||||
fn set() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `0`
|
||||
// Estimated: `1493`
|
||||
// Minimum execution time: 3_691_000 picoseconds.
|
||||
Weight::from_parts(3_816_000, 1493)
|
||||
.saturating_add(T::DbWeight::get().reads(2_u64))
|
||||
.saturating_add(T::DbWeight::get().writes(1_u64))
|
||||
}
|
||||
fn on_finalize() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `36`
|
||||
// Estimated: `0`
|
||||
// Minimum execution time: 3_111_000 picoseconds.
|
||||
Weight::from_parts(3_246_000, 0)
|
||||
}
|
||||
}
|
||||
|
||||
// For backwards compatibility and tests.
|
||||
impl WeightInfo for () {
|
||||
/// Storage: `Timestamp::Now` (r:1 w:1)
|
||||
/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Babe::CurrentSlot` (r:1 w:0)
|
||||
/// Proof: `Babe::CurrentSlot` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
|
||||
fn set() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `0`
|
||||
// Estimated: `1493`
|
||||
// Minimum execution time: 3_691_000 picoseconds.
|
||||
Weight::from_parts(3_816_000, 1493)
|
||||
.saturating_add(RocksDbWeight::get().reads(2_u64))
|
||||
.saturating_add(RocksDbWeight::get().writes(1_u64))
|
||||
}
|
||||
fn on_finalize() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `36`
|
||||
// Estimated: `0`
|
||||
// Minimum execution time: 3_111_000 picoseconds.
|
||||
Weight::from_parts(3_246_000, 0)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user