gulliver
/
oc-mint
mirror of https://github.com/OpenCoin/oc-mint-cpp.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fixes for warnings from code analysis

This commit is contained in:
Gulliver 2023-04-20 22:55:17 +02:00
parent 84cbb34391
commit e3fd9cb576
8 changed files with 152 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -18,8 +18,8 @@ The following table gives an overview of the mapping of requests to URLs:
| Request | URL | Response | C++ Interface Method | | Request | URL | Response | C++ Interface Method |
|:------------------|:-------------|:------------------------------|:---------------------------------------------------| |:------------------|:-------------|:------------------------------|:---------------------------------------------------|
| RequestCDDCSerial | /cddc/serial | ResponseCDDCSerial | cdd.cdd_serial of Model::getCurrentCDDC() | | RequestCDDCSerial | /cddc/serial | ResponseCDDCSerial | cdd.cdd_serial of Model::get_current_cddc() |
| RequestCDDC | /cddc | ResponseCDDC | Model::getCurrentCDDC() | | RequestCDDC | /cddc | ResponseCDDC | Model::get_current_cddc() |
| RequestMKCs | /mkcs | ResponseMKCs | Model::getMKCs | | RequestMKCs | /mkcs | ResponseMKCs | Model::getMKCs |
| RequestMint | /mint | ResponseMint | Model::mint | | RequestMint | /mint | ResponseMint | Model::mint |
| RequestRenew | /renew | ResponseMint or ResponseDelay | ? | | RequestRenew | /renew | ResponseMint or ResponseDelay | ? |

104
src/big_int.cpp
View File

@ -1,82 +1,76 @@
#include "big_int.hpp" #include "big_int.hpp"
#include "tl/expected.hpp" #include "tl/expected.hpp"
#include <iostream>
#include <charconv> #include <charconv>
#include <vector>
#pragma clang diagnostic push
#pragma ide diagnostic ignored "clion-misra-cpp2008-6-4-5"
inline uint8_t hex(char c) { inline uint8_t hex(char c) {
switch(c) { switch(c) {
case '0': return 0; case '0': return 0U;
case '1': return 1; case '1': return 1U;
case '2': return 2; case '2': return 2U;
case '3': return 3; case '3': return 3U;
case '4': return 4; case '4': return 4U;
case '5': return 5; case '5': return 5U;
case '6': return 6; case '6': return 6U;
case '7': return 7; case '7': return 7U;
case '8': return 8; case '8': return 8U;
case '9': return 9; case '9': return 9U;
case 'a': return 10; case 'a': return 10U;
case 'b': return 11; case 'b': return 11U;
case 'c': return 12; case 'c': return 12U;
case 'd': return 13; case 'd': return 13U;
case 'e': return 14; case 'e': return 14U;
case 'f': return 15; case 'f': return 15U;
case 'A': return 10; case 'A': return 10U;
case 'B': return 11; case 'B': return 11U;
case 'C': return 12; case 'C': return 12U;
case 'D': return 13; case 'D': return 13U;
case 'E': return 14; case 'E': return 14U;
case 'F': return 15; case 'F': return 15U;
default: default:
return 0xff; return 0xffU;
} }
} }
#pragma clang diagnostic pop
tl::expected<BigInt,BigInt::eError> tl::expected<BigInt,BigInt::eError>
BigInt::from_string(const std::string& str) { BigInt::from_string(const std::string& str) {
BigInt b; BigInt b;
// std::cout << str << std::endl;
uint8_t hval=0; uint8_t hval=0U;
uint8_t nibble; uint8_t nibble;
size_t i = str.size()+1; size_t i = str.size()+1U;
for(auto c : str) { for(auto c : str) {
nibble = hex(c); nibble = hex(c);
if (nibble ==0xFF) { if (nibble ==0xFFU) {
return tl::make_unexpected(eError::PARSE_ERROR); return tl::make_unexpected(eError::PARSE_ERROR);
} }
if (i%2) { if ( i%2U != 0U ) {
hval = nibble << 4; hval = nibble << 4U;
} else { } else {
hval |= nibble; hval |= nibble;
b.data[256 - (i/2)]= hval; b.data[256U - (i/2U)]= hval;
hval = 0; hval = 0U;
} }
i--; i--;
} }
// std::cout << std::hex;
// for (auto b: b.data)
// {
// std::cout << (int)b;
// }
// std::cout << std::dec << std::endl;
return b; return b;
} }
BigInt BigInt::from_int(uint64_t value) BigInt BigInt::from_int(uint64_t value)
{ {
BigInt b; BigInt b;
b.data[248]=(value >> 56 & 0xff); b.data[248U]=static_cast<uint8_t>(value >> 56 & 0xffU);
b.data[249]=(value >> 48 & 0xff); b.data[249U]=static_cast<uint8_t>(value >> 48 & 0xffU);
b.data[250]=(value >> 40 & 0xff); b.data[250U]=static_cast<uint8_t>(value >> 40U & 0xffU);
b.data[251]=(value >> 32 & 0xff); b.data[251U]=static_cast<uint8_t>(value >> 32U & 0xffU);
b.data[252]=(value >> 24 & 0xff); b.data[252U]=static_cast<uint8_t>(value >> 24U & 0xffU);
b.data[253]=(value >> 16 & 0xff); b.data[253U]=static_cast<uint8_t>(value >> 16U & 0xffU);
b.data[254]=(value >> 8 & 0xff); b.data[254U]=static_cast<uint8_t>(value >> 8U & 0xffU);
b.data[255]=(value & 0xff); b.data[255U]=static_cast<uint8_t>(value & 0xffU);
return b; return b;
} }
@ -85,14 +79,16 @@ std::string BigInt::to_string() const
{ {
std::string s; std::string s;
uint8_t b; uint8_t b;
uint8_t first_digit = 0; uint8_t first_digit = 0U;
for (size_t i = 0; i<256;i++) { for (size_t i = 0U; i<256U;i++) {
b = data[i]; b = data[i];
if (first_digit==0) { if (first_digit==0U) {
if (b==0) { if (b==0U) {
continue; continue;
} else if (b>0xf) { } else if (b>0xfU) {
s.push_back(hex_char[b >> 4]); s.push_back(hex_char[b >> 4]);
} else {
/* nothing to do here */
} }
s.push_back(hex_char[b & 0xf]); s.push_back(hex_char[b & 0xf]);
first_digit = b; first_digit = b;

12
src/big_int.hpp
View File

@ -1,5 +1,5 @@
#ifndef BIG_INT_HPP #ifndef OC_ISSUER_BIG_INT_HPP
#define BIG_INT_HPP #define OC_ISSUER_BIG_INT_HPP
#include <string> #include <string>
#include <array> #include <array>
@ -9,19 +9,19 @@
struct BigInt { struct BigInt {
BigInt() : data() {} BigInt() : data() {}
virtual ~BigInt() {} virtual ~BigInt() = default;
enum class eError : uint8_t { PARSE_ERROR }; enum class eError : uint8_t { PARSE_ERROR };
static tl::expected<BigInt, eError> from_string(const std::string &str); static tl::expected<BigInt, eError> from_string(const std::string &str);
static BigInt from_int(uint64_t value); static BigInt from_int(uint64_t value);
std::string to_string() const; [[nodiscard]] std::string to_string() const;
friend bool operator == (const BigInt& rhs, const BigInt& lhs); friend bool operator == (const BigInt& rhs, const BigInt& lhs);
private: private:
std::array<uint8_t,256> data; std::array<uint8_t,256U> data;
}; };
bool operator==(const BigInt &rhs, const BigInt &lhs); bool operator==(const BigInt &rhs, const BigInt &lhs);
#endif // #ifndef #ifndef BIG_INT_HPP #endif // #ifndef #ifndef OC_ISSUER_BIG_INT_HPP

26
src/json_serialisation.cpp
View File

@ -10,16 +10,18 @@
template <class T> template <class T>
crow::json::wvalue list_to_json(const std::vector<T> &array) { crow::json::wvalue list_to_json(const std::vector<T> &array) {
crow::json::wvalue::list l; crow::json::wvalue::list l;
for (auto item : array) for (const auto& item : array) {
l.push_back(item.to_json()); l.push_back(item.to_json());
return crow::json::wvalue(l); }
return {l};
} }
crow::json::wvalue list_to_json(const std::vector<unsigned int> &array) { crow::json::wvalue list_to_json(const std::vector<unsigned int> &array) {
crow::json::wvalue::list l; crow::json::wvalue::list l;
for (auto item : array) for (auto item : array) {
l.push_back(item); l.emplace_back(item);
return crow::json::wvalue(l); }
return {l};
} }
crow::json::wvalue PublicKey::to_json() const { crow::json::wvalue PublicKey::to_json() const {
@ -35,7 +37,7 @@ crow::json::wvalue WeightedUrl::to_json() const {
crow::json::wvalue w(weight); crow::json::wvalue w(weight);
l.push_back(w); l.push_back(w);
l.push_back(url); l.emplace_back(url);
return l; return l;
} }
@ -171,7 +173,7 @@ RequestMKCs::from_string(const std::string &str) {
if (denominations.t() != crow::json::type::List) { if (denominations.t() != crow::json::type::List) {
return tl::make_unexpected(eError::JSON_WRONG_REQUEST_TYPE); return tl::make_unexpected(eError::JSON_WRONG_REQUEST_TYPE);
} else { } else {
for (auto d : denominations.lo()) { for (const auto& d : denominations.lo()) {
r.denominations.push_back(d.u()); r.denominations.push_back(d.u());
} }
} }
@ -179,7 +181,7 @@ RequestMKCs::from_string(const std::string &str) {
if (mint_key_ids.t() != crow::json::type::List) { if (mint_key_ids.t() != crow::json::type::List) {
return tl::make_unexpected(eError::JSON_WRONG_REQUEST_TYPE); return tl::make_unexpected(eError::JSON_WRONG_REQUEST_TYPE);
} else { } else {
for (auto k: mint_key_ids.lo()) { for (const auto& k: mint_key_ids.lo()) {
auto kv = BigInt::from_string(k.s()); auto kv = BigInt::from_string(k.s());
if (!kv.has_value()) { if (!kv.has_value()) {
return tl::make_unexpected(eError::JSON_PARSE_ERROR); return tl::make_unexpected(eError::JSON_PARSE_ERROR);
@ -269,7 +271,7 @@ RequestMint::from_string(const std::string &str) {
return tl::make_unexpected(eError::JSON_WRONG_VALUE_TYPE); return tl::make_unexpected(eError::JSON_WRONG_VALUE_TYPE);
} }
for (auto item : json["blinds"]) { for (const auto& item : json["blinds"]) {
auto b = Blind::from_json(item); auto b = Blind::from_json(item);
if (!b.has_value()) { if (!b.has_value()) {
return tl::make_unexpected(b.error()); return tl::make_unexpected(b.error());
@ -384,7 +386,7 @@ RequestRenew::from_string(const std::string &str) {
} else { } else {
RequestRenew r; RequestRenew r;
for (auto item : json["coins"]) { for (const auto& item : json["coins"]) {
auto coin = Coin::from_json(item); auto coin = Coin::from_json(item);
if (!coin.has_value()) { if (!coin.has_value()) {
return tl::make_unexpected(coin.error()); return tl::make_unexpected(coin.error());
@ -393,7 +395,7 @@ RequestRenew::from_string(const std::string &str) {
} }
} }
for (auto item : json["blinds"]) { for (const auto& item : json["blinds"]) {
auto blind = Blind::from_json(item); auto blind = Blind::from_json(item);
if (!blind.has_value()) { if (!blind.has_value()) {
return tl::make_unexpected(blind.error()); return tl::make_unexpected(blind.error());
@ -453,7 +455,7 @@ RequestRedeem::from_string(const std::string &str) {
return tl::make_unexpected(eError::JSON_WRONG_VALUE_TYPE); return tl::make_unexpected(eError::JSON_WRONG_VALUE_TYPE);
} }
for (auto item : json["coins"]) { for (const auto& item : json["coins"]) {
auto coin = Coin::from_json(item); auto coin = Coin::from_json(item);
if (!coin.has_value()) { if (!coin.has_value()) {
return tl::make_unexpected(coin.error()); return tl::make_unexpected(coin.error());

23
src/main.cpp
View File

@ -1,22 +1,22 @@
#include "crow.h" #include "crow.h"
#include "crow/common.h" #include "crow/common.h"
#include "crow/http_parser_merged.h"
#include "crow/http_response.h" #include "crow/http_response.h"
#include "model.hpp" #include "model.hpp"
int main() { int main() {
crow::SimpleApp app; crow::SimpleApp app;
std::shared_ptr<Model> model = Model::getModel("simple"); std::shared_ptr<Model> model = Model::get_model("simple");
CROW_ROUTE(app, "/cddc") CROW_ROUTE(app, "/cddc")
.methods(crow::HTTPMethod::POST)([&model](const crow::request &req) { .methods(crow::HTTPMethod::POST)
([&model](const crow::request &req) {
auto req_cddc = RequestCDDC::from_string(req.body); auto req_cddc = RequestCDDC::from_string(req.body);
if (!req_cddc) { if (!req_cddc) {
return crow::response(crow::status::BAD_REQUEST); return crow::response(crow::status::BAD_REQUEST);
} else { } else {
ResponseCDDC res; ResponseCDDC res;
res.message_reference = req_cddc->message_reference; res.message_reference = req_cddc->message_reference;
auto cddc = model->getCDDC(req_cddc->cdd_serial); auto cddc = model->get_cddc(req_cddc->cdd_serial);
if (!cddc) { if (!cddc) {
res.status_code = crow::status::NOT_FOUND; res.status_code = crow::status::NOT_FOUND;
} else { } else {
@ -36,7 +36,7 @@ int main() {
ResponseCDDCSerial res; ResponseCDDCSerial res;
res.message_reference = req->message_reference; res.message_reference = req->message_reference;
auto cddc = model->getCurrentCDDC(); auto cddc = model->get_current_cddc();
if (!cddc) { if (!cddc) {
res.status_code = crow::status::NOT_FOUND; res.status_code = crow::status::NOT_FOUND;
} else { } else {
@ -47,8 +47,8 @@ int main() {
} }
}); });
CROW_ROUTE(app, "/mkcs") CROW_ROUTE(app, "/mkcs").methods(crow::HTTPMethod::POST)
.methods(crow::HTTPMethod::POST)([&model](const crow::request &request) { ([&model](const crow::request &request) {
auto req = RequestMKCs::from_string(request.body); auto req = RequestMKCs::from_string(request.body);
if (!req) { if (!req) {
return crow::response(crow::status::BAD_REQUEST); return crow::response(crow::status::BAD_REQUEST);
@ -61,8 +61,8 @@ int main() {
} }
}); });
CROW_ROUTE(app, "/mint") CROW_ROUTE(app, "/mint").methods(crow::HTTPMethod::POST)
.methods(crow::HTTPMethod::POST)([&model](const crow::request &request) { ([&model](const crow::request &request) {
auto req = RequestMint::from_string(request.body); auto req = RequestMint::from_string(request.body);
if (!req) { if (!req) {
return crow::response(crow::status::BAD_REQUEST); return crow::response(crow::status::BAD_REQUEST);
@ -70,8 +70,9 @@ int main() {
ResponseMint res; ResponseMint res;
res.message_reference = req->message_reference; res.message_reference = req->message_reference;
/// \todo change argument transaction_reference to bigint /// \todo change argument transaction_reference to bigint
auto minted = model->mint(req->transaction_reference.to_string(), req->blinds); auto minted =
model->mint(req->transaction_reference.to_string(), req->blinds);
res.blind_signatures = minted; res.blind_signatures = minted;
res.status_code = crow::status::OK; res.status_code = crow::status::OK;

72
src/model.cpp
View File

@ -4,53 +4,53 @@
using std::cout; using std::cout;
using std::endl; using std::endl;
#define UNUSED(s) /* s */ #define UNUSED(s) /* s */
/** this is for now our sample model */ /** this is for now our sample model */
class DefaultModel : public Model { class DefaultModel : public Model {
public: public:
DefaultModel() {} DefaultModel() = default;
tl::expected<CDDC *, bool> getCDDC(unsigned int cdd_serial) override {
cout << __FUNCTION__ << "(" << cdd_serial << ")" << endl;
return &m_cddc;
};
tl::expected<CDDC *, bool> getCurrentCDDC() override { tl::expected<CDDC *, bool> get_cddc(unsigned int cdd_serial) override {
cout << __FUNCTION__ << "()" << endl; cout << __FUNCTION__ << "(" << cdd_serial << ")" << endl; // NOLINT(clion-misra-cpp2008-5-2-12)
return &m_cddc;
};
return &m_cddc; tl::expected<CDDC *, bool> get_current_cddc() override {
} cout << __FUNCTION__ << "()" << endl;
std::vector<BlindSignature> return &m_cddc;
mint(const std::string& UNUSED(transaction_reference), }
const std::vector<Blind> &UNUSED(blinds) ) override
{
std::vector<BlindSignature> res;
cout << __FUNCTION__ << "("
<< ")" << endl;
return res; std::vector<BlindSignature>
} mint(const std::string & UNUSED(transaction_reference),
const std::vector<Blind> &UNUSED(blinds)) override {
std::vector<BlindSignature> res;
cout << __FUNCTION__ << "("
<< ")" << endl;
const std::vector<MintKeyCert> return res;
getMKCs(const std::vector<unsigned int> & UNUSED(denominations), }
const std::vector<BigInt> & UNUSED(mint_key_ids) ) override
{
std::vector<MintKeyCert> res;
cout << __FUNCTION__ << endl;
return res;
}
bool redeem(const std::vector<Coin> &UNUSED(coins)) override { std::vector<MintKeyCert>
cout << __FUNCTION__ << endl; getMKCs(const std::vector<unsigned int> & UNUSED(denominations),
return false; const std::vector<BigInt> & UNUSED(mint_key_ids)) override {
} std::vector<MintKeyCert> res;
cout << __FUNCTION__ << endl;
return res;
}
bool redeem(const std::vector<Coin> &UNUSED(coins)) override {
cout << __FUNCTION__ << endl;
return false;
}
private: private:
CDDC m_cddc; CDDC m_cddc;
}; };
std::unique_ptr<Model> Model::getModel(const std::string & /*backend_name*/) { std::unique_ptr<Model> Model::get_model(const std::string & /*backend_name*/) {
cout << __FUNCTION__ << endl; cout << __FUNCTION__ << endl;
//:wq //:wq
// if (backend_name=="default") // if (backend_name=="default")
return std::make_unique<DefaultModel>(); return std::make_unique<DefaultModel>();
} }

56
src/model.hpp
View File

@ -1,5 +1,5 @@
#ifndef MODEL_HPP #ifndef OC_ISSUER_MODEL_HPP
#define MODEL_HPP #define OC_ISSUER_MODEL_HPP
#include <chrono> #include <chrono>
#include <memory> #include <memory>
@ -15,14 +15,14 @@ struct PublicKey {
BigInt modulus; //: "daaa63ddda38c189b8c49020c8276adbe0a695685a...", BigInt modulus; //: "daaa63ddda38c189b8c49020c8276adbe0a695685a...",
BigInt public_exponent;//: 65537, BigInt public_exponent;//: 65537,
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
}; };
struct WeightedUrl { struct WeightedUrl {
uint32_t weight; uint32_t weight;
std::string url; std::string url;
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
}; };
/** @brief currency description document /** @brief currency description document
@ -58,14 +58,14 @@ struct CDD {
std::vector<WeightedUrl> redeem_service; std::vector<WeightedUrl> redeem_service;
std::vector<WeightedUrl> renew_service; std::vector<WeightedUrl> renew_service;
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
}; };
struct CDDC { struct CDDC {
CDD cdd; CDD cdd;
std::string signature; std::string signature;
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
}; };
struct MintKey { struct MintKey {
@ -79,14 +79,14 @@ struct MintKey {
std::string sign_coins_not_after; std::string sign_coins_not_after;
std::string sign_coins_not_before; std::string sign_coins_not_before;
// "type": "mint key" // "type": "mint key"
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
}; };
struct MintKeyCert { struct MintKeyCert {
MintKey mint_key; MintKey mint_key;
std::string signature; std::string signature;
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
}; };
enum class eError { enum class eError {
@ -103,7 +103,7 @@ struct Response {
unsigned int status_code; unsigned int status_code;
std::string status_description; std::string status_description;
virtual crow::json::wvalue to_json() const; [[nodiscard]] virtual crow::json::wvalue to_json() const=0;
}; };
struct RequestCDDCSerial { struct RequestCDDCSerial {
@ -114,9 +114,9 @@ struct RequestCDDCSerial {
}; };
struct ResponseCDDCSerial : Response { struct ResponseCDDCSerial : Response {
unsigned int cdd_serial; unsigned int cdd_serial{0U};
crow::json::wvalue to_json() const override; [[nodiscard]] crow::json::wvalue to_json() const override;
}; };
struct RequestCDDC { struct RequestCDDC {
@ -129,7 +129,7 @@ struct RequestCDDC {
struct ResponseCDDC : Response { struct ResponseCDDC : Response {
CDDC cddc; CDDC cddc;
crow::json::wvalue to_json() const override; [[nodiscard]] crow::json::wvalue to_json() const override;
}; };
struct RequestMKCs { struct RequestMKCs {
@ -144,21 +144,21 @@ struct RequestMKCs {
struct ResponseMKCs : Response { struct ResponseMKCs : Response {
std::vector<MintKeyCert> keys; std::vector<MintKeyCert> keys;
crow::json::wvalue to_json() const override; [[nodiscard]] crow::json::wvalue to_json() const override;
}; };
struct Blind { struct Blind {
BigInt blinded_payload_hash; //bigint BigInt blinded_payload_hash; //bigint
BigInt mint_key_id; //bigint BigInt mint_key_id; //bigint
std::string reference; std::string reference;
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
static tl::expected<Blind, eError> from_json(const crow::json::rvalue &json); static tl::expected<Blind, eError> from_json(const crow::json::rvalue &json);
}; };
struct BlindSignature { struct BlindSignature {
BigInt blind_signature; BigInt blind_signature;
std::string reference; std::string reference;
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
}; };
struct RequestMint { struct RequestMint {
@ -173,7 +173,7 @@ struct RequestMint {
struct ResponseMint : Response { struct ResponseMint : Response {
std::vector<BlindSignature> blind_signatures; std::vector<BlindSignature> blind_signatures;
crow::json::wvalue to_json() const override; [[nodiscard]] crow::json::wvalue to_json() const override;
}; };
struct Coin { struct Coin {
@ -184,15 +184,15 @@ struct Coin {
BigInt mint_key_id; BigInt mint_key_id;
std::string protocol_version; std::string protocol_version;
BigInt serial; BigInt serial;
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
static tl::expected<Payload,eError> from_json(const crow::json::rvalue& json); static tl::expected<Payload,eError> from_json(const crow::json::rvalue& json);
}; };
Payload payload; Payload payload;
std::string signature; std::string signature;
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
static tl::expected<Coin, eError> from_json(const crow::json::rvalue &json); static tl::expected<Coin, eError> from_json(const crow::json::rvalue &json);
}; };
@ -200,7 +200,7 @@ struct CoinStack {
std::vector<Coin> coins; std::vector<Coin> coins;
std::string subject; std::string subject;
// "type": "coinstack" // "type": "coinstack"
crow::json::wvalue to_json() const; [[nodiscard]] crow::json::wvalue to_json() const;
}; };
struct RequestRenew { struct RequestRenew {
@ -214,7 +214,7 @@ struct RequestRenew {
}; };
struct ResponseDelay : Response { struct ResponseDelay : Response {
crow::json::wvalue to_json() const override; [[nodiscard]] crow::json::wvalue to_json() const override;
}; };
struct RequestResume { struct RequestResume {
@ -236,12 +236,12 @@ struct RequestRedeem {
}; };
struct ResponseRedeem : Response { struct ResponseRedeem : Response {
crow::json::wvalue to_json() const override; [[nodiscard]] crow::json::wvalue to_json() const override;
}; };
class Model { class Model {
public: public:
virtual ~Model(){}; virtual ~Model()=default;
/** /**
* return the CurrencyDocumentDescription certifikate for a specific * return the CurrencyDocumentDescription certifikate for a specific
@ -249,13 +249,13 @@ public:
* [see spec](https://opencoin.org/0.4/schemata.html#cddc) * [see spec](https://opencoin.org/0.4/schemata.html#cddc)
* @return returns a pointer to the CDDC if successful, false otherwise * @return returns a pointer to the CDDC if successful, false otherwise
*/ */
virtual tl::expected<CDDC *, bool> getCDDC(unsigned int cdd_serial) = 0; virtual tl::expected<CDDC *, bool> get_cddc(unsigned int cdd_serial) = 0;
/** /**
* return the CurrencyDocumentDescription certifikate * return the CurrencyDocumentDescription certifikate
* [see spec](https://opencoin.org/0.4/schemata.html#cddc) * [see spec](https://opencoin.org/0.4/schemata.html#cddc)
* @return returns a pointer to the CDDC if successful, false otherwise * @return returns a pointer to the CDDC if successful, false otherwise
*/virtual tl::expected<CDDC *, bool> getCurrentCDDC() = 0; */virtual tl::expected<CDDC *, bool> get_current_cddc() = 0;
/** /**
* return the MintKey certificates for a given list of denominations * return the MintKey certificates for a given list of denominations
@ -266,7 +266,7 @@ public:
* *
* @return mint key certificates for given denominations and mint_key_ids * @return mint key certificates for given denominations and mint_key_ids
*/ */
virtual const std::vector<MintKeyCert> virtual std::vector<MintKeyCert>
getMKCs(const std::vector<unsigned int> &denominations, getMKCs(const std::vector<unsigned int> &denominations,
const std::vector<BigInt> &mint_key_ids) = 0; const std::vector<BigInt> &mint_key_ids) = 0;
@ -300,9 +300,9 @@ public:
* *
* @return pointer to backend instance or null on invalid backend name * @return pointer to backend instance or null on invalid backend name
*/ */
static std::unique_ptr<Model> getModel(const std::string &backend_name); static std::unique_ptr<Model> get_model(const std::string &backend_name);
private: private:
}; };
#endif // #ifndef MODEL_HPP #endif // #ifndef OC_ISSUER_MODEL_HPP

8
test/test_big_int.cpp
View File

@ -2,7 +2,7 @@
#include <catch2/catch_test_macros.hpp> #include <catch2/catch_test_macros.hpp>
TEST_CASE("BigInt::from_string", "[big_int]") { TEST_CASE("BigInt::from_string", "[big_int]") {
std::string VALID [] = { const std::string VALID [] = {
"1", "1",
"12", "12",
"123", "123",
@ -17,10 +17,10 @@ TEST_CASE("BigInt::from_string", "[big_int]") {
"abcdef1" "abcdef1"
}; };
for (size_t i= 0; i<sizeof(VALID)/sizeof(VALID[0]);i++) { for (const auto & i : VALID) {
auto b = BigInt::from_string(VALID[i]); auto b = BigInt::from_string(i);
REQUIRE(b->to_string() == VALID[i]);
REQUIRE(b.has_value()); REQUIRE(b.has_value());
REQUIRE(b->to_string() == i);
} }
auto invalid_hex = "aabbcc.."; auto invalid_hex = "aabbcc..";