public static BitAddress from(CoinType type, String address) throws AddressMalformedException { try { return new BitAddress(type, address); } catch (AddressFormatException e) { throw new AddressMalformedException(e); } }
@Override public BitAddress newAddress(String addressStr) throws AddressMalformedException { return BitAddress.from(this, addressStr); } }
@Override public long getId() { return ByteBuffer.wrap(getHash160()).getLong(); } }
@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())); }
@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; } }
@Test public void testConstructors() throws AddressFormatException { // BTC assertEquals(BTC_P2PKH_ADDR, new BitAddress(BTC, HASH160).toString()); assertEquals(BTC_P2PKH_ADDR, new BitAddress(BTC, BTC.getAddressHeader(), HASH160).toString()); assertEquals(BTC_P2PKH_ADDR, new BitAddress(BTC, BTC_P2PKH_ADDR).toString()); assertEquals(BTC_P2SH_ADDR, new BitAddress(BTC, BTC.getP2SHHeader(), HASH160).toString()); assertEquals(BTC_P2SH_ADDR, new BitAddress(BTC, BTC_P2SH_ADDR).toString()); // LTC assertEquals(LTC_P2PKH_ADDR, new BitAddress(LTC, HASH160).toString()); assertEquals(LTC_P2PKH_ADDR, new BitAddress(LTC, LTC.getAddressHeader(), HASH160).toString()); assertEquals(LTC_P2PKH_ADDR, new BitAddress(LTC, LTC_P2PKH_ADDR).toString()); assertEquals(LTC_P2SH_ADDR, new BitAddress(LTC, LTC.getP2SHHeader(), HASH160).toString()); assertEquals(LTC_P2SH_ADDR, new BitAddress(LTC, LTC_P2SH_ADDR).toString()); }
}; 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());
public static String addressSplitToGroups(final BitAddress address) { String addressStr = address.toString(); StringBuilder sb = new StringBuilder(); sb.append(addressStr.substring(0, 5)); sb.append(" "); sb.append(addressStr.substring(5, 9)); sb.append(" "); sb.append(addressStr.substring(9, 13)); sb.append(" "); sb.append(addressStr.substring(13, 17)); sb.append(" "); sb.append(addressStr.substring(17, 21)); sb.append(" "); sb.append(addressStr.substring(21, 25)); sb.append(" "); sb.append(addressStr.substring(25, 29)); sb.append(" "); sb.append(addressStr.substring(29)); return sb.toString(); }
@Override public CoinType getType() { return (CoinType) getParameters(); }
public static BitSendRequest emptyWallet(BitAddress destination) { checkNotNull(destination.getType(), "Address is for an unknown network"); checkTypeCompatibility(destination.getType()); BitSendRequest req = new BitSendRequest(destination.getType()); Transaction tx = new Transaction(req.type); tx.addOutput(Coin.ZERO, destination); req.tx = new BitTransaction(tx); req.emptyWallet = true; return req; }
public static boolean isP2SHAddress(AbstractAddress address) { checkArgument(address instanceof BitAddress, "This address cannot be a P2SH address"); return ((BitAddress) address).isP2SHAddress(); }
@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)); }
@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(); } }
public static String addressSplitToGroupsMultiline(final BitAddress address) { String addressStr = address.toString(); StringBuilder sb = new StringBuilder(); sb.append(addressStr.substring(0, 4)); sb.append(" "); sb.append(addressStr.substring(4, 8)); sb.append(" "); sb.append(addressStr.substring(8, 12)); sb.append(" "); sb.append(addressStr.substring(12, 17)); sb.append("\n"); sb.append(addressStr.substring(17, 21)); sb.append(" "); sb.append(addressStr.substring(21, 25)); sb.append(" "); sb.append(addressStr.substring(25, 29)); sb.append(" "); sb.append(addressStr.substring(29)); return sb.toString(); }
/** * {@link #sendCoinsOffline(BitAddress, Value)} */ public BitSendRequest sendCoinsOffline(BitAddress address, Value amount, @Nullable KeyParameter aesKey) throws WalletAccountException { checkState(address.getParameters() instanceof CoinType); BitSendRequest request = BitSendRequest.to(address, amount); request.aesKey = aesKey; return request; }
/** * <p>Creates a new SendRequest to the given address for the given value.</p> * * <p>Be very careful when value is smaller than {@link Transaction#MIN_NONDUST_OUTPUT} as the transaction will * likely be rejected by the network in this case.</p> */ public static BitSendRequest to(BitAddress destination, Value amount) { checkNotNull(destination.getType(), "Address is for an unknown network"); checkState(TypeUtils.is(destination.getType(), amount.type), "Incompatible sending amount type"); checkTypeCompatibility(destination.getType()); BitSendRequest req = new BitSendRequest(destination.getType()); Transaction tx = new Transaction(req.type); tx.addOutput(amount.toCoin(), destination); req.tx = new BitTransaction(tx); return req; }
byte[] hash160 = BitAddress.from(BitcoinMain.get(), MAINNET_GOOD_ADDRESS).getHash160(); String goodAddressStr; goodAddressStr = BitAddress.from(BTC_TEST, hash160).toString(); uri = new CoinURI("bitcoin:?req-addressrequest=https%3A%2F%2Fcoinomi.com&req-network=test"); assertTrue(uri.isAddressRequest()); goodAddressStr = BitAddress.from(NBT, hash160).toString(); uri = new CoinURI("nu:?req-addressrequest=https%3A%2F%2Fcoinomi.com"); assertTrue(uri.isAddressRequest()); goodAddressStr = BitAddress.from(NSR, hash160).toString(); uri = new CoinURI("nu:?req-addressrequest=https%3A%2F%2Fcoinomi.com&req-network=nsr.main"); assertTrue(uri.isAddressRequest());
public BitAddress getAddress() { lock.lock(); try { return BitAddress.from(type, keys.getKey(null)); } finally { lock.unlock(); } }
@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()); }