Implement net gas metering for SSTORE in LegacyVM

libethcore/EVMSchedule.h

@@ -33,6 +33,7 @@ struct EVMSchedule
     bool haveDelegateCall = true;
     bool eip150Mode = false;
     bool eip158Mode = false;
+    bool eip1283Mode = false;
     bool haveBitwiseShifting = false;
     bool haveRevert = false;
     bool haveReturnData = false;
@@ -47,7 +48,9 @@ struct EVMSchedule
     unsigned sloadGas = 50;
     unsigned sstoreSetGas = 20000;
     unsigned sstoreResetGas = 5000;
+    unsigned sstoreUnchangedGas = 200;
     unsigned sstoreRefundGas = 15000;
+    unsigned sstoreRefundNonzeroGas = 4800;
     unsigned jumpdestGas = 1;
     unsigned logGas = 375;
     unsigned logDataGas = 8;
@@ -135,6 +138,7 @@ static const EVMSchedule ConstantinopleSchedule = []
     schedule.haveCreate2 = true;
     schedule.haveBitwiseShifting = true;
     schedule.haveExtcodehash = true;
+    schedule.eip1283Mode = true;
     return schedule;
 }();
 

libethereum/Account.cpp

@@ -20,8 +20,10 @@
  */
 
 #include "Account.h"
+#include "SecureTrieDB.h"
 #include "ValidationSchemes.h"
 #include <libdevcore/JsonUtils.h>
+#include <libdevcore/OverlayDB.h>
 #include <libethcore/ChainOperationParams.h>
 #include <libethcore/Precompiled.h>
 
@@ -39,6 +41,20 @@ void Account::setCode(bytes&& _code)
     m_codeHash = sha3(m_codeCache);
 }
 
+u256 Account::originalStorageValue(u256 const& _key, OverlayDB const& _db) const
+{
+    auto it = m_storageOriginal.find(_key);
+    if (it != m_storageOriginal.end())
+        return it->second;
+
+    // Not in the original values cache - go to the DB.
+    SecureTrieDB<h256, OverlayDB> const memdb(const_cast<OverlayDB*>(&_db), m_storageRoot);
+    std::string const payload = memdb.at(_key);
+    auto const value = payload.size() ? RLP(payload).toInt<u256>() : 0;
+    m_storageOriginal[_key] = value;
+    return value;
+}
+
 namespace js = json_spirit;
 
 namespace

libethereum/Account.h

@@ -22,13 +22,16 @@
 #pragma once
 
 #include <libdevcore/Common.h>
-#include <libdevcore/RLP.h>
-#include <libdevcore/TrieDB.h>
 #include <libdevcore/SHA3.h>
+#include <libdevcore/TrieCommon.h>
 #include <libethcore/Common.h>
 
+#include <boost/filesystem/path.hpp>
+
 namespace dev
 {
+class OverlayDB;
+
 namespace eth
 {
 
@@ -45,20 +48,6 @@ namespace eth
  * in the overlay, stored in this class and retrieved with storageOverlay(). setStorage allows the overlay
  * to be altered.
  *
- * The code handling explicitly supports a two-stage commit model needed for contract-creation. When creating
- * a contract (running the initialisation code), the code of the account is considered empty. The attribute
- * of emptiness can be retrieved with codeBearing(). After initialisation one must set the code accordingly;
- * the code of the Account can be set with setCode(). To validate a setCode() call, this class records the
- * state of being in contract-creation (and thus in a state where setCode may validly be called). It can be
- * determined through isFreshCode().
- *
- * The code can be retrieved through code(), and its hash through codeHash(). codeHash() is only valid when
- * the account is not in the contract-creation phase (i.e. when isFreshCode() returns false). This class
- * supports populating code on-demand from the state database. To determine if the code has been prepopulated
- * call codeCacheValid(). To populate the code, look it up with codeHash() and populate with noteCode().
- *
- * @todo: need to make a noteCodeCommitted().
- *
  * The constructor allows you to create an one of a number of "types" of accounts. The default constructor
  * makes a dead account (this is ignored by State when writing out the Trie). Another three allow a basic
  * or contract account to be specified along with an initial balance. The fina two allow either a basic or
@@ -88,8 +77,19 @@ class Account
     Account(u256 _nonce, u256 _balance, h256 _contractRoot, h256 _codeHash, Changedness _c): m_isAlive(true), m_isUnchanged(_c == Unchanged), m_nonce(_nonce), m_balance(_balance), m_storageRoot(_contractRoot), m_codeHash(_codeHash) { assert(_contractRoot); }
 
 
-    /// Kill this account. Useful for the suicide opcode. Following this call, isAlive() returns false.
-    void kill() { m_isAlive = false; m_storageOverlay.clear(); m_codeHash = EmptySHA3; m_storageRoot = EmptyTrie; m_balance = 0; m_nonce = 0; changed(); }
+    /// Kill this account. Useful for the suicide opcode. Following this call, isAlive() returns
+    /// false.
+    void kill()
+    {
+        m_isAlive = false;
+        m_storageOverlay.clear();
+        m_storageOriginal.clear();
+        m_codeHash = EmptySHA3;
+        m_storageRoot = EmptyTrie;
+        m_balance = 0;
+        m_nonce = 0;
+        changed();
+    }
 
     /// @returns true iff this object represents an account in the state. Returns false if this object
     /// represents an account that should no longer exist in the trie (an account that never existed or was
@@ -121,11 +121,25 @@ class Account
     /// the account.
     void setNonce(u256 const& _nonce) { m_nonce = _nonce; changed(); }
 
-
     /// @returns the root of the trie (whose nodes are stored in the state db externally to this class)
     /// which encodes the base-state of the account's storage (upon which the storage is overlaid).
     h256 baseRoot() const { assert(m_storageRoot); return m_storageRoot; }
 
+    /// @returns account's storage value corresponding to the @_key
+    /// taking into account overlayed modifications
+    u256 storageValue(u256 const& _key, OverlayDB const& _db) const
+    {
+        auto mit = m_storageOverlay.find(_key);
+        if (mit != m_storageOverlay.end())
+            return mit->second;
+
+        return originalStorageValue(_key, _db);
+    }
+
+    /// @returns account's original storage value corresponding to the @_key
+    /// not taking into account overlayed modifications
+    u256 originalStorageValue(u256 const& _key, OverlayDB const& _db) const;
+
     /// @returns the storage overlay as a simple hash map.
     std::unordered_map<u256, u256> const& storageOverlay() const { return m_storageOverlay; }
 
@@ -139,10 +153,6 @@ class Account
     /// Set the storage root.  Used when clearStorage() is reverted.
     void setStorageRoot(h256 const& _root) { m_storageOverlay.clear(); m_storageRoot = _root; changed(); }
 
-    /// Set a key/value pair in the account's storage to a value that is already present inside the
-    /// database.
-    void setStorageCache(u256 _p, u256 _v) const { const_cast<decltype(m_storageOverlay)&>(m_storageOverlay)[_p] = _v; }
-
     /// @returns the hash of the account's code.
     h256 codeHash() const { return m_codeHash; }
 
@@ -193,10 +203,13 @@ class Account
     h256 m_codeHash = EmptySHA3;
 
     /// The map with is overlaid onto whatever storage is implied by the m_storageRoot in the trie.
-    std::unordered_map<u256, u256> m_storageOverlay;
+    mutable std::unordered_map<u256, u256> m_storageOverlay;
+
+    /// The cache of unmodifed storage items
+    mutable std::unordered_map<u256, u256> m_storageOriginal;
 
-    /// The associated code for this account. The SHA3 of this should be equal to m_codeHash unless m_codeHash
-    /// equals c_contractConceptionCodeHash.
+    /// The associated code for this account. The SHA3 of this should be equal to m_codeHash unless
+    /// m_codeHash equals c_contractConceptionCodeHash.
     bytes m_codeCache;
 
     /// Value for m_codeHash when this account is having its code determined.
@@ -249,7 +262,7 @@ class PrecompiledContract;
 using PrecompiledContractMap = std::unordered_map<Address, PrecompiledContract>;
 
 AccountMap jsonToAccountMap(std::string const& _json, u256 const& _defaultNonce = 0,
-    AccountMaskMap* o_mask = nullptr, PrecompiledContractMap* o_precompiled = nullptr,
-    const boost::filesystem::path& _configPath = {});
+	AccountMaskMap* o_mask = nullptr, PrecompiledContractMap* o_precompiled = nullptr,
+	const boost::filesystem::path& _configPath = {});
 }
 }

libethereum/ExtVM.h

@@ -60,6 +60,12 @@ class ExtVM : public ExtVMFace
     /// Write a value in storage.
     void setStore(u256 _n, u256 _v) final;
 
+    /// Read original storage value (before modifications in the current transaction).
+    u256 originalStorageValue(u256 const& _key) final
+    {
+        return m_s.originalStorageValue(myAddress, _key);
+    }
+
     /// Read address's code.
     bytes const& codeAt(Address _a) final { return m_s.code(_a); }
 

libethereum/SecureTrieDB.h

@@ -0,0 +1,35 @@
+/*
+    This file is part of cpp-ethereum.
+
+    cpp-ethereum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    cpp-ethereum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <libdevcore/TrieDB.h>
+
+namespace dev
+{
+namespace eth
+{
+#if ETH_FATDB
+template <class KeyType, class DB>
+using SecureTrieDB = SpecificTrieDB<FatGenericTrieDB<DB>, KeyType>;
+#else
+template <class KeyType, class DB>
+using SecureTrieDB = SpecificTrieDB<HashedGenericTrieDB<DB>, KeyType>;
+#endif
+
+}  // namespace eth
+}  // namespace dev

libethereum/State.cpp

@@ -418,18 +418,7 @@ u256 State::getNonce(Address const& _addr) const
 u256 State::storage(Address const& _id, u256 const& _key) const
 {
     if (Account const* a = account(_id))
-    {
-        auto mit = a->storageOverlay().find(_key);
-        if (mit != a->storageOverlay().end())
-            return mit->second;
-
-        // Not in the storage cache - go to the DB.
-        SecureTrieDB<h256, OverlayDB> memdb(const_cast<OverlayDB*>(&m_db), a->baseRoot());          // promise we won't change the overlay! :)
-        string payload = memdb.at(_key);
-        u256 ret = payload.size() ? RLP(payload).toInt<u256>() : 0;
-        a->setStorageCache(_key, ret);
-        return ret;
-    }
+        return a->storageValue(_key, m_db);
     else
         return 0;
 }
@@ -440,6 +429,14 @@ void State::setStorage(Address const& _contract, u256 const& _key, u256 const& _
     m_cache[_contract].setStorage(_key, _value);
 }
 
+u256 State::originalStorageValue(Address const& _contract, u256 const& _key) const
+{
+    if (Account const* a = account(_contract))
+        return a->originalStorageValue(_key, m_db);
+    else
+        return 0;
+}
+
 void State::clearStorage(Address const& _contract)
 {
     h256 const& oldHash{m_cache[_contract].baseRoot()};

libethereum/State.h

@@ -17,20 +17,20 @@
 
 #pragma once
 
-#include <array>
-#include <unordered_map>
+#include "Account.h"
+#include "GasPricer.h"
+#include "SecureTrieDB.h"
+#include "Transaction.h"
+#include "TransactionReceipt.h"
 #include <libdevcore/Common.h>
-#include <libdevcore/RLP.h>
-#include <libdevcore/TrieDB.h>
 #include <libdevcore/OverlayDB.h>
-#include <libethcore/Exceptions.h>
+#include <libdevcore/RLP.h>
 #include <libethcore/BlockHeader.h>
+#include <libethcore/Exceptions.h>
 #include <libethereum/CodeSizeCache.h>
 #include <libevm/ExtVMFace.h>
-#include "Account.h"
-#include "Transaction.h"
-#include "TransactionReceipt.h"
-#include "GasPricer.h"
+#include <array>
+#include <unordered_map>
 
 namespace dev
 {
@@ -73,15 +73,9 @@ enum class Permanence
 {
     Reverted,
     Committed,
-    Uncommitted	///< Uncommitted state for change log readings in tests.
+    Uncommitted  ///< Uncommitted state for change log readings in tests.
 };
 
-#if ETH_FATDB
-template <class KeyType, class DB> using SecureTrieDB = SpecificTrieDB<FatGenericTrieDB<DB>, KeyType>;
-#else
-template <class KeyType, class DB> using SecureTrieDB = SpecificTrieDB<HashedGenericTrieDB<DB>, KeyType>;
-#endif
-
 DEV_SIMPLE_EXCEPTION(InvalidAccountStartNonceInState);
 DEV_SIMPLE_EXCEPTION(IncorrectAccountStartNonceInState);
 
@@ -266,6 +260,11 @@ class State
     /// Set the value of a storage position of an account.
     void setStorage(Address const& _contract, u256 const& _location, u256 const& _value);
 
+    /// Get the original value of a storage position of an account (before modifications saved in
+    /// account cache).
+    /// @returns 0 if no account exists at that address.
+    u256 originalStorageValue(Address const& _contract, u256 const& _key) const;
+
     /// Clear the storage root hash of an account to the hash of the empty trie.
     void clearStorage(Address const& _contract);
 
@@ -322,7 +321,7 @@ class State
     u256 const& requireAccountStartNonce() const;
     void noteAccountStartNonce(u256 const& _actual);
 
-    /// Create a savepoint in the state changelog.	///
+    /// Create a savepoint in the state changelog.
     /// @return The savepoint index that can be used in rollback() function.
     size_t savepoint() const;
 
@@ -352,12 +351,19 @@ class State
     /// exception occurred.
     bool executeTransaction(Executive& _e, Transaction const& _t, OnOpFunc const& _onOp);
 
-    OverlayDB m_db;								///< Our overlay for the state tree.
-    SecureTrieDB<Address, OverlayDB> m_state;	///< Our state tree, as an OverlayDB DB.
-    mutable std::unordered_map<Address, Account> m_cache;	///< Our address cache. This stores the states of each address that has (or at least might have) been changed.
-    mutable std::vector<Address> m_unchangedCacheEntries;	///< Tracks entries in m_cache that can potentially be purged if it grows too large.
-    mutable std::set<Address> m_nonExistingAccountsCache;	///< Tracks addresses that are known to not exist.
-    AddressHash m_touched;						///< Tracks all addresses touched so far.
+    /// Our overlay for the state tree.
+    OverlayDB m_db;
+    /// Our state tree, as an OverlayDB DB.
+    SecureTrieDB<Address, OverlayDB> m_state;
+    /// Our address cache. This stores the states of each address that has (or at least might have)
+    /// been changed.
+    mutable std::unordered_map<Address, Account> m_cache;
+    /// Tracks entries in m_cache that can potentially be purged if it grows too large.
+    mutable std::vector<Address> m_unchangedCacheEntries;
+    /// Tracks addresses that are known to not exist.
+    mutable std::set<Address> m_nonExistingAccountsCache;
+    /// Tracks all addresses touched so far.
+    AddressHash m_touched;
 
     u256 m_accountStartNonce;
 

libevm/ExtVMFace.h

@@ -218,6 +218,9 @@ class ExtVMFace: public evmc_context
     /// Write a value in storage.
     virtual void setStore(u256, u256) {}
 
+    /// Read original storage value (before modifications in the current transaction).
+    virtual u256 originalStorageValue(u256 const&) { return 0; }
+
     /// Read address's balance.
     virtual u256 balance(Address) { return 0; }