Merge branch 'liamaharon-feature/tuples'

Author: miguelmota

.gitignore

@@ -104,3 +104,5 @@ tmp
 
 # Files to ignore #
 #####################
+package-lock.json
+yarn.lock

.npmrc

@@ -0,0 +1 @@
+package-lock=false

README.md

@@ -90,6 +90,36 @@ web3.eth.getTransaction(txHash, (error, txResult) => {
 });
 ```
 
+### Decoding tuple and tuple[] types
+
+Where `OrderData` is
+
+```solidity
+struct OrderData {
+  uint256 amount;
+  address buyer;
+}
+```
+
+decoding input to a method `someMethod(address,OrderData,OrderData[])` returns data in format
+
+```js
+{
+  method: 'someMethod',
+  types: ['address', '(uint256,address)', '(uint256,address)[]'],
+  inputs: [
+    '0x81c55017F7Ce6E72451cEd49FF7bAB1e3DF64d0C',
+    [100, '0xA37dE6790861B5541b0dAa7d0C0e651F44c6f4D9']
+    [[274, '0xea674fdde714fd979de3edf0f56aa9716b898ec8']]
+  ],
+  names: ['sender', ['order', ['amount', 'buyer']], ['allOrders', ['amount', 'buyer']]]
+}
+```
+
+- In the `types` field, tuples are represented as a string containing types contained in the tuple
+- In the `inputs` field, tuples are represented as an array containing values contained in the tuple
+- In the `names` field, tuples are represented as an array with 2 items. Item 1 is the name of the tuple, item 2 is an array containing the names of the values contained in the tuple.
+
 ### Decoding Big Numbers
 
 All numbers are returned in [big number](https://github.com/indutny/bn.js) format to preserve precision.
@@ -213,7 +243,7 @@ npm test
 5. Run linter:
 
   ```bash
-  npm run lint:fix
+  npm run lint
   ```
 
 ## Contributing

dist/index.js

@@ -2,6 +2,8 @@
 
 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 var fs = require('fs');
@@ -98,16 +100,18 @@ var InputDataDecoder = function () {
         if (obj.type === 'event') return acc;
         var method = obj.name || null;
         var types = obj.inputs ? obj.inputs.map(function (x) {
-          if (x.type === 'tuple[]') {
+          if (x.type.includes('tuple')) {
             return x;
           } else {
             return x.type;
           }
         }) : [];
 
         var names = obj.inputs ? obj.inputs.map(function (x) {
-          if (x.type === 'tuple[]') {
-            return '';
+          if (x.type.includes('tuple')) {
+            return [x.name, x.components.map(function (a) {
+              return a.name;
+            })];
           } else {
             return x.name;
           }
@@ -122,15 +126,44 @@ var InputDataDecoder = function () {
             inputsBuf = normalizeAddresses(types, inputsBuf);
             inputs = ethabi.rawDecode(types, inputsBuf);
           } catch (err) {
-            // TODO: normalize addresses for tuples
             inputs = ethers.utils.defaultAbiCoder.decode(types, inputsBuf);
-
-            inputs = inputs[0];
+            // defaultAbiCoder attaches some unwanted properties to the list object
+            inputs = deepRemoveUnwantedArrayProperties(inputs);
+
+            // TODO: do this normalization into normalizeAddresses
+            inputs = inputs.map(function (input, i) {
+              if (types[i].components) {
+                var tupleTypes = types[i].components;
+                return deepStripTupleAddresses(input, tupleTypes);
+              }
+              if (types[i] === 'address') {
+                return input.split('0x')[1];
+              }
+              if (types[i] === 'address[]') {
+                return input.map(function (address) {
+                  return address.split('0x')[1];
+                });
+              }
+              return input;
+            });
           }
 
+          // Map any tuple types into arrays
+          var typesToReturn = types.map(function (t) {
+            if (t.components) {
+              var arr = t.components.reduce(function (acc, cur) {
+                return [].concat(_toConsumableArray(acc), [cur.type]);
+              }, []);
+              var tupleStr = '(' + arr.join(',') + ')';
+              if (t.type === 'tuple[]') return tupleStr + '[]';
+              return tupleStr;
+            }
+            return t;
+          });
+
           return {
             method: method,
-            types: types,
+            types: typesToReturn,
             inputs: inputs,
             names: names
           };
@@ -155,6 +188,33 @@ var InputDataDecoder = function () {
   return InputDataDecoder;
 }();
 
+// remove 0x from addresses
+
+
+function deepStripTupleAddresses(input, tupleTypes) {
+  return input.map(function (item, i) {
+    var type = tupleTypes[i].type;
+    if (type === 'address') {
+      console.log(item);
+      return item.split('0x')[1];
+    }
+    if (type === 'address[]') {
+      return item.map(function (a) {
+        return a.split('0x')[1];
+      });
+    }
+    return item;
+  });
+  console.log({ input: input, tupleTypes: tupleTypes });
+}
+
+function deepRemoveUnwantedArrayProperties(arr) {
+  return [].concat(_toConsumableArray(arr.map(function (item) {
+    if (Array.isArray(item)) return deepRemoveUnwantedArrayProperties(item);
+    return item;
+  })));
+}
+
 function normalizeAddresses(types, input) {
   var offset = 0;
   for (var i = 0; i < types.length; i++) {
@@ -190,11 +250,9 @@ function isArray(type) {
   return type.lastIndexOf(']') === type.length - 1;
 }
 
-function handleInputs(input) {
-  var tupleArray = false;
+function handleInputs(input, tupleArray) {
   if (input instanceof Object && input.components) {
     input = input.components;
-    tupleArray = true;
   }
 
   if (!Array.isArray(input)) {
@@ -219,11 +277,13 @@ function handleInputs(input) {
   if (tupleArray) {
     return ret + '[]';
   }
+
+  return ret;
 }
 
 function genMethodId(methodName, types) {
   var input = methodName + '(' + types.reduce(function (acc, x) {
-    acc.push(handleInputs(x));
+    acc.push(handleInputs(x, x.type === 'tuple[]'));
     return acc;
   }, []).join(',') + ')';
 

index.js

@@ -83,16 +83,16 @@ class InputDataDecoder {
       if (obj.type === 'event') return acc
       const method = obj.name || null
       let types = obj.inputs ? obj.inputs.map(x => {
-        if (x.type === 'tuple[]') {
+        if (x.type.includes('tuple')) {
           return x
         } else {
           return x.type
         }
       }) : []
 
       let names = obj.inputs ? obj.inputs.map(x => {
-        if (x.type === 'tuple[]') {
-          return ''
+        if (x.type.includes('tuple')) {
+          return [x.name, x.components.map(a => a.name)]
         } else {
           return x.name
         }
@@ -107,15 +107,40 @@ class InputDataDecoder {
           inputsBuf = normalizeAddresses(types, inputsBuf)
           inputs = ethabi.rawDecode(types, inputsBuf)
         } catch (err) {
-          // TODO: normalize addresses for tuples
           inputs = ethers.utils.defaultAbiCoder.decode(types, inputsBuf)
-
-          inputs = inputs[0]
+          // defaultAbiCoder attaches some unwanted properties to the list object
+          inputs = deepRemoveUnwantedArrayProperties(inputs)
+
+          // 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
+        })
+
         return {
           method,
-          types,
+          types: typesToReturn,
           inputs,
           names
         }
@@ -137,6 +162,27 @@ class InputDataDecoder {
   }
 }
 
+// remove 0x from addresses
+function deepStripTupleAddresses (input, tupleTypes) {
+  return input.map((item, i) => {
+    const type = tupleTypes[i].type
+    if (type === 'address' && typeof item === 'string') {
+      return item.split('0x')[1]
+    }
+    if (type === 'address[]' || Array.isArray()) {
+      return item.map(a => a.split('0x')[1])
+    }
+    return item
+  })
+}
+
+function deepRemoveUnwantedArrayProperties (arr) {
+  return [...arr.map(item => {
+    if (Array.isArray(item)) return deepRemoveUnwantedArrayProperties(item)
+    return item
+  })]
+}
+
 function normalizeAddresses (types, input) {
   let offset = 0
   for (let i = 0; i < types.length; i++) {
@@ -172,11 +218,9 @@ function isArray (type) {
   return type.lastIndexOf(']') === type.length - 1
 }
 
-function handleInputs (input) {
-  let tupleArray = false
+function handleInputs (input, tupleArray) {
   if (input instanceof Object && input.components) {
     input = input.components
-    tupleArray = true
   }
 
   if (!Array.isArray(input)) {
@@ -201,11 +245,13 @@ function handleInputs (input) {
   if (tupleArray) {
     return ret + '[]'
   }
+
+  return ret
 }
 
 function genMethodId (methodName, types) {
   const input = methodName + '(' + (types.reduce((acc, x) => {
-    acc.push(handleInputs(x))
+    acc.push(handleInputs(x, x.type === 'tuple[]'))
     return acc
   }, []).join(',')) + ')'
 

package.json

@@ -1,14 +1,13 @@
 {
   "name": "ethereum-input-data-decoder",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Ethereum smart contract transaction input data decoder",
   "main": "dist/index.js",
   "scripts": {
     "test": "tape ./test/index.js",
     "client": "browserify ./example/main.js -o ./example/bundle.js",
     "build": "babel index.js --presets babel-preset-es2015 --out-dir dist/",
-    "lint": "standard index.js test/*.js",
-    "lint:fix": "standard --fix index.js test/*.js",
+    "lint": "standard --fix index.js test/*.js",
     "prepublishOnly": "npm run lint:fix && npm run build"
   },
   "bin": {