git.delta.rocks / unique-network / refs/commits / dd68ddac660b

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617#![doc = include_str!("../README.md")]18#![cfg_attr(not(feature = "std"), no_std)]19#![warn(missing_docs)]2021use codec::{Decode, Encode, MaxEncodedLen};22pub use pallet::*;23pub use eth::*;24use scale_info::TypeInfo;25use frame_support::storage::bounded_btree_map::BoundedBTreeMap;26pub mod eth;2728/// Maximum number of methods per contract that could have fee limit29pub const MAX_FEE_LIMITED_METHODS: u32 = 5;3031#[frame_support::pallet]32pub mod pallet {33	pub use super::*;34	use crate::eth::ContractHelpersEvents;35	use frame_support::pallet_prelude::*;36	use pallet_evm_coder_substrate::DispatchResult;37	use sp_core::{H160, U256};38	use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};39	use up_data_structs::SponsorshipState;40	use evm_coder::ToLog;4142	#[pallet::config]43	pub trait Config:44		frame_system::Config + pallet_evm_coder_substrate::Config + pallet_evm::account::Config45	{46		/// Overarching event type.47		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;4849		/// Address, under which magic contract will be available50		type ContractAddress: Get<H160>;5152		/// In case of enabled sponsoring, but no sponsoring rate limit set,53		/// this value will be used implicitly54		type DefaultSponsoringRateLimit: Get<Self::BlockNumber>;55	}5657	#[pallet::error]58	pub enum Error<T> {59		/// This method is only executable by contract owner60		NoPermission,6162		/// No pending sponsor for contract.63		NoPendingSponsor,6465		/// Number of methods that sponsored limit is defined for exceeds maximum.66		TooManyMethodsHaveSponsoredLimit,67	}6869	#[pallet::pallet]70	#[pallet::generate_store(pub(super) trait Store)]71	pub struct Pallet<T>(_);7273	/// Store owner for contract.74	///75	/// * **Key** - contract address.76	/// * **Value** - owner for contract.77	#[pallet::storage]78	pub(super) type Owner<T: Config> =79		StorageMap<Hasher = Twox128, Key = H160, Value = H160, QueryKind = ValueQuery>;8081	#[pallet::storage]82	#[deprecated]83	pub(super) type SelfSponsoring<T: Config> =84		StorageMap<Hasher = Twox128, Key = H160, Value = bool, QueryKind = ValueQuery>;8586	/// Store for contract sponsorship state.87	///88	/// * **Key** - contract address.89	/// * **Value** - sponsorship state.90	#[pallet::storage]91	pub(super) type Sponsoring<T: Config> = StorageMap<92		Hasher = Twox64Concat,93		Key = H160,94		Value = SponsorshipState<T::CrossAccountId>,95		QueryKind = ValueQuery,96	>;9798	/// Store for sponsoring mode.99	///100	/// ### Usage101	/// Prefer to delete collection from storage if mode chaged to [`Disabled`](SponsoringModeT::Disabled).102	///103	/// * **Key** - contract address.104	/// * **Value** - [`sponsoring mode`](SponsoringModeT).105	#[pallet::storage]106	pub(super) type SponsoringMode<T: Config> =107		StorageMap<Hasher = Twox128, Key = H160, Value = SponsoringModeT, QueryKind = OptionQuery>;108109	/// Storage for sponsoring rate limit in blocks.110	///111	/// * **Key** - contract address.112	/// * **Value** - amount of sponsored blocks.113	#[pallet::storage]114	pub(super) type SponsoringRateLimit<T: Config> = StorageMap<115		Hasher = Twox128,116		Key = H160,117		Value = T::BlockNumber,118		QueryKind = ValueQuery,119		OnEmpty = T::DefaultSponsoringRateLimit,120	>;121122	/// Storage for last sponsored block.123	///124	/// * **Key1** - contract address.125	/// * **Key2** - sponsored user address.126	/// * **Value** - last sponsored block number.127	#[pallet::storage]128	pub(super) type SponsoringFeeLimit<T: Config> = StorageMap<129		Hasher = Twox128,130		Key = H160,131		Value = BoundedBTreeMap<u32, U256, ConstU32<MAX_FEE_LIMITED_METHODS>>,132		QueryKind = ValueQuery,133	>;134135	#[pallet::storage]136	pub(super) type SponsorBasket<T: Config> = StorageDoubleMap<137		Hasher1 = Twox128,138		Key1 = H160,139		Hasher2 = Twox128,140		Key2 = H160,141		Value = T::BlockNumber,142		QueryKind = OptionQuery,143	>;144145	/// Storege for contracts with [`Allowlisted`](SponsoringModeT::Allowlisted) sponsoring mode.146	///147	/// ### Usage148	/// Prefer to delete collection from storage if mode chaged to non `Allowlisted`, than set **Value** to **false**.149	///150	/// * **Key** - contract address.151	/// * **Value** - is contract in [`Allowlisted`](SponsoringModeT::Allowlisted) mode.152	#[pallet::storage]153	pub(super) type AllowlistEnabled<T: Config> =154		StorageMap<Hasher = Twox128, Key = H160, Value = bool, QueryKind = ValueQuery>;155156	/// Storage for users that allowed for sponsorship.157	///158	/// ### Usage159	/// Prefer to delete record from storage if user no more allowed for sponsorship.160	///161	/// * **Key1** - contract address.162	/// * **Key2** - user that allowed for sponsorship.163	/// * **Value** - allowance for sponsorship.164	#[pallet::storage]165	pub(super) type Allowlist<T: Config> = StorageDoubleMap<166		Hasher1 = Twox128,167		Key1 = H160,168		Hasher2 = Twox128,169		Key2 = H160,170		Value = bool,171		QueryKind = ValueQuery,172	>;173174	#[pallet::event]175	#[pallet::generate_deposit(pub fn deposit_event)]176	pub enum Event<T: Config> {177		/// Contract sponsor was set.178		ContractSponsorSet(179			/// Contract address of the affected collection.180			H160,181			/// New sponsor address.182			T::AccountId,183		),184185		/// New sponsor was confirm.186		ContractSponsorshipConfirmed(187			/// Contract address of the affected collection.188			H160,189			/// New sponsor address.190			T::AccountId,191		),192193		/// Collection sponsor was removed.194		ContractSponsorRemoved(195			/// Contract address of the affected collection.196			H160,197		),198	}199200	impl<T: Config> Pallet<T> {201		/// Get contract owner.202		pub fn contract_owner(contract: H160) -> H160 {203			<Owner<T>>::get(contract)204		}205206		/// Set `sponsor` for `contract`.207		///208		/// `sender` must be owner of contract.209		pub fn set_sponsor(210			sender: &T::CrossAccountId,211			contract: H160,212			sponsor: &T::CrossAccountId,213		) -> DispatchResult {214			Pallet::<T>::ensure_owner(contract, *sender.as_eth())?;215			Sponsoring::<T>::insert(216				contract,217				SponsorshipState::<T::CrossAccountId>::Unconfirmed(sponsor.clone()),218			);219220			<Pallet<T>>::deposit_event(Event::<T>::ContractSponsorSet(221				contract,222				sponsor.as_sub().clone(),223			));224			<PalletEvm<T>>::deposit_log(225				ContractHelpersEvents::ContractSponsorSet {226					contract_address: contract,227					sponsor: *sponsor.as_eth(),228				}229				.to_log(contract),230			);231			Ok(())232		}233234		/// TO-DO235		///236		///237		pub fn force_set_sponsor(238			contract_address: H160,239			sponsor: &T::CrossAccountId,240		) -> DispatchResult {241			Sponsoring::<T>::insert(242				contract_address,243				SponsorshipState::<T::CrossAccountId>::Confirmed(sponsor.clone()),244			);245246			let eth_sponsor = *sponsor.as_eth();247			let sub_sponsor = sponsor.as_sub().clone();248249			<Pallet<T>>::deposit_event(Event::<T>::ContractSponsorSet(250				contract_address,251				sub_sponsor.clone(),252			));253			<PalletEvm<T>>::deposit_log(254				ContractHelpersEvents::ContractSponsorSet {255					contract_address,256					sponsor: eth_sponsor,257				}258				.to_log(contract_address),259			);260261			<Pallet<T>>::deposit_event(Event::<T>::ContractSponsorshipConfirmed(262				contract_address,263				sub_sponsor,264			));265			<PalletEvm<T>>::deposit_log(266				ContractHelpersEvents::ContractSponsorshipConfirmed {267					contract_address,268					sponsor: eth_sponsor,269				}270				.to_log(contract_address),271			);272273			Ok(())274		}275276		/// Remove sponsor for `contract`.277		///278		/// `sender` must be owner of contract.279		pub fn remove_sponsor(280			sender: &T::CrossAccountId,281			contract_address: H160,282		) -> DispatchResult {283			Self::ensure_owner(contract_address, *sender.as_eth())?;284			Self::force_remove_sponsor(contract_address)285		}286287		/// TO-DO288		///289		///290		pub fn force_remove_sponsor(contract_address: H160) -> DispatchResult {291			Sponsoring::<T>::remove(contract_address);292293			Self::deposit_event(Event::<T>::ContractSponsorRemoved(contract_address));294			<PalletEvm<T>>::deposit_log(295				ContractHelpersEvents::ContractSponsorRemoved { contract_address }296					.to_log(contract_address),297			);298299			Ok(())300		}301302		/// Confirm sponsorship.303		///304		/// `sender` must be same that set via [`set_sponsor`].305		pub fn confirm_sponsorship(306			sender: &T::CrossAccountId,307			contract_address: H160,308		) -> DispatchResult {309			match Sponsoring::<T>::get(contract_address) {310				SponsorshipState::Unconfirmed(sponsor) => {311					ensure!(sponsor == *sender, Error::<T>::NoPermission);312					let eth_sponsor = *sponsor.as_eth();313					let sub_sponsor = sponsor.as_sub().clone();314					Sponsoring::<T>::insert(315						contract_address,316						SponsorshipState::<T::CrossAccountId>::Confirmed(sponsor),317					);318319					<Pallet<T>>::deposit_event(Event::<T>::ContractSponsorshipConfirmed(320						contract_address,321						sub_sponsor,322					));323					<PalletEvm<T>>::deposit_log(324						ContractHelpersEvents::ContractSponsorshipConfirmed {325							contract_address,326							sponsor: eth_sponsor,327						}328						.to_log(contract_address),329					);330331					Ok(())332				}333				SponsorshipState::Disabled | SponsorshipState::Confirmed(_) => {334					Err(Error::<T>::NoPendingSponsor.into())335				}336			}337		}338339		/// Get sponsor.340		pub fn get_sponsor(contract: H160) -> Option<T::CrossAccountId> {341			match Sponsoring::<T>::get(contract) {342				SponsorshipState::Disabled | SponsorshipState::Unconfirmed(_) => None,343				SponsorshipState::Confirmed(sponsor) => Some(sponsor),344			}345		}346347		/// Get current sponsoring mode, performing lazy migration from legacy storage348		pub fn sponsoring_mode(contract: H160) -> SponsoringModeT {349			<SponsoringMode<T>>::get(contract)350				.or_else(|| {351					<SelfSponsoring<T>>::get(contract).then(|| SponsoringModeT::Allowlisted)352				})353				.unwrap_or_default()354		}355356		/// Reconfigure contract sponsoring mode357		pub fn set_sponsoring_mode(contract: H160, mode: SponsoringModeT) {358			if mode == SponsoringModeT::Disabled {359				<SponsoringMode<T>>::remove(contract);360			} else {361				<SponsoringMode<T>>::insert(contract, mode);362			}363			<SelfSponsoring<T>>::remove(contract)364		}365366		/// Set duration between two sponsored contract calls367		pub fn set_sponsoring_rate_limit(contract: H160, rate_limit: T::BlockNumber) {368			<SponsoringRateLimit<T>>::insert(contract, rate_limit);369		}370371		/// Set maximum for gas limit of transaction372		pub fn set_sponsoring_fee_limit(contract: H160, fee_limit: U256) -> DispatchResult {373			<SponsoringFeeLimit<T>>::try_mutate(contract, |limits_map| {374				limits_map375					.try_insert(0xffffffff, fee_limit)376					.map_err(|_| <Error<T>>::TooManyMethodsHaveSponsoredLimit)377			})?;378			Ok(())379		}380381		/// Is user added to allowlist, or he is owner of specified contract382		pub fn allowed(contract: H160, user: H160) -> bool {383			<Allowlist<T>>::get(&contract, &user) || <Owner<T>>::get(&contract) == user384		}385386		/// Toggle contract allowlist access387		pub fn toggle_allowlist(contract: H160, enabled: bool) {388			<AllowlistEnabled<T>>::insert(contract, enabled)389		}390391		/// Toggle user presence in contract's allowlist392		pub fn toggle_allowed(contract: H160, user: H160, allowed: bool) {393			<Allowlist<T>>::insert(contract, user, allowed);394		}395396		/// Throw error if user is not allowed to reconfigure target contract397		pub fn ensure_owner(contract: H160, user: H160) -> DispatchResult {398			ensure!(<Owner<T>>::get(&contract) == user, Error::<T>::NoPermission);399			Ok(())400		}401	}402}403404/// Available contract sponsoring modes405#[derive(Encode, Decode, PartialEq, TypeInfo, MaxEncodedLen, Default)]406pub enum SponsoringModeT {407	/// Sponsoring is disabled408	#[default]409	Disabled,410	/// Only users from allowlist will be sponsored411	Allowlisted,412	/// All users will be sponsored413	Generous,414}415416impl SponsoringModeT {417	fn from_eth(v: u8) -> Option<Self> {418		Some(match v {419			0 => Self::Disabled,420			1 => Self::Allowlisted,421			2 => Self::Generous,422			_ => return None,423		})424	}425	fn to_eth(self) -> u8 {426		match self {427			SponsoringModeT::Disabled => 0,428			SponsoringModeT::Allowlisted => 1,429			SponsoringModeT::Generous => 2,430		}431	}432}