Currency is now optional for withdraw-fee CLI, renamed into withdraw-…

…fees

src/api-objects/include/exchangepublicapitypes.hpp

@@ -9,14 +9,12 @@
 #include "market.hpp"
 #include "marketorderbook.hpp"
 #include "monetaryamount.hpp"
-#include "monetaryamountbycurrencyset.hpp"
 #include "publictrade.hpp"
 
 namespace cct {
 using MarketSet = FlatSet<Market>;
 using MarketOrderBookMap = std::unordered_map<Market, MarketOrderBook>;
 using MarketPriceMap = std::unordered_map<Market, MonetaryAmount>;
 using MarketsPath = SmallVector<Market, 3>;
-using WithdrawalFeesSet = MonetaryAmountByCurrencySet;
 using LastTradesVector = vector<PublicTrade>;
 }  // namespace cct

src/api/common/include/exchangeprivateapi.hpp

@@ -1,14 +1,12 @@
 #pragma once
 
-#include <chrono>
 #include <span>
 #include <utility>
 
 #include "apikey.hpp"
 #include "balanceoptions.hpp"
 #include "balanceportfolio.hpp"
 #include "cachedresultvault.hpp"
-#include "curlhandle.hpp"
 #include "currencycode.hpp"
 #include "currencyexchangeflatset.hpp"
 #include "depositsconstraints.hpp"
@@ -19,7 +17,7 @@
 #include "exchangepublicapitypes.hpp"
 #include "market.hpp"
 #include "monetaryamount.hpp"
-#include "order.hpp"
+#include "monetaryamountbycurrencyset.hpp"
 #include "orderid.hpp"
 #include "ordersconstraints.hpp"
 #include "tradedamounts.hpp"
@@ -105,11 +103,11 @@ class ExchangePrivate : public ExchangeBase {
 
   /// Retrieve the fixed withdrawal fees per currency.
   /// Some exchanges provide this service in the public REST API but not all, hence this private API flavor.
-  virtual WithdrawalFeesSet queryWithdrawalFees() { return _exchangePublic.queryWithdrawalFees(); }
+  virtual MonetaryAmountByCurrencySet queryWithdrawalFees() { return _exchangePublic.queryWithdrawalFees(); }
 
   /// Retrieve the withdrawal fee of a Currency only
   /// Some exchanges provide this service in the public REST API but not all, hence this private API flavor.
-  virtual MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) {
+  virtual std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) {
     return _exchangePublic.queryWithdrawalFee(currencyCode);
   }
 

src/api/common/include/exchangepublicapi.hpp

@@ -12,8 +12,8 @@
 #include "market.hpp"
 #include "marketorderbook.hpp"
 #include "monetaryamount.hpp"
+#include "monetaryamountbycurrencyset.hpp"
 #include "priceoptions.hpp"
-#include "tradedefinitions.hpp"
 
 namespace cct {
 
@@ -70,10 +70,10 @@ class ExchangePublic : public ExchangeBase {
   /// Retrieve the fixed withdrawal fees per currency.
   /// Depending on the exchange, this could be retrieved dynamically,
   /// or, if not possible, should be retrieved from a static source updated regularly.
-  virtual WithdrawalFeesSet queryWithdrawalFees() = 0;
+  virtual MonetaryAmountByCurrencySet queryWithdrawalFees() = 0;
 
   /// Retrieve the withdrawal fee of a Currency only
-  virtual MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) = 0;
+  virtual std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) = 0;
 
   /// Return true if exchange supports official REST API has an endpoint to get withdrawal fees
   /// For instance, Kraken does not offer such endpoint, we nee to query external sources which may provide inaccurate
@@ -162,6 +162,10 @@ class ExchangePublic : public ExchangeBase {
 
   CommonAPI &commonAPI() { return _commonApi; }
 
+  /// Query withdrawal fee for given currency code.
+  /// If no data found, return a 0 MonetaryAmount on given currency.
+  MonetaryAmount queryWithdrawalFeeOrZero(CurrencyCode currencyCode);
+
  protected:
   friend class ExchangePrivate;
 

src/api/common/include/exchangepublicapi_mock.hpp

@@ -2,10 +2,13 @@
 
 #include <gmock/gmock.h>
 
+#include <optional>
+
 #include "commonapi.hpp"
 #include "exchangepublicapi.hpp"
 #include "exchangepublicapitypes.hpp"
 #include "fiatconverter.hpp"
+#include "monetaryamount.hpp"
 
 namespace cct::api {
 class MockExchangePublic : public ExchangePublic {
@@ -19,8 +22,8 @@ class MockExchangePublic : public ExchangePublic {
   MOCK_METHOD(CurrencyExchange, convertStdCurrencyToCurrencyExchange, (CurrencyCode currencyCode), (override));
   MOCK_METHOD(MarketSet, queryTradableMarkets, (), (override));
   MOCK_METHOD(MarketPriceMap, queryAllPrices, (), (override));
-  MOCK_METHOD(WithdrawalFeesSet, queryWithdrawalFees, (), (override));
-  MOCK_METHOD(MonetaryAmount, queryWithdrawalFee, (CurrencyCode currencyCode), (override));
+  MOCK_METHOD(MonetaryAmountByCurrencySet, queryWithdrawalFees, (), (override));
+  MOCK_METHOD(std::optional<MonetaryAmount>, queryWithdrawalFee, (CurrencyCode currencyCode), (override));
   MOCK_METHOD(bool, isWithdrawalFeesSourceReliable, (), (const override));
   MOCK_METHOD(MarketOrderBookMap, queryAllApproximatedOrderBooks, (int depth), (override));
   MOCK_METHOD(MarketOrderBook, queryOrderBook, (Market mk, int depth), (override));

src/api/common/src/exchangepublicapi.cpp

@@ -325,4 +325,16 @@ Market ExchangePublic::determineMarketFromFilterCurrencies(MarketSet &markets, C
   return ret;
 }
 
+MonetaryAmount ExchangePublic::queryWithdrawalFeeOrZero(CurrencyCode currencyCode) {
+  std::optional<MonetaryAmount> optWithdrawFee = queryWithdrawalFee(currencyCode);
+  MonetaryAmount withdrawFee;
+  if (optWithdrawFee) {
+    withdrawFee = *optWithdrawFee;
+  } else {
+    log::error("Unable to retrieve withdraw fee for {} on {}, consider 0", currencyCode, name());
+    withdrawFee = MonetaryAmount(0, currencyCode);
+  }
+  return withdrawFee;
+}
+
 }  // namespace cct::api

src/api/exchanges/include/binanceprivateapi.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <optional>
 #include <type_traits>
 
 #include "apikey.hpp"
@@ -13,7 +14,6 @@
 #include "depositsconstraints.hpp"
 #include "exchangeprivateapi.hpp"
 #include "exchangeprivateapitypes.hpp"
-#include "exchangepublicapitypes.hpp"
 #include "httprequesttype.hpp"
 #include "monetaryamount.hpp"
 #include "ordersconstraints.hpp"
@@ -54,9 +54,11 @@ class BinancePrivate : public ExchangePrivate {
 
   WithdrawsSet queryRecentWithdraws(const WithdrawsConstraints& withdrawsConstraints = WithdrawsConstraints()) override;
 
-  WithdrawalFeesSet queryWithdrawalFees() override { return _allWithdrawFeesCache.get(); }
+  MonetaryAmountByCurrencySet queryWithdrawalFees() override { return _allWithdrawFeesCache.get(); }
 
-  MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) override { return _withdrawFeesCache.get(currencyCode); }
+  std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) override {
+    return _withdrawFeesCache.get(currencyCode);
+  }
 
  protected:
   bool isSimulatedOrderSupported() const override { return true; }
@@ -111,14 +113,14 @@ class BinancePrivate : public ExchangePrivate {
                         Duration& queryDelay)
         : BinanceContext(curlHandle, apiKey, exchangePublic, queryDelay) {}
 
-    WithdrawalFeesSet operator()();
+    MonetaryAmountByCurrencySet operator()();
   };
 
   struct WithdrawFeesFunc : public BinanceContext {
     WithdrawFeesFunc(CurlHandle& curlHandle, const APIKey& apiKey, BinancePublic& exchangePublic, Duration& queryDelay)
         : BinanceContext(curlHandle, apiKey, exchangePublic, queryDelay) {}
 
-    MonetaryAmount operator()(CurrencyCode currencyCode);
+    std::optional<MonetaryAmount> operator()(CurrencyCode currencyCode);
   };
 
   CurlHandle _curlHandle;

src/api/exchanges/include/binancepublicapi.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <optional>
 #include <string_view>
 #include <unordered_map>
 
@@ -46,9 +47,9 @@ class BinancePublic : public ExchangePublic {
 
   MarketPriceMap queryAllPrices() override { return MarketPriceMapFromMarketOrderBookMap(_allOrderBooksCache.get(1)); }
 
-  WithdrawalFeesSet queryWithdrawalFees() override;
+  MonetaryAmountByCurrencySet queryWithdrawalFees() override;
 
-  MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) override;
+  std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) override;
 
   bool isWithdrawalFeesSourceReliable() const override { return true; }
 

src/api/exchanges/include/bithumbpublicapi.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <optional>
 #include <string_view>
 
 #include "cachedresult.hpp"
@@ -34,9 +35,9 @@ class BithumbPublic : public ExchangePublic {
 
   MarketPriceMap queryAllPrices() override { return MarketPriceMapFromMarketOrderBookMap(_allOrderBooksCache.get()); }
 
-  WithdrawalFeesSet queryWithdrawalFees() override { return _withdrawalFeesCache.get(); }
+  MonetaryAmountByCurrencySet queryWithdrawalFees() override { return _withdrawalFeesCache.get(); }
 
-  MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) override;
+  std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) override;
 
   bool isWithdrawalFeesSourceReliable() const override { return true; }
 
@@ -74,7 +75,7 @@ class BithumbPublic : public ExchangePublic {
                        settings::RunMode runMode)
         : _curlHandle(kFeeUrl, pMetricGateway, permanentCurlOptions, runMode) {}
 
-    WithdrawalFeesSet operator()();
+    MonetaryAmountByCurrencySet operator()();
 
     CurlHandle _curlHandle;
   };

src/api/exchanges/include/huobipublicapi.hpp

@@ -1,12 +1,12 @@
 #pragma once
 
 #include <limits>
+#include <optional>
 #include <string_view>
 #include <unordered_map>
 
 #include "cachedresult.hpp"
 #include "cct_json.hpp"
-#include "cct_string.hpp"
 #include "curlhandle.hpp"
 #include "currencycode.hpp"
 #include "exchangepublicapi.hpp"
@@ -42,9 +42,9 @@ class HuobiPublic : public ExchangePublic {
 
   MarketPriceMap queryAllPrices() override { return MarketPriceMapFromMarketOrderBookMap(_allOrderBooksCache.get(1)); }
 
-  WithdrawalFeesSet queryWithdrawalFees() override;
+  MonetaryAmountByCurrencySet queryWithdrawalFees() override;
 
-  MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) override;
+  std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) override;
 
   bool isWithdrawalFeesSourceReliable() const override { return true; }
 

src/api/exchanges/include/krakenpublicapi.hpp

@@ -1,7 +1,8 @@
 #pragma once
 
+#include <optional>
+
 #include "cachedresult.hpp"
-#include "cct_string.hpp"
 #include "curlhandle.hpp"
 #include "exchangepublicapi.hpp"
 #include "exchangepublicapitypes.hpp"
@@ -35,9 +36,9 @@ class KrakenPublic : public ExchangePublic {
 
   MarketPriceMap queryAllPrices() override { return MarketPriceMapFromMarketOrderBookMap(_allOrderBooksCache.get(1)); }
 
-  WithdrawalFeesSet queryWithdrawalFees() override { return _withdrawalFeesCache.get().first; }
+  MonetaryAmountByCurrencySet queryWithdrawalFees() override { return _withdrawalFeesCache.get().first; }
 
-  MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) override;
+  std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) override;
 
   bool isWithdrawalFeesSourceReliable() const override { return false; }
 
@@ -76,7 +77,7 @@ class KrakenPublic : public ExchangePublic {
   class WithdrawalFeesFunc {
    public:
     using WithdrawalMinMap = std::unordered_map<CurrencyCode, MonetaryAmount>;
-    using WithdrawalInfoMaps = std::pair<WithdrawalFeesSet, WithdrawalMinMap>;
+    using WithdrawalInfoMaps = std::pair<MonetaryAmountByCurrencySet, WithdrawalMinMap>;
 
     WithdrawalFeesFunc(const CoincenterInfo& coincenterInfo, Duration minDurationBetweenQueries);
 

src/api/exchanges/include/kucoinpublicapi.hpp

@@ -1,13 +1,11 @@
 #pragma once
 
-#include <limits>
+#include <optional>
 #include <string_view>
 #include <unordered_map>
 
 #include "cachedresult.hpp"
 #include "cct_flatset.hpp"
-#include "cct_json.hpp"
-#include "cct_string.hpp"
 #include "curlhandle.hpp"
 #include "curlpostdata.hpp"
 #include "currencycode.hpp"
@@ -44,9 +42,9 @@ class KucoinPublic : public ExchangePublic {
 
   MarketPriceMap queryAllPrices() override { return MarketPriceMapFromMarketOrderBookMap(_allOrderBooksCache.get(1)); }
 
-  WithdrawalFeesSet queryWithdrawalFees() override;
+  MonetaryAmountByCurrencySet queryWithdrawalFees() override;
 
-  MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) override;
+  std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) override;
 
   bool isWithdrawalFeesSourceReliable() const override { return true; }
 

src/api/exchanges/include/upbitprivateapi.hpp

@@ -35,7 +35,7 @@ class UpbitPrivate : public ExchangePrivate {
 
   WithdrawsSet queryRecentWithdraws(const WithdrawsConstraints& withdrawsConstraints = WithdrawsConstraints()) override;
 
-  MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) override {
+  std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) override {
     return _withdrawalFeesCache.get(currencyCode);
   }
 
@@ -70,7 +70,7 @@ class UpbitPrivate : public ExchangePrivate {
   };
 
   struct WithdrawFeesFunc {
-    MonetaryAmount operator()(CurrencyCode currencyCode);
+    std::optional<MonetaryAmount> operator()(CurrencyCode currencyCode);
 
     CurlHandle& _curlHandle;
     const APIKey& _apiKey;

src/api/exchanges/include/upbitpublicapi.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <optional>
 #include <string_view>
 
 #include "cachedresult.hpp"
@@ -33,9 +34,9 @@ class UpbitPublic : public ExchangePublic {
 
   MarketPriceMap queryAllPrices() override { return MarketPriceMapFromMarketOrderBookMap(_allOrderBooksCache.get(1)); }
 
-  WithdrawalFeesSet queryWithdrawalFees() override { return _withdrawalFeesCache.get(); }
+  MonetaryAmountByCurrencySet queryWithdrawalFees() override { return _withdrawalFeesCache.get(); }
 
-  MonetaryAmount queryWithdrawalFee(CurrencyCode currencyCode) override;
+  std::optional<MonetaryAmount> queryWithdrawalFee(CurrencyCode currencyCode) override;
 
   bool isWithdrawalFeesSourceReliable() const override { return true; }
 
@@ -79,7 +80,7 @@ class UpbitPublic : public ExchangePublic {
   };
 
   struct WithdrawalFeesFunc {
-    WithdrawalFeesSet operator()();
+    MonetaryAmountByCurrencySet operator()();
 
     const string& _name;
     std::string_view _dataDir;

src/api/exchanges/src/binanceprivateapi.cpp

@@ -542,7 +542,7 @@ WithdrawsSet BinancePrivate::queryRecentWithdraws(const WithdrawsConstraints& wi
   return withdrawsSet;
 }
 
-WithdrawalFeesSet BinancePrivate::AllWithdrawFeesFunc::operator()() {
+MonetaryAmountByCurrencySet BinancePrivate::AllWithdrawFeesFunc::operator()() {
   json result = PrivateQuery(_curlHandle, _apiKey, HttpRequestType::kGet, "/sapi/v1/asset/assetDetail", _queryDelay);
   vector<MonetaryAmount> fees;
   for (const auto& [curCodeStr, withdrawFeeDetails] : result.items()) {
@@ -551,20 +551,20 @@ WithdrawalFeesSet BinancePrivate::AllWithdrawFeesFunc::operator()() {
       fees.emplace_back(withdrawFeeDetails["withdrawFee"].get<std::string_view>(), cur);
     }
   }
-  return WithdrawalFeesSet(std::move(fees));
+  return MonetaryAmountByCurrencySet(std::move(fees));
 }
 
-MonetaryAmount BinancePrivate::WithdrawFeesFunc::operator()(CurrencyCode currencyCode) {
+std::optional<MonetaryAmount> BinancePrivate::WithdrawFeesFunc::operator()(CurrencyCode currencyCode) {
   json result = PrivateQuery(_curlHandle, _apiKey, HttpRequestType::kGet, "/sapi/v1/asset/assetDetail", _queryDelay,
                              {{"asset", currencyCode.str()}});
   if (!result.contains(currencyCode.str())) {
-    throw exception("Unable to find asset information in assetDetail query to Binance");
+    return {};
   }
   const json& withdrawFeeDetails = result[currencyCode.str()];
   if (!withdrawFeeDetails["withdrawStatus"].get<bool>()) {
     log::error("{} is currently unavailable for withdraw from {}", currencyCode, _exchangePublic.name());
   }
-  return {withdrawFeeDetails["withdrawFee"].get<std::string_view>(), currencyCode};
+  return MonetaryAmount(withdrawFeeDetails["withdrawFee"].get<std::string_view>(), currencyCode);
 }
 
 namespace {