git.delta.rocks / unique-network / refs/commits / 53625bbe3192

244	fn set_collection_sponsor_cross(244	fn set_collection_sponsor_cross(
245		&mut self,245		&mut self,
246		caller: caller,246		caller: caller,
247		sponsor: eth::CrossAccount,247		sponsor: eth::CrossAddress,
248	) -> Result<void> {248	) -> Result<void> {
249		self.consume_store_reads_and_writes(1, 1)?;249		self.consume_store_reads_and_writes(1, 1)?;
250250
284	/// Get current sponsor.284	/// Get current sponsor.
285	///285	///
286	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.286	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
287	fn collection_sponsor(&self) -> Result<eth::CrossAccount> {287	fn collection_sponsor(&self) -> Result<eth::CrossAddress> {
288		let sponsor = match self.collection.sponsorship.sponsor() {288		let sponsor = match self.collection.sponsorship.sponsor() {
289			Some(sponsor) => sponsor,289			Some(sponsor) => sponsor,
290			None => return Ok(Default::default()),290			None => return Ok(Default::default()),
291		};291		};
292292
293		Ok(eth::CrossAccount::from_sub::<T>(&sponsor))293		Ok(eth::CrossAddress::from_sub::<T>(&sponsor))
294	}294	}
295295
296	/// Get current collection limits.296	/// Get current collection limits.
376	fn add_collection_admin_cross(376	fn add_collection_admin_cross(
377		&mut self,377		&mut self,
378		caller: caller,378		caller: caller,
379		new_admin: eth::CrossAccount,379		new_admin: eth::CrossAddress,
380	) -> Result<void> {380	) -> Result<void> {
381		self.consume_store_reads_and_writes(2, 2)?;381		self.consume_store_reads_and_writes(2, 2)?;
382382
391	fn remove_collection_admin_cross(391	fn remove_collection_admin_cross(
392		&mut self,392		&mut self,
393		caller: caller,393		caller: caller,
394		admin: eth::CrossAccount,394		admin: eth::CrossAddress,
395	) -> Result<void> {395	) -> Result<void> {
396		self.consume_store_reads_and_writes(2, 2)?;396		self.consume_store_reads_and_writes(2, 2)?;
397397
539	/// Checks that user allowed to operate with collection.539	/// Checks that user allowed to operate with collection.
540	///540	///
541	/// @param user User address to check.541	/// @param user User address to check.
542	fn allowlisted_cross(&self, user: eth::CrossAccount) -> Result<bool> {542	fn allowlisted_cross(&self, user: eth::CrossAddress) -> Result<bool> {
543		let user = user.into_sub_cross_account::<T>()?;543		let user = user.into_sub_cross_account::<T>()?;
544		Ok(Pallet::<T>::allowed(self.id, user))544		Ok(Pallet::<T>::allowed(self.id, user))
545	}545	}
563	fn add_to_collection_allow_list_cross(563	fn add_to_collection_allow_list_cross(
564		&mut self,564		&mut self,
565		caller: caller,565		caller: caller,
566		user: eth::CrossAccount,566		user: eth::CrossAddress,
567	) -> Result<void> {567	) -> Result<void> {
568		self.consume_store_writes(1)?;568		self.consume_store_writes(1)?;
569569
592	fn remove_from_collection_allow_list_cross(592	fn remove_from_collection_allow_list_cross(
593		&mut self,593		&mut self,
594		caller: caller,594		caller: caller,
595		user: eth::CrossAccount,595		user: eth::CrossAddress,
596	) -> Result<void> {596	) -> Result<void> {
597		self.consume_store_writes(1)?;597		self.consume_store_writes(1)?;
598598
630	///630	///
631	/// @param user User cross account to verify631	/// @param user User cross account to verify
632	/// @return "true" if account is the owner or admin632	/// @return "true" if account is the owner or admin
633	fn is_owner_or_admin_cross(&self, user: eth::CrossAccount) -> Result<bool> {633	fn is_owner_or_admin_cross(&self, user: eth::CrossAddress) -> Result<bool> {
634		let user = user.into_sub_cross_account::<T>()?;634		let user = user.into_sub_cross_account::<T>()?;
635		Ok(self.is_owner_or_admin(&user))635		Ok(self.is_owner_or_admin(&user))
636	}636	}
651	///651	///
652	/// @return Tuble with sponsor address and his substrate mirror.652	/// @return Tuble with sponsor address and his substrate mirror.
653	/// If address is canonical then substrate mirror is zero and vice versa.653	/// If address is canonical then substrate mirror is zero and vice versa.
654	fn collection_owner(&self) -> Result<eth::CrossAccount> {654	fn collection_owner(&self) -> Result<eth::CrossAddress> {
655		Ok(eth::CrossAccount::from_sub_cross_account::<T>(655		Ok(eth::CrossAddress::from_sub_cross_account::<T>(
656			&T::CrossAccountId::from_sub(self.owner.clone()),656			&T::CrossAccountId::from_sub(self.owner.clone()),
657		))657		))
658	}658	}
675	///675	///
676	/// @return Vector of tuples with admins address and his substrate mirror.676	/// @return Vector of tuples with admins address and his substrate mirror.
677	/// If address is canonical then substrate mirror is zero and vice versa.677	/// If address is canonical then substrate mirror is zero and vice versa.
678	fn collection_admins(&self) -> Result<Vec<eth::CrossAccount>> {678	fn collection_admins(&self) -> Result<Vec<eth::CrossAddress>> {
679		let result = crate::IsAdmin::<T>::iter_prefix((self.id,))679		let result = crate::IsAdmin::<T>::iter_prefix((self.id,))
680			.map(|(admin, _)| eth::CrossAccount::from_sub_cross_account::<T>(&admin))680			.map(|(admin, _)| eth::CrossAddress::from_sub_cross_account::<T>(&admin))
681			.collect();681			.collect();
682		Ok(result)682		Ok(result)
683	}683	}
689	fn change_collection_owner_cross(689	fn change_collection_owner_cross(
690		&mut self,690		&mut self,
691		caller: caller,691		caller: caller,
692		new_owner: eth::CrossAccount,692		new_owner: eth::CrossAddress,
693	) -> Result<void> {693	) -> Result<void> {
694		self.consume_store_writes(1)?;694		self.consume_store_writes(1)?;
695695

118118
119/// Cross account struct119/// Cross account struct
120#[derive(Debug, Default, AbiCoder)]120#[derive(Debug, Default, AbiCoder)]
121pub struct CrossAccount {121pub struct CrossAddress {
122	pub(crate) eth: address,122	pub(crate) eth: address,
123	pub(crate) sub: uint256,123	pub(crate) sub: uint256,
124}124}
125125
126impl CrossAccount {126impl CrossAddress {
127	/// Converts `CrossAccountId` to [`CrossAccount`]127	/// Converts `CrossAccountId` to [`CrossAddress`]
128	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self128	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self
129	where129	where
130		T: pallet_evm::Config,130		T: pallet_evm::Config,
139			}139			}
140		}140		}
141	}141	}
142	/// Creates [`CrossAccount`] from substrate account142	/// Creates [`CrossAddress`] from substrate account
143	pub fn from_sub<T>(account_id: &T::AccountId) -> Self143	pub fn from_sub<T>(account_id: &T::AccountId) -> Self
144	where144	where
145		T: pallet_evm::Config,145		T: pallet_evm::Config,
150			sub: uint256::from_big_endian(account_id.as_ref()),150			sub: uint256::from_big_endian(account_id.as_ref()),
151		}151		}
152	}152	}
153	/// Converts [`CrossAccount`] to `CrossAccountId`153	/// Converts [`CrossAddress`] to `CrossAccountId`
154	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>154	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>
155	where155	where
156		T: pallet_evm::Config,156		T: pallet_evm::Config,

174	///174	///
175	/// @param contractAddress The contract for which a sponsor is requested.175	/// @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.176	/// @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<pallet_common::eth::CrossAccount> {177	fn sponsor(&self, contract_address: address) -> Result<pallet_common::eth::CrossAddress> {
178		Ok(178		Ok(
179			pallet_common::eth::CrossAccount::from_sub_cross_account::<T>(179			pallet_common::eth::CrossAddress::from_sub_cross_account::<T>(
180				&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")?,
181			),181			),
182		)182		)

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 (CrossAccount memory) {99	function sponsor(address contractAddress) public view returns (CrossAddress memory) {
100		require(false, stub_error);100		require(false, stub_error);
101		contractAddress;101		contractAddress;
102		dummy;102		dummy;
103		return CrossAccount(0x0000000000000000000000000000000000000000, 0);103		return CrossAddress(0x0000000000000000000000000000000000000000, 0);
104	}104	}
105105
106	/// Check tat contract has confirmed sponsor.106	/// Check tat contract has confirmed sponsor.
266}266}
267267
268/// @dev Cross account struct268/// @dev Cross account struct
269struct CrossAccount {269struct CrossAddress {
270	address eth;270	address eth;
271	uint256 sub;271	uint256 sub;
272}272}

177	fn mint_cross(177	fn mint_cross(
178		&mut self,178		&mut self,
179		caller: caller,179		caller: caller,
180		to: pallet_common::eth::CrossAccount,180		to: pallet_common::eth::CrossAddress,
181		amount: uint256,181		amount: uint256,
182	) -> Result<bool> {182	) -> Result<bool> {
183		let caller = T::CrossAccountId::from_eth(caller);183		let caller = T::CrossAccountId::from_eth(caller);
195	fn approve_cross(195	fn approve_cross(
196		&mut self,196		&mut self,
197		caller: caller,197		caller: caller,
198		spender: pallet_common::eth::CrossAccount,198		spender: pallet_common::eth::CrossAddress,
199		amount: uint256,199		amount: uint256,
200	) -> Result<bool> {200	) -> Result<bool> {
201		let caller = T::CrossAccountId::from_eth(caller);201		let caller = T::CrossAccountId::from_eth(caller);
236	fn burn_from_cross(236	fn burn_from_cross(
237		&mut self,237		&mut self,
238		caller: caller,238		caller: caller,
239		from: pallet_common::eth::CrossAccount,239		from: pallet_common::eth::CrossAddress,
240		amount: uint256,240		amount: uint256,
241	) -> Result<bool> {241	) -> Result<bool> {
242		let caller = T::CrossAccountId::from_eth(caller);242		let caller = T::CrossAccountId::from_eth(caller);
278	fn transfer_cross(278	fn transfer_cross(
279		&mut self,279		&mut self,
280		caller: caller,280		caller: caller,
281		to: pallet_common::eth::CrossAccount,281		to: pallet_common::eth::CrossAddress,
282		amount: uint256,282		amount: uint256,
283	) -> Result<bool> {283	) -> Result<bool> {
284		let caller = T::CrossAccountId::from_eth(caller);284		let caller = T::CrossAccountId::from_eth(caller);
296	fn transfer_from_cross(296	fn transfer_from_cross(
297		&mut self,297		&mut self,
298		caller: caller,298		caller: caller,
299		from: pallet_common::eth::CrossAccount,299		from: pallet_common::eth::CrossAddress,
300		to: pallet_common::eth::CrossAccount,300		to: pallet_common::eth::CrossAddress,
301		amount: uint256,301		amount: uint256,
302	) -> Result<bool> {302	) -> Result<bool> {
303		let caller = T::CrossAccountId::from_eth(caller);303		let caller = T::CrossAccountId::from_eth(caller);

binary blob — no preview

114	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.114	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.
115	/// @dev EVM selector for this function is: 0x84a1d5a8,115	/// @dev EVM selector for this function is: 0x84a1d5a8,
116	///  or in textual repr: setCollectionSponsorCross((address,uint256))116	///  or in textual repr: setCollectionSponsorCross((address,uint256))
117	function setCollectionSponsorCross(CrossAccount memory sponsor) public {117	function setCollectionSponsorCross(CrossAddress memory sponsor) public {
118		require(false, stub_error);118		require(false, stub_error);
119		sponsor;119		sponsor;
120		dummy = 0;120		dummy = 0;
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 (CrossAccount memory) {155	function collectionSponsor() public view returns (CrossAddress memory) {
156		require(false, stub_error);156		require(false, stub_error);
157		dummy;157		dummy;
158		return CrossAccount(0x0000000000000000000000000000000000000000, 0);158		return CrossAddress(0x0000000000000000000000000000000000000000, 0);
159	}159	}
160160
161	/// Get current collection limits.161	/// Get current collection limits.
193	/// @param newAdmin Cross account administrator address.193	/// @param newAdmin Cross account administrator address.
194	/// @dev EVM selector for this function is: 0x859aa7d6,194	/// @dev EVM selector for this function is: 0x859aa7d6,
195	///  or in textual repr: addCollectionAdminCross((address,uint256))195	///  or in textual repr: addCollectionAdminCross((address,uint256))
196	function addCollectionAdminCross(CrossAccount memory newAdmin) public {196	function addCollectionAdminCross(CrossAddress memory newAdmin) public {
197		require(false, stub_error);197		require(false, stub_error);
198		newAdmin;198		newAdmin;
199		dummy = 0;199		dummy = 0;
203	/// @param admin Cross account administrator address.203	/// @param admin Cross account administrator address.
204	/// @dev EVM selector for this function is: 0x6c0cd173,204	/// @dev EVM selector for this function is: 0x6c0cd173,
205	///  or in textual repr: removeCollectionAdminCross((address,uint256))205	///  or in textual repr: removeCollectionAdminCross((address,uint256))
206	function removeCollectionAdminCross(CrossAccount memory admin) public {206	function removeCollectionAdminCross(CrossAddress memory admin) public {
207		require(false, stub_error);207		require(false, stub_error);
208		admin;208		admin;
209		dummy = 0;209		dummy = 0;
289	/// @param user User address to check.289	/// @param user User address to check.
290	/// @dev EVM selector for this function is: 0x91b6df49,290	/// @dev EVM selector for this function is: 0x91b6df49,
291	///  or in textual repr: allowlistedCross((address,uint256))291	///  or in textual repr: allowlistedCross((address,uint256))
292	function allowlistedCross(CrossAccount memory user) public view returns (bool) {292	function allowlistedCross(CrossAddress memory user) public view returns (bool) {
293		require(false, stub_error);293		require(false, stub_error);
294		user;294		user;
295		dummy;295		dummy;
312	/// @param user User cross account address.312	/// @param user User cross account address.
313	/// @dev EVM selector for this function is: 0xa0184a3a,313	/// @dev EVM selector for this function is: 0xa0184a3a,
314	///  or in textual repr: addToCollectionAllowListCross((address,uint256))314	///  or in textual repr: addToCollectionAllowListCross((address,uint256))
315	function addToCollectionAllowListCross(CrossAccount memory user) public {315	function addToCollectionAllowListCross(CrossAddress memory user) public {
316		require(false, stub_error);316		require(false, stub_error);
317		user;317		user;
318		dummy = 0;318		dummy = 0;
334	/// @param user User cross account address.334	/// @param user User cross account address.
335	/// @dev EVM selector for this function is: 0x09ba452a,335	/// @dev EVM selector for this function is: 0x09ba452a,
336	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))336	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))
337	function removeFromCollectionAllowListCross(CrossAccount memory user) public {337	function removeFromCollectionAllowListCross(CrossAddress memory user) public {
338		require(false, stub_error);338		require(false, stub_error);
339		user;339		user;
340		dummy = 0;340		dummy = 0;
370	/// @return "true" if account is the owner or admin370	/// @return "true" if account is the owner or admin
371	/// @dev EVM selector for this function is: 0x3e75a905,371	/// @dev EVM selector for this function is: 0x3e75a905,
372	///  or in textual repr: isOwnerOrAdminCross((address,uint256))372	///  or in textual repr: isOwnerOrAdminCross((address,uint256))
373	function isOwnerOrAdminCross(CrossAccount memory user) public view returns (bool) {373	function isOwnerOrAdminCross(CrossAddress memory user) public view returns (bool) {
374		require(false, stub_error);374		require(false, stub_error);
375		user;375		user;
376		dummy;376		dummy;
394	/// If address is canonical then substrate mirror is zero and vice versa.394	/// If address is canonical then substrate mirror is zero and vice versa.
395	/// @dev EVM selector for this function is: 0xdf727d3b,395	/// @dev EVM selector for this function is: 0xdf727d3b,
396	///  or in textual repr: collectionOwner()396	///  or in textual repr: collectionOwner()
397	function collectionOwner() public view returns (CrossAccount memory) {397	function collectionOwner() public view returns (CrossAddress memory) {
398		require(false, stub_error);398		require(false, stub_error);
399		dummy;399		dummy;
400		return CrossAccount(0x0000000000000000000000000000000000000000, 0);400		return CrossAddress(0x0000000000000000000000000000000000000000, 0);
401	}401	}
402402
403	// /// Changes collection owner to another account403	// /// Changes collection owner to another account
418	/// If address is canonical then substrate mirror is zero and vice versa.418	/// If address is canonical then substrate mirror is zero and vice versa.
419	/// @dev EVM selector for this function is: 0x5813216b,419	/// @dev EVM selector for this function is: 0x5813216b,
420	///  or in textual repr: collectionAdmins()420	///  or in textual repr: collectionAdmins()
421	function collectionAdmins() public view returns (CrossAccount[] memory) {421	function collectionAdmins() public view returns (CrossAddress[] memory) {
422		require(false, stub_error);422		require(false, stub_error);
423		dummy;423		dummy;
424		return new CrossAccount[](0);424		return new CrossAddress[](0);
425	}425	}
426426
427	/// Changes collection owner to another account427	/// Changes collection owner to another account
430	/// @param newOwner new owner cross account430	/// @param newOwner new owner cross account
431	/// @dev EVM selector for this function is: 0x6496c497,431	/// @dev EVM selector for this function is: 0x6496c497,
432	///  or in textual repr: changeCollectionOwnerCross((address,uint256))432	///  or in textual repr: changeCollectionOwnerCross((address,uint256))
433	function changeCollectionOwnerCross(CrossAccount memory newOwner) public {433	function changeCollectionOwnerCross(CrossAddress memory newOwner) public {
434		require(false, stub_error);434		require(false, stub_error);
435		newOwner;435		newOwner;
436		dummy = 0;436		dummy = 0;
437	}437	}
438}438}
439439
440/// @dev Cross account struct440/// @dev Cross account struct
441struct CrossAccount {441struct CrossAddress {
442	address eth;442	address eth;
443	uint256 sub;443	uint256 sub;
444}444}
516516
517	/// @dev EVM selector for this function is: 0x269e6158,517	/// @dev EVM selector for this function is: 0x269e6158,
518	///  or in textual repr: mintCross((address,uint256),uint256)518	///  or in textual repr: mintCross((address,uint256),uint256)
519	function mintCross(CrossAccount memory to, uint256 amount) public returns (bool) {519	function mintCross(CrossAddress memory to, uint256 amount) public returns (bool) {
520		require(false, stub_error);520		require(false, stub_error);
521		to;521		to;
522		amount;522		amount;
526526
527	/// @dev EVM selector for this function is: 0x0ecd0ab0,527	/// @dev EVM selector for this function is: 0x0ecd0ab0,
528	///  or in textual repr: approveCross((address,uint256),uint256)528	///  or in textual repr: approveCross((address,uint256),uint256)
529	function approveCross(CrossAccount memory spender, uint256 amount) public returns (bool) {529	function approveCross(CrossAddress memory spender, uint256 amount) public returns (bool) {
530		require(false, stub_error);530		require(false, stub_error);
531		spender;531		spender;
532		amount;532		amount;
556	/// @param amount The amount that will be burnt.556	/// @param amount The amount that will be burnt.
557	/// @dev EVM selector for this function is: 0xbb2f5a58,557	/// @dev EVM selector for this function is: 0xbb2f5a58,
558	///  or in textual repr: burnFromCross((address,uint256),uint256)558	///  or in textual repr: burnFromCross((address,uint256),uint256)
559	function burnFromCross(CrossAccount memory from, uint256 amount) public returns (bool) {559	function burnFromCross(CrossAddress memory from, uint256 amount) public returns (bool) {
560		require(false, stub_error);560		require(false, stub_error);
561		from;561		from;
562		amount;562		amount;
577577
578	/// @dev EVM selector for this function is: 0x2ada85ff,578	/// @dev EVM selector for this function is: 0x2ada85ff,
579	///  or in textual repr: transferCross((address,uint256),uint256)579	///  or in textual repr: transferCross((address,uint256),uint256)
580	function transferCross(CrossAccount memory to, uint256 amount) public returns (bool) {580	function transferCross(CrossAddress memory to, uint256 amount) public returns (bool) {
581		require(false, stub_error);581		require(false, stub_error);
582		to;582		to;
583		amount;583		amount;
588	/// @dev EVM selector for this function is: 0xd5cf430b,588	/// @dev EVM selector for this function is: 0xd5cf430b,
589	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)589	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)
590	function transferFromCross(590	function transferFromCross(
591		CrossAccount memory from,591		CrossAddress memory from,
592		CrossAccount memory to,592		CrossAddress memory to,
593		uint256 amount593		uint256 amount
594	) public returns (bool) {594	) public returns (bool) {
595		require(false, stub_error);595		require(false, stub_error);

762	/// Returns the owner (in cross format) of the token.762	/// Returns the owner (in cross format) of the token.
763	///763	///
764	/// @param tokenId Id for the token.764	/// @param tokenId Id for the token.
765	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAccount> {765	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAddress> {
766		Self::token_owner(&self, token_id.try_into()?)766		Self::token_owner(&self, token_id.try_into()?)
767			.map(|o| pallet_common::eth::CrossAccount::from_sub_cross_account::<T>(&o))767			.map(|o| pallet_common::eth::CrossAddress::from_sub_cross_account::<T>(&o))
768			.ok_or(Error::Revert("key too large".into()))768			.ok_or(Error::Revert("key too large".into()))
769	}769	}
770770
812	fn approve_cross(812	fn approve_cross(
813		&mut self,813		&mut self,
814		caller: caller,814		caller: caller,
815		approved: pallet_common::eth::CrossAccount,815		approved: pallet_common::eth::CrossAddress,
816		token_id: uint256,816		token_id: uint256,
817	) -> Result<void> {817	) -> Result<void> {
818		let caller = T::CrossAccountId::from_eth(caller);818		let caller = T::CrossAccountId::from_eth(caller);
851	fn transfer_cross(851	fn transfer_cross(
852		&mut self,852		&mut self,
853		caller: caller,853		caller: caller,
854		to: pallet_common::eth::CrossAccount,854		to: pallet_common::eth::CrossAddress,
855		token_id: uint256,855		token_id: uint256,
856	) -> Result<void> {856	) -> Result<void> {
857		let caller = T::CrossAccountId::from_eth(caller);857		let caller = T::CrossAccountId::from_eth(caller);
875	fn transfer_from_cross(875	fn transfer_from_cross(
876		&mut self,876		&mut self,
877		caller: caller,877		caller: caller,
878		from: pallet_common::eth::CrossAccount,878		from: pallet_common::eth::CrossAddress,
879		to: pallet_common::eth::CrossAccount,879		to: pallet_common::eth::CrossAddress,
880		token_id: uint256,880		token_id: uint256,
881	) -> Result<void> {881	) -> Result<void> {
882		let caller = T::CrossAccountId::from_eth(caller);882		let caller = T::CrossAccountId::from_eth(caller);
922	fn burn_from_cross(922	fn burn_from_cross(
923		&mut self,923		&mut self,
924		caller: caller,924		caller: caller,
925		from: pallet_common::eth::CrossAccount,925		from: pallet_common::eth::CrossAddress,
926		token_id: uint256,926		token_id: uint256,
927	) -> Result<void> {927	) -> Result<void> {
928		let caller = T::CrossAccountId::from_eth(caller);928		let caller = T::CrossAccountId::from_eth(caller);
1044	fn mint_cross(1044	fn mint_cross(
1045		&mut self,1045		&mut self,
1046		caller: caller,1046		caller: caller,
1047		to: pallet_common::eth::CrossAccount,1047		to: pallet_common::eth::CrossAddress,
1048		properties: Vec<pallet_common::eth::Property>,1048		properties: Vec<pallet_common::eth::Property>,
1049	) -> Result<uint256> {1049	) -> Result<uint256> {
1050		let token_id = <TokensMinted<T>>::get(self.id)1050		let token_id = <TokensMinted<T>>::get(self.id)

binary blob — no preview

256	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.256	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.
257	/// @dev EVM selector for this function is: 0x84a1d5a8,257	/// @dev EVM selector for this function is: 0x84a1d5a8,
258	///  or in textual repr: setCollectionSponsorCross((address,uint256))258	///  or in textual repr: setCollectionSponsorCross((address,uint256))
259	function setCollectionSponsorCross(CrossAccount memory sponsor) public {259	function setCollectionSponsorCross(CrossAddress memory sponsor) public {
260		require(false, stub_error);260		require(false, stub_error);
261		sponsor;261		sponsor;
262		dummy = 0;262		dummy = 0;
294	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.294	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
295	/// @dev EVM selector for this function is: 0x6ec0a9f1,295	/// @dev EVM selector for this function is: 0x6ec0a9f1,
296	///  or in textual repr: collectionSponsor()296	///  or in textual repr: collectionSponsor()
297	function collectionSponsor() public view returns (CrossAccount memory) {297	function collectionSponsor() public view returns (CrossAddress memory) {
298		require(false, stub_error);298		require(false, stub_error);
299		dummy;299		dummy;
300		return CrossAccount(0x0000000000000000000000000000000000000000, 0);300		return CrossAddress(0x0000000000000000000000000000000000000000, 0);
301	}301	}
302302
303	/// Get current collection limits.303	/// Get current collection limits.
335	/// @param newAdmin Cross account administrator address.335	/// @param newAdmin Cross account administrator address.
336	/// @dev EVM selector for this function is: 0x859aa7d6,336	/// @dev EVM selector for this function is: 0x859aa7d6,
337	///  or in textual repr: addCollectionAdminCross((address,uint256))337	///  or in textual repr: addCollectionAdminCross((address,uint256))
338	function addCollectionAdminCross(CrossAccount memory newAdmin) public {338	function addCollectionAdminCross(CrossAddress memory newAdmin) public {
339		require(false, stub_error);339		require(false, stub_error);
340		newAdmin;340		newAdmin;
341		dummy = 0;341		dummy = 0;
345	/// @param admin Cross account administrator address.345	/// @param admin Cross account administrator address.
346	/// @dev EVM selector for this function is: 0x6c0cd173,346	/// @dev EVM selector for this function is: 0x6c0cd173,
347	///  or in textual repr: removeCollectionAdminCross((address,uint256))347	///  or in textual repr: removeCollectionAdminCross((address,uint256))
348	function removeCollectionAdminCross(CrossAccount memory admin) public {348	function removeCollectionAdminCross(CrossAddress memory admin) public {
349		require(false, stub_error);349		require(false, stub_error);
350		admin;350		admin;
351		dummy = 0;351		dummy = 0;
431	/// @param user User address to check.431	/// @param user User address to check.
432	/// @dev EVM selector for this function is: 0x91b6df49,432	/// @dev EVM selector for this function is: 0x91b6df49,
433	///  or in textual repr: allowlistedCross((address,uint256))433	///  or in textual repr: allowlistedCross((address,uint256))
434	function allowlistedCross(CrossAccount memory user) public view returns (bool) {434	function allowlistedCross(CrossAddress memory user) public view returns (bool) {
435		require(false, stub_error);435		require(false, stub_error);
436		user;436		user;
437		dummy;437		dummy;
454	/// @param user User cross account address.454	/// @param user User cross account address.
455	/// @dev EVM selector for this function is: 0xa0184a3a,455	/// @dev EVM selector for this function is: 0xa0184a3a,
456	///  or in textual repr: addToCollectionAllowListCross((address,uint256))456	///  or in textual repr: addToCollectionAllowListCross((address,uint256))
457	function addToCollectionAllowListCross(CrossAccount memory user) public {457	function addToCollectionAllowListCross(CrossAddress memory user) public {
458		require(false, stub_error);458		require(false, stub_error);
459		user;459		user;
460		dummy = 0;460		dummy = 0;
476	/// @param user User cross account address.476	/// @param user User cross account address.
477	/// @dev EVM selector for this function is: 0x09ba452a,477	/// @dev EVM selector for this function is: 0x09ba452a,
478	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))478	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))
479	function removeFromCollectionAllowListCross(CrossAccount memory user) public {479	function removeFromCollectionAllowListCross(CrossAddress memory user) public {
480		require(false, stub_error);480		require(false, stub_error);
481		user;481		user;
482		dummy = 0;482		dummy = 0;
512	/// @return "true" if account is the owner or admin512	/// @return "true" if account is the owner or admin
513	/// @dev EVM selector for this function is: 0x3e75a905,513	/// @dev EVM selector for this function is: 0x3e75a905,
514	///  or in textual repr: isOwnerOrAdminCross((address,uint256))514	///  or in textual repr: isOwnerOrAdminCross((address,uint256))
515	function isOwnerOrAdminCross(CrossAccount memory user) public view returns (bool) {515	function isOwnerOrAdminCross(CrossAddress memory user) public view returns (bool) {
516		require(false, stub_error);516		require(false, stub_error);
517		user;517		user;
518		dummy;518		dummy;
536	/// If address is canonical then substrate mirror is zero and vice versa.536	/// If address is canonical then substrate mirror is zero and vice versa.
537	/// @dev EVM selector for this function is: 0xdf727d3b,537	/// @dev EVM selector for this function is: 0xdf727d3b,
538	///  or in textual repr: collectionOwner()538	///  or in textual repr: collectionOwner()
539	function collectionOwner() public view returns (CrossAccount memory) {539	function collectionOwner() public view returns (CrossAddress memory) {
540		require(false, stub_error);540		require(false, stub_error);
541		dummy;541		dummy;
542		return CrossAccount(0x0000000000000000000000000000000000000000, 0);542		return CrossAddress(0x0000000000000000000000000000000000000000, 0);
543	}543	}
544544
545	// /// Changes collection owner to another account545	// /// Changes collection owner to another account
560	/// If address is canonical then substrate mirror is zero and vice versa.560	/// If address is canonical then substrate mirror is zero and vice versa.
561	/// @dev EVM selector for this function is: 0x5813216b,561	/// @dev EVM selector for this function is: 0x5813216b,
562	///  or in textual repr: collectionAdmins()562	///  or in textual repr: collectionAdmins()
563	function collectionAdmins() public view returns (CrossAccount[] memory) {563	function collectionAdmins() public view returns (CrossAddress[] memory) {
564		require(false, stub_error);564		require(false, stub_error);
565		dummy;565		dummy;
566		return new CrossAccount[](0);566		return new CrossAddress[](0);
567	}567	}
568568
569	/// Changes collection owner to another account569	/// Changes collection owner to another account
572	/// @param newOwner new owner cross account572	/// @param newOwner new owner cross account
573	/// @dev EVM selector for this function is: 0x6496c497,573	/// @dev EVM selector for this function is: 0x6496c497,
574	///  or in textual repr: changeCollectionOwnerCross((address,uint256))574	///  or in textual repr: changeCollectionOwnerCross((address,uint256))
575	function changeCollectionOwnerCross(CrossAccount memory newOwner) public {575	function changeCollectionOwnerCross(CrossAddress memory newOwner) public {
576		require(false, stub_error);576		require(false, stub_error);
577		newOwner;577		newOwner;
578		dummy = 0;578		dummy = 0;
579	}579	}
580}580}
581581
582/// @dev Cross account struct582/// @dev Cross account struct
583struct CrossAccount {583struct CrossAddress {
584	address eth;584	address eth;
585	uint256 sub;585	uint256 sub;
586}586}
817	/// @param tokenId Id for the token.817	/// @param tokenId Id for the token.
818	/// @dev EVM selector for this function is: 0x2b29dace,818	/// @dev EVM selector for this function is: 0x2b29dace,
819	///  or in textual repr: crossOwnerOf(uint256)819	///  or in textual repr: crossOwnerOf(uint256)
820	function crossOwnerOf(uint256 tokenId) public view returns (CrossAccount memory) {820	function crossOwnerOf(uint256 tokenId) public view returns (CrossAddress memory) {
821		require(false, stub_error);821		require(false, stub_error);
822		tokenId;822		tokenId;
823		dummy;823		dummy;
824		return CrossAccount(0x0000000000000000000000000000000000000000, 0);824		return CrossAddress(0x0000000000000000000000000000000000000000, 0);
825	}825	}
826826
827	/// Returns the token properties.827	/// Returns the token properties.
847	/// @param tokenId The NFT to approve847	/// @param tokenId The NFT to approve
848	/// @dev EVM selector for this function is: 0x0ecd0ab0,848	/// @dev EVM selector for this function is: 0x0ecd0ab0,
849	///  or in textual repr: approveCross((address,uint256),uint256)849	///  or in textual repr: approveCross((address,uint256),uint256)
850	function approveCross(CrossAccount memory approved, uint256 tokenId) public {850	function approveCross(CrossAddress memory approved, uint256 tokenId) public {
851		require(false, stub_error);851		require(false, stub_error);
852		approved;852		approved;
853		tokenId;853		tokenId;
875	/// @param tokenId The NFT to transfer875	/// @param tokenId The NFT to transfer
876	/// @dev EVM selector for this function is: 0x2ada85ff,876	/// @dev EVM selector for this function is: 0x2ada85ff,
877	///  or in textual repr: transferCross((address,uint256),uint256)877	///  or in textual repr: transferCross((address,uint256),uint256)
878	function transferCross(CrossAccount memory to, uint256 tokenId) public {878	function transferCross(CrossAddress memory to, uint256 tokenId) public {
879		require(false, stub_error);879		require(false, stub_error);
880		to;880		to;
881		tokenId;881		tokenId;
891	/// @dev EVM selector for this function is: 0xd5cf430b,891	/// @dev EVM selector for this function is: 0xd5cf430b,
892	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)892	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)
893	function transferFromCross(893	function transferFromCross(
894		CrossAccount memory from,894		CrossAddress memory from,
895		CrossAccount memory to,895		CrossAddress memory to,
896		uint256 tokenId896		uint256 tokenId
897	) public {897	) public {
898		require(false, stub_error);898		require(false, stub_error);
925	/// @param tokenId The NFT to transfer925	/// @param tokenId The NFT to transfer
926	/// @dev EVM selector for this function is: 0xbb2f5a58,926	/// @dev EVM selector for this function is: 0xbb2f5a58,
927	///  or in textual repr: burnFromCross((address,uint256),uint256)927	///  or in textual repr: burnFromCross((address,uint256),uint256)
928	function burnFromCross(CrossAccount memory from, uint256 tokenId) public {928	function burnFromCross(CrossAddress memory from, uint256 tokenId) public {
929		require(false, stub_error);929		require(false, stub_error);
930		from;930		from;
931		tokenId;931		tokenId;
977	/// @return uint256 The id of the newly minted token977	/// @return uint256 The id of the newly minted token
978	/// @dev EVM selector for this function is: 0xb904db03,978	/// @dev EVM selector for this function is: 0xb904db03,
979	///  or in textual repr: mintCross((address,uint256),(string,bytes)[])979	///  or in textual repr: mintCross((address,uint256),(string,bytes)[])
980	function mintCross(CrossAccount memory to, Property[] memory properties) public returns (uint256) {980	function mintCross(CrossAddress memory to, Property[] memory properties) public returns (uint256) {
981		require(false, stub_error);981		require(false, stub_error);
982		to;982		to;
983		properties;983		properties;