atomizer.hpp

Go to the documentation of this file.

// Copyright (c) 2021 MIT Digital Currency Initiative,
//                    Federal Reserve Bank of Boston
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef OPENCBDC_TX_SRC_ATOMIZER_ATOMIZER_H_
#define OPENCBDC_TX_SRC_ATOMIZER_ATOMIZER_H_
 
#include "block.hpp"
#include "uhs/atomizer/watchtower/tx_error_messages.hpp"
#include "uhs/transaction/transaction.hpp"
#include "util/common/hashmap.hpp"
 
#include <map>
#include <mutex>
#include <unordered_map>
#include <unordered_set>
 
namespace cbdc::atomizer {
    class atomizer {
      public:
        atomizer(uint64_t best_height, size_t stxo_cache_depth);
 
        ~atomizer() = default;
 
        atomizer() = delete;
        atomizer(const atomizer&) = delete;
        auto operator=(const atomizer&) -> atomizer& = delete;
        atomizer(atomizer&&) = delete;
        auto operator=(atomizer&&) -> atomizer& = delete;
 
        [[nodiscard]] auto insert(uint64_t block_height,
                                  transaction::compact_tx tx,
                                  std::unordered_set<uint32_t> attestations)
            -> std::optional<watchtower::tx_error>;
 
        [[nodiscard]] auto insert_complete(uint64_t oldest_attestation,
                                           transaction::compact_tx&& tx)
            -> std::optional<watchtower::tx_error>;
 
        [[nodiscard]] auto make_block()
            -> std::pair<cbdc::atomizer::block,
                         std::vector<watchtower::tx_error>>;
 
        [[nodiscard]] auto pending_transactions() const -> size_t;
 
        [[nodiscard]] auto height() const -> uint64_t;
 
        [[nodiscard]] auto serialize() -> buffer;
 
        void deserialize(serializer& buf);
 
        auto operator==(const atomizer& other) const -> bool;
 
      private:
        std::vector<std::unordered_map<transaction::compact_tx,
                                       std::unordered_set<uint32_t>,
                                       transaction::compact_tx_hasher>>
            m_txs;
 
        // These maps should be keyed/salted for safety. For now they
        // use input values directly as an optimization.
        std::vector<transaction::compact_tx> m_complete_txs;
 
        std::vector<std::unordered_set<hash_t, hashing::null>> m_spent;
 
        uint64_t m_best_height{};
        size_t m_spent_cache_depth;
 
        [[nodiscard]] auto get_notification_offset(uint64_t block_height) const
            -> uint64_t;
 
        [[nodiscard]] auto
        check_notification_offset(uint64_t height_offset,
                                  const transaction::compact_tx& tx) const
            -> std::optional<watchtower::tx_error>;
 
        [[nodiscard]] auto check_stxo_cache(const transaction::compact_tx& tx,
                                            uint64_t cache_check_range) const
            -> std::optional<watchtower::tx_error>;
 
        void add_tx_to_stxo_cache(const transaction::compact_tx& tx);
    };
}
 
#endif // OPENCBDC_TX_SRC_ATOMIZER_ATOMIZER_H_