Peerplays_Blockchain/peerplays_migrated
1
0
Fork 0
Code Issues 35 Pull requests 4 Projects Releases 20 Packages Wiki Activity Actions

implementing betting_market_resolve_group_operation (3) #1

Browse source
This commit is contained in:
Roman Olearski 2017-07-04 16:55:34 +02:00
parent 21661eb12c
commit 9b08b502be
15 changed files with 195 additions and 112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
libraries/app/impacted.cpp
View file

@ -209,7 +209,7 @@ struct get_impacted_account_visitor
void operator()( const event_create_operation& op ) {} void operator()( const event_create_operation& op ) {}
void operator()( const betting_market_group_create_operation& op ) {} void operator()( const betting_market_group_create_operation& op ) {}
void operator()( const betting_market_create_operation& op ) {} void operator()( const betting_market_create_operation& op ) {}
void operator()( const betting_market_resolve_operation& op ) {} void operator()( const betting_market_group_resolve_operation& op ) {}
void operator()( const bet_place_operation& op ) void operator()( const bet_place_operation& op )
{ {
_impacted.insert( op.bettor_id ); _impacted.insert( op.bettor_id );
@ -226,7 +226,7 @@ struct get_impacted_account_visitor
{ {
_impacted.insert( op.bettor_id ); _impacted.insert( op.bettor_id );
} }
void operator()( const betting_market_resolved_operation& op ) void operator()( const betting_market_group_resolved_operation& op )
{ {
_impacted.insert( op.bettor_id ); _impacted.insert( op.bettor_id );
} }

10
libraries/chain/betting_market_evaluator.cpp
View file

@ -191,17 +191,19 @@ void_result bet_cancel_evaluator::do_apply(const bet_cancel_operation& op)
return void_result(); return void_result();
} FC_CAPTURE_AND_RETHROW( (op) ) } } FC_CAPTURE_AND_RETHROW( (op) ) }
void_result betting_market_resolve_evaluator::do_evaluate(const betting_market_resolve_operation& op) void_result betting_market_group_resolve_evaluator::do_evaluate(const betting_market_group_resolve_operation& op)
{ try { { try {
const database& d = db(); const database& d = db();
_betting_market = &op.betting_market_id(d); _betting_market_group = &op.betting_market_group_id(d);
db().validate_betting_market_group_resolutions(*_betting_market_group, op.resolutions);
return void_result(); return void_result();
} FC_CAPTURE_AND_RETHROW( (op) ) } } FC_CAPTURE_AND_RETHROW( (op) ) }
void_result betting_market_resolve_evaluator::do_apply(const betting_market_resolve_operation& op) void_result betting_market_group_resolve_evaluator::do_apply(const betting_market_group_resolve_operation& op)
{ try { { try {
db().resolve_betting_market(*_betting_market, op.resolution); db().resolve_betting_market_group(*_betting_market_group, op.resolutions);
return void_result(); return void_result();
} FC_CAPTURE_AND_RETHROW( (op) ) } } FC_CAPTURE_AND_RETHROW( (op) ) }
} } // graphene::chain } } // graphene::chain

130
libraries/chain/db_bet.cpp
View file

@ -44,64 +44,126 @@ void database::cancel_all_betting_markets_for_event(const event_object& event_ob
for (const betting_market_group_object& betting_market_group : for (const betting_market_group_object& betting_market_group :
boost::make_iterator_range(betting_market_group_index.equal_range(event_obj.id))) boost::make_iterator_range(betting_market_group_index.equal_range(event_obj.id)))
{ {
//for each betting market in the betting market group resolve_betting_market_group(betting_market_group, {});
auto betting_market_itr = betting_market_index.lower_bound(betting_market_group.id);
while (betting_market_itr != betting_market_index.end() &&
betting_market_itr->group_id == betting_market_group.id)
{
auto old_betting_market_itr = betting_market_itr;
++betting_market_itr;
resolve_betting_market(*old_betting_market_itr, betting_market_resolution_type::cancel);
} }
}
//TODO: should we remove market groups once all their markets are resolved?
} }
void database::resolve_betting_market(const betting_market_object& betting_market, void database::validate_betting_market_group_resolutions(const betting_market_group_object& betting_market_group,
betting_market_resolution_type resolution) const std::map<betting_market_id_type, betting_market_resolution_type>& resolutions)
{ {
auto& betting_market_index = get_index_type<betting_market_object_index>().indices().get<by_betting_market_group_id>();
auto betting_market_itr = betting_market_index.lower_bound(betting_market_group.id);
while (betting_market_itr != betting_market_index.end() && betting_market_itr->group_id == betting_market_group.id)
{
const betting_market_object& betting_market = *betting_market_itr;
// every betting market in the group tied with resolution
assert(resolutions.count(betting_market.id));
++betting_market_itr;
}
}
void database::resolve_betting_market_group(const betting_market_group_object& betting_market_group,
const std::map<betting_market_id_type, betting_market_resolution_type>& resolutions)
{
bool cancel = resolutions.size() == 0;
// collecting bettors and their positions
std::map<account_id_type, std::vector<const betting_market_position_object*> > bettor_positions_map;
auto& betting_market_index = get_index_type<betting_market_object_index>().indices().get<by_betting_market_group_id>();
auto betting_market_itr = betting_market_index.lower_bound(betting_market_group.id);
while (betting_market_itr != betting_market_index.end() && betting_market_itr->group_id == betting_market_group.id)
{
const betting_market_object& betting_market = *betting_market_itr;
++betting_market_itr;
cancel_all_unmatched_bets_on_betting_market(betting_market); cancel_all_unmatched_bets_on_betting_market(betting_market);
auto& index = get_index_type<betting_market_position_index>().indices().get<by_bettor_betting_market>(); auto& index = get_index_type<betting_market_position_index>().indices().get<by_bettor_betting_market>();
auto position_itr = index.lower_bound(std::make_tuple(betting_market.id)); auto position_itr = index.lower_bound(std::make_tuple(betting_market.id));
while (position_itr != index.end() &&
position_itr->betting_market_id == betting_market.id) while (position_itr != index.end() && position_itr->betting_market_id == betting_market.id)
{ {
const betting_market_position_object& position = *position_itr; const betting_market_position_object& position = *position_itr;
++position_itr; ++position_itr;
share_type payout_amount = 0; bettor_positions_map[position.bettor_id].push_back(&position);
}
}
// walking through bettors' positions and collecting winings and fees respecting asset_id
for (const auto& bettor_positions_pair: bettor_positions_map)
{
std::map<asset_id_type, share_type> payout_amounts;
std::map<asset_id_type, share_type> fees_collected;
account_id_type bettor_id = bettor_positions_pair.first;
const std::vector<const betting_market_position_object*>& bettor_positions = bettor_positions_pair.second;
for (const betting_market_position_object* position : bettor_positions)
{
betting_market_resolution_type resolution;
if (cancel)
{
resolution = betting_market_resolution_type::cancel;
}
else
{
// checked in evaluator, should never happen, see above
assert(resolutions.count(position->betting_market_id));
resolution = resolutions.at(position->betting_market_id);
}
const betting_market_object& betting_market = position->betting_market_id(*this);
switch (resolution) switch (resolution)
{ {
case betting_market_resolution_type::win: case betting_market_resolution_type::win:
payout_amount += position.pay_if_payout_condition; payout_amounts[betting_market.asset_id] += position->pay_if_payout_condition;
payout_amount += position.pay_if_not_canceled; payout_amounts[betting_market.asset_id] += position->pay_if_not_canceled;
//TODO: pay the fees to the correct (dividend-distribution) account fees_collected[betting_market.asset_id] += position->fees_collected;
adjust_balance(account_id_type(), asset(position.fees_collected, betting_market.asset_id));
break; break;
case betting_market_resolution_type::not_win: case betting_market_resolution_type::not_win:
payout_amount += position.pay_if_not_payout_condition; payout_amounts[betting_market.asset_id] += position->pay_if_not_payout_condition;
payout_amount += position.pay_if_not_canceled; payout_amounts[betting_market.asset_id] += position->pay_if_not_canceled;
//TODO: pay the fees to the correct (dividend-distribution) account fees_collected[betting_market.asset_id] += position->fees_collected;
adjust_balance(account_id_type(), asset(position.fees_collected, betting_market.asset_id));
break; break;
case betting_market_resolution_type::cancel: case betting_market_resolution_type::cancel:
payout_amount += position.pay_if_canceled; payout_amounts[betting_market.asset_id] += position->pay_if_canceled;
payout_amount += position.fees_collected; payout_amounts[betting_market.asset_id] += position->fees_collected;
break; break;
default:
continue;
}
remove(*position);
} }
adjust_balance(position.bettor_id, asset(payout_amount, betting_market.asset_id)); std::vector<asset> winnings;
std::vector<asset> fees;
push_applied_operation(betting_market_resolved_operation(position.bettor_id, for (const auto& payout_amount_pair: payout_amounts)
betting_market.id, {
resolution, asset payout = asset(payout_amount_pair.second, payout_amount_pair.first);
payout_amount, adjust_balance(bettor_id, payout);
position.fees_collected)); winnings.push_back(payout);
remove(position);
} }
for (const auto& fee_collected_pair: fees_collected)
{
// TODO : pay the fees to the correct (dividend-distribution) account
asset fee = asset(fee_collected_pair.second, fee_collected_pair.first);
adjust_balance(account_id_type(), fee);
fees.push_back(fee);
}
push_applied_operation(betting_market_group_resolved_operation(bettor_id,
betting_market_group.id,
resolutions,
winnings,
fees));
}
betting_market_itr = betting_market_index.lower_bound(betting_market_group.id);
while (betting_market_itr != betting_market_index.end() && betting_market_itr->group_id == betting_market_group.id)
{
const betting_market_object& betting_market = *betting_market_itr;
++betting_market_itr;
remove(betting_market); remove(betting_market);
}
remove(betting_market_group);
} }
#if 0 #if 0

2
libraries/chain/db_init.cpp
View file

@ -218,7 +218,7 @@ void database::initialize_evaluators()
register_evaluator<betting_market_group_create_evaluator>(); register_evaluator<betting_market_group_create_evaluator>();
register_evaluator<betting_market_create_evaluator>(); register_evaluator<betting_market_create_evaluator>();
register_evaluator<bet_place_evaluator>(); register_evaluator<bet_place_evaluator>();
register_evaluator<betting_market_resolve_evaluator>(); register_evaluator<betting_market_group_resolve_evaluator>();
} }
void database::initialize_indexes() void database::initialize_indexes()

4
libraries/chain/db_notify.cpp
View file

@ -192,8 +192,8 @@ struct get_impacted_account_visitor
void operator()(const betting_market_group_create_operation&){} void operator()(const betting_market_group_create_operation&){}
void operator()(const betting_market_create_operation&){} void operator()(const betting_market_create_operation&){}
void operator()(const bet_place_operation&){} void operator()(const bet_place_operation&){}
void operator()(const betting_market_resolve_operation&){} void operator()(const betting_market_group_resolve_operation&){}
void operator()(const betting_market_resolved_operation &){} void operator()(const betting_market_group_resolved_operation &){}
void operator()(const bet_matched_operation &){} void operator()(const bet_matched_operation &){}
void operator()(const bet_cancel_operation&){} void operator()(const bet_cancel_operation&){}
void operator()(const bet_canceled_operation &){} void operator()(const bet_canceled_operation &){}

11
libraries/chain/include/graphene/chain/betting_market_evaluator.hpp
View file

@ -76,15 +76,16 @@ namespace graphene { namespace chain {
const bet_object* _bet_to_cancel; const bet_object* _bet_to_cancel;
}; };
class betting_market_resolve_evaluator : public evaluator<betting_market_resolve_evaluator> class betting_market_group_resolve_evaluator : public evaluator<betting_market_group_resolve_evaluator>
{ {
public: public:
typedef betting_market_resolve_operation operation_type; typedef betting_market_group_resolve_operation operation_type;
void_result do_evaluate( const betting_market_resolve_operation& o ); void_result do_evaluate( const betting_market_group_resolve_operation& o );
void_result do_apply( const betting_market_resolve_operation& o ); void_result do_apply( const betting_market_group_resolve_operation& o );
private: private:
const betting_market_object* _betting_market; const betting_market_group_object* _betting_market_group;
}; };
} } // graphene::chain } } // graphene::chain

6
libraries/chain/include/graphene/chain/database.hpp
View file

@ -375,8 +375,10 @@ namespace graphene { namespace chain {
void cancel_bet(const bet_object& bet, bool create_virtual_op = true); void cancel_bet(const bet_object& bet, bool create_virtual_op = true);
void cancel_all_unmatched_bets_on_betting_market(const betting_market_object& betting_market); void cancel_all_unmatched_bets_on_betting_market(const betting_market_object& betting_market);
void cancel_all_betting_markets_for_event(const event_object&); void cancel_all_betting_markets_for_event(const event_object&);
void resolve_betting_market(const betting_market_object& betting_market, void validate_betting_market_group_resolutions(const betting_market_group_object& betting_market_group,
betting_market_resolution_type resolution); const std::map<betting_market_id_type, betting_market_resolution_type>& resolutions);
void resolve_betting_market_group(const betting_market_group_object& betting_market_group,
const std::map<betting_market_id_type, betting_market_resolution_type>& resolutions);
/** /**
* @brief Process a new bet * @brief Process a new bet
* @param new_bet_object The new bet to process * @param new_bet_object The new bet to process

48
libraries/chain/include/graphene/chain/protocol/betting_market.hpp
View file

@ -95,14 +95,14 @@ enum class betting_market_resolution_type {
BETTING_MARKET_RESOLUTION_COUNT BETTING_MARKET_RESOLUTION_COUNT
}; };
struct betting_market_resolve_operation : public base_operation struct betting_market_group_resolve_operation : public base_operation
{ {
struct fee_parameters_type { uint64_t fee = GRAPHENE_BLOCKCHAIN_PRECISION; }; struct fee_parameters_type { uint64_t fee = GRAPHENE_BLOCKCHAIN_PRECISION; };
asset fee; asset fee;
betting_market_id_type betting_market_id; betting_market_group_id_type betting_market_group_id;
betting_market_resolution_type resolution; std::map<betting_market_id_type, betting_market_resolution_type> resolutions;
extensions_type extensions; extensions_type extensions;
@ -110,30 +110,32 @@ struct betting_market_resolve_operation : public base_operation
void validate()const; void validate()const;
}; };
struct betting_market_resolved_operation : public base_operation struct betting_market_group_resolved_operation : public base_operation
{ {
struct fee_parameters_type {}; struct fee_parameters_type {};
account_id_type bettor_id; account_id_type bettor_id;
betting_market_id_type betting_market_id; betting_market_group_id_type betting_market_group_id;
betting_market_resolution_type resolution; std::map<betting_market_id_type, betting_market_resolution_type> resolutions;
asset winnings; std::vector<asset> winnings;
share_type fees_paid; std::vector<asset> fees_paid;
asset fee; // unused in a virtual operation asset fee; // unused in a virtual operation
betting_market_resolved_operation() {} betting_market_group_resolved_operation() {}
betting_market_resolved_operation(account_id_type bettor_id, betting_market_group_resolved_operation(account_id_type bettor_id,
betting_market_id_type betting_market_id, betting_market_group_id_type betting_market_group_id,
betting_market_resolution_type resolution, const std::map<betting_market_id_type, betting_market_resolution_type>& resolutions,
asset winnings, std::vector<asset> winnings,
share_type fees_paid) : std::vector<asset> fees_paid) :
bettor_id(bettor_id), bettor_id(bettor_id),
betting_market_id(betting_market_id), betting_market_group_id(betting_market_group_id),
resolution(resolution), resolutions(resolutions),
winnings(winnings), winnings(winnings),
fees_paid(fees_paid) fees_paid(fees_paid)
{} {
// TODO ?
}
account_id_type fee_payer()const { return bettor_id; } account_id_type fee_payer()const { return bettor_id; }
void validate()const { FC_ASSERT(false, "virtual operation"); } void validate()const { FC_ASSERT(false, "virtual operation"); }
@ -279,13 +281,13 @@ FC_REFLECT( graphene::chain::betting_market_create_operation,
FC_REFLECT_ENUM( graphene::chain::betting_market_resolution_type, (win)(not_win)(cancel)(BETTING_MARKET_RESOLUTION_COUNT) ) FC_REFLECT_ENUM( graphene::chain::betting_market_resolution_type, (win)(not_win)(cancel)(BETTING_MARKET_RESOLUTION_COUNT) )
FC_REFLECT( graphene::chain::betting_market_resolve_operation::fee_parameters_type, (fee) ) FC_REFLECT( graphene::chain::betting_market_group_resolve_operation::fee_parameters_type, (fee) )
FC_REFLECT( graphene::chain::betting_market_resolve_operation, FC_REFLECT( graphene::chain::betting_market_group_resolve_operation,
(fee)(betting_market_id)(resolution)(extensions) ) (fee)(betting_market_group_id)(resolutions)(extensions) )
FC_REFLECT( graphene::chain::betting_market_resolved_operation::fee_parameters_type, ) FC_REFLECT( graphene::chain::betting_market_group_resolved_operation::fee_parameters_type, )
FC_REFLECT( graphene::chain::betting_market_resolved_operation, FC_REFLECT( graphene::chain::betting_market_group_resolved_operation,
(bettor_id)(betting_market_id)(resolution)(winnings)(fees_paid)(fee) ) (bettor_id)(betting_market_group_id)(resolutions)(winnings)(fees_paid)(fee) )
FC_REFLECT_ENUM( graphene::chain::bet_type, (back)(lay) ) FC_REFLECT_ENUM( graphene::chain::bet_type, (back)(lay) )
FC_REFLECT( graphene::chain::bet_place_operation::fee_parameters_type, (fee) ) FC_REFLECT( graphene::chain::bet_place_operation::fee_parameters_type, (fee) )

4
libraries/chain/include/graphene/chain/protocol/operations.hpp
View file

@ -104,8 +104,8 @@ namespace graphene { namespace chain {
betting_market_group_create_operation, betting_market_group_create_operation,
betting_market_create_operation, betting_market_create_operation,
bet_place_operation, bet_place_operation,
betting_market_resolve_operation, betting_market_group_resolve_operation,
betting_market_resolved_operation, // VIRTUAL betting_market_group_resolved_operation, // VIRTUAL
bet_matched_operation, // VIRTUAL bet_matched_operation, // VIRTUAL
bet_cancel_operation, bet_cancel_operation,
bet_canceled_operation // VIRTUAL bet_canceled_operation // VIRTUAL

4
libraries/chain/protocol/betting_market.cpp
View file

@ -35,9 +35,9 @@ void betting_market_create_operation::validate() const
FC_ASSERT( fee.amount >= 0 ); FC_ASSERT( fee.amount >= 0 );
} }
void betting_market_resolve_operation::validate() const void betting_market_group_resolve_operation::validate() const
{ {
FC_ASSERT( fee.amount >= 0 ); //FC_ASSERT( fee.amount >= 0 );
} }
void bet_place_operation::validate() const void bet_place_operation::validate() const

8
libraries/wallet/include/graphene/wallet/wallet.hpp
View file

@ -1559,11 +1559,11 @@ class wallet_api
share_type amount_reserved_for_fees, share_type amount_reserved_for_fees,
bool broadcast = false); bool broadcast = false);
signed_transaction propose_resolve_betting_market( signed_transaction propose_resolve_betting_market_group(
const string& proposing_account, const string& proposing_account,
fc::time_point_sec expiration_time, fc::time_point_sec expiration_time,
betting_market_id_type betting_market_id, betting_market_group_id_type betting_market_group_id,
betting_market_resolution_type resolution, const std::map<betting_market_id_type, betting_market_resolution_type>& resolutions,
bool broadcast = false); bool broadcast = false);
void dbg_make_uia(string creator, string symbol); void dbg_make_uia(string creator, string symbol);
@ -1779,6 +1779,6 @@ FC_API( graphene::wallet::wallet_api,
(propose_create_betting_market_group) (propose_create_betting_market_group)
(propose_create_betting_market) (propose_create_betting_market)
(place_bet) (place_bet)
(propose_resolve_betting_market) (propose_resolve_betting_market_group)
(get_order_book) (get_order_book)
) )

14
libraries/wallet/wallet.cpp
View file

@ -4577,25 +4577,25 @@ signed_transaction wallet_api::place_bet(
return my->sign_transaction(tx, broadcast); return my->sign_transaction(tx, broadcast);
} }
signed_transaction wallet_api::propose_resolve_betting_market( signed_transaction wallet_api::propose_resolve_betting_market_group(
const string& proposing_account, const string& proposing_account,
fc::time_point_sec expiration_time, fc::time_point_sec expiration_time,
betting_market_id_type betting_market_id, betting_market_group_id_type betting_market_group_id,
betting_market_resolution_type resolution, const std::map<betting_market_id_type, betting_market_resolution_type>& resolutions,
bool broadcast /*= false*/) bool broadcast /*= false*/)
{ {
FC_ASSERT( !is_locked() ); FC_ASSERT( !is_locked() );
const chain_parameters& current_params = get_global_properties().parameters; const chain_parameters& current_params = get_global_properties().parameters;
betting_market_resolve_operation betting_market_resolve_op; betting_market_group_resolve_operation betting_market_group_resolve_op;
betting_market_resolve_op.betting_market_id = betting_market_id; betting_market_group_resolve_op.betting_market_group_id = betting_market_group_id;
betting_market_resolve_op.resolution = resolution; betting_market_group_resolve_op.resolutions = resolutions;
proposal_create_operation prop_op; proposal_create_operation prop_op;
prop_op.expiration_time = expiration_time; prop_op.expiration_time = expiration_time;
prop_op.review_period_seconds = current_params.committee_proposal_review_period; prop_op.review_period_seconds = current_params.committee_proposal_review_period;
prop_op.fee_paying_account = get_account(proposing_account).id; prop_op.fee_paying_account = get_account(proposing_account).id;
prop_op.proposed_ops.emplace_back( betting_market_resolve_op ); prop_op.proposed_ops.emplace_back( betting_market_group_resolve_op );
current_params.current_fees->set_fee( prop_op.proposed_ops.back().op ); current_params.current_fees->set_fee( prop_op.proposed_ops.back().op );
signed_transaction tx; signed_transaction tx;

21
tests/betting/betting_tests.cpp
View file

@ -114,7 +114,9 @@ BOOST_AUTO_TEST_CASE( peerplays_sport_create_test )
BOOST_CHECK_EQUAL(get_balance(bob_id, asset_id_type()), 10000000 - 1000000 - 20000); BOOST_CHECK_EQUAL(get_balance(bob_id, asset_id_type()), 10000000 - 1000000 - 20000);
// caps win // caps win
resolve_betting_market(capitals_win_market.id, betting_market_resolution_type::win); resolve_betting_market_group(moneyline_betting_markets.id,
{{capitals_win_market.id, betting_market_resolution_type::win},
{blackhawks_win_market.id, betting_market_resolution_type::cancel}});
BOOST_CHECK_EQUAL(get_balance(alice_id, asset_id_type()), 10000000 - 1000000 - 20000 + 2000000); BOOST_CHECK_EQUAL(get_balance(alice_id, asset_id_type()), 10000000 - 1000000 - 20000 + 2000000);
BOOST_CHECK_EQUAL(get_balance(bob_id, asset_id_type()), 10000000 - 1000000 - 20000); BOOST_CHECK_EQUAL(get_balance(bob_id, asset_id_type()), 10000000 - 1000000 - 20000);
@ -253,6 +255,9 @@ BOOST_AUTO_TEST_SUITE_END()
// the result in all three possible outcomes // the result in all three possible outcomes
struct simple_bet_test_fixture : database_fixture { struct simple_bet_test_fixture : database_fixture {
betting_market_id_type capitals_win_betting_market_id; betting_market_id_type capitals_win_betting_market_id;
betting_market_id_type blackhawks_win_betting_market_id;
betting_market_group_id_type moneyline_betting_markets_id;
simple_bet_test_fixture() simple_bet_test_fixture()
{ {
ACTORS( (alice)(bob) ); ACTORS( (alice)(bob) );
@ -271,6 +276,8 @@ struct simple_bet_test_fixture : database_fixture {
place_bet(bob_id, capitals_win_market.id, bet_type::back, asset(1100, asset_id_type()), 2 * GRAPHENE_BETTING_ODDS_PRECISION, 22); place_bet(bob_id, capitals_win_market.id, bet_type::back, asset(1100, asset_id_type()), 2 * GRAPHENE_BETTING_ODDS_PRECISION, 22);
capitals_win_betting_market_id = capitals_win_market.id; capitals_win_betting_market_id = capitals_win_market.id;
blackhawks_win_betting_market_id = blackhawks_win_market.id;
moneyline_betting_markets_id = moneyline_betting_markets.id;
} }
}; };
@ -280,7 +287,9 @@ BOOST_AUTO_TEST_CASE( win )
{ {
try try
{ {
resolve_betting_market(capitals_win_betting_market_id, betting_market_resolution_type::win); resolve_betting_market_group(moneyline_betting_markets_id,
{{capitals_win_betting_market_id, betting_market_resolution_type::win},
{blackhawks_win_betting_market_id, betting_market_resolution_type::cancel}});
GET_ACTOR(alice); GET_ACTOR(alice);
GET_ACTOR(bob); GET_ACTOR(bob);
@ -296,7 +305,9 @@ BOOST_AUTO_TEST_CASE( not_win )
{ {
try try
{ {
resolve_betting_market(capitals_win_betting_market_id, betting_market_resolution_type::not_win); resolve_betting_market_group(moneyline_betting_markets_id,
{{capitals_win_betting_market_id, betting_market_resolution_type::not_win},
{blackhawks_win_betting_market_id, betting_market_resolution_type::cancel}});
GET_ACTOR(alice); GET_ACTOR(alice);
GET_ACTOR(bob); GET_ACTOR(bob);
@ -312,7 +323,9 @@ BOOST_AUTO_TEST_CASE( cancel )
{ {
try try
{ {
resolve_betting_market(capitals_win_betting_market_id, betting_market_resolution_type::cancel); resolve_betting_market_group(moneyline_betting_markets_id,
{{capitals_win_betting_market_id, betting_market_resolution_type::cancel},
{blackhawks_win_betting_market_id, betting_market_resolution_type::cancel}});
GET_ACTOR(alice); GET_ACTOR(alice);
GET_ACTOR(bob); GET_ACTOR(bob);

13
tests/common/database_fixture.cpp
View file

@ -1198,13 +1198,14 @@ const betting_market_object& database_fixture::create_betting_market(betting_mar
trx.operations.clear(); trx.operations.clear();
} FC_CAPTURE_AND_RETHROW( (bettor_id)(back_or_lay)(amount_to_bet) ) } } FC_CAPTURE_AND_RETHROW( (bettor_id)(back_or_lay)(amount_to_bet) ) }
void database_fixture::resolve_betting_market(betting_market_id_type betting_market_id, betting_market_resolution_type resolution) void database_fixture::resolve_betting_market_group(betting_market_group_id_type betting_market_group_id,
std::map<betting_market_id_type, betting_market_resolution_type> resolutions)
{ try { { try {
betting_market_resolve_operation betting_market_resolve_op; betting_market_group_resolve_operation betting_market_group_resolve_op;
betting_market_resolve_op.betting_market_id = betting_market_id; betting_market_group_resolve_op.betting_market_group_id = betting_market_group_id;
betting_market_resolve_op.resolution = resolution; betting_market_group_resolve_op.resolutions = resolutions;
process_operation_by_witnesses(betting_market_resolve_op); process_operation_by_witnesses(betting_market_group_resolve_op);
} FC_CAPTURE_AND_RETHROW( (betting_market_id)(resolution) ) } } FC_CAPTURE_AND_RETHROW( (betting_market_group_id)(resolutions) ) }
namespace test { namespace test {

2
tests/common/database_fixture.hpp
View file

@ -290,7 +290,7 @@ struct database_fixture {
const betting_market_object& create_betting_market(betting_market_group_id_type group_id, internationalized_string_type payout_condition, asset_id_type asset_id); const betting_market_object& create_betting_market(betting_market_group_id_type group_id, internationalized_string_type payout_condition, asset_id_type asset_id);
void place_bet(account_id_type bettor_id, betting_market_id_type betting_market_id, bet_type back_or_lay, asset amount_to_bet, bet_multiplier_type backer_multiplier, share_type amount_reserved_for_fees); void place_bet(account_id_type bettor_id, betting_market_id_type betting_market_id, bet_type back_or_lay, asset amount_to_bet, bet_multiplier_type backer_multiplier, share_type amount_reserved_for_fees);
void resolve_betting_market(betting_market_id_type betting_market_id, betting_market_resolution_type resolution); void resolve_betting_market_group(betting_market_group_id_type betting_market_group_id, std::map<betting_market_id_type, betting_market_resolution_type> resolutions);
}; };
namespace test { namespace test {