1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8 uint8 dummy;9 string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13 function supportsInterface(bytes4 interfaceID) external view returns (bool) {14 require(false, stub_error);15 interfaceID;16 return true;17 }18}1920/// @dev inlined interface21contract ContractHelpersEvents {22 event ContractSponsorSet(address indexed contractAddress, address sponsor);23 event ContractSponsorshipConfirmed(address indexed contractAddress, address sponsor);24 event ContractSponsorRemoved(address indexed contractAddress);25}2627/// @title Magic contract, which allows users to reconfigure other contracts28/// @dev the ERC-165 identifier for this interface is 0x30afad0429contract ContractHelpers is Dummy, ERC165, ContractHelpersEvents {30 /// Get user, which deployed specified contract31 /// @dev May return zero address in case if contract is deployed32 /// using uniquenetwork evm-migration pallet, or using other terms not33 /// intended by pallet-evm34 /// @dev Returns zero address if contract does not exists35 /// @param contractAddress Contract to get owner of36 /// @return address Owner of contract37 /// @dev EVM selector for this function is: 0x5152b14c,38 /// or in textual repr: contractOwner(address)39 function contractOwner(address contractAddress) public view returns (address) {40 require(false, stub_error);41 contractAddress;42 dummy;43 return 0x0000000000000000000000000000000000000000;44 }4546 /// Set sponsor.47 /// @param contractAddress Contract for which a sponsor is being established.48 /// @param sponsor User address who set as pending sponsor.49 /// @dev EVM selector for this function is: 0xf01fba93,50 /// or in textual repr: setSponsor(address,address)51 function setSponsor(address contractAddress, address sponsor) public {52 require(false, stub_error);53 contractAddress;54 sponsor;55 dummy = 0;56 }5758 /// Set contract as self sponsored.59 ///60 /// @param contractAddress Contract for which a self sponsoring is being enabled.61 /// @dev EVM selector for this function is: 0x89f7d9ae,62 /// or in textual repr: selfSponsoredEnable(address)63 function selfSponsoredEnable(address contractAddress) public {64 require(false, stub_error);65 contractAddress;66 dummy = 0;67 }6869 /// Remove sponsor.70 ///71 /// @param contractAddress Contract for which a sponsorship is being removed.72 /// @dev EVM selector for this function is: 0xef784250,73 /// or in textual repr: removeSponsor(address)74 function removeSponsor(address contractAddress) public {75 require(false, stub_error);76 contractAddress;77 dummy = 0;78 }7980 /// Confirm sponsorship.81 ///82 /// @dev Caller must be same that set via [`setSponsor`].83 ///84 /// @param contractAddress Сontract for which need to confirm sponsorship.85 /// @dev EVM selector for this function is: 0xabc00001,86 /// or in textual repr: confirmSponsorship(address)87 function confirmSponsorship(address contractAddress) public {88 require(false, stub_error);89 contractAddress;90 dummy = 0;91 }9293 /// Get current sponsor.94 ///95 /// @param contractAddress The contract for which a sponsor is requested.96 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.97 /// @dev EVM selector for this function is: 0x766c4f37,98 /// or in textual repr: sponsor(address)99 function sponsor(address contractAddress) public view returns (OptionCrossAddress memory) {100 require(false, stub_error);101 contractAddress;102 dummy;103 return OptionCrossAddress(false, CrossAddress(0x0000000000000000000000000000000000000000, 0));104 }105106 /// Check tat contract has confirmed sponsor.107 ///108 /// @param contractAddress The contract for which the presence of a confirmed sponsor is checked.109 /// @return **true** if contract has confirmed sponsor.110 /// @dev EVM selector for this function is: 0x97418603,111 /// or in textual repr: hasSponsor(address)112 function hasSponsor(address contractAddress) public view returns (bool) {113 require(false, stub_error);114 contractAddress;115 dummy;116 return false;117 }118119 /// Check tat contract has pending sponsor.120 ///121 /// @param contractAddress The contract for which the presence of a pending sponsor is checked.122 /// @return **true** if contract has pending sponsor.123 /// @dev EVM selector for this function is: 0x39b9b242,124 /// or in textual repr: hasPendingSponsor(address)125 function hasPendingSponsor(address contractAddress) public view returns (bool) {126 require(false, stub_error);127 contractAddress;128 dummy;129 return false;130 }131132 /// @dev EVM selector for this function is: 0x6027dc61,133 /// or in textual repr: sponsoringEnabled(address)134 function sponsoringEnabled(address contractAddress) public view returns (bool) {135 require(false, stub_error);136 contractAddress;137 dummy;138 return false;139 }140141 /// @dev EVM selector for this function is: 0xfde8a560,142 /// or in textual repr: setSponsoringMode(address,uint8)143 function setSponsoringMode(address contractAddress, SponsoringModeT mode) public {144 require(false, stub_error);145 contractAddress;146 mode;147 dummy = 0;148 }149150 /// Get current contract sponsoring rate limit151 /// @param contractAddress Contract to get sponsoring rate limit of152 /// @return uint32 Amount of blocks between two sponsored transactions153 /// @dev EVM selector for this function is: 0xf29694d8,154 /// or in textual repr: sponsoringRateLimit(address)155 function sponsoringRateLimit(address contractAddress) public view returns (uint32) {156 require(false, stub_error);157 contractAddress;158 dummy;159 return 0;160 }161162 /// Set contract sponsoring rate limit163 /// @dev Sponsoring rate limit - is a minimum amount of blocks that should164 /// pass between two sponsored transactions165 /// @param contractAddress Contract to change sponsoring rate limit of166 /// @param rateLimit Target rate limit167 /// @dev Only contract owner can change this setting168 /// @dev EVM selector for this function is: 0x77b6c908,169 /// or in textual repr: setSponsoringRateLimit(address,uint32)170 function setSponsoringRateLimit(address contractAddress, uint32 rateLimit) public {171 require(false, stub_error);172 contractAddress;173 rateLimit;174 dummy = 0;175 }176177 /// Set contract sponsoring fee limit178 /// @dev Sponsoring fee limit - is maximum fee that could be spent by179 /// single transaction180 /// @param contractAddress Contract to change sponsoring fee limit of181 /// @param feeLimit Fee limit182 /// @dev Only contract owner can change this setting183 /// @dev EVM selector for this function is: 0x03aed665,184 /// or in textual repr: setSponsoringFeeLimit(address,uint256)185 function setSponsoringFeeLimit(address contractAddress, uint256 feeLimit) public {186 require(false, stub_error);187 contractAddress;188 feeLimit;189 dummy = 0;190 }191192 /// Get current contract sponsoring fee limit193 /// @param contractAddress Contract to get sponsoring fee limit of194 /// @return uint256 Maximum amount of fee that could be spent by single195 /// transaction196 /// @dev EVM selector for this function is: 0x75b73606,197 /// or in textual repr: sponsoringFeeLimit(address)198 function sponsoringFeeLimit(address contractAddress) public view returns (uint256) {199 require(false, stub_error);200 contractAddress;201 dummy;202 return 0;203 }204205 /// Is specified user present in contract allow list206 /// @dev Contract owner always implicitly included207 /// @param contractAddress Contract to check allowlist of208 /// @param user User to check209 /// @return bool Is specified users exists in contract allowlist210 /// @dev EVM selector for this function is: 0x5c658165,211 /// or in textual repr: allowed(address,address)212 function allowed(address contractAddress, address user) public view returns (bool) {213 require(false, stub_error);214 contractAddress;215 user;216 dummy;217 return false;218 }219220 /// Toggle user presence in contract allowlist221 /// @param contractAddress Contract to change allowlist of222 /// @param user Which user presence should be toggled223 /// @param isAllowed `true` if user should be allowed to be sponsored224 /// or call this contract, `false` otherwise225 /// @dev Only contract owner can change this setting226 /// @dev EVM selector for this function is: 0x4706cc1c,227 /// or in textual repr: toggleAllowed(address,address,bool)228 function toggleAllowed(229 address contractAddress,230 address user,231 bool isAllowed232 ) public {233 require(false, stub_error);234 contractAddress;235 user;236 isAllowed;237 dummy = 0;238 }239240 /// Is this contract has allowlist access enabled241 /// @dev Allowlist always can have users, and it is used for two purposes:242 /// in case of allowlist sponsoring mode, users will be sponsored if they exist in allowlist243 /// in case of allowlist access enabled, only users from allowlist may call this contract244 /// @param contractAddress Contract to get allowlist access of245 /// @return bool Is specified contract has allowlist access enabled246 /// @dev EVM selector for this function is: 0xc772ef6c,247 /// or in textual repr: allowlistEnabled(address)248 function allowlistEnabled(address contractAddress) public view returns (bool) {249 require(false, stub_error);250 contractAddress;251 dummy;252 return false;253 }254255 /// Toggle contract allowlist access256 /// @param contractAddress Contract to change allowlist access of257 /// @param enabled Should allowlist access to be enabled?258 /// @dev EVM selector for this function is: 0x36de20f5,259 /// or in textual repr: toggleAllowlist(address,bool)260 function toggleAllowlist(address contractAddress, bool enabled) public {261 require(false, stub_error);262 contractAddress;263 enabled;264 dummy = 0;265 }266}267268/// Available contract sponsoring modes269enum SponsoringModeT {270 /// Sponsoring is disabled271 Disabled,272 /// Only users from allowlist will be sponsored273 Allowlisted,274 /// All users will be sponsored275 Generous276}277278/// Cross account struct279struct CrossAddress {280 address eth;281 uint256 sub;282}283284/// Optional value285struct OptionCrossAddress {286 /// Shows the status of accessibility of value287 bool status;288 /// Actual value if `status` is true289 CrossAddress value;290}