use solidityproxy to send statevar to localdecoder

src/code/sourceLocationTracker.js

@@ -20,18 +20,13 @@ function SourceLocationTracker (_codeManager) {
  * @param {Object} contractDetails - AST of compiled contracts
  * @param {Function} cb - callback function
  */
-SourceLocationTracker.prototype.getSourceLocation = function (address, index, contracts, cb) {
+SourceLocationTracker.prototype.getSourceLocationFromInstructionIndex = function (address, index, contracts, cb) {
   var self = this
-  this.codeManager.getCode(address, function (error, result) {
+  extractSourceMap(this.codeManager, address, contracts, function (error, sourceMap) {
-    if (!error) {
+    if (error) {
-      var sourceMap = getSourceMap(address, result.bytecode, contracts)
-      if (sourceMap) {
-        cb(null, self.sourceMappingDecoder.atIndex(index, sourceMap))
-      } else {
-        cb('no srcmap associated with the code ' + address)
-      }
-    } else {
       cb(error)
+    } else {
+      cb(null, self.sourceMappingDecoder.atIndex(index, sourceMap))
     }
   })
 }
@@ -44,12 +39,10 @@ SourceLocationTracker.prototype.getSourceLocation = function (address, index, co
  * @param {Object} contractDetails - AST of compiled contracts
  * @param {Function} cb - callback function
  */
-SourceLocationTracker.prototype.getSourceLocation = function (address, vmtraceStepIndex, contracts, cb) {
+SourceLocationTracker.prototype.getSourceLocationFromVMTraceIndex = function (address, vmtraceStepIndex, contracts, cb) {
   var self = this
-  this.codeManager.getCode(address, function (error, result) {
+  extractSourceMap(this.codeManager, address, contracts, function (error, sourceMap) {
     if (!error) {
-      var sourceMap = getSourceMap(address, result.bytecode, contracts)
-      if (sourceMap) {
       self.codeManager.getInstructionIndex(address, vmtraceStepIndex, function (error, index) {
         if (error) {
           cb(error)
@@ -57,9 +50,6 @@ SourceLocationTracker.prototype.getSourceLocation = function (address, vmtraceSt
           cb(null, self.sourceMappingDecoder.atIndex(index, sourceMap))
         }
       })
-      } else {
-        cb('no srcmap associated with the code ' + address)
-      }
     } else {
       cb(error)
     }
@@ -84,4 +74,19 @@ function getSourceMap (address, code, contracts) {
   return null
 }
 
+function extractSourceMap (codeManager, address, contracts, cb) {
+  codeManager.getCode(address, function (error, result) {
+    if (!error) {
+      var sourceMap = getSourceMap(address, result.bytecode, contracts)
+      if (sourceMap) {
+        cb(null, sourceMap)
+      } else {
+        cb('no srcmap associated with the code ' + address)
+      }
+    } else {
+      cb(error)
+    }
+  })
+}
+
 module.exports = SourceLocationTracker

src/solidity/localDecoder.js

@@ -3,13 +3,12 @@ var SourceLocationTracker = require('../code/sourceLocationTracker')
 var AstWalker = require('../util/astWalker')
 var decodeInfo = require('../solidity/decodeInfo')
 
-function LocalDecoder (parent, codeManager, traceAnalyserEvent) {
+class LocalDecoder {
+  constructor (codeManager, traceAnalyserEvent, solidityProxy) {
     this.astWalker = new AstWalker()
-  this.codeManager = codeManager
+    this.sourceLocationTracker = new SourceLocationTracker(codeManager)
-  this.parent = parent
+    this.solidityProxy = solidityProxy
     this.locals = {}
-  this.loading = false
-  this.sourceLocationTracker = new SourceLocationTracker(this.codeManager)
     var self = this
     traceAnalyserEvent.register('startAnalysing', function (step) {
       self.clear()
@@ -18,26 +17,26 @@ function LocalDecoder (parent, codeManager, traceAnalyserEvent) {
       self.push(index, step, callStack, cache)
     })
     traceAnalyserEvent.register('finishAnalysing', function (index, step) {
-    self.loading = true
     })
   }
 
-LocalDecoder.prototype.push = function (index, step, callStack, cache) {
+  push (index, step, callStack, cache) {
-  if (!this.parent.sources) return
+    if (!this.solidityProxy.loaded()) return
     if (step.op.indexOf('PUSH') === 0) {
-    var self = this
-    var compiledContracts = this.parent.contracts
       var address = callStack[callStack.length - 1]
-    this.sourceLocationTracker.getSourceLocation(address, index, compiledContracts, function (error, result) {
+      this.sourceLocationTracker.getSourceLocationFromVMTraceIndex(address, index, this.solidityProxy.contracts, (error, result) => {
+        if (error) {
+          console.log(error)
+        } else {
+          var ast = this.solidityProxy.ast(result)
+          this.solidityProxy.extractStateVariablesAt(index, (error, stateVars) => { // cached
             if (error) {
               console.log(error)
             } else {
-        var file = self.parent.sourceList[result.file]
+              this.astWalker.walk(ast, (node) => {
-        var ast = self.parent.sources[file].AST
-        self.astWalker.walk(ast, function (node) {
                 if (node.name === 'VariableDeclaration' && node.src.indexOf(result.start + ':' + result.length) === 0) {
-            self.locals[node.attributes.name] = {
+                  this.locals[node.attributes.name] = {
-              type: decodeInfo.parseType(node.attributes.type, []),
+                    type: decodeInfo.parseType(node.attributes.type, stateVars),
                     stack: step.stack
                   }
                   return false
@@ -48,11 +47,13 @@ LocalDecoder.prototype.push = function (index, step, callStack, cache) {
             }
           })
         }
+      })
+    }
   }
 
-LocalDecoder.prototype.clear = function () {
+  clear () {
-  this.loading = false
     this.locals = {}
   }
+}
 
 module.exports = LocalDecoder

src/solidity/solidityProxy.js

@@ -0,0 +1,90 @@
+'use strict'
+var traceHelper = require('../helpers/traceHelper')
+var stateDecoder = require('./stateDecoder')
+
+class SolidityProxy {
+  constructor (traceManager, codeManager) {
+    this.cache = new Cache()
+    this.reset({})
+    this.traceManager = traceManager
+    this.codeManager = codeManager
+  }
+
+  reset (compilationResult) {
+    this.sources = compilationResult.sources
+    this.sourceList = compilationResult.sourceList
+    this.contracts = compilationResult.contracts
+    this.cache.reset()
+  }
+
+  loaded () {
+    return this.contracts !== undefined
+  }
+
+  contractNameAt (vmTraceIndex, cb) {
+    this.traceManager.getCurrentCalledAddressAt(vmTraceIndex, (error, address) => {
+      if (error) {
+        cb(error)
+      } else {
+        if (this.cache.contractNameByAddress[address]) {
+          cb(null, this.cache.contractNameByAddress[address])
+        } else {
+          this.codeManager.getCode(address, (error, code) => {
+            if (error) {
+              cb(error)
+            } else {
+              var contractName = contractNameFromCode(this.contracts, code.bytecode, address)
+              this.cache.contractNameByAddress[address] = contractName
+              cb(null, contractName)
+            }
+          })
+        }
+      }
+    })
+  }
+
+  extractStateVariables (contractName) {
+    if (!this.cache.stateVariablesByContractName[contractName]) {
+      this.cache.stateVariablesByContractName[contractName] = stateDecoder.extractStateVariables(contractName, this.sources)
+    }
+    return this.cache.stateVariablesByContractName[contractName]
+  }
+
+  extractStateVariablesAt (vmtraceIndex, cb) {
+    this.contractNameAt(vmtraceIndex, (error, contractName) => {
+      if (error) {
+        cb(error)
+      } else {
+        cb(null, this.extractStateVariables(contractName))
+      }
+    })
+  }
+
+  ast (sourceLocation) {
+    var file = this.sourceList[sourceLocation.file]
+    return this.sources[file].AST
+  }
+}
+
+function contractNameFromCode (contracts, code, address) {
+  var isCreation = traceHelper.isContractCreation(address)
+  var byteProp = isCreation ? 'bytecode' : 'runtimeBytecode'
+  for (var k in contracts) {
+    if ('0x' + contracts[k][byteProp] === code) {
+      return k
+    }
+  }
+  return null
+}
+
+class Cache {
+  constructor () {
+    this.reset()
+  }
+  reset () {
+    this.contractNameByAddress = {}
+    this.stateVariablesByContractName = {}
+  }
+}
+
+module.exports = SolidityProxy

src/ui/Ethdebugger.js

@@ -11,16 +11,14 @@ var ui = require('../helpers/ui')
 var Web3Providers = require('../web3Provider/web3Providers')
 var DummyProvider = require('../web3Provider/dummyProvider')
 var CodeManager = require('../code/codeManager')
-var SourceLocationTracker = require('../code/sourceLocationTracker')
 var LocalDecoder = require('../solidity/localDecoder')
+var SolidityProxy = require('../solidity/solidityProxy')
 
 function Ethdebugger () {
   this.event = new EventManager()
 
   this.currentStepIndex = -1
   this.tx
-  this.sources
-  this.contracts
   this.statusMessage = ''
 
   this.view
@@ -29,9 +27,8 @@ function Ethdebugger () {
   this.switchProvider('DUMMYWEB3')
   this.traceManager = new TraceManager()
   this.codeManager = new CodeManager(this.traceManager)
-  this.sourceLocationTracker = new SourceLocationTracker(this.codeManager)
+  this.solidityProxy = new SolidityProxy(this.traceManager, this.codeManager)
-  this.locals = new LocalDecoder(this, this.codeManager, this.traceManager.traceAnalyser.event)
+  this.locals = new LocalDecoder(this.codeManager, this.traceManager.traceAnalyser.event, this.solidityProxy)
-
   var self = this
   this.event.register('indexChanged', this, function (index) {
     self.codeManager.resolveStep(index, self.tx)
@@ -51,7 +48,7 @@ function Ethdebugger () {
   this.stepManager.event.register('stepChanged', this, function (stepIndex) {
     self.stepChanged(stepIndex)
   })
-  this.vmDebugger = new VmDebugger(this, this.traceManager, this.codeManager)
+  this.vmDebugger = new VmDebugger(this, this.traceManager, this.codeManager, this.solidityProxy)
 }
 
 Ethdebugger.prototype.web3 = function () {
@@ -77,13 +74,9 @@ Ethdebugger.prototype.switchProvider = function (type) {
 
 Ethdebugger.prototype.setCompilationResult = function (compilationResult) {
   if (compilationResult && compilationResult.sources && compilationResult.contracts) {
-    this.sources = compilationResult.sources
+    this.solidityProxy.reset(compilationResult)
-    this.sourceList = compilationResult.sourceList
-    this.contracts = compilationResult.contracts
   } else {
-    this.sources = null
+    this.solidityProxy.reset({})
-    this.contracts = null
-    this.sourceList = null
   }
 }
 

src/ui/SolidityState.js

@@ -1,13 +1,13 @@
 'use strict'
 var DropdownPanel = require('./DropdownPanel')
-var traceHelper = require('../helpers/traceHelper')
 var stateDecoder = require('../solidity/stateDecoder')
 var yo = require('yo-yo')
 
-function SolidityState (_parent, _traceManager, _codeManager) {
+function SolidityState (_parent, _traceManager, _codeManager, _solidityProxy) {
   this.parent = _parent
   this.traceManager = _traceManager
   this.codeManager = _codeManager
+  this.solidityProxy = _solidityProxy
   this.basicPanel = new DropdownPanel('Solidity State')
   this.init()
 }
@@ -24,7 +24,7 @@ SolidityState.prototype.init = function () {
       return
     }
     if (self.parent.currentStepIndex !== index) return
-    if (!this.parent.contracts || !this.parent.sources) {
+    if (!this.solidityProxy.loaded()) {
       self.basicPanel.update({info: 'no source has been specified'})
       return
     }
@@ -33,39 +33,16 @@ SolidityState.prototype.init = function () {
       if (error) {
         self.basicPanel.update({ info: error })
       } else {
-        self.traceManager.getCurrentCalledAddressAt(index, function (error, address) {
+        self.solidityProxy.extractStateVariablesAt(index, function (error, stateVars) {
           if (error) {
             self.basicPanel.update({ info: error })
           } else {
-            self.codeManager.getCode(address, function (error, code) {
+            self.basicPanel.update(stateDecoder.decodeState(stateVars, storage))
-              if (error) {
-                self.basicPanel.update({ info: error })
-              } else {
-                var contractName = contractNameFromCode(self.parent.contracts, code.bytecode, address)
-                if (contractName === null) {
-                  self.basicPanel.update({ info: 'could not find compiled contract with address ' + address })
-                } else {
-                  var state = stateDecoder.solidityState(storage, self.parent.sources, contractName)
-                  self.basicPanel.update(state)
-                }
           }
         })
       }
     })
-      }
   })
-  })
-}
-
-function contractNameFromCode (contracts, code, address) {
-  var isCreation = traceHelper.isContractCreation(address)
-  var byteProp = isCreation ? 'bytecode' : 'runtimeBytecode'
-  for (var k in contracts) {
-    if ('0x' + contracts[k][byteProp] === code) {
-      return k
-    }
-  }
-  return null
 }
 
 module.exports = SolidityState

src/ui/VmDebugger.js

@@ -11,7 +11,7 @@ var DropdownPanel = require('./DropdownPanel')
 var SolidityState = require('./SolidityState')
 var yo = require('yo-yo')
 
-function VmDebugger (_parent, _traceManager, _codeManager) {
+function VmDebugger (_parent, _traceManager, _codeManager, _solidityProxy) {
   this.asmCode = new CodeListView(_parent, _codeManager)
   this.stackPanel = new StackPanel(_parent, _traceManager)
   this.storagePanel = new StoragePanel(_parent, _traceManager)
@@ -19,7 +19,7 @@ function VmDebugger (_parent, _traceManager, _codeManager) {
   this.calldataPanel = new CalldataPanel(_parent, _traceManager)
   this.callstackPanel = new CallstackPanel(_parent, _traceManager)
   this.stepDetail = new StepDetail(_parent, _traceManager)
-  this.solidityState = new SolidityState(_parent, _traceManager, _codeManager)
+  this.solidityState = new SolidityState(_parent, _traceManager, _codeManager, _solidityProxy)
 
   /* Return values - */
   this.returnValuesPanel = new DropdownPanel('Return Value')

test/solidity/localDecoder.js

@@ -13,6 +13,7 @@ var Web3Providers = require('../../src/web3Provider/web3Providers')
 var traceHelper = require('../../src/helpers/traceHelper')
 var util = require('../../src/helpers/global')
 var LocalDecoder = require('../../src/solidity/localDecoder')
+var SolidityProxy = require('../../src/solidity/solidityProxy')
 
 tape('solidity', function (t) {
   t.test('local decoder', function (st) {
@@ -32,7 +33,9 @@ tape('solidity', function (t) {
             tx.to = traceHelper.contractCreationToken('0')
             var traceManager = new TraceManager()
             var codeManager = new CodeManager(traceManager)
-            var localDecoder = new LocalDecoder(output, codeManager, traceManager.traceAnalyser.event)
+            var solidityProxy = new SolidityProxy(traceManager, codeManager)
+            solidityProxy.reset(output)
+            var localDecoder = new LocalDecoder(codeManager, traceManager.traceAnalyser.event, solidityProxy)
             traceManager.resolveTrace(tx, function (error, result) {
               if (error) {
                 st.fail(error)