fix locals decoding

src/solidity/types/ArrayType.js

@@ -57,23 +57,24 @@ class ArrayType extends RefType {
   }
 
   decodeFromMemory (offset, memory) {
+    offset = 2 * offset
     var ret = []
     var length = extractLength(this, offset, memory)
     if (this.arraySize === 'dynamic') {
       offset = offset + 64
     }
+    this.underlyingType.location = this.location
     for (var k = 0; k < length; k++) {
       var contentOffset = offset
-      if (this.underlyingType.typeName === 'bytes' || this.underlyingType.typeName === 'string' || this.underlyingType.typeName === 'array' || this.underlyingType.typeName === 'struct') {
+      if (this.underlyingType.basicType === 'RefType') {
         contentOffset = memory.substr(offset, 64)
-        contentOffset = 2 * parseInt(contentOffset, 16)
+        contentOffset = parseInt(contentOffset, 16)
       }
-      ret.push(this.underlyingType.decodeFromMemory(contentOffset, memory))
+      ret.push(this.underlyingType.decode(contentOffset, memory))
       offset += 64
     }
     return ret
   }
-
 }
 
 function extractLength (type, offset, memory) {

src/solidity/types/DynamicByteArray.js

@@ -1,15 +1,11 @@
 'use strict'
 var util = require('./util')
 var BN = require('ethereumjs-util').BN
-var ValueType = require('./ValueType')
+var RefType = require('./RefType')
 
-class DynamicByteArray extends ValueType {
+class DynamicByteArray extends RefType {
-  constructor () {
+  constructor (location) {
-    super(1, 32, 'bytes')
+    super(1, 32, 'bytes', location)
-  }
-
-  decodeValue (value) {
-    return '0x' + value.toUpperCase()
   }
 
   decodeFromStorage (location, storageContent) {
@@ -39,20 +35,8 @@ class DynamicByteArray extends ValueType {
     }
   }
 
-  decodeFromStack (stackDepth, stack, memory) {
-    if (stack.length - 1 < stackDepth) {
-      return {
-        value: '0x',
-        length: '0x0'
-      }
-    } else {
-      var offset = stack[stack.length - 1 - stackDepth]
-      offset = 2 * parseInt(offset, 16)
-      return this.decodeFromMemory(offset, memory)
-    }
-  }
-
   decodeFromMemory (offset, memory) {
+    offset = 2 * offset
     var length = memory.substr(offset, 64)
     length = 2 * parseInt(length, 16)
     return {

src/solidity/types/RefType.js

@@ -7,20 +7,31 @@ class RefType {
     this.storageSlots = storageSlots
     this.storageBytes = storageBytes
     this.typeName = typeName
+    this.basicType = 'RefType'
   }
 
   decodeFromStack (stackDepth, stack, memory, storage) {
+    if (!storage) {
+      storage = {} // TODO this is a fallback, should manage properly locals store in storage
+    }
     if (stack.length - 1 < stackDepth) {
-      return []
+      return { error: '<decoding failed - stack underflow ' + stackDepth + '>' }
     }
     var offset = stack[stack.length - 1 - stackDepth]
-    offset = 2 * parseInt(offset, 16)
+    offset = parseInt(offset, 16)
+    return this.decode(offset, memory, storage)
+  }
+
+  decode (offset, memory, storage) {
+    if (!storage) {
+      storage = {} // TODO this is a fallback, should manage properly locals store in storage
+    }
     if (util.storageStore(this)) {
-      return this.decodeFromStorage(offset, storage)
+      return this.decodeFromStorage({ offset: 0, slot: offset }, storage)
     } else if (util.memoryStore(this)) {
       return this.decodeFromMemory(offset, memory)
     } else {
-      return '<decoding failed - no decoder for ' + this.location + '>'
+      return { error: '<decoding failed - no decoder for ' + this.location + '>' }
     }
   }
 }

src/solidity/types/StringType.js

@@ -2,24 +2,18 @@
 var DynamicBytes = require('./DynamicByteArray')
 
 class StringType extends DynamicBytes {
-  constructor () {
+  constructor (location) {
-    super()
+    super(location)
     this.typeName = 'string'
   }
 
-  decodeValue (value) {
-    var decoded = super.decodeValue(value)
-    return format(decoded)
-  }
-
   decodeFromStorage (location, storageContent) {
     var decoded = super.decodeFromStorage(location, storageContent)
     return format(decoded)
   }
 
   decodeFromStack (stackDepth, stack, memory) {
-    var decoded = super.decodeFromStack(stackDepth, stack, memory)
+    return super.decodeFromStack(stackDepth, stack, memory)
-    return format(decoded)
   }
 
   decodeFromMemory (offset, memory) {
@@ -29,6 +23,9 @@ class StringType extends DynamicBytes {
 }
 
 function format (decoded) {
+  if (decoded.error) {
+    return decoded
+  }
   var value = decoded.value
   value = value.replace('0x', '').replace(/(..)/g, '%$1')
   var ret = {

src/solidity/types/Struct.js

@@ -21,14 +21,16 @@ class Struct extends RefType {
   }
 
   decodeFromMemory (offset, memory) {
+    offset = 2 * offset
     var ret = {}
-    this.members.map(function (item, i) {
+    this.members.map((item, i) => {
       var contentOffset = offset
-      if (item.type.typeName === 'bytes' || item.type.typeName === 'string' || item.type.typeName === 'array' || item.type.typeName === 'struct') {
+      if (item.type.basicType === 'RefType') {
-        contentOffset = memory.substr(offset, 64)
+        contentOffset = memory.substr(contentOffset, 64)
-        contentOffset = 2 * parseInt(contentOffset, 16)
+        contentOffset = parseInt(contentOffset, 16)
       }
-      var member = item.type.decodeFromMemory(contentOffset, memory)
+      item.type.location = this.location
+      var member = item.type.decode(contentOffset, memory)
       ret[item.name] = member
       offset += 64
     })

src/solidity/types/ValueType.js

@@ -6,6 +6,7 @@ class ValueType {
     this.storageSlots = storageSlots
     this.storageBytes = storageBytes
     this.typeName = typeName
+    this.basicType = 'ValueType'
   }
 
   decodeFromStorage (location, storageContent) {
@@ -22,9 +23,14 @@ class ValueType {
   }
 
   decodeFromMemory (offset, memory) {
-    var value = memory.substr(offset, 64)
+    var value = memory.substr(2 * offset, 64)
     return this.decodeValue(util.extractHexByteSlice(value, this.storageBytes, 0))
   }
+
+  decode (offset, memory) {
+    offset = offset / 2
+    return this.decodeFromMemory(offset, memory)
+  }
 }
 
 module.exports = ValueType