wrap awaited function by try/catch

src/solidity/localDecoder.js

@@ -17,7 +17,12 @@ async function solidityLocals (vmtraceIndex, internalTreeCall, stack, memory, st
         name = '<' + anonymousIncr + '>'
         anonymousIncr++
       }
+      try {
         locals[name] = await variable.type.decodeFromStack(variable.stackDepth, stack, memory, storageResolver)
+      } catch (e) {
+        console.log(e)
+        locals[name] = '<decoding failed - ' + e.message + '>'
+      }
     }
   }
   return locals

src/solidity/stateDecoder.js

@@ -12,7 +12,12 @@ async function decodeState (stateVars, storageResolver) {
   var ret = {}
   for (var k in stateVars) {
     var stateVar = stateVars[k]
+    try {
       ret[stateVar.name] = await stateVar.type.decodeFromStorage(stateVar.storagelocation, storageResolver)
+    } catch (e) {
+      console.log(e)
+      ret[stateVar.name] = '<decoding failed - ' + e.message + '>'
+    }
   }
   return ret
 }
@@ -47,7 +52,11 @@ function extractStateVariables (contractName, sourcesList) {
   */
 async function solidityState (storageResolver, astList, contractName) {
   var stateVars = extractStateVariables(contractName, astList)
+  try {
     return await decodeState(stateVars, storageResolver)
+  } catch (e) {
+    return '<decoding failed - ' + e.message + '>'
+  }
 }
 
 module.exports = {

src/solidity/types/ArrayType.js

@@ -27,7 +27,16 @@ class ArrayType extends RefType {
   async decodeFromStorage (location, storageResolver) {
     var ret = []
     var size = null
-    var slotValue = await util.extractHexValue(location, storageResolver, this.storageBytes)
+    var slotValue
+    try {
+      slotValue = await util.extractHexValue(location, storageResolver, this.storageBytes)
+    } catch (e) {
+      console.log(e)
+      return {
+        value: '<decoding failed - ' + e.message + '>',
+        type: this.typeName
+      }
+    }
     var currentLocation = {
       offset: 0,
       slot: location.slot
@@ -40,8 +49,14 @@ class ArrayType extends RefType {
     }
     var k = util.toBN(0)
     for (; k.lt(size) && k.ltn(300); k.iaddn(1)) {
-      var item = await this.underlyingType.decodeFromStorage(currentLocation, storageResolver)
-      ret.push(item)
+      try {
+        ret.push(await this.underlyingType.decodeFromStorage(currentLocation, storageResolver))
+      } catch (e) {
+        return {
+          value: '<decoding failed - ' + e.message + '>',
+          type: this.typeName
+        }
+      }
       if (this.underlyingType.storageSlots === 1 && location.offset + this.underlyingType.storageBytes <= 32) {
         currentLocation.offset += this.underlyingType.storageBytes
         if (currentLocation.offset + this.underlyingType.storageBytes > 32) {

src/solidity/types/DynamicByteArray.js

@@ -10,18 +10,44 @@ class DynamicByteArray extends RefType {
   }
 
   async decodeFromStorage (location, storageResolver) {
-    var value = await util.extractHexValue(location, storageResolver, this.storageBytes)
+    var value = '0x0'
+    try {
+      value = await util.extractHexValue(location, storageResolver, this.storageBytes)
+    } catch (e) {
+      console.log(e)
+      return {
+        value: '<decoding failed - ' + e.message + '>',
+        type: this.typeName
+      }
+    }
     var bn = new BN(value, 16)
     if (bn.testn(0)) {
       var length = bn.div(new BN(2))
       var dataPos = new BN(helper.sha3(location.slot).replace('0x', ''), 16)
       var ret = ''
-      var currentSlot = await util.readFromStorage(dataPos, storageResolver)
+      var currentSlot = '0x'
+      try {
+        currentSlot = await util.readFromStorage(dataPos, storageResolver)
+      } catch (e) {
+        console.log(e)
+        return {
+          value: '<decoding failed - ' + e.message + '>',
+          type: this.typeName
+        }
+      }
       while (length.gt(ret.length) && ret.length < 32000) {
         currentSlot = currentSlot.replace('0x', '')
         ret += currentSlot
         dataPos = dataPos.add(new BN(1))
+        try {
           currentSlot = await util.readFromStorage(dataPos, storageResolver)
+        } catch (e) {
+          console.log(e)
+          return {
+            value: '<decoding failed - ' + e.message + '>',
+            type: this.typeName
+          }
+        }
       }
       return {
         value: '0x' + ret.replace(/(00)+$/, ''),

src/solidity/types/RefType.js

@@ -29,7 +29,15 @@ class RefType {
     var offset = stack[stack.length - 1 - stackDepth]
     if (this.isInStorage()) {
       offset = util.toBN(offset)
+      try {
         return await this.decodeFromStorage({ offset: 0, slot: offset }, storageResolver)
+      } catch (e) {
+        console.log(e)
+        return {
+          error: '<decoding failed - ' + e.message + '>',
+          type: this.typeName
+        }
+      }
     } else if (this.isInMemory()) {
       offset = parseInt(offset, 16)
       return this.decodeFromMemoryInternal(offset, memory)

src/solidity/types/StringType.js

@@ -8,12 +8,23 @@ class StringType extends DynamicBytes {
   }
 
   async decodeFromStorage (location, storageResolver) {
-    var decoded = await super.decodeFromStorage(location, storageResolver)
+    var decoded = '0x'
+    try {
+      decoded = await super.decodeFromStorage(location, storageResolver)
+    } catch (e) {
+      console.log(e)
+      return '<decoding failed - ' + e.message + '>'
+    }
     return format(decoded)
   }
 
   async decodeFromStack (stackDepth, stack, memory) {
+    try {
       return await super.decodeFromStack(stackDepth, stack, memory)
+    } catch (e) {
+      console.log(e)
+      return '<decoding failed - ' + e.message + '>'
+    }
   }
 
   decodeFromMemoryInternal (offset, memory) {

src/solidity/types/Struct.js

@@ -16,7 +16,12 @@ class Struct extends RefType {
         offset: location.offset + item.storagelocation.offset,
         slot: util.add(location.slot, item.storagelocation.slot)
       }
+      try {
         ret[item.name] = await item.type.decodeFromStorage(globalLocation, storageResolver)
+      } catch (e) {
+        console.log(e)
+        ret[item.name] = '<decoding failed - ' + e.message + '>'
+      }
     }
     return {
       value: ret,

src/solidity/types/ValueType.js

@@ -17,11 +17,19 @@ class ValueType {
     * @return {Object} - decoded value
     */
   async decodeFromStorage (location, storageResolver) {
+    try {
       var value = await util.extractHexValue(location, storageResolver, this.storageBytes)
       return {
         value: this.decodeValue(value),
         type: this.typeName
       }
+    } catch (e) {
+      console.log(e)
+      return {
+        value: '<decoding failed - ' + e.message + '>',
+        type: this.typeName
+      }
+    }
   }
 
   /**

src/solidity/types/util.js

@@ -64,7 +64,13 @@ function extractHexByteSlice (slotValue, byteLength, offsetFromLSB) {
  * @param {Int} byteLength  - Length of the byte slice to extract
  */
 async function extractHexValue (location, storageResolver, byteLength) {
-  var slotvalue = await readFromStorage(location.slot, storageResolver)
+  var slotvalue
+  try {
+    slotvalue = await readFromStorage(location.slot, storageResolver)
+  } catch (e) {
+    console.log(e)
+    return '0x'
+  }
   return extractHexByteSlice(slotvalue, byteLength, location.offset)
 }