hw::trezor::protocol::tx Namespace Reference

Classes
class	TData
class	Signer

Typedefs
using	TsxData = messages::electroneum::ElectroneumTransactionInitRequest_ElectroneumTransactionData
using	ElectroneumTransactionDestinationEntry = messages::electroneum::ElectroneumTransactionDestinationEntry
using	ElectroneumAccountPublicAddress = messages::electroneum::ElectroneumTransactionDestinationEntry_ElectroneumAccountPublicAddress
using	ElectroneumTransactionSourceEntry = messages::electroneum::ElectroneumTransactionSourceEntry
using	ElectroneumMultisigKLRki = messages::electroneum::ElectroneumTransactionSourceEntry_ElectroneumMultisigKLRki
using	ElectroneumOutputEntry = messages::electroneum::ElectroneumTransactionSourceEntry_ElectroneumOutputEntry
using	ElectroneumRctKey = messages::electroneum::ElectroneumTransactionSourceEntry_ElectroneumOutputEntry_ElectroneumRctKeyPublic
using	ElectroneumRsigData = messages::electroneum::ElectroneumTransactionRsigData
using	tx_construction_data = tools::wallet2::tx_construction_data
using	unsigned_tx_set = tools::wallet2::unsigned_tx_set
typedef boost::variant< rct::rangeSig, rct::Bulletproof >	rsig_v

Functions
void	translate_address (ElectroneumAccountPublicAddress *dst, const cryptonote::account_public_address *src)
void	translate_dst_entry (ElectroneumTransactionDestinationEntry *dst, const cryptonote::tx_destination_entry *src)
void	translate_src_entry (ElectroneumTransactionSourceEntry *dst, const cryptonote::tx_source_entry *src)
void	translate_klrki (ElectroneumMultisigKLRki *dst, const rct::multisig_kLRki *src)
void	translate_rct_key (ElectroneumRctKey *dst, const rct::ctkey *src)
std::string	hash_addr (const ElectroneumAccountPublicAddress *addr, boost::optional< uint64_t > amount, boost::optional< bool > is_subaddr)
std::string	hash_addr (const std::string &spend_key, const std::string &view_key, boost::optional< uint64_t > amount, boost::optional< bool > is_subaddr)
std::string	hash_addr (const ::crypto::public_key *spend_key, const ::crypto::public_key *view_key, boost::optional< uint64_t > amount, boost::optional< bool > is_subaddr)
::crypto::secret_key	compute_enc_key (const ::crypto::secret_key &private_view_key, const std::string &aux, const std::string &salt)
void	load_tx_key_data (hw::device_cold::tx_key_data_t &res, const std::string &data)
std::shared_ptr< messages::Electroneum::ElectroneumGetTxKeyRequest >	get_tx_key (const hw::device_cold::tx_key_data_t &tx_data)
void	get_tx_key_ack (std::vector<::crypto::secret_key > &tx_keys, const std::string &tx_prefix_hash, const ::crypto::secret_key &view_key_priv, std::shared_ptr< const messages::Electroneum::ElectroneumGetTxKeyAck > ack)
void	get_tx_key_ack (std::vector<::crypto::secret_key > &tx_keys, const std::string &tx_prefix_hash, const ::crypto::secret_key &view_key_priv, std::shared_ptr< const messages::electroneum::ElectroneumGetTxKeyAck > ack)

Typedef Documentation

ElectroneumAccountPublicAddress

using hw::trezor::protocol::tx::ElectroneumAccountPublicAddress = messages::electroneum::ElectroneumTransactionDestinationEntry_ElectroneumAccountPublicAddress

Definition at line 149 of file protocol.hpp.

ElectroneumMultisigKLRki

using hw::trezor::protocol::tx::ElectroneumMultisigKLRki = messages::electroneum::ElectroneumTransactionSourceEntry_ElectroneumMultisigKLRki

Definition at line 151 of file protocol.hpp.

ElectroneumOutputEntry

using hw::trezor::protocol::tx::ElectroneumOutputEntry = messages::electroneum::ElectroneumTransactionSourceEntry_ElectroneumOutputEntry

Definition at line 152 of file protocol.hpp.

ElectroneumRctKey

using hw::trezor::protocol::tx::ElectroneumRctKey = messages::electroneum::ElectroneumTransactionSourceEntry_ElectroneumOutputEntry_ElectroneumRctKeyPublic

Definition at line 153 of file protocol.hpp.

ElectroneumRsigData

using hw::trezor::protocol::tx::ElectroneumRsigData = messages::electroneum::ElectroneumTransactionRsigData

Definition at line 154 of file protocol.hpp.

ElectroneumTransactionDestinationEntry

using hw::trezor::protocol::tx::ElectroneumTransactionDestinationEntry = messages::electroneum::ElectroneumTransactionDestinationEntry

Definition at line 148 of file protocol.hpp.

ElectroneumTransactionSourceEntry

using hw::trezor::protocol::tx::ElectroneumTransactionSourceEntry = messages::electroneum::ElectroneumTransactionSourceEntry

Definition at line 150 of file protocol.hpp.

rsig_v

typedef boost::variant<rct::rangeSig, rct::Bulletproof> hw::trezor::protocol::tx::rsig_v

Definition at line 169 of file protocol.hpp.

TsxData

using hw::trezor::protocol::tx::TsxData = messages::electroneum::ElectroneumTransactionInitRequest_ElectroneumTransactionData

Definition at line 147 of file protocol.hpp.

tx_construction_data

using hw::trezor::protocol::tx::tx_construction_data = tools::wallet2::tx_construction_data

Definition at line 156 of file protocol.hpp.

unsigned_tx_set

using hw::trezor::protocol::tx::unsigned_tx_set = tools::wallet2::unsigned_tx_set

Definition at line 157 of file protocol.hpp.

Function Documentation

compute_enc_key()

crypto::secret_key hw::trezor::protocol::tx::compute_enc_key	(	const ::crypto::secret_key &	private_view_key,
		const std::string &	aux,
		const std::string &	salt )

Definition at line 351 of file protocol.cpp.

  {
    uint8_t hash[32];
    KECCAK_CTX ctx;
    ::crypto::secret_key res;
 
    keccak_init(&ctx);
    keccak_update(&ctx, (const uint8_t *) private_view_key.data, sizeof(private_view_key.data));
    if (!aux.empty()){
      keccak_update(&ctx, (const uint8_t *) aux.data(), aux.size());
    }
    keccak_finish(&ctx, hash);
    keccak(hash, sizeof(hash), hash, sizeof(hash));
 
    hmac_keccak_hash(hash, (const uint8_t *) salt.data(), salt.size(), hash, sizeof(hash));
    memcpy(res.data, hash, sizeof(hash));
    memwipe(hash, sizeof(hash));
    return res;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_tx_key()

std::shared_ptr< messages::electroneum::ElectroneumGetTxKeyRequest > hw::trezor::protocol::tx::get_tx_key

(

const hw::device_cold::tx_key_data_t &

tx_data

)

Definition at line 1038 of file protocol.cpp.

  {
    auto req = std::make_shared<messages::Electroneum::ElectroneumGetTxKeyRequest>();
    req->set_salt1(tx_data.salt1);
    req->set_salt2(tx_data.salt2);
    req->set_tx_enc_keys(tx_data.tx_enc_keys);
    req->set_tx_prefix_hash(tx_data.tx_prefix_hash);
    req->set_reason(0);
 
    return req;
  }

get_tx_key_ack() [1/2]

void hw::trezor::protocol::tx::get_tx_key_ack	(	std::vector<::crypto::secret_key > &	tx_keys,
		const std::string &	tx_prefix_hash,
		const ::crypto::secret_key &	view_key_priv,
		std::shared_ptr< const messages::Electroneum::ElectroneumGetTxKeyAck >	ack )

Definition at line 1051 of file protocol.cpp.

  {
    auto enc_key = protocol::tx::compute_enc_key(view_key_priv, tx_prefix_hash, ack->salt());
    auto & encrypted_keys = ack->has_tx_derivations() ? ack->tx_derivations() : ack->tx_keys();
 
    const size_t len_ciphertext = encrypted_keys.size();  // IV || keys || TAG
    CHECK_AND_ASSERT_THROW_MES(len_ciphertext > crypto::chacha::IV_SIZE + crypto::chacha::TAG_SIZE, "Invalid size");
 
    size_t keys_len = len_ciphertext - crypto::chacha::IV_SIZE - crypto::chacha::TAG_SIZE;
    std::unique_ptr<uint8_t[]> plaintext(new uint8_t[keys_len]);
 
    protocol::crypto::chacha::decrypt(
        encrypted_keys.data() + crypto::chacha::IV_SIZE,
        len_ciphertext - crypto::chacha::IV_SIZE,
        reinterpret_cast<const uint8_t *>(enc_key.data),
        reinterpret_cast<const uint8_t *>(encrypted_keys.data()),
        reinterpret_cast<char *>(plaintext.get()), &keys_len);
 
    CHECK_AND_ASSERT_THROW_MES(keys_len % 32 == 0, "Invalid size");
    tx_keys.resize(keys_len / 32);
 
    for(unsigned i = 0; i < keys_len / 32; ++i)
    {
      memcpy(tx_keys[i].data, plaintext.get() + 32 * i, 32);
    }
    memwipe(plaintext.get(), keys_len);
  }

Here is the call graph for this function:

get_tx_key_ack() [2/2]

void hw::trezor::protocol::tx::get_tx_key_ack	(	std::vector<::crypto::secret_key > &	tx_keys,
		const std::string &	tx_prefix_hash,
		const ::crypto::secret_key &	view_key_priv,
		std::shared_ptr< const messages::electroneum::ElectroneumGetTxKeyAck >	ack )

hash_addr() [1/3]

std::string hw::trezor::protocol::tx::hash_addr	(	const ::crypto::public_key *	spend_key,
		const ::crypto::public_key *	view_key,
		boost::optional< uint64_t >	amount,
		boost::optional< bool >	is_subaddr )

Definition at line 332 of file protocol.cpp.

                                                                                                                                                            {
    char buff[64+8+1];
    size_t offset = 0;
 
    memcpy(buff + offset, spend_key->data, 32); offset += 32;
    memcpy(buff + offset, view_key->data, 32); offset += 32;
 
    if (amount){
      memcpy(buff + offset, (uint8_t*) &(amount.get()), sizeof(amount.get())); offset += sizeof(amount.get());
    }
 
    if (is_subaddr){
      buff[offset] = is_subaddr.get();
      offset += 1;
    }
 
    return std::string(buff, offset);
  }

Here is the call graph for this function:

hash_addr() [2/3]

std::string hw::trezor::protocol::tx::hash_addr	(	const ElectroneumAccountPublicAddress *	addr,
		boost::optional< uint64_t >	amount,
		boost::optional< bool >	is_subaddr )

Definition at line 317 of file protocol.cpp.

                                                                                                                                   {
    return hash_addr(addr->spend_public_key(), addr->view_public_key(), amount, is_subaddr);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

hash_addr() [3/3]

std::string hw::trezor::protocol::tx::hash_addr	(	const std::string &	spend_key,
		const std::string &	view_key,
		boost::optional< uint64_t >	amount,
		boost::optional< bool >	is_subaddr )

Definition at line 321 of file protocol.cpp.

                                                                                                                                              {
    ::crypto::public_key spend{}, view{};
    if (spend_key.size() != 32 || view_key.size() != 32){
      throw std::invalid_argument("Public keys have invalid sizes");
    }
 
    memcpy(spend.data, spend_key.data(), 32);
    memcpy(view.data, view_key.data(), 32);
    return hash_addr(&spend, &view, amount, is_subaddr);
  }

Here is the call graph for this function:

load_tx_key_data()

void hw::trezor::protocol::tx::load_tx_key_data	(	hw::device_cold::tx_key_data_t &	res,
		const std::string &	data )

Definition at line 1007 of file protocol.cpp.

  {
    rapidjson::Document json;
 
    // The contents should be JSON if the wallet follows the new format.
    if (json.Parse(data.c_str()).HasParseError())
    {
      throw std::invalid_argument("Data parsing error");
    }
    else if(!json.IsObject())
    {
      throw std::invalid_argument("Data parsing error - not an object");
    }
 
    GET_FIELD_FROM_JSON(json, version, int, Int, true, -1);
    GET_STRING_FROM_JSON(json, salt1, std::string, true, std::string());
    GET_STRING_FROM_JSON(json, salt2, std::string, true, std::string());
    GET_STRING_FROM_JSON(json, enc_keys, std::string, true, std::string());
    GET_STRING_FROM_JSON(json, tx_prefix_hash, std::string, false, std::string());
 
    if (field_version != 1)
    {
      throw std::invalid_argument("Unknown version");
    }
 
    res.salt1 = field_salt1;
    res.salt2 = field_salt2;
    res.tx_enc_keys = field_enc_keys;
    res.tx_prefix_hash = field_tx_prefix_hash;
  }

translate_address()

void hw::trezor::protocol::tx::translate_address	(	ElectroneumAccountPublicAddress *	dst,
		const cryptonote::account_public_address *	src )

Definition at line 272 of file protocol.cpp.

                                                                                                             {
    dst->set_view_public_key(key_to_string(src->m_view_public_key));
    dst->set_spend_public_key(key_to_string(src->m_spend_public_key));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

translate_dst_entry()

void hw::trezor::protocol::tx::translate_dst_entry	(	ElectroneumTransactionDestinationEntry *	dst,
		const cryptonote::tx_destination_entry *	src )

Definition at line 277 of file protocol.cpp.

                                                                                                                    {
    dst->set_amount(src->amount);
    dst->set_is_subaddress(src->is_subaddress);
    dst->set_is_integrated(src->is_integrated);
    dst->set_original(src->original);
    translate_address(dst->mutable_addr(), &(src->addr));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

translate_klrki()

void hw::trezor::protocol::tx::translate_klrki	(	ElectroneumMultisigKLRki *	dst,
		const rct::multisig_kLRki *	src )

Definition at line 305 of file protocol.cpp.

                                                                                     {
    dst->set_k(key_to_string(src->k));
    dst->set_l(key_to_string(src->L));
    dst->set_r(key_to_string(src->R));
    dst->set_ki(key_to_string(src->ki));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

translate_rct_key()

void hw::trezor::protocol::tx::translate_rct_key	(	ElectroneumRctKey *	dst,
		const rct::ctkey *	src )

Definition at line 312 of file protocol.cpp.

                                                                       {
    dst->set_dest(key_to_string(src->dest));
    dst->set_commitment(key_to_string(src->mask));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

translate_src_entry()

void hw::trezor::protocol::tx::translate_src_entry	(	ElectroneumTransactionSourceEntry *	dst,
		const cryptonote::tx_source_entry *	src )

Definition at line 285 of file protocol.cpp.

                                                                                                          {
    for(auto & cur : src->outputs){
      auto out = dst->add_outputs();
      out->set_idx(cur.first);
      translate_rct_key(out->mutable_key(), &(cur.second));
    }
 
    dst->set_real_output(src->real_output);
    dst->set_real_out_tx_key(key_to_string(src->real_out_tx_key));
    for(auto & cur : src->real_out_additional_tx_keys){
      dst->add_real_out_additional_tx_keys(key_to_string(cur));
    }
 
    dst->set_real_output_in_tx_index(src->real_output_in_tx_index);
    dst->set_amount(src->amount);
    dst->set_rct(src->rct);
    dst->set_mask(key_to_string(src->mask));
    translate_klrki(dst->mutable_multisig_klrki(), &(src->multisig_kLRki));
  }

Here is the call graph for this function:

Here is the caller graph for this function: