validation.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_VALIDATION_H_
#define OPENCBDC_TX_SRC_TRANSACTION_VALIDATION_H_
 
#include "transaction.hpp"
 
#include <cassert>
#include <memory>
#include <optional>
#include <secp256k1.h>
#include <secp256k1_schnorrsig.h>
#include <set>
#include <variant>
 
namespace cbdc::transaction::validation {
    enum class witness_program_type : uint8_t {
        p2pk = 0x0 
    };
 
    static constexpr auto p2pk_witness_prog_len
        = sizeof(witness_program_type) + sizeof(pubkey_t);
    static constexpr auto p2pk_witness_len = p2pk_witness_prog_len + sig_len;
 
    enum class input_error_code : uint8_t {
        duplicate,
        data_error 
    };
 
    enum class output_error_code : uint8_t {
        zero_value 
    };
 
    struct input_error {
        auto operator==(const input_error& rhs) const -> bool;
 
        input_error_code m_code{};
 
        std::optional<output_error_code> m_data_err;
 
        uint64_t m_idx{};
    };
 
    enum class witness_error_code : uint8_t {
        missing_witness_program_type, 
        unknown_witness_program_type,
        malformed, 
        program_mismatch,
        invalid_public_key, 
        invalid_signature   
    };
 
    enum class tx_error_code : uint8_t {
        no_inputs,       
        no_outputs,      
        missing_witness, 
        asymmetric_values,
        value_overflow,
    };
 
    struct witness_error {
        auto operator==(const witness_error& rhs) const -> bool;
 
        witness_error_code m_code{};
 
        uint64_t m_idx{};
    };
 
    struct output_error {
        auto operator==(const output_error& rhs) const -> bool;
 
        output_error_code m_code{};
 
        uint64_t m_idx{};
    };
 
    using tx_error = std::
        variant<input_error, output_error, witness_error, tx_error_code>;
 
    auto check_tx(const transaction::full_tx& tx) -> std::optional<tx_error>;
    auto check_tx_structure(const transaction::full_tx& tx)
        -> std::optional<tx_error>;
    auto check_input_structure(const transaction::input& inp) -> std::optional<
        std::pair<input_error_code, std::optional<output_error_code>>>;
    auto check_in_out_set(const transaction::full_tx& tx)
        -> std::optional<tx_error>;
    // TODO: check input assumptions with flags for whether preconditions have
    //       already been checked.
    auto check_witness(const transaction::full_tx& tx, size_t idx)
        -> std::optional<witness_error_code>;
    auto check_p2pk_witness(const transaction::full_tx& tx, size_t idx)
        -> std::optional<witness_error_code>;
    auto check_p2pk_witness_len(const transaction::full_tx& tx, size_t idx)
        -> std::optional<witness_error_code>;
    auto check_p2pk_witness_commitment(const transaction::full_tx& tx,
                                       size_t idx)
        -> std::optional<witness_error_code>;
    auto check_p2pk_witness_signature(const transaction::full_tx& tx,
                                      size_t idx)
        -> std::optional<witness_error_code>;
    auto check_input_count(const transaction::full_tx& tx)
        -> std::optional<tx_error>;
    auto check_output_count(const transaction::full_tx& tx)
        -> std::optional<tx_error>;
    auto check_witness_count(const transaction::full_tx& tx)
        -> std::optional<tx_error>;
    auto check_input_set(const transaction::full_tx& tx)
        -> std::optional<tx_error>;
    auto check_output_value(const transaction::output& out)
        -> std::optional<output_error_code>;
    auto get_p2pk_witness_commitment(const pubkey_t& payee) -> hash_t;
    auto to_string(const tx_error& err) -> std::string;
 
    auto check_attestations(
        const transaction::compact_tx& tx,
        const std::unordered_set<pubkey_t, hashing::null>& pubkeys,
        size_t threshold) -> bool;
}
 
#endif // OPENCBDC_TX_SRC_TRANSACTION_VALIDATION_H_