Merge branch 'master' of git+ssh://taler.net/var/git/mint

37 files changed, 1107 insertions, 688 deletions

diff --git a/contrib/coverage.sh b/contrib/coverage.sh
new file mode 100755
index 000000000..f9106a2e1
--- /dev/null
+++ b/contrib/coverage.sh
@@ -0,0 +1,10 @@
+#!/bin/sh
+# Run from 'taler-mint/' top-level directory to generate
+# code coverage data.
+TOP=`pwd`
+mkdir -p doc/coverage/
+lcov -d $TOP -z
+make check
+lcov -d $TOP -c -o doc/coverage/coverage.info
+cd doc/coverage/
+genhtml coverage.info
diff --git a/contrib/mint-template/config/mint-common.conf b/contrib/mint-template/config/mint-common.conf
index b76ce3931..13f5d11bb 100644
--- a/contrib/mint-template/config/mint-common.conf
+++ b/contrib/mint-template/config/mint-common.conf
@@ -8,7 +8,7 @@ WIREFORMAT = SEPA
 # How to access our database
 DB = postgres
 
-DB_CONN_STR = ""
+DB_CONN_STR = "postgres:///taler"
 
 # HTTP port the mint listens to
 PORT = 4241
diff --git a/doc/paper/taler.tex b/doc/paper/taler.tex
index 96f074058..4adc6a925 100644
--- a/doc/paper/taler.tex
+++ b/doc/paper/taler.tex
@@ -874,6 +874,23 @@ be added to the basic protocol.
 
 \subsection{Refunds}
 
+The refresh protocol offers an easy way to enable refunds to
+customers, even if they are anonymous.  Refunds can be supported
+by including a public signing key of the mechant in the transaction
+details, and having the customer keep the private key of the spent
+coins on file.  
+
+Given this, the merchant can simply sign a {\em refund confirmation}
+and share it with the mint (and the customer).  Assuming the mint has
+a way to recover the funds from the merchant (or simply not performed
+the transfer yet), the mint can simply add the value of the refunded
+transaction back to the original coin, re-enabling those funds to be
+spent again by the original customer.
+
+The (anonymous) customer -- but nobody else -- can then use the
+refresh protocol to melt the refunded coin and create a fresh coin
+that is unlinkable to the previous transaction.
+
 
 \subsection{Incremental spending}
 
@@ -1029,45 +1046,57 @@ protocol with the mint.
 %\end{figure}
 
 
-
-\subsection{Probabilistic spending}
-
-Similar to Peppercoin, Taler supports probabilistic spending of coins to
-support cost-effective transactions for small amounts.  Here, an
-ordinary transaction is performed based on the result of a biased coin
-flip with a probability related to the desired transaction amount in
-relation to the value of the coin.  Unlike Peppercoin, in Taler either
-the merchant wins and the customer looses the coin, or the merchant
-looses and the customer keeps the coin.  Thus, there is no opportunity
-for the merchant and the customer to conspire against the mint.  To
-determine if the coin is to be transferred, merchant and customer
-execute a secure coin flipping protocol~\cite{blum1981}.  The commit
-values are included in the business contract and are revealed after
-the contract has been signed using the private key of the coin.  If
-the coin flip is decided in favor of the merchant, the merchant can
-redeem the coin at the mint.
+\subsection{Probabilistic donations}
+
+Similar to Peppercoin, Taler supports probabilistic {\em micro}donations of coins to
+support cost-effective transactions for small amounts.  We consider
+amounts to be ``micro'' if the value of the transaction is close or
+even below the business cost of an individual transaction to the mint.
+
+To support microdonations, an ordinary transaction is performed based
+on the result of a biased coin flip with a probability related to the
+desired transaction amount in relation to the value of the coin.  More
+specifically, a microdonation of value $\epsilon$ is upgraded to a
+macropayment of value $m$ with a probability of $\frac{\epsilon}{m}$.
+Here, $m$ is chosen such that the business transaction cost at the
+mint is small in relation to $m$.  The mint is only involved in the
+tiny fraction of transactions that are upgraded.  On average both
+customers and merchants end up paying (or receiving) the expected
+amount $\epsilon$ per microdonation.
+
+Unlike Peppercoin, in Taler either the merchant wins and the customer
+looses the coin, or the merchant looses and the customer keeps the
+coin.  Thus, there is no opportunity for the merchant and the customer
+to conspire against the mint.  To determine if the coin is to be
+transferred, merchant and customer execute a secure coin flipping
+protocol~\cite{blum1981}.  The commit values are included in the
+business contract and are revealed after the contract has been signed
+using the private key of the coin.  If the coin flip is decided in
+favor of the merchant, the merchant can redeem the coin at the mint.
 
 One issue in this protocol is that the customer may use a worthless
 coin by offering a coin that has already been spent.  This kind of
 fraud would only be detected if the customer actually lost the coin
 flip, and at this point the merchant might not be able to recover from
 the loss.  A fradulent anonymous customer may run the protocol using
-already spent coins until the coin flip is in his favor.  As with
-incremental spending, lock permissions could be used to ensure that
-the customer cannot defraud the merchant by offering a coin that has
-already been spent.  However, as this means involving the mint even if
-the merchant looses the coin flip, such a scheme is unsuitable for
-microdonations as the transaction costs from involving the mint might
-be disproportionate to the value of the transaction, and thus with
-locking the probabilistic scheme has no advantage over simply using
-fractional payments.
-
-Hence, Taler uses probabilistic transactions {\em without} the online
+already spent coins until the coin flip is in his favor.  
+
+As with incremental spending, lock permissions could be used to ensure
+that the customer cannot defraud the merchant by offering a coin that
+has already been spent.  However, as this means involving the mint
+even if the merchant looses the coin flip, such a scheme is unsuitable
+for microdonations as the transaction costs from involving the mint
+might be disproportionate to the value of the transaction, and thus
+with locking the probabilistic scheme has no advantage over simply
+using fractional payments.
+
+Hence, Taler uses probabilistic transactions {\em without} online
 double-spending detection.  This enables the customer to defraud the
 merchant by paying with a coin that was already spent.  However, as,
 by definition, such microdonations are for tiny amounts, the incentive
-for customers to pursue this kind of fraud is limited.
-
+for customers to pursue this kind of fraud is limited.  Still, to
+clarify that the customer must be honest, we prefer the term
+micro{\em donations} over micro{\em payments} for this scheme.
 
 
 The following steps are executed for microdonations with upgrade probability $p$:
@@ -1083,6 +1112,4 @@ The following steps are executed for microdonations with upgrade probability $p$
     with $H(r_c)$.
 \end{enumerate}
 
-
-
 \end{document}
diff --git a/src/include/taler_crypto_lib.h b/src/include/taler_crypto_lib.h
index 0ab05f5d0..f2c73faa3 100644
--- a/src/include/taler_crypto_lib.h
+++ b/src/include/taler_crypto_lib.h
@@ -17,6 +17,7 @@
  * @file include/taler_crypto_lib.h
  * @brief taler-specific crypto functions
  * @author Sree Harsha Totakura <sreeharsha@totakura.in>
+ * @author Christian Grothoff <christian@grothoff.org>
  */
 #ifndef TALER_CRYPTO_LIB_H
 #define TALER_CRYPTO_LIB_H
@@ -100,7 +101,7 @@ struct TALER_MerchantPrivateKeyP
 struct TALER_TransferPublicKeyP
 {
   /**
-   * Taler uses ECDSA for transfer keys.
+   * Taler uses ECDHE for transfer keys.
    */
   struct GNUNET_CRYPTO_EcdhePublicKey ecdhe_pub;
 };
@@ -113,7 +114,7 @@ struct TALER_TransferPublicKeyP
 struct TALER_TransferPrivateKeyP
 {
   /**
-   * Taler uses ECDSA for melting session keys.
+   * Taler uses ECDHE for melting session keys.
    */
   struct GNUNET_CRYPTO_EcdhePrivateKey ecdhe_priv;
 };
@@ -196,37 +197,28 @@ struct TALER_MasterSignatureP
 
 /**
  * @brief Type of public keys for Taler coins.  The same key material is used
- * for ECDSA and ECDHE operations.
+ * for EdDSA and ECDHE operations.
  */
-union TALER_CoinSpendPublicKeyP
+struct TALER_CoinSpendPublicKeyP
 {
   /**
-   * Taler uses ECDSA for coins when signing deposit requests.
+   * Taler uses EdDSA for coins when signing deposit requests.
    */
-  struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_pub;
+  struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
 
-  /**
-   * Taler uses ECDH(E) for coin linkage during refresh operations.
-   */
-  struct GNUNET_CRYPTO_EcdhePublicKey ecdhe_pub;
 };
 
 
 /**
  * @brief Type of private keys for Taler coins.  The same key material is used
- * for ECDSA and ECDHE operations.
+ * for EdDSA and ECDHE operations.
  */
-union TALER_CoinSpendPrivateKeyP
+struct TALER_CoinSpendPrivateKeyP
 {
   /**
-   * Taler uses ECDSA for coins when signing deposit requests.
-   */
-  struct GNUNET_CRYPTO_EcdsaPrivateKey ecdsa_priv;
-
-  /**
-   * Taler uses ECDHE for coin linkage during refresh operations.
+   * Taler uses EdDSA for coins when signing deposit requests.
    */
-  struct GNUNET_CRYPTO_EcdhePrivateKey ecdhe_priv;
+  struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_priv;
 };
 
 
@@ -236,9 +228,9 @@ union TALER_CoinSpendPrivateKeyP
 struct TALER_CoinSpendSignatureP
 {
   /**
-   * Taler uses ECDSA for coins.
+   * Taler uses EdDSA for coins.
    */
-  struct GNUNET_CRYPTO_EcdsaSignature ecdsa_signature;
+  struct GNUNET_CRYPTO_EddsaSignature eddsa_signature;
 };
 
 
@@ -302,7 +294,7 @@ struct TALER_CoinPublicInfo
   /**
    * The coin's public key.
    */
-  union TALER_CoinSpendPublicKeyP coin_pub;
+  struct TALER_CoinSpendPublicKeyP coin_pub;
 
   /**
    * Public key representing the denomination of the coin
@@ -383,7 +375,7 @@ struct TALER_RefreshLinkDecrypted
   /**
    * Private key of the coin.
    */
-  union TALER_CoinSpendPrivateKeyP coin_priv;
+  struct TALER_CoinSpendPrivateKeyP coin_priv;
 
   /**
    * Blinding key.
@@ -416,7 +408,7 @@ struct TALER_RefreshLinkEncrypted
   /**
    * Encrypted private key of the coin.
    */
-  char coin_priv_enc[sizeof (union TALER_CoinSpendPrivateKeyP)];
+  char coin_priv_enc[sizeof (struct TALER_CoinSpendPrivateKeyP)];
 
 };
 
@@ -427,7 +419,7 @@ struct TALER_RefreshLinkEncrypted
  * private key and the coin's public key.
  *
  * @param secret_enc encrypted link secret
- * @param transfer_priv transfer private key
+ * @param trans_priv transfer private key
  * @param coin_pub coin public key
  * @param[out] secret set to the shared secret
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
@@ -435,7 +427,7 @@ struct TALER_RefreshLinkEncrypted
 int
 TALER_link_decrypt_secret (const struct TALER_EncryptedLinkSecretP *secret_enc,
 			   const struct TALER_TransferPrivateKeyP *trans_priv,
-			   const union TALER_CoinSpendPublicKeyP *coin_pub,
+			   const struct TALER_CoinSpendPublicKeyP *coin_pub,
 			   struct TALER_LinkSecretP *secret);
 
 
@@ -445,7 +437,7 @@ TALER_link_decrypt_secret (const struct TALER_EncryptedLinkSecretP *secret_enc,
  * public key and the coin's private key.
  *
  * @param secret_enc encrypted link secret
- * @param transfer_pub transfer public key
+ * @param trans_pub transfer public key
  * @param coin_priv coin private key
  * @param[out] secret set to the shared secret
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
@@ -453,7 +445,7 @@ TALER_link_decrypt_secret (const struct TALER_EncryptedLinkSecretP *secret_enc,
 int
 TALER_link_decrypt_secret2 (const struct TALER_EncryptedLinkSecretP *secret_enc,
 			    const struct TALER_TransferPublicKeyP *trans_pub,
-			    const union TALER_CoinSpendPrivateKeyP *coin_priv,
+			    const struct TALER_CoinSpendPrivateKeyP *coin_priv,
 			    struct TALER_LinkSecretP *secret);
 
 
@@ -463,14 +455,14 @@ TALER_link_decrypt_secret2 (const struct TALER_EncryptedLinkSecretP *secret_enc,
  *
  * @param secret link secret to encrypt
  * @param coin_pub coin public key
- * @param transfer_priv[out] set to transfer private key
- * @param transfer_pub[out] set to transfer public key
+ * @param[out] trans_priv set to transfer private key
+ * @param[out] trans_pub set to transfer public key
  * @param[out] secret_enc set to the encryptd @a secret
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
 TALER_link_encrypt_secret (const struct TALER_LinkSecretP *secret,
-			   const union TALER_CoinSpendPublicKeyP *coin_pub,
+			   const struct TALER_CoinSpendPublicKeyP *coin_pub,
 			   struct TALER_TransferPrivateKeyP *trans_priv,
 			   struct TALER_TransferPublicKeyP *trans_pub,
 			   struct TALER_EncryptedLinkSecretP *secret_enc);
diff --git a/src/include/taler_json_lib.h b/src/include/taler_json_lib.h
index 7e0955688..ede2a20ee 100644
--- a/src/include/taler_json_lib.h
+++ b/src/include/taler_json_lib.h
@@ -65,18 +65,6 @@ TALER_json_from_eddsa_sig (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpo
 
 
 /**
- * Convert a signature (with purpose) to a JSON object representation.
- *
- * @param purpose purpose of the signature
- * @param signature the signature
- * @return the JSON reporesentation of the signature with purpose
- */
-json_t *
-TALER_json_from_ecdsa_sig (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
-                           const struct GNUNET_CRYPTO_EcdsaSignature *signature);
-
-
-/**
  * Convert RSA public key to JSON.
  *
  * @param pk public key to convert
@@ -109,17 +97,6 @@ TALER_json_from_data (const void *data, size_t size);
 
 
 /**
- * Convert binary hash to a JSON string with the base32crockford
- * encoding.
- *
- * @param hc binary data
- * @return json string that encodes @a hc
- */
-json_t *
-TALER_json_from_hash (const struct GNUNET_HashCode *hc);
-
-
-/**
  * Parse given JSON object to Amount
  *
  * @param json the json object representing Amount
@@ -154,6 +131,27 @@ TALER_json_to_data (json_t *json,
                     void *out,
                     size_t out_size);
 
+
+/**
+ * Convert JSON to RSA public key.
+ *
+ * @param pk JSON encoding to convert 
+ * @return corresponding public key
+ */
+struct GNUNET_CRYPTO_rsa_PublicKey *
+TALER_json_to_rsa_public_key (json_t *json);
+
+
+/**
+ * Convert JSON to RSA signature.
+ *
+ * @param pk JSON encoding to convert 
+ * @return corresponding signature
+ */
+struct GNUNET_CRYPTO_rsa_Signature *
+TALER_json_to_rsa_signature (json_t *json);
+
+
 /**
  * Check if the given wire format JSON object is correctly formatted
  *
diff --git a/src/include/taler_mint_service.h b/src/include/taler_mint_service.h
index 4c71c002a..4fd9a281d 100644
--- a/src/include/taler_mint_service.h
+++ b/src/include/taler_mint_service.h
@@ -22,7 +22,6 @@
 #define _TALER_MINT_SERVICE_H
 
 #include "taler_util.h"
-#include <jansson.h>
 
 /**
  * @brief Handle to this library context
diff --git a/src/include/taler_mintdb_lib.h b/src/include/taler_mintdb_lib.h
index 646693dee..739194a40 100644
--- a/src/include/taler_mintdb_lib.h
+++ b/src/include/taler_mintdb_lib.h
@@ -23,7 +23,6 @@
 #ifndef TALER_MINTDB_LIB_H
 #define TALER_MINTDB_LIB_H
 
-#include <gnunet/gnunet_util_lib.h>
 #include "taler_signatures.h"
 
 /**
diff --git a/src/include/taler_mintdb_plugin.h b/src/include/taler_mintdb_plugin.h
index ffa1b13d3..6cc8fd76c 100644
--- a/src/include/taler_mintdb_plugin.h
+++ b/src/include/taler_mintdb_plugin.h
@@ -23,8 +23,6 @@
 #define TALER_MINTDB_PLUGIN_H
 
 #include <gnunet/gnunet_util_lib.h>
-#include "taler_util.h"
-#include "taler_signatures.h"
 #include "taler_mintdb_lib.h"
 
 
@@ -685,7 +683,9 @@ struct TALER_MINTDB_Plugin
 
   /**
    * Insert a incoming transaction into reserves.  New reserves are
-   * also created through this function.
+   * also created through this function.  Note that this API call
+   * starts (and stops) its own transaction scope (so the application
+   * must not do so).
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param db the database connection handle
@@ -704,7 +704,7 @@ struct TALER_MINTDB_Plugin
                          const struct TALER_ReservePublicKeyP *reserve_pub,
                          const struct TALER_Amount *balance,
                          const char *details,
-                         const struct GNUNET_TIME_Absolute expiry);
+                         struct GNUNET_TIME_Absolute expiry);
 
 
   /**
@@ -1066,7 +1066,7 @@ struct TALER_MINTDB_Plugin
   struct TALER_MINTDB_LinkDataList *
   (*get_link_data_list) (void *cls,
                          struct TALER_MINTDB_Session *sesssion,
-                         const union TALER_CoinSpendPublicKeyP *coin_pub);
+                         const struct TALER_CoinSpendPublicKeyP *coin_pub);
 
 
   /**
@@ -1083,7 +1083,7 @@ struct TALER_MINTDB_Plugin
   /**
    * Obtain shared secret and transfer public key from the public key of
    * the coin.  This information and the link information returned by
-   * #TALER_db_get_link() enable the owner of an old coin to determine
+   * @e get_link_data_list() enable the owner of an old coin to determine
    * the private keys of the new coins after the melt.
    *
    *
@@ -1099,7 +1099,7 @@ struct TALER_MINTDB_Plugin
   int
   (*get_transfer) (void *cls,
                    struct TALER_MINTDB_Session *sesssion,
-                   const union TALER_CoinSpendPublicKeyP *coin_pub,
+                   const struct TALER_CoinSpendPublicKeyP *coin_pub,
                    struct TALER_TransferPublicKeyP *transfer_pub,
                    struct TALER_EncryptedLinkSecretP *shared_secret_enc);
 
@@ -1111,7 +1111,7 @@ struct TALER_MINTDB_Plugin
    * @param sesssion database connection
    * @param lock lock operation
    * @return #GNUNET_YES if known,
-   *         #GNUENT_NO if not,
+   *         #GNUNET_NO if not,
    *         #GNUNET_SYSERR on internal error
    */
   int
@@ -1147,7 +1147,7 @@ struct TALER_MINTDB_Plugin
   struct TALER_MINTDB_TransactionList *
   (*get_coin_transactions) (void *cls,
                             struct TALER_MINTDB_Session *sesssion,
-                            const union TALER_CoinSpendPublicKeyP *coin_pub);
+                            const struct TALER_CoinSpendPublicKeyP *coin_pub);
 
 
   /**
diff --git a/src/include/taler_pq_lib.h b/src/include/taler_pq_lib.h
index 148385c8b..d030d9b74 100644
--- a/src/include/taler_pq_lib.h
+++ b/src/include/taler_pq_lib.h
@@ -108,7 +108,7 @@ struct TALER_PQ_QueryParam
 /**
  * End of query parameter specification.
  */
-#define TALER_PQ_QUERY_PARAM_END { TALER_PQ_QF_END, NULL, 0 }
+#define TALER_PQ_query_param_end { TALER_PQ_QF_END, NULL, 0 }
 
 /**
  * Generate fixed-size query parameter with size given explicitly.
@@ -116,7 +116,7 @@ struct TALER_PQ_QueryParam
  * @param x pointer to the query parameter to pass
  * @param s number of bytes of @a x to use for the query
  */
-#define TALER_PQ_QUERY_PARAM_PTR_SIZED(x,s) { TALER_PQ_QF_FIXED_BLOB, (x), (s) }
+#define TALER_PQ_query_param_fixed_size(x,s) { TALER_PQ_QF_FIXED_BLOB, (x), (s) }
 
 
 /**
@@ -125,7 +125,7 @@ struct TALER_PQ_QueryParam
  *
  * @param x pointer to the query parameter to pass.
  */
-#define TALER_PQ_QUERY_PARAM_PTR(x) { TALER_PQ_QF_VARSIZE_BLOB, x, sizeof (*(x)) }
+#define TALER_PQ_query_param_auto_from_type(x) { TALER_PQ_QF_VARSIZE_BLOB, x, sizeof (*(x)) }
 
 
 /**
@@ -137,7 +137,7 @@ struct TALER_PQ_QueryParam
  * @param x pointer to the query parameter to pass
  */
 struct TALER_PQ_QueryParam
-TALER_PQ_QUERY_PARAM_AMOUNT_NBO(const struct TALER_AmountNBO *x);
+TALER_PQ_query_param_amount_nbo(const struct TALER_AmountNBO *x);
 
 
 /**
@@ -149,7 +149,7 @@ TALER_PQ_QUERY_PARAM_AMOUNT_NBO(const struct TALER_AmountNBO *x);
  * @param x pointer to the query parameter to pass
  */
 struct TALER_PQ_QueryParam
-TALER_PQ_QUERY_PARAM_AMOUNT(const struct TALER_Amount *x);
+TALER_PQ_query_param_amount(const struct TALER_Amount *x);
 
 
 /**
@@ -159,7 +159,7 @@ TALER_PQ_QUERY_PARAM_AMOUNT(const struct TALER_Amount *x);
  * @param x the query parameter to pass.
  */
 struct TALER_PQ_QueryParam
-TALER_PQ_QUERY_PARAM_RSA_PUBLIC_KEY(const struct GNUNET_CRYPTO_rsa_PublicKey *x);
+TALER_PQ_query_param_rsa_public_key(const struct GNUNET_CRYPTO_rsa_PublicKey *x);
 
 
 /**
@@ -169,7 +169,7 @@ TALER_PQ_QUERY_PARAM_RSA_PUBLIC_KEY(const struct GNUNET_CRYPTO_rsa_PublicKey *x)
  * @param x the query parameter to pass
  */
 struct TALER_PQ_QueryParam
-TALER_PQ_QUERY_PARAM_RSA_SIGNATURE(const struct GNUNET_CRYPTO_rsa_Signature *x);
+TALER_PQ_query_param_rsa_signature(const struct GNUNET_CRYPTO_rsa_Signature *x);
 
 
 /**
@@ -179,7 +179,7 @@ TALER_PQ_QUERY_PARAM_RSA_SIGNATURE(const struct GNUNET_CRYPTO_rsa_Signature *x);
  * @param x pointer to the query parameter to pass
  */
 struct TALER_PQ_QueryParam
-TALER_PQ_QUERY_PARAM_ABSOLUTE_TIME(struct GNUNET_TIME_Absolute x);
+TALER_PQ_query_param_absolute_time(const struct GNUNET_TIME_Absolute *x);
 
 
 /**
@@ -277,7 +277,7 @@ struct TALER_PQ_ResultSpec
  *
  * @return array last entry for the result specification to use
  */
-#define TALER_PQ_RESULT_SPEC_END { TALER_PQ_RF_END, NULL, 0, NULL, NULL }
+#define TALER_PQ_result_spec_end { TALER_PQ_RF_END, NULL, 0, NULL, NULL }
 
 /**
  * We expect a fixed-size result, with size given explicitly
@@ -287,7 +287,7 @@ struct TALER_PQ_ResultSpec
  * @param s number of bytes we should use in @a dst
  * @return array entry for the result specification to use
  */
-#define TALER_PQ_RESULT_SPEC_SIZED(name, dst, s) { TALER_PQ_RF_FIXED_BLOB,  (void *) (dst), (s), (name), NULL }
+#define TALER_PQ_result_spec_fixed_size(name, dst, s) { TALER_PQ_RF_FIXED_BLOB,  (void *) (dst), (s), (name), NULL }
 
 
 /**
@@ -297,7 +297,7 @@ struct TALER_PQ_ResultSpec
  * @param dst point to where to store the result, type fits expected result size
  * @return array entry for the result specification to use
  */
-#define TALER_PQ_RESULT_SPEC(name, dst) { TALER_PQ_RF_VARSIZE_BLOB, (void *) dst, sizeof (*(dst)), name, NULL }
+#define TALER_PQ_result_spec_auto_from_type(name, dst) { TALER_PQ_RF_FIXED_BLOB, (void *) (dst), sizeof (*(dst)), name, NULL }
 
 
 /**
@@ -309,9 +309,9 @@ struct TALER_PQ_ResultSpec
  * @return array entry for the result specification to use
  */
 struct TALER_PQ_ResultSpec
-TALER_PQ_RESULT_SPEC_VAR (const char *name,
-			  void **dst,
-			  size_t *sptr);
+TALER_PQ_result_spec_variable_size (const char *name,
+				    void **dst,
+				    size_t *sptr);
 
 
 /**
@@ -322,7 +322,7 @@ TALER_PQ_RESULT_SPEC_VAR (const char *name,
  * @return array entry for the result specification to use
  */
 struct TALER_PQ_ResultSpec
-TALER_PQ_RESULT_SPEC_AMOUNT_NBO (const char *name,
+TALER_PQ_result_spec_amount_nbo (const char *name,
 				 struct TALER_AmountNBO *amount);
 
 
@@ -334,7 +334,7 @@ TALER_PQ_RESULT_SPEC_AMOUNT_NBO (const char *name,
  * @return array entry for the result specification to use
  */
 struct TALER_PQ_ResultSpec
-TALER_PQ_RESULT_SPEC_AMOUNT (const char *name,
+TALER_PQ_result_spec_amount (const char *name,
 			     struct TALER_Amount *amount);
 
 
@@ -346,7 +346,7 @@ TALER_PQ_RESULT_SPEC_AMOUNT (const char *name,
  * @return array entry for the result specification to use
  */
 struct TALER_PQ_ResultSpec
-TALER_PQ_RESULT_SPEC_RSA_PUBLIC_KEY (const char *name,
+TALER_PQ_result_spec_rsa_public_key (const char *name,
 				     struct GNUNET_CRYPTO_rsa_PublicKey **rsa);
 
 
@@ -358,7 +358,7 @@ TALER_PQ_RESULT_SPEC_RSA_PUBLIC_KEY (const char *name,
  * @return array entry for the result specification to use
  */
 struct TALER_PQ_ResultSpec
-TALER_PQ_RESULT_SPEC_RSA_SIGNATURE (const char *name,
+TALER_PQ_result_spec_rsa_signature (const char *name,
 				    struct GNUNET_CRYPTO_rsa_Signature **sig);
 
 
@@ -370,7 +370,7 @@ TALER_PQ_RESULT_SPEC_RSA_SIGNATURE (const char *name,
  * @return array entry for the result specification to use
  */
 struct TALER_PQ_ResultSpec
-TALER_PQ_RESULT_SPEC_ABSOLUTE_TIME (const char *name,
+TALER_PQ_result_spec_absolute_time (const char *name,
 				    struct GNUNET_TIME_Absolute *at);
 
 
@@ -394,7 +394,7 @@ TALER_PQ_exec_prepared (PGconn *db_conn,
  * is returned.
  *
  * @param result result to process
- * @param[in|out] rs result specification to extract for
+ * @param[in,out] rs result specification to extract for
  * @param row row from the result to extract
  * @return
  *   #GNUNET_YES if all results could be extracted
diff --git a/src/include/taler_signatures.h b/src/include/taler_signatures.h
index de6dbfc24..bc34c32e9 100644
--- a/src/include/taler_signatures.h
+++ b/src/include/taler_signatures.h
@@ -123,16 +123,6 @@
 
 
 /**
- * ECDSA test signature.
- */
-#define TALER_SIGNATURE_CLIENT_TEST_ECDSA 1300
-
-/**
- * ECDSA test signature.
- */
-#define TALER_SIGNATURE_MINT_TEST_ECDSA 1301
-
-/**
  * EdDSA test signature.
  */
 #define TALER_SIGNATURE_CLIENT_TEST_EDDSA 1302
@@ -207,7 +197,7 @@ struct TALER_DepositRequestPS
 {
   /**
    * Purpose must be #TALER_SIGNATURE_WALLET_COIN_DEPOSIT.
-   * Used for an ECDSA signature with the `union TALER_CoinSpendPublicKeyP`.
+   * Used for an EdDSA signature with the `struct TALER_CoinSpendPublicKeyP`.
    */
   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
 
@@ -283,9 +273,9 @@ struct TALER_DepositRequestPS
   /**
    * The coin's public key.  This is the value that must have been
    * signed (blindly) by the Mint.  The deposit request is to be
-   * signed by the corresponding private key (using ECDSA).
+   * signed by the corresponding private key (using EdDSA).
    */
-  union TALER_CoinSpendPublicKeyP coin_pub;
+  struct TALER_CoinSpendPublicKeyP coin_pub;
 
 };
 
@@ -341,9 +331,9 @@ struct TALER_DepositConfirmationPS
   /**
    * The coin's public key.  This is the value that must have been
    * signed (blindly) by the Mint.  The deposit request is to be
-   * signed by the corresponding private key (using ECDSA).
+   * signed by the corresponding private key (using EdDSA).
    */
-  union TALER_CoinSpendPublicKeyP coin_pub;
+  struct TALER_CoinSpendPublicKeyP coin_pub;
 
   /**
    * The Merchant's public key.  Allows the merchant to later refund
@@ -363,7 +353,7 @@ struct TALER_RefreshMeltCoinAffirmationPS
 {
   /**
    * Purpose is #TALER_SIGNATURE_WALLET_COIN_MELT.
-   * Used for an ECDSA signature with the `union TALER_CoinSpendPublicKeyP`.
+   * Used for an EdDSA signature with the `struct TALER_CoinSpendPublicKeyP`.
    */
   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
 
@@ -396,9 +386,9 @@ struct TALER_RefreshMeltCoinAffirmationPS
   /**
    * The coin's public key.  This is the value that must have been
    * signed (blindly) by the Mint.  The deposit request is to be
-   * signed by the corresponding private key (using ECDSA).
+   * signed by the corresponding private key (using EdDSA).
    */
-  union TALER_CoinSpendPublicKeyP coin_pub;
+  struct TALER_CoinSpendPublicKeyP coin_pub;
 };
 
 
diff --git a/src/include/taler_util.h b/src/include/taler_util.h
index cad899685..c9db9f789 100644
--- a/src/include/taler_util.h
+++ b/src/include/taler_util.h
@@ -108,7 +108,7 @@ TALER_config_get_denom (struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return a pointer to the dir path (to be freed by the caller)
  */
 char *
-TALER_os_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind);
+TALER_OS_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind);
 
 
 /**
diff --git a/src/mint-tools/taler-mint-dbinit.c b/src/mint-tools/taler-mint-dbinit.c
index 0eefc63b4..3293a69ab 100644
--- a/src/mint-tools/taler-mint-dbinit.c
+++ b/src/mint-tools/taler-mint-dbinit.c
@@ -21,9 +21,7 @@
 #include "platform.h"
 #include <gnunet/gnunet_util_lib.h>
 #include <libpq-fe.h>
-#include "taler_util.h"
 #include "taler_mintdb_plugin.h"
-#include "taler_mintdb_lib.h"
 
 /**
  * Mint directory with the keys.
diff --git a/src/mint-tools/taler-mint-keyup.c b/src/mint-tools/taler-mint-keyup.c
index cc60756a9..70c664433 100644
--- a/src/mint-tools/taler-mint-keyup.c
+++ b/src/mint-tools/taler-mint-keyup.c
@@ -22,8 +22,6 @@
  * @author Christian Grothoff
  */
 #include <platform.h>
-#include <gnunet/gnunet_util_lib.h>
-#include "taler_util.h"
 #include "taler_mintdb_lib.h"
 
 /**
diff --git a/src/mint-tools/taler-mint-reservemod.c b/src/mint-tools/taler-mint-reservemod.c
index 5bb6bce46..9dff5731c 100644
--- a/src/mint-tools/taler-mint-reservemod.c
+++ b/src/mint-tools/taler-mint-reservemod.c
@@ -22,11 +22,7 @@
 #include "platform.h"
 #include <gnunet/gnunet_util_lib.h>
 #include <libpq-fe.h>
-#include "taler_util.h"
-#include "taler_signatures.h"
-#include "taler_pq_lib.h"
 #include "taler_mintdb_plugin.h"
-#include "taler_mintdb_lib.h"
 
 /**
  * After what time to inactive reserves expire?
@@ -98,6 +94,9 @@ main (int argc, char *const *argv)
   {
     fprintf (stderr,
              "Mint directory not given\n");
+    GNUNET_free_non_null (add_str);
+    GNUNET_free_non_null (details);
+    GNUNET_free_non_null (reserve_pub_str);
     return 1;
   }
   if ((NULL == reserve_pub_str) ||
@@ -109,6 +108,9 @@ main (int argc, char *const *argv)
   {
     fprintf (stderr,
              "Parsing reserve key invalid\n");
+    GNUNET_free_non_null (add_str);
+    GNUNET_free_non_null (details);
+    GNUNET_free_non_null (reserve_pub_str);
     return 1;
   }
   if ( (NULL == add_str) ||
@@ -119,6 +121,9 @@ main (int argc, char *const *argv)
     fprintf (stderr,
              "Failed to parse currency amount `%s'\n",
              add_str);
+    GNUNET_free_non_null (add_str);
+    GNUNET_free_non_null (details);
+    GNUNET_free_non_null (reserve_pub_str);
     return 1;
   }
 
@@ -126,7 +131,9 @@ main (int argc, char *const *argv)
   {
     fprintf (stderr,
              "No wiring details given (justification required)\n");
-    return 1;
+   GNUNET_free_non_null (add_str);
+   GNUNET_free_non_null (reserve_pub_str);
+   return 1;
   }
 
   cfg = TALER_config_load (mint_directory);
@@ -134,7 +141,10 @@ main (int argc, char *const *argv)
   {
     fprintf (stderr,
              "Failed to load mint configuration\n");
-    return 1;
+    GNUNET_free_non_null (add_str);
+    GNUNET_free_non_null (details);
+    GNUNET_free_non_null (reserve_pub_str);
+   return 1;
   }
   ret = 1;
   if (NULL ==
@@ -153,34 +163,23 @@ main (int argc, char *const *argv)
              "Failed to initialize DB session\n");
     goto cleanup;
   }
-  if (GNUNET_OK !=
-      plugin->start (plugin->cls,
-                     session))
-  {
-    fprintf (stderr,
-             "Failed to start transaction\n");
-    goto cleanup;
-  }
   expiration = GNUNET_TIME_relative_to_absolute (RESERVE_EXPIRATION);
-  if (GNUNET_OK !=
-      plugin->reserves_in_insert (plugin->cls,
-                                  session,
-                                  &reserve_pub,
-                                  &add_value,
-                                  details,
-                                  expiration))
+  ret = plugin->reserves_in_insert (plugin->cls,
+				    session,
+				    &reserve_pub,
+				    &add_value,
+				    details,
+				    expiration);
+  if (GNUNET_SYSERR == ret)
   {
     fprintf (stderr,
              "Failed to update reserve.\n");
     goto cleanup;
   }
-  if (GNUNET_OK !=
-      plugin->commit (plugin->cls,
-                     session))
+  if (GNUNET_NO == ret)
   {
     fprintf (stderr,
-             "Failed to commit transaction\n");
-    goto cleanup;
+             "Record exists, reserve not updated.\n");
   }
   ret = 0;
  cleanup:
@@ -188,6 +187,9 @@ main (int argc, char *const *argv)
     TALER_MINTDB_plugin_unload (plugin);
   if (NULL != cfg)
     GNUNET_CONFIGURATION_destroy (cfg);
+  GNUNET_free_non_null (add_str);
+  GNUNET_free_non_null (details);
+  GNUNET_free_non_null (reserve_pub_str);
   return ret;
 }
 
diff --git a/src/mint/taler-mint-httpd.c b/src/mint/taler-mint-httpd.c
index d7e2c353a..b9146c5d8 100644
--- a/src/mint/taler-mint-httpd.c
+++ b/src/mint/taler-mint-httpd.c
@@ -26,8 +26,6 @@
 #include <jansson.h>
 #include <microhttpd.h>
 #include <pthread.h>
-#include "taler_signatures.h"
-#include "taler_util.h"
 #include "taler-mint-httpd_parsing.h"
 #include "taler-mint-httpd_mhd.h"
 #include "taler-mint-httpd_deposit.h"
@@ -232,13 +230,6 @@ handle_mhd_request (void *cls,
         "Only POST is allowed", 0,
         &TMH_MHD_handler_send_json_pack_error, MHD_HTTP_METHOD_NOT_ALLOWED },
 
-      { "/test/ecdsa", MHD_HTTP_METHOD_POST, "application/json",
-	NULL, 0,
-	&TMH_TEST_handler_test_ecdsa, MHD_HTTP_OK },
-      { "/test/ecdsa", NULL, "text/plain",
-        "Only POST is allowed", 0,
-        &TMH_MHD_handler_send_json_pack_error, MHD_HTTP_METHOD_NOT_ALLOWED },
-
       { "/test/eddsa", MHD_HTTP_METHOD_POST, "application/json",
 	NULL, 0,
 	&TMH_TEST_handler_test_eddsa, MHD_HTTP_OK },
diff --git a/src/mint/taler-mint-httpd_db.c b/src/mint/taler-mint-httpd_db.c
index 53567a92a..22f225c22 100644
--- a/src/mint/taler-mint-httpd_db.c
+++ b/src/mint/taler-mint-httpd_db.c
@@ -21,12 +21,8 @@
 #include "platform.h"
 #include <pthread.h>
 #include <jansson.h>
-#include "taler-mint-httpd_db.h"
-#include "taler_signatures.h"
 #include "taler-mint-httpd_responses.h"
-#include "taler_util.h"
 #include "taler-mint-httpd_keystate.h"
-#include "taler_mintdb_lib.h"
 
 
 /**
@@ -926,7 +922,7 @@ check_commitment (struct MHD_Connection *connection,
   for (j = 0; j < num_newcoins; j++)
   {
     struct TALER_RefreshLinkDecrypted *link_data;
-    union TALER_CoinSpendPublicKeyP coin_pub;
+    struct TALER_CoinSpendPublicKeyP coin_pub;
     struct GNUNET_HashCode h_msg;
     char *buf;
     size_t buf_len;
@@ -942,10 +938,10 @@ check_commitment (struct MHD_Connection *connection,
           ? GNUNET_NO : GNUNET_SYSERR;
     }
 
-    GNUNET_CRYPTO_ecdsa_key_get_public (&link_data->coin_priv.ecdsa_priv,
-                                        &coin_pub.ecdsa_pub);
+    GNUNET_CRYPTO_eddsa_key_get_public (&link_data->coin_priv.eddsa_priv,
+                                        &coin_pub.eddsa_pub);
     GNUNET_CRYPTO_hash (&coin_pub,
-                        sizeof (union TALER_CoinSpendPublicKeyP),
+                        sizeof (struct TALER_CoinSpendPublicKeyP),
                         &h_msg);
     if (0 == (buf_len =
               GNUNET_CRYPTO_rsa_blind (&h_msg,
@@ -1248,7 +1244,7 @@ TMH_DB_execute_refresh_reveal (struct MHD_Connection *connection,
  */
 int
 TMH_DB_execute_refresh_link (struct MHD_Connection *connection,
-                             const union TALER_CoinSpendPublicKeyP *coin_pub)
+                             const struct TALER_CoinSpendPublicKeyP *coin_pub)
 {
   int res;
   struct TALER_MINTDB_Session *session;
diff --git a/src/mint/taler-mint-httpd_db.h b/src/mint/taler-mint-httpd_db.h
index 5a8e1aee8..56a4dd9cb 100644
--- a/src/mint/taler-mint-httpd_db.h
+++ b/src/mint/taler-mint-httpd_db.h
@@ -22,8 +22,6 @@
 #define TALER_MINT_HTTPD_DB_H
 
 #include <microhttpd.h>
-#include <gnunet/gnunet_util_lib.h>
-#include "taler_util.h"
 #include "taler_mintdb_plugin.h"
 
 
@@ -166,7 +164,7 @@ TMH_DB_execute_refresh_reveal (struct MHD_Connection *connection,
  */
 int
 TMH_DB_execute_refresh_link (struct MHD_Connection *connection,
-                             const union TALER_CoinSpendPublicKeyP *coin_pub);
+                             const struct TALER_CoinSpendPublicKeyP *coin_pub);
 
 
 #endif
diff --git a/src/mint/taler-mint-httpd_deposit.c b/src/mint/taler-mint-httpd_deposit.c
index a45cf354b..2e9facdff 100644
--- a/src/mint/taler-mint-httpd_deposit.c
+++ b/src/mint/taler-mint-httpd_deposit.c
@@ -30,11 +30,7 @@
 #include <jansson.h>
 #include <microhttpd.h>
 #include <pthread.h>
-#include "taler_mintdb_plugin.h"
-#include "taler_signatures.h"
-#include "taler_util.h"
 #include "taler-mint-httpd_parsing.h"
-#include "taler-mint-httpd_db.h"
 #include "taler-mint-httpd_deposit.h"
 #include "taler-mint-httpd_responses.h"
 #include "taler-mint-httpd_keystate.h"
@@ -73,10 +69,10 @@ verify_and_execute_deposit (struct MHD_Connection *connection,
   dr.merchant = deposit->merchant_pub;
   dr.coin_pub = deposit->coin.coin_pub;
   if (GNUNET_OK !=
-      GNUNET_CRYPTO_ecdsa_verify (TALER_SIGNATURE_WALLET_COIN_DEPOSIT,
+      GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_WALLET_COIN_DEPOSIT,
                                   &dr.purpose,
-                                  &deposit->csig.ecdsa_signature,
-                                  &deposit->coin.coin_pub.ecdsa_pub))
+                                  &deposit->csig.eddsa_signature,
+                                  &deposit->coin.coin_pub.eddsa_pub))
   {
     TALER_LOG_WARNING ("Invalid signature on /deposit request\n");
     return TMH_RESPONSE_reply_signature_invalid (connection,
diff --git a/src/mint/taler-mint-httpd_refresh.c b/src/mint/taler-mint-httpd_refresh.c
index 759c55bb2..0ffba6e87 100644
--- a/src/mint/taler-mint-httpd_refresh.c
+++ b/src/mint/taler-mint-httpd_refresh.c
@@ -24,9 +24,6 @@
 #include <gnunet/gnunet_util_lib.h>
 #include <jansson.h>
 #include <microhttpd.h>
-#include "taler_mintdb_plugin.h"
-#include "taler_signatures.h"
-#include "taler_util.h"
 #include "taler-mint-httpd_parsing.h"
 #include "taler-mint-httpd_mhd.h"
 #include "taler-mint-httpd_refresh.h"
@@ -269,10 +266,10 @@ verify_coin_public_info (struct MHD_Connection *connection,
 
   TMH_KS_release (key_state);
   if (GNUNET_OK !=
-      GNUNET_CRYPTO_ecdsa_verify (TALER_SIGNATURE_WALLET_COIN_MELT,
+      GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_WALLET_COIN_MELT,
                                   &body.purpose,
-                                  &melt_detail->melt_sig.ecdsa_signature,
-                                  &melt_detail->coin_info.coin_pub.ecdsa_pub))
+                                  &melt_detail->melt_sig.eddsa_signature,
+                                  &melt_detail->coin_info.coin_pub.eddsa_pub))
   {
     if (MHD_YES !=
         TMH_RESPONSE_reply_signature_invalid (connection,
@@ -439,7 +436,7 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
     {
       if (0 == memcmp (&coin_melt_details[i].coin_info.coin_pub,
                        &coin_melt_details[j].coin_info.coin_pub,
-                       sizeof (union TALER_CoinSpendPublicKeyP)))
+                       sizeof (struct TALER_CoinSpendPublicKeyP)))
       {
         for (j=0;j<i;j++)
         {
@@ -458,7 +455,7 @@ handle_refresh_melt_json (struct MHD_Connection *connection,
                        &coin_melt_details[i].melt_amount_with_fee);
     GNUNET_CRYPTO_hash_context_read (hash_context,
                                      &coin_melt_details[i].coin_info.coin_pub,
-                                     sizeof (union TALER_CoinSpendPublicKeyP));
+                                     sizeof (struct TALER_CoinSpendPublicKeyP));
     GNUNET_CRYPTO_hash_context_read (hash_context,
                                      &melt_amount,
                                      sizeof (struct TALER_AmountNBO));
@@ -891,13 +888,13 @@ TMH_REFRESH_handler_refresh_link (struct TMH_RequestHandler *rh,
                                   const char *upload_data,
                                   size_t *upload_data_size)
 {
-  union TALER_CoinSpendPublicKeyP coin_pub;
+  struct TALER_CoinSpendPublicKeyP coin_pub;
   int res;
 
   res = TMH_PARSE_mhd_request_arg_data (connection,
                                         "coin_pub",
                                         &coin_pub,
-                                        sizeof (union TALER_CoinSpendPublicKeyP));
+                                        sizeof (struct TALER_CoinSpendPublicKeyP));
   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 e37eea188..f8240df52 100644
--- a/src/mint/taler-mint-httpd_responses.c
+++ b/src/mint/taler-mint-httpd_responses.c
@@ -303,7 +303,7 @@ TMH_RESPONSE_reply_invalid_json (struct MHD_Connection *connection)
  */
 int
 TMH_RESPONSE_reply_deposit_success (struct MHD_Connection *connection,
-                                    const union TALER_CoinSpendPublicKeyP *coin_pub,
+                                    const struct TALER_CoinSpendPublicKeyP *coin_pub,
                                     const struct GNUNET_HashCode *h_wire,
                                     const struct GNUNET_HashCode *h_contract,
                                     uint64_t transaction_id,
@@ -381,8 +381,8 @@ compile_transaction_history (const struct TALER_MINTDB_TransactionList *tl)
                            &deposit->deposit_fee);
         dr.merchant = deposit->merchant_pub;
         dr.coin_pub = deposit->coin.coin_pub;
-        transaction = TALER_json_from_ecdsa_sig (&dr.purpose,
-                                                 &deposit->csig.ecdsa_signature);
+        transaction = TALER_json_from_eddsa_sig (&dr.purpose,
+                                                 &deposit->csig.eddsa_signature);
         break;
       }
     case TALER_MINTDB_TT_REFRESH_MELT:
@@ -400,8 +400,8 @@ compile_transaction_history (const struct TALER_MINTDB_TransactionList *tl)
         TALER_amount_hton (&ms.melt_fee,
                            &melt->melt_fee);
         ms.coin_pub = melt->coin.coin_pub;
-        transaction = TALER_json_from_ecdsa_sig (&ms.purpose,
-                                                 &melt->coin_sig.ecdsa_signature);
+        transaction = TALER_json_from_eddsa_sig (&ms.purpose,
+                                                 &melt->coin_sig.eddsa_signature);
       }
       break;
     case TALER_MINTDB_TT_LOCK:
@@ -678,7 +678,7 @@ TMH_RESPONSE_reply_withdraw_sign_success (struct MHD_Connection *connection,
  */
 int
 TMH_RESPONSE_reply_refresh_melt_insufficient_funds (struct MHD_Connection *connection,
-                                                    const union TALER_CoinSpendPublicKeyP *coin_pub,
+                                                    const struct TALER_CoinSpendPublicKeyP *coin_pub,
                                                     struct TALER_Amount coin_value,
                                                     struct TALER_MINTDB_TransactionList *tl,
                                                     struct TALER_Amount requested,
@@ -692,7 +692,7 @@ TMH_RESPONSE_reply_refresh_melt_insufficient_funds (struct MHD_Connection *conne
                                        "{s:s, s:o, s:o, s:o, s:o, s:o}",
                                        "error", "insufficient funds",
                                        "coin-pub", TALER_json_from_data (coin_pub,
-                                                                         sizeof (union TALER_CoinSpendPublicKeyP)),
+                                                                         sizeof (struct TALER_CoinSpendPublicKeyP)),
                                        "original-value", TALER_json_from_amount (&coin_value),
                                        "residual-value", TALER_json_from_amount (&residual),
                                        "requested-value", TALER_json_from_amount (&requested),
@@ -814,7 +814,7 @@ TMH_RESPONSE_reply_refresh_reveal_missmatch (struct MHD_Connection *connection,
     json_object_set_new (rm_json,
                          "coin_pub",
                          TALER_json_from_data (&rm->coin.coin_pub,
-                                               sizeof (union TALER_CoinSpendPublicKeyP)));
+                                               sizeof (struct TALER_CoinSpendPublicKeyP)));
     json_object_set_new (rm_json,
                          "melt_amount_with_fee",
                          TALER_json_from_amount (&rm->amount_with_fee));
@@ -856,7 +856,7 @@ TMH_RESPONSE_reply_refresh_reveal_missmatch (struct MHD_Connection *connection,
       json_object_set_new (cc_json,
                            "coin_priv_enc",
                            TALER_json_from_data (cc->refresh_link->coin_priv_enc,
-                                                 sizeof (union TALER_CoinSpendPrivateKeyP)));
+                                                 sizeof (struct TALER_CoinSpendPrivateKeyP)));
       json_object_set_new (cc_json,
                            "blinding_key_enc",
                            TALER_json_from_data (cc->refresh_link->blinding_key_enc,
@@ -933,7 +933,7 @@ TMH_RESPONSE_reply_refresh_link_success (struct MHD_Connection *connection,
     json_object_set_new (obj,
                          "link_enc",
                          TALER_json_from_data (ldl->link_data_enc->coin_priv_enc,
-                                               sizeof (union TALER_CoinSpendPrivateKeyP) +
+                                               sizeof (struct TALER_CoinSpendPrivateKeyP) +
                                                ldl->link_data_enc->blinding_key_enc_size));
     json_object_set_new (obj,
                          "denom_pub",
diff --git a/src/mint/taler-mint-httpd_responses.h b/src/mint/taler-mint-httpd_responses.h
index ab062c2a7..8392e73d7 100644
--- a/src/mint/taler-mint-httpd_responses.h
+++ b/src/mint/taler-mint-httpd_responses.h
@@ -200,7 +200,7 @@ TMH_RESPONSE_reply_invalid_json (struct MHD_Connection *connection);
  */
 int
 TMH_RESPONSE_reply_deposit_success (struct MHD_Connection *connection,
-                                    const union TALER_CoinSpendPublicKeyP *coin_pub,
+                                    const struct TALER_CoinSpendPublicKeyP *coin_pub,
                                     const struct GNUNET_HashCode *h_wire,
                                     const struct GNUNET_HashCode *h_contract,
                                     uint64_t transaction_id,
@@ -291,7 +291,7 @@ TMH_RESPONSE_reply_refresh_melt_success (struct MHD_Connection *connection,
  */
 int
 TMH_RESPONSE_reply_refresh_melt_insufficient_funds (struct MHD_Connection *connection,
-                                                    const union TALER_CoinSpendPublicKeyP *coin_pub,
+                                                    const struct TALER_CoinSpendPublicKeyP *coin_pub,
                                                     struct TALER_Amount coin_value,
                                                     struct TALER_MINTDB_TransactionList *tl,
                                                     struct TALER_Amount requested,
diff --git a/src/mint/taler-mint-httpd_test.c b/src/mint/taler-mint-httpd_test.c
index 6bf11c33e..22c13908e 100644
--- a/src/mint/taler-mint-httpd_test.c
+++ b/src/mint/taler-mint-httpd_test.c
@@ -24,7 +24,6 @@
 #include <jansson.h>
 #include <microhttpd.h>
 #include "taler_signatures.h"
-#include "taler_util.h"
 #include "taler-mint-httpd_test.h"
 #include "taler-mint-httpd_parsing.h"
 #include "taler-mint-httpd_responses.h"
@@ -297,97 +296,9 @@ TMH_TEST_handler_test_ecdhe (struct TMH_RequestHandler *rh,
 
 
 /**
- * Handle a "/test/ecdsa" request.  Parses the JSON in the post, 
- * which must contain a "ecdsa_pub" with a public key and an
- *"ecdsa_sig" with the corresponding signature for a purpose
- * of #TALER_SIGNATURE_CLIENT_TEST_ECDSA.  If the signature is
- * valid, a reply with a #TALER_SIGNATURE_MINT_TEST_ECDSA is 
- * returned using the same JSON format.
- *
- * @param rh context of the handler
- * @param connection the MHD connection to handle
- * @param[in,out] connection_cls the connection's closure (can be updated)
- * @param upload_data upload data
- * @param[in,out] upload_data_size number of bytes (left) in @a upload_data
- * @return MHD result code
-  */
-int
-TMH_TEST_handler_test_ecdsa (struct TMH_RequestHandler *rh,
-			     struct MHD_Connection *connection,
-			     void **connection_cls,
-			     const char *upload_data,
-			     size_t *upload_data_size)
-{
-  json_t *json;
-  int res;
-  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
-  struct GNUNET_CRYPTO_EcdsaSignature sig;
-  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
-  struct TMH_PARSE_FieldSpecification spec[] = {
-    TMH_PARSE_MEMBER_FIXED ("ecdsa_pub", &pub),
-    TMH_PARSE_MEMBER_FIXED ("ecdsa_sig", &sig),
-    TMH_PARSE_MEMBER_END
-  };
-  struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
-
-  res = TMH_PARSE_post_json (connection,
-                             connection_cls,
-                             upload_data,
-                             upload_data_size,
-                             &json);
-  if (GNUNET_SYSERR == res)
-    return MHD_NO;
-  if ( (GNUNET_NO == res) || (NULL == json) )
-    return MHD_YES;
-  res = TMH_PARSE_json_data (connection,
-			     json,
-			     spec);
-  json_decref (json);
-  if (GNUNET_YES != res)
-    return (GNUNET_NO == res) ? MHD_YES : MHD_NO;
-  purpose.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
-  purpose.purpose = htonl (TALER_SIGNATURE_CLIENT_TEST_ECDSA);
-  if (GNUNET_OK !=
-      GNUNET_CRYPTO_ecdsa_verify (TALER_SIGNATURE_CLIENT_TEST_ECDSA,
-				  &purpose,
-				  &sig,
-				  &pub))
-  {
-    TMH_PARSE_release_data (spec);
-    return TMH_RESPONSE_reply_signature_invalid (connection,
-						 "ecdsa_sig");
-  }
-  TMH_PARSE_release_data (spec);
-  pk = GNUNET_CRYPTO_ecdsa_key_create ();
-  purpose.purpose = htonl (TALER_SIGNATURE_MINT_TEST_ECDSA);
-  if (GNUNET_OK !=
-      GNUNET_CRYPTO_ecdsa_sign (pk,
-				&purpose,
-				&sig))
-  {
-    GNUNET_free (pk);
-    return TMH_RESPONSE_reply_internal_error (connection,
-					      "Failed to ECDSA-sign");
-  }
-  GNUNET_CRYPTO_ecdsa_key_get_public (pk,
-				      &pub);
-  GNUNET_free (pk);
-  return TMH_RESPONSE_reply_json_pack (connection,
-				       MHD_HTTP_OK,
-				       "{s:o, s:o}",
-				       "ecdsa_pub",
-				       TALER_json_from_data (&pub,
-							     sizeof (pub)),
-				       "ecdsa_sig",
-				       TALER_json_from_data (&sig,
-							     sizeof (sig)));
-}
-
-
-/**
  * Handle a "/test/eddsa" request.  Parses the JSON in the post, 
  * which must contain a "eddsa_pub" with a public key and an
- *"ecdsa_sig" with the corresponding signature for a purpose
+ *"eddsa_sig" with the corresponding signature for a purpose
  * of #TALER_SIGNATURE_CLIENT_TEST_EDDSA.  If the signature is
  * valid, a reply with a #TALER_SIGNATURE_MINT_TEST_EDDSA is 
  * returned using the same JSON format.
@@ -583,7 +494,7 @@ TMH_TEST_handler_test_transfer (struct TMH_RequestHandler *rh,
   int res;
   struct TALER_EncryptedLinkSecretP secret_enc;
   struct TALER_TransferPrivateKeyP trans_priv;
-  union TALER_CoinSpendPublicKeyP coin_pub;
+  struct TALER_CoinSpendPublicKeyP coin_pub;
   struct TMH_PARSE_FieldSpecification spec[] = {
     TMH_PARSE_MEMBER_FIXED ("secret_enc", &secret_enc),
     TMH_PARSE_MEMBER_FIXED ("trans_priv", &trans_priv),
diff --git a/src/mint/taler-mint-httpd_test.h b/src/mint/taler-mint-httpd_test.h
index e220e438a..1bc5fb66c 100644
--- a/src/mint/taler-mint-httpd_test.h
+++ b/src/mint/taler-mint-httpd_test.h
@@ -122,29 +122,6 @@ TMH_TEST_handler_test_ecdhe (struct TMH_RequestHandler *rh,
 
 
 /**
- * Handle a "/test/ecdsa" request.  Parses the JSON in the post, 
- * which must contain a "ecdsa_pub" with a public key and an
- *"ecdsa_sig" with the corresponding signature for a purpose
- * of #TALER_SIGNATURE_CLIENT_TEST_ECDSA.  If the signature is
- * valid, a reply with a #TALER_SIGNATURE_MINT_TEST_ECDSA is 
- * returned using the same JSON format.
- *
- * @param rh context of the handler
- * @param connection the MHD connection to handle
- * @param[in,out] connection_cls the connection's closure (can be updated)
- * @param upload_data upload data
- * @param[in,out] upload_data_size number of bytes (left) in @a upload_data
- * @return MHD result code
-  */
-int
-TMH_TEST_handler_test_ecdsa (struct TMH_RequestHandler *rh,
-			     struct MHD_Connection *connection,
-			     void **connection_cls,
-			     const char *upload_data,
-			     size_t *upload_data_size);
-
-
-/**
  * Handle a "/test/eddsa" request.  Parses the JSON in the post, 
  * which must contain a "eddsa_pub" with a public key and an
  *"ecdsa_sig" with the corresponding signature for a purpose
diff --git a/src/mintdb/mintdb_plugin.c b/src/mintdb/mintdb_plugin.c
index 4480e27c5..2e8d206fd 100644
--- a/src/mintdb/mintdb_plugin.c
+++ b/src/mintdb/mintdb_plugin.c
@@ -20,7 +20,6 @@
  * @author Sree Harsha Totakura <sreeharsha@totakura.in>
  */
 #include "platform.h"
-#include "taler_mintdb_lib.h"
 #include "taler_mintdb_plugin.h"
 #include <ltdl.h>
 
@@ -112,7 +111,7 @@ plugin_init ()
   opath = lt_dlgetsearchpath ();
   if (NULL != opath)
     old_dlsearchpath = GNUNET_strdup (opath);
-  path = TALER_os_installation_get_path (GNUNET_OS_IPK_LIBDIR);
+  path = TALER_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
   if (NULL != path)
   {
     if (NULL != opath)
diff --git a/src/mintdb/plugin_mintdb_postgres.c b/src/mintdb/plugin_mintdb_postgres.c
index 7d3a3e870..3800f03b2 100644
--- a/src/mintdb/plugin_mintdb_postgres.c
+++ b/src/mintdb/plugin_mintdb_postgres.c
@@ -23,7 +23,6 @@
  */
 #include "platform.h"
 #include "taler_pq_lib.h"
-#include "taler_signatures.h"
 #include "taler_mintdb_plugin.h"
 #include <pthread.h>
 #include <libpq-fe.h>
@@ -62,6 +61,12 @@
     PQclear (result); result = NULL;                                    \
   } while (0)
 
+#define SQLEXEC_IGNORE_ERROR_(conn, sql, result)                         \
+  do {                                                                  \
+    result = PQexec (conn, sql);                                        \
+    PQclear (result); result = NULL;                                    \
+  } while (0)
+
 
 /**
  * Handle for a database session (per-thread, for transactions).
@@ -172,6 +177,7 @@ postgres_create_tables (void *cls,
     return GNUNET_SYSERR;
   }
 #define SQLEXEC(sql) SQLEXEC_(conn, sql, result);
+#define SQLEXEC_INDEX(sql) SQLEXEC_IGNORE_ERROR_(conn, sql, result);
   /* Denomination table for holding the publicly available information of
      denominations keys.  The denominations are to be referred to by using
      foreign keys.  The denominations are deleted by a housekeeping tool;
@@ -216,15 +222,15 @@ postgres_create_tables (void *cls,
           ",balance_curr VARCHAR("TALER_CURRENCY_LEN_STR") NOT NULL"
           ",details VARCHAR NOT NULL "
           ",expiration_date INT8 NOT NULL"
-          " CONSTRAINT unique_details PRIMARY KEY (reserve_pub,details)"
+          ",PRIMARY KEY (reserve_pub,details)"
           ");");
   /* Create indices on reserves_in */
-  SQLEXEC ("CREATE INDEX reserves_in_reserve_pub_index"
-           " ON reserves_in (reserve_pub);");
-  SQLEXEC ("CREATE INDEX reserves_in_reserve_pub_details_index"
-           " ON reserves_in (reserve_pub,details);");
-  SQLEXEC ("CREATE INDEX expiration_index"
-           " ON reserves_in (expiration_date);");
+  SQLEXEC_INDEX ("CREATE INDEX reserves_in_reserve_pub_index"
+		 " ON reserves_in (reserve_pub);");
+  SQLEXEC_INDEX ("CREATE INDEX reserves_in_reserve_pub_details_index"
+		 " ON reserves_in (reserve_pub,details);");
+  SQLEXEC_INDEX ("CREATE INDEX expiration_index"
+		 " ON reserves_in (expiration_date);");
   /* Table with the withdraw operations that have been performed on a reserve.
      TODO: maybe rename to "reserves_out"?
      TODO: is blind_ev really a _primary key_? Is this constraint useful? */
@@ -237,8 +243,8 @@ postgres_create_tables (void *cls,
            ",reserve_sig BYTEA NOT NULL CHECK (LENGTH(reserve_sig)=64)"
            ");");
   /* Index blindcoins(reserve_pub) for get_reserves_blindcoins statement */
-  SQLEXEC ("CREATE INDEX collectable_blindcoins_reserve_pub_index ON"
-           " collectable_blindcoins (reserve_pub)");
+  SQLEXEC_INDEX ("CREATE INDEX collectable_blindcoins_reserve_pub_index ON"
+		 " collectable_blindcoins (reserve_pub)");
   /* Table with coins that have been (partially) spent, used to detect
      double-spending.
      TODO: maybe rename to "spent_coins"?
@@ -302,7 +308,7 @@ postgres_create_tables (void *cls,
           ")");
   SQLEXEC("CREATE TABLE IF NOT EXISTS refresh_melt"
           "("
-          " session_hash BYTEA NOT NULL CHECK(LENGTH(session_hash=64)) REFERENCES refresh_sessions (session_hash) "
+          " session_hash BYTEA NOT NULL CHECK(LENGTH(session_hash)=64) REFERENCES refresh_sessions (session_hash) "
           ",coin_pub BYTEA NOT NULL CHECK(LENGTH(coin_pub)=32) REFERENCES known_coins (coin_pub) "
           ",coin_sig BYTEA NOT NULL CHECK(LENGTH(coin_sig)=64)"
           ",denom_pub BYTEA NOT NULL "
@@ -421,10 +427,10 @@ postgres_prepare (PGconn *db_conn)
   PREPARE ("update_reserve",
            "UPDATE reserves "
            "SET"
-           "expiration_date=$1 "
+           " expiration_date=$1 "
            ",current_balance_val=$2 "
            ",current_balance_frac=$3 "
-           "WHERE current_balance_curr=$4 AND reserve_pub=$5 ",
+           "WHERE current_balance_curr=$4 AND reserve_pub=$5",
            5, NULL);
   PREPARE ("create_reserves_in_transaction",
            "INSERT INTO reserves_in ("
@@ -841,7 +847,7 @@ postgres_commit (void *cls,
  * Insert a denomination key
  *
  * @param cls the @e cls of this struct with the plugin-specific state
- * @param sesssion connection to use
+ * @param session connection to use
  * @param dki the denomination key information
  * @return #GNUNET_OK on success; #GNUNET_SYSERR on failure
  */
@@ -855,15 +861,15 @@ postgres_insert_denomination (void *cls,
   int ret;
 
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_RSA_PUBLIC_KEY (dki->denom_pub.rsa_public_key),
-    TALER_PQ_QUERY_PARAM_PTR (&issue->start.abs_value_us__),
-    TALER_PQ_QUERY_PARAM_PTR (&issue->expire_withdraw.abs_value_us__),
-    TALER_PQ_QUERY_PARAM_PTR (&issue->expire_spend.abs_value_us__),
-    TALER_PQ_QUERY_PARAM_PTR (&issue->expire_legal.abs_value_us__),
-    TALER_PQ_QUERY_PARAM_AMOUNT_NBO (&issue->value),
-    TALER_PQ_QUERY_PARAM_AMOUNT_NBO (&issue->fee_withdraw),
-    TALER_PQ_QUERY_PARAM_AMOUNT_NBO (&issue->fee_refresh),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_rsa_public_key (dki->denom_pub.rsa_public_key),
+    TALER_PQ_query_param_auto_from_type (&issue->start.abs_value_us__),
+    TALER_PQ_query_param_auto_from_type (&issue->expire_withdraw.abs_value_us__),
+    TALER_PQ_query_param_auto_from_type (&issue->expire_spend.abs_value_us__),
+    TALER_PQ_query_param_auto_from_type (&issue->expire_legal.abs_value_us__),
+    TALER_PQ_query_param_amount_nbo (&issue->value),
+    TALER_PQ_query_param_amount_nbo (&issue->fee_withdraw),
+    TALER_PQ_query_param_amount_nbo (&issue->fee_refresh),
+    TALER_PQ_query_param_end
   };
   result = TALER_PQ_exec_prepared (session->conn,
                                    "insert_denomination",
@@ -899,13 +905,13 @@ postgres_reserve_get (void *cls,
 {
   PGresult *result;
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(&reserve->pub),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type(&reserve->pub),
+    TALER_PQ_query_param_end
   };
   struct TALER_PQ_ResultSpec rs[] = {
-    TALER_PQ_RESULT_SPEC_AMOUNT("current_balance", &reserve->balance),
-    TALER_PQ_RESULT_SPEC_ABSOLUTE_TIME("expiration_date", &reserve->expiry),
-    TALER_PQ_RESULT_SPEC_END
+    TALER_PQ_result_spec_amount("current_balance", &reserve->balance),
+    TALER_PQ_result_spec_absolute_time("expiration_date", &reserve->expiry),
+    TALER_PQ_result_spec_end
   };
 
   result = TALER_PQ_exec_prepared (session->conn,
@@ -914,7 +920,7 @@ postgres_reserve_get (void *cls,
   if (PGRES_TUPLES_OK != PQresultStatus (result))
   {
     QUERY_ERR (result);
-    PQclear (resultE);
+    PQclear (result);
     return GNUNET_SYSERR;
   }
   if (0 == PQntuples (result))
@@ -955,10 +961,10 @@ postgres_reserves_update (void *cls,
   if (NULL == reserve)
     return GNUNET_SYSERR;
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_ABSOLUTE_TIME (reserve->expiry),
-    TALER_PQ_QUERY_PARAM_AMOUNT (&reserve->balance),
-    TALER_PQ_QUERY_PARAM_PTR (&reserve->pub),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_absolute_time (&reserve->expiry),
+    TALER_PQ_query_param_amount (&reserve->balance),
+    TALER_PQ_query_param_auto_from_type (&reserve->pub),
+    TALER_PQ_query_param_end
   };
   result = TALER_PQ_exec_prepared (session->conn,
                                    "update_reserve",
@@ -979,7 +985,8 @@ postgres_reserves_update (void *cls,
 
 /**
  * Insert a incoming transaction into reserves.  New reserves are also created
- * through this function.
+ * through this function.  Note that this API call starts (and stops) its
+ * own transaction scope (so the application must not do so).
  *
  * @param cls the `struct PostgresClosure` with the plugin-specific state
  * @param session the database connection handle
@@ -995,10 +1002,10 @@ postgres_reserves_update (void *cls,
 static int
 postgres_reserves_in_insert (void *cls,
                              struct TALER_MINTDB_Session *session,
-                             struct TALER_ReservePublicKeyP *reserve_pub,
+                             const struct TALER_ReservePublicKeyP *reserve_pub,
                              const struct TALER_Amount *balance,
                              const char *details,
-                             const struct GNUNET_TIME_Absolute expiry)
+                             struct GNUNET_TIME_Absolute expiry)
 {
   PGresult *result;
   int reserve_exists;
@@ -1018,19 +1025,18 @@ postgres_reserves_in_insert (void *cls,
                                          &reserve);
   if (GNUNET_SYSERR == reserve_exists)
   {
-    postgres_rollback (cls,
-                       session);
-    return GNUNET_SYSERR;
+    GNUNET_break (0);
+    goto rollback;
   }
   if (GNUNET_NO == reserve_exists)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Reserve does not exist; creating a new one\n");
     struct TALER_PQ_QueryParam params[] = {
-      TALER_PQ_QUERY_PARAM_PTR (reserve_pub),
-      TALER_PQ_QUERY_PARAM_AMOUNT (balance),
-      TALER_PQ_QUERY_PARAM_ABSOLUTE_TIME (expiry),
-      TALER_PQ_QUERY_PARAM_END
+      TALER_PQ_query_param_auto_from_type (reserve_pub),
+      TALER_PQ_query_param_amount (balance),
+      TALER_PQ_query_param_absolute_time (&expiry),
+      TALER_PQ_query_param_end
     };
     result = TALER_PQ_exec_prepared (session->conn,
                                      "create_reserve",
@@ -1044,11 +1050,11 @@ postgres_reserves_in_insert (void *cls,
   else
   {
     /* Update reserve */
-    updated_reserve.pub = reserve->pub;
+    updated_reserve.pub = reserve.pub;
 
     if (GNUNET_OK !=
         TALER_amount_add (&updated_reserve.balance,
-                          &reserve->balance,
+                          &reserve.balance,
                           balance))
     {
       /* currency overflow or incompatible currency */
@@ -1057,7 +1063,7 @@ postgres_reserves_in_insert (void *cls,
       goto rollback;
     }
     updated_reserve.expiry = GNUNET_TIME_absolute_max (expiry,
-                                                       reserve->expiry);
+                                                       reserve.expiry);
 
   }
   if (NULL != result)
@@ -1066,17 +1072,32 @@ postgres_reserves_in_insert (void *cls,
   /* create new incoming transaction, SQL "primary key" logic
      is used to guard against duplicates! */
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR (&reserve->pub),
-    TALER_PQ_QUERY_PARAM_AMOUNT (balance),
-    TALER_PQ_QUERY_PARAM_PTR_SIZED (details, strlen (details)),
-    TALER_PQ_QUERY_PARAM_ABSOLUTE_TIME (expiry),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type (&reserve.pub),
+    TALER_PQ_query_param_amount (balance),
+    TALER_PQ_query_param_fixed_size (details, strlen (details)),
+    TALER_PQ_query_param_absolute_time (&expiry),
+    TALER_PQ_query_param_end
   };
   result = TALER_PQ_exec_prepared (session->conn,
                                    "create_reserves_in_transaction",
                                    params);
   if (PGRES_COMMAND_OK != PQresultStatus(result))
   {
+    const char *efield;
+    
+    efield = PQresultErrorField (result,
+				 PG_DIAG_SQLSTATE);
+    if ( (PGRES_FATAL_ERROR == PQresultStatus(result)) &&
+	 (NULL != strstr ("23505", /* unique violation */
+			  efield)) )
+    {
+      /* This means we had the same reserve/justification/details
+	 before */
+      PQclear (result);
+      postgres_rollback (cls,
+			 session);
+      return GNUNET_NO;
+    }
     QUERY_ERR (result);
     goto rollback;
   }
@@ -1121,8 +1142,8 @@ postgres_get_collectable_blindcoin (void *cls,
 {
   PGresult *result;
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR (h_blind),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type (h_blind),
+    TALER_PQ_query_param_end
   };
   struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub;
   struct GNUNET_CRYPTO_rsa_Signature *denom_sig;
@@ -1144,11 +1165,11 @@ postgres_get_collectable_blindcoin (void *cls,
     goto cleanup;
   }
   struct TALER_PQ_ResultSpec rs[] = {
-    TALER_PQ_RESULT_SPEC_RSA_PUBLIC_KEY("denom_pub", &denom_pub),
-    TALER_PQ_RESULT_SPEC_RSA_SIGNATURE("denom_sig", &denom_sig),
-    TALER_PQ_RESULT_SPEC("reserve_sig", &collectable->reserve_sig),
-    TALER_PQ_RESULT_SPEC("reserve_pub", &collectable->reserve_pub),
-    TALER_PQ_RESULT_SPEC_END
+    TALER_PQ_result_spec_rsa_public_key("denom_pub", &denom_pub),
+    TALER_PQ_result_spec_rsa_signature("denom_sig", &denom_sig),
+    TALER_PQ_result_spec_auto_from_type("reserve_sig", &collectable->reserve_sig),
+    TALER_PQ_result_spec_auto_from_type("reserve_pub", &collectable->reserve_pub),
+    TALER_PQ_result_spec_end
   };
 
   if (GNUNET_OK != TALER_PQ_extract_result (result, rs, 0))
@@ -1194,12 +1215,12 @@ postgres_insert_collectable_blindcoin (void *cls,
   struct TALER_MINTDB_Reserve reserve;
   int ret = GNUNET_SYSERR;
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR (h_blind),
-    TALER_PQ_QUERY_PARAM_RSA_PUBLIC_KEY (collectable->denom_pub.rsa_public_key),
-    TALER_PQ_QUERY_PARAM_RSA_SIGNATURE (collectable->sig.rsa_signature),
-    TALER_PQ_QUERY_PARAM_PTR (&collectable->reserve_pub),
-    TALER_PQ_QUERY_PARAM_PTR (&collectable->reserve_sig),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type (h_blind),
+    TALER_PQ_query_param_rsa_public_key (collectable->denom_pub.rsa_public_key),
+    TALER_PQ_query_param_rsa_signature (collectable->sig.rsa_signature),
+    TALER_PQ_query_param_auto_from_type (&collectable->reserve_pub),
+    TALER_PQ_query_param_auto_from_type (&collectable->reserve_sig),
+    TALER_PQ_query_param_end
   };
 
   if (GNUNET_OK != postgres_start (cls,
@@ -1272,8 +1293,8 @@ postgres_get_reserve_history (void *cls,
   {
     struct TALER_MINTDB_BankTransfer *bt;
     struct TALER_PQ_QueryParam params[] = {
-      TALER_PQ_QUERY_PARAM_PTR (reserve_pub),
-      TALER_PQ_QUERY_PARAM_END
+      TALER_PQ_query_param_auto_from_type (reserve_pub),
+      TALER_PQ_query_param_end
     };
 
     result = TALER_PQ_exec_prepared (session->conn,
@@ -1329,8 +1350,8 @@ postgres_get_reserve_history (void *cls,
     struct GNUNET_CRYPTO_rsa_Signature *denom_sig;
 
     struct TALER_PQ_QueryParam params[] = {
-      TALER_PQ_QUERY_PARAM_PTR (reserve_pub),
-      TALER_PQ_QUERY_PARAM_END
+      TALER_PQ_query_param_auto_from_type (reserve_pub),
+      TALER_PQ_query_param_end
     };
     result = TALER_PQ_exec_prepared (session->conn,
                                      "get_reserves_blindcoins",
@@ -1346,11 +1367,11 @@ postgres_get_reserve_history (void *cls,
       goto cleanup;
     }
     struct TALER_PQ_ResultSpec rs[] = {
-      TALER_PQ_RESULT_SPEC ("blind_ev", &blind_ev),
-      TALER_PQ_RESULT_SPEC_RSA_PUBLIC_KEY ("denom_pub", &denom_pub),
-      TALER_PQ_RESULT_SPEC_RSA_SIGNATURE ("denom_sig", &denom_sig),
-      TALER_PQ_RESULT_SPEC ("reserve_sig", &reserve_sig),
-      TALER_PQ_RESULT_SPEC_END
+      TALER_PQ_result_spec_auto_from_type ("blind_ev", &blind_ev),
+      TALER_PQ_result_spec_rsa_public_key ("denom_pub", &denom_pub),
+      TALER_PQ_result_spec_rsa_signature ("denom_sig", &denom_sig),
+      TALER_PQ_result_spec_auto_from_type ("reserve_sig", &reserve_sig),
+      TALER_PQ_result_spec_end
     };
     GNUNET_assert (NULL != rh);
     GNUNET_assert (NULL != rh_head);
@@ -1405,10 +1426,10 @@ postgres_have_deposit (void *cls,
                        const struct TALER_MINTDB_Deposit *deposit)
 {
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR (&deposit->coin.coin_pub),
-    TALER_PQ_QUERY_PARAM_PTR (&deposit->transaction_id),
-    TALER_PQ_QUERY_PARAM_PTR (&deposit->merchant_pub),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type (&deposit->coin.coin_pub),
+    TALER_PQ_query_param_auto_from_type (&deposit->transaction_id),
+    TALER_PQ_query_param_auto_from_type (&deposit->merchant_pub),
+    TALER_PQ_query_param_end
   };
   PGresult *result;
   int ret;
@@ -1458,18 +1479,18 @@ postgres_insert_deposit (void *cls,
   ret = GNUNET_SYSERR;
   json_wire_enc = json_dumps (deposit->wire, JSON_COMPACT);
   struct TALER_PQ_QueryParam params[]= {
-    TALER_PQ_QUERY_PARAM_PTR (&deposit->coin.coin_pub),
-    TALER_PQ_QUERY_PARAM_RSA_PUBLIC_KEY (deposit->coin.denom_pub.rsa_public_key),
-    TALER_PQ_QUERY_PARAM_RSA_SIGNATURE (deposit->coin.denom_sig.rsa_signature),
-    TALER_PQ_QUERY_PARAM_PTR (&deposit->transaction_id),
-    TALER_PQ_QUERY_PARAM_AMOUNT (&deposit->amount_with_fee),
-    TALER_PQ_QUERY_PARAM_PTR (&deposit->merchant_pub),
-    TALER_PQ_QUERY_PARAM_PTR (&deposit->h_contract),
-    TALER_PQ_QUERY_PARAM_PTR (&deposit->h_wire),
-    TALER_PQ_QUERY_PARAM_PTR (&deposit->csig),
-    TALER_PQ_QUERY_PARAM_PTR_SIZED (json_wire_enc,
+    TALER_PQ_query_param_auto_from_type (&deposit->coin.coin_pub),
+    TALER_PQ_query_param_rsa_public_key (deposit->coin.denom_pub.rsa_public_key),
+    TALER_PQ_query_param_rsa_signature (deposit->coin.denom_sig.rsa_signature),
+    TALER_PQ_query_param_auto_from_type (&deposit->transaction_id),
+    TALER_PQ_query_param_amount (&deposit->amount_with_fee),
+    TALER_PQ_query_param_auto_from_type (&deposit->merchant_pub),
+    TALER_PQ_query_param_auto_from_type (&deposit->h_contract),
+    TALER_PQ_query_param_auto_from_type (&deposit->h_wire),
+    TALER_PQ_query_param_auto_from_type (&deposit->csig),
+    TALER_PQ_query_param_fixed_size (json_wire_enc,
                                     strlen (json_wire_enc)),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_end
   };
   result = TALER_PQ_exec_prepared (session->conn, "insert_deposit", params);
   if (PGRES_COMMAND_OK != PQresultStatus (result))
@@ -1505,8 +1526,8 @@ postgres_get_refresh_session (void *cls,
 {
   PGresult *result;
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(session_hash),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type(session_hash),
+    TALER_PQ_query_param_end
   };
   int ret;
   uint16_t num_oldcoins;
@@ -1537,10 +1558,10 @@ postgres_get_refresh_session (void *cls,
   }
   memset (refresh_session, 0, sizeof (struct TALER_MINTDB_RefreshSession));
   struct TALER_PQ_ResultSpec rs[] = {
-    TALER_PQ_RESULT_SPEC("num_oldcoins", &num_oldcoins),
-    TALER_PQ_RESULT_SPEC("num_newcoins", &num_newcoins),
-    TALER_PQ_RESULT_SPEC("noreveal_index", &noreveal_index),
-    TALER_PQ_RESULT_SPEC_END
+    TALER_PQ_result_spec_auto_from_type("num_oldcoins", &num_oldcoins),
+    TALER_PQ_result_spec_auto_from_type("num_newcoins", &num_newcoins),
+    TALER_PQ_result_spec_auto_from_type("noreveal_index", &noreveal_index),
+    TALER_PQ_result_spec_end
   };
   if (GNUNET_OK != TALER_PQ_extract_result (result, rs, 0))
   {
@@ -1580,11 +1601,11 @@ postgres_create_refresh_session (void *cls,
   uint16_t num_newcoins;
   uint16_t noreveal_index;
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(session_hash),
-    TALER_PQ_QUERY_PARAM_PTR(&num_oldcoins),
-    TALER_PQ_QUERY_PARAM_PTR(&num_newcoins),
-    TALER_PQ_QUERY_PARAM_PTR(&noreveal_index),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type(session_hash),
+    TALER_PQ_query_param_auto_from_type(&num_oldcoins),
+    TALER_PQ_query_param_auto_from_type(&num_newcoins),
+    TALER_PQ_query_param_auto_from_type(&noreveal_index),
+    TALER_PQ_query_param_end
   };
   num_oldcoins = htons (refresh_session->num_oldcoins);
   num_newcoins = htons (refresh_session->num_newcoins);
@@ -1626,11 +1647,11 @@ postgres_insert_refresh_melt (void *cls,
 
   {
     struct TALER_PQ_QueryParam params[] = {
-      TALER_PQ_QUERY_PARAM_PTR(&melt->session_hash),
-      TALER_PQ_QUERY_PARAM_PTR(&oldcoin_index_nbo),
-      TALER_PQ_QUERY_PARAM_PTR(&melt->coin.coin_pub),
-      TALER_PQ_QUERY_PARAM_RSA_PUBLIC_KEY(melt->coin.denom_pub.rsa_public_key),
-      TALER_PQ_QUERY_PARAM_END
+      TALER_PQ_query_param_auto_from_type(&melt->session_hash),
+      TALER_PQ_query_param_auto_from_type(&oldcoin_index_nbo),
+      TALER_PQ_query_param_auto_from_type(&melt->coin.coin_pub),
+      TALER_PQ_query_param_rsa_public_key(melt->coin.denom_pub.rsa_public_key),
+      TALER_PQ_query_param_end
     };
     result = TALER_PQ_exec_prepared (session->conn,
                                      "insert_refresh_melt",
@@ -1669,18 +1690,18 @@ postgres_get_refresh_melt (void *cls,
   // FIXME: check logic!
   uint16_t oldcoin_index_nbo = htons (oldcoin_index);
   struct TALER_PQ_Query params[] = {
-    TALER_PQ_QUERY_PARAM_PTR (session_hash),
-    TALER_PQ_QUERY_PARAM_PTR (&oldcoin_index_nbo),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type (session_hash),
+    TALER_PQ_query_param_auto_from_type (&oldcoin_index_nbo),
+    TALER_PQ_query_param_end
   };
   struct TALER_PQ_ResultSpec rs[] = {
-    TALER_PQ_RESULT_SPEC ("coin_pub", &melt->coin),
-    TALER_PQ_RESULT_SPEC ("coin_sig", &melt->coin_sig),
-    TALER_PQ_RESULT_SPEC ("denom_pub", &melt->coin),
-    TALER_PQ_RESULT_SPEC ("denom_sig", &melt->coin),
-    TALER_PQ_RESULT_SPEC_AMOUNT ("amount", melt->amount_with_fee),
-    TALER_PQ_RESULT_SPEC_AMOUNT ("fee", melt->melt_fee),
-    TALER_PQ_RESULT_SPEC_END
+    TALER_PQ_result_spec_auto_from_type ("coin_pub", &melt->coin),
+    TALER_PQ_result_spec_auto_from_type ("coin_sig", &melt->coin_sig),
+    TALER_PQ_result_spec_auto_from_type ("denom_pub", &melt->coin),
+    TALER_PQ_result_spec_auto_from_type ("denom_sig", &melt->coin),
+    TALER_PQ_result_spec_amount ("amount", melt->amount_with_fee),
+    TALER_PQ_result_spec_amount ("fee", melt->melt_fee),
+    TALER_PQ_result_spec_end
   };
 
   result = TALER_PQ_exec_prepared (session->conn,
@@ -1730,10 +1751,10 @@ postgres_insert_refresh_order (void *cls,
 
   {
     struct TALER_PQ_QueryParam params[] = {
-      TALER_PQ_QUERY_PARAM_PTR (&newcoin_index_nbo),
-      TALER_PQ_QUERY_PARAM_PTR (session_hash),
-      TALER_PQ_QUERY_PARAM_RSA_PUBLIC_KEY (denom_pubs->rsa_public_key),
-      TALER_PQ_QUERY_PARAM_END
+      TALER_PQ_query_param_auto_from_type (&newcoin_index_nbo),
+      TALER_PQ_query_param_auto_from_type (session_hash),
+      TALER_PQ_query_param_rsa_public_key (denom_pubs->rsa_public_key),
+      TALER_PQ_query_param_end
     };
     result = TALER_PQ_exec_prepared (session->conn,
                                      "insert_refresh_order",
@@ -1778,9 +1799,9 @@ postgres_get_refresh_order (void *cls,
   uint16_t newcoin_index_nbo = htons (num_newcoins);
 
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(session_hash),
-    TALER_PQ_QUERY_PARAM_PTR(&newcoin_index_nbo),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type(session_hash),
+    TALER_PQ_query_param_auto_from_type(&newcoin_index_nbo),
+    TALER_PQ_query_param_end
   };
 
   PGresult *result = TALER_PQ_exec_prepared (session->conn,
@@ -1801,8 +1822,8 @@ postgres_get_refresh_order (void *cls,
   }
   GNUNET_assert (1 == PQntuples (result));
   struct TALER_PQ_ResultSpec rs[] = {
-    TALER_PQ_RESULT_SPEC_RSA_PUBLIC_KEY ("denom_pub", &denom_pubs->rsa_public_key),
-    TALER_PQ_RESULT_SPEC_END
+    TALER_PQ_result_spec_rsa_public_key ("denom_pub", &denom_pubs->rsa_public_key),
+    TALER_PQ_result_spec_end
   };
   if (GNUNET_OK != TALER_PQ_extract_result (result, rs, 0))
   {
@@ -1841,14 +1862,14 @@ postgres_insert_refresh_commit_coins (void *cls,
   uint16_t cnc_index_nbo = htons (i);
   uint16_t newcoin_index_nbo = htons (num_newcoins);
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(session_hash),
-    TALER_PQ_QUERY_PARAM_PTR_SIZED(commit_coins->coin_ev, commit_coins->coin_ev_size),
-    TALER_PQ_QUERY_PARAM_PTR(&cnc_index_nbo),
-    TALER_PQ_QUERY_PARAM_PTR(&newcoin_index_nbo),
-    TALER_PQ_QUERY_PARAM_PTR_SIZED (commit_coins->refresh_link->coin_priv_enc,
+    TALER_PQ_query_param_auto_from_type(session_hash),
+    TALER_PQ_query_param_fixed_size(commit_coins->coin_ev, commit_coins->coin_ev_size),
+    TALER_PQ_query_param_auto_from_type(&cnc_index_nbo),
+    TALER_PQ_query_param_auto_from_type(&newcoin_index_nbo),
+    TALER_PQ_query_param_fixed_size (commit_coins->refresh_link->coin_priv_enc,
                                     commit_coins->refresh_link->blinding_key_enc_size +
-                                    sizeof (union TALER_CoinSpendPrivateKeyP)),
-    TALER_PQ_QUERY_PARAM_END
+                                    sizeof (struct TALER_CoinSpendPrivateKeyP)),
+    TALER_PQ_query_param_end
   };
 
   PGresult *result = TALER_PQ_exec_prepared (session->conn,
@@ -1899,10 +1920,10 @@ postgres_get_refresh_commit_coins (void *cls,
   uint16_t cnc_index_nbo = htons (cnc_index);
   uint16_t newcoin_index_nbo = htons (newcoin_index);
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(session_hash),
-    TALER_PQ_QUERY_PARAM_PTR(&cnc_index_nbo),
-    TALER_PQ_QUERY_PARAM_PTR(&newcoin_index_nbo),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type(session_hash),
+    TALER_PQ_query_param_auto_from_type(&cnc_index_nbo),
+    TALER_PQ_query_param_auto_from_type(&newcoin_index_nbo),
+    TALER_PQ_query_param_end
   };
   void *c_buf;
   size_t c_buf_size;
@@ -1928,9 +1949,9 @@ postgres_get_refresh_commit_coins (void *cls,
   }
 
   struct TALER_PQ_ResultSpec rs[] = {
-    TALER_PQ_RESULT_SPEC_VAR("coin_ev", &c_buf, &c_buf_size),
-    TALER_PQ_RESULT_SPEC_VAR("link_vector_enc", &rl_buf, &rl_buf_size),
-    TALER_PQ_RESULT_SPEC_END
+    TALER_PQ_result_spec_variable_size("coin_ev", &c_buf, &c_buf_size),
+    TALER_PQ_result_spec_variable_size("link_vector_enc", &rl_buf, &rl_buf_size),
+    TALER_PQ_result_spec_end
   };
   if (GNUNET_YES != TALER_PQ_extract_result (result, rs, 0))
   {
@@ -1938,7 +1959,7 @@ postgres_get_refresh_commit_coins (void *cls,
     return GNUNET_SYSERR;
   }
   PQclear (result);
-  if (rl_buf_size < sizeof (union TALER_CoinSpendPrivateKeyP))
+  if (rl_buf_size < sizeof (struct TALER_CoinSpendPrivateKeyP))
   {
     GNUNET_free (c_buf);
     GNUNET_free (rl_buf);
@@ -1978,12 +1999,12 @@ postgres_insert_refresh_commit_links (void *cls,
   uint16_t cnc_index_nbo = htons (i);
   uint16_t oldcoin_index_nbo = htons (j);
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(session_hash),
-    TALER_PQ_QUERY_PARAM_PTR(&commit_link->transfer_pub),
-    TALER_PQ_QUERY_PARAM_PTR(&cnc_index_nbo),
-    TALER_PQ_QUERY_PARAM_PTR(&oldcoin_index_nbo),
-    TALER_PQ_QUERY_PARAM_PTR(&commit_link->shared_secret_enc),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type(session_hash),
+    TALER_PQ_query_param_auto_from_type(&commit_link->transfer_pub),
+    TALER_PQ_query_param_auto_from_type(&cnc_index_nbo),
+    TALER_PQ_query_param_auto_from_type(&oldcoin_index_nbo),
+    TALER_PQ_query_param_auto_from_type(&commit_link->shared_secret_enc),
+    TALER_PQ_query_param_end
   };
 
   PGresult *result = TALER_PQ_exec_prepared (session->conn,
@@ -2034,10 +2055,10 @@ postgres_get_refresh_commit_links (void *cls,
   uint16_t oldcoin_index_nbo = htons (num_links);
 
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(session_hash),
-    TALER_PQ_QUERY_PARAM_PTR(&cnc_index_nbo),
-    TALER_PQ_QUERY_PARAM_PTR(&oldcoin_index_nbo),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type(session_hash),
+    TALER_PQ_query_param_auto_from_type(&cnc_index_nbo),
+    TALER_PQ_query_param_auto_from_type(&oldcoin_index_nbo),
+    TALER_PQ_query_param_end
   };
 
   PGresult *result = TALER_PQ_exec_prepared (session->conn,
@@ -2057,9 +2078,9 @@ postgres_get_refresh_commit_links (void *cls,
   }
 
   struct TALER_PQ_ResultSpec rs[] = {
-    TALER_PQ_RESULT_SPEC("transfer_pub", &links->transfer_pub),
-    TALER_PQ_RESULT_SPEC("link_secret_enc", &links->shared_secret_enc),
-    TALER_PQ_RESULT_SPEC_END
+    TALER_PQ_result_spec_auto_from_type("transfer_pub", &links->transfer_pub),
+    TALER_PQ_result_spec_auto_from_type("link_secret_enc", &links->shared_secret_enc),
+    TALER_PQ_result_spec_end
   };
 
   if (GNUNET_YES != TALER_PQ_extract_result (result, rs, 0))
@@ -2077,14 +2098,14 @@ postgres_get_refresh_commit_links (void *cls,
  * Get all of the information from the given melt commit operation.
  *
  * @param cls the @e cls of this struct with the plugin-specific state
- * @param sesssion database connection to use
+ * @param session database connection to use
  * @param session_hash hash to identify refresh session
  * @return NULL if the @a session_hash does not correspond to any known melt
  *         operation
  */
 static struct TALER_MINTDB_MeltCommitment *
 postgres_get_melt_commitment (void *cls,
-                              struct TALER_MINTDB_Session *sesssion,
+                              struct TALER_MINTDB_Session *session,
                               const struct GNUNET_HashCode *session_hash)
 {
   // FIXME: needs to be implemented!
@@ -2145,10 +2166,10 @@ postgres_insert_refresh_collectable (void *cls,
 
   {
     struct TALER_PQ_QueryParam params[] = {
-      TALER_PQ_QUERY_PARAM_PTR(session_hash),
-      TALER_PQ_QUERY_PARAM_PTR(&newcoin_index_nbo),
-      TALER_PQ_QUERY_PARAM_RSA_SIGNATURE(ev_sig->rsa_signature),
-      TALER_PQ_QUERY_PARAM_END
+      TALER_PQ_query_param_auto_from_type(session_hash),
+      TALER_PQ_query_param_auto_from_type(&newcoin_index_nbo),
+      TALER_PQ_query_param_rsa_signature(ev_sig->rsa_signature),
+      TALER_PQ_query_param_end
     };
     result = TALER_PQ_exec_prepared (session->conn,
                                      "insert_refresh_collectable",
@@ -2177,14 +2198,14 @@ postgres_insert_refresh_collectable (void *cls,
 static struct TALER_MINTDB_LinkDataList *
 postgres_get_link_data_list (void *cls,
                              struct TALER_MINTDB_Session *session,
-                             const union TALER_CoinSpendPublicKeyP *coin_pub)
+                             const struct TALER_CoinSpendPublicKeyP *coin_pub)
 {
   // FIXME: check logic!
   struct TALER_MINTDB_LinkDataList *ldl;
   struct TALER_MINTDB_LinkDataList *pos;
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(coin_pub),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type(coin_pub),
+    TALER_PQ_query_param_end
   };
   PGresult *result = TALER_PQ_exec_prepared (session->conn, "get_link", params);
 
@@ -2211,10 +2232,10 @@ postgres_get_link_data_list (void *cls,
     void *ld_buf;
     size_t ld_buf_size;
     struct TALER_PQ_ResultSpec rs[] = {
-      TALER_PQ_RESULT_SPEC_VAR("link_vector_enc", &ld_buf, &ld_buf_size),
-      TALER_PQ_RESULT_SPEC_RSA_PUBLIC_KEY("denom_pub", &denom_pub),
-      TALER_PQ_RESULT_SPEC_RSA_SIGNATURE("ev_sig", &sig),
-      TALER_PQ_RESULT_SPEC_END
+      TALER_PQ_result_spec_variable_size("link_vector_enc", &ld_buf, &ld_buf_size),
+      TALER_PQ_result_spec_rsa_public_key("denom_pub", &denom_pub),
+      TALER_PQ_result_spec_rsa_signature("ev_sig", &sig),
+      TALER_PQ_result_spec_end
     };
 
     if (GNUNET_OK != TALER_PQ_extract_result (result, rs, i))
@@ -2225,7 +2246,7 @@ postgres_get_link_data_list (void *cls,
                                   ldl);
       return NULL;
     }
-    if (ld_buf_size < sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))
+    if (ld_buf_size < sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey))
     {
       PQclear (result);
       GNUNET_free (ld_buf);
@@ -2235,9 +2256,9 @@ postgres_get_link_data_list (void *cls,
     }
     // FIXME: use util API for this!
     link_enc = GNUNET_malloc (sizeof (struct TALER_RefreshLinkEncrypted) +
-                              ld_buf_size - sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
+                              ld_buf_size - sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
     link_enc->blinding_key_enc = (const char *) &link_enc[1];
-    link_enc->blinding_key_enc_size = ld_buf_size - sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
+    link_enc->blinding_key_enc_size = ld_buf_size - sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey);
     memcpy (link_enc->coin_priv_enc,
             ld_buf,
             ld_buf_size);
@@ -2271,14 +2292,14 @@ postgres_get_link_data_list (void *cls,
 static int
 postgres_get_transfer (void *cls,
                        struct TALER_MINTDB_Session *session,
-                       const union TALER_CoinSpendPublicKeyP *coin_pub,
+                       const struct TALER_CoinSpendPublicKeyP *coin_pub,
                        struct TALER_TransferPublicKeyP *transfer_pub,
                        struct TALER_EncryptedLinkSecretP *shared_secret_enc)
 {
   // FIXME: check logic!
   struct TALER_PQ_QueryParam params[] = {
-    TALER_PQ_QUERY_PARAM_PTR(coin_pub),
-    TALER_PQ_QUERY_PARAM_END
+    TALER_PQ_query_param_auto_from_type(coin_pub),
+    TALER_PQ_query_param_end
   };
 
   PGresult *result = TALER_PQ_exec_prepared (session->conn, "get_transfer", params);
@@ -2306,9 +2327,9 @@ postgres_get_transfer (void *cls,
   }
 
   struct TALER_PQ_ResultSpec rs[] = {
-    TALER_PQ_RESULT_SPEC("transfer_pub", transfer_pub),
-    TALER_PQ_RESULT_SPEC("link_secret_enc", shared_secret_enc),
-    TALER_PQ_RESULT_SPEC_END
+    TALER_PQ_result_spec_auto_from_type("transfer_pub", transfer_pub),
+    TALER_PQ_result_spec_auto_from_type("link_secret_enc", shared_secret_enc),
+    TALER_PQ_result_spec_end
   };
 
   if (GNUNET_OK != TALER_PQ_extract_result (result, rs, 0))
@@ -2335,7 +2356,7 @@ postgres_get_transfer (void *cls,
 static struct TALER_MINTDB_TransactionList *
 postgres_get_coin_transactions (void *cls,
                                 struct TALER_MINTDB_Session *session,
-                                const union TALER_CoinSpendPublicKeyP *coin_pub)
+                                const struct TALER_CoinSpendPublicKeyP *coin_pub)
 {
   PGresult *result;
   struct TALER_MINTDB_TransactionList *head;
@@ -2353,8 +2374,8 @@ postgres_get_coin_transactions (void *cls,
   {
     struct TALER_MINTDB_Deposit *deposit;
     struct TALER_PQ_QueryParam params[] = {
-      TALER_PQ_QUERY_PARAM_PTR (&coin_pub->ecdsa_pub),
-      TALER_PQ_QUERY_PARAM_END
+      TALER_PQ_query_param_auto_from_type (&coin_pub->eddsa_pub),
+      TALER_PQ_query_param_end
     };
     json_error_t json_error;
     void *json_wire_enc;
@@ -2373,19 +2394,19 @@ postgres_get_coin_transactions (void *cls,
     {
       deposit = GNUNET_new (struct TALER_MINTDB_Deposit);
       struct TALER_PQ_ResultSpec rs[] = {
-        TALER_PQ_RESULT_SPEC ("coin_pub", &deposit->coin),
-        TALER_PQ_RESULT_SPEC ("coin_sig", &deposit->csig),
-        TALER_PQ_RESULT_SPEC ("merchant_pub", &deposit->merchant_pub),
-        TALER_PQ_RESULT_SPEC ("h_contract", &deposit->h_contract),
-        TALER_PQ_RESULT_SPEC ("h_wire", &deposit->h_wire),
-        TALER_PQ_RESULT_SPEC_VAR ("wire", &json_wire_enc, &json_wire_enc_size),
-        TALER_PQ_RESULT_SPEC ("transaction_id", &deposit->transaction_id),
+        TALER_PQ_result_spec_auto_from_type ("coin_pub", &deposit->coin),
+        TALER_PQ_result_spec_auto_from_type ("coin_sig", &deposit->csig),
+        TALER_PQ_result_spec_auto_from_type ("merchant_pub", &deposit->merchant_pub),
+        TALER_PQ_result_spec_auto_from_type ("h_contract", &deposit->h_contract),
+        TALER_PQ_result_spec_auto_from_type ("h_wire", &deposit->h_wire),
+        TALER_PQ_result_spec_variable_size ("wire", &json_wire_enc, &json_wire_enc_size),
+        TALER_PQ_result_spec_auto_from_type ("transaction_id", &deposit->transaction_id),
         /**  FIXME:
-         * TALER_PQ_RESULT_SPEC ("timestamp", &deposit->timestamp),
-         * TALER_PQ_RESULT_SPEC ("refund_deadline", &deposit->refund_deadline),
+         * TALER_PQ_result_spec_auto_from_type ("timestamp", &deposit->timestamp),
+         * TALER_PQ_result_spec_auto_from_type ("refund_deadline", &deposit->refund_deadline),
          * TALER_PQ_RESULT_AMOUNT_NBO ("deposit_fee", &deposit->deposit_fee)
          */
-        TALER_PQ_RESULT_SPEC_END
+        TALER_PQ_result_spec_end
       };
       if ((GNUNET_OK != TALER_PQ_extract_result (result, rs, i)) ||
 	  (GNUNET_OK != TALER_PQ_extract_amount (result,
diff --git a/src/mintdb/test-mint-db-postgres.conf b/src/mintdb/test-mint-db-postgres.conf
index a5a738e49..07f8a0e58 100644
--- a/src/mintdb/test-mint-db-postgres.conf
+++ b/src/mintdb/test-mint-db-postgres.conf
@@ -3,4 +3,4 @@
 DB = postgres
 
 #The connection string the plugin has to use for connecting to the database
-DB_CONN_STR = postgres:///taler
+DB_CONN_STR = postgres:///talercheck
diff --git a/src/mintdb/test_mintdb.c b/src/mintdb/test_mintdb.c
index a35809e3e..212e763bc 100644
--- a/src/mintdb/test_mintdb.c
+++ b/src/mintdb/test_mintdb.c
@@ -127,7 +127,6 @@ run (void *cls,
 {
   struct TALER_MINTDB_Session *session;
   struct TALER_ReservePublicKeyP reserve_pub;
-  struct TALER_MINTDB_Reserve reserve;
   struct GNUNET_TIME_Absolute expiry;
   struct TALER_Amount amount;
   struct DenomKeyPair *dkp;
@@ -178,7 +177,6 @@ run (void *cls,
     goto drop;
   }
   RND_BLK (&reserve_pub);
-  reserve.pub = reserve_pub;
   amount.value = 1;
   amount.fraction = 1;
   strcpy (amount.currency, CURRENCY);
@@ -188,8 +186,9 @@ run (void *cls,
   FAILIF (GNUNET_OK !=
           plugin->reserves_in_insert (plugin->cls,
                                       session,
-                                      &reserve,
+                                      &reserve_pub,
                                       &amount,
+				      "justification 1",
                                       expiry));
   FAILIF (GNUNET_OK !=
           check_reserve (session,
@@ -201,8 +200,9 @@ run (void *cls,
   FAILIF (GNUNET_OK !=
           plugin->reserves_in_insert (plugin->cls,
                                       session,
-                                      &reserve,
+                                      &reserve_pub,
                                       &amount,
+				      "justification 2",
                                       expiry));
   FAILIF (GNUNET_OK !=
           check_reserve (session,
diff --git a/src/pq/db_pq.c b/src/pq/db_pq.c
index 72a9370ed..a718c805f 100644
--- a/src/pq/db_pq.c
+++ b/src/pq/db_pq.c
@@ -60,6 +60,7 @@ TALER_PQ_exec_prepared (PGconn *db_conn,
       break;
     case TALER_PQ_QF_RSA_PUBLIC_KEY:
     case TALER_PQ_QF_RSA_SIGNATURE:
+    case TALER_PQ_QF_TIME_ABSOLUTE:
       len++;
       break;
     default:
@@ -67,6 +68,7 @@ TALER_PQ_exec_prepared (PGconn *db_conn,
       GNUNET_assert (0);
       break;
     }
+    i++;
   }
 
   /* new scope to allow stack allocation without alloca */
@@ -111,7 +113,7 @@ TALER_PQ_exec_prepared (PGconn *db_conn,
           param_formats[off] = 1;
           off++;
           param_values[off] = (void *) amount->currency;
-          param_lengths[off] = strlen (amount->currency) + 1;
+          param_lengths[off] = strlen (amount->currency);
           param_formats[off] = 1;
           off++;
         }
@@ -134,7 +136,7 @@ TALER_PQ_exec_prepared (PGconn *db_conn,
           param_formats[off] = 1;
           off++;
           param_values[off] = (void *) amount->currency;
-          param_lengths[off] = strlen (amount->currency) + 1;
+          param_lengths[off] = strlen (amount->currency);
           param_formats[off] = 1;
           off++;
         }
@@ -176,8 +178,6 @@ TALER_PQ_exec_prepared (PGconn *db_conn,
 	  
           at_nbo = GNUNET_new (struct GNUNET_TIME_AbsoluteNBO);
           scratch[soff++] = at_nbo;
-	  /* FIXME: this does not work for 'forever' as PQ uses 63-bit integers;
-	     should check and handle! (Need testcase!) */
           *at_nbo = GNUNET_TIME_absolute_hton (*at_hbo);
           param_values[off] = (void *) at_nbo;
           param_lengths[off] = sizeof (struct GNUNET_TIME_AbsoluteNBO);
@@ -190,6 +190,7 @@ TALER_PQ_exec_prepared (PGconn *db_conn,
         GNUNET_assert (0);
         break;
       }
+      i++;
     }
     GNUNET_assert (off == len);
     res = PQexecPrepared (db_conn,
@@ -200,7 +201,7 @@ TALER_PQ_exec_prepared (PGconn *db_conn,
                           param_formats,
                           1);
     for (off = 0; off < soff; off++)
-      GNUNET_free (scratch[soff]);
+      GNUNET_free (scratch[off]);
     return res;
   }
 }
@@ -222,25 +223,34 @@ TALER_PQ_cleanup_result (struct TALER_PQ_ResultSpec *rs)
     switch (rs[i].format)
     {
     case TALER_PQ_RF_VARSIZE_BLOB:
-      if (NULL != rs[i].dst)
       {
-        GNUNET_free (rs[i].dst);
-        rs[i].dst = NULL;
-        *rs[i].result_size = 0;
+	void **dst = rs[i].dst;
+	if (NULL != *dst)
+	{
+	  GNUNET_free (*dst);
+	  *dst = NULL;
+	  *rs[i].result_size = 0;
+	}
+	break;
       }
-      break;
     case TALER_PQ_RF_RSA_PUBLIC_KEY:
-      if (NULL != rs[i].dst)
       {
-        GNUNET_CRYPTO_rsa_public_key_free (rs[i].dst);
-        rs[i].dst = NULL;
+	void **dst = rs[i].dst;
+	if (NULL != *dst)
+	{
+	  GNUNET_CRYPTO_rsa_public_key_free (*dst);
+	  *dst = NULL;
+	}
+	break;
       }
-      break;
     case TALER_PQ_RF_RSA_SIGNATURE:
-      if (NULL != rs[i].dst)
       {
-        GNUNET_CRYPTO_rsa_signature_free (rs[i].dst);
-        rs[i].dst = NULL;
+	void **dst = rs[i].dst;
+	if (NULL != *dst)
+	{
+	  GNUNET_CRYPTO_rsa_signature_free (*dst);
+	  *dst = NULL;
+	}
       }
       break;
     default:
@@ -256,7 +266,7 @@ TALER_PQ_cleanup_result (struct TALER_PQ_ResultSpec *rs)
  * is returned.
  *
  * @param result result to process
- * @param[in|out] rs result specification to extract for
+ * @param[in,out] rs result specification to extract for
  * @param row row from the result to extract
  * @return
  *   #GNUNET_YES if all results could be extracted
@@ -525,8 +535,6 @@ TALER_PQ_extract_result (PGresult *result,
 	  PQgetvalue (result,
 		      row,
 		      fnum);
-	/* FIXME: this does not work for 'forever' as PQ uses 63-bit integers;
-	   should check and handle! (Need testcase!) */
 	*dst = GNUNET_TIME_absolute_ntoh (*res);
         break;
       }
diff --git a/src/pq/pq_helper.c b/src/pq/pq_helper.c
new file mode 100644
index 000000000..5da1ced41
--- /dev/null
+++ b/src/pq/pq_helper.c
@@ -0,0 +1,214 @@
+/*
+  This file is part of TALER
+  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
+  Foundation; either version 3, or (at your option) any later version.
+
+  TALER is distributed in the hope that it will be useful, but WITHOUT ANY
+  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License along with
+  TALER; see the file COPYING.  If not, If not, see <http://www.gnu.org/licenses/>
+*/
+/**
+ * @file pq/pq_helper.c
+ * @brief functions to initialize parameter arrays 
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include <gnunet/gnunet_util_lib.h>
+#include "taler_pq_lib.h"
+
+
+/**
+ * Generate query parameter for a currency, consisting of the three
+ * components "value", "fraction" and "currency" in this order. The
+ * types must be a 64-bit integer, 32-bit integer and a
+ * #TALER_CURRENCY_LEN-sized BLOB/VARCHAR respectively.
+ *
+ * @param x pointer to the query parameter to pass
+ * @return array entry for the query parameters to use
+ */
+struct TALER_PQ_QueryParam
+TALER_PQ_query_param_amount_nbo (const struct TALER_AmountNBO *x)
+{
+  struct TALER_PQ_QueryParam res =
+    { TALER_PQ_QF_AMOUNT_NBO, x, sizeof (*x) };
+  return res;
+}
+	    
+
+/**
+ * Generate query parameter for a currency, consisting of the three
+ * components "value", "fraction" and "currency" in this order. The
+ * types must be a 64-bit integer, 32-bit integer and a
+ * #TALER_CURRENCY_LEN-sized BLOB/VARCHAR respectively.
+ *
+ * @param x pointer to the query parameter to pass
+ * @return array entry for the query parameters to use
+ */
+struct TALER_PQ_QueryParam
+TALER_PQ_query_param_amount (const struct TALER_Amount *x)
+{
+  struct TALER_PQ_QueryParam res =
+    { TALER_PQ_QF_AMOUNT, x, sizeof (*x) };
+  return res;
+}
+
+
+/**
+ * Generate query parameter for an RSA public key.  The
+ * database must contain a BLOB type in the respective position.
+ *
+ * @param x the query parameter to pass
+ * @return array entry for the query parameters to use
+ */
+struct TALER_PQ_QueryParam
+TALER_PQ_query_param_rsa_public_key (const struct GNUNET_CRYPTO_rsa_PublicKey *x)
+{
+  struct TALER_PQ_QueryParam res =
+    { TALER_PQ_QF_RSA_PUBLIC_KEY, (x), 0 };
+  return res;
+}
+
+
+/**
+ * Generate query parameter for an RSA signature.  The
+ * database must contain a BLOB type in the respective position.
+ *
+ * @param x the query parameter to pass
+ * @return array entry for the query parameters to use
+ */
+struct TALER_PQ_QueryParam
+TALER_PQ_query_param_rsa_signature (const struct GNUNET_CRYPTO_rsa_Signature *x)
+{
+  struct TALER_PQ_QueryParam res =
+    { TALER_PQ_QF_RSA_SIGNATURE, (x), 0 };
+  return res;
+}
+
+
+/**
+ * Generate query parameter for an absolute time value.
+ * The database must store a 64-bit integer.
+ *
+ * @param x pointer to the query parameter to pass
+ * @return array entry for the query parameters to use
+ */
+struct TALER_PQ_QueryParam
+TALER_PQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x)
+{
+  struct TALER_PQ_QueryParam res =
+    { TALER_PQ_QF_TIME_ABSOLUTE, x, sizeof (*x) };
+  return res;
+}
+
+
+/**
+ * Variable-size result expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] dst where to store the result, allocated
+ * @param[out] sptr where to store the size of @a dst
+ * @return array entry for the result specification to use
+ */
+struct TALER_PQ_ResultSpec
+TALER_PQ_result_spec_variable_size (const char *name,
+			  void **dst,
+			  size_t *sptr)
+{
+  struct TALER_PQ_ResultSpec res = 
+    { TALER_PQ_RF_VARSIZE_BLOB, (void *) (dst), 0, name, sptr };
+  return res;
+}
+
+
+/**
+ * Currency amount expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] amount where to store the result
+ * @return array entry for the result specification to use
+ */
+struct TALER_PQ_ResultSpec
+TALER_PQ_result_spec_amount_nbo (const char *name,
+				 struct TALER_AmountNBO *amount)
+{
+  struct TALER_PQ_ResultSpec res = 
+    {TALER_PQ_RF_AMOUNT_NBO, (void *) amount, sizeof (*amount), name, NULL };
+  return res;
+}
+
+
+/**
+ * Currency amount expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] amount where to store the result
+ * @return array entry for the result specification to use
+ */
+struct TALER_PQ_ResultSpec
+TALER_PQ_result_spec_amount (const char *name,
+			     struct TALER_Amount *amount)
+{
+  struct TALER_PQ_ResultSpec res = 
+    {TALER_PQ_RF_AMOUNT, (void *) amount, sizeof (*amount), name, NULL };
+  return res;
+}
+
+
+/**
+ * RSA public key expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] rsa where to store the result
+ * @return array entry for the result specification to use
+ */
+struct TALER_PQ_ResultSpec
+TALER_PQ_result_spec_rsa_public_key (const char *name,
+				     struct GNUNET_CRYPTO_rsa_PublicKey **rsa)
+{
+  struct TALER_PQ_ResultSpec res = 
+    {TALER_PQ_RF_RSA_PUBLIC_KEY, (void *) rsa, 0, name, NULL };
+  return res;
+}
+ 
+
+/**
+ * RSA signature expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] sig where to store the result;
+ * @return array entry for the result specification to use
+ */
+struct TALER_PQ_ResultSpec
+TALER_PQ_result_spec_rsa_signature (const char *name,
+				    struct GNUNET_CRYPTO_rsa_Signature **sig)
+{
+  struct TALER_PQ_ResultSpec res = 
+    {TALER_PQ_RF_RSA_SIGNATURE, (void *) sig, 0, (name), NULL };
+  return res;
+}
+
+  
+/**
+ * Absolute time expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] at where to store the result
+ * @return array entry for the result specification to use
+ */
+struct TALER_PQ_ResultSpec
+TALER_PQ_result_spec_absolute_time (const char *name,
+				    struct GNUNET_TIME_Absolute *at)
+{
+  struct TALER_PQ_ResultSpec res = 
+    {TALER_PQ_RF_TIME_ABSOLUTE, (void *) at, sizeof (*at), (name), NULL };
+  return res;
+}
+  
+
+/* end of pq_helper.c */
diff --git a/src/pq/test_pq.c b/src/pq/test_pq.c
index 2d56e11e7..ff89e29f3 100644
--- a/src/pq/test_pq.c
+++ b/src/pq/test_pq.c
@@ -60,9 +60,10 @@ postgres_prepare (PGconn *db_conn)
            ",namount_val" 
            ",namount_frac"
            ",namount_curr"
+           ",vsize"
            ") VALUES "
            "($1, $2, $3, $4, $5, $6,"
-            "$7, $8, $9, $10, $11);",
+            "$7, $8, $9, $10, $11, $12);",
            11, NULL);
   PREPARE ("test_select",
            "SELECT"
@@ -77,9 +78,10 @@ postgres_prepare (PGconn *db_conn)
            ",namount_val" 
            ",namount_frac"
            ",namount_curr"
-           "FROM test_pq"
-           "ORDER BY abs_time DESC "
-           "LIMIT 1;",
+	   ",vsize"
+           " FROM test_pq"
+           " ORDER BY abs_time DESC "
+           " LIMIT 1;",
            0, NULL);
   return GNUNET_OK;
 #undef PREPARE
@@ -108,47 +110,119 @@ run_queries (PGconn *conn)
   struct TALER_Amount hamount2;
   struct TALER_AmountNBO namount;
   struct TALER_AmountNBO namount2;
-  struct TALER_PQ_QueryParam params_insert[] = {
-    TALER_PQ_QUERY_PARAM_RSA_PUBLIC_KEY (pub),
-    TALER_PQ_QUERY_PARAM_RSA_SIGNATURE (sig),
-    TALER_PQ_QUERY_PARAM_ABSOLUTE_TIME (abs_time),
-    TALER_PQ_QUERY_PARAM_ABSOLUTE_TIME (forever),
-    TALER_PQ_QUERY_PARAM_PTR (&hc),
-    TALER_PQ_QUERY_PARAM_AMOUNT (hamount),
-    TALER_PQ_QUERY_PARAM_AMOUNT_NBO (namount),
-    TALER_PQ_QUERY_PARAM_END
-  };
-  struct TALER_PQ_QueryParam params_select[] = {
-    TALER_PQ_QUERY_PARAM_END
-  };
-  struct TALER_PQ_ResultSpec results_select[] = {
-    TALER_PQ_RESULT_SPEC_RSA_PUBLIC_KEY ("pub", pub2),
-    TALER_PQ_RESULT_SPEC_RSA_SIGNATURE ("sig", sig2),
-    TALER_PQ_RESULT_SPEC_ABSOLUTE_TIME ("abs_time", abs_time2),
-    TALER_PQ_RESULT_SPEC_ABSOLUTE_TIME ("forever", forever2),
-    TALER_PQ_RESULT_SPEC ("hash", &hc2),
-    TALER_PQ_RESULT_SPEC_AMOUNT ("hamount", hamount2),
-    TALER_PQ_RESULT_SPEC_AMOUNT_NBO ("namount", namount2),
-    TALER_PQ_RESULT_SPEC_END
-  };
   PGresult *result;
   int ret;
+  struct GNUNET_CRYPTO_rsa_PrivateKey *priv;
+  char msg[] = "Hello";
+  void *msg2;
+  size_t msg2_len;
+  
+  priv = GNUNET_CRYPTO_rsa_private_key_create (1024);
+  pub = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
+  sig = GNUNET_CRYPTO_rsa_sign (priv,
+				msg,
+				sizeof (msg));
+  TALER_string_to_amount ("EUR:5.5",
+			  &hamount);
+  TALER_amount_hton (&namount,
+		     &hamount);		     
+  TALER_string_to_amount ("EUR:4.4",
+			  &hamount);
+  /* FIXME: test TALER_PQ_result_spec_variable_size */
+  {
+    struct TALER_PQ_QueryParam params_insert[] = {
+      TALER_PQ_query_param_rsa_public_key (pub),
+      TALER_PQ_query_param_rsa_signature (sig),
+      TALER_PQ_query_param_absolute_time (&abs_time),
+      TALER_PQ_query_param_absolute_time (&forever),
+      TALER_PQ_query_param_auto_from_type (&hc),
+      TALER_PQ_query_param_amount (&hamount),
+      TALER_PQ_query_param_amount_nbo (&namount),
+      TALER_PQ_query_param_fixed_size (msg, strlen (msg)),
+      TALER_PQ_query_param_end
+    };
+    struct TALER_PQ_QueryParam params_select[] = {
+      TALER_PQ_query_param_end
+    };
+    struct TALER_PQ_ResultSpec results_select[] = {
+      TALER_PQ_result_spec_rsa_public_key ("pub", &pub2),
+      TALER_PQ_result_spec_rsa_signature ("sig", &sig2),
+      TALER_PQ_result_spec_absolute_time ("abs_time", &abs_time2),
+      TALER_PQ_result_spec_absolute_time ("forever", &forever2),
+      TALER_PQ_result_spec_auto_from_type ("hash", &hc2),
+      TALER_PQ_result_spec_amount ("hamount", &hamount2),
+      TALER_PQ_result_spec_amount_nbo ("namount", &namount2),
+      TALER_PQ_result_spec_variable_size ("vsize", &msg2, &msg2_len),
+      TALER_PQ_result_spec_end
+    };
+    
+    result = TALER_PQ_exec_prepared (conn,
+				     "test_insert",
+				     params_insert);
+    if (PGRES_COMMAND_OK != PQresultStatus (result))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+		  "Database failure: %s\n",
+		  PQresultErrorMessage (result));
+      PQclear (result);
+      GNUNET_CRYPTO_rsa_signature_free (sig);
+      GNUNET_CRYPTO_rsa_private_key_free (priv);
+      GNUNET_CRYPTO_rsa_public_key_free (pub);
+      return 1;
+    }
+    
+    PQclear (result);
+    result = TALER_PQ_exec_prepared (conn,
+				     "test_select",
+				     params_select);
+    if (1 !=
+	PQntuples (result))
+    {
+      GNUNET_break (0);
+      PQclear (result);
+      GNUNET_CRYPTO_rsa_signature_free (sig);
+      GNUNET_CRYPTO_rsa_private_key_free (priv);
+      GNUNET_CRYPTO_rsa_public_key_free (pub);
+      return 1;
+    }
+    ret = TALER_PQ_extract_result (result,
+				   results_select,
+				   0);
+    GNUNET_break (GNUNET_YES == ret);
+    GNUNET_break (abs_time.abs_value_us == abs_time2.abs_value_us);
+    GNUNET_break (forever.abs_value_us == forever2.abs_value_us);
+    GNUNET_break (0 ==
+		  memcmp (&hc,
+			  &hc2,
+			  sizeof (struct GNUNET_HashCode)));
+    GNUNET_break (0 ==
+		  TALER_amount_cmp (&hamount,
+				    &hamount2));
+    TALER_string_to_amount ("EUR:5.5",
+			    &hamount);
+    TALER_amount_ntoh (&hamount2,
+		       &namount2);		         
+    GNUNET_break (0 ==
+		  TALER_amount_cmp (&hamount,
+				    &hamount2));
+    GNUNET_break (0 ==
+		  GNUNET_CRYPTO_rsa_signature_cmp (sig,
+						   sig2));
+    GNUNET_break (0 ==
+		  GNUNET_CRYPTO_rsa_public_key_cmp (pub,
+						    pub2));
+    GNUNET_break (strlen (msg) == msg2_len);
+    GNUNET_break (0 ==
+		  strncmp (msg,
+			   msg2,
+			   msg2_len));
 
-  // FIXME: init pub, sig
-  result = TALER_PQ_exec_prepared (conn,
-				   "test_insert",
-				   params_insert);
-  PQclear (result);
-  result = TALER_PQ_exec_prepared (conn,
-				   "test_select",
-				   params_select);
-  ret = TALER_PQ_extract_result (result,
-				 results_select,
-				 0);
-  // FIXME: cmp results!
-  TALER_PQ_cleanup_result (results_select);
-  PQclear (result);
-
+    TALER_PQ_cleanup_result (results_select);
+    PQclear (result);
+  }
+  GNUNET_CRYPTO_rsa_signature_free (sig);
+  GNUNET_CRYPTO_rsa_private_key_free (priv);
+  GNUNET_CRYPTO_rsa_public_key_free (pub);
   if (GNUNET_OK != ret)
     return 1;
   
@@ -164,8 +238,10 @@ main(int argc,
   PGresult *result;
   int ret;
 
-  // FIXME: pass valid connect string for tests...
-  conn = PQconnectdb ("");
+  GNUNET_log_setup ("test-pq",
+		    "WARNING",
+		    NULL);
+  conn = PQconnectdb ("postgres:///talercheck");
   if (CONNECTION_OK != PQstatus (conn))
   {
     fprintf (stderr,
@@ -177,7 +253,7 @@ main(int argc,
   }
 
   result = PQexec (conn,
-		   "CREATE TABLE test_pq ("
+		   "CREATE TEMPORARY TABLE IF NOT EXISTS test_pq ("
 		   " pub BYTEA NOT NULL"
 		   ",sig BYTEA NOT NULL"
 		   ",abs_time INT8 NOT NULL"
@@ -189,6 +265,7 @@ main(int argc,
 		   ",namount_val INT8 NOT NULL"
 		   ",namount_frac INT4 NOT NULL"
 		   ",namount_curr VARCHAR("TALER_CURRENCY_LEN_STR") NOT NULL"
+		   ",vsize VARCHAR NOT NULL"
 		   ")");
   if (PGRES_COMMAND_OK != PQresultStatus (result))
   {
@@ -204,7 +281,6 @@ main(int argc,
       postgres_prepare (conn))
   {
     GNUNET_break (0);
-    PQclear (result);
     PQfinish (conn);
     return 1;
   }
diff --git a/src/util/crypto.c b/src/util/crypto.c
index 562377e37..6e78259eb 100644
--- a/src/util/crypto.c
+++ b/src/util/crypto.c
@@ -50,7 +50,7 @@ fatal_error_handler (void *cls,
 /**
  * Initialize libgcrypt.
  */
-void
+void  __attribute__ ((constructor))
 TALER_gcrypt_init ()
 {
   gcry_set_fatalerror_handler (&fatal_error_handler,
@@ -219,7 +219,7 @@ TALER_refresh_decrypt (const struct TALER_RefreshLinkEncrypted *input,
   ret = GNUNET_new (struct TALER_RefreshLinkDecrypted);
   memcpy (&ret->coin_priv,
           buf,
-          sizeof (union TALER_CoinSpendPrivateKeyP));
+          sizeof (struct TALER_CoinSpendPrivateKeyP));
   ret->blinding_key.rsa_blinding_key
     = GNUNET_CRYPTO_rsa_blinding_key_decode (&buf[sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)],
                                              input->blinding_key_enc_size);
@@ -295,7 +295,7 @@ TALER_refresh_link_encrypted_decode (const char *buf,
 {
   struct TALER_RefreshLinkEncrypted *rle;
 
-  if (buf_len < sizeof (union TALER_CoinSpendPrivateKeyP))
+  if (buf_len < sizeof (struct TALER_CoinSpendPrivateKeyP))
     return NULL;
   if (buf_len >= GNUNET_MAX_MALLOC_CHECKED)
   {
@@ -303,9 +303,9 @@ TALER_refresh_link_encrypted_decode (const char *buf,
     return NULL;
   }
   rle = GNUNET_malloc (sizeof (struct TALER_RefreshLinkEncrypted) +
-                       buf_len - sizeof (union TALER_CoinSpendPrivateKeyP));
+                       buf_len - sizeof (struct TALER_CoinSpendPrivateKeyP));
   rle->blinding_key_enc = (const char *) &rle[1];
-  rle->blinding_key_enc_size = buf_len - sizeof (union TALER_CoinSpendPrivateKeyP);
+  rle->blinding_key_enc_size = buf_len - sizeof (struct TALER_CoinSpendPrivateKeyP);
   memcpy (rle->coin_priv_enc,
           buf,
           buf_len);
@@ -326,12 +326,12 @@ TALER_refresh_link_encrypted_encode (const struct TALER_RefreshLinkEncrypted *rl
 {
   char *buf;
 
-  if (rle->blinding_key_enc_size >= GNUNET_MAX_MALLOC_CHECKED - sizeof (union TALER_CoinSpendPrivateKeyP))
+  if (rle->blinding_key_enc_size >= GNUNET_MAX_MALLOC_CHECKED - sizeof (struct TALER_CoinSpendPrivateKeyP))
   {
     GNUNET_break (0);
     return NULL;
   }
-  *buf_len = sizeof (union TALER_CoinSpendPrivateKeyP) + rle->blinding_key_enc_size;
+  *buf_len = sizeof (struct TALER_CoinSpendPrivateKeyP) + rle->blinding_key_enc_size;
   buf = GNUNET_malloc (*buf_len);
   memcpy (buf,
 	  rle->coin_priv_enc,
@@ -376,7 +376,7 @@ TALER_test_coin_valid (const struct TALER_CoinPublicInfo *coin_public_info)
  * private key and the coin's public key.
  *
  * @param secret_enc encrypted link secret
- * @param transfer_priv transfer private key
+ * @param trans_priv transfer private key
  * @param coin_pub coin public key
  * @param[out] secret set to the shared secret
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
@@ -384,15 +384,15 @@ TALER_test_coin_valid (const struct TALER_CoinPublicInfo *coin_public_info)
 int
 TALER_link_decrypt_secret (const struct TALER_EncryptedLinkSecretP *secret_enc,
 			   const struct TALER_TransferPrivateKeyP *trans_priv,
-			   const union TALER_CoinSpendPublicKeyP *coin_pub,
+			   const struct TALER_CoinSpendPublicKeyP *coin_pub,
 			   struct TALER_LinkSecretP *secret)
 {
   struct TALER_TransferSecretP transfer_secret;
 
   if (GNUNET_OK !=
-      GNUNET_CRYPTO_ecc_ecdh (&trans_priv->ecdhe_priv,
-			      &coin_pub->ecdhe_pub,
-			      &transfer_secret.key))
+      GNUNET_CRYPTO_ecdh_eddsa (&trans_priv->ecdhe_priv,
+				&coin_pub->eddsa_pub,
+				&transfer_secret.key))
   {
     GNUNET_break (0);
     return GNUNET_SYSERR;
@@ -415,7 +415,7 @@ TALER_link_decrypt_secret (const struct TALER_EncryptedLinkSecretP *secret_enc,
  * public key and the coin's private key.
  *
  * @param secret_enc encrypted link secret
- * @param transfer_pub transfer public key
+ * @param trans_pub transfer public key
  * @param coin_priv coin private key
  * @param[out] secret set to the shared secret
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
@@ -423,15 +423,15 @@ TALER_link_decrypt_secret (const struct TALER_EncryptedLinkSecretP *secret_enc,
 int
 TALER_link_decrypt_secret2 (const struct TALER_EncryptedLinkSecretP *secret_enc,
 			    const struct TALER_TransferPublicKeyP *trans_pub,
-			    const union TALER_CoinSpendPrivateKeyP *coin_priv,
+			    const struct TALER_CoinSpendPrivateKeyP *coin_priv,
 			    struct TALER_LinkSecretP *secret)
 {
   struct TALER_TransferSecretP transfer_secret;
 
   if (GNUNET_OK !=
-      GNUNET_CRYPTO_ecc_ecdh (&coin_priv->ecdhe_priv,
-			      &trans_pub->ecdhe_pub,
-			      &transfer_secret.key))
+      GNUNET_CRYPTO_eddsa_ecdh (&coin_priv->eddsa_priv,
+				&trans_pub->ecdhe_pub,
+				&transfer_secret.key))
   {
     GNUNET_break (0);
     return GNUNET_SYSERR;
@@ -454,14 +454,14 @@ TALER_link_decrypt_secret2 (const struct TALER_EncryptedLinkSecretP *secret_enc,
  *
  * @param secret link secret to encrypt
  * @param coin_pub coin public key
- * @param transfer_priv[out] set to transfer private key
- * @param transfer_pub[out] set to transfer public key
+ * @param[out] trans_priv set to transfer private key
+ * @param[out] trans_pub set to transfer public key
  * @param[out] secret_enc set to the encryptd @a secret
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
 TALER_link_encrypt_secret (const struct TALER_LinkSecretP *secret,
-			   const union TALER_CoinSpendPublicKeyP *coin_pub,
+			   const struct TALER_CoinSpendPublicKeyP *coin_pub,
 			   struct TALER_TransferPrivateKeyP *trans_priv,
 			   struct TALER_TransferPublicKeyP *trans_pub,
 			   struct TALER_EncryptedLinkSecretP *secret_enc)
@@ -471,9 +471,9 @@ TALER_link_encrypt_secret (const struct TALER_LinkSecretP *secret,
 
   pk = GNUNET_CRYPTO_ecdhe_key_create ();
   if (GNUNET_OK !=
-      GNUNET_CRYPTO_ecc_ecdh (pk,
-			      &coin_pub->ecdhe_pub,
-			      &transfer_secret.key))
+      GNUNET_CRYPTO_ecdh_eddsa (pk,
+				&coin_pub->eddsa_pub,
+				&transfer_secret.key))
   {
     GNUNET_break (0);
     GNUNET_free (pk);
diff --git a/src/util/json.c b/src/util/json.c
index 1cc04fe83..34e41e0d7 100644
--- a/src/util/json.c
+++ b/src/util/json.c
@@ -21,7 +21,6 @@
 #include "platform.h"
 #include <gnunet/gnunet_util_lib.h>
 #include "taler_util.h"
-#include "taler_json_lib.h"
 
 /**
  * Shorthand for exit jumps.
@@ -84,6 +83,9 @@ TALER_json_from_abs (struct GNUNET_TIME_Absolute stamp)
   json_t *j;
   char *mystr;
   int ret;
+
+  if (stamp.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
+    return json_string ("never");
   ret = GNUNET_asprintf (&mystr,
                          "%llu",
                          (long long) (stamp.abs_value_us / (1000 * 1000)));
@@ -129,58 +131,94 @@ TALER_json_from_eddsa_sig (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpo
 
 
 /**
- * Convert a signature (with purpose) to a JSON object representation.
+ * Convert RSA public key to JSON.
  *
- * @param purpose purpose of the signature
- * @param signature the signature
- * @return the JSON reporesentation of the signature with purpose
+ * @param pk public key to convert
+ * @return corresponding JSON encoding
  */
 json_t *
-TALER_json_from_ecdsa_sig (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
-                           const struct GNUNET_CRYPTO_EcdsaSignature *signature)
+TALER_json_from_rsa_public_key (struct GNUNET_CRYPTO_rsa_PublicKey *pk)
 {
-  json_t *root;
-  json_t *el;
-
-  root = json_object ();
-
-  el = json_integer ((json_int_t) ntohl (purpose->size));
-  json_object_set_new (root, "size", el);
+  char *buf;
+  size_t buf_len;
+  json_t *ret;
 
-  el = json_integer ((json_int_t) ntohl (purpose->purpose));
-  json_object_set_new (root, "purpose", el);
+  buf_len = GNUNET_CRYPTO_rsa_public_key_encode (pk,
+                                                 &buf);
+  ret = TALER_json_from_data (buf,
+                              buf_len);
+  GNUNET_free (buf);
+  return ret;
+}
 
-  el = TALER_json_from_data (purpose,
-                             ntohl (purpose->size));
-  json_object_set_new (root, "ecdsa_val", el);
 
-  el = TALER_json_from_data (signature,
-                             sizeof (struct GNUNET_CRYPTO_EddsaSignature));
-  json_object_set_new (root, "ecdsa_sig", el);
+/**
+ * Convert JSON to RSA public key.
+ *
+ * @param pk JSON encoding to convert 
+ * @return corresponding public key
+ */
+struct GNUNET_CRYPTO_rsa_PublicKey *
+TALER_json_to_rsa_public_key (json_t *json)
+{
+  const char *enc;
+  char *buf;
+  size_t len;
+  size_t buf_len;
+  struct GNUNET_CRYPTO_rsa_PublicKey *pk;
 
-  return root;
+  buf = NULL;
+  EXITIF (NULL == (enc = json_string_value (json)));
+  len = strlen (enc);
+  buf_len =  (len * 5) / 8;
+  buf = GNUNET_malloc (buf_len);
+  EXITIF (GNUNET_OK != 
+	  GNUNET_STRINGS_string_to_data (enc, 
+					 len, 
+					 buf, 
+					 buf_len));
+  EXITIF (NULL == (pk = GNUNET_CRYPTO_rsa_public_key_decode (buf,
+							     buf_len)));
+  GNUNET_free (buf);
+  return pk;
+ EXITIF_exit:
+  GNUNET_free_non_null (buf);
+  return NULL;
 }
 
 
 /**
- * Convert RSA public key to JSON.
+ * Convert JSON to RSA signature.
  *
- * @param pk public key to convert
- * @return corresponding JSON encoding
+ * @param pk JSON encoding to convert 
+ * @return corresponding signature
  */
-json_t *
-TALER_json_from_rsa_public_key (struct GNUNET_CRYPTO_rsa_PublicKey *pk)
+struct GNUNET_CRYPTO_rsa_Signature *
+TALER_json_to_rsa_signature (json_t *json)
 {
+  const char *enc;
   char *buf;
+  size_t len;
   size_t buf_len;
-  json_t *ret;
+  struct GNUNET_CRYPTO_rsa_Signature *sig;
 
-  buf_len = GNUNET_CRYPTO_rsa_public_key_encode (pk,
-                                                 &buf);
-  ret = TALER_json_from_data (buf,
-                              buf_len);
+  buf = NULL;
+  EXITIF (NULL == (enc = json_string_value (json)));
+  len = strlen (enc);
+  buf_len =  (len * 5) / 8;
+  buf = GNUNET_malloc (buf_len);
+  EXITIF (GNUNET_OK != 
+	  GNUNET_STRINGS_string_to_data (enc, 
+					 len, 
+					 buf, 
+					 buf_len));
+  EXITIF (NULL == (sig = GNUNET_CRYPTO_rsa_signature_decode (buf,
+							     buf_len)));
   GNUNET_free (buf);
-  return ret;
+  return sig;
+ EXITIF_exit:
+  GNUNET_free_non_null (buf);
+  return NULL;
 }
 
 
@@ -229,20 +267,6 @@ TALER_json_from_data (const void *data,
 
 
 /**
- * Convert binary hash to a JSON string with the base32crockford
- * encoding.
- *
- * @param hc binary data
- * @return json string that encodes @a hc
- */
-json_t *
-TALER_json_from_hash (const struct GNUNET_HashCode *hc)
-{
-  return TALER_json_from_data (hc, sizeof (struct GNUNET_HashCode));
-}
-
-
-/**
  * Parse given JSON object to Amount
  *
  * @param json the json object representing Amount
@@ -262,10 +286,13 @@ TALER_json_to_amount (json_t *json,
                                       &error,
                                       JSON_STRICT,
                                       "{s:s, s:I, s:I}",
-                                      "curreny", &currency,
+                                      "currency", &currency,
                                       "value", &value,
                                       "fraction", &fraction));
   EXITIF (3 < strlen (currency));
+  EXITIF (TALER_CURRENCY_LEN <= strlen (currency));
+  strcpy (r_amount->currency,
+	  currency);
   r_amount->value = (uint32_t) value;
   r_amount->fraction = (uint32_t) fraction;
   return GNUNET_OK;
@@ -291,6 +318,12 @@ TALER_json_to_abs (json_t *json,
 
   GNUNET_assert (NULL != abs);
   EXITIF (NULL == (str = json_string_value (json)));
+  if (0 == strcasecmp (str,
+		       "never"))
+  {
+    *abs = GNUNET_TIME_UNIT_FOREVER_ABS;
+    return GNUNET_OK;
+  }
   EXITIF (1 > sscanf (str, "%llu", &abs_value_s));
   abs->abs_value_us = abs_value_s * 1000 * 1000;
   return GNUNET_OK;
@@ -317,7 +350,7 @@ TALER_json_to_data (json_t *json,
 
   EXITIF (NULL == (enc = json_string_value (json)));
   len = strlen (enc);
-  EXITIF ((((len * 5) / 8) + ((((len * 5) % 8) == 0) ? 0 : 1)) == out_size);
+  EXITIF (((len * 5) / 8) != out_size);
   EXITIF (GNUNET_OK != GNUNET_STRINGS_string_to_data (enc, len, out, out_size));
   return GNUNET_OK;
  EXITIF_exit:
diff --git a/src/util/os_installation.c b/src/util/os_installation.c
index ad89f4e58..1308fa3f3 100644
--- a/src/util/os_installation.c
+++ b/src/util/os_installation.c
@@ -454,7 +454,7 @@ os_get_exec_path ()
  * @return a pointer to the dir path (to be freed by the caller)
  */
 char *
-TALER_os_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
+TALER_OS_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
 {
   size_t n;
   const char *dirname;
diff --git a/src/util/test_crypto.c b/src/util/test_crypto.c
index ce946dd53..a5313195a 100644
--- a/src/util/test_crypto.c
+++ b/src/util/test_crypto.c
@@ -71,7 +71,7 @@ test_basics ()
   GNUNET_assert (NULL != rld);
   GNUNET_assert (0 == memcmp (&rld->coin_priv,
 			      &rl.coin_priv,
-			      sizeof (union TALER_CoinSpendPrivateKeyP)));
+			      sizeof (struct TALER_CoinSpendPrivateKeyP)));
   GNUNET_assert (0 ==
 		 GNUNET_CRYPTO_rsa_blinding_key_cmp (rl.blinding_key.rsa_blinding_key,
 						     rld->blinding_key.rsa_blinding_key));
@@ -121,21 +121,21 @@ test_rled ()
 static int
 test_high_level ()
 {
-  struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
+  struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
   struct TALER_LinkSecretP secret;
   struct TALER_LinkSecretP secret2;
-  union TALER_CoinSpendPublicKeyP coin_pub;
-  union TALER_CoinSpendPrivateKeyP coin_priv;
+  struct TALER_CoinSpendPublicKeyP coin_pub;
+  struct TALER_CoinSpendPrivateKeyP coin_priv;
   struct TALER_TransferPrivateKeyP trans_priv;
   struct TALER_TransferPublicKeyP trans_pub;
   struct TALER_EncryptedLinkSecretP secret_enc;
 
-  pk = GNUNET_CRYPTO_ecdsa_key_create ();
+  pk = GNUNET_CRYPTO_eddsa_key_create ();
   GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
 			      &secret,
 			      sizeof (secret));
-  GNUNET_CRYPTO_ecdsa_key_get_public (pk,
-				      &coin_pub.ecdsa_pub);
+  GNUNET_CRYPTO_eddsa_key_get_public (pk,
+				      &coin_pub.eddsa_pub);
   GNUNET_assert (GNUNET_OK == 
 		 TALER_link_encrypt_secret (&secret,
 					    &coin_pub,
@@ -151,7 +151,7 @@ test_high_level ()
 		 memcmp (&secret,
 			 &secret2,
 			 sizeof (secret)));
-  coin_priv.ecdsa_priv = *pk;
+  coin_priv.eddsa_priv = *pk;
   GNUNET_assert (GNUNET_OK == 
 		 TALER_link_decrypt_secret2 (&secret_enc,
 					     &trans_pub,
diff --git a/src/util/test_json.c b/src/util/test_json.c
index 9eb72fb8c..6d887f489 100644
--- a/src/util/test_json.c
+++ b/src/util/test_json.c
@@ -24,6 +24,142 @@
 #include "taler_json_lib.h"
 
 
+/**
+ * Test amount conversion from/to JSON.
+ *
+ * @return 0 on success
+ */
+static int
+test_amount ()
+{
+  json_t *j;
+  struct TALER_Amount a1;
+  struct TALER_Amount a2;
+
+  GNUNET_assert (GNUNET_OK ==
+		 TALER_string_to_amount ("EUR:4.3",
+					 &a1));
+  j = TALER_json_from_amount (&a1);
+  GNUNET_assert (NULL != j);
+  GNUNET_assert (GNUNET_OK ==
+		 TALER_json_to_amount (j,
+				       &a2));
+  GNUNET_assert (0 ==
+		 TALER_amount_cmp (&a1,
+				   &a2));
+  json_decref (j);
+  return 0;
+}
+
+
+/**
+ * Test time conversion from/to JSON.
+ *
+ * @return 0 on success
+ */
+static int
+test_time ()
+{
+  json_t *j;
+  struct GNUNET_TIME_Absolute a1;
+  struct GNUNET_TIME_Absolute a2;
+
+  a1 = GNUNET_TIME_absolute_get ();
+  a1.abs_value_us -= a1.abs_value_us % 1000000; /* round! */
+  j = TALER_json_from_abs (a1);
+  GNUNET_assert (NULL != j);
+  GNUNET_assert (GNUNET_OK ==
+		 TALER_json_to_abs (j,
+				    &a2));
+  GNUNET_assert (a1.abs_value_us ==
+		 a2.abs_value_us);
+  json_decref (j);
+
+  a1 = GNUNET_TIME_UNIT_FOREVER_ABS;
+  j = TALER_json_from_abs (a1);
+  GNUNET_assert (NULL != j);
+  GNUNET_assert (GNUNET_OK ==
+		 TALER_json_to_abs (j,
+				    &a2));
+  GNUNET_assert (a1.abs_value_us ==
+		 a2.abs_value_us);
+  json_decref (j);
+  return 0;
+}
+
+
+/**
+ * Test raw (binary) conversion from/to JSON.
+ *
+ * @return 0 on success
+ */
+static int
+test_raw ()
+{
+  char blob[256];
+  char blob2[256];
+  unsigned int i;
+  json_t *j;
+
+  for (i=0;i<=256;i++)
+  {
+    memset (blob, i, i);
+    j = TALER_json_from_data (blob, i);
+    GNUNET_assert (NULL != j);
+    GNUNET_assert (GNUNET_OK ==
+		   TALER_json_to_data (j,
+				       blob2,
+				       i));
+    GNUNET_assert (0 == 
+		   memcmp (blob,
+			   blob2,
+			   i));
+  }
+  return 0;
+}
+
+
+/**
+ * Test rsa conversions from/to JSON.
+ *
+ * @return 0 on success
+ */
+static int
+test_rsa ()
+{
+  struct GNUNET_CRYPTO_rsa_PublicKey *pub;
+  struct GNUNET_CRYPTO_rsa_PublicKey *pub2;
+  struct GNUNET_CRYPTO_rsa_Signature *sig;
+  struct GNUNET_CRYPTO_rsa_Signature *sig2;
+  struct GNUNET_CRYPTO_rsa_PrivateKey *priv;
+  char msg[] = "Hello";
+  json_t *jp;
+  json_t *js;
+
+  priv = GNUNET_CRYPTO_rsa_private_key_create (1024);
+  pub = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
+  sig = GNUNET_CRYPTO_rsa_sign (priv,
+				msg,
+				sizeof (msg));
+  GNUNET_assert (NULL != (jp = TALER_json_from_rsa_public_key (pub)));
+  GNUNET_assert (NULL != (js = TALER_json_from_rsa_signature (sig)));
+  GNUNET_assert (NULL != (pub2 = TALER_json_to_rsa_public_key (jp)));
+  GNUNET_assert (NULL != (sig2 = TALER_json_to_rsa_signature (js)));
+  GNUNET_break (0 ==
+		GNUNET_CRYPTO_rsa_signature_cmp (sig,
+						 sig2));
+  GNUNET_break (0 ==
+		GNUNET_CRYPTO_rsa_public_key_cmp (pub,
+						  pub2));
+  GNUNET_CRYPTO_rsa_signature_free (sig);
+  GNUNET_CRYPTO_rsa_signature_free (sig2);
+  GNUNET_CRYPTO_rsa_private_key_free (priv);
+  GNUNET_CRYPTO_rsa_public_key_free (pub);
+  GNUNET_CRYPTO_rsa_public_key_free (pub2);
+  return 0;
+}
+
+
 int
 main(int argc,
      const char *const argv[])
@@ -31,7 +167,15 @@ main(int argc,
   GNUNET_log_setup ("test-json",
 		    "WARNING",
 		    NULL);
-  /* FIXME: implement test... */
+  if (0 != test_amount ())
+    return 1;
+  if (0 != test_time ())
+    return 1;
+  if (0 != test_raw ())
+    return 1;
+  if (0 != test_rsa ())
+    return 1;
+  /* FIXME: test EdDSA signature conversion... */
   return 0;
 }
 
diff --git a/src/util/test_wireformats.c b/src/util/test_wireformats.c
index 26ec4b79f..ebb96604c 100644
--- a/src/util/test_wireformats.c
+++ b/src/util/test_wireformats.c
@@ -24,7 +24,8 @@
 #include "taler_util.h"
 #include "taler_json_lib.h"
 
-static const char * const json_wire_str =
+/* Valid SEPA data */
+static const char * const valid_wire_str =
     "{ \"type\":\"SEPA\", \
 \"IBAN\":\"DE67830654080004822650\",                 \
 \"name\":\"GNUnet e.V.\",                               \
@@ -33,7 +34,40 @@ static const char * const json_wire_str =
 \"r\":123456789,                                     \
 \"address\": \"foobar\"}";
 
-int main(int argc, const char *const argv[])
+/* IBAN has wrong country code */
+static const char * const invalid_wire_str =
+    "{ \"type\":\"SEPA\", \
+\"IBAN\":\"XX67830654080004822650\",                 \
+\"name\":\"GNUnet e.V.\",                               \
+\"bic\":\"GENODEF1SLR\",                                 \
+\"edate\":\"1449930207000\",                                \
+\"r\":123456789,                                     \
+\"address\": \"foobar\"}";
+
+/* IBAN has wrong checksum */
+static const char * const invalid_wire_str2 =
+    "{ \"type\":\"SEPA\", \
+\"IBAN\":\"DE67830654080004822651\",                 \
+\"name\":\"GNUnet e.V.\",                               \
+\"bic\":\"GENODEF1SLR\",                                 \
+\"edate\":\"1449930207000\",                                \
+\"r\":123456789,                                     \
+\"address\": \"foobar\"}";
+
+/* Unsupported wireformat type */
+static const char * const unsupported_wire_str =
+    "{ \"type\":\"unsupported\", \
+\"IBAN\":\"DE67830654080004822650\",                 \
+\"name\":\"GNUnet e.V.\",                               \
+\"bic\":\"GENODEF1SLR\",                                 \
+\"edate\":\"1449930207000\",                                \
+\"r\":123456789,                                     \
+\"address\": \"foobar\"}";
+
+
+int 
+main(int argc, 
+     const char *const argv[])
 {
   json_t *wire;
   json_error_t error;
@@ -41,13 +75,18 @@ int main(int argc, const char *const argv[])
 
   GNUNET_log_setup ("test-json-validations", "WARNING", NULL);
   (void) memset(&error, 0, sizeof(error));
-  wire = json_loads (json_wire_str, 0, &error);
-  if (NULL == wire)
-  {
-    TALER_json_warn (error);
-    return 2;
-  }
+  GNUNET_assert (NULL != (wire = json_loads (unsupported_wire_str, 0, NULL)));
+  GNUNET_assert (1 != TALER_json_validate_wireformat ("unsupported", wire));
+  json_decref (wire);
+  GNUNET_assert (NULL != (wire = json_loads (invalid_wire_str, 0, NULL)));
+  GNUNET_assert (1 != TALER_json_validate_wireformat ("SEPA", wire));
+  json_decref (wire);
+  GNUNET_assert (NULL != (wire = json_loads (invalid_wire_str2, 0, NULL)));
+  GNUNET_assert (1 != TALER_json_validate_wireformat ("SEPA", wire));
+  json_decref (wire);
+  GNUNET_assert (NULL != (wire = json_loads (valid_wire_str, 0, &error)));
   ret = TALER_json_validate_wireformat ("SEPA", wire);
+  json_decref (wire);
   if (1 == ret)
     return 0;
   return 1;
diff --git a/src/util/wireformats.c b/src/util/wireformats.c
index df32f2d3d..7ea4fd067 100644
--- a/src/util/wireformats.c
+++ b/src/util/wireformats.c
@@ -22,7 +22,6 @@
 #include "platform.h"
 #include <gnunet/gnunet_util_lib.h>
 #include "taler_util.h"
-#include "taler_json_lib.h"
 
 /**
  * Shorthand for exit jumps.
@@ -298,10 +297,11 @@ validate_iban (const char *iban)
       dividend += remainder * (pow (10, nread));
     remainder = dividend % 97;
   }
-  EXITIF (1 != remainder);
-  GNUNET_free (nbuf);
-  return GNUNET_YES;
-
+  if (1 == remainder)
+  {
+    GNUNET_free (nbuf);
+    return GNUNET_YES;
+  }
  EXITIF_exit:
   GNUNET_free (nbuf);
   return GNUNET_NO;
@@ -346,7 +346,13 @@ validate_sepa (const json_t *wire)
                   "r", &r,
                   "address", &address));
   EXITIF (0 != strcmp (type, "SEPA"));
-  EXITIF (1 != validate_iban (iban));
+  if (1 != validate_iban (iban))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+		"IBAN `%s' invalid\n",
+		iban);
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
  EXITIF_exit:
   return GNUNET_NO;
@@ -394,7 +400,7 @@ TALER_json_validate_wireformat (const char *type,
     if (0 == strcasecmp (format_handlers[i].type,
                          type))
       return format_handlers[i].handler (wire);
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Wireformat `%s' not supported\n",
               type);
   return GNUNET_NO;