ContractController to run contract functions and compiling refactoring

Author: fergarrui

src/api/bytecode/EVMDisassembler.test.ts

@@ -1,14 +1,14 @@
 import 'reflect-metadata'
 import { Disassembler } from './Disassembler'
-import { EVMDisassembler } from './EVMDisassembler'
 import { DisassembledContract } from './DisassembledContract'
+import { createEVMDisassembler } from '../symbolic/evm/exec/TestUtils';
 let BN = require('bn.js')
 
 describe('Disassembler test', () => {
   let disass: Disassembler
 
   beforeEach(() => {
-    disass = new EVMDisassembler()
+    disass = createEVMDisassembler()
   })
 
   it('Test disassembler bytecode', async () => {

src/api/bytecode/EVMDisassembler.ts

@@ -1,41 +1,40 @@
 import { Disassembler } from './Disassembler'
 import { Operation } from './Operation'
 import { Opcodes } from './Opcodes'
-import { injectable } from 'inversify'
+import { injectable, inject } from 'inversify'
 import { Opcode } from './Opcode'
 import { DisassembledContract } from './DisassembledContract'
 import { logger } from '../../Logger';
+import { TYPES } from '../../inversify/types';
+import { ContractService } from '../service/service/ContractService';
 let BN = require('bn.js')
-let solc = require('solc')
-let fs = require('fs')
-let nodePath = require('path')
+
 
 @injectable()
 export class EVMDisassembler implements Disassembler {
   static readonly metadataPrefix = 'a165627a7a72305820'
 
-  constructor() {}
+  constructor(
+    @inject(TYPES.ContractService) private contractService: ContractService
+  ) {}
 
   disassembleSourceCode(contractName: string, source: string, path: string): DisassembledContract {
     if (source.startsWith('0x')) {
       return this.disassembleContract(source)
     }
-    const compileJson = this.generateCompileObject(contractName, source, path)
-    const compiledContract = JSON.parse(solc.compileStandardWrapper(JSON.stringify(compileJson)))
-    const contractWithExt = `${contractName}.sol`
-    const contract = compiledContract.contracts[contractWithExt][contractName]
-    if (!contract) {
-      throw new Error('Bad source code')
-    }
+    
+    const contract = this.contractService.compileContract(contractName, source, path)
+
+
     const bytecode = contract.evm.bytecode.object
-    const runtimeBytecode = compiledContract.contracts[contractWithExt][contractName].evm.deployedBytecode.object
-    const contractAssembly = compiledContract.contracts[contractWithExt][contractName].evm.legacyAssembly
+    const runtimeBytecode = contract.evm.deployedBytecode.object
+    const contractAssembly = contract.evm.legacyAssembly
     if (!contractAssembly) {
-      logger.error(JSON.stringify(compiledContract))
+      logger.error(JSON.stringify(contract))
       throw new Error(`No code found in contract ${contractName}`)
     }
     const asmRuntime = contractAssembly['.data'][0]['.code'].filter(elem => elem.name !== 'tag')
-    const asmConstructor = compiledContract.contracts[contractWithExt][contractName].evm.legacyAssembly['.code'].filter(
+    const asmConstructor = contract.evm.legacyAssembly['.code'].filter(
       elem => elem.name !== 'tag'
     )
     const disassembledCode: DisassembledContract = this.disassembleContract(bytecode)
@@ -164,75 +163,7 @@ export class EVMDisassembler implements Disassembler {
     } as Operation
   }
 
-  private findImports(sources: any, content: string, path: string, filesChecked: string[], initialPath: string) {
-    const regexp = /import "(.*)"|import '(.*)'/g
-    const match = content.match(regexp)
-    if (!match) {
-      return
-    }
-    const matches = match.map(imp => {
-      const splittedImp = imp.split('"')
-      if (splittedImp.length < 2) {
-        return imp.split("'")[1]
-      } else {
-        return splittedImp[1]
-      }
-    })
-
-    for (const imp of matches) {
-      let importFilePath = path
-      if (!importFilePath.endsWith(nodePath.sep)) {
-        importFilePath = importFilePath + nodePath.sep
-      }
-      importFilePath = nodePath.normalize(importFilePath + imp)
-      const importPathRelative = nodePath
-        .relative(initialPath, importFilePath)
-        .replace('./', '')
-        .replace('../', '')
-        .replace(/^\./, '')
-
-      const importContent = fs.readFileSync(importFilePath).toString()
-      let sourceFileName = imp.replace('./', '').replace('../', '')
-      if (sourceFileName.startsWith('.')) {
-        sourceFileName = sourceFileName.substr(1, sourceFileName.length)
-      }
-      if (filesChecked.includes(importPathRelative)) {
-        continue
-      }
-      filesChecked.push(importPathRelative)
-      sources[importPathRelative] = {
-        content: importContent
-      }
-      this.findImports(
-        sources,
-        importContent,
-        nodePath.normalize(nodePath.dirname(importFilePath)),
-        filesChecked,
-        initialPath
-      )
-    }
-  }
 
-  private generateCompileObject(contractName: string, content: string, path: string) {
-    const sources = {}
-    sources[`${contractName}.sol`] = {
-      content: content
-    }
-    const filesChecked = []
-    this.findImports(sources, content, path, filesChecked, path)
-    const compileJson = {
-      language: 'Solidity',
-      sources,
-      settings: {
-        outputSelection: {
-          '*': {
-            '*': ['evm.bytecode', 'evm.legacyAssembly', 'evm.deployedBytecode']
-          }
-        }
-      }
-    }
-    return compileJson
-  }
 
   private isPush(opcode: Opcode): boolean {
     return opcode.name.startsWith('PUSH')

src/api/cfg/EthereumCFGCreator.test.ts

@@ -5,6 +5,7 @@ import { Disassembler } from '../bytecode/Disassembler'
 import { Operation } from '../bytecode/Operation'
 import { Opcodes } from '../bytecode/Opcodes'
 import { CFGBlocks } from './CFGBlocks'
+import { createEVMDisassembler } from '../symbolic/evm/exec/TestUtils';
 let BN = require('bn.js')
 
 describe('EthereumCFGCreator', () => {
@@ -13,7 +14,7 @@ describe('EthereumCFGCreator', () => {
 
   beforeEach(() => {
     cfgCreator = new EthereumCFGCreator()
-    disassembler = new EVMDisassembler()
+    disassembler = createEVMDisassembler()
   })
 
   it('Test blocks correctly created, no jumps', () => {

src/api/cfg/GraphVizService.test.ts

@@ -1,9 +1,8 @@
 import { EthereumCFGCreator } from './EthereumCFGCreator'
 import { Disassembler } from '../bytecode/Disassembler'
 import { OpcodeExecutor } from '../symbolic/evm/exec/OpcodeExecutor'
-import { EVMDisassembler } from '../bytecode/EVMDisassembler'
 import { EVMExecutor } from '../symbolic/evm/EVMExecutor'
-import { createExecutor } from '../symbolic/evm/exec/TestUtils'
+import { createExecutor, createEVMDisassembler } from '../symbolic/evm/exec/TestUtils'
 import { GraphVizService } from './GraphVizService'
 
 describe('GraphVizService', () => {
@@ -14,7 +13,7 @@ describe('GraphVizService', () => {
 
   beforeEach(() => {
     cfgCreator = new EthereumCFGCreator()
-    disassembler = new EVMDisassembler()
+    disassembler = createEVMDisassembler()
     graph = new GraphVizService()
   })
 

src/api/service/controller/ContractController.ts

@@ -0,0 +1,69 @@
+import { Route, Controller, Get, Query, Post, Path, Body } from 'tsoa'
+import { provideSingleton, inject } from '../../../inversify/ioc';
+import { TYPES } from '../../../inversify/types';
+import { ContractService } from '../service/ContractService';
+import { logger } from '../../../Logger';
+import { RunContractFunctionRequest } from '../request/RunContractFunctionRequest';
+import { IWeb3 } from '../../blockchain/IWeb3';
+import { Web3Instance } from '../../blockchain/Web3Instance';
+import { Web3Configuration } from '../../blockchain/Web3Configuration';
+
+@Route('contract')
+@provideSingleton(ContractController)
+export class ContractController extends Controller {
+
+  constructor(
+    @inject(TYPES.ContractService) private contractService: ContractService,
+  ) {
+    super()
+  }
+
+  @Get('abi')
+  async getAbi(
+    @Query('source') source: string,
+    @Query('name') name: string,
+    @Query('path') path: string
+  ){
+    try {
+      const abi = this.contractService.getAbi(name, source, path)
+      if (!abi) {
+        throw new Error(`No abi found for contract ${name}`)
+      }
+      return abi
+    } catch (err) {
+      logger.error(err)
+      throw new Error(err.message)
+    }
+  }
+
+  @Post('run/{contractAddress}')
+  async run(
+    @Path() contractAddress: string,
+    @Body() runFunction: RunContractFunctionRequest,
+    @Query('blockchainHost') blockchainHost?: string,
+    @Query('blockchainProtocol') blockchainProtocol?: string,
+    @Query('blockchainBasicAuthUsername') blockchainBasicAuthUsername?: string,
+    @Query('blockchainBasicAuthPassword') blockchainBasicAuthPassword?: string
+  )
+  {
+    const config = {
+      blockchainHost,
+      blockchainProtocol,
+      blockchainBasicAuthUsername,
+      blockchainBasicAuthPassword
+    } as Web3Configuration
+    const iWeb3: IWeb3 = new Web3Instance(config)
+    const web3 = iWeb3.getInstance()
+    const functionCallEncoded = web3.eth.abi.encodeFunctionCall(runFunction.abi, runFunction.params)
+    const accounts = await web3.eth.getAccounts()
+    const receipt = await web3.eth.sendTransaction({
+      to: contractAddress,
+      from: runFunction.from || accounts[0],
+      gas: runFunction.gas,
+      gasPrice: runFunction.gasPrice,
+      value: runFunction.value,
+      input: functionCallEncoded
+    })
+    return receipt
+  }
+}

src/api/service/request/RunContractFunctionRequest.ts

@@ -0,0 +1,8 @@
+export interface RunContractFunctionRequest {
+  abi: any
+  params: string[],
+  from?: string,
+  gas?: number,
+  gasPrice?: number,
+  value?: number
+}

src/api/service/service/ContractService.ts

@@ -0,0 +1,93 @@
+import { injectable } from "inversify";
+let solc = require('solc')
+let fs = require('fs')
+let nodePath = require('path')
+
+@injectable()
+export class ContractService {
+
+  getAbi(contractName: string, source: string, path: string) {
+    const contract = this.compileContract(contractName, source, path)
+    return contract.abi
+  }
+
+  compileContract(contractName: string, source: string, path: string) {
+    const compileJson = this.generateCompileObject(contractName, source, path)
+    const compiledContract = JSON.parse(solc.compileStandardWrapper(JSON.stringify(compileJson)))
+    const contractWithExt = `${contractName}.sol`
+    const contract = compiledContract.contracts[contractWithExt][contractName]
+    if (!contract) {
+      throw new Error('Bad source code')
+    }
+    return contract
+  }
+
+  private generateCompileObject(contractName: string, content: string, path: string) {
+    const sources = {}
+    sources[`${contractName}.sol`] = {
+      content: content
+    }
+    const filesChecked = []
+    this.findImports(sources, content, path, filesChecked, path)
+    const compileJson = {
+      language: 'Solidity',
+      sources,
+      settings: {
+        outputSelection: {
+          '*': {
+            '*': ['evm.bytecode', 'evm.legacyAssembly', 'evm.deployedBytecode', "abi"]
+          }
+        }
+      }
+    }
+    return compileJson
+  }
+  private findImports(sources: any, content: string, path: string, filesChecked: string[], initialPath: string) {
+    const regexp = /import "(.*)"|import '(.*)'/g
+    const match = content.match(regexp)
+    if (!match) {
+      return
+    }
+    const matches = match.map(imp => {
+      const splittedImp = imp.split('"')
+      if (splittedImp.length < 2) {
+        return imp.split("'")[1]
+      } else {
+        return splittedImp[1]
+      }
+    })
+
+    for (const imp of matches) {
+      let importFilePath = path
+      if (!importFilePath.endsWith(nodePath.sep)) {
+        importFilePath = importFilePath + nodePath.sep
+      }
+      importFilePath = nodePath.normalize(importFilePath + imp)
+      const importPathRelative = nodePath
+        .relative(initialPath, importFilePath)
+        .replace('./', '')
+        .replace('../', '')
+        .replace(/^\./, '')
+
+      const importContent = fs.readFileSync(importFilePath).toString()
+      let sourceFileName = imp.replace('./', '').replace('../', '')
+      if (sourceFileName.startsWith('.')) {
+        sourceFileName = sourceFileName.substr(1, sourceFileName.length)
+      }
+      if (filesChecked.includes(importPathRelative)) {
+        continue
+      }
+      filesChecked.push(importPathRelative)
+      sources[importPathRelative] = {
+        content: importContent
+      }
+      this.findImports(
+        sources,
+        importContent,
+        nodePath.normalize(nodePath.dirname(importFilePath)),
+        filesChecked,
+        initialPath
+      )
+    }
+  }
+}

src/api/service/service/StorageRecover.ts

@@ -6,7 +6,6 @@ import { Web3Configuration } from "../../blockchain/Web3Configuration";
 import { TransactionReceipt } from "../bean/TransactionReceipt";
 import { TransactionService } from "./TransactionService";
 import { Storage } from "../bean/Storage"
-import { IWeb3 } from "../../blockchain/IWeb3";
 import { Transaction } from "../bean/Transaction";
 
 @injectable()

src/api/symbolic/evm/EVMExecutor.test.ts

@@ -5,7 +5,7 @@ import { Disassembler } from '../../bytecode/Disassembler'
 import { EVMDisassembler } from '../../bytecode/EVMDisassembler'
 import { OpcodeExecutor } from './exec/OpcodeExecutor'
 import { Word } from './Word'
-import { createExecutor } from './exec/TestUtils'
+import { createExecutor, createEVMDisassembler } from './exec/TestUtils'
 import { DisassembledContract } from '../../bytecode/DisassembledContract'
 
 describe('EVMExecutor', () => {
@@ -15,7 +15,7 @@ describe('EVMExecutor', () => {
 
   beforeEach(() => {
     cfgCreator = new EthereumCFGCreator()
-    disassembler = new EVMDisassembler()
+    disassembler = createEVMDisassembler()
   })
 
   it('Test simple PUSH execution', () => {