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

9ENV PATH="/cargo-home/bin:$PATH"9ENV PATH="/cargo-home/bin:$PATH"
1010
1111
12
13RUN apt-get update && \12RUN apt-get update && \
14    apt-get install -y curl cmake pkg-config libssl-dev git clang && \13    apt-get install -y curl cmake pkg-config libssl-dev git clang && \
15    apt-get clean && \14    apt-get clean && \
24    rustup show23    rustup show
25RUN rustup target add wasm32-unknown-unknown --toolchain $RUST_TOOLCHAIN24RUN rustup target add wasm32-unknown-unknown --toolchain $RUST_TOOLCHAIN
2625
27
28RUN mkdir /unique_parachain26RUN mkdir /unique_parachain
29WORKDIR /unique_parachain27WORKDIR /unique_parachain
3028
29
31# ===== BUILD ======30# ===== BUILD ======
32FROM rust-builder as builder-unique31FROM rust-builder as builder-unique
3332
4140
42RUN git clone $REPO_URL -b $BRANCH && \41RUN git clone $REPO_URL -b $BRANCH && \
43    cargo build --features=$FEATURE --$PROFILE42    cargo build --features=$FEATURE --$PROFILE
43
4444
45# ===== BUILD POLKADOT =====45# ===== BUILD POLKADOT =====
46FROM rust-builder as builder-polkadot46FROM rust-builder as builder-polkadot
60FROM ubuntu:20.0460FROM ubuntu:20.04
6161
62RUN apt-get -y update && \62RUN apt-get -y update && \
63      apt-get -y upgrade && \
64      apt-get -y install curl git && \63      apt-get -y install curl git && \
65      curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash && \64      curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash && \
66      export NVM_DIR="$HOME/.nvm" && \65      export NVM_DIR="$HOME/.nvm" && \

1* text=auto1* text=auto
2*.sh text eol=lf2*.sh text eol=lf
33*.ts linguist-detectable=false

32      matrix:32      matrix:
33        include:33        include:
34          - network: "Opal"34          - network: "Opal"
35            features: "--features=opal-runtime"35            features: " "
36          - network: "Quartz"36          - network: "Quartz"
37            features: "--features=quartz-runtime"37            features: "--features=quartz-runtime"
38          - network: "Unique"38          - network: "Unique"
57        if: github.event.pull_request.draft == true57        if: github.event.pull_request.draft == true
58        run: exit 158        run: exit 1
5959
60      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it60      - name: Clean Workspace
61        uses: AutoModality/action-clean@v1.1.0
62
63      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
61      - uses: actions/checkout@v364      - uses: actions/checkout@v3
62        with:65        with:
63          ref: ${{ github.head_ref }}  #Checking out head commit66          ref: ${{ github.head_ref }}  #Checking out head commit
70        with:73        with:
71          template: .docker/docker-compose.tmp.j274          template: .docker/docker-compose.tmp.j2
72          output_file: .docker/docker-compose.${{ matrix.network }}.yml75          output_file: .docker/docker-compose.${{ matrix.network }}.yml
73          variables: |76          variables: |
74            REPO_URL=${{ github.server_url }}/${{ github.repository }}.git77            REPO_URL=${{ github.server_url }}/${{ github.repository }}.git
75            RUST_TOOLCHAIN=${{ env.RUST_TOOLCHAIN }}78            RUST_TOOLCHAIN=${{ env.RUST_TOOLCHAIN }}
76            POLKADOT_BUILD_BRANCH=${{ env.POLKADOT_BUILD_BRANCH }}79            POLKADOT_BUILD_BRANCH=${{ env.POLKADOT_BUILD_BRANCH }}
77            FEATURE='${{ matrix.features }}'80            FEATURE=${{ matrix.features }}
78            BRANCH=${{ github.head_ref }}81            BRANCH=${{ github.head_ref }}
7982
80      - name: Show build configuration83      - name: Show build configuration
81        run: cat .docker/docker-compose.${{ matrix.network }}.yml84        run: cat .docker/docker-compose.${{ matrix.network }}.yml
100103
101      - name: Test Report104      - name: Test Report
102        uses: phoenix-actions/test-reporting@v8105        uses: phoenix-actions/test-reporting@v8
106        id: test-report
103        if: success() || failure()    # run this step even if previous step failed107        if: success() || failure()    # run this step even if previous step failed
104        with:108        with:
105          name: Tests ${{ matrix.network }}            # Name of the check run which will be created109          name: Tests ${{ matrix.network }}            # Name of the check run which will be created

5291 "cumulus-primitives-timestamp",5291 "cumulus-primitives-timestamp",
5292 "cumulus-primitives-utility",5292 "cumulus-primitives-utility",
5293 "derivative",5293 "derivative",
5294 "evm-coder",
5294 "fp-evm-mapping",5295 "fp-evm-mapping",
5295 "fp-rpc",5296 "fp-rpc",
5296 "fp-self-contained",5297 "fp-self-contained",
5352 "sp-transaction-pool",5353 "sp-transaction-pool",
5353 "sp-version",5354 "sp-version",
5354 "substrate-wasm-builder",5355 "substrate-wasm-builder",
5355 "unique-runtime-common",5356 "up-common",
5356 "up-data-structs",5357 "up-data-structs",
5357 "up-rpc",5358 "up-rpc",
5359 "up-sponsorship",
5358 "xcm",5360 "xcm",
5359 "xcm-builder",5361 "xcm-builder",
5360 "xcm-executor",5362 "xcm-executor",
8605 "cumulus-primitives-timestamp",8607 "cumulus-primitives-timestamp",
8606 "cumulus-primitives-utility",8608 "cumulus-primitives-utility",
8607 "derivative",8609 "derivative",
8610 "evm-coder",
8608 "fp-evm-mapping",8611 "fp-evm-mapping",
8609 "fp-rpc",8612 "fp-rpc",
8610 "fp-self-contained",8613 "fp-self-contained",
8666 "sp-transaction-pool",8669 "sp-transaction-pool",
8667 "sp-version",8670 "sp-version",
8668 "substrate-wasm-builder",8671 "substrate-wasm-builder",
8669 "unique-runtime-common",8672 "up-common",
8670 "up-data-structs",8673 "up-data-structs",
8671 "up-rpc",8674 "up-rpc",
8675 "up-sponsorship",
8672 "xcm",8676 "xcm",
8673 "xcm-builder",8677 "xcm-builder",
8674 "xcm-executor",8678 "xcm-executor",
11881name = "tests"11885name = "tests"
11882version = "0.1.0"11886version = "0.1.0"
11883dependencies = [11887dependencies = [
11888 "evm-coder",
11884 "fp-evm-mapping",11889 "fp-evm-mapping",
11885 "frame-support",11890 "frame-support",
11886 "frame-system",11891 "frame-system",
11902 "sp-io",11907 "sp-io",
11903 "sp-runtime",11908 "sp-runtime",
11904 "sp-std",11909 "sp-std",
11905 "unique-runtime-common",
11906 "up-data-structs",11910 "up-data-structs",
11911 "up-sponsorship",
11907]11912]
1190811913
11909[[package]]11914[[package]]
12387 "sp-core",12392 "sp-core",
12388 "sp-rpc",12393 "sp-rpc",
12389 "sp-runtime",12394 "sp-runtime",
12390 "unique-runtime-common",
12391 "up-data-structs",12395 "up-data-structs",
12392 "up-rpc",12396 "up-rpc",
12393]12397]
12541 "try-runtime-cli",12545 "try-runtime-cli",
12542 "unique-rpc",12546 "unique-rpc",
12543 "unique-runtime",12547 "unique-runtime",
12544 "unique-runtime-common",12548 "up-common",
12545 "up-data-structs",12549 "up-data-structs",
12546 "up-rpc",12550 "up-rpc",
12547]12551]
12590 "substrate-frame-rpc-system",12594 "substrate-frame-rpc-system",
12591 "tokio 0.2.25",12595 "tokio 0.2.25",
12592 "uc-rpc",12596 "uc-rpc",
12593 "unique-runtime-common",12597 "up-common",
12594 "up-data-structs",12598 "up-data-structs",
12595 "up-rpc",12599 "up-rpc",
12596]12600]
12608 "cumulus-primitives-timestamp",12612 "cumulus-primitives-timestamp",
12609 "cumulus-primitives-utility",12613 "cumulus-primitives-utility",
12610 "derivative",12614 "derivative",
12615 "evm-coder",
12611 "fp-evm-mapping",12616 "fp-evm-mapping",
12612 "fp-rpc",12617 "fp-rpc",
12613 "fp-self-contained",12618 "fp-self-contained",
12669 "sp-transaction-pool",12674 "sp-transaction-pool",
12670 "sp-version",12675 "sp-version",
12671 "substrate-wasm-builder",12676 "substrate-wasm-builder",
12672 "unique-runtime-common",12677 "up-common",
12673 "up-data-structs",12678 "up-data-structs",
12674 "up-rpc",12679 "up-rpc",
12680 "up-sponsorship",
12675 "xcm",12681 "xcm",
12676 "xcm-builder",12682 "xcm-builder",
12677 "xcm-executor",12683 "xcm-executor",
12678]12684]
12679
12680[[package]]
12681name = "unique-runtime-common"
12682version = "0.9.24"
12683dependencies = [
12684 "evm-coder",
12685 "fp-rpc",
12686 "frame-support",
12687 "frame-system",
12688 "pallet-common",
12689 "pallet-evm",
12690 "pallet-fungible",
12691 "pallet-nonfungible",
12692 "pallet-refungible",
12693 "pallet-unique",
12694 "pallet-unique-scheduler",
12695 "parity-scale-codec 3.1.5",
12696 "rmrk-rpc",
12697 "scale-info",
12698 "sp-consensus-aura",
12699 "sp-core",
12700 "sp-runtime",
12701 "sp-std",
12702 "up-data-structs",
12703 "up-sponsorship",
12704]
1270512685
12706[[package]]12686[[package]]
12707name = "universal-hash"12687name = "universal-hash"
12731source = "registry+https://github.com/rust-lang/crates.io-index"12711source = "registry+https://github.com/rust-lang/crates.io-index"
12732checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"12712checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
12713
12714[[package]]
12715name = "up-common"
12716version = "0.9.24"
12717dependencies = [
12718 "fp-rpc",
12719 "frame-support",
12720 "pallet-evm",
12721 "sp-consensus-aura",
12722 "sp-core",
12723 "sp-runtime",
12724 "sp-std",
12725]
1273312726
12734[[package]]12727[[package]]
12735name = "up-data-structs"12728name = "up-data-structs"

2323
24Wider Unique Ecosystem (most of it was developed during Hackusama):24Wider Unique Ecosystem (most of it was developed during Hackusama):
2525
26-   [SubstraPunks Game hosted on IPFS](https://github.com/usetech-llc/substrapunks)26-   [SubstraPunks Game hosted on IPFS](https://github.com/UniqueNetwork/substrapunks)
27-   [Unique Wallet and UI](https://uniqueapps.usetech.com/#/nft)27-   [Unique Wallet and UI](https://wallet.unique.network)
28-   [NFT Asset for Unity Framework](https://github.com/usetech-llc/nft_unity)28-   [NFT Asset for Unity Framework](https://github.com/usetech-llc/nft_unity)
2929
30Please see our [walk-through instructions](doc/hackusama_walk_through.md) to try everything out!30Please see our [walk-through instructions](doc/hackusama_walk_through.md) to try everything out!

5edition = "2021"5edition = "2021"
66
7[dependencies]7[dependencies]
8unique-runtime-common = { default-features = false, path = "../../runtime/common" }
9pallet-common = { default-features = false, path = '../../pallets/common' }8pallet-common = { default-features = false, path = '../../pallets/common' }
10up-data-structs = { default-features = false, path = '../../primitives/data-structs' }9up-data-structs = { default-features = false, path = '../../primitives/data-structs' }
11up-rpc = { path = "../../primitives/rpc" }10up-rpc = { path = "../../primitives/rpc" }

253################################################################################253################################################################################
254# Local dependencies254# Local dependencies
255255
256[dependencies.unique-runtime-common]256[dependencies.up-common]
257default-features = false
258path = "../../runtime/common"257path = "../../primitives/common"
259258
260[dependencies.unique-runtime]259[dependencies.unique-runtime]
261path = '../../runtime/unique'260path = '../../runtime/unique'

23use serde::{Deserialize, Serialize};23use serde::{Deserialize, Serialize};
24use serde_json::map::Map;24use serde_json::map::Map;
2525
26use unique_runtime_common::types::*;26use up_common::types::opaque::*;
2727
28#[cfg(feature = "unique-runtime")]28#[cfg(feature = "unique-runtime")]
29pub use unique_runtime as default_runtime;29pub use unique_runtime as default_runtime;

64use sp_runtime::traits::{AccountIdConversion, Block as BlockT};64use sp_runtime::traits::{AccountIdConversion, Block as BlockT};
65use std::{io::Write, net::SocketAddr, time::Duration};65use std::{io::Write, net::SocketAddr, time::Duration};
6666
67use unique_runtime_common::types::Block;67use up_common::types::opaque::Block;
6868
69macro_rules! no_runtime_err {69macro_rules! no_runtime_err {
70	($chain_name:expr) => {70	($chain_name:expr) => {

63use fc_rpc_core::types::FilterPool;63use fc_rpc_core::types::FilterPool;
64use fc_mapping_sync::{MappingSyncWorker, SyncStrategy};64use fc_mapping_sync::{MappingSyncWorker, SyncStrategy};
6565
66use unique_runtime_common::types::{AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block};66use up_common::types::opaque::{AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block};
6767
68// RMRK68// RMRK
69use up_data_structs::{69use up_data_structs::{

49fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }49fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }
5050
51pallet-common = { default-features = false, path = "../../pallets/common" }51pallet-common = { default-features = false, path = "../../pallets/common" }
52unique-runtime-common = { default-features = false, path = "../../runtime/common" }52up-common = { path = "../../primitives/common" }
53pallet-unique = { path = "../../pallets/unique" }53pallet-unique = { path = "../../pallets/unique" }
54uc-rpc = { path = "../../client/rpc" }54uc-rpc = { path = "../../client/rpc" }
55up-rpc = { path = "../../primitives/rpc" }55up-rpc = { path = "../../primitives/rpc" }

40use sc_service::TransactionPool;40use sc_service::TransactionPool;
41use std::{collections::BTreeMap, sync::Arc};41use std::{collections::BTreeMap, sync::Arc};
4242
43use unique_runtime_common::types::{43use up_common::types::opaque::{Hash, AccountId, RuntimeInstance, Index, Block, BlockNumber, Balance};
44	Hash, AccountId, RuntimeInstance, Index, Block, BlockNumber, Balance,44
45};
46// RMRK45// RMRK
47use up_data_structs::{46use up_data_structs::{

25use pallet_evm_coder_substrate::dispatch_to_evm;25use pallet_evm_coder_substrate::dispatch_to_evm;
26use sp_std::vec::Vec;26use sp_std::vec::Vec;
27use up_data_structs::{27use up_data_structs::{
28	Property, SponsoringRateLimit, OwnerRestrictedSet, AccessMode, CollectionPermissions,28	AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,
29	SponsoringRateLimit,
29};30};
30use alloc::format;31use alloc::format;
3132
409		save(self)410		save(self)
410	}411	}
412
413	/// Check that account is the owner or admin of the collection
414	///
415	/// @param user account to verify
416	/// @return "true" if account is the owner or admin
417	fn verify_owner_or_admin(&self, user: address) -> Result<bool> {
418		Ok(check_is_owner_or_admin(user, self)
419			.map(|_| true)
420			.unwrap_or(false))
421	}
422
423	/// Returns collection type
424	///
425	/// @return `Fungible` or `NFT` or `ReFungible`
426	fn unique_collection_type(&mut self) -> Result<string> {
427		let mode = match self.collection.mode {
428			CollectionMode::Fungible(_) => "Fungible",
429			CollectionMode::NFT => "NFT",
430			CollectionMode::ReFungible => "ReFungible",
431		};
432		Ok(mode.into())
433	}
411}434}
412435
413fn check_is_owner_or_admin<T: Config>(436fn check_is_owner_or_admin<T: Config>(
463			property_key_from_bytes(b"suffix").expect(EXPECT_CONVERT_ERROR)486			property_key_from_bytes(b"suffix").expect(EXPECT_CONVERT_ERROR)
464		}487		}
488
489		/// Key "parentNft".
490		pub fn parent_nft() -> up_data_structs::PropertyKey {
491			property_key_from_bytes(b"parentNft").expect(EXPECT_CONVERT_ERROR)
492		}
465	}493	}
466494
467	/// Values.495	/// Values.

535535
536		/// Can't transfer tokens to ethereum zero address536		/// Can't transfer tokens to ethereum zero address
537		AddressIsZero,537		AddressIsZero,
538		/// Target collection doesn't support this operation538
539		/// The oprtation is not supported
539		UnsupportedOperation,540		UnsupportedOperation,
540541
541		/// Insufficient funds to perform an action542		/// Insufficient funds to perform an action
1111		collection: &CollectionHandle<T>,1112		collection: &CollectionHandle<T>,
1112		sender: &T::CrossAccountId,1113		sender: &T::CrossAccountId,
1113		property_permission: PropertyKeyPermission,1114		property_permission: PropertyKeyPermission,
1114	) -> DispatchResult {1115	) -> DispatchResult {
1116		Self::set_scoped_property_permission(
1117			collection,
1118			sender,
1119			PropertyScope::None,
1120			property_permission,
1121		)
1122	}
1123
1124	/// Set collection property permission with scope.
1125	///
1126	/// * `collection` - Collection handler.
1127	/// * `sender` - The owner or administrator of the collection.
1128	/// * `scope` - Property scope.
1129	/// * `property_permission` - Property permission.
1130	pub fn set_scoped_property_permission(
1131		collection: &CollectionHandle<T>,
1132		sender: &T::CrossAccountId,
1133		scope: PropertyScope,
1134		property_permission: PropertyKeyPermission,
1135	) -> DispatchResult {
1115		collection.check_is_owner_or_admin(sender)?;1136		collection.check_is_owner_or_admin(sender)?;
11161137
1117		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1138		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);
11251146
1126		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1147		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {
1127			let property_permission = property_permission.clone();1148			let property_permission = property_permission.clone();
1128			permissions.try_set(property_permission.key, property_permission.permission)1149			permissions.try_scoped_set(
1150				scope,
1151				property_permission.key,
1152				property_permission.permission,
1153			)
1129		})1154		})
1130		.map_err(<Error<T>>::from)?;1155		.map_err(<Error<T>>::from)?;
1147		collection: &CollectionHandle<T>,1172		collection: &CollectionHandle<T>,
1148		sender: &T::CrossAccountId,1173		sender: &T::CrossAccountId,
1149		property_permissions: Vec<PropertyKeyPermission>,1174		property_permissions: Vec<PropertyKeyPermission>,
1150	) -> DispatchResult {1175	) -> DispatchResult {
1176		Self::set_scoped_token_property_permissions(
1177			collection,
1178			sender,
1179			PropertyScope::None,
1180			property_permissions,
1181		)
1182	}
1183
1184	/// Set token property permission with scope.
1185	///
1186	/// * `collection` - Collection handler.
1187	/// * `sender` - The owner or administrator of the collection.
1188	/// * `scope` - Property scope.
1189	/// * `property_permissions` - Property permissions.
1190	#[transactional]
1191	pub fn set_scoped_token_property_permissions(
1192		collection: &CollectionHandle<T>,
1193		sender: &T::CrossAccountId,
1194		scope: PropertyScope,
1195		property_permissions: Vec<PropertyKeyPermission>,
1196	) -> DispatchResult {
1151		for prop_pemission in property_permissions {1197		for prop_pemission in property_permissions {
1152			Self::set_property_permission(collection, sender, prop_pemission)?;1198			Self::set_scoped_property_permission(collection, sender, scope, prop_pemission)?;
1153		}1199		}
11541200
1155		Ok(())1201		Ok(())
1353/// Indicates unsupported methods by returning [Error::UnsupportedOperation].1399/// Indicates unsupported methods by returning [Error::UnsupportedOperation].
1354#[macro_export]1400#[macro_export]
1355macro_rules! unsupported {1401macro_rules! unsupported {
1356	() => {1402	($runtime:path) => {
1357		Err(<Error<T>>::UnsupportedOperation.into())1403		Err($crate::Error::<$runtime>::UnsupportedOperation.into())
1358	};1404	};
1359}1405}
13601406
1430			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))1476			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))
1431	}1477	}
1478
1479	/// The price of retrieving token owner
1480	fn token_owner() -> Weight;
1432}1481}
14331482
1434/// Weight info extension trait for refungible pallet.1483/// Weight info extension trait for refungible pallet.
1567	///1616	///
1568	/// * `sender` - Must be either the owner of the token or its admin.1617	/// * `sender` - Must be either the owner of the token or its admin.
1569	/// * `token_id` - The token for which the properties are being set.1618	/// * `token_id` - The token for which the properties are being set.
1570	/// * `properties` - Properties to be set.1619	/// * `property_permissions` - Property permissions to be set.
1571	/// * `budget` - Budget for setting properties.1620	/// * `budget` - Budget for setting properties.
1572	fn set_token_property_permissions(1621	fn set_token_property_permissions(
1573		&self,1622		&self,

104		0104		0
105	}105	}
106
107	fn token_owner() -> Weight {
108		0
109	}
106}110}
107111
108/// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete112/// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete

binary blob — no preview

31	);31	);
32}32}
33
34// Selector: 6cf113cd
35contract Collection is Dummy, ERC165 {
36	// Set collection property.
37	//
38	// @param key Property key.
39	// @param value Propery value.
40	//
41	// Selector: setCollectionProperty(string,bytes) 2f073f66
42	function setCollectionProperty(string memory key, bytes memory value)
43		public
44	{
45		require(false, stub_error);
46		key;
47		value;
48		dummy = 0;
49	}
50
51	// Delete collection property.
52	//
53	// @param key Property key.
54	//
55	// Selector: deleteCollectionProperty(string) 7b7debce
56	function deleteCollectionProperty(string memory key) public {
57		require(false, stub_error);
58		key;
59		dummy = 0;
60	}
61
62	// Get collection property.
63	//
64	// @dev Throws error if key not found.
65	//
66	// @param key Property key.
67	// @return bytes The property corresponding to the key.
68	//
69	// Selector: collectionProperty(string) cf24fd6d
70	function collectionProperty(string memory key)
71		public
72		view
73		returns (bytes memory)
74	{
75		require(false, stub_error);
76		key;
77		dummy;
78		return hex"";
79	}
80
81	// Set the sponsor of the collection.
82	//
83	// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
84	//
85	// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
86	//
87	// Selector: setCollectionSponsor(address) 7623402e
88	function setCollectionSponsor(address sponsor) public {
89		require(false, stub_error);
90		sponsor;
91		dummy = 0;
92	}
93
94	// Collection sponsorship confirmation.
95	//
96	// @dev After setting the sponsor for the collection, it must be confirmed with this function.
97	//
98	// Selector: confirmCollectionSponsorship() 3c50e97a
99	function confirmCollectionSponsorship() public {
100		require(false, stub_error);
101		dummy = 0;
102	}
103
104	// Set limits for the collection.
105	// @dev Throws error if limit not found.
106	// @param limit Name of the limit. Valid names:
107	// 	"accountTokenOwnershipLimit",
108	// 	"sponsoredDataSize",
109	// 	"sponsoredDataRateLimit",
110	// 	"tokenLimit",
111	// 	"sponsorTransferTimeout",
112	// 	"sponsorApproveTimeout"
113	// @param value Value of the limit.
114	//
115	// Selector: setCollectionLimit(string,uint32) 6a3841db
116	function setCollectionLimit(string memory limit, uint32 value) public {
117		require(false, stub_error);
118		limit;
119		value;
120		dummy = 0;
121	}
122
123	// Set limits for the collection.
124	// @dev Throws error if limit not found.
125	// @param limit Name of the limit. Valid names:
126	// 	"ownerCanTransfer",
127	// 	"ownerCanDestroy",
128	// 	"transfersEnabled"
129	// @param value Value of the limit.
130	//
131	// Selector: setCollectionLimit(string,bool) 993b7fba
132	function setCollectionLimit(string memory limit, bool value) public {
133		require(false, stub_error);
134		limit;
135		value;
136		dummy = 0;
137	}
138
139	// Get contract address.
140	//
141	// Selector: contractAddress() f6b4dfb4
142	function contractAddress() public view returns (address) {
143		require(false, stub_error);
144		dummy;
145		return 0x0000000000000000000000000000000000000000;
146	}
147
148	// Add collection admin by substrate address.
149	// @param new_admin Substrate administrator address.
150	//
151	// Selector: addCollectionAdminSubstrate(uint256) 5730062b
152	function addCollectionAdminSubstrate(uint256 newAdmin) public {
153		require(false, stub_error);
154		newAdmin;
155		dummy = 0;
156	}
157
158	// Remove collection admin by substrate address.
159	// @param admin Substrate administrator address.
160	//
161	// Selector: removeCollectionAdminSubstrate(uint256) 4048fcf9
162	function removeCollectionAdminSubstrate(uint256 admin) public {
163		require(false, stub_error);
164		admin;
165		dummy = 0;
166	}
167
168	// Add collection admin.
169	// @param new_admin Address of the added administrator.
170	//
171	// Selector: addCollectionAdmin(address) 92e462c7
172	function addCollectionAdmin(address newAdmin) public {
173		require(false, stub_error);
174		newAdmin;
175		dummy = 0;
176	}
177
178	// Remove collection admin.
179	//
180	// @param new_admin Address of the removed administrator.
181	//
182	// Selector: removeCollectionAdmin(address) fafd7b42
183	function removeCollectionAdmin(address admin) public {
184		require(false, stub_error);
185		admin;
186		dummy = 0;
187	}
188
189	// Toggle accessibility of collection nesting.
190	//
191	// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
192	//
193	// Selector: setCollectionNesting(bool) 112d4586
194	function setCollectionNesting(bool enable) public {
195		require(false, stub_error);
196		enable;
197		dummy = 0;
198	}
199
200	// Toggle accessibility of collection nesting.
201	//
202	// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'
203	// @param collections Addresses of collections that will be available for nesting.
204	//
205	// Selector: setCollectionNesting(bool,address[]) 64872396
206	function setCollectionNesting(bool enable, address[] memory collections)
207		public
208	{
209		require(false, stub_error);
210		enable;
211		collections;
212		dummy = 0;
213	}
214
215	// Set the collection access method.
216	// @param mode Access mode
217	// 	0 for Normal
218	// 	1 for AllowList
219	//
220	// Selector: setCollectionAccess(uint8) 41835d4c
221	function setCollectionAccess(uint8 mode) public {
222		require(false, stub_error);
223		mode;
224		dummy = 0;
225	}
226
227	// Add the user to the allowed list.
228	//
229	// @param user Address of a trusted user.
230	//
231	// Selector: addToCollectionAllowList(address) 67844fe6
232	function addToCollectionAllowList(address user) public {
233		require(false, stub_error);
234		user;
235		dummy = 0;
236	}
237
238	// Remove the user from the allowed list.
239	//
240	// @param user Address of a removed user.
241	//
242	// Selector: removeFromCollectionAllowList(address) 85c51acb
243	function removeFromCollectionAllowList(address user) public {
244		require(false, stub_error);
245		user;
246		dummy = 0;
247	}
248
249	// Switch permission for minting.
250	//
251	// @param mode Enable if "true".
252	//
253	// Selector: setCollectionMintMode(bool) 00018e84
254	function setCollectionMintMode(bool mode) public {
255		require(false, stub_error);
256		mode;
257		dummy = 0;
258	}
259
260	// Check that account is the owner or admin of the collection
261	//
262	// @param user account to verify
263	// @return "true" if account is the owner or admin
264	//
265	// Selector: verifyOwnerOrAdmin(address) c2282493
266	function verifyOwnerOrAdmin(address user) public view returns (bool) {
267		require(false, stub_error);
268		user;
269		dummy;
270		return false;
271	}
272
273	// Returns collection type
274	//
275	// @return `Fungible` or `NFT` or `ReFungible`
276	//
277	// Selector: uniqueCollectionType() d34b55b8
278	function uniqueCollectionType() public returns (string memory) {
279		require(false, stub_error);
280		dummy = 0;
281		return "";
282	}
283}
33284
34// Selector: 79cc6790285// Selector: 79cc6790
35contract ERC20UniqueExtensions is Dummy, ERC165 {286contract ERC20UniqueExtensions is Dummy, ERC165 {
43	}294	}
44}295}
45
46// Selector: 7d9262e6
47contract Collection is Dummy, ERC165 {
48	// Set collection property.
49	//
50	// @param key Property key.
51	// @param value Propery value.
52	//
53	// Selector: setCollectionProperty(string,bytes) 2f073f66
54	function setCollectionProperty(string memory key, bytes memory value)
55		public
56	{
57		require(false, stub_error);
58		key;
59		value;
60		dummy = 0;
61	}
62
63	// Delete collection property.
64	//
65	// @param key Property key.
66	//
67	// Selector: deleteCollectionProperty(string) 7b7debce
68	function deleteCollectionProperty(string memory key) public {
69		require(false, stub_error);
70		key;
71		dummy = 0;
72	}
73
74	// Get collection property.
75	//
76	// @dev Throws error if key not found.
77	//
78	// @param key Property key.
79	// @return bytes The property corresponding to the key.
80	//
81	// Selector: collectionProperty(string) cf24fd6d
82	function collectionProperty(string memory key)
83		public
84		view
85		returns (bytes memory)
86	{
87		require(false, stub_error);
88		key;
89		dummy;
90		return hex"";
91	}
92
93	// Set the sponsor of the collection.
94	//
95	// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
96	//
97	// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
98	//
99	// Selector: setCollectionSponsor(address) 7623402e
100	function setCollectionSponsor(address sponsor) public {
101		require(false, stub_error);
102		sponsor;
103		dummy = 0;
104	}
105
106	// Collection sponsorship confirmation.
107	//
108	// @dev After setting the sponsor for the collection, it must be confirmed with this function.
109	//
110	// Selector: confirmCollectionSponsorship() 3c50e97a
111	function confirmCollectionSponsorship() public {
112		require(false, stub_error);
113		dummy = 0;
114	}
115
116	// Set limits for the collection.
117	// @dev Throws error if limit not found.
118	// @param limit Name of the limit. Valid names:
119	// 	"accountTokenOwnershipLimit",
120	// 	"sponsoredDataSize",
121	// 	"sponsoredDataRateLimit",
122	// 	"tokenLimit",
123	// 	"sponsorTransferTimeout",
124	// 	"sponsorApproveTimeout"
125	// @param value Value of the limit.
126	//
127	// Selector: setCollectionLimit(string,uint32) 6a3841db
128	function setCollectionLimit(string memory limit, uint32 value) public {
129		require(false, stub_error);
130		limit;
131		value;
132		dummy = 0;
133	}
134
135	// Set limits for the collection.
136	// @dev Throws error if limit not found.
137	// @param limit Name of the limit. Valid names:
138	// 	"ownerCanTransfer",
139	// 	"ownerCanDestroy",
140	// 	"transfersEnabled"
141	// @param value Value of the limit.
142	//
143	// Selector: setCollectionLimit(string,bool) 993b7fba
144	function setCollectionLimit(string memory limit, bool value) public {
145		require(false, stub_error);
146		limit;
147		value;
148		dummy = 0;
149	}
150
151	// Get contract address.
152	//
153	// Selector: contractAddress() f6b4dfb4
154	function contractAddress() public view returns (address) {
155		require(false, stub_error);
156		dummy;
157		return 0x0000000000000000000000000000000000000000;
158	}
159
160	// Add collection admin by substrate address.
161	// @param new_admin Substrate administrator address.
162	//
163	// Selector: addCollectionAdminSubstrate(uint256) 5730062b
164	function addCollectionAdminSubstrate(uint256 newAdmin) public {
165		require(false, stub_error);
166		newAdmin;
167		dummy = 0;
168	}
169
170	// Remove collection admin by substrate address.
171	// @param admin Substrate administrator address.
172	//
173	// Selector: removeCollectionAdminSubstrate(uint256) 4048fcf9
174	function removeCollectionAdminSubstrate(uint256 admin) public {
175		require(false, stub_error);
176		admin;
177		dummy = 0;
178	}
179
180	// Add collection admin.
181	// @param new_admin Address of the added administrator.
182	//
183	// Selector: addCollectionAdmin(address) 92e462c7
184	function addCollectionAdmin(address newAdmin) public {
185		require(false, stub_error);
186		newAdmin;
187		dummy = 0;
188	}
189
190	// Remove collection admin.
191	//
192	// @param new_admin Address of the removed administrator.
193	//
194	// Selector: removeCollectionAdmin(address) fafd7b42
195	function removeCollectionAdmin(address admin) public {
196		require(false, stub_error);
197		admin;
198		dummy = 0;
199	}
200
201	// Toggle accessibility of collection nesting.
202	//
203	// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
204	//
205	// Selector: setCollectionNesting(bool) 112d4586
206	function setCollectionNesting(bool enable) public {
207		require(false, stub_error);
208		enable;
209		dummy = 0;
210	}
211
212	// Toggle accessibility of collection nesting.
213	//
214	// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'
215	// @param collections Addresses of collections that will be available for nesting.
216	//
217	// Selector: setCollectionNesting(bool,address[]) 64872396
218	function setCollectionNesting(bool enable, address[] memory collections)
219		public
220	{
221		require(false, stub_error);
222		enable;
223		collections;
224		dummy = 0;
225	}
226
227	// Set the collection access method.
228	// @param mode Access mode
229	// 	0 for Normal
230	// 	1 for AllowList
231	//
232	// Selector: setCollectionAccess(uint8) 41835d4c
233	function setCollectionAccess(uint8 mode) public {
234		require(false, stub_error);
235		mode;
236		dummy = 0;
237	}
238
239	// Add the user to the allowed list.
240	//
241	// @param user Address of a trusted user.
242	//
243	// Selector: addToCollectionAllowList(address) 67844fe6
244	function addToCollectionAllowList(address user) public {
245		require(false, stub_error);
246		user;
247		dummy = 0;
248	}
249
250	// Remove the user from the allowed list.
251	//
252	// @param user Address of a removed user.
253	//
254	// Selector: removeFromCollectionAllowList(address) 85c51acb
255	function removeFromCollectionAllowList(address user) public {
256		require(false, stub_error);
257		user;
258		dummy = 0;
259	}
260
261	// Switch permission for minting.
262	//
263	// @param mode Enable if "true".
264	//
265	// Selector: setCollectionMintMode(bool) 00018e84
266	function setCollectionMintMode(bool mode) public {
267		require(false, stub_error);
268		mode;
269		dummy = 0;
270	}
271}
272296
273// Selector: 942e8b22297// Selector: 942e8b22
274contract ERC20 is Dummy, ERC165, ERC20Events {298contract ERC20 is Dummy, ERC165, ERC20Events {