ethereum-web-token/dist/decoder/decoder.js

EWT bundles Ethereum function-calls into [JWT](https://jwt.io/)-like tokens. It simplifies the use of ECDSA signatures for webapps and the development of [Smart Oracles](https://github.com/codius/codius/wiki/Smart-Oracles:-A-Simple,-Powerful-Approach-to-S

'use strict';Object.defineProperty(exports, "__esModule", { value: true });var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);var _createClass2 = require('babel-runtime/helpers/createClass');var _createClass3 = _interopRequireDefault(_createClass2);var _utf = require('utf8');var _utf2 = _interopRequireDefault(_utf);

var _token = require('../token/token');var _token2 = _interopRequireDefault(_token);
var _bytesTaken = require('./bytesTaken');var _bytesTaken2 = _interopRequireDefault(_bytesTaken);
var _decodeResult = require('./decodeResult');var _decodeResult2 = _interopRequireDefault(_decodeResult);
var _paramType = require('../spec/paramType/paramType');var _paramType2 = _interopRequireDefault(_paramType);
var _slice = require('../util/slice');
var _sliceAs = require('../util/sliceAs');
var _types = require('../util/types');function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };}var

Decoder = function () {function Decoder() {(0, _classCallCheck3.default)(this, Decoder);}(0, _createClass3.default)(Decoder, null, [{ key: 'decode', value: function decode(
    params, data) {
      if (!(0, _types.isArray)(params)) {
        throw new Error('Parameters should be array of ParamType');
      }

      var slices = (0, _slice.sliceData)(data);
      var offset = 0;

      return params.map(function (param) {
        var result = Decoder.decodeParam(param, slices, offset);
        offset = result.newOffset;
        return result.token;
      });
    } }, { key: 'peek', value: function peek(

    slices, position) {
      if (!slices || !slices[position]) {
        throw new Error('Invalid position ' + position + ' in slices peek');
      }

      return slices[position];
    } }, { key: 'takeBytes', value: function takeBytes(

    slices, position, length) {
      var slicesLength = Math.floor((length + 31) / 32);
      var bytesStr = '';

      for (var idx = 0; idx < slicesLength; idx++) {
        bytesStr = '' + bytesStr + Decoder.peek(slices, position + idx);
      }

      var bytes = bytesStr.substr(0, length * 2).match(/.{1,2}/g).map(function (code) {return parseInt(code, 16);});

      return new _bytesTaken2.default(bytes, position + slicesLength);
    } }, { key: 'decodeParam', value: function decodeParam(

    param, slices, offset) {
      if (!(0, _types.isInstanceOf)(param, _paramType2.default)) {
        throw new Error('param should be instanceof ParamType');
      }

      var tokens = [];
      var taken = void 0;
      var lengthOffset = void 0;
      var length = void 0;
      var newOffset = void 0;

      switch (param.type) {
        case 'address':
          return new _decodeResult2.default(new _token2.default(param.type, (0, _sliceAs.asAddress)(Decoder.peek(slices, offset))), offset + 1);

        case 'bool':
          return new _decodeResult2.default(new _token2.default(param.type, (0, _sliceAs.asBool)(Decoder.peek(slices, offset))), offset + 1);

        case 'int':
          return new _decodeResult2.default(new _token2.default(param.type, (0, _sliceAs.asI32)(Decoder.peek(slices, offset))), offset + 1);

        case 'uint':
          return new _decodeResult2.default(new _token2.default(param.type, (0, _sliceAs.asU32)(Decoder.peek(slices, offset))), offset + 1);

        case 'fixedBytes':
          taken = Decoder.takeBytes(slices, offset, param.length);

          return new _decodeResult2.default(new _token2.default(param.type, taken.bytes), taken.newOffset);

        case 'bytes':
          lengthOffset = (0, _sliceAs.asU32)(Decoder.peek(slices, offset)).div(32).toNumber();
          length = (0, _sliceAs.asU32)(Decoder.peek(slices, lengthOffset)).toNumber();
          taken = Decoder.takeBytes(slices, lengthOffset + 1, length);

          return new _decodeResult2.default(new _token2.default(param.type, taken.bytes), offset + 1);

        case 'string':
          lengthOffset = (0, _sliceAs.asU32)(Decoder.peek(slices, offset)).div(32).toNumber();
          length = (0, _sliceAs.asU32)(Decoder.peek(slices, lengthOffset)).toNumber();
          taken = Decoder.takeBytes(slices, lengthOffset + 1, length);

          var str = taken.bytes.map(function (code) {return String.fromCharCode(code);}).join('');

          return new _decodeResult2.default(new _token2.default(param.type, _utf2.default.decode(str)), offset + 1);

        case 'array':
          lengthOffset = (0, _sliceAs.asU32)(Decoder.peek(slices, offset)).div(32).toNumber();
          length = (0, _sliceAs.asU32)(Decoder.peek(slices, lengthOffset)).toNumber();
          newOffset = lengthOffset + 1;

          for (var idx = 0; idx < length; idx++) {
            var result = Decoder.decodeParam(param.subtype, slices, newOffset);
            newOffset = result.newOffset;
            tokens.push(result.token);
          }

          return new _decodeResult2.default(new _token2.default(param.type, tokens), offset + 1);

        case 'fixedArray':
          newOffset = offset;

          for (var _idx = 0; _idx < param.length; _idx++) {
            var _result = Decoder.decodeParam(param.subtype, slices, newOffset);
            newOffset = _result.newOffset;
            tokens.push(_result.token);
          }

          return new _decodeResult2.default(new _token2.default(param.type, tokens), newOffset);

        default:
          throw new Error('Invalid param type ' + param.type + ' in decodeParam');}

    } }]);return Decoder;}();exports.default = Decoder;module.exports = exports['default'];