app.h

Go to the documentation of this file.

/*
-------------------------------------------------------------------------------
                            PLEBBLE
-------------------------------------------------------------------------------
 Copyright (C) 2019-2020 KATLAS Technology. (http://katlastechnology.com)
 Copyright (C) 2017-2020 Marcos Mayorga. (mm@mm-studios.com)
 
 This file is part of our Plebble(R) Platform.
 
 The code below cannot be copied, used for any purpose other than the one
 agreed and/or distributed without the express permission of
 KATLAS Technology.
-------------------------------------------------------------------------------
 
 
*/
#ifndef USGOV_49e5fff0395fac385e48353d91ae777f7b0ba92baa74a883f127855ad412c9e0
#define USGOV_49e5fff0395fac385e48353d91ae777f7b0ba92baa74a883f127855ad412c9e0
 
#include <us/gov/auth.h>
#include <us/gov/engine.h>
#include <vector>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <us/gov/socket/datagram.h>
#include <us/gov/crypto/crypto.h>
#include <us/gov/engine/diff.h>
#include <us/gov/engine/app.h>
#include "protocol.h"
#include "tx.h"
#include <chrono>
#include <cassert>
#include <map>
#include <atomic>
#include <mutex>
#include <us/gov/engine/evidence.h>
#include <us/gov/dfs/fileattr_t.h>
#include <us/gov/config.h>
 
namespace us { namespace gov {
namespace cash {
 
    using namespace std;
    using socket::datagram;
    using engine::local_deltas;
    using crypto::ripemd160;
    using crypto::ec;
    using engine::peer_t;
 
    typedef crypto::ec::keys keys;
    typedef keys::pub_t pubkey_t;
    typedef ripemd160 hasher_t;
    typedef hasher_t::value_type hash_t;
    typedef tx::cash_t cash_t;
    typedef engine::evidence evidence;
 
    static const hash_t min_locking_program(10000);
 
    struct tx;
    struct map_tx;
    struct file_tx;
    struct ttx;
    struct app final:engine::app {
        typedef engine::app b;
 
        struct local_delta final:engine::app::local_delta {
            typedef engine::app::local_delta b;
            local_delta& operator =(int zero);
            local_delta();
            local_delta(const local_delta&);
            bool operator == (const local_delta& other) const;
            bool operator != (const local_delta& other) const;
 
            ~local_delta() override;
            int app_id() const override;
            void to_stream(ostream&) const override;
            void from_stream(istream&) override;
            void from_stream_prev(istream&) override;
            void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const override;
            void hash_data(crypto::ripemd160&) const override;
 
            struct accounts_t;
 
            struct safe_deposit_box final {
                safe_deposit_box(const cash_t& v);
                safe_deposit_box(const safe_deposit_box& other);
                safe_deposit_box& operator=(const safe_deposit_box& other);
                virtual ~safe_deposit_box();
                cash_t charge(const cash_t&tax); //charges tax plus storage costs
                cash_t maintenance_fee() const;
 
                void print_kv_b64(ostream& os) const;
                hash_t file_hash(const string& path) const;
                void merge(const safe_deposit_box&other);
                void on_destroy(accounts_t& ledger);
                void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
                void hash_data(crypto::ripemd160&) const;
 
                cash_t value; //gas
 
                struct m_t: map<string,string> {
                    m_t();
                    m_t(const m_t&);
                    m_t& operator=(const m_t&)=delete;
                    void dump(const string& prefix, ostream& os) const;
                    void to_stream(ostream& os) const;
                    void from_stream(istream& is);
                    void from_stream_prev(istream& is);
                    void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
                    void hash_data(crypto::ripemd160&) const;
                    void merge(const m_t&other);
                };
                m_t* m{0}; 
 
                typedef us::gov::dfs::fileattr_t fileattr_t;
 
                struct f_t final: map<hash_t,fileattr_t> {
                    f_t();
                    f_t(const f_t&);
                    f_t& operator=(const f_t&)=delete;
                    void dump(const string& prefix, ostream& os) const;
                    void to_stream(ostream& os) const;
                    void from_stream(istream& is);
                    void from_stream_prev(istream& is);
                    void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
                    void hash_data(crypto::ripemd160&) const;
                    uint32_t total_mib() const;
                    void list_files(const string&path, ostream&os) const;
                    void get_files(vector<pair<dfs::hash_t,fileattr_t>>& v) const;
                    void get_files(vector<pair<dfs::hash_t,uint32_t>>& v) const;
                    void get_files(const hash_t& a, vector<pair<hash_t,pair<dfs::hash_t,fileattr_t>>>& v) const;
                    void get_files(set<dfs::hash_t>& v) const;
                    hash_t file_hash(const string& path) const;
                    void diff(const f_t& newer,vector<pair<hash_t,uint32_t>>& old_files,vector<pair<hash_t,uint32_t>>& new_files) const;
                    void merge(const f_t&other);
                };
                f_t* f{0};
 
                struct t_t final: map<hash_t,cash_t> {
                    t_t();
                    t_t(const t_t&);
                    t_t& operator=(const t_t&)=delete;
                    void dump(const string& prefix, const hash_t& addr, ostream& os) const;
                    void to_stream(ostream& os) const;
                    void from_stream(istream& is);
                    void from_stream_prev(istream& is);
                    void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
                    void hash_data(crypto::ripemd160&) const;
                    bool burn(const hash_t& token, const cash_t&);
                    cash_t get_value(const hash_t&token) const;
                    void set_supply(const hash_t&token, const cash_t& supply);
                    void merge(const t_t&other);
                    void on_destroy(accounts_t& ledger);
                };
                t_t* t{0}; 
 
                bool burn(const hash_t& token, const cash_t& amount, cash_t& fee);
                void add(const hash_t& token, const cash_t&);
                bool store(const string& key, const string& value);
                bool store(const string& path, const hash_t& key, const uint32_t& sz);
                void dump(ostream& os) const;
                void to_stream(ostream& os) const;
 
                bool from_stream(istream& is);
                bool from_stream_prev(istream& is);
 
                void diff_files(const safe_deposit_box& newer,vector<pair<hash_t,uint32_t>>& old_files,vector<pair<hash_t,uint32_t>>& new_files) const;
                void get_files(const hash_t&a, vector<pair<hash_t,pair<dfs::hash_t,fileattr_t>>>&) const;
                void get_files(vector<pair<dfs::hash_t,fileattr_t>>&) const;
                void get_files(vector<pair<dfs::hash_t,uint32_t>>&) const;
                void get_files(set<dfs::hash_t>&) const;
 
                void set_supply(const hash_t&token, const cash_t& supply);
 
            };
 
            typedef safe_deposit_box box_t;
 
            struct account_t {
                account_t();
                account_t(const hash_t& locking_program, const box_t&);
                void on_destroy(accounts_t& ledger);
                void merge(const account_t&other);
                void dump(const hash_t& addr, int detail, ostream& os) const;
                void list_files(const string&path, ostream&os) const;
                void print_data(const hash_t& addr, ostream& os) const;
                void to_stream(ostream& os) const;
                bool from_stream(istream& is);
                bool from_stream_prev(istream& is);
                void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
                void hash_data(crypto::ripemd160&) const;
                cash_t get_value(const hash_t& token) const;
                cash_t input_eligible(const hash_t& coin) const; //not eligible if account contains data, or not enough gas
                cash_t input_eligible2(const hash_t& coin) const; //not eligible only if not enough gas
                hash_t file_hash(const string& path) const;
 
                hash_t locking_program;
                box_t box;
            };
            typedef account_t batch_item;
 
            struct batch_t final: unordered_map<hash_t,batch_item> {
                void add(const hash_t& address, const batch_item& bi);
            };
 
            struct accounts_t final: map<hash_t,account_t> {
                accounts_t();
                ~accounts_t();
                account_t merge() const;
                void add(const batch_t& batch);
                cash_t get_balance() const;
                void to_stream(ostream& os) const;
                static accounts_t* from_stream(istream& is);
                static accounts_t* from_stream_prev(istream& is);
                void dump(int detail, ostream& os) const;
                bool pay(const hash_t& k, const cash_t& amount);
                bool withdraw(const hash_t& k, const cash_t& amount);
                void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
                void hash_data(crypto::ripemd160&) const;
                cash_t sum() const;
                void list_files(const hash_t& addr, const string&path, ostream&os) const;
                void print_data(const hash_t& addr, ostream& os) const;
                void print_kv_b64(const hash_t& addr, ostream& os) const;
                void get_files(vector<pair<hash_t,pair<dfs::hash_t,safe_deposit_box::fileattr_t>>>& v) const;
                void get_files(vector<pair<dfs::hash_t,safe_deposit_box::fileattr_t>>& v) const;
                void get_files(vector<pair<dfs::hash_t,uint32_t>>& v) const;
                void get_files(set<dfs::hash_t>& v) const;
                hash_t file_hash(const hash_t& addr, const string& path) const;
            };
 
            accounts_t accounts;
            cash_t fees{0};
 
            mutable hash_t hash{0};
            const hash_t& get_hash() const;
            hash_t compute_hash() const;
        };
 
        typedef local_delta::box_t box_t;
 
        struct delta final: engine::app::delta {
            typedef engine::app::delta b;
            typedef local_delta::accounts_t accounts_t;
            delta();
            delta(const delta&)=delete;
            delta& operator = (const delta&)=delete;
            ~delta() override;
            uint64_t merge(engine::app::local_delta* other0) override;
            void end_merge() override;
            void to_stream(ostream& os) const override;
            static delta* from_stream(istream& is);
            static delta* from_stream_prev(istream& is);
            local_delta g;
            engine::majority_merger<local_delta>* m;
        };
 
        struct query_accounts_t final:vector<hash_t> {
            void add(const hash_t& addr);
            datagram* get_datagram(uint16_t seq) const;
            static query_accounts_t from_datagram(datagram*);
            static query_accounts_t from_string(const string&);
        };
 
        struct db_t final {
            typedef local_delta::accounts_t accounts_t;
            db_t();
            db_t(const db_t&)=delete;
            db_t& operator = (const db_t&)=delete;
            db_t(db_t&& other);
            ~db_t();
            bool add_(const hash_t&, const cash_t& amount);
            bool withdraw_(const hash_t& k, const cash_t& amount);
            void dump(int detail, ostream& os) const;
            cash_t budget() const;
            void tax_accounts(const cash_t& amount);
 
            cash_t cash_in_circulation() const;
            void clear();
            void to_stream(ostream&) const;
            void from_stream(istream&);
            void from_stream_prev(istream&);
            void print_data(const hash_t& addr, ostream& os) const;
            void print_kv_b64(const hash_t& addr, ostream& os) const;
            void list_files(const hash_t& addr, const string&path, ostream&os) const;
            hash_t file_hash(const hash_t& addr, const string& path) const;
 
            mutable mutex mx;
            accounts_t* accounts{0};
            cash_t max_subsidy;
        };
 
        #if CFG_COUNTERS==1
            struct counters_t final {
                uint32_t tx_rejected_bad_amounts{0};
                uint32_t tx_rejected_state{0};
                uint32_t tx_rejected_could_not_unlock_input{0};
                uint32_t tx_rejected_locking_program_mismatch{0};
                uint32_t tx_processed{0};
                void dump(ostream&os) const;
            };
            static counters_t counters;
        #endif
 
        typedef local_delta::account_t account_t;
        typedef local_delta::accounts_t accounts_t;
        typedef local_delta::safe_deposit_box::fileattr_t fileattr_t;
 
 
        constexpr static const char* name={"cash"};
 
        static bool unlock(const hash_t& address, const hash_t& locking_program, const string& locking_program_input, const tx&);
        static bool unlock(const hash_t& address, const hash_t& locking_program, const map_tx& t);
        static bool unlock(const hash_t& address, const hash_t& locking_program, const file_tx& t);
        static bool unlock(const hash_t& address, const hash_t& locking_program, const ttx& t);
 
        static constexpr int id() { return 30; }
 
        app(engine::daemon&);
        app(const app&)=delete;
        app& operator = (const app&)=delete;
        ~app() override;
        engine::app::local_delta* create_local_delta() override;
        bool process_query(peer_t *, datagram*) override;
        static evidence* evidence_from_stream(uint8_t evid, istream&is); // const override;
 
        string get_name() const override { return name; }
        bool process(const evidence&) override;
        bool process(const tx&, const tx::section_t&, local_delta::batch_t&, cash_t& fee);
        bool process(const tx&, const tx::sections_t&, local_delta::batch_t&, cash_t& fee);
        bool process(const tx&);
        bool process(const map_tx&);
        bool process(const file_tx&);
        bool process(const ttx&);
        void report_wallet(const tx& t, const string& feedback) const;
 
        void save_db(ostream&) const override;
        bool load_db(istream&) override;
        bool load_db_prev(istream&) override;
        void clear() override;
        bool process_tx(peer_t *, datagram*);
        void cash_query(peer_t *, datagram*);
        void search_kv(peer_t *, datagram*);
        bool account_state(const local_delta::batch_t& batch, const hash_t& address, account_t& acc) const;
        bool checksig(const size_t& this_index, const string& locking_program_input, const tx&) const;
        static bool check_amounts(const tx&);
        int get_id() const override { return id(); }
        bool shell_command(istream&, ostream&) override;
        void import(const engine::app::delta&, const engine::pow_t&) override;
        void update_ledger(const delta& g, vector<pair<hash_t,uint32_t>>& old_files, vector<pair<hash_t,uint32_t>>& new_files);
        cash_t charge_ledger();
 
        //cryptoeconomics
        cash_t pay_services() const;
        void tax_accounts(const cash_t& amount);
        void process_profit(cash_t& profit);
        void pay_subsidy(const cash_t& amount, const engine::pow_t& w);
 
        void get_files(vector<pair<hash_t,uint32_t>>&) const;
        void get_files(vector<pair<hash_t,fileattr_t>>&) const;
        void get_files(set<hash_t>&) const;
        void file_hash(peer_t *c, datagram*d) const;
 
        db_t db;
        local_delta* pool{0};
        mutex mx_pool;
 
        vector<pair<hash_t,uint32_t>> old_files;
        vector<pair<hash_t,uint32_t>> new_files;
    };
 
}}
}
 
namespace std {
    template <>
    struct hash<us::gov::cash::app::local_delta> {
        size_t operator()(const us::gov::cash::app::local_delta&) const;
    };
}
 
#endif