txs) {
135 | this.txs = txs;
136 | }
137 | }
138 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/etc/Base58.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.etc;
2 |
3 | /**
4 | * Copyright 2011 Google Inc.
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | import java.math.BigInteger;
20 | import java.security.MessageDigest;
21 | import java.security.NoSuchAlgorithmException;
22 | import java.text.ParseException;
23 | import java.util.Arrays;
24 |
25 | /**
26 | * Base58 is a way to encode Bitcoin addresses (or arbitrary data) as alphanumeric strings.
27 | *
28 | * Note that this is not the same base58 as used by Flickr, which you may find referenced around the Internet.
29 | *
30 | * Satoshi explains: why base-58 instead of standard base-64 encoding?
31 | *
32 | * - Don't want 0OIl characters that look the same in some fonts and
33 | * could be used to create visually identical looking account numbers.
34 | * - A string with non-alphanumeric characters is not as easily accepted as an account number.
35 | * - E-mail usually won't line-break if there's no punctuation to break at.
36 | * - Doubleclicking selects the whole number as one word if it's all alphanumeric.
37 | *
38 | *
39 | * However, note that the encoding/decoding runs in O(n²) time, so it is not useful for large data.
40 | *
41 | * The basic idea of the encoding is to treat the data bytes as a large number represented using
42 | * base-256 digits, convert the number to be represented using base-58 digits, preserve the exact
43 | * number of leading zeros (which are otherwise lost during the mathematical operations on the
44 | * numbers), and finally represent the resulting base-58 digits as alphanumeric ASCII characters.
45 | */
46 | public class Base58 {
47 | public static final char[] ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray();
48 | private static final char ENCODED_ZERO = ALPHABET[0];
49 | private static final int[] INDEXES = new int[128];
50 |
51 | static {
52 | Arrays.fill(INDEXES, -1);
53 | for (int i = 0; i < ALPHABET.length; i++) {
54 | INDEXES[ALPHABET[i]] = i;
55 | }
56 | }
57 |
58 | /**
59 | * Encodes the given bytes as a base58 string (no checksum is appended).
60 | *
61 | * @param input the bytes to encode
62 | * @return the base58-encoded string
63 | */
64 | public static String encode (byte[] input) {
65 | if (input.length == 0) {
66 | return "";
67 | }
68 | // Count leading zeros.
69 | int zeros = 0;
70 | while (zeros < input.length && input[zeros] == 0) {
71 | ++zeros;
72 | }
73 | // Convert base-256 digits to base-58 digits (plus conversion to ASCII characters)
74 | input = Arrays.copyOf(input, input.length); // since we modify it in-place
75 | char[] encoded = new char[input.length * 2]; // upper bound
76 | int outputStart = encoded.length;
77 | for (int inputStart = zeros; inputStart < input.length; ) {
78 | encoded[--outputStart] = ALPHABET[divmod(input, inputStart, 256, 58)];
79 | if (input[inputStart] == 0) {
80 | ++inputStart; // optimization - skip leading zeros
81 | }
82 | }
83 | // Preserve exactly as many leading encoded zeros in output as there were leading zeros in input.
84 | while (outputStart < encoded.length && encoded[outputStart] == ENCODED_ZERO) {
85 | ++outputStart;
86 | }
87 | while (--zeros >= 0) {
88 | encoded[--outputStart] = ENCODED_ZERO;
89 | }
90 | // Return encoded string (including encoded leading zeros).
91 | return new String(encoded, outputStart, encoded.length - outputStart);
92 | }
93 |
94 | /**
95 | * Decodes the given base58 string into the original data bytes.
96 | *
97 | * @param input the base58-encoded string to decode
98 | * @return the decoded data bytes
99 | * @throws ParseException if the given string is not a valid base58 string
100 | */
101 | public static byte[] decode (String input) throws ParseException {
102 | if (input.length() == 0) {
103 | return new byte[0];
104 | }
105 | // Convert the base58-encoded ASCII chars to a base58 byte sequence (base58 digits).
106 | byte[] input58 = new byte[input.length()];
107 | for (int i = 0; i < input.length(); ++i) {
108 | char c = input.charAt(i);
109 | int digit = c < 128 ? INDEXES[c] : -1;
110 | if (digit < 0) {
111 | throw new ParseException("Illegal character " + c + " at position " + i, i);
112 | }
113 | input58[i] = (byte) digit;
114 | }
115 | // Count leading zeros.
116 | int zeros = 0;
117 | while (zeros < input58.length && input58[zeros] == 0) {
118 | ++zeros;
119 | }
120 | // Convert base-58 digits to base-256 digits.
121 | byte[] decoded = new byte[input.length()];
122 | int outputStart = decoded.length;
123 | for (int inputStart = zeros; inputStart < input58.length; ) {
124 | decoded[--outputStart] = divmod(input58, inputStart, 58, 256);
125 | if (input58[inputStart] == 0) {
126 | ++inputStart; // optimization - skip leading zeros
127 | }
128 | }
129 | // Ignore extra leading zeroes that were added during the calculation.
130 | while (outputStart < decoded.length && decoded[outputStart] == 0) {
131 | ++outputStart;
132 | }
133 | // Return decoded data (including original number of leading zeros).
134 | return Arrays.copyOfRange(decoded, outputStart - zeros, decoded.length);
135 | }
136 |
137 | public static BigInteger decodeToBigInteger (String input) throws ParseException {
138 | return new BigInteger(1, decode(input));
139 | }
140 |
141 | /**
142 | * Decodes the given base58 string into the original data bytes, using the checksum in the
143 | * last 4 bytes of the decoded data to verify that the rest are correct. The checksum is
144 | * removed from the returned data.
145 | *
146 | * @param input the base58-encoded string to decode (which should include the checksum)
147 | * @throws ParseException if the input is not base 58 or the checksum does not validate.
148 | */
149 | public static byte[] decodeChecked (String input) throws ParseException {
150 | byte[] decoded = decode(input);
151 | if (decoded.length < 4) {
152 | throw new ParseException("Input too short", 0);
153 | }
154 | byte[] data = Arrays.copyOfRange(decoded, 0, decoded.length - 4);
155 | byte[] checksum = Arrays.copyOfRange(decoded, decoded.length - 4, decoded.length);
156 | byte[] actualChecksum = Arrays.copyOfRange(hashTwice(data), 0, 4);
157 | if (!Arrays.equals(checksum, actualChecksum)) {
158 | throw new ParseException("Checksum does not validate", 0);
159 | }
160 | return data;
161 | }
162 |
163 | /**
164 | * Divides a number, represented as an array of bytes each containing a single digit
165 | * in the specified base, by the given divisor. The given number is modified in-place
166 | * to contain the quotient, and the return value is the remainder.
167 | *
168 | * @param number the number to divide
169 | * @param firstDigit the index within the array of the first non-zero digit
170 | * (this is used for optimization by skipping the leading zeros)
171 | * @param base the base in which the number's digits are represented (up to 256)
172 | * @param divisor the number to divide by (up to 256)
173 | * @return the remainder of the division operation
174 | */
175 | private static byte divmod (byte[] number, int firstDigit, int base, int divisor) {
176 | // this is just long division which accounts for the base of the input digits
177 | int remainder = 0;
178 | for (int i = firstDigit; i < number.length; i++) {
179 | int digit = (int) number[i] & 0xFF;
180 | int temp = remainder * base + digit;
181 | number[i] = (byte) (temp / divisor);
182 | remainder = temp % divisor;
183 | }
184 | return (byte) remainder;
185 | }
186 |
187 | public static byte[] hashTwice (byte[] input) {
188 | MessageDigest digest = null;
189 | try {
190 | digest = MessageDigest.getInstance("SHA-256");
191 | digest.update(input, 0, input.length);
192 | return digest.digest(digest.digest());
193 | } catch (NoSuchAlgorithmException e) {
194 | throw new RuntimeException(e);
195 | }
196 |
197 | }
198 | }
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/exchangerates/Currency.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.exchangerates;
2 |
3 | import java.math.BigDecimal;
4 |
5 | /**
6 | * Used in response to the `getTicker` method in the `ExchangeRates` class.
7 | */
8 | public class Currency {
9 | private BigDecimal buy;
10 | private BigDecimal sell;
11 | private BigDecimal last;
12 | private BigDecimal price15m;
13 | private String symbol;
14 |
15 | public Currency (double buy, double sell, double last, double price15m, String symbol) {
16 | this.buy = BigDecimal.valueOf(buy);
17 | this.sell = BigDecimal.valueOf(sell);
18 | this.last = BigDecimal.valueOf(last);
19 | this.price15m = BigDecimal.valueOf(price15m);
20 | this.symbol = symbol;
21 | }
22 |
23 | /**
24 | * @return Current buy price
25 | */
26 | public BigDecimal getBuy () {
27 | return buy;
28 | }
29 |
30 | /**
31 | * @return Current sell price
32 | */
33 | public BigDecimal getSell () {
34 | return sell;
35 | }
36 |
37 | /**
38 | * @return Most recent market price
39 | */
40 | public BigDecimal getLast () {
41 | return last;
42 | }
43 |
44 | /**
45 | * @return 15 minutes delayed market price
46 | */
47 | public BigDecimal getPrice15m () {
48 | return price15m;
49 | }
50 |
51 | /**
52 | * @return Currency symbol
53 | */
54 | public String getSymbol () {
55 | return symbol;
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/exchangerates/ExchangeRates.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.exchangerates;
2 |
3 | import com.google.gson.JsonElement;
4 | import com.google.gson.JsonObject;
5 | import com.google.gson.JsonParser;
6 | import info.blockchain.api.APIException;
7 | import info.blockchain.api.HttpClient;
8 |
9 | import java.io.IOException;
10 | import java.math.BigDecimal;
11 | import java.util.HashMap;
12 | import java.util.Map;
13 | import java.util.Map.Entry;
14 |
15 | /**
16 | * This class reflects the functionality documented
17 | * at https://blockchain.info/api/exchange_rates_api. It allows users to fetch the latest
18 | * ticker data and convert amounts between BTC and fiat currencies.
19 | */
20 | public class ExchangeRates {
21 |
22 | private final String apiCode;
23 |
24 | public ExchangeRates () {
25 | this(null);
26 | }
27 |
28 | public ExchangeRates (String apiCode) {
29 | this.apiCode = apiCode;
30 | }
31 |
32 | /**
33 | * Gets the price ticker from https://blockchain.info/ticker
34 | *
35 | * @return A map of currencies where the key is a 3-letter currency symbol and the
36 | * value is the `Currency` class
37 | * @throws APIException If the server returns an error
38 | */
39 | public Map getTicker () throws APIException, IOException {
40 | Map params = new HashMap();
41 | if (apiCode != null) {
42 | params.put("api_code", apiCode);
43 | }
44 |
45 | String response = HttpClient.getInstance().get("ticker", params);
46 | JsonObject ticker = new JsonParser().parse(response).getAsJsonObject();
47 |
48 | Map resultMap = new HashMap();
49 | for (Entry ccyKVP : ticker.entrySet()) {
50 | JsonObject ccy = ccyKVP.getValue().getAsJsonObject();
51 | Currency currency = new Currency(ccy.get("buy").getAsDouble(), ccy.get("sell").getAsDouble(), ccy.get("last").getAsDouble(), ccy.get("15m").getAsDouble(), ccy.get("symbol").getAsString());
52 |
53 | resultMap.put(ccyKVP.getKey(), currency);
54 | }
55 |
56 | return resultMap;
57 | }
58 |
59 | /**
60 | * Converts x value in the provided currency to BTC.
61 | *
62 | * @param currency Currency code
63 | * @param value Value to convert
64 | * @return Converted value in BTC
65 | * @throws APIException If the server returns an error
66 | */
67 | public BigDecimal toBTC (String currency, BigDecimal value) throws APIException, IOException {
68 | Map params = new HashMap();
69 | params.put("currency", currency);
70 | params.put("value", String.valueOf(value));
71 | if (apiCode != null) {
72 | params.put("api_code", apiCode);
73 | }
74 |
75 | String response = HttpClient.getInstance().get("tobtc", params);
76 | return new BigDecimal(response);
77 | }
78 |
79 | /**
80 | * Converts x value in BTC to the provided currency.
81 | *
82 | * @param currency Currency code
83 | * @param value Value to convert
84 | * @return Converted value in the provided currency
85 | * @throws APIException If the server returns an error
86 | */
87 | public BigDecimal toFiat (String currency, BigDecimal value) throws APIException, IOException {
88 | Map params = new HashMap();
89 | params.put("currency", currency);
90 | params.put("value", String.valueOf(value.multiply(BigDecimal.valueOf(100000000L)))); // The endpoint is expecting satoshi
91 | if (apiCode != null) {
92 | params.put("api_code", apiCode);
93 | }
94 |
95 | String response = HttpClient.getInstance().get("frombtc", params);
96 | return new BigDecimal(response);
97 | }
98 |
99 | }
100 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/pushtx/PushTx.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.pushtx;
2 |
3 | import info.blockchain.api.APIException;
4 | import info.blockchain.api.HttpClient;
5 |
6 | import java.io.IOException;
7 | import java.util.HashMap;
8 | import java.util.Map;
9 |
10 | /**
11 | * This class reflects the functionality provided at
12 | * https://blockchain.info/pushtx. It allows users to broadcast hex encoded
13 | * transactions to the bitcoin network.
14 | */
15 | public class PushTx {
16 | /**
17 | * Pushes a hex encoded transaction to the network.
18 | *
19 | * @param tx Hex encoded transaction
20 | * @throws APIException If the server returns an error (malformed tx etc.)
21 | */
22 | public static void pushTx (String tx) throws APIException, IOException {
23 | pushTx(tx, null);
24 | }
25 |
26 | /**
27 | * Pushes a hex encoded transaction to the network.
28 | *
29 | * @param tx Hex encoded transaction
30 | * @param apiCode Blockchain.info API code (optional, nullable)
31 | * @throws APIException If the server returns an error (malformed tx etc.)
32 | */
33 | public static void pushTx (String tx, String apiCode) throws APIException, IOException {
34 | Map params = new HashMap();
35 | params.put("tx", tx);
36 |
37 | if (apiCode != null) {
38 | params.put("api_code", apiCode);
39 | }
40 |
41 | HttpClient.getInstance().post("pushtx", params);
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/receive/CallbackLog.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.receive;
2 |
3 | import com.google.gson.JsonObject;
4 |
5 | public class CallbackLog {
6 | private String callback;
7 | private String callbackTime;
8 | private String response;
9 | private int responseCode;
10 |
11 | public CallbackLog (JsonObject callbackJson) {
12 | this(
13 | callbackJson.has("callback") ? callbackJson.get("callback").getAsString() : "",
14 | callbackJson.has("called_at") ? callbackJson.get("called_at").getAsString() : "",
15 | callbackJson.has("raw_response") ? callbackJson.get("raw_response").getAsString() : "",
16 | callbackJson.has("response_code") ? callbackJson.get("response_code").getAsInt() : 0
17 | );
18 | }
19 |
20 | public CallbackLog (String callback, String callbackTime, String response, int responseCode) {
21 | this.callback = callback;
22 | this.callbackTime = callbackTime;
23 | this.response = response;
24 | this.responseCode = responseCode;
25 | }
26 |
27 | public String getCallback () {
28 | return callback;
29 | }
30 |
31 | public void setCallback (String callback) {
32 | this.callback = callback;
33 | }
34 |
35 | public String getCallbackTime () {
36 | return callbackTime;
37 | }
38 |
39 | public void setCallbackTime (String callbackTime) {
40 | this.callbackTime = callbackTime;
41 | }
42 |
43 | public String getResponse () {
44 | return response;
45 | }
46 |
47 | public void setResponse (String response) {
48 | this.response = response;
49 | }
50 |
51 | public int getResponseCode () {
52 | return responseCode;
53 | }
54 |
55 | public void setResponseCode (int responseCode) {
56 | this.responseCode = responseCode;
57 | }
58 |
59 | }
60 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/receive/Receive.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.receive;
2 |
3 | import com.google.gson.JsonObject;
4 | import com.google.gson.JsonParser;
5 | import info.blockchain.api.APIException;
6 | import info.blockchain.api.HttpClient;
7 |
8 | import java.io.IOException;
9 | import java.util.HashMap;
10 | import java.util.Map;
11 |
12 | /**
13 | * This class reflects the functionality necessary for using the receive-payments-api v2.
14 | * Passing on a xPUB, callbackUrl and the apiCode will return an address for receiving a payment.
15 | *
16 | * Upon receiving a payment on this address, the merchant will be notified using the callback URL.
17 | */
18 | public class Receive {
19 | private final String apiCode;
20 |
21 | /**
22 | * @param apiCode Blockchain.info API code for the receive-payments v2 API (different from normal API key)
23 | */
24 | public Receive (String apiCode) {
25 | this.apiCode = apiCode;
26 | }
27 |
28 | /**
29 | * Calls the receive-payments-api v2 and returns an address for the payment.
30 | *
31 | * @param xPUB Destination address where the payment should be sent
32 | * @param callbackUrl Callback URI that will be called upon payment
33 | * @return An instance of the ReceiveV2Response class
34 | * @throws APIException If the server returns an error
35 | */
36 | public ReceiveResponse receive (String xPUB, String callbackUrl) throws APIException, IOException {
37 | Map params = new HashMap();
38 | params.put("xpub", xPUB);
39 | params.put("callback", callbackUrl);
40 | params.put("key", apiCode);
41 |
42 | String response = HttpClient.getInstance().get("https://api.blockchain.info/", "v2/receive", params);
43 | JsonParser parser = new JsonParser();
44 | JsonObject obj = parser.parse(response).getAsJsonObject();
45 |
46 | return new ReceiveResponse(obj.get("index").getAsInt(), obj.get("address").getAsString(), obj.get("callback").getAsString());
47 | }
48 |
49 | /**
50 | * Calls the receive-payments-api v2 and returns the xpub gap of an xpub.
51 | *
52 | * @param xPUB Destination address where the payment should be sent
53 | * @return An instance of the ReceiveV2Response class
54 | * @throws APIException If the server returns an error
55 | */
56 | public int checkGap (String xPUB) throws APIException, IOException {
57 | Map params = new HashMap();
58 | params.put("xpub", xPUB);
59 | params.put("key", apiCode);
60 |
61 | String response = HttpClient.getInstance().get("https://api.blockchain.info/", "v2/receive/checkgap", params);
62 | JsonObject obj = new JsonParser().parse(response).getAsJsonObject();
63 |
64 | return obj.get("gap").getAsInt();
65 | }
66 |
67 | /**
68 | * Calls the receive-payments-api v2 and returns the callback log based on url.
69 | *
70 | * @param callbackUrl Callback URI that will be called upon payment
71 | * @return An instance of the ReceiveV2Response class
72 | * @throws APIException If the server returns an error
73 | */
74 | public CallbackLog getCallbackLog (String callbackUrl) throws APIException, IOException {
75 | Map params = new HashMap();
76 | params.put("callback", callbackUrl);
77 | params.put("key", apiCode);
78 |
79 | String response = HttpClient.getInstance().get("https://api.blockchain.info/", "v2/receive/callback", params);
80 | JsonObject obj = new JsonParser().parse(response).getAsJsonObject();
81 |
82 | return new CallbackLog(obj);
83 | }
84 | }
85 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/receive/ReceiveResponse.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.receive;
2 |
3 | /**
4 | * This class is used as a response object to the `ReceiveV2.receive` method.
5 | */
6 | public class ReceiveResponse {
7 | private int index;
8 | private String receivingAddress;
9 | private String callbackUrl;
10 |
11 | public ReceiveResponse (int index, String receivingAddress, String callbackUrl) {
12 | this.index = index;
13 | this.receivingAddress = receivingAddress;
14 | this.callbackUrl = callbackUrl;
15 | }
16 |
17 | /**
18 | * @return Index of the address in the account
19 | */
20 | public int getIndex () {
21 | return index;
22 | }
23 |
24 | /**
25 | * @return Address to be displayed for the customer at checkout.
26 | */
27 | public String getReceivingAddress () {
28 | return receivingAddress;
29 | }
30 |
31 | /**
32 | * @return Callback URI that will be called upon payment
33 | */
34 | public String getCallbackUrl () {
35 | return callbackUrl;
36 | }
37 | }
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/statistics/Chart.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.statistics;
2 |
3 | import com.google.gson.JsonElement;
4 | import com.google.gson.JsonObject;
5 |
6 | import java.util.ArrayList;
7 | import java.util.List;
8 |
9 | public class Chart {
10 |
11 | private String status;
12 | private String name;
13 | private String unit;
14 | private String period;
15 | private String description;
16 | private List values;
17 |
18 | public Chart (JsonObject chartJson) {
19 | this(
20 | chartJson.has("status") ? chartJson.get("status").getAsString() : "",
21 | chartJson.has("name") ? chartJson.get("name").getAsString() : "",
22 | chartJson.has("unit") ? chartJson.get("unit").getAsString() : "",
23 | chartJson.has("period") ? chartJson.get("period").getAsString() : "",
24 | chartJson.has("description") ? chartJson.get("description").getAsString() : "",
25 | null
26 | );
27 | values = getPoints(chartJson);
28 | }
29 |
30 | public Chart (String status, String name, String unit, String period, String description, List values) {
31 | this.status = status;
32 | this.name = name;
33 | this.unit = unit;
34 | this.period = period;
35 | this.description = description;
36 | this.values = values;
37 | }
38 |
39 | private List getPoints(JsonObject chartJson) {
40 | List points = new ArrayList();
41 | for (JsonElement pointElement : chartJson.getAsJsonArray()) {
42 | JsonObject pointJson = pointElement.getAsJsonObject();
43 | points.add(new Point(pointJson));
44 | }
45 |
46 | return points;
47 | }
48 |
49 | public String getStatus() {
50 | return status;
51 | }
52 |
53 | public String getName() {
54 | return name;
55 | }
56 |
57 | public String getUnit() {
58 | return unit;
59 | }
60 |
61 | public String getPeriod() {
62 | return period;
63 | }
64 |
65 | public String getDescription() {
66 | return description;
67 | }
68 |
69 | public List getValues() {
70 | return values;
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/statistics/Point.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.statistics;
2 |
3 | import com.google.gson.JsonObject;
4 |
5 | public class Point {
6 |
7 | private float x;
8 | private float y;
9 |
10 | public Point (JsonObject pointJson) {
11 | this(
12 | pointJson.has("x") ? pointJson.get("x").getAsFloat() : 0.0F,
13 | pointJson.has("y") ? pointJson.get("y").getAsFloat() : 0.0F
14 | );
15 | }
16 |
17 | public Point (float x, float y) {
18 | this.x = x;
19 | this.y = y;
20 | }
21 |
22 | public float getX() {
23 | return x;
24 | }
25 |
26 | public float getY() {
27 | return y;
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/statistics/Statistics.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.statistics;
2 |
3 | import com.google.gson.Gson;
4 | import com.google.gson.JsonObject;
5 | import com.google.gson.JsonParser;
6 | import com.google.gson.reflect.TypeToken;
7 | import info.blockchain.api.APIException;
8 | import info.blockchain.api.HttpClient;
9 |
10 | import java.io.IOException;
11 | import java.lang.reflect.Type;
12 | import java.util.HashMap;
13 | import java.util.Map;
14 |
15 | /**
16 | * This class reflects the functionality documented
17 | * at https://blockchain.info/api/charts_api
18 | */
19 | public class Statistics {
20 | private final String apiCode;
21 |
22 | public Statistics () {
23 | this(null);
24 | }
25 |
26 | public Statistics (String apiCode) {
27 | this.apiCode = apiCode;
28 | }
29 |
30 | /**
31 | * Gets the network statistics.
32 | *
33 | * @return An instance of the StatisticsResponse class
34 | * @throws APIException If the server returns an error
35 | */
36 | public StatisticsResponse getStats () throws APIException, IOException {
37 | Map params = new HashMap();
38 | params.put("format", "json");
39 | if (apiCode != null) {
40 | params.put("api_code", apiCode);
41 | }
42 |
43 | String response = HttpClient.getInstance().get("stats", params);
44 | return new StatisticsResponse(response);
45 | }
46 |
47 | /**
48 | * This method can be used to get and manipulate data behind all Blockchain.info's charts.
49 | *
50 | * @param type of chart (Example: transactions-per-second, total-bitcoins)
51 | * @param timeSpan (Example: 5weeks)
52 | * @param rollingAverage (Example: 8hours)
53 | * @return {@code Chart} represents the series of data of the chart
54 | * @throws APIException If the server returns an error
55 | */
56 | public Chart getChart(String type, String timeSpan, String rollingAverage) throws APIException, IOException {
57 | Map params = new HashMap();
58 | params.put("format", "json");
59 | if (apiCode != null) {
60 | params.put("api_code", apiCode);
61 | }
62 | if (timeSpan != null) {
63 | params.put("timespan", timeSpan);
64 | }
65 | if (rollingAverage != null) {
66 | params.put("rollingAverage", rollingAverage);
67 | }
68 |
69 | String response = HttpClient.getInstance().get("charts/" + type, params);
70 | JsonObject chartJson = new JsonParser().parse(response).getAsJsonObject();
71 |
72 | return new Chart(chartJson);
73 | }
74 |
75 | /**
76 | * This method can be used to get the data behind Blockchain.info's pools information.
77 | *
78 | * @param timeSpan (Example: 5weeks)
79 | * @return a map of pool name and the number of blocks it mined
80 | * @throws APIException If the server returns an error
81 | */
82 | public Map getPools(String timeSpan) throws APIException, IOException {
83 | Map params = new HashMap();
84 | params.put("format", "json");
85 | if (apiCode != null) {
86 | params.put("api_code", apiCode);
87 | }
88 | if (timeSpan != null) {
89 | params.put("timespan", timeSpan);
90 | }
91 |
92 | String response = HttpClient.getInstance().get("pools", params);
93 | Type type = new TypeToken>(){}.getType();
94 | Gson gson = new Gson();
95 | Map pools = gson.fromJson(response, type);
96 |
97 | return pools;
98 | }
99 |
100 | }
101 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/statistics/StatisticsResponse.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.statistics;
2 |
3 | import com.google.gson.JsonObject;
4 | import com.google.gson.JsonParser;
5 |
6 | import java.math.BigDecimal;
7 |
8 | /**
9 | * This class is used as a response object to the 'get' method in the 'Statistics' class
10 | */
11 | public class StatisticsResponse {
12 | private BigDecimal tradeVolumeBTC;
13 | private BigDecimal tradeVolumeUSD;
14 | private BigDecimal minersRevenueBTC;
15 | private BigDecimal minersRevenueUSD;
16 | private BigDecimal marketPriceUSD;
17 | private BigDecimal estimatedTransactionVolumeUSD;
18 | private long totalFeesBTC;
19 | private long totalBTCSent;
20 | private long estimatedBTCSent;
21 | private long btcMined;
22 | private double difficulty;
23 | private double minutesBetweenBlocks;
24 | private long numberOfTransactions;
25 | private double hashRate;
26 | private long timestamp;
27 | private long minedBlocks;
28 | private long blocksSize;
29 | private long totalBTC;
30 | private long totalBlocks;
31 | private long nextRetarget;
32 |
33 | public StatisticsResponse (String jsonString) {
34 | JsonObject s = new JsonParser().parse(jsonString).getAsJsonObject();
35 |
36 | this.tradeVolumeBTC = new BigDecimal(s.get("trade_volume_btc").getAsString());
37 | this.tradeVolumeUSD = new BigDecimal(s.get("trade_volume_usd").getAsString());
38 | this.minersRevenueBTC = new BigDecimal(s.get("miners_revenue_btc").getAsString());
39 | this.minersRevenueUSD = new BigDecimal(s.get("miners_revenue_usd").getAsString());
40 | this.marketPriceUSD = new BigDecimal(s.get("market_price_usd").getAsString());
41 | this.estimatedTransactionVolumeUSD = new BigDecimal(s.get("estimated_transaction_volume_usd").getAsString());
42 | this.totalFeesBTC = s.get("total_fees_btc").getAsLong();
43 | this.totalBTCSent = s.get("total_btc_sent").getAsLong();
44 | this.estimatedBTCSent = s.get("estimated_btc_sent").getAsLong();
45 | this.btcMined = s.get("n_btc_mined").getAsLong();
46 | this.difficulty = s.get("difficulty").getAsDouble();
47 | this.minutesBetweenBlocks = s.get("minutes_between_blocks").getAsDouble();
48 | this.numberOfTransactions = s.get("n_tx").getAsLong();
49 | this.hashRate = s.get("hash_rate").getAsDouble();
50 | this.timestamp = s.get("timestamp").getAsLong();
51 | this.minedBlocks = s.get("n_blocks_mined").getAsLong();
52 | this.blocksSize = s.get("blocks_size").getAsLong();
53 | this.totalBTC = s.get("totalbc").getAsLong();
54 | this.totalBlocks = s.get("n_blocks_total").getAsLong();
55 | this.nextRetarget = s.get("nextretarget").getAsLong();
56 | }
57 |
58 | /**
59 | * @return Trade volume in the past 24 hours
60 | */
61 | public BigDecimal getTradeVolumeBTC () {
62 | return tradeVolumeBTC;
63 | }
64 |
65 | /**
66 | * @return Trade volume in the past 24 hours
67 | */
68 | public BigDecimal getTradeVolumeUSD () {
69 | return tradeVolumeUSD;
70 | }
71 |
72 | /**
73 | * @return Miners' revenue in BTC
74 | */
75 | public BigDecimal getMinersRevenueBTC () {
76 | return minersRevenueBTC;
77 | }
78 |
79 | /**
80 | * @return Miners' revenue in USD
81 | */
82 | public BigDecimal getMinersRevenueUSD () {
83 | return minersRevenueUSD;
84 | }
85 |
86 | /**
87 | * @return Current market price in USD
88 | */
89 | public BigDecimal getMarketPriceUSD () {
90 | return marketPriceUSD;
91 | }
92 |
93 | /**
94 | * @return Estimated transaction volume in the past 24 hours
95 | */
96 | public BigDecimal getEstimatedTransactionVolumeUSD () {
97 | return estimatedTransactionVolumeUSD;
98 | }
99 |
100 | /**
101 | * @return Total fees in the past 24 hours (in satoshi)
102 | */
103 | public long getTotalFeesBTC () {
104 | return totalFeesBTC;
105 | }
106 |
107 | /**
108 | * @return Total BTC sent in the past 24 hours (in satoshi)
109 | */
110 | public long getTotalBTCSent () {
111 | return totalBTCSent;
112 | }
113 |
114 | /**
115 | * @return Estimated BTC sent in the past 24 hours (in satoshi)
116 | */
117 | public long getEstimatedBTCSent () {
118 | return estimatedBTCSent;
119 | }
120 |
121 | /**
122 | * @return Number of BTC mined in the past 24 hours (in satoshi)
123 | */
124 | public long getBTCMined () {
125 | return btcMined;
126 | }
127 |
128 | /**
129 | * @return Current difficulty
130 | */
131 | public double getDifficulty () {
132 | return difficulty;
133 | }
134 |
135 | /**
136 | * @return Minutes between blocks
137 | */
138 | public double getMinutesBetweenBlocks () {
139 | return minutesBetweenBlocks;
140 | }
141 |
142 | /**
143 | * @return Number of transactions in the past 24 hours
144 | */
145 | public long getNumberOfTransactions () {
146 | return numberOfTransactions;
147 | }
148 |
149 | /**
150 | * @return Current hashrate in GH/s
151 | */
152 | public double getHashRate () {
153 | return hashRate;
154 | }
155 |
156 | /**
157 | * @return Timestamp of when this report was compiled (in ms)
158 | */
159 | public long getTimestamp () {
160 | return timestamp;
161 | }
162 |
163 | /**
164 | * @return Number of blocks mined in the past 24 hours
165 | */
166 | public long getMinedBlocks () {
167 | return minedBlocks;
168 | }
169 |
170 | /**
171 | * @return the blocksSize
172 | */
173 | public long getBlocksSize () {
174 | return blocksSize;
175 | }
176 |
177 | /**
178 | * @return Total BTC in existence (in satoshi)
179 | */
180 | public long getTotalBTC () {
181 | return totalBTC;
182 | }
183 |
184 | /**
185 | * @return Total number of blocks in existence (in satoshi)
186 | */
187 | public long getTotalBlocks () {
188 | return totalBlocks;
189 | }
190 |
191 | /**
192 | * @return The next block height where the difficulty retarget will occur
193 | */
194 | public long getNextRetarget () {
195 | return nextRetarget;
196 | }
197 | }
198 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/wallet/Wallet.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.wallet;
2 |
3 | import java.io.IOException;
4 | import java.util.ArrayList;
5 | import java.util.HashMap;
6 | import java.util.List;
7 | import java.util.Map;
8 | import java.util.Map.Entry;
9 |
10 | import com.google.gson.Gson;
11 | import com.google.gson.JsonElement;
12 | import com.google.gson.JsonObject;
13 | import com.google.gson.JsonParser;
14 |
15 | import info.blockchain.api.APIException;
16 | import info.blockchain.api.HttpClient;
17 | import info.blockchain.api.wallet.entity.Address;
18 | import info.blockchain.api.wallet.entity.CreateWalletResponse;
19 | import info.blockchain.api.wallet.entity.PaymentResponse;
20 |
21 | /**
22 | * This class reflects the functionality documented
23 | * at https://blockchain.info/api/blockchain_wallet_api. It allows users to interact
24 | * with their Blockchain.info wallet. If you have an API code, please set it via the
25 | * `setApiCode` method.
26 | */
27 | public class Wallet {
28 | private JsonParser jsonParser;
29 |
30 | private String serviceURL;
31 | private String identifier;
32 | private String password;
33 | private String secondPassword;
34 | private String apiCode;
35 |
36 | /**
37 | * Creates a new Blockchain.info wallet.
38 | *
39 | * @param serviceURL URL to an instance of service-my-wallet-v3 (with trailing slash)
40 | * @param password Password for the new wallet. At least 10 characters.
41 | * @param apiCode API code with create wallets permission
42 | * @return An instance of the CreateWalletResponse class
43 | * @throws APIException If the server returns an error
44 | */
45 | public static CreateWalletResponse create (String serviceURL, String password,
46 | String apiCode) throws IOException, APIException {
47 | return create(serviceURL, password, apiCode, null, null, null);
48 | }
49 |
50 | /**
51 | * Creates a new Blockchain.info wallet. It can be created containing a pre-generated
52 | * private key or will otherwise generate a new private key.
53 | *
54 | * @param serviceURL URL to an instance of service-my-wallet-v3 (with trailing slash)
55 | * @param password Password for the new wallet. At least 10 characters.
56 | * @param apiCode API code with create wallets permission
57 | * @param privateKey Private key to add to the wallet (optional, nullable)
58 | * @param label Label for the first address in the wallet (optional, nullable)
59 | * @param email Email to associate with the new wallet (optional, nullable)
60 | * @return An instance of the CreateWalletResponse class
61 | * @throws APIException If the server returns an error
62 | */
63 | public static CreateWalletResponse create (String serviceURL, String password,String apiCode,
64 | String privateKey, String label, String email) throws IOException, APIException {
65 | Map params = new HashMap();
66 |
67 | params.put("password", password);
68 | params.put("api_code", apiCode);
69 | if (privateKey != null) {
70 | params.put("priv", privateKey);
71 | }
72 | if (label != null) {
73 | params.put("label", label);
74 | }
75 | if (email != null) {
76 | params.put("email", email);
77 | }
78 |
79 | String response = HttpClient.getInstance().post(serviceURL, "api/v2/create", params);
80 | JsonObject jsonObj = new JsonParser().parse(response).getAsJsonObject();
81 |
82 | return new CreateWalletResponse(
83 | jsonObj.get("guid").getAsString(),
84 | jsonObj.get("address").getAsString(),
85 | jsonObj.get("label").getAsString());
86 | }
87 |
88 | /**
89 | * @param serviceURL URL to an instance of service-my-wallet-v3 (with trailing slash)
90 | * @param apiCode API Code
91 | * @param identifier Wallet identifier (GUID)
92 | * @param password Decryption password
93 | */
94 | public Wallet (String serviceURL, String apiCode, String identifier, String password) {
95 | this(serviceURL, apiCode, identifier, password, null);
96 | }
97 |
98 | /**
99 | * @param serviceURL URL to an instance of service-my-wallet-v3 (with trailing slash)
100 | * @param apiCode API Code
101 | * @param identifier Wallet identifier (GUID)
102 | * @param password Decryption password
103 | * @param secondPassword Second password
104 | */
105 | public Wallet (String serviceURL, String apiCode, String identifier, String password, String secondPassword) {
106 | this.serviceURL = serviceURL;
107 | this.apiCode = apiCode;
108 | this.identifier = identifier;
109 | this.password = password;
110 | this.secondPassword = secondPassword;
111 | this.jsonParser = new JsonParser();
112 | }
113 |
114 | /**
115 | * Sends bitcoin from your wallet to a single address.
116 | *
117 | * @param toAddress Recipient bitcoin address
118 | * @param amount Amount to send (in satoshi)
119 | * @param fromAddress Specific address to send from (optional, nullable)
120 | * @param fee Transaction fee in satoshi. Must be greater than the default fee (optional, nullable).
121 | * @return An instance of the PaymentResponse class
122 | * @throws APIException If the server returns an error
123 | */
124 | public PaymentResponse send (String toAddress, long amount, String fromAddress, Long fee) throws APIException, IOException {
125 | Map recipient = new HashMap();
126 | recipient.put(toAddress, amount);
127 |
128 | return sendMany(recipient, fromAddress, fee);
129 | }
130 |
131 | /**
132 | * Sends bitcoin from your wallet to multiple addresses.
133 | *
134 | * @param recipients Map with the structure of 'address':amount in satoshi (String:long)
135 | * @param fromAddress Specific address to send from (optional, nullable)
136 | * @param fee Transaction fee in satoshi. Must be greater than the default fee (optional, nullable).
137 | * @return An instance of the PaymentResponse class
138 | * @throws APIException If the server returns an error
139 | * @throws IllegalArgumentException If no recipients is null or empty
140 | */
141 | public PaymentResponse sendMany (Map recipients, String fromAddress, Long fee) throws APIException, IOException {
142 | Map params = buildBasicRequestWithSecondPassword();
143 | String method = null;
144 |
145 | if (recipients.size() == 1) {
146 | method = "payment";
147 | Entry e = recipients.entrySet().iterator().next();
148 | params.put("to", e.getKey());
149 | params.put("amount", e.getValue().toString());
150 | } else {
151 | method = "sendmany";
152 | params.put("recipients", new Gson().toJson(recipients));
153 | }
154 |
155 | if (fromAddress != null) {
156 | params.put("from", fromAddress);
157 | }
158 | if (fee != null) {
159 | params.put("fee", fee.toString());
160 | }
161 |
162 | String response = HttpClient.getInstance().post(serviceURL, String.format("merchant/%s/%s", identifier, method), params);
163 | JsonObject topElem = parseResponse(response);
164 |
165 | return new PaymentResponse(topElem.get("message").getAsString(), topElem.get("tx_hash").getAsString(), topElem.has("notice") ? topElem.get("notice").getAsString() : null);
166 | }
167 |
168 | /**
169 | * Fetches the wallet balance. Includes unconfirmed transactions and
170 | * possibly double spends.
171 | *
172 | * @return Wallet balance in satoshi
173 | * @throws APIException If the server returns an error
174 | */
175 | public long getBalance () throws APIException, IOException {
176 | String response = HttpClient.getInstance().get(serviceURL, String.format("merchant/%s/balance", identifier), buildBasicRequest());
177 | JsonObject topElem = parseResponse(response);
178 |
179 | return topElem.get("balance").getAsLong();
180 | }
181 |
182 | /**
183 | * Lists all active addresses in the wallet.
184 | *
185 | * @return A list of Address objects
186 | * @throws APIException If the server returns an error
187 | */
188 | public List listAddresses () throws APIException, IOException {
189 | Map params = buildBasicRequest();
190 |
191 | String response = HttpClient.getInstance().get(serviceURL, String.format("merchant/%s/list", identifier), params);
192 | JsonObject topElem = parseResponse(response);
193 |
194 | List addresses = new ArrayList();
195 | for (JsonElement jAddr : topElem.get("addresses").getAsJsonArray()) {
196 | JsonObject a = jAddr.getAsJsonObject();
197 | Address address = new Address(a.get("balance").getAsLong(), a.get("address").getAsString(), a.has("label") && !a.get("label").isJsonNull() ? a.get("label").getAsString() : null, a.get("total_received").getAsLong());
198 |
199 | addresses.add(address);
200 | }
201 |
202 | return addresses;
203 | }
204 |
205 | /**
206 | * Retrieves an address from the wallet.
207 | *
208 | * @param address Address in the wallet to look up
209 | * @return An instance of the Address class
210 | * @throws APIException If the server returns an error
211 | */
212 | public Address getAddress (String address) throws APIException, IOException {
213 | Map params = buildBasicRequest();
214 | params.put("address", address);
215 |
216 | String response = HttpClient.getInstance().get(serviceURL, String.format("merchant/%s/address_balance", identifier), params);
217 | JsonObject topElem = parseResponse(response);
218 |
219 | return new Address(topElem.get("balance").getAsLong(), topElem.get("address").getAsString(), topElem.has("label") && !topElem.get("label").isJsonNull() ? topElem.get("label").getAsString() : null, topElem.get("total_received").getAsLong());
220 | }
221 |
222 | /**
223 | * Generates a new address and adds it to the wallet.
224 | *
225 | * @param label Label to attach to this address (optional, nullable)
226 | * @return An instance of the Address class
227 | * @throws APIException If the server returns an error
228 | */
229 | public Address newAddress (String label) throws APIException, IOException {
230 | Map params = buildBasicRequest();
231 | if (label != null) {
232 | params.put("label", label);
233 | }
234 |
235 | String response = HttpClient.getInstance().post(serviceURL, String.format("merchant/%s/new_address", identifier), params);
236 | JsonObject topElem = parseResponse(response);
237 |
238 | return new Address(0L, topElem.get("address").getAsString(), topElem.has("label") && !topElem.get("label").isJsonNull() ? topElem.get("label").getAsString() : null, 0L);
239 | }
240 |
241 | /**
242 | * Archives an address.
243 | *
244 | * @param address Address to archive
245 | * @return String representation of the archived address
246 | * @throws APIException If the server returns an error
247 | */
248 | public String archiveAddress (String address) throws APIException, IOException {
249 | Map params = buildBasicRequest();
250 | params.put("address", address);
251 |
252 | String response = HttpClient.getInstance().post(serviceURL, String.format("merchant/%s/archive_address", identifier), params);
253 | JsonObject topElem = parseResponse(response);
254 |
255 | return topElem.get("archived").getAsString();
256 | }
257 |
258 | /**
259 | * Unarchives an address.
260 | *
261 | * @param address Address to unarchive
262 | * @return String representation of the unarchived address
263 | * @throws APIException If the server returns an error
264 | */
265 | public String unarchiveAddress (String address) throws APIException, IOException {
266 | Map params = buildBasicRequest();
267 | params.put("address", address);
268 |
269 | String response = HttpClient.getInstance().post(serviceURL, String.format("merchant/%s/unarchive_address", identifier), params);
270 | JsonObject topElem = parseResponse(response);
271 |
272 | return topElem.get("active").getAsString();
273 | }
274 |
275 | private Map buildBasicRequest () {
276 | Map params = new HashMap();
277 |
278 | params.put("password", password);
279 | if (apiCode != null) {
280 | params.put("api_code", apiCode);
281 | }
282 |
283 | return params;
284 | }
285 |
286 | private Map buildBasicRequestWithSecondPassword () {
287 | Map params = buildBasicRequest();
288 | if (secondPassword != null) {
289 | params.put("second_password", secondPassword);
290 | }
291 |
292 | return params;
293 | }
294 |
295 | private JsonObject parseResponse (String response) throws APIException {
296 | JsonObject topElem = jsonParser.parse(response).getAsJsonObject();
297 | if (topElem.has("error")) {
298 | throw new APIException(topElem.get("error").getAsString());
299 | }
300 |
301 | return topElem;
302 | }
303 |
304 | @Override
305 | public boolean equals (Object o) {
306 | if (this == o) {
307 | return true;
308 | }
309 | if (o == null || getClass() != o.getClass()) {
310 | return false;
311 | }
312 |
313 | Wallet wallet = (Wallet) o;
314 |
315 | return identifier == null ? wallet.identifier == null : identifier.equals(wallet.identifier);
316 | }
317 |
318 | @Override
319 | public int hashCode () {
320 | return identifier != null ? identifier.hashCode() : 0;
321 | }
322 |
323 | }
324 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/wallet/entity/Address.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.wallet.entity;
2 |
3 | /**
4 | * Used in combination with the `Wallet` class
5 | */
6 | public class Address {
7 | private long balance;
8 | private String address;
9 | private String label;
10 | private long totalReceived;
11 |
12 | public Address (long balance, String address, String label, long totalReceived) {
13 | this.balance = balance;
14 | this.address = address;
15 | this.label = label;
16 | this.totalReceived = totalReceived;
17 | }
18 |
19 | @Override
20 | public boolean equals (Object o) {
21 | if (this == o) {
22 | return true;
23 | }
24 | if (o == null || getClass() != o.getClass()) {
25 | return false;
26 | }
27 |
28 | Address address1 = (Address) o;
29 |
30 | if (balance != address1.balance) {
31 | return false;
32 | }
33 | if (totalReceived != address1.totalReceived) {
34 | return false;
35 | }
36 | if (address != null ? !address.equals(address1.address) : address1.address != null) {
37 | return false;
38 | }
39 | return !(label != null ? !label.equals(address1.label) : address1.label != null);
40 |
41 | }
42 |
43 | @Override
44 | public int hashCode () {
45 | int result = (int) (balance ^ (balance >>> 32));
46 | result = 31 * result + (address != null ? address.hashCode() : 0);
47 | result = 31 * result + (label != null ? label.hashCode() : 0);
48 | result = 31 * result + (int) (totalReceived ^ (totalReceived >>> 32));
49 | return result;
50 | }
51 |
52 | /**
53 | * @return Balance in satoshi
54 | */
55 | public long getBalance () {
56 | return balance;
57 | }
58 |
59 | /**
60 | * @return String representation of the address
61 | */
62 | public String getAddress () {
63 | return address;
64 | }
65 |
66 | /**
67 | * @return Label attached to the address
68 | */
69 | public String getLabel () {
70 | return label;
71 | }
72 |
73 | /**
74 | * @return Total received amount in satoshi
75 | */
76 | public long getTotalReceived () {
77 | return totalReceived;
78 | }
79 | }
80 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/wallet/entity/CreateWalletResponse.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.wallet.entity;
2 |
3 | /**
4 | * Used in response to the `create` method in the `CreateWallet` class.
5 | */
6 | public class CreateWalletResponse {
7 | private String identifier;
8 | private String address;
9 | private String label;
10 |
11 | public CreateWalletResponse (String identifier, String address, String label) {
12 | this.identifier = identifier;
13 | this.address = address;
14 | this.label = label;
15 | }
16 |
17 | /**
18 | * @return Wallet identifier (GUID)
19 | */
20 | public String getIdentifier () {
21 | return identifier;
22 | }
23 |
24 | /**
25 | * @return First address in the wallet
26 | */
27 | public String getAddress () {
28 | return address;
29 | }
30 |
31 | /**
32 | * @return Label of first address in the wallet
33 | */
34 | public String getLable () {
35 | return label;
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/src/main/java/info/blockchain/api/wallet/entity/PaymentResponse.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.wallet.entity;
2 |
3 | /**
4 | * Used in response to the `send` and `sendMany` methods in the `Wallet` class.
5 | */
6 | public class PaymentResponse {
7 | private String message;
8 | private String txHash;
9 | private String notice;
10 |
11 | public PaymentResponse (String message, String txHash, String notice) {
12 | this.message = message;
13 | this.txHash = txHash;
14 | this.notice = notice;
15 | }
16 |
17 | @Override
18 | public boolean equals (Object o) {
19 | if (o == null) {
20 | return false;
21 | }
22 | if (o instanceof PaymentResponse) {
23 | PaymentResponse that = (PaymentResponse) o;
24 | return (this.getMessage().equals(that.getMessage()) && this.getTxHash().equals(that.getTxHash()) && this.getNotice().equals(that.getNotice()));
25 | }
26 | return false;
27 | }
28 |
29 | /**
30 | * @return Response message from the server
31 | */
32 | public String getMessage () {
33 | return message;
34 | }
35 |
36 | /**
37 | * @return Transaction hash
38 | */
39 | public String getTxHash () {
40 | return txHash;
41 | }
42 |
43 | /**
44 | * @return Additional response message from the server
45 | */
46 | public String getNotice () {
47 | return notice;
48 | }
49 |
50 | }
51 |
--------------------------------------------------------------------------------
/src/test/java/info/blockchain/api/AppTest.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api;
2 |
3 | import junit.framework.Test;
4 | import junit.framework.TestCase;
5 | import junit.framework.TestSuite;
6 |
7 | /**
8 | * Unit test for simple App.
9 | */
10 | public class AppTest extends TestCase {
11 | /**
12 | * Create the test case
13 | *
14 | * @param testName name of the test case
15 | */
16 | public AppTest (String testName) {
17 | super(testName);
18 | }
19 |
20 | /**
21 | * @return the suite of tests being tested
22 | */
23 | public static Test suite () {
24 | return new TestSuite(AppTest.class);
25 | }
26 |
27 | /**
28 | * Rigourous Test :-)
29 | */
30 | public void testApp () {
31 | assertTrue(true);
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/test/java/info/blockchain/api/blockexplorer/BlockExplorerTest.java:
--------------------------------------------------------------------------------
1 | package info.blockchain.api.blockexplorer;
2 |
3 | import info.blockchain.api.blockexplorer.entity.*;
4 | import org.junit.Assert;
5 | import org.junit.Before;
6 | import org.junit.Test;
7 |
8 | import java.util.Arrays;
9 | import java.util.List;
10 | import java.util.Map;
11 |
12 | import static org.junit.Assert.*;
13 |
14 | /**
15 | * Created by ray on 10/05/2017.
16 | */
17 | public class BlockExplorerTest {
18 |
19 | BlockExplorer client;
20 |
21 | @Before
22 | public void setUp () throws Exception {
23 | client = new BlockExplorer();
24 | }
25 |
26 | @Test
27 | public void getAddress () throws Exception {
28 | Address address = client.getAddress("1jH7K4RJrQBXijtLj1JpzqPRhR7MdFtaW", FilterType.All, 10, null);
29 |
30 | assertEquals("1jH7K4RJrQBXijtLj1JpzqPRhR7MdFtaW", address.getAddress());
31 | assertEquals("07feead7f9fb7d16a0251421ac9fa090169cc169",
32 | address.getHash160());
33 | assertEquals(0, address.getFinalBalance());
34 | assertEquals(16, address.getTxCount());
35 | assertEquals(605204 , address.getTotalReceived());
36 | assertEquals(605204 , address.getTotalSent());
37 | assertEquals(10, address.getTransactions().size());
38 | }
39 |
40 | @Test
41 | public void getUnspentOutputs () throws Exception {
42 | String address1 = "1FrWWFJ95Jq7EDgpkeBwVLAtoJMPwmYS7T";
43 | String address2 = "xpub6CmZamQcHw2TPtbGmJNEvRgfhLwitarvzFn3fBYEEkFTqztus7W7CNbf48Kxuj1bRRBmZPzQocB6qar9ay6buVkQk73ftKE1z4tt9cPHWRn";
44 | List unspentOutputs = client.getUnspentOutputs(Arrays.asList(address1, address2), 6, 10);
45 |
46 | assertTrue(unspentOutputs != null && unspentOutputs.size() != 0);
47 | assertEquals("2e7ab41818ee0ab987d393d4c8bf5e436b6e8c15ef3535a2b3eac581e33c7472", unspentOutputs.get(0).getTransactionHash());
48 | assertEquals(20000, unspentOutputs.get(0).getValue());
49 | }
50 |
51 | @Test
52 | public void getBalance () throws Exception {
53 | String address1 = "1jH7K4RJrQBXijtLj1JpzqPRhR7MdFtaW";
54 | String address2 = "xpub6CmZamQcHw2TPtbGmJNEvRgfhLwitarvzFn3fBYEEkFTqztus7W7CNbf48Kxuj1bRRBmZPzQocB6qar9ay6buVkQk73ftKE1z4tt9cPHWRn";
55 |
56 | List list = Arrays.asList(address1, address2);
57 |
58 | Map balances = client.getBalance(list, FilterType.All);
59 |
60 | assertEquals(0, balances.get(address1).getFinalBalance());
61 | assertEquals(16, balances.get(address1).getTxCount());
62 | assertEquals(605204, balances.get(address1).getTotalReceived());
63 | assertEquals(20000, balances.get(address2).getFinalBalance());
64 | assertEquals(1, balances.get(address2).getTxCount());
65 | assertEquals(20000, balances.get(address2).getTotalReceived());
66 | }
67 |
68 | @Test
69 | public void getXpub () throws Exception {
70 | String address = "xpub6CmZamQcHw2TPtbGmJNEvRgfhLwitarvzFn3fBYEEkFTqztus7W7CNbf48Kxuj1bRRBmZPzQocB6qar9ay6buVkQk73ftKE1z4tt9cPHWRn";
71 | XpubFull xpub = client.getXpub(address, null, null, null);
72 |
73 | assertEquals(xpub.getAddress(),
74 | "xpub6CmZamQcHw2TPtbGmJNEvRgfhLwitarvzFn3fBYEEkFTqztus7W7CNbf48Kxuj1bRRBmZPzQocB6qar9ay6buVkQk73ftKE1z4tt9cPHWRn");
75 | assertEquals(1, xpub.getTxCount());
76 | assertEquals(20000, xpub.getTotalReceived());
77 | assertEquals(0, xpub.getTotalSent());
78 | assertEquals(20000, xpub.getFinalBalance());
79 | assertEquals(0, xpub.getChangeIndex());
80 | assertEquals(1, xpub.getAccountIndex());
81 | assertEquals(0, xpub.getGapLimit());
82 | }
83 |
84 | }
--------------------------------------------------------------------------------