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

difftreelog

feat ethereum method handling

Yaroslav Bolyukin2021-04-30parent: #651e1c7.patch.diff
in: master

8 files changed

modifiedpallets/nft/src/eth/mod.rsdiffbeforeafterboth
4use abi::{AbiReader, AbiWriter};4use abi::{AbiReader, AbiWriter};
5pub mod log;5pub mod log;
66
77use sp_std::borrow::ToOwned;
8use sp_std::vec::Vec;
9use sp_std::convert::TryInto;
10
11use codec::{Decode, Encode};
12use pallet_evm::{AddressMapping, PrecompileLog, PrecompileOutput, ExitReason, ExitRevert, ExitSucceed};
13use sp_core::{H160, H256};
14use frame_support::storage::{StorageMap, StorageDoubleMap};
15
16use crate::{Allowances, NftItemList, Module, Balance, Config, CollectionById, CollectionHandle, CollectionId, CollectionMode};
17
18pub struct NftErcSupport<T: Config>(core::marker::PhantomData<T>);
19
20// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection
21// TODO: Unhardcode prefix
22const ETH_ACCOUNT_PREFIX: [u8; 16] = [0x17, 0xc4, 0xe6, 0x45, 0x3c, 0xc4, 0x9a, 0xaa, 0xae, 0xac, 0xa8, 0x94, 0xe6, 0xd9, 0x68, 0x3e];
23
24fn map_eth_to_id(eth: &H160) -> Option<CollectionId> {
25	if &eth[0..16] != ETH_ACCOUNT_PREFIX {
26		return None;
27	}
28	let mut id_bytes = [0; 4];
29	id_bytes.copy_from_slice(&eth[16..20]);
30	Some(u32::from_be_bytes(id_bytes))
31}
32pub fn collection_id_to_address(id: u32) -> H160 {
33	let mut out = [0; 20];
34	out[0..16].copy_from_slice(&ETH_ACCOUNT_PREFIX);
35	out[16..20].copy_from_slice(&u32::to_be_bytes(id));
36	H160(out)
37}
38
39fn result_to_output(result: Result<AbiWriter, Option<&'static str>>, logs: Vec<PrecompileLog>) -> PrecompileOutput {
40	sp_io::storage::start_transaction();
41	match result {
42		Ok(result) => {
43			sp_io::storage::commit_transaction();
44			// TODO: weight
45			PrecompileOutput(ExitReason::Succeed(ExitSucceed::Returned), result.finish(), 0, logs)
46		}
47		Err(Some(s)) => {
48			sp_io::storage::rollback_transaction();
49			// Error(string)
50			let mut out = AbiWriter::new_call(0x08c379a0);
51			out.string(&s);
52			PrecompileOutput(ExitReason::Revert(ExitRevert::Reverted), out.finish(), 0, Vec::new())
53		}
54		Err(None) => {
55			sp_io::storage::rollback_transaction();
56			PrecompileOutput(ExitReason::Revert(ExitRevert::Reverted), Vec::new(), 0, Vec::new())
57		}
58	}
59}
60
61fn call_internal<T: Config>(sender: H160, collection: &CollectionHandle<T>, method_id: u32, mut input: AbiReader) -> Result<AbiWriter, Option<&'static str>> {
62	let erc20 = matches!(collection.mode, CollectionMode::Fungible(_));
63	let erc721 = matches!(collection.mode, CollectionMode::ReFungible);
64
65	Ok(match method_id {
66		// function name() external view returns (string memory)
67		0x06fdde03 => {
68			let name = collection.name.iter()
69				.map(|&e| e.try_into().ok() as Option<u8>)
70				.collect::<Option<Vec<u8>>>()
71				.ok_or(Some("non-ascii name"))?;
72			
73			crate::abi_encode!(memory(&name))
74		}
75		// function symbol() external view returns (string memory)
76		0x95d89b41 => {
77			let name = collection.token_prefix.iter()
78				.map(|&e| e.is_ascii_uppercase().then(|| e))
79				.collect::<Option<Vec<u8>>>()
80				.ok_or(Some("non-uppercase prefix"))?;
81			
82			crate::abi_encode!(memory(&name))
83		}
84		// function decimals() external view returns (uint8 decimals)
85		0x313ce567 if erc20 => {
86			if let CollectionMode::Fungible(decimals) = &collection.mode {
87				crate::abi_encode!(uint8(*decimals))
88			} else {
89				unreachable!()
90			}			
91		}
92		// function totalSupply() external view returns (uint256)
93		0x18160ddd if erc20 => {
94			// TODO: can't be implemented, as we don't track total amount of fungibles
95			crate::abi_encode!(uint256(0))
96		}
97		// function balanceOf(address account) external view returns (uint256)
98		0x70a08231 if erc20 || erc721 => {
99			crate::abi_decode!(input, account: address);
100			let account = T::EvmAddressMapping::into_account_id(account);
101			let balance = <Balance<T>>::get(collection.id, account);
102			crate::abi_encode!(uint256(balance))
103		}
104		// function ownerOf(uint256 tokenId) external view returns (address)
105		0x6352211e if erc721 => {
106			crate::abi_decode!(input, token_id: uint256);
107			let token_id: u32 = token_id.try_into().map_err(|_| "bad token id")?;
108
109			let token = <NftItemList<T>>::get(collection.id, token_id).ok_or("unknown token")?;
110
111			crate::abi_encode!(address(token.owner.as_eth().clone()))
112		}
113		// function transfer(address recipient, uint256 amount) external returns (bool) {
114		0xa9059cbb if erc20 => {
115			crate::abi_decode!(input, recipient: address, amount: uint256);
116			let sender = T::CrossAccountId::from_eth(sender);
117			let recipient = T::CrossAccountId::from_eth(recipient);
118
119			<Module<T>>::transfer_internal(
120				sender,
121				recipient,
122				&collection,
123				1,
124				amount,
125			).map_err(|_| "transfer error")?;
126
127			crate::abi_encode!(bool(true))
128		}
129		// function allowance(address owner, address spender) external view returns (uint256)
130		0xdd62ed3e if erc20 => {
131			crate::abi_decode!(input, owner: address, spender: address);
132			let owner = T::EvmAddressMapping::into_account_id(owner);
133			let spender = T::EvmAddressMapping::into_account_id(spender);
134			let allowance = <Allowances<T>>::get(collection.id, (1, &owner, &spender));
135			crate::abi_encode!(uint256(allowance))
136		}
137		// function approve(address spender, uint256 amount) external returns (bool)
138		// FIXME: All current implementations resets amount to specified value, ours - adds it
139		// FIXME: Our implementation doesn't handle resets (approve with zero amount)
140		0x095ea7b3 if erc20 => {
141			crate::abi_decode!(input, spender: address, amount: uint256);
142			let sender = T::CrossAccountId::from_eth(sender);
143			let spender = T::CrossAccountId::from_eth(spender);
144
145			<Module<T>>::approve_internal(
146				sender,
147				spender,
148				&collection,
149				1,
150				amount,
151			).map_err(|_| "approve error")?;
152
153			crate::abi_encode!(bool(true))
154		}
155		// function approve(address approved, uint256 tokenId) external payable
156		0x095ea7b3 if erc721 => {
157			crate::abi_decode!(input, approved: address, token_id: uint256);
158			let sender = T::CrossAccountId::from_eth(sender);
159			let approved = T::CrossAccountId::from_eth(approved);
160			let token_id = token_id.try_into().map_err(|_| "bad token id")?;
161
162			<Module<T>>::approve_internal(
163				sender,
164				approved,
165				&collection,
166				token_id,
167				1,
168			).map_err(|_| "approve error")?;
169			crate::abi_encode!()
170		}
171		// function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
172		0x23b872dd if erc20 => {
173			crate::abi_decode!(input, from: address, recipient: address, amount: uint256);
174			let sender = T::CrossAccountId::from_eth(sender);
175			let from = T::CrossAccountId::from_eth(from);
176			let recipient = T::CrossAccountId::from_eth(recipient);
177
178			<Module<T>>::transfer_from_internal(
179				sender,
180				from,
181				recipient,
182				&collection,
183				1,
184				amount,
185			).map_err(|_| "transfer_from error")?;
186
187			crate::abi_encode!(bool(true))
188		}
189		// function transferFrom(address from, address to, uint256 tokenId) external payable
190		0x23b872dd if erc721 => {
191			crate::abi_decode!(input, from: address, recipient: address, token_id: uint256);
192			let sender = T::CrossAccountId::from_eth(sender);
193			let from = T::CrossAccountId::from_eth(from);
194			let recipient = T::CrossAccountId::from_eth(recipient);
195			let token_id = token_id.try_into().map_err(|_| "bad token id")?;
196
197			<Module<T>>::transfer_from_internal(
198				sender,
199				from,
200				recipient,
201				&collection,
202				token_id,
203				1,
204			).map_err(|_| "transfer_from error")?;
205
206			crate::abi_encode!()
207		}
208		// function supportsInterface(bytes4 interfaceID) public pure returns (bool)
209		0x01ffc9a7 => {
210			crate::abi_decode!(input, interface_id: uint32);
211			let supports = match interface_id {
212				// ERC165
213				0x01ffc9a7 => true,
214				// ERC20
215				0x36372b07 if erc20 => true,
216				// ERC721
217				0x80ac58cd if erc721 => true,
218				_ => false,
219			};
220			crate::abi_encode!(bool(supports))
221		}
222		_ => return Err(None)
223	})
224}
225
226impl<T: Config> pallet_evm::OnMethodCall<T> for NftErcSupport<T> {
227	fn is_reserved(target: &H160) -> bool {
228		map_eth_to_id(target).is_some()
229	}
230	fn is_used(target: &H160) -> bool {
231		map_eth_to_id(target)
232			.map(<CollectionById<T>>::contains_key)
233			.unwrap_or(false)
234	}
235	fn get_code(target: &H160) -> Option<Vec<u8>> {
236		map_eth_to_id(&target)
237			.and_then(<CollectionById<T>>::get)
238			.map(|collection| {
239				match collection.mode {
240					CollectionMode::NFT => include_bytes!("stubs/ERC721.bin") as &[u8],
241					CollectionMode::Fungible(_) => include_bytes!("stubs/ERC20.bin") as &[u8],
242					CollectionMode::ReFungible => include_bytes!("stubs/ERC1633.bin") as &[u8],
243					CollectionMode::Invalid => include_bytes!("stubs/Invalid.bin") as &[u8],
244				}.to_owned()
245			})
246	}
247	fn call(
248		source: &H160,
249		target: &H160,
250		input: &[u8],
251	) -> Option<PrecompileOutput> {
252		let collection = map_eth_to_id(&target)
253			.and_then(<CollectionHandle<T>>::get)?;
254		let (method_id, input) = AbiReader::new_call(input).unwrap();
255		let result = call_internal(*source, &collection, method_id, input);
256		Some(result_to_output(result, collection.logs.retrieve_logs_for_contract(*target)))
257	}
258}
259
260/// event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
261pub const TRANSFER_NFT_TOPIC: H256 = H256(hex_literal::hex!("ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"));
262/// event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
263pub const APPROVAL_NFT_TOPIC: H256 = H256(hex_literal::hex!("8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"));
264// TODO: event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
265
266/// event Transfer(address indexed from, address indexed to, uint256 indexed amount);
267pub const TRANSFER_FUNGIBLE_TOPIC: H256 = H256(hex_literal::hex!("ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"));
268/// event Approval(address indexed owner, address indexed approved, uint256 indexed amount);
269pub const APPROVAL_FUNGIBLE_TOPIC: H256 = H256(hex_literal::hex!("8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"));
270
271pub fn address_to_topic(address: &H160) -> H256 {
272	let mut output = [0; 32];
273	output[12..32].copy_from_slice(&address.0);
274	H256(output)
275}
276
277
278// TODO: This function is slow, and output can be memoized
279pub fn generate_transaction(collection_id: u32, chain_id: u64) -> ethereum::Transaction {
280	let contract = collection_id_to_address(collection_id);
281
282	// TODO: Make it work without native runtime by forking ethereum_tx_sign, and
283	// switching to pure-rust implementation of secp256k1
284	#[cfg(feature = "std")]
285	{
286		let signed = ethereum_tx_sign::RawTransaction {
287			nonce: 0.into(),
288			to: Some(contract.0.into()),
289			value: 0.into(),
290			gas_price: 0.into(),
291			gas: 0.into(),
292			// zero selector, this transaction always have same sender, so all data should be acquired from logs
293			data: Vec::from([0, 0, 0, 0]),
294		}.sign(
295			// TODO: move to pallet config
296			// 0xF70631E55faff9f3FD3681545aa6c724226a3853
297			// 9dbaef9b3ebc00e53f67c6a77bcfbf2c4f2aebe4d70d94af4f2df01744b7a91a
298			&hex_literal::hex!("9dbaef9b3ebc00e53f67c6a77bcfbf2c4f2aebe4d70d94af4f2df01744b7a91a").into(),
299			&chain_id
300		);
301		rlp::decode::<ethereum::Transaction>(&signed).expect("transaction is just created, it can't be broken")
302	}
303	#[cfg(not(feature = "std"))]
304	{
305		panic!("transaction generation not yet supported by wasm runtime")
306	}
307}
addedpallets/nft/src/eth/stubs/ERC1633.bindiffbeforeafterboth
--- /dev/null
+++ b/pallets/nft/src/eth/stubs/ERC1633.bin
@@ -0,0 +1 @@
+TODO
\ No newline at end of file
addedpallets/nft/src/eth/stubs/ERC20.bindiffbeforeafterboth

binary blob — no preview

addedpallets/nft/src/eth/stubs/ERC20.soldiffbeforeafterboth
--- /dev/null
+++ b/pallets/nft/src/eth/stubs/ERC20.sol
@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: OTHER
+
+pragma solidity >=0.8.0 <0.9.0;
+
+contract ERC20 {
+	uint8 _dummy = 0;
+	string stub_error = "this contract does not exists, code for collections is implemented at pallet side";
+
+	// 0x18160ddd
+	function totalSupply() external view returns (uint256) {
+		require(false, stub_error);
+		_dummy;
+		return 0;
+	}
+
+	// 0x70a08231
+	function balanceOf(address account) external view returns (uint256) {
+		require(false, stub_error);
+		account;
+		_dummy;
+		return 0;
+	}
+
+	// 0xa9059cbb
+	function transfer(address recipient, uint256 amount) external returns (bool) {
+		require(false, stub_error);
+		recipient;
+		amount;
+		_dummy = 0;
+		return false;
+	}
+
+	// 0xdd62ed3e
+	function allowance(address owner, address spender) external view returns (uint256) {
+		require(false, stub_error);
+		owner;
+		spender;
+		return _dummy;
+	}
+
+	// 0x095ea7b3
+	function approve(address spender, uint256 amount) external returns (bool) {
+		require(false, stub_error);
+		spender;
+		amount;
+		_dummy = 0;
+		return false;
+	}
+
+	// 0x23b872dd
+	function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
+		require(false, stub_error);
+		sender;
+		recipient;
+		amount;
+		_dummy = 0;
+		return false;
+	}
+
+	// While ERC165 is not required by spec of ERC20, better implement it
+	// 0x01ffc9a7
+	function supportsInterface(bytes4 interfaceID) public pure returns (bool) {
+		return 
+			// ERC20
+			interfaceID == 0x36372b07 || 
+			// ERC165
+			interfaceID == 0x01ffc9a7;
+	}
+}
\ No newline at end of file
addedpallets/nft/src/eth/stubs/ERC721.bindiffbeforeafterboth
--- /dev/null
+++ b/pallets/nft/src/eth/stubs/ERC721.bin
@@ -0,0 +1 @@
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
\ No newline at end of file
addedpallets/nft/src/eth/stubs/ERC721.soldiffbeforeafterboth
--- /dev/null
+++ b/pallets/nft/src/eth/stubs/ERC721.sol
@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: OTHER
+
+pragma solidity >=0.8.0 <0.9.0;
+
+contract ERC721 {
+    uint8 _dummy = 0;
+    address _dummy_addr = 0x0000000000000000000000000000000000000000;
+    string _dummy_string = "";
+    string stub_error =
+        "this contract does not exists, code for collections is implemented at pallet side";
+
+    event Transfer(
+        address indexed from,
+        address indexed to,
+        uint256 indexed tokenId
+    );
+
+    event Approval(
+        address indexed owner,
+        address indexed approved,
+        uint256 indexed tokenId
+    );
+
+    event ApprovalForAll(
+        address indexed owner,
+        address indexed operator,
+        bool approved
+    );
+
+	// 0x18160ddd
+    function totalSupply() external view returns (uint256) {
+        require(false, stub_error);
+        return 0;
+    }
+
+    function name() external view returns (string memory res_name) {
+        require(false, stub_error);
+        res_name = _dummy_string;
+    }
+
+    function symbol() external view returns (string memory res_symbol) {
+        require(false, stub_error);
+        res_symbol = _dummy_string;
+    }
+
+    function tokenURI(uint256 tokenId) external view returns (string memory) {
+        require(false, stub_error);
+        tokenId;
+        return _dummy_string;
+    }
+
+    function tokenByIndex(uint256 index) external view returns (uint256) {
+        require(false, stub_error);
+        index;
+		return 0;
+    }
+
+    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256) {
+        require(false, stub_error);
+		owner;
+		index;
+		return 0;
+    }
+
+    // 0x70a08231
+    function balanceOf(address owner) external view returns (uint256) {
+        require(false, stub_error);
+        owner;
+        return 0;
+    }
+
+    // 0x6352211e
+    function ownerOf(uint256 tokenId) external view returns (address) {
+        require(false, stub_error);
+        tokenId;
+        return _dummy_addr;
+    }
+
+    // 0xb88d4fde
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 tokenId,
+        bytes calldata data
+    ) external payable {
+        require(false, stub_error);
+        from;
+        to;
+        tokenId;
+        data;
+    }
+
+    // 0x42842e0e
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 tokenId
+    ) external payable {
+        require(false, stub_error);
+        from;
+        to;
+        tokenId;
+    }
+
+    // 0x23b872dd
+    function transferFrom(
+        address from,
+        address to,
+        uint256 tokenId
+    ) external payable {
+        require(false, stub_error);
+        from;
+        to;
+        tokenId;
+    }
+
+    // 0x095ea7b3
+    function approve(address approved, uint256 tokenId) external payable {
+        require(false, stub_error);
+        approved;
+        tokenId;
+    }
+
+    // 0xa22cb465
+    function setApprovalForAll(address operator, bool approved) external {
+        require(false, stub_error);
+        operator;
+        approved;
+        _dummy = 0;
+    }
+
+    // 0x081812fc
+    function getApproved(uint256 tokenId) external view returns (address) {
+        require(false, stub_error);
+        tokenId;
+        return _dummy_addr;
+    }
+
+    // 0xe985e9c5
+    function isApprovedForAll(address owner, address operator)
+        external
+        view
+        returns (bool)
+    {
+        require(false, stub_error);
+        owner;
+        operator;
+        return false;
+    }
+
+    // 0x01ffc9a7
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool) {
+        return
+            // ERC721
+            interfaceID == 0x80ac58cd ||
+            // ERC721Metadata
+            interfaceID == 0x5b5e139f ||
+            // ERC721Enumerable
+            interfaceID == 0x780e9d63 ||
+            // ERC165
+            interfaceID == 0x01ffc9a7;
+    }
+}
addedpallets/nft/src/eth/stubs/Invalid.bindiffbeforeafterboth
--- /dev/null
+++ b/pallets/nft/src/eth/stubs/Invalid.bin
@@ -0,0 +1 @@
+TODO
\ No newline at end of file
modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -55,6 +55,7 @@
 mod default_weights;
 mod eth;
 
+pub use eth::NftErcSupport;
 pub use eth::account::*;
 
 pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;