@Override public BitAddress newAddress(String addressStr) throws AddressMalformedException { return BitAddress.from(this, addressStr); } }
public BitAddress getAddress() { lock.lock(); try { return BitAddress.from(type, keys.getKey(null)); } finally { lock.unlock(); } }
@Override public AbstractAddress getReceiveAddress() { lock.lock(); try { return BitAddress.from(type, keys.getKey(null)); } finally { lock.unlock(); } }
@Override public List<AbstractAddress> getActiveAddresses() { lock.lock(); try { ImmutableList.Builder<AbstractAddress> activeAddresses = ImmutableList.builder(); for (DeterministicKey key : keys.getActiveKeys()) { activeAddresses.add(BitAddress.from(type, key)); } return activeAddresses.build(); } finally { lock.unlock(); } }
@Override public List<AbstractAddress> getActiveAddresses() { lock.lock(); try { ImmutableList.Builder<AbstractAddress> activeAddresses = ImmutableList.builder(); for (ECKey key : keys.getKeys()) { activeAddresses.add(BitAddress.from(type, key)); } return activeAddresses.build(); } finally { lock.unlock(); } }
/** * Get the last used receiving address */ @Nullable public BitAddress getLastUsedAddress(SimpleHDKeyChain.KeyPurpose purpose) { lock.lock(); try { DeterministicKey lastUsedKey = keys.getLastIssuedKey(purpose); if (lastUsedKey != null) { return BitAddress.from(type, lastUsedKey); } else { return null; } } finally { lock.unlock(); } }
/** * Get the currently latest unused address by purpose. */ @VisibleForTesting BitAddress currentAddress(SimpleHDKeyChain.KeyPurpose purpose) { lock.lock(); try { return BitAddress.from(type, keys.getCurrentUnusedKey(purpose)); } finally { lock.unlock(); subscribeToAddressesIfNeeded(); } }
/** * Returns a list of addresses that have been issued. * The list is sorted in descending chronological order: older in the end */ public List<AbstractAddress> getIssuedReceiveAddresses() { lock.lock(); try { ArrayList<DeterministicKey> issuedKeys = keys.getIssuedExternalKeys(); ArrayList<AbstractAddress> receiveAddresses = new ArrayList<>(); Collections.sort(issuedKeys, HD_KEY_COMPARATOR); for (ECKey key : issuedKeys) { receiveAddresses.add(BitAddress.from(type, key)); } return receiveAddresses; } finally { lock.unlock(); } }
public static boolean producesAddress(Script script, AbstractAddress address) { try { return BitAddress.from(address.getType(), script).equals(address); } catch (AddressMalformedException e) { return false; } } }
@Override public List<AbstractOutput> getSentTo() { List<AbstractOutput> outputs = new ArrayList<>(); for (TransactionOutput output : getOutputs(false)) { try { AbstractAddress address = BitAddress.from(type, output.getScriptPubKey()); outputs.add(new AbstractOutput(address, type.value(output.getValue()))); } catch (Exception e) { /* ignore this output */ } } return outputs; }
@Override public void verifyMessage(SignedMessage signedMessage) { try { ECKey pubKey = ECKey.signedMessageToKey( type.getSignedMessageHeader(), signedMessage.message, signedMessage.signature); byte[] expectedPubKeyHash = BitAddress.from(type, signedMessage.address).getHash160(); if (Arrays.equals(expectedPubKeyHash, pubKey.getPubKeyHash())) { signedMessage.status = SignedMessage.Status.VerifiedOK; } else { signedMessage.status = SignedMessage.Status.InvalidSigningAddress; } } catch (SignatureException e) { signedMessage.status = SignedMessage.Status.InvalidMessageSignature; } catch (AddressMalformedException e) { signedMessage.status = SignedMessage.Status.AddressMalformed; } }
@Override public void handle(CallMessage message) { try { AbstractAddress address = BitAddress.from(type, message.getParams().getString(0)); AddressStatus status; if (message.getParams().isNull(1)) { status = new AddressStatus(address, null); } else { status = new AddressStatus(address, message.getParams().getString(1)); } listener.onAddressStatusUpdate(status); } catch (AddressMalformedException e) { log.error("Address subscribe sent a malformed address", e); } catch (JSONException e) { log.error("Unexpected JSON format", e); } } };
@Override public void signMessage(SignedMessage unsignedMessage, @Nullable KeyParameter aesKey) { String message = unsignedMessage.message; lock.lock(); try { ECKey key; try { BitAddress address = BitAddress.from(type, unsignedMessage.getAddress()); key = findKeyFromPubHash(address.getHash160()); } catch (AddressMalformedException e) { unsignedMessage.status = SignedMessage.Status.AddressMalformed; return; } if (key == null) { unsignedMessage.status = SignedMessage.Status.MissingPrivateKey; return; } try { unsignedMessage.signature = key.signMessage(type.getSignedMessageHeader(), message, aesKey); unsignedMessage.status = SignedMessage.Status.SignedOK; } catch (ECKey.KeyIsEncryptedException e) { unsignedMessage.status = SignedMessage.Status.KeyIsEncrypted; } catch (ECKey.MissingPrivateKeyException e) { unsignedMessage.status = SignedMessage.Status.MissingPrivateKey; } } finally { lock.unlock(); } }
}; assertEquals(BTC_P2PKH_ADDR, BitAddress.from(BTC, BTC_P2PKH_ADDR).toString()); assertEquals(BTC_P2PKH_ADDR, BitAddress.from(BTC, BTC.getAddressHeader(), HASH160).toString()); assertEquals(BTC_P2PKH_ADDR, BitAddress.from(BTC, new Script(P2PKH_SCRIPT)).toString()); assertEquals(BTC_P2PKH_ADDR, BitAddress.from(BTC, pubKey).toString()); assertEquals(BTC_P2PKH_ADDR, BitAddress.from(abstractAddress).toString()); assertEquals(BTC_P2PKH_ADDR, BitAddress.from(address).toString()); assertEquals(BTC_P2SH_ADDR, BitAddress.from(BTC, BTC_P2SH_ADDR).toString()); assertEquals(BTC_P2SH_ADDR, BitAddress.from(BTC, BTC.getP2SHHeader(), HASH160).toString()); assertEquals(BTC_P2SH_ADDR, BitAddress.from(BTC, new Script(P2SH_SCRIPT)).toString()); assertEquals(BTC_P2SH_ADDR, BitAddress.from(abstractAddress).toString()); assertEquals(BTC_P2SH_ADDR, BitAddress.from(address).toString()); assertEquals(LTC_P2PKH_ADDR, BitAddress.from(LTC, LTC_P2PKH_ADDR).toString()); assertEquals(LTC_P2PKH_ADDR, BitAddress.from(LTC, LTC.getAddressHeader(), HASH160).toString()); assertEquals(LTC_P2PKH_ADDR, BitAddress.from(LTC, new Script(P2PKH_SCRIPT)).toString()); assertEquals(LTC_P2PKH_ADDR, BitAddress.from(LTC, pubKey).toString()); assertEquals(LTC_P2PKH_ADDR, BitAddress.from(abstractAddress).toString()); assertEquals(LTC_P2PKH_ADDR, BitAddress.from(address).toString()); assertEquals(LTC_P2SH_ADDR, BitAddress.from(LTC, LTC_P2SH_ADDR).toString()); assertEquals(LTC_P2SH_ADDR, BitAddress.from(LTC, LTC.getP2SHHeader(), HASH160).toString()); assertEquals(LTC_P2SH_ADDR, BitAddress.from(LTC, new Script(P2SH_SCRIPT)).toString()); assertEquals(LTC_P2SH_ADDR, BitAddress.from(abstractAddress).toString()); assertEquals(LTC_P2SH_ADDR, BitAddress.from(address).toString());
@Test public void testAltChainsGoodAmount() throws Exception { byte[] hash160 = BitAddress.from(BitcoinMain.get(), MAINNET_GOOD_ADDRESS).getHash160(); String goodAddressStr; BitAddress goodAddress; // Litecoin goodAddress = BitAddress.from(LTC, hash160); goodAddressStr = goodAddress.toString(); testObject = new CoinURI(LTC, "litecoin:" + goodAddressStr + "?amount=12.34"); assertEquals("12.34", GenericUtils.formatCoinValue(LTC, testObject.getAmount())); // Dogecoin goodAddress = BitAddress.from(DOGE, hash160); goodAddressStr = goodAddress.toString(); testObject = new CoinURI(DOGE, "dogecoin:" + goodAddressStr + "?amount=12.34"); assertEquals("12.34", GenericUtils.formatCoinValue(DOGE, testObject.getAmount())); // Peercoin goodAddress = BitAddress.from(PPC, hash160); goodAddressStr = goodAddress.toString(); testObject = new CoinURI(PPC, "peercoin:" + goodAddressStr + "?amount=12.34"); assertEquals("12.34", GenericUtils.formatCoinValue(PPC, testObject.getAmount())); // Darkcoin goodAddress = BitAddress.from(DASH, hash160); goodAddressStr = goodAddress.toString(); testObject = new CoinURI(DASH, "dash:" + goodAddressStr + "?amount=12.34"); assertEquals("12.34", GenericUtils.formatCoinValue(DASH, testObject.getAmount())); }
@Test public void testAltChainsConvertToCoinURI() throws Exception { byte[] hash160 = BitAddress.from(BitcoinMain.get(), MAINNET_GOOD_ADDRESS).getHash160(); String goodAddressStr; BitAddress goodAddress; // Litecoin goodAddress = BitAddress.from(LTC, hash160); goodAddressStr = goodAddress.toString(); assertEquals("litecoin:" + goodAddressStr + "?amount=12.34&label=Hello&message=AMessage", CoinURI.convertToCoinURI(goodAddress, LTC.value("12.34"), "Hello", "AMessage")); // Dogecoin goodAddress = BitAddress.from(DOGE, hash160); goodAddressStr = goodAddress.toString(); assertEquals("dogecoin:" + goodAddressStr + "?amount=12.34&label=Hello&message=AMessage", CoinURI.convertToCoinURI(goodAddress, DOGE.value("12.34"), "Hello", "AMessage")); // Peercoin goodAddress = BitAddress.from(PPC, hash160); goodAddressStr = goodAddress.toString(); assertEquals("peercoin:" + goodAddressStr + "?amount=12.34&label=Hello&message=AMessage", CoinURI.convertToCoinURI(goodAddress, PPC.value("12.34"), "Hello", "AMessage")); // Darkcoin goodAddress = BitAddress.from(DASH, hash160); goodAddressStr = goodAddress.toString(); assertEquals("dash:" + goodAddressStr + "?amount=12.34&label=Hello&message=AMessage", CoinURI.convertToCoinURI(goodAddress, DASH.value("12.34"), "Hello", "AMessage")); // NXT String pubkeyStr = "3c1c0b3f8f87d6efdc2694ce43f848375a4f761624d255e5fc1194a4ebc76755"; byte[] pubkey = Hex.decode(pubkeyStr); NxtAddress nxtGoodAddress = new NxtAddress(NXT, pubkey); goodAddressStr = nxtGoodAddress.toString(); assertEquals("nxt:" + goodAddressStr + "?amount=12.34&label=Hello&message=AMessage&pubkey="+pubkeyStr, CoinURI.convertToCoinURI(nxtGoodAddress, NXT.value("12.34"), "Hello", "AMessage", pubkeyStr)); }
@Test public void testSharedCoinURI() throws Exception { byte[] hash160 = BitAddress.from(BitcoinMain.get(), MAINNET_GOOD_ADDRESS).getHash160(); // Bitcoin and Bitcoin Testnet BitAddress address = BitAddress.from(BTC, hash160); testObject = new CoinURI(BTC.getUriScheme() + ":" + address); assertTrue(testObject.hasType()); assertEquals(BTC, testObject.getType()); assertEquals(address, testObject.getAddress()); BitAddress addressTestnet = BitAddress.from(BTC_TEST, hash160); testObject = new CoinURI(BTC_TEST.getUriScheme() + ":" + addressTestnet); assertEquals(BTC_TEST, testObject.getType()); assertEquals(addressTestnet, testObject.getAddress()); // NuBits and NuShares BitAddress nuBitAddress = BitAddress.from(NBT, hash160); testObject = new CoinURI(NBT.getUriScheme() + ":" + nuBitAddress); assertEquals(NBT, testObject.getType()); assertEquals(nuBitAddress, testObject.getAddress()); BitAddress nuSharesAddress = BitAddress.from(NSR, hash160); testObject = new CoinURI(NSR.getUriScheme() + ":" + nuSharesAddress); assertEquals(NSR, testObject.getType()); assertEquals(nuSharesAddress, testObject.getAddress()); }
@Test public void createDustTransactionFee() throws Exception { pocket.onConnection(getBlockchainConnection(DOGE)); BitAddress toAddr = BitAddress.from(DOGE, "nZB8PHkfgJvuCJqchSexmfY3ABXa2aE1vp"); Value softDust = DOGE.getSoftDustLimit(); assertNotNull(softDust); // Send a soft dust BitSendRequest sendRequest = pocket.sendCoinsOffline(toAddr, softDust.subtract(DOGE.value(1))); pocket.completeTransaction(sendRequest); assertEquals(DOGE.getFeeValue().multiply(2), sendRequest.tx.getFee()); }
@Test public void createTransactionAndBroadcast() throws Exception { pocket.onConnection(getBlockchainConnection(DOGE)); BitAddress toAddr = BitAddress.from(DOGE, "nZB8PHkfgJvuCJqchSexmfY3ABXa2aE1vp"); Value orgBalance = pocket.getBalance(); BitSendRequest sendRequest = pocket.sendCoinsOffline(toAddr, DOGE.value(AMOUNT_TO_SEND)); sendRequest.shuffleOutputs = false; sendRequest.feePerTxSize = DOGE.value(0); pocket.completeTransaction(sendRequest); // FIXME, mock does not work here // pocket.broadcastTx(tx); pocket.addNewTransactionIfNeeded(sendRequest.tx); assertEquals(orgBalance.subtract(AMOUNT_TO_SEND), pocket.getBalance()); }
@Test public void testConvertToCoinURI() throws Exception { BitAddress goodAddress = BitAddress.from(BitcoinMain.get(), MAINNET_GOOD_ADDRESS); // simple example assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?amount=12.34&label=Hello&message=AMessage", CoinURI.convertToCoinURI(goodAddress, BTC.value("12.34"), "Hello", "AMessage")); // example with spaces, ampersand and plus assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?amount=12.34&label=Hello%20World&message=Mess%20%26%20age%20%2B%20hope", CoinURI.convertToCoinURI(goodAddress, BTC.value("12.34"), "Hello World", "Mess & age + hope")); // no amount, label present, message present assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?label=Hello&message=glory", CoinURI.convertToCoinURI(goodAddress, null, "Hello", "glory")); // amount present, no label, message present assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?amount=0.1&message=glory", CoinURI.convertToCoinURI(goodAddress, BTC.value("0.1"), null, "glory")); assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?amount=0.1&message=glory", CoinURI.convertToCoinURI(goodAddress, BTC.value("0.1"), "", "glory")); // amount present, label present, no message assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?amount=12.34&label=Hello", CoinURI.convertToCoinURI(goodAddress, BTC.value("12.34"), "Hello", null)); assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?amount=12.34&label=Hello", CoinURI.convertToCoinURI(goodAddress, BTC.value("12.34"), "Hello", "")); // amount present, no label, no message assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?amount=1000", CoinURI.convertToCoinURI(goodAddress, BTC.value("1000"), null, null)); assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?amount=1000", CoinURI.convertToCoinURI(goodAddress, BTC.value("1000"), "", "")); // no amount, label present, no message assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?label=Hello", CoinURI.convertToCoinURI(goodAddress, null, "Hello", null)); // no amount, no label, message present assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?message=Agatha", CoinURI.convertToCoinURI(goodAddress, null, null, "Agatha")); assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS + "?message=Agatha", CoinURI.convertToCoinURI(goodAddress, null, "", "Agatha")); // no amount, no label, no message assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS, CoinURI.convertToCoinURI(goodAddress, null, null, null)); assertEquals("bitcoin:" + MAINNET_GOOD_ADDRESS, CoinURI.convertToCoinURI(goodAddress, null, "", "")); }