tx.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_33de4fece6646b4a064a30507e7a1a35c3b5bcd4dc9c1c87059904e7ac05e335
#define USGOV_33de4fece6646b4a064a30507e7a1a35c3b5bcd4dc9c1c87059904e7ac05e335
 
#include <us/gov/config.h>
#include <us/gov/auth.h>
#include <us/gov/engine.h>
#include <vector>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <us/gov/crypto/crypto.h>
#include "protocol.h"
#include <chrono>
#include <cassert>
#include <memory>
#include <map>
 
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;
 
    struct tx final:engine::evidence {
        typedef engine::evidence b;
        typedef int64_t cash_t;
 
        static constexpr uint16_t magic{200};
 
        struct sigcode_section_t {
            struct side_t: vector<uint8_t> {
                void to_stream(ostream& os) const;
                static void from_stream(side_t&, istream& is);
                void dump(const string& prefix, ostream&) const;
            };
            side_t inputs;
            side_t outputs;
            void to_stream(ostream& os) const;
            static void from_stream(sigcode_section_t&, istream& is);
            void dump(const string& prefix, ostream&) const;
        };
 
        struct sigcode_t:vector<sigcode_section_t> {
            void to_stream(ostream& os) const;
            static bool from_stream(sigcode_t&, istream& is);
            void dump(ostream&) const;
            string to_b58() const;
            static pair<ko,sigcode_t> from_b58(const string&);
 
            bool ts{true};
        };
 
        struct input_t final {
            input_t() {}
            input_t(const hash_t& address, const cash_t& amount): address(address), amount(amount) {}
            input_t(const hash_t& address, const cash_t& amount, const string& locking_program_input): address(address), amount(amount), locking_program_input(locking_program_input) {}
            void write_sigmsg(ec::sigmsg_hasher_t&) const;
            void to_stream(ostream&) const;
            void write_pretty(const string& prefix, ostream& os) const;
            static pair<ko,input_t> from_stream(istream&);
 
            hash_t address;
            cash_t amount;
            string locking_program_input;
        };
 
        struct output_t final {
            output_t() {}
            output_t(const hash_t& address, const cash_t& amount): address(address), amount(amount) {}
            void write_sigmsg(ec::sigmsg_hasher_t&) const;
            void to_stream(ostream&) const;
            void write_pretty(const string& prefix, ostream& os) const;
            static pair<ko,output_t> from_stream(istream&);
 
            hash_t address;
            cash_t amount;
        };
 
        struct inputs_t final:vector<input_t> {
            void write_sigmsg(ec::sigmsg_hasher_t&, const sigcode_section_t&) const;
            void to_stream(ostream&) const;
            void write_pretty(const string& prefix, ostream& os) const;
            ko from_stream(istream&);
        };
 
        struct outputs_t final:vector<output_t> {
            void write_sigmsg(ec::sigmsg_hasher_t&, const sigcode_section_t&) const;
            void to_stream(ostream&) const;
            void write_pretty(const string& prefix, ostream& os) const;
            ko from_stream(istream&);
        };
 
        tx();
        ~tx() override {}
 
        sigcode_t get_sigcode_all() const;
        static pair<ko,tx*> from_stream(istream&);
        static pair<ko,tx*> from_b58(const string&);
        string to_b58() const;
        sigcode_t make_sigcode_all() const;
        hash_t compute_hash() const override;
        string name() const override { return "cash::tx"; };
        bool check_amounts() const;
        ec::sigmsg_hasher_t::value_type get_hash(const sigcode_t&) const;
        void to_stream(ostream&) const;
        void write_sigmsg(ec::sigmsg_hasher_t&, const sigcode_t& sh) const;
        void write_pretty(ostream&) const override;
        datagram* get_datagram(uint16_t seq) const;
        void dump(const string& prefix, ostream&) const;
 
        struct section_t final {
            section_t() {}
            section_t(const hash_t& token): token(token) {}
            void add_input(const hash_t& addr, const cash_t& amount);
            void add_input(const hash_t& addr, const cash_t& amount, const string& locking_program_input);
            void add_output(const hash_t& addr, const cash_t& amount);
            void write_sigmsg(ec::sigmsg_hasher_t&, const sigcode_section_t&) const;
            void write_pretty(const string& prefix, ostream& os) const;
            void to_stream(ostream&) const;
            ko from_stream(istream&);
            cash_t required_input() const;
            cash_t required_output() const;
            bool check_amounts() const;
            hash_t token;
            inputs_t inputs;
            outputs_t outputs;
        };
 
        struct sections_t final: vector<section_t> {
            void write_sigmsg(ec::sigmsg_hasher_t&, const sigcode_t&) const;
            void write_pretty(const string& prefix, ostream& os) const;
            void to_stream(ostream&) const;
            ko from_stream(istream&);
            bool check_amounts() const;
            const_iterator find(const hash_t& token) const;
            iterator find(const hash_t& token);
        };
 
        bool verify(ostream& os) const override;  
        section_t& add_section(const hash_t& token);
        sections_t sections;
    };
 
    static ostream& operator << (ostream&os, const cash::tx& t) {
        os << t.to_b58();
        return os;
    }
}
}}
 
#endif