difftreelog
Merge branch 'develop' into tests/generalization
in: master
33 files changed
Cargo.lockdiffbeforeafterboth--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2321,7 +2321,7 @@
[[package]]
name = "evm-coder"
-version = "0.1.5"
+version = "0.1.6"
dependencies = [
"ethereum 0.14.0",
"evm-coder-procedural",
crates/evm-coder/CHANGELOG.mddiffbeforeafterboth--- a/crates/evm-coder/CHANGELOG.md
+++ b/crates/evm-coder/CHANGELOG.md
@@ -3,6 +3,13 @@
All notable changes to this project will be documented in this file.
<!-- bureaucrate goes here -->
+## [v0.1.6] - 2023-01-12
+
+### Added
+- Support Option<T> type.
+### Removed
+- Frontier dependency.
+
## [v0.1.5] - 2022-11-30
### Added
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.5"
+version = "0.1.6"
license = "GPLv3"
edition = "2021"
crates/evm-coder/src/abi/impls.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/impls.rs
+++ b/crates/evm-coder/src/abi/impls.rs
@@ -258,3 +258,39 @@
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}
+
+//----- impls for Option -----
+impl<T: AbiType> AbiType for Option<T> {
+ const SIGNATURE: SignatureUnit = <(bool, T)>::SIGNATURE;
+
+ fn is_dynamic() -> bool {
+ <(bool, T)>::is_dynamic()
+ }
+
+ fn size() -> usize {
+ <(bool, T)>::size()
+ }
+}
+
+impl<T: AbiWrite + AbiType + Default> AbiWrite for Option<T> {
+ fn abi_write(&self, writer: &mut AbiWriter) {
+ match self {
+ Some(value) => (true, value).abi_write(writer),
+ None => (false, T::default()).abi_write(writer),
+ }
+ }
+}
+
+impl<T> AbiRead for Option<T>
+where
+ Self: AbiType,
+ T: AbiRead + AbiType,
+{
+ fn abi_read(reader: &mut AbiReader) -> Result<Self>
+ where
+ Self: Sized,
+ {
+ let (status, value) = <(bool, T)>::abi_read(reader)?;
+ Ok(if status { Some(value) } else { None })
+ }
+}
crates/evm-coder/src/abi/test.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/test.rs
+++ b/crates/evm-coder/src/abi/test.rs
@@ -538,3 +538,68 @@
assert_eq!(p1, 0x0a);
assert_eq!(p2, 0x0b);
}
+
+#[test]
+fn encode_decode_option_uint8_some() {
+ test_impl::<Option<u8>>(
+ 0xdeadbeef,
+ Some(44),
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000001
+ 000000000000000000000000000000000000000000000000000000000000002c
+ "
+ ),
+ );
+}
+
+#[test]
+fn encode_decode_option_uint8_none() {
+ test_impl::<Option<u8>>(
+ 0xdeadbeef,
+ None,
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
+
+#[test]
+fn encode_decode_option_string_some() {
+ test_impl::<Option<String>>(
+ 0xdeadbeef,
+ Some("some string".to_string()),
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 0000000000000000000000000000000000000000000000000000000000000001
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 000000000000000000000000000000000000000000000000000000000000000b
+ 736f6d6520737472696e67000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
+
+#[test]
+fn encode_decode_option_string_none() {
+ test_impl::<Option<String>>(
+ 0xdeadbeef,
+ None,
+ &hex!(
+ "
+ deadbeef
+ 0000000000000000000000000000000000000000000000000000000000000020
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000040
+ 0000000000000000000000000000000000000000000000000000000000000000
+ "
+ ),
+ );
+}
crates/evm-coder/src/solidity/impls.rsdiffbeforeafterboth--- a/crates/evm-coder/src/solidity/impls.rs
+++ b/crates/evm-coder/src/solidity/impls.rs
@@ -121,3 +121,59 @@
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}
+
+//----- impls for Option -----
+impl<T: SolidityTypeName + 'static> SolidityTypeName for Option<T> {
+ 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>())?;
+ bool::solidity_default(writer, tc)?;
+ write!(writer, ", ");
+ T::solidity_default(writer, tc)?;
+ write!(writer, ")")
+ }
+}
+
+impl<T: SolidityTypeName> super::SolidityStructTy for Option<T> {
+ fn generate_solidity_interface(tc: &TypeCollector) -> String {
+ let mut solidity_name = "Option".to_string();
+ let mut generic_name = String::new();
+ T::solidity_name(&mut generic_name, tc);
+ solidity_name.push(
+ generic_name
+ .chars()
+ .next()
+ .expect("Generic name is empty")
+ .to_ascii_uppercase(),
+ );
+ solidity_name.push_str(&generic_name[1..]);
+
+ let interface = super::SolidityStruct {
+ docs: &[" Optional value"],
+ name: solidity_name.as_str(),
+ fields: (
+ super::SolidityStructField::<bool> {
+ docs: &[" Shows the status of accessibility of value"],
+ name: "status",
+ ty: ::core::marker::PhantomData,
+ },
+ super::SolidityStructField::<T> {
+ docs: &[" Actual value if `status` is true"],
+ name: "value",
+ ty: ::core::marker::PhantomData,
+ },
+ ),
+ };
+
+ let mut out = String::new();
+ let _ = interface.format(&mut out, tc);
+ tc.collect(out);
+
+ solidity_name.to_string()
+ }
+}
crates/evm-coder/src/solidity/mod.rsdiffbeforeafterboth--- a/crates/evm-coder/src/solidity/mod.rs
+++ b/crates/evm-coder/src/solidity/mod.rs
@@ -456,13 +456,13 @@
Ok(())
}
}
-pub struct SolidityStruct<F> {
- pub docs: &'static [&'static str],
+pub struct SolidityStruct<'a, F> {
+ pub docs: &'a [&'a str],
// pub generics:
- pub name: &'static str,
+ pub name: &'a str,
pub fields: F,
}
-impl<F> SolidityStruct<F>
+impl<F> SolidityStruct<'_, F>
where
F: SolidityItems,
{
pallets/common/src/erc.rsdiffbeforeafterboth--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -284,6 +284,11 @@
fn collection_limits(&self) -> Result<Vec<eth::CollectionLimit>> {
let limits = &self.collection.limits;
+ let convert_value_from_bool = |ob: Option<bool>| match ob {
+ Some(b) => Some(b as u32),
+ None => None,
+ };
+
Ok(vec![
eth::CollectionLimit::new(
eth::CollectionLimitField::AccountTokenOwnership,
@@ -297,15 +302,15 @@
.sponsored_data_rate_limit
.and_then(|limit| {
if let SponsoringRateLimit::Blocks(blocks) = limit {
- Some(eth::CollectionLimit::new::<u32>(
+ Some(eth::CollectionLimit::new(
eth::CollectionLimitField::SponsoredDataRateLimit,
- blocks,
+ Some(blocks),
))
} else {
None
}
})
- .unwrap_or(eth::CollectionLimit::new::<u32>(
+ .unwrap_or(eth::CollectionLimit::new(
eth::CollectionLimitField::SponsoredDataRateLimit,
Default::default(),
)),
@@ -320,15 +325,15 @@
),
eth::CollectionLimit::new(
eth::CollectionLimitField::OwnerCanTransfer,
- limits.owner_can_transfer,
+ convert_value_from_bool(limits.owner_can_transfer),
),
eth::CollectionLimit::new(
eth::CollectionLimitField::OwnerCanDestroy,
- limits.owner_can_destroy,
+ convert_value_from_bool(limits.owner_can_destroy),
),
eth::CollectionLimit::new(
eth::CollectionLimitField::TransferEnabled,
- limits.transfers_enabled,
+ convert_value_from_bool(limits.transfers_enabled),
),
])
}
pallets/common/src/eth.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//! The module contains a number of functions for converting and checking ethereum identifiers.1819use alloc::format;20use sp_std::{vec, vec::Vec};21use evm_coder::{22 AbiCoder,23 types::{uint256, address},24};25pub use pallet_evm::{Config, account::CrossAccountId};26use sp_core::H160;27use up_data_structs::CollectionId;2829// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 130// TODO: Unhardcode prefix31const ETH_COLLECTION_PREFIX: [u8; 16] = [32 0x17, 0xc4, 0xe6, 0x45, 0x3c, 0xc4, 0x9a, 0xaa, 0xae, 0xac, 0xa8, 0x94, 0xe6, 0xd9, 0x68, 0x3e,33];3435/// Maps the ethereum address of the collection in substrate.36pub fn map_eth_to_id(eth: &H160) -> Option<CollectionId> {37 if eth[0..16] != ETH_COLLECTION_PREFIX {38 return None;39 }40 let mut id_bytes = [0; 4];41 id_bytes.copy_from_slice(ð[16..20]);42 Some(CollectionId(u32::from_be_bytes(id_bytes)))43}4445/// Maps the substrate collection id in ethereum.46pub fn collection_id_to_address(id: CollectionId) -> H160 {47 let mut out = [0; 20];48 out[0..16].copy_from_slice(Ð_COLLECTION_PREFIX);49 out[16..20].copy_from_slice(&u32::to_be_bytes(id.0));50 H160(out)51}5253/// Check if the ethereum address is a collection.54pub fn is_collection(address: &H160) -> bool {55 address[0..16] == ETH_COLLECTION_PREFIX56}5758/// Convert `uint256` to `CrossAccountId`.59pub fn convert_uint256_to_cross_account<T: Config>(from: uint256) -> T::CrossAccountId60where61 T::AccountId: From<[u8; 32]>,62{63 let mut new_admin_arr = [0_u8; 32];64 from.to_big_endian(&mut new_admin_arr);65 let account_id = T::AccountId::from(new_admin_arr);66 T::CrossAccountId::from_sub(account_id)67}6869/// Ethereum representation of Optional value with uint256.70#[derive(Debug, Default, AbiCoder)]71pub struct OptionUint {72 status: bool,73 value: uint256,74}7576impl From<u32> for OptionUint {77 fn from(value: u32) -> Self {78 Self {79 status: true,80 value: uint256::from(value),81 }82 }83}8485impl From<Option<u32>> for OptionUint {86 fn from(value: Option<u32>) -> Self {87 match value {88 Some(value) => Self {89 status: true,90 value: value.into(),91 },92 None => Self {93 status: false,94 value: Default::default(),95 },96 }97 }98}99100impl From<bool> for OptionUint {101 fn from(value: bool) -> Self {102 Self {103 status: true,104 value: if value {105 uint256::from(1)106 } else {107 Default::default()108 },109 }110 }111}112113impl From<Option<bool>> for OptionUint {114 fn from(value: Option<bool>) -> Self {115 match value {116 Some(value) => Self::from(value),117 None => Self {118 status: false,119 value: Default::default(),120 },121 }122 }123}124125/// Ethereum representation of Optional value with CrossAddress.126#[derive(Debug, Default, AbiCoder)]127pub struct OptionCrossAddress {128 /// Whether or not this CrossAdress is valid and has meaning.129 pub status: bool,130 /// The underlying CrossAddress value. If the status is false, can be set to whatever.131 pub value: CrossAddress,132}133134/// Cross account struct135#[derive(Debug, Default, AbiCoder)]136pub struct CrossAddress {137 pub(crate) eth: address,138 pub(crate) sub: uint256,139}140141impl CrossAddress {142 /// Converts `CrossAccountId` to [`CrossAddress`] to be correctly usable with Ethereum.143 pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self144 where145 T: pallet_evm::Config,146 T::AccountId: AsRef<[u8; 32]>,147 {148 if cross_account_id.is_canonical_substrate() {149 Self::from_sub::<T>(cross_account_id.as_sub())150 } else {151 Self {152 eth: *cross_account_id.as_eth(),153 sub: Default::default(),154 }155 }156 }157 /// Creates [`CrossAddress`] from Substrate account.158 pub fn from_sub<T>(account_id: &T::AccountId) -> Self159 where160 T: pallet_evm::Config,161 T::AccountId: AsRef<[u8; 32]>,162 {163 Self {164 eth: Default::default(),165 sub: uint256::from_big_endian(account_id.as_ref()),166 }167 }168 /// Converts [`CrossAddress`] to `CrossAccountId`.169 pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>170 where171 T: pallet_evm::Config,172 T::AccountId: From<[u8; 32]>,173 {174 if self.eth == Default::default() && self.sub == Default::default() {175 Err("All fields of cross account is zeroed".into())176 } else if self.eth == Default::default() {177 Ok(convert_uint256_to_cross_account::<T>(self.sub))178 } else if self.sub == Default::default() {179 Ok(T::CrossAccountId::from_eth(self.eth))180 } else {181 Err("All fields of cross account is non zeroed".into())182 }183 }184}185186/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).187#[derive(Debug, Default, AbiCoder)]188pub struct Property {189 key: evm_coder::types::string,190 value: evm_coder::types::bytes,191}192193impl TryFrom<up_data_structs::Property> for Property {194 type Error = evm_coder::execution::Error;195196 fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {197 let key = evm_coder::types::string::from_utf8(from.key.into())198 .map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;199 let value = evm_coder::types::bytes(from.value.to_vec());200 Ok(Property { key, value })201 }202}203204impl TryInto<up_data_structs::Property> for Property {205 type Error = evm_coder::execution::Error;206207 fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {208 let key = <Vec<u8>>::from(self.key)209 .try_into()210 .map_err(|_| "key too large")?;211212 let value = self.value.0.try_into().map_err(|_| "value too large")?;213214 Ok(up_data_structs::Property { key, value })215 }216}217218/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.219#[derive(Debug, Default, Clone, Copy, AbiCoder)]220#[repr(u8)]221pub enum CollectionLimitField {222 /// How many tokens can a user have on one account.223 #[default]224 AccountTokenOwnership,225226 /// How many bytes of data are available for sponsorship.227 SponsoredDataSize,228229 /// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]230 SponsoredDataRateLimit,231232 /// How many tokens can be mined into this collection.233 TokenLimit,234235 /// Timeouts for transfer sponsoring.236 SponsorTransferTimeout,237238 /// Timeout for sponsoring an approval in passed blocks.239 SponsorApproveTimeout,240241 /// Whether the collection owner of the collection can send tokens (which belong to other users).242 OwnerCanTransfer,243244 /// Can the collection owner burn other people's tokens.245 OwnerCanDestroy,246247 /// Is it possible to send tokens from this collection between users.248 TransferEnabled,249}250251/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.252#[derive(Debug, Default, AbiCoder)]253pub struct CollectionLimit {254 field: CollectionLimitField,255 value: OptionUint,256}257258impl CollectionLimit {259 /// Create [`CollectionLimit`] from field and value.260 pub fn new<T>(field: CollectionLimitField, value: T) -> Self261 where262 OptionUint: From<T>,263 {264 Self {265 field,266 value: value.into(),267 }268 }269 /// Whether the field contains a value.270 pub fn has_value(&self) -> bool {271 self.value.status272 }273}274275impl TryInto<up_data_structs::CollectionLimits> for CollectionLimit {276 type Error = evm_coder::execution::Error;277278 fn try_into(self) -> Result<up_data_structs::CollectionLimits, Self::Error> {279 let value = self.value.value.try_into().map_err(|error| {280 Self::Error::Revert(format!(281 "can't convert value to u32 \"{}\" because: \"{error}\"",282 self.value.value283 ))284 })?;285286 let convert_value_to_bool = || match value {287 0 => Ok(false),288 1 => Ok(true),289 _ => {290 return Err(Self::Error::Revert(format!(291 "can't convert value to boolean \"{value}\""292 )))293 }294 };295296 let mut limits = up_data_structs::CollectionLimits::default();297 match self.field {298 CollectionLimitField::AccountTokenOwnership => {299 limits.account_token_ownership_limit = Some(value);300 }301 CollectionLimitField::SponsoredDataSize => {302 limits.sponsored_data_size = Some(value);303 }304 CollectionLimitField::SponsoredDataRateLimit => {305 limits.sponsored_data_rate_limit =306 Some(up_data_structs::SponsoringRateLimit::Blocks(value));307 }308 CollectionLimitField::TokenLimit => {309 limits.token_limit = Some(value);310 }311 CollectionLimitField::SponsorTransferTimeout => {312 limits.sponsor_transfer_timeout = Some(value);313 }314 CollectionLimitField::SponsorApproveTimeout => {315 limits.sponsor_approve_timeout = Some(value);316 }317 CollectionLimitField::OwnerCanTransfer => {318 limits.owner_can_transfer = Some(convert_value_to_bool()?);319 }320 CollectionLimitField::OwnerCanDestroy => {321 limits.owner_can_destroy = Some(convert_value_to_bool()?);322 }323 CollectionLimitField::TransferEnabled => {324 limits.transfers_enabled = Some(convert_value_to_bool()?);325 }326 };327 Ok(limits)328 }329}330331/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.332#[derive(Default, Debug, Clone, Copy, AbiCoder)]333#[repr(u8)]334pub enum CollectionPermissionField {335 /// Owner of token can nest tokens under it.336 #[default]337 TokenOwner,338339 /// Admin of token collection can nest tokens under token.340 CollectionAdmin,341}342343/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.344#[derive(AbiCoder, Copy, Clone, Default, Debug)]345#[repr(u8)]346pub enum TokenPermissionField {347 /// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]348 #[default]349 Mutable,350351 /// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]352 TokenOwner,353354 /// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]355 CollectionAdmin,356}357358/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.359#[derive(Debug, Default, AbiCoder)]360pub struct PropertyPermission {361 /// TokenPermission field.362 code: TokenPermissionField,363 /// TokenPermission value.364 value: bool,365}366367impl PropertyPermission {368 /// Make vector of [`PropertyPermission`] from [`up_data_structs::PropertyPermission`].369 pub fn into_vec(pp: up_data_structs::PropertyPermission) -> Vec<Self> {370 vec![371 PropertyPermission {372 code: TokenPermissionField::Mutable,373 value: pp.mutable,374 },375 PropertyPermission {376 code: TokenPermissionField::TokenOwner,377 value: pp.token_owner,378 },379 PropertyPermission {380 code: TokenPermissionField::CollectionAdmin,381 value: pp.collection_admin,382 },383 ]384 }385386 /// Make [`up_data_structs::PropertyPermission`] from vector of [`PropertyPermission`].387 pub fn from_vec(permission: Vec<Self>) -> up_data_structs::PropertyPermission {388 let mut token_permission = up_data_structs::PropertyPermission::default();389390 for PropertyPermission { code, value } in permission {391 match code {392 TokenPermissionField::Mutable => token_permission.mutable = value,393 TokenPermissionField::TokenOwner => token_permission.token_owner = value,394 TokenPermissionField::CollectionAdmin => token_permission.collection_admin = value,395 }396 }397 token_permission398 }399}400401/// Ethereum representation of Token Property Permissions.402#[derive(Debug, Default, AbiCoder)]403pub struct TokenPropertyPermission {404 /// Token property key.405 key: evm_coder::types::string,406 /// Token property permissions.407 permissions: Vec<PropertyPermission>,408}409410impl411 From<(412 up_data_structs::PropertyKey,413 up_data_structs::PropertyPermission,414 )> for TokenPropertyPermission415{416 fn from(417 value: (418 up_data_structs::PropertyKey,419 up_data_structs::PropertyPermission,420 ),421 ) -> Self {422 let (key, permission) = value;423 let key = evm_coder::types::string::from_utf8(key.into_inner())424 .expect("Stored key must be valid");425 let permissions = PropertyPermission::into_vec(permission);426 Self { key, permissions }427 }428}429430impl TokenPropertyPermission {431 /// Convert vector of [`TokenPropertyPermission`] into vector of [`up_data_structs::PropertyKeyPermission`].432 pub fn into_property_key_permissions(433 permissions: Vec<TokenPropertyPermission>,434 ) -> evm_coder::execution::Result<Vec<up_data_structs::PropertyKeyPermission>> {435 let mut perms = Vec::new();436437 for TokenPropertyPermission { key, permissions } in permissions {438 let token_permission = PropertyPermission::from_vec(permissions);439440 perms.push(up_data_structs::PropertyKeyPermission {441 key: key.into_bytes().try_into().map_err(|_| "too long key")?,442 permission: token_permission,443 });444 }445 Ok(perms)446 }447}448449/// Nested collections.450#[derive(Debug, Default, AbiCoder)]451pub struct CollectionNesting {452 token_owner: bool,453 ids: Vec<uint256>,454}455456impl CollectionNesting {457 /// Create [`CollectionNesting`].458 pub fn new(token_owner: bool, ids: Vec<uint256>) -> Self {459 Self { token_owner, ids }460 }461}462463/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.464#[derive(Debug, Default, AbiCoder)]465pub struct CollectionNestingPermission {466 field: CollectionPermissionField,467 value: bool,468}469470impl CollectionNestingPermission {471 /// Create [`CollectionNestingPermission`].472 pub fn new(field: CollectionPermissionField, value: bool) -> Self {473 Self { field, value }474 }475}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//! The module contains a number of functions for converting and checking ethereum identifiers.1819use alloc::format;20use sp_std::{vec, vec::Vec};21use evm_coder::{22 AbiCoder,23 types::{uint256, address},24};25pub use pallet_evm::{Config, account::CrossAccountId};26use sp_core::H160;27use up_data_structs::CollectionId;2829// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 130// TODO: Unhardcode prefix31const ETH_COLLECTION_PREFIX: [u8; 16] = [32 0x17, 0xc4, 0xe6, 0x45, 0x3c, 0xc4, 0x9a, 0xaa, 0xae, 0xac, 0xa8, 0x94, 0xe6, 0xd9, 0x68, 0x3e,33];3435/// Maps the ethereum address of the collection in substrate.36pub fn map_eth_to_id(eth: &H160) -> Option<CollectionId> {37 if eth[0..16] != ETH_COLLECTION_PREFIX {38 return None;39 }40 let mut id_bytes = [0; 4];41 id_bytes.copy_from_slice(ð[16..20]);42 Some(CollectionId(u32::from_be_bytes(id_bytes)))43}4445/// Maps the substrate collection id in ethereum.46pub fn collection_id_to_address(id: CollectionId) -> H160 {47 let mut out = [0; 20];48 out[0..16].copy_from_slice(Ð_COLLECTION_PREFIX);49 out[16..20].copy_from_slice(&u32::to_be_bytes(id.0));50 H160(out)51}5253/// Check if the ethereum address is a collection.54pub fn is_collection(address: &H160) -> bool {55 address[0..16] == ETH_COLLECTION_PREFIX56}5758/// Convert `uint256` to `CrossAccountId`.59pub fn convert_uint256_to_cross_account<T: Config>(from: uint256) -> T::CrossAccountId60where61 T::AccountId: From<[u8; 32]>,62{63 let mut new_admin_arr = [0_u8; 32];64 from.to_big_endian(&mut new_admin_arr);65 let account_id = T::AccountId::from(new_admin_arr);66 T::CrossAccountId::from_sub(account_id)67}6869/// Cross account struct70#[derive(Debug, Default, AbiCoder)]71pub struct CrossAddress {72 pub(crate) eth: address,73 pub(crate) sub: uint256,74}7576impl CrossAddress {77 /// Converts `CrossAccountId` to [`CrossAddress`] to be correctly usable with Ethereum.78 pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self79 where80 T: pallet_evm::Config,81 T::AccountId: AsRef<[u8; 32]>,82 {83 if cross_account_id.is_canonical_substrate() {84 Self::from_sub::<T>(cross_account_id.as_sub())85 } else {86 Self {87 eth: *cross_account_id.as_eth(),88 sub: Default::default(),89 }90 }91 }92 /// Creates [`CrossAddress`] from Substrate account.93 pub fn from_sub<T>(account_id: &T::AccountId) -> Self94 where95 T: pallet_evm::Config,96 T::AccountId: AsRef<[u8; 32]>,97 {98 Self {99 eth: Default::default(),100 sub: uint256::from_big_endian(account_id.as_ref()),101 }102 }103 /// Converts [`CrossAddress`] to `CrossAccountId`.104 pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>105 where106 T: pallet_evm::Config,107 T::AccountId: From<[u8; 32]>,108 {109 if self.eth == Default::default() && self.sub == Default::default() {110 Err("All fields of cross account is zeroed".into())111 } else if self.eth == Default::default() {112 Ok(convert_uint256_to_cross_account::<T>(self.sub))113 } else if self.sub == Default::default() {114 Ok(T::CrossAccountId::from_eth(self.eth))115 } else {116 Err("All fields of cross account is non zeroed".into())117 }118 }119}120121/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).122#[derive(Debug, Default, AbiCoder)]123pub struct Property {124 key: evm_coder::types::string,125 value: evm_coder::types::bytes,126}127128impl TryFrom<up_data_structs::Property> for Property {129 type Error = evm_coder::execution::Error;130131 fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {132 let key = evm_coder::types::string::from_utf8(from.key.into())133 .map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;134 let value = evm_coder::types::bytes(from.value.to_vec());135 Ok(Property { key, value })136 }137}138139impl TryInto<up_data_structs::Property> for Property {140 type Error = evm_coder::execution::Error;141142 fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {143 let key = <Vec<u8>>::from(self.key)144 .try_into()145 .map_err(|_| "key too large")?;146147 let value = self.value.0.try_into().map_err(|_| "value too large")?;148149 Ok(up_data_structs::Property { key, value })150 }151}152153/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.154#[derive(Debug, Default, Clone, Copy, AbiCoder)]155#[repr(u8)]156pub enum CollectionLimitField {157 /// How many tokens can a user have on one account.158 #[default]159 AccountTokenOwnership,160161 /// How many bytes of data are available for sponsorship.162 SponsoredDataSize,163164 /// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]165 SponsoredDataRateLimit,166167 /// How many tokens can be mined into this collection.168 TokenLimit,169170 /// Timeouts for transfer sponsoring.171 SponsorTransferTimeout,172173 /// Timeout for sponsoring an approval in passed blocks.174 SponsorApproveTimeout,175176 /// Whether the collection owner of the collection can send tokens (which belong to other users).177 OwnerCanTransfer,178179 /// Can the collection owner burn other people's tokens.180 OwnerCanDestroy,181182 /// Is it possible to send tokens from this collection between users.183 TransferEnabled,184}185186/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.187#[derive(Debug, Default, AbiCoder)]188pub struct CollectionLimit {189 field: CollectionLimitField,190 value: Option<uint256>,191}192193impl CollectionLimit {194 /// Create [`CollectionLimit`] from field and value.195 pub fn new(field: CollectionLimitField, value: Option<u32>) -> Self {196 Self {197 field,198 value: match value {199 Some(value) => Some(value.into()),200 None => None,201 },202 }203 }204 /// Whether the field contains a value.205 pub fn has_value(&self) -> bool {206 self.value.is_some()207 }208}209210impl TryInto<up_data_structs::CollectionLimits> for CollectionLimit {211 type Error = evm_coder::execution::Error;212213 fn try_into(self) -> Result<up_data_structs::CollectionLimits, Self::Error> {214 let value = self215 .value216 .ok_or::<Self::Error>("can't convert `None` value to boolean".into())?;217 let value = Some(value.try_into().map_err(|error| {218 Self::Error::Revert(format!(219 "can't convert value to u32 \"{}\" because: \"{error}\"",220 value221 ))222 })?);223224 let convert_value_to_bool = || match value {225 Some(value) => match value {226 0 => Ok(Some(false)),227 1 => Ok(Some(true)),228 _ => {229 return Err(Self::Error::Revert(format!(230 "can't convert value to boolean \"{value}\""231 )))232 }233 },234 None => Ok(None),235 };236237 let mut limits = up_data_structs::CollectionLimits::default();238 match self.field {239 CollectionLimitField::AccountTokenOwnership => {240 limits.account_token_ownership_limit = value;241 }242 CollectionLimitField::SponsoredDataSize => {243 limits.sponsored_data_size = value;244 }245 CollectionLimitField::SponsoredDataRateLimit => {246 limits.sponsored_data_rate_limit = match value {247 Some(value) => Some(up_data_structs::SponsoringRateLimit::Blocks(value)),248 None => None,249 };250 }251 CollectionLimitField::TokenLimit => {252 limits.token_limit = value;253 }254 CollectionLimitField::SponsorTransferTimeout => {255 limits.sponsor_transfer_timeout = value;256 }257 CollectionLimitField::SponsorApproveTimeout => {258 limits.sponsor_approve_timeout = value;259 }260 CollectionLimitField::OwnerCanTransfer => {261 limits.owner_can_transfer = convert_value_to_bool()?;262 }263 CollectionLimitField::OwnerCanDestroy => {264 limits.owner_can_destroy = convert_value_to_bool()?;265 }266 CollectionLimitField::TransferEnabled => {267 limits.transfers_enabled = convert_value_to_bool()?;268 }269 };270 Ok(limits)271 }272}273274/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.275#[derive(Default, Debug, Clone, Copy, AbiCoder)]276#[repr(u8)]277pub enum CollectionPermissionField {278 /// Owner of token can nest tokens under it.279 #[default]280 TokenOwner,281282 /// Admin of token collection can nest tokens under token.283 CollectionAdmin,284}285286/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.287#[derive(AbiCoder, Copy, Clone, Default, Debug)]288#[repr(u8)]289pub enum TokenPermissionField {290 /// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]291 #[default]292 Mutable,293294 /// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]295 TokenOwner,296297 /// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]298 CollectionAdmin,299}300301/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.302#[derive(Debug, Default, AbiCoder)]303pub struct PropertyPermission {304 /// TokenPermission field.305 code: TokenPermissionField,306 /// TokenPermission value.307 value: bool,308}309310impl PropertyPermission {311 /// Make vector of [`PropertyPermission`] from [`up_data_structs::PropertyPermission`].312 pub fn into_vec(pp: up_data_structs::PropertyPermission) -> Vec<Self> {313 vec![314 PropertyPermission {315 code: TokenPermissionField::Mutable,316 value: pp.mutable,317 },318 PropertyPermission {319 code: TokenPermissionField::TokenOwner,320 value: pp.token_owner,321 },322 PropertyPermission {323 code: TokenPermissionField::CollectionAdmin,324 value: pp.collection_admin,325 },326 ]327 }328329 /// Make [`up_data_structs::PropertyPermission`] from vector of [`PropertyPermission`].330 pub fn from_vec(permission: Vec<Self>) -> up_data_structs::PropertyPermission {331 let mut token_permission = up_data_structs::PropertyPermission::default();332333 for PropertyPermission { code, value } in permission {334 match code {335 TokenPermissionField::Mutable => token_permission.mutable = value,336 TokenPermissionField::TokenOwner => token_permission.token_owner = value,337 TokenPermissionField::CollectionAdmin => token_permission.collection_admin = value,338 }339 }340 token_permission341 }342}343344/// Ethereum representation of Token Property Permissions.345#[derive(Debug, Default, AbiCoder)]346pub struct TokenPropertyPermission {347 /// Token property key.348 key: evm_coder::types::string,349 /// Token property permissions.350 permissions: Vec<PropertyPermission>,351}352353impl354 From<(355 up_data_structs::PropertyKey,356 up_data_structs::PropertyPermission,357 )> for TokenPropertyPermission358{359 fn from(360 value: (361 up_data_structs::PropertyKey,362 up_data_structs::PropertyPermission,363 ),364 ) -> Self {365 let (key, permission) = value;366 let key = evm_coder::types::string::from_utf8(key.into_inner())367 .expect("Stored key must be valid");368 let permissions = PropertyPermission::into_vec(permission);369 Self { key, permissions }370 }371}372373impl TokenPropertyPermission {374 /// Convert vector of [`TokenPropertyPermission`] into vector of [`up_data_structs::PropertyKeyPermission`].375 pub fn into_property_key_permissions(376 permissions: Vec<TokenPropertyPermission>,377 ) -> evm_coder::execution::Result<Vec<up_data_structs::PropertyKeyPermission>> {378 let mut perms = Vec::new();379380 for TokenPropertyPermission { key, permissions } in permissions {381 let token_permission = PropertyPermission::from_vec(permissions);382383 perms.push(up_data_structs::PropertyKeyPermission {384 key: key.into_bytes().try_into().map_err(|_| "too long key")?,385 permission: token_permission,386 });387 }388 Ok(perms)389 }390}391392/// Nested collections.393#[derive(Debug, Default, AbiCoder)]394pub struct CollectionNesting {395 token_owner: bool,396 ids: Vec<uint256>,397}398399impl CollectionNesting {400 /// Create [`CollectionNesting`].401 pub fn new(token_owner: bool, ids: Vec<uint256>) -> Self {402 Self { token_owner, ids }403 }404}405406/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.407#[derive(Debug, Default, AbiCoder)]408pub struct CollectionNestingPermission {409 field: CollectionPermissionField,410 value: bool,411}412413impl CollectionNestingPermission {414 /// Create [`CollectionNestingPermission`].415 pub fn new(field: CollectionPermissionField, value: bool) -> Self {416 Self { field, value }417 }418}pallets/evm-contract-helpers/src/eth.rsdiffbeforeafterboth--- a/pallets/evm-contract-helpers/src/eth.rs
+++ b/pallets/evm-contract-helpers/src/eth.rs
@@ -175,16 +175,10 @@
///
/// @param contractAddress The contract for which a sponsor is requested.
/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
- fn sponsor(&self, contract_address: address) -> Result<eth::OptionCrossAddress> {
+ fn sponsor(&self, contract_address: address) -> Result<Option<eth::CrossAddress>> {
Ok(match Pallet::<T>::get_sponsor(contract_address) {
- Some(ref value) => eth::OptionCrossAddress {
- status: true,
- value: eth::CrossAddress::from_sub_cross_account::<T>(value),
- },
- None => eth::OptionCrossAddress {
- status: false,
- value: Default::default(),
- },
+ Some(ref value) => Some(eth::CrossAddress::from_sub_cross_account::<T>(value)),
+ None => None,
})
}
pallets/evm-contract-helpers/src/stubs/ContractHelpers.rawdiffbeforeafterbothbinary blob — no preview
pallets/evm-contract-helpers/src/stubs/ContractHelpers.soldiffbeforeafterboth--- a/pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol
+++ b/pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol
@@ -281,10 +281,10 @@
uint256 sub;
}
-/// Ethereum representation of Optional value with CrossAddress.
+/// Optional value
struct OptionCrossAddress {
- /// Whether or not this CrossAdress is valid and has meaning.
+ /// Shows the status of accessibility of value
bool status;
- /// The underlying CrossAddress value. If the status is false, can be set to whatever.
+ /// Actual value if `status` is true
CrossAddress value;
}
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
@@ -466,12 +466,14 @@
/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.
struct CollectionLimit {
CollectionLimitField field;
- OptionUint value;
+ OptionUint256 value;
}
-/// Ethereum representation of Optional value with uint256.
-struct OptionUint {
+/// Optional value
+struct OptionUint256 {
+ /// Shows the status of accessibility of value
bool status;
+ /// Actual value if `status` is true
uint256 value;
}
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
@@ -608,12 +608,14 @@
/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.
struct CollectionLimit {
CollectionLimitField field;
- OptionUint value;
+ OptionUint256 value;
}
-/// Ethereum representation of Optional value with uint256.
-struct OptionUint {
+/// Optional value
+struct OptionUint256 {
+ /// Shows the status of accessibility of value
bool status;
+ /// Actual value if `status` is true
uint256 value;
}
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
@@ -608,12 +608,14 @@
/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.
struct CollectionLimit {
CollectionLimitField field;
- OptionUint value;
+ OptionUint256 value;
}
-/// Ethereum representation of Optional value with uint256.
-struct OptionUint {
+/// Optional value
+struct OptionUint256 {
+ /// Shows the status of accessibility of value
bool status;
+ /// Actual value if `status` is true
uint256 value;
}
runtime/common/identity.rsdiffbeforeafterboth--- a/runtime/common/identity.rs
+++ b/runtime/common/identity.rs
@@ -24,9 +24,6 @@
transaction_validity::{TransactionValidity, ValidTransaction, TransactionValidityError},
};
-#[cfg(feature = "collator-selection")]
-use sp_runtime::transaction_validity::InvalidTransaction;
-
#[derive(Debug, Encode, Decode, PartialEq, Eq, Clone, TypeInfo)]
pub struct DisableIdentityCalls;
tests/src/eth/abi/fungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/fungible.json
+++ b/tests/src/eth/abi/fungible.json
@@ -222,7 +222,7 @@
{ "internalType": "bool", "name": "status", "type": "bool" },
{ "internalType": "uint256", "name": "value", "type": "uint256" }
],
- "internalType": "struct OptionUint",
+ "internalType": "struct OptionUint256",
"name": "value",
"type": "tuple"
}
@@ -508,7 +508,7 @@
{ "internalType": "bool", "name": "status", "type": "bool" },
{ "internalType": "uint256", "name": "value", "type": "uint256" }
],
- "internalType": "struct OptionUint",
+ "internalType": "struct OptionUint256",
"name": "value",
"type": "tuple"
}
tests/src/eth/abi/fungibleDeprecated.jsondiffbeforeafterboth--- a/tests/src/eth/abi/fungibleDeprecated.json
+++ b/tests/src/eth/abi/fungibleDeprecated.json
@@ -88,14 +88,5 @@
"outputs": [],
"stateMutability": "nonpayable",
"type": "function"
- },
- {
- "inputs": [
- { "internalType": "address", "name": "newOwner", "type": "address" }
- ],
- "name": "changeCollectionOwner",
- "outputs": [],
- "stateMutability": "nonpayable",
- "type": "function"
}
]
tests/src/eth/abi/nonFungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/nonFungible.json
+++ b/tests/src/eth/abi/nonFungible.json
@@ -51,12 +51,6 @@
},
{
"anonymous": false,
- "inputs": [],
- "name": "MintingFinished",
- "type": "event"
- },
- {
- "anonymous": false,
"inputs": [
{
"indexed": true,
@@ -252,7 +246,7 @@
{ "internalType": "bool", "name": "status", "type": "bool" },
{ "internalType": "uint256", "name": "value", "type": "uint256" }
],
- "internalType": "struct OptionUint",
+ "internalType": "struct OptionUint256",
"name": "value",
"type": "tuple"
}
@@ -420,13 +414,6 @@
"name": "description",
"outputs": [{ "internalType": "string", "name": "", "type": "string" }],
"stateMutability": "view",
- "type": "function"
- },
- {
- "inputs": [],
- "name": "finishMinting",
- "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
- "stateMutability": "nonpayable",
"type": "function"
},
{
@@ -513,13 +500,6 @@
"name": "mintWithTokenURI",
"outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
"stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "inputs": [],
- "name": "mintingFinished",
- "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
- "stateMutability": "view",
"type": "function"
},
{
@@ -670,7 +650,7 @@
{ "internalType": "bool", "name": "status", "type": "bool" },
{ "internalType": "uint256", "name": "value", "type": "uint256" }
],
- "internalType": "struct OptionUint",
+ "internalType": "struct OptionUint256",
"name": "value",
"type": "tuple"
}
tests/src/eth/abi/reFungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/reFungible.json
+++ b/tests/src/eth/abi/reFungible.json
@@ -51,12 +51,6 @@
},
{
"anonymous": false,
- "inputs": [],
- "name": "MintingFinished",
- "type": "event"
- },
- {
- "anonymous": false,
"inputs": [
{
"indexed": true,
@@ -234,7 +228,7 @@
{ "internalType": "bool", "name": "status", "type": "bool" },
{ "internalType": "uint256", "name": "value", "type": "uint256" }
],
- "internalType": "struct OptionUint",
+ "internalType": "struct OptionUint256",
"name": "value",
"type": "tuple"
}
@@ -402,13 +396,6 @@
"name": "description",
"outputs": [{ "internalType": "string", "name": "", "type": "string" }],
"stateMutability": "view",
- "type": "function"
- },
- {
- "inputs": [],
- "name": "finishMinting",
- "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
- "stateMutability": "nonpayable",
"type": "function"
},
{
@@ -495,13 +482,6 @@
"name": "mintWithTokenURI",
"outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
"stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "inputs": [],
- "name": "mintingFinished",
- "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
- "stateMutability": "view",
"type": "function"
},
{
@@ -652,7 +632,7 @@
{ "internalType": "bool", "name": "status", "type": "bool" },
{ "internalType": "uint256", "name": "value", "type": "uint256" }
],
- "internalType": "struct OptionUint",
+ "internalType": "struct OptionUint256",
"name": "value",
"type": "tuple"
}
tests/src/eth/abi/reFungibleDeprecated.jsondiffbeforeafterboth--- a/tests/src/eth/abi/reFungibleDeprecated.json
+++ b/tests/src/eth/abi/reFungibleDeprecated.json
@@ -82,6 +82,17 @@
},
{
"inputs": [
+ { "internalType": "uint256", "name": "tokenId", "type": "uint256" },
+ { "internalType": "string", "name": "key", "type": "string" },
+ { "internalType": "bytes", "name": "value", "type": "bytes" }
+ ],
+ "name": "setProperty",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
{ "internalType": "address", "name": "newOwner", "type": "address" }
],
"name": "changeCollectionOwner",
tests/src/eth/abi/reFungibleToken.jsondiffbeforeafterboth--- a/tests/src/eth/abi/reFungibleToken.json
+++ b/tests/src/eth/abi/reFungibleToken.json
@@ -98,16 +98,6 @@
},
{
"inputs": [
- { "internalType": "address", "name": "from", "type": "address" },
- { "internalType": "uint256", "name": "amount", "type": "uint256" }
- ],
- "name": "burnFrom",
- "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "inputs": [
{
"components": [
{ "internalType": "address", "name": "eth", "type": "address" },
tests/src/eth/abi/reFungibleTokenDeprecated.jsondiffbeforeafterboth--- /dev/null
+++ b/tests/src/eth/abi/reFungibleTokenDeprecated.json
@@ -0,0 +1,12 @@
+[
+ {
+ "inputs": [
+ { "internalType": "address", "name": "from", "type": "address" },
+ { "internalType": "uint256", "name": "amount", "type": "uint256" }
+ ],
+ "name": "burnFrom",
+ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ }
+]
tests/src/eth/api/ContractHelpers.soldiffbeforeafterboth--- a/tests/src/eth/api/ContractHelpers.sol
+++ b/tests/src/eth/api/ContractHelpers.sol
@@ -181,11 +181,11 @@
Generous
}
-/// Ethereum representation of Optional value with CrossAddress.
+/// Optional value
struct OptionCrossAddress {
- /// Whether or not this CrossAdress is valid and has meaning.
+ /// Shows the status of accessibility of value
bool status;
- /// The underlying CrossAddress value. If the status is false, can be set to whatever.
+ /// Actual value if `status` is true
CrossAddress value;
}
tests/src/eth/api/UniqueFungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -308,12 +308,14 @@
/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.
struct CollectionLimit {
CollectionLimitField field;
- OptionUint value;
+ OptionUint256 value;
}
-/// Ethereum representation of Optional value with uint256.
-struct OptionUint {
+/// Optional value
+struct OptionUint256 {
+ /// Shows the status of accessibility of value
bool status;
+ /// Actual value if `status` is true
uint256 value;
}
tests/src/eth/api/UniqueNFT.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -408,12 +408,14 @@
/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.
struct CollectionLimit {
CollectionLimitField field;
- OptionUint value;
+ OptionUint256 value;
}
-/// Ethereum representation of Optional value with uint256.
-struct OptionUint {
+/// Optional value
+struct OptionUint256 {
+ /// Shows the status of accessibility of value
bool status;
+ /// Actual value if `status` is true
uint256 value;
}
tests/src/eth/api/UniqueRefungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueRefungible.sol
+++ b/tests/src/eth/api/UniqueRefungible.sol
@@ -408,12 +408,14 @@
/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.
struct CollectionLimit {
CollectionLimitField field;
- OptionUint value;
+ OptionUint256 value;
}
-/// Ethereum representation of Optional value with uint256.
-struct OptionUint {
+/// Optional value
+struct OptionUint256 {
+ /// Shows the status of accessibility of value
bool status;
+ /// Actual value if `status` is true
uint256 value;
}
tests/src/eth/reFungible.test.tsdiffbeforeafterboth--- a/tests/src/eth/reFungible.test.ts
+++ b/tests/src/eth/reFungible.test.ts
@@ -213,7 +213,7 @@
const address = helper.ethAddress.fromCollectionId(collection.collectionId);
const contract = await helper.ethNativeContract.collection(address, 'rft');
- const rftToken = await helper.ethNativeContract.rftTokenById(token.collectionId, token.tokenId, owner);
+ const rftToken = await helper.ethNativeContract.rftTokenById(token.collectionId, token.tokenId, owner, true);
{
await rftToken.methods.approve(operator, 15n).send({from: owner});
tests/src/eth/reFungibleToken.test.tsdiffbeforeafterboth--- a/tests/src/eth/reFungibleToken.test.ts
+++ b/tests/src/eth/reFungibleToken.test.ts
@@ -413,7 +413,7 @@
const result = await contract.methods.mint(caller).send();
const tokenId = result.events.Transfer.returnValues.tokenId;
const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);
- const tokenContract = await helper.ethNativeContract.rftToken(tokenAddress, caller);
+ const tokenContract = await helper.ethNativeContract.rftToken(tokenAddress, caller, true);
await tokenContract.methods.repartition(2).send();
await tokenContract.methods.transfer(receiver, 1).send();
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
@@ -29,6 +29,7 @@
import refungibleAbi from '../../abi/reFungible.json';
import refungibleDeprecatedAbi from '../../abi/reFungibleDeprecated.json';
import refungibleTokenAbi from '../../abi/reFungibleToken.json';
+import refungibleTokenDeprecatedAbi from '../../abi/reFungibleTokenDeprecated.json';
import contractHelpersAbi from '../../abi/contractHelpers.json';
import {ICrossAccountId, TEthereumAccount} from '../../../util/playgrounds/types';
import {TCollectionMode} from '../../../util/playgrounds/types';
@@ -187,17 +188,18 @@
return this.collection(this.helper.ethAddress.fromCollectionId(collectionId), mode, caller, mergeDeprecated);
}
- async rftToken(address: string, caller?: string) {
+ async rftToken(address: string, caller?: string, mergeDeprecated = false) {
const web3 = this.helper.getWeb3();
- return unlimitedMoneyHack(new web3.eth.Contract(refungibleTokenAbi as any, address, {
+ const abi = mergeDeprecated ? [...refungibleTokenAbi, ...refungibleTokenDeprecatedAbi] : refungibleTokenAbi;
+ return unlimitedMoneyHack(new web3.eth.Contract(abi as any, address, {
gas: this.helper.eth.DEFAULT_GAS,
gasPrice: await this.getGasPrice(),
...(caller ? {from: caller} : {}),
}));
}
- rftTokenById(collectionId: number, tokenId: number, caller?: string) {
- return this.rftToken(this.helper.ethAddress.fromTokenId(collectionId, tokenId), caller);
+ rftTokenById(collectionId: number, tokenId: number, caller?: string, mergeDeprecated = false) {
+ return this.rftToken(this.helper.ethAddress.fromTokenId(collectionId, tokenId), caller, mergeDeprecated);
}
}