static share_type scaled_precision( uint8_t precision )
 {
    FC_ASSERT( precision < 19 );
    return scaled_precision_lut[ precision ];
 }

fc::microseconds ntp_error()
{
  fc::optional<fc::time_point> current_ntp_time = ntp_time();
  FC_ASSERT( current_ntp_time, "We don't have NTP time!" );
  return *current_ntp_time - fc::time_point::now();
}

            void match_orders( std::vector<signed_transaction>& matched,  asset::type quote, asset::type base )
            { try {
               ilog( "match orders.." );
               auto bids = _market_db.get_bids( quote, base );
               auto asks = _market_db.get_asks( quote, base );
               wlog( "asks: ${asks}", ("asks",asks) );
               wlog( "bids: ${bids}", ("bids",bids) );

               fc::optional<trx_output>  ask_change;
               fc::optional<trx_output>  bid_change;
               fc::optional<trx_output>  cover_change;

               address                   bid_payout_address;
               fc::optional<asset>       bid_payout;

               asset                                cover_collat;       
               fc::optional<claim_by_cover_output>  cover_payout;


               signed_transaction market_trx;
               market_trx.timestamp = fc::time_point::now();


               /** asks are sorted from low to high, so we start
                * with the lowest ask, and check to see if there are
                * any bids that are greaterthan or equal to the ask, if
                * there are then either the full bid or full ask will be
                * filled.  If the full bid is filled, then move on to the
                * next bid, and save the leftover ask.  If the left over
                * ask is filled, then move to the next ask.
                *
                * When there are no more pairs that can be matched, exit
                * the loop and any partial payouts are made.  
                */
               auto ask_itr = asks.begin();
               auto bid_itr = bids.rbegin();
               while( ask_itr != asks.end() &&
                      bid_itr != bids.rend() )
               { 
                  trx_output working_ask;
                  trx_output working_bid;

                  if( ask_change ) {  working_ask = *ask_change; }
                  else             {  working_ask = get_output( ask_itr->location );  }

                  if( bid_change ) {  working_bid = *bid_change; }
                  else             {  working_bid = get_output( bid_itr->location);   }

                  claim_by_bid_output bid_claim = working_bid.as<claim_by_bid_output>();

                  if( working_ask.claim_func == claim_by_long )
                  {
                     auto long_claim = working_ask.as<claim_by_long_output>();
                     if( long_claim.ask_price > bid_claim.ask_price )
                     {
                        break; // exit the while loop, no more trades can occur
                     }
                     asset bid_amount = working_bid.get_amount() * bid_claim.ask_price;
                     asset ask_amount = working_ask.get_amount() * long_claim.ask_price;
                     FC_ASSERT( bid_amount.unit == ask_amount.unit );

                     auto  trade_amount = std::min(bid_amount,ask_amount);

                     ilog( "bid amount: ${b} @ ${bp}  ask amount: ${a} @ ${ap}", ("b",bid_amount)("a",ask_amount)("bp",bid_claim.ask_price)("ap",long_claim.ask_price) );

                     asset bid_change_amount   = working_bid.get_amount();
                     bid_change_amount        -= trade_amount * bid_claim.ask_price;
                     ilog( "bid change.. ${c}", ("c",bid_change_amount) );
                     
                     asset ask_change_amount   = working_ask.get_amount();
                     ask_change_amount        -= trade_amount * long_claim.ask_price;
                     ilog( "ask change.. ${c}", ("c",ask_change_amount) );
                      
                     if( ask_change_amount != bid_change_amount  && ask_change_amount != asset(0,working_bid.unit) )
                     {
                       FC_ASSERT( !"At least one of the bid or ask should be completely filled", "", 
                                  ("ask_change_amount",ask_change_amount)("bid_change_amount",bid_change_amount) );
                     }
                     
                     bid_payout_address = bid_claim.pay_address;
                     auto bid_payout_amount  = bid_amount - (bid_change_amount * bid_claim.ask_price);

                     if( bid_payout ) { *bid_payout += bid_payout_amount; }
                     else             { bid_payout   = bid_payout_amount; }

                     if( cover_payout ) 
                     { 
                        cover_payout->payoff_amount += trade_amount.get_rounded_amount();
                        cover_collat                += (trade_amount * long_claim.ask_price)*2;
                     }
                     else
                     {
                        cover_payout                = claim_by_cover_output();
                        cover_payout->owner         = long_claim.pay_address;
                        cover_payout->payoff_unit   = trade_amount.unit;
                        cover_payout->payoff_amount = trade_amount.get_rounded_amount();
                        cover_collat                = (trade_amount * long_claim.ask_price)*2;
                     }

                     if( bid_change_amount != asset(0, working_bid.unit) )
//.........这里部分代码省略.........

void committee_member_create_operation::validate()const
{
   FC_ASSERT( fee.amount >= 0 );
   FC_ASSERT(url.size() < GRAPHENE_MAX_URL_LENGTH );
}

    void domain_buy_operation::evaluate( transaction_evaluation_state& eval_state )
    {
        FC_ASSERT( is_valid_domain( this->domain_name ), "Trying to buy an invalid domain name" );

        auto now = eval_state._current_state->now().sec_since_epoch();
        auto odomain_rec = eval_state._current_state->get_domain_record( this->domain_name );
        /* If it already exists and hasn't expired and you offered enough */
        if( odomain_rec.valid() 
            && odomain_rec->get_true_state(now) == domain_record::in_sale
            && this->price >= odomain_rec->price )
        {
            share_type paid_to_owner = 0;
            for (auto op : eval_state.trx.operations)
            {
                if (op.type == operation_type_enum::deposit_op_type)
                {
                    auto deposit = op.as<deposit_operation>();
                    if (deposit.condition.type == withdraw_condition_types::withdraw_signature_type)
                    {
                        auto condition = deposit.condition.as<withdraw_with_signature>();
                        if (condition.owner == odomain_rec->owner)
                        {
                            paid_to_owner += deposit.amount;
                        }
                    }
                }
            }
            FC_ASSERT( this->price == paid_to_owner );
            FC_ASSERT( paid_to_owner >= odomain_rec->price, "Did not pay enough to previous owner" );
            odomain_rec->state = domain_record::owned;
            odomain_rec->owner = this->new_owner;
            odomain_rec->last_update = eval_state._current_state->now().sec_since_epoch();
            eval_state._current_state->store_domain_record( *odomain_rec );
            return;
        }
        /* Domain does not exist or is not for sale or is too expensive, so this is an offer */
        else
        {
            auto balance = eval_state._current_state->get_domain_offer(this->new_owner);
            FC_ASSERT( !balance.valid(), "Trying to make an offer with an offer ID that already exists");
            FC_ASSERT(this->price > 0, "Price must be greater than 0 when you offer" );
            bool found_deposit = false;
            for ( auto op : eval_state.trx.operations )
            {
                if (op.type == operation_type_enum::deposit_op_type)
                {
                    auto deposit = op.as<deposit_operation>();
                    if( deposit.condition.type == withdraw_condition_types::withdraw_domain_offer_type )
                    {
                        auto condition = deposit.condition.as<bts::blockchain::withdraw_domain_offer>();
                        FC_ASSERT( condition.domain_name == this->domain_name, "condition does not match offer op" );
                        FC_ASSERT( condition.price == this->price, "condition does not match offer op" );
                        FC_ASSERT( condition.owner == this->new_owner, "condition does not match offer op" );
                        found_deposit = true;
                    }
                }
            }
            FC_ASSERT( found_deposit, "Did not find a deposit on this domain offer transaction" );
            auto offer_key = offer_index_key();
            offer_key.price = this->price;
            offer_key.domain_name = this->domain_name;
            offer_key.offer_address = this->new_owner;
            offer_key.offer_time = eval_state._current_state->now().sec_since_epoch();
            ulog( "about to store offer\n" );
            eval_state._current_state->store_domain_offer( offer_key );
        }
    }

std::string asset::symbol_name() const {
    auto a = (const char *)&symbol;
    FC_ASSERT(a[7] == 0);
    return &a[1];
}

 friend bool operator < ( const asset& a, const asset& b )
 {
    FC_ASSERT( a.symbol == b.symbol );
    return std::tie(a.amount,a.symbol) < std::tie(b.amount,b.symbol);
 }

 WithdrawType as()const
 {
    FC_ASSERT( type == WithdrawType::type, "", ("type",type)("WithdrawType",WithdrawType::type) );
    return fc::raw::unpack<WithdrawType>(data);
 }

 optional<extended_private_key> wallet_db::get_master_key( const fc::sha512& password    )const
 {
    FC_ASSERT( wallet_master_key );
    return wallet_master_key->decrypt_key( password );
 }

 void              validate()const
 {
    FC_ASSERT( fee.amount >= 0 );
    FC_ASSERT( amount.amount > 0 );
 }

 OperationType as()const
 {
    FC_ASSERT( (operation_type_enum)type == OperationType::type, "", ("type",type)("OperationType",OperationType::type) );
    return fc::raw::unpack<OperationType>(data);
 }

 void validate()const { FC_ASSERT( fee.amount >= 0 ); FC_ASSERT(new_listing < 0x4); }

price market_order::get_highest_cover_price()const
{ try {
  FC_ASSERT( type == cover_order );
  return asset( state.balance, market_index.order_price.quote_asset_id ) / asset( *collateral );
} FC_CAPTURE_AND_RETHROW() }

 fc::api<network_broadcast_api> login_api::network_broadcast()const
 {
    FC_ASSERT(_network_broadcast_api);
    return *_network_broadcast_api;
 }

    void message_oriented_connection_impl::read_loop()
    {
      VERIFY_CORRECT_THREAD();
      const unsigned int BUFFER_SIZE = 16;
      static_assert(BUFFER_SIZE >= sizeof(message_header), "insufficient buffer");
      const int LEFTOVER = BUFFER_SIZE - sizeof(message_header);

      _connected_time = fc::time_point::now();

      fc::oexception exception_to_rethrow;
      bool call_on_connection_closed = false;

      try
      {
        message m;
        while( true )
        {
          char buffer[BUFFER_SIZE];
          _sock.read(buffer, BUFFER_SIZE);
          _bytes_received += BUFFER_SIZE;
          memcpy((char*)&m, buffer, sizeof(message_header));

          FC_ASSERT( m.size <= MAX_MESSAGE_SIZE, "", ("m.size",m.size)("MAX_MESSAGE_SIZE",MAX_MESSAGE_SIZE) );

          size_t remaining_bytes_with_padding = 16 * ((m.size - LEFTOVER + 15) / 16);
          m.data.resize(LEFTOVER + remaining_bytes_with_padding); //give extra 16 bytes to allow for padding added in send call
          std::copy(buffer + sizeof(message_header), buffer + sizeof(buffer), m.data.begin());
          if (remaining_bytes_with_padding)
          {
            _sock.read(&m.data[LEFTOVER], remaining_bytes_with_padding);
            _bytes_received += remaining_bytes_with_padding;
          }
          m.data.resize(m.size); // truncate off the padding bytes

          _last_message_received_time = fc::time_point::now();

          try
          {
            // message handling errors are warnings...
            _delegate->on_message(_self, m);
          }
          /// Dedicated catches needed to distinguish from general fc::exception
          catch ( const fc::canceled_exception& e ) { throw e; }
          catch ( const fc::eof_exception& e ) { throw e; }
          catch ( const fc::exception& e)
          {
            /// Here loop should be continued so exception should be just caught locally.
            wlog( "message transmission failed ${er}", ("er", e.to_detail_string() ) );
            throw;
          }
        }
      }
      catch ( const fc::canceled_exception& e )
      {
        wlog( "caught a canceled_exception in read_loop.  this should mean we're in the process of deleting this object already, so there's no need to notify the delegate: ${e}", ("e", e.to_detail_string() ) );
        throw;
      }
      catch ( const fc::eof_exception& e )
      {
        wlog( "disconnected ${e}", ("e", e.to_detail_string() ) );
        call_on_connection_closed = true;
      }
      catch ( const fc::exception& e )
      {
        elog( "disconnected ${er}", ("er", e.to_detail_string() ) );
        call_on_connection_closed = true;
        exception_to_rethrow = fc::unhandled_exception(FC_LOG_MESSAGE(warn, "disconnected: ${e}", ("e", e.to_detail_string())));
      }
      catch ( const std::exception& e )
      {
        elog( "disconnected ${er}", ("er", e.what() ) );
        call_on_connection_closed = true;
        exception_to_rethrow = fc::unhandled_exception(FC_LOG_MESSAGE(warn, "disconnected: ${e}", ("e", e.what())));
      }
      catch ( ... )
      {
        elog( "unexpected exception" );
        call_on_connection_closed = true;
        exception_to_rethrow = fc::unhandled_exception(FC_LOG_MESSAGE(warn, "disconnected: ${e}", ("e", fc::except_str())));
      }

      if (call_on_connection_closed)
        _delegate->on_connection_closed(_self);

      if (exception_to_rethrow)
        throw *exception_to_rethrow;
    }

   void chain_parameters::validate()const
   {
      current_fees->validate();
      FC_ASSERT( reserve_percent_of_fee <= GRAPHENE_100_PERCENT );
      FC_ASSERT( network_percent_of_fee <= GRAPHENE_100_PERCENT );
      FC_ASSERT( lifetime_referrer_percent_of_fee <= GRAPHENE_100_PERCENT );
      FC_ASSERT( network_percent_of_fee + lifetime_referrer_percent_of_fee <= GRAPHENE_100_PERCENT );

      FC_ASSERT( block_interval >= GRAPHENE_MIN_BLOCK_INTERVAL );
      FC_ASSERT( block_interval <= GRAPHENE_MAX_BLOCK_INTERVAL );
      FC_ASSERT( block_interval > 0 );
      FC_ASSERT( maintenance_interval > block_interval,
                 "Maintenance interval must be longer than block interval" );
      FC_ASSERT( maintenance_interval % block_interval == 0,
                 "Maintenance interval must be a multiple of block interval" );
      FC_ASSERT( maximum_transaction_size >= GRAPHENE_MIN_TRANSACTION_SIZE_LIMIT,
                 "Transaction size limit is too low" );
      FC_ASSERT( maximum_block_size >= GRAPHENE_MIN_BLOCK_SIZE_LIMIT,
                 "Block size limit is too low" );
      FC_ASSERT( maximum_time_until_expiration > block_interval,
                 "Maximum transaction expiration time must be greater than a block interval" );
      FC_ASSERT( maximum_proposal_lifetime - committee_proposal_review_period > block_interval,
                 "Committee proposal review period must be less than the maximum proposal lifetime" );
   }

 bigint::bigint( const std::vector<char>& bige ) {
   n = BN_bin2bn( (const unsigned char*)bige.data(), bige.size(), NULL );
   FC_ASSERT( n != nullptr );
 }

 asset& operator += ( const asset& o )
 {
    FC_ASSERT( asset_id == o.asset_id );
    amount += o.amount;
    return *this;
 }

 friend asset operator + ( const asset& a, const asset& b )
 {
    FC_ASSERT( a.asset_id == b.asset_id );
    return asset( a.amount + b.amount, a.asset_id );
 }