Add Memory class for evm and use it in eei

s1na · s1na · commit 6a9cabd1779f · 2019-01-23T13:51:48.000+01:00
Signed-off-by: Sina Mahmoodi &lt;itz.s1na@gmail.com&gt;
diff --git a/lib/runCode.js b/lib/runCode.js
@@ -18,6 +18,7 @@ const Block = require('ethereumjs-block')
 const lookupOpInfo = require('./vm/opcodes.js')
 const opFns = require('./vm/opFns.js')
 const EEI = require('./vm/eei')
+const Memory = require('./vm/memory')
 const exceptions = require('./exceptions.js')
 const StorageReader = require('./storageReader')
 const setImmediate = require('timers').setImmediate
@@ -76,7 +77,7 @@ module.exports = function (opts, cb) {
     gasLeft: new BN(opts.gasLimit),
     gasLimit: new BN(opts.gasLimit),
     gasPrice: opts.gasPrice,
-    memory: [],
+    memory: new Memory(),
     memoryWordCount: new BN(0),
     stack: [],
     lastReturned: [],
diff --git a/lib/vm/eei.js b/lib/vm/eei.js
@@ -144,14 +144,12 @@ module.exports = class EEI {
   }
 
   /**
-   * Loads bytes from memory and returns them as a buffer. If an error occurs
-   * a string is instead returned. The function also subtracts the amount of
-   * gas need for memory expansion.
+   * Loads bytes from memory and returns them as a buffer. The function
+   * also subtracts the amount of gas need for memory expansion.
    * @method memLoad
-   * @param {Object} runState
    * @param {BN} offset where to start reading from
    * @param {BN} length how far to read
-   * @returns {Buffer|String}
+   * @returns {Buffer}
    */
   memLoad (offset, length) {
     // check to see if we have enougth gas for the mem read
@@ -166,58 +164,19 @@ module.exports = class EEI {
     offset = offset.toNumber()
     length = length.toNumber()
 
-    var loaded = this._runState.memory.slice(offset, offset + length)
-    // fill the remaining lenth with zeros
-    for (var i = loaded.length; i < length; i++) {
-      loaded[i] = 0
-    }
-    return Buffer.from(loaded)
-  }
-
-  /**
-   * Subtracts the amount needed for memory usage from `runState.gasLeft`
-   * @method subMemUsage
-   * @param {Object} runState
-   * @param {BN} offset
-   * @param {BN} length
-   * @returns {String}
-   */
-  subMemUsage (offset, length) {
-    // YP (225): access with zero length will not extend the memory
-    if (length.isZero()) return
-
-    const newMemoryWordCount = offset.add(length).divCeil(new BN(32))
-    if (newMemoryWordCount.lte(this._runState.memoryWordCount)) return
-
-    const words = newMemoryWordCount
-    const fee = new BN(this._runState._common.param('gasPrices', 'memory'))
-    const quadCoeff = new BN(this._runState._common.param('gasPrices', 'quadCoeffDiv'))
-    // words * 3 + words ^2 / 512
-    const cost = words.mul(fee).add(words.mul(words).div(quadCoeff))
-
-    if (cost.gt(this._runState.highestMemCost)) {
-      this.useGas(cost.sub(this._runState.highestMemCost))
-      this._runState.highestMemCost = cost
-    }
-
-    this._runState.memoryWordCount = newMemoryWordCount
-  }
-
-  trap (err) {
-    throw new VmError(err)
+    return this._runState.memory.read(offset, length)
   }
 
   /**
-   * Stores bytes to memory. If an error occurs a string is instead returned.
-   * The function also subtracts the amount of gas need for memory expansion.
+   * Stores bytes to memory. The function also subtracts the amount
+   * of gas need for memory expansion.
    * @method memStore
-   * @param {Object} runState
    * @param {BN} offset where to start reading from
    * @param {Buffer} val
    * @param {BN} valOffset
    * @param {BN} length how far to read
    * @param {Boolean} skipSubMem
-   * @returns {Buffer|String}
+   * @returns {Buffer}
    */
   memStore (offset, val, valOffset, length, skipSubMem) {
     if (skipSubMem !== false) {
@@ -246,23 +205,47 @@ module.exports = class EEI {
       safeLen = val.length
     }
 
-    let i = 0
-    if (safeLen > 0) {
-      safeLen = safeLen > length ? length : safeLen
-      for (; i < safeLen; i++) {
-        this._runState.memory[offset + i] = val[valOffset + i]
-      }
+    safeLen = safeLen > length ? length : safeLen
+    val = val.slice(valOffset)
+    // Pad the remaining length with zeros
+    if (val.length > 0 && safeLen < length) {
+      val = val.fill(0, safeLen, length)
     }
 
-    /*
-    pad the remaining length with zeros IF AND ONLY IF a value was stored
-    (even if value offset > value length, strange spec...)
-    */
-    if (val.length > 0 && i < length) {
-      for (; i < length; i++) {
-        this._runState.memory[offset + i] = 0
-      }
+    this._runState.memory.write(offset, safeLen, val.slice(valOffset))
+  }
+
+  /**
+   * Subtracts the amount needed for memory usage from `runState.gasLeft`
+   * @method subMemUsage
+   * @param {Object} runState
+   * @param {BN} offset
+   * @param {BN} length
+   * @returns {String}
+   */
+  subMemUsage (offset, length) {
+    // YP (225): access with zero length will not extend the memory
+    if (length.isZero()) return
+
+    const newMemoryWordCount = offset.add(length).divCeil(new BN(32))
+    if (newMemoryWordCount.lte(this._runState.memoryWordCount)) return
+
+    const words = newMemoryWordCount
+    const fee = new BN(this._runState._common.param('gasPrices', 'memory'))
+    const quadCoeff = new BN(this._runState._common.param('gasPrices', 'quadCoeffDiv'))
+    // words * 3 + words ^2 / 512
+    const cost = words.mul(fee).add(words.mul(words).div(quadCoeff))
+
+    if (cost.gt(this._runState.highestMemCost)) {
+      this.useGas(cost.sub(this._runState.highestMemCost))
+      this._runState.highestMemCost = cost
     }
+
+    this._runState.memoryWordCount = newMemoryWordCount
+  }
+
+  trap (err) {
+    throw new VmError(err)
   }
 
   // checks if a jump is valid given a destination
diff --git a/lib/vm/memory.js b/lib/vm/memory.js
@@ -0,0 +1,38 @@
+/**
+ * Memory implements a simple memory model
+ * for the ethereum virtual machine.
+ */
+module.exports = class Memory {
+  constructor () {
+    this._store = []
+  }
+
+  /**
+   * Writes a byte array with length `size` to memory, starting from `offset`.
+   * @param {Number} offset - Starting position
+   * @param {Number} size - How many bytes to write
+   * @param {Buffer} value - Value
+   */
+  write (offset, size, value) {
+    if (size > 0) {
+      for (let i = 0; i < size; i++) {
+        this._store[offset + i] = value[i]
+      }
+    }
+  }
+
+  /**
+   * Reads a slice of memory from `offset` till `offset + size` as a `Buffer`.
+   * @param {Number} offset - Starting position
+   * @param {Number} size - How many bytes to read
+   * @returns {Buffer}
+   */
+  read (offset, size) {
+    const loaded = this._store.slice(offset, offset + size)
+    // Fill the remaining lenth with zeros
+    for (let i = loaded.length; i < size; i++) {
+      loaded[i] = 0
+    }
+    return Buffer.from(loaded)
+  }
+}
