difftreelog
CORE-337 Rewrite set limits
in: master
9 files changed
pallets/common/src/erc.rsdiffbeforeafterboth--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -16,10 +16,11 @@
use evm_coder::{solidity_interface, types::*, execution::{Result, Error}};
pub use pallet_evm::{PrecompileOutput, PrecompileResult, account::CrossAccountId};
-use pallet_evm_coder_substrate::{dispatch_to_evm, SubstrateRecorder};
+use pallet_evm_coder_substrate::dispatch_to_evm;
use sp_core::{H160, U256};
use sp_std::vec::Vec;
-use up_data_structs::Property;
+use up_data_structs::{Property, SponsoringRateLimit};
+use alloc::format;
use crate::{Pallet, CollectionHandle, Config, CollectionProperties};
@@ -87,37 +88,53 @@
Ok(())
}
- fn set_limits(
- &self,
+ fn set_limit(
+ &mut self,
caller: caller,
- limits_json: string,
+ limit: string,
+ value: string,
) -> Result<void> {
- // let mut collection = collection_from_address::<T>(self.contract_address(caller).unwrap(), self.1.gas_left())?;
- // check_is_owner(caller, &collection)?;
+ check_is_owner(caller, self)?;
+ let mut limits = self.limits.clone();
- // let limits = serde_json_core::from_str(limits_json.as_ref())
- // .map_err(|e| Error::Revert(format!("Parse JSON error: {}", e)))?;
- // collection.limits = limits.0;
- // collection.save().map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)?;
+ match limit.as_str() {
+ "accountTokenOwnershipLimit" => {
+ limits.account_token_ownership_limit = parse_int(value)?;
+ },
+ "sponsoredDataSize" => {
+ limits.sponsored_data_size = parse_int(value)?;
+ },
+ "sponsoredDataRateLimit" => {
+ limits.sponsored_data_rate_limit = Some(SponsoringRateLimit::Blocks(parse_int(value)?.unwrap()));
+ },
+ "tokenLimit" => {
+ limits.token_limit = parse_int(value)?;
+ },
+ "sponsorTransferTimeout" => {
+ limits.sponsor_transfer_timeout = parse_int(value)?;
+ },
+ "sponsorApproveTimeout" => {
+ limits.sponsor_approve_timeout = parse_int(value)?;
+ },
+ "ownerCanTransfer" => {
+ limits.owner_can_transfer = parse_bool(value)?;
+ },
+ "ownerCanDestroy" => {
+ limits.owner_can_destroy = parse_bool(value)?;
+ },
+ "transfersEnabled" => {
+ limits.transfers_enabled = parse_bool(value)?;
+ },
+ _ => return Err(Error::Revert(format!("Unknown limit \"{}\"", limit)))
+ }
+ self.limits = limits;
+ save(self);
Ok(())
}
fn contract_address(&self, _caller: caller) -> Result<address> {
Ok(crate::eth::collection_id_to_address(self.id))
}
-}
-
-fn collection_from_address<T: Config>(
- collection_address: address,
- gas_limit: u64
-) -> Result<CollectionHandle<T>> {
- let collection_id = crate::eth::map_eth_to_id(&collection_address)
- .ok_or(Error::Revert("Contract is not an unique collection".into()))?;
- let recorder = <SubstrateRecorder<T>>::new(gas_limit);
- let collection =
- CollectionHandle::new_with_recorder(collection_id, recorder)
- .ok_or(Error::Revert("Create collection handle error".into()))?;
- Ok(collection)
}
fn check_is_owner<T: Config>(caller: caller, collection: &CollectionHandle<T>) -> Result<()> {
@@ -130,4 +147,16 @@
fn save<T: Config>(collection: &CollectionHandle<T>) {
<crate::CollectionById<T>>::insert(collection.id, collection.collection.clone());
+}
+
+fn parse_int(value: string) -> Result<Option<u32>> {
+ value.parse::<u32>()
+ .map_err(|e| Error::Revert(format!("Int value \"{}\" parse error: {}", value, e)))
+ .map(|value| Some(value))
+}
+
+fn parse_bool(value: string) -> Result<Option<bool>> {
+ value.parse::<bool>()
+ .map_err(|e| Error::Revert(format!("Bool value \"{}\" parse error: {}", value, e)))
+ .map(|value| Some(value))
}
\ No newline at end of file
pallets/nonfungible/src/stubs/UniqueNFT.rawdiffbeforeafterbothbinary blob — no preview
pallets/nonfungible/src/stubs/UniqueNFT.soldiffbeforeafterboth--- a/pallets/nonfungible/src/stubs/UniqueNFT.sol
+++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol
@@ -51,67 +51,6 @@
event MintingFinished();
}
-// Selector: 38e33c60
-contract Collection is Dummy, ERC165 {
- // Selector: setCollectionProperty(string,bytes) 2f073f66
- function setCollectionProperty(string memory key, bytes memory value)
- public
- {
- require(false, stub_error);
- key;
- value;
- dummy = 0;
- }
-
- // Selector: deleteCollectionProperty(string) 7b7debce
- function deleteCollectionProperty(string memory key) public {
- require(false, stub_error);
- key;
- dummy = 0;
- }
-
- // Throws error if key not found
- //
- // Selector: collectionProperty(string) cf24fd6d
- function collectionProperty(string memory key)
- public
- view
- returns (bytes memory)
- {
- require(false, stub_error);
- key;
- dummy;
- return hex"";
- }
-
- // Selector: ethSetSponsor(address) 8f9af356
- function ethSetSponsor(address sponsor) public {
- require(false, stub_error);
- sponsor;
- dummy = 0;
- }
-
- // Selector: ethConfirmSponsorship() a8580d1a
- function ethConfirmSponsorship() public {
- require(false, stub_error);
- dummy = 0;
- }
-
- // Selector: setLimits(string) 72cb345d
- function setLimits(string memory limitsJson) public view {
- require(false, stub_error);
- limitsJson;
- dummy;
- }
-
- // Selector: contractAddress() f6b4dfb4
- function contractAddress() public view returns (address) {
- require(false, stub_error);
- dummy;
- return 0x0000000000000000000000000000000000000000;
- }
-}
-
// Selector: 41369377
contract TokenProperties is Dummy, ERC165 {
// Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa
@@ -441,6 +380,68 @@
}
}
+// Selector: f5652829
+contract Collection is Dummy, ERC165 {
+ // Selector: setCollectionProperty(string,bytes) 2f073f66
+ function setCollectionProperty(string memory key, bytes memory value)
+ public
+ {
+ require(false, stub_error);
+ key;
+ value;
+ dummy = 0;
+ }
+
+ // Selector: deleteCollectionProperty(string) 7b7debce
+ function deleteCollectionProperty(string memory key) public {
+ require(false, stub_error);
+ key;
+ dummy = 0;
+ }
+
+ // Throws error if key not found
+ //
+ // Selector: collectionProperty(string) cf24fd6d
+ function collectionProperty(string memory key)
+ public
+ view
+ returns (bytes memory)
+ {
+ require(false, stub_error);
+ key;
+ dummy;
+ return hex"";
+ }
+
+ // Selector: ethSetSponsor(address) 8f9af356
+ function ethSetSponsor(address sponsor) public {
+ require(false, stub_error);
+ sponsor;
+ dummy = 0;
+ }
+
+ // Selector: ethConfirmSponsorship() a8580d1a
+ function ethConfirmSponsorship() public {
+ require(false, stub_error);
+ dummy = 0;
+ }
+
+ // Selector: setLimit(string,string) bf4d2014
+ function setLimit(string memory limit, string memory value) public {
+ require(false, stub_error);
+ limit;
+ value;
+ dummy = 0;
+ }
+
+ // Selector: contractAddress() f6b4dfb4
+ function contractAddress() public view returns (address) {
+ require(false, stub_error);
+ dummy;
+ return 0x0000000000000000000000000000000000000000;
+ }
+}
+
contract UniqueNFT is
Dummy,
ERC165,
pallets/unique/src/eth/mod.rsdiffbeforeafterboth--- a/pallets/unique/src/eth/mod.rs
+++ b/pallets/unique/src/eth/mod.rs
@@ -26,7 +26,7 @@
};
use frame_support::traits::Get;
use sp_core::H160;
- use pallet_common::{CollectionHandle, CollectionById};
+ use pallet_common::CollectionById;
use sp_std::vec::Vec;
use alloc::format;
primitives/data-structs/src/lib.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617#![cfg_attr(not(feature = "std"), no_std)]1819use core::{20 convert::{TryFrom, TryInto},21 fmt,22};23use frame_support::{24 storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet},25 traits::Get,26 parameter_types,27};2829#[cfg(feature = "serde")]30use serde::{Serialize, Deserialize};3132use sp_core::U256;33use sp_runtime::{ArithmeticError, sp_std::prelude::Vec, Permill};34use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};35use frame_support::{BoundedVec, traits::ConstU32};36use derivative::Derivative;37use scale_info::TypeInfo;3839pub mod rmrk;4041// RMRK42use rmrk::{43 CollectionInfo, NftInfo, ResourceInfo, PropertyInfo, BaseInfo, PartType, Theme, ThemeProperty,44};45pub use rmrk::{46 primitives::{47 CollectionId as RmrkCollectionId, NftId as RmrkNftId, BaseId as RmrkBaseId,48 PartId as RmrkPartId, ResourceId as RmrkResourceId,49 },50 NftChild as RmrkNftChild, AccountIdOrCollectionNftTuple as RmrkAccountIdOrCollectionNftTuple,51 FixedPart as RmrkFixedPart, SlotPart as RmrkSlotPart, EquippableList as RmrkEquippableList,52 BasicResource as RmrkBasicResource, ComposableResource as RmrkComposableResource, SlotResource as RmrkSlotResource,53};5455mod bounded;56pub mod budget;57pub mod mapping;58mod migration;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;6364pub const MAX_TOKEN_OWNERSHIP: u32 = if cfg!(not(feature = "limit-testing")) {65 100_00066} else {67 1068};69pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {70 100_00071} else {72 1073};74pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {75 204876} else {77 1078};79pub const COLLECTION_ADMINS_LIMIT: u32 = 5;80pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX;81pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {82 1_000_00083} else {84 1085};8687// Timeouts for item types in passed blocks88pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;89pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;90pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;9192pub const SPONSOR_APPROVE_TIMEOUT: u32 = 5;9394// Schema limits95pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 8192;96pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 8192;97pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 32768;9899pub const COLLECTION_FIELD_LIMIT: u32 = CONST_ON_CHAIN_SCHEMA_LIMIT;100101pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;102pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;103pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;104105pub const MAX_PROPERTY_KEY_LENGTH: u32 = 256;106pub const MAX_PROPERTY_VALUE_LENGTH: u32 = 32768;107pub const MAX_PROPERTIES_PER_ITEM: u32 = 64;108109pub const MAX_COLLECTION_PROPERTIES_SIZE: u32 = 40960;110pub const MAX_TOKEN_PROPERTIES_SIZE: u32 = 32768;111112// RMRK constants113pub const RMRK_STRING_LIMIT: u32 = 128;114pub const RMRK_COLLECTION_SYMBOL_LIMIT: u32 = 100;115pub const RMRK_RESOURCE_SYMBOL_LIMIT: u32 = 10;116pub const RMRK_KEY_LIMIT: u32 = 32;117pub const RMRK_VALUE_LIMIT: u32 = 256;118119/// How much items can be created per single120/// create_many call121pub const MAX_ITEMS_PER_BATCH: u32 = 200;122123pub type CustomDataLimit = ConstU32<CUSTOM_DATA_LIMIT>;124125#[derive(126 Encode,127 Decode,128 PartialEq,129 Eq,130 PartialOrd,131 Ord,132 Clone,133 Copy,134 Debug,135 Default,136 TypeInfo,137 MaxEncodedLen,138)]139#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]140pub struct CollectionId(pub u32);141impl EncodeLike<u32> for CollectionId {}142impl EncodeLike<CollectionId> for u32 {}143144#[derive(145 Encode,146 Decode,147 PartialEq,148 Eq,149 PartialOrd,150 Ord,151 Clone,152 Copy,153 Debug,154 Default,155 TypeInfo,156 MaxEncodedLen,157)]158#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]159pub struct TokenId(pub u32);160impl EncodeLike<u32> for TokenId {}161impl EncodeLike<TokenId> for u32 {}162163impl TokenId {164 pub fn try_next(self) -> Result<TokenId, ArithmeticError> {165 self.0166 .checked_add(1)167 .ok_or(ArithmeticError::Overflow)168 .map(Self)169 }170}171172impl From<TokenId> for U256 {173 fn from(t: TokenId) -> Self {174 t.0.into()175 }176}177178impl TryFrom<U256> for TokenId {179 type Error = &'static str;180181 fn try_from(value: U256) -> Result<Self, Self::Error> {182 Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))183 }184}185186#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]187#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]188pub struct TokenData<CrossAccountId> {189 pub properties: Vec<Property>,190 pub owner: Option<CrossAccountId>,191}192193pub struct OverflowError;194impl From<OverflowError> for &'static str {195 fn from(_: OverflowError) -> Self {196 "overflow occured"197 }198}199200pub type DecimalPoints = u8;201202#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]203#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]204pub enum CollectionMode {205 NFT,206 // decimal points207 Fungible(DecimalPoints),208 ReFungible,209}210211impl CollectionMode {212 pub fn id(&self) -> u8 {213 match self {214 CollectionMode::NFT => 1,215 CollectionMode::Fungible(_) => 2,216 CollectionMode::ReFungible => 3,217 }218 }219}220221pub trait SponsoringResolve<AccountId, Call> {222 fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;223}224225#[derive(Encode, Decode, Eq, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]226#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]227pub enum AccessMode {228 Normal,229 AllowList,230}231impl Default for AccessMode {232 fn default() -> Self {233 Self::Normal234 }235}236237#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]238#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]239pub enum SchemaVersion {240 ImageURL,241 Unique,242}243impl Default for SchemaVersion {244 fn default() -> Self {245 Self::ImageURL246 }247}248249#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]250#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]251pub struct Ownership<AccountId> {252 pub owner: AccountId,253 pub fraction: u128,254}255256#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]257#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]258pub enum SponsorshipState<AccountId> {259 /// The fees are applied to the transaction sender260 Disabled,261 Unconfirmed(AccountId),262 /// Transactions are sponsored by specified account263 Confirmed(AccountId),264}265266impl<AccountId> SponsorshipState<AccountId> {267 pub fn sponsor(&self) -> Option<&AccountId> {268 match self {269 Self::Confirmed(sponsor) => Some(sponsor),270 _ => None,271 }272 }273274 pub fn pending_sponsor(&self) -> Option<&AccountId> {275 match self {276 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),277 _ => None,278 }279 }280281 pub fn confirmed(&self) -> bool {282 matches!(self, Self::Confirmed(_))283 }284}285286impl<T> Default for SponsorshipState<T> {287 fn default() -> Self {288 Self::Disabled289 }290}291292/// Used in storage293#[struct_versioning::versioned(version = 2, upper)]294#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]295pub struct Collection<AccountId> {296 pub owner: AccountId,297 pub mode: CollectionMode,298 #[version(..2)]299 pub access: AccessMode,300 pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,301 pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,302 pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,303304 #[version(..2)]305 pub mint_mode: bool,306307 #[version(..2)]308 pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,309310 #[version(..2)]311 pub schema_version: SchemaVersion,312 pub sponsorship: SponsorshipState<AccountId>,313314 pub limits: CollectionLimits,315316 #[version(2.., upper(Default::default()))]317 pub permissions: CollectionPermissions,318319 #[version(..2)]320 pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,321322 #[version(..2)]323 pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,324325 #[version(..2)]326 pub meta_update_permission: MetaUpdatePermission,327}328329/// Used in RPC calls330#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]331#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]332pub struct RpcCollection<AccountId> {333 pub owner: AccountId,334 pub mode: CollectionMode,335 pub name: Vec<u16>,336 pub description: Vec<u16>,337 pub token_prefix: Vec<u8>,338 pub sponsorship: SponsorshipState<AccountId>,339 pub limits: CollectionLimits,340 pub permissions: CollectionPermissions,341 pub token_property_permissions: Vec<PropertyKeyPermission>,342 pub properties: Vec<Property>,343}344345#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Derivative, MaxEncodedLen)]346#[derivative(Debug, Default(bound = ""))]347pub struct CreateCollectionData<AccountId> {348 #[derivative(Default(value = "CollectionMode::NFT"))]349 pub mode: CollectionMode,350 pub access: Option<AccessMode>,351 pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,352 pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,353 pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,354 pub pending_sponsor: Option<AccountId>,355 pub limits: Option<CollectionLimits>,356 pub permissions: Option<CollectionPermissions>,357 pub token_property_permissions: CollectionPropertiesPermissionsVec,358 pub properties: CollectionPropertiesVec,359}360361pub type CollectionPropertiesPermissionsVec =362 BoundedVec<PropertyKeyPermission, ConstU32<MAX_PROPERTIES_PER_ITEM>>;363364pub type CollectionPropertiesVec =365 BoundedVec<Property, ConstU32<MAX_PROPERTIES_PER_ITEM>>;366367/// All fields are wrapped in `Option`s, where None means chain default368#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]369#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]370pub struct CollectionLimits {371 pub account_token_ownership_limit: Option<u32>,372 pub sponsored_data_size: Option<u32>,373374 /// FIXME should we delete this or repurpose it?375 /// None - setVariableMetadata is not sponsored376 /// Some(v) - setVariableMetadata is sponsored377 /// if there is v block between txs378 pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,379 pub token_limit: Option<u32>,380381 // Timeouts for item types in passed blocks382 pub sponsor_transfer_timeout: Option<u32>,383 pub sponsor_approve_timeout: Option<u32>,384 pub owner_can_transfer: Option<bool>,385 pub owner_can_destroy: Option<bool>,386 pub transfers_enabled: Option<bool>,387}388389impl CollectionLimits {390 pub fn account_token_ownership_limit(&self) -> u32 {391 self.account_token_ownership_limit392 .unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)393 .min(MAX_TOKEN_OWNERSHIP)394 }395 pub fn sponsored_data_size(&self) -> u32 {396 self.sponsored_data_size397 .unwrap_or(CUSTOM_DATA_LIMIT)398 .min(CUSTOM_DATA_LIMIT)399 }400 pub fn token_limit(&self) -> u32 {401 self.token_limit402 .unwrap_or(COLLECTION_TOKEN_LIMIT)403 .min(COLLECTION_TOKEN_LIMIT)404 }405 pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {406 self.sponsor_transfer_timeout407 .unwrap_or(default)408 .min(MAX_SPONSOR_TIMEOUT)409 }410 pub fn sponsor_approve_timeout(&self) -> u32 {411 self.sponsor_approve_timeout412 .unwrap_or(SPONSOR_APPROVE_TIMEOUT)413 .min(MAX_SPONSOR_TIMEOUT)414 }415 pub fn owner_can_transfer(&self) -> bool {416 self.owner_can_transfer.unwrap_or(true)417 }418 pub fn owner_can_destroy(&self) -> bool {419 self.owner_can_destroy.unwrap_or(true)420 }421 pub fn transfers_enabled(&self) -> bool {422 self.transfers_enabled.unwrap_or(true)423 }424 pub fn sponsored_data_rate_limit(&self) -> Option<u32> {425 match self426 .sponsored_data_rate_limit427 .unwrap_or(SponsoringRateLimit::SponsoringDisabled)428 {429 SponsoringRateLimit::SponsoringDisabled => None,430 SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),431 }432 }433}434435#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]436#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]437pub struct CollectionPermissions {438 pub access: Option<AccessMode>,439 pub mint_mode: Option<bool>,440 pub nesting: Option<NestingRule>,441}442443impl CollectionPermissions {444 pub fn access(&self) -> AccessMode {445 self.access.unwrap_or(AccessMode::Normal)446 }447 pub fn mint_mode(&self) -> bool {448 self.mint_mode.unwrap_or(false)449 }450 pub fn nesting(&self) -> &NestingRule {451 static DEFAULT: NestingRule = NestingRule::Disabled;452 self.nesting.as_ref().unwrap_or(&DEFAULT)453 }454}455456#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]457#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]458#[derivative(Debug)]459pub enum NestingRule {460 /// No one can nest tokens461 Disabled,462 /// Owner can nest any tokens463 Owner,464 /// Owner can nest tokens from specified collections465 OwnerRestricted(466 #[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]467 #[derivative(Debug(format_with = "bounded::set_debug"))]468 BoundedBTreeSet<CollectionId, ConstU32<16>>,469 ),470}471472#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]473#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]474pub enum SponsoringRateLimit {475 SponsoringDisabled,476 Blocks(u32),477}478479#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]480#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]481#[derivative(Debug)]482pub struct CreateNftData {483 #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]484 #[derivative(Debug(format_with = "bounded::vec_debug"))]485 pub const_data: BoundedVec<u8, CustomDataLimit>,486487 #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]488 #[derivative(Debug(format_with = "bounded::vec_debug"))]489 pub properties: CollectionPropertiesVec,490}491492#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]493#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]494pub struct CreateFungibleData {495 pub value: u128,496}497498#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]499#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]500#[derivative(Debug)]501pub struct CreateReFungibleData {502 #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]503 #[derivative(Debug(format_with = "bounded::vec_debug"))]504 pub const_data: BoundedVec<u8, CustomDataLimit>,505 pub pieces: u128,506}507508#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]509#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]510pub enum MetaUpdatePermission {511 ItemOwner,512 Admin,513 None,514}515516#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]517#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]518pub enum CreateItemData {519 NFT(CreateNftData),520 Fungible(CreateFungibleData),521 ReFungible(CreateReFungibleData),522}523524#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]525#[derivative(Debug)]526pub struct CreateNftExData<CrossAccountId> {527 #[derivative(Debug(format_with = "bounded::vec_debug"))]528 pub properties: CollectionPropertiesVec,529 pub owner: CrossAccountId,530}531532#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]533#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]534pub struct CreateRefungibleExData<CrossAccountId> {535 #[derivative(Debug(format_with = "bounded::vec_debug"))]536 pub const_data: BoundedVec<u8, CustomDataLimit>,537 #[derivative(Debug(format_with = "bounded::map_debug"))]538 pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,539}540541#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]542#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]543pub enum CreateItemExData<CrossAccountId> {544 NFT(545 #[derivative(Debug(format_with = "bounded::vec_debug"))]546 BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,547 ),548 Fungible(549 #[derivative(Debug(format_with = "bounded::map_debug"))]550 BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,551 ),552 /// Many tokens, each may have only one owner553 RefungibleMultipleItems(554 #[derivative(Debug(format_with = "bounded::vec_debug"))]555 BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,556 ),557 /// Single token, which may have many owners558 RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),559}560561impl CreateItemData {562 pub fn data_size(&self) -> usize {563 match self {564 CreateItemData::NFT(data) => data.const_data.len(),565 CreateItemData::ReFungible(data) => data.const_data.len(),566 _ => 0,567 }568 }569}570571impl From<CreateNftData> for CreateItemData {572 fn from(item: CreateNftData) -> Self {573 CreateItemData::NFT(item)574 }575}576577impl From<CreateReFungibleData> for CreateItemData {578 fn from(item: CreateReFungibleData) -> Self {579 CreateItemData::ReFungible(item)580 }581}582583impl From<CreateFungibleData> for CreateItemData {584 fn from(item: CreateFungibleData) -> Self {585 CreateItemData::Fungible(item)586 }587}588589#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]590#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]591pub struct CollectionStats {592 pub created: u32,593 pub destroyed: u32,594 pub alive: u32,595}596597#[derive(Encode, Decode, Clone, Debug)]598#[cfg_attr(feature = "std", derive(PartialEq))]599pub struct PhantomType<T>(core::marker::PhantomData<T>);600601impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {602 type Identity = PhantomType<T>;603604 fn type_info() -> scale_info::Type {605 use scale_info::{606 Type, Path,607 build::{FieldsBuilder, UnnamedFields},608 type_params,609 };610 Type::builder()611 .path(Path::new("up_data_structs", "PhantomType"))612 .type_params(type_params!(T))613 .composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))614 }615}616impl<T> MaxEncodedLen for PhantomType<T> {617 fn max_encoded_len() -> usize {618 0619 }620}621622pub type PropertyKey = BoundedVec<u8, ConstU32<MAX_PROPERTY_KEY_LENGTH>>;623pub type PropertyValue = BoundedVec<u8, ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;624625#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]626#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]627pub struct PropertyPermission {628 pub mutable: bool,629 pub collection_admin: bool,630 pub token_owner: bool,631}632633impl PropertyPermission {634 pub fn none() -> Self {635 Self {636 mutable: true,637 collection_admin: false,638 token_owner: false,639 }640 }641}642643#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]644#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]645pub struct Property {646 #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]647 pub key: PropertyKey,648649 #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]650 pub value: PropertyValue,651}652653impl Into<(PropertyKey, PropertyValue)> for Property {654 fn into(self) -> (PropertyKey, PropertyValue) {655 (self.key, self.value)656 }657}658659#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]660#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]661pub struct PropertyKeyPermission {662 #[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]663 pub key: PropertyKey,664665 pub permission: PropertyPermission,666}667668impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {669 fn into(self) -> (PropertyKey, PropertyPermission) {670 (self.key, self.permission)671 }672}673674#[derive(Debug)]675pub enum PropertiesError {676 NoSpaceForProperty,677 PropertyLimitReached,678 InvalidCharacterInPropertyKey,679 PropertyKeyIsTooLong,680 EmptyPropertyKey,681}682683#[derive(Clone, Copy)]684pub enum PropertyScope {685 None,686 Rmrk,687}688689impl PropertyScope {690 pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {691 let scope_str: &[u8] = match self {692 Self::None => return Ok(key),693 Self::Rmrk => b"rmrk",694 };695696 [scope_str, b":", key.as_slice()]697 .concat()698 .try_into()699 .map_err(|_| PropertiesError::PropertyKeyIsTooLong)700 }701}702703pub trait TrySetProperty: Sized {704 type Value;705706 fn try_scoped_set(707 &mut self,708 scope: PropertyScope,709 key: PropertyKey,710 value: Self::Value,711 ) -> Result<(), PropertiesError>;712713 fn try_scoped_set_from_iter<I, KV>(714 &mut self,715 scope: PropertyScope,716 iter: I,717 ) -> Result<(), PropertiesError>718 where719 I: Iterator<Item = KV>,720 KV: Into<(PropertyKey, Self::Value)>,721 {722 for kv in iter {723 let (key, value) = kv.into();724 self.try_scoped_set(scope, key, value)?;725 }726727 Ok(())728 }729730 fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {731 self.try_scoped_set(PropertyScope::None, key, value)732 }733734 fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>735 where736 I: Iterator<Item = KV>,737 KV: Into<(PropertyKey, Self::Value)>,738 {739 self.try_scoped_set_from_iter(PropertyScope::None, iter)740 }741}742743#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]744#[derivative(Default(bound = ""))]745pub struct PropertiesMap<Value>(746 BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,747);748749impl<Value> PropertiesMap<Value> {750 pub fn new() -> Self {751 Self(BoundedBTreeMap::new())752 }753754 pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {755 Self::check_property_key(key)?;756757 Ok(self.0.remove(key))758 }759760 pub fn get(&self, key: &PropertyKey) -> Option<&Value> {761 self.0.get(key)762 }763764 fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {765 if key.is_empty() {766 return Err(PropertiesError::EmptyPropertyKey);767 }768769 for byte in key.as_slice().iter() {770 let byte = *byte;771772 if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' {773 return Err(PropertiesError::InvalidCharacterInPropertyKey);774 }775 }776777 Ok(())778 }779}780781impl<Value> IntoIterator for PropertiesMap<Value> {782 type Item = (PropertyKey, Value);783 type IntoIter = <784 BoundedBTreeMap<785 PropertyKey,786 Value,787 ConstU32<MAX_PROPERTIES_PER_ITEM>788 > as IntoIterator789 >::IntoIter;790791 fn into_iter(self) -> Self::IntoIter {792 self.0.into_iter()793 }794}795796impl<Value> TrySetProperty for PropertiesMap<Value> {797 type Value = Value;798799 fn try_scoped_set(800 &mut self,801 scope: PropertyScope,802 key: PropertyKey,803 value: Self::Value,804 ) -> Result<(), PropertiesError> {805 Self::check_property_key(&key)?;806807 let key = scope.apply(key)?;808 self.0809 .try_insert(key, value)810 .map_err(|_| PropertiesError::PropertyLimitReached)?;811812 Ok(())813 }814}815816pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;817818#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]819pub struct Properties {820 map: PropertiesMap<PropertyValue>,821 consumed_space: u32,822 space_limit: u32,823}824825impl Properties {826 pub fn new(space_limit: u32) -> Self {827 Self {828 map: PropertiesMap::new(),829 consumed_space: 0,830 space_limit,831 }832 }833834 pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {835 let value = self.map.remove(key)?;836837 if let Some(ref value) = value {838 let value_len = value.len() as u32;839 self.consumed_space -= value_len;840 }841842 Ok(value)843 }844845 pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {846 self.map.get(key)847 }848}849850impl IntoIterator for Properties {851 type Item = (PropertyKey, PropertyValue);852 type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;853854 fn into_iter(self) -> Self::IntoIter {855 self.map.into_iter()856 }857}858859impl TrySetProperty for Properties {860 type Value = PropertyValue;861862 fn try_scoped_set(863 &mut self,864 scope: PropertyScope,865 key: PropertyKey,866 value: Self::Value,867 ) -> Result<(), PropertiesError> {868 let value_len = value.len();869870 if self.consumed_space as usize + value_len > self.space_limit as usize871 && !cfg!(feature = "runtime-benchmarks")872 {873 return Err(PropertiesError::NoSpaceForProperty);874 }875876 self.map.try_scoped_set(scope, key, value)?;877878 self.consumed_space += value_len as u32;879880 Ok(())881 }882}883884pub struct CollectionProperties;885886impl Get<Properties> for CollectionProperties {887 fn get() -> Properties {888 Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)889 }890}891892pub struct TokenProperties;893894impl Get<Properties> for TokenProperties {895 fn get() -> Properties {896 Properties::new(MAX_TOKEN_PROPERTIES_SIZE)897 }898}899900// RMRK901// todo document?902parameter_types! {903 #[derive(PartialEq, TypeInfo)]904 pub const RmrkStringLimit: u32 = 128;905 #[derive(PartialEq)]906 pub const RmrkCollectionSymbolLimit: u32 = 100;907 #[derive(PartialEq)]908 pub const RmrkResourceSymbolLimit: u32 = 10;909 #[derive(PartialEq)]910 pub const RmrkKeyLimit: u32 = 32;911 #[derive(PartialEq)]912 pub const RmrkValueLimit: u32 = 256;913 #[derive(PartialEq)]914 pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;915 #[derive(PartialEq)]916 pub const RmrkPartsLimit: u32 = 3;917}918919impl From<RmrkCollectionId> for CollectionId {920 fn from(id: RmrkCollectionId) -> Self {921 Self(id)922 }923}924925impl From<RmrkNftId> for TokenId {926 fn from(id: RmrkNftId) -> Self {927 Self(id)928 }929}930931pub type RmrkCollectionInfo<AccountId> =932 CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;933pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;934pub type RmrkResourceInfo = ResourceInfo<935 RmrkBoundedResource,936 RmrkString,937 RmrkBoundedParts,938>;939pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;940pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;941pub type RmrkPartType =942 PartType<RmrkString, BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>>;943pub type RmrkThemeProperty = ThemeProperty<RmrkString>;944pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;945946pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;947pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;948pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;949950type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;951type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>;952953pub type RmrkRpcString = Vec<u8>;954pub type RmrkThemeName = RmrkRpcString;955pub type RmrkPropertyKey = RmrkRpcString;956957pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;tests/src/eth/api/Collection.soldiffbeforeafterboth--- a/tests/src/eth/api/Collection.sol
+++ /dev/null
@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: OTHER
-// This code is automatically generated
-
-pragma solidity >=0.8.0 <0.9.0;
-
-// Common stubs holder
-interface Dummy {
-
-}
-
-interface ERC165 is Dummy {
- function supportsInterface(bytes4 interfaceID) external view returns (bool);
-}
-
-// Selector: 15cc740e
-interface Collection is Dummy, ERC165 {
- // Selector: setSponsor(address) 59753fb1
- function setSponsor(address sponsor) external view;
-
- // Selector: confirmSponsorship() c8c6a056
- function confirmSponsorship() external view;
-
- // Selector: setLimits(string) 72cb345d
- function setLimits(string memory limitsJson) external view;
-
- // Selector: contractAddress() f6b4dfb4
- function contractAddress() external view returns (address);
-}
tests/src/eth/api/UniqueNFT.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -42,36 +42,6 @@
event MintingFinished();
}
-// Selector: 38e33c60
-interface Collection is Dummy, ERC165 {
- // Selector: setCollectionProperty(string,bytes) 2f073f66
- function setCollectionProperty(string memory key, bytes memory value)
- external;
-
- // Selector: deleteCollectionProperty(string) 7b7debce
- function deleteCollectionProperty(string memory key) external;
-
- // Throws error if key not found
- //
- // Selector: collectionProperty(string) cf24fd6d
- function collectionProperty(string memory key)
- external
- view
- returns (bytes memory);
-
- // Selector: ethSetSponsor(address) 8f9af356
- function ethSetSponsor(address sponsor) external;
-
- // Selector: ethConfirmSponsorship() a8580d1a
- function ethConfirmSponsorship() external;
-
- // Selector: setLimits(string) 72cb345d
- function setLimits(string memory limitsJson) external view;
-
- // Selector: contractAddress() f6b4dfb4
- function contractAddress() external view returns (address);
-}
-
// Selector: 41369377
interface TokenProperties is Dummy, ERC165 {
// Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa
@@ -243,6 +213,36 @@
returns (bool);
}
+// Selector: f5652829
+interface Collection is Dummy, ERC165 {
+ // Selector: setCollectionProperty(string,bytes) 2f073f66
+ function setCollectionProperty(string memory key, bytes memory value)
+ external;
+
+ // Selector: deleteCollectionProperty(string) 7b7debce
+ function deleteCollectionProperty(string memory key) external;
+
+ // Throws error if key not found
+ //
+ // Selector: collectionProperty(string) cf24fd6d
+ function collectionProperty(string memory key)
+ external
+ view
+ returns (bytes memory);
+
+ // Selector: ethSetSponsor(address) 8f9af356
+ function ethSetSponsor(address sponsor) external;
+
+ // Selector: ethConfirmSponsorship() a8580d1a
+ function ethConfirmSponsorship() external;
+
+ // Selector: setLimit(string,string) bf4d2014
+ function setLimit(string memory limit, string memory value) external;
+
+ // Selector: contractAddress() f6b4dfb4
+ function contractAddress() external view returns (address);
+}
+
interface UniqueNFT is
Dummy,
ERC165,
tests/src/eth/createCollection.test.tsdiffbeforeafterboth--- a/tests/src/eth/createCollection.test.ts
+++ b/tests/src/eth/createCollection.test.ts
@@ -108,7 +108,7 @@
const limits = {
accountTokenOwnershipLimit: 1000,
sponsoredDataSize: 1024,
- sponsoredDataRateLimit: {Blocks: 30},
+ sponsoredDataRateLimit: 30,
tokenLimit: 1000000,
sponsorTransferTimeout: 6,
sponsorApproveTimeout: 6,
@@ -117,14 +117,21 @@
transfersEnabled: false,
};
- const limitsJson = JSON.stringify(limits, null, 1);
const collectionEvm = evmCollection(web3, owner, collectionIdAddress);
- await collectionEvm.methods.setLimits(limitsJson).send();
+ await collectionEvm.methods.setLimit('accountTokenOwnershipLimit', limits.accountTokenOwnershipLimit.toString()).send();
+ await collectionEvm.methods.setLimit('sponsoredDataSize', limits.sponsoredDataSize.toString()).send();
+ await collectionEvm.methods.setLimit('sponsoredDataRateLimit', limits.sponsoredDataRateLimit.toString()).send();
+ await collectionEvm.methods.setLimit('tokenLimit', limits.tokenLimit.toString()).send();
+ await collectionEvm.methods.setLimit('sponsorTransferTimeout', limits.sponsorTransferTimeout.toString()).send();
+ await collectionEvm.methods.setLimit('sponsorApproveTimeout', limits.sponsorApproveTimeout.toString()).send();
+ await collectionEvm.methods.setLimit('ownerCanTransfer', limits.ownerCanTransfer.toString()).send();
+ await collectionEvm.methods.setLimit('ownerCanDestroy', limits.ownerCanDestroy.toString()).send();
+ await collectionEvm.methods.setLimit('transfersEnabled', limits.transfersEnabled.toString()).send();
const collectionSub = (await getDetailedCollectionInfo(api, collectionId))!;
expect(collectionSub.limits.accountTokenOwnershipLimit.unwrap().toNumber()).to.be.eq(limits.accountTokenOwnershipLimit);
expect(collectionSub.limits.sponsoredDataSize.unwrap().toNumber()).to.be.eq(limits.sponsoredDataSize);
- expect(collectionSub.limits.sponsoredDataRateLimit.unwrap().asBlocks.toNumber()).to.be.eq(limits.sponsoredDataRateLimit.Blocks);
+ expect(collectionSub.limits.sponsoredDataRateLimit.unwrap().asBlocks.toNumber()).to.be.eq(limits.sponsoredDataRateLimit);
expect(collectionSub.limits.tokenLimit.unwrap().toNumber()).to.be.eq(limits.tokenLimit);
expect(collectionSub.limits.sponsorTransferTimeout.unwrap().toNumber()).to.be.eq(limits.sponsorTransferTimeout);
expect(collectionSub.limits.sponsorApproveTimeout.unwrap().toNumber()).to.be.eq(limits.sponsorApproveTimeout);
@@ -171,6 +178,21 @@
// const tokenUri = await contract.methods.tokenURI(nextTokenId).call();
// expect(tokenUri).to.be.equal(`https://offchain-service.local/token-info/${nextTokenId}`);
});
+
+ itWeb3('Collection address exist', async ({api, web3}) => {
+ const owner = await createEthAccountWithBalance(api, web3);
+ const collectionAddressForNonexistentCollection = '0x17C4E6453CC49AAAAEACA894E6D9683E00112233';
+ const collectionHelper = evmCollectionHelper(web3, owner);
+ expect(await collectionHelper.methods
+ .isCollectionExist(collectionAddressForNonexistentCollection).call())
+ .to.be.false;
+
+ const result = await collectionHelper.methods.create721Collection('Const collection', '5', '5').send();
+ const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);
+ expect(await collectionHelper.methods
+ .isCollectionExist(collectionIdAddress).call())
+ .to.be.true;
+ });
});
describe('(!negative tests!) Create collection from EVM', () => {
@@ -218,30 +240,6 @@
await expect(helper.methods
.create721Collection(collectionName, description, tokenPrefix)
.call()).to.be.rejectedWith('NotSufficientFounds');
- });
-
- itWeb3('(!negative test!) Collection address (Create collection handle error)', async ({api, web3}) => {
- const owner = await createEthAccountWithBalance(api, web3);
- const collectionAddressForNonexistentCollection = '0x17C4E6453CC49AAAAEACA894E6D9683E00112233';
- const collectionEvm = evmCollection(web3, owner, collectionAddressForNonexistentCollection);
- const EXPECTED_ERROR = 'Create collection handle error';
- {
- const sponsor = await createEthAccountWithBalance(api, web3);
- await expect(collectionEvm.methods
- .setSponsor(sponsor)
- .call()).to.be.rejectedWith(EXPECTED_ERROR);
-
- const sponsorCollection = evmCollection(web3, sponsor, collectionAddressForNonexistentCollection);
- await expect(sponsorCollection.methods
- .confirmSponsorship()
- .call()).to.be.rejectedWith(EXPECTED_ERROR);
- }
- {
- const limits = '{"account_token_ownership_limit":1000}';
- await expect(collectionEvm.methods
- .setLimits(limits)
- .call()).to.be.rejectedWith(EXPECTED_ERROR);
- }
});
itWeb3('(!negative test!) Check owner', async ({api, web3}) => {
@@ -255,18 +253,17 @@
{
const sponsor = await createEthAccountWithBalance(api, web3);
await expect(contractEvmFromNotOwner.methods
- .setSponsor(sponsor)
+ .ethSetSponsor(sponsor)
.call()).to.be.rejectedWith(EXPECTED_ERROR);
const sponsorCollection = evmCollection(web3, sponsor, collectionIdAddress);
await expect(sponsorCollection.methods
- .confirmSponsorship()
+ .ethConfirmSponsorship()
.call()).to.be.rejectedWith('Caller is not set as sponsor');
}
{
- const limits = '{"account_token_ownership_limit":1000}';
await expect(contractEvmFromNotOwner.methods
- .setLimits(limits)
+ .setLimit('account_token_ownership_limit', '1000')
.call()).to.be.rejectedWith(EXPECTED_ERROR);
}
});
@@ -277,9 +274,14 @@
const result = await collectionHelper.methods.create721Collection('Schema collection', 'A', 'A').send();
const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);
const collectionEvm = evmCollection(web3, owner, collectionIdAddress);
- const badJson = '{accountTokenOwnershipLimit: 1000}';
await expect(collectionEvm.methods
- .setLimits(badJson)
- .call()).to.be.rejectedWith('Parse JSON error:');
+ .setLimit('badLimit', 'true')
+ .call()).to.be.rejectedWith('Unknown limit "badLimit"');
+ await expect(collectionEvm.methods
+ .setLimit('sponsoredDataSize', 'badValue')
+ .call()).to.be.rejectedWith('Int value "badValue" parse error:');
+ await expect(collectionEvm.methods
+ .setLimit('ownerCanTransfer', 'badValue')
+ .call()).to.be.rejectedWith('Bool value "badValue" parse error:');
});
});
\ No newline at end of file
tests/src/eth/nonFungibleAbi.jsondiffbeforeafterboth--- a/tests/src/eth/nonFungibleAbi.json
+++ b/tests/src/eth/nonFungibleAbi.json
@@ -325,11 +325,12 @@
},
{
"inputs": [
- { "internalType": "string", "name": "limitsJson", "type": "string" }
+ { "internalType": "string", "name": "limit", "type": "string" },
+ { "internalType": "string", "name": "value", "type": "string" }
],
- "name": "setLimits",
+ "name": "setLimit",
"outputs": [],
- "stateMutability": "view",
+ "stateMutability": "nonpayable",
"type": "function"
},
{