fix #3638

23 files changed, 794 insertions, 467 deletions

diff --git a/src/include/taler_crypto_lib.h b/src/include/taler_crypto_lib.h
index db663612..0c0ad886 100644
--- a/src/include/taler_crypto_lib.h
+++ b/src/include/taler_crypto_lib.h
@@ -28,6 +28,296 @@
 /* ****************** Coin crypto primitives ************* */
 
 /**
+ * Type of public keys for Taler reserves.
+ */
+struct TALER_ReservePublicKey
+{
+  /**
+   * Taler uses EdDSA for reserves.
+   */
+  struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
+};
+
+
+/**
+ * Type of private keys for Taler reserves.
+ */
+struct TALER_ReservePrivateKey
+{
+  /**
+   * Taler uses EdDSA for reserves.
+   */
+  struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_priv;
+};
+
+
+/**
+ * Type of signatures used with Taler reserves.
+ */
+struct TALER_ReserveSignature
+{
+  /**
+   * Taler uses EdDSA for reserves.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature eddsa_signature;
+};
+
+
+/**
+ * Type of public keys to for merchant authorizations.
+ * Merchants can issue refunds using the corresponding
+ * private key.
+ */
+struct TALER_MerchantPublicKey
+{
+  /**
+   * Taler uses EdDSA for merchants.
+   */
+  struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
+};
+
+
+/**
+ * Type of private keys for merchant authorizations.
+ * Merchants can issue refunds using the corresponding
+ * private key.
+ */
+struct TALER_MerchantPrivateKey
+{
+  /**
+   * Taler uses EdDSA for merchants.
+   */
+  struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_priv;
+};
+
+
+/**
+ * Type of public keys used by clients to sign
+ * messages during a melting session.
+ */
+struct TALER_SessionPublicKey
+{
+  /**
+   * Taler uses EdDSA for melting session keys.
+   */
+  struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
+};
+
+
+/**
+ * Type of public keys used by clients to sign
+ * messages during a melting session.
+ */
+struct TALER_SessionPrivateKey
+{
+  /**
+   * Taler uses EdDSA for melting session keys.
+   */
+  struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_priv;
+};
+
+
+/**
+ * Type of transfer public keys used during refresh
+ * operations.
+ */
+struct TALER_TransferPublicKey
+{
+  /**
+   * Taler uses ECDSA for transfer keys.
+   * FIXME: should this not be ECDHE?
+   */
+  struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_pub;
+};
+
+
+/**
+ * Type of transfer public keys used during refresh
+ * operations.
+ */
+struct TALER_TransferPrivateKey
+{
+  /**
+   * Taler uses ECDSA for melting session keys.
+   * FIXME: should this not be ECDHE?
+   */
+  struct GNUNET_CRYPTO_EcdsaPrivateKey ecdsa_priv;
+};
+
+
+/**
+ * Type of signatures used by clients to sign
+ * messages during a melting session.
+ */
+struct TALER_SessionSignature
+{
+  /**
+   * Taler uses EdDSA for melting session keys.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature eddsa_signature;
+};
+
+
+/**
+ * Type of online public keys used by the mint to sign
+ * messages.
+ */
+struct TALER_MintPublicKey
+{
+  /**
+   * Taler uses EdDSA for online mint message signing.
+   */
+  struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
+};
+
+
+/**
+ * Type of online public keys used by the mint to
+ * sign messages.
+ */
+struct TALER_MintPrivateKey
+{
+  /**
+   * Taler uses EdDSA for online signatures sessions.
+   */
+  struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_priv;
+};
+
+
+/**
+ * Type of signatures used by the mint to sign messages online.
+ */
+struct TALER_MintSignature
+{
+  /**
+   * Taler uses EdDSA for online signatures sessions.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature eddsa_signature;
+};
+
+
+/**
+ * Type of the offline master public key used by the mint.
+ */
+struct TALER_MasterPublicKey
+{
+  /**
+   * Taler uses EdDSA for the long-term offline master key.
+   */
+  struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
+};
+
+
+/**
+ * Type of the offline master public keys used by the mint.
+ */
+struct TALER_MasterPrivateKey
+{
+  /**
+   * Taler uses EdDSA for the long-term offline master key.
+   */
+  struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_priv;
+};
+
+
+/**
+ * Type of signatures by the offline master public key used by the mint.
+ */
+struct TALER_MasterSignature
+{
+  /**
+   * Taler uses EdDSA for the long-term offline master key.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature eddsa_signature;
+};
+
+
+
+/**
+ * Type of public keys for Taler coins.
+ */
+struct TALER_CoinSpendPublicKey
+{
+  /**
+   * Taler uses ECDSA for coins.
+   */
+  struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_pub;
+};
+
+
+/**
+ * Type of private keys for Taler coins.
+ */
+struct TALER_CoinSpendPrivateKey
+{
+  /**
+   * Taler uses ECDSA for coins.
+   */
+  struct GNUNET_CRYPTO_EcdsaPrivateKey ecdsa_priv;
+};
+
+
+/**
+ * Type of signatures made with Taler coins.
+ */
+struct TALER_CoinSpendSignature
+{
+  /**
+   * Taler uses ECDSA for coins.
+   */
+  struct GNUNET_CRYPTO_EcdsaSignature ecdsa_signature;
+};
+
+
+/**
+ * Type of blinding keys for Taler.
+ */
+struct TALER_DenominationBlindingKey
+{
+  /**
+   * Taler uses RSA for blinding.
+   */
+  struct GNUNET_CRYPTO_rsa_BlindingKey *rsa_blinding_key;
+};
+
+
+/**
+ * Type of (unblinded) coin signatures for Taler.
+ */
+struct TALER_DenominationSignature
+{
+  /**
+   * Taler uses RSA for blinding.
+   */
+  struct GNUNET_CRYPTO_rsa_Signature *rsa_signature;
+};
+
+
+/**
+ * Type of public signing keys for verifying blindly signed coins.
+ */
+struct TALER_DenominationPublicKey
+{
+  /**
+   * Taler uses RSA for signing coins.
+   */
+  struct GNUNET_CRYPTO_rsa_PublicKey *rsa_public_key;
+};
+
+
+/**
+ * Type of private signing keys for blind signing of coins.
+ */
+struct TALER_DenominationPrivateKey
+{
+  /**
+   * Taler uses RSA for signing coins.
+   */
+  struct GNUNET_CRYPTO_rsa_PrivateKey *rsa_private_key;
+};
+
+
+/**
  * Public information about a coin (including the public key
  * of the coin, the denomination key and the signature with
  * the denomination key).
@@ -37,19 +327,19 @@ struct TALER_CoinPublicInfo
   /**
    * The coin's public key.
    */
-  struct GNUNET_CRYPTO_EcdsaPublicKey coin_pub;
+  struct TALER_CoinSpendPublicKey coin_pub;
 
   /**
    * Public key representing the denomination of the coin
    * that is being deposited.
    */
-  struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub;
+  struct TALER_DenominationPublicKey denom_pub;
 
   /**
    * (Unblinded) signature over @e coin_pub with @e denom_pub,
    * which demonstrates that the coin is valid.
    */
-  struct GNUNET_CRYPTO_rsa_Signature *denom_sig;
+  struct TALER_DenominationSignature denom_sig;
 };
 
 
@@ -126,7 +416,7 @@ struct TALER_RefreshLinkEncrypted
   /**
    * Encrypted private key of the coin.
    */
-  char coin_priv_enc[sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)];
+  char coin_priv_enc[sizeof (struct TALER_CoinSpendPrivateKey)];
 
 };
 
@@ -140,12 +430,12 @@ struct TALER_RefreshLinkDecrypted
   /**
    * Private key of the coin.
    */
-  struct GNUNET_CRYPTO_EcdsaPrivateKey coin_priv;
+  struct TALER_CoinSpendPrivateKey coin_priv;
 
   /**
-   * Blinding key with @e blinding_key_enc_size bytes.
+   * Blinding key.
    */
-  struct GNUNET_CRYPTO_rsa_BlindingKey *blinding_key;
+  struct TALER_DenominationBlindingKey blinding_key;
 
 };
 
diff --git a/src/include/taler_mint_service.h b/src/include/taler_mint_service.h
index f300a5cf..30aaad38 100644
--- a/src/include/taler_mint_service.h
+++ b/src/include/taler_mint_service.h
@@ -1,6 +1,6 @@
 /*
   This file is part of TALER
-  Copyright (C) 2014 Christian Grothoff (and other contributing authors)
+  Copyright (C) 2014, 2015 Christian Grothoff (and other contributing authors)
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
@@ -42,7 +42,7 @@ struct TALER_MINT_SigningPublicKey
   /**
    * The signing public key
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey key;
+  struct TALER_MintPublicKey key;
 
   /**
    * Validity start time
@@ -64,7 +64,7 @@ struct TALER_MINT_DenomPublicKey
   /**
    * The public key
    */
-  struct GNUNET_CRYPTO_rsa_PublicKey *key;
+  struct TALER_DenominationPublicKey key;
 
   /**
    * Timestamp indicating when the denomination key becomes valid
@@ -132,7 +132,7 @@ TALER_MINT_cleanup (struct TALER_MINT_Context *ctx);
  * @param hostname the hostname of the mint
  * @param port the point where the mint's HTTP service is running.  If port is
  *             given as 0, ports 80 or 443 are chosen depending on @a url.
- * @param mint_key the public key of the mint.  This is used to verify the
+ * @param master_key the public master key of the mint.  This is used to verify the
  *                 responses of the mint.
  * @return the mint handle; NULL upon error
  */
@@ -140,7 +140,7 @@ struct TALER_MINT_Handle *
 TALER_MINT_connect (struct TALER_MINT_Context *ctx,
                     const char *hostname,
                     uint16_t port,
-                    struct GNUNET_CRYPTO_EddsaPublicKey *mint_key);
+                    const struct TALER_MasterPublicKey *master_key);
 
 /**
  * Disconnect from the mint
@@ -282,15 +282,15 @@ struct TALER_MINT_DepositHandle *
 TALER_MINT_deposit_submit_json_ (struct TALER_MINT_Handle *mint,
                                  TALER_MINT_DepositResultCallback *cb,
                                  void *cls,
-                                 struct GNUNET_CRYPTO_EddsaPublicKey *coin_pub,
-                                 struct TALER_BLIND_SigningPublicKey *denom_pub,
+                                 const struct TALER_CoinPublicKey *coin_pub,
+                                 const struct TALER_BLIND_SigningPublicKey *denom_pub,
                                  struct TALER_BLIND_Signature *ubsig,
                                  uint64_t transaction_id,
                                  struct TALER_Amount *amount,
-                                 struct GNUNET_CRYPTO_EddsaPublicKey *merchant_pub,
-                                 struct GNUNET_HashCode *h_contract,
-                                 struct GNUNET_HashCode *h_wire,
-                                 struct GNUNET_CRYPTO_EddsaSignature *csig,
+                                 const struct TALER_MerchantPublicKey *merchant_pub,
+                                 const struct GNUNET_HashCode *h_contract,
+                                 const struct GNUNET_HashCode *h_wire,
+                                 const struct TALER_CoinSignature *csig,
                                  json_t *wire_obj);
 #endif
 
diff --git a/src/include/taler_signatures.h b/src/include/taler_signatures.h
index 4566764d..51134bf2 100644
--- a/src/include/taler_signatures.h
+++ b/src/include/taler_signatures.h
@@ -1,6 +1,6 @@
 /*
   This file is part of TALER
-  Copyright (C) 2014 Christian Grothoff (and other contributing authors)
+  Copyright (C) 2014, 2015 Christian Grothoff (and other contributing authors)
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU General Public License as published by the Free Software
@@ -28,7 +28,6 @@
 #ifndef TALER_SIGNATURES_H
 #define TALER_SIGNATURES_H
 
-#include <gnunet/gnunet_util_lib.h>
 #include "taler_util.h"
 
 /**
@@ -129,7 +128,7 @@ struct TALER_WithdrawRequest
    * Reserve public key (which reserve to withdraw from).  This is
    * the public key which must match the signature.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
+  struct TALER_ReservePublicKey reserve_pub;
 
   /**
    * Value of the coin being minted (matching the denomination key)
@@ -189,7 +188,7 @@ struct TALER_DepositRequest
   /**
    * The coin's public key.
    */
-  struct GNUNET_CRYPTO_EcdsaPublicKey coin_pub;
+  struct TALER_CoinSpendPublicKey coin_pub;
 
 };
 
@@ -232,12 +231,12 @@ struct TALER_DepositConfirmation
   /**
    * The coin's public key.
    */
-  struct GNUNET_CRYPTO_EcdsaPublicKey coin_pub;
+  struct TALER_CoinSpendPublicKey coin_pub;
 
   /**
    * The Merchant's public key.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey merchant;
+  struct TALER_MerchantPublicKey merchant;
 
 };
 
@@ -274,7 +273,7 @@ struct RefreshMeltCoinSignature
   /**
    * The coin's public key.
    */
-  struct GNUNET_CRYPTO_EcdsaPublicKey coin_pub;
+  struct TALER_CoinSpendPublicKey coin_pub;
 };
 
 
@@ -298,7 +297,7 @@ struct RefreshMeltSessionSignature
    * Public key of the refresh session for which
    * @e melt_client_signature must be a valid signature.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey session_key;
+  struct TALER_SessionPublicKey session_key;
 
   /**
    * What is the total value of the coins created during the
@@ -348,10 +347,12 @@ struct RefreshMeltConfirmSignRequestBody
    */
   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
 
+  // FIXME: We probably need more info in here...
+
   /**
-   * FIXME.
+   * Public key the client uses for this session.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey session_pub;
+  struct TALER_SessionPublicKey session_pub;
 };
 
 
@@ -365,7 +366,7 @@ struct TALER_MINT_SignKeyIssue
   /**
    * Signature over the signing key (by the master key of the mint).
    */
-  struct GNUNET_CRYPTO_EddsaSignature signature;
+  struct TALER_MasterSignature signature;
 
   /**
    * Purpose is #TALER_SIGNATURE_MASTER_SIGNKEY.
@@ -376,7 +377,7 @@ struct TALER_MINT_SignKeyIssue
    * Master public key of the mint corresponding to @e signature.
    * This is the long-term offline master key of the mint.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey master_pub;
+  struct TALER_MasterPublicKey master_pub;
 
   /**
    * When does this signing key begin to be valid?
@@ -395,7 +396,7 @@ struct TALER_MINT_SignKeyIssue
    * The public online signing key that the mint will use
    * between @e start and @e expire.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey signkey_pub;
+  struct TALER_MintPublicKey signkey_pub;
 };
 
 
@@ -409,7 +410,7 @@ struct TALER_MINT_DenomKeyIssue
    * Signature over this struct to affirm the validity
    * of the key.
    */
-  struct GNUNET_CRYPTO_EddsaSignature signature;
+  struct TALER_MasterSignature signature;
 
   /**
    * Purpose ist #TALER_SIGNATURE_MASTER_DENOM.
@@ -420,7 +421,7 @@ struct TALER_MINT_DenomKeyIssue
    * The long-term offline master key of the mint that was
    * used to create @e signature.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey master;
+  struct TALER_MasterPublicKey master;
 
   /**
    * Start time of the validity period for this key.
diff --git a/src/lib/mint_api.c b/src/lib/mint_api.c
index eb2697a2..305fc95d 100644
--- a/src/lib/mint_api.c
+++ b/src/lib/mint_api.c
@@ -179,9 +179,11 @@ struct TALER_MINT_KeysGetHandle
   char *url;
 
   TALER_MINT_KeysGetCallback cb;
-  void *cls;
+
+  void *cb_cls;
 
   TALER_MINT_ContinuationCallback cont_cb;
+
   void *cont_cls;
 };
 
@@ -202,7 +204,8 @@ struct TALER_MINT_DepositHandle
   char *url;
 
   TALER_MINT_DepositResultCallback cb;
-  void *cls;
+
+  void *cb_cls;
 
   char *json_enc;
 
@@ -219,7 +222,8 @@ struct TALER_MINT_DepositHandle
  * @return #GNUNET_OK upon success; #GNUNET_SYSERR upon failure
  */
 static int
-parse_timestamp (struct GNUNET_TIME_Absolute *abs, const char *tstamp_enc)
+parse_timestamp (struct GNUNET_TIME_Absolute *abs,
+                 const char *tstamp_enc)
 {
   unsigned long tstamp;
 
@@ -242,7 +246,7 @@ parse_timestamp (struct GNUNET_TIME_Absolute *abs, const char *tstamp_enc)
 static int
 parse_json_signkey (struct TALER_MINT_SigningPublicKey **_sign_key,
                     json_t *sign_key_obj,
-                    struct GNUNET_CRYPTO_EddsaPublicKey *master_key)
+                    struct TALER_MasterPublicKey *master_key)
 {
   json_t *valid_from_obj;
   json_t *valid_until_obj;
@@ -281,7 +285,7 @@ parse_json_signkey (struct TALER_MINT_SigningPublicKey **_sign_key,
   EXITIF (GNUNET_SYSERR ==
           GNUNET_CRYPTO_eddsa_public_key_from_string (key_enc,
                                                       52,
-                                                      &sign_key_issue.signkey_pub));
+                                                      &sign_key_issue.signkey_pub.eddsa_pub));
   sign_key_issue.purpose.purpose = htonl (TALER_SIGNATURE_MASTER_SIGNKEY);
   sign_key_issue.purpose.size =
       htonl (sizeof (sign_key_issue)
@@ -293,7 +297,7 @@ parse_json_signkey (struct TALER_MINT_SigningPublicKey **_sign_key,
           GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_MASTER_SIGNKEY,
                                       &sign_key_issue.purpose,
                                       &sig,
-                                      master_key));
+                                      &master_key->eddsa_pub));
   sign_key = GNUNET_new (struct TALER_MINT_SigningPublicKey);
   sign_key->valid_from = valid_from;
   sign_key->valid_until = valid_until;
@@ -337,7 +341,7 @@ parse_json_amount (json_t *amount_obj, struct TALER_Amount *amt)
 static int
 parse_json_denomkey (struct TALER_MINT_DenomPublicKey **_denom_key,
                      json_t *denom_key_obj,
-                     struct GNUNET_CRYPTO_EddsaPublicKey *master_key)
+                     struct TALER_MasterPublicKey *master_key)
 {
   json_t *obj;
   const char *sig_enc;
@@ -424,9 +428,9 @@ parse_json_denomkey (struct TALER_MINT_DenomPublicKey **_denom_key,
           GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_MASTER_DENOM,
                                       &denom_key_issue.purpose,
                                       &sig,
-                                      master_key));
+                                      &master_key->eddsa_pub));
   denom_key = GNUNET_new (struct TALER_MINT_DenomPublicKey);
-  denom_key->key = pk;
+  denom_key->key.rsa_public_key = pk;
   denom_key->valid_from = valid_from;
   denom_key->withdraw_valid_until = withdraw_valid_until;
   denom_key->deposit_valid_until = deposit_valid_until;
@@ -451,7 +455,7 @@ parse_response_keys_get (const char *in, size_t size,
 {
   json_t *resp_obj;
   struct TALER_MINT_DenomPublicKey **denom_keys;
-  struct GNUNET_CRYPTO_EddsaPublicKey master_key;
+  struct TALER_MasterPublicKey master_key;
   struct GNUNET_TIME_Absolute list_issue_date;
   struct TALER_MINT_SigningPublicKey **sign_keys;
   unsigned int n_denom_keys;
@@ -487,7 +491,7 @@ parse_response_keys_get (const char *in, size_t size,
     EXITIF (GNUNET_OK !=
               GNUNET_CRYPTO_eddsa_public_key_from_string (master_key_enc,
                                                           52,
-                                                          &master_key));
+                                                          &master_key.eddsa_pub));
   }
   {
     /* parse the issue date of the response */
@@ -664,7 +668,8 @@ request_failed (struct TALER_MINT_Handle *mint, long resp_code)
     {
       struct TALER_MINT_DepositHandle *dh = mint->req.deposit;
       TALER_MINT_DepositResultCallback cb = dh->cb;
-      void *cls = dh->cls;
+      void *cls = dh->cb_cls;
+
       GNUNET_assert (NULL != dh);
       cleanup_deposit (dh);
       mint_disconnect (mint);
@@ -705,7 +710,7 @@ request_succeeded (struct TALER_MINT_Handle *mint, long resp_code)
             parse_response_keys_get (mint->buf, mint->buf_size,
                                      &sign_keys, &n_sign_keys,
                                      &denom_keys, &n_denom_keys))
-          gh->cb (gh->cls, sign_keys, denom_keys);
+          gh->cb (gh->cb_cls, sign_keys, denom_keys);
         else
           emsg = GNUNET_strdup ("Error parsing response");
       }
@@ -727,7 +732,7 @@ request_succeeded (struct TALER_MINT_Handle *mint, long resp_code)
       GNUNET_assert (NULL != dh);
       obj = NULL;
       cb = dh->cb;
-      cls = dh->cls;
+      cls = dh->cb_cls;
       status = 0;
       if (200 == resp_code)
       {
@@ -903,15 +908,15 @@ download (char *bufptr, size_t size, size_t nitems, void *cls)
  * @param ctx the context
  * @param hostname the hostname of the mint
  * @param port the point where the mint's HTTP service is running.
- * @param mint_key the public key of the mint.  This is used to verify the
- *                 responses of the mint.
+ * @param mint_key the offline master public key of the mint.
+ *                 This is used to verify the responses of the mint.
  * @return the mint handle; NULL upon error
  */
 struct TALER_MINT_Handle *
 TALER_MINT_connect (struct TALER_MINT_Context *ctx,
                     const char *hostname,
                     uint16_t port,
-                    struct GNUNET_CRYPTO_EddsaPublicKey *mint_key)
+                    const struct TALER_MasterPublicKey *mint_key)
 {
   struct TALER_MINT_Handle *mint;
 
@@ -952,15 +957,17 @@ TALER_MINT_disconnect (struct TALER_MINT_Handle *mint)
  *
  * @param mint handle to the mint
  * @param cb the callback to call with each retrieved denomination key
- * @param cls closure for the above callback
+ * @param cb_cls closure for the above callback
  * @param cont_cb the callback to call after completing this asynchronous call
  * @param cont_cls the closure for the continuation callback
  * @return a handle to this asynchronous call; NULL upon eror
  */
 struct TALER_MINT_KeysGetHandle *
 TALER_MINT_keys_get (struct TALER_MINT_Handle *mint,
-                           TALER_MINT_KeysGetCallback cb, void *cls,
-                           TALER_MINT_ContinuationCallback cont_cb, void *cont_cls)
+                     TALER_MINT_KeysGetCallback cb,
+                     void *cb_cls,
+                     TALER_MINT_ContinuationCallback cont_cb,
+                     void *cont_cls)
 {
   struct TALER_MINT_KeysGetHandle *gh;
 
@@ -970,12 +977,17 @@ TALER_MINT_keys_get (struct TALER_MINT_Handle *mint,
   mint->req_type = REQUEST_TYPE_KEYSGET;
   mint->req.keys_get = gh;
   gh->cb = cb;
-  gh->cls = cls;
+  gh->cb_cls = cb_cls;
   gh->cont_cb = cont_cb;
   gh->cont_cls = cont_cls;
-  GNUNET_asprintf (&gh->url, "http://%s:%hu/keys", mint->hostname, mint->port);
+  GNUNET_asprintf (&gh->url,
+                   "http://%s:%hu/keys",
+                   mint->hostname,
+                   mint->port);
   GNUNET_assert (CURLE_OK ==
-                 curl_easy_setopt (mint->curl, CURLOPT_URL, gh->url));
+                 curl_easy_setopt (mint->curl,
+                                   CURLOPT_URL,
+                                   gh->url));
   if (GNUNET_NO == mint->connected)
     mint_connect (mint);
   perform_now (mint->ctx);
@@ -1005,7 +1017,7 @@ TALER_MINT_keys_get_cancel (struct TALER_MINT_KeysGetHandle *get)
  *
  * @param mint the mint handle
  * @param cb the callback to call when a reply for this request is available
- * @param cls closure for the above callback
+ * @param cb_cls closure for the above callback
  * @param deposit_obj the deposit permission received from the customer along
  *         with the wireformat JSON object
  * @return a handle for this request; NULL if the JSON object could not be
@@ -1015,7 +1027,7 @@ TALER_MINT_keys_get_cancel (struct TALER_MINT_KeysGetHandle *get)
 struct TALER_MINT_DepositHandle *
 TALER_MINT_deposit_submit_json (struct TALER_MINT_Handle *mint,
                                 TALER_MINT_DepositResultCallback cb,
-                                void *cls,
+                                void *cb_cls,
                                 json_t *deposit_obj)
 {
   struct TALER_MINT_DepositHandle *dh;
@@ -1026,7 +1038,7 @@ TALER_MINT_deposit_submit_json (struct TALER_MINT_Handle *mint,
   mint->req_type = REQUEST_TYPE_DEPOSIT;
   mint->req.deposit = dh;
   dh->cb = cb;
-  dh->cls = cls;
+  dh->cb_cls = cb_cls;
   GNUNET_asprintf (&dh->url, "http://%s:%hu/deposit", mint->hostname, mint->port);
   GNUNET_assert (NULL != (dh->json_enc = json_dumps (deposit_obj, JSON_COMPACT)));
   GNUNET_assert (CURLE_OK ==
diff --git a/src/mint/key_io.c b/src/mint/key_io.c
index d267ce2a..182d6f3d 100644
--- a/src/mint/key_io.c
+++ b/src/mint/key_io.c
@@ -164,8 +164,9 @@ TALER_MINT_read_denom_key (const char *filename,
     GNUNET_free (data);
     return GNUNET_SYSERR;
   }
-  dki->denom_priv = priv;
-  dki->denom_pub = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
+  dki->denom_priv.rsa_private_key = priv;
+  dki->denom_pub.rsa_public_key
+    = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
   memcpy (&dki->issue,
           data,
           offset);
@@ -193,8 +194,9 @@ TALER_MINT_write_denom_key (const char *filename,
   int ret;
 
   fh = NULL;
-  priv_enc_size = GNUNET_CRYPTO_rsa_private_key_encode (dki->denom_priv,
-                                                        &priv_enc);
+  priv_enc_size
+    = GNUNET_CRYPTO_rsa_private_key_encode (dki->denom_priv.rsa_private_key,
+                                            &priv_enc);
   ret = GNUNET_SYSERR;
   if (NULL == (fh = GNUNET_DISK_file_open
                (filename,
diff --git a/src/mint/key_io.h b/src/mint/key_io.h
index b204629a..6c6722a8 100644
--- a/src/mint/key_io.h
+++ b/src/mint/key_io.h
@@ -52,7 +52,7 @@ struct TALER_MINT_SignKeyIssuePriv
   /**
    * Private key part of the mint's signing key.
    */
-  struct GNUNET_CRYPTO_EddsaPrivateKey signkey_priv;
+  struct TALER_MintPrivateKey signkey_priv;
 
   /**
    * Public information about a mint signing key.
@@ -75,13 +75,13 @@ struct TALER_MINT_DenomKeyIssuePriv
    * key is not available (this is the case after the key has expired
    * for signing coins, but is still valid for depositing coins).
    */
-  struct GNUNET_CRYPTO_rsa_PrivateKey *denom_priv;
+  struct TALER_DenominationPrivateKey denom_priv;
 
   /**
    * Decoded denomination public key (the hash of it is in
    * @e issue, but we sometimes need the full public key as well).
    */
-  struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub;
+  struct TALER_DenominationPublicKey denom_pub;
 
   /**
    * Signed public information about a denomination key.
diff --git a/src/mint/plugin_mintdb_common.c b/src/mint/plugin_mintdb_common.c
index 34aefb87..6e52a3bc 100644
--- a/src/mint/plugin_mintdb_common.c
+++ b/src/mint/plugin_mintdb_common.c
@@ -46,8 +46,8 @@ common_free_reserve_history (void *cls,
       break;
     case TALER_MINT_DB_RO_WITHDRAW_COIN:
       cbc = rh->details.withdraw;
-      GNUNET_CRYPTO_rsa_signature_free (cbc->sig);
-      GNUNET_CRYPTO_rsa_public_key_free (cbc->denom_pub);
+      GNUNET_CRYPTO_rsa_signature_free (cbc->sig.rsa_signature);
+      GNUNET_CRYPTO_rsa_public_key_free (cbc->denom_pub.rsa_public_key);
       GNUNET_free (cbc);
       break;
     }
diff --git a/src/mint/plugin_mintdb_postgres.c b/src/mint/plugin_mintdb_postgres.c
index 1d7a965c..1c038842 100644
--- a/src/mint/plugin_mintdb_postgres.c
+++ b/src/mint/plugin_mintdb_postgres.c
@@ -758,15 +758,10 @@ postgres_reserve_get (void *cls,
   PGresult *result;
   uint64_t expiration_date_nbo;
   struct TALER_DB_QueryParam params[] = {
-    TALER_DB_QUERY_PARAM_PTR(reserve->pub),
+    TALER_DB_QUERY_PARAM_PTR(&reserve->pub),
     TALER_DB_QUERY_PARAM_END
   };
 
-  if (NULL == reserve->pub)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
   result = TALER_DB_exec_prepared (session->conn,
                                    "get_reserve",
                                    params);
@@ -821,11 +816,11 @@ postgres_reserves_update (void *cls,
   struct GNUNET_TIME_AbsoluteNBO expiry_nbo;
   int ret;
 
-  if ((NULL == reserve) || (NULL == reserve->pub))
+  if (NULL == reserve)
     return GNUNET_SYSERR;
   ret = GNUNET_OK;
   struct TALER_DB_QueryParam params[] = {
-    TALER_DB_QUERY_PARAM_PTR (reserve->pub),
+    TALER_DB_QUERY_PARAM_PTR (&reserve->pub),
     TALER_DB_QUERY_PARAM_PTR (&balance_nbo.value),
     TALER_DB_QUERY_PARAM_PTR (&balance_nbo.fraction),
     TALER_DB_QUERY_PARAM_PTR (&expiry_nbo),
@@ -901,7 +896,7 @@ postgres_reserves_in_insert (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Reserve does not exist; creating a new one\n");
     struct TALER_DB_QueryParam params[] = {
-      TALER_DB_QUERY_PARAM_PTR (reserve->pub),
+      TALER_DB_QUERY_PARAM_PTR (&reserve->pub),
       TALER_DB_QUERY_PARAM_PTR (&balance_nbo.value),
       TALER_DB_QUERY_PARAM_PTR (&balance_nbo.fraction),
       TALER_DB_QUERY_PARAM_PTR_SIZED (balance_nbo.currency,
@@ -923,7 +918,7 @@ postgres_reserves_in_insert (void *cls,
   result = NULL;
   /* create new incoming transaction */
   struct TALER_DB_QueryParam params[] = {
-    TALER_DB_QUERY_PARAM_PTR (reserve->pub),
+    TALER_DB_QUERY_PARAM_PTR (&reserve->pub),
     TALER_DB_QUERY_PARAM_PTR (&balance_nbo.value),
     TALER_DB_QUERY_PARAM_PTR (&balance_nbo.fraction),
     TALER_DB_QUERY_PARAM_PTR_SIZED (&balance_nbo.currency,
@@ -1053,8 +1048,8 @@ postgres_get_collectable_blindcoin (void *cls,
     GNUNET_break (0);
     goto cleanup;
   }
-  collectable->denom_pub = denom_pub;
-  collectable->sig = denom_sig;
+  collectable->denom_pub.rsa_public_key = denom_pub;
+  collectable->sig.rsa_signature = denom_sig;
   ret = GNUNET_YES;
 
  cleanup:
@@ -1103,10 +1098,10 @@ postgres_insert_collectable_blindcoin (void *cls,
 
   ret = GNUNET_SYSERR;
   denom_pub_enc_size =
-      GNUNET_CRYPTO_rsa_public_key_encode (collectable->denom_pub,
+      GNUNET_CRYPTO_rsa_public_key_encode (collectable->denom_pub.rsa_public_key,
                                            &denom_pub_enc);
   denom_sig_enc_size =
-      GNUNET_CRYPTO_rsa_signature_encode (collectable->sig,
+      GNUNET_CRYPTO_rsa_signature_encode (collectable->sig.rsa_signature,
                                           &denom_sig_enc);
   struct TALER_DB_QueryParam params[] = {
     TALER_DB_QUERY_PARAM_PTR (h_blind),
@@ -1127,8 +1122,7 @@ postgres_insert_collectable_blindcoin (void *cls,
     QUERY_ERR (result);
     goto rollback;
   }
-  reserve.pub = (struct GNUNET_CRYPTO_EddsaPublicKey *)
-      &collectable->reserve_pub;
+  reserve.pub = collectable->reserve_pub;
   if (GNUNET_OK != postgres_reserve_get (cls,
                                          session,
                                          &reserve))
@@ -1172,7 +1166,7 @@ postgres_insert_collectable_blindcoin (void *cls,
 static struct ReserveHistory *
 postgres_get_reserve_history (void *cls,
                               struct TALER_MINTDB_Session *session,
-                              const struct GNUNET_CRYPTO_EddsaPublicKey *reserve_pub)
+                              const struct TALER_ReservePublicKey *reserve_pub)
 {
   PGresult *result;
   struct ReserveHistory *rh;
@@ -1219,7 +1213,7 @@ postgres_get_reserve_history (void *cls,
         GNUNET_break (0);
         goto cleanup;
       }
-      (void) memcpy (&bt->reserve_pub, reserve_pub, sizeof (bt->reserve_pub));
+      bt->reserve_pub = *reserve_pub;
       if (NULL != rh_head)
       {
         rh_head->next = GNUNET_new (struct ReserveHistory);
@@ -1238,7 +1232,7 @@ postgres_get_reserve_history (void *cls,
   result = NULL;
   {
     struct GNUNET_HashCode blind_ev;
-    struct GNUNET_CRYPTO_EddsaSignature reserve_sig;
+    struct TALER_ReserveSignature reserve_sig;
     struct CollectableBlindcoin *cbc;
     char *denom_pub_enc;
     char *denom_sig_enc;
@@ -1280,20 +1274,23 @@ postgres_get_reserve_history (void *cls,
         goto cleanup;
       }
       cbc = GNUNET_new (struct CollectableBlindcoin);
-      cbc->sig = GNUNET_CRYPTO_rsa_signature_decode (denom_sig_enc,
-                                                    denom_sig_enc_size);
+      cbc->sig.rsa_signature
+        = GNUNET_CRYPTO_rsa_signature_decode (denom_sig_enc,
+                                              denom_sig_enc_size);
       GNUNET_free (denom_sig_enc);
       denom_sig_enc = NULL;
-      cbc->denom_pub = GNUNET_CRYPTO_rsa_public_key_decode (denom_pub_enc,
-                                                            denom_pub_enc_size);
+      cbc->denom_pub.rsa_public_key
+        = GNUNET_CRYPTO_rsa_public_key_decode (denom_pub_enc,
+                                               denom_pub_enc_size);
       GNUNET_free (denom_pub_enc);
       denom_pub_enc = NULL;
-      if ((NULL == cbc->sig) || (NULL == cbc->denom_pub))
+      if ( (NULL == cbc->sig.rsa_signature) ||
+           (NULL == cbc->denom_pub.rsa_public_key) )
       {
-        if (NULL != cbc->sig)
-          GNUNET_CRYPTO_rsa_signature_free (cbc->sig);
-        if (NULL != cbc->denom_pub)
-          GNUNET_CRYPTO_rsa_public_key_free (cbc->denom_pub);
+        if (NULL != cbc->sig.rsa_signature)
+          GNUNET_CRYPTO_rsa_signature_free (cbc->sig.rsa_signature);
+        if (NULL != cbc->denom_pub.rsa_public_key)
+          GNUNET_CRYPTO_rsa_public_key_free (cbc->denom_pub.rsa_public_key);
         GNUNET_free (cbc);
         GNUNET_break (0);
         goto cleanup;
@@ -1394,10 +1391,10 @@ postgres_insert_deposit (void *cls,
 
   ret = GNUNET_SYSERR;
   denom_pub_enc_size =
-      GNUNET_CRYPTO_rsa_public_key_encode (deposit->coin.denom_pub,
+      GNUNET_CRYPTO_rsa_public_key_encode (deposit->coin.denom_pub.rsa_public_key,
                                            &denom_pub_enc);
   denom_sig_enc_size =
-      GNUNET_CRYPTO_rsa_signature_encode (deposit->coin.denom_sig,
+      GNUNET_CRYPTO_rsa_signature_encode (deposit->coin.denom_sig.rsa_signature,
                                           &denom_sig_enc);
   json_wire_enc = json_dumps (deposit->wire, JSON_COMPACT);
   TALER_amount_hton (&amount_nbo,
@@ -1450,7 +1447,7 @@ postgres_insert_deposit (void *cls,
 static int
 postgres_get_refresh_session (void *cls,
                               struct TALER_MINTDB_Session *session,
-                              const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                              const struct TALER_SessionPublicKey *refresh_session_pub,
                               struct RefreshSession *refresh_session)
 {
   // FIXME: check logic!
@@ -1526,7 +1523,7 @@ postgres_get_refresh_session (void *cls,
 static int
 postgres_create_refresh_session (void *cls,
                                  struct TALER_MINTDB_Session *session,
-                                 const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
+                                 const struct TALER_SessionPublicKey *session_pub,
                                  const struct RefreshSession *refresh_session)
 {
   // FIXME: actually store session data!
@@ -1570,7 +1567,7 @@ postgres_create_refresh_session (void *cls,
 static int
 postgres_insert_refresh_melt (void *cls,
                               struct TALER_MINTDB_Session *session,
-                              const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session,
+                              const struct TALER_SessionPublicKey *refresh_session,
                               uint16_t oldcoin_index,
                               const struct RefreshMelt *melt)
 {
@@ -1580,7 +1577,7 @@ postgres_insert_refresh_melt (void *cls,
   size_t buf_size;
   PGresult *result;
 
-  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (melt->coin.denom_pub,
+  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (melt->coin.denom_pub.rsa_public_key,
                                                   &buf);
   {
     struct TALER_DB_QueryParam params[] = {
@@ -1620,7 +1617,7 @@ postgres_insert_refresh_melt (void *cls,
 static int
 postgres_get_refresh_melt (void *cls,
                            struct TALER_MINTDB_Session *session,
-                           const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session,
+                           const struct TALER_SessionPublicKey *refresh_session,
                            uint16_t oldcoin_index,
                            struct RefreshMelt *melt)
 {
@@ -1645,9 +1642,9 @@ postgres_get_refresh_melt (void *cls,
 static int
 postgres_insert_refresh_order (void *cls,
                                struct TALER_MINTDB_Session *session,
-                               const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
+                               const struct TALER_SessionPublicKey *session_pub,
                                uint16_t num_newcoins,
-                               struct GNUNET_CRYPTO_rsa_PublicKey *const*denom_pubs)
+                               const struct TALER_DenominationPublicKey *denom_pubs)
 {
   // FIXME: check logic: was written for just one COIN!
   uint16_t newcoin_index_nbo = htons (num_newcoins);
@@ -1655,7 +1652,7 @@ postgres_insert_refresh_order (void *cls,
   size_t buf_size;
   PGresult *result;
 
-  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (*denom_pubs,
+  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (denom_pubs->rsa_public_key,
                                                   &buf);
 
   {
@@ -1701,9 +1698,9 @@ postgres_insert_refresh_order (void *cls,
 static int
 postgres_get_refresh_order (void *cls,
                             struct TALER_MINTDB_Session *session,
-                            const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
+                            const struct TALER_SessionPublicKey *session_pub,
                             uint16_t num_newcoins,
-                            struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs)
+                            struct TALER_DenominationPublicKey *denom_pubs)
 {
   // FIXME: check logic -- was written for just one coin!
   char *buf;
@@ -1744,7 +1741,9 @@ postgres_get_refresh_order (void *cls,
     return GNUNET_SYSERR;
   }
   PQclear (result);
-  denom_pubs[0] = GNUNET_CRYPTO_rsa_public_key_decode (buf, buf_size);
+  denom_pubs->rsa_public_key
+    = GNUNET_CRYPTO_rsa_public_key_decode (buf,
+                                           buf_size);
   GNUNET_free (buf);
   return GNUNET_OK;
 }
@@ -1767,7 +1766,7 @@ postgres_get_refresh_order (void *cls,
 static int
 postgres_insert_refresh_commit_coins (void *cls,
                                       struct TALER_MINTDB_Session *session,
-                                      const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                                      const struct TALER_SessionPublicKey *refresh_session_pub,
                                       unsigned int i,
                                       unsigned int num_newcoins,
                                       const struct RefreshCommitCoin *commit_coins)
@@ -1780,9 +1779,9 @@ postgres_insert_refresh_commit_coins (void *cls,
     TALER_DB_QUERY_PARAM_PTR_SIZED(commit_coins->coin_ev, commit_coins->coin_ev_size),
     TALER_DB_QUERY_PARAM_PTR(&cnc_index_nbo),
     TALER_DB_QUERY_PARAM_PTR(&newcoin_index_nbo),
-    TALER_DB_QUERY_PARAM_PTR_SIZED(commit_coins->refresh_link->coin_priv_enc,
-                                   commit_coins->refresh_link->blinding_key_enc_size +
-                                   sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)),
+    TALER_DB_QUERY_PARAM_PTR_SIZED (commit_coins->refresh_link->coin_priv_enc,
+                                    commit_coins->refresh_link->blinding_key_enc_size +
+                                    sizeof (struct TALER_CoinSpendPrivateKey)),
     TALER_DB_QUERY_PARAM_END
   };
 
@@ -1825,7 +1824,7 @@ postgres_insert_refresh_commit_coins (void *cls,
 static int
 postgres_get_refresh_commit_coins (void *cls,
                                    struct TALER_MINTDB_Session *session,
-                                   const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                                   const struct TALER_SessionPublicKey *refresh_session_pub,
                                    unsigned int cnc_index,
                                    unsigned int newcoin_index,
                                    struct RefreshCommitCoin *cc)
@@ -1873,7 +1872,7 @@ postgres_get_refresh_commit_coins (void *cls,
     return GNUNET_SYSERR;
   }
   PQclear (result);
-  if (rl_buf_size < sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))
+  if (rl_buf_size < sizeof (struct TALER_CoinSpendPrivateKey))
   {
     GNUNET_free (c_buf);
     GNUNET_free (rl_buf);
@@ -1896,7 +1895,7 @@ postgres_get_refresh_commit_coins (void *cls,
  * @param cls the `struct PostgresClosure` with the plugin-specific state
  * @param session database connection to use
  * @param refresh_session_pub public key of the refresh session this
- *        commitment belongs with
+ *        commitment belongs with  -- FIXME: should not be needed!
  * @param i set index (1st dimension)
  * @param j coin index (2nd dimension), corresponds to melted (old) coins
  * @param commit_link link information to store
@@ -1905,7 +1904,7 @@ postgres_get_refresh_commit_coins (void *cls,
 static int
 postgres_insert_refresh_commit_links (void *cls,
                                       struct TALER_MINTDB_Session *session,
-                                      const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                                      const struct TALER_SessionPublicKey *refresh_session_pub,
                                       unsigned int i,
                                       unsigned int j,
                                       const struct RefreshCommitLink *commit_link)
@@ -1950,7 +1949,7 @@ postgres_insert_refresh_commit_links (void *cls,
  * @param cls the `struct PostgresClosure` with the plugin-specific state
  * @param session database connection to use
  * @param refresh_session_pub public key of the refresh session this
- *        commitment belongs with
+ *        commitment belongs with -- FIXME: should not be needed!
  * @param i set index (1st dimension)
  * @param num_links size of the @a commit_link array
  * @param links[OUT] array of link information to return
@@ -1961,7 +1960,7 @@ postgres_insert_refresh_commit_links (void *cls,
 static int
 postgres_get_refresh_commit_links (void *cls,
                                    struct TALER_MINTDB_Session *session,
-                                   const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                                   const struct TALER_SessionPublicKey *refresh_session_pub,
                                    unsigned int i,
                                    unsigned int num_links,
                                    struct RefreshCommitLink *links)
@@ -2026,9 +2025,9 @@ postgres_get_refresh_commit_links (void *cls,
 static int
 postgres_insert_refresh_collectable (void *cls,
                                      struct TALER_MINTDB_Session *session,
-                                     const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
+                                     const struct TALER_SessionPublicKey *session_pub,
                                      uint16_t newcoin_index,
-                                     const struct GNUNET_CRYPTO_rsa_Signature *ev_sig)
+                                     const struct TALER_DenominationSignature *ev_sig)
 {
   // FIXME: check logic!
   uint16_t newcoin_index_nbo = htons (newcoin_index);
@@ -2036,7 +2035,7 @@ postgres_insert_refresh_collectable (void *cls,
   size_t buf_size;
   PGresult *result;
 
-  buf_size = GNUNET_CRYPTO_rsa_signature_encode (ev_sig,
+  buf_size = GNUNET_CRYPTO_rsa_signature_encode (ev_sig->rsa_signature,
                                                  &buf);
   {
     struct TALER_DB_QueryParam params[] = {
@@ -2073,7 +2072,7 @@ postgres_insert_refresh_collectable (void *cls,
 static struct LinkDataList *
 postgres_get_link_data_list (void *cls,
                              struct TALER_MINTDB_Session *session,
-                             const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub)
+                             const struct TALER_CoinSpendPublicKey *coin_pub)
 {
   // FIXME: check logic!
   struct LinkDataList *ldl;
@@ -2146,10 +2145,12 @@ postgres_get_link_data_list (void *cls,
             ld_buf,
             ld_buf_size);
 
-    sig = GNUNET_CRYPTO_rsa_signature_decode (sig_buf,
-                                              sig_buf_size);
-    denom_pub = GNUNET_CRYPTO_rsa_public_key_decode (pk_buf,
-                                                     pk_buf_size);
+    sig
+      = GNUNET_CRYPTO_rsa_signature_decode (sig_buf,
+                                            sig_buf_size);
+    denom_pub
+      = GNUNET_CRYPTO_rsa_public_key_decode (pk_buf,
+                                             pk_buf_size);
     GNUNET_free (pk_buf);
     GNUNET_free (sig_buf);
     GNUNET_free (ld_buf);
@@ -2170,8 +2171,8 @@ postgres_get_link_data_list (void *cls,
     pos = GNUNET_new (struct LinkDataList);
     pos->next = ldl;
     pos->link_data_enc = link_enc;
-    pos->denom_pub = denom_pub;
-    pos->ev_sig = sig;
+    pos->denom_pub.rsa_public_key = denom_pub;
+    pos->ev_sig.rsa_signature = sig;
     ldl = pos;
   }
   return ldl;
@@ -2196,8 +2197,8 @@ postgres_get_link_data_list (void *cls,
 static int
 postgres_get_transfer (void *cls,
                        struct TALER_MINTDB_Session *session,
-                       const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
-                       struct GNUNET_CRYPTO_EcdsaPublicKey *transfer_pub,
+                       const struct TALER_CoinSpendPublicKey *coin_pub,
+                       struct TALER_TransferPublicKey *transfer_pub,
                        struct TALER_EncryptedLinkSecret *shared_secret_enc)
 {
   // FIXME: check logic!
@@ -2260,7 +2261,7 @@ postgres_get_transfer (void *cls,
 static struct TALER_MINT_DB_TransactionList *
 postgres_get_coin_transactions (void *cls,
                                 struct TALER_MINTDB_Session *session,
-                                const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub)
+                                const struct TALER_CoinSpendPublicKey *coin_pub)
 {
   // FIXME: check logic!
   GNUNET_break (0); // FIXME: implement!
diff --git a/src/mint/taler-mint-httpd_db.c b/src/mint/taler-mint-httpd_db.c
index 43b226e6..039e74ff 100644
--- a/src/mint/taler-mint-httpd_db.c
+++ b/src/mint/taler-mint-httpd_db.c
@@ -130,7 +130,7 @@ TALER_MINT_db_execute_deposit (struct MHD_Connection *connection,
   }
   mks = TALER_MINT_key_state_acquire ();
   dki = TALER_MINT_get_denom_key (mks,
-                                  deposit->coin.denom_pub);
+                                  &deposit->coin.denom_pub);
   TALER_amount_ntoh (&value,
                      &dki->issue.value);
   TALER_MINT_key_state_release (mks);
@@ -211,7 +211,7 @@ TALER_MINT_db_execute_deposit (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_db_execute_withdraw_status (struct MHD_Connection *connection,
-                                       const struct GNUNET_CRYPTO_EddsaPublicKey *reserve_pub)
+                                       const struct TALER_ReservePublicKey *reserve_pub)
 {
   struct TALER_MINTDB_Session *session;
   struct ReserveHistory *rh;
@@ -255,11 +255,11 @@ TALER_MINT_db_execute_withdraw_status (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_db_execute_withdraw_sign (struct MHD_Connection *connection,
-                                     const struct GNUNET_CRYPTO_EddsaPublicKey *reserve,
-                                     const struct GNUNET_CRYPTO_rsa_PublicKey *denomination_pub,
+                                     const struct TALER_ReservePublicKey *reserve,
+                                     const struct TALER_DenominationPublicKey *denomination_pub,
                                      const char *blinded_msg,
                                      size_t blinded_msg_len,
-                                     const struct GNUNET_CRYPTO_EddsaSignature *signature)
+                                     const struct TALER_ReserveSignature *signature)
 {
   struct TALER_MINTDB_Session *session;
   struct ReserveHistory *rh;
@@ -303,8 +303,8 @@ TALER_MINT_db_execute_withdraw_sign (struct MHD_Connection *connection,
   {
     res = TALER_MINT_reply_withdraw_sign_success (connection,
                                                   &collectable);
-    GNUNET_CRYPTO_rsa_signature_free (collectable.sig);
-    GNUNET_CRYPTO_rsa_public_key_free (collectable.denom_pub);
+    GNUNET_CRYPTO_rsa_signature_free (collectable.sig.rsa_signature);
+    GNUNET_CRYPTO_rsa_public_key_free (collectable.denom_pub.rsa_public_key);
     return res;
   }
   GNUNET_assert (GNUNET_NO == res);
@@ -387,7 +387,7 @@ TALER_MINT_db_execute_withdraw_sign (struct MHD_Connection *connection,
       break;
     case TALER_MINT_DB_RO_WITHDRAW_COIN:
       tdki = TALER_MINT_get_denom_key (key_state,
-                                       pos->details.withdraw->denom_pub);
+                                       &pos->details.withdraw->denom_pub);
       TALER_amount_ntoh (&value,
                          &tdki->issue.value);
       if (0 == (res & 2))
@@ -428,7 +428,7 @@ TALER_MINT_db_execute_withdraw_sign (struct MHD_Connection *connection,
                                 rh);
 
   /* Balance is good, sign the coin! */
-  sig = GNUNET_CRYPTO_rsa_sign (dki->denom_priv,
+  sig = GNUNET_CRYPTO_rsa_sign (dki->denom_priv.rsa_private_key,
                                 blinded_msg,
                                 blinded_msg_len);
   TALER_MINT_key_state_release (key_state);
@@ -440,8 +440,9 @@ TALER_MINT_db_execute_withdraw_sign (struct MHD_Connection *connection,
     return TALER_MINT_reply_internal_error (connection,
                                             "Internal error");
   }
-  collectable.sig = sig;
-  collectable.denom_pub = (struct GNUNET_CRYPTO_rsa_PublicKey *) denomination_pub;
+  /* FIXME: this signature is still blinded, bad name... */
+  collectable.sig.rsa_signature = sig;
+  collectable.denom_pub = *denomination_pub;
   collectable.reserve_pub = *reserve;
   GNUNET_CRYPTO_hash (blinded_msg,
                       blinded_msg_len,
@@ -494,7 +495,7 @@ refresh_accept_melts (struct MHD_Connection *connection,
                       struct TALER_MINTDB_Session *session,
                       const struct MintKeyState *key_state,
                       const struct GNUNET_HashCode *melt_hash,
-                      const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
+                      const struct TALER_SessionPublicKey *session_pub,
                       const struct TALER_CoinPublicInfo *coin_public_info,
                       const struct MeltDetails *coin_details,
                       uint16_t oldcoin_index)
@@ -508,7 +509,7 @@ refresh_accept_melts (struct MHD_Connection *connection,
   int res;
 
   dki = &TALER_MINT_get_denom_key (key_state,
-                                   coin_public_info->denom_pub)->issue;
+                                   &coin_public_info->denom_pub)->issue;
 
   if (NULL == dki)
     return (MHD_YES ==
@@ -607,10 +608,10 @@ refresh_accept_melts (struct MHD_Connection *connection,
 int
 TALER_MINT_db_execute_refresh_melt (struct MHD_Connection *connection,
                                     const struct GNUNET_HashCode *melt_hash,
-                                    const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
-                                    const struct GNUNET_CRYPTO_EddsaSignature *client_signature,
+                                    const struct TALER_SessionPublicKey *refresh_session_pub,
+                                    const struct TALER_SessionSignature *client_signature,
                                     unsigned int num_new_denoms,
-                                    struct GNUNET_CRYPTO_rsa_PublicKey *const*denom_pubs,
+                                    const struct TALER_DenominationPublicKey *denom_pubs,
                                     unsigned int coin_count,
                                     const struct TALER_CoinPublicInfo *coin_public_infos,
                                     const struct MeltDetails *coin_melt_details,
@@ -773,7 +774,7 @@ TALER_MINT_db_execute_refresh_melt (struct MHD_Connection *connection,
  * @param transfer_privs private transfer keys
  * @param melts array of melted coins
  * @param num_newcoins number of newcoins being generated
- * @param denom_pub array of @a num_newcoins keys for the new coins
+ * @param denom_pubs array of @a num_newcoins keys for the new coins
  * @return #GNUNET_OK if the committment was honest,
  *         #GNUNET_NO if there was a problem and we generated an error message
  *         #GNUNET_SYSERR if we could not even generate an error message
@@ -781,13 +782,13 @@ TALER_MINT_db_execute_refresh_melt (struct MHD_Connection *connection,
 static int
 check_commitment (struct MHD_Connection *connection,
                   struct TALER_MINTDB_Session *session,
-                  const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session,
+                  const struct TALER_SessionPublicKey *refresh_session,
                   unsigned int off,
                   unsigned int num_oldcoins,
-                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *transfer_privs,
+                  const struct TALER_TransferPrivateKey *transfer_privs,
                   const struct RefreshMelt *melts,
                   unsigned int num_newcoins,
-                  struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs)
+                  const struct TALER_DenominationPublicKey *denom_pubs)
 {
   unsigned int j;
   struct TALER_LinkSecret last_shared_secret;
@@ -817,14 +818,14 @@ check_commitment (struct MHD_Connection *connection,
   {
     struct TALER_TransferSecret transfer_secret;
     struct TALER_LinkSecret shared_secret;
-    struct GNUNET_CRYPTO_EcdsaPublicKey transfer_pub_check;
+    struct TALER_TransferPublicKey transfer_pub_check;
 
-    GNUNET_CRYPTO_ecdsa_key_get_public (&transfer_privs[j],
-                                        &transfer_pub_check);
+    GNUNET_CRYPTO_ecdsa_key_get_public (&transfer_privs[j].ecdsa_priv,
+                                        &transfer_pub_check.ecdsa_pub);
     if (0 !=
         memcmp (&transfer_pub_check,
                 &commit_links[j].transfer_pub,
-                sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
+                sizeof (struct TALER_TransferPublicKey)))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   "transfer keys do not match\n");
@@ -840,9 +841,9 @@ check_commitment (struct MHD_Connection *connection,
 
     /* We're converting key types here, which is not very nice
      * but necessary and harmless (keys will be thrown away later). */
-    GNUNET_CRYPTO_ecdsa_public_to_ecdhe (&melts[j].coin.coin_pub,
+    GNUNET_CRYPTO_ecdsa_public_to_ecdhe (&melts[j].coin.coin_pub.ecdsa_pub,
                                          &coin_ecdhe);
-    GNUNET_CRYPTO_ecdsa_private_to_ecdhe (&transfer_privs[j],
+    GNUNET_CRYPTO_ecdsa_private_to_ecdhe (&transfer_privs[j].ecdsa_priv,
                                           &transfer_ecdhe);
     if (GNUNET_OK !=
         GNUNET_CRYPTO_ecc_ecdh (&transfer_ecdhe,
@@ -915,7 +916,7 @@ check_commitment (struct MHD_Connection *connection,
   for (j = 0; j < num_newcoins; j++)
   {
     struct TALER_RefreshLinkDecrypted *link_data;
-    struct GNUNET_CRYPTO_EcdsaPublicKey coin_pub;
+    struct TALER_CoinSpendPublicKey coin_pub;
     struct GNUNET_HashCode h_msg;
     char *buf;
     size_t buf_len;
@@ -931,15 +932,15 @@ check_commitment (struct MHD_Connection *connection,
         ? GNUNET_NO : GNUNET_SYSERR;
     }
 
-    GNUNET_CRYPTO_ecdsa_key_get_public (&link_data->coin_priv,
-                                        &coin_pub);
+    GNUNET_CRYPTO_ecdsa_key_get_public (&link_data->coin_priv.ecdsa_priv,
+                                        &coin_pub.ecdsa_pub);
     GNUNET_CRYPTO_hash (&coin_pub,
-                        sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey),
+                        sizeof (struct TALER_CoinSpendPublicKey),
                         &h_msg);
     if (0 == (buf_len =
               GNUNET_CRYPTO_rsa_blind (&h_msg,
-                                       link_data->blinding_key,
-                                       denom_pubs[j],
+                                       link_data->blinding_key.rsa_blinding_key,
+                                       denom_pubs[j].rsa_public_key,
                                        &buf)))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -989,42 +990,45 @@ check_commitment (struct MHD_Connection *connection,
  * @param coin_off number of the coin
  * @return NULL on error, otherwise signature over the coin
  */
-static struct GNUNET_CRYPTO_rsa_Signature *
+static struct TALER_DenominationSignature
 refresh_mint_coin (struct MHD_Connection *connection,
                    struct TALER_MINTDB_Session *session,
-                   const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session,
+                   const struct TALER_SessionPublicKey *refresh_session,
                    struct MintKeyState *key_state,
-                   const struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub,
+                   const struct TALER_DenominationPublicKey *denom_pub,
                    const struct RefreshCommitCoin *commit_coin,
                    unsigned int coin_off)
 {
   struct TALER_MINT_DenomKeyIssuePriv *dki;
-  struct GNUNET_CRYPTO_rsa_Signature *ev_sig;
+  struct TALER_DenominationSignature ev_sig;
 
-  dki = TALER_MINT_get_denom_key (key_state, denom_pub);
+  dki = TALER_MINT_get_denom_key (key_state,
+                                  denom_pub);
   if (NULL == dki)
   {
     GNUNET_break (0);
-    return NULL;
+    ev_sig.rsa_signature = NULL;
+    return ev_sig;
   }
-  ev_sig = GNUNET_CRYPTO_rsa_sign (dki->denom_priv,
-                                   commit_coin->coin_ev,
-                                   commit_coin->coin_ev_size);
-  if (NULL == ev_sig)
+  ev_sig.rsa_signature
+    = GNUNET_CRYPTO_rsa_sign (dki->denom_priv.rsa_private_key,
+                              commit_coin->coin_ev,
+                              commit_coin->coin_ev_size);
+  if (NULL == ev_sig.rsa_signature)
   {
     GNUNET_break (0);
-    return NULL;
+    return ev_sig;
   }
   if (GNUNET_OK !=
       plugin->insert_refresh_collectable (plugin->cls,
                                           session,
                                           refresh_session,
                                           coin_off,
-                                          ev_sig))
+                                          &ev_sig))
   {
     GNUNET_break (0);
-    GNUNET_CRYPTO_rsa_signature_free (ev_sig);
-    return NULL;
+    GNUNET_CRYPTO_rsa_signature_free (ev_sig.rsa_signature);
+    ev_sig.rsa_signature = NULL;
   }
   return ev_sig;
 }
@@ -1046,18 +1050,18 @@ refresh_mint_coin (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
-                                      const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                                      const struct TALER_SessionPublicKey *refresh_session_pub,
                                       unsigned int kappa,
                                       unsigned int num_oldcoins,
-                                      struct GNUNET_CRYPTO_EcdsaPrivateKey *const*transfer_privs)
+                                      struct TALER_TransferPrivateKey **transfer_privs)
 {
   int res;
   struct TALER_MINTDB_Session *session;
   struct RefreshSession refresh_session;
   struct MintKeyState *key_state;
   struct RefreshMelt *melts;
-  struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs;
-  struct GNUNET_CRYPTO_rsa_Signature **ev_sigs;
+  struct TALER_DenominationPublicKey *denom_pubs;
+  struct TALER_DenominationSignature *ev_sigs;
   struct RefreshCommitCoin *commit_coins;
   unsigned int i;
   unsigned int j;
@@ -1102,7 +1106,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
     }
   }
   denom_pubs = GNUNET_malloc (refresh_session.num_newcoins *
-                              sizeof (struct GNUNET_CRYPTO_rsa_PublicKey *));
+                              sizeof (struct TALER_DenominationPublicKey));
   if (GNUNET_OK !=
       plugin->get_refresh_order (plugin->cls,
                                  session,
@@ -1135,7 +1139,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
                                  denom_pubs)))
     {
       for (j=0;j<refresh_session.num_newcoins;j++)
-        GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
+        GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j].rsa_public_key);
       GNUNET_free (denom_pubs);
       GNUNET_free (melts);
       return (GNUNET_NO == res) ? MHD_YES : MHD_NO;
@@ -1150,7 +1154,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
   {
     GNUNET_break (0);
     for (j=0;j<refresh_session.num_newcoins;j++)
-      GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
+      GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j].rsa_public_key);
     GNUNET_free (denom_pubs);
     return TALER_MINT_reply_internal_db_error (connection);
   }
@@ -1168,12 +1172,12 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
     GNUNET_break (0);
     GNUNET_free (commit_coins);
     for (j=0;j<refresh_session.num_newcoins;j++)
-      GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
+      GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j].rsa_public_key);
     GNUNET_free (denom_pubs);
     return TALER_MINT_reply_internal_db_error (connection);
   }
   ev_sigs = GNUNET_malloc (refresh_session.num_newcoins *
-                           sizeof (struct GNUNET_CRYPTO_rsa_Signature *));
+                           sizeof (struct TALER_DenominationSignature));
   key_state = TALER_MINT_key_state_acquire ();
   for (j=0;j<refresh_session.num_newcoins;j++)
   {
@@ -1181,17 +1185,17 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
                                     session,
                                     refresh_session_pub,
                                     key_state,
-                                    denom_pubs[j],
+                                    &denom_pubs[j],
                                     &commit_coins[j],
                                     j);
-    if (NULL == ev_sigs[j])
+    if (NULL == ev_sigs[j].rsa_signature)
     {
       TALER_MINT_key_state_release (key_state);
       for (i=0;i<j;i++)
-        GNUNET_CRYPTO_rsa_signature_free (ev_sigs[i]);
+        GNUNET_CRYPTO_rsa_signature_free (ev_sigs[i].rsa_signature);
       GNUNET_free (ev_sigs);
       for (j=0;j<refresh_session.num_newcoins;j++)
-        GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
+        GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j].rsa_public_key);
       GNUNET_free (denom_pubs);
       GNUNET_free (commit_coins);
       return TALER_MINT_reply_internal_db_error (connection);
@@ -1199,7 +1203,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
   }
   TALER_MINT_key_state_release (key_state);
   for (j=0;j<refresh_session.num_newcoins;j++)
-    GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
+    GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j].rsa_public_key);
   GNUNET_free (denom_pubs);
   GNUNET_free (commit_coins);
 
@@ -1209,7 +1213,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
   {
     LOG_WARNING ("/refresh/reveal transaction commit failed\n");
     for (i=0;i<refresh_session.num_newcoins;i++)
-      GNUNET_CRYPTO_rsa_signature_free (ev_sigs[i]);
+      GNUNET_CRYPTO_rsa_signature_free (ev_sigs[i].rsa_signature);
     GNUNET_free (ev_sigs);
     return TALER_MINT_reply_commit_error (connection);
   }
@@ -1218,7 +1222,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
                                                  refresh_session.num_newcoins,
                                                  ev_sigs);
   for (i=0;i<refresh_session.num_newcoins;i++)
-    GNUNET_CRYPTO_rsa_signature_free (ev_sigs[i]);
+    GNUNET_CRYPTO_rsa_signature_free (ev_sigs[i].rsa_signature);
   GNUNET_free (ev_sigs);
   return res;
 }
@@ -1235,11 +1239,11 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_db_execute_refresh_link (struct MHD_Connection *connection,
-                                    const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub)
+                                    const struct TALER_CoinSpendPublicKey *coin_pub)
 {
   int res;
   struct TALER_MINTDB_Session *session;
-  struct GNUNET_CRYPTO_EcdsaPublicKey transfer_pub;
+  struct TALER_TransferPublicKey transfer_pub;
   struct TALER_EncryptedLinkSecret shared_secret_enc;
   struct LinkDataList *ldl;
 
diff --git a/src/mint/taler-mint-httpd_db.h b/src/mint/taler-mint-httpd_db.h
index 52e86f89..fd420bd9 100644
--- a/src/mint/taler-mint-httpd_db.h
+++ b/src/mint/taler-mint-httpd_db.h
@@ -53,7 +53,7 @@ TALER_MINT_db_execute_deposit (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_db_execute_withdraw_status (struct MHD_Connection *connection,
-                                       const struct GNUNET_CRYPTO_EddsaPublicKey *reserve_pub);
+                                       const struct TALER_ReservePublicKey *reserve_pub);
 
 
 /**
@@ -72,11 +72,11 @@ TALER_MINT_db_execute_withdraw_status (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_db_execute_withdraw_sign (struct MHD_Connection *connection,
-                                     const struct GNUNET_CRYPTO_EddsaPublicKey *reserve,
-                                     const struct GNUNET_CRYPTO_rsa_PublicKey *denomination_pub,
+                                     const struct TALER_ReservePublicKey *reserve,
+                                     const struct TALER_DenominationPublicKey *denomination_pub,
                                      const char *blinded_msg,
                                      size_t blinded_msg_len,
-                                     const struct GNUNET_CRYPTO_EddsaSignature *signature);
+                                     const struct TALER_ReserveSignature *signature);
 
 
 /**
@@ -88,7 +88,7 @@ struct MeltDetails
    * Signature allowing the melt (using
    * a `struct RefreshMeltConfirmSignRequestBody`) to sign over.
    */
-  struct GNUNET_CRYPTO_EcdsaSignature melt_sig;
+  struct TALER_CoinSpendSignature melt_sig;
 
   /**
    * How much of the coin's value did the client allow to be melted?
@@ -129,10 +129,10 @@ struct MeltDetails
 int
 TALER_MINT_db_execute_refresh_melt (struct MHD_Connection *connection,
                                     const struct GNUNET_HashCode *melt_hash,
-                                    const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
-                                    const struct GNUNET_CRYPTO_EddsaSignature *client_signature,
+                                    const struct TALER_SessionPublicKey *refresh_session_pub,
+                                    const struct TALER_SessionSignature *client_signature,
                                     unsigned int num_new_denoms,
-                                    struct GNUNET_CRYPTO_rsa_PublicKey *const*denom_pubs,
+                                    const struct TALER_DenominationPublicKey *denom_pubs,
                                     unsigned int coin_count,
                                     const struct TALER_CoinPublicInfo *coin_public_infos,
                                     const struct MeltDetails *coin_melt_details,
@@ -157,10 +157,10 @@ TALER_MINT_db_execute_refresh_melt (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
-                                      const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                                      const struct TALER_SessionPublicKey *refresh_session_pub,
                                       unsigned int kappa,
                                       unsigned int num_oldcoins,
-                                      struct GNUNET_CRYPTO_EcdsaPrivateKey *const*transfer_privs);
+                                      struct TALER_TransferPrivateKey **transfer_privs);
 
 
 /**
@@ -174,7 +174,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_db_execute_refresh_link (struct MHD_Connection *connection,
-                                    const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub);
+                                    const struct TALER_CoinSpendPublicKey *coin_pub);
 
 
 #endif
diff --git a/src/mint/taler-mint-httpd_deposit.c b/src/mint/taler-mint-httpd_deposit.c
index 810d1c32..bf812103 100644
--- a/src/mint/taler-mint-httpd_deposit.c
+++ b/src/mint/taler-mint-httpd_deposit.c
@@ -72,8 +72,8 @@ verify_and_execute_deposit (struct MHD_Connection *connection,
   if (GNUNET_OK !=
       GNUNET_CRYPTO_ecdsa_verify (TALER_SIGNATURE_WALLET_DEPOSIT,
                                   &dr.purpose,
-                                  &deposit->csig,
-                                  &deposit->coin.coin_pub))
+                                  &deposit->csig.ecdsa_signature,
+                                  &deposit->coin.coin_pub.ecdsa_pub))
   {
     LOG_WARNING ("Invalid signature on /deposit request\n");
     return TALER_MINT_reply_arg_invalid (connection,
@@ -82,7 +82,7 @@ verify_and_execute_deposit (struct MHD_Connection *connection,
   /* check denomination exists and is valid */
   key_state = TALER_MINT_key_state_acquire ();
   dki = TALER_MINT_get_denom_key (key_state,
-                                  deposit->coin.denom_pub);
+                                  &deposit->coin.denom_pub);
   if (NULL == dki)
   {
     TALER_MINT_key_state_release (key_state);
diff --git a/src/mint/taler-mint-httpd_keystate.c b/src/mint/taler-mint-httpd_keystate.c
index ca802e2d..b795323e 100644
--- a/src/mint/taler-mint-httpd_keystate.c
+++ b/src/mint/taler-mint-httpd_keystate.c
@@ -111,7 +111,7 @@ static int reload_pipe[2];
  * @return a JSON object describing the denomination key isue (public part)
  */
 static json_t *
-denom_key_issue_to_json (struct GNUNET_CRYPTO_rsa_PublicKey *pk,
+denom_key_issue_to_json (const struct TALER_DenominationPublicKey *pk,
                          const struct TALER_MINT_DenomKeyIssue *dki)
 {
   struct TALER_Amount value;
@@ -139,7 +139,7 @@ denom_key_issue_to_json (struct GNUNET_CRYPTO_rsa_PublicKey *pk,
                "stamp_expire_deposit",
                TALER_JSON_from_abs (GNUNET_TIME_absolute_ntoh (dki->expire_spend)),
                "denom_pub",
-               TALER_JSON_from_rsa_public_key (pk),
+               TALER_JSON_from_rsa_public_key (pk->rsa_public_key),
                "value",
                TALER_JSON_from_amount (&value),
                "fee_withdraw",
@@ -217,7 +217,7 @@ reload_keys_denom_iter (void *cls,
     return GNUNET_OK;
   }
 
-  GNUNET_CRYPTO_rsa_public_key_hash (dki->denom_pub,
+  GNUNET_CRYPTO_rsa_public_key_hash (dki->denom_pub.rsa_public_key,
                                      &denom_key_hash);
   d2 = GNUNET_memdup (dki,
                       sizeof (struct TALER_MINT_DenomKeyIssuePriv));
@@ -234,7 +234,7 @@ reload_keys_denom_iter (void *cls,
     return GNUNET_OK;
   }
   json_array_append_new (ctx->denom_keys_array,
-                         denom_key_issue_to_json (dki->denom_pub,
+                         denom_key_issue_to_json (&dki->denom_pub,
                                                   &dki->issue));
   return GNUNET_OK;
 }
@@ -435,11 +435,11 @@ TALER_MINT_key_state_acquire (void)
  */
 struct TALER_MINT_DenomKeyIssuePriv *
 TALER_MINT_get_denom_key (const struct MintKeyState *key_state,
-                          const struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub)
+                          const struct TALER_DenominationPublicKey *denom_pub)
 {
   struct GNUNET_HashCode hc;
 
-  GNUNET_CRYPTO_rsa_public_key_hash (denom_pub,
+  GNUNET_CRYPTO_rsa_public_key_hash (denom_pub->rsa_public_key,
                                      &hc);
   return GNUNET_CONTAINER_multihashmap_get (key_state->denomkey_map,
                                             &hc);
@@ -564,16 +564,16 @@ read_again:
  */
 void
 TALER_MINT_keys_sign (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
-                      struct GNUNET_CRYPTO_EddsaSignature *sig)
+                      struct TALER_MintSignature *sig)
 
 {
   struct MintKeyState *key_state;
 
   key_state = TALER_MINT_key_state_acquire ();
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CRYPTO_eddsa_sign (&key_state->current_sign_key_issue.signkey_priv,
+                 GNUNET_CRYPTO_eddsa_sign (&key_state->current_sign_key_issue.signkey_priv.eddsa_priv,
                                            purpose,
-                                           sig));
+                                           &sig->eddsa_signature));
   TALER_MINT_key_state_release (key_state);
 }
 
diff --git a/src/mint/taler-mint-httpd_keystate.h b/src/mint/taler-mint-httpd_keystate.h
index 4bb468ea..faccc8f0 100644
--- a/src/mint/taler-mint-httpd_keystate.h
+++ b/src/mint/taler-mint-httpd_keystate.h
@@ -67,7 +67,7 @@ TALER_MINT_key_state_release (struct MintKeyState *key_state);
  */
 struct TALER_MINT_DenomKeyIssuePriv *
 TALER_MINT_get_denom_key (const struct MintKeyState *key_state,
-                          const struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub);
+                          const struct TALER_DenominationPublicKey *denom_pub);
 
 
 /**
@@ -90,7 +90,7 @@ TALER_MINT_key_reload_loop (void);
  */
 void
 TALER_MINT_keys_sign (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
-                      struct GNUNET_CRYPTO_EddsaSignature *sig);
+                      struct TALER_MintSignature *sig);
 
 
 /**
diff --git a/src/mint/taler-mint-httpd_refresh.c b/src/mint/taler-mint-httpd_refresh.c
index d6bf3c42..8a024dff 100644
--- a/src/mint/taler-mint-httpd_refresh.c
+++ b/src/mint/taler-mint-httpd_refresh.c
@@ -58,14 +58,14 @@
  */
 static int
 handle_refresh_melt_binary (struct MHD_Connection *connection,
-                            const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                            const struct TALER_SessionPublicKey *refresh_session_pub,
                             unsigned int num_new_denoms,
-                            struct GNUNET_CRYPTO_rsa_PublicKey *const*denom_pubs,
+                            const struct TALER_DenominationPublicKey *denom_pubs,
                             unsigned int coin_count,
                             struct TALER_CoinPublicInfo *coin_public_infos,
                             const struct MeltDetails *coin_melt_details,
                             const struct GNUNET_HashCode *commit_hash,
-                            const struct GNUNET_CRYPTO_EddsaSignature *commit_client_sig,
+                            const struct TALER_SessionSignature *commit_client_sig,
                             unsigned int kappa,
                             struct RefreshCommitCoin *const* commit_coin,
                             struct RefreshCommitLink *const* commit_link)
@@ -92,7 +92,7 @@ handle_refresh_melt_binary (struct MHD_Connection *connection,
   /* FIXME: also hash session public key here!? #3708 */
   for (i = 0; i < num_new_denoms; i++)
   {
-    buf_size = GNUNET_CRYPTO_rsa_public_key_encode (denom_pubs[i],
+    buf_size = GNUNET_CRYPTO_rsa_public_key_encode (denom_pubs[i].rsa_public_key,
                                                     &buf);
     GNUNET_CRYPTO_hash_context_read (hash_context,
                                      buf,
@@ -113,10 +113,11 @@ handle_refresh_melt_binary (struct MHD_Connection *connection,
   TALER_amount_hton (&body.amount_with_fee,
                      &coin_melt_details->melt_amount_with_fee);
 
-  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_REFRESH_MELT_SESSION,
-                                               &body.purpose,
-                                               commit_client_sig,
-                                               refresh_session_pub))
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_REFRESH_MELT_SESSION,
+                                  &body.purpose,
+                                  &commit_client_sig->eddsa_signature,
+                                  &refresh_session_pub->eddsa_pub))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "signature invalid (did not verify)\n");
@@ -133,7 +134,7 @@ handle_refresh_melt_binary (struct MHD_Connection *connection,
   for (i=0;i<num_new_denoms;i++)
   {
     dki = &TALER_MINT_get_denom_key (key_state,
-                                     denom_pubs[i])->issue;
+                                     &denom_pubs[i])->issue;
     TALER_amount_ntoh (&value,
                        &dki->value);
     TALER_amount_ntoh (&fee_withdraw,
@@ -161,7 +162,7 @@ handle_refresh_melt_binary (struct MHD_Connection *connection,
     /* calculate contribution of the i-th melt by subtracting
        the fee; add the rest to the total_melt value */
     dki = &TALER_MINT_get_denom_key (key_state,
-                                     coin_public_infos[i].denom_pub)->issue;
+                                     &coin_public_infos[i].denom_pub)->issue;
     TALER_amount_ntoh (&fee_melt,
                        &dki->fee_refresh);
     if (GNUNET_OK !=
@@ -228,14 +229,14 @@ get_coin_public_info (struct MHD_Connection *connection,
                       struct MeltDetails *r_melt_detail)
 {
   int ret;
-  struct GNUNET_CRYPTO_EcdsaSignature melt_sig;
-  struct GNUNET_CRYPTO_rsa_Signature *sig;
-  struct GNUNET_CRYPTO_rsa_PublicKey *pk;
+  struct TALER_CoinSpendSignature melt_sig;
+  struct TALER_DenominationSignature sig;
+  struct TALER_DenominationPublicKey pk;
   struct TALER_Amount amount;
   struct GNUNET_MINT_ParseFieldSpec spec[] = {
     TALER_MINT_PARSE_FIXED ("coin_pub", &r_public_info->coin_pub),
-    TALER_MINT_PARSE_RSA_SIGNATURE ("denom_sig", &sig),
-    TALER_MINT_PARSE_RSA_PUBLIC_KEY ("denom_pub", &pk),
+    TALER_MINT_PARSE_RSA_SIGNATURE ("denom_sig", &sig.rsa_signature),
+    TALER_MINT_PARSE_RSA_PUBLIC_KEY ("denom_pub", &pk.rsa_public_key),
     TALER_MINT_PARSE_FIXED ("confirm_sig", &melt_sig),
     TALER_MINT_PARSE_AMOUNT ("value_with_fee", &amount),
     TALER_MINT_PARSE_END
@@ -253,8 +254,8 @@ get_coin_public_info (struct MHD_Connection *connection,
       TALER_test_coin_valid (r_public_info))
   {
     TALER_MINT_release_parsed_data (spec);
-    r_public_info->denom_sig = NULL;
-    r_public_info->denom_pub = NULL;
+    r_public_info->denom_sig.rsa_signature = NULL;
+    r_public_info->denom_pub.rsa_public_key = NULL;
     return (MHD_YES ==
             TALER_MINT_reply_json_pack (connection,
                                         MHD_HTTP_NOT_FOUND,
@@ -304,8 +305,8 @@ verify_coin_public_info (struct MHD_Connection *connection,
   if (GNUNET_OK !=
       GNUNET_CRYPTO_ecdsa_verify (TALER_SIGNATURE_REFRESH_MELT_COIN,
                                   &body.purpose,
-                                  &r_melt_detail->melt_sig,
-                                  &r_public_info->coin_pub))
+                                  &r_melt_detail->melt_sig.ecdsa_signature,
+                                  &r_public_info->coin_pub.ecdsa_pub))
   {
     if (MHD_YES !=
         TALER_MINT_reply_json_pack (connection,
@@ -317,7 +318,7 @@ verify_coin_public_info (struct MHD_Connection *connection,
   }
   key_state = TALER_MINT_key_state_acquire ();
   dki = TALER_MINT_get_denom_key (key_state,
-                                  r_public_info->denom_pub);
+                                  &r_public_info->denom_pub);
   if (NULL == dki)
   {
     TALER_MINT_key_state_release (key_state);
@@ -420,7 +421,7 @@ free_commit_links (struct RefreshCommitLink **commit_link,
  */
 static int
 handle_refresh_melt_json (struct MHD_Connection *connection,
-                          const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                          const struct TALER_SessionPublicKey *refresh_session_pub,
                           const json_t *new_denoms,
                           const json_t *melt_coins,
                           const json_t *melt_sig_json,
@@ -437,7 +438,7 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
   int res;
   unsigned int i;
   unsigned int j;
-  struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs;
+  struct TALER_DenominationPublicKey *denom_pubs;
   unsigned int num_new_denoms;
   struct TALER_CoinPublicInfo *coin_public_infos;
   struct MeltDetails *coin_melt_details;
@@ -446,20 +447,22 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
   struct GNUNET_HashContext *hash_context;
   struct RefreshCommitCoin *commit_coin[kappa];
   struct RefreshCommitLink *commit_link[kappa];
-  const struct GNUNET_CRYPTO_EddsaSignature commit_client_sig;
+  const struct TALER_SessionSignature commit_client_sig;
 
   num_new_denoms = json_array_size (new_denoms);
   denom_pubs = GNUNET_malloc (num_new_denoms *
-                              sizeof (struct GNUNET_CRYPTO_rsa_PublicKey *));
+                              sizeof (struct TALER_DenominationPublicKey));
   for (i=0;i<num_new_denoms;i++)
   {
-    res = GNUNET_MINT_parse_navigate_json (connection, new_denoms,
+    res = GNUNET_MINT_parse_navigate_json (connection,
+                                           new_denoms,
                                            JNAV_INDEX, (int) i,
-                                           JNAV_RET_RSA_PUBLIC_KEY, &denom_pubs[i]);
+                                           JNAV_RET_RSA_PUBLIC_KEY,
+                                           &denom_pubs[i].rsa_public_key);
     if (GNUNET_OK != res)
     {
       for (j=0;j<i;j++)
-        GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
+        GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j].rsa_public_key);
       GNUNET_free (denom_pubs);
       return res;
     }
@@ -483,12 +486,12 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
     {
       for (j=0;j<i;j++)
       {
-        GNUNET_CRYPTO_rsa_public_key_free (coin_public_infos[j].denom_pub);
-        GNUNET_CRYPTO_rsa_signature_free (coin_public_infos[j].denom_sig);
+        GNUNET_CRYPTO_rsa_public_key_free (coin_public_infos[j].denom_pub.rsa_public_key);
+        GNUNET_CRYPTO_rsa_signature_free (coin_public_infos[j].denom_sig.rsa_signature);
       }
       GNUNET_free (coin_public_infos);
       for (j=0;j<num_new_denoms;j++)
-        GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
+        GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j].rsa_public_key);
       GNUNET_free (coin_melt_details);
       GNUNET_free (denom_pubs);
       return (GNUNET_NO == res) ? MHD_YES : MHD_NO;
@@ -499,16 +502,16 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
     {
       if (0 == memcmp (&coin_public_infos[i].coin_pub,
                        &coin_public_infos[j].coin_pub,
-                       sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
+                       sizeof (struct TALER_CoinSpendPublicKey)))
       {
         for (j=0;j<i;j++)
         {
-          GNUNET_CRYPTO_rsa_public_key_free (coin_public_infos[j].denom_pub);
-          GNUNET_CRYPTO_rsa_signature_free (coin_public_infos[j].denom_sig);
+          GNUNET_CRYPTO_rsa_public_key_free (coin_public_infos[j].denom_pub.rsa_public_key);
+          GNUNET_CRYPTO_rsa_signature_free (coin_public_infos[j].denom_sig.rsa_signature);
         }
         GNUNET_free (coin_public_infos);
         for (j=0;j<num_new_denoms;j++)
-          GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
+          GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j].rsa_public_key);
         GNUNET_free (coin_melt_details);
         GNUNET_free (denom_pubs);
         return TALER_MINT_reply_external_error (connection,
@@ -583,7 +586,7 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
                                              JNAV_INDEX, (int) j,
                                              JNAV_RET_DATA,
                                              &commit_link[i][j].transfer_pub,
-                                             sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
+                                             sizeof (struct TALER_TransferPublicKey));
 
       if (GNUNET_OK != res)
       {
@@ -596,7 +599,7 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
 
       GNUNET_CRYPTO_hash_context_read (hash_context,
                                        &commit_link[i][j].transfer_pub,
-                                       sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
+                                       sizeof (struct TALER_TransferPublicKey));
 
       res = GNUNET_MINT_parse_navigate_json (connection,
                                              secret_encs,
@@ -629,7 +632,7 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
                                          "sig",
                                          JNAV_RET_DATA,
                                          &commit_client_sig,
-                                         sizeof (struct GNUNET_CRYPTO_EddsaSignature));
+                                         sizeof (struct TALER_SessionSignature));
 
   if (GNUNET_OK != res)
     return (GNUNET_NO == res) ? MHD_YES : MHD_NO;
@@ -667,14 +670,12 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
   free_commit_links (commit_link, kappa, num_oldcoins);
   for (j=0;j<coin_count;j++)
   {
-    GNUNET_CRYPTO_rsa_public_key_free (coin_public_infos[j].denom_pub);
-    GNUNET_CRYPTO_rsa_signature_free (coin_public_infos[j].denom_sig);
+    GNUNET_CRYPTO_rsa_public_key_free (coin_public_infos[j].denom_pub.rsa_public_key);
+    GNUNET_CRYPTO_rsa_signature_free (coin_public_infos[j].denom_sig.rsa_signature);
   }
   GNUNET_free (coin_public_infos);
   for (j=0;j<num_new_denoms;j++)
-  {
-    GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
-  }
+    GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j].rsa_public_key);
   GNUNET_free (coin_melt_details);
   GNUNET_free (denom_pubs);
   return res;
@@ -714,7 +715,7 @@ TALER_MINT_handler_refresh_melt (struct RequestHandler *rh,
   unsigned int num_oldcoins;
   unsigned int num_newcoins;
   json_t *coin_detail;
-  struct GNUNET_CRYPTO_EddsaPublicKey refresh_session_pub;
+  struct TALER_SessionPublicKey refresh_session_pub;
   int res;
   struct GNUNET_MINT_ParseFieldSpec spec[] = {
     TALER_MINT_PARSE_FIXED ("session_pub", &refresh_session_pub),
@@ -819,19 +820,19 @@ TALER_MINT_handler_refresh_melt (struct RequestHandler *rh,
   */
 static int
 handle_refresh_reveal_json (struct MHD_Connection *connection,
-                            const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                            const struct TALER_SessionPublicKey *refresh_session_pub,
                             unsigned int kappa,
                             unsigned int num_oldcoins,
                             const json_t *tp_json)
 {
-  struct GNUNET_CRYPTO_EcdsaPrivateKey *transfer_privs[kappa - 1];
+  struct TALER_TransferPrivateKey *transfer_privs[kappa - 1];
   unsigned int i;
   unsigned int j;
   int res;
 
   for (i = 0; i < kappa - 1; i++)
     transfer_privs[i] = GNUNET_malloc (num_oldcoins *
-                                       sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
+                                       sizeof (struct TALER_TransferPrivateKey));
   res = GNUNET_OK;
   for (i = 0; i < kappa - 1; i++)
   {
@@ -847,7 +848,7 @@ handle_refresh_reveal_json (struct MHD_Connection *connection,
                                              JNAV_INDEX, (int) j,
                                              JNAV_RET_DATA,
                                              &transfer_privs[i][j],
-                                             sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
+                                             sizeof (struct TALER_TransferPrivateKey));
     }
   }
   if (GNUNET_OK != res)
@@ -887,7 +888,7 @@ TALER_MINT_handler_refresh_reveal (struct RequestHandler *rh,
                                    const char *upload_data,
                                    size_t *upload_data_size)
 {
-  struct GNUNET_CRYPTO_EddsaPublicKey refresh_session_pub;
+  struct TALER_SessionPublicKey refresh_session_pub;
   int res;
   unsigned int kappa;
   unsigned int num_oldcoins;
@@ -966,13 +967,13 @@ TALER_MINT_handler_refresh_link (struct RequestHandler *rh,
                                  const char *upload_data,
                                  size_t *upload_data_size)
 {
-  struct GNUNET_CRYPTO_EcdsaPublicKey coin_pub;
+  struct TALER_CoinSpendPublicKey coin_pub;
   int res;
 
   res = TALER_MINT_mhd_request_arg_data (connection,
                                          "coin_pub",
                                          &coin_pub,
-                                         sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
+                                         sizeof (struct TALER_CoinSpendPublicKey));
   if (GNUNET_SYSERR == res)
     return MHD_NO;
   if (GNUNET_OK != res)
diff --git a/src/mint/taler-mint-httpd_responses.c b/src/mint/taler-mint-httpd_responses.c
index 681b2b92..4f124a15 100644
--- a/src/mint/taler-mint-httpd_responses.c
+++ b/src/mint/taler-mint-httpd_responses.c
@@ -282,15 +282,15 @@ TALER_MINT_reply_invalid_json (struct MHD_Connection *connection)
  */
 int
 TALER_MINT_reply_deposit_success (struct MHD_Connection *connection,
-                                  const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
+                                  const struct TALER_CoinSpendPublicKey *coin_pub,
                                   const struct GNUNET_HashCode *h_wire,
                                   const struct GNUNET_HashCode *h_contract,
                                   uint64_t transaction_id,
-                                  const struct GNUNET_CRYPTO_EddsaPublicKey *merchant,
+                                  const struct TALER_MerchantPublicKey *merchant,
                                   const struct TALER_Amount *amount)
 {
   struct TALER_DepositConfirmation dc;
-  struct GNUNET_CRYPTO_EddsaSignature sig;
+  struct TALER_MintSignature sig;
   json_t *sig_json;
   int ret;
 
@@ -305,7 +305,8 @@ TALER_MINT_reply_deposit_success (struct MHD_Connection *connection,
   dc.merchant = *merchant;
   TALER_MINT_keys_sign (&dc.purpose,
                         &sig);
-  sig_json = TALER_JSON_from_eddsa_sig (&dc.purpose, &sig);
+  sig_json = TALER_JSON_from_eddsa_sig (&dc.purpose,
+                                        &sig.eddsa_signature);
   ret = TALER_MINT_reply_json_pack (connection,
                                     MHD_HTTP_OK,
                                     "{s:s, s:o}",
@@ -351,7 +352,7 @@ compile_transaction_history (const struct TALER_MINT_DB_TransactionList *tl)
                            &deposit->amount_with_fee);
         dr.coin_pub = deposit->coin.coin_pub;
         transaction = TALER_JSON_from_ecdsa_sig (&dr.purpose,
-                                                 &deposit->csig);
+                                                 &deposit->csig.ecdsa_signature);
         break;
       }
     case TALER_MINT_DB_TT_REFRESH_MELT:
@@ -368,7 +369,7 @@ compile_transaction_history (const struct TALER_MINT_DB_TransactionList *tl)
                            &melt->amount_with_fee);
         ms.coin_pub = melt->coin.coin_pub;
         transaction = TALER_JSON_from_ecdsa_sig (&ms.purpose,
-                                                 &melt->coin_sig);
+                                                 &melt->coin_sig.ecdsa_signature);
       }
       break;
     case TALER_MINT_DB_TT_LOCK:
@@ -480,7 +481,7 @@ compile_reserve_history (const struct ReserveHistory *rh,
     case TALER_MINT_DB_RO_WITHDRAW_COIN:
 
       dki = TALER_MINT_get_denom_key (key_state,
-                                      pos->details.withdraw->denom_pub);
+                                      &pos->details.withdraw->denom_pub);
       TALER_amount_ntoh (&value,
                          &dki->issue.value);
       if (0 == ret)
@@ -499,12 +500,12 @@ compile_reserve_history (const struct ReserveHistory *rh,
       wr.purpose.purpose = htonl (TALER_SIGNATURE_WITHDRAW);
       wr.purpose.size = htonl (sizeof (struct TALER_WithdrawRequest));
       wr.reserve_pub = pos->details.withdraw->reserve_pub;
-      GNUNET_CRYPTO_rsa_public_key_hash (pos->details.withdraw->denom_pub,
+      GNUNET_CRYPTO_rsa_public_key_hash (pos->details.withdraw->denom_pub.rsa_public_key,
                                          &wr.h_denomination_pub);
       wr.h_coin_envelope = pos->details.withdraw->h_coin_envelope;
 
       transaction = TALER_JSON_from_eddsa_sig (&wr.purpose,
-                                               &pos->details.withdraw->reserve_sig);
+                                               &pos->details.withdraw->reserve_sig.eddsa_signature);
 
       json_array_append_new (json_history,
                              json_pack ("{s:s, s:o, s:o}",
@@ -613,7 +614,7 @@ TALER_MINT_reply_withdraw_sign_success (struct MHD_Connection *connection,
   json_t *sig_json;
   int ret;
 
-  sig_json = TALER_JSON_from_rsa_signature (collectable->sig);
+  sig_json = TALER_JSON_from_rsa_signature (collectable->sig.rsa_signature);
   ret = TALER_MINT_reply_json_pack (connection,
                                     MHD_HTTP_OK,
                                     "{s:o}",
@@ -640,7 +641,7 @@ TALER_MINT_reply_withdraw_sign_success (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_reply_refresh_melt_insufficient_funds (struct MHD_Connection *connection,
-                                                  const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
+                                                  const struct TALER_CoinSpendPublicKey *coin_pub,
                                                   struct TALER_Amount coin_value,
                                                   struct TALER_MINT_DB_TransactionList *tl,
                                                   struct TALER_Amount requested,
@@ -654,7 +655,7 @@ TALER_MINT_reply_refresh_melt_insufficient_funds (struct MHD_Connection *connect
                                      "{s:s, s:o, s:o, s:o, s:o, s:o}",
                                      "error", "insufficient funds",
                                      "coin-pub", TALER_JSON_from_data (coin_pub,
-                                                                       sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)),
+                                                                       sizeof (struct TALER_CoinSpendPublicKey)),
                                      "original-value", TALER_JSON_from_amount (&coin_value),
                                      "residual-value", TALER_JSON_from_amount (&residual),
                                      "requested-value", TALER_JSON_from_amount (&requested),
@@ -676,7 +677,7 @@ TALER_MINT_reply_refresh_melt_success (struct MHD_Connection *connection,
                                        uint16_t noreveal_index)
 {
   struct RefreshMeltResponseSignatureBody body;
-  struct GNUNET_CRYPTO_EddsaSignature sig;
+  struct TALER_MintSignature sig;
   json_t *sig_json;
   int ret;
 
@@ -687,7 +688,7 @@ TALER_MINT_reply_refresh_melt_success (struct MHD_Connection *connection,
   TALER_MINT_keys_sign (&body.purpose,
                         &sig);
   sig_json = TALER_JSON_from_eddsa_sig (&body.purpose,
-                                        &sig);
+                                        &sig.eddsa_signature);
   GNUNET_assert (NULL != sig_json);
   ret = TALER_MINT_reply_json_pack (connection,
                                      MHD_HTTP_OK,
@@ -710,7 +711,7 @@ TALER_MINT_reply_refresh_melt_success (struct MHD_Connection *connection,
 int
 TALER_MINT_reply_refresh_reveal_success (struct MHD_Connection *connection,
                                          unsigned int num_newcoins,
-                                         struct GNUNET_CRYPTO_rsa_Signature **sigs)
+                                         const struct TALER_DenominationSignature *sigs)
 {
   int newcoin_index;
   json_t *root;
@@ -724,7 +725,7 @@ TALER_MINT_reply_refresh_reveal_success (struct MHD_Connection *connection,
                        list);
   for (newcoin_index = 0; newcoin_index < num_newcoins; newcoin_index++)
     json_array_append_new (list,
-                           TALER_JSON_from_rsa_signature (sigs[newcoin_index]));
+                           TALER_JSON_from_rsa_signature (sigs[newcoin_index].rsa_signature));
   ret = TALER_MINT_reply_json (connection,
                                root,
                                MHD_HTTP_OK);
@@ -777,7 +778,7 @@ TALER_MINT_reply_refresh_reveal_missmatch (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_reply_refresh_link_success (struct MHD_Connection *connection,
-                                       const struct GNUNET_CRYPTO_EcdsaPublicKey *transfer_pub,
+                                       const struct TALER_TransferPublicKey *transfer_pub,
                                        const struct TALER_EncryptedLinkSecret *shared_secret_enc,
                                        const struct LinkDataList *ldl)
 {
@@ -794,14 +795,14 @@ TALER_MINT_reply_refresh_link_success (struct MHD_Connection *connection,
     obj = json_object ();
     json_object_set_new (obj, "link_enc",
                          TALER_JSON_from_data (ldl->link_data_enc->coin_priv_enc,
-                                               sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey) +
+                                               sizeof (struct TALER_CoinSpendPrivateKey) +
                                                ldl->link_data_enc->blinding_key_enc_size));
     json_object_set_new (obj,
                          "denom_pub",
-                         TALER_JSON_from_rsa_public_key (ldl->denom_pub));
+                         TALER_JSON_from_rsa_public_key (ldl->denom_pub.rsa_public_key));
     json_object_set_new (obj,
                          "ev_sig",
-                         TALER_JSON_from_rsa_signature (ldl->ev_sig));
+                         TALER_JSON_from_rsa_signature (ldl->ev_sig.rsa_signature));
     json_array_append_new (list, obj);
   }
 
@@ -812,7 +813,7 @@ TALER_MINT_reply_refresh_link_success (struct MHD_Connection *connection,
   json_object_set_new (root,
                        "transfer_pub",
                        TALER_JSON_from_data (transfer_pub,
-                                             sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)));
+                                             sizeof (struct TALER_TransferPublicKey)));
   json_object_set_new (root,
                        "secret_enc",
                        TALER_JSON_from_data (shared_secret_enc,
diff --git a/src/mint/taler-mint-httpd_responses.h b/src/mint/taler-mint-httpd_responses.h
index d42aa29b..d7e56350 100644
--- a/src/mint/taler-mint-httpd_responses.h
+++ b/src/mint/taler-mint-httpd_responses.h
@@ -185,11 +185,11 @@ TALER_MINT_reply_invalid_json (struct MHD_Connection *connection);
  */
 int
 TALER_MINT_reply_deposit_success (struct MHD_Connection *connection,
-                                  const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
+                                  const struct TALER_CoinSpendPublicKey *coin_pub,
                                   const struct GNUNET_HashCode *h_wire,
                                   const struct GNUNET_HashCode *h_contract,
                                   uint64_t transaction_id,
-                                  const struct GNUNET_CRYPTO_EddsaPublicKey *merchant,
+                                  const struct TALER_MerchantPublicKey *merchant,
                                   const struct TALER_Amount *amount);
 
 
@@ -276,7 +276,7 @@ TALER_MINT_reply_refresh_melt_success (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_reply_refresh_melt_insufficient_funds (struct MHD_Connection *connection,
-                                                  const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
+                                                  const struct TALER_CoinSpendPublicKey *coin_pub,
                                                   struct TALER_Amount coin_value,
                                                   struct TALER_MINT_DB_TransactionList *tl,
                                                   struct TALER_Amount requested,
@@ -294,7 +294,7 @@ TALER_MINT_reply_refresh_melt_insufficient_funds (struct MHD_Connection *connect
 int
 TALER_MINT_reply_refresh_reveal_success (struct MHD_Connection *connection,
                                          unsigned int num_newcoins,
-                                         struct GNUNET_CRYPTO_rsa_Signature **sigs);
+                                         const struct TALER_DenominationSignature *sigs);
 
 
 /**
@@ -332,7 +332,7 @@ TALER_MINT_reply_refresh_reveal_missmatch (struct MHD_Connection *connection,
  */
 int
 TALER_MINT_reply_refresh_link_success (struct MHD_Connection *connection,
-                                       const struct GNUNET_CRYPTO_EcdsaPublicKey *transfer_pub,
+                                       const struct TALER_TransferPublicKey *transfer_pub,
                                        const struct TALER_EncryptedLinkSecret *shared_secret_enc,
                                        const struct LinkDataList *ldl);
 
diff --git a/src/mint/taler-mint-httpd_withdraw.c b/src/mint/taler-mint-httpd_withdraw.c
index b796af94..7d7ca806 100644
--- a/src/mint/taler-mint-httpd_withdraw.c
+++ b/src/mint/taler-mint-httpd_withdraw.c
@@ -49,13 +49,13 @@ TALER_MINT_handler_withdraw_status (struct RequestHandler *rh,
                                     const char *upload_data,
                                     size_t *upload_data_size)
 {
-  struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
+  struct TALER_ReservePublicKey reserve_pub;
   int res;
 
   res = TALER_MINT_mhd_request_arg_data (connection,
                                          "reserve_pub",
                                          &reserve_pub,
-                                         sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+                                         sizeof (struct TALER_ReservePublicKey));
   if (GNUNET_SYSERR == res)
     return MHD_NO; /* internal error */
   if (GNUNET_NO == res)
@@ -90,17 +90,17 @@ TALER_MINT_handler_withdraw_sign (struct RequestHandler *rh,
 {
   struct TALER_WithdrawRequest wsrd;
   int res;
-  struct GNUNET_CRYPTO_rsa_PublicKey *denomination_pub;
+  struct TALER_DenominationPublicKey denomination_pub;
   char *denomination_pub_data;
   size_t denomination_pub_data_size;
   char *blinded_msg;
   size_t blinded_msg_len;
-  struct GNUNET_CRYPTO_EddsaSignature signature;
+  struct TALER_ReserveSignature signature;
 
   res = TALER_MINT_mhd_request_arg_data (connection,
                                          "reserve_pub",
                                          &wsrd.reserve_pub,
-                                         sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+                                         sizeof (struct TALER_ReservePublicKey));
   if (GNUNET_SYSERR == res)
     return MHD_NO; /* internal error */
   if (GNUNET_NO == res)
@@ -108,7 +108,7 @@ TALER_MINT_handler_withdraw_sign (struct RequestHandler *rh,
   res = TALER_MINT_mhd_request_arg_data (connection,
                                          "reserve_sig",
                                          &signature,
-                                         sizeof (struct GNUNET_CRYPTO_EddsaSignature));
+                                         sizeof (struct TALER_ReserveSignature));
   if (GNUNET_SYSERR == res)
     return MHD_NO; /* internal error */
   if (GNUNET_NO == res)
@@ -148,8 +148,8 @@ TALER_MINT_handler_withdraw_sign (struct RequestHandler *rh,
   if (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_WITHDRAW,
                                   &wsrd.purpose,
-                                  &signature,
-                                  &wsrd.reserve_pub))
+                                  &signature.eddsa_signature,
+                                  &wsrd.reserve_pub.eddsa_pub))
   {
     LOG_WARNING ("Client supplied invalid signature for /withdraw/sign request\n");
     GNUNET_free (denomination_pub_data);
@@ -157,10 +157,11 @@ TALER_MINT_handler_withdraw_sign (struct RequestHandler *rh,
     return TALER_MINT_reply_arg_invalid (connection,
                                          "reserve_sig");
   }
-  denomination_pub = GNUNET_CRYPTO_rsa_public_key_decode (denomination_pub_data,
-                                                          denomination_pub_data_size);
+  denomination_pub.rsa_public_key
+    = GNUNET_CRYPTO_rsa_public_key_decode (denomination_pub_data,
+                                           denomination_pub_data_size);
   GNUNET_free (denomination_pub_data);
-  if (NULL == denomination_pub)
+  if (NULL == denomination_pub.rsa_public_key)
   {
     LOG_WARNING ("Client supplied ill-formed denomination public key for /withdraw/sign request\n");
     GNUNET_free (blinded_msg);
@@ -169,12 +170,12 @@ TALER_MINT_handler_withdraw_sign (struct RequestHandler *rh,
   }
   res = TALER_MINT_db_execute_withdraw_sign (connection,
                                              &wsrd.reserve_pub,
-                                             denomination_pub,
+                                             &denomination_pub,
                                              blinded_msg,
                                              blinded_msg_len,
                                              &signature);
   GNUNET_free (blinded_msg);
-  GNUNET_CRYPTO_rsa_public_key_free (denomination_pub);
+  GNUNET_CRYPTO_rsa_public_key_free (denomination_pub.rsa_public_key);
   return res;
 }
 
diff --git a/src/mint/taler-mint-keycheck.c b/src/mint/taler-mint-keycheck.c
index cb46c14e..370b1c51 100644
--- a/src/mint/taler-mint-keycheck.c
+++ b/src/mint/taler-mint-keycheck.c
@@ -70,8 +70,8 @@ signkeys_iter (void *cls,
   if (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_MASTER_SIGNKEY,
                                   &ski->issue.purpose,
-                                  &ski->issue.signature,
-                                  &ski->issue.master_pub))
+                                  &ski->issue.signature.eddsa_signature,
+                                  &ski->issue.master_pub.eddsa_pub))
   {
     fprintf (stderr,
              "Signing key `%s' has invalid signature\n",
@@ -130,15 +130,15 @@ denomkeys_iter (void *cls,
   if (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_MASTER_DENOM,
                                   &dki->issue.purpose,
-                                  &dki->issue.signature,
-                                  &dki->issue.master))
+                                  &dki->issue.signature.eddsa_signature,
+                                  &dki->issue.master.eddsa_pub))
   {
     fprintf (stderr,
              "Denomination key for `%s' has invalid signature\n",
              alias);
     return GNUNET_SYSERR;
   }
-  GNUNET_CRYPTO_rsa_public_key_hash (dki->denom_pub,
+  GNUNET_CRYPTO_rsa_public_key_hash (dki->denom_pub.rsa_public_key,
                                      &hc);
   if (0 != memcmp (&hc,
                    &dki->issue.denom_hash,
diff --git a/src/mint/taler-mint-keyup.c b/src/mint/taler-mint-keyup.c
index 759e7c1b..019ae5b3 100644
--- a/src/mint/taler-mint-keyup.c
+++ b/src/mint/taler-mint-keyup.c
@@ -179,12 +179,12 @@ static struct GNUNET_TIME_Absolute now;
 /**
  * Master private key of the mint.
  */
-static struct GNUNET_CRYPTO_EddsaPrivateKey *master_priv;
+static struct TALER_MasterPrivateKey master_priv;
 
 /**
  * Master public key of the mint.
  */
-static struct GNUNET_CRYPTO_EddsaPublicKey *master_pub;
+static struct TALER_MasterPublicKey master_pub;
 
 /**
  * Until what time do we provide keys?
@@ -440,23 +440,23 @@ create_signkey_issue_priv (struct GNUNET_TIME_Absolute start,
   struct TALER_MINT_SignKeyIssue *issue = &pi->issue;
 
   priv = GNUNET_CRYPTO_eddsa_key_create ();
-  pi->signkey_priv = *priv;
+  pi->signkey_priv.eddsa_priv = *priv;
   GNUNET_free (priv);
-  issue->master_pub = *master_pub;
+  issue->master_pub = master_pub;
   issue->start = GNUNET_TIME_absolute_hton (start);
   issue->expire = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (start,
                                                                        duration));
-  GNUNET_CRYPTO_eddsa_key_get_public (&pi->signkey_priv,
-                                      &issue->signkey_pub);
+  GNUNET_CRYPTO_eddsa_key_get_public (&pi->signkey_priv.eddsa_priv,
+                                      &issue->signkey_pub.eddsa_pub);
   issue->purpose.purpose = htonl (TALER_SIGNATURE_MASTER_SIGNKEY);
   issue->purpose.size = htonl (sizeof (struct TALER_MINT_SignKeyIssue) -
                                offsetof (struct TALER_MINT_SignKeyIssue,
                                          purpose));
 
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CRYPTO_eddsa_sign (master_priv,
+                 GNUNET_CRYPTO_eddsa_sign (&master_priv.eddsa_priv,
                                            &issue->purpose,
-                                           &issue->signature));
+                                           &issue->signature.eddsa_signature));
 }
 
 
@@ -678,12 +678,14 @@ static void
 create_denomkey_issue (const struct CoinTypeParams *params,
                        struct TALER_MINT_DenomKeyIssuePriv *dki)
 {
-  GNUNET_assert (NULL !=
-                 (dki->denom_priv = GNUNET_CRYPTO_rsa_private_key_create (params->rsa_keysize)));
-  dki->denom_pub = GNUNET_CRYPTO_rsa_private_key_get_public (dki->denom_priv);
-  GNUNET_CRYPTO_rsa_public_key_hash (dki->denom_pub,
+  dki->denom_priv.rsa_private_key
+    = GNUNET_CRYPTO_rsa_private_key_create (params->rsa_keysize);
+  GNUNET_assert (NULL != dki->denom_priv.rsa_private_key);
+  dki->denom_pub.rsa_public_key
+    = GNUNET_CRYPTO_rsa_private_key_get_public (dki->denom_priv.rsa_private_key);
+  GNUNET_CRYPTO_rsa_public_key_hash (dki->denom_pub.rsa_public_key,
                                      &dki->issue.denom_hash);
-  dki->issue.master = *master_pub;
+  dki->issue.master = master_pub;
   dki->issue.start = GNUNET_TIME_absolute_hton (params->anchor);
   dki->issue.expire_withdraw =
       GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (params->anchor,
@@ -704,9 +706,9 @@ create_denomkey_issue (const struct CoinTypeParams *params,
                                    offsetof (struct TALER_MINT_DenomKeyIssuePriv,
                                              issue.purpose));
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CRYPTO_eddsa_sign (master_priv,
+                 GNUNET_CRYPTO_eddsa_sign (&master_priv.eddsa_priv,
                                            &dki->issue.purpose,
-                                           &dki->issue.signature));
+                                           &dki->issue.signature.eddsa_signature));
 }
 
 
@@ -764,10 +766,10 @@ mint_keys_update_cointype (void *cls,
                "Failed to write denomination key information to file `%s'.\n",
                dkf);
       *ret = GNUNET_SYSERR;
-      GNUNET_CRYPTO_rsa_private_key_free (denomkey_issue.denom_priv);
+      GNUNET_CRYPTO_rsa_private_key_free (denomkey_issue.denom_priv.rsa_private_key);
       return;
     }
-    GNUNET_CRYPTO_rsa_private_key_free (denomkey_issue.denom_priv);
+    GNUNET_CRYPTO_rsa_private_key_free (denomkey_issue.denom_priv.rsa_private_key);
     p.anchor = GNUNET_TIME_absolute_add (p.anchor,
                                          p.duration_spend);
     p.anchor = GNUNET_TIME_absolute_subtract (p.anchor,
@@ -825,6 +827,7 @@ main (int argc,
     GNUNET_GETOPT_OPTION_END
   };
   struct GNUNET_TIME_Relative lookahead_sign;
+  struct GNUNET_CRYPTO_EddsaPrivateKey *eddsa_priv;
 
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_log_setup ("taler-mint-keyup",
@@ -872,18 +875,18 @@ main (int argc,
              "Master key file not given\n");
     return 1;
   }
-  master_priv = GNUNET_CRYPTO_eddsa_key_create_from_file (masterkeyfile);
-  if (NULL == master_priv)
+  eddsa_priv = GNUNET_CRYPTO_eddsa_key_create_from_file (masterkeyfile);
+  if (NULL == eddsa_priv)
   {
     fprintf (stderr,
              "Failed to initialize master key from file `%s'\n",
              masterkeyfile);
     return 1;
   }
-
-  master_pub = GNUNET_new (struct GNUNET_CRYPTO_EddsaPublicKey);
-  GNUNET_CRYPTO_eddsa_key_get_public (master_priv,
-                                      master_pub);
+  master_priv.eddsa_priv = *eddsa_priv;
+  GNUNET_free (eddsa_priv);
+  GNUNET_CRYPTO_eddsa_key_get_public (&master_priv.eddsa_priv,
+                                      &master_pub.eddsa_pub);
 
   /* check if key from file matches the one from the configuration */
   {
@@ -902,7 +905,7 @@ main (int argc,
       return 1;
     }
     if (0 !=
-        memcmp (master_pub,
+        memcmp (&master_pub,
                 &master_pub_from_cfg,
                 sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)))
     {
diff --git a/src/mint/taler_mintdb_plugin.h b/src/mint/taler_mintdb_plugin.h
index 83e37334..22522881 100644
--- a/src/mint/taler_mintdb_plugin.h
+++ b/src/mint/taler_mintdb_plugin.h
@@ -35,7 +35,7 @@ struct BankTransfer
   /**
    * Public key of the reserve that was filled.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
+  struct TALER_ReservePublicKey reserve_pub;
 
   /**
    * Amount that was transferred to the mint.
@@ -58,7 +58,7 @@ struct Reserve
   /**
    * The reserve's public key.  This uniquely identifies the reserve
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey *pub;
+  struct TALER_ReservePublicKey pub;
 
   /**
    * The balance amount existing in the reserve
@@ -83,7 +83,7 @@ struct CollectableBlindcoin
   /**
    * Our signature over the (blinded) coin.
    */
-  struct GNUNET_CRYPTO_rsa_Signature *sig;
+  struct TALER_DenominationSignature sig;
 
   /**
    * Denomination key (which coin was generated).
@@ -91,12 +91,12 @@ struct CollectableBlindcoin
    * AMOUNT *including* fee in what is being signed
    * as well!
    */
-  struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub;
+  struct TALER_DenominationPublicKey denom_pub;
 
   /**
    * Public key of the reserve that was drained.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
+  struct TALER_ReservePublicKey reserve_pub;
 
   /**
    * Hash over the blinded message, needed to verify
@@ -108,7 +108,7 @@ struct CollectableBlindcoin
    * Signature confirming the withdrawl, matching @e reserve_pub,
    * @e denom_pub and @e h_coin_envelope.
    */
-  struct GNUNET_CRYPTO_EddsaSignature reserve_sig;
+  struct TALER_ReserveSignature reserve_sig;
 };
 
 
@@ -186,13 +186,13 @@ struct Deposit
    * by @e h_wire in relation to the contract identified
    * by @e h_contract.
    */
-  struct GNUNET_CRYPTO_EcdsaSignature csig;
+  struct TALER_CoinSpendSignature csig;
 
   /**
    * Public key of the merchant.  Enables later identification
    * of the merchant in case of a need to rollback transactions.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey merchant_pub;
+  struct TALER_MerchantPublicKey merchant_pub;
 
   /**
    * Hash over the contract between merchant and customer
@@ -238,8 +238,10 @@ struct RefreshSession
   /**
    * Signature over the commitments by the client,
    * only valid if @e has_commit_sig is set.
+   *
+   * FIXME: The above comment is clearly confused.
    */
-  struct GNUNET_CRYPTO_EddsaSignature commit_sig;
+  struct TALER_SessionSignature commit_sig;
 
   /**
    * Hash over coins to melt and coins to create of the
@@ -250,7 +252,7 @@ struct RefreshSession
   /**
    * Signature over the melt by the client.
    */
-  struct GNUNET_CRYPTO_EddsaSignature melt_sig;
+  struct TALER_SessionSignature melt_sig;
 
   /**
    * Number of coins we are melting.
@@ -291,7 +293,7 @@ struct RefreshMelt
   /**
    * Signature over the melting operation.
    */
-  struct GNUNET_CRYPTO_EcdsaSignature coin_sig;
+  struct TALER_CoinSpendSignature coin_sig;
 
   /**
    * Which melting operation should the coin become a part of.
@@ -350,7 +352,7 @@ struct RefreshCommitLink
   /**
    * Transfer public key (FIXME: explain!)
    */
-  struct GNUNET_CRYPTO_EcdsaPublicKey transfer_pub;
+  struct TALER_TransferPublicKey transfer_pub;
 
   /**
    * Encrypted shared secret to decrypt the link.
@@ -378,12 +380,12 @@ struct LinkDataList
   /**
    * Denomination public key, determines the value of the coin.
    */
-  struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub;
+  struct TALER_DenominationPublicKey denom_pub;
 
   /**
    * Signature over the blinded envelope.
    */
-  struct GNUNET_CRYPTO_rsa_Signature *ev_sig;
+  struct TALER_DenominationSignature ev_sig;
 };
 
 
@@ -393,14 +395,14 @@ struct LinkDataList
 struct Lock
 {
   /**
-   * Information about the coin that is being melted.
+   * Information about the coin that is being locked.
    */
   struct TALER_CoinPublicInfo coin;
 
   /**
-   * Signature over the melting operation.
+   * Signature over the locking operation.
    */
-  const struct GNUNET_CRYPTO_EcdsaSignature coin_sig;
+  struct TALER_CoinSpendSignature coin_sig;
 
   /**
    * How much value is being locked?
@@ -535,35 +537,35 @@ struct TALER_MINTDB_Plugin
    * Start a transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn connection to use
+   * @param sesssion connection to use
    * @return #GNUNET_OK on success
    */
   int
   (*start) (void *cls,
-            struct TALER_MINTDB_Session *db_conn);
+            struct TALER_MINTDB_Session *sesssion);
 
 
   /**
    * Commit a transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn connection to use
+   * @param sesssion connection to use
    * @return #GNUNET_OK on success
    */
   int
   (*commit) (void *cls,
-             struct TALER_MINTDB_Session *db_conn);
+             struct TALER_MINTDB_Session *sesssion);
 
 
   /**
    * Abort/rollback a transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn connection to use
+   * @param sesssion connection to use
    */
   void
   (*rollback) (void *cls,
-               struct TALER_MINTDB_Session *db_conn);
+               struct TALER_MINTDB_Session *sesssion);
 
 
   /**
@@ -611,7 +613,7 @@ struct TALER_MINTDB_Plugin
    * key of the hash of the blinded message.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection to use
+   * @param sesssion database connection to use
    * @param h_blind hash of the blinded message
    * @param collectable corresponding collectable coin (blind signature)
    *                    if a coin is found
@@ -621,7 +623,7 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*get_collectable_blindcoin) (void *cls,
-                                struct TALER_MINTDB_Session *db_conn,
+                                struct TALER_MINTDB_Session *sesssion,
                                 const struct GNUNET_HashCode *h_blind,
                                 struct CollectableBlindcoin *collectable);
 
@@ -631,7 +633,7 @@ struct TALER_MINTDB_Plugin
    * hash of the blinded message.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection to use
+   * @param sesssion database connection to use
    * @param h_blind hash of the blinded message
    * @param withdraw amount by which the reserve will be withdrawn with this
    *          transaction
@@ -643,7 +645,7 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*insert_collectable_blindcoin) (void *cls,
-                                   struct TALER_MINTDB_Session *db_conn,
+                                   struct TALER_MINTDB_Session *sesssion,
                                    const struct GNUNET_HashCode *h_blind,
                                    struct TALER_Amount withdraw,
                                    const struct CollectableBlindcoin *collectable);
@@ -654,14 +656,14 @@ struct TALER_MINTDB_Plugin
    * reserve.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn connection to use
+   * @param sesssion connection to use
    * @param reserve_pub public key of the reserve
    * @return known transaction history (NULL if reserve is unknown)
    */
   struct ReserveHistory *
   (*get_reserve_history) (void *cls,
-                          struct TALER_MINTDB_Session *db_conn,
-                          const struct GNUNET_CRYPTO_EddsaPublicKey *reserve_pub);
+                          struct TALER_MINTDB_Session *sesssion,
+                          const struct TALER_ReservePublicKey *reserve_pub);
 
 
   /**
@@ -679,7 +681,7 @@ struct TALER_MINTDB_Plugin
    * Check if we have the specified deposit already in the database.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param deposit deposit to search for
    * @return #GNUNET_YES if we know this operation,
    *         #GNUNET_NO if this deposit is unknown to us,
@@ -687,7 +689,7 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*have_deposit) (void *cls,
-                   struct TALER_MINTDB_Session *db_conn,
+                   struct TALER_MINTDB_Session *sesssion,
                    const struct Deposit *deposit);
 
 
@@ -696,13 +698,13 @@ struct TALER_MINTDB_Plugin
    * database.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn connection to the database
+   * @param sesssion connection to the database
    * @param deposit deposit information to store
    * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
    */
   int
   (*insert_deposit) (void *cls,
-                     struct TALER_MINTDB_Session *db_conn,
+                     struct TALER_MINTDB_Session *sesssion,
                      const struct Deposit *deposit);
 
 
@@ -710,7 +712,7 @@ struct TALER_MINTDB_Plugin
    * Lookup refresh session data under the given public key.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database handle to use
+   * @param sesssion database handle to use
    * @param refresh_session_pub public key to use for the lookup
    * @param refresh_session[OUT] where to store the result
    * @return #GNUNET_YES on success,
@@ -719,8 +721,8 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*get_refresh_session) (void *cls,
-                          struct TALER_MINTDB_Session *db_conn,
-                          const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                          struct TALER_MINTDB_Session *sesssion,
+                          const struct TALER_SessionPublicKey *refresh_session_pub,
                           struct RefreshSession *refresh_session);
 
 
@@ -728,7 +730,7 @@ struct TALER_MINTDB_Plugin
    * Store new refresh session data under the given public key.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database handle to use
+   * @param sesssion database handle to use
    * @param refresh_session_pub public key to use to locate the session
    * @param refresh_session session data to store
    * @return #GNUNET_YES on success,
@@ -736,8 +738,8 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*create_refresh_session) (void *cls,
-                             struct TALER_MINTDB_Session *db_conn,
-                             const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
+                             struct TALER_MINTDB_Session *sesssion,
+                             const struct TALER_SessionPublicKey *session_pub,
                              const struct RefreshSession *refresh_session);
 
 
@@ -746,7 +748,7 @@ struct TALER_MINTDB_Plugin
    * Store the given /refresh/melt request in the database.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param refresh_session session key of the melt operation
    * @param oldcoin_index index of the coin to store
    * @param melt coin melt operation details to store
@@ -755,8 +757,8 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*insert_refresh_melt) (void *cls,
-                          struct TALER_MINTDB_Session *db_conn,
-                          const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session,
+                          struct TALER_MINTDB_Session *sesssion,
+                          const struct TALER_SessionPublicKey *refresh_session,
                           uint16_t oldcoin_index,
                           const struct RefreshMelt *melt);
 
@@ -765,7 +767,7 @@ struct TALER_MINTDB_Plugin
    * Get information about melted coin details from the database.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param refresh_session session key of the melt operation
    * @param oldcoin_index index of the coin to retrieve
    * @param melt melt data to fill in
@@ -774,8 +776,8 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*get_refresh_melt) (void *cls,
-                       struct TALER_MINTDB_Session *db_conn,
-                       const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session,
+                       struct TALER_MINTDB_Session *sesssion,
+                       const struct TALER_SessionPublicKey *refresh_session,
                        uint16_t oldcoin_index,
                        struct RefreshMelt *melt);
 
@@ -785,7 +787,7 @@ struct TALER_MINTDB_Plugin
    * in a given refresh operation.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param session_pub refresh session key
    * @param num_newcoins number of coins to generate, size of the @a denom_pubs array
    * @param denom_pubs array denominations of the coins to create
@@ -794,10 +796,10 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*insert_refresh_order) (void *cls,
-                           struct TALER_MINTDB_Session *db_conn,
-                           const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
+                           struct TALER_MINTDB_Session *sesssion,
+                           const struct TALER_SessionPublicKey *session_pub,
                            uint16_t num_newcoins,
-                           struct GNUNET_CRYPTO_rsa_PublicKey *const*denom_pubs);
+                           const struct TALER_DenominationPublicKey *denom_pubs);
 
 
   /**
@@ -805,7 +807,7 @@ struct TALER_MINTDB_Plugin
    * create in the given refresh operation.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param session_pub refresh session key
    * @param num_newcoins size of the @a denom_pubs array
    * @param denom_pubs[OUT] where to write @a num_newcoins denomination keys
@@ -814,10 +816,10 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*get_refresh_order) (void *cls,
-                        struct TALER_MINTDB_Session *db_conn,
-                        const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
+                        struct TALER_MINTDB_Session *sesssion,
+                        const struct TALER_SessionPublicKey *session_pub,
                         uint16_t num_newcoins,
-                        struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs);
+                        struct TALER_DenominationPublicKey *denom_pubs);
 
 
   /**
@@ -825,7 +827,7 @@ struct TALER_MINTDB_Plugin
    * for the given refresh session in the database.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection to use
+   * @param sesssion database connection to use
    * @param refresh_session_pub refresh session this commitment belongs to
    * @param i set index (1st dimension), relating to kappa
    * @param num_newcoins coin index size of the @a commit_coins array
@@ -835,8 +837,8 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*insert_refresh_commit_coins) (void *cls,
-                                  struct TALER_MINTDB_Session *db_conn,
-                                  const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                                  struct TALER_MINTDB_Session *sesssion,
+                                  const struct TALER_SessionPublicKey *refresh_session_pub,
                                   unsigned int i,
                                   unsigned int num_newcoins,
                                   const struct RefreshCommitCoin *commit_coins);
@@ -847,22 +849,22 @@ struct TALER_MINTDB_Plugin
    * given coin of the given refresh session from the database.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection to use
+   * @param sesssion database connection to use
    * @param refresh_session_pub refresh session the commitment belongs to
    * @param i set index (1st dimension)
-   * @param j coin index (2nd dimension), corresponds to refreshed (new) coins
-   * @param commit_coin[OUT] coin commitment to return
+   * @param num_coins size of the @a commit_coins array
+   * @param commit_coin[OUT] array of coin commitments to return
    * @return #GNUNET_OK on success
    *         #GNUNET_NO if not found
    *         #GNUNET_SYSERR on error
    */
   int
   (*get_refresh_commit_coins) (void *cls,
-                               struct TALER_MINTDB_Session *db_conn,
-                               const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                               struct TALER_MINTDB_Session *sesssion,
+                               const struct TALER_SessionPublicKey *refresh_session_pub,
                                unsigned int i,
-                               unsigned int j,
-                               struct RefreshCommitCoin *commit_coin);
+                               unsigned int num_coins,
+                               struct RefreshCommitCoin *commit_coins);
 
 
   /**
@@ -870,7 +872,7 @@ struct TALER_MINTDB_Plugin
    * for the given refresh session.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection to use
+   * @param sesssion database connection to use
    * @param refresh_session_pub public key of the refresh session this
    *        commitment belongs with
    * @param i set index (1st dimension), relating to kappa
@@ -880,8 +882,8 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*insert_refresh_commit_links) (void *cls,
-                                  struct TALER_MINTDB_Session *db_conn,
-                                  const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                                  struct TALER_MINTDB_Session *sesssion,
+                                  const struct TALER_SessionPublicKey *refresh_session_pub,
                                   unsigned int i,
                                   unsigned int num_links,
                                   const struct RefreshCommitLink *commit_links);
@@ -891,7 +893,7 @@ struct TALER_MINTDB_Plugin
    * for the given refresh session.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection to use
+   * @param sesssion database connection to use
    * @param refresh_session_pub public key of the refresh session this
    *        commitment belongs with
    * @param i set index (1st dimension)
@@ -903,10 +905,10 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*get_refresh_commit_links) (void *cls,
-                               struct TALER_MINTDB_Session *db_conn,
-                               const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
+                               struct TALER_MINTDB_Session *sesssion,
+                               const struct TALER_SessionPublicKey *refresh_session_pub,
                                unsigned int i,
-                               unsigned int j,
+                               unsigned int num_links,
                                struct RefreshCommitLink *links);
 
 
@@ -917,7 +919,7 @@ struct TALER_MINTDB_Plugin
    * be used to try to obtain the private keys during "/refresh/link".
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param session_pub refresh session
    * @param newcoin_index coin index
    * @param ev_sig coin signature
@@ -925,10 +927,10 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*insert_refresh_collectable) (void *cls,
-                                 struct TALER_MINTDB_Session *db_conn,
-                                 const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
+                                 struct TALER_MINTDB_Session *sesssion,
+                                 const struct TALER_SessionPublicKey *session_pub,
                                  uint16_t newcoin_index,
-                                 const struct GNUNET_CRYPTO_rsa_Signature *ev_sig);
+                                 const struct TALER_DenominationSignature *ev_sig);
 
 
   /**
@@ -936,14 +938,14 @@ struct TALER_MINTDB_Plugin
    * information, the denomination keys and the signatures.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param coin_pub public key to use to retrieve linkage data
    * @return all known link data for the coin
    */
   struct LinkDataList *
   (*get_link_data_list) (void *cls,
-                         struct TALER_MINTDB_Session *db_conn,
-                         const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub);
+                         struct TALER_MINTDB_Session *sesssion,
+                         const struct TALER_CoinSpendPublicKey *coin_pub);
 
 
   /**
@@ -965,7 +967,7 @@ struct TALER_MINTDB_Plugin
    *
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param coin_pub public key of the coin
    * @param transfer_pub[OUT] public transfer key
    * @param shared_secret_enc[OUT] set to shared secret
@@ -975,9 +977,9 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*get_transfer) (void *cls,
-                   struct TALER_MINTDB_Session *db_conn,
-                   const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
-                   struct GNUNET_CRYPTO_EcdsaPublicKey *transfer_pub,
+                   struct TALER_MINTDB_Session *sesssion,
+                   const struct TALER_CoinSpendPublicKey *coin_pub,
+                   struct TALER_TransferPublicKey *transfer_pub,
                    struct TALER_EncryptedLinkSecret *shared_secret_enc);
 
 
@@ -985,7 +987,7 @@ struct TALER_MINTDB_Plugin
    * Test if the given /lock request is known to us.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param lock lock operation
    * @return #GNUNET_YES if known,
    *         #GNUENT_NO if not,
@@ -993,7 +995,7 @@ struct TALER_MINTDB_Plugin
    */
   int
   (*have_lock) (void *cls,
-                struct TALER_MINTDB_Session *db_conn,
+                struct TALER_MINTDB_Session *sesssion,
                 const struct Lock *lock);
 
 
@@ -1001,14 +1003,14 @@ struct TALER_MINTDB_Plugin
    * Store the given /lock request in the database.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param lock lock operation
    * @return #GNUNET_OK on success
    *         #GNUNET_SYSERR on internal error
    */
   int
   (*insert_lock) (void *cls,
-                  struct TALER_MINTDB_Session *db_conn,
+                  struct TALER_MINTDB_Session *sesssion,
                   const struct Lock *lock);
 
 
@@ -1017,14 +1019,14 @@ struct TALER_MINTDB_Plugin
    * with the given coin (/refresh/melt and /deposit operations).
    *
    * @param cls the @e cls of this struct with the plugin-specific state
-   * @param db_conn database connection
+   * @param sesssion database connection
    * @param coin_pub coin to investigate
    * @return list of transactions, NULL if coin is fresh
    */
   struct TALER_MINT_DB_TransactionList *
   (*get_coin_transactions) (void *cls,
-                            struct TALER_MINTDB_Session *db_conn,
-                            const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub);
+                            struct TALER_MINTDB_Session *sesssion,
+                            const struct TALER_CoinSpendPublicKey *coin_pub);
 
 
   /**
diff --git a/src/mint/test_mint_common.c b/src/mint/test_mint_common.c
index aa72dfdc..f6771474 100644
--- a/src/mint/test_mint_common.c
+++ b/src/mint/test_mint_common.c
@@ -31,8 +31,10 @@
     if (cond) { GNUNET_break (0); goto EXITIF_exit; }             \
   } while (0)
 
+
 int
-main (int argc, const char *const argv[])
+main (int argc,
+      const char *const argv[])
 {
   struct TALER_MINT_DenomKeyIssuePriv dki;
   char *enc;
@@ -41,25 +43,26 @@ main (int argc, const char *const argv[])
   char *enc_read;
   size_t enc_read_size;
   char *tmpfile;
-
   int ret;
 
   ret = 1;
   enc = NULL;
   enc_read = NULL;
   tmpfile = NULL;
-  dki.denom_priv = NULL;
-  dki_read.denom_priv = NULL;
+  dki.denom_priv.rsa_private_key = NULL;
+  dki_read.denom_priv.rsa_private_key = NULL;
   GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
                               &dki.issue.signature,
                               sizeof (dki) - offsetof (struct TALER_MINT_DenomKeyIssue,
                                                        signature));
-  dki.denom_priv = GNUNET_CRYPTO_rsa_private_key_create (RSA_KEY_SIZE);
-  enc_size = GNUNET_CRYPTO_rsa_private_key_encode (dki.denom_priv, &enc);
+  dki.denom_priv.rsa_private_key
+    = GNUNET_CRYPTO_rsa_private_key_create (RSA_KEY_SIZE);
+  enc_size = GNUNET_CRYPTO_rsa_private_key_encode (dki.denom_priv.rsa_private_key,
+                                                   &enc);
   EXITIF (NULL == (tmpfile = GNUNET_DISK_mktemp ("test_mint_common")));
   EXITIF (GNUNET_OK != TALER_MINT_write_denom_key (tmpfile, &dki));
   EXITIF (GNUNET_OK != TALER_MINT_read_denom_key (tmpfile, &dki_read));
-  enc_read_size = GNUNET_CRYPTO_rsa_private_key_encode (dki_read.denom_priv,
+  enc_read_size = GNUNET_CRYPTO_rsa_private_key_encode (dki_read.denom_priv.rsa_private_key,
                                                         &enc_read);
   EXITIF (enc_size != enc_read_size);
   EXITIF (0 != memcmp (enc,
@@ -75,9 +78,9 @@ main (int argc, const char *const argv[])
     GNUNET_free (tmpfile);
   }
   GNUNET_free_non_null (enc_read);
-  if (NULL != dki.denom_priv)
-    GNUNET_CRYPTO_rsa_private_key_free (dki.denom_priv);
-  if (NULL != dki_read.denom_priv)
-    GNUNET_CRYPTO_rsa_private_key_free (dki_read.denom_priv);
+  if (NULL != dki.denom_priv.rsa_private_key)
+    GNUNET_CRYPTO_rsa_private_key_free (dki.denom_priv.rsa_private_key);
+  if (NULL != dki_read.denom_priv.rsa_private_key)
+    GNUNET_CRYPTO_rsa_private_key_free (dki_read.denom_priv.rsa_private_key);
   return ret;
 }
diff --git a/src/mint/test_mint_db.c b/src/mint/test_mint_db.c
index c80be70c..0b61818f 100644
--- a/src/mint/test_mint_db.c
+++ b/src/mint/test_mint_db.c
@@ -54,14 +54,15 @@ static int result;
  */
 static int
 check_reserve (struct TALER_MINTDB_Session *session,
-               struct GNUNET_CRYPTO_EddsaPublicKey *pub,
+               const struct TALER_ReservePublicKey *pub,
                uint32_t value,
                uint32_t fraction,
                const char *currency,
                uint64_t expiry)
 {
   struct Reserve reserve;
-  reserve.pub = pub;
+
+  reserve.pub = *pub;
 
   FAILIF (GNUNET_OK !=
           plugin->reserve_get (plugin->cls,
@@ -80,8 +81,8 @@ check_reserve (struct TALER_MINTDB_Session *session,
 
 struct DenomKeyPair
 {
-  struct GNUNET_CRYPTO_rsa_PrivateKey *priv;
-  struct GNUNET_CRYPTO_rsa_PublicKey *pub;
+  struct TALER_DenominationPrivateKey priv;
+  struct TALER_DenominationPublicKey pub;
 };
 
 
@@ -91,9 +92,10 @@ create_denom_key_pair (unsigned int size)
   struct DenomKeyPair *dkp;
 
   dkp = GNUNET_new (struct DenomKeyPair);
-  dkp->priv = GNUNET_CRYPTO_rsa_private_key_create (size);
-  GNUNET_assert (NULL != dkp->priv);
-  dkp->pub = GNUNET_CRYPTO_rsa_private_key_get_public (dkp->priv);
+  dkp->priv.rsa_private_key = GNUNET_CRYPTO_rsa_private_key_create (size);
+  GNUNET_assert (NULL != dkp->priv.rsa_private_key);
+  dkp->pub.rsa_public_key
+    = GNUNET_CRYPTO_rsa_private_key_get_public (dkp->priv.rsa_private_key);
   return dkp;
 }
 
@@ -101,8 +103,8 @@ create_denom_key_pair (unsigned int size)
 static void
 destroy_denon_key_pair (struct DenomKeyPair *dkp)
 {
-  GNUNET_CRYPTO_rsa_public_key_free (dkp->pub);
-  GNUNET_CRYPTO_rsa_private_key_free (dkp->priv);
+  GNUNET_CRYPTO_rsa_public_key_free (dkp->pub.rsa_public_key);
+  GNUNET_CRYPTO_rsa_private_key_free (dkp->priv.rsa_private_key);
   GNUNET_free (dkp);
 }
 
@@ -121,7 +123,7 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct TALER_MINTDB_Session *session;
-  struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
+  struct TALER_ReservePublicKey reserve_pub;
   struct Reserve reserve;
   struct GNUNET_TIME_Absolute expiry;
   struct TALER_Amount amount;
@@ -172,7 +174,7 @@ run (void *cls,
     goto drop;
   }
   RND_BLK (&reserve_pub);
-  reserve.pub = &reserve_pub;
+  reserve.pub = reserve_pub;
   amount.value = 1;
   amount.fraction = 1;
   strcpy (amount.currency, CURRENCY);
@@ -209,7 +211,10 @@ run (void *cls,
   RND_BLK(&h_blind);
   RND_BLK(&cbc.reserve_sig);
   cbc.denom_pub = dkp->pub;
-  cbc.sig = GNUNET_CRYPTO_rsa_sign (dkp->priv, &h_blind, sizeof (h_blind));
+  cbc.sig.rsa_signature
+    = GNUNET_CRYPTO_rsa_sign (dkp->priv.rsa_private_key,
+                              &h_blind,
+                              sizeof (h_blind));
   (void) memcpy (&cbc.reserve_pub,
                  &reserve_pub,
                  sizeof (reserve_pub));
@@ -233,7 +238,7 @@ run (void *cls,
                                              session,
                                              &h_blind,
                                              &cbc2));
-  FAILIF (NULL == cbc2.denom_pub);
+  FAILIF (NULL == cbc2.denom_pub.rsa_public_key);
   FAILIF (0 != memcmp (&cbc2.reserve_sig,
                        &cbc.reserve_sig,
                        sizeof (cbc2.reserve_sig)));
@@ -242,8 +247,8 @@ run (void *cls,
                        sizeof (cbc2.reserve_pub)));
   FAILIF (GNUNET_OK !=
           GNUNET_CRYPTO_rsa_verify (&h_blind,
-                                    cbc2.sig,
-                                    dkp->pub));
+                                    cbc2.sig.rsa_signature,
+                                    dkp->pub.rsa_public_key));
   rh = plugin->get_reserve_history (plugin->cls,
                                     session,
                                     &reserve_pub);
@@ -331,12 +336,12 @@ run (void *cls,
                                           session));
   if (NULL != dkp)
     destroy_denon_key_pair (dkp);
-  if (NULL != cbc.sig)
-    GNUNET_CRYPTO_rsa_signature_free (cbc.sig);
-  if (NULL != cbc2.denom_pub)
-    GNUNET_CRYPTO_rsa_public_key_free (cbc2.denom_pub);
-  if (NULL != cbc2.sig)
-    GNUNET_CRYPTO_rsa_signature_free (cbc2.sig);
+  if (NULL != cbc.sig.rsa_signature)
+    GNUNET_CRYPTO_rsa_signature_free (cbc.sig.rsa_signature);
+  if (NULL != cbc2.denom_pub.rsa_public_key)
+    GNUNET_CRYPTO_rsa_public_key_free (cbc2.denom_pub.rsa_public_key);
+  if (NULL != cbc2.sig.rsa_signature)
+    GNUNET_CRYPTO_rsa_signature_free (cbc2.sig.rsa_signature);
   dkp = NULL;
 }
 
diff --git a/src/util/crypto.c b/src/util/crypto.c
index c7a00b9a..ffc12fed 100644
--- a/src/util/crypto.c
+++ b/src/util/crypto.c
@@ -52,7 +52,8 @@ fatal_error_handler (void *cls,
 void
 TALER_gcrypt_init ()
 {
-  gcry_set_fatalerror_handler (&fatal_error_handler, NULL);
+  gcry_set_fatalerror_handler (&fatal_error_handler,
+                               NULL);
   TALER_assert_as (gcry_check_version (NEED_LIBGCRYPT_VERSION),
                    "libgcrypt version mismatch");
   /* Disable secure memory.  */
@@ -205,11 +206,11 @@ TALER_refresh_decrypt (const struct TALER_RefreshLinkEncrypted *input,
   ret = GNUNET_new (struct TALER_RefreshLinkDecrypted);
   memcpy (&ret->coin_priv,
           buf,
-          sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
-  ret->blinding_key
+          sizeof (struct TALER_CoinSpendPrivateKey));
+  ret->blinding_key.rsa_blinding_key
     = GNUNET_CRYPTO_rsa_blinding_key_decode (&buf[sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)],
                                              input->blinding_key_enc_size);
-  if (NULL == ret->blinding_key)
+  if (NULL == ret->blinding_key.rsa_blinding_key)
   {
     GNUNET_free (ret);
     return NULL;
@@ -236,7 +237,7 @@ TALER_refresh_encrypt (const struct TALER_RefreshLinkDecrypted *input,
   struct TALER_RefreshLinkEncrypted *ret;
 
   derive_refresh_key (secret, &iv, &skey);
-  b_buf_size = GNUNET_CRYPTO_rsa_blinding_key_encode (input->blinding_key,
+  b_buf_size = GNUNET_CRYPTO_rsa_blinding_key_encode (input->blinding_key.rsa_blinding_key,
                                                       &b_buf);
   ret = GNUNET_malloc (sizeof (struct TALER_RefreshLinkEncrypted) +
                        b_buf_size);
@@ -313,8 +314,8 @@ TALER_test_coin_valid (const struct TALER_CoinPublicInfo *coin_public_info)
                       &c_hash);
   if (GNUNET_OK !=
       GNUNET_CRYPTO_rsa_verify (&c_hash,
-                                coin_public_info->denom_sig,
-                                coin_public_info->denom_pub))
+                                coin_public_info->denom_sig.rsa_signature,
+                                coin_public_info->denom_pub.rsa_public_key))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "coin signature is invalid\n");