From c9b1333a14f4e29d81992c0bfd6529847e90a132 Mon Sep 17 00:00:00 2001 From: Yaroslav Bolyukin Date: Thu, 12 May 2022 11:38:32 +0000 Subject: [PATCH] Merge remote-tracking branch 'origin/feature/collection-and-nft-props-rebased' into feature/pallet-structure-rebased --- --- a/client/rpc/src/lib.rs +++ b/client/rpc/src/lib.rs @@ -19,7 +19,10 @@ use codec::Decode; use jsonrpc_core::{Error as RpcError, ErrorCode, Result}; use jsonrpc_derive::rpc; -use up_data_structs::{RpcCollection, CollectionId, CollectionStats, CollectionLimits, TokenId}; +use up_data_structs::{ + RpcCollection, CollectionId, CollectionStats, CollectionLimits, TokenId, Property, + PropertyKeyPermission, TokenData, +}; use sp_api::{BlockId, BlockT, ProvideRuntimeApi, ApiExt}; use sp_blockchain::HeaderBackend; use up_rpc::UniqueApi as UniqueRuntimeApi; @@ -76,6 +79,40 @@ at: Option, ) -> Result>; + #[rpc(name = "unique_collectionProperties")] + fn collection_properties( + &self, + collection: CollectionId, + keys: Vec, + at: Option, + ) -> Result>; + + #[rpc(name = "unique_tokenProperties")] + fn token_properties( + &self, + collection: CollectionId, + token_id: TokenId, + properties: Vec, + at: Option, + ) -> Result>; + + #[rpc(name = "unique_propertyPermissions")] + fn property_permissions( + &self, + collection: CollectionId, + keys: Vec, + at: Option, + ) -> Result>; + + #[rpc(name = "unique_tokenData")] + fn token_data( + &self, + collection: CollectionId, + token_id: TokenId, + keys: Vec, + at: Option, + ) -> Result>; + #[rpc(name = "unique_totalSupply")] fn total_supply(&self, collection: CollectionId, at: Option) -> Result; #[rpc(name = "unique_accountBalance")] @@ -177,7 +214,9 @@ macro_rules! pass_method { ( - $method_name:ident($($name:ident: $ty:ty),* $(,)?) -> $result:ty $(=> $mapper:expr)? + $method_name:ident( + $($(#[map(|$map_arg:ident| $map:expr)])? $name:ident: $ty:ty),* $(,)? + ) -> $result:ty $(=> $mapper:expr)? $(; changed_in $ver:expr, $changed_method_name:ident ($($changed_name:expr), * $(,)?) => $fixer:expr)* ) => { fn $method_name( @@ -205,7 +244,7 @@ let result = $(if _api_version < $ver { api.$changed_method_name(&at, $($changed_name),*).map(|r| r.map($fixer)) } else)* - { api.$method_name(&at, $($name),*) }; + { api.$method_name(&at, $($((|$map_arg: $ty| $map))? ($name)),*) }; let result = result.map_err(|e| RpcError { code: ErrorCode::ServerError(Error::RuntimeError.into()), @@ -242,6 +281,36 @@ pass_method!(const_metadata(collection: CollectionId, token: TokenId) -> Vec); pass_method!(variable_metadata(collection: CollectionId, token: TokenId) -> Vec); + pass_method!(collection_properties( + collection: CollectionId, + + #[map(|keys| string_keys_to_bytes_keys(keys))] + keys: Vec + ) -> Vec); + + pass_method!(token_properties( + collection: CollectionId, + token_id: TokenId, + + #[map(|keys| string_keys_to_bytes_keys(keys))] + properties: Vec + ) -> Vec); + + pass_method!(property_permissions( + collection: CollectionId, + + #[map(|keys| string_keys_to_bytes_keys(keys))] + keys: Vec + ) -> Vec); + + pass_method!(token_data( + collection: CollectionId, + token_id: TokenId, + + #[map(|keys| string_keys_to_bytes_keys(keys))] + keys: Vec, + ) -> TokenData); + pass_method!(total_supply(collection: CollectionId) -> u32); pass_method!(account_balance(collection: CollectionId, account: CrossAccountId) -> u32); pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string()); @@ -256,3 +325,7 @@ pass_method!(next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Option); pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option); } + +fn string_keys_to_bytes_keys(keys: Vec) -> Vec> { + keys.into_iter().map(|key| key.into_bytes()).collect() +} --- a/pallets/common/src/lib.rs +++ b/pallets/common/src/lib.rs @@ -35,7 +35,8 @@ FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT, CUSTOM_DATA_LIMIT, CollectionLimits, CustomDataLimit, CreateCollectionData, SponsorshipState, CreateItemExData, SponsoringRateLimit, budget::Budget, COLLECTION_FIELD_LIMIT, CollectionField, - PhantomType, + PhantomType, Property, Properties, PropertiesPermissionMap, PropertyKey, PropertyPermission, + PropertiesError, PropertyKeyPermission, TokenData, TrySet, }; pub use pallet::*; use sp_core::H160; @@ -288,6 +289,16 @@ T::CrossAccountId, u128, ), + + CollectionPropertySet(CollectionId, Property), + + CollectionPropertyDeleted(CollectionId, PropertyKey), + + TokenPropertySet(CollectionId, TokenId, Property), + + TokenPropertyDeleted(CollectionId, TokenId, PropertyKey), + + PropertyPermissionSet(CollectionId, PropertyKeyPermission), } #[pallet::error] @@ -319,7 +330,6 @@ CollectionLimitBoundsExceeded, /// Tried to enable permissions which are only permitted to be disabled OwnerPermissionsCantBeReverted, - /// Collection settings not allowing items transferring TransferNotAllowed, /// Account token limit exceeded per collection @@ -355,6 +365,18 @@ /// Tried to store more data than allowed in collection field CollectionFieldSizeExceeded, + + /// Tried to store more property data than allowed + NoSpaceForProperty, + + /// Tried to store more property keys than allowed + PropertyLimitReached, + + /// Unable to read array of unbounded keys + UnableToReadUnboundedKeys, + + /// Only ASCII letters, digits, and '_', '-' are allowed + InvalidCharacterInPropertyKey, } #[pallet::storage] @@ -372,6 +394,26 @@ QueryKind = OptionQuery, >; + /// Collection properties + #[pallet::storage] + #[pallet::getter(fn collection_properties)] + pub type CollectionProperties = StorageMap< + Hasher = Blake2_128Concat, + Key = CollectionId, + Value = Properties, + QueryKind = ValueQuery, + OnEmpty = up_data_structs::CollectionProperties, + >; + + #[pallet::storage] + #[pallet::getter(fn property_permissions)] + pub type CollectionPropertyPermissions = StorageMap< + Hasher = Blake2_128Concat, + Key = CollectionId, + Value = PropertiesPermissionMap, + QueryKind = ValueQuery, + >; + /// Large variable-size collection fields are extracted here #[pallet::storage] pub type CollectionData = StorageNMap< @@ -420,6 +462,7 @@ CollectionStats, CollectionId, TokenId, + PhantomType>, PhantomType>, ), QueryKind = OptionQuery, @@ -539,6 +582,23 @@ limits, meta_update_permission, } = >::get(collection)?; + + let token_property_permissions = >::get(collection) + .iter() + .map(|(key, permission)| PropertyKeyPermission { + key: key.clone(), + permission: permission.clone(), + }) + .collect(); + + let properties = >::get(collection) + .iter() + .map(|(key, value)| Property { + key: key.clone(), + value: value.clone() + }) + .collect(); + Some(RpcCollection { name: name.into_inner(), description: description.into_inner(), @@ -566,6 +626,8 @@ CollectionField::VariableOnChainSchema, )) .into_inner(), + token_property_permissions, + properties, }) } } @@ -617,6 +679,23 @@ meta_update_permission: data.meta_update_permission.unwrap_or_default(), }; + let mut collection_properties = up_data_structs::CollectionProperties::get(); + collection_properties.try_set_from_iter( + data.properties.into_iter() + .map(|p| (p.key, p.value)) + ).map_err(|e| -> Error { e.into() })?; + + CollectionProperties::::insert(id, collection_properties); + + let mut token_props_permissions = PropertiesPermissionMap::new(); + token_props_permissions.try_set_from_iter( + data.token_property_permissions + .into_iter() + .map(|property| (property.key, property.permission)) + ).map_err(|e| -> Error { e.into() })?; + + CollectionPropertyPermissions::::insert(id, token_props_permissions); + // Take a (non-refundable) deposit of collection creation { let mut imbalance = @@ -688,6 +767,174 @@ Ok(()) } + pub fn set_collection_property( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + property: Property, + ) -> DispatchResult { + collection.check_is_owner_or_admin(sender)?; + + CollectionProperties::::try_mutate(collection.id, |properties| { + let property = property.clone(); + properties.try_set(property.key, property.value) + }) + .map_err(|e| -> Error { e.into() })?; + + Self::deposit_event(Event::CollectionPropertySet(collection.id, property)); + + Ok(()) + } + + pub fn set_collection_properties( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + properties: Vec, + ) -> DispatchResult { + for property in properties { + Self::set_collection_property(collection, sender, property)?; + } + + Ok(()) + } + + pub fn delete_collection_property( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + property_key: PropertyKey, + ) -> DispatchResult { + collection.check_is_owner_or_admin(sender)?; + + CollectionProperties::::try_mutate(collection.id, |properties| { + properties.remove(&property_key) + }).map_err(|e| -> Error { e.into() })?; + + Self::deposit_event(Event::CollectionPropertyDeleted( + collection.id, + property_key, + )); + + Ok(()) + } + + pub fn delete_collection_properties( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + property_keys: Vec, + ) -> DispatchResult { + for key in property_keys { + Self::delete_collection_property(collection, sender, key)?; + } + + Ok(()) + } + + pub fn set_property_permission( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + property_permission: PropertyKeyPermission, + ) -> DispatchResult { + collection.check_is_owner_or_admin(sender)?; + + let all_permissions = CollectionPropertyPermissions::::get(collection.id); + let current_permission = all_permissions.get(&property_permission.key); + if matches![ + current_permission, + Some(PropertyPermission { mutable: false, .. }) + ] { + return Err(>::NoPermission.into()); + } + + CollectionPropertyPermissions::::try_mutate(collection.id, |permissions| { + let property_permission = property_permission.clone(); + permissions.try_set(property_permission.key, property_permission.permission) + }) + .map_err(|_| -> Error { PropertiesError::PropertyLimitReached.into() })?; + + Self::deposit_event(Event::PropertyPermissionSet( + collection.id, + property_permission, + )); + + Ok(()) + } + + pub fn set_property_permissions( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + property_permissions: Vec, + ) -> DispatchResult { + for prop_pemission in property_permissions { + Self::set_property_permission(collection, sender, prop_pemission)?; + } + + Ok(()) + } + + pub fn bytes_keys_to_property_keys( + keys: Vec>, + ) -> Result, DispatchError> { + keys.into_iter() + .map(|key| -> Result { + key.try_into() + .map_err(|_| >::UnableToReadUnboundedKeys.into()) + }) + .collect::, DispatchError>>() + } + + pub fn check_property_key(key: &PropertyKey) -> Result<(), DispatchError> { + let key_str = sp_std::str::from_utf8(key.as_slice()) + .map_err(|_| >::InvalidCharacterInPropertyKey)?; + + for ch in key_str.chars() { + if !ch.is_ascii_alphanumeric() && ch != '_' && ch != '-' { + return Err(>::InvalidCharacterInPropertyKey.into()); + } + } + + Ok(()) + } + + pub fn filter_collection_properties( + collection_id: CollectionId, + keys: Vec, + ) -> Result, DispatchError> { + let properties = Self::collection_properties(collection_id); + + let properties = keys + .into_iter() + .filter_map(|key| { + properties.get(&key) + .map(|value| Property { + key, + value: value.clone(), + }) + }) + .collect(); + + Ok(properties) + } + + pub fn filter_property_permissions( + collection_id: CollectionId, + keys: Vec, + ) -> Result, DispatchError> { + let permissions = Self::property_permissions(collection_id); + + let key_permissions = keys + .into_iter() + .filter_map(|key| { + permissions + .get(&key) + .map(|permission| PropertyKeyPermission { + key, + permission: permission.clone(), + }) + }) + .collect(); + + Ok(key_permissions) + } + fn set_field_raw( collection_id: CollectionId, field: CollectionField, @@ -840,6 +1087,11 @@ fn create_multiple_items(amount: u32) -> Weight; fn create_multiple_items_ex(cost: &CreateItemExData) -> Weight; fn burn_item() -> Weight; + fn set_collection_properties(amount: u32) -> Weight; + fn delete_collection_properties(amount: u32) -> Weight; + fn set_token_properties(amount: u32) -> Weight; + fn delete_token_properties(amount: u32) -> Weight; + fn set_property_permissions(amount: u32) -> Weight; fn transfer() -> Weight; fn approve() -> Weight; fn transfer_from() -> Weight; @@ -874,7 +1126,33 @@ token: TokenId, amount: u128, ) -> DispatchResultWithPostInfo; - + fn set_collection_properties( + &self, + sender: T::CrossAccountId, + properties: Vec, + ) -> DispatchResultWithPostInfo; + fn delete_collection_properties( + &self, + sender: &T::CrossAccountId, + property_keys: Vec, + ) -> DispatchResultWithPostInfo; + fn set_token_properties( + &self, + sender: T::CrossAccountId, + token_id: TokenId, + property: Vec, + ) -> DispatchResultWithPostInfo; + fn delete_token_properties( + &self, + sender: T::CrossAccountId, + token_id: TokenId, + property_keys: Vec, + ) -> DispatchResultWithPostInfo; + fn set_property_permissions( + &self, + sender: &T::CrossAccountId, + property_permissions: Vec, + ) -> DispatchResultWithPostInfo; fn transfer( &self, sender: T::CrossAccountId, @@ -931,7 +1209,7 @@ fn token_owner(&self, token: TokenId) -> Option; fn const_metadata(&self, token: TokenId) -> Vec; fn variable_metadata(&self, token: TokenId) -> Vec; - + fn token_properties(&self, token_id: TokenId, keys: Vec) -> Vec; /// Amount of unique collection tokens fn total_supply(&self) -> u32; /// Amount of different tokens account has (Applicable to nonfungible/refungible) @@ -957,3 +1235,13 @@ Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }), } } + +impl From for Error { + fn from(error: PropertiesError) -> Self { + match error { + PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty, + PropertiesError::PropertyLimitReached => Self::PropertyLimitReached, + PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey, + } + } +} --- a/pallets/fungible/src/common.rs +++ b/pallets/fungible/src/common.rs @@ -21,7 +21,7 @@ use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight}; use sp_runtime::ArithmeticError; use sp_std::{vec::Vec, vec}; -use up_data_structs::CustomDataLimit; +use up_data_structs::{CustomDataLimit, Property, PropertyKey, PropertyKeyPermission}; use crate::{ Allowance, Balance, Config, Error, FungibleHandle, Pallet, SelfWeightOf, weights::WeightInfo, @@ -50,6 +50,26 @@ >::burn_item() } + fn set_collection_properties(amount: u32) -> Weight { + >::set_collection_properties(amount) + } + + fn delete_collection_properties(amount: u32) -> Weight { + >::delete_collection_properties(amount) + } + + fn set_token_properties(amount: u32) -> Weight { + >::set_token_properties(amount) + } + + fn delete_token_properties(amount: u32) -> Weight { + >::delete_token_properties(amount) + } + + fn set_property_permissions(amount: u32) -> Weight { + >::set_property_permissions(amount) + } + fn transfer() -> Weight { >::transfer() } @@ -225,6 +245,48 @@ ) } + fn set_collection_properties( + &self, + _sender: T::CrossAccountId, + _property: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + + fn delete_collection_properties( + &self, + _sender: &T::CrossAccountId, + _property_keys: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + + fn set_token_properties( + &self, + _sender: T::CrossAccountId, + _token_id: TokenId, + _property: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + + fn set_property_permissions( + &self, + _sender: &T::CrossAccountId, + _property_permissions: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + + fn delete_token_properties( + &self, + _sender: T::CrossAccountId, + _token_id: TokenId, + _property_keys: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + fn set_variable_metadata( &self, _sender: T::CrossAccountId, @@ -274,6 +336,10 @@ Vec::new() } + fn token_properties(&self, _token_id: TokenId, _keys: Vec) -> Vec { + Vec::new() + } + fn total_supply(&self) -> u32 { 1 } --- a/pallets/fungible/src/lib.rs +++ b/pallets/fungible/src/lib.rs @@ -61,6 +61,8 @@ FungibleItemsDontHaveData, /// Fungible token does not support nested FungibleDisallowsNesting, + /// Setting item properties is not allowed + SettingPropertiesNotAllowed, } #[pallet::config] --- a/pallets/fungible/src/weights.rs +++ b/pallets/fungible/src/weights.rs @@ -35,6 +35,11 @@ fn create_item() -> Weight; fn create_multiple_items_ex(b: u32, ) -> Weight; fn burn_item() -> Weight; + fn set_collection_properties(amount: u32) -> Weight; + fn delete_collection_properties(amount: u32) -> Weight; + fn set_token_properties(amount: u32) -> Weight; + fn delete_token_properties(amount: u32) -> Weight; + fn set_property_permissions(amount: u32) -> Weight; fn transfer() -> Weight; fn approve() -> Weight; fn transfer_from() -> Weight; @@ -69,6 +74,32 @@ .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } + + fn set_collection_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn delete_collection_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn set_token_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn delete_token_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn set_property_permissions(_amount: u32) -> Weight { + // Error + 0 + } + // Storage: Fungible Balance (r:2 w:2) fn transfer() -> Weight { (17_713_000 as Weight) @@ -126,6 +157,32 @@ .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } + + fn set_collection_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn delete_collection_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn set_token_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn delete_token_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn set_property_permissions(_amount: u32) -> Weight { + // Error + 0 + } + // Storage: Fungible Balance (r:2 w:2) fn transfer() -> Weight { (17_713_000 as Weight) --- a/pallets/nonfungible/src/common.rs +++ b/pallets/nonfungible/src/common.rs @@ -17,7 +17,10 @@ use core::marker::PhantomData; use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, BoundedVec}; -use up_data_structs::{TokenId, CustomDataLimit, CreateItemExData, CollectionId, budget::Budget}; +use up_data_structs::{ + TokenId, CustomDataLimit, CreateItemExData, CollectionId, budget::Budget, Property, + PropertyKey, PropertyKeyPermission, +}; use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight}; use sp_runtime::DispatchError; use sp_std::vec::Vec; @@ -48,6 +51,26 @@ >::burn_item() } + fn set_collection_properties(amount: u32) -> Weight { + >::set_collection_properties(amount) + } + + fn delete_collection_properties(amount: u32) -> Weight { + >::delete_collection_properties(amount) + } + + fn set_token_properties(amount: u32) -> Weight { + >::set_token_properties(amount) + } + + fn delete_token_properties(amount: u32) -> Weight { + >::delete_token_properties(amount) + } + + fn set_property_permissions(amount: u32) -> Weight { + >::set_property_permissions(amount) + } + fn transfer() -> Weight { >::transfer() } @@ -77,6 +100,7 @@ up_data_structs::CreateItemData::NFT(data) => Ok(CreateItemData:: { const_data: data.const_data, variable_data: data.variable_data, + properties: data.properties, owner: to.clone(), }), _ => fail!(>::NotNonfungibleDataUsedToMintFungibleCollectionToken), @@ -139,6 +163,74 @@ ) } + fn set_collection_properties( + &self, + sender: T::CrossAccountId, + properties: Vec, + ) -> DispatchResultWithPostInfo { + 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, + ) -> DispatchResultWithPostInfo { + let weight = >::delete_collection_properties(property_keys.len() as u32); + + with_weight( + >::delete_collection_properties(self, &sender, property_keys), + weight, + ) + } + + fn set_token_properties( + &self, + sender: T::CrossAccountId, + token_id: TokenId, + properties: Vec, + ) -> DispatchResultWithPostInfo { + let weight = >::set_token_properties(properties.len() as u32); + + with_weight( + >::set_token_properties(self, &sender, token_id, properties), + weight, + ) + } + + fn delete_token_properties( + &self, + sender: T::CrossAccountId, + token_id: TokenId, + property_keys: Vec, + ) -> DispatchResultWithPostInfo { + let weight = >::delete_token_properties(property_keys.len() as u32); + + with_weight( + >::delete_token_properties(self, &sender, token_id, property_keys), + weight, + ) + } + + fn set_property_permissions( + &self, + sender: &T::CrossAccountId, + property_permissions: Vec, + ) -> DispatchResultWithPostInfo { + let weight = + >::set_property_permissions(property_permissions.len() as u32); + + with_weight( + >::set_property_permissions(self, sender, property_permissions), + weight, + ) + } + fn burn_item( &self, sender: T::CrossAccountId, @@ -294,6 +386,20 @@ .into_inner() } + fn token_properties(&self, token_id: TokenId, keys: Vec) -> Vec { + let properties = >::token_properties((self.id, token_id)); + + keys.into_iter() + .filter_map(|key| { + properties.get(&key) + .map(|value| Property { + key, + value: value.clone(), + }) + }) + .collect() + } + fn total_supply(&self) -> u32 { >::total_supply(self) } --- a/pallets/nonfungible/src/erc.rs +++ b/pallets/nonfungible/src/erc.rs @@ -274,6 +274,7 @@ CreateItemData:: { const_data: BoundedVec::default(), variable_data: BoundedVec::default(), + properties: BoundedVec::default(), owner: to, }, &budget, @@ -321,6 +322,7 @@ .try_into() .map_err(|_| "token uri is too long")?, variable_data: BoundedVec::default(), + properties: BoundedVec::default(), owner: to, }, &budget, @@ -438,6 +440,7 @@ .map(|_| CreateItemData:: { const_data: BoundedVec::default(), variable_data: BoundedVec::default(), + properties: BoundedVec::default(), owner: to.clone(), }) .collect(); @@ -481,6 +484,7 @@ .try_into() .map_err(|_| "token uri is too long")?, variable_data: vec![].try_into().unwrap(), + properties: BoundedVec::default(), owner: to.clone(), }); } --- a/pallets/nonfungible/src/lib.rs +++ b/pallets/nonfungible/src/lib.rs @@ -20,7 +20,8 @@ use frame_support::{BoundedVec, ensure, fail}; use up_data_structs::{ AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData, - mapping::TokenAddressMapping, NestingRule, budget::Budget, + mapping::TokenAddressMapping, NestingRule, budget::Budget, Property, PropertyPermission, + PropertyKey, PropertyKeyPermission, Properties, TrySet, }; use pallet_evm::account::CrossAccountId; use pallet_common::{ @@ -94,6 +95,15 @@ QueryKind = OptionQuery, >; + #[pallet::storage] + #[pallet::getter(fn token_properties)] + pub type TokenProperties = StorageNMap< + Key = (Key, Key), + Value = Properties, + QueryKind = ValueQuery, + OnEmpty = up_data_structs::TokenProperties, + >; + /// Used to enumerate tokens owned by account #[pallet::storage] pub type Owned = StorageNMap< @@ -246,6 +256,148 @@ Ok(()) } + pub fn set_token_property( + collection: &NonfungibleHandle, + sender: &T::CrossAccountId, + token_id: TokenId, + property: Property, + ) -> DispatchResult { + Self::check_token_change_permission(collection, sender, token_id, &property.key)?; + + >::try_mutate((collection.id, token_id), |properties| { + let property = property.clone(); + properties.try_set(property.key, property.value) + }) + .map_err(|e| -> CommonError { e.into() })?; + + >::deposit_event(CommonEvent::TokenPropertySet( + collection.id, + token_id, + property, + )); + + Ok(()) + } + + pub fn set_token_properties( + collection: &NonfungibleHandle, + sender: &T::CrossAccountId, + token_id: TokenId, + properties: Vec, + ) -> DispatchResult { + for property in properties { + Self::set_token_property(collection, sender, token_id, property)?; + } + + Ok(()) + } + + pub fn delete_token_property( + collection: &NonfungibleHandle, + sender: &T::CrossAccountId, + token_id: TokenId, + property_key: PropertyKey, + ) -> DispatchResult { + Self::check_token_change_permission(collection, sender, token_id, &property_key)?; + + >::try_mutate((collection.id, token_id), |properties| { + properties.remove(&property_key) + }).map_err(|e| -> CommonError { e.into() })?; + + >::deposit_event(CommonEvent::TokenPropertyDeleted( + collection.id, + token_id, + property_key, + )); + + Ok(()) + } + + fn check_token_change_permission( + collection: &NonfungibleHandle, + sender: &T::CrossAccountId, + token_id: TokenId, + property_key: &PropertyKey, + ) -> DispatchResult { + let permission = >::property_permissions(collection.id) + .get(property_key) + .map(|p| p.clone()) + .unwrap_or(PropertyPermission::none()); + + let token_data = >::get((collection.id, token_id)) + .ok_or(>::TokenNotFound)?; + + let check_token_owner = || -> DispatchResult { + ensure!(&token_data.owner == sender, >::NoPermission); + Ok(()) + }; + + let is_property_exists = TokenProperties::::get((collection.id, token_id)) + .get(property_key) + .is_some(); + + match permission { + PropertyPermission { mutable: false, .. } if is_property_exists => { + Err(>::NoPermission.into()) + } + + PropertyPermission { + collection_admin, + token_owner, + .. + } => { + let mut check_result = Err(>::NoPermission.into()); + + if collection_admin { + check_result = collection.check_is_owner_or_admin(sender); + } + + if token_owner { + check_result.or(check_token_owner()) + } else { + check_result + } + } + } + } + + pub fn delete_token_properties( + collection: &NonfungibleHandle, + sender: &T::CrossAccountId, + token_id: TokenId, + property_keys: Vec, + ) -> DispatchResult { + for key in property_keys { + Self::delete_token_property(collection, sender, token_id, key)?; + } + + Ok(()) + } + + pub fn set_collection_properties( + collection: &NonfungibleHandle, + sender: &T::CrossAccountId, + properties: Vec, + ) -> DispatchResult { + >::set_collection_properties(collection, sender, properties) + } + + pub fn delete_collection_properties( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + property_keys: Vec, + ) -> DispatchResult { + >::delete_collection_properties(collection, sender, property_keys) + } + + pub fn set_property_permissions( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + property_permissions: Vec, + ) -> DispatchResult { + >::set_property_permissions(collection, sender, property_permissions) + } + pub fn transfer( collection: &NonfungibleHandle, from: &T::CrossAccountId, @@ -420,6 +572,13 @@ ); >::insert((collection.id, &data.owner, token), true); + Self::set_token_properties( + collection, + sender, + TokenId(token), + data.properties.into_inner(), + )?; + collection.log_mirrored(ERC721Events::Transfer { from: H160::default(), to: *data.owner.as_eth(), --- a/pallets/nonfungible/src/weights.rs +++ b/pallets/nonfungible/src/weights.rs @@ -36,6 +36,11 @@ fn create_multiple_items(b: u32, ) -> Weight; fn create_multiple_items_ex(b: u32, ) -> Weight; fn burn_item() -> Weight; + fn set_collection_properties(amount: u32) -> Weight; + fn delete_collection_properties(amount: u32) -> Weight; + fn set_token_properties(amount: u32) -> Weight; + fn delete_token_properties(amount: u32) -> Weight; + fn set_property_permissions(amount: u32) -> Weight; fn transfer() -> Weight; fn approve() -> Weight; fn transfer_from() -> Weight; @@ -90,6 +95,32 @@ .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(4 as Weight)) } + + fn set_collection_properties(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + + fn delete_collection_properties(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + + fn set_token_properties(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + + fn delete_token_properties(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + + fn set_property_permissions(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + // Storage: Nonfungible TokenData (r:1 w:1) // Storage: Nonfungible AccountBalance (r:2 w:2) // Storage: Nonfungible Allowance (r:1 w:0) @@ -179,6 +210,32 @@ .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(4 as Weight)) } + + fn set_collection_properties(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + + fn delete_collection_properties(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + + fn set_token_properties(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + + fn delete_token_properties(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + + fn set_property_permissions(amount: u32) -> Weight { + // TODO calculate appropriate weight + (50_000_000 as Weight).saturating_mul(amount as Weight) + } + // Storage: Nonfungible TokenData (r:1 w:1) // Storage: Nonfungible AccountBalance (r:2 w:2) // Storage: Nonfungible Allowance (r:1 w:0) --- a/pallets/refungible/src/common.rs +++ b/pallets/refungible/src/common.rs @@ -20,7 +20,7 @@ use frame_support::{dispatch::DispatchResultWithPostInfo, fail, weights::Weight, BoundedVec}; use up_data_structs::{ CollectionId, TokenId, CustomDataLimit, CreateItemExData, CreateRefungibleExData, - budget::Budget, + budget::Budget, Property, PropertyKey, PropertyKeyPermission, }; use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight}; use sp_runtime::DispatchError; @@ -66,6 +66,26 @@ max_weight_of!(burn_item_partial(), burn_item_fully()) } + fn set_collection_properties(amount: u32) -> Weight { + >::set_collection_properties(amount) + } + + fn delete_collection_properties(amount: u32) -> Weight { + >::delete_collection_properties(amount) + } + + fn set_token_properties(amount: u32) -> Weight { + >::set_token_properties(amount) + } + + fn delete_token_properties(amount: u32) -> Weight { + >::delete_token_properties(amount) + } + + fn set_property_permissions(amount: u32) -> Weight { + >::set_property_permissions(amount) + } + fn transfer() -> Weight { max_weight_of!( transfer_normal(), @@ -244,6 +264,48 @@ ) } + fn set_collection_properties( + &self, + _sender: T::CrossAccountId, + _property: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + + fn delete_collection_properties( + &self, + _sender: &T::CrossAccountId, + _property_keys: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + + fn set_token_properties( + &self, + _sender: T::CrossAccountId, + _token_id: TokenId, + _property: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + + fn set_property_permissions( + &self, + _sender: &T::CrossAccountId, + _property_permissions: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + + fn delete_token_properties( + &self, + _sender: T::CrossAccountId, + _token_id: TokenId, + _property_keys: Vec, + ) -> DispatchResultWithPostInfo { + fail!(>::SettingPropertiesNotAllowed) + } + fn set_variable_metadata( &self, sender: T::CrossAccountId, @@ -301,6 +363,10 @@ .into_inner() } + fn token_properties(&self, _token_id: TokenId, _keys: Vec) -> Vec { + Vec::new() + } + fn total_supply(&self) -> u32 { >::total_supply(self) } --- a/pallets/refungible/src/lib.rs +++ b/pallets/refungible/src/lib.rs @@ -62,6 +62,8 @@ WrongRefungiblePieces, /// Refungible token can't nest other tokens RefungibleDisallowsNesting, + /// Setting item properties is not allowed + SettingPropertiesNotAllowed, } #[pallet::config] --- a/pallets/refungible/src/weights.rs +++ b/pallets/refungible/src/weights.rs @@ -38,6 +38,11 @@ fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight; fn burn_item_partial() -> Weight; fn burn_item_fully() -> Weight; + fn set_collection_properties(amount: u32) -> Weight; + fn delete_collection_properties(amount: u32) -> Weight; + fn set_token_properties(amount: u32) -> Weight; + fn delete_token_properties(amount: u32) -> Weight; + fn set_property_permissions(amount: u32) -> Weight; fn transfer_normal() -> Weight; fn transfer_creating() -> Weight; fn transfer_removing() -> Weight; @@ -129,6 +134,32 @@ .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(6 as Weight)) } + + fn set_collection_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn delete_collection_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn set_token_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn delete_token_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn set_property_permissions(_amount: u32) -> Weight { + // Error + 0 + } + // Storage: Refungible Balance (r:2 w:2) fn transfer_normal() -> Weight { (19_766_000 as Weight) @@ -297,6 +328,32 @@ .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) } + + fn set_collection_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn delete_collection_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn set_token_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn delete_token_properties(_amount: u32) -> Weight { + // Error + 0 + } + + fn set_property_permissions(_amount: u32) -> Weight { + // Error + 0 + } + // Storage: Refungible Balance (r:2 w:2) fn transfer_normal() -> Weight { (19_766_000 as Weight) --- a/pallets/unique/src/lib.rs +++ b/pallets/unique/src/lib.rs @@ -39,7 +39,7 @@ MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, AccessMode, CreateItemData, CollectionLimits, CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, MetaUpdatePermission, CreateCollectionData, CustomDataLimit, - CreateItemExData, budget, CollectionField, + CreateItemExData, budget, CollectionField, Property, PropertyKey, PropertyKeyPermission, }; use pallet_evm::account::CrossAccountId; use pallet_common::{ @@ -694,6 +694,78 @@ dispatch_call::(collection_id, |d| d.create_multiple_items(sender, owner, items_data, &budget)) } + #[weight = T::CommonWeightInfo::set_collection_properties(properties.len() as u32)] + #[transactional] + pub fn set_collection_properties( + origin, + collection_id: CollectionId, + properties: Vec + ) -> DispatchResultWithPostInfo { + ensure!(!properties.is_empty(), Error::::EmptyArgument); + + let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?); + + dispatch_call::(collection_id, |d| d.set_collection_properties(sender, properties)) + } + + #[weight = T::CommonWeightInfo::delete_collection_properties(property_keys.len() as u32)] + #[transactional] + pub fn delete_collection_properties( + origin, + collection_id: CollectionId, + property_keys: Vec, + ) -> DispatchResultWithPostInfo { + ensure!(!property_keys.is_empty(), Error::::EmptyArgument); + + let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?); + + dispatch_call::(collection_id, |d| d.delete_collection_properties(&sender, property_keys)) + } + + #[weight = T::CommonWeightInfo::set_token_properties(properties.len() as u32)] + #[transactional] + pub fn set_token_properties( + origin, + collection_id: CollectionId, + token_id: TokenId, + properties: Vec + ) -> DispatchResultWithPostInfo { + ensure!(!properties.is_empty(), Error::::EmptyArgument); + + let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?); + + dispatch_call::(collection_id, |d| d.set_token_properties(sender, token_id, properties)) + } + + #[weight = T::CommonWeightInfo::delete_token_properties(property_keys.len() as u32)] + #[transactional] + pub fn delete_token_properties( + origin, + collection_id: CollectionId, + token_id: TokenId, + property_keys: Vec + ) -> DispatchResultWithPostInfo { + ensure!(!property_keys.is_empty(), Error::::EmptyArgument); + + let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?); + + dispatch_call::(collection_id, |d| d.delete_token_properties(sender, token_id, property_keys)) + } + + #[weight = T::CommonWeightInfo::set_property_permissions(property_permissions.len() as u32)] + #[transactional] + pub fn set_property_permissions( + origin, + collection_id: CollectionId, + property_permissions: Vec, + ) -> DispatchResultWithPostInfo { + ensure!(!property_permissions.is_empty(), Error::::EmptyArgument); + + let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?); + + dispatch_call::(collection_id, |d| d.set_property_permissions(&sender, property_permissions)) + } + #[weight = T::CommonWeightInfo::create_multiple_items_ex(&data)] #[transactional] pub fn create_multiple_items_ex(origin, collection_id: CollectionId, data: CreateItemExData) -> DispatchResultWithPostInfo { --- a/primitives/data-structs/src/lib.rs +++ b/primitives/data-structs/src/lib.rs @@ -22,6 +22,7 @@ }; use frame_support::{ storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet}, + traits::Get, }; #[cfg(feature = "serde")] @@ -85,6 +86,26 @@ pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256; pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16; +pub const MAX_PROPERTY_KEY_LENGTH: u32 = 256; +pub const MAX_PROPERTY_VALUE_LENGTH: u32 = 32768; +pub const MAX_PROPERTIES_PER_ITEM: u32 = 64; + +// pub const MAX_PROPERTY_KEYS_OVERALL_LENGTH: u32 = MAX_PROPERTY_KEY_LENGTH * MAX_PROPERTIES_PER_ITEM; +pub const MAX_COLLECTION_PROPERTIES_SIZE: u32 = 40960; +pub const MAX_TOKEN_PROPERTIES_SIZE: u32 = 32768; + +pub const MAX_COLLECTION_PROPERTIES_ENCODE_LEN: u32 = + MAX_PROPERTIES_PER_ITEM * MAX_PROPERTY_KEY_LENGTH + MAX_COLLECTION_PROPERTIES_SIZE; + +pub struct MaxPropertiesPermissionsEncodeLen; + +impl Get for MaxPropertiesPermissionsEncodeLen { + fn get() -> u32 { + MAX_PROPERTIES_PER_ITEM * MAX_PROPERTY_KEY_LENGTH + + ::max_encoded_len() as u32 + } +} + /// How much items can be created per single /// create_many call pub const MAX_ITEMS_PER_BATCH: u32 = 200; @@ -152,6 +173,14 @@ } } +#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)] +#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))] +pub struct TokenData { + pub const_data: Vec, + pub properties: Vec, + pub owner: Option, +} + pub struct OverflowError; impl From for &'static str { fn from(_: OverflowError) -> Self { @@ -300,6 +329,8 @@ pub variable_on_chain_schema: Vec, pub const_on_chain_schema: Vec, pub meta_update_permission: MetaUpdatePermission, + pub token_property_permissions: Vec, + pub properties: Vec, } #[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)] @@ -310,31 +341,32 @@ OffchainSchema, } -#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Debug, Derivative, MaxEncodedLen)] -#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))] -#[derivative(Default(bound = ""))] +#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Derivative, MaxEncodedLen)] +#[derivative(Debug, Default(bound = ""))] pub struct CreateCollectionData { #[derivative(Default(value = "CollectionMode::NFT"))] pub mode: CollectionMode, pub access: Option, - #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] pub name: BoundedVec>, - #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] pub description: BoundedVec>, - #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] pub token_prefix: BoundedVec>, - #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] pub offchain_schema: BoundedVec>, pub schema_version: Option, pub pending_sponsor: Option, pub limits: Option, - #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] pub variable_on_chain_schema: BoundedVec>, - #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] pub const_on_chain_schema: BoundedVec>, pub meta_update_permission: Option, + pub token_property_permissions: CollectionPropertiesPermissionsVec, + pub properties: CollectionPropertiesVec, } +pub type CollectionPropertiesPermissionsVec = + BoundedVec; + +pub type CollectionPropertiesVec = + BoundedVec>; + #[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo)] #[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))] pub struct NftItemType { @@ -464,6 +496,10 @@ #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] #[derivative(Debug(format_with = "bounded::vec_debug"))] pub variable_data: BoundedVec, + + #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] + #[derivative(Debug(format_with = "bounded::vec_debug"))] + pub properties: CollectionPropertiesVec, } #[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)] @@ -514,6 +550,8 @@ pub const_data: BoundedVec, #[derivative(Debug(format_with = "bounded::vec_debug"))] pub variable_data: BoundedVec, + #[derivative(Debug(format_with = "bounded::vec_debug"))] + pub properties: CollectionPropertiesVec, pub owner: CrossAccountId, } @@ -607,3 +645,189 @@ 0 } } + +pub type PropertyKey = BoundedVec>; +pub type PropertyValue = BoundedVec>; + +#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)] +#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))] +pub struct PropertyPermission { + pub mutable: bool, + pub collection_admin: bool, + pub token_owner: bool, +} + +impl PropertyPermission { + pub fn none() -> Self { + Self { + mutable: true, + collection_admin: false, + token_owner: false, + } + } +} + +#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)] +#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))] +pub struct Property { + #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] + pub key: PropertyKey, + + #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] + pub value: PropertyValue, +} + +#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)] +#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))] +pub struct PropertyKeyPermission { + #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))] + pub key: PropertyKey, + + pub permission: PropertyPermission, +} + +pub enum PropertiesError { + NoSpaceForProperty, + PropertyLimitReached, + InvalidCharacterInPropertyKey, +} + +pub trait TrySet: Sized { + type Value; + + fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError>; + + fn try_set_from_iter(&mut self, iter: I) -> Result<(), PropertiesError> + where + I: Iterator + { + for (key, value) in iter { + self.try_set(key, value)?; + } + + Ok(()) + } +} + +#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)] +#[derivative(Default(bound = ""))] +pub struct PropertiesMap(BoundedBTreeMap>); + +impl PropertiesMap { + pub fn new() -> Self { + Self(BoundedBTreeMap::new()) + } + + pub fn remove(&mut self, key: &PropertyKey) -> Result, PropertiesError> { + Self::check_property_key(key)?; + + Ok(self.0.remove(key)) + } + + pub fn get(&self, key: &PropertyKey) -> Option<&Value> { + self.0.get(key) + } + + pub fn iter(&self) -> impl Iterator { + self.0.iter() + } + + fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> { + let key_str = sp_std::str::from_utf8(key.as_slice()) + .map_err(|_| PropertiesError::InvalidCharacterInPropertyKey)?; + + for ch in key_str.chars() { + if !ch.is_ascii_alphanumeric() && ch != '_' && ch != '-' { + return Err(PropertiesError::InvalidCharacterInPropertyKey); + } + } + + Ok(()) + } +} + +impl TrySet for PropertiesMap { + type Value = Value; + + fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> { + Self::check_property_key(&key)?; + + self.0 + .try_insert(key, value) + .map_err(|_| PropertiesError::PropertyLimitReached)?; + + Ok(()) + } +} + +pub type PropertiesPermissionMap = PropertiesMap; + +#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)] +pub struct Properties { + map: PropertiesMap, + consumed_space: u32, + space_limit: u32, +} + +impl Properties { + pub fn new(space_limit: u32) -> Self { + Self { + map: PropertiesMap::new(), + consumed_space: 0, + space_limit, + } + } + + pub fn remove(&mut self, key: &PropertyKey) -> Result, PropertiesError> { + let value = self.map.remove(key)?; + + if let Some(ref value) = value { + let value_len = value.len() as u32; + self.consumed_space -= value_len; + } + + Ok(value) + } + + pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> { + self.map.get(key) + } + + pub fn iter(&self) -> impl Iterator { + self.map.iter() + } +} + +impl TrySet for Properties { + type Value = PropertyValue; + + fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> { + let value_len = value.len(); + + if self.consumed_space as usize + value_len > self.space_limit as usize { + return Err(PropertiesError::NoSpaceForProperty); + } + + self.map.try_set(key, value)?; + + self.consumed_space += value_len as u32; + + Ok(()) + } +} + +pub struct CollectionProperties; + +impl Get for CollectionProperties { + fn get() -> Properties { + Properties::new(MAX_COLLECTION_PROPERTIES_SIZE) + } +} + +pub struct TokenProperties; + +impl Get for TokenProperties { + fn get() -> Properties { + Properties::new(MAX_TOKEN_PROPERTIES_SIZE) + } +} --- a/primitives/rpc/src/lib.rs +++ b/primitives/rpc/src/lib.rs @@ -16,7 +16,10 @@ #![cfg_attr(not(feature = "std"), no_std)] -use up_data_structs::{CollectionId, TokenId, RpcCollection, CollectionStats, CollectionLimits}; +use up_data_structs::{ + CollectionId, TokenId, RpcCollection, CollectionStats, CollectionLimits, Property, + PropertyKeyPermission, TokenData, +}; use sp_std::vec::Vec; use codec::Decode; use sp_runtime::DispatchError; @@ -41,6 +44,21 @@ fn const_metadata(collection: CollectionId, token: TokenId) -> Result>; fn variable_metadata(collection: CollectionId, token: TokenId) -> Result>; + fn collection_properties(collection: CollectionId, properties: Vec>) -> Result>; + + fn token_properties( + collection: CollectionId, + token_id: TokenId, + properties: Vec> + ) -> Result>; + + fn property_permissions( + collection: CollectionId, + properties: Vec> + ) -> Result>; + + fn token_data(collection: CollectionId, token_id: TokenId, keys: Vec>) -> Result>; + fn total_supply(collection: CollectionId) -> Result; fn account_balance(collection: CollectionId, account: CrossAccountId) -> Result; fn balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result; --- a/runtime/common/src/runtime_apis.rs +++ b/runtime/common/src/runtime_apis.rs @@ -36,6 +36,47 @@ dispatch_unique_runtime!(collection.variable_metadata(token)) } + fn collection_properties( + collection: CollectionId, + keys: Vec> + ) -> Result, DispatchError> { + let keys = pallet_common::Pallet::::bytes_keys_to_property_keys(keys)?; + + pallet_common::Pallet::::filter_collection_properties(collection, keys) + } + + fn token_properties( + collection: CollectionId, + token_id: TokenId, + keys: Vec> + ) -> Result, DispatchError> { + let keys = pallet_common::Pallet::::bytes_keys_to_property_keys(keys)?; + dispatch_unique_runtime!(collection.token_properties(token_id, keys)) + } + + fn property_permissions( + collection: CollectionId, + keys: Vec> + ) -> Result, DispatchError> { + let keys = pallet_common::Pallet::::bytes_keys_to_property_keys(keys)?; + + pallet_common::Pallet::::filter_property_permissions(collection, keys) + } + + fn token_data( + collection: CollectionId, + token_id: TokenId, + keys: Vec> + ) -> Result, DispatchError> { + let token_data = TokenData { + const_data: Self::const_metadata(collection, token_id)?, + properties: Self::token_properties(collection, token_id, keys)?, + owner: Self::token_owner(collection, token_id)? + }; + + Ok(token_data) + } + fn total_supply(collection: CollectionId) -> Result { dispatch_unique_runtime!(collection.total_supply()) } --- a/runtime/common/src/weights.rs +++ b/runtime/common/src/weights.rs @@ -54,6 +54,26 @@ dispatch_weight::() + max_weight_of!(burn_item()) } + fn set_collection_properties(amount: u32) -> Weight { + dispatch_weight::() + max_weight_of!(set_collection_properties(amount)) + } + + fn delete_collection_properties(amount: u32) -> Weight { + dispatch_weight::() + max_weight_of!(delete_collection_properties(amount)) + } + + fn set_token_properties(amount: u32) -> Weight { + dispatch_weight::() + max_weight_of!(set_token_properties(amount)) + } + + fn delete_token_properties(amount: u32) -> Weight { + dispatch_weight::() + max_weight_of!(delete_token_properties(amount)) + } + + fn set_property_permissions(amount: u32) -> Weight { + dispatch_weight::() + max_weight_of!(set_property_permissions(amount)) + } + fn transfer() -> Weight { dispatch_weight::() + max_weight_of!(transfer()) } --- a/runtime/opal/src/lib.rs +++ b/runtime/opal/src/lib.rs @@ -67,7 +67,7 @@ }, }; use up_data_structs::mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping}; -use up_data_structs::{CollectionId, TokenId, CollectionStats, CollectionLimits, RpcCollection}; +use up_data_structs::*; // use pallet_contracts::weights::WeightInfo; // #[cfg(any(feature = "std", test))] use frame_system::{ --- a/tests/package.json +++ b/tests/package.json @@ -34,6 +34,7 @@ "testCollision": "mocha --timeout 9999999 -r ts-node/register ./src/collision-tests/*.test.ts", "testEvent": "mocha --timeout 9999999 -r ts-node/register ./src/check-event/*.test.ts", "testNesting": "mocha --timeout 9999999 -r ts-node/register ./**/nesting/**.test.ts", + "testProperties": "mocha --timeout 9999999 -r ts-node/register ./**/properties.test.ts", "testMigrationStructure": "mocha --timeout 9999999 -r ts-node/register ./**/nesting/migration-check.test.ts", "testAddCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/addCollectionAdmin.test.ts", "testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts", @@ -49,6 +50,7 @@ "testContracts": "mocha --timeout 9999999 -r ts-node/register ./**/contracts.test.ts", "testCreateItem": "mocha --timeout 9999999 -r ts-node/register ./**/createItem.test.ts", "testCreateMultipleItems": "mocha --timeout 9999999 -r ts-node/register ./**/createMultipleItems.test.ts", + "testCreateMultipleItemsEx": "mocha --timeout 9999999 -r ts-node/register ./**/createMultipleItemsEx.test.ts", "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts", "testTransferFrom": "mocha --timeout 9999999 -r ts-node/register ./**/transferFrom.test.ts", "testCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts", --- a/tests/src/createCollection.test.ts +++ b/tests/src/createCollection.test.ts @@ -17,7 +17,7 @@ import {expect} from 'chai'; import privateKey from './substrate/privateKey'; import usingApi, {executeTransaction, submitTransactionAsync} from './substrate/substrate-api'; -import {createCollectionExpectFailure, createCollectionExpectSuccess, getCreateCollectionResult, getDetailedCollectionInfo} from './util/helpers'; +import {createCollectionWithPropsExpectFailure, createCollectionExpectFailure, createCollectionExpectSuccess, getCreateCollectionResult, getDetailedCollectionInfo, createCollectionWithPropsExpectSuccess} from './util/helpers'; describe('integration test: ext. createCollection():', () => { it('Create new NFT collection', async () => { @@ -38,6 +38,25 @@ it('Create new ReFungible collection', async () => { await createCollectionExpectSuccess({mode: {type: 'ReFungible'}}); }); + + it('create new collection with properties #1', async () => { + await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}, + properties: [{key: 'key1', value: 'val1'}], + propPerm: [{key: 'key1', tokenOwner: true, mutable: false, collectionAdmin: true}]}); + }); + + it('create new collection with properties #2', async () => { + await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}, + properties: [{key: 'key1', value: 'val1'}], + propPerm: [{key: 'key1', tokenOwner: false, mutable: true, collectionAdmin: false}]}); + }); + + it('create new collection with properties #3', async () => { + await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}, + properties: [{key: 'key1', value: 'val1'}], + propPerm: [{key: 'key1', tokenOwner: true, mutable: false, collectionAdmin: false}]}); + }); + it('Create new collection with extra fields', async () => { await usingApi(async api => { const alice = privateKey('//Alice'); @@ -96,4 +115,24 @@ await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/^common.CollectionTokenLimitExceeded$/); }); }); + + it('(!negative test!) create collection with incorrect property limit (64 elements)', async () => { + const props = []; + + for (let i = 0; i < 65; i++) { + props.push({key: `key${i}`, value: `value${i}`}); + } + + await createCollectionWithPropsExpectFailure({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}, properties: props}); + }); + + it('(!negative test!) create collection with incorrect property limit (40 kb)', async () => { + const props = []; + + for (let i = 0; i < 32; i++) { + props.push({key: `key${i}`.repeat(80), value: `value${i}`.repeat(80)}); + } + + await createCollectionWithPropsExpectFailure({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}, properties: props}); + }); }); --- a/tests/src/createItem.test.ts +++ b/tests/src/createItem.test.ts @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -import {default as usingApi} from './substrate/substrate-api'; +import {default as usingApi, executeTransaction} from './substrate/substrate-api'; import chai from 'chai'; import {Keyring} from '@polkadot/api'; import {IKeyringPair} from '@polkadot/types/types'; @@ -22,6 +22,7 @@ createCollectionExpectSuccess, createItemExpectSuccess, addCollectionAdminExpectSuccess, + createCollectionWithPropsExpectSuccess, } from './util/helpers'; const expect = chai.expect; @@ -70,6 +71,33 @@ await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address); await createItemExpectSuccess(bob, newCollectionID, createMode); }); + + it('Set property Admin', async () => { + const createMode = 'NFT'; + const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode}, + properties: [{key: 'key1', value: 'val1'}], + propPerm: [{key: 'key1', mutable: true, collectionAdmin: true, tokenOwner: false}]}); + + await createItemExpectSuccess(alice, newCollectionID, createMode); + }); + + it('Set property AdminConst', async () => { + const createMode = 'NFT'; + const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode}, + properties: [{key: 'key1', value: 'val1'}], + propPerm: [{key: 'key1', mutable: false, collectionAdmin: true, tokenOwner: false}]}); + + await createItemExpectSuccess(alice, newCollectionID, createMode); + }); + + it('Set property itemOwnerOrAdmin', async () => { + const createMode = 'NFT'; + const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode}, + properties: [{key: 'key1', value: 'val1'}], + propPerm: [{key: 'key1', mutable: true, collectionAdmin: true, tokenOwner: true}]}); + + await createItemExpectSuccess(alice, newCollectionID, createMode); + }); }); describe('Negative integration test: ext. createItem():', () => { @@ -96,4 +124,76 @@ const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}}); await expect(createItemExpectSuccess(bob, newCollectionID, createMode)).to.be.rejected; }); + + it('No editing rights', async () => { + await usingApi(async api => { + const createMode = 'NFT'; + const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode}, + propPerm: [{key: 'key1', mutable: false, collectionAdmin: false, tokenOwner: false}]}); + + const token = await createItemExpectSuccess(alice, newCollectionID, 'NFT'); + await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setTokenProperties(newCollectionID, token, [{key: 'key1', value: 'v2'}]), + )).to.be.rejected; + }); + }); + + it('User doesnt have editing rights', async () => { + await usingApi(async api => { + const createMode = 'NFT'; + const newCollectionID = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'key1', mutable: true, collectionAdmin: false, tokenOwner: false}]}); + const token = await createItemExpectSuccess(alice, newCollectionID, 'NFT'); + + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(newCollectionID, token, [{key: 'key1', value: 'v2'}]), + )).to.be.rejected; + }); + }); + + it('Adding property without access rights', async () => { + await usingApi(async api => { + const createMode = 'NFT'; + const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}}); + + const token = await createItemExpectSuccess(alice, newCollectionID, 'NFT'); + await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address); + + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(newCollectionID, token, [{key: 'key1', value: 'v2'}]), + )).to.be.rejected; + }); + }); + + it('Adding more than 64 prps', async () => { + await usingApi(async api => { + const createMode = 'NFT'; + + const prps = []; + + for (let i = 0; i < 65; i++) { + prps.push({key: `key${i}`, value: `value${i}`}); + } + + const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}}); + + await expect(executeTransaction(api, alice, api.tx.unique.setCollectionProperties(newCollectionID, prps))).to.be.rejectedWith(/common\.PropertyLimitReached/); + }); + }); + + it('Trying to add bigger property than allowed', async () => { + await usingApi(async api => { + const createMode = 'NFT'; + const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}}); + + await expect(executeTransaction(api, alice, api.tx.unique.setCollectionProperties(newCollectionID, [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]))).to.be.rejectedWith(/common\.NoSpaceForProperty/); + }); + }); }); --- a/tests/src/createMultipleItems.test.ts +++ b/tests/src/createMultipleItems.test.ts @@ -19,7 +19,7 @@ import chai from 'chai'; import chaiAsPromised from 'chai-as-promised'; import privateKey from './substrate/privateKey'; -import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api'; +import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync, executeTransaction} from './substrate/substrate-api'; import { createCollectionExpectSuccess, destroyCollectionExpectSuccess, @@ -33,6 +33,8 @@ getVariableMetadata, getConstMetadata, getCreatedCollectionCount, + createCollectionWithPropsExpectSuccess, + getCreateItemsResult, } from './util/helpers'; chai.use(chaiAsPromised); @@ -45,7 +47,9 @@ const itemsListIndexBefore = await getLastTokenId(api, collectionId); expect(itemsListIndexBefore).to.be.equal(0); const alice = privateKey('//Alice'); - const args = [{NFT: ['0x31', '0x31']}, {NFT: ['0x32', '0x32']}, {NFT: ['0x33', '0x33']}]; + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; const createMultipleItemsTx = api.tx.unique .createMultipleItems(collectionId, normalizeAccountId(alice.address), args); await submitTransactionAsync(alice, createMultipleItemsTx); @@ -135,6 +139,114 @@ expect(result.success).to.be.true; }); }); + + it('Create 0x31, 0x32, 0x33 items in active NFT with property Admin', async () => { + await usingApi(async (api: ApiPromise) => { + const collectionId = await createCollectionExpectSuccess(); + const itemsListIndexBefore = await getLastTokenId(api, collectionId); + expect(itemsListIndexBefore).to.be.equal(0); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; + const createMultipleItemsTx = api.tx.unique + .createMultipleItems(collectionId, normalizeAccountId(alice.address), args); + await submitTransactionAsync(alice, createMultipleItemsTx); + const itemsListIndexAfter = await getLastTokenId(api, collectionId); + expect(itemsListIndexAfter).to.be.equal(3); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collectionId, [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: false}}]), + )).to.not.be.rejected; + + expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address)); + expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address)); + expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address)); + + expect(await getConstMetadata(api, collectionId, 1)).to.be.deep.equal([0x31]); + expect(await getConstMetadata(api, collectionId, 2)).to.be.deep.equal([0x32]); + expect(await getConstMetadata(api, collectionId, 3)).to.be.deep.equal([0x33]); + + expect(await getVariableMetadata(api, collectionId, 1)).to.be.deep.equal([0x31]); + expect(await getVariableMetadata(api, collectionId, 2)).to.be.deep.equal([0x32]); + expect(await getVariableMetadata(api, collectionId, 3)).to.be.deep.equal([0x33]); + }); + }); + + it('Create 0x31, 0x32, 0x33 items in active NFT with property AdminConst', async () => { + await usingApi(async (api: ApiPromise) => { + const collectionId = await createCollectionExpectSuccess(); + const itemsListIndexBefore = await getLastTokenId(api, collectionId); + expect(itemsListIndexBefore).to.be.equal(0); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; + const createMultipleItemsTx = api.tx.unique + .createMultipleItems(collectionId, normalizeAccountId(alice.address), args); + await submitTransactionAsync(alice, createMultipleItemsTx); + const itemsListIndexAfter = await getLastTokenId(api, collectionId); + expect(itemsListIndexAfter).to.be.equal(3); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collectionId, [{key: 'k', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}}]), + )).to.not.be.rejected; + + expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address)); + expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address)); + expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address)); + + expect(await getConstMetadata(api, collectionId, 1)).to.be.deep.equal([0x31]); + expect(await getConstMetadata(api, collectionId, 2)).to.be.deep.equal([0x32]); + expect(await getConstMetadata(api, collectionId, 3)).to.be.deep.equal([0x33]); + + expect(await getVariableMetadata(api, collectionId, 1)).to.be.deep.equal([0x31]); + expect(await getVariableMetadata(api, collectionId, 2)).to.be.deep.equal([0x32]); + expect(await getVariableMetadata(api, collectionId, 3)).to.be.deep.equal([0x33]); + }); + }); + + it('Create 0x31, 0x32, 0x33 items in active NFT with property itemOwnerOrAdmin', async () => { + await usingApi(async (api: ApiPromise) => { + const collectionId = await createCollectionExpectSuccess(); + const itemsListIndexBefore = await getLastTokenId(api, collectionId); + expect(itemsListIndexBefore).to.be.equal(0); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; + const createMultipleItemsTx = api.tx.unique + .createMultipleItems(collectionId, normalizeAccountId(alice.address), args); + await submitTransactionAsync(alice, createMultipleItemsTx); + const itemsListIndexAfter = await getLastTokenId(api, collectionId); + expect(itemsListIndexAfter).to.be.equal(3); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collectionId, [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]), + )).to.not.be.rejected; + + expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address)); + expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address)); + expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address)); + + expect(await getConstMetadata(api, collectionId, 1)).to.be.deep.equal([0x31]); + expect(await getConstMetadata(api, collectionId, 2)).to.be.deep.equal([0x32]); + expect(await getConstMetadata(api, collectionId, 3)).to.be.deep.equal([0x33]); + + expect(await getVariableMetadata(api, collectionId, 1)).to.be.deep.equal([0x31]); + expect(await getVariableMetadata(api, collectionId, 2)).to.be.deep.equal([0x32]); + expect(await getVariableMetadata(api, collectionId, 3)).to.be.deep.equal([0x33]); + }); + }); }); describe('Integration Test createMultipleItems(collection_id, owner, items_data) with collection admin permissions:', () => { @@ -155,7 +267,9 @@ const itemsListIndexBefore = await getLastTokenId(api, collectionId); expect(itemsListIndexBefore).to.be.equal(0); await addCollectionAdminExpectSuccess(alice, collectionId, bob.address); - const args = [{NFT: ['0x31', '0x31']}, {NFT: ['0x32', '0x32']}, {NFT: ['0x33', '0x33']}]; + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; const createMultipleItemsTx = api.tx.unique .createMultipleItems(collectionId, normalizeAccountId(bob.address), args); await submitTransactionAsync(bob, createMultipleItemsTx); @@ -245,7 +359,9 @@ const collectionId = await createCollectionExpectSuccess(); const itemsListIndexBefore = await getLastTokenId(api, collectionId); expect(itemsListIndexBefore).to.be.equal(0); - const args = [{NFT: ['0x31', '0x31']}, {NFT: ['0x32', '0x32']}, {NFT: ['0x33', '0x33']}]; + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; const createMultipleItemsTx = api.tx.unique .createMultipleItems(collectionId, normalizeAccountId(alice.address), args); await expect(submitTransactionAsync(bob, createMultipleItemsTx)).to.be.rejected; @@ -361,4 +477,146 @@ await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTx)).to.be.rejected; }); }); + + it('No editing rights', async () => { + await usingApi(async (api: ApiPromise) => { + const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}], + propPerm: [{key: 'key1', mutable: true, collectionAdmin: false, tokenOwner: false}]}); + const itemsListIndexBefore = await getLastTokenId(api, collectionId); + expect(itemsListIndexBefore).to.be.equal(0); + await addCollectionAdminExpectSuccess(alice, collectionId, bob.address); + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; + + const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args); + + const events = await submitTransactionAsync(alice, createMultipleItemsTx); + const result = getCreateItemsResult(events); + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'key1', value: 'v2'}]), + )).to.be.rejected; + } + + // await expect(submitTransactionAsync(bob, createMultipleItemsTx)).to.be.rejected; + }); + }); + + it('User doesnt have editing rights', async () => { + await usingApi(async (api: ApiPromise) => { + const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}], + propPerm: [{key: 'key1', mutable: false, collectionAdmin: false, tokenOwner: false}]}); + const itemsListIndexBefore = await getLastTokenId(api, collectionId); + expect(itemsListIndexBefore).to.be.equal(0); + await addCollectionAdminExpectSuccess(alice, collectionId, bob.address); + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; + + const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args); + + const events = await submitTransactionAsync(alice, createMultipleItemsTx); + const result = getCreateItemsResult(events); + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'key1', value: 'v2'}]), + )).to.be.rejected; + } + }); + }); + + it('Adding property without access rights', async () => { + await usingApi(async (api: ApiPromise) => { + const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}]}); + const itemsListIndexBefore = await getLastTokenId(api, collectionId); + await addCollectionAdminExpectSuccess(alice, collectionId, bob.address); + expect(itemsListIndexBefore).to.be.equal(0); + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; + + const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args); + + const events = await submitTransactionAsync(alice, createMultipleItemsTx); + const result = getCreateItemsResult(events); + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'key1', value: 'v2'}]), + )).to.be.rejected; + } + }); + }); + + it('Adding more than 64 prps', async () => { + await usingApi(async (api: ApiPromise) => { + const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}], + propPerm: [{key: 'key1', mutable: true, collectionAdmin: true, tokenOwner: false}]}); + const itemsListIndexBefore = await getLastTokenId(api, collectionId); + expect(itemsListIndexBefore).to.be.equal(0); + await addCollectionAdminExpectSuccess(alice, collectionId, bob.address); + + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; + + const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args); + const events = await submitTransactionAsync(alice, createMultipleItemsTx); + + const result = getCreateItemsResult(events); + + const prps = []; + + for (let i = 0; i < 65; i++) { + prps.push({key: `key${i}`, value: `value${i}`}); + } + + await expect(executeTransaction(api, bob, api.tx.unique.setCollectionProperties(collectionId, prps))).to.be.rejectedWith(/common\.PropertyLimitReached/); + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, prps), + )).to.be.rejected; + } + }); + }); + + it('Trying to add bigger property than allowed', async () => { + await usingApi(async (api: ApiPromise) => { + const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}], + propPerm: [{key: 'key1', mutable: true, collectionAdmin: false, tokenOwner: false}]}); + const itemsListIndexBefore = await getLastTokenId(api, collectionId); + expect(itemsListIndexBefore).to.be.equal(0); + const args = [{Nft: {const_data: '0x31', variable_data: '0x31'}}, + {Nft: {const_data: '0x32', variable_data: '0x32'}}, + {Nft: {const_data: '0x33', variable_data: '0x33'}}]; + + const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args); + + const events = await submitTransactionAsync(alice, createMultipleItemsTx); + const result = getCreateItemsResult(events); + + + await expect(executeTransaction(api, alice, api.tx.unique.setCollectionProperties(collectionId, [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]))).to.be.rejectedWith(/common\.NoSpaceForProperty/); + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]), + )).to.be.rejected; + } + }); + }); }); --- a/tests/src/createMultipleItemsEx.test.ts +++ b/tests/src/createMultipleItemsEx.test.ts @@ -16,8 +16,8 @@ import {expect} from 'chai'; import privateKey from './substrate/privateKey'; -import usingApi, {executeTransaction} from './substrate/substrate-api'; -import {createCollectionExpectSuccess} from './util/helpers'; +import usingApi, {executeTransaction, submitTransactionAsync} from './substrate/substrate-api'; +import {createCollectionExpectSuccess, createCollectionWithPropsExpectSuccess, addCollectionAdminExpectSuccess, getCreateItemsResult} from './util/helpers'; describe('createMultipleItemsEx', () => { it('can initialize multiple NFT with different owners', async () => { @@ -51,6 +51,362 @@ }); }); + it('createMultipleItemsEx with property Admin', async () => { + const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}}); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + constData: '0x0000', + variableData: '0x1111', + }, { + owner: {substrate: bob.address}, + constData: '0x2222', + variableData: '0x3333', + }, { + owner: {substrate: charlie.address}, + constData: '0x4444', + variableData: '0x5555', + }, + ]; + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: false}}]), + )).to.not.be.rejected; + + await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, { + NFT: data, + })); + const tokens = await api.query.nonfungible.tokenData.entries(collection); + const json = tokens.map(([, token]) => token.toJSON()); + expect(json).to.be.deep.equal(data); + }); + }); + + it('createMultipleItemsEx with property AdminConst', async () => { + const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}}); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + constData: '0x0000', + variableData: '0x1111', + }, { + owner: {substrate: bob.address}, + constData: '0x2222', + variableData: '0x3333', + }, { + owner: {substrate: charlie.address}, + constData: '0x4444', + variableData: '0x5555', + }, + ]; + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'k', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}}]), + )).to.not.be.rejected; + + await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, { + NFT: data, + })); + + + const tokens = await api.query.nonfungible.tokenData.entries(collection); + const json = tokens.map(([, token]) => token.toJSON()); + expect(json).to.be.deep.equal(data); + }); + }); + + it('createMultipleItemsEx with property itemOwnerOrAdmin', async () => { + const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}}); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + constData: '0x0000', + variableData: '0x1111', + }, { + owner: {substrate: bob.address}, + constData: '0x2222', + variableData: '0x3333', + }, { + owner: {substrate: charlie.address}, + constData: '0x4444', + variableData: '0x5555', + }, + ]; + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]), + )).to.not.be.rejected; + + await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, { + NFT: data, + })); + + + const tokens = await api.query.nonfungible.tokenData.entries(collection); + const json = tokens.map(([, token]) => token.toJSON()); + expect(json).to.be.deep.equal(data); + }); + }); + + it('No editing rights', async () => { + const collection = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}], + propPerm: [{key: 'key1', mutable: true, collectionAdmin: false, tokenOwner: false}]}); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await addCollectionAdminExpectSuccess(alice, collection, bob.address); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + }, { + owner: {substrate: bob.address}, + }, { + owner: {substrate: charlie.address}, + }, + ]; + + const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data}); + await executeTransaction(api, alice, tx); + + const events = await submitTransactionAsync(alice, tx); + const result = getCreateItemsResult(events); + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'key1', value: 'v2'}]), + )).to.be.rejected; + } + }); + }); + + it('User doesnt have editing rights', async () => { + const collection = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}], + propPerm: [{key: 'key1', mutable: false, collectionAdmin: false, tokenOwner: false}]}); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await addCollectionAdminExpectSuccess(alice, collection, bob.address); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + }, { + owner: {substrate: bob.address}, + }, { + owner: {substrate: charlie.address}, + }, + ]; + + const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data}); + await executeTransaction(api, alice, tx); + + const events = await submitTransactionAsync(alice, tx); + const result = getCreateItemsResult(events); + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'key1', value: 'v2'}]), + )).to.be.rejected; + } + }); + }); + + it('Adding property without access rights', async () => { + const collection = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}]}); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await addCollectionAdminExpectSuccess(alice, collection, bob.address); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + }, { + owner: {substrate: bob.address}, + }, { + owner: {substrate: charlie.address}, + }, + ]; + + const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data}); + await executeTransaction(api, alice, tx); + + const events = await submitTransactionAsync(alice, tx); + const result = getCreateItemsResult(events); + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, [{key: 'key1', value: 'v2'}]), + )).to.be.rejected; + } + }); + }); + + it('Adding more than 64 prps', async () => { + const collection = await createCollectionWithPropsExpectSuccess(); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await addCollectionAdminExpectSuccess(alice, collection, bob.address); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + }, { + owner: {substrate: bob.address}, + }, { + owner: {substrate: charlie.address}, + }, + ]; + + const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data}); + await executeTransaction(api, alice, tx); + + const events = await submitTransactionAsync(alice, tx); + const result = getCreateItemsResult(events); + + const prps = []; + + for (let i = 0; i < 65; i++) { + prps.push({key: `key${i}`, value: `value${i}`}); + } + + await expect(executeTransaction(api, bob, api.tx.unique.setCollectionProperties(collection, prps))).to.be.rejectedWith(/common\.PropertyLimitReached/); + + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, prps), + )).to.be.rejected; + } + }); + }); + + it('Trying to add bigger property than allowed', async () => { + const collection = await createCollectionWithPropsExpectSuccess(); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await addCollectionAdminExpectSuccess(alice, collection, bob.address); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + }, { + owner: {substrate: bob.address}, + }, { + owner: {substrate: charlie.address}, + }, + ]; + + const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data}); + await executeTransaction(api, alice, tx); + + const events = await submitTransactionAsync(alice, tx); + const result = getCreateItemsResult(events); + + const prps = [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]; + + await expect(executeTransaction(api, bob, api.tx.unique.setCollectionProperties(collection, prps))).to.be.rejectedWith(/common\.NoSpaceForProperty/); + + + for (const elem of result) { + await expect(executeTransaction( + api, + bob, + api.tx.unique.setTokenProperties(elem.collectionId, elem.itemId, prps), + )).to.be.rejected; + } + }); + }); + + it('can initialize multiple NFT with different owners', async () => { + const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}}); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + constData: '0x0000', + variableData: '0x1111', + }, { + owner: {substrate: bob.address}, + constData: '0x2222', + variableData: '0x3333', + }, { + owner: {substrate: charlie.address}, + constData: '0x4444', + variableData: '0x5555', + }, + ]; + + await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, { + NFT: data, + })); + const tokens = await api.query.nonfungible.tokenData.entries(collection); + const json = tokens.map(([, token]) => token.toJSON()); + expect(json).to.be.deep.equal(data); + }); + }); + + it('can initialize multiple NFT with different owners', async () => { + const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}}); + const alice = privateKey('//Alice'); + const bob = privateKey('//Bob'); + const charlie = privateKey('//Charlie'); + await usingApi(async (api) => { + const data = [ + { + owner: {substrate: alice.address}, + constData: '0x0000', + variableData: '0x1111', + }, { + owner: {substrate: bob.address}, + constData: '0x2222', + variableData: '0x3333', + }, { + owner: {substrate: charlie.address}, + constData: '0x4444', + variableData: '0x5555', + }, + ]; + + await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, { + NFT: data, + })); + const tokens = await api.query.nonfungible.tokenData.entries(collection); + const json = tokens.map(([, token]) => token.toJSON()); + expect(json).to.be.deep.equal(data); + }); + }); + it('fails when trying to set multiple owners when creating multiple refungibles', async () => { const collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}}); const alice = privateKey('//Alice'); @@ -72,3 +428,4 @@ }); }); }); +''; --- a/tests/src/interfaces/augment-api-errors.ts +++ b/tests/src/interfaces/augment-api-errors.ts @@ -112,6 +112,7 @@ * No permission to perform action **/ NoPermission: AugmentedError; + NoSpaceForProperty: AugmentedError; /** * Not sufficient founds to perform action **/ @@ -124,6 +125,7 @@ * Tried to enable permissions which are only permitted to be disabled **/ OwnerPermissionsCantBeReverted: AugmentedError; + PropertyLimitReached: AugmentedError; /** * Collection is not in mint mode. **/ @@ -269,6 +271,10 @@ **/ NotFungibleDataUsedToMintFungibleCollectionToken: AugmentedError; /** + * Setting item properties is not allowed + **/ + SettingPropertiesNotAllowed: AugmentedError; + /** * Generic error **/ [key: string]: AugmentedError; @@ -397,6 +403,10 @@ **/ RefungibleDisallowsNesting: AugmentedError; /** + * Setting item properties is not allowed + **/ + SettingPropertiesNotAllowed: AugmentedError; + /** * Maximum refungibility exceeded **/ WrongRefungiblePieces: AugmentedError; --- a/tests/src/interfaces/augment-api-events.ts +++ b/tests/src/interfaces/augment-api-events.ts @@ -2,9 +2,9 @@ /* eslint-disable */ import type { ApiTypes } from '@polkadot/api-base/types'; -import type { Null, Option, Result, U256, U8aFixed, u128, u32, u64, u8 } from '@polkadot/types-codec'; +import type { Bytes, Null, Option, Result, U256, U8aFixed, u128, u32, u64, u8 } from '@polkadot/types-codec'; import type { AccountId32, H160, H256 } from '@polkadot/types/interfaces/runtime'; -import type { EthereumLog, EvmCoreErrorExitReason, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchInfo, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, SpRuntimeDispatchError, UpDataStructsAccessMode, XcmV1MultiLocation, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation } from '@polkadot/types/lookup'; +import type { EthereumLog, EvmCoreErrorExitReason, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchInfo, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, SpRuntimeDispatchError, UpDataStructsAccessMode, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation } from '@polkadot/types/lookup'; declare module '@polkadot/api-base/types/events' { export interface AugmentedEvents { @@ -89,6 +89,8 @@ * * collection_id: Globally unique identifier of collection. **/ CollectionDestroyed: AugmentedEvent; + CollectionPropertyDeleted: AugmentedEvent; + CollectionPropertySet: AugmentedEvent; /** * New item was created. * @@ -117,6 +119,9 @@ * * amount: Always 1 for NFT **/ ItemDestroyed: AugmentedEvent; + PropertyPermissionSet: AugmentedEvent; + TokenPropertyDeleted: AugmentedEvent; + TokenPropertySet: AugmentedEvent; /** * Item was transferred * --- a/tests/src/interfaces/augment-api-query.ts +++ b/tests/src/interfaces/augment-api-query.ts @@ -5,7 +5,7 @@ import type { BTreeMap, Bytes, Option, U256, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types-codec'; import type { AnyNumber, ITuple } from '@polkadot/types-codec/types'; import type { AccountId32, H160, H256 } from '@polkadot/types/interfaces/runtime'; -import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletNonfungibleItemData, PalletRefungibleItemData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpRuntimeDigest, SpTrieStorageProof, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionStats } from '@polkadot/types/lookup'; +import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletNonfungibleItemData, PalletRefungibleItemData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsTokenData, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpRuntimeDigest, SpTrieStorageProof, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertyPermission } from '@polkadot/types/lookup'; import type { Observable } from '@polkadot/types/types'; declare module '@polkadot/api-base/types/storage' { @@ -82,12 +82,17 @@ * Large variable-size collection fields are extracted here **/ collectionData: AugmentedQuery Observable, [u32, UpDataStructsCollectionField]> & QueryableStorageEntry; + /** + * Collection properties + **/ + collectionProperties: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + collectionPropertyPermissions: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; createdCollectionCount: AugmentedQuery Observable, []> & QueryableStorageEntry; destroyedCollectionCount: AugmentedQuery Observable, []> & QueryableStorageEntry; /** * Not used by code, exists only to provide some types to metadata **/ - dummyStorageValue: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + dummyStorageValue: AugmentedQuery Observable>>, []> & QueryableStorageEntry; /** * List of collection admins **/ @@ -223,6 +228,7 @@ **/ owned: AugmentedQuery Observable, [u32, PalletEvmAccountBasicCrossAccountIdRepr, u32]> & QueryableStorageEntry; tokenData: AugmentedQuery Observable>, [u32, u32]> & QueryableStorageEntry; + tokenProperties: AugmentedQuery Observable, [u32, u32]> & QueryableStorageEntry; tokensBurnt: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; tokensMinted: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; /** --- a/tests/src/interfaces/augment-api-rpc.ts +++ b/tests/src/interfaces/augment-api-rpc.ts @@ -1,7 +1,7 @@ // Auto-generated via `yarn polkadot-types-from-chain`, do not edit /* eslint-disable */ -import type { PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCollectionLimits, UpDataStructsCollectionStats, UpDataStructsRpcCollection } from './unique'; +import type { PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCollectionLimits, UpDataStructsCollectionStats, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsRpcCollection, UpDataStructsTokenData } from './unique'; import type { AugmentedRpc } from '@polkadot/rpc-core/types'; import type { Metadata, StorageKey } from '@polkadot/types'; import type { Bytes, HashMap, Json, Null, Option, Text, U256, U64, Vec, bool, u128, u32, u64 } from '@polkadot/types-codec'; @@ -603,6 +603,10 @@ **/ collectionById: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; /** + * Get collection properties + **/ + collectionProperties: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, propertyKeys: Vec | (Text | string)[], at?: Hash | string | Uint8Array) => Observable>>; + /** * Get collection stats **/ collectionStats: AugmentedRpc<(at?: Hash | string | Uint8Array) => Observable>; @@ -627,6 +631,14 @@ **/ nextSponsored: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, account: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; /** + * Get property permissions + **/ + propertyPermissions: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, propertyKeys: Vec | (Text | string)[], at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get token data + **/ + tokenData: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec | (Text | string)[], at?: Hash | string | Uint8Array) => Observable>; + /** * Check if token exists **/ tokenExists: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>; @@ -635,6 +647,10 @@ **/ tokenOwner: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; /** + * Get token properties + **/ + tokenProperties: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec | (Text | string)[], at?: Hash | string | Uint8Array) => Observable>>; + /** * Get token owner, in case of nested token - find parent recursive **/ topmostTokenOwner: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; --- a/tests/src/interfaces/augment-api-tx.ts +++ b/tests/src/interfaces/augment-api-tx.ts @@ -5,7 +5,7 @@ import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types-codec'; import type { AnyNumber, ITuple } from '@polkadot/types-codec/types'; import type { AccountId32, Call, H160, H256, MultiAddress, Perbill } from '@polkadot/types/interfaces/runtime'; -import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsAccessMode, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsMetaUpdatePermission, UpDataStructsSchemaVersion, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; +import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsAccessMode, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsMetaUpdatePermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsSchemaVersion, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; declare module '@polkadot/api-base/types/submittable' { export interface AugmentedSubmittables { @@ -679,7 +679,7 @@ * * Prefer it to deprecated [`created_collection`] method **/ - createCollectionEx: AugmentedSubmittable<(data: UpDataStructsCreateCollectionData | { mode?: any; access?: any; name?: any; description?: any; tokenPrefix?: any; offchainSchema?: any; schemaVersion?: any; pendingSponsor?: any; limits?: any; variableOnChainSchema?: any; constOnChainSchema?: any; metaUpdatePermission?: any } | string | Uint8Array) => SubmittableExtrinsic, [UpDataStructsCreateCollectionData]>; + createCollectionEx: AugmentedSubmittable<(data: UpDataStructsCreateCollectionData | { mode?: any; access?: any; name?: any; description?: any; tokenPrefix?: any; offchainSchema?: any; schemaVersion?: any; pendingSponsor?: any; limits?: any; variableOnChainSchema?: any; constOnChainSchema?: any; metaUpdatePermission?: any; tokenPropertyPermissions?: any; properties?: any } | string | Uint8Array) => SubmittableExtrinsic, [UpDataStructsCreateCollectionData]>; /** * This method creates a concrete instance of NFT Collection created with CreateCollection method. * @@ -723,6 +723,8 @@ **/ createMultipleItems: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, owner: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, itemsData: Vec | (UpDataStructsCreateItemData | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [u32, PalletEvmAccountBasicCrossAccountIdRepr, Vec]>; createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, UpDataStructsCreateItemExData]>; + deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic, [u32, Vec]>; + deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic, [u32, u32, Vec]>; /** * **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money. * @@ -778,6 +780,7 @@ **/ removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>; setCollectionLimits: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newLimit: UpDataStructsCollectionLimits | { accountTokenOwnershipLimit?: any; sponsoredDataSize?: any; sponsoredDataRateLimit?: any; tokenLimit?: any; sponsorTransferTimeout?: any; sponsorApproveTimeout?: any; ownerCanTransfer?: any; ownerCanDestroy?: any; transfersEnabled?: any; nestingRule?: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, UpDataStructsCollectionLimits]>; + setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [u32, Vec]>; /** * # Permissions * @@ -850,6 +853,7 @@ * * schema: String representing the offchain data schema. **/ setOffchainSchema: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, schema: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + setPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [u32, Vec]>; /** * Toggle between normal and allow list access for the methods with access for `Anyone`. * @@ -881,6 +885,7 @@ * * schema: SchemaVersion: enum **/ setSchemaVersion: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, version: UpDataStructsSchemaVersion | 'ImageURL' | 'Unique' | number | Uint8Array) => SubmittableExtrinsic, [u32, UpDataStructsSchemaVersion]>; + setTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, properties: Vec | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [u32, u32, Vec]>; /** * Set transfers_enabled value for particular collection * --- a/tests/src/interfaces/augment-types.ts +++ b/tests/src/interfaces/augment-types.ts @@ -1,7 +1,7 @@ // Auto-generated via `yarn polkadot-types-from-defs`, do not edit /* eslint-disable */ -import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportStorageBoundedBTreeSet, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExData, UpDataStructsMetaUpdatePermission, UpDataStructsNestingRule, UpDataStructsRpcCollection, UpDataStructsSchemaVersion, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './unique'; +import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportStorageBoundedBTreeSet, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsTokenData, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExData, UpDataStructsMetaUpdatePermission, UpDataStructsNestingRule, UpDataStructsProperties, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsRpcCollection, UpDataStructsSchemaVersion, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './unique'; import type { Data, StorageKey } from '@polkadot/types'; import type { BitVec, Bool, Bytes, I128, I16, I256, I32, I64, I8, Json, Null, Raw, Text, Type, U128, U16, U256, U32, U64, U8, USize, bool, i128, i16, i256, i32, i64, i8, u128, u16, u256, u32, u64, u8, usize } from '@polkadot/types-codec'; import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDestroyWitness, AssetDetails, AssetMetadata, TAssetBalance, TAssetDepositBalance } from '@polkadot/types/interfaces/assets'; @@ -849,7 +849,8 @@ PerU16: PerU16; Phantom: Phantom; PhantomData: PhantomData; - PhantomTypeUpDataStructs: PhantomTypeUpDataStructs; + PhantomTypeUpDataStructsRpcCollection: PhantomTypeUpDataStructsRpcCollection; + PhantomTypeUpDataStructsTokenData: PhantomTypeUpDataStructsTokenData; Phase: Phase; PhragmenScore: PhragmenScore; Points: Points; @@ -1182,10 +1183,15 @@ UpDataStructsCreateRefungibleExData: UpDataStructsCreateRefungibleExData; UpDataStructsMetaUpdatePermission: UpDataStructsMetaUpdatePermission; UpDataStructsNestingRule: UpDataStructsNestingRule; + UpDataStructsProperties: UpDataStructsProperties; + UpDataStructsProperty: UpDataStructsProperty; + UpDataStructsPropertyKeyPermission: UpDataStructsPropertyKeyPermission; + UpDataStructsPropertyPermission: UpDataStructsPropertyPermission; UpDataStructsRpcCollection: UpDataStructsRpcCollection; UpDataStructsSchemaVersion: UpDataStructsSchemaVersion; UpDataStructsSponsoringRateLimit: UpDataStructsSponsoringRateLimit; UpDataStructsSponsorshipState: UpDataStructsSponsorshipState; + UpDataStructsTokenData: UpDataStructsTokenData; UpgradeGoAhead: UpgradeGoAhead; UpgradeRestriction: UpgradeRestriction; UpwardMessage: UpwardMessage; --- a/tests/src/interfaces/lookup.ts +++ b/tests/src/interfaces/lookup.ts @@ -1300,6 +1300,28 @@ owner: 'PalletEvmAccountBasicCrossAccountIdRepr', itemsData: 'Vec', }, + set_collection_properties: { + collectionId: 'u32', + properties: 'Vec', + }, + delete_collection_properties: { + collectionId: 'u32', + propertyKeys: 'Vec', + }, + set_token_properties: { + collectionId: 'u32', + tokenId: 'u32', + properties: 'Vec', + }, + delete_token_properties: { + collectionId: 'u32', + tokenId: 'u32', + propertyKeys: 'Vec', + }, + set_property_permissions: { + collectionId: 'u32', + propertyPermissions: 'Vec', + }, create_multiple_items_ex: { collectionId: 'u32', data: 'UpDataStructsCreateItemExData', @@ -1394,7 +1416,9 @@ limits: 'Option', variableOnChainSchema: 'Bytes', constOnChainSchema: 'Bytes', - metaUpdatePermission: 'Option' + metaUpdatePermission: 'Option', + tokenPropertyPermissions: 'Vec', + properties: 'Vec' }, /** * Lookup159: up_data_structs::AccessMode @@ -1453,7 +1477,29 @@ _enum: ['ItemOwner', 'Admin', 'None'] }, /** - * Lookup178: pallet_evm::account::BasicCrossAccountIdRepr + * Lookup179: up_data_structs::PropertyKeyPermission + **/ + UpDataStructsPropertyKeyPermission: { + key: 'Bytes', + permission: 'UpDataStructsPropertyPermission' + }, + /** + * Lookup181: up_data_structs::PropertyPermission + **/ + UpDataStructsPropertyPermission: { + mutable: 'bool', + collectionAdmin: 'bool', + tokenOwner: 'bool' + }, + /** + * Lookup184: up_data_structs::Property + **/ + UpDataStructsProperty: { + key: 'Bytes', + value: 'Bytes' + }, + /** + * Lookup186: pallet_evm::account::BasicCrossAccountIdRepr **/ PalletEvmAccountBasicCrossAccountIdRepr: { _enum: { @@ -1462,7 +1508,7 @@ } }, /** - * Lookup180: up_data_structs::CreateItemData + * Lookup188: up_data_structs::CreateItemData **/ UpDataStructsCreateItemData: { _enum: { @@ -1472,20 +1518,21 @@ } }, /** - * Lookup181: up_data_structs::CreateNftData + * Lookup189: up_data_structs::CreateNftData **/ UpDataStructsCreateNftData: { constData: 'Bytes', - variableData: 'Bytes' + variableData: 'Bytes', + properties: 'Vec' }, /** - * Lookup183: up_data_structs::CreateFungibleData + * Lookup191: up_data_structs::CreateFungibleData **/ UpDataStructsCreateFungibleData: { value: 'u128' }, /** - * Lookup184: up_data_structs::CreateReFungibleData + * Lookup192: up_data_structs::CreateReFungibleData **/ UpDataStructsCreateReFungibleData: { constData: 'Bytes', @@ -1493,7 +1540,7 @@ pieces: 'u128' }, /** - * Lookup186: up_data_structs::CreateItemExData> + * Lookup196: up_data_structs::CreateItemExData> **/ UpDataStructsCreateItemExData: { _enum: { @@ -1504,15 +1551,16 @@ } }, /** - * Lookup188: up_data_structs::CreateNftExData> + * Lookup198: up_data_structs::CreateNftExData> **/ UpDataStructsCreateNftExData: { constData: 'Bytes', variableData: 'Bytes', + properties: 'Vec', owner: 'PalletEvmAccountBasicCrossAccountIdRepr' }, /** - * Lookup195: up_data_structs::CreateRefungibleExData> + * Lookup205: up_data_structs::CreateRefungibleExData> **/ UpDataStructsCreateRefungibleExData: { constData: 'Bytes', @@ -1520,15 +1568,15 @@ users: 'BTreeMap' }, /** - * Lookup198: pallet_template_transaction_payment::Call + * Lookup207: pallet_template_transaction_payment::Call **/ PalletTemplateTransactionPaymentCall: 'Null', /** - * Lookup199: pallet_structure::pallet::Call + * Lookup208: pallet_structure::pallet::Call **/ PalletStructureCall: 'Null', /** - * Lookup200: pallet_evm::pallet::Call + * Lookup209: pallet_evm::pallet::Call **/ PalletEvmCall: { _enum: { @@ -1571,7 +1619,7 @@ } }, /** - * Lookup206: pallet_ethereum::pallet::Call + * Lookup215: pallet_ethereum::pallet::Call **/ PalletEthereumCall: { _enum: { @@ -1581,7 +1629,7 @@ } }, /** - * Lookup207: ethereum::transaction::TransactionV2 + * Lookup216: ethereum::transaction::TransactionV2 **/ EthereumTransactionTransactionV2: { _enum: { @@ -1591,7 +1639,7 @@ } }, /** - * Lookup208: ethereum::transaction::LegacyTransaction + * Lookup217: ethereum::transaction::LegacyTransaction **/ EthereumTransactionLegacyTransaction: { nonce: 'U256', @@ -1603,7 +1651,7 @@ signature: 'EthereumTransactionTransactionSignature' }, /** - * Lookup209: ethereum::transaction::TransactionAction + * Lookup218: ethereum::transaction::TransactionAction **/ EthereumTransactionTransactionAction: { _enum: { @@ -1612,7 +1660,7 @@ } }, /** - * Lookup210: ethereum::transaction::TransactionSignature + * Lookup219: ethereum::transaction::TransactionSignature **/ EthereumTransactionTransactionSignature: { v: 'u64', @@ -1620,7 +1668,7 @@ s: 'H256' }, /** - * Lookup212: ethereum::transaction::EIP2930Transaction + * Lookup221: ethereum::transaction::EIP2930Transaction **/ EthereumTransactionEip2930Transaction: { chainId: 'u64', @@ -1636,14 +1684,14 @@ s: 'H256' }, /** - * Lookup214: ethereum::transaction::AccessListItem + * Lookup223: ethereum::transaction::AccessListItem **/ EthereumTransactionAccessListItem: { address: 'H160', storageKeys: 'Vec' }, /** - * Lookup215: ethereum::transaction::EIP1559Transaction + * Lookup224: ethereum::transaction::EIP1559Transaction **/ EthereumTransactionEip1559Transaction: { chainId: 'u64', @@ -1660,7 +1708,7 @@ s: 'H256' }, /** - * Lookup216: pallet_evm_migration::pallet::Call + * Lookup225: pallet_evm_migration::pallet::Call **/ PalletEvmMigrationCall: { _enum: { @@ -1678,7 +1726,7 @@ } }, /** - * Lookup219: pallet_sudo::pallet::Event + * Lookup228: pallet_sudo::pallet::Event **/ PalletSudoEvent: { _enum: { @@ -1694,7 +1742,7 @@ } }, /** - * Lookup221: sp_runtime::DispatchError + * Lookup230: sp_runtime::DispatchError **/ SpRuntimeDispatchError: { _enum: { @@ -1711,38 +1759,38 @@ } }, /** - * Lookup222: sp_runtime::ModuleError + * Lookup231: sp_runtime::ModuleError **/ SpRuntimeModuleError: { index: 'u8', error: '[u8;4]' }, /** - * Lookup223: sp_runtime::TokenError + * Lookup232: sp_runtime::TokenError **/ SpRuntimeTokenError: { _enum: ['NoFunds', 'WouldDie', 'BelowMinimum', 'CannotCreate', 'UnknownAsset', 'Frozen', 'Unsupported'] }, /** - * Lookup224: sp_runtime::ArithmeticError + * Lookup233: sp_runtime::ArithmeticError **/ SpRuntimeArithmeticError: { _enum: ['Underflow', 'Overflow', 'DivisionByZero'] }, /** - * Lookup225: sp_runtime::TransactionalError + * Lookup234: sp_runtime::TransactionalError **/ SpRuntimeTransactionalError: { _enum: ['LimitReached', 'NoLayer'] }, /** - * Lookup226: pallet_sudo::pallet::Error + * Lookup235: pallet_sudo::pallet::Error **/ PalletSudoError: { _enum: ['RequireSudo'] }, /** - * Lookup227: frame_system::AccountInfo> + * Lookup236: frame_system::AccountInfo> **/ FrameSystemAccountInfo: { nonce: 'u32', @@ -1752,7 +1800,7 @@ data: 'PalletBalancesAccountData' }, /** - * Lookup228: frame_support::weights::PerDispatchClass + * Lookup237: frame_support::weights::PerDispatchClass **/ FrameSupportWeightsPerDispatchClassU64: { normal: 'u64', @@ -1760,13 +1808,13 @@ mandatory: 'u64' }, /** - * Lookup229: sp_runtime::generic::digest::Digest + * Lookup238: sp_runtime::generic::digest::Digest **/ SpRuntimeDigest: { logs: 'Vec' }, /** - * Lookup231: sp_runtime::generic::digest::DigestItem + * Lookup240: sp_runtime::generic::digest::DigestItem **/ SpRuntimeDigestDigestItem: { _enum: { @@ -1782,7 +1830,7 @@ } }, /** - * Lookup233: frame_system::EventRecord + * Lookup242: frame_system::EventRecord **/ FrameSystemEventRecord: { phase: 'FrameSystemPhase', @@ -1790,7 +1838,7 @@ topics: 'Vec' }, /** - * Lookup235: frame_system::pallet::Event + * Lookup244: frame_system::pallet::Event **/ FrameSystemEvent: { _enum: { @@ -1818,7 +1866,7 @@ } }, /** - * Lookup236: frame_support::weights::DispatchInfo + * Lookup245: frame_support::weights::DispatchInfo **/ FrameSupportWeightsDispatchInfo: { weight: 'u64', @@ -1826,19 +1874,19 @@ paysFee: 'FrameSupportWeightsPays' }, /** - * Lookup237: frame_support::weights::DispatchClass + * Lookup246: frame_support::weights::DispatchClass **/ FrameSupportWeightsDispatchClass: { _enum: ['Normal', 'Operational', 'Mandatory'] }, /** - * Lookup238: frame_support::weights::Pays + * Lookup247: frame_support::weights::Pays **/ FrameSupportWeightsPays: { _enum: ['Yes', 'No'] }, /** - * Lookup239: orml_vesting::module::Event + * Lookup248: orml_vesting::module::Event **/ OrmlVestingModuleEvent: { _enum: { @@ -1857,7 +1905,7 @@ } }, /** - * Lookup240: cumulus_pallet_xcmp_queue::pallet::Event + * Lookup249: cumulus_pallet_xcmp_queue::pallet::Event **/ CumulusPalletXcmpQueueEvent: { _enum: { @@ -1872,7 +1920,7 @@ } }, /** - * Lookup241: pallet_xcm::pallet::Event + * Lookup250: pallet_xcm::pallet::Event **/ PalletXcmEvent: { _enum: { @@ -1895,7 +1943,7 @@ } }, /** - * Lookup242: xcm::v2::traits::Outcome + * Lookup251: xcm::v2::traits::Outcome **/ XcmV2TraitsOutcome: { _enum: { @@ -1905,7 +1953,7 @@ } }, /** - * Lookup244: cumulus_pallet_xcm::pallet::Event + * Lookup253: cumulus_pallet_xcm::pallet::Event **/ CumulusPalletXcmEvent: { _enum: { @@ -1915,7 +1963,7 @@ } }, /** - * Lookup245: cumulus_pallet_dmp_queue::pallet::Event + * Lookup254: cumulus_pallet_dmp_queue::pallet::Event **/ CumulusPalletDmpQueueEvent: { _enum: { @@ -1928,7 +1976,7 @@ } }, /** - * Lookup246: pallet_unique::RawEvent> + * Lookup255: pallet_unique::RawEvent> **/ PalletUniqueRawEvent: { _enum: { @@ -1950,7 +1998,7 @@ } }, /** - * Lookup247: pallet_common::pallet::Event + * Lookup256: pallet_common::pallet::Event **/ PalletCommonEvent: { _enum: { @@ -1959,11 +2007,16 @@ ItemCreated: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,u128)', ItemDestroyed: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,u128)', Transfer: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,u128)', - Approved: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,u128)' + Approved: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,u128)', + CollectionPropertySet: '(u32,UpDataStructsProperty)', + CollectionPropertyDeleted: '(u32,Bytes)', + TokenPropertySet: '(u32,u32,UpDataStructsProperty)', + TokenPropertyDeleted: '(u32,u32,Bytes)', + PropertyPermissionSet: '(u32,UpDataStructsPropertyKeyPermission)' } }, /** - * Lookup248: pallet_structure::pallet::Event + * Lookup257: pallet_structure::pallet::Event **/ PalletStructureEvent: { _enum: { @@ -1971,7 +2024,7 @@ } }, /** - * Lookup249: pallet_evm::pallet::Event + * Lookup258: pallet_evm::pallet::Event **/ PalletEvmEvent: { _enum: { @@ -1985,7 +2038,7 @@ } }, /** - * Lookup250: ethereum::log::Log + * Lookup259: ethereum::log::Log **/ EthereumLog: { address: 'H160', @@ -1993,7 +2046,7 @@ data: 'Bytes' }, /** - * Lookup251: pallet_ethereum::pallet::Event + * Lookup260: pallet_ethereum::pallet::Event **/ PalletEthereumEvent: { _enum: { @@ -2001,7 +2054,7 @@ } }, /** - * Lookup252: evm_core::error::ExitReason + * Lookup261: evm_core::error::ExitReason **/ EvmCoreErrorExitReason: { _enum: { @@ -2012,13 +2065,13 @@ } }, /** - * Lookup253: evm_core::error::ExitSucceed + * Lookup262: evm_core::error::ExitSucceed **/ EvmCoreErrorExitSucceed: { _enum: ['Stopped', 'Returned', 'Suicided'] }, /** - * Lookup254: evm_core::error::ExitError + * Lookup263: evm_core::error::ExitError **/ EvmCoreErrorExitError: { _enum: { @@ -2040,13 +2093,13 @@ } }, /** - * Lookup257: evm_core::error::ExitRevert + * Lookup266: evm_core::error::ExitRevert **/ EvmCoreErrorExitRevert: { _enum: ['Reverted'] }, /** - * Lookup258: evm_core::error::ExitFatal + * Lookup267: evm_core::error::ExitFatal **/ EvmCoreErrorExitFatal: { _enum: { @@ -2057,7 +2110,7 @@ } }, /** - * Lookup259: frame_system::Phase + * Lookup268: frame_system::Phase **/ FrameSystemPhase: { _enum: { @@ -2067,14 +2120,14 @@ } }, /** - * Lookup261: frame_system::LastRuntimeUpgradeInfo + * Lookup270: frame_system::LastRuntimeUpgradeInfo **/ FrameSystemLastRuntimeUpgradeInfo: { specVersion: 'Compact', specName: 'Text' }, /** - * Lookup262: frame_system::limits::BlockWeights + * Lookup271: frame_system::limits::BlockWeights **/ FrameSystemLimitsBlockWeights: { baseBlock: 'u64', @@ -2082,7 +2135,7 @@ perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass' }, /** - * Lookup263: frame_support::weights::PerDispatchClass + * Lookup272: frame_support::weights::PerDispatchClass **/ FrameSupportWeightsPerDispatchClassWeightsPerClass: { normal: 'FrameSystemLimitsWeightsPerClass', @@ -2090,7 +2143,7 @@ mandatory: 'FrameSystemLimitsWeightsPerClass' }, /** - * Lookup264: frame_system::limits::WeightsPerClass + * Lookup273: frame_system::limits::WeightsPerClass **/ FrameSystemLimitsWeightsPerClass: { baseExtrinsic: 'u64', @@ -2099,13 +2152,13 @@ reserved: 'Option' }, /** - * Lookup266: frame_system::limits::BlockLength + * Lookup275: frame_system::limits::BlockLength **/ FrameSystemLimitsBlockLength: { max: 'FrameSupportWeightsPerDispatchClassU32' }, /** - * Lookup267: frame_support::weights::PerDispatchClass + * Lookup276: frame_support::weights::PerDispatchClass **/ FrameSupportWeightsPerDispatchClassU32: { normal: 'u32', @@ -2113,14 +2166,14 @@ mandatory: 'u32' }, /** - * Lookup268: frame_support::weights::RuntimeDbWeight + * Lookup277: frame_support::weights::RuntimeDbWeight **/ FrameSupportWeightsRuntimeDbWeight: { read: 'u64', write: 'u64' }, /** - * Lookup269: sp_version::RuntimeVersion + * Lookup278: sp_version::RuntimeVersion **/ SpVersionRuntimeVersion: { specName: 'Text', @@ -2133,19 +2186,19 @@ stateVersion: 'u8' }, /** - * Lookup273: frame_system::pallet::Error + * Lookup282: frame_system::pallet::Error **/ FrameSystemError: { _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered'] }, /** - * Lookup275: orml_vesting::module::Error + * Lookup284: orml_vesting::module::Error **/ OrmlVestingModuleError: { _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded'] }, /** - * Lookup277: cumulus_pallet_xcmp_queue::InboundChannelDetails + * Lookup286: cumulus_pallet_xcmp_queue::InboundChannelDetails **/ CumulusPalletXcmpQueueInboundChannelDetails: { sender: 'u32', @@ -2153,19 +2206,19 @@ messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>' }, /** - * Lookup278: cumulus_pallet_xcmp_queue::InboundState + * Lookup287: cumulus_pallet_xcmp_queue::InboundState **/ CumulusPalletXcmpQueueInboundState: { _enum: ['Ok', 'Suspended'] }, /** - * Lookup281: polkadot_parachain::primitives::XcmpMessageFormat + * Lookup290: polkadot_parachain::primitives::XcmpMessageFormat **/ PolkadotParachainPrimitivesXcmpMessageFormat: { _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals'] }, /** - * Lookup284: cumulus_pallet_xcmp_queue::OutboundChannelDetails + * Lookup293: cumulus_pallet_xcmp_queue::OutboundChannelDetails **/ CumulusPalletXcmpQueueOutboundChannelDetails: { recipient: 'u32', @@ -2175,13 +2228,13 @@ lastIndex: 'u16' }, /** - * Lookup285: cumulus_pallet_xcmp_queue::OutboundState + * Lookup294: cumulus_pallet_xcmp_queue::OutboundState **/ CumulusPalletXcmpQueueOutboundState: { _enum: ['Ok', 'Suspended'] }, /** - * Lookup287: cumulus_pallet_xcmp_queue::QueueConfigData + * Lookup296: cumulus_pallet_xcmp_queue::QueueConfigData **/ CumulusPalletXcmpQueueQueueConfigData: { suspendThreshold: 'u32', @@ -2192,29 +2245,29 @@ xcmpMaxIndividualWeight: 'u64' }, /** - * Lookup289: cumulus_pallet_xcmp_queue::pallet::Error + * Lookup298: cumulus_pallet_xcmp_queue::pallet::Error **/ CumulusPalletXcmpQueueError: { _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit'] }, /** - * Lookup290: pallet_xcm::pallet::Error + * Lookup299: pallet_xcm::pallet::Error **/ PalletXcmError: { _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed'] }, /** - * Lookup291: cumulus_pallet_xcm::pallet::Error + * Lookup300: cumulus_pallet_xcm::pallet::Error **/ CumulusPalletXcmError: 'Null', /** - * Lookup292: cumulus_pallet_dmp_queue::ConfigData + * Lookup301: cumulus_pallet_dmp_queue::ConfigData **/ CumulusPalletDmpQueueConfigData: { maxIndividual: 'u64' }, /** - * Lookup293: cumulus_pallet_dmp_queue::PageIndexData + * Lookup302: cumulus_pallet_dmp_queue::PageIndexData **/ CumulusPalletDmpQueuePageIndexData: { beginUsed: 'u32', @@ -2222,19 +2275,19 @@ overweightCount: 'u64' }, /** - * Lookup296: cumulus_pallet_dmp_queue::pallet::Error + * Lookup305: cumulus_pallet_dmp_queue::pallet::Error **/ CumulusPalletDmpQueueError: { _enum: ['Unknown', 'OverLimit'] }, /** - * Lookup300: pallet_unique::Error + * Lookup309: pallet_unique::Error **/ PalletUniqueError: { _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument'] }, /** - * Lookup301: up_data_structs::Collection + * Lookup310: up_data_structs::Collection **/ UpDataStructsCollection: { owner: 'AccountId32', @@ -2250,7 +2303,7 @@ metaUpdatePermission: 'UpDataStructsMetaUpdatePermission' }, /** - * Lookup302: up_data_structs::SponsorshipState + * Lookup311: up_data_structs::SponsorshipState **/ UpDataStructsSponsorshipState: { _enum: { @@ -2260,13 +2313,21 @@ } }, /** - * Lookup304: up_data_structs::CollectionField + * Lookup312: up_data_structs::Properties **/ + UpDataStructsProperties: { + map: 'BTreeMap', + consumedSpace: 'u32', + spaceLimit: 'u32' + }, + /** + * Lookup322: up_data_structs::CollectionField + **/ UpDataStructsCollectionField: { _enum: ['VariableOnChainSchema', 'ConstOnChainSchema', 'OffchainSchema'] }, /** - * Lookup307: up_data_structs::CollectionStats + * Lookup325: up_data_structs::CollectionStats **/ UpDataStructsCollectionStats: { created: 'u32', @@ -2274,11 +2335,23 @@ alive: 'u32' }, /** - * Lookup308: PhantomType::up_data_structs> + * Lookup326: PhantomType::up_data_structs>> + **/ + PhantomTypeUpDataStructsTokenData: '[Lookup327;0]', + /** + * Lookup327: up_data_structs::TokenData> + **/ + UpDataStructsTokenData: { + constData: 'Bytes', + properties: 'Vec', + owner: 'Option' + }, + /** + * Lookup330: PhantomType::up_data_structs> **/ - PhantomTypeUpDataStructs: '[Lookup309;0]', + PhantomTypeUpDataStructsRpcCollection: '[Lookup331;0]', /** - * Lookup309: up_data_structs::RpcCollection + * Lookup331: up_data_structs::RpcCollection **/ UpDataStructsRpcCollection: { owner: 'AccountId32', @@ -2294,35 +2367,37 @@ limits: 'UpDataStructsCollectionLimits', variableOnChainSchema: 'Bytes', constOnChainSchema: 'Bytes', - metaUpdatePermission: 'UpDataStructsMetaUpdatePermission' + metaUpdatePermission: 'UpDataStructsMetaUpdatePermission', + tokenPropertyPermissions: 'Vec', + properties: 'Vec' }, /** - * Lookup311: pallet_common::pallet::Error + * Lookup333: pallet_common::pallet::Error **/ PalletCommonError: { - _enum: ['CollectionNotFound', 'MustBeTokenOwner', 'NoPermission', 'PublicMintingNotAllowed', 'AddressNotInAllowlist', 'CollectionNameLimitExceeded', 'CollectionDescriptionLimitExceeded', 'CollectionTokenPrefixLimitExceeded', 'TotalCollectionsLimitExceeded', 'TokenVariableDataLimitExceeded', 'CollectionAdminCountExceeded', 'CollectionLimitBoundsExceeded', 'OwnerPermissionsCantBeReverted', 'TransferNotAllowed', 'AccountTokenLimitExceeded', 'CollectionTokenLimitExceeded', 'MetadataFlagFrozen', 'TokenNotFound', 'TokenValueTooLow', 'ApprovedValueTooLow', 'CantApproveMoreThanOwned', 'AddressIsZero', 'UnsupportedOperation', 'NotSufficientFounds', 'NestingIsDisabled', 'OnlyOwnerAllowedToNest', 'SourceCollectionIsNotAllowedToNest', 'CollectionFieldSizeExceeded'] + _enum: ['CollectionNotFound', 'MustBeTokenOwner', 'NoPermission', 'PublicMintingNotAllowed', 'AddressNotInAllowlist', 'CollectionNameLimitExceeded', 'CollectionDescriptionLimitExceeded', 'CollectionTokenPrefixLimitExceeded', 'TotalCollectionsLimitExceeded', 'TokenVariableDataLimitExceeded', 'CollectionAdminCountExceeded', 'CollectionLimitBoundsExceeded', 'OwnerPermissionsCantBeReverted', 'TransferNotAllowed', 'AccountTokenLimitExceeded', 'CollectionTokenLimitExceeded', 'MetadataFlagFrozen', 'TokenNotFound', 'TokenValueTooLow', 'ApprovedValueTooLow', 'CantApproveMoreThanOwned', 'AddressIsZero', 'UnsupportedOperation', 'NotSufficientFounds', 'NestingIsDisabled', 'OnlyOwnerAllowedToNest', 'SourceCollectionIsNotAllowedToNest', 'CollectionFieldSizeExceeded', 'NoSpaceForProperty', 'PropertyLimitReached'] }, /** - * Lookup313: pallet_fungible::pallet::Error + * Lookup335: pallet_fungible::pallet::Error **/ PalletFungibleError: { - _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting'] + _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed'] }, /** - * Lookup314: pallet_refungible::ItemData + * Lookup336: pallet_refungible::ItemData **/ PalletRefungibleItemData: { constData: 'Bytes', variableData: 'Bytes' }, /** - * Lookup318: pallet_refungible::pallet::Error + * Lookup340: pallet_refungible::pallet::Error **/ PalletRefungibleError: { - _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RefungibleDisallowsNesting'] + _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed'] }, /** - * Lookup319: pallet_nonfungible::ItemData> + * Lookup341: pallet_nonfungible::ItemData> **/ PalletNonfungibleItemData: { constData: 'Bytes', @@ -2330,25 +2405,25 @@ owner: 'PalletEvmAccountBasicCrossAccountIdRepr' }, /** - * Lookup320: pallet_nonfungible::pallet::Error + * Lookup342: pallet_nonfungible::pallet::Error **/ PalletNonfungibleError: { _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount'] }, /** - * Lookup321: pallet_structure::pallet::Error + * Lookup343: pallet_structure::pallet::Error **/ PalletStructureError: { _enum: ['OuroborosDetected', 'DepthLimit', 'TokenNotFound'] }, /** - * Lookup323: pallet_evm::pallet::Error + * Lookup345: pallet_evm::pallet::Error **/ PalletEvmError: { _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce'] }, /** - * Lookup326: fp_rpc::TransactionStatus + * Lookup348: fp_rpc::TransactionStatus **/ FpRpcTransactionStatus: { transactionHash: 'H256', @@ -2360,11 +2435,11 @@ logsBloom: 'EthbloomBloom' }, /** - * Lookup329: ethbloom::Bloom + * Lookup351: ethbloom::Bloom **/ EthbloomBloom: '[u8;256]', /** - * Lookup331: ethereum::receipt::ReceiptV3 + * Lookup353: ethereum::receipt::ReceiptV3 **/ EthereumReceiptReceiptV3: { _enum: { @@ -2374,7 +2449,7 @@ } }, /** - * Lookup332: ethereum::receipt::EIP658ReceiptData + * Lookup354: ethereum::receipt::EIP658ReceiptData **/ EthereumReceiptEip658ReceiptData: { statusCode: 'u8', @@ -2383,7 +2458,7 @@ logs: 'Vec' }, /** - * Lookup333: ethereum::block::Block + * Lookup355: ethereum::block::Block **/ EthereumBlock: { header: 'EthereumHeader', @@ -2391,7 +2466,7 @@ ommers: 'Vec' }, /** - * Lookup334: ethereum::header::Header + * Lookup356: ethereum::header::Header **/ EthereumHeader: { parentHash: 'H256', @@ -2411,41 +2486,41 @@ nonce: 'EthereumTypesHashH64' }, /** - * Lookup335: ethereum_types::hash::H64 + * Lookup357: ethereum_types::hash::H64 **/ EthereumTypesHashH64: '[u8;8]', /** - * Lookup340: pallet_ethereum::pallet::Error + * Lookup362: pallet_ethereum::pallet::Error **/ PalletEthereumError: { _enum: ['InvalidSignature', 'PreLogExists'] }, /** - * Lookup341: pallet_evm_coder_substrate::pallet::Error + * Lookup363: pallet_evm_coder_substrate::pallet::Error **/ PalletEvmCoderSubstrateError: { _enum: ['OutOfGas', 'OutOfFund'] }, /** - * Lookup342: pallet_evm_contract_helpers::SponsoringModeT + * Lookup364: pallet_evm_contract_helpers::SponsoringModeT **/ PalletEvmContractHelpersSponsoringModeT: { _enum: ['Disabled', 'Allowlisted', 'Generous'] }, /** - * Lookup344: pallet_evm_contract_helpers::pallet::Error + * Lookup366: pallet_evm_contract_helpers::pallet::Error **/ PalletEvmContractHelpersError: { _enum: ['NoPermission'] }, /** - * Lookup345: pallet_evm_migration::pallet::Error + * Lookup367: pallet_evm_migration::pallet::Error **/ PalletEvmMigrationError: { _enum: ['AccountNotEmpty', 'AccountIsNotMigrating'] }, /** - * Lookup347: sp_runtime::MultiSignature + * Lookup369: sp_runtime::MultiSignature **/ SpRuntimeMultiSignature: { _enum: { @@ -2455,39 +2530,39 @@ } }, /** - * Lookup348: sp_core::ed25519::Signature + * Lookup370: sp_core::ed25519::Signature **/ SpCoreEd25519Signature: '[u8;64]', /** - * Lookup350: sp_core::sr25519::Signature + * Lookup372: sp_core::sr25519::Signature **/ SpCoreSr25519Signature: '[u8;64]', /** - * Lookup351: sp_core::ecdsa::Signature + * Lookup373: sp_core::ecdsa::Signature **/ SpCoreEcdsaSignature: '[u8;65]', /** - * Lookup354: frame_system::extensions::check_spec_version::CheckSpecVersion + * Lookup376: frame_system::extensions::check_spec_version::CheckSpecVersion **/ FrameSystemExtensionsCheckSpecVersion: 'Null', /** - * Lookup355: frame_system::extensions::check_genesis::CheckGenesis + * Lookup377: frame_system::extensions::check_genesis::CheckGenesis **/ FrameSystemExtensionsCheckGenesis: 'Null', /** - * Lookup358: frame_system::extensions::check_nonce::CheckNonce + * Lookup380: frame_system::extensions::check_nonce::CheckNonce **/ FrameSystemExtensionsCheckNonce: 'Compact', /** - * Lookup359: frame_system::extensions::check_weight::CheckWeight + * Lookup381: frame_system::extensions::check_weight::CheckWeight **/ FrameSystemExtensionsCheckWeight: 'Null', /** - * Lookup360: pallet_template_transaction_payment::ChargeTransactionPayment + * Lookup382: pallet_template_transaction_payment::ChargeTransactionPayment **/ PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact', /** - * Lookup361: opal_runtime::Runtime + * Lookup383: opal_runtime::Runtime **/ OpalRuntimeRuntime: 'Null' }; --- a/tests/src/interfaces/registry.ts +++ b/tests/src/interfaces/registry.ts @@ -1,7 +1,7 @@ // Auto-generated via `yarn polkadot-types-from-defs`, do not edit /* eslint-disable */ -import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportStorageBoundedBTreeSet, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExData, UpDataStructsMetaUpdatePermission, UpDataStructsNestingRule, UpDataStructsRpcCollection, UpDataStructsSchemaVersion, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; +import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportStorageBoundedBTreeSet, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsTokenData, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExData, UpDataStructsMetaUpdatePermission, UpDataStructsNestingRule, UpDataStructsProperties, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsRpcCollection, UpDataStructsSchemaVersion, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; declare module '@polkadot/types/types/registry' { export interface InterfaceTypes { @@ -124,7 +124,8 @@ PalletXcmCall: PalletXcmCall; PalletXcmError: PalletXcmError; PalletXcmEvent: PalletXcmEvent; - PhantomTypeUpDataStructs: PhantomTypeUpDataStructs; + PhantomTypeUpDataStructsRpcCollection: PhantomTypeUpDataStructsRpcCollection; + PhantomTypeUpDataStructsTokenData: PhantomTypeUpDataStructsTokenData; PolkadotCorePrimitivesInboundDownwardMessage: PolkadotCorePrimitivesInboundDownwardMessage; PolkadotCorePrimitivesInboundHrmpMessage: PolkadotCorePrimitivesInboundHrmpMessage; PolkadotCorePrimitivesOutboundHrmpMessage: PolkadotCorePrimitivesOutboundHrmpMessage; @@ -162,10 +163,15 @@ UpDataStructsCreateRefungibleExData: UpDataStructsCreateRefungibleExData; UpDataStructsMetaUpdatePermission: UpDataStructsMetaUpdatePermission; UpDataStructsNestingRule: UpDataStructsNestingRule; + UpDataStructsProperties: UpDataStructsProperties; + UpDataStructsProperty: UpDataStructsProperty; + UpDataStructsPropertyKeyPermission: UpDataStructsPropertyKeyPermission; + UpDataStructsPropertyPermission: UpDataStructsPropertyPermission; UpDataStructsRpcCollection: UpDataStructsRpcCollection; UpDataStructsSchemaVersion: UpDataStructsSchemaVersion; UpDataStructsSponsoringRateLimit: UpDataStructsSponsoringRateLimit; UpDataStructsSponsorshipState: UpDataStructsSponsorshipState; + UpDataStructsTokenData: UpDataStructsTokenData; XcmDoubleEncoded: XcmDoubleEncoded; XcmV0Junction: XcmV0Junction; XcmV0JunctionBodyId: XcmV0JunctionBodyId; --- a/tests/src/interfaces/types-lookup.ts +++ b/tests/src/interfaces/types-lookup.ts @@ -1421,6 +1421,33 @@ readonly owner: PalletEvmAccountBasicCrossAccountIdRepr; readonly itemsData: Vec; } & Struct; + readonly isSetCollectionProperties: boolean; + readonly asSetCollectionProperties: { + readonly collectionId: u32; + readonly properties: Vec; + } & Struct; + readonly isDeleteCollectionProperties: boolean; + readonly asDeleteCollectionProperties: { + readonly collectionId: u32; + readonly propertyKeys: Vec; + } & Struct; + readonly isSetTokenProperties: boolean; + readonly asSetTokenProperties: { + readonly collectionId: u32; + readonly tokenId: u32; + readonly properties: Vec; + } & Struct; + readonly isDeleteTokenProperties: boolean; + readonly asDeleteTokenProperties: { + readonly collectionId: u32; + readonly tokenId: u32; + readonly propertyKeys: Vec; + } & Struct; + readonly isSetPropertyPermissions: boolean; + readonly asSetPropertyPermissions: { + readonly collectionId: u32; + readonly propertyPermissions: Vec; + } & Struct; readonly isCreateMultipleItemsEx: boolean; readonly asCreateMultipleItemsEx: { readonly collectionId: u32; @@ -1502,7 +1529,7 @@ readonly collectionId: u32; readonly newLimit: UpDataStructsCollectionLimits; } & Struct; - readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'SetPublicAccessMode' | 'SetMintPermission' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetVariableMetaData' | 'SetMetaUpdatePermissionFlag' | 'SetSchemaVersion' | 'SetOffchainSchema' | 'SetConstOnChainSchema' | 'SetVariableOnChainSchema' | 'SetCollectionLimits'; + readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'SetPublicAccessMode' | 'SetMintPermission' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetVariableMetaData' | 'SetMetaUpdatePermissionFlag' | 'SetSchemaVersion' | 'SetOffchainSchema' | 'SetConstOnChainSchema' | 'SetVariableOnChainSchema' | 'SetCollectionLimits'; } /** @name UpDataStructsCollectionMode (156) */ @@ -1528,6 +1555,8 @@ readonly variableOnChainSchema: Bytes; readonly constOnChainSchema: Bytes; readonly metaUpdatePermission: Option; + readonly tokenPropertyPermissions: Vec; + readonly properties: Vec; } /** @name UpDataStructsAccessMode (159) */ @@ -1586,7 +1615,26 @@ readonly type: 'ItemOwner' | 'Admin' | 'None'; } - /** @name PalletEvmAccountBasicCrossAccountIdRepr (178) */ + /** @name UpDataStructsPropertyKeyPermission (179) */ + export interface UpDataStructsPropertyKeyPermission extends Struct { + readonly key: Bytes; + readonly permission: UpDataStructsPropertyPermission; + } + + /** @name UpDataStructsPropertyPermission (181) */ + export interface UpDataStructsPropertyPermission extends Struct { + readonly mutable: bool; + readonly collectionAdmin: bool; + readonly tokenOwner: bool; + } + + /** @name UpDataStructsProperty (184) */ + export interface UpDataStructsProperty extends Struct { + readonly key: Bytes; + readonly value: Bytes; + } + + /** @name PalletEvmAccountBasicCrossAccountIdRepr (186) */ export interface PalletEvmAccountBasicCrossAccountIdRepr extends Enum { readonly isSubstrate: boolean; readonly asSubstrate: AccountId32; @@ -1595,7 +1643,7 @@ readonly type: 'Substrate' | 'Ethereum'; } - /** @name UpDataStructsCreateItemData (180) */ + /** @name UpDataStructsCreateItemData (188) */ export interface UpDataStructsCreateItemData extends Enum { readonly isNft: boolean; readonly asNft: UpDataStructsCreateNftData; @@ -1606,25 +1654,26 @@ readonly type: 'Nft' | 'Fungible' | 'ReFungible'; } - /** @name UpDataStructsCreateNftData (181) */ + /** @name UpDataStructsCreateNftData (189) */ export interface UpDataStructsCreateNftData extends Struct { readonly constData: Bytes; readonly variableData: Bytes; + readonly properties: Vec; } - /** @name UpDataStructsCreateFungibleData (183) */ + /** @name UpDataStructsCreateFungibleData (191) */ export interface UpDataStructsCreateFungibleData extends Struct { readonly value: u128; } - /** @name UpDataStructsCreateReFungibleData (184) */ + /** @name UpDataStructsCreateReFungibleData (192) */ export interface UpDataStructsCreateReFungibleData extends Struct { readonly constData: Bytes; readonly variableData: Bytes; readonly pieces: u128; } - /** @name UpDataStructsCreateItemExData (186) */ + /** @name UpDataStructsCreateItemExData (196) */ export interface UpDataStructsCreateItemExData extends Enum { readonly isNft: boolean; readonly asNft: Vec; @@ -1637,27 +1686,28 @@ readonly type: 'Nft' | 'Fungible' | 'RefungibleMultipleItems' | 'RefungibleMultipleOwners'; } - /** @name UpDataStructsCreateNftExData (188) */ + /** @name UpDataStructsCreateNftExData (198) */ export interface UpDataStructsCreateNftExData extends Struct { readonly constData: Bytes; readonly variableData: Bytes; + readonly properties: Vec; readonly owner: PalletEvmAccountBasicCrossAccountIdRepr; } - /** @name UpDataStructsCreateRefungibleExData (195) */ + /** @name UpDataStructsCreateRefungibleExData (205) */ export interface UpDataStructsCreateRefungibleExData extends Struct { readonly constData: Bytes; readonly variableData: Bytes; readonly users: BTreeMap; } - /** @name PalletTemplateTransactionPaymentCall (198) */ + /** @name PalletTemplateTransactionPaymentCall (207) */ export type PalletTemplateTransactionPaymentCall = Null; - /** @name PalletStructureCall (199) */ + /** @name PalletStructureCall (208) */ export type PalletStructureCall = Null; - /** @name PalletEvmCall (200) */ + /** @name PalletEvmCall (209) */ export interface PalletEvmCall extends Enum { readonly isWithdraw: boolean; readonly asWithdraw: { @@ -1702,7 +1752,7 @@ readonly type: 'Withdraw' | 'Call' | 'Create' | 'Create2'; } - /** @name PalletEthereumCall (206) */ + /** @name PalletEthereumCall (215) */ export interface PalletEthereumCall extends Enum { readonly isTransact: boolean; readonly asTransact: { @@ -1711,7 +1761,7 @@ readonly type: 'Transact'; } - /** @name EthereumTransactionTransactionV2 (207) */ + /** @name EthereumTransactionTransactionV2 (216) */ export interface EthereumTransactionTransactionV2 extends Enum { readonly isLegacy: boolean; readonly asLegacy: EthereumTransactionLegacyTransaction; @@ -1722,7 +1772,7 @@ readonly type: 'Legacy' | 'Eip2930' | 'Eip1559'; } - /** @name EthereumTransactionLegacyTransaction (208) */ + /** @name EthereumTransactionLegacyTransaction (217) */ export interface EthereumTransactionLegacyTransaction extends Struct { readonly nonce: U256; readonly gasPrice: U256; @@ -1733,7 +1783,7 @@ readonly signature: EthereumTransactionTransactionSignature; } - /** @name EthereumTransactionTransactionAction (209) */ + /** @name EthereumTransactionTransactionAction (218) */ export interface EthereumTransactionTransactionAction extends Enum { readonly isCall: boolean; readonly asCall: H160; @@ -1741,14 +1791,14 @@ readonly type: 'Call' | 'Create'; } - /** @name EthereumTransactionTransactionSignature (210) */ + /** @name EthereumTransactionTransactionSignature (219) */ export interface EthereumTransactionTransactionSignature extends Struct { readonly v: u64; readonly r: H256; readonly s: H256; } - /** @name EthereumTransactionEip2930Transaction (212) */ + /** @name EthereumTransactionEip2930Transaction (221) */ export interface EthereumTransactionEip2930Transaction extends Struct { readonly chainId: u64; readonly nonce: U256; @@ -1763,13 +1813,13 @@ readonly s: H256; } - /** @name EthereumTransactionAccessListItem (214) */ + /** @name EthereumTransactionAccessListItem (223) */ export interface EthereumTransactionAccessListItem extends Struct { readonly address: H160; readonly storageKeys: Vec; } - /** @name EthereumTransactionEip1559Transaction (215) */ + /** @name EthereumTransactionEip1559Transaction (224) */ export interface EthereumTransactionEip1559Transaction extends Struct { readonly chainId: u64; readonly nonce: U256; @@ -1785,7 +1835,7 @@ readonly s: H256; } - /** @name PalletEvmMigrationCall (216) */ + /** @name PalletEvmMigrationCall (225) */ export interface PalletEvmMigrationCall extends Enum { readonly isBegin: boolean; readonly asBegin: { @@ -1804,7 +1854,7 @@ readonly type: 'Begin' | 'SetData' | 'Finish'; } - /** @name PalletSudoEvent (219) */ + /** @name PalletSudoEvent (228) */ export interface PalletSudoEvent extends Enum { readonly isSudid: boolean; readonly asSudid: { @@ -1821,7 +1871,7 @@ readonly type: 'Sudid' | 'KeyChanged' | 'SudoAsDone'; } - /** @name SpRuntimeDispatchError (221) */ + /** @name SpRuntimeDispatchError (230) */ export interface SpRuntimeDispatchError extends Enum { readonly isOther: boolean; readonly isCannotLookup: boolean; @@ -1840,13 +1890,13 @@ readonly type: 'Other' | 'CannotLookup' | 'BadOrigin' | 'Module' | 'ConsumerRemaining' | 'NoProviders' | 'TooManyConsumers' | 'Token' | 'Arithmetic' | 'Transactional'; } - /** @name SpRuntimeModuleError (222) */ + /** @name SpRuntimeModuleError (231) */ export interface SpRuntimeModuleError extends Struct { readonly index: u8; readonly error: U8aFixed; } - /** @name SpRuntimeTokenError (223) */ + /** @name SpRuntimeTokenError (232) */ export interface SpRuntimeTokenError extends Enum { readonly isNoFunds: boolean; readonly isWouldDie: boolean; @@ -1858,7 +1908,7 @@ readonly type: 'NoFunds' | 'WouldDie' | 'BelowMinimum' | 'CannotCreate' | 'UnknownAsset' | 'Frozen' | 'Unsupported'; } - /** @name SpRuntimeArithmeticError (224) */ + /** @name SpRuntimeArithmeticError (233) */ export interface SpRuntimeArithmeticError extends Enum { readonly isUnderflow: boolean; readonly isOverflow: boolean; @@ -1866,20 +1916,20 @@ readonly type: 'Underflow' | 'Overflow' | 'DivisionByZero'; } - /** @name SpRuntimeTransactionalError (225) */ + /** @name SpRuntimeTransactionalError (234) */ export interface SpRuntimeTransactionalError extends Enum { readonly isLimitReached: boolean; readonly isNoLayer: boolean; readonly type: 'LimitReached' | 'NoLayer'; } - /** @name PalletSudoError (226) */ + /** @name PalletSudoError (235) */ export interface PalletSudoError extends Enum { readonly isRequireSudo: boolean; readonly type: 'RequireSudo'; } - /** @name FrameSystemAccountInfo (227) */ + /** @name FrameSystemAccountInfo (236) */ export interface FrameSystemAccountInfo extends Struct { readonly nonce: u32; readonly consumers: u32; @@ -1888,19 +1938,19 @@ readonly data: PalletBalancesAccountData; } - /** @name FrameSupportWeightsPerDispatchClassU64 (228) */ + /** @name FrameSupportWeightsPerDispatchClassU64 (237) */ export interface FrameSupportWeightsPerDispatchClassU64 extends Struct { readonly normal: u64; readonly operational: u64; readonly mandatory: u64; } - /** @name SpRuntimeDigest (229) */ + /** @name SpRuntimeDigest (238) */ export interface SpRuntimeDigest extends Struct { readonly logs: Vec; } - /** @name SpRuntimeDigestDigestItem (231) */ + /** @name SpRuntimeDigestDigestItem (240) */ export interface SpRuntimeDigestDigestItem extends Enum { readonly isOther: boolean; readonly asOther: Bytes; @@ -1914,14 +1964,14 @@ readonly type: 'Other' | 'Consensus' | 'Seal' | 'PreRuntime' | 'RuntimeEnvironmentUpdated'; } - /** @name FrameSystemEventRecord (233) */ + /** @name FrameSystemEventRecord (242) */ export interface FrameSystemEventRecord extends Struct { readonly phase: FrameSystemPhase; readonly event: Event; readonly topics: Vec; } - /** @name FrameSystemEvent (235) */ + /** @name FrameSystemEvent (244) */ export interface FrameSystemEvent extends Enum { readonly isExtrinsicSuccess: boolean; readonly asExtrinsicSuccess: { @@ -1949,14 +1999,14 @@ readonly type: 'ExtrinsicSuccess' | 'ExtrinsicFailed' | 'CodeUpdated' | 'NewAccount' | 'KilledAccount' | 'Remarked'; } - /** @name FrameSupportWeightsDispatchInfo (236) */ + /** @name FrameSupportWeightsDispatchInfo (245) */ export interface FrameSupportWeightsDispatchInfo extends Struct { readonly weight: u64; readonly class: FrameSupportWeightsDispatchClass; readonly paysFee: FrameSupportWeightsPays; } - /** @name FrameSupportWeightsDispatchClass (237) */ + /** @name FrameSupportWeightsDispatchClass (246) */ export interface FrameSupportWeightsDispatchClass extends Enum { readonly isNormal: boolean; readonly isOperational: boolean; @@ -1964,14 +2014,14 @@ readonly type: 'Normal' | 'Operational' | 'Mandatory'; } - /** @name FrameSupportWeightsPays (238) */ + /** @name FrameSupportWeightsPays (247) */ export interface FrameSupportWeightsPays extends Enum { readonly isYes: boolean; readonly isNo: boolean; readonly type: 'Yes' | 'No'; } - /** @name OrmlVestingModuleEvent (239) */ + /** @name OrmlVestingModuleEvent (248) */ export interface OrmlVestingModuleEvent extends Enum { readonly isVestingScheduleAdded: boolean; readonly asVestingScheduleAdded: { @@ -1991,7 +2041,7 @@ readonly type: 'VestingScheduleAdded' | 'Claimed' | 'VestingSchedulesUpdated'; } - /** @name CumulusPalletXcmpQueueEvent (240) */ + /** @name CumulusPalletXcmpQueueEvent (249) */ export interface CumulusPalletXcmpQueueEvent extends Enum { readonly isSuccess: boolean; readonly asSuccess: Option; @@ -2012,7 +2062,7 @@ readonly type: 'Success' | 'Fail' | 'BadVersion' | 'BadFormat' | 'UpwardMessageSent' | 'XcmpMessageSent' | 'OverweightEnqueued' | 'OverweightServiced'; } - /** @name PalletXcmEvent (241) */ + /** @name PalletXcmEvent (250) */ export interface PalletXcmEvent extends Enum { readonly isAttempted: boolean; readonly asAttempted: XcmV2TraitsOutcome; @@ -2049,7 +2099,7 @@ readonly type: 'Attempted' | 'Sent' | 'UnexpectedResponse' | 'ResponseReady' | 'Notified' | 'NotifyOverweight' | 'NotifyDispatchError' | 'NotifyDecodeFailed' | 'InvalidResponder' | 'InvalidResponderVersion' | 'ResponseTaken' | 'AssetsTrapped' | 'VersionChangeNotified' | 'SupportedVersionChanged' | 'NotifyTargetSendFail' | 'NotifyTargetMigrationFail'; } - /** @name XcmV2TraitsOutcome (242) */ + /** @name XcmV2TraitsOutcome (251) */ export interface XcmV2TraitsOutcome extends Enum { readonly isComplete: boolean; readonly asComplete: u64; @@ -2060,7 +2110,7 @@ readonly type: 'Complete' | 'Incomplete' | 'Error'; } - /** @name CumulusPalletXcmEvent (244) */ + /** @name CumulusPalletXcmEvent (253) */ export interface CumulusPalletXcmEvent extends Enum { readonly isInvalidFormat: boolean; readonly asInvalidFormat: U8aFixed; @@ -2071,7 +2121,7 @@ readonly type: 'InvalidFormat' | 'UnsupportedVersion' | 'ExecutedDownward'; } - /** @name CumulusPalletDmpQueueEvent (245) */ + /** @name CumulusPalletDmpQueueEvent (254) */ export interface CumulusPalletDmpQueueEvent extends Enum { readonly isInvalidFormat: boolean; readonly asInvalidFormat: U8aFixed; @@ -2088,7 +2138,7 @@ readonly type: 'InvalidFormat' | 'UnsupportedVersion' | 'ExecutedDownward' | 'WeightExhausted' | 'OverweightEnqueued' | 'OverweightServiced'; } - /** @name PalletUniqueRawEvent (246) */ + /** @name PalletUniqueRawEvent (255) */ export interface PalletUniqueRawEvent extends Enum { readonly isCollectionSponsorRemoved: boolean; readonly asCollectionSponsorRemoved: u32; @@ -2123,7 +2173,7 @@ readonly type: 'CollectionSponsorRemoved' | 'CollectionAdminAdded' | 'CollectionOwnedChanged' | 'CollectionSponsorSet' | 'ConstOnChainSchemaSet' | 'SponsorshipConfirmed' | 'CollectionAdminRemoved' | 'AllowListAddressRemoved' | 'AllowListAddressAdded' | 'CollectionLimitSet' | 'MintPermissionSet' | 'OffchainSchemaSet' | 'PublicAccessModeSet' | 'SchemaVersionSet' | 'VariableOnChainSchemaSet'; } - /** @name PalletCommonEvent (247) */ + /** @name PalletCommonEvent (256) */ export interface PalletCommonEvent extends Enum { readonly isCollectionCreated: boolean; readonly asCollectionCreated: ITuple<[u32, u8, AccountId32]>; @@ -2137,17 +2187,27 @@ readonly asTransfer: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>; readonly isApproved: boolean; readonly asApproved: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>; - readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved'; + readonly isCollectionPropertySet: boolean; + readonly asCollectionPropertySet: ITuple<[u32, UpDataStructsProperty]>; + readonly isCollectionPropertyDeleted: boolean; + readonly asCollectionPropertyDeleted: ITuple<[u32, Bytes]>; + readonly isTokenPropertySet: boolean; + readonly asTokenPropertySet: ITuple<[u32, u32, UpDataStructsProperty]>; + readonly isTokenPropertyDeleted: boolean; + readonly asTokenPropertyDeleted: ITuple<[u32, u32, Bytes]>; + readonly isPropertyPermissionSet: boolean; + readonly asPropertyPermissionSet: ITuple<[u32, UpDataStructsPropertyKeyPermission]>; + readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved' | 'CollectionPropertySet' | 'CollectionPropertyDeleted' | 'TokenPropertySet' | 'TokenPropertyDeleted' | 'PropertyPermissionSet'; } - /** @name PalletStructureEvent (248) */ + /** @name PalletStructureEvent (257) */ export interface PalletStructureEvent extends Enum { readonly isExecuted: boolean; readonly asExecuted: Result; readonly type: 'Executed'; } - /** @name PalletEvmEvent (249) */ + /** @name PalletEvmEvent (258) */ export interface PalletEvmEvent extends Enum { readonly isLog: boolean; readonly asLog: EthereumLog; @@ -2166,21 +2226,21 @@ readonly type: 'Log' | 'Created' | 'CreatedFailed' | 'Executed' | 'ExecutedFailed' | 'BalanceDeposit' | 'BalanceWithdraw'; } - /** @name EthereumLog (250) */ + /** @name EthereumLog (259) */ export interface EthereumLog extends Struct { readonly address: H160; readonly topics: Vec; readonly data: Bytes; } - /** @name PalletEthereumEvent (251) */ + /** @name PalletEthereumEvent (260) */ export interface PalletEthereumEvent extends Enum { readonly isExecuted: boolean; readonly asExecuted: ITuple<[H160, H160, H256, EvmCoreErrorExitReason]>; readonly type: 'Executed'; } - /** @name EvmCoreErrorExitReason (252) */ + /** @name EvmCoreErrorExitReason (261) */ export interface EvmCoreErrorExitReason extends Enum { readonly isSucceed: boolean; readonly asSucceed: EvmCoreErrorExitSucceed; @@ -2193,7 +2253,7 @@ readonly type: 'Succeed' | 'Error' | 'Revert' | 'Fatal'; } - /** @name EvmCoreErrorExitSucceed (253) */ + /** @name EvmCoreErrorExitSucceed (262) */ export interface EvmCoreErrorExitSucceed extends Enum { readonly isStopped: boolean; readonly isReturned: boolean; @@ -2201,7 +2261,7 @@ readonly type: 'Stopped' | 'Returned' | 'Suicided'; } - /** @name EvmCoreErrorExitError (254) */ + /** @name EvmCoreErrorExitError (263) */ export interface EvmCoreErrorExitError extends Enum { readonly isStackUnderflow: boolean; readonly isStackOverflow: boolean; @@ -2222,13 +2282,13 @@ readonly type: 'StackUnderflow' | 'StackOverflow' | 'InvalidJump' | 'InvalidRange' | 'DesignatedInvalid' | 'CallTooDeep' | 'CreateCollision' | 'CreateContractLimit' | 'OutOfOffset' | 'OutOfGas' | 'OutOfFund' | 'PcUnderflow' | 'CreateEmpty' | 'Other' | 'InvalidCode'; } - /** @name EvmCoreErrorExitRevert (257) */ + /** @name EvmCoreErrorExitRevert (266) */ export interface EvmCoreErrorExitRevert extends Enum { readonly isReverted: boolean; readonly type: 'Reverted'; } - /** @name EvmCoreErrorExitFatal (258) */ + /** @name EvmCoreErrorExitFatal (267) */ export interface EvmCoreErrorExitFatal extends Enum { readonly isNotSupported: boolean; readonly isUnhandledInterrupt: boolean; @@ -2239,7 +2299,7 @@ readonly type: 'NotSupported' | 'UnhandledInterrupt' | 'CallErrorAsFatal' | 'Other'; } - /** @name FrameSystemPhase (259) */ + /** @name FrameSystemPhase (268) */ export interface FrameSystemPhase extends Enum { readonly isApplyExtrinsic: boolean; readonly asApplyExtrinsic: u32; @@ -2248,27 +2308,27 @@ readonly type: 'ApplyExtrinsic' | 'Finalization' | 'Initialization'; } - /** @name FrameSystemLastRuntimeUpgradeInfo (261) */ + /** @name FrameSystemLastRuntimeUpgradeInfo (270) */ export interface FrameSystemLastRuntimeUpgradeInfo extends Struct { readonly specVersion: Compact; readonly specName: Text; } - /** @name FrameSystemLimitsBlockWeights (262) */ + /** @name FrameSystemLimitsBlockWeights (271) */ export interface FrameSystemLimitsBlockWeights extends Struct { readonly baseBlock: u64; readonly maxBlock: u64; readonly perClass: FrameSupportWeightsPerDispatchClassWeightsPerClass; } - /** @name FrameSupportWeightsPerDispatchClassWeightsPerClass (263) */ + /** @name FrameSupportWeightsPerDispatchClassWeightsPerClass (272) */ export interface FrameSupportWeightsPerDispatchClassWeightsPerClass extends Struct { readonly normal: FrameSystemLimitsWeightsPerClass; readonly operational: FrameSystemLimitsWeightsPerClass; readonly mandatory: FrameSystemLimitsWeightsPerClass; } - /** @name FrameSystemLimitsWeightsPerClass (264) */ + /** @name FrameSystemLimitsWeightsPerClass (273) */ export interface FrameSystemLimitsWeightsPerClass extends Struct { readonly baseExtrinsic: u64; readonly maxExtrinsic: Option; @@ -2276,25 +2336,25 @@ readonly reserved: Option; } - /** @name FrameSystemLimitsBlockLength (266) */ + /** @name FrameSystemLimitsBlockLength (275) */ export interface FrameSystemLimitsBlockLength extends Struct { readonly max: FrameSupportWeightsPerDispatchClassU32; } - /** @name FrameSupportWeightsPerDispatchClassU32 (267) */ + /** @name FrameSupportWeightsPerDispatchClassU32 (276) */ export interface FrameSupportWeightsPerDispatchClassU32 extends Struct { readonly normal: u32; readonly operational: u32; readonly mandatory: u32; } - /** @name FrameSupportWeightsRuntimeDbWeight (268) */ + /** @name FrameSupportWeightsRuntimeDbWeight (277) */ export interface FrameSupportWeightsRuntimeDbWeight extends Struct { readonly read: u64; readonly write: u64; } - /** @name SpVersionRuntimeVersion (269) */ + /** @name SpVersionRuntimeVersion (278) */ export interface SpVersionRuntimeVersion extends Struct { readonly specName: Text; readonly implName: Text; @@ -2306,7 +2366,7 @@ readonly stateVersion: u8; } - /** @name FrameSystemError (273) */ + /** @name FrameSystemError (282) */ export interface FrameSystemError extends Enum { readonly isInvalidSpecName: boolean; readonly isSpecVersionNeedsToIncrease: boolean; @@ -2317,7 +2377,7 @@ readonly type: 'InvalidSpecName' | 'SpecVersionNeedsToIncrease' | 'FailedToExtractRuntimeVersion' | 'NonDefaultComposite' | 'NonZeroRefCount' | 'CallFiltered'; } - /** @name OrmlVestingModuleError (275) */ + /** @name OrmlVestingModuleError (284) */ export interface OrmlVestingModuleError extends Enum { readonly isZeroVestingPeriod: boolean; readonly isZeroVestingPeriodCount: boolean; @@ -2328,21 +2388,21 @@ readonly type: 'ZeroVestingPeriod' | 'ZeroVestingPeriodCount' | 'InsufficientBalanceToLock' | 'TooManyVestingSchedules' | 'AmountLow' | 'MaxVestingSchedulesExceeded'; } - /** @name CumulusPalletXcmpQueueInboundChannelDetails (277) */ + /** @name CumulusPalletXcmpQueueInboundChannelDetails (286) */ export interface CumulusPalletXcmpQueueInboundChannelDetails extends Struct { readonly sender: u32; readonly state: CumulusPalletXcmpQueueInboundState; readonly messageMetadata: Vec>; } - /** @name CumulusPalletXcmpQueueInboundState (278) */ + /** @name CumulusPalletXcmpQueueInboundState (287) */ export interface CumulusPalletXcmpQueueInboundState extends Enum { readonly isOk: boolean; readonly isSuspended: boolean; readonly type: 'Ok' | 'Suspended'; } - /** @name PolkadotParachainPrimitivesXcmpMessageFormat (281) */ + /** @name PolkadotParachainPrimitivesXcmpMessageFormat (290) */ export interface PolkadotParachainPrimitivesXcmpMessageFormat extends Enum { readonly isConcatenatedVersionedXcm: boolean; readonly isConcatenatedEncodedBlob: boolean; @@ -2350,7 +2410,7 @@ readonly type: 'ConcatenatedVersionedXcm' | 'ConcatenatedEncodedBlob' | 'Signals'; } - /** @name CumulusPalletXcmpQueueOutboundChannelDetails (284) */ + /** @name CumulusPalletXcmpQueueOutboundChannelDetails (293) */ export interface CumulusPalletXcmpQueueOutboundChannelDetails extends Struct { readonly recipient: u32; readonly state: CumulusPalletXcmpQueueOutboundState; @@ -2359,14 +2419,14 @@ readonly lastIndex: u16; } - /** @name CumulusPalletXcmpQueueOutboundState (285) */ + /** @name CumulusPalletXcmpQueueOutboundState (294) */ export interface CumulusPalletXcmpQueueOutboundState extends Enum { readonly isOk: boolean; readonly isSuspended: boolean; readonly type: 'Ok' | 'Suspended'; } - /** @name CumulusPalletXcmpQueueQueueConfigData (287) */ + /** @name CumulusPalletXcmpQueueQueueConfigData (296) */ export interface CumulusPalletXcmpQueueQueueConfigData extends Struct { readonly suspendThreshold: u32; readonly dropThreshold: u32; @@ -2376,7 +2436,7 @@ readonly xcmpMaxIndividualWeight: u64; } - /** @name CumulusPalletXcmpQueueError (289) */ + /** @name CumulusPalletXcmpQueueError (298) */ export interface CumulusPalletXcmpQueueError extends Enum { readonly isFailedToSend: boolean; readonly isBadXcmOrigin: boolean; @@ -2386,7 +2446,7 @@ readonly type: 'FailedToSend' | 'BadXcmOrigin' | 'BadXcm' | 'BadOverweightIndex' | 'WeightOverLimit'; } - /** @name PalletXcmError (290) */ + /** @name PalletXcmError (299) */ export interface PalletXcmError extends Enum { readonly isUnreachable: boolean; readonly isSendFailure: boolean; @@ -2404,29 +2464,29 @@ readonly type: 'Unreachable' | 'SendFailure' | 'Filtered' | 'UnweighableMessage' | 'DestinationNotInvertible' | 'Empty' | 'CannotReanchor' | 'TooManyAssets' | 'InvalidOrigin' | 'BadVersion' | 'BadLocation' | 'NoSubscription' | 'AlreadySubscribed'; } - /** @name CumulusPalletXcmError (291) */ + /** @name CumulusPalletXcmError (300) */ export type CumulusPalletXcmError = Null; - /** @name CumulusPalletDmpQueueConfigData (292) */ + /** @name CumulusPalletDmpQueueConfigData (301) */ export interface CumulusPalletDmpQueueConfigData extends Struct { readonly maxIndividual: u64; } - /** @name CumulusPalletDmpQueuePageIndexData (293) */ + /** @name CumulusPalletDmpQueuePageIndexData (302) */ export interface CumulusPalletDmpQueuePageIndexData extends Struct { readonly beginUsed: u32; readonly endUsed: u32; readonly overweightCount: u64; } - /** @name CumulusPalletDmpQueueError (296) */ + /** @name CumulusPalletDmpQueueError (305) */ export interface CumulusPalletDmpQueueError extends Enum { readonly isUnknown: boolean; readonly isOverLimit: boolean; readonly type: 'Unknown' | 'OverLimit'; } - /** @name PalletUniqueError (300) */ + /** @name PalletUniqueError (309) */ export interface PalletUniqueError extends Enum { readonly isCollectionDecimalPointLimitExceeded: boolean; readonly isConfirmUnsetSponsorFail: boolean; @@ -2434,7 +2494,7 @@ readonly type: 'CollectionDecimalPointLimitExceeded' | 'ConfirmUnsetSponsorFail' | 'EmptyArgument'; } - /** @name UpDataStructsCollection (301) */ + /** @name UpDataStructsCollection (310) */ export interface UpDataStructsCollection extends Struct { readonly owner: AccountId32; readonly mode: UpDataStructsCollectionMode; @@ -2449,7 +2509,7 @@ readonly metaUpdatePermission: UpDataStructsMetaUpdatePermission; } - /** @name UpDataStructsSponsorshipState (302) */ + /** @name UpDataStructsSponsorshipState (311) */ export interface UpDataStructsSponsorshipState extends Enum { readonly isDisabled: boolean; readonly isUnconfirmed: boolean; @@ -2459,7 +2519,14 @@ readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed'; } - /** @name UpDataStructsCollectionField (304) */ + /** @name UpDataStructsProperties (312) */ + export interface UpDataStructsProperties extends Struct { + readonly map: BTreeMap; + readonly consumedSpace: u32; + readonly spaceLimit: u32; + } + + /** @name UpDataStructsCollectionField (322) */ export interface UpDataStructsCollectionField extends Enum { readonly isVariableOnChainSchema: boolean; readonly isConstOnChainSchema: boolean; @@ -2467,17 +2534,27 @@ readonly type: 'VariableOnChainSchema' | 'ConstOnChainSchema' | 'OffchainSchema'; } - /** @name UpDataStructsCollectionStats (307) */ + /** @name UpDataStructsCollectionStats (325) */ export interface UpDataStructsCollectionStats extends Struct { readonly created: u32; readonly destroyed: u32; readonly alive: u32; } - /** @name PhantomTypeUpDataStructs (308) */ - export interface PhantomTypeUpDataStructs extends Vec {} + /** @name PhantomTypeUpDataStructsTokenData (326) */ + export interface PhantomTypeUpDataStructsTokenData extends Vec {} + + /** @name UpDataStructsTokenData (327) */ + export interface UpDataStructsTokenData extends Struct { + readonly constData: Bytes; + readonly properties: Vec; + readonly owner: Option; + } + + /** @name PhantomTypeUpDataStructsRpcCollection (330) */ + export interface PhantomTypeUpDataStructsRpcCollection extends Vec {} - /** @name UpDataStructsRpcCollection (309) */ + /** @name UpDataStructsRpcCollection (331) */ export interface UpDataStructsRpcCollection extends Struct { readonly owner: AccountId32; readonly mode: UpDataStructsCollectionMode; @@ -2493,9 +2570,11 @@ readonly variableOnChainSchema: Bytes; readonly constOnChainSchema: Bytes; readonly metaUpdatePermission: UpDataStructsMetaUpdatePermission; + readonly tokenPropertyPermissions: Vec; + readonly properties: Vec; } - /** @name PalletCommonError (311) */ + /** @name PalletCommonError (333) */ export interface PalletCommonError extends Enum { readonly isCollectionNotFound: boolean; readonly isMustBeTokenOwner: boolean; @@ -2525,47 +2604,51 @@ readonly isOnlyOwnerAllowedToNest: boolean; readonly isSourceCollectionIsNotAllowedToNest: boolean; readonly isCollectionFieldSizeExceeded: boolean; - readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'TokenVariableDataLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'NestingIsDisabled' | 'OnlyOwnerAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded'; + readonly isNoSpaceForProperty: boolean; + readonly isPropertyLimitReached: boolean; + readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'TokenVariableDataLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'NestingIsDisabled' | 'OnlyOwnerAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded' | 'NoSpaceForProperty' | 'PropertyLimitReached'; } - /** @name PalletFungibleError (313) */ + /** @name PalletFungibleError (335) */ export interface PalletFungibleError extends Enum { readonly isNotFungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isFungibleItemsHaveNoId: boolean; readonly isFungibleItemsDontHaveData: boolean; readonly isFungibleDisallowsNesting: boolean; - readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting'; + readonly isSettingPropertiesNotAllowed: boolean; + readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed'; } - /** @name PalletRefungibleItemData (314) */ + /** @name PalletRefungibleItemData (336) */ export interface PalletRefungibleItemData extends Struct { readonly constData: Bytes; readonly variableData: Bytes; } - /** @name PalletRefungibleError (318) */ + /** @name PalletRefungibleError (340) */ export interface PalletRefungibleError extends Enum { readonly isNotRefungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isWrongRefungiblePieces: boolean; readonly isRefungibleDisallowsNesting: boolean; - readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RefungibleDisallowsNesting'; + readonly isSettingPropertiesNotAllowed: boolean; + readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RefungibleDisallowsNesting' | 'SettingPropertiesNotAllowed'; } - /** @name PalletNonfungibleItemData (319) */ + /** @name PalletNonfungibleItemData (341) */ export interface PalletNonfungibleItemData extends Struct { readonly constData: Bytes; readonly variableData: Bytes; readonly owner: PalletEvmAccountBasicCrossAccountIdRepr; } - /** @name PalletNonfungibleError (320) */ + /** @name PalletNonfungibleError (342) */ export interface PalletNonfungibleError extends Enum { readonly isNotNonfungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isNonfungibleItemsHaveNoAmount: boolean; readonly type: 'NotNonfungibleDataUsedToMintFungibleCollectionToken' | 'NonfungibleItemsHaveNoAmount'; } - /** @name PalletStructureError (321) */ + /** @name PalletStructureError (343) */ export interface PalletStructureError extends Enum { readonly isOuroborosDetected: boolean; readonly isDepthLimit: boolean; @@ -2573,7 +2656,7 @@ readonly type: 'OuroborosDetected' | 'DepthLimit' | 'TokenNotFound'; } - /** @name PalletEvmError (323) */ + /** @name PalletEvmError (345) */ export interface PalletEvmError extends Enum { readonly isBalanceLow: boolean; readonly isFeeOverflow: boolean; @@ -2584,7 +2667,7 @@ readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce'; } - /** @name FpRpcTransactionStatus (326) */ + /** @name FpRpcTransactionStatus (348) */ export interface FpRpcTransactionStatus extends Struct { readonly transactionHash: H256; readonly transactionIndex: u32; @@ -2595,10 +2678,10 @@ readonly logsBloom: EthbloomBloom; } - /** @name EthbloomBloom (329) */ + /** @name EthbloomBloom (351) */ export interface EthbloomBloom extends U8aFixed {} - /** @name EthereumReceiptReceiptV3 (331) */ + /** @name EthereumReceiptReceiptV3 (353) */ export interface EthereumReceiptReceiptV3 extends Enum { readonly isLegacy: boolean; readonly asLegacy: EthereumReceiptEip658ReceiptData; @@ -2609,7 +2692,7 @@ readonly type: 'Legacy' | 'Eip2930' | 'Eip1559'; } - /** @name EthereumReceiptEip658ReceiptData (332) */ + /** @name EthereumReceiptEip658ReceiptData (354) */ export interface EthereumReceiptEip658ReceiptData extends Struct { readonly statusCode: u8; readonly usedGas: U256; @@ -2617,14 +2700,14 @@ readonly logs: Vec; } - /** @name EthereumBlock (333) */ + /** @name EthereumBlock (355) */ export interface EthereumBlock extends Struct { readonly header: EthereumHeader; readonly transactions: Vec; readonly ommers: Vec; } - /** @name EthereumHeader (334) */ + /** @name EthereumHeader (356) */ export interface EthereumHeader extends Struct { readonly parentHash: H256; readonly ommersHash: H256; @@ -2643,24 +2726,24 @@ readonly nonce: EthereumTypesHashH64; } - /** @name EthereumTypesHashH64 (335) */ + /** @name EthereumTypesHashH64 (357) */ export interface EthereumTypesHashH64 extends U8aFixed {} - /** @name PalletEthereumError (340) */ + /** @name PalletEthereumError (362) */ export interface PalletEthereumError extends Enum { readonly isInvalidSignature: boolean; readonly isPreLogExists: boolean; readonly type: 'InvalidSignature' | 'PreLogExists'; } - /** @name PalletEvmCoderSubstrateError (341) */ + /** @name PalletEvmCoderSubstrateError (363) */ export interface PalletEvmCoderSubstrateError extends Enum { readonly isOutOfGas: boolean; readonly isOutOfFund: boolean; readonly type: 'OutOfGas' | 'OutOfFund'; } - /** @name PalletEvmContractHelpersSponsoringModeT (342) */ + /** @name PalletEvmContractHelpersSponsoringModeT (364) */ export interface PalletEvmContractHelpersSponsoringModeT extends Enum { readonly isDisabled: boolean; readonly isAllowlisted: boolean; @@ -2668,20 +2751,20 @@ readonly type: 'Disabled' | 'Allowlisted' | 'Generous'; } - /** @name PalletEvmContractHelpersError (344) */ + /** @name PalletEvmContractHelpersError (366) */ export interface PalletEvmContractHelpersError extends Enum { readonly isNoPermission: boolean; readonly type: 'NoPermission'; } - /** @name PalletEvmMigrationError (345) */ + /** @name PalletEvmMigrationError (367) */ export interface PalletEvmMigrationError extends Enum { readonly isAccountNotEmpty: boolean; readonly isAccountIsNotMigrating: boolean; readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating'; } - /** @name SpRuntimeMultiSignature (347) */ + /** @name SpRuntimeMultiSignature (369) */ export interface SpRuntimeMultiSignature extends Enum { readonly isEd25519: boolean; readonly asEd25519: SpCoreEd25519Signature; @@ -2692,31 +2775,31 @@ readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa'; } - /** @name SpCoreEd25519Signature (348) */ + /** @name SpCoreEd25519Signature (370) */ export interface SpCoreEd25519Signature extends U8aFixed {} - /** @name SpCoreSr25519Signature (350) */ + /** @name SpCoreSr25519Signature (372) */ export interface SpCoreSr25519Signature extends U8aFixed {} - /** @name SpCoreEcdsaSignature (351) */ + /** @name SpCoreEcdsaSignature (373) */ export interface SpCoreEcdsaSignature extends U8aFixed {} - /** @name FrameSystemExtensionsCheckSpecVersion (354) */ + /** @name FrameSystemExtensionsCheckSpecVersion (376) */ export type FrameSystemExtensionsCheckSpecVersion = Null; - /** @name FrameSystemExtensionsCheckGenesis (355) */ + /** @name FrameSystemExtensionsCheckGenesis (377) */ export type FrameSystemExtensionsCheckGenesis = Null; - /** @name FrameSystemExtensionsCheckNonce (358) */ + /** @name FrameSystemExtensionsCheckNonce (380) */ export interface FrameSystemExtensionsCheckNonce extends Compact {} - /** @name FrameSystemExtensionsCheckWeight (359) */ + /** @name FrameSystemExtensionsCheckWeight (381) */ export type FrameSystemExtensionsCheckWeight = Null; - /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (360) */ + /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (382) */ export interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact {} - /** @name OpalRuntimeRuntime (361) */ + /** @name OpalRuntimeRuntime (383) */ export type OpalRuntimeRuntime = Null; } // declare module --- a/tests/src/interfaces/unique/definitions.ts +++ b/tests/src/interfaces/unique/definitions.ts @@ -26,6 +26,7 @@ const collectionParam = {name: 'collection', type: 'u32'}; const tokenParam = {name: 'tokenId', type: 'u32'}; +const propertyKeysParam = {name: 'propertyKeys', type: 'Vec'}; const crossAccountParam = (name = 'account') => ({name, type: CROSS_ACCOUNT_ID_TYPE}); const atParam = {name: 'at', type: 'Hash', isOptional: true}; @@ -53,6 +54,26 @@ topmostTokenOwner: fun('Get token owner, in case of nested token - find parent recursive', [collectionParam, tokenParam], `Option<${CROSS_ACCOUNT_ID_TYPE}>`), constMetadata: fun('Get token constant metadata', [collectionParam, tokenParam], 'Vec'), variableMetadata: fun('Get token variable metadata', [collectionParam, tokenParam], 'Vec'), + collectionProperties: fun( + 'Get collection properties', + [collectionParam, propertyKeysParam], + 'Vec', + ), + tokenProperties: fun( + 'Get token properties', + [collectionParam, tokenParam, propertyKeysParam], + 'Vec', + ), + propertyPermissions: fun( + 'Get property permissions', + [collectionParam, propertyKeysParam], + 'Vec', + ), + tokenData: fun( + 'Get token data', + [collectionParam, tokenParam, propertyKeysParam], + 'UpDataStructsTokenData', + ), tokenExists: fun('Check if token exists', [collectionParam, tokenParam], 'bool'), collectionById: fun('Get collection by specified id', [collectionParam], 'Option'), collectionStats: fun('Get collection stats', [], 'UpDataStructsCollectionStats'), --- a/tests/src/interfaces/unique/types.ts +++ b/tests/src/interfaces/unique/types.ts @@ -894,7 +894,9 @@ readonly isOnlyOwnerAllowedToNest: boolean; readonly isSourceCollectionIsNotAllowedToNest: boolean; readonly isCollectionFieldSizeExceeded: boolean; - readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'TokenVariableDataLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'NestingIsDisabled' | 'OnlyOwnerAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded'; + readonly isNoSpaceForProperty: boolean; + readonly isPropertyLimitReached: boolean; + readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'TokenVariableDataLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'NestingIsDisabled' | 'OnlyOwnerAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded' | 'NoSpaceForProperty' | 'PropertyLimitReached'; } /** @name PalletCommonEvent */ @@ -911,7 +913,17 @@ readonly asTransfer: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>; readonly isApproved: boolean; readonly asApproved: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>; - readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved'; + readonly isCollectionPropertySet: boolean; + readonly asCollectionPropertySet: ITuple<[u32, UpDataStructsProperty]>; + readonly isCollectionPropertyDeleted: boolean; + readonly asCollectionPropertyDeleted: ITuple<[u32, Bytes]>; + readonly isTokenPropertySet: boolean; + readonly asTokenPropertySet: ITuple<[u32, u32, UpDataStructsProperty]>; + readonly isTokenPropertyDeleted: boolean; + readonly asTokenPropertyDeleted: ITuple<[u32, u32, Bytes]>; + readonly isPropertyPermissionSet: boolean; + readonly asPropertyPermissionSet: ITuple<[u32, UpDataStructsPropertyKeyPermission]>; + readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved' | 'CollectionPropertySet' | 'CollectionPropertyDeleted' | 'TokenPropertySet' | 'TokenPropertyDeleted' | 'PropertyPermissionSet'; } /** @name PalletEthereumCall */ @@ -1074,7 +1086,8 @@ readonly isFungibleItemsHaveNoId: boolean; readonly isFungibleItemsDontHaveData: boolean; readonly isFungibleDisallowsNesting: boolean; - readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting'; + readonly isSettingPropertiesNotAllowed: boolean; + readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed'; } /** @name PalletInflationCall */ @@ -1105,7 +1118,8 @@ readonly isNotRefungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isWrongRefungiblePieces: boolean; readonly isRefungibleDisallowsNesting: boolean; - readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RefungibleDisallowsNesting'; + readonly isSettingPropertiesNotAllowed: boolean; + readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RefungibleDisallowsNesting' | 'SettingPropertiesNotAllowed'; } /** @name PalletRefungibleItemData */ @@ -1347,6 +1361,33 @@ readonly owner: PalletEvmAccountBasicCrossAccountIdRepr; readonly itemsData: Vec; } & Struct; + readonly isSetCollectionProperties: boolean; + readonly asSetCollectionProperties: { + readonly collectionId: u32; + readonly properties: Vec; + } & Struct; + readonly isDeleteCollectionProperties: boolean; + readonly asDeleteCollectionProperties: { + readonly collectionId: u32; + readonly propertyKeys: Vec; + } & Struct; + readonly isSetTokenProperties: boolean; + readonly asSetTokenProperties: { + readonly collectionId: u32; + readonly tokenId: u32; + readonly properties: Vec; + } & Struct; + readonly isDeleteTokenProperties: boolean; + readonly asDeleteTokenProperties: { + readonly collectionId: u32; + readonly tokenId: u32; + readonly propertyKeys: Vec; + } & Struct; + readonly isSetPropertyPermissions: boolean; + readonly asSetPropertyPermissions: { + readonly collectionId: u32; + readonly propertyPermissions: Vec; + } & Struct; readonly isCreateMultipleItemsEx: boolean; readonly asCreateMultipleItemsEx: { readonly collectionId: u32; @@ -1428,7 +1469,7 @@ readonly collectionId: u32; readonly newLimit: UpDataStructsCollectionLimits; } & Struct; - readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'SetPublicAccessMode' | 'SetMintPermission' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetVariableMetaData' | 'SetMetaUpdatePermissionFlag' | 'SetSchemaVersion' | 'SetOffchainSchema' | 'SetConstOnChainSchema' | 'SetVariableOnChainSchema' | 'SetCollectionLimits'; + readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'SetPublicAccessMode' | 'SetMintPermission' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetVariableMetaData' | 'SetMetaUpdatePermissionFlag' | 'SetSchemaVersion' | 'SetOffchainSchema' | 'SetConstOnChainSchema' | 'SetVariableOnChainSchema' | 'SetCollectionLimits'; } /** @name PalletUniqueError */ @@ -1591,8 +1632,11 @@ readonly type: 'Attempted' | 'Sent' | 'UnexpectedResponse' | 'ResponseReady' | 'Notified' | 'NotifyOverweight' | 'NotifyDispatchError' | 'NotifyDecodeFailed' | 'InvalidResponder' | 'InvalidResponderVersion' | 'ResponseTaken' | 'AssetsTrapped' | 'VersionChangeNotified' | 'SupportedVersionChanged' | 'NotifyTargetSendFail' | 'NotifyTargetMigrationFail'; } -/** @name PhantomTypeUpDataStructs */ -export interface PhantomTypeUpDataStructs extends Vec {} +/** @name PhantomTypeUpDataStructsRpcCollection */ +export interface PhantomTypeUpDataStructsRpcCollection extends Vec {} + +/** @name PhantomTypeUpDataStructsTokenData */ +export interface PhantomTypeUpDataStructsTokenData extends Vec {} /** @name PolkadotCorePrimitivesInboundDownwardMessage */ export interface PolkadotCorePrimitivesInboundDownwardMessage extends Struct { @@ -1839,6 +1883,8 @@ readonly variableOnChainSchema: Bytes; readonly constOnChainSchema: Bytes; readonly metaUpdatePermission: Option; + readonly tokenPropertyPermissions: Vec; + readonly properties: Vec; } /** @name UpDataStructsCreateFungibleData */ @@ -1874,12 +1920,14 @@ export interface UpDataStructsCreateNftData extends Struct { readonly constData: Bytes; readonly variableData: Bytes; + readonly properties: Vec; } /** @name UpDataStructsCreateNftExData */ export interface UpDataStructsCreateNftExData extends Struct { readonly constData: Bytes; readonly variableData: Bytes; + readonly properties: Vec; readonly owner: PalletEvmAccountBasicCrossAccountIdRepr; } @@ -1914,6 +1962,32 @@ readonly type: 'Disabled' | 'Owner' | 'OwnerRestricted'; } +/** @name UpDataStructsProperties */ +export interface UpDataStructsProperties extends Struct { + readonly map: BTreeMap; + readonly consumedSpace: u32; + readonly spaceLimit: u32; +} + +/** @name UpDataStructsProperty */ +export interface UpDataStructsProperty extends Struct { + readonly key: Bytes; + readonly value: Bytes; +} + +/** @name UpDataStructsPropertyKeyPermission */ +export interface UpDataStructsPropertyKeyPermission extends Struct { + readonly key: Bytes; + readonly permission: UpDataStructsPropertyPermission; +} + +/** @name UpDataStructsPropertyPermission */ +export interface UpDataStructsPropertyPermission extends Struct { + readonly mutable: bool; + readonly collectionAdmin: bool; + readonly tokenOwner: bool; +} + /** @name UpDataStructsRpcCollection */ export interface UpDataStructsRpcCollection extends Struct { readonly owner: AccountId32; @@ -1930,6 +2004,8 @@ readonly variableOnChainSchema: Bytes; readonly constOnChainSchema: Bytes; readonly metaUpdatePermission: UpDataStructsMetaUpdatePermission; + readonly tokenPropertyPermissions: Vec; + readonly properties: Vec; } /** @name UpDataStructsSchemaVersion */ @@ -1957,6 +2033,13 @@ readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed'; } +/** @name UpDataStructsTokenData */ +export interface UpDataStructsTokenData extends Struct { + readonly constData: Bytes; + readonly properties: Vec; + readonly owner: Option; +} + /** @name XcmDoubleEncoded */ export interface XcmDoubleEncoded extends Struct { readonly encoded: Bytes; --- a/tests/src/nesting/migration-check.test.ts +++ b/tests/src/nesting/migration-check.test.ts @@ -5,6 +5,8 @@ import {IKeyringPair} from '@polkadot/types/types'; import {strToUTF16} from '../util/util'; import waitNewBlocks from '../substrate/wait-new-blocks'; +// Used for polkadot-launch signalling +import find from 'find-process'; // todo skip describe('Migration testing for pallet-common', () => { @@ -54,13 +56,12 @@ let newVersion = oldVersion!; let connectionFailCounter = 0; - // Cooperate with polkadot-launch if it's running (assuming custom name change), and send a custom signal - const find = require('find-process'); - find('name', 'polkadot-launch', true).then(function (list: [any]) { - for (let proc of list) { + // Cooperate with polkadot-launch if it's running (assuming custom name change to 'polkadot-launch'), and send a custom signal + find('name', 'polkadot-launch', true).then((list) => { + for (const proc of list) { process.kill(proc.pid, 'SIGUSR1'); } - }) + }); // And wait for the parachain upgrade while (newVersion == oldVersion! && connectionFailCounter < 2) { --- a/tests/src/nesting/nest.test.ts +++ b/tests/src/nesting/nest.test.ts @@ -23,8 +23,10 @@ describe('Integration Test: Nesting', () => { before(async () => { - alice = privateKey('//Alice'); - bob = privateKey('//Bob'); + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + }); }); // ---------- Non-Fungible ---------- @@ -208,8 +210,10 @@ describe('Negative Test: Nesting', async() => { before(async () => { - alice = privateKey('//Alice'); - bob = privateKey('//Bob'); + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + }); }); // ---------- Non-Fungible ---------- --- /dev/null +++ b/tests/src/nesting/properties.test.ts @@ -0,0 +1,664 @@ +import {expect} from 'chai'; +import privateKey from '../substrate/privateKey'; +import usingApi, {executeTransaction} from '../substrate/substrate-api'; +import { + addCollectionAdminExpectSuccess, + createCollectionExpectSuccess, + createItemExpectSuccess, + getCreateCollectionResult, + transferExpectSuccess, +} from '../util/helpers'; +import {IKeyringPair} from '@polkadot/types/types'; + +let alice: IKeyringPair; +let bob: IKeyringPair; +let charlie: IKeyringPair; + +// ---------- COLLECTION PROPERTIES + +describe('Integration Test: Collection Properties', () => { + before(async () => { + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + }); + }); + + it('Reads properties from a collection', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + const properties = (await api.query.common.collectionProperties(collection)).toJSON(); + expect(properties.map).to.be.empty; + expect(properties.consumedSpace).to.equal(0); + }); + }); + + it('Sets properties for a collection', async () => { + await usingApi(async api => { + const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: 'NFT'})); + const {collectionId} = getCreateCollectionResult(events); + + // As owner + await expect(executeTransaction( + api, + bob, + api.tx.unique.setCollectionProperties(collectionId, [{key: 'electron', value: 'come bond'}]), + )).to.not.be.rejected; + + await addCollectionAdminExpectSuccess(bob, collectionId, alice.address); + + // As administrator + await expect(executeTransaction( + api, + alice, + api.tx.unique.setCollectionProperties(collectionId, [{key: 'black hole'}]), + )).to.not.be.rejected; + + const properties = (await api.rpc.unique.collectionProperties(collectionId, ['electron', 'black hole'])).toJSON(); + expect(properties).to.be.deep.equal([ + {key: `0x${Buffer.from('electron').toString('hex')}`, value: `0x${Buffer.from('come bond').toString('hex')}`}, + {key: `0x${Buffer.from('black hole').toString('hex')}`, value: `0x${Buffer.from('').toString('hex')}`}, + ]); + }); + }); + + it('Changes properties of a collection', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black hole'}]), + )).to.not.be.rejected; + + // Mutate the properties + await expect(executeTransaction( + api, + alice, + api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'bonded'}, {key: 'black hole', value: 'LIGO'}]), + )).to.not.be.rejected; + + const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black hole'])).toJSON(); + expect(properties).to.be.deep.equal([ + {key: `0x${Buffer.from('electron').toString('hex')}`, value: `0x${Buffer.from('bonded').toString('hex')}`}, + {key: `0x${Buffer.from('black hole').toString('hex')}`, value: `0x${Buffer.from('LIGO').toString('hex')}`}, + ]); + }); + }); + + it('Deletes properties of a collection', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black hole', value: 'LIGO'}]), + )).to.not.be.rejected; + + await expect(executeTransaction( + api, + alice, + api.tx.unique.deleteCollectionProperties(collection, ['electron']), + )).to.not.be.rejected; + + const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black hole'])).toJSON(); + expect(properties).to.be.deep.equal([ + {key: `0x${Buffer.from('black hole').toString('hex')}`, value: `0x${Buffer.from('LIGO').toString('hex')}`}, + ]); + }); + }); +}); + +describe('Negative Integration Test: Collection Properties', () => { + before(async () => { + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + }); + }); + + it('Fails to set properties in a collection if not its onwer/administrator', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + + await expect(executeTransaction( + api, + bob, + api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black hole', value: 'LIGO'}]), + )).to.be.rejectedWith(/common\.NoPermission/); + + const properties = (await api.query.common.collectionProperties(collection)).toJSON(); + expect(properties.map).to.be.empty; + expect(properties.consumedSpace).to.equal(0); + }); + }); + + it('Fails to set properties that exceed the limits', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + const spaceLimit = (await api.query.common.collectionProperties(collection)).toJSON().spaceLimit as number; + + // Mute the general tx parsing error, too many bytes to process + { + console.error = () => {}; + await expect(executeTransaction( + api, + alice, + api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))}]), + )).to.be.rejected; + } + + let properties = (await api.rpc.unique.collectionProperties(collection, ['electron'])).toJSON(); + expect(properties).to.be.empty; + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setCollectionProperties(collection, [ + {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/); + + properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black hole'])).toJSON(); + expect(properties).to.be.empty; + }); + }); + + it('Fails to set more properties than it is allowed', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + + const propertiesToBeSet = []; + for (let i = 0; i < 65; i++) { + propertiesToBeSet.push({ + key: 'electron ' + i, + value: Math.random() > 0.5 ? 'high' : 'low', + }); + } + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setCollectionProperties(collection, propertiesToBeSet), + )).to.be.rejectedWith(/common\.PropertyLimitReached/); + + const properties = (await api.query.common.collectionProperties(collection)).toJSON(); + expect(properties.map).to.be.empty; + expect(properties.consumedSpace).to.equal(0); + }); + }); +}); + +// ---------- ACCESS RIGHTS + +describe('Integration Test: Access Rights to Token Properties', () => { + before(async () => { + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + }); + }); + + it('Reads access rights to properties of a collection', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON(); + expect(propertyRights).to.be.empty; + }); + }); + + it('Sets access rights to properties of a collection', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true}}]), + )).to.not.be.rejected; + + await addCollectionAdminExpectSuccess(alice, collection, bob.address); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]), + )).to.not.be.rejected; + + const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery', 'mindgame'])).toJSON(); + expect(propertyRights).to.be.deep.equal([ + {key: `0x${Buffer.from('skullduggery').toString('hex')}`, permission: {'mutable': true, 'collectionAdmin': false, 'tokenOwner': false}}, + {key: `0x${Buffer.from('mindgame').toString('hex')}`, permission: {'mutable': false, 'collectionAdmin': true, 'tokenOwner': false}}, + ]); + }); + }); + + it('Changes access rights to properties of a collection', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]), + )).to.not.be.rejected; + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), + )).to.not.be.rejected; + + const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toJSON(); + expect(propertyRights).to.be.deep.equal([ + {key: `0x${Buffer.from('skullduggery').toString('hex')}`, permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}}, + ]); + }); + }); +}); + +describe('Negative Integration Test: Access Rights to Token Properties', () => { + before(async () => { + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + }); + }); + + it('Prevents from setting access rights to properties of a collection if not an onwer/admin', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + + await expect(executeTransaction( + api, + bob, + api.tx.unique.setPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]), + )).to.be.rejectedWith(/common\.NoPermission/); + + const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toJSON(); + expect(propertyRights).to.be.empty; + }); + }); + + it('Prevents from adding too many possible properties', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + + const constitution = []; + for (let i = 0; i < 65; i++) { + constitution.push({ + key: 'property ' + i, + permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {}, + }); + } + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, constitution), + )).to.be.rejectedWith(/common\.PropertyLimitReached/); + + const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON(); + expect(propertyRights).to.be.empty; + }); + }); + + it('Prevents access rights to be modified if constant', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), + )).to.not.be.rejected; + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'skullduggery', permission: {}}]), + )).to.be.rejectedWith(/common\.NoPermission/); + + const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toJSON(); + expect(propertyRights).to.deep.equal([ + {key: `0x${Buffer.from('skullduggery').toString('hex')}`, permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}}, + ]); + }); + }); +}); + +// ---------- TOKEN PROPERTIES + +describe('Integration Test: Token Properties', () => { + let collection: number; + let token: number; + let permissions: {permission: any, signers: IKeyringPair[]}[]; + + before(async () => { + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + charlie = privateKey('//Charlie'); + + permissions = [ + {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]}, + {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]}, + {permission: {mutable: true, tokenOwner: true}, signers: [charlie]}, + {permission: {mutable: false, tokenOwner: true}, signers: [charlie]}, + {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]}, + {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]}, + ]; + }); + }); + + beforeEach(async () => { + collection = await createCollectionExpectSuccess(); + token = await createItemExpectSuccess(alice, collection, 'NFT'); + await addCollectionAdminExpectSuccess(alice, collection, bob.address); + await transferExpectSuccess(collection, token, alice, charlie); + }); + + it('Reads properties of a token', async () => { + await usingApi(async api => { + const collection = await createCollectionExpectSuccess(); + const token = await createItemExpectSuccess(alice, collection, 'NFT'); + + const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON(); + expect(properties.map).to.be.empty; + expect(properties.consumedSpace).to.be.equal(0); + + const tokenData = (await api.rpc.unique.tokenData(collection, token, ['anything'])).toJSON().properties; + expect(tokenData).to.be.empty; + }); + }); + + it('Assigns properties to a token according to permissions', async () => { + await usingApi(async api => { + const propertyKeys: string[] = []; + let i = 0; + for (const permission of permissions) { + for (const signer of permission.signers) { + const key = i + ' ' + signer.address; + propertyKeys.push(key); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: key, permission: permission.permission}]), + ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected; + + await expect(executeTransaction( + api, + signer, + api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), + ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected; + } + + i++; + } + + const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toJSON() as any[]; + const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toJSON().properties as any[]; + for (let i = 0; i < properties.length; i++) { + expect(properties[i].value).to.be.equal(`0x${Buffer.from('Serotonin increase').toString('hex')}`); + expect(tokensData[i].value).to.be.equal(`0x${Buffer.from('Serotonin increase').toString('hex')}`); + } + }); + }); + + it('Changes properties of a token according to permissions', async () => { + await usingApi(async api => { + const propertyKeys: string[] = []; + let i = 0; + for (const permission of permissions) { + if (!permission.permission.mutable) continue; + + for (const signer of permission.signers) { + const key = i + ' ' + signer.address; + propertyKeys.push(key); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: key, permission: permission.permission}]), + ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected; + + await expect(executeTransaction( + api, + signer, + api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), + ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected; + + await expect(executeTransaction( + api, + signer, + api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin stable'}]), + ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected; + } + + i++; + } + + const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toJSON() as any[]; + const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toJSON().properties as any[]; + for (let i = 0; i < properties.length; i++) { + expect(properties[i].value).to.be.equal(`0x${Buffer.from('Serotonin stable').toString('hex')}`); + expect(tokensData[i].value).to.be.equal(`0x${Buffer.from('Serotonin stable').toString('hex')}`); + } + }); + }); + + it('Deletes properties of a token according to permissions', async () => { + await usingApi(async api => { + const propertyKeys: string[] = []; + let i = 0; + + for (const permission of permissions) { + if (!permission.permission.mutable) continue; + + for (const signer of permission.signers) { + const key = i + ' ' + signer.address; + propertyKeys.push(key); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: key, permission: permission.permission}]), + ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected; + + await expect(executeTransaction( + api, + signer, + api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), + ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected; + + await expect(executeTransaction( + api, + signer, + api.tx.unique.deleteTokenProperties(collection, token, [key]), + ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected; + } + + i++; + } + + const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toJSON() as any[]; + expect(properties).to.be.empty; + const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toJSON().properties as any[]; + expect(tokensData).to.be.empty; + expect((await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace).to.be.equal(0); + }); + }); +}); + +describe('Negative Integration Test: Token Properties', () => { + let collection: number; + let token: number; + let originalSpace: number; + let constitution: {permission: any, signers: IKeyringPair[], sinner: IKeyringPair}[]; + + before(async () => { + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + charlie = privateKey('//Charlie'); + const dave = privateKey('//Dave'); + + constitution = [ + {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob], sinner: charlie}, + {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob], sinner: charlie}, + {permission: {mutable: true, tokenOwner: true}, signers: [charlie], sinner: alice}, + {permission: {mutable: false, tokenOwner: true}, signers: [charlie], sinner: alice}, + {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave}, + {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave}, + ]; + }); + }); + + beforeEach(async () => { + collection = await createCollectionExpectSuccess(); + token = await createItemExpectSuccess(alice, collection, 'NFT'); + await addCollectionAdminExpectSuccess(alice, collection, bob.address); + await transferExpectSuccess(collection, token, alice, charlie); + + await usingApi(async api => { + let i = 0; + for (const passage of constitution) { + const signer = passage.signers[0]; + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: i, permission: passage.permission}]), + ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected; + + await expect(executeTransaction( + api, + signer, + api.tx.unique.setTokenProperties(collection, token, [{key: i, value: 'Serotonin increase'}]), + ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected; + + i++; + } + + originalSpace = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace as number; + }); + }); + + it('Forbids changing/deleting properties of a token if the user is outside of permissions', async () => { + await usingApi(async api => { + let i = -1; + for (const forbiddance of constitution) { + i++; + if (!forbiddance.permission.mutable) continue; + + await expect(executeTransaction( + api, + forbiddance.sinner, + api.tx.unique.setTokenProperties(collection, token, [{key: i, value: 'Serotonin down'}]), + ), `on failing to change property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/); + + await expect(executeTransaction( + api, + forbiddance.sinner, + api.tx.unique.deleteTokenProperties(collection, token, [forbiddance.permission]), + ), `on failing to delete property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/); + } + + // todo RPC? + const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON(); + expect(properties.consumedSpace).to.be.equal(originalSpace); + }); + }); + + it('Forbids changing/deleting properties of a token if the property is permanent (constant)', async () => { + await usingApi(async api => { + let i = -1; + for (const permission of constitution) { + i++; + if (permission.permission.mutable) continue; + + await expect(executeTransaction( + api, + permission.signers[0], + api.tx.unique.setTokenProperties(collection, token, [{key: i, value: 'Serotonin down'}]), + ), `on failing to change property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/); + + await expect(executeTransaction( + api, + permission.signers[0], + api.tx.unique.deleteTokenProperties(collection, token, [i.toString()]), + ), `on failing to delete property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/); + } + + // todo RPC? + const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON(); + expect(properties.consumedSpace).to.be.equal(originalSpace); + }); + }); + + it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission', async () => { + await usingApi(async api => { + await expect(executeTransaction( + api, + alice, + api.tx.unique.setTokenProperties(collection, token, [{key: 'non-existent', value: 'I exist!'}]), + ), 'on failing to add a previously non-existent property').to.be.rejectedWith(/common\.NoPermission/); + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [{key: 'now-existent', permission: {}}]), + ), 'on setting a new non-permitted property').to.not.be.rejected; + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setTokenProperties(collection, token, [{key: 'now-existent', value: 'I exist!'}]), + ), 'on failing to add a property forbidden by the \'None\' permission').to.be.rejectedWith(/common\.NoPermission/); + + expect((await api.rpc.unique.tokenProperties(collection, token, ['non-existent', 'now-existent'])).toJSON()).to.be.empty; + const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON(); + expect(properties.consumedSpace).to.be.equal(originalSpace); + }); + }); + + it('Forbids adding too many properties to a token', async () => { + await usingApi(async api => { + await expect(executeTransaction( + api, + alice, + api.tx.unique.setPropertyPermissions(collection, [ + {key: 'a holy book', permission: {collectionAdmin: true, tokenOwner: true}}, + {key: 'young years', permission: {collectionAdmin: true, tokenOwner: true}}, + ]), + ), 'on setting a new non-permitted property').to.not.be.rejected; + + // Mute the general tx parsing error + { + console.error = () => {}; + await expect(executeTransaction( + api, + alice, + api.tx.unique.setCollectionProperties(collection, [{key: 'a holy book', value: 'word '.repeat(6554)}]), + )).to.be.rejected; + } + + await expect(executeTransaction( + api, + alice, + api.tx.unique.setTokenProperties(collection, token, [ + {key: 'a holy book', value: 'word '.repeat(3277)}, + {key: 'young years', value: 'neverending'.repeat(1490)}, + ]), + )).to.be.rejectedWith(/common\.NoSpaceForProperty/); + + expect((await api.rpc.unique.tokenProperties(collection, token, ['a holy book', 'young years'])).toJSON()).to.be.empty; + const propertiesMap = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON(); + expect(propertiesMap.consumedSpace).to.be.equal(originalSpace); + }); + }); +}); \ No newline at end of file --- a/tests/src/nesting/unnest.test.ts +++ b/tests/src/nesting/unnest.test.ts @@ -19,8 +19,10 @@ describe('Integration Test: Unnesting', () => { before(async () => { - alice = privateKey('//Alice'); - bob = privateKey('//Bob'); + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + }); }); it('Allows the owner to successfully unnest a token', async () => { @@ -57,8 +59,10 @@ describe('Negative Test: Unnesting', () => { before(async () => { - alice = privateKey('//Alice'); - bob = privateKey('//Bob'); + await usingApi(async api => { + alice = privateKey('//Alice'); + bob = privateKey('//Bob'); + }); }); it('Disallows a non-owner to unnest/burn a token', async () => { --- a/tests/src/substrate/privateKey.ts +++ b/tests/src/substrate/privateKey.ts @@ -17,6 +17,8 @@ import {Keyring} from '@polkadot/api'; import {IKeyringPair} from '@polkadot/types/types'; +// WARNING: the WASM interface must be initialized before this function is called. +// Use either `usingApi`, or `cryptoWaitReady` for consistency. export default function privateKey(account: string): IKeyringPair { const keyring = new Keyring({type: 'sr25519'}); --- a/tests/src/util/helpers.ts +++ b/tests/src/util/helpers.ts @@ -206,6 +206,37 @@ return result; } +export function getCreateItemsResult(events: EventRecord[]): CreateItemResult[] { + let success = false; + let collectionId = 0; + let itemId = 0; + let recipient; + + const results : CreateItemResult[] = []; + + events.forEach(({event: {data, method, section}}) => { + // console.log(` ${phase}: ${section}.${method}:: ${data}`); + if (method == 'ExtrinsicSuccess') { + success = true; + } else if ((section == 'common') && (method == 'ItemCreated')) { + collectionId = parseInt(data[0].toString(), 10); + itemId = parseInt(data[1].toString(), 10); + recipient = normalizeAccountId(data[2].toJSON() as any); + + const itemRes: CreateItemResult = { + success, + collectionId, + itemId, + recipient, + }; + + results.push(itemRes); + } + }); + + return results; +} + export function getCreateItemResult(events: EventRecord[]): CreateItemResult { let success = false; let collectionId = 0; @@ -261,12 +292,26 @@ type CollectionMode = Nft | Fungible | ReFungible; +export type Property = { + key: any, + value: any, +}; + +type PropertyPermission = { + key: any, + mutable: boolean; + collectionAdmin: boolean; + tokenOwner: boolean; +} + export type CreateCollectionParams = { mode: CollectionMode, name: string, description: string, tokenPrefix: string, schemaVersion: string, + properties?: Array, + propPerm?: Array }; const defaultCreateCollectionParams: CreateCollectionParams = { @@ -331,6 +376,86 @@ return collectionId; } +export async function createCollectionWithPropsExpectSuccess(params: Partial = {}): Promise { + const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params}; + + let collectionId = 0; + await usingApi(async (api) => { + // Get number of collections before the transaction + const collectionCountBefore = await getCreatedCollectionCount(api); + + // Run the CreateCollection transaction + const alicePrivateKey = privateKey('//Alice'); + + let modeprm = {}; + if (mode.type === 'NFT') { + modeprm = {nft: null}; + } else if (mode.type === 'Fungible') { + modeprm = {fungible: mode.decimalPoints}; + } else if (mode.type === 'ReFungible') { + modeprm = {refungible: null}; + } + + const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any, properties: params.properties, tokenPropertyPermissions: params.propPerm}); + const events = await submitTransactionAsync(alicePrivateKey, tx); + const result = getCreateCollectionResult(events); + + // Get number of collections after the transaction + const collectionCountAfter = await getCreatedCollectionCount(api); + + // Get the collection + const collection = await queryCollectionExpectSuccess(api, result.collectionId); + + // What to expect + // tslint:disable-next-line:no-unused-expression + expect(result.success).to.be.true; + expect(result.collectionId).to.be.equal(collectionCountAfter); + // tslint:disable-next-line:no-unused-expression + expect(collection).to.be.not.null; + expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.'); + expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicesPublicKey)); + expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name); + expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description); + expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix); + + + collectionId = result.collectionId; + }); + + return collectionId; +} + +export async function createCollectionWithPropsExpectFailure(params: Partial = {}) { + const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params}; + + const collectionId = 0; + await usingApi(async (api) => { + // Get number of collections before the transaction + const collectionCountBefore = await getCreatedCollectionCount(api); + + // Run the CreateCollection transaction + const alicePrivateKey = privateKey('//Alice'); + + let modeprm = {}; + if (mode.type === 'NFT') { + modeprm = {nft: null}; + } else if (mode.type === 'Fungible') { + modeprm = {fungible: mode.decimalPoints}; + } else if (mode.type === 'ReFungible') { + modeprm = {refungible: null}; + } + + const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any, properties: params.properties, tokenPropertyPermissions: params.propPerm}); + await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected; + + + // Get number of collections after the transaction + const collectionCountAfter = await getCreatedCollectionCount(api); + + expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.'); + }); +} + export async function createCollectionExpectFailure(params: Partial = {}) { const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params}; --- a/tests/yarn.lock +++ b/tests/yarn.lock @@ -3,11 +3,12 @@ "@ampproject/remapping@^2.1.0": - version "2.1.2" - resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.1.2.tgz#4edca94973ded9630d20101cd8559cedb8d8bd34" - integrity sha512-hoyByceqwKirw7w3Z7gnIIZC3Wx3J484Y3L/cMpXFbr7d9ZQj2mODrirNzcJa+SM3UlpWXYvKV4RlRpFXlWgXg== + version "2.2.0" + resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.0.tgz#56c133824780de3174aed5ab6834f3026790154d" + integrity sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w== dependencies: - "@jridgewell/trace-mapping" "^0.3.0" + "@jridgewell/gen-mapping" "^0.1.0" + "@jridgewell/trace-mapping" "^0.3.9" "@babel/cli@^7.17.10": version "7.17.10" @@ -32,17 +33,12 @@ dependencies: "@babel/highlight" "^7.16.7" -"@babel/compat-data@^7.13.11", "@babel/compat-data@^7.16.4", "@babel/compat-data@^7.17.0": - version "7.17.0" - resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.17.0.tgz#86850b8597ea6962089770952075dcaabb8dba34" - integrity sha512-392byTlpGWXMv4FbyWw3sAZ/FrW/DrwqLGXpy0mbyNe9Taqv1mg9yON5/o0cnr8XYCkFTZbC1eV+c+LAROgrng== - -"@babel/compat-data@^7.17.10": +"@babel/compat-data@^7.13.11", "@babel/compat-data@^7.17.0", "@babel/compat-data@^7.17.10": version "7.17.10" resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.17.10.tgz#711dc726a492dfc8be8220028b1b92482362baab" integrity sha512-GZt/TCsG70Ms19gfZO1tM4CVnXsPgEPBCpJu+Qz3L0LUDsY5nZqFZglIoPC1kIYOtNBZlrnFT+klg12vFGZXrw== -"@babel/core@^7.11.6", "@babel/core@^7.17.10": +"@babel/core@^7.11.6", "@babel/core@^7.12.3", "@babel/core@^7.17.10": version "7.17.10" resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.17.10.tgz#74ef0fbf56b7dfc3f198fc2d927f4f03e12f4b05" integrity sha512-liKoppandF3ZcBnIYFjfSDHZLKdLHGJRkoWtG8zQyGJBQfIYobpnVGI5+pLBNtS6psFLDzyq8+h5HiVljW9PNA== @@ -63,44 +59,14 @@ json5 "^2.2.1" semver "^6.3.0" -"@babel/core@^7.12.3": - version "7.17.5" - resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.17.5.tgz#6cd2e836058c28f06a4ca8ee7ed955bbf37c8225" - integrity sha512-/BBMw4EvjmyquN5O+t5eh0+YqB3XXJkYD2cjKpYtWOfFy4lQ4UozNSmxAcWT8r2XtZs0ewG+zrfsqeR15i1ajA== - dependencies: - "@ampproject/remapping" "^2.1.0" - "@babel/code-frame" "^7.16.7" - "@babel/generator" "^7.17.3" - "@babel/helper-compilation-targets" "^7.16.7" - "@babel/helper-module-transforms" "^7.16.7" - "@babel/helpers" "^7.17.2" - "@babel/parser" "^7.17.3" - "@babel/template" "^7.16.7" - "@babel/traverse" "^7.17.3" - "@babel/types" "^7.17.0" - convert-source-map "^1.7.0" - debug "^4.1.0" - gensync "^1.0.0-beta.2" - json5 "^2.1.2" - semver "^6.3.0" - -"@babel/generator@^7.17.10": +"@babel/generator@^7.17.10", "@babel/generator@^7.7.2": version "7.17.10" resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.17.10.tgz#c281fa35b0c349bbe9d02916f4ae08fc85ed7189" integrity sha512-46MJZZo9y3o4kmhBVc7zW7i8dtR1oIK/sdO5NcfcZRhTGYi+KKJRtHNgsU6c4VUcJmUNV/LQdebD/9Dlv4K+Tg== dependencies: "@babel/types" "^7.17.10" "@jridgewell/gen-mapping" "^0.1.0" - jsesc "^2.5.1" - -"@babel/generator@^7.17.3", "@babel/generator@^7.7.2": - version "7.17.3" - resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.17.3.tgz#a2c30b0c4f89858cb87050c3ffdfd36bdf443200" - integrity sha512-+R6Dctil/MgUsZsZAkYgK+ADNSZzJRRy0TvY65T71z/CR854xHQ1EweBYXdfT+HNeN7w0cSJJEzgxZMv40pxsg== - dependencies: - "@babel/types" "^7.17.0" jsesc "^2.5.1" - source-map "^0.5.0" "@babel/helper-annotate-as-pure@^7.16.0", "@babel/helper-annotate-as-pure@^7.16.7": version "7.16.7" @@ -117,17 +83,7 @@ "@babel/helper-explode-assignable-expression" "^7.16.7" "@babel/types" "^7.16.7" -"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.16.7": - version "7.16.7" - resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.16.7.tgz#06e66c5f299601e6c7da350049315e83209d551b" - integrity sha512-mGojBwIWcwGD6rfqgRXVlVYmPAv7eOpIemUG3dGnDdCY4Pae70ROij3XmfrH6Fa1h1aiDylpglbZyktfzyo/hA== - dependencies: - "@babel/compat-data" "^7.16.4" - "@babel/helper-validator-option" "^7.16.7" - browserslist "^4.17.5" - semver "^6.3.0" - -"@babel/helper-compilation-targets@^7.17.10": +"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.16.7", "@babel/helper-compilation-targets@^7.17.10": version "7.17.10" resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.17.10.tgz#09c63106d47af93cf31803db6bc49fef354e2ebe" integrity sha512-gh3RxjWbauw/dFiU/7whjd0qN9K6nPJMqe6+Er7rOavFh0CQUSwhAE3IcTho2rywPJFxej6TUUHDkWcYI6gGqQ== @@ -137,20 +93,7 @@ browserslist "^4.20.2" semver "^6.3.0" -"@babel/helper-create-class-features-plugin@^7.16.10", "@babel/helper-create-class-features-plugin@^7.16.7": - version "7.17.1" - resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.17.1.tgz#9699f14a88833a7e055ce57dcd3ffdcd25186b21" - integrity sha512-JBdSr/LtyYIno/pNnJ75lBcqc3Z1XXujzPanHqjvvrhOA+DTceTFuJi8XjmWTZh4r3fsdfqaCMN0iZemdkxZHQ== - dependencies: - "@babel/helper-annotate-as-pure" "^7.16.7" - "@babel/helper-environment-visitor" "^7.16.7" - "@babel/helper-function-name" "^7.16.7" - "@babel/helper-member-expression-to-functions" "^7.16.7" - "@babel/helper-optimise-call-expression" "^7.16.7" - "@babel/helper-replace-supers" "^7.16.7" - "@babel/helper-split-export-declaration" "^7.16.7" - -"@babel/helper-create-class-features-plugin@^7.17.6": +"@babel/helper-create-class-features-plugin@^7.16.10", "@babel/helper-create-class-features-plugin@^7.16.7", "@babel/helper-create-class-features-plugin@^7.17.6": version "7.17.9" resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.17.9.tgz#71835d7fb9f38bd9f1378e40a4c0902fdc2ea49d" integrity sha512-kUjip3gruz6AJKOq5i3nC6CoCEEF/oHH3cp6tOZhB+IyyyPyW0g1Gfsxn3mkk6S08pIA2y8GQh609v9G/5sHVQ== @@ -196,19 +139,10 @@ version "7.16.7" resolved "https://registry.yarnpkg.com/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.16.7.tgz#12a6d8522fdd834f194e868af6354e8650242b7a" integrity sha512-KyUenhWMC8VrxzkGP0Jizjo4/Zx+1nNZhgocs+gLzyZyB8SHidhoq9KK/8Ato4anhwsivfkBLftky7gvzbZMtQ== - dependencies: - "@babel/types" "^7.16.7" - -"@babel/helper-function-name@^7.16.7": - version "7.16.7" - resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.16.7.tgz#f1ec51551fb1c8956bc8dd95f38523b6cf375f8f" - integrity sha512-QfDfEnIUyyBSR3HtrtGECuZ6DAyCkYFp7GHl75vFtTnn6pjKeK0T1DB5lLkFvBea8MdaiUABx3osbgLyInoejA== dependencies: - "@babel/helper-get-function-arity" "^7.16.7" - "@babel/template" "^7.16.7" "@babel/types" "^7.16.7" -"@babel/helper-function-name@^7.17.9": +"@babel/helper-function-name@^7.16.7", "@babel/helper-function-name@^7.17.9": version "7.17.9" resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.17.9.tgz#136fcd54bc1da82fcb47565cf16fd8e444b1ff12" integrity sha512-7cRisGlVtiVqZ0MW0/yFB4atgpGLWEHUVYnb448hZK4x+vih0YO5UoS11XIYtZYqHd0dIPMdUSv8q5K4LdMnIg== @@ -216,13 +150,6 @@ "@babel/template" "^7.16.7" "@babel/types" "^7.17.0" -"@babel/helper-get-function-arity@^7.16.7": - version "7.16.7" - resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.16.7.tgz#ea08ac753117a669f1508ba06ebcc49156387419" - integrity sha512-flc+RLSOBXzNzVhcLu6ujeHUrD6tANAOU5ojrRx/as+tbzf8+stUCj7+IfRRoAbEZqj/ahXEMsjhOhgeZsrnTw== - dependencies: - "@babel/types" "^7.16.7" - "@babel/helper-hoist-variables@^7.16.7": version "7.16.7" resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.16.7.tgz#86bcb19a77a509c7b77d0e22323ef588fa58c246" @@ -230,14 +157,7 @@ dependencies: "@babel/types" "^7.16.7" -"@babel/helper-member-expression-to-functions@^7.16.7": - version "7.16.7" - resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.16.7.tgz#42b9ca4b2b200123c3b7e726b0ae5153924905b0" - integrity sha512-VtJ/65tYiU/6AbMTDwyoXGPKHgTsfRarivm+YbB5uAzKUyuPjgZSgAFeG87FCigc7KNHu2Pegh1XIT3lXjvz3Q== - dependencies: - "@babel/types" "^7.16.7" - -"@babel/helper-member-expression-to-functions@^7.17.7": +"@babel/helper-member-expression-to-functions@^7.16.7", "@babel/helper-member-expression-to-functions@^7.17.7": version "7.17.7" resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.17.7.tgz#a34013b57d8542a8c4ff8ba3f747c02452a4d8c4" integrity sha512-thxXgnQ8qQ11W2wVUObIqDL4p148VMxkt5T/qpN5k2fboRyzFGFmKsTGViquyM5QHKUy48OZoca8kw4ajaDPyw== @@ -251,21 +171,7 @@ dependencies: "@babel/types" "^7.16.7" -"@babel/helper-module-transforms@^7.16.7": - version "7.16.7" - resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.16.7.tgz#7665faeb721a01ca5327ddc6bba15a5cb34b6a41" - integrity sha512-gaqtLDxJEFCeQbYp9aLAefjhkKdjKcdh6DB7jniIGU3Pz52WAmP268zK0VgPz9hUNkMSYeH976K2/Y6yPadpng== - dependencies: - "@babel/helper-environment-visitor" "^7.16.7" - "@babel/helper-module-imports" "^7.16.7" - "@babel/helper-simple-access" "^7.16.7" - "@babel/helper-split-export-declaration" "^7.16.7" - "@babel/helper-validator-identifier" "^7.16.7" - "@babel/template" "^7.16.7" - "@babel/traverse" "^7.16.7" - "@babel/types" "^7.16.7" - -"@babel/helper-module-transforms@^7.17.7": +"@babel/helper-module-transforms@^7.16.7", "@babel/helper-module-transforms@^7.17.7": version "7.17.7" resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.17.7.tgz#3943c7f777139e7954a5355c815263741a9c1cbd" integrity sha512-VmZD99F3gNTYB7fJRDTi+u6l/zxY0BE6OIxPSU7a50s6ZUQkHwSDmV92FfM+oCG0pZRVojGYhkR8I0OGeCVREw== @@ -309,13 +215,6 @@ "@babel/helper-member-expression-to-functions" "^7.16.7" "@babel/helper-optimise-call-expression" "^7.16.7" "@babel/traverse" "^7.16.7" - "@babel/types" "^7.16.7" - -"@babel/helper-simple-access@^7.16.7": - version "7.16.7" - resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.16.7.tgz#d656654b9ea08dbb9659b69d61063ccd343ff0f7" - integrity sha512-ZIzHVyoeLMvXMN/vok/a4LWRy8G2v205mNP0XOuf9XRLyX5/u9CnVulUtDgUTama3lT+bf/UqucuZjqiGuTS1g== - dependencies: "@babel/types" "^7.16.7" "@babel/helper-simple-access@^7.17.7": @@ -359,15 +258,6 @@ "@babel/traverse" "^7.16.8" "@babel/types" "^7.16.8" -"@babel/helpers@^7.17.2": - version "7.17.2" - resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.17.2.tgz#23f0a0746c8e287773ccd27c14be428891f63417" - integrity sha512-0Qu7RLR1dILozr/6M0xgj+DFPmi6Bnulgm9M8BVa9ZCWxDqlSnqt3cf8IDPB5m45sVXUZ0kuQAgUrdSFFH79fQ== - dependencies: - "@babel/template" "^7.16.7" - "@babel/traverse" "^7.17.0" - "@babel/types" "^7.17.0" - "@babel/helpers@^7.17.9": version "7.17.9" resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.17.9.tgz#b2af120821bfbe44f9907b1826e168e819375a1a" @@ -378,20 +268,15 @@ "@babel/types" "^7.17.0" "@babel/highlight@^7.16.7": - version "7.16.10" - resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.16.10.tgz#744f2eb81579d6eea753c227b0f570ad785aba88" - integrity sha512-5FnTQLSLswEj6IkgVw5KusNUUFY9ZGqe/TRFnP/BKYHYgfh7tc+C7mwiy95/yNP7Dh9x580Vv8r7u7ZfTBFxdw== + version "7.17.9" + resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.17.9.tgz#61b2ee7f32ea0454612def4fccdae0de232b73e3" + integrity sha512-J9PfEKCbFIv2X5bjTMiZu6Vf341N05QIY+d6FvVKynkG1S7G0j3I0QoRtWIrXhZ+/Nlb5Q0MzqL7TokEJ5BNHg== dependencies: "@babel/helper-validator-identifier" "^7.16.7" chalk "^2.0.0" js-tokens "^4.0.0" -"@babel/parser@^7.0.0", "@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.16.7", "@babel/parser@^7.17.3": - version "7.17.3" - resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.17.3.tgz#b07702b982990bf6fdc1da5049a23fece4c5c3d0" - integrity sha512-7yJPvPV+ESz2IUTPbOL+YkIGyCqOyNIzdguKQuJGnH7bg1WTIifuM21YqokFt/THWh1AkCRn9IgoykTRCBVpzA== - -"@babel/parser@^7.17.10": +"@babel/parser@^7.0.0", "@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.16.7", "@babel/parser@^7.17.10": version "7.17.10" resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.17.10.tgz#873b16db82a8909e0fbd7f115772f4b739f6ce78" integrity sha512-n2Q6i+fnJqzOaq2VkdXxy2TCPCWQZHiCo0XqmrCvDWcZQKRyZzYi4Z0yxlBuN0w+r2ZHmre+Q087DSrw3pbJDQ== @@ -660,9 +545,9 @@ "@babel/helper-plugin-utils" "^7.14.5" "@babel/plugin-syntax-typescript@^7.16.7", "@babel/plugin-syntax-typescript@^7.7.2": - version "7.16.7" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.16.7.tgz#39c9b55ee153151990fb038651d58d3fd03f98f8" - integrity sha512-YhUIJHHGkqPgEcMYkPCKTyGUdoGKWtopIycQyjJH8OjvRgOYsXsaKehLVPScKJWAULPxMa4N1vCe6szREFlZ7A== + version "7.17.10" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.17.10.tgz#80031e6042cad6a95ed753f672ebd23c30933195" + integrity sha512-xJefea1DWXW09pW4Tm9bjwVlPDyYA2it3fWlmEjpYz6alPvTUjL0EOzNzI/FEOyI3r4/J7uVH5UqKgl1TQ5hqQ== dependencies: "@babel/helper-plugin-utils" "^7.16.7" @@ -1093,20 +978,13 @@ pirates "^4.0.5" source-map-support "^0.5.16" -"@babel/runtime@^7.17.9": +"@babel/runtime@^7.17.9", "@babel/runtime@^7.8.4": version "7.17.9" resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.17.9.tgz#d19fbf802d01a8cb6cf053a64e472d42c434ba72" integrity sha512-lSiBBvodq29uShpWGNbgFdKYNiFDo5/HIYsaCEY9ff4sb10x9jizo2+pRrSyF4jKZCXqgzuqBOQKbUm90gQwJg== dependencies: regenerator-runtime "^0.13.4" -"@babel/runtime@^7.8.4": - version "7.17.2" - resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.17.2.tgz#66f68591605e59da47523c631416b18508779941" - integrity sha512-hzeyJyMA1YGdJTuWU0e/j4wKXrU4OMFvY2MSlaI9B7VQb0r5cxTE3EAIS2Q7Tn2RIcDkRvTA/v2JsAEhxe99uw== - dependencies: - regenerator-runtime "^0.13.4" - "@babel/template@^7.16.7", "@babel/template@^7.3.3": version "7.16.7" resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.16.7.tgz#8d126c8701fde4d66b264b3eba3d96f07666d155" @@ -1116,23 +994,7 @@ "@babel/parser" "^7.16.7" "@babel/types" "^7.16.7" -"@babel/traverse@^7.13.0", "@babel/traverse@^7.16.7", "@babel/traverse@^7.16.8", "@babel/traverse@^7.17.0", "@babel/traverse@^7.17.3", "@babel/traverse@^7.7.2": - version "7.17.3" - resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.17.3.tgz#0ae0f15b27d9a92ba1f2263358ea7c4e7db47b57" - integrity sha512-5irClVky7TxRWIRtxlh2WPUUOLhcPN06AGgaQSB8AEwuyEBgJVuJ5imdHm5zxk8w0QS5T+tDfnDxAlhWjpb7cw== - dependencies: - "@babel/code-frame" "^7.16.7" - "@babel/generator" "^7.17.3" - "@babel/helper-environment-visitor" "^7.16.7" - "@babel/helper-function-name" "^7.16.7" - "@babel/helper-hoist-variables" "^7.16.7" - "@babel/helper-split-export-declaration" "^7.16.7" - "@babel/parser" "^7.17.3" - "@babel/types" "^7.17.0" - debug "^4.1.0" - globals "^11.1.0" - -"@babel/traverse@^7.17.10", "@babel/traverse@^7.17.9": +"@babel/traverse@^7.13.0", "@babel/traverse@^7.16.7", "@babel/traverse@^7.16.8", "@babel/traverse@^7.17.10", "@babel/traverse@^7.17.3", "@babel/traverse@^7.17.9", "@babel/traverse@^7.7.2": version "7.17.10" resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.17.10.tgz#1ee1a5ac39f4eac844e6cf855b35520e5eb6f8b5" integrity sha512-VmbrTHQteIdUUQNTb+zE12SHS/xQVIShmBPhlNP12hD5poF2pbITW1Z4172d03HegaQWhLffdkRJYtAzp0AGcw== @@ -1148,15 +1010,7 @@ debug "^4.1.0" globals "^11.1.0" -"@babel/types@^7.0.0", "@babel/types@^7.16.0", "@babel/types@^7.16.7", "@babel/types@^7.16.8", "@babel/types@^7.17.0", "@babel/types@^7.3.0", "@babel/types@^7.3.3", "@babel/types@^7.4.4": - version "7.17.0" - resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.17.0.tgz#a826e368bccb6b3d84acd76acad5c0d87342390b" - integrity sha512-TmKSNO4D5rzhL5bjWFcVHHLETzfQ/AmbKpKPOSjlP0WoHZ6L911fgoOKY4Alp/emzG4cHJdyN49zpgkbXFEHHw== - dependencies: - "@babel/helper-validator-identifier" "^7.16.7" - to-fast-properties "^2.0.0" - -"@babel/types@^7.17.10": +"@babel/types@^7.0.0", "@babel/types@^7.16.0", "@babel/types@^7.16.7", "@babel/types@^7.16.8", "@babel/types@^7.17.0", "@babel/types@^7.17.10", "@babel/types@^7.3.0", "@babel/types@^7.3.3", "@babel/types@^7.4.4": version "7.17.10" resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.17.10.tgz#d35d7b4467e439fcf06d195f8100e0fea7fc82c4" integrity sha512-9O26jG0mBYfGkUYCYZRnBwbVLd1UZOICEr2Em6InB6jVfsAv1GKgwXHmrSg+WFWDmeKTA6vyTZiN8tCSM5Oo3A== @@ -1196,20 +1050,20 @@ minimatch "^3.0.4" strip-json-comments "^3.1.1" -"@ethereumjs/common@^2.5.0", "@ethereumjs/common@^2.6.1": - version "2.6.2" - resolved "https://registry.yarnpkg.com/@ethereumjs/common/-/common-2.6.2.tgz#eb006c9329c75c80f634f340dc1719a5258244df" - integrity sha512-vDwye5v0SVeuDky4MtKsu+ogkH2oFUV8pBKzH/eNBzT8oI91pKa8WyzDuYuxOQsgNgv5R34LfFDh2aaw3H4HbQ== +"@ethereumjs/common@^2.5.0", "@ethereumjs/common@^2.6.3": + version "2.6.4" + resolved "https://registry.yarnpkg.com/@ethereumjs/common/-/common-2.6.4.tgz#1b3cdd3aa4ee3b0ca366756fc35e4a03022a01cc" + integrity sha512-RDJh/R/EAr+B7ZRg5LfJ0BIpf/1LydFgYdvZEuTraojCbVypO2sQ+QnpP5u2wJf9DASyooKqu8O4FJEWUV6NXw== dependencies: crc-32 "^1.2.0" ethereumjs-util "^7.1.4" "@ethereumjs/tx@^3.3.2": - version "3.5.0" - resolved "https://registry.yarnpkg.com/@ethereumjs/tx/-/tx-3.5.0.tgz#783b0aeb08518b9991b23f5155763bbaf930a037" - integrity sha512-/+ZNbnJhQhXC83Xuvy6I9k4jT5sXiV0tMR9C+AzSSpcCV64+NB8dTE1m3x98RYMqb8+TLYWA+HML4F5lfXTlJw== + version "3.5.1" + resolved "https://registry.yarnpkg.com/@ethereumjs/tx/-/tx-3.5.1.tgz#8d941b83a602b4a89949c879615f7ea9a90e6671" + integrity sha512-xzDrTiu4sqZXUcaBxJ4n4W5FrppwxLxZB4ZDGVLtxSQR4lVuOnFR6RcUHdg1mpUhAPVrmnzLJpxaeXnPxIyhWA== dependencies: - "@ethereumjs/common" "^2.6.1" + "@ethereumjs/common" "^2.6.3" ethereumjs-util "^7.1.4" "@ethersproject/abi@5.0.7": @@ -1227,171 +1081,171 @@ "@ethersproject/properties" "^5.0.3" "@ethersproject/strings" "^5.0.4" -"@ethersproject/abstract-provider@^5.5.0": - version "5.5.1" - resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.5.1.tgz#2f1f6e8a3ab7d378d8ad0b5718460f85649710c5" - integrity sha512-m+MA/ful6eKbxpr99xUYeRvLkfnlqzrF8SZ46d/xFB1A7ZVknYc/sXJG0RcufF52Qn2jeFj1hhcoQ7IXjNKUqg== +"@ethersproject/abstract-provider@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.6.0.tgz#0c4ac7054650dbd9c476cf5907f588bbb6ef3061" + integrity sha512-oPMFlKLN+g+y7a79cLK3WiLcjWFnZQtXWgnLAbHZcN3s7L4v90UHpTOrLk+m3yr0gt+/h9STTM6zrr7PM8uoRw== dependencies: - "@ethersproject/bignumber" "^5.5.0" - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/logger" "^5.5.0" - "@ethersproject/networks" "^5.5.0" - "@ethersproject/properties" "^5.5.0" - "@ethersproject/transactions" "^5.5.0" - "@ethersproject/web" "^5.5.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/networks" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/transactions" "^5.6.0" + "@ethersproject/web" "^5.6.0" -"@ethersproject/abstract-signer@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.5.0.tgz#590ff6693370c60ae376bf1c7ada59eb2a8dd08d" - integrity sha512-lj//7r250MXVLKI7sVarXAbZXbv9P50lgmJQGr2/is82EwEb8r7HrxsmMqAjTsztMYy7ohrIhGMIml+Gx4D3mA== +"@ethersproject/abstract-signer@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.6.0.tgz#9cd7ae9211c2b123a3b29bf47aab17d4d016e3e7" + integrity sha512-WOqnG0NJKtI8n0wWZPReHtaLkDByPL67tn4nBaDAhmVq8sjHTPbCdz4DRhVu/cfTOvfy9w3iq5QZ7BX7zw56BQ== dependencies: - "@ethersproject/abstract-provider" "^5.5.0" - "@ethersproject/bignumber" "^5.5.0" - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/logger" "^5.5.0" - "@ethersproject/properties" "^5.5.0" + "@ethersproject/abstract-provider" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" -"@ethersproject/address@^5.0.4", "@ethersproject/address@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.5.0.tgz#bcc6f576a553f21f3dd7ba17248f81b473c9c78f" - integrity sha512-l4Nj0eWlTUh6ro5IbPTgbpT4wRbdH5l8CQf7icF7sb/SI3Nhd9Y9HzhonTSTi6CefI0necIw7LJqQPopPLZyWw== +"@ethersproject/address@^5.0.4", "@ethersproject/address@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.6.0.tgz#13c49836d73e7885fc148ad633afad729da25012" + integrity sha512-6nvhYXjbXsHPS+30sHZ+U4VMagFC/9zAk6Gd/h3S21YW4+yfb0WfRtaAIZ4kfM4rrVwqiy284LP0GtL5HXGLxQ== dependencies: - "@ethersproject/bignumber" "^5.5.0" - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/keccak256" "^5.5.0" - "@ethersproject/logger" "^5.5.0" - "@ethersproject/rlp" "^5.5.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/rlp" "^5.6.0" -"@ethersproject/base64@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.5.0.tgz#881e8544e47ed976930836986e5eb8fab259c090" - integrity sha512-tdayUKhU1ljrlHzEWbStXazDpsx4eg1dBXUSI6+mHlYklOXoXF6lZvw8tnD6oVaWfnMxAgRSKROg3cVKtCcppA== +"@ethersproject/base64@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.6.0.tgz#a12c4da2a6fb86d88563216b0282308fc15907c9" + integrity sha512-2Neq8wxJ9xHxCF9TUgmKeSh9BXJ6OAxWfeGWvbauPh8FuHEjamgHilllx8KkSd5ErxyHIX7Xv3Fkcud2kY9ezw== dependencies: - "@ethersproject/bytes" "^5.5.0" + "@ethersproject/bytes" "^5.6.0" -"@ethersproject/bignumber@^5.0.7", "@ethersproject/bignumber@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.5.0.tgz#875b143f04a216f4f8b96245bde942d42d279527" - integrity sha512-6Xytlwvy6Rn3U3gKEc1vP7nR92frHkv6wtVr95LFR3jREXiCPzdWxKQ1cx4JGQBXxcguAwjA8murlYN2TSiEbg== +"@ethersproject/bignumber@^5.0.7", "@ethersproject/bignumber@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.6.0.tgz#116c81b075c57fa765a8f3822648cf718a8a0e26" + integrity sha512-VziMaXIUHQlHJmkv1dlcd6GY2PmT0khtAqaMctCIDogxkrarMzA9L94KN1NeXqqOfFD6r0sJT3vCTOFSmZ07DA== dependencies: - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/logger" "^5.5.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" bn.js "^4.11.9" -"@ethersproject/bytes@^5.0.4", "@ethersproject/bytes@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.5.0.tgz#cb11c526de657e7b45d2e0f0246fb3b9d29a601c" - integrity sha512-ABvc7BHWhZU9PNM/tANm/Qx4ostPGadAuQzWTr3doklZOhDlmcBqclrQe/ZXUIj3K8wC28oYeuRa+A37tX9kog== +"@ethersproject/bytes@^5.0.4", "@ethersproject/bytes@^5.6.0": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.6.1.tgz#24f916e411f82a8a60412344bf4a813b917eefe7" + integrity sha512-NwQt7cKn5+ZE4uDn+X5RAXLp46E1chXoaMmrxAyA0rblpxz8t58lVkrHXoRIn0lz1joQElQ8410GqhTqMOwc6g== dependencies: - "@ethersproject/logger" "^5.5.0" + "@ethersproject/logger" "^5.6.0" -"@ethersproject/constants@^5.0.4", "@ethersproject/constants@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.5.0.tgz#d2a2cd7d94bd1d58377d1d66c4f53c9be4d0a45e" - integrity sha512-2MsRRVChkvMWR+GyMGY4N1sAX9Mt3J9KykCsgUFd/1mwS0UH1qw+Bv9k1UJb3X3YJYFco9H20pjSlOIfCG5HYQ== +"@ethersproject/constants@^5.0.4", "@ethersproject/constants@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.6.0.tgz#55e3eb0918584d3acc0688e9958b0cedef297088" + integrity sha512-SrdaJx2bK0WQl23nSpV/b1aq293Lh0sUaZT/yYKPDKn4tlAbkH96SPJwIhwSwTsoQQZxuh1jnqsKwyymoiBdWA== dependencies: - "@ethersproject/bignumber" "^5.5.0" + "@ethersproject/bignumber" "^5.6.0" "@ethersproject/hash@^5.0.4": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.5.0.tgz#7cee76d08f88d1873574c849e0207dcb32380cc9" - integrity sha512-dnGVpK1WtBjmnp3mUT0PlU2MpapnwWI0PibldQEq1408tQBAbZpPidkWoVVuNMOl/lISO3+4hXZWCL3YV7qzfg== + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.6.0.tgz#d24446a5263e02492f9808baa99b6e2b4c3429a2" + integrity sha512-fFd+k9gtczqlr0/BruWLAu7UAOas1uRRJvOR84uDf4lNZ+bTkGl366qvniUZHKtlqxBRU65MkOobkmvmpHU+jA== dependencies: - "@ethersproject/abstract-signer" "^5.5.0" - "@ethersproject/address" "^5.5.0" - "@ethersproject/bignumber" "^5.5.0" - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/keccak256" "^5.5.0" - "@ethersproject/logger" "^5.5.0" - "@ethersproject/properties" "^5.5.0" - "@ethersproject/strings" "^5.5.0" + "@ethersproject/abstract-signer" "^5.6.0" + "@ethersproject/address" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.0" -"@ethersproject/keccak256@^5.0.3", "@ethersproject/keccak256@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.5.0.tgz#e4b1f9d7701da87c564ffe336f86dcee82983492" - integrity sha512-5VoFCTjo2rYbBe1l2f4mccaRFN/4VQEYFwwn04aJV2h7qf4ZvI2wFxUE1XOX+snbwCLRzIeikOqtAoPwMza9kg== +"@ethersproject/keccak256@^5.0.3", "@ethersproject/keccak256@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.6.0.tgz#fea4bb47dbf8f131c2e1774a1cecbfeb9d606459" + integrity sha512-tk56BJ96mdj/ksi7HWZVWGjCq0WVl/QvfhFQNeL8fxhBlGoP+L80uDCiQcpJPd+2XxkivS3lwRm3E0CXTfol0w== dependencies: - "@ethersproject/bytes" "^5.5.0" + "@ethersproject/bytes" "^5.6.0" js-sha3 "0.8.0" -"@ethersproject/logger@^5.0.5", "@ethersproject/logger@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.5.0.tgz#0c2caebeff98e10aefa5aef27d7441c7fd18cf5d" - integrity sha512-rIY/6WPm7T8n3qS2vuHTUBPdXHl+rGxWxW5okDfo9J4Z0+gRRZT0msvUdIJkE4/HS29GUMziwGaaKO2bWONBrg== +"@ethersproject/logger@^5.0.5", "@ethersproject/logger@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.6.0.tgz#d7db1bfcc22fd2e4ab574cba0bb6ad779a9a3e7a" + integrity sha512-BiBWllUROH9w+P21RzoxJKzqoqpkyM1pRnEKG69bulE9TSQD8SAIvTQqIMZmmCO8pUNkgLP1wndX1gKghSpBmg== -"@ethersproject/networks@^5.5.0": - version "5.5.2" - resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.5.2.tgz#784c8b1283cd2a931114ab428dae1bd00c07630b" - integrity sha512-NEqPxbGBfy6O3x4ZTISb90SjEDkWYDUbEeIFhJly0F7sZjoQMnj5KYzMSkMkLKZ+1fGpx00EDpHQCy6PrDupkQ== +"@ethersproject/networks@^5.6.0": + version "5.6.2" + resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.6.2.tgz#2bacda62102c0b1fcee408315f2bed4f6fbdf336" + integrity sha512-9uEzaJY7j5wpYGTojGp8U89mSsgQLc40PCMJLMCnFXTs7nhBveZ0t7dbqWUNrepWTszDbFkYD6WlL8DKx5huHA== dependencies: - "@ethersproject/logger" "^5.5.0" + "@ethersproject/logger" "^5.6.0" -"@ethersproject/properties@^5.0.3", "@ethersproject/properties@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.5.0.tgz#61f00f2bb83376d2071baab02245f92070c59995" - integrity sha512-l3zRQg3JkD8EL3CPjNK5g7kMx4qSwiR60/uk5IVjd3oq1MZR5qUg40CNOoEJoX5wc3DyY5bt9EbMk86C7x0DNA== +"@ethersproject/properties@^5.0.3", "@ethersproject/properties@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.6.0.tgz#38904651713bc6bdd5bdd1b0a4287ecda920fa04" + integrity sha512-szoOkHskajKePTJSZ46uHUWWkbv7TzP2ypdEK6jGMqJaEt2sb0jCgfBo0gH0m2HBpRixMuJ6TBRaQCF7a9DoCg== dependencies: - "@ethersproject/logger" "^5.5.0" + "@ethersproject/logger" "^5.6.0" -"@ethersproject/rlp@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.5.0.tgz#530f4f608f9ca9d4f89c24ab95db58ab56ab99a0" - integrity sha512-hLv8XaQ8PTI9g2RHoQGf/WSxBfTB/NudRacbzdxmst5VHAqd1sMibWG7SENzT5Dj3yZ3kJYx+WiRYEcQTAkcYA== +"@ethersproject/rlp@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.6.0.tgz#55a7be01c6f5e64d6e6e7edb6061aa120962a717" + integrity sha512-dz9WR1xpcTL+9DtOT/aDO+YyxSSdO8YIS0jyZwHHSlAmnxA6cKU3TrTd4Xc/bHayctxTgGLYNuVVoiXE4tTq1g== dependencies: - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/logger" "^5.5.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" -"@ethersproject/signing-key@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.5.0.tgz#2aa37169ce7e01e3e80f2c14325f624c29cedbe0" - integrity sha512-5VmseH7qjtNmDdZBswavhotYbWB0bOwKIlOTSlX14rKn5c11QmJwGt4GHeo7NrL/Ycl7uo9AHvEqs5xZgFBTng== +"@ethersproject/signing-key@^5.6.0": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.6.1.tgz#31b0a531520616254eb0465b9443e49515c4d457" + integrity sha512-XvqQ20DH0D+bS3qlrrgh+axRMth5kD1xuvqUQUTeezxUTXBOeR6hWz2/C6FBEu39FRytyybIWrYf7YLSAKr1LQ== dependencies: - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/logger" "^5.5.0" - "@ethersproject/properties" "^5.5.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" bn.js "^4.11.9" elliptic "6.5.4" hash.js "1.1.7" -"@ethersproject/strings@^5.0.4", "@ethersproject/strings@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.5.0.tgz#e6784d00ec6c57710755699003bc747e98c5d549" - integrity sha512-9fy3TtF5LrX/wTrBaT8FGE6TDJyVjOvXynXJz5MT5azq+E6D92zuKNx7i29sWW2FjVOaWjAsiZ1ZWznuduTIIQ== +"@ethersproject/strings@^5.0.4", "@ethersproject/strings@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.6.0.tgz#9891b26709153d996bf1303d39a7f4bc047878fd" + integrity sha512-uv10vTtLTZqrJuqBZR862ZQjTIa724wGPWQqZrofaPI/kUsf53TBG0I0D+hQ1qyNtllbNzaW+PDPHHUI6/65Mg== dependencies: - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/constants" "^5.5.0" - "@ethersproject/logger" "^5.5.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/constants" "^5.6.0" + "@ethersproject/logger" "^5.6.0" -"@ethersproject/transactions@^5.0.0-beta.135", "@ethersproject/transactions@^5.5.0": - version "5.5.0" - resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.5.0.tgz#7e9bf72e97bcdf69db34fe0d59e2f4203c7a2908" - integrity sha512-9RZYSKX26KfzEd/1eqvv8pLauCKzDTub0Ko4LfIgaERvRuwyaNV78mJs7cpIgZaDl6RJui4o49lHwwCM0526zA== +"@ethersproject/transactions@^5.0.0-beta.135", "@ethersproject/transactions@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.6.0.tgz#4b594d73a868ef6e1529a2f8f94a785e6791ae4e" + integrity sha512-4HX+VOhNjXHZyGzER6E/LVI2i6lf9ejYeWD6l4g50AdmimyuStKc39kvKf1bXWQMg7QNVh+uC7dYwtaZ02IXeg== dependencies: - "@ethersproject/address" "^5.5.0" - "@ethersproject/bignumber" "^5.5.0" - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/constants" "^5.5.0" - "@ethersproject/keccak256" "^5.5.0" - "@ethersproject/logger" "^5.5.0" - "@ethersproject/properties" "^5.5.0" - "@ethersproject/rlp" "^5.5.0" - "@ethersproject/signing-key" "^5.5.0" + "@ethersproject/address" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/constants" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/rlp" "^5.6.0" + "@ethersproject/signing-key" "^5.6.0" -"@ethersproject/web@^5.5.0": - version "5.5.1" - resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.5.1.tgz#cfcc4a074a6936c657878ac58917a61341681316" - integrity sha512-olvLvc1CB12sREc1ROPSHTdFCdvMh0J5GSJYiQg2D0hdD4QmJDy8QYDb1CvoqD/bF1c++aeKv2sR5uduuG9dQg== +"@ethersproject/web@^5.6.0": + version "5.6.0" + resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.6.0.tgz#4bf8b3cbc17055027e1a5dd3c357e37474eaaeb8" + integrity sha512-G/XHj0hV1FxI2teHRfCGvfBUHFmU+YOSbCxlAMqJklxSa7QMiHFQfAxvwY2PFqgvdkxEKwRNr/eCjfAPEm2Ctg== dependencies: - "@ethersproject/base64" "^5.5.0" - "@ethersproject/bytes" "^5.5.0" - "@ethersproject/logger" "^5.5.0" - "@ethersproject/properties" "^5.5.0" - "@ethersproject/strings" "^5.5.0" + "@ethersproject/base64" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.0" "@humanwhocodes/config-array@^0.9.2": - version "0.9.3" - resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.9.3.tgz#f2564c744b387775b436418491f15fce6601f63e" - integrity sha512-3xSMlXHh03hCcCmFc0rbKp3Ivt2PFEJnQUJDDMTJQ2wkECZWdq4GePs2ctc5H8zV+cHPaq8k2vU8mrQjA6iHdQ== + version "0.9.5" + resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.9.5.tgz#2cbaf9a89460da24b5ca6531b8bbfc23e1df50c7" + integrity sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw== dependencies: "@humanwhocodes/object-schema" "^1.2.1" debug "^4.1.1" @@ -1618,9 +1472,9 @@ "@jridgewell/sourcemap-codec" "^1.4.10" "@jridgewell/resolve-uri@^3.0.3": - version "3.0.5" - resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.0.5.tgz#68eb521368db76d040a6315cdb24bf2483037b9c" - integrity sha512-VPeQ7+wH0itvQxnG+lIzWgkysKIr3L9sslimFW55rHMdGu/qCQ5z5h9zq4gI8uBtqkpHhsF4Z/OwExufUCThew== + version "3.0.6" + resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.0.6.tgz#4ac237f4dabc8dd93330386907b97591801f7352" + integrity sha512-R7xHtBSNm+9SyvpJkdQl+qrM3Hm2fea3Ef197M3mUug+v+yR+Rhfbs7PBtcBUVnIWJ4JcAdjvij+c8hXS9p5aw== "@jridgewell/set-array@^1.0.0": version "1.1.0" @@ -1628,19 +1482,11 @@ integrity sha512-SfJxIxNVYLTsKwzB3MoOQ1yxf4w/E6MdkvTgrgAt1bfxjSrLUoHMKrDOykwN14q65waezZIdqDneUIPh4/sKxg== "@jridgewell/sourcemap-codec@^1.4.10": - version "1.4.11" - resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.11.tgz#771a1d8d744eeb71b6adb35808e1a6c7b9b8c8ec" - integrity sha512-Fg32GrJo61m+VqYSdRSjRXMjQ06j8YIYfcTqndLYVAaHmroZHLJZCydsWBOTDqXS2v+mjxohBWEMfg97GXmYQg== - -"@jridgewell/trace-mapping@^0.3.0": - version "0.3.4" - resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.4.tgz#f6a0832dffd5b8a6aaa633b7d9f8e8e94c83a0c3" - integrity sha512-vFv9ttIedivx0ux3QSjhgtCVjPZd5l46ZOMDSCwnH1yUO2e964gO8LZGyv2QkqcgR6TnBU1v+1IFqmeoG+0UJQ== - dependencies: - "@jridgewell/resolve-uri" "^3.0.3" - "@jridgewell/sourcemap-codec" "^1.4.10" + version "1.4.12" + resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.12.tgz#7ed98f6fa525ffb7c56a2cbecb5f7bb91abd2baf" + integrity sha512-az/NhpIwP3K33ILr0T2bso+k2E/SLf8Yidd8mHl0n6sCQ4YdyC8qDhZA6kOPDNDBA56ZnIjngVl0U3jREA0BUA== -"@jridgewell/trace-mapping@^0.3.7", "@jridgewell/trace-mapping@^0.3.8": +"@jridgewell/trace-mapping@^0.3.7", "@jridgewell/trace-mapping@^0.3.8", "@jridgewell/trace-mapping@^0.3.9": version "0.3.9" resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9" integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ== @@ -1692,13 +1538,13 @@ "@octokit/types" "^6.0.3" "@octokit/core@^3.5.1": - version "3.5.1" - resolved "https://registry.yarnpkg.com/@octokit/core/-/core-3.5.1.tgz#8601ceeb1ec0e1b1b8217b960a413ed8e947809b" - integrity sha512-omncwpLVxMP+GLpLPgeGJBF6IWJFjXDS5flY5VbppePYX9XehevbDykRH9PdCdvqt9TS5AOTiDide7h0qrkHjw== + version "3.6.0" + resolved "https://registry.yarnpkg.com/@octokit/core/-/core-3.6.0.tgz#3376cb9f3008d9b3d110370d90e0a1fcd5fe6085" + integrity sha512-7RKRKuA4xTjMhY+eG3jthb3hlZCsOwg3rztWh75Xc+ShDWOfDDATWbeZpAHBNRpm4Tv9WgBMOy1zEJYXG6NJ7Q== dependencies: "@octokit/auth-token" "^2.4.4" "@octokit/graphql" "^4.5.8" - "@octokit/request" "^5.6.0" + "@octokit/request" "^5.6.3" "@octokit/request-error" "^2.0.5" "@octokit/types" "^6.0.3" before-after-hook "^2.2.0" @@ -1756,7 +1602,7 @@ deprecation "^2.0.0" once "^1.4.0" -"@octokit/request@^5.6.0": +"@octokit/request@^5.6.0", "@octokit/request@^5.6.3": version "5.6.3" resolved "https://registry.yarnpkg.com/@octokit/request/-/request-5.6.3.tgz#19a022515a5bba965ac06c9d1334514eb50c48b0" integrity sha512-bFJl0I1KVc9jYTe9tdGGpAMPy32dLBXXo1dS/YwSCTL/2nd9XeHsY616RE3HPXDVk+a+dBuzyz5YdlXwcDTr2A== @@ -2347,9 +2193,9 @@ integrity sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA== "@types/babel__core@^7.1.14": - version "7.1.18" - resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.1.18.tgz#1a29abcc411a9c05e2094c98f9a1b7da6cdf49f8" - integrity sha512-S7unDjm/C7z2A2R9NzfKCK1I+BAALDtxEmsJBwlB3EzNfb929ykjL++1CK9LO++EIp2fQrC8O+BwjKvz6UeDyQ== + version "7.1.19" + resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.1.19.tgz#7b497495b7d1b4812bdb9d02804d0576f43ee460" + integrity sha512-WEOTgRsbYkvA/KCsDwVEGkd7WAr1e3g31VHQ8zy5gul/V1qKullU/BU5I68X5v7V3GnB9eotmom4v5a5gjxorw== dependencies: "@babel/parser" "^7.1.0" "@babel/types" "^7.0.0" @@ -2373,9 +2219,9 @@ "@babel/types" "^7.0.0" "@types/babel__traverse@*", "@types/babel__traverse@^7.0.6": - version "7.14.2" - resolved "https://registry.yarnpkg.com/@types/babel__traverse/-/babel__traverse-7.14.2.tgz#ffcd470bbb3f8bf30481678fb5502278ca833a43" - integrity sha512-K2waXdXBi2302XUdcHcR1jCeU0LL4TD9HRs/gk0N2Xvrht+G/BfJa4QObBQZfhMdxiCpV3COl5Nfq4uKTeTnJA== + version "7.17.1" + resolved "https://registry.yarnpkg.com/@types/babel__traverse/-/babel__traverse-7.17.1.tgz#1a0e73e8c28c7e832656db372b779bfd2ef37314" + integrity sha512-kVzjari1s2YVi77D3w1yuvohV2idweYXMCDzqBiVNN63TcDWrIlTVOYpqVrvbbyOE/IyzBoTKF0fdnLPEORFxA== dependencies: "@babel/types" "^7.3.0" @@ -2400,12 +2246,7 @@ dependencies: "@types/chai" "*" -"@types/chai@*": - version "4.3.0" - resolved "https://registry.yarnpkg.com/@types/chai/-/chai-4.3.0.tgz#23509ebc1fa32f1b4d50d6a66c4032d5b8eaabdc" - integrity sha512-/ceqdqeRraGolFTcfoXNiqjyQhZzbINDngeoAq9GoHa8PPK1yNzTaxWjA6BFWp5Ua9JpXEMSS4s5i9tS0hOJtw== - -"@types/chai@^4.3.1": +"@types/chai@*", "@types/chai@^4.3.1": version "4.3.1" resolved "https://registry.yarnpkg.com/@types/chai/-/chai-4.3.1.tgz#e2c6e73e0bdeb2521d00756d099218e9f5d90a04" integrity sha512-/zPMqDkzSZ8t3VtxOa4KPq7uzzW978M9Tvh+j7GHKuo6k6GTLxPJ4J5gE5cjfJ26pnXst0N5Hax8Sr0T2Mi9zQ== @@ -2481,9 +2322,9 @@ "@types/tough-cookie" "*" "@types/json-schema@^7.0.9": - version "7.0.9" - resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.9.tgz#97edc9037ea0c38585320b28964dde3b39e4660d" - integrity sha512-qcUXuemtEu+E5wZSJHNxUXeCZhAfXKQ41D+duX+VYPde7xyEVZci+/oXKJL13tnRs9lR2pr4fod59GT6/X1/yQ== + version "7.0.11" + resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3" + integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ== "@types/json5@^0.0.29": version "0.0.29" @@ -2503,21 +2344,16 @@ "@types/node" "*" form-data "^3.0.0" -"@types/node@*": - version "17.0.18" - resolved "https://registry.yarnpkg.com/@types/node/-/node-17.0.18.tgz#3b4fed5cfb58010e3a2be4b6e74615e4847f1074" - integrity sha512-eKj4f/BsN/qcculZiRSujogjvp5O/k4lOW5m35NopjZM/QwLOR075a8pJW5hD+Rtdm2DaCVPENS6KtSQnUD6BA== - -"@types/node@^12.12.6": - version "12.20.46" - resolved "https://registry.yarnpkg.com/@types/node/-/node-12.20.46.tgz#7e49dee4c54fd19584e6a9e0da5f3dc2e9136bc7" - integrity sha512-cPjLXj8d6anFPzFvOPxS3fvly3Shm5nTfl6g8X5smexixbuGUf7hfr21J5tX9JW+UPStp/5P5R8qrKL5IyVJ+A== - -"@types/node@^17.0.31": +"@types/node@*", "@types/node@^17.0.31": version "17.0.31" resolved "https://registry.yarnpkg.com/@types/node/-/node-17.0.31.tgz#a5bb84ecfa27eec5e1c802c6bbf8139bdb163a5d" integrity sha512-AR0x5HbXGqkEx9CadRH3EBYx/VkiUgZIhP4wvPn/+5KIsgpNoyFaRlVe0Zlx9gRtg8fA06a9tskE2MSN7TcG4Q== +"@types/node@^12.12.6": + version "12.20.50" + resolved "https://registry.yarnpkg.com/@types/node/-/node-12.20.50.tgz#14ba5198f1754ffd0472a2f84ab433b45ee0b65e" + integrity sha512-+9axpWx2b2JCVovr7Ilgt96uc6C1zBKOQMpGtRbWT9IoR/8ue32GGMfGA4woP8QyP2gBs6GQWEVM3tCybGCxDA== + "@types/parse5@*": version "6.0.3" resolved "https://registry.yarnpkg.com/@types/parse5/-/parse5-6.0.3.tgz#705bb349e789efa06f43f128cef51240753424cb" @@ -2531,9 +2367,9 @@ "@types/node" "*" "@types/prettier@^2.1.5": - version "2.4.4" - resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-2.4.4.tgz#5d9b63132df54d8909fce1c3f8ca260fdd693e17" - integrity sha512-ReVR2rLTV1kvtlWFyuot+d1pkpG2Fw/XKE3PDAdj57rbM97ttSp9JZ2UsP+2EHTylra9cUf6JA7tGwW1INzUrA== + version "2.6.0" + resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-2.6.0.tgz#efcbd41937f9ae7434c714ab698604822d890759" + integrity sha512-G/AdOadiZhnJp0jXCaBQU449W2h716OW/EoXeYkCytxKL06X1WCXB4DZpp8TpZ8eyIJVS1cw4lrlkkSYU21cDw== "@types/resolve@1.17.1": version "1.17.1" @@ -2567,9 +2403,9 @@ "@types/node" "*" "@types/yargs-parser@*": - version "20.2.1" - resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-20.2.1.tgz#3b9ce2489919d9e4fea439b76916abc34b2df129" - integrity sha512-7tFImggNeNBVMsn0vLrpn1H1uPrUBdnARPTpZoitY37ZrdJREzf7I16tMrlK3hen349gr1NYh8CmZQa7CTG6Aw== + version "21.0.0" + resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-21.0.0.tgz#0c60e537fa790f5f9472ed2776c2b71ec117351b" + integrity sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA== "@types/yargs@^17.0.8": version "17.0.10" @@ -2643,7 +2479,7 @@ semver "^7.3.5" tsutils "^3.21.0" -"@typescript-eslint/typescript-estree@^4.8.2": +"@typescript-eslint/typescript-estree@^4.33.0": version "4.33.0" resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.33.0.tgz#0dfb51c2908f68c5c08d82aefeaf166a17c24609" integrity sha512-rkWRY1MPFzjwnEVHsxGemDzqqddw2QbTJlICPD9p9I9LfsO8fdmfQPOX3uKfUaGRDFJbfrtm/sXhVXN4E+bzCA== @@ -2705,12 +2541,7 @@ optionalDependencies: prettier "^1.18.2 || ^2.0.0" -abab@^2.0.5: - version "2.0.5" - resolved "https://registry.yarnpkg.com/abab/-/abab-2.0.5.tgz#c0b678fb32d60fc1219c784d6a826fe385aeb79a" - integrity sha512-9IK9EadsbHo6jLWIpxpR6pL0sazTXV6+SQv25ZB+F7Bj9mJNaOc4nCRabwd5M/JwmUa8idz6Eci6eKfJryPs6Q== - -abab@^2.0.6: +abab@^2.0.5, abab@^2.0.6: version "2.0.6" resolved "https://registry.yarnpkg.com/abab/-/abab-2.0.6.tgz#41b80f2c871d19686216b82309231cfd3cb3d291" integrity sha512-j2afSsaIENvHZN2B8GOpF566vZ5WVk5opAiMTvWgaQT8DkbOqsTfvNAvHoRGU2zzP8cPoqys+xHTRDWW8L+/BA== @@ -2751,12 +2582,7 @@ resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa" integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A== -acorn@^8.4.1, acorn@^8.7.0: - version "8.7.0" - resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.7.0.tgz#90951fde0f8f09df93549481e5fc141445b791cf" - integrity sha512-V/LGr1APy+PXIwKebEWrkZPwoeoF+w1jiOBUmuxuiUIaOHtob8Qc9BTrYo7VuI5fR8tqsy+buA2WFooR5olqvQ== - -acorn@^8.5.0: +acorn@^8.4.1, acorn@^8.5.0, acorn@^8.7.0: version "8.7.1" resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.7.1.tgz#0197122c843d1bf6d0a5e83220a788f278f63c30" integrity sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A== @@ -2875,14 +2701,14 @@ resolved "https://registry.yarnpkg.com/array-flatten/-/array-flatten-1.1.1.tgz#9a5f699051b1e7073328f2a008968b64ea2955d2" integrity sha1-ml9pkFGx5wczKPKgCJaLZOopVdI= -array-includes@^3.1.3, array-includes@^3.1.4: - version "3.1.4" - resolved "https://registry.yarnpkg.com/array-includes/-/array-includes-3.1.4.tgz#f5b493162c760f3539631f005ba2bb46acb45ba9" - integrity sha512-ZTNSQkmWumEbiHO2GF4GmWxYVTiQyJy2XOTa15sdQSrvKn7l+180egQMqlrMOUMCyLMD7pmyQe4mMDUT6Behrw== +array-includes@^3.1.4: + version "3.1.5" + resolved "https://registry.yarnpkg.com/array-includes/-/array-includes-3.1.5.tgz#2c320010db8d31031fd2a5f6b3bbd4b1aad31bdb" + integrity sha512-iSDYZMMyTPkiFasVqfuAQnWAYcvO/SeBSCGKePoEthjp4LEMTe4uLc7b025o4jAZpHhihh8xPo99TNWUWWkGDQ== dependencies: call-bind "^1.0.2" - define-properties "^1.1.3" - es-abstract "^1.19.1" + define-properties "^1.1.4" + es-abstract "^1.19.5" get-intrinsic "^1.1.1" is-string "^1.0.7" @@ -2904,22 +2730,24 @@ integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY= array.prototype.flat@^1.2.5: - version "1.2.5" - resolved "https://registry.yarnpkg.com/array.prototype.flat/-/array.prototype.flat-1.2.5.tgz#07e0975d84bbc7c48cd1879d609e682598d33e13" - integrity sha512-KaYU+S+ndVqyUnignHftkwc58o3uVU1jzczILJ1tN2YaIZpFIKBiP/x/j97E5MVPsaCloPbqWLB/8qCTVvT2qg== + version "1.3.0" + resolved "https://registry.yarnpkg.com/array.prototype.flat/-/array.prototype.flat-1.3.0.tgz#0b0c1567bf57b38b56b4c97b8aa72ab45e4adc7b" + integrity sha512-12IUEkHsAhA4DY5s0FPgNXIdc8VRSqD9Zp78a5au9abH/SOBrsp082JOWFNTjkMozh8mqcdiKuaLGhPeYztxSw== dependencies: call-bind "^1.0.2" define-properties "^1.1.3" - es-abstract "^1.19.0" + es-abstract "^1.19.2" + es-shim-unscopables "^1.0.0" array.prototype.flatmap@^1.2.5: - version "1.2.5" - resolved "https://registry.yarnpkg.com/array.prototype.flatmap/-/array.prototype.flatmap-1.2.5.tgz#908dc82d8a406930fdf38598d51e7411d18d4446" - integrity sha512-08u6rVyi1Lj7oqWbS9nUxliETrtIROT4XGTA4D/LWGten6E3ocm7cy9SIrmNHOL5XVbVuckUp3X6Xyg8/zpvHA== + version "1.3.0" + resolved "https://registry.yarnpkg.com/array.prototype.flatmap/-/array.prototype.flatmap-1.3.0.tgz#a7e8ed4225f4788a70cd910abcf0791e76a5534f" + integrity sha512-PZC9/8TKAIxcWKdyeb77EzULHPrIX/tIZebLJUQOMR1OwYosT8yggdfWScfTBCDj5utONvOuPQQumYsU2ULbkg== dependencies: - call-bind "^1.0.0" + call-bind "^1.0.2" define-properties "^1.1.3" - es-abstract "^1.19.0" + es-abstract "^1.19.2" + es-shim-unscopables "^1.0.0" asn1.js@^5.2.0: version "5.4.1" @@ -2948,20 +2776,25 @@ resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b" integrity sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw== -ast-module-types@^2.3.2, ast-module-types@^2.4.0, ast-module-types@^2.7.0, ast-module-types@^2.7.1: +ast-module-types@^2.7.1: version "2.7.1" resolved "https://registry.yarnpkg.com/ast-module-types/-/ast-module-types-2.7.1.tgz#3f7989ef8dfa1fdb82dfe0ab02bdfc7c77a57dd3" integrity sha512-Rnnx/4Dus6fn7fTqdeLEAn5vUll5w7/vts0RN608yFa6si/rDOUonlIIiwugHBFWjylHjxm9owoSZn71KwG4gw== +ast-module-types@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/ast-module-types/-/ast-module-types-3.0.0.tgz#9a6d8a80f438b6b8fe4995699d700297f398bf81" + integrity sha512-CMxMCOCS+4D+DkOQfuZf+vLrSEmY/7xtORwdxs4wtcC1wVgvk2MqFFTwQCFhvWsI4KPU9lcWXPI8DgRiz+xetQ== + async-limiter@~1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/async-limiter/-/async-limiter-1.0.1.tgz#dd379e94f0db8310b08291f9d64c3209766617fd" integrity sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ== async@^2.6.1: - version "2.6.3" - resolved "https://registry.yarnpkg.com/async/-/async-2.6.3.tgz#d72625e2344a3656e3a3ad4fa749fa83299d82ff" - integrity sha512-zflvls11DCy+dQWzTW2dzuilv8Z5X/pjfmZOWba6TNIVDm+2UDaJmXSOXlasHKfNBs8oo3M0aT50fDEWfKZjXg== + version "2.6.4" + resolved "https://registry.yarnpkg.com/async/-/async-2.6.4.tgz#706b7ff6084664cd7eae713f6f965433b5504221" + integrity sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA== dependencies: lodash "^4.17.14" @@ -3162,9 +2995,9 @@ readable-stream "^3.4.0" blakejs@^1.1.0: - version "1.1.1" - resolved "https://registry.yarnpkg.com/blakejs/-/blakejs-1.1.1.tgz#bf313053978b2cd4c444a48795710be05c785702" - integrity sha512-bLG6PHOCZJKNshTjGRBvET0vTciwQE6zFKOKKXPDJfwFBd4Ac0yBfPZqcGvGJap50l7ktvlpFqc2jGVaUgbJgg== + version "1.2.1" + resolved "https://registry.yarnpkg.com/blakejs/-/blakejs-1.2.1.tgz#5057e4206eadb4a97f7c0b6e197a505042fc3814" + integrity sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ== bluebird@^3.1.1, bluebird@^3.5.0: version "3.7.2" @@ -3186,21 +3019,23 @@ resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-5.2.0.tgz#358860674396c6997771a9d051fcc1b57d4ae002" integrity sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw== -body-parser@1.19.2, body-parser@^1.16.0: - version "1.19.2" - resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.19.2.tgz#4714ccd9c157d44797b8b5607d72c0b89952f26e" - integrity sha512-SAAwOxgoCKMGs9uUAUFHygfLAyaniaoun6I8mFY9pRAJL9+Kec34aU+oIjDhTycub1jozEfEwx1W1IuOYxVSFw== +body-parser@1.20.0, body-parser@^1.16.0: + version "1.20.0" + resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.0.tgz#3de69bd89011c11573d7bfee6a64f11b6bd27cc5" + integrity sha512-DfJ+q6EPcGKZD1QWUjSpqp+Q7bDQTsQIF4zfUAtZ6qk+H/3/QRhg9CEp39ss+/T2vw0+HaidC0ecJj/DRLIaKg== dependencies: bytes "3.1.2" content-type "~1.0.4" debug "2.6.9" - depd "~1.1.2" - http-errors "1.8.1" + depd "2.0.0" + destroy "1.2.0" + http-errors "2.0.0" iconv-lite "0.4.24" - on-finished "~2.3.0" - qs "6.9.7" - raw-body "2.4.3" + on-finished "2.4.1" + qs "6.10.3" + raw-body "2.5.1" type-is "~1.6.18" + unpipe "1.0.0" boxen@^5.0.0: version "5.1.2" @@ -3231,7 +3066,7 @@ dependencies: balanced-match "^1.0.0" -braces@^3.0.1, braces@~3.0.2: +braces@^3.0.2, braces@~3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107" integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A== @@ -3307,17 +3142,6 @@ readable-stream "^3.6.0" safe-buffer "^5.2.0" -browserslist@^4.17.5, browserslist@^4.19.1: - version "4.19.2" - resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.19.2.tgz#9ba98791192a39e1242f0670bb265ceee1baf0a4" - integrity sha512-97XU1CTZ5TwU9Qy/Taj+RtiI6SQM1WIhZ9osT7EY0oO2aWXGABZT2OZeRL+6PfaQsiiMIjjwIoYFPq4APgspgQ== - dependencies: - caniuse-lite "^1.0.30001312" - electron-to-chromium "^1.4.71" - escalade "^3.1.1" - node-releases "^2.0.2" - picocolors "^1.0.0" - browserslist@^4.20.2, browserslist@^4.20.3: version "4.20.3" resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.20.3.tgz#eb7572f49ec430e054f56d52ff0ebe9be915f8bf" @@ -3443,11 +3267,6 @@ resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a" integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== -caniuse-lite@^1.0.30001312: - version "1.0.30001312" - resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001312.tgz#e11eba4b87e24d22697dae05455d5aea28550d5f" - integrity sha512-Wiz1Psk2MEK0pX3rUzWaunLTZzqS2JYZFzNKqAiJGiuxIjRPLgV6+VDPOg6lQOUxmDwhTlh198JsTTi8Hzw6aQ== - caniuse-lite@^1.0.30001332: version "1.0.30001335" resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001335.tgz#899254a0b70579e5a957c32dced79f0727c61f2a" @@ -3504,9 +3323,9 @@ supports-color "^7.1.0" changelog-parser@^2.0.0: - version "2.8.0" - resolved "https://registry.yarnpkg.com/changelog-parser/-/changelog-parser-2.8.0.tgz#c14293e3e8fab797913c722de965480198650108" - integrity sha512-ZtSwN0hY7t+WpvaXqqXz98RHCNhWX9HsvCRAv1aBLlqJ7BpKtqdM6Nu6JOiUhRAWR7Gov0aN0fUnmflTz0WgZg== + version "2.8.1" + resolved "https://registry.yarnpkg.com/changelog-parser/-/changelog-parser-2.8.1.tgz#1428998c275e4f7c0a855026dc60c66cde36bb87" + integrity sha512-tNUYFRCEeWTXmwLqoNtOEzx9wcytg72MmGQqsEs14ClYwIDln7sbQw7FJj/dulXgSlsxkemc9gpPQhZYZx1TPw== dependencies: line-reader "^0.2.4" remove-markdown "^0.2.2" @@ -3780,25 +3599,17 @@ resolved "https://registry.yarnpkg.com/cookie-signature/-/cookie-signature-1.0.6.tgz#e303a882b342cc3ee8ca513a79999734dab3ae2c" integrity sha1-4wOogrNCzD7oylE6eZmXNNqzriw= -cookie@0.4.2: - version "0.4.2" - resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.4.2.tgz#0e41f24de5ecf317947c82fc789e06a884824432" - integrity sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA== +cookie@0.5.0: + version "0.5.0" + resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.5.0.tgz#d1f5d71adec6558c58f389987c366aa47e994f8b" + integrity sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw== cookiejar@^2.1.1: version "2.1.3" resolved "https://registry.yarnpkg.com/cookiejar/-/cookiejar-2.1.3.tgz#fc7a6216e408e74414b90230050842dacda75acc" integrity sha512-JxbCBUdrfr6AQjOXrxoTvAMJO4HBTUIlBzslcJPAz+/KT8yk53fXun51u+RenNYvad/+Vc2DIz5o9UxlCDymFQ== -core-js-compat@^3.21.0: - version "3.21.1" - resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.21.1.tgz#cac369f67c8d134ff8f9bd1623e3bc2c42068c82" - integrity sha512-gbgX5AUvMb8gwxC7FLVWYT7Kkgu/y7+h/h1X43yJkNqhlK2fuYyQimqvKGNZFAY6CKii/GFKJ2cp/1/42TN36g== - dependencies: - browserslist "^4.19.1" - semver "7.0.0" - -core-js-compat@^3.22.1: +core-js-compat@^3.21.0, core-js-compat@^3.22.1: version "3.22.4" resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.22.4.tgz#d700f451e50f1d7672dcad0ac85d910e6691e579" integrity sha512-dIWcsszDezkFZrfm1cnB4f/J85gyhiCpxbgBdohWCDtSVuAaChTSpPV7ldOQf/Xds2U5xCIJZOK82G4ZPAIswA== @@ -3836,12 +3647,9 @@ request "^2.88.2" crc-32@^1.2.0: - version "1.2.1" - resolved "https://registry.yarnpkg.com/crc-32/-/crc-32-1.2.1.tgz#436d2bcaad27bcb6bd073a2587139d3024a16460" - integrity sha512-Dn/xm/1vFFgs3nfrpEVScHoIslO9NZRITWGz/1E/St6u4xw99vfZzVkW0OSnzx2h9egej9xwMCEut6sqwokM/w== - dependencies: - exit-on-epipe "~1.0.1" - printj "~1.3.1" + version "1.2.2" + resolved "https://registry.yarnpkg.com/crc-32/-/crc-32-1.2.2.tgz#3cad35a934b8bf71f25ca524b6da51fb7eace2ff" + integrity sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ== create-ecdh@^4.0.0: version "4.0.4" @@ -3963,14 +3771,7 @@ dependencies: ms "2.0.0" -debug@4, debug@^4.0.0, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1, debug@^4.3.2, debug@^4.3.3: - version "4.3.3" - resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.3.tgz#04266e0b70a98d4462e6e288e38259213332b664" - integrity sha512-/zxw5+vh1Tfv+4Qn7a5nsbcJKPaSvCDhojn6FEl9vupwK2VCSDtEiEtqr8DFtzYFOdz63LBkxec7DYuc2jon6Q== - dependencies: - ms "2.1.2" - -debug@4.3.4: +debug@4, debug@4.3.4, debug@^4.0.0, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1, debug@^4.3.2, debug@^4.3.3: version "4.3.4" resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865" integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ== @@ -4052,22 +3853,23 @@ resolved "https://registry.yarnpkg.com/defer-to-connect/-/defer-to-connect-1.1.3.tgz#331ae050c08dcf789f8c83a7b81f0ed94f4ac591" integrity sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ== -define-properties@^1.1.3: - version "1.1.3" - resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1" - integrity sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ== +define-properties@^1.1.3, define-properties@^1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.4.tgz#0b14d7bd7fbeb2f3572c3a7eda80ea5d57fb05b1" + integrity sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA== dependencies: - object-keys "^1.0.12" + has-property-descriptors "^1.0.0" + object-keys "^1.1.1" delayed-stream@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk= -depd@~1.1.2: - version "1.1.2" - resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz#9bcd52e14c097763e749b274c4346ed2e560b5a9" - integrity sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak= +depd@2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df" + integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw== dependency-tree@^8.1.1: version "8.1.2" @@ -4093,10 +3895,10 @@ inherits "^2.0.1" minimalistic-assert "^1.0.0" -destroy@~1.0.4: - version "1.0.4" - resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.0.4.tgz#978857442c44749e4206613e37946205826abd80" - integrity sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA= +destroy@1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.2.0.tgz#4803735509ad8be552934c67df614f94e66fa015" + integrity sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg== detect-indent@^6.0.0: version "6.1.0" @@ -4109,27 +3911,27 @@ integrity sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA== detective-amd@^3.1.0: - version "3.1.0" - resolved "https://registry.yarnpkg.com/detective-amd/-/detective-amd-3.1.0.tgz#92daee3214a0ca4522646cf333cac90a3fca6373" - integrity sha512-G7wGWT6f0VErjUkE2utCm7IUshT7nBh7aBBH2VBOiY9Dqy2DMens5iiOvYCuhstoIxRKLrnOvVAz4/EyPIAjnw== + version "3.1.2" + resolved "https://registry.yarnpkg.com/detective-amd/-/detective-amd-3.1.2.tgz#bf55eb5291c218b76d6224a3d07932ef13a9a357" + integrity sha512-jffU26dyqJ37JHR/o44La6CxtrDf3Rt9tvd2IbImJYxWKTMdBjctp37qoZ6ZcY80RHg+kzWz4bXn39e4P7cctQ== dependencies: - ast-module-types "^2.7.0" + ast-module-types "^3.0.0" escodegen "^2.0.0" get-amd-module-type "^3.0.0" - node-source-walk "^4.0.0" + node-source-walk "^4.2.0" detective-cjs@^3.1.1: - version "3.1.1" - resolved "https://registry.yarnpkg.com/detective-cjs/-/detective-cjs-3.1.1.tgz#18da3e39a002d2098a1123d45ce1de1b0d9045a0" - integrity sha512-JQtNTBgFY6h8uT6pgph5QpV3IyxDv+z3qPk/FZRDT9TlFfm5dnRtpH39WtQEr1khqsUxVqXzKjZHpdoQvQbllg== + version "3.1.3" + resolved "https://registry.yarnpkg.com/detective-cjs/-/detective-cjs-3.1.3.tgz#50e107d67b37f459b0ec02966ceb7e20a73f268b" + integrity sha512-ljs7P0Yj9MK64B7G0eNl0ThWSYjhAaSYy+fQcpzaKalYl/UoQBOzOeLCSFEY1qEBhziZ3w7l46KG/nH+s+L7BQ== dependencies: - ast-module-types "^2.4.0" + ast-module-types "^3.0.0" node-source-walk "^4.0.0" detective-es6@^2.2.0, detective-es6@^2.2.1: - version "2.2.1" - resolved "https://registry.yarnpkg.com/detective-es6/-/detective-es6-2.2.1.tgz#090c874e2cdcda677389cc2ae36f0b37faced187" - integrity sha512-22z7MblxkhsIQGuALeGwCKEfqNy4WmgDGmfJCwdXbfDkVYIiIDmY513hiIWBvX3kCmzvvWE7RR7kAYxs01wwKQ== + version "2.2.2" + resolved "https://registry.yarnpkg.com/detective-es6/-/detective-es6-2.2.2.tgz#ee5f880981d9fecae9a694007029a2f6f26d8d28" + integrity sha512-eZUKCUsbHm8xoeoCM0z6JFwvDfJ5Ww5HANo+jPR7AzkFpW9Mun3t/TqIF2jjeWa2TFbAiGaWESykf2OQp3oeMw== dependencies: node-source-walk "^4.0.0" @@ -4153,47 +3955,44 @@ postcss-values-parser "^2.0.1" detective-postcss@^5.0.0: - version "5.0.0" - resolved "https://registry.yarnpkg.com/detective-postcss/-/detective-postcss-5.0.0.tgz#7d39bde17a280e26d0b43130fd735a4a75786fb0" - integrity sha512-IBmim4GTEmZJDBOAoNFBskzNryTmYpBq+CQGghKnSGkoGWascE8iEo98yA+ZM4N5slwGjCr/NxCm+Kzg+q3tZg== + version "5.1.1" + resolved "https://registry.yarnpkg.com/detective-postcss/-/detective-postcss-5.1.1.tgz#ec23ac3818f8be95ac3a38a8b9f3b6d43103ef87" + integrity sha512-YJMsvA0Y6/ST9abMNcQytl9iFQ2bfu4I7B74IUiAvyThfaI9Y666yipL+SrqfReoIekeIEwmGH72oeqX63mwUw== dependencies: - debug "^4.3.1" is-url "^1.2.4" - postcss "^8.2.13" + postcss "^8.4.6" postcss-values-parser "^5.0.0" detective-sass@^3.0.1: - version "3.0.1" - resolved "https://registry.yarnpkg.com/detective-sass/-/detective-sass-3.0.1.tgz#496b819efd1f5c4dd3f0e19b43a8634bdd6927c4" - integrity sha512-oSbrBozRjJ+QFF4WJFbjPQKeakoaY1GiR380NPqwdbWYd5wfl5cLWv0l6LsJVqrgWfFN1bjFqSeo32Nxza8Lbw== + version "3.0.2" + resolved "https://registry.yarnpkg.com/detective-sass/-/detective-sass-3.0.2.tgz#e0f35aac79a4d2f6409c284d95b8f7ecd5973afd" + integrity sha512-DNVYbaSlmti/eztFGSfBw4nZvwsTaVXEQ4NsT/uFckxhJrNRFUh24d76KzoCC3aarvpZP9m8sC2L1XbLej4F7g== dependencies: - debug "^4.1.1" - gonzales-pe "^4.2.3" + gonzales-pe "^4.3.0" node-source-walk "^4.0.0" detective-scss@^2.0.1: - version "2.0.1" - resolved "https://registry.yarnpkg.com/detective-scss/-/detective-scss-2.0.1.tgz#06f8c21ae6dedad1fccc26d544892d968083eaf8" - integrity sha512-VveyXW4WQE04s05KlJ8K0bG34jtHQVgTc9InspqoQxvnelj/rdgSAy7i2DXAazyQNFKlWSWbS+Ro2DWKFOKTPQ== + version "2.0.2" + resolved "https://registry.yarnpkg.com/detective-scss/-/detective-scss-2.0.2.tgz#7d2a642616d44bf677963484fa8754d9558b8235" + integrity sha512-hDWnWh/l0tht/7JQltumpVea/inmkBaanJUcXRB9kEEXVwVUMuZd6z7eusQ6GcBFrfifu3pX/XPyD7StjbAiBg== dependencies: - debug "^4.1.1" - gonzales-pe "^4.2.3" + gonzales-pe "^4.3.0" node-source-walk "^4.0.0" detective-stylus@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/detective-stylus/-/detective-stylus-1.0.0.tgz#50aee7db8babb990381f010c63fabba5b58e54cd" - integrity sha1-UK7n24uruZA4HwEMY/q7pbWOVM0= + version "1.0.3" + resolved "https://registry.yarnpkg.com/detective-stylus/-/detective-stylus-1.0.3.tgz#20a702936c9fd7d4203fd7a903314b5dd43ac713" + integrity sha512-4/bfIU5kqjwugymoxLXXLltzQNeQfxGoLm2eIaqtnkWxqbhap9puDVpJPVDx96hnptdERzS5Cy6p9N8/08A69Q== detective-typescript@^7.0.0: - version "7.0.0" - resolved "https://registry.yarnpkg.com/detective-typescript/-/detective-typescript-7.0.0.tgz#8c8917f2e51d9e4ee49821abf759ff512dd897f2" - integrity sha512-y/Ev98AleGvl43YKTNcA2Q+lyFmsmCfTTNWy4cjEJxoLkbobcXtRS0Kvx06daCgr2GdtlwLfNzL553BkktfJoA== + version "7.0.2" + resolved "https://registry.yarnpkg.com/detective-typescript/-/detective-typescript-7.0.2.tgz#c6e00b4c28764741ef719662250e6b014a5f3c8e" + integrity sha512-unqovnhxzvkCz3m1/W4QW4qGsvXCU06aU2BAm8tkza+xLnp9SOFnob2QsTxUv5PdnQKfDvWcv9YeOeFckWejwA== dependencies: - "@typescript-eslint/typescript-estree" "^4.8.2" + "@typescript-eslint/typescript-estree" "^4.33.0" ast-module-types "^2.7.1" node-source-walk "^4.2.0" - typescript "^3.9.7" + typescript "^3.9.10" diff-sequences@^28.0.2: version "28.0.2" @@ -4295,14 +4094,9 @@ integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0= electron-to-chromium@^1.4.118: - version "1.4.132" - resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.132.tgz#b64599eb018221e52e2e4129de103b03a413c55d" - integrity sha512-JYdZUw/1068NWN+SwXQ7w6Ue0bWYGihvSUNNQwurvcDV/SM7vSiGZ3NuFvFgoEiCs4kB8xs3cX2an3wB7d4TBw== - -electron-to-chromium@^1.4.71: - version "1.4.71" - resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.71.tgz#17056914465da0890ce00351a3b946fd4cd51ff6" - integrity sha512-Hk61vXXKRb2cd3znPE9F+2pLWdIOmP7GjiTj45y6L3W/lO+hSnUSUhq+6lEaERWBdZOHbk2s3YV5c9xVl3boVw== + version "1.4.134" + resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.134.tgz#9baca7a018ca489d8e81a00c7cfe15161da38568" + integrity sha512-OdD7M2no4Mi8PopfvoOuNcwYDJ2mNFxaBfurA6okG3fLBaMcFah9S+si84FhX+FIWLKkdaiHfl4A+5ep/gOVrg== elliptic@6.5.4, elliptic@^6.4.0, elliptic@^6.5.3, elliptic@^6.5.4: version "6.5.4" @@ -4345,9 +4139,9 @@ once "^1.4.0" enhanced-resolve@^5.8.3: - version "5.9.0" - resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.9.0.tgz#49ac24953ac8452ed8fed2ef1340fc8e043667ee" - integrity sha512-weDYmzbBygL7HzGGS26M3hGQx68vehdEg6VUmqSOaFzXExFqlnKuSvsEJCVGQHScS8CQMbrAqftT+AzzHNt/YA== + version "5.9.3" + resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.9.3.tgz#44a342c012cbc473254af5cc6ae20ebd0aae5d88" + integrity sha512-Bq9VSor+kjvW3f9/MiiR4eE3XYgOl7/rS8lnSxbRbF3kS0B2r+Y9w5krBWxZgDxASVZbdYrn5wT4j/Wb0J9qow== dependencies: graceful-fs "^4.2.4" tapable "^2.2.0" @@ -4359,10 +4153,10 @@ dependencies: is-arrayish "^0.2.1" -es-abstract@^1.18.5, es-abstract@^1.19.0, es-abstract@^1.19.1: - version "1.19.1" - resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.19.1.tgz#d4885796876916959de78edaa0df456627115ec3" - integrity sha512-2vJ6tjA/UfqLm2MPs7jxVybLoB8i1t1Jd9R3kISld20sIxPcTbLuggQOUxeWeAvIUkduv/CfMjuh4WmiXr2v9w== +es-abstract@^1.18.5, es-abstract@^1.19.1, es-abstract@^1.19.2, es-abstract@^1.19.5: + version "1.19.5" + resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.19.5.tgz#a2cb01eb87f724e815b278b0dd0d00f36ca9a7f1" + integrity sha512-Aa2G2+Rd3b6kxEUKTF4TaW67czBLyAv3z7VOhYRU50YBx+bbsYZ9xQP4lMNazePuFlybXI0V4MruPos7qUo5fA== dependencies: call-bind "^1.0.2" es-to-primitive "^1.2.1" @@ -4370,21 +4164,28 @@ get-intrinsic "^1.1.1" get-symbol-description "^1.0.0" has "^1.0.3" - has-symbols "^1.0.2" + has-symbols "^1.0.3" internal-slot "^1.0.3" is-callable "^1.2.4" - is-negative-zero "^2.0.1" + is-negative-zero "^2.0.2" is-regex "^1.1.4" - is-shared-array-buffer "^1.0.1" + is-shared-array-buffer "^1.0.2" is-string "^1.0.7" - is-weakref "^1.0.1" - object-inspect "^1.11.0" + is-weakref "^1.0.2" + object-inspect "^1.12.0" object-keys "^1.1.1" object.assign "^4.1.2" string.prototype.trimend "^1.0.4" string.prototype.trimstart "^1.0.4" unbox-primitive "^1.0.1" +es-shim-unscopables@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz#702e632193201e3edf8713635d083d378e510241" + integrity sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w== + dependencies: + has "^1.0.3" + es-to-primitive@^1.2.1: version "1.2.1" resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.1.tgz#e55cd4c9cdc188bcefb03b366c736323fc5c898a" @@ -4395,15 +4196,15 @@ is-symbol "^1.0.2" es5-ext@^0.10.35, es5-ext@^0.10.50: - version "0.10.53" - resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.53.tgz#93c5a3acfdbef275220ad72644ad02ee18368de1" - integrity sha512-Xs2Stw6NiNHWypzRTY1MtaG/uJlwCk8kH81920ma8mvN8Xq1gsfhZvpkImLQArw8AHnv8MT2I45J3c0R8slE+Q== + version "0.10.61" + resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.61.tgz#311de37949ef86b6b0dcea894d1ffedb909d3269" + integrity sha512-yFhIqQAzu2Ca2I4SE2Au3rxVfmohU9Y7wqGR+s7+H7krk26NXhIRAZDgqd6xqjCEFUomDEA3/Bo/7fKmIkW1kA== dependencies: - es6-iterator "~2.0.3" - es6-symbol "~3.1.3" - next-tick "~1.0.0" + es6-iterator "^2.0.3" + es6-symbol "^3.1.3" + next-tick "^1.1.0" -es6-iterator@~2.0.3: +es6-iterator@^2.0.3: version "2.0.3" resolved "https://registry.yarnpkg.com/es6-iterator/-/es6-iterator-2.0.3.tgz#a7de889141a05a94b0854403b2d0a0fbfa98f3b7" integrity sha1-p96IkUGgWpSwhUQDstCg+/qY87c= @@ -4412,7 +4213,7 @@ es5-ext "^0.10.35" es6-symbol "^3.1.1" -es6-symbol@^3.1.1, es6-symbol@~3.1.3: +es6-symbol@^3.1.1, es6-symbol@^3.1.3: version "3.1.3" resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18" integrity sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA== @@ -4834,11 +4635,6 @@ signal-exit "^3.0.3" strip-final-newline "^2.0.0" -exit-on-epipe@~1.0.1: - version "1.0.1" - resolved "https://registry.yarnpkg.com/exit-on-epipe/-/exit-on-epipe-1.0.1.tgz#0bdd92e87d5285d267daa8171d0eb06159689692" - integrity sha512-h2z5mrROTxce56S+pnvAV890uu7ls7f1kEvVGJbw1OlFH3/mlJ5bkXu0KRyW94v37zzHPiUd55iLn3DA7TjWpw== - exit@^0.1.2: version "0.1.2" resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c" @@ -4856,37 +4652,38 @@ jest-util "^28.0.2" express@^4.14.0: - version "4.17.3" - resolved "https://registry.yarnpkg.com/express/-/express-4.17.3.tgz#f6c7302194a4fb54271b73a1fe7a06478c8f85a1" - integrity sha512-yuSQpz5I+Ch7gFrPCk4/c+dIBKlQUxtgwqzph132bsT6qhuzss6I8cLJQz7B3rFblzd6wtcI0ZbGltH/C4LjUg== + version "4.18.1" + resolved "https://registry.yarnpkg.com/express/-/express-4.18.1.tgz#7797de8b9c72c857b9cd0e14a5eea80666267caf" + integrity sha512-zZBcOX9TfehHQhtupq57OF8lFZ3UZi08Y97dwFCkD8p9d/d2Y3M+ykKcwaMDEL+4qyUolgBDX6AblpR3fL212Q== dependencies: accepts "~1.3.8" array-flatten "1.1.1" - body-parser "1.19.2" + body-parser "1.20.0" content-disposition "0.5.4" content-type "~1.0.4" - cookie "0.4.2" + cookie "0.5.0" cookie-signature "1.0.6" debug "2.6.9" - depd "~1.1.2" + depd "2.0.0" encodeurl "~1.0.2" escape-html "~1.0.3" etag "~1.8.1" - finalhandler "~1.1.2" + finalhandler "1.2.0" fresh "0.5.2" + http-errors "2.0.0" merge-descriptors "1.0.1" methods "~1.1.2" - on-finished "~2.3.0" + on-finished "2.4.1" parseurl "~1.3.3" path-to-regexp "0.1.7" proxy-addr "~2.0.7" - qs "6.9.7" + qs "6.10.3" range-parser "~1.2.1" safe-buffer "5.2.1" - send "0.17.2" - serve-static "1.14.2" + send "0.18.0" + serve-static "1.15.0" setprototypeof "1.2.0" - statuses "~1.5.0" + statuses "2.0.1" type-is "~1.6.18" utils-merge "1.0.1" vary "~1.1.2" @@ -4991,9 +4788,9 @@ trim-repeated "^1.0.0" filing-cabinet@^3.0.1: - version "3.1.0" - resolved "https://registry.yarnpkg.com/filing-cabinet/-/filing-cabinet-3.1.0.tgz#3f2a347f0392faad772744de099e25b6dd6f86fd" - integrity sha512-ZFutWTo14Z1xmog76UoQzDKEza1fSpqc+HvUN6K6GILrfhIn6NbR8fHQktltygF+wbt7PZ/EvfLK6yJnebd40A== + version "3.3.0" + resolved "https://registry.yarnpkg.com/filing-cabinet/-/filing-cabinet-3.3.0.tgz#365294d2d3d6ab01b4273e62fb6d23388a70cc0f" + integrity sha512-Tnbpbme1ONaHXV5DGcw0OFpcfP3p2itRf5VXO1bguBXdIewDbK6ZFBK//DGKM0BuCzaQLQNY4f5gljzxY1VCUw== dependencies: app-module-path "^2.2.0" commander "^2.20.3" @@ -5006,6 +4803,7 @@ resolve-dependency-path "^2.0.0" sass-lookup "^3.0.0" stylus-lookup "^3.0.1" + tsconfig-paths "^3.10.1" typescript "^3.9.7" fill-range@^7.0.1: @@ -5015,17 +4813,17 @@ dependencies: to-regex-range "^5.0.1" -finalhandler@~1.1.2: - version "1.1.2" - resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.1.2.tgz#b7e7d000ffd11938d0fdb053506f6ebabe9f587d" - integrity sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA== +finalhandler@1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.2.0.tgz#7d23fe5731b207b4640e4fcd00aec1f9207a7b32" + integrity sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg== dependencies: debug "2.6.9" encodeurl "~1.0.2" escape-html "~1.0.3" - on-finished "~2.3.0" + on-finished "2.4.1" parseurl "~1.3.3" - statuses "~1.5.0" + statuses "2.0.1" unpipe "~1.0.0" find-babel-config@^1.2.0: @@ -5122,9 +4920,9 @@ integrity sha512-dVsPA/UwQ8+2uoFe5GHtiBMu48dWLTdsuEd7CKGlZlD78r1TTWBvDuFaFGKCo/ZfEr95Uk56vZoX86OsHkUeIg== follow-redirects@^1.12.1: - version "1.14.9" - resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.14.9.tgz#dd4ea157de7bfaf9ea9b3fbd85aa16951f78d8d7" - integrity sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w== + version "1.15.0" + resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.0.tgz#06441868281c86d0dda4ad8bdaead2d02dca89d4" + integrity sha512-aExlJShTV4qOUOL7yF1U5tvLCB0xQuudbf6toyYA0E/acBNw71mvjFTnLaRp50aQaYocMR0a/RMMBIHeZnGyjQ== foreach@^2.0.5: version "2.0.5" @@ -5232,6 +5030,11 @@ resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327" integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc= +functions-have-names@^1.2.2: + version "1.2.3" + resolved "https://registry.yarnpkg.com/functions-have-names/-/functions-have-names-1.2.3.tgz#0404fe4ee2ba2f607f0e0ec3c80bae994133b834" + integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ== + gauge@^v4.0.4: version "4.0.4" resolved "https://registry.yarnpkg.com/gauge/-/gauge-4.0.4.tgz#52ff0652f2bbf607a989793d53b751bef2328dce" @@ -5252,12 +5055,12 @@ integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== get-amd-module-type@^3.0.0: - version "3.0.0" - resolved "https://registry.yarnpkg.com/get-amd-module-type/-/get-amd-module-type-3.0.0.tgz#bb334662fa04427018c937774570de495845c288" - integrity sha512-99Q7COuACPfVt18zH9N4VAMyb81S6TUgJm2NgV6ERtkh9VIkAaByZkW530wl3lLN5KTtSrK9jVLxYsoP5hQKsw== + version "3.0.2" + resolved "https://registry.yarnpkg.com/get-amd-module-type/-/get-amd-module-type-3.0.2.tgz#46550cee2b8e1fa4c3f2c8a5753c36990aa49ab0" + integrity sha512-PcuKwB8ouJnKuAPn6Hk3UtdfKoUV3zXRqVEvj8XGIXqjWfgd1j7QGdXy5Z9OdQfzVt1Sk29HVe/P+X74ccOuqw== dependencies: - ast-module-types "^2.3.2" - node-source-walk "^4.0.0" + ast-module-types "^3.0.0" + node-source-walk "^4.2.2" get-caller-file@^2.0.5: version "2.0.5" @@ -5341,12 +5144,12 @@ globby "^6.1.0" gh-release-assets@^2.0.0: - version "2.0.0" - resolved "https://registry.yarnpkg.com/gh-release-assets/-/gh-release-assets-2.0.0.tgz#1aca1a7a3f2a7ead0eeb43104177cda6cdf1febf" - integrity sha512-I+Gy+e86o7A6J7sJRX4uA3EvLlLFcXxsRre22YTJ5dzpl/elZA75bMWfoBd0WVY3Mp9M8KtROfn3zlzDkptyWw== + version "2.0.1" + resolved "https://registry.yarnpkg.com/gh-release-assets/-/gh-release-assets-2.0.1.tgz#d6a1bfe70aca9592980dc30fe14842602005d5b4" + integrity sha512-KrhmYIA/5oQdfEl9vQ2yF6DOM2QOAjpCOsNKFkc7X3dOTefSixttW0ysot3noQ+3XL8NdkdC7z+mqfePzIwexg== dependencies: async "^3.2.0" - mime "^2.4.6" + mime "^3.0.0" progress-stream "^2.0.0" pumpify "^2.0.1" simple-get "^4.0.0" @@ -5452,9 +5255,9 @@ integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== globals@^13.6.0, globals@^13.9.0: - version "13.12.1" - resolved "https://registry.yarnpkg.com/globals/-/globals-13.12.1.tgz#ec206be932e6c77236677127577aa8e50bf1c5cb" - integrity sha512-317dFlgY2pdJZ9rspXDks7073GpDmXdfbM3vYYp0HAMKGDh1FfWPleI2ljVNLQX5M5lXcAslTcPTrOrMEFOjyw== + version "13.13.0" + resolved "https://registry.yarnpkg.com/globals/-/globals-13.13.0.tgz#ac32261060d8070e2719dd6998406e27d2b5727b" + integrity sha512-EQ7Q18AJlPwp3vUDL4mKA0KXrXyNIQyWon6T6XQiBQF0XHvRsiCSrWmmeATpUzdJN2HhWZU6Pdl0a9zdep5p6A== dependencies: type-fest "^0.20.2" @@ -5481,7 +5284,7 @@ pify "^2.0.0" pinkie-promise "^2.0.0" -gonzales-pe@^4.2.3: +gonzales-pe@^4.2.3, gonzales-pe@^4.3.0: version "4.3.0" resolved "https://registry.yarnpkg.com/gonzales-pe/-/gonzales-pe-4.3.0.tgz#fe9dec5f3c557eead09ff868c65826be54d067b3" integrity sha512-otgSPpUmdWJ43VXyiNgEYE4luzHCL2pz4wQ0OnDluC6Eg4Ko3Vexy/SrSynglw/eR+OhkzmqFCZa/OFa/RgAOQ== @@ -5526,9 +5329,9 @@ url-to-options "^1.0.1" graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.4, graceful-fs@^4.2.9: - version "4.2.9" - resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.9.tgz#041b05df45755e587a24942279b9d113146e1c96" - integrity sha512-NtNxqUcXgpW2iMrfqSfR73Glt39K+BLwWsPs94yR63v45T0Wbej7eRmL5cWfwEgqXnmjQp3zaJTshdRW/qC2ZQ== + version "4.2.10" + resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz#147d3a006da4ca3ce14728c7aefc287c367d7a6c" + integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA== graphviz@0.0.9: version "0.0.9" @@ -5562,10 +5365,10 @@ ajv "^6.12.3" har-schema "^2.0.0" -has-bigints@^1.0.1: - version "1.0.1" - resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.1.tgz#64fe6acb020673e3b78db035a5af69aa9d07b113" - integrity sha512-LSBS2LjbNBTf6287JEbEzvJgftkF5qFkmCo9hDRpAzKhUOlJ+hx8dd4USs00SgsUNwc4617J9ki5YtEClM2ffA== +has-bigints@^1.0.1, has-bigints@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.2.tgz#0871bd3e3d51626f6ca0966668ba35d5602d6eaa" + integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ== has-flag@^3.0.0: version "3.0.0" @@ -5577,15 +5380,22 @@ resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b" integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== +has-property-descriptors@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz#610708600606d36961ed04c196193b6a607fa861" + integrity sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ== + dependencies: + get-intrinsic "^1.1.1" + has-symbol-support-x@^1.4.1: version "1.4.2" resolved "https://registry.yarnpkg.com/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz#1409f98bc00247da45da67cee0a36f282ff26455" integrity sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw== -has-symbols@^1.0.1, has-symbols@^1.0.2: - version "1.0.2" - resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.2.tgz#165d3070c00309752a1236a479331e3ac56f1423" - integrity sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw== +has-symbols@^1.0.1, has-symbols@^1.0.2, has-symbols@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8" + integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A== has-to-string-tag-x@^1.2.0: version "1.4.1" @@ -5671,15 +5481,15 @@ resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz#49e91c5cbf36c9b94bcfcd71c23d5249ec74e390" integrity sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ== -http-errors@1.8.1: - version "1.8.1" - resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-1.8.1.tgz#7c3f28577cbc8a207388455dbd62295ed07bd68c" - integrity sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g== +http-errors@2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-2.0.0.tgz#b7774a1486ef73cf7667ac9ae0858c012c57b9d3" + integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ== dependencies: - depd "~1.1.2" + depd "2.0.0" inherits "2.0.4" setprototypeof "1.2.0" - statuses ">= 1.5.0 < 2" + statuses "2.0.1" toidentifier "1.0.1" http-https@^1.0.0: @@ -5706,9 +5516,9 @@ sshpk "^1.7.0" https-proxy-agent@^5.0.0: - version "5.0.0" - resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.0.tgz#e2a90542abb68a762e0a0850f6c9edadfd8506b2" - integrity sha512-EkYm5BcKUGiduxzSt3Eppko+PiNWNEpa4ySk9vTC6wDsQJW9rHSa+UhGNJoRYp7bz6Ht1eaRIa6QaJqO5rCFbA== + version "5.0.1" + resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz#c59ef224a04fe8b754f3db0063a25ea30d0005d6" + integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA== dependencies: agent-base "6" debug "4" @@ -5804,9 +5614,9 @@ integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== inquirer@^8.0.0: - version "8.2.0" - resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-8.2.0.tgz#f44f008dd344bbfc4b30031f45d984e034a3ac3a" - integrity sha512-0crLweprevJ02tTuA6ThpoAERAGyVILC4sS74uib58Xf/zSr1/ZWtmm7D5CI+bSQEaA04f0K7idaHpQbSWgiVQ== + version "8.2.4" + resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-8.2.4.tgz#ddbfe86ca2f67649a67daa6f1051c128f684f0b4" + integrity sha512-nn4F01dxU8VeKfq192IjLsxu0/OmMZ4Lg3xKAns148rCaXP6ntAoEkVYZThWjwON8AlzdZZi6oqnhNbxUG9hVg== dependencies: ansi-escapes "^4.2.1" chalk "^4.1.1" @@ -5818,10 +5628,11 @@ mute-stream "0.0.8" ora "^5.4.1" run-async "^2.4.0" - rxjs "^7.2.0" + rxjs "^7.5.5" string-width "^4.1.0" strip-ansi "^6.0.0" through "^2.3.6" + wrap-ansi "^7.0.0" internal-slot@^1.0.3: version "1.0.3" @@ -5901,14 +5712,7 @@ dependencies: ci-info "^2.0.0" -is-core-module@^2.2.0, is-core-module@^2.8.1: - version "2.8.1" - resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.8.1.tgz#f59fdfca701d5879d0a6b100a40aa1560ce27211" - integrity sha512-SdNCUs284hr40hFTFP6l0IfZ/RSrMXF3qgoRHd3/79unUTvrFO/JoXwkGm+5J/Oe3E/b5GsnG330uUNgRpu1PA== - dependencies: - has "^1.0.3" - -is-core-module@^2.3.0: +is-core-module@^2.2.0, is-core-module@^2.3.0, is-core-module@^2.8.1: version "2.9.0" resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.9.0.tgz#e1c34429cd51c6dd9e09e0799e396e27b19a9c69" integrity sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A== @@ -5979,7 +5783,7 @@ resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591" integrity sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE= -is-negative-zero@^2.0.1: +is-negative-zero@^2.0.2: version "2.0.2" resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.2.tgz#7bf6f03a28003b8b3965de3ac26f664d765f3150" integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA== @@ -5990,9 +5794,9 @@ integrity sha512-WW/rQLOazUq+ST/bCAVBp/2oMERWLsR7OrKyt052dNDk4DHcDE0/7QSXITlmi+VBcV13DfIbysG3tZJm5RfdBA== is-number-object@^1.0.4: - version "1.0.6" - resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.6.tgz#6a7aaf838c7f0686a50b4553f7e54a96494e89f0" - integrity sha512-bEVOqiRcvo3zO1+G2lVMy+gkkEm9Yh7cDMRusKKu5ZJKPUYSJwICTKZrNKHA2EbSP0Tu0+6B/emsYNHZyn6K8g== + version "1.0.7" + resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.7.tgz#59d50ada4c45251784e9904f5246c742f07a42fc" + integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ== dependencies: has-tostringtag "^1.0.0" @@ -6078,10 +5882,12 @@ resolved "https://registry.yarnpkg.com/is-retry-allowed/-/is-retry-allowed-1.2.0.tgz#d778488bd0a4666a3be8a1482b9f2baafedea8b4" integrity sha512-RUbUeKwvm3XG2VYamhJL1xFktgjvPzL0Hq8C+6yrWIswDy3BIXGqCxhxkc30N9jqK311gVU137K8Ei55/zVJRg== -is-shared-array-buffer@^1.0.1: - version "1.0.1" - resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.1.tgz#97b0c85fbdacb59c9c446fe653b82cf2b5b7cfe6" - integrity sha512-IU0NmyknYZN0rChcKhRO1X8LYz5Isj/Fsqh8NJOSf+N/hCOTwy29F32Ik7a+QszE63IdvmwdTPDd6cZ5pg4cwA== +is-shared-array-buffer@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz#8f259c573b60b6a32d4058a1a07430c0a7344c79" + integrity sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA== + dependencies: + call-bind "^1.0.2" is-stream@^1.0.0: version "1.1.0" @@ -6138,7 +5944,7 @@ resolved "https://registry.yarnpkg.com/is-url/-/is-url-1.2.4.tgz#04a4df46d28c4cff3d73d01ff06abeb318a1aa52" integrity sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww== -is-weakref@^1.0.1: +is-weakref@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/is-weakref/-/is-weakref-1.0.2.tgz#9529f383a9338205e89765e0392efc2f100f06f2" integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ== @@ -6176,9 +5982,9 @@ integrity sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw== istanbul-lib-instrument@^5.0.4, istanbul-lib-instrument@^5.1.0: - version "5.1.0" - resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-5.1.0.tgz#7b49198b657b27a730b8e9cb601f1e1bff24c59a" - integrity sha512-czwUz525rkOFDJxfKK6mYfIs9zBKILyrZQxjz3ABhjQXhbhFsSbo1HW/BFcsDnfJYJWA6thRR5/TUY2qs5W99Q== + version "5.2.0" + resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.0.tgz#31d18bdd127f825dd02ea7bfdfd906f8ab840e9f" + integrity sha512-6Lthe1hqXHBNsqvgDzGO6l03XNeu3CrG4RqQ1KM9+l5+jNGpEJfIELx1NS3SEHmJQA8np/u+E4EPRKRiu6m19A== dependencies: "@babel/core" "^7.12.3" "@babel/parser" "^7.14.7" @@ -6720,13 +6526,6 @@ dependencies: minimist "^1.2.0" -json5@^2.1.2: - version "2.2.0" - resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3" - integrity sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA== - dependencies: - minimist "^1.2.5" - json5@^2.2.1: version "2.2.1" resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.1.tgz#655d50ed1e6f95ad1a3caababd2b0efda10b395c" @@ -6759,11 +6558,11 @@ verror "1.10.0" "jsx-ast-utils@^2.4.1 || ^3.0.0": - version "3.2.1" - resolved "https://registry.yarnpkg.com/jsx-ast-utils/-/jsx-ast-utils-3.2.1.tgz#720b97bfe7d901b927d87c3773637ae8ea48781b" - integrity sha512-uP5vu8xfy2F9A6LGC22KO7e2/vGTS1MhP+18f++ZNlf0Ohaxbc9nIEwHAsejlJKyzfZzU5UIhe5ItYkitcZnZA== + version "3.3.0" + resolved "https://registry.yarnpkg.com/jsx-ast-utils/-/jsx-ast-utils-3.3.0.tgz#e624f259143b9062c92b6413ff92a164c80d3ccb" + integrity sha512-XzO9luP6L0xkxwhIJMTJQpZo/eeN60K08jHdexfD569AGxeNug6UketeHXEhROoM8aR7EcUoOQmIhcJQjcuq8Q== dependencies: - array-includes "^3.1.3" + array-includes "^3.1.4" object.assign "^4.1.2" keccak@^3.0.0: @@ -6983,11 +6782,11 @@ walkdir "^0.4.1" magic-string@^0.25.7: - version "0.25.7" - resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.7.tgz#3f497d6fd34c669c6798dcb821f2ef31f5445051" - integrity sha512-4CrMT5DOHTDk4HYDlzmwu4FVCcIYI8gauveasrdCu2IKIFOJ3f0v/8MDGJCDL9oD2ppz/Av1b0Nj345H9M+XIA== + version "0.25.9" + resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.9.tgz#de7f9faf91ef8a1c91d02c2e5314c8277dbcdd1c" + integrity sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ== dependencies: - sourcemap-codec "^1.4.4" + sourcemap-codec "^1.4.8" make-dir@^2.0.0, make-dir@^2.1.0: version "2.1.0" @@ -7063,12 +6862,12 @@ integrity sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4= micromatch@^4.0.4: - version "4.0.4" - resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.4.tgz#896d519dfe9db25fce94ceb7a500919bf881ebf9" - integrity sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg== + version "4.0.5" + resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6" + integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA== dependencies: - braces "^3.0.1" - picomatch "^2.2.3" + braces "^3.0.2" + picomatch "^2.3.1" miller-rabin@^4.0.0: version "4.0.1" @@ -7078,27 +6877,27 @@ bn.js "^4.0.0" brorand "^1.0.1" -mime-db@1.51.0: - version "1.51.0" - resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.51.0.tgz#d9ff62451859b18342d960850dc3cfb77e63fb0c" - integrity sha512-5y8A56jg7XVQx2mbv1lu49NR4dokRnhZYTtL+KGfaa27uq4pSTXkwQkFJl4pkRMyNFz/EtYDSkiiEHx3F7UN6g== +mime-db@1.52.0: + version "1.52.0" + resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70" + integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== mime-types@^2.1.12, mime-types@^2.1.16, mime-types@~2.1.19, mime-types@~2.1.24, mime-types@~2.1.34: - version "2.1.34" - resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.34.tgz#5a712f9ec1503511a945803640fafe09d3793c24" - integrity sha512-6cP692WwGIs9XXdOO4++N+7qjqv0rqxxVvJ3VHPh/Sc9mVZcQP+ZGhkKiTvWMQRr2tbHkJP/Yn7Y0npb3ZBs4A== + version "2.1.35" + resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a" + integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== dependencies: - mime-db "1.51.0" + mime-db "1.52.0" mime@1.6.0: version "1.6.0" resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1" integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg== -mime@^2.4.6: - version "2.6.0" - resolved "https://registry.yarnpkg.com/mime/-/mime-2.6.0.tgz#a2a682a95cd4d0cb1d6257e28f83da7e35800367" - integrity sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg== +mime@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/mime/-/mime-3.0.0.tgz#b374550dca3a0c18443b0c950a6a58f1931cf7a7" + integrity sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A== mimic-fn@^2.1.0: version "2.1.0" @@ -7146,12 +6945,7 @@ dependencies: brace-expansion "^1.1.7" -minimist@^1.2.0, minimist@^1.2.5: - version "1.2.5" - resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602" - integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw== - -minimist@^1.2.6: +minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6: version "1.2.6" resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.6.tgz#8637a5b759ea0d6e98702cfb3a9283323c93af44" integrity sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q== @@ -7184,11 +6978,11 @@ integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== mkdirp@^0.5.5: - version "0.5.5" - resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def" - integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ== + version "0.5.6" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.6.tgz#7def03d2432dcae4ba1d611445c48396062255f6" + integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw== dependencies: - minimist "^1.2.5" + minimist "^1.2.6" mocha@^10.0.0: version "10.0.0" @@ -7229,11 +7023,11 @@ integrity sha512-uz8lx8c5wuJYJ21f5UtovqpV0+KJuVwE7cVOLNhrl2QW/CvmstOLRfjXnLSbfFHZtJtiaSGQu0oCJA8SmRcK6A== module-definition@^3.3.1: - version "3.3.1" - resolved "https://registry.yarnpkg.com/module-definition/-/module-definition-3.3.1.tgz#fedef71667713e36988b93d0626a4fe7b35aebfc" - integrity sha512-kLidGPwQ2yq484nSD+D3JoJp4Etc0Ox9P0L34Pu/cU4X4HcG7k7p62XI5BBuvURWMRX3RPyuhOcBHbKus+UH4A== + version "3.4.0" + resolved "https://registry.yarnpkg.com/module-definition/-/module-definition-3.4.0.tgz#953a3861f65df5e43e80487df98bb35b70614c2b" + integrity sha512-XxJ88R1v458pifaSkPNLUTdSPNVGMP2SXVncVmApGO+gAfrLANiYe6JofymCzVceGOMwQE2xogxBSc8uB7XegA== dependencies: - ast-module-types "^2.7.1" + ast-module-types "^3.0.0" node-source-walk "^4.0.0" module-lookup-amd@^7.0.1: @@ -7317,10 +7111,10 @@ resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.3.tgz#fd8e8b7aa761fe807dba2d1b98fb7241bb724a25" integrity sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w== -nanoid@^3.2.0: - version "3.3.1" - resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.1.tgz#6347a18cac88af88f58af0b3594b723d5e99bb35" - integrity sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw== +nanoid@^3.3.3: + version "3.3.4" + resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.4.tgz#730b67e3cd09e2deacf03c027c81c9d9dbc5e8ab" + integrity sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw== natural-compare-lite@^1.4.0: version "1.4.0" @@ -7342,10 +7136,10 @@ resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f" integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw== -next-tick@~1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.0.0.tgz#ca86d1fe8828169b0120208e3dc8424b9db8342c" - integrity sha1-yobR/ogoFpsBICCOPchCS524NCw= +next-tick@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.1.0.tgz#1836ee30ad56d67ef281b22bd199f709449b35eb" + integrity sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ== nock@^13.2.4: version "13.2.4" @@ -7370,29 +7164,24 @@ whatwg-url "^5.0.0" node-gyp-build@^4.2.0, node-gyp-build@^4.3.0: - version "4.3.0" - resolved "https://registry.yarnpkg.com/node-gyp-build/-/node-gyp-build-4.3.0.tgz#9f256b03e5826150be39c764bf51e993946d71a3" - integrity sha512-iWjXZvmboq0ja1pUGULQBexmxq8CV4xBhX7VDOTbL7ZR4FOowwY/VOtRxBN/yKxmdGoIp4j5ysNT4u3S2pDQ3Q== + version "4.4.0" + resolved "https://registry.yarnpkg.com/node-gyp-build/-/node-gyp-build-4.4.0.tgz#42e99687ce87ddeaf3a10b99dc06abc11021f3f4" + integrity sha512-amJnQCcgtRVw9SvoebO3BKGESClrfXGCUTX9hSn1OuGQTQBOZmVd0Z0OlecpuRksKvbsUqALE8jls/ErClAPuQ== node-int64@^0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b" integrity sha1-h6kGXNs1XTGC2PlM4RGIuCXGijs= -node-releases@^2.0.2: - version "2.0.2" - resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.2.tgz#7139fe71e2f4f11b47d4d2986aaf8c48699e0c01" - integrity sha512-XxYDdcQ6eKqp/YjI+tb2C5WM2LgjnZrfYg4vgQt49EK268b6gYCHsBLrK2qvJo4FmCtqmKezb0WZFK4fkrZNsg== - node-releases@^2.0.3: version "2.0.4" resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.4.tgz#f38252370c43854dc48aa431c766c6c398f40476" integrity sha512-gbMzqQtTtDz/00jQzZ21PQzdI9PyLYqUSvD0p3naOhX4odFji0ZxYdnVwPTxmSwkmxhcFImpozceidSG+AgoPQ== -node-source-walk@^4.0.0, node-source-walk@^4.2.0: - version "4.2.0" - resolved "https://registry.yarnpkg.com/node-source-walk/-/node-source-walk-4.2.0.tgz#c2efe731ea8ba9c03c562aa0a9d984e54f27bc2c" - integrity sha512-hPs/QMe6zS94f5+jG3kk9E7TNm4P2SulrKiLWMzKszBfNZvL/V6wseHlTd7IvfW0NZWqPtK3+9yYNr+3USGteA== +node-source-walk@^4.0.0, node-source-walk@^4.2.0, node-source-walk@^4.2.2: + version "4.3.0" + resolved "https://registry.yarnpkg.com/node-source-walk/-/node-source-walk-4.3.0.tgz#8336b56cfed23ac5180fe98f1e3bb6b11fd5317c" + integrity sha512-8Q1hXew6ETzqKRAs3jjLioSxNfT1cx74ooiF8RlAONwVMcfq+UdzLC2eB5qcPldUxaE5w3ytLkrmV1TGddhZTA== dependencies: "@babel/parser" "^7.0.0" @@ -7436,12 +7225,12 @@ resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863" integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM= -object-inspect@^1.11.0, object-inspect@^1.9.0: +object-inspect@^1.12.0, object-inspect@^1.9.0: version "1.12.0" resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.0.tgz#6e2c120e868fd1fd18cb4f18c31741d0d6e776f0" integrity sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g== -object-keys@^1.0.12, object-keys@^1.1.1: +object-keys@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e" integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA== @@ -7498,10 +7287,10 @@ dependencies: http-https "^1.0.0" -on-finished@~2.3.0: - version "2.3.0" - resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.3.0.tgz#20f1336481b083cd75337992a16971aa2d906947" - integrity sha1-IPEzZIGwg811M3mSoWlxqi2QaUc= +on-finished@2.4.1: + version "2.4.1" + resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.4.1.tgz#58c8c44116e54845ad57f14ab10b03533184ac3f" + integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg== dependencies: ee-first "1.1.1" @@ -7692,9 +7481,9 @@ safe-buffer "^5.1.1" parse-headers@^2.0.0: - version "2.0.4" - resolved "https://registry.yarnpkg.com/parse-headers/-/parse-headers-2.0.4.tgz#9eaf2d02bed2d1eff494331ce3df36d7924760bf" - integrity sha512-psZ9iZoCNFLrgRjZ1d8mn0h9WRqJwFxM9q3x7iUjN/YT2OksthDJ5TiPCu2F38kS4zutqfW+YdVVkBZZx3/1aw== + version "2.0.5" + resolved "https://registry.yarnpkg.com/parse-headers/-/parse-headers-2.0.5.tgz#069793f9356a54008571eb7f9761153e6c770da9" + integrity sha512-ft3iAoLOB/MlwbNXgzy43SWGP6sQki2jQvAyBg/zDFAgr9bfNWZIUj42Kw2eJIl8kEi4PbgE6U1Zau/HwI75HA== parse-json@^5.0.0, parse-json@^5.2.0: version "5.2.0" @@ -7792,7 +7581,7 @@ resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c" integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ== -picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.2, picomatch@^2.2.3, picomatch@^2.3.0: +picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.2, picomatch@^2.2.3, picomatch@^2.3.0, picomatch@^2.3.1: version "2.3.1" resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42" integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== @@ -7851,9 +7640,9 @@ integrity sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA== postcss-selector-parser@^6.0.2: - version "6.0.9" - resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.9.tgz#ee71c3b9ff63d9cd130838876c13a2ec1a992b2f" - integrity sha512-UO3SgnZOVTwu4kyLR22UQ1xZh086RyNZppb7lLAKBFK8a32ttG5i87Y/P3+2bRSjZNyJ1B7hfFNo273tKe9YxQ== + version "6.0.10" + resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz#79b61e2c0d1bfc2602d549e11d0876256f8df88d" + integrity sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w== dependencies: cssesc "^3.0.0" util-deprecate "^1.0.2" @@ -7884,12 +7673,12 @@ picocolors "^0.2.1" source-map "^0.6.1" -postcss@^8.1.7, postcss@^8.2.13: - version "8.4.6" - resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.4.6.tgz#c5ff3c3c457a23864f32cb45ac9b741498a09ae1" - integrity sha512-OovjwIzs9Te46vlEx7+uXB0PLijpwjXGKXjVGGPIGubGpq7uh5Xgf6D6FiJ/SzJMBosHDp6a2hiXOS97iBXcaA== +postcss@^8.1.7, postcss@^8.4.6: + version "8.4.13" + resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.4.13.tgz#7c87bc268e79f7f86524235821dfdf9f73e5d575" + integrity sha512-jtL6eTBrza5MPzy8oJLFuUscHDXTV5KcLlqAWHl5q5WYRfnNRGSmOZmOZ1T6Gy7A99mOZfqungmZMpMmCVJ8ZA== dependencies: - nanoid "^3.2.0" + nanoid "^3.3.3" picocolors "^1.0.0" source-map-js "^1.0.2" @@ -7932,12 +7721,7 @@ resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-2.0.0.tgz#e92434bfa5ea8c19f41cdfd401d741a3c819d897" integrity sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc= -"prettier@^1.18.2 || ^2.0.0": - version "2.5.1" - resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.5.1.tgz#fff75fa9d519c54cf0fce328c1017d94546bc56a" - integrity sha512-vBZcPRUR5MZJwoyi3ZoyQlc1rXeEck8KgeC9AwwOn+exuxLxq5toTRDTSaVrXHxelDMHy9zlicw8u66yxoSUFg== - -prettier@^2.6.2: +"prettier@^1.18.2 || ^2.0.0", prettier@^2.6.2: version "2.6.2" resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.6.2.tgz#e26d71a18a74c3d0f0597f55f01fb6c06c206032" integrity sha512-PkUpF+qoXTqhOeWL9fu7As8LXsIUZ1WYaJiY/a7McAQzxjk82OF0tibkFXVCDImZtWxbvojFjerkiLb0/q8mew== @@ -7959,11 +7743,6 @@ dependencies: parse-ms "^2.1.0" -printj@~1.3.1: - version "1.3.1" - resolved "https://registry.yarnpkg.com/printj/-/printj-1.3.1.tgz#9af6b1d55647a1587ac44f4c1654a4b95b8e12cb" - integrity sha512-GA3TdL8szPK4AQ2YnOe/b+Y1jUFwmmGMMK/qbY7VcE3Z7FU8JstbKiKRzO6CIiAKPhTO8m01NoQ0V5f3jc4OGg== - process-nextick-args@~2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2" @@ -8068,10 +7847,12 @@ dependencies: escape-goat "^2.0.0" -qs@6.9.7: - version "6.9.7" - resolved "https://registry.yarnpkg.com/qs/-/qs-6.9.7.tgz#4610846871485e1e048f44ae3b94033f0e675afe" - integrity sha512-IhMFgUmuNpyRfxA90umL7ByLlgRXu6tIfKPpF5TmcfRLlLCckfP/g3IQmju6jjpu+Hh8rA+2p6A27ZSPOOHdKw== +qs@6.10.3: + version "6.10.3" + resolved "https://registry.yarnpkg.com/qs/-/qs-6.10.3.tgz#d6cde1b2ffca87b5aa57889816c5f81535e22e8e" + integrity sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ== + dependencies: + side-channel "^1.0.4" qs@~6.5.2: version "6.5.3" @@ -8117,13 +7898,13 @@ resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.1.tgz#3cf37023d199e1c24d1a55b84800c2f3e6468031" integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg== -raw-body@2.4.3: - version "2.4.3" - resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.4.3.tgz#8f80305d11c2a0a545c2d9d89d7a0286fcead43c" - integrity sha512-UlTNLIcu0uzb4D2f4WltY6cVjLi+/jEN4lgEUj3E04tpMDpUlkBo/eSn6zou9hum2VMNpCCUone0O0WeJim07g== +raw-body@2.5.1: + version "2.5.1" + resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.5.1.tgz#fe1b1628b181b700215e5fd42389f98b71392857" + integrity sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig== dependencies: bytes "3.1.2" - http-errors "1.8.1" + http-errors "2.0.0" iconv-lite "0.4.24" unpipe "1.0.0" @@ -8214,13 +7995,14 @@ dependencies: "@babel/runtime" "^7.8.4" -regexp.prototype.flags@^1.3.1: - version "1.4.1" - resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.4.1.tgz#b3f4c0059af9e47eca9f3f660e51d81307e72307" - integrity sha512-pMR7hBVUUGI7PMA37m2ofIdQCsomVnas+Jn5UPGAHQ+/LlwKm/aTLJHdasmHRzlfeZwHiAOaRSo2rbBDm3nNUQ== +regexp.prototype.flags@^1.4.1: + version "1.4.3" + resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz#87cab30f80f66660181a3bb7bf5981a872b367ac" + integrity sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA== dependencies: call-bind "^1.0.2" define-properties "^1.1.3" + functions-have-names "^1.2.2" regexpp@^3.0.0, regexpp@^3.2.0: version "3.2.0" @@ -8421,9 +8203,9 @@ estree-walker "^0.6.1" rollup@^2.71.1: - version "2.71.1" - resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.71.1.tgz#82b259af7733dfd1224a8171013aaaad02971a22" - integrity sha512-lMZk3XfUBGjrrZQpvPSoXcZSfKcJ2Bgn+Z0L1MoW2V8Wh7BVM+LOBJTPo16yul2MwL59cXedzW1ruq3rCjSRgw== + version "2.72.0" + resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.72.0.tgz#f94280b003bcf9f2f1f2594059a9db5abced371e" + integrity sha512-KqtR2YcO35/KKijg4nx4STO3569aqCUeGRkKWnJ6r+AvBBrVY9L4pmf4NHVrQr4mTOq6msbohflxr2kpihhaOA== optionalDependencies: fsevents "~2.3.2" @@ -8439,13 +8221,6 @@ dependencies: queue-microtask "^1.2.2" -rxjs@^7.2.0: - version "7.5.4" - resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.5.4.tgz#3d6bd407e6b7ce9a123e76b1e770dc5761aa368d" - integrity sha512-h5M3Hk78r6wAheJF0a5YahB1yRQKCsZ4MsGdZ5O9ETbVtjPcScGfrMmoOq7EBsCRzd4BDkvDJ7ogP8Sz5tTFiQ== - dependencies: - tslib "^2.1.0" - rxjs@^7.5.5: version "7.5.5" resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.5.5.tgz#2ebad89af0f560f460ad5cc4213219e1f7dd4e9f" @@ -8518,38 +8293,31 @@ resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d" integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw== -semver@^7.0.0: +semver@^7.0.0, semver@^7.3.4, semver@^7.3.5: version "7.3.7" resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.7.tgz#12c5b649afdbf9049707796e22a4028814ce523f" integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g== dependencies: lru-cache "^6.0.0" -semver@^7.3.4, semver@^7.3.5: - version "7.3.5" - resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7" - integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ== - dependencies: - lru-cache "^6.0.0" - -send@0.17.2: - version "0.17.2" - resolved "https://registry.yarnpkg.com/send/-/send-0.17.2.tgz#926622f76601c41808012c8bf1688fe3906f7820" - integrity sha512-UJYB6wFSJE3G00nEivR5rgWp8c2xXvJ3OPWPhmuteU0IKj8nKbG3DrjiOmLwpnHGYWAVwA69zmTm++YG0Hmwww== +send@0.18.0: + version "0.18.0" + resolved "https://registry.yarnpkg.com/send/-/send-0.18.0.tgz#670167cc654b05f5aa4a767f9113bb371bc706be" + integrity sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg== dependencies: debug "2.6.9" - depd "~1.1.2" - destroy "~1.0.4" + depd "2.0.0" + destroy "1.2.0" encodeurl "~1.0.2" escape-html "~1.0.3" etag "~1.8.1" fresh "0.5.2" - http-errors "1.8.1" + http-errors "2.0.0" mime "1.6.0" ms "2.1.3" - on-finished "~2.3.0" + on-finished "2.4.1" range-parser "~1.2.1" - statuses "~1.5.0" + statuses "2.0.1" serialize-javascript@6.0.0: version "6.0.0" @@ -8558,15 +8326,15 @@ dependencies: randombytes "^2.1.0" -serve-static@1.14.2: - version "1.14.2" - resolved "https://registry.yarnpkg.com/serve-static/-/serve-static-1.14.2.tgz#722d6294b1d62626d41b43a013ece4598d292bfa" - integrity sha512-+TMNA9AFxUEGuC0z2mevogSnn9MXKb4fa7ngeRMJaaGv8vTwnIEkKi+QGvPt33HSnf8pRS+WGM0EbMtCJLKMBQ== +serve-static@1.15.0: + version "1.15.0" + resolved "https://registry.yarnpkg.com/serve-static/-/serve-static-1.15.0.tgz#faaef08cffe0a1a62f60cad0c4e513cff0ac9540" + integrity sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g== dependencies: encodeurl "~1.0.2" escape-html "~1.0.3" parseurl "~1.3.3" - send "0.17.2" + send "0.18.0" servify@^0.1.12: version "0.1.12" @@ -8714,17 +8482,12 @@ buffer-from "^1.0.0" source-map "^0.6.0" -source-map@^0.5.0: - version "0.5.7" - resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc" - integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w= - source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1: version "0.6.1" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== -sourcemap-codec@^1.4.4: +sourcemap-codec@^1.4.8: version "1.4.8" resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4" integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA== @@ -8761,10 +8524,10 @@ dependencies: escape-string-regexp "^2.0.0" -"statuses@>= 1.5.0 < 2", statuses@~1.5.0: - version "1.5.0" - resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c" - integrity sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow= +statuses@2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/statuses/-/statuses-2.0.1.tgz#55cb000ccf1d48728bd23c685a063998cf1a1b63" + integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ== stream-shift@^1.0.0: version "1.0.1" @@ -8794,34 +8557,36 @@ strip-ansi "^6.0.1" string.prototype.matchall@^4.0.6: - version "4.0.6" - resolved "https://registry.yarnpkg.com/string.prototype.matchall/-/string.prototype.matchall-4.0.6.tgz#5abb5dabc94c7b0ea2380f65ba610b3a544b15fa" - integrity sha512-6WgDX8HmQqvEd7J+G6VtAahhsQIssiZ8zl7zKh1VDMFyL3hRTJP4FTNA3RbIp2TOQ9AYNDcc7e3fH0Qbup+DBg== + version "4.0.7" + resolved "https://registry.yarnpkg.com/string.prototype.matchall/-/string.prototype.matchall-4.0.7.tgz#8e6ecb0d8a1fb1fda470d81acecb2dba057a481d" + integrity sha512-f48okCX7JiwVi1NXCVWcFnZgADDC/n2vePlQ/KUCNqCikLLilQvwjMO8+BHVKvgzH0JB0J9LEPgxOGT02RoETg== dependencies: call-bind "^1.0.2" define-properties "^1.1.3" es-abstract "^1.19.1" get-intrinsic "^1.1.1" - has-symbols "^1.0.2" + has-symbols "^1.0.3" internal-slot "^1.0.3" - regexp.prototype.flags "^1.3.1" + regexp.prototype.flags "^1.4.1" side-channel "^1.0.4" string.prototype.trimend@^1.0.4: - version "1.0.4" - resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz#e75ae90c2942c63504686c18b287b4a0b1a45f80" - integrity sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A== + version "1.0.5" + resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.5.tgz#914a65baaab25fbdd4ee291ca7dde57e869cb8d0" + integrity sha512-I7RGvmjV4pJ7O3kdf+LXFpVfdNOxtCW/2C8f6jNiW4+PQchwxkCDzlk1/7p+Wl4bqFIZeF47qAHXLuHHWKAxog== dependencies: call-bind "^1.0.2" - define-properties "^1.1.3" + define-properties "^1.1.4" + es-abstract "^1.19.5" string.prototype.trimstart@^1.0.4: - version "1.0.4" - resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz#b36399af4ab2999b4c9c648bd7a3fb2bb26feeed" - integrity sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw== + version "1.0.5" + resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.5.tgz#5466d93ba58cfa2134839f81d7f42437e8c01fef" + integrity sha512-THx16TJCGlsN0o6dl2o6ncWUsdgnLRSA23rRE5pyGBw/mLr3Ej/R2LaqCtgP8VNMGZsvMWnf9ooZPyY2bHvUFg== dependencies: call-bind "^1.0.2" - define-properties "^1.1.3" + define-properties "^1.1.4" + es-abstract "^1.19.5" string_decoder@^1.1.1: version "1.3.0" @@ -9113,7 +8878,7 @@ v8-compile-cache-lib "^3.0.0" yn "3.1.1" -tsconfig-paths@^3.14.1: +tsconfig-paths@^3.10.1, tsconfig-paths@^3.14.1: version "3.14.1" resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-3.14.1.tgz#ba0734599e8ea36c862798e920bcf163277b137a" integrity sha512-fxDhWnFSLt3VuTwtvJt5fpwxBHg5AdKWMsgcPOOIilyjymcYVZoCQF8fvFRezCNfblEXmi+PcM1eYHeOAgXCOQ== @@ -9129,9 +8894,9 @@ integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== tslib@^2.1.0: - version "2.3.1" - resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.3.1.tgz#e8a335add5ceae51aa261d32a490158ef042ef01" - integrity sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw== + version "2.4.0" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.4.0.tgz#7cecaa7f073ce680a05847aa77be941098f36dc3" + integrity sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ== tsutils@^3.21.0: version "3.21.0" @@ -9216,7 +8981,7 @@ dependencies: is-typedarray "^1.0.0" -typescript@^3.9.5, typescript@^3.9.7: +typescript@^3.9.10, typescript@^3.9.5, typescript@^3.9.7: version "3.9.10" resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.9.10.tgz#70f3910ac7a51ed6bef79da7800690b19bf778b8" integrity sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q== @@ -9227,9 +8992,9 @@ integrity sha512-9ia/jWHIEbo49HfjrLGfKbZSuWo9iTMwXO+Ca3pRsSpbsMbc7/IU8NKdCZVRRBafVPGnoJeFL76ZOAA84I9fEg== uglify-js@^3.1.4: - version "3.15.1" - resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.15.1.tgz#9403dc6fa5695a6172a91bc983ea39f0f7c9086d" - integrity sha512-FAGKF12fWdkpvNJZENacOH0e/83eG6JyVQyanIJaBXCN1J11TUQv1T1/z8S+Z0CG0ZPk1nPcreF/c7lrTd0TEQ== + version "3.15.4" + resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.15.4.tgz#fa95c257e88f85614915b906204b9623d4fa340d" + integrity sha512-vMOPGDuvXecPs34V74qDKk4iJ/SN4vL3Ow/23ixafENYvtrNvtbcgUeugTcUGRGsOF/5fU8/NYSL5Hyb3l1OJA== ultron@~1.1.0: version "1.1.1" @@ -9237,13 +9002,13 @@ integrity sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og== unbox-primitive@^1.0.1: - version "1.0.1" - resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.1.tgz#085e215625ec3162574dc8859abee78a59b14471" - integrity sha512-tZU/3NqK3dA5gpE1KtyiJUrEB0lxnGkMFHptJ7q6ewdZ8s12QrODwNbhIJStmJkd1QDXa1NRA8aF2A1zk/Ypyw== + version "1.0.2" + resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.2.tgz#29032021057d5e6cdbd08c5129c226dff8ed6f9e" + integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw== dependencies: - function-bind "^1.1.1" - has-bigints "^1.0.1" - has-symbols "^1.0.2" + call-bind "^1.0.2" + has-bigints "^1.0.2" + has-symbols "^1.0.3" which-boxed-primitive "^1.0.2" unicode-canonical-property-names-ecmascript@^2.0.0: @@ -9353,9 +9118,9 @@ integrity sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k= utf-8-validate@^5.0.2: - version "5.0.8" - resolved "https://registry.yarnpkg.com/utf-8-validate/-/utf-8-validate-5.0.8.tgz#4a735a61661dbb1c59a0868c397d2fe263f14e58" - integrity sha512-k4dW/Qja1BYDl2qD4tOMB9PFVha/UJtxTc1cXYOe3WwA/2m0Yn4qB7wLMpJyLJ/7DR0XnTut3HsCSzDT4ZvKgA== + version "5.0.9" + resolved "https://registry.yarnpkg.com/utf-8-validate/-/utf-8-validate-5.0.9.tgz#ba16a822fbeedff1a58918f2a6a6b36387493ea3" + integrity sha512-Yek7dAy0v3Kl0orwMlvi7TPtiCNrdfHNd7Gcc/pLq4BLXqfAmd0J7OWMizUQnTTJsyjKn02mU7anqwfmUP4J8Q== dependencies: node-gyp-build "^4.3.0" @@ -9402,9 +9167,9 @@ integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A== v8-compile-cache-lib@^3.0.0: - version "3.0.0" - resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.0.tgz#0582bcb1c74f3a2ee46487ceecf372e46bce53e8" - integrity sha512-mpSYqfsFvASnSn5qMiwrr4VKfumbPyONLCOPmsR3A6pTY/r0+tSaVbgPWSAIuzbk3lCTa+FForeTiO+wBQGkjA== + version "3.0.1" + resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf" + integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg== v8-compile-cache@^2.0.3: version "2.3.0" @@ -9973,9 +9738,9 @@ integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w== yargs-parser@^21.0.0: - version "21.0.0" - resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.0.0.tgz#a485d3966be4317426dd56bdb6a30131b281dc55" - integrity sha512-z9kApYUOCwoeZ78rfRYYWdiU/iNL6mwwYlkkZfJoyMR1xps+NEBX5X7XmRpxkZHhXJ6+Ey00IwKxBBSW9FIjyA== + version "21.0.1" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.0.1.tgz#0267f286c877a4f0f728fceb6f8a3e4cb95c6e35" + integrity sha512-9BK1jFpLzJROCI5TzwZL/TU4gqjK5xiHV/RfWLOahrjAko/e4DJkRDZQXfvqAsiZzzYhgAzbgz6lg48jcm4GLg== yargs-unparser@2.0.0: version "2.0.0" @@ -10000,20 +9765,7 @@ y18n "^5.0.5" yargs-parser "^20.2.2" -yargs@^17.0.0, yargs@^17.3.1: - version "17.3.1" - resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.3.1.tgz#da56b28f32e2fd45aefb402ed9c26f42be4c07b9" - integrity sha512-WUANQeVgjLbNsEmGk20f+nlHgOqzRFpiGWVaBrYGYIGANIIu3lWjoyi0fNlFmJkvfhCZ6BXINe7/W2O2bV4iaA== - dependencies: - cliui "^7.0.2" - escalade "^3.1.1" - get-caller-file "^2.0.5" - require-directory "^2.1.1" - string-width "^4.2.3" - y18n "^5.0.5" - yargs-parser "^21.0.0" - -yargs@^17.4.1: +yargs@^17.0.0, yargs@^17.3.1, yargs@^17.4.1: version "17.4.1" resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.4.1.tgz#ebe23284207bb75cee7c408c33e722bfb27b5284" integrity sha512-WSZD9jgobAg3ZKuCQZSa3g9QOJeCCqLoLAykiWgmXnDo9EPnn4RPf5qVTtzgOx66o6/oqhcA5tHtJXpG8pMt3g== -- gitstuff