hw::trezor::protocol::tx::Signer Class Reference

#include <protocol.hpp>

Public Member Functions
	Signer (wallet_shim *wallet2, const unsigned_tx_set *unsigned_tx, size_t tx_idx=0, hw::tx_aux_data *aux_data=nullptr)
std::shared_ptr< messages::electroneum::ElectroneumTransactionInitRequest >	step_init ()
void	step_init_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionInitAck > ack)
std::shared_ptr< messages::electroneum::ElectroneumTransactionSetInputRequest >	step_set_input (size_t idx)
void	step_set_input_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionSetInputAck > ack)
void	sort_ki ()
std::shared_ptr< messages::electroneum::ElectroneumTransactionInputsPermutationRequest >	step_permutation ()
void	step_permutation_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionInputsPermutationAck > ack)
std::shared_ptr< messages::electroneum::ElectroneumTransactionInputViniRequest >	step_set_vini_input (size_t idx)
void	step_set_vini_input_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionInputViniAck > ack)
std::shared_ptr< messages::electroneum::ElectroneumTransactionAllInputsSetRequest >	step_all_inputs_set ()
void	step_all_inputs_set_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionAllInputsSetAck > ack)
std::shared_ptr< messages::electroneum::ElectroneumTransactionSetOutputRequest >	step_set_output (size_t idx)
void	step_set_output_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionSetOutputAck > ack)
std::shared_ptr< messages::electroneum::ElectroneumTransactionSetOutputRequest >	step_rsig (size_t idx)
void	step_set_rsig_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionSetOutputAck > ack)
std::shared_ptr< messages::electroneum::ElectroneumTransactionAllOutSetRequest >	step_all_outs_set ()
void	step_all_outs_set_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionAllOutSetAck > ack, hw::device &hwdev)
std::shared_ptr< messages::electroneum::ElectroneumTransactionSignInputRequest >	step_sign_input (size_t idx)
void	step_sign_input_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionSignInputAck > ack)
std::shared_ptr< messages::electroneum::ElectroneumTransactionFinalRequest >	step_final ()
void	step_final_ack (std::shared_ptr< const messages::electroneum::ElectroneumTransactionFinalAck > ack)
std::string	store_tx_aux_info ()
unsigned	client_version () const
bool	is_simple () const
bool	is_req_bulletproof () const
bool	is_bulletproof () const
bool	is_offloading () const
size_t	num_outputs () const
size_t	num_inputs () const
const TData &	tdata () const

Detailed Description

Definition at line 212 of file protocol.hpp.

Constructor & Destructor Documentation

Signer()

hw::trezor::protocol::tx::Signer::Signer	(	wallet_shim *	wallet2,
		const unsigned_tx_set *	unsigned_tx,
		size_t	tx_idx = 0,
		hw::tx_aux_data *	aux_data = nullptr )

Definition at line 380 of file protocol.cpp.

                                                                                                                   {
    m_wallet2 = wallet2;
    m_unsigned_tx = unsigned_tx;
    m_aux_data = aux_data;
    m_tx_idx = tx_idx;
    m_ct.tx_data = cur_tx();
    m_multisig = false;
    m_client_version = 1;
  }

Member Function Documentation

client_version()

unsigned hw::trezor::protocol::tx::Signer::client_version ( ) const

inline

Definition at line 271 of file protocol.hpp.

                                    {
      return m_client_version;
    }

Here is the caller graph for this function:

is_bulletproof()

bool hw::trezor::protocol::tx::Signer::is_bulletproof ( ) const

inline

Definition at line 287 of file protocol.hpp.

                                {
      if (!m_ct.rv){
        throw std::invalid_argument("RV not initialized");
      }
      auto tp = m_ct.rv->type;
      return tp == rct::RCTTypeBulletproof || tp == rct::RCTTypeBulletproof2;
    }

Here is the caller graph for this function:

is_offloading()

bool hw::trezor::protocol::tx::Signer::is_offloading ( ) const

inline

Definition at line 295 of file protocol.hpp.

                               {
      return m_ct.rsig_param && m_ct.rsig_param->offload_type() != 0;
    }

Here is the caller graph for this function:

is_req_bulletproof()

bool hw::trezor::protocol::tx::Signer::is_req_bulletproof ( ) const

inline

Definition at line 283 of file protocol.hpp.

                                    {
      return m_ct.tx_data.rct_config.range_proof_type != rct::RangeProofBorromean;
    }

Here is the caller graph for this function:

is_simple()

bool hw::trezor::protocol::tx::Signer::is_simple ( ) const

inline

Definition at line 275 of file protocol.hpp.

                           {
      if (!m_ct.rv){
        throw std::invalid_argument("RV not initialized");
      }
      auto tp = m_ct.rv->type;
      return tp == rct::RCTTypeSimple;
    }

Here is the caller graph for this function:

num_inputs()

size_t hw::trezor::protocol::tx::Signer::num_inputs ( ) const

inline

Definition at line 303 of file protocol.hpp.

                              {
      return m_ct.tx_data.sources.size();
    }

num_outputs()

size_t hw::trezor::protocol::tx::Signer::num_outputs ( ) const

inline

Definition at line 299 of file protocol.hpp.

                               {
      return m_ct.tx_data.splitted_dsts.size();
    }

Here is the caller graph for this function:

sort_ki()

void hw::trezor::protocol::tx::Signer::sort_ki

(

)

Definition at line 579 of file protocol.cpp.

                      {
    const size_t input_size = cur_tx().sources.size();
 
    m_ct.source_permutation.clear();
    for (size_t n = 0; n < input_size; ++n){
      m_ct.source_permutation.push_back(n);
    }
 
    CHECK_AND_ASSERT_THROW_MES(m_ct.tx.vin.size() == input_size, "Invalid vector size");
    std::sort(m_ct.source_permutation.begin(), m_ct.source_permutation.end(), [&](const size_t i0, const size_t i1) {
      const cryptonote::txin_to_key &tk0 = boost::get<cryptonote::txin_to_key>(m_ct.tx.vin[i0]);
      const cryptonote::txin_to_key &tk1 = boost::get<cryptonote::txin_to_key>(m_ct.tx.vin[i1]);
      return memcmp(&tk0.k_image, &tk1.k_image, sizeof(tk0.k_image)) > 0;
    });
 
    CHECK_AND_ASSERT_THROW_MES(m_ct.tx_in_hmacs.size() == input_size, "Invalid vector size");
    CHECK_AND_ASSERT_THROW_MES(m_ct.pseudo_outs.size() == input_size, "Invalid vector size");
    CHECK_AND_ASSERT_THROW_MES(m_ct.pseudo_outs_hmac.size() == input_size, "Invalid vector size");
    CHECK_AND_ASSERT_THROW_MES(m_ct.alphas.size() == input_size, "Invalid vector size");
    CHECK_AND_ASSERT_THROW_MES(m_ct.spend_encs.size() == input_size, "Invalid vector size");
    CHECK_AND_ASSERT_THROW_MES(m_ct.tx_data.sources.size() == input_size, "Invalid vector size");
 
    tools::apply_permutation(m_ct.source_permutation, [&](size_t i0, size_t i1){
      std::swap(m_ct.tx.vin[i0], m_ct.tx.vin[i1]);
      std::swap(m_ct.tx_in_hmacs[i0], m_ct.tx_in_hmacs[i1]);
      std::swap(m_ct.pseudo_outs[i0], m_ct.pseudo_outs[i1]);
      std::swap(m_ct.pseudo_outs_hmac[i0], m_ct.pseudo_outs_hmac[i1]);
      std::swap(m_ct.alphas[i0], m_ct.alphas[i1]);
      std::swap(m_ct.spend_encs[i0], m_ct.spend_encs[i1]);
      std::swap(m_ct.tx_data.sources[i0], m_ct.tx_data.sources[i1]);
    });
  }

Here is the call graph for this function:

Here is the caller graph for this function:

step_all_inputs_set()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionAllInputsSetRequest > hw::trezor::protocol::tx::Signer::step_all_inputs_set

(

)

Definition at line 652 of file protocol.cpp.

                                                                                                         {
    return std::make_shared<messages::Electroneum::ElectroneumTransactionAllInputsSetRequest>();
  }

step_all_inputs_set_ack()

void hw::trezor::protocol::tx::Signer::step_all_inputs_set_ack

(

std::shared_ptr< const messages::electroneum::ElectroneumTransactionAllInputsSetAck >

ack

)

Definition at line 656 of file protocol.cpp.

                                                                                                                       {
    if (client_version() > 0 || !is_offloading()){
      return;
    }
 
    // If offloading, expect rsig configuration.
    if (!ack->has_rsig_data()){
      throw exc::ProtocolException("Rsig offloading requires rsig param");
    }
 
    auto & rsig_data = ack->rsig_data();
    if (!rsig_data.has_mask()){
      throw exc::ProtocolException("Gamma masks not present in offloaded version");
    }
 
    auto & mask = rsig_data.mask();
    if (mask.size() != 32 * num_outputs()){
      throw exc::ProtocolException("Invalid number of gamma masks");
    }
 
    m_ct.rsig_gamma.reserve(num_outputs());
    for(size_t c=0; c < num_outputs(); ++c){
      rct::key cmask{};
      memcpy(cmask.bytes, mask.data() + c * 32, 32);
      m_ct.rsig_gamma.emplace_back(cmask);
    }
  }

Here is the call graph for this function:

step_all_outs_set()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionAllOutSetRequest > hw::trezor::protocol::tx::Signer::step_all_outs_set

(

)

Definition at line 833 of file protocol.cpp.

                                                                                                    {
    return std::make_shared<messages::Electroneum::ElectroneumTransactionAllOutSetRequest>();
  }

step_all_outs_set_ack()

void hw::trezor::protocol::tx::Signer::step_all_outs_set_ack	(	std::shared_ptr< const messages::electroneum::ElectroneumTransactionAllOutSetAck >	ack,
		hw::device &	hwdev )

Definition at line 837 of file protocol.cpp.

                                                                                                                                   {
    m_ct.rv = std::make_shared<rct::rctSig>();
    m_ct.rv->txnFee = ack->rv().txn_fee();
    m_ct.rv->type = static_cast<uint8_t>(ack->rv().rv_type());
    string_to_key(m_ct.rv->message, ack->rv().message());
 
    // Extra copy
    m_ct.tx.extra.clear();
    auto extra = ack->extra();
    auto extra_data = extra.data();
    m_ct.tx.extra.reserve(extra.size());
    for(size_t i = 0; i < extra.size(); ++i){
      m_ct.tx.extra.push_back(static_cast<uint8_t>(extra_data[i]));
    }
 
    ::crypto::hash tx_prefix_hash{};
    cryptonote::get_transaction_prefix_hash(m_ct.tx, tx_prefix_hash);
    m_ct.tx_prefix_hash = key_to_string(tx_prefix_hash);
    if (crypto_verify_32(reinterpret_cast<const unsigned char *>(tx_prefix_hash.data),
        reinterpret_cast<const unsigned char *>(ack->tx_prefix_hash().data()))){
      throw exc::proto::SecurityException("Transaction prefix has does not match to the computed value");
    }
 
    // RctSig
    auto num_sources = m_ct.tx_data.sources.size();
    if (is_simple() || is_req_bulletproof()){
      auto dst = &m_ct.rv->pseudoOuts;
      if (is_bulletproof()){
        dst = &m_ct.rv->p.pseudoOuts;
      }
 
      dst->clear();
      for (const auto &pseudo_out : m_ct.pseudo_outs) {
        dst->emplace_back();
        string_to_key(dst->back(), pseudo_out);
      }
 
      m_ct.rv->mixRing.resize(num_sources);
    } else {
      m_ct.rv->mixRing.resize(m_ct.tsx_data.mixin());
      m_ct.rv->mixRing[0].resize(num_sources);
    }
 
    CHECK_AND_ASSERT_THROW_MES(m_ct.tx_out_pk.size() == m_ct.tx_out_ecdh.size(), "Invalid vector sizes");
    for(size_t i = 0; i < m_ct.tx_out_ecdh.size(); ++i){
      m_ct.rv->outPk.push_back(m_ct.tx_out_pk[i]);
      m_ct.rv->ecdhInfo.push_back(m_ct.tx_out_ecdh[i]);
    }
 
    for(size_t i = 0; i < m_ct.tx_out_rsigs.size(); ++i){
      if (is_bulletproof()){
        m_ct.rv->p.bulletproofs.push_back(boost::get<rct::Bulletproof>(m_ct.tx_out_rsigs[i]));
      } else {
        m_ct.rv->p.rangeSigs.push_back(boost::get<rct::rangeSig>(m_ct.tx_out_rsigs[i]));
      }
    }
 
    rct::key hash_computed = rct::get_pre_mlsag_hash(*(m_ct.rv), hwdev);
    auto & hash = ack->full_message_hash();
 
    if (hash.size() != 32){
      throw exc::ProtocolException("Returned mlsag hash has invalid size");
    }
 
    if (crypto_verify_32(reinterpret_cast<const unsigned char *>(hash_computed.bytes),
                         reinterpret_cast<const unsigned char *>(hash.data()))){
      throw exc::proto::SecurityException("Computed MLSAG does not match");
    }
  }

Here is the call graph for this function:

step_final()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionFinalRequest > hw::trezor::protocol::tx::Signer::step_final

(

)

Definition at line 952 of file protocol.cpp.

                                                                                         {
    m_ct.tx.rct_signatures = *(m_ct.rv);
    return std::make_shared<messages::Electroneum::ElectroneumTransactionFinalRequest>();
  }

step_final_ack()

void hw::trezor::protocol::tx::Signer::step_final_ack

(

std::shared_ptr< const messages::electroneum::ElectroneumTransactionFinalAck >

ack

)

Definition at line 957 of file protocol.cpp.

                                                                                                       {
    if (m_multisig){
      auto & cout_key = ack->cout_key();
      for(auto & cur : m_ct.couts){
        if (cur.size() != crypto::chacha::IV_SIZE + 32){
          throw std::invalid_argument("Encrypted cout has invalid length");
        }
 
        char buff[32];
        auto data = cur.data();
 
        crypto::chacha::decrypt(data + crypto::chacha::IV_SIZE, 32, reinterpret_cast<const uint8_t *>(cout_key.data()), reinterpret_cast<const uint8_t *>(data), buff);
        m_ct.couts_dec.emplace_back(buff, 32);
      }
    }
 
    m_ct.enc_salt1 = ack->salt();
    m_ct.enc_salt2 = ack->rand_mult();
    m_ct.enc_keys = ack->tx_enc_keys();
  }

Here is the call graph for this function:

step_init()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionInitRequest > hw::trezor::protocol::tx::Signer::step_init

(

)

Definition at line 490 of file protocol.cpp.

                                                                                       {
    // extract payment ID from construction data
    auto & tsx_data = m_ct.tsx_data;
    auto & tx = cur_tx();
 
    m_ct.tx.version = 4;
    m_ct.tx.unlock_time = tx.unlock_time;
    m_client_version = (m_aux_data->client_version ? m_aux_data->client_version.get() : 1);
 
    tsx_data.set_version(1);
    tsx_data.set_client_version(client_version());
    tsx_data.set_unlock_time(tx.unlock_time);
    tsx_data.set_num_inputs(static_cast<google::protobuf::uint32>(tx.sources.size()));
    tsx_data.set_mixin(static_cast<google::protobuf::uint32>(tx.sources[0].outputs.size() - 1));
    tsx_data.set_account(tx.subaddr_account);
    assign_to_repeatable(tsx_data.mutable_minor_indices(), tx.subaddr_indices.begin(), tx.subaddr_indices.end());
 
    // Rsig decision
    auto rsig_data = tsx_data.mutable_rsig_data();
    m_ct.rsig_type = get_rsig_type(tx.rct_config, tx.splitted_dsts.size());
    rsig_data->set_rsig_type(m_ct.rsig_type);
    if (tx.rct_config.range_proof_type != rct::RangeProofBorromean){
      m_ct.bp_version = (m_aux_data->bp_version ? m_aux_data->bp_version.get() : 1);
      rsig_data->set_bp_version((uint32_t) m_ct.bp_version);
    }
 
    generate_rsig_batch_sizes(m_ct.grouping_vct, m_ct.rsig_type, tx.splitted_dsts.size());
    assign_to_repeatable(rsig_data->mutable_grouping(), m_ct.grouping_vct.begin(), m_ct.grouping_vct.end());
 
    translate_dst_entry(tsx_data.mutable_change_dts(), &(tx.change_dts));
    for(auto & cur : tx.splitted_dsts){
      auto dst = tsx_data.mutable_outputs()->Add();
      translate_dst_entry(dst, &cur);
    }
 
    compute_integrated_indices(&tsx_data);
 
    int64_t fee = 0;
    for(auto & cur_in : tx.sources){
      fee += cur_in.amount;
    }
    for(auto & cur_out : tx.splitted_dsts){
      fee -= cur_out.amount;
    }
    if (fee < 0){
      throw std::invalid_argument("Fee cannot be negative");
    }
 
    tsx_data.set_fee(static_cast<google::protobuf::uint64>(fee));
    this->extract_payment_id();
 
    auto init_req = std::make_shared<messages::Electroneum::ElectroneumTransactionInitRequest>();
    init_req->set_version(0);
    init_req->mutable_tsx_data()->CopyFrom(tsx_data);
    return init_req;
  }

Here is the call graph for this function:

step_init_ack()

void hw::trezor::protocol::tx::Signer::step_init_ack

(

std::shared_ptr< const messages::electroneum::ElectroneumTransactionInitAck >

ack

)

Definition at line 547 of file protocol.cpp.

                                                                                                     {
    if (ack->has_rsig_data()){
      m_ct.rsig_param = std::make_shared<ElectroneumRsigData>(ack->rsig_data());
    }
 
    assign_from_repeatable(&(m_ct.tx_out_entr_hmacs), ack->hmacs().begin(), ack->hmacs().end());
  }

Here is the call graph for this function:

step_permutation()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionInputsPermutationRequest > hw::trezor::protocol::tx::Signer::step_permutation

(

)

Definition at line 612 of file protocol.cpp.

                                                                                                           {
    sort_ki();
 
    auto res = std::make_shared<messages::Electroneum::ElectroneumTransactionInputsPermutationRequest>();
    assign_to_repeatable(res->mutable_perm(), m_ct.source_permutation.begin(), m_ct.source_permutation.end());
 
    return res;
  }

Here is the call graph for this function:

step_permutation_ack()

void hw::trezor::protocol::tx::Signer::step_permutation_ack

(

std::shared_ptr< const messages::electroneum::ElectroneumTransactionInputsPermutationAck >

ack

)

Definition at line 621 of file protocol.cpp.

                                                                                                                         {
 
  }

step_rsig()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionSetOutputRequest > hw::trezor::protocol::tx::Signer::step_rsig

(

size_t

idx

)

Definition at line 813 of file protocol.cpp.

                                                                                                      {
    if (client_version() == 0 || !is_offloading() || !should_compute_bp_now()){
      return nullptr;
    }
 
    auto res = std::make_shared<messages::Electroneum::ElectroneumTransactionSetOutputRequest>();
    auto & cur_dst = m_ct.tx_data.splitted_dsts[idx];
    translate_dst_entry(res->mutable_dst_entr(), &cur_dst);
    res->set_dst_entr_hmac(m_ct.tx_out_entr_hmacs[idx]);
 
    compute_bproof(*(res->mutable_rsig_data()));
    res->set_is_offloaded_bp(true);
    return res;
  }

Here is the call graph for this function:

step_set_input()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionSetInputRequest > hw::trezor::protocol::tx::Signer::step_set_input

(

size_t

idx

)

Definition at line 555 of file protocol.cpp.

                                                                                                          {
    CHECK_AND_ASSERT_THROW_MES(idx < cur_tx().sources.size(), "Invalid source index");
    m_ct.cur_input_idx = idx;
    auto res = std::make_shared<messages::Electroneum::ElectroneumTransactionSetInputRequest>();
    translate_src_entry(res->mutable_src_entr(), &(cur_tx().sources[idx]));
    return res;
  }

Here is the call graph for this function:

step_set_input_ack()

void hw::trezor::protocol::tx::Signer::step_set_input_ack

(

std::shared_ptr< const messages::electroneum::ElectroneumTransactionSetInputAck >

ack

)

Definition at line 563 of file protocol.cpp.

                                                                                                              {
    auto & vini_str = ack->vini();
 
    cryptonote::txin_v vini;
    if (!cn_deserialize(vini_str.data(), vini_str.size(), vini)){
      throw exc::ProtocolException("Cannot deserialize vin[i]");
    }
 
    m_ct.tx.vin.emplace_back(vini);
    m_ct.tx_in_hmacs.push_back(ack->vini_hmac());
    m_ct.pseudo_outs.push_back(ack->pseudo_out());
    m_ct.pseudo_outs_hmac.push_back(ack->pseudo_out_hmac());
    m_ct.alphas.push_back(ack->pseudo_out_alpha());
    m_ct.spend_encs.push_back(ack->spend_key());
  }

Here is the call graph for this function:

step_set_output()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionSetOutputRequest > hw::trezor::protocol::tx::Signer::step_set_output

(

size_t

idx

)

Definition at line 684 of file protocol.cpp.

                                                                                                            {
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.tx_data.splitted_dsts.size(), "Invalid transaction index");
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.tx_out_entr_hmacs.size(), "Invalid transaction index");
    CHECK_AND_ASSERT_THROW_MES(is_req_bulletproof(), "Borromean rsig not supported");
 
    m_ct.cur_output_idx = idx;
    m_ct.cur_output_in_batch_idx += 1;   // assumes sequential call to step_set_output()
 
    auto res = std::make_shared<messages::Electroneum::ElectroneumTransactionSetOutputRequest>();
    auto & cur_dst = m_ct.tx_data.splitted_dsts[idx];
    translate_dst_entry(res->mutable_dst_entr(), &cur_dst);
    res->set_dst_entr_hmac(m_ct.tx_out_entr_hmacs[idx]);
 
    // Range sig offloading to the host
    // ClientV0 sends offloaded BP with the last message in the batch.
    // ClientV1 needs additional message after the last message in the batch as BP uses deterministic masks.
    if (client_version() == 0 && is_offloading() && should_compute_bp_now()) {
      auto rsig_data = res->mutable_rsig_data();
      compute_bproof(*rsig_data);
    }
 
    return res;
  }

Here is the call graph for this function:

step_set_output_ack()

void hw::trezor::protocol::tx::Signer::step_set_output_ack

(

std::shared_ptr< const messages::electroneum::ElectroneumTransactionSetOutputAck >

ack

)

Definition at line 708 of file protocol.cpp.

                                                                                                                {
    cryptonote::tx_out tx_out;
    rct::Bulletproof bproof{};
    rct::ctkey out_pk{};
    rct::ecdhTuple ecdh{};
 
    bool has_rsig = false;
    std::string rsig_buff;
 
    if (ack->has_rsig_data()){
      auto & rsig_data = ack->rsig_data();
 
      if (rsig_data.has_rsig() && !rsig_data.rsig().empty()){
        has_rsig = true;
        rsig_buff = rsig_data.rsig();
      }
 
      if (client_version() >= 1 && rsig_data.has_mask()){
        rct::key cmask{};
        string_to_key(cmask, rsig_data.mask());
        m_ct.rsig_gamma.emplace_back(cmask);
      }
    }
 
    if (!cn_deserialize(ack->tx_out(), tx_out)){
      throw exc::ProtocolException("Cannot deserialize vout[i]");
    }
 
    if (!cn_deserialize(ack->out_pk(), out_pk)){
      throw exc::ProtocolException("Cannot deserialize out_pk");
    }
 
    if (m_ct.bp_version <= 1) {
      if (!cn_deserialize(ack->ecdh_info(), ecdh)){
        throw exc::ProtocolException("Cannot deserialize ecdhtuple");
      }
    } else {
      CHECK_AND_ASSERT_THROW_MES(8 == ack->ecdh_info().size(), "Invalid ECDH.amount size");
      memcpy(ecdh.amount.bytes, ack->ecdh_info().data(), 8);
    }
 
    if (has_rsig && is_req_bulletproof() && !cn_deserialize(rsig_buff, bproof)){
      throw exc::ProtocolException("Cannot deserialize bulletproof rangesig");
    }
 
    m_ct.tx.vout.emplace_back(tx_out);
    m_ct.tx_out_hmacs.push_back(ack->vouti_hmac());
    m_ct.tx_out_pk.emplace_back(out_pk);
    m_ct.tx_out_ecdh.emplace_back(ecdh);
 
    // ClientV0, if no rsig was generated on Trezor, do not continue.
    // ClientV1+ generates BP after all masks in the current batch are generated
    if (!has_rsig || (client_version() >= 1 && is_offloading())){
      return;
    }
 
    process_bproof(bproof);
    m_ct.cur_batch_idx += 1;
    m_ct.cur_output_in_batch_idx = 0;
  }

Here is the call graph for this function:

step_set_rsig_ack()

void hw::trezor::protocol::tx::Signer::step_set_rsig_ack

(

std::shared_ptr< const messages::electroneum::ElectroneumTransactionSetOutputAck >

ack

)

Definition at line 828 of file protocol.cpp.

                                                                                                              {
    m_ct.cur_batch_idx += 1;
    m_ct.cur_output_in_batch_idx = 0;
  }

step_set_vini_input()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionInputViniRequest > hw::trezor::protocol::tx::Signer::step_set_vini_input

(

size_t

idx

)

Definition at line 625 of file protocol.cpp.

                                                                                                                {
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.tx_data.sources.size(), "Invalid transaction index");
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.tx.vin.size(), "Invalid transaction index");
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.tx_in_hmacs.size(), "Invalid transaction index");
 
    m_ct.cur_input_idx = idx;
    auto tx = m_ct.tx_data;
    auto res = std::make_shared<messages::Electroneum::ElectroneumTransactionInputViniRequest>();
    auto & vini = m_ct.tx.vin[idx];
    translate_src_entry(res->mutable_src_entr(), &(tx.sources[idx]));
    res->set_vini(cryptonote::t_serializable_object_to_blob(vini));
    res->set_vini_hmac(m_ct.tx_in_hmacs[idx]);
 
    if (client_version() == 0) {
      CHECK_AND_ASSERT_THROW_MES(idx < m_ct.pseudo_outs.size(), "Invalid transaction index");
      CHECK_AND_ASSERT_THROW_MES(idx < m_ct.pseudo_outs_hmac.size(), "Invalid transaction index");
      res->set_pseudo_out(m_ct.pseudo_outs[idx]);
      res->set_pseudo_out_hmac(m_ct.pseudo_outs_hmac[idx]);
    }
 
    return res;
  }

Here is the call graph for this function:

step_set_vini_input_ack()

void hw::trezor::protocol::tx::Signer::step_set_vini_input_ack

(

std::shared_ptr< const messages::electroneum::ElectroneumTransactionInputViniAck >

ack

)

Definition at line 648 of file protocol.cpp.

                                                                                                                    {
 
  }

step_sign_input()

std::shared_ptr< messages::Electroneum::ElectroneumTransactionSignInputRequest > hw::trezor::protocol::tx::Signer::step_sign_input

(

size_t

idx

)

Definition at line 907 of file protocol.cpp.

                                                                                                            {
    m_ct.cur_input_idx = idx;
 
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.tx_data.sources.size(), "Invalid transaction index");
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.tx.vin.size(), "Invalid transaction index");
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.tx_in_hmacs.size(), "Invalid transaction index");
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.alphas.size(), "Invalid transaction index");
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.spend_encs.size(), "Invalid transaction index");
 
    auto res = std::make_shared<messages::Electroneum::ElectroneumTransactionSignInputRequest>();
    translate_src_entry(res->mutable_src_entr(), &(m_ct.tx_data.sources[idx]));
    res->set_vini(cryptonote::t_serializable_object_to_blob(m_ct.tx.vin[idx]));
    res->set_vini_hmac(m_ct.tx_in_hmacs[idx]);
    res->set_pseudo_out_alpha(m_ct.alphas[idx]);
    res->set_spend_key(m_ct.spend_encs[idx]);
 
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.pseudo_outs.size(), "Invalid transaction index");
    CHECK_AND_ASSERT_THROW_MES(idx < m_ct.pseudo_outs_hmac.size(), "Invalid transaction index");
    res->set_pseudo_out(m_ct.pseudo_outs[idx]);
    res->set_pseudo_out_hmac(m_ct.pseudo_outs_hmac[idx]);
    return res;
  }

Here is the call graph for this function:

step_sign_input_ack()

void hw::trezor::protocol::tx::Signer::step_sign_input_ack

(

std::shared_ptr< const messages::electroneum::ElectroneumTransactionSignInputAck >

ack

)

Definition at line 930 of file protocol.cpp.

                                                                                                                {
    rct::mgSig mg;
    if (!cn_deserialize(ack->signature(), mg)){
      throw exc::ProtocolException("Cannot deserialize mg[i]");
    }
 
    // Sync updated pseudo_outputs, client_version>=1, HF10+
    if (client_version() >= 1 && ack->has_pseudo_out()){
      CHECK_AND_ASSERT_THROW_MES(m_ct.cur_input_idx < m_ct.pseudo_outs.size(), "Invalid pseudo-out index");
      m_ct.pseudo_outs[m_ct.cur_input_idx] = ack->pseudo_out();
      if (is_bulletproof()){
        CHECK_AND_ASSERT_THROW_MES(m_ct.cur_input_idx < m_ct.rv->p.pseudoOuts.size(), "Invalid pseudo-out index");
        string_to_key(m_ct.rv->p.pseudoOuts[m_ct.cur_input_idx], ack->pseudo_out());
      } else {
        CHECK_AND_ASSERT_THROW_MES(m_ct.cur_input_idx < m_ct.rv->pseudoOuts.size(), "Invalid pseudo-out index");
        string_to_key(m_ct.rv->pseudoOuts[m_ct.cur_input_idx], ack->pseudo_out());
      }
    }
 
    m_ct.rv->p.MGs.push_back(mg);
  }

Here is the call graph for this function:

store_tx_aux_info()

std::string hw::trezor::protocol::tx::Signer::store_tx_aux_info

(

)

Definition at line 978 of file protocol.cpp.

                                     {
    rapidjson::StringBuffer sb;
    rapidjson::Writer<rapidjson::StringBuffer> writer(sb);
 
    rapidjson::Document json;
    json.SetObject();
 
    rapidjson::Value valueS(rapidjson::kStringType);
    rapidjson::Value valueI(rapidjson::kNumberType);
 
    valueI.SetInt(1);
    json.AddMember("version", valueI, json.GetAllocator());
 
    valueS.SetString(m_ct.enc_salt1.c_str(), m_ct.enc_salt1.size());
    json.AddMember("salt1", valueS, json.GetAllocator());
 
    valueS.SetString(m_ct.enc_salt2.c_str(), m_ct.enc_salt2.size());
    json.AddMember("salt2", valueS, json.GetAllocator());
 
    valueS.SetString(m_ct.tx_prefix_hash.c_str(), m_ct.tx_prefix_hash.size());
    json.AddMember("tx_prefix_hash", valueS, json.GetAllocator());
 
    valueS.SetString(m_ct.enc_keys.c_str(), m_ct.enc_keys.size());
    json.AddMember("enc_keys", valueS, json.GetAllocator());
 
    json.Accept(writer);
    return sb.GetString();
  }

tdata()

const TData & hw::trezor::protocol::tx::Signer::tdata ( ) const

inline

Definition at line 307 of file protocol.hpp.

                                {
      return m_ct;
    }

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/device_trezor/trezor/protocol.hpp
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/device_trezor/trezor/protocol.cpp