refactor unitest

libs/remix-debug/test/decoder/contracts/calldata.ts

@@ -0,0 +1,13 @@
+'use strict'
+
+module.exports = {
+  contract: `
+contract calldataLocal {
+    constructor () public {     
+    }
+    
+    function level11(uint8[1] calldata foo, string[2][1] calldata boo) public {
+      
+    }
+  }
+`}

libs/remix-debug/test/decoder/localDecoder.ts

@@ -4,37 +4,40 @@ var compiler = require('solc')
 var intLocal = require('./contracts/intLocal')
 var miscLocal = require('./contracts/miscLocal')
 var structArrayLocal = require('./contracts/structArrayLocal')
+var calldataLocal = require('./contracts/calldata')
 var vmCall = require('./vmCall')
 var intLocalTest = require('./localsTests/int')
 var miscLocalTest = require('./localsTests/misc')
 var misc2LocalTest = require('./localsTests/misc2')
 var structArrayLocalTest = require('./localsTests/structArray')
+var calldataLocalTest = require('./localsTests/calldata')
 var compilerInput = require('../helpers/compilerHelper').compilerInput
 
 tape('solidity', function (t) {
   t.test('local decoder', async function (st) {
     var privateKey = Buffer.from('dae9801649ba2d95a21e688b56f77905e5667c44ce868ec83f82e838712a2c7a', 'hex')
     var vm = await vmCall.initVM(st, privateKey)
-    test(st, vm, privateKey)
+    await test(st, vm, privateKey)
   })
 })
 
-function test (st, vm, privateKey) {
+async function test (st, vm, privateKey) {
   var output = compiler.compile(compilerInput(intLocal.contract))
   output = JSON.parse(output)
-  intLocalTest(st, vm, privateKey, output.contracts['test.sol']['intLocal'].evm.bytecode.object, output, function () {
+  await intLocalTest(st, vm, privateKey, output.contracts['test.sol']['intLocal'].evm.bytecode.object, output)
   output = compiler.compile(compilerInput(miscLocal.contract))
   output = JSON.parse(output)
-    miscLocalTest(st, vm, privateKey, output.contracts['test.sol']['miscLocal'].evm.bytecode.object, output, function () {
+  await miscLocalTest(st, vm, privateKey, output.contracts['test.sol']['miscLocal'].evm.bytecode.object, output)
   output = compiler.compile(compilerInput(miscLocal.contract))
   output = JSON.parse(output)
-      misc2LocalTest(st, vm, privateKey, output.contracts['test.sol']['miscLocal2'].evm.bytecode.object, output, function () {
+  await misc2LocalTest(st, vm, privateKey, output.contracts['test.sol']['miscLocal2'].evm.bytecode.object, output)
   output = compiler.compile(compilerInput(structArrayLocal.contract))
   output = JSON.parse(output)
-        structArrayLocalTest(st, vm, privateKey, output.contracts['test.sol']['structArrayLocal'].evm.bytecode.object, output, function () {
+  await structArrayLocalTest(st, vm, privateKey, output.contracts['test.sol']['structArrayLocal'].evm.bytecode.object, output)
+
+  output = compiler.compile(compilerInput(calldataLocal.contract))
+  output = JSON.parse(output)
+  await calldataLocalTest(st, vm, privateKey, output.contracts['test.sol']['structArrayLocal'].evm.bytecode.object, output)
+
   st.end()
-        })
-      })
-    })
-  })
 }

libs/remix-debug/test/decoder/localsTests/calldata.ts

@@ -0,0 +1,133 @@
+'use strict'
+
+import { sendTx } from '../vmCall'
+import { TraceManager } from '../../../src/trace/traceManager'
+import { CodeManager } from '../../../src/code/codeManager'
+import { contractCreationToken } from '../../../src/trace/traceHelper'
+import { SolidityProxy } from '../../../src/solidity-decoder/solidityProxy'
+import { InternalCallTree } from '../../../src/solidity-decoder/internalCallTree'
+import { EventManager } from '../../../src/eventManager'
+import * as helper from './helper'
+
+module.exports = async function (st, vm, privateKey, contractBytecode, compilationResult) {
+  let txHash
+  try {
+    let data = await sendTx(vm, { nonce: 0, privateKey: privateKey }, null, 0, contractBytecode)
+    const to = (data as any).result.contractAddress
+    data = await sendTx(vm, { nonce: 0, privateKey: privateKey }, to, 0, '0xa372a595000000000000000000000000000000000000000000000000000000000000000900000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000006746573742031000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000067465737420320000000000000000000000000000000000000000000000000000') // call to level11
+    txHash = (data as any).hash
+  } catch (e) {
+    return st.fail(e)
+  }
+  return new Promise((resolve) => {    
+    vm.web3.eth.getTransaction(txHash, function (error, tx) {
+      if (error) {
+        return st.fail(error)
+      }
+      tx.to = contractCreationToken('0')
+      var traceManager = new TraceManager({ web3: vm.web3 })
+      var codeManager = new CodeManager(traceManager)
+      codeManager.clear()
+      var solidityProxy = new SolidityProxy({ getCurrentCalledAddressAt: traceManager.getCurrentCalledAddressAt.bind(traceManager), getCode: codeManager.getCode.bind(codeManager) })
+      solidityProxy.reset(compilationResult)
+      var debuggerEvent = new EventManager()
+      var callTree = new InternalCallTree(debuggerEvent, traceManager, solidityProxy, codeManager, { includeLocalVariables: true })
+      callTree.event.register('callTreeBuildFailed', (error) => {
+        st.fail(error)
+      })
+      callTree.event.register('callTreeNotReady', (reason) => {
+        st.fail(reason)
+      })
+      callTree.event.register('callTreeReady', (scopes, scopeStarts) => {
+        try {
+          let functions1 = callTree.retrieveFunctionsStack(102)
+          let functions2 = callTree.retrieveFunctionsStack(115)
+          let functions3 = callTree.retrieveFunctionsStack(13)
+
+          st.equals(functions1.length, 1)
+          st.equals(functions2.length, 2)
+          st.equals(functions3.length, 0)
+
+          st.equals(Object.keys(functions1[0])[0], 'functionDefinition')
+          st.equals(Object.keys(functions1[0])[1], 'inputs')
+          st.equals(functions1[0].inputs[0], 'foo')
+          st.equals(Object.keys(functions2[0])[0], 'functionDefinition')
+          st.equals(Object.keys(functions2[0])[1], 'inputs')
+          st.equals(Object.keys(functions2[1])[0], 'functionDefinition')
+          st.equals(Object.keys(functions2[1])[1], 'inputs')
+          st.equals(functions2[0].inputs[0], 'asd')
+          st.equals(functions2[1].inputs[0], 'foo')
+
+          st.equals(functions1[0].functionDefinition.name, 'level11')
+          st.equals(functions2[0].functionDefinition.name, 'level12')
+          st.equals(functions2[1].functionDefinition.name, 'level11')
+
+          st.equals(scopeStarts[0], '')
+          st.equals(scopeStarts[13], '1')
+          st.equals(scopeStarts[102], '2')
+          st.equals(scopeStarts[115], '2.1')
+          st.equals(scopeStarts[136], '3')
+          st.equals(scopeStarts[153], '4')
+          st.equals(scopeStarts[166], '4.1')
+          st.equals(scopes[''].locals['ui8'].type.typeName, 'uint8')
+          st.equals(scopes[''].locals['ui16'].type.typeName, 'uint16')
+          st.equals(scopes[''].locals['ui32'].type.typeName, 'uint32')
+          st.equals(scopes[''].locals['ui64'].type.typeName, 'uint64')
+          st.equals(scopes[''].locals['ui128'].type.typeName, 'uint128')
+          st.equals(scopes[''].locals['ui256'].type.typeName, 'uint256')
+          st.equals(scopes[''].locals['ui'].type.typeName, 'uint256')
+          st.equals(scopes[''].locals['i8'].type.typeName, 'int8')
+          st.equals(scopes[''].locals['i16'].type.typeName, 'int16')
+          st.equals(scopes[''].locals['i32'].type.typeName, 'int32')
+          st.equals(scopes[''].locals['i64'].type.typeName, 'int64')
+          st.equals(scopes[''].locals['i128'].type.typeName, 'int128')
+          st.equals(scopes[''].locals['i256'].type.typeName, 'int256')
+          st.equals(scopes[''].locals['i'].type.typeName, 'int256')
+          st.equals(scopes[''].locals['ishrink'].type.typeName, 'int32')
+          st.equals(scopes['2'].locals['ui8'].type.typeName, 'uint8')
+          st.equals(scopes['2.1'].locals['ui81'].type.typeName, 'uint8')
+          st.equals(scopes['3'].locals['ui81'].type.typeName, 'uint8')
+          st.equals(scopes['4'].locals['ui8'].type.typeName, 'uint8')
+          st.equals(scopes['4.1'].locals['ui81'].type.typeName, 'uint8')
+        } catch (e) {
+          st.fail(e.message)
+        }
+
+        helper.decodeLocals(st, 95, traceManager, callTree, function (locals) {
+          st.equals(Object.keys(locals).length, 16)
+          st.equals(locals['ui8'].value, '130')
+          st.equals(locals['ui16'].value, '456')
+          st.equals(locals['ui32'].value, '4356')
+          st.equals(locals['ui64'].value, '3543543543')
+          st.equals(locals['ui128'].value, '234567')
+          st.equals(locals['ui256'].value, '115792089237316195423570985008687907853269984665640564039457584007880697216513')
+          st.equals(locals['ui'].value, '123545666')
+          st.equals(locals['i8'].value, '-45')
+          st.equals(locals['i16'].value, '-1234')
+          st.equals(locals['i32'].value, '3455')
+          st.equals(locals['i64'].value, '-35566')
+          st.equals(locals['i128'].value, '-444444')
+          st.equals(locals['i256'].value, '3434343')
+          st.equals(locals['i'].value, '-32432423423')
+          st.equals(locals['ishrink'].value, '2')
+        })
+
+        helper.decodeLocals(st, 106, traceManager, callTree, function (locals) {
+          try {
+            st.equals(locals['ui8'].value, '123')
+            st.equals(Object.keys(locals).length, 2)
+          } catch (e) {
+            st.fail(e.message)
+          }
+          resolve({})
+        })
+      })
+      traceManager.resolveTrace(tx).then(() => {
+        debuggerEvent.trigger('newTraceLoaded', [traceManager.trace])
+      }).catch((error) => {
+        st.fail(error)
+      })
+    })
+  })  
+}
+

libs/remix-debug/test/decoder/localsTests/int.ts

@@ -9,11 +9,13 @@ import { InternalCallTree } from '../../../src/solidity-decoder/internalCallTree
 import { EventManager } from '../../../src/eventManager'
 import * as helper from './helper'
 
-module.exports = function (st, vm, privateKey, contractBytecode, compilationResult, cb) {
+module.exports = function (st, vm, privateKey, contractBytecode, compilationResult) {
-  sendTx(vm, { nonce: 0, privateKey: privateKey }, null, 0, contractBytecode, function (error, txHash) {
+  return new Promise((resolve) => {
+    sendTx(vm, { nonce: 0, privateKey: privateKey }, null, 0, contractBytecode, function (error, data) {      
       if (error) {
         return st.fail(error)
       }
+      const txHash = data.hash
       vm.web3.eth.getTransaction(txHash, function (error, tx) {
         if (error) {
           return st.fail(error)
@@ -113,7 +115,7 @@ module.exports = function (st, vm, privateKey, contractBytecode, compilationResu
             } catch (e) {
               st.fail(e.message)
             }
-          cb()
+            resolve({})
           })
         })
         traceManager.resolveTrace(tx).then(() => {
@@ -123,5 +125,6 @@ module.exports = function (st, vm, privateKey, contractBytecode, compilationResu
         })
       })
     })
+  })  
 }
 

libs/remix-debug/test/decoder/localsTests/misc.ts

@@ -8,11 +8,13 @@ import * as helper from './helper'
 import { TraceManager } from '../../../src/trace/traceManager'
 import { CodeManager } from '../../../src/code/codeManager'
 
-module.exports = function (st, vm, privateKey, contractBytecode, compilationResult, cb) {
+module.exports = function (st, vm, privateKey, contractBytecode, compilationResult) {
-  sendTx(vm, { nonce: 0, privateKey: privateKey }, null, 0, contractBytecode, function (error, txHash) {
+  return new Promise((resolve) => {
+    sendTx(vm, { nonce: 0, privateKey: privateKey }, null, 0, contractBytecode, function (error, data) {      
       if (error) {
         return st.fail(error)
       }
+      const txHash = data.hash
       vm.web3.eth.getTransaction(txHash, function (error, tx) {
         if (error) {
           return st.fail(error)
@@ -60,7 +62,7 @@ module.exports = function (st, vm, privateKey, contractBytecode, compilationResu
             } catch (e) {
               st.fail(e.message)
             }
-          cb()
+            resolve({})
           })
         })
         traceManager.resolveTrace(tx).then(() => {
@@ -70,4 +72,5 @@ module.exports = function (st, vm, privateKey, contractBytecode, compilationResu
         })
       })
     })
+  })  
 }

libs/remix-debug/test/decoder/localsTests/misc2.ts

@@ -8,11 +8,13 @@ import * as helper from './helper'
 import { TraceManager } from '../../../src/trace/traceManager'
 import { CodeManager } from '../../../src/code/codeManager'
 
-module.exports = function (st, vm, privateKey, contractBytecode, compilationResult, cb) {
+module.exports = function (st, vm, privateKey, contractBytecode, compilationResult) {
-  sendTx(vm, { nonce: 0, privateKey: privateKey }, null, 0, contractBytecode, function (error, txHash) {
+  return new Promise((resolve) => {
+    sendTx(vm, { nonce: 0, privateKey: privateKey }, null, 0, contractBytecode, function (error, data) {
       if (error) {
         return st.fail(error)
       }
+      const txHash = data.hash
       vm.web3.eth.getTransaction(txHash, function (error, tx) {
         if (error) {
           return st.fail(error)
@@ -46,7 +48,7 @@ module.exports = function (st, vm, privateKey, contractBytecode, compilationResu
             } catch (e) {
               st.fail(e.message)
             }
-          cb()
+            resolve({})
           })
         })
         traceManager.resolveTrace(tx).then(() => {
@@ -56,4 +58,5 @@ module.exports = function (st, vm, privateKey, contractBytecode, compilationResu
         })
       })
     })
+  })  
 }

libs/remix-debug/test/decoder/localsTests/structArray.ts

@@ -8,11 +8,13 @@ import * as helper from './helper'
 import { TraceManager } from '../../../src/trace/traceManager'
 import { CodeManager } from '../../../src/code/codeManager'
 
-module.exports = function (st, vm, privateKey, contractBytecode, compilationResult, cb) {
+module.exports = function (st, vm, privateKey, contractBytecode, compilationResult) {
-  sendTx(vm, { nonce: 0, privateKey: privateKey }, null, 0, contractBytecode, function (error, txHash) {
+  return new Promise((resolve) => {
+    sendTx(vm, { nonce: 0, privateKey: privateKey }, null, 0, contractBytecode, function (error, data) {
       if (error) {
         return st.fail(error)
       }
+      const txHash = data.hash
       vm.web3.eth.getTransaction(txHash, function (error, tx) {
         if (error) {
           return st.fail(error)
@@ -104,7 +106,7 @@ module.exports = function (st, vm, privateKey, contractBytecode, compilationResu
             } catch (e) {
               st.fail(e.message)
             }
-          cb()
+            resolve({})
           })
         })
         traceManager.resolveTrace(tx).then(() => {
@@ -114,4 +116,5 @@ module.exports = function (st, vm, privateKey, contractBytecode, compilationResu
         })
       })
     })
+  })  
 }

libs/remix-debug/test/decoder/stateTests/mapping.ts

@@ -12,11 +12,12 @@ module.exports = async function testMappingStorage (st, cb) {
   var vm = await initVM(st, privateKey)
   var output = compile(compilerInput(mappingStorage.contract))
   output = JSON.parse(output)
-  sendTx(vm, {nonce: 0, privateKey: privateKey}, null, 0, output.contracts['test.sol']['SimpleMappingState'].evm.bytecode.object, function (error, txHash) {
+  sendTx(vm, {nonce: 0, privateKey: privateKey}, null, 0, output.contracts['test.sol']['SimpleMappingState'].evm.bytecode.object, function (error, data) {
     if (error) {
       console.log(error)
       st.end(error)
     } else {
+      const txHash = data.hash
       vm.web3.eth.getTransaction(txHash, (error, tx) => {
         if (error) {
           console.log(error)
@@ -31,12 +32,12 @@ module.exports = async function testMappingStorage (st, cb) {
 
 function testMapping (st, vm, privateKey, contractAddress, output, cb) {
   sendTx(vm, {nonce: 1, privateKey: privateKey}, contractAddress, 0, '2fd0a83a00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000001074686973206973206120737472696e6700000000000000000000000000000000',
-        function (error, txHash) {
+        function (error, data) {
           if (error) {
             console.log(error)
             st.end(error)
           } else {
-            console.log(txHash)
+            const txHash = data.hash
             vm.web3.eth.getTransaction(txHash, (error, tx) => {
               if (error) {
                 console.log(error)

libs/remix-debug/test/decoder/vmCall.ts

@@ -6,7 +6,9 @@ import { vm as remixlibVM } from '@remix-project/remix-lib'
 import VM from '@ethereumjs/vm'
 import Common from '@ethereumjs/common'
 
-export function sendTx (vm, from, to, value, data, cb) {
+export function sendTx (vm, from, to, value, data, cb?) {
+  cb = cb || (() => {})
+  return new Promise ((resolve, reject) => {
     var tx = new Tx({
       nonce: new BN(from.nonce++),
       gasPrice: new BN(1),
@@ -27,15 +29,19 @@ export function sendTx (vm, from, to, value, data, cb) {
     try {
       vm.runTx({block: block, tx: tx, skipBalance: true, skipNonce: true}).then(function (result) {
         setTimeout(() => {
-        cb(null, bufferToHex(tx.hash()))
+          const hash = bufferToHex(tx.hash())
+          cb(null, { hash, result })
+          resolve({ hash, result })
         }, 500)
       }).catch((error) => {
         console.error(error)
         cb(error)
+        reject(error)
       })
     } catch (e) {
       console.error(e)
     }
+  })
 }
 
 async function createVm (hardfork) {