git.delta.rocks / unique-network / refs/commits / 8cbbfc657245

4290version = "1.4.0"4290version = "1.4.0"
4291source = "registry+https://github.com/rust-lang/crates.io-index"4291source = "registry+https://github.com/rust-lang/crates.io-index"
4292checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"4292checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
4293dependencies = [
4294 "spin",
4295]
42934296
4294[[package]]4297[[package]]
4295name = "lazycell"4298name = "lazycell"
54675470
5468[[package]]5471[[package]]
5469name = "once_cell"5472name = "once_cell"
5470version = "1.11.0"5473version = "1.12.0"
5471source = "registry+https://github.com/rust-lang/crates.io-index"5474source = "registry+https://github.com/rust-lang/crates.io-index"
5472checksum = "7b10983b38c53aebdf33f542c6275b0f58a238129d00c4ae0e6fb59738d783ca"5475checksum = "7709cef83f0c1f58f666e746a08b21e0085f7440fa6a29cc194d68aac97a4225"
54735476
5474[[package]]5477[[package]]
5475name = "opal-runtime"5478name = "opal-runtime"
5917 "frame-benchmarking",5920 "frame-benchmarking",
5918 "frame-support",5921 "frame-support",
5919 "frame-system",5922 "frame-system",
5923 "lazy_static",
5920 "pallet-evm",5924 "pallet-evm",
5921 "pallet-evm-coder-substrate",5925 "pallet-evm-coder-substrate",
5922 "parity-scale-codec 3.1.2",5926 "parity-scale-codec 3.1.2",
6083 "frame-support",6087 "frame-support",
6084 "frame-system",6088 "frame-system",
6085 "log",6089 "log",
6090 "pallet-common",
6086 "pallet-evm",6091 "pallet-evm",
6087 "pallet-evm-coder-substrate",6092 "pallet-evm-coder-substrate",
6088 "parity-scale-codec 3.1.2",6093 "parity-scale-codec 3.1.2",
6089 "scale-info",6094 "scale-info",
6090 "sp-core",6095 "sp-core",
6091 "sp-runtime",6096 "sp-runtime",
6092 "sp-std",6097 "sp-std",
6098 "up-data-structs",
6093 "up-sponsorship",6099 "up-sponsorship",
6094]6100]
60956101
6814name = "pallet-unique"6820name = "pallet-unique"
6815version = "0.1.0"6821version = "0.1.0"
6816dependencies = [6822dependencies = [
6823 "ethereum",
6824 "evm-coder",
6817 "frame-benchmarking",6825 "frame-benchmarking",
6818 "frame-support",6826 "frame-support",
6819 "frame-system",6827 "frame-system",
6820 "pallet-common",6828 "pallet-common",
6821 "pallet-evm",6829 "pallet-evm",
6830 "pallet-evm-coder-substrate",
6831 "pallet-nonfungible",
6822 "parity-scale-codec 3.1.2",6832 "parity-scale-codec 3.1.2",
6823 "scale-info",6833 "scale-info",
6834 "serde",
6824 "sp-core",6835 "sp-core",
6825 "sp-io",6836 "sp-io",
6826 "sp-runtime",6837 "sp-runtime",
1200512016
12006[[package]]12017[[package]]
12007name = "target-lexicon"12018name = "target-lexicon"
12008version = "0.12.3"12019version = "0.12.4"
12009source = "registry+https://github.com/rust-lang/crates.io-index"12020source = "registry+https://github.com/rust-lang/crates.io-index"
12010checksum = "d7fa7e55043acb85fca6b3c01485a2eeb6b69c5d21002e273c79e465f43b7ac1"12021checksum = "c02424087780c9b71cc96799eaeddff35af2bc513278cda5c99fc1f5d026d3c1"
1201112022
12012[[package]]12023[[package]]
12013name = "tempfile"12024name = "tempfile"

1.PHONY: _help1.PHONY: _help
2_help:2_help:
3	@echo "regenerate_solidity - generate stubs/interfaces for contracts defined in native (via evm-coder)"3	@echo "regenerate_solidity - generate stubs/interfaces for contracts defined in native (via evm-coder)"
4	@echo "evm_stubs - recompile contract stubs"4	@echo "evm_stubs - recompile contract stubs and ABI"
5	@echo "bench - run frame-benchmarking"5	@echo "bench - run frame-benchmarking"
6	@echo "  bench-evm-migration"6	@echo "  bench-evm-migration"
7	@echo "  bench-unique"7	@echo "  bench-unique"
8
9.PHONY: regenerate_solidity
10regenerate_solidity:
11	PACKAGE=pallet-fungible NAME=erc::gen_iface OUTPUT=./tests/src/eth/api/UniqueFungible.sol ./.maintain/scripts/generate_api.sh
12	PACKAGE=pallet-nonfungible NAME=erc::gen_iface OUTPUT=./tests/src/eth/api/UniqueNFT.sol ./.maintain/scripts/generate_api.sh
13	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_iface OUTPUT=./tests/src/eth/api/ContractHelpers.sol ./.maintain/scripts/generate_api.sh
14
15	PACKAGE=pallet-fungible NAME=erc::gen_impl OUTPUT=./pallets/fungible/src/stubs/UniqueFungible.sol ./.maintain/scripts/generate_api.sh
16	PACKAGE=pallet-nonfungible NAME=erc::gen_impl OUTPUT=./pallets/nonfungible/src/stubs/UniqueNFT.sol ./.maintain/scripts/generate_api.sh
17	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_impl OUTPUT=./pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol ./.maintain/scripts/generate_api.sh
188
19FUNGIBLE_EVM_STUBS=./pallets/fungible/src/stubs9FUNGIBLE_EVM_STUBS=./pallets/fungible/src/stubs
10FUNGIBLE_EVM_ABI=./tests/src/eth/fungibleAbi.json
11
20NONFUNGIBLE_EVM_STUBS=./pallets/nonfungible/src/stubs12NONFUNGIBLE_EVM_STUBS=./pallets/nonfungible/src/stubs
13NONFUNGIBLE_EVM_ABI=./tests/src/eth/nonFungibleAbi.json
14
21CONTRACT_HELPERS_STUBS=./pallets/evm-contract-helpers/src/stubs/15CONTRACT_HELPERS_STUBS=./pallets/evm-contract-helpers/src/stubs/
16CONTRACT_HELPERS_ABI=./tests/src/eth/util/contractHelpersAbi.json
17
18COLLECTION_HELPER_STUBS=./pallets/unique/src/eth/stubs/
19COLLECTION_HELPER_ABI=./tests/src/eth/collectionHelperAbi.json
20
21TESTS_API=./tests/src/eth/api/
2222
23$(FUNGIBLE_EVM_STUBS)/UniqueFungible.raw: $(FUNGIBLE_EVM_STUBS)/UniqueFungible.sol23.PHONY: regenerate_solidity
24regenerate_solidity: UniqueFungible.sol UniqueNFT.sol ContractHelpers.sol CollectionHelper.sol
25
26UniqueFungible.sol:
24	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh27	PACKAGE=pallet-fungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh
28	PACKAGE=pallet-fungible NAME=erc::gen_impl OUTPUT=$(FUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh
29
30UniqueNFT.sol:
31	PACKAGE=pallet-nonfungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh
32	PACKAGE=pallet-nonfungible NAME=erc::gen_impl OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh
33
25$(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw: $(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.sol34ContractHelpers.sol:
35	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh
36	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_impl OUTPUT=$(CONTRACT_HELPERS_STUBS)/$@ ./.maintain/scripts/generate_sol.sh
37
38CollectionHelper.sol:
39	PACKAGE=pallet-unique NAME=eth::collection_helper_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh
40	PACKAGE=pallet-unique NAME=eth::collection_helper_impl OUTPUT=$(COLLECTION_HELPER_STUBS)/$@ ./.maintain/scripts/generate_sol.sh
41
42UniqueFungible: UniqueFungible.sol
26	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh43	INPUT=$(FUNGIBLE_EVM_STUBS)/$< OUTPUT=$(FUNGIBLE_EVM_STUBS)/UniqueFungible.raw ./.maintain/scripts/compile_stub.sh
44	INPUT=$(FUNGIBLE_EVM_STUBS)/$< OUTPUT=$(FUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh
45
46UniqueNFT: UniqueNFT.sol
47	INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw ./.maintain/scripts/compile_stub.sh
48	INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh
49
27$(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw: $(CONTRACT_HELPERS_STUBS)/ContractHelpers.sol50ContractHelpers: ContractHelpers.sol
51	INPUT=$(CONTRACT_HELPERS_STUBS)/$< OUTPUT=$(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw ./.maintain/scripts/compile_stub.sh
52	INPUT=$(CONTRACT_HELPERS_STUBS)/$< OUTPUT=$(CONTRACT_HELPERS_ABI) ./.maintain/scripts/generate_abi.sh
53
54CollectionHelper: CollectionHelper.sol
28	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh55	INPUT=$(COLLECTION_HELPER_STUBS)/$< OUTPUT=$(COLLECTION_HELPER_STUBS)/CollectionHelper.raw ./.maintain/scripts/compile_stub.sh
56	INPUT=$(COLLECTION_HELPER_STUBS)/$< OUTPUT=$(COLLECTION_HELPER_ABI) ./.maintain/scripts/generate_abi.sh
2957
30evm_stubs: $(FUNGIBLE_EVM_STUBS)/UniqueFungible.raw $(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw $(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw58evm_stubs: UniqueFungible UniqueNFT ContractHelpers CollectionHelper
3159
32.PHONY: _bench60.PHONY: _bench
33_bench:61_bench:

327	}327	}
328}328}
329329
330#[impl_for_tuples(1, 5)]330#[impl_for_tuples(1, 12)]
331impl SolidityArguments for Tuple {331impl SolidityArguments for Tuple {
332	for_tuples!( where #( Tuple: SolidityArguments ),* );332	for_tuples!( where #( Tuple: SolidityArguments ),* );
333333

16sp-runtime = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }16sp-runtime = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
17sp-std = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }17sp-std = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
18sp-core = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }18sp-core = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
19frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
19fp-evm-mapping = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }20fp-evm-mapping = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }
20up-data-structs = { default-features = false, path = '../../primitives/data-structs' }21up-data-structs = { default-features = false, path = '../../primitives/data-structs' }
21pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }22pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }
25scale-info = { version = "2.0.1", default-features = false, features = [27scale-info = { version = "2.0.1", default-features = false, features = [
26    "derive",28    "derive",
27] }29] }
28frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }30lazy_static = { version = "1.4.0", default-features = false, features = ["spin_no_std"] }
2931
30[features]32[features]
31default = ["std"]33default = ["std"]

17use evm_coder::{solidity_interface, types::*, execution::Result};17use evm_coder::{
18	solidity_interface,
19	types::*,
20	execution::{Result, Error},
21};
18pub use pallet_evm::{PrecompileOutput, PrecompileResult, account::CrossAccountId};22pub use pallet_evm::{PrecompileOutput, PrecompileResult, account::CrossAccountId};
19use pallet_evm_coder_substrate::dispatch_to_evm;23use pallet_evm_coder_substrate::dispatch_to_evm;
20use sp_core::{H160, U256};24use sp_core::{H160, U256};
21use sp_std::vec::Vec;25use sp_std::vec::Vec;
22use up_data_structs::Property;26use up_data_structs::{Property, SponsoringRateLimit};
27use alloc::format;
2328
24use crate::{Pallet, CollectionHandle, Config, CollectionProperties};29use crate::{Pallet, CollectionHandle, Config, CollectionProperties};
2530
31	fn call(self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileResult>;36	fn call(self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileResult>;
32}37}
3338
34#[solidity_interface(name = "CollectionProperties")]39#[solidity_interface(name = "Collection")]
35impl<T: Config> CollectionHandle<T> {40impl<T: Config> CollectionHandle<T> {
36	fn set_collection_property(&mut self, caller: caller, key: string, value: bytes) -> Result<()> {41	fn set_collection_property(&mut self, caller: caller, key: string, value: bytes) -> Result<()> {
37		let caller = T::CrossAccountId::from_eth(caller);42		let caller = T::CrossAccountId::from_eth(caller);
65		Ok(prop.to_vec())70		Ok(prop.to_vec())
66	}71	}
72
73	fn eth_set_sponsor(&mut self, caller: caller, sponsor: address) -> Result<void> {
74		check_is_owner(caller, self)?;
75
76		let sponsor = T::CrossAccountId::from_eth(sponsor);
77		self.set_sponsor(sponsor.as_sub().clone());
78		save(self);
79		Ok(())
80	}
81
82	fn eth_confirm_sponsorship(&mut self, caller: caller) -> Result<void> {
83		let caller = T::CrossAccountId::from_eth(caller);
84		if !self.confirm_sponsorship(caller.as_sub()) {
85			return Err(Error::Revert("Caller is not set as sponsor".into()));
86		}
87		save(self);
88		Ok(())
89	}
90
91	fn set_limit(&mut self, caller: caller, limit: string, value: string) -> Result<void> {
92		check_is_owner(caller, self)?;
93		let mut limits = self.limits.clone();
94
95		match limit.as_str() {
96			"accountTokenOwnershipLimit" => {
97				limits.account_token_ownership_limit = parse_int(value)?;
98			}
99			"sponsoredDataSize" => {
100				limits.sponsored_data_size = parse_int(value)?;
101			}
102			"sponsoredDataRateLimit" => {
103				limits.sponsored_data_rate_limit =
104					Some(SponsoringRateLimit::Blocks(parse_int(value)?.unwrap()));
105			}
106			"tokenLimit" => {
107				limits.token_limit = parse_int(value)?;
108			}
109			"sponsorTransferTimeout" => {
110				limits.sponsor_transfer_timeout = parse_int(value)?;
111			}
112			"sponsorApproveTimeout" => {
113				limits.sponsor_approve_timeout = parse_int(value)?;
114			}
115			"ownerCanTransfer" => {
116				limits.owner_can_transfer = parse_bool(value)?;
117			}
118			"ownerCanDestroy" => {
119				limits.owner_can_destroy = parse_bool(value)?;
120			}
121			"transfersEnabled" => {
122				limits.transfers_enabled = parse_bool(value)?;
123			}
124			_ => return Err(Error::Revert(format!("Unknown limit \"{}\"", limit))),
125		}
126		self.limits = <Pallet<T>>::clamp_limits(self.mode.clone(), &self.limits, limits)
127			.map_err(dispatch_to_evm::<T>)?;
128		save(self);
129		Ok(())
130	}
131
132	fn contract_address(&self, _caller: caller) -> Result<address> {
133		Ok(crate::eth::collection_id_to_address(self.id))
134	}
67}135}
136
137fn check_is_owner<T: Config>(caller: caller, collection: &CollectionHandle<T>) -> Result<()> {
138	let caller = T::CrossAccountId::from_eth(caller);
139	collection
140		.check_is_owner(&caller)
141		.map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)?;
142	Ok(())
143}
144
145fn save<T: Config>(collection: &CollectionHandle<T>) {
146	<crate::CollectionById<T>>::insert(collection.id, collection.collection.clone());
147}
148
149fn parse_int(value: string) -> Result<Option<u32>> {
150	value
151		.parse::<u32>()
152		.map_err(|e| Error::Revert(format!("Int value \"{}\" parse error: {}", value, e)))
153		.map(|value| Some(value))
154}
155
156fn parse_bool(value: string) -> Result<Option<bool>> {
157	value
158		.parse::<bool>()
159		.map_err(|e| Error::Revert(format!("Bool value \"{}\" parse error: {}", value, e)))
160		.map(|value| Some(value))
161}
68162

17use up_data_structs::CollectionId;17use up_data_structs::CollectionId;
18use sp_core::H160;18use sp_core::H160;
19
20lazy_static::lazy_static! {
21	pub static ref KEY_TOKEN_URI: up_data_structs::PropertyKey = {
22		let key: evm_coder::types::string = "tokenURI".into(); //TODO: make static
23		let key: up_data_structs::PropertyKey = key.into_bytes().try_into().expect("Can't create \"tokenURI\" key");
24		key
25	};
26}
1927
20// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 128// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 1
21// TODO: Unhardcode prefix29// TODO: Unhardcode prefix
38	H160(out)46	H160(out)
39}47}
48
49pub fn is_collection(address: &H160) -> bool {
50	address[0..16] == ETH_COLLECTION_PREFIX
51}
4052

115		})115		})
116	}116	}
117
118	pub fn new_with_recorder(id: CollectionId, recorder: SubstrateRecorder<T>) -> Option<Self> {
119		<CollectionById<T>>::get(id).map(|collection| Self {
120			id,
121			collection,
122			recorder,
123		})
124	}
125
117	pub fn new(id: CollectionId) -> Option<Self> {126	pub fn new(id: CollectionId) -> Option<Self> {
118		Self::new_with_gas_limit(id, u64::MAX)127		Self::new_with_gas_limit(id, u64::MAX)
141		Ok(())150		Ok(())
142	}151	}
152
153	pub fn set_sponsor(&mut self, sponsor: T::AccountId) {
154		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor);
155	}
156
157	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> bool {
158		if self.collection.sponsorship.pending_sponsor() != Some(sender) {
159			return false;
160		};
161
162		self.collection.sponsorship = SponsorshipState::Confirmed(sender.clone());
163		true
164	}
143}165}
144impl<T: Config> Deref for CollectionHandle<T> {166impl<T: Config> Deref for CollectionHandle<T> {
145	type Target = Collection<T::AccountId>;167	type Target = Collection<T::AccountId>;
476			CollectionStats,498			CollectionStats,
477			CollectionId,499			CollectionId,
478			TokenId,500			TokenId,
479			PhantomType<TokenData<T::CrossAccountId>>,501			PhantomType<(
502				TokenData<T::CrossAccountId>,
480			PhantomType<RpcCollection<T::AccountId>>,503				RpcCollection<T::AccountId>,
504
481			// RMRK505				// RMRK
482			PhantomType<RmrkCollectionInfo<T::AccountId>>,506				RmrkCollectionInfo<T::AccountId>,
483			PhantomType<RmrkInstanceInfo<T::AccountId>>,507				RmrkInstanceInfo<T::AccountId>,
484			PhantomType<RmrkResourceInfo>,508				RmrkResourceInfo,
485			PhantomType<RmrkPropertyInfo>,509				RmrkPropertyInfo,
486			PhantomType<RmrkBaseInfo<T::AccountId>>,510				RmrkBaseInfo<T::AccountId>,
487			PhantomType<RmrkPartType>,511				RmrkPartType,
488			PhantomType<RmrkTheme>,512				RmrkTheme,
489			PhantomType<RmrkNftChild>,513				RmrkNftChild,
514			)>,
490		),515		),
491		QueryKind = OptionQuery,516		QueryKind = OptionQuery,
492	>;517	>;
633			})658			})
634			.collect();659			.collect();
660
661		let permissions = CollectionPermissions {
662			access: Some(permissions.access()),
663			mint_mode: Some(permissions.mint_mode()),
664			nesting: Some(permissions.nesting().clone()),
665		};
635666
636		Some(RpcCollection {667		Some(RpcCollection {
637			name: name.into_inner(),668			name: name.into_inner(),

8scale-info = { version = "2.0.1", default-features = false, features = [8scale-info = { version = "2.0.1", default-features = false, features = [
9    "derive",9    "derive",
10] }10] }
11log = { default-features = false, version = "0.4.14" }
12
13# Substrate
11frame-support = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }14frame-support = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.21' }
12frame-system = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }15frame-system = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.21' }
13sp-runtime = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }16sp-runtime = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.21' }
14sp-std = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }17sp-std = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.21' }
15sp-core = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }18sp-core = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.21' }
16evm-coder = { default-features = false, path = '../../crates/evm-coder' }19
17pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }20# Unique
18pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }21pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }
19fp-evm-mapping = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }22fp-evm-mapping = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }
20up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = "polkadot-v0.9.21" }23up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = "polkadot-v0.9.21" }
24
25# Locals
26evm-coder = { default-features = false, path = '../../crates/evm-coder' }
21log = "0.4.14"27pallet-common = { default-features = false, path = '../../pallets/common' }
28pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }
29up-data-structs = { default-features = false, path = '../../primitives/data-structs', features = ['serde1'] }
2230
23[dependencies.codec]31[dependencies.codec]
24default-features = false32default-features = false

24use pallet_evm::account::CrossAccountId;24use pallet_evm::account::CrossAccountId;
25use pallet_evm_coder_substrate::{call, dispatch_to_evm};25use pallet_evm_coder_substrate::{call, dispatch_to_evm};
26use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};26use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
27use pallet_common::{CollectionHandle, erc::CollectionPropertiesCall};27use pallet_common::{CollectionHandle, erc::CollectionCall};
2828
29use crate::{29use crate::{
30	Allowance, Balance, Config, FungibleHandle, Pallet, SelfWeightOf, TotalSupply,30	Allowance, Balance, Config, FungibleHandle, Pallet, SelfWeightOf, TotalSupply,
150	is(150	is(
151		ERC20,151		ERC20,
152		ERC20UniqueExtensions,152		ERC20UniqueExtensions,
153		via("CollectionHandle<T>", common_mut, CollectionProperties)153		via("CollectionHandle<T>", common_mut, Collection)
154	)154	)
155)]155)]
156impl<T: Config> FungibleHandle<T> {}156impl<T: Config> FungibleHandle<T> {}

33use pallet_evm_coder_substrate::WithRecorder;33use pallet_evm_coder_substrate::WithRecorder;
34use sp_core::H160;34use sp_core::H160;
35use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};35use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};
36use sp_std::collections::btree_map::BTreeMap;36use sp_std::{collections::btree_map::BTreeMap};
3737
38pub use pallet::*;38pub use pallet::*;
3939

binary blob — no preview

127	}127	}
128}128}
129129
130// Selector: 9b5e29c5130// Selector: f5652829
131contract CollectionProperties is Dummy, ERC165 {131contract Collection is Dummy, ERC165 {
132	// Selector: setCollectionProperty(string,bytes) 2f073f66132	// Selector: setCollectionProperty(string,bytes) 2f073f66
133	function setCollectionProperty(string memory key, bytes memory value)133	function setCollectionProperty(string memory key, bytes memory value)
134		public134		public
160		return hex"";160		return hex"";
161	}161	}
162
163	// Selector: ethSetSponsor(address) 8f9af356
164	function ethSetSponsor(address sponsor) public {
165		require(false, stub_error);
166		sponsor;
167		dummy = 0;
168	}
169
170	// Selector: ethConfirmSponsorship() a8580d1a
171	function ethConfirmSponsorship() public {
172		require(false, stub_error);
173		dummy = 0;
174	}
175
176	// Selector: setLimit(string,string) bf4d2014
177	function setLimit(string memory limit, string memory value) public {
178		require(false, stub_error);
179		limit;
180		value;
181		dummy = 0;
182	}
183
184	// Selector: contractAddress() f6b4dfb4
185	function contractAddress() public view returns (address) {
186		require(false, stub_error);
187		dummy;
188		return 0x0000000000000000000000000000000000000000;
189	}
162}190}
163191
164contract UniqueFungible is192contract UniqueFungible is
165	Dummy,193	Dummy,
166	ERC165,194	ERC165,
167	ERC20,195	ERC20,
168	ERC20UniqueExtensions,196	ERC20UniqueExtensions,
169	CollectionProperties197	Collection
170{}198{}
171199

22	PropertyKeyPermission, PropertyValue,22	PropertyKeyPermission, PropertyValue,
23};23};
24use pallet_common::{24use pallet_common::{
25	CommonCollectionOperations, CommonWeightInfo, with_weight, weights::WeightInfo as _,25	CommonCollectionOperations, CommonWeightInfo, with_weight, weights::WeightInfo as _
26};26};
27use sp_runtime::DispatchError;27use sp_runtime::DispatchError;
28use sp_std::vec::Vec;28use sp_std::vec::Vec;

22use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};22use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};
23use frame_support::BoundedVec;23use frame_support::BoundedVec;
24use up_data_structs::{TokenId, SchemaVersion, PropertyPermission, PropertyKeyPermission, Property};24use up_data_structs::{
25	TokenId, SchemaVersion, PropertyPermission, PropertyKeyPermission, Property, CollectionId,
26	PropertyKey, CollectionPropertiesVec,
27};
25use pallet_evm_coder_substrate::dispatch_to_evm;28use pallet_evm_coder_substrate::dispatch_to_evm;
26use sp_core::{H160, U256};29use sp_core::{H160, U256};
27use sp_std::vec::Vec;30use sp_std::vec::Vec;
28use pallet_common::{31use pallet_common::{
29	erc::{CommonEvmHandler, PrecompileResult, CollectionPropertiesCall},32	erc::{CommonEvmHandler, PrecompileResult, CollectionCall},
30	CollectionHandle,33	CollectionHandle, CollectionPropertyPermissions,
31};34};
32use pallet_evm::account::CrossAccountId;35use pallet_evm::account::CrossAccountId;
33use pallet_evm_coder_substrate::call;36use pallet_evm_coder_substrate::call;
158	/// Returns token's const_metadata161	/// Returns token's const_metadata
159	#[solidity(rename_selector = "tokenURI")]162	#[solidity(rename_selector = "tokenURI")]
160	fn token_uri(&self, token_id: uint256) -> Result<string> {163	fn token_uri(&self, token_id: uint256) -> Result<string> {
164		let key = pallet_common::eth::KEY_TOKEN_URI.clone();
165		if !has_token_permission::<T>(self.id, &key) {
166			return Err("No tokenURI permission".into());
167		}
168
161		self.consume_store_reads(1)?;169		self.consume_store_reads(1)?;
162		let _token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;170		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
171
172		let properties = <TokenProperties<T>>::try_get((self.id, token_id))
173			.map_err(|_| Error::Revert("Token properties not found".into()))?;
174		if let Some(property) = properties.get(&key) {
163		Ok(string::from_utf8_lossy(175			return Ok(string::from_utf8_lossy(property).into());
164			todo!()176		}
165		)177
166		.into())178		Err("Property tokenURI not found".into())
167	}179	}
168}180}
169181
350		token_id: uint256,362		token_id: uint256,
351		token_uri: string,363		token_uri: string,
352	) -> Result<bool> {364	) -> Result<bool> {
365		let key = pallet_common::eth::KEY_TOKEN_URI.clone();
366		let permission = get_token_permission::<T>(self.id, &key)?;
367		if !permission.collection_admin {
368			return Err("Operation is not allowed".into());
369		}
370
353		let caller = T::CrossAccountId::from_eth(caller);371		let caller = T::CrossAccountId::from_eth(caller);
354		let to = T::CrossAccountId::from_eth(to);372		let to = T::CrossAccountId::from_eth(to);
365			return Err("item id should be next".into());383			return Err("item id should be next".into());
366		}384		}
367385
386		let mut properties = CollectionPropertiesVec::default();
387		properties
388			.try_push(Property {
389				key,
390				value: token_uri
391					.into_bytes()
392					.try_into()
393					.map_err(|_| "token uri is too long")?,
394			})
368		todo!("token uri");395			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;
369396
370		<Pallet<T>>::create_item(397		<Pallet<T>>::create_item(
371			self,398			self,
372			&caller,399			&caller,
373			CreateItemData::<T> {400			CreateItemData::<T> {
374				properties: BoundedVec::default(),401				properties,
375				owner: to,402				owner: to,
376			},403			},
377			&budget,404			&budget,
386	}413	}
387}414}
415
416fn get_token_permission<T: Config>(
417	collection_id: CollectionId,
418	key: &PropertyKey,
419) -> Result<PropertyPermission> {
420	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)
421		.map_err(|_| Error::Revert("No permissions for collection".into()))?;
422	let a = token_property_permissions
423		.get(key)
424		.map(|p| p.clone())
425		.ok_or_else(|| Error::Revert("No permission".into()))?;
426	Ok(a)
427}
428
429fn has_token_permission<T: Config>(
430	collection_id: CollectionId,
431	key: &PropertyKey,
432) -> bool {
433	if let Ok(token_property_permissions) = CollectionPropertyPermissions::<T>::try_get(collection_id) {
434		return token_property_permissions.contains_key(key);
435	}
436
437	false
438}
388439
389#[solidity_interface(name = "ERC721UniqueExtensions")]440#[solidity_interface(name = "ERC721UniqueExtensions")]
390impl<T: Config> NonfungibleHandle<T> {441impl<T: Config> NonfungibleHandle<T> {
491			}542			}
492			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;543			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
493544
494			todo!("token uri");
495			data.push(CreateItemData::<T> {545			data.push(CreateItemData::<T> {
496				properties: BoundedVec::default(),546				properties: BoundedVec::default(),
497				owner: to.clone(),547				owner: to.clone(),
513		ERC721UniqueExtensions,563		ERC721UniqueExtensions,
514		ERC721Mintable,564		ERC721Mintable,
515		ERC721Burnable,565		ERC721Burnable,
516		via("CollectionHandle<T>", common_mut, CollectionProperties),566		via("CollectionHandle<T>", common_mut, Collection),
517		TokenProperties,567		TokenProperties,
518	)568	)
519)]569)]

33use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};33use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};
34use sp_core::H160;34use sp_core::H160;
35use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};35use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};
36use sp_std::{vec::Vec, vec, collections::btree_set::BTreeSet};36use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap, collections::btree_set::BTreeSet};
37use core::ops::Deref;37use core::ops::Deref;
38use sp_std::collections::btree_map::BTreeMap;
39use codec::{Encode, Decode, MaxEncodedLen};38use codec::{Encode, Decode, MaxEncodedLen};
40use scale_info::TypeInfo;39use scale_info::TypeInfo;
4140