# All files / web3-eth-abi/src param.js

57.14% Statements 20/35
50% Branches 5/10
38.46% Functions 5/13
57.14% Lines 20/35

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154

    1x

    1x
    637x
    637x
    637x

    1x

    1x

    1x

    1x
    962x

    1x

    1x
    584x
    584x

    1x
    378x

    1x
    315x

    1x

    1x

     /*
        This file is part of web3.js.

        web3.js is free software: you can redistribute it and/or modify
        it under the terms of the GNU Lesser General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.

        web3.js is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU Lesser General Public License for more details.

        You should have received a copy of the GNU Lesser General Public License
        along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
    */
    /**
     * @file param.js
     * @author Marek Kotewicz <marek@parity.io>
     * @date 2015
     */

    var formatters = require('./formatters.js');

    /**
     * SolidityParam object prototype.
     * Should be used when encoding, decoding solidity bytes
     */
    var SolidityParam = function (value, offset, rawValue) {
        this.value = value || '';
        this.offset = offset; // offset in bytes
        this.rawValue = rawValue; // used for debugging
    };

    /**
     * This method should be used to get length of params's dynamic part
     *
     * @method dynamicPartLength
     * @returns {Number} length of dynamic part (in bytes)
     */
    SolidityParam.prototype.dynamicPartLength = function () {
        return this.dynamicPart().length / 2;
    };

    /**
     * This method should be used to create copy of solidity param with different offset
     *
     * @method withOffset
     * @param {Number} offset length in bytes
     * @returns {SolidityParam} new solidity param with applied offset
     */
    SolidityParam.prototype.withOffset = function (offset) {
        return new SolidityParam(this.value, offset);
    };

    /**
     * This method should be used to combine solidity params together
     * eg. when appending an array
     *
     * @method combine
     * @param {SolidityParam} param with which we should combine
     * @param {SolidityParam} result of combination
     */
    SolidityParam.prototype.combine = function (param) {
        return new SolidityParam(this.value + param.value);
    };

    /**
     * This method should be called to check if param has dynamic size.
     * If it has, it returns true, otherwise false
     *
     * @method isDynamic
     * @returns {Boolean}
     */
    SolidityParam.prototype.isDynamic = function () {
        return this.offset !== undefined;
    };

    /**
     * This method should be called to transform offset to bytes
     *
     * @method offsetAsBytes
     * @returns {String} bytes representation of offset
     */
    SolidityParam.prototype.offsetAsBytes = function () {
        return !this.isDynamic() ? '' : formatters.toTwosComplement(this.offset).replace('0x','');
    };

    /**
     * This method should be called to get static part of param
     *
     * @method staticPart
     * @returns {String} offset if it is a dynamic param, otherwise value
     */
    SolidityParam.prototype.staticPart = function () {
        Eif (!this.isDynamic()) {
            return this.value;
        }
        return this.offsetAsBytes();
    };

    /**
     * This method should be called to get dynamic part of param
     *
     * @method dynamicPart
     * @returns {String} returns a value if it is a dynamic param, otherwise empty string
     */
    SolidityParam.prototype.dynamicPart = function () {
        return this.isDynamic() ? this.value : '';
    };

    /**
     * This method should be called to encode param
     *
     * @method encode
     * @returns {String}
     */
    SolidityParam.prototype.encode = function () {
        return this.staticPart() + this.dynamicPart();
    };

    /**
     * This method should be called to encode array of params
     *
     * @method encodeList
     * @param {Array[SolidityParam]} params
     * @returns {String}
     */
    SolidityParam.encodeList = function (params) {

        // updating offsets
        var totalOffset = params.length * 32;
        var offsetParams = params.map(function (param) {
            if (!param.isDynamic()) {
                return param;
            }
            var offset = totalOffset;
            totalOffset += param.dynamicPartLength();
            return param.withOffset(offset);
        });

        // encode everything!
        return offsetParams.reduce(function (result, param) {
            return result + param.dynamicPart();
        }, offsetParams.reduce(function (result, param) {
            return result + param.staticPart();
        }, ''));
    };

    module.exports = SolidityParam;