Method delegate_loop

src/Chain/libraries/client/Client.cpp:640–708

                return _wallet->delete_account(account_name);
            }
            void ClientImpl::delegate_loop() {
                if (!_wallet->is_open() || _wallet->is_locked())
                    return;
                    
                vector<WalletAccountEntry> enabled_delegates = _wallet->get_my_delegates(enabled_delegate_status);
                
                if (enabled_delegates.empty())
                    return;
                    
                const auto now = blockchain::now();
                ilog("Starting delegate loop at time: ${t}", ("t", now));
                _chain_db->_verify_transaction_signatures = true;
                
                if (_delegate_loop_first_run) {
                    set_target_connections(ALP_NET_DELEGATE_DESIRED_CONNECTIONS);
                    _delegate_loop_first_run = false;
                }
                
                _chain_db->generating_block = false;
                const auto next_block_time = _wallet->get_next_producible_block_timestamp(enabled_delegates);
                
                if (next_block_time.valid()) {
                    _wallet->_generating_block = true;
                    _chain_db->generating_block = true;
                    ilog("Producing block at time: ${t}", ("t", *next_block_time));
                    
                    if (*next_block_time <= now) {
                        try {
                            _delegate_config.validate();
                            FC_ASSERT(network_get_connection_count() >= _delegate_config.network_min_connection_count,
                                      "Client must have ${count} connections before you may produce blocks!",
                                      ("count", _delegate_config.network_min_connection_count));
                            FC_ASSERT(_wallet->is_unlocked(), "Wallet must be unlocked to produce blocks!");
                            FC_ASSERT((now - *next_block_time) < fc::seconds(ALP_BLOCKCHAIN_BLOCK_INTERVAL_SEC),
                                      "You missed your slot at time: ${t}!", ("t", *next_block_time));
                            FullBlock next_block = _chain_db->generate_block(*next_block_time, _delegate_config);
                            _wallet->sign_block(next_block);
                            on_new_block(next_block, next_block.id(), false);
                            _p2p_node->broadcast(BlockMessage(next_block));
                            ilog("Produced block #${n}!", ("n", next_block.block_num));
                            
                        } catch (const fc::canceled_exception&) {
                            throw;
                            
                        } catch (const fc::exception& e) {
                            _exception_db.store(e);
                        }
                    }
                }
                
                uint32_t slot_number = blockchain::get_slot_number(now);
                time_point_sec next_slot_time = blockchain::get_slot_start_time(slot_number + 1);
                ilog("Rescheduling delegate loop for time: ${t}", ("t", next_slot_time));
                time_point scheduled_time = next_slot_time;
                
                if (blockchain::ntp_time().valid())
                    scheduled_time -= blockchain::ntp_error();