@ -291,12 +291,6 @@ void do_prepare_file_names(const std::string& file_path, std::string& keys_file,
mms_file = file_path + " .mms " ;
}
uint64_t calculate_fee ( uint64_t fee_per_kb , size_t bytes )
{
uint64_t kB = ( bytes + 1023 ) / 1024 ;
return kB * fee_per_kb ;
}
uint64_t calculate_fee_from_weight ( uint64_t base_fee , uint64_t weight , uint64_t fee_quantization_mask )
{
uint64_t fee = weight * base_fee ;
@ -890,12 +884,9 @@ uint8_t get_view_tag_fork()
return HF_VERSION_VIEW_TAGS ;
}
uint64_t calculate_fee ( bool use_per_byte_fee , const cryptonote : : transaction & tx , size_t blob_size , uint64_t base_fee , uint64_t fee_quantization_mask )
uint64_t calculate_fee ( const cryptonote : : transaction & tx , size_t blob_size , uint64_t base_fee , uint64_t fee_quantization_mask )
{
if ( use_per_byte_fee )
return calculate_fee_from_weight ( base_fee , cryptonote : : get_transaction_weight ( tx , blob_size ) , fee_quantization_mask ) ;
else
return calculate_fee ( base_fee , blob_size ) ;
return calculate_fee_from_weight ( base_fee , cryptonote : : get_transaction_weight ( tx , blob_size ) , fee_quantization_mask ) ;
}
bool get_short_payment_id ( crypto : : hash8 & payment_id8 , const tools : : wallet2 : : pending_tx & ptx , hw : : device & hwdev )
@ -7923,140 +7914,44 @@ bool wallet2::sign_multisig_tx_from_file(const std::string &filename, std::vecto
return sign_multisig_tx_to_file ( exported_txs , filename , txids ) ;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2 : : estimate_fee ( bool use_ per_byte_fee, bool use_ rct, int n_inputs , int mixin , int n_outputs , size_t extra_size , bool bulletproof , bool clsag , bool bulletproof_plus , bool use_view_tags , uint64_t base_fee , uint64_t fee_quantization_mask ) const
uint64_t wallet2 : : estimate_fee ( bool use_ rct, int n_inputs , int mixin , int n_outputs , size_t extra_size , bool bulletproof , bool clsag , bool bulletproof_plus , bool use_view_tags , uint64_t base_fee , uint64_t fee_quantization_mask ) const
{
if ( use_per_byte_fee )
{
const size_t estimated_tx_weight = estimate_tx_weight ( use_rct , n_inputs , mixin , n_outputs , extra_size , bulletproof , clsag , bulletproof_plus , use_view_tags ) ;
return calculate_fee_from_weight ( base_fee , estimated_tx_weight , fee_quantization_mask ) ;
}
else
{
const size_t estimated_tx_size = estimate_tx_size ( use_rct , n_inputs , mixin , n_outputs , extra_size , bulletproof , clsag , bulletproof_plus , use_view_tags ) ;
return calculate_fee ( base_fee , estimated_tx_size ) ;
}
}
uint64_t wallet2 : : get_fee_multiplier ( uint32_t priority , int fee_algorithm )
{
static const struct
{
size_t count ;
uint64_t multipliers [ 4 ] ;
}
multipliers [ ] =
{
{ 3 , { 1 , 2 , 3 } } ,
{ 3 , { 1 , 20 , 166 } } ,
{ 4 , { 1 , 4 , 20 , 166 } } ,
{ 4 , { 1 , 5 , 25 , 1000 } } ,
} ;
if ( fee_algorithm = = - 1 )
fee_algorithm = get_fee_algorithm ( ) ;
// 0 -> default (here, x1 till fee algorithm 2, x4 from it)
if ( priority = = 0 )
priority = m_default_priority ;
if ( priority = = 0 )
{
if ( fee_algorithm > = 2 )
priority = 2 ;
else
priority = 1 ;
}
THROW_WALLET_EXCEPTION_IF ( fee_algorithm < 0 | | fee_algorithm > 3 , error : : invalid_priority ) ;
// 1 to 3/4 are allowed as priorities
const uint32_t max_priority = multipliers [ fee_algorithm ] . count ;
if ( priority > = 1 & & priority < = max_priority )
{
return multipliers [ fee_algorithm ] . multipliers [ priority - 1 ] ;
}
THROW_WALLET_EXCEPTION_IF ( false , error : : invalid_priority ) ;
return 1 ;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2 : : get_dynamic_base_fee_estimate ( )
{
uint64_t fee ;
boost : : optional < std : : string > result = m_node_rpc_proxy . get_dynamic_base_fee_estimate ( FEE_ESTIMATE_GRACE_BLOCKS , fee ) ;
if ( ! result )
return fee ;
const uint64_t base_fee = use_fork_rules ( HF_VERSION_PER_BYTE_FEE ) ? FEE_PER_BYTE : FEE_PER_KB ;
LOG_PRINT_L1 ( " Failed to query base fee, using " < < print_money ( base_fee ) ) ;
return base_fee ;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2 : : get_base_fee ( )
{
bool use_dyn_fee = use_fork_rules ( HF_VERSION_DYNAMIC_FEE , - 30 * 1 ) ;
if ( ! use_dyn_fee )
return FEE_PER_KB ;
return get_dynamic_base_fee_estimate ( ) ;
const size_t estimated_tx_weight = estimate_tx_weight ( use_rct , n_inputs , mixin , n_outputs , extra_size , bulletproof , clsag , bulletproof_plus , use_view_tags ) ;
return calculate_fee_from_weight ( base_fee , estimated_tx_weight , fee_quantization_mask ) ;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2 : : get_base_fee ( uint32_t priority )
{
const bool use_2021_scaling = use_fork_rules ( HF_VERSION_2021_SCALING , - 30 * 1 ) ;
if ( use_2021_scaling )
{
// clamp and map to 0..3 indices, mapping 0 (default, but should not end up here) to 0, and 1..4 to 0..3
if ( priority = = 0 )
priority = 1 ;
else if ( priority > 4 )
priority = 4 ;
- - priority ;
// clamp and map to 0..3 indices, mapping 0 (default, but should not end up here) to 0, and 1..4 to 0..3
if ( priority = = 0 )
priority = 1 ;
else if ( priority > 4 )
priority = 4 ;
- - priority ;
std : : vector < uint64_t > fees ;
boost : : optional < std : : string > result = m_node_rpc_proxy . get_dynamic_base_fee_estimate_2021_scaling ( FEE_ESTIMATE_GRACE_BLOCKS , fees ) ;
if ( result )
{
MERROR ( " Failed to determine base fee, using default " ) ;
return FEE_PER_BYTE ;
}
if ( priority > = fees . size ( ) )
{
MERROR ( " Failed to determine base fee for priority " < < priority < < " , using default " ) ;
return FEE_PER_BYTE ;
}
return fees [ priority ] ;
std : : vector < uint64_t > fees ;
boost : : optional < std : : string > result = m_node_rpc_proxy . get_dynamic_base_fee_estimate_2021_scaling ( FEE_ESTIMATE_GRACE_BLOCKS , fees ) ;
if ( result )
{
MERROR ( " Failed to determine base fee, using default " ) ;
return FEE_PER_BYTE ;
}
else
if ( priority > = fees . size ( ) )
{
const uint64_t base_fee = get_base_fee ( ) ;
const uint64_t fee_multiplier = get_fee_multiplier ( priority ) ;
return base_fee * fee_multiplier ;
MERROR ( " Failed to determine base fee for priority " < < priority < < " , using default " ) ;
return FEE_PER_BYTE ;
}
return fees [ priority ] ;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2 : : get_fee_quantization_mask ( )
{
bool use_per_byte_fee = use_fork_rules ( HF_VERSION_PER_BYTE_FEE , 0 ) ;
if ( ! use_per_byte_fee )
return 1 ;
uint64_t fee_quantization_mask ;
boost : : optional < std : : string > result = m_node_rpc_proxy . get_fee_quantization_mask ( fee_quantization_mask ) ;
if ( result )
return 1 ;
return fee_quantization_mask ;
}
//----------------------------------------------------------------------------------------------------
int wallet2 : : get_fee_algorithm ( )
{
// changes at v3, v5, v8
if ( use_fork_rules ( HF_VERSION_PER_BYTE_FEE , 0 ) )
return 3 ;
if ( use_fork_rules ( 5 , 0 ) )
return 2 ;
if ( use_fork_rules ( 3 , - 30 * 14 ) )
return 1 ;
return 0 ;
}
//------------------------------------------------------------------------------------------------------------------------------
uint64_t wallet2 : : get_min_ring_size ( )
{
@ -8106,9 +8001,7 @@ uint32_t wallet2::adjust_priority(uint32_t priority)
try
{
// check if there's a backlog in the tx pool
const bool use_per_byte_fee = use_fork_rules ( HF_VERSION_PER_BYTE_FEE , 0 ) ;
const uint64_t base_fee = get_base_fee ( 1 ) ;
const double fee_level = base_fee * ( use_per_byte_fee ? 1 : ( 12 / ( double ) 13 / ( double ) 1024 ) ) ;
const double fee_level = get_base_fee ( 1 ) ;
const std : : vector < std : : pair < uint64_t , uint64_t > > blocks = estimate_backlog ( { std : : make_pair ( fee_level , fee_level ) } ) ;
if ( blocks . size ( ) ! = 1 )
{
@ -9981,7 +9874,6 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
bool adding_fee ; // true if new outputs go towards fee, rather than destinations
uint64_t needed_fee , available_for_fee = 0 ;
uint64_t upper_transaction_weight_limit = get_upper_transaction_weight_limit ( ) ;
const bool use_per_byte_fee = use_fork_rules ( HF_VERSION_PER_BYTE_FEE , 0 ) ;
const bool use_rct = use_fork_rules ( 4 , 0 ) ;
const bool bulletproof = use_fork_rules ( get_bulletproof_fork ( ) , 0 ) ;
const bool bulletproof_plus = use_fork_rules ( get_bulletproof_plus_fork ( ) , 0 ) ;
@ -10056,7 +9948,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
const size_t tx_weight_two_rings = estimate_tx_weight ( use_rct , 2 , fake_outs_count , 2 , 0 , bulletproof , clsag , bulletproof_plus , use_view_tags ) ;
THROW_WALLET_EXCEPTION_IF ( tx_weight_one_ring > tx_weight_two_rings , error : : wallet_internal_error , " Estimated tx weight with 1 input is larger than with 2 inputs! " ) ;
const size_t tx_weight_per_ring = tx_weight_two_rings - tx_weight_one_ring ;
const uint64_t fractional_threshold = ( base_fee * tx_weight_per_ring ) / ( use_per_byte_fee ? 1 : 1024 ) ;
const uint64_t fractional_threshold = base_fee * tx_weight_per_ring ;
// gather all dust and non-dust outputs belonging to specified subaddresses
size_t num_nondust_outputs = 0 ;
@ -10147,7 +10039,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
{
// this is used to build a tx that's 1 or 2 inputs, and 2 outputs, which
// will get us a known fee.
uint64_t estimated_fee = estimate_fee ( use_ per_byte_fee, use_ rct, 2 , fake_outs_count , 2 , extra . size ( ) , bulletproof , clsag , bulletproof_plus , use_view_tags , base_fee , fee_quantization_mask ) ;
uint64_t estimated_fee = estimate_fee ( use_ rct, 2 , fake_outs_count , 2 , extra . size ( ) , bulletproof , clsag , bulletproof_plus , use_view_tags , base_fee , fee_quantization_mask ) ;
total_needed_money = needed_money + ( subtract_fee_from_outputs . size ( ) ? 0 : estimated_fee ) ;
preferred_inputs = pick_preferred_rct_inputs ( total_needed_money , subaddr_account , subaddr_indices ) ;
if ( ! preferred_inputs . empty ( ) )
@ -10330,7 +10222,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
pending_tx test_ptx ;
const size_t num_outputs = get_num_outputs ( tx . dsts , m_transfers , tx . selected_transfers ) ;
needed_fee = estimate_fee ( use_ per_byte_fee, use_ rct , tx . selected_transfers . size ( ) , fake_outs_count , num_outputs , extra . size ( ) , bulletproof , clsag , bulletproof_plus , use_view_tags , base_fee , fee_quantization_mask ) ;
needed_fee = estimate_fee ( use_ rct , tx . selected_transfers . size ( ) , fake_outs_count , num_outputs , extra . size ( ) , bulletproof , clsag , bulletproof_plus , use_view_tags , base_fee , fee_quantization_mask ) ;
auto try_carving_from_partial_payment = [ & ] ( uint64_t needed_fee , uint64_t available_for_fee )
{
@ -10389,7 +10281,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
transfer_selected ( tx_dsts , tx . selected_transfers , fake_outs_count , outs , valid_public_keys_cache , unlock_time , needed_fee , extra ,
detail : : digit_split_strategy , tx_dust_policy ( : : config : : DEFAULT_DUST_THRESHOLD ) , test_tx , test_ptx , use_view_tags ) ;
auto txBlob = t_serializable_object_to_blob ( test_ptx . tx ) ;
needed_fee = calculate_fee ( use_per_byte_fee, test_ptx. tx , txBlob . size ( ) , base_fee , fee_quantization_mask ) ;
needed_fee = calculate_fee ( test_ptx. tx , txBlob . size ( ) , base_fee , fee_quantization_mask ) ;
// Depending on the mode, we take extra fees from either our change output or the destination outputs for which subtract_fee_from_outputs is true
uint64_t output_available_for_fee = 0 ;
@ -10433,7 +10325,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
transfer_selected ( tx_dsts , tx . selected_transfers , fake_outs_count , outs , valid_public_keys_cache , unlock_time , needed_fee , extra ,
detail : : digit_split_strategy , tx_dust_policy ( : : config : : DEFAULT_DUST_THRESHOLD ) , test_tx , test_ptx , use_view_tags ) ;
txBlob = t_serializable_object_to_blob ( test_ptx . tx ) ;
needed_fee = calculate_fee ( use_per_byte_fee, test_ptx. tx , txBlob . size ( ) , base_fee , fee_quantization_mask ) ;
needed_fee = calculate_fee ( test_ptx. tx , txBlob . size ( ) , base_fee , fee_quantization_mask ) ;
LOG_PRINT_L2 ( " Made an attempt at a final " < < get_weight_string ( test_ptx . tx , txBlob . size ( ) ) < < " tx, with " < < print_money ( test_ptx . fee ) < <
" fee and " < < print_money ( test_ptx . change_dts . amount ) < < " change " ) ;
} ;
@ -10637,7 +10529,6 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_all(uint64_t below
const bool use_rct = use_fork_rules ( 4 , 0 ) ;
// determine threshold for fractional amount
const bool use_per_byte_fee = use_fork_rules ( HF_VERSION_PER_BYTE_FEE , 0 ) ;
const bool bulletproof = use_fork_rules ( get_bulletproof_fork ( ) , 0 ) ;
const bool bulletproof_plus = use_fork_rules ( get_bulletproof_plus_fork ( ) , 0 ) ;
const bool clsag = use_fork_rules ( get_clsag_fork ( ) , 0 ) ;
@ -10647,7 +10538,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_all(uint64_t below
const size_t tx_weight_two_rings = estimate_tx_weight ( use_rct , 2 , fake_outs_count , 2 , 0 , bulletproof , clsag , bulletproof_plus , use_view_tags ) ;
THROW_WALLET_EXCEPTION_IF ( tx_weight_one_ring > tx_weight_two_rings , error : : wallet_internal_error , " Estimated tx weight with 1 input is larger than with 2 inputs! " ) ;
const size_t tx_weight_per_ring = tx_weight_two_rings - tx_weight_one_ring ;
const uint64_t fractional_threshold = ( base_fee * tx_weight_per_ring ) / ( use_per_byte_fee ? 1 : 1024 ) ;
const uint64_t fractional_threshold = base_fee * tx_weight_per_ring ;
std : : unordered_set < crypto : : public_key > valid_public_keys_cache ;
THROW_WALLET_EXCEPTION_IF ( unlocked_balance ( subaddr_account , false ) = = 0 , error : : wallet_internal_error , " No unlocked balance in the specified account " ) ;
@ -10749,7 +10640,6 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_from(const crypton
uint64_t upper_transaction_weight_limit = get_upper_transaction_weight_limit ( ) ;
std : : vector < std : : vector < get_outs_entry > > outs ;
const bool use_per_byte_fee = use_fork_rules ( HF_VERSION_PER_BYTE_FEE ) ;
const bool use_rct = fake_outs_count > 0 & & use_fork_rules ( 4 , 0 ) ;
const bool bulletproof = use_fork_rules ( get_bulletproof_fork ( ) , 0 ) ;
const bool bulletproof_plus = use_fork_rules ( get_bulletproof_plus_fork ( ) , 0 ) ;
@ -10783,15 +10673,8 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_from(const crypton
// dust and non dust to ensure we never get with only dust, from which we might
// get a tx that can't pay for itself
uint64_t fee_dust_threshold ;
if ( use_fork_rules ( HF_VERSION_PER_BYTE_FEE ) )
{
const uint64_t estimated_tx_weight_with_one_extra_output = estimate_tx_weight ( use_rct , tx . selected_transfers . size ( ) + 1 , fake_outs_count , tx . dsts . size ( ) + 1 , extra . size ( ) , bulletproof , clsag , bulletproof_plus , use_view_tags ) ;
fee_dust_threshold = calculate_fee_from_weight ( base_fee , estimated_tx_weight_with_one_extra_output , fee_quantization_mask ) ;
}
else
{
fee_dust_threshold = base_fee * ( upper_transaction_weight_limit + 1023 ) / 1024 ;
}
const uint64_t estimated_tx_weight_with_one_extra_output = estimate_tx_weight ( use_rct , tx . selected_transfers . size ( ) + 1 , fake_outs_count , tx . dsts . size ( ) + 1 , extra . size ( ) , bulletproof , clsag , bulletproof_plus , use_view_tags ) ;
fee_dust_threshold = calculate_fee_from_weight ( base_fee , estimated_tx_weight_with_one_extra_output , fee_quantization_mask ) ;
size_t idx =
unused_transfers_indices . empty ( )
@ -10824,7 +10707,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_from(const crypton
pending_tx test_ptx ;
const size_t num_outputs = get_num_outputs ( tx . dsts , m_transfers , tx . selected_transfers ) ;
needed_fee = estimate_fee ( use_ per_byte_fee, use_ rct, tx . selected_transfers . size ( ) , fake_outs_count , num_outputs , extra . size ( ) , bulletproof , clsag , bulletproof_plus , use_view_tags , base_fee , fee_quantization_mask ) ;
needed_fee = estimate_fee ( use_ rct, tx . selected_transfers . size ( ) , fake_outs_count , num_outputs , extra . size ( ) , bulletproof , clsag , bulletproof_plus , use_view_tags , base_fee , fee_quantization_mask ) ;
// add N - 1 outputs for correct initial fee estimation
for ( size_t i = 0 ; i < ( ( outputs > 1 ) ? outputs - 1 : outputs ) ; + + i )
@ -10839,7 +10722,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_from(const crypton
transfer_selected ( tx . dsts , tx . selected_transfers , fake_outs_count , outs , valid_public_keys_cache , unlock_time , needed_fee , extra ,
detail : : digit_split_strategy , tx_dust_policy ( : : config : : DEFAULT_DUST_THRESHOLD ) , test_tx , test_ptx , use_view_tags ) ;
auto txBlob = t_serializable_object_to_blob ( test_ptx . tx ) ;
needed_fee = calculate_fee ( use_per_byte_fee, test_ptx. tx , txBlob . size ( ) , base_fee , fee_quantization_mask ) ;
needed_fee = calculate_fee ( test_ptx. tx , txBlob . size ( ) , base_fee , fee_quantization_mask ) ;
available_for_fee = test_ptx . fee + test_ptx . change_dts . amount ;
for ( auto & dt : test_ptx . dests )
available_for_fee + = dt . amount ;
@ -10876,7 +10759,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_from(const crypton
transfer_selected ( tx . dsts , tx . selected_transfers , fake_outs_count , outs , valid_public_keys_cache , unlock_time , needed_fee , extra ,
detail : : digit_split_strategy , tx_dust_policy ( : : config : : DEFAULT_DUST_THRESHOLD ) , test_tx , test_ptx , use_view_tags ) ;
txBlob = t_serializable_object_to_blob ( test_ptx . tx ) ;
needed_fee = calculate_fee ( use_per_byte_fee, test_ptx. tx , txBlob . size ( ) , base_fee , fee_quantization_mask ) ;
needed_fee = calculate_fee ( test_ptx. tx , txBlob . size ( ) , base_fee , fee_quantization_mask ) ;
LOG_PRINT_L2 ( " Made an attempt at a final " < < get_weight_string ( test_ptx . tx , txBlob . size ( ) ) < < " tx, with " < < print_money ( test_ptx . fee ) < <
" fee and " < < print_money ( test_ptx . change_dts . amount ) < < " change " ) ;
} while ( needed_fee > test_ptx . fee ) ;
@ -11065,11 +10948,8 @@ uint64_t wallet2::get_upper_transaction_weight_limit()
{
if ( m_upper_transaction_weight_limit > 0 )
return m_upper_transaction_weight_limit ;
uint64_t full_reward_zone = use_fork_rules ( 5 , 10 ) ? CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5 : use_fork_rules ( 2 , 10 ) ? CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 : CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 ;
if ( use_fork_rules ( 8 , 10 ) )
return full_reward_zone / 2 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE ;
else
return full_reward_zone - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE ;
uint64_t full_reward_zone = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5 ;
return full_reward_zone / 2 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE ;
}
//----------------------------------------------------------------------------------------------------
std : : vector < size_t > wallet2 : : select_available_outputs ( const std : : function < bool ( const transfer_details & td ) > & f )
@ -14265,23 +14145,6 @@ std::vector<std::pair<uint64_t, uint64_t>> wallet2::estimate_backlog(const std::
return blocks ;
}
//----------------------------------------------------------------------------------------------------
std : : vector < std : : pair < uint64_t , uint64_t > > wallet2 : : estimate_backlog ( uint64_t min_tx_weight , uint64_t max_tx_weight , const std : : vector < uint64_t > & fees )
{
THROW_WALLET_EXCEPTION_IF ( min_tx_weight = = 0 , error : : wallet_internal_error , " Invalid 0 fee " ) ;
THROW_WALLET_EXCEPTION_IF ( max_tx_weight = = 0 , error : : wallet_internal_error , " Invalid 0 fee " ) ;
for ( uint64_t fee : fees )
{
THROW_WALLET_EXCEPTION_IF ( fee = = 0 , error : : wallet_internal_error , " Invalid 0 fee " ) ;
}
std : : vector < std : : pair < double , double > > fee_levels ;
for ( uint64_t fee : fees )
{
double our_fee_byte_min = fee / ( double ) min_tx_weight , our_fee_byte_max = fee / ( double ) max_tx_weight ;
fee_levels . emplace_back ( our_fee_byte_min , our_fee_byte_max ) ;
}
return estimate_backlog ( fee_levels ) ;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2 : : get_segregation_fork_height ( ) const
{
if ( m_nettype = = TESTNET )