confidential.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/base.hpp>
#include <graphene/protocol/asset.hpp>
#include <graphene/protocol/authority.hpp>
 
namespace graphene { namespace protocol {
 
using fc::ecc::blind_factor_type;
 
 
struct blind_memo
{
   account_id_type     from;
   share_type          amount;
   string              message;
   uint32_t            check= 0;
};
 
struct blind_input
{
   fc::ecc::commitment_type      commitment;
   authority                      owner;
};
 
struct stealth_confirmation
{
   struct memo_data
   {
      optional<public_key_type> from;
      asset                     amount;
      fc::sha256                blinding_factor;
      fc::ecc::commitment_type  commitment;
      uint32_t                  check = 0;
   };
 
   operator string()const;
   stealth_confirmation( const std::string& base58 );
   stealth_confirmation(){}
 
   public_key_type           one_time_key;
   optional<public_key_type> to;
   vector<char>              encrypted_memo;
};
 
struct blind_output
{
   fc::ecc::commitment_type                commitment;
   range_proof_type                        range_proof;
   authority                               owner;
   optional<stealth_confirmation>          stealth_memo;
};
 
 
struct transfer_to_blind_operation : public base_operation
{
   struct fee_params_t {
      uint64_t fee              = 5*GRAPHENE_BLOCKCHAIN_PRECISION; 
      uint32_t price_per_output = 5*GRAPHENE_BLOCKCHAIN_PRECISION;
   };
 
 
   asset                 fee;
   asset                 amount;
   account_id_type       from;
   blind_factor_type     blinding_factor;
   vector<blind_output>  outputs;
 
   account_id_type fee_payer()const { return from; }
   void            validate()const;
   share_type      calculate_fee(const fee_params_t& )const;
};
 
struct transfer_from_blind_operation : public base_operation
{
   struct fee_params_t {
      uint64_t fee              = 5*GRAPHENE_BLOCKCHAIN_PRECISION; 
   };
 
   asset                 fee;
   asset                 amount;
   account_id_type       to;
   blind_factor_type     blinding_factor;
   vector<blind_input>   inputs;
 
   account_id_type fee_payer()const { return GRAPHENE_TEMP_ACCOUNT; }
   void            validate()const;
 
   void            get_required_authorities( vector<authority>& a )const
   {
      for( const auto& in : inputs )
         a.push_back( in.owner ); 
   }
};
 
struct blind_transfer_operation : public base_operation
{
   struct fee_params_t {
      uint64_t fee              = 5*GRAPHENE_BLOCKCHAIN_PRECISION; 
      uint32_t price_per_output = 5*GRAPHENE_BLOCKCHAIN_PRECISION;
   };
 
   asset                 fee;
   vector<blind_input>   inputs;
   vector<blind_output>  outputs;
    
   account_id_type fee_payer()const;
   void            validate()const;
   share_type      calculate_fee( const fee_params_t& k )const;
 
   void            get_required_authorities( vector<authority>& a )const
   {
      for( const auto& in : inputs )
         a.push_back( in.owner ); 
   }
};
 
 
} } // graphene::protocol
 
FC_REFLECT( graphene::protocol::stealth_confirmation,
            (one_time_key)(to)(encrypted_memo) )
 
FC_REFLECT( graphene::protocol::stealth_confirmation::memo_data,
            (from)(amount)(blinding_factor)(commitment)(check) )
 
FC_REFLECT( graphene::protocol::blind_memo,
            (from)(amount)(message)(check) )
FC_REFLECT( graphene::protocol::blind_input,
            (commitment)(owner) )
FC_REFLECT( graphene::protocol::blind_output,
            (commitment)(range_proof)(owner)(stealth_memo) )
FC_REFLECT( graphene::protocol::transfer_to_blind_operation,
            (fee)(amount)(from)(blinding_factor)(outputs) )
FC_REFLECT( graphene::protocol::transfer_from_blind_operation,
            (fee)(amount)(to)(blinding_factor)(inputs) )
FC_REFLECT( graphene::protocol::blind_transfer_operation,
            (fee)(inputs)(outputs) )
FC_REFLECT( graphene::protocol::transfer_to_blind_operation::fee_params_t, (fee)(price_per_output) )
FC_REFLECT( graphene::protocol::transfer_from_blind_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::blind_transfer_operation::fee_params_t, (fee)(price_per_output) )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::transfer_to_blind_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::transfer_from_blind_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::blind_transfer_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::transfer_to_blind_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::transfer_from_blind_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::blind_transfer_operation )