Implement simple collateralized P2P funding

Author: abitmore

libraries/chain/CMakeLists.txt

@@ -39,6 +39,7 @@ add_library( graphene_chain
              evaluator.cpp
              liquidity_pool_evaluator.cpp
              samet_fund_evaluator.cpp
+             credit_offer_evaluator.cpp
              balance_evaluator.cpp
              account_evaluator.cpp
              assert_evaluator.cpp

libraries/chain/credit_offer_evaluator.cpp

@@ -648,6 +648,7 @@ void database::_apply_block( const signed_block& next_block )
    update_expired_feeds();       // this will update expired feeds and some core exchange rates
    update_core_exchange_rates(); // this will update remaining core exchange rates
    update_withdraw_permissions();
+   update_credit_offers_and_deals();
 
    // n.b., update_maintenance_flag() happens this late
    // because get_slot_time() / get_slot_at_time() is needed above

libraries/chain/db_block.cpp

@@ -33,6 +33,7 @@
 #include <graphene/chain/chain_property_object.hpp>
 #include <graphene/chain/committee_member_object.hpp>
 #include <graphene/chain/confidential_object.hpp>
+#include <graphene/chain/credit_offer_object.hpp>
 #include <graphene/chain/fba_object.hpp>
 #include <graphene/chain/global_property_object.hpp>
 #include <graphene/chain/liquidity_pool_object.hpp>
@@ -57,6 +58,7 @@
 #include <graphene/chain/balance_evaluator.hpp>
 #include <graphene/chain/committee_member_evaluator.hpp>
 #include <graphene/chain/confidential_evaluator.hpp>
+#include <graphene/chain/credit_offer_evaluator.hpp>
 #include <graphene/chain/custom_evaluator.hpp>
 #include <graphene/chain/liquidity_pool_evaluator.hpp>
 #include <graphene/chain/market_evaluator.hpp>
@@ -138,6 +140,11 @@ void database::initialize_evaluators()
    register_evaluator<samet_fund_update_evaluator>();
    register_evaluator<samet_fund_borrow_evaluator>();
    register_evaluator<samet_fund_repay_evaluator>();
+   register_evaluator<credit_offer_create_evaluator>();
+   register_evaluator<credit_offer_delete_evaluator>();
+   register_evaluator<credit_offer_update_evaluator>();
+   register_evaluator<credit_offer_accept_evaluator>();
+   register_evaluator<credit_deal_repay_evaluator>();
 }
 
 void database::initialize_indexes()
@@ -165,6 +172,8 @@ void database::initialize_indexes()
    add_index< primary_index<ticket_index> >();
    add_index< primary_index<liquidity_pool_index> >();
    add_index< primary_index<samet_fund_index> >();
+   add_index< primary_index<credit_offer_index> >();
+   add_index< primary_index<credit_deal_index> >();
 
    //Implementation object indexes
    add_index< primary_index<transaction_index                             > >();
@@ -185,6 +194,7 @@ void database::initialize_indexes()
    add_index< primary_index< buyback_index                                > >();
    add_index< primary_index<collateral_bid_index                          > >();
    add_index< primary_index< simple_index< fba_accumulator_object       > > >();
+   add_index< primary_index<credit_deal_summary_index                     > >();
 }
 
 } }

libraries/chain/db_init.cpp

@@ -20,6 +20,7 @@
 #include <graphene/chain/ticket_object.hpp>
 #include <graphene/chain/liquidity_pool_object.hpp>
 #include <graphene/chain/samet_fund_object.hpp>
+#include <graphene/chain/credit_offer_object.hpp>
 #include <graphene/chain/impacted.hpp>
 #include <graphene/chain/hardfork.hpp>
 
@@ -356,6 +357,31 @@ struct get_impacted_account_visitor
    {
       _impacted.insert( op.fee_payer() ); // account
    }
+   void operator()( const credit_offer_create_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); // owner_account
+   }
+   void operator()( const credit_offer_delete_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); // owner_account
+   }
+   void operator()( const credit_offer_update_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); // owner_account
+   }
+   void operator()( const credit_offer_accept_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); // borrower
+   }
+   void operator()( const credit_deal_repay_operation& op )
+   {
+      _impacted.insert( op.fee_payer() ); // account
+   }
+   void operator()( const credit_deal_expired_operation& op )
+   {
+      _impacted.insert( op.offer_owner );
+      _impacted.insert( op.borrower );
+   }
 };
 
 } // namespace detail
@@ -474,6 +500,17 @@ void get_relevant_accounts( const object* obj, flat_set<account_id_type>& accoun
            FC_ASSERT( aobj != nullptr );
            accounts.insert( aobj->owner_account );
            break;
+         } case credit_offer_object_type:{
+           const auto* aobj = dynamic_cast<const credit_offer_object*>( obj );
+           FC_ASSERT( aobj != nullptr );
+           accounts.insert( aobj->owner_account );
+           break;
+         } case credit_deal_object_type:{
+           const auto* aobj = dynamic_cast<const credit_deal_object*>( obj );
+           FC_ASSERT( aobj != nullptr );
+           accounts.insert( aobj->offer_owner );
+           accounts.insert( aobj->borrower );
+           break;
         }
       }
    }
@@ -537,6 +574,12 @@ void get_relevant_accounts( const object* obj, flat_set<account_id_type>& accoun
               FC_ASSERT( aobj != nullptr );
               accounts.insert( aobj->bidder );
               break;
+           } case impl_credit_deal_summary_object_type:{
+              const auto& aobj = dynamic_cast<const credit_deal_summary_object*>(obj);
+              FC_ASSERT( aobj != nullptr );
+              accounts.insert( aobj->offer_owner );
+              accounts.insert( aobj->borrower );
+              break;
            }
       }
    }

libraries/chain/db_notify.cpp

@@ -26,6 +26,7 @@
 #include <graphene/chain/db_with.hpp>
 
 #include <graphene/chain/asset_object.hpp>
+#include <graphene/chain/credit_offer_object.hpp>
 #include <graphene/chain/global_property_object.hpp>
 #include <graphene/chain/hardfork.hpp>
 #include <graphene/chain/htlc_object.hpp>
@@ -697,4 +698,74 @@ generic_operation_result database::process_tickets()
    return result;
 }
 
+void database::update_credit_offers_and_deals()
+{
+   const auto head_time = head_block_time();
+
+   // Auto-disable offers
+   const auto& offer_idx = get_index_type<credit_offer_index>().indices().get<by_auto_disable_time>();
+   auto offer_itr = offer_idx.lower_bound( true );
+   auto offer_itr_end = offer_idx.upper_bound( boost::make_tuple( true, head_time ) );
+   while( offer_itr != offer_itr_end )
+   {
+      const credit_offer_object& offer = *offer_itr;
+      ++offer_itr;
+      modify( offer, []( credit_offer_object& obj ) {
+         obj.enabled = false;
+      });
+   }
+
+   // Auto-process deals
+   const auto& deal_idx = get_index_type<credit_deal_index>().indices().get<by_latest_repay_time>();
+   const auto& deal_summary_idx = get_index_type<credit_deal_summary_index>().indices().get<by_offer_borrower>();
+   auto deal_itr_end = deal_idx.upper_bound( head_time );
+   for( auto deal_itr = deal_idx.begin(); deal_itr != deal_itr_end; deal_itr = deal_idx.begin() )
+   {
+      const credit_deal_object& deal = *deal_itr;
+
+      // Update offer
+      // Note: offer balance can be zero after updated. TODO remove zero-balance offers after a period
+      const credit_offer_object& offer = deal.offer_id(*this);
+      modify( offer, [&deal]( credit_offer_object& obj ){
+         obj.total_balance -= deal.debt_amount;
+      });
+
+      // Process deal summary
+      auto summ_itr = deal_summary_idx.find( boost::make_tuple( deal.offer_id, deal.borrower ) );
+      if( summ_itr == deal_summary_idx.end() ) // This should not happen, just be defensive here
+      {
+         // We do not do FC_ASSERT or FC_THROW here to avoid halting the chain
+         elog( "Error: unable to find the credit deal summary object for credit deal ${d}",
+               ("d", deal) );
+      }
+      else
+      {
+         const credit_deal_summary_object& summ_obj = *summ_itr;
+         if( summ_obj.total_debt_amount == deal.debt_amount )
+         {
+            remove( summ_obj );
+         }
+         else
+         {
+            modify( summ_obj, [&deal]( credit_deal_summary_object& obj ){
+               obj.total_debt_amount -= deal.debt_amount;
+            });
+         }
+      }
+
+      // Adjust balance
+      adjust_balance( deal.offer_owner, asset( deal.collateral_amount, deal.collateral_asset ) );
+
+      // Notify related parties
+      push_applied_operation( credit_deal_expired_operation (
+                                    deal.id, deal.offer_id, deal.offer_owner, deal.borrower,
+                                    asset( deal.debt_amount, deal.debt_asset ),
+                                    asset( deal.collateral_amount, deal.collateral_asset ),
+                                    deal.fee_rate ) );
+
+      // Remove the deal
+      remove( deal );
+   }
+}
+
 } }

libraries/chain/db_update.cpp

@@ -0,0 +1,6 @@
+// bitshares-core issue #2362 Simple collateralized P2P funding
+#ifndef HARDFORK_CORE_2362_TIME
+// Jan 1 2030, midnight; this is a dummy date until a hardfork date is scheduled
+#define HARDFORK_CORE_2362_TIME (fc::time_point_sec( 1893456000 ))
+#define HARDFORK_CORE_2362_PASSED(now) (now >= HARDFORK_CORE_2362_TIME)
+#endif

libraries/chain/hardfork.d/CORE_2362.hf

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2021 Abit More, and contributors.
+ *
+ * The MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#pragma once
+#include <graphene/chain/evaluator.hpp>
+
+#include <graphene/protocol/credit_offer.hpp>
+
+namespace graphene { namespace chain {
+
+   class credit_offer_object;
+
+   class credit_offer_create_evaluator : public evaluator<credit_offer_create_evaluator>
+   {
+      public:
+         using operation_type = credit_offer_create_operation;
+
+         void_result do_evaluate( const credit_offer_create_operation& op ) const;
+         object_id_type do_apply( const credit_offer_create_operation& op ) const;
+   };
+
+   class credit_offer_delete_evaluator : public evaluator<credit_offer_delete_evaluator>
+   {
+      public:
+         using operation_type = credit_offer_delete_operation;
+
+         void_result do_evaluate( const credit_offer_delete_operation& op );
+         asset do_apply( const credit_offer_delete_operation& op ) const;
+
+         const credit_offer_object* _offer = nullptr;
+   };
+
+   class credit_offer_update_evaluator : public evaluator<credit_offer_update_evaluator>
+   {
+      public:
+         using operation_type = credit_offer_update_operation;
+
+         void_result do_evaluate( const credit_offer_update_operation& op );
+         void_result do_apply( const credit_offer_update_operation& op ) const;
+
+         const credit_offer_object* _offer = nullptr;
+   };
+
+   class credit_offer_accept_evaluator : public evaluator<credit_offer_accept_evaluator>
+   {
+      public:
+         using operation_type = credit_offer_accept_operation;
+
+         void_result do_evaluate( const credit_offer_accept_operation& op );
+         extendable_operation_result do_apply( const credit_offer_accept_operation& op ) const;
+
+         const credit_offer_object* _offer = nullptr;
+         const credit_deal_summary_object* _deal_summary = nullptr;
+   };
+
+   class credit_deal_repay_evaluator : public evaluator<credit_deal_repay_evaluator>
+   {
+      public:
+         using operation_type = credit_deal_repay_operation;
+
+         void_result do_evaluate( const credit_deal_repay_operation& op );
+         extendable_operation_result do_apply( const credit_deal_repay_operation& op ) const;
+
+         const credit_deal_object* _deal = nullptr;
+   };
+
+} } // graphene::chain