abi.h

#ifndef IOTEX_ABI_H
#define IOTEX_ABI_H
 
#include "extern/cjson/cJSON.h"
#include "helpers/client_helper.h"
#include "helpers/json_helper.h"
#include "IoTeXConstants.h"
#include "IoTeXResultCodes.h"
#include <vector>
 
namespace iotex
{
namespace abi
{
enum EthereumTypeName
{
    UINT,
    INT,
    ADDRESS,
    BOOL,
    FIXED,
    UFIXED,
    BYTES_STATIC,
    STRING,
    BYTES_DYNAMIC,
    ARRAY_STATIC,
    ARRAY_DYNAMIC,
    TUPLE_STATIC,
    TUPLE_DYNAMIC,
    UNKNOWN
};
 
static const char* EthereumTypeNameToStringLT[] = {"uint",   "int",   "address", "bool",  "fixed",
                                                   "ufixed", "bytes", "string",  "bytes", "",
                                                   "",       "",      ""};
 
// Json objects
class InputOutputAbi
{
  public:
    IotexString name;
    EthereumTypeName type;
    uint32_t sizeBytes;
    EthereumTypeName arrayType;
    uint32_t arrayTypeSizeBytes = 0;
    uint32_t arraySize;
 
    static ResultCode getTypeAndSizeFromString(IotexString& str, InputOutputAbi& out);
 
    bool IsDynamic()
    {
        bool isDynamic = false;
        if(type == EthereumTypeName::BYTES_DYNAMIC)
            isDynamic = true;
        else if(type == EthereumTypeName::STRING)
            isDynamic = true;
        else if(type == EthereumTypeName::ARRAY_DYNAMIC)
            isDynamic = true;
        else if(type == EthereumTypeName::TUPLE_DYNAMIC)
            isDynamic = true;
        else if(type == EthereumTypeName::ARRAY_STATIC)
        {
            if(arrayType == EthereumTypeName::BYTES_DYNAMIC ||
               arrayType == EthereumTypeName::STRING ||
               arrayType == EthereumTypeName::ARRAY_DYNAMIC ||
               arrayType == EthereumTypeName::TUPLE_DYNAMIC)
                isDynamic = true;
        }
        return isDynamic;
    }
 
    bool isInteger() const
    {
        return (type == EthereumTypeName::UINT || type == EthereumTypeName::INT);
    }
 
  private:
    static ResultCode getSizeFromStringAndCheckIfArray(IotexString& str, InputOutputAbi& out);
};
 
class FunctionAbi
{
  public:
    bool constant;
    std::vector<InputOutputAbi> inputs; // Not present in fallback
    IotexString name;
    std::vector<InputOutputAbi> outputs; // Not present in constructor or fallback
    IotexString stateMutability;
    bool payable;
 
    void getSignature(IotexString& out);
};
 
// Parsing
ResultCode parseContract(const IotexString& contractAbi, std::vector<FunctionAbi>& out);
 
ResultCode parseFunction(const cJSON* data, FunctionAbi& out);
 
ResultCode parseInputOutput(const cJSON* data, InputOutputAbi& out);
 
// Utils
class ParameterValue
{
  public:
    union
    {
        uint8_t uint8;
        uint16_t uint16;
        uint32_t uint32;
        uint64_t uint64;
        int8_t int8;
        int16_t int16;
        int32_t int32;
        int64_t int64;
        IotexString* uint256;
        bool boolean;
        IotexString* string;
        uint8_t* bytes;
        ParameterValue* elements; // Array or tuple elements
    } value;
    int32_t size = -1;
    bool isBigInt = false;
    EthereumTypeName type = EthereumTypeName::UNKNOWN;
 
    bool isDynamic()
    {
        return (type == EthereumTypeName::BYTES_DYNAMIC || type == EthereumTypeName::STRING ||
                type == EthereumTypeName::ARRAY_DYNAMIC || type == EthereumTypeName::TUPLE_DYNAMIC);
    }
};
 
ParameterValue MakeParamUint(uint64_t value);
 
ParameterValue MakeParamInt(int64_t value);
 
ParameterValue MakeParamString(IotexString& value);
 
ParameterValue MakeParamAddress(uint8_t value[ETH_ADDRESS_SIZE]);
 
ParameterValue MakeParamBytes(uint8_t value[], size_t size, bool dynamic);
} // namespace abi
} // namespace iotex
 
#endif