2018-04-10 09:57:57 +02:00
// Copyright (c) 2014-2018, The Monero Project
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
# pragma once
# include <vector>
# include <iostream>
# include <stdint.h>
# include <boost/archive/binary_oarchive.hpp>
# include <boost/archive/binary_iarchive.hpp>
# include <boost/program_options.hpp>
2018-11-20 14:40:51 +01:00
# include <boost/optional.hpp>
2018-04-10 09:57:57 +02:00
# include <boost/serialization/vector.hpp>
# include <boost/serialization/variant.hpp>
2018-11-20 14:40:51 +01:00
# include <boost/serialization/optional.hpp>
2018-04-10 09:57:57 +02:00
# include "include_base_utils.h"
# include "common/boost_serialization_helper.h"
# include "common/command_line.h"
# include "cryptonote_basic/account_boost_serialization.h"
# include "cryptonote_basic/cryptonote_basic.h"
# include "cryptonote_basic/cryptonote_basic_impl.h"
# include "cryptonote_basic/cryptonote_format_utils.h"
# include "cryptonote_core/cryptonote_core.h"
# include "cryptonote_basic/cryptonote_boost_serialization.h"
# include "misc_language.h"
2019-09-02 12:18:54 +02:00
# include "blockchain_db/testdb.h"
2019-01-17 05:14:42 +01:00
# undef LOKI_DEFAULT_LOG_CATEGORY
# define LOKI_DEFAULT_LOG_CATEGORY "tests.core"
2018-04-10 09:57:57 +02:00
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
# define TESTS_DEFAULT_FEE ((uint64_t)200000000) // 2 * pow(10, 8)
2019-09-02 12:18:54 +02:00
# define TEST_DEFAULT_DIFFICULTY 1
2018-04-10 09:57:57 +02:00
2019-08-23 02:32:34 +02:00
# define DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN DIFFICULTY_TARGET_V2
2019-10-10 02:56:10 +02:00
# if defined(__GNUG__) && !defined(__clang__) && __GNUC__ < 6
namespace service_nodes {
const std : : vector < payout_entry > dummy ; // help GCC 5 realize it needs to generate a default constructor
}
# endif
2019-09-02 12:18:54 +02:00
struct loki_block_with_checkpoint
{
cryptonote : : block block ;
bool has_checkpoint ;
cryptonote : : checkpoint_t checkpoint ;
} ;
2019-09-11 08:04:58 +02:00
struct loki_transaction
{
cryptonote : : transaction tx ;
bool kept_by_block ;
} ;
2019-09-02 12:18:54 +02:00
// TODO(loki): Deperecate other methods of doing polymorphism for items to be
// added to test_event_entry. Right now, adding a block and checking for
// failure requires you to add a member field to mark the event index that
// should of failed, and you must add a member function that checks at run-time
// if at the marked index the block failed or not.
// Doing this way lets you write the failure case inline to when you create the
// test_event_entry, which means less book-keeping and boilerplate code of
// tracking event indexes and making member functions to detect the failure cases.
template < typename T >
struct loki_blockchain_addable
{
loki_blockchain_addable ( ) = default ;
loki_blockchain_addable ( T const & data , bool can_be_added_to_blockchain = true , std : : string const & fail_msg = { } )
: data ( data )
, can_be_added_to_blockchain ( can_be_added_to_blockchain )
, fail_msg ( fail_msg )
{
}
T data ;
bool can_be_added_to_blockchain ;
std : : string fail_msg ;
private : // TODO(doyle): Not implemented properly. Just copy pasta. Do we even need serialization?
friend class boost : : serialization : : access ;
template < class Archive > void serialize ( Archive & /*ar*/ , const unsigned int /*version*/ ) { }
} ;
typedef boost : : function < bool ( cryptonote : : core & c , size_t ev_index ) > loki_callback ;
struct loki_callback_entry
{
std : : string name ;
loki_callback callback ;
private : // TODO(doyle): Not implemented properly. Just copy pasta. Do we even need serialization?
friend class boost : : serialization : : access ;
template < class Archive >
void serialize ( Archive & ar , const unsigned int /*version*/ ) { ar & name ; }
} ;
//
// NOTE: Monero
//
2018-04-10 09:57:57 +02:00
struct callback_entry
{
std : : string callback_name ;
BEGIN_SERIALIZE_OBJECT ( )
FIELD ( callback_name )
END_SERIALIZE ( )
private :
friend class boost : : serialization : : access ;
template < class Archive >
void serialize ( Archive & ar , const unsigned int /*version*/ )
{
ar & callback_name ;
}
} ;
template < typename T >
struct serialized_object
{
serialized_object ( ) { }
serialized_object ( const cryptonote : : blobdata & a_data )
: data ( a_data )
{
}
cryptonote : : blobdata data ;
BEGIN_SERIALIZE_OBJECT ( )
FIELD ( data )
END_SERIALIZE ( )
private :
friend class boost : : serialization : : access ;
template < class Archive >
void serialize ( Archive & ar , const unsigned int /*version*/ )
{
ar & data ;
}
} ;
typedef serialized_object < cryptonote : : block > serialized_block ;
typedef serialized_object < cryptonote : : transaction > serialized_transaction ;
struct event_visitor_settings
{
int valid_mask ;
bool txs_keeped_by_block ;
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
crypto : : secret_key service_node_key ;
2018-04-10 09:57:57 +02:00
enum settings
{
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
set_txs_keeped_by_block = 1 < < 0 ,
2018-04-10 09:57:57 +02:00
} ;
event_visitor_settings ( int a_valid_mask = 0 , bool a_txs_keeped_by_block = false )
: valid_mask ( a_valid_mask )
, txs_keeped_by_block ( a_txs_keeped_by_block )
{
}
private :
friend class boost : : serialization : : access ;
template < class Archive >
void serialize ( Archive & ar , const unsigned int /*version*/ )
{
ar & valid_mask ;
ar & txs_keeped_by_block ;
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
ar & service_node_key ;
2018-04-10 09:57:57 +02:00
}
} ;
2018-11-20 14:40:51 +01:00
typedef std : : vector < std : : pair < uint8_t , uint64_t > > v_hardforks_t ;
struct event_replay_settings
{
event_replay_settings ( ) = default ;
2019-09-02 12:18:54 +02:00
boost : : optional < v_hardforks_t > hard_forks ;
2018-11-20 14:40:51 +01:00
private :
friend class boost : : serialization : : access ;
template < class Archive >
void serialize ( Archive & ar , const unsigned int /*version*/ )
{
ar & hard_forks ;
}
} ;
2018-04-10 09:57:57 +02:00
VARIANT_TAG ( binary_archive , callback_entry , 0xcb ) ;
VARIANT_TAG ( binary_archive , cryptonote : : account_base , 0xcc ) ;
VARIANT_TAG ( binary_archive , serialized_block , 0xcd ) ;
VARIANT_TAG ( binary_archive , serialized_transaction , 0xce ) ;
VARIANT_TAG ( binary_archive , event_visitor_settings , 0xcf ) ;
2018-11-20 14:40:51 +01:00
VARIANT_TAG ( binary_archive , event_replay_settings , 0xda ) ;
2018-04-10 09:57:57 +02:00
2019-09-02 12:18:54 +02:00
typedef boost : : variant < cryptonote : : block ,
cryptonote : : transaction ,
std : : vector < cryptonote : : transaction > ,
cryptonote : : account_base ,
callback_entry ,
serialized_block ,
serialized_transaction ,
event_visitor_settings ,
event_replay_settings ,
loki_callback_entry ,
loki_blockchain_addable < loki_block_with_checkpoint > ,
2019-09-11 08:04:58 +02:00
loki_blockchain_addable < cryptonote : : block > ,
loki_blockchain_addable < loki_transaction > ,
2019-09-02 12:18:54 +02:00
loki_blockchain_addable < service_nodes : : quorum_vote_t > ,
loki_blockchain_addable < cryptonote : : checkpoint_t >
> test_event_entry ;
2018-04-10 09:57:57 +02:00
typedef std : : unordered_map < crypto : : hash , const cryptonote : : transaction * > map_hash2tx_t ;
class test_chain_unit_base
{
public :
typedef boost : : function < bool ( cryptonote : : core & c , size_t ev_index , const std : : vector < test_event_entry > & events ) > verify_callback ;
typedef std : : map < std : : string , verify_callback > callbacks_map ;
void register_callback ( const std : : string & cb_name , verify_callback cb ) ;
bool verify ( const std : : string & cb_name , cryptonote : : core & c , size_t ev_index , const std : : vector < test_event_entry > & events ) ;
2019-05-01 08:01:17 +02:00
bool check_block_verification_context ( const cryptonote : : block_verification_context & bvc , size_t event_idx , const cryptonote : : block & /*blk*/ ) ;
bool check_tx_verification_context ( const cryptonote : : tx_verification_context & tvc , bool /*tx_added*/ , size_t /*event_index*/ , const cryptonote : : transaction & /*tx*/ ) ;
bool check_tx_verification_context_array ( const std : : vector < cryptonote : : tx_verification_context > & tvcs , size_t /*tx_added*/ , size_t /*event_index*/ , const std : : vector < cryptonote : : transaction > & /*txs*/ ) ;
2019-09-02 12:18:54 +02:00
bool was_vote_meant_to_be_successfully_added ( size_t event_index , bool vote_was_added ) { ( void ) event_index ; return vote_was_added ; }
2019-05-01 08:01:17 +02:00
2018-04-10 09:57:57 +02:00
private :
callbacks_map m_callbacks ;
} ;
class test_generator
{
public :
struct block_info
{
2014-03-03 23:07:58 +01:00
block_info ( )
: prev_id ( )
, already_generated_coins ( 0 )
2018-07-18 23:24:53 +02:00
, block_weight ( 0 )
2014-03-03 23:07:58 +01:00
{
}
2018-11-12 04:02:21 +01:00
block_info ( crypto : : hash a_prev_id , uint64_t an_already_generated_coins , size_t a_block_weight , cryptonote : : block a_block )
2018-04-10 09:57:57 +02:00
: prev_id ( a_prev_id )
, already_generated_coins ( an_already_generated_coins )
2018-07-18 23:24:53 +02:00
, block_weight ( a_block_weight )
2018-11-12 04:02:21 +01:00
, block ( a_block )
2018-04-10 09:57:57 +02:00
{
}
crypto : : hash prev_id ;
uint64_t already_generated_coins ;
2018-07-18 23:24:53 +02:00
size_t block_weight ;
2018-11-12 04:02:21 +01:00
cryptonote : : block block ;
2018-11-20 14:40:51 +01:00
private :
friend class boost : : serialization : : access ;
template < class Archive >
void serialize ( Archive & ar , const unsigned int /*version*/ )
{
ar & prev_id ;
ar & already_generated_coins ;
ar & block_weight ;
2019-04-12 06:17:05 +02:00
ar & block ;
2018-11-20 14:40:51 +01:00
}
2018-04-10 09:57:57 +02:00
} ;
enum block_fields
{
bf_none = 0 ,
bf_major_ver = 1 < < 0 ,
bf_minor_ver = 1 < < 1 ,
bf_timestamp = 1 < < 2 ,
bf_prev_id = 1 < < 3 ,
bf_miner_tx = 1 < < 4 ,
bf_tx_hashes = 1 < < 5 ,
bf_diffic = 1 < < 6 ,
bf_hf_version = 1 < < 8
} ;
2019-04-12 06:17:05 +02:00
explicit test_generator ( int hf_version = 7 ) : m_hf_version ( hf_version ) { }
2018-11-12 04:02:21 +01:00
void get_block_chain ( std : : vector < block_info > & blockchain , const crypto : : hash & head , size_t n ) const ;
void get_block_chain ( std : : vector < cryptonote : : block > & blockchain , const crypto : : hash & head , size_t n ) const ;
2019-02-25 08:33:06 +01:00
void get_last_n_block_weights ( std : : vector < uint64_t > & block_weights , const crypto : : hash & head , size_t n ) const ;
2018-04-10 09:57:57 +02:00
uint64_t get_already_generated_coins ( const crypto : : hash & blk_id ) const ;
uint64_t get_already_generated_coins ( const cryptonote : : block & blk ) const ;
2019-03-04 03:50:08 +01:00
void add_block ( const cryptonote : : block & blk , size_t tsx_size , std : : vector < uint64_t > & block_weights , uint64_t already_generated_coins ) ;
2018-04-10 09:57:57 +02:00
bool construct_block ( cryptonote : : block & blk , uint64_t height , const crypto : : hash & prev_id ,
const cryptonote : : account_base & miner_acc , uint64_t timestamp , uint64_t already_generated_coins ,
2019-09-02 12:18:54 +02:00
std : : vector < uint64_t > & block_weights , const std : : list < cryptonote : : transaction > & tx_list , const service_nodes : : block_winner & winner = { } ) ;
2018-04-10 09:57:57 +02:00
bool construct_block ( cryptonote : : block & blk , const cryptonote : : account_base & miner_acc , uint64_t timestamp ) ;
bool construct_block ( cryptonote : : block & blk , const cryptonote : : block & blk_prev , const cryptonote : : account_base & miner_acc ,
2019-09-02 12:18:54 +02:00
const std : : list < cryptonote : : transaction > & tx_list = std : : list < cryptonote : : transaction > ( ) , const service_nodes : : block_winner & winner = { } ) ;
2018-04-10 09:57:57 +02:00
bool construct_block_manually ( cryptonote : : block & blk , const cryptonote : : block & prev_block ,
const cryptonote : : account_base & miner_acc , int actual_params = bf_none , uint8_t major_ver = 0 ,
uint8_t minor_ver = 0 , uint64_t timestamp = 0 , const crypto : : hash & prev_id = crypto : : hash ( ) ,
const cryptonote : : difficulty_type & diffic = 1 , const cryptonote : : transaction & miner_tx = cryptonote : : transaction ( ) ,
2018-08-18 14:21:42 +02:00
const std : : vector < crypto : : hash > & tx_hashes = std : : vector < crypto : : hash > ( ) , size_t txs_sizes = 0 ) ;
2018-04-10 09:57:57 +02:00
bool construct_block_manually_tx ( cryptonote : : block & blk , const cryptonote : : block & prev_block ,
const cryptonote : : account_base & miner_acc , const std : : vector < crypto : : hash > & tx_hashes , size_t txs_size ) ;
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
2018-11-12 04:02:21 +01:00
int m_hf_version ;
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
2018-04-10 09:57:57 +02:00
private :
std : : unordered_map < crypto : : hash , block_info > m_blocks_info ;
2018-11-20 14:40:51 +01:00
friend class boost : : serialization : : access ;
template < class Archive >
void serialize ( Archive & ar , const unsigned int /*version*/ )
{
ar & m_blocks_info ;
}
2018-04-10 09:57:57 +02:00
} ;
2018-11-20 14:40:51 +01:00
template < typename T >
std : : string dump_keys ( T * buff32 )
{
std : : ostringstream ss ;
char buff [ 10 ] ;
ss < < " [ " ;
for ( int i = 0 ; i < 32 ; i + + )
{
snprintf ( buff , 10 , " 0x%02x " , ( ( uint8_t ) buff32 [ i ] & 0xff ) ) ;
ss < < buff ;
if ( i < 31 )
ss < < " , " ;
}
ss < < " ] " ;
return ss . str ( ) ;
}
struct output_index {
2019-04-12 06:17:05 +02:00
cryptonote : : txout_target_v out ;
2018-11-20 14:40:51 +01:00
uint64_t amount ;
size_t blk_height ; // block height
size_t tx_no ; // index of transaction in block
size_t out_no ; // index of out in transaction
size_t idx ;
uint64_t unlock_time ;
bool is_coin_base ;
2019-04-12 06:17:05 +02:00
bool deterministic_key_pair ;
2018-11-20 14:40:51 +01:00
bool spent ;
bool rct ;
rct : : key comm ;
2019-04-12 06:17:05 +02:00
rct : : key mask ; // TODO(loki): I dont know if this is still meant to be here. Monero removed and replaced with commitment, whereas we use the mask in our tests?
cryptonote : : block const * p_blk ;
cryptonote : : transaction const * p_tx ;
2018-11-20 14:40:51 +01:00
2019-04-12 06:17:05 +02:00
output_index ( ) = default ;
2018-11-20 14:40:51 +01:00
output_index ( const cryptonote : : txout_target_v & _out , uint64_t _a , size_t _h , size_t tno , size_t ono , const cryptonote : : block * _pb , const cryptonote : : transaction * _pt )
{
2019-04-12 06:17:05 +02:00
* this = { } ;
out = _out ;
amount = _a ;
blk_height = _h ;
tx_no = tno ;
out_no = ono ;
p_blk = _pb ;
p_tx = _pt ;
2018-11-20 14:40:51 +01:00
}
2019-04-12 06:17:05 +02:00
#if 0
2018-11-20 14:40:51 +01:00
output_index ( const output_index & other )
: out ( other . out ) , amount ( other . amount ) , blk_height ( other . blk_height ) , tx_no ( other . tx_no ) , rct ( other . rct ) ,
out_no ( other . out_no ) , idx ( other . idx ) , unlock_time ( other . unlock_time ) , is_coin_base ( other . is_coin_base ) ,
spent ( other . spent ) , comm ( other . comm ) , p_blk ( other . p_blk ) , p_tx ( other . p_tx ) { }
2019-04-12 06:17:05 +02:00
# endif
2018-11-20 14:40:51 +01:00
void set_rct ( bool arct ) {
rct = arct ;
if ( rct & & p_tx - > rct_signatures . outPk . size ( ) > out_no )
comm = p_tx - > rct_signatures . outPk [ out_no ] . mask ;
else
comm = rct : : commit ( amount , rct : : identity ( ) ) ;
}
rct : : key commitment ( ) const {
return comm ;
}
const std : : string toString ( ) const {
std : : stringstream ss ;
ss < < " output_index{blk_height= " < < blk_height
< < " tx_no= " < < tx_no
< < " out_no= " < < out_no
< < " amount= " < < amount
< < " idx= " < < idx
< < " unlock_time= " < < unlock_time
< < " spent= " < < spent
< < " is_coin_base= " < < is_coin_base
< < " rct= " < < rct
< < " comm= " < < dump_keys ( comm . bytes )
< < " } " ;
return ss . str ( ) ;
}
2019-08-23 02:54:21 +02:00
output_index ( const output_index & ) = default ;
2018-11-20 14:40:51 +01:00
output_index & operator = ( const output_index & other )
{
new ( this ) output_index ( other ) ;
return * this ;
}
} ;
typedef std : : tuple < uint64_t , crypto : : public_key , rct : : key > get_outs_entry ;
typedef std : : pair < crypto : : hash , size_t > output_hasher ;
typedef boost : : hash < output_hasher > output_hasher_hasher ;
typedef std : : map < uint64_t , std : : vector < size_t > > map_output_t ;
typedef std : : map < uint64_t , std : : vector < output_index > > map_output_idx_t ;
typedef std : : unordered_map < crypto : : hash , cryptonote : : block > map_block_t ;
typedef std : : unordered_map < output_hasher , output_index , output_hasher_hasher > map_txid_output_t ;
typedef std : : unordered_map < crypto : : public_key , cryptonote : : subaddress_index > subaddresses_t ;
typedef std : : pair < uint64_t , size_t > outloc_t ;
typedef boost : : variant < cryptonote : : account_public_address , cryptonote : : account_keys , cryptonote : : account_base , cryptonote : : tx_destination_entry > var_addr_t ;
2019-09-02 12:18:54 +02:00
cryptonote : : account_public_address get_address ( const var_addr_t & inp ) ;
2018-11-20 14:40:51 +01:00
typedef struct {
const var_addr_t addr ;
bool is_subaddr ;
uint64_t amount ;
} dest_wrapper_t ;
// Daemon functionality
class block_tracker
{
public :
map_output_idx_t m_outs ;
map_txid_output_t m_map_outs ; // mapping (txid, out) -> output_index
map_block_t m_blocks ;
block_tracker ( ) = default ;
block_tracker ( const block_tracker & bt ) : m_outs ( bt . m_outs ) , m_map_outs ( bt . m_map_outs ) , m_blocks ( bt . m_blocks ) { } ;
map_txid_output_t : : iterator find_out ( const crypto : : hash & txid , size_t out ) ;
map_txid_output_t : : iterator find_out ( const output_hasher & id ) ;
void process ( const std : : vector < cryptonote : : block > & blockchain , const map_hash2tx_t & mtx ) ;
void process ( const std : : vector < const cryptonote : : block * > & blockchain , const map_hash2tx_t & mtx ) ;
void process ( const cryptonote : : block * blk , const cryptonote : : transaction * tx , size_t i ) ;
void global_indices ( const cryptonote : : transaction * tx , std : : vector < uint64_t > & indices ) ;
void get_fake_outs ( size_t num_outs , uint64_t amount , uint64_t global_index , uint64_t cur_height , std : : vector < get_outs_entry > & outs ) ;
std : : string dump_data ( ) ;
void dump_data ( const std : : string & fname ) ;
private :
friend class boost : : serialization : : access ;
template < class Archive >
void serialize ( Archive & ar , const unsigned int /*version*/ )
{
ar & m_outs ;
ar & m_map_outs ;
ar & m_blocks ;
}
} ;
std : : string dump_data ( const cryptonote : : transaction & tx ) ;
2014-03-03 23:07:58 +01:00
2018-11-20 14:40:51 +01:00
cryptonote : : tx_destination_entry build_dst ( const var_addr_t & to , bool is_subaddr = false , uint64_t amount = 0 ) ;
std : : vector < cryptonote : : tx_destination_entry > build_dsts ( const var_addr_t & to1 , bool sub1 = false , uint64_t am1 = 0 ) ;
std : : vector < cryptonote : : tx_destination_entry > build_dsts ( std : : initializer_list < dest_wrapper_t > inps ) ;
uint64_t sum_amount ( const std : : vector < cryptonote : : tx_destination_entry > & destinations ) ;
uint64_t sum_amount ( const std : : vector < cryptonote : : tx_source_entry > & sources ) ;
2014-03-03 23:07:58 +01:00
bool construct_tx_to_key ( const std : : vector < test_event_entry > & events , cryptonote : : transaction & tx ,
2018-11-20 14:40:51 +01:00
const cryptonote : : block & blk_head , const cryptonote : : account_base & from , const var_addr_t & to , uint64_t amount ,
2019-04-12 06:17:05 +02:00
uint64_t fee , size_t nmix , rct : : RangeProofType range_proof_type = rct : : RangeProofBorromean , int bp_version = 0 ) ;
2018-11-20 14:40:51 +01:00
bool construct_tx_to_key ( const std : : vector < test_event_entry > & events , cryptonote : : transaction & tx , const cryptonote : : block & blk_head ,
const cryptonote : : account_base & from , std : : vector < cryptonote : : tx_destination_entry > destinations ,
2019-04-12 06:17:05 +02:00
uint64_t fee , size_t nmix , rct : : RangeProofType range_proof_type = rct : : RangeProofBorromean , int bp_version = 0 ) ;
2018-11-20 14:40:51 +01:00
bool construct_tx_to_key ( cryptonote : : transaction & tx , const cryptonote : : account_base & from , const var_addr_t & to , uint64_t amount ,
std : : vector < cryptonote : : tx_source_entry > & sources ,
2019-04-12 06:17:05 +02:00
uint64_t fee , rct : : RangeProofType range_proof_type = rct : : RangeProofBorromean , int bp_version = 0 ) ;
2018-11-20 14:40:51 +01:00
bool construct_tx_to_key ( cryptonote : : transaction & tx , const cryptonote : : account_base & from , const std : : vector < cryptonote : : tx_destination_entry > & destinations ,
std : : vector < cryptonote : : tx_source_entry > & sources ,
2019-04-12 06:17:05 +02:00
uint64_t fee , rct : : RangeProofType range_proof_type , int bp_version = 0 ) ;
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
2018-04-10 09:57:57 +02:00
cryptonote : : transaction construct_tx_with_fee ( std : : vector < test_event_entry > & events , const cryptonote : : block & blk_head ,
const cryptonote : : account_base & acc_from , const cryptonote : : account_base & acc_to ,
uint64_t amount , uint64_t fee ) ;
2018-11-20 14:40:51 +01:00
bool construct_tx_rct ( const cryptonote : : account_keys & sender_account_keys ,
std : : vector < cryptonote : : tx_source_entry > & sources ,
const std : : vector < cryptonote : : tx_destination_entry > & destinations ,
2019-04-12 06:17:05 +02:00
const boost : : optional < cryptonote : : tx_destination_entry > & change_addr ,
2018-11-20 14:40:51 +01:00
std : : vector < uint8_t > extra , cryptonote : : transaction & tx , uint64_t unlock_time ,
2019-04-12 06:17:05 +02:00
rct : : RangeProofType range_proof_type = rct : : RangeProofBorromean , int bp_version = 0 ) ;
2018-11-20 14:40:51 +01:00
uint64_t num_blocks ( const std : : vector < test_event_entry > & events ) ;
cryptonote : : block get_head_block ( const std : : vector < test_event_entry > & events ) ;
2018-04-10 09:57:57 +02:00
void get_confirmed_txs ( const std : : vector < cryptonote : : block > & blockchain , const map_hash2tx_t & mtx , map_hash2tx_t & confirmed_txs ) ;
2018-11-20 14:40:51 +01:00
bool trim_block_chain ( std : : vector < cryptonote : : block > & blockchain , const crypto : : hash & tail ) ;
bool trim_block_chain ( std : : vector < const cryptonote : : block * > & blockchain , const crypto : : hash & tail ) ;
2018-04-10 09:57:57 +02:00
bool find_block_chain ( const std : : vector < test_event_entry > & events , std : : vector < cryptonote : : block > & blockchain , map_hash2tx_t & mtx , const crypto : : hash & head ) ;
2018-10-08 04:34:36 +02:00
2019-04-12 06:17:05 +02:00
void fill_tx_sources_and_multi_destinations ( const std : : vector < test_event_entry > & events ,
const cryptonote : : block & blk_head ,
const cryptonote : : account_base & from ,
const cryptonote : : account_public_address & to ,
uint64_t const * amount ,
int num_amounts ,
uint64_t fee ,
size_t nmix ,
2018-10-08 04:34:36 +02:00
std : : vector < cryptonote : : tx_source_entry > & sources ,
2019-04-12 06:17:05 +02:00
std : : vector < cryptonote : : tx_destination_entry > & destinations ,
bool always_add_change_output = false ,
uint64_t * change_amount = nullptr ) ;
2018-11-20 14:40:51 +01:00
bool find_block_chain ( const std : : vector < test_event_entry > & events , std : : vector < const cryptonote : : block * > & blockchain , map_hash2tx_t & mtx , const crypto : : hash & head ) ;
void fill_tx_destinations ( const var_addr_t & from , const cryptonote : : account_public_address & to ,
uint64_t amount , uint64_t fee ,
const std : : vector < cryptonote : : tx_source_entry > & sources ,
std : : vector < cryptonote : : tx_destination_entry > & destinations , bool always_change = false ) ;
void fill_tx_destinations ( const var_addr_t & from , const std : : vector < cryptonote : : tx_destination_entry > & dests ,
uint64_t fee ,
const std : : vector < cryptonote : : tx_source_entry > & sources ,
std : : vector < cryptonote : : tx_destination_entry > & destinations ,
bool always_change ) ;
void fill_tx_destinations ( const var_addr_t & from , const cryptonote : : account_public_address & to ,
uint64_t amount , uint64_t fee ,
const std : : vector < cryptonote : : tx_source_entry > & sources ,
std : : vector < cryptonote : : tx_destination_entry > & destinations ,
std : : vector < cryptonote : : tx_destination_entry > & destinations_pure ,
bool always_change = false ) ;
2018-10-08 04:34:36 +02:00
2018-04-10 09:57:57 +02:00
void fill_tx_sources_and_destinations ( const std : : vector < test_event_entry > & events , const cryptonote : : block & blk_head ,
2018-11-20 14:40:51 +01:00
const cryptonote : : account_base & from , const cryptonote : : account_public_address & to ,
2018-04-10 09:57:57 +02:00
uint64_t amount , uint64_t fee , size_t nmix ,
std : : vector < cryptonote : : tx_source_entry > & sources ,
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
std : : vector < cryptonote : : tx_destination_entry > & destinations , uint64_t * change_amount = nullptr ) ;
/// Get the amount transferred to `account` in `tx` as output `i`
uint64_t get_amount ( const cryptonote : : account_base & account , const cryptonote : : transaction & tx , int i ) ;
2018-11-20 14:40:51 +01:00
2018-04-10 09:57:57 +02:00
uint64_t get_balance ( const cryptonote : : account_base & addr , const std : : vector < cryptonote : : block > & blockchain , const map_hash2tx_t & mtx ) ;
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
uint64_t get_unlocked_balance ( const cryptonote : : account_base & addr , const std : : vector < cryptonote : : block > & blockchain , const map_hash2tx_t & mtx ) ;
2018-04-10 09:57:57 +02:00
2018-11-20 14:40:51 +01:00
bool extract_hard_forks ( const std : : vector < test_event_entry > & events , v_hardforks_t & hard_forks ) ;
2018-04-10 09:57:57 +02:00
/************************************************************************/
/* */
/************************************************************************/
template < class t_test_class >
struct push_core_event_visitor : public boost : : static_visitor < bool >
{
private :
cryptonote : : core & m_c ;
const std : : vector < test_event_entry > & m_events ;
t_test_class & m_validator ;
size_t m_ev_index ;
bool m_txs_keeped_by_block ;
public :
push_core_event_visitor ( cryptonote : : core & c , const std : : vector < test_event_entry > & events , t_test_class & validator )
: m_c ( c )
, m_events ( events )
, m_validator ( validator )
, m_ev_index ( 0 )
, m_txs_keeped_by_block ( false )
{
}
void event_index ( size_t ev_index )
{
m_ev_index = ev_index ;
}
2018-11-20 14:40:51 +01:00
bool operator ( ) ( const event_replay_settings & settings )
{
log_event ( " event_replay_settings " ) ;
return true ;
}
2018-04-10 09:57:57 +02:00
bool operator ( ) ( const event_visitor_settings & settings )
{
log_event ( " event_visitor_settings " ) ;
if ( settings . valid_mask & event_visitor_settings : : set_txs_keeped_by_block )
{
m_txs_keeped_by_block = settings . txs_keeped_by_block ;
}
return true ;
}
bool operator ( ) ( const cryptonote : : transaction & tx ) const
{
log_event ( " cryptonote::transaction " ) ;
2019-10-31 23:26:58 +01:00
cryptonote : : tx_verification_context tvc { } ;
2019-11-06 07:14:06 +01:00
size_t pool_size = m_c . get_pool ( ) . get_transactions_count ( ) ;
2018-04-10 09:57:57 +02:00
m_c . handle_incoming_tx ( t_serializable_object_to_blob ( tx ) , tvc , m_txs_keeped_by_block , false , false ) ;
2019-11-06 07:14:06 +01:00
bool tx_added = pool_size + 1 = = m_c . get_pool ( ) . get_transactions_count ( ) ;
2019-05-01 08:01:17 +02:00
bool r = m_validator . check_tx_verification_context ( tvc , tx_added , m_ev_index , tx ) ;
2018-04-10 09:57:57 +02:00
CHECK_AND_NO_ASSERT_MES ( r , false , " tx verification context check failed " ) ;
return true ;
}
2018-03-30 21:29:42 +02:00
bool operator ( ) ( const std : : vector < cryptonote : : transaction > & txs ) const
{
log_event ( " cryptonote::transaction " ) ;
std : : vector < cryptonote : : blobdata > tx_blobs ;
std : : vector < cryptonote : : tx_verification_context > tvcs ;
2019-10-31 23:26:58 +01:00
cryptonote : : tx_verification_context tvc0 { } ;
2018-03-30 21:29:42 +02:00
for ( const auto & tx : txs )
{
tx_blobs . push_back ( t_serializable_object_to_blob ( tx ) ) ;
tvcs . push_back ( tvc0 ) ;
}
2019-11-06 07:14:06 +01:00
size_t pool_size = m_c . get_pool ( ) . get_transactions_count ( ) ;
2018-03-30 21:29:42 +02:00
m_c . handle_incoming_txs ( tx_blobs , tvcs , m_txs_keeped_by_block , false , false ) ;
2019-11-06 07:14:06 +01:00
size_t tx_added = m_c . get_pool ( ) . get_transactions_count ( ) - pool_size ;
2019-05-01 08:01:17 +02:00
bool r = m_validator . check_tx_verification_context_array ( tvcs , tx_added , m_ev_index , txs ) ;
2018-03-30 21:29:42 +02:00
CHECK_AND_NO_ASSERT_MES ( r , false , " tx verification context check failed " ) ;
return true ;
}
2018-04-10 09:57:57 +02:00
bool operator ( ) ( const cryptonote : : block & b ) const
{
log_event ( " cryptonote::block " ) ;
2019-10-31 23:26:58 +01:00
cryptonote : : block_verification_context bvc { } ;
2019-04-05 11:28:30 +02:00
cryptonote : : blobdata bd = t_serializable_object_to_blob ( b ) ;
std : : vector < cryptonote : : block > pblocks ;
2019-06-26 06:00:05 +02:00
if ( m_c . prepare_handle_incoming_blocks ( std : : vector < cryptonote : : block_complete_entry > ( 1 , { bd , { } , { } } ) , pblocks ) )
2019-04-05 11:28:30 +02:00
{
2019-06-26 06:00:05 +02:00
m_c . handle_incoming_block ( bd , & b , bvc , nullptr ) ;
2019-04-05 11:28:30 +02:00
m_c . cleanup_handle_incoming_blocks ( ) ;
}
else
bvc . m_verifivation_failed = true ;
2019-05-01 08:01:17 +02:00
bool r = m_validator . check_block_verification_context ( bvc , m_ev_index , b ) ;
2018-04-10 09:57:57 +02:00
CHECK_AND_NO_ASSERT_MES ( r , false , " block verification context check failed " ) ;
return r ;
}
2019-09-02 12:18:54 +02:00
// TODO(loki): Deprecate callback_entry for loki_callback_entry, why don't you
// just include the callback routine in the callback entry instead of going
// down into the validator and then have to do a string->callback (map) lookup
// for the callback?
2018-04-10 09:57:57 +02:00
bool operator ( ) ( const callback_entry & cb ) const
{
log_event ( std : : string ( " callback_entry " ) + cb . callback_name ) ;
return m_validator . verify ( cb . callback_name , m_c , m_ev_index , m_events ) ;
}
bool operator ( ) ( const cryptonote : : account_base & ab ) const
{
log_event ( " cryptonote::account_base " ) ;
return true ;
}
bool operator ( ) ( const serialized_block & sr_block ) const
{
log_event ( " serialized_block " ) ;
2019-10-31 23:26:58 +01:00
cryptonote : : block_verification_context bvc { } ;
2019-04-05 11:28:30 +02:00
std : : vector < cryptonote : : block > pblocks ;
2019-06-26 06:00:05 +02:00
if ( m_c . prepare_handle_incoming_blocks ( std : : vector < cryptonote : : block_complete_entry > ( 1 , { sr_block . data , { } , { } } ) , pblocks ) )
2019-04-05 11:28:30 +02:00
{
2019-06-26 06:00:05 +02:00
m_c . handle_incoming_block ( sr_block . data , NULL , bvc , nullptr ) ;
2019-04-05 11:28:30 +02:00
m_c . cleanup_handle_incoming_blocks ( ) ;
}
else
bvc . m_verifivation_failed = true ;
2018-04-10 09:57:57 +02:00
cryptonote : : block blk ;
std : : stringstream ss ;
ss < < sr_block . data ;
binary_archive < false > ba ( ss ) ;
: : serialization : : serialize ( ba , blk ) ;
if ( ! ss . good ( ) )
{
blk = cryptonote : : block ( ) ;
}
2019-05-01 08:01:17 +02:00
bool r = m_validator . check_block_verification_context ( bvc , m_ev_index , blk ) ;
CHECK_AND_NO_ASSERT_MES ( r , false , " block verification context check failed " ) ;
2018-04-10 09:57:57 +02:00
return true ;
}
bool operator ( ) ( const serialized_transaction & sr_tx ) const
{
log_event ( " serialized_transaction " ) ;
2019-10-31 23:26:58 +01:00
cryptonote : : tx_verification_context tvc { } ;
2019-11-06 07:14:06 +01:00
size_t pool_size = m_c . get_pool ( ) . get_transactions_count ( ) ;
2018-04-10 09:57:57 +02:00
m_c . handle_incoming_tx ( sr_tx . data , tvc , m_txs_keeped_by_block , false , false ) ;
2019-11-06 07:14:06 +01:00
bool tx_added = pool_size + 1 = = m_c . get_pool ( ) . get_transactions_count ( ) ;
2018-04-10 09:57:57 +02:00
cryptonote : : transaction tx ;
std : : stringstream ss ;
ss < < sr_tx . data ;
binary_archive < false > ba ( ss ) ;
: : serialization : : serialize ( ba , tx ) ;
if ( ! ss . good ( ) )
{
tx = cryptonote : : transaction ( ) ;
}
2019-05-01 08:01:17 +02:00
bool r = m_validator . check_tx_verification_context ( tvc , tx_added , m_ev_index , tx ) ;
2018-04-10 09:57:57 +02:00
CHECK_AND_NO_ASSERT_MES ( r , false , " transaction verification context check failed " ) ;
return true ;
}
2019-09-02 12:18:54 +02:00
//
// NOTE: Loki
//
bool operator ( ) ( const loki_blockchain_addable < cryptonote : : checkpoint_t > & entry ) const
{
log_event ( " loki_blockchain_addable<cryptonote::checkpoint_t> " ) ;
cryptonote : : Blockchain & blockchain = m_c . get_blockchain_storage ( ) ;
bool added = blockchain . update_checkpoint ( entry . data ) ;
2019-10-04 07:01:03 +02:00
CHECK_AND_NO_ASSERT_MES ( added = = entry . can_be_added_to_blockchain , false , ( entry . fail_msg . size ( ) ? entry . fail_msg : " Failed to add checkpoint (no reason given) " ) ) ;
2019-09-02 12:18:54 +02:00
return true ;
}
bool operator ( ) ( const loki_blockchain_addable < service_nodes : : quorum_vote_t > & entry ) const
{
log_event ( " loki_blockchain_addable<service_nodes::quorum_vote_t> " ) ;
cryptonote : : vote_verification_context vvc = { } ;
bool added = m_c . add_service_node_vote ( entry . data , vvc ) ;
2019-10-04 07:01:03 +02:00
CHECK_AND_NO_ASSERT_MES ( added = = entry . can_be_added_to_blockchain , false , ( entry . fail_msg . size ( ) ? entry . fail_msg : " Failed to add service node vote (no reason given) " ) ) ;
2019-09-02 12:18:54 +02:00
return true ;
}
bool operator ( ) ( const loki_blockchain_addable < loki_block_with_checkpoint > & entry ) const
{
log_event ( " loki_blockchain_addable<loki_block_with_checkpoint> " ) ;
cryptonote : : block const & block = entry . data . block ;
// TODO(loki): Need to make a copy because we still need modify checkpoints
// in handle_incoming_blocks but that is because of temporary forking code
cryptonote : : checkpoint_t checkpoint_copy = entry . data . checkpoint ;
cryptonote : : block_verification_context bvc = { } ;
cryptonote : : blobdata bd = t_serializable_object_to_blob ( block ) ;
std : : vector < cryptonote : : block > pblocks ;
if ( m_c . prepare_handle_incoming_blocks ( std : : vector < cryptonote : : block_complete_entry > ( 1 , { bd , { } , { } } ) , pblocks ) )
{
2019-09-11 08:04:58 +02:00
m_c . handle_incoming_block ( bd , & block , bvc , & checkpoint_copy ) ;
2019-09-02 12:18:54 +02:00
m_c . cleanup_handle_incoming_blocks ( ) ;
}
else
bvc . m_verifivation_failed = true ;
bool added = ! bvc . m_verifivation_failed ;
2019-10-04 07:01:03 +02:00
CHECK_AND_NO_ASSERT_MES ( added = = entry . can_be_added_to_blockchain , false , ( entry . fail_msg . size ( ) ? entry . fail_msg : " Failed to add block with checkpoint (no reason given) " ) ) ;
2019-09-02 12:18:54 +02:00
return true ;
}
2019-09-11 08:04:58 +02:00
bool operator ( ) ( const loki_blockchain_addable < cryptonote : : block > & entry ) const
{
log_event ( " loki_blockchain_addable<cryptonote::block> " ) ;
cryptonote : : block const & block = entry . data ;
2019-09-02 12:18:54 +02:00
2019-09-11 08:04:58 +02:00
cryptonote : : block_verification_context bvc = { } ;
cryptonote : : blobdata bd = t_serializable_object_to_blob ( block ) ;
std : : vector < cryptonote : : block > pblocks ;
if ( m_c . prepare_handle_incoming_blocks ( std : : vector < cryptonote : : block_complete_entry > ( 1 , { bd , { } , { } } ) , pblocks ) )
{
m_c . handle_incoming_block ( bd , & block , bvc , nullptr ) ;
m_c . cleanup_handle_incoming_blocks ( ) ;
}
else
bvc . m_verifivation_failed = true ;
bool added = ! bvc . m_verifivation_failed ;
2019-10-04 07:01:03 +02:00
CHECK_AND_NO_ASSERT_MES ( added = = entry . can_be_added_to_blockchain , false , ( entry . fail_msg . size ( ) ? entry . fail_msg : " Failed to add block (no reason given) " ) ) ;
2019-09-11 08:04:58 +02:00
return true ;
}
bool operator ( ) ( const loki_blockchain_addable < loki_transaction > & entry ) const
2019-09-02 12:18:54 +02:00
{
2019-09-11 08:04:58 +02:00
log_event ( " loki_blockchain_addable<loki_transaction> " ) ;
2019-09-02 12:18:54 +02:00
cryptonote : : tx_verification_context tvc = { } ;
2019-11-06 07:14:06 +01:00
size_t pool_size = m_c . get_pool ( ) . get_transactions_count ( ) ;
2019-09-11 08:04:58 +02:00
m_c . handle_incoming_tx ( t_serializable_object_to_blob ( entry . data . tx ) , tvc , entry . data . kept_by_block , false , false ) ;
2019-09-02 12:18:54 +02:00
2019-11-06 07:14:06 +01:00
bool added = ( pool_size + 1 ) = = m_c . get_pool ( ) . get_transactions_count ( ) ;
2019-10-04 07:01:03 +02:00
CHECK_AND_NO_ASSERT_MES ( added = = entry . can_be_added_to_blockchain , false , ( entry . fail_msg . size ( ) ? entry . fail_msg : " Failed to add transaction (no reason given) " ) ) ;
2019-09-02 12:18:54 +02:00
return true ;
}
bool operator ( ) ( const loki_callback_entry & entry ) const
{
log_event ( std : : string ( " loki_callback_entry " ) + entry . name ) ;
bool result = entry . callback ( m_c , m_ev_index ) ;
return result ;
}
2018-04-10 09:57:57 +02:00
private :
void log_event ( const std : : string & event_type ) const
{
MGINFO_YELLOW ( " === EVENT # " < < m_ev_index < < " : " < < event_type ) ;
}
} ;
//--------------------------------------------------------------------------
template < class t_test_class >
2018-11-20 14:40:51 +01:00
inline bool replay_events_through_core_plain ( cryptonote : : core & cr , const std : : vector < test_event_entry > & events , t_test_class & validator , bool reinit = true )
2018-04-10 09:57:57 +02:00
{
TRY_ENTRY ( ) ;
2019-09-02 12:18:54 +02:00
// start with a clean pool
std : : vector < crypto : : hash > pool_txs ;
2019-11-06 07:14:06 +01:00
cr . get_pool ( ) . get_transaction_hashes ( pool_txs ) ;
2019-09-02 12:18:54 +02:00
cr . get_blockchain_storage ( ) . flush_txes_from_pool ( pool_txs ) ;
2018-04-10 09:57:57 +02:00
//init core here
2018-11-20 14:40:51 +01:00
if ( reinit ) {
CHECK_AND_ASSERT_MES ( typeid ( cryptonote : : block ) = = events [ 0 ] . type ( ) , false ,
" First event must be genesis block creation " ) ;
cr . set_genesis_block ( boost : : get < cryptonote : : block > ( events [ 0 ] ) ) ;
}
2018-04-10 09:57:57 +02:00
bool r = true ;
push_core_event_visitor < t_test_class > visitor ( cr , events , validator ) ;
for ( size_t i = 1 ; i < events . size ( ) & & r ; + + i )
{
visitor . event_index ( i ) ;
r = boost : : apply_visitor ( visitor , events [ i ] ) ;
}
return r ;
CATCH_ENTRY_L0 ( " replay_events_through_core " , false ) ;
}
//--------------------------------------------------------------------------
template < typename t_test_class >
struct get_test_options {
2018-10-10 04:02:22 +02:00
const std : : vector < std : : pair < uint8_t , uint64_t > > hard_forks = { { 7 , 0 } } ;
2018-04-10 09:57:57 +02:00
const cryptonote : : test_options test_options = {
2019-04-07 18:15:20 +02:00
hard_forks , 0
2018-04-10 09:57:57 +02:00
} ;
} ;
//--------------------------------------------------------------------------
template < class t_test_class >
2019-09-02 12:18:54 +02:00
inline bool do_replay_events_get_core ( std : : vector < test_event_entry > & events , cryptonote : : core * core , t_test_class & validator )
2018-04-10 09:57:57 +02:00
{
boost : : program_options : : options_description desc ( " Allowed options " ) ;
cryptonote : : core : : init_options ( desc ) ;
boost : : program_options : : variables_map vm ;
bool r = command_line : : handle_error_helper ( desc , [ & ] ( )
{
boost : : program_options : : store ( boost : : program_options : : basic_parsed_options < char > ( & desc ) , vm ) ;
boost : : program_options : : notify ( vm ) ;
return true ;
} ) ;
if ( ! r )
return false ;
2019-02-27 16:55:31 +01:00
auto & c = * core ;
2018-11-20 14:40:51 +01:00
2019-09-02 12:18:54 +02:00
// TODO(loki): Deprecate having to specify hardforks in a templated struct. This
// puts an unecessary level of indirection that makes it hard to follow the
// code. Hardforks should just be declared next to the testing code in the
// generate function. Inlining code and localizing declarations so that we read
// as much as possible top-to-bottom in linear sequences makes things easier to
// follow
// But changing this now means that all the other tests would break.
2018-04-10 09:57:57 +02:00
get_test_options < t_test_class > gto ;
2018-11-20 14:40:51 +01:00
2019-09-02 12:18:54 +02:00
// TODO(loki): Hard forks should always be specified in events OR do replay
// events should be passed a testing context which should have this specific
// testing situation
2018-11-20 14:40:51 +01:00
// Hardforks can be specified in events.
2019-04-12 06:17:05 +02:00
v_hardforks_t derived_hardforks ;
bool use_derived_hardforks = extract_hard_forks ( events , derived_hardforks ) ;
const cryptonote : : test_options derived_test_options =
{
derived_hardforks ,
gto . test_options . long_term_block_weight_window ,
} ;
2018-11-20 14:40:51 +01:00
2019-09-02 12:18:54 +02:00
// FIXME: make sure that vm has arg_testnet_on set to true or false if
// this test needs for it to be so.
2019-04-12 06:17:05 +02:00
cryptonote : : test_options const * testing_options = ( use_derived_hardforks ) ? & derived_test_options : & gto . test_options ;
if ( ! c . init ( vm , testing_options ) )
2018-04-10 09:57:57 +02:00
{
MERROR ( " Failed to init core " ) ;
return false ;
}
c . get_blockchain_storage ( ) . get_db ( ) . set_batch_transactions ( true ) ;
2019-09-02 12:18:54 +02:00
bool ret = replay_events_through_core_plain < t_test_class > ( c , events , validator , true ) ;
2018-04-10 09:57:57 +02:00
return ret ;
}
//--------------------------------------------------------------------------
template < class t_test_class >
inline bool do_replay_file ( const std : : string & filename )
{
std : : vector < test_event_entry > events ;
if ( ! tools : : unserialize_obj_from_file ( events , filename ) )
{
MERROR ( " Failed to deserialize data from file: " ) ;
return false ;
}
2019-09-02 12:18:54 +02:00
cryptonote : : core core ( nullptr ) ;
t_test_class validator ;
bool result = do_replay_events_get_core < t_test_class > ( events , & core , validator ) ;
core . deinit ( ) ;
return result ;
2018-04-10 09:57:57 +02:00
}
2018-07-17 11:44:46 +02:00
2018-04-10 09:57:57 +02:00
//--------------------------------------------------------------------------
2018-11-20 14:40:51 +01:00
# define DEFAULT_HARDFORKS(HARDFORKS) do { \
HARDFORKS . push_back ( std : : make_pair ( ( uint8_t ) 1 , ( uint64_t ) 0 ) ) ; \
} while ( 0 )
# define ADD_HARDFORK(HARDFORKS, FORK, HEIGHT) HARDFORKS.push_back(std::make_pair((uint8_t)FORK, (uint64_t)HEIGHT))
2018-04-10 09:57:57 +02:00
# define GENERATE_ACCOUNT(account) \
cryptonote : : account_base account ; \
account . generate ( ) ;
# define GENERATE_MULTISIG_ACCOUNT(account, threshold, total) \
CHECK_AND_ASSERT_MES ( threshold > = 2 & & threshold < = total , false , " Invalid multisig scheme " ) ; \
std : : vector < cryptonote : : account_base > account ( total ) ; \
do \
{ \
for ( size_t msidx = 0 ; msidx < total ; + + msidx ) \
account [ msidx ] . generate ( ) ; \
2018-07-17 11:44:46 +02:00
make_multisig_accounts ( account , threshold ) ; \
2018-04-10 09:57:57 +02:00
} while ( 0 )
# define MAKE_ACCOUNT(VEC_EVENTS, account) \
cryptonote : : account_base account ; \
account . generate ( ) ; \
VEC_EVENTS . push_back ( account ) ;
# define DO_CALLBACK(VEC_EVENTS, CB_NAME) \
{ \
callback_entry CALLBACK_ENTRY ; \
CALLBACK_ENTRY . callback_name = CB_NAME ; \
VEC_EVENTS . push_back ( CALLBACK_ENTRY ) ; \
}
# define REGISTER_CALLBACK(CB_NAME, CLBACK) \
register_callback ( CB_NAME , boost : : bind ( & CLBACK , this , _1 , _2 , _3 ) ) ;
# define REGISTER_CALLBACK_METHOD(CLASS, METHOD) \
register_callback ( # METHOD , boost : : bind ( & CLASS : : METHOD , this , _1 , _2 , _3 ) ) ;
# define MAKE_GENESIS_BLOCK(VEC_EVENTS, BLK_NAME, MINER_ACC, TS) \
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
test_generator generator ; \
cryptonote : : block BLK_NAME ; \
generator . construct_block ( BLK_NAME , MINER_ACC , TS ) ; \
VEC_EVENTS . push_back ( BLK_NAME ) ;
/// TODO: use hf_ver from test options
# define MAKE_GENESIS_BLOCK_WITH_HF_VERSION(VEC_EVENTS, BLK_NAME, MINER_ACC, TS, HF_VER) \
test_generator generator ( HF_VER ) ; \
2018-04-10 09:57:57 +02:00
cryptonote : : block BLK_NAME ; \
generator . construct_block ( BLK_NAME , MINER_ACC , TS ) ; \
VEC_EVENTS . push_back ( BLK_NAME ) ;
# define MAKE_NEXT_BLOCK(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC) \
cryptonote : : block BLK_NAME ; \
generator . construct_block ( BLK_NAME , PREV_BLOCK , MINER_ACC ) ; \
VEC_EVENTS . push_back ( BLK_NAME ) ;
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
# define MAKE_NEXT_BLOCK_V2(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, WINNER, SN_INFO) \
cryptonote : : block BLK_NAME ; \
generator . construct_block ( BLK_NAME , PREV_BLOCK , MINER_ACC , { } , WINNER , SN_INFO ) ; \
VEC_EVENTS . push_back ( BLK_NAME ) ;
2018-04-10 09:57:57 +02:00
# define MAKE_NEXT_BLOCK_TX1(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, TX1) \
cryptonote : : block BLK_NAME ; \
{ \
std : : list < cryptonote : : transaction > tx_list ; \
tx_list . push_back ( TX1 ) ; \
generator . construct_block ( BLK_NAME , PREV_BLOCK , MINER_ACC , tx_list ) ; \
} \
VEC_EVENTS . push_back ( BLK_NAME ) ;
# define MAKE_NEXT_BLOCK_TX_LIST(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, TXLIST) \
cryptonote : : block BLK_NAME ; \
generator . construct_block ( BLK_NAME , PREV_BLOCK , MINER_ACC , TXLIST ) ; \
VEC_EVENTS . push_back ( BLK_NAME ) ;
2019-04-12 06:17:05 +02:00
# define REWIND_BLOCKS_N(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, COUNT) \
2018-11-20 14:40:51 +01:00
cryptonote : : block BLK_NAME ; \
2018-04-10 09:57:57 +02:00
{ \
2018-11-20 14:40:51 +01:00
cryptonote : : block blk_last = PREV_BLOCK ; \
2018-04-10 09:57:57 +02:00
for ( size_t i = 0 ; i < COUNT ; + + i ) \
{ \
2019-04-12 06:17:05 +02:00
MAKE_NEXT_BLOCK ( VEC_EVENTS , blk , blk_last , MINER_ACC ) ; \
2018-04-10 09:57:57 +02:00
blk_last = blk ; \
} \
BLK_NAME = blk_last ; \
}
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
# define REWIND_BLOCKS_N_V2(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, COUNT, WINNER, SN_INFO) \
cryptonote : : block BLK_NAME ; \
{ \
cryptonote : : block blk_last = PREV_BLOCK ; \
for ( size_t i = 0 ; i < COUNT ; + + i ) \
{ \
MAKE_NEXT_BLOCK_V2 ( VEC_EVENTS , blk , blk_last , MINER_ACC , WINNER , SN_INFO ) ; \
blk_last = blk ; \
} \
BLK_NAME = blk_last ; \
}
2018-04-10 09:57:57 +02:00
# define REWIND_BLOCKS(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC) REWIND_BLOCKS_N(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW)
2018-11-21 06:30:16 +01:00
// NOTE(loki): These macros assume hardfork version 7 and are from the old Monero testing code
2018-04-10 09:57:57 +02:00
# define MAKE_TX_MIX(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, NMIX, HEAD) \
2018-10-15 03:23:28 +02:00
cryptonote : : transaction TX_NAME ; \
2019-09-02 12:18:54 +02:00
loki_tx_builder ( VEC_EVENTS , TX_NAME , HEAD , FROM , TO , AMOUNT , cryptonote : : network_version_7 ) . build ( ) ; \
2018-04-10 09:57:57 +02:00
VEC_EVENTS . push_back ( TX_NAME ) ;
2018-11-20 14:40:51 +01:00
# define MAKE_TX_MIX_RCT(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, NMIX, HEAD) \
cryptonote : : transaction TX_NAME ; \
2019-04-12 06:17:05 +02:00
construct_tx_to_key ( VEC_EVENTS , TX_NAME , HEAD , FROM , TO , AMOUNT , TESTS_DEFAULT_FEE , NMIX , rct : : RangeProofPaddedBulletproof ) ; \
2018-11-20 14:40:51 +01:00
VEC_EVENTS . push_back ( TX_NAME ) ;
2018-08-10 06:15:47 +02:00
# define MAKE_TX(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, HEAD) MAKE_TX_MIX(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, 9, HEAD)
2018-04-10 09:57:57 +02:00
# define MAKE_TX_MIX_LIST(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, NMIX, HEAD) \
{ \
cryptonote : : transaction t ; \
2019-09-02 12:18:54 +02:00
loki_tx_builder ( VEC_EVENTS , t , HEAD , FROM , TO , AMOUNT , cryptonote : : network_version_7 ) . build ( ) ; \
2018-04-10 09:57:57 +02:00
SET_NAME . push_back ( t ) ; \
VEC_EVENTS . push_back ( t ) ; \
}
2018-08-21 11:06:38 +02:00
2018-11-20 14:40:51 +01:00
# define MAKE_TX_MIX_LIST_RCT(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, NMIX, HEAD) \
MAKE_TX_MIX_LIST_RCT_EX ( VEC_EVENTS , SET_NAME , FROM , TO , AMOUNT , NMIX , HEAD , rct : : RangeProofPaddedBulletproof , 1 )
# define MAKE_TX_MIX_LIST_RCT_EX(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, NMIX, HEAD, RCT_TYPE, BP_VER) \
{ \
cryptonote : : transaction t ; \
2019-04-12 06:17:05 +02:00
construct_tx_to_key ( VEC_EVENTS , t , HEAD , FROM , TO , AMOUNT , TESTS_DEFAULT_FEE , NMIX , RCT_TYPE , BP_VER ) ; \
2018-11-20 14:40:51 +01:00
SET_NAME . push_back ( t ) ; \
VEC_EVENTS . push_back ( t ) ; \
}
# define MAKE_TX_MIX_DEST_LIST_RCT(VEC_EVENTS, SET_NAME, FROM, TO, NMIX, HEAD) \
MAKE_TX_MIX_DEST_LIST_RCT_EX ( VEC_EVENTS , SET_NAME , FROM , TO , NMIX , HEAD , rct : : RangeProofPaddedBulletproof , 1 )
# define MAKE_TX_MIX_DEST_LIST_RCT_EX(VEC_EVENTS, SET_NAME, FROM, TO, NMIX, HEAD, RCT_TYPE, BP_VER) \
{ \
cryptonote : : transaction t ; \
2019-04-12 06:17:05 +02:00
construct_tx_to_key ( VEC_EVENTS , t , HEAD , FROM , TO , TESTS_DEFAULT_FEE , NMIX , RCT_TYPE , BP_VER ) ; \
2018-11-20 14:40:51 +01:00
SET_NAME . push_back ( t ) ; \
VEC_EVENTS . push_back ( t ) ; \
}
2019-04-12 06:17:05 +02:00
# define MAKE_TX_LIST(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD) MAKE_TX_MIX_LIST(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, 9, HEAD)
2018-04-10 09:57:57 +02:00
# define MAKE_TX_LIST_START(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD) \
std : : list < cryptonote : : transaction > SET_NAME ; \
MAKE_TX_LIST ( VEC_EVENTS , SET_NAME , FROM , TO , AMOUNT , HEAD ) ;
Version 0.4.0 Release Candidate (#216)
* core: submit uptime proof immediately after registering
* Increase visibility of autostaking prompts
* quorum_cop: changed uptime proof prune timeout to 2 hours 10 minutes
* cleanup: removed scope limiting block
* check_tx_inputs: fix deregister double spend test to include deregisters from other heights
* config: new testnet network id, genesis tx, and version bump
* wallet2: fix testnet wallet blockheight approximation
* Fix change in address format in RPC which broke parsing and pooling contributors (#184)
* Fix service node endpoints for RPC to also use stdout (#185)
* fixed some further rct core tests (#180)
* Fix service node state by calling detached hooks on failure to switch to alt chain (#188)
* fixed block verification core tests (#186)
* fixed block verification core tests
* core tests: removed gen_block_miner_tx_out_is_small which is only relevant to hardfork version 1
* Don't consider expired deregistrations when filling block template
* Add unit tests for getting staking requirement (#191)
* First service node test (#190)
* core_tests: added service node tests
* core_tests: check balance after registration tx
* Fix underflow for popping rollback events (#189)
* Move deregistration age check into check_tx_inputs
* Zero initialise rct_signatures member txnFee is a uint64_t and has uninit values
* Enforce that deregisters must be 0 fee since we skip checks
* Add unit tests for vote validation (#193)
* Add unit tests for deregistration validation (#194)
* Mainnet checkpoint 86535, testnet 3591, 4166
* Bump version number
* Add print_sr for getting staking requirement (#198)
* Misc bugfixes (#203)
* removed unnecessary cast to double during txfee+coinbase calculation
* simplewallet: increased autostaking interval from 2 minutes to 40
* Fix casting issues from uint to int (#204)
* core_tests: check service node registration and expiration (#195)
* core_tests: check service node registration and deregistration
* core_tests for service nodes:
- include service nodes rewards when calculating account's balance
- check that service nodes rewards have been received
* fixed namespace error; reduced the scope of staking requirement constants
* On blockchain inc/dec mark deregisters relayble based on age (#201)
* Service nodes restore only 1 rollback bug (#206)
* Fix restore 1 rollback event, ensure prevent rollback is always added
* Remove adding prevent_rollback event at init
It gets called in on block added generic anyway.
* Log db exception, fix relation operators for vote/deregister lifetime (#207)
* Filter relayable deregisters w/ check_tx_inputs instead of blockchain callbacks
* Bump version to 0.3.7-beta
* fix build with GCC 8.1.0 (#211)
* Add temp hardfork rule in testnet for deregister lifetimes (#210)
* Update testnet, remove testnet forks, remove checkpoints, update blockheight estimate (#212)
* Don't ban peers for a bad vote, just drop their connection (#213)
* Update to version 0.3.0 release candidate (#215)
2018-09-07 07:14:28 +02:00
# define MAKE_MINER_TX_MANUALLY(TX, BLK) \
transaction TX ; \
if ( ! construct_miner_tx ( get_block_height ( BLK ) + 1 , 0 , generator . get_already_generated_coins ( BLK ) , \
0 , 0 , miner_account . get_keys ( ) . m_account_address , TX , { } , 7 ) ) \
2019-04-12 06:17:05 +02:00
return false ; \
2018-11-20 14:40:51 +01:00
# define MAKE_TX_LIST_START_RCT(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, NMIX, HEAD) \
std : : list < cryptonote : : transaction > SET_NAME ; \
MAKE_TX_MIX_LIST_RCT ( VEC_EVENTS , SET_NAME , FROM , TO , AMOUNT , NMIX , HEAD ) ;
2018-04-10 09:57:57 +02:00
# define SET_EVENT_VISITOR_SETT(VEC_EVENTS, SETT, VAL) VEC_EVENTS.push_back(event_visitor_settings(SETT, VAL));
2019-09-02 12:18:54 +02:00
# define GENERATE(filename, generator_class) \
2018-04-10 09:57:57 +02:00
{ \
std : : vector < test_event_entry > events ; \
2019-09-02 12:18:54 +02:00
generator_class g ; \
2018-04-10 09:57:57 +02:00
g . generate ( events ) ; \
if ( ! tools : : serialize_obj_to_file ( events , filename ) ) \
{ \
MERROR ( " Failed to serialize data to file: " < < filename ) ; \
throw std : : runtime_error ( " Failed to serialize data to file " ) ; \
} \
}
2019-09-02 12:18:54 +02:00
# define PLAY(filename, generator_class) \
if ( ! do_replay_file < generator_class > ( filename ) ) \
2018-04-10 09:57:57 +02:00
{ \
2019-09-02 12:18:54 +02:00
MERROR ( " Failed to pass test : " < < # generator_class ) ; \
2018-04-10 09:57:57 +02:00
return 1 ; \
}
2019-09-02 12:18:54 +02:00
# define CATCH_REPLAY(generator_class) \
catch ( const std : : exception & ex ) { MERROR ( # generator_class < < " generation failed: what= " < < ex . what ( ) ) ; } \
catch ( . . . ) { MERROR ( # generator_class < < " generation failed: generic exception " ) ; }
# define REPLAY_CORE(generator_class, generator_class_instance) \
{ \
cryptonote : : core core ( nullptr ) ; \
if ( generated & & do_replay_events_get_core < generator_class > ( events , & core , generator_class_instance ) ) \
{ \
MGINFO_GREEN ( " #TEST# Succeeded " < < # generator_class ) ; \
} \
else \
{ \
MERROR ( " #TEST# Failed " < < # generator_class ) ; \
failed_tests . push_back ( # generator_class ) ; \
} \
core . deinit ( ) ; \
}
2018-11-20 14:40:51 +01:00
2019-09-02 12:18:54 +02:00
# define REPLAY_WITH_CORE(generator_class, generator_class_instance, CORE) \
{ \
if ( generated & & \
replay_events_through_core_plain < generator_class > ( events , CORE , generator_class_instance , false /*reinit*/ ) ) \
{ \
MGINFO_GREEN ( " #TEST# Succeeded " < < # generator_class ) ; \
} \
else \
{ \
MERROR ( " #TEST# Failed " < < # generator_class ) ; \
failed_tests . push_back ( # generator_class ) ; \
} \
}
2018-11-20 14:40:51 +01:00
2019-09-02 12:18:54 +02:00
# define CATCH_GENERATE_REPLAY(generator_class, generator_class_instance) \
CATCH_REPLAY ( generator_class ) ; \
REPLAY_CORE ( generator_class , generator_class_instance ) ;
# define CATCH_GENERATE_REPLAY_CORE(generator_class, generator_class_instance, CORE) \
CATCH_REPLAY ( generator_class ) ; \
REPLAY_WITH_CORE ( generator_class , generator_class_instance , CORE ) ;
# define GENERATE_AND_PLAY(generator_class) \
if ( list_tests ) \
std : : cout < < # generator_class < < std : : endl ; \
else if ( filter . empty ( ) | | boost : : regex_match ( std : : string ( # generator_class ) , match , boost : : regex ( filter ) ) ) \
{ \
std : : vector < test_event_entry > events ; \
+ + tests_count ; \
bool generated = false ; \
generator_class generator_class_instance ; \
try \
{ \
generated = generator_class_instance . generate ( events ) ; \
} \
CATCH_GENERATE_REPLAY ( generator_class , generator_class_instance ) ; \
2018-11-20 14:40:51 +01:00
}
2019-09-02 12:18:54 +02:00
# define GENERATE_AND_PLAY_INSTANCE(generator_class, generator_class_instance, CORE) \
if ( filter . empty ( ) | | boost : : regex_match ( std : : string ( # generator_class ) , match , boost : : regex ( filter ) ) ) \
{ \
std : : vector < test_event_entry > events ; \
+ + tests_count ; \
bool generated = false ; \
try \
{ \
generated = ins . generate ( events ) ; \
} \
CATCH_GENERATE_REPLAY_CORE ( generator_class , generator_class_instance , CORE ) ; \
2018-04-10 09:57:57 +02:00
}
# define CALL_TEST(test_name, function) \
{ \
if ( ! function ( ) ) \
{ \
MERROR ( " #TEST# Failed " < < test_name ) ; \
return 1 ; \
} \
else \
{ \
MGINFO_GREEN ( " #TEST# Succeeded " < < test_name ) ; \
} \
}
# define QUOTEME(x) #x
# define DEFINE_TESTS_ERROR_CONTEXT(text) const char* perr_context = text;
# define CHECK_TEST_CONDITION(cond) CHECK_AND_ASSERT_MES(cond, false, "[" << perr_context << "] failed: \"" << QUOTEME(cond) << "\"")
2019-09-02 12:18:54 +02:00
# define CHECK_TEST_CONDITION_MSG(cond, msg) CHECK_AND_ASSERT_MES(cond, false, "[" << perr_context << "] failed: \"" << QUOTEME(cond) << "\", msg: " << msg)
2018-04-10 09:57:57 +02:00
# define CHECK_EQ(v1, v2) CHECK_AND_ASSERT_MES(v1 == v2, false, "[" << perr_context << "] failed: \"" << QUOTEME(v1) << " == " << QUOTEME(v2) << "\", " << v1 << " != " << v2)
# define CHECK_NOT_EQ(v1, v2) CHECK_AND_ASSERT_MES(!(v1 == v2), false, "[" << perr_context << "] failed: \"" << QUOTEME(v1) << " != " << QUOTEME(v2) << "\", " << v1 << " == " << v2)
# define MK_COINS(amount) (UINT64_C(amount) * COIN)
2019-09-02 12:18:54 +02:00
//
// NOTE: Loki
//
class loki_tx_builder {
/// required fields
const std : : vector < test_event_entry > & m_events ;
const size_t m_hf_version ;
cryptonote : : transaction & m_tx ;
const cryptonote : : block & m_head ;
const cryptonote : : account_base & m_from ;
const cryptonote : : account_base & m_to ;
uint64_t m_amount ;
uint64_t m_fee ;
uint64_t m_unlock_time ;
std : : vector < uint8_t > m_extra ;
/// optional fields
bool m_per_output_unlock = false ;
bool m_is_staking = false ;
/// this makes sure we didn't forget to build it
bool m_finished = false ;
public :
loki_tx_builder ( const std : : vector < test_event_entry > & events ,
cryptonote : : transaction & tx ,
const cryptonote : : block & head ,
const cryptonote : : account_base & from ,
const cryptonote : : account_base & to ,
uint64_t amount ,
uint8_t hf_version )
: m_events ( events )
, m_tx ( tx )
, m_head ( head )
, m_from ( from )
, m_to ( to )
, m_amount ( amount )
, m_hf_version ( hf_version )
, m_fee ( TESTS_DEFAULT_FEE )
, m_unlock_time ( 0 )
{ }
loki_tx_builder & & with_fee ( uint64_t fee ) {
m_fee = fee ;
return std : : move ( * this ) ;
}
loki_tx_builder & & with_extra ( const std : : vector < uint8_t > & extra ) {
m_extra = extra ;
return std : : move ( * this ) ;
}
loki_tx_builder & & is_staking ( bool val ) {
m_is_staking = val ;
return std : : move ( * this ) ;
}
loki_tx_builder & & with_unlock_time ( uint64_t val ) {
m_unlock_time = val ;
return std : : move ( * this ) ;
}
loki_tx_builder & & with_per_output_unlock ( bool val = true ) {
m_per_output_unlock = val ;
return std : : move ( * this ) ;
}
~ loki_tx_builder ( ) {
if ( ! m_finished ) {
std : : cerr < < " Tx building not finished \n " ;
abort ( ) ;
}
}
bool build ( )
{
m_finished = true ;
std : : vector < cryptonote : : tx_source_entry > sources ;
std : : vector < cryptonote : : tx_destination_entry > destinations ;
uint64_t change_amount ;
// TODO(loki): Eww we still depend on monero land test code
const auto nmix = 9 ;
fill_tx_sources_and_destinations (
m_events , m_head , m_from , m_to . get_keys ( ) . m_account_address , m_amount , m_fee , nmix , sources , destinations , & change_amount ) ;
cryptonote : : tx_destination_entry change_addr { change_amount , m_from . get_keys ( ) . m_account_address , false /*is_subaddr*/ } ;
bool result = cryptonote : : construct_tx (
m_from . get_keys ( ) , sources , destinations , change_addr , m_extra , m_tx , m_unlock_time , m_hf_version , m_is_staking ) ;
return result ;
}
} ;
struct loki_blockchain_entry
{
cryptonote : : block block ;
std : : vector < cryptonote : : transaction > txs ;
uint64_t block_weight ;
uint64_t already_generated_coins ;
service_nodes : : service_node_list : : state_t service_node_state ;
2019-09-10 09:52:52 +02:00
bool checkpointed ;
2019-09-02 12:18:54 +02:00
cryptonote : : checkpoint_t checkpoint ;
} ;
struct loki_chain_generator_db : public cryptonote : : BaseTestDB
{
std : : vector < loki_blockchain_entry > & blockchain ;
std : : unordered_map < crypto : : hash , cryptonote : : transaction > & tx_table ; // TODO(loki): I want to store pointers to transactions but I get some memory corruption somewhere. Pls fix.
2019-10-04 07:01:03 +02:00
std : : unordered_map < crypto : : hash , loki_blockchain_entry > & block_table ;
2019-09-02 12:18:54 +02:00
loki_chain_generator_db ( std : : vector < loki_blockchain_entry > & blockchain ,
std : : unordered_map < crypto : : hash , cryptonote : : transaction > & tx_table ,
2019-10-04 07:01:03 +02:00
std : : unordered_map < crypto : : hash , loki_blockchain_entry > & block_table )
2019-09-02 12:18:54 +02:00
: blockchain ( blockchain )
, tx_table ( tx_table )
, block_table ( block_table )
{
}
cryptonote : : block get_block_from_height ( const uint64_t & height ) const override ;
bool get_tx ( const crypto : : hash & h , cryptonote : : transaction & tx ) const override ;
} ;
struct loki_chain_generator
{
mutable std : : unordered_map < crypto : : public_key , crypto : : secret_key > service_node_keys_ ;
std : : set < service_nodes : : service_node_list : : state_t > state_history_ ;
2019-10-07 17:16:20 +02:00
service_nodes : : service_node_keys get_cached_keys ( const crypto : : public_key & pubkey ) const ;
2019-09-02 12:18:54 +02:00
// TODO(loki): I want to store pointers to transactions but I get some memory corruption somewhere. Pls fix.
// We already store blockchain_entries in block_ vector which stores the actual backing transaction entries.
std : : unordered_map < crypto : : hash , cryptonote : : transaction > tx_table_ ;
2019-10-04 07:01:03 +02:00
std : : unordered_map < crypto : : hash , loki_blockchain_entry > block_table_ ; // TODO(loki): Hmm takes a copy. But its easier to work this way, particularly for storing alt blocks
2019-09-02 12:18:54 +02:00
std : : vector < loki_blockchain_entry > blocks_ ;
loki_chain_generator_db db_ ;
uint8_t hf_version_ = cryptonote : : network_version_7 ;
std : : vector < test_event_entry > & events_ ;
const std : : vector < std : : pair < uint8_t , uint64_t > > hard_forks_ ;
cryptonote : : account_base first_miner_ ;
loki_chain_generator ( std : : vector < test_event_entry > & events , const std : : vector < std : : pair < uint8_t , uint64_t > > & hard_forks ) ;
uint64_t height ( ) const { return cryptonote : : get_block_height ( blocks_ . back ( ) . block ) ; }
const std : : vector < loki_blockchain_entry > & blocks ( ) const { return blocks_ ; }
size_t event_index ( ) const { return events_ . size ( ) - 1 ; }
const loki_blockchain_entry & top ( ) const { return blocks_ . back ( ) ; }
service_nodes : : quorum_manager top_quorum ( ) const ;
service_nodes : : quorum_manager quorum ( uint64_t height ) const ;
std : : shared_ptr < const service_nodes : : testing_quorum > get_testing_quorum ( service_nodes : : quorum_type type , uint64_t height ) const ;
cryptonote : : account_base add_account ( ) ;
2019-10-04 07:01:03 +02:00
loki_blockchain_entry & add_block ( loki_blockchain_entry const & entry , bool can_be_added_to_blockchain = true , std : : string const & fail_msg = { } ) ;
2019-09-02 12:18:54 +02:00
void add_blocks_until_version ( uint8_t hf_version ) ;
void add_n_blocks ( int n ) ;
void add_blocks_until_next_checkpointable_height ( ) ;
void add_service_node_checkpoint ( uint64_t block_height , size_t num_votes ) ;
void add_mined_money_unlock_blocks ( ) ; // NOTE: Unlock all Loki generated from mining prior to this call i.e. CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW
2019-10-04 07:01:03 +02:00
void add_tx ( cryptonote : : transaction const & tx , bool can_be_added_to_blockchain = true , std : : string const & fail_msg = { } , bool kept_by_block = false ) ;
2019-09-02 12:18:54 +02:00
// NOTE: Add constructed TX to events_ and assume that it is valid to add to the blockchain. If the TX is meant to be unaddable to the blockchain use the individual create + add functions to
// be able to mark the add TX event as something that should trigger a failure.
2019-09-19 10:40:22 +02:00
cryptonote : : transaction create_and_add_tx ( const cryptonote : : account_base & src , const cryptonote : : account_base & dest , uint64_t amount , uint64_t fee = TESTS_DEFAULT_FEE , bool kept_by_block = false ) ;
2019-09-11 08:14:24 +02:00
cryptonote : : transaction create_and_add_state_change_tx ( service_nodes : : new_state state , const crypto : : public_key & pub_key , uint64_t height = - 1 , const std : : vector < uint64_t > & voters = { } , uint64_t fee = 0 , bool kept_by_block = false ) ;
2019-09-11 08:04:58 +02:00
cryptonote : : transaction create_and_add_registration_tx ( const cryptonote : : account_base & src , const cryptonote : : keypair & sn_keys = cryptonote : : keypair : : generate ( hw : : get_device ( " default " ) ) , bool kept_by_block = false ) ;
2019-10-04 07:01:03 +02:00
loki_blockchain_entry & create_and_add_next_block ( const std : : vector < cryptonote : : transaction > & txs = { } , cryptonote : : checkpoint_t const * checkpoint = nullptr , bool can_be_added_to_blockchain = true , std : : string const & fail_msg = { } ) ;
2019-09-02 12:18:54 +02:00
// NOTE: Create transactions but don't add to events_
2019-10-04 07:01:03 +02:00
cryptonote : : transaction create_tx ( const cryptonote : : account_base & src , const cryptonote : : account_base & dest , uint64_t amount , uint64_t fee , bool kept_by_block , bool can_be_added_to_blockchain = true , std : : string const & fail_msg = { } ) const ;
2019-09-02 12:18:54 +02:00
cryptonote : : transaction create_registration_tx ( const cryptonote : : account_base & src , const cryptonote : : keypair & sn_keys = cryptonote : : keypair : : generate ( hw : : get_device ( " default " ) ) ) const ;
2019-09-11 08:14:24 +02:00
cryptonote : : transaction create_state_change_tx ( service_nodes : : new_state state , const crypto : : public_key & pub_key , uint64_t height = - 1 , const std : : vector < uint64_t > & voters = { } , uint64_t fee = 0 ) const ;
2019-09-02 12:18:54 +02:00
cryptonote : : checkpoint_t create_service_node_checkpoint ( uint64_t block_height , size_t num_votes ) const ;
loki_blockchain_entry create_genesis_block ( const cryptonote : : account_base & miner , uint64_t timestamp ) ;
2019-10-30 22:28:47 +01:00
loki_blockchain_entry create_next_block ( const std : : vector < cryptonote : : transaction > & txs = { } , cryptonote : : checkpoint_t const * checkpoint = nullptr , uint64_t total_fee = 0 ) ;
bool create_block ( loki_blockchain_entry & entry , uint8_t hf_version , loki_blockchain_entry const & prev , const cryptonote : : account_base & miner_acc , uint64_t timestamp , std : : vector < uint64_t > & block_weights , const std : : vector < cryptonote : : transaction > & tx_list , const service_nodes : : block_winner & block_winner , uint64_t total_fee = 0 ) const ;
2019-09-02 12:18:54 +02:00
uint8_t get_hf_version_at ( uint64_t height ) const ;
std : : vector < uint64_t > last_n_block_weights ( uint64_t height , uint64_t num ) const ;
const cryptonote : : account_base & first_miner ( ) const { return first_miner_ ; }
} ;