aboutsummaryrefslogtreecommitdiffstats
path: root/test/RPCSession.h
blob: 9b7009bf6190892e794cea85e3452c536dfc6de6 (plain) (blame)
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
/*
    This file is part of cpp-ethereum.

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

    cpp-ethereum 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
/** @file RPCSession.h
 * @author Dimtiry Khokhlov <dimitry@ethdev.com>
 * @date 2016
 */

#if defined(_WIN32)
#include <windows.h>
#include "libdevcore/UndefMacros.h"
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#endif

#include <string>
#include <stdio.h>
#include <map>
#include <json/value.h>
#include <boost/test/unit_test.hpp>

#if defined(_WIN32)
const int c_buffsize = 5120000; //because windows pipe is broken and wont work as in examples. use larger buffer limit to receive whole package in one call
class IPCSocket : public boost::noncopyable
{
public:
    IPCSocket(std::string const& _path);
    std::string sendRequest(std::string const& _req);
    ~IPCSocket() { CloseHandle(m_socket); }

    std::string const& path() const { return m_path; }

private:
    std::string m_path;
    HANDLE  m_socket;
};
#else
class IPCSocket: public boost::noncopyable
{
public:
    IPCSocket(std::string const& _path);
    std::string sendRequest(std::string const& _req);
    ~IPCSocket() { close(m_socket); fclose(m_fp); }

    std::string const& path() const { return m_path; }

private:
    FILE *m_fp;
    std::string m_path;
    int m_socket;
};
#endif

class RPCSession: public boost::noncopyable
{
public:
    struct TransactionData
    {
        std::string from;
        std::string to;
        std::string gas;
        std::string gasPrice;
        std::string value;
        std::string data;

        std::string toJson() const;
    };

    struct LogEntry {
        std::string address;
        std::vector<std::string> topics;
        std::string data;
    };

    struct TransactionReceipt
    {
        std::string gasUsed;
        std::string contractAddress;
        std::vector<LogEntry> logEntries;
    };

    static RPCSession& instance(std::string const& _path);

    std::string eth_getCode(std::string const& _address, std::string const& _blockNumber);
    std::string eth_call(TransactionData const& _td, std::string const& _blockNumber);
    TransactionReceipt eth_getTransactionReceipt(std::string const& _transactionHash);
    std::string eth_sendTransaction(TransactionData const& _transactionData);
    std::string eth_sendTransaction(std::string const& _transaction);
    std::string eth_getBalance(std::string const& _address, std::string const& _blockNumber);
    std::string eth_getStorageRoot(std::string const& _address, std::string const& _blockNumber);
    std::string personal_newAccount(std::string const& _password);
    void personal_unlockAccount(std::string const& _address, std::string const& _password, int _duration);
    void test_setChainParams(std::vector<std::string> const& _accounts);
    void test_setChainParams(std::string const& _config);
    void test_rewindToBlock(size_t _blockNr);
    void test_modifyTimestamp(size_t _timestamp);
    void test_mineBlocks(int _number);
    Json::Value rpcCall(std::string const& _methodName, std::vector<std::string> const& _args = std::vector<std::string>(), bool _canFail = false);

    std::string const& account(size_t _id) const { return m_accounts.at(_id); }
    std::string const& accountCreateIfNotExists(size_t _id);

private:
    RPCSession(std::string const& _path);

    inline std::string quote(std::string const& _arg) { return "\"" + _arg + "\""; }
    /// Parse std::string replacing keywords to values
    void parseString(std::string& _string, std::map<std::string, std::string> const& _varMap);

    IPCSocket m_ipcSocket;
    size_t m_rpcSequence = 1;

    std::vector<std::string> m_accounts;
};