From 6d28dd8067cd5ae5e43f9e2af63c4ccdabb21fa9 Mon Sep 17 00:00:00 2001 From: Max Andreev Date: Fri, 16 Dec 2022 14:31:03 +0000 Subject: [PATCH] Merge branch 'develop' into tests/eth-helpers --- --- a/Cargo.lock +++ b/Cargo.lock @@ -2274,7 +2274,7 @@ "hash256-std-hasher", "rlp", "rlp-derive", - "sha3", + "sha3 0.10.6", "triehash", ] @@ -2292,7 +2292,7 @@ "rlp", "scale-info", "serde", - "sha3", + "sha3 0.10.6", "triehash", ] @@ -2350,7 +2350,7 @@ "rlp", "scale-info", "serde", - "sha3", + "sha3 0.10.6", ] [[package]] @@ -2380,7 +2380,7 @@ "hex", "proc-macro2", "quote", - "sha3", + "sha3 0.10.6", "syn", ] @@ -2415,7 +2415,7 @@ "environmental", "evm-core", "primitive-types 0.12.1", - "sha3", + "sha3 0.10.6", ] [[package]] @@ -4958,7 +4958,7 @@ "digest 0.10.6", "multihash-derive", "sha2 0.10.6", - "sha3", + "sha3 0.10.6", "unsigned-varint", ] @@ -5280,6 +5280,7 @@ "cumulus-primitives-utility", "derivative", "evm-coder", + "fp-evm", "fp-evm-mapping", "fp-rpc", "fp-self-contained", @@ -5294,6 +5295,7 @@ "impl-trait-for-tuples", "log", "logtest", + "num_enum", "orml-tokens", "orml-traits", "orml-vesting", @@ -5309,6 +5311,7 @@ "pallet-evm-coder-substrate", "pallet-evm-contract-helpers", "pallet-evm-migration", + "pallet-evm-precompile-simple", "pallet-evm-transaction-payment", "pallet-foreign-assets", "pallet-fungible", @@ -5333,6 +5336,7 @@ "parachain-info", "parity-scale-codec 3.2.1", "polkadot-parachain", + "precompile-utils-macro", "rmrk-rpc", "scale-info", "serde", @@ -6005,6 +6009,16 @@ ] [[package]] +name = "pallet-evm-precompile-simple" +version = "2.0.0-dev" +source = "git+https://github.com/uniquenetwork/frontier?branch=unique-polkadot-v0.9.33#c37ced433a29baad45899d6ab364fe437f97570e" +dependencies = [ + "fp-evm", + "ripemd", + "sp-io", +] + +[[package]] name = "pallet-evm-transaction-payment" version = "0.1.1" dependencies = [ @@ -6328,7 +6342,7 @@ [[package]] name = "pallet-nonfungible" -version = "0.1.9" +version = "0.1.11" dependencies = [ "ethereum 0.14.0", "evm-coder", @@ -6487,7 +6501,7 @@ [[package]] name = "pallet-refungible" -version = "0.2.8" +version = "0.2.10" dependencies = [ "derivative", "ethereum 0.14.0", @@ -8595,6 +8609,17 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" [[package]] +name = "precompile-utils-macro" +version = "0.1.0" +dependencies = [ + "num_enum", + "proc-macro2", + "quote", + "sha3 0.8.2", + "syn", +] + +[[package]] name = "predicates" version = "2.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -8850,6 +8875,7 @@ "cumulus-primitives-utility", "derivative", "evm-coder", + "fp-evm", "fp-evm-mapping", "fp-rpc", "fp-self-contained", @@ -8864,6 +8890,7 @@ "impl-trait-for-tuples", "log", "logtest", + "num_enum", "orml-tokens", "orml-traits", "orml-vesting", @@ -8879,6 +8906,7 @@ "pallet-evm-coder-substrate", "pallet-evm-contract-helpers", "pallet-evm-migration", + "pallet-evm-precompile-simple", "pallet-evm-transaction-payment", "pallet-foreign-assets", "pallet-fungible", @@ -8901,6 +8929,7 @@ "parachain-info", "parity-scale-codec 3.2.1", "polkadot-parachain", + "precompile-utils-macro", "rmrk-rpc", "scale-info", "serde", @@ -9249,6 +9278,15 @@ ] [[package]] +name = "ripemd" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd124222d17ad93a644ed9d011a40f4fb64aa54275c08cc216524a9ea82fb09f" +dependencies = [ + "digest 0.10.6", +] + +[[package]] name = "rlp" version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -10961,6 +10999,19 @@ [[package]] name = "sha3" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd26bc0e7a2e3a7c959bc494caf58b72ee0c71d67704e9520f736ca7e4853ecf" +dependencies = [ + "block-buffer 0.7.3", + "byte-tools", + "digest 0.8.1", + "keccak", + "opaque-debug 0.2.3", +] + +[[package]] +name = "sha3" version = "0.10.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bdf0c33fae925bdc080598b84bc15c55e7b9a4a43b3c704da051f977469691c9" @@ -11396,7 +11447,7 @@ "byteorder", "digest 0.10.6", "sha2 0.10.6", - "sha3", + "sha3 0.10.6", "sp-std", "twox-hash", ] @@ -13026,6 +13077,7 @@ "cumulus-primitives-utility", "derivative", "evm-coder", + "fp-evm", "fp-evm-mapping", "fp-rpc", "fp-self-contained", @@ -13040,6 +13092,7 @@ "impl-trait-for-tuples", "log", "logtest", + "num_enum", "orml-tokens", "orml-traits", "orml-vesting", @@ -13055,6 +13108,7 @@ "pallet-evm-coder-substrate", "pallet-evm-contract-helpers", "pallet-evm-migration", + "pallet-evm-precompile-simple", "pallet-evm-transaction-payment", "pallet-foreign-assets", "pallet-fungible", @@ -13077,6 +13131,7 @@ "parachain-info", "parity-scale-codec 3.2.1", "polkadot-parachain", + "precompile-utils-macro", "rmrk-rpc", "scale-info", "serde", --- a/crates/evm-coder/tests/abi_derive_generation.rs +++ b/crates/evm-coder/tests/abi_derive_generation.rs @@ -740,7 +740,7 @@ /// Some docs /// At multi /// line - #[derive(AbiCoder, Debug, PartialEq, Default)] + #[derive(AbiCoder, Debug, PartialEq, Default, Clone, Copy)] #[repr(u8)] enum Color { /// Docs for Red --- a/pallets/app-promotion/src/lib.rs +++ b/pallets/app-promotion/src/lib.rs @@ -564,7 +564,7 @@ /// # Arguments /// /// * `stakers_number`: the number of stakers for which recalculation will be performed - #[pallet::weight(::WeightInfo::payout_stakers(stakers_number.unwrap_or(20) as u32))] + #[pallet::weight(::WeightInfo::payout_stakers(stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS) as u32))] pub fn payout_stakers(admin: OriginFor, stakers_number: Option) -> DispatchResult { let admin_id = ensure_signed(admin)?; --- a/pallets/common/src/eth.rs +++ b/pallets/common/src/eth.rs @@ -162,3 +162,18 @@ CollectionAdmin, TokenOwner, } + +/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration. +#[derive(AbiCoder, Copy, Clone, Default, Debug)] +#[repr(u8)] +pub enum EthTokenPermissions { + /// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`] + #[default] + Mutable, + + /// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`] + TokenOwner, + + /// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`] + CollectionAdmin, +} --- a/pallets/common/src/lib.rs +++ b/pallets/common/src/lib.rs @@ -1222,7 +1222,8 @@ Ok(()) } - /// Set scouped collection property. + /// Set a scoped collection property, where the scope is a special prefix + /// prohibiting a user to change the property. /// /// * `collection_id` - ID of the collection for which the property is being set. /// * `scope` - Property scope. @@ -1240,7 +1241,8 @@ Ok(()) } - /// Set scouped collection properties. + /// Set scoped collection properties, where the scope is a special prefix + /// prohibiting a user to change the properties. /// /// * `collection_id` - ID of the collection for which the properties is being set. /// * `scope` - Property scope. --- a/pallets/configuration/src/lib.rs +++ b/pallets/configuration/src/lib.rs @@ -52,7 +52,7 @@ type DefaultMinGasPrice: Get; #[pallet::constant] - type MaxOverridedAllowedLocations: Get; + type MaxXcmAllowedLocations: Get; #[pallet::constant] type AppPromotionDailyRate: Get; #[pallet::constant] @@ -77,7 +77,7 @@ #[pallet::storage] pub type XcmAllowedLocationsOverride = StorageValue< - Value = BoundedVec, + Value = BoundedVec, QueryKind = OptionQuery, >; @@ -118,7 +118,7 @@ #[pallet::weight(T::DbWeight::get().writes(1))] pub fn set_xcm_allowed_locations( origin: OriginFor, - locations: Option>, + locations: Option>, ) -> DispatchResult { ensure_root(origin)?; >::set(locations); --- a/pallets/fungible/src/common.rs +++ b/pallets/fungible/src/common.rs @@ -18,7 +18,10 @@ use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get}; use up_data_structs::{TokenId, CollectionId, CreateItemExData, budget::Budget, CreateItemData}; -use pallet_common::{CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight}; +use pallet_common::{ + CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight, + weights::WeightInfo as _, +}; use pallet_structure::Error as StructureError; use sp_runtime::ArithmeticError; use sp_std::{vec::Vec, vec}; @@ -53,14 +56,12 @@ >::burn_item() } - fn set_collection_properties(_amount: u32) -> Weight { - // Error - Weight::zero() + fn set_collection_properties(amount: u32) -> Weight { + >::set_collection_properties(amount) } - fn delete_collection_properties(_amount: u32) -> Weight { - // Error - Weight::zero() + fn delete_collection_properties(amount: u32) -> Weight { + >::delete_collection_properties(amount) } fn set_token_properties(_amount: u32) -> Weight { @@ -294,18 +295,28 @@ fn set_collection_properties( &self, - _sender: T::CrossAccountId, - _property: Vec, + sender: T::CrossAccountId, + properties: Vec, ) -> DispatchResultWithPostInfo { - fail!(>::SettingPropertiesNotAllowed) + let weight = >::set_collection_properties(properties.len() as u32); + + with_weight( + >::set_collection_properties(self, &sender, properties), + weight, + ) } fn delete_collection_properties( &self, - _sender: &T::CrossAccountId, - _property_keys: Vec, + sender: &T::CrossAccountId, + property_keys: Vec, ) -> DispatchResultWithPostInfo { - fail!(>::SettingPropertiesNotAllowed) + let weight = >::delete_collection_properties(property_keys.len() as u32); + + with_weight( + >::delete_collection_properties(self, sender, property_keys), + weight, + ) } fn set_token_properties( --- a/pallets/fungible/src/lib.rs +++ b/pallets/fungible/src/lib.rs @@ -80,11 +80,11 @@ use core::ops::Deref; use evm_coder::ToLog; -use frame_support::{ensure}; +use frame_support::ensure; use pallet_evm::account::CrossAccountId; use up_data_structs::{ AccessMode, CollectionId, CollectionFlags, TokenId, CreateCollectionData, - mapping::TokenAddressMapping, budget::Budget, + mapping::TokenAddressMapping, budget::Budget, PropertyKey, Property, }; use pallet_common::{ Error as CommonError, Event as CommonEvent, Pallet as PalletCommon, @@ -260,7 +260,25 @@ Ok(()) } - ///Checks if collection has tokens. Return `true` if it has. + /// Add properties to the collection. + pub fn set_collection_properties( + collection: &FungibleHandle, + sender: &T::CrossAccountId, + properties: Vec, + ) -> DispatchResult { + >::set_collection_properties(collection, sender, properties) + } + + /// Delete properties of the collection, associated with the provided keys. + pub fn delete_collection_properties( + collection: &FungibleHandle, + sender: &T::CrossAccountId, + property_keys: Vec, + ) -> DispatchResult { + >::delete_collection_properties(collection, sender, property_keys) + } + + /// Checks if collection has tokens. Return `true` if it has. fn collection_has_tokens(collection_id: CollectionId) -> bool { >::get(collection_id) != 0 } --- a/pallets/nonfungible/CHANGELOG.md +++ b/pallets/nonfungible/CHANGELOG.md @@ -4,6 +4,16 @@ +## [0.1.11] - 2022-12-16 + +### Added + +- The function `tokenPropertyPermissions` and `setTokenPropertyPermissions` to `TokenProperties` interface. + +### Changed + +- Hide `setTokenPropertyPermission` function in `TokenProperties` interface. + ## [0.1.10] - 2022-11-18 ### Added --- a/pallets/nonfungible/Cargo.toml +++ b/pallets/nonfungible/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pallet-nonfungible" -version = "0.1.9" +version = "0.1.11" license = "GPLv3" edition = "2021" --- a/pallets/nonfungible/src/erc.rs +++ b/pallets/nonfungible/src/erc.rs @@ -34,11 +34,11 @@ CollectionPropertiesVec, }; use pallet_evm_coder_substrate::dispatch_to_evm; -use sp_std::vec::Vec; +use sp_std::{vec::Vec, vec}; use pallet_common::{ CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations, erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key}, - eth::EthCrossAccount, + eth::{EthCrossAccount, EthTokenPermissions}, }; use pallet_evm::{account::CrossAccountId, PrecompileHandle}; use pallet_evm_coder_substrate::call; @@ -60,6 +60,7 @@ /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. /// @param tokenOwner Permission to mutate property by token owner if property is mutable. #[weight(>::set_token_property_permissions(1))] + #[solidity(hide)] fn set_token_property_permission( &mut self, caller: caller, @@ -69,10 +70,10 @@ token_owner: bool, ) -> Result<()> { let caller = T::CrossAccountId::from_eth(caller); - >::set_property_permission( + >::set_token_property_permissions( self, &caller, - PropertyKeyPermission { + vec![PropertyKeyPermission { key: >::from(key) .try_into() .map_err(|_| "too long key")?, @@ -81,11 +82,78 @@ collection_admin, token_owner, }, - }, + }], ) .map_err(dispatch_to_evm::) } + /// @notice Set permissions for token property. + /// @dev Throws error if `msg.sender` is not admin or owner of the collection. + /// @param permissions Permissions for keys. + #[weight(>::set_token_property_permissions(permissions.len() as u32))] + fn set_token_property_permissions( + &mut self, + caller: caller, + permissions: Vec<(string, Vec<(EthTokenPermissions, bool)>)>, + ) -> Result<()> { + let caller = T::CrossAccountId::from_eth(caller); + const PERMISSIONS_FIELDS_COUNT: usize = 3; + + let mut perms = Vec::new(); + + for (key, pp) in permissions { + if pp.len() > PERMISSIONS_FIELDS_COUNT { + return Err(alloc::format!( + "Actual number of fields {} for {}, which exceeds the maximum value of {}", + pp.len(), + stringify!(EthTokenPermissions), + PERMISSIONS_FIELDS_COUNT + ) + .as_str() + .into()); + } + + let mut token_permission = PropertyPermission::default(); + + for (perm, value) in pp { + match perm { + EthTokenPermissions::Mutable => token_permission.mutable = value, + EthTokenPermissions::TokenOwner => token_permission.token_owner = value, + EthTokenPermissions::CollectionAdmin => { + token_permission.collection_admin = value + } + } + } + + perms.push(PropertyKeyPermission { + key: key.into_bytes().try_into().map_err(|_| "too long key")?, + permission: token_permission, + }); + } + + >::set_token_property_permissions(self, &caller, perms) + .map_err(dispatch_to_evm::) + } + + /// @notice Get permissions for token properties. + fn token_property_permissions( + &self, + ) -> Result)>> { + let perms = >::token_property_permission(self.id); + Ok(perms + .into_iter() + .map(|(key, pp)| { + let key = string::from_utf8(key.into_inner()).expect("Stored key must be valid"); + let pp = vec![ + (EthTokenPermissions::Mutable, pp.mutable), + (EthTokenPermissions::TokenOwner, pp.token_owner), + (EthTokenPermissions::CollectionAdmin, pp.collection_admin), + ]; + (key, pp) + }) + .collect()) + } + /// @notice Set token property value. /// @dev Throws error if `msg.sender` has no permission to edit the property. /// @param tokenId ID of the token. --- a/pallets/nonfungible/src/lib.rs +++ b/pallets/nonfungible/src/lib.rs @@ -103,7 +103,7 @@ AccessMode, CollectionId, CollectionFlags, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData, mapping::TokenAddressMapping, budget::Budget, Property, PropertyPermission, PropertyKey, PropertyValue, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, - TokenChild, AuxPropertyValue, + TokenChild, AuxPropertyValue, PropertiesPermissionMap, }; use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; use pallet_common::{ @@ -824,15 +824,8 @@ ) } - /// Set property permissions for the collection. - /// - /// Sender should be the owner or admin of the collection. - pub fn set_property_permission( - collection: &CollectionHandle, - sender: &T::CrossAccountId, - permission: PropertyKeyPermission, - ) -> DispatchResult { - >::set_property_permission(collection, sender, permission) + pub fn token_property_permission(collection_id: CollectionId) -> PropertiesPermissionMap { + >::property_permissions(collection_id) } pub fn check_token_immediate_ownership( --- a/pallets/nonfungible/src/stubs/UniqueNFT.sol +++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol @@ -18,30 +18,44 @@ } /// @title A contract that allows to set and delete token properties and change token property permissions. -/// @dev the ERC-165 identifier for this interface is 0x91a97a68 +/// @dev the ERC-165 identifier for this interface is 0xde0695c2 contract TokenProperties is Dummy, ERC165 { + // /// @notice Set permissions for token property. + // /// @dev Throws error if `msg.sender` is not admin or owner of the collection. + // /// @param key Property key. + // /// @param isMutable Permission to mutate property. + // /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. + // /// @param tokenOwner Permission to mutate property by token owner if property is mutable. + // /// @dev EVM selector for this function is: 0x222d97fa, + // /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool) + // function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public { + // require(false, stub_error); + // key; + // isMutable; + // collectionAdmin; + // tokenOwner; + // dummy = 0; + // } + /// @notice Set permissions for token property. /// @dev Throws error if `msg.sender` is not admin or owner of the collection. - /// @param key Property key. - /// @param isMutable Permission to mutate property. - /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. - /// @param tokenOwner Permission to mutate property by token owner if property is mutable. - /// @dev EVM selector for this function is: 0x222d97fa, - /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool) - function setTokenPropertyPermission( - string memory key, - bool isMutable, - bool collectionAdmin, - bool tokenOwner - ) public { + /// @param permissions Permissions for keys. + /// @dev EVM selector for this function is: 0xbd92983a, + /// or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[]) + function setTokenPropertyPermissions(Tuple48[] memory permissions) public { require(false, stub_error); - key; - isMutable; - collectionAdmin; - tokenOwner; + permissions; dummy = 0; } + /// @dev EVM selector for this function is: 0xf23d7790, + /// or in textual repr: tokenPropertyPermissions() + function tokenPropertyPermissions() public view returns (Tuple48[] memory) { + require(false, stub_error); + dummy; + return new Tuple48[](0); + } + // /// @notice Set token property value. // /// @dev Throws error if `msg.sender` has no permission to edit the property. // /// @param tokenId ID of the token. @@ -118,6 +132,24 @@ bytes value; } +enum EthTokenPermissions { + Mutable, + TokenOwner, + CollectionAdmin +} + +/// @dev anonymous struct +struct Tuple48 { + string field_0; + Tuple46[] field_1; +} + +/// @dev anonymous struct +struct Tuple46 { + EthTokenPermissions field_0; + bool field_1; +} + /// @title A contract that allows you to work with collections. /// @dev the ERC-165 identifier for this interface is 0xb5e1747f contract Collection is Dummy, ERC165 { --- a/pallets/refungible/CHANGELOG.md +++ b/pallets/refungible/CHANGELOG.md @@ -4,6 +4,16 @@ +## [0.2.10] - 2022-12-16 + +### Added + +- The function `tokenPropertyPermissions` and `setTokenPropertyPermissions` to `TokenProperties` interface. + +### Changed + +- Hide `setTokenPropertyPermission` function in `TokenProperties` interface. + ## [0.2.9] - 2022-11-18 ### Added --- a/pallets/refungible/Cargo.toml +++ b/pallets/refungible/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pallet-refungible" -version = "0.2.8" +version = "0.2.10" license = "GPLv3" edition = "2021" --- a/pallets/refungible/src/erc.rs +++ b/pallets/refungible/src/erc.rs @@ -33,7 +33,7 @@ use pallet_common::{ CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations, erc::{CommonEvmHandler, CollectionCall, static_property::key}, - eth::EthCrossAccount, + eth::{EthCrossAccount, EthTokenPermissions}, Error as CommonError, }; use pallet_evm::{account::CrossAccountId, PrecompileHandle}; @@ -63,6 +63,7 @@ /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. /// @param tokenOwner Permission to mutate property by token owner if property is mutable. #[weight(>::set_token_property_permissions(1))] + #[solidity(hide)] fn set_token_property_permission( &mut self, caller: caller, @@ -89,6 +90,77 @@ .map_err(dispatch_to_evm::) } + /// @notice Set permissions for token property. + /// @dev Throws error if `msg.sender` is not admin or owner of the collection. + /// @param permissions Permissions for keys. + #[weight(>::set_token_property_permissions(permissions.len() as u32))] + fn set_token_property_permissions( + &mut self, + caller: caller, + permissions: Vec<(string, Vec<(EthTokenPermissions, bool)>)>, + ) -> Result<()> { + let caller = T::CrossAccountId::from_eth(caller); + const PERMISSIONS_FIELDS_COUNT: usize = 3; + + let mut perms = Vec::new(); + + for (key, pp) in permissions { + if pp.len() > PERMISSIONS_FIELDS_COUNT { + return Err(alloc::format!( + "Actual number of fields {} for {}, which exceeds the maximum value of {}", + pp.len(), + stringify!(EthTokenPermissions), + PERMISSIONS_FIELDS_COUNT + ) + .as_str() + .into()); + } + + let mut token_permission = PropertyPermission { + mutable: false, + collection_admin: false, + token_owner: false, + }; + + for (perm, value) in pp { + match perm { + EthTokenPermissions::Mutable => token_permission.mutable = value, + EthTokenPermissions::TokenOwner => token_permission.token_owner = value, + EthTokenPermissions::CollectionAdmin => { + token_permission.collection_admin = value + } + } + } + + perms.push(PropertyKeyPermission { + key: key.into_bytes().try_into().map_err(|_| "too long key")?, + permission: token_permission, + }); + } + + >::set_token_property_permissions(self, &caller, perms) + .map_err(dispatch_to_evm::) + } + + /// @notice Get permissions for token properties. + fn token_property_permissions( + &self, + ) -> Result)>> { + let perms = >::token_property_permission(self.id); + Ok(perms + .into_iter() + .map(|(key, pp)| { + let key = string::from_utf8(key.into_inner()).expect("Stored key must be valid"); + let pp = vec![ + (EthTokenPermissions::Mutable, pp.mutable), + (EthTokenPermissions::TokenOwner, pp.token_owner), + (EthTokenPermissions::CollectionAdmin, pp.collection_admin), + ]; + (key, pp) + }) + .collect()) + } + /// @notice Set token property value. /// @dev Throws error if `msg.sender` has no permission to edit the property. /// @param tokenId ID of the token. --- a/pallets/refungible/src/erc_token.rs +++ b/pallets/refungible/src/erc_token.rs @@ -19,11 +19,6 @@ //! Provides ERC-20 standart support implementation and EVM API for unique extensions for Refungible Pallet. //! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods. -extern crate alloc; - -#[cfg(not(feature = "std"))] -use alloc::format; - use core::{ char::{REPLACEMENT_CHARACTER, decode_utf16}, convert::TryInto, @@ -35,7 +30,7 @@ use pallet_common::{ CommonWeightInfo, erc::{CommonEvmHandler, PrecompileResult}, - eth::collection_id_to_address, + eth::{collection_id_to_address, EthCrossAccount}, }; use pallet_evm::{account::CrossAccountId, PrecompileHandle}; use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder}; @@ -199,7 +194,10 @@ } #[solidity_interface(name = ERC20UniqueExtensions)] -impl RefungibleTokenHandle { +impl RefungibleTokenHandle +where + T::AccountId: From<[u8; 32]>, +{ /// @dev Function that burns an amount of the token of a given account, /// deducting from the sender's allowance for said account. /// @param from The account whose tokens will be burnt. @@ -218,6 +216,51 @@ Ok(true) } + /// @dev Function that burns an amount of the token of a given account, + /// deducting from the sender's allowance for said account. + /// @param from The account whose tokens will be burnt. + /// @param amount The amount that will be burnt. + #[weight(>::burn_from())] + fn burn_from_cross( + &mut self, + caller: caller, + from: EthCrossAccount, + amount: uint256, + ) -> Result { + let caller = T::CrossAccountId::from_eth(caller); + let from = from.into_sub_cross_account::()?; + let amount = amount.try_into().map_err(|_| "amount overflow")?; + let budget = self + .recorder + .weight_calls_budget(>::find_parent()); + + >::burn_from(self, &caller, &from, self.1, amount, &budget) + .map_err(dispatch_to_evm::)?; + Ok(true) + } + + /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`. + /// Beware that changing an allowance with this method brings the risk that someone may use both the old + /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this + /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: + /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + /// @param spender The crossaccount which will spend the funds. + /// @param amount The amount of tokens to be spent. + #[weight(>::approve())] + fn approve_cross( + &mut self, + caller: caller, + spender: EthCrossAccount, + amount: uint256, + ) -> Result { + let caller = T::CrossAccountId::from_eth(caller); + let spender = spender.into_sub_cross_account::()?; + let amount = amount.try_into().map_err(|_| "amount overflow")?; + + >::set_allowance(self, &caller, &spender, self.1, amount) + .map_err(dispatch_to_evm::)?; + Ok(true) + } /// @dev Function that changes total amount of the tokens. /// Throws if `msg.sender` doesn't owns all of the tokens. /// @param amount New total amount of the tokens. @@ -229,6 +272,53 @@ >::repartition(self, &caller, self.1, amount).map_err(dispatch_to_evm::)?; Ok(true) } + + /// @dev Transfer token for a specified address + /// @param to The crossaccount to transfer to. + /// @param amount The amount to be transferred. + #[weight(>::transfer())] + fn transfer_cross( + &mut self, + caller: caller, + to: EthCrossAccount, + amount: uint256, + ) -> Result { + let caller = T::CrossAccountId::from_eth(caller); + let to = to.into_sub_cross_account::()?; + let amount = amount.try_into().map_err(|_| "amount overflow")?; + let budget = self + .recorder + .weight_calls_budget(>::find_parent()); + + >::transfer(self, &caller, &to, self.1, amount, &budget) + .map_err(dispatch_to_evm::)?; + Ok(true) + } + + /// @dev Transfer tokens from one address to another + /// @param from The address which you want to send tokens from + /// @param to The address which you want to transfer to + /// @param amount the amount of tokens to be transferred + #[weight(>::transfer_from())] + fn transfer_from_cross( + &mut self, + caller: caller, + from: EthCrossAccount, + to: EthCrossAccount, + amount: uint256, + ) -> Result { + let caller = T::CrossAccountId::from_eth(caller); + let from = from.into_sub_cross_account::()?; + let to = to.into_sub_cross_account::()?; + let amount = amount.try_into().map_err(|_| "amount overflow")?; + let budget = self + .recorder + .weight_calls_budget(>::find_parent()); + + >::transfer_from(self, &caller, &from, &to, self.1, amount, &budget) + .map_err(dispatch_to_evm::)?; + Ok(true) + } } impl RefungibleTokenHandle { --- a/pallets/refungible/src/lib.rs +++ b/pallets/refungible/src/lib.rs @@ -113,7 +113,7 @@ AccessMode, budget::Budget, CollectionId, CollectionFlags, CollectionPropertiesVec, CreateCollectionData, CustomDataLimit, mapping::TokenAddressMapping, MAX_ITEMS_PER_BATCH, MAX_REFUNGIBLE_PIECES, Property, PropertyKey, PropertyKeyPermission, PropertyPermission, - PropertyScope, PropertyValue, TokenId, TrySetProperty, + PropertyScope, PropertyValue, TokenId, TrySetProperty, PropertiesPermissionMap, }; pub use pallet::*; @@ -1378,6 +1378,10 @@ >::set_token_property_permissions(collection, sender, property_permissions) } + pub fn token_property_permission(collection_id: CollectionId) -> PropertiesPermissionMap { + >::property_permissions(collection_id) + } + pub fn set_scoped_token_property_permissions( collection: &RefungibleHandle, sender: &T::CrossAccountId, --- a/pallets/refungible/src/stubs/UniqueRefungible.sol +++ b/pallets/refungible/src/stubs/UniqueRefungible.sol @@ -18,30 +18,45 @@ } /// @title A contract that allows to set and delete token properties and change token property permissions. -/// @dev the ERC-165 identifier for this interface is 0x91a97a68 +/// @dev the ERC-165 identifier for this interface is 0xde0695c2 contract TokenProperties is Dummy, ERC165 { + // /// @notice Set permissions for token property. + // /// @dev Throws error if `msg.sender` is not admin or owner of the collection. + // /// @param key Property key. + // /// @param isMutable Permission to mutate property. + // /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. + // /// @param tokenOwner Permission to mutate property by token owner if property is mutable. + // /// @dev EVM selector for this function is: 0x222d97fa, + // /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool) + // function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public { + // require(false, stub_error); + // key; + // isMutable; + // collectionAdmin; + // tokenOwner; + // dummy = 0; + // } + /// @notice Set permissions for token property. /// @dev Throws error if `msg.sender` is not admin or owner of the collection. - /// @param key Property key. - /// @param isMutable Permission to mutate property. - /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. - /// @param tokenOwner Permission to mutate property by token owner if property is mutable. - /// @dev EVM selector for this function is: 0x222d97fa, - /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool) - function setTokenPropertyPermission( - string memory key, - bool isMutable, - bool collectionAdmin, - bool tokenOwner - ) public { + /// @param permissions Permissions for keys. + /// @dev EVM selector for this function is: 0xbd92983a, + /// or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[]) + function setTokenPropertyPermissions(Tuple53[] memory permissions) public { require(false, stub_error); - key; - isMutable; - collectionAdmin; - tokenOwner; + permissions; dummy = 0; } + /// @notice Get permissions for token properties. + /// @dev EVM selector for this function is: 0xf23d7790, + /// or in textual repr: tokenPropertyPermissions() + function tokenPropertyPermissions() public view returns (Tuple53[] memory) { + require(false, stub_error); + dummy; + return new Tuple53[](0); + } + // /// @notice Set token property value. // /// @dev Throws error if `msg.sender` has no permission to edit the property. // /// @param tokenId ID of the token. @@ -118,6 +133,24 @@ bytes value; } +enum EthTokenPermissions { + Mutable, + TokenOwner, + CollectionAdmin +} + +/// @dev anonymous struct +struct Tuple53 { + string field_0; + Tuple51[] field_1; +} + +/// @dev anonymous struct +struct Tuple51 { + EthTokenPermissions field_0; + bool field_1; +} + /// @title A contract that allows you to work with collections. /// @dev the ERC-165 identifier for this interface is 0xb5e1747f contract Collection is Dummy, ERC165 { --- a/pallets/refungible/src/stubs/UniqueRefungibleToken.sol +++ b/pallets/refungible/src/stubs/UniqueRefungibleToken.sol @@ -36,7 +36,7 @@ } } -/// @dev the ERC-165 identifier for this interface is 0xab8deb37 +/// @dev the ERC-165 identifier for this interface is 0xe17a7d2b contract ERC20UniqueExtensions is Dummy, ERC165 { /// @dev Function that burns an amount of the token of a given account, /// deducting from the sender's allowance for said account. @@ -52,6 +52,37 @@ return false; } + /// @dev Function that burns an amount of the token of a given account, + /// deducting from the sender's allowance for said account. + /// @param from The account whose tokens will be burnt. + /// @param amount The amount that will be burnt. + /// @dev EVM selector for this function is: 0xbb2f5a58, + /// or in textual repr: burnFromCross((address,uint256),uint256) + function burnFromCross(EthCrossAccount memory from, uint256 amount) public returns (bool) { + require(false, stub_error); + from; + amount; + dummy = 0; + return false; + } + + /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`. + /// Beware that changing an allowance with this method brings the risk that someone may use both the old + /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this + /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: + /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + /// @param spender The crossaccount which will spend the funds. + /// @param amount The amount of tokens to be spent. + /// @dev EVM selector for this function is: 0x0ecd0ab0, + /// or in textual repr: approveCross((address,uint256),uint256) + function approveCross(EthCrossAccount memory spender, uint256 amount) public returns (bool) { + require(false, stub_error); + spender; + amount; + dummy = 0; + return false; + } + /// @dev Function that changes total amount of the tokens. /// Throws if `msg.sender` doesn't owns all of the tokens. /// @param amount New total amount of the tokens. @@ -63,6 +94,44 @@ dummy = 0; return false; } + + /// @dev Transfer token for a specified address + /// @param to The crossaccount to transfer to. + /// @param amount The amount to be transferred. + /// @dev EVM selector for this function is: 0x2ada85ff, + /// or in textual repr: transferCross((address,uint256),uint256) + function transferCross(EthCrossAccount memory to, uint256 amount) public returns (bool) { + require(false, stub_error); + to; + amount; + dummy = 0; + return false; + } + + /// @dev Transfer tokens from one address to another + /// @param from The address which you want to send tokens from + /// @param to The address which you want to transfer to + /// @param amount the amount of tokens to be transferred + /// @dev EVM selector for this function is: 0xd5cf430b, + /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256) + function transferFromCross( + EthCrossAccount memory from, + EthCrossAccount memory to, + uint256 amount + ) public returns (bool) { + require(false, stub_error); + from; + to; + amount; + dummy = 0; + return false; + } +} + +/// @dev Cross account struct +struct EthCrossAccount { + address eth; + uint256 sub; } /// @dev inlined interface --- a/primitives/data-structs/src/lib.rs +++ b/primitives/data-structs/src/lib.rs @@ -1010,7 +1010,7 @@ pub type PropertyValue = BoundedBytes>; /// Property permission. -#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)] +#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone, Default)] #[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))] pub struct PropertyPermission { /// Permission to change the property and property permission. --- a/runtime/common/config/ethereum.rs +++ b/runtime/common/config/ethereum.rs @@ -7,8 +7,10 @@ use sp_runtime::{RuntimeAppPublic, Perbill}; use crate::{ runtime_common::{ - dispatch::CollectionDispatchT, ethereum::sponsoring::EvmSponsorshipHandler, - config::sponsoring::DefaultSponsoringRateLimit, DealWithFees, + config::sponsoring::DefaultSponsoringRateLimit, + DealWithFees, + dispatch::CollectionDispatchT, + ethereum::{precompiles::UniquePrecompiles, sponsoring::EvmSponsorshipHandler}, }, Runtime, Aura, Balances, RuntimeEvent, ChainId, }; @@ -34,6 +36,7 @@ const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50); parameter_types! { pub BlockGasLimit: U256 = U256::from((NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightTimePerGas::get()).ref_time()); + pub PrecompilesValue: UniquePrecompiles = UniquePrecompiles::<_>::new(); } pub struct EthereumFindAuthor(core::marker::PhantomData); @@ -62,8 +65,8 @@ type CallOrigin = EnsureAddressTruncated; type WithdrawOrigin = EnsureAddressTruncated; type AddressMapping = HashedAddressMapping; - type PrecompilesType = (); - type PrecompilesValue = (); + type PrecompilesType = UniquePrecompiles; + type PrecompilesValue = PrecompilesValue; type Currency = Balances; type RuntimeEvent = RuntimeEvent; type OnMethodCall = ( --- a/runtime/common/config/pallets/mod.rs +++ b/runtime/common/config/pallets/mod.rs @@ -106,7 +106,7 @@ impl pallet_configuration::Config for Runtime { type DefaultWeightToFeeCoefficient = ConstU32<{ up_common::constants::WEIGHT_TO_FEE_COEFF }>; type DefaultMinGasPrice = ConstU64<{ up_common::constants::MIN_GAS_PRICE }>; - type MaxOverridedAllowedLocations = ConstU32<16>; + type MaxXcmAllowedLocations = ConstU32<16>; type AppPromotionDailyRate = AppPromotionDailyRate; type DayRelayBlocks = DayRelayBlocks; } --- a/runtime/common/construct_runtime/mod.rs +++ b/runtime/common/construct_runtime/mod.rs @@ -82,7 +82,7 @@ #[runtimes(opal, quartz)] AppPromotion: pallet_app_promotion::{Pallet, Call, Storage, Event} = 73, - #[runtimes(opal)] + #[runtimes(opal, quartz, unique)] ForeignAssets: pallet_foreign_assets::{Pallet, Call, Storage, Event} = 80, // Frontier --- a/runtime/common/ethereum/mod.rs +++ b/runtime/common/ethereum/mod.rs @@ -14,6 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . +pub mod precompiles; pub mod self_contained_call; pub mod sponsoring; pub mod transaction_converter; --- /dev/null +++ b/runtime/common/ethereum/precompiles/mod.rs @@ -0,0 +1,60 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +use pallet_evm::{Precompile, PrecompileHandle, PrecompileResult, PrecompileSet}; +use sp_core::H160; +use sp_std::marker::PhantomData; + +use pallet_evm_precompile_simple::{ECRecover}; +use sr25519::Sr25519Precompile; + +mod sr25519; +mod utils; + +pub struct UniquePrecompiles(PhantomData); + +impl UniquePrecompiles +where + R: pallet_evm::Config, +{ + pub fn new() -> Self { + Self(Default::default()) + } + pub fn used_addresses() -> [H160; 2] { + [hash(1), hash(20482)] + } +} +impl PrecompileSet for UniquePrecompiles +where + R: pallet_evm::Config, +{ + fn execute(&self, handle: &mut impl PrecompileHandle) -> Option { + match handle.code_address() { + a if a == hash(1) => Some(ECRecover::execute(handle)), + // Sr25519 0x5002 + a if a == hash(20482) => Some(Sr25519Precompile::::execute(handle)), + _ => None, + } + } + + fn is_precompile(&self, address: H160) -> bool { + Self::used_addresses().contains(&address) + } +} + +fn hash(a: u64) -> H160 { + H160::from_low_u64_be(a) +} --- /dev/null +++ b/runtime/common/ethereum/precompiles/sr25519.rs @@ -0,0 +1,103 @@ +// Copyright 2019-2022 PureStake Inc. +// Copyright 2022 Stake Technologies + +// Astar Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Astar Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Astar Network. If not, see . + +use fp_evm::{Context, ExitSucceed, PrecompileHandle, PrecompileOutput}; +use pallet_evm::Precompile; +use sp_core::{crypto::UncheckedFrom, sr25519, H256}; +use sp_std::marker::PhantomData; +use sp_std::prelude::*; + +use super::utils::{Bytes, EvmDataReader, EvmDataWriter, EvmResult, FunctionModifier, Gasometer}; + +#[precompile_utils_macro::generate_function_selector] +#[derive(Debug, PartialEq)] +pub enum Action { + Verify = "verify(bytes32,bytes,bytes)", +} + +/// A precompile to wrap substrate sr25519 functions. +pub struct Sr25519Precompile(PhantomData); + +impl Precompile for Sr25519Precompile { + fn execute(handle: &mut impl PrecompileHandle) -> EvmResult { + log::trace!(target: "sr25519-precompile", "In sr25519 precompile"); + + let gasometer = Gasometer::new(); + + let (mut input, selector) = EvmDataReader::new_with_selector(&gasometer, handle.input())?; + let input = &mut input; + + gasometer.check_function_modifier( + handle.context(), + handle.is_static(), + FunctionModifier::View, + )?; + + match selector { + // Dispatchables + Action::Verify => Self::verify(input, &gasometer, handle.context()), + } + } +} + +impl Sr25519Precompile { + fn verify( + input: &mut EvmDataReader, + gasometer: &Gasometer, + _: &Context, + ) -> EvmResult { + // Bound check + input.expect_arguments(gasometer, 3)?; + + // Parse arguments + let public: sr25519::Public = + sr25519::Public::unchecked_from(input.read::(gasometer)?).into(); + let signature_bytes: Vec = input.read::(gasometer)?.into(); + let message: Vec = input.read::(gasometer)?.into(); + + // Parse signature + let signature_opt = sr25519::Signature::from_slice(&signature_bytes[..]); + + let signature = if let Some(sig) = signature_opt { + sig + } else { + // Return `false` if signature length is wrong + return Ok(PrecompileOutput { + exit_status: ExitSucceed::Returned, + output: EvmDataWriter::new().write(false).build(), + }); + }; + + log::trace!( + target: "sr25519-precompile", + "Verify signature {:?} for public {:?} and message {:?}", + signature, public, message, + ); + + let is_confirmed = sp_io::crypto::sr25519_verify(&signature, &message[..], &public); + + log::trace!( + target: "sr25519-precompile", + "Verified signature {:?} is {:?}", + signature, is_confirmed, + ); + + Ok(PrecompileOutput { + exit_status: ExitSucceed::Returned, + output: EvmDataWriter::new().write(is_confirmed).build(), + }) + } +} --- /dev/null +++ b/runtime/common/ethereum/precompiles/utils/data.rs @@ -0,0 +1,486 @@ +// Copyright 2019-2022 PureStake Inc. +// Copyright 2022 Stake Technologies +// This file is part of Utils package, originally developed by Purestake Inc. +// Utils package used in Astar Network in terms of GPLv3. +// +// Utils is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Utils is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Utils. If not, see . + +use super::{EvmResult, Gasometer}; + +use sp_std::borrow::ToOwned; +use core::{any::type_name, ops::Range}; +use sp_core::{H160, H256, U256}; +use sp_std::{convert::TryInto, vec, vec::Vec}; + +/// The `address` type of Solidity. +/// H160 could represent 2 types of data (bytes20 and address) that are not encoded the same way. +/// To avoid issues writing H160 is thus not supported. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct Address(pub H160); + +impl From for Address { + fn from(a: H160) -> Address { + Address(a) + } +} + +impl From
for H160 { + fn from(a: Address) -> H160 { + a.0 + } +} + +/// The `bytes`/`string` type of Solidity. +/// It is different from `Vec` which will be serialized with padding for each `u8` element +/// of the array, while `Bytes` is tightly packed. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct Bytes(pub Vec); + +impl From<&[u8]> for Bytes { + fn from(a: &[u8]) -> Self { + Self(a.to_owned()) + } +} + +impl From<&str> for Bytes { + fn from(a: &str) -> Self { + a.as_bytes().into() + } +} + +impl Into> for Bytes { + fn into(self: Self) -> Vec { + self.0 + } +} + +/// Wrapper around an EVM input slice, helping to parse it. +/// Provide functions to parse common types. +#[derive(Clone, Copy, Debug)] +pub struct EvmDataReader<'a> { + input: &'a [u8], + cursor: usize, +} + +impl<'a> EvmDataReader<'a> { + /// Create a new input parser. + pub fn new(input: &'a [u8]) -> Self { + Self { input, cursor: 0 } + } + + /// Create a new input parser from a selector-initial input. + pub fn new_with_selector(gasometer: &Gasometer, input: &'a [u8]) -> EvmResult<(Self, T)> + where + T: num_enum::TryFromPrimitive, + { + if input.len() < 4 { + return Err(gasometer.revert("tried to parse selector out of bounds")); + } + + let mut buffer = [0u8; 4]; + buffer.copy_from_slice(&input[0..4]); + let selector = T::try_from_primitive(u32::from_be_bytes(buffer)).map_err(|_| { + log::trace!( + target: "precompile-utils", + "Failed to match function selector for {}", + type_name::() + ); + gasometer.revert("unknown selector") + })?; + + Ok((Self::new(&input[4..]), selector)) + } + + /// Check the input has at least the correct amount of arguments before the end (32 bytes values). + pub fn expect_arguments(&self, gasometer: &Gasometer, args: usize) -> EvmResult { + if self.input.len() >= self.cursor + args * 32 { + Ok(()) + } else { + Err(gasometer.revert("input doesn't match expected length")) + } + } + + /// Read data from the input. + /// Must be provided a gasometer to generate correct Revert errors. + /// TODO : Benchmark and add cost of parsing to gasometer ? + pub fn read(&mut self, gasometer: &Gasometer) -> EvmResult { + T::read(self, gasometer) + } + + /// Reads a pointer, returning a reader targetting the pointed location. + pub fn read_pointer(&mut self, gasometer: &Gasometer) -> EvmResult { + let offset: usize = self + .read::(gasometer) + .map_err(|_| gasometer.revert("tried to parse array offset out of bounds"))? + .try_into() + .map_err(|_| gasometer.revert("array offset is too large"))?; + + if offset >= self.input.len() { + return Err(gasometer.revert("pointer points out of bounds")); + } + + Ok(Self { + input: &self.input[offset..], + cursor: 0, + }) + } + + /// Move the reading cursor with provided length, and return a range from the previous cursor + /// location to the new one. + /// Checks cursor overflows. + fn move_cursor(&mut self, gasometer: &Gasometer, len: usize) -> EvmResult> { + let start = self.cursor; + let end = self + .cursor + .checked_add(len) + .ok_or_else(|| gasometer.revert("data reading cursor overflow"))?; + + self.cursor = end; + + Ok(start..end) + } +} + +/// Help build an EVM input/output data. +/// +/// Functions takes `self` to allow chaining all calls like +/// `EvmDataWriter::new().write(...).write(...).build()`. +/// While it could be more ergonomic to take &mut self, this would +/// prevent to have a `build` function that don't clone the output. +#[derive(Clone, Debug)] +pub struct EvmDataWriter { + pub(crate) data: Vec, + offset_data: Vec, + selector: Option, +} + +#[derive(Clone, Debug)] +struct OffsetDatum { + // Offset location in the container data. + offset_position: usize, + // Data pointed by the offset that must be inserted at the end of container data. + data: Vec, + // Inside of arrays, the offset is not from the start of array data (length), but from the start + // of the item. This shift allow to correct this. + offset_shift: usize, +} + +impl EvmDataWriter { + /// Creates a new empty output builder (without selector). + pub fn new() -> Self { + Self { + data: vec![], + offset_data: vec![], + selector: None, + } + } + + /// Return the built data. + pub fn build(mut self) -> Vec { + Self::bake_offsets(&mut self.data, self.offset_data); + + if let Some(selector) = self.selector { + let mut output = selector.to_be_bytes().to_vec(); + output.append(&mut self.data); + output + } else { + self.data + } + } + + /// Add offseted data at the end of this writer's data, updating the offsets. + fn bake_offsets(output: &mut Vec, offsets: Vec) { + for mut offset_datum in offsets { + let offset_position = offset_datum.offset_position; + let offset_position_end = offset_position + 32; + + // The offset is the distance between the start of the data and the + // start of the pointed data (start of a struct, length of an array). + // Offsets in inner data are relative to the start of their respective "container". + // However in arrays the "container" is actually the item itself instead of the whole + // array, which is corrected by `offset_shift`. + let free_space_offset = output.len() - offset_datum.offset_shift; + + // Override dummy offset to the offset it will be in the final output. + U256::from(free_space_offset) + .to_big_endian(&mut output[offset_position..offset_position_end]); + + // Append this data at the end of the current output. + output.append(&mut offset_datum.data); + } + } + + /// Write arbitrary bytes. + /// Doesn't handle any alignement checks, prefer using `write` instead if possible. + fn write_raw_bytes(mut self, value: &[u8]) -> Self { + self.data.extend_from_slice(value); + self + } + + /// Write data of requested type. + pub fn write(mut self, value: T) -> Self { + T::write(&mut self, value); + self + } + + /// Writes a pointer to given data. + /// The data will be appended when calling `build`. + /// Initially write a dummy value as offset in this writer's data, which will be replaced by + /// the correct offset once the pointed data is appended. + /// + /// Takes `&mut self` since its goal is to be used inside `EvmData` impl and not in chains. + pub fn write_pointer(&mut self, data: Vec) { + let offset_position = self.data.len(); + H256::write(self, H256::repeat_byte(0xff)); + + self.offset_data.push(OffsetDatum { + offset_position, + data, + offset_shift: 0, + }); + } +} + +impl Default for EvmDataWriter { + fn default() -> Self { + Self::new() + } +} + +/// Data that can be converted from and to EVM data types. +pub trait EvmData: Sized { + fn read(reader: &mut EvmDataReader, gasometer: &Gasometer) -> EvmResult; + fn write(writer: &mut EvmDataWriter, value: Self); +} + +impl EvmData for H256 { + fn read(reader: &mut EvmDataReader, gasometer: &Gasometer) -> EvmResult { + let range = reader.move_cursor(gasometer, 32)?; + + let data = reader + .input + .get(range) + .ok_or_else(|| gasometer.revert("tried to parse H256 out of bounds"))?; + + Ok(H256::from_slice(data)) + } + + fn write(writer: &mut EvmDataWriter, value: Self) { + writer.data.extend_from_slice(value.as_bytes()); + } +} + +impl EvmData for Address { + fn read(reader: &mut EvmDataReader, gasometer: &Gasometer) -> EvmResult { + let range = reader.move_cursor(gasometer, 32)?; + + let data = reader + .input + .get(range) + .ok_or_else(|| gasometer.revert("tried to parse H160 out of bounds"))?; + + Ok(H160::from_slice(&data[12..32]).into()) + } + + fn write(writer: &mut EvmDataWriter, value: Self) { + H256::write(writer, value.0.into()); + } +} + +impl EvmData for U256 { + fn read(reader: &mut EvmDataReader, gasometer: &Gasometer) -> EvmResult { + let range = reader.move_cursor(gasometer, 32)?; + + let data = reader + .input + .get(range) + .ok_or_else(|| gasometer.revert("tried to parse U256 out of bounds"))?; + + Ok(U256::from_big_endian(data)) + } + + fn write(writer: &mut EvmDataWriter, value: Self) { + let mut buffer = [0u8; 32]; + value.to_big_endian(&mut buffer); + writer.data.extend_from_slice(&buffer); + } +} + +macro_rules! impl_evmdata_for_uints { + ($($uint:ty, )*) => { + $( + impl EvmData for $uint { + fn read(reader: &mut EvmDataReader, gasometer: &Gasometer) -> EvmResult { + let range = reader.move_cursor(gasometer, 32)?; + + let data = reader + .input + .get(range) + .ok_or_else(|| gasometer.revert(alloc::format!( + "tried to parse {} out of bounds", core::any::type_name::() + )))?; + + let mut buffer = [0u8; core::mem::size_of::()]; + buffer.copy_from_slice(&data[32 - core::mem::size_of::()..]); + Ok(Self::from_be_bytes(buffer)) + } + + fn write(writer: &mut EvmDataWriter, value: Self) { + let mut buffer = [0u8; 32]; + buffer[32 - core::mem::size_of::()..].copy_from_slice(&value.to_be_bytes()); + writer.data.extend_from_slice(&buffer); + } + } + )* + }; +} + +impl_evmdata_for_uints!(u16, u32, u64, u128,); + +// The implementation for u8 is specific, for performance reasons. +impl EvmData for u8 { + fn read(reader: &mut EvmDataReader, gasometer: &Gasometer) -> EvmResult { + let range = reader.move_cursor(gasometer, 32)?; + + let data = reader + .input + .get(range) + .ok_or_else(|| gasometer.revert("tried to parse u64 out of bounds"))?; + + Ok(data[31]) + } + + fn write(writer: &mut EvmDataWriter, value: Self) { + let mut buffer = [0u8; 32]; + buffer[31] = value; + + writer.data.extend_from_slice(&buffer); + } +} + +impl EvmData for bool { + fn read(reader: &mut EvmDataReader, gasometer: &Gasometer) -> EvmResult { + let h256 = H256::read(reader, gasometer) + .map_err(|_| gasometer.revert("tried to parse bool out of bounds"))?; + + Ok(!h256.is_zero()) + } + + fn write(writer: &mut EvmDataWriter, value: Self) { + let mut buffer = [0u8; 32]; + if value { + buffer[31] = 1; + } + + writer.data.extend_from_slice(&buffer); + } +} + +impl EvmData for Vec { + fn read(reader: &mut EvmDataReader, gasometer: &Gasometer) -> EvmResult { + let mut inner_reader = reader.read_pointer(gasometer)?; + + let array_size: usize = inner_reader + .read::(gasometer) + .map_err(|_| gasometer.revert("tried to parse array length out of bounds"))? + .try_into() + .map_err(|_| gasometer.revert("array length is too large"))?; + + let mut array = vec![]; + + let mut item_reader = EvmDataReader { + input: inner_reader + .input + .get(32..) + .ok_or_else(|| gasometer.revert("try to read array items out of bound"))?, + cursor: 0, + }; + + for _ in 0..array_size { + array.push(item_reader.read(gasometer)?); + } + + Ok(array) + } + + fn write(writer: &mut EvmDataWriter, value: Self) { + let mut inner_writer = EvmDataWriter::new().write(U256::from(value.len())); + + for inner in value { + // Any offset in items are relative to the start of the item instead of the + // start of the array. However if there is offseted data it must but appended after + // all items (offsets) are written. We thus need to rely on `compute_offsets` to do + // that, and must store a "shift" to correct the offsets. + let shift = inner_writer.data.len(); + let item_writer = EvmDataWriter::new().write(inner); + + inner_writer = inner_writer.write_raw_bytes(&item_writer.data); + for mut offset_datum in item_writer.offset_data { + offset_datum.offset_shift += 32; + offset_datum.offset_position += shift; + inner_writer.offset_data.push(offset_datum); + } + } + + writer.write_pointer(inner_writer.build()); + } +} + +impl EvmData for Bytes { + fn read(reader: &mut EvmDataReader, gasometer: &Gasometer) -> EvmResult { + let mut inner_reader = reader.read_pointer(gasometer)?; + + // Read bytes/string size. + let array_size: usize = inner_reader + .read::(gasometer) + .map_err(|_| gasometer.revert("tried to parse bytes/string length out of bounds"))? + .try_into() + .map_err(|_| gasometer.revert("bytes/string length is too large"))?; + + // Get valid range over the bytes data. + let range = inner_reader.move_cursor(gasometer, array_size)?; + + let data = inner_reader + .input + .get(range) + .ok_or_else(|| gasometer.revert("tried to parse bytes/string out of bounds"))?; + + let bytes = Self(data.to_owned()); + + Ok(bytes) + } + + fn write(writer: &mut EvmDataWriter, value: Self) { + let length = value.0.len(); + + // Pad the data. + // Leave it as is if a multiple of 32, otherwise pad to next + // multiple or 32. + let chunks = length / 32; + let padded_size = match length % 32 { + 0 => chunks * 32, + _ => (chunks + 1) * 32, + }; + + let mut value = value.0.to_vec(); + value.resize(padded_size, 0); + + writer.write_pointer( + EvmDataWriter::new() + .write(U256::from(length)) + .write_raw_bytes(&value) + .build(), + ); + } +} --- /dev/null +++ b/runtime/common/ethereum/precompiles/utils/macro/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "precompile-utils-macro" +authors = [ "StakeTechnologies", "PureStake" ] +description = "" +edition = "2018" +version = "0.1.0" + +[lib] +proc-macro = true + +[dependencies] +num_enum = { version = "0.5.3", default-features = false } +proc-macro2 = "1.0" +quote = "1.0" +sha3 = "0.8" +syn = { version = "1.0", features = [ "extra-traits", "fold", "full", "visit" ] } --- /dev/null +++ b/runtime/common/ethereum/precompiles/utils/macro/src/lib.rs @@ -0,0 +1,115 @@ +// Copyright 2019-2022 PureStake Inc. +// Copyright 2022 Stake Technologies +// This file is part of Utils package, originally developed by Purestake Inc. +// Utils package used in Astar Network in terms of GPLv3. +// +// Utils is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Utils is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Utils. If not, see . + +#![crate_type = "proc-macro"] +extern crate proc_macro; + +use proc_macro::TokenStream; +use proc_macro2::Literal; +use quote::{quote, quote_spanned}; +use sha3::{Digest, Keccak256}; +use std::convert::TryInto; +use syn::{parse_macro_input, spanned::Spanned, Expr, ExprLit, Ident, ItemEnum, Lit}; + +/// This macro allows to associate to each variant of an enumeration a discriminant (of type u32 +/// whose value corresponds to the first 4 bytes of the Hash Keccak256 of the character string +///indicated by the user of this macro. +/// +/// Usage: +/// +/// ```ignore +/// #[generate_function_selector] +/// enum Action { +/// Toto = "toto()", +/// Tata = "tata()", +/// } +/// ``` +/// +/// Extanded to: +/// +/// ```rust +/// #[repr(u32)] +/// enum Action { +/// Toto = 119097542u32, +/// Tata = 1414311903u32, +/// } +/// ``` +/// +#[proc_macro_attribute] +pub fn generate_function_selector(_: TokenStream, input: TokenStream) -> TokenStream { + let item = parse_macro_input!(input as ItemEnum); + + let ItemEnum { + attrs, + vis, + enum_token, + ident, + variants, + .. + } = item; + + let mut ident_expressions: Vec = vec![]; + let mut variant_expressions: Vec = vec![]; + for variant in variants { + match variant.discriminant { + Some((_, Expr::Lit(ExprLit { lit, .. }))) => { + if let Lit::Str(lit_str) = lit { + let selector = u32::from_be_bytes( + Keccak256::digest(lit_str.value().as_ref())[..4] + .try_into() + .unwrap(), + ); + ident_expressions.push(variant.ident); + variant_expressions.push(Expr::Lit(ExprLit { + lit: Lit::Verbatim(Literal::u32_suffixed(selector)), + attrs: Default::default(), + })); + } else { + return quote_spanned! { + lit.span() => compile_error("Expected literal string"); + } + .into(); + } + } + Some((_eg, expr)) => { + return quote_spanned! { + expr.span() => compile_error("Expected literal"); + } + .into() + } + None => { + return quote_spanned! { + variant.span() => compile_error("Each variant must have a discriminant"); + } + .into() + } + } + } + + (quote! { + #(#attrs)* + #[derive(num_enum::TryFromPrimitive, num_enum::IntoPrimitive)] + #[repr(u32)] + #vis #enum_token #ident { + #( + #ident_expressions = #variant_expressions, + )* + } + }) + .into() +} --- /dev/null +++ b/runtime/common/ethereum/precompiles/utils/mod.rs @@ -0,0 +1,95 @@ +// Copyright 2019-2022 PureStake Inc. +// Copyright 2022 Stake Technologies +// This file is part of Utils package, originally developed by Purestake Inc. +// Utils package used in Astar Network in terms of GPLv3. +// +// Utils is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Utils is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Utils. If not, see . + +use sp_std::borrow::ToOwned; +use fp_evm::{Context, ExitRevert, PrecompileFailure}; +use sp_core::U256; +use sp_std::marker::PhantomData; + +mod data; + +pub use data::{Bytes, EvmData, EvmDataReader, EvmDataWriter}; + +/// Alias for Result returning an EVM precompile error. +pub type EvmResult = Result; + +/// Helper functions requiring a Runtime. +/// This runtime must of course implement `pallet_evm::Config`. +#[derive(Clone, Copy, Debug)] +pub struct RuntimeHelper(PhantomData); + +/// Represents modifiers a Solidity function can be annotated with. +#[derive(Copy, Clone, PartialEq, Eq)] +pub enum FunctionModifier { + /// Function that doesn't modify the state. + View, + /// Function that modifies the state and accept funds. + Payable, +} + +/// Custom Gasometer to record costs in precompiles. +/// It is advised to record known costs as early as possible to +/// avoid unecessary computations if there is an Out of Gas. +/// +/// Provides functions related to reverts, as reverts takes the recorded amount +/// of gas into account. +#[derive(Clone, Copy, Debug)] +pub struct Gasometer(); + +impl Gasometer { + /// Create a new Gasometer with provided gas limit. + /// None is no limit. + pub fn new() -> Self { + Self() + } + + /// Revert the execution, making the user pay for the the currently + /// recorded cost. It is better to **revert** instead of **error** as + /// erroring consumes the entire gas limit, and **revert** returns an error + /// message to the calling contract. + /// + /// TODO : Record cost of the input based on its size and handle Out of Gas ? + /// This might be required if we format revert messages using user data. + #[must_use] + pub fn revert(&self, output: impl AsRef<[u8]>) -> PrecompileFailure { + PrecompileFailure::Revert { + exit_status: ExitRevert::Reverted, + output: output.as_ref().to_owned(), + } + } + + #[must_use] + /// Check that a function call is compatible with the context it is + /// called into. + pub fn check_function_modifier( + &self, + context: &Context, + is_static: bool, + modifier: FunctionModifier, + ) -> EvmResult { + if is_static && modifier != FunctionModifier::View { + return Err(self.revert("can't call non-static function in static context")); + } + + if modifier != FunctionModifier::Payable && context.apparent_value > U256::zero() { + return Err(self.revert("function is not payable")); + } + + Ok(()) + } +} --- a/runtime/opal/Cargo.toml +++ b/runtime/opal/Cargo.toml @@ -471,6 +471,7 @@ up-rpc = { path = "../../primitives/rpc", default-features = false } app-promotion-rpc = { path = "../../primitives/app_promotion_rpc", default-features = false } rmrk-rpc = { path = "../../primitives/rmrk-rpc", default-features = false } +fp-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } fp-evm-mapping = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } pallet-inflation = { path = '../../pallets/inflation', default-features = false } pallet-app-promotion = { path = '../../pallets/app-promotion', default-features = false } @@ -494,10 +495,13 @@ pallet-base-fee = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } fp-rpc = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } fp-self-contained = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } +pallet-evm-precompile-simple = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } evm-coder = { default-features = false, path = '../../crates/evm-coder' } up-sponsorship = { default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = 'polkadot-v0.9.33' } pallet-foreign-assets = { default-features = false, path = "../../pallets/foreign-assets" } pallet-maintenance = { default-features = false, path = "../../pallets/maintenance" } +precompile-utils-macro = { path = "../common/ethereum/precompiles/utils/macro" } +num_enum = { version = "0.5.3", default-features = false } ################################################################################ # Test dependencies --- a/runtime/opal/src/lib.rs +++ b/runtime/opal/src/lib.rs @@ -25,6 +25,8 @@ #[cfg(feature = "std")] include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); +extern crate alloc; + use frame_support::parameter_types; use sp_version::RuntimeVersion; --- a/runtime/quartz/Cargo.toml +++ b/runtime/quartz/Cargo.toml @@ -169,7 +169,7 @@ "pallet-maintenance/std", ] limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing'] -quartz-runtime = ['refungible', 'app-promotion'] +quartz-runtime = ['refungible', 'app-promotion', 'foreign-assets'] refungible = [] scheduler = [] @@ -463,6 +463,7 @@ pallet-unique = { path = '../../pallets/unique', default-features = false } up-rpc = { path = "../../primitives/rpc", default-features = false } app-promotion-rpc = { path = "../../primitives/app_promotion_rpc", default-features = false } +fp-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } fp-evm-mapping = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } pallet-inflation = { path = '../../pallets/inflation', default-features = false } pallet-app-promotion = { path = '../../pallets/app-promotion', default-features = false } @@ -486,10 +487,13 @@ pallet-base-fee = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } fp-rpc = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } fp-self-contained = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } +pallet-evm-precompile-simple = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } evm-coder = { default-features = false, path = '../../crates/evm-coder' } up-sponsorship = { default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = 'polkadot-v0.9.33' } pallet-foreign-assets = { default-features = false, path = "../../pallets/foreign-assets" } pallet-maintenance = { default-features = false, path = "../../pallets/maintenance" } +precompile-utils-macro = { path = "../common/ethereum/precompiles/utils/macro" } +num_enum = { version = "0.5.3", default-features = false } ################################################################################ # Other Dependencies --- a/runtime/quartz/src/lib.rs +++ b/runtime/quartz/src/lib.rs @@ -25,6 +25,8 @@ #[cfg(feature = "std")] include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); +extern crate alloc; + use frame_support::parameter_types; use sp_version::RuntimeVersion; --- a/runtime/quartz/src/xcm_barrier.rs +++ b/runtime/quartz/src/xcm_barrier.rs @@ -52,6 +52,11 @@ parents: 1, interior: Here, }, + // Statemint/Statemint location + MultiLocation { + parents: 1, + interior: X1(Parachain(1000)), + }, // Karura/Acala location MultiLocation { parents: 1, --- a/runtime/unique/Cargo.toml +++ b/runtime/unique/Cargo.toml @@ -170,7 +170,7 @@ "pallet-maintenance/std", ] limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing'] -unique-runtime = [] +unique-runtime = ['foreign-assets'] stubgen = ["evm-coder/stubgen"] refungible = [] @@ -479,11 +479,15 @@ pallet-base-fee = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } fp-rpc = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } fp-self-contained = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } +fp-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } fp-evm-mapping = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } +pallet-evm-precompile-simple = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.33" } evm-coder = { default-features = false, path = '../../crates/evm-coder' } up-sponsorship = { default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = 'polkadot-v0.9.33' } pallet-foreign-assets = { default-features = false, path = "../../pallets/foreign-assets" } pallet-maintenance = { default-features = false, path = "../../pallets/maintenance" } +precompile-utils-macro = { path = "../common/ethereum/precompiles/utils/macro" } +num_enum = { version = "0.5.3", default-features = false } ################################################################################ # Other Dependencies --- a/runtime/unique/src/lib.rs +++ b/runtime/unique/src/lib.rs @@ -25,6 +25,8 @@ #[cfg(feature = "std")] include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); +extern crate alloc; + use frame_support::parameter_types; use sp_version::RuntimeVersion; --- a/runtime/unique/src/xcm_barrier.rs +++ b/runtime/unique/src/xcm_barrier.rs @@ -52,6 +52,11 @@ parents: 1, interior: Here, }, + // Statemint/Statemint location + MultiLocation { + parents: 1, + interior: X1(Parachain(1000)), + }, // Karura/Acala location MultiLocation { parents: 1, --- a/tests/package.json +++ b/tests/package.json @@ -45,6 +45,7 @@ "testNesting": "mocha --timeout 9999999 -r ts-node/register ./**/nest.test.ts", "testUnnesting": "mocha --timeout 9999999 -r ts-node/register ./**/unnest.test.ts", "testProperties": "mocha --timeout 9999999 -r ts-node/register ./**/collectionProperties.test.ts ./**/tokenProperties.test.ts ./**/getPropertiesRpc.test.ts", + "testCollectionProperties": "mocha --timeout 9999999 -r ts-node/register ./**/collectionProperties.test.ts", "testMigration": "mocha --timeout 9999999 -r ts-node/register ./**/nesting/migration-check.test.ts", "testAddCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/addCollectionAdmin.test.ts", "testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts", --- a/tests/src/eth/abi/nonFungible.json +++ b/tests/src/eth/abi/nonFungible.json @@ -697,12 +697,29 @@ }, { "inputs": [ - { "internalType": "string", "name": "key", "type": "string" }, - { "internalType": "bool", "name": "isMutable", "type": "bool" }, - { "internalType": "bool", "name": "collectionAdmin", "type": "bool" }, - { "internalType": "bool", "name": "tokenOwner", "type": "bool" } + { + "components": [ + { "internalType": "string", "name": "field_0", "type": "string" }, + { + "components": [ + { + "internalType": "enum EthTokenPermissions", + "name": "field_0", + "type": "uint8" + }, + { "internalType": "bool", "name": "field_1", "type": "bool" } + ], + "internalType": "struct Tuple46[]", + "name": "field_1", + "type": "tuple[]" + } + ], + "internalType": "struct Tuple48[]", + "name": "permissions", + "type": "tuple[]" + } ], - "name": "setTokenPropertyPermission", + "name": "setTokenPropertyPermissions", "outputs": [], "stateMutability": "nonpayable", "type": "function" @@ -743,6 +760,35 @@ "type": "function" }, { + "inputs": [], + "name": "tokenPropertyPermissions", + "outputs": [ + { + "components": [ + { "internalType": "string", "name": "field_0", "type": "string" }, + { + "components": [ + { + "internalType": "enum EthTokenPermissions", + "name": "field_0", + "type": "uint8" + }, + { "internalType": "bool", "name": "field_1", "type": "bool" } + ], + "internalType": "struct Tuple46[]", + "name": "field_1", + "type": "tuple[]" + } + ], + "internalType": "struct Tuple48[]", + "name": "", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { "inputs": [ { "internalType": "uint256", "name": "tokenId", "type": "uint256" } ], --- a/tests/src/eth/abi/reFungible.json +++ b/tests/src/eth/abi/reFungible.json @@ -679,12 +679,29 @@ }, { "inputs": [ - { "internalType": "string", "name": "key", "type": "string" }, - { "internalType": "bool", "name": "isMutable", "type": "bool" }, - { "internalType": "bool", "name": "collectionAdmin", "type": "bool" }, - { "internalType": "bool", "name": "tokenOwner", "type": "bool" } + { + "components": [ + { "internalType": "string", "name": "field_0", "type": "string" }, + { + "components": [ + { + "internalType": "enum EthTokenPermissions", + "name": "field_0", + "type": "uint8" + }, + { "internalType": "bool", "name": "field_1", "type": "bool" } + ], + "internalType": "struct Tuple51[]", + "name": "field_1", + "type": "tuple[]" + } + ], + "internalType": "struct Tuple53[]", + "name": "permissions", + "type": "tuple[]" + } ], - "name": "setTokenPropertyPermission", + "name": "setTokenPropertyPermissions", "outputs": [], "stateMutability": "nonpayable", "type": "function" @@ -734,6 +751,35 @@ "type": "function" }, { + "inputs": [], + "name": "tokenPropertyPermissions", + "outputs": [ + { + "components": [ + { "internalType": "string", "name": "field_0", "type": "string" }, + { + "components": [ + { + "internalType": "enum EthTokenPermissions", + "name": "field_0", + "type": "uint8" + }, + { "internalType": "bool", "name": "field_1", "type": "bool" } + ], + "internalType": "struct Tuple51[]", + "name": "field_1", + "type": "tuple[]" + } + ], + "internalType": "struct Tuple53[]", + "name": "", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { "inputs": [ { "internalType": "uint256", "name": "tokenId", "type": "uint256" } ], --- a/tests/src/eth/abi/reFungibleToken.json +++ b/tests/src/eth/abi/reFungibleToken.json @@ -71,6 +71,24 @@ }, { "inputs": [ + { + "components": [ + { "internalType": "address", "name": "eth", "type": "address" }, + { "internalType": "uint256", "name": "sub", "type": "uint256" } + ], + "internalType": "struct EthCrossAccount", + "name": "spender", + "type": "tuple" + }, + { "internalType": "uint256", "name": "amount", "type": "uint256" } + ], + "name": "approveCross", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ { "internalType": "address", "name": "owner", "type": "address" } ], "name": "balanceOf", @@ -89,6 +107,24 @@ "type": "function" }, { + "inputs": [ + { + "components": [ + { "internalType": "address", "name": "eth", "type": "address" }, + { "internalType": "uint256", "name": "sub", "type": "uint256" } + ], + "internalType": "struct EthCrossAccount", + "name": "from", + "type": "tuple" + }, + { "internalType": "uint256", "name": "amount", "type": "uint256" } + ], + "name": "burnFromCross", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { "inputs": [], "name": "decimals", "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }], @@ -160,6 +196,24 @@ }, { "inputs": [ + { + "components": [ + { "internalType": "address", "name": "eth", "type": "address" }, + { "internalType": "uint256", "name": "sub", "type": "uint256" } + ], + "internalType": "struct EthCrossAccount", + "name": "to", + "type": "tuple" + }, + { "internalType": "uint256", "name": "amount", "type": "uint256" } + ], + "name": "transferCross", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ { "internalType": "address", "name": "from", "type": "address" }, { "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "amount", "type": "uint256" } @@ -168,5 +222,32 @@ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" + }, + { + "inputs": [ + { + "components": [ + { "internalType": "address", "name": "eth", "type": "address" }, + { "internalType": "uint256", "name": "sub", "type": "uint256" } + ], + "internalType": "struct EthCrossAccount", + "name": "from", + "type": "tuple" + }, + { + "components": [ + { "internalType": "address", "name": "eth", "type": "address" }, + { "internalType": "uint256", "name": "sub", "type": "uint256" } + ], + "internalType": "struct EthCrossAccount", + "name": "to", + "type": "tuple" + }, + { "internalType": "uint256", "name": "amount", "type": "uint256" } + ], + "name": "transferFromCross", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" } ] --- a/tests/src/eth/api/UniqueNFT.sol +++ b/tests/src/eth/api/UniqueNFT.sol @@ -13,22 +13,28 @@ } /// @title A contract that allows to set and delete token properties and change token property permissions. -/// @dev the ERC-165 identifier for this interface is 0x91a97a68 +/// @dev the ERC-165 identifier for this interface is 0xde0695c2 interface TokenProperties is Dummy, ERC165 { + // /// @notice Set permissions for token property. + // /// @dev Throws error if `msg.sender` is not admin or owner of the collection. + // /// @param key Property key. + // /// @param isMutable Permission to mutate property. + // /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. + // /// @param tokenOwner Permission to mutate property by token owner if property is mutable. + // /// @dev EVM selector for this function is: 0x222d97fa, + // /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool) + // function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) external; + /// @notice Set permissions for token property. /// @dev Throws error if `msg.sender` is not admin or owner of the collection. - /// @param key Property key. - /// @param isMutable Permission to mutate property. - /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. - /// @param tokenOwner Permission to mutate property by token owner if property is mutable. - /// @dev EVM selector for this function is: 0x222d97fa, - /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool) - function setTokenPropertyPermission( - string memory key, - bool isMutable, - bool collectionAdmin, - bool tokenOwner - ) external; + /// @param permissions Permissions for keys. + /// @dev EVM selector for this function is: 0xbd92983a, + /// or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[]) + function setTokenPropertyPermissions(Tuple43[] memory permissions) external; + + /// @dev EVM selector for this function is: 0xf23d7790, + /// or in textual repr: tokenPropertyPermissions() + function tokenPropertyPermissions() external view returns (Tuple43[] memory); // /// @notice Set token property value. // /// @dev Throws error if `msg.sender` has no permission to edit the property. @@ -79,6 +85,24 @@ bytes value; } +enum EthTokenPermissions { + Mutable, + TokenOwner, + CollectionAdmin +} + +/// @dev anonymous struct +struct Tuple43 { + string field_0; + Tuple41[] field_1; +} + +/// @dev anonymous struct +struct Tuple41 { + EthTokenPermissions field_0; + bool field_1; +} + /// @title A contract that allows you to work with collections. /// @dev the ERC-165 identifier for this interface is 0xb5e1747f interface Collection is Dummy, ERC165 { --- a/tests/src/eth/api/UniqueRefungible.sol +++ b/tests/src/eth/api/UniqueRefungible.sol @@ -13,22 +13,29 @@ } /// @title A contract that allows to set and delete token properties and change token property permissions. -/// @dev the ERC-165 identifier for this interface is 0x91a97a68 +/// @dev the ERC-165 identifier for this interface is 0xde0695c2 interface TokenProperties is Dummy, ERC165 { + // /// @notice Set permissions for token property. + // /// @dev Throws error if `msg.sender` is not admin or owner of the collection. + // /// @param key Property key. + // /// @param isMutable Permission to mutate property. + // /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. + // /// @param tokenOwner Permission to mutate property by token owner if property is mutable. + // /// @dev EVM selector for this function is: 0x222d97fa, + // /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool) + // function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) external; + /// @notice Set permissions for token property. /// @dev Throws error if `msg.sender` is not admin or owner of the collection. - /// @param key Property key. - /// @param isMutable Permission to mutate property. - /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable. - /// @param tokenOwner Permission to mutate property by token owner if property is mutable. - /// @dev EVM selector for this function is: 0x222d97fa, - /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool) - function setTokenPropertyPermission( - string memory key, - bool isMutable, - bool collectionAdmin, - bool tokenOwner - ) external; + /// @param permissions Permissions for keys. + /// @dev EVM selector for this function is: 0xbd92983a, + /// or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[]) + function setTokenPropertyPermissions(Tuple47[] memory permissions) external; + + /// @notice Get permissions for token properties. + /// @dev EVM selector for this function is: 0xf23d7790, + /// or in textual repr: tokenPropertyPermissions() + function tokenPropertyPermissions() external view returns (Tuple47[] memory); // /// @notice Set token property value. // /// @dev Throws error if `msg.sender` has no permission to edit the property. @@ -79,6 +86,24 @@ bytes value; } +enum EthTokenPermissions { + Mutable, + TokenOwner, + CollectionAdmin +} + +/// @dev anonymous struct +struct Tuple47 { + string field_0; + Tuple45[] field_1; +} + +/// @dev anonymous struct +struct Tuple45 { + EthTokenPermissions field_0; + bool field_1; +} + /// @title A contract that allows you to work with collections. /// @dev the ERC-165 identifier for this interface is 0xb5e1747f interface Collection is Dummy, ERC165 { --- a/tests/src/eth/api/UniqueRefungibleToken.sol +++ b/tests/src/eth/api/UniqueRefungibleToken.sol @@ -23,7 +23,7 @@ function parentTokenId() external view returns (uint256); } -/// @dev the ERC-165 identifier for this interface is 0xab8deb37 +/// @dev the ERC-165 identifier for this interface is 0xe17a7d2b interface ERC20UniqueExtensions is Dummy, ERC165 { /// @dev Function that burns an amount of the token of a given account, /// deducting from the sender's allowance for said account. @@ -33,12 +33,56 @@ /// or in textual repr: burnFrom(address,uint256) function burnFrom(address from, uint256 amount) external returns (bool); + /// @dev Function that burns an amount of the token of a given account, + /// deducting from the sender's allowance for said account. + /// @param from The account whose tokens will be burnt. + /// @param amount The amount that will be burnt. + /// @dev EVM selector for this function is: 0xbb2f5a58, + /// or in textual repr: burnFromCross((address,uint256),uint256) + function burnFromCross(EthCrossAccount memory from, uint256 amount) external returns (bool); + + /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`. + /// Beware that changing an allowance with this method brings the risk that someone may use both the old + /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this + /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: + /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + /// @param spender The crossaccount which will spend the funds. + /// @param amount The amount of tokens to be spent. + /// @dev EVM selector for this function is: 0x0ecd0ab0, + /// or in textual repr: approveCross((address,uint256),uint256) + function approveCross(EthCrossAccount memory spender, uint256 amount) external returns (bool); + /// @dev Function that changes total amount of the tokens. /// Throws if `msg.sender` doesn't owns all of the tokens. /// @param amount New total amount of the tokens. /// @dev EVM selector for this function is: 0xd2418ca7, /// or in textual repr: repartition(uint256) function repartition(uint256 amount) external returns (bool); + + /// @dev Transfer token for a specified address + /// @param to The crossaccount to transfer to. + /// @param amount The amount to be transferred. + /// @dev EVM selector for this function is: 0x2ada85ff, + /// or in textual repr: transferCross((address,uint256),uint256) + function transferCross(EthCrossAccount memory to, uint256 amount) external returns (bool); + + /// @dev Transfer tokens from one address to another + /// @param from The address which you want to send tokens from + /// @param to The address which you want to transfer to + /// @param amount the amount of tokens to be transferred + /// @dev EVM selector for this function is: 0xd5cf430b, + /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256) + function transferFromCross( + EthCrossAccount memory from, + EthCrossAccount memory to, + uint256 amount + ) external returns (bool); +} + +/// @dev Cross account struct +struct EthCrossAccount { + address eth; + uint256 sub; } /// @dev inlined interface --- a/tests/src/eth/events.test.ts +++ b/tests/src/eth/events.test.ts @@ -19,7 +19,7 @@ import {EthUniqueHelper, itEth, usingEthPlaygrounds} from './util'; import {IEvent, TCollectionMode} from '../util/playgrounds/types'; import {Pallets, requirePalletsOrSkip} from '../util'; -import {NormalizedEvent} from './util/playgrounds/types'; +import {EthTokenPermissions, NormalizedEvent} from './util/playgrounds/types'; let donor: IKeyringPair; @@ -119,7 +119,13 @@ ethEvents.push(event); }); const {unsubscribe, collectedEvents: subEvents} = await helper.subscribeEvents([{section: 'common', names: ['PropertyPermissionSet']}]); - await collection.methods.setTokenPropertyPermission('testKey', true, true, true).send({from: owner}); + await collection.methods.setTokenPropertyPermissions([ + ['A', [ + [EthTokenPermissions.Mutable, true], + [EthTokenPermissions.TokenOwner, true], + [EthTokenPermissions.CollectionAdmin, true]], + ], + ]).send({from: owner}); await helper.wait.newBlocks(1); expect(ethEvents).to.be.like([ { @@ -374,7 +380,13 @@ const collectionHelper = helper.ethNativeContract.collectionHelpers(owner); const result = await collection.methods.mint(owner).send({from: owner}); const tokenId = result.events.Transfer.returnValues.tokenId; - await collection.methods.setTokenPropertyPermission('A', true, true, true).send({from: owner}); + await collection.methods.setTokenPropertyPermissions([ + ['A', [ + [EthTokenPermissions.Mutable, true], + [EthTokenPermissions.TokenOwner, true], + [EthTokenPermissions.CollectionAdmin, true]], + ], + ]).send({from: owner}); const ethEvents: any = []; --- /dev/null +++ b/tests/src/eth/precompile.test.ts @@ -0,0 +1,112 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +import {IKeyringPair} from '@polkadot/types/types'; + +import {expect, itEth, usingEthPlaygrounds} from './util'; + +describe('Precompiles', () => { + let donor: IKeyringPair; + + before(async function() { + await usingEthPlaygrounds(async (_, privateKey) => { + donor = await privateKey({filename: __filename}); + }); + }); + + itEth('ecrecover is supported', async ({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const ecrecoverCompiledСontract = await helper.ethContract.compile( + 'ECRECOVER', + ` + // SPDX-License-Identifier: MIT + pragma solidity ^0.8.17; + + contract ECRECOVER{ + address addressTest = 0x12Cb274aAD8251C875c0bf6872b67d9983E53fDd; + bytes32 msgHash1 = 0xc51dac836bc7841a01c4b631fa620904fc8724d7f9f1d3c420f0e02adf229d50; + bytes32 msgHash2 = 0xc51dac836bc7841a01c4b631fa620904fc8724d7f9f1d3c420f0e02adf229d51; + uint8 v = 0x1b; + bytes32 r = 0x44287513919034a471a7dc2b2ed121f95984ae23b20f9637ba8dff471b6719ef; + bytes32 s = 0x7d7dc30309a3baffbfd9342b97d0e804092c0aeb5821319aa732bc09146eafb4; + + + function verifyValid() public view returns(bool) { + // Use ECRECOVER to verify address + return ecrecover(msgHash1, v, r, s) == (addressTest); + } + + function verifyInvalid() public view returns(bool) { + // Use ECRECOVER to verify address + return ecrecover(msgHash2, v, r, s) == (addressTest); + } + } + `, + ); + + const ecrecoverСontract = await helper.ethContract.deployByAbi(owner, ecrecoverCompiledСontract.abi, ecrecoverCompiledСontract.object); + expect(await ecrecoverСontract.methods.verifyValid().call({from: owner})).to.be.true; + expect(await ecrecoverСontract.methods.verifyInvalid().call({from: owner})).to.be.false; + }); + + itEth('sr25519 is supported', async ({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const sr25519CompiledСontract = await helper.ethContract.compile( + 'SR25519Contract', + ` + // SPDX-License-Identifier: MIT + pragma solidity ^0.8.17; + + /** + * @title SR25519 signature interface. + */ + interface SR25519 { + /** + * @dev Verify signed message using SR25519 crypto. + * @return A boolean confirming whether the public key is signer for the message. + */ + function verify( + bytes32 public_key, + bytes calldata signature, + bytes calldata message + ) external view returns (bool); + } + + contract SR25519Contract{ + SR25519 public constant sr25519 = SR25519(0x0000000000000000000000000000000000005002); + + bytes32 public_key = 0x96b2f9237ed0890fbeed891ebb81b91ac0d5d5b6e3afcdbc95df1b68d9f14036; + bytes signature = hex"4a5d733d7c568f2e88abf0467fd497f87c1be3e940ed897efdf9da72eaad394ef9918cb574ee99c54485775b17a0deaf46ff7a1f10346cea39fff0e4ede97689"; + bytes message1 = hex"7372323535313920697320737570706f72746564"; + bytes message2 = hex"7372323535313920697320737570706f7274656401"; + + + function verifyValid() public view returns(bool) { + return sr25519.verify(public_key, signature, message1); + } + + function verifyInvalid() public view returns(bool) { + return sr25519.verify(public_key, signature, message2); + } + } + `, + ); + + const sr25519Сontract = await helper.ethContract.deployByAbi(owner, sr25519CompiledСontract.abi, sr25519CompiledСontract.object); + expect(await sr25519Сontract.methods.verifyValid().call({from: owner})).to.be.true; + expect(await sr25519Сontract.methods.verifyInvalid().call({from: owner})).to.be.false; + }); +}); \ No newline at end of file --- a/tests/src/eth/reFungibleToken.test.ts +++ b/tests/src/eth/reFungibleToken.test.ts @@ -159,7 +159,55 @@ expect(+allowance).to.equal(100); } }); + + itEth('Can perform approveCross()', async ({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const spender = helper.eth.createAccount(); + const spenderSub = (await helper.arrange.createAccounts([1n], donor))[0]; + const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender); + const spenderCrossSub = helper.ethCrossAccount.fromKeyringPair(spenderSub); + + + const collection = await helper.rft.mintCollection(alice); + const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner}); + + const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId); + const contract = helper.ethNativeContract.rftToken(tokenAddress, owner); + { + const result = await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner}); + const event = result.events.Approval; + expect(event.address).to.be.equal(tokenAddress); + expect(event.returnValues.owner).to.be.equal(owner); + expect(event.returnValues.spender).to.be.equal(spender); + expect(event.returnValues.value).to.be.equal('100'); + } + + { + const allowance = await contract.methods.allowance(owner, spender).call(); + expect(+allowance).to.equal(100); + } + + + { + const result = await contract.methods.approveCross(spenderCrossSub, 100).send({from: owner}); + const event = result.events.Approval; + expect(event.address).to.be.equal(tokenAddress); + expect(event.returnValues.owner).to.be.equal(owner); + expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(spenderSub.address)); + expect(event.returnValues.value).to.be.equal('100'); + } + + { + const allowance = await collection.getTokenApprovedPieces(tokenId, {Ethereum: owner}, {Substrate: spenderSub.address}); + expect(allowance).to.equal(100n); + } + + { + //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call() + } + }); + itEth('Can perform transferFrom()', async ({helper}) => { const owner = await helper.eth.createAccountWithBalance(donor); const spender = await helper.eth.createAccountWithBalance(donor); @@ -197,7 +245,75 @@ expect(+balance).to.equal(151); } }); + + itEth('Can perform transferFromCross()', async ({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const ownerCross = helper.ethCrossAccount.fromAddress(owner); + const spender = await helper.eth.createAccountWithBalance(donor); + const receiver = helper.eth.createAccount(); + const receiverSub = (await helper.arrange.createAccounts([1n], donor))[0]; + const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiver); + const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub); + + const collection = await helper.rft.mintCollection(alice); + const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner}); + + const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId); + const contract = helper.ethNativeContract.rftToken(tokenAddress, owner); + + await contract.methods.approve(spender, 100).send({from: owner}); + + { + const result = await contract.methods.transferFromCross(ownerCross, receiverCrossEth, 49).send({from: spender}); + let event = result.events.Transfer; + expect(event.address).to.be.equal(tokenAddress); + expect(event.returnValues.from).to.be.equal(owner); + expect(event.returnValues.to).to.be.equal(receiver); + expect(event.returnValues.value).to.be.equal('49'); + event = result.events.Approval; + expect(event.address).to.be.equal(tokenAddress); + expect(event.returnValues.owner).to.be.equal(owner); + expect(event.returnValues.spender).to.be.equal(spender); + expect(event.returnValues.value).to.be.equal('51'); + } + + { + const balance = await contract.methods.balanceOf(receiver).call(); + expect(+balance).to.equal(49); + } + + { + const balance = await contract.methods.balanceOf(owner).call(); + expect(+balance).to.equal(151); + } + + { + const result = await contract.methods.transferFromCross(ownerCross, receiverCrossSub, 51).send({from: spender}); + let event = result.events.Transfer; + expect(event.address).to.be.equal(tokenAddress); + expect(event.returnValues.from).to.be.equal(owner); + expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address)); + expect(event.returnValues.value).to.be.equal('51'); + + event = result.events.Approval; + expect(event.address).to.be.equal(tokenAddress); + expect(event.returnValues.owner).to.be.equal(owner); + expect(event.returnValues.spender).to.be.equal(spender); + expect(event.returnValues.value).to.be.equal('0'); + } + + { + const balance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address}); + expect(balance).to.equal(51n); + } + + { + const balance = await contract.methods.balanceOf(owner).call(); + expect(+balance).to.equal(100); + } + }); + itEth('Can perform transfer()', async ({helper}) => { const owner = await helper.eth.createAccountWithBalance(donor); const receiver = helper.eth.createAccount(); @@ -226,7 +342,7 @@ expect(+balance).to.equal(50); } }); - + [ 'transfer', // 'transferCross', // TODO @@ -267,6 +383,56 @@ expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]); })); + itEth('Can perform transferCross()', async ({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const receiver = helper.eth.createAccount(); + const receiverSub = (await helper.arrange.createAccounts([1n], donor))[0]; + const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiver); + const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub); + const collection = await helper.rft.mintCollection(alice); + const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner}); + + const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId); + const contract = helper.ethNativeContract.rftToken(tokenAddress, owner); + + { + const result = await contract.methods.transferCross(receiverCrossEth, 50).send({from: owner}); + const event = result.events.Transfer; + expect(event.address).to.be.equal(tokenAddress); + expect(event.returnValues.from).to.be.equal(owner); + expect(event.returnValues.to).to.be.equal(receiver); + expect(event.returnValues.value).to.be.equal('50'); + } + + { + const balance = await contract.methods.balanceOf(owner).call(); + expect(+balance).to.equal(150); + } + + { + const balance = await contract.methods.balanceOf(receiver).call(); + expect(+balance).to.equal(50); + } + + { + const result = await contract.methods.transferCross(receiverCrossSub, 50).send({from: owner}); + const event = result.events.Transfer; + expect(event.address).to.be.equal(tokenAddress); + expect(event.returnValues.from).to.be.equal(owner); + expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address)); + expect(event.returnValues.value).to.be.equal('50'); + } + + { + const balance = await contract.methods.balanceOf(owner).call(); + expect(+balance).to.equal(100); + } + + { + const balance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address}); + expect(balance).to.equal(50n); + } + }); itEth('Can perform repartition()', async ({helper}) => { const owner = await helper.eth.createAccountWithBalance(donor); const receiver = await helper.eth.createAccountWithBalance(donor); @@ -353,6 +519,41 @@ expect(event.returnValues.to).to.be.equal(receiver); expect(event.returnValues.tokenId).to.be.equal(tokenId); }); + + itEth('Can perform burnFromCross()', async ({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const ownerSub = (await helper.arrange.createAccounts([10n], donor))[0]; + const ownerCross = helper.ethCrossAccount.fromAddress(owner); + const spender = await helper.eth.createAccountWithBalance(donor); + + const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender); + const ownerSubCross = helper.ethCrossAccount.fromKeyringPair(ownerSub); + + const collection = await helper.rft.mintCollection(alice); + const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner}); + + + const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId); + const contract = helper.ethNativeContract.rftToken(tokenAddress, owner); + + { + await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner}); + + await expect(contract.methods.burnFromCross(ownerCross, 50).send({from: spender})).to.be.fulfilled; + await expect(contract.methods.burnFromCross(ownerCross, 100).send({from: spender})).to.be.rejected; + expect(await contract.methods.balanceOf(owner).call({from: owner})).to.be.equal('150'); + } + { + const {tokenId} = await collection.mintToken(alice, 200n, {Substrate: ownerSub.address}); + await collection.approveToken(ownerSub, tokenId, {Ethereum: spender}, 100n); + const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId); + const contract = helper.ethNativeContract.rftToken(tokenAddress, owner); + + await expect(contract.methods.burnFromCross(ownerSubCross, 50).send({from: spender})).to.be.fulfilled; + await expect(contract.methods.burnFromCross(ownerSubCross, 100).send({from: spender})).to.be.rejected; + expect(await collection.getTokenBalance(tokenId, {Substrate: ownerSub.address})).to.be.equal(150n); + } + }); }); describe('Refungible: Fees', () => { --- a/tests/src/eth/tokenProperties.test.ts +++ b/tests/src/eth/tokenProperties.test.ts @@ -20,6 +20,7 @@ import {ITokenPropertyPermission} from '../util/playgrounds/types'; import {Pallets} from '../util'; import {UniqueNFTCollection, UniqueNFToken, UniqueRFTCollection} from '../util/playgrounds/unique'; +import {EthTokenPermissions} from './util/playgrounds/types'; describe('EVM token properties', () => { let donor: IKeyringPair; @@ -32,25 +33,170 @@ }); }); - itEth('Can be reconfigured', async({helper}) => { - const caller = await helper.eth.createAccountWithBalance(donor); - for(const [mutable,collectionAdmin, tokenOwner] of cartesian([], [false, true], [false, true], [false, true])) { - const collection = await helper.nft.mintCollection(alice); - await collection.addAdmin(alice, {Ethereum: caller}); + [ + {mode: 'nft' as const, requiredPallets: []}, + {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]}, + ].map(testCase => + itEth.ifWithPallets(`[${testCase.mode}] Set and get token property permissions`, testCase.requiredPallets, async({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const caller = await helper.ethCrossAccount.createAccountWithBalance(donor); + for(const [mutable,collectionAdmin, tokenOwner] of cartesian([], [false, true], [false, true], [false, true])) { + const {collectionId, collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C'); + const collection = await helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner); + await collection.methods.addCollectionAdminCross(caller).send({from: owner}); + + await collection.methods.setTokenPropertyPermissions([ + ['testKey', [ + [EthTokenPermissions.Mutable, mutable], + [EthTokenPermissions.TokenOwner, tokenOwner], + [EthTokenPermissions.CollectionAdmin, collectionAdmin]], + ], + ]).send({from: caller.eth}); - const address = helper.ethAddress.fromCollectionId(collection.collectionId); - const contract = helper.ethNativeContract.collection(address, 'nft', caller); - - await contract.methods.setTokenPropertyPermission('testKey', mutable, collectionAdmin, tokenOwner).send({from: caller}); - - expect(await collection.getPropertyPermissions()).to.be.deep.equal([{ - key: 'testKey', - permission: {mutable, collectionAdmin, tokenOwner}, - }]); - } - }); + expect(await helper[testCase.mode].getPropertyPermissions(collectionId)).to.be.deep.equal([{ + key: 'testKey', + permission: {mutable, collectionAdmin, tokenOwner}, + }]); + expect(await collection.methods.tokenPropertyPermissions().call({from: caller.eth})).to.be.like([ + ['testKey', [ + [EthTokenPermissions.Mutable.toString(), mutable], + [EthTokenPermissions.TokenOwner.toString(), tokenOwner], + [EthTokenPermissions.CollectionAdmin.toString(), collectionAdmin]], + ], + ]); + } + })); + [ + {mode: 'nft' as const, requiredPallets: []}, + {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]}, + ].map(testCase => + itEth.ifWithPallets(`[${testCase.mode}] Set and get multiple token property permissions as owner`, testCase.requiredPallets, async({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + + const {collectionId, collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C'); + const collection = await helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner); + + await collection.methods.setTokenPropertyPermissions([ + ['testKey_0', [ + [EthTokenPermissions.Mutable, true], + [EthTokenPermissions.TokenOwner, true], + [EthTokenPermissions.CollectionAdmin, true]], + ], + ['testKey_1', [ + [EthTokenPermissions.Mutable, true], + [EthTokenPermissions.TokenOwner, false], + [EthTokenPermissions.CollectionAdmin, true]], + ], + ['testKey_2', [ + [EthTokenPermissions.Mutable, false], + [EthTokenPermissions.TokenOwner, true], + [EthTokenPermissions.CollectionAdmin, false]], + ], + ]).send({from: owner}); + + expect(await helper[testCase.mode].getPropertyPermissions(collectionId)).to.be.deep.equal([ + { + key: 'testKey_0', + permission: {mutable: true, tokenOwner: true, collectionAdmin: true}, + }, + { + key: 'testKey_1', + permission: {mutable: true, tokenOwner: false, collectionAdmin: true}, + }, + { + key: 'testKey_2', + permission: {mutable: false, tokenOwner: true, collectionAdmin: false}, + }, + ]); + + expect(await collection.methods.tokenPropertyPermissions().call({from: owner})).to.be.like([ + ['testKey_0', [ + [EthTokenPermissions.Mutable.toString(), true], + [EthTokenPermissions.TokenOwner.toString(), true], + [EthTokenPermissions.CollectionAdmin.toString(), true]], + ], + ['testKey_1', [ + [EthTokenPermissions.Mutable.toString(), true], + [EthTokenPermissions.TokenOwner.toString(), false], + [EthTokenPermissions.CollectionAdmin.toString(), true]], + ], + ['testKey_2', [ + [EthTokenPermissions.Mutable.toString(), false], + [EthTokenPermissions.TokenOwner.toString(), true], + [EthTokenPermissions.CollectionAdmin.toString(), false]], + ], + ]); + + })); + + [ + {mode: 'nft' as const, requiredPallets: []}, + {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]}, + ].map(testCase => + itEth.ifWithPallets(`[${testCase.mode}] Set and get multiple token property permissions as admin`, testCase.requiredPallets, async({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const caller = await helper.ethCrossAccount.createAccountWithBalance(donor); + + const {collectionId, collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C'); + const collection = await helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner); + await collection.methods.addCollectionAdminCross(caller).send({from: owner}); + + await collection.methods.setTokenPropertyPermissions([ + ['testKey_0', [ + [EthTokenPermissions.Mutable, true], + [EthTokenPermissions.TokenOwner, true], + [EthTokenPermissions.CollectionAdmin, true]], + ], + ['testKey_1', [ + [EthTokenPermissions.Mutable, true], + [EthTokenPermissions.TokenOwner, false], + [EthTokenPermissions.CollectionAdmin, true]], + ], + ['testKey_2', [ + [EthTokenPermissions.Mutable, false], + [EthTokenPermissions.TokenOwner, true], + [EthTokenPermissions.CollectionAdmin, false]], + ], + ]).send({from: caller.eth}); + + expect(await helper[testCase.mode].getPropertyPermissions(collectionId)).to.be.deep.equal([ + { + key: 'testKey_0', + permission: {mutable: true, tokenOwner: true, collectionAdmin: true}, + }, + { + key: 'testKey_1', + permission: {mutable: true, tokenOwner: false, collectionAdmin: true}, + }, + { + key: 'testKey_2', + permission: {mutable: false, tokenOwner: true, collectionAdmin: false}, + }, + ]); + + expect(await collection.methods.tokenPropertyPermissions().call({from: caller.eth})).to.be.like([ + ['testKey_0', [ + [EthTokenPermissions.Mutable.toString(), true], + [EthTokenPermissions.TokenOwner.toString(), true], + [EthTokenPermissions.CollectionAdmin.toString(), true]], + ], + ['testKey_1', [ + [EthTokenPermissions.Mutable.toString(), true], + [EthTokenPermissions.TokenOwner.toString(), false], + [EthTokenPermissions.CollectionAdmin.toString(), true]], + ], + ['testKey_2', [ + [EthTokenPermissions.Mutable.toString(), false], + [EthTokenPermissions.TokenOwner.toString(), true], + [EthTokenPermissions.CollectionAdmin.toString(), false]], + ], + ]); + + })); + + [ { method: 'setProperties', methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]], @@ -301,6 +447,47 @@ const actualProps = await collectionEvm.methods.properties(token.tokenId, []).call(); expect(actualProps).to.deep.eq(expectedProps); })); + + [ + {mode: 'nft' as const, requiredPallets: []}, + {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]}, + ].map(testCase => + itEth.ifWithPallets(`[${testCase.mode}] Cant set token property permissions as non owner or admin`, testCase.requiredPallets, async({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + const caller = await helper.eth.createAccountWithBalance(donor); + + const {collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C'); + const collection = await helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner); + + await expect(collection.methods.setTokenPropertyPermissions([ + ['testKey_0', [ + [EthTokenPermissions.Mutable, true], + [EthTokenPermissions.TokenOwner, true], + [EthTokenPermissions.CollectionAdmin, true]], + ], + ]).call({from: caller})).to.be.rejectedWith('NoPermission'); + })); + + [ + {mode: 'nft' as const, requiredPallets: []}, + {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]}, + ].map(testCase => + itEth.ifWithPallets(`[${testCase.mode}] Cant set token property permissions with invalid character`, testCase.requiredPallets, async({helper}) => { + const owner = await helper.eth.createAccountWithBalance(donor); + + const {collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C'); + const collection = await helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner); + + await expect(collection.methods.setTokenPropertyPermissions([ + // "Space" is invalid character + ['testKey 0', [ + [EthTokenPermissions.Mutable, true], + [EthTokenPermissions.TokenOwner, true], + [EthTokenPermissions.CollectionAdmin, true]], + ], + ]).call({from: owner})).to.be.rejectedWith('InvalidCharacterInPropertyKey'); + })); + }); --- a/tests/src/eth/util/playgrounds/types.ts +++ b/tests/src/eth/util/playgrounds/types.ts @@ -20,3 +20,8 @@ export type EthProperty = string[]; +export enum EthTokenPermissions { + Mutable, + TokenOwner, + CollectionAdmin +} \ No newline at end of file --- a/tests/src/eth/util/playgrounds/unique.dev.ts +++ b/tests/src/eth/util/playgrounds/unique.dev.ts @@ -60,7 +60,7 @@ } async compile(name: string, src: string, imports?: ContractImports[]): Promise { - const out = JSON.parse(solc.compile(JSON.stringify({ + const compiled = JSON.parse(solc.compile(JSON.stringify({ language: 'Solidity', sources: { [`${name}.sol`]: { @@ -74,7 +74,18 @@ }, }, }, - }), {import: await this.findImports(imports)})).contracts[`${name}.sol`][name]; + }), {import: await this.findImports(imports)})); + + const hasErrors = compiled['errors'] + && compiled['errors'].length > 0 + && compiled.errors.some(function(err: any) { + return err.severity == 'error'; + }); + + if (hasErrors) { + throw compiled.errors; + } + const out = compiled.contracts[`${name}.sol`][name]; return { abi: out.abi, --- a/tests/src/interfaces/augment-api-rpc.ts +++ b/tests/src/interfaces/augment-api-rpc.ts @@ -16,7 +16,7 @@ import type { BlockHash } from '@polkadot/types/interfaces/chain'; import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate'; import type { AuthorityId } from '@polkadot/types/interfaces/consensus'; -import type { CodeUploadRequest, CodeUploadResult, ContractCallRequest, ContractExecResult, ContractInstantiateResult, InstantiateRequestV1 } from '@polkadot/types/interfaces/contracts'; +import type { CodeUploadRequest, CodeUploadResult, ContractCallRequest, ContractExecResult, ContractInstantiateResult, InstantiateRequest } from '@polkadot/types/interfaces/contracts'; import type { BlockStats } from '@polkadot/types/interfaces/dev'; import type { CreatedBlock } from '@polkadot/types/interfaces/engine'; import type { EthAccount, EthCallRequest, EthFeeHistory, EthFilter, EthFilterChanges, EthLog, EthReceipt, EthRichBlock, EthSubKind, EthSubParams, EthSyncStatus, EthTransaction, EthTransactionRequest, EthWork } from '@polkadot/types/interfaces/eth'; @@ -24,7 +24,7 @@ import type { EncodedFinalityProofs, JustificationNotification, ReportedRoundStates } from '@polkadot/types/interfaces/grandpa'; import type { MmrLeafBatchProof, MmrLeafProof } from '@polkadot/types/interfaces/mmr'; import type { StorageKind } from '@polkadot/types/interfaces/offchain'; -import type { FeeDetails, RuntimeDispatchInfoV1 } from '@polkadot/types/interfaces/payment'; +import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment'; import type { RpcMethods } from '@polkadot/types/interfaces/rpc'; import type { AccountId, AccountId32, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime'; import type { MigrationStatusResult, ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state'; @@ -174,7 +174,7 @@ * @deprecated Use the runtime interface `api.call.contractsApi.instantiate` instead * Instantiate a new contract **/ - instantiate: AugmentedRpc<(request: InstantiateRequestV1 | { origin?: any; value?: any; gasLimit?: any; code?: any; data?: any; salt?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable>; + instantiate: AugmentedRpc<(request: InstantiateRequest | { origin?: any; value?: any; gasLimit?: any; storageDepositLimit?: any; code?: any; data?: any; salt?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable>; /** * @deprecated Not available in newer versions of the contracts interfaces * Returns the projected time a given contract will be able to sustain paying its rent @@ -426,15 +426,13 @@ }; payment: { /** - * @deprecated Use `api.call.transactionPaymentApi.queryFeeDetails` instead * Query the detailed fee of a given encoded extrinsic **/ queryFeeDetails: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable>; /** - * @deprecated Use `api.call.transactionPaymentApi.queryInfo` instead * Retrieves the fee information for an encoded extrinsic **/ - queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable>; + queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable>; }; rmrk: { /** --- a/tests/src/interfaces/augment-api-runtime.ts +++ b/tests/src/interfaces/augment-api-runtime.ts @@ -6,7 +6,7 @@ import '@polkadot/api-base/types/calls'; import type { ApiTypes, AugmentedCall, DecoratedCallBase } from '@polkadot/api-base/types'; -import type { Bytes, Null, Option, Result, U256, Vec, bool, u256, u32, u64 } from '@polkadot/types-codec'; +import type { Bytes, Null, Option, Result, U256, Vec, bool, u256, u64 } from '@polkadot/types-codec'; import type { AnyNumber, ITuple } from '@polkadot/types-codec/types'; import type { CheckInherentsResult, InherentData } from '@polkadot/types/interfaces/blockbuilder'; import type { BlockHash } from '@polkadot/types/interfaces/chain'; @@ -16,7 +16,6 @@ import type { EvmAccount, EvmCallInfo, EvmCreateInfo } from '@polkadot/types/interfaces/evm'; import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics'; import type { OpaqueMetadata } from '@polkadot/types/interfaces/metadata'; -import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment'; import type { AccountId, Block, H160, H256, Header, Index, KeyTypeId, Permill, SlotDuration } from '@polkadot/types/interfaces/runtime'; import type { RuntimeVersion } from '@polkadot/types/interfaces/state'; import type { ApplyExtrinsicResult, DispatchError } from '@polkadot/types/interfaces/system'; @@ -224,21 +223,6 @@ * Validate the transaction. **/ validateTransaction: AugmentedCall Observable>; - /** - * Generic call - **/ - [key: string]: DecoratedCallBase; - }; - /** 0x37c8bb1350a9a2a8/2 */ - transactionPaymentApi: { - /** - * The transaction fee details - **/ - queryFeeDetails: AugmentedCall Observable>; - /** - * The transaction info - **/ - queryInfo: AugmentedCall Observable>; /** * Generic call **/ --- a/tests/src/interfaces/augment-types.ts +++ b/tests/src/interfaces/augment-types.ts @@ -24,7 +24,7 @@ import type { StatementKind } from '@polkadot/types/interfaces/claims'; import type { CollectiveOrigin, MemberCount, ProposalIndex, Votes, VotesTo230 } from '@polkadot/types/interfaces/collective'; import type { AuthorityId, RawVRFOutput } from '@polkadot/types/interfaces/consensus'; -import type { AliveContractInfo, CodeHash, CodeSource, CodeUploadRequest, CodeUploadResult, CodeUploadResultValue, ContractCallFlags, ContractCallRequest, ContractExecResult, ContractExecResultOk, ContractExecResultResult, ContractExecResultSuccessTo255, ContractExecResultSuccessTo260, ContractExecResultTo255, ContractExecResultTo260, ContractExecResultTo267, ContractExecResultU64, ContractInfo, ContractInstantiateResult, ContractInstantiateResultTo267, ContractInstantiateResultTo299, ContractInstantiateResultU64, ContractReturnFlags, ContractStorageKey, DeletedContract, ExecReturnValue, Gas, HostFnWeights, HostFnWeightsTo264, InstantiateRequest, InstantiateRequestV1, InstantiateRequestV2, InstantiateReturnValue, InstantiateReturnValueOk, InstantiateReturnValueTo267, InstructionWeights, Limits, LimitsTo264, PrefabWasmModule, RentProjection, Schedule, ScheduleTo212, ScheduleTo258, ScheduleTo264, SeedOf, StorageDeposit, TombstoneContractInfo, TrieId } from '@polkadot/types/interfaces/contracts'; +import type { AliveContractInfo, CodeHash, CodeSource, CodeUploadRequest, CodeUploadResult, CodeUploadResultValue, ContractCallFlags, ContractCallRequest, ContractExecResult, ContractExecResultOk, ContractExecResultResult, ContractExecResultSuccessTo255, ContractExecResultSuccessTo260, ContractExecResultTo255, ContractExecResultTo260, ContractExecResultTo267, ContractInfo, ContractInstantiateResult, ContractInstantiateResultTo267, ContractInstantiateResultTo299, ContractReturnFlags, ContractStorageKey, DeletedContract, ExecReturnValue, Gas, HostFnWeights, HostFnWeightsTo264, InstantiateRequest, InstantiateRequestV1, InstantiateRequestV2, InstantiateReturnValue, InstantiateReturnValueOk, InstantiateReturnValueTo267, InstructionWeights, Limits, LimitsTo264, PrefabWasmModule, RentProjection, Schedule, ScheduleTo212, ScheduleTo258, ScheduleTo264, SeedOf, StorageDeposit, TombstoneContractInfo, TrieId } from '@polkadot/types/interfaces/contracts'; import type { ContractConstructorSpecLatest, ContractConstructorSpecV0, ContractConstructorSpecV1, ContractConstructorSpecV2, ContractConstructorSpecV3, ContractContractSpecV0, ContractContractSpecV1, ContractContractSpecV2, ContractContractSpecV3, ContractContractSpecV4, ContractCryptoHasher, ContractDiscriminant, ContractDisplayName, ContractEventParamSpecLatest, ContractEventParamSpecV0, ContractEventParamSpecV2, ContractEventSpecLatest, ContractEventSpecV0, ContractEventSpecV1, ContractEventSpecV2, ContractLayoutArray, ContractLayoutCell, ContractLayoutEnum, ContractLayoutHash, ContractLayoutHashingStrategy, ContractLayoutKey, ContractLayoutStruct, ContractLayoutStructField, ContractMessageParamSpecLatest, ContractMessageParamSpecV0, ContractMessageParamSpecV2, ContractMessageSpecLatest, ContractMessageSpecV0, ContractMessageSpecV1, ContractMessageSpecV2, ContractMetadata, ContractMetadataLatest, ContractMetadataV0, ContractMetadataV1, ContractMetadataV2, ContractMetadataV3, ContractMetadataV4, ContractProject, ContractProjectContract, ContractProjectInfo, ContractProjectSource, ContractProjectV0, ContractSelector, ContractStorageLayout, ContractTypeSpec } from '@polkadot/types/interfaces/contractsAbi'; import type { FundIndex, FundInfo, LastContribution, TrieIndex } from '@polkadot/types/interfaces/crowdloan'; import type { CollationInfo, CollationInfoV1, ConfigData, MessageId, OverweightIndex, PageCounter, PageIndexData } from '@polkadot/types/interfaces/cumulus'; @@ -47,7 +47,7 @@ import type { StorageKind } from '@polkadot/types/interfaces/offchain'; import type { DeferredOffenceOf, Kind, OffenceDetails, Offender, OpaqueTimeSlot, ReportIdOf, Reporter } from '@polkadot/types/interfaces/offences'; import type { AbridgedCandidateReceipt, AbridgedHostConfiguration, AbridgedHrmpChannel, AssignmentId, AssignmentKind, AttestedCandidate, AuctionIndex, AuthorityDiscoveryId, AvailabilityBitfield, AvailabilityBitfieldRecord, BackedCandidate, Bidder, BufferedSessionChange, CandidateCommitments, CandidateDescriptor, CandidateEvent, CandidateHash, CandidateInfo, CandidatePendingAvailability, CandidateReceipt, CollatorId, CollatorSignature, CommittedCandidateReceipt, CoreAssignment, CoreIndex, CoreOccupied, CoreState, DisputeLocation, DisputeResult, DisputeState, DisputeStatement, DisputeStatementSet, DoubleVoteReport, DownwardMessage, ExplicitDisputeStatement, GlobalValidationData, GlobalValidationSchedule, GroupIndex, GroupRotationInfo, HeadData, HostConfiguration, HrmpChannel, HrmpChannelId, HrmpOpenChannelRequest, InboundDownwardMessage, InboundHrmpMessage, InboundHrmpMessages, IncomingParachain, IncomingParachainDeploy, IncomingParachainFixed, InvalidDisputeStatementKind, LeasePeriod, LeasePeriodOf, LocalValidationData, MessageIngestionType, MessageQueueChain, MessagingStateSnapshot, MessagingStateSnapshotEgressEntry, MultiDisputeStatementSet, NewBidder, OccupiedCore, OccupiedCoreAssumption, OldV1SessionInfo, OutboundHrmpMessage, ParaGenesisArgs, ParaId, ParaInfo, ParaLifecycle, ParaPastCodeMeta, ParaScheduling, ParaValidatorIndex, ParachainDispatchOrigin, ParachainInherentData, ParachainProposal, ParachainsInherentData, ParathreadClaim, ParathreadClaimQueue, ParathreadEntry, PersistedValidationData, PvfCheckStatement, QueuedParathread, RegisteredParachainInfo, RelayBlockNumber, RelayChainBlockNumber, RelayChainHash, RelayHash, Remark, ReplacementTimes, Retriable, ScheduledCore, Scheduling, ScrapedOnChainVotes, ServiceQuality, SessionInfo, SessionInfoValidatorGroup, SignedAvailabilityBitfield, SignedAvailabilityBitfields, SigningContext, SlotRange, SlotRange10, Statement, SubId, SystemInherentData, TransientValidationData, UpgradeGoAhead, UpgradeRestriction, UpwardMessage, ValidDisputeStatementKind, ValidationCode, ValidationCodeHash, ValidationData, ValidationDataType, ValidationFunctionParams, ValidatorSignature, ValidityAttestation, VecInboundHrmpMessage, WinnersData, WinnersData10, WinnersDataTuple, WinnersDataTuple10, WinningData, WinningData10, WinningDataEntry } from '@polkadot/types/interfaces/parachains'; -import type { FeeDetails, InclusionFee, RuntimeDispatchInfo, RuntimeDispatchInfoV1, RuntimeDispatchInfoV2 } from '@polkadot/types/interfaces/payment'; +import type { FeeDetails, InclusionFee, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment'; import type { Approvals } from '@polkadot/types/interfaces/poll'; import type { ProxyAnnouncement, ProxyDefinition, ProxyType } from '@polkadot/types/interfaces/proxy'; import type { AccountStatus, AccountValidity } from '@polkadot/types/interfaces/purchase'; @@ -273,12 +273,10 @@ ContractExecResultTo255: ContractExecResultTo255; ContractExecResultTo260: ContractExecResultTo260; ContractExecResultTo267: ContractExecResultTo267; - ContractExecResultU64: ContractExecResultU64; ContractInfo: ContractInfo; ContractInstantiateResult: ContractInstantiateResult; ContractInstantiateResultTo267: ContractInstantiateResultTo267; ContractInstantiateResultTo299: ContractInstantiateResultTo299; - ContractInstantiateResultU64: ContractInstantiateResultU64; ContractLayoutArray: ContractLayoutArray; ContractLayoutCell: ContractLayoutCell; ContractLayoutEnum: ContractLayoutEnum; @@ -1059,8 +1057,6 @@ RpcMethods: RpcMethods; RuntimeDbWeight: RuntimeDbWeight; RuntimeDispatchInfo: RuntimeDispatchInfo; - RuntimeDispatchInfoV1: RuntimeDispatchInfoV1; - RuntimeDispatchInfoV2: RuntimeDispatchInfoV2; RuntimeVersion: RuntimeVersion; RuntimeVersionApi: RuntimeVersionApi; RuntimeVersionPartial: RuntimeVersionPartial; --- a/tests/src/nesting/collectionProperties.test.ts +++ b/tests/src/nesting/collectionProperties.test.ts @@ -15,8 +15,7 @@ // along with Unique Network. If not, see . import {IKeyringPair} from '@polkadot/types/types'; -import {itSub, Pallets, usingPlaygrounds, expect} from '../util'; -import {UniqueBaseCollection} from '../util/playgrounds/unique'; +import {itSub, Pallets, usingPlaygrounds, expect, requirePalletsOrSkip} from '../util'; describe('Integration Test: Collection Properties', () => { let alice: IKeyringPair; @@ -32,116 +31,98 @@ itSub('Properties are initially empty', async ({helper}) => { const collection = await helper.nft.mintCollection(alice); expect(await collection.getProperties()).to.be.empty; - }); - - async function testSetsPropertiesForCollection(collection: UniqueBaseCollection) { - // As owner - await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}])).to.be.fulfilled; - - await collection.addAdmin(alice, {Substrate: bob.address}); - - // As administrator - await expect(collection.setProperties(bob, [{key: 'black_hole'}])).to.be.fulfilled; - - const properties = await collection.getProperties(); - expect(properties).to.include.deep.members([ - {key: 'electron', value: 'come bond'}, - {key: 'black_hole', value: ''}, - ]); - } - - itSub('Sets properties for a NFT collection', async ({helper}) => { - await testSetsPropertiesForCollection(await helper.nft.mintCollection(alice)); - }); - - itSub.ifWithPallets('Sets properties for a ReFungible collection', [Pallets.ReFungible], async ({helper}) => { - await testSetsPropertiesForCollection(await helper.rft.mintCollection(alice)); }); - - async function testCheckValidNames(collection: UniqueBaseCollection) { - // alpha symbols - await expect(collection.setProperties(alice, [{key: 'answer'}])).to.be.fulfilled; - - // numeric symbols - await expect(collection.setProperties(alice, [{key: '451'}])).to.be.fulfilled; - - // underscore symbol - await expect(collection.setProperties(alice, [{key: 'black_hole'}])).to.be.fulfilled; - - // dash symbol - await expect(collection.setProperties(alice, [{key: '-'}])).to.be.fulfilled; - - // dot symbol - await expect(collection.setProperties(alice, [{key: 'once.in.a.long.long.while...', value: 'you get a little lost'}])).to.be.fulfilled; - - const properties = await collection.getProperties(); - expect(properties).to.include.deep.members([ - {key: 'answer', value: ''}, - {key: '451', value: ''}, - {key: 'black_hole', value: ''}, - {key: '-', value: ''}, - {key: 'once.in.a.long.long.while...', value: 'you get a little lost'}, - ]); - } - - itSub('Check valid names for NFT collection properties keys', async ({helper}) => { - await testCheckValidNames(await helper.nft.mintCollection(alice)); - }); - - itSub.ifWithPallets('Check valid names for ReFungible collection properties keys', [Pallets.ReFungible], async ({helper}) => { - await testCheckValidNames(await helper.rft.mintCollection(alice)); - }); - - async function testChangesProperties(collection: UniqueBaseCollection) { - await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: ''}])).to.be.fulfilled; - - // Mutate the properties - await expect(collection.setProperties(alice, [{key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled; - - const properties = await collection.getProperties(); - expect(properties).to.include.deep.members([ - {key: 'electron', value: 'come bond'}, - {key: 'black_hole', value: 'LIGO'}, - ]); - } - - itSub('Changes properties of a NFT collection', async ({helper}) => { - await testChangesProperties(await helper.nft.mintCollection(alice)); - }); - - itSub.ifWithPallets('Changes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => { - await testChangesProperties(await helper.rft.mintCollection(alice)); - }); - - async function testDeleteProperties(collection: UniqueBaseCollection) { - await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled; - - await expect(collection.deleteProperties(alice, ['electron'])).to.be.fulfilled; - - const properties = await collection.getProperties(['black_hole', 'electron']); - expect(properties).to.be.deep.equal([ - {key: 'black_hole', value: 'LIGO'}, - ]); - } - - itSub('Deletes properties of a NFT collection', async ({helper}) => { - await testDeleteProperties(await helper.nft.mintCollection(alice)); - }); - - itSub.ifWithPallets('Deletes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => { - await testDeleteProperties(await helper.rft.mintCollection(alice)); - }); [ - // TODO enable properties for FT collection in Substrate (release 040) - // {mode: 'ft' as const, requiredPallets: []}, {mode: 'nft' as const, requiredPallets: []}, + {mode: 'ft' as const, requiredPallets: []}, {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]}, - ].map(testCase => - itSub.ifWithPallets(`Allows modifying a collection property multiple times with the same size (${testCase.mode})`, testCase.requiredPallets, async({helper}) => { + ].map(testSuite => describe(`${testSuite.mode.toUpperCase()}`, () => { + before(async function() { + // eslint-disable-next-line require-await + await usingPlaygrounds(async helper => { + requirePalletsOrSkip(this, helper, testSuite.requiredPallets); + }); + }); + + itSub('Sets properties for a collection', async ({helper}) => { + const collection = await helper[testSuite.mode].mintCollection(alice); + + // As owner + await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}])).to.be.fulfilled; + + await collection.addAdmin(alice, {Substrate: bob.address}); + + // As administrator + await expect(collection.setProperties(bob, [{key: 'black_hole'}])).to.be.fulfilled; + + const properties = await collection.getProperties(); + expect(properties).to.include.deep.members([ + {key: 'electron', value: 'come bond'}, + {key: 'black_hole', value: ''}, + ]); + }); + + itSub('Check valid names for collection properties keys', async ({helper}) => { + const collection = await helper[testSuite.mode].mintCollection(alice); + + // alpha symbols + await expect(collection.setProperties(alice, [{key: 'answer'}])).to.be.fulfilled; + + // numeric symbols + await expect(collection.setProperties(alice, [{key: '451'}])).to.be.fulfilled; + + // underscore symbol + await expect(collection.setProperties(alice, [{key: 'black_hole'}])).to.be.fulfilled; + + // dash symbol + await expect(collection.setProperties(alice, [{key: '-'}])).to.be.fulfilled; + + // dot symbol + await expect(collection.setProperties(alice, [{key: 'once.in.a.long.long.while...', value: 'you get a little lost'}])).to.be.fulfilled; + + const properties = await collection.getProperties(); + expect(properties).to.include.deep.members([ + {key: 'answer', value: ''}, + {key: '451', value: ''}, + {key: 'black_hole', value: ''}, + {key: '-', value: ''}, + {key: 'once.in.a.long.long.while...', value: 'you get a little lost'}, + ]); + }); + + itSub('Changes properties of a collection', async ({helper}) => { + const collection = await helper[testSuite.mode].mintCollection(alice); + + await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: ''}])).to.be.fulfilled; + + // Mutate the properties + await expect(collection.setProperties(alice, [{key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled; + + const properties = await collection.getProperties(); + expect(properties).to.include.deep.members([ + {key: 'electron', value: 'come bond'}, + {key: 'black_hole', value: 'LIGO'}, + ]); + }); + + itSub('Deletes properties of a collection', async ({helper}) => { + const collection = await helper[testSuite.mode].mintCollection(alice); + + await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled; + + await expect(collection.deleteProperties(alice, ['electron'])).to.be.fulfilled; + + const properties = await collection.getProperties(['black_hole', 'electron']); + expect(properties).to.be.deep.equal([ + {key: 'black_hole', value: 'LIGO'}, + ]); + }); + + itSub('Allows modifying a collection property multiple times with the same size', async({helper}) => { const propKey = 'tok-prop'; - const collection = await helper[testCase.mode].mintCollection(alice); + const collection = await helper[testSuite.mode].mintCollection(alice); const maxCollectionPropertiesSize = 40960; @@ -166,18 +147,12 @@ const consumedSpace = await collection.getPropertiesConsumedSpace(); expect(consumedSpace).to.be.equal(originalSpace); } - })); + }); - [ - // TODO enable properties for FT collection in Substrate (release 040) - // {mode: 'ft' as const, requiredPallets: []}, - {mode: 'nft' as const, requiredPallets: []}, - {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]}, - ].map(testCase => - itSub.ifWithPallets(`Adding then removing a collection property doesn't change the consumed space (${testCase.mode})`, testCase.requiredPallets, async({helper}) => { + itSub('Adding then removing a collection property doesn\'t change the consumed space', async({helper}) => { const propKey = 'tok-prop'; - const collection = await helper[testCase.mode].mintCollection(alice); + const collection = await helper[testSuite.mode].mintCollection(alice); const originalSpace = await collection.getPropertiesConsumedSpace(); const propDataSize = 4096; @@ -190,18 +165,12 @@ await collection.deleteProperties(alice, [propKey]); consumedSpace = await collection.getPropertiesConsumedSpace(); expect(consumedSpace).to.be.equal(originalSpace); - })); + }); - [ - // TODO enable properties for FT collection in Substrate (release 040) - // {mode: 'ft' as const, requiredPallets: []}, - {mode: 'nft' as const, requiredPallets: []}, - {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]}, - ].map(testCase => - itSub.ifWithPallets(`Modifying a collection property with different sizes correctly changes the consumed space (${testCase.mode})`, testCase.requiredPallets, async({helper}) => { + itSub('Modifying a collection property with different sizes correctly changes the consumed space', async({helper}) => { const propKey = 'tok-prop'; - const collection = await helper[testCase.mode].mintCollection(alice); + const collection = await helper[testSuite.mode].mintCollection(alice); const originalSpace = await collection.getPropertiesConsumedSpace(); const initPropDataSize = 4096; @@ -229,7 +198,8 @@ consumedSpace = await collection.getPropertiesConsumedSpace(); expectedConsumedSpaceDiff = biggerPropDataSize - smallerPropDataSize; expect(consumedSpace).to.be.equal(biggerPropDataSize - expectedConsumedSpaceDiff); - })); + }); + })); }); describe('Negative Integration Test: Collection Properties', () => { @@ -242,119 +212,108 @@ [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor); }); }); + + [ + {mode: 'nft' as const, requiredPallets: []}, + {mode: 'ft' as const, requiredPallets: []}, + {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]}, + ].map(testSuite => describe(`${testSuite.mode.toUpperCase()}`, () => { + before(async function() { + // eslint-disable-next-line require-await + await usingPlaygrounds(async helper => { + requirePalletsOrSkip(this, helper, testSuite.requiredPallets); + }); + }); - async function testFailsSetPropertiesIfNotOwnerOrAdmin(collection: UniqueBaseCollection) { - await expect(collection.setProperties(bob, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])) - .to.be.rejectedWith(/common\.NoPermission/); - - expect(await collection.getProperties()).to.be.empty; - } - - itSub('Fails to set properties in a NFT collection if not its onwer/administrator', async ({helper}) => { - await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.nft.mintCollection(alice)); - }); - - itSub.ifWithPallets('Fails to set properties in a ReFungible collection if not its onwer/administrator', [Pallets.ReFungible], async ({helper}) => { - await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.rft.mintCollection(alice)); - }); + itSub('Fails to set properties in a collection if not its onwer/administrator', async ({helper}) => { + const collection = await helper[testSuite.mode].mintCollection(alice); + + await expect(collection.setProperties(bob, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])) + .to.be.rejectedWith(/common\.NoPermission/); - async function testFailsSetPropertiesThatExeedLimits(collection: UniqueBaseCollection) { - const spaceLimit = (await (collection.helper!.api! as any).query.common.collectionProperties(collection.collectionId)).spaceLimit.toNumber(); + expect(await collection.getProperties()).to.be.empty; + }); - // Mute the general tx parsing error, too many bytes to process - { - console.error = () => {}; + itSub('Fails to set properties that exceed the limits', async ({helper}) => { + const collection = await helper[testSuite.mode].mintCollection(alice); + + const spaceLimit = (await (collection.helper!.api! as any).query.common.collectionProperties(collection.collectionId)).spaceLimit.toNumber(); + + // Mute the general tx parsing error, too many bytes to process + { + console.error = () => {}; + await expect(collection.setProperties(alice, [ + {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))}, + ])).to.be.rejected; + } + + expect(await collection.getProperties(['electron'])).to.be.empty; + await expect(collection.setProperties(alice, [ - {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))}, - ])).to.be.rejected; - } - - expect(await collection.getProperties(['electron'])).to.be.empty; - - await expect(collection.setProperties(alice, [ - {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, - {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, - ])).to.be.rejectedWith(/common\.NoSpaceForProperty/); - - expect(await collection.getProperties(['electron', 'black_hole'])).to.be.empty; - } - - itSub('Fails to set properties that exceed the limits (NFT)', async ({helper}) => { - await testFailsSetPropertiesThatExeedLimits(await helper.nft.mintCollection(alice)); - }); - - itSub.ifWithPallets('Fails to set properties that exceed the limits (ReFungible)', [Pallets.ReFungible], async ({helper}) => { - await testFailsSetPropertiesThatExeedLimits(await helper.rft.mintCollection(alice)); - }); + {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, + {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, + ])).to.be.rejectedWith(/common\.NoSpaceForProperty/); - async function testFailsSetMorePropertiesThanAllowed(collection: UniqueBaseCollection) { - const propertiesToBeSet = []; - for (let i = 0; i < 65; i++) { - propertiesToBeSet.push({ - key: 'electron_' + i, - value: Math.random() > 0.5 ? 'high' : 'low', - }); - } - - await expect(collection.setProperties(alice, propertiesToBeSet)). - to.be.rejectedWith(/common\.PropertyLimitReached/); - - expect(await collection.getProperties()).to.be.empty; - } - - itSub('Fails to set more properties than it is allowed (NFT)', async ({helper}) => { - await testFailsSetMorePropertiesThanAllowed(await helper.nft.mintCollection(alice)); - }); - - itSub.ifWithPallets('Fails to set more properties than it is allowed (ReFungible)', [Pallets.ReFungible], async ({helper}) => { - await testFailsSetMorePropertiesThanAllowed(await helper.rft.mintCollection(alice)); - }); + expect(await collection.getProperties(['electron', 'black_hole'])).to.be.empty; + }); + + itSub('Fails to set more properties than it is allowed', async ({helper}) => { + const collection = await helper[testSuite.mode].mintCollection(alice); + + const propertiesToBeSet = []; + for (let i = 0; i < 65; i++) { + propertiesToBeSet.push({ + key: 'electron_' + i, + value: Math.random() > 0.5 ? 'high' : 'low', + }); + } + + await expect(collection.setProperties(alice, propertiesToBeSet)). + to.be.rejectedWith(/common\.PropertyLimitReached/); + + expect(await collection.getProperties()).to.be.empty; + }); + + itSub('Fails to set properties with invalid names', async ({helper}) => { + const collection = await helper[testSuite.mode].mintCollection(alice); + + const invalidProperties = [ + [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}], + [{key: 'Mr/Sandman', value: 'Bring me a gene'}], + [{key: 'déjà vu', value: 'hmm...'}], + ]; - async function testFailsSetPropertiesWithInvalidNames(collection: UniqueBaseCollection) { - const invalidProperties = [ - [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}], - [{key: 'Mr/Sandman', value: 'Bring me a gene'}], - [{key: 'déjà vu', value: 'hmm...'}], - ]; - - for (let i = 0; i < invalidProperties.length; i++) { + for (let i = 0; i < invalidProperties.length; i++) { + await expect( + collection.setProperties(alice, invalidProperties[i]), + `on rejecting the new badly-named property #${i}`, + ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/); + } + await expect( - collection.setProperties(alice, invalidProperties[i]), - `on rejecting the new badly-named property #${i}`, - ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/); - } - - await expect( - collection.setProperties(alice, [{key: '', value: 'nothing must not exist'}]), - 'on rejecting an unnamed property', - ).to.be.rejectedWith(/common\.EmptyPropertyKey/); - - await expect( - collection.setProperties(alice, [{key: 'CRISPR-Cas9', value: 'rewriting nature!'}]), - 'on setting the correctly-but-still-badly-named property', - ).to.be.fulfilled; - - const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat(''); - - const properties = await collection.getProperties(keys); - expect(properties).to.be.deep.equal([ - {key: 'CRISPR-Cas9', value: 'rewriting nature!'}, - ]); - - for (let i = 0; i < invalidProperties.length; i++) { + collection.setProperties(alice, [{key: '', value: 'nothing must not exist'}]), + 'on rejecting an unnamed property', + ).to.be.rejectedWith(/common\.EmptyPropertyKey/); + await expect( - collection.deleteProperties(alice, invalidProperties[i].map(propertySet => propertySet.key)), - `on trying to delete the non-existent badly-named property #${i}`, - ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/); - } - } - - itSub('Fails to set properties with invalid names (NFT)', async ({helper}) => { - await testFailsSetPropertiesWithInvalidNames(await helper.nft.mintCollection(alice)); - }); - - itSub.ifWithPallets('Fails to set properties with invalid names (ReFungible)', [Pallets.ReFungible], async ({helper}) => { - await testFailsSetPropertiesWithInvalidNames(await helper.rft.mintCollection(alice)); - }); + collection.setProperties(alice, [{key: 'CRISPR-Cas9', value: 'rewriting nature!'}]), + 'on setting the correctly-but-still-badly-named property', + ).to.be.fulfilled; + + const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat(''); + + const properties = await collection.getProperties(keys); + expect(properties).to.be.deep.equal([ + {key: 'CRISPR-Cas9', value: 'rewriting nature!'}, + ]); + + for (let i = 0; i < invalidProperties.length; i++) { + await expect( + collection.deleteProperties(alice, invalidProperties[i].map(propertySet => propertySet.key)), + `on trying to delete the non-existent badly-named property #${i}`, + ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/); + } + }); + })); }); \ No newline at end of file --- a/tests/src/pallet-presence.test.ts +++ b/tests/src/pallet-presence.test.ts @@ -80,6 +80,7 @@ requiredPallets.push( refungible, appPromotion, + foreignAssets, ); } else if (chain.eq('UNIQUE')) { // Insert Unique additional pallets here -- gitstuff