Implement alternative black swan response methods

.github/workflows/build-and-test.mac.yml

@@ -8,7 +8,7 @@ jobs:
  name: Build and test in macOS
  strategy:
  matrix:
- os: [macos-10.15, macos-11.0]
+ os: [macos-10.15, macos-11]
  runs-on: ${{ matrix.os }}
  steps:
  - name: Install dependencies

.github/workflows/build-and-test.ubuntu-debug.yml

@@ -8,7 +8,7 @@ jobs:
  name: Build and test in Debug mode
  strategy:
  matrix:
- os: [ ubuntu-16.04, ubuntu-18.04, ubuntu-20.04 ]
+ os: [ ubuntu-18.04, ubuntu-20.04 ]
  runs-on: ${{ matrix.os }}
  services:
  elasticsearch:

.github/workflows/build-and-test.ubuntu-release.yml

@@ -8,7 +8,7 @@ jobs:
  name: Build and test in Release mode
  strategy:
  matrix:
- os: [ ubuntu-16.04, ubuntu-18.04, ubuntu-20.04 ]
+ os: [ ubuntu-18.04, ubuntu-20.04 ]
  runs-on: ${{ matrix.os }}
  services:
  elasticsearch:

.github/workflows/build-and-test.win.yml

@@ -14,12 +14,15 @@ jobs:
  name: Build required 3rd-party libraries
  runs-on: ubuntu-latest
  steps:
+ # Get OS version to be used in cache key - see https://github.com/actions/cache/issues/543
+ - run: |
+ echo "OS_VERSION=`lsb_release -sr`" >> $GITHUB_ENV
  - name: Load Cache
  id: cache-libs
- uses: actions/cache@v1
+ uses: actions/cache@v2
  with:
  path: libs
- key: mingw64-libs-${{ env.BOOST_VERSION }}_${{ env.CURL_VERSION }}_${{ env.OPENSSL_VERSION }}_${{ env.ZLIB_VERSION }}
+ key: mingw64-libs-${{ env.OS_VERSION }}-${{ env.BOOST_VERSION }}_${{ env.CURL_VERSION }}_${{ env.OPENSSL_VERSION }}_${{ env.ZLIB_VERSION }}
  - name: Install dependencies
  if: steps.cache-libs.outputs.cache-hit != 'true'
  run: |
@@ -113,11 +116,13 @@ jobs:
  - uses: actions/checkout@v2
  with:
  submodules: recursive
+ - run: |
+ echo "OS_VERSION=`lsb_release -sr`" >> $GITHUB_ENV
  - name: Load external libraries
- uses: actions/cache@v1
+ uses: actions/cache@v2
  with:
  path: libs
- key: mingw64-libs-${{ env.BOOST_VERSION }}_${{ env.CURL_VERSION }}_${{ env.OPENSSL_VERSION }}_${{ env.ZLIB_VERSION }}
+ key: mingw64-libs-${{ env.OS_VERSION }}-${{ env.BOOST_VERSION }}_${{ env.CURL_VERSION }}_${{ env.OPENSSL_VERSION }}_${{ env.ZLIB_VERSION }}
  - name: Configure
  run: |
  LIBS="`pwd`/libs"
@@ -138,13 +143,13 @@ jobs:
  -D GRAPHENE_DISABLE_UNITY_BUILD=ON \
  ..
  - name: Load Cache
- uses: actions/cache@v1
+ uses: actions/cache@v2
  with:
  path: ccache
- key: ccache-mingw64-${{ github.ref }}-${{ github.sha }}
+ key: ccache-mingw64-${{ env.OS_VERSION }}-${{ github.ref }}-${{ github.sha }}
  restore-keys: |
- ccache-mingw64-${{ github.ref }}-
- ccache-mingw64-
+ ccache-mingw64-${{ env.OS_VERSION }}-${{ github.ref }}-
+ ccache-mingw64-${{ env.OS_VERSION }}-
  - name: Build
  run: |
  export CCACHE_DIR="$GITHUB_WORKSPACE/ccache"

libraries/chain/asset_object.cpp

@@ -32,9 +32,9 @@ using namespace graphene::chain;
 
 share_type asset_bitasset_data_object::max_force_settlement_volume(share_type current_supply) const
 {
- if( options.maximum_force_settlement_volume == 0 )
+ if( 0 == options.maximum_force_settlement_volume )
  return 0;
- if( options.maximum_force_settlement_volume == GRAPHENE_100_PERCENT )
+ if( GRAPHENE_100_PERCENT == options.maximum_force_settlement_volume )
  return current_supply + force_settled_volume;
 
  fc::uint128_t volume = current_supply.value;
@@ -49,66 +49,67 @@ void graphene::chain::asset_bitasset_data_object::update_median_feeds( time_poin
 {
  bool after_core_hardfork_1270 = ( next_maintenance_time > HARDFORK_CORE_1270_TIME ); // call price caching issue
  current_feed_publication_time = current_time;
- vector<std::reference_wrapper<const price_feed_with_icr>> current_feeds;
+ vector<std::reference_wrapper<const price_feed_with_icr>> effective_feeds;
  // find feeds that were alive at current_time
  for( const pair<account_id_type, pair<time_point_sec,price_feed_with_icr>>& f : feeds )
  {
  if( (current_time - f.second.first).to_seconds() < options.feed_lifetime_sec &&
  f.second.first != time_point_sec() )
  {
- current_feeds.emplace_back(f.second.second);
+ effective_feeds.emplace_back(f.second.second);
  current_feed_publication_time = std::min(current_feed_publication_time, f.second.first);
  }
  }
 
  // If there are no valid feeds, or the number available is less than the minimum to calculate a median...
- if( current_feeds.size() < options.minimum_feeds )
+ if( effective_feeds.size() < options.minimum_feeds )
  {
  //... don't calculate a median, and set a null feed
  feed_cer_updated = false; // new median cer is null, won't update asset_object anyway, set to false for better performance
  current_feed_publication_time = current_time;
- current_feed = price_feed_with_icr();
+ median_feed = price_feed_with_icr();
  if( after_core_hardfork_1270 )
  {
  // update data derived from MCR, ICR and etc
  refresh_cache();
  }
  return;
  }
- if( current_feeds.size() == 1 )
+
+ if( 1u == effective_feeds.size() )
  {
- if( current_feed.core_exchange_rate != current_feeds.front().get().core_exchange_rate )
+ if( median_feed.core_exchange_rate != effective_feeds.front().get().core_exchange_rate )
  feed_cer_updated = true;
- current_feed = current_feeds.front();
+ median_feed = effective_feeds.front();
  // Note: perhaps can defer updating current_maintenance_collateralization for better performance
  if( after_core_hardfork_1270 )
  {
  const auto& exts = options.extensions.value;
  if( exts.maintenance_collateral_ratio.valid() )
- current_feed.maintenance_collateral_ratio = *exts.maintenance_collateral_ratio;
+ median_feed.maintenance_collateral_ratio = *exts.maintenance_collateral_ratio;
  if( exts.maximum_short_squeeze_ratio.valid() )
- current_feed.maximum_short_squeeze_ratio = *exts.maximum_short_squeeze_ratio;
+ median_feed.maximum_short_squeeze_ratio = *exts.maximum_short_squeeze_ratio;
  if( exts.initial_collateral_ratio.valid() )
- current_feed.initial_collateral_ratio = *exts.initial_collateral_ratio;
+ median_feed.initial_collateral_ratio = *exts.initial_collateral_ratio;
  // update data derived from MCR, ICR and etc
  refresh_cache();
  }
  return;
  }
 
  // *** Begin Median Calculations ***
- price_feed_with_icr median_feed;
- const auto median_itr = current_feeds.begin() + current_feeds.size() / 2;
+ price_feed_with_icr tmp_median_feed;
+ const auto median_itr = effective_feeds.begin() + ( effective_feeds.size() / 2 );
 #define CALCULATE_MEDIAN_VALUE(r, data, field_name) \
- std::nth_element( current_feeds.begin(), median_itr, current_feeds.end(), \
+ std::nth_element( effective_feeds.begin(), median_itr, effective_feeds.end(), \
  [](const price_feed_with_icr& a, const price_feed_with_icr& b) { \
  return a.field_name < b.field_name; \
  }); \
- median_feed.field_name = median_itr->get().field_name;
+ tmp_median_feed.field_name = median_itr->get().field_name;
 
 #define CHECK_AND_CALCULATE_MEDIAN_VALUE(r, data, field_name) \
  if( options.extensions.value.field_name.valid() ) { \
- median_feed.field_name = *options.extensions.value.field_name; \
+ tmp_median_feed.field_name = *options.extensions.value.field_name; \
  } else { \
  CALCULATE_MEDIAN_VALUE(r, data, field_name); \
  }
@@ -120,9 +121,9 @@ void graphene::chain::asset_bitasset_data_object::update_median_feeds( time_poin
 #undef CALCULATE_MEDIAN_VALUE
  // *** End Median Calculations ***
 
- if( current_feed.core_exchange_rate != median_feed.core_exchange_rate )
+ if( median_feed.core_exchange_rate != tmp_median_feed.core_exchange_rate )
  feed_cer_updated = true;
- current_feed = median_feed;
+ median_feed = tmp_median_feed;
  // Note: perhaps can defer updating current_maintenance_collateralization for better performance
  if( after_core_hardfork_1270 )
  {
@@ -133,14 +134,14 @@ void graphene::chain::asset_bitasset_data_object::update_median_feeds( time_poin
 
 void asset_bitasset_data_object::refresh_cache()
 {
- current_maintenance_collateralization = current_feed.maintenance_collateralization();
- if( current_feed.initial_collateral_ratio > current_feed.maintenance_collateral_ratio ) // if ICR is above MCR
- current_initial_collateralization = current_feed.calculate_initial_collateralization();
+ current_maintenance_collateralization = median_feed.maintenance_collateralization();
+ if( median_feed.initial_collateral_ratio > median_feed.maintenance_collateral_ratio ) // if ICR is above MCR
+ current_initial_collateralization = median_feed.get_initial_collateralization();
  else // if ICR is not above MCR
  current_initial_collateralization = current_maintenance_collateralization;
 }
 
-price price_feed_with_icr::calculate_initial_collateralization()const
+price price_feed_with_icr::get_initial_collateralization()const
 {
  if( settlement_price.is_null() )
  return price();
@@ -223,6 +224,7 @@ FC_REFLECT_DERIVED_NO_TYPENAME( graphene::chain::asset_dynamic_data_object, (gra
 FC_REFLECT_DERIVED_NO_TYPENAME( graphene::chain::asset_bitasset_data_object, (graphene::db::object),
  (asset_id)
  (feeds)
+ (median_feed)
  (current_feed)
  (current_feed_publication_time)
  (current_maintenance_collateralization)
@@ -232,6 +234,8 @@ FC_REFLECT_DERIVED_NO_TYPENAME( graphene::chain::asset_bitasset_data_object, (gr
  (is_prediction_market)
  (settlement_price)
  (settlement_fund)
+ (individual_settlement_debt)
+ (individual_settlement_fund)
  (asset_cer_updated)
  (feed_cer_updated)
  )

libraries/chain/db_getter.cpp

@@ -24,9 +24,12 @@
 
 #include <graphene/chain/database.hpp>
 
+#include <graphene/chain/hardfork.hpp>
+
 #include <graphene/chain/asset_object.hpp>
 #include <graphene/chain/chain_property_object.hpp>
 #include <graphene/chain/global_property_object.hpp>
+#include <graphene/chain/market_object.hpp>
 #include <graphene/chain/custom_authority_object.hpp>
 
 namespace graphene { namespace chain {
@@ -146,4 +149,47 @@ const witness_schedule_object& database::get_witness_schedule_object()const
  return *_p_witness_schedule_obj;
 }
 
+const limit_order_object* database::find_settled_debt_order( const asset_id_type& a )const
+{
+ const auto& limit_index = get_index_type<limit_order_index>().indices().get<by_is_settled_debt>();
+ auto itr = limit_index.lower_bound( std::make_tuple( true, a ) );
+ if( itr != limit_index.end() && itr->receive_asset_id() == a )
+ return &(*itr);
+ return nullptr;
+}
+
+const call_order_object* database::find_least_collateralized_short( const asset_bitasset_data_object& bitasset,
+ bool force_by_collateral_index )const
+{
+ bool find_by_collateral = true;
+ if( !force_by_collateral_index )
+ // core-1270 hard fork : call price caching issue
+ find_by_collateral = ( get_dynamic_global_properties().next_maintenance_time > HARDFORK_CORE_1270_TIME );
+
+ const call_order_object* call_ptr = nullptr; // place holder
+
+ auto call_min = price::min( bitasset.options.short_backing_asset, bitasset.asset_id );
+
+ if( !find_by_collateral ) // before core-1270 hard fork, check with call_price
+ {
+ const auto& call_price_index = get_index_type<call_order_index>().indices().get<by_price>();
+ auto call_itr = call_price_index.lower_bound( call_min );
+ if( call_itr != call_price_index.end() ) // found a call order
+ call_ptr = &(*call_itr);
+ }
+ else // after core-1270 hard fork, check with collateralization
+ {
+ // Note: it is safe to check here even if there is no call order due to individual settlements
+ const auto& call_collateral_index = get_index_type<call_order_index>().indices().get<by_collateral>();
+ auto call_itr = call_collateral_index.lower_bound( call_min );
+ if( call_itr != call_collateral_index.end() ) // found a call order
+ call_ptr = &(*call_itr);
+ }
+ if( !call_ptr ) // not found
+ return nullptr;
+ if( call_ptr->debt_type() != bitasset.asset_id ) // call order is of another asset
+ return nullptr;
+ return call_ptr;
+}
+
 } }

libraries/chain/db_maint.cpp

@@ -991,19 +991,11 @@ void process_hf_2103( database& db )
  }
 }
 
-void update_median_feeds(database& db)
+static void update_bitasset_current_feeds(database& db)
 {
- time_point_sec head_time = db.head_block_time();
- time_point_sec next_maint_time = db.get_dynamic_global_properties().next_maintenance_time;
-
- const auto update_bitasset = [head_time, next_maint_time]( asset_bitasset_data_object &o )
+ for( const auto& bitasset : db.get_index_type<asset_bitasset_data_index>().indices() )
  {
- o.update_median_feeds( head_time, next_maint_time );
- };
-
- for( const auto& d : db.get_index_type<asset_bitasset_data_index>().indices() )
- {
- db.modify( d, update_bitasset );
+ db.update_bitasset_current_feed( bitasset );
  }
 }
 
@@ -1027,8 +1019,6 @@ void update_median_feeds(database& db)
 // feeds were found.
 void process_hf_868_890( database& db, bool skip_check_call_orders )
 {
- const auto next_maint_time = db.get_dynamic_global_properties().next_maintenance_time;
- const auto head_time = db.head_block_time();
  // for each market issued asset
  const auto& asset_idx = db.get_index_type<asset_index>().indices().get<by_type>();
  for( auto asset_itr = asset_idx.lower_bound(true); asset_itr != asset_idx.end(); ++asset_itr )
@@ -1074,11 +1064,9 @@ void process_hf_868_890( database& db, bool skip_check_call_orders )
  } // end loop of each feed
 
  // always update the median feed due to https://github.com/bitshares/bitshares-core/issues/890
- db.modify( bitasset_data, [head_time,next_maint_time]( asset_bitasset_data_object &obj ) {
- obj.update_median_feeds( head_time, next_maint_time );
- // NOTE: Normally we should call check_call_orders() after called update_median_feeds(), but for
- // mainnet actually check_call_orders() would do nothing, so we skipped it for better performance.
- });
+ db.update_bitasset_current_feed( bitasset_data );
+ // NOTE: Normally we should call check_call_orders() after called update_bitasset_current_feed(), but for
+ // mainnet actually check_call_orders() would do nothing, so we skipped it for better performance.
 
  } // for each market issued asset
 }
@@ -1497,7 +1485,7 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
  if( to_update_and_match_call_orders_for_hf_1270 )
  {
  update_call_orders_hf_1270(*this);
- update_median_feeds(*this);
+ update_bitasset_current_feeds(*this);
  match_call_orders(*this);
  }