Use coinbase client library.

Author: moxie0

pom.xml

@@ -98,6 +98,18 @@
             <artifactId>commons-lang3</artifactId>
             <version>3.1</version>
         </dependency>
+
+        <dependency>
+            <groupId>com.coinbase.api</groupId>
+            <artifactId>coinbase-java</artifactId>
+            <version>1.9.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+            <version>2.4.3</version>
+        </dependency>
+
     </dependencies>
 
     <build>

src/main/java/org/whispersystems/bithub/client/CoinbaseClient.java

@@ -17,30 +17,16 @@
 
 package org.whispersystems.bithub.client;
 
-import com.sun.jersey.api.client.Client;
-import com.sun.jersey.api.client.ClientHandlerException;
-import com.sun.jersey.api.client.UniformInterfaceException;
-import com.sun.jersey.api.client.WebResource;
-import com.sun.jersey.api.client.config.ClientConfig;
-import com.sun.jersey.api.client.config.DefaultClientConfig;
-import com.sun.jersey.api.json.JSONConfiguration;
-import org.apache.commons.codec.binary.Hex;
-import org.codehaus.jackson.map.ObjectMapper;
+import com.coinbase.api.Coinbase;
+import com.coinbase.api.CoinbaseBuilder;
+import com.coinbase.api.entity.Account;
+import com.coinbase.api.entity.Transaction;
+import com.coinbase.api.exception.CoinbaseException;
+import org.joda.money.Money;
 import org.whispersystems.bithub.entities.Author;
-import org.whispersystems.bithub.entities.BalanceResponse;
-import org.whispersystems.bithub.entities.BitcoinTransaction;
-import org.whispersystems.bithub.entities.BitcoinTransactionResponse;
-import org.whispersystems.bithub.entities.CoinbaseTransaction;
-import org.whispersystems.bithub.entities.CoinbseRecentTransactionsResponse;
-import org.whispersystems.bithub.entities.ExchangeRate;
 
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-import javax.ws.rs.core.MediaType;
 import java.io.IOException;
 import java.math.BigDecimal;
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
 import java.util.List;
 
 /**
@@ -50,116 +36,55 @@
  */
 public class CoinbaseClient {
 
-  private static final String COINBASE_URL             = "https://coinbase.com";
-  private static final String BALANCE_PATH             = "/api/v1/account/balance";
-  private static final String PAYMENT_PATH             = "/api/v1/transactions/send_money";
-  private static final String EXCHANGE_PATH            = "/api/v1/currencies/exchange_rates";
-  private static final String RECENT_TRANSACTIONS_PATH = "/api/v1/transactions";
-
-  private final String apiKey;
-  private final String apiSecret;
-  private final Client client;
-
-  private static final ObjectMapper objectMapper = new ObjectMapper();
+  private final Coinbase coinbase;
 
   public CoinbaseClient(String apiKey, String apiSecret) {
-    this.apiKey    = apiKey;
-    this.apiSecret = apiSecret;
-    this.client    = Client.create(getClientConfig());
+    this.coinbase = new CoinbaseBuilder().withApiKey(apiKey, apiSecret).build();
   }
 
-  public List<CoinbaseTransaction> getRecentTransactions()
-      throws IOException, TransferFailedException
+  public List<Transaction> getRecentTransactions()
+      throws CoinbaseException, IOException
   {
-    try {
-      return getAuthenticatedWebResource(RECENT_TRANSACTIONS_PATH, null).get(CoinbseRecentTransactionsResponse.class)
-                                                                        .getTransactions();
-    } catch (UniformInterfaceException | ClientHandlerException e) {
-      throw new IOException(e);
-    }
+    return coinbase.getTransactions().getTransactions();
   }
 
-  public BigDecimal getExchangeRate() throws IOException {
-    try {
-      WebResource resource = client.resource(COINBASE_URL)
-                                   .path(EXCHANGE_PATH);
-
-      String btcToUsd = resource.accept(MediaType.APPLICATION_JSON)
-                                .get(ExchangeRate.class)
-                                .getBtc_to_usd();
-
-      return new BigDecimal(btcToUsd);
-  } catch (UniformInterfaceException | ClientHandlerException e) {
-    throw new IOException(e);
+  public BigDecimal getExchangeRate() throws IOException, CoinbaseException {
+    return coinbase.getExchangeRates().get("btc_to_usd");
   }
-}
 
   public void sendPayment(Author author, BigDecimal amount, String url)
       throws TransferFailedException
   {
     try {
       String note = "Commit payment:\n__" + author.getUsername() + "__ " + url;
 
-      BitcoinTransaction transaction = new BitcoinTransaction(author.getEmail(),
-                                                              amount.toPlainString(),
-                                                              note);
-
-      WebResource.Builder resource = getAuthenticatedWebResource(PAYMENT_PATH, transaction);
+      Transaction transaction = new Transaction();
+      transaction.setTo(author.getEmail());
+      transaction.setAmount(Money.parse("BTC " + amount.toPlainString()));
+      transaction.setNotes(note);
 
-      BitcoinTransactionResponse response = resource.type(MediaType.APPLICATION_JSON_TYPE)
-                                                    .entity(transaction)
-                                                    .post(BitcoinTransactionResponse.class);
+      Transaction response = coinbase.sendMoney(transaction);
 
-      if (!response.isSuccess()) {
+      if (response.getStatus() != Transaction.Status.COMPLETE) {
         throw new TransferFailedException();
       }
-
-    } catch (UniformInterfaceException | ClientHandlerException e) {
+    } catch (CoinbaseException | IOException e) {
       throw new TransferFailedException(e);
     }
   }
 
-  public BigDecimal getAccountBalance() throws IOException, TransferFailedException {
-    try {
-      WebResource.Builder resource = getAuthenticatedWebResource(BALANCE_PATH, null);
-      String amount = resource.get(BalanceResponse.class)
-                              .getAmount();
-      if (amount == null) {
-        throw new IOException("Empty amount in response!");
-      }
-
-      return new BigDecimal(amount);
-    } catch (UniformInterfaceException | ClientHandlerException e) {
-      throw new IOException(e);
-    }
-  }
-
-  private WebResource.Builder getAuthenticatedWebResource(String path, Object body) throws TransferFailedException {
-    try {
-      String json    = body == null ? "" : objectMapper.writeValueAsString(body);
-      String nonce   = String.valueOf(System.currentTimeMillis());
-      String message = nonce + COINBASE_URL + path + json;
-      Mac    mac     = Mac.getInstance("HmacSHA256");
-      mac.init(new SecretKeySpec(apiSecret.getBytes(), "HmacSHA256"));
+  public BigDecimal getAccountBalance() throws IOException, CoinbaseException {
+    List<Account> accounts = coinbase.getAccounts().getAccounts();
+    Account       primary  = null;
 
-      String signature = new String(Hex.encodeHex(mac.doFinal(message.getBytes())));
-
-      return client.resource(COINBASE_URL)
-              .path(path)
-              .accept(MediaType.APPLICATION_JSON)
-              .header("ACCESS_SIGNATURE", signature)
-              .header("ACCESS_NONCE", nonce)
-              .header("ACCESS_KEY", apiKey);
-    } catch (NoSuchAlgorithmException | InvalidKeyException | IOException e) {
-      throw new TransferFailedException();
+    for (Account account : accounts) {
+      if (account.isPrimary()) {
+        primary = account;
+        break;
+      }
     }
-  }
 
-  private ClientConfig getClientConfig() {
-    ClientConfig config = new DefaultClientConfig();
-    config.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);
-
-    return config;
+    if (primary != null) return coinbase.getBalance(primary.getId()).getAmount();
+    else                 return new BigDecimal(0.0);
   }
-
 }

src/main/java/org/whispersystems/bithub/controllers/GithubController.java

@@ -18,6 +18,7 @@
 package org.whispersystems.bithub.controllers;
 
 import com.codahale.metrics.annotation.Timed;
+import com.coinbase.api.exception.CoinbaseException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.commons.net.util.SubnetUtils;
 import org.apache.commons.net.util.SubnetUtils.SubnetInfo;
@@ -96,7 +97,7 @@ public GithubController(List<RepositoryConfiguration> repositories,
   public void handleCommits(@Auth Authentication auth,
                             @HeaderParam("X-Forwarded-For") String clientIp,
                             @FormParam("payload") String eventString)
-          throws IOException, UnauthorizedHookException, TransferFailedException
+      throws IOException, UnauthorizedHookException, TransferFailedException, CoinbaseException
   {
     authenticate(clientIp);
     PushEvent event = getEventFromPayload(eventString);