Skip to content

Y
YTBP

YottaChain / YTBP

通知 0
Star 0
Fork 0
Y
YTBP

体验新版 GitCode，发现更多精彩内容 >>

提交 344b8ce2 编写于 作者: D Daniel Larimer
浏览文件
操作

Merge branch 'master' of github.com:EOSIO/eos

上级 0a52fa69 e44d170a
隐藏空白更改
内联 并排
Showing with 65 addition and 82 deletion
libraries/app/application.cpp
浏览文件 @ 344b8ce2
......@@ -539,6 +539,8 @@ namespace detail {
for (const auto& cycle : blk_msg.block.cycles)
for (const auto& thread : cycle)
for (const auto& transaction : thread.input_transactions)
// In theory, we can ignore generated transactions here, since they don't ever go bare over the
// network. Is this true?...
if (transaction.which() == decay_t<decltype(transaction)>::tag<signed_transaction>::value) {
eos::net::trx_message transaction_message(transaction.get<signed_transaction>());
contained_transaction_message_ids.push_back(eos::net::message(transaction_message).id());
......
libraries/chain/include/eos/chain/protocol/types.hpp
浏览文件 @ 344b8ce2
......@@ -123,13 +123,12 @@ namespace eos { namespace chain {
using account_id_type = chainbase::oid<account_object>;
using producer_id_type = chainbase::oid<producer_object>;
using generated_transaction_id_type = uint32_t;
using block_id_type = fc::ripemd160;
using checksum_type = fc::ripemd160;
using transaction_id_type = fc::ripemd160;
using digest_type = fc::sha256;
using generated_transaction_id_type = fc::sha256;
using signature_type = fc::ecc::compact_signature;
using share_type = safe<int64_t>;
using weight_type = uint16_t;
struct public_key_type
......@@ -152,7 +151,6 @@ namespace eos { namespace chain {
friend bool operator == ( const public_key_type& p1, const public_key_type& p2);
friend bool operator != ( const public_key_type& p1, const public_key_type& p2);
friend bool operator < ( const public_key_type& p1, const public_key_type& p2);
// TODO: This is temporary for testing
bool is_valid_v1( const std::string& base58str );
};
......
libraries/chain/protocol/block.cpp
浏览文件 @ 344b8ce2
......@@ -91,9 +91,16 @@ namespace eos { namespace chain {
vector<digest_type> ids;
std::transform(input_transactions.begin(), input_transactions.end(), std::back_inserter(ids),
[](const input_transaction& trx) {
if (trx.which() == input_transaction::tag<signed_transaction>::value)
return trx.get<signed_transaction>().merkle_digest();
#warning How do I get the digest from a generated_transaction_id_type?...
struct {
using result_type = digest_type;
result_type operator() (const signed_transaction& t) {
return t.merkle_digest();
}
result_type operator() (const generated_transaction_id_type& id) {
return id;
}
} digester;
return trx.visit(digester);
});
std::transform(output_transactions.begin(), output_transactions.end(), std::back_inserter(ids),
std::bind(&generated_transaction::merkle_digest, std::placeholders::_1));
......
libraries/chain/protocol/types.cpp
浏览文件 @ 344b8ce2
......@@ -33,49 +33,25 @@ namespace eos { namespace chain {
public_key_type::public_key_type():key_data(){};
public_key_type::public_key_type( const fc::ecc::public_key_data& data )
public_key_type::public_key_type(const fc::ecc::public_key_data& data)
:key_data( data ) {};
public_key_type::public_key_type( const fc::ecc::public_key& pubkey )
public_key_type::public_key_type(const fc::ecc::public_key& pubkey)
:key_data( pubkey ) {};
public_key_type::public_key_type( const std::string& base58str )
public_key_type::public_key_type(const std::string& base58str)
{
// TODO: Refactor syntactic checks into static is_valid()
// to make public_key_type API more similar to address API
std::string prefix( EOS_KEY_PREFIX );
// TODO: This is temporary for testing
try
{
if( is_valid_v1( base58str ) )
prefix = std::string( "BTS" );
}
catch( ... )
{
}
const size_t prefix_len = prefix.size();
FC_ASSERT( base58str.size() > prefix_len );
FC_ASSERT( base58str.substr( 0, prefix_len ) == prefix , "", ("base58str", base58str) );
auto bin = fc::from_base58( base58str.substr( prefix_len ) );
FC_ASSERT(base58str.size() > prefix_len);
FC_ASSERT(base58str.substr(0, prefix_len) == prefix , "", ("base58str", base58str));
auto bin = fc::from_base58(base58str.substr(prefix_len));
auto bin_key = fc::raw::unpack<binary_key>(bin);
key_data = bin_key.data;
FC_ASSERT( fc::ripemd160::hash( key_data.data, key_data.size() )._hash[0] == bin_key.check );
}
// TODO: This is temporary for testing
bool public_key_type::is_valid_v1( const std::string& base58str )
{
std::string prefix( "BTS" );
const size_t prefix_len = prefix.size();
FC_ASSERT( base58str.size() > prefix_len );
FC_ASSERT( base58str.substr( 0, prefix_len ) == prefix , "", ("base58str", base58str) );
auto bin = fc::from_base58( base58str.substr( prefix_len ) );
auto bin_key = fc::raw::unpack<binary_key>(bin);
fc::ecc::public_key_data key_data = bin_key.data;
FC_ASSERT( fc::ripemd160::hash( key_data.data, key_data.size() )._hash[0] == bin_key.check );
return true;
FC_ASSERT(fc::ripemd160::hash(key_data.data, key_data.size())._hash[0] == bin_key.check);
}
public_key_type::operator fc::ecc::public_key_data() const
......@@ -85,7 +61,7 @@ namespace eos { namespace chain {
public_key_type::operator fc::ecc::public_key() const
{
return fc::ecc::public_key( key_data );
return fc::ecc::public_key(key_data);
};
public_key_type::operator std::string() const
......@@ -97,17 +73,17 @@ namespace eos { namespace chain {
return EOS_KEY_PREFIX + fc::to_base58( data.data(), data.size() );
}
bool operator == ( const public_key_type& p1, const fc::ecc::public_key& p2)
bool operator == (const public_key_type& p1, const fc::ecc::public_key& p2)
{
return p1.key_data == p2.serialize();
}
bool operator == ( const public_key_type& p1, const public_key_type& p2)
bool operator == (const public_key_type& p1, const public_key_type& p2)
{
return p1.key_data == p2.key_data;
}
bool operator != ( const public_key_type& p1, const public_key_type& p2)
bool operator != (const public_key_type& p1, const public_key_type& p2)
{
return p1.key_data != p2.key_data;
}
......@@ -121,52 +97,52 @@ namespace eos { namespace chain {
extended_public_key_type::extended_public_key_type():key_data(){};
extended_public_key_type::extended_public_key_type( const fc::ecc::extended_key_data& data )
extended_public_key_type::extended_public_key_type(const fc::ecc::extended_key_data& data)
:key_data( data ){};
extended_public_key_type::extended_public_key_type( const fc::ecc::extended_public_key& extpubkey )
extended_public_key_type::extended_public_key_type(const fc::ecc::extended_public_key& extpubkey)
{
key_data = extpubkey.serialize_extended();
};
extended_public_key_type::extended_public_key_type( const std::string& base58str )
extended_public_key_type::extended_public_key_type(const std::string& base58str)
{
std::string prefix( EOS_KEY_PREFIX );
const size_t prefix_len = prefix.size();
FC_ASSERT( base58str.size() > prefix_len );
FC_ASSERT( base58str.substr( 0, prefix_len ) == prefix , "", ("base58str", base58str) );
auto bin = fc::from_base58( base58str.substr( prefix_len ) );
FC_ASSERT(base58str.size() > prefix_len);
FC_ASSERT(base58str.substr(0, prefix_len) == prefix , "", ("base58str", base58str));
auto bin = fc::from_base58(base58str.substr(prefix_len));
auto bin_key = fc::raw::unpack<binary_key>(bin);
FC_ASSERT( fc::ripemd160::hash( bin_key.data.data, bin_key.data.size() )._hash[0] == bin_key.check );
FC_ASSERT(fc::ripemd160::hash(bin_key.data.data, bin_key.data.size())._hash[0] == bin_key.check);
key_data = bin_key.data;
}
extended_public_key_type::operator fc::ecc::extended_public_key() const
{
return fc::ecc::extended_public_key::deserialize( key_data );
return fc::ecc::extended_public_key::deserialize(key_data);
}
extended_public_key_type::operator std::string() const
{
binary_key k;
k.data = key_data;
k.check = fc::ripemd160::hash( k.data.data, k.data.size() )._hash[0];
auto data = fc::raw::pack( k );
return EOS_KEY_PREFIX + fc::to_base58( data.data(), data.size() );
k.check = fc::ripemd160::hash(k.data.data, k.data.size())._hash[0];
auto data = fc::raw::pack(k);
return EOS_KEY_PREFIX + fc::to_base58(data.data(), data.size());
}
bool operator == ( const extended_public_key_type& p1, const fc::ecc::extended_public_key& p2)
bool operator == (const extended_public_key_type& p1, const fc::ecc::extended_public_key& p2)
{
return p1.key_data == p2.serialize_extended();
}
bool operator == ( const extended_public_key_type& p1, const extended_public_key_type& p2)
bool operator == (const extended_public_key_type& p1, const extended_public_key_type& p2)
{
return p1.key_data == p2.key_data;
}
bool operator != ( const extended_public_key_type& p1, const extended_public_key_type& p2)
bool operator != (const extended_public_key_type& p1, const extended_public_key_type& p2)
{
return p1.key_data != p2.key_data;
}
......@@ -175,52 +151,52 @@ namespace eos { namespace chain {
extended_private_key_type::extended_private_key_type():key_data(){};
extended_private_key_type::extended_private_key_type( const fc::ecc::extended_key_data& data )
extended_private_key_type::extended_private_key_type(const fc::ecc::extended_key_data& data)
:key_data( data ){};
extended_private_key_type::extended_private_key_type( const fc::ecc::extended_private_key& extprivkey )
extended_private_key_type::extended_private_key_type(const fc::ecc::extended_private_key& extprivkey)
{
key_data = extprivkey.serialize_extended();
};
extended_private_key_type::extended_private_key_type( const std::string& base58str )
extended_private_key_type::extended_private_key_type(const std::string& base58str)
{
std::string prefix( EOS_KEY_PREFIX );
std::string prefix(EOS_KEY_PREFIX);
const size_t prefix_len = prefix.size();
FC_ASSERT( base58str.size() > prefix_len );
FC_ASSERT( base58str.substr( 0, prefix_len ) == prefix , "", ("base58str", base58str) );
auto bin = fc::from_base58( base58str.substr( prefix_len ) );
FC_ASSERT(base58str.size() > prefix_len);
FC_ASSERT(base58str.substr(0, prefix_len) == prefix , "", ("base58str", base58str));
auto bin = fc::from_base58(base58str.substr(prefix_len));
auto bin_key = fc::raw::unpack<binary_key>(bin);
FC_ASSERT( fc::ripemd160::hash( bin_key.data.data, bin_key.data.size() )._hash[0] == bin_key.check );
FC_ASSERT(fc::ripemd160::hash(bin_key.data.data, bin_key.data.size())._hash[0] == bin_key.check);
key_data = bin_key.data;
}
extended_private_key_type::operator fc::ecc::extended_private_key() const
{
return fc::ecc::extended_private_key::deserialize( key_data );
return fc::ecc::extended_private_key::deserialize(key_data);
}
extended_private_key_type::operator std::string() const
{
binary_key k;
k.data = key_data;
k.check = fc::ripemd160::hash( k.data.data, k.data.size() )._hash[0];
auto data = fc::raw::pack( k );
return EOS_KEY_PREFIX + fc::to_base58( data.data(), data.size() );
k.check = fc::ripemd160::hash(k.data.data, k.data.size())._hash[0];
auto data = fc::raw::pack(k);
return EOS_KEY_PREFIX + fc::to_base58(data.data(), data.size());
}
bool operator == ( const extended_private_key_type& p1, const fc::ecc::extended_public_key& p2)
bool operator == (const extended_private_key_type& p1, const fc::ecc::extended_public_key& p2)
{
return p1.key_data == p2.serialize_extended();
}
bool operator == ( const extended_private_key_type& p1, const extended_private_key_type& p2)
bool operator == (const extended_private_key_type& p1, const extended_private_key_type& p2)
{
return p1.key_data == p2.key_data;
}
bool operator != ( const extended_private_key_type& p1, const extended_private_key_type& p2)
bool operator != (const extended_private_key_type& p1, const extended_private_key_type& p2)
{
return p1.key_data != p2.key_data;
}
......@@ -230,33 +206,33 @@ namespace eos { namespace chain {
namespace fc
{
using namespace std;
void to_variant( const eos::chain::public_key_type& var, fc::variant& vo )
void to_variant(const eos::chain::public_key_type& var, fc::variant& vo)
{
vo = std::string( var );
vo = std::string(var);
}
void from_variant( const fc::variant& var, eos::chain::public_key_type& vo )
void from_variant(const fc::variant& var, eos::chain::public_key_type& vo)
{
vo = eos::chain::public_key_type( var.as_string() );
vo = eos::chain::public_key_type(var.as_string());
}
void to_variant( const eos::chain::extended_public_key_type& var, fc::variant& vo )
void to_variant(const eos::chain::extended_public_key_type& var, fc::variant& vo)
{
vo = std::string( var );
vo = std::string(var);
}
void from_variant( const fc::variant& var, eos::chain::extended_public_key_type& vo )
void from_variant(const fc::variant& var, eos::chain::extended_public_key_type& vo)
{
vo = eos::chain::extended_public_key_type( var.as_string() );
vo = eos::chain::extended_public_key_type(var.as_string());
}
void to_variant( const eos::chain::extended_private_key_type& var, fc::variant& vo )
void to_variant(const eos::chain::extended_private_key_type& var, fc::variant& vo)
{
vo = std::string( var );
vo = std::string(var);
}
void from_variant( const fc::variant& var, eos::chain::extended_private_key_type& vo )
void from_variant(const fc::variant& var, eos::chain::extended_private_key_type& vo)
{
vo = eos::chain::extended_private_key_type( var.as_string() );
vo = eos::chain::extended_private_key_type(var.as_string());
}
} // fc
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或