helpers erc updated

libs/remix-lib/src/helpers/compilerHelper.ts

-module.exports = {
-  compilerInput: compilerInput
-}
-
-function compilerInput (contracts) {
+export function compilerInput (contracts) {
   return JSON.stringify({
     language: 'Solidity',
     sources: {

libs/remix-lib/src/helpers/txResultHelper.ts

 'use strict'
-const { bufferToHex, isHexString } = require('ethereumjs-util')
+import { bufferToHex } from 'ethereumjs-util'
+import { isHexString } from 'ethjs-util'
 
 function convertToPrefixedHex (input) {
   if (input === undefined || input === null || isHexString(input)) {
@@ -19,7 +20,7 @@ function convertToPrefixedHex (input) {
  Also, VM results use BN and Buffers, Node results use hex strings/ints,
  So we need to normalize the values to prefixed hex strings
 */
-function resultToRemixTx (txResult) {
+export function resultToRemixTx (txResult) {
   const { result, transactionHash } = txResult
   const { status, execResult, gasUsed, createdAddress, contractAddress } = result
   let returnValue, errorMessage
@@ -40,7 +41,3 @@ function resultToRemixTx (txResult) {
     createdAddress: convertToPrefixedHex(createdAddress || contractAddress)
   }
 }
-
-module.exports = {
-  resultToRemixTx
-}

libs/remix-lib/src/helpers/uiHelper.ts

 'use strict'
-module.exports = {
-  formatMemory: function (mem, width) {
-    const ret = {}
-    if (!mem) {
-      return ret
-    }
+export function formatMemory (mem, width) {
+  const ret = {}
+  if (!mem) {
+    return ret
+  }
 
-    if (!mem.substr) {
-      mem = mem.join('') // geth returns an array, eth return raw string
-    }
+  if (!mem.substr) {
+    mem = mem.join('') // geth returns an array, eth return raw string
+  }
 
-    for (let k = 0; k < mem.length; k += (width * 2)) {
-      const memory = mem.substr(k, width * 2)
-      const content = this.tryConvertAsciiFormat(memory)
-      ret['0x' + (k / 2).toString(16)] = content.raw + '\t' + content.ascii
-    }
-    return ret
-  },
+  for (let k = 0; k < mem.length; k += (width * 2)) {
+    const memory = mem.substr(k, width * 2)
+    const content = this.tryConvertAsciiFormat(memory)
+    ret['0x' + (k / 2).toString(16)] = content.raw + '\t' + content.ascii
+  }
+  return ret
+}
 
-  tryConvertAsciiFormat: function (memorySlot) {
-    const ret = { ascii: '', raw: '' }
-    for (let k = 0; k < memorySlot.length; k += 2) {
-      const raw = memorySlot.substr(k, 2)
-      let ascii = String.fromCharCode(parseInt(raw, 16))
-      ascii = ascii.replace(/[^\w\s]/, '?')
-      if (ascii === '') {
-        ascii = '?'
-      }
-      ret.ascii += ascii
-      ret.raw += raw
+export function tryConvertAsciiFormat (memorySlot) {
+  const ret = { ascii: '', raw: '' }
+  for (let k = 0; k < memorySlot.length; k += 2) {
+    const raw = memorySlot.substr(k, 2)
+    let ascii = String.fromCharCode(parseInt(raw, 16))
+    ascii = ascii.replace(/[^\w\s]/, '?')
+    if (ascii === '') {
+      ascii = '?'
     }
-    return ret
-  },
+    ret.ascii += ascii
+    ret.raw += raw
+  }
+  return ret
+}
 
-  /**
-   * format @args css1, css2, css3 to css inline style
-   *
-   * @param {Object} css1 - css inline declaration
-   * @param {Object} css2 - css inline declaration
-   * @param {Object} css3 - css inline declaration
-   * @param {Object} ...
-   * @return {String} css inline style
-   *                  if the key start with * the value is direcly appended to the inline style (which should be already inline style formatted)
-   *                  used if multiple occurences of the same key is needed
-   */
-  formatCss: function (css1, css2) {
-    let ret = ''
-    for (let arg in arguments) {
-      for (let k in arguments[arg]) {
-        if (arguments[arg][k] && ret.indexOf(k) === -1) {
-          if (k.indexOf('*') === 0) {
-            ret += arguments[arg][k]
-          } else {
-            ret += k + ':' + arguments[arg][k] + ';'
-          }
+/**
+ * format @args css1, css2, css3 to css inline style
+ *
+ * @param {Object} css1 - css inline declaration
+ * @param {Object} css2 - css inline declaration
+ * @param {Object} css3 - css inline declaration
+ * @param {Object} ...
+ * @return {String} css inline style
+ *                  if the key start with * the value is direcly appended to the inline style (which should be already inline style formatted)
+ *                  used if multiple occurences of the same key is needed
+ */
+export function formatCss (css1, css2) {
+  let ret = ''
+  for (let arg in arguments) {
+    for (let k in arguments[arg]) {
+      if (arguments[arg][k] && ret.indexOf(k) === -1) {
+        if (k.indexOf('*') === 0) {
+          ret += arguments[arg][k]
+        } else {
+          ret += k + ':' + arguments[arg][k] + ';'
         }
       }
     }
-    return ret
-  },
+  }
+  return ret
+}
 
-  normalizeHex: function (hex) {
-    if (hex.indexOf('0x') === 0) {
-      hex = hex.replace('0x', '')
-    }
-    hex = hex.replace(/^0+/, '')
-    return '0x' + hex
-  },
+export function normalizeHex (hex) {
+  if (hex.indexOf('0x') === 0) {
+    hex = hex.replace('0x', '')
+  }
+  hex = hex.replace(/^0+/, '')
+  return '0x' + hex
+}
 
-  normalizeHexAddress: function (hex) {
-    if (hex.indexOf('0x') === 0) hex = hex.replace('0x', '')
-    if (hex.length >= 40) {
-      const reg = /(.{40})$/.exec(hex)
-      if (reg) {
-        return '0x' + reg[0]
-      }
-    } else {
-      return '0x' + (new Array(40 - hex.length + 1).join('0')) + hex
+export function normalizeHexAddress (hex) {
+  if (hex.indexOf('0x') === 0) hex = hex.replace('0x', '')
+  if (hex.length >= 40) {
+    const reg = /(.{40})$/.exec(hex)
+    if (reg) {
+      return '0x' + reg[0]
     }
-  },
-
-  runInBrowser: function () {
-    return typeof window !== 'undefined'
+  } else {
+    return '0x' + (new Array(40 - hex.length + 1).join('0')) + hex
   }
 }
+
+export function runInBrowser () {
+  return typeof window !== 'undefined'
+}