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

1// 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};2627#[cfg(feature = "serde")]28use serde::{Serialize, Deserialize};2930use sp_core::U256;31use sp_runtime::{ArithmeticError, sp_std::prelude::Vec};32use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};33use frame_support::{BoundedVec, traits::ConstU32};34use derivative::Derivative;35use scale_info::TypeInfo;3637mod bounded;38pub mod budget;39pub mod mapping;40mod migration;4142pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;43pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;44pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;4546pub const MAX_TOKEN_OWNERSHIP: u32 = if cfg!(not(feature = "limit-testing")) {47	100_00048} else {49	1050};51pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {52	100_00053} else {54	1055};56pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {57	204858} else {59	1060};61pub const COLLECTION_ADMINS_LIMIT: u32 = 5;62pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX;63pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {64	1_000_00065} else {66	1067};6869// Timeouts for item types in passed blocks70pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;71pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;72pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;7374pub const SPONSOR_APPROVE_TIMEOUT: u32 = 5;7576// Schema limits77pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 8192;78pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 8192;79pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 32768;8081pub const COLLECTION_FIELD_LIMIT: u32 = CONST_ON_CHAIN_SCHEMA_LIMIT;82// u32::max is not const: OFFCHAIN_SCHEMA_LIMIT.max(VARIABLE_ON_CHAIN_SCHEMA_LIMIT).max(CONST_ON_CHAIN_SCHEMA_LIMIT);8384pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;85pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;86pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;8788/// How much items can be created per single89/// create_many call90pub const MAX_ITEMS_PER_BATCH: u32 = 200;9192pub type CustomDataLimit = ConstU32<CUSTOM_DATA_LIMIT>;9394#[derive(95	Encode,96	Decode,97	PartialEq,98	Eq,99	PartialOrd,100	Ord,101	Clone,102	Copy,103	Debug,104	Default,105	TypeInfo,106	MaxEncodedLen,107)]108#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]109pub struct CollectionId(pub u32);110impl EncodeLike<u32> for CollectionId {}111impl EncodeLike<CollectionId> for u32 {}112113#[derive(114	Encode,115	Decode,116	PartialEq,117	Eq,118	PartialOrd,119	Ord,120	Clone,121	Copy,122	Debug,123	Default,124	TypeInfo,125	MaxEncodedLen,126)]127#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]128pub struct TokenId(pub u32);129impl EncodeLike<u32> for TokenId {}130impl EncodeLike<TokenId> for u32 {}131132impl TokenId {133	pub fn try_next(self) -> Result<TokenId, ArithmeticError> {134		self.0135			.checked_add(1)136			.ok_or(ArithmeticError::Overflow)137			.map(Self)138	}139}140141impl From<TokenId> for U256 {142	fn from(t: TokenId) -> Self {143		t.0.into()144	}145}146147impl TryFrom<U256> for TokenId {148	type Error = &'static str;149150	fn try_from(value: U256) -> Result<Self, Self::Error> {151		Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))152	}153}154155pub struct OverflowError;156impl From<OverflowError> for &'static str {157	fn from(_: OverflowError) -> Self {158		"overflow occured"159	}160}161162pub type DecimalPoints = u8;163164#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]165#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]166pub enum CollectionMode {167	NFT,168	// decimal points169	Fungible(DecimalPoints),170	ReFungible,171}172173impl CollectionMode {174	pub fn id(&self) -> u8 {175		match self {176			CollectionMode::NFT => 1,177			CollectionMode::Fungible(_) => 2,178			CollectionMode::ReFungible => 3,179		}180	}181}182183pub trait SponsoringResolve<AccountId, Call> {184	fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;185}186187#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]188#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]189pub enum AccessMode {190	Normal,191	AllowList,192}193impl Default for AccessMode {194	fn default() -> Self {195		Self::Normal196	}197}198199#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]200#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]201pub enum SchemaVersion {202	ImageURL,203	Unique,204}205impl Default for SchemaVersion {206	fn default() -> Self {207		Self::ImageURL208	}209}210211#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]212#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]213pub struct Ownership<AccountId> {214	pub owner: AccountId,215	pub fraction: u128,216}217218#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]219#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]220pub enum SponsorshipState<AccountId> {221	/// The fees are applied to the transaction sender222	Disabled,223	Unconfirmed(AccountId),224	/// Transactions are sponsored by specified account225	Confirmed(AccountId),226}227228impl<AccountId> SponsorshipState<AccountId> {229	pub fn sponsor(&self) -> Option<&AccountId> {230		match self {231			Self::Confirmed(sponsor) => Some(sponsor),232			_ => None,233		}234	}235236	pub fn pending_sponsor(&self) -> Option<&AccountId> {237		match self {238			Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),239			_ => None,240		}241	}242243	pub fn confirmed(&self) -> bool {244		matches!(self, Self::Confirmed(_))245	}246}247248impl<T> Default for SponsorshipState<T> {249	fn default() -> Self {250		Self::Disabled251	}252}253254/// Used in storage255#[struct_versioning::versioned(version = 2, upper)]256#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]257pub struct Collection<AccountId> {258	pub owner: AccountId,259	pub mode: CollectionMode,260	pub access: AccessMode,261	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,262	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,263	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,264	pub mint_mode: bool,265266	#[version(..2)]267	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,268269	pub schema_version: SchemaVersion,270	pub sponsorship: SponsorshipState<AccountId>,271272	#[version(..2)]273	pub limits: CollectionLimitsVersion1, // Collection private restrictions274	#[version(2.., upper(limits.into()))]275	pub limits: CollectionLimitsVersion2,276277	#[version(..2)]278	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,279	#[version(..2)]280	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,281282	pub meta_update_permission: MetaUpdatePermission,283}284285/// Used in RPC calls286#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]287#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]288pub struct RpcCollection<AccountId> {289	pub owner: AccountId,290	pub mode: CollectionMode,291	pub access: AccessMode,292	pub name: Vec<u16>,293	pub description: Vec<u16>,294	pub token_prefix: Vec<u8>,295	pub mint_mode: bool,296	pub offchain_schema: Vec<u8>,297	pub schema_version: SchemaVersion,298	pub sponsorship: SponsorshipState<AccountId>,299	pub limits: CollectionLimits,300	pub variable_on_chain_schema: Vec<u8>,301	pub const_on_chain_schema: Vec<u8>,302	pub meta_update_permission: MetaUpdatePermission,303}304305#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]306#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]307pub enum CollectionField {308	VariableOnChainSchema,309	ConstOnChainSchema,310	OffchainSchema,311}312313#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Debug, Derivative, MaxEncodedLen)]314#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]315#[derivative(Default(bound = ""))]316pub struct CreateCollectionData<AccountId> {317	#[derivative(Default(value = "CollectionMode::NFT"))]318	pub mode: CollectionMode,319	pub access: Option<AccessMode>,320	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]321	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,322	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]323	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,324	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]325	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,326	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]327	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,328	pub schema_version: Option<SchemaVersion>,329	pub pending_sponsor: Option<AccountId>,330	pub limits: Option<CollectionLimits>,331	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]332	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,333	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]334	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,335	pub meta_update_permission: Option<MetaUpdatePermission>,336}337338#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo)]339#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]340pub struct NftItemType<AccountId> {341	pub owner: AccountId,342	pub const_data: Vec<u8>,343	pub variable_data: Vec<u8>,344}345346#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]347#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]348pub struct FungibleItemType {349	pub value: u128,350}351352#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo)]353#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]354pub struct ReFungibleItemType<AccountId> {355	pub owner: Vec<Ownership<AccountId>>,356	pub const_data: Vec<u8>,357	pub variable_data: Vec<u8>,358}359360/// All fields are wrapped in `Option`s, where None means chain default361#[struct_versioning::versioned(version = 2, upper)]362#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]363#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]364pub struct CollectionLimits {365	pub account_token_ownership_limit: Option<u32>,366	pub sponsored_data_size: Option<u32>,367	/// None - setVariableMetadata is not sponsored368	/// Some(v) - setVariableMetadata is sponsored369	///           if there is v block between txs370	pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,371	pub token_limit: Option<u32>,372373	// Timeouts for item types in passed blocks374	pub sponsor_transfer_timeout: Option<u32>,375	pub sponsor_approve_timeout: Option<u32>,376	pub owner_can_transfer: Option<bool>,377	pub owner_can_destroy: Option<bool>,378	pub transfers_enabled: Option<bool>,379380	#[version(2.., upper(None))]381	pub nesting_rule: Option<NestingRule>,382}383384impl CollectionLimits {385	pub fn account_token_ownership_limit(&self) -> u32 {386		self.account_token_ownership_limit387			.unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)388			.min(MAX_TOKEN_OWNERSHIP)389	}390	pub fn sponsored_data_size(&self) -> u32 {391		self.sponsored_data_size392			.unwrap_or(CUSTOM_DATA_LIMIT)393			.min(CUSTOM_DATA_LIMIT)394	}395	pub fn token_limit(&self) -> u32 {396		self.token_limit397			.unwrap_or(COLLECTION_TOKEN_LIMIT)398			.min(COLLECTION_TOKEN_LIMIT)399	}400	pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {401		self.sponsor_transfer_timeout402			.unwrap_or(default)403			.min(MAX_SPONSOR_TIMEOUT)404	}405	pub fn sponsor_approve_timeout(&self) -> u32 {406		self.sponsor_approve_timeout407			.unwrap_or(SPONSOR_APPROVE_TIMEOUT)408			.min(MAX_SPONSOR_TIMEOUT)409	}410	pub fn owner_can_transfer(&self) -> bool {411		self.owner_can_transfer.unwrap_or(true)412	}413	pub fn owner_can_destroy(&self) -> bool {414		self.owner_can_destroy.unwrap_or(true)415	}416	pub fn transfers_enabled(&self) -> bool {417		self.transfers_enabled.unwrap_or(true)418	}419	pub fn sponsored_data_rate_limit(&self) -> Option<u32> {420		match self421			.sponsored_data_rate_limit422			.unwrap_or(SponsoringRateLimit::SponsoringDisabled)423		{424			SponsoringRateLimit::SponsoringDisabled => None,425			SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),426		}427	}428	pub fn nesting_rule(&self) -> &NestingRule {429		static DEFAULT: NestingRule = NestingRule::Owner;430		self.nesting_rule.as_ref().unwrap_or(&DEFAULT)431	}432}433434#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]435#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]436#[derivative(Debug)]437pub enum NestingRule {438	/// No one can nest tokens439	Disabled,440	/// Owner can nest any tokens441	Owner,442	/// Owner can nest tokens from specified collections443	OwnerRestricted(444		#[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]445		#[derivative(Debug(format_with = "bounded::set_debug"))]446		BoundedBTreeSet<CollectionId, ConstU32<16>>,447	),448}449450#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]451#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]452pub enum SponsoringRateLimit {453	SponsoringDisabled,454	Blocks(u32),455}456457#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]458#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]459#[derivative(Debug)]460pub struct CreateNftData {461	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]462	#[derivative(Debug(format_with = "bounded::vec_debug"))]463	pub const_data: BoundedVec<u8, CustomDataLimit>,464	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]465	#[derivative(Debug(format_with = "bounded::vec_debug"))]466	pub variable_data: BoundedVec<u8, CustomDataLimit>,467}468469#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]470#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]471pub struct CreateFungibleData {472	pub value: u128,473}474475#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]476#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]477#[derivative(Debug)]478pub struct CreateReFungibleData {479	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]480	#[derivative(Debug(format_with = "bounded::vec_debug"))]481	pub const_data: BoundedVec<u8, CustomDataLimit>,482	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]483	#[derivative(Debug(format_with = "bounded::vec_debug"))]484	pub variable_data: BoundedVec<u8, CustomDataLimit>,485	pub pieces: u128,486}487488#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]489#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]490pub enum MetaUpdatePermission {491	ItemOwner,492	Admin,493	None,494}495496impl Default for MetaUpdatePermission {497	fn default() -> Self {498		Self::ItemOwner499	}500}501502#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]503#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]504pub enum CreateItemData {505	NFT(CreateNftData),506	Fungible(CreateFungibleData),507	ReFungible(CreateReFungibleData),508}509510#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]511#[derivative(Debug)]512pub struct CreateNftExData<CrossAccountId> {513	#[derivative(Debug(format_with = "bounded::vec_debug"))]514	pub const_data: BoundedVec<u8, CustomDataLimit>,515	#[derivative(Debug(format_with = "bounded::vec_debug"))]516	pub variable_data: BoundedVec<u8, CustomDataLimit>,517	pub owner: CrossAccountId,518}519520#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]521#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]522pub struct CreateRefungibleExData<CrossAccountId> {523	#[derivative(Debug(format_with = "bounded::vec_debug"))]524	pub const_data: BoundedVec<u8, CustomDataLimit>,525	#[derivative(Debug(format_with = "bounded::vec_debug"))]526	pub variable_data: BoundedVec<u8, CustomDataLimit>,527	#[derivative(Debug(format_with = "bounded::map_debug"))]528	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,529}530531#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]532#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]533pub enum CreateItemExData<CrossAccountId> {534	NFT(535		#[derivative(Debug(format_with = "bounded::vec_debug"))]536		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,537	),538	Fungible(539		#[derivative(Debug(format_with = "bounded::map_debug"))]540		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,541	),542	/// Many tokens, each may have only one owner543	RefungibleMultipleItems(544		#[derivative(Debug(format_with = "bounded::vec_debug"))]545		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,546	),547	/// Single token, which may have many owners548	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),549}550551impl CreateItemData {552	pub fn data_size(&self) -> usize {553		match self {554			CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),555			CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),556			_ => 0,557		}558	}559}560561impl From<CreateNftData> for CreateItemData {562	fn from(item: CreateNftData) -> Self {563		CreateItemData::NFT(item)564	}565}566567impl From<CreateReFungibleData> for CreateItemData {568	fn from(item: CreateReFungibleData) -> Self {569		CreateItemData::ReFungible(item)570	}571}572573impl From<CreateFungibleData> for CreateItemData {574	fn from(item: CreateFungibleData) -> Self {575		CreateItemData::Fungible(item)576	}577}578579#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]580#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]581pub struct CollectionStats {582	pub created: u32,583	pub destroyed: u32,584	pub alive: u32,585}586587#[derive(Encode, Decode, PartialEq, Clone, Debug)]588pub struct PhantomType<T>(core::marker::PhantomData<T>);589590impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {591	type Identity = PhantomType<T>;592593	fn type_info() -> scale_info::Type {594		use scale_info::{595			Type, Path,596			build::{FieldsBuilder, UnnamedFields},597			type_params,598		};599		Type::builder()600			.path(Path::new("up_data_structs", "PhantomType"))601			.type_params(type_params!(T))602			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))603	}604}605impl<T> MaxEncodedLen for PhantomType<T> {606	fn max_encoded_len() -> usize {607		0608	}609}