diff --git a/libraries/app/application.cpp b/libraries/app/application.cpp
index c13eae4e41f1550b170d572d93871f0b8faee21a..b4d95de4584c1bcc99e4cc22b717c493d491888b 100644
--- a/libraries/app/application.cpp
+++ b/libraries/app/application.cpp
@@ -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());
diff --git a/libraries/chain/include/eos/chain/protocol/types.hpp b/libraries/chain/include/eos/chain/protocol/types.hpp
index 8425736608bb11086f9a5a5dcdc1ae1c9118d501..4841ef1657b01073e62055ea71cc6a13c9fd4d94 100644
--- a/libraries/chain/include/eos/chain/protocol/types.hpp
+++ b/libraries/chain/include/eos/chain/protocol/types.hpp
@@ -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 );
    };
 
diff --git a/libraries/chain/protocol/block.cpp b/libraries/chain/protocol/block.cpp
index d783ef73809cb0644214664a921eaf636ea03f0f..eca99ccf056643dd419309747cf4d20d08eaa0ed 100644
--- a/libraries/chain/protocol/block.cpp
+++ b/libraries/chain/protocol/block.cpp
@@ -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));
diff --git a/libraries/chain/protocol/types.cpp b/libraries/chain/protocol/types.cpp
index deaa0f6cdc4bdeb17dd3f7de61bad046d1edac6b..91e097f8ef643f000958bf606732524c71ee223c 100644
--- a/libraries/chain/protocol/types.cpp
+++ b/libraries/chain/protocol/types.cpp
@@ -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