Address toAddress(Secret _private) { secp256k1_start(); byte pubkey[65]; int pubkeylen = 65; int ok = secp256k1_ecdsa_seckey_verify(_private.data()); if (!ok) return Address(); ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, _private.data(), 0); assert(pubkeylen == 65); if (!ok) return Address(); ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65); if (!ok) return Address(); auto ret = right160(dev::eth::sha3(bytesConstRef(&(pubkey[1]), 64))); #if ETH_ADDRESS_DEBUG cout << "---- ADDRESS -------------------------------" << endl; cout << "SEC: " << _private << endl; cout << "PUB: " << toHex(bytesConstRef(&(pubkey[1]), 64)) << endl; cout << "ADR: " << ret << endl; #endif return ret; }
void MemTrie::insert(std::string const& _key, std::string const& _value) { if (_value.empty()) remove(_key); auto h = asNibbles(_key); m_root = m_root ? m_root->insert(&h, _value) : new TrieLeafNode(bytesConstRef(&h), _value); }
std::string const& MemTrie::at(std::string const& _key) const { if (!m_root) return c_nullString; auto h = asNibbles(_key); return m_root->at(bytesConstRef(&h)); }
NEXT CASE(SHA3) { ON_OP(); constexpr int64_t sha3Gas = VMSchedule::sha3Gas; constexpr int64_t sha3WordGas = VMSchedule::sha3WordGas; m_runGas = toInt63(sha3Gas + (u512(m_SP[1]) + 31) / 32 * sha3WordGas); updateMem(memNeed(m_SP[0], m_SP[1])); updateIOGas(); uint64_t inOff = (uint64_t)m_SP[0]; uint64_t inSize = (uint64_t)m_SP[1]; m_SPP[0] = (u256)sha3(bytesConstRef(m_mem.data() + inOff, inSize)); }
MemTrieNode* TrieBranchNode::rejig() { mark(); byte n = activeBranch(); if (n == (byte)-1 && m_value.size()) { // switch to leaf auto r = new TrieLeafNode(bytesConstRef(), m_value); delete this; return r; } else if (n < 16 && m_value.empty()) { // only branching to n... if (auto b = dynamic_cast<TrieBranchNode*>(m_nodes[n])) { // switch to infix m_nodes[n] = nullptr; delete this; return new TrieInfixNode(bytesConstRef(&n, 1), b); } else { auto x = dynamic_cast<TrieExtNode*>(m_nodes[n]); assert(x); // include in child pushFront(x->m_ext, n); m_nodes[n] = nullptr; delete this; return x; } } return this; }
MemTrieNode* TrieLeafNode::insert(bytesConstRef _key, std::string const& _value) { assert(_value.size()); mark(); if (contains(_key)) { m_value = _value; return this; } else { // create new trie. auto n = MemTrieNode::newBranch(_key, _value, bytesConstRef(&m_ext), m_value); delete this; return n; } }
void hash256rlp(HexMap const& _s, HexMap::const_iterator _begin, HexMap::const_iterator _end, unsigned _preLen, RLPStream& _rlp) { #if ENABLE_DEBUG_PRINT static std::string s_indent; if (_preLen) s_indent += " "; #endif if (_begin == _end) _rlp << ""; // NULL else if (std::next(_begin) == _end) { // only one left - terminate with the pair. _rlp.appendList(2) << hexPrefixEncode(_begin->first, true, _preLen) << _begin->second; #if ENABLE_DEBUG_PRINT if (g_hashDebug) std::cerr << s_indent << toHex(bytesConstRef(_begin->first.data() + _preLen, _begin->first.size() - _preLen), 1) << ": " << _begin->second << " = " << sha3(_rlp.out()) << std::endl; #endif } else { // find the number of common prefix nibbles shared // i.e. the minimum number of nibbles shared at the beginning between the first hex string and each successive. uint sharedPre = (uint)-1; uint c = 0; for (auto i = std::next(_begin); i != _end && sharedPre; ++i, ++c) { uint x = std::min(sharedPre, std::min((uint)_begin->first.size(), (uint)i->first.size())); uint shared = _preLen; for (; shared < x && _begin->first[shared] == i->first[shared]; ++shared) {} sharedPre = std::min(shared, sharedPre); } if (sharedPre > _preLen) { // if they all have the same next nibble, we also want a pair. #if ENABLE_DEBUG_PRINT if (g_hashDebug) std::cerr << s_indent << toHex(bytesConstRef(_begin->first.data() + _preLen, sharedPre), 1) << ": " << std::endl; #endif _rlp.appendList(2) << hexPrefixEncode(_begin->first, false, _preLen, (int)sharedPre); hash256aux(_s, _begin, _end, (unsigned)sharedPre, _rlp); #if ENABLE_DEBUG_PRINT if (g_hashDebug) std::cerr << s_indent << "= " << hex << sha3(_rlp.out()) << dec << std::endl; #endif } else { // otherwise enumerate all 16+1 entries. _rlp.appendList(17); auto b = _begin; if (_preLen == b->first.size()) { #if ENABLE_DEBUG_PRINT if (g_hashDebug) std::cerr << s_indent << "@: " << b->second << std::endl; #endif ++b; } for (auto i = 0; i < 16; ++i) { auto n = b; for (; n != _end && n->first[_preLen] == i; ++n) {} if (b == n) _rlp << ""; else { #if ENABLE_DEBUG_PRINT if (g_hashDebug) std::cerr << s_indent << std::hex << i << ": " << std::dec << std::endl; #endif hash256aux(_s, b, n, _preLen + 1, _rlp); } b = n; } if (_preLen == _begin->first.size()) _rlp << _begin->second; else _rlp << ""; #if ENABLE_DEBUG_PRINT if (g_hashDebug) std::cerr << s_indent << "= " << hex << sha3(_rlp.out()) << dec << std::endl; #endif } } #if ENABLE_DEBUG_PRINT if (_preLen) s_indent.resize(s_indent.size() - 2); #endif }
bytes MemTrie::rlp() const { return m_root ? m_root->rlp() : dev::rlp(bytesConstRef()); }
h256 MemTrie::hash256() const { return m_root ? m_root->hash256() : sha3(dev::rlp(bytesConstRef())); }
virtual void Delete(ldb::Slice const& _key) { cnote << "Delete" << toHex(bytesConstRef(_key)); }
virtual void Put(ldb::Slice const& _key, ldb::Slice const& _value) { cnote << "Put" << toHex(bytesConstRef(_key)) << "=>" << toHex(bytesConstRef(_value)); }