git.delta.rocks / unique-network / refs/commits / d8b03ef62dde

60856085
6086[[package]]6086[[package]]
6087name = "pallet-fungible"6087name = "pallet-fungible"
6088version = "0.1.7"6088version = "0.1.9"
6089dependencies = [6089dependencies = [
6090 "ethereum 0.14.0",6090 "ethereum 0.14.0",
6091 "evm-coder",6091 "evm-coder",
63426342
6343[[package]]6343[[package]]
6344name = "pallet-nonfungible"6344name = "pallet-nonfungible"
6345version = "0.1.11"6345version = "0.1.12"
6346dependencies = [6346dependencies = [
6347 "ethereum 0.14.0",6347 "ethereum 0.14.0",
6348 "evm-coder",6348 "evm-coder",
65016501
6502[[package]]6502[[package]]
6503name = "pallet-refungible"6503name = "pallet-refungible"
6504version = "0.2.10"6504version = "0.2.11"
6505dependencies = [6505dependencies = [
6506 "derivative",6506 "derivative",
6507 "ethereum 0.14.0",6507 "ethereum 0.14.0",

36use crate::{36use crate::{
37	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,37	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,
38	eth::{38	eth::{
39		EthCrossAccount, convert_cross_account_to_uint256, CollectionPermissions as EvmPermissions,39		EthCrossAccount, CollectionPermissions as EvmPermissions,
40		CollectionLimits as EvmCollectionLimits,40		CollectionLimits as EvmCollectionLimits,
41	},41	},
42	weights::WeightInfo,42	weights::WeightInfo,
289	/// Get current sponsor.289	/// Get current sponsor.
290	///290	///
291	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.291	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
292	fn collection_sponsor(&self) -> Result<(address, uint256)> {292	fn collection_sponsor(&self) -> Result<EthCrossAccount> {
293		let sponsor = match self.collection.sponsorship.sponsor() {293		let sponsor = match self.collection.sponsorship.sponsor() {
294			Some(sponsor) => sponsor,294			Some(sponsor) => sponsor,
295			None => return Ok(Default::default()),295			None => return Ok(Default::default()),
296		};296		};
297
297		let sponsor = T::CrossAccountId::from_sub(sponsor.clone());298		Ok(EthCrossAccount::from_sub::<T>(&sponsor))
298		let result: (address, uint256) = if sponsor.is_canonical_substrate() {
299			let sponsor = convert_cross_account_to_uint256::<T>(&sponsor);
300			(Default::default(), sponsor)
301		} else {
302			let sponsor = *sponsor.as_eth();
303			(sponsor, Default::default())
304		};
305		Ok(result)
306	}299	}
307300
308	/// Get current collection limits.301	/// Get current collection limits.

53	address[0..16] == ETH_COLLECTION_PREFIX53	address[0..16] == ETH_COLLECTION_PREFIX
54}54}
55
56/// Convert `CrossAccountId` to `uint256`.
57pub fn convert_cross_account_to_uint256<T: Config>(from: &T::CrossAccountId) -> uint256
58where
59	T::AccountId: AsRef<[u8; 32]>,
60{
61	let slice = from.as_sub().as_ref();
62	uint256::from_big_endian(slice)
63}
6455
65/// Convert `uint256` to `CrossAccountId`.56/// Convert `uint256` to `CrossAccountId`.
66pub fn convert_uint256_to_cross_account<T: Config>(from: uint256) -> T::CrossAccountId57pub fn convert_uint256_to_cross_account<T: Config>(from: uint256) -> T::CrossAccountId
73	T::CrossAccountId::from_sub(account_id)64	T::CrossAccountId::from_sub(account_id)
74}65}
75
76/// Convert `CrossAccountId` to `(address, uint256)`.
77pub fn convert_cross_account_to_tuple<T: Config>(
78	cross_account_id: &T::CrossAccountId,
79) -> (address, uint256)
80where
81	T::AccountId: AsRef<[u8; 32]>,
82{
83	if cross_account_id.is_canonical_substrate() {
84		let sub = convert_cross_account_to_uint256::<T>(cross_account_id);
85		(Default::default(), sub)
86	} else {
87		let eth = *cross_account_id.as_eth();
88		(eth, Default::default())
89	}
90}
91
92/// Convert tuple `(address, uint256)` to `CrossAccountId`.
93///
94/// If `address` in the tuple has *default* value, then the canonical form is substrate,
95/// if `uint256` has *default* value, then the ethereum form is canonical,
96/// if both values are *default* or *non default*, then this is considered an invalid address and `Error` is returned.
97pub fn convert_tuple_to_cross_account<T: Config>(
98	eth_cross_account_id: (address, uint256),
99) -> evm_coder::execution::Result<T::CrossAccountId>
100where
101	T::AccountId: From<[u8; 32]>,
102{
103	if eth_cross_account_id == Default::default() {
104		Err("All fields of cross account is zeroed".into())
105	} else if eth_cross_account_id.0 == Default::default() {
106		Ok(convert_uint256_to_cross_account::<T>(
107			eth_cross_account_id.1,
108		))
109	} else if eth_cross_account_id.1 == Default::default() {
110		Ok(T::CrossAccountId::from_eth(eth_cross_account_id.0))
111	} else {
112		Err("All fields of cross account is non zeroed".into())
113	}
114}
11566
116/// Cross account struct67/// Cross account struct
117#[derive(Debug, Default, AbiCoder)]68#[derive(Debug, Default, AbiCoder)]
121}72}
12273
123impl EthCrossAccount {74impl EthCrossAccount {
75	/// Converts `CrossAccountId` to `EthCrossAccountId`
124	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self76	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self
125	where77	where
126		T: pallet_evm::Config,78		T: pallet_evm::Config,
127		T::AccountId: AsRef<[u8; 32]>,79		T::AccountId: AsRef<[u8; 32]>,
128	{80	{
129		if cross_account_id.is_canonical_substrate() {81		if cross_account_id.is_canonical_substrate() {
130			Self {82			Self::from_sub::<T>(cross_account_id.as_sub())
131				eth: Default::default(),
132				sub: convert_cross_account_to_uint256::<T>(cross_account_id),
133			}
134		} else {83		} else {
135			Self {84			Self {
136				eth: *cross_account_id.as_eth(),85				eth: *cross_account_id.as_eth(),
137				sub: Default::default(),86				sub: Default::default(),
138			}87			}
139		}88		}
140	}89	}
14190	/// Creates `EthCrossAccount` from substrate account
91	pub fn from_sub<T>(account_id: &T::AccountId) -> Self
92	where
93		T: pallet_evm::Config,
94		T::AccountId: AsRef<[u8; 32]>,
95	{
96		Self {
97			eth: Default::default(),
98			sub: uint256::from_big_endian(account_id.as_ref()),
99		}
100	}
101	/// Converts `EthCrossAccount` to `CrossAccountId`
142	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>102	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>
143	where103	where
144		T: pallet_evm::Config,104		T: pallet_evm::Config,
180	/// Is it possible to send tokens from this collection between users.148	/// Is it possible to send tokens from this collection between users.
181	TransferEnabled,149	TransferEnabled,
182}150}
151/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.
183#[derive(Default, Debug, Clone, Copy, AbiCoder)]152#[derive(Default, Debug, Clone, Copy, AbiCoder)]
184#[repr(u8)]153#[repr(u8)]
185pub enum CollectionPermissions {154pub enum CollectionPermissions {
155	/// Owner of token can nest tokens under it.
186	#[default]156	#[default]
187	CollectionAdmin,
188	TokenOwner,157	TokenOwner,
158
159	/// Admin of token collection can nest tokens under token.
160	CollectionAdmin,
189}161}
190162
191/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.163/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.

50    "pallet-evm-coder-substrate/std",50    "pallet-evm-coder-substrate/std",
51    "pallet-evm/std",51    "pallet-evm/std",
52    "up-sponsorship/std",52    "up-sponsorship/std",
53    "pallet-common/std",
53]54]
54try-runtime = ["frame-support/try-runtime"]55try-runtime = ["frame-support/try-runtime"]
55stubgen = ["evm-coder/stubgen"]56stubgen = ["evm-coder/stubgen", "pallet-common/stubgen"]
5657

25	types::*,25	types::*,
26	ToLog,26	ToLog,
27};27};
28use pallet_common::eth::EthCrossAccount;
28use pallet_evm::{29use pallet_evm::{
29	ExitRevert, OnCreate, OnMethodCall, PrecompileResult, PrecompileFailure, PrecompileHandle,30	ExitRevert, OnCreate, OnMethodCall, PrecompileResult, PrecompileFailure, PrecompileHandle,
30	account::CrossAccountId,31	account::CrossAccountId,
174	///175	///
175	/// @param contractAddress The contract for which a sponsor is requested.176	/// @param contractAddress The contract for which a sponsor is requested.
176	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.177	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
177	fn sponsor(&self, contract_address: address) -> Result<(address, uint256)> {178	fn sponsor(&self, contract_address: address) -> Result<EthCrossAccount> {
178		let sponsor =179		Ok(EthCrossAccount::from_sub_cross_account::<T>(
179			Pallet::<T>::get_sponsor(contract_address).ok_or("Contract has no sponsor")?;180			&Pallet::<T>::get_sponsor(contract_address).ok_or("Contract has no sponsor")?,
180		Ok(pallet_common::eth::convert_cross_account_to_tuple::<T>(181		))
181			&sponsor,
182		))
183	}182	}
184183
185	/// Check tat contract has confirmed sponsor.184	/// Check tat contract has confirmed sponsor.

binary blob — no preview

96	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.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,97	/// @dev EVM selector for this function is: 0x766c4f37,
98	///  or in textual repr: sponsor(address)98	///  or in textual repr: sponsor(address)
99	function sponsor(address contractAddress) public view returns (Tuple0 memory) {99	function sponsor(address contractAddress) public view returns (EthCrossAccount memory) {
100		require(false, stub_error);100		require(false, stub_error);
101		contractAddress;101		contractAddress;
102		dummy;102		dummy;
103		return Tuple0(0x0000000000000000000000000000000000000000, 0);103		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);
104	}104	}
105105
106	/// Check tat contract has confirmed sponsor.106	/// Check tat contract has confirmed sponsor.
265	}265	}
266}266}
267267
268/// @dev anonymous struct268/// @dev Cross account struct
269struct Tuple0 {269struct EthCrossAccount {
270	address field_0;270	address eth;
271	uint256 field_1;271	uint256 sub;
272}272}
273273

44
5<!-- bureaucrate goes here -->5<!-- bureaucrate goes here -->
66
7## [0.1.9] - 2022-12-01
8
9### Added
10
11- The functions `mintCross` to `ERC20UniqueExtensions` interface.
12
7## [0.1.8] - 2022-11-1813## [0.1.8] - 2022-11-18
814
9### Added15### Added

1[package]1[package]
2name = "pallet-fungible"2name = "pallet-fungible"
3version = "0.1.7"3version = "0.1.9"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

174			.collect::<string>())174			.collect::<string>())
175	}175	}
176
177	#[weight(<SelfWeightOf<T>>::create_item())]
178	fn mint_cross(&mut self, caller: caller, to: EthCrossAccount, amount: uint256) -> Result<bool> {
179		let caller = T::CrossAccountId::from_eth(caller);
180		let to = to.into_sub_cross_account::<T>()?;
181		let amount = amount.try_into().map_err(|_| "amount overflow")?;
182		let budget = self
183			.recorder
184			.weight_calls_budget(<StructureWeight<T>>::find_parent());
185		<Pallet<T>>::create_item(&self, &caller, (to, amount), &budget)
186			.map_err(dispatch_to_evm::<T>)?;
187		Ok(true)
188	}
176189
177	#[weight(<SelfWeightOf<T>>::approve())]190	#[weight(<SelfWeightOf<T>>::approve())]
178	fn approve_cross(191	fn approve_cross(

binary blob — no preview

152	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.152	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
153	/// @dev EVM selector for this function is: 0x6ec0a9f1,153	/// @dev EVM selector for this function is: 0x6ec0a9f1,
154	///  or in textual repr: collectionSponsor()154	///  or in textual repr: collectionSponsor()
155	function collectionSponsor() public view returns (Tuple8 memory) {155	function collectionSponsor() public view returns (EthCrossAccount memory) {
156		require(false, stub_error);156		require(false, stub_error);
157		dummy;157		dummy;
158		return Tuple8(0x0000000000000000000000000000000000000000, 0);158		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);
159	}159	}
160160
161	/// Get current collection limits.161	/// Get current collection limits.
173	/// Return `false` if a limit not set.173	/// Return `false` if a limit not set.
174	/// @dev EVM selector for this function is: 0xf63bc572,174	/// @dev EVM selector for this function is: 0xf63bc572,
175	///  or in textual repr: collectionLimits()175	///  or in textual repr: collectionLimits()
176	function collectionLimits() public view returns (Tuple20[] memory) {176	function collectionLimits() public view returns (Tuple23[] memory) {
177		require(false, stub_error);177		require(false, stub_error);
178		dummy;178		dummy;
179		return new Tuple20[](0);179		return new Tuple23[](0);
180	}180	}
181181
182	/// Set limits for the collection.182	/// Set limits for the collection.
284	/// Returns nesting for a collection284	/// Returns nesting for a collection
285	/// @dev EVM selector for this function is: 0x22d25bfe,285	/// @dev EVM selector for this function is: 0x22d25bfe,
286	///  or in textual repr: collectionNestingRestrictedCollectionIds()286	///  or in textual repr: collectionNestingRestrictedCollectionIds()
287	function collectionNestingRestrictedCollectionIds() public view returns (Tuple26 memory) {287	function collectionNestingRestrictedCollectionIds() public view returns (Tuple29 memory) {
288		require(false, stub_error);288		require(false, stub_error);
289		dummy;289		dummy;
290		return Tuple26(false, new uint256[](0));290		return Tuple29(false, new uint256[](0));
291	}291	}
292292
293	/// Returns permissions for a collection293	/// Returns permissions for a collection
294	/// @dev EVM selector for this function is: 0x5b2eaf4b,294	/// @dev EVM selector for this function is: 0x5b2eaf4b,
295	///  or in textual repr: collectionNestingPermissions()295	///  or in textual repr: collectionNestingPermissions()
296	function collectionNestingPermissions() public view returns (Tuple29[] memory) {296	function collectionNestingPermissions() public view returns (Tuple32[] memory) {
297		require(false, stub_error);297		require(false, stub_error);
298		dummy;298		dummy;
299		return new Tuple29[](0);299		return new Tuple32[](0);
300	}300	}
301301
302	/// Set the collection access method.302	/// Set the collection access method.
476}476}
477477
478/// @dev anonymous struct478/// @dev anonymous struct
479struct Tuple29 {479struct Tuple32 {
480	CollectionPermissions field_0;480	CollectionPermissions field_0;
481	bool field_1;481	bool field_1;
482}482}
483483
484/// @dev anonymous struct484/// @dev anonymous struct
485struct Tuple26 {485struct Tuple29 {
486	bool field_0;486	bool field_0;
487	uint256[] field_1;487	uint256[] field_1;
488}488}
510}510}
511511
512/// @dev anonymous struct512/// @dev anonymous struct
513struct Tuple20 {513struct Tuple23 {
514	CollectionLimits field_0;514	CollectionLimits field_0;
515	bool field_1;515	bool field_1;
516	uint256 field_2;516	uint256 field_2;
522	bytes value;522	bytes value;
523}523}
524524
525/// @dev the ERC-165 identifier for this interface is 0x5b7038cf525/// @dev the ERC-165 identifier for this interface is 0x7dee5997
526contract ERC20UniqueExtensions is Dummy, ERC165 {526contract ERC20UniqueExtensions is Dummy, ERC165 {
527	/// @notice A description for the collection.527	/// @notice A description for the collection.
528	/// @dev EVM selector for this function is: 0x7284e416,528	/// @dev EVM selector for this function is: 0x7284e416,
533		return "";533		return "";
534	}534	}
535
536	/// @dev EVM selector for this function is: 0x269e6158,
537	///  or in textual repr: mintCross((address,uint256),uint256)
538	function mintCross(EthCrossAccount memory to, uint256 amount) public returns (bool) {
539		require(false, stub_error);
540		to;
541		amount;
542		dummy = 0;
543		return false;
544	}
535545
536	/// @dev EVM selector for this function is: 0x0ecd0ab0,546	/// @dev EVM selector for this function is: 0x0ecd0ab0,
537	///  or in textual repr: approveCross((address,uint256),uint256)547	///  or in textual repr: approveCross((address,uint256),uint256)
577	/// @param amounts array of pairs of account address and amount587	/// @param amounts array of pairs of account address and amount
578	/// @dev EVM selector for this function is: 0x1acf2d55,588	/// @dev EVM selector for this function is: 0x1acf2d55,
579	///  or in textual repr: mintBulk((address,uint256)[])589	///  or in textual repr: mintBulk((address,uint256)[])
580	function mintBulk(Tuple8[] memory amounts) public returns (bool) {590	function mintBulk(Tuple9[] memory amounts) public returns (bool) {
581		require(false, stub_error);591		require(false, stub_error);
582		amounts;592		amounts;
583		dummy = 0;593		dummy = 0;
611}621}
612622
613/// @dev anonymous struct623/// @dev anonymous struct
614struct Tuple8 {624struct Tuple9 {
615	address field_0;625	address field_0;
616	uint256 field_1;626	uint256 field_1;
617}627}

44
5<!-- bureaucrate goes here -->5<!-- bureaucrate goes here -->
66
7## [0.1.11] - 2022-12-167## [0.1.12] - 2022-12-16
88
9### Added9### Added
1010
1414
15- Hide `setTokenPropertyPermission` function in `TokenProperties` interface.15- Hide `setTokenPropertyPermission` function in `TokenProperties` interface.
1616
17## [0.1.11] - 2022-12-01
18
19### Added
20
21- The functions `mintCross` to `ERC721UniqueExtensions` interface.
22
17## [0.1.10] - 2022-11-1823## [0.1.10] - 2022-11-18
1824
19### Added25### Added

1[package]1[package]
2name = "pallet-nonfungible"2name = "pallet-nonfungible"
3version = "0.1.11"3version = "0.1.12"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

605		Ok(false)605		Ok(false)
606	}606	}
607607
608	/// @notice Function to mint token.608	/// @notice Function to mint a token.
609	/// @param to The new owner609	/// @param to The new owner
610	/// @return uint256 The id of the newly minted token610	/// @return uint256 The id of the newly minted token
611	#[weight(<SelfWeightOf<T>>::create_item())]611	#[weight(<SelfWeightOf<T>>::create_item())]
618		Ok(token_id)618		Ok(token_id)
619	}619	}
620620
621	/// @notice Function to mint token.621	/// @notice Function to mint a token.
622	/// @dev `tokenId` should be obtained with `nextTokenId` method,622	/// @dev `tokenId` should be obtained with `nextTokenId` method,
623	///  unlike standard, you can't specify it manually623	///  unlike standard, you can't specify it manually
624	/// @param to The new owner624	/// @param to The new owner
1070		Ok(true)1070		Ok(true)
1071	}1071	}
1072
1073	/// @notice Function to mint a token.
1074	/// @param to The new owner crossAccountId
1075	/// @param properties Properties of minted token
1076	/// @return uint256 The id of the newly minted token
1077	#[weight(<SelfWeightOf<T>>::create_item())]
1078	fn mint_cross(
1079		&mut self,
1080		caller: caller,
1081		to: EthCrossAccount,
1082		properties: Vec<PropertyStruct>,
1083	) -> Result<uint256> {
1084		let token_id = <TokensMinted<T>>::get(self.id)
1085			.checked_add(1)
1086			.ok_or("item id overflow")?;
1087
1088		let to = to.into_sub_cross_account::<T>()?;
1089
1090		let properties = properties
1091			.into_iter()
1092			.map(|PropertyStruct { key, value }| {
1093				let key = <Vec<u8>>::from(key)
1094					.try_into()
1095					.map_err(|_| "key too large")?;
1096
1097				let value = value.0.try_into().map_err(|_| "value too large")?;
1098
1099				Ok(Property { key, value })
1100			})
1101			.collect::<Result<Vec<_>>>()?
1102			.try_into()
1103			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;
1104
1105		let caller = T::CrossAccountId::from_eth(caller);
1106
1107		let budget = self
1108			.recorder
1109			.weight_calls_budget(<StructureWeight<T>>::find_parent());
1110
1111		<Pallet<T>>::create_item(
1112			self,
1113			&caller,
1114			CreateItemData::<T> {
1115				properties,
1116				owner: to,
1117			},
1118			&budget,
1119		)
1120		.map_err(dispatch_to_evm::<T>)?;
1121
1122		Ok(token_id.into())
1123	}
1072}1124}
10731125
1074#[solidity_interface(1126#[solidity_interface(

binary blob — no preview

42	/// @param permissions Permissions for keys.42	/// @param permissions Permissions for keys.
43	/// @dev EVM selector for this function is: 0xbd92983a,43	/// @dev EVM selector for this function is: 0xbd92983a,
44	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])44	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])
45	function setTokenPropertyPermissions(Tuple59[] memory permissions) public {45	function setTokenPropertyPermissions(Tuple61[] memory permissions) public {
46		require(false, stub_error);46		require(false, stub_error);
47		permissions;47		permissions;
48		dummy = 0;48		dummy = 0;
51	/// @notice Get permissions for token properties.51	/// @notice Get permissions for token properties.
52	/// @dev EVM selector for this function is: 0xf23d7790,52	/// @dev EVM selector for this function is: 0xf23d7790,
53	///  or in textual repr: tokenPropertyPermissions()53	///  or in textual repr: tokenPropertyPermissions()
54	function tokenPropertyPermissions() public view returns (Tuple59[] memory) {54	function tokenPropertyPermissions() public view returns (Tuple61[] memory) {
55		require(false, stub_error);55		require(false, stub_error);
56		dummy;56		dummy;
57		return new Tuple59[](0);57		return new Tuple61[](0);
58	}58	}
5959
60	// /// @notice Set token property value.60	// /// @notice Set token property value.
144}144}
145145
146/// @dev anonymous struct146/// @dev anonymous struct
147struct Tuple59 {147struct Tuple61 {
148	string field_0;148	string field_0;
149	Tuple57[] field_1;149	Tuple59[] field_1;
150}150}
151151
152/// @dev anonymous struct152/// @dev anonymous struct
153struct Tuple57 {153struct Tuple59 {
154	EthTokenPermissions field_0;154	EthTokenPermissions field_0;
155	bool field_1;155	bool field_1;
156}156}
290	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.290	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
291	/// @dev EVM selector for this function is: 0x6ec0a9f1,291	/// @dev EVM selector for this function is: 0x6ec0a9f1,
292	///  or in textual repr: collectionSponsor()292	///  or in textual repr: collectionSponsor()
293	function collectionSponsor() public view returns (Tuple30 memory) {293	function collectionSponsor() public view returns (EthCrossAccount memory) {
294		require(false, stub_error);294		require(false, stub_error);
295		dummy;295		dummy;
296		return Tuple30(0x0000000000000000000000000000000000000000, 0);296		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);
297	}297	}
298298
299	/// Get current collection limits.299	/// Get current collection limits.
311	/// Return `false` if a limit not set.311	/// Return `false` if a limit not set.
312	/// @dev EVM selector for this function is: 0xf63bc572,312	/// @dev EVM selector for this function is: 0xf63bc572,
313	///  or in textual repr: collectionLimits()313	///  or in textual repr: collectionLimits()
314	function collectionLimits() public view returns (Tuple33[] memory) {314	function collectionLimits() public view returns (Tuple35[] memory) {
315		require(false, stub_error);315		require(false, stub_error);
316		dummy;316		dummy;
317		return new Tuple33[](0);317		return new Tuple35[](0);
318	}318	}
319319
320	/// Set limits for the collection.320	/// Set limits for the collection.
422	/// Returns nesting for a collection422	/// Returns nesting for a collection
423	/// @dev EVM selector for this function is: 0x22d25bfe,423	/// @dev EVM selector for this function is: 0x22d25bfe,
424	///  or in textual repr: collectionNestingRestrictedCollectionIds()424	///  or in textual repr: collectionNestingRestrictedCollectionIds()
425	function collectionNestingRestrictedCollectionIds() public view returns (Tuple39 memory) {425	function collectionNestingRestrictedCollectionIds() public view returns (Tuple41 memory) {
426		require(false, stub_error);426		require(false, stub_error);
427		dummy;427		dummy;
428		return Tuple39(false, new uint256[](0));428		return Tuple41(false, new uint256[](0));
429	}429	}
430430
431	/// Returns permissions for a collection431	/// Returns permissions for a collection
432	/// @dev EVM selector for this function is: 0x5b2eaf4b,432	/// @dev EVM selector for this function is: 0x5b2eaf4b,
433	///  or in textual repr: collectionNestingPermissions()433	///  or in textual repr: collectionNestingPermissions()
434	function collectionNestingPermissions() public view returns (Tuple42[] memory) {434	function collectionNestingPermissions() public view returns (Tuple44[] memory) {
435		require(false, stub_error);435		require(false, stub_error);
436		dummy;436		dummy;
437		return new Tuple42[](0);437		return new Tuple44[](0);
438	}438	}
439439
440	/// Set the collection access method.440	/// Set the collection access method.
614}614}
615615
616/// @dev anonymous struct616/// @dev anonymous struct
617struct Tuple42 {617struct Tuple44 {
618	CollectionPermissions field_0;618	CollectionPermissions field_0;
619	bool field_1;619	bool field_1;
620}620}
621621
622/// @dev anonymous struct622/// @dev anonymous struct
623struct Tuple39 {623struct Tuple41 {
624	bool field_0;624	bool field_0;
625	uint256[] field_1;625	uint256[] field_1;
626}626}
648}648}
649649
650/// @dev anonymous struct650/// @dev anonymous struct
651struct Tuple33 {651struct Tuple35 {
652	CollectionLimits field_0;652	CollectionLimits field_0;
653	bool field_1;653	bool field_1;
654	uint256 field_2;654	uint256 field_2;
655}655}
656
657/// @dev anonymous struct
658struct Tuple30 {
659	address field_0;
660	uint256 field_1;
661}
662656
663/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension657/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
664/// @dev See https://eips.ethereum.org/EIPS/eip-721658/// @dev See https://eips.ethereum.org/EIPS/eip-721
735		return false;729		return false;
736	}730	}
737731
738	/// @notice Function to mint token.732	/// @notice Function to mint a token.
739	/// @param to The new owner733	/// @param to The new owner
740	/// @return uint256 The id of the newly minted token734	/// @return uint256 The id of the newly minted token
741	/// @dev EVM selector for this function is: 0x6a627842,735	/// @dev EVM selector for this function is: 0x6a627842,
747		return 0;741		return 0;
748	}742	}
749743
750	// /// @notice Function to mint token.744	// /// @notice Function to mint a token.
751	// /// @dev `tokenId` should be obtained with `nextTokenId` method,745	// /// @dev `tokenId` should be obtained with `nextTokenId` method,
752	// ///  unlike standard, you can't specify it manually746	// ///  unlike standard, you can't specify it manually
753	// /// @param to The new owner747	// /// @param to The new owner
804}798}
805799
806/// @title Unique extensions for ERC721.800/// @title Unique extensions for ERC721.
807/// @dev the ERC-165 identifier for this interface is 0xb74c26b7801/// @dev the ERC-165 identifier for this interface is 0x0e48fdb4
808contract ERC721UniqueExtensions is Dummy, ERC165 {802contract ERC721UniqueExtensions is Dummy, ERC165 {
809	/// @notice A descriptive name for a collection of NFTs in this contract803	/// @notice A descriptive name for a collection of NFTs in this contract
810	/// @dev EVM selector for this function is: 0x06fdde03,804	/// @dev EVM selector for this function is: 0x06fdde03,
991	// 	return false;986	// 	return false;
992	// }987	// }
993988
989	/// @notice Function to mint a token.
990	/// @param to The new owner crossAccountId
991	/// @param properties Properties of minted token
992	/// @return uint256 The id of the newly minted token
993	/// @dev EVM selector for this function is: 0xb904db03,
994	///  or in textual repr: mintCross((address,uint256),(string,bytes)[])
995	function mintCross(EthCrossAccount memory to, Property[] memory properties) public returns (uint256) {
996		require(false, stub_error);
997		to;
998		properties;
999		dummy = 0;
1000		return 0;
1001	}
994}1002}
9951003
996/// @dev anonymous struct1004/// @dev anonymous struct

44
5<!-- bureaucrate goes here -->5<!-- bureaucrate goes here -->
66
7## [0.2.10] - 2022-12-167## [0.2.11] - 2022-12-16
88
9### Added9### Added
1010
1414
15- Hide `setTokenPropertyPermission` function in `TokenProperties` interface.15- Hide `setTokenPropertyPermission` function in `TokenProperties` interface.
1616
17## [0.2.10] - 2022-12-01
18
19### Added
20
21- The functions `mintCross` to `ERC721UniqueExtensions` interface.
22
17## [0.2.9] - 2022-11-1823## [0.2.9] - 2022-11-18
1824
19### Added25### Added

1[package]1[package]
2name = "pallet-refungible"2name = "pallet-refungible"
3version = "0.2.10"3version = "0.2.11"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

165fn map_create_data<T: Config>(165fn map_create_data<T: Config>(
166	data: up_data_structs::CreateItemData,166	data: up_data_structs::CreateItemData,
167	to: &T::CrossAccountId,167	to: &T::CrossAccountId,
168) -> Result<CreateItemData<T::CrossAccountId>, DispatchError> {168) -> Result<CreateItemData<T>, DispatchError> {
169	match data {169	match data {
170		up_data_structs::CreateItemData::ReFungible(data) => Ok(CreateItemData {170		up_data_structs::CreateItemData::ReFungible(data) => Ok(CreateItemData::<T> {
171			users: {171			users: {
172				let mut out = BTreeMap::new();172				let mut out = BTreeMap::new();
173				out.insert(to.clone(), data.pieces);173				out.insert(to.clone(), data.pieces);
230			CreateItemExData::RefungibleMultipleOwners(CreateRefungibleExMultipleOwners {230			CreateItemExData::RefungibleMultipleOwners(CreateRefungibleExMultipleOwners {
231				users,231				users,
232				properties,232				properties,
233			}) => vec![CreateItemData { users, properties }],233			}) => vec![CreateItemData::<T> { users, properties }],
234			CreateItemExData::RefungibleMultipleItems(r) => r234			CreateItemExData::RefungibleMultipleItems(r) => r
235				.into_inner()235				.into_inner()
236				.into_iter()236				.into_iter()
239					     user,239					     user,
240					     pieces,240					     pieces,
241					     properties,241					     properties,
242					 }| CreateItemData {242					 }| CreateItemData::<T> {
243						users: BTreeMap::from([(user, pieces)])243						users: BTreeMap::from([(user, pieces)])
244							.try_into()244							.try_into()
245							.expect("limit >= 1"),245							.expect("limit >= 1"),

637		Ok(false)637		Ok(false)
638	}638	}
639639
640	/// @notice Function to mint token.640	/// @notice Function to mint a token.
641	/// @param to The new owner641	/// @param to The new owner
642	/// @return uint256 The id of the newly minted token642	/// @return uint256 The id of the newly minted token
643	#[weight(<SelfWeightOf<T>>::create_item())]643	#[weight(<SelfWeightOf<T>>::create_item())]
650		Ok(token_id)650		Ok(token_id)
651	}651	}
652652
653	/// @notice Function to mint token.653	/// @notice Function to mint a token.
654	/// @dev `tokenId` should be obtained with `nextTokenId` method,654	/// @dev `tokenId` should be obtained with `nextTokenId` method,
655	///  unlike standard, you can't specify it manually655	///  unlike standard, you can't specify it manually
656	/// @param to The new owner656	/// @param to The new owner
681		<Pallet<T>>::create_item(681		<Pallet<T>>::create_item(
682			self,682			self,
683			&caller,683			&caller,
684			CreateItemData::<T::CrossAccountId> {684			CreateItemData::<T> {
685				users,685				users,
686				properties: CollectionPropertiesVec::default(),686				properties: CollectionPropertiesVec::default(),
687			},687			},
767		<Pallet<T>>::create_item(767		<Pallet<T>>::create_item(
768			self,768			self,
769			&caller,769			&caller,
770			CreateItemData::<T::CrossAccountId> { users, properties },770			CreateItemData::<T> { users, properties },
771			&budget,771			&budget,
772		)772		)
773		.map_err(dispatch_to_evm::<T>)?;773		.map_err(dispatch_to_evm::<T>)?;
1048			.collect::<BTreeMap<_, _>>()1048			.collect::<BTreeMap<_, _>>()
1049			.try_into()1049			.try_into()
1050			.unwrap();1050			.unwrap();
1051		let create_item_data = CreateItemData::<T::CrossAccountId> {1051		let create_item_data = CreateItemData::<T> {
1052			users,1052			users,
1053			properties: CollectionPropertiesVec::default(),1053			properties: CollectionPropertiesVec::default(),
1054		};1054		};
1108				})1108				})
1109				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;1109				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;
11101110
1111			let create_item_data = CreateItemData::<T::CrossAccountId> {1111			let create_item_data = CreateItemData::<T> {
1112				users: users.clone(),1112				users: users.clone(),
1113				properties,1113				properties,
1114			};1114			};
1120		Ok(true)1120		Ok(true)
1121	}1121	}
1122
1123	/// @notice Function to mint a token.
1124	/// @param to The new owner crossAccountId
1125	/// @param properties Properties of minted token
1126	/// @return uint256 The id of the newly minted token
1127	#[weight(<SelfWeightOf<T>>::create_item())]
1128	fn mint_cross(
1129		&mut self,
1130		caller: caller,
1131		to: EthCrossAccount,
1132		properties: Vec<PropertyStruct>,
1133	) -> Result<uint256> {
1134		let token_id = <TokensMinted<T>>::get(self.id)
1135			.checked_add(1)
1136			.ok_or("item id overflow")?;
1137
1138		let to = to.into_sub_cross_account::<T>()?;
1139
1140		let properties = properties
1141			.into_iter()
1142			.map(|PropertyStruct { key, value }| {
1143				let key = <Vec<u8>>::from(key)
1144					.try_into()
1145					.map_err(|_| "key too large")?;
1146
1147				let value = value.0.try_into().map_err(|_| "value too large")?;
1148
1149				Ok(Property { key, value })
1150			})
1151			.collect::<Result<Vec<_>>>()?
1152			.try_into()
1153			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;
1154
1155		let caller = T::CrossAccountId::from_eth(caller);
1156
1157		let budget = self
1158			.recorder
1159			.weight_calls_budget(<StructureWeight<T>>::find_parent());
1160
1161		let users = [(to, 1)]
1162			.into_iter()
1163			.collect::<BTreeMap<_, _>>()
1164			.try_into()
1165			.unwrap();
1166		<Pallet<T>>::create_item(
1167			self,
1168			&caller,
1169			CreateItemData::<T> { users, properties },
1170			&budget,
1171		)
1172		.map_err(dispatch_to_evm::<T>)?;
1173
1174		Ok(token_id.into())
1175	}
11221176
1123	/// Returns EVM address for refungible token1177	/// Returns EVM address for refungible token
1124	///1178	///