transaction.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Cryptonomex, Inc., and contributors.
 *
 * The MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
#include <graphene/protocol/operations.hpp>
 
namespace graphene { namespace protocol {
   struct predicate_result;
 
   using rejected_predicate = static_variant<predicate_result, fc::exception>;
   using rejected_predicate_map = map<custom_authority_id_type, rejected_predicate>;
   using custom_authority_lookup = std::function<vector<authority>(account_id_type, const operation&,
                                                                   rejected_predicate_map*)>;
 
   class transaction
   {
   public:
      virtual ~transaction() = default;
      uint16_t           ref_block_num    = 0;
      uint32_t           ref_block_prefix = 0;
 
      fc::time_point_sec expiration;
 
      vector<operation>  operations;
      extensions_type    extensions;
 
      digest_type                        digest()const;
      virtual const transaction_id_type& id()const;
      virtual void                       validate() const;
 
      void set_expiration( fc::time_point_sec expiration_time );
      void set_reference_block( const block_id_type& reference_block );
 
      template<typename Visitor>
      vector<typename Visitor::result_type> visit( Visitor&& visitor )
      {
         vector<typename Visitor::result_type> results;
         for( auto& op : operations )
            results.push_back(op.visit( std::forward<Visitor>( visitor ) ));
         return results;
      }
      template<typename Visitor>
      vector<typename Visitor::result_type> visit( Visitor&& visitor )const
      {
         vector<typename Visitor::result_type> results;
         for( auto& op : operations )
            results.push_back(op.visit( std::forward<Visitor>( visitor ) ));
         return results;
      }
 
      void get_required_authorities( flat_set<account_id_type>& active,
                                     flat_set<account_id_type>& owner,
                                     vector<authority>& other,
                                     bool ignore_custom_operation_required_auths )const;
 
      virtual uint64_t get_packed_size()const;
 
   protected:
      // Calculate the digest used for signature validation
      digest_type sig_digest( const chain_id_type& chain_id )const;
      mutable transaction_id_type _tx_id_buffer;
   };
 
   class signed_transaction : public transaction
   {
   public:
      signed_transaction( const transaction& trx = transaction() )
         : transaction(trx){}
      virtual ~signed_transaction() = default;
 
      const signature_type& sign( const private_key_type& key, const chain_id_type& chain_id );
 
      signature_type sign( const private_key_type& key, const chain_id_type& chain_id )const;
 
      set<public_key_type> get_required_signatures(
              const chain_id_type& chain_id,
              const flat_set<public_key_type>& available_keys,
              const std::function<const authority*(account_id_type)>& get_active,
              const std::function<const authority*(account_id_type)>& get_owner,
              bool allow_non_immediate_owner,
              bool ignore_custom_operation_required_authorities,
              uint32_t max_recursion = GRAPHENE_MAX_SIG_CHECK_DEPTH )const;
 
      void verify_authority(
              const chain_id_type& chain_id,
              const std::function<const authority*(account_id_type)>& get_active,
              const std::function<const authority*(account_id_type)>& get_owner,
              const custom_authority_lookup& get_custom,
              bool allow_non_immediate_owner,
              bool ignore_custom_operation_required_auths,
              uint32_t max_recursion = GRAPHENE_MAX_SIG_CHECK_DEPTH )const;
 
      set<public_key_type> minimize_required_signatures(
              const chain_id_type& chain_id,
              const flat_set<public_key_type>& available_keys,
              const std::function<const authority*(account_id_type)>& get_active,
              const std::function<const authority*(account_id_type)>& get_owner,
              const custom_authority_lookup& get_custom,
              bool allow_non_immediate_owner,
              bool ignore_custom_operation_required_auths,
              uint32_t max_recursion = GRAPHENE_MAX_SIG_CHECK_DEPTH) const;
 
      virtual const flat_set<public_key_type>& get_signature_keys( const chain_id_type& chain_id )const;
 
      vector<signature_type> signatures;
 
      void clear() { operations.clear(); signatures.clear(); }
 
      void clear_signatures() { signatures.clear(); }
   protected:
      mutable flat_set<public_key_type> _signees;
   };
 
   class precomputable_transaction : public signed_transaction {
   public:
      precomputable_transaction() {}
      precomputable_transaction( const signed_transaction& tx ) : signed_transaction(tx) {};
      precomputable_transaction( signed_transaction&& tx ) : signed_transaction( std::move(tx) ) {};
      virtual ~precomputable_transaction() = default;
 
      virtual const transaction_id_type&       id()const override;
      virtual void                             validate()const override;
      virtual const flat_set<public_key_type>& get_signature_keys( const chain_id_type& chain_id )const override;
      virtual uint64_t                         get_packed_size()const override;
   protected:
      mutable bool _validated = false;
      mutable uint64_t _packed_size = 0;
   };
 
   void verify_authority( const vector<operation>& ops, const flat_set<public_key_type>& sigs,
                          const std::function<const authority*(account_id_type)>& get_active,
                          const std::function<const authority*(account_id_type)>& get_owner,
                          const custom_authority_lookup& get_custom,
                          bool allow_non_immediate_owner,
                          bool ignore_custom_operation_required_auths,
                          uint32_t max_recursion = GRAPHENE_MAX_SIG_CHECK_DEPTH,
                          bool allow_committee = false,
                          const flat_set<account_id_type>& active_approvals = flat_set<account_id_type>(),
                          const flat_set<account_id_type>& owner_approvals = flat_set<account_id_type>() );
 
   struct processed_transaction : public precomputable_transaction
   {
      processed_transaction( const signed_transaction& trx = signed_transaction() )
         : precomputable_transaction(trx){}
      virtual ~processed_transaction() = default;
 
      vector<operation_result> operation_results;
 
      digest_type merkle_digest()const;
   };
 
 
} } // graphene::protocol
 
FC_REFLECT( graphene::protocol::transaction, (ref_block_num)(ref_block_prefix)(expiration)(operations)(extensions) )
// Note: not reflecting _signees field for backward compatibility; in addition, it should not be in p2p messages
FC_REFLECT_DERIVED( graphene::protocol::signed_transaction, (graphene::protocol::transaction), (signatures) )
FC_REFLECT_DERIVED( graphene::protocol::precomputable_transaction, (graphene::protocol::signed_transaction), )
FC_REFLECT_DERIVED( graphene::protocol::processed_transaction, (graphene::protocol::precomputable_transaction), (operation_results) )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::transaction)
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::signed_transaction)
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::precomputable_transaction)
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::processed_transaction)