Ecosystem/monero-lws
1
0
Fork 0
mirror of https://github.com/vtnerd/monero-lws.git synced 2025-04-02 20:09:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add tests for get_unspent_outs, and update get_address_txs

Browse source
This commit is contained in:
Lee Clagett 2024-03-12 13:38:01 -04:00
parent dc80e1e022
commit d5259e3429
3 changed files with 198 additions and 71 deletions

3
src/rpc/light_wallet.cpp
View file

@ -262,6 +262,7 @@ namespace lws
wire::field("coinbase", is_coinbase),
wire::field("mempool", false),
wire::field("mixin", self.value().info.spend_meta.mixin_count),
wire::field("recipient", self.value().info.recipient),
wire::field("spent_outputs", std::cref(self.value().spends))
);
}
@ -316,7 +317,7 @@ namespace lws
WIRE_FIELD_COPY(per_byte_fee),
WIRE_FIELD_COPY(fee_mask),
WIRE_FIELD_COPY(amount),
wire::field("outputs", wire::array(boost::adaptors::transform(self.outputs, expand)))
wire::optional_field("outputs", wire::array(boost::adaptors::transform(self.outputs, expand)))
);
}

140
tests/unit/rest.test.cpp
View file

@ -31,9 +31,11 @@
#include "db/data.h"
#include "db/storage.test.h"
#include "db/string.h"
#include "error.h"
#include "hex.h" // monero/epee/contrib/include
#include "net/http_client.h"
#include "rest_server.h"
#include "scanner.test.h"
namespace
{
@ -43,6 +45,19 @@ namespace
constexpr const char rest_server[] = "http://127.0.0.1:10000";
constexpr const char admin_server[] = "http://127.0.0.1:10001";
struct join
{
boost::thread& thread;
~join() { thread.join(); }
};
struct rct_bytes
{
rct::key commitment;
rct::key mask;
rct::key amount;
};
std::string invoke(enet::http::http_simple_client& client, const boost::string_ref uri, const boost::string_ref body)
{
const enet::http::http_response_info* info = nullptr;
@ -51,7 +66,38 @@ namespace
if (info->m_response_code != 200)
throw std::runtime_error{"HTTP invoke not 200, instead " + std::to_string(info->m_response_code)};
return std::string{info->m_body};
}
}
epee::byte_slice get_fee_response()
{
return epee::byte_slice{
std::string{
"{\"jsonrpc\":2.0,\"id\":0,\"result\":{"
"\"estimated_base_fee\":10000,\"fee_mask\":1000,\"size_scale\":256,\"hard_fork_version\":16"
"}}"
}
};
}
rct_bytes get_rct_bytes(const crypto::secret_key& user_key, const crypto::public_key& tx_public, const rct::key& ringct_mask, const std::uint64_t amount, const std::uint32_t index)
{
rct_bytes out{};
crypto::key_derivation derived;
if (!crypto::generate_key_derivation(tx_public, user_key, derived))
MONERO_THROW(lws::error::crypto_failure, "generate_key_derivation failed");
crypto::secret_key scalar;
rct::ecdhTuple encrypted{ringct_mask, rct::d2h(amount)};
crypto::derivation_to_scalar(derived, index, scalar);
rct::ecdhEncode(encrypted, rct::sk2rct(scalar), false);
out.commitment = rct::commit(amount, ringct_mask);
out.mask = encrypted.mask;
out.amount = encrypted.amount;
return out;
}
}
LWS_CASE("rest_server")
@ -68,8 +114,9 @@ LWS_CASE("rest_server")
std::optional<lws::rest_server> server;
lws::db::test::cleanup_db on_scope_exit{};
lws::db::storage db = lws::db::test::get_fresh_db();
auto rpc_client =
lws::rpc::context::make(fake_daemon, {}, {}, {}, std::chrono::minutes{0});
auto context =
lws::rpc::context::make(lws_test::rpc_rendevous, {}, {}, {}, std::chrono::minutes{0});
const auto rpc = MONERO_UNWRAP(context.connect());
{
const lws::rest_server::configuration config{
{}, {}, 1, 10, {}, false, true, true
@ -79,7 +126,7 @@ LWS_CASE("rest_server")
epee::to_span(addresses),
std::vector<std::string>{admin_server},
db.clone(),
MONERO_UNWRAP(rpc_client.connect()),
MONERO_UNWRAP(rpc.clone()),
config
);
}
@ -129,6 +176,15 @@ LWS_CASE("rest_server")
"\"transaction_height\":" + scan_height + ","
"\"blockchain_height\":" + scan_height + "}"
);
std::vector<epee::byte_slice> messages;
messages.emplace_back(get_fee_response());
boost::thread server_thread(&lws_test::rpc_thread, context.zmq_context(), std::cref(messages));
const join on_scope_exit{server_thread};
message = "{\"address\":\"" + address + "\",\"view_key\":\"" + viewkey + "\",\"amount\":\"0\"}";
response = invoke(client, "/get_unspent_outs", message);
EXPECT(response == "{\"per_byte_fee\":39,\"fee_mask\":1000,\"amount\":\"0\"}");
}
SECTION("One Receive, Zero Spends")
@ -140,7 +196,12 @@ LWS_CASE("rest_server")
const lws::db::transaction_link link{
lws::db::block_id(4000), crypto::rand<crypto::hash>()
};
const crypto::public_key tx_public = crypto::rand<crypto::public_key>();
const crypto::public_key tx_public = []() {
crypto::secret_key secret;
crypto::public_key out;
crypto::generate_keys(out, secret);
return out;
}();
const crypto::hash tx_prefix = crypto::rand<crypto::hash>();
const crypto::public_key pub = crypto::rand<crypto::public_key>();
const rct::key ringct = crypto::rand<rct::key>();
@ -218,7 +279,36 @@ LWS_CASE("rest_server")
"\"payment_id\":\"" + epee::to_hex::string(epee::as_byte_span(payment_id_)) + "\","
"\"coinbase\":true,"
"\"mempool\":false,"
"\"mixin\":16}"
"\"mixin\":16,"
"\"recipient\":{\"maj_i\":2,\"min_i\":66}}"
"]}"
);
std::vector<epee::byte_slice> messages;
messages.emplace_back(get_fee_response());
boost::thread server_thread(&lws_test::rpc_thread, context.zmq_context(), std::cref(messages));
const join on_scope_exit{server_thread};
const auto ringct_expanded = get_rct_bytes(view, tx_public, ringct, 40000, 2);
message = "{\"address\":\"" + address + "\",\"view_key\":\"" + viewkey + "\",\"amount\":\"0\"}";
response = invoke(client, "/get_unspent_outs", message);
EXPECT(response ==
"{\"per_byte_fee\":39,"
"\"fee_mask\":1000,"
"\"amount\":\"40000\","
"\"outputs\":["
"{\"amount\":\"40000\","
"\"public_key\":\"" + epee::to_hex::string(epee::as_byte_span(pub)) + "\","
"\"index\":2,"
"\"global_index\":30,"
"\"tx_id\":30,"
"\"tx_hash\":\"" + epee::to_hex::string(epee::as_byte_span(link.tx_hash)) + "\","
"\"tx_prefix_hash\":\"" + epee::to_hex::string(epee::as_byte_span(tx_prefix)) + "\","
"\"tx_pub_key\":\"" + epee::to_hex::string(epee::as_byte_span(tx_public)) + "\","
"\"timestamp\":\"1970-01-01T01:56:40Z\","
"\"height\":4000,"
"\"rct\":\"" + epee::to_hex::string(epee::as_byte_span(ringct_expanded)) + "\","
"\"recipient\":{\"maj_i\":2,\"min_i\":66}}"
"]}"
);
}
@ -232,7 +322,12 @@ LWS_CASE("rest_server")
const lws::db::transaction_link link{
lws::db::block_id(4000), crypto::rand<crypto::hash>()
};
const crypto::public_key tx_public = crypto::rand<crypto::public_key>();
const crypto::public_key tx_public = []() {
crypto::secret_key secret;
crypto::public_key out;
crypto::generate_keys(out, secret);
return out;
}();
const crypto::hash tx_prefix = crypto::rand<crypto::hash>();
const crypto::public_key pub = crypto::rand<crypto::public_key>();
const rct::key ringct = crypto::rand<rct::key>();
@ -334,6 +429,7 @@ LWS_CASE("rest_server")
"\"coinbase\":true,"
"\"mempool\":false,"
"\"mixin\":16,"
"\"recipient\":{\"maj_i\":2,\"min_i\":66},"
"\"spent_outputs\":[{"
"\"amount\":\"40000\","
"\"key_image\":\"" + epee::to_hex::string(epee::as_byte_span(image)) + "\","
@ -344,8 +440,36 @@ LWS_CASE("rest_server")
"}]}"
"]}"
);
}
std::vector<epee::byte_slice> messages;
messages.emplace_back(get_fee_response());
boost::thread server_thread(&lws_test::rpc_thread, context.zmq_context(), std::cref(messages));
const join on_scope_exit{server_thread};
const auto ringct_expanded = get_rct_bytes(view, tx_public, ringct, 40000, 2);
message = "{\"address\":\"" + address + "\",\"view_key\":\"" + viewkey + "\",\"amount\":\"0\"}";
response = invoke(client, "/get_unspent_outs", message);
EXPECT(response ==
"{\"per_byte_fee\":39,"
"\"fee_mask\":1000,"
"\"amount\":\"40000\","
"\"outputs\":["
"{\"amount\":\"40000\","
"\"public_key\":\"" + epee::to_hex::string(epee::as_byte_span(pub)) + "\","
"\"index\":2,"
"\"global_index\":30,"
"\"tx_id\":30,"
"\"tx_hash\":\"" + epee::to_hex::string(epee::as_byte_span(link.tx_hash)) + "\","
"\"tx_prefix_hash\":\"" + epee::to_hex::string(epee::as_byte_span(tx_prefix)) + "\","
"\"tx_pub_key\":\"" + epee::to_hex::string(epee::as_byte_span(tx_public)) + "\","
"\"timestamp\":\"1970-01-01T01:56:40Z\","
"\"height\":4000,"
"\"spend_key_images\":[\"" + epee::to_hex::string(epee::as_byte_span(image)) + "\"],"
"\"rct\":\"" + epee::to_hex::string(epee::as_byte_span(ringct_expanded)) + "\","
"\"recipient\":{\"maj_i\":2,\"min_i\":66}}"
"]}"
);
}
}
}

126
tests/unit/scanner.test.cpp
View file

@ -25,10 +25,10 @@
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "scanner.test.h"
#include "framework.test.h"
#include <boost/thread.hpp>
#include <iostream>
#include "cryptonote_basic/account.h" // monero/src
#include "cryptonote_basic/cryptonote_format_utils.h" // monero/src
@ -47,7 +47,6 @@
namespace
{
constexpr const char rendevous[] = "inproc://fake_daemon";
constexpr const std::chrono::seconds message_timeout{3};
template<typename T>
@ -82,60 +81,6 @@ namespace
return cryptonote::rpc::FullMessage::getResponse(message, id);
}
void rpc_thread(void* ctx, const std::vector<epee::byte_slice>& reply)
{
struct stop_
{
~stop_() noexcept { lws::scanner::stop(); };
} stop{};
try
{
net::zmq::socket server{};
server.reset(zmq_socket(ctx, ZMQ_REP));
if (!server || zmq_bind(server.get(), rendevous))
{
std::cout << "Failed to create ZMQ server" << std::endl;
return;
}
for (const epee::byte_slice& message : reply)
{
const auto start = std::chrono::steady_clock::now();
for (;;)
{
const auto request = net::zmq::receive(server.get(), ZMQ_DONTWAIT);
if (request)
break;
if (request != net::zmq::make_error_code(EAGAIN))
{
std::cout << "Failed to retrieve message in fake ZMQ server: " << request.error().message() << std::endl;;
return;
}
if (message_timeout <= std::chrono::steady_clock::now() - start)
{
std::cout << "Timeout in dummy RPC server" << std::endl;
return;
}
boost::this_thread::sleep_for(boost::chrono::milliseconds{10});
} // until error or received message
const auto sent = net::zmq::send(message.clone(), server.get());
if (!sent)
{
std::cout << "Failed to send dummy RPC message: " << sent.error().message() << std::endl;
return;
}
} // foreach message
}
catch (const std::exception& e)
{
std::cout << "Unexpected exception in dummy RPC server: " << e.what() << std::endl;
}
}
struct join
{
boost::thread& thread;
@ -278,6 +223,63 @@ namespace
}
return out;
}
} // anonymous
namespace lws_test
{
void rpc_thread(void* ctx, const std::vector<epee::byte_slice>& reply)
{
struct stop_
{
~stop_() noexcept { lws::scanner::stop(); };
} stop{};
try
{
net::zmq::socket server{};
server.reset(zmq_socket(ctx, ZMQ_REP));
if (!server || zmq_bind(server.get(), lws_test::rpc_rendevous))
{
std::cout << "Failed to create ZMQ server" << std::endl;
return;
}
for (const epee::byte_slice& message : reply)
{
const auto start = std::chrono::steady_clock::now();
for (;;)
{
const auto request = net::zmq::receive(server.get(), ZMQ_DONTWAIT);
if (request)
break;
if (request != net::zmq::make_error_code(EAGAIN))
{
std::cout << "Failed to retrieve message in fake ZMQ server: " << request.error().message() << std::endl;;
return;
}
if (message_timeout <= std::chrono::steady_clock::now() - start)
{
std::cout << "Timeout in dummy RPC server" << std::endl;
return;
}
boost::this_thread::sleep_for(boost::chrono::milliseconds{10});
} // until error or received message
const auto sent = net::zmq::send(message.clone(), server.get());
if (!sent)
{
std::cout << "Failed to send dummy RPC message: " << sent.error().message() << std::endl;
return;
}
} // foreach message
}
catch (const std::exception& e)
{
std::cout << "Unexpected exception in dummy RPC server: " << e.what() << std::endl;
}
}
}
LWS_CASE("lws::scanner::sync and lws::scanner::run")
@ -321,7 +323,7 @@ LWS_CASE("lws::scanner::sync and lws::scanner::run")
{
lws::scanner::reset();
auto rpc =
lws::rpc::context::make(rendevous, {}, {}, {}, std::chrono::minutes{0}, false);
lws::rpc::context::make(lws_test::rpc_rendevous, {}, {}, {}, std::chrono::minutes{0}, false);
lws::db::test::cleanup_db on_scope_exit{};
@ -343,7 +345,7 @@ LWS_CASE("lws::scanner::sync and lws::scanner::run")
std::vector<epee::byte_slice> messages{};
messages.push_back(to_json_rpc(1));
boost::thread server_thread(&rpc_thread, rpc.zmq_context(), std::cref(messages));
boost::thread server_thread(&lws_test::rpc_thread, rpc.zmq_context(), std::cref(messages));
const join on_scope_exit{server_thread};
EXPECT(!lws::scanner::sync(db.clone(), MONERO_UNWRAP(rpc.connect())));
lws_test::test_chain(lest_env, MONERO_UNWRAP(db.start_read()), last_block.id, hashes);
@ -375,7 +377,7 @@ LWS_CASE("lws::scanner::sync and lws::scanner::run")
lws_test::test_chain(lest_env, MONERO_UNWRAP(db.start_read()), last_block.id, {hashes.data(), 1});
{
boost::thread server_thread(&rpc_thread, rpc.zmq_context(), std::cref(messages));
boost::thread server_thread(&lws_test::rpc_thread, rpc.zmq_context(), std::cref(messages));
const join on_scope_exit{server_thread};
EXPECT(lws::scanner::sync(db.clone(), MONERO_UNWRAP(rpc.connect())));
lws_test::test_chain(lest_env, MONERO_UNWRAP(db.start_read()), last_block.id, epee::to_span(hashes));
@ -398,7 +400,7 @@ LWS_CASE("lws::scanner::sync and lws::scanner::run")
message.hashes.resize(1);
messages.push_back(daemon_response(message));
boost::thread server_thread(&rpc_thread, rpc.zmq_context(), std::cref(messages));
boost::thread server_thread(&lws_test::rpc_thread, rpc.zmq_context(), std::cref(messages));
const join on_scope_exit{server_thread};
EXPECT(lws::scanner::sync(db.clone(), MONERO_UNWRAP(rpc.connect())));
lws_test::test_chain(lest_env, MONERO_UNWRAP(db.start_read()), last_block.id, epee::to_span(hashes));
@ -505,7 +507,7 @@ LWS_CASE("lws::scanner::sync and lws::scanner::run")
messages.push_back(daemon_response(hmessage));
{
boost::thread server_thread(&rpc_thread, rpc.zmq_context(), std::cref(messages));
boost::thread server_thread(&lws_test::rpc_thread, rpc.zmq_context(), std::cref(messages));
const join on_scope_exit{server_thread};
EXPECT(lws::scanner::sync(db.clone(), MONERO_UNWRAP(rpc.connect())));
lws_test::test_chain(lest_env, MONERO_UNWRAP(db.start_read()), last_block.id, epee::to_span(hashes));
@ -524,7 +526,7 @@ LWS_CASE("lws::scanner::sync and lws::scanner::run")
bmessage.output_indices.resize(1);
messages.push_back(daemon_response(bmessage));
{
boost::thread server_thread(&rpc_thread, rpc.zmq_context(), std::cref(messages));
boost::thread server_thread(&lws_test::rpc_thread, rpc.zmq_context(), std::cref(messages));
const join on_scope_exit{server_thread};
lws::scanner::run(db.clone(), std::move(rpc), 1, epee::net_utils::ssl_verification_t::none, true);
}