output parser string support

dist/ethereum.js

@@ -158,6 +158,7 @@ var toAbiInput = function (json, methodName, params) {
     var method = json[index];
     var padding = ETH_PADDING * 2;
 
+    /// first we iterate in search for dynamic 
     method.inputs.forEach(function (input, index) {
         bytes += dynamicTypeBytes(input.type, params[index]);
     });
@@ -186,13 +187,9 @@ var toAbiInput = function (json, methodName, params) {
     return bytes;
 };
 
-/// Setups output formaters for solidity types
-/// @returns an array of output formatters
-var setupOutputTypes = function () {
-
 /// Formats input right-aligned input bytes to int
 /// @returns right-aligned input bytes formatted to int
-    var formatInt = function (value) {
+var formatOutputInt = function (value) {
     // check if it's negative number
     // it it is, return two's complement
     var firstBit = new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1);
@@ -204,39 +201,49 @@ var setupOutputTypes = function () {
 
 /// Formats big right-aligned input bytes to uint
 /// @returns right-aligned input bytes formatted to uint
-    var formatUInt = function (value) {
+var formatOutputUInt = function (value) {
     return new BigNumber(value, 16);
 };
 
 /// @returns right-aligned input bytes formatted to hex
-    var formatHash = function (value) {
+var formatOutputHash = function (value) {
     return "0x" + value;
 };
 
 /// @returns right-aligned input bytes formatted to bool
-    var formatBool = function (value) {
+var formatOutputBool = function (value) {
     return value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
 };
 
 /// @returns left-aligned input bytes formatted to ascii string
-    var formatString = function (value) {
+var formatOutputString = function (value) {
     return web3.toAscii(value);
 };
 
 /// @returns right-aligned input bytes formatted to address
-    var formatAddress = function (value) {
+var formatOutputAddress = function (value) {
     return "0x" + value.slice(value.length - 40, value.length);
 };
 
+var dynamicBytesLength = function (type) {
+    if (arrayType(type) || prefixedType('string')(type))
+        return ETH_PADDING * 2;
+    return 0;
+};
+
+/// Setups output formaters for solidity types
+/// @returns an array of output formatters
+var setupOutputTypes = function () {
+
     return [
-        { type: prefixedType('uint'), format: formatUInt },
+        { type: prefixedType('uint'), format: formatOutputUInt },
-        { type: prefixedType('int'), format: formatInt },
+        { type: prefixedType('int'), format: formatOutputInt },
-        { type: prefixedType('hash'), format: formatHash },
+        { type: prefixedType('hash'), format: formatOutputHash },
-        { type: prefixedType('string'), format: formatString },
+        { type: prefixedType('string'), format: formatOutputString },
-        { type: prefixedType('real'), format: formatInt },
+        { type: prefixedType('real'), format: formatOutputInt },
-        { type: prefixedType('ureal'), format: formatInt },
+        { type: prefixedType('ureal'), format: formatOutputInt },
-        { type: namedType('address'), format: formatAddress },
+        { type: namedType('address'), format: formatOutputAddress },
-        { type: namedType('bool'), format: formatBool }
+        { type: namedType('bool'), format: formatOutputBool }
     ];
 };
 
@@ -259,22 +266,44 @@ var fromAbiOutput = function (json, methodName, output) {
     var result = [];
     var method = json[index];
     var padding = ETH_PADDING * 2;
-    for (var i = 0; i < method.outputs.length; i++) {
+
+    var dynamicPartLength = method.outputs.reduce(function (acc, curr) {
+        return acc + dynamicBytesLength(curr.type);
+    }, 0);
+    
+    var dynamicPart = output.slice(0, dynamicPartLength);
+    output = output.slice(dynamicPartLength);
+
+    method.outputs.forEach(function (out, i) {
         var typeMatch = false;
         for (var j = 0; j < outputTypes.length && !typeMatch; j++) {
             typeMatch = outputTypes[j].type(method.outputs[i].type);
         }
 
         if (!typeMatch) {
-            // not found output parsing
             console.error('output parser does not support type: ' + method.outputs[i].type);
-            continue;
         }
-        var res = output.slice(0, padding);
+
         var formatter = outputTypes[j - 1].format;
-        result.push(formatter ? formatter(res) : ("0x" + res));
+        if (arrayType(method.outputs[i].type)) {
+            var size = formatOutputUInt(dynamicPart.slice(0, padding));
+            dynamicPart = dynamicPart.slice(padding);
+            var array = [];
+            for (var k = 0; k < size; k++) {
+                array.push(formatter(output.slice(0, padding))); 
                 output = output.slice(padding);
             }
+            result.push(array);
+        }
+        else if (prefixedType('string')(method.outputs[i].type)) {
+            dynamicPart = dynamicPart.slice(padding); 
+            result.push(formatter(output.slice(0, padding)));
+            output = output.slice(padding);
+        } else {
+            result.push(formatter(output.slice(0, padding)));
+            output = output.slice(padding);
+        }
+    });
 
     return result;
 };

lib/abi.js

@@ -186,13 +186,9 @@ var toAbiInput = function (json, methodName, params) {
     return bytes;
 };
 
-/// Setups output formaters for solidity types
-/// @returns an array of output formatters
-var setupOutputTypes = function () {
-
 /// Formats input right-aligned input bytes to int
 /// @returns right-aligned input bytes formatted to int
-    var formatInt = function (value) {
+var formatOutputInt = function (value) {
     // check if it's negative number
     // it it is, return two's complement
     var firstBit = new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1);
@@ -204,39 +200,49 @@ var setupOutputTypes = function () {
 
 /// Formats big right-aligned input bytes to uint
 /// @returns right-aligned input bytes formatted to uint
-    var formatUInt = function (value) {
+var formatOutputUInt = function (value) {
     return new BigNumber(value, 16);
 };
 
 /// @returns right-aligned input bytes formatted to hex
-    var formatHash = function (value) {
+var formatOutputHash = function (value) {
     return "0x" + value;
 };
 
 /// @returns right-aligned input bytes formatted to bool
-    var formatBool = function (value) {
+var formatOutputBool = function (value) {
     return value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
 };
 
 /// @returns left-aligned input bytes formatted to ascii string
-    var formatString = function (value) {
+var formatOutputString = function (value) {
     return web3.toAscii(value);
 };
 
 /// @returns right-aligned input bytes formatted to address
-    var formatAddress = function (value) {
+var formatOutputAddress = function (value) {
     return "0x" + value.slice(value.length - 40, value.length);
 };
 
+var dynamicBytesLength = function (type) {
+    if (arrayType(type) || prefixedType('string')(type))
+        return ETH_PADDING * 2;
+    return 0;
+};
+
+/// Setups output formaters for solidity types
+/// @returns an array of output formatters
+var setupOutputTypes = function () {
+
     return [
-        { type: prefixedType('uint'), format: formatUInt },
+        { type: prefixedType('uint'), format: formatOutputUInt },
-        { type: prefixedType('int'), format: formatInt },
+        { type: prefixedType('int'), format: formatOutputInt },
-        { type: prefixedType('hash'), format: formatHash },
+        { type: prefixedType('hash'), format: formatOutputHash },
-        { type: prefixedType('string'), format: formatString },
+        { type: prefixedType('string'), format: formatOutputString },
-        { type: prefixedType('real'), format: formatInt },
+        { type: prefixedType('real'), format: formatOutputInt },
-        { type: prefixedType('ureal'), format: formatInt },
+        { type: prefixedType('ureal'), format: formatOutputInt },
-        { type: namedType('address'), format: formatAddress },
+        { type: namedType('address'), format: formatOutputAddress },
-        { type: namedType('bool'), format: formatBool }
+        { type: namedType('bool'), format: formatOutputBool }
     ];
 };
 
@@ -259,22 +265,44 @@ var fromAbiOutput = function (json, methodName, output) {
     var result = [];
     var method = json[index];
     var padding = ETH_PADDING * 2;
-    for (var i = 0; i < method.outputs.length; i++) {
+
+    var dynamicPartLength = method.outputs.reduce(function (acc, curr) {
+        return acc + dynamicBytesLength(curr.type);
+    }, 0);
+    
+    var dynamicPart = output.slice(0, dynamicPartLength);
+    output = output.slice(dynamicPartLength);
+
+    method.outputs.forEach(function (out, i) {
         var typeMatch = false;
         for (var j = 0; j < outputTypes.length && !typeMatch; j++) {
             typeMatch = outputTypes[j].type(method.outputs[i].type);
         }
 
         if (!typeMatch) {
-            // not found output parsing
             console.error('output parser does not support type: ' + method.outputs[i].type);
-            continue;
         }
-        var res = output.slice(0, padding);
+
         var formatter = outputTypes[j - 1].format;
-        result.push(formatter ? formatter(res) : ("0x" + res));
+        if (arrayType(method.outputs[i].type)) {
+            var size = formatOutputUInt(dynamicPart.slice(0, padding));
+            dynamicPart = dynamicPart.slice(padding);
+            var array = [];
+            for (var k = 0; k < size; k++) {
+                array.push(formatter(output.slice(0, padding))); 
                 output = output.slice(padding);
             }
+            result.push(array);
+        }
+        else if (prefixedType('string')(method.outputs[i].type)) {
+            dynamicPart = dynamicPart.slice(padding); 
+            result.push(formatter(output.slice(0, padding)));
+            output = output.slice(padding);
+        } else {
+            result.push(formatter(output.slice(0, padding)));
+            output = output.slice(padding);
+        }
+    });
 
     return result;
 };

test/abi.parsers.js

@@ -396,8 +396,18 @@ describe('abi', function() {
             var parser = abi.outputParser(d);
             
             // then
-            assert.equal(parser.test("0x68656c6c6f000000000000000000000000000000000000000000000000000000")[0], 'hello');
+            assert.equal(
-            assert.equal(parser.test("0x776f726c64000000000000000000000000000000000000000000000000000000")[0], 'world');
+                parser.test("0x" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
+                'hello'
+                );
+            assert.equal(
+                parser.test("0x" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "776f726c64000000000000000000000000000000000000000000000000000000")[0], 
+                'world'
+                );
 
         });
 
@@ -644,12 +654,21 @@ describe('abi', function() {
 
             // then
             assert.equal(
-                parser.test("0x68656c6c6f000000000000000000000000000000000000000000000000000000776f726c64000000000000000000000000000000000000000000000000000000")[0],
+                parser.test("0x" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000" + 
+                    "776f726c64000000000000000000000000000000000000000000000000000000")[0],
                 'hello'
                 );
             assert.equal(
-                parser.test("0x68656c6c6f000000000000000000000000000000000000000000000000000000776f726c64000000000000000000000000000000000000000000000000000000")[1], 
+                parser.test("0x" +
-                'world');
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000" + 
+                    "776f726c64000000000000000000000000000000000000000000000000000000")[1],
+                'world'
+                );
 
         });
         
@@ -689,7 +708,11 @@ describe('abi', function() {
 
             //then
             assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-            assert.equal(parser.test2("0x68656c6c6f000000000000000000000000000000000000000000000000000000")[0], "hello");
+            assert.equal(parser.test2("0x" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
+                "hello"
+                );
 
         });