#
#
# patch "annotate.cc"
#  from [17e3492599d170bc64c4b7c5750dda63a4769a73]
#    to [873cb5eff33acad204f11e830e6f3450516f4a6d]
# 
# patch "cert.cc"
#  from [eee0a9f1b710ccedc34bf59e118445004e042a80]
#    to [5ebfa0d0b82b11d5c8bb9b5531e22c18fa688ab4]
# 
# patch "cert.hh"
#  from [2334e8f1ead86407aeb5d97e9657b5978532773b]
#    to [3ba508335352895ab27c927625976080ffc39745]
# 
# patch "cmd_diff_log.cc"
#  from [f6c361c235ff5746a230e9b854354ad88abd1865]
#    to [ce9525bfdb3ce7d55ff4ddacf3640cf530433fe8]
# 
# patch "cmd_list.cc"
#  from [77c5aba2c0c1ea69a6e991576f6558af766e4146]
#    to [481ca237fbebe2d50a820e47d98869ad0e5d9e9f]
# 
# patch "cmd_merging.cc"
#  from [d0665576f84bff0c83322468d04ef070825f978f]
#    to [76227d1249a0bf097b4d0aa63fbe04d92e3f2419]
# 
# patch "cmd_ws_commit.cc"
#  from [73f2a0c13972f94ad2fcc93d0aac750af1ebee9c]
#    to [96c5d93b31ffe4437a647caff8919ff3e856b64c]
# 
# patch "commands.cc"
#  from [1ecf0a9c99788b117e23ed8c7124811674c5923f]
#    to [f815513f8a69b69bcf44822070d793895cdf9888]
# 
# patch "database.cc"
#  from [168be0db6ec45fd18c6716e0a622e7515916ef94]
#    to [c96663fc818db68864f8754d6bdc1bac842a2458]
# 
# patch "database.hh"
#  from [673f98403c91c3abd882b8802d09148199287969]
#    to [6d8e070db13b8b7cd7d572e9b49e8adad9719a1d]
# 
# patch "netsync.cc"
#  from [832911ff01940c887b43c73d47c4db7c41da1628]
#    to [e52a6b004ef68b64510c8949ddaf90109050f458]
# 
# patch "packet.cc"
#  from [e617e272fd17fbb13bd705c1daf6113fa4f858da]
#    to [c44a0d07d219b67519ea96520ad8a513000f8a28]
# 
# patch "project.cc"
#  from [fd4a5d9d8a3267204ff3a198a6dbf562c1df11a6]
#    to [91bc4553292ae576135e759d2a8ad59baf022b48]
# 
# patch "revision.cc"
#  from [5f45dc66571d4ca62bddc7b943b815596f82ef7b]
#    to [6c2631fcf27ce20938e7abe44d9f0c6393865bef]
# 
# patch "transforms.cc"
#  from [37cf33ed51b47de79a6001247cfb2571ce1d7b0e]
#    to [bbac152c792f330fc02e3b2ec76aba70dade4581]
# 
# patch "transforms.hh"
#  from [e4d0e3f76acf27d96ccf87b6741921a99b3c6833]
#    to [7b1ad2508a1fed5c39b318d8d1dc1fb1b5f2725b]
# 
# patch "update.cc"
#  from [c6472ee28faff6f12f9882801d0bbfbd7efe606f]
#    to [04ca1a313bbd21e3fb4654074b36a791246052af]
#
============================================================
--- annotate.cc	17e3492599d170bc64c4b7c5750dda63a4769a73
+++ annotate.cc	873cb5eff33acad204f11e830e6f3450516f4a6d
@@ -353,7 +353,7 @@ cert_string_value(vector< revision<cert>
     {
       if (i->inner().name == name)
         {
-          cert_value tv = decode_base64(i->inner().value);
+          cert_value tv(i->inner().value);
           string::size_type f = 0;
           string::size_type l = string::npos;
           if (from_start)
============================================================
--- cert.cc	eee0a9f1b710ccedc34bf59e118445004e042a80
+++ cert.cc	5ebfa0d0b82b11d5c8bb9b5531e22c18fa688ab4
@@ -115,7 +115,7 @@ erase_bogus_certs(database & db,
   vector< manifest<cert> > tmp_certs;
 
   // Sorry, this is a crazy data structure
-  typedef tuple< hexenc<id>, cert_name, base64<cert_value> > trust_key;
+  typedef tuple< hexenc<id>, cert_name, cert_value > trust_key;
   typedef map< trust_key, 
     pair< shared_ptr< set<rsa_keypair_id> >, it > > trust_map;
   trust_map trust;
@@ -140,11 +140,10 @@ erase_bogus_certs(database & db,
   for (trust_map::const_iterator i = trust.begin();
        i != trust.end(); ++i)
     {
-      cert_value decoded_value = decode_base64(get<2>(i->first));
       if (db.hook_get_manifest_cert_trust(*(i->second.first),
                                           get<0>(i->first),
                                           get<1>(i->first),
-                                          decoded_value))
+                                          get<2>(i->first)))
         {
           L(FL("trust function liked %d signers of %s cert on manifest %s")
             % i->second.first->size() % get<1>(i->first) % get<0>(i->first));
@@ -170,8 +169,7 @@ erase_bogus_certs(database & db,
   vector< revision<cert> > tmp_certs;
 
   // sorry, this is a crazy data structure
-  typedef tuple< hexenc<id>, 
-    cert_name, base64<cert_value> > trust_key;
+  typedef tuple< hexenc<id>, cert_name, cert_value > trust_key;
   typedef map< trust_key, 
     pair< shared_ptr< set<rsa_keypair_id> >, it > > trust_map;
   trust_map trust;
@@ -196,11 +194,10 @@ erase_bogus_certs(database & db,
   for (trust_map::const_iterator i = trust.begin();
        i != trust.end(); ++i)
     {
-      cert_value decoded_value = decode_base64(get<2>(i->first));
       if (db.hook_get_revision_cert_trust(*(i->second.first),
                                           get<0>(i->first),
                                           get<1>(i->first),
-                                          decoded_value))
+                                          get<2>(i->first)))
         {
           L(FL("trust function liked %d signers of %s cert on revision %s")
             % i->second.first->size() % get<1>(i->first) % get<0>(i->first));
@@ -228,14 +225,14 @@ cert::cert(hexenc<id> const & ident,
 
 cert::cert(hexenc<id> const & ident,
            cert_name const & name,
-           base64<cert_value> const & value,
+           cert_value const & value,
            rsa_keypair_id const & key)
   : ident(ident), name(name), value(value), key(key)
 {}
 
 cert::cert(hexenc<id> const & ident,
          cert_name const & name,
-         base64<cert_value> const & value,
+         cert_value const & value,
          rsa_keypair_id const & key,
          rsa_sha1_signature const & sig)
   : ident(ident), name(name), value(value), key(key), sig(sig)
@@ -286,9 +283,7 @@ read_cert(string const & in, cert & t)
 
   hexenc<id> hid;
   encode_hexenc(ident, hid);
-  base64<cert_value> bval = encode_base64(cert_value(val));
-
-  cert tmp(hid, cert_name(name), bval, rsa_keypair_id(key),
+  cert tmp(hid, cert_name(name), cert_value(val), rsa_keypair_id(key),
            rsa_sha1_signature(sig));
 
   hexenc<id> hcheck;
@@ -311,7 +306,6 @@ write_cert(cert const & t, string & out)
   string name, key;
   hexenc<id> hash;
   id ident_decoded, hash_decoded;
-  cert_value value_decoded = decode_base64(t.value);
 
   cert_hash_code(t, hash);
   decode_hexenc(t.ident, ident_decoded);
@@ -320,35 +314,48 @@ write_cert(cert const & t, string & out)
   out.append(hash_decoded());
   out.append(ident_decoded());
   insert_variable_length_string(t.name(), out);
-  insert_variable_length_string(value_decoded(), out);
+  insert_variable_length_string(t.value(), out);
   insert_variable_length_string(t.key(), out);
   insert_variable_length_string(t.sig(), out);
 }
 
 void
-cert_signable_text(cert const & t,
-                   string & out)
+cert_signable_text(cert const & t, string & out)
 {
-  out = (FL("address@hidden:%s]") % t.name % t.ident % remove_ws(t.value())).str();
+  base64<cert_value> val_encoded(encode_base64(t.value));
+
+  out.clear();
+  out.reserve(4 + t.name().size() + t.ident().size()
+              + val_encoded().size());
+
+  out += '[';
+  out.append(t.name());
+  out += '@';
+  out.append(t.ident());
+  out += ':';
+  append_without_ws(out, val_encoded());
+  out += ']';
+
   L(FL("cert: signable text %s") % out);
 }
 
 void
 cert_hash_code(cert const & t, hexenc<id> & out)
 {
-  base64<rsa_sha1_signature> sig_encoded(encode_hexenc(t.sig()));
+  base64<rsa_sha1_signature> sig_encoded(encode_base64(t.sig));
+  base64<cert_value> val_encoded(encode_base64(t.value));
   string tmp;
-  tmp.reserve(4+t.ident().size() + t.name().size() + t.value().size() +
+  tmp.reserve(4+t.ident().size() + t.name().size() + val_encoded().size() +
               t.key().size() + sig_encoded().size());
   tmp.append(t.ident());
   tmp += ':';
   tmp.append(t.name());
   tmp += ':';
-  append_without_ws(tmp,t.value());
+  append_without_ws(tmp, val_encoded());
   tmp += ':';
   tmp.append(t.key());
   tmp += ':';
-  append_without_ws(tmp,sig_encoded());
+  append_without_ws(tmp, sig_encoded());
 
   data tdat(tmp);
   calculate_ident(tdat, out);
@@ -371,9 +378,7 @@ put_simple_revision_cert(database & db,
 {
   I(!keys.signing_key().empty());
 
-  base64<cert_value> encoded_val = encode_base64(val);
-  cert t(id.inner(), nm, encoded_val, keys.signing_key);
-
+  cert t(id.inner(), nm, val, keys.signing_key);
   string signed_text;
   cert_signable_text(t, signed_text);
   load_key_pair(keys, t.key);
============================================================
--- cert.hh	2334e8f1ead86407aeb5d97e9657b5978532773b
+++ cert.hh	3ba508335352895ab27c927625976080ffc39745
@@ -37,16 +37,16 @@ struct cert
 
   cert(hexenc<id> const & ident,
       cert_name const & name,
-      base64<cert_value> const & value,
+      cert_value const & value,
       rsa_keypair_id const & key);
   cert(hexenc<id> const & ident,
       cert_name const & name,
-      base64<cert_value> const & value,
+      cert_value const & value,
       rsa_keypair_id const & key,
       rsa_sha1_signature const & sig);
   hexenc<id> ident;
   cert_name name;
-  base64<cert_value> value;
+  cert_value value;
   rsa_keypair_id key;
   rsa_sha1_signature sig;
   bool operator<(cert const & other) const;
============================================================
--- cmd_diff_log.cc	f6c361c235ff5746a230e9b854354ad88abd1865
+++ cmd_diff_log.cc	ce9525bfdb3ce7d55ff4ddacf3640cf530433fe8
@@ -577,8 +577,6 @@ log_certs(project_t & project, ostream &
   for (vector< revision<cert> >::const_iterator i = certs.begin();
        i != certs.end(); ++i)
     {
-      cert_value tv = decode_base64(i->inner().value);
-
       if (first)
         os << label;
       else
@@ -586,7 +584,7 @@ log_certs(project_t & project, ostream &
 
       if (multiline)
         os << "\n\n";
-      os << tv;
+      os << i->inner().value;
       if (newline)
         os << '\n';
 
============================================================
--- cmd_list.cc	77c5aba2c0c1ea69a6e991576f6558af766e4146
+++ cmd_list.cc	481ca237fbebe2d50a820e47d98869ad0e5d9e9f
@@ -109,7 +109,7 @@ CMD(certs, "certs", "", CMD_REF(list), "
   for (size_t i = 0; i < certs.size(); ++i)
     {
       cert_status status = check_cert(db, idx(certs, i));
-      cert_value tv = decode_base64(idx(certs, i).value);
+      cert_value tv = idx(certs, i).value;
       string washed;
       if (guess_binary(tv()))
         {
@@ -720,7 +720,7 @@ CMD_AUTOMATE(certs, N_("REV"),
     {
       basic_io::stanza st;
       cert_status status = check_cert(db, idx(certs, i));
-      cert_value tv = decode_base64(idx(certs, i).value);
+      cert_value tv = idx(certs, i).value;
       cert_name name = idx(certs, i).name;
       set<rsa_keypair_id> signers;
 
============================================================
--- cmd_merging.cc	d0665576f84bff0c83322468d04ef070825f978f
+++ cmd_merging.cc	76227d1249a0bf097b4d0aa63fbe04d92e3f2419
@@ -99,7 +99,7 @@ pick_branch_for_update(options & opts, d
   set< branch_name > branches;
   for (vector< revision<cert> >::const_iterator i = certs.begin();
        i != certs.end(); i++)
-    branches.insert(branch_name(decode_base64(i->inner().value)()));
+    branches.insert(branch_name(i->inner().value()));
 
   if (branches.find(opts.branchname) != branches.end())
     {
============================================================
--- cmd_ws_commit.cc	73f2a0c13972f94ad2fcc93d0aac750af1ebee9c
+++ cmd_ws_commit.cc	96c5d93b31ffe4437a647caff8919ff3e856b64c
@@ -1307,10 +1307,8 @@ CMD(commit, "commit", "ci", CMD_REF(work
     project.get_revision_certs(restricted_rev_id, ctmp);
     for (vector< revision<cert> >::const_iterator i = ctmp.begin();
          i != ctmp.end(); ++i)
-      {
-        cert_value vtmp = decode_base64(i->inner().value);
-        certs.insert(make_pair(i->inner().name, vtmp));
-      }
+      certs.insert(make_pair(i->inner().name, i->inner().value));
+
     revision_data rdat;
     db.get_revision(restricted_rev_id, rdat);
     app.lua.hook_note_commit(restricted_rev_id, rdat, certs);
============================================================
--- commands.cc	1ecf0a9c99788b117e23ed8c7124811674c5923f
+++ commands.cc	f815513f8a69b69bcf44822070d793895cdf9888
@@ -874,14 +874,14 @@ describe_revision(project_t & project, r
        i != tmp.end(); ++i)
     {
       description += " ";
-      description += decode_base64(i->inner().value)();
+      description += i->inner().value();
     }
   project.get_revision_certs_by_name(id, date_name, tmp);
   for (vector< revision<cert> >::const_iterator i = tmp.begin();
        i != tmp.end(); ++i)
     {
       description += " ";
-      description += decode_base64(i->inner().value)();
+      description += i->inner().value();
     }
 
   return description;
============================================================
--- database.cc	168be0db6ec45fd18c6716e0a622e7515916ef94
+++ database.cc	c96663fc818db68864f8754d6bdc1bac842a2458
@@ -377,12 +377,12 @@ private:
 
   void get_certs(hexenc<id> const & ident,
                  cert_name const & name,
-                 base64<cert_value> const & val,
+                 cert_value const & val,
                  vector<cert> & certs,
                  string const & table);
 
   void get_certs(cert_name const & name,
-                 base64<cert_value> const & val,
+                 cert_value const & val,
                  vector<cert> & certs,
                  string const & table);
 
@@ -2766,7 +2766,6 @@ database_impl::cert_exists(cert const & 
                            string const & table)
 {
   results res;
-  cert_value value = decode_base64(t.value);
   query q = query("SELECT id FROM " + table + " WHERE id = ? "
                   "AND name = ? "
                   "AND value = ? "
@@ -2774,7 +2773,7 @@ database_impl::cert_exists(cert const & 
                   "AND signature = ?")
     % text(t.ident())
     % text(t.name())
-    % blob(value())
+    % blob(t.value())
     % text(t.key())
     % blob(t.sig());
 
@@ -2790,7 +2789,6 @@ database_impl::put_cert(cert const & t,
 {
   hexenc<id> thash;
   cert_hash_code(t, thash);
-  cert_value value = decode_base64(t.value);
   rsa_sha1_signature sig;
 
   string insert = "INSERT INTO " + table + " VALUES(?, ?, ?, ?, ?, ?)";
@@ -2799,7 +2797,7 @@ database_impl::put_cert(cert const & t,
           % text(thash())
           % text(t.ident())
           % text(t.name())
-          % blob(value())
+          % blob(t.value())
           % text(t.key())
           % blob(t.sig()));
 }
@@ -2812,12 +2810,11 @@ database_impl::results_to_certs(results 
   for (size_t i = 0; i < res.size(); ++i)
     {
       cert t;
-      base64<cert_value> value = encode_base64(cert_value(res[i][2]));
       t = cert(hexenc<id>(res[i][0]),
-              cert_name(res[i][1]),
-              value,
-              rsa_keypair_id(res[i][3]),
-              rsa_sha1_signature(res[i][4]));
+               cert_name(res[i][1]),
+               cert_value(res[i][2]),
+               rsa_keypair_id(res[i][3]),
+               rsa_sha1_signature(res[i][4]));
       certs.push_back(t);
     }
 }
@@ -2888,7 +2885,7 @@ database_impl::get_certs(cert_name const
 
 void
 database_impl::get_certs(cert_name const & name,
-                         base64<cert_value> const & val,
+                         cert_value const & val,
                          vector<cert> & certs,
                          string const & table)
 {
@@ -2896,10 +2893,9 @@ database_impl::get_certs(cert_name const
   query q("SELECT id, name, value, keypair, signature FROM " + table +
           " WHERE name = ? AND value = ?");
 
-  cert_value binvalue = decode_base64(val);
   fetch(res, 5, any_rows,
         q % text(name())
-          % blob(binvalue()));
+          % blob(val()));
   results_to_certs(res, certs);
 }
 
@@ -2907,7 +2903,7 @@ database_impl::get_certs(hexenc<id> cons
 void
 database_impl::get_certs(hexenc<id> const & ident,
                          cert_name const & name,
-                         base64<cert_value> const & value,
+                         cert_value const & value,
                          vector<cert> & certs,
                          string const & table)
 {
@@ -2915,11 +2911,10 @@ database_impl::get_certs(hexenc<id> cons
   query q("SELECT id, name, value, keypair, signature FROM " + table +
           " WHERE id = ? AND name = ? AND value = ?");
 
-  cert_value binvalue = decode_base64(value);
   fetch(res, 5, any_rows,
         q % text(ident())
           % text(name())
-          % blob(binvalue()));
+          % blob(value()));
   results_to_certs(res, certs);
 }
 
@@ -3013,7 +3008,7 @@ database::get_revision_certs(revision_id
 outdated_indicator
 database::get_revision_certs(revision_id const & id,
                              cert_name const & name,
-                             base64<cert_value> const & val,
+                             cert_value const & val,
                              vector< revision<cert> > & ts)
 {
   vector<cert> certs;
@@ -3025,14 +3020,13 @@ database::get_revisions_with_cert(cert_n
 
 outdated_indicator
 database::get_revisions_with_cert(cert_name const & name,
-                                  base64<cert_value> const & val,
+                                  cert_value const & val,
                                   set<revision_id> & revisions)
 {
   revisions.clear();
   results res;
   query q("SELECT id FROM revision_certs WHERE name = ? AND value = ?");
-  cert_value binvalue = decode_base64(val);
-  imp->fetch(res, one_col, any_rows, q % text(name()) % blob(binvalue()));
+  imp->fetch(res, one_col, any_rows, q % text(name()) % blob(val()));
   for (results::const_iterator i = res.begin(); i != res.end(); ++i)
     revisions.insert(revision_id((*i)[0]));
   return imp->cert_stamper.get_indicator();
@@ -3040,7 +3034,7 @@ database::get_revision_certs(cert_name c
 
 outdated_indicator
 database::get_revision_certs(cert_name const & name,
-                             base64<cert_value> const & val,
+                             cert_value const & val,
                              vector< revision<cert> > & ts)
 {
   vector<cert> certs;
============================================================
--- database.hh	673f98403c91c3abd882b8802d09148199287969
+++ database.hh	6d8e070db13b8b7cd7d572e9b49e8adad9719a1d
@@ -274,18 +274,18 @@ public:
 
   // Only used by get_branch_certs (project.cc)
   outdated_indicator get_revision_certs(cert_name const & name,
-                          base64<cert_value> const & val,
+                          cert_value const & val,
                           std::vector< revision<cert> > & certs);
 
   // Only used by revision_is_in_branch (project.cc)
   outdated_indicator get_revision_certs(revision_id const & ident,
                           cert_name const & name,
-                          base64<cert_value> const & value,
+                          cert_value const & value,
                           std::vector< revision<cert> > & certs);
 
   // Only used by get_branch_heads (project.cc)
   outdated_indicator get_revisions_with_cert(cert_name const & name,
-                               base64<cert_value> const & value,
+                               cert_value const & value,
                                std::set<revision_id> & revisions);
 
   // Used through project.cc, and by
============================================================
--- netsync.cc	832911ff01940c887b43c73d47c4db7c41da1628
+++ netsync.cc	e52a6b004ef68b64510c8949ddaf90109050f458
@@ -645,10 +645,8 @@ session::~session()
           set<pair<rsa_keypair_id, pair<cert_name, cert_value> > > certs;
           for (vector<cert>::const_iterator j = ctmp.begin();
                j != ctmp.end(); ++j)
-            {
-              cert_value vtmp = decode_base64(j->value);
-              certs.insert(make_pair(j->key, make_pair(j->name, vtmp)));
-            }
+            certs.insert(make_pair(j->key, make_pair(j->name, j->value)));
+
           revision_data rdat;
           project.db.get_revision(*i, rdat);
           lua.hook_note_netsync_revision_received(*i, rdat, certs,
@@ -658,11 +656,8 @@ session::~session()
       //Certs (not attached to a new revision)
       for (vector<cert>::iterator i = unattached_certs.begin();
            i != unattached_certs.end(); ++i)
-        {
-          cert_value tmp = decode_base64(i->value);
-          lua.hook_note_netsync_cert_received(revision_id(i->ident), i->key,
-                                              i->name, tmp, session_id);
-        }
+        lua.hook_note_netsync_cert_received(revision_id(i->ident), i->key,
+                                            i->name, i->value, session_id);
     }
   lua.hook_note_netsync_end(session_id, error_code,
                             bytes_in, bytes_out,
============================================================
--- packet.cc	e617e272fd17fbb13bd705c1daf6113fa4f858da
+++ packet.cc	c44a0d07d219b67519ea96520ad8a513000f8a28
@@ -76,7 +76,7 @@ packet_writer::consume_revision_cert(rev
   ost << "[rcert " << t.inner().ident() << '\n'
       << "       " << t.inner().name() << '\n'
       << "       " << t.inner().key() << '\n'
-      << "       " << trim_ws(t.inner().value()) << "]\n"
+      << "       " << trim_ws(encode_base64(t.inner().value)()) << "]\n"
       << trim_ws(encode_base64(t.inner().sig)()) << '\n'
       << "[end]\n";
 }
@@ -215,7 +215,7 @@ namespace
       // canonicalize the base64 encodings to permit searches
       cert t = cert(hexenc<id>(certid),
                     cert_name(name),
-                    base64<cert_value>(canonical_base64(val)),
+                    decode_base64_as<cert_value>(val),
                     rsa_keypair_id(keyid),
                     decode_base64_as<rsa_sha1_signature>(body));
       cons.consume_revision_cert(revision<cert>(t));
@@ -496,7 +496,7 @@ UNIT_TEST(packet, roundabout)
     pw.consume_revision_data(rid, rdat);
 
     // a cert packet
-    base64<cert_value> val = encode_base64(cert_value("peaches"));
+    cert_value val("peaches");
     rsa_sha1_signature sig("blah blah there is no way this is a valid signature");
     // should be a type violation to use a file id here instead of a revision
     // id, but no-one checks...
============================================================
--- project.cc	fd4a5d9d8a3267204ff3a198a6dbf562c1df11a6
+++ project.cc	91bc4553292ae576135e759d2a8ad59baf022b48
@@ -82,17 +82,17 @@ namespace
   struct not_in_branch : public is_failure
   {
     database & db;
-    base64<cert_value > const & branch_encoded;
+    branch_name const & branch;
     not_in_branch(database & db,
-                  base64<cert_value> const & branch_encoded)
-      : db(db), branch_encoded(branch_encoded)
+                  branch_name const & branch)
+      : db(db), branch(branch)
     {}
     virtual bool operator()(revision_id const & rid)
     {
       vector< revision<cert> > certs;
       db.get_revision_certs(rid,
                             cert_name(branch_cert_name),
-                            branch_encoded,
+                            cert_value(branch()),
                             certs);
       erase_bogus_certs(db, certs);
       return certs.empty();
@@ -102,17 +102,17 @@ namespace
   struct suspended_in_branch : public is_failure
   {
     database & db;
-    base64<cert_value > const & branch_encoded;
+    branch_name const & branch;
     suspended_in_branch(database & db,
-                  base64<cert_value> const & branch_encoded)
-      : db(db), branch_encoded(branch_encoded)
+                        branch_name const & branch)
+      : db(db), branch(branch)
     {}
     virtual bool operator()(revision_id const & rid)
     {
       vector< revision<cert> > certs;
       db.get_revision_certs(rid,
                             cert_name(suspend_cert_name),
-                            branch_encoded,
+                            cert_value(branch()),
                             certs);
       erase_bogus_certs(db, certs);
       return !certs.empty();
@@ -133,20 +133,18 @@ project_t::get_branch_heads(branch_name 
   if (branch.first.outdated())
     {
       L(FL("getting heads of branch %s") % name);
-      base64<cert_value> branch_encoded = encode_base64(cert_value(name()));
 
-      outdated_indicator stamp;
       branch.first = db.get_revisions_with_cert(cert_name(branch_cert_name),
-                                                    branch_encoded,
-                                                    branch.second);
+                                                cert_value(name()),
+                                                branch.second);
 
-      not_in_branch p(db, branch_encoded);
+      not_in_branch p(db, name);
       erase_ancestors_and_failures(db, branch.second, p,
                                    inverse_graph_cache_ptr);
 
       if (!ignore_suspend_certs)
         {
-          suspended_in_branch s(db, branch_encoded);
+          suspended_in_branch s(db, name);
           std::set<revision_id>::iterator it = branch.second.begin();
           while (it != branch.second.end())
             if (s(*it))
@@ -165,10 +163,8 @@ project_t::revision_is_in_branch(revisio
 project_t::revision_is_in_branch(revision_id const & id,
                                  branch_name const & branch)
 {
-  base64<cert_value> branch_encoded = encode_base64(cert_value(branch()));
-
   vector<revision<cert> > certs;
-  db.get_revision_certs(id, branch_cert_name, branch_encoded, certs);
+  db.get_revision_certs(id, branch_cert_name, cert_value(branch()), certs);
 
   int num = certs.size();
 
@@ -195,10 +191,8 @@ project_t::revision_is_suspended_in_bran
 project_t::revision_is_suspended_in_branch(revision_id const & id,
                                  branch_name const & branch)
 {
-  base64<cert_value> branch_encoded = encode_base64(cert_value(branch()));
-
   vector<revision<cert> > certs;
-  db.get_revision_certs(id, suspend_cert_name, branch_encoded, certs);
+  db.get_revision_certs(id, suspend_cert_name, cert_value(branch()), certs);
 
   int num = certs.size();
 
@@ -255,10 +249,8 @@ project_t::get_revision_branches(revisio
   branches.clear();
   for (std::vector<revision<cert> >::const_iterator i = certs.begin();
        i != certs.end(); ++i)
-    {
-      cert_value b = decode_base64(i->inner().value);
-      branches.insert(branch_name(b()));
-    }
+    branches.insert(branch_name(i->inner().value()));
+
   return i;
 }
 
@@ -266,8 +258,7 @@ project_t::get_branch_certs(branch_name 
 project_t::get_branch_certs(branch_name const & branch,
                             std::vector<revision<cert> > & certs)
 {
-  base64<cert_value> branch_encoded = encode_base64(cert_value(branch()));
-  return db.get_revision_certs(branch_cert_name, branch_encoded, certs);
+  return db.get_revision_certs(branch_cert_name, cert_value(branch()), certs);
 }
 
 tag_t::tag_t(revision_id const & ident,
@@ -303,10 +294,9 @@ project_t::get_tags(set<tag_t> & tags)
   tags.clear();
   for (std::vector<revision<cert> >::const_iterator i = certs.begin();
        i != certs.end(); ++i)
-    {
-      cert_value value = decode_base64(i->inner().value);
-      tags.insert(tag_t(revision_id(i->inner().ident), utf8(value()), i->inner().key));
-    }
+    tags.insert(tag_t(revision_id(i->inner().ident),
+                      utf8(i->inner().value()), i->inner().key));
+
   return i;
 }
 
============================================================
--- revision.cc	5f45dc66571d4ca62bddc7b943b815596f82ef7b
+++ revision.cc	6c2631fcf27ce20938e7abe44d9f0c6393865bef
@@ -1066,10 +1066,9 @@ anc_graph::add_node_for_old_manifest(man
           i != mcerts.end(); ++i)
         {
           L(FL("loaded '%s' manifest cert for node %s") % i->inner().name % node);
-          cert_value tv = decode_base64(i->inner().value);
           ++n_certs_in;
-          certs.insert(make_pair(node,
-                                      make_pair(i->inner().name, tv)));
+          certs.insert(make_pair(node, make_pair(i->inner().name,
+                                                 i->inner().value)));
         }
     }
   else
@@ -1107,13 +1106,12 @@ u64 anc_graph::add_node_for_oldstyle_rev
           i != rcerts.end(); ++i)
         {
           L(FL("loaded '%s' revision cert for node %s") % i->inner().name % node);
-          cert_value tv = decode_base64(i->inner().value);
           ++n_certs_in;
-          certs.insert(make_pair(node,
-                                      make_pair(i->inner().name, tv)));
+          certs.insert(make_pair(node, make_pair(i->inner().name,
+                                                 i->inner().value)));
 
           if (i->inner().name == branch_cert_name)
-            branches.insert(tv());
+            branches.insert(i->inner().value());
         }
     }
   else
@@ -1695,10 +1693,9 @@ build_changesets_from_manifest_ancestry(
   for (vector< manifest<cert> >::const_iterator i = tmp.begin();
        i != tmp.end(); ++i)
     {
-      cert_value tv = decode_base64(i->inner().value);
       manifest_id child, parent;
       child = manifest_id(i->inner().ident);
-      parent = manifest_id(tv());
+      parent = manifest_id(i->inner().value());
 
       u64 parent_node = graph.add_node_for_old_manifest(parent);
       u64 child_node = graph.add_node_for_old_manifest(child);
============================================================
--- transforms.cc	37cf33ed51b47de79a6001247cfb2571ce1d7b0e
+++ transforms.cc	bbac152c792f330fc02e3b2ec76aba70dade4581
@@ -245,23 +245,6 @@ calculate_ident(revision_data const & da
   ident = revision_id(tmp);
 }
 
-string
-canonical_base64(string const & s)
-{
-  try
-    {
-      Botan::Pipe pipe(new Botan::Base64_Decoder(),
-                       new Botan::Base64_Encoder());
-      pipe.process_msg(s);
-      return pipe.read_all_as_string();
-    }
-  catch (Botan::Exception & e)
-    {
-      error_in_transform(e);
-    }
-}
-
-
 #ifdef BUILD_UNIT_TESTS
 #include "unit_tests.hh"
 #include <stdlib.h>
============================================================
--- transforms.hh	e4d0e3f76acf27d96ccf87b6741921a99b3c6833
+++ transforms.hh	7b1ad2508a1fed5c39b318d8d1dc1fb1b5f2725b
@@ -126,10 +126,6 @@ void calculate_ident(revision_data const
 void calculate_ident(revision_data const & dat,
                      revision_id & ident);
 
-// canonicalize base64 encoding
-std::string canonical_base64(std::string const & s);
-
-
 // Local Variables:
 // mode: C++
 // fill-column: 76
============================================================
--- update.cc	c6472ee28faff6f12f9882801d0bbfbd7efe606f
+++ update.cc	04ca1a313bbd21e3fb4654074b36a791246052af
@@ -63,7 +63,7 @@ get_test_results_for_revision(project_t 
   for (vector< revision<cert> >::const_iterator i = certs.begin();
        i != certs.end(); ++i)
     {
-      cert_value cv = decode_base64(i->inner().value);
+      cert_value cv = i->inner().value;
       try
         {
           bool test_ok = lexical_cast<bool>(cv());