PageRenderTime 62ms CodeModel.GetById 28ms RepoModel.GetById 0ms app.codeStats 1ms

/xchange-ripple/src/test/java/org/knowm/xchange/ripple/RippleAdaptersTest.java

http://github.com/timmolter/XChange
Java | 477 lines | 382 code | 68 blank | 27 comment | 0 complexity | b0647f75a3dabc9ef7ed846135af20c1 MD5 | raw file
  1. package org.knowm.xchange.ripple;
  2. import static org.assertj.core.api.Assertions.assertThat;
  3. import com.fasterxml.jackson.core.JsonParseException;
  4. import com.fasterxml.jackson.databind.JsonMappingException;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.math.BigDecimal;
  9. import java.math.RoundingMode;
  10. import java.text.ParseException;
  11. import org.junit.Test;
  12. import org.knowm.xchange.currency.Currency;
  13. import org.knowm.xchange.currency.CurrencyPair;
  14. import org.knowm.xchange.dto.Order.OrderType;
  15. import org.knowm.xchange.dto.account.AccountInfo;
  16. import org.knowm.xchange.dto.account.Balance;
  17. import org.knowm.xchange.dto.account.Wallet;
  18. import org.knowm.xchange.dto.marketdata.OrderBook;
  19. import org.knowm.xchange.dto.trade.LimitOrder;
  20. import org.knowm.xchange.dto.trade.OpenOrders;
  21. import org.knowm.xchange.dto.trade.UserTrade;
  22. import org.knowm.xchange.ripple.dto.account.ITransferFeeSource;
  23. import org.knowm.xchange.ripple.dto.account.RippleAccountBalances;
  24. import org.knowm.xchange.ripple.dto.account.RippleAccountSettings;
  25. import org.knowm.xchange.ripple.dto.marketdata.RippleOrderBook;
  26. import org.knowm.xchange.ripple.dto.trade.IRippleTradeTransaction;
  27. import org.knowm.xchange.ripple.dto.trade.RippleAccountOrders;
  28. import org.knowm.xchange.ripple.dto.trade.RippleLimitOrder;
  29. import org.knowm.xchange.ripple.dto.trade.RippleOrderTransaction;
  30. import org.knowm.xchange.ripple.dto.trade.RipplePaymentTransaction;
  31. import org.knowm.xchange.ripple.dto.trade.RippleUserTrade;
  32. import org.knowm.xchange.ripple.service.params.RippleMarketDataParams;
  33. import org.knowm.xchange.ripple.service.params.RippleTradeHistoryParams;
  34. import org.knowm.xchange.service.trade.params.TradeHistoryParams;
  35. public class RippleAdaptersTest implements ITransferFeeSource {
  36. @Test
  37. public void adaptAccountInfoTest() throws IOException {
  38. // Read in the JSON from the example resources
  39. final InputStream is =
  40. getClass()
  41. .getResourceAsStream(
  42. "/org/knowm/xchange/ripple/dto/account/example-account-balances.json");
  43. // Use Jackson to parse it
  44. final ObjectMapper mapper = new ObjectMapper();
  45. final RippleAccountBalances rippleAccount = mapper.readValue(is, RippleAccountBalances.class);
  46. // Convert to xchange object and check field values
  47. final AccountInfo account = RippleAdapters.adaptAccountInfo(rippleAccount, "username");
  48. assertThat(account.getWallets()).hasSize(2);
  49. assertThat(account.getUsername()).isEqualTo("username");
  50. assertThat(account.getTradingFee()).isEqualTo(BigDecimal.ZERO);
  51. final Wallet counterWallet = account.getWallet("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B");
  52. assertThat(counterWallet.getId()).isEqualTo("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B");
  53. assertThat(counterWallet.getBalances()).hasSize(2);
  54. final Balance btcBalance = counterWallet.getBalance(Currency.BTC);
  55. assertThat(btcBalance.getTotal()).isEqualTo("0.038777349225374");
  56. assertThat(btcBalance.getCurrency()).isEqualTo(Currency.BTC);
  57. final Balance usdBalance = counterWallet.getBalance(Currency.USD);
  58. assertThat(usdBalance.getTotal()).isEqualTo("10");
  59. assertThat(usdBalance.getCurrency()).isEqualTo(Currency.USD);
  60. final Wallet mainWallet = account.getWallet("main");
  61. assertThat(mainWallet.getBalances()).hasSize(1);
  62. final Balance xrpBalance = mainWallet.getBalance(Currency.XRP);
  63. assertThat(xrpBalance.getTotal()).isEqualTo("861.401578");
  64. assertThat(xrpBalance.getCurrency()).isEqualTo(Currency.XRP);
  65. }
  66. @Test
  67. public void adaptOrderBookTest() throws IOException {
  68. // Read in the JSON from the example resources
  69. final InputStream is =
  70. getClass()
  71. .getResourceAsStream(
  72. "/org/knowm/xchange/ripple/dto/marketdata/example-order-book.json");
  73. final CurrencyPair currencyPair = CurrencyPair.XRP_BTC;
  74. // Test data uses Bitstamp issued BTC
  75. final RippleMarketDataParams params = new RippleMarketDataParams();
  76. params.setCounterCounterparty("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B");
  77. // Use Jackson to parse it
  78. final ObjectMapper mapper = new ObjectMapper();
  79. final RippleOrderBook rippleOrderBook = mapper.readValue(is, RippleOrderBook.class);
  80. // Convert to xchange object and check field values
  81. final OrderBook orderBook =
  82. RippleAdapters.adaptOrderBook(rippleOrderBook, params, currencyPair);
  83. assertThat(orderBook.getBids()).hasSize(10);
  84. assertThat(orderBook.getAsks()).hasSize(10);
  85. final LimitOrder lastBid = orderBook.getBids().get(9);
  86. assertThat(lastBid).isInstanceOf(RippleLimitOrder.class);
  87. assertThat(lastBid.getCurrencyPair()).isEqualTo(currencyPair);
  88. assertThat(((RippleLimitOrder) lastBid).getCounterCounterparty())
  89. .isEqualTo("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B");
  90. assertThat(lastBid.getType()).isEqualTo(OrderType.BID);
  91. assertThat(lastBid.getId()).isEqualTo("1303704");
  92. assertThat(lastBid.getOriginalAmount()).isEqualTo("66314.537782");
  93. assertThat(lastBid.getLimitPrice()).isEqualTo("0.00003317721777288062");
  94. final LimitOrder firstAsk = orderBook.getAsks().get(0);
  95. assertThat(firstAsk).isInstanceOf(RippleLimitOrder.class);
  96. assertThat(firstAsk.getCurrencyPair()).isEqualTo(currencyPair);
  97. assertThat(((RippleLimitOrder) firstAsk).getCounterCounterparty())
  98. .isEqualTo("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B");
  99. assertThat(firstAsk.getType()).isEqualTo(OrderType.ASK);
  100. assertThat(firstAsk.getId()).isEqualTo("1011310");
  101. assertThat(firstAsk.getOriginalAmount()).isEqualTo("35447.914936");
  102. assertThat(firstAsk.getLimitPrice()).isEqualTo("0.00003380846624897726");
  103. }
  104. @Test
  105. public void adaptOpenOrdersTest() throws JsonParseException, JsonMappingException, IOException {
  106. final RippleExchange exchange = new RippleExchange();
  107. final int roundingScale = exchange.getRoundingScale();
  108. // Read in the JSON from the example resources
  109. final InputStream is =
  110. getClass()
  111. .getResourceAsStream("/org/knowm/xchange/ripple/dto/trade/example-account-orders.json");
  112. final ObjectMapper mapper = new ObjectMapper();
  113. final RippleAccountOrders response = mapper.readValue(is, RippleAccountOrders.class);
  114. // Convert to XChange orders
  115. final OpenOrders orders = RippleAdapters.adaptOpenOrders(response, roundingScale);
  116. assertThat(orders.getOpenOrders()).hasSize(12);
  117. final LimitOrder firstOrder = orders.getOpenOrders().get(0);
  118. assertThat(firstOrder).isInstanceOf(RippleLimitOrder.class);
  119. assertThat(firstOrder.getCurrencyPair()).isEqualTo(CurrencyPair.XRP_BTC);
  120. assertThat(((RippleLimitOrder) firstOrder).getCounterCounterparty())
  121. .isEqualTo("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B");
  122. assertThat(firstOrder.getId()).isEqualTo("5");
  123. assertThat(firstOrder.getLimitPrice()).isEqualTo("0.00003226");
  124. assertThat(firstOrder.getTimestamp()).isNull();
  125. assertThat(firstOrder.getOriginalAmount()).isEqualTo("1");
  126. assertThat(firstOrder.getType()).isEqualTo(OrderType.BID);
  127. final LimitOrder secondOrder = orders.getOpenOrders().get(1);
  128. assertThat(secondOrder).isInstanceOf(RippleLimitOrder.class);
  129. assertThat(secondOrder.getCurrencyPair()).isEqualTo(CurrencyPair.XRP_BTC);
  130. assertThat(((RippleLimitOrder) secondOrder).getCounterCounterparty())
  131. .isEqualTo("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B");
  132. assertThat(secondOrder.getId()).isEqualTo("7");
  133. // Price = 15159.38551342023 / 123.123456
  134. assertThat(secondOrder.getLimitPrice())
  135. .isEqualTo("123.12345677999998635515884154518859509596611713043533");
  136. assertThat(secondOrder.getTimestamp()).isNull();
  137. assertThat(secondOrder.getOriginalAmount()).isEqualTo("123.123456");
  138. assertThat(secondOrder.getType()).isEqualTo(OrderType.ASK);
  139. }
  140. @Override
  141. public BigDecimal getTransferFeeRate(final String address) throws IOException {
  142. final InputStream is =
  143. getClass()
  144. .getResourceAsStream(
  145. String.format(
  146. "/org/knowm/xchange/ripple/dto/account/example-account-settings-%s.json",
  147. address));
  148. final ObjectMapper mapper = new ObjectMapper();
  149. return mapper.readValue(is, RippleAccountSettings.class).getSettings().getTransferFeeRate();
  150. }
  151. @Test
  152. public void adaptTrade_BuyXRP_SellBTC()
  153. throws JsonParseException, JsonMappingException, IOException, ParseException {
  154. final RippleExchange exchange = new RippleExchange();
  155. final int roundingScale = exchange.getRoundingScale();
  156. // Read the trade JSON from the example resources
  157. final InputStream is =
  158. getClass()
  159. .getResourceAsStream(
  160. "/org/knowm/xchange/ripple/dto/trade/example-trade-buyXRP-sellBTC.json");
  161. final ObjectMapper mapper = new ObjectMapper();
  162. final RippleOrderTransaction response = mapper.readValue(is, RippleOrderTransaction.class);
  163. final RippleTradeHistoryParams params = new RippleTradeHistoryParams();
  164. params.addPreferredCounterCurrency(Currency.BTC);
  165. final UserTrade trade = RippleAdapters.adaptTrade(response, params, this, roundingScale);
  166. assertThat(trade.getCurrencyPair()).isEqualTo(CurrencyPair.XRP_BTC);
  167. assertThat(trade.getFeeAmount()).isEqualTo("0.012");
  168. assertThat(trade.getFeeCurrency()).isEqualTo(Currency.XRP);
  169. assertThat(trade.getId())
  170. .isEqualTo("0000000000000000000000000000000000000000000000000000000000000000");
  171. assertThat(trade.getOrderId()).isEqualTo("1010");
  172. // Price = 0.000029309526038 * 0.998
  173. assertThat(trade.getPrice())
  174. .isEqualTo(
  175. new BigDecimal("0.000029250906985924")
  176. .setScale(roundingScale, RoundingMode.HALF_UP)
  177. .stripTrailingZeros());
  178. assertThat(trade.getTimestamp()).isEqualTo(RippleExchange.ToDate("2000-00-00T00:00:00.000Z"));
  179. assertThat(trade.getOriginalAmount()).isEqualTo("1");
  180. assertThat(trade.getType()).isEqualTo(OrderType.BID);
  181. assertThat(trade).isInstanceOf(RippleUserTrade.class);
  182. final RippleUserTrade ripple = (RippleUserTrade) trade;
  183. assertThat(ripple.getBaseCounterparty()).isEmpty();
  184. assertThat(ripple.getBaseTransferFee()).isZero();
  185. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(Currency.XRP);
  186. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().base);
  187. assertThat(ripple.getCounterCounterparty()).isEqualTo("rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q");
  188. // Transfer fee = 0.000029309526038 * 0.002
  189. assertThat(ripple.getCounterTransferFee()).isEqualTo("0.000000058619052076");
  190. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(Currency.BTC);
  191. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().counter);
  192. }
  193. @Test
  194. public void adaptTrade_SellBTC_BuyXRP()
  195. throws JsonParseException, JsonMappingException, IOException, ParseException {
  196. final RippleExchange exchange = new RippleExchange();
  197. final int roundingScale = exchange.getRoundingScale();
  198. // Read the trade JSON from the example resources
  199. final InputStream is =
  200. getClass()
  201. .getResourceAsStream(
  202. "/org/knowm/xchange/ripple/dto/trade/example-trade-buyXRP-sellBTC.json");
  203. final ObjectMapper mapper = new ObjectMapper();
  204. final RippleOrderTransaction response = mapper.readValue(is, RippleOrderTransaction.class);
  205. final RippleTradeHistoryParams params = new RippleTradeHistoryParams();
  206. params.addPreferredBaseCurrency(Currency.BTC);
  207. final UserTrade trade = RippleAdapters.adaptTrade(response, params, this, roundingScale);
  208. assertThat(trade.getCurrencyPair()).isEqualTo(CurrencyPair.BTC_XRP);
  209. assertThat(trade.getFeeAmount()).isEqualTo("0.012");
  210. assertThat(trade.getFeeCurrency()).isEqualTo(Currency.XRP);
  211. assertThat(trade.getId())
  212. .isEqualTo("0000000000000000000000000000000000000000000000000000000000000000");
  213. assertThat(trade.getOrderId()).isEqualTo("1010");
  214. // Price = 1.0 / (0.000029309526038 * 0.998)
  215. assertThat(trade.getPrice())
  216. .isEqualTo(
  217. new BigDecimal("34186.97411609205306550363511634115030681332485583111528")
  218. .setScale(roundingScale, RoundingMode.HALF_UP));
  219. assertThat(trade.getTimestamp()).isEqualTo(RippleExchange.ToDate("2000-00-00T00:00:00.000Z"));
  220. // Quantity = 0.000029309526038 * 0.998
  221. assertThat(trade.getOriginalAmount()).isEqualTo("0.000029250906985924");
  222. assertThat(trade.getType()).isEqualTo(OrderType.ASK);
  223. assertThat(trade).isInstanceOf(RippleUserTrade.class);
  224. final RippleUserTrade ripple = (RippleUserTrade) trade;
  225. assertThat(ripple.getBaseCounterparty()).isEqualTo("rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q");
  226. // Transfer fee = 0.000029309526038 * 0.002
  227. assertThat(ripple.getBaseTransferFee()).isEqualTo("0.000000058619052076");
  228. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(Currency.BTC);
  229. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().base);
  230. assertThat(ripple.getCounterCounterparty()).isEmpty();
  231. assertThat(ripple.getCounterTransferFee()).isZero();
  232. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(Currency.XRP);
  233. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().counter);
  234. }
  235. @Test
  236. public void adaptTrade_SellXRP_BuyBTC()
  237. throws JsonParseException, JsonMappingException, IOException, ParseException {
  238. final RippleExchange exchange = new RippleExchange();
  239. final int roundingScale = exchange.getRoundingScale();
  240. // Read the trade JSON from the example resources
  241. final InputStream is =
  242. getClass()
  243. .getResourceAsStream(
  244. "/org/knowm/xchange/ripple/dto/trade/example-trade-sellXRP-buyBTC.json");
  245. final ObjectMapper mapper = new ObjectMapper();
  246. final IRippleTradeTransaction response = mapper.readValue(is, RippleOrderTransaction.class);
  247. final RippleTradeHistoryParams params = new RippleTradeHistoryParams();
  248. params.setCurrencyPair(CurrencyPair.XRP_BTC);
  249. final UserTrade trade = RippleAdapters.adaptTrade(response, params, this, roundingScale);
  250. assertThat(trade.getCurrencyPair()).isEqualTo(CurrencyPair.XRP_BTC);
  251. assertThat(trade.getFeeAmount()).isEqualTo("0.012");
  252. assertThat(trade.getFeeCurrency()).isEqualTo(Currency.XRP);
  253. assertThat(trade.getId())
  254. .isEqualTo("1111111111111111111111111111111111111111111111111111111111111111");
  255. assertThat(trade.getOrderId()).isEqualTo("1111");
  256. assertThat(trade.getPrice())
  257. .isEqualTo(
  258. new BigDecimal("0.000028572057152")
  259. .setScale(roundingScale, RoundingMode.HALF_UP)
  260. .stripTrailingZeros());
  261. assertThat(trade.getTimestamp()).isEqualTo(RippleExchange.ToDate("2011-11-11T11:11:11.111Z"));
  262. assertThat(trade.getOriginalAmount()).isEqualTo("1");
  263. assertThat(trade.getType()).isEqualTo(OrderType.ASK);
  264. assertThat(trade).isInstanceOf(RippleUserTrade.class);
  265. final RippleUserTrade ripple = (RippleUserTrade) trade;
  266. assertThat(ripple.getBaseCounterparty()).isEmpty();
  267. assertThat(ripple.getBaseTransferFee()).isZero();
  268. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(Currency.XRP);
  269. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().base);
  270. assertThat(ripple.getCounterCounterparty()).isEqualTo("rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q");
  271. assertThat(ripple.getCounterTransferFee()).isZero();
  272. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(Currency.BTC);
  273. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().counter);
  274. // make sure that if the IRippleTradeTransaction is adapted again it returns the same values
  275. final UserTrade trade2 = RippleAdapters.adaptTrade(response, params, this, roundingScale);
  276. assertThat(trade2.getCurrencyPair()).isEqualTo(trade.getCurrencyPair());
  277. assertThat(trade2.getFeeAmount()).isEqualTo(trade.getFeeAmount());
  278. assertThat(trade2.getFeeCurrency()).isEqualTo(trade.getFeeCurrency());
  279. assertThat(trade2.getId()).isEqualTo(trade.getId());
  280. assertThat(trade2.getOrderId()).isEqualTo(trade.getOrderId());
  281. assertThat(trade2.getPrice()).isEqualTo(trade.getPrice());
  282. assertThat(trade2.getTimestamp()).isEqualTo(trade.getTimestamp());
  283. assertThat(trade2.getOriginalAmount()).isEqualTo(trade.getOriginalAmount());
  284. assertThat(trade2.getType()).isEqualTo(trade.getType());
  285. }
  286. @Test
  287. public void adaptTrade_BuyBTC_SellXRP()
  288. throws JsonParseException, JsonMappingException, IOException, ParseException {
  289. final RippleExchange exchange = new RippleExchange();
  290. final int roundingScale = exchange.getRoundingScale();
  291. // Read the trade JSON from the example resources
  292. final InputStream is =
  293. getClass()
  294. .getResourceAsStream(
  295. "/org/knowm/xchange/ripple/dto/trade/example-trade-sellXRP-buyBTC.json");
  296. final ObjectMapper mapper = new ObjectMapper();
  297. final RippleOrderTransaction response = mapper.readValue(is, RippleOrderTransaction.class);
  298. final RippleTradeHistoryParams params = new RippleTradeHistoryParams();
  299. params.addPreferredBaseCurrency(Currency.BTC);
  300. final UserTrade trade = RippleAdapters.adaptTrade(response, params, this, roundingScale);
  301. assertThat(trade.getCurrencyPair()).isEqualTo(CurrencyPair.BTC_XRP);
  302. assertThat(trade.getFeeAmount()).isEqualTo("0.012");
  303. assertThat(trade.getFeeCurrency()).isEqualTo(Currency.XRP);
  304. assertThat(trade.getId())
  305. .isEqualTo("1111111111111111111111111111111111111111111111111111111111111111");
  306. assertThat(trade.getOrderId()).isEqualTo("1111");
  307. // Price = 1.0 / 0.000028572057152
  308. assertThat(trade.getPrice())
  309. .isEqualTo(
  310. new BigDecimal("34999.23000574012011552062010939099496310569328655387396")
  311. .setScale(roundingScale, RoundingMode.HALF_UP)
  312. .stripTrailingZeros());
  313. assertThat(trade.getTimestamp()).isEqualTo(RippleExchange.ToDate("2011-11-11T11:11:11.111Z"));
  314. assertThat(trade.getOriginalAmount()).isEqualTo("0.000028572057152");
  315. assertThat(trade.getType()).isEqualTo(OrderType.BID);
  316. assertThat(trade).isInstanceOf(RippleUserTrade.class);
  317. final RippleUserTrade ripple = (RippleUserTrade) trade;
  318. assertThat(ripple.getBaseCounterparty()).isEqualTo("rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q");
  319. assertThat(ripple.getBaseTransferFee()).isZero();
  320. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(Currency.BTC);
  321. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().base);
  322. assertThat(ripple.getCounterCounterparty()).isEmpty();
  323. assertThat(ripple.getCounterTransferFee()).isZero();
  324. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(Currency.XRP);
  325. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().counter);
  326. }
  327. @Test
  328. public void adaptTrade_BuyBTC_SellBTC()
  329. throws JsonParseException, JsonMappingException, IOException, ParseException {
  330. final RippleExchange exchange = new RippleExchange();
  331. final int roundingScale = exchange.getRoundingScale();
  332. // Read the trade JSON from the example resources
  333. final InputStream is =
  334. getClass()
  335. .getResourceAsStream(
  336. "/org/knowm/xchange/ripple/dto/trade/example-trade-buyBTC-sellBTC.json");
  337. final ObjectMapper mapper = new ObjectMapper();
  338. final RippleOrderTransaction response = mapper.readValue(is, RippleOrderTransaction.class);
  339. final TradeHistoryParams params = new TradeHistoryParams() {};
  340. final UserTrade trade = RippleAdapters.adaptTrade(response, params, this, roundingScale);
  341. assertThat(trade.getCurrencyPair().base).isEqualTo(Currency.BTC);
  342. assertThat(trade.getCurrencyPair().counter).isEqualTo(Currency.BTC);
  343. assertThat(trade.getFeeAmount()).isEqualTo("0.012");
  344. assertThat(trade.getFeeCurrency()).isEqualTo(Currency.XRP);
  345. assertThat(trade.getId())
  346. .isEqualTo("2222222222222222222222222222222222222222222222222222222222222222");
  347. assertThat(trade.getOrderId()).isEqualTo("2222");
  348. // Price = 0.501 * 0.998 / 0.50150835545121407952
  349. assertThat(trade.getPrice())
  350. .isEqualTo(
  351. new BigDecimal("0.99698837430165008596385145696065600512973847422746")
  352. .setScale(roundingScale, RoundingMode.HALF_UP));
  353. assertThat(trade.getTimestamp()).isEqualTo(RippleExchange.ToDate("2022-22-22T22:22:22.222Z"));
  354. assertThat(trade.getOriginalAmount()).isEqualTo("0.50150835545121407952");
  355. assertThat(trade.getType()).isEqualTo(OrderType.BID);
  356. assertThat(trade).isInstanceOf(RippleUserTrade.class);
  357. final RippleUserTrade ripple = (RippleUserTrade) trade;
  358. assertThat(ripple.getBaseCounterparty()).isEqualTo("rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q");
  359. assertThat(ripple.getBaseTransferFee()).isZero();
  360. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(Currency.BTC);
  361. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().base);
  362. assertThat(ripple.getCounterCounterparty()).isEqualTo("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B");
  363. // Transfer fee = 0.501 * 0.002
  364. assertThat(ripple.getCounterTransferFee()).isEqualTo("0.001002");
  365. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(Currency.BTC);
  366. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().counter);
  367. }
  368. @Test
  369. public void adaptTrade_PaymentPassthrough()
  370. throws JsonParseException, JsonMappingException, IOException, ParseException {
  371. final RippleExchange exchange = new RippleExchange();
  372. final int roundingScale = exchange.getRoundingScale();
  373. // Read the trade JSON from the example resources
  374. final InputStream is =
  375. getClass()
  376. .getResourceAsStream(
  377. "/org/knowm/xchange/ripple/dto/trade/example-payment-passthrough.json");
  378. final ObjectMapper mapper = new ObjectMapper();
  379. final RipplePaymentTransaction response = mapper.readValue(is, RipplePaymentTransaction.class);
  380. final TradeHistoryParams params = new TradeHistoryParams() {};
  381. final UserTrade trade = RippleAdapters.adaptTrade(response, params, this, roundingScale);
  382. assertThat(trade.getCurrencyPair().base).isEqualTo(Currency.XRP);
  383. assertThat(trade.getCurrencyPair().counter).isEqualTo(Currency.BTC);
  384. assertThat(trade.getFeeAmount()).isEqualTo("0.012");
  385. assertThat(trade.getFeeCurrency()).isEqualTo(Currency.XRP);
  386. assertThat(trade.getId())
  387. .isEqualTo("GHRE072948B95345396B2D9A364363GDE521HRT67QQRGGRTHYTRUP0RRB631107");
  388. assertThat(trade.getOrderId()).isEqualTo("9338");
  389. // Price = 0.009941478580724 / (349.559725 - 0.012)
  390. assertThat(trade.getPrice())
  391. .isEqualTo(
  392. new BigDecimal("0.00002844097635229638527900589254299967193321026478")
  393. .setScale(roundingScale, RoundingMode.HALF_UP));
  394. assertThat(trade.getTimestamp()).isEqualTo(RippleExchange.ToDate("2015-08-07T03:58:10.000Z"));
  395. assertThat(trade.getOriginalAmount()).isEqualTo("349.547725");
  396. assertThat(trade.getType()).isEqualTo(OrderType.ASK);
  397. assertThat(trade).isInstanceOf(RippleUserTrade.class);
  398. final RippleUserTrade ripple = (RippleUserTrade) trade;
  399. assertThat(ripple.getBaseCounterparty()).isEqualTo("");
  400. assertThat(ripple.getBaseTransferFee()).isZero();
  401. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(Currency.XRP);
  402. assertThat(ripple.getBaseTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().base);
  403. assertThat(ripple.getCounterCounterparty()).isEqualTo("rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q");
  404. // Transfer fee = 0.501 * 0.002
  405. assertThat(ripple.getCounterTransferFee()).isEqualTo("0");
  406. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(Currency.BTC);
  407. assertThat(ripple.getCounterTransferFeeCurrency()).isEqualTo(trade.getCurrencyPair().counter);
  408. }
  409. }