difftreelog
Merge branch 'develop' into feature/CORE-164
in: master
22 files changed
crates/evm-coder-macros/src/solidity_interface.rsdiffbeforeafterboth--- a/crates/evm-coder-macros/src/solidity_interface.rs
+++ b/crates/evm-coder-macros/src/solidity_interface.rs
@@ -1,16 +1,16 @@
#![allow(dead_code)]
use quote::quote;
-use darling::FromMeta;
+use darling::{FromMeta, ToTokens};
use inflector::cases;
use std::fmt::Write;
use syn::{
- FnArg, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Meta, NestedMeta, PatType, Path,
- ReturnType, Type, spanned::Spanned,
+ Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta,
+ NestedMeta, PatType, Path, PathArguments, ReturnType, Type, spanned::Spanned,
};
use crate::{
- fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_ident_from_type,
+ fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_path, parse_path_segment,
parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,
snake_ident_to_screaming,
};
@@ -77,14 +77,14 @@
fn expand_generator(&self) -> proc_macro2::TokenStream {
let pascal_call_name = &self.pascal_call_name;
quote! {
- #pascal_call_name::generate_solidity_interface(out_set, is_impl);
+ #pascal_call_name::generate_solidity_interface(tc, is_impl);
}
}
fn expand_event_generator(&self) -> proc_macro2::TokenStream {
let name = &self.name;
quote! {
- #name::generate_solidity_interface(out_set, is_impl);
+ #name::generate_solidity_interface(tc, is_impl);
}
}
}
@@ -121,10 +121,161 @@
rename_selector: Option<String>,
}
+enum AbiType {
+ // type
+ Plain(Ident),
+ // (type1,type2)
+ Tuple(Vec<AbiType>),
+ // type[]
+ Vec(Box<AbiType>),
+ // type[20]
+ Array(Box<AbiType>, usize),
+}
+impl AbiType {
+ fn try_from(value: &Type) -> syn::Result<Self> {
+ let value = Self::try_maybe_special_from(value)?;
+ if value.is_special() {
+ return Err(syn::Error::new(value.span(), "unexpected special type"));
+ }
+ Ok(value)
+ }
+ fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {
+ match value {
+ Type::Array(arr) => {
+ let wrapped = AbiType::try_from(&arr.elem)?;
+ match &arr.len {
+ Expr::Lit(l) => match &l.lit {
+ Lit::Int(i) => {
+ let num = i.base10_parse::<usize>()?;
+ Ok(AbiType::Array(Box::new(wrapped), num as usize))
+ }
+ _ => Err(syn::Error::new(arr.len.span(), "should be int literal")),
+ },
+ _ => Err(syn::Error::new(arr.len.span(), "should be literal")),
+ }
+ }
+ Type::Path(_) => {
+ let path = parse_path(value)?;
+ let segment = parse_path_segment(path)?;
+ if segment.ident == "Vec" {
+ let args = match &segment.arguments {
+ PathArguments::AngleBracketed(e) => e,
+ _ => {
+ return Err(syn::Error::new(
+ segment.arguments.span(),
+ "missing Vec generic",
+ ))
+ }
+ };
+ let args = &args.args;
+ if args.len() != 1 {
+ return Err(syn::Error::new(
+ args.span(),
+ "expected only one generic for vec",
+ ));
+ }
+ let arg = args.first().unwrap();
+
+ let ty = match arg {
+ GenericArgument::Type(ty) => ty,
+ _ => {
+ return Err(syn::Error::new(
+ arg.span(),
+ "expected first generic to be type",
+ ))
+ }
+ };
+
+ let wrapped = AbiType::try_from(ty)?;
+ Ok(Self::Vec(Box::new(wrapped)))
+ } else {
+ if !segment.arguments.is_empty() {
+ return Err(syn::Error::new(
+ segment.arguments.span(),
+ "unexpected generic arguments for non-vec type",
+ ));
+ }
+ Ok(Self::Plain(segment.ident.clone()))
+ }
+ }
+ Type::Tuple(t) => {
+ let mut out = Vec::with_capacity(t.elems.len());
+ for el in t.elems.iter() {
+ out.push(AbiType::try_from(el)?)
+ }
+ Ok(Self::Tuple(out))
+ }
+ _ => Err(syn::Error::new(
+ value.span(),
+ "unexpected type, only arrays, plain types and tuples are supported",
+ )),
+ }
+ }
+ fn is_value(&self) -> bool {
+ match self {
+ Self::Plain(v) if v == "value" => true,
+ _ => false,
+ }
+ }
+ fn is_caller(&self) -> bool {
+ match self {
+ Self::Plain(v) if v == "caller" => true,
+ _ => false,
+ }
+ }
+ fn is_special(&self) -> bool {
+ self.is_caller() || self.is_value()
+ }
+ fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {
+ match self {
+ AbiType::Plain(t) => {
+ write!(buf, "{}", t)
+ }
+ AbiType::Tuple(t) => {
+ write!(buf, "(")?;
+ for (i, t) in t.iter().enumerate() {
+ if i != 0 {
+ write!(buf, ",")?;
+ }
+ t.selector_ty_buf(buf)?;
+ }
+ write!(buf, ")")
+ }
+ AbiType::Vec(v) => {
+ v.selector_ty_buf(buf)?;
+ write!(buf, "[]")
+ }
+ AbiType::Array(v, len) => {
+ v.selector_ty_buf(buf)?;
+ write!(buf, "[{}]", len)
+ }
+ }
+ }
+ fn selector_ty(&self) -> String {
+ let mut out = String::new();
+ self.selector_ty_buf(&mut out).expect("no fmt error");
+ out
+ }
+}
+impl ToTokens for AbiType {
+ fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+ match self {
+ AbiType::Plain(t) => tokens.extend(quote! {#t}),
+ AbiType::Tuple(t) => {
+ tokens.extend(quote! {(
+ #(#t),*
+ )});
+ }
+ AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),
+ AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),
+ }
+ }
+}
+
struct MethodArg {
name: Ident,
camel_name: String,
- ty: Ident,
+ ty: AbiType,
}
impl MethodArg {
fn try_from(value: &PatType) -> syn::Result<Self> {
@@ -132,21 +283,21 @@
Ok(Self {
camel_name: cases::camelcase::to_camel_case(&name.to_string()),
name,
- ty: parse_ident_from_type(&value.ty, false)?.clone(),
+ ty: AbiType::try_maybe_special_from(&value.ty)?,
})
}
fn is_value(&self) -> bool {
- self.ty == "value"
+ self.ty.is_value()
}
fn is_caller(&self) -> bool {
- self.ty == "caller"
+ self.ty.is_caller()
}
fn is_special(&self) -> bool {
- self.is_value() || self.is_caller()
+ self.ty.is_special()
}
- fn selector_ty(&self) -> &Ident {
+ fn selector_ty(&self) -> String {
assert!(!self.is_special());
- &self.ty
+ self.ty.selector_ty()
}
fn expand_call_def(&self) -> proc_macro2::TokenStream {
@@ -419,9 +570,11 @@
.iter()
.filter(|a| !a.is_special())
.map(MethodArg::expand_solidity_argument);
+ let selector = format!("{} {:0>8x}", self.selector_str, self.selector);
quote! {
SolidityFunction {
+ selector: #selector,
name: #camel_name,
mutability: #mutability,
args: (
@@ -544,7 +697,7 @@
)*
)
}
- pub fn generate_solidity_interface(out_set: &mut sp_std::collections::btree_set::BTreeSet<string>, is_impl: bool) {
+ pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {
use evm_coder::solidity::*;
use core::fmt::Write;
let interface = SolidityInterface {
@@ -559,9 +712,9 @@
)*),
};
if is_impl {
- out_set.insert("// Common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\n".into());
+ tc.collect("// Common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\n".into());
} else {
- out_set.insert("// Common stubs holder\ninterface Dummy {\n}\n".into());
+ tc.collect("// Common stubs holder\ninterface Dummy {\n}\n".into());
}
#(
#solidity_generators
@@ -576,8 +729,8 @@
if #solidity_name.starts_with("Inline") {
out.push_str("// Inline\n");
}
- let _ = interface.format(is_impl, &mut out);
- out_set.insert(out);
+ let _ = interface.format(is_impl, &mut out, tc);
+ tc.collect(out);
}
}
impl ::evm_coder::Call for #call_name {
crates/evm-coder-macros/src/to_log.rsdiffbeforeafterboth--- a/crates/evm-coder-macros/src/to_log.rs
+++ b/crates/evm-coder-macros/src/to_log.rs
@@ -179,7 +179,7 @@
#consts
)*
- pub fn generate_solidity_interface(out_set: &mut sp_std::collections::btree_set::BTreeSet<string>, is_impl: bool) {
+ pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {
use evm_coder::solidity::*;
use core::fmt::Write;
let interface = SolidityInterface {
@@ -191,8 +191,8 @@
};
let mut out = string::new();
out.push_str("// Inline\n");
- let _ = interface.format(is_impl, &mut out);
- out_set.insert(out);
+ let _ = interface.format(is_impl, &mut out, tc);
+ tc.collect(out);
}
}
crates/evm-coder/src/abi.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi.rs
+++ b/crates/evm-coder/src/abi.rs
@@ -211,6 +211,10 @@
self.memory(value.as_bytes())
}
+ pub fn bytes(&mut self, value: &[u8]) {
+ self.memory(value)
+ }
+
pub fn finish(mut self) -> Vec<u8> {
for (static_offset, part) in self.dynamic_part {
let part_offset = self.static_part.len();
@@ -247,6 +251,59 @@
impl_abi_readable!(bool, bool);
impl_abi_readable!(string, string);
+mod sealed {
+ /// Not all types can be placed in vec, i.e `Vec<u8>` is restricted, `bytes` should be used instead
+ pub trait CanBePlacedInVec {}
+}
+
+impl sealed::CanBePlacedInVec for U256 {}
+impl sealed::CanBePlacedInVec for string {}
+impl sealed::CanBePlacedInVec for H160 {}
+
+impl<R: sealed::CanBePlacedInVec> AbiRead<Vec<R>> for AbiReader<'_>
+where
+ Self: AbiRead<R>,
+{
+ fn abi_read(&mut self) -> Result<Vec<R>> {
+ let mut sub = self.subresult()?;
+ let size = sub.read_usize()?;
+ sub.subresult_offset = sub.offset;
+ let mut out = Vec::with_capacity(size);
+ for _ in 0..size {
+ out.push(<Self as AbiRead<R>>::abi_read(&mut sub)?);
+ }
+ Ok(out)
+ }
+}
+
+macro_rules! impl_tuples {
+ ($($ident:ident)+) => {
+ impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
+ impl<$($ident),+> AbiRead<($($ident,)+)> for AbiReader<'_>
+ where
+ $(Self: AbiRead<$ident>),+
+ {
+ fn abi_read(&mut self) -> Result<($($ident,)+)> {
+ let mut subresult = self.subresult()?;
+ Ok((
+ $(<Self as AbiRead<$ident>>::abi_read(&mut subresult)?,)+
+ ))
+ }
+ }
+ };
+}
+
+impl_tuples! {A}
+impl_tuples! {A B}
+impl_tuples! {A B C}
+impl_tuples! {A B C D}
+impl_tuples! {A B C D E}
+impl_tuples! {A B C D E F}
+impl_tuples! {A B C D E F G}
+impl_tuples! {A B C D E F G H}
+impl_tuples! {A B C D E F G H I}
+impl_tuples! {A B C D E F G H I J}
+
pub trait AbiWrite {
fn abi_write(&self, writer: &mut AbiWriter);
}
@@ -273,6 +330,11 @@
writer.string(self)
}
}
+impl AbiWrite for &Vec<u8> {
+ fn abi_write(&self, writer: &mut AbiWriter) {
+ writer.bytes(self)
+ }
+}
impl AbiWrite for () {
fn abi_write(&self, _writer: &mut AbiWriter) {}
@@ -308,6 +370,11 @@
#[cfg(test)]
pub mod test {
+ use crate::{
+ abi::AbiRead,
+ types::{string, uint256},
+ };
+
use super::{AbiReader, AbiWriter};
use hex_literal::hex;
@@ -355,4 +422,48 @@
assert_eq!(decoder.uint32().unwrap(), 1);
assert_eq!(decoder.string().unwrap(), "Test URI");
}
+
+ #[test]
+ fn mint_bulk() {
+ let (call, mut decoder) = AbiReader::new_call(&hex!(
+ "
+ 36543006
+ 00000000000000000000000053744e6da587ba10b32a2554d2efdcd985bc27a3 // address
+ 0000000000000000000000000000000000000000000000000000000000000040 // offset of (uint256, string)[]
+ 0000000000000000000000000000000000000000000000000000000000000003 // length of (uint256, string)[]
+
+ 0000000000000000000000000000000000000000000000000000000000000060 // offset of first elem
+ 00000000000000000000000000000000000000000000000000000000000000e0 // offset of second elem
+ 0000000000000000000000000000000000000000000000000000000000000160 // offset of third elem
+
+ 0000000000000000000000000000000000000000000000000000000000000001 // first token id? #60
+ 0000000000000000000000000000000000000000000000000000000000000040 // offset of string
+ 000000000000000000000000000000000000000000000000000000000000000a // size of string
+ 5465737420555249203000000000000000000000000000000000000000000000 // string
+
+ 000000000000000000000000000000000000000000000000000000000000000b // second token id? Why ==11? #e0
+ 0000000000000000000000000000000000000000000000000000000000000040 // offset of string
+ 000000000000000000000000000000000000000000000000000000000000000a // size of string
+ 5465737420555249203100000000000000000000000000000000000000000000 // string
+
+ 000000000000000000000000000000000000000000000000000000000000000c // third token id? Why ==12? #160
+ 0000000000000000000000000000000000000000000000000000000000000040 // offset of string
+ 000000000000000000000000000000000000000000000000000000000000000a // size of string
+ 5465737420555249203200000000000000000000000000000000000000000000 // string
+ "
+ ))
+ .unwrap();
+ assert_eq!(call, 0x36543006);
+ let _ = decoder.address().unwrap();
+ let data =
+ <AbiReader<'_> as AbiRead<Vec<(uint256, string)>>>::abi_read(&mut decoder).unwrap();
+ assert_eq!(
+ data,
+ vec![
+ (1.into(), "Test URI 0".to_string()),
+ (11.into(), "Test URI 1".to_string()),
+ (12.into(), "Test URI 2".to_string())
+ ]
+ );
+ }
}
crates/evm-coder/src/lib.rsdiffbeforeafterboth--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -67,8 +67,8 @@
#[test]
#[ignore]
fn $name() {
- use sp_std::collections::btree_set::BTreeSet;
- let mut out = BTreeSet::new();
+ use evm_coder::solidity::TypeCollector;
+ let mut out = TypeCollector::new();
$decl::generate_solidity_interface(&mut out, $is_impl);
println!("=== SNIP START ===");
println!("// SPDX-License-Identifier: OTHER");
@@ -76,7 +76,7 @@
println!();
println!("pragma solidity >=0.8.0 <0.9.0;");
println!();
- for b in out {
+ for b in out.finish() {
println!("{}", b);
}
println!("=== SNIP END ===");
crates/evm-coder/src/solidity.rsdiffbeforeafterboth--- a/crates/evm-coder/src/solidity.rs
+++ b/crates/evm-coder/src/solidity.rs
@@ -1,25 +1,79 @@
#[cfg(not(feature = "std"))]
-use alloc::{string::String};
-use core::{fmt, marker::PhantomData};
+use alloc::{
+ string::String,
+ vec::Vec,
+ collections::{BTreeSet, BTreeMap},
+ format,
+};
+#[cfg(feature = "std")]
+use std::collections::{BTreeSet, BTreeMap};
+use core::{
+ fmt::{self, Write},
+ marker::PhantomData,
+ cell::{Cell, RefCell},
+};
use impl_trait_for_tuples::impl_for_tuples;
use crate::types::*;
+#[derive(Default)]
+pub struct TypeCollector {
+ structs: RefCell<BTreeSet<string>>,
+ anonymous: RefCell<BTreeMap<Vec<string>, usize>>,
+ id: Cell<usize>,
+}
+impl TypeCollector {
+ pub fn new() -> Self {
+ Self::default()
+ }
+ pub fn collect(&self, item: string) {
+ self.structs.borrow_mut().insert(item);
+ }
+ pub fn next_id(&self) -> usize {
+ let v = self.id.get();
+ self.id.set(v + 1);
+ v
+ }
+ pub fn collect_tuple<T: SolidityTupleType>(&self) -> String {
+ let names = T::names(self);
+ if let Some(id) = self.anonymous.borrow().get(&names).cloned() {
+ return format!("Tuple{}", id);
+ }
+ let id = self.next_id();
+ let mut str = String::new();
+ writeln!(str, "// Anonymous struct").unwrap();
+ writeln!(str, "struct Tuple{} {{", id).unwrap();
+ for (i, name) in names.iter().enumerate() {
+ writeln!(str, "\t{} field_{};", name, i).unwrap();
+ }
+ writeln!(str, "}}").unwrap();
+ self.collect(str);
+ self.anonymous.borrow_mut().insert(names, id);
+ format!("Tuple{}", id)
+ }
+ pub fn finish(self) -> BTreeSet<string> {
+ self.structs.into_inner()
+ }
+}
+
pub trait SolidityTypeName: 'static {
- fn solidity_name(writer: &mut impl fmt::Write) -> fmt::Result;
- fn solidity_default(writer: &mut impl fmt::Write) -> fmt::Result;
+ fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
+ fn is_simple() -> bool;
+ fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
fn is_void() -> bool {
false
}
}
-
macro_rules! solidity_type_name {
- ($($ty:ident => $name:literal = $default:literal),* $(,)?) => {
+ ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {
$(
impl SolidityTypeName for $ty {
- fn solidity_name(writer: &mut impl core::fmt::Write) -> core::fmt::Result {
+ fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
write!(writer, $name)
}
- fn solidity_default(writer: &mut impl core::fmt::Write) -> core::fmt::Result {
+ fn is_simple() -> bool {
+ $simple
+ }
+ fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
write!(writer, $default)
}
}
@@ -28,20 +82,23 @@
}
solidity_type_name! {
- uint8 => "uint8" = "0",
- uint32 => "uint32" = "0",
- uint128 => "uint128" = "0",
- uint256 => "uint256" = "0",
- address => "address" = "0x0000000000000000000000000000000000000000",
- string => "string memory" = "\"\"",
- bytes => "bytes memory" = "hex\"\"",
- bool => "bool" = "false",
+ uint8 => "uint8" true = "0",
+ uint32 => "uint32" true = "0",
+ uint128 => "uint128" true = "0",
+ uint256 => "uint256" true = "0",
+ address => "address" true = "0x0000000000000000000000000000000000000000",
+ string => "string" false = "\"\"",
+ bytes => "bytes" false = "hex\"\"",
+ bool => "bool" true = "false",
}
impl SolidityTypeName for void {
- fn solidity_name(_writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
Ok(())
}
- fn solidity_default(_writer: &mut impl fmt::Write) -> fmt::Result {
+ fn is_simple() -> bool {
+ true
+ }
+ fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
Ok(())
}
fn is_void() -> bool {
@@ -49,10 +106,88 @@
}
}
+mod sealed {
+ pub trait CanBePlacedInVec {}
+}
+
+impl sealed::CanBePlacedInVec for uint256 {}
+impl sealed::CanBePlacedInVec for string {}
+impl sealed::CanBePlacedInVec for address {}
+
+impl<T: SolidityTypeName + sealed::CanBePlacedInVec> SolidityTypeName for Vec<T> {
+ fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ T::solidity_name(writer, tc)?;
+ write!(writer, "[]")
+ }
+ fn is_simple() -> bool {
+ false
+ }
+ fn solidity_default(writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
+ write!(writer, "[]")
+ }
+}
+
+pub trait SolidityTupleType {
+ fn names(tc: &TypeCollector) -> Vec<String>;
+ fn len() -> usize;
+}
+
+macro_rules! count {
+ () => (0usize);
+ ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));
+}
+
+macro_rules! impl_tuples {
+ ($($ident:ident)+) => {
+ impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
+ impl<$($ident: SolidityTypeName + 'static),+> SolidityTupleType for ($($ident,)+) {
+ fn names(tc: &TypeCollector) -> Vec<string> {
+ let mut collected = Vec::with_capacity(Self::len());
+ $({
+ let mut out = string::new();
+ $ident::solidity_name(&mut out, tc).expect("no fmt error");
+ collected.push(out);
+ })*;
+ collected
+ }
+
+ fn len() -> usize {
+ count!($($ident)*)
+ }
+ }
+ impl<$($ident: SolidityTypeName + 'static),+> SolidityTypeName for ($($ident,)+) {
+ fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ write!(writer, "{}", tc.collect_tuple::<Self>())
+ }
+ fn is_simple() -> bool {
+ false
+ }
+ fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ write!(writer, "{}(", tc.collect_tuple::<Self>())?;
+ $(
+ <$ident>::solidity_default(writer, tc)?;
+ )*
+ write!(writer, ")")
+ }
+ }
+ };
+}
+
+impl_tuples! {A}
+impl_tuples! {A B}
+impl_tuples! {A B C}
+impl_tuples! {A B C D}
+impl_tuples! {A B C D E}
+impl_tuples! {A B C D E F}
+impl_tuples! {A B C D E F G}
+impl_tuples! {A B C D E F G H}
+impl_tuples! {A B C D E F G H I}
+impl_tuples! {A B C D E F G H I J}
+
pub trait SolidityArguments {
- fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result;
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result;
- fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result;
+ fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
fn is_empty(&self) -> bool {
self.len() == 0
}
@@ -63,9 +198,13 @@
pub struct UnnamedArgument<T>(PhantomData<*const T>);
impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {
- fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
if !T::is_void() {
- T::solidity_name(writer)
+ T::solidity_name(writer, tc)?;
+ if !T::is_simple() {
+ write!(writer, " memory")?;
+ }
+ Ok(())
} else {
Ok(())
}
@@ -73,8 +212,8 @@
fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {
Ok(())
}
- fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {
- T::solidity_default(writer)
+ fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ T::solidity_default(writer, tc)
}
fn len(&self) -> usize {
if T::is_void() {
@@ -94,9 +233,12 @@
}
impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {
- fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
if !T::is_void() {
- T::solidity_name(writer)?;
+ T::solidity_name(writer, tc)?;
+ if !T::is_simple() {
+ write!(writer, " memory")?;
+ }
write!(writer, " {}", self.0)
} else {
Ok(())
@@ -105,8 +247,8 @@
fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {
writeln!(writer, "\t\t{};", self.0)
}
- fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {
- T::solidity_default(writer)
+ fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ T::solidity_default(writer, tc)
}
fn len(&self) -> usize {
if T::is_void() {
@@ -126,9 +268,9 @@
}
impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {
- fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
if !T::is_void() {
- T::solidity_name(writer)?;
+ T::solidity_name(writer, tc)?;
if self.0 {
write!(writer, " indexed")?;
}
@@ -140,8 +282,8 @@
fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {
writeln!(writer, "\t\t{};", self.1)
}
- fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {
- T::solidity_default(writer)
+ fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ T::solidity_default(writer, tc)
}
fn len(&self) -> usize {
if T::is_void() {
@@ -153,13 +295,13 @@
}
impl SolidityArguments for () {
- fn solidity_name(&self, _writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
Ok(())
}
fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {
Ok(())
}
- fn solidity_default(&self, _writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
Ok(())
}
fn len(&self) -> usize {
@@ -171,7 +313,7 @@
impl SolidityArguments for Tuple {
for_tuples!( where #( Tuple: SolidityArguments ),* );
- fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
let mut first = true;
for_tuples!( #(
if !Tuple.is_empty() {
@@ -179,7 +321,7 @@
write!(writer, ", ")?;
}
first = false;
- Tuple.solidity_name(writer)?;
+ Tuple.solidity_name(writer, tc)?;
}
)* );
Ok(())
@@ -190,12 +332,12 @@
)* );
Ok(())
}
- fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
if self.is_empty() {
Ok(())
} else if self.len() == 1 {
for_tuples!( #(
- Tuple.solidity_default(writer)?;
+ Tuple.solidity_default(writer, tc)?;
)* );
Ok(())
} else {
@@ -207,7 +349,7 @@
write!(writer, ", ")?;
}
first = false;
- Tuple.solidity_name(writer)?;
+ Tuple.solidity_default(writer, tc)?;
}
)* );
write!(writer, ")")?;
@@ -220,7 +362,12 @@
}
pub trait SolidityFunctions {
- fn solidity_name(&self, is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result;
+ fn solidity_name(
+ &self,
+ is_impl: bool,
+ writer: &mut impl fmt::Write,
+ tc: &TypeCollector,
+ ) -> fmt::Result;
}
pub enum SolidityMutability {
@@ -229,15 +376,22 @@
Mutable,
}
pub struct SolidityFunction<A, R> {
+ pub selector: &'static str,
pub name: &'static str,
pub args: A,
pub result: R,
pub mutability: SolidityMutability,
}
impl<A: SolidityArguments, R: SolidityArguments> SolidityFunctions for SolidityFunction<A, R> {
- fn solidity_name(&self, is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_name(
+ &self,
+ is_impl: bool,
+ writer: &mut impl fmt::Write,
+ tc: &TypeCollector,
+ ) -> fmt::Result {
+ writeln!(writer, "\t// Selector: {}", self.selector)?;
write!(writer, "\tfunction {}(", self.name)?;
- self.args.solidity_name(writer)?;
+ self.args.solidity_name(writer, tc)?;
write!(writer, ")")?;
if is_impl {
write!(writer, " public")?;
@@ -251,7 +405,7 @@
}
if !self.result.is_empty() {
write!(writer, " returns (")?;
- self.result.solidity_name(writer)?;
+ self.result.solidity_name(writer, tc)?;
write!(writer, ")")?;
}
if is_impl {
@@ -265,7 +419,7 @@
}
if !self.result.is_empty() {
write!(writer, "\t\treturn ")?;
- self.result.solidity_default(writer)?;
+ self.result.solidity_default(writer, tc)?;
writeln!(writer, ";")?;
}
writeln!(writer, "\t}}")?;
@@ -280,10 +434,15 @@
impl SolidityFunctions for Tuple {
for_tuples!( where #( Tuple: SolidityFunctions ),* );
- fn solidity_name(&self, is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_name(
+ &self,
+ is_impl: bool,
+ writer: &mut impl fmt::Write,
+ tc: &TypeCollector,
+ ) -> fmt::Result {
let mut first = false;
for_tuples!( #(
- Tuple.solidity_name(is_impl, writer)?;
+ Tuple.solidity_name(is_impl, writer, tc)?;
)* );
Ok(())
}
@@ -296,7 +455,12 @@
}
impl<F: SolidityFunctions> SolidityInterface<F> {
- pub fn format(&self, is_impl: bool, out: &mut impl fmt::Write) -> fmt::Result {
+ pub fn format(
+ &self,
+ is_impl: bool,
+ out: &mut impl fmt::Write,
+ tc: &TypeCollector,
+ ) -> fmt::Result {
if is_impl {
write!(out, "contract ")?;
} else {
@@ -313,7 +477,7 @@
}
}
writeln!(out, " {{")?;
- self.functions.solidity_name(is_impl, out)?;
+ self.functions.solidity_name(is_impl, out, tc)?;
writeln!(out, "}}")?;
Ok(())
}
@@ -325,9 +489,14 @@
}
impl<A: SolidityArguments> SolidityFunctions for SolidityEvent<A> {
- fn solidity_name(&self, _is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result {
+ fn solidity_name(
+ &self,
+ _is_impl: bool,
+ writer: &mut impl fmt::Write,
+ tc: &TypeCollector,
+ ) -> fmt::Result {
write!(writer, "\tevent {}(", self.name)?;
- self.args.solidity_name(writer)?;
+ self.args.solidity_name(writer, tc)?;
writeln!(writer, ");")
}
}
pallets/evm-contract-helpers/src/stubs/ContractHelpers.soldiffbeforeafterboth--- a/pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol
+++ b/pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol
@@ -10,6 +10,7 @@
}
contract ContractHelpers is Dummy {
+ // Selector: contractOwner(address) 5152b14c
function contractOwner(address contractAddress)
public
view
@@ -21,6 +22,7 @@
return 0x0000000000000000000000000000000000000000;
}
+ // Selector: sponsoringEnabled(address) 6027dc61
function sponsoringEnabled(address contractAddress)
public
view
@@ -32,6 +34,7 @@
return false;
}
+ // Selector: toggleSponsoring(address,bool) fcac6d86
function toggleSponsoring(address contractAddress, bool enabled) public {
require(false, stub_error);
contractAddress;
@@ -39,6 +42,7 @@
dummy = 0;
}
+ // Selector: setSponsoringRateLimit(address,uint32) 77b6c908
function setSponsoringRateLimit(address contractAddress, uint32 rateLimit)
public
{
@@ -48,6 +52,7 @@
dummy = 0;
}
+ // Selector: allowed(address,address) 5c658165
function allowed(address contractAddress, address user)
public
view
@@ -60,6 +65,7 @@
return false;
}
+ // Selector: allowlistEnabled(address) c772ef6c
function allowlistEnabled(address contractAddress)
public
view
@@ -71,6 +77,7 @@
return false;
}
+ // Selector: toggleAllowlist(address,bool) 36de20f5
function toggleAllowlist(address contractAddress, bool enabled) public {
require(false, stub_error);
contractAddress;
@@ -78,6 +85,7 @@
dummy = 0;
}
+ // Selector: toggleAllowed(address,address,bool) 4706cc1c
function toggleAllowed(
address contractAddress,
address user,
pallets/nft/src/eth/erc.rsdiffbeforeafterboth--- a/pallets/nft/src/eth/erc.rs
+++ b/pallets/nft/src/eth/erc.rs
@@ -8,6 +8,7 @@
};
use frame_support::storage::{StorageMap, StorageDoubleMap};
use pallet_evm::AddressMapping;
+use pallet_evm_coder_substrate::dispatch_to_evm;
use super::account::CrossAccountId;
use sp_std::{vec, vec::Vec};
@@ -299,6 +300,90 @@
.ok_or("item id overflow")?
.into())
}
+
+ fn set_variable_metadata(
+ &mut self,
+ caller: caller,
+ token_id: uint256,
+ data: bytes,
+ ) -> Result<void> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let token_id = token_id.try_into().map_err(|_| "token id overflow")?;
+
+ <Module<T>>::set_variable_meta_data_internal(&caller, self, token_id, data)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(())
+ }
+
+ fn get_variable_metadata(&self, token_id: uint256) -> Result<bytes> {
+ let token_id = token_id.try_into().map_err(|_| "token id overflow")?;
+
+ <Module<T>>::get_variable_metadata(self, token_id).map_err(dispatch_to_evm::<T>)
+ }
+
+ fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let to = T::CrossAccountId::from_eth(to);
+ let mut expected_index = <ItemListIndex>::get(self.id)
+ .checked_add(1)
+ .ok_or("item id overflow")?;
+
+ let total_tokens = token_ids.len();
+ for id in token_ids.into_iter() {
+ let id: u32 = id.try_into().map_err(|_| "token id overflow")?;
+ if id != expected_index {
+ return Err("item id should be next".into());
+ }
+ expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
+ }
+
+ let data = (0..total_tokens)
+ .map(|_| {
+ CreateItemData::NFT(CreateNftData {
+ const_data: vec![].try_into().unwrap(),
+ variable_data: vec![].try_into().unwrap(),
+ })
+ })
+ .collect();
+
+ <Module<T>>::create_multiple_items_internal(&caller, self, &to, data)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(true)
+ }
+
+ #[solidity(rename_selector = "mintBulkWithTokenURI")]
+ fn mint_bulk_with_token_uri(
+ &mut self,
+ caller: caller,
+ to: address,
+ tokens: Vec<(uint256, string)>,
+ ) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let to = T::CrossAccountId::from_eth(to);
+ let mut expected_index = <ItemListIndex>::get(self.id)
+ .checked_add(1)
+ .ok_or("item id overflow")?;
+
+ let mut data = Vec::with_capacity(tokens.len());
+ for (id, token_uri) in tokens {
+ let id: u32 = id.try_into().map_err(|_| "token id overflow")?;
+ if id != expected_index {
+ panic!("item id should be next ({}) but got {}", expected_index, id);
+ }
+ expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
+
+ data.push(CreateItemData::NFT(CreateNftData {
+ const_data: Vec::<u8>::from(token_uri)
+ .try_into()
+ .map_err(|_| "token uri is too long")?,
+ variable_data: vec![].try_into().unwrap(),
+ }));
+ }
+
+ <Module<T>>::create_multiple_items_internal(&caller, self, &to, data)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(true)
+ }
}
#[solidity_interface(
pallets/nft/src/eth/stubs/UniqueFungible.soldiffbeforeafterboth--- a/pallets/nft/src/eth/stubs/UniqueFungible.sol
+++ b/pallets/nft/src/eth/stubs/UniqueFungible.sol
@@ -21,12 +21,14 @@
// Inline
contract InlineNameSymbol is Dummy {
+ // Selector: name() 06fdde03
function name() public view returns (string memory) {
require(false, stub_error);
dummy;
return "";
}
+ // Selector: symbol() 95d89b41
function symbol() public view returns (string memory) {
require(false, stub_error);
dummy;
@@ -36,6 +38,7 @@
// Inline
contract InlineTotalSupply is Dummy {
+ // Selector: totalSupply() 18160ddd
function totalSupply() public view returns (uint256) {
require(false, stub_error);
dummy;
@@ -44,6 +47,7 @@
}
contract ERC165 is Dummy {
+ // Selector: supportsInterface(bytes4) 01ffc9a7
function supportsInterface(uint32 interfaceId) public view returns (bool) {
require(false, stub_error);
interfaceId;
@@ -53,12 +57,14 @@
}
contract ERC20 is Dummy, InlineNameSymbol, InlineTotalSupply, ERC20Events {
+ // Selector: decimals() 313ce567
function decimals() public view returns (uint8) {
require(false, stub_error);
dummy;
return 0;
}
+ // Selector: balanceOf(address) 70a08231
function balanceOf(address owner) public view returns (uint256) {
require(false, stub_error);
owner;
@@ -66,6 +72,7 @@
return 0;
}
+ // Selector: transfer(address,uint256) a9059cbb
function transfer(address to, uint256 amount) public returns (bool) {
require(false, stub_error);
to;
@@ -74,6 +81,7 @@
return false;
}
+ // Selector: transferFrom(address,address,uint256) 23b872dd
function transferFrom(
address from,
address to,
@@ -87,6 +95,7 @@
return false;
}
+ // Selector: approve(address,uint256) 095ea7b3
function approve(address spender, uint256 amount) public returns (bool) {
require(false, stub_error);
spender;
@@ -95,6 +104,7 @@
return false;
}
+ // Selector: allowance(address,address) dd62ed3e
function allowance(address owner, address spender)
public
view
pallets/nft/src/eth/stubs/UniqueNFT.rawdiffbeforeafterbothbinary blob — no preview
pallets/nft/src/eth/stubs/UniqueNFT.soldiffbeforeafterboth--- a/pallets/nft/src/eth/stubs/UniqueNFT.sol
+++ b/pallets/nft/src/eth/stubs/UniqueNFT.sol
@@ -3,6 +3,12 @@
pragma solidity >=0.8.0 <0.9.0;
+// Anonymous struct
+struct Tuple0 {
+ uint256 field_0;
+ string field_1;
+}
+
// Common stubs holder
contract Dummy {
uint8 dummy;
@@ -35,12 +41,14 @@
// Inline
contract InlineNameSymbol is Dummy {
+ // Selector: name() 06fdde03
function name() public view returns (string memory) {
require(false, stub_error);
dummy;
return "";
}
+ // Selector: symbol() 95d89b41
function symbol() public view returns (string memory) {
require(false, stub_error);
dummy;
@@ -50,6 +58,7 @@
// Inline
contract InlineTotalSupply is Dummy {
+ // Selector: totalSupply() 18160ddd
function totalSupply() public view returns (uint256) {
require(false, stub_error);
dummy;
@@ -58,6 +67,7 @@
}
contract ERC165 is Dummy {
+ // Selector: supportsInterface(bytes4) 01ffc9a7
function supportsInterface(uint32 interfaceId) public view returns (bool) {
require(false, stub_error);
interfaceId;
@@ -67,6 +77,7 @@
}
contract ERC721 is Dummy, ERC165, ERC721Events {
+ // Selector: balanceOf(address) 70a08231
function balanceOf(address owner) public view returns (uint256) {
require(false, stub_error);
owner;
@@ -74,6 +85,7 @@
return 0;
}
+ // Selector: ownerOf(uint256) 6352211e
function ownerOf(uint256 tokenId) public view returns (address) {
require(false, stub_error);
tokenId;
@@ -81,6 +93,7 @@
return 0x0000000000000000000000000000000000000000;
}
+ // Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
function safeTransferFromWithData(
address from,
address to,
@@ -95,6 +108,7 @@
dummy = 0;
}
+ // Selector: safeTransferFrom(address,address,uint256) 42842e0e
function safeTransferFrom(
address from,
address to,
@@ -107,6 +121,7 @@
dummy = 0;
}
+ // Selector: transferFrom(address,address,uint256) 23b872dd
function transferFrom(
address from,
address to,
@@ -119,6 +134,7 @@
dummy = 0;
}
+ // Selector: approve(address,uint256) 095ea7b3
function approve(address approved, uint256 tokenId) public {
require(false, stub_error);
approved;
@@ -126,6 +142,7 @@
dummy = 0;
}
+ // Selector: setApprovalForAll(address,bool) a22cb465
function setApprovalForAll(address operator, bool approved) public {
require(false, stub_error);
operator;
@@ -133,6 +150,7 @@
dummy = 0;
}
+ // Selector: getApproved(uint256) 081812fc
function getApproved(uint256 tokenId) public view returns (address) {
require(false, stub_error);
tokenId;
@@ -140,6 +158,7 @@
return 0x0000000000000000000000000000000000000000;
}
+ // Selector: isApprovedForAll(address,address) e985e9c5
function isApprovedForAll(address owner, address operator)
public
view
@@ -154,6 +173,7 @@
}
contract ERC721Burnable is Dummy {
+ // Selector: burn(uint256) 42966c68
function burn(uint256 tokenId) public {
require(false, stub_error);
tokenId;
@@ -162,6 +182,7 @@
}
contract ERC721Enumerable is Dummy, InlineTotalSupply {
+ // Selector: tokenByIndex(uint256) 4f6ccce7
function tokenByIndex(uint256 index) public view returns (uint256) {
require(false, stub_error);
index;
@@ -169,6 +190,7 @@
return 0;
}
+ // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
@@ -183,6 +205,7 @@
}
contract ERC721Metadata is Dummy, InlineNameSymbol {
+ // Selector: tokenURI(uint256) c87b56dd
function tokenURI(uint256 tokenId) public view returns (string memory) {
require(false, stub_error);
tokenId;
@@ -192,12 +215,14 @@
}
contract ERC721Mintable is Dummy, ERC721MintableEvents {
+ // Selector: mintingFinished() 05d2035b
function mintingFinished() public view returns (bool) {
require(false, stub_error);
dummy;
return false;
}
+ // Selector: mint(address,uint256) 40c10f19
function mint(address to, uint256 tokenId) public returns (bool) {
require(false, stub_error);
to;
@@ -206,6 +231,7 @@
return false;
}
+ // Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
function mintWithTokenURI(
address to,
uint256 tokenId,
@@ -219,6 +245,7 @@
return false;
}
+ // Selector: finishMinting() 7d64bcb4
function finishMinting() public returns (bool) {
require(false, stub_error);
dummy = 0;
@@ -227,6 +254,7 @@
}
contract ERC721UniqueExtensions is Dummy {
+ // Selector: transfer(address,uint256) a9059cbb
function transfer(address to, uint256 tokenId) public {
require(false, stub_error);
to;
@@ -234,11 +262,56 @@
dummy = 0;
}
+ // Selector: nextTokenId() 75794a3c
function nextTokenId() public view returns (uint256) {
require(false, stub_error);
dummy;
return 0;
}
+
+ // Selector: setVariableMetadata(uint256,bytes) d4eac26d
+ function setVariableMetadata(uint256 tokenId, bytes memory data) public {
+ require(false, stub_error);
+ tokenId;
+ data;
+ dummy = 0;
+ }
+
+ // Selector: getVariableMetadata(uint256) e6c5ce6f
+ function getVariableMetadata(uint256 tokenId)
+ public
+ view
+ returns (bytes memory)
+ {
+ require(false, stub_error);
+ tokenId;
+ dummy;
+ return hex"";
+ }
+
+ // Selector: mintBulk(address,uint256[]) 44a9945e
+ function mintBulk(address to, uint256[] memory tokenIds)
+ public
+ returns (bool)
+ {
+ require(false, stub_error);
+ to;
+ tokenIds;
+ dummy = 0;
+ return false;
+ }
+
+ // Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
+ function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
+ public
+ returns (bool)
+ {
+ require(false, stub_error);
+ to;
+ tokens;
+ dummy = 0;
+ return false;
+ }
}
contract UniqueNFT is
pallets/nft/src/lib.rsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9 clippy::too_many_arguments,10 clippy::unnecessary_mut_passed,11 clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41 CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42 VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43 OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44 MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45 CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46 FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70 /// Error for non-fungible-token module.71 pub enum Error for Module<T: Config> {72 /// Total collections bound exceeded.73 TotalCollectionsLimitExceeded,74 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75 CollectionDecimalPointLimitExceeded,76 /// Collection name can not be longer than 63 char.77 CollectionNameLimitExceeded,78 /// Collection description can not be longer than 255 char.79 CollectionDescriptionLimitExceeded,80 /// Token prefix can not be longer than 15 char.81 CollectionTokenPrefixLimitExceeded,82 /// This collection does not exist.83 CollectionNotFound,84 /// Item not exists.85 TokenNotFound,86 /// Admin not found87 AdminNotFound,88 /// Arithmetic calculation overflow.89 NumOverflow,90 /// Account already has admin role.91 AlreadyAdmin,92 /// You do not own this collection.93 NoPermission,94 /// This address is not set as sponsor, use setCollectionSponsor first.95 ConfirmUnsetSponsorFail,96 /// Collection is not in mint mode.97 PublicMintingNotAllowed,98 /// Sender parameter and item owner must be equal.99 MustBeTokenOwner,100 /// Item balance not enough.101 TokenValueTooLow,102 /// Size of item is too large.103 NftSizeLimitExceeded,104 /// No approve found105 ApproveNotFound,106 /// Requested value more than approved.107 TokenValueNotEnough,108 /// Only approved addresses can call this method.109 ApproveRequired,110 /// Address is not in white list.111 AddresNotInWhiteList,112 /// Number of collection admins bound exceeded.113 CollectionAdminsLimitExceeded,114 /// Owned tokens by a single address bound exceeded.115 AddressOwnershipLimitExceeded,116 /// Length of items properties must be greater than 0.117 EmptyArgument,118 /// const_data exceeded data limit.119 TokenConstDataLimitExceeded,120 /// variable_data exceeded data limit.121 TokenVariableDataLimitExceeded,122 /// Not NFT item data used to mint in NFT collection.123 NotNftDataUsedToMintNftCollectionToken,124 /// Not Fungible item data used to mint in Fungible collection.125 NotFungibleDataUsedToMintFungibleCollectionToken,126 /// Not Re Fungible item data used to mint in Re Fungible collection.127 NotReFungibleDataUsedToMintReFungibleCollectionToken,128 /// Unexpected collection type.129 UnexpectedCollectionType,130 /// Can't store metadata in fungible tokens.131 CantStoreMetadataInFungibleTokens,132 /// Collection token limit exceeded133 CollectionTokenLimitExceeded,134 /// Account token limit exceeded per collection135 AccountTokenLimitExceeded,136 /// Collection limit bounds per collection exceeded137 CollectionLimitBoundsExceeded,138 /// Tried to enable permissions which are only permitted to be disabled139 OwnerPermissionsCantBeReverted,140 /// Schema data size limit bound exceeded141 SchemaDataLimitExceeded,142 /// Maximum refungibility exceeded143 WrongRefungiblePieces,144 /// createRefungible should be called with one owner145 BadCreateRefungibleCall,146 /// Gas limit exceeded147 OutOfGas,148 /// Collection settings not allowing items transferring149 TransferNotAllowed,150 /// Can't transfer tokens to ethereum zero address151 AddressIsZero,152 }153}154155#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]156pub struct CollectionHandle<T: Config> {157 pub id: CollectionId,158 collection: Collection<T>,159 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,160}161impl<T: Config> CollectionHandle<T> {162 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {163 <CollectionById<T>>::get(id).map(|collection| Self {164 id,165 collection,166 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(167 eth::collection_id_to_address(id),168 gas_limit,169 ),170 })171 }172 pub fn get(id: CollectionId) -> Option<Self> {173 Self::get_with_gas_limit(id, u64::MAX)174 }175 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {176 self.recorder.log_sub(log)177 }178 #[allow(dead_code)]179 fn consume_gas(&self, gas: u64) -> DispatchResult {180 self.recorder.consume_gas_sub(gas)181 }182 fn consume_sload(&self) -> DispatchResult {183 self.recorder.consume_sload_sub()184 }185 fn consume_sstore(&self) -> DispatchResult {186 self.recorder.consume_sstore_sub()187 }188 pub fn submit_logs(self) -> DispatchResult {189 self.recorder.submit_logs()190 }191 pub fn save(self) -> DispatchResult {192 self.recorder.submit_logs()?;193 <CollectionById<T>>::insert(self.id, self.collection);194 Ok(())195 }196}197impl<T: Config> Deref for CollectionHandle<T> {198 type Target = Collection<T>;199200 fn deref(&self) -> &Self::Target {201 &self.collection202 }203}204205impl<T: Config> DerefMut for CollectionHandle<T> {206 fn deref_mut(&mut self) -> &mut Self::Target {207 &mut self.collection208 }209}210211pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {212 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;213214 /// Weight information for extrinsics in this pallet.215 type WeightInfo: WeightInfo;216217 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;218 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;219220 type CrossAccountId: CrossAccountId<Self::AccountId>;221 type Currency: Currency<Self::AccountId>;222 type CollectionCreationPrice: Get<223 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,224 >;225 type TreasuryAccountId: Get<Self::AccountId>;226}227228type SelfWeightOf<T> = <T as Config>::WeightInfo;229230trait WeightInfoHelpers: WeightInfo {231 fn transfer() -> Weight {232 Self::transfer_nft()233 .max(Self::transfer_fungible())234 .max(Self::transfer_refungible())235 }236 fn transfer_from() -> Weight {237 Self::transfer_from_nft()238 .max(Self::transfer_from_fungible())239 .max(Self::transfer_from_refungible())240 }241 fn approve() -> Weight {242 // TODO: refungible, fungible243 Self::approve_nft()244 }245 fn set_variable_meta_data(data: u32) -> Weight {246 // TODO: refungible247 Self::set_variable_meta_data_nft(data)248 }249 fn create_item(data: u32) -> Weight {250 Self::create_item_nft(data)251 .max(Self::create_item_fungible())252 .max(Self::create_item_refungible(data))253 }254 fn burn_item() -> Weight {255 // TODO: refungible, fungible256 Self::burn_item_nft()257 }258}259impl<T: WeightInfo> WeightInfoHelpers for T {}260261// # Used definitions262//263// ## User control levels264//265// chain-controlled - key is uncontrolled by user266// i.e autoincrementing index267// can use non-cryptographic hash268// real - key is controlled by user269// but it is hard to generate enough colliding values, i.e owner of signed txs270// can use non-cryptographic hash271// controlled - key is completly controlled by users272// i.e maps with mutable keys273// should use cryptographic hash274//275// ## User control level downgrade reasons276//277// ?1 - chain-controlled -> controlled278// collections/tokens can be destroyed, resulting in massive holes279// ?2 - chain-controlled -> controlled280// same as ?1, but can be only added, resulting in easier exploitation281// ?3 - real -> controlled282// no confirmation required, so addresses can be easily generated283decl_storage! {284 trait Store for Module<T: Config> as Nft {285286 //#region Private members287 /// Id of next collection288 CreatedCollectionCount: u32;289 /// Used for migrations290 ChainVersion: u64;291 /// Id of last collection token292 /// Collection id (controlled?1)293 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;294 //#endregion295296 //#region Bound counters297 /// Amount of collections destroyed, used for total amount tracking with298 /// CreatedCollectionCount299 DestroyedCollectionCount: u32;300 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)301 /// Account id (real)302 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;303 //#endregion304305 //#region Basic collections306 /// Collection info307 /// Collection id (controlled?1)308 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;309 /// List of collection admins310 /// Collection id (controlled?2)311 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;312 /// Whitelisted collection users313 /// Collection id (controlled?2), user id (controlled?3)314 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;315 //#endregion316317 /// How many of collection items user have318 /// Collection id (controlled?2), account id (real)319 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;320321 /// Amount of items which spender can transfer out of owners account (via transferFrom)322 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))323 /// TODO: Off chain worker should remove from this map when token gets removed324 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;325326 //#region Item collections327 /// Collection id (controlled?2), token id (controlled?1)328 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;329 /// Collection id (controlled?2), owner (controlled?2)330 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;331 /// Collection id (controlled?2), token id (controlled?1)332 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;333 //#endregion334335 //#region Index list336 /// Collection id (controlled?2), tokens owner (controlled?2)337 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;338 //#endregion339340 //#region Tokens transfer rate limit baskets341 /// (Collection id (controlled?2), who created (real))342 /// TODO: Off chain worker should remove from this map when collection gets removed343 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;344 /// Collection id (controlled?2), token id (controlled?2)345 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;346 /// Collection id (controlled?2), owning user (real)347 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;348 /// Collection id (controlled?2), token id (controlled?2)349 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;350 //#endregion351352 /// Variable metadata sponsoring353 /// Collection id (controlled?2), token id (controlled?2)354 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;355 }356 add_extra_genesis {357 build(|config: &GenesisConfig<T>| {358 // Modification of storage359 for (_num, _c) in &config.collection_id {360 <Module<T>>::init_collection(_c);361 }362363 for (_num, _c, _i) in &config.nft_item_id {364 <Module<T>>::init_nft_token(*_c, _i);365 }366367 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {368 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);369 }370371 for (_num, _c, _i) in &config.refungible_item_id {372 <Module<T>>::init_refungible_token(*_c, _i);373 }374 })375 }376}377378decl_event!(379 pub enum Event<T>380 where381 AccountId = <T as frame_system::Config>::AccountId,382 CrossAccountId = <T as Config>::CrossAccountId,383 {384 /// New collection was created385 ///386 /// # Arguments387 ///388 /// * collection_id: Globally unique identifier of newly created collection.389 ///390 /// * mode: [CollectionMode] converted into u8.391 ///392 /// * account_id: Collection owner.393 CollectionCreated(CollectionId, u8, AccountId),394395 /// New item was created.396 ///397 /// # Arguments398 ///399 /// * collection_id: Id of the collection where item was created.400 ///401 /// * item_id: Id of an item. Unique within the collection.402 ///403 /// * recipient: Owner of newly created item404 ItemCreated(CollectionId, TokenId, CrossAccountId),405406 /// Collection item was burned.407 ///408 /// # Arguments409 ///410 /// collection_id.411 ///412 /// item_id: Identifier of burned NFT.413 ItemDestroyed(CollectionId, TokenId),414415 /// Item was transferred416 ///417 /// * collection_id: Id of collection to which item is belong418 ///419 /// * item_id: Id of an item420 ///421 /// * sender: Original owner of item422 ///423 /// * recipient: New owner of item424 ///425 /// * amount: Always 1 for NFT426 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),427428 /// * collection_id429 ///430 /// * item_id431 ///432 /// * sender433 ///434 /// * spender435 ///436 /// * amount437 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),438 }439);440441decl_module! {442 pub struct Module<T: Config> for enum Call443 where444 origin: T::Origin445 {446 fn deposit_event() = default;447 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;448 type Error = Error<T>;449450 fn on_initialize(_now: T::BlockNumber) -> Weight {451 0452 }453454 /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.455 ///456 /// # Permissions457 ///458 /// * Anyone.459 ///460 /// # Arguments461 ///462 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.463 ///464 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.465 ///466 /// * token_prefix: UTF-8 string with token prefix.467 ///468 /// * mode: [CollectionMode] collection type and type dependent data.469 // returns collection ID470 #[weight = <SelfWeightOf<T>>::create_collection()]471 #[transactional]472 pub fn create_collection(origin,473 collection_name: Vec<u16>,474 collection_description: Vec<u16>,475 token_prefix: Vec<u8>,476 mode: CollectionMode) -> DispatchResult {477478 // Anyone can create a collection479 let who = ensure_signed(origin)?;480481 // Take a (non-refundable) deposit of collection creation482 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();483 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(484 &T::TreasuryAccountId::get(),485 T::CollectionCreationPrice::get(),486 ));487 <T as Config>::Currency::settle(488 &who,489 imbalance,490 WithdrawReasons::TRANSFER,491 ExistenceRequirement::KeepAlive,492 ).map_err(|_| Error::<T>::NoPermission)?;493494 let decimal_points = match mode {495 CollectionMode::Fungible(points) => points,496 _ => 0497 };498499 let created_count = CreatedCollectionCount::get();500 let destroyed_count = DestroyedCollectionCount::get();501502 // bound Total number of collections503 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);504505 // check params506 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);507 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);508 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);509 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);510511 // Generate next collection ID512 let next_id = created_count513 .checked_add(1)514 .ok_or(Error::<T>::NumOverflow)?;515516 CreatedCollectionCount::put(next_id);517518 let limits = CollectionLimits {519 sponsored_data_size: CUSTOM_DATA_LIMIT,520 ..Default::default()521 };522523 // Create new collection524 let new_collection = Collection {525 owner: who.clone(),526 name: collection_name,527 mode: mode.clone(),528 mint_mode: false,529 access: AccessMode::Normal,530 description: collection_description,531 decimal_points,532 token_prefix,533 offchain_schema: Vec::new(),534 schema_version: SchemaVersion::ImageURL,535 sponsorship: SponsorshipState::Disabled,536 variable_on_chain_schema: Vec::new(),537 const_on_chain_schema: Vec::new(),538 limits,539 transfers_enabled: true,540 };541542 // Add new collection to map543 <CollectionById<T>>::insert(next_id, new_collection);544545 // call event546 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));547548 Ok(())549 }550551 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.552 ///553 /// # Permissions554 ///555 /// * Collection Owner.556 ///557 /// # Arguments558 ///559 /// * collection_id: collection to destroy.560 #[weight = <SelfWeightOf<T>>::destroy_collection()]561 #[transactional]562 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {563564 let sender = ensure_signed(origin)?;565 let collection = Self::get_collection(collection_id)?;566 Self::check_owner_permissions(&collection, &sender)?;567 if !collection.limits.owner_can_destroy {568 fail!(Error::<T>::NoPermission);569 }570571 <AddressTokens<T>>::remove_prefix(collection_id, None);572 <Allowances<T>>::remove_prefix(collection_id, None);573 <Balance<T>>::remove_prefix(collection_id, None);574 <ItemListIndex>::remove(collection_id);575 <AdminList<T>>::remove(collection_id);576 <CollectionById<T>>::remove(collection_id);577 <WhiteList<T>>::remove_prefix(collection_id, None);578579 <NftItemList<T>>::remove_prefix(collection_id, None);580 <FungibleItemList<T>>::remove_prefix(collection_id, None);581 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);582583 <NftTransferBasket<T>>::remove_prefix(collection_id, None);584 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);585 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);586587 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);588589 DestroyedCollectionCount::put(DestroyedCollectionCount::get()590 .checked_add(1)591 .ok_or(Error::<T>::NumOverflow)?);592593 Ok(())594 }595596 /// Add an address to white list.597 ///598 /// # Permissions599 ///600 /// * Collection Owner601 /// * Collection Admin602 ///603 /// # Arguments604 ///605 /// * collection_id.606 ///607 /// * address.608 #[weight = <SelfWeightOf<T>>::add_to_white_list()]609 #[transactional]610 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{611612 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);613 let collection = Self::get_collection(collection_id)?;614615 Self::toggle_white_list_internal(616 &sender,617 &collection,618 &address,619 true,620 )?;621622 Ok(())623 }624625 /// Remove an address from white list.626 ///627 /// # Permissions628 ///629 /// * Collection Owner630 /// * Collection Admin631 ///632 /// # Arguments633 ///634 /// * collection_id.635 ///636 /// * address.637 #[weight = <SelfWeightOf<T>>::remove_from_white_list()]638 #[transactional]639 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{640641 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);642 let collection = Self::get_collection(collection_id)?;643644 Self::toggle_white_list_internal(645 &sender,646 &collection,647 &address,648 false,649 )?;650651 Ok(())652 }653654 /// Toggle between normal and white list access for the methods with access for `Anyone`.655 ///656 /// # Permissions657 ///658 /// * Collection Owner.659 ///660 /// # Arguments661 ///662 /// * collection_id.663 ///664 /// * mode: [AccessMode]665 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]666 #[transactional]667 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult668 {669 let sender = ensure_signed(origin)?;670671 let mut target_collection = Self::get_collection(collection_id)?;672 Self::check_owner_permissions(&target_collection, &sender)?;673 target_collection.access = mode;674 target_collection.save()675 }676677 /// Allows Anyone to create tokens if:678 /// * White List is enabled, and679 /// * Address is added to white list, and680 /// * This method was called with True parameter681 ///682 /// # Permissions683 /// * Collection Owner684 ///685 /// # Arguments686 ///687 /// * collection_id.688 ///689 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.690 #[weight = <SelfWeightOf<T>>::set_mint_permission()]691 #[transactional]692 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult693 {694 let sender = ensure_signed(origin)?;695696 let mut target_collection = Self::get_collection(collection_id)?;697 Self::check_owner_permissions(&target_collection, &sender)?;698 target_collection.mint_mode = mint_permission;699 target_collection.save()700 }701702 /// Change the owner of the collection.703 ///704 /// # Permissions705 ///706 /// * Collection Owner.707 ///708 /// # Arguments709 ///710 /// * collection_id.711 ///712 /// * new_owner.713 #[weight = <SelfWeightOf<T>>::change_collection_owner()]714 #[transactional]715 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {716717 let sender = ensure_signed(origin)?;718 let mut target_collection = Self::get_collection(collection_id)?;719 Self::check_owner_permissions(&target_collection, &sender)?;720 target_collection.owner = new_owner;721 target_collection.save()722 }723724 /// Adds an admin of the Collection.725 /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.726 ///727 /// # Permissions728 ///729 /// * Collection Owner.730 /// * Collection Admin.731 ///732 /// # Arguments733 ///734 /// * collection_id: ID of the Collection to add admin for.735 ///736 /// * new_admin_id: Address of new admin to add.737 #[weight = <SelfWeightOf<T>>::add_collection_admin()]738 #[transactional]739 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {740 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);741 let collection = Self::get_collection(collection_id)?;742 Self::check_owner_or_admin_permissions(&collection, &sender)?;743 let mut admin_arr = <AdminList<T>>::get(collection_id);744745 match admin_arr.binary_search(&new_admin_id) {746 Ok(_) => {},747 Err(idx) => {748 ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);749 admin_arr.insert(idx, new_admin_id);750 <AdminList<T>>::insert(collection_id, admin_arr);751 }752 }753 Ok(())754 }755756 /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.757 ///758 /// # Permissions759 ///760 /// * Collection Owner.761 /// * Collection Admin.762 ///763 /// # Arguments764 ///765 /// * collection_id: ID of the Collection to remove admin for.766 ///767 /// * account_id: Address of admin to remove.768 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]769 #[transactional]770 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {771 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);772 let collection = Self::get_collection(collection_id)?;773 Self::check_owner_or_admin_permissions(&collection, &sender)?;774 let mut admin_arr = <AdminList<T>>::get(collection_id);775776 if let Ok(idx) = admin_arr.binary_search(&account_id) {777 admin_arr.remove(idx);778 <AdminList<T>>::insert(collection_id, admin_arr);779 }780 Ok(())781 }782783 /// # Permissions784 ///785 /// * Collection Owner786 ///787 /// # Arguments788 ///789 /// * collection_id.790 ///791 /// * new_sponsor.792 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]793 #[transactional]794 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {795 let sender = ensure_signed(origin)?;796 let mut target_collection = Self::get_collection(collection_id)?;797 Self::check_owner_permissions(&target_collection, &sender)?;798799 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);800 target_collection.save()801 }802803 /// # Permissions804 ///805 /// * Sponsor.806 ///807 /// # Arguments808 ///809 /// * collection_id.810 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]811 #[transactional]812 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {813 let sender = ensure_signed(origin)?;814815 let mut target_collection = Self::get_collection(collection_id)?;816 ensure!(817 target_collection.sponsorship.pending_sponsor() == Some(&sender),818 Error::<T>::ConfirmUnsetSponsorFail819 );820821 target_collection.sponsorship = SponsorshipState::Confirmed(sender);822 target_collection.save()823 }824825 /// Switch back to pay-per-own-transaction model.826 ///827 /// # Permissions828 ///829 /// * Collection owner.830 ///831 /// # Arguments832 ///833 /// * collection_id.834 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]835 #[transactional]836 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {837 let sender = ensure_signed(origin)?;838839 let mut target_collection = Self::get_collection(collection_id)?;840 Self::check_owner_permissions(&target_collection, &sender)?;841842 target_collection.sponsorship = SponsorshipState::Disabled;843 target_collection.save()844 }845846 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.847 ///848 /// # Permissions849 ///850 /// * Collection Owner.851 /// * Collection Admin.852 /// * Anyone if853 /// * White List is enabled, and854 /// * Address is added to white list, and855 /// * MintPermission is enabled (see SetMintPermission method)856 ///857 /// # Arguments858 ///859 /// * collection_id: ID of the collection.860 ///861 /// * owner: Address, initial owner of the NFT.862 ///863 /// * data: Token data to store on chain.864 // #[weight =865 // (130_000_000 as Weight)866 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))867 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))868 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]869870 #[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]871 #[transactional]872 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {873 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);874 let collection = Self::get_collection(collection_id)?;875876 Self::create_item_internal(&sender, &collection, &owner, data)?;877878 collection.submit_logs()879 }880881 /// This method creates multiple items in a collection created with CreateCollection method.882 ///883 /// # Permissions884 ///885 /// * Collection Owner.886 /// * Collection Admin.887 /// * Anyone if888 /// * White List is enabled, and889 /// * Address is added to white list, and890 /// * MintPermission is enabled (see SetMintPermission method)891 ///892 /// # Arguments893 ///894 /// * collection_id: ID of the collection.895 ///896 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].897 ///898 /// * owner: Address, initial owner of the NFT.899 #[weight = <SelfWeightOf<T>>::create_item(items_data.iter()900 .map(|data| { data.data_size() as u32 })901 .sum())]902 #[transactional]903 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {904905 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);906 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);907 let collection = Self::get_collection(collection_id)?;908909 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;910911 collection.submit_logs()912 }913914 // TODO! transaction weight915916 /// Set transfers_enabled value for particular collection917 ///918 /// # Permissions919 ///920 /// * Collection Owner.921 ///922 /// # Arguments923 ///924 /// * collection_id: ID of the collection.925 ///926 /// * value: New flag value.927 #[weight = <SelfWeightOf<T>>::burn_item()]928 #[transactional]929 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {930931 let sender = ensure_signed(origin)?;932 let mut target_collection = Self::get_collection(collection_id)?;933934 Self::check_owner_permissions(&target_collection, &sender)?;935936 target_collection.transfers_enabled = value;937 target_collection.save()938 }939940 /// Destroys a concrete instance of NFT.941 ///942 /// # Permissions943 ///944 /// * Collection Owner.945 /// * Collection Admin.946 /// * Current NFT Owner.947 ///948 /// # Arguments949 ///950 /// * collection_id: ID of the collection.951 ///952 /// * item_id: ID of NFT to burn.953 #[weight = <SelfWeightOf<T>>::burn_item()]954 #[transactional]955 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {956957 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);958 let target_collection = Self::get_collection(collection_id)?;959960 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;961962 target_collection.submit_logs()963 }964965 /// Change ownership of the token.966 ///967 /// # Permissions968 ///969 /// * Collection Owner970 /// * Collection Admin971 /// * Current NFT owner972 ///973 /// # Arguments974 ///975 /// * recipient: Address of token recipient.976 ///977 /// * collection_id.978 ///979 /// * item_id: ID of the item980 /// * Non-Fungible Mode: Required.981 /// * Fungible Mode: Ignored.982 /// * Re-Fungible Mode: Required.983 ///984 /// * value: Amount to transfer.985 /// * Non-Fungible Mode: Ignored986 /// * Fungible Mode: Must specify transferred amount987 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)988 #[weight = <SelfWeightOf<T>>::transfer()]989 #[transactional]990 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);992 let collection = Self::get_collection(collection_id)?;993994 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;995996 collection.submit_logs()997 }998999 /// Set, change, or remove approved address to transfer the ownership of the NFT.1000 ///1001 /// # Permissions1002 ///1003 /// * Collection Owner1004 /// * Collection Admin1005 /// * Current NFT owner1006 ///1007 /// # Arguments1008 ///1009 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1010 ///1011 /// * collection_id.1012 ///1013 /// * item_id: ID of the item.1014 #[weight = <SelfWeightOf<T>>::approve()]1015 #[transactional]1016 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1017 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1018 let collection = Self::get_collection(collection_id)?;10191020 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10211022 collection.submit_logs()1023 }10241025 /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1026 ///1027 /// # Permissions1028 /// * Collection Owner1029 /// * Collection Admin1030 /// * Current NFT owner1031 /// * Address approved by current NFT owner1032 ///1033 /// # Arguments1034 ///1035 /// * from: Address that owns token.1036 ///1037 /// * recipient: Address of token recipient.1038 ///1039 /// * collection_id.1040 ///1041 /// * item_id: ID of the item.1042 ///1043 /// * value: Amount to transfer.1044 #[weight = <SelfWeightOf<T>>::transfer_from()]1045 #[transactional]1046 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1047 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1048 let collection = Self::get_collection(collection_id)?;10491050 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10511052 collection.submit_logs()1053 }1054 // #[weight = 0]1055 // // let no_perm_mes = "You do not have permissions to modify this collection";1056 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1057 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1058 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10591060 // // // on_nft_received call10611062 // // Self::transfer(origin, collection_id, item_id, new_owner)?;10631064 // Ok(())1065 // }10661067 /// Set off-chain data schema.1068 ///1069 /// # Permissions1070 ///1071 /// * Collection Owner1072 /// * Collection Admin1073 ///1074 /// # Arguments1075 ///1076 /// * collection_id.1077 ///1078 /// * schema: String representing the offchain data schema.1079 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1080 #[transactional]1081 pub fn set_variable_meta_data (1082 origin,1083 collection_id: CollectionId,1084 item_id: TokenId,1085 data: Vec<u8>1086 ) -> DispatchResult {1087 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10881089 let collection = Self::get_collection(collection_id)?;10901091 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10921093 Ok(())1094 }10951096 /// Set schema standard1097 /// ImageURL1098 /// Unique1099 ///1100 /// # Permissions1101 ///1102 /// * Collection Owner1103 /// * Collection Admin1104 ///1105 /// # Arguments1106 ///1107 /// * collection_id.1108 ///1109 /// * schema: SchemaVersion: enum1110 #[weight = <SelfWeightOf<T>>::set_schema_version()]1111 #[transactional]1112 pub fn set_schema_version(1113 origin,1114 collection_id: CollectionId,1115 version: SchemaVersion1116 ) -> DispatchResult {1117 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1118 let mut target_collection = Self::get_collection(collection_id)?;1119 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1120 target_collection.schema_version = version;1121 target_collection.save()1122 }11231124 /// Set off-chain data schema.1125 ///1126 /// # Permissions1127 ///1128 /// * Collection Owner1129 /// * Collection Admin1130 ///1131 /// # Arguments1132 ///1133 /// * collection_id.1134 ///1135 /// * schema: String representing the offchain data schema.1136 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1137 #[transactional]1138 pub fn set_offchain_schema(1139 origin,1140 collection_id: CollectionId,1141 schema: Vec<u8>1142 ) -> DispatchResult {1143 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1144 let mut target_collection = Self::get_collection(collection_id)?;1145 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11461147 // check schema limit1148 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11491150 target_collection.offchain_schema = schema;1151 target_collection.save()1152 }11531154 /// Set const on-chain data schema.1155 ///1156 /// # Permissions1157 ///1158 /// * Collection Owner1159 /// * Collection Admin1160 ///1161 /// # Arguments1162 ///1163 /// * collection_id.1164 ///1165 /// * schema: String representing the const on-chain data schema.1166 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1167 #[transactional]1168 pub fn set_const_on_chain_schema (1169 origin,1170 collection_id: CollectionId,1171 schema: Vec<u8>1172 ) -> DispatchResult {1173 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1174 let mut target_collection = Self::get_collection(collection_id)?;1175 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11761177 // check schema limit1178 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");11791180 target_collection.const_on_chain_schema = schema;1181 target_collection.save()1182 }11831184 /// Set variable on-chain data schema.1185 ///1186 /// # Permissions1187 ///1188 /// * Collection Owner1189 /// * Collection Admin1190 ///1191 /// # Arguments1192 ///1193 /// * collection_id.1194 ///1195 /// * schema: String representing the variable on-chain data schema.1196 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1197 #[transactional]1198 pub fn set_variable_on_chain_schema (1199 origin,1200 collection_id: CollectionId,1201 schema: Vec<u8>1202 ) -> DispatchResult {1203 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1204 let mut target_collection = Self::get_collection(collection_id)?;1205 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12061207 // check schema limit1208 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12091210 target_collection.variable_on_chain_schema = schema;1211 target_collection.save()1212 }12131214 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1215 #[transactional]1216 pub fn set_collection_limits(1217 origin,1218 collection_id: u32,1219 new_limits: CollectionLimits<T::BlockNumber>,1220 ) -> DispatchResult {1221 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1222 let mut target_collection = Self::get_collection(collection_id)?;1223 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1224 let old_limits = &target_collection.limits;12251226 // collection bounds1227 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1228 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1229 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1230 Error::<T>::CollectionLimitBoundsExceeded);12311232 // token_limit check prev1233 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1234 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12351236 ensure!(1237 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1238 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1239 Error::<T>::OwnerPermissionsCantBeReverted,1240 );12411242 target_collection.limits = new_limits;12431244 target_collection.save()1245 }1246 }1247}12481249impl<T: Config> Module<T> {1250 pub fn create_item_internal(1251 sender: &T::CrossAccountId,1252 collection: &CollectionHandle<T>,1253 owner: &T::CrossAccountId,1254 data: CreateItemData,1255 ) -> DispatchResult {1256 ensure!(1257 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1258 Error::<T>::AddressIsZero1259 );12601261 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1262 Self::validate_create_item_args(collection, &data)?;1263 Self::create_item_no_validation(collection, owner, data)?;12641265 Ok(())1266 }12671268 pub fn transfer_internal(1269 sender: &T::CrossAccountId,1270 recipient: &T::CrossAccountId,1271 target_collection: &CollectionHandle<T>,1272 item_id: TokenId,1273 value: u128,1274 ) -> DispatchResult {1275 ensure!(1276 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1277 Error::<T>::AddressIsZero1278 );12791280 // Limits check1281 Self::is_correct_transfer(target_collection, recipient)?;12821283 // Transfer permissions check1284 ensure!(1285 Self::is_item_owner(sender, target_collection, item_id)?1286 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1287 Error::<T>::NoPermission1288 );12891290 if target_collection.access == AccessMode::WhiteList {1291 Self::check_white_list(target_collection, sender)?;1292 Self::check_white_list(target_collection, recipient)?;1293 }12941295 match target_collection.mode {1296 CollectionMode::NFT => Self::transfer_nft(1297 target_collection,1298 item_id,1299 sender.clone(),1300 recipient.clone(),1301 )?,1302 CollectionMode::Fungible(_) => {1303 Self::transfer_fungible(target_collection, value, sender, recipient)?1304 }1305 CollectionMode::ReFungible => Self::transfer_refungible(1306 target_collection,1307 item_id,1308 value,1309 sender.clone(),1310 recipient.clone(),1311 )?,1312 _ => (),1313 };13141315 Self::deposit_event(RawEvent::Transfer(1316 target_collection.id,1317 item_id,1318 sender.clone(),1319 recipient.clone(),1320 value,1321 ));13221323 Ok(())1324 }13251326 pub fn approve_internal(1327 sender: &T::CrossAccountId,1328 spender: &T::CrossAccountId,1329 collection: &CollectionHandle<T>,1330 item_id: TokenId,1331 amount: u128,1332 ) -> DispatchResult {1333 Self::token_exists(collection, item_id)?;13341335 // Transfer permissions check1336 let bypasses_limits = collection.limits.owner_can_transfer1337 && Self::is_owner_or_admin_permissions(collection, sender)?;13381339 let allowance_limit = if bypasses_limits {1340 None1341 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1342 Some(amount)1343 } else {1344 fail!(Error::<T>::NoPermission);1345 };13461347 if collection.access == AccessMode::WhiteList {1348 Self::check_white_list(collection, sender)?;1349 Self::check_white_list(collection, spender)?;1350 }13511352 collection.consume_sload()?;1353 let allowance: u128 = amount1354 .checked_add(<Allowances<T>>::get(1355 collection.id,1356 (item_id, sender.as_sub(), spender.as_sub()),1357 ))1358 .ok_or(Error::<T>::NumOverflow)?;1359 if let Some(limit) = allowance_limit {1360 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1361 }1362 collection.consume_sstore()?;1363 <Allowances<T>>::insert(1364 collection.id,1365 (item_id, sender.as_sub(), spender.as_sub()),1366 allowance,1367 );13681369 if matches!(collection.mode, CollectionMode::NFT) {1370 // TODO: NFT: only one owner may exist for token in ERC7211371 collection.log(ERC721Events::Approval {1372 owner: *sender.as_eth(),1373 approved: *spender.as_eth(),1374 token_id: item_id.into(),1375 })?;1376 }13771378 if matches!(collection.mode, CollectionMode::Fungible(_)) {1379 // TODO: NFT: only one owner may exist for token in ERC201380 collection.log(ERC20Events::Approval {1381 owner: *sender.as_eth(),1382 spender: *spender.as_eth(),1383 value: allowance.into(),1384 })?;1385 }13861387 Self::deposit_event(RawEvent::Approved(1388 collection.id,1389 item_id,1390 sender.clone(),1391 spender.clone(),1392 allowance,1393 ));1394 Ok(())1395 }13961397 pub fn transfer_from_internal(1398 sender: &T::CrossAccountId,1399 from: &T::CrossAccountId,1400 recipient: &T::CrossAccountId,1401 collection: &CollectionHandle<T>,1402 item_id: TokenId,1403 amount: u128,1404 ) -> DispatchResult {1405 if sender == from {1406 // Transfer by `from`, because it is either equal to sender, or derived from him1407 return Self::transfer_internal(from, recipient, collection, item_id, amount);1408 }14091410 // Check approval1411 collection.consume_sload()?;1412 let approval: u128 =1413 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14141415 // Limits check1416 Self::is_correct_transfer(collection, recipient)?;14171418 // Transfer permissions check1419 ensure!(1420 approval >= amount1421 || (collection.limits.owner_can_transfer1422 && Self::is_owner_or_admin_permissions(collection, sender)?),1423 Error::<T>::NoPermission1424 );14251426 if collection.access == AccessMode::WhiteList {1427 Self::check_white_list(collection, sender)?;1428 Self::check_white_list(collection, recipient)?;1429 }14301431 // Reduce approval by transferred amount or remove if remaining approval drops to 01432 let allowance = approval.saturating_sub(amount);1433 collection.consume_sstore()?;1434 if allowance > 0 {1435 <Allowances<T>>::insert(1436 collection.id,1437 (item_id, from.as_sub(), sender.as_sub()),1438 allowance,1439 );1440 } else {1441 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1442 }14431444 match collection.mode {1445 CollectionMode::NFT => {1446 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1447 }1448 CollectionMode::Fungible(_) => {1449 Self::transfer_fungible(collection, amount, from, recipient)?1450 }1451 CollectionMode::ReFungible => Self::transfer_refungible(1452 collection,1453 item_id,1454 amount,1455 from.clone(),1456 recipient.clone(),1457 )?,1458 _ => (),1459 };14601461 if matches!(collection.mode, CollectionMode::Fungible(_)) {1462 collection.log(ERC20Events::Approval {1463 owner: *from.as_eth(),1464 spender: *sender.as_eth(),1465 value: allowance.into(),1466 })?;1467 }14681469 Ok(())1470 }14711472 pub fn set_variable_meta_data_internal(1473 sender: &T::CrossAccountId,1474 collection: &CollectionHandle<T>,1475 item_id: TokenId,1476 data: Vec<u8>,1477 ) -> DispatchResult {1478 Self::token_exists(collection, item_id)?;14791480 ensure!(1481 CUSTOM_DATA_LIMIT >= data.len() as u32,1482 Error::<T>::TokenVariableDataLimitExceeded1483 );14841485 // Modify permissions check1486 ensure!(1487 Self::is_item_owner(sender, collection, item_id)?1488 || Self::is_owner_or_admin_permissions(collection, sender)?,1489 Error::<T>::NoPermission1490 );14911492 match collection.mode {1493 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1494 CollectionMode::ReFungible => {1495 Self::set_re_fungible_variable_data(collection, item_id, data)?1496 }1497 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1498 _ => fail!(Error::<T>::UnexpectedCollectionType),1499 };15001501 Ok(())1502 }15031504 pub fn create_multiple_items_internal(1505 sender: &T::CrossAccountId,1506 collection: &CollectionHandle<T>,1507 owner: &T::CrossAccountId,1508 items_data: Vec<CreateItemData>,1509 ) -> DispatchResult {1510 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15111512 for data in &items_data {1513 Self::validate_create_item_args(collection, data)?;1514 }1515 for data in &items_data {1516 Self::create_item_no_validation(collection, owner, data.clone())?;1517 }15181519 Ok(())1520 }15211522 pub fn burn_item_internal(1523 sender: &T::CrossAccountId,1524 collection: &CollectionHandle<T>,1525 item_id: TokenId,1526 value: u128,1527 ) -> DispatchResult {1528 ensure!(1529 Self::is_item_owner(sender, collection, item_id)?1530 || (collection.limits.owner_can_transfer1531 && Self::is_owner_or_admin_permissions(collection, sender)?),1532 Error::<T>::NoPermission1533 );15341535 if collection.access == AccessMode::WhiteList {1536 Self::check_white_list(collection, sender)?;1537 }15381539 match collection.mode {1540 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1541 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1542 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1543 _ => (),1544 };15451546 Ok(())1547 }15481549 pub fn toggle_white_list_internal(1550 sender: &T::CrossAccountId,1551 collection: &CollectionHandle<T>,1552 address: &T::CrossAccountId,1553 whitelisted: bool,1554 ) -> DispatchResult {1555 Self::check_owner_or_admin_permissions(collection, sender)?;15561557 if whitelisted {1558 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1559 } else {1560 <WhiteList<T>>::remove(collection.id, address.as_sub());1561 }15621563 Ok(())1564 }15651566 fn is_correct_transfer(1567 collection: &CollectionHandle<T>,1568 recipient: &T::CrossAccountId,1569 ) -> DispatchResult {1570 let collection_id = collection.id;15711572 // check token limit and account token limit1573 collection.consume_sload()?;1574 let account_items: u32 =1575 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1576 ensure!(1577 collection.limits.account_token_ownership_limit > account_items,1578 Error::<T>::AccountTokenLimitExceeded1579 );15801581 // preliminary transfer check1582 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);15831584 Ok(())1585 }15861587 fn can_create_items_in_collection(1588 collection: &CollectionHandle<T>,1589 sender: &T::CrossAccountId,1590 owner: &T::CrossAccountId,1591 amount: u32,1592 ) -> DispatchResult {1593 let collection_id = collection.id;15941595 // check token limit and account token limit1596 let total_items: u32 = ItemListIndex::get(collection_id)1597 .checked_add(amount)1598 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1599 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1600 as u32)1601 .checked_add(amount)1602 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1603 ensure!(1604 collection.limits.token_limit >= total_items,1605 Error::<T>::CollectionTokenLimitExceeded1606 );1607 ensure!(1608 collection.limits.account_token_ownership_limit >= account_items,1609 Error::<T>::AccountTokenLimitExceeded1610 );16111612 if !Self::is_owner_or_admin_permissions(collection, sender)? {1613 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1614 Self::check_white_list(collection, owner)?;1615 Self::check_white_list(collection, sender)?;1616 }16171618 Ok(())1619 }16201621 fn validate_create_item_args(1622 target_collection: &CollectionHandle<T>,1623 data: &CreateItemData,1624 ) -> DispatchResult {1625 match target_collection.mode {1626 CollectionMode::NFT => {1627 if !matches!(data, CreateItemData::NFT(_)) {1628 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1629 }1630 }1631 CollectionMode::Fungible(_) => {1632 if !matches!(data, CreateItemData::Fungible(_)) {1633 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1634 }1635 }1636 CollectionMode::ReFungible => {1637 if let CreateItemData::ReFungible(data) = data {1638 // Check refungibility limits1639 ensure!(1640 data.pieces <= MAX_REFUNGIBLE_PIECES,1641 Error::<T>::WrongRefungiblePieces1642 );1643 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1644 } else {1645 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1646 }1647 }1648 _ => {1649 fail!(Error::<T>::UnexpectedCollectionType);1650 }1651 };16521653 Ok(())1654 }16551656 fn create_item_no_validation(1657 collection: &CollectionHandle<T>,1658 owner: &T::CrossAccountId,1659 data: CreateItemData,1660 ) -> DispatchResult {1661 match data {1662 CreateItemData::NFT(data) => {1663 let item = NftItemType {1664 owner: owner.clone(),1665 const_data: data.const_data.into_inner(),1666 variable_data: data.variable_data.into_inner(),1667 };16681669 Self::add_nft_item(collection, item)?;1670 }1671 CreateItemData::Fungible(data) => {1672 Self::add_fungible_item(collection, owner, data.value)?;1673 }1674 CreateItemData::ReFungible(data) => {1675 let owner_list = vec![Ownership {1676 owner: owner.clone(),1677 fraction: data.pieces,1678 }];16791680 let item = ReFungibleItemType {1681 owner: owner_list,1682 const_data: data.const_data.into_inner(),1683 variable_data: data.variable_data.into_inner(),1684 };16851686 Self::add_refungible_item(collection, item)?;1687 }1688 };16891690 Ok(())1691 }16921693 fn add_fungible_item(1694 collection: &CollectionHandle<T>,1695 owner: &T::CrossAccountId,1696 value: u128,1697 ) -> DispatchResult {1698 let collection_id = collection.id;16991700 // Does new owner already have an account?1701 collection.consume_sload()?;1702 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17031704 // Mint1705 let item = FungibleItemType {1706 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1707 };1708 collection.consume_sstore()?;1709 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17101711 // Update balance1712 collection.consume_sload()?;1713 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1714 .checked_add(value)1715 .ok_or(Error::<T>::NumOverflow)?;1716 collection.consume_sstore()?;1717 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17181719 collection.log(ERC20Events::Transfer {1720 from: H160::default(),1721 to: *owner.as_eth(),1722 value: value.into(),1723 })?;1724 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1725 Ok(())1726 }17271728 fn add_refungible_item(1729 collection: &CollectionHandle<T>,1730 item: ReFungibleItemType<T::CrossAccountId>,1731 ) -> DispatchResult {1732 let collection_id = collection.id;17331734 let current_index = <ItemListIndex>::get(collection_id)1735 .checked_add(1)1736 .ok_or(Error::<T>::NumOverflow)?;1737 let itemcopy = item.clone();17381739 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1740 let item_owner = item.owner.first().expect("only one owner is defined");17411742 let value = item_owner.fraction;1743 let owner = item_owner.owner.clone();17441745 Self::add_token_index(collection, current_index, &owner)?;17461747 <ItemListIndex>::insert(collection_id, current_index);1748 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17491750 // Update balance1751 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1752 .checked_add(value)1753 .ok_or(Error::<T>::NumOverflow)?;1754 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17551756 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1757 Ok(())1758 }17591760 fn add_nft_item(1761 collection: &CollectionHandle<T>,1762 item: NftItemType<T::CrossAccountId>,1763 ) -> DispatchResult {1764 let collection_id = collection.id;17651766 let current_index = <ItemListIndex>::get(collection_id)1767 .checked_add(1)1768 .ok_or(Error::<T>::NumOverflow)?;17691770 let item_owner = item.owner.clone();1771 Self::add_token_index(collection, current_index, &item.owner)?;17721773 <ItemListIndex>::insert(collection_id, current_index);1774 <NftItemList<T>>::insert(collection_id, current_index, item);17751776 // Update balance1777 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1778 .checked_add(1)1779 .ok_or(Error::<T>::NumOverflow)?;1780 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17811782 collection.log(ERC721Events::Transfer {1783 from: H160::default(),1784 to: *item_owner.as_eth(),1785 token_id: current_index.into(),1786 })?;1787 Self::deposit_event(RawEvent::ItemCreated(1788 collection_id,1789 current_index,1790 item_owner,1791 ));1792 Ok(())1793 }17941795 fn burn_refungible_item(1796 collection: &CollectionHandle<T>,1797 item_id: TokenId,1798 owner: &T::CrossAccountId,1799 ) -> DispatchResult {1800 let collection_id = collection.id;18011802 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1803 .ok_or(Error::<T>::TokenNotFound)?;1804 let rft_balance = token1805 .owner1806 .iter()1807 .find(|&i| i.owner == *owner)1808 .ok_or(Error::<T>::TokenNotFound)?;1809 Self::remove_token_index(collection, item_id, owner)?;18101811 // update balance1812 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1813 .checked_sub(rft_balance.fraction)1814 .ok_or(Error::<T>::NumOverflow)?;1815 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18161817 // Re-create owners list with sender removed1818 let index = token1819 .owner1820 .iter()1821 .position(|i| i.owner == *owner)1822 .expect("owned item is exists");1823 token.owner.remove(index);1824 let owner_count = token.owner.len();18251826 // Burn the token completely if this was the last (only) owner1827 if owner_count == 0 {1828 <ReFungibleItemList<T>>::remove(collection_id, item_id);1829 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1830 } else {1831 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1832 }18331834 Ok(())1835 }18361837 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1838 let collection_id = collection.id;18391840 let item =1841 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1842 Self::remove_token_index(collection, item_id, &item.owner)?;18431844 // update balance1845 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1846 .checked_sub(1)1847 .ok_or(Error::<T>::NumOverflow)?;1848 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1849 <NftItemList<T>>::remove(collection_id, item_id);1850 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18511852 collection.log(ERC721Events::Transfer {1853 from: *item.owner.as_eth(),1854 to: H160::default(),1855 token_id: item_id.into(),1856 })?;1857 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1858 Ok(())1859 }18601861 fn burn_fungible_item(1862 owner: &T::CrossAccountId,1863 collection: &CollectionHandle<T>,1864 value: u128,1865 ) -> DispatchResult {1866 let collection_id = collection.id;18671868 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1869 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18701871 // update balance1872 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1873 .checked_sub(value)1874 .ok_or(Error::<T>::NumOverflow)?;1875 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18761877 if balance.value - value > 0 {1878 balance.value -= value;1879 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1880 } else {1881 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1882 }18831884 collection.log(ERC20Events::Transfer {1885 from: *owner.as_eth(),1886 to: H160::default(),1887 value: value.into(),1888 })?;1889 Ok(())1890 }18911892 pub fn get_collection(1893 collection_id: CollectionId,1894 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1895 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1896 }18971898 fn check_owner_permissions(1899 target_collection: &CollectionHandle<T>,1900 subject: &T::AccountId,1901 ) -> DispatchResult {1902 ensure!(1903 *subject == target_collection.owner,1904 Error::<T>::NoPermission1905 );19061907 Ok(())1908 }19091910 fn is_owner_or_admin_permissions(1911 collection: &CollectionHandle<T>,1912 subject: &T::CrossAccountId,1913 ) -> Result<bool, DispatchError> {1914 collection.consume_sload()?;1915 Ok(*subject.as_sub() == collection.owner1916 || <AdminList<T>>::get(collection.id).contains(subject))1917 }19181919 fn check_owner_or_admin_permissions(1920 collection: &CollectionHandle<T>,1921 subject: &T::CrossAccountId,1922 ) -> DispatchResult {1923 ensure!(1924 Self::is_owner_or_admin_permissions(collection, subject)?,1925 Error::<T>::NoPermission1926 );19271928 Ok(())1929 }19301931 fn owned_amount(1932 subject: &T::CrossAccountId,1933 collection: &CollectionHandle<T>,1934 item_id: TokenId,1935 ) -> Result<Option<u128>, DispatchError> {1936 collection.consume_sload()?;1937 Ok(Self::owned_amount_unchecked(subject, collection, item_id))1938 }19391940 fn owned_amount_unchecked(1941 subject: &T::CrossAccountId,1942 target_collection: &CollectionHandle<T>,1943 item_id: TokenId,1944 ) -> Option<u128> {1945 let collection_id = target_collection.id;19461947 match target_collection.mode {1948 CollectionMode::NFT => {1949 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1950 }1951 CollectionMode::Fungible(_) => {1952 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1953 }1954 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1955 .owner1956 .iter()1957 .find(|i| i.owner == *subject)1958 .map(|i| i.fraction),1959 CollectionMode::Invalid => None,1960 }1961 }19621963 fn is_item_owner(1964 subject: &T::CrossAccountId,1965 target_collection: &CollectionHandle<T>,1966 item_id: TokenId,1967 ) -> Result<bool, DispatchError> {1968 Ok(match target_collection.mode {1969 CollectionMode::Fungible(_) => true,1970 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),1971 })1972 }19731974 fn check_white_list(1975 collection: &CollectionHandle<T>,1976 address: &T::CrossAccountId,1977 ) -> DispatchResult {1978 collection.consume_sload()?;1979 ensure!(1980 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),1981 Error::<T>::AddresNotInWhiteList,1982 );1983 Ok(())1984 }19851986 /// Check if token exists. In case of Fungible, check if there is an entry for1987 /// the owner in fungible balances double map1988 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1989 let collection_id = target_collection.id;1990 let exists = match target_collection.mode {1991 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1992 CollectionMode::Fungible(_) => true,1993 CollectionMode::ReFungible => {1994 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)1995 }1996 _ => false,1997 };19981999 ensure!(exists, Error::<T>::TokenNotFound);2000 Ok(())2001 }20022003 fn transfer_fungible(2004 collection: &CollectionHandle<T>,2005 value: u128,2006 owner: &T::CrossAccountId,2007 recipient: &T::CrossAccountId,2008 ) -> DispatchResult {2009 let collection_id = collection.id;20102011 collection.consume_sload()?;2012 collection.consume_sload()?;2013 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2014 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20152016 recipient_balance.value = recipient_balance2017 .value2018 .checked_add(value)2019 .ok_or(Error::<T>::NumOverflow)?;2020 balance.value = balance2021 .value2022 .checked_sub(value)2023 .ok_or(Error::<T>::TokenValueTooLow)?;20242025 // update balanceOf2026 collection.consume_sstore()?;2027 collection.consume_sstore()?;2028 if balance.value != 0 {2029 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2030 } else {2031 <Balance<T>>::remove(collection_id, owner.as_sub());2032 }2033 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20342035 // Reduce or remove sender2036 collection.consume_sstore()?;2037 collection.consume_sstore()?;2038 if balance.value != 0 {2039 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2040 } else {2041 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2042 }2043 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20442045 collection.log(ERC20Events::Transfer {2046 from: *owner.as_eth(),2047 to: *recipient.as_eth(),2048 value: value.into(),2049 })?;2050 Self::deposit_event(RawEvent::Transfer(2051 collection.id,2052 1,2053 owner.clone(),2054 recipient.clone(),2055 value,2056 ));20572058 Ok(())2059 }20602061 fn transfer_refungible(2062 collection: &CollectionHandle<T>,2063 item_id: TokenId,2064 value: u128,2065 owner: T::CrossAccountId,2066 new_owner: T::CrossAccountId,2067 ) -> DispatchResult {2068 let collection_id = collection.id;2069 collection.consume_sload()?;2070 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2071 .ok_or(Error::<T>::TokenNotFound)?;20722073 let item = full_item2074 .owner2075 .iter()2076 .find(|i| i.owner == owner)2077 .ok_or(Error::<T>::TokenNotFound)?;2078 let amount = item.fraction;20792080 ensure!(amount >= value, Error::<T>::TokenValueTooLow);20812082 collection.consume_sload()?;2083 // update balance2084 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2085 .checked_sub(value)2086 .ok_or(Error::<T>::NumOverflow)?;2087 collection.consume_sstore()?;2088 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20892090 collection.consume_sload()?;2091 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2092 .checked_add(value)2093 .ok_or(Error::<T>::NumOverflow)?;2094 collection.consume_sstore()?;2095 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20962097 let old_owner = item.owner.clone();2098 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20992100 let mut new_full_item = full_item.clone();2101 // transfer2102 if amount == value && !new_owner_has_account {2103 // change owner2104 // new owner do not have account2105 new_full_item2106 .owner2107 .iter_mut()2108 .find(|i| i.owner == owner)2109 .expect("old owner does present in refungible")2110 .owner = new_owner.clone();2111 collection.consume_sstore()?;2112 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21132114 // update index collection2115 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2116 } else {2117 new_full_item2118 .owner2119 .iter_mut()2120 .find(|i| i.owner == owner)2121 .expect("old owner does present in refungible")2122 .fraction -= value;21232124 // separate amount2125 if new_owner_has_account {2126 // new owner has account2127 new_full_item2128 .owner2129 .iter_mut()2130 .find(|i| i.owner == new_owner)2131 .expect("new owner has account")2132 .fraction += value;2133 } else {2134 // new owner do not have account2135 new_full_item.owner.push(Ownership {2136 owner: new_owner.clone(),2137 fraction: value,2138 });2139 Self::add_token_index(collection, item_id, &new_owner)?;2140 }21412142 collection.consume_sstore()?;2143 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2144 }21452146 Self::deposit_event(RawEvent::Transfer(2147 collection.id,2148 item_id,2149 owner,2150 new_owner,2151 amount,2152 ));21532154 Ok(())2155 }21562157 fn transfer_nft(2158 collection: &CollectionHandle<T>,2159 item_id: TokenId,2160 sender: T::CrossAccountId,2161 new_owner: T::CrossAccountId,2162 ) -> DispatchResult {2163 let collection_id = collection.id;2164 collection.consume_sload()?;2165 let mut item =2166 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21672168 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21692170 collection.consume_sload()?;2171 // update balance2172 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2173 .checked_sub(1)2174 .ok_or(Error::<T>::NumOverflow)?;2175 collection.consume_sstore()?;2176 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21772178 collection.consume_sload()?;2179 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2180 .checked_add(1)2181 .ok_or(Error::<T>::NumOverflow)?;2182 collection.consume_sstore()?;2183 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21842185 // change owner2186 let old_owner = item.owner.clone();2187 item.owner = new_owner.clone();2188 collection.consume_sstore()?;2189 <NftItemList<T>>::insert(collection_id, item_id, item);21902191 // update index collection2192 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;21932194 collection.log(ERC721Events::Transfer {2195 from: *sender.as_eth(),2196 to: *new_owner.as_eth(),2197 token_id: item_id.into(),2198 })?;2199 Self::deposit_event(RawEvent::Transfer(2200 collection.id,2201 item_id,2202 sender,2203 new_owner,2204 1,2205 ));22062207 Ok(())2208 }22092210 fn set_re_fungible_variable_data(2211 collection: &CollectionHandle<T>,2212 item_id: TokenId,2213 data: Vec<u8>,2214 ) -> DispatchResult {2215 let collection_id = collection.id;2216 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2217 .ok_or(Error::<T>::TokenNotFound)?;22182219 item.variable_data = data;22202221 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22222223 Ok(())2224 }22252226 fn set_nft_variable_data(2227 collection: &CollectionHandle<T>,2228 item_id: TokenId,2229 data: Vec<u8>,2230 ) -> DispatchResult {2231 let collection_id = collection.id;2232 let mut item =2233 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22342235 item.variable_data = data;22362237 <NftItemList<T>>::insert(collection_id, item_id, item);22382239 Ok(())2240 }22412242 #[allow(dead_code)]2243 fn init_collection(item: &Collection<T>) {2244 // check params2245 assert!(2246 item.decimal_points <= MAX_DECIMAL_POINTS,2247 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2248 );2249 assert!(2250 item.name.len() <= 64,2251 "Collection name can not be longer than 63 char"2252 );2253 assert!(2254 item.name.len() <= 256,2255 "Collection description can not be longer than 255 char"2256 );2257 assert!(2258 item.token_prefix.len() <= 16,2259 "Token prefix can not be longer than 15 char"2260 );22612262 // Generate next collection ID2263 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22642265 CreatedCollectionCount::put(next_id);2266 }22672268 #[allow(dead_code)]2269 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2270 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22712272 Self::add_token_index(2273 &CollectionHandle::get(collection_id).unwrap(),2274 current_index,2275 &item.owner,2276 )2277 .unwrap();22782279 <ItemListIndex>::insert(collection_id, current_index);22802281 // Update balance2282 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2283 .checked_add(1)2284 .unwrap();2285 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2286 }22872288 #[allow(dead_code)]2289 fn init_fungible_token(2290 collection_id: CollectionId,2291 owner: &T::CrossAccountId,2292 item: &FungibleItemType,2293 ) {2294 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22952296 Self::add_token_index(2297 &CollectionHandle::get(collection_id).unwrap(),2298 current_index,2299 owner,2300 )2301 .unwrap();23022303 <ItemListIndex>::insert(collection_id, current_index);23042305 // Update balance2306 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2307 .checked_add(item.value)2308 .unwrap();2309 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2310 }23112312 #[allow(dead_code)]2313 fn init_refungible_token(2314 collection_id: CollectionId,2315 item: &ReFungibleItemType<T::CrossAccountId>,2316 ) {2317 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23182319 let value = item.owner.first().unwrap().fraction;2320 let owner = item.owner.first().unwrap().owner.clone();23212322 Self::add_token_index(2323 &CollectionHandle::get(collection_id).unwrap(),2324 current_index,2325 &owner,2326 )2327 .unwrap();23282329 <ItemListIndex>::insert(collection_id, current_index);23302331 // Update balance2332 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2333 .checked_add(value)2334 .unwrap();2335 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2336 }23372338 fn add_token_index(2339 collection: &CollectionHandle<T>,2340 item_index: TokenId,2341 owner: &T::CrossAccountId,2342 ) -> DispatchResult {2343 // add to account limit2344 collection.consume_sload()?;2345 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2346 // bound Owned tokens by a single address2347 collection.consume_sload()?;2348 let count = <AccountItemCount<T>>::get(owner.as_sub());2349 ensure!(2350 count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2351 Error::<T>::AddressOwnershipLimitExceeded2352 );23532354 collection.consume_sstore()?;2355 <AccountItemCount<T>>::insert(2356 owner.as_sub(),2357 count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2358 );2359 } else {2360 collection.consume_sstore()?;2361 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2362 }23632364 collection.consume_sload()?;2365 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2366 if list_exists {2367 collection.consume_sload()?;2368 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2369 let item_contains = list.contains(&item_index.clone());23702371 if !item_contains {2372 list.push(item_index);2373 }23742375 collection.consume_sstore()?;2376 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2377 } else {2378 let itm = vec![item_index];2379 collection.consume_sstore()?;2380 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2381 }23822383 Ok(())2384 }23852386 fn remove_token_index(2387 collection: &CollectionHandle<T>,2388 item_index: TokenId,2389 owner: &T::CrossAccountId,2390 ) -> DispatchResult {2391 // update counter2392 collection.consume_sload()?;2393 collection.consume_sstore()?;2394 <AccountItemCount<T>>::insert(2395 owner.as_sub(),2396 <AccountItemCount<T>>::get(owner.as_sub())2397 .checked_sub(1)2398 .ok_or(Error::<T>::NumOverflow)?,2399 );24002401 collection.consume_sload()?;2402 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2403 if list_exists {2404 collection.consume_sload()?;2405 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2406 let item_contains = list.contains(&item_index.clone());24072408 if item_contains {2409 list.retain(|&item| item != item_index);2410 collection.consume_sstore()?;2411 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2412 }2413 }24142415 Ok(())2416 }24172418 fn move_token_index(2419 collection: &CollectionHandle<T>,2420 item_index: TokenId,2421 old_owner: &T::CrossAccountId,2422 new_owner: &T::CrossAccountId,2423 ) -> DispatchResult {2424 Self::remove_token_index(collection, item_index, old_owner)?;2425 Self::add_token_index(collection, item_index, new_owner)?;24262427 Ok(())2428 }2429}24302431sp_api::decl_runtime_apis! {2432 pub trait NftApi {2433 /// Used for ethereum integration2434 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2435 }2436}1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9 clippy::too_many_arguments,10 clippy::unnecessary_mut_passed,11 clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41 CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42 VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43 OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44 MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45 CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46 FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70 /// Error for non-fungible-token module.71 pub enum Error for Module<T: Config> {72 /// Total collections bound exceeded.73 TotalCollectionsLimitExceeded,74 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75 CollectionDecimalPointLimitExceeded,76 /// Collection name can not be longer than 63 char.77 CollectionNameLimitExceeded,78 /// Collection description can not be longer than 255 char.79 CollectionDescriptionLimitExceeded,80 /// Token prefix can not be longer than 15 char.81 CollectionTokenPrefixLimitExceeded,82 /// This collection does not exist.83 CollectionNotFound,84 /// Item not exists.85 TokenNotFound,86 /// Admin not found87 AdminNotFound,88 /// Arithmetic calculation overflow.89 NumOverflow,90 /// Account already has admin role.91 AlreadyAdmin,92 /// You do not own this collection.93 NoPermission,94 /// This address is not set as sponsor, use setCollectionSponsor first.95 ConfirmUnsetSponsorFail,96 /// Collection is not in mint mode.97 PublicMintingNotAllowed,98 /// Sender parameter and item owner must be equal.99 MustBeTokenOwner,100 /// Item balance not enough.101 TokenValueTooLow,102 /// Size of item is too large.103 NftSizeLimitExceeded,104 /// No approve found105 ApproveNotFound,106 /// Requested value more than approved.107 TokenValueNotEnough,108 /// Only approved addresses can call this method.109 ApproveRequired,110 /// Address is not in white list.111 AddresNotInWhiteList,112 /// Number of collection admins bound exceeded.113 CollectionAdminsLimitExceeded,114 /// Owned tokens by a single address bound exceeded.115 AddressOwnershipLimitExceeded,116 /// Length of items properties must be greater than 0.117 EmptyArgument,118 /// const_data exceeded data limit.119 TokenConstDataLimitExceeded,120 /// variable_data exceeded data limit.121 TokenVariableDataLimitExceeded,122 /// Not NFT item data used to mint in NFT collection.123 NotNftDataUsedToMintNftCollectionToken,124 /// Not Fungible item data used to mint in Fungible collection.125 NotFungibleDataUsedToMintFungibleCollectionToken,126 /// Not Re Fungible item data used to mint in Re Fungible collection.127 NotReFungibleDataUsedToMintReFungibleCollectionToken,128 /// Unexpected collection type.129 UnexpectedCollectionType,130 /// Can't store metadata in fungible tokens.131 CantStoreMetadataInFungibleTokens,132 /// Collection token limit exceeded133 CollectionTokenLimitExceeded,134 /// Account token limit exceeded per collection135 AccountTokenLimitExceeded,136 /// Collection limit bounds per collection exceeded137 CollectionLimitBoundsExceeded,138 /// Tried to enable permissions which are only permitted to be disabled139 OwnerPermissionsCantBeReverted,140 /// Schema data size limit bound exceeded141 SchemaDataLimitExceeded,142 /// Maximum refungibility exceeded143 WrongRefungiblePieces,144 /// createRefungible should be called with one owner145 BadCreateRefungibleCall,146 /// Gas limit exceeded147 OutOfGas,148 /// Collection settings not allowing items transferring149 TransferNotAllowed,150 /// Can't transfer tokens to ethereum zero address151 AddressIsZero,152 }153}154155#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]156pub struct CollectionHandle<T: Config> {157 pub id: CollectionId,158 collection: Collection<T>,159 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,160}161impl<T: Config> CollectionHandle<T> {162 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {163 <CollectionById<T>>::get(id).map(|collection| Self {164 id,165 collection,166 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(167 eth::collection_id_to_address(id),168 gas_limit,169 ),170 })171 }172 pub fn get(id: CollectionId) -> Option<Self> {173 Self::get_with_gas_limit(id, u64::MAX)174 }175 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {176 self.recorder.log_sub(log)177 }178 #[allow(dead_code)]179 fn consume_gas(&self, gas: u64) -> DispatchResult {180 self.recorder.consume_gas_sub(gas)181 }182 fn consume_sload(&self) -> DispatchResult {183 self.recorder.consume_sload_sub()184 }185 fn consume_sstore(&self) -> DispatchResult {186 self.recorder.consume_sstore_sub()187 }188 pub fn submit_logs(self) -> DispatchResult {189 self.recorder.submit_logs()190 }191 pub fn save(self) -> DispatchResult {192 self.recorder.submit_logs()?;193 <CollectionById<T>>::insert(self.id, self.collection);194 Ok(())195 }196}197impl<T: Config> Deref for CollectionHandle<T> {198 type Target = Collection<T>;199200 fn deref(&self) -> &Self::Target {201 &self.collection202 }203}204205impl<T: Config> DerefMut for CollectionHandle<T> {206 fn deref_mut(&mut self) -> &mut Self::Target {207 &mut self.collection208 }209}210211pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {212 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;213214 /// Weight information for extrinsics in this pallet.215 type WeightInfo: WeightInfo;216217 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;218 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;219220 type CrossAccountId: CrossAccountId<Self::AccountId>;221 type Currency: Currency<Self::AccountId>;222 type CollectionCreationPrice: Get<223 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,224 >;225 type TreasuryAccountId: Get<Self::AccountId>;226}227228type SelfWeightOf<T> = <T as Config>::WeightInfo;229230trait WeightInfoHelpers: WeightInfo {231 fn transfer() -> Weight {232 Self::transfer_nft()233 .max(Self::transfer_fungible())234 .max(Self::transfer_refungible())235 }236 fn transfer_from() -> Weight {237 Self::transfer_from_nft()238 .max(Self::transfer_from_fungible())239 .max(Self::transfer_from_refungible())240 }241 fn approve() -> Weight {242 // TODO: refungible, fungible243 Self::approve_nft()244 }245 fn set_variable_meta_data(data: u32) -> Weight {246 // TODO: refungible247 Self::set_variable_meta_data_nft(data)248 }249 fn create_item(data: u32) -> Weight {250 Self::create_item_nft(data)251 .max(Self::create_item_fungible())252 .max(Self::create_item_refungible(data))253 }254 fn create_multiple_items(amount: u32) -> Weight {255 Self::create_multiple_items_nft(amount)256 .max(Self::create_multiple_items_fungible(amount))257 .max(Self::create_multiple_items_refungible(amount))258 }259 fn burn_item() -> Weight {260 // TODO: refungible, fungible261 Self::burn_item_nft()262 }263}264impl<T: WeightInfo> WeightInfoHelpers for T {}265266// # Used definitions267//268// ## User control levels269//270// chain-controlled - key is uncontrolled by user271// i.e autoincrementing index272// can use non-cryptographic hash273// real - key is controlled by user274// but it is hard to generate enough colliding values, i.e owner of signed txs275// can use non-cryptographic hash276// controlled - key is completly controlled by users277// i.e maps with mutable keys278// should use cryptographic hash279//280// ## User control level downgrade reasons281//282// ?1 - chain-controlled -> controlled283// collections/tokens can be destroyed, resulting in massive holes284// ?2 - chain-controlled -> controlled285// same as ?1, but can be only added, resulting in easier exploitation286// ?3 - real -> controlled287// no confirmation required, so addresses can be easily generated288decl_storage! {289 trait Store for Module<T: Config> as Nft {290291 //#region Private members292 /// Id of next collection293 CreatedCollectionCount: u32;294 /// Used for migrations295 ChainVersion: u64;296 /// Id of last collection token297 /// Collection id (controlled?1)298 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;299 //#endregion300301 //#region Bound counters302 /// Amount of collections destroyed, used for total amount tracking with303 /// CreatedCollectionCount304 DestroyedCollectionCount: u32;305 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)306 /// Account id (real)307 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;308 //#endregion309310 //#region Basic collections311 /// Collection info312 /// Collection id (controlled?1)313 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;314 /// List of collection admins315 /// Collection id (controlled?2)316 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;317 /// Whitelisted collection users318 /// Collection id (controlled?2), user id (controlled?3)319 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;320 //#endregion321322 /// How many of collection items user have323 /// Collection id (controlled?2), account id (real)324 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;325326 /// Amount of items which spender can transfer out of owners account (via transferFrom)327 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))328 /// TODO: Off chain worker should remove from this map when token gets removed329 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;330331 //#region Item collections332 /// Collection id (controlled?2), token id (controlled?1)333 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;334 /// Collection id (controlled?2), owner (controlled?2)335 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;336 /// Collection id (controlled?2), token id (controlled?1)337 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;338 //#endregion339340 //#region Index list341 /// Collection id (controlled?2), tokens owner (controlled?2)342 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;343 //#endregion344345 //#region Tokens transfer rate limit baskets346 /// (Collection id (controlled?2), who created (real))347 /// TODO: Off chain worker should remove from this map when collection gets removed348 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;349 /// Collection id (controlled?2), token id (controlled?2)350 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;351 /// Collection id (controlled?2), owning user (real)352 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;353 /// Collection id (controlled?2), token id (controlled?2)354 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;355 //#endregion356357 /// Variable metadata sponsoring358 /// Collection id (controlled?2), token id (controlled?2)359 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;360 }361 add_extra_genesis {362 build(|config: &GenesisConfig<T>| {363 // Modification of storage364 for (_num, _c) in &config.collection_id {365 <Module<T>>::init_collection(_c);366 }367368 for (_num, _c, _i) in &config.nft_item_id {369 <Module<T>>::init_nft_token(*_c, _i);370 }371372 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {373 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);374 }375376 for (_num, _c, _i) in &config.refungible_item_id {377 <Module<T>>::init_refungible_token(*_c, _i);378 }379 })380 }381}382383decl_event!(384 pub enum Event<T>385 where386 AccountId = <T as frame_system::Config>::AccountId,387 CrossAccountId = <T as Config>::CrossAccountId,388 {389 /// New collection was created390 ///391 /// # Arguments392 ///393 /// * collection_id: Globally unique identifier of newly created collection.394 ///395 /// * mode: [CollectionMode] converted into u8.396 ///397 /// * account_id: Collection owner.398 CollectionCreated(CollectionId, u8, AccountId),399400 /// New item was created.401 ///402 /// # Arguments403 ///404 /// * collection_id: Id of the collection where item was created.405 ///406 /// * item_id: Id of an item. Unique within the collection.407 ///408 /// * recipient: Owner of newly created item409 ItemCreated(CollectionId, TokenId, CrossAccountId),410411 /// Collection item was burned.412 ///413 /// # Arguments414 ///415 /// collection_id.416 ///417 /// item_id: Identifier of burned NFT.418 ItemDestroyed(CollectionId, TokenId),419420 /// Item was transferred421 ///422 /// * collection_id: Id of collection to which item is belong423 ///424 /// * item_id: Id of an item425 ///426 /// * sender: Original owner of item427 ///428 /// * recipient: New owner of item429 ///430 /// * amount: Always 1 for NFT431 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),432433 /// * collection_id434 ///435 /// * item_id436 ///437 /// * sender438 ///439 /// * spender440 ///441 /// * amount442 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),443 }444);445446decl_module! {447 pub struct Module<T: Config> for enum Call448 where449 origin: T::Origin450 {451 fn deposit_event() = default;452 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;453 type Error = Error<T>;454455 fn on_initialize(_now: T::BlockNumber) -> Weight {456 0457 }458459 /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.460 ///461 /// # Permissions462 ///463 /// * Anyone.464 ///465 /// # Arguments466 ///467 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.468 ///469 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.470 ///471 /// * token_prefix: UTF-8 string with token prefix.472 ///473 /// * mode: [CollectionMode] collection type and type dependent data.474 // returns collection ID475 #[weight = <SelfWeightOf<T>>::create_collection()]476 #[transactional]477 pub fn create_collection(origin,478 collection_name: Vec<u16>,479 collection_description: Vec<u16>,480 token_prefix: Vec<u8>,481 mode: CollectionMode) -> DispatchResult {482483 // Anyone can create a collection484 let who = ensure_signed(origin)?;485486 // Take a (non-refundable) deposit of collection creation487 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();488 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(489 &T::TreasuryAccountId::get(),490 T::CollectionCreationPrice::get(),491 ));492 <T as Config>::Currency::settle(493 &who,494 imbalance,495 WithdrawReasons::TRANSFER,496 ExistenceRequirement::KeepAlive,497 ).map_err(|_| Error::<T>::NoPermission)?;498499 let decimal_points = match mode {500 CollectionMode::Fungible(points) => points,501 _ => 0502 };503504 let created_count = CreatedCollectionCount::get();505 let destroyed_count = DestroyedCollectionCount::get();506507 // bound Total number of collections508 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);509510 // check params511 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);512 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);513 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);514 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);515516 // Generate next collection ID517 let next_id = created_count518 .checked_add(1)519 .ok_or(Error::<T>::NumOverflow)?;520521 CreatedCollectionCount::put(next_id);522523 let limits = CollectionLimits {524 sponsored_data_size: CUSTOM_DATA_LIMIT,525 ..Default::default()526 };527528 // Create new collection529 let new_collection = Collection {530 owner: who.clone(),531 name: collection_name,532 mode: mode.clone(),533 mint_mode: false,534 access: AccessMode::Normal,535 description: collection_description,536 decimal_points,537 token_prefix,538 offchain_schema: Vec::new(),539 schema_version: SchemaVersion::ImageURL,540 sponsorship: SponsorshipState::Disabled,541 variable_on_chain_schema: Vec::new(),542 const_on_chain_schema: Vec::new(),543 limits,544 transfers_enabled: true,545 };546547 // Add new collection to map548 <CollectionById<T>>::insert(next_id, new_collection);549550 // call event551 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));552553 Ok(())554 }555556 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.557 ///558 /// # Permissions559 ///560 /// * Collection Owner.561 ///562 /// # Arguments563 ///564 /// * collection_id: collection to destroy.565 #[weight = <SelfWeightOf<T>>::destroy_collection()]566 #[transactional]567 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {568569 let sender = ensure_signed(origin)?;570 let collection = Self::get_collection(collection_id)?;571 Self::check_owner_permissions(&collection, &sender)?;572 if !collection.limits.owner_can_destroy {573 fail!(Error::<T>::NoPermission);574 }575576 <AddressTokens<T>>::remove_prefix(collection_id, None);577 <Allowances<T>>::remove_prefix(collection_id, None);578 <Balance<T>>::remove_prefix(collection_id, None);579 <ItemListIndex>::remove(collection_id);580 <AdminList<T>>::remove(collection_id);581 <CollectionById<T>>::remove(collection_id);582 <WhiteList<T>>::remove_prefix(collection_id, None);583584 <NftItemList<T>>::remove_prefix(collection_id, None);585 <FungibleItemList<T>>::remove_prefix(collection_id, None);586 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);587588 <NftTransferBasket<T>>::remove_prefix(collection_id, None);589 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);590 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);591592 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);593594 DestroyedCollectionCount::put(DestroyedCollectionCount::get()595 .checked_add(1)596 .ok_or(Error::<T>::NumOverflow)?);597598 Ok(())599 }600601 /// Add an address to white list.602 ///603 /// # Permissions604 ///605 /// * Collection Owner606 /// * Collection Admin607 ///608 /// # Arguments609 ///610 /// * collection_id.611 ///612 /// * address.613 #[weight = <SelfWeightOf<T>>::add_to_white_list()]614 #[transactional]615 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{616617 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);618 let collection = Self::get_collection(collection_id)?;619620 Self::toggle_white_list_internal(621 &sender,622 &collection,623 &address,624 true,625 )?;626627 Ok(())628 }629630 /// Remove an address from white list.631 ///632 /// # Permissions633 ///634 /// * Collection Owner635 /// * Collection Admin636 ///637 /// # Arguments638 ///639 /// * collection_id.640 ///641 /// * address.642 #[weight = <SelfWeightOf<T>>::remove_from_white_list()]643 #[transactional]644 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{645646 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);647 let collection = Self::get_collection(collection_id)?;648649 Self::toggle_white_list_internal(650 &sender,651 &collection,652 &address,653 false,654 )?;655656 Ok(())657 }658659 /// Toggle between normal and white list access for the methods with access for `Anyone`.660 ///661 /// # Permissions662 ///663 /// * Collection Owner.664 ///665 /// # Arguments666 ///667 /// * collection_id.668 ///669 /// * mode: [AccessMode]670 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]671 #[transactional]672 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult673 {674 let sender = ensure_signed(origin)?;675676 let mut target_collection = Self::get_collection(collection_id)?;677 Self::check_owner_permissions(&target_collection, &sender)?;678 target_collection.access = mode;679 target_collection.save()680 }681682 /// Allows Anyone to create tokens if:683 /// * White List is enabled, and684 /// * Address is added to white list, and685 /// * This method was called with True parameter686 ///687 /// # Permissions688 /// * Collection Owner689 ///690 /// # Arguments691 ///692 /// * collection_id.693 ///694 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.695 #[weight = <SelfWeightOf<T>>::set_mint_permission()]696 #[transactional]697 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult698 {699 let sender = ensure_signed(origin)?;700701 let mut target_collection = Self::get_collection(collection_id)?;702 Self::check_owner_permissions(&target_collection, &sender)?;703 target_collection.mint_mode = mint_permission;704 target_collection.save()705 }706707 /// Change the owner of the collection.708 ///709 /// # Permissions710 ///711 /// * Collection Owner.712 ///713 /// # Arguments714 ///715 /// * collection_id.716 ///717 /// * new_owner.718 #[weight = <SelfWeightOf<T>>::change_collection_owner()]719 #[transactional]720 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {721722 let sender = ensure_signed(origin)?;723 let mut target_collection = Self::get_collection(collection_id)?;724 Self::check_owner_permissions(&target_collection, &sender)?;725 target_collection.owner = new_owner;726 target_collection.save()727 }728729 /// Adds an admin of the Collection.730 /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.731 ///732 /// # Permissions733 ///734 /// * Collection Owner.735 /// * Collection Admin.736 ///737 /// # Arguments738 ///739 /// * collection_id: ID of the Collection to add admin for.740 ///741 /// * new_admin_id: Address of new admin to add.742 #[weight = <SelfWeightOf<T>>::add_collection_admin()]743 #[transactional]744 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {745 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);746 let collection = Self::get_collection(collection_id)?;747 Self::check_owner_or_admin_permissions(&collection, &sender)?;748 let mut admin_arr = <AdminList<T>>::get(collection_id);749750 match admin_arr.binary_search(&new_admin_id) {751 Ok(_) => {},752 Err(idx) => {753 ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);754 admin_arr.insert(idx, new_admin_id);755 <AdminList<T>>::insert(collection_id, admin_arr);756 }757 }758 Ok(())759 }760761 /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.762 ///763 /// # Permissions764 ///765 /// * Collection Owner.766 /// * Collection Admin.767 ///768 /// # Arguments769 ///770 /// * collection_id: ID of the Collection to remove admin for.771 ///772 /// * account_id: Address of admin to remove.773 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]774 #[transactional]775 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {776 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);777 let collection = Self::get_collection(collection_id)?;778 Self::check_owner_or_admin_permissions(&collection, &sender)?;779 let mut admin_arr = <AdminList<T>>::get(collection_id);780781 if let Ok(idx) = admin_arr.binary_search(&account_id) {782 admin_arr.remove(idx);783 <AdminList<T>>::insert(collection_id, admin_arr);784 }785 Ok(())786 }787788 /// # Permissions789 ///790 /// * Collection Owner791 ///792 /// # Arguments793 ///794 /// * collection_id.795 ///796 /// * new_sponsor.797 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]798 #[transactional]799 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {800 let sender = ensure_signed(origin)?;801 let mut target_collection = Self::get_collection(collection_id)?;802 Self::check_owner_permissions(&target_collection, &sender)?;803804 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);805 target_collection.save()806 }807808 /// # Permissions809 ///810 /// * Sponsor.811 ///812 /// # Arguments813 ///814 /// * collection_id.815 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]816 #[transactional]817 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {818 let sender = ensure_signed(origin)?;819820 let mut target_collection = Self::get_collection(collection_id)?;821 ensure!(822 target_collection.sponsorship.pending_sponsor() == Some(&sender),823 Error::<T>::ConfirmUnsetSponsorFail824 );825826 target_collection.sponsorship = SponsorshipState::Confirmed(sender);827 target_collection.save()828 }829830 /// Switch back to pay-per-own-transaction model.831 ///832 /// # Permissions833 ///834 /// * Collection owner.835 ///836 /// # Arguments837 ///838 /// * collection_id.839 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]840 #[transactional]841 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {842 let sender = ensure_signed(origin)?;843844 let mut target_collection = Self::get_collection(collection_id)?;845 Self::check_owner_permissions(&target_collection, &sender)?;846847 target_collection.sponsorship = SponsorshipState::Disabled;848 target_collection.save()849 }850851 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.852 ///853 /// # Permissions854 ///855 /// * Collection Owner.856 /// * Collection Admin.857 /// * Anyone if858 /// * White List is enabled, and859 /// * Address is added to white list, and860 /// * MintPermission is enabled (see SetMintPermission method)861 ///862 /// # Arguments863 ///864 /// * collection_id: ID of the collection.865 ///866 /// * owner: Address, initial owner of the NFT.867 ///868 /// * data: Token data to store on chain.869 // #[weight =870 // (130_000_000 as Weight)871 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))872 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))873 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]874875 #[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]876 #[transactional]877 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {878 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);879 let collection = Self::get_collection(collection_id)?;880881 Self::create_item_internal(&sender, &collection, &owner, data)?;882883 collection.submit_logs()884 }885886 /// This method creates multiple items in a collection created with CreateCollection method.887 ///888 /// # Permissions889 ///890 /// * Collection Owner.891 /// * Collection Admin.892 /// * Anyone if893 /// * White List is enabled, and894 /// * Address is added to white list, and895 /// * MintPermission is enabled (see SetMintPermission method)896 ///897 /// # Arguments898 ///899 /// * collection_id: ID of the collection.900 ///901 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].902 ///903 /// * owner: Address, initial owner of the NFT.904 #[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]905 #[transactional]906 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {907908 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);909 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);910 let collection = Self::get_collection(collection_id)?;911912 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;913914 collection.submit_logs()915 }916917 // TODO! transaction weight918919 /// Set transfers_enabled value for particular collection920 ///921 /// # Permissions922 ///923 /// * Collection Owner.924 ///925 /// # Arguments926 ///927 /// * collection_id: ID of the collection.928 ///929 /// * value: New flag value.930 #[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]931 #[transactional]932 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {933934 let sender = ensure_signed(origin)?;935 let mut target_collection = Self::get_collection(collection_id)?;936937 Self::check_owner_permissions(&target_collection, &sender)?;938939 target_collection.transfers_enabled = value;940 target_collection.save()941 }942943 /// Destroys a concrete instance of NFT.944 ///945 /// # Permissions946 ///947 /// * Collection Owner.948 /// * Collection Admin.949 /// * Current NFT Owner.950 ///951 /// # Arguments952 ///953 /// * collection_id: ID of the collection.954 ///955 /// * item_id: ID of NFT to burn.956 #[weight = <SelfWeightOf<T>>::burn_item()]957 #[transactional]958 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {959960 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);961 let target_collection = Self::get_collection(collection_id)?;962963 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;964965 target_collection.submit_logs()966 }967968 /// Change ownership of the token.969 ///970 /// # Permissions971 ///972 /// * Collection Owner973 /// * Collection Admin974 /// * Current NFT owner975 ///976 /// # Arguments977 ///978 /// * recipient: Address of token recipient.979 ///980 /// * collection_id.981 ///982 /// * item_id: ID of the item983 /// * Non-Fungible Mode: Required.984 /// * Fungible Mode: Ignored.985 /// * Re-Fungible Mode: Required.986 ///987 /// * value: Amount to transfer.988 /// * Non-Fungible Mode: Ignored989 /// * Fungible Mode: Must specify transferred amount990 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)991 #[weight = <SelfWeightOf<T>>::transfer()]992 #[transactional]993 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {994 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);995 let collection = Self::get_collection(collection_id)?;996997 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;998999 collection.submit_logs()1000 }10011002 /// Set, change, or remove approved address to transfer the ownership of the NFT.1003 ///1004 /// # Permissions1005 ///1006 /// * Collection Owner1007 /// * Collection Admin1008 /// * Current NFT owner1009 ///1010 /// # Arguments1011 ///1012 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1013 ///1014 /// * collection_id.1015 ///1016 /// * item_id: ID of the item.1017 #[weight = <SelfWeightOf<T>>::approve()]1018 #[transactional]1019 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1020 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1021 let collection = Self::get_collection(collection_id)?;10221023 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10241025 collection.submit_logs()1026 }10271028 /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1029 ///1030 /// # Permissions1031 /// * Collection Owner1032 /// * Collection Admin1033 /// * Current NFT owner1034 /// * Address approved by current NFT owner1035 ///1036 /// # Arguments1037 ///1038 /// * from: Address that owns token.1039 ///1040 /// * recipient: Address of token recipient.1041 ///1042 /// * collection_id.1043 ///1044 /// * item_id: ID of the item.1045 ///1046 /// * value: Amount to transfer.1047 #[weight = <SelfWeightOf<T>>::transfer_from()]1048 #[transactional]1049 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1050 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1051 let collection = Self::get_collection(collection_id)?;10521053 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10541055 collection.submit_logs()1056 }1057 // #[weight = 0]1058 // // let no_perm_mes = "You do not have permissions to modify this collection";1059 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1060 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1061 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10621063 // // // on_nft_received call10641065 // // Self::transfer(origin, collection_id, item_id, new_owner)?;10661067 // Ok(())1068 // }10691070 /// Set off-chain data schema.1071 ///1072 /// # Permissions1073 ///1074 /// * Collection Owner1075 /// * Collection Admin1076 ///1077 /// # Arguments1078 ///1079 /// * collection_id.1080 ///1081 /// * schema: String representing the offchain data schema.1082 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1083 #[transactional]1084 pub fn set_variable_meta_data (1085 origin,1086 collection_id: CollectionId,1087 item_id: TokenId,1088 data: Vec<u8>1089 ) -> DispatchResult {1090 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10911092 let collection = Self::get_collection(collection_id)?;10931094 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10951096 Ok(())1097 }10981099 /// Set schema standard1100 /// ImageURL1101 /// Unique1102 ///1103 /// # Permissions1104 ///1105 /// * Collection Owner1106 /// * Collection Admin1107 ///1108 /// # Arguments1109 ///1110 /// * collection_id.1111 ///1112 /// * schema: SchemaVersion: enum1113 #[weight = <SelfWeightOf<T>>::set_schema_version()]1114 #[transactional]1115 pub fn set_schema_version(1116 origin,1117 collection_id: CollectionId,1118 version: SchemaVersion1119 ) -> DispatchResult {1120 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1121 let mut target_collection = Self::get_collection(collection_id)?;1122 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1123 target_collection.schema_version = version;1124 target_collection.save()1125 }11261127 /// Set off-chain data schema.1128 ///1129 /// # Permissions1130 ///1131 /// * Collection Owner1132 /// * Collection Admin1133 ///1134 /// # Arguments1135 ///1136 /// * collection_id.1137 ///1138 /// * schema: String representing the offchain data schema.1139 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1140 #[transactional]1141 pub fn set_offchain_schema(1142 origin,1143 collection_id: CollectionId,1144 schema: Vec<u8>1145 ) -> DispatchResult {1146 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1147 let mut target_collection = Self::get_collection(collection_id)?;1148 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11491150 // check schema limit1151 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11521153 target_collection.offchain_schema = schema;1154 target_collection.save()1155 }11561157 /// Set const on-chain data schema.1158 ///1159 /// # Permissions1160 ///1161 /// * Collection Owner1162 /// * Collection Admin1163 ///1164 /// # Arguments1165 ///1166 /// * collection_id.1167 ///1168 /// * schema: String representing the const on-chain data schema.1169 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1170 #[transactional]1171 pub fn set_const_on_chain_schema (1172 origin,1173 collection_id: CollectionId,1174 schema: Vec<u8>1175 ) -> DispatchResult {1176 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1177 let mut target_collection = Self::get_collection(collection_id)?;1178 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11791180 // check schema limit1181 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");11821183 target_collection.const_on_chain_schema = schema;1184 target_collection.save()1185 }11861187 /// Set variable on-chain data schema.1188 ///1189 /// # Permissions1190 ///1191 /// * Collection Owner1192 /// * Collection Admin1193 ///1194 /// # Arguments1195 ///1196 /// * collection_id.1197 ///1198 /// * schema: String representing the variable on-chain data schema.1199 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1200 #[transactional]1201 pub fn set_variable_on_chain_schema (1202 origin,1203 collection_id: CollectionId,1204 schema: Vec<u8>1205 ) -> DispatchResult {1206 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1207 let mut target_collection = Self::get_collection(collection_id)?;1208 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12091210 // check schema limit1211 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12121213 target_collection.variable_on_chain_schema = schema;1214 target_collection.save()1215 }12161217 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1218 #[transactional]1219 pub fn set_collection_limits(1220 origin,1221 collection_id: u32,1222 new_limits: CollectionLimits<T::BlockNumber>,1223 ) -> DispatchResult {1224 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1225 let mut target_collection = Self::get_collection(collection_id)?;1226 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1227 let old_limits = &target_collection.limits;12281229 // collection bounds1230 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1231 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1232 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1233 Error::<T>::CollectionLimitBoundsExceeded);12341235 // token_limit check prev1236 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1237 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12381239 ensure!(1240 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1241 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1242 Error::<T>::OwnerPermissionsCantBeReverted,1243 );12441245 target_collection.limits = new_limits;12461247 target_collection.save()1248 }1249 }1250}12511252impl<T: Config> Module<T> {1253 pub fn create_item_internal(1254 sender: &T::CrossAccountId,1255 collection: &CollectionHandle<T>,1256 owner: &T::CrossAccountId,1257 data: CreateItemData,1258 ) -> DispatchResult {1259 ensure!(1260 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1261 Error::<T>::AddressIsZero1262 );12631264 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1265 Self::validate_create_item_args(collection, &data)?;1266 Self::create_item_no_validation(collection, owner, data)?;12671268 Ok(())1269 }12701271 pub fn transfer_internal(1272 sender: &T::CrossAccountId,1273 recipient: &T::CrossAccountId,1274 target_collection: &CollectionHandle<T>,1275 item_id: TokenId,1276 value: u128,1277 ) -> DispatchResult {1278 ensure!(1279 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1280 Error::<T>::AddressIsZero1281 );12821283 // Limits check1284 Self::is_correct_transfer(target_collection, recipient)?;12851286 // Transfer permissions check1287 ensure!(1288 Self::is_item_owner(sender, target_collection, item_id)?1289 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1290 Error::<T>::NoPermission1291 );12921293 if target_collection.access == AccessMode::WhiteList {1294 Self::check_white_list(target_collection, sender)?;1295 Self::check_white_list(target_collection, recipient)?;1296 }12971298 match target_collection.mode {1299 CollectionMode::NFT => Self::transfer_nft(1300 target_collection,1301 item_id,1302 sender.clone(),1303 recipient.clone(),1304 )?,1305 CollectionMode::Fungible(_) => {1306 Self::transfer_fungible(target_collection, value, sender, recipient)?1307 }1308 CollectionMode::ReFungible => Self::transfer_refungible(1309 target_collection,1310 item_id,1311 value,1312 sender.clone(),1313 recipient.clone(),1314 )?,1315 _ => (),1316 };13171318 Self::deposit_event(RawEvent::Transfer(1319 target_collection.id,1320 item_id,1321 sender.clone(),1322 recipient.clone(),1323 value,1324 ));13251326 Ok(())1327 }13281329 pub fn approve_internal(1330 sender: &T::CrossAccountId,1331 spender: &T::CrossAccountId,1332 collection: &CollectionHandle<T>,1333 item_id: TokenId,1334 amount: u128,1335 ) -> DispatchResult {1336 Self::token_exists(collection, item_id)?;13371338 // Transfer permissions check1339 let bypasses_limits = collection.limits.owner_can_transfer1340 && Self::is_owner_or_admin_permissions(collection, sender)?;13411342 let allowance_limit = if bypasses_limits {1343 None1344 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1345 Some(amount)1346 } else {1347 fail!(Error::<T>::NoPermission);1348 };13491350 if collection.access == AccessMode::WhiteList {1351 Self::check_white_list(collection, sender)?;1352 Self::check_white_list(collection, spender)?;1353 }13541355 collection.consume_sload()?;1356 let allowance: u128 = amount1357 .checked_add(<Allowances<T>>::get(1358 collection.id,1359 (item_id, sender.as_sub(), spender.as_sub()),1360 ))1361 .ok_or(Error::<T>::NumOverflow)?;1362 if let Some(limit) = allowance_limit {1363 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1364 }1365 collection.consume_sstore()?;1366 <Allowances<T>>::insert(1367 collection.id,1368 (item_id, sender.as_sub(), spender.as_sub()),1369 allowance,1370 );13711372 if matches!(collection.mode, CollectionMode::NFT) {1373 // TODO: NFT: only one owner may exist for token in ERC7211374 collection.log(ERC721Events::Approval {1375 owner: *sender.as_eth(),1376 approved: *spender.as_eth(),1377 token_id: item_id.into(),1378 })?;1379 }13801381 if matches!(collection.mode, CollectionMode::Fungible(_)) {1382 // TODO: NFT: only one owner may exist for token in ERC201383 collection.log(ERC20Events::Approval {1384 owner: *sender.as_eth(),1385 spender: *spender.as_eth(),1386 value: allowance.into(),1387 })?;1388 }13891390 Self::deposit_event(RawEvent::Approved(1391 collection.id,1392 item_id,1393 sender.clone(),1394 spender.clone(),1395 allowance,1396 ));1397 Ok(())1398 }13991400 pub fn transfer_from_internal(1401 sender: &T::CrossAccountId,1402 from: &T::CrossAccountId,1403 recipient: &T::CrossAccountId,1404 collection: &CollectionHandle<T>,1405 item_id: TokenId,1406 amount: u128,1407 ) -> DispatchResult {1408 if sender == from {1409 // Transfer by `from`, because it is either equal to sender, or derived from him1410 return Self::transfer_internal(from, recipient, collection, item_id, amount);1411 }14121413 // Check approval1414 collection.consume_sload()?;1415 let approval: u128 =1416 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14171418 // Limits check1419 Self::is_correct_transfer(collection, recipient)?;14201421 // Transfer permissions check1422 ensure!(1423 approval >= amount1424 || (collection.limits.owner_can_transfer1425 && Self::is_owner_or_admin_permissions(collection, sender)?),1426 Error::<T>::NoPermission1427 );14281429 if collection.access == AccessMode::WhiteList {1430 Self::check_white_list(collection, sender)?;1431 Self::check_white_list(collection, recipient)?;1432 }14331434 // Reduce approval by transferred amount or remove if remaining approval drops to 01435 let allowance = approval.saturating_sub(amount);1436 collection.consume_sstore()?;1437 if allowance > 0 {1438 <Allowances<T>>::insert(1439 collection.id,1440 (item_id, from.as_sub(), sender.as_sub()),1441 allowance,1442 );1443 } else {1444 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1445 }14461447 match collection.mode {1448 CollectionMode::NFT => {1449 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1450 }1451 CollectionMode::Fungible(_) => {1452 Self::transfer_fungible(collection, amount, from, recipient)?1453 }1454 CollectionMode::ReFungible => Self::transfer_refungible(1455 collection,1456 item_id,1457 amount,1458 from.clone(),1459 recipient.clone(),1460 )?,1461 _ => (),1462 };14631464 if matches!(collection.mode, CollectionMode::Fungible(_)) {1465 collection.log(ERC20Events::Approval {1466 owner: *from.as_eth(),1467 spender: *sender.as_eth(),1468 value: allowance.into(),1469 })?;1470 }14711472 Ok(())1473 }14741475 pub fn set_variable_meta_data_internal(1476 sender: &T::CrossAccountId,1477 collection: &CollectionHandle<T>,1478 item_id: TokenId,1479 data: Vec<u8>,1480 ) -> DispatchResult {1481 Self::token_exists(collection, item_id)?;14821483 ensure!(1484 CUSTOM_DATA_LIMIT >= data.len() as u32,1485 Error::<T>::TokenVariableDataLimitExceeded1486 );14871488 // Modify permissions check1489 ensure!(1490 Self::is_item_owner(sender, collection, item_id)?1491 || Self::is_owner_or_admin_permissions(collection, sender)?,1492 Error::<T>::NoPermission1493 );14941495 match collection.mode {1496 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1497 CollectionMode::ReFungible => {1498 Self::set_re_fungible_variable_data(collection, item_id, data)?1499 }1500 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1501 _ => fail!(Error::<T>::UnexpectedCollectionType),1502 };15031504 Ok(())1505 }15061507 pub fn get_variable_metadata(1508 collection: &CollectionHandle<T>,1509 item_id: TokenId,1510 ) -> Result<Vec<u8>, DispatchError> {1511 Ok(match collection.mode {1512 CollectionMode::NFT => {1513 <NftItemList<T>>::get(collection.id, item_id)1514 .ok_or(Error::<T>::TokenNotFound)?1515 .variable_data1516 }1517 CollectionMode::ReFungible => {1518 <ReFungibleItemList<T>>::get(collection.id, item_id)1519 .ok_or(Error::<T>::TokenNotFound)?1520 .variable_data1521 }1522 _ => fail!(Error::<T>::UnexpectedCollectionType),1523 })1524 }15251526 pub fn create_multiple_items_internal(1527 sender: &T::CrossAccountId,1528 collection: &CollectionHandle<T>,1529 owner: &T::CrossAccountId,1530 items_data: Vec<CreateItemData>,1531 ) -> DispatchResult {1532 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15331534 for data in &items_data {1535 Self::validate_create_item_args(collection, data)?;1536 }1537 for data in &items_data {1538 Self::create_item_no_validation(collection, owner, data.clone())?;1539 }15401541 Ok(())1542 }15431544 pub fn burn_item_internal(1545 sender: &T::CrossAccountId,1546 collection: &CollectionHandle<T>,1547 item_id: TokenId,1548 value: u128,1549 ) -> DispatchResult {1550 ensure!(1551 Self::is_item_owner(sender, collection, item_id)?1552 || (collection.limits.owner_can_transfer1553 && Self::is_owner_or_admin_permissions(collection, sender)?),1554 Error::<T>::NoPermission1555 );15561557 if collection.access == AccessMode::WhiteList {1558 Self::check_white_list(collection, sender)?;1559 }15601561 match collection.mode {1562 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1563 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1564 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1565 _ => (),1566 };15671568 Ok(())1569 }15701571 pub fn toggle_white_list_internal(1572 sender: &T::CrossAccountId,1573 collection: &CollectionHandle<T>,1574 address: &T::CrossAccountId,1575 whitelisted: bool,1576 ) -> DispatchResult {1577 Self::check_owner_or_admin_permissions(collection, sender)?;15781579 if whitelisted {1580 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1581 } else {1582 <WhiteList<T>>::remove(collection.id, address.as_sub());1583 }15841585 Ok(())1586 }15871588 fn is_correct_transfer(1589 collection: &CollectionHandle<T>,1590 recipient: &T::CrossAccountId,1591 ) -> DispatchResult {1592 let collection_id = collection.id;15931594 // check token limit and account token limit1595 collection.consume_sload()?;1596 let account_items: u32 =1597 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1598 ensure!(1599 collection.limits.account_token_ownership_limit > account_items,1600 Error::<T>::AccountTokenLimitExceeded1601 );16021603 // preliminary transfer check1604 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16051606 Ok(())1607 }16081609 fn can_create_items_in_collection(1610 collection: &CollectionHandle<T>,1611 sender: &T::CrossAccountId,1612 owner: &T::CrossAccountId,1613 amount: u32,1614 ) -> DispatchResult {1615 let collection_id = collection.id;16161617 // check token limit and account token limit1618 let total_items: u32 = ItemListIndex::get(collection_id)1619 .checked_add(amount)1620 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1621 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1622 as u32)1623 .checked_add(amount)1624 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1625 ensure!(1626 collection.limits.token_limit >= total_items,1627 Error::<T>::CollectionTokenLimitExceeded1628 );1629 ensure!(1630 collection.limits.account_token_ownership_limit >= account_items,1631 Error::<T>::AccountTokenLimitExceeded1632 );16331634 if !Self::is_owner_or_admin_permissions(collection, sender)? {1635 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1636 Self::check_white_list(collection, owner)?;1637 Self::check_white_list(collection, sender)?;1638 }16391640 Ok(())1641 }16421643 fn validate_create_item_args(1644 target_collection: &CollectionHandle<T>,1645 data: &CreateItemData,1646 ) -> DispatchResult {1647 match target_collection.mode {1648 CollectionMode::NFT => {1649 if !matches!(data, CreateItemData::NFT(_)) {1650 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1651 }1652 }1653 CollectionMode::Fungible(_) => {1654 if !matches!(data, CreateItemData::Fungible(_)) {1655 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1656 }1657 }1658 CollectionMode::ReFungible => {1659 if let CreateItemData::ReFungible(data) = data {1660 // Check refungibility limits1661 ensure!(1662 data.pieces <= MAX_REFUNGIBLE_PIECES,1663 Error::<T>::WrongRefungiblePieces1664 );1665 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1666 } else {1667 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1668 }1669 }1670 _ => {1671 fail!(Error::<T>::UnexpectedCollectionType);1672 }1673 };16741675 Ok(())1676 }16771678 fn create_item_no_validation(1679 collection: &CollectionHandle<T>,1680 owner: &T::CrossAccountId,1681 data: CreateItemData,1682 ) -> DispatchResult {1683 match data {1684 CreateItemData::NFT(data) => {1685 let item = NftItemType {1686 owner: owner.clone(),1687 const_data: data.const_data.into_inner(),1688 variable_data: data.variable_data.into_inner(),1689 };16901691 Self::add_nft_item(collection, item)?;1692 }1693 CreateItemData::Fungible(data) => {1694 Self::add_fungible_item(collection, owner, data.value)?;1695 }1696 CreateItemData::ReFungible(data) => {1697 let owner_list = vec![Ownership {1698 owner: owner.clone(),1699 fraction: data.pieces,1700 }];17011702 let item = ReFungibleItemType {1703 owner: owner_list,1704 const_data: data.const_data.into_inner(),1705 variable_data: data.variable_data.into_inner(),1706 };17071708 Self::add_refungible_item(collection, item)?;1709 }1710 };17111712 Ok(())1713 }17141715 fn add_fungible_item(1716 collection: &CollectionHandle<T>,1717 owner: &T::CrossAccountId,1718 value: u128,1719 ) -> DispatchResult {1720 let collection_id = collection.id;17211722 // Does new owner already have an account?1723 collection.consume_sload()?;1724 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17251726 // Mint1727 let item = FungibleItemType {1728 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1729 };1730 collection.consume_sstore()?;1731 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17321733 // Update balance1734 collection.consume_sload()?;1735 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1736 .checked_add(value)1737 .ok_or(Error::<T>::NumOverflow)?;1738 collection.consume_sstore()?;1739 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17401741 collection.log(ERC20Events::Transfer {1742 from: H160::default(),1743 to: *owner.as_eth(),1744 value: value.into(),1745 })?;1746 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1747 Ok(())1748 }17491750 fn add_refungible_item(1751 collection: &CollectionHandle<T>,1752 item: ReFungibleItemType<T::CrossAccountId>,1753 ) -> DispatchResult {1754 let collection_id = collection.id;17551756 let current_index = <ItemListIndex>::get(collection_id)1757 .checked_add(1)1758 .ok_or(Error::<T>::NumOverflow)?;1759 let itemcopy = item.clone();17601761 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1762 let item_owner = item.owner.first().expect("only one owner is defined");17631764 let value = item_owner.fraction;1765 let owner = item_owner.owner.clone();17661767 Self::add_token_index(collection, current_index, &owner)?;17681769 <ItemListIndex>::insert(collection_id, current_index);1770 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17711772 // Update balance1773 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1774 .checked_add(value)1775 .ok_or(Error::<T>::NumOverflow)?;1776 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17771778 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1779 Ok(())1780 }17811782 fn add_nft_item(1783 collection: &CollectionHandle<T>,1784 item: NftItemType<T::CrossAccountId>,1785 ) -> DispatchResult {1786 let collection_id = collection.id;17871788 let current_index = <ItemListIndex>::get(collection_id)1789 .checked_add(1)1790 .ok_or(Error::<T>::NumOverflow)?;17911792 let item_owner = item.owner.clone();1793 Self::add_token_index(collection, current_index, &item.owner)?;17941795 <ItemListIndex>::insert(collection_id, current_index);1796 <NftItemList<T>>::insert(collection_id, current_index, item);17971798 // Update balance1799 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1800 .checked_add(1)1801 .ok_or(Error::<T>::NumOverflow)?;1802 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18031804 collection.log(ERC721Events::Transfer {1805 from: H160::default(),1806 to: *item_owner.as_eth(),1807 token_id: current_index.into(),1808 })?;1809 Self::deposit_event(RawEvent::ItemCreated(1810 collection_id,1811 current_index,1812 item_owner,1813 ));1814 Ok(())1815 }18161817 fn burn_refungible_item(1818 collection: &CollectionHandle<T>,1819 item_id: TokenId,1820 owner: &T::CrossAccountId,1821 ) -> DispatchResult {1822 let collection_id = collection.id;18231824 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1825 .ok_or(Error::<T>::TokenNotFound)?;1826 let rft_balance = token1827 .owner1828 .iter()1829 .find(|&i| i.owner == *owner)1830 .ok_or(Error::<T>::TokenNotFound)?;1831 Self::remove_token_index(collection, item_id, owner)?;18321833 // update balance1834 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1835 .checked_sub(rft_balance.fraction)1836 .ok_or(Error::<T>::NumOverflow)?;1837 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18381839 // Re-create owners list with sender removed1840 let index = token1841 .owner1842 .iter()1843 .position(|i| i.owner == *owner)1844 .expect("owned item is exists");1845 token.owner.remove(index);1846 let owner_count = token.owner.len();18471848 // Burn the token completely if this was the last (only) owner1849 if owner_count == 0 {1850 <ReFungibleItemList<T>>::remove(collection_id, item_id);1851 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1852 } else {1853 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1854 }18551856 Ok(())1857 }18581859 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1860 let collection_id = collection.id;18611862 let item =1863 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1864 Self::remove_token_index(collection, item_id, &item.owner)?;18651866 // update balance1867 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1868 .checked_sub(1)1869 .ok_or(Error::<T>::NumOverflow)?;1870 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1871 <NftItemList<T>>::remove(collection_id, item_id);1872 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18731874 collection.log(ERC721Events::Transfer {1875 from: *item.owner.as_eth(),1876 to: H160::default(),1877 token_id: item_id.into(),1878 })?;1879 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1880 Ok(())1881 }18821883 fn burn_fungible_item(1884 owner: &T::CrossAccountId,1885 collection: &CollectionHandle<T>,1886 value: u128,1887 ) -> DispatchResult {1888 let collection_id = collection.id;18891890 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1891 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18921893 // update balance1894 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1895 .checked_sub(value)1896 .ok_or(Error::<T>::NumOverflow)?;1897 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18981899 if balance.value - value > 0 {1900 balance.value -= value;1901 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1902 } else {1903 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1904 }19051906 collection.log(ERC20Events::Transfer {1907 from: *owner.as_eth(),1908 to: H160::default(),1909 value: value.into(),1910 })?;1911 Ok(())1912 }19131914 pub fn get_collection(1915 collection_id: CollectionId,1916 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1917 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1918 }19191920 fn check_owner_permissions(1921 target_collection: &CollectionHandle<T>,1922 subject: &T::AccountId,1923 ) -> DispatchResult {1924 ensure!(1925 *subject == target_collection.owner,1926 Error::<T>::NoPermission1927 );19281929 Ok(())1930 }19311932 fn is_owner_or_admin_permissions(1933 collection: &CollectionHandle<T>,1934 subject: &T::CrossAccountId,1935 ) -> Result<bool, DispatchError> {1936 collection.consume_sload()?;1937 Ok(*subject.as_sub() == collection.owner1938 || <AdminList<T>>::get(collection.id).contains(subject))1939 }19401941 fn check_owner_or_admin_permissions(1942 collection: &CollectionHandle<T>,1943 subject: &T::CrossAccountId,1944 ) -> DispatchResult {1945 ensure!(1946 Self::is_owner_or_admin_permissions(collection, subject)?,1947 Error::<T>::NoPermission1948 );19491950 Ok(())1951 }19521953 fn owned_amount(1954 subject: &T::CrossAccountId,1955 collection: &CollectionHandle<T>,1956 item_id: TokenId,1957 ) -> Result<Option<u128>, DispatchError> {1958 collection.consume_sload()?;1959 Ok(Self::owned_amount_unchecked(subject, collection, item_id))1960 }19611962 fn owned_amount_unchecked(1963 subject: &T::CrossAccountId,1964 target_collection: &CollectionHandle<T>,1965 item_id: TokenId,1966 ) -> Option<u128> {1967 let collection_id = target_collection.id;19681969 match target_collection.mode {1970 CollectionMode::NFT => {1971 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1972 }1973 CollectionMode::Fungible(_) => {1974 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1975 }1976 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1977 .owner1978 .iter()1979 .find(|i| i.owner == *subject)1980 .map(|i| i.fraction),1981 CollectionMode::Invalid => None,1982 }1983 }19841985 fn is_item_owner(1986 subject: &T::CrossAccountId,1987 target_collection: &CollectionHandle<T>,1988 item_id: TokenId,1989 ) -> Result<bool, DispatchError> {1990 Ok(match target_collection.mode {1991 CollectionMode::Fungible(_) => true,1992 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),1993 })1994 }19951996 fn check_white_list(1997 collection: &CollectionHandle<T>,1998 address: &T::CrossAccountId,1999 ) -> DispatchResult {2000 collection.consume_sload()?;2001 ensure!(2002 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2003 Error::<T>::AddresNotInWhiteList,2004 );2005 Ok(())2006 }20072008 /// Check if token exists. In case of Fungible, check if there is an entry for2009 /// the owner in fungible balances double map2010 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2011 let collection_id = target_collection.id;2012 let exists = match target_collection.mode {2013 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2014 CollectionMode::Fungible(_) => true,2015 CollectionMode::ReFungible => {2016 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2017 }2018 _ => false,2019 };20202021 ensure!(exists, Error::<T>::TokenNotFound);2022 Ok(())2023 }20242025 fn transfer_fungible(2026 collection: &CollectionHandle<T>,2027 value: u128,2028 owner: &T::CrossAccountId,2029 recipient: &T::CrossAccountId,2030 ) -> DispatchResult {2031 let collection_id = collection.id;20322033 collection.consume_sload()?;2034 collection.consume_sload()?;2035 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2036 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20372038 recipient_balance.value = recipient_balance2039 .value2040 .checked_add(value)2041 .ok_or(Error::<T>::NumOverflow)?;2042 balance.value = balance2043 .value2044 .checked_sub(value)2045 .ok_or(Error::<T>::TokenValueTooLow)?;20462047 // update balanceOf2048 collection.consume_sstore()?;2049 collection.consume_sstore()?;2050 if balance.value != 0 {2051 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2052 } else {2053 <Balance<T>>::remove(collection_id, owner.as_sub());2054 }2055 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20562057 // Reduce or remove sender2058 collection.consume_sstore()?;2059 collection.consume_sstore()?;2060 if balance.value != 0 {2061 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2062 } else {2063 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2064 }2065 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20662067 collection.log(ERC20Events::Transfer {2068 from: *owner.as_eth(),2069 to: *recipient.as_eth(),2070 value: value.into(),2071 })?;2072 Self::deposit_event(RawEvent::Transfer(2073 collection.id,2074 1,2075 owner.clone(),2076 recipient.clone(),2077 value,2078 ));20792080 Ok(())2081 }20822083 fn transfer_refungible(2084 collection: &CollectionHandle<T>,2085 item_id: TokenId,2086 value: u128,2087 owner: T::CrossAccountId,2088 new_owner: T::CrossAccountId,2089 ) -> DispatchResult {2090 let collection_id = collection.id;2091 collection.consume_sload()?;2092 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2093 .ok_or(Error::<T>::TokenNotFound)?;20942095 let item = full_item2096 .owner2097 .iter()2098 .find(|i| i.owner == owner)2099 .ok_or(Error::<T>::TokenNotFound)?;2100 let amount = item.fraction;21012102 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21032104 collection.consume_sload()?;2105 // update balance2106 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2107 .checked_sub(value)2108 .ok_or(Error::<T>::NumOverflow)?;2109 collection.consume_sstore()?;2110 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21112112 collection.consume_sload()?;2113 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2114 .checked_add(value)2115 .ok_or(Error::<T>::NumOverflow)?;2116 collection.consume_sstore()?;2117 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21182119 let old_owner = item.owner.clone();2120 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21212122 let mut new_full_item = full_item.clone();2123 // transfer2124 if amount == value && !new_owner_has_account {2125 // change owner2126 // new owner do not have account2127 new_full_item2128 .owner2129 .iter_mut()2130 .find(|i| i.owner == owner)2131 .expect("old owner does present in refungible")2132 .owner = new_owner.clone();2133 collection.consume_sstore()?;2134 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21352136 // update index collection2137 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2138 } else {2139 new_full_item2140 .owner2141 .iter_mut()2142 .find(|i| i.owner == owner)2143 .expect("old owner does present in refungible")2144 .fraction -= value;21452146 // separate amount2147 if new_owner_has_account {2148 // new owner has account2149 new_full_item2150 .owner2151 .iter_mut()2152 .find(|i| i.owner == new_owner)2153 .expect("new owner has account")2154 .fraction += value;2155 } else {2156 // new owner do not have account2157 new_full_item.owner.push(Ownership {2158 owner: new_owner.clone(),2159 fraction: value,2160 });2161 Self::add_token_index(collection, item_id, &new_owner)?;2162 }21632164 collection.consume_sstore()?;2165 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2166 }21672168 Self::deposit_event(RawEvent::Transfer(2169 collection.id,2170 item_id,2171 owner,2172 new_owner,2173 amount,2174 ));21752176 Ok(())2177 }21782179 fn transfer_nft(2180 collection: &CollectionHandle<T>,2181 item_id: TokenId,2182 sender: T::CrossAccountId,2183 new_owner: T::CrossAccountId,2184 ) -> DispatchResult {2185 let collection_id = collection.id;2186 collection.consume_sload()?;2187 let mut item =2188 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21892190 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21912192 collection.consume_sload()?;2193 // update balance2194 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2195 .checked_sub(1)2196 .ok_or(Error::<T>::NumOverflow)?;2197 collection.consume_sstore()?;2198 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21992200 collection.consume_sload()?;2201 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2202 .checked_add(1)2203 .ok_or(Error::<T>::NumOverflow)?;2204 collection.consume_sstore()?;2205 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22062207 // change owner2208 let old_owner = item.owner.clone();2209 item.owner = new_owner.clone();2210 collection.consume_sstore()?;2211 <NftItemList<T>>::insert(collection_id, item_id, item);22122213 // update index collection2214 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22152216 collection.log(ERC721Events::Transfer {2217 from: *sender.as_eth(),2218 to: *new_owner.as_eth(),2219 token_id: item_id.into(),2220 })?;2221 Self::deposit_event(RawEvent::Transfer(2222 collection.id,2223 item_id,2224 sender,2225 new_owner,2226 1,2227 ));22282229 Ok(())2230 }22312232 fn set_re_fungible_variable_data(2233 collection: &CollectionHandle<T>,2234 item_id: TokenId,2235 data: Vec<u8>,2236 ) -> DispatchResult {2237 let collection_id = collection.id;2238 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2239 .ok_or(Error::<T>::TokenNotFound)?;22402241 item.variable_data = data;22422243 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22442245 Ok(())2246 }22472248 fn set_nft_variable_data(2249 collection: &CollectionHandle<T>,2250 item_id: TokenId,2251 data: Vec<u8>,2252 ) -> DispatchResult {2253 let collection_id = collection.id;2254 let mut item =2255 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22562257 item.variable_data = data;22582259 <NftItemList<T>>::insert(collection_id, item_id, item);22602261 Ok(())2262 }22632264 #[allow(dead_code)]2265 fn init_collection(item: &Collection<T>) {2266 // check params2267 assert!(2268 item.decimal_points <= MAX_DECIMAL_POINTS,2269 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2270 );2271 assert!(2272 item.name.len() <= 64,2273 "Collection name can not be longer than 63 char"2274 );2275 assert!(2276 item.name.len() <= 256,2277 "Collection description can not be longer than 255 char"2278 );2279 assert!(2280 item.token_prefix.len() <= 16,2281 "Token prefix can not be longer than 15 char"2282 );22832284 // Generate next collection ID2285 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22862287 CreatedCollectionCount::put(next_id);2288 }22892290 #[allow(dead_code)]2291 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2292 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22932294 Self::add_token_index(2295 &CollectionHandle::get(collection_id).unwrap(),2296 current_index,2297 &item.owner,2298 )2299 .unwrap();23002301 <ItemListIndex>::insert(collection_id, current_index);23022303 // Update balance2304 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2305 .checked_add(1)2306 .unwrap();2307 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2308 }23092310 #[allow(dead_code)]2311 fn init_fungible_token(2312 collection_id: CollectionId,2313 owner: &T::CrossAccountId,2314 item: &FungibleItemType,2315 ) {2316 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23172318 Self::add_token_index(2319 &CollectionHandle::get(collection_id).unwrap(),2320 current_index,2321 owner,2322 )2323 .unwrap();23242325 <ItemListIndex>::insert(collection_id, current_index);23262327 // Update balance2328 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2329 .checked_add(item.value)2330 .unwrap();2331 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2332 }23332334 #[allow(dead_code)]2335 fn init_refungible_token(2336 collection_id: CollectionId,2337 item: &ReFungibleItemType<T::CrossAccountId>,2338 ) {2339 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23402341 let value = item.owner.first().unwrap().fraction;2342 let owner = item.owner.first().unwrap().owner.clone();23432344 Self::add_token_index(2345 &CollectionHandle::get(collection_id).unwrap(),2346 current_index,2347 &owner,2348 )2349 .unwrap();23502351 <ItemListIndex>::insert(collection_id, current_index);23522353 // Update balance2354 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2355 .checked_add(value)2356 .unwrap();2357 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2358 }23592360 fn add_token_index(2361 collection: &CollectionHandle<T>,2362 item_index: TokenId,2363 owner: &T::CrossAccountId,2364 ) -> DispatchResult {2365 // add to account limit2366 collection.consume_sload()?;2367 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2368 // bound Owned tokens by a single address2369 collection.consume_sload()?;2370 let count = <AccountItemCount<T>>::get(owner.as_sub());2371 ensure!(2372 count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2373 Error::<T>::AddressOwnershipLimitExceeded2374 );23752376 collection.consume_sstore()?;2377 <AccountItemCount<T>>::insert(2378 owner.as_sub(),2379 count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2380 );2381 } else {2382 collection.consume_sstore()?;2383 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2384 }23852386 collection.consume_sload()?;2387 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2388 if list_exists {2389 collection.consume_sload()?;2390 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2391 let item_contains = list.contains(&item_index.clone());23922393 if !item_contains {2394 list.push(item_index);2395 }23962397 collection.consume_sstore()?;2398 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2399 } else {2400 let itm = vec![item_index];2401 collection.consume_sstore()?;2402 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2403 }24042405 Ok(())2406 }24072408 fn remove_token_index(2409 collection: &CollectionHandle<T>,2410 item_index: TokenId,2411 owner: &T::CrossAccountId,2412 ) -> DispatchResult {2413 // update counter2414 collection.consume_sload()?;2415 collection.consume_sstore()?;2416 <AccountItemCount<T>>::insert(2417 owner.as_sub(),2418 <AccountItemCount<T>>::get(owner.as_sub())2419 .checked_sub(1)2420 .ok_or(Error::<T>::NumOverflow)?,2421 );24222423 collection.consume_sload()?;2424 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2425 if list_exists {2426 collection.consume_sload()?;2427 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2428 let item_contains = list.contains(&item_index.clone());24292430 if item_contains {2431 list.retain(|&item| item != item_index);2432 collection.consume_sstore()?;2433 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2434 }2435 }24362437 Ok(())2438 }24392440 fn move_token_index(2441 collection: &CollectionHandle<T>,2442 item_index: TokenId,2443 old_owner: &T::CrossAccountId,2444 new_owner: &T::CrossAccountId,2445 ) -> DispatchResult {2446 Self::remove_token_index(collection, item_index, old_owner)?;2447 Self::add_token_index(collection, item_index, new_owner)?;24482449 Ok(())2450 }2451}24522453sp_api::decl_runtime_apis! {2454 pub trait NftApi {2455 /// Used for ethereum integration2456 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2457 }2458}tests/src/eth/api/ContractHelpers.soldiffbeforeafterboth--- a/tests/src/eth/api/ContractHelpers.sol
+++ b/tests/src/eth/api/ContractHelpers.sol
@@ -9,33 +9,41 @@
}
interface ContractHelpers is Dummy {
+ // Selector: contractOwner(address) 5152b14c
function contractOwner(address contractAddress)
external
view
returns (address);
+ // Selector: sponsoringEnabled(address) 6027dc61
function sponsoringEnabled(address contractAddress)
external
view
returns (bool);
+ // Selector: toggleSponsoring(address,bool) fcac6d86
function toggleSponsoring(address contractAddress, bool enabled) external;
+ // Selector: setSponsoringRateLimit(address,uint32) 77b6c908
function setSponsoringRateLimit(address contractAddress, uint32 rateLimit)
external;
+ // Selector: allowed(address,address) 5c658165
function allowed(address contractAddress, address user)
external
view
returns (bool);
+ // Selector: allowlistEnabled(address) c772ef6c
function allowlistEnabled(address contractAddress)
external
view
returns (bool);
+ // Selector: toggleAllowlist(address,bool) 36de20f5
function toggleAllowlist(address contractAddress, bool enabled) external;
+ // Selector: toggleAllowed(address,address,bool) 4706cc1c
function toggleAllowed(
address contractAddress,
address user,
tests/src/eth/api/UniqueFungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -20,35 +20,45 @@
// Inline
interface InlineNameSymbol is Dummy {
+ // Selector: name() 06fdde03
function name() external view returns (string memory);
+ // Selector: symbol() 95d89b41
function symbol() external view returns (string memory);
}
// Inline
interface InlineTotalSupply is Dummy {
+ // Selector: totalSupply() 18160ddd
function totalSupply() external view returns (uint256);
}
interface ERC165 is Dummy {
+ // Selector: supportsInterface(bytes4) 01ffc9a7
function supportsInterface(uint32 interfaceId) external view returns (bool);
}
interface ERC20 is Dummy, InlineNameSymbol, InlineTotalSupply, ERC20Events {
+ // Selector: decimals() 313ce567
function decimals() external view returns (uint8);
+ // Selector: balanceOf(address) 70a08231
function balanceOf(address owner) external view returns (uint256);
+ // Selector: transfer(address,uint256) a9059cbb
function transfer(address to, uint256 amount) external returns (bool);
+ // Selector: transferFrom(address,address,uint256) 23b872dd
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
+ // Selector: approve(address,uint256) 095ea7b3
function approve(address spender, uint256 amount) external returns (bool);
+ // Selector: allowance(address,address) dd62ed3e
function allowance(address owner, address spender)
external
view
tests/src/eth/api/UniqueNFT.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -3,6 +3,12 @@
pragma solidity >=0.8.0 <0.9.0;
+// Anonymous struct
+struct Tuple0 {
+ uint256 field_0;
+ string field_1;
+}
+
// Common stubs holder
interface Dummy {
@@ -34,25 +40,32 @@
// Inline
interface InlineNameSymbol is Dummy {
+ // Selector: name() 06fdde03
function name() external view returns (string memory);
+ // Selector: symbol() 95d89b41
function symbol() external view returns (string memory);
}
// Inline
interface InlineTotalSupply is Dummy {
+ // Selector: totalSupply() 18160ddd
function totalSupply() external view returns (uint256);
}
interface ERC165 is Dummy {
+ // Selector: supportsInterface(bytes4) 01ffc9a7
function supportsInterface(uint32 interfaceId) external view returns (bool);
}
interface ERC721 is Dummy, ERC165, ERC721Events {
+ // Selector: balanceOf(address) 70a08231
function balanceOf(address owner) external view returns (uint256);
+ // Selector: ownerOf(uint256) 6352211e
function ownerOf(uint256 tokenId) external view returns (address);
+ // Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
function safeTransferFromWithData(
address from,
address to,
@@ -60,24 +73,30 @@
bytes memory data
) external;
+ // Selector: safeTransferFrom(address,address,uint256) 42842e0e
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
+ // Selector: transferFrom(address,address,uint256) 23b872dd
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
+ // Selector: approve(address,uint256) 095ea7b3
function approve(address approved, uint256 tokenId) external;
+ // Selector: setApprovalForAll(address,bool) a22cb465
function setApprovalForAll(address operator, bool approved) external;
+ // Selector: getApproved(uint256) 081812fc
function getApproved(uint256 tokenId) external view returns (address);
+ // Selector: isApprovedForAll(address,address) e985e9c5
function isApprovedForAll(address owner, address operator)
external
view
@@ -85,12 +104,15 @@
}
interface ERC721Burnable is Dummy {
+ // Selector: burn(uint256) 42966c68
function burn(uint256 tokenId) external;
}
interface ERC721Enumerable is Dummy, InlineTotalSupply {
+ // Selector: tokenByIndex(uint256) 4f6ccce7
function tokenByIndex(uint256 index) external view returns (uint256);
+ // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
@@ -98,27 +120,53 @@
}
interface ERC721Metadata is Dummy, InlineNameSymbol {
+ // Selector: tokenURI(uint256) c87b56dd
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface ERC721Mintable is Dummy, ERC721MintableEvents {
+ // Selector: mintingFinished() 05d2035b
function mintingFinished() external view returns (bool);
+ // Selector: mint(address,uint256) 40c10f19
function mint(address to, uint256 tokenId) external returns (bool);
+ // Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
function mintWithTokenURI(
address to,
uint256 tokenId,
string memory tokenUri
) external returns (bool);
+ // Selector: finishMinting() 7d64bcb4
function finishMinting() external returns (bool);
}
interface ERC721UniqueExtensions is Dummy {
+ // Selector: transfer(address,uint256) a9059cbb
function transfer(address to, uint256 tokenId) external;
+ // Selector: nextTokenId() 75794a3c
function nextTokenId() external view returns (uint256);
+
+ // Selector: setVariableMetadata(uint256,bytes) d4eac26d
+ function setVariableMetadata(uint256 tokenId, bytes memory data) external;
+
+ // Selector: getVariableMetadata(uint256) e6c5ce6f
+ function getVariableMetadata(uint256 tokenId)
+ external
+ view
+ returns (bytes memory);
+
+ // Selector: mintBulk(address,uint256[]) 44a9945e
+ function mintBulk(address to, uint256[] memory tokenIds)
+ external
+ returns (bool);
+
+ // Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
+ function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
+ external
+ returns (bool);
}
interface UniqueNFT is
tests/src/eth/nonFungible.test.tsdiffbeforeafterboth--- a/tests/src/eth/nonFungible.test.ts
+++ b/tests/src/eth/nonFungible.test.ts
@@ -4,9 +4,8 @@
//
import privateKey from '../substrate/privateKey';
-import { approveExpectSuccess, burnItemExpectSuccess, createCollectionExpectSuccess, createItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess, UNIQUE } from '../util/helpers';
+import { approveExpectSuccess, burnItemExpectSuccess, createCollectionExpectSuccess, createItemExpectSuccess, setVariableMetaDataExpectSuccess, transferExpectSuccess, transferFromExpectSuccess, UNIQUE } from '../util/helpers';
import { collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, transferBalanceToEth } from './util/helpers';
-import { evmToAddress } from '@polkadot/util-crypto';
import nonFungibleAbi from './nonFungibleAbi.json';
import { expect } from 'chai';
import waitNewBlocks from '../substrate/wait-new-blocks';
@@ -106,7 +105,70 @@
expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
}
});
+ itWeb3('Can perform mintBulk()', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'NFT' },
+ });
+ const alice = privateKey('//Alice');
+
+ const caller = await createEthAccountWithBalance(api, web3);
+ const changeAdminTx = api.tx.nft.addCollectionAdmin(collection, { ethereum: caller });
+ await submitTransactionAsync(alice, changeAdminTx);
+ const receiver = createEthAccount(web3);
+ const address = collectionIdToAddress(collection);
+ const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, ...GAS_ARGS});
+
+ {
+ const nextTokenId = await contract.methods.nextTokenId().call();
+ expect(nextTokenId).to.be.equal('1');
+ const result = await contract.methods.mintBulkWithTokenURI(
+ receiver,
+ [
+ [nextTokenId, 'Test URI 0'],
+ [+nextTokenId + 1, 'Test URI 1'],
+ [+nextTokenId + 2, 'Test URI 2'],
+ ],
+ ).send({ from: caller });
+ const events = normalizeEvents(result.events);
+
+ expect(events).to.be.deep.equal([
+ {
+ address,
+ event: 'Transfer',
+ args: {
+ from: '0x0000000000000000000000000000000000000000',
+ to: receiver,
+ tokenId: nextTokenId,
+ },
+ },
+ {
+ address,
+ event: 'Transfer',
+ args: {
+ from: '0x0000000000000000000000000000000000000000',
+ to: receiver,
+ tokenId: String(+nextTokenId + 1),
+ },
+ },
+ {
+ address,
+ event: 'Transfer',
+ args: {
+ from: '0x0000000000000000000000000000000000000000',
+ to: receiver,
+ tokenId: String(+nextTokenId + 2),
+ },
+ },
+ ]);
+
+ await waitNewBlocks(api, 1);
+ expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI 0');
+ expect(await contract.methods.tokenURI(+nextTokenId + 1).call()).to.be.equal('Test URI 1');
+ expect(await contract.methods.tokenURI(+nextTokenId + 2).call()).to.be.equal('Test URI 2');
+ }
+ });
+
itWeb3('Can perform burn()', async ({ web3, api }) => {
const collection = await createCollectionExpectSuccess({
mode: {type: 'NFT'},
@@ -264,6 +326,41 @@
expect(+balance).to.equal(1);
}
});
+
+ itWeb3('Can perform getVariableMetadata', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'NFT' },
+ });
+ const alice = privateKey('//Alice');
+
+ const owner = await createEthAccountWithBalance(api, web3);
+
+ const item = await createItemExpectSuccess(alice, collection, 'NFT', { ethereum: owner });
+ await setVariableMetaDataExpectSuccess(alice, collection, item, [1, 2, 3]);
+
+ const address = collectionIdToAddress(collection);
+ const contract = new web3.eth.Contract(nonFungibleAbi as any, address, { from: owner, ...GAS_ARGS });
+
+ expect(await contract.methods.getVariableMetadata(item).call()).to.be.equal('0x010203');
+ });
+
+ itWeb3('Can perform setVariableMetadata', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'NFT' },
+ });
+ const alice = privateKey('//Alice');
+
+ const owner = await createEthAccountWithBalance(api, web3);
+
+ const item = await createItemExpectSuccess(alice, collection, 'NFT', { ethereum: owner });
+
+ const address = collectionIdToAddress(collection);
+ const contract = new web3.eth.Contract(nonFungibleAbi as any, address, { from: owner, ...GAS_ARGS });
+
+ expect(await contract.methods.setVariableMetadata(item, '0x010203').send({ from: owner }));
+ await waitNewBlocks(api, 1);
+ expect(await contract.methods.getVariableMetadata(item).call()).to.be.equal('0x010203');
+ });
});
describe('NFT: Fees', () => {
tests/src/eth/nonFungibleAbi.jsondiffbeforeafterboth--- a/tests/src/eth/nonFungibleAbi.json
+++ b/tests/src/eth/nonFungibleAbi.json
@@ -50,7 +50,7 @@
"type": "event"
},
{
- "anonymous": true,
+ "anonymous": false,
"inputs": [],
"name": "MintingFinished",
"type": "event"
@@ -165,6 +165,25 @@
{
"inputs": [
{
+ "internalType": "uint256",
+ "name": "tokenId",
+ "type": "uint256"
+ }
+ ],
+ "name": "getVariableMetadata",
+ "outputs": [
+ {
+ "internalType": "bytes",
+ "name": "",
+ "type": "bytes"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
"internalType": "address",
"name": "owner",
"type": "address"
@@ -218,13 +237,73 @@
"type": "address"
},
{
+ "internalType": "uint256[]",
+ "name": "tokenIds",
+ "type": "uint256[]"
+ }
+ ],
+ "name": "mintBulk",
+ "outputs": [
+ {
+ "internalType": "bool",
+ "name": "",
+ "type": "bool"
+ }
+ ],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "address",
+ "name": "to",
+ "type": "address"
+ },
+ {
+ "components": [
+ {
+ "internalType": "uint256",
+ "name": "field_0",
+ "type": "uint256"
+ },
+ {
+ "internalType": "string",
+ "name": "field_1",
+ "type": "string"
+ }
+ ],
+ "internalType": "struct Tuple0[]",
+ "name": "tokens",
+ "type": "tuple[]"
+ }
+ ],
+ "name": "mintBulkWithTokenURI",
+ "outputs": [
+ {
+ "internalType": "bool",
+ "name": "",
+ "type": "bool"
+ }
+ ],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "address",
+ "name": "to",
+ "type": "address"
+ },
+ {
"internalType": "uint256",
"name": "tokenId",
"type": "uint256"
},
{
"internalType": "string",
- "name": "tokenURI",
+ "name": "tokenUri",
"type": "string"
}
],
@@ -369,6 +448,24 @@
{
"inputs": [
{
+ "internalType": "uint256",
+ "name": "tokenId",
+ "type": "uint256"
+ },
+ {
+ "internalType": "bytes",
+ "name": "data",
+ "type": "bytes"
+ }
+ ],
+ "name": "setVariableMetadata",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
"internalType": "uint32",
"name": "interfaceId",
"type": "uint32"
@@ -514,4 +611,4 @@
"stateMutability": "nonpayable",
"type": "function"
}
-]
\ No newline at end of file
+]
tests/src/eth/proxy/UniqueNFTProxy.abidiffbeforeafterboth--- a/tests/src/eth/proxy/UniqueNFTProxy.abi
+++ b/tests/src/eth/proxy/UniqueNFTProxy.abi
@@ -1 +1 @@
-[{"inputs":[{"internalType":"address","name":"_proxied","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[],"name":"MintingFinished","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"approved","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finishMinting","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"tokenUri","type":"string"}],"name":"mintWithTokenURI","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintingFinished","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFromWithData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"interfaceId","type":"uint32"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}]
\ No newline at end of file
+[{"inputs":[{"internalType":"address","name":"_proxied","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[],"name":"MintingFinished","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"approved","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finishMinting","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getVariableMetadata","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"mintBulk","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"components":[{"internalType":"uint256","name":"field_0","type":"uint256"},{"internalType":"string","name":"field_1","type":"string"}],"internalType":"struct Tuple0[]","name":"tokens","type":"tuple[]"}],"name":"mintBulkWithTokenURI","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"tokenUri","type":"string"}],"name":"mintWithTokenURI","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintingFinished","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFromWithData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"setVariableMetadata","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"interfaceId","type":"uint32"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}]
\ No newline at end of file
tests/src/eth/proxy/UniqueNFTProxy.bindiffbeforeafterboth--- a/tests/src/eth/proxy/UniqueNFTProxy.bin
+++ b/tests/src/eth/proxy/UniqueNFTProxy.bin
@@ -1 +1 @@
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
\ No newline at end of file
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
\ No newline at end of file
tests/src/eth/proxy/UniqueNFTProxy.soldiffbeforeafterboth--- a/tests/src/eth/proxy/UniqueNFTProxy.sol
+++ b/tests/src/eth/proxy/UniqueNFTProxy.sol
@@ -156,4 +156,36 @@
{
return proxied.supportsInterface(interfaceId);
}
+
+ function setVariableMetadata(uint256 tokenId, bytes memory data)
+ external
+ override
+ {
+ return proxied.setVariableMetadata(tokenId, data);
+ }
+
+ function getVariableMetadata(uint256 tokenId)
+ external
+ view
+ override
+ returns (bytes memory)
+ {
+ return proxied.getVariableMetadata(tokenId);
+ }
+
+ function mintBulk(address to, uint256[] memory tokenIds)
+ external
+ override
+ returns (bool)
+ {
+ return proxied.mintBulk(to, tokenIds);
+ }
+
+ function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
+ external
+ override
+ returns (bool)
+ {
+ return proxied.mintBulkWithTokenURI(to, tokens);
+ }
}
tests/src/eth/proxy/nonFungibleProxy.test.tsdiffbeforeafterboth--- a/tests/src/eth/proxy/nonFungibleProxy.test.ts
+++ b/tests/src/eth/proxy/nonFungibleProxy.test.ts
@@ -4,7 +4,7 @@
//
import privateKey from '../../substrate/privateKey';
-import { createCollectionExpectSuccess, createItemExpectSuccess } from '../../util/helpers';
+import { createCollectionExpectSuccess, createItemExpectSuccess, setVariableMetaDataExpectSuccess } from '../../util/helpers';
import { collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, itWeb3, normalizeEvents } from '../util/helpers';
import nonFungibleAbi from '../nonFungibleAbi.json';
import { expect } from 'chai';
@@ -96,13 +96,11 @@
{
const nextTokenId = await contract.methods.nextTokenId().call();
expect(nextTokenId).to.be.equal('1');
- console.log('Before mint');
const result = await contract.methods.mintWithTokenURI(
receiver,
nextTokenId,
'Test URI',
).send({ from: caller });
- console.log('After mint');
const events = normalizeEvents(result.events);
expect(events).to.be.deep.equal([
@@ -121,6 +119,69 @@
expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
}
});
+ itWeb3('Can perform mintBulk()', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'NFT' },
+ });
+ const alice = privateKey('//Alice');
+
+ const caller = await createEthAccountWithBalance(api, web3);
+ const receiver = createEthAccount(web3);
+
+ const address = collectionIdToAddress(collection);
+ const contract = await proxyWrap(api, web3, new web3.eth.Contract(nonFungibleAbi as any, address, { from: caller, ...GAS_ARGS }));
+ const changeAdminTx = api.tx.nft.addCollectionAdmin(collection, { ethereum: contract.options.address });
+ await submitTransactionAsync(alice, changeAdminTx);
+
+ {
+ const nextTokenId = await contract.methods.nextTokenId().call();
+ expect(nextTokenId).to.be.equal('1');
+ const result = await contract.methods.mintBulkWithTokenURI(
+ receiver,
+ [
+ [nextTokenId, 'Test URI 0'],
+ [+nextTokenId + 1, 'Test URI 1'],
+ [+nextTokenId + 2, 'Test URI 2'],
+ ],
+ ).send({ from: caller });
+ const events = normalizeEvents(result.events);
+
+ expect(events).to.be.deep.equal([
+ {
+ address,
+ event: 'Transfer',
+ args: {
+ from: '0x0000000000000000000000000000000000000000',
+ to: receiver,
+ tokenId: nextTokenId,
+ },
+ },
+ {
+ address,
+ event: 'Transfer',
+ args: {
+ from: '0x0000000000000000000000000000000000000000',
+ to: receiver,
+ tokenId: String(+nextTokenId + 1),
+ },
+ },
+ {
+ address,
+ event: 'Transfer',
+ args: {
+ from: '0x0000000000000000000000000000000000000000',
+ to: receiver,
+ tokenId: String(+nextTokenId + 2),
+ },
+ },
+ ]);
+
+ await waitNewBlocks(api, 1);
+ expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI 0');
+ expect(await contract.methods.tokenURI(+nextTokenId + 1).call()).to.be.equal('Test URI 1');
+ expect(await contract.methods.tokenURI(+nextTokenId + 2).call()).to.be.equal('Test URI 2');
+ }
+ });
itWeb3('Can perform burn()', async ({ web3, api }) => {
const collection = await createCollectionExpectSuccess({
@@ -267,4 +328,35 @@
expect(+balance).to.equal(1);
}
});
+
+ itWeb3('Can perform getVariableMetadata', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'NFT' },
+ });
+ const alice = privateKey('//Alice');
+ const caller = await createEthAccountWithBalance(api, web3);
+
+ const address = collectionIdToAddress(collection);
+ const contract = await proxyWrap(api, web3, new web3.eth.Contract(nonFungibleAbi as any, address, { from: caller, ...GAS_ARGS }));
+ const item = await createItemExpectSuccess(alice, collection, 'NFT', { ethereum: contract.options.address });
+ await setVariableMetaDataExpectSuccess(alice, collection, item, [1, 2, 3]);
+
+ expect(await contract.methods.getVariableMetadata(item).call()).to.be.equal('0x010203');
+ });
+
+ itWeb3('Can perform setVariableMetadata', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'NFT' },
+ });
+ const alice = privateKey('//Alice');
+ const caller = await createEthAccountWithBalance(api, web3);
+
+ const address = collectionIdToAddress(collection);
+ const contract = await proxyWrap(api, web3, new web3.eth.Contract(nonFungibleAbi as any, address, { from: caller, ...GAS_ARGS }));
+ const item = await createItemExpectSuccess(alice, collection, 'NFT', { ethereum: contract.options.address });
+
+ expect(await contract.methods.setVariableMetadata(item, '0x010203').send({ from: caller }));
+ await waitNewBlocks(api, 1);
+ expect(await contract.methods.getVariableMetadata(item).call()).to.be.equal('0x010203');
+ });
});
tests/src/eth/util/helpers.tsdiffbeforeafterboth--- a/tests/src/eth/util/helpers.ts
+++ b/tests/src/eth/util/helpers.ts
@@ -269,4 +269,4 @@
expect(after < before).to.be.true;
return before - after;
-}
\ No newline at end of file
+}
tests/src/transfer.test.tsdiffbeforeafterboth--- a/tests/src/transfer.test.ts
+++ b/tests/src/transfer.test.ts
@@ -60,7 +60,7 @@
// tslint:disable-next-line:no-unused-expression
expect(result.success).to.be.false;
};
- expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees , e.g. account balance too low');
+ await expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees , e.g. account balance too low');
});
});