@Test public void isBIPs() throws Exception { final MainNetParams mainnet = MainNetParams.get(); final Block genesis = mainnet.getGenesisBlock(); assertFalse(genesis.isBIP34()); assertFalse(genesis.isBIP66()); assertFalse(genesis.isBIP65()); assertFalse(genesis.isBIP101()); // 227835/00000000000001aa077d7aa84c532a4d69bdbff519609d1da0835261b7a74eb6: last version 1 block final Block block227835 = mainnet .getDefaultSerializer() .makeBlock(ByteStreams.toByteArray(getClass().getResourceAsStream("block227835.dat"))); assertFalse(block227835.isBIP34()); assertFalse(block227835.isBIP66()); assertFalse(block227835.isBIP65()); assertFalse(block227835.isBIP101()); // 227836/00000000000000d0dfd4c9d588d325dce4f32c1b31b7c0064cba7025a9b9adcc: version 2 block final Block block227836 = mainnet .getDefaultSerializer() .makeBlock(ByteStreams.toByteArray(getClass().getResourceAsStream("block227836.dat"))); assertTrue(block227836.isBIP34()); assertFalse(block227836.isBIP66()); assertFalse(block227836.isBIP65()); assertFalse(block227836.isBIP101()); // 363703/0000000000000000011b2a4cb91b63886ffe0d2263fd17ac5a9b902a219e0a14: version 3 block final Block block363703 = mainnet .getDefaultSerializer() .makeBlock(ByteStreams.toByteArray(getClass().getResourceAsStream("block363703.dat"))); assertTrue(block363703.isBIP34()); assertTrue(block363703.isBIP66()); assertFalse(block363703.isBIP65()); assertFalse(block363703.isBIP101()); // 383616/00000000000000000aab6a2b34e979b09ca185584bd1aecf204f24d150ff55e9: version 4 block final Block block383616 = mainnet .getDefaultSerializer() .makeBlock(ByteStreams.toByteArray(getClass().getResourceAsStream("block383616.dat"))); assertTrue(block383616.isBIP34()); assertTrue(block383616.isBIP66()); assertTrue(block383616.isBIP65()); assertFalse(block383616.isBIP101()); // 370661/00000000000000001416a613602d73bbe5c79170fd8f39d509896b829cf9021e final Block block370661 = mainnet .getDefaultSerializer() .makeBlock(ByteStreams.toByteArray(getClass().getResourceAsStream("block370661.dat"))); assertTrue(block370661.isBIP34()); assertTrue(block370661.isBIP66()); assertTrue(block370661.isBIP65()); assertTrue(block370661.isBIP101()); }
private void parsePaymentRequest(Protos.PaymentRequest request) throws PaymentProtocolException { try { if (request == null) throw new PaymentProtocolException("request cannot be null"); if (request.getPaymentDetailsVersion() != 1) throw new PaymentProtocolException.InvalidVersion( "Version 1 required. Received version " + request.getPaymentDetailsVersion()); paymentRequest = request; if (!request.hasSerializedPaymentDetails()) throw new PaymentProtocolException("No PaymentDetails"); paymentDetails = Protos.PaymentDetails.newBuilder() .mergeFrom(request.getSerializedPaymentDetails()) .build(); if (paymentDetails == null) throw new PaymentProtocolException("Invalid PaymentDetails"); if (!paymentDetails.hasNetwork()) params = MainNetParams.get(); else params = NetworkParameters.fromPmtProtocolID(paymentDetails.getNetwork()); if (params == null) throw new PaymentProtocolException.InvalidNetwork( "Invalid network " + paymentDetails.getNetwork()); if (paymentDetails.getOutputsCount() < 1) throw new PaymentProtocolException.InvalidOutputs("No outputs"); for (Protos.Output output : paymentDetails.getOutputsList()) { if (output.hasAmount()) totalValue = totalValue.add(Coin.valueOf(output.getAmount())); } // This won't ever happen in practice. It would only happen if the user provided outputs // that are obviously invalid. Still, we don't want to silently overflow. if (params.hasMaxMoney() && totalValue.compareTo(params.getMaxMoney()) > 0) throw new PaymentProtocolException.InvalidOutputs("The outputs are way too big."); } catch (InvalidProtocolBufferException e) { throw new PaymentProtocolException(e); } }
@Test public void testLastBlockSeenHash() throws Exception { // Test the lastBlockSeenHash field works. // LastBlockSeenHash should be empty if never set. Wallet wallet = new Wallet(params); Protos.Wallet walletProto = new WalletProtobufSerializer().walletToProto(wallet); ByteString lastSeenBlockHash = walletProto.getLastSeenBlockHash(); assertTrue(lastSeenBlockHash.isEmpty()); // Create a block. Block block = params.getDefaultSerializer().makeBlock(BlockTest.blockBytes); Sha256Hash blockHash = block.getHash(); wallet.setLastBlockSeenHash(blockHash); wallet.setLastBlockSeenHeight(1); // Roundtrip the wallet and check it has stored the blockHash. Wallet wallet1 = roundTrip(wallet); assertEquals(blockHash, wallet1.getLastBlockSeenHash()); assertEquals(1, wallet1.getLastBlockSeenHeight()); // Test the Satoshi genesis block (hash of all zeroes) is roundtripped ok. Block genesisBlock = MainNetParams.get().getGenesisBlock(); wallet.setLastBlockSeenHash(genesisBlock.getHash()); Wallet wallet2 = roundTrip(wallet); assertEquals(genesisBlock.getHash(), wallet2.getLastBlockSeenHash()); }
/** * Returns the network parameters for the given string paymentProtocolID or NULL if not * recognized. */ @Nullable public static NetworkParameters fromPmtProtocolID(String pmtProtocolId) { if (pmtProtocolId.equals(PAYMENT_PROTOCOL_ID_MAINNET)) { return MainNetParams.get(); } else if (pmtProtocolId.equals(PAYMENT_PROTOCOL_ID_TESTNET)) { return TestNet3Params.get(); } else { return null; } }
public NetworkParameters get() { switch (this) { case MAIN: case PROD: return MainNetParams.get(); case TEST: return TestNet3Params.get(); case REGTEST: default: return RegTestParams.get(); } }
public static NetworkParameters getNetworkParameter(BlockchainNetworkType blockchainNetworkType) { switch (blockchainNetworkType) { case PRODUCTION: return MainNetParams.get(); case TEST_NET: return TestNet3Params.get(); case REG_TEST: return RegTestParams.get(); default: return getNetworkParameter(BitcoinNetworkConfiguration.DEFAULT_NETWORK_TYPE); } }
/** Returns the network parameters for the given string ID or NULL if not recognized. */ @Nullable public static NetworkParameters fromID(String id) { if (id.equals(ID_MAINNET)) { return MainNetParams.get(); } else if (id.equals(ID_TESTNET)) { return TestNet3Params.get(); } else if (id.equals(ID_UNITTESTNET)) { return UnitTestParams.get(); } else if (id.equals(ID_REGTEST)) { return RegTestParams.get(); } else { return null; } }
/** * Gets the correct BlockchainNetworkType based in the passed NetworkParameters * * @param networkParameters * @return */ public static BlockchainNetworkType getBlockchainNetworkType( NetworkParameters networkParameters) { /** I will return the correct network type. */ BlockchainNetworkType blockchainNetworkType = null; if (networkParameters == RegTestParams.get()) { blockchainNetworkType = BlockchainNetworkType.REG_TEST; } else if (networkParameters == MainNetParams.get()) { blockchainNetworkType = BlockchainNetworkType.PRODUCTION; } else if (networkParameters == TestNet3Params.get()) { blockchainNetworkType = BlockchainNetworkType.TEST_NET; } return blockchainNetworkType; }
@Test public void testFirst100KBlocks() throws Exception { NetworkParameters params = MainNetParams.get(); Context context = new Context(params); File blockFile = new File(getClass().getResource("first-100k-blocks.dat").getFile()); BlockFileLoader loader = new BlockFileLoader(params, Arrays.asList(blockFile)); store = createStore(params, 10); resetStore(store); chain = new FullPrunedBlockChain(context, store); for (Block block : loader) chain.add(block); try { store.close(); } catch (Exception e) { } }
@Test public void testReceiveCoinbaseTransaction() throws Exception { // Block 169482 (hash 0000000000000756935f1ee9d5987857b604046f846d3df56d024cdb5f368665) // contains coinbase transactions that are mining pool shares. // The private key MINERS_KEY is used to check transactions are received by a wallet correctly. // The address for this private key is 1GqtGtn4fctXuKxsVzRPSLmYWN1YioLi9y. final String MINING_PRIVATE_KEY = "5JDxPrBRghF1EvSBjDigywqfmAjpHPmTJxYtQTYJxJRHLLQA4mG"; final long BLOCK_NONCE = 3973947400L; final Coin BALANCE_AFTER_BLOCK = Coin.valueOf(22223642); final NetworkParameters PARAMS = MainNetParams.get(); Block block169482 = PARAMS .getDefaultSerializer() .makeBlock(ByteStreams.toByteArray(getClass().getResourceAsStream("block169482.dat"))); // Check block. assertNotNull(block169482); block169482.verify(169482, EnumSet.noneOf(Block.VerifyFlag.class)); assertEquals(BLOCK_NONCE, block169482.getNonce()); StoredBlock storedBlock = new StoredBlock(block169482, BigInteger.ONE, 169482); // Nonsense work - not used in test. // Create a wallet contain the miner's key that receives a spend from a coinbase. ECKey miningKey = DumpedPrivateKey.fromBase58(PARAMS, MINING_PRIVATE_KEY).getKey(); assertNotNull(miningKey); Context context = new Context(PARAMS); Wallet wallet = new Wallet(context); wallet.importKey(miningKey); // Initial balance should be zero by construction. assertEquals(Coin.ZERO, wallet.getBalance()); // Give the wallet the first transaction in the block - this is the coinbase tx. List<Transaction> transactions = block169482.getTransactions(); assertNotNull(transactions); wallet.receiveFromBlock(transactions.get(0), storedBlock, NewBlockType.BEST_CHAIN, 0); // Coinbase transaction should have been received successfully but be unavailable to spend (too // young). assertEquals(BALANCE_AFTER_BLOCK, wallet.getBalance(BalanceType.ESTIMATED)); assertEquals(Coin.ZERO, wallet.getBalance(BalanceType.AVAILABLE)); }
public void checkUpgrade(Context context, NetworkParameters params) { if (checkDone) { // skip if already done return; } String appVersion = SharedPrefUtils.getAppVersion(context); if (appVersion == null) { // first start - no app version yet. Log.d(TAG, "No appVersion yet - first launch"); } else if (appVersion.equals(BuildConfig.VERSION_NAME)) { Log.d(TAG, "appVersion '" + appVersion + "' equals current version - no action required"); } else { // add upgrade instructions as needed. } if (migrateFrom_v1_0_262(context)) { Log.d(TAG, "Migrate from v1.0.262 / 2of2 multisig (CeBIT) to CLTV"); /* special case: migrate from objectstore and 2of2 multisig wallet * - migrate from early version v1.0.262 (CeBIT) * - enable transfer of funds to new address (2of2 multisig to cltv) */ try { // migration is done for mainnet and testnet regardless of the current network setting of // the app! NetworkParameters[] cltvMigrationParams = new NetworkParameters[] {MainNetParams.get(), TestNet3Params.get()}; for (NetworkParameters migrationParams : cltvMigrationParams) { doMigrateFrom_v1_0_262(context, migrationParams); } } catch (Exception e) { Log.e(TAG, "Migration failed: ", e); } } SharedPrefUtils.setAppVersion(context, BuildConfig.VERSION_NAME); checkDone = true; }
/** @author Andreas Schildbach */ public final class Constants { public static final boolean TEST = R.class.getPackage().getName().contains("_test"); /** Network this wallet is on (e.g. testnet or mainnet). */ public static final NetworkParameters NETWORK_PARAMETERS = TEST ? TestNet3Params.get() : MainNetParams.get(); public static final class Files { private static final String FILENAME_NETWORK_SUFFIX = NETWORK_PARAMETERS.getId().equals(NetworkParameters.ID_MAINNET) ? "" : "-testnet"; /** Filename of the wallet. */ public static final String WALLET_FILENAME_PROTOBUF = "wallet-protobuf" + FILENAME_NETWORK_SUFFIX; /** Filename of the automatic key backup (old format, can only be read). */ public static final String WALLET_KEY_BACKUP_BASE58 = "key-backup-base58" + FILENAME_NETWORK_SUFFIX; /** Filename of the automatic wallet backup. */ public static final String WALLET_KEY_BACKUP_PROTOBUF = "key-backup-protobuf" + FILENAME_NETWORK_SUFFIX; /** Path to external storage */ public static final File EXTERNAL_STORAGE_DIR = Environment.getExternalStorageDirectory(); /** Manual backups go here. */ public static final File EXTERNAL_WALLET_BACKUP_DIR = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS); /** Filename of the manual key backup (old format, can only be read). */ public static final String EXTERNAL_WALLET_KEY_BACKUP = "bitcoin-wallet-keys" + FILENAME_NETWORK_SUFFIX; /** Filename of the manual wallet backup. */ public static final String EXTERNAL_WALLET_BACKUP = "bitcoin-wallet-backup" + FILENAME_NETWORK_SUFFIX; /** Filename of the block store for storing the chain. */ public static final String BLOCKCHAIN_FILENAME = "blockchain" + FILENAME_NETWORK_SUFFIX; /** Filename of the block checkpoints file. */ public static final String CHECKPOINTS_FILENAME = "checkpoints" + FILENAME_NETWORK_SUFFIX + ".txt"; } /** Maximum size of backups. Files larger will be rejected. */ public static final long BACKUP_MAX_CHARS = 10000000; private static final String BITEASY_API_URL_PROD = "https://api.biteasy.com/blockchain/v1/"; private static final String BITEASY_API_URL_TEST = "https://api.biteasy.com/testnet/v1/"; /** Base URL for blockchain API. */ public static final String BITEASY_API_URL = NETWORK_PARAMETERS.getId().equals(NetworkParameters.ID_MAINNET) ? BITEASY_API_URL_PROD : BITEASY_API_URL_TEST; /** URL to fetch version alerts from. */ public static final String VERSION_URL = "https://wallet.schildbach.de/version"; /** MIME type used for transmitting single transactions. */ public static final String MIMETYPE_TRANSACTION = "application/x-btctx"; /** MIME type used for transmitting wallet backups. */ public static final String MIMETYPE_WALLET_BACKUP = "application/x-bitcoin-wallet-backup"; /** Number of confirmations until a transaction is fully confirmed. */ public static final int MAX_NUM_CONFIRMATIONS = 7; /** User-agent to use for network access. */ public static final String USER_AGENT = "Bitcoin Wallet"; /** Default currency to use if all default mechanisms fail. */ public static final String DEFAULT_EXCHANGE_CURRENCY = "USD"; /** Donation address for tip/donate action. */ public static final String DONATION_ADDRESS = "18CK5k1gajRKKSC7yVSTXT9LUzbheh1XY4"; /** Recipient e-mail address for reports. */ public static final String REPORT_EMAIL = "*****@*****.**"; /** Subject line for manually reported issues. */ public static final String REPORT_SUBJECT_ISSUE = "Reported issue"; /** Subject line for crash reports. */ public static final String REPORT_SUBJECT_CRASH = "Crash report"; public static final char CHAR_HAIR_SPACE = '\u200a'; public static final char CHAR_THIN_SPACE = '\u2009'; public static final char CHAR_ALMOST_EQUAL_TO = '\u2248'; public static final char CHAR_CHECKMARK = '\u2713'; public static final char CURRENCY_PLUS_SIGN = '\uff0b'; public static final char CURRENCY_MINUS_SIGN = '\uff0d'; public static final String PREFIX_ALMOST_EQUAL_TO = Character.toString(CHAR_ALMOST_EQUAL_TO) + CHAR_THIN_SPACE; public static final int ADDRESS_FORMAT_GROUP_SIZE = 4; public static final int ADDRESS_FORMAT_LINE_SIZE = 12; public static final MonetaryFormat LOCAL_FORMAT = new MonetaryFormat().noCode().minDecimals(2).optionalDecimals(); public static final BaseEncoding HEX = BaseEncoding.base16().lowerCase(); public static final String SOURCE_URL = "https://github.com/schildbach/bitcoin-wallet"; public static final String BINARY_URL = "https://github.com/schildbach/bitcoin-wallet/releases"; public static final String MARKET_APP_URL = "market://details?id=%s"; public static final String WEBMARKET_APP_URL = "https://play.google.com/store/apps/details?id=%s"; public static final int HTTP_TIMEOUT_MS = 15 * (int) DateUtils.SECOND_IN_MILLIS; public static final int PEER_TIMEOUT_MS = 15 * (int) DateUtils.SECOND_IN_MILLIS; public static final long LAST_USAGE_THRESHOLD_JUST_MS = DateUtils.HOUR_IN_MILLIS; public static final long LAST_USAGE_THRESHOLD_RECENTLY_MS = 2 * DateUtils.DAY_IN_MILLIS; public static final int SDK_JELLY_BEAN = 16; public static final int SDK_JELLY_BEAN_MR2 = 18; public static final int SDK_LOLLIPOP = 21; public static final int SDK_DEPRECATED_BELOW = Build.VERSION_CODES.ICE_CREAM_SANDWICH; public static final boolean BUG_OPENSSL_HEARTBLEED = Build.VERSION.SDK_INT == Constants.SDK_JELLY_BEAN && Build.VERSION.RELEASE.startsWith("4.1.1"); public static final int MEMORY_CLASS_LOWEND = 48; }
/** Alias for MainNetParams.get(), use that instead */ @Deprecated public static NetworkParameters prodNet() { return MainNetParams.get(); }