fix: add native meta transaction question to meta transactions section

Author: PavelNaydanov

solidity/junior-3/solidity/README.md

@@ -36,11 +36,136 @@
     - Для чего необходимо реализовать контракт ```Paymaster```?
     - Можно ли использовать [контракты из библиотеки OpenZeppelin](https://docs.openzeppelin.com/contracts/4.x/api/metatx) для организации метатранзакций?
     - Какие еще есть сервисы, которые можно использовать для организации метатранзакций?
-5. Творческий вопрос. Как ты считаешь, на сколько важны метатранзакции? Есть ли у них будущее? Нарушают ли они какие-нибудь законы децентрализации?
+5. Можно ли реализовать метатранзакции нативно?
+   - Как работает следующий пример кода?
+    ```solidity
+        // SPDX-License-Identifier: UNLICENSED
+        pragma solidity ^0.8.19;
+
+        import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+        contract Token is ERC20 {
+            bytes32 public constant META_TRANSACTION_TYPEHASH =
+                keccak256("MetaTransaction(uint256 nonce,address signer,bytes functionSignature)");
+
+            mapping(address signer => uint256 nonce) private _nonces;
+
+            struct MetaTransaction {
+                uint256 nonce;
+                address signer;
+                bytes functionSignature;
+            }
+
+            event MetaTransactionExecuted(
+                address signer,
+                address relayer,
+                bytes functionSignature
+            );
+
+            error ZeroAddress();
+            error InvalidSignature();
+            error InvalidCall();
+
+            constructor() ERC20("Token", "MTT") {}
+
+            function DOMAIN_SEPARATOR() public view returns (bytes32) {
+                return keccak256(
+                    abi.encode(
+                        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
+                        keccak256("EIP712"),
+                        keccak256("1"),
+                        block.chainid,
+                        address(this)
+                    )
+                );
+            }
+
+            function executeMetaTransaction(
+                address signer,
+                bytes memory functionSignature,
+                uint8 v,
+                bytes32 r,
+                bytes32 s
+            ) external payable returns (bytes memory result) {
+                MetaTransaction memory _tx = MetaTransaction({
+                    nonce: _nonces[signer],
+                    signer: signer,
+                    functionSignature: functionSignature
+                });
+
+                bool isVerify = _verify(signer, _tx, v, r, s);
+                if (!isVerify) {
+                    revert InvalidSignature();
+                }
+
+                _nonces[signer] += 1;
+
+                (bool success, bytes memory data) = address(this).call(
+                    abi.encodePacked(functionSignature, signer)
+                );
+
+                if (!success) {
+                    revert InvalidCall();
+                }
+
+                emit MetaTransactionExecuted(signer, msg.sender, functionSignature);
+
+                return data;
+            }
+
+            function getNonce(address account) external view returns (uint256) {
+                return _nonces[account];
+            }
+
+            function _msgSender() internal view override returns (address sender) {
+                if (msg.sender == address(this)) {
+                    assembly {
+                        sender := shr(96, calldataload(sub(calldatasize(), 20)))
+                    }
+                }
+                else {
+                    return super._msgSender();
+                }
+            }
+
+            function _verify(
+                address signer,
+                MetaTransaction memory _tx,
+                uint8 v,
+                bytes32 r,
+                bytes32 s
+            ) private view returns (bool) {
+                if (signer == address(0)) {
+                    revert ZeroAddress();
+                }
+
+                return signer == ecrecover(_getDigest(_tx), v, r, s);
+            }
+
+            function _getDigest(MetaTransaction memory _tx) private view returns (bytes32) {
+                return keccak256(
+                    abi.encodePacked(
+                        "\x19\x01",
+                        DOMAIN_SEPARATOR(),
+                        keccak256(
+                            abi.encode(
+                                META_TRANSACTION_TYPEHASH,
+                                _tx.nonce,
+                                _tx.signer,
+                                keccak256(_tx.functionSignature)
+                            )
+                        )
+                    )
+                );
+            }
+        }
+    ```
+6. Творческий вопрос. Как ты считаешь, на сколько важны метатранзакции? Есть ли у них будущее? Нарушают ли они какие-нибудь законы децентрализации?
 
 - [Gas-free transactions: Meta Transactions explained](https://medium.com/coinmonks/gas-free-transactions-meta-transactions-explained-f829509a462d)
 - [ERC-2771](https://eips.ethereum.org/EIPS/eip-2771)
 - [Gas Station Network](https://docs.opengsn.org/)
+- [Native Meta Transactions](https://medium.com/gitcoin/native-meta-transactions-e509d91a8482)
 
 ## Oracles