What I've done so far

Author: EduMenges

src/account/GeniusAccount.cpp

@@ -12,6 +12,7 @@
 #include <WalletCore/Hash.h>
 #include <WalletCore/PrivateKey.h>
 #include <ipfs_pubsub/gossip_pubsub.hpp>
+#include <string>
 
 #include "base/hexutil.hpp"
 #include "local_secure_storage/impl/json/JSONSecureStorage.hpp"
@@ -195,6 +196,21 @@ namespace sgns
         return nullptr;
     }
 
+    std::shared_ptr<GeniusAccount> GeniusAccount::NewFromPublicKey( TokenID          token_id,
+                                                                    std::string_view public_key,
+                                                                    bool             full_node )
+    {
+        if ( auto response = LoadGeniusAccount( public_key ); response.has_value() )
+        {
+            genius_account_logger()->debug( "Loaded existing Genius address" );
+            return CreateInstanceFromResponse( token_id, std::move( response.value() ), full_node );
+        }
+
+        genius_account_logger()->error( "Could not load Genius address from storage" );
+
+        return nullptr;
+    }
+
     std::shared_ptr<GeniusAccount> GeniusAccount::New( TokenID                        token_id,
                                                        const boost::filesystem::path &base_path,
                                                        bool                           full_node )
@@ -213,6 +229,31 @@ namespace sgns
         return GeniusAccount::NewFromMnemonic( token_id, wallet.getMnemonic(), base_path, full_node );
     }
 
+    std::vector<std::string> GeniusAccount::GetAvailableAccounts( const boost::filesystem::path &base_path )
+    {
+        auto file_path = SetupStoragePath( base_path );
+        genius_account_logger()->info( "Secure storage ID path: {}", file_path.string() );
+        std::ifstream file( file_path.string() );
+
+        if ( !file.is_open() )
+        {
+            genius_account_logger()->debug( "Could not find ID file" );
+            return {};
+        }
+
+        std::vector<std::string> addresses;
+        std::string              line;
+
+        while ( std::getline( file, line ) )
+        {
+            addresses.push_back( std::move( line ) );
+        }
+
+        genius_account_logger()->debug( "Found {} addresses in files", addresses.size() );
+
+        return addresses;
+    }
+
     outcome::result<GeniusAccount::StorageWithAddress> GeniusAccount::LoadGeniusAccount(
         const boost::filesystem::path &base_path )
     {
@@ -272,6 +313,37 @@ namespace sgns
                                std::make_pair( KeyGenerator::ElGamal( std::move( key_seed ) ), std::move( eth_key ) ) );
     }
 
+    outcome::result<GeniusAccount::StorageWithAddress> GeniusAccount::LoadGeniusAccount( std::string_view public_key )
+    {
+        OUTCOME_TRY( std::vector<uint8_t> vec, base::unhex( public_key ) );
+
+        std::shared_ptr<ISecureStorage> storage = std::make_shared<SecureStorageImpl>(
+            std::string( SECURE_STORAGE_PREFIX ) + libp2p::multi::detail::encodeBase58( vec ) );
+
+        auto load_res = storage->Load( "sgns_key" );
+        if ( !load_res )
+        {
+            genius_account_logger()->warn( "Could not load sgns_key from secure storage" );
+            return std::errc::no_such_file_or_directory;
+        }
+
+        auto key_seed = nil::crypto3::multiprecision::uint256_t( load_res.value() );
+        genius_account_logger()->info( "Successfully loaded key_seed from storage" );
+
+        // Validate loaded key_seed matches stored public key
+        if ( ethereum::EthereumKeyGenerator( key_seed ).GetEntirePubValue() != public_key )
+        {
+            genius_account_logger()->error( "Validation failed: key_seed does not match stored public key" );
+            return std::errc::bad_message;
+        }
+        genius_account_logger()->info( "Validation successful: key_seed matches stored public key" );
+
+        ethereum::EthereumKeyGenerator eth_key( key_seed );
+
+        return std::make_pair( std::move( storage ),
+                               std::make_pair( KeyGenerator::ElGamal( std::move( key_seed ) ), std::move( eth_key ) ) );
+    }
+
     outcome::result<GeniusAccount::StorageWithAddress> GeniusAccount::GenerateGeniusAddress(
         const char                    *eth_private_key,
         const boost::filesystem::path &base_path )
@@ -403,13 +475,16 @@ namespace sgns
         {
             if ( auto self = weakptr.lock() )
             {
-                std::lock_guard lock( self->get_cids_mutex_ );
-                if ( self->get_utxos_method_ )
+                std::vector<std::string> results;
+                auto                     utxos = self->GetUTXOManager().GetUTXOs( address );
+                results.reserve( utxos.size() );
+
+                for ( const auto &utxo : utxos )
                 {
-                    return self->get_utxos_method_( address );
+                    results.push_back( utxo.GetTxID().toReadableString() );
                 }
 
-                return outcome::failure( AccountMessenger::Error::UTXO_REQUEST_ERROR );
+                return results;
             }
 
             return outcome::failure( std::errc::owner_dead );
@@ -541,9 +616,9 @@ namespace sgns
                                   TokenID                                         token_id,
                                   std::shared_ptr<ISecureStorage>                 storage,
                                   bool                                            full_node ) :
-        eth_keypair_( std::move( eth_keypair ) ),
         token( token_id ),
         is_full_node_( full_node ),
+        eth_keypair_( std::move( eth_keypair ) ),
         storage_( std::move( storage ) ),
         utxo_manager_(
             is_full_node_,
@@ -799,7 +874,7 @@ namespace sgns
         if ( cached_nonce_result_.has_value() )
         {
             auto now          = std::chrono::steady_clock::now();
-            auto cache_age_ms = std::chrono::duration_cast<std::chrono::milliseconds>( now - cached_nonce_timestamp_ )
+            uint64_t cache_age_ms = std::chrono::duration_cast<std::chrono::milliseconds>( now - cached_nonce_timestamp_ )
                                     .count();
 
             if ( cache_age_ms < NONCE_CACHE_DURATION_MS )
@@ -984,19 +1059,6 @@ namespace sgns
         has_cid_method_ = nullptr;
     }
 
-    void GeniusAccount::SetGetUTXOsMethod(
-        std::function<outcome::result<std::vector<std::string>>( const std::string & )> method )
-    {
-        std::lock_guard lock( get_cids_mutex_ );
-        get_utxos_method_ = std::move( method );
-    }
-
-    void GeniusAccount::ClearGetUTXOsMethod()
-    {
-        std::lock_guard lock( get_cids_mutex_ );
-        get_utxos_method_ = nullptr;
-    }
-
     void GeniusAccount::SetGetValidatorWeightMethod(
         std::function<outcome::result<std::optional<uint64_t>>( const std::string & )> method )
     {

src/account/GeniusAccount.hpp

@@ -17,7 +17,6 @@
 #include <functional>
 #include <optional>
 #include <set>
-#include <storage/rocksdb/rocksdb.hpp>
 #include <string_view>
 
 #include <boost/multiprecision/cpp_int.hpp>
@@ -28,6 +27,7 @@
 #include <ProofSystem/EthereumKeyGenerator.hpp>
 
 #include "account/TokenID.hpp"
+#include "storage/rocksdb/rocksdb.hpp"
 #include "local_secure_storage/ISecureStorage.hpp"
 #include "outcome/outcome.hpp"
 #include "UTXOManager.hpp"
@@ -38,15 +38,6 @@ namespace sgns
 {
     using namespace boost::multiprecision;
 
-    namespace ipfs_pubsub
-    {
-        class GossipPubSub;
-    }
-
-    namespace crdt
-    {
-        class GlobalDB;
-    }
     class AccountMessenger;
     class TransactionManager;
 
@@ -56,12 +47,6 @@ namespace sgns
         using StorageWithAddress = std::pair<std::shared_ptr<ISecureStorage>,
                                              std::pair<KeyGenerator::ElGamal, ethereum::EthereumKeyGenerator>>;
 
-        struct Credentials
-        {
-            std::string email;
-            std::string password;
-        };
-
         static const std::array<uint8_t, 32> ELGAMAL_PUBKEY_PREDEFINED;      ///< Predefined ElGamal public key
         static constexpr uint64_t            NONCE_CACHE_DURATION_MS = 5000; ///< Cache nonce results for 5 seconds
 
@@ -83,6 +68,10 @@ namespace sgns
                                                                const boost::filesystem::path &base_path,
                                                                bool                           full_node = false );
 
+        static std::shared_ptr<GeniusAccount> NewFromPublicKey( TokenID          token_id,
+                                                                std::string_view public_key,
+                                                                bool             full_node = false );
+
         /**
          * @brief       Factory constructor of new GeniusAccount
          * @param[in]   token_id Token ID of the account
@@ -91,6 +80,8 @@ namespace sgns
                                                    const boost::filesystem::path &base_path,
                                                    bool                           full_node = false );
 
+        static std::vector<std::string> GetAvailableAccounts( const boost::filesystem::path &base_path );
+
         /**
          * @brief       Initialize the messenger for the account
          * @param[in]   pubsub pubsub instance
@@ -274,9 +265,6 @@ namespace sgns
         void ClearGetBlockChainCIDMethod();
         void SetHasBlockCidMethod( std::function<outcome::result<bool>( const std::string & )> method );
         void ClearHasBlockCidMethod();
-        void SetGetUTXOsMethod(
-            std::function<outcome::result<std::vector<std::string>>( const std::string & )> method );
-        void ClearGetUTXOsMethod();
         void SetGetValidatorWeightMethod(
             std::function<outcome::result<std::optional<uint64_t>>( const std::string & )> method );
         void ClearGetValidatorWeightMethod();
@@ -289,6 +277,8 @@ namespace sgns
 
         static outcome::result<StorageWithAddress> LoadGeniusAccount( const boost::filesystem::path &base_path );
 
+        static outcome::result<StorageWithAddress> LoadGeniusAccount( std::string_view public_key );
+
         static std::shared_ptr<GeniusAccount> CreateInstanceFromResponse( TokenID            token_id,
                                                                           StorageWithAddress response_value,
                                                                           bool               full_node );