account.hpp

Go to the documentation of this file.

#pragma once
#include "ots.hpp"
#include "ots-internal.hpp"
#include "ots-exceptions.hpp"
#include "key-store.hpp"
#include <wipeable_string.h>
#include <cryptonote_basic/cryptonote_format_utils.h>
#include <cryptonote_basic/account.h>
#include <utility>
#include <unordered_map>
#include <set>
 
// transfer_details and exported_transfer_details stuff following
#include <vector>
#include <utility>
#include <crypto/crypto.h>          // For crypto::public_key, crypto::hash, crypto::key_image
#include <crypto/hash.h>            // For crypto::hash (if needed separately)
#include <cryptonote_basic/cryptonote_basic.h>  // For cryptonote::transaction_prefix, cryptonote::subaddress_index
#include <ringct/rctTypes.h>        // For rct::key
#include <serialization/serialization.h> // For serialize support
#include <serialization/variant.h>   // For tools::write_varint
#include <serialization/tuple.h>
#include <serialization/pair.h>
#include <serialization/string.h>
 
namespace ots {
    class Account {
        struct is_out_data;
        struct tx_scan_info_t;
        struct exported_transfer_details;
        struct transfer_details;
        typedef std::vector<transfer_details> transfer_container;
 
        public:
            explicit Account(const std::array<unsigned char, 32>& key, const Network network);
 
            explicit Account(const crypto::secret_key& key, const Network network);
 
            explicit Account(const KeyStore& key, const Network network);
 
            explicit Account(const cryptonote::account_base& account, const Network network);
 
            explicit Account(const Account& account);
 
            Address address() const noexcept;
 
            Address address(uint32_t account, uint32_t index) const noexcept;
 
            Address address(const cryptonote::subaddress_index index) const noexcept;
 
            bool hasAddress(
                    const Address& address,
                    uint32_t maxAccountDepth = DEFAULT_MAX_ACCOUNT_DEPTH,
                    uint32_t maxIndexDepth = DEFAULT_MAX_INDEX_DEPTH
                    ) const noexcept;
 
            std::pair<uint32_t, uint32_t> addressIndex(
                    const Address& address,
                    uint32_t maxAccountDepth = DEFAULT_MAX_ACCOUNT_DEPTH,
                    uint32_t maxIndexDepth = DEFAULT_MAX_INDEX_DEPTH
                    ) const;
 
            WipeableString secretSpendKey() const noexcept;
 
            WipeableString publicSpendKey() const noexcept;
 
            WipeableString secretViewKey() const noexcept;
 
            WipeableString publicViewKey() const noexcept;
 
            void clearAddressCache() const noexcept;
 
            size_t importOutputs(const std::string& outputs);
 
            size_t importOutputs(const std::tuple<uint64_t, uint64_t, std::vector<exported_transfer_details>> &outputs);
 
            size_t importOutputs(const std::tuple<uint64_t, uint64_t, std::vector<transfer_details>> &outputs);
 
            std::string signData(const std::string& data) const;
 
            std::string signData(const std::string& data, const std::pair<uint32_t, uint32_t>& index) const;
 
            std::string signData(
                    const std::string& data,
                    const std::string& address,
                    uint32_t maxAccountDepth = DEFAULT_MAX_ACCOUNT_DEPTH,
                    uint32_t maxIndexDepth = DEFAULT_MAX_INDEX_DEPTH
                    ) const;
 
            std::string signData(const std::string& data, const Address& address, uint32_t maxAccountDepth = DEFAULT_MAX_ACCOUNT_DEPTH, uint32_t maxIndexDepth = DEFAULT_MAX_INDEX_DEPTH) const;
 
            bool static verifyData(const std::string& data, const Address& address, const std::string& signature);
 
            bool static verifyData(const std::string& data, const std::string& address, const std::string& signature);
 
            bool static verifyDataLegacy(const std::string& data, const Address& address, const std::string& signature);
 
            bool static verifyDataLegacy(const std::string& data, const std::string& address, const std::string& signature);
 
        private:
            static crypto::hash hashData(const std::string& data, const crypto::public_key& spendKey, const crypto::public_key& viewKey);
            std::string decrypt_with_view_secret_key(const std::string& ciphertext, bool authenticated = true) const;
 
            void authenticate_with_public_view_view_key(const std::string& data, const crypto::signature& signature) const;
 
            crypto::public_key get_tx_pub_key_from_received_outs(const transfer_details &td) const;
 
    void check_acc_out_precomp(const cryptonote::tx_out &o, const crypto::key_derivation &derivation, const std::vector<crypto::key_derivation> &additional_derivations, size_t i, tx_scan_info_t &tx_scan_info) const;
    void check_acc_out_precomp(const cryptonote::tx_out &o, const crypto::key_derivation &derivation, const std::vector<crypto::key_derivation> &additional_derivations, size_t i, const is_out_data *is_out_data, tx_scan_info_t &tx_scan_info) const;
            cryptonote::account_base m_account;
 
            mutable std::unordered_map<std::string, std::pair<uint32_t, uint32_t>> m_addressCache;
 
            mutable std::map<std::pair<uint32_t, uint32_t>, std::string> m_indexToAddressCache;
 
            mutable std::set<std::pair<uint32_t, uint32_t>> m_addressIndexCache;
 
            std::pair<uint32_t, uint32_t> cachedAddressIndex(const Address& address) const;
 
            void cacheAddress(const Address& address, uint32_t account, uint32_t index) const noexcept;
 
            void cacheAddress(const Address& address, cryptonote::subaddress_index index) const noexcept;
 
            void cacheAddress(cryptonote::subaddress_index index) const noexcept;
 
            bool addressInCache(const Address& address) const noexcept;
            
            bool addressIndexInCache(const std::pair<uint32_t, uint32_t>& index) const noexcept;
            
            bool addressIndexInCache(const uint32_t account, const uint32_t index) const noexcept;
            
            bool addressIndexInCache(const cryptonote::subaddress_index& index) const noexcept;
 
            Address cachedAddress(const uint32_t account, const uint32_t index) const;
 
            Address cachedAddress(const cryptonote::subaddress_index index) const;
            Network m_network;
 
            struct multisig_info
            {
                struct LR
                {
                    rct::key m_L;
                    rct::key m_R;
 
                    BEGIN_SERIALIZE_OBJECT()
                        FIELD(m_L)
                        FIELD(m_R)
                        END_SERIALIZE()
                };
 
                crypto::public_key m_signer;
                std::vector<LR> m_LR;
                std::vector<crypto::key_image> m_partial_key_images; // one per key the participant has
 
                BEGIN_SERIALIZE_OBJECT()
                    FIELD(m_signer)
                    FIELD(m_LR)
                    FIELD(m_partial_key_images)
                    END_SERIALIZE()
            };
 
            struct transfer_details
            {
                uint64_t m_block_height;
                cryptonote::transaction_prefix m_tx;
                crypto::hash m_txid;
                uint64_t m_internal_output_index;
                uint64_t m_global_output_index;
                bool m_spent;
                bool m_frozen;
                uint64_t m_spent_height;
                crypto::key_image m_key_image; //TODO: key_image stored twice :(
                rct::key m_mask;
                uint64_t m_amount;
                bool m_rct;
                bool m_key_image_known;
                bool m_key_image_request; // view wallets: we want to request it; cold wallets: it was requested
                uint64_t m_pk_index;
                cryptonote::subaddress_index m_subaddr_index;
                bool m_key_image_partial;
                std::vector<rct::key> m_multisig_k;
                std::vector<multisig_info> m_multisig_info; // one per other participant
                std::vector<std::pair<uint64_t, crypto::hash>> m_uses;
 
                bool is_rct() const { return m_rct; }
                uint64_t amount() const { return m_amount; }
                const crypto::public_key get_public_key() const {
                    crypto::public_key output_public_key;
                    if(m_tx.vout.size() <= m_internal_output_index)
                        throw ots::exception::wallet::InternalError("Too few outputs, outputs may be corrupted");
                    if(!get_output_public_key(m_tx.vout[m_internal_output_index], output_public_key))
                        throw ots::exception::wallet::InternalError("Unable to get output public key from output");
                    return output_public_key;
                };
 
                BEGIN_SERIALIZE_OBJECT()
                    FIELD(m_block_height)
                    FIELD(m_tx)
                    FIELD(m_txid)
                    FIELD(m_internal_output_index)
                    FIELD(m_global_output_index)
                    FIELD(m_spent)
                    FIELD(m_frozen)
                    FIELD(m_spent_height)
                    FIELD(m_key_image)
                    FIELD(m_mask)
                    FIELD(m_amount)
                    FIELD(m_rct)
                    FIELD(m_key_image_known)
                    FIELD(m_key_image_request)
                    FIELD(m_pk_index)
                    FIELD(m_subaddr_index)
                    FIELD(m_key_image_partial)
                    FIELD(m_multisig_k)
                    FIELD(m_multisig_info)
                    FIELD(m_uses)
                    END_SERIALIZE()
            };
 
            struct exported_transfer_details
            {
                crypto::public_key m_pubkey;
                uint64_t m_internal_output_index;
                uint64_t m_global_output_index;
                crypto::public_key m_tx_pubkey;
                union
                {
                    struct
                    {
                        uint8_t m_spent: 1;
                        uint8_t m_frozen: 1;
                        uint8_t m_rct: 1;
                        uint8_t m_key_image_known: 1;
                        uint8_t m_key_image_request: 1; // view wallets: we want to request it; cold wallets: it was requested
                        uint8_t m_key_image_partial: 1;
                    };
                    uint8_t flags;
                } m_flags;
                uint64_t m_amount;
                std::vector<crypto::public_key> m_additional_tx_keys;
                uint32_t m_subaddr_index_major;
                uint32_t m_subaddr_index_minor;
 
                BEGIN_SERIALIZE_OBJECT()
                    VERSION_FIELD(1)
                    if (version < 1)
                        return false;
                FIELD(m_pubkey)
                    VARINT_FIELD(m_internal_output_index)
                    VARINT_FIELD(m_global_output_index)
                    FIELD(m_tx_pubkey)
                    FIELD(m_flags.flags)
                    VARINT_FIELD(m_amount)
                    FIELD(m_additional_tx_keys)
                    VARINT_FIELD(m_subaddr_index_major)
                    VARINT_FIELD(m_subaddr_index_minor)
                    END_SERIALIZE()
            };
 
            struct tx_scan_info_t
            {
                cryptonote::keypair in_ephemeral;
                crypto::key_image ki;
                rct::key mask;
                uint64_t amount;
                uint64_t money_transfered;
                bool error;
                boost::optional<cryptonote::subaddress_receive_info> received;
 
                tx_scan_info_t(): amount(0), money_transfered(0), error(true) {}
            };
 
            struct is_out_data
            {
                crypto::public_key pkey;
                crypto::key_derivation derivation;
                std::vector<boost::optional<cryptonote::subaddress_receive_info>> received;
            };
 
            transfer_container m_transfers;
            std::unordered_map<crypto::key_image, size_t> m_key_images;
            std::unordered_map<crypto::public_key, size_t> m_pub_keys;
            std::unordered_map<crypto::public_key, cryptonote::subaddress_index> m_subaddresses;
            std::vector<std::vector<std::string>> m_subaddress_labels;
            size_t m_subaddress_lookahead_major, m_subaddress_lookahead_minor;
    };
}