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

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/>.1617use core::marker::PhantomData;18use evm_coder::{abi::AbiWriter, execution::Result, generate_stubgen, solidity_interface, types::*};19use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder, dispatch_to_evm};20use pallet_evm::{21	ExitRevert, OnCreate, OnMethodCall, PrecompileResult, PrecompileFailure, PrecompileHandle,22	account::CrossAccountId,23};24use sp_core::H160;25use up_data_structs::SponsorshipState;26use crate::{27	AllowlistEnabled, Config, Owner, Pallet, SponsorBasket, SponsoringRateLimit, SponsoringModeT,28	Sponsoring,29};30use frame_support::traits::Get;31use up_sponsorship::SponsorshipHandler;32use sp_std::vec::Vec;3334struct ContractHelpers<T: Config>(SubstrateRecorder<T>);35impl<T: Config> WithRecorder<T> for ContractHelpers<T> {36	fn recorder(&self) -> &SubstrateRecorder<T> {37		&self.038	}3940	fn into_recorder(self) -> SubstrateRecorder<T> {41		self.042	}43}4445#[solidity_interface(name = "ContractHelpers")]46impl<T: Config> ContractHelpers<T>47where48	T::AccountId: AsRef<[u8; 32]>,49{50	/// Get contract ovner51	///52	/// @param Contract_address contract for which the owner is being determined.53	/// @return Contract owner.54	fn contract_owner(&self, contract_address: address) -> Result<address> {55		Ok(<Owner<T>>::get(contract_address))56	}5758	/// Set sponsor.59	///60	/// @param contract_address Contract for which a sponsor is being established.61	/// @param sponsor User address who set as pending sponsor.62	fn set_sponsor(63		&mut self,64		caller: caller,65		contract_address: address,66		sponsor: address,67	) -> Result<void> {68		Pallet::<T>::set_sponsor(69			&T::CrossAccountId::from_eth(caller),70			contract_address,71			&T::CrossAccountId::from_eth(sponsor),72		)73		.map_err(dispatch_to_evm::<T>)?;7475		self.recorder().consume_sload()?;76		self.recorder().consume_sstore()?;77		78		Ok(())79	}8081	/// Set contract as self sponsored.82	///83	/// @param contract_address Contract for which a self sponsoring is being enabled.84	fn self_sponsored_enable(&mut self, caller: caller, contract_address: address) -> Result<void> {85		Pallet::<T>::self_sponsored_enable(&T::CrossAccountId::from_eth(caller), contract_address)86			.map_err(dispatch_to_evm::<T>)?;87		88		self.recorder().consume_sload()?;89		self.recorder().consume_sstore()?;9091		Ok(())92	}9394	/// Remove sponsor.95	///96	/// @param contract_address Contract for which a sponsorship is being removed.97	fn remove_sponsor(&mut self, caller: caller, contract_address: address) -> Result<void> {98		Pallet::<T>::remove_sponsor(&T::CrossAccountId::from_eth(caller), contract_address)99			.map_err(dispatch_to_evm::<T>)?;100101		self.recorder().consume_sload()?;102		self.recorder().consume_sstore()?;103		104		Ok(())105	}106107	/// Confirm sponsorship.108	///109	/// @dev Caller must be same that set via [`set_sponsor`].110	///111	/// @param contract_address Сontract for which need to confirm sponsorship.112	fn confirm_sponsorship(&mut self, caller: caller, contract_address: address) -> Result<void> {113		Pallet::<T>::confirm_sponsorship(&T::CrossAccountId::from_eth(caller), contract_address)114			.map_err(dispatch_to_evm::<T>)?;115116		self.recorder().consume_sload()?;117		self.recorder().consume_sstore()?;118119		Ok(())120	}121122	/// Get current sponsor.123	///124	/// @param contract_address The contract for which a sponsor is requested.125	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.126	fn get_sponsor(&self, contract_address: address) -> Result<(address, uint256)> {127		let sponsor =128			Pallet::<T>::get_sponsor(contract_address).ok_or("Contract has no sponsor")?;129		let sponsor_sub = pallet_common::eth::convert_cross_account_to_uint256::<T>(&sponsor);130		Ok((*sponsor.as_eth(), sponsor_sub))131	}132133	/// Check tat contract has confirmed sponsor.134	///135	/// @param contract_address The contract for which the presence of a confirmed sponsor is checked.136	/// @return **true** if contract has confirmed sponsor.137	fn has_sponsor(&self, contract_address: address) -> Result<bool> {138		Ok(Pallet::<T>::get_sponsor(contract_address).is_some())139	}140141	/// Check tat contract has pending sponsor.142	///143	/// @param contract_address The contract for which the presence of a pending sponsor is checked.144	/// @return **true** if contract has pending sponsor.145	fn has_pending_sponsor(&self, contract_address: address) -> Result<bool> {146		Ok(match Sponsoring::<T>::get(contract_address) {147			SponsorshipState::Disabled | SponsorshipState::Confirmed(_) => false,148			SponsorshipState::Unconfirmed(_) => true,149		})150	}151152	fn sponsoring_enabled(&self, contract_address: address) -> Result<bool> {153		Ok(<Pallet<T>>::sponsoring_mode(contract_address) != SponsoringModeT::Disabled)154	}155156	fn set_sponsoring_mode(157		&mut self,158		caller: caller,159		contract_address: address,160		mode: uint8,161	) -> Result<void> {162		<Pallet<T>>::ensure_owner(contract_address, caller).map_err(dispatch_to_evm::<T>)?;163		let mode = SponsoringModeT::from_eth(mode).ok_or("unknown mode")?;164		<Pallet<T>>::set_sponsoring_mode(contract_address, mode);165166		self.recorder().consume_sload()?;167		self.recorder().consume_sstore()?;168169		Ok(())170	}171172	fn sponsoring_mode(&self, contract_address: address) -> Result<uint8> {173		Ok(<Pallet<T>>::sponsoring_mode(contract_address).to_eth())174	}175176	fn set_sponsoring_rate_limit(177		&mut self,178		caller: caller,179		contract_address: address,180		rate_limit: uint32,181	) -> Result<void> {182		<Pallet<T>>::ensure_owner(contract_address, caller).map_err(dispatch_to_evm::<T>)?;183		<Pallet<T>>::set_sponsoring_rate_limit(contract_address, rate_limit.into());184185		self.recorder().consume_sload()?;186		self.recorder().consume_sstore()?;187188		Ok(())189	}190191	fn get_sponsoring_rate_limit(&self, contract_address: address) -> Result<uint32> {192		Ok(<SponsoringRateLimit<T>>::get(contract_address)193			.try_into()194			.map_err(|_| "rate limit > u32::MAX")?)195	}196197	fn allowed(&self, contract_address: address, user: address) -> Result<bool> {198		self.0.consume_sload()?;199		Ok(<Pallet<T>>::allowed(contract_address, user))200	}201202	fn allowlist_enabled(&self, contract_address: address) -> Result<bool> {203		Ok(<AllowlistEnabled<T>>::get(contract_address))204	}205206	fn toggle_allowlist(207		&mut self,208		caller: caller,209		contract_address: address,210		enabled: bool,211	) -> Result<void> {212		<Pallet<T>>::ensure_owner(contract_address, caller).map_err(dispatch_to_evm::<T>)?;213		<Pallet<T>>::toggle_allowlist(contract_address, enabled);214215		self.recorder().consume_sload()?;216		self.recorder().consume_sstore()?;217218		Ok(())219	}220221	fn toggle_allowed(222		&mut self,223		caller: caller,224		contract_address: address,225		user: address,226		allowed: bool,227	) -> Result<void> {228		<Pallet<T>>::ensure_owner(contract_address, caller).map_err(dispatch_to_evm::<T>)?;229		<Pallet<T>>::toggle_allowed(contract_address, user, allowed);230231		self.recorder().consume_sload()?;232		self.recorder().consume_sstore()?;233		234		Ok(())235	}236}237238pub struct HelpersOnMethodCall<T: Config>(PhantomData<*const T>);239impl<T: Config> OnMethodCall<T> for HelpersOnMethodCall<T>240where241	T::AccountId: AsRef<[u8; 32]>,242{243	fn is_reserved(contract: &sp_core::H160) -> bool {244		contract == &T::ContractAddress::get()245	}246247	fn is_used(contract: &sp_core::H160) -> bool {248		contract == &T::ContractAddress::get()249	}250251	fn call(handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {252		// TODO: Extract to another OnMethodCall handler253		if <AllowlistEnabled<T>>::get(handle.code_address())254			&& !<Pallet<T>>::allowed(handle.code_address(), handle.context().caller)255		{256			return Some(Err(PrecompileFailure::Revert {257				exit_status: ExitRevert::Reverted,258				output: {259					let mut writer = AbiWriter::new_call(evm_coder::fn_selector!(Error(string)));260					writer.string("Target contract is allowlisted");261					writer.finish()262				},263			}));264		}265266		if handle.code_address() != T::ContractAddress::get() {267			return None;268		}269270		let helpers = ContractHelpers::<T>(SubstrateRecorder::<T>::new(handle.remaining_gas()));271		pallet_evm_coder_substrate::call(handle, helpers)272	}273274	fn get_code(contract: &sp_core::H160) -> Option<Vec<u8>> {275		(contract == &T::ContractAddress::get())276			.then(|| include_bytes!("./stubs/ContractHelpers.raw").to_vec())277	}278}279280pub struct HelpersOnCreate<T: Config>(PhantomData<*const T>);281impl<T: Config> OnCreate<T> for HelpersOnCreate<T> {282	fn on_create(owner: H160, contract: H160) {283		<Owner<T>>::insert(contract, owner);284	}285}286287pub struct HelpersContractSponsoring<T: Config>(PhantomData<*const T>);288impl<T: Config> SponsorshipHandler<T::CrossAccountId, (H160, Vec<u8>)>289	for HelpersContractSponsoring<T>290{291	fn get_sponsor(who: &T::CrossAccountId, call: &(H160, Vec<u8>)) -> Option<T::CrossAccountId> {292		let (contract, _) = call;293		let mode = <Pallet<T>>::sponsoring_mode(*contract);294		if mode == SponsoringModeT::Disabled {295			return None;296		}297298		let sponsor = match <Pallet<T>>::get_sponsor(*contract) {299			Some(sponsor) => sponsor,300			None => return None,301		};302303		if mode == SponsoringModeT::Allowlisted && !<Pallet<T>>::allowed(*contract, *who.as_eth()) {304			return None;305		}306		let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;307308		if let Some(last_tx_block) = <SponsorBasket<T>>::get(contract, who.as_eth()) {309			let limit = <SponsoringRateLimit<T>>::get(contract);310311			let timeout = last_tx_block + limit;312			if block_number < timeout {313				return None;314			}315		}316317		<SponsorBasket<T>>::insert(contract, who.as_eth(), block_number);318319		Some(sponsor)320	}321}322323generate_stubgen!(contract_helpers_impl, ContractHelpersCall<()>, true);324generate_stubgen!(contract_helpers_iface, ContractHelpersCall<()>, false);