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

11RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none11RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
1212
13ARG RUST_TOOLCHAIN=13ARG RUST_TOOLCHAIN=
14ARG POLKADOT_BUILD_BRANCH=
14ARG BRANCH=15ARG BRANCH=
15ARG REPO_URL=16ARG REPO_URL=
16ARG FEATURE=17ARG FEATURE=
2526
26RUN cargo build --release27RUN cargo build --release
2728
28CMD cargo run --release $FEATURE -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external29CMD cargo run --release --features=$FEATURE -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external
2930

38RUN mkdir /unique_parachain38RUN mkdir /unique_parachain
39WORKDIR /unique_parachain39WORKDIR /unique_parachain
4040
41RUN git clone $REPO_URL -b $BRANCH41RUN git clone $REPO_URL -b $BRANCH && \
42RUN cargo build --features=$FEATURE --$PROFILE42    cargo build --features=$FEATURE --$PROFILE
4343
44
45# ===== BUILD POLKADOT =====44# ===== BUILD POLKADOT =====
46FROM rust-builder as builder-polkadot45FROM rust-builder as builder-polkadot
4746

10        - "FEATURE={{ FEATURE }}"10        - "FEATURE={{ FEATURE }}"
11        - "POLKADOT_BUILD_BRANCH={{ POLKADOT_BUILD_BRANCH }}"11        - "POLKADOT_BUILD_BRANCH={{ POLKADOT_BUILD_BRANCH }}"
1212
13    command: cargo run --release {{ FEATURE }} -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external13    command: cargo run --release --features=$FEATURE -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external
1414

1.git/1.git/
2.github/2.github/
3.docker/
4doc/3doc/
5target/4target/
6tests/5tests/

5UNIQUE_MAINNET_TAG=v9240105UNIQUE_MAINNET_TAG=v924010
66
7KUSAMA_MAINNET_BRANCH=release-v0.9.267KUSAMA_MAINNET_BRANCH=release-v0.9.26
8QUARTZ_MAINNET_TAG=v9240128QUARTZ_MAINNET_TAG=quartz-v924012-2
9

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

2120
22# A workflow run is made up of one or more jobs that can run sequentially or in parallel21# A workflow run is made up of one or more jobs that can run sequentially or in parallel
23jobs:22jobs:
24  build:23  dev_build_test:
25    # The type of runner that the job will run on24    # The type of runner that the job will run on
26    runs-on: self-hosted-ci25    runs-on: self-hosted-ci
2726

9      - reopened9      - reopened
10      - synchronize10      - synchronize
11jobs:11jobs:
12  build:12  code_style:
13    runs-on: self-hosted-ci13    runs-on: self-hosted-ci
1414
15    steps:15    steps:

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",
5308 "pallet-balances",5309 "pallet-balances",
5309 "pallet-base-fee",5310 "pallet-base-fee",
5310 "pallet-common",5311 "pallet-common",
5312 "pallet-configuration",
5311 "pallet-ethereum",5313 "pallet-ethereum",
5312 "pallet-evm",5314 "pallet-evm",
5313 "pallet-evm-coder-substrate",5315 "pallet-evm-coder-substrate",
5352 "sp-transaction-pool",5354 "sp-transaction-pool",
5353 "sp-version",5355 "sp-version",
5354 "substrate-wasm-builder",5356 "substrate-wasm-builder",
5355 "unique-runtime-common",5357 "up-common",
5356 "up-data-structs",5358 "up-data-structs",
5357 "up-rpc",5359 "up-rpc",
5360 "up-sponsorship",
5358 "xcm",5361 "xcm",
5359 "xcm-builder",5362 "xcm-builder",
5360 "xcm-executor",5363 "xcm-executor",
5741 "up-data-structs",5744 "up-data-structs",
5742]5745]
5746
5747[[package]]
5748name = "pallet-configuration"
5749version = "0.1.0"
5750dependencies = [
5751 "fp-evm",
5752 "frame-support",
5753 "frame-system",
5754 "parity-scale-codec 3.1.5",
5755 "scale-info",
5756 "smallvec",
5757 "sp-arithmetic",
5758 "sp-core",
5759 "sp-runtime",
5760 "sp-std",
5761]
57435762
5744[[package]]5763[[package]]
5745name = "pallet-democracy"5764name = "pallet-democracy"
58695888
5870[[package]]5889[[package]]
5871name = "pallet-evm-coder-substrate"5890name = "pallet-evm-coder-substrate"
5872version = "0.1.1"5891version = "0.1.2"
5873dependencies = [5892dependencies = [
5874 "ethereum",5893 "ethereum",
5875 "evm-coder",5894 "evm-coder",
8605 "cumulus-primitives-timestamp",8624 "cumulus-primitives-timestamp",
8606 "cumulus-primitives-utility",8625 "cumulus-primitives-utility",
8607 "derivative",8626 "derivative",
8627 "evm-coder",
8608 "fp-evm-mapping",8628 "fp-evm-mapping",
8609 "fp-rpc",8629 "fp-rpc",
8610 "fp-self-contained",8630 "fp-self-contained",
8622 "pallet-balances",8642 "pallet-balances",
8623 "pallet-base-fee",8643 "pallet-base-fee",
8624 "pallet-common",8644 "pallet-common",
8645 "pallet-configuration",
8625 "pallet-ethereum",8646 "pallet-ethereum",
8626 "pallet-evm",8647 "pallet-evm",
8627 "pallet-evm-coder-substrate",8648 "pallet-evm-coder-substrate",
8666 "sp-transaction-pool",8687 "sp-transaction-pool",
8667 "sp-version",8688 "sp-version",
8668 "substrate-wasm-builder",8689 "substrate-wasm-builder",
8669 "unique-runtime-common",8690 "up-common",
8670 "up-data-structs",8691 "up-data-structs",
8671 "up-rpc",8692 "up-rpc",
8693 "up-sponsorship",
8672 "xcm",8694 "xcm",
8673 "xcm-builder",8695 "xcm-builder",
8674 "xcm-executor",8696 "xcm-executor",
11881name = "tests"11903name = "tests"
11882version = "0.1.0"11904version = "0.1.0"
11883dependencies = [11905dependencies = [
11906 "evm-coder",
11884 "fp-evm-mapping",11907 "fp-evm-mapping",
11885 "frame-support",11908 "frame-support",
11886 "frame-system",11909 "frame-system",
11902 "sp-io",11925 "sp-io",
11903 "sp-runtime",11926 "sp-runtime",
11904 "sp-std",11927 "sp-std",
11905 "unique-runtime-common",
11906 "up-data-structs",11928 "up-data-structs",
11929 "up-sponsorship",
11907]11930]
1190811931
11909[[package]]11932[[package]]
1237412397
12375[[package]]12398[[package]]
12376name = "uc-rpc"12399name = "uc-rpc"
12377version = "0.1.1"12400version = "0.1.2"
12378dependencies = [12401dependencies = [
12379 "anyhow",12402 "anyhow",
12380 "jsonrpsee",12403 "jsonrpsee",
12387 "sp-core",12410 "sp-core",
12388 "sp-rpc",12411 "sp-rpc",
12389 "sp-runtime",12412 "sp-runtime",
12390 "unique-runtime-common",
12391 "up-data-structs",12413 "up-data-structs",
12392 "up-rpc",12414 "up-rpc",
12393]12415]
12541 "try-runtime-cli",12563 "try-runtime-cli",
12542 "unique-rpc",12564 "unique-rpc",
12543 "unique-runtime",12565 "unique-runtime",
12544 "unique-runtime-common",12566 "up-common",
12545 "up-data-structs",12567 "up-data-structs",
12546 "up-rpc",12568 "up-rpc",
12547]12569]
12590 "substrate-frame-rpc-system",12612 "substrate-frame-rpc-system",
12591 "tokio 0.2.25",12613 "tokio 0.2.25",
12592 "uc-rpc",12614 "uc-rpc",
12593 "unique-runtime-common",12615 "up-common",
12594 "up-data-structs",12616 "up-data-structs",
12595 "up-rpc",12617 "up-rpc",
12596]12618]
12608 "cumulus-primitives-timestamp",12630 "cumulus-primitives-timestamp",
12609 "cumulus-primitives-utility",12631 "cumulus-primitives-utility",
12610 "derivative",12632 "derivative",
12633 "evm-coder",
12611 "fp-evm-mapping",12634 "fp-evm-mapping",
12612 "fp-rpc",12635 "fp-rpc",
12613 "fp-self-contained",12636 "fp-self-contained",
12625 "pallet-balances",12648 "pallet-balances",
12626 "pallet-base-fee",12649 "pallet-base-fee",
12627 "pallet-common",12650 "pallet-common",
12651 "pallet-configuration",
12628 "pallet-ethereum",12652 "pallet-ethereum",
12629 "pallet-evm",12653 "pallet-evm",
12630 "pallet-evm-coder-substrate",12654 "pallet-evm-coder-substrate",
12669 "sp-transaction-pool",12693 "sp-transaction-pool",
12670 "sp-version",12694 "sp-version",
12671 "substrate-wasm-builder",12695 "substrate-wasm-builder",
12672 "unique-runtime-common",12696 "up-common",
12673 "up-data-structs",12697 "up-data-structs",
12674 "up-rpc",12698 "up-rpc",
12699 "up-sponsorship",
12675 "xcm",12700 "xcm",
12676 "xcm-builder",12701 "xcm-builder",
12677 "xcm-executor",12702 "xcm-executor",
12678]12703]
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]
1270512704
12706[[package]]12705[[package]]
12707name = "universal-hash"12706name = "universal-hash"
12731source = "registry+https://github.com/rust-lang/crates.io-index"12730source = "registry+https://github.com/rust-lang/crates.io-index"
12732checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"12731checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
12732
12733[[package]]
12734name = "up-common"
12735version = "0.9.24"
12736dependencies = [
12737 "fp-rpc",
12738 "frame-support",
12739 "pallet-evm",
12740 "sp-consensus-aura",
12741 "sp-core",
12742 "sp-runtime",
12743 "sp-std",
12744]
1273312745
12734[[package]]12746[[package]]
12735name = "up-data-structs"12747name = "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!

22
3All notable changes to this project will be documented in this file.3All notable changes to this project will be documented in this file.
44
5## [0.1.2] - 2022-08-12
6
7### Fixed
8
9-   Method signature `total_pieces`. Before that the number of pieces greater than 2^53 -1 caused an error when calling this method.
10
5## [0.1.1] - 2022-07-1411## [0.1.1] - 2022-07-14
612
7### Added13### Added
814
9 - Implementation of RPC method `token_owners` returning 10 owners in no particular order.15-   Implementation of RPC method `token_owners` returning 10 owners in no particular order.
10    This was an internal request to improve the web interface and support fractionalization event. 16    This was an internal request to improve the web interface and support fractionalization event.
11 17

1[package]1[package]
2name = "uc-rpc"2name = "uc-rpc"
3version = "0.1.1"3version = "0.1.2"
4license = "GPLv3"4license = "GPLv3"
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" }

242		collection_id: CollectionId,242		collection_id: CollectionId,
243		token_id: TokenId,243		token_id: TokenId,
244		at: Option<BlockHash>,244		at: Option<BlockHash>,
245	) -> Result<Option<u128>>;245	) -> Result<Option<String>>;
246}246}
247247
248mod rmrk_unique_rpc {248mod rmrk_unique_rpc {
518	pass_method!(collection_stats() -> CollectionStats, unique_api);518	pass_method!(collection_stats() -> CollectionStats, unique_api);
519	pass_method!(next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Option<u64>, unique_api);519	pass_method!(next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Option<u64>, unique_api);
520	pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>, unique_api);520	pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>, unique_api);
521	pass_method!(total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<u128>, unique_api);521	pass_method!(total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<String> => |o| o.map(|number| number.to_string()) , unique_api);
522	pass_method!(token_owners(collection: CollectionId, token: TokenId) -> Vec<CrossAccountId>, unique_api);522	pass_method!(token_owners(collection: CollectionId, token: TokenId) -> Vec<CrossAccountId>, unique_api);
523}523}
524524

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 operation 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,

1[package]1[package]
2name = "pallet-evm-coder-substrate"2name = "pallet-evm-coder-substrate"
3version = "0.1.1"3version = "0.1.2"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

261	let (selector, mut reader) = AbiReader::new_call(input)?;261	let (selector, mut reader) = AbiReader::new_call(input)?;
262	let call = C::parse(selector, &mut reader)?;262	let call = C::parse(selector, &mut reader)?;
263	if call.is_none() {263	if call.is_none() {
264		let selector = u32::from_be_bytes(selector);
264		return Ok(None);265		return Err(format!("unrecognized selector: 0x{selector:0<8x}").into());
265	}266	}
266	let call = call.unwrap();267	let call = call.unwrap();
267268

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 {