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

--- 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

--- a/crates/evm-coder/src/abi/impls.rs
+++ b/crates/evm-coder/src/abi/impls.rs
@@ -120,42 +120,6 @@
 	}
 }
 
-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);
-	}
-}
-
 impl sealed::CanBePlacedInVec for Property {}
 
 impl AbiType for Property {

93pub use evm_coder_procedural::solidity;93pub use evm_coder_procedural::solidity;
94/// See [`solidity_interface`]94/// See [`solidity_interface`]
95pub use evm_coder_procedural::weight;95pub use evm_coder_procedural::weight;
96pub use evm_coder_procedural::AbiCoder;
96pub use sha3_const;97pub use sha3_const;
9798
98/// Derives [`ToLog`] for enum99/// Derives [`ToLog`] for enum
119120
120	#[cfg(not(feature = "std"))]121	#[cfg(not(feature = "std"))]
121	use alloc::{vec::Vec};122	use alloc::{vec::Vec};
122	use pallet_evm::account::CrossAccountId;
123	use primitive_types::{U256, H160, H256};123	use primitive_types::{U256, H160, H256};
124124
125	pub type address = H160;125	pub type address = H160;
188		}188		}
189	}189	}
190
191	#[derive(Debug, Default)]
192	pub struct EthCrossAccount {
193		pub(crate) eth: address,
194		pub(crate) sub: uint256,
195	}
196
197	impl EthCrossAccount {
198		pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self
199		where
200			T: pallet_evm::Config,
201			T::AccountId: AsRef<[u8; 32]>,
202		{
203			if cross_account_id.is_canonical_substrate() {
204				Self {
205					eth: Default::default(),
206					sub: convert_cross_account_to_uint256::<T>(cross_account_id),
207				}
208			} else {
209				Self {
210					eth: *cross_account_id.as_eth(),
211					sub: Default::default(),
212				}
213			}
214		}
215
216		pub fn into_sub_cross_account<T>(&self) -> crate::execution::Result<T::CrossAccountId>
217		where
218			T: pallet_evm::Config,
219			T::AccountId: From<[u8; 32]>,
220		{
221			if self.eth == Default::default() && self.sub == Default::default() {
222				Err("All fields of cross account is zeroed".into())
223			} else if self.eth == Default::default() {
224				Ok(convert_uint256_to_cross_account::<T>(self.sub))
225			} else if self.sub == Default::default() {
226				Ok(T::CrossAccountId::from_eth(self.eth))
227			} else {
228				Err("All fields of cross account is non zeroed".into())
229			}
230		}
231	}
232
233	/// Convert `CrossAccountId` to `uint256`.
234	pub fn convert_cross_account_to_uint256<T: pallet_evm::Config>(
235		from: &T::CrossAccountId,
236	) -> uint256
237	where
238		T::AccountId: AsRef<[u8; 32]>,
239	{
240		let slice = from.as_sub().as_ref();
241		uint256::from_big_endian(slice)
242	}
243
244	/// Convert `uint256` to `CrossAccountId`.
245	pub fn convert_uint256_to_cross_account<T: pallet_evm::Config>(
246		from: uint256,
247	) -> T::CrossAccountId
248	where
249		T::AccountId: From<[u8; 32]>,
250	{
251		let mut new_admin_arr = [0_u8; 32];
252		from.to_big_endian(&mut new_admin_arr);
253		let account_id = T::AccountId::from(new_admin_arr);
254		T::CrossAccountId::from_sub(account_id)
255	}
256190
257	#[derive(Debug, Default)]191	#[derive(Debug, Default)]
258	pub struct Property {192	pub struct Property {

--- a/crates/evm-coder/src/solidity.rs
+++ b/crates/evm-coder/src/solidity.rs
@@ -145,7 +145,7 @@
 	}
 }
 
-mod sealed {
+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.
@@ -156,7 +156,6 @@
 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> {
@@ -171,61 +170,6 @@
 		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
 	}
 }
 

--- 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.

--- 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,111 @@
 		Err("All fields of cross account is non zeroed".into())
 	}
 }
+
+#[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::account::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::account::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())
+		}
+	}
+}
+
+impl ::evm_coder::solidity::sealed::CanBePlacedInVec for EthCrossAccount {}
+impl ::evm_coder::solidity::SolidityTupleType for EthCrossAccount {
+	fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {
+		let mut collected =
+			Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityTupleType>::len());
+		{
+			let mut out = String::new();
+			<address as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)
+				.expect("no fmt error");
+			collected.push(out);
+		}
+		{
+			let mut out = String::new();
+			<uint256 as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)
+				.expect("no fmt error");
+			collected.push(out);
+		}
+		collected
+	}
+
+	fn len() -> usize {
+		2
+	}
+}
+impl ::evm_coder::solidity::SolidityTypeName for EthCrossAccount {
+	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>())?;
+		address::solidity_default(writer, tc)?;
+		write!(writer, ",")?;
+		uint256::solidity_default(writer, tc)?;
+		write!(writer, ")")
+	}
+}
+
+impl ::evm_coder::solidity::StructCollect for EthCrossAccount {
+	fn name() -> String {
+		"EthCrossAccount".into()
+	}
+
+	fn declaration() -> String {
+		use std::fmt::Write;
+
+		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
+	}
+}

--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -24,12 +24,15 @@
 	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::{

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -36,8 +36,9 @@
 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;

--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -33,6 +33,7 @@
 use pallet_common::{
 	CollectionHandle, CollectionPropertyPermissions,
 	erc::{CommonEvmHandler, CollectionCall, static_property::key},
+	eth::EthCrossAccount,
 	CommonCollectionOperations,
 };
 use pallet_evm::{account::CrossAccountId, PrecompileHandle};