git.delta.rocks / unique-network / refs/commits / 4efa9ce62081

--- a/pallets/evm-contract-helpers/src/eth.rs
+++ b/pallets/evm-contract-helpers/src/eth.rs
@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
+//! Implementation of magic contract
+
 use core::marker::PhantomData;
 use evm_coder::{abi::AbiWriter, execution::Result, generate_stubgen, solidity_interface, types::*};
 use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder, dispatch_to_evm};
@@ -31,7 +33,8 @@
 use up_sponsorship::SponsorshipHandler;
 use sp_std::vec::Vec;
 
-struct ContractHelpers<T: Config>(SubstrateRecorder<T>);
+/// See [`ContractHelpersCall`]
+pub struct ContractHelpers<T: Config>(SubstrateRecorder<T>);
 impl<T: Config> WithRecorder<T> for ContractHelpers<T> {
 	fn recorder(&self) -> &SubstrateRecorder<T> {
 		&self.0
@@ -42,21 +45,24 @@
 	}
 }
 
+/// @title Magic contract, which allows users to reconfigure other contracts
 #[solidity_interface(name = ContractHelpers)]
 impl<T: Config> ContractHelpers<T>
 where
 	T::AccountId: AsRef<[u8; 32]>,
 {
-	/// Get contract ovner
-	///
-	/// @param contractAddress contract for which the owner is being determined.
-	/// @return Contract owner.
+	/// Get user, which deployed specified contract
+	/// @dev May return zero address in case if contract is deployed
+	///  using uniquenetwork evm-migration pallet, or using other terms not
+	///  intended by pallet-evm
+	/// @dev Returns zero address if contract does not exists
+	/// @param contractAddress Contract to get owner of
+	/// @return address Owner of contract
 	fn contract_owner(&self, contract_address: address) -> Result<address> {
 		Ok(<Owner<T>>::get(contract_address))
 	}
 
 	/// Set sponsor.
-	///
 	/// @param contractAddress Contract for which a sponsor is being established.
 	/// @param sponsor User address who set as pending sponsor.
 	fn set_sponsor(
@@ -163,6 +169,7 @@
 		&mut self,
 		caller: caller,
 		contract_address: address,
+		// TODO: implement support for enums in evm-coder
 		mode: uint8,
 	) -> Result<void> {
 		self.recorder().consume_sload()?;
@@ -175,10 +182,21 @@
 		Ok(())
 	}
 
-	fn sponsoring_mode(&self, contract_address: address) -> Result<uint8> {
-		Ok(<Pallet<T>>::sponsoring_mode(contract_address).to_eth())
+	/// Get current contract sponsoring rate limit
+	/// @param contractAddress Contract to get sponsoring mode of
+	/// @return uint32 Amount of blocks between two sponsored transactions
+	fn get_sponsoring_rate_limit(&self, contract_address: address) -> Result<uint32> {
+		Ok(<SponsoringRateLimit<T>>::get(contract_address)
+			.try_into()
+			.map_err(|_| "rate limit > u32::MAX")?)
 	}
 
+	/// Set contract sponsoring rate limit
+	/// @dev Sponsoring rate limit - is a minimum amount of blocks that should
+	///  pass between two sponsored transactions
+	/// @param contractAddress Contract to change sponsoring rate limit of
+	/// @param rateLimit Target rate limit
+	/// @dev Only contract owner can change this setting
 	fn set_sponsoring_rate_limit(
 		&mut self,
 		caller: caller,
@@ -190,57 +208,70 @@
 
 		<Pallet<T>>::ensure_owner(contract_address, caller).map_err(dispatch_to_evm::<T>)?;
 		<Pallet<T>>::set_sponsoring_rate_limit(contract_address, rate_limit.into());
-
 		Ok(())
 	}
 
-	fn get_sponsoring_rate_limit(&self, contract_address: address) -> Result<uint32> {
-		Ok(<SponsoringRateLimit<T>>::get(contract_address)
-			.try_into()
-			.map_err(|_| "rate limit > u32::MAX")?)
-	}
-
+	/// Is specified user present in contract allow list
+	/// @dev Contract owner always implicitly included
+	/// @param contractAddress Contract to check allowlist of
+	/// @param user User to check
+	/// @return bool Is specified users exists in contract allowlist
 	fn allowed(&self, contract_address: address, user: address) -> Result<bool> {
 		self.0.consume_sload()?;
 		Ok(<Pallet<T>>::allowed(contract_address, user))
 	}
 
-	fn allowlist_enabled(&self, contract_address: address) -> Result<bool> {
-		Ok(<AllowlistEnabled<T>>::get(contract_address))
-	}
-
-	fn toggle_allowlist(
+	/// Toggle user presence in contract allowlist
+	/// @param contractAddress Contract to change allowlist of
+	/// @param user Which user presence should be toggled
+	/// @param isAllowed `true` if user should be allowed to be sponsored
+	///  or call this contract, `false` otherwise
+	/// @dev Only contract owner can change this setting
+	fn toggle_allowed(
 		&mut self,
 		caller: caller,
 		contract_address: address,
-		enabled: bool,
+		user: address,
+		is_allowed: bool,
 	) -> Result<void> {
 		self.recorder().consume_sload()?;
 		self.recorder().consume_sstore()?;
 
 		<Pallet<T>>::ensure_owner(contract_address, caller).map_err(dispatch_to_evm::<T>)?;
-		<Pallet<T>>::toggle_allowlist(contract_address, enabled);
+		<Pallet<T>>::toggle_allowed(contract_address, user, is_allowed);
 
 		Ok(())
 	}
 
-	fn toggle_allowed(
+	/// Is this contract has allowlist access enabled
+	/// @dev Allowlist always can have users, and it is used for two purposes:
+	///  in case of allowlist sponsoring mode, users will be sponsored if they exist in allowlist
+	///  in case of allowlist access enabled, only users from allowlist may call this contract
+	/// @param contractAddress Contract to get allowlist access of
+	/// @return bool Is specified contract has allowlist access enabled
+	fn allowlist_enabled(&self, contract_address: address) -> Result<bool> {
+		Ok(<AllowlistEnabled<T>>::get(contract_address))
+	}
+
+	/// Toggle contract allowlist access
+	/// @param contractAddress Contract to change allowlist access of
+	/// @param enabled Should allowlist access to be enabled?
+	fn toggle_allowlist(
 		&mut self,
 		caller: caller,
 		contract_address: address,
-		user: address,
-		is_allowed: bool,
+		enabled: bool,
 	) -> Result<void> {
 		self.recorder().consume_sload()?;
 		self.recorder().consume_sstore()?;
 
 		<Pallet<T>>::ensure_owner(contract_address, caller).map_err(dispatch_to_evm::<T>)?;
-		<Pallet<T>>::toggle_allowed(contract_address, user, is_allowed);
-
+		<Pallet<T>>::toggle_allowlist(contract_address, enabled);
 		Ok(())
 	}
 }
 
+/// Implements [`OnMethodCall`], which delegates call to [`ContractHelpers`]
 pub struct HelpersOnMethodCall<T: Config>(PhantomData<*const T>);
 impl<T: Config> OnMethodCall<T> for HelpersOnMethodCall<T>
 where
@@ -283,6 +314,7 @@
 	}
 }
 
+/// Hooks into contract creation, storing owner of newly deployed contract
 pub struct HelpersOnCreate<T: Config>(PhantomData<*const T>);
 impl<T: Config> OnCreate<T> for HelpersOnCreate<T> {
 	fn on_create(owner: H160, contract: H160) {
@@ -290,6 +322,7 @@
 	}
 }
 
+/// Bridge to pallet-sponsoring
 pub struct HelpersContractSponsoring<T: Config>(PhantomData<*const T>);
 impl<T: Config> SponsorshipHandler<T::CrossAccountId, (H160, Vec<u8>)>
 	for HelpersContractSponsoring<T>

--- a/pallets/evm-contract-helpers/src/lib.rs
+++ b/pallets/evm-contract-helpers/src/lib.rs
@@ -14,7 +14,9 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
+#![doc = include_str!("../README.md")]
 #![cfg_attr(not(feature = "std"), no_std)]
+#![deny(missing_docs)]
 
 use codec::{Decode, Encode, MaxEncodedLen};
 pub use pallet::*;
@@ -35,13 +37,16 @@
 	pub trait Config:
 		frame_system::Config + pallet_evm_coder_substrate::Config + pallet_evm::account::Config
 	{
+		/// Address, under which magic contract will be available
 		type ContractAddress: Get<H160>;
+		/// In case of enabled sponsoring, but no sponsoring rate limit set,
+		/// this value will be used implicitly
 		type DefaultSponsoringRateLimit: Get<Self::BlockNumber>;
 	}
 
 	#[pallet::error]
 	pub enum Error<T> {
-		/// This method is only executable by owner.
+		/// This method is only executable by contract owner
 		NoPermission,
 
 		/// No pending sponsor for contract.
@@ -217,6 +222,7 @@
 			}
 		}
 
+		/// Get current sponsoring mode, performing lazy migration from legacy storage
 		pub fn sponsoring_mode(contract: H160) -> SponsoringModeT {
 			<SponsoringMode<T>>::get(contract)
 				.or_else(|| {
@@ -225,6 +231,7 @@
 				.unwrap_or_default()
 		}
 
+		/// Reconfigure contract sponsoring mode
 		pub fn set_sponsoring_mode(contract: H160, mode: SponsoringModeT) {
 			if mode == SponsoringModeT::Disabled {
 				<SponsoringMode<T>>::remove(contract);
@@ -234,22 +241,27 @@
 			<SelfSponsoring<T>>::remove(contract)
 		}
 
+		/// Set duration between two sponsored contract calls
 		pub fn set_sponsoring_rate_limit(contract: H160, rate_limit: T::BlockNumber) {
 			<SponsoringRateLimit<T>>::insert(contract, rate_limit);
 		}
 
+		/// Is user added to allowlist, or he is owner of specified contract
 		pub fn allowed(contract: H160, user: H160) -> bool {
 			<Allowlist<T>>::get(&contract, &user) || <Owner<T>>::get(&contract) == user
 		}
 
+		/// Toggle contract allowlist access
 		pub fn toggle_allowlist(contract: H160, enabled: bool) {
 			<AllowlistEnabled<T>>::insert(contract, enabled)
 		}
 
+		/// Toggle user presence in contract's allowlist
 		pub fn toggle_allowed(contract: H160, user: H160, allowed: bool) {
 			<Allowlist<T>>::insert(contract, user, allowed);
 		}
 
+		/// Throw error if user is not allowed to reconfigure target contract
 		pub fn ensure_owner(contract: H160, user: H160) -> DispatchResult {
 			ensure!(<Owner<T>>::get(&contract) == user, Error::<T>::NoPermission);
 			Ok(())
@@ -257,10 +269,15 @@
 	}
 }
 
-#[derive(Encode, Decode, PartialEq, TypeInfo, MaxEncodedLen)]
+/// Available contract sponsoring modes
+#[derive(Encode, Decode, PartialEq, TypeInfo, MaxEncodedLen, Default)]
 pub enum SponsoringModeT {
+	/// Sponsoring is disabled
+	#[default]
 	Disabled,
+	/// Only users from allowlist will be sponsored
 	Allowlisted,
+	/// All users will be sponsored
 	Generous,
 }
 
@@ -279,11 +296,5 @@
 			SponsoringModeT::Allowlisted => 1,
 			SponsoringModeT::Generous => 2,
 		}
-	}
-}
-
-impl Default for SponsoringModeT {
-	fn default() -> Self {
-		Self::Disabled
 	}
 }

binary blob — no preview

33
4pragma solidity >=0.8.0 <0.9.0;4pragma solidity >=0.8.0 <0.9.0;
5
6/// @dev anonymous struct
7struct Tuple0 {
8	address field_0;
9	uint256 field_1;
10}
115
12/// @dev common stubs holder6/// @dev common stubs holder
13contract Dummy {7contract Dummy {
27	}21	}
28}22}
2923
24/// @title Magic contract, which allows users to reconfigure other contracts
30/// @dev the ERC-165 identifier for this interface is 0x6073d91725/// @dev the ERC-165 identifier for this interface is 0xd77fab70
31contract ContractHelpers is Dummy, ERC165 {26contract ContractHelpers is Dummy, ERC165 {
32	/// Get contract ovner27	/// Get user, which deployed specified contract
33	///28	/// @dev May return zero address in case if contract is deployed
34	/// @param contractAddress contract for which the owner is being determined.29	///  using uniquenetwork evm-migration pallet, or using other terms not
30	///  intended by pallet-evm
31	/// @dev Returns zero address if contract does not exists
32	/// @param contractAddress Contract to get owner of
35	/// @return Contract owner.33	/// @return address Owner of contract
36	///34	/// @dev EVM selector for this function is: 0x5152b14c,
37	/// Selector: contractOwner(address) 5152b14c35	///  or in textual repr: contractOwner(address)
38	function contractOwner(address contractAddress)36	function contractOwner(address contractAddress)
39		public37		public
40		view38		view
47	}45	}
4846
49	/// Set sponsor.47	/// Set sponsor.
50	///
51	/// @param contractAddress Contract for which a sponsor is being established.48	/// @param contractAddress Contract for which a sponsor is being established.
52	/// @param sponsor User address who set as pending sponsor.49	/// @param sponsor User address who set as pending sponsor.
53	///50	/// @dev EVM selector for this function is: 0xf01fba93,
54	/// Selector: setSponsor(address,address) f01fba9351	///  or in textual repr: setSponsor(address,address)
55	function setSponsor(address contractAddress, address sponsor) public {52	function setSponsor(address contractAddress, address sponsor) public {
56		require(false, stub_error);53		require(false, stub_error);
57		contractAddress;54		contractAddress;
62	/// Set contract as self sponsored.59	/// Set contract as self sponsored.
63	///60	///
64	/// @param contractAddress Contract for which a self sponsoring is being enabled.61	/// @param contractAddress Contract for which a self sponsoring is being enabled.
65	///62	/// @dev EVM selector for this function is: 0x89f7d9ae,
66	/// Selector: selfSponsoredEnable(address) 89f7d9ae63	///  or in textual repr: selfSponsoredEnable(address)
67	function selfSponsoredEnable(address contractAddress) public {64	function selfSponsoredEnable(address contractAddress) public {
68		require(false, stub_error);65		require(false, stub_error);
69		contractAddress;66		contractAddress;
73	/// Remove sponsor.70	/// Remove sponsor.
74	///71	///
75	/// @param contractAddress Contract for which a sponsorship is being removed.72	/// @param contractAddress Contract for which a sponsorship is being removed.
76	///73	/// @dev EVM selector for this function is: 0xef784250,
77	/// Selector: removeSponsor(address) ef78425074	///  or in textual repr: removeSponsor(address)
78	function removeSponsor(address contractAddress) public {75	function removeSponsor(address contractAddress) public {
79		require(false, stub_error);76		require(false, stub_error);
80		contractAddress;77		contractAddress;
86	/// @dev Caller must be same that set via [`setSponsor`].83	/// @dev Caller must be same that set via [`setSponsor`].
87	///84	///
88	/// @param contractAddress Сontract for which need to confirm sponsorship.85	/// @param contractAddress Сontract for which need to confirm sponsorship.
89	///86	/// @dev EVM selector for this function is: 0xabc00001,
90	/// Selector: confirmSponsorship(address) abc0000187	///  or in textual repr: confirmSponsorship(address)
91	function confirmSponsorship(address contractAddress) public {88	function confirmSponsorship(address contractAddress) public {
92		require(false, stub_error);89		require(false, stub_error);
93		contractAddress;90		contractAddress;
98	///95	///
99	/// @param contractAddress The contract for which a sponsor is requested.96	/// @param contractAddress The contract for which a sponsor is requested.
100	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.97	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
101	///98	/// @dev EVM selector for this function is: 0x743fc745,
102	/// Selector: getSponsor(address) 743fc74599	///  or in textual repr: getSponsor(address)
103	function getSponsor(address contractAddress)100	function getSponsor(address contractAddress)
104		public101		public
105		view102		view
115	///112	///
116	/// @param contractAddress The contract for which the presence of a confirmed sponsor is checked.113	/// @param contractAddress The contract for which the presence of a confirmed sponsor is checked.
117	/// @return **true** if contract has confirmed sponsor.114	/// @return **true** if contract has confirmed sponsor.
118	///115	/// @dev EVM selector for this function is: 0x97418603,
119	/// Selector: hasSponsor(address) 97418603116	///  or in textual repr: hasSponsor(address)
120	function hasSponsor(address contractAddress) public view returns (bool) {117	function hasSponsor(address contractAddress) public view returns (bool) {
121		require(false, stub_error);118		require(false, stub_error);
122		contractAddress;119		contractAddress;
128	///125	///
129	/// @param contractAddress The contract for which the presence of a pending sponsor is checked.126	/// @param contractAddress The contract for which the presence of a pending sponsor is checked.
130	/// @return **true** if contract has pending sponsor.127	/// @return **true** if contract has pending sponsor.
131	///128	/// @dev EVM selector for this function is: 0x39b9b242,
132	/// Selector: hasPendingSponsor(address) 39b9b242129	///  or in textual repr: hasPendingSponsor(address)
133	function hasPendingSponsor(address contractAddress)130	function hasPendingSponsor(address contractAddress)
134		public131		public
135		view132		view
141		return false;138		return false;
142	}139	}
143140
141	/// @dev EVM selector for this function is: 0x6027dc61,
144	/// Selector: sponsoringEnabled(address) 6027dc61142	///  or in textual repr: sponsoringEnabled(address)
145	function sponsoringEnabled(address contractAddress)143	function sponsoringEnabled(address contractAddress)
146		public144		public
147		view145		view
153		return false;151		return false;
154	}152	}
155153
154	/// @dev EVM selector for this function is: 0xfde8a560,
156	/// Selector: setSponsoringMode(address,uint8) fde8a560155	///  or in textual repr: setSponsoringMode(address,uint8)
157	function setSponsoringMode(address contractAddress, uint8 mode) public {156	function setSponsoringMode(address contractAddress, uint8 mode) public {
158		require(false, stub_error);157		require(false, stub_error);
159		contractAddress;158		contractAddress;
160		mode;159		mode;
161		dummy = 0;160		dummy = 0;
162	}161	}
163162
164	/// Selector: sponsoringMode(address) b70c7267163	/// Get current contract sponsoring rate limit
164	/// @param contractAddress Contract to get sponsoring mode of
165	/// @return uint32 Amount of blocks between two sponsored transactions
166	/// @dev EVM selector for this function is: 0x610cfabd,
167	///  or in textual repr: getSponsoringRateLimit(address)
165	function sponsoringMode(address contractAddress)168	function getSponsoringRateLimit(address contractAddress)
166		public169		public
167		view170		view
168		returns (uint8)171		returns (uint32)
169	{172	{
170		require(false, stub_error);173		require(false, stub_error);
171		contractAddress;174		contractAddress;
172		dummy;175		dummy;
173		return 0;176		return 0;
174	}177	}
175178
179	/// Set contract sponsoring rate limit
180	/// @dev Sponsoring rate limit - is a minimum amount of blocks that should
181	///  pass between two sponsored transactions
182	/// @param contractAddress Contract to change sponsoring rate limit of
183	/// @param rateLimit Target rate limit
184	/// @dev Only contract owner can change this setting
185	/// @dev EVM selector for this function is: 0x77b6c908,
176	/// Selector: setSponsoringRateLimit(address,uint32) 77b6c908186	///  or in textual repr: setSponsoringRateLimit(address,uint32)
177	function setSponsoringRateLimit(address contractAddress, uint32 rateLimit)187	function setSponsoringRateLimit(address contractAddress, uint32 rateLimit)
178		public188		public
179	{189	{
183		dummy = 0;193		dummy = 0;
184	}194	}
185195
186	/// Selector: getSponsoringRateLimit(address) 610cfabd196	/// Is specified user present in contract allow list
197	/// @dev Contract owner always implicitly included
198	/// @param contractAddress Contract to check allowlist of
199	/// @param user User to check
200	/// @return bool Is specified users exists in contract allowlist
201	/// @dev EVM selector for this function is: 0x5c658165,
202	///  or in textual repr: allowed(address,address)
187	function getSponsoringRateLimit(address contractAddress)203	function allowed(address contractAddress, address user)
188		public204		public
189		view205		view
190		returns (uint32)206		returns (bool)
191	{207	{
192		require(false, stub_error);208		require(false, stub_error);
193		contractAddress;209		contractAddress;
210		user;
194		dummy;211		dummy;
195		return 0;212		return false;
196	}213	}
197214
215	/// Toggle user presence in contract allowlist
216	/// @param contractAddress Contract to change allowlist of
217	/// @param user Which user presence should be toggled
218	/// @param isAllowed `true` if user should be allowed to be sponsored
219	///  or call this contract, `false` otherwise
220	/// @dev Only contract owner can change this setting
221	/// @dev EVM selector for this function is: 0x4706cc1c,
198	/// Selector: allowed(address,address) 5c658165222	///  or in textual repr: toggleAllowed(address,address,bool)
199	function allowed(address contractAddress, address user)223	function toggleAllowed(
224		address contractAddress,
225		address user,
226		bool isAllowed
200		public227	) public {
201		view
202		returns (bool)
203	{
204		require(false, stub_error);228		require(false, stub_error);
205		contractAddress;229		contractAddress;
206		user;230		user;
207		dummy;231		isAllowed;
208		return false;232		dummy = 0;
209	}233	}
210234
235	/// Is this contract has allowlist access enabled
236	/// @dev Allowlist always can have users, and it is used for two purposes:
237	///  in case of allowlist sponsoring mode, users will be sponsored if they exist in allowlist
238	///  in case of allowlist access enabled, only users from allowlist may call this contract
239	/// @param contractAddress Contract to get allowlist access of
240	/// @return bool Is specified contract has allowlist access enabled
241	/// @dev EVM selector for this function is: 0xc772ef6c,
211	/// Selector: allowlistEnabled(address) c772ef6c242	///  or in textual repr: allowlistEnabled(address)
212	function allowlistEnabled(address contractAddress)243	function allowlistEnabled(address contractAddress)
213		public244		public
214		view245		view
220		return false;251		return false;
221	}252	}
222253
254	/// Toggle contract allowlist access
255	/// @param contractAddress Contract to change allowlist access of
256	/// @param enabled Should allowlist access to be enabled?
257	/// @dev EVM selector for this function is: 0x36de20f5,
223	/// Selector: toggleAllowlist(address,bool) 36de20f5258	///  or in textual repr: toggleAllowlist(address,bool)
224	function toggleAllowlist(address contractAddress, bool enabled) public {259	function toggleAllowlist(address contractAddress, bool enabled) public {
225		require(false, stub_error);260		require(false, stub_error);
226		contractAddress;261		contractAddress;
227		enabled;262		enabled;
228		dummy = 0;263		dummy = 0;
229	}264	}
230
231	/// Selector: toggleAllowed(address,address,bool) 4706cc1c
232	function toggleAllowed(
233		address contractAddress,
234		address user,
235		bool isAllowed
236	) public {
237		require(false, stub_error);
238		contractAddress;
239		user;
240		isAllowed;
241		dummy = 0;
242	}
243}265}
266
267/// @dev anonymous struct
268struct Tuple0 {
269	address field_0;
270	uint256 field_1;
271}
244272

--- a/tests/src/eth/api/ContractHelpers.sol
+++ b/tests/src/eth/api/ContractHelpers.sol
@@ -3,12 +3,6 @@
 
 pragma solidity >=0.8.0 <0.9.0;
 
-/// @dev anonymous struct
-struct Tuple0 {
-	address field_0;
-	uint256 field_1;
-}
-
 /// @dev common stubs holder
 interface Dummy {
 
@@ -18,39 +12,42 @@
 	function supportsInterface(bytes4 interfaceID) external view returns (bool);
 }
 
-/// @dev the ERC-165 identifier for this interface is 0x6073d917
+/// @title Magic contract, which allows users to reconfigure other contracts
+/// @dev the ERC-165 identifier for this interface is 0xd77fab70
 interface ContractHelpers is Dummy, ERC165 {
-	/// Get contract ovner
-	///
-	/// @param contractAddress contract for which the owner is being determined.
-	/// @return Contract owner.
-	///
-	/// Selector: contractOwner(address) 5152b14c
+	/// Get user, which deployed specified contract
+	/// @dev May return zero address in case if contract is deployed
+	///  using uniquenetwork evm-migration pallet, or using other terms not
+	///  intended by pallet-evm
+	/// @dev Returns zero address if contract does not exists
+	/// @param contractAddress Contract to get owner of
+	/// @return address Owner of contract
+	/// @dev EVM selector for this function is: 0x5152b14c,
+	///  or in textual repr: contractOwner(address)
 	function contractOwner(address contractAddress)
 		external
 		view
 		returns (address);
 
 	/// Set sponsor.
-	///
 	/// @param contractAddress Contract for which a sponsor is being established.
 	/// @param sponsor User address who set as pending sponsor.
-	///
-	/// Selector: setSponsor(address,address) f01fba93
+	/// @dev EVM selector for this function is: 0xf01fba93,
+	///  or in textual repr: setSponsor(address,address)
 	function setSponsor(address contractAddress, address sponsor) external;
 
 	/// Set contract as self sponsored.
 	///
 	/// @param contractAddress Contract for which a self sponsoring is being enabled.
-	///
-	/// Selector: selfSponsoredEnable(address) 89f7d9ae
+	/// @dev EVM selector for this function is: 0x89f7d9ae,
+	///  or in textual repr: selfSponsoredEnable(address)
 	function selfSponsoredEnable(address contractAddress) external;
 
 	/// Remove sponsor.
 	///
 	/// @param contractAddress Contract for which a sponsorship is being removed.
-	///
-	/// Selector: removeSponsor(address) ef784250
+	/// @dev EVM selector for this function is: 0xef784250,
+	///  or in textual repr: removeSponsor(address)
 	function removeSponsor(address contractAddress) external;
 
 	/// Confirm sponsorship.
@@ -58,16 +55,16 @@
 	/// @dev Caller must be same that set via [`setSponsor`].
 	///
 	/// @param contractAddress Сontract for which need to confirm sponsorship.
-	///
-	/// Selector: confirmSponsorship(address) abc00001
+	/// @dev EVM selector for this function is: 0xabc00001,
+	///  or in textual repr: confirmSponsorship(address)
 	function confirmSponsorship(address contractAddress) external;
 
 	/// Get current sponsor.
 	///
 	/// @param contractAddress The contract for which a sponsor is requested.
 	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
-	///
-	/// Selector: getSponsor(address) 743fc745
+	/// @dev EVM selector for this function is: 0x743fc745,
+	///  or in textual repr: getSponsor(address)
 	function getSponsor(address contractAddress)
 		external
 		view
@@ -77,65 +74,102 @@
 	///
 	/// @param contractAddress The contract for which the presence of a confirmed sponsor is checked.
 	/// @return **true** if contract has confirmed sponsor.
-	///
-	/// Selector: hasSponsor(address) 97418603
+	/// @dev EVM selector for this function is: 0x97418603,
+	///  or in textual repr: hasSponsor(address)
 	function hasSponsor(address contractAddress) external view returns (bool);
 
 	/// Check tat contract has pending sponsor.
 	///
 	/// @param contractAddress The contract for which the presence of a pending sponsor is checked.
 	/// @return **true** if contract has pending sponsor.
-	///
-	/// Selector: hasPendingSponsor(address) 39b9b242
+	/// @dev EVM selector for this function is: 0x39b9b242,
+	///  or in textual repr: hasPendingSponsor(address)
 	function hasPendingSponsor(address contractAddress)
 		external
 		view
 		returns (bool);
 
-	/// Selector: sponsoringEnabled(address) 6027dc61
+	/// @dev EVM selector for this function is: 0x6027dc61,
+	///  or in textual repr: sponsoringEnabled(address)
 	function sponsoringEnabled(address contractAddress)
 		external
 		view
 		returns (bool);
 
-	/// Selector: setSponsoringMode(address,uint8) fde8a560
+	/// @dev EVM selector for this function is: 0xfde8a560,
+	///  or in textual repr: setSponsoringMode(address,uint8)
 	function setSponsoringMode(address contractAddress, uint8 mode) external;
 
-	/// Selector: sponsoringMode(address) b70c7267
-	function sponsoringMode(address contractAddress)
+	/// Get current contract sponsoring rate limit
+	/// @param contractAddress Contract to get sponsoring mode of
+	/// @return uint32 Amount of blocks between two sponsored transactions
+	/// @dev EVM selector for this function is: 0x610cfabd,
+	///  or in textual repr: getSponsoringRateLimit(address)
+	function getSponsoringRateLimit(address contractAddress)
 		external
 		view
-		returns (uint8);
+		returns (uint32);
 
-	/// Selector: setSponsoringRateLimit(address,uint32) 77b6c908
+	/// Set contract sponsoring rate limit
+	/// @dev Sponsoring rate limit - is a minimum amount of blocks that should
+	///  pass between two sponsored transactions
+	/// @param contractAddress Contract to change sponsoring rate limit of
+	/// @param rateLimit Target rate limit
+	/// @dev Only contract owner can change this setting
+	/// @dev EVM selector for this function is: 0x77b6c908,
+	///  or in textual repr: setSponsoringRateLimit(address,uint32)
 	function setSponsoringRateLimit(address contractAddress, uint32 rateLimit)
 		external;
 
-	/// Selector: getSponsoringRateLimit(address) 610cfabd
-	function getSponsoringRateLimit(address contractAddress)
-		external
-		view
-		returns (uint32);
-
-	/// Selector: allowed(address,address) 5c658165
+	/// Is specified user present in contract allow list
+	/// @dev Contract owner always implicitly included
+	/// @param contractAddress Contract to check allowlist of
+	/// @param user User to check
+	/// @return bool Is specified users exists in contract allowlist
+	/// @dev EVM selector for this function is: 0x5c658165,
+	///  or in textual repr: allowed(address,address)
 	function allowed(address contractAddress, address user)
 		external
 		view
 		returns (bool);
 
-	/// Selector: allowlistEnabled(address) c772ef6c
+	/// Toggle user presence in contract allowlist
+	/// @param contractAddress Contract to change allowlist of
+	/// @param user Which user presence should be toggled
+	/// @param isAllowed `true` if user should be allowed to be sponsored
+	///  or call this contract, `false` otherwise
+	/// @dev Only contract owner can change this setting
+	/// @dev EVM selector for this function is: 0x4706cc1c,
+	///  or in textual repr: toggleAllowed(address,address,bool)
+	function toggleAllowed(
+		address contractAddress,
+		address user,
+		bool isAllowed
+	) external;
+
+	/// Is this contract has allowlist access enabled
+	/// @dev Allowlist always can have users, and it is used for two purposes:
+	///  in case of allowlist sponsoring mode, users will be sponsored if they exist in allowlist
+	///  in case of allowlist access enabled, only users from allowlist may call this contract
+	/// @param contractAddress Contract to get allowlist access of
+	/// @return bool Is specified contract has allowlist access enabled
+	/// @dev EVM selector for this function is: 0xc772ef6c,
+	///  or in textual repr: allowlistEnabled(address)
 	function allowlistEnabled(address contractAddress)
 		external
 		view
 		returns (bool);
 
-	/// Selector: toggleAllowlist(address,bool) 36de20f5
+	/// Toggle contract allowlist access
+	/// @param contractAddress Contract to change allowlist access of
+	/// @param enabled Should allowlist access to be enabled?
+	/// @dev EVM selector for this function is: 0x36de20f5,
+	///  or in textual repr: toggleAllowlist(address,bool)
 	function toggleAllowlist(address contractAddress, bool enabled) external;
+}
 
-	/// Selector: toggleAllowed(address,address,bool) 4706cc1c
-	function toggleAllowed(
-		address contractAddress,
-		address user,
-		bool isAllowed
-	) external;
+/// @dev anonymous struct
+struct Tuple0 {
+	address field_0;
+	uint256 field_1;
 }

--- a/tests/src/eth/util/contractHelpersAbi.json
+++ b/tests/src/eth/util/contractHelpersAbi.json
@@ -197,19 +197,6 @@
   },
   {
     "inputs": [
-      {
-        "internalType": "address",
-        "name": "contractAddress",
-        "type": "address"
-      }
-    ],
-    "name": "sponsoringMode",
-    "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
       { "internalType": "bytes4", "name": "interfaceID", "type": "bytes4" }
     ],
     "name": "supportsInterface",