transaction.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_TRANSACTION_TRANSACTION_H_
#define OPENCBDC_TX_SRC_TRANSACTION_TRANSACTION_H_
 
#include "crypto/sha256.h"
#include "util/common/hash.hpp"
#include "util/common/keys.hpp"
#include "util/serialization/format.hpp"
#include "util/serialization/util.hpp"
 
#include <cstdint>
#include <optional>
 
namespace cbdc::transaction {
    struct out_point {
        hash_t m_tx_id{};
 
        uint64_t m_index{0};
 
        auto operator==(const out_point& rhs) const -> bool;
        auto operator<(const out_point& rhs) const -> bool;
 
        out_point(const hash_t& hash, uint64_t index);
 
        out_point() = default;
    };
    struct out_point {…};
 
    struct output {
        hash_t m_witness_program_commitment{};
 
        uint64_t m_value{0};
 
        auto operator==(const output& rhs) const -> bool;
        auto operator!=(const output& rhs) const -> bool;
 
        output(hash_t witness_program_commitment, uint64_t value);
 
        output() = default;
    };
    struct output {…};
 
    struct input {
        out_point m_prevout;
 
        output m_prevout_data;
 
        auto operator==(const input& rhs) const -> bool;
        auto operator!=(const input& rhs) const -> bool;
 
        [[nodiscard]] auto hash() const -> hash_t;
 
        input() = default;
    };
    struct input {…};
 
    struct full_tx {
        std::vector<input> m_inputs{};
 
        std::vector<output> m_outputs{};
 
        std::vector<witness_t> m_witness{};
 
        auto operator==(const full_tx& rhs) const -> bool;
 
        full_tx() = default;
    };
    struct full_tx {…};
 
    using sentinel_attestation = std::pair<pubkey_t, signature_t>;
 
    struct compact_tx {
        hash_t m_id{};
 
        std::vector<hash_t> m_inputs;
 
        std::vector<hash_t> m_uhs_outputs;
 
        std::unordered_map<pubkey_t, signature_t, hashing::null>
            m_attestations;
 
        auto operator==(const compact_tx& tx) const noexcept -> bool;
 
        compact_tx() = default;
 
        explicit compact_tx(const full_tx& tx);
 
        [[nodiscard]] auto sign(secp256k1_context* ctx,
                                const privkey_t& key) const
            -> sentinel_attestation;
 
        [[nodiscard]] auto verify(secp256k1_context* ctx,
                                  const sentinel_attestation& att) const
            -> bool;
 
        [[nodiscard]] auto hash() const -> hash_t;
    };
    struct compact_tx {…};
 
    struct compact_tx_hasher {
        auto operator()(compact_tx const& tx) const noexcept -> size_t;
    };
    struct compact_tx_hasher {…};
 
    [[nodiscard]] auto tx_id(const full_tx& tx) noexcept -> hash_t;
 
    auto input_from_output(const full_tx& tx, size_t i, const hash_t& txid)
        -> std::optional<input>;
 
    auto input_from_output(const full_tx& tx, size_t i)
        -> std::optional<input>;
 
    auto uhs_id_from_output(const hash_t& entropy,
                            uint64_t i,
                            const output& output) -> hash_t;
}
 
#endif // OPENCBDC_TX_SRC_TRANSACTION_TRANSACTION_H_