article: EIP-1153: Transient storage opcodes

EIPs/eip-1153/contracts/ERC20WithTempApprove.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/**
+ * 
+ * ///////////////////////////////////////////////////////////////
+ *                            ВАЖНО!
+ * ///////////////////////////////////////////////////////////////
+ * 
+ * @notice Код написан для демонстрации возможностей transient storage,
+ * используется исключительно в этих целях и не проходил аудит
+ * Не использовать в mainnet с реальными средствами!
+ *
+ */
+contract ERC20WithTempApprove is ERC20 {
+    error ExternalCallFailed();
+
+    constructor() ERC20("Test", "T") {}
+
+    /// @notice Функция для вызова внешнего смарт-контракта с выдачей ему разрешения на списание токенов
+    function approveAndCall(address spender, uint256 value, bytes memory data) external {
+        // Выдаем временный апрув только на ту сумму которую планируем потратить
+        _temporaryApprove(spender, value);
+
+        // Выполняем внешний вызов к смарт-контракту который спишет токены
+        (bool success,) = address(spender).call(data);
+        if (!success) {
+            revert ExternalCallFailed();
+        }
+    }
+
+    /// @notice Функция для выдачи временного разрешения
+    function _temporaryApprove(address spender, uint256 value) private {
+        // Формируем ключ для записи в transient storage
+        // записываем в него адрес владельца токенов,
+        // адрес контракта, который их спишет
+        // и само значение
+        bytes32 key = keccak256(abi.encode(msg.sender, spender, value));
+
+        // Записываем одобренное количество токенов по сформированному ключу
+        assembly {
+            tstore(key, value)
+        }
+    }
+
+    /**
+     * @notice Когда целевой смарт-контракт вызовет transferFrom
+     * transferFrom задействует функцию _spendAllowance
+     * поэтому здесь мы проверим было ли выдано временное разрешение
+     */
+    function _spendAllowance(address owner, address spender, uint256 value) internal override {
+        // для начала восстановим ключ
+        bytes32 key = keccak256(abi.encode(owner, spender, value));
+
+        // Получаем значение по ключу
+        uint256 temporaryApproval;
+        assembly {
+            temporaryApproval := tload(key)
+        }
+
+        // Если одобрение есть, перевод токенов будет выполнен
+        // если нет, передаем выполнение стандартной функции
+        // для проверки ранее выданных разрешений
+        if (temporaryApproval > 0) {
+            // Проверка соответствует ли временное разрешение тому value
+            // которое будет потрачено - не имеет смысла
+            // потому что в таком случае ключ не совпадет
+
+            // Обязательно очищаем переходное хранилище!
+            assembly {
+                tstore(key, 0)
+            }
+        } else {
+            super._spendAllowance(owner, spender, value);
+        }
+    }
+
+    function mint(address account, uint256 amount) external {
+        _mint(account, amount);
+    }
+}

EIPs/eip-1153/contracts/ExampleWithBoolReentrancyLock.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.22;
+
+/** 
+ * 
+ * ///////////////////////////////////////////////////////////////
+ *                            ВАЖНО!
+ * ///////////////////////////////////////////////////////////////
+ * 
+ * @notice Код написан для демонстрации возможностей transient storage,
+ * используется исключительно в этих целях и не проходил аудит
+ * Не использовать в mainnet с реальными средствами!
+ * 
+ */
+contract ExampleWithBoolReentrancyLock {
+    // Создаем переменную _lock
+    bool private _lock;
+
+    // Заводим маппинг для отслеживания балансов
+    mapping(address account => uint256 amount) private _balances;
+
+    error InsufficientBalance();
+    error ReentrancyAttackPrevented();
+    error TransferFailed();
+
+    function withdraw(uint256 amount) external {
+        // Перед выполнением функции проверяем, что это не повторный вход
+        if (_lock) {
+            revert ReentrancyAttackPrevented();
+        }
+        // Блокируем функцию для защиты от повторного входа
+        _lock = true;
+
+        // Проверяем текущее состояние
+        if (_balances[msg.sender] < amount) {
+            revert InsufficientBalance();
+        }
+
+        // Изменяем состояние
+        _balances[msg.sender] -= amount;
+
+        // Переводим запрошенные средства
+        (bool success,) = msg.sender.call{value: amount}("");
+        if (!success) {
+            revert TransferFailed();
+        }
+
+        // Выключем блокировку функции
+        _lock = false;
+    }
+
+    function balanceOf(address account) external view returns (uint256) {
+        return _balances[account];
+    }
+
+    receive() external payable {
+        _balances[msg.sender] += msg.value;
+    }
+}

EIPs/eip-1153/contracts/ExampleWithReentrancyGuard.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.21;
+
+import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+
+/** 
+ * 
+ * ///////////////////////////////////////////////////////////////
+ *                            ВАЖНО!
+ * ///////////////////////////////////////////////////////////////
+ * 
+ * @notice Код написан для демонстрации возможностей transient storage,
+ * используется исключительно в этих целях и не проходил аудит
+ * Не использовать в mainnet с реальными средствами!
+ * 
+ */
+contract ExampleWithReentrancyGuard is ReentrancyGuard {
+    mapping(address account => uint256 amount) private _balances;
+
+    error InsufficientBalance();
+    error ReentrancyAttackPrevented();
+    error TransferFailed();
+
+    function withdraw(uint256 amount) external nonReentrant {
+        // Проверяем текущее состояние
+        if (_balances[msg.sender] < amount) {
+            revert InsufficientBalance();
+        }
+
+        // Изменяем состояние
+        _balances[msg.sender] -= amount;
+
+        // Переводим запрошенные средства
+        (bool success,) = msg.sender.call{value: amount}("");
+        if (!success) {
+            revert TransferFailed();
+        }
+    }
+
+    function balanceOf(address account) external view returns (uint256) {
+        return _balances[account];
+    }
+
+    receive() external payable {
+        _balances[msg.sender] += msg.value;
+    }
+}

EIPs/eip-1153/contracts/ExampleWithTransientReentrancyLock.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+/** 
+ * 
+ * ///////////////////////////////////////////////////////////////
+ *                            ВАЖНО!
+ * ///////////////////////////////////////////////////////////////
+ * 
+ * @notice Код написан для демонстрации возможностей transient storage,
+ * используется исключительно в этих целях и не проходил аудит
+ * Не использовать в mainnet с реальными средствами!
+ * 
+ */
+contract ExampleWithTransientReentrancyLock {
+    // Заводим константное значение для адресации в transient storage
+    // keccak256("REENTRANCY_GUARD_SLOT");
+    bytes32 constant REENTRANCY_GUARD_SLOT = 0x167f9e63e7ffa6919d959c882a4da1182dccfb0d790328477621b65d1978856b;
+
+    mapping(address account => uint256 amount) private _balances;
+
+    error InsufficientBalance();
+    error ReentrancyAttackPrevented();
+    error TransferFailed();
+
+    modifier nonReentrant() {
+        // Перед выполнением функции проверяем, что это не повторный вход
+        if (_tload(REENTRANCY_GUARD_SLOT) == 1) {
+            revert ReentrancyAttackPrevented();
+        }
+        // Записываем по ключу REENTRANCY_GUARD_SLOT значение 1
+        _tstore(REENTRANCY_GUARD_SLOT, 1);
+
+        _;
+
+        // Очищаем значение ключа в transient storage после внешнего вызова
+        _tstore(REENTRANCY_GUARD_SLOT, 0);
+    }
+
+    function withdraw(uint256 amount) external nonReentrant {
+        // Проверяем текущее состояние
+        if (_balances[msg.sender] < amount) {
+            revert InsufficientBalance();
+        }
+
+        // Изменяем состояние
+        _balances[msg.sender] -= amount;
+
+        // Переводим запрошенные средства
+        (bool success,) = msg.sender.call{value: amount}("");
+        if (!success) {
+            revert TransferFailed();
+        }
+    }
+
+    /// @notice Вспомогательная функция для записи в transient storage
+    function _tstore(bytes32 location, uint256 value) private {
+        assembly {
+            tstore(location, value)
+        }
+    }
+
+    /// @notice Вспомогательная функция для чтения из transient storage
+    function _tload(bytes32 location) private view returns (uint256 value) {
+        assembly {
+            value := tload(location)
+        }
+    }
+
+    function balanceOf(address account) external view returns (uint256) {
+        return _balances[account];
+    }
+
+    receive() external payable {
+        _balances[msg.sender] += msg.value;
+    }
+}

README.md

@@ -116,6 +116,7 @@ Join our TG-channel: [MetaLamp|Web3 DevTeam](https://t.me/metametalamp)
 
       - [EIP-140: REVERT instruction](./EIPs/erc-140/README.md)
       - [ERC-165: Standard Interface Detection](./EIPs/erc-165/README.md)
+      - [EIP-1153: Transient storage opcodes](./EIPs/eip-1153/README.md)
       - [ERC-1363: Payable Token(transferAndCall)](./EIPs/erc-1363/README.md)
       - [ERC-4337: Account Abstraction Using Alt Mempool](./EIPs/erc-4337/README.md)
       - [ERC-4626: Tokenized Vaults](./EIPs/erc-4626/README.md)