git.delta.rocks / unique-network / refs/commits / 9836c2113849

1{1{
2	"name": "Rust",2	"name": "Rust",
3    "dockerComposeFile": "./docker-compose.yml",3    "dockerComposeFile": "./docker-compose.yml",
4    "service": "nft_private",4    "service": "unique-chain",
5    "workspaceFolder": "/workspaces/nft_private",5    "workspaceFolder": "/workspaces/unique-chain",
6	"settings": { 6	"settings": { 
7		"terminal.integrated.shell.linux": "/bin/bash",7		"terminal.integrated.shell.linux": "/bin/bash",
8		"lldb.executable": "/usr/bin/lldb",8		"lldb.executable": "/usr/bin/lldb",

1version: '3'1version: '3'
2services:2services:
3  nft_private:3  unique-chain:
4    build: 4    build: 
5        context: .5        context: .
6    environment:6    environment:
7      - JAEGER_AGENT_HOST=jaeger7      - JAEGER_AGENT_HOST=jaeger
8      - JAEGER_AGENT_PORT=68318      - JAEGER_AGENT_PORT=6831
9    volumes:9    volumes:
10      - ..:/workspaces/nft_private:cached10      - ..:/workspaces/unique-chain:cached
11      - ../../polkadot:/workspaces/polkadot:cached11      - ../../polkadot:/workspaces/polkadot:cached
12      - ../../polkadot-launch:/workspaces/polkadot-launch:cached12      - ../../polkadot-launch:/workspaces/polkadot-launch:cached
13      #- ../../frontier:/workspaces/frontier13      #- ../../frontier:/workspaces/frontier

32          key: ${{ secrets.KEY }}32          key: ${{ secrets.KEY }}
33          port: ${{ secrets.SERVER_PORT }}33          port: ${{ secrets.SERVER_PORT }}
34          command_timeout: 300m34          command_timeout: 300m
35          script: |35          script: |
36            eval $(ssh-agent -s)36            eval $(ssh-agent -s)
37            ssh-add /home/devops/.ssh/git_hub37            ssh-add /home/devops/.ssh/git_hub
38            git clone git@github.com:UniqueNetwork/nft_private.git38            git clone git@github.com:UniqueNetwork/unique-chain.git
39            cd nft_private39            cd unique-chain
40            git checkout develop40            git checkout develop
41            # git pull --all41            # git pull --all
42            chmod +x ci_node.sh42            chmod +x ci_node.sh
43            ./ci_node.sh43            ./ci_node.sh
44            rm -rf /home/polkadot/nft_private44            rm -rf /home/polkadot/unique-chain
4545

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"

98    npm install --global yarn && \98    npm install --global yarn && \
99    yarn99    yarn
100100
101COPY --from=builder /nft_parachain/target/$PROFILE/nft /nft_private/target/$PROFILE/101COPY --from=builder /nft_parachain/target/$PROFILE/nft /unique-chain/target/$PROFILE/
102COPY --from=builder-polkadot /nft_parachain/polkadot/target/$PROFILE/polkadot /polkadot/target/$PROFILE/102COPY --from=builder-polkadot /nft_parachain/polkadot/target/$PROFILE/polkadot /polkadot/target/$PROFILE/
103103
104CMD export NVM_DIR="$HOME/.nvm" && \104CMD export NVM_DIR="$HOME/.nvm" && \

3use codec::Decode;3use codec::Decode;
4use jsonrpc_core::{Error as RpcError, ErrorCode, Result};4use jsonrpc_core::{Error as RpcError, ErrorCode, Result};
5use jsonrpc_derive::rpc;5use jsonrpc_derive::rpc;
6use nft_data_structs::{CollectionId, TokenId};6use nft_data_structs::{Collection, CollectionId, CollectionStats, TokenId};
7use sp_api::{BlockId, BlockT, ProvideRuntimeApi};7use sp_api::{BlockId, BlockT, ProvideRuntimeApi};
8use sp_blockchain::HeaderBackend;8use sp_blockchain::HeaderBackend;
9use up_rpc::NftApi as NftRuntimeApi;9use up_rpc::NftApi as NftRuntimeApi;
86		collection: CollectionId,86		collection: CollectionId,
87		at: Option<BlockHash>,87		at: Option<BlockHash>,
88	) -> Result<Vec<CrossAccountId>>;88	) -> Result<Vec<CrossAccountId>>;
89	#[rpc(name = "nft_allowed")]
90	fn allowed(
91		&self,
92		collection: CollectionId,
93		user: CrossAccountId,
94		at: Option<BlockHash>,
95	) -> Result<bool>;
89	#[rpc(name = "nft_lastTokenId")]96	#[rpc(name = "nft_lastTokenId")]
90	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;97	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;
98	#[rpc(name = "nft_collectionById")]
99	fn collection_by_id(
100		&self,
101		collection: CollectionId,
102		at: Option<BlockHash>,
103	) -> Result<Option<Collection<AccountId>>>;
104	#[rpc(name = "nft_collectionStats")]
105	fn collection_stats(&self, at: Option<BlockHash>) -> Result<CollectionStats>;
91}106}
92107
93pub struct Nft<C, P> {108pub struct Nft<C, P> {
160175
161	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>);176	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>);
162	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>);177	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>);
178	pass_method!(allowed(collection: CollectionId, user: CrossAccountId) -> bool);
163	pass_method!(last_token_id(collection: CollectionId) -> TokenId);179	pass_method!(last_token_id(collection: CollectionId) -> TokenId);
180	pass_method!(collection_by_id(collection: CollectionId) -> Option<Collection<AccountId>>);
181	pass_method!(collection_stats() -> CollectionStats);
164}182}
165183

55    },55    },
56    "parachains": [56    "parachains": [
57        {57        {
58            "bin": "../nft_private/target/release/nft",58            "bin": "../unique-chain/target/release/nft",
59            "id": "2000",59            "id": "2000",
60            "balance": "1000000000000000000000",60            "balance": "1000000000000000000000",
61            "nodes": [61            "nodes": [

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

19pub fn create_collection_raw<T: Config, R>(19pub fn create_collection_raw<T: Config, R>(
20	owner: T::AccountId,20	owner: T::AccountId,
21	mode: CollectionMode,21	mode: CollectionMode,
22	handler: impl FnOnce(Collection<T>) -> Result<CollectionId, DispatchError>,22	handler: impl FnOnce(Collection<T::AccountId>) -> Result<CollectionId, DispatchError>,
23	cast: impl FnOnce(CollectionHandle<T>) -> R,23	cast: impl FnOnce(CollectionHandle<T>) -> R,
24) -> Result<R, DispatchError> {24) -> Result<R, DispatchError> {
25	T::Currency::deposit_creating(&owner, T::CollectionCreationPrice::get());25	T::Currency::deposit_creating(&owner, T::CollectionCreationPrice::get());

12	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, ExistenceRequirement,12	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, ExistenceRequirement,
13	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH,13	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
14	COLLECTION_ADMINS_LIMIT, MetaUpdatePermission, Pays, PostDispatchInfo, TokenId, Weight,14	COLLECTION_ADMINS_LIMIT, MetaUpdatePermission, Pays, PostDispatchInfo, TokenId, Weight,
15	WithdrawReasons,15	WithdrawReasons, CollectionStats,
16};16};
17pub use pallet::*;17pub use pallet::*;
18use sp_core::H160;18use sp_core::H160;
26#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]26#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]
27pub struct CollectionHandle<T: Config> {27pub struct CollectionHandle<T: Config> {
28	pub id: CollectionId,28	pub id: CollectionId,
29	collection: Collection<T>,29	collection: Collection<T::AccountId>,
30	pub recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,30	pub recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,
31}31}
32impl<T: Config> CollectionHandle<T> {32impl<T: Config> CollectionHandle<T> {
78	}78	}
79}79}
80impl<T: Config> Deref for CollectionHandle<T> {80impl<T: Config> Deref for CollectionHandle<T> {
81	type Target = Collection<T>;81	type Target = Collection<T::AccountId>;
8282
83	fn deref(&self) -> &Self::Target {83	fn deref(&self) -> &Self::Target {
84		&self.collection84		&self.collection
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<
311	pub type CollectionById<T> = StorageMap<311	pub type CollectionById<T> = StorageMap<
312		Hasher = Blake2_128Concat,312		Hasher = Blake2_128Concat,
313		Key = CollectionId,313		Key = CollectionId,
314		Value = Collection<T>,314		Value = Collection<<T as frame_system::Config>::AccountId>,
315		QueryKind = OptionQuery,315		QueryKind = OptionQuery,
316	>;316	>;
317317
345		QueryKind = ValueQuery,345		QueryKind = ValueQuery,
346	>;346	>;
347
348	/// Not used by code, exists only to provide some types to metadata
349	#[pallet::storage]
350	pub type DummyStorageValue<T> =
351		StorageValue<Value = (CollectionStats, CollectionId, TokenId), QueryKind = OptionQuery>;
347}352}
348353
349impl<T: Config> Pallet<T> {354impl<T: Config> Pallet<T> {
355		);360		);
356		Ok(())361		Ok(())
357	}362	}
363	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {
364		<IsAdmin<T>>::iter_prefix((collection,))
365			.map(|(a, _)| a)
366			.collect()
367	}
368	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {
369		<Allowlist<T>>::iter_prefix((collection,))
370			.map(|(a, _)| a)
371			.collect()
372	}
373	pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {
374		<Allowlist<T>>::get((collection, user))
375	}
376	pub fn collection_stats() -> CollectionStats {
377		let created = <CreatedCollectionCount<T>>::get();
378		let destroyed = <DestroyedCollectionCount<T>>::get();
379		CollectionStats {
380			created: created.0,
381			destroyed: destroyed.0,
382			alive: created.0 - destroyed.0,
383		}
384	}
358}385}
359386
360impl<T: Config> Pallet<T> {387impl<T: Config> Pallet<T> {
361	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {388	pub fn init_collection(data: Collection<T::AccountId>) -> Result<CollectionId, DispatchError> {
362		{389		{
363			ensure!(390			ensure!(
364				data.name.len() <= MAX_COLLECTION_NAME_LENGTH,391				data.name.len() <= MAX_COLLECTION_NAME_LENGTH,

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

52		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u128, QueryKind = ValueQuery>;52		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u128, QueryKind = ValueQuery>;
5353
54	#[pallet::storage]54	#[pallet::storage]
55	pub(super) type Balance<T: Config> = StorageNMap<55	pub type Balance<T: Config> = StorageNMap<
56		Key = (56		Key = (
57			Key<Twox64Concat, CollectionId>,57			Key<Twox64Concat, CollectionId>,
58			Key<Blake2_128Concat, T::CrossAccountId>,58			Key<Blake2_128Concat, T::CrossAccountId>,
91}91}
9292
93impl<T: Config> Pallet<T> {93impl<T: Config> Pallet<T> {
94	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {94	pub fn init_collection(data: Collection<T::AccountId>) -> Result<CollectionId, DispatchError> {
95		PalletCommon::init_collection(data)95		<PalletCommon<T>>::init_collection(data)
96	}96	}
97	pub fn destroy_collection(97	pub fn destroy_collection(
98		collection: FungibleHandle<T>,98		collection: FungibleHandle<T>,