Minor debug alterations/fixes for blockchain downloading to make it play

marginally better with the braindead Go strategy.
Import key without address.

alethzero/MainWin.cpp

@@ -2114,14 +2114,14 @@ void Main::on_reencryptKey_triggered()
 			auto pw = [&](){
 				auto p = QInputDialog::getText(this, "Re-Encrypt Key", "Enter the original password for this key.\nHint: " + QString::fromStdString(m_keyManager.hint(a)), QLineEdit::Password, QString()).toStdString();
 				if (p.empty())
-					throw UnknownPassword();
+					throw PasswordUnknown();
 				return p;
 			};
 			while (!(password.empty() ? m_keyManager.recode(a, SemanticPassword::Master, pw, kdf) : m_keyManager.recode(a, password, hint, pw, kdf)))
 				if (QMessageBox::question(this, "Re-Encrypt Key", "Password given is incorrect. Would you like to try again?", QMessageBox::Retry, QMessageBox::Cancel) == QMessageBox::Cancel)
 					return;
 		}
-		catch (UnknownPassword&) {}
+		catch (PasswordUnknown&) {}
 	}
 }
 
@@ -2137,13 +2137,13 @@ void Main::on_reencryptAll_triggered()
 			while (!m_keyManager.recode(a, SemanticPassword::Existing, [&](){
 				auto p = QInputDialog::getText(nullptr, "Re-Encrypt Key", QString("Enter the original password for key %1.\nHint: %2").arg(QString::fromStdString(pretty(a))).arg(QString::fromStdString(m_keyManager.hint(a))), QLineEdit::Password, QString()).toStdString();
 				if (p.empty())
-					throw UnknownPassword();
+					throw PasswordUnknown();
 				return p;
 			}, (KDF)kdfs.indexOf(kdf)))
 				if (QMessageBox::question(this, "Re-Encrypt Key", "Password given is incorrect. Would you like to try again?", QMessageBox::Retry, QMessageBox::Cancel) == QMessageBox::Cancel)
 					return;
 	}
-	catch (UnknownPassword&) {}
+	catch (PasswordUnknown&) {}
 }
 
 void Main::on_go_triggered()

ethkey/KeyAux.h

@@ -102,6 +102,7 @@ public:
 		List,
 		New,
 		Import,
+		ImportWithAddress,
 		Export,
 		Recode,
 		Kill
@@ -159,6 +160,13 @@ public:
 			m_inputs = strings(1, argv[++i]);
 			m_name = argv[++i];
 		}
+		else if ((arg == "-i" || arg == "--import-with-address") && i + 3 < argc)
+		{
+			m_mode = OperationMode::ImportWithAddress;
+			m_inputs = strings(1, argv[++i]);
+			m_address = Address(argv[++i]);
+			m_name = argv[++i];
+		}
 		else if (arg == "--export")
 			m_mode = OperationMode::Export;
 		else if (arg == "--recode")
@@ -314,6 +322,33 @@ public:
 				cout << "  ICAP: " << ICAP(k.address()).encoded() << endl;
 				break;
 			}
+			case OperationMode::ImportWithAddress:
+			{
+				string const& i = m_inputs[0];
+				h128 u;
+				bytes b;
+				b = fromHex(i);
+				if (b.size() != 32)
+				{
+					std::string s = contentsString(i);
+					b = fromHex(s);
+					if (b.size() != 32)
+						u = wallet.store().importKey(i);
+				}
+				if (!u && b.size() == 32)
+					u = wallet.store().importSecret(b, lockPassword(toAddress(Secret(b)).abridged()));
+				if (!u)
+				{
+					cerr << "Cannot import " << i << " not a file or secret." << endl;
+					break;
+				}
+				wallet.importExisting(u, m_name, m_address);
+				cout << "Successfully imported " << i << ":" << endl;
+				cout << "  Name: " << m_name << endl;
+				cout << "  Address: " << m_address << endl;
+				cout << "  UUID: " << toUUID(u) << endl;
+				break;
+			}
 			case OperationMode::List:
 			{
 				vector<u128> bare;
@@ -369,6 +404,7 @@ public:
 			<< "    -l,--list  List all keys available in wallet." << endl
 			<< "    -n,--new <name>  Create a new key with given name and add it in the wallet." << endl
 			<< "    -i,--import [<uuid>|<file>|<secret-hex>] <name>  Import keys from given source and place in wallet." << endl
+			<< "    --import-with-address [<uuid>|<file>|<secret-hex>] <address> <name>  Import keys from given source with given address and place in wallet." << endl
 			<< "    -e,--export [ <address>|<uuid> , ... ]  Export given keys." << endl
 			<< "    -r,--recode [ <address>|<uuid>|<file> , ... ]  Decrypt and re-encrypt given keys." << endl
 			<< "Wallet configuration:" << endl
@@ -418,8 +454,9 @@ private:
 	string m_lockHint;
 	bool m_icap = true;
 
-	/// Creating
+	/// Creating/importing
 	string m_name;
+	Address m_address;
 
 	/// Importing
 	strings m_inputs;

libdevcore/CommonData.cpp

@@ -67,7 +67,7 @@ std::string dev::randomWord()
 	return ret;
 }
 
-int dev::fromHex(char _i)
+int dev::fromHex(char _i, WhenError _throw)
 {
 	if (_i >= '0' && _i <= '9')
 		return _i - '0';
@@ -75,7 +75,10 @@ int dev::fromHex(char _i)
 		return _i - 'a' + 10;
 	if (_i >= 'A' && _i <= 'F')
 		return _i - 'A' + 10;
-	BOOST_THROW_EXCEPTION(BadHexCharacter() << errinfo_invalidSymbol(_i));
+	if (_throw == WhenError::Throw)
+		BOOST_THROW_EXCEPTION(BadHexCharacter() << errinfo_invalidSymbol(_i));
+	else
+		return -1;
 }
 
 bytes dev::fromHex(std::string const& _s, WhenError _throw)
@@ -85,33 +88,26 @@ bytes dev::fromHex(std::string const& _s, WhenError _throw)
 	ret.reserve((_s.size() - s + 1) / 2);
 
 	if (_s.size() % 2)
-		try
-		{
-			ret.push_back(fromHex(_s[s++]));
-		}
-		catch (...)
-		{ 
-			ret.push_back(0);
-			// msvc does not support it
-#ifndef BOOST_NO_EXCEPTIONS
-			cwarn << boost::current_exception_diagnostic_information(); 
-#endif
-			if (_throw == WhenError::Throw)
-				throw;
-		}
+	{
+		int h = fromHex(_s[s++], WhenError::DontThrow);
+		if (h != -1)
+			ret.push_back(h);
+		else if (_throw == WhenError::Throw)
+			throw BadHexCharacter();
+		else
+			return bytes();
+	}
 	for (unsigned i = s; i < _s.size(); i += 2)
-		try
-		{
-			ret.push_back((byte)(fromHex(_s[i]) * 16 + fromHex(_s[i + 1])));
-		}
-		catch (...){
-			ret.push_back(0);
-#ifndef BOOST_NO_EXCEPTIONS
-			cwarn << boost::current_exception_diagnostic_information();
-#endif
-			if (_throw == WhenError::Throw)
-				throw;
-		}
+	{
+		int h = fromHex(_s[i], WhenError::DontThrow);
+		int l = fromHex(_s[i + 1], WhenError::DontThrow);
+		if (h != -1 && l != -1)
+			ret.push_back((byte)(h * 16 + l));
+		else if (_throw == WhenError::Throw)
+			throw BadHexCharacter();
+		else
+			return bytes();
+	}
 	return ret;
 }
 

libdevcore/CommonData.h

@@ -61,7 +61,7 @@ std::string toHex(_T const& _data, int _w = 2, HexPrefix _prefix = HexPrefix::Do
 
 /// Converts a (printable) ASCII hex character into the correspnding integer value.
 /// @example fromHex('A') == 10 && fromHex('f') == 15 && fromHex('5') == 5
-int fromHex(char _i);
+int fromHex(char _i, WhenError _throw);
 
 /// Converts a (printable) ASCII hex string into the corresponding byte stream.
 /// @example fromHex("41626261") == asBytes("Abba")

libdevcrypto/SecretStore.cpp

@@ -164,7 +164,7 @@ void SecretStore::load(std::string const& _keysPath)
 
 h128 SecretStore::readKey(std::string const& _file, bool _deleteFile)
 {
-	cdebug << "Reading" << _file;
+	cnote << "Reading" << _file;
 	return readKeyContent(contentsString(_file), _deleteFile ? _file : string());
 }
 

libethcore/KeyManager.cpp

@@ -89,18 +89,18 @@ bool KeyManager::load(std::string const& _pass)
 			for (auto const& i: s[1])
 			{
 				m_keyInfo[m_addrLookup[(Address)i[0]] = (h128)i[1]] = KeyInfo((h256)i[2], (std::string)i[3]);
-				cdebug << toString((Address)i[0]) << toString((h128)i[1]) << toString((h256)i[2]) << (std::string)i[3];
+//				cdebug << toString((Address)i[0]) << toString((h128)i[1]) << toString((h256)i[2]) << (std::string)i[3];
 			}
 
 			for (auto const& i: s[2])
 				m_passwordInfo[(h256)i[0]] = (std::string)i[1];
 			m_password = (string)s[3];
 		}
-		cdebug << hashPassword(m_password) << toHex(m_password);
+//		cdebug << hashPassword(m_password) << toHex(m_password);
 		m_cachedPasswords[hashPassword(m_password)] = m_password;
-		cdebug << hashPassword(asString(m_key.ref())) << m_key.hex();
+//		cdebug << hashPassword(asString(m_key.ref())) << m_key.hex();
 		m_cachedPasswords[hashPassword(asString(m_key.ref()))] = asString(m_key.ref());
-		cdebug << hashPassword(_pass) << _pass;
+//		cdebug << hashPassword(_pass) << _pass;
 		m_cachedPasswords[m_master = hashPassword(_pass)] = _pass;
 		return true;
 	}
@@ -141,7 +141,7 @@ std::string KeyManager::getPassword(h256 const& _passHash, function<std::string(
 		std::string p = _pass();
 		if (p.empty())
 			break;
-		if (hashPassword(p) == _passHash || !_passHash)
+		if (hashPassword(p) == _passHash || _passHash == UnknownPassword)
 		{
 			m_cachedPasswords[hashPassword(p)] = p;
 			return p;
@@ -186,12 +186,17 @@ void KeyManager::importExisting(h128 const& _uuid, std::string const& _info, std
 		return;
 	Address a = KeyPair(Secret(key)).address();
 	auto passHash = hashPassword(_pass);
-	if (!m_passwordInfo.count(passHash))
-		m_passwordInfo[passHash] = _passInfo;
 	if (!m_cachedPasswords.count(passHash))
 		m_cachedPasswords[passHash] = _pass;
-	m_addrLookup[a] = _uuid;
-	m_keyInfo[_uuid].passHash = passHash;
+	importExisting(_uuid, _info, a, passHash, _passInfo);
+}
+
+void KeyManager::importExisting(h128 const& _uuid, std::string const& _info, Address const& _address, h256 const& _passHash, std::string const& _passInfo)
+{
+	if (!m_passwordInfo.count(_passHash))
+		m_passwordInfo[_passHash] = _passInfo;
+	m_addrLookup[_address] = _uuid;
+	m_keyInfo[_uuid].passHash = _passHash;
 	m_keyInfo[_uuid].info = _info;
 	write(m_keysFile);
 }

libethcore/KeyManager.h

@@ -30,17 +30,19 @@ namespace dev
 {
 namespace eth
 {
-class UnknownPassword: public Exception {};
+class PasswordUnknown: public Exception {};
 
 struct KeyInfo
 {
 	KeyInfo() = default;
 	KeyInfo(h256 const& _passHash, std::string const& _info): passHash(_passHash), info(_info) {}
-	h256 passHash;
-	std::string info;
+
+	h256 passHash;		///< Hash of the password or h256() if unknown.
+	std::string info;	///< Name of the key, or JSON key info if begins with '{'.
 };
 
-static const auto DontKnowThrow = [](){ throw UnknownPassword(); return std::string(); };
+static const h256 UnknownPassword;
+static const auto DontKnowThrow = [](){ throw PasswordUnknown(); return std::string(); };
 
 enum class SemanticPassword
 {
@@ -89,6 +91,7 @@ public:
 	SecretStore& store() { return m_store; }
 	void importExisting(h128 const& _uuid, std::string const& _info, std::string const& _pass, std::string const& _passInfo);
 	void importExisting(h128 const& _uuid, std::string const& _info) { importExisting(_uuid, _info, defaultPassword(), std::string()); }
+	void importExisting(h128 const& _uuid, std::string const& _info, Address const& _addr, h256 const& _passHash = h256(), std::string const& _passInfo = std::string());
 
 	Secret secret(Address const& _address, std::function<std::string()> const& _pass = DontKnowThrow) const;
 	Secret secret(h128 const& _uuid, std::function<std::string()> const& _pass = DontKnowThrow) const;

libethereum/CommonNet.h

@@ -38,14 +38,16 @@ namespace eth
 
 #if ETH_DEBUG
 static const unsigned c_maxHashes = 2048;		///< Maximum number of hashes BlockHashes will ever send.
-static const unsigned c_maxHashesAsk = 2048;	///< Maximum number of hashes GetBlockHashes will ever ask for.
+static const unsigned c_maxHashesAsk = 256;		///< Maximum number of hashes GetBlockHashes will ever ask for.
 static const unsigned c_maxBlocks = 128;		///< Maximum number of blocks Blocks will ever send.
-static const unsigned c_maxBlocksAsk = 128;		///< Maximum number of blocks we ask to receive in Blocks (when using GetChain).
+static const unsigned c_maxBlocksAsk = 8;		///< Maximum number of blocks we ask to receive in Blocks (when using GetChain).
+static const unsigned c_maxPayload = 262144;	///< Maximum size of packet for us to send.
 #else
 static const unsigned c_maxHashes = 2048;		///< Maximum number of hashes BlockHashes will ever send.
 static const unsigned c_maxHashesAsk = 2048;	///< Maximum number of hashes GetBlockHashes will ever ask for.
 static const unsigned c_maxBlocks = 128;		///< Maximum number of blocks Blocks will ever send.
 static const unsigned c_maxBlocksAsk = 128;		///< Maximum number of blocks we ask to receive in Blocks (when using GetChain).
+static const unsigned c_maxPayload = 262144;	///< Maximum size of packet for us to send.
 #endif
 
 class BlockChain;

libethereum/EthereumHost.cpp

@@ -253,7 +253,9 @@ void EthereumHost::onPeerStatus(EthereumPeer* _peer)
 		if (_peer->m_protocolVersion != protocolVersion())
 			estimatePeerHashes(_peer);
 		else if (_peer->m_latestBlockNumber > m_chain.number())
-			_peer->m_expectedHashes = (unsigned)_peer->m_latestBlockNumber - m_chain.number();
+			_peer->m_expectedHashes = (unsigned)_peer->m_latestBlockNumber - m_chain.number() + 1000;
+		else
+			_peer->m_expectedHashes = 1000;
 		if (m_hashMan.chainSize() < _peer->m_expectedHashes)
 			m_hashMan.resetToRange(m_chain.number() + 1, _peer->m_expectedHashes);
 		continueSync(_peer);

libethereum/EthereumPeer.cpp

@@ -263,7 +263,7 @@ bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
 		// return the requested blocks.
 		bytes rlp;
 		unsigned n = 0;
-		for (unsigned i = 0; i < min(count, c_maxBlocks); ++i)
+		for (unsigned i = 0; i < min(count, c_maxBlocks) && rlp.size() < c_maxPayload; ++i)
 		{
 			auto h = _r[i].toHash<h256>();
 			if (host()->chain().isKnown(h))
@@ -286,7 +286,7 @@ bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
 	case BlocksPacket:
 	{
 		if (m_asking != Asking::Blocks)
-			clog(NetWarn) << "Peer giving us blocks when we didn't ask for them.";
+			clog(NetImpolite) << "Peer giving us blocks when we didn't ask for them.";
 		else
 		{
 			setAsking(Asking::Nothing);