difftreelog
Merge pull request #193 from UniqueNetwork/feature/erc-bulk-mint-metadata
in: master
Implement bulkMint/getVariableMetadata/setVariableMetadata for EVM
21 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 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 create_multiple_items_internal(1508 sender: &T::CrossAccountId,1509 collection: &CollectionHandle<T>,1510 owner: &T::CrossAccountId,1511 items_data: Vec<CreateItemData>,1512 ) -> DispatchResult {1513 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15141515 for data in &items_data {1516 Self::validate_create_item_args(collection, data)?;1517 }1518 for data in &items_data {1519 Self::create_item_no_validation(collection, owner, data.clone())?;1520 }15211522 Ok(())1523 }15241525 pub fn burn_item_internal(1526 sender: &T::CrossAccountId,1527 collection: &CollectionHandle<T>,1528 item_id: TokenId,1529 value: u128,1530 ) -> DispatchResult {1531 ensure!(1532 Self::is_item_owner(sender, collection, item_id)?1533 || (collection.limits.owner_can_transfer1534 && Self::is_owner_or_admin_permissions(collection, sender)?),1535 Error::<T>::NoPermission1536 );15371538 if collection.access == AccessMode::WhiteList {1539 Self::check_white_list(collection, sender)?;1540 }15411542 match collection.mode {1543 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1544 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1545 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1546 _ => (),1547 };15481549 Ok(())1550 }15511552 pub fn toggle_white_list_internal(1553 sender: &T::CrossAccountId,1554 collection: &CollectionHandle<T>,1555 address: &T::CrossAccountId,1556 whitelisted: bool,1557 ) -> DispatchResult {1558 Self::check_owner_or_admin_permissions(collection, sender)?;15591560 if whitelisted {1561 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1562 } else {1563 <WhiteList<T>>::remove(collection.id, address.as_sub());1564 }15651566 Ok(())1567 }15681569 fn is_correct_transfer(1570 collection: &CollectionHandle<T>,1571 recipient: &T::CrossAccountId,1572 ) -> DispatchResult {1573 let collection_id = collection.id;15741575 // check token limit and account token limit1576 collection.consume_sload()?;1577 let account_items: u32 =1578 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1579 ensure!(1580 collection.limits.account_token_ownership_limit > account_items,1581 Error::<T>::AccountTokenLimitExceeded1582 );15831584 // preliminary transfer check1585 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);15861587 Ok(())1588 }15891590 fn can_create_items_in_collection(1591 collection: &CollectionHandle<T>,1592 sender: &T::CrossAccountId,1593 owner: &T::CrossAccountId,1594 amount: u32,1595 ) -> DispatchResult {1596 let collection_id = collection.id;15971598 // check token limit and account token limit1599 let total_items: u32 = ItemListIndex::get(collection_id)1600 .checked_add(amount)1601 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1602 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1603 as u32)1604 .checked_add(amount)1605 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1606 ensure!(1607 collection.limits.token_limit >= total_items,1608 Error::<T>::CollectionTokenLimitExceeded1609 );1610 ensure!(1611 collection.limits.account_token_ownership_limit >= account_items,1612 Error::<T>::AccountTokenLimitExceeded1613 );16141615 if !Self::is_owner_or_admin_permissions(collection, sender)? {1616 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1617 Self::check_white_list(collection, owner)?;1618 Self::check_white_list(collection, sender)?;1619 }16201621 Ok(())1622 }16231624 fn validate_create_item_args(1625 target_collection: &CollectionHandle<T>,1626 data: &CreateItemData,1627 ) -> DispatchResult {1628 match target_collection.mode {1629 CollectionMode::NFT => {1630 if !matches!(data, CreateItemData::NFT(_)) {1631 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1632 }1633 }1634 CollectionMode::Fungible(_) => {1635 if !matches!(data, CreateItemData::Fungible(_)) {1636 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1637 }1638 }1639 CollectionMode::ReFungible => {1640 if let CreateItemData::ReFungible(data) = data {1641 // Check refungibility limits1642 ensure!(1643 data.pieces <= MAX_REFUNGIBLE_PIECES,1644 Error::<T>::WrongRefungiblePieces1645 );1646 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1647 } else {1648 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1649 }1650 }1651 _ => {1652 fail!(Error::<T>::UnexpectedCollectionType);1653 }1654 };16551656 Ok(())1657 }16581659 fn create_item_no_validation(1660 collection: &CollectionHandle<T>,1661 owner: &T::CrossAccountId,1662 data: CreateItemData,1663 ) -> DispatchResult {1664 match data {1665 CreateItemData::NFT(data) => {1666 let item = NftItemType {1667 owner: owner.clone(),1668 const_data: data.const_data.into_inner(),1669 variable_data: data.variable_data.into_inner(),1670 };16711672 Self::add_nft_item(collection, item)?;1673 }1674 CreateItemData::Fungible(data) => {1675 Self::add_fungible_item(collection, owner, data.value)?;1676 }1677 CreateItemData::ReFungible(data) => {1678 let owner_list = vec![Ownership {1679 owner: owner.clone(),1680 fraction: data.pieces,1681 }];16821683 let item = ReFungibleItemType {1684 owner: owner_list,1685 const_data: data.const_data.into_inner(),1686 variable_data: data.variable_data.into_inner(),1687 };16881689 Self::add_refungible_item(collection, item)?;1690 }1691 };16921693 Ok(())1694 }16951696 fn add_fungible_item(1697 collection: &CollectionHandle<T>,1698 owner: &T::CrossAccountId,1699 value: u128,1700 ) -> DispatchResult {1701 let collection_id = collection.id;17021703 // Does new owner already have an account?1704 collection.consume_sload()?;1705 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17061707 // Mint1708 let item = FungibleItemType {1709 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1710 };1711 collection.consume_sstore()?;1712 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17131714 // Update balance1715 collection.consume_sload()?;1716 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1717 .checked_add(value)1718 .ok_or(Error::<T>::NumOverflow)?;1719 collection.consume_sstore()?;1720 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17211722 collection.log(ERC20Events::Transfer {1723 from: H160::default(),1724 to: *owner.as_eth(),1725 value: value.into(),1726 })?;1727 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1728 Ok(())1729 }17301731 fn add_refungible_item(1732 collection: &CollectionHandle<T>,1733 item: ReFungibleItemType<T::CrossAccountId>,1734 ) -> DispatchResult {1735 let collection_id = collection.id;17361737 let current_index = <ItemListIndex>::get(collection_id)1738 .checked_add(1)1739 .ok_or(Error::<T>::NumOverflow)?;1740 let itemcopy = item.clone();17411742 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1743 let item_owner = item.owner.first().expect("only one owner is defined");17441745 let value = item_owner.fraction;1746 let owner = item_owner.owner.clone();17471748 Self::add_token_index(collection, current_index, &owner)?;17491750 <ItemListIndex>::insert(collection_id, current_index);1751 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17521753 // Update balance1754 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1755 .checked_add(value)1756 .ok_or(Error::<T>::NumOverflow)?;1757 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17581759 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1760 Ok(())1761 }17621763 fn add_nft_item(1764 collection: &CollectionHandle<T>,1765 item: NftItemType<T::CrossAccountId>,1766 ) -> DispatchResult {1767 let collection_id = collection.id;17681769 let current_index = <ItemListIndex>::get(collection_id)1770 .checked_add(1)1771 .ok_or(Error::<T>::NumOverflow)?;17721773 let item_owner = item.owner.clone();1774 Self::add_token_index(collection, current_index, &item.owner)?;17751776 <ItemListIndex>::insert(collection_id, current_index);1777 <NftItemList<T>>::insert(collection_id, current_index, item);17781779 // Update balance1780 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1781 .checked_add(1)1782 .ok_or(Error::<T>::NumOverflow)?;1783 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17841785 collection.log(ERC721Events::Transfer {1786 from: H160::default(),1787 to: *item_owner.as_eth(),1788 token_id: current_index.into(),1789 })?;1790 Self::deposit_event(RawEvent::ItemCreated(1791 collection_id,1792 current_index,1793 item_owner,1794 ));1795 Ok(())1796 }17971798 fn burn_refungible_item(1799 collection: &CollectionHandle<T>,1800 item_id: TokenId,1801 owner: &T::CrossAccountId,1802 ) -> DispatchResult {1803 let collection_id = collection.id;18041805 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1806 .ok_or(Error::<T>::TokenNotFound)?;1807 let rft_balance = token1808 .owner1809 .iter()1810 .find(|&i| i.owner == *owner)1811 .ok_or(Error::<T>::TokenNotFound)?;1812 Self::remove_token_index(collection, item_id, owner)?;18131814 // update balance1815 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1816 .checked_sub(rft_balance.fraction)1817 .ok_or(Error::<T>::NumOverflow)?;1818 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18191820 // Re-create owners list with sender removed1821 let index = token1822 .owner1823 .iter()1824 .position(|i| i.owner == *owner)1825 .expect("owned item is exists");1826 token.owner.remove(index);1827 let owner_count = token.owner.len();18281829 // Burn the token completely if this was the last (only) owner1830 if owner_count == 0 {1831 <ReFungibleItemList<T>>::remove(collection_id, item_id);1832 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1833 } else {1834 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1835 }18361837 Ok(())1838 }18391840 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1841 let collection_id = collection.id;18421843 let item =1844 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1845 Self::remove_token_index(collection, item_id, &item.owner)?;18461847 // update balance1848 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1849 .checked_sub(1)1850 .ok_or(Error::<T>::NumOverflow)?;1851 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1852 <NftItemList<T>>::remove(collection_id, item_id);1853 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18541855 collection.log(ERC721Events::Transfer {1856 from: *item.owner.as_eth(),1857 to: H160::default(),1858 token_id: item_id.into(),1859 })?;1860 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1861 Ok(())1862 }18631864 fn burn_fungible_item(1865 owner: &T::CrossAccountId,1866 collection: &CollectionHandle<T>,1867 value: u128,1868 ) -> DispatchResult {1869 let collection_id = collection.id;18701871 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1872 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18731874 // update balance1875 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1876 .checked_sub(value)1877 .ok_or(Error::<T>::NumOverflow)?;1878 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18791880 if balance.value - value > 0 {1881 balance.value -= value;1882 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1883 } else {1884 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1885 }18861887 collection.log(ERC20Events::Transfer {1888 from: *owner.as_eth(),1889 to: H160::default(),1890 value: value.into(),1891 })?;1892 Ok(())1893 }18941895 pub fn get_collection(1896 collection_id: CollectionId,1897 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1898 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1899 }19001901 fn check_owner_permissions(1902 target_collection: &CollectionHandle<T>,1903 subject: &T::AccountId,1904 ) -> DispatchResult {1905 ensure!(1906 *subject == target_collection.owner,1907 Error::<T>::NoPermission1908 );19091910 Ok(())1911 }19121913 fn is_owner_or_admin_permissions(1914 collection: &CollectionHandle<T>,1915 subject: &T::CrossAccountId,1916 ) -> Result<bool, DispatchError> {1917 collection.consume_sload()?;1918 Ok(*subject.as_sub() == collection.owner1919 || <AdminList<T>>::get(collection.id).contains(subject))1920 }19211922 fn check_owner_or_admin_permissions(1923 collection: &CollectionHandle<T>,1924 subject: &T::CrossAccountId,1925 ) -> DispatchResult {1926 ensure!(1927 Self::is_owner_or_admin_permissions(collection, subject)?,1928 Error::<T>::NoPermission1929 );19301931 Ok(())1932 }19331934 fn owned_amount(1935 subject: &T::CrossAccountId,1936 collection: &CollectionHandle<T>,1937 item_id: TokenId,1938 ) -> Result<Option<u128>, DispatchError> {1939 collection.consume_sload()?;1940 Ok(Self::owned_amount_unchecked(subject, collection, item_id))1941 }19421943 fn owned_amount_unchecked(1944 subject: &T::CrossAccountId,1945 target_collection: &CollectionHandle<T>,1946 item_id: TokenId,1947 ) -> Option<u128> {1948 let collection_id = target_collection.id;19491950 match target_collection.mode {1951 CollectionMode::NFT => {1952 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1953 }1954 CollectionMode::Fungible(_) => {1955 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1956 }1957 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1958 .owner1959 .iter()1960 .find(|i| i.owner == *subject)1961 .map(|i| i.fraction),1962 CollectionMode::Invalid => None,1963 }1964 }19651966 fn is_item_owner(1967 subject: &T::CrossAccountId,1968 target_collection: &CollectionHandle<T>,1969 item_id: TokenId,1970 ) -> Result<bool, DispatchError> {1971 Ok(match target_collection.mode {1972 CollectionMode::Fungible(_) => true,1973 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),1974 })1975 }19761977 fn check_white_list(1978 collection: &CollectionHandle<T>,1979 address: &T::CrossAccountId,1980 ) -> DispatchResult {1981 collection.consume_sload()?;1982 ensure!(1983 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),1984 Error::<T>::AddresNotInWhiteList,1985 );1986 Ok(())1987 }19881989 /// Check if token exists. In case of Fungible, check if there is an entry for1990 /// the owner in fungible balances double map1991 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1992 let collection_id = target_collection.id;1993 let exists = match target_collection.mode {1994 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1995 CollectionMode::Fungible(_) => true,1996 CollectionMode::ReFungible => {1997 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)1998 }1999 _ => false,2000 };20012002 ensure!(exists, Error::<T>::TokenNotFound);2003 Ok(())2004 }20052006 fn transfer_fungible(2007 collection: &CollectionHandle<T>,2008 value: u128,2009 owner: &T::CrossAccountId,2010 recipient: &T::CrossAccountId,2011 ) -> DispatchResult {2012 let collection_id = collection.id;20132014 collection.consume_sload()?;2015 collection.consume_sload()?;2016 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2017 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20182019 recipient_balance.value = recipient_balance2020 .value2021 .checked_add(value)2022 .ok_or(Error::<T>::NumOverflow)?;2023 balance.value = balance2024 .value2025 .checked_sub(value)2026 .ok_or(Error::<T>::TokenValueTooLow)?;20272028 // update balanceOf2029 collection.consume_sstore()?;2030 collection.consume_sstore()?;2031 if balance.value != 0 {2032 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2033 } else {2034 <Balance<T>>::remove(collection_id, owner.as_sub());2035 }2036 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20372038 // Reduce or remove sender2039 collection.consume_sstore()?;2040 collection.consume_sstore()?;2041 if balance.value != 0 {2042 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2043 } else {2044 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2045 }2046 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20472048 collection.log(ERC20Events::Transfer {2049 from: *owner.as_eth(),2050 to: *recipient.as_eth(),2051 value: value.into(),2052 })?;2053 Self::deposit_event(RawEvent::Transfer(2054 collection.id,2055 1,2056 owner.clone(),2057 recipient.clone(),2058 value,2059 ));20602061 Ok(())2062 }20632064 fn transfer_refungible(2065 collection: &CollectionHandle<T>,2066 item_id: TokenId,2067 value: u128,2068 owner: T::CrossAccountId,2069 new_owner: T::CrossAccountId,2070 ) -> DispatchResult {2071 let collection_id = collection.id;2072 collection.consume_sload()?;2073 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2074 .ok_or(Error::<T>::TokenNotFound)?;20752076 let item = full_item2077 .owner2078 .iter()2079 .find(|i| i.owner == owner)2080 .ok_or(Error::<T>::TokenNotFound)?;2081 let amount = item.fraction;20822083 ensure!(amount >= value, Error::<T>::TokenValueTooLow);20842085 collection.consume_sload()?;2086 // update balance2087 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2088 .checked_sub(value)2089 .ok_or(Error::<T>::NumOverflow)?;2090 collection.consume_sstore()?;2091 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20922093 collection.consume_sload()?;2094 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2095 .checked_add(value)2096 .ok_or(Error::<T>::NumOverflow)?;2097 collection.consume_sstore()?;2098 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20992100 let old_owner = item.owner.clone();2101 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21022103 let mut new_full_item = full_item.clone();2104 // transfer2105 if amount == value && !new_owner_has_account {2106 // change owner2107 // new owner do not have account2108 new_full_item2109 .owner2110 .iter_mut()2111 .find(|i| i.owner == owner)2112 .expect("old owner does present in refungible")2113 .owner = new_owner.clone();2114 collection.consume_sstore()?;2115 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21162117 // update index collection2118 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2119 } else {2120 new_full_item2121 .owner2122 .iter_mut()2123 .find(|i| i.owner == owner)2124 .expect("old owner does present in refungible")2125 .fraction -= value;21262127 // separate amount2128 if new_owner_has_account {2129 // new owner has account2130 new_full_item2131 .owner2132 .iter_mut()2133 .find(|i| i.owner == new_owner)2134 .expect("new owner has account")2135 .fraction += value;2136 } else {2137 // new owner do not have account2138 new_full_item.owner.push(Ownership {2139 owner: new_owner.clone(),2140 fraction: value,2141 });2142 Self::add_token_index(collection, item_id, &new_owner)?;2143 }21442145 collection.consume_sstore()?;2146 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2147 }21482149 Self::deposit_event(RawEvent::Transfer(2150 collection.id,2151 item_id,2152 owner,2153 new_owner,2154 amount,2155 ));21562157 Ok(())2158 }21592160 fn transfer_nft(2161 collection: &CollectionHandle<T>,2162 item_id: TokenId,2163 sender: T::CrossAccountId,2164 new_owner: T::CrossAccountId,2165 ) -> DispatchResult {2166 let collection_id = collection.id;2167 collection.consume_sload()?;2168 let mut item =2169 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21702171 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21722173 collection.consume_sload()?;2174 // update balance2175 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2176 .checked_sub(1)2177 .ok_or(Error::<T>::NumOverflow)?;2178 collection.consume_sstore()?;2179 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21802181 collection.consume_sload()?;2182 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2183 .checked_add(1)2184 .ok_or(Error::<T>::NumOverflow)?;2185 collection.consume_sstore()?;2186 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21872188 // change owner2189 let old_owner = item.owner.clone();2190 item.owner = new_owner.clone();2191 collection.consume_sstore()?;2192 <NftItemList<T>>::insert(collection_id, item_id, item);21932194 // update index collection2195 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;21962197 collection.log(ERC721Events::Transfer {2198 from: *sender.as_eth(),2199 to: *new_owner.as_eth(),2200 token_id: item_id.into(),2201 })?;2202 Self::deposit_event(RawEvent::Transfer(2203 collection.id,2204 item_id,2205 sender,2206 new_owner,2207 1,2208 ));22092210 Ok(())2211 }22122213 fn set_re_fungible_variable_data(2214 collection: &CollectionHandle<T>,2215 item_id: TokenId,2216 data: Vec<u8>,2217 ) -> DispatchResult {2218 let collection_id = collection.id;2219 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2220 .ok_or(Error::<T>::TokenNotFound)?;22212222 item.variable_data = data;22232224 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22252226 Ok(())2227 }22282229 fn set_nft_variable_data(2230 collection: &CollectionHandle<T>,2231 item_id: TokenId,2232 data: Vec<u8>,2233 ) -> DispatchResult {2234 let collection_id = collection.id;2235 let mut item =2236 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22372238 item.variable_data = data;22392240 <NftItemList<T>>::insert(collection_id, item_id, item);22412242 Ok(())2243 }22442245 #[allow(dead_code)]2246 fn init_collection(item: &Collection<T>) {2247 // check params2248 assert!(2249 item.decimal_points <= MAX_DECIMAL_POINTS,2250 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2251 );2252 assert!(2253 item.name.len() <= 64,2254 "Collection name can not be longer than 63 char"2255 );2256 assert!(2257 item.name.len() <= 256,2258 "Collection description can not be longer than 255 char"2259 );2260 assert!(2261 item.token_prefix.len() <= 16,2262 "Token prefix can not be longer than 15 char"2263 );22642265 // Generate next collection ID2266 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22672268 CreatedCollectionCount::put(next_id);2269 }22702271 #[allow(dead_code)]2272 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2273 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22742275 Self::add_token_index(2276 &CollectionHandle::get(collection_id).unwrap(),2277 current_index,2278 &item.owner,2279 )2280 .unwrap();22812282 <ItemListIndex>::insert(collection_id, current_index);22832284 // Update balance2285 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2286 .checked_add(1)2287 .unwrap();2288 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2289 }22902291 #[allow(dead_code)]2292 fn init_fungible_token(2293 collection_id: CollectionId,2294 owner: &T::CrossAccountId,2295 item: &FungibleItemType,2296 ) {2297 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22982299 Self::add_token_index(2300 &CollectionHandle::get(collection_id).unwrap(),2301 current_index,2302 owner,2303 )2304 .unwrap();23052306 <ItemListIndex>::insert(collection_id, current_index);23072308 // Update balance2309 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2310 .checked_add(item.value)2311 .unwrap();2312 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2313 }23142315 #[allow(dead_code)]2316 fn init_refungible_token(2317 collection_id: CollectionId,2318 item: &ReFungibleItemType<T::CrossAccountId>,2319 ) {2320 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23212322 let value = item.owner.first().unwrap().fraction;2323 let owner = item.owner.first().unwrap().owner.clone();23242325 Self::add_token_index(2326 &CollectionHandle::get(collection_id).unwrap(),2327 current_index,2328 &owner,2329 )2330 .unwrap();23312332 <ItemListIndex>::insert(collection_id, current_index);23332334 // Update balance2335 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2336 .checked_add(value)2337 .unwrap();2338 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2339 }23402341 fn add_token_index(2342 collection: &CollectionHandle<T>,2343 item_index: TokenId,2344 owner: &T::CrossAccountId,2345 ) -> DispatchResult {2346 // add to account limit2347 collection.consume_sload()?;2348 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2349 // bound Owned tokens by a single address2350 collection.consume_sload()?;2351 let count = <AccountItemCount<T>>::get(owner.as_sub());2352 ensure!(2353 count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2354 Error::<T>::AddressOwnershipLimitExceeded2355 );23562357 collection.consume_sstore()?;2358 <AccountItemCount<T>>::insert(2359 owner.as_sub(),2360 count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2361 );2362 } else {2363 collection.consume_sstore()?;2364 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2365 }23662367 collection.consume_sload()?;2368 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2369 if list_exists {2370 collection.consume_sload()?;2371 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2372 let item_contains = list.contains(&item_index.clone());23732374 if !item_contains {2375 list.push(item_index);2376 }23772378 collection.consume_sstore()?;2379 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2380 } else {2381 let itm = vec![item_index];2382 collection.consume_sstore()?;2383 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2384 }23852386 Ok(())2387 }23882389 fn remove_token_index(2390 collection: &CollectionHandle<T>,2391 item_index: TokenId,2392 owner: &T::CrossAccountId,2393 ) -> DispatchResult {2394 // update counter2395 collection.consume_sload()?;2396 collection.consume_sstore()?;2397 <AccountItemCount<T>>::insert(2398 owner.as_sub(),2399 <AccountItemCount<T>>::get(owner.as_sub())2400 .checked_sub(1)2401 .ok_or(Error::<T>::NumOverflow)?,2402 );24032404 collection.consume_sload()?;2405 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2406 if list_exists {2407 collection.consume_sload()?;2408 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2409 let item_contains = list.contains(&item_index.clone());24102411 if item_contains {2412 list.retain(|&item| item != item_index);2413 collection.consume_sstore()?;2414 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2415 }2416 }24172418 Ok(())2419 }24202421 fn move_token_index(2422 collection: &CollectionHandle<T>,2423 item_index: TokenId,2424 old_owner: &T::CrossAccountId,2425 new_owner: &T::CrossAccountId,2426 ) -> DispatchResult {2427 Self::remove_token_index(collection, item_index, old_owner)?;2428 Self::add_token_index(collection, item_index, new_owner)?;24292430 Ok(())2431 }2432}24332434sp_api::decl_runtime_apis! {2435 pub trait NftApi {2436 /// Used for ethereum integration2437 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2438 }2439}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
+}