difftreelog
Merge branch 'develop' into tests/eth-helpers
in: master
59 files changed
.maintain/scripts/generate_abi.shdiffbeforeafterboth--- a/.maintain/scripts/generate_abi.sh
+++ b/.maintain/scripts/generate_abi.sh
@@ -4,6 +4,7 @@
dir=$PWD
tmp=$(mktemp -d)
+echo "Tmp file: $tmp/input.sol"
cd $tmp
cp $dir/$INPUT input.sol
solcjs --abi -p input.sol
Cargo.lockdiffbeforeafterboth--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1058,16 +1058,6 @@
]
[[package]]
-name = "concat-idents"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fe0e1d9f7de897d18e590a7496b5facbe87813f746cf4b8db596ba77e07e832"
-dependencies = [
- "quote",
- "syn",
-]
-
-[[package]]
name = "concurrent-queue"
version = "1.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2347,9 +2337,8 @@
[[package]]
name = "evm-coder"
-version = "0.1.4"
+version = "0.1.5"
dependencies = [
- "concat-idents",
"ethereum",
"evm-coder-procedural",
"evm-core",
@@ -2367,7 +2356,7 @@
[[package]]
name = "evm-coder-procedural"
-version = "0.2.1"
+version = "0.2.2"
dependencies = [
"Inflector",
"hex",
crates/evm-coder/CHANGELOG.mddiffbeforeafterboth--- a/crates/evm-coder/CHANGELOG.md
+++ b/crates/evm-coder/CHANGELOG.md
@@ -3,6 +3,10 @@
All notable changes to this project will be documented in this file.
<!-- bureaucrate goes here -->
+## [v0.1.5] - 2022-11-30
+
+### Added
+- Derive macro to support structures and enums.
## [v0.1.4] - 2022-11-02
crates/evm-coder/Cargo.tomldiffbeforeafterboth--- a/crates/evm-coder/Cargo.toml
+++ b/crates/evm-coder/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "evm-coder"
-version = "0.1.4"
+version = "0.1.5"
license = "GPLv3"
edition = "2021"
@@ -26,7 +26,6 @@
hex = "0.4.3"
hex-literal = "0.3.4"
similar-asserts = "1.4.2"
-concat-idents = "1.1.3"
trybuild = "1.0"
[features]
crates/evm-coder/procedural/Cargo.tomldiffbeforeafterboth--- a/crates/evm-coder/procedural/Cargo.toml
+++ b/crates/evm-coder/procedural/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "evm-coder-procedural"
-version = "0.2.1"
+version = "0.2.2"
license = "GPLv3"
edition = "2021"
crates/evm-coder/procedural/src/abi_derive/derive_enum.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/procedural/src/abi_derive/derive_enum.rs
@@ -0,0 +1,211 @@
+use quote::quote;
+
+pub fn impl_solidity_option<'a>(
+ name: &proc_macro2::Ident,
+ enum_options: impl Iterator<Item = &'a syn::Ident>,
+) -> proc_macro2::TokenStream {
+ let enum_options = enum_options.map(|opt| {
+ let s = name.to_string() + "." + opt.to_string().as_str();
+ let as_string = proc_macro2::Literal::string(s.as_str());
+ quote!(#name::#opt => #as_string,)
+ });
+ quote!(
+ #[cfg(feature = "stubgen")]
+ impl ::evm_coder::solidity::SolidityEnum for #name {
+ fn solidity_option(&self) -> &str {
+ match self {
+ #(#enum_options)*
+ }
+ }
+ }
+ )
+}
+
+pub fn impl_enum_from_u8<'a>(
+ name: &proc_macro2::Ident,
+ enum_options: impl Iterator<Item = &'a syn::Ident>,
+) -> proc_macro2::TokenStream {
+ let error_str = format!("Value not convertible into enum \"{name}\"");
+ let error_str = proc_macro2::Literal::string(&error_str);
+ let enum_options = enum_options.enumerate().map(|(i, opt)| {
+ let n = proc_macro2::Literal::u8_suffixed(i as u8);
+ quote! {#n => Ok(#name::#opt),}
+ });
+
+ quote!(
+ impl TryFrom<u8> for #name {
+ type Error = &'static str;
+
+ fn try_from(value: u8) -> ::core::result::Result<Self, Self::Error> {
+ const err: &'static str = #error_str;
+ match value {
+ #(#enum_options)*
+ _ => Err(err)
+ }
+ }
+ }
+ )
+}
+
+pub fn impl_enum_abi_type(name: &syn::Ident) -> proc_macro2::TokenStream {
+ quote! {
+ impl ::evm_coder::abi::AbiType for #name {
+ const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <u8 as ::evm_coder::abi::AbiType>::SIGNATURE;
+
+ fn is_dynamic() -> bool {
+ <u8 as ::evm_coder::abi::AbiType>::is_dynamic()
+ }
+ fn size() -> usize {
+ <u8 as ::evm_coder::abi::AbiType>::size()
+ }
+ }
+ }
+}
+
+pub fn impl_enum_abi_read(name: &syn::Ident) -> proc_macro2::TokenStream {
+ quote!(
+ impl ::evm_coder::abi::AbiRead for #name {
+ fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {
+ Ok(
+ <u8 as ::evm_coder::abi::AbiRead>::abi_read(reader)?
+ .try_into()?
+ )
+ }
+ }
+ )
+}
+
+pub fn impl_enum_abi_write(name: &syn::Ident) -> proc_macro2::TokenStream {
+ quote!(
+ impl ::evm_coder::abi::AbiWrite for #name {
+ fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {
+ ::evm_coder::abi::AbiWrite::abi_write(&(*self as u8), writer);
+ }
+ }
+ )
+}
+
+pub fn impl_enum_solidity_type_name(name: &syn::Ident) -> proc_macro2::TokenStream {
+ quote!(
+ #[cfg(feature = "stubgen")]
+ impl ::evm_coder::solidity::SolidityTypeName for #name {
+ fn solidity_name(
+ writer: &mut impl ::core::fmt::Write,
+ tc: &::evm_coder::solidity::TypeCollector,
+ ) -> ::core::fmt::Result {
+ write!(writer, "{}", tc.collect_struct::<Self>())
+ }
+
+ fn is_simple() -> bool {
+ true
+ }
+
+ fn solidity_default(
+ writer: &mut impl ::core::fmt::Write,
+ tc: &::evm_coder::solidity::TypeCollector,
+ ) -> ::core::fmt::Result {
+ write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnum>::solidity_option(&<#name>::default()))
+ }
+ }
+ )
+}
+
+pub fn impl_enum_solidity_struct_collect<'a>(
+ name: &syn::Ident,
+ enum_options: impl Iterator<Item = &'a syn::Ident>,
+ option_count: usize,
+ enum_options_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>>,
+ docs: &[proc_macro2::TokenStream],
+) -> proc_macro2::TokenStream {
+ let string_name = name.to_string();
+ let enum_options = enum_options
+ .zip(enum_options_docs)
+ .enumerate()
+ .map(|(i, (opt, doc))| {
+ let opt = proc_macro2::Literal::string(opt.to_string().as_str());
+ let doc = doc.expect("Doc parsing error");
+ let comma = if i != option_count - 1 { "," } else { "" };
+ quote! {
+ #(#doc)*
+ writeln!(str, "\t{}{}", #opt, #comma).expect("Enum format option");
+ }
+ });
+
+ quote!(
+ #[cfg(feature = "stubgen")]
+ impl ::evm_coder::solidity::StructCollect for #name {
+ fn name() -> String {
+ #string_name.into()
+ }
+
+ fn declaration() -> String {
+ use std::fmt::Write;
+
+ let mut str = String::new();
+ #(#docs)*
+ writeln!(str, "enum {} {{", <Self as ::evm_coder::solidity::StructCollect>::name()).unwrap();
+ #(#enum_options)*
+ writeln!(str, "}}").unwrap();
+ str
+ }
+ }
+ )
+}
+
+pub fn check_and_count_options(de: &syn::DataEnum) -> syn::Result<usize> {
+ let mut count = 0;
+ for v in de.variants.iter() {
+ if !v.fields.is_empty() {
+ return Err(syn::Error::new(
+ v.ident.span(),
+ "Enumeration parameters should not have fields",
+ ));
+ } else if v.discriminant.is_some() {
+ return Err(syn::Error::new(
+ v.ident.span(),
+ "Enumeration options should not have an explicit specified value",
+ ));
+ } else {
+ count += 1;
+ }
+ }
+
+ Ok(count)
+}
+
+pub fn check_repr_u8(name: &syn::Ident, attrs: &[syn::Attribute]) -> syn::Result<()> {
+ let mut has_repr = false;
+ for attr in attrs.iter() {
+ if attr.path.is_ident("repr") {
+ has_repr = true;
+ let meta = attr.parse_meta()?;
+ check_meta_u8(&meta)?;
+ }
+ }
+
+ if !has_repr {
+ return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));
+ }
+
+ Ok(())
+}
+
+fn check_meta_u8(meta: &syn::Meta) -> Result<(), syn::Error> {
+ if let syn::Meta::List(p) = meta {
+ for nm in p.nested.iter() {
+ if let syn::NestedMeta::Meta(syn::Meta::Path(p)) = nm {
+ if !p.is_ident("u8") {
+ return Err(syn::Error::new(
+ p.segments
+ .first()
+ .expect("repr segments are empty")
+ .ident
+ .span(),
+ "Enum is not \"repr(u8)\"",
+ ));
+ }
+ }
+ }
+ }
+ Ok(())
+}
crates/evm-coder/procedural/src/abi_derive/derive_struct.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/procedural/src/abi_derive/derive_struct.rs
@@ -0,0 +1,260 @@
+use super::extract_docs;
+use quote::quote;
+
+pub fn tuple_type<'a>(
+ field_types: impl Iterator<Item = &'a syn::Type> + Clone,
+) -> proc_macro2::TokenStream {
+ let field_types = field_types.map(|ty| quote!(#ty,));
+ quote! {(#(#field_types)*)}
+}
+
+pub fn tuple_ref_type<'a>(
+ field_types: impl Iterator<Item = &'a syn::Type> + Clone,
+) -> proc_macro2::TokenStream {
+ let field_types = field_types.map(|ty| quote!(&#ty,));
+ quote! {(#(#field_types)*)}
+}
+
+pub fn tuple_data_as_ref(
+ is_named_fields: bool,
+ field_names: impl Iterator<Item = syn::Ident> + Clone,
+) -> proc_macro2::TokenStream {
+ let field_names = field_names.enumerate().map(|(i, field)| {
+ if is_named_fields {
+ quote!(&self.#field,)
+ } else {
+ let field = proc_macro2::Literal::usize_unsuffixed(i);
+ quote!(&self.#field,)
+ }
+ });
+ quote! {(#(#field_names)*)}
+}
+
+pub fn tuple_names(
+ is_named_fields: bool,
+ field_names: impl Iterator<Item = syn::Ident> + Clone,
+) -> proc_macro2::TokenStream {
+ let field_names = field_names.enumerate().map(|(i, field)| {
+ if is_named_fields {
+ quote!(#field,)
+ } else {
+ let field = proc_macro2::Ident::new(
+ format!("field{}", i).as_str(),
+ proc_macro2::Span::call_site(),
+ );
+ quote!(#field,)
+ }
+ });
+ quote! {(#(#field_names)*)}
+}
+
+pub fn struct_from_tuple(
+ name: &syn::Ident,
+ is_named_fields: bool,
+ field_names: impl Iterator<Item = syn::Ident> + Clone,
+) -> proc_macro2::TokenStream {
+ let field_names = field_names.enumerate().map(|(i, field)| {
+ if is_named_fields {
+ quote!(#field,)
+ } else {
+ let field = proc_macro2::Ident::new(
+ format!("field{}", i).as_str(),
+ proc_macro2::Span::call_site(),
+ );
+ quote!(#field,)
+ }
+ });
+
+ if is_named_fields {
+ quote! {#name {#(#field_names)*}}
+ } else {
+ quote! {#name (#(#field_names)*)}
+ }
+}
+
+pub fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {
+ match field.1.ident.as_ref() {
+ Some(name) => name.clone(),
+ None => {
+ let mut name = "field".to_string();
+ name.push_str(field.0.to_string().as_str());
+ syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())
+ }
+ }
+}
+
+pub fn map_field_to_type(field: &syn::Field) -> &syn::Type {
+ &field.ty
+}
+
+pub fn map_field_to_doc(field: &syn::Field) -> syn::Result<Vec<proc_macro2::TokenStream>> {
+ extract_docs(&field.attrs, true)
+}
+
+pub fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {
+ quote! {
+ impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}
+ }
+}
+
+pub fn impl_struct_abi_type(
+ name: &syn::Ident,
+ tuple_type: proc_macro2::TokenStream,
+) -> proc_macro2::TokenStream {
+ quote! {
+ impl ::evm_coder::abi::AbiType for #name {
+ const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;
+ fn is_dynamic() -> bool {
+ <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()
+ }
+ fn size() -> usize {
+ <#tuple_type as ::evm_coder::abi::AbiType>::size()
+ }
+ }
+ }
+}
+
+pub fn impl_struct_abi_read(
+ name: &syn::Ident,
+ tuple_type: proc_macro2::TokenStream,
+ tuple_names: proc_macro2::TokenStream,
+ struct_from_tuple: proc_macro2::TokenStream,
+) -> proc_macro2::TokenStream {
+ quote!(
+ impl ::evm_coder::abi::AbiRead for #name {
+ fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {
+ let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;
+ Ok(#struct_from_tuple)
+ }
+ }
+ )
+}
+
+pub fn impl_struct_abi_write(
+ name: &syn::Ident,
+ _is_named_fields: bool,
+ tuple_type: proc_macro2::TokenStream,
+ tuple_data: proc_macro2::TokenStream,
+) -> proc_macro2::TokenStream {
+ quote!(
+ impl ::evm_coder::abi::AbiWrite for #name {
+ fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {
+ <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)
+ }
+ }
+ )
+}
+
+pub fn impl_struct_solidity_type<'a>(
+ name: &syn::Ident,
+ field_types: impl Iterator<Item = &'a syn::Type> + Clone,
+ params_count: usize,
+) -> proc_macro2::TokenStream {
+ let len = proc_macro2::Literal::usize_suffixed(params_count);
+ quote! {
+ #[cfg(feature = "stubgen")]
+ impl ::evm_coder::solidity::SolidityType for #name {
+ fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {
+ let mut collected =
+ Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());
+ #({
+ let mut out = String::new();
+ <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)
+ .expect("no fmt error");
+ collected.push(out);
+ })*
+ collected
+ }
+
+ fn len() -> usize {
+ #len
+ }
+ }
+ }
+}
+
+pub fn impl_struct_solidity_type_name<'a>(
+ name: &syn::Ident,
+ field_types: impl Iterator<Item = &'a syn::Type> + Clone,
+ params_count: usize,
+) -> proc_macro2::TokenStream {
+ let arg_dafaults = field_types.enumerate().map(|(i, ty)| {
+ let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName
+ >::solidity_default(writer, tc)?;);
+ let last_item = params_count - 1;
+ if i != last_item {
+ defult_value.extend(quote! {write!(writer, ",")?;})
+ }
+ defult_value
+ });
+
+ quote! {
+ #[cfg(feature = "stubgen")]
+ impl ::evm_coder::solidity::SolidityTypeName for #name {
+ fn solidity_name(
+ writer: &mut impl ::core::fmt::Write,
+ tc: &::evm_coder::solidity::TypeCollector,
+ ) -> ::core::fmt::Result {
+ write!(writer, "{}", tc.collect_struct::<Self>())
+ }
+
+ fn is_simple() -> bool {
+ false
+ }
+
+ fn solidity_default(
+ writer: &mut impl ::core::fmt::Write,
+ tc: &::evm_coder::solidity::TypeCollector,
+ ) -> ::core::fmt::Result {
+ write!(writer, "{}(", tc.collect_struct::<Self>())?;
+
+ #(#arg_dafaults)*
+
+ write!(writer, ")")
+ }
+ }
+ }
+}
+
+pub fn impl_struct_solidity_struct_collect<'a>(
+ name: &syn::Ident,
+ field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,
+ field_types: impl Iterator<Item = &'a syn::Type> + Clone,
+ field_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>> + Clone,
+ docs: &[proc_macro2::TokenStream],
+) -> syn::Result<proc_macro2::TokenStream> {
+ let string_name = name.to_string();
+ let name_type = field_names
+ .into_iter()
+ .zip(field_types)
+ .zip(field_docs)
+ .map(|((name, ty), doc)| {
+ let field_docs = doc.expect("Doc parse error");
+ let name = format!("{}", name);
+ quote!(
+ #(#field_docs)*
+ write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();
+ writeln!(str, "{};", #name).unwrap();
+ )
+ });
+
+ Ok(quote! {
+ #[cfg(feature = "stubgen")]
+ impl ::evm_coder::solidity::StructCollect for #name {
+ fn name() -> String {
+ #string_name.into()
+ }
+
+ fn declaration() -> String {
+ use std::fmt::Write;
+
+ let mut str = String::new();
+ #(#docs)*
+ writeln!(str, "struct {} {{", Self::name()).unwrap();
+ #(#name_type)*
+ writeln!(str, "}}").unwrap();
+ str
+ }
+ }
+ })
+}
crates/evm-coder/procedural/src/abi_derive/mod.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/procedural/src/abi_derive/mod.rs
@@ -0,0 +1,145 @@
+mod derive_enum;
+mod derive_struct;
+
+use quote::quote;
+use derive_struct::*;
+use derive_enum::*;
+
+pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
+ let name = &ast.ident;
+ match &ast.data {
+ syn::Data::Struct(ds) => expand_struct(ds, ast),
+ syn::Data::Enum(de) => expand_enum(de, ast),
+ syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),
+ }
+}
+
+fn expand_struct(
+ ds: &syn::DataStruct,
+ ast: &syn::DeriveInput,
+) -> syn::Result<proc_macro2::TokenStream> {
+ let name = &ast.ident;
+ let docs = extract_docs(&ast.attrs, false)?;
+ let (is_named_fields, field_names, field_types, field_docs, params_count) = match ds.fields {
+ syn::Fields::Named(ref fields) => Ok((
+ true,
+ fields.named.iter().enumerate().map(map_field_to_name),
+ fields.named.iter().map(map_field_to_type),
+ fields.named.iter().map(map_field_to_doc),
+ fields.named.len(),
+ )),
+ syn::Fields::Unnamed(ref fields) => Ok((
+ false,
+ fields.unnamed.iter().enumerate().map(map_field_to_name),
+ fields.unnamed.iter().map(map_field_to_type),
+ fields.unnamed.iter().map(map_field_to_doc),
+ fields.unnamed.len(),
+ )),
+ syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),
+ }?;
+
+ if params_count == 0 {
+ return Err(syn::Error::new(name.span(), "Empty structs not supported"));
+ };
+
+ let tuple_type = tuple_type(field_types.clone());
+ let tuple_ref_type = tuple_ref_type(field_types.clone());
+ let tuple_data = tuple_data_as_ref(is_named_fields, field_names.clone());
+ let tuple_names = tuple_names(is_named_fields, field_names.clone());
+ let struct_from_tuple = struct_from_tuple(name, is_named_fields, field_names.clone());
+
+ let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);
+ let abi_type = impl_struct_abi_type(name, tuple_type.clone());
+ let abi_read = impl_struct_abi_read(name, tuple_type, tuple_names, struct_from_tuple);
+ let abi_write = impl_struct_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);
+ let solidity_type = impl_struct_solidity_type(name, field_types.clone(), params_count);
+ let solidity_type_name =
+ impl_struct_solidity_type_name(name, field_types.clone(), params_count);
+ let solidity_struct_collect =
+ impl_struct_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;
+
+ Ok(quote! {
+ #can_be_plcaed_in_vec
+ #abi_type
+ #abi_read
+ #abi_write
+ #solidity_type
+ #solidity_type_name
+ #solidity_struct_collect
+ })
+}
+
+fn expand_enum(
+ de: &syn::DataEnum,
+ ast: &syn::DeriveInput,
+) -> syn::Result<proc_macro2::TokenStream> {
+ let name = &ast.ident;
+ check_repr_u8(name, &ast.attrs)?;
+ let docs = extract_docs(&ast.attrs, false)?;
+ let option_count = check_and_count_options(de)?;
+ let enum_options = de.variants.iter().map(|v| &v.ident);
+ let enum_options_docs = de.variants.iter().map(|v| extract_docs(&v.attrs, true));
+
+ let from = impl_enum_from_u8(name, enum_options.clone());
+ let solidity_option = impl_solidity_option(name, enum_options.clone());
+ let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);
+ let abi_type = impl_enum_abi_type(name);
+ let abi_read = impl_enum_abi_read(name);
+ let abi_write = impl_enum_abi_write(name);
+ let solidity_type_name = impl_enum_solidity_type_name(name);
+ let solidity_struct_collect = impl_enum_solidity_struct_collect(
+ name,
+ enum_options,
+ option_count,
+ enum_options_docs,
+ &docs,
+ );
+
+ Ok(quote! {
+ #from
+ #solidity_option
+ #can_be_plcaed_in_vec
+ #abi_type
+ #abi_read
+ #abi_write
+ #solidity_type_name
+ #solidity_struct_collect
+ })
+}
+
+fn extract_docs(
+ attrs: &[syn::Attribute],
+ is_field_doc: bool,
+) -> syn::Result<Vec<proc_macro2::TokenStream>> {
+ attrs
+ .iter()
+ .filter_map(|attr| {
+ if let Some(ps) = attr.path.segments.first() {
+ if ps.ident == "doc" {
+ let meta = match attr.parse_meta() {
+ Ok(meta) => meta,
+ Err(e) => return Some(Err(e)),
+ };
+ match meta {
+ syn::Meta::NameValue(mnv) => match &mnv.lit {
+ syn::Lit::Str(ls) => return Some(Ok(ls.value())),
+ _ => unreachable!(),
+ },
+ _ => unreachable!(),
+ }
+ }
+ }
+ None
+ })
+ .enumerate()
+ .map(|(i, doc)| {
+ let doc = doc?;
+ let doc = doc.trim();
+ let dev = if i == 0 { " @dev" } else { "" };
+ let tab = if is_field_doc { "\t" } else { "" };
+ Ok(quote! {
+ writeln!(str, "{}///{} {}", #tab, #dev, #doc).unwrap();
+ })
+ })
+ .collect()
+}
crates/evm-coder/procedural/src/lib.rsdiffbeforeafterboth--- a/crates/evm-coder/procedural/src/lib.rs
+++ b/crates/evm-coder/procedural/src/lib.rs
@@ -25,6 +25,7 @@
parse_macro_input, spanned::Spanned,
};
+mod abi_derive;
mod solidity_interface;
mod to_log;
@@ -242,3 +243,13 @@
}
.into()
}
+
+#[proc_macro_derive(AbiCoder)]
+pub fn abi_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+ let ast = syn::parse(input).unwrap();
+ let ts = match abi_derive::impl_abi_macro(&ast) {
+ Ok(e) => e,
+ Err(e) => e.to_compile_error(),
+ };
+ ts.into()
+}
crates/evm-coder/procedural/src/solidity_interface.rsdiffbeforeafterboth--- a/crates/evm-coder/procedural/src/solidity_interface.rs
+++ b/crates/evm-coder/procedural/src/solidity_interface.rs
@@ -404,7 +404,11 @@
let name = &self.name;
let ty = &self.ty;
quote! {
- #name: <#ty>::abi_read(reader)?
+ #name: {
+ let value = <#ty as ::evm_coder::abi::AbiRead>::abi_read(reader)?;
+ if !is_dynamic {reader.bytes_read(<#ty as ::evm_coder::abi::AbiType>::size())};
+ value
+ }
}
}
@@ -630,17 +634,18 @@
let pascal_name = &self.pascal_name;
let screaming_name = &self.screaming_name;
if self.has_normal_args {
- let parsers = self
- .args
- .iter()
- .filter(|a| !a.is_special())
- .map(|a| a.expand_parse());
+ let args_iter = self.args.iter().filter(|a| !a.is_special());
+ let arg_type = args_iter.clone().map(|a| &a.ty);
+ let parsers = args_iter.map(|a| a.expand_parse());
quote! {
- Self::#screaming_name => return Ok(Some(Self::#pascal_name {
- #(
- #parsers,
- )*
- }))
+ Self::#screaming_name => {
+ let is_dynamic = false #(|| <#arg_type as ::evm_coder::abi::AbiType>::is_dynamic())*;
+ return Ok(Some(Self::#pascal_name {
+ #(
+ #parsers,
+ )*
+ }))
+ }
}
} else {
quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }
crates/evm-coder/src/abi/impls.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/impls.rs
+++ b/crates/evm-coder/src/abi/impls.rs
@@ -1,8 +1,8 @@
use crate::{
+ custom_signature::SignatureUnit,
execution::{Result, ResultWithPostInfo, WithPostDispatchInfo},
+ make_signature, sealed,
types::*,
- make_signature,
- custom_signature::SignatureUnit,
};
use super::{traits::*, ABI_ALIGNMENT, AbiReader, AbiWriter};
use primitive_types::{U256, H160};
@@ -10,12 +10,12 @@
#[cfg(not(feature = "std"))]
use alloc::vec::Vec;
-macro_rules! impl_abi_readable {
- ($ty:ty, $method:ident, $dynamic:literal) => {
+macro_rules! impl_abi_type {
+ ($ty:ty, $name:ident, $dynamic:literal) => {
impl sealed::CanBePlacedInVec for $ty {}
impl AbiType for $ty {
- const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($ty)));
+ const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($name)));
fn is_dynamic() -> bool {
$dynamic
@@ -25,7 +25,11 @@
ABI_ALIGNMENT
}
}
+ };
+}
+macro_rules! impl_abi_readable {
+ ($ty:ty, $method:ident) => {
impl AbiRead for $ty {
fn abi_read(reader: &mut AbiReader) -> Result<$ty> {
reader.$method()
@@ -34,79 +38,93 @@
};
}
-impl_abi_readable!(uint32, uint32, false);
-impl_abi_readable!(uint64, uint64, false);
-impl_abi_readable!(uint128, uint128, false);
-impl_abi_readable!(uint256, uint256, false);
-impl_abi_readable!(bytes4, bytes4, false);
-impl_abi_readable!(address, address, false);
-impl_abi_readable!(string, string, true);
+macro_rules! impl_abi_writeable {
+ ($ty:ty, $method:ident) => {
+ impl AbiWrite for $ty {
+ fn abi_write(&self, writer: &mut AbiWriter) {
+ writer.$method(&self)
+ }
+ }
+ };
+}
-impl sealed::CanBePlacedInVec for bool {}
+macro_rules! impl_abi {
+ ($ty:ty, $method:ident, $dynamic:literal) => {
+ impl_abi_type!($ty, $method, $dynamic);
+ impl_abi_readable!($ty, $method);
+ impl_abi_writeable!($ty, $method);
+ };
+}
-impl AbiType for bool {
- const SIGNATURE: SignatureUnit = make_signature!(new fixed("bool"));
+impl_abi!(bool, bool, false);
+impl_abi!(u8, uint8, false);
+impl_abi!(u32, uint32, false);
+impl_abi!(u64, uint64, false);
+impl_abi!(u128, uint128, false);
+impl_abi!(U256, uint256, false);
+impl_abi!(H160, address, false);
+impl_abi!(string, string, true);
- fn is_dynamic() -> bool {
- false
- }
- fn size() -> usize {
- ABI_ALIGNMENT
+impl_abi_writeable!(&str, string);
+
+impl_abi_type!(bytes, bytes, true);
+
+impl AbiRead for bytes {
+ fn abi_read(reader: &mut AbiReader) -> Result<bytes> {
+ Ok(bytes(reader.bytes()?))
}
}
-impl AbiRead for bool {
- fn abi_read(reader: &mut AbiReader) -> Result<bool> {
- reader.bool()
+
+impl AbiWrite for bytes {
+ fn abi_write(&self, writer: &mut AbiWriter) {
+ writer.bytes(self.0.as_slice())
}
}
-
-impl AbiType for uint8 {
- const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint8"));
- fn is_dynamic() -> bool {
- false
- }
- fn size() -> usize {
- ABI_ALIGNMENT
+impl_abi_type!(bytes4, bytes4, false);
+impl AbiRead for bytes4 {
+ fn abi_read(reader: &mut AbiReader) -> Result<bytes4> {
+ reader.bytes4()
}
}
-impl AbiRead for uint8 {
- fn abi_read(reader: &mut AbiReader) -> Result<uint8> {
- reader.uint8()
+
+impl<T: AbiWrite> AbiWrite for &T {
+ fn abi_write(&self, writer: &mut AbiWriter) {
+ T::abi_write(self, writer);
}
}
-impl AbiType for bytes {
- const SIGNATURE: SignatureUnit = make_signature!(new fixed("bytes"));
+impl<T: AbiType> AbiType for &T {
+ const SIGNATURE: SignatureUnit = T::SIGNATURE;
fn is_dynamic() -> bool {
- true
+ T::is_dynamic()
}
+
fn size() -> usize {
- ABI_ALIGNMENT
- }
-}
-impl AbiRead for bytes {
- fn abi_read(reader: &mut AbiReader) -> Result<bytes> {
- Ok(bytes(reader.bytes()?))
+ T::size()
}
}
-impl<R: AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<R> {
- fn abi_read(reader: &mut AbiReader) -> Result<Vec<R>> {
+impl<T: AbiType + AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<T> {
+ fn abi_read(reader: &mut AbiReader) -> Result<Vec<T>> {
let mut sub = reader.subresult(None)?;
let size = sub.uint32()? as usize;
sub.subresult_offset = sub.offset;
+ let is_dynamic = <T as AbiType>::is_dynamic();
let mut out = Vec::with_capacity(size);
for _ in 0..size {
- out.push(<R>::abi_read(&mut sub)?);
+ out.push(<T as AbiRead>::abi_read(&mut sub)?);
+ if !is_dynamic {
+ sub.bytes_read(<T as AbiType>::size());
+ };
}
Ok(out)
}
}
-impl<R: AbiType> AbiType for Vec<R> {
- const SIGNATURE: SignatureUnit = make_signature!(new nameof(R::SIGNATURE) fixed("[]"));
+impl<T: AbiType> AbiType for Vec<T> {
+ const SIGNATURE: SignatureUnit = make_signature!(new nameof(T::SIGNATURE) fixed("[]"));
fn is_dynamic() -> bool {
true
@@ -114,42 +132,6 @@
fn size() -> usize {
ABI_ALIGNMENT
- }
-}
-
-impl sealed::CanBePlacedInVec for EthCrossAccount {}
-
-impl AbiType for EthCrossAccount {
- const SIGNATURE: SignatureUnit = make_signature!(new fixed("(address,uint256)"));
-
- fn is_dynamic() -> bool {
- address::is_dynamic() || uint256::is_dynamic()
- }
-
- fn size() -> usize {
- <address as AbiType>::size() + <uint256 as AbiType>::size()
- }
-}
-
-impl AbiRead for EthCrossAccount {
- fn abi_read(reader: &mut AbiReader) -> Result<EthCrossAccount> {
- let size = if !EthCrossAccount::is_dynamic() {
- Some(<EthCrossAccount as AbiType>::size())
- } else {
- None
- };
- let mut subresult = reader.subresult(size)?;
- let eth = <address>::abi_read(&mut subresult)?;
- let sub = <uint256>::abi_read(&mut subresult)?;
-
- Ok(EthCrossAccount { eth, sub })
- }
-}
-
-impl AbiWrite for EthCrossAccount {
- fn abi_write(&self, writer: &mut AbiWriter) {
- self.eth.abi_write(writer);
- self.sub.abi_write(writer);
}
}
@@ -188,36 +170,6 @@
}
}
-macro_rules! impl_abi_writeable {
- ($ty:ty, $method:ident) => {
- impl AbiWrite for $ty {
- fn abi_write(&self, writer: &mut AbiWriter) {
- writer.$method(&self)
- }
- }
- };
-}
-
-impl_abi_writeable!(u8, uint8);
-impl_abi_writeable!(u32, uint32);
-impl_abi_writeable!(u128, uint128);
-impl_abi_writeable!(U256, uint256);
-impl_abi_writeable!(H160, address);
-impl_abi_writeable!(bool, bool);
-impl_abi_writeable!(&str, string);
-
-impl AbiWrite for string {
- fn abi_write(&self, writer: &mut AbiWriter) {
- writer.string(self)
- }
-}
-
-impl AbiWrite for bytes {
- fn abi_write(&self, writer: &mut AbiWriter) {
- writer.bytes(self.0.as_slice())
- }
-}
-
impl<T: AbiWrite + AbiType> AbiWrite for Vec<T> {
fn abi_write(&self, writer: &mut AbiWriter) {
let is_dynamic = T::is_dynamic();
@@ -295,14 +247,19 @@
impl<$($ident),+> AbiRead for ($($ident,)+)
where
- $($ident: AbiRead,)+
- ($($ident,)+): AbiType,
+ Self: AbiType,
+ $($ident: AbiRead + AbiType,)+
{
fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {
- let size = if !<($($ident,)+)>::is_dynamic() { Some(<($($ident,)+)>::size()) } else { None };
+ let is_dynamic = <Self>::is_dynamic();
+ let size = if !is_dynamic { Some(<Self>::size()) } else { None };
let mut subresult = reader.subresult(size)?;
Ok((
- $(<$ident>::abi_read(&mut subresult)?,)+
+ $({
+ let value = <$ident>::abi_read(&mut subresult)?;
+ if !is_dynamic {subresult.bytes_read(<$ident as AbiType>::size())};
+ value
+ },)+
))
}
}
@@ -310,11 +267,11 @@
#[allow(non_snake_case)]
impl<$($ident),+> AbiWrite for ($($ident,)+)
where
- $($ident: AbiWrite,)+
+ $($ident: AbiWrite + AbiType,)+
{
fn abi_write(&self, writer: &mut AbiWriter) {
let ($($ident,)+) = self;
- if writer.is_dynamic {
+ if <Self as AbiType>::is_dynamic() {
let mut sub = AbiWriter::new();
$($ident.abi_write(&mut sub);)+
writer.write_subresult(sub);
crates/evm-coder/src/abi/mod.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/mod.rs
+++ b/crates/evm-coder/src/abi/mod.rs
@@ -75,19 +75,19 @@
buf: &[u8],
offset: usize,
pad_start: usize,
- pad_size: usize,
+ pad_end: usize,
block_start: usize,
- block_size: usize,
+ block_end: usize,
) -> Result<[u8; S]> {
if buf.len() - offset < ABI_ALIGNMENT {
return Err(Error::Error(ExitError::OutOfOffset));
}
let mut block = [0; S];
- let is_pad_zeroed = buf[pad_start..pad_size].iter().all(|&v| v == 0);
+ let is_pad_zeroed = buf[pad_start..pad_end].iter().all(|&v| v == 0);
if !is_pad_zeroed {
return Err(Error::Error(ExitError::InvalidRange));
}
- block.copy_from_slice(&buf[block_start..block_size]);
+ block.copy_from_slice(&buf[block_start..block_end]);
Ok(block)
}
@@ -186,11 +186,10 @@
/// Slice recursive buffer, advance one word for buffer offset
/// If `size` is [`None`] then [`Self::offset`] and [`Self::subresult_offset`] evals from [`Self::buf`].
- fn subresult(&mut self, size: Option<usize>) -> Result<AbiReader<'i>> {
+ pub fn subresult(&mut self, size: Option<usize>) -> Result<AbiReader<'i>> {
let subresult_offset = self.subresult_offset;
let offset = if let Some(size) = size {
self.offset += size;
- self.subresult_offset += size;
0
} else {
self.uint32()? as usize
@@ -208,6 +207,11 @@
})
}
+ /// Notify about readed data portion.
+ pub fn bytes_read(&mut self, size: usize) {
+ self.subresult_offset += size;
+ }
+
/// Is this parser reached end of buffer?
pub fn is_finished(&self) -> bool {
self.buf.len() == self.offset
@@ -277,6 +281,11 @@
self.write_padleft(&u32::to_be_bytes(*value))
}
+ /// Write [`u64`] to end of buffer
+ pub fn uint64(&mut self, value: &u64) {
+ self.write_padleft(&u64::to_be_bytes(*value))
+ }
+
/// Write [`u128`] to end of buffer
pub fn uint128(&mut self, value: &u128) {
self.write_padleft(&u128::to_be_bytes(*value))
crates/evm-coder/src/abi/test.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/test.rs
+++ b/crates/evm-coder/src/abi/test.rs
@@ -6,36 +6,25 @@
use super::{AbiReader, AbiWriter};
use hex_literal::hex;
use primitive_types::{H160, U256};
-use concat_idents::concat_idents;
-macro_rules! test_impl {
- ($name:ident, $type:ty, $function_identifier:expr, $decoded_data:expr, $encoded_data:expr) => {
- concat_idents!(test_name = encode_decode_, $name {
- #[test]
- fn test_name() {
- let function_identifier: u32 = $function_identifier;
- let decoded_data = $decoded_data;
- let encoded_data = $encoded_data;
-
- let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();
- assert_eq!(call, u32::to_be_bytes(function_identifier));
- let data = <$type>::abi_read(&mut decoder).unwrap();
- assert_eq!(data, decoded_data);
+fn test_impl<T>(function_identifier: u32, decoded_data: T, encoded_data: &[u8])
+where
+ T: AbiWrite + AbiRead + std::cmp::PartialEq + std::fmt::Debug,
+{
+ let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();
+ assert_eq!(call, u32::to_be_bytes(function_identifier));
+ let data = <T>::abi_read(&mut decoder).unwrap();
+ assert_eq!(data, decoded_data);
- let mut writer = AbiWriter::new_call(function_identifier);
- decoded_data.abi_write(&mut writer);
- let ed = writer.finish();
- similar_asserts::assert_eq!(encoded_data, ed.as_slice());
- }
- });
- };
+ let mut writer = AbiWriter::new_call(function_identifier);
+ decoded_data.abi_write(&mut writer);
+ let ed = writer.finish();
+ similar_asserts::assert_eq!(encoded_data, ed.as_slice());
}
macro_rules! test_impl_uint {
($type:ident) => {
- test_impl!(
- $type,
- $type,
+ test_impl::<$type>(
0xdeadbeef,
255 as $type,
&hex!(
@@ -43,101 +32,148 @@
deadbeef
00000000000000000000000000000000000000000000000000000000000000ff
"
- )
+ ),
);
};
}
-test_impl_uint!(uint8);
-test_impl_uint!(uint32);
-test_impl_uint!(uint128);
+#[test]
+fn encode_decode_uint8() {
+ test_impl_uint!(uint8);
+}
-test_impl!(
- uint256,
- uint256,
- 0xdeadbeef,
- U256([255, 0, 0, 0]),
- &hex!(
- "
- deadbeef
- 00000000000000000000000000000000000000000000000000000000000000ff
- "
- )
-);
+#[test]
+fn encode_decode_uint32() {
+ test_impl_uint!(uint32);
+}
-test_impl!(
- vec_tuple_address_uint256,
- Vec<(address, uint256)>,
- 0x1ACF2D55,
- vec![
- (
- H160(hex!("2D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC")),
- U256([10, 0, 0, 0]),
- ),
- (
- H160(hex!("AB8E3D9134955566483B11E6825C9223B6737B10")),
- U256([20, 0, 0, 0]),
- ),
- (
- H160(hex!("8C582BDF2953046705FC56F189385255EFC1BE18")),
- U256([30, 0, 0, 0]),
- ),
- ],
- &hex!(
- "
- 1ACF2D55
- 0000000000000000000000000000000000000000000000000000000000000020 // offset of (address, uint256)[]
- 0000000000000000000000000000000000000000000000000000000000000003 // length of (address, uint256)[]
+#[test]
+fn encode_decode_uint128() {
+ test_impl_uint!(uint128);
+}
- 0000000000000000000000002D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC // address
- 000000000000000000000000000000000000000000000000000000000000000A // uint256
+#[test]
+fn encode_decode_uint256() {
+ test_impl::<uint256>(
+ 0xdeadbeef,
+ U256([255, 0, 0, 0]),
+ &hex!(
+ "
+ deadbeef
+ 00000000000000000000000000000000000000000000000000000000000000ff
+ "
+ ),
+ );
+}
- 000000000000000000000000AB8E3D9134955566483B11E6825C9223B6737B10 // address
- 0000000000000000000000000000000000000000000000000000000000000014 // uint256
+#[test]
+fn encode_decode_string() {
+ test_impl::<String>(
+ 0xdeadbeef,
+ "some string".to_string(),
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 000000000000000000000000000000000000000000000000000000000000000b
+ 736f6d6520737472696e67000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
- 0000000000000000000000008C582BDF2953046705FC56F189385255EFC1BE18 // address
- 000000000000000000000000000000000000000000000000000000000000001E // uint256
- "
- )
-);
+#[test]
+fn encode_decode_tuple_string() {
+ test_impl::<(String,)>(
+ 0xdeadbeef,
+ ("some string".to_string(),),
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 000000000000000000000000000000000000000000000000000000000000000b
+ 736f6d6520737472696e67000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
-test_impl!(
- vec_tuple_uint256_string,
- Vec<(uint256, string)>,
- 0xdeadbeef,
- vec![
- (1.into(), "Test URI 0".to_string()),
- (11.into(), "Test URI 1".to_string()),
- (12.into(), "Test URI 2".to_string()),
- ],
- &hex!(
- "
- deadbeef
- 0000000000000000000000000000000000000000000000000000000000000020 // offset of (uint256, string)[]
- 0000000000000000000000000000000000000000000000000000000000000003 // length of (uint256, string)[]
+#[test]
+fn encode_decode_vec_tuple_address_uint256() {
+ test_impl::<Vec<(address, uint256)>>(
+ 0x1ACF2D55,
+ vec![
+ (
+ H160(hex!("2D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC")),
+ U256([10, 0, 0, 0]),
+ ),
+ (
+ H160(hex!("AB8E3D9134955566483B11E6825C9223B6737B10")),
+ U256([20, 0, 0, 0]),
+ ),
+ (
+ H160(hex!("8C582BDF2953046705FC56F189385255EFC1BE18")),
+ U256([30, 0, 0, 0]),
+ ),
+ ],
+ &hex!(
+ "
+ 1ACF2D55
+ 0000000000000000000000000000000000000000000000000000000000000020 // offset of (address, uint256)[]
+ 0000000000000000000000000000000000000000000000000000000000000003 // length of (address, uint256)[]
- 0000000000000000000000000000000000000000000000000000000000000060 // offset of first elem
- 00000000000000000000000000000000000000000000000000000000000000e0 // offset of second elem
- 0000000000000000000000000000000000000000000000000000000000000160 // offset of third elem
+ 0000000000000000000000002D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC // address
+ 000000000000000000000000000000000000000000000000000000000000000A // uint256
- 0000000000000000000000000000000000000000000000000000000000000001 // first token id? #60
- 0000000000000000000000000000000000000000000000000000000000000040 // offset of string
- 000000000000000000000000000000000000000000000000000000000000000a // size of string
- 5465737420555249203000000000000000000000000000000000000000000000 // string
+ 000000000000000000000000AB8E3D9134955566483B11E6825C9223B6737B10 // address
+ 0000000000000000000000000000000000000000000000000000000000000014 // uint256
- 000000000000000000000000000000000000000000000000000000000000000b // second token id? Why ==11? #e0
- 0000000000000000000000000000000000000000000000000000000000000040 // offset of string
- 000000000000000000000000000000000000000000000000000000000000000a // size of string
- 5465737420555249203100000000000000000000000000000000000000000000 // string
+ 0000000000000000000000008C582BDF2953046705FC56F189385255EFC1BE18 // address
+ 000000000000000000000000000000000000000000000000000000000000001E // uint256
+ "
+ )
+ );
+}
- 000000000000000000000000000000000000000000000000000000000000000c // third token id? Why ==12? #160
- 0000000000000000000000000000000000000000000000000000000000000040 // offset of string
- 000000000000000000000000000000000000000000000000000000000000000a // size of string
- 5465737420555249203200000000000000000000000000000000000000000000 // string
- "
- )
-);
+#[test]
+fn encode_decode_vec_tuple_uint256_string() {
+ test_impl::<Vec<(uint256, string)>>(
+ 0xdeadbeef,
+ vec![
+ (1.into(), "Test URI 0".to_string()),
+ (11.into(), "Test URI 1".to_string()),
+ (12.into(), "Test URI 2".to_string()),
+ ],
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020 // 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
+ "
+ )
+ );
+}
+
#[test]
fn dynamic_after_static() {
let mut encoder = AbiWriter::new();
@@ -235,63 +271,270 @@
similar_asserts::assert_eq!(encoded_data, ed.as_slice());
}
-test_impl!(
- vec_tuple_string_bytes,
- Vec<(string, bytes)>,
- 0xdeadbeef,
- vec![
- (
- "Test URI 0".to_string(),
- bytes(vec![
- 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
- 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
- 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
- 0x11, 0x11, 0x11, 0x11, 0x11, 0x11
- ])
+#[test]
+fn encode_decode_vec_tuple_string_bytes() {
+ test_impl::<Vec<(string, bytes)>>(
+ 0xdeadbeef,
+ vec![
+ (
+ "Test URI 0".to_string(),
+ bytes(vec![
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ ]),
+ ),
+ (
+ "Test URI 1".to_string(),
+ bytes(vec![
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ ]),
+ ),
+ ("Test URI 2".to_string(), bytes(vec![0x33, 0x33])),
+ ],
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 0000000000000000000000000000000000000000000000000000000000000003
+
+ 0000000000000000000000000000000000000000000000000000000000000060
+ 0000000000000000000000000000000000000000000000000000000000000140
+ 0000000000000000000000000000000000000000000000000000000000000220
+
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 0000000000000000000000000000000000000000000000000000000000000080
+ 000000000000000000000000000000000000000000000000000000000000000a
+ 5465737420555249203000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000030
+ 1111111111111111111111111111111111111111111111111111111111111111
+ 1111111111111111111111111111111100000000000000000000000000000000
+
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 0000000000000000000000000000000000000000000000000000000000000080
+ 000000000000000000000000000000000000000000000000000000000000000a
+ 5465737420555249203100000000000000000000000000000000000000000000
+ 000000000000000000000000000000000000000000000000000000000000002f
+ 2222222222222222222222222222222222222222222222222222222222222222
+ 2222222222222222222222222222220000000000000000000000000000000000
+
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 0000000000000000000000000000000000000000000000000000000000000080
+ 000000000000000000000000000000000000000000000000000000000000000a
+ 5465737420555249203200000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000002
+ 3333000000000000000000000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
+
+#[test]
+// #[ignore = "reason"]
+fn encode_decode_tuple0_tuple1_uint8_tuple1_string_bytes_tuple1_uint8_bytes() {
+ let int = 0xff;
+ let by = bytes(vec![0x11, 0x22, 0x33]);
+ let string = "some string".to_string();
+
+ test_impl::<((u8,), (String, bytes), (u8, bytes))>(
+ 0xdeadbeef,
+ ((int,), (string.clone(), by.clone()), (int, by)),
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 00000000000000000000000000000000000000000000000000000000000000ff
+ 0000000000000000000000000000000000000000000000000000000000000060
+ 0000000000000000000000000000000000000000000000000000000000000120
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 0000000000000000000000000000000000000000000000000000000000000080
+ 000000000000000000000000000000000000000000000000000000000000000b
+ 736f6d6520737472696e67000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000003
+ 1122330000000000000000000000000000000000000000000000000000000000
+ 00000000000000000000000000000000000000000000000000000000000000ff
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 0000000000000000000000000000000000000000000000000000000000000003
+ 1122330000000000000000000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
+
+#[test]
+fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8_uint8_tuple1_uint8_uint8() {
+ test_impl::<((u8,), (u8, u8), (u8, u8))>(
+ 0xdeadbeef,
+ ((43,), (44, 45), (46, 47)),
+ &hex!(
+ "
+ deadbeef
+ 000000000000000000000000000000000000000000000000000000000000002b
+ 000000000000000000000000000000000000000000000000000000000000002c
+ 000000000000000000000000000000000000000000000000000000000000002d
+ 000000000000000000000000000000000000000000000000000000000000002e
+ 000000000000000000000000000000000000000000000000000000000000002f
+ "
+ ),
+ );
+}
+
+#[test]
+fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8() {
+ test_impl::<((u8,), (u8,))>(
+ 0xdeadbeef,
+ ((43,), (44,)),
+ &hex!(
+ "
+ deadbeef
+ 000000000000000000000000000000000000000000000000000000000000002b
+ 000000000000000000000000000000000000000000000000000000000000002c
+ "
+ ),
+ );
+}
+
+#[test]
+fn encode_decode_tuple0_tuple1_uint8_uint8() {
+ test_impl::<((u8, u8),)>(
+ 0xdeadbeef,
+ ((43, 44),),
+ &hex!(
+ "
+ deadbeef
+ 000000000000000000000000000000000000000000000000000000000000002b
+ 000000000000000000000000000000000000000000000000000000000000002c
+ "
+ ),
+ );
+}
+
+#[test]
+fn encode_decode_tuple_uint8_uint8() {
+ test_impl::<(u8, u8)>(
+ 0xdeadbeef,
+ (43, 44),
+ &hex!(
+ "
+ deadbeef
+ 000000000000000000000000000000000000000000000000000000000000002b
+ 000000000000000000000000000000000000000000000000000000000000002c
+ "
+ ),
+ );
+}
+
+#[test]
+fn encode_decode_tuple0_tuple1_uint8_uint8_tuple1_uint8_uint8_and_uint8() {
+ test_impl::<((u8, u8), (u8, u8), u8)>(
+ 0xdeadbeef,
+ ((10, 11), (12, 13), 14),
+ &hex!(
+ "
+ deadbeef
+ 000000000000000000000000000000000000000000000000000000000000000a
+ 000000000000000000000000000000000000000000000000000000000000000b
+ 000000000000000000000000000000000000000000000000000000000000000c
+ 000000000000000000000000000000000000000000000000000000000000000d
+ 000000000000000000000000000000000000000000000000000000000000000e
+ "
),
- (
- "Test URI 1".to_string(),
- bytes(vec![
- 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
- 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
- 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
- 0x22, 0x22, 0x22, 0x22, 0x22
- ])
+ );
+}
+
+#[test]
+fn encode_decode_tuple0_tuple1_string() {
+ test_impl::<((String,),)>(
+ 0xdeadbeef,
+ (("some string".to_string(),),),
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 000000000000000000000000000000000000000000000000000000000000000b
+ 736f6d6520737472696e67000000000000000000000000000000000000000000
+ "
),
- ("Test URI 2".to_string(), bytes(vec![0x33, 0x33])),
- ],
- &hex!(
- "
- deadbeef
- 0000000000000000000000000000000000000000000000000000000000000020
- 0000000000000000000000000000000000000000000000000000000000000003
-
- 0000000000000000000000000000000000000000000000000000000000000060
- 0000000000000000000000000000000000000000000000000000000000000140
- 0000000000000000000000000000000000000000000000000000000000000220
+ );
+}
- 0000000000000000000000000000000000000000000000000000000000000040
- 0000000000000000000000000000000000000000000000000000000000000080
- 000000000000000000000000000000000000000000000000000000000000000a
- 5465737420555249203000000000000000000000000000000000000000000000
- 0000000000000000000000000000000000000000000000000000000000000030
- 1111111111111111111111111111111111111111111111111111111111111111
- 1111111111111111111111111111111100000000000000000000000000000000
+#[test]
+fn encode_decode_tuple0_tuple1_uint8_string() {
+ test_impl::<((u8, String),)>(
+ 0xdeadbeef,
+ ((0xff, "some string".to_string()),),
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 00000000000000000000000000000000000000000000000000000000000000ff
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 000000000000000000000000000000000000000000000000000000000000000b
+ 736f6d6520737472696e67000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
- 0000000000000000000000000000000000000000000000000000000000000040
- 0000000000000000000000000000000000000000000000000000000000000080
- 000000000000000000000000000000000000000000000000000000000000000a
- 5465737420555249203100000000000000000000000000000000000000000000
- 000000000000000000000000000000000000000000000000000000000000002f
- 2222222222222222222222222222222222222222222222222222222222222222
- 2222222222222222222222222222220000000000000000000000000000000000
+#[test]
+fn encode_decode_tuple0_tuple1_string_bytes() {
+ test_impl::<((String, bytes),)>(
+ 0xdeadbeef,
+ (("some string".to_string(), bytes(vec![1, 2, 3])),),
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 0000000000000000000000000000000000000000000000000000000000000080
+ 000000000000000000000000000000000000000000000000000000000000000b
+ 736f6d6520737472696e67000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000003
+ 0102030000000000000000000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
- 0000000000000000000000000000000000000000000000000000000000000040
- 0000000000000000000000000000000000000000000000000000000000000080
+#[test]
+fn encode_decode_tuple0_tuple1_uint8_tuple1_string() {
+ test_impl::<((u8,), (String,))>(
+ 0xdeadbeef,
+ ((0xff,), ("some string".to_string(),)),
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 00000000000000000000000000000000000000000000000000000000000000ff
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 000000000000000000000000000000000000000000000000000000000000000b
+ 736f6d6520737472696e67000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
+
+#[test]
+fn parse_multiple_params() {
+ let encoded_data = hex!(
+ "
+ deadbeef
000000000000000000000000000000000000000000000000000000000000000a
- 5465737420555249203200000000000000000000000000000000000000000000
- 0000000000000000000000000000000000000000000000000000000000000002
- 3333000000000000000000000000000000000000000000000000000000000000
+ 000000000000000000000000000000000000000000000000000000000000000b
"
- )
-);
+ );
+ let (_, mut decoder) = AbiReader::new_call(&encoded_data).unwrap();
+ let p1 = <u8>::abi_read(&mut decoder).unwrap();
+ let p2 = <u8>::abi_read(&mut decoder).unwrap();
+ assert_eq!(p1, 0x0a);
+ assert_eq!(p2, 0x0b);
+}
crates/evm-coder/src/abi/traits.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/traits.rs
+++ b/crates/evm-coder/src/abi/traits.rs
@@ -22,12 +22,6 @@
fn size() -> usize;
}
-/// Sealed traits.
-pub mod sealed {
- /// Not all types can be placed in vec, i.e `Vec<u8>` is restricted, `bytes` should be used instead
- pub trait CanBePlacedInVec {}
-}
-
/// [`AbiReader`] implements reading of many types.
pub trait AbiRead {
/// Read item from current position, advanding decoder
@@ -47,11 +41,5 @@
let mut writer = AbiWriter::new();
self.abi_write(&mut writer);
Ok(writer.into())
- }
-}
-
-impl<T: AbiWrite> AbiWrite for &T {
- fn abi_write(&self, writer: &mut AbiWriter) {
- T::abi_write(self, writer);
}
}
crates/evm-coder/src/lib.rsdiffbeforeafterboth--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -93,6 +93,7 @@
pub use evm_coder_procedural::solidity;
/// See [`solidity_interface`]
pub use evm_coder_procedural::weight;
+pub use evm_coder_procedural::AbiCoder;
pub use sha3_const;
/// Derives [`ToLog`] for enum
@@ -111,6 +112,15 @@
#[cfg(feature = "stubgen")]
pub mod solidity;
+/// Sealed traits.
+pub mod sealed {
+ /// Not every type should be directly placed in vec.
+ /// Vec encoding is not memory efficient, as every item will be padded
+ /// to 32 bytes.
+ /// Instead you should use specialized types (`bytes` in case of `Vec<u8>`)
+ pub trait CanBePlacedInVec {}
+}
+
/// Solidity type definitions (aliases from solidity name to rust type)
/// To be used in [`solidity_interface`] definitions, to make sure there is no
/// type conflict between Rust code and generated definitions
@@ -119,7 +129,6 @@
#[cfg(not(feature = "std"))]
use alloc::{vec::Vec};
- use pallet_evm::account::CrossAccountId;
use primitive_types::{U256, H160, H256};
pub type address = H160;
@@ -137,7 +146,7 @@
#[cfg(feature = "std")]
pub type string = ::std::string::String;
- #[derive(Default, Debug, PartialEq)]
+ #[derive(Default, Debug, PartialEq, Eq, Clone)]
pub struct bytes(pub Vec<u8>);
/// Solidity doesn't have `void` type, however we have special implementation
@@ -185,73 +194,7 @@
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
- }
- }
-
- #[derive(Debug, Default)]
- pub struct EthCrossAccount {
- pub(crate) eth: address,
- pub(crate) sub: uint256,
- }
-
- impl EthCrossAccount {
- pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self
- where
- T: pallet_evm::Config,
- T::AccountId: AsRef<[u8; 32]>,
- {
- if cross_account_id.is_canonical_substrate() {
- Self {
- eth: Default::default(),
- sub: convert_cross_account_to_uint256::<T>(cross_account_id),
- }
- } else {
- Self {
- eth: *cross_account_id.as_eth(),
- sub: Default::default(),
- }
- }
}
-
- pub fn into_sub_cross_account<T>(&self) -> crate::execution::Result<T::CrossAccountId>
- where
- T: pallet_evm::Config,
- T::AccountId: From<[u8; 32]>,
- {
- if self.eth == Default::default() && self.sub == Default::default() {
- Err("All fields of cross account is zeroed".into())
- } else if self.eth == Default::default() {
- Ok(convert_uint256_to_cross_account::<T>(self.sub))
- } else if self.sub == Default::default() {
- Ok(T::CrossAccountId::from_eth(self.eth))
- } else {
- Err("All fields of cross account is non zeroed".into())
- }
- }
- }
-
- /// Convert `CrossAccountId` to `uint256`.
- pub fn convert_cross_account_to_uint256<T: pallet_evm::Config>(
- from: &T::CrossAccountId,
- ) -> uint256
- where
- T::AccountId: AsRef<[u8; 32]>,
- {
- let slice = from.as_sub().as_ref();
- uint256::from_big_endian(slice)
- }
-
- /// Convert `uint256` to `CrossAccountId`.
- pub fn convert_uint256_to_cross_account<T: pallet_evm::Config>(
- from: uint256,
- ) -> T::CrossAccountId
- where
- T::AccountId: From<[u8; 32]>,
- {
- let mut new_admin_arr = [0_u8; 32];
- from.to_big_endian(&mut new_admin_arr);
- let account_id = T::AccountId::from(new_admin_arr);
- T::CrossAccountId::from_sub(account_id)
}
#[derive(Debug, Default)]
crates/evm-coder/src/solidity.rsdiffbeforeafterboth--- a/crates/evm-coder/src/solidity.rs
+++ /dev/null
@@ -1,702 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-//! Implementation detail of [`crate::solidity_interface`] macro code-generation.
-//! You should not rely on any public item from this module, as it is only intended to be used
-//! by procedural macro, API and output format may be changed at any time.
-//!
-//! Purpose of this module is to receive solidity contract definition in module-specified
-//! format, and then output string, representing interface of this contract in solidity language
-
-#[cfg(not(feature = "std"))]
-use alloc::{string::String, vec::Vec, collections::BTreeMap, format};
-#[cfg(feature = "std")]
-use std::collections::BTreeMap;
-use core::{
- fmt::{self, Write},
- marker::PhantomData,
- cell::{Cell, RefCell},
- cmp::Reverse,
-};
-use impl_trait_for_tuples::impl_for_tuples;
-use crate::{types::*, custom_signature::SignatureUnit};
-
-#[derive(Default)]
-pub struct TypeCollector {
- /// Code => id
- /// id ordering is required to perform topo-sort on the resulting data
- structs: RefCell<BTreeMap<string, usize>>,
- anonymous: RefCell<BTreeMap<Vec<string>, usize>>,
- id: Cell<usize>,
-}
-impl TypeCollector {
- pub fn new() -> Self {
- Self::default()
- }
- pub fn collect(&self, item: string) {
- let id = self.next_id();
- self.structs.borrow_mut().insert(item, id);
- }
- 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, "/// @dev 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 collect_struct<T: StructCollect>(&self) -> String {
- self.collect(<T as StructCollect>::declaration());
- <T as StructCollect>::name()
- }
- pub fn finish(self) -> Vec<string> {
- let mut data = self.structs.into_inner().into_iter().collect::<Vec<_>>();
- data.sort_by_key(|(_, id)| Reverse(*id));
- data.into_iter().map(|(code, _)| code).collect()
- }
-}
-
-pub trait StructCollect: 'static {
- /// Structure name.
- fn name() -> String;
- /// Structure declaration.
- fn declaration() -> String;
-}
-
-pub trait SolidityTypeName: 'static {
- fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
- /// "simple" types are stored inline, no `memory` modifier should be used in solidity
- fn is_simple() -> bool;
- fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
- /// Specialization
- fn is_void() -> bool {
- false
- }
-}
-macro_rules! solidity_type_name {
- ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {
- $(
- impl SolidityTypeName for $ty {
- fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
- write!(writer, $name)
- }
- fn is_simple() -> bool {
- $simple
- }
- fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
- write!(writer, $default)
- }
- }
- )*
- };
-}
-
-solidity_type_name! {
- uint8 => "uint8" true = "0",
- uint32 => "uint32" true = "0",
- uint64 => "uint64" true = "0",
- uint128 => "uint128" true = "0",
- uint256 => "uint256" true = "0",
- bytes4 => "bytes4" true = "bytes4(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, _tc: &TypeCollector) -> fmt::Result {
- Ok(())
- }
- fn is_simple() -> bool {
- true
- }
- fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
- Ok(())
- }
- fn is_void() -> bool {
- true
- }
-}
-
-mod sealed {
- /// Not every type should be directly placed in vec.
- /// Vec encoding is not memory efficient, as every item will be padded
- /// to 32 bytes.
- /// Instead you should use specialized types (`bytes` in case of `Vec<u8>`)
- pub trait CanBePlacedInVec {}
-}
-
-impl sealed::CanBePlacedInVec for uint256 {}
-impl sealed::CanBePlacedInVec for string {}
-impl sealed::CanBePlacedInVec for address {}
-impl sealed::CanBePlacedInVec for EthCrossAccount {}
-impl sealed::CanBePlacedInVec for Property {}
-
-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, "new ")?;
- T::solidity_name(writer, tc)?;
- write!(writer, "[](0)")
- }
-}
-
-impl SolidityTupleType for EthCrossAccount {
- fn names(tc: &TypeCollector) -> Vec<string> {
- let mut collected = Vec::with_capacity(Self::len());
- {
- let mut out = string::new();
- address::solidity_name(&mut out, tc).expect("no fmt error");
- collected.push(out);
- }
- {
- let mut out = string::new();
- uint256::solidity_name(&mut out, tc).expect("no fmt error");
- collected.push(out);
- }
- collected
- }
-
- fn len() -> usize {
- 2
- }
-}
-
-impl SolidityTypeName for EthCrossAccount {
- fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
- write!(writer, "{}", tc.collect_struct::<Self>())
- }
-
- fn is_simple() -> bool {
- false
- }
-
- fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
- write!(writer, "{}(", tc.collect_struct::<Self>())?;
- address::solidity_default(writer, tc)?;
- write!(writer, ",")?;
- uint256::solidity_default(writer, tc)?;
- write!(writer, ")")
- }
-}
-
-impl StructCollect for EthCrossAccount {
- fn name() -> String {
- "EthCrossAccount".into()
- }
-
- fn declaration() -> String {
- let mut str = String::new();
- writeln!(str, "/// @dev Cross account struct").unwrap();
- writeln!(str, "struct {} {{", Self::name()).unwrap();
- writeln!(str, "\taddress eth;").unwrap();
- writeln!(str, "\tuint256 sub;").unwrap();
- writeln!(str, "}}").unwrap();
- str
- }
-}
-
-impl StructCollect for Property {
- fn name() -> String {
- "Property".into()
- }
-
- fn declaration() -> String {
- let mut str = String::new();
- writeln!(str, "/// @dev Property struct").unwrap();
- writeln!(str, "struct {} {{", Self::name()).unwrap();
- writeln!(str, "\tstring key;").unwrap();
- writeln!(str, "\tbytes value;").unwrap();
- writeln!(str, "}}").unwrap();
- str
- }
-}
-
-impl SolidityTypeName for Property {
- fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
- write!(writer, "{}", tc.collect_struct::<Self>())
- }
-
- fn is_simple() -> bool {
- false
- }
-
- fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
- write!(writer, "{}(", tc.collect_struct::<Self>())?;
- address::solidity_default(writer, tc)?;
- write!(writer, ",")?;
- uint256::solidity_default(writer, tc)?;
- write!(writer, ")")
- }
-}
-
-impl SolidityTupleType for Property {
- fn names(tc: &TypeCollector) -> Vec<string> {
- let mut collected = Vec::with_capacity(Self::len());
- {
- let mut out = string::new();
- string::solidity_name(&mut out, tc).expect("no fmt error");
- collected.push(out);
- }
- {
- let mut out = string::new();
- bytes::solidity_name(&mut out, tc).expect("no fmt error");
- collected.push(out);
- }
- collected
- }
-
- fn len() -> usize {
- 2
- }
-}
-
-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
- }
- #[allow(unused_assignments)]
- fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
- write!(writer, "{}(", tc.collect_tuple::<Self>())?;
- let mut first = true;
- $(
- if !first {
- write!(writer, ",")?;
- } else {
- first = false;
- }
- <$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, tc: &TypeCollector) -> fmt::Result;
- fn solidity_get(&self, prefix: &str, 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
- }
- fn len(&self) -> usize;
-}
-
-#[derive(Default)]
-pub struct UnnamedArgument<T>(PhantomData<*const T>);
-
-impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {
- fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
- if !T::is_void() {
- T::solidity_name(writer, tc)?;
- if !T::is_simple() {
- write!(writer, " memory")?;
- }
- Ok(())
- } else {
- Ok(())
- }
- }
- fn solidity_get(&self, _prefix: &str, _writer: &mut impl fmt::Write) -> fmt::Result {
- Ok(())
- }
- 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() {
- 0
- } else {
- 1
- }
- }
-}
-
-pub struct NamedArgument<T>(&'static str, PhantomData<*const T>);
-
-impl<T> NamedArgument<T> {
- pub fn new(name: &'static str) -> Self {
- Self(name, Default::default())
- }
-}
-
-impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {
- fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
- if !T::is_void() {
- T::solidity_name(writer, tc)?;
- if !T::is_simple() {
- write!(writer, " memory")?;
- }
- write!(writer, " {}", self.0)
- } else {
- Ok(())
- }
- }
- fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
- writeln!(writer, "\t{prefix}\t{};", self.0)
- }
- 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() {
- 0
- } else {
- 1
- }
- }
-}
-
-pub struct SolidityEventArgument<T>(pub bool, &'static str, PhantomData<*const T>);
-
-impl<T> SolidityEventArgument<T> {
- pub fn new(indexed: bool, name: &'static str) -> Self {
- Self(indexed, name, Default::default())
- }
-}
-
-impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {
- fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
- if !T::is_void() {
- T::solidity_name(writer, tc)?;
- if self.0 {
- write!(writer, " indexed")?;
- }
- write!(writer, " {}", self.1)
- } else {
- Ok(())
- }
- }
- fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
- writeln!(writer, "\t{prefix}\t{};", self.1)
- }
- 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() {
- 0
- } else {
- 1
- }
- }
-}
-
-impl SolidityArguments for () {
- fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
- Ok(())
- }
- fn solidity_get(&self, _prefix: &str, _writer: &mut impl fmt::Write) -> fmt::Result {
- Ok(())
- }
- fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
- Ok(())
- }
- fn len(&self) -> usize {
- 0
- }
-}
-
-#[impl_for_tuples(1, 12)]
-impl SolidityArguments for Tuple {
- for_tuples!( where #( Tuple: SolidityArguments ),* );
-
- fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
- let mut first = true;
- for_tuples!( #(
- if !Tuple.is_empty() {
- if !first {
- write!(writer, ", ")?;
- }
- first = false;
- Tuple.solidity_name(writer, tc)?;
- }
- )* );
- Ok(())
- }
- fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
- for_tuples!( #(
- Tuple.solidity_get(prefix, writer)?;
- )* );
- Ok(())
- }
- 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, tc)?;
- )* );
- Ok(())
- } else {
- write!(writer, "(")?;
- let mut first = true;
- for_tuples!( #(
- if !Tuple.is_empty() {
- if !first {
- write!(writer, ", ")?;
- }
- first = false;
- Tuple.solidity_default(writer, tc)?;
- }
- )* );
- write!(writer, ")")?;
- Ok(())
- }
- }
- fn len(&self) -> usize {
- for_tuples!( #( Tuple.len() )+* )
- }
-}
-
-pub trait SolidityFunctions {
- fn solidity_name(
- &self,
- is_impl: bool,
- writer: &mut impl fmt::Write,
- tc: &TypeCollector,
- ) -> fmt::Result;
-}
-
-pub enum SolidityMutability {
- Pure,
- View,
- Mutable,
-}
-pub struct SolidityFunction<A, R> {
- pub docs: &'static [&'static str],
- pub selector: u32,
- pub hide: bool,
- pub custom_signature: SignatureUnit,
- pub name: &'static str,
- pub args: A,
- pub result: R,
- pub mutability: SolidityMutability,
- pub is_payable: bool,
-}
-impl<A: SolidityArguments, R: SolidityArguments> SolidityFunctions for SolidityFunction<A, R> {
- fn solidity_name(
- &self,
- is_impl: bool,
- writer: &mut impl fmt::Write,
- tc: &TypeCollector,
- ) -> fmt::Result {
- let hide_comment = self.hide.then(|| "// ").unwrap_or("");
- for doc in self.docs {
- writeln!(writer, "\t{hide_comment}///{}", doc)?;
- }
- writeln!(
- writer,
- "\t{hide_comment}/// @dev EVM selector for this function is: 0x{:0>8x},",
- self.selector
- )?;
- writeln!(
- writer,
- "\t{hide_comment}/// or in textual repr: {}",
- self.custom_signature.as_str().expect("bad utf-8")
- )?;
- write!(writer, "\t{hide_comment}function {}(", self.name)?;
- self.args.solidity_name(writer, tc)?;
- write!(writer, ")")?;
- if is_impl {
- write!(writer, " public")?;
- } else {
- write!(writer, " external")?;
- }
- match &self.mutability {
- SolidityMutability::Pure => write!(writer, " pure")?,
- SolidityMutability::View => write!(writer, " view")?,
- SolidityMutability::Mutable => {}
- }
- if self.is_payable {
- write!(writer, " payable")?;
- }
- if !self.result.is_empty() {
- write!(writer, " returns (")?;
- self.result.solidity_name(writer, tc)?;
- write!(writer, ")")?;
- }
- if is_impl {
- writeln!(writer, " {{")?;
- writeln!(writer, "\t{hide_comment}\trequire(false, stub_error);")?;
- self.args.solidity_get(hide_comment, writer)?;
- match &self.mutability {
- SolidityMutability::Pure => {}
- SolidityMutability::View => writeln!(writer, "\t{hide_comment}\tdummy;")?,
- SolidityMutability::Mutable => writeln!(writer, "\t{hide_comment}\tdummy = 0;")?,
- }
- if !self.result.is_empty() {
- write!(writer, "\t{hide_comment}\treturn ")?;
- self.result.solidity_default(writer, tc)?;
- writeln!(writer, ";")?;
- }
- writeln!(writer, "\t{hide_comment}}}")?;
- } else {
- writeln!(writer, ";")?;
- }
- if self.hide {
- writeln!(writer, "// FORMATTING: FORCE NEWLINE")?;
- }
- Ok(())
- }
-}
-
-#[impl_for_tuples(0, 48)]
-impl SolidityFunctions for Tuple {
- for_tuples!( where #( Tuple: SolidityFunctions ),* );
-
- 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, tc)?;
- )* );
- Ok(())
- }
-}
-
-pub struct SolidityInterface<F: SolidityFunctions> {
- pub docs: &'static [&'static str],
- pub selector: bytes4,
- pub name: &'static str,
- pub is: &'static [&'static str],
- pub functions: F,
-}
-
-impl<F: SolidityFunctions> SolidityInterface<F> {
- pub fn format(
- &self,
- is_impl: bool,
- out: &mut impl fmt::Write,
- tc: &TypeCollector,
- ) -> fmt::Result {
- const ZERO_BYTES: [u8; 4] = [0; 4];
- for doc in self.docs {
- writeln!(out, "///{}", doc)?;
- }
- if self.selector != ZERO_BYTES {
- writeln!(
- out,
- "/// @dev the ERC-165 identifier for this interface is 0x{:0>8x}",
- u32::from_be_bytes(self.selector)
- )?;
- }
- if is_impl {
- write!(out, "contract ")?;
- } else {
- write!(out, "interface ")?;
- }
- write!(out, "{}", self.name)?;
- if !self.is.is_empty() {
- write!(out, " is")?;
- for (i, n) in self.is.iter().enumerate() {
- if i != 0 {
- write!(out, ",")?;
- }
- write!(out, " {}", n)?;
- }
- }
- writeln!(out, " {{")?;
- self.functions.solidity_name(is_impl, out, tc)?;
- writeln!(out, "}}")?;
- Ok(())
- }
-}
-
-pub struct SolidityEvent<A> {
- pub name: &'static str,
- pub args: A,
-}
-
-impl<A: SolidityArguments> SolidityFunctions for SolidityEvent<A> {
- 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, tc)?;
- writeln!(writer, ");")
- }
-}
crates/evm-coder/src/solidity/impls.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/src/solidity/impls.rs
@@ -0,0 +1,190 @@
+use super::{TypeCollector, SolidityTypeName, SolidityType, StructCollect};
+use crate::{sealed, types::*};
+use core::fmt;
+use primitive_types::{U256, H160};
+
+macro_rules! solidity_type_name {
+ ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {
+ $(
+ impl SolidityTypeName for $ty {
+ fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
+ write!(writer, $name)
+ }
+ fn is_simple() -> bool {
+ $simple
+ }
+ fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
+ write!(writer, $default)
+ }
+ }
+
+ impl StructCollect for $ty {
+ fn name() -> String {
+ $name.to_string()
+ }
+
+ fn declaration() -> String {
+ String::default()
+ }
+ }
+ )*
+ };
+}
+
+solidity_type_name! {
+ u8 => "uint8" true = "0",
+ u32 => "uint32" true = "0",
+ u64 => "uint64" true = "0",
+ u128 => "uint128" true = "0",
+ U256 => "uint256" true = "0",
+ bytes4 => "bytes4" true = "bytes4(0)",
+ H160 => "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, _tc: &TypeCollector) -> fmt::Result {
+ Ok(())
+ }
+ fn is_simple() -> bool {
+ true
+ }
+ fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
+ Ok(())
+ }
+ fn is_void() -> bool {
+ true
+ }
+}
+
+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, "new ")?;
+ T::solidity_name(writer, tc)?;
+ write!(writer, "[](0)")
+ }
+}
+
+macro_rules! count {
+ () => (0usize);
+ ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));
+}
+
+macro_rules! impl_tuples {
+ ($($ident:ident)+) => {
+ impl<$($ident: SolidityTypeName + 'static),+> SolidityType 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
+ }
+ #[allow(unused_assignments)]
+ fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ write!(writer, "{}(", tc.collect_tuple::<Self>())?;
+ let mut first = true;
+ $(
+ if !first {
+ write!(writer, ",")?;
+ } else {
+ first = false;
+ }
+ <$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}
+
+impl StructCollect for Property {
+ fn name() -> String {
+ "Property".into()
+ }
+
+ fn declaration() -> String {
+ use std::fmt::Write;
+
+ let mut str = String::new();
+ writeln!(str, "/// @dev Property struct").unwrap();
+ writeln!(str, "struct {} {{", Self::name()).unwrap();
+ writeln!(str, "\tstring key;").unwrap();
+ writeln!(str, "\tbytes value;").unwrap();
+ writeln!(str, "}}").unwrap();
+ str
+ }
+}
+
+impl SolidityTypeName for Property {
+ fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ write!(writer, "{}", tc.collect_struct::<Self>())
+ }
+
+ fn is_simple() -> bool {
+ false
+ }
+
+ fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ write!(writer, "{}(", tc.collect_struct::<Self>())?;
+ address::solidity_default(writer, tc)?;
+ write!(writer, ",")?;
+ uint256::solidity_default(writer, tc)?;
+ write!(writer, ")")
+ }
+}
+
+impl SolidityType for Property {
+ fn names(tc: &TypeCollector) -> Vec<string> {
+ let mut collected = Vec::with_capacity(Self::len());
+ {
+ let mut out = string::new();
+ string::solidity_name(&mut out, tc).expect("no fmt error");
+ collected.push(out);
+ }
+ {
+ let mut out = string::new();
+ bytes::solidity_name(&mut out, tc).expect("no fmt error");
+ collected.push(out);
+ }
+ collected
+ }
+
+ fn len() -> usize {
+ 2
+ }
+}
crates/evm-coder/src/solidity/mod.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/src/solidity/mod.rs
@@ -0,0 +1,421 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+//! Implementation detail of [`crate::solidity_interface`] macro code-generation.
+//! You should not rely on any public item from this module, as it is only intended to be used
+//! by procedural macro, API and output format may be changed at any time.
+//!
+//! Purpose of this module is to receive solidity contract definition in module-specified
+//! format, and then output string, representing interface of this contract in solidity language
+
+mod traits;
+pub use traits::*;
+mod impls;
+
+#[cfg(not(feature = "std"))]
+use alloc::{string::String, vec::Vec, collections::BTreeMap, format};
+#[cfg(feature = "std")]
+use std::collections::BTreeMap;
+use core::{
+ fmt::{self, Write},
+ marker::PhantomData,
+ cell::{Cell, RefCell},
+ cmp::Reverse,
+};
+use impl_trait_for_tuples::impl_for_tuples;
+use crate::{types::*, custom_signature::SignatureUnit};
+
+#[derive(Default)]
+pub struct TypeCollector {
+ /// Code => id
+ /// id ordering is required to perform topo-sort on the resulting data
+ structs: RefCell<BTreeMap<string, usize>>,
+ anonymous: RefCell<BTreeMap<Vec<string>, usize>>,
+ id: Cell<usize>,
+}
+impl TypeCollector {
+ pub fn new() -> Self {
+ Self::default()
+ }
+ pub fn collect(&self, item: string) {
+ let id = self.next_id();
+ self.structs.borrow_mut().insert(item, id);
+ }
+ pub fn next_id(&self) -> usize {
+ let v = self.id.get();
+ self.id.set(v + 1);
+ v
+ }
+ pub fn collect_tuple<T: SolidityType>(&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, "/// @dev 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 collect_struct<T: StructCollect>(&self) -> String {
+ self.collect(<T as StructCollect>::declaration());
+ <T as StructCollect>::name()
+ }
+ pub fn finish(self) -> Vec<string> {
+ let mut data = self.structs.into_inner().into_iter().collect::<Vec<_>>();
+ data.sort_by_key(|(_, id)| Reverse(*id));
+ data.into_iter().map(|(code, _)| code).collect()
+ }
+}
+#[derive(Default)]
+pub struct UnnamedArgument<T>(PhantomData<*const T>);
+
+impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ if !T::is_void() {
+ T::solidity_name(writer, tc)?;
+ if !T::is_simple() {
+ write!(writer, " memory")?;
+ }
+ Ok(())
+ } else {
+ Ok(())
+ }
+ }
+ fn solidity_get(&self, _prefix: &str, _writer: &mut impl fmt::Write) -> fmt::Result {
+ Ok(())
+ }
+ 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() {
+ 0
+ } else {
+ 1
+ }
+ }
+}
+
+pub struct NamedArgument<T>(&'static str, PhantomData<*const T>);
+
+impl<T> NamedArgument<T> {
+ pub fn new(name: &'static str) -> Self {
+ Self(name, Default::default())
+ }
+}
+
+impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ if !T::is_void() {
+ T::solidity_name(writer, tc)?;
+ if !T::is_simple() {
+ write!(writer, " memory")?;
+ }
+ write!(writer, " {}", self.0)
+ } else {
+ Ok(())
+ }
+ }
+ fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
+ writeln!(writer, "\t{prefix}\t{};", self.0)
+ }
+ 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() {
+ 0
+ } else {
+ 1
+ }
+ }
+}
+
+pub struct SolidityEventArgument<T>(pub bool, &'static str, PhantomData<*const T>);
+
+impl<T> SolidityEventArgument<T> {
+ pub fn new(indexed: bool, name: &'static str) -> Self {
+ Self(indexed, name, Default::default())
+ }
+}
+
+impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ if !T::is_void() {
+ T::solidity_name(writer, tc)?;
+ if self.0 {
+ write!(writer, " indexed")?;
+ }
+ write!(writer, " {}", self.1)
+ } else {
+ Ok(())
+ }
+ }
+ fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
+ writeln!(writer, "\t{prefix}\t{};", self.1)
+ }
+ 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() {
+ 0
+ } else {
+ 1
+ }
+ }
+}
+
+impl SolidityArguments for () {
+ fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
+ Ok(())
+ }
+ fn solidity_get(&self, _prefix: &str, _writer: &mut impl fmt::Write) -> fmt::Result {
+ Ok(())
+ }
+ fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
+ Ok(())
+ }
+ fn len(&self) -> usize {
+ 0
+ }
+}
+
+#[impl_for_tuples(1, 12)]
+impl SolidityArguments for Tuple {
+ for_tuples!( where #( Tuple: SolidityArguments ),* );
+
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
+ let mut first = true;
+ for_tuples!( #(
+ if !Tuple.is_empty() {
+ if !first {
+ write!(writer, ", ")?;
+ }
+ first = false;
+ Tuple.solidity_name(writer, tc)?;
+ }
+ )* );
+ Ok(())
+ }
+ fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
+ for_tuples!( #(
+ Tuple.solidity_get(prefix, writer)?;
+ )* );
+ Ok(())
+ }
+ 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, tc)?;
+ )* );
+ Ok(())
+ } else {
+ write!(writer, "(")?;
+ let mut first = true;
+ for_tuples!( #(
+ if !Tuple.is_empty() {
+ if !first {
+ write!(writer, ", ")?;
+ }
+ first = false;
+ Tuple.solidity_default(writer, tc)?;
+ }
+ )* );
+ write!(writer, ")")?;
+ Ok(())
+ }
+ }
+ fn len(&self) -> usize {
+ for_tuples!( #( Tuple.len() )+* )
+ }
+}
+
+pub enum SolidityMutability {
+ Pure,
+ View,
+ Mutable,
+}
+pub struct SolidityFunction<A, R> {
+ pub docs: &'static [&'static str],
+ pub selector: u32,
+ pub hide: bool,
+ pub custom_signature: SignatureUnit,
+ pub name: &'static str,
+ pub args: A,
+ pub result: R,
+ pub mutability: SolidityMutability,
+ pub is_payable: bool,
+}
+impl<A: SolidityArguments, R: SolidityArguments> SolidityFunctions for SolidityFunction<A, R> {
+ fn solidity_name(
+ &self,
+ is_impl: bool,
+ writer: &mut impl fmt::Write,
+ tc: &TypeCollector,
+ ) -> fmt::Result {
+ let hide_comment = self.hide.then_some("// ").unwrap_or("");
+ for doc in self.docs {
+ writeln!(writer, "\t{hide_comment}///{}", doc)?;
+ }
+ writeln!(
+ writer,
+ "\t{hide_comment}/// @dev EVM selector for this function is: 0x{:0>8x},",
+ self.selector
+ )?;
+ writeln!(
+ writer,
+ "\t{hide_comment}/// or in textual repr: {}",
+ self.custom_signature.as_str().expect("bad utf-8")
+ )?;
+ write!(writer, "\t{hide_comment}function {}(", self.name)?;
+ self.args.solidity_name(writer, tc)?;
+ write!(writer, ")")?;
+ if is_impl {
+ write!(writer, " public")?;
+ } else {
+ write!(writer, " external")?;
+ }
+ match &self.mutability {
+ SolidityMutability::Pure => write!(writer, " pure")?,
+ SolidityMutability::View => write!(writer, " view")?,
+ SolidityMutability::Mutable => {}
+ }
+ if self.is_payable {
+ write!(writer, " payable")?;
+ }
+ if !self.result.is_empty() {
+ write!(writer, " returns (")?;
+ self.result.solidity_name(writer, tc)?;
+ write!(writer, ")")?;
+ }
+ if is_impl {
+ writeln!(writer, " {{")?;
+ writeln!(writer, "\t{hide_comment}\trequire(false, stub_error);")?;
+ self.args.solidity_get(hide_comment, writer)?;
+ match &self.mutability {
+ SolidityMutability::Pure => {}
+ SolidityMutability::View => writeln!(writer, "\t{hide_comment}\tdummy;")?,
+ SolidityMutability::Mutable => writeln!(writer, "\t{hide_comment}\tdummy = 0;")?,
+ }
+ if !self.result.is_empty() {
+ write!(writer, "\t{hide_comment}\treturn ")?;
+ self.result.solidity_default(writer, tc)?;
+ writeln!(writer, ";")?;
+ }
+ writeln!(writer, "\t{hide_comment}}}")?;
+ } else {
+ writeln!(writer, ";")?;
+ }
+ if self.hide {
+ writeln!(writer, "// FORMATTING: FORCE NEWLINE")?;
+ }
+ Ok(())
+ }
+}
+
+#[impl_for_tuples(0, 48)]
+impl SolidityFunctions for Tuple {
+ for_tuples!( where #( Tuple: SolidityFunctions ),* );
+
+ 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, tc)?;
+ )* );
+ Ok(())
+ }
+}
+
+pub struct SolidityInterface<F: SolidityFunctions> {
+ pub docs: &'static [&'static str],
+ pub selector: bytes4,
+ pub name: &'static str,
+ pub is: &'static [&'static str],
+ pub functions: F,
+}
+
+impl<F: SolidityFunctions> SolidityInterface<F> {
+ pub fn format(
+ &self,
+ is_impl: bool,
+ out: &mut impl fmt::Write,
+ tc: &TypeCollector,
+ ) -> fmt::Result {
+ const ZERO_BYTES: [u8; 4] = [0; 4];
+ for doc in self.docs {
+ writeln!(out, "///{}", doc)?;
+ }
+ if self.selector != ZERO_BYTES {
+ writeln!(
+ out,
+ "/// @dev the ERC-165 identifier for this interface is 0x{:0>8x}",
+ u32::from_be_bytes(self.selector)
+ )?;
+ }
+ if is_impl {
+ write!(out, "contract ")?;
+ } else {
+ write!(out, "interface ")?;
+ }
+ write!(out, "{}", self.name)?;
+ if !self.is.is_empty() {
+ write!(out, " is")?;
+ for (i, n) in self.is.iter().enumerate() {
+ if i != 0 {
+ write!(out, ",")?;
+ }
+ write!(out, " {}", n)?;
+ }
+ }
+ writeln!(out, " {{")?;
+ self.functions.solidity_name(is_impl, out, tc)?;
+ writeln!(out, "}}")?;
+ Ok(())
+ }
+}
+
+pub struct SolidityEvent<A> {
+ pub name: &'static str,
+ pub args: A,
+}
+
+impl<A: SolidityArguments> SolidityFunctions for SolidityEvent<A> {
+ 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, tc)?;
+ writeln!(writer, ");")
+ }
+}
crates/evm-coder/src/solidity/traits.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/src/solidity/traits.rs
@@ -0,0 +1,48 @@
+use super::TypeCollector;
+use core::fmt;
+
+pub trait StructCollect: 'static {
+ /// Structure name.
+ fn name() -> String;
+ /// Structure declaration.
+ fn declaration() -> String;
+}
+
+pub trait SolidityEnum: 'static {
+ fn solidity_option(&self) -> &str;
+}
+
+pub trait SolidityTypeName: 'static {
+ fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
+ /// "simple" types are stored inline, no `memory` modifier should be used in solidity
+ fn is_simple() -> bool;
+ fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
+ /// Specialization
+ fn is_void() -> bool {
+ false
+ }
+}
+
+pub trait SolidityType {
+ fn names(tc: &TypeCollector) -> Vec<String>;
+ fn len() -> usize;
+}
+
+pub trait SolidityArguments {
+ fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
+ fn solidity_get(&self, prefix: &str, 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
+ }
+ fn len(&self) -> usize;
+}
+
+pub trait SolidityFunctions {
+ fn solidity_name(
+ &self,
+ is_impl: bool,
+ writer: &mut impl fmt::Write,
+ tc: &TypeCollector,
+ ) -> fmt::Result;
+}
crates/evm-coder/tests/abi_derive_generation.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/tests/abi_derive_generation.rs
@@ -0,0 +1,841 @@
+mod test_struct {
+ use evm_coder_procedural::AbiCoder;
+ use evm_coder::types::bytes;
+
+ #[test]
+ fn empty_struct() {
+ let t = trybuild::TestCases::new();
+ t.compile_fail("tests/build_failed/abi_derive_struct_generation.rs");
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct1SimpleParam {
+ _a: u8,
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct1DynamicParam {
+ _a: String,
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct2SimpleParam {
+ _a: u8,
+ _b: u32,
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct2DynamicParam {
+ _a: String,
+ _b: bytes,
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct2MixedParam {
+ _a: u8,
+ _b: bytes,
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct1DerivedSimpleParam {
+ _a: TypeStruct1SimpleParam,
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct2DerivedSimpleParam {
+ _a: TypeStruct1SimpleParam,
+ _b: TypeStruct2SimpleParam,
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct1DerivedDynamicParam {
+ _a: TypeStruct1DynamicParam,
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct2DerivedDynamicParam {
+ _a: TypeStruct1DynamicParam,
+ _b: TypeStruct2DynamicParam,
+ }
+
+ /// Some docs
+ /// At multi
+ /// line
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct3DerivedMixedParam {
+ /// Docs for A
+ /// multi
+ /// line
+ _a: TypeStruct1SimpleParam,
+ /// Docs for B
+ _b: TypeStruct2DynamicParam,
+ /// Docs for C
+ _c: TypeStruct2MixedParam,
+ }
+
+ #[test]
+ #[cfg(feature = "stubgen")]
+ fn struct_collect_type_struct3_derived_mixed_param() {
+ assert_eq!(
+ <TypeStruct3DerivedMixedParam as ::evm_coder::solidity::StructCollect>::name(),
+ "TypeStruct3DerivedMixedParam"
+ );
+ similar_asserts::assert_eq!(
+ <TypeStruct3DerivedMixedParam as ::evm_coder::solidity::StructCollect>::declaration(),
+ r#"/// @dev Some docs
+/// At multi
+/// line
+struct TypeStruct3DerivedMixedParam {
+ /// @dev Docs for A
+ /// multi
+ /// line
+ TypeStruct1SimpleParam _a;
+ /// @dev Docs for B
+ TypeStruct2DynamicParam _b;
+ /// @dev Docs for C
+ TypeStruct2MixedParam _c;
+}
+"#
+ );
+ }
+
+ #[test]
+ fn impl_abi_type_signature() {
+ assert_eq!(
+ <TypeStruct1SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "(uint8)"
+ );
+ assert_eq!(
+ <TypeStruct1DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "(string)"
+ );
+ assert_eq!(
+ <TypeStruct2SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "(uint8,uint32)"
+ );
+ assert_eq!(
+ <TypeStruct2DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "(string,bytes)"
+ );
+ assert_eq!(
+ <TypeStruct2MixedParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "(uint8,bytes)"
+ );
+ assert_eq!(
+ <TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "((uint8))"
+ );
+ assert_eq!(
+ <TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "((uint8),(uint8,uint32))"
+ );
+ assert_eq!(
+ <TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "((string))"
+ );
+ assert_eq!(
+ <TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "((string),(string,bytes))"
+ );
+ assert_eq!(
+ <TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ "((uint8),(string,bytes),(uint8,bytes))"
+ );
+ }
+
+ #[test]
+ fn impl_abi_type_is_dynamic() {
+ assert_eq!(
+ <TypeStruct1SimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
+ false
+ );
+ assert_eq!(
+ <TypeStruct1DynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
+ true
+ );
+ assert_eq!(
+ <TypeStruct2SimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
+ false
+ );
+ assert_eq!(
+ <TypeStruct2DynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
+ true
+ );
+ assert_eq!(
+ <TypeStruct2MixedParam as evm_coder::abi::AbiType>::is_dynamic(),
+ true
+ );
+ assert_eq!(
+ <TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
+ false
+ );
+ assert_eq!(
+ <TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
+ false
+ );
+ assert_eq!(
+ <TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
+ true
+ );
+ assert_eq!(
+ <TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
+ true
+ );
+ assert_eq!(
+ <TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::is_dynamic(),
+ true
+ );
+ }
+
+ #[test]
+ fn impl_abi_type_size() {
+ const ABI_ALIGNMENT: usize = 32;
+ assert_eq!(
+ <TypeStruct1SimpleParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT
+ );
+ assert_eq!(
+ <TypeStruct1DynamicParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT
+ );
+ assert_eq!(
+ <TypeStruct2SimpleParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT * 2
+ );
+ assert_eq!(
+ <TypeStruct2DynamicParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT * 2
+ );
+ assert_eq!(
+ <TypeStruct2MixedParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT * 2
+ );
+ assert_eq!(
+ <TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT
+ );
+ assert_eq!(
+ <TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT * 3
+ );
+ assert_eq!(
+ <TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT
+ );
+ assert_eq!(
+ <TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT * 3
+ );
+ assert_eq!(
+ <TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::size(),
+ ABI_ALIGNMENT * 5
+ );
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct1SimpleParam(u8);
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct1DynamicParam(String);
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct2SimpleParam(u8, u32);
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct2DynamicParam(String, bytes);
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct2MixedParam(u8, bytes);
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct1DerivedSimpleParam(TupleStruct1SimpleParam);
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct2DerivedSimpleParam(TupleStruct1SimpleParam, TupleStruct2SimpleParam);
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct1DerivedDynamicParam(TupleStruct1DynamicParam);
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct2DerivedDynamicParam(TupleStruct1DynamicParam, TupleStruct2DynamicParam);
+
+ /// Some docs
+ /// At multi
+ /// line
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct3DerivedMixedParam(
+ /// Docs for A
+ /// multi
+ /// line
+ TupleStruct1SimpleParam,
+ TupleStruct2DynamicParam,
+ /// Docs for C
+ TupleStruct2MixedParam,
+ );
+
+ #[test]
+ #[cfg(feature = "stubgen")]
+ fn struct_collect_tuple_struct3_derived_mixed_param() {
+ assert_eq!(
+ <TupleStruct3DerivedMixedParam as ::evm_coder::solidity::StructCollect>::name(),
+ "TupleStruct3DerivedMixedParam"
+ );
+ similar_asserts::assert_eq!(
+ <TupleStruct3DerivedMixedParam as ::evm_coder::solidity::StructCollect>::declaration(),
+ r#"/// @dev Some docs
+/// At multi
+/// line
+struct TupleStruct3DerivedMixedParam {
+ /// @dev Docs for A
+ /// multi
+ /// line
+ TupleStruct1SimpleParam field0;
+ TupleStruct2DynamicParam field1;
+ /// @dev Docs for C
+ TupleStruct2MixedParam field2;
+}
+"#
+ );
+ }
+
+ #[test]
+ fn impl_abi_type_signature_same_for_structs() {
+ assert_eq!(
+ <TypeStruct1SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct1SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap()
+ );
+ assert_eq!(
+ <TypeStruct1DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct1DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap()
+ );
+ assert_eq!(
+ <TypeStruct2SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct2SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap()
+ );
+ assert_eq!(
+ <TypeStruct2DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct2DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap()
+ );
+ assert_eq!(
+ <TypeStruct2MixedParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct2MixedParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ );
+ assert_eq!(
+ <TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ );
+ assert_eq!(
+ <TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ );
+ assert_eq!(
+ <TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ );
+ assert_eq!(
+ <TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ );
+ assert_eq!(
+ <TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <TupleStruct3DerivedMixedParam as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ );
+ }
+
+ #[test]
+ fn impl_abi_type_is_dynamic_same_for_structs() {
+ assert_eq!(
+ <TypeStruct1SimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct1SimpleParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ assert_eq!(
+ <TypeStruct1DynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct1DynamicParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ assert_eq!(
+ <TypeStruct2SimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct2SimpleParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ assert_eq!(
+ <TypeStruct2DynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct2DynamicParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ assert_eq!(
+ <TypeStruct2MixedParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct2MixedParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ assert_eq!(
+ <TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ assert_eq!(
+ <TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ assert_eq!(
+ <TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ assert_eq!(
+ <TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ assert_eq!(
+ <TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::is_dynamic(),
+ <TupleStruct3DerivedMixedParam as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ }
+
+ #[test]
+ fn impl_abi_type_size_same_for_structs() {
+ assert_eq!(
+ <TypeStruct1SimpleParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct1SimpleParam as evm_coder::abi::AbiType>::size()
+ );
+ assert_eq!(
+ <TypeStruct1DynamicParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct1DynamicParam as evm_coder::abi::AbiType>::size()
+ );
+ assert_eq!(
+ <TypeStruct2SimpleParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct2SimpleParam as evm_coder::abi::AbiType>::size()
+ );
+ assert_eq!(
+ <TypeStruct2DynamicParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct2DynamicParam as evm_coder::abi::AbiType>::size()
+ );
+ assert_eq!(
+ <TypeStruct2MixedParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct2MixedParam as evm_coder::abi::AbiType>::size()
+ );
+ assert_eq!(
+ <TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::size()
+ );
+ assert_eq!(
+ <TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::size()
+ );
+ assert_eq!(
+ <TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::size()
+ );
+ assert_eq!(
+ <TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::size()
+ );
+ assert_eq!(
+ <TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::size(),
+ <TupleStruct3DerivedMixedParam as evm_coder::abi::AbiType>::size()
+ );
+ }
+
+ const FUNCTION_IDENTIFIER: u32 = 0xdeadbeef;
+
+ fn test_impl<Tuple, TupleStruct, TypeStruct>(
+ tuple_data: Tuple,
+ tuple_struct_data: TupleStruct,
+ type_struct_data: TypeStruct,
+ ) where
+ TypeStruct: evm_coder::abi::AbiWrite
+ + evm_coder::abi::AbiRead
+ + std::cmp::PartialEq
+ + std::fmt::Debug,
+ TupleStruct: evm_coder::abi::AbiWrite
+ + evm_coder::abi::AbiRead
+ + std::cmp::PartialEq
+ + std::fmt::Debug,
+ Tuple: evm_coder::abi::AbiWrite
+ + evm_coder::abi::AbiRead
+ + std::cmp::PartialEq
+ + std::fmt::Debug,
+ {
+ let encoded_type_struct = test_abi_write_impl(&type_struct_data);
+ let encoded_tuple_struct = test_abi_write_impl(&tuple_struct_data);
+ let encoded_tuple = test_abi_write_impl(&tuple_data);
+
+ similar_asserts::assert_eq!(encoded_tuple, encoded_type_struct);
+ similar_asserts::assert_eq!(encoded_tuple, encoded_tuple_struct);
+
+ {
+ let (_, mut decoder) = evm_coder::abi::AbiReader::new_call(&encoded_tuple).unwrap();
+ let restored_struct_data = <TypeStruct>::abi_read(&mut decoder).unwrap();
+ assert_eq!(restored_struct_data, type_struct_data);
+ }
+ {
+ let (_, mut decoder) = evm_coder::abi::AbiReader::new_call(&encoded_tuple).unwrap();
+ let restored_struct_data = <TupleStruct>::abi_read(&mut decoder).unwrap();
+ assert_eq!(restored_struct_data, tuple_struct_data);
+ }
+
+ {
+ let (_, mut decoder) =
+ evm_coder::abi::AbiReader::new_call(&encoded_type_struct).unwrap();
+ let restored_tuple_data = <Tuple>::abi_read(&mut decoder).unwrap();
+ assert_eq!(restored_tuple_data, tuple_data);
+ }
+ {
+ let (_, mut decoder) =
+ evm_coder::abi::AbiReader::new_call(&encoded_tuple_struct).unwrap();
+ let restored_tuple_data = <Tuple>::abi_read(&mut decoder).unwrap();
+ assert_eq!(restored_tuple_data, tuple_data);
+ }
+ }
+
+ fn test_abi_write_impl<A>(data: &A) -> Vec<u8>
+ where
+ A: evm_coder::abi::AbiWrite
+ + evm_coder::abi::AbiRead
+ + std::cmp::PartialEq
+ + std::fmt::Debug,
+ {
+ let mut writer = evm_coder::abi::AbiWriter::new_call(FUNCTION_IDENTIFIER);
+ data.abi_write(&mut writer);
+ let encoded_tuple = writer.finish();
+ encoded_tuple
+ }
+
+ #[test]
+ fn codec_struct_1_simple() {
+ let _a = 0xff;
+ test_impl::<(u8,), TupleStruct1SimpleParam, TypeStruct1SimpleParam>(
+ (_a,),
+ TupleStruct1SimpleParam(_a),
+ TypeStruct1SimpleParam { _a },
+ );
+ }
+
+ #[test]
+ fn codec_struct_1_dynamic() {
+ let _a: String = "some string".into();
+ test_impl::<(String,), TupleStruct1DynamicParam, TypeStruct1DynamicParam>(
+ (_a.clone(),),
+ TupleStruct1DynamicParam(_a.clone()),
+ TypeStruct1DynamicParam { _a },
+ );
+ }
+
+ #[test]
+ fn codec_struct_1_derived_simple() {
+ let _a: u8 = 0xff;
+ test_impl::<((u8,),), TupleStruct1DerivedSimpleParam, TypeStruct1DerivedSimpleParam>(
+ ((_a,),),
+ TupleStruct1DerivedSimpleParam(TupleStruct1SimpleParam(_a)),
+ TypeStruct1DerivedSimpleParam {
+ _a: TypeStruct1SimpleParam { _a },
+ },
+ );
+ }
+
+ #[test]
+ fn codec_struct_1_derived_dynamic() {
+ let _a: String = "some string".into();
+ test_impl::<((String,),), TupleStruct1DerivedDynamicParam, TypeStruct1DerivedDynamicParam>(
+ ((_a.clone(),),),
+ TupleStruct1DerivedDynamicParam(TupleStruct1DynamicParam(_a.clone())),
+ TypeStruct1DerivedDynamicParam {
+ _a: TypeStruct1DynamicParam { _a },
+ },
+ );
+ }
+
+ #[test]
+ fn codec_struct_2_simple() {
+ let _a = 0xff;
+ let _b = 0xbeefbaba;
+ test_impl::<(u8, u32), TupleStruct2SimpleParam, TypeStruct2SimpleParam>(
+ (_a, _b),
+ TupleStruct2SimpleParam(_a, _b),
+ TypeStruct2SimpleParam { _a, _b },
+ );
+ }
+
+ #[test]
+ fn codec_struct_2_dynamic() {
+ let _a: String = "some string".into();
+ let _b: bytes = bytes(vec![0x11, 0x22, 0x33]);
+ test_impl::<(String, bytes), TupleStruct2DynamicParam, TypeStruct2DynamicParam>(
+ (_a.clone(), _b.clone()),
+ TupleStruct2DynamicParam(_a.clone(), _b.clone()),
+ TypeStruct2DynamicParam { _a, _b },
+ );
+ }
+
+ #[test]
+ fn codec_struct_2_mixed() {
+ let _a: u8 = 0xff;
+ let _b: bytes = bytes(vec![0x11, 0x22, 0x33]);
+ test_impl::<(u8, bytes), TupleStruct2MixedParam, TypeStruct2MixedParam>(
+ (_a.clone(), _b.clone()),
+ TupleStruct2MixedParam(_a.clone(), _b.clone()),
+ TypeStruct2MixedParam { _a, _b },
+ );
+ }
+
+ #[test]
+ fn codec_struct_2_derived_simple() {
+ let _a = 0xff;
+ let _b = 0xbeefbaba;
+ test_impl::<
+ ((u8,), (u8, u32)),
+ TupleStruct2DerivedSimpleParam,
+ TypeStruct2DerivedSimpleParam,
+ >(
+ ((_a,), (_a, _b)),
+ TupleStruct2DerivedSimpleParam(
+ TupleStruct1SimpleParam(_a),
+ TupleStruct2SimpleParam(_a, _b),
+ ),
+ TypeStruct2DerivedSimpleParam {
+ _a: TypeStruct1SimpleParam { _a },
+ _b: TypeStruct2SimpleParam { _a, _b },
+ },
+ );
+ }
+
+ #[test]
+ fn codec_struct_2_derived_dynamic() {
+ let _a = "some string".to_string();
+ let _b = bytes(vec![0x11, 0x22, 0x33]);
+ test_impl::<
+ ((String,), (String, bytes)),
+ TupleStruct2DerivedDynamicParam,
+ TypeStruct2DerivedDynamicParam,
+ >(
+ ((_a.clone(),), (_a.clone(), _b.clone())),
+ TupleStruct2DerivedDynamicParam(
+ TupleStruct1DynamicParam(_a.clone()),
+ TupleStruct2DynamicParam(_a.clone(), _b.clone()),
+ ),
+ TypeStruct2DerivedDynamicParam {
+ _a: TypeStruct1DynamicParam { _a: _a.clone() },
+ _b: TypeStruct2DynamicParam { _a, _b },
+ },
+ );
+ }
+
+ #[test]
+ fn codec_struct_3_derived_mixed() {
+ let int = 0xff;
+ let by = bytes(vec![0x11, 0x22, 0x33]);
+ let string = "some string".to_string();
+ test_impl::<
+ ((u8,), (String, bytes), (u8, bytes)),
+ TupleStruct3DerivedMixedParam,
+ TypeStruct3DerivedMixedParam,
+ >(
+ ((int,), (string.clone(), by.clone()), (int, by.clone())),
+ TupleStruct3DerivedMixedParam(
+ TupleStruct1SimpleParam(int),
+ TupleStruct2DynamicParam(string.clone(), by.clone()),
+ TupleStruct2MixedParam(int, by.clone()),
+ ),
+ TypeStruct3DerivedMixedParam {
+ _a: TypeStruct1SimpleParam { _a: int },
+ _b: TypeStruct2DynamicParam {
+ _a: string.clone(),
+ _b: by.clone(),
+ },
+ _c: TypeStruct2MixedParam { _a: int, _b: by },
+ },
+ );
+ }
+
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TypeStruct2SimpleStruct1Simple {
+ _a: TypeStruct2SimpleParam,
+ _b: TypeStruct2SimpleParam,
+ _c: u8,
+ }
+ #[derive(AbiCoder, PartialEq, Debug)]
+ struct TupleStruct2SimpleStruct1Simple(TupleStruct2SimpleParam, TupleStruct2SimpleParam, u8);
+
+ #[test]
+ fn codec_struct_2_struct_simple_1_simple() {
+ let _a = 0xff;
+ let _b = 0xbeefbaba;
+ test_impl::<
+ ((u8, u32), (u8, u32), u8),
+ TupleStruct2SimpleStruct1Simple,
+ TypeStruct2SimpleStruct1Simple,
+ >(
+ ((_a, _b), (_a, _b), _a),
+ TupleStruct2SimpleStruct1Simple(
+ TupleStruct2SimpleParam(_a, _b),
+ TupleStruct2SimpleParam(_a, _b),
+ _a,
+ ),
+ TypeStruct2SimpleStruct1Simple {
+ _a: TypeStruct2SimpleParam { _a, _b },
+ _b: TypeStruct2SimpleParam { _a, _b },
+ _c: _a,
+ },
+ );
+ }
+}
+
+mod test_enum {
+ use evm_coder::AbiCoder;
+
+ /// Some docs
+ /// At multi
+ /// line
+ #[derive(AbiCoder, Debug, PartialEq, Default)]
+ #[repr(u8)]
+ enum Color {
+ /// Docs for Red
+ /// multi
+ /// line
+ Red,
+ Green,
+ /// Docs for Blue
+ #[default]
+ Blue,
+ }
+
+ #[test]
+ fn empty() {}
+
+ #[test]
+ fn bad_enums() {
+ let t = trybuild::TestCases::new();
+ t.compile_fail("tests/build_failed/abi_derive_enum_generation.rs");
+ }
+
+ #[test]
+ fn impl_abi_type_signature_same_for_structs() {
+ assert_eq!(
+ <Color as evm_coder::abi::AbiType>::SIGNATURE
+ .as_str()
+ .unwrap(),
+ <u8 as evm_coder::abi::AbiType>::SIGNATURE.as_str().unwrap()
+ );
+ }
+
+ #[test]
+ fn impl_abi_type_is_dynamic_same_for_structs() {
+ assert_eq!(
+ <Color as evm_coder::abi::AbiType>::is_dynamic(),
+ <u8 as evm_coder::abi::AbiType>::is_dynamic()
+ );
+ }
+
+ #[test]
+ fn impl_abi_type_size_same_for_structs() {
+ assert_eq!(
+ <Color as evm_coder::abi::AbiType>::size(),
+ <u8 as evm_coder::abi::AbiType>::size()
+ );
+ }
+
+ #[test]
+ fn test_coder() {
+ const FUNCTION_IDENTIFIER: u32 = 0xdeadbeef;
+
+ let encoded_enum = {
+ let mut writer = evm_coder::abi::AbiWriter::new_call(FUNCTION_IDENTIFIER);
+ <Color as evm_coder::abi::AbiWrite>::abi_write(&Color::Green, &mut writer);
+ writer.finish()
+ };
+
+ let encoded_u8 = {
+ let mut writer = evm_coder::abi::AbiWriter::new_call(FUNCTION_IDENTIFIER);
+ <u8 as evm_coder::abi::AbiWrite>::abi_write(&(Color::Green as u8), &mut writer);
+ writer.finish()
+ };
+
+ similar_asserts::assert_eq!(encoded_enum, encoded_u8);
+
+ {
+ let (_, mut decoder) = evm_coder::abi::AbiReader::new_call(&encoded_enum).unwrap();
+ let restored_enum_data =
+ <Color as evm_coder::abi::AbiRead>::abi_read(&mut decoder).unwrap();
+ assert_eq!(restored_enum_data, Color::Green);
+ }
+ }
+
+ #[test]
+ #[cfg(feature = "stubgen")]
+ fn struct_collect_enum() {
+ assert_eq!(
+ <Color as ::evm_coder::solidity::StructCollect>::name(),
+ "Color"
+ );
+ similar_asserts::assert_eq!(
+ <Color as ::evm_coder::solidity::StructCollect>::declaration(),
+ r#"/// @dev Some docs
+/// At multi
+/// line
+enum Color {
+ /// @dev Docs for Red
+ /// multi
+ /// line
+ Red,
+ Green,
+ /// @dev Docs for Blue
+ Blue
+}
+"#
+ );
+ }
+}
crates/evm-coder/tests/build_failed/abi_derive_enum_generation.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/tests/build_failed/abi_derive_enum_generation.rs
@@ -0,0 +1,36 @@
+use evm_coder_procedural::AbiCoder;
+
+#[derive(AbiCoder)]
+enum NonRepr {
+ A,
+ B,
+ C,
+}
+
+#[derive(AbiCoder)]
+#[repr(u32)]
+enum NonReprU8 {
+ A,
+ B,
+ C,
+}
+
+#[derive(AbiCoder)]
+#[repr(u8)]
+enum RustEnum {
+ A(u128),
+ B,
+ C,
+}
+
+#[derive(AbiCoder)]
+#[repr(u8)]
+enum WithExplicit {
+ A = 128,
+ B,
+ C,
+}
+
+fn main() {
+ assert!(false);
+}
crates/evm-coder/tests/build_failed/abi_derive_enum_generation.stderrdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/tests/build_failed/abi_derive_enum_generation.stderr
@@ -0,0 +1,23 @@
+error: Enum is not "repr(u8)"
+ --> tests/build_failed/abi_derive_enum_generation.rs:4:6
+ |
+4 | enum NonRepr {
+ | ^^^^^^^
+
+error: Enum is not "repr(u8)"
+ --> tests/build_failed/abi_derive_enum_generation.rs:11:8
+ |
+11 | #[repr(u32)]
+ | ^^^
+
+error: Enumeration parameters should not have fields
+ --> tests/build_failed/abi_derive_enum_generation.rs:21:2
+ |
+21 | A(u128),
+ | ^
+
+error: Enumeration options should not have an explicit specified value
+ --> tests/build_failed/abi_derive_enum_generation.rs:29:2
+ |
+29 | A = 128,
+ | ^
crates/evm-coder/tests/build_failed/abi_derive_struct_generation.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/tests/build_failed/abi_derive_struct_generation.rs
@@ -0,0 +1,11 @@
+use evm_coder_procedural::AbiCoder;
+
+#[derive(AbiCoder, PartialEq, Debug)]
+struct EmptyStruct {}
+
+#[derive(AbiCoder, PartialEq, Debug)]
+struct EmptyTupleStruct();
+
+fn main() {
+ assert!(false);
+}
crates/evm-coder/tests/build_failed/abi_derive_struct_generation.stderrdiffbeforeafterboth--- /dev/null
+++ b/crates/evm-coder/tests/build_failed/abi_derive_struct_generation.stderr
@@ -0,0 +1,11 @@
+error: Empty structs not supported
+ --> tests/build_failed/abi_derive_struct_generation.rs:4:8
+ |
+4 | struct EmptyStruct {}
+ | ^^^^^^^^^^^
+
+error: Empty structs not supported
+ --> tests/build_failed/abi_derive_struct_generation.rs:7:8
+ |
+7 | struct EmptyTupleStruct();
+ | ^^^^^^^^^^^^^^^^
pallets/common/src/erc.rsdiffbeforeafterboth--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -16,6 +16,7 @@
//! This module contains the implementation of pallet methods for evm.
+pub use pallet_evm::{PrecompileOutput, PrecompileResult, PrecompileHandle, account::CrossAccountId};
use evm_coder::{
abi::AbiType,
solidity_interface, solidity, ToLog,
@@ -24,7 +25,6 @@
execution::{Result, Error},
weight,
};
-pub use pallet_evm::{PrecompileOutput, PrecompileResult, PrecompileHandle, account::CrossAccountId};
use pallet_evm_coder_substrate::dispatch_to_evm;
use sp_std::vec::Vec;
use up_data_structs::{
@@ -35,7 +35,8 @@
use crate::{
Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,
- eth::convert_cross_account_to_uint256, weights::WeightInfo,
+ eth::{EthCrossAccount, convert_cross_account_to_uint256},
+ weights::WeightInfo,
};
/// Events for ethereum collection helper.
pallets/common/src/eth.rsdiffbeforeafterboth--- a/pallets/common/src/eth.rs
+++ b/pallets/common/src/eth.rs
@@ -16,7 +16,10 @@
//! The module contains a number of functions for converting and checking ethereum identifiers.
-use evm_coder::types::{uint256, address};
+use evm_coder::{
+ AbiCoder,
+ types::{uint256, address},
+};
pub use pallet_evm::{Config, account::CrossAccountId};
use sp_core::H160;
use up_data_structs::CollectionId;
@@ -109,3 +112,46 @@
Err("All fields of cross account is non zeroed".into())
}
}
+
+/// Cross account struct
+#[derive(Debug, Default, AbiCoder)]
+pub struct EthCrossAccount {
+ pub(crate) eth: address,
+ pub(crate) sub: uint256,
+}
+
+impl EthCrossAccount {
+ pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self
+ where
+ T: pallet_evm::Config,
+ T::AccountId: AsRef<[u8; 32]>,
+ {
+ if cross_account_id.is_canonical_substrate() {
+ Self {
+ eth: Default::default(),
+ sub: convert_cross_account_to_uint256::<T>(cross_account_id),
+ }
+ } else {
+ Self {
+ eth: *cross_account_id.as_eth(),
+ sub: Default::default(),
+ }
+ }
+ }
+
+ pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>
+ where
+ T: pallet_evm::Config,
+ T::AccountId: From<[u8; 32]>,
+ {
+ if self.eth == Default::default() && self.sub == Default::default() {
+ Err("All fields of cross account is zeroed".into())
+ } else if self.eth == Default::default() {
+ Ok(convert_uint256_to_cross_account::<T>(self.sub))
+ } else if self.sub == Default::default() {
+ Ok(T::CrossAccountId::from_eth(self.eth))
+ } else {
+ Err("All fields of cross account is non zeroed".into())
+ }
+ }
+}
pallets/common/src/lib.rsdiffbeforeafterboth--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -376,6 +376,7 @@
type TreasuryAccountId: Get<Self::AccountId>;
/// Address under which the CollectionHelper contract would be available.
+ #[pallet::constant]
type ContractAddress: Get<H160>;
/// Mapper for token addresses to Ethereum addresses.
pallets/evm-contract-helpers/src/lib.rsdiffbeforeafterboth--- a/pallets/evm-contract-helpers/src/lib.rs
+++ b/pallets/evm-contract-helpers/src/lib.rs
@@ -47,6 +47,7 @@
type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;
/// Address, under which magic contract will be available
+ #[pallet::constant]
type ContractAddress: Get<H160>;
/// In case of enabled sponsoring, but no sponsoring rate limit set,
pallets/evm-contract-helpers/src/stubs/ContractHelpers.rawdiffbeforeafterbothbinary blob — no preview
pallets/fungible/src/erc.rsdiffbeforeafterboth--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -24,12 +24,16 @@
weight,
};
use up_data_structs::CollectionMode;
-use pallet_common::erc::{CommonEvmHandler, PrecompileResult};
+use pallet_common::{
+ CollectionHandle,
+ erc::{CommonEvmHandler, PrecompileResult, CollectionCall},
+ eth::EthCrossAccount,
+};
use sp_std::vec::Vec;
use pallet_evm::{account::CrossAccountId, PrecompileHandle};
use pallet_evm_coder_substrate::{call, dispatch_to_evm};
use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
-use pallet_common::{CollectionHandle, erc::CollectionCall};
+use sp_core::Get;
use crate::{
Allowance, Balance, Config, FungibleHandle, Pallet, SelfWeightOf, TotalSupply,
@@ -132,6 +136,11 @@
Ok(<Allowance<T>>::get((self.id, owner, spender)).into())
}
+
+ /// @notice Returns collection helper contract address
+ fn collection_helper_address(&self) -> Result<address> {
+ Ok(T::ContractAddress::get())
+ }
}
#[solidity_interface(name = ERC20Mintable)]
pallets/fungible/src/stubs/UniqueFungible.rawdiffbeforeafterbothbinary blob — no preview
pallets/fungible/src/stubs/UniqueFungible.soldiffbeforeafterboth--- a/pallets/fungible/src/stubs/UniqueFungible.sol
+++ b/pallets/fungible/src/stubs/UniqueFungible.sol
@@ -547,7 +547,7 @@
event Approval(address indexed owner, address indexed spender, uint256 value);
}
-/// @dev the ERC-165 identifier for this interface is 0x942e8b22
+/// @dev the ERC-165 identifier for this interface is 0x8cb847c4
contract ERC20 is Dummy, ERC165, ERC20Events {
/// @dev EVM selector for this function is: 0x06fdde03,
/// or in textual repr: name()
@@ -634,6 +634,15 @@
dummy;
return 0;
}
+
+ /// @notice Returns collection helper contract address
+ /// @dev EVM selector for this function is: 0x1896cce6,
+ /// or in textual repr: collectionHelperAddress()
+ function collectionHelperAddress() public view returns (address) {
+ require(false, stub_error);
+ dummy;
+ return 0x0000000000000000000000000000000000000000;
+ }
}
contract UniqueFungible is Dummy, ERC165, ERC20, ERC20Mintable, ERC20UniqueExtensions, Collection {}
pallets/nonfungible/src/erc.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -36,12 +36,14 @@
use pallet_evm_coder_substrate::dispatch_to_evm;
use sp_std::vec::Vec;
use pallet_common::{
+ CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,
erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},
- CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,
+ eth::EthCrossAccount,
};
use pallet_evm::{account::CrossAccountId, PrecompileHandle};
use pallet_evm_coder_substrate::call;
use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
+use sp_core::Get;
use crate::{
AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,
@@ -489,6 +491,11 @@
// TODO: Not implemetable
Err("not implemented".into())
}
+
+ /// @notice Returns collection helper contract address
+ fn collection_helper_address(&self) -> Result<address> {
+ Ok(T::ContractAddress::get())
+ }
}
/// @title ERC721 Token that can be irreversibly burned (destroyed).
pallets/nonfungible/src/stubs/UniqueNFT.rawdiffbeforeafterbothbinary blob — no preview
pallets/nonfungible/src/stubs/UniqueNFT.soldiffbeforeafterboth--- a/pallets/nonfungible/src/stubs/UniqueNFT.sol
+++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol
@@ -920,7 +920,7 @@
/// @title ERC-721 Non-Fungible Token Standard
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
-/// @dev the ERC-165 identifier for this interface is 0x80ac58cd
+/// @dev the ERC-165 identifier for this interface is 0x983a942b
contract ERC721 is Dummy, ERC165, ERC721Events {
/// @notice Count all NFTs assigned to an owner
/// @dev NFTs assigned to the zero address are considered invalid, and this
@@ -1050,6 +1050,15 @@
dummy;
return 0x0000000000000000000000000000000000000000;
}
+
+ /// @notice Returns collection helper contract address
+ /// @dev EVM selector for this function is: 0x1896cce6,
+ /// or in textual repr: collectionHelperAddress()
+ function collectionHelperAddress() public view returns (address) {
+ require(false, stub_error);
+ dummy;
+ return 0x0000000000000000000000000000000000000000;
+ }
}
contract UniqueNFT is
pallets/proxy-rmrk-core/src/lib.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # RMRK Core Proxy Pallet18//!19//! A pallet used as proxy for RMRK Core (<https://rmrk-team.github.io/rmrk-substrate/#/pallets/rmrk-core>).20//!21//! - [`Config`]22//! - [`Call`]23//! - [`Pallet`]24//!25//! ## Overview26//!27//! The RMRK Core Proxy pallet mirrors the functionality of RMRK Core,28//! binding its externalities to Unique's own underlying structure.29//! It is purposed to mimic RMRK Core exactly, allowing seamless integrations30//! of solutions based on RMRK.31//!32//! RMRK Core itself contains essential functionality for RMRK's nested and33//! multi-resourced NFTs.34//!35//! *Note*, that while RMRK itself is subject to active development and restructuring,36//! the proxy may be caught temporarily out of date.37//!38//! ### What is RMRK?39//!40//! RMRK is a set of NFT standards which compose several "NFT 2.0 lego" primitives.41//! Putting these legos together allows a user to create NFT systems of arbitrary complexity.42//!43//! Meaning, RMRK NFTs are dynamic, able to nest into each other and form a hierarchy,44//! make use of specific changeable and partially shared metadata in the form of resources,45//! and more.46//!47//! Visit RMRK documentation and repositories to learn more:48//! - Docs: <https://docs.rmrk.app/getting-started/>49//! - FAQ: <https://coda.io/@rmrk/faq>50//! - Substrate code repository: <https://github.com/rmrk-team/rmrk-substrate>51//! - RMRK specification repository: <https://github.com/rmrk-team/rmrk-spec>52//!53//! ## Terminology54//!55//! For more information on RMRK, see RMRK's own documentation.56//!57//! ### Intro to RMRK58//!59//! - **Resource:** Additional piece of metadata of an NFT usually serving to add60//! a piece of media on top of the root metadata (NFT's own), be it a different wing61//! on the root template bird or something entirely unrelated.62//!63//! - **Base:** A list of possible "components" - Parts, a combination of which can64//! be appended/equipped to/on an NFT.65//!66//! - **Part:** Something that, together with other Parts, can constitute an NFT.67//! Parts are defined in the Base to which they belong. Parts can be either68//! of the `slot` type or `fixed` type. Slots are intended for equippables.69//! Note that "part of something" and "Part of a Base" can be easily confused,70//! and so in this documentation these words are distinguished by the capital letter.71//!72//! - **Theme:** Named objects of variable => value pairs which get interpolated into73//! the Base's `themable` Parts. Themes can hold any value, but are often represented74//! in RMRK's examples as colors applied to visible Parts.75//!76//! ### Peculiarities in Unique77//!78//! - **Scoped properties:** Properties that are normally obscured from users.79//! Their purpose is to contain structured metadata that was not included in the Unique standard80//! for collections and tokens, meant to be operated on by proxies and other outliers.81//! Scoped property keys are prefixed with `some-scope:`, where `some-scope` is82//! an arbitrary keyword, like "rmrk". `:` is considered an unacceptable symbol in user-defined83//! properties, which, along with other safeguards, makes scoped ones impossible to tamper with.84//!85//! - **Auxiliary properties:** A slightly different structure of properties,86//! trading universality of use for more convenient storage, writes and access.87//! Meant to be inaccessible to end users.88//!89//! ## Proxy Implementation90//!91//! An external user is supposed to be able to utilize this proxy as they would92//! utilize RMRK, and get exactly the same results. Normally, Unique transactions93//! are off-limits to RMRK collections and tokens, and vice versa. However,94//! the information stored on chain can be freely interpreted by storage reads and Unique RPCs.95//!96//! ### ID Mapping97//!98//! RMRK's collections' IDs are counted independently of Unique's and start at 0.99//! Note that tokens' IDs still start at 1.100//! The collections themselves, as well as tokens, are stored as Unique collections,101//! and thus RMRK IDs are mapped to Unique IDs (but not vice versa).102//!103//! ### External/Internal Collection Insulation104//!105//! A Unique transaction cannot target collections purposed for RMRK,106//! and they are flagged as `external` to specify that. On the other hand,107//! due to the mapping, RMRK transactions and RPCs simply cannot reach Unique collections.108//!109//! ### Native Properties110//!111//! Many of RMRK's native parameters are stored as scoped properties of a collection112//! or an NFT on the chain. Scoped properties are prefixed with `rmrk:`, where `:`113//! is an unacceptable symbol in user-defined properties, which, along with other safeguards,114//! makes them impossible to tamper with.115//!116//! ### Collection and NFT Types, or Base, Parts and Themes Handling117//!118//! RMRK introduces the concept of a Base, which is a catalogue of Parts,119//! possible components of an NFT. Due to its similarity with the functionality120//! of a token collection, a Base is stored and handled as one, and the Base's Parts and Themes121//! are this collection's NFTs. See [`CollectionType`] and [`NftType`].122//!123//! ## Interface124//!125//! ### Dispatchables126//!127//! - `create_collection` - Create a new collection of NFTs.128//! - `destroy_collection` - Destroy a collection.129//! - `change_collection_issuer` - Change the issuer of a collection.130//! Analogous to Unique's collection's [`owner`](up_data_structs::Collection).131//! - `lock_collection` - "Lock" the collection and prevent new token creation. **Cannot be undone.**132//! - `mint_nft` - Mint an NFT in a specified collection.133//! - `burn_nft` - Burn an NFT, destroying it and its nested tokens.134//! - `send` - Transfer an NFT from an account/NFT A to another account/NFT B.135//! - `accept_nft` - Accept an NFT sent from another account to self or an owned NFT.136//! - `reject_nft` - Reject an NFT sent from another account to self or owned NFT and **burn it**.137//! - `accept_resource` - Accept the addition of a newly created pending resource to an existing NFT.138//! - `accept_resource_removal` - Accept the removal of a removal-pending resource from an NFT.139//! - `set_property` - Add or edit a custom user property of a token or a collection.140//! - `set_priority` - Set a different order of resource priorities for an NFT.141//! - `add_basic_resource` - Create and set/propose a basic resource for an NFT.142//! - `add_composable_resource` - Create and set/propose a composable resource for an NFT.143//! - `add_slot_resource` - Create and set/propose a slot resource for an NFT.144//! - `remove_resource` - Remove and erase a resource from an NFT.145146#![cfg_attr(not(feature = "std"), no_std)]147148use frame_support::{pallet_prelude::*, BoundedVec, dispatch::DispatchResult};149use frame_system::{pallet_prelude::*, ensure_signed};150use sp_runtime::{DispatchError, Permill, traits::StaticLookup};151use sp_std::{152 vec::Vec,153 collections::{btree_set::BTreeSet, btree_map::BTreeMap},154};155use up_data_structs::{*, mapping::TokenAddressMapping};156use pallet_common::{157 Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations,158};159use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData};160use pallet_structure::{Pallet as PalletStructure, Error as StructureError};161use pallet_evm::account::CrossAccountId;162use core::convert::AsRef;163164pub use pallet::*;165166#[cfg(feature = "runtime-benchmarks")]167pub mod benchmarking;168pub mod misc;169pub mod property;170pub mod rpc;171pub mod weights;172173pub type SelfWeightOf<T> = <T as Config>::WeightInfo;174175use weights::WeightInfo;176use misc::*;177pub use property::*;178179use RmrkProperty::*;180181/// Maximum number of levels of depth in the token nesting tree.182pub const NESTING_BUDGET: u32 = 5;183184type PendingTarget = (CollectionId, TokenId);185type PendingChild = (RmrkCollectionId, RmrkNftId);186type PendingChildrenSet = BTreeSet<PendingChild>;187188type BasesMap = BTreeMap<RmrkBaseId, u32>;189190#[frame_support::pallet]191pub mod pallet {192 use super::*;193194 #[pallet::config]195 pub trait Config:196 frame_system::Config197 + pallet_common::Config198 + pallet_nonfungible::Config199 + pallet_evm::Config200 {201 /// Overarching event type.202 type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;203204 /// The weight information of this pallet.205 type WeightInfo: WeightInfo;206 }207208 /// Latest yet-unused collection ID.209 #[pallet::storage]210 #[pallet::getter(fn collection_index)]211 pub type CollectionIndex<T: Config> = StorageValue<_, RmrkCollectionId, ValueQuery>;212213 /// Mapping from RMRK collection ID to Unique's.214 #[pallet::storage]215 pub type UniqueCollectionId<T: Config> =216 StorageMap<_, Twox64Concat, RmrkCollectionId, CollectionId, ValueQuery>;217218 #[pallet::pallet]219 #[pallet::generate_store(pub(super) trait Store)]220 pub struct Pallet<T>(_);221222 #[pallet::event]223 #[pallet::generate_deposit(pub(super) fn deposit_event)]224 pub enum Event<T: Config> {225 CollectionCreated {226 issuer: T::AccountId,227 collection_id: RmrkCollectionId,228 },229 CollectionDestroyed {230 issuer: T::AccountId,231 collection_id: RmrkCollectionId,232 },233 IssuerChanged {234 old_issuer: T::AccountId,235 new_issuer: T::AccountId,236 collection_id: RmrkCollectionId,237 },238 CollectionLocked {239 issuer: T::AccountId,240 collection_id: RmrkCollectionId,241 },242 NftMinted {243 owner: T::AccountId,244 collection_id: RmrkCollectionId,245 nft_id: RmrkNftId,246 },247 NFTBurned {248 owner: T::AccountId,249 nft_id: RmrkNftId,250 },251 NFTSent {252 sender: T::AccountId,253 recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,254 collection_id: RmrkCollectionId,255 nft_id: RmrkNftId,256 approval_required: bool,257 },258 NFTAccepted {259 sender: T::AccountId,260 recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,261 collection_id: RmrkCollectionId,262 nft_id: RmrkNftId,263 },264 NFTRejected {265 sender: T::AccountId,266 collection_id: RmrkCollectionId,267 nft_id: RmrkNftId,268 },269 PropertySet {270 collection_id: RmrkCollectionId,271 maybe_nft_id: Option<RmrkNftId>,272 key: RmrkKeyString,273 value: RmrkValueString,274 },275 ResourceAdded {276 nft_id: RmrkNftId,277 resource_id: RmrkResourceId,278 },279 ResourceRemoval {280 nft_id: RmrkNftId,281 resource_id: RmrkResourceId,282 },283 ResourceAccepted {284 nft_id: RmrkNftId,285 resource_id: RmrkResourceId,286 },287 ResourceRemovalAccepted {288 nft_id: RmrkNftId,289 resource_id: RmrkResourceId,290 },291 PrioritySet {292 collection_id: RmrkCollectionId,293 nft_id: RmrkNftId,294 },295 }296297 #[pallet::error]298 pub enum Error<T> {299 /* Unique proxy-specific events */300 /// Property of the type of RMRK collection could not be read successfully.301 CorruptedCollectionType,302 // NftTypeEncodeError,303 /// Too many symbols supplied as the property key. The maximum is [256](up_data_structs::MAX_PROPERTY_KEY_LENGTH).304 RmrkPropertyKeyIsTooLong,305 /// Too many bytes supplied as the property value. The maximum is [32768](up_data_structs::MAX_PROPERTY_VALUE_LENGTH).306 RmrkPropertyValueIsTooLong,307 /// Could not find a property by the supplied key.308 RmrkPropertyIsNotFound,309 /// Something went wrong when decoding encoded data from the storage.310 /// Perhaps, there was a wrong key supplied for the type, or the data was improperly stored.311 UnableToDecodeRmrkData,312313 /* RMRK compatible events */314 /// Only destroying collections without tokens is allowed.315 CollectionNotEmpty,316 /// Could not find an ID for a collection. It is likely there were too many collections created on the chain, causing an overflow.317 NoAvailableCollectionId,318 /// Token does not exist, or there is no suitable ID for it, likely too many tokens were created in a collection, causing an overflow.319 NoAvailableNftId,320 /// Collection does not exist, has a wrong type, or does not map to a Unique ID.321 CollectionUnknown,322 /// No permission to perform action.323 NoPermission,324 /// Token is marked as non-transferable, and thus cannot be transferred.325 NonTransferable,326 /// Too many tokens created in the collection, no new ones are allowed.327 CollectionFullOrLocked,328 /// No such resource found.329 ResourceDoesntExist,330 /// If an NFT is sent to a descendant, that would form a nesting loop, an ouroboros.331 /// Sending to self is redundant.332 CannotSendToDescendentOrSelf,333 /// Not the target owner of the sent NFT.334 CannotAcceptNonOwnedNft,335 /// Not the target owner of the sent NFT.336 CannotRejectNonOwnedNft,337 /// NFT was not sent and is not pending.338 CannotRejectNonPendingNft,339 /// Resource is not pending for the operation.340 ResourceNotPending,341 /// Could not find an ID for the resource. It is likely there were too many resources created on an NFT, causing an overflow.342 NoAvailableResourceId,343 }344345 #[pallet::call]346 impl<T: Config> Pallet<T> {347 // todo :refactor replace every collection_id with rmrk_collection_id (and nft_id) in arguments for uniformity?348349 /// Create a new collection of NFTs.350 ///351 /// # Permissions:352 /// * Anyone - will be assigned as the issuer of the collection.353 ///354 /// # Arguments:355 /// - `origin`: sender of the transaction356 /// - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.357 /// - `max`: Optional maximum number of tokens.358 /// - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.359 /// Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.360 #[pallet::weight(<SelfWeightOf<T>>::create_collection())]361 pub fn create_collection(362 origin: OriginFor<T>,363 metadata: RmrkString,364 max: Option<u32>,365 symbol: RmrkCollectionSymbol,366 ) -> DispatchResult {367 let sender = ensure_signed(origin)?;368369 let limits = CollectionLimits {370 owner_can_transfer: Some(false),371 token_limit: max,372 ..Default::default()373 };374375 let data = CreateCollectionData {376 limits: Some(limits),377 token_prefix: symbol378 .into_inner()379 .try_into()380 .map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,381 permissions: Some(CollectionPermissions {382 nesting: Some(NestingPermissions {383 token_owner: true,384 collection_admin: false,385 restricted: None,386 #[cfg(feature = "runtime-benchmarks")]387 permissive: false,388 }),389 ..Default::default()390 }),391 ..Default::default()392 };393394 let unique_collection_id = Self::init_collection(395 T::CrossAccountId::from_sub(sender.clone()),396 data,397 [398 Self::encode_rmrk_property(Metadata, &metadata)?,399 Self::encode_rmrk_property(CollectionType, &misc::CollectionType::Regular)?,400 ]401 .into_iter(),402 )?;403 let rmrk_collection_id = <CollectionIndex<T>>::get();404405 <UniqueCollectionId<T>>::insert(rmrk_collection_id, unique_collection_id);406407 <PalletCommon<T>>::set_scoped_collection_property(408 unique_collection_id,409 RMRK_SCOPE,410 Self::encode_rmrk_property(RmrkInternalCollectionId, &rmrk_collection_id)?,411 )?;412413 <CollectionIndex<T>>::mutate(|n| *n += 1);414415 Self::deposit_event(Event::CollectionCreated {416 issuer: sender,417 collection_id: rmrk_collection_id,418 });419420 Ok(())421 }422423 /// Destroy a collection.424 ///425 /// Only empty collections can be destroyed. If it has any tokens, they must be burned first.426 ///427 /// # Permissions:428 /// * Collection issuer429 ///430 /// # Arguments:431 /// - `origin`: sender of the transaction432 /// - `collection_id`: RMRK ID of the collection to destroy.433 #[pallet::weight(<SelfWeightOf<T>>::destroy_collection())]434 pub fn destroy_collection(435 origin: OriginFor<T>,436 collection_id: RmrkCollectionId,437 ) -> DispatchResult {438 let sender = ensure_signed(origin)?;439 let cross_sender = T::CrossAccountId::from_sub(sender.clone());440441 let collection = Self::get_typed_nft_collection(442 Self::unique_collection_id(collection_id)?,443 misc::CollectionType::Regular,444 )?;445 collection.check_is_external()?;446447 <PalletNft<T>>::destroy_collection(collection, &cross_sender)448 .map_err(Self::map_unique_err_to_proxy)?;449450 Self::deposit_event(Event::CollectionDestroyed {451 issuer: sender,452 collection_id,453 });454455 Ok(())456 }457458 /// Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).459 ///460 /// # Permissions:461 /// * Collection issuer462 ///463 /// # Arguments:464 /// - `origin`: sender of the transaction465 /// - `collection_id`: RMRK collection ID to change the issuer of.466 /// - `new_issuer`: Collection's new issuer.467 #[pallet::weight(<SelfWeightOf<T>>::change_collection_issuer())]468 pub fn change_collection_issuer(469 origin: OriginFor<T>,470 collection_id: RmrkCollectionId,471 new_issuer: <T::Lookup as StaticLookup>::Source,472 ) -> DispatchResult {473 let sender = ensure_signed(origin)?;474475 let collection = Self::get_nft_collection(Self::unique_collection_id(collection_id)?)?;476 collection.check_is_external()?;477478 let new_issuer = T::Lookup::lookup(new_issuer)?;479480 Self::change_collection_owner(481 Self::unique_collection_id(collection_id)?,482 misc::CollectionType::Regular,483 sender.clone(),484 new_issuer.clone(),485 )?;486487 Self::deposit_event(Event::IssuerChanged {488 old_issuer: sender,489 new_issuer,490 collection_id,491 });492493 Ok(())494 }495496 /// "Lock" the collection and prevent new token creation. Cannot be undone.497 ///498 /// # Permissions:499 /// * Collection issuer500 ///501 /// # Arguments:502 /// - `origin`: sender of the transaction503 /// - `collection_id`: RMRK ID of the collection to lock.504 #[pallet::weight(<SelfWeightOf<T>>::lock_collection())]505 pub fn lock_collection(506 origin: OriginFor<T>,507 collection_id: RmrkCollectionId,508 ) -> DispatchResult {509 let sender = ensure_signed(origin)?;510 let cross_sender = T::CrossAccountId::from_sub(sender.clone());511512 let collection = Self::get_typed_nft_collection(513 Self::unique_collection_id(collection_id)?,514 misc::CollectionType::Regular,515 )?;516 collection.check_is_external()?;517518 Self::check_collection_owner(&collection, &cross_sender)?;519520 let token_count = collection.total_supply();521522 let mut collection = collection.into_inner();523 collection.limits.token_limit = Some(token_count);524 collection.save()?;525526 Self::deposit_event(Event::CollectionLocked {527 issuer: sender,528 collection_id,529 });530531 Ok(())532 }533534 /// Mint an NFT in a specified collection.535 ///536 /// # Permissions:537 /// * Collection issuer538 ///539 /// # Arguments:540 /// - `origin`: sender of the transaction541 /// - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).542 /// - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.543 /// - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.544 /// - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.545 /// - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.546 /// - `transferable`: Can this NFT be transferred? Cannot be changed.547 /// - `resources`: Resource data to be added to the NFT immediately after minting.548 #[pallet::weight(<SelfWeightOf<T>>::mint_nft(resources.as_ref().map(|r| r.len() as u32).unwrap_or(0)))]549 pub fn mint_nft(550 origin: OriginFor<T>,551 owner: Option<T::AccountId>,552 collection_id: RmrkCollectionId,553 recipient: Option<T::AccountId>,554 royalty_amount: Option<Permill>,555 metadata: RmrkString,556 transferable: bool,557 resources: Option<BoundedVec<RmrkResourceTypes, MaxResourcesOnMint>>,558 ) -> DispatchResult {559 let sender = ensure_signed(origin)?;560 let cross_sender = T::CrossAccountId::from_sub(sender.clone());561562 let owner = owner.unwrap_or(sender.clone());563 let cross_owner = T::CrossAccountId::from_sub(owner.clone());564565 let collection = Self::get_typed_nft_collection(566 Self::unique_collection_id(collection_id)?,567 misc::CollectionType::Regular,568 )?;569 collection.check_is_external()?;570571 let royalty_info = royalty_amount.map(|amount| rmrk_traits::RoyaltyInfo {572 recipient: recipient.unwrap_or_else(|| owner.clone()),573 amount,574 });575576 let nft_id = Self::create_nft(577 &cross_sender,578 &cross_owner,579 &collection,580 [581 Self::encode_rmrk_property(TokenType, &NftType::Regular)?,582 Self::encode_rmrk_property(Transferable, &transferable)?,583 Self::encode_rmrk_property(PendingNftAccept, &None::<PendingTarget>)?,584 Self::encode_rmrk_property(RoyaltyInfo, &royalty_info)?,585 Self::encode_rmrk_property(Metadata, &metadata)?,586 Self::encode_rmrk_property(Equipped, &false)?,587 Self::encode_rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,588 Self::encode_rmrk_property(NextResourceId, &(0 as RmrkResourceId))?,589 Self::encode_rmrk_property(PendingChildren, &PendingChildrenSet::new())?,590 Self::encode_rmrk_property(AssociatedBases, &BasesMap::new())?,591 ]592 .into_iter(),593 )594 .map_err(|err| match err {595 DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),596 err => Self::map_unique_err_to_proxy(err),597 })?;598599 if let Some(resources) = resources {600 for resource in resources {601 Self::resource_add(sender.clone(), collection.id, nft_id, resource)?;602 }603 }604605 Self::deposit_event(Event::NftMinted {606 owner,607 collection_id,608 nft_id: nft_id.0,609 });610611 Ok(())612 }613614 /// Burn an NFT, destroying it and its nested tokens up to the specified limit.615 /// If the burning budget is exceeded, the transaction is reverted.616 ///617 /// This is the way to burn a nested token as well.618 ///619 /// For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).620 ///621 /// # Permissions:622 /// * Token owner623 ///624 /// # Arguments:625 /// - `origin`: sender of the transaction626 /// - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.627 /// - `nft_id`: ID of the NFT to be destroyed.628 /// - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction629 /// is reverted if there are more tokens to burn in the nesting tree than this number.630 /// This is primarily a mechanism of transaction weight control.631 #[pallet::weight(<SelfWeightOf<T>>::burn_nft(*max_burns))]632 pub fn burn_nft(633 origin: OriginFor<T>,634 collection_id: RmrkCollectionId,635 nft_id: RmrkNftId,636 max_burns: u32,637 ) -> DispatchResult {638 let sender = ensure_signed(origin)?;639 let cross_sender = T::CrossAccountId::from_sub(sender.clone());640641 let collection = Self::get_typed_nft_collection(642 Self::unique_collection_id(collection_id)?,643 misc::CollectionType::Regular,644 )?;645 collection.check_is_external()?;646647 Self::destroy_nft(648 cross_sender,649 Self::unique_collection_id(collection_id)?,650 nft_id.into(),651 max_burns,652 <Error<T>>::NoPermission,653 )654 .map_err(|err| Self::map_unique_err_to_proxy(err.error))?;655656 Self::deposit_event(Event::NFTBurned {657 owner: sender,658 nft_id,659 });660661 Ok(())662 }663664 /// Transfer an NFT from an account/NFT A to another account/NFT B.665 /// The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].666 ///667 /// If the target owner is an NFT owned by another account, then the NFT will enter668 /// the pending state and will have to be accepted by the other account.669 ///670 /// # Permissions:671 /// - Token owner672 ///673 /// # Arguments:674 /// - `origin`: sender of the transaction675 /// - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.676 /// - `rmrk_nft_id`: ID of the NFT to be transferred.677 /// - `new_owner`: New owner of the nft which can be either an account or a NFT.678 #[pallet::weight(<SelfWeightOf<T>>::send())]679 pub fn send(680 origin: OriginFor<T>,681 rmrk_collection_id: RmrkCollectionId,682 rmrk_nft_id: RmrkNftId,683 new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,684 ) -> DispatchResult {685 let sender = ensure_signed(origin.clone())?;686 let cross_sender = T::CrossAccountId::from_sub(sender.clone());687688 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;689 let nft_id = rmrk_nft_id.into();690691 let collection =692 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;693 collection.check_is_external()?;694695 let token_data =696 <TokenData<T>>::get((collection_id, nft_id)).ok_or(<Error<T>>::NoAvailableNftId)?;697698 let from = token_data.owner;699700 ensure!(701 Self::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Transferable)?,702 <Error<T>>::NonTransferable703 );704705 ensure!(706 Self::get_nft_property_decoded::<Option<PendingTarget>>(707 collection_id,708 nft_id,709 RmrkProperty::PendingNftAccept710 )?711 .is_none(),712 <Error<T>>::NoPermission713 );714715 let target_owner;716 let approval_required;717718 match new_owner {719 RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {720 target_owner = T::CrossAccountId::from_sub(account_id.clone());721 approval_required = false;722 }723 RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(724 target_collection_id,725 target_nft_id,726 ) => {727 let target_collection_id = Self::unique_collection_id(target_collection_id)?;728729 let target_nft_budget = budget::Value::new(NESTING_BUDGET);730731 let target_nft_owner = <PalletStructure<T>>::get_checked_topmost_owner(732 target_collection_id,733 target_nft_id.into(),734 Some((collection_id, nft_id)),735 &target_nft_budget,736 )737 .map_err(Self::map_unique_err_to_proxy)?;738739 approval_required = cross_sender != target_nft_owner;740741 if approval_required {742 target_owner = target_nft_owner;743744 <PalletNft<T>>::set_scoped_token_property(745 collection.id,746 nft_id,747 RMRK_SCOPE,748 Self::encode_rmrk_property::<Option<PendingTarget>>(749 PendingNftAccept,750 &Some((target_collection_id, target_nft_id.into())),751 )?,752 )?;753754 Self::insert_pending_child(755 (target_collection_id, target_nft_id.into()),756 (rmrk_collection_id, rmrk_nft_id),757 )?;758 } else {759 target_owner = T::CrossTokenAddressMapping::token_to_address(760 target_collection_id,761 target_nft_id.into(),762 );763 }764 }765 }766767 let src_nft_budget = budget::Value::new(NESTING_BUDGET);768769 <PalletNft<T>>::transfer_from(770 &collection,771 &cross_sender,772 &from,773 &target_owner,774 nft_id,775 &src_nft_budget,776 )777 .map_err(Self::map_unique_err_to_proxy)?;778779 Self::deposit_event(Event::NFTSent {780 sender,781 recipient: new_owner,782 collection_id: rmrk_collection_id,783 nft_id: rmrk_nft_id,784 approval_required,785 });786787 Ok(())788 }789790 /// Accept an NFT sent from another account to self or an owned NFT.791 ///792 /// The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.793 ///794 /// # Permissions:795 /// - Token-owner-to-be796 ///797 /// # Arguments:798 /// - `origin`: sender of the transaction799 /// - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.800 /// - `rmrk_nft_id`: ID of the NFT to be accepted.801 /// - `new_owner`: Either the sender's account ID or a sender-owned NFT,802 /// whichever the accepted NFT was sent to.803 #[pallet::weight(<SelfWeightOf<T>>::accept_nft())]804 pub fn accept_nft(805 origin: OriginFor<T>,806 rmrk_collection_id: RmrkCollectionId,807 rmrk_nft_id: RmrkNftId,808 new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,809 ) -> DispatchResult {810 let sender = ensure_signed(origin.clone())?;811 let cross_sender = T::CrossAccountId::from_sub(sender.clone());812813 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;814 let nft_id = rmrk_nft_id.into();815816 let collection =817 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;818 collection.check_is_external()?;819820 let new_cross_owner = match new_owner {821 RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {822 T::CrossAccountId::from_sub(account_id.clone())823 }824 RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(825 target_collection_id,826 target_nft_id,827 ) => {828 let target_collection_id = Self::unique_collection_id(target_collection_id)?;829830 T::CrossTokenAddressMapping::token_to_address(831 target_collection_id,832 TokenId(target_nft_id),833 )834 }835 };836837 let budget = budget::Value::new(NESTING_BUDGET);838839 <PalletNft<T>>::transfer(840 &collection,841 &cross_sender,842 &new_cross_owner,843 nft_id,844 &budget,845 )846 .map_err(|err| {847 if err == <CommonError<T>>::UserIsNotAllowedToNest.into() {848 <Error<T>>::CannotAcceptNonOwnedNft.into()849 } else {850 Self::map_unique_err_to_proxy(err)851 }852 })?;853854 let pending_target = Self::get_nft_property_decoded::<Option<PendingTarget>>(855 collection_id,856 nft_id,857 RmrkProperty::PendingNftAccept,858 )?;859860 if let Some(pending_target) = pending_target {861 Self::remove_pending_child(pending_target, (rmrk_collection_id, rmrk_nft_id))?;862863 <PalletNft<T>>::set_scoped_token_property(864 collection.id,865 nft_id,866 RMRK_SCOPE,867 Self::encode_rmrk_property(PendingNftAccept, &None::<PendingTarget>)?,868 )?;869 }870871 Self::deposit_event(Event::NFTAccepted {872 sender,873 recipient: new_owner,874 collection_id: rmrk_collection_id,875 nft_id: rmrk_nft_id,876 });877878 Ok(())879 }880881 /// Reject an NFT sent from another account to self or owned NFT.882 /// The NFT in question will not be sent back and burnt instead.883 ///884 /// The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.885 ///886 /// # Permissions:887 /// - Token-owner-to-be-not888 ///889 /// # Arguments:890 /// - `origin`: sender of the transaction891 /// - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.892 /// - `rmrk_nft_id`: ID of the NFT to be rejected.893 #[pallet::weight(<SelfWeightOf<T>>::reject_nft())]894 pub fn reject_nft(895 origin: OriginFor<T>,896 rmrk_collection_id: RmrkCollectionId,897 rmrk_nft_id: RmrkNftId,898 ) -> DispatchResult {899 let sender = ensure_signed(origin)?;900 let cross_sender = T::CrossAccountId::from_sub(sender.clone());901902 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;903 let nft_id = rmrk_nft_id.into();904905 let collection =906 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;907 collection.check_is_external()?;908909 ensure!(910 <TokenData<T>>::get((collection_id, nft_id)).is_some(),911 <Error<T>>::NoAvailableNftId912 );913914 let pending_target = Self::get_nft_property_decoded::<Option<PendingTarget>>(915 collection_id,916 nft_id,917 RmrkProperty::PendingNftAccept,918 )?;919920 match pending_target {921 Some(pending_target) => {922 Self::remove_pending_child(pending_target, (rmrk_collection_id, rmrk_nft_id))?923 }924 None => return Err(<Error<T>>::CannotRejectNonPendingNft.into()),925 }926927 Self::destroy_nft(928 cross_sender,929 collection_id,930 nft_id,931 NESTING_BUDGET,932 <Error<T>>::CannotRejectNonOwnedNft,933 )934 .map_err(|err| Self::map_unique_err_to_proxy(err.error))?;935936 Self::deposit_event(Event::NFTRejected {937 sender,938 collection_id: rmrk_collection_id,939 nft_id: rmrk_nft_id,940 });941942 Ok(())943 }944945 /// Accept the addition of a newly created pending resource to an existing NFT.946 ///947 /// This transaction is needed when a resource is created and assigned to an NFT948 /// by a non-owner, i.e. the collection issuer, with one of the949 /// [`add_...` transactions](Pallet::add_basic_resource).950 ///951 /// # Permissions:952 /// - Token owner953 ///954 /// # Arguments:955 /// - `origin`: sender of the transaction956 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.957 /// - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.958 /// - `resource_id`: ID of the newly created pending resource.959 /// accept the addition of a new resource to an existing NFT960 #[pallet::weight(<SelfWeightOf<T>>::accept_resource())]961 pub fn accept_resource(962 origin: OriginFor<T>,963 rmrk_collection_id: RmrkCollectionId,964 rmrk_nft_id: RmrkNftId,965 resource_id: RmrkResourceId,966 ) -> DispatchResult {967 let sender = ensure_signed(origin)?;968 let cross_sender = T::CrossAccountId::from_sub(sender);969970 let collection_id = Self::unique_collection_id(rmrk_collection_id)971 .map_err(|_| <Error<T>>::ResourceDoesntExist)?;972 let collection =973 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;974 collection.check_is_external()?;975976 let nft_id = rmrk_nft_id.into();977978 let budget = budget::Value::new(NESTING_BUDGET);979980 let nft_owner =981 <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)982 .map_err(|_| <Error<T>>::ResourceDoesntExist)?;983984 Self::try_mutate_resource_info(collection_id, nft_id, resource_id, |res| {985 ensure!(res.pending, <Error<T>>::ResourceNotPending);986 ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);987988 res.pending = false;989990 Ok(())991 })?;992993 Self::deposit_event(Event::<T>::ResourceAccepted {994 nft_id: rmrk_nft_id,995 resource_id,996 });997998 Ok(())999 }10001001 /// Accept the removal of a removal-pending resource from an NFT.1002 ///1003 /// This transaction is needed when a non-owner, i.e. the collection issuer,1004 /// requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.1005 ///1006 /// # Permissions:1007 /// - Token owner1008 ///1009 /// # Arguments:1010 /// - `origin`: sender of the transaction1011 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1012 /// - `rmrk_nft_id`: ID of the NFT with a resource to be removed.1013 /// - `resource_id`: ID of the removal-pending resource.1014 #[pallet::weight(<SelfWeightOf<T>>::accept_resource_removal())]1015 pub fn accept_resource_removal(1016 origin: OriginFor<T>,1017 rmrk_collection_id: RmrkCollectionId,1018 rmrk_nft_id: RmrkNftId,1019 resource_id: RmrkResourceId,1020 ) -> DispatchResult {1021 let sender = ensure_signed(origin)?;1022 let cross_sender = T::CrossAccountId::from_sub(sender);10231024 let collection_id = Self::unique_collection_id(rmrk_collection_id)1025 .map_err(|_| <Error<T>>::ResourceDoesntExist)?;1026 let collection =1027 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1028 collection.check_is_external()?;10291030 let nft_id = rmrk_nft_id.into();10311032 let budget = budget::Value::new(NESTING_BUDGET);10331034 let nft_owner =1035 <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)1036 .map_err(|_| <Error<T>>::ResourceDoesntExist)?;10371038 ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);10391040 let resource_id_key = Self::get_scoped_property_key(ResourceId(resource_id))?;10411042 let resource_info = <PalletNft<T>>::token_aux_property((1043 collection_id,1044 nft_id,1045 RMRK_SCOPE,1046 resource_id_key.clone(),1047 ))1048 .ok_or(<Error<T>>::ResourceDoesntExist)?;10491050 let resource_info: RmrkResourceInfo = Self::decode_property_value(&resource_info)?;10511052 ensure!(1053 resource_info.pending_removal,1054 <Error<T>>::ResourceNotPending1055 );10561057 <PalletNft<T>>::remove_token_aux_property(1058 collection_id,1059 nft_id,1060 RMRK_SCOPE,1061 resource_id_key,1062 );10631064 if let RmrkResourceTypes::Composable(resource) = resource_info.resource {1065 let base_id = resource.base;10661067 Self::remove_associated_base_id(collection_id, nft_id, base_id)?;1068 }10691070 Self::deposit_event(Event::<T>::ResourceRemovalAccepted {1071 nft_id: rmrk_nft_id,1072 resource_id,1073 });10741075 Ok(())1076 }10771078 /// Add or edit a custom user property, a key-value pair, describing the metadata1079 /// of a token or a collection, on either one of these.1080 ///1081 /// Note that in this proxy implementation many details regarding RMRK are stored1082 /// as scoped properties prefixed with "rmrk:", normally inaccessible1083 /// to external transactions and RPCs.1084 ///1085 /// # Permissions:1086 /// - Collection issuer - in case of collection property1087 /// - Token owner - in case of NFT property1088 ///1089 /// # Arguments:1090 /// - `origin`: sender of the transaction1091 /// - `rmrk_collection_id`: RMRK collection ID.1092 /// - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.1093 /// - `key`: Key of the custom property to be referenced by.1094 /// - `value`: Value of the custom property to be stored.1095 #[pallet::weight(<SelfWeightOf<T>>::set_property())]1096 pub fn set_property(1097 origin: OriginFor<T>,1098 #[pallet::compact] rmrk_collection_id: RmrkCollectionId,1099 maybe_nft_id: Option<RmrkNftId>,1100 key: RmrkKeyString,1101 value: RmrkValueString,1102 ) -> DispatchResult {1103 let sender = ensure_signed(origin)?;1104 let sender = T::CrossAccountId::from_sub(sender);11051106 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1107 let collection =1108 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1109 collection.check_is_external()?;11101111 let budget = budget::Value::new(NESTING_BUDGET);11121113 match maybe_nft_id {1114 Some(nft_id) => {1115 let token_id: TokenId = nft_id.into();11161117 Self::ensure_nft_type(collection_id, token_id, NftType::Regular)?;1118 Self::ensure_nft_owner(collection_id, token_id, &sender, &budget)?;11191120 <PalletNft<T>>::set_scoped_token_property(1121 collection_id,1122 token_id,1123 RMRK_SCOPE,1124 Self::encode_rmrk_property(UserProperty(key.as_slice()), &value)?,1125 )?;1126 }1127 None => {1128 let collection = Self::get_typed_nft_collection(1129 collection_id,1130 misc::CollectionType::Regular,1131 )?;11321133 Self::check_collection_owner(&collection, &sender)?;11341135 <PalletCommon<T>>::set_scoped_collection_property(1136 collection_id,1137 RMRK_SCOPE,1138 Self::encode_rmrk_property(UserProperty(key.as_slice()), &value)?,1139 )?;1140 }1141 }11421143 Self::deposit_event(Event::PropertySet {1144 collection_id: rmrk_collection_id,1145 maybe_nft_id,1146 key,1147 value,1148 });11491150 Ok(())1151 }11521153 /// Set a different order of resource priorities for an NFT. Priorities can be used,1154 /// for example, for order of rendering.1155 ///1156 /// Note that the priorities are not updated automatically, and are an empty vector1157 /// by default. There is no pre-set definition for the order to be particular,1158 /// it can be interpreted arbitrarily use-case by use-case.1159 ///1160 /// # Permissions:1161 /// - Token owner1162 ///1163 /// # Arguments:1164 /// - `origin`: sender of the transaction1165 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1166 /// - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.1167 /// - `priorities`: Ordered vector of resource IDs.1168 #[pallet::weight(<SelfWeightOf<T>>::set_priority())]1169 pub fn set_priority(1170 origin: OriginFor<T>,1171 rmrk_collection_id: RmrkCollectionId,1172 rmrk_nft_id: RmrkNftId,1173 priorities: BoundedVec<RmrkResourceId, RmrkMaxPriorities>,1174 ) -> DispatchResult {1175 let sender = ensure_signed(origin)?;1176 let sender = T::CrossAccountId::from_sub(sender);11771178 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1179 let nft_id = rmrk_nft_id.into();11801181 let collection =1182 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1183 collection.check_is_external()?;11841185 let budget = budget::Value::new(NESTING_BUDGET);11861187 Self::ensure_nft_type(collection_id, nft_id, NftType::Regular)?;1188 Self::ensure_nft_owner(collection_id, nft_id, &sender, &budget)?;11891190 <PalletNft<T>>::set_scoped_token_property(1191 collection_id,1192 nft_id,1193 RMRK_SCOPE,1194 Self::encode_rmrk_property(ResourcePriorities, &priorities.into_inner())?,1195 )?;11961197 Self::deposit_event(Event::<T>::PrioritySet {1198 collection_id: rmrk_collection_id,1199 nft_id: rmrk_nft_id,1200 });12011202 Ok(())1203 }12041205 /// Create and set/propose a basic resource for an NFT.1206 ///1207 /// A basic resource is the simplest, lacking a Base and anything that comes with it.1208 /// See RMRK docs for more information and examples.1209 ///1210 /// # Permissions:1211 /// - Collection issuer - if not the token owner, adding the resource will warrant1212 /// the owner's [acceptance](Pallet::accept_resource).1213 ///1214 /// # Arguments:1215 /// - `origin`: sender of the transaction1216 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1217 /// - `nft_id`: ID of the NFT to assign a resource to.1218 /// - `resource`: Data of the resource to be created.1219 #[pallet::weight(<SelfWeightOf<T>>::add_basic_resource())]1220 pub fn add_basic_resource(1221 origin: OriginFor<T>,1222 rmrk_collection_id: RmrkCollectionId,1223 nft_id: RmrkNftId,1224 resource: RmrkBasicResource,1225 ) -> DispatchResult {1226 let sender = ensure_signed(origin.clone())?;12271228 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1229 let collection =1230 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1231 collection.check_is_external()?;12321233 let resource_id = Self::resource_add(1234 sender,1235 collection_id,1236 nft_id.into(),1237 RmrkResourceTypes::Basic(resource),1238 )?;12391240 Self::deposit_event(Event::ResourceAdded {1241 nft_id,1242 resource_id,1243 });1244 Ok(())1245 }12461247 /// Create and set/propose a composable resource for an NFT.1248 ///1249 /// A composable resource links to a Base and has a subset of its Parts it is composed of.1250 /// See RMRK docs for more information and examples.1251 ///1252 /// # Permissions:1253 /// - Collection issuer - if not the token owner, adding the resource will warrant1254 /// the owner's [acceptance](Pallet::accept_resource).1255 ///1256 /// # Arguments:1257 /// - `origin`: sender of the transaction1258 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1259 /// - `nft_id`: ID of the NFT to assign a resource to.1260 /// - `resource`: Data of the resource to be created.1261 #[pallet::weight(<SelfWeightOf<T>>::add_composable_resource())]1262 pub fn add_composable_resource(1263 origin: OriginFor<T>,1264 rmrk_collection_id: RmrkCollectionId,1265 nft_id: RmrkNftId,1266 resource: RmrkComposableResource,1267 ) -> DispatchResult {1268 let sender = ensure_signed(origin.clone())?;12691270 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1271 let collection =1272 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1273 collection.check_is_external()?;12741275 let base_id = resource.base;12761277 let resource_id = Self::resource_add(1278 sender,1279 collection_id,1280 nft_id.into(),1281 RmrkResourceTypes::Composable(resource),1282 )?;12831284 <PalletNft<T>>::try_mutate_token_aux_property(1285 collection_id,1286 nft_id.into(),1287 RMRK_SCOPE,1288 Self::get_scoped_property_key(AssociatedBases)?,1289 |value| -> DispatchResult {1290 let mut bases: BasesMap = match value {1291 Some(value) => Self::decode_property_value(value)?,1292 None => BasesMap::new(),1293 };12941295 *bases.entry(base_id).or_insert(0) += 1;12961297 *value = Some(Self::encode_property_value(&bases)?);1298 Ok(())1299 },1300 )?;13011302 Self::deposit_event(Event::ResourceAdded {1303 nft_id,1304 resource_id,1305 });1306 Ok(())1307 }13081309 /// Create and set/propose a slot resource for an NFT.1310 ///1311 /// A slot resource links to a Base and a slot ID in it which it can fit into.1312 /// See RMRK docs for more information and examples.1313 ///1314 /// # Permissions:1315 /// - Collection issuer - if not the token owner, adding the resource will warrant1316 /// the owner's [acceptance](Pallet::accept_resource).1317 ///1318 /// # Arguments:1319 /// - `origin`: sender of the transaction1320 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1321 /// - `nft_id`: ID of the NFT to assign a resource to.1322 /// - `resource`: Data of the resource to be created.1323 #[pallet::weight(<SelfWeightOf<T>>::add_slot_resource())]1324 pub fn add_slot_resource(1325 origin: OriginFor<T>,1326 rmrk_collection_id: RmrkCollectionId,1327 nft_id: RmrkNftId,1328 resource: RmrkSlotResource,1329 ) -> DispatchResult {1330 let sender = ensure_signed(origin.clone())?;13311332 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1333 let collection =1334 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1335 collection.check_is_external()?;13361337 let resource_id = Self::resource_add(1338 sender,1339 collection_id,1340 nft_id.into(),1341 RmrkResourceTypes::Slot(resource),1342 )?;13431344 Self::deposit_event(Event::ResourceAdded {1345 nft_id,1346 resource_id,1347 });1348 Ok(())1349 }13501351 /// Remove and erase a resource from an NFT.1352 ///1353 /// If the sender does not own the NFT, then it will be pending confirmation,1354 /// and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.1355 ///1356 /// # Permissions1357 /// - Collection issuer1358 ///1359 /// # Arguments1360 /// - `origin`: sender of the transaction1361 /// - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.1362 /// - `nft_id`: ID of the NFT with a resource to be removed.1363 /// - `resource_id`: ID of the resource to be removed.1364 #[pallet::weight(<SelfWeightOf<T>>::remove_resource())]1365 pub fn remove_resource(1366 origin: OriginFor<T>,1367 rmrk_collection_id: RmrkCollectionId,1368 nft_id: RmrkNftId,1369 resource_id: RmrkResourceId,1370 ) -> DispatchResult {1371 let sender = ensure_signed(origin.clone())?;13721373 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1374 let collection =1375 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1376 collection.check_is_external()?;13771378 Self::resource_remove(sender, collection_id, nft_id.into(), resource_id)?;13791380 Self::deposit_event(Event::ResourceRemoval {1381 nft_id,1382 resource_id,1383 });1384 Ok(())1385 }1386 }1387}13881389impl<T: Config> Pallet<T> {1390 /// Transform one of possible RMRK keys into a byte key with a RMRK scope.1391 pub fn get_scoped_property_key(rmrk_key: RmrkProperty) -> Result<PropertyKey, DispatchError> {1392 let key = rmrk_key.to_key::<T>()?;13931394 let scoped_key = RMRK_SCOPE1395 .apply(key)1396 .map_err(|_| <Error<T>>::RmrkPropertyKeyIsTooLong)?;13971398 Ok(scoped_key)1399 }14001401 /// Form a Unique property, transforming a RMRK key into bytes (without assigning the scope yet)1402 /// and encoding the value from an arbitrary type into bytes.1403 pub fn encode_rmrk_property<E: Encode>(1404 rmrk_key: RmrkProperty,1405 value: &E,1406 ) -> Result<Property, DispatchError> {1407 let key = rmrk_key.to_key::<T>()?;14081409 let value = Self::encode_property_value(value)?;14101411 let property = Property { key, value };14121413 Ok(property)1414 }14151416 /// Encode property value from an arbitrary type into bytes for storage.1417 pub fn encode_property_value<E: Encode, S: Get<u32>>(1418 value: &E,1419 ) -> Result<BoundedBytes<S>, DispatchError> {1420 let value = value1421 .encode()1422 .try_into()1423 .map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong)?;14241425 Ok(value)1426 }14271428 /// Decode property value from bytes into an arbitrary type.1429 pub fn decode_property_value<D: Decode, S: Get<u32>>(1430 vec: &BoundedBytes<S>,1431 ) -> Result<D, DispatchError> {1432 vec.decode()1433 .map_err(|_| <Error<T>>::UnableToDecodeRmrkData.into())1434 }14351436 /// Change the limit of a property value byte vector.1437 pub fn rebind<L, S>(vec: &BoundedVec<u8, L>) -> Result<BoundedVec<u8, S>, DispatchError>1438 where1439 BoundedVec<u8, S>: TryFrom<Vec<u8>>,1440 {1441 vec.rebind()1442 .map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong.into())1443 }14441445 /// Initialize a new NFT collection with certain RMRK-scoped properties.1446 ///1447 /// See [`init_collection`](pallet_nonfungible::pallet::Pallet::init_collection) for more details.1448 fn init_collection(1449 sender: T::CrossAccountId,1450 data: CreateCollectionData<T::AccountId>,1451 properties: impl Iterator<Item = Property>,1452 ) -> Result<CollectionId, DispatchError> {1453 let collection_id = <PalletNft<T>>::init_collection(1454 sender.clone(),1455 sender,1456 data,1457 up_data_structs::CollectionFlags {1458 external: true,1459 ..Default::default()1460 },1461 );14621463 if let Err(DispatchError::Arithmetic(_)) = &collection_id {1464 return Err(<Error<T>>::NoAvailableCollectionId.into());1465 }14661467 <PalletCommon<T>>::set_scoped_collection_properties(1468 collection_id?,1469 RMRK_SCOPE,1470 properties,1471 )?;14721473 collection_id1474 }14751476 /// Mint a new NFT with certain RMRK-scoped properties. Sender must be the collection owner.1477 ///1478 /// See [`create_item`](pallet_nonfungible::pallet::Pallet::create_item) for more details.1479 pub fn create_nft(1480 sender: &T::CrossAccountId,1481 owner: &T::CrossAccountId,1482 collection: &NonfungibleHandle<T>,1483 properties: impl Iterator<Item = Property>,1484 ) -> Result<TokenId, DispatchError> {1485 let data = CreateNftExData {1486 properties: BoundedVec::default(),1487 owner: owner.clone(),1488 };14891490 let budget = budget::Value::new(NESTING_BUDGET);14911492 <PalletNft<T>>::create_item(collection, sender, data, &budget)?;14931494 let nft_id = <PalletNft<T>>::current_token_id(collection.id);14951496 <PalletNft<T>>::set_scoped_token_properties(collection.id, nft_id, RMRK_SCOPE, properties)?;14971498 Ok(nft_id)1499 }15001501 /// Burn an NFT, along with its nested children, limited by `max_burns`. The sender must be the token owner.1502 ///1503 /// See [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively) for more details.1504 fn destroy_nft(1505 sender: T::CrossAccountId,1506 collection_id: CollectionId,1507 token_id: TokenId,1508 max_burns: u32,1509 error_if_not_owned: Error<T>,1510 ) -> DispatchResultWithPostInfo {1511 let collection =1512 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;15131514 let token_data =1515 <TokenData<T>>::get((collection_id, token_id)).ok_or(<Error<T>>::NoAvailableNftId)?;15161517 let from = token_data.owner;15181519 let owner_check_budget = budget::Value::new(NESTING_BUDGET);15201521 ensure!(1522 <PalletStructure<T>>::check_indirectly_owned(1523 sender.clone(),1524 collection_id,1525 token_id,1526 None,1527 &owner_check_budget1528 )?,1529 error_if_not_owned,1530 );15311532 let burns_budget = budget::Value::new(max_burns);1533 let breadth_budget = budget::Value::new(max_burns);15341535 <PalletNft<T>>::burn_recursively(1536 &collection,1537 &from,1538 token_id,1539 &burns_budget,1540 &breadth_budget,1541 )1542 }15431544 /// Add a sent token pending acceptance to the target owning token as a property.1545 fn insert_pending_child(1546 target: (CollectionId, TokenId),1547 child: (RmrkCollectionId, RmrkNftId),1548 ) -> DispatchResult {1549 Self::mutate_pending_children(target, |pending_children| {1550 pending_children.insert(child);1551 })1552 }15531554 /// Remove a sent token pending acceptance from the target token's properties.1555 fn remove_pending_child(1556 target: (CollectionId, TokenId),1557 child: (RmrkCollectionId, RmrkNftId),1558 ) -> DispatchResult {1559 Self::mutate_pending_children(target, |pending_children| {1560 pending_children.remove(&child);1561 })1562 }15631564 /// Apply a mutation to the property of a token containing sent tokens1565 /// that are currently pending acceptance.1566 fn mutate_pending_children(1567 (target_collection_id, target_nft_id): (CollectionId, TokenId),1568 f: impl FnOnce(&mut PendingChildrenSet),1569 ) -> DispatchResult {1570 <PalletNft<T>>::try_mutate_token_aux_property(1571 target_collection_id,1572 target_nft_id,1573 RMRK_SCOPE,1574 Self::get_scoped_property_key(PendingChildren)?,1575 |pending_children| -> DispatchResult {1576 let mut map = match pending_children {1577 Some(map) => Self::decode_property_value(map)?,1578 None => PendingChildrenSet::new(),1579 };15801581 f(&mut map);15821583 *pending_children = Some(Self::encode_property_value(&map)?);15841585 Ok(())1586 },1587 )1588 }15891590 /// Get an iterator from a token's property containing tokens sent to it1591 /// that are currently pending acceptance.1592 fn iterate_pending_children(1593 collection_id: CollectionId,1594 nft_id: TokenId,1595 ) -> Result<impl Iterator<Item = PendingChild>, DispatchError> {1596 let property = <PalletNft<T>>::token_aux_property((1597 collection_id,1598 nft_id,1599 RMRK_SCOPE,1600 Self::get_scoped_property_key(PendingChildren)?,1601 ));16021603 let pending_children = match property {1604 Some(map) => Self::decode_property_value(&map)?,1605 None => PendingChildrenSet::new(),1606 };16071608 Ok(pending_children.into_iter())1609 }16101611 /// Get incremented resource ID from within an NFT's properties and store the new latest ID.1612 /// Thus, the returned resource ID should be used.1613 ///1614 /// Resource IDs are unique only across an NFT.1615 fn acquire_next_resource_id(1616 collection_id: CollectionId,1617 nft_id: TokenId,1618 ) -> Result<RmrkResourceId, DispatchError> {1619 let resource_id: RmrkResourceId =1620 Self::get_nft_property_decoded(collection_id, nft_id, NextResourceId)?;16211622 let next_id = resource_id1623 .checked_add(1)1624 .ok_or(<Error<T>>::NoAvailableResourceId)?;16251626 <PalletNft<T>>::set_scoped_token_property(1627 collection_id,1628 nft_id,1629 RMRK_SCOPE,1630 Self::encode_rmrk_property(NextResourceId, &next_id)?,1631 )?;16321633 Ok(resource_id)1634 }16351636 /// Create and add a resource for a regular NFT, mark it as pending if the sender1637 /// is not the token owner. The sender must be the collection owner.1638 fn resource_add(1639 sender: T::AccountId,1640 collection_id: CollectionId,1641 nft_id: TokenId,1642 resource: RmrkResourceTypes,1643 ) -> Result<RmrkResourceId, DispatchError> {1644 let collection =1645 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1646 ensure!(collection.owner == sender, Error::<T>::NoPermission);16471648 let sender = T::CrossAccountId::from_sub(sender);1649 let budget = budget::Value::new(NESTING_BUDGET);16501651 let nft_owner = <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)1652 .map_err(Self::map_unique_err_to_proxy)?;16531654 let pending = sender != nft_owner;16551656 let id = Self::acquire_next_resource_id(collection_id, nft_id)?;16571658 let resource_info = RmrkResourceInfo {1659 id,1660 resource,1661 pending,1662 pending_removal: false,1663 };16641665 <PalletNft<T>>::try_mutate_token_aux_property(1666 collection_id,1667 nft_id,1668 RMRK_SCOPE,1669 Self::get_scoped_property_key(ResourceId(id))?,1670 |value| -> DispatchResult {1671 *value = Some(Self::encode_property_value(&resource_info)?);16721673 Ok(())1674 },1675 )?;16761677 Ok(id)1678 }16791680 /// Designate a resource for erasure from an NFT, and remove it if the sender is the token owner.1681 /// The sender must be the collection owner.1682 fn resource_remove(1683 sender: T::AccountId,1684 collection_id: CollectionId,1685 nft_id: TokenId,1686 resource_id: RmrkResourceId,1687 ) -> DispatchResult {1688 let collection =1689 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1690 ensure!(collection.owner == sender, Error::<T>::NoPermission);16911692 let resource_id_key = Self::get_scoped_property_key(ResourceId(resource_id))?;16931694 let resource = <PalletNft<T>>::token_aux_property((1695 collection_id,1696 nft_id,1697 RMRK_SCOPE,1698 resource_id_key.clone(),1699 ))1700 .ok_or(<Error<T>>::ResourceDoesntExist)?;17011702 let resource_info: RmrkResourceInfo = Self::decode_property_value(&resource)?;17031704 let budget = up_data_structs::budget::Value::new(NESTING_BUDGET);1705 let topmost_owner =1706 <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)?;17071708 let sender = T::CrossAccountId::from_sub(sender);1709 if topmost_owner == sender {1710 <PalletNft<T>>::remove_token_aux_property(1711 collection_id,1712 nft_id,1713 RMRK_SCOPE,1714 Self::get_scoped_property_key(ResourceId(resource_id))?,1715 );17161717 if let RmrkResourceTypes::Composable(resource) = resource_info.resource {1718 let base_id = resource.base;17191720 Self::remove_associated_base_id(collection_id, nft_id, base_id)?;1721 }1722 } else {1723 Self::try_mutate_resource_info(collection_id, nft_id, resource_id, |res| {1724 res.pending_removal = true;17251726 Ok(())1727 })?;1728 }17291730 Ok(())1731 }17321733 /// Remove a Base ID from an NFT if they are associated.1734 /// The Base itself is deleted if the number of associated NFTs reaches 0.1735 fn remove_associated_base_id(1736 collection_id: CollectionId,1737 nft_id: TokenId,1738 base_id: RmrkBaseId,1739 ) -> DispatchResult {1740 <PalletNft<T>>::try_mutate_token_aux_property(1741 collection_id,1742 nft_id,1743 RMRK_SCOPE,1744 Self::get_scoped_property_key(AssociatedBases)?,1745 |value| -> DispatchResult {1746 let mut bases: BasesMap = match value {1747 Some(value) => Self::decode_property_value(value)?,1748 None => BasesMap::new(),1749 };17501751 let remaining = bases.get(&base_id);17521753 if let Some(remaining) = remaining {1754 if let Some(0) | None = remaining.checked_sub(1) {1755 bases.remove(&base_id);1756 }1757 }17581759 *value = Some(Self::encode_property_value(&bases)?);1760 Ok(())1761 },1762 )1763 }17641765 /// Apply a mutation to a resource stored in the token properties of an NFT.1766 fn try_mutate_resource_info(1767 collection_id: CollectionId,1768 nft_id: TokenId,1769 resource_id: RmrkResourceId,1770 f: impl FnOnce(&mut RmrkResourceInfo) -> DispatchResult,1771 ) -> DispatchResult {1772 <PalletNft<T>>::try_mutate_token_aux_property(1773 collection_id,1774 nft_id,1775 RMRK_SCOPE,1776 Self::get_scoped_property_key(ResourceId(resource_id))?,1777 |value| match value {1778 Some(value) => {1779 let mut resource_info: RmrkResourceInfo = Self::decode_property_value(value)?;17801781 f(&mut resource_info)?;17821783 *value = Self::encode_property_value(&resource_info)?;17841785 Ok(())1786 }1787 None => Err(<Error<T>>::ResourceDoesntExist.into()),1788 },1789 )1790 }17911792 /// Change the owner of an NFT collection, ensuring that the sender is the current owner.1793 fn change_collection_owner(1794 collection_id: CollectionId,1795 collection_type: misc::CollectionType,1796 sender: T::AccountId,1797 new_owner: T::AccountId,1798 ) -> DispatchResult {1799 let collection = Self::get_typed_nft_collection(collection_id, collection_type)?;1800 Self::check_collection_owner(&collection, &T::CrossAccountId::from_sub(sender))?;18011802 let mut collection = collection.into_inner();18031804 collection.owner = new_owner;1805 collection.save()1806 }18071808 /// Ensure that an account is the collection owner/issuer, return an error if not.1809 pub fn check_collection_owner(1810 collection: &NonfungibleHandle<T>,1811 account: &T::CrossAccountId,1812 ) -> DispatchResult {1813 collection1814 .check_is_owner(account)1815 .map_err(Self::map_unique_err_to_proxy)1816 }18171818 /// Get the latest yet-unused RMRK collection index from the storage.1819 pub fn last_collection_idx() -> RmrkCollectionId {1820 <CollectionIndex<T>>::get()1821 }18221823 /// Get a mapping from a RMRK collection ID to its corresponding Unique collection ID.1824 pub fn unique_collection_id(1825 rmrk_collection_id: RmrkCollectionId,1826 ) -> Result<CollectionId, DispatchError> {1827 <UniqueCollectionId<T>>::try_get(rmrk_collection_id)1828 .map_err(|_| <Error<T>>::CollectionUnknown.into())1829 }18301831 /// Get a mapping from a Unique collection ID to its RMRK collection ID counterpart, if it exists.1832 pub fn rmrk_collection_id(1833 unique_collection_id: CollectionId,1834 ) -> Result<RmrkCollectionId, DispatchError> {1835 Self::get_collection_property_decoded(unique_collection_id, RmrkInternalCollectionId)1836 }18371838 /// Fetch a Unique NFT collection.1839 pub fn get_nft_collection(1840 collection_id: CollectionId,1841 ) -> Result<NonfungibleHandle<T>, DispatchError> {1842 let collection = <CollectionHandle<T>>::try_get(collection_id)1843 .map_err(|_| <Error<T>>::CollectionUnknown)?;18441845 match collection.mode {1846 CollectionMode::NFT => Ok(NonfungibleHandle::cast(collection)),1847 _ => Err(<Error<T>>::CollectionUnknown.into()),1848 }1849 }18501851 /// Check if an NFT collection with such an ID exists.1852 pub fn collection_exists(collection_id: CollectionId) -> bool {1853 <CollectionHandle<T>>::try_get(collection_id).is_ok()1854 }18551856 /// Fetch and decode a RMRK-scoped collection property value in bytes.1857 pub fn get_collection_property(1858 collection_id: CollectionId,1859 key: RmrkProperty,1860 ) -> Result<PropertyValue, DispatchError> {1861 let collection_property = <PalletCommon<T>>::collection_properties(collection_id)1862 .get(&Self::get_scoped_property_key(key)?)1863 .ok_or(<Error<T>>::CollectionUnknown)?1864 .clone();18651866 Ok(collection_property)1867 }18681869 /// Fetch a RMRK-scoped collection property and decode it from bytes into an appropriate type.1870 pub fn get_collection_property_decoded<V: Decode>(1871 collection_id: CollectionId,1872 key: RmrkProperty,1873 ) -> Result<V, DispatchError> {1874 Self::decode_property_value(&Self::get_collection_property(collection_id, key)?)1875 }18761877 /// Get the type of a collection stored as a scoped property.1878 ///1879 /// RMRK Core proxy differentiates between regular collections as well as RMRK Bases as collections.1880 pub fn get_collection_type(1881 collection_id: CollectionId,1882 ) -> Result<misc::CollectionType, DispatchError> {1883 Self::get_collection_property_decoded(collection_id, CollectionType).map_err(|err| {1884 if err != <Error<T>>::CollectionUnknown.into() {1885 <Error<T>>::CorruptedCollectionType.into()1886 } else {1887 err1888 }1889 })1890 }18911892 /// Ensure that the type of the collection equals the provided type,1893 /// otherwise return an error.1894 pub fn ensure_collection_type(1895 collection_id: CollectionId,1896 collection_type: misc::CollectionType,1897 ) -> DispatchResult {1898 let actual_type = Self::get_collection_type(collection_id)?;1899 ensure!(1900 actual_type == collection_type,1901 <CommonError<T>>::NoPermission1902 );19031904 Ok(())1905 }19061907 /// Fetch an NFT collection, but make sure it has the appropriate type.1908 pub fn get_typed_nft_collection(1909 collection_id: CollectionId,1910 collection_type: misc::CollectionType,1911 ) -> Result<NonfungibleHandle<T>, DispatchError> {1912 Self::ensure_collection_type(collection_id, collection_type)?;19131914 Self::get_nft_collection(collection_id)1915 }19161917 /// Same as [`get_typed_nft_collection`](crate::pallet::Pallet::get_typed_nft_collection),1918 /// but also return the Unique collection ID.1919 pub fn get_typed_nft_collection_mapped(1920 rmrk_collection_id: RmrkCollectionId,1921 collection_type: misc::CollectionType,1922 ) -> Result<(NonfungibleHandle<T>, CollectionId), DispatchError> {1923 let unique_collection_id = match collection_type {1924 misc::CollectionType::Regular => Self::unique_collection_id(rmrk_collection_id)?,1925 _ => rmrk_collection_id.into(),1926 };19271928 let collection = Self::get_typed_nft_collection(unique_collection_id, collection_type)?;19291930 Ok((collection, unique_collection_id))1931 }19321933 /// Fetch and decode a RMRK-scoped NFT property value in bytes.1934 pub fn get_nft_property(1935 collection_id: CollectionId,1936 nft_id: TokenId,1937 key: RmrkProperty,1938 ) -> Result<PropertyValue, DispatchError> {1939 let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))1940 .get(&Self::get_scoped_property_key(key)?)1941 .ok_or(<Error<T>>::RmrkPropertyIsNotFound)?1942 .clone();19431944 Ok(nft_property)1945 }19461947 /// Fetch a RMRK-scoped NFT property and decode it from bytes into an appropriate type.1948 pub fn get_nft_property_decoded<V: Decode>(1949 collection_id: CollectionId,1950 nft_id: TokenId,1951 key: RmrkProperty,1952 ) -> Result<V, DispatchError> {1953 Self::decode_property_value(&Self::get_nft_property(collection_id, nft_id, key)?)1954 }19551956 /// Check that an NFT exists.1957 pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {1958 <TokenData<T>>::contains_key((collection_id, nft_id))1959 }19601961 /// Get the type of an NFT stored as a scoped property.1962 ///1963 /// RMRK Core proxy differentiates between regular NFTs, and RMRK Parts and Themes.1964 pub fn get_nft_type(1965 collection_id: CollectionId,1966 token_id: TokenId,1967 ) -> Result<NftType, DispatchError> {1968 Self::get_nft_property_decoded(collection_id, token_id, TokenType)1969 .map_err(|_| <Error<T>>::NoAvailableNftId.into())1970 }19711972 /// Ensure that the type of the NFT equals the provided type, otherwise return an error.1973 pub fn ensure_nft_type(1974 collection_id: CollectionId,1975 token_id: TokenId,1976 nft_type: NftType,1977 ) -> DispatchResult {1978 let actual_type = Self::get_nft_type(collection_id, token_id)?;1979 ensure!(actual_type == nft_type, <Error<T>>::NoPermission);19801981 Ok(())1982 }19831984 /// Ensure that an account is the owner of the token, either directly1985 /// or at the top of the nesting hierarchy; return an error if it is not.1986 pub fn ensure_nft_owner(1987 collection_id: CollectionId,1988 token_id: TokenId,1989 possible_owner: &T::CrossAccountId,1990 nesting_budget: &dyn budget::Budget,1991 ) -> DispatchResult {1992 let is_owned = <PalletStructure<T>>::check_indirectly_owned(1993 possible_owner.clone(),1994 collection_id,1995 token_id,1996 None,1997 nesting_budget,1998 )1999 .map_err(Self::map_unique_err_to_proxy)?;20002001 ensure!(is_owned, <Error<T>>::NoPermission);20022003 Ok(())2004 }20052006 /// Fetch non-scoped properties of a collection or a token that match the filter keys supplied,2007 /// or, if None are provided, return all non-scoped properties.2008 pub fn filter_user_properties<Key, Value, R, Mapper>(2009 collection_id: CollectionId,2010 token_id: Option<TokenId>,2011 filter_keys: Option<Vec<RmrkPropertyKey>>,2012 mapper: Mapper,2013 ) -> Result<Vec<R>, DispatchError>2014 where2015 Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,2016 Value: Decode + Default,2017 Mapper: Fn(Key, Value) -> R,2018 {2019 filter_keys2020 .map(|keys| {2021 let properties = keys2022 .into_iter()2023 .filter_map(|key| {2024 let key: Key = key.try_into().ok()?;20252026 let value = match token_id {2027 Some(token_id) => Self::get_nft_property_decoded(2028 collection_id,2029 token_id,2030 UserProperty(key.as_ref()),2031 ),2032 None => Self::get_collection_property_decoded(2033 collection_id,2034 UserProperty(key.as_ref()),2035 ),2036 }2037 .ok()?;20382039 Some(mapper(key, value))2040 })2041 .collect();20422043 Ok(properties)2044 })2045 .unwrap_or_else(|| {2046 let properties =2047 Self::iterate_user_properties(collection_id, token_id, mapper)?.collect();20482049 Ok(properties)2050 })2051 }20522053 /// Get all non-scoped properties from a collection or a token, and apply some transformation,2054 /// supplied by `mapper`, to each key-value pair.2055 pub fn iterate_user_properties<Key, Value, R, Mapper>(2056 collection_id: CollectionId,2057 token_id: Option<TokenId>,2058 mapper: Mapper,2059 ) -> Result<impl Iterator<Item = R>, DispatchError>2060 where2061 Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,2062 Value: Decode + Default,2063 Mapper: Fn(Key, Value) -> R,2064 {2065 let properties = match token_id {2066 Some(token_id) => <PalletNft<T>>::token_properties((collection_id, token_id)),2067 None => <PalletCommon<T>>::collection_properties(collection_id),2068 };20692070 let properties = properties.into_iter().filter_map(move |(key, value)| {2071 let key = strip_key_prefix(&key, USER_PROPERTY_PREFIX)?;20722073 let key: Key = key.to_vec().try_into().ok()?;2074 let value: Value = value.decode().ok()?;20752076 Some(mapper(key, value))2077 });20782079 Ok(properties)2080 }20812082 /// Match Unique errors to RMRK's own and return the RMRK error if a match is successful.2083 fn map_unique_err_to_proxy(err: DispatchError) -> DispatchError {2084 map_unique_err_to_proxy! {2085 match err {2086 CommonError::NoPermission => NoPermission,2087 CommonError::CollectionTokenLimitExceeded => CollectionFullOrLocked,2088 CommonError::PublicMintingNotAllowed => NoPermission,2089 CommonError::TokenNotFound => NoAvailableNftId,2090 CommonError::ApprovedValueTooLow => NoPermission,2091 CommonError::CantDestroyNotEmptyCollection => CollectionNotEmpty,2092 StructureError::TokenNotFound => NoAvailableNftId,2093 StructureError::OuroborosDetected => CannotSendToDescendentOrSelf,2094 }2095 }2096 }2097}1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # RMRK Core Proxy Pallet18//!19//! A pallet used as proxy for RMRK Core (<https://rmrk-team.github.io/rmrk-substrate/#/pallets/rmrk-core>).20//!21//! - [`Config`]22//! - [`Call`]23//! - [`Pallet`]24//!25//! ## Overview26//!27//! The RMRK Core Proxy pallet mirrors the functionality of RMRK Core,28//! binding its externalities to Unique's own underlying structure.29//! It is purposed to mimic RMRK Core exactly, allowing seamless integrations30//! of solutions based on RMRK.31//!32//! RMRK Core itself contains essential functionality for RMRK's nested and33//! multi-resourced NFTs.34//!35//! *Note*, that while RMRK itself is subject to active development and restructuring,36//! the proxy may be caught temporarily out of date.37//!38//! ### What is RMRK?39//!40//! RMRK is a set of NFT standards which compose several "NFT 2.0 lego" primitives.41//! Putting these legos together allows a user to create NFT systems of arbitrary complexity.42//!43//! Meaning, RMRK NFTs are dynamic, able to nest into each other and form a hierarchy,44//! make use of specific changeable and partially shared metadata in the form of resources,45//! and more.46//!47//! Visit RMRK documentation and repositories to learn more:48//! - Docs: <https://docs.rmrk.app/getting-started/>49//! - FAQ: <https://coda.io/@rmrk/faq>50//! - Substrate code repository: <https://github.com/rmrk-team/rmrk-substrate>51//! - RMRK specification repository: <https://github.com/rmrk-team/rmrk-spec>52//!53//! ## Terminology54//!55//! For more information on RMRK, see RMRK's own documentation.56//!57//! ### Intro to RMRK58//!59//! - **Resource:** Additional piece of metadata of an NFT usually serving to add60//! a piece of media on top of the root metadata (NFT's own), be it a different wing61//! on the root template bird or something entirely unrelated.62//!63//! - **Base:** A list of possible "components" - Parts, a combination of which can64//! be appended/equipped to/on an NFT.65//!66//! - **Part:** Something that, together with other Parts, can constitute an NFT.67//! Parts are defined in the Base to which they belong. Parts can be either68//! of the `slot` type or `fixed` type. Slots are intended for equippables.69//! Note that "part of something" and "Part of a Base" can be easily confused,70//! and so in this documentation these words are distinguished by the capital letter.71//!72//! - **Theme:** Named objects of variable => value pairs which get interpolated into73//! the Base's `themable` Parts. Themes can hold any value, but are often represented74//! in RMRK's examples as colors applied to visible Parts.75//!76//! ### Peculiarities in Unique77//!78//! - **Scoped properties:** Properties that are normally obscured from users.79//! Their purpose is to contain structured metadata that was not included in the Unique standard80//! for collections and tokens, meant to be operated on by proxies and other outliers.81//! Scoped property keys are prefixed with `some-scope:`, where `some-scope` is82//! an arbitrary keyword, like "rmrk". `:` is considered an unacceptable symbol in user-defined83//! properties, which, along with other safeguards, makes scoped ones impossible to tamper with.84//!85//! - **Auxiliary properties:** A slightly different structure of properties,86//! trading universality of use for more convenient storage, writes and access.87//! Meant to be inaccessible to end users.88//!89//! ## Proxy Implementation90//!91//! An external user is supposed to be able to utilize this proxy as they would92//! utilize RMRK, and get exactly the same results. Normally, Unique transactions93//! are off-limits to RMRK collections and tokens, and vice versa. However,94//! the information stored on chain can be freely interpreted by storage reads and Unique RPCs.95//!96//! ### ID Mapping97//!98//! RMRK's collections' IDs are counted independently of Unique's and start at 0.99//! Note that tokens' IDs still start at 1.100//! The collections themselves, as well as tokens, are stored as Unique collections,101//! and thus RMRK IDs are mapped to Unique IDs (but not vice versa).102//!103//! ### External/Internal Collection Insulation104//!105//! A Unique transaction cannot target collections purposed for RMRK,106//! and they are flagged as `external` to specify that. On the other hand,107//! due to the mapping, RMRK transactions and RPCs simply cannot reach Unique collections.108//!109//! ### Native Properties110//!111//! Many of RMRK's native parameters are stored as scoped properties of a collection112//! or an NFT on the chain. Scoped properties are prefixed with `rmrk:`, where `:`113//! is an unacceptable symbol in user-defined properties, which, along with other safeguards,114//! makes them impossible to tamper with.115//!116//! ### Collection and NFT Types, or Base, Parts and Themes Handling117//!118//! RMRK introduces the concept of a Base, which is a catalogue of Parts,119//! possible components of an NFT. Due to its similarity with the functionality120//! of a token collection, a Base is stored and handled as one, and the Base's Parts and Themes121//! are this collection's NFTs. See [`CollectionType`] and [`NftType`].122//!123//! ## Interface124//!125//! ### Dispatchables126//!127//! - `create_collection` - Create a new collection of NFTs.128//! - `destroy_collection` - Destroy a collection.129//! - `change_collection_issuer` - Change the issuer of a collection.130//! Analogous to Unique's collection's [`owner`](up_data_structs::Collection).131//! - `lock_collection` - "Lock" the collection and prevent new token creation. **Cannot be undone.**132//! - `mint_nft` - Mint an NFT in a specified collection.133//! - `burn_nft` - Burn an NFT, destroying it and its nested tokens.134//! - `send` - Transfer an NFT from an account/NFT A to another account/NFT B.135//! - `accept_nft` - Accept an NFT sent from another account to self or an owned NFT.136//! - `reject_nft` - Reject an NFT sent from another account to self or owned NFT and **burn it**.137//! - `accept_resource` - Accept the addition of a newly created pending resource to an existing NFT.138//! - `accept_resource_removal` - Accept the removal of a removal-pending resource from an NFT.139//! - `set_property` - Add or edit a custom user property of a token or a collection.140//! - `set_priority` - Set a different order of resource priorities for an NFT.141//! - `add_basic_resource` - Create and set/propose a basic resource for an NFT.142//! - `add_composable_resource` - Create and set/propose a composable resource for an NFT.143//! - `add_slot_resource` - Create and set/propose a slot resource for an NFT.144//! - `remove_resource` - Remove and erase a resource from an NFT.145146#![cfg_attr(not(feature = "std"), no_std)]147148use frame_support::{pallet_prelude::*, BoundedVec, dispatch::DispatchResult};149use frame_system::{pallet_prelude::*, ensure_signed};150use sp_runtime::{DispatchError, Permill, traits::StaticLookup};151use sp_std::{152 vec::Vec,153 collections::{btree_set::BTreeSet, btree_map::BTreeMap},154};155use up_data_structs::{*, mapping::TokenAddressMapping};156use pallet_common::{157 Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations,158};159use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData};160use pallet_structure::{Pallet as PalletStructure, Error as StructureError};161use pallet_evm::account::CrossAccountId;162use core::convert::AsRef;163164pub use pallet::*;165166#[cfg(feature = "runtime-benchmarks")]167pub mod benchmarking;168pub mod misc;169pub mod property;170pub mod rpc;171pub mod weights;172173pub type SelfWeightOf<T> = <T as Config>::WeightInfo;174175use weights::WeightInfo;176use misc::*;177pub use property::*;178179use RmrkProperty::*;180181/// A maximum number of levels of depth in the token nesting tree.182pub const NESTING_BUDGET: u32 = 5;183184type PendingTarget = (CollectionId, TokenId);185type PendingChild = (RmrkCollectionId, RmrkNftId);186type PendingChildrenSet = BTreeSet<PendingChild>;187188type BasesMap = BTreeMap<RmrkBaseId, u32>;189190#[frame_support::pallet]191pub mod pallet {192 use super::*;193194 #[pallet::config]195 pub trait Config:196 frame_system::Config197 + pallet_common::Config198 + pallet_nonfungible::Config199 + pallet_evm::Config200 {201 /// Overarching event type.202 type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;203204 /// The weight information of this pallet.205 type WeightInfo: WeightInfo;206 }207208 /// Latest yet-unused collection ID.209 #[pallet::storage]210 #[pallet::getter(fn collection_index)]211 pub type CollectionIndex<T: Config> = StorageValue<_, RmrkCollectionId, ValueQuery>;212213 /// Mapping from RMRK collection ID to Unique's.214 #[pallet::storage]215 pub type UniqueCollectionId<T: Config> =216 StorageMap<_, Twox64Concat, RmrkCollectionId, CollectionId, ValueQuery>;217218 #[pallet::pallet]219 #[pallet::generate_store(pub(super) trait Store)]220 pub struct Pallet<T>(_);221222 #[pallet::event]223 #[pallet::generate_deposit(pub(super) fn deposit_event)]224 pub enum Event<T: Config> {225 CollectionCreated {226 issuer: T::AccountId,227 collection_id: RmrkCollectionId,228 },229 CollectionDestroyed {230 issuer: T::AccountId,231 collection_id: RmrkCollectionId,232 },233 IssuerChanged {234 old_issuer: T::AccountId,235 new_issuer: T::AccountId,236 collection_id: RmrkCollectionId,237 },238 CollectionLocked {239 issuer: T::AccountId,240 collection_id: RmrkCollectionId,241 },242 NftMinted {243 owner: T::AccountId,244 collection_id: RmrkCollectionId,245 nft_id: RmrkNftId,246 },247 NFTBurned {248 owner: T::AccountId,249 nft_id: RmrkNftId,250 },251 NFTSent {252 sender: T::AccountId,253 recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,254 collection_id: RmrkCollectionId,255 nft_id: RmrkNftId,256 approval_required: bool,257 },258 NFTAccepted {259 sender: T::AccountId,260 recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,261 collection_id: RmrkCollectionId,262 nft_id: RmrkNftId,263 },264 NFTRejected {265 sender: T::AccountId,266 collection_id: RmrkCollectionId,267 nft_id: RmrkNftId,268 },269 PropertySet {270 collection_id: RmrkCollectionId,271 maybe_nft_id: Option<RmrkNftId>,272 key: RmrkKeyString,273 value: RmrkValueString,274 },275 ResourceAdded {276 nft_id: RmrkNftId,277 resource_id: RmrkResourceId,278 },279 ResourceRemoval {280 nft_id: RmrkNftId,281 resource_id: RmrkResourceId,282 },283 ResourceAccepted {284 nft_id: RmrkNftId,285 resource_id: RmrkResourceId,286 },287 ResourceRemovalAccepted {288 nft_id: RmrkNftId,289 resource_id: RmrkResourceId,290 },291 PrioritySet {292 collection_id: RmrkCollectionId,293 nft_id: RmrkNftId,294 },295 }296297 #[pallet::error]298 pub enum Error<T> {299 /* Unique proxy-specific events */300 /// Property of the type of RMRK collection could not be read successfully.301 CorruptedCollectionType,302 // NftTypeEncodeError,303 /// Too many symbols supplied as the property key. The maximum is [256](up_data_structs::MAX_PROPERTY_KEY_LENGTH).304 RmrkPropertyKeyIsTooLong,305 /// Too many bytes supplied as the property value. The maximum is [32768](up_data_structs::MAX_PROPERTY_VALUE_LENGTH).306 RmrkPropertyValueIsTooLong,307 /// Could not find a property by the supplied key.308 RmrkPropertyIsNotFound,309 /// Something went wrong when decoding encoded data from the storage.310 /// Perhaps, there was a wrong key supplied for the type, or the data was improperly stored.311 UnableToDecodeRmrkData,312313 /* RMRK compatible events */314 /// Only destroying collections without tokens is allowed.315 CollectionNotEmpty,316 /// Could not find an ID for a collection. It is likely there were too many collections created on the chain, causing an overflow.317 NoAvailableCollectionId,318 /// Token does not exist, or there is no suitable ID for it, likely too many tokens were created in a collection, causing an overflow.319 NoAvailableNftId,320 /// Collection does not exist, has a wrong type, or does not map to a Unique ID.321 CollectionUnknown,322 /// No permission to perform action.323 NoPermission,324 /// Token is marked as non-transferable, and thus cannot be transferred.325 NonTransferable,326 /// Too many tokens created in the collection, no new ones are allowed.327 CollectionFullOrLocked,328 /// No such resource found.329 ResourceDoesntExist,330 /// If an NFT is sent to a descendant, that would form a nesting loop, an ouroboros.331 /// Sending to self is redundant.332 CannotSendToDescendentOrSelf,333 /// Not the target owner of the sent NFT.334 CannotAcceptNonOwnedNft,335 /// Not the target owner of the sent NFT.336 CannotRejectNonOwnedNft,337 /// NFT was not sent and is not pending.338 CannotRejectNonPendingNft,339 /// Resource is not pending for the operation.340 ResourceNotPending,341 /// Could not find an ID for the resource. It is likely there were too many resources created on an NFT, causing an overflow.342 NoAvailableResourceId,343 }344345 #[pallet::call]346 impl<T: Config> Pallet<T> {347 // todo :refactor replace every collection_id with rmrk_collection_id (and nft_id) in arguments for uniformity?348349 /// Create a new collection of NFTs.350 ///351 /// # Permissions:352 /// * Anyone - will be assigned as the issuer of the collection.353 ///354 /// # Arguments:355 /// - `origin`: sender of the transaction356 /// - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.357 /// - `max`: Optional maximum number of tokens.358 /// - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.359 /// Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.360 #[pallet::weight(<SelfWeightOf<T>>::create_collection())]361 pub fn create_collection(362 origin: OriginFor<T>,363 metadata: RmrkString,364 max: Option<u32>,365 symbol: RmrkCollectionSymbol,366 ) -> DispatchResult {367 let sender = ensure_signed(origin)?;368369 let limits = CollectionLimits {370 owner_can_transfer: Some(false),371 token_limit: max,372 ..Default::default()373 };374375 let data = CreateCollectionData {376 limits: Some(limits),377 token_prefix: symbol378 .into_inner()379 .try_into()380 .map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,381 permissions: Some(CollectionPermissions {382 nesting: Some(NestingPermissions {383 token_owner: true,384 collection_admin: false,385 restricted: None,386 #[cfg(feature = "runtime-benchmarks")]387 permissive: false,388 }),389 ..Default::default()390 }),391 ..Default::default()392 };393394 let unique_collection_id = Self::init_collection(395 T::CrossAccountId::from_sub(sender.clone()),396 data,397 [398 Self::encode_rmrk_property(Metadata, &metadata)?,399 Self::encode_rmrk_property(CollectionType, &misc::CollectionType::Regular)?,400 ]401 .into_iter(),402 )?;403 let rmrk_collection_id = <CollectionIndex<T>>::get();404405 <UniqueCollectionId<T>>::insert(rmrk_collection_id, unique_collection_id);406407 <PalletCommon<T>>::set_scoped_collection_property(408 unique_collection_id,409 RMRK_SCOPE,410 Self::encode_rmrk_property(RmrkInternalCollectionId, &rmrk_collection_id)?,411 )?;412413 <CollectionIndex<T>>::mutate(|n| *n += 1);414415 Self::deposit_event(Event::CollectionCreated {416 issuer: sender,417 collection_id: rmrk_collection_id,418 });419420 Ok(())421 }422423 /// Destroy a collection.424 ///425 /// Only empty collections can be destroyed. If it has any tokens, they must be burned first.426 ///427 /// # Permissions:428 /// * Collection issuer429 ///430 /// # Arguments:431 /// - `origin`: sender of the transaction432 /// - `collection_id`: RMRK ID of the collection to destroy.433 #[pallet::weight(<SelfWeightOf<T>>::destroy_collection())]434 pub fn destroy_collection(435 origin: OriginFor<T>,436 collection_id: RmrkCollectionId,437 ) -> DispatchResult {438 let sender = ensure_signed(origin)?;439 let cross_sender = T::CrossAccountId::from_sub(sender.clone());440441 let collection = Self::get_typed_nft_collection(442 Self::unique_collection_id(collection_id)?,443 misc::CollectionType::Regular,444 )?;445 collection.check_is_external()?;446447 <PalletNft<T>>::destroy_collection(collection, &cross_sender)448 .map_err(Self::map_unique_err_to_proxy)?;449450 Self::deposit_event(Event::CollectionDestroyed {451 issuer: sender,452 collection_id,453 });454455 Ok(())456 }457458 /// Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).459 ///460 /// # Permissions:461 /// * Collection issuer462 ///463 /// # Arguments:464 /// - `origin`: sender of the transaction465 /// - `collection_id`: RMRK collection ID to change the issuer of.466 /// - `new_issuer`: Collection's new issuer.467 #[pallet::weight(<SelfWeightOf<T>>::change_collection_issuer())]468 pub fn change_collection_issuer(469 origin: OriginFor<T>,470 collection_id: RmrkCollectionId,471 new_issuer: <T::Lookup as StaticLookup>::Source,472 ) -> DispatchResult {473 let sender = ensure_signed(origin)?;474475 let collection = Self::get_nft_collection(Self::unique_collection_id(collection_id)?)?;476 collection.check_is_external()?;477478 let new_issuer = T::Lookup::lookup(new_issuer)?;479480 Self::change_collection_owner(481 Self::unique_collection_id(collection_id)?,482 misc::CollectionType::Regular,483 sender.clone(),484 new_issuer.clone(),485 )?;486487 Self::deposit_event(Event::IssuerChanged {488 old_issuer: sender,489 new_issuer,490 collection_id,491 });492493 Ok(())494 }495496 /// "Lock" the collection and prevent new token creation. Cannot be undone.497 ///498 /// # Permissions:499 /// * Collection issuer500 ///501 /// # Arguments:502 /// - `origin`: sender of the transaction503 /// - `collection_id`: RMRK ID of the collection to lock.504 #[pallet::weight(<SelfWeightOf<T>>::lock_collection())]505 pub fn lock_collection(506 origin: OriginFor<T>,507 collection_id: RmrkCollectionId,508 ) -> DispatchResult {509 let sender = ensure_signed(origin)?;510 let cross_sender = T::CrossAccountId::from_sub(sender.clone());511512 let collection = Self::get_typed_nft_collection(513 Self::unique_collection_id(collection_id)?,514 misc::CollectionType::Regular,515 )?;516 collection.check_is_external()?;517518 Self::check_collection_owner(&collection, &cross_sender)?;519520 let token_count = collection.total_supply();521522 let mut collection = collection.into_inner();523 collection.limits.token_limit = Some(token_count);524 collection.save()?;525526 Self::deposit_event(Event::CollectionLocked {527 issuer: sender,528 collection_id,529 });530531 Ok(())532 }533534 /// Mint an NFT in a specified collection.535 ///536 /// # Permissions:537 /// * Collection issuer538 ///539 /// # Arguments:540 /// - `origin`: sender of the transaction541 /// - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).542 /// - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.543 /// - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.544 /// - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.545 /// - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.546 /// - `transferable`: Can this NFT be transferred? Cannot be changed.547 /// - `resources`: Resource data to be added to the NFT immediately after minting.548 #[pallet::weight(<SelfWeightOf<T>>::mint_nft(resources.as_ref().map(|r| r.len() as u32).unwrap_or(0)))]549 pub fn mint_nft(550 origin: OriginFor<T>,551 owner: Option<T::AccountId>,552 collection_id: RmrkCollectionId,553 recipient: Option<T::AccountId>,554 royalty_amount: Option<Permill>,555 metadata: RmrkString,556 transferable: bool,557 resources: Option<BoundedVec<RmrkResourceTypes, MaxResourcesOnMint>>,558 ) -> DispatchResult {559 let sender = ensure_signed(origin)?;560 let cross_sender = T::CrossAccountId::from_sub(sender.clone());561562 let owner = owner.unwrap_or(sender.clone());563 let cross_owner = T::CrossAccountId::from_sub(owner.clone());564565 let collection = Self::get_typed_nft_collection(566 Self::unique_collection_id(collection_id)?,567 misc::CollectionType::Regular,568 )?;569 collection.check_is_external()?;570571 let royalty_info = royalty_amount.map(|amount| rmrk_traits::RoyaltyInfo {572 recipient: recipient.unwrap_or_else(|| owner.clone()),573 amount,574 });575576 let nft_id = Self::create_nft(577 &cross_sender,578 &cross_owner,579 &collection,580 [581 Self::encode_rmrk_property(TokenType, &NftType::Regular)?,582 Self::encode_rmrk_property(Transferable, &transferable)?,583 Self::encode_rmrk_property(PendingNftAccept, &None::<PendingTarget>)?,584 Self::encode_rmrk_property(RoyaltyInfo, &royalty_info)?,585 Self::encode_rmrk_property(Metadata, &metadata)?,586 Self::encode_rmrk_property(Equipped, &false)?,587 Self::encode_rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,588 Self::encode_rmrk_property(NextResourceId, &(0 as RmrkResourceId))?,589 Self::encode_rmrk_property(PendingChildren, &PendingChildrenSet::new())?,590 Self::encode_rmrk_property(AssociatedBases, &BasesMap::new())?,591 ]592 .into_iter(),593 )594 .map_err(|err| match err {595 DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),596 err => Self::map_unique_err_to_proxy(err),597 })?;598599 if let Some(resources) = resources {600 for resource in resources {601 Self::resource_add(sender.clone(), collection.id, nft_id, resource)?;602 }603 }604605 Self::deposit_event(Event::NftMinted {606 owner,607 collection_id,608 nft_id: nft_id.0,609 });610611 Ok(())612 }613614 /// Burn an NFT, destroying it and its nested tokens up to the specified limit.615 /// If the burning budget is exceeded, the transaction is reverted.616 ///617 /// This is the way to burn a nested token as well.618 ///619 /// For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).620 ///621 /// # Permissions:622 /// * Token owner623 ///624 /// # Arguments:625 /// - `origin`: sender of the transaction626 /// - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.627 /// - `nft_id`: ID of the NFT to be destroyed.628 /// - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction629 /// is reverted if there are more tokens to burn in the nesting tree than this number.630 /// This is primarily a mechanism of transaction weight control.631 #[pallet::weight(<SelfWeightOf<T>>::burn_nft(*max_burns))]632 pub fn burn_nft(633 origin: OriginFor<T>,634 collection_id: RmrkCollectionId,635 nft_id: RmrkNftId,636 max_burns: u32,637 ) -> DispatchResult {638 let sender = ensure_signed(origin)?;639 let cross_sender = T::CrossAccountId::from_sub(sender.clone());640641 let collection = Self::get_typed_nft_collection(642 Self::unique_collection_id(collection_id)?,643 misc::CollectionType::Regular,644 )?;645 collection.check_is_external()?;646647 Self::destroy_nft(648 cross_sender,649 Self::unique_collection_id(collection_id)?,650 nft_id.into(),651 max_burns,652 <Error<T>>::NoPermission,653 )654 .map_err(|err| Self::map_unique_err_to_proxy(err.error))?;655656 Self::deposit_event(Event::NFTBurned {657 owner: sender,658 nft_id,659 });660661 Ok(())662 }663664 /// Transfer an NFT from an account/NFT A to another account/NFT B.665 /// The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].666 ///667 /// If the target owner is an NFT owned by another account, then the NFT will enter668 /// the pending state and will have to be accepted by the other account.669 ///670 /// # Permissions:671 /// - Token owner672 ///673 /// # Arguments:674 /// - `origin`: sender of the transaction675 /// - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.676 /// - `rmrk_nft_id`: ID of the NFT to be transferred.677 /// - `new_owner`: New owner of the nft which can be either an account or a NFT.678 #[pallet::weight(<SelfWeightOf<T>>::send())]679 pub fn send(680 origin: OriginFor<T>,681 rmrk_collection_id: RmrkCollectionId,682 rmrk_nft_id: RmrkNftId,683 new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,684 ) -> DispatchResult {685 let sender = ensure_signed(origin.clone())?;686 let cross_sender = T::CrossAccountId::from_sub(sender.clone());687688 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;689 let nft_id = rmrk_nft_id.into();690691 let collection =692 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;693 collection.check_is_external()?;694695 let token_data =696 <TokenData<T>>::get((collection_id, nft_id)).ok_or(<Error<T>>::NoAvailableNftId)?;697698 let from = token_data.owner;699700 ensure!(701 Self::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Transferable)?,702 <Error<T>>::NonTransferable703 );704705 ensure!(706 Self::get_nft_property_decoded::<Option<PendingTarget>>(707 collection_id,708 nft_id,709 RmrkProperty::PendingNftAccept710 )?711 .is_none(),712 <Error<T>>::NoPermission713 );714715 let target_owner;716 let approval_required;717718 match new_owner {719 RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {720 target_owner = T::CrossAccountId::from_sub(account_id.clone());721 approval_required = false;722 }723 RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(724 target_collection_id,725 target_nft_id,726 ) => {727 let target_collection_id = Self::unique_collection_id(target_collection_id)?;728729 let target_nft_budget = budget::Value::new(NESTING_BUDGET);730731 let target_nft_owner = <PalletStructure<T>>::get_checked_topmost_owner(732 target_collection_id,733 target_nft_id.into(),734 Some((collection_id, nft_id)),735 &target_nft_budget,736 )737 .map_err(Self::map_unique_err_to_proxy)?;738739 approval_required = cross_sender != target_nft_owner;740741 if approval_required {742 target_owner = target_nft_owner;743744 <PalletNft<T>>::set_scoped_token_property(745 collection.id,746 nft_id,747 RMRK_SCOPE,748 Self::encode_rmrk_property::<Option<PendingTarget>>(749 PendingNftAccept,750 &Some((target_collection_id, target_nft_id.into())),751 )?,752 )?;753754 Self::insert_pending_child(755 (target_collection_id, target_nft_id.into()),756 (rmrk_collection_id, rmrk_nft_id),757 )?;758 } else {759 target_owner = T::CrossTokenAddressMapping::token_to_address(760 target_collection_id,761 target_nft_id.into(),762 );763 }764 }765 }766767 let src_nft_budget = budget::Value::new(NESTING_BUDGET);768769 <PalletNft<T>>::transfer_from(770 &collection,771 &cross_sender,772 &from,773 &target_owner,774 nft_id,775 &src_nft_budget,776 )777 .map_err(Self::map_unique_err_to_proxy)?;778779 Self::deposit_event(Event::NFTSent {780 sender,781 recipient: new_owner,782 collection_id: rmrk_collection_id,783 nft_id: rmrk_nft_id,784 approval_required,785 });786787 Ok(())788 }789790 /// Accept an NFT sent from another account to self or an owned NFT.791 ///792 /// The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.793 ///794 /// # Permissions:795 /// - Token-owner-to-be796 ///797 /// # Arguments:798 /// - `origin`: sender of the transaction799 /// - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.800 /// - `rmrk_nft_id`: ID of the NFT to be accepted.801 /// - `new_owner`: Either the sender's account ID or a sender-owned NFT,802 /// whichever the accepted NFT was sent to.803 #[pallet::weight(<SelfWeightOf<T>>::accept_nft())]804 pub fn accept_nft(805 origin: OriginFor<T>,806 rmrk_collection_id: RmrkCollectionId,807 rmrk_nft_id: RmrkNftId,808 new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,809 ) -> DispatchResult {810 let sender = ensure_signed(origin.clone())?;811 let cross_sender = T::CrossAccountId::from_sub(sender.clone());812813 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;814 let nft_id = rmrk_nft_id.into();815816 let collection =817 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;818 collection.check_is_external()?;819820 let new_cross_owner = match new_owner {821 RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {822 T::CrossAccountId::from_sub(account_id.clone())823 }824 RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(825 target_collection_id,826 target_nft_id,827 ) => {828 let target_collection_id = Self::unique_collection_id(target_collection_id)?;829830 T::CrossTokenAddressMapping::token_to_address(831 target_collection_id,832 TokenId(target_nft_id),833 )834 }835 };836837 let budget = budget::Value::new(NESTING_BUDGET);838839 <PalletNft<T>>::transfer(840 &collection,841 &cross_sender,842 &new_cross_owner,843 nft_id,844 &budget,845 )846 .map_err(|err| {847 if err == <CommonError<T>>::UserIsNotAllowedToNest.into() {848 <Error<T>>::CannotAcceptNonOwnedNft.into()849 } else {850 Self::map_unique_err_to_proxy(err)851 }852 })?;853854 let pending_target = Self::get_nft_property_decoded::<Option<PendingTarget>>(855 collection_id,856 nft_id,857 RmrkProperty::PendingNftAccept,858 )?;859860 if let Some(pending_target) = pending_target {861 Self::remove_pending_child(pending_target, (rmrk_collection_id, rmrk_nft_id))?;862863 <PalletNft<T>>::set_scoped_token_property(864 collection.id,865 nft_id,866 RMRK_SCOPE,867 Self::encode_rmrk_property(PendingNftAccept, &None::<PendingTarget>)?,868 )?;869 }870871 Self::deposit_event(Event::NFTAccepted {872 sender,873 recipient: new_owner,874 collection_id: rmrk_collection_id,875 nft_id: rmrk_nft_id,876 });877878 Ok(())879 }880881 /// Reject an NFT sent from another account to self or owned NFT.882 /// The NFT in question will not be sent back and burnt instead.883 ///884 /// The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.885 ///886 /// # Permissions:887 /// - Token-owner-to-be-not888 ///889 /// # Arguments:890 /// - `origin`: sender of the transaction891 /// - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.892 /// - `rmrk_nft_id`: ID of the NFT to be rejected.893 #[pallet::weight(<SelfWeightOf<T>>::reject_nft())]894 pub fn reject_nft(895 origin: OriginFor<T>,896 rmrk_collection_id: RmrkCollectionId,897 rmrk_nft_id: RmrkNftId,898 ) -> DispatchResult {899 let sender = ensure_signed(origin)?;900 let cross_sender = T::CrossAccountId::from_sub(sender.clone());901902 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;903 let nft_id = rmrk_nft_id.into();904905 let collection =906 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;907 collection.check_is_external()?;908909 ensure!(910 <TokenData<T>>::get((collection_id, nft_id)).is_some(),911 <Error<T>>::NoAvailableNftId912 );913914 let pending_target = Self::get_nft_property_decoded::<Option<PendingTarget>>(915 collection_id,916 nft_id,917 RmrkProperty::PendingNftAccept,918 )?;919920 match pending_target {921 Some(pending_target) => {922 Self::remove_pending_child(pending_target, (rmrk_collection_id, rmrk_nft_id))?923 }924 None => return Err(<Error<T>>::CannotRejectNonPendingNft.into()),925 }926927 Self::destroy_nft(928 cross_sender,929 collection_id,930 nft_id,931 NESTING_BUDGET,932 <Error<T>>::CannotRejectNonOwnedNft,933 )934 .map_err(|err| Self::map_unique_err_to_proxy(err.error))?;935936 Self::deposit_event(Event::NFTRejected {937 sender,938 collection_id: rmrk_collection_id,939 nft_id: rmrk_nft_id,940 });941942 Ok(())943 }944945 /// Accept the addition of a newly created pending resource to an existing NFT.946 ///947 /// This transaction is needed when a resource is created and assigned to an NFT948 /// by a non-owner, i.e. the collection issuer, with one of the949 /// [`add_...` transactions](Pallet::add_basic_resource).950 ///951 /// # Permissions:952 /// - Token owner953 ///954 /// # Arguments:955 /// - `origin`: sender of the transaction956 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.957 /// - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.958 /// - `resource_id`: ID of the newly created pending resource.959 /// accept the addition of a new resource to an existing NFT960 #[pallet::weight(<SelfWeightOf<T>>::accept_resource())]961 pub fn accept_resource(962 origin: OriginFor<T>,963 rmrk_collection_id: RmrkCollectionId,964 rmrk_nft_id: RmrkNftId,965 resource_id: RmrkResourceId,966 ) -> DispatchResult {967 let sender = ensure_signed(origin)?;968 let cross_sender = T::CrossAccountId::from_sub(sender);969970 let collection_id = Self::unique_collection_id(rmrk_collection_id)971 .map_err(|_| <Error<T>>::ResourceDoesntExist)?;972 let collection =973 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;974 collection.check_is_external()?;975976 let nft_id = rmrk_nft_id.into();977978 let budget = budget::Value::new(NESTING_BUDGET);979980 let nft_owner =981 <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)982 .map_err(|_| <Error<T>>::ResourceDoesntExist)?;983984 Self::try_mutate_resource_info(collection_id, nft_id, resource_id, |res| {985 ensure!(res.pending, <Error<T>>::ResourceNotPending);986 ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);987988 res.pending = false;989990 Ok(())991 })?;992993 Self::deposit_event(Event::<T>::ResourceAccepted {994 nft_id: rmrk_nft_id,995 resource_id,996 });997998 Ok(())999 }10001001 /// Accept the removal of a removal-pending resource from an NFT.1002 ///1003 /// This transaction is needed when a non-owner, i.e. the collection issuer,1004 /// requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.1005 ///1006 /// # Permissions:1007 /// - Token owner1008 ///1009 /// # Arguments:1010 /// - `origin`: sender of the transaction1011 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1012 /// - `rmrk_nft_id`: ID of the NFT with a resource to be removed.1013 /// - `resource_id`: ID of the removal-pending resource.1014 #[pallet::weight(<SelfWeightOf<T>>::accept_resource_removal())]1015 pub fn accept_resource_removal(1016 origin: OriginFor<T>,1017 rmrk_collection_id: RmrkCollectionId,1018 rmrk_nft_id: RmrkNftId,1019 resource_id: RmrkResourceId,1020 ) -> DispatchResult {1021 let sender = ensure_signed(origin)?;1022 let cross_sender = T::CrossAccountId::from_sub(sender);10231024 let collection_id = Self::unique_collection_id(rmrk_collection_id)1025 .map_err(|_| <Error<T>>::ResourceDoesntExist)?;1026 let collection =1027 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1028 collection.check_is_external()?;10291030 let nft_id = rmrk_nft_id.into();10311032 let budget = budget::Value::new(NESTING_BUDGET);10331034 let nft_owner =1035 <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)1036 .map_err(|_| <Error<T>>::ResourceDoesntExist)?;10371038 ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);10391040 let resource_id_key = Self::get_scoped_property_key(ResourceId(resource_id))?;10411042 let resource_info = <PalletNft<T>>::token_aux_property((1043 collection_id,1044 nft_id,1045 RMRK_SCOPE,1046 resource_id_key.clone(),1047 ))1048 .ok_or(<Error<T>>::ResourceDoesntExist)?;10491050 let resource_info: RmrkResourceInfo = Self::decode_property_value(&resource_info)?;10511052 ensure!(1053 resource_info.pending_removal,1054 <Error<T>>::ResourceNotPending1055 );10561057 <PalletNft<T>>::remove_token_aux_property(1058 collection_id,1059 nft_id,1060 RMRK_SCOPE,1061 resource_id_key,1062 );10631064 if let RmrkResourceTypes::Composable(resource) = resource_info.resource {1065 let base_id = resource.base;10661067 Self::remove_associated_base_id(collection_id, nft_id, base_id)?;1068 }10691070 Self::deposit_event(Event::<T>::ResourceRemovalAccepted {1071 nft_id: rmrk_nft_id,1072 resource_id,1073 });10741075 Ok(())1076 }10771078 /// Add or edit a custom user property, a key-value pair, describing the metadata1079 /// of a token or a collection, on either one of these.1080 ///1081 /// Note that in this proxy implementation many details regarding RMRK are stored1082 /// as scoped properties prefixed with "rmrk:", normally inaccessible1083 /// to external transactions and RPCs.1084 ///1085 /// # Permissions:1086 /// - Collection issuer - in case of collection property1087 /// - Token owner - in case of NFT property1088 ///1089 /// # Arguments:1090 /// - `origin`: sender of the transaction1091 /// - `rmrk_collection_id`: RMRK collection ID.1092 /// - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.1093 /// - `key`: Key of the custom property to be referenced by.1094 /// - `value`: Value of the custom property to be stored.1095 #[pallet::weight(<SelfWeightOf<T>>::set_property())]1096 pub fn set_property(1097 origin: OriginFor<T>,1098 #[pallet::compact] rmrk_collection_id: RmrkCollectionId,1099 maybe_nft_id: Option<RmrkNftId>,1100 key: RmrkKeyString,1101 value: RmrkValueString,1102 ) -> DispatchResult {1103 let sender = ensure_signed(origin)?;1104 let sender = T::CrossAccountId::from_sub(sender);11051106 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1107 let collection =1108 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1109 collection.check_is_external()?;11101111 let budget = budget::Value::new(NESTING_BUDGET);11121113 match maybe_nft_id {1114 Some(nft_id) => {1115 let token_id: TokenId = nft_id.into();11161117 Self::ensure_nft_type(collection_id, token_id, NftType::Regular)?;1118 Self::ensure_nft_owner(collection_id, token_id, &sender, &budget)?;11191120 <PalletNft<T>>::set_scoped_token_property(1121 collection_id,1122 token_id,1123 RMRK_SCOPE,1124 Self::encode_rmrk_property(UserProperty(key.as_slice()), &value)?,1125 )?;1126 }1127 None => {1128 let collection = Self::get_typed_nft_collection(1129 collection_id,1130 misc::CollectionType::Regular,1131 )?;11321133 Self::check_collection_owner(&collection, &sender)?;11341135 <PalletCommon<T>>::set_scoped_collection_property(1136 collection_id,1137 RMRK_SCOPE,1138 Self::encode_rmrk_property(UserProperty(key.as_slice()), &value)?,1139 )?;1140 }1141 }11421143 Self::deposit_event(Event::PropertySet {1144 collection_id: rmrk_collection_id,1145 maybe_nft_id,1146 key,1147 value,1148 });11491150 Ok(())1151 }11521153 /// Set a different order of resource priorities for an NFT. Priorities can be used,1154 /// for example, for order of rendering.1155 ///1156 /// Note that the priorities are not updated automatically, and are an empty vector1157 /// by default. There is no pre-set definition for the order to be particular,1158 /// it can be interpreted arbitrarily use-case by use-case.1159 ///1160 /// # Permissions:1161 /// - Token owner1162 ///1163 /// # Arguments:1164 /// - `origin`: sender of the transaction1165 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1166 /// - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.1167 /// - `priorities`: Ordered vector of resource IDs.1168 #[pallet::weight(<SelfWeightOf<T>>::set_priority())]1169 pub fn set_priority(1170 origin: OriginFor<T>,1171 rmrk_collection_id: RmrkCollectionId,1172 rmrk_nft_id: RmrkNftId,1173 priorities: BoundedVec<RmrkResourceId, RmrkMaxPriorities>,1174 ) -> DispatchResult {1175 let sender = ensure_signed(origin)?;1176 let sender = T::CrossAccountId::from_sub(sender);11771178 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1179 let nft_id = rmrk_nft_id.into();11801181 let collection =1182 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1183 collection.check_is_external()?;11841185 let budget = budget::Value::new(NESTING_BUDGET);11861187 Self::ensure_nft_type(collection_id, nft_id, NftType::Regular)?;1188 Self::ensure_nft_owner(collection_id, nft_id, &sender, &budget)?;11891190 <PalletNft<T>>::set_scoped_token_property(1191 collection_id,1192 nft_id,1193 RMRK_SCOPE,1194 Self::encode_rmrk_property(ResourcePriorities, &priorities.into_inner())?,1195 )?;11961197 Self::deposit_event(Event::<T>::PrioritySet {1198 collection_id: rmrk_collection_id,1199 nft_id: rmrk_nft_id,1200 });12011202 Ok(())1203 }12041205 /// Create and set/propose a basic resource for an NFT.1206 ///1207 /// A basic resource is the simplest, lacking a Base and anything that comes with it.1208 /// See RMRK docs for more information and examples.1209 ///1210 /// # Permissions:1211 /// - Collection issuer - if not the token owner, adding the resource will warrant1212 /// the owner's [acceptance](Pallet::accept_resource).1213 ///1214 /// # Arguments:1215 /// - `origin`: sender of the transaction1216 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1217 /// - `nft_id`: ID of the NFT to assign a resource to.1218 /// - `resource`: Data of the resource to be created.1219 #[pallet::weight(<SelfWeightOf<T>>::add_basic_resource())]1220 pub fn add_basic_resource(1221 origin: OriginFor<T>,1222 rmrk_collection_id: RmrkCollectionId,1223 nft_id: RmrkNftId,1224 resource: RmrkBasicResource,1225 ) -> DispatchResult {1226 let sender = ensure_signed(origin.clone())?;12271228 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1229 let collection =1230 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1231 collection.check_is_external()?;12321233 let resource_id = Self::resource_add(1234 sender,1235 collection_id,1236 nft_id.into(),1237 RmrkResourceTypes::Basic(resource),1238 )?;12391240 Self::deposit_event(Event::ResourceAdded {1241 nft_id,1242 resource_id,1243 });1244 Ok(())1245 }12461247 /// Create and set/propose a composable resource for an NFT.1248 ///1249 /// A composable resource links to a Base and has a subset of its Parts it is composed of.1250 /// See RMRK docs for more information and examples.1251 ///1252 /// # Permissions:1253 /// - Collection issuer - if not the token owner, adding the resource will warrant1254 /// the owner's [acceptance](Pallet::accept_resource).1255 ///1256 /// # Arguments:1257 /// - `origin`: sender of the transaction1258 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1259 /// - `nft_id`: ID of the NFT to assign a resource to.1260 /// - `resource`: Data of the resource to be created.1261 #[pallet::weight(<SelfWeightOf<T>>::add_composable_resource())]1262 pub fn add_composable_resource(1263 origin: OriginFor<T>,1264 rmrk_collection_id: RmrkCollectionId,1265 nft_id: RmrkNftId,1266 resource: RmrkComposableResource,1267 ) -> DispatchResult {1268 let sender = ensure_signed(origin.clone())?;12691270 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1271 let collection =1272 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1273 collection.check_is_external()?;12741275 let base_id = resource.base;12761277 let resource_id = Self::resource_add(1278 sender,1279 collection_id,1280 nft_id.into(),1281 RmrkResourceTypes::Composable(resource),1282 )?;12831284 <PalletNft<T>>::try_mutate_token_aux_property(1285 collection_id,1286 nft_id.into(),1287 RMRK_SCOPE,1288 Self::get_scoped_property_key(AssociatedBases)?,1289 |value| -> DispatchResult {1290 let mut bases: BasesMap = match value {1291 Some(value) => Self::decode_property_value(value)?,1292 None => BasesMap::new(),1293 };12941295 *bases.entry(base_id).or_insert(0) += 1;12961297 *value = Some(Self::encode_property_value(&bases)?);1298 Ok(())1299 },1300 )?;13011302 Self::deposit_event(Event::ResourceAdded {1303 nft_id,1304 resource_id,1305 });1306 Ok(())1307 }13081309 /// Create and set/propose a slot resource for an NFT.1310 ///1311 /// A slot resource links to a Base and a slot ID in it which it can fit into.1312 /// See RMRK docs for more information and examples.1313 ///1314 /// # Permissions:1315 /// - Collection issuer - if not the token owner, adding the resource will warrant1316 /// the owner's [acceptance](Pallet::accept_resource).1317 ///1318 /// # Arguments:1319 /// - `origin`: sender of the transaction1320 /// - `rmrk_collection_id`: RMRK collection ID of the NFT.1321 /// - `nft_id`: ID of the NFT to assign a resource to.1322 /// - `resource`: Data of the resource to be created.1323 #[pallet::weight(<SelfWeightOf<T>>::add_slot_resource())]1324 pub fn add_slot_resource(1325 origin: OriginFor<T>,1326 rmrk_collection_id: RmrkCollectionId,1327 nft_id: RmrkNftId,1328 resource: RmrkSlotResource,1329 ) -> DispatchResult {1330 let sender = ensure_signed(origin.clone())?;13311332 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1333 let collection =1334 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1335 collection.check_is_external()?;13361337 let resource_id = Self::resource_add(1338 sender,1339 collection_id,1340 nft_id.into(),1341 RmrkResourceTypes::Slot(resource),1342 )?;13431344 Self::deposit_event(Event::ResourceAdded {1345 nft_id,1346 resource_id,1347 });1348 Ok(())1349 }13501351 /// Remove and erase a resource from an NFT.1352 ///1353 /// If the sender does not own the NFT, then it will be pending confirmation,1354 /// and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.1355 ///1356 /// # Permissions1357 /// - Collection issuer1358 ///1359 /// # Arguments1360 /// - `origin`: sender of the transaction1361 /// - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.1362 /// - `nft_id`: ID of the NFT with a resource to be removed.1363 /// - `resource_id`: ID of the resource to be removed.1364 #[pallet::weight(<SelfWeightOf<T>>::remove_resource())]1365 pub fn remove_resource(1366 origin: OriginFor<T>,1367 rmrk_collection_id: RmrkCollectionId,1368 nft_id: RmrkNftId,1369 resource_id: RmrkResourceId,1370 ) -> DispatchResult {1371 let sender = ensure_signed(origin.clone())?;13721373 let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1374 let collection =1375 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1376 collection.check_is_external()?;13771378 Self::resource_remove(sender, collection_id, nft_id.into(), resource_id)?;13791380 Self::deposit_event(Event::ResourceRemoval {1381 nft_id,1382 resource_id,1383 });1384 Ok(())1385 }1386 }1387}13881389impl<T: Config> Pallet<T> {1390 /// Transform one of possible RMRK keys into a byte key with a RMRK scope.1391 pub fn get_scoped_property_key(rmrk_key: RmrkProperty) -> Result<PropertyKey, DispatchError> {1392 let key = rmrk_key.to_key::<T>()?;13931394 let scoped_key = RMRK_SCOPE1395 .apply(key)1396 .map_err(|_| <Error<T>>::RmrkPropertyKeyIsTooLong)?;13971398 Ok(scoped_key)1399 }14001401 /// Form a Unique property, transforming a RMRK key into bytes (without assigning the scope yet)1402 /// and encoding the value from an arbitrary type into bytes.1403 pub fn encode_rmrk_property<E: Encode>(1404 rmrk_key: RmrkProperty,1405 value: &E,1406 ) -> Result<Property, DispatchError> {1407 let key = rmrk_key.to_key::<T>()?;14081409 let value = Self::encode_property_value(value)?;14101411 let property = Property { key, value };14121413 Ok(property)1414 }14151416 /// Encode property value from an arbitrary type into bytes for storage.1417 pub fn encode_property_value<E: Encode, S: Get<u32>>(1418 value: &E,1419 ) -> Result<BoundedBytes<S>, DispatchError> {1420 let value = value1421 .encode()1422 .try_into()1423 .map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong)?;14241425 Ok(value)1426 }14271428 /// Decode property value from bytes into an arbitrary type.1429 pub fn decode_property_value<D: Decode, S: Get<u32>>(1430 vec: &BoundedBytes<S>,1431 ) -> Result<D, DispatchError> {1432 vec.decode()1433 .map_err(|_| <Error<T>>::UnableToDecodeRmrkData.into())1434 }14351436 /// Change the limit of a property value byte vector.1437 pub fn rebind<L, S>(vec: &BoundedVec<u8, L>) -> Result<BoundedVec<u8, S>, DispatchError>1438 where1439 BoundedVec<u8, S>: TryFrom<Vec<u8>>,1440 {1441 vec.rebind()1442 .map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong.into())1443 }14441445 /// Initialize a new NFT collection with certain RMRK-scoped properties.1446 ///1447 /// See [`init_collection`](pallet_nonfungible::pallet::Pallet::init_collection) for more details.1448 fn init_collection(1449 sender: T::CrossAccountId,1450 data: CreateCollectionData<T::AccountId>,1451 properties: impl Iterator<Item = Property>,1452 ) -> Result<CollectionId, DispatchError> {1453 let collection_id = <PalletNft<T>>::init_collection(1454 sender.clone(),1455 sender,1456 data,1457 up_data_structs::CollectionFlags {1458 external: true,1459 ..Default::default()1460 },1461 );14621463 if let Err(DispatchError::Arithmetic(_)) = &collection_id {1464 return Err(<Error<T>>::NoAvailableCollectionId.into());1465 }14661467 <PalletCommon<T>>::set_scoped_collection_properties(1468 collection_id?,1469 RMRK_SCOPE,1470 properties,1471 )?;14721473 collection_id1474 }14751476 /// Mint a new NFT with certain RMRK-scoped properties. Sender must be the collection owner.1477 ///1478 /// See [`create_item`](pallet_nonfungible::pallet::Pallet::create_item) for more details.1479 pub fn create_nft(1480 sender: &T::CrossAccountId,1481 owner: &T::CrossAccountId,1482 collection: &NonfungibleHandle<T>,1483 properties: impl Iterator<Item = Property>,1484 ) -> Result<TokenId, DispatchError> {1485 let data = CreateNftExData {1486 properties: BoundedVec::default(),1487 owner: owner.clone(),1488 };14891490 let budget = budget::Value::new(NESTING_BUDGET);14911492 <PalletNft<T>>::create_item(collection, sender, data, &budget)?;14931494 let nft_id = <PalletNft<T>>::current_token_id(collection.id);14951496 <PalletNft<T>>::set_scoped_token_properties(collection.id, nft_id, RMRK_SCOPE, properties)?;14971498 Ok(nft_id)1499 }15001501 /// Burn an NFT, along with its nested children, limited by `max_burns`. The sender must be the token owner.1502 ///1503 /// See [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively) for more details.1504 fn destroy_nft(1505 sender: T::CrossAccountId,1506 collection_id: CollectionId,1507 token_id: TokenId,1508 max_burns: u32,1509 error_if_not_owned: Error<T>,1510 ) -> DispatchResultWithPostInfo {1511 let collection =1512 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;15131514 let token_data =1515 <TokenData<T>>::get((collection_id, token_id)).ok_or(<Error<T>>::NoAvailableNftId)?;15161517 let from = token_data.owner;15181519 let owner_check_budget = budget::Value::new(NESTING_BUDGET);15201521 ensure!(1522 <PalletStructure<T>>::check_indirectly_owned(1523 sender.clone(),1524 collection_id,1525 token_id,1526 None,1527 &owner_check_budget1528 )?,1529 error_if_not_owned,1530 );15311532 let burns_budget = budget::Value::new(max_burns);1533 let breadth_budget = budget::Value::new(max_burns);15341535 <PalletNft<T>>::burn_recursively(1536 &collection,1537 &from,1538 token_id,1539 &burns_budget,1540 &breadth_budget,1541 )1542 }15431544 /// Add a sent token pending acceptance to the target owning token as a property.1545 fn insert_pending_child(1546 target: (CollectionId, TokenId),1547 child: (RmrkCollectionId, RmrkNftId),1548 ) -> DispatchResult {1549 Self::mutate_pending_children(target, |pending_children| {1550 pending_children.insert(child);1551 })1552 }15531554 /// Remove a sent token pending acceptance from the target token's properties.1555 fn remove_pending_child(1556 target: (CollectionId, TokenId),1557 child: (RmrkCollectionId, RmrkNftId),1558 ) -> DispatchResult {1559 Self::mutate_pending_children(target, |pending_children| {1560 pending_children.remove(&child);1561 })1562 }15631564 /// Apply a mutation to the property of a token containing sent tokens1565 /// that are currently pending acceptance.1566 fn mutate_pending_children(1567 (target_collection_id, target_nft_id): (CollectionId, TokenId),1568 f: impl FnOnce(&mut PendingChildrenSet),1569 ) -> DispatchResult {1570 <PalletNft<T>>::try_mutate_token_aux_property(1571 target_collection_id,1572 target_nft_id,1573 RMRK_SCOPE,1574 Self::get_scoped_property_key(PendingChildren)?,1575 |pending_children| -> DispatchResult {1576 let mut map = match pending_children {1577 Some(map) => Self::decode_property_value(map)?,1578 None => PendingChildrenSet::new(),1579 };15801581 f(&mut map);15821583 *pending_children = Some(Self::encode_property_value(&map)?);15841585 Ok(())1586 },1587 )1588 }15891590 /// Get an iterator from a token's property containing tokens sent to it1591 /// that are currently pending acceptance.1592 fn iterate_pending_children(1593 collection_id: CollectionId,1594 nft_id: TokenId,1595 ) -> Result<impl Iterator<Item = PendingChild>, DispatchError> {1596 let property = <PalletNft<T>>::token_aux_property((1597 collection_id,1598 nft_id,1599 RMRK_SCOPE,1600 Self::get_scoped_property_key(PendingChildren)?,1601 ));16021603 let pending_children = match property {1604 Some(map) => Self::decode_property_value(&map)?,1605 None => PendingChildrenSet::new(),1606 };16071608 Ok(pending_children.into_iter())1609 }16101611 /// Get incremented resource ID from within an NFT's properties and store the new latest ID.1612 /// Thus, the returned resource ID should be used.1613 ///1614 /// Resource IDs are unique only across an NFT.1615 fn acquire_next_resource_id(1616 collection_id: CollectionId,1617 nft_id: TokenId,1618 ) -> Result<RmrkResourceId, DispatchError> {1619 let resource_id: RmrkResourceId =1620 Self::get_nft_property_decoded(collection_id, nft_id, NextResourceId)?;16211622 let next_id = resource_id1623 .checked_add(1)1624 .ok_or(<Error<T>>::NoAvailableResourceId)?;16251626 <PalletNft<T>>::set_scoped_token_property(1627 collection_id,1628 nft_id,1629 RMRK_SCOPE,1630 Self::encode_rmrk_property(NextResourceId, &next_id)?,1631 )?;16321633 Ok(resource_id)1634 }16351636 /// Create and add a resource for a regular NFT, mark it as pending if the sender1637 /// is not the token owner. The sender must be the collection owner.1638 fn resource_add(1639 sender: T::AccountId,1640 collection_id: CollectionId,1641 nft_id: TokenId,1642 resource: RmrkResourceTypes,1643 ) -> Result<RmrkResourceId, DispatchError> {1644 let collection =1645 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1646 ensure!(collection.owner == sender, Error::<T>::NoPermission);16471648 let sender = T::CrossAccountId::from_sub(sender);1649 let budget = budget::Value::new(NESTING_BUDGET);16501651 let nft_owner = <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)1652 .map_err(Self::map_unique_err_to_proxy)?;16531654 let pending = sender != nft_owner;16551656 let id = Self::acquire_next_resource_id(collection_id, nft_id)?;16571658 let resource_info = RmrkResourceInfo {1659 id,1660 resource,1661 pending,1662 pending_removal: false,1663 };16641665 <PalletNft<T>>::try_mutate_token_aux_property(1666 collection_id,1667 nft_id,1668 RMRK_SCOPE,1669 Self::get_scoped_property_key(ResourceId(id))?,1670 |value| -> DispatchResult {1671 *value = Some(Self::encode_property_value(&resource_info)?);16721673 Ok(())1674 },1675 )?;16761677 Ok(id)1678 }16791680 /// Designate a resource for erasure from an NFT, and remove it if the sender is the token owner.1681 /// The sender must be the collection owner.1682 fn resource_remove(1683 sender: T::AccountId,1684 collection_id: CollectionId,1685 nft_id: TokenId,1686 resource_id: RmrkResourceId,1687 ) -> DispatchResult {1688 let collection =1689 Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1690 ensure!(collection.owner == sender, Error::<T>::NoPermission);16911692 let resource_id_key = Self::get_scoped_property_key(ResourceId(resource_id))?;16931694 let resource = <PalletNft<T>>::token_aux_property((1695 collection_id,1696 nft_id,1697 RMRK_SCOPE,1698 resource_id_key.clone(),1699 ))1700 .ok_or(<Error<T>>::ResourceDoesntExist)?;17011702 let resource_info: RmrkResourceInfo = Self::decode_property_value(&resource)?;17031704 let budget = up_data_structs::budget::Value::new(NESTING_BUDGET);1705 let topmost_owner =1706 <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)?;17071708 let sender = T::CrossAccountId::from_sub(sender);1709 if topmost_owner == sender {1710 <PalletNft<T>>::remove_token_aux_property(1711 collection_id,1712 nft_id,1713 RMRK_SCOPE,1714 Self::get_scoped_property_key(ResourceId(resource_id))?,1715 );17161717 if let RmrkResourceTypes::Composable(resource) = resource_info.resource {1718 let base_id = resource.base;17191720 Self::remove_associated_base_id(collection_id, nft_id, base_id)?;1721 }1722 } else {1723 Self::try_mutate_resource_info(collection_id, nft_id, resource_id, |res| {1724 res.pending_removal = true;17251726 Ok(())1727 })?;1728 }17291730 Ok(())1731 }17321733 /// Remove a Base ID from an NFT if they are associated.1734 /// The Base itself is deleted if the number of associated NFTs reaches 0.1735 fn remove_associated_base_id(1736 collection_id: CollectionId,1737 nft_id: TokenId,1738 base_id: RmrkBaseId,1739 ) -> DispatchResult {1740 <PalletNft<T>>::try_mutate_token_aux_property(1741 collection_id,1742 nft_id,1743 RMRK_SCOPE,1744 Self::get_scoped_property_key(AssociatedBases)?,1745 |value| -> DispatchResult {1746 let mut bases: BasesMap = match value {1747 Some(value) => Self::decode_property_value(value)?,1748 None => BasesMap::new(),1749 };17501751 let remaining = bases.get(&base_id);17521753 if let Some(remaining) = remaining {1754 if let Some(0) | None = remaining.checked_sub(1) {1755 bases.remove(&base_id);1756 }1757 }17581759 *value = Some(Self::encode_property_value(&bases)?);1760 Ok(())1761 },1762 )1763 }17641765 /// Apply a mutation to a resource stored in the token properties of an NFT.1766 fn try_mutate_resource_info(1767 collection_id: CollectionId,1768 nft_id: TokenId,1769 resource_id: RmrkResourceId,1770 f: impl FnOnce(&mut RmrkResourceInfo) -> DispatchResult,1771 ) -> DispatchResult {1772 <PalletNft<T>>::try_mutate_token_aux_property(1773 collection_id,1774 nft_id,1775 RMRK_SCOPE,1776 Self::get_scoped_property_key(ResourceId(resource_id))?,1777 |value| match value {1778 Some(value) => {1779 let mut resource_info: RmrkResourceInfo = Self::decode_property_value(value)?;17801781 f(&mut resource_info)?;17821783 *value = Self::encode_property_value(&resource_info)?;17841785 Ok(())1786 }1787 None => Err(<Error<T>>::ResourceDoesntExist.into()),1788 },1789 )1790 }17911792 /// Change the owner of an NFT collection, ensuring that the sender is the current owner.1793 fn change_collection_owner(1794 collection_id: CollectionId,1795 collection_type: misc::CollectionType,1796 sender: T::AccountId,1797 new_owner: T::AccountId,1798 ) -> DispatchResult {1799 let collection = Self::get_typed_nft_collection(collection_id, collection_type)?;1800 Self::check_collection_owner(&collection, &T::CrossAccountId::from_sub(sender))?;18011802 let mut collection = collection.into_inner();18031804 collection.owner = new_owner;1805 collection.save()1806 }18071808 /// Ensure that an account is the collection owner/issuer, return an error if not.1809 pub fn check_collection_owner(1810 collection: &NonfungibleHandle<T>,1811 account: &T::CrossAccountId,1812 ) -> DispatchResult {1813 collection1814 .check_is_owner(account)1815 .map_err(Self::map_unique_err_to_proxy)1816 }18171818 /// Get the latest yet-unused RMRK collection index from the storage.1819 pub fn last_collection_idx() -> RmrkCollectionId {1820 <CollectionIndex<T>>::get()1821 }18221823 /// Get a mapping from a RMRK collection ID to its corresponding Unique collection ID.1824 pub fn unique_collection_id(1825 rmrk_collection_id: RmrkCollectionId,1826 ) -> Result<CollectionId, DispatchError> {1827 <UniqueCollectionId<T>>::try_get(rmrk_collection_id)1828 .map_err(|_| <Error<T>>::CollectionUnknown.into())1829 }18301831 /// Get a mapping from a Unique collection ID to its RMRK collection ID counterpart, if it exists.1832 pub fn rmrk_collection_id(1833 unique_collection_id: CollectionId,1834 ) -> Result<RmrkCollectionId, DispatchError> {1835 Self::get_collection_property_decoded(unique_collection_id, RmrkInternalCollectionId)1836 }18371838 /// Fetch a Unique NFT collection.1839 pub fn get_nft_collection(1840 collection_id: CollectionId,1841 ) -> Result<NonfungibleHandle<T>, DispatchError> {1842 let collection = <CollectionHandle<T>>::try_get(collection_id)1843 .map_err(|_| <Error<T>>::CollectionUnknown)?;18441845 match collection.mode {1846 CollectionMode::NFT => Ok(NonfungibleHandle::cast(collection)),1847 _ => Err(<Error<T>>::CollectionUnknown.into()),1848 }1849 }18501851 /// Check if an NFT collection with such an ID exists.1852 pub fn collection_exists(collection_id: CollectionId) -> bool {1853 <CollectionHandle<T>>::try_get(collection_id).is_ok()1854 }18551856 /// Fetch and decode a RMRK-scoped collection property value in bytes.1857 pub fn get_collection_property(1858 collection_id: CollectionId,1859 key: RmrkProperty,1860 ) -> Result<PropertyValue, DispatchError> {1861 let collection_property = <PalletCommon<T>>::collection_properties(collection_id)1862 .get(&Self::get_scoped_property_key(key)?)1863 .ok_or(<Error<T>>::CollectionUnknown)?1864 .clone();18651866 Ok(collection_property)1867 }18681869 /// Fetch a RMRK-scoped collection property and decode it from bytes into an appropriate type.1870 pub fn get_collection_property_decoded<V: Decode>(1871 collection_id: CollectionId,1872 key: RmrkProperty,1873 ) -> Result<V, DispatchError> {1874 Self::decode_property_value(&Self::get_collection_property(collection_id, key)?)1875 }18761877 /// Get the type of a collection stored as a scoped property.1878 ///1879 /// RMRK Core proxy differentiates between regular collections as well as RMRK Bases as collections.1880 pub fn get_collection_type(1881 collection_id: CollectionId,1882 ) -> Result<misc::CollectionType, DispatchError> {1883 Self::get_collection_property_decoded(collection_id, CollectionType).map_err(|err| {1884 if err != <Error<T>>::CollectionUnknown.into() {1885 <Error<T>>::CorruptedCollectionType.into()1886 } else {1887 err1888 }1889 })1890 }18911892 /// Ensure that the type of the collection equals the provided type,1893 /// otherwise return an error.1894 pub fn ensure_collection_type(1895 collection_id: CollectionId,1896 collection_type: misc::CollectionType,1897 ) -> DispatchResult {1898 let actual_type = Self::get_collection_type(collection_id)?;1899 ensure!(1900 actual_type == collection_type,1901 <CommonError<T>>::NoPermission1902 );19031904 Ok(())1905 }19061907 /// Fetch an NFT collection, but make sure it has the appropriate type.1908 pub fn get_typed_nft_collection(1909 collection_id: CollectionId,1910 collection_type: misc::CollectionType,1911 ) -> Result<NonfungibleHandle<T>, DispatchError> {1912 Self::ensure_collection_type(collection_id, collection_type)?;19131914 Self::get_nft_collection(collection_id)1915 }19161917 /// Same as [`get_typed_nft_collection`](crate::pallet::Pallet::get_typed_nft_collection),1918 /// but also return the Unique collection ID.1919 pub fn get_typed_nft_collection_mapped(1920 rmrk_collection_id: RmrkCollectionId,1921 collection_type: misc::CollectionType,1922 ) -> Result<(NonfungibleHandle<T>, CollectionId), DispatchError> {1923 let unique_collection_id = match collection_type {1924 misc::CollectionType::Regular => Self::unique_collection_id(rmrk_collection_id)?,1925 _ => rmrk_collection_id.into(),1926 };19271928 let collection = Self::get_typed_nft_collection(unique_collection_id, collection_type)?;19291930 Ok((collection, unique_collection_id))1931 }19321933 /// Fetch and decode a RMRK-scoped NFT property value in bytes.1934 pub fn get_nft_property(1935 collection_id: CollectionId,1936 nft_id: TokenId,1937 key: RmrkProperty,1938 ) -> Result<PropertyValue, DispatchError> {1939 let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))1940 .get(&Self::get_scoped_property_key(key)?)1941 .ok_or(<Error<T>>::RmrkPropertyIsNotFound)?1942 .clone();19431944 Ok(nft_property)1945 }19461947 /// Fetch a RMRK-scoped NFT property and decode it from bytes into an appropriate type.1948 pub fn get_nft_property_decoded<V: Decode>(1949 collection_id: CollectionId,1950 nft_id: TokenId,1951 key: RmrkProperty,1952 ) -> Result<V, DispatchError> {1953 Self::decode_property_value(&Self::get_nft_property(collection_id, nft_id, key)?)1954 }19551956 /// Check that an NFT exists.1957 pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {1958 <TokenData<T>>::contains_key((collection_id, nft_id))1959 }19601961 /// Get the type of an NFT stored as a scoped property.1962 ///1963 /// RMRK Core proxy differentiates between regular NFTs, and RMRK Parts and Themes.1964 pub fn get_nft_type(1965 collection_id: CollectionId,1966 token_id: TokenId,1967 ) -> Result<NftType, DispatchError> {1968 Self::get_nft_property_decoded(collection_id, token_id, TokenType)1969 .map_err(|_| <Error<T>>::NoAvailableNftId.into())1970 }19711972 /// Ensure that the type of the NFT equals the provided type, otherwise return an error.1973 pub fn ensure_nft_type(1974 collection_id: CollectionId,1975 token_id: TokenId,1976 nft_type: NftType,1977 ) -> DispatchResult {1978 let actual_type = Self::get_nft_type(collection_id, token_id)?;1979 ensure!(actual_type == nft_type, <Error<T>>::NoPermission);19801981 Ok(())1982 }19831984 /// Ensure that an account is the owner of the token, either directly1985 /// or at the top of the nesting hierarchy; return an error if it is not.1986 pub fn ensure_nft_owner(1987 collection_id: CollectionId,1988 token_id: TokenId,1989 possible_owner: &T::CrossAccountId,1990 nesting_budget: &dyn budget::Budget,1991 ) -> DispatchResult {1992 let is_owned = <PalletStructure<T>>::check_indirectly_owned(1993 possible_owner.clone(),1994 collection_id,1995 token_id,1996 None,1997 nesting_budget,1998 )1999 .map_err(Self::map_unique_err_to_proxy)?;20002001 ensure!(is_owned, <Error<T>>::NoPermission);20022003 Ok(())2004 }20052006 /// Fetch non-scoped properties of a collection or a token that match the filter keys supplied,2007 /// or, if None are provided, return all non-scoped properties.2008 pub fn filter_user_properties<Key, Value, R, Mapper>(2009 collection_id: CollectionId,2010 token_id: Option<TokenId>,2011 filter_keys: Option<Vec<RmrkPropertyKey>>,2012 mapper: Mapper,2013 ) -> Result<Vec<R>, DispatchError>2014 where2015 Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,2016 Value: Decode + Default,2017 Mapper: Fn(Key, Value) -> R,2018 {2019 filter_keys2020 .map(|keys| {2021 let properties = keys2022 .into_iter()2023 .filter_map(|key| {2024 let key: Key = key.try_into().ok()?;20252026 let value = match token_id {2027 Some(token_id) => Self::get_nft_property_decoded(2028 collection_id,2029 token_id,2030 UserProperty(key.as_ref()),2031 ),2032 None => Self::get_collection_property_decoded(2033 collection_id,2034 UserProperty(key.as_ref()),2035 ),2036 }2037 .ok()?;20382039 Some(mapper(key, value))2040 })2041 .collect();20422043 Ok(properties)2044 })2045 .unwrap_or_else(|| {2046 let properties =2047 Self::iterate_user_properties(collection_id, token_id, mapper)?.collect();20482049 Ok(properties)2050 })2051 }20522053 /// Get all non-scoped properties from a collection or a token, and apply some transformation,2054 /// supplied by `mapper`, to each key-value pair.2055 pub fn iterate_user_properties<Key, Value, R, Mapper>(2056 collection_id: CollectionId,2057 token_id: Option<TokenId>,2058 mapper: Mapper,2059 ) -> Result<impl Iterator<Item = R>, DispatchError>2060 where2061 Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,2062 Value: Decode + Default,2063 Mapper: Fn(Key, Value) -> R,2064 {2065 let properties = match token_id {2066 Some(token_id) => <PalletNft<T>>::token_properties((collection_id, token_id)),2067 None => <PalletCommon<T>>::collection_properties(collection_id),2068 };20692070 let properties = properties.into_iter().filter_map(move |(key, value)| {2071 let key = strip_key_prefix(&key, USER_PROPERTY_PREFIX)?;20722073 let key: Key = key.to_vec().try_into().ok()?;2074 let value: Value = value.decode().ok()?;20752076 Some(mapper(key, value))2077 });20782079 Ok(properties)2080 }20812082 /// Match Unique errors to RMRK's own and return the RMRK error if a match is successful.2083 fn map_unique_err_to_proxy(err: DispatchError) -> DispatchError {2084 map_unique_err_to_proxy! {2085 match err {2086 CommonError::NoPermission => NoPermission,2087 CommonError::CollectionTokenLimitExceeded => CollectionFullOrLocked,2088 CommonError::PublicMintingNotAllowed => NoPermission,2089 CommonError::TokenNotFound => NoAvailableNftId,2090 CommonError::ApprovedValueTooLow => NoPermission,2091 CommonError::CantDestroyNotEmptyCollection => CollectionNotEmpty,2092 StructureError::TokenNotFound => NoAvailableNftId,2093 StructureError::OuroborosDetected => CannotSendToDescendentOrSelf,2094 }2095 }2096 }2097}pallets/refungible/src/erc.rsdiffbeforeafterboth--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -31,14 +31,14 @@
};
use frame_support::{BoundedBTreeMap, BoundedVec};
use pallet_common::{
- CollectionHandle, CollectionPropertyPermissions,
+ CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,
erc::{CommonEvmHandler, CollectionCall, static_property::key},
- CommonCollectionOperations,
+ eth::EthCrossAccount,
};
use pallet_evm::{account::CrossAccountId, PrecompileHandle};
use pallet_evm_coder_substrate::{call, dispatch_to_evm};
use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
-use sp_core::H160;
+use sp_core::{H160, Get};
use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};
use up_data_structs::{
CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey,
@@ -482,6 +482,11 @@
// TODO: Not implemetable
Err("not implemented".into())
}
+
+ /// @notice Returns collection helper contract address
+ fn collection_helper_address(&self) -> Result<address> {
+ Ok(T::ContractAddress::get())
+ }
}
/// Returns amount of pieces of `token` that `owner` have
pallets/refungible/src/stubs/UniqueRefungible.rawdiffbeforeafterbothbinary blob — no preview
pallets/refungible/src/stubs/UniqueRefungible.soldiffbeforeafterboth--- a/pallets/refungible/src/stubs/UniqueRefungible.sol
+++ b/pallets/refungible/src/stubs/UniqueRefungible.sol
@@ -919,7 +919,7 @@
/// @title ERC-721 Non-Fungible Token Standard
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
-/// @dev the ERC-165 identifier for this interface is 0x58800161
+/// @dev the ERC-165 identifier for this interface is 0x4016cd87
contract ERC721 is Dummy, ERC165, ERC721Events {
/// @notice Count all RFTs assigned to an owner
/// @dev RFTs assigned to the zero address are considered invalid, and this
@@ -1047,6 +1047,15 @@
dummy;
return 0x0000000000000000000000000000000000000000;
}
+
+ /// @notice Returns collection helper contract address
+ /// @dev EVM selector for this function is: 0x1896cce6,
+ /// or in textual repr: collectionHelperAddress()
+ function collectionHelperAddress() public view returns (address) {
+ require(false, stub_error);
+ dummy;
+ return 0x0000000000000000000000000000000000000000;
+ }
}
contract UniqueRefungible is
pallets/refungible/src/stubs/UniqueRefungibleToken.rawdiffbeforeafterbothbinary blob — no preview
pallets/unique/src/eth/mod.rsdiffbeforeafterboth--- a/pallets/unique/src/eth/mod.rs
+++ b/pallets/unique/src/eth/mod.rs
@@ -28,6 +28,7 @@
CollectionById,
dispatch::CollectionDispatch,
erc::{CollectionHelpersEvents, static_property::key},
+ eth::{map_eth_to_id, collection_id_to_address},
Pallet as PalletCommon,
};
use pallet_evm::{account::CrossAccountId, OnMethodCall, PrecompileHandle, PrecompileResult};
@@ -35,7 +36,7 @@
use sp_std::vec;
use up_data_structs::{
CollectionDescription, CollectionMode, CollectionName, CollectionTokenPrefix,
- CreateCollectionData,
+ CreateCollectionData, CollectionId,
};
use crate::{weights::WeightInfo, Config, SelfWeightOf};
@@ -361,6 +362,25 @@
.expect("Collection creation price should be convertible to u128");
Ok(price.into())
}
+
+ /// Returns address of a collection.
+ /// @param collectionId - CollectionId of the collection
+ /// @return eth mirror address of the collection
+ fn collection_address(&self, collection_id: uint32) -> Result<address> {
+ Ok(collection_id_to_address(collection_id.into()))
+ }
+
+ /// Returns collectionId of a collection.
+ /// @param collectionAddress - Eth address of the collection
+ /// @return collectionId of the collection
+ fn collection_id(&self, collection_address: address) -> Result<uint32> {
+ map_eth_to_id(&collection_address)
+ .map(|id| id.0)
+ .ok_or(Error::Revert(format!(
+ "failed to convert address {} into collectionId.",
+ collection_address
+ )))
+ }
}
/// Implements [`OnMethodCall`], which delegates call to [`EvmCollectionHelpers`]
pallets/unique/src/eth/stubs/CollectionHelpers.rawdiffbeforeafterbothbinary blob — no preview
pallets/unique/src/eth/stubs/CollectionHelpers.soldiffbeforeafterboth--- a/pallets/unique/src/eth/stubs/CollectionHelpers.sol
+++ b/pallets/unique/src/eth/stubs/CollectionHelpers.sol
@@ -24,7 +24,7 @@
}
/// @title Contract, which allows users to operate with collections
-/// @dev the ERC-165 identifier for this interface is 0x7dea03b1
+/// @dev the ERC-165 identifier for this interface is 0xe65011aa
contract CollectionHelpers is Dummy, ERC165, CollectionHelpersEvents {
/// Create an NFT collection
/// @param name Name of the collection
@@ -130,4 +130,28 @@
dummy;
return 0;
}
+
+ /// Returns address of a collection.
+ /// @param collectionId - CollectionId of the collection
+ /// @return eth mirror address of the collection
+ /// @dev EVM selector for this function is: 0x2e716683,
+ /// or in textual repr: collectionAddress(uint32)
+ function collectionAddress(uint32 collectionId) public view returns (address) {
+ require(false, stub_error);
+ collectionId;
+ dummy;
+ return 0x0000000000000000000000000000000000000000;
+ }
+
+ /// Returns collectionId of a collection.
+ /// @param collectionAddress - Eth address of the collection
+ /// @return collectionId of the collection
+ /// @dev EVM selector for this function is: 0xb5cb7498,
+ /// or in textual repr: collectionId(address)
+ function collectionId(address collectionAddress) public view returns (uint32) {
+ require(false, stub_error);
+ collectionAddress;
+ dummy;
+ return 0;
+ }
}
pallets/unique/src/lib.rsdiffbeforeafterboth--- a/pallets/unique/src/lib.rs
+++ b/pallets/unique/src/lib.rs
@@ -86,6 +86,8 @@
use sp_std::{vec, vec::Vec};
use up_data_structs::{
MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
+ MAX_PROPERTIES_PER_ITEM, MAX_PROPERTY_KEY_LENGTH, MAX_PROPERTY_VALUE_LENGTH,
+ MAX_COLLECTION_PROPERTIES_SIZE, COLLECTION_ADMINS_LIMIT, MAX_TOKEN_PROPERTIES_SIZE,
CreateItemData, CollectionLimits, CollectionPermissions, CollectionId, CollectionMode, TokenId,
SponsorshipState, CreateCollectionData, CreateItemExData, budget, Property, PropertyKey,
PropertyKeyPermission,
@@ -102,7 +104,7 @@
pub mod weights;
use weights::WeightInfo;
-/// Maximum number of levels of depth in the token nesting tree.
+/// A maximum number of levels of depth in the token nesting tree.
pub const NESTING_BUDGET: u32 = 5;
decl_error! {
@@ -277,6 +279,46 @@
{
type Error = Error<T>;
+ #[doc = "A maximum number of levels of depth in the token nesting tree."]
+ const NESTING_BUDGET: u32 = NESTING_BUDGET;
+
+ #[doc = "Maximal length of a collection name."]
+ const MAX_COLLECTION_NAME_LENGTH: u32 = MAX_COLLECTION_NAME_LENGTH;
+
+ #[doc = "Maximal length of a collection description."]
+ const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = MAX_COLLECTION_DESCRIPTION_LENGTH;
+
+ #[doc = "Maximal length of a token prefix."]
+ const MAX_TOKEN_PREFIX_LENGTH: u32 = MAX_TOKEN_PREFIX_LENGTH;
+
+ #[doc = "Maximum admins per collection."]
+ const COLLECTION_ADMINS_LIMIT: u32 = COLLECTION_ADMINS_LIMIT;
+
+ #[doc = "Maximal length of a property key."]
+ const MAX_PROPERTY_KEY_LENGTH: u32 = MAX_PROPERTY_KEY_LENGTH;
+
+ #[doc = "Maximal length of a property value."]
+ const MAX_PROPERTY_VALUE_LENGTH: u32 = MAX_PROPERTY_VALUE_LENGTH;
+
+ #[doc = "A maximum number of token properties."]
+ const MAX_PROPERTIES_PER_ITEM: u32 = MAX_PROPERTIES_PER_ITEM;
+
+ #[doc = "Maximum size for all collection properties."]
+ const MAX_COLLECTION_PROPERTIES_SIZE: u32 = MAX_COLLECTION_PROPERTIES_SIZE;
+
+ #[doc = "Maximum size of all token properties."]
+ const MAX_TOKEN_PROPERTIES_SIZE: u32 = MAX_TOKEN_PROPERTIES_SIZE;
+
+ #[doc = "Default NFT collection limit."]
+ const NFT_DEFAULT_COLLECTION_LIMITS: CollectionLimits = CollectionLimits::with_default_limits(CollectionMode::NFT);
+
+ #[doc = "Default RFT collection limit."]
+ const RFT_DEFAULT_COLLECTION_LIMITS: CollectionLimits = CollectionLimits::with_default_limits(CollectionMode::ReFungible);
+
+ #[doc = "Default FT collection limit."]
+ const FT_DEFAULT_COLLECTION_LIMITS: CollectionLimits = CollectionLimits::with_default_limits(CollectionMode::Fungible(0));
+
+
pub fn deposit_event() = default;
fn on_initialize(_now: T::BlockNumber) -> Weight {
primitives/data-structs/CHANGELOG.mddiffbeforeafterboth--- a/primitives/data-structs/CHANGELOG.md
+++ b/primitives/data-structs/CHANGELOG.md
@@ -3,6 +3,7 @@
All notable changes to this project will be documented in this file.
<!-- bureaucrate goes here -->
+
## [v0.2.2] 2022-08-16
### Other changes
@@ -28,12 +29,19 @@
multiple users into `RefungibleMultipleItems` call.
## [v0.2.0] - 2022-08-01
+
### Deprecated
+
- `CreateReFungibleData::const_data`
## [v0.1.2] - 2022-07-25
+
### Added
+
- Type aliases `CollectionName`, `CollectionDescription`, `CollectionTokenPrefix`
+
## [v0.1.1] - 2022-07-22
+
### Added
-- Аields with properties to `CreateReFungibleData` and `CreateRefungibleExData`.
\ No newline at end of file
+
+- Fields with properties to `CreateReFungibleData` and `CreateRefungibleExData`.
primitives/data-structs/src/lib.rsdiffbeforeafterboth--- a/primitives/data-structs/src/lib.rs
+++ b/primitives/data-structs/src/lib.rs
@@ -120,22 +120,22 @@
// TODO: not used. Delete?
pub const COLLECTION_FIELD_LIMIT: u32 = CONST_ON_CHAIN_SCHEMA_LIMIT;
-/// Maximum length for collection name.
+/// Maximal length of a collection name.
pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;
-/// Maximum length for collection description.
+/// Maximal length of a collection description.
pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;
-/// Maximal token prefix length.
+/// Maximal length of a token prefix.
pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;
-/// Maximal lenght of property key.
+/// Maximal length of a property key.
pub const MAX_PROPERTY_KEY_LENGTH: u32 = 256;
-/// Maximal lenght of property value.
+/// Maximal length of a property value.
pub const MAX_PROPERTY_VALUE_LENGTH: u32 = 32768;
-/// Maximum properties that can be assigned to token.
+/// A maximum number of token properties.
pub const MAX_PROPERTIES_PER_ITEM: u32 = 64;
/// Maximal lenght of extended property value.
@@ -144,7 +144,7 @@
/// Maximum size for all collection properties.
pub const MAX_COLLECTION_PROPERTIES_SIZE: u32 = 40960;
-/// Maximum size for all token properties.
+/// Maximum size of all token properties.
pub const MAX_TOKEN_PROPERTIES_SIZE: u32 = 32768;
/// How much items can be created per single
@@ -609,6 +609,24 @@
}
impl CollectionLimits {
+ pub fn with_default_limits(collection_type: CollectionMode) -> Self {
+ CollectionLimits {
+ account_token_ownership_limit: Some(ACCOUNT_TOKEN_OWNERSHIP_LIMIT),
+ sponsored_data_size: Some(CUSTOM_DATA_LIMIT),
+ sponsored_data_rate_limit: Some(SponsoringRateLimit::SponsoringDisabled),
+ token_limit: Some(COLLECTION_TOKEN_LIMIT),
+ sponsor_transfer_timeout: match collection_type {
+ CollectionMode::NFT => Some(NFT_SPONSOR_TRANSFER_TIMEOUT),
+ CollectionMode::ReFungible => Some(REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT),
+ CollectionMode::Fungible(_) => Some(FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT),
+ },
+ sponsor_approve_timeout: Some(SPONSOR_APPROVE_TIMEOUT),
+ owner_can_transfer: Some(false),
+ owner_can_destroy: Some(true),
+ transfers_enabled: Some(true),
+ }
+ }
+
/// Get effective value for [`account_token_ownership_limit`](self.account_token_ownership_limit).
pub fn account_token_ownership_limit(&self) -> u32 {
self.account_token_ownership_limit
tests/package.jsondiffbeforeafterboth--- a/tests/package.json
+++ b/tests/package.json
@@ -102,6 +102,7 @@
"testXcmTransferStatemine": "mocha --timeout 9999999 -r ts-node/register ./**/xcm/xcmTransferStatemine.test.ts statemineId=1000 uniqueId=5000",
"testXcmTransferMoonbeam": "mocha --timeout 9999999 -r ts-node/register ./**/xcm/xcmTransferMoonbeam.test.ts",
"benchMintingFee": "ts-node src/benchmarks/mintFee/benchmark.ts",
+ "testApiConsts": "mocha --timeout 9999999 -r ts-node/register ./**/apiConsts.test.ts",
"load": "mocha --timeout 9999999 -r ts-node/register './**/*.load.ts'",
"loadTransfer": "ts-node src/transfer.nload.ts",
"polkadot-types-fetch-metadata": "curl -H 'Content-Type: application/json' -d '{\"id\":\"1\", \"jsonrpc\":\"2.0\", \"method\": \"state_getMetadata\", \"params\":[]}' http://localhost:9933 > src/interfaces/metadata.json",
tests/src/apiConsts.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/apiConsts.test.ts
@@ -0,0 +1,120 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+import {ApiPromise} from '@polkadot/api';
+import {ApiBase} from '@polkadot/api/base';
+import {usingPlaygrounds, itSub, expect} from './util';
+
+
+const MAX_COLLECTION_DESCRIPTION_LENGTH = 256n;
+const MAX_COLLECTION_NAME_LENGTH = 64n;
+const COLLECTION_ADMINS_LIMIT = 5n;
+const MAX_COLLECTION_PROPERTIES_SIZE = 40960n;
+const MAX_TOKEN_PREFIX_LENGTH = 16n;
+const MAX_PROPERTY_KEY_LENGTH = 256n;
+const MAX_PROPERTY_VALUE_LENGTH = 32768n;
+const MAX_PROPERTIES_PER_ITEM = 64n;
+const MAX_TOKEN_PROPERTIES_SIZE = 32768n;
+const NESTING_BUDGET = 5n;
+
+const DEFAULT_COLLETCTION_LIMIT = {
+ accountTokenOwnershipLimit: '1,000,000',
+ sponsoredDataSize: '2,048',
+ sponsoredDataRateLimit: 'SponsoringDisabled',
+ tokenLimit: '4,294,967,295',
+ sponsorTransferTimeout: '5',
+ sponsorApproveTimeout: '5',
+ ownerCanTransfer: false,
+ ownerCanDestroy: true,
+ transfersEnabled: true,
+};
+
+const EVM_COLLECTION_HELPERS_ADDRESS = '0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f';
+const HELPERS_CONTRACT_ADDRESS = '0x842899ECF380553E8a4de75bF534cdf6fBF64049';
+
+describe('integration test: API UNIQUE consts', () => {
+ let api: ApiPromise;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper) => {
+ api = await helper.getApi();
+ });
+ });
+
+ itSub('DEFAULT_NFT_COLLECTION_LIMITS', () => {
+ expect(api.consts.unique.nftDefaultCollectionLimits.toHuman()).to.deep.equal(DEFAULT_COLLETCTION_LIMIT);
+ });
+
+ itSub('DEFAULT_RFT_COLLECTION_LIMITS', () => {
+ expect(api.consts.unique.rftDefaultCollectionLimits.toHuman()).to.deep.equal(DEFAULT_COLLETCTION_LIMIT);
+ });
+
+ itSub('DEFAULT_FT_COLLECTION_LIMITS', () => {
+ expect(api.consts.unique.ftDefaultCollectionLimits.toHuman()).to.deep.equal(DEFAULT_COLLETCTION_LIMIT);
+ });
+
+ itSub('MAX_COLLECTION_NAME_LENGTH', () => {
+ checkConst(api.consts.unique.maxCollectionNameLength, MAX_COLLECTION_NAME_LENGTH);
+ });
+
+ itSub('MAX_COLLECTION_DESCRIPTION_LENGTH', () => {
+ checkConst(api.consts.unique.maxCollectionDescriptionLength, MAX_COLLECTION_DESCRIPTION_LENGTH);
+ });
+
+ itSub('MAX_COLLECTION_PROPERTIES_SIZE', () => {
+ checkConst(api.consts.unique.maxCollectionPropertiesSize, MAX_COLLECTION_PROPERTIES_SIZE);
+ });
+
+ itSub('MAX_TOKEN_PREFIX_LENGTH', () => {
+ checkConst(api.consts.unique.maxTokenPrefixLength, MAX_TOKEN_PREFIX_LENGTH);
+ });
+
+ itSub('MAX_PROPERTY_KEY_LENGTH', () => {
+ checkConst(api.consts.unique.maxPropertyKeyLength, MAX_PROPERTY_KEY_LENGTH);
+ });
+
+ itSub('MAX_PROPERTY_VALUE_LENGTH', () => {
+ checkConst(api.consts.unique.maxPropertyValueLength, MAX_PROPERTY_VALUE_LENGTH);
+ });
+
+ itSub('MAX_PROPERTIES_PER_ITEM', () => {
+ checkConst(api.consts.unique.maxPropertiesPerItem, MAX_PROPERTIES_PER_ITEM);
+ });
+
+ itSub('NESTING_BUDGET', () => {
+ checkConst(api.consts.unique.nestingBudget, NESTING_BUDGET);
+ });
+
+ itSub('MAX_TOKEN_PROPERTIES_SIZE', () => {
+ checkConst(api.consts.unique.maxTokenPropertiesSize, MAX_TOKEN_PROPERTIES_SIZE);
+ });
+
+ itSub('COLLECTION_ADMINS_LIMIT', () => {
+ checkConst(api.consts.unique.collectionAdminsLimit, COLLECTION_ADMINS_LIMIT);
+ });
+
+ itSub('HELPERS_CONTRACT_ADDRESS', () => {
+ expect(api.consts.evmContractHelpers.contractAddress.toString().toLowerCase()).to.be.equal(HELPERS_CONTRACT_ADDRESS.toLowerCase());
+ });
+
+ itSub('EVM_COLLECTION_HELPERS_ADDRESS', () => {
+ expect(api.consts.common.contractAddress.toString().toLowerCase()).to.be.equal(EVM_COLLECTION_HELPERS_ADDRESS.toLowerCase());
+ });
+});
+
+function checkConst<T>(constValue: any, expectedValue: T) {
+ expect(constValue.toBigInt()).equal(expectedValue);
+}
\ No newline at end of file
tests/src/eth/abi/collectionHelpers.jsondiffbeforeafterboth--- a/tests/src/eth/abi/collectionHelpers.json
+++ b/tests/src/eth/abi/collectionHelpers.json
@@ -32,6 +32,15 @@
"type": "event"
},
{
+ "inputs": [
+ { "internalType": "uint32", "name": "collectionId", "type": "uint32" }
+ ],
+ "name": "collectionAddress",
+ "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
"inputs": [],
"name": "collectionCreationFee",
"outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
@@ -40,6 +49,19 @@
},
{
"inputs": [
+ {
+ "internalType": "address",
+ "name": "collectionAddress",
+ "type": "address"
+ }
+ ],
+ "name": "collectionId",
+ "outputs": [{ "internalType": "uint32", "name": "", "type": "uint32" }],
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "inputs": [
{ "internalType": "string", "name": "name", "type": "string" },
{ "internalType": "uint8", "name": "decimals", "type": "uint8" },
{ "internalType": "string", "name": "description", "type": "string" },
tests/src/eth/abi/fungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/fungible.json
+++ b/tests/src/eth/abi/fungible.json
@@ -201,6 +201,13 @@
},
{
"inputs": [],
+ "name": "collectionHelperAddress",
+ "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "inputs": [],
"name": "collectionOwner",
"outputs": [
{
tests/src/eth/abi/nonFungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/nonFungible.json
+++ b/tests/src/eth/abi/nonFungible.json
@@ -231,6 +231,13 @@
},
{
"inputs": [],
+ "name": "collectionHelperAddress",
+ "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "inputs": [],
"name": "collectionOwner",
"outputs": [
{
tests/src/eth/abi/reFungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/reFungible.json
+++ b/tests/src/eth/abi/reFungible.json
@@ -213,6 +213,13 @@
},
{
"inputs": [],
+ "name": "collectionHelperAddress",
+ "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "inputs": [],
"name": "collectionOwner",
"outputs": [
{
tests/src/eth/api/CollectionHelpers.soldiffbeforeafterboth--- a/tests/src/eth/api/CollectionHelpers.sol
+++ b/tests/src/eth/api/CollectionHelpers.sol
@@ -19,7 +19,7 @@
}
/// @title Contract, which allows users to operate with collections
-/// @dev the ERC-165 identifier for this interface is 0x7dea03b1
+/// @dev the ERC-165 identifier for this interface is 0xe65011aa
interface CollectionHelpers is Dummy, ERC165, CollectionHelpersEvents {
/// Create an NFT collection
/// @param name Name of the collection
@@ -78,4 +78,18 @@
/// @dev EVM selector for this function is: 0xd23a7ab1,
/// or in textual repr: collectionCreationFee()
function collectionCreationFee() external view returns (uint256);
+
+ /// Returns address of a collection.
+ /// @param collectionId - CollectionId of the collection
+ /// @return eth mirror address of the collection
+ /// @dev EVM selector for this function is: 0x2e716683,
+ /// or in textual repr: collectionAddress(uint32)
+ function collectionAddress(uint32 collectionId) external view returns (address);
+
+ /// Returns collectionId of a collection.
+ /// @param collectionAddress - Eth address of the collection
+ /// @return collectionId of the collection
+ /// @dev EVM selector for this function is: 0xb5cb7498,
+ /// or in textual repr: collectionId(address)
+ function collectionId(address collectionAddress) external view returns (uint32);
}
tests/src/eth/api/UniqueFungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -354,7 +354,7 @@
event Approval(address indexed owner, address indexed spender, uint256 value);
}
-/// @dev the ERC-165 identifier for this interface is 0x942e8b22
+/// @dev the ERC-165 identifier for this interface is 0x8cb847c4
interface ERC20 is Dummy, ERC165, ERC20Events {
/// @dev EVM selector for this function is: 0x06fdde03,
/// or in textual repr: name()
@@ -395,6 +395,11 @@
/// @dev EVM selector for this function is: 0xdd62ed3e,
/// or in textual repr: allowance(address,address)
function allowance(address owner, address spender) external view returns (uint256);
+
+ /// @notice Returns collection helper contract address
+ /// @dev EVM selector for this function is: 0x1896cce6,
+ /// or in textual repr: collectionHelperAddress()
+ function collectionHelperAddress() external view returns (address);
}
interface UniqueFungible is Dummy, ERC165, ERC20, ERC20Mintable, ERC20UniqueExtensions, Collection {}
tests/src/eth/api/UniqueNFT.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -605,7 +605,7 @@
/// @title ERC-721 Non-Fungible Token Standard
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
-/// @dev the ERC-165 identifier for this interface is 0x80ac58cd
+/// @dev the ERC-165 identifier for this interface is 0x983a942b
interface ERC721 is Dummy, ERC165, ERC721Events {
/// @notice Count all NFTs assigned to an owner
/// @dev NFTs assigned to the zero address are considered invalid, and this
@@ -685,6 +685,11 @@
/// @dev EVM selector for this function is: 0xe985e9c5,
/// or in textual repr: isApprovedForAll(address,address)
function isApprovedForAll(address owner, address operator) external view returns (address);
+
+ /// @notice Returns collection helper contract address
+ /// @dev EVM selector for this function is: 0x1896cce6,
+ /// or in textual repr: collectionHelperAddress()
+ function collectionHelperAddress() external view returns (address);
}
interface UniqueNFT is
tests/src/eth/api/UniqueRefungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueRefungible.sol
+++ b/tests/src/eth/api/UniqueRefungible.sol
@@ -604,7 +604,7 @@
/// @title ERC-721 Non-Fungible Token Standard
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
-/// @dev the ERC-165 identifier for this interface is 0x58800161
+/// @dev the ERC-165 identifier for this interface is 0x4016cd87
interface ERC721 is Dummy, ERC165, ERC721Events {
/// @notice Count all RFTs assigned to an owner
/// @dev RFTs assigned to the zero address are considered invalid, and this
@@ -682,6 +682,11 @@
/// @dev EVM selector for this function is: 0xe985e9c5,
/// or in textual repr: isApprovedForAll(address,address)
function isApprovedForAll(address owner, address operator) external view returns (address);
+
+ /// @notice Returns collection helper contract address
+ /// @dev EVM selector for this function is: 0x1896cce6,
+ /// or in textual repr: collectionHelperAddress()
+ function collectionHelperAddress() external view returns (address);
}
interface UniqueRefungible is
tests/src/eth/collectionHelperAddress.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/eth/collectionHelperAddress.test.ts
@@ -0,0 +1,72 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+import {itEth, usingEthPlaygrounds, expect} from './util';
+import {IKeyringPair} from '@polkadot/types/types';
+import {Pallets} from '../util';
+
+const EVM_COLLECTION_HELPERS_ADDRESS = '0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f';
+
+describe('[eth]CollectionHelperAddress test: ERC20/ERC721 ', () => {
+ let donor: IKeyringPair;
+
+ before(async function() {
+ await usingEthPlaygrounds(async (helper, privateKey) => {
+ donor = await privateKey({filename: __filename});
+ });
+ });
+
+ itEth('NFT', async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+
+ const {collectionAddress: nftCollectionAddress} = await helper.eth.createNFTCollection(owner, 'Sponsor', 'absolutely anything', 'ROC');
+ const nftCollection = helper.ethNativeContract.collection(nftCollectionAddress, 'nft', owner);
+
+ expect((await nftCollection.methods.collectionHelperAddress().call())
+ .toString().toLowerCase()).to.be.equal(EVM_COLLECTION_HELPERS_ADDRESS);
+ });
+
+ itEth.ifWithPallets('RFT ', [Pallets.ReFungible], async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+
+ const {collectionAddress: rftCollectionAddress} = await helper.eth.createRFTCollection(owner, 'Sponsor', 'absolutely anything', 'ROC');
+
+ const rftCollection = helper.ethNativeContract.collection(rftCollectionAddress, 'rft', owner);
+ expect((await rftCollection.methods.collectionHelperAddress().call())
+ .toString().toLowerCase()).to.be.equal(EVM_COLLECTION_HELPERS_ADDRESS);
+ });
+
+ itEth('FT', async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+
+ const {collectionAddress} = await helper.eth.createFungibleCollection(owner, 'Sponsor', 18, 'absolutely anything', 'ROC');
+ const collection = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
+
+ expect((await collection.methods.collectionHelperAddress().call())
+ .toString().toLowerCase()).to.be.equal(EVM_COLLECTION_HELPERS_ADDRESS);
+ });
+
+ itEth('[collectionHelpers] convert collectionId into address', async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const collectionId = 7;
+ const collectionAddress = helper.ethAddress.fromCollectionId(collectionId);
+ const helperContract = helper.ethNativeContract.collectionHelpers(owner);
+
+ expect(await helperContract.methods.collectionAddress(collectionId).call()).to.be.equal(collectionAddress);
+ expect(parseInt(await helperContract.methods.collectionId(collectionAddress).call())).to.be.equal(collectionId);
+ });
+
+});
tests/src/eth/util/playgrounds/unique.dev.tsdiffbeforeafterboth--- a/tests/src/eth/util/playgrounds/unique.dev.ts
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -103,12 +103,12 @@
contractHelpers(caller: string): Contract {
const web3 = this.helper.getWeb3();
- return new web3.eth.Contract(contractHelpersAbi as any, '0x842899ECF380553E8a4de75bF534cdf6fBF64049', {from: caller, gas: this.helper.eth.DEFAULT_GAS});
+ return new web3.eth.Contract(contractHelpersAbi as any, this.helper.getApi().consts.evmContractHelpers.contractAddress.toString(), {from: caller, gas: this.helper.eth.DEFAULT_GAS});
}
collectionHelpers(caller: string) {
const web3 = this.helper.getWeb3();
- return new web3.eth.Contract(collectionHelpersAbi as any, '0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f', {from: caller, gas: this.helper.eth.DEFAULT_GAS});
+ return new web3.eth.Contract(collectionHelpersAbi as any, this.helper.getApi().consts.common.contractAddress.toString(), {from: caller, gas: this.helper.eth.DEFAULT_GAS});
}
collection(address: string, mode: TCollectionMode, caller?: string, mergeDeprecated = false): Contract {
tests/src/interfaces/augment-api-consts.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-api-consts.ts
+++ b/tests/src/interfaces/augment-api-consts.ts
@@ -8,8 +8,8 @@
import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types';
import type { Option, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { Codec } from '@polkadot/types-codec/types';
-import type { Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime';
-import type { FrameSupportPalletId, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, XcmV1MultiLocation } from '@polkadot/types/lookup';
+import type { H160, Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime';
+import type { FrameSupportPalletId, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, UpDataStructsCollectionLimits, XcmV1MultiLocation } from '@polkadot/types/lookup';
export type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;
@@ -70,6 +70,10 @@
**/
collectionCreationPrice: u128 & AugmentedConst<ApiType>;
/**
+ * Address under which the CollectionHelper contract would be available.
+ **/
+ contractAddress: H160 & AugmentedConst<ApiType>;
+ /**
* Generic const
**/
[key: string]: Codec;
@@ -82,6 +86,16 @@
**/
[key: string]: Codec;
};
+ evmContractHelpers: {
+ /**
+ * Address, under which magic contract will be available
+ **/
+ contractAddress: H160 & AugmentedConst<ApiType>;
+ /**
+ * Generic const
+ **/
+ [key: string]: Codec;
+ };
inflation: {
/**
* Number of blocks that pass between treasury balance updates due to inflation
@@ -231,6 +245,64 @@
**/
[key: string]: Codec;
};
+ unique: {
+ /**
+ * Maximum admins per collection.
+ **/
+ collectionAdminsLimit: u32 & AugmentedConst<ApiType>;
+ /**
+ * Default FT collection limit.
+ **/
+ ftDefaultCollectionLimits: UpDataStructsCollectionLimits & AugmentedConst<ApiType>;
+ /**
+ * Maximal length of a collection description.
+ **/
+ maxCollectionDescriptionLength: u32 & AugmentedConst<ApiType>;
+ /**
+ * Maximal length of a collection name.
+ **/
+ maxCollectionNameLength: u32 & AugmentedConst<ApiType>;
+ /**
+ * Maximum size for all collection properties.
+ **/
+ maxCollectionPropertiesSize: u32 & AugmentedConst<ApiType>;
+ /**
+ * A maximum number of token properties.
+ **/
+ maxPropertiesPerItem: u32 & AugmentedConst<ApiType>;
+ /**
+ * Maximal length of a property key.
+ **/
+ maxPropertyKeyLength: u32 & AugmentedConst<ApiType>;
+ /**
+ * Maximal length of a property value.
+ **/
+ maxPropertyValueLength: u32 & AugmentedConst<ApiType>;
+ /**
+ * Maximal length of a token prefix.
+ **/
+ maxTokenPrefixLength: u32 & AugmentedConst<ApiType>;
+ /**
+ * Maximum size of all token properties.
+ **/
+ maxTokenPropertiesSize: u32 & AugmentedConst<ApiType>;
+ /**
+ * A maximum number of levels of depth in the token nesting tree.
+ **/
+ nestingBudget: u32 & AugmentedConst<ApiType>;
+ /**
+ * Default NFT collection limit.
+ **/
+ nftDefaultCollectionLimits: UpDataStructsCollectionLimits & AugmentedConst<ApiType>;
+ /**
+ * Default RFT collection limit.
+ **/
+ rftDefaultCollectionLimits: UpDataStructsCollectionLimits & AugmentedConst<ApiType>;
+ /**
+ * Generic const
+ **/
+ [key: string]: Codec;
+ };
vesting: {
/**
* The minimum amount transferred to call `vested_transfer`.