git.delta.rocks / unique-network / refs/commits / 23a018e7c903

5097 "frame-system-rpc-runtime-api",5097 "frame-system-rpc-runtime-api",
5098 "hex-literal",5098 "hex-literal",
5099 "nft-data-structs",5099 "nft-data-structs",
5100 "orml-vesting",
5100 "pallet-aura",5101 "pallet-aura",
5101 "pallet-balances",5102 "pallet-balances",
5102 "pallet-common",5103 "pallet-common",
5109 "pallet-fungible",5110 "pallet-fungible",
5110 "pallet-inflation",5111 "pallet-inflation",
5111 "pallet-nft",5112 "pallet-nft",
5112 "pallet-nft-transaction-payment",
5113 "pallet-nonfungible",5113 "pallet-nonfungible",
5114 "pallet-randomness-collective-flip",5114 "pallet-randomness-collective-flip",
5115 "pallet-refungible",5115 "pallet-refungible",
5120 "pallet-transaction-payment-rpc-runtime-api",5120 "pallet-transaction-payment-rpc-runtime-api",
5121 "pallet-treasury",5121 "pallet-treasury",
5122 "pallet-unq-scheduler",5122 "pallet-unq-scheduler",
5123 "pallet-vesting",
5124 "pallet-xcm",5123 "pallet-xcm",
5125 "parachain-info",5124 "parachain-info",
5126 "parity-scale-codec",5125 "parity-scale-codec",
5142 "sp-transaction-pool",5141 "sp-transaction-pool",
5143 "sp-version",5142 "sp-version",
5144 "substrate-wasm-builder",5143 "substrate-wasm-builder",
5144 "up-evm-mapping",
5145 "up-rpc",5145 "up-rpc",
5146 "xcm",5146 "xcm",
5147 "xcm-builder",5147 "xcm-builder",
5307 "num-traits",5307 "num-traits",
5308]5308]
5309
5310[[package]]
5311name = "orml-vesting"
5312version = "0.4.1-dev"
5313source = "git+https://github.com/UniqueNetwork/open-runtime-module-library#d69f226e332ae29b7b33d53d2f06f309d2986ea0"
5314dependencies = [
5315 "frame-support",
5316 "frame-system",
5317 "parity-scale-codec",
5318 "scale-info",
5319 "serde",
5320 "sp-io",
5321 "sp-runtime",
5322 "sp-std",
5323]
53095324
5310[[package]]5325[[package]]
5311name = "owning_ref"5326name = "owning_ref"
5575 "sp-core",5590 "sp-core",
5576 "sp-runtime",5591 "sp-runtime",
5577 "sp-std",5592 "sp-std",
5593 "up-evm-mapping",
5578]5594]
55795595
5580[[package]]5596[[package]]
5824 "sp-io",5840 "sp-io",
5825 "sp-runtime",5841 "sp-runtime",
5826 "sp-std",5842 "sp-std",
5843 "up-evm-mapping",
5827 "up-sponsorship",5844 "up-sponsorship",
5828]5845]
58295846
6072 "sp-io",6089 "sp-io",
6073 "sp-runtime",6090 "sp-runtime",
6074 "sp-std",6091 "sp-std",
6092 "up-evm-mapping",
6075 "up-sponsorship",6093 "up-sponsorship",
6076]6094]
6077
6078[[package]]
6079name = "pallet-nft-transaction-payment"
6080version = "3.0.0"
6081dependencies = [
6082 "frame-benchmarking",
6083 "frame-support",
6084 "frame-system",
6085 "pallet-transaction-payment",
6086 "parity-scale-codec",
6087 "scale-info",
6088 "serde",
6089 "sp-core",
6090 "sp-io",
6091 "sp-runtime",
6092 "sp-std",
6093 "up-sponsorship",
6094]
60956095
6096[[package]]6096[[package]]
6097name = "pallet-nicks"6097name = "pallet-nicks"
11831source = "registry+https://github.com/rust-lang/crates.io-index"11831source = "registry+https://github.com/rust-lang/crates.io-index"
11832checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"11832checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
11833
11834[[package]]
11835name = "up-evm-mapping"
11836version = "0.1.0"
11837dependencies = [
11838 "frame-support",
11839 "sp-core",
11840]
1183311841
11834[[package]]11842[[package]]
11835name = "up-rpc"11843name = "up-rpc"

9                "rpcPort": 9843,9                "rpcPort": 9843,
10                "port": 30444,10                "port": 30444,
11                "flags": [11                "flags": [
12                    "--rpc-port=9843",
13                    "-lparachain::candidate_validation=debug"12                    "-lparachain::candidate_validation=debug"
14                ]13                ]
15            },14            },
19                "rpcPort": 9854,18                "rpcPort": 9854,
20                "port": 30555,19                "port": 30555,
21                "flags": [20                "flags": [
22                    "--rpc-port=9854",
23                    "-lparachain::candidate_validation=debug"21                    "-lparachain::candidate_validation=debug"
24                ]22                ]
25            },23            },
29                "rpcPort": 9865,27                "rpcPort": 9865,
30                "port": 30666,28                "port": 30666,
31                "flags": [29                "flags": [
32                    "--rpc-port=9865",
33                    "-lparachain::candidate_validation=debug"30                    "-lparachain::candidate_validation=debug"
34                ]31                ]
35            },32            },
39                "rpcPort": 9876,36                "rpcPort": 9876,
40                "port": 30777,37                "port": 30777,
41                "flags": [38                "flags": [
42                    "--rpc-port=9876",
43                    "-lparachain::candidate_validation=debug"39                    "-lparachain::candidate_validation=debug"
44                ]40                ]
45            }41            }
70                    "name": "alice",66                    "name": "alice",
71                    "flags": [67                    "flags": [
72                        "--rpc-cors=all",68                        "--rpc-cors=all",
73                        "--rpc-port=9933",
74                        "--unsafe-rpc-external",69                        "--unsafe-rpc-external",
75                        "--unsafe-ws-external"70                        "--unsafe-ws-external"
76                    ]71                    ]
82                    "name": "bob",77                    "name": "bob",
83                    "flags": [78                    "flags": [
84                        "--rpc-cors=all",79                        "--rpc-cors=all",
85                        "--rpc-port=9934",
86                        "--unsafe-rpc-external",80                        "--unsafe-rpc-external",
87                        "--unsafe-ws-external"81                        "--unsafe-ws-external"
88                    ]82                    ]

15sp-runtime = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }15sp-runtime = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
16sp-std = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }16sp-std = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
17sp-core = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }17sp-core = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
18up-evm-mapping = { default-features = false, path = '../../primitives/evm-mapping' }
18nft-data-structs = { default-features = false, path = '../../primitives/nft' }19nft-data-structs = { default-features = false, path = '../../primitives/nft' }
19pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }20pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }
20evm-coder = { default-features = false, path = '../../crates/evm-coder' }21evm-coder = { default-features = false, path = '../../crates/evm-coder' }
32    "frame-system/std",32    "frame-system/std",
33    "sp-runtime/std",33    "sp-runtime/std",
34    "sp-std/std",34    "sp-std/std",
35    "up-evm-mapping/std",
35    "nft-data-structs/std",36    "nft-data-structs/std",
36    "pallet-evm/std",37    "pallet-evm/std",
37]38]

2use codec::{Encode, EncodeLike, Decode};2use codec::{Encode, EncodeLike, Decode};
3use sp_core::H160;3use sp_core::H160;
4use scale_info::{Type, TypeInfo};4use scale_info::{Type, TypeInfo};
5use sp_core::crypto::AccountId32;
6use core::cmp::Ordering;5use core::cmp::Ordering;
7use serde::{Serialize, Deserialize};6use serde::{Serialize, Deserialize};
8use pallet_evm::AddressMapping;7use pallet_evm::AddressMapping;
9use sp_std::vec::Vec;8use sp_std::vec::Vec;
10use sp_std::clone::Clone;9use sp_std::clone::Clone;
10use up_evm_mapping::EvmBackwardsAddressMapping;
1111
12pub trait CrossAccountId<AccountId>:12pub trait CrossAccountId<AccountId>:
13	Encode + EncodeLike + Decode + TypeInfo + Clone + PartialEq + Ord + core::fmt::Debug + Default13	Encode + EncodeLike + Decode + TypeInfo + Clone + PartialEq + Ord + core::fmt::Debug + Default
177	}177	}
178}178}
179
180pub trait EvmBackwardsAddressMapping<AccountId> {
181	fn from_account_id(account_id: AccountId) -> H160;
182}
183
184/// Should have same mapping as EnsureAddressTruncated
185pub struct MapBackwardsAddressTruncated;
186impl EvmBackwardsAddressMapping<AccountId32> for MapBackwardsAddressTruncated {
187	fn from_account_id(account_id: AccountId32) -> H160 {
188		let mut out = [0; 20];
189		out.copy_from_slice(&(account_id.as_ref() as &[u8])[0..20]);
190		H160(out)
191	}
192}
193179

141pub mod pallet {141pub mod pallet {
142	use super::*;142	use super::*;
143	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key};143	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key};
144	use account::{EvmBackwardsAddressMapping, CrossAccountId};144	use account::CrossAccountId;
145	use frame_support::traits::Currency;145	use frame_support::traits::Currency;
146	use nft_data_structs::TokenId;146	use nft_data_structs::TokenId;
147	use scale_info::TypeInfo;147	use scale_info::TypeInfo;
153		type CrossAccountId: CrossAccountId<Self::AccountId>;153		type CrossAccountId: CrossAccountId<Self::AccountId>;
154154
155		type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;155		type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;
156		type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;156		type EvmBackwardsAddressMapping: up_evm_mapping::EvmBackwardsAddressMapping<Self::AccountId>;
157157
158		type Currency: Currency<Self::AccountId>;158		type Currency: Currency<Self::AccountId>;
159		type CollectionCreationPrice: Get<159		type CollectionCreationPrice: Get<

5959
60	fn allowed(&self, contract_address: address, user: address) -> Result<bool> {60	fn allowed(&self, contract_address: address, user: address) -> Result<bool> {
61		self.0.consume_sload()?;61		self.0.consume_sload()?;
62		Ok(<Pallet<T>>::allowed(contract_address, user, true))62		Ok(<Pallet<T>>::allowed(contract_address, user)
63			|| !<AllowlistEnabled<T>>::get(contract_address))
63	}64	}
6465
65	fn allowlist_enabled(&self, contract_address: address) -> Result<bool> {66	fn allowlist_enabled(&self, contract_address: address) -> Result<bool> {
113		value: sp_core::U256,114		value: sp_core::U256,
114	) -> Option<PrecompileOutput> {115	) -> Option<PrecompileOutput> {
115		// TODO: Extract to another OnMethodCall handler116		// TODO: Extract to another OnMethodCall handler
116		if !<Pallet<T>>::allowed(*target, *source, true) {117		if <AllowlistEnabled<T>>::get(target) && !<Pallet<T>>::allowed(*target, *source) {
117			return Some(PrecompileOutput {118			return Some(PrecompileOutput {
118				exit_status: ExitReason::Revert(ExitRevert::Reverted),119				exit_status: ExitReason::Revert(ExitRevert::Reverted),
119				cost: 0,120				cost: 0,
151pub struct HelpersContractSponsoring<T: Config>(PhantomData<*const T>);152pub struct HelpersContractSponsoring<T: Config>(PhantomData<*const T>);
152impl<T: Config> SponsorshipHandler<H160, (H160, Vec<u8>)> for HelpersContractSponsoring<T> {153impl<T: Config> SponsorshipHandler<H160, (H160, Vec<u8>)> for HelpersContractSponsoring<T> {
153	fn get_sponsor(who: &H160, call: &(H160, Vec<u8>)) -> Option<H160> {154	fn get_sponsor(who: &H160, call: &(H160, Vec<u8>)) -> Option<H160> {
154		if <SelfSponsoring<T>>::get(&call.0) && <Pallet<T>>::allowed(call.0, *who, false) {155		if !<SelfSponsoring<T>>::get(&call.0) {
156			return None;
157		}
158		if !<Pallet<T>>::allowed(call.0, *who) {
159			return None;
160		}
155			let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;161		let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;
162
156			if let Some(last_tx_block) = <SponsorBasket<T>>::get(&call.0, who) {163		if let Some(last_tx_block) = <SponsorBasket<T>>::get(&call.0, who) {
157				let rate_limit = <SponsoringRateLimit<T>>::get(&call.0);164			let limit = <SponsoringRateLimit<T>>::get(&call.0);
165
158				let limit_time = last_tx_block + rate_limit;166			let timeout = last_tx_block + limit.into();
159167			if block_number < timeout {
160				if block_number > limit_time {168				return None;
161					<SponsorBasket<T>>::insert(&call.0, who, block_number);169			}
162					return Some(call.0);
163				}
164			} else {170		}
171
165				<SponsorBasket<T>>::insert(&call.0, who, block_number);172		<SponsorBasket<T>>::insert(&call.0, who, block_number);
173
166				return Some(call.0);174		Some(call.0)
167			}
168		}
169		None
170	}175	}
171}176}
172177

76			<SponsoringRateLimit<T>>::insert(contract, rate_limit);76			<SponsoringRateLimit<T>>::insert(contract, rate_limit);
77		}77		}
7878
79		/// Default is returned if allowlist is disabled
80		pub fn allowed(contract: H160, user: H160, default: bool) -> bool {79		pub fn allowed(contract: H160, user: H160) -> bool {
81			if !<AllowlistEnabled<T>>::get(contract) {
82				return default;
83			}
84			<Allowlist<T>>::get(&contract, &user) || <Owner<T>>::get(&contract) == user80			<Allowlist<T>>::get(&contract, &user) || <Owner<T>>::get(&contract) == user
85		}81		}
8682

15fp-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }15fp-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }
16pallet-ethereum = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }16pallet-ethereum = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }
17up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring" } 17up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring" } 
18up-evm-mapping = { default-features = false, path = "../../primitives/evm-mapping" }
1819
19[dependencies.codec]20[dependencies.codec]
20default-features = false21default-features = false
35    "pallet-ethereum/std",36    "pallet-ethereum/std",
36    "fp-evm/std",37    "fp-evm/std",
37    "up-sponsorship/std",38    "up-sponsorship/std",
39    "up-evm-mapping/std",
38]40]
3941

1#![cfg_attr(not(feature = "std"), no_std)]1#![cfg_attr(not(feature = "std"), no_std)]
22
3pub use pallet::*;
4
5#[frame_support::pallet]
6pub mod pallet {
7	use core::marker::PhantomData;3use core::marker::PhantomData;
4use fp_evm::WithdrawReason;
8	use frame_support::traits::Currency;5use frame_support::traits::{Currency, IsSubType};
9	use pallet_evm::EVMCurrencyAdapter;6pub use pallet::*;
10	use fp_evm::WithdrawReason;7use pallet_evm::{EVMCurrencyAdapter, EnsureAddressOrigin};
11	use sp_core::{H160, U256};8use sp_core::{H160, U256};
12	use sp_runtime::TransactionOutcome;9use sp_runtime::TransactionOutcome;
13	use up_sponsorship::SponsorshipHandler;10use up_sponsorship::SponsorshipHandler;
11use up_evm_mapping::EvmBackwardsAddressMapping;
12use pallet_evm::AddressMapping;
13
14#[frame_support::pallet]
15pub mod pallet {
16	use super::*;
17
14	use sp_std::vec::Vec;18	use frame_support::traits::Currency;
15
16	type NegativeImbalanceOf<C, T> =
17		<C as Currency<<T as frame_system::Config>::AccountId>>::NegativeImbalance;19	use sp_std::vec::Vec;
1820
19	#[pallet::config]21	#[pallet::config]
20	pub trait Config: frame_system::Config {22	pub trait Config: frame_system::Config {
21		type SponsorshipHandler: SponsorshipHandler<H160, (H160, Vec<u8>)>;23		type EvmSponsorshipHandler: SponsorshipHandler<H160, (H160, Vec<u8>)>;
22		type Currency: Currency<Self::AccountId>;24		type Currency: Currency<Self::AccountId>;
25		type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;
26		type EvmAddressMapping: AddressMapping<Self::AccountId>;
23	}27	}
2428
25	#[pallet::pallet]29	#[pallet::pallet]
26	#[pallet::generate_store(pub(super) trait Store)]30	#[pallet::generate_store(pub(super) trait Store)]
27	pub struct Pallet<T>(_);31	pub struct Pallet<T>(_);
32}
33
34type NegativeImbalanceOf<C, T> =
35	<C as Currency<<T as frame_system::Config>::AccountId>>::NegativeImbalance;
2836
29	pub struct ChargeEvmLiquidityInfo<T>37pub struct ChargeEvmLiquidityInfo<T>
30	where38where
42				WithdrawReason::Call { target, input } => {50			WithdrawReason::Call { target, input } => {
43					// This method is only used for checking, we shouldn't touch storage in it51				// This method is only used for checking, we shouldn't touch storage in it
44					frame_support::storage::with_transaction(|| {52				frame_support::storage::with_transaction(|| {
45						TransactionOutcome::Rollback(T::SponsorshipHandler::get_sponsor(53					TransactionOutcome::Rollback(T::EvmSponsorshipHandler::get_sponsor(
46							&origin,54						&origin,
47							&(*target, input.clone()),55						&(*target, input.clone()),
48						))56					))
68		) -> core::result::Result<Self::LiquidityInfo, pallet_evm::Error<T>> {75	) -> core::result::Result<Self::LiquidityInfo, pallet_evm::Error<T>> {
69			let mut who_pays_fee = *who;76		let mut who_pays_fee = *who;
70			if let WithdrawReason::Call { target, input } = &reason {77		if let WithdrawReason::Call { target, input } = &reason {
71				who_pays_fee = T::SponsorshipHandler::get_sponsor(who, &(*target, input.clone()))78			who_pays_fee = T::EvmSponsorshipHandler::get_sponsor(who, &(*target, input.clone()))
72					.unwrap_or(who_pays_fee);79				.unwrap_or(who_pays_fee);
73			}80		}
74			let negative_imbalance =81		let negative_imbalance = EVMCurrencyAdapter::<<T as Config>::Currency, ()>::withdraw_fee(
95			)101		)
96		}102	}
97	}103}
98}104
105/// Implements sponsoring for evm calls performed from pallet-evm (via api.tx.ethereum.transact/api.tx.evm.call)
106pub struct BridgeSponsorshipHandler<T>(PhantomData<T>);
107impl<T, C> SponsorshipHandler<T::AccountId, C> for BridgeSponsorshipHandler<T>
108where
109	T: Config + pallet_evm::Config,
110	C: IsSubType<pallet_evm::Call<T>>,
111{
112	fn get_sponsor(who: &T::AccountId, call: &C) -> Option<T::AccountId> {
113		match call.is_sub_type()? {
114			pallet_evm::Call::call {
115				source,
116				target,
117				input,
118				..
119			} => {
120				let _ = T::CallOrigin::ensure_address_origin(
121					source,
122					<frame_system::RawOrigin<T::AccountId>>::Signed(who.clone()).into(),
123				)
124				.ok()?;
125				let who = T::EvmBackwardsAddressMapping::from_account_id(who.clone());
126				// Effects from EvmSponsorshipHandler are applied in OnChargeEvmTransaction by pallet_evm::runner
127				// TODO: Should we implement simulation mode (test, but do not apply effects) in `up-sponsorship`?
128				let sponsor = frame_support::storage::with_transaction(|| {
129					TransactionOutcome::Rollback(T::EvmSponsorshipHandler::get_sponsor(
130						&who,
131						&(target.clone(), input.clone()),
132					))
133				})?;
134				let sponsor = T::EvmAddressMapping::into_account_id(sponsor);
135				Some(sponsor)
136			}
137			_ => None,
138		}
139	}
140}
99141

34    'fp-evm/std',34    'fp-evm/std',
35    'nft-data-structs/std',35    'nft-data-structs/std',
36    'up-sponsorship/std',36    'up-sponsorship/std',
37    'up-evm-mapping/std',
37    'sp-std/std',38    'sp-std/std',
38    'sp-api/std',39    'sp-api/std',
39    'sp-runtime/std',40    'sp-runtime/std',
135sp-api = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.12" }136sp-api = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.12" }
136137
137up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring" } 138up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring" } 
138139up-evm-mapping = { default-features = false, path = "../../primitives/evm-mapping" }
139evm-coder = { default-features = false, path = "../../crates/evm-coder" }140evm-coder = { default-features = false, path = "../../crates/evm-coder" }
140pallet-evm-coder-substrate = { default-features = false, path = "../../pallets/evm-coder-substrate" }141pallet-evm-coder-substrate = { default-features = false, path = "../../pallets/evm-coder-substrate" }
141primitive-types = { version = "0.10.1", default-features = false, features = [142primitive-types = { version = "0.10.1", default-features = false, features = [

1//! Implements EVM sponsoring logic via OnChargeEVMTransaction1//! Implements EVM sponsoring logic via OnChargeEVMTransaction
22
3use crate::{Collection, Config, FungibleTransferBasket, NftTransferBasket};3use crate::{Config, sponsorship::*};
4use evm_coder::{Call, abi::AbiReader};4use evm_coder::{Call, abi::AbiReader};
5use frame_support::{
6	storage::{StorageDoubleMap},
7};
8use pallet_common::eth::map_eth_to_id;5use pallet_common::{CollectionHandle, eth::map_eth_to_id};
9use sp_core::H160;6use sp_core::H160;
10use sp_std::prelude::*;7use sp_std::prelude::*;
11use up_sponsorship::SponsorshipHandler;8use up_sponsorship::SponsorshipHandler;
12use core::marker::PhantomData;9use core::marker::PhantomData;
13use core::convert::TryInto;10use core::convert::TryInto;
14use nft_data_structs::{CollectionId, NFT_SPONSOR_TRANSFER_TIMEOUT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT};11use nft_data_structs::TokenId;
15use pallet_common::{12use up_evm_mapping::EvmBackwardsAddressMapping;
16	CollectionById,13use pallet_evm::AddressMapping;
17	account::{CrossAccountId, EvmBackwardsAddressMapping},
18};
1914
20use pallet_nonfungible::erc::{UniqueNFTCall, ERC721UniqueExtensionsCall, ERC721Call};15use pallet_nonfungible::erc::{UniqueNFTCall, ERC721UniqueExtensionsCall, ERC721Call};
21use pallet_fungible::erc::{UniqueFungibleCall, ERC20Call};16use pallet_fungible::erc::{UniqueFungibleCall, ERC20Call};
22
23struct AnyError;
24
25fn try_sponsor<T: Config>(
26	caller: &H160,
27	collection_id: CollectionId,
28	collection: &Collection<T::AccountId>,
29	call: &[u8],
30) -> Result<(), AnyError> {
31	let (method_id, mut reader) = AbiReader::new_call(call).map_err(|_| AnyError)?;
32	match &collection.mode {
33		crate::CollectionMode::NFT => {
34			let call: UniqueNFTCall = UniqueNFTCall::parse(method_id, &mut reader)
35				.map_err(|_| AnyError)?
36				.ok_or(AnyError)?;
37			match call {
38				UniqueNFTCall::ERC721UniqueExtensions(ERC721UniqueExtensionsCall::Transfer {
39					token_id,
40					..
41				})
42				| UniqueNFTCall::ERC721(ERC721Call::TransferFrom { token_id, .. }) => {
43					let token_id: u32 = token_id.try_into().map_err(|_| AnyError)?;
44					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;
45					let collection_limits = &collection.limits;
46					let limit =
47						collection_limits.sponsor_transfer_timeout(NFT_SPONSOR_TRANSFER_TIMEOUT);
48
49					let mut sponsor = true;
50					if <NftTransferBasket<T>>::contains_key(collection_id, token_id) {
51						let last_tx_block = <NftTransferBasket<T>>::get(collection_id, token_id);
52						let limit_time = last_tx_block + limit.into();
53						if block_number <= limit_time {
54							sponsor = false;
55						}
56					}
57					if sponsor {
58						<NftTransferBasket<T>>::insert(collection_id, token_id, block_number);
59						return Ok(());
60					}
61				}
62				_ => {}
63			}
64		}
65		crate::CollectionMode::Fungible(_) => {
66			let call: UniqueFungibleCall = UniqueFungibleCall::parse(method_id, &mut reader)
67				.map_err(|_| AnyError)?
68				.ok_or(AnyError)?;
69			#[allow(clippy::single_match)]
70			match call {
71				UniqueFungibleCall::ERC20(ERC20Call::Transfer { .. }) => {
72					let who = T::CrossAccountId::from_eth(*caller);
73					let collection_limits = &collection.limits;
74					let limit = collection_limits
75						.sponsor_transfer_timeout(FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT);
76
77					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;
78					let mut sponsored = true;
79					if <FungibleTransferBasket<T>>::contains_key(collection_id, who.as_sub()) {
80						let last_tx_block =
81							<FungibleTransferBasket<T>>::get(collection_id, who.as_sub());
82						let limit_time = last_tx_block + limit.into();
83						if block_number <= limit_time {
84							sponsored = false;
85						}
86					}
87					if sponsored {
88						<FungibleTransferBasket<T>>::insert(
89							collection_id,
90							who.as_sub(),
91							block_number,
92						);
93						return Ok(());
94					}
95				}
96				_ => {}
97			}
98		}
99		_ => {}
100	}
101	Err(AnyError)
102}
10317
104pub struct NftEthSponsorshipHandler<T: Config>(PhantomData<*const T>);18pub struct NftEthSponsorshipHandler<T: Config>(PhantomData<*const T>);
105impl<T: Config> SponsorshipHandler<H160, (H160, Vec<u8>)> for NftEthSponsorshipHandler<T> {19impl<T: Config> SponsorshipHandler<H160, (H160, Vec<u8>)> for NftEthSponsorshipHandler<T> {
106	fn get_sponsor(who: &H160, call: &(H160, Vec<u8>)) -> Option<H160> {20	fn get_sponsor(who: &H160, call: &(H160, Vec<u8>)) -> Option<H160> {
107		if let Some(collection_id) = map_eth_to_id(&call.0) {21		let collection_id = map_eth_to_id(&call.0)?;
108			if let Some(collection) = <CollectionById<T>>::get(collection_id) {22		let collection = <CollectionHandle<T>>::new(collection_id)?;
109				if !collection.sponsorship.confirmed() {23		let sponsor = collection.sponsorship.sponsor()?.clone();
110					return None;24		let sponsor =
111				}25			<T as pallet_common::Config>::EvmBackwardsAddressMapping::from_account_id(sponsor);
26		let who = <T as pallet_common::Config>::EvmAddressMapping::into_account_id(*who);
27		let (method_id, mut reader) = AbiReader::new_call(&call.1).ok()?;
28		match &collection.mode {
29			crate::CollectionMode::NFT => {
30				let call = UniqueNFTCall::parse(method_id, &mut reader).ok()??;
31				match call {
32					UniqueNFTCall::ERC721UniqueExtensions(
33						ERC721UniqueExtensionsCall::Transfer { token_id, .. },
34					)
35					| UniqueNFTCall::ERC721(ERC721Call::TransferFrom { token_id, .. }) => {
36						let token_id: TokenId = token_id.try_into().ok()?;
112				if try_sponsor::<T>(who, collection_id, &collection, &call.1).is_ok() {37						withdraw_transfer::<T>(&collection, &who, &token_id).map(|()| sponsor)
113					return collection38					}
114						.sponsorship39					UniqueNFTCall::ERC721(ERC721Call::Approve { token_id, .. }) => {
115						.sponsor()40						let token_id: TokenId = token_id.try_into().ok()?;
116						.cloned()41						withdraw_approve::<T>(&collection, &who, &token_id).map(|()| sponsor)
117						.map(T::EvmBackwardsAddressMapping::from_account_id);42					}
118				}43					_ => None,
119			}44				}
120		}45			}
46			crate::CollectionMode::Fungible(_) => {
47				let call = UniqueFungibleCall::parse(method_id, &mut reader).ok()??;
48				#[allow(clippy::single_match)]
49				match call {
50					UniqueFungibleCall::ERC20(
51						ERC20Call::Transfer { .. } | ERC20Call::TransferFrom { .. },
52					) => withdraw_transfer::<T>(&collection, &who, &TokenId::default())
53						.map(|()| sponsor),
54					UniqueFungibleCall::ERC20(ERC20Call::Approve { .. }) => {
55						withdraw_approve::<T>(&collection, &who, &TokenId::default())
56							.map(|()| sponsor)
57					}
58					_ => None,
59				}
60			}
121		None61			_ => None,
62		}
122	}63	}
123}64}
12465