Examples to use this library

[DerXanRam]

Below examples are code snippets from my project and it may help someone to interact with Ethereum network and other networks that support EVM(like BSC) using this library.

use the below file as a header inside ur project and u can encode ABI, decode ABI output, and decode ABI inputs

#include <iostream>
#include <vector>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <ethc/abi.h>
#include <gmp.h>

#define ok(ethcop) assert(ethcop >= 0)
using namespace std;

using namespace std;
long double bstod(string a)
{
	stringstream s(a);
	long double ret = 0;
	s >> ret;
	return ret;
}
string EncodeABI(string functionName, vector<pair<string, string>> parameters) // beanchmark--for hard work =210 micro-sec
{
    string function = functionName + "(";
    int NumOfParametrs = parameters.size();

    // separating parameters
    string conParamValues[NumOfParametrs];
    string ParamName[NumOfParametrs];
    vector<pair<string, string>>::iterator it;
    int k = 0;
    for (it = parameters.begin(); it != parameters.end(); ++it)
    {
        conParamValues[k] = it->second;
        ParamName[k] = it->first;
        function += ParamName[k] + ",";
        k++;
    }
    // encoding
    struct eth_abi abi;
    if (function[function.length() - 1] == ',')
        function[function.length() - 1] = ')';
    else
        function += ")";
    // cout << "function is " << function << endl;
    char *fn = strdup(function.c_str()), *hex;
    size_t hexlen;
    eth_abi_init(&abi, ETH_ABI_ENCODE);
    eth_abi_call(&abi, &fn, NULL);
    if (NumOfParametrs != 0)
    {
        for (int i = 0; i < k; i++)
        {
            if (ParamName[i] == "uint8" || ParamName[i] == "uint8[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, NULL); // array beign
                    string value = conParamValues[i];
                    string temp;
                    for (int j = 0; j < value.length(); j++)
                    {
                        if (value[j] == ',')
                        {
                            uint8_t val = bstod(temp);
                            eth_abi_uint8(&abi, &val);
                            temp = "";
                        }
                        else if (j == value.length() - 1)
                        {
                            temp += value[j];
                            uint8_t val = bstod(temp);
                            eth_abi_uint8(&abi, &val);
                        }
                        else
                        {
                            temp += value[j];
                        }
                    }
                    eth_abi_array_end(&abi); // array end
                }
                else
                {
                    uint8_t val = bstod(conParamValues[i]);
                    eth_abi_uint8(&abi, &val);
                }
            }

            if (ParamName[i] == "uint16" || ParamName[i] == "uint16[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, NULL); // array beign
                    string value = conParamValues[i];
                    string temp;
                    for (int j = 0; j < value.length(); j++)
                    {
                        if (value[j] == ',')
                        {
                            uint16_t val = bstod(temp);
                            eth_abi_uint16(&abi, &val);
                            temp = "";
                        }
                        else if (j == value.length() - 1)
                        {
                            temp += value[j];
                            uint16_t val = bstod(temp);
                            eth_abi_uint16(&abi, &val);
                        }
                        else
                        {
                            temp += value[j];
                        }
                    }
                    eth_abi_array_end(&abi); // array end
                }
                else
                {
                    uint16_t val = bstod(conParamValues[i]);
                    eth_abi_uint16(&abi, &val);
                }
            }

            if (ParamName[i] == "uint32" || ParamName[i] == "uint32[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, NULL); // array beign
                    string value = conParamValues[i];
                    string temp;
                    for (int j = 0; j < value.length(); j++)
                    {
                        if (value[j] == ',')
                        {
                            uint32_t val = bstod(temp);
                            eth_abi_uint32(&abi, &val);
                            temp = "";
                        }
                        else if (j == value.length() - 1)
                        {
                            temp += value[j];
                            uint32_t val = bstod(temp);
                            eth_abi_uint32(&abi, &val);
                        }
                        else
                        {
                            temp += value[j];
                        }
                    }
                    eth_abi_array_end(&abi); // array end
                }
                else
                {
                    uint32_t val = bstod(conParamValues[i]);
                    eth_abi_uint32(&abi, &val);
                }
            }
            if (ParamName[i] == "uint64" || ParamName[i] == "uint64[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, NULL); // array beign
                    string value = conParamValues[i];
                    string temp;
                    for (int j = 0; j < value.length(); j++)
                    {
                        if (value[j] == ',')
                        {
                            uint64_t val = bstod(temp);
                            eth_abi_uint64(&abi, &val);
                            temp = "";
                        }
                        else if (j == value.length() - 1)
                        {
                            temp += value[j];
                            uint64_t val = bstod(temp);
                            eth_abi_uint64(&abi, &val);
                        }
                        else
                        {
                            temp += value[j];
                        }
                    }
                    eth_abi_array_end(&abi); // array end
                }
                else
                {
                    uint64_t val = bstod(conParamValues[i]);
                    eth_abi_uint64(&abi, &val);
                }
            }
            if (ParamName[i] == "address" || ParamName[i] == "address[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, NULL); // array beign
                    string value = conParamValues[i];
                    string temp;
                    for (int j = 0; j < value.length(); j++)
                    {
                        if (value[j] == ',')
                        {
                            char *val = strdup(temp.c_str());
                            eth_abi_address(&abi, &val);
                            temp = "";
                        }
                        else if (j == value.length() - 1)
                        {
                            temp += value[j];
                            char *val = strdup(temp.c_str());
                            eth_abi_address(&abi, &val);
                        }
                        else
                        {
                            temp += value[j];
                        }
                    }
                    eth_abi_array_end(&abi); // array end
                }
                else
                {
                    char *val = strdup(conParamValues[i].c_str());
                    eth_abi_address(&abi, &val);
                }
            }
            if (ParamName[i] == "bool" || ParamName[i] == "bool[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, NULL); // array beign
                    string value = conParamValues[i];
                    string temp;
                    for (int j = 0; j < value.length(); j++)
                    {
                        if (value[j] == ',')
                        {
                            bool sym = false;
                            if (temp == "true")
                                sym = true;
                            uint8_t val = sym;
                            eth_abi_bool(&abi, &val);
                            temp = "";
                        }
                        else if (j == value.length() - 1)
                        {
                            temp += value[j];
                            bool sym = false;
                            if (temp == "true")
                                sym = true;
                            uint8_t val = sym;
                            eth_abi_bool(&abi, &val);
                        }
                        else
                        {
                            temp += value[j];
                        }
                    }
                    eth_abi_array_end(&abi); // array end
                }
                else
                {
                    bool sym = false;
                    if (conParamValues[i] == "true")
                        sym = true;
                    uint8_t val = sym;
                    eth_abi_bool(&abi, &val);
                }
            }

            if (ParamName[i] == "uint256" || ParamName[i] == "uint256[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, NULL); // array beign

                    string value = conParamValues[i];
                    string temp;
                    for (int j = 0; j < value.length(); j++)
                    {
                        if (value[j] == ',')
                        {
                            char *num = strdup(temp.c_str());
                            mpz_t val;
                            mpz_init_set_str(val, num, 0);
                            eth_abi_mpint(&abi, val);
                            temp = "";
                        }
                        else if (j == value.length() - 1)
                        {
                            temp += value[j];
                            char *num = strdup(temp.c_str());
                            mpz_t val;
                            mpz_init_set_str(val, num, 0);
                            eth_abi_mpint(&abi, val);
                        }
                        else
                        {
                            temp += value[j];
                        }
                    }
                    eth_abi_array_end(&abi); // array end
                }
                else
                {
                    char *num = strdup(conParamValues[i].c_str());
                    mpz_t val;
                    mpz_init_set_str(val, num, 0);
                    eth_abi_mpint(&abi, val);
                }
            }
            if (ParamName[i] == "bytes" || ParamName[i] == "bytes[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, NULL); // array beign
                    string value = conParamValues[i];
                    string temp;
                    for (int j = 0; j < value.length(); j++)
                    {
                        if (value[j] == ',')
                        {
                            uint8_t *val = (uint8_t *)temp.c_str();
                            eth_abi_bytes(&abi, &val, NULL);
                            temp = "";
                        }
                        else if (j == value.length() - 1)
                        {
                            temp += value[j];
                            uint8_t *val = (uint8_t *)temp.c_str();
                            eth_abi_bytes(&abi, &val, NULL);
                        }
                        else
                        {
                            temp += value[j];
                        }
                    }
                    eth_abi_array_end(&abi); // array end
                }
                else
                {
                    size_t byteLen = conParamValues[i].size();
                    uint8_t *val = (uint8_t *)conParamValues[i].c_str();
                    char *final = (char *)val;

                    string decodedres;
                    for (int i = 0; i < 4; i++)
                    {
                        decodedres += final[i];
                    }
                    eth_abi_bytes(&abi, &val, &byteLen);
                }
            }
        }
    }

    eth_abi_call_end(&abi);
    ok(eth_abi_to_hex(&abi, &hex, &hexlen));
    ok(eth_abi_free(&abi));
    string data(hex);
    return data;
}

vector<string> DecodeABIOutput(string outputDataTypes, string data) // beanchmark--for hard work =210 micro-sec
{
    vector<string> result;
    string temp;
    uint64_t arrlen = 0; // for array
    vector<string> ParamName;
    int NumOfParametrs = 0;
    for (int i = 0; i < outputDataTypes.length(); i++)
    {
        if (outputDataTypes[i] == ',')
        {
            ParamName.push_back(temp);
            temp = "";
            NumOfParametrs++;
        }
        else if (i == outputDataTypes.length() - 1 && !outputDataTypes.empty())
        {
            temp += outputDataTypes[i];
            ParamName.push_back(temp);
            temp = "";
            NumOfParametrs++;
            break;
        }
        else
        {
            temp += outputDataTypes[i];
        }
    }

    // decoding result
    struct eth_abi abi;
    size_t hexlen;

    char *input = strdup(data.c_str());
    eth_abi_from_hex(&abi, input, data.length());
    if (NumOfParametrs != 0)
    {
        for (int i = 0; i < NumOfParametrs; i++)
        {
            if (ParamName[i] == "uint8" || ParamName[i] == "uint8[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint8_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_uint8(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint8_t val;
                    eth_abi_uint8(&abi, &val);
                    result.push_back(to_string(val));
                }
            }

            if (ParamName[i] == "uint16" || ParamName[i] == "uint16[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint16_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_uint16(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint16_t val;
                    eth_abi_uint16(&abi, &val);
                    result.push_back(to_string(val));
                }
            }

            if (ParamName[i] == "uint32" || ParamName[i] == "uint32[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint32_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_uint32(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint32_t val;
                    eth_abi_uint32(&abi, &val);
                    result.push_back(to_string(val));
                }
            }
            if (ParamName[i] == "uint64" || ParamName[i] == "uint64[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint64_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_uint64(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint64_t val;
                    eth_abi_uint64(&abi, &val);
                    result.push_back(to_string(val));
                }
            }
            if (ParamName[i] == "uint256" || ParamName[i] == "uint256[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;

                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    mpz_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {

                        mpz_init(val[j]);
                        eth_abi_mpint(&abi, val[j]);
                        char *mpnum;
                        gmp_asprintf(&mpnum, "%Zd", val[j]);
                        string n(mpnum);
                        result.push_back(n);
                        free(mpnum);
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {

                    mpz_t val;
                    mpz_init(val);
                    eth_abi_mpint(&abi, val);
                    char *mpnum;
                    gmp_asprintf(&mpnum, "%Zd", val);
                    string n(mpnum);
                    result.push_back(n);
                }
            }
            if (ParamName[i] == "address" || ParamName[i] == "address[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    char *val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_address(&abi, &val[j]);
                        string a(val[j]);
                        result.push_back("0x"+a);
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    char *val;
                    eth_abi_address(&abi, &val);
                    string a(val);
                    result.push_back("0x"+a);
                }
            }

            if (ParamName[i] == "bool" || ParamName[i] == "bool[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint8_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_bool(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint8_t val;
                    eth_abi_bool(&abi, &val);
                    result.push_back(to_string(val));
                }
            }
            if (ParamName[i] == "bytes" || ParamName[i] == "bytes[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint8_t *val[arrlen];
                    size_t len;
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_bytes(&abi, &val[j], &len);
                        char *final = (char *)val[j];
                        string decoded;
                        for (int i = 0; i < len; i++)
                        {
                            decoded += final[i];
                        }
                        result.push_back(decoded);
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint8_t *val;
                    size_t len;
                    int a = eth_abi_bytes(&abi, &val, &len);
                    len = 4;
                    char *final = (char *)val;
                    string decoded;
                    for (int j = 0; j < len; j++)
                    {
                        decoded += final[j];
                    }
                    result.push_back(decoded);
                }
            }
        }
    }

    eth_abi_call_end(&abi);
    ok(eth_abi_free(&abi));
    return result;
}

vector<string> DecodeABIinputs(string func, string data) // beanchmark--for hard work =210 micro-sec
{

    vector<string> result;
    uint64_t arrlen = 0; // for array

    // separating parameters
    vector<string> ParamName;
    vector<string>::iterator it;
    int k = 0;
    bool flag = false;
    ;
    string con;
    for (int i = 0; i < func.length(); i++)
    {
        if (func[i] == '(')
        {
            for (int j = i + 1; j < func.length(); j++)
            {
                if (func[j] == ')')
                {
                    if (k != 0 || flag)
                    {
                        ParamName.push_back(con);
                        con = "";
                        k++;
                    }
                    break;
                }
                else if (func[j] == ',')
                {
                    ParamName.push_back(con);
                    con = "";
                    k++;
                }
                else
                {
                    flag = true;
                    con += func[j];
                }
            }
        }
    }

    // encoding
    struct eth_abi abi;
    // cout << "function is " << func << endl;
    char *fn = strdup(func.c_str()), *hex;
    size_t hexlen;

    char *input = strdup(data.c_str());
    eth_abi_from_hex(&abi, input, data.length());
    eth_abi_call(&abi, &fn, NULL);
    if (k != 0)
    {
        for (int i = 0; i < k; i++)
        {
            if (ParamName[i] == "uint8" || ParamName[i] == "uint8[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beig
                    uint8_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_uint8(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint8_t val;
                    eth_abi_uint8(&abi, &val);
                    result.push_back(to_string(val));
                }
            }

            if (ParamName[i] == "uint16" || ParamName[i] == "uint16[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint16_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {

                        eth_abi_uint16(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint16_t val;
                    eth_abi_uint16(&abi, &val);
                    result.push_back(to_string(val));
                }
            }

            if (ParamName[i] == "uint32" || ParamName[i] == "uint32[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint32_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_uint32(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint32_t val;
                    eth_abi_uint32(&abi, &val);
                    result.push_back(to_string(val));
                }
            }
            if (ParamName[i] == "uint64" || ParamName[i] == "uint64[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint64_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_uint64(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint64_t val;
                    eth_abi_uint64(&abi, &val);
                    result.push_back(to_string(val));
                }
            }
            if (ParamName[i] == "uint256" || ParamName[i] == "uint256[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;

                if (temp0[templen] == ']')
                {

                    eth_abi_array(&abi, &arrlen); // array beign
                    mpz_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {

                        mpz_init(val[j]);
                        eth_abi_mpint(&abi, val[j]);
                        char *mpnum;
                        gmp_asprintf(&mpnum, "%Zd", val[j]);
                        string n(mpnum);
                        result.push_back(n);
                        free(mpnum);
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {

                    mpz_t val;
                    mpz_init(val);
                    eth_abi_mpint(&abi, val);
                    char *mpnum;
                    gmp_asprintf(&mpnum, "%Zd", val);
                    string n(mpnum);
                    result.push_back(n);
                }
            }
            if (ParamName[i] == "address" || ParamName[i] == "address[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    char *val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_address(&abi, &val[j]);
                        string a(val[j]);
                        result.push_back("0x"+a);
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    char *val;
                    eth_abi_address(&abi, &val);
                    string a(val);
                    result.push_back("0x"+a);
                }
            }

            if (ParamName[i] == "bool" || ParamName[i] == "bool[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign
                    uint8_t val[arrlen];
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_bool(&abi, &val[j]);
                        result.push_back(to_string(val[j]));
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint8_t val;
                    eth_abi_bool(&abi, &val);
                    result.push_back(to_string(val));
                }
            }

            if (ParamName[i] == "bytes" || ParamName[i] == "bytes[]")
            {
                string temp0 = ParamName[i];
                int templen = temp0.length() - 1;
                if (temp0[templen] == ']')
                {
                    eth_abi_array(&abi, &arrlen); // array beign

                    uint8_t *val[arrlen];
                    size_t len;
                    for (int j = 0; j < arrlen; j++)
                    {
                        eth_abi_bytes(&abi, &val[j], &len);
                        char *final = (char *)val[j];
                        string decoded;
                        for (int i = 0; i < len; i++)
                        {
                            decoded += final[i];
                        }
                        result.push_back(decoded);
                    }
                    eth_abi_array_end(&abi); // array end
                    arrlen = 0;
                }
                else
                {
                    uint8_t *val;
                    size_t len;
                    int a = eth_abi_bytes(&abi, &val, &len);
                    len = 4;
                    char *final = (char *)val;
                    string decoded;
                    for (int j = 0; j < len; j++)
                    {
                        decoded += final[j];
                    }
                    result.push_back(decoded);
                }
            }
        }
    }

    eth_abi_call_end(&abi);
    ok(eth_abi_free(&abi));
    return result;
}

The usage is pretty simple. Take a look this example

#include <iostream>
#include "ABI-Utils.h"

using namespace std;

int main()
{
  	//encoding ABI
   vector<pair<string,string>> parr;
   string funame="test";
	parr=
		{   {"bool","true"},
			{"uint256","1000"},
			{"address[]","0x10ed43c718714eb63d5aa57b78b54704e256024e,0x13f4ea83d0bd40e75c8222255bc855a974568dd4"},
			{"uint256[]","300,400"}
		}
	;
    string encodedForm=EncodeABI(funame,parr);
    cout<<"encoded data "<<encodedForm<<endl;

	//decode ABI response
	string OutputDataType="address";//u can add more by separating using comma(,)
 	vector<string>output=DecodeABIOutput(OutputDataType,"0x0000000000000000000000003139ffc91b99aa94da8a2dc13f1fc36f9bdc98ee");
	cout<<"\ndecoded ABI response is \n";
    for(int i=0;i<output.size();i++)
	{
		cout<<output[i]<<endl;
	}


	//decoding ABI Inputs
    string data="0x7ff36ab50000000000000000000000000000000000000000000000000000000001506f7a000000000000000000000000000000000000000000000000000000000000008000000000000000000000000072e03cfbde614060871c71629fa3a1518023319c000000000000000000000000000000000000000000000000000000006099faeb0000000000000000000000000000000000000000000000000000000000000003000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c599000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7";
	string Func="swapExactETHForTokens(uint256,address[],address,uint256)";
	vector<string> InputData = DecodeABIinputs(Func,data);
	cout<<"\nencoded input datas are \n";
	for (int i = 0; i < InputData.size(); i++)
	{
		cout << InputData[i] << endl;
	}
}

The above code can operate on uint8,uint16,uint32,uint64,uint256,bool,address and their array form. Encoding ABI and decoding ABI response of bytes and bytes[] data type is possible. However decoding ABI inputs of bytes is not stable!

[DerXanRam]

and this is utilities code and u need them in your blockchain project. The code contains functionalities to convert decimal to hex and vise versa, to calculate gaslimit and gas fee, and bstod a function to convert string to number(u can do this using stod but amount of decimal points supported is not enough to enteract with EVM).

#include <sstream>
#include <fstream>
#include <ctime>
#include <chrono>
#include <math.h>
#include <string>
#include <map>

using namespace std;
using namespace std::chrono;

string getTimestamp()
{
	long long ms_since_epoch = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
	return to_string(ms_since_epoch);
}
long double bstod(string a)
{
	stringstream s(a);
	long double ret = 0;
	s >> ret;
	return ret;
}
string hex2dec(string hex)
{
	string::size_type sz = 0;
	return to_string(stoll(hex, &sz, 16));
}
string dec2hex(long long hex)
{
	auto temp = (std::stringstream{} << std::hex << hex).str();
	string res = "0x";
	res += temp;
	return res;
}
string GetgasLimit(string data)
{
	int sizeInBytes = data.size();
	long long limit = 21000 + (68 * sizeInBytes);
	return to_string(limit);
}
string gasfee(string gasLimit, string gasPrice) // more fix here
{
	double gwei = bstod(gasPrice) / 1000000000;
	string gasFee=to_string(gwei *bstod(gasLimit));
	return gasFee;
}

i think their usage is straight forward 👍

[DerXanRam]

and finally to sign raw transaction

#include <stdio.h>
#include <assert.h>
#include <ethc/ecdsa.h>
#include <ethc/rlp.h>
#include <ethc/keccak256.h>

#define ok(ethcop) assert(ethcop >= 0)

string rawTransaction(string inputData, string gasLimit,string gasPrice, string to,string val="0x00", string from="0xb438D71c1E6E8E53637e1F1deC37c2E635e335fc")
{
	struct eth_rlp rlp0, rlp1;
	struct eth_ecdsa_signature sign;
   
	uint8_t privkey[] = {0x80, 0x3e, 0x53, 0x83, 0x51, 0x93, 0xdd, 0x6e,
			      0xad, 0x61, 0xa2, 0x5a, 0x74, 0x5f, 0xa6, 0x35,
			      0x86, 0xb4, 0xb2, 0xdd, 0x7b, 0x6a, 0xbe, 0x4a,
			      0x06, 0xfa, 0x7f, 0x33, 0xc1, 0x1a, 0xed, 0x81}; // real privare key of 0xa9d0a7dC416f586491f2fb596731598F937617b5
  uint8_t nonce=0x3D, zero=0x00, keccak[32], *rlp0bytes, *r, *s;
  char *gasprice = strdup(gasPrice.c_str()), *gaslimit = strdup(gasLimit.c_str()), *value = strdup(val.c_str()), *input=strdup(inputData.c_str());
  char *toaddr = strdup(to.c_str()), *txn;
  uint8_t chainid = 0x38, v;
  size_t rlp0len, rlp1len, siglen=32;

  ok(eth_rlp_init(&rlp0, ETH_RLP_ENCODE));

  ok(eth_rlp_array(&rlp0));                  //[
    ok(eth_rlp_uint8(&rlp0, &nonce));        //  
    ok(eth_rlp_hex(&rlp0, &gasprice, NULL)); //  
    ok(eth_rlp_hex(&rlp0, &gaslimit, NULL)); //   
    ok(eth_rlp_address(&rlp0, &toaddr));     //   
    ok(eth_rlp_hex(&rlp0, &value, NULL));    //   value
    ok(eth_rlp_hex(&rlp0, &input,NULL));     //   abi data
    ok(eth_rlp_uint8(&rlp0, &chainid));     //   0x7a69,
    ok(eth_rlp_uint8(&rlp0, &zero));         //   0x,
    ok(eth_rlp_uint8(&rlp0, &zero));         //   0x,
  ok(eth_rlp_array_end(&rlp0));              // ]

  ok(eth_rlp_to_bytes(&rlp0bytes, &rlp0len, &rlp0));
  ok(eth_rlp_free(&rlp0));

  // compute the keccak hash of the encoded rlp elements
  ok(eth_keccak256(keccak, rlp0bytes, rlp0len));
  free(rlp0bytes);

  // sign the transaction
  ok(eth_ecdsa_sign(&sign, privkey, keccak));

  // calculate v
  v = sign.recid + chainid * 2 + 35;
  r = sign.r;
  s = sign.s;

  ok(eth_rlp_init(&rlp1, ETH_RLP_ENCODE));

  ok(eth_rlp_array(&rlp1));                 //[
    ok(eth_rlp_uint8(&rlp1, &nonce));
    ok(eth_rlp_hex(&rlp1, &gasprice, NULL));
    ok(eth_rlp_hex(&rlp1, &gaslimit, NULL));
    ok(eth_rlp_address(&rlp1, &toaddr));
    ok(eth_rlp_hex(&rlp1, &value, NULL));     //value
    ok(eth_rlp_hex(&rlp1, &input,NULL));      //abi data
    ok(eth_rlp_uint8(&rlp1, &v));
    ok(eth_rlp_bytes(&rlp1, &r, &siglen));
    ok(eth_rlp_bytes(&rlp1, &s, &siglen));
  ok(eth_rlp_array_end(&rlp1));             //]

  ok(eth_rlp_to_hex(&txn, &rlp1));
  ok(eth_rlp_free(&rlp1));
  string raw(txn);
  free(txn);
  return raw;
}

the above code is tested in real transaction and it works 👍

[mhw0]

Good job @DerXanRam!