import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
/**
 * Get the exchange rate from Bitstamp. As a trader can do a tradeback, we need the specific exchange. The exchange
 * rate for the fiat currency is then calculated in a second step.
 * @return
 * @throws IOException
 */
public ForexDTO getBitstampCurrentRateBTCUSD() {
	ForexDTO forexDTO = new ForexDTO();

	try {
		Ticker ticker = MARKET_DATA_SERVICE.getTicker(BTC_USD);
		forexDTO.setCurrencyFrom(BTC);
		forexDTO.setCurrencyTo(USD);
		forexDTO.setRate(ticker.getAsk().add(ticker.getBid()).divide(BigDecimal.valueOf(2)));
		forexDTO.setUpdatedAt(ticker.getTimestamp());

	} catch (IOException exception) {
		throw new CoinbleskInternalError("Bitstamp currency rate currently not available.");
	}

	return forexDTO;
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
/**
 * Calculates bid target between current ask price and last price
 */
private BigDecimal getTargetBid(Ticker ticker) {
    if (ticker.getAsk().compareTo(ticker.getLast()) < 0) {
        return ticker.getAsk();
    }

    // Factor with regards to ask price
    BigDecimal balance = BigDecimal.ZERO;
    return ticker.getAsk().add(balance.multiply(ticker.getLast().subtract(ticker.getAsk())));
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
/**
 * Updates the Tickers for a specific Exchange.
 *
 * @param reference The reference to the Exchange.
 * @return The cached Tickers.
 */
@SuppressWarnings("WeakerAccess")
@Async
public CompletableFuture<Map<CurrencyPair, Ticker>> updateExchangeCache(ExchangeReference reference) {
    // Create a cache for the Exchange.
    Map<CurrencyPair, Ticker> exchangeCache = new HashMap<>();

    // Get the MarketDataService for the Exchange.
    MarketDataService marketDataService = reference.getMarketDataService();

    // Try the Currency Pairs.
    for (CurrencyPair currencyPair : TickerCacheService.CURRENCY_PAIRS) {
        Ticker ticker = null;

        // Try to get the Ticker for this CurrencyPair.
        try {
            ticker = marketDataService.getTicker(currencyPair);
        } catch (Exception ignored) {
        }

        // If the Ticker was found, add it to the cache.
        if (ticker != null) {
            exchangeCache.put(currencyPair, ticker);
            logService.logDebug(getClass(), reference.name() + ": " + currencyPair.toString() + ": Success");
        } else {
            logService.logDebug(getClass(), reference.name() + ": " + currencyPair.toString() + ": Fail");
        }
    }

    return CompletableFuture.completedFuture(exchangeCache);
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
private ExchangeRateChange buildExchangeRateChange(CurrencyUnitPair pair, Ticker ticker) {
    Date date = ticker.getTimestamp();
    // Not all exchanges provide a timestamp, default to 0 if it is null
    long milliseconds = (date != null) ? date.getTime() : 0;

    return new ExchangeRateChange(buildExchangeRate(pair, ticker), milliseconds);
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
private ExchangeRate buildExchangeRate(CurrencyUnitPair pair, Ticker ticker) {
    return new ExchangeRateBuilder(name, RateType.DEFERRED)
            .setBase(pair.getBase())
            .setTerm(pair.getTarget())
            .setFactor(DefaultNumberValue.of(ticker.getLast()))
            .build();
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
@Override
public Ticker getTicker(CurrencyPair pair) throws IOException {
    LOGGER.debug("Getting ticker for pair: {}", pair);
    return marketDataService.getTicker(pair);
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
public TickerDto(String exchangeName, Ticker ticker) {
    this.exchangeName = exchangeName;
    this.ticker = ticker;
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
public Ticker getTicker() {
    return ticker;
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
public void setTicker(Ticker ticker) {
    this.ticker = ticker;
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
public BigDecimal getBTCUSD() throws IOException {
    Ticker ticker = marketDataServiceKraken.getTicker(CurrencyPair.BTC_USD);
    return ticker.getLast();
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
public BigDecimal getETHUSD() throws IOException {
    Ticker ticker = marketDataServiceKraken.getTicker(CurrencyPair.ETH_USD);
    return ticker.getLast();
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
public BigDecimal getBTCUSDBitfinex() throws IOException {
    Ticker ticker = marketDataServiceBitfinex.getTicker(CurrencyPair.BTC_USD);
    return ticker.getLast();
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
public BigDecimal getIOTAUSDBitfinex() throws IOException {
    Ticker ticker = marketDataServiceBitfinex.getTicker(IOTA_USD);
    return ticker.getLast();
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
public BigDecimal getETHUSDBitfinex() throws IOException {
    Ticker ticker = marketDataServiceBitfinex.getTicker(CurrencyPair.ETH_USD);
    return ticker.getLast();
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
private void notifyObserver(ExchangeRateObserver observer, CurrencyUnitPair pair, Ticker ticker) {
    observer.onExchangeRateChange(buildExchangeRateChange(pair, ticker));
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
/**
 * Get Ticker for given pair.
 *
 * @param pair Pair as str, format: BTC_ETC
 * @return the ticker
 *
 * @throws IOException if any error occur while contacting the exchange
 */
Ticker getTicker(CurrencyPair pair) throws IOException;
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
/**
 * Determines the price of a CurrencyPair for an Exchange.
 *
 * @param exchangeReference The Exchange.
 * @param currencyPair      The CurrencyPair.
 * @return The price of the CurrencyPair on the Exchange, or null if the CurrencyPair is not on the Exchange.
 */
public BigDecimal getPrice(ExchangeReference exchangeReference, CurrencyPair currencyPair) {
    Ticker ticker = this.tickerCacheService.getTicker(exchangeReference, currencyPair);
    return ticker != null ? ticker.getBid() : null;
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
/**
 * Retrieves the cached Ticker for the given Exchange and Currency Pair.
 *
 * @param exchangeReference The ExchangeReference for the desired Exchange.
 * @param currencyPair      The CurrencyPair of the Ticker.
 * @return The Ticker, if one exists.
 */
public Ticker getTicker(ExchangeReference exchangeReference, CurrencyPair currencyPair) {
    return TICKER_CACHE.get(exchangeReference).get(currencyPair);
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
/**
 * Get Ticker from the UpdateableValueLatch
 * @return ticker object
 * @throws InterruptedException thread was interrupted by another thread
 * @throws TimeoutException should only happen if first request times out
 */
Ticker getTicker() throws InterruptedException, TimeoutException {
    return tickerLatch.getValue();
}
 

import org.knowm.xchange.dto.marketdata.Ticker; //导入依赖的package包/类
/**
 * Set the ticker object, called from polling method
 * @param ticker ticker object
 */
void setTicker(Ticker ticker) {
    tickerLatch.setValue(ticker);
}