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

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#![cfg_attr(not(feature = "std"), no_std)]1819use codec::{Decode, Encode, MaxEncodedLen};20pub use pallet::*;21pub use eth::*;22use scale_info::TypeInfo;23pub mod eth;2425#[frame_support::pallet]26pub mod pallet {27	pub use super::*;28	use frame_support::pallet_prelude::*;29	use pallet_evm_coder_substrate::DispatchResult;30	use sp_core::H160;31	use pallet_evm::account::CrossAccountId;32	use frame_system::pallet_prelude::BlockNumberFor;33	use up_data_structs::SponsorshipState;3435	#[pallet::config]36	pub trait Config:37		frame_system::Config + pallet_evm_coder_substrate::Config + pallet_evm::account::Config38	{39		type ContractAddress: Get<H160>;40		type DefaultSponsoringRateLimit: Get<Self::BlockNumber>;41	}4243	#[pallet::error]44	pub enum Error<T> {45		/// This method is only executable by owner.46		NoPermission,4748		/// No pending sponsor for contract.49		NoPendingSponsor,50	}5152	#[pallet::pallet]53	#[pallet::generate_store(pub(super) trait Store)]54	pub struct Pallet<T>(_);5556	/// Store owner for contract.57	///58	/// * **Key** - contract address.59	/// * **Value** - owner for contract.60	#[pallet::storage]61	pub(super) type Owner<T: Config> =62		StorageMap<Hasher = Twox128, Key = H160, Value = H160, QueryKind = ValueQuery>;6364	#[pallet::storage]65	#[deprecated]66	pub(super) type SelfSponsoring<T: Config> =67		StorageMap<Hasher = Twox128, Key = H160, Value = bool, QueryKind = ValueQuery>;6869	#[pallet::storage]70	pub(super) type Sponsoring<T: Config> = StorageMap<71		Hasher = Twox128,72		Key = H160,73		Value = SponsorshipState<T::CrossAccountId>,74		QueryKind = ValueQuery,75	>;7677	/// Store for sponsoring mode.78	///79	/// ### Usage80	/// Prefer to delete collection from storage if mode chaged to [`Disabled`](SponsoringModeT::Disabled).81	///82	/// * **Key** - contract address.83	/// * **Value** - [`sponsoring mode`](SponsoringModeT).84	#[pallet::storage]85	pub(super) type SponsoringMode<T: Config> =86		StorageMap<Hasher = Twox128, Key = H160, Value = SponsoringModeT, QueryKind = OptionQuery>;8788	/// Storage for sponsoring rate limit in blocks.89	///90	/// * **Key** - contract address.91	/// * **Value** - amount of sponsored blocks.92	#[pallet::storage]93	pub(super) type SponsoringRateLimit<T: Config> = StorageMap<94		Hasher = Twox128,95		Key = H160,96		Value = T::BlockNumber,97		QueryKind = ValueQuery,98		OnEmpty = T::DefaultSponsoringRateLimit,99	>;100101	/// Storage for last sponsored block.102	///103	/// * **Key1** - contract address.104	/// * **Key2** - sponsored user address.105	/// * **Value** - last sponsored block number.106	#[pallet::storage]107	pub(super) type SponsorBasket<T: Config> = StorageDoubleMap<108		Hasher1 = Twox128,109		Key1 = H160,110		Hasher2 = Twox128,111		Key2 = H160,112		Value = T::BlockNumber,113		QueryKind = OptionQuery,114	>;115116	/// Storege for contracts with [`Allowlisted`](SponsoringModeT::Allowlisted) sponsoring mode.117	///118	/// ### Usage119	/// Prefer to delete collection from storage if mode chaged to non `Allowlisted`, than set **Value** to **false**.120	///121	/// * **Key** - contract address.122	/// * **Value** - is contract in [`Allowlisted`](SponsoringModeT::Allowlisted) mode.123	#[pallet::storage]124	pub(super) type AllowlistEnabled<T: Config> =125		StorageMap<Hasher = Twox128, Key = H160, Value = bool, QueryKind = ValueQuery>;126127	/// Storage for users that allowed for sponsorship.128	///129	/// ### Usage130	/// Prefer to delete record from storage if user no more allowed for sponsorship.131	///132	/// * **Key1** - contract address.133	/// * **Key2** - user that allowed for sponsorship.134	/// * **Value** - allowance for sponsorship.135	#[pallet::storage]136	pub(super) type Allowlist<T: Config> = StorageDoubleMap<137		Hasher1 = Twox128,138		Key1 = H160,139		Hasher2 = Twox128,140		Key2 = H160,141		Value = bool,142		QueryKind = ValueQuery,143	>;144145	impl<T: Config> Pallet<T> {146		/// Get contract owner.147		pub fn contract_owner(contract: H160) -> H160 {148			<Owner<T>>::get(contract)149		}150151		/// Set `sponsor` for `contract`.152		///153		/// `sender` must be owner of contract.154		pub fn set_sponsor(155			sender: &T::CrossAccountId,156			contract: H160,157			sponsor: &T::CrossAccountId,158		) -> DispatchResult {159			Pallet::<T>::ensure_owner(contract, *sender.as_eth())?;160			Sponsoring::<T>::insert(161				contract,162				SponsorshipState::<T::CrossAccountId>::Unconfirmed(sponsor.clone()),163			);164			Ok(())165		}166167		/// Set `contract` as self sponsored.168		///169		/// `sender` must be owner of contract.170		pub fn self_sponsored_enable(sender: &T::CrossAccountId, contract: H160) -> DispatchResult {171			Pallet::<T>::ensure_owner(contract, *sender.as_eth())?;172			Sponsoring::<T>::insert(173				contract,174				SponsorshipState::<T::CrossAccountId>::Confirmed(T::CrossAccountId::from_eth(175					contract,176				)),177			);178			Ok(())179		}180181		/// Remove sponsor for `contract`.182		///183		/// `sender` must be owner of contract.184		pub fn remove_sponsor(sender: &T::CrossAccountId, contract: H160) -> DispatchResult {185			Pallet::<T>::ensure_owner(contract, *sender.as_eth())?;186			Sponsoring::<T>::remove(contract);187			Ok(())188		}189190		/// Confirm sponsorship.191		///192		/// `sender` must be same that set via [`set_sponsor`].193		pub fn confirm_sponsorship(sender: &T::CrossAccountId, contract: H160) -> DispatchResult {194			match Sponsoring::<T>::get(contract) {195				SponsorshipState::Unconfirmed(sponsor) => {196					ensure!(sponsor == *sender, Error::<T>::NoPermission);197					Sponsoring::<T>::mutate_exists(contract, |state| {198						*state = Some(SponsorshipState::<T::CrossAccountId>::Confirmed(199							sponsor.clone(),200						))201					});202					Ok(())203				}204				SponsorshipState::Disabled | SponsorshipState::Confirmed(_) => {205					Err(Error::<T>::NoPendingSponsor.into())206				}207			}208		}209210		/// Get sponsor.211		pub fn get_sponsor(contract: H160) -> Option<T::CrossAccountId> {212			match Sponsoring::<T>::get(contract) {213				SponsorshipState::Disabled | SponsorshipState::Unconfirmed(_) => None,214				SponsorshipState::Confirmed(sponsor) => Some(sponsor),215			}216		}217218		pub fn sponsoring_mode(contract: H160) -> SponsoringModeT {219			<SponsoringMode<T>>::get(contract)220				.or_else(|| {221					<SelfSponsoring<T>>::get(contract).then(|| SponsoringModeT::Allowlisted)222				})223				.unwrap_or_default()224		}225226		pub fn set_sponsoring_mode(contract: H160, mode: SponsoringModeT) {227			if mode == SponsoringModeT::Disabled {228				<SponsoringMode<T>>::remove(contract);229			} else {230				<SponsoringMode<T>>::insert(contract, mode);231			}232			<SelfSponsoring<T>>::remove(contract)233		}234235		pub fn set_sponsoring_rate_limit(contract: H160, rate_limit: T::BlockNumber) {236			<SponsoringRateLimit<T>>::insert(contract, rate_limit);237		}238239		pub fn allowed(contract: H160, user: H160) -> bool {240			<Allowlist<T>>::get(&contract, &user) || <Owner<T>>::get(&contract) == user241		}242243		pub fn toggle_allowlist(contract: H160, enabled: bool) {244			<AllowlistEnabled<T>>::insert(contract, enabled)245		}246247		pub fn toggle_allowed(contract: H160, user: H160, allowed: bool) {248			<Allowlist<T>>::insert(contract, user, allowed);249		}250251		pub fn ensure_owner(contract: H160, user: H160) -> DispatchResult {252			ensure!(<Owner<T>>::get(&contract) == user, Error::<T>::NoPermission);253			Ok(())254		}255	}256}257258#[derive(Encode, Decode, PartialEq, TypeInfo, MaxEncodedLen)]259pub enum SponsoringModeT {260	Disabled,261	Allowlisted,262	Generous,263}264265impl SponsoringModeT {266	fn from_eth(v: u8) -> Option<Self> {267		Some(match v {268			0 => Self::Disabled,269			1 => Self::Allowlisted,270			2 => Self::Generous,271			_ => return None,272		})273	}274	fn to_eth(self) -> u8 {275		match self {276			SponsoringModeT::Disabled => 0,277			SponsoringModeT::Allowlisted => 1,278			SponsoringModeT::Generous => 2,279		}280	}281}282283impl Default for SponsoringModeT {284	fn default() -> Self {285		Self::Disabled286	}287}