Metro-Byzantium Working Branch

CHANGELOG.md

@@ -5,8 +5,13 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 (modification: no type change headlines) and this project adheres to 
 [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## [2.3.0] - Unreleased
-- TODO
+## [2.3.0] - Unreleased (``master`` branch)
+- ``Byzantium`` compatible
+- New opcodes ``REVERT``, ``RETURNDATA`` and ``STATICCALL``
+- Precompiles for curve operations and bigint mod exp
+- Transaction return data in receipts
+- Detailed list of changes in PR [#161](https://github.com/ethereumjs/ethereumjs-vm/pull/161) 
+- For a ``Spurious Dragon``/``EIP 150`` compatible version of this library install latest version of ``2.2.x``
 
 ## [2.2.2] - 2017-09-19
 - Fixed [JS number issues](https://github.com/ethereumjs/ethereumjs-vm/pull/168)
@@ -22,7 +27,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 [2.2.1]: https://github.com/ethereumjs/ethereumjs-vm/compare/v2.2.0...v2.2.1
 
 ## [2.2.0] - 2017-07-28
-- Spurious Dragon & EIP 150 compatible
+- ``Spurious Dragon`` & ``EIP 150`` compatible
 - Detailed list of changes in pull requests [#147](https://github.com/ethereumjs/ethereumjs-vm/pull/147) and  [#143](https://github.com/ethereumjs/ethereumjs-vm/pull/143)
 - Removed ``enableHomestead`` option when creating a [ new VM object](https://github.com/ethereumjs/ethereumjs-vm#new-vmstatetrie-blockchain) (pre-Homestead fork rules not supported any more)
 

README.md

@@ -8,6 +8,16 @@
 
 Implements Ethereum's VM in JS
 
+#### Note on Byzantium Support:
+
+The ``master`` branch of this repository has now been updated with the latest 
+[Byzantium changes](https://github.com/ethereumjs/ethereumjs-vm/pull/161) please install
+directly from GitHub if you want to try out the latest ``VM`` version and report
+issues on our [Gitter channel](https://gitter.im/ethereum/ethereumjs-lib).
+
+For a ``Spurious Dragon``/``EIP 150`` compatible version of this library install the
+latest of the ``2.2.x`` series (see [Changelog](./CHANGELOG.md)).
+
 # INSTALL
 `npm install ethereumjs-vm`
 

examples/run-blockchain/index.js

@@ -110,6 +110,7 @@ function setupPreConditions (state, testData, done) {
     storageTrie.root = null
 
     async.series([
+
       function (cb2) {
         var keys = Object.keys(acctData.storage)
 
@@ -130,7 +131,7 @@ function setupPreConditions (state, testData, done) {
         if (testData.exec && key === testData.exec.address) {
           testData.root = storageTrie.root
         }
-        state.put(Buffer.from(key, 'hex'), account.serialize(), function () {
+        state.put(Buffer.from(utils.stripHexPrefix(key), 'hex'), account.serialize(), function () {
           cb2()
         })
       }

lib/constants.js

@@ -3,5 +3,7 @@ exports.ERROR = {
   STACK_UNDERFLOW: 'stack underflow',
   STACK_OVERFLOW: 'stack overflow',
   INVALID_JUMP: 'invalid JUMP',
-  INVALID_OPCODE: 'invalid opcode'
+  INVALID_OPCODE: 'invalid opcode',
+  REVERT: 'revert',
+  STATIC_STATE_CHANGE: 'static state change'
 }

lib/index.js

@@ -11,6 +11,10 @@ const num01 = require('./precompiled/01-ecrecover.js')
 const num02 = require('./precompiled/02-sha256.js')
 const num03 = require('./precompiled/03-ripemd160.js')
 const num04 = require('./precompiled/04-identity.js')
+const num05 = require('./precompiled/05-modexp.js')
+const num06 = require('./precompiled/06-ecadd.js')
+const num07 = require('./precompiled/07-ecmul.js')
+const num08 = require('./precompiled/08-ecpairing.js')
 
 module.exports = VM
 
@@ -46,9 +50,13 @@ function VM (opts = {}) {
   this._precompiled['0000000000000000000000000000000000000002'] = num02
   this._precompiled['0000000000000000000000000000000000000003'] = num03
   this._precompiled['0000000000000000000000000000000000000004'] = num04
+  this._precompiled['0000000000000000000000000000000000000005'] = num05
+  this._precompiled['0000000000000000000000000000000000000006'] = num06
+  this._precompiled['0000000000000000000000000000000000000007'] = num07
+  this._precompiled['0000000000000000000000000000000000000008'] = num08
 
   if (this.opts.activatePrecompiles) {
-    for (var i = 1; i <= 4; i++) {
+    for (var i = 1; i <= 7; i++) {
       this.trie.put(new BN(i).toArrayLike(Buffer, 'be', 20), new Account().serialize())
     }
   }

lib/opFns.js

@@ -298,6 +298,22 @@ module.exports = {
       cb(null)
     })
   },
+  RETURNDATASIZE: function (runState) {
+    return utils.intToBuffer(runState.lastReturned.length)
+  },
+  RETURNDATACOPY: function (memOffset, returnDataOffset, length, runState) {
+    memOffset = utils.bufferToInt(memOffset)
+    returnDataOffset = utils.bufferToInt(returnDataOffset)
+    length = utils.bufferToInt(length)
+
+    if (returnDataOffset + length > runState.lastReturned.length) {
+      trap(ERROR.OUT_OF_GAS)
+    }
+
+    memStore(runState, memOffset, utils.toBuffer(runState.lastReturned), returnDataOffset, length, false)
+    // sub the COPY fee
+    subGas(runState, new BN(fees.copyGas.v).imuln(Math.ceil(length / 32)))
+  },
   GASPRICE: function (runState) {
     return utils.setLengthLeft(runState.gasPrice, 32)
   },
@@ -361,6 +377,9 @@ module.exports = {
     })
   },
   SSTORE: function (key, val, runState, cb) {
+    if (runState.static) {
+      trap(ERROR.STATIC_STATE_CHANGE)
+    }
     var stateManager = runState.stateManager
     var address = runState.address
     key = utils.setLengthLeft(key, 32)
@@ -465,6 +484,10 @@ module.exports = {
   LOG: function (memOffset, memLength) {
     var args = Array.prototype.slice.call(arguments, 0)
     var runState = args.pop()
+    if (runState.static) {
+      trap(ERROR.STATIC_STATE_CHANGE)
+    }
+
     var topics = args.slice(2)
     topics = topics.map(function (a) {
       return utils.setLengthLeft(a, 32)
@@ -487,6 +510,10 @@ module.exports = {
 
   // '0xf0' range - closures
   CREATE: function (value, offset, length, runState, done) {
+    if (runState.static) {
+      trap(ERROR.STATIC_STATE_CHANGE)
+    }
+
     value = new BN(value)
     offset = utils.bufferToInt(offset)
     length = utils.bufferToInt(length)
@@ -519,13 +546,18 @@ module.exports = {
     outOffset = utils.bufferToInt(outOffset)
     outLength = utils.bufferToInt(outLength)
 
+    if (runState.static && !value.isZero()) {
+      trap(ERROR.STATIC_STATE_CHANGE)
+    }
+
     var data = memLoad(runState, inOffset, inLength)
 
     var options = {
       gasLimit: gasLimit,
       value: value,
       to: toAddress,
-      data: data
+      data: data,
+      static: runState.static
     }
 
     var localOpts = {
@@ -595,7 +627,8 @@ module.exports = {
       gasLimit: gas,
       value: value,
       data: data,
-      to: runState.address
+      to: runState.address,
+      static: runState.static
     }
 
     const localOpts = {
@@ -620,7 +653,7 @@ module.exports = {
     // load the code
     stateManager.getAccount(toAddress, function (err, account) {
       if (err) return done(err)
-      if (utils.isPrecompiled(toAddress)) {
+      if (runState._precompiled[toAddress.toString('hex')]) {
         options.compiled = true
         options.code = runState._precompiled[toAddress.toString('hex')]
         makeCall(runState, options, localOpts, done)
@@ -652,7 +685,8 @@ module.exports = {
       data: data,
       to: runState.address,
       caller: runState.caller,
-      delegatecall: true
+      delegatecall: true,
+      static: runState.static
     }
 
     const localOpts = {
@@ -668,7 +702,7 @@ module.exports = {
     // load the code
     stateManager.getAccount(toAddress, function (err, account) {
       if (err) return done(err)
-      if (utils.isPrecompiled(toAddress)) {
+      if (runState._precompiled[toAddress.toString('hex')]) {
         options.compiled = true
         options.code = runState._precompiled[toAddress.toString('hex')]
         makeCall(runState, options, localOpts, done)
@@ -682,13 +716,75 @@ module.exports = {
       }
     })
   },
+  STATICCALL: function (gasLimit, toAddress, inOffset, inLength, outOffset, outLength, runState, done) {
+    var stateManager = runState.stateManager
+    gasLimit = new BN(gasLimit)
+    toAddress = utils.setLengthLeft(toAddress, 20)
+    var value = new BN(0)
+    inOffset = utils.bufferToInt(inOffset)
+    inLength = utils.bufferToInt(inLength)
+    outOffset = utils.bufferToInt(outOffset)
+    outLength = utils.bufferToInt(outLength)
+
+    var data = memLoad(runState, inOffset, inLength)
+
+    var options = {
+      gasLimit: gasLimit,
+      value: value,
+      to: toAddress,
+      data: data,
+      static: true
+    }
+
+    var localOpts = {
+      inOffset: inOffset,
+      inLength: inLength,
+      outOffset: outOffset,
+      outLength: outLength
+    }
+
+    stateManager.exists(toAddress, function (err, exists) {
+      if (err) {
+        done(err)
+        return
+      }
+
+      stateManager.accountIsEmpty(toAddress, function (err, empty) {
+        if (err) {
+          done(err)
+          return
+        }
+
+        try {
+          checkCallMemCost(runState, options, localOpts)
+          checkOutOfGas(runState, options)
+        } catch (e) {
+          done(e.error)
+          return
+        }
+
+        makeCall(runState, options, localOpts, done)
+      })
+    })
+  },
   RETURN: function (offset, length, runState) {
     offset = utils.bufferToInt(offset)
     length = utils.bufferToInt(length)
     runState.returnValue = memLoad(runState, offset, length)
   },
+  REVERT: function (offset, length, runState) {
+    offset = utils.bufferToInt(offset)
+    length = utils.bufferToInt(length)
+
+    runState.stopped = true
+    runState.returnValue = memLoad(runState, offset, length)
+    trap(ERROR.REVERT)
+  },
   // '0x70', range - other
   SELFDESTRUCT: function (selfdestructToAddress, runState, cb) {
+    if (runState.static) {
+      trap(ERROR.STATIC_STATE_CHANGE)
+    }
     var stateManager = runState.stateManager
     var contract = runState.contract
     var contractAddress = runState.address
@@ -870,11 +966,15 @@ function makeCall (runState, callOptions, localOpts, cb) {
   callOptions.gasPrice = runState.gasPrice
   callOptions.block = runState.block
   callOptions.populateCache = false
+  callOptions.static = callOptions.static || false
   callOptions.selfdestruct = runState.selfdestruct
 
   // increment the runState.depth
   callOptions.depth = runState.depth + 1
 
+  // empty the return data buffer
+  runState.lastReturned = new Buffer([])
+
   // check if account has enough ether
   // Note: in the case of delegatecall, the value is persisted and doesn't need to be deducted again
   if (runState.depth >= fees.stackLimit.v || (callOptions.delegatecall !== true && new BN(runState.contract.balance).lt(callOptions.value))) {
@@ -906,12 +1006,25 @@ function makeCall (runState, callOptions, localOpts, cb) {
     // this should always be safe
     runState.gasLeft.isub(results.gasUsed)
 
-    if (!results.vm.exceptionError) {
-      // save results to memory
-      if (results.vm.return) {
-        memStore(runState, localOpts.outOffset, results.vm.return, 0, localOpts.outLength, false)
+    // save results to memory
+    if (results.vm.return && (!results.vm.exceptionError || results.vm.exceptionError === ERROR.REVERT)) {
+      memStore(runState, localOpts.outOffset, results.vm.return, 0, localOpts.outLength, false)
+
+      if (results.vm.exceptionError === ERROR.REVERT && runState.opName === 'CREATE') {
+        runState.lastReturned = results.vm.return
       }
 
+      switch (runState.opName) {
+        case 'CALL':
+        case 'CALLCODE':
+        case 'DELEGATECALL':
+        case 'STATICCALL':
+          runState.lastReturned = results.vm.return
+          break
+      }
+    }
+
+    if (!results.vm.exceptionError) {
       // update stateRoot on current contract
       runState.stateManager.getAccount(runState.address, function (err, account) {
         if (err) return cb(err)

lib/opcodes.js

@@ -44,6 +44,8 @@ const codes = {
   0x3a: ['GASPRICE', 2, 0, 1, false],
   0x3b: ['EXTCODESIZE', 700, 1, 1, true, true],
   0x3c: ['EXTCODECOPY', 700, 4, 0, true, true],
+  0x3d: ['RETURNDATASIZE', 2, 0, 1, true],
+  0x3e: ['RETURNDATACOPY', 3, 3, 0, true],
 
   // '0x40' range - block operations
   0x40: ['BLOCKHASH', 20, 1, 1, true, true],
@@ -147,6 +149,8 @@ const codes = {
   0xf2: ['CALLCODE', 700, 7, 1, true, true],
   0xf3: ['RETURN', 0, 2, 0, false],
   0xf4: ['DELEGATECALL', 700, 6, 1, true, true],
+  0xfa: ['STATICCALL', 700, 6, 1, true, true],
+  0xfd: ['REVERT', 0, 2, 0, false],
 
   // '0x70', range - other
   0xfe: ['INVALID', 0, 0, 0, false],