git.delta.rocks / unique-network / refs/commits / 78a995207d2e

--- a/crates/evm-coder/src/abi.rs
+++ b/crates/evm-coder/src/abi.rs
@@ -28,10 +28,13 @@
 	types::{string, self},
 };
 use crate::execution::Result;
-use crate::solidity::SolidityTypeName;
 
 const ABI_ALIGNMENT: usize = 32;
 
+trait TypeHelper<T> {
+	fn is_dynamic() -> bool;
+}
+
 /// View into RLP data, which provides method to read typed items from it
 #[derive(Clone)]
 pub struct AbiReader<'i> {
@@ -330,11 +333,18 @@
 pub trait AbiRead<T> {
 	/// Read item from current position, advanding decoder
 	fn abi_read(&mut self) -> Result<T>;
+
+	/// Size for type aligned to [`ABI_ALIGNMENT`].
 	fn size() -> usize;
 }
 
 macro_rules! impl_abi_readable {
-	($ty:ty, $method:ident) => {
+	($ty:ty, $method:ident, $dynamic:literal) => {
+		impl TypeHelper<$ty> for $ty {
+			fn is_dynamic() -> bool {
+				$dynamic
+			}
+		}
 		impl AbiRead<$ty> for AbiReader<'_> {
 			fn abi_read(&mut self) -> Result<$ty> {
 				self.$method()
@@ -347,16 +357,16 @@
 	};
 }
 
-impl_abi_readable!(u8, uint8);
-impl_abi_readable!(u32, uint32);
-impl_abi_readable!(u64, uint64);
-impl_abi_readable!(u128, uint128);
-impl_abi_readable!(U256, uint256);
-impl_abi_readable!([u8; 4], bytes4);
-impl_abi_readable!(H160, address);
-impl_abi_readable!(Vec<u8>, bytes);
-impl_abi_readable!(bool, bool);
-impl_abi_readable!(string, string);
+impl_abi_readable!(u8, uint8, false);
+impl_abi_readable!(u32, uint32, false);
+impl_abi_readable!(u64, uint64, false);
+impl_abi_readable!(u128, uint128, false);
+impl_abi_readable!(U256, uint256, false);
+impl_abi_readable!([u8; 4], bytes4, false);
+impl_abi_readable!(H160, address, false);
+impl_abi_readable!(Vec<u8>, bytes, true);
+impl_abi_readable!(bool, bool, true);
+impl_abi_readable!(string, string, true);
 
 mod sealed {
 	/// Not all types can be placed in vec, i.e `Vec<u8>` is restricted, `bytes` should be used instead
@@ -389,16 +399,24 @@
 
 macro_rules! impl_tuples {
 	($($ident:ident)+) => {
+		impl<$($ident: TypeHelper<$ident>,)+> TypeHelper<($($ident,)+)> for ($($ident,)+) {
+			fn is_dynamic() -> bool {
+				false
+				$(
+					|| <$ident>::is_dynamic()
+				)*
+			}
+		}
 		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
 		impl<$($ident),+> AbiRead<($($ident,)+)> for AbiReader<'_>
 		where
 			$(
 				Self: AbiRead<$ident>,
 			)+
-			($($ident,)+): SolidityTypeName,
+			($($ident,)+): TypeHelper<($($ident,)+)>,
 		{
 			fn abi_read(&mut self) -> Result<($($ident,)+)> {
-				let size = if <($($ident,)+)>::is_simple() { Some(<Self as AbiRead<($($ident,)+)>>::size()) } else { None };
+				let size = if !<($($ident,)+)>::is_dynamic() { Some(<Self as AbiRead<($($ident,)+)>>::size()) } else { None };
 				let mut subresult = self.subresult(size)?;
 				Ok((
 					$(<Self as AbiRead<$ident>>::abi_read(&mut subresult)?,)+

--- a/crates/evm-coder/src/solidity.rs
+++ b/crates/evm-coder/src/solidity.rs
@@ -192,10 +192,7 @@
 				write!(writer, "{}", tc.collect_tuple::<Self>())
 			}
 			fn is_simple() -> bool {
-				true
-				$(
-					&& <$ident>::is_simple()
-				)*
+				false
 			}
 			#[allow(unused_assignments)]
 			fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {

--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -129,7 +129,7 @@
 	}
 }
 
-#[solidity_interface(name = "ERC20Mintable")]
+#[solidity_interface(name = ERC20Mintable)]
 impl<T: Config> FungibleHandle<T> {
 	/// Mint tokens for `to` account.
 	/// @param to account that will receive minted tokens
@@ -148,7 +148,7 @@
 	}
 }
 
-#[solidity_interface(name = "ERC20UniqueExtensions")]
+#[solidity_interface(name = ERC20UniqueExtensions)]
 impl<T: Config> FungibleHandle<T> {
 	/// Burn tokens from account
 	/// @dev Function that burns an `amount` of the tokens of a given account,

binary blob — no preview

--- a/pallets/fungible/src/stubs/UniqueFungible.sol
+++ b/pallets/fungible/src/stubs/UniqueFungible.sol
@@ -3,13 +3,7 @@
 
 pragma solidity >=0.8.0 <0.9.0;
 
-// Anonymous struct
-struct Tuple0 {
-	address field_0;
-	uint256 field_1;
-}
-
-// Common stubs holder
+/// @dev common stubs holder
 contract Dummy {
 	uint8 dummy;
 	string stub_error = "this contract is implemented in native";
@@ -27,49 +21,8 @@
 	}
 }
 
-// Inline
-contract ERC20Events {
-	event Transfer(address indexed from, address indexed to, uint256 value);
-	event Approval(
-		address indexed owner,
-		address indexed spender,
-		uint256 value
-	);
-}
-
-// Selector: 40c10f19
-contract ERC20Mintable is Dummy, ERC165 {
-	// Selector: mint(address,uint256) 40c10f19
-	function mint(address to, uint256 amount) public returns (bool) {
-		require(false, stub_error);
-		to;
-		amount;
-		dummy = 0;
-		return false;
-	}
-}
-
-// Selector: 63034ac5
-contract ERC20UniqueExtensions is Dummy, ERC165 {
-	// Selector: burnFrom(address,uint256) 79cc6790
-	function burnFrom(address from, uint256 amount) public returns (bool) {
-		require(false, stub_error);
-		from;
-		amount;
-		dummy = 0;
-		return false;
-	}
-
-	// Selector: mintBulk((address,uint256)[]) 1acf2d55
-	function mintBulk(Tuple0[] memory amounts) public returns (bool) {
-		require(false, stub_error);
-		amounts;
-		dummy = 0;
-		return false;
-	}
-}
-
-// Selector: 6cf113cd
+/// @title A contract that allows you to work with collections.
+/// @dev the ERC-165 identifier for this interface is 0xe54be640
 contract Collection is Dummy, ERC165 {
 	/// Set collection property.
 	///
@@ -397,19 +350,51 @@
 	}
 }
 
+/// @dev the ERC-165 identifier for this interface is 0x63034ac5
+contract ERC20UniqueExtensions is Dummy, ERC165 {
+	/// Burn tokens from account
+	/// @dev Function that burns an `amount` of the tokens of a given account,
+	/// deducting from the sender's allowance for said account.
+	/// @param from The account whose tokens will be burnt.
+	/// @param amount The amount that will be burnt.
+	/// @dev EVM selector for this function is: 0x79cc6790,
+	///  or in textual repr: burnFrom(address,uint256)
+	function burnFrom(address from, uint256 amount) public returns (bool) {
+		require(false, stub_error);
+		from;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	/// Mint tokens for multiple accounts.
+	/// @param amounts array of pairs of account address and amount
+	/// @dev EVM selector for this function is: 0x1acf2d55,
+	///  or in textual repr: mintBulk((address,uint256)[])
+	function mintBulk(Tuple6[] memory amounts) public returns (bool) {
+		require(false, stub_error);
+		amounts;
+		dummy = 0;
+		return false;
+	}
+}
+
 /// @dev anonymous struct
 struct Tuple6 {
 	address field_0;
 	uint256 field_1;
 }
 
-/// @dev the ERC-165 identifier for this interface is 0x79cc6790
-contract ERC20UniqueExtensions is Dummy, ERC165 {
-	/// @dev EVM selector for this function is: 0x79cc6790,
-	///  or in textual repr: burnFrom(address,uint256)
-	function burnFrom(address from, uint256 amount) public returns (bool) {
+/// @dev the ERC-165 identifier for this interface is 0x40c10f19
+contract ERC20Mintable is Dummy, ERC165 {
+	/// Mint tokens for `to` account.
+	/// @param to account that will receive minted tokens
+	/// @param amount amount of tokens to mint
+	/// @dev EVM selector for this function is: 0x40c10f19,
+	///  or in textual repr: mint(address,uint256)
+	function mint(address to, uint256 amount) public returns (bool) {
 		require(false, stub_error);
-		from;
+		to;
 		amount;
 		dummy = 0;
 		return false;

33
4pragma solidity >=0.8.0 <0.9.0;4pragma solidity >=0.8.0 <0.9.0;
5
6// Anonymous struct
7struct Tuple0 {
8	address field_0;
9	uint256 field_1;
10}
115
12// Common stubs holder6/// @dev common stubs holder
13interface Dummy {7interface Dummy {
148
15}9}
18	function supportsInterface(bytes4 interfaceID) external view returns (bool);12	function supportsInterface(bytes4 interfaceID) external view returns (bool);
19}13}
2014
21// Inline15/// @title A contract that allows you to work with collections.
22interface ERC20Events {16/// @dev the ERC-165 identifier for this interface is 0xe54be640
23	event Transfer(address indexed from, address indexed to, uint256 value);
24	event Approval(
25		address indexed owner,
26		address indexed spender,
27		uint256 value
28	);
29}
30
31// Selector: 40c10f19
32interface ERC20Mintable is Dummy, ERC165 {
33	// Selector: mint(address,uint256) 40c10f19
34	function mint(address to, uint256 amount) external returns (bool);
35}
36
37// Selector: 63034ac5
38interface ERC20UniqueExtensions is Dummy, ERC165 {
39	// Selector: burnFrom(address,uint256) 79cc6790
40	function burnFrom(address from, uint256 amount) external returns (bool);
41
42	// Selector: mintBulk((address,uint256)[]) 1acf2d55
43	function mintBulk(Tuple0[] memory amounts) external returns (bool);
44}
45
46// Selector: 6cf113cd
47interface Collection is Dummy, ERC165 {17interface Collection is Dummy, ERC165 {
48	/// Set collection property.18	/// Set collection property.
49	///19	///
238	///  or in textual repr: uniqueCollectionType()208	///  or in textual repr: uniqueCollectionType()
239	function uniqueCollectionType() external returns (string memory);209	function uniqueCollectionType() external returns (string memory);
210
211	/// Changes collection owner to another account
212	///
213	/// @dev Owner can be changed only by current owner
214	/// @param newOwner new owner account
215	/// @dev EVM selector for this function is: 0x13af4035,
216	///  or in textual repr: setOwner(address)
217	function setOwner(address newOwner) external;
218
219	/// Changes collection owner to another substrate account
220	///
221	/// @dev Owner can be changed only by current owner
222	/// @param newOwner new owner substrate account
223	/// @dev EVM selector for this function is: 0xb212138f,
224	///  or in textual repr: setOwnerSubstrate(uint256)
225	function setOwnerSubstrate(uint256 newOwner) external;
240}226}
241227
242/// @dev the ERC-165 identifier for this interface is 0x79cc6790228/// @dev the ERC-165 identifier for this interface is 0x63034ac5
243interface ERC20UniqueExtensions is Dummy, ERC165 {229interface ERC20UniqueExtensions is Dummy, ERC165 {
230	/// Burn tokens from account
231	/// @dev Function that burns an `amount` of the tokens of a given account,
232	/// deducting from the sender's allowance for said account.
233	/// @param from The account whose tokens will be burnt.
234	/// @param amount The amount that will be burnt.
244	/// @dev EVM selector for this function is: 0x79cc6790,235	/// @dev EVM selector for this function is: 0x79cc6790,
245	///  or in textual repr: burnFrom(address,uint256)236	///  or in textual repr: burnFrom(address,uint256)
246	function burnFrom(address from, uint256 amount) external returns (bool);237	function burnFrom(address from, uint256 amount) external returns (bool);
238
239	/// Mint tokens for multiple accounts.
240	/// @param amounts array of pairs of account address and amount
241	/// @dev EVM selector for this function is: 0x1acf2d55,
242	///  or in textual repr: mintBulk((address,uint256)[])
243	function mintBulk(Tuple6[] memory amounts) external returns (bool);
247}244}
245
246/// @dev anonymous struct
247struct Tuple6 {
248	address field_0;
249	uint256 field_1;
250}
251
252/// @dev the ERC-165 identifier for this interface is 0x40c10f19
253interface ERC20Mintable is Dummy, ERC165 {
254	/// Mint tokens for `to` account.
255	/// @param to account that will receive minted tokens
256	/// @param amount amount of tokens to mint
257	/// @dev EVM selector for this function is: 0x40c10f19,
258	///  or in textual repr: mint(address,uint256)
259	function mint(address to, uint256 amount) external returns (bool);
260}
248261
249/// @dev inlined interface262/// @dev inlined interface
250interface ERC20Events {263interface ERC20Events {

--- a/tests/src/eth/base.test.ts
+++ b/tests/src/eth/base.test.ts
@@ -94,7 +94,7 @@
   });
 
   itWeb3('ERC721 support', async ({web3}) => {
-    expect(await contract(web3).methods.supportsInterface('0x58800161').call()).to.be.true;
+    expect(await contract(web3).methods.supportsInterface('0x780e9d63').call()).to.be.true;
   });
 
   itWeb3('ERC721Metadata support', async ({web3}) => {

--- a/tests/src/eth/fungibleAbi.json
+++ b/tests/src/eth/fungibleAbi.json
@@ -151,33 +151,6 @@
     "type": "function"
   },
   {
-    "inputs": [
-      { "internalType": "address", "name": "to", "type": "address" },
-      { "internalType": "uint256", "name": "amount", "type": "uint256" }
-    ],
-    "name": "mint",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple0[]",
-        "name": "amounts",
-        "type": "tuple[]"
-      }
-    ],
-    "name": "mintBulk",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
     "inputs": [],
     "name": "getCollectionSponsor",
     "outputs": [
@@ -220,6 +193,33 @@
     "type": "function"
   },
   {
+    "inputs": [
+      { "internalType": "address", "name": "to", "type": "address" },
+      { "internalType": "uint256", "name": "amount", "type": "uint256" }
+    ],
+    "name": "mint",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          { "internalType": "address", "name": "field_0", "type": "address" },
+          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+        ],
+        "internalType": "struct Tuple6[]",
+        "name": "amounts",
+        "type": "tuple[]"
+      }
+    ],
+    "name": "mintBulk",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
     "inputs": [],
     "name": "name",
     "outputs": [{ "internalType": "string", "name": "", "type": "string" }],