contractabi.h

Go to the documentation of this file.

#ifndef CONTRACTABI_H
#define CONTRACTABI_H
#include <string>
#include <vector>
#include <map>
#include <QRegularExpression>
#include <QStringList>

#define paternUint "^[0-9]{1,77}$"
#define paternInt "^\\-{0,1}[0-9]{1,76}$"
#define paternAddress "^[a-fA-F0-9]{40,40}$"
#define paternBool "^true$|^false$"
#define paternHex "^[a-fA-F0-9]{1,}$"
#define paternBytes paternHex
#define paternBytes32 "^[a-fA-F0-9]{%1,%1}$"


class ParameterType
{
public:
    enum Type
    {
        abi_none,
        abi_bytes,
        abi_string,
        abi_uint,
        abi_int,
        abi_address,
        abi_bool,
        abi_fixed,
        abi_ufixed,
        abi_function
    };

    ParameterType(const std::string& _type = "");

    bool determine(const std::string& _type);

    size_t wholeBits() const;

    size_t decimalBits() const;

    size_t totalBytes() const;

    size_t length() const;

    bool isList() const;

    bool isDynamic() const;

    bool isValid() const;

    const std::string& canonical() const;

    Type type() const;

private:
    void clean();

    Type m_type;
    int m_whole;
    int m_decimal;
    int m_length;
    bool m_isList;
    bool m_valid;
    std::string m_canonical;
};

class ParameterABI
{
public:
    enum ErrorType
    {
        Ok = 0,
        UnsupportedABI,
        EncodingError,
        DecodingError
    };

    ParameterABI(const std::string& _name = "", const std::string& _type = "", bool _indexed = false);
    ~ParameterABI();
    bool abiIn(const std::vector<std::string> &value, std::string &data, std::map<int, std::string>& mapDynamic) const;
    bool abiOut(const std::string &data, size_t& pos, std::vector<std::string> &value) const;
    const ParameterType &decodeType() const;
    static bool getRegularExpession(const ParameterType &paramType, QRegularExpression &regEx);

    std::string name; // The name of the parameter;
    std::string type; // The canonical type of the parameter.
    bool indexed; // True if the field is part of the log's topics, false if it one of the log's data segment.
    // Indexed is only used with event function

    ErrorType lastError() const;

private:
    bool abiInBasic(ParameterType::Type abiType, std::string value, std::string &data) const;
    bool abiOutBasic(ParameterType::Type abiType, const std::string &data, size_t &pos, std::string &value) const;
    void addDynamic(const std::string& paramData, std::string &data, std::map<int, std::string>& mapDynamic) const;


    mutable ParameterType m_decodeType;
    mutable ErrorType m_lastError;
};

class FunctionABI
{
public:
    FunctionABI(const std::string& _name = "",
                const std::string& _type = "function",
                const std::vector<ParameterABI>& _inputs = std::vector<ParameterABI>(),
                const std::vector<ParameterABI>& _outputs = std::vector<ParameterABI>(),
                bool _payable = false,
                bool _constant = false,
                bool _anonymous = false);

    bool abiIn(const std::vector<std::vector<std::string>>& values, std::string& data, std::vector<ParameterABI::ErrorType>& errors) const;

    bool abiOut(const std::string& data, std::vector<std::vector<std::string>>& values, std::vector<ParameterABI::ErrorType>& errors) const;

    std::string selector() const;

    static std::string defaultSelector();

    QString errorMessage(std::vector<ParameterABI::ErrorType>& errors, bool in) const;

    std::string name; // The name of the function;
    std::string type; // Function types: "function", "constructor", "fallback" or "event"
    std::vector<ParameterABI> inputs; // Array of input parameters
    std::vector<ParameterABI> outputs; // Array of output parameters, can be omitted if function doesn't return
    bool payable; // True if function accepts ether, defaults to false.
    bool constant; // True if function is specified to not modify blockchain state.
    bool anonymous; // True if the event was declared as anonymous.

    // Constructor and fallback function never have name or outputs.
    // Fallback function doesn't have inputs either.
    // Event function is the only one that have anonymous.
    // Sending non-zero ether to non-payable function will throw.
    // Type can be omitted, defaulting to "function".

private:
    void processDynamicParams(const std::map<int, std::string>& mapDynamic, std::string& data) const;
};

class ContractABI
{
public:
    ContractABI();
    bool loads(const std::string& json_data);
    void clean();

    std::vector<FunctionABI> functions;
};

#endif // CONTRACTABI_H