Remove AbstractBlockchainExplorer dependency from TezosLikeBlockchainExplorer

- Remove some unused code
- Use single address instead of vector of addresses in explorer endpoints
- Remove sessions mechanism from TezosLikeBlockchainExplorer

Author: Remi Barjon

core/src/wallet/tezos/TezosLikeAccount.cpp

@@ -129,15 +129,15 @@ namespace ledger {
                 if (transaction.type == api::TezosOperationTag::OPERATION_TAG_ORIGINATION && transaction.status == 1) {
                     updateOriginatedAccounts(sql, operation);
                 }
-                out.push_back(operation);               
+                out.push_back(operation);
                 result = static_cast<int>(transaction.type);
             }
 
             if (_accountAddress == transaction.receiver) {
                 operation.amount = transaction.value;
                 operation.type = api::OperationType::RECEIVE;
                 operation.refreshUid();
-                out.push_back(operation);   
+                out.push_back(operation);
                 result = static_cast<int>(transaction.type);
             }
         }
@@ -164,13 +164,13 @@ namespace ledger {
                 auto originatedAccountUid = TezosLikeAccountDatabaseHelper::createOriginatedAccountUid(getAccountUid(), origAccount.address);
 
             const auto found = std::find_if (
-                _originatedAccounts.begin(), 
-                _originatedAccounts.end(), 
-                [&originatedAccountUid](const std::shared_ptr<api::TezosLikeOriginatedAccount>& element) { 
+                _originatedAccounts.begin(),
+                _originatedAccounts.end(),
+                [&originatedAccountUid](const std::shared_ptr<api::TezosLikeOriginatedAccount>& element) {
                     return std::dynamic_pointer_cast<TezosLikeOriginatedAccount>(element)->getAccountUid() == originatedAccountUid;
                 });
 
-            if (found == _originatedAccounts.end()) {    
+            if (found == _originatedAccounts.end()) {
                 _originatedAccounts.emplace_back(
                         std::make_shared<TezosLikeOriginatedAccount>(originatedAccountUid,
                                                                      origAccount.address,
@@ -205,10 +205,9 @@ namespace ledger {
             if (cachedBalance.hasValue()) {
                 return FuturePtr<Amount>::successful(std::make_shared<Amount>(cachedBalance.getValue()));
             }
-            std::vector<TezosLikeKeychain::Address> listAddresses{_keychain->getAddress()};
             auto currency = getWallet()->getCurrency();
             auto self = getSelf();
-            return _explorer->getBalance(listAddresses).mapPtr<Amount>(getMainExecutionContext(), [self, currency](
+            return _explorer->getBalance(_keychain->getAddress()).mapPtr<Amount>(getMainExecutionContext(), [self, currency](
                     const std::shared_ptr<BigInt> &balance) -> std::shared_ptr<Amount> {
                 Amount b(currency, 0, BigInt(balance->toString()));
                 self->getWallet()->updateBalanceCache(self->getIndex(), b);

core/src/wallet/tezos/TezosLikeAccount2.cpp

@@ -215,7 +215,7 @@ namespace ledger {
                 // Check if balance is sufficient
                 auto currency = self->getWallet()->getCurrency();
                 auto accountAddress = TezosLikeAddress::fromBase58(senderAddress, currency);
-                return explorer->getBalance(std::vector<std::shared_ptr<TezosLikeAddress>>{accountAddress}).flatMapPtr<api::TezosLikeTransaction>(
+                return explorer->getBalance(accountAddress).flatMapPtr<api::TezosLikeTransaction>(
                         self->getMainExecutionContext(),
                         [self, request, explorer, accountAddress, currency, senderAddress](const std::shared_ptr<BigInt> &balance) {
                             // Check if all needed values are set

core/src/wallet/tezos/explorers/ExternalTezosLikeBlockchainExplorer.cpp

@@ -28,97 +28,77 @@
  *
  */
 
-#pragma once
-#include <wallet/common/explorers/AbstractLedgerApiBlockchainExplorer.h>
+#ifndef LEDGER_CORE_EXTERNALTEZOSLIKEBLOCKCHAINEXPLORER_H
+#define LEDGER_CORE_EXTERNALTEZOSLIKEBLOCKCHAINEXPLORER_H
+
 #include <wallet/tezos/explorers/TezosLikeBlockchainExplorer.h>
-#include <wallet/tezos/explorers/api/TezosLikeTransactionsParser.h>
-#include <wallet/tezos/explorers/api/TezosLikeTransactionsBulkParser.h>
-#include <wallet/tezos/explorers/api/TezosLikeBlockParser.h>
-#include <api/TezosLikeNetworkParameters.hpp>
 #include <wallet/tezos/api_impl/TezosLikeTransactionApi.h>
 
 namespace ledger {
     namespace core {
-        using ExternalApiBlockchainExplorer = AbstractLedgerApiBlockchainExplorer<
-                TezosLikeBlockchainExplorerTransaction,
-                TezosLikeBlockchainExplorer::TransactionsBulk,
-                TezosLikeTransactionsParser,
-                TezosLikeTransactionsBulkParser,
-                TezosLikeBlockParser,
-                api::TezosLikeNetworkParameters>;
-
-        class ExternalTezosLikeBlockchainExplorer : public TezosLikeBlockchainExplorer,
-                                                    public ExternalApiBlockchainExplorer,
-                                                    public DedicatedContext,
-                                                    public std::enable_shared_from_this<ExternalTezosLikeBlockchainExplorer> {
+
+        class ExternalTezosLikeBlockchainExplorer : public TezosLikeBlockchainExplorer
+        {
         public:
-            ExternalTezosLikeBlockchainExplorer(const std::shared_ptr<api::ExecutionContext> &context,
-                                                const std::shared_ptr<HttpClient> &http,
-                                                const api::TezosLikeNetworkParameters &parameters,
-                                                const std::shared_ptr<api::DynamicObject> &configuration);
+            ExternalTezosLikeBlockchainExplorer(
+                const std::shared_ptr<api::ExecutionContext> &context,
+                const std::shared_ptr<HttpClient> &http,
+                const api::TezosLikeNetworkParameters &parameters,
+                const std::shared_ptr<ledger::core::api::DynamicObject> &configuration);
 
             Future<std::shared_ptr<BigInt>>
-            getBalance(const std::vector<TezosLikeKeychain::Address> &addresses) override;
+            getBalance(const TezosLikeKeychain::Address &address) const override;
 
             Future<std::shared_ptr<BigInt>>
-            getFees() override;
+            getFees() const override;
 
             Future<std::shared_ptr<BigInt>>
-            getGasPrice() override;
-
-            Future<String> pushLedgerApiTransaction(const std::vector<uint8_t> &transaction) override;
-
-            Future<void *> startSession() override;
+            getGasPrice() const override;
 
-            Future<Unit> killSession(void *session) override;
-
-            Future<Bytes> getRawTransaction(const String &transactionHash) override;
-
-            Future<String> pushTransaction(const std::vector<uint8_t> &transaction) override;
+            Future<String> pushLedgerApiTransaction(const std::vector<uint8_t> &transaction) override ;
 
             FuturePtr<TezosLikeBlockchainExplorer::TransactionsBulk>
-            getTransactions(const std::vector<std::string> &addresses,
-                            Option<std::string> offset = Option<std::string>(),
-                            Option<void *> session = Option<void *>()) override;
-
-            FuturePtr<Block> getCurrentBlock() const override;
-
-            FuturePtr<TezosLikeBlockchainExplorerTransaction>
-            getTransactionByHash(const String &transactionHash) const override;
+            getTransactions(const std::string& address,
+                            const Either<std::string, uint32_t>& token = {}) const override;
 
-            Future<int64_t> getTimestamp() const override;
-
-            std::shared_ptr<api::ExecutionContext> getExplorerContext() const override;
-
-            api::TezosLikeNetworkParameters getNetworkParameters() const override;
+            FuturePtr<Block>
+            getCurrentBlock() const override;
 
             std::string getExplorerVersion() const override;
 
             Future<std::shared_ptr<BigInt>>
-            getEstimatedGasLimit(const std::string &address) override;
+            getEstimatedGasLimit(const std::string &address) const override;
 
             Future<std::shared_ptr<GasLimit>>
-            getEstimatedGasLimit(const std::shared_ptr<TezosLikeTransactionApi> &transaction) override;
+            getEstimatedGasLimit(const std::shared_ptr<TezosLikeTransactionApi> &tx) const override;
 
             Future<std::shared_ptr<BigInt>>
-            getStorage(const std::string &address) override;
+            getStorage(const std::string &address) const override;
 
-            Future<std::shared_ptr<BigInt>> getCounter(const std::string &address) override;
+            Future<std::vector<uint8_t>>
+            forgeKTOperation(const std::shared_ptr<TezosLikeTransactionApi> &tx) const override;
 
-            Future<std::vector<uint8_t>> forgeKTOperation(const std::shared_ptr<TezosLikeTransactionApi> &tx) override;
+            Future<std::string>
+            getManagerKey(const std::string &address) const override;
 
-            Future<std::string> getManagerKey(const std::string &address) override;
+            Future<bool>
+            isAllocated(const std::string &address) const override;
 
-            Future<bool> isAllocated(const std::string &address) override;
+            Future<std::string>
+            getCurrentDelegate(const std::string &address) const override;
 
-            Future<std::string> getCurrentDelegate(const std::string &address) override;
+            Future<std::shared_ptr<BigInt>>
+            getCounter(const std::string &address) const override;
 
-            Future<bool> isFunded(const std::string &address) override;
+            Future<bool>
+            isFunded(const std::string &address) const override;
 
-            Future<std::shared_ptr<BigInt>>
-            getTokenBalance(const std::string& accountAddress, const std::string& tokenAddress) const override;
+            Future<bool>
+            isDelegate(const std::string &address) const override;
 
-            Future<bool> isDelegate(const std::string &address) override;
+            Future<std::shared_ptr<BigInt>>
+            getTokenBalance(const std::string& accountAddress,
+                            const std::string& tokenAddress) const override;
 
         private:
             /*
@@ -132,14 +112,16 @@ namespace ledger {
             Future<std::shared_ptr<BigInt>>
             getHelper(const std::string &url,
                       const std::string &field,
-                      const std::unordered_map<std::string, std::string> &params = std::unordered_map<std::string, std::string>(),
+                      const std::unordered_map<std::string, std::string> &params = {},
                       const std::string &fallbackValue = "",
                       const std::string &forceUrl = "",
-                      bool isDecimal = false);
+                      bool isDecimal = false) const;
 
-            api::TezosLikeNetworkParameters _parameters;
-            std::unordered_map<std::string, uint64_t> _sessions;
+        private:
             std::string _bcd;
         };
-    }
-}
+
+    } // namespace core
+} // namespace ledger
+
+#endif //LEDGER_CORE_EXTERNALTEZOSLIKEBLOCKCHAINEXPLORER_H