WiP:age-withdraw: started handler for age-withdraw reveal

contrib/gana

@@ -1 +1 @@
-Subproject commit 3e659ed54023230dd45dbec5664f176e1763d260
+Subproject commit b309c93f859f68124f76cef03b35b0143b8331cb

src/auditor/taler-helper-auditor-coins.c

@@ -1218,7 +1218,7 @@ static enum GNUNET_GenericReturnValue
 refresh_session_cb (void *cls,
                     uint64_t rowid,
                     const struct TALER_DenominationPublicKey *denom_pub,
-                    const struct TALER_AgeCommitmentHash *h_age_commitment,
+                    const struct TALER_AgeCommitmentHashP *h_age_commitment,
                     const struct TALER_CoinSpendPublicKeyP *coin_pub,
                     const struct TALER_CoinSpendSignatureP *coin_sig,
                     const struct TALER_Amount *amount_with_fee,

src/benchmark/taler-aggregator-benchmark.c

@@ -277,7 +277,7 @@ add_deposit (const struct Merchant *m)
   struct TALER_EXCHANGEDB_Deposit deposit;
   uint64_t known_coin_id;
   struct TALER_DenominationHashP dph;
-  struct TALER_AgeCommitmentHash agh;
+  struct TALER_AgeCommitmentHashP agh;
 
   RANDOMIZE (&d.coin.coin_pub);
   d.coin.denom_pub_hash = h_denom_pub;
@@ -468,7 +468,7 @@ run (void *cls,
     struct TALER_PlanchetMasterSecretP ps;
     struct TALER_ExchangeWithdrawValues alg_values;
     struct TALER_CoinSpendPublicKeyP coin_pub;
-    struct TALER_AgeCommitmentHash hac;
+    struct TALER_AgeCommitmentHashP hac;
     union TALER_DenominationBlindingKeyP bks;
 
     RANDOMIZE (&coin_pub);

src/exchange/taler-exchange-httpd_age-withdraw.c

@@ -27,10 +27,48 @@
 #include "taler_json_lib.h"
 #include "taler_kyclogic_lib.h"
 #include "taler_mhd_lib.h"
-#include "taler-exchange-httpd_withdraw.h"
+#include "taler-exchange-httpd_age-withdraw.h"
 #include "taler-exchange-httpd_responses.h"
 #include "taler-exchange-httpd_keys.h"
 
+/**
+ * Send a response to a "age-withdraw" request.
+ *
+ * @param connection the connection to send the response to
+ * @param ach value the client committed to
+ * @param noreveal_index which index will the client not have to reveal
+ * @return a MHD status code
+ */
+static MHD_RESULT
+reply_age_withdraw_success (struct MHD_Connection *connection,
+                            const struct TALER_AgeWithdrawCommitmentHashP *ach,
+                            uint32_t noreveal_index)
+{
+  struct TALER_ExchangePublicKeyP pub;
+  struct TALER_ExchangeSignatureP sig;
+  enum TALER_ErrorCode ec =
+    TALER_exchange_online_age_withdraw_confirmation_sign (
+      &TEH_keys_exchange_sign_,
+      ach,
+      noreveal_index,
+      &pub,
+      &sig);
+
+  if (TALER_EC_NONE != ec)
+    return TALER_MHD_reply_with_ec (connection,
+                                    ec,
+                                    NULL);
+
+  return TALER_MHD_REPLY_JSON_PACK (connection,
+                                    MHD_HTTP_OK,
+                                    GNUNET_JSON_pack_uint64 ("noreveal_index",
+                                                             noreveal_index),
+                                    GNUNET_JSON_pack_data_auto ("exchange_sig",
+                                                                &sig),
+                                    GNUNET_JSON_pack_data_auto ("exchange_pub",
+                                                                &pub));
+}
+
 
 /**
  * Context for #age_withdraw_transaction.
@@ -43,7 +81,12 @@ struct AgeWithdrawContext
   struct TALER_EXCHANGEDB_KycStatus kyc;
 
   /**
-   * The commitment request, for n*kappa coins.
+   * Hash of the wire source URL, needed when kyc is needed.
+   */
+  struct TALER_PaytoHashP h_payto;
+
+  /**
+   * The data from the age-withdraw request
    */
   struct TALER_EXCHANGEDB_AgeWithdrawCommitment commitment;
 
@@ -54,7 +97,6 @@ struct AgeWithdrawContext
 };
 
 
-#if 0
 /**
  * Function called to iterate over KYC-relevant
  * transaction amounts for a particular time range.
@@ -71,28 +113,27 @@ struct AgeWithdrawContext
  * @param cb_cls closure for @a cb
  */
 static void
-withdraw_amount_cb (void *cls,
-                    struct GNUNET_TIME_Absolute limit,
-                    TALER_EXCHANGEDB_KycAmountCallback cb,
-                    void *cb_cls)
+age_withdraw_amount_cb (void *cls,
+                        struct GNUNET_TIME_Absolute limit,
+                        TALER_EXCHANGEDB_KycAmountCallback cb,
+                        void *cb_cls)
 {
   struct AgeWithdrawContext *awc = cls;
   enum GNUNET_DB_QueryStatus qs;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Signaling amount %s for KYC check during age-withdrawal\n",
-              TALER_amount2s (&awc->amount_with_fee));
+              TALER_amount2s (&awc->commitment.amount_with_fee));
   if (GNUNET_OK !=
       cb (cb_cls,
-          &awc->amount_with_fee,
+          &awc->commitment.amount_with_fee,
           awc->now.abs_time))
     return;
-  qs = TEH_plugin->select_withdraw_amounts_for_kyc_check (
-    TEH_plugin->cls,
-    &wc->h_payto,
-    limit,
-    cb,
-    cb_cls);
+  qs = TEH_plugin->select_withdraw_amounts_for_kyc_check (TEH_plugin->cls,
+                                                          &awc->h_payto,
+                                                          limit,
+                                                          cb,
+                                                          cb_cls);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Got %d additional transactions for this age-withdrawal and limit %llu\n",
               qs,
@@ -101,12 +142,7 @@ withdraw_amount_cb (void *cls,
 }
 
 
-#endif
-
-
-#if 0
 /**
- * TODO: REWRITE
  * Function implementing age withdraw transaction.  Runs the
  * transaction logic; IF it returns a non-error code, the transaction
  * logic MUST NOT queue a MHD response.  IF it returns an hard error,
@@ -114,10 +150,10 @@ withdraw_amount_cb (void *cls,
  * IF it returns the soft error code, the function MAY be called again
  * to retry and MUST not queue a MHD response.
  *
- * Note that "wc->collectable.sig" is set before entering this function as we
+ * Note that "awc->commitment.sig" is set before entering this function as we
  * signed before entering the transaction.
  *
- * @param cls a `struct WithdrawContext *`
+ * @param cls a `struct AgeWithdrawContext *`
  * @param connection MHD request which triggered the transaction
  * @param[out] mhd_ret set to MHD response status for @a connection,
  *             if transaction failed (!)
@@ -128,21 +164,19 @@ age_withdraw_transaction (void *cls,
                           struct MHD_Connection *connection,
                           MHD_RESULT *mhd_ret)
 {
-  struct AgeWithdrawContext *wc = cls;
+  struct AgeWithdrawContext *awc = cls;
   enum GNUNET_DB_QueryStatus qs;
   bool found = false;
   bool balance_ok = false;
-  bool nonce_ok = false;
   uint64_t ruuid;
-  const struct TALER_CsNonce *nonce;
-  const struct TALER_BlindedPlanchet *bp;
 
-  wc->now = GNUNET_TIME_timestamp_get ();
+  awc->now = GNUNET_TIME_timestamp_get ();
   qs = TEH_plugin->reserves_get_origin (TEH_plugin->cls,
-                                        &wc->collectable.reserve_pub,
-                                        &wc->h_payto);
+                                        &awc->commitment.reserve_pub,
+                                        &awc->h_payto);
   if (qs < 0)
     return qs;
+
   /* If no results, reserve was created by merge,
      in which case no KYC check is required as the
      merge already did that. */
@@ -151,46 +185,42 @@ age_withdraw_transaction (void *cls,
     const char *kyc_required;
 
     kyc_required = TALER_KYCLOGIC_kyc_test_required (
-      TALER_KYCLOGIC_KYC_TRIGGER_WITHDRAW,
-      &wc->h_payto,
+      TALER_KYCLOGIC_KYC_TRIGGER_AGE_WITHDRAW,
+      &awc->h_payto,
       TEH_plugin->select_satisfied_kyc_processes,
       TEH_plugin->cls,
-      &withdraw_amount_cb,
-      wc);
+      &age_withdraw_amount_cb,
+      awc);
+
     if (NULL != kyc_required)
     {
       /* insert KYC requirement into DB! */
-      wc->kyc.ok = false;
+      awc->kyc.ok = false;
       return TEH_plugin->insert_kyc_requirement_for_account (
         TEH_plugin->cls,
         kyc_required,
-        &wc->h_payto,
-        &wc->kyc.requirement_row);
+        &awc->h_payto,
+        &awc->kyc.requirement_row);
     }
   }
-  wc->kyc.ok = true;
-  bp = &wc->blinded_planchet;
-  nonce = (TALER_DENOMINATION_CS == bp->cipher)
-    ? &bp->details.cs_blinded_planchet.nonce
-    : NULL;
-  qs = TEH_plugin->do_withdraw (TEH_plugin->cls,
-                                nonce,
-                                &wc->collectable,
-                                wc->now,
-                                &found,
-                                &balance_ok,
-                                &nonce_ok,
-                                &ruuid);
+
+  awc->kyc.ok = true;
+  qs = TEH_plugin->do_age_withdraw (TEH_plugin->cls,
+                                    &awc->commitment,
+                                    awc->now,
+                                    &found,
+                                    &balance_ok,
+                                    &ruuid);
   if (0 > qs)
   {
     if (GNUNET_DB_STATUS_HARD_ERROR == qs)
       *mhd_ret = TALER_MHD_reply_with_error (connection,
                                              MHD_HTTP_INTERNAL_SERVER_ERROR,
                                              TALER_EC_GENERIC_DB_FETCH_FAILED,
-                                             "do_withdraw");
+                                             "do_age_withdraw");
     return qs;
   }
-  if (! found)
+  else if (! found)
   {
     *mhd_ret = TALER_MHD_reply_with_error (connection,
                                            MHD_HTTP_NOT_FOUND,
@@ -198,34 +228,23 @@ age_withdraw_transaction (void *cls,
                                            NULL);
     return GNUNET_DB_STATUS_HARD_ERROR;
   }
-  if (! balance_ok)
+  else if (! balance_ok)
   {
     TEH_plugin->rollback (TEH_plugin->cls);
     *mhd_ret = TEH_RESPONSE_reply_reserve_insufficient_balance (
       connection,
-      TALER_EC_EXCHANGE_WITHDRAW_INSUFFICIENT_FUNDS,
-      &wc->collectable.amount_with_fee,
-      &wc->collectable.reserve_pub);
-    return GNUNET_DB_STATUS_HARD_ERROR;
-  }
-  if (! nonce_ok)
-  {
-    TEH_plugin->rollback (TEH_plugin->cls);
-    *mhd_ret = TALER_MHD_reply_with_error (connection,
-                                           MHD_HTTP_CONFLICT,
-                                           TALER_EC_EXCHANGE_WITHDRAW_NONCE_REUSE,
-                                           NULL);
+      TALER_EC_EXCHANGE_AGE_WITHDRAW_INSUFFICIENT_FUNDS,
+      &awc->commitment.amount_with_fee,
+      &awc->commitment.reserve_pub);
     return GNUNET_DB_STATUS_HARD_ERROR;
   }
+
   if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs)
-    TEH_METRICS_num_success[TEH_MT_SUCCESS_WITHDRAW]++;
+    TEH_METRICS_num_success[TEH_MT_SUCCESS_AGE_WITHDRAW]++;
   return qs;
 }
 
 
-#endif
-
-
 /**
  * Check if the @a rc is replayed and we already have an
  * answer. If so, replay the existing answer and return the
@@ -243,10 +262,12 @@ request_is_idempotent (struct TEH_RequestContext *rc,
                        MHD_RESULT *mret)
 {
   enum GNUNET_DB_QueryStatus qs;
+  struct TALER_EXCHANGEDB_AgeWithdrawCommitment commitment;
 
   qs = TEH_plugin->get_age_withdraw_info (TEH_plugin->cls,
-                                          &awc->reserve_pub,
-                                          &awc->commitment);
+                                          &awc->commitment.reserve_pub,
+                                          &awc->commitment.h_commitment,
+                                          &commitment);
   if (0 > qs)
   {
     GNUNET_break (GNUNET_DB_STATUS_SOFT_ERROR == qs);
@@ -263,16 +284,9 @@ request_is_idempotent (struct TEH_RequestContext *rc,
 
   /* generate idempotent reply */
   TEH_METRICS_num_requests[TEH_MT_REQUEST_IDEMPOTENT_AGE_WITHDRAW]++;
-  *mret = TALER_MHD_REPLY_JSON_PACK (
-    rc->connection,
-    MHD_HTTP_OK,
-    GNUNET_JSON_pack_uint64 ("noreveal_index",
-                             &awc->commitment.noreveal_index),
-    GNUNET_JSON_pack_data_auto ("exchange_sig",
-                                &awc->commitment.sig),
-    GNUNET_JSON_pack_data_auto ("exchange_pub",
-                                /* TODO:oec: where does the pub come from? */
-                                &pub));
+  *mret = reply_age_withdraw_success (rc->connection,
+                                      &commitment.h_commitment,
+                                      commitment.noreveal_index);
   return true;
 }
 
@@ -282,24 +296,26 @@ TEH_handler_age_withdraw (struct TEH_RequestContext *rc,
                           const struct TALER_ReservePublicKeyP *reserve_pub,
                           const json_t *root)
 {
+  MHD_RESULT mhd_ret;
   struct AgeWithdrawContext awc;
   struct GNUNET_JSON_Specification spec[] = {
     GNUNET_JSON_spec_fixed_auto ("reserve_sig",
                                  &awc.commitment.reserve_sig),
-    GNUNET_JSON_spec_fixed_auto ("age_restricted_coins_commitment",
+    GNUNET_JSON_spec_fixed_auto ("h_commitment",
                                  &awc.commitment.h_commitment),
     TALER_JSON_spec_amount ("amount",
-                            &awc.commitment.amount_with_fee);
-    GNUNET_JSON_spec_uint8 ("max_age_group",
-                            &awc.commitment.max_age_group),
+                            TEH_currency,
+                            &awc.commitment.amount_with_fee),
+    GNUNET_JSON_spec_uint32 ("max_age_group",
+                             &awc.commitment.max_age_group),
     GNUNET_JSON_spec_end ()
   };
-  enum TALER_ErrorCode ec;
 
   memset (&awc, 0, sizeof (awc));
   awc.commitment.reserve_pub = *reserve_pub;
 
 
+  /* Parse the JSON body */
   {
     enum GNUNET_GenericReturnValue res;
 
@@ -310,34 +326,31 @@ TEH_handler_age_withdraw (struct TEH_RequestContext *rc,
       return (GNUNET_SYSERR == res) ? MHD_NO : MHD_YES;
   }
 
-  if (request_is_idempotent (rc,
-                             &awc,
-                             &mret))
-  {
-    GNUNET_JSON_parse_free (spec);
-    return mret;
-  }
+  do {
+    /* If request was made before successfully, return the previous answer */
+    if (request_is_idempotent (rc,
+                               &awc,
+                               &mhd_ret))
+      break;
 
-  TEH_METRICS_num_verifications[TEH_MT_SIGNATURE_EDDSA]++;
-  if (GNUNET_OK !=
-      TALER_wallet_age_withdraw_verify (&awc.commitment.h_commitment,
-                                        &awc.commitment.amount_with_fee,
-                                        &awc.commitment.max_age_group,
-                                        &awc.commitment.reserve_pub,
-                                        &awc.commitment.reserve_sig))
-  {
-    GNUNET_break_op (0);
-    GNUNET_JSON_parse_free (spec);
-    return TALER_MHD_reply_with_error (rc->connection,
-                                       MHD_HTTP_FORBIDDEN,
-                                       TALER_EC_EXCHANGE_WITHDRAW_RESERVE_SIGNATURE_INVALID,
-                                       NULL);
-  }
-
-  /* run transaction */
-  {
-    MHD_RESULT mhd_ret;
+    /* Verify the signature of the request body with the reserve key */
+    TEH_METRICS_num_verifications[TEH_MT_SIGNATURE_EDDSA]++;
+    if (GNUNET_OK !=
+        TALER_wallet_age_withdraw_verify (&awc.commitment.h_commitment,
+                                          &awc.commitment.amount_with_fee,
+                                          awc.commitment.max_age_group,
+                                          &awc.commitment.reserve_pub,
+                                          &awc.commitment.reserve_sig))
+    {
+      GNUNET_break_op (0);
+      mhd_ret = TALER_MHD_reply_with_error (rc->connection,
+                                            MHD_HTTP_FORBIDDEN,
+                                            TALER_EC_EXCHANGE_WITHDRAW_RESERVE_SIGNATURE_INVALID,
+                                            NULL);
+      break;
+    }
 
+    /* Run the transaction */
     if (GNUNET_OK !=
         TEH_DB_run_transaction (rc->connection,
                                 "run age withdraw",
@@ -345,40 +358,24 @@ TEH_handler_age_withdraw (struct TEH_RequestContext *rc,
                                 &mhd_ret,
                                 &age_withdraw_transaction,
                                 &awc))
-    {
-      /* Even if #withdraw_transaction() failed, it may have created a signature
-         (or we might have done it optimistically above). */
-      /*TODO:oec:which function to call here!? */
-      TALER_blinded_denom_sig_free (&awc.commitment.sig);
-      GNUNET_JSON_parse_free (spec);
-      return mhd_ret;
-    }
-  }
+      break;
+
+    /* Clean up and send back final response */
+    GNUNET_JSON_parse_free (spec);
+
+    if (! awc.kyc.ok)
+      return TEH_RESPONSE_reply_kyc_required (rc->connection,
+                                              &awc.h_payto,
+                                              &awc.kyc);
+
+    return reply_age_withdraw_success (rc->connection,
+                                       &awc.commitment.h_commitment,
+                                       awc.commitment.noreveal_index);
+  } while(0);
 
-  /* Clean up and send back final response */
   GNUNET_JSON_parse_free (spec);
+  return mhd_ret;
 
-  if (! awc.kyc.ok)
-    return TEH_RESPONSE_reply_kyc_required (rc->connection,
-                                            &awc.h_payto,
-                                            &awc.kyc);
-  {
-    MHD_RESULT ret;
-
-    ret = TALER_MHD_REPLY_JSON_PACK (
-      rc->connection,
-      MHD_HTTP_OK,
-      /* TODO:oec: put in the right answer fields */
-      GNUNET_JSON_pack_uint64 ("noreveal_index",
-                               &awc->commitment.noreveal_index),
-      GNUNET_JSON_pack_data_auto ("exchange_sig",
-                                  &awc->commitment.sig),
-      GNUNET_JSON_pack_data_auto ("exchange_pub",
-                                  /* TODO:oec: where does the pub come from? */
-                                  &pub));
-    TALER_blinded_denom_sig_free (&awc.commitment.sig);
-    return ret;
-  }
 }
 
 

src/exchange/taler-exchange-httpd_age-withdraw_reveal.c

@@ -0,0 +1,303 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2023 Taler Systems SA
+
+  TALER is free software; you can redistribute it and/or modify it under the
+  terms of the GNU Affero General Public License as published by the Free Software
+  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 Affero General Public License for more details.
+
+  You should have received a copy of the GNU Affero General Public License along with
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
+/**
+ * @file taler-exchange-httpd_age-withdraw_reveal.c
+ * @brief Handle /age-withdraw/$ACH/reveal requests
+ * @author Özgür Kesim
+ */
+#include "platform.h"
+#include <gnunet/gnunet_util_lib.h>
+#include <jansson.h>
+#include <microhttpd.h>
+#include "taler_mhd_lib.h"
+#include "taler-exchange-httpd_mhd.h"
+#include "taler-exchange-httpd_age-withdraw_reveal.h"
+#include "taler-exchange-httpd_responses.h"
+#include "taler-exchange-httpd_keys.h"
+
+/**
+ * State for an /age-withdraw/$ACH/reveal operation.
+ */
+struct AgeRevealContext
+{
+
+  /**
+   * Commitment for the age-withdraw operation.
+   */
+  struct TALER_AgeWithdrawCommitmentHashP ach;
+
+  /**
+   * Public key of the reserve for with the age-withdraw commitment was
+   * originally made.  This parameter is provided by the client again
+   * during the call to reveal in order to save a database-lookup .
+   */
+  struct TALER_ReservePublicKeyP reserve_pub;
+
+  /**
+   * Number of coins/denonations in the reveal
+   */
+  uint32_t num_coins;
+
+  /**
+   * TODO:oec num_coins denoms
+   */
+  struct TALER_DenominationHashP *denoms_h;
+
+  /**
+   * TODO:oec num_coins blinded coins
+   */
+  struct TALER_BlindedCoinHashP *coin_evs;
+
+  /**
+   * TODO:oec num_coins*(kappa - 1) disclosed coins
+   */
+  struct GNUNET_CRYPTO_EddsaPrivateKey *disclosed_coins;
+
+};
+
+/**
+ * Helper function to free resources in the context
+ */
+void
+age_reveal_context_free (struct AgeRevealContext *actx)
+{
+  GNUNET_free (actx->denoms_h);
+  GNUNET_free (actx->coin_evs);
+  GNUNET_free (actx->disclosed_coins);
+}
+
+
+/**
+ * Handle a "/age-withdraw/$ACH/reveal request.  Parses the given JSON
+ * ... TODO:oec:description
+ *
+ * @param connection The MHD connection to handle
+ * @param actx The context of the operation, only partially built at call time
+ * @param j_denoms_h Array of hashes of the denominations for the withdrawal, in JSON format
+ * @param j_coin_evs The blinded envelopes in JSON format for the coins that are not revealed and will be signed on success
+ * @param j_disclosed_coins The n*(kappa-1) disclosed coins' private keys in JSON format, from which all other attributes (age restriction, blinding, nonce) will be derived from
+ */
+MHD_RESULT
+handle_age_withdraw_reveal_json (
+  struct MHD_Connection *connection,
+  struct AgeRevealContext *actx,
+  const json_t *j_denoms_h,
+  const json_t *j_coin_evs,
+  const json_t *j_disclosed_coins)
+{
+  MHD_RESULT mhd_ret = MHD_NO;
+
+  /* Verify JSON-structure consistency */
+  {
+    const char *error = NULL;
+
+    actx->num_coins = json_array_size (j_denoms_h); /* 0, if j_denoms_h is not an array */
+
+    if (! json_is_array (j_denoms_h))
+      error = "denoms_h must be an array";
+    else if (! json_is_array (j_coin_evs))
+      error = "coin_evs must be an array";
+    else if (! json_is_array (j_disclosed_coins))
+      error = "disclosed_coins must be an array";
+    else if (actx->num_coins == 0)
+      error = "denoms_h must not be empty";
+    else if (actx->num_coins != json_array_size (j_coin_evs))
+      error = "denoms_h and coins_evs must be arrays of the same size";
+    else if (actx->num_coins * (TALER_CNC_KAPPA - 1)
+             != json_array_size (j_disclosed_coins))
+      error = "the size of array disclosed_coins must be "
+              TALER_CNC_KAPPA_MINUS_ONE_STR " times of the size of denoms_h";
+    else if (actx->num_coins > TALER_MAX_FRESH_COINS)
+      /**
+       * FIXME?: If the user had commited to more than the maximum coins allowed,
+       * the reserve has been charged, but now the user can not withdraw any money
+       * from it. How can the user get their money back?
+       **/
+      error = "maximum number of coins that can be withdrawn has been exceeded";
+
+    if (NULL != error)
+      return TALER_MHD_reply_with_error (connection,
+                                         MHD_HTTP_BAD_REQUEST,
+                                         TALER_EC_GENERIC_PARAMETER_MALFORMED,
+                                         error);
+  }
+
+  /* Parse denomination keys */
+  {
+    unsigned int idx;
+    json_t *jh;
+
+    actx->denoms_h = GNUNET_new_array (actx->num_coins,
+                                       struct TALER_DenominationHashP);
+
+    json_array_foreach (j_denoms_h, idx, jh) {
+      struct GNUNET_JSON_Specification spec[] = {
+        GNUNET_JSON_spec_fixed_auto (NULL, &actx->denoms_h[idx]),
+        GNUNET_JSON_spec_end ()
+      };
+
+      if (GNUNET_OK !=
+          GNUNET_JSON_parse (jh, spec, NULL, NULL))
+      {
+        char msg[256] = {0};
+        GNUNET_snprintf (msg,
+                         sizeof(msg),
+                         "couldn't parse entry no. %d in array denoms_h",
+                         idx + 1);
+        mhd_ret = TALER_MHD_reply_with_error (connection,
+                                              MHD_HTTP_BAD_REQUEST,
+                                              TALER_EC_GENERIC_PARAMETER_MALFORMED,
+                                              msg);
+        goto EXIT;
+      }
+
+    };
+  }
+
+  /* Parse blinded envelopes */
+  {
+    unsigned int idx;
+    json_t *ce;
+
+    actx->coin_evs = GNUNET_new_array (actx->num_coins,
+                                       struct TALER_BlindedCoinHashP);
+
+    json_array_foreach (j_coin_evs, idx, ce) {
+      struct GNUNET_JSON_Specification spec[] = {
+        GNUNET_JSON_spec_fixed_auto (NULL, &actx->coin_evs[idx]),
+        GNUNET_JSON_spec_end ()
+      };
+
+      if (GNUNET_OK !=
+          GNUNET_JSON_parse (ce, spec, NULL, NULL))
+      {
+        char msg[256] = {0};
+        GNUNET_snprintf (msg,
+                         sizeof(msg),
+                         "couldn't parse entry no. %d in array coin_evs",
+                         idx + 1);
+        mhd_ret = TALER_MHD_reply_with_error (connection,
+                                              MHD_HTTP_BAD_REQUEST,
+                                              TALER_EC_GENERIC_PARAMETER_MALFORMED,
+                                              msg);
+        goto EXIT;
+      }
+    };
+  }
+
+  /* Parse diclosed keys */
+  {
+    unsigned int idx;
+    json_t *dc;
+
+    actx->disclosed_coins = GNUNET_new_array (
+      actx->num_coins * (TALER_CNC_KAPPA),
+      struct GNUNET_CRYPTO_EddsaPrivateKey);
+
+    json_array_foreach (j_coin_evs, idx, dc) {
+      struct GNUNET_JSON_Specification spec[] = {
+        GNUNET_JSON_spec_fixed_auto (NULL, &actx->disclosed_coins[idx]),
+        GNUNET_JSON_spec_end ()
+      };
+
+      if (GNUNET_OK !=
+          GNUNET_JSON_parse (dc, spec, NULL, NULL))
+      {
+        char msg[256] = {0};
+        GNUNET_snprintf (msg,
+                         sizeof(msg),
+                         "couldn't parse entry no. %d in array disclosed_coins",
+                         idx + 1);
+        mhd_ret = TALER_MHD_reply_with_error (connection,
+                                              MHD_HTTP_BAD_REQUEST,
+                                              TALER_EC_GENERIC_PARAMETER_MALFORMED,
+                                              msg);
+        goto EXIT;
+      }
+    };
+
+  }
+
+  /* TODO:oec: find commitment */
+  /* TODO:oec: check validity of denoms */
+  /* TODO:oec: check amount total against denoms */
+  /* TODO:oec: compute the disclosed blinded coins */
+  /* TODO:oec: generate h_commitment_comp */
+  /* TODO:oec: compare h_commitment_comp against h_commitment */
+  /* TODO:oec: sign the coins */
+  /* TODO:oec: send response */
+
+
+  /* TODO */
+EXIT:
+  age_reveal_context_free (actx);
+  return mhd_ret;
+}
+
+
+MHD_RESULT
+TEH_handler_age_withdraw_reveal (
+  struct TEH_RequestContext *rc,
+  const struct TALER_AgeWithdrawCommitmentHashP *ach,
+  const json_t *root)
+{
+  struct AgeRevealContext actx = {0};
+  json_t *j_denoms_h;
+  json_t *j_coin_evs;
+  json_t *j_disclosed_coins;
+  struct GNUNET_JSON_Specification spec[] = {
+    GNUNET_JSON_spec_fixed_auto ("reserve_pub", &actx.reserve_pub),
+    GNUNET_JSON_spec_json ("denoms_h", &j_denoms_h),
+    GNUNET_JSON_spec_json ("coin_evs", &j_coin_evs),
+    GNUNET_JSON_spec_json ("disclosed_coins", &j_disclosed_coins),
+    GNUNET_JSON_spec_end ()
+  };
+
+  actx.ach = *ach;
+
+  /* Parse JSON body*/
+  {
+    enum GNUNET_GenericReturnValue res;
+
+    res = TALER_MHD_parse_json_data (rc->connection,
+                                     root,
+                                     spec);
+    if (GNUNET_OK != res)
+    {
+      GNUNET_break_op (0);
+      return (GNUNET_SYSERR == res) ? MHD_NO : MHD_YES;
+    }
+  }
+
+
+  /* handle reveal request */
+  {
+    MHD_RESULT res;
+
+    res = handle_age_withdraw_reveal_json (rc->connection,
+                                           &actx,
+                                           j_denoms_h,
+                                           j_coin_evs,
+                                           j_disclosed_coins);
+
+    GNUNET_JSON_parse_free (spec);
+    return res;
+  }
+
+}
+
+
+/* end of taler-exchange-httpd_age-withdraw_reveal.c */

src/exchange/taler-exchange-httpd_age-withdraw_reveal.h

@@ -50,7 +50,7 @@
 MHD_RESULT
 TEH_handler_age_withdraw_reveal (
   struct TEH_RequestContext *rc,
-  const struct TALER_AgeRestrictedCoinsCommitmentP *ach,
+  const struct TALER_AgeWithdrawCommitmentHashP *ach,
   const json_t *root);
 
 #endif

src/exchange/taler-exchange-httpd_db.c

@@ -37,7 +37,7 @@ TEH_make_coin_known (const struct TALER_CoinPublicInfo *coin,
 {
   enum TALER_EXCHANGEDB_CoinKnownStatus cks;
   struct TALER_DenominationHashP h_denom_pub;
-  struct TALER_AgeCommitmentHash age_hash;
+  struct TALER_AgeCommitmentHashP age_hash;
 
   /* make sure coin is 'known' in database */
   cks = TEH_plugin->ensure_coin_known (TEH_plugin->cls,

src/exchange/taler-exchange-httpd_metrics.h

@@ -34,18 +34,20 @@ enum TEH_MetricTypeRequest
   TEH_MT_REQUEST_OTHER = 0,
   TEH_MT_REQUEST_DEPOSIT = 1,
   TEH_MT_REQUEST_WITHDRAW = 2,
-  TEH_MT_REQUEST_MELT = 3,
-  TEH_MT_REQUEST_PURSE_CREATE = 4,
-  TEH_MT_REQUEST_PURSE_MERGE = 5,
-  TEH_MT_REQUEST_RESERVE_PURSE = 6,
-  TEH_MT_REQUEST_PURSE_DEPOSIT = 7,
-  TEH_MT_REQUEST_IDEMPOTENT_DEPOSIT = 8,
-  TEH_MT_REQUEST_IDEMPOTENT_WITHDRAW = 9,
-  TEH_MT_REQUEST_IDEMPOTENT_MELT = 10,
-  TEH_MT_REQUEST_IDEMPOTENT_BATCH_WITHDRAW = 11,
-  TEH_MT_REQUEST_BATCH_DEPOSIT = 12,
-  TEH_MT_REQUEST_POLICY_FULFILLMENT = 13,
-  TEH_MT_REQUEST_COUNT = 14 /* MUST BE LAST! */
+  TEH_MT_REQUEST_AGE_WITHDRAW = 3,
+  TEH_MT_REQUEST_MELT = 4,
+  TEH_MT_REQUEST_PURSE_CREATE = 5,
+  TEH_MT_REQUEST_PURSE_MERGE = 6,
+  TEH_MT_REQUEST_RESERVE_PURSE = 7,
+  TEH_MT_REQUEST_PURSE_DEPOSIT = 8,
+  TEH_MT_REQUEST_IDEMPOTENT_DEPOSIT = 9,
+  TEH_MT_REQUEST_IDEMPOTENT_WITHDRAW = 10,
+  TEH_MT_REQUEST_IDEMPOTENT_AGE_WITHDRAW = 11,
+  TEH_MT_REQUEST_IDEMPOTENT_MELT = 12,
+  TEH_MT_REQUEST_IDEMPOTENT_BATCH_WITHDRAW = 13,
+  TEH_MT_REQUEST_BATCH_DEPOSIT = 14,
+  TEH_MT_REQUEST_POLICY_FULFILLMENT = 15,
+  TEH_MT_REQUEST_COUNT = 16 /* MUST BE LAST! */
 };
 
 /**
@@ -55,10 +57,11 @@ enum TEH_MetricTypeSuccess
 {
   TEH_MT_SUCCESS_DEPOSIT = 0,
   TEH_MT_SUCCESS_WITHDRAW = 1,
-  TEH_MT_SUCCESS_BATCH_WITHDRAW = 2,
-  TEH_MT_SUCCESS_MELT = 3,
-  TEH_MT_SUCCESS_REFRESH_REVEAL = 4,
-  TEH_MT_SUCCESS_COUNT = 5 /* MUST BE LAST! */
+  TEH_MT_SUCCESS_AGE_WITHDRAW = 2,
+  TEH_MT_SUCCESS_BATCH_WITHDRAW = 3,
+  TEH_MT_SUCCESS_MELT = 4,
+  TEH_MT_SUCCESS_REFRESH_REVEAL = 5,
+  TEH_MT_SUCCESS_COUNT = 6 /* MUST BE LAST! */
 };
 
 /**

src/exchange/taler-exchange-httpd_purses_create.c

@@ -260,7 +260,7 @@ create_transaction (void *cls,
       struct TALER_CoinSpendPublicKeyP coin_pub;
       struct TALER_CoinSpendSignatureP coin_sig;
       struct TALER_DenominationHashP h_denom_pub;
-      struct TALER_AgeCommitmentHash phac;
+      struct TALER_AgeCommitmentHashP phac;
       char *partner_url = NULL;
 
       TEH_plugin->rollback (TEH_plugin->cls);

src/exchange/taler-exchange-httpd_purses_deposit.c

@@ -222,7 +222,7 @@ deposit_transaction (void *cls,
       struct TALER_CoinSpendPublicKeyP coin_pub;
       struct TALER_CoinSpendSignatureP coin_sig;
       struct TALER_DenominationHashP h_denom_pub;
-      struct TALER_AgeCommitmentHash phac;
+      struct TALER_AgeCommitmentHashP phac;
       char *partner_url = NULL;
 
       TEH_plugin->rollback (TEH_plugin->cls);

src/exchange/taler-exchange-httpd_refreshes_reveal.c

@@ -263,8 +263,8 @@ check_commitment (struct RevealContext *rctx,
         const struct TALER_TransferPrivateKeyP *tpriv
           = &rctx->transfer_privs[i - off];
         struct TALER_TransferSecretP ts;
-        struct TALER_AgeCommitmentHash h = {0};
-        struct TALER_AgeCommitmentHash *hac = NULL;
+        struct TALER_AgeCommitmentHashP h = {0};
+        struct TALER_AgeCommitmentHashP *hac = NULL;
 
         GNUNET_CRYPTO_ecdhe_key_get_public (&tpriv->ecdhe_priv,
                                             &rce->transfer_pub.ecdhe_pub);
@@ -657,11 +657,11 @@ resolve_refreshes_reveal_denominations (
 
     /* Sanity check: Compare hash from melting with hash of this age commitment */
     {
-      struct TALER_AgeCommitmentHash hac = {0};
+      struct TALER_AgeCommitmentHashP hac = {0};
       TALER_age_commitment_hash (oac, &hac);
       if (0 != memcmp (&hac,
                        &rctx->melt.session.coin.h_age_commitment,
-                       sizeof(struct TALER_AgeCommitmentHash)))
+                       sizeof(struct TALER_AgeCommitmentHashP)))
         goto clean_age;
     }
 

src/exchange/taler-exchange-httpd_responses.c

@@ -129,7 +129,7 @@ TEH_RESPONSE_compile_transaction_history (
       {
         const struct TALER_EXCHANGEDB_MeltListEntry *melt =
           pos->details.melt;
-        const struct TALER_AgeCommitmentHash *phac = NULL;
+        const struct TALER_AgeCommitmentHashP *phac = NULL;
 
 #if ENABLE_SANITY_CHECKS
         TEH_METRICS_num_verifications[TEH_MT_SIGNATURE_EDDSA]++;
@@ -391,7 +391,7 @@ TEH_RESPONSE_compile_transaction_history (
       {
         struct TALER_EXCHANGEDB_PurseDepositListEntry *pd
           = pos->details.purse_deposit;
-        const struct TALER_AgeCommitmentHash *phac = NULL;
+        const struct TALER_AgeCommitmentHashP *phac = NULL;
 
         if (! pd->no_age_commitment)
           phac = &pd->h_age_commitment;

src/exchangedb/Makefile.am

@@ -114,6 +114,7 @@ libtaler_plugin_exchangedb_postgres_la_SOURCES = \
   pg_drain_kyc_alert.h pg_drain_kyc_alert.c \
   pg_reserves_in_insert.h pg_reserves_in_insert.c \
   pg_get_withdraw_info.h pg_get_withdraw_info.c \
+  pg_get_age_withdraw_info.c pg_get_age_withdraw_info.h \
   pg_do_batch_withdraw.h pg_do_batch_withdraw.c \
   pg_get_policy_details.h pg_get_policy_details.c \
   pg_persist_policy_details.h pg_persist_policy_details.c \

src/exchangedb/pg_ensure_coin_known.c

@@ -28,10 +28,10 @@
 
 enum TALER_EXCHANGEDB_CoinKnownStatus
 TEH_PG_ensure_coin_known (void *cls,
-                            const struct TALER_CoinPublicInfo *coin,
-                            uint64_t *known_coin_id,
-                            struct TALER_DenominationHashP *denom_hash,
-                            struct TALER_AgeCommitmentHash *h_age_commitment)
+                          const struct TALER_CoinPublicInfo *coin,
+                          uint64_t *known_coin_id,
+                          struct TALER_DenominationHashP *denom_hash,
+                          struct TALER_AgeCommitmentHashP *h_age_commitment)
 {
   struct PostgresClosure *pg = cls;
   enum GNUNET_DB_QueryStatus qs;
@@ -60,12 +60,12 @@ TEH_PG_ensure_coin_known (void *cls,
       &is_age_hash_null),
     GNUNET_PQ_result_spec_end
   };
-    /* Used in #postgres_insert_known_coin() to store the denomination public
-       key and signature for a coin known to the exchange.
+  /* Used in #postgres_insert_known_coin() to store the denomination public
+     key and signature for a coin known to the exchange.
 
-       See also:
-       https://stackoverflow.com/questions/34708509/how-to-use-returning-with-on-conflict-in-postgresql/37543015#37543015
-     */
+     See also:
+     https://stackoverflow.com/questions/34708509/how-to-use-returning-with-on-conflict-in-postgresql/37543015#37543015
+   */
   PREPARE (pg,
            "insert_known_coin",
            "WITH dd"

src/exchangedb/pg_ensure_coin_known.h

@@ -37,9 +37,9 @@
  */
 enum TALER_EXCHANGEDB_CoinKnownStatus
 TEH_PG_ensure_coin_known (void *cls,
-                            const struct TALER_CoinPublicInfo *coin,
-                            uint64_t *known_coin_id,
-                            struct TALER_DenominationHashP *denom_hash,
-                          struct TALER_AgeCommitmentHash *h_age_commitment);
+                          const struct TALER_CoinPublicInfo *coin,
+                          uint64_t *known_coin_id,
+                          struct TALER_DenominationHashP *denom_hash,
+                          struct TALER_AgeCommitmentHashP *h_age_commitment);
 
 #endif

src/exchangedb/pg_get_age_withdraw_info.c

@@ -0,0 +1,80 @@
+/*
+   This file is part of TALER
+   Copyright (C) 2023 Taler Systems SA
+
+   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, see <http://www.gnu.org/licenses/>
+ */
+/**
+ * @file exchangedb/pg_get_age_withdraw_info.c
+ * @brief Implementation of the get_age_withdraw_info function for Postgres
+ * @author Özgür Kesim
+ */
+#include "platform.h"
+#include "taler_error_codes.h"
+#include "taler_dbevents.h"
+#include "taler_pq_lib.h"
+#include "pg_get_age_withdraw_info.h"
+#include "pg_helper.h"
+
+
+enum GNUNET_DB_QueryStatus
+TEH_PG_get_age_withdraw_info (
+  void *cls,
+  const struct TALER_ReservePublicKeyP *reserve_pub,
+  const struct TALER_AgeWithdrawCommitmentHashP *ach,
+  struct TALER_EXCHANGEDB_AgeWithdrawCommitment *awc)
+{
+  struct PostgresClosure *pg = cls;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (ach),
+    GNUNET_PQ_query_param_end
+  };
+  struct GNUNET_PQ_ResultSpec rs[] = {
+    GNUNET_PQ_result_spec_auto_from_type ("h_commitment",
+                                          &awc->h_commitment),
+    GNUNET_PQ_result_spec_auto_from_type ("reserve_sig",
+                                          &awc->reserve_sig),
+    GNUNET_PQ_result_spec_auto_from_type ("reserve_pub",
+                                          &awc->reserve_pub),
+    GNUNET_PQ_result_spec_uint32 ("max_age_group",
+                                  &awc->max_age_group),
+    TALER_PQ_RESULT_SPEC_AMOUNT ("amount_with_fee",
+                                 &awc->amount_with_fee),
+    GNUNET_PQ_result_spec_uint32 ("noreveal_index",
+                                  &awc->noreveal_index),
+    GNUNET_PQ_result_spec_timestamp ("timtestamp",
+                                     &awc->timestamp),
+    GNUNET_PQ_result_spec_end
+  };
+
+  /* Used in #postgres_get_age_withdraw_info() to
+     locate the response for a /reserve/$RESERVE_PUB/age-withdraw request using
+     the hash of the blinded message.  Used to make sure
+     /reserve/$RESERVE_PUB/age-withdraw requests are idempotent. */
+  PREPARE (pg,
+           "get_age_withdraw_info",
+           "SELECT"
+           " h_commitment"
+           ",reserve_sig"
+           ",reserve_pub"
+           ",max_age_group"
+           ",amount_with_fee_val"
+           ",amount_with_fee_frac"
+           ",noreveal_index"
+           ",timestamp"
+           " FROM withdraw_age_commitments"
+           " WHERE h_commitment=$1;");
+  return GNUNET_PQ_eval_prepared_singleton_select (pg->conn,
+                                                   "get_age_withdraw_info",
+                                                   params,
+                                                   rs);
+}

src/exchangedb/pg_get_age_withdraw_info.h

@@ -0,0 +1,45 @@
+/*
+   This file is part of TALER
+   Copyright (C) 2023 Taler Systems SA
+
+   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, see <http://www.gnu.org/licenses/>
+ */
+/**
+ * @file exchangedb/pg_get_age_withdraw_info.h
+ * @brief implementation of the get_age_withdraw_info function for Postgres
+ * @author Özgür KESIM
+ */
+#ifndef PG_GET_AGE_WITHDRAW_INFO_H
+#define PG_GET_AGE_WITHDRAW_INFO_H
+
+#include "taler_util.h"
+#include "taler_json_lib.h"
+#include "taler_exchangedb_plugin.h"
+
+/**
+   * Locate the response for a age-withdraw request under a hash that uniquely
+   * identifies the age-withdraw operation.  Used to ensure idempotency of the
+   * request.
+   *
+   * @param cls the @e cls of this struct with the plugin-specific state
+   * @param reserve_pub public key of the reserve for which the age-withdraw request is made
+   * @param ach hash that uniquely identifies the age-withdraw operation
+   * @param[out] awc corresponding details of the previous age-withdraw request if an entry was found
+   * @return statement execution status
+   */
+enum GNUNET_DB_QueryStatus
+TEH_PG_get_age_withdraw_info (void *cls,
+                              const struct TALER_ReservePublicKeyP *reserve_pub,
+                              const struct
+                              TALER_AgeWithdrawCommitmentHashP *ach,
+                              struct TALER_EXCHANGEDB_AgeWithdrawCommitment *awc);
+#endif

src/exchangedb/pg_get_purse_deposit.c

@@ -32,7 +32,7 @@ TEH_PG_get_purse_deposit (
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   struct TALER_Amount *amount,
   struct TALER_DenominationHashP *h_denom_pub,
-  struct TALER_AgeCommitmentHash *phac,
+  struct TALER_AgeCommitmentHashP *phac,
   struct TALER_CoinSpendSignatureP *coin_sig,
   char **partner_url)
 {
@@ -61,7 +61,7 @@ TEH_PG_get_purse_deposit (
 
 
   *partner_url = NULL;
- /* Used in #postgres_get_purse_deposit */
+  /* Used in #postgres_get_purse_deposit */
   PREPARE (pg,
            "select_purse_deposit_by_coin_pub",
            "SELECT "

src/exchangedb/pg_get_purse_deposit.h

@@ -46,7 +46,7 @@ TEH_PG_get_purse_deposit (
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   struct TALER_Amount *amount,
   struct TALER_DenominationHashP *h_denom_pub,
-  struct TALER_AgeCommitmentHash *phac,
+  struct TALER_AgeCommitmentHashP *phac,
   struct TALER_CoinSpendSignatureP *coin_sig,
   char **partner_url);
 

src/exchangedb/pg_select_refreshes_above_serial_id.c

@@ -75,7 +75,7 @@ refreshs_serial_helper_cb (void *cls,
     struct TALER_DenominationPublicKey denom_pub;
     struct TALER_CoinSpendPublicKeyP coin_pub;
     struct TALER_CoinSpendSignatureP coin_sig;
-    struct TALER_AgeCommitmentHash h_age_commitment;
+    struct TALER_AgeCommitmentHashP h_age_commitment;
     bool ac_isnull;
     struct TALER_Amount amount_with_fee;
     uint32_t noreveal_index;
@@ -130,10 +130,6 @@ refreshs_serial_helper_cb (void *cls,
 }
 
 
-
-
-
-
 enum GNUNET_DB_QueryStatus
 TEH_PG_select_refreshes_above_serial_id (
   void *cls,
@@ -153,8 +149,8 @@ TEH_PG_select_refreshes_above_serial_id (
     .status = GNUNET_OK
   };
   enum GNUNET_DB_QueryStatus qs;
-    /* Used in #postgres_select_refreshes_above_serial_id() to fetch
-       refresh session with id '\geq' the given parameter */
+  /* Used in #postgres_select_refreshes_above_serial_id() to fetch
+     refresh session with id '\geq' the given parameter */
   PREPARE (pg,
            "audit_get_refresh_commitments_incr",
            "SELECT"

src/exchangedb/plugin_exchangedb_postgres.c

@@ -115,6 +115,7 @@
 #include "pg_drain_kyc_alert.h"
 #include "pg_reserves_in_insert.h"
 #include "pg_get_withdraw_info.h"
+#include "pg_get_age_withdraw_info.h"
 #include "pg_do_batch_withdraw.h"
 #include "pg_get_policy_details.h"
 #include "pg_persist_policy_details.h"
@@ -577,6 +578,8 @@ libtaler_plugin_exchangedb_postgres_init (void *cls)
     = &TEH_PG_reserves_in_insert;
   plugin->get_withdraw_info
     = &TEH_PG_get_withdraw_info;
+  plugin->get_age_withdraw_info
+    = &TEH_PG_get_age_withdraw_info;
   plugin->do_batch_withdraw
     = &TEH_PG_do_batch_withdraw;
   plugin->get_policy_details

src/exchangedb/test_exchangedb.c

@@ -449,7 +449,7 @@ audit_refresh_session_cb (
   void *cls,
   uint64_t rowid,
   const struct TALER_DenominationPublicKey *denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_CoinSpendSignatureP *coin_sig,
   const struct TALER_Amount *amount_with_fee,
@@ -1340,8 +1340,8 @@ run (void *cls)
   {
     struct TALER_PlanchetDetail pd;
     struct TALER_CoinSpendPublicKeyP coin_pub;
-    struct TALER_AgeCommitmentHash age_hash;
-    struct TALER_AgeCommitmentHash *p_ah[2] = {
+    struct TALER_AgeCommitmentHashP age_hash;
+    struct TALER_AgeCommitmentHashP *p_ah[2] = {
       NULL,
       &age_hash
     };
@@ -1465,7 +1465,7 @@ run (void *cls)
   deadline = GNUNET_TIME_timestamp_get ();
   {
     struct TALER_DenominationHashP dph;
-    struct TALER_AgeCommitmentHash agh;
+    struct TALER_AgeCommitmentHashP agh;
 
     FAILIF (TALER_EXCHANGEDB_CKS_ADDED !=
             plugin->ensure_coin_known (plugin->cls,
@@ -1713,7 +1713,7 @@ run (void *cls)
     uint64_t new_known_coin_id;
     struct TALER_CoinPublicInfo new_coin;
     struct TALER_DenominationHashP dph;
-    struct TALER_AgeCommitmentHash agh;
+    struct TALER_AgeCommitmentHashP agh;
     bool recoup_ok;
     bool internal_failure;
 
@@ -2086,7 +2086,7 @@ run (void *cls)
   {
     uint64_t known_coin_id;
     struct TALER_DenominationHashP dph;
-    struct TALER_AgeCommitmentHash agh;
+    struct TALER_AgeCommitmentHashP agh;
 
     FAILIF (TALER_EXCHANGEDB_CKS_ADDED !=
             plugin->ensure_coin_known (plugin->cls,

src/exchangedb/test_exchangedb_populate_link_data.c

@@ -29,7 +29,7 @@
  */
 #define FAILIF(cond)                            \
   do {                                          \
-      if (! (cond)) {break;}                    \
+    if (! (cond)) {break;}                    \
     GNUNET_break (0);                           \
     goto drop;                                  \
   } while (0)
@@ -166,6 +166,7 @@ create_denom_key_pair (unsigned int size,
   return dkp;
 }
 
+
 /**
  * Function called with the session hashes and transfer secret
  * information for a given coin.
@@ -219,25 +220,25 @@ run (void *cls)
   struct GNUNET_CONFIGURATION_Handle *cfg = cls;
   const uint32_t num_partitions = 10;
   struct DenomKeyPair *dkp = NULL;
-  struct TALER_EXCHANGEDB_Deposit *depos=NULL;
+  struct TALER_EXCHANGEDB_Deposit *depos = NULL;
   struct TALER_Amount value;
   struct TALER_DenominationPublicKey *new_denom_pubs = NULL;
   struct GNUNET_TIME_Relative times = GNUNET_TIME_UNIT_ZERO;
-  unsigned long long sqrs=0;
-  struct TALER_EXCHANGEDB_Refund *ref=NULL;
+  unsigned long long sqrs = 0;
+  struct TALER_EXCHANGEDB_Refund *ref = NULL;
   unsigned int *perm;
   unsigned long long duration_sq;
   struct TALER_EXCHANGEDB_RefreshRevealedCoin *ccoin;
   struct TALER_ExchangeWithdrawValues alg_values = {
     .cipher = TALER_DENOMINATION_RSA
-    };
+  };
 
-  ref = GNUNET_new_array (ROUNDS +1,
+  ref = GNUNET_new_array (ROUNDS + 1,
                           struct TALER_EXCHANGEDB_Refund);
-  depos = GNUNET_new_array (ROUNDS +1,
+  depos = GNUNET_new_array (ROUNDS + 1,
                             struct TALER_EXCHANGEDB_Deposit);
-  refresh = GNUNET_new_array (ROUNDS +1,
-                            struct TALER_EXCHANGEDB_Refresh);
+  refresh = GNUNET_new_array (ROUNDS + 1,
+                              struct TALER_EXCHANGEDB_Refresh);
 
   if (NULL ==
       (plugin = TALER_EXCHANGEDB_plugin_load (cfg)))
@@ -278,140 +279,140 @@ run (void *cls)
   GNUNET_assert (GNUNET_OK ==
                  TALER_string_to_amount (CURRENCY ":0.000010",
                                          &fees.refund));
-  //DENOMINATION
+  // DENOMINATION
   {
-    //PAIR KEY LIST
+    // PAIR KEY LIST
     new_dkp = GNUNET_new_array (MELT_NEW_COINS,
-                              struct DenomKeyPair *);
-    //PUBLIC KEY LIST
+                                struct DenomKeyPair *);
+    // PUBLIC KEY LIST
     new_denom_pubs = GNUNET_new_array (MELT_NEW_COINS,
                                        struct TALER_DenominationPublicKey);
-    //REFRESH REVEAL COIN LIST
+    // REFRESH REVEAL COIN LIST
     revealed_coins
       = GNUNET_new_array (MELT_NEW_COINS,
                           struct TALER_EXCHANGEDB_RefreshRevealedCoin);
     for (unsigned int cnt = 0; cnt < MELT_NEW_COINS; cnt++)
-      {
-        struct GNUNET_TIME_Timestamp now;
-        struct TALER_BlindedRsaPlanchet *rp;
-        struct TALER_BlindedPlanchet *bp;
+    {
+      struct GNUNET_TIME_Timestamp now;
+      struct TALER_BlindedRsaPlanchet *rp;
+      struct TALER_BlindedPlanchet *bp;
 
-        now = GNUNET_TIME_timestamp_get ();
-        //5 KEY PAIR
-        new_dkp[cnt] = create_denom_key_pair (RSA_KEY_SIZE,
-                                              now,
-                                              &value,
-                                              &fees);
-        GNUNET_assert (NULL != new_dkp[cnt]);
-        new_denom_pubs[cnt] = new_dkp[cnt]->pub;
-        ccoin = &revealed_coins[cnt];
-        bp = &ccoin->blinded_planchet;
-        bp->cipher = TALER_DENOMINATION_RSA;
-        rp = &bp->details.rsa_blinded_planchet;
-        rp->blinded_msg_size = 1 + (size_t) GNUNET_CRYPTO_random_u64 (
-                                                                      GNUNET_CRYPTO_QUALITY_WEAK,
-                                                                      (RSA_KEY_SIZE / 8) - 1);
-        rp->blinded_msg = GNUNET_malloc (rp->blinded_msg_size);
-        GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                                    rp->blinded_msg,
-                                    rp->blinded_msg_size);
-        TALER_denom_pub_hash (&new_dkp[cnt]->pub,
-                              &ccoin->h_denom_pub);
-        ccoin->exchange_vals = alg_values;
-        TALER_coin_ev_hash (bp,
-                            &ccoin->h_denom_pub,
-                            &ccoin->coin_envelope_hash);
-        GNUNET_assert (GNUNET_OK ==
+      now = GNUNET_TIME_timestamp_get ();
+      // 5 KEY PAIR
+      new_dkp[cnt] = create_denom_key_pair (RSA_KEY_SIZE,
+                                            now,
+                                            &value,
+                                            &fees);
+      GNUNET_assert (NULL != new_dkp[cnt]);
+      new_denom_pubs[cnt] = new_dkp[cnt]->pub;
+      ccoin = &revealed_coins[cnt];
+      bp = &ccoin->blinded_planchet;
+      bp->cipher = TALER_DENOMINATION_RSA;
+      rp = &bp->details.rsa_blinded_planchet;
+      rp->blinded_msg_size = 1 + (size_t) GNUNET_CRYPTO_random_u64 (
+        GNUNET_CRYPTO_QUALITY_WEAK,
+        (RSA_KEY_SIZE / 8) - 1);
+      rp->blinded_msg = GNUNET_malloc (rp->blinded_msg_size);
+      GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  rp->blinded_msg,
+                                  rp->blinded_msg_size);
+      TALER_denom_pub_hash (&new_dkp[cnt]->pub,
+                            &ccoin->h_denom_pub);
+      ccoin->exchange_vals = alg_values;
+      TALER_coin_ev_hash (bp,
+                          &ccoin->h_denom_pub,
+                          &ccoin->coin_envelope_hash);
+      GNUNET_assert (GNUNET_OK ==
                      TALER_denom_sign_blinded (&ccoin->coin_sig,
                                                &new_dkp[cnt]->priv,
                                                true,
                                                bp));
-      }
+    }
   }
   perm = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_NONCE,
                                        NUM_ROWS);
-  //BEGIN
+  // BEGIN
   FAILIF (GNUNET_OK !=
           plugin->start (plugin->cls,
                          "Transaction"));
   for (unsigned int j = 0; j < NUM_ROWS; j++)
-    {
-      union TALER_DenominationBlindingKeyP bks;
-      struct TALER_CoinSpendPublicKeyP coin_pub;
-      struct TALER_CoinPubHashP c_hash;
-      unsigned int k = (unsigned int)rand()%5;
-      unsigned int i = perm[j];
-      if (i >= ROUNDS)
-        i = ROUNDS; /* throw-away slot, do not keep around */
-      RND_BLK (&coin_pub);
-      RND_BLK (&c_hash);
+  {
+    union TALER_DenominationBlindingKeyP bks;
+    struct TALER_CoinSpendPublicKeyP coin_pub;
+    struct TALER_CoinPubHashP c_hash;
+    unsigned int k = (unsigned int) rand () % 5;
+    unsigned int i = perm[j];
+    if (i >= ROUNDS)
+      i = ROUNDS;   /* throw-away slot, do not keep around */
+    RND_BLK (&coin_pub);
+    RND_BLK (&c_hash);
 
-      RND_BLK (&depos[i].coin.coin_pub);
-      TALER_denom_pub_hash (&new_dkp[k]->pub,
-                            &depos[i].coin.denom_pub_hash);
-      GNUNET_assert (GNUNET_OK ==
-                     TALER_denom_sig_unblind (&depos[i].coin.denom_sig,
-                                              &ccoin->coin_sig,
-                                              &bks,
-                                              &c_hash,
-                                              &alg_values,
-                                              &new_dkp[k]->pub));
-      {
-        /* ENSURE_COIN_KNOWN */
-        uint64_t known_coin_id;
-        struct TALER_DenominationHashP dph;
-        struct TALER_AgeCommitmentHash agh;
-        bool zombie_required = false;
-        bool balance_ok;
-        FAILIF (TALER_EXCHANGEDB_CKS_ADDED !=
-                plugin->ensure_coin_known (plugin->cls,
-                                           &depos[i].coin,
-                                           &known_coin_id,
-                                           &dph,
-                                           &agh));
-        /**** INSERT REFRESH COMMITMENTS ****/
-        refresh[i].coin = depos[i].coin;
-        RND_BLK (&refresh[i].coin_sig);
-        RND_BLK (&refresh[i].rc);
-        refresh[i].amount_with_fee = value;
-        refresh[i].noreveal_index = MELT_NOREVEAL_INDEX;
-        FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
-                plugin->do_melt (plugin->cls,
-                                 NULL,
-                                 &refresh[i],
-                                 known_coin_id,
-                                 &zombie_required,
-                                 &balance_ok));
-        FAILIF (! balance_ok);
-        FAILIF (zombie_required);
-      }
-      /**** INSERT REFRESH_REVEAL + TRANSFER_KEYS *****/
-        RND_BLK (&tprivs);
-        RND_BLK (&tpub);
-        RND_BLK(&melt_serial_id);
-        FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
-                plugin->insert_refresh_reveal (plugin->cls,
-                                               melt_serial_id,
-                                               MELT_NEW_COINS,
-                                               revealed_coins,
-                                               TALER_CNC_KAPPA - 1,
-                                               tprivs,
-                                               &tpub));
-        if (ROUNDS == i)
-          TALER_denom_sig_free (&depos[i].coin.denom_sig);
+    RND_BLK (&depos[i].coin.coin_pub);
+    TALER_denom_pub_hash (&new_dkp[k]->pub,
+                          &depos[i].coin.denom_pub_hash);
+    GNUNET_assert (GNUNET_OK ==
+                   TALER_denom_sig_unblind (&depos[i].coin.denom_sig,
+                                            &ccoin->coin_sig,
+                                            &bks,
+                                            &c_hash,
+                                            &alg_values,
+                                            &new_dkp[k]->pub));
+    {
+      /* ENSURE_COIN_KNOWN */
+      uint64_t known_coin_id;
+      struct TALER_DenominationHashP dph;
+      struct TALER_AgeCommitmentHashP agh;
+      bool zombie_required = false;
+      bool balance_ok;
+      FAILIF (TALER_EXCHANGEDB_CKS_ADDED !=
+              plugin->ensure_coin_known (plugin->cls,
+                                         &depos[i].coin,
+                                         &known_coin_id,
+                                         &dph,
+                                         &agh));
+      /**** INSERT REFRESH COMMITMENTS ****/
+      refresh[i].coin = depos[i].coin;
+      RND_BLK (&refresh[i].coin_sig);
+      RND_BLK (&refresh[i].rc);
+      refresh[i].amount_with_fee = value;
+      refresh[i].noreveal_index = MELT_NOREVEAL_INDEX;
+      FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
+              plugin->do_melt (plugin->cls,
+                               NULL,
+                               &refresh[i],
+                               known_coin_id,
+                               &zombie_required,
+                               &balance_ok));
+      FAILIF (! balance_ok);
+      FAILIF (zombie_required);
     }
+    /**** INSERT REFRESH_REVEAL + TRANSFER_KEYS *****/
+    RND_BLK (&tprivs);
+    RND_BLK (&tpub);
+    RND_BLK (&melt_serial_id);
+    FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
+            plugin->insert_refresh_reveal (plugin->cls,
+                                           melt_serial_id,
+                                           MELT_NEW_COINS,
+                                           revealed_coins,
+                                           TALER_CNC_KAPPA - 1,
+                                           tprivs,
+                                           &tpub));
+    if (ROUNDS == i)
+      TALER_denom_sig_free (&depos[i].coin.denom_sig);
+  }
   /* End of benchmark setup */
-  GNUNET_free(perm);
+  GNUNET_free (perm);
   // commit
   FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
           plugin->commit (plugin->cls));
   /**** CALL GET LINK DATA ****/
-  for (unsigned int r=0; r< ROUNDS; r++)
+  for (unsigned int r = 0; r< ROUNDS; r++)
   {
     struct GNUNET_TIME_Absolute time;
     struct GNUNET_TIME_Relative duration;
     enum GNUNET_DB_QueryStatus qs;
-    time = GNUNET_TIME_absolute_get();
+    time = GNUNET_TIME_absolute_get ();
     qs = plugin->get_link_data (plugin->cls,
                                 &refresh[r].coin.coin_pub,
                                 &handle_link_data_cb,
@@ -422,7 +423,8 @@ run (void *cls)
     times = GNUNET_TIME_relative_add (times,
                                       duration);
     duration_sq = duration.rel_value_us * duration.rel_value_us;
-    GNUNET_assert (duration_sq / duration.rel_value_us == duration.rel_value_us);
+    GNUNET_assert (duration_sq / duration.rel_value_us ==
+                   duration.rel_value_us);
     GNUNET_assert (sqrs + duration_sq >= sqrs);
     sqrs += duration_sq;
   }
@@ -437,15 +439,15 @@ run (void *cls)
                                        ROUNDS);
     avg_dbl = avg.rel_value_us;
     variance = sqrs - (avg_dbl * avg_dbl * ROUNDS);
-    fprintf(stdout,
-            "%8llu ± %6.0f\n",
-            (unsigned long long) avg.rel_value_us,
-            sqrt (variance / (ROUNDS-1)));
+    fprintf (stdout,
+             "%8llu ± %6.0f\n",
+             (unsigned long long) avg.rel_value_us,
+             sqrt (variance / (ROUNDS - 1)));
   }
   result = 0;
 drop:
   GNUNET_break (GNUNET_OK ==
-  plugin->drop_tables (plugin->cls));
+                plugin->drop_tables (plugin->cls));
 cleanup:
   if (NULL != dkp)
     destroy_denom_key_pair (dkp);
@@ -465,13 +467,13 @@ cleanup:
        cnt++)
     destroy_denom_key_pair (new_dkp[cnt]);
   GNUNET_free (new_dkp);
-  for (unsigned int i=0; i< ROUNDS; i++)
-    {
-      TALER_denom_sig_free (&depos[i].coin.denom_sig);
-    }
-  GNUNET_free(depos);
-  GNUNET_free(ref);
-  GNUNET_free(refresh);
+  for (unsigned int i = 0; i< ROUNDS; i++)
+  {
+    TALER_denom_sig_free (&depos[i].coin.denom_sig);
+  }
+  GNUNET_free (depos);
+  GNUNET_free (ref);
+  GNUNET_free (refresh);
   dkp = NULL;
   TALER_EXCHANGEDB_plugin_unload (plugin);
   plugin = NULL;

src/exchangedb/test_exchangedb_populate_ready_deposit.c

@@ -34,7 +34,7 @@ static int result;
  */
 #define FAILIF(cond)                            \
   do {                                          \
-      if (! (cond)) {break;}                    \
+    if (! (cond)) {break;}                    \
     GNUNET_break (0);                           \
     goto drop;                                  \
   } while (0)
@@ -173,8 +173,6 @@ create_denom_key_pair (unsigned int size,
 }
 
 
-
-
 /**
  * Main function that will be run by the scheduler.
  *
@@ -191,19 +189,19 @@ run (void *cls)
   struct TALER_EXCHANGEDB_CollectableBlindcoin cbc;
   struct TALER_DenominationPublicKey *new_denom_pubs = NULL;
   struct GNUNET_TIME_Relative times = GNUNET_TIME_UNIT_ZERO;
-  unsigned long long sqrs=0;
-  struct TALER_EXCHANGEDB_Deposit *depos=NULL;
-  struct TALER_EXCHANGEDB_Refund *ref=NULL;
+  unsigned long long sqrs = 0;
+  struct TALER_EXCHANGEDB_Deposit *depos = NULL;
+  struct TALER_EXCHANGEDB_Refund *ref = NULL;
   unsigned int *perm;
   unsigned long long duration_sq;
   struct TALER_EXCHANGEDB_RefreshRevealedCoin *ccoin;
   struct TALER_ExchangeWithdrawValues alg_values = {
     .cipher = TALER_DENOMINATION_RSA
-    };
+  };
 
-  ref = GNUNET_new_array (ROUNDS +1,
+  ref = GNUNET_new_array (ROUNDS + 1,
                           struct TALER_EXCHANGEDB_Refund);
-  depos = GNUNET_new_array (ROUNDS +1,
+  depos = GNUNET_new_array (ROUNDS + 1,
                             struct TALER_EXCHANGEDB_Deposit);
 
   if (NULL ==
@@ -245,75 +243,122 @@ run (void *cls)
   GNUNET_assert (GNUNET_OK ==
                  TALER_string_to_amount (CURRENCY ":0.000010",
                                          &fees.refund));
-  //DENOMINATION
+  // DENOMINATION
   {
     ZR_BLK (&cbc);
-    //PAIR KEY LIST
+    // PAIR KEY LIST
     new_dkp = GNUNET_new_array (MELT_NEW_COINS,
-                              struct DenomKeyPair *);
-    //PUBLIC KEY LIST
+                                struct DenomKeyPair *);
+    // PUBLIC KEY LIST
     new_denom_pubs = GNUNET_new_array (MELT_NEW_COINS,
                                        struct TALER_DenominationPublicKey);
-    //REFRESH REVEAL COIN LIST
+    // REFRESH REVEAL COIN LIST
     revealed_coins
       = GNUNET_new_array (MELT_NEW_COINS,
                           struct TALER_EXCHANGEDB_RefreshRevealedCoin);
     for (unsigned int cnt = 0; cnt < MELT_NEW_COINS; cnt++)
-      {
-        struct GNUNET_TIME_Timestamp now;
-        struct TALER_BlindedRsaPlanchet *rp;
-        struct TALER_BlindedPlanchet *bp;
+    {
+      struct GNUNET_TIME_Timestamp now;
+      struct TALER_BlindedRsaPlanchet *rp;
+      struct TALER_BlindedPlanchet *bp;
 
-        now = GNUNET_TIME_timestamp_get ();
-        //5 KEY PAIR
-        new_dkp[cnt] = create_denom_key_pair (RSA_KEY_SIZE,
-                                              now,
-                                              &value,
-                                              &fees);
-        GNUNET_assert (NULL != new_dkp[cnt]);
-        new_denom_pubs[cnt] = new_dkp[cnt]->pub;
-        ccoin = &revealed_coins[cnt];
-        bp = &ccoin->blinded_planchet;
-        bp->cipher = TALER_DENOMINATION_RSA;
-        rp = &bp->details.rsa_blinded_planchet;
-        rp->blinded_msg_size = 1 + (size_t) GNUNET_CRYPTO_random_u64 (
-                                                                      GNUNET_CRYPTO_QUALITY_WEAK,
-                                                                      (RSA_KEY_SIZE / 8) - 1);
-        rp->blinded_msg = GNUNET_malloc (rp->blinded_msg_size);
-        GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                                    rp->blinded_msg,
-                                    rp->blinded_msg_size);
-        TALER_denom_pub_hash (&new_dkp[cnt]->pub,
-                              &ccoin->h_denom_pub);
-        ccoin->exchange_vals = alg_values;
-        TALER_coin_ev_hash (bp,
-                            &ccoin->h_denom_pub,
-                            &ccoin->coin_envelope_hash);
-        GNUNET_assert (GNUNET_OK ==
+      now = GNUNET_TIME_timestamp_get ();
+      // 5 KEY PAIR
+      new_dkp[cnt] = create_denom_key_pair (RSA_KEY_SIZE,
+                                            now,
+                                            &value,
+                                            &fees);
+      GNUNET_assert (NULL != new_dkp[cnt]);
+      new_denom_pubs[cnt] = new_dkp[cnt]->pub;
+      ccoin = &revealed_coins[cnt];
+      bp = &ccoin->blinded_planchet;
+      bp->cipher = TALER_DENOMINATION_RSA;
+      rp = &bp->details.rsa_blinded_planchet;
+      rp->blinded_msg_size = 1 + (size_t) GNUNET_CRYPTO_random_u64 (
+        GNUNET_CRYPTO_QUALITY_WEAK,
+        (RSA_KEY_SIZE / 8) - 1);
+      rp->blinded_msg = GNUNET_malloc (rp->blinded_msg_size);
+      GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  rp->blinded_msg,
+                                  rp->blinded_msg_size);
+      TALER_denom_pub_hash (&new_dkp[cnt]->pub,
+                            &ccoin->h_denom_pub);
+      ccoin->exchange_vals = alg_values;
+      TALER_coin_ev_hash (bp,
+                          &ccoin->h_denom_pub,
+                          &ccoin->coin_envelope_hash);
+      GNUNET_assert (GNUNET_OK ==
                      TALER_denom_sign_blinded (&ccoin->coin_sig,
                                                &new_dkp[cnt]->priv,
                                                true,
                                                bp));
-        GNUNET_assert (GNUNET_OK ==
-                       TALER_coin_ev_hash (bp,
-                                           &cbc.denom_pub_hash,
-                                           &cbc.h_coin_envelope));
-        GNUNET_assert (
-                       GNUNET_OK ==
-                       TALER_denom_sign_blinded (
-                                                 &cbc.sig,
-                                                 &new_dkp[cnt]->priv,
-                                                 false,
-                                                 bp));
-      }
+      GNUNET_assert (GNUNET_OK ==
+                     TALER_coin_ev_hash (bp,
+                                         &cbc.denom_pub_hash,
+                                         &cbc.h_coin_envelope));
+      GNUNET_assert (
+        GNUNET_OK ==
+        TALER_denom_sign_blinded (
+          &cbc.sig,
+          &new_dkp[cnt]->priv,
+          false,
+          bp));
+    }
   }
   perm = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_NONCE,
                                        NUM_ROWS);
-  //BEGIN
+  // BEGIN
   FAILIF (GNUNET_OK !=
           plugin->start (plugin->cls,
                          "Transaction"));
   for (unsigned int j = 0; j < NUM_ROWS; j++)
+  {
+    /*** NEED TO INSERT REFRESH COMMITMENTS + ENSURECOIN ***/
+    union TALER_DenominationBlindingKeyP bks;
+    struct GNUNET_TIME_Timestamp deadline;
+    struct TALER_CoinSpendPublicKeyP coin_pub;
+    struct TALER_ReservePublicKeyP reserve_pub;
+    struct TALER_CoinPubHashP c_hash;
+    unsigned int k = (unsigned int) rand () % 5;
+    unsigned int i = perm[j];
+    if (i >= ROUNDS)
+      i = ROUNDS;   /* throw-away slot, do not keep around */
+    depos[i].deposit_fee = fees.deposit;
+    RND_BLK (&coin_pub);
+    RND_BLK (&c_hash);
+    RND_BLK (&reserve_pub);
+    RND_BLK (&cbc.reserve_sig);
+    TALER_denom_pub_hash (&new_dkp[k]->pub,
+                          &cbc.denom_pub_hash);
+    deadline = GNUNET_TIME_timestamp_get ();
+    RND_BLK (&depos[i].coin.coin_pub);
+    TALER_denom_pub_hash (&new_dkp[k]->pub,
+                          &depos[i].coin.denom_pub_hash);
+    GNUNET_assert (GNUNET_OK ==
+                   TALER_denom_sig_unblind (&depos[i].coin.denom_sig,
+                                            &ccoin->coin_sig,
+                                            &bks,
+                                            &c_hash,
+                                            &alg_values,
+                                            &new_dkp[k]->pub));
+    RND_BLK (&depos[i].merchant_pub);
+    RND_BLK (&depos[i].csig);
+    RND_BLK (&depos[i].h_contract_terms);
+    RND_BLK (&depos[i].wire_salt);
+    depos[i].amount_with_fee = value;
+    depos[i].refund_deadline = deadline;
+    depos[i].wire_deadline = deadline;
+    depos[i].receiver_wire_account =
+      "payto://iban/DE67830654080004822650?receiver-name=Test";
+    TALER_merchant_wire_signature_hash (
+      "payto://iban/DE67830654080004822650?receiver-name=Test",
+      &depos[i].wire_salt,
+      &h_wire_wt);
+    cbc.reserve_pub = reserve_pub;
+    cbc.amount_with_fee = value;
+    GNUNET_assert (GNUNET_OK ==
+                   TALER_amount_set_zero (CURRENCY,
+                                          &cbc.withdraw_fee));
     {
       /*** NEED TO INSERT REFRESH COMMITMENTS + ENSURECOIN ***/
       union TALER_DenominationBlindingKeyP bks;
@@ -331,8 +376,7 @@ run (void *cls)
       RND_BLK (&reserve_pub);
       RND_BLK (&cbc.reserve_sig);
       TALER_denom_pub_hash (&new_dkp[k]->pub,
-                            &cbc.denom_pub_hash);
-      deadline = GNUNET_TIME_timestamp_get ();
+                            &cbc.denom_pub_hash); deadline = GNUNET_TIME_timestamp_get ();
       RND_BLK (&depos[i].coin.coin_pub);
       TALER_denom_pub_hash (&new_dkp[k]->pub,
                             &depos[i].coin.denom_pub_hash);
@@ -408,8 +452,38 @@ run (void *cls)
       if (ROUNDS == i)
         TALER_denom_sig_free (&depos[i].coin.denom_sig);
     }
+
+    {
+      /* ENSURE_COIN_KNOWN */
+      uint64_t known_coin_id;
+      struct TALER_DenominationHashP dph;
+      struct TALER_AgeCommitmentHashP agh;
+      FAILIF (TALER_EXCHANGEDB_CKS_ADDED !=
+              plugin->ensure_coin_known (plugin->cls,
+                                         &depos[i].coin,
+                                         &known_coin_id,
+                                         &dph,
+                                         &agh));
+      refresh.coin = depos[i].coin;
+      RND_BLK (&refresh.coin_sig);
+      RND_BLK (&refresh.rc);
+      refresh.amount_with_fee = value;
+      refresh.noreveal_index = MELT_NOREVEAL_INDEX;
+    }
+    /*STORE INTO DEPOSIT*/
+    {
+      struct GNUNET_TIME_Timestamp now;
+      now = GNUNET_TIME_timestamp_get ();
+      FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
+              plugin->insert_deposit (plugin->cls,
+                                      now,
+                                      &depos[i]));
+    }
+    if (ROUNDS == i)
+      TALER_denom_sig_free (&depos[i].coin.denom_sig);
+  }
   /* End of benchmark setup */
-  GNUNET_free(perm);
+  GNUNET_free (perm);
   // commit
   FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
           plugin->commit (plugin->cls));
@@ -420,7 +494,7 @@ run (void *cls)
     struct GNUNET_TIME_Relative duration;
     struct TALER_MerchantPublicKeyP merchant_pub;
     char *payto_uri;
-    time = GNUNET_TIME_absolute_get();
+    time = GNUNET_TIME_absolute_get ();
     FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
             plugin->get_ready_deposit (plugin->cls,
                                        0,
@@ -432,7 +506,8 @@ run (void *cls)
     times = GNUNET_TIME_relative_add (times,
                                       duration);
     duration_sq = duration.rel_value_us * duration.rel_value_us;
-    GNUNET_assert (duration_sq / duration.rel_value_us == duration.rel_value_us);
+    GNUNET_assert (duration_sq / duration.rel_value_us ==
+                   duration.rel_value_us);
     GNUNET_assert (sqrs + duration_sq >= sqrs);
     sqrs += duration_sq;
   }
@@ -447,15 +522,15 @@ run (void *cls)
                                        ROUNDS);
     avg_dbl = avg.rel_value_us;
     variance = sqrs - (avg_dbl * avg_dbl * ROUNDS);
-    fprintf(stdout,
-            "%8llu ± %6.0f\n",
-            (unsigned long long) avg.rel_value_us,
-            sqrt (variance / (ROUNDS-1)));
+    fprintf (stdout,
+             "%8llu ± %6.0f\n",
+             (unsigned long long) avg.rel_value_us,
+             sqrt (variance / (ROUNDS - 1)));
   }
   result = 0;
 drop:
   GNUNET_break (GNUNET_OK ==
-  plugin->drop_tables (plugin->cls));
+                plugin->drop_tables (plugin->cls));
 cleanup:
   if (NULL != revealed_coins)
   {
@@ -473,12 +548,12 @@ cleanup:
        cnt++)
     destroy_denom_key_pair (new_dkp[cnt]);
   GNUNET_free (new_dkp);
-  for (unsigned int i=0; i< ROUNDS ; i++)
-    {
-      TALER_denom_sig_free (&depos[i].coin.denom_sig);
-    }
-  GNUNET_free(depos);
-  GNUNET_free(ref);
+  for (unsigned int i = 0; i< ROUNDS; i++)
+  {
+    TALER_denom_sig_free (&depos[i].coin.denom_sig);
+  }
+  GNUNET_free (depos);
+  GNUNET_free (ref);
   TALER_EXCHANGEDB_plugin_unload (plugin);
   plugin = NULL;
 }

src/exchangedb/test_exchangedb_populate_select_refunds_by_coin.c

@@ -34,7 +34,7 @@ static int result;
  */
 #define FAILIF(cond)                            \
   do {                                          \
-      if (! (cond)) {break;}                    \
+    if (! (cond)) {break;}                    \
     GNUNET_break (0);                           \
     goto drop;                                  \
   } while (0)
@@ -166,6 +166,8 @@ create_denom_key_pair (unsigned int size,
   }
   return dkp;
 }
+
+
 /**
  * Callback invoked with information about refunds applicable
  * to a particular coin.
@@ -201,7 +203,7 @@ run (void *cls)
   struct GNUNET_CONFIGURATION_Handle *cfg = cls;
   const uint32_t num_partitions = 10;
   struct GNUNET_TIME_Timestamp ts;
-  struct TALER_EXCHANGEDB_Deposit *depos=NULL;
+  struct TALER_EXCHANGEDB_Deposit *depos = NULL;
   struct GNUNET_TIME_Timestamp deadline;
   struct TALER_Amount value;
   union TALER_DenominationBlindingKeyP bks;
@@ -209,10 +211,10 @@ run (void *cls)
   struct TALER_EXCHANGEDB_CollectableBlindcoin cbc;
   struct TALER_ExchangeWithdrawValues alg_values = {
     .cipher = TALER_DENOMINATION_RSA
-    };
+  };
   struct GNUNET_TIME_Relative times = GNUNET_TIME_UNIT_ZERO;
   unsigned long long sqrs = 0;
-  struct TALER_EXCHANGEDB_Refund *ref=NULL;
+  struct TALER_EXCHANGEDB_Refund *ref = NULL;
   unsigned int *perm;
   unsigned long long duration_sq;
   struct TALER_CoinSpendPublicKeyP coin_pub;
@@ -222,7 +224,7 @@ run (void *cls)
 
   ref = GNUNET_new_array (ROUNDS +1,
                           struct TALER_EXCHANGEDB_Refund);
-  depos = GNUNET_new_array (ROUNDS +1,
+  depos = GNUNET_new_array (ROUNDS + 1,
                             struct TALER_EXCHANGEDB_Deposit);
   ZR_BLK (&cbc);
 
@@ -270,66 +272,66 @@ run (void *cls)
 
   ts = GNUNET_TIME_timestamp_get ();
   deadline = GNUNET_TIME_timestamp_get ();
-  //DENOMINATION
+  // DENOMINATION
   {
-    //PAIR KEY LIST
+    // PAIR KEY LIST
     new_dkp = GNUNET_new_array (MELT_NEW_COINS,
-                              struct DenomKeyPair *);
-    //PUBLIC KEY LIST
+                                struct DenomKeyPair *);
+    // PUBLIC KEY LIST
     new_denom_pubs = GNUNET_new_array (MELT_NEW_COINS,
                                        struct TALER_DenominationPublicKey);
-    //REFRESH REVEAL COIN LIST
+    // REFRESH REVEAL COIN LIST
     revealed_coins
       = GNUNET_new_array (MELT_NEW_COINS,
                           struct TALER_EXCHANGEDB_RefreshRevealedCoin);
     for (unsigned int cnt = 0; cnt < MELT_NEW_COINS; cnt++)
-      {
-        struct GNUNET_TIME_Timestamp now;
-        struct TALER_BlindedRsaPlanchet *rp;
-        struct TALER_BlindedPlanchet *bp;
+    {
+      struct GNUNET_TIME_Timestamp now;
+      struct TALER_BlindedRsaPlanchet *rp;
+      struct TALER_BlindedPlanchet *bp;
 
-        now = GNUNET_TIME_timestamp_get ();
-        //5 KEY PAIR
-        new_dkp[cnt] = create_denom_key_pair (RSA_KEY_SIZE,
-                                              now,
-                                              &value,
-                                              &fees);
-        GNUNET_assert (NULL != new_dkp[cnt]);
-        new_denom_pubs[cnt] = new_dkp[cnt]->pub;
-        ccoin = &revealed_coins[cnt];
-        bp = &ccoin->blinded_planchet;
-        bp->cipher = TALER_DENOMINATION_RSA;
-        rp = &bp->details.rsa_blinded_planchet;
-        rp->blinded_msg_size = 1 + (size_t) GNUNET_CRYPTO_random_u64 (
-                                                                      GNUNET_CRYPTO_QUALITY_WEAK,
-                                                                      (RSA_KEY_SIZE / 8) - 1);
-        rp->blinded_msg = GNUNET_malloc (rp->blinded_msg_size);
-        GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                                    rp->blinded_msg,
-                                    rp->blinded_msg_size);
-        TALER_denom_pub_hash (&new_dkp[cnt]->pub,
-                              &ccoin->h_denom_pub);
-        ccoin->exchange_vals = alg_values;
-        TALER_coin_ev_hash (bp,
-                            &ccoin->h_denom_pub,
-                            &ccoin->coin_envelope_hash);
-        GNUNET_assert (GNUNET_OK ==
+      now = GNUNET_TIME_timestamp_get ();
+      // 5 KEY PAIR
+      new_dkp[cnt] = create_denom_key_pair (RSA_KEY_SIZE,
+                                            now,
+                                            &value,
+                                            &fees);
+      GNUNET_assert (NULL != new_dkp[cnt]);
+      new_denom_pubs[cnt] = new_dkp[cnt]->pub;
+      ccoin = &revealed_coins[cnt];
+      bp = &ccoin->blinded_planchet;
+      bp->cipher = TALER_DENOMINATION_RSA;
+      rp = &bp->details.rsa_blinded_planchet;
+      rp->blinded_msg_size = 1 + (size_t) GNUNET_CRYPTO_random_u64 (
+        GNUNET_CRYPTO_QUALITY_WEAK,
+        (RSA_KEY_SIZE / 8) - 1);
+      rp->blinded_msg = GNUNET_malloc (rp->blinded_msg_size);
+      GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  rp->blinded_msg,
+                                  rp->blinded_msg_size);
+      TALER_denom_pub_hash (&new_dkp[cnt]->pub,
+                            &ccoin->h_denom_pub);
+      ccoin->exchange_vals = alg_values;
+      TALER_coin_ev_hash (bp,
+                          &ccoin->h_denom_pub,
+                          &ccoin->coin_envelope_hash);
+      GNUNET_assert (GNUNET_OK ==
                      TALER_denom_sign_blinded (&ccoin->coin_sig,
                                                &new_dkp[cnt]->priv,
                                                true,
                                                bp));
-        GNUNET_assert (GNUNET_OK ==
-                       TALER_coin_ev_hash (bp,
-                                           &cbc.denom_pub_hash,
-                                           &cbc.h_coin_envelope));
-        GNUNET_assert (
-                       GNUNET_OK ==
-                       TALER_denom_sign_blinded (
-                                                 &cbc.sig,
-                                                 &new_dkp[cnt]->priv,
-                                                 false,
-                                                 bp));
-      }
+      GNUNET_assert (GNUNET_OK ==
+                     TALER_coin_ev_hash (bp,
+                                         &cbc.denom_pub_hash,
+                                         &cbc.h_coin_envelope));
+      GNUNET_assert (
+        GNUNET_OK ==
+        TALER_denom_sign_blinded (
+          &cbc.sig,
+          &new_dkp[cnt]->priv,
+          false,
+          bp));
+    }
   }
 
   perm = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_NONCE,
@@ -338,10 +340,10 @@ run (void *cls)
   FAILIF (GNUNET_OK !=
           plugin->start (plugin->cls,
                          "Transaction"));
-  for (unsigned int j=0; j< NUM_ROWS; j++)
+  for (unsigned int j = 0; j< NUM_ROWS; j++)
   {
     unsigned int i = perm[j];
-    unsigned int k = (unsigned int)rand()%5;
+    unsigned int k = (unsigned int) rand () % 5;
     if (i >= ROUNDS)
       i = ROUNDS; /* throw-away slot, do not keep around */
     RND_BLK (&coin_pub);
@@ -369,15 +371,15 @@ run (void *cls)
     depos[i].receiver_wire_account =
       "payto://iban/DE67830654080004822650?receiver-name=Test";
     TALER_merchant_wire_signature_hash (
-                                        "payto://iban/DE67830654080004822650?receiver-name=Test",
-                                        &depos[i].wire_salt,
-                                        &h_wire_wt);
+      "payto://iban/DE67830654080004822650?receiver-name=Test",
+      &depos[i].wire_salt,
+      &h_wire_wt);
     depos[i].timestamp = ts;
-      uint64_t known_coin_id;
-    {//ENSURE_COIN_KNOWN
+    uint64_t known_coin_id;
+    {// ENSURE_COIN_KNOWN
 
       struct TALER_DenominationHashP dph;
-      struct TALER_AgeCommitmentHash agh;
+      struct TALER_AgeCommitmentHashP agh;
       FAILIF (TALER_EXCHANGEDB_CKS_ADDED !=
               plugin->ensure_coin_known (plugin->cls,
                                          &depos[i].coin,
@@ -399,6 +401,7 @@ run (void *cls)
       bool refund_ok;
       bool gone;
       bool conflict;
+<<<<<<< HEAD:src/exchangedb/test_exchangedb_populate_select_refunds_by_coin.c
       unsigned int refund_percent=0;
       switch (refund_percent){
       case 2 ://100% refund
@@ -460,6 +463,13 @@ run (void *cls)
       RND_BLK(&ref[i].details.merchant_sig);
       RND_BLK(&ref[i].details.h_contract_terms);
       RND_BLK(&ref[i].coin.coin_pub);
+=======
+      ref[i].coin = depos[i].coin;
+      ref[i].details.merchant_pub = depos[i].merchant_pub;
+      RND_BLK (&ref[i].details.merchant_sig);
+      ref[i].details.h_contract_terms = depos[i].h_contract_terms;
+      ref[i].coin.coin_pub = depos[i].coin.coin_pub;
+>>>>>>> 6a074b36 (-refactor: AgeCommitmentHash->AgeCommitmentHashP):src/exchangedb/test_exchangedb_populate_table.c
       ref[i].details.rtransaction_id = i;
       ref[i].details.refund_amount = value;
       ref[i].details.refund_fee = fees.refund;
@@ -500,7 +510,8 @@ run (void *cls)
     times = GNUNET_TIME_relative_add (times,
                                       duration);
     duration_sq = duration.rel_value_us * duration.rel_value_us;
-    GNUNET_assert (duration_sq / duration.rel_value_us == duration.rel_value_us);
+    GNUNET_assert (duration_sq / duration.rel_value_us ==
+                   duration.rel_value_us);
     GNUNET_assert (sqrs + duration_sq >= sqrs);
     sqrs += duration_sq;
   }
@@ -514,10 +525,10 @@ run (void *cls)
                                        ROUNDS);
     avg_dbl = avg.rel_value_us;
     variance = sqrs - (avg_dbl * avg_dbl * ROUNDS);
-    fprintf(stdout,
-            "%8llu ± %6.0f\n",
-            (unsigned long long) avg.rel_value_us,
-            sqrt (variance / (ROUNDS-1)));
+    fprintf (stdout,
+             "%8llu ± %6.0f\n",
+             (unsigned long long) avg.rel_value_us,
+             sqrt (variance / (ROUNDS - 1)));
   }
   result = 0;
 drop:
@@ -540,12 +551,22 @@ cleanup:
        cnt++)
     destroy_denom_key_pair (new_dkp[cnt]);
   GNUNET_free (new_dkp);
+<<<<<<< HEAD:src/exchangedb/test_exchangedb_populate_select_refunds_by_coin.c
   for (unsigned int i=0; i< ROUNDS +1 ; i++)
     {
       TALER_denom_sig_free (&depos[i].coin.denom_sig);
     }
   GNUNET_free(depos);
   GNUNET_free(ref);
+=======
+  for (unsigned int i = 0; i< ROUNDS + 1; i++)
+  {
+    TALER_denom_sig_free (&depos[i].coin.denom_sig);
+  }
+  GNUNET_free (depos);
+  GNUNET_free (ref);
+  dkp = NULL;
+>>>>>>> 6a074b36 (-refactor: AgeCommitmentHash->AgeCommitmentHashP):src/exchangedb/test_exchangedb_populate_table.c
   TALER_EXCHANGEDB_plugin_unload (plugin);
   plugin = NULL;
 }

src/include/taler_crypto_lib.h

@@ -47,6 +47,8 @@
  */
 #define TALER_CNC_KAPPA 3
 
+#define TALER_CNC_KAPPA_MINUS_ONE_STR "2"
+
 
 /* ****************** Coin crypto primitives ************* */
 
@@ -435,6 +437,13 @@ struct TALER_AgeCommitmentPublicKeyP
 #endif
 };
 
+/*
+ * @brief Hash to represent the commitment to n*kappa blinded keys during a age-withdrawal.
+ */
+struct TALER_AgeWithdrawCommitmentHashP
+{
+  struct GNUNET_HashCode hash;
+};
 
 /**
  * @brief Type of online public keys used by the wallet to establish a purse and the associated contract meta data.
@@ -1239,7 +1248,7 @@ struct TALER_AgeMask
 /**
  * @brief Age commitment of a coin.
  */
-struct TALER_AgeCommitmentHash
+struct TALER_AgeCommitmentHashP
 {
   /**
    * The commitment is a SHA-256 hash code.
@@ -1259,13 +1268,13 @@ struct TALER_AgeAttestation
 #endif
 };
 
-extern const struct TALER_AgeCommitmentHash TALER_ZeroAgeCommitmentHash;
+extern const struct TALER_AgeCommitmentHashP TALER_ZeroAgeCommitmentHash;
 #define TALER_AgeCommitmentHash_isNullOrZero(ph) ((NULL == ph) || \
                                                   (0 == memcmp (ph, \
                                                                 & \
                                                                 TALER_ZeroAgeCommitmentHash, \
                                                                 sizeof(struct \
-                                                                       TALER_AgeCommitmentHash))))
+                                                                       TALER_AgeCommitmentHashP))))
 
 /**
  * @brief Type of public signing keys for verifying blindly signed coins.
@@ -1448,7 +1457,7 @@ struct TALER_CoinPublicInfo
    * Hash of the age commitment.  If no age commitment was provided, it must be
    * set to all zeroes.
    */
-  struct TALER_AgeCommitmentHash h_age_commitment;
+  struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * True, if age commitment is not applicable.
@@ -1624,7 +1633,7 @@ TALER_denom_sig_free (struct TALER_DenominationSignature *denom_sig);
 enum GNUNET_GenericReturnValue
 TALER_denom_blind (const struct TALER_DenominationPublicKey *dk,
                    const union TALER_DenominationBlindingKeyP *coin_bks,
-                   const struct TALER_AgeCommitmentHash *age_commitment_hash,
+                   const struct TALER_AgeCommitmentHashP *age_commitment_hash,
                    const struct TALER_CoinSpendPublicKeyP *coin_pub,
                    const struct TALER_ExchangeWithdrawValues *alg_values,
                    struct TALER_CoinPubHashP *c_hash,
@@ -1873,7 +1882,7 @@ TALER_coin_ev_hash (const struct TALER_BlindedPlanchet *blinded_planchet,
  */
 void
 TALER_coin_pub_hash (const struct TALER_CoinSpendPublicKeyP *coin_pub,
-                     const struct TALER_AgeCommitmentHash *age_commitment_hash,
+                     const struct TALER_AgeCommitmentHashP *age_commitment_hash,
                      struct TALER_CoinPubHashP *coin_h);
 
 
@@ -1928,7 +1937,7 @@ struct TALER_FreshCoin
   /**
    * Optional hash of an age commitment bound to this coin, maybe NULL.
    */
-  const struct TALER_AgeCommitmentHash *h_age_commitment;
+  const struct TALER_AgeCommitmentHashP *h_age_commitment;
 };
 
 
@@ -2111,7 +2120,7 @@ TALER_planchet_prepare (const struct TALER_DenominationPublicKey *dk,
                         const struct TALER_ExchangeWithdrawValues *alg_values,
                         const union TALER_DenominationBlindingKeyP *bks,
                         const struct TALER_CoinSpendPrivateKeyP *coin_priv,
-                        const struct TALER_AgeCommitmentHash *ach,
+                        const struct TALER_AgeCommitmentHashP *ach,
                         struct TALER_CoinPubHashP *c_hash,
                         struct TALER_PlanchetDetail *pd);
 
@@ -2155,7 +2164,7 @@ TALER_planchet_to_coin (
   const struct TALER_BlindedDenominationSignature *blind_sig,
   const union TALER_DenominationBlindingKeyP *bks,
   const struct TALER_CoinSpendPrivateKeyP *coin_priv,
-  const struct TALER_AgeCommitmentHash *ach,
+  const struct TALER_AgeCommitmentHashP *ach,
   const struct TALER_CoinPubHashP *c_hash,
   const struct TALER_ExchangeWithdrawValues *alg_values,
   struct TALER_FreshCoin *coin);
@@ -3110,7 +3119,7 @@ TALER_wallet_purse_deposit_sign (
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   const struct TALER_Amount *amount,
   const struct TALER_DenominationHashP *h_denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPrivateKeyP *coin_priv,
   struct TALER_CoinSpendSignatureP *coin_sig);
 
@@ -3133,7 +3142,7 @@ TALER_wallet_purse_deposit_verify (
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   const struct TALER_Amount *amount,
   const struct TALER_DenominationHashP *h_denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_CoinSpendSignatureP *coin_sig);
 
@@ -3469,7 +3478,7 @@ TALER_wallet_deposit_sign (
   const struct TALER_Amount *deposit_fee,
   const struct TALER_MerchantWireHashP *h_wire,
   const struct TALER_PrivateContractHashP *h_contract_terms,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_ExtensionPolicyHashP *h_policy,
   const struct TALER_DenominationHashP *h_denom_pub,
   struct GNUNET_TIME_Timestamp wallet_timestamp,
@@ -3502,7 +3511,7 @@ TALER_wallet_deposit_verify (
   const struct TALER_Amount *deposit_fee,
   const struct TALER_MerchantWireHashP *h_wire,
   const struct TALER_PrivateContractHashP *h_contract_terms,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_ExtensionPolicyHashP *h_policy,
   const struct TALER_DenominationHashP *h_denom_pub,
   struct GNUNET_TIME_Timestamp wallet_timestamp,
@@ -3529,7 +3538,7 @@ TALER_wallet_melt_sign (
   const struct TALER_Amount *melt_fee,
   const struct TALER_RefreshCommitmentP *rc,
   const struct TALER_DenominationHashP *h_denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPrivateKeyP *coin_priv,
   struct TALER_CoinSpendSignatureP *coin_sig);
 
@@ -3552,7 +3561,7 @@ TALER_wallet_melt_verify (
   const struct TALER_Amount *melt_fee,
   const struct TALER_RefreshCommitmentP *rc,
   const struct TALER_DenominationHashP *h_denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_CoinSpendSignatureP *coin_sig);
 
@@ -3630,6 +3639,40 @@ TALER_wallet_withdraw_verify (
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_ReserveSignatureP *reserve_sig);
 
+/**
+ * Sign age-withdraw request.
+ *
+ * @param h_commitment hash all n*kappa blinded coins in the commitment for the age-withdraw
+ * @param amount_with_fee amount to debit the reserve for
+ * @param max_age_group maximum age group that the withdrawn coins must be restricted to
+ * @param reserve_priv private key to sign with
+ * @param[out] reserve_sig resulting signature
+ */
+void
+TALER_wallet_age_withdraw_sign (
+  const struct TALER_AgeWithdrawCommitmentHashP *h_commitment,
+  const struct TALER_Amount *amount_with_fee,
+  uint32_t max_age_group,
+  const struct TALER_ReservePrivateKeyP *reserve_priv,
+  struct TALER_ReserveSignatureP *reserve_sig);
+
+/**
+ * Verify an age-withdraw request.
+ *
+ * @param h_commitment hash all n*kappa blinded coins in the commitment for the age-withdraw
+ * @param amount_with_fee amount to debit the reserve for
+ * @param max_age_group maximum age group that the withdrawn coins must be restricted to
+ * @param reserve_pub public key of the reserve
+ * @param reserve_sig resulting signature
+ * @return #GNUNET_OK if the signature is valid
+ */
+enum GNUNET_GenericReturnValue
+TALER_wallet_age_withdraw_verify (
+  const struct TALER_AgeWithdrawCommitmentHashP *h_commitment,
+  const struct TALER_Amount *amount_with_fee,
+  uint32_t max_age_group,
+  const struct TALER_ReservePublicKeyP *reserve_pub,
+  const struct TALER_ReserveSignatureP *reserve_sig);
 
 /**
  * Verify exchange melt confirmation.
@@ -5687,7 +5730,7 @@ struct TALER_AgeCommitmentProof
 void
 TALER_age_commitment_hash (
   const struct TALER_AgeCommitment *commitment,
-  struct TALER_AgeCommitmentHash *hash);
+  struct TALER_AgeCommitmentHashP *hash);
 
 
 /**
@@ -5738,7 +5781,7 @@ TALER_age_commitment_attest (
 
 
 /**
- * @brief Verify the attestation for an given age and age commitment
+ * @brief Verify the attestation for a given age and age commitment
  *
  * @param commitment The age commitment that went into the attestation.  Only the public keys are needed.
  * @param age Age (not age group) for which the an attestation should be done
@@ -5752,6 +5795,24 @@ TALER_age_commitment_verify (
   const struct TALER_AgeAttestation *attest);
 
 
+/**
+ * Create age-withdraw confirmation signature.
+ *
+ * @param scb function to call to create the signature
+ * @param awch age-withdraw commitment that identifies the n*kappa blinded coins
+ * @param noreveal_index gamma cut-and-choose value chosen by the exchange
+ * @param[out] pub where to write the exchange public key
+ * @param[out] sig where to write the exchange signature
+ * @return #TALER_EC_NONE on success
+ */
+enum TALER_ErrorCode
+TALER_exchange_online_age_withdraw_confirmation_sign (
+  TALER_ExchangeSignCallback scb,
+  const struct TALER_AgeWithdrawCommitmentHashP *h_commitment,
+  uint32_t noreveal_index,
+  struct TALER_ExchangePublicKeyP *pub,
+  struct TALER_ExchangeSignatureP *sig);
+
 /**
  * @brief helper function to free memory of a struct TALER_AgeCommitment
  *

src/include/taler_exchange_service.h

@@ -844,7 +844,7 @@ struct TALER_EXCHANGE_CoinDepositDetail
   /**
    * Hash over the age commitment of the coin.
    */
-  struct TALER_AgeCommitmentHash h_age_commitment;
+  struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * The coin’s public key.
@@ -2155,7 +2155,7 @@ struct TALER_EXCHANGE_WithdrawCoinInput
   /**
    * Age commitment for the coin.
    */
-  const struct TALER_AgeCommitmentHash *ach;
+  const struct TALER_AgeCommitmentHashP *ach;
 
 };
 
@@ -2579,7 +2579,7 @@ struct TALER_EXCHANGE_RefreshData
    * might be NULL.
    */
   const struct TALER_AgeCommitmentProof *melt_age_commitment_proof;
-  const struct TALER_AgeCommitmentHash *melt_h_age_commitment;
+  const struct TALER_AgeCommitmentHashP *melt_h_age_commitment;
 
   /**
    * amount specifying how much the coin will contribute to the melt
@@ -2752,7 +2752,7 @@ struct TALER_EXCHANGE_RevealedCoinInfo
    * Age commitment and its hash of the coin, might be NULL.
    */
   struct TALER_AgeCommitmentProof *age_commitment_proof;
-  struct TALER_AgeCommitmentHash *h_age_commitment;
+  struct TALER_AgeCommitmentHashP *h_age_commitment;
 
   /**
    * Blinding keys used to blind the fresh coin.
@@ -2896,7 +2896,7 @@ struct TALER_EXCHANGE_LinkedCoinInfo
    * Age commitment and its hash, if applicable.  Might be NULL.
    */
   struct TALER_AgeCommitmentProof *age_commitment_proof;
-  struct TALER_AgeCommitmentHash *h_age_commitment;
+  struct TALER_AgeCommitmentHashP *h_age_commitment;
 
   /**
    * Master secret of this coin.

src/include/taler_exchangedb_plugin.h

@@ -391,7 +391,7 @@ struct TALER_EXCHANGEDB_TableData
     struct
     {
       struct TALER_CoinSpendPublicKeyP coin_pub;
-      struct TALER_AgeCommitmentHash age_hash;
+      struct TALER_AgeCommitmentHashP age_hash;
       uint64_t denominations_serial;
       struct TALER_DenominationSignature denom_sig;
     } known_coins;
@@ -1062,15 +1062,10 @@ struct TALER_EXCHANGEDB_AgeWithdrawCommitment
    */
   struct TALER_Amount amount_with_fee;
 
-  /**
-   * Public key of the reserve that was drained.
-   */
-  struct TALER_ReservePublicKeyP reserve_pub;
-
   /**
    * Maximum age group that the coins are restricted to.
    */
-  uint8_t max_age_group;
+  uint32_t max_age_group;
 
   /**
    * The hash of the commitment of all n*kappa coins
@@ -1084,6 +1079,11 @@ struct TALER_EXCHANGEDB_AgeWithdrawCommitment
    */
   uint32_t noreveal_index;
 
+  /**
+   * Public key of the reserve that was drained.
+   */
+  struct TALER_ReservePublicKeyP reserve_pub;
+
   /**
    * Signature confirming the age withdrawal, matching @e reserve_pub, @e
    * maximum_age_group and @e h_commitment and @e total_amount_with_fee.
@@ -1094,7 +1094,12 @@ struct TALER_EXCHANGEDB_AgeWithdrawCommitment
    * The exchange's signature of the response.
    */
   struct TALER_ExchangeSignatureP sig;
-}
+
+  /**
+   * Timestamp of the request beeing made
+   */
+  struct GNUNET_TIME_Timestamp timestamp;
+};
 
 
 /**
@@ -1668,7 +1673,7 @@ struct TALER_EXCHANGEDB_DepositListEntry
    * Age commitment hash, if applicable to the denomination.  Should be all
    * zeroes if age commitment is not applicable to the denonimation.
    */
-  struct TALER_AgeCommitmentHash h_age_commitment;
+  struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * true, if age commitment is not applicable
@@ -1879,7 +1884,7 @@ struct TALER_EXCHANGEDB_MeltListEntry
    * applicable to the denomination.  May be all zeroes if no age restriction
    * applies.
    */
-  struct TALER_AgeCommitmentHash h_age_commitment;
+  struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * true, if no h_age_commitment is applicable
@@ -1946,7 +1951,7 @@ struct TALER_EXCHANGEDB_PurseDepositListEntry
    * Hash of the age commitment used to sign the coin, if age restriction was
    * applicable to the denomination.
    */
-  struct TALER_AgeCommitmentHash h_age_commitment;
+  struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * Set to true if the coin was refunded.
@@ -2053,7 +2058,7 @@ struct TALER_EXCHANGEDB_PurseDeposit
    * applicable to the denomination.  May be all zeroes if no age restriction
    * applies.
    */
-  struct TALER_AgeCommitmentHash h_age_commitment;
+  struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * Set to true if @e h_age_commitment is not available.
@@ -2533,7 +2538,7 @@ typedef enum GNUNET_GenericReturnValue
   void *cls,
   uint64_t rowid,
   const struct TALER_DenominationPublicKey *denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_CoinSpendSignatureP *coin_sig,
   const struct TALER_Amount *amount_with_fee,
@@ -3693,6 +3698,45 @@ struct TALER_EXCHANGEDB_Plugin
     bool *conflict,
     bool *nonce_reuse);
 
+  /**
+   * Locate the response for a age-withdraw request under a hash that uniquely
+   * identifies the age-withdraw operation.  Used to ensure idempotency of the
+   * request.
+   *
+   * @param cls the @e cls of this struct with the plugin-specific state
+   * @param reserve_pub public key of the reserve for which the age-withdraw request is made
+   * @param ach hash that uniquely identifies the age-withdraw operation
+   * @param[out] awc corresponding details of the previous age-withdraw request if an entry was found
+   * @return statement execution status
+   */
+  enum GNUNET_DB_QueryStatus
+  (*get_age_withdraw_info)(void *cls,
+                           const struct TALER_ReservePublicKeyP *reserve_pub,
+                           const struct TALER_AgeWithdrawCommitmentHashP *ach,
+                           struct TALER_EXCHANGEDB_AgeWithdrawCommitment *awc);
+
+  /**
+   * Perform an age-withdraw operation, checking for sufficient balance
+   * and possibly persisting the withdrawal details.
+   *
+   * @param cls the `struct PostgresClosure` with the plugin-specific state
+   * @param commitment corresponding commitment for the age-withdraw
+   * @param now current time (rounded)
+   * @param[out] found set to true if the reserve was found
+   * @param[out] balance_ok set to true if the balance was sufficient
+   * @param[out] ruuid set to the reserve's UUID (reserves table row)
+   * @return query execution status
+   */
+  enum GNUNET_DB_QueryStatus
+  (*do_age_withdraw)(
+    void *cls,
+    const struct TALER_EXCHANGEDB_AgeWithdrawCommitment *commitment,
+    struct GNUNET_TIME_Timestamp now,
+    bool *found,
+    bool *balance_ok,
+    uint64_t *ruuid);
+
+
   /**
    * Retrieve the details to a policy given by its hash_code
    *
@@ -4019,7 +4063,7 @@ struct TALER_EXCHANGEDB_Plugin
                        const struct TALER_CoinPublicInfo *coin,
                        uint64_t *known_coin_id,
                        struct TALER_DenominationHashP *denom_pub_hash,
-                       struct TALER_AgeCommitmentHash *age_hash);
+                       struct TALER_AgeCommitmentHashP *age_hash);
 
 
   /**
@@ -6105,7 +6149,7 @@ struct TALER_EXCHANGEDB_Plugin
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     struct TALER_Amount *amount,
     struct TALER_DenominationHashP *h_denom_pub,
-    struct TALER_AgeCommitmentHash *phac,
+    struct TALER_AgeCommitmentHashP *phac,
     struct TALER_CoinSpendSignatureP *coin_sig,
     char **partner_url);
 

src/include/taler_kyclogic_lib.h

@@ -73,8 +73,12 @@ enum TALER_KYCLOGIC_KycTriggerEvent
   /**
    * Reserve is being closed by force.
    */
-  TALER_KYCLOGIC_KYC_TRIGGER_RESERVE_CLOSE = 4
+  TALER_KYCLOGIC_KYC_TRIGGER_RESERVE_CLOSE = 4,
 
+  /**
+   * Customer withdraws coins via age-withdraw.
+   */
+  TALER_KYCLOGIC_KYC_TRIGGER_AGE_WITHDRAW = 5,
 };
 
 

src/include/taler_testing_lib.h

@@ -2958,7 +2958,7 @@ TALER_TESTING_get_trait (const struct TALER_TESTING_Trait *traits,
   op (deposit_fee_amount, const struct TALER_Amount)               \
   op (age_commitment, const struct TALER_AgeCommitment)              \
   op (age_commitment_proof, const struct TALER_AgeCommitmentProof)     \
-  op (h_age_commitment, const struct TALER_AgeCommitmentHash)          \
+  op (h_age_commitment, const struct TALER_AgeCommitmentHashP)          \
   op (reserve_history, const struct TALER_EXCHANGE_ReserveHistoryEntry) \
   op (planchet_secrets, const struct TALER_PlanchetMasterSecretP)      \
   op (exchange_wd_value, const struct TALER_ExchangeWithdrawValues)    \

src/kyclogic/kyclogic_api.c

@@ -180,6 +180,7 @@ TALER_KYCLOGIC_kyc_trigger_from_string (const char *trigger_s,
     enum TALER_KYCLOGIC_KycTriggerEvent out;
   } map [] = {
     { "withdraw", TALER_KYCLOGIC_KYC_TRIGGER_WITHDRAW },
+    { "age-withdraw", TALER_KYCLOGIC_KYC_TRIGGER_AGE_WITHDRAW },
     { "deposit", TALER_KYCLOGIC_KYC_TRIGGER_DEPOSIT  },
     { "merge", TALER_KYCLOGIC_KYC_TRIGGER_P2P_RECEIVE },
     { "balance", TALER_KYCLOGIC_KYC_TRIGGER_WALLET_BALANCE },
@@ -208,6 +209,8 @@ TALER_KYCLOGIC_kyc_trigger2s (enum TALER_KYCLOGIC_KycTriggerEvent trigger)
   {
   case TALER_KYCLOGIC_KYC_TRIGGER_WITHDRAW:
     return "withdraw";
+  case TALER_KYCLOGIC_KYC_TRIGGER_AGE_WITHDRAW:
+    return "age-withdraw";
   case TALER_KYCLOGIC_KYC_TRIGGER_DEPOSIT:
     return "deposit";
   case TALER_KYCLOGIC_KYC_TRIGGER_P2P_RECEIVE:

src/lib/exchange_api_batch_withdraw.c

@@ -51,7 +51,7 @@ struct CoinData
   /**
    * Age commitment for the coin.
    */
-  const struct TALER_AgeCommitmentHash *ach;
+  const struct TALER_AgeCommitmentHashP *ach;
 
   /**
    *  blinding secret

src/lib/exchange_api_common.c

@@ -850,7 +850,7 @@ help_deposit (struct CoinHistoryParseContext *pc,
   struct TALER_MerchantPublicKeyP merchant_pub;
   struct GNUNET_TIME_Timestamp refund_deadline = {0};
   struct TALER_CoinSpendSignatureP sig;
-  struct TALER_AgeCommitmentHash hac;
+  struct TALER_AgeCommitmentHashP hac;
   bool no_hac;
   struct TALER_Amount deposit_fee;
   struct GNUNET_JSON_Specification spec[] = {
@@ -938,7 +938,7 @@ help_melt (struct CoinHistoryParseContext *pc,
 {
   struct TALER_CoinSpendSignatureP sig;
   struct TALER_RefreshCommitmentP rc;
-  struct TALER_AgeCommitmentHash h_age_commitment;
+  struct TALER_AgeCommitmentHashP h_age_commitment;
   bool no_hac;
   struct TALER_Amount melt_fee;
   struct GNUNET_JSON_Specification spec[] = {
@@ -1292,7 +1292,7 @@ help_purse_deposit (struct CoinHistoryParseContext *pc,
   struct TALER_CoinSpendSignatureP coin_sig;
   const char *exchange_base_url;
   bool refunded;
-  struct TALER_AgeCommitmentHash phac = { 0 };
+  struct TALER_AgeCommitmentHashP phac = { 0 };
   struct GNUNET_JSON_Specification spec[] = {
     GNUNET_JSON_spec_fixed_auto ("purse_pub",
                                  &purse_pub),
@@ -1758,7 +1758,7 @@ TALER_EXCHANGE_check_purse_coin_conflict_ (
   const char *exchange_url,
   const json_t *proof,
   struct TALER_DenominationHashP *h_denom_pub,
-  struct TALER_AgeCommitmentHash *phac,
+  struct TALER_AgeCommitmentHashP *phac,
   struct TALER_CoinSpendPublicKeyP *coin_pub,
   struct TALER_CoinSpendSignatureP *coin_sig)
 {

src/lib/exchange_api_common.h

@@ -87,7 +87,7 @@ TALER_EXCHANGE_check_purse_coin_conflict_ (
   const char *exchange_url,
   const json_t *proof,
   struct TALER_DenominationHashP *h_denom_pub,
-  struct TALER_AgeCommitmentHash *phac,
+  struct TALER_AgeCommitmentHashP *phac,
   struct TALER_CoinSpendPublicKeyP *coin_pub,
   struct TALER_CoinSpendSignatureP *coin_sig);
 

src/lib/exchange_api_link.c

@@ -149,7 +149,7 @@ parse_link_coin (const struct TALER_EXCHANGE_LinkHandle *lh,
   if (NULL != lh->age_commitment_proof)
   {
     lci->age_commitment_proof = GNUNET_new (struct TALER_AgeCommitmentProof);
-    lci->h_age_commitment = GNUNET_new (struct TALER_AgeCommitmentHash);
+    lci->h_age_commitment = GNUNET_new (struct TALER_AgeCommitmentHashP);
 
     GNUNET_assert (GNUNET_OK ==
                    TALER_age_commitment_derive (

src/lib/exchange_api_purse_create_with_deposit.c

@@ -57,7 +57,7 @@ struct Deposit
   /**
    * Age restriction hash for the coin.
    */
-  struct TALER_AgeCommitmentHash ahac;
+  struct TALER_AgeCommitmentHashP ahac;
 
   /**
    * How much did we say the coin contributed.
@@ -381,7 +381,7 @@ handle_purse_create_deposit_finished (void *cls,
           struct TALER_CoinSpendPublicKeyP coin_pub;
           struct TALER_CoinSpendSignatureP coin_sig;
           struct TALER_DenominationHashP h_denom_pub;
-          struct TALER_AgeCommitmentHash phac;
+          struct TALER_AgeCommitmentHashP phac;
           bool found = false;
 
           if (GNUNET_OK !=
@@ -594,7 +594,7 @@ TALER_EXCHANGE_purse_create_with_deposit (
     const struct TALER_AgeCommitmentProof *acp = deposit->age_commitment_proof;
     struct Deposit *d = &pch->deposits[i];
     json_t *jdeposit;
-    struct TALER_AgeCommitmentHash *aghp = NULL;
+    struct TALER_AgeCommitmentHashP *aghp = NULL;
     struct TALER_AgeAttestation attest;
     struct TALER_AgeAttestation *attestp = NULL;
 

src/lib/exchange_api_purse_deposit.c

@@ -57,7 +57,7 @@ struct Coin
   /**
    * Age restriction hash for the coin.
    */
-  struct TALER_AgeCommitmentHash ahac;
+  struct TALER_AgeCommitmentHashP ahac;
 
   /**
    * How much did we say the coin contributed.
@@ -240,7 +240,7 @@ handle_purse_deposit_finished (void *cls,
         struct TALER_CoinSpendPublicKeyP coin_pub;
         struct TALER_CoinSpendSignatureP coin_sig;
         struct TALER_DenominationHashP h_denom_pub;
-        struct TALER_AgeCommitmentHash phac;
+        struct TALER_AgeCommitmentHashP phac;
         bool found = false;
 
         if (GNUNET_OK !=
@@ -513,7 +513,7 @@ TALER_EXCHANGE_purse_deposit (
     const struct TALER_AgeCommitmentProof *acp = deposit->age_commitment_proof;
     struct Coin *coin = &pch->coins[i];
     json_t *jdeposit;
-    struct TALER_AgeCommitmentHash *achp = NULL;
+    struct TALER_AgeCommitmentHashP *achp = NULL;
     struct TALER_AgeAttestation attest;
     struct TALER_AgeAttestation *attestp = NULL;
 

src/lib/exchange_api_refresh_common.c

@@ -168,7 +168,7 @@ TALER_EXCHANGE_get_melt_data_ (
       union TALER_DenominationBlindingKeyP *bks = &fcd->bks[i];
       struct TALER_PlanchetDetail pd;
       struct TALER_CoinPubHashP c_hash;
-      struct TALER_AgeCommitmentHash *ach = NULL;
+      struct TALER_AgeCommitmentHashP *ach = NULL;
 
       TALER_transfer_secret_to_planchet_secret (&trans_sec,
                                                 j,
@@ -187,7 +187,7 @@ TALER_EXCHANGE_get_melt_data_ (
       {
         fcd->age_commitment_proof[i] = GNUNET_new (struct
                                                    TALER_AgeCommitmentProof);
-        ach = GNUNET_new (struct TALER_AgeCommitmentHash);
+        ach = GNUNET_new (struct TALER_AgeCommitmentHashP);
 
         GNUNET_assert (GNUNET_OK ==
                        TALER_age_commitment_derive (

src/lib/exchange_api_refresh_common.h

@@ -57,7 +57,7 @@ struct MeltedCoin
    * age commitment was set.
    */
   const struct TALER_AgeCommitmentProof *age_commitment_proof;
-  const struct TALER_AgeCommitmentHash *h_age_commitment;
+  const struct TALER_AgeCommitmentHashP *h_age_commitment;
 
   /**
    * Timestamp indicating when coins of this denomination become invalid.

src/lib/exchange_api_refreshes_reveal.c

@@ -168,7 +168,7 @@ refresh_reveal_ok (struct TALER_EXCHANGE_RefreshesRevealHandle *rrh,
 
     if (NULL != rci->age_commitment_proof)
     {
-      rci->h_age_commitment = GNUNET_new (struct TALER_AgeCommitmentHash);
+      rci->h_age_commitment = GNUNET_new (struct TALER_AgeCommitmentHashP);
       TALER_age_commitment_hash (
         &rci->age_commitment_proof->commitment,
         rci->h_age_commitment);

src/lib/exchange_api_refund.c

@@ -234,7 +234,7 @@ verify_conflict_history_ok (struct TALER_EXCHANGE_RefundHandle *rh,
       struct TALER_Amount deposit_fee;
       struct TALER_MerchantWireHashP h_wire;
       struct TALER_PrivateContractHashP h_contract_terms;
-      struct TALER_AgeCommitmentHash h_age_commitment;
+      struct TALER_AgeCommitmentHashP h_age_commitment;
       bool no_hac;
       struct TALER_ExtensionPolicyHashP h_policy;
       bool no_h_policy;

src/lib/exchange_api_reserves_open.c

@@ -510,8 +510,8 @@ TALER_EXCHANGE_reserves_open (
   {
     const struct TALER_EXCHANGE_PurseDeposit *pd = &coin_payments[i];
     const struct TALER_AgeCommitmentProof *acp = pd->age_commitment_proof;
-    struct TALER_AgeCommitmentHash ahac;
-    struct TALER_AgeCommitmentHash *achp = NULL;
+    struct TALER_AgeCommitmentHashP ahac;
+    struct TALER_AgeCommitmentHashP *achp = NULL;
     struct CoinData *cd = &roh->coins[i];
     json_t *cp;
 

src/lib/exchange_api_withdraw.c

@@ -91,7 +91,7 @@ struct TALER_EXCHANGE_WithdrawHandle
   /**
    * Hash of the age commitment for this coin, if applicable. Maybe NULL
    */
-  const struct TALER_AgeCommitmentHash *ach;
+  const struct TALER_AgeCommitmentHashP *ach;
 
   /**
    * Denomination key we are withdrawing.

src/testing/testing_api_cmd_batch_withdraw.c

@@ -82,7 +82,7 @@ struct CoinState
    * its hash, respectivelly, NULL otherwise.
    */
   struct TALER_AgeCommitmentProof *age_commitment_proof;
-  struct TALER_AgeCommitmentHash *h_age_commitment;
+  struct TALER_AgeCommitmentHashP *h_age_commitment;
 
   /**
    * Reserve history entry that corresponds to this coin.
@@ -484,12 +484,12 @@ TALER_TESTING_cmd_batch_withdraw (const char *label,
     if (0 < age)
     {
       struct TALER_AgeCommitmentProof *acp;
-      struct TALER_AgeCommitmentHash *hac;
+      struct TALER_AgeCommitmentHashP *hac;
       struct GNUNET_HashCode seed;
       struct TALER_AgeMask mask;
 
       acp = GNUNET_new (struct TALER_AgeCommitmentProof);
-      hac = GNUNET_new (struct TALER_AgeCommitmentHash);
+      hac = GNUNET_new (struct TALER_AgeCommitmentHashP);
       mask = TALER_extensions_get_age_restriction_mask ();
       GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
                                   &seed,

src/testing/testing_api_cmd_deposit.c

@@ -289,7 +289,7 @@ deposit_run (void *cls,
   const struct TALER_CoinSpendPrivateKeyP *coin_priv;
   struct TALER_CoinSpendPublicKeyP coin_pub;
   const struct TALER_AgeCommitmentProof *age_commitment_proof = NULL;
-  struct TALER_AgeCommitmentHash h_age_commitment = {0};
+  struct TALER_AgeCommitmentHashP h_age_commitment = {0};
   const struct TALER_EXCHANGE_DenomPublicKey *denom_pub;
   const struct TALER_DenominationSignature *denom_pub_sig;
   struct TALER_CoinSpendSignatureP coin_sig;

src/testing/testing_api_cmd_insert_deposit.c

@@ -245,7 +245,7 @@ insert_deposit_run (void *cls,
   {
     uint64_t known_coin_id;
     struct TALER_DenominationHashP dph;
-    struct TALER_AgeCommitmentHash agh;
+    struct TALER_AgeCommitmentHashP agh;
 
     if ( (GNUNET_OK !=
           ids->dbc->plugin->start (ids->dbc->plugin->cls,

src/testing/testing_api_cmd_refresh.c

@@ -75,7 +75,7 @@ struct TALER_TESTING_FreshCoinData
    * applicable.
    */
   struct TALER_AgeCommitmentProof *age_commitment_proof;
-  struct TALER_AgeCommitmentHash *h_age_commitment;
+  struct TALER_AgeCommitmentHashP *h_age_commitment;
 
   /**
    * The blinding key (needed for recoup operations).
@@ -1027,7 +1027,7 @@ melt_run (void *cls,
     struct TALER_Amount melt_amount;
     struct TALER_Amount fresh_amount;
     const struct TALER_AgeCommitmentProof *age_commitment_proof;
-    const struct TALER_AgeCommitmentHash *h_age_commitment;
+    const struct TALER_AgeCommitmentHashP *h_age_commitment;
     const struct TALER_DenominationSignature *melt_sig;
     const struct TALER_EXCHANGE_DenomPublicKey *melt_denom_pub;
     const struct TALER_TESTING_Command *coin_command;

src/testing/testing_api_cmd_withdraw.c

@@ -142,7 +142,7 @@ struct WithdrawState
    * its hash, respectivelly, NULL otherwise.
    */
   struct TALER_AgeCommitmentProof *age_commitment_proof;
-  struct TALER_AgeCommitmentHash *h_age_commitment;
+  struct TALER_AgeCommitmentHashP *h_age_commitment;
 
   /**
    * Reserve history entry that corresponds to this operation.
@@ -581,12 +581,12 @@ TALER_TESTING_cmd_withdraw_amount (const char *label,
   if (0 < age)
   {
     struct TALER_AgeCommitmentProof *acp;
-    struct TALER_AgeCommitmentHash *hac;
+    struct TALER_AgeCommitmentHashP *hac;
     struct GNUNET_HashCode seed;
     struct TALER_AgeMask mask;
 
     acp = GNUNET_new (struct TALER_AgeCommitmentProof);
-    hac = GNUNET_new (struct TALER_AgeCommitmentHash);
+    hac = GNUNET_new (struct TALER_AgeCommitmentHashP);
     mask = TALER_extensions_get_age_restriction_mask ();
     GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
                                 &seed,

src/util/age_restriction.c

@@ -27,7 +27,7 @@
 void
 TALER_age_commitment_hash (
   const struct TALER_AgeCommitment *commitment,
-  struct TALER_AgeCommitmentHash *ahash)
+  struct TALER_AgeCommitmentHashP *ahash)
 {
   struct GNUNET_HashContext *hash_context;
   struct GNUNET_HashCode hash;
@@ -35,7 +35,7 @@ TALER_age_commitment_hash (
   GNUNET_assert (NULL != ahash);
   if (NULL == commitment)
   {
-    memset (ahash, 0, sizeof(struct TALER_AgeCommitmentHash));
+    memset (ahash, 0, sizeof(struct TALER_AgeCommitmentHashP));
     return;
   }
 

src/util/crypto.c

@@ -29,7 +29,7 @@
 /**
  * Used in TALER_AgeCommitmentHash_isNullOrZero for comparison
  */
-const struct TALER_AgeCommitmentHash TALER_ZeroAgeCommitmentHash = {0};
+const struct TALER_AgeCommitmentHashP TALER_ZeroAgeCommitmentHash = {0};
 
 /**
  * Function called by libgcrypt on serious errors.
@@ -258,7 +258,7 @@ TALER_planchet_prepare (const struct TALER_DenominationPublicKey *dk,
                         const struct TALER_ExchangeWithdrawValues *alg_values,
                         const union TALER_DenominationBlindingKeyP *bks,
                         const struct TALER_CoinSpendPrivateKeyP *coin_priv,
-                        const struct TALER_AgeCommitmentHash *ach,
+                        const struct TALER_AgeCommitmentHashP *ach,
                         struct TALER_CoinPubHashP *c_hash,
                         struct TALER_PlanchetDetail *pd
                         )
@@ -299,7 +299,7 @@ TALER_planchet_to_coin (
   const struct TALER_BlindedDenominationSignature *blind_sig,
   const union TALER_DenominationBlindingKeyP *bks,
   const struct TALER_CoinSpendPrivateKeyP *coin_priv,
-  const struct TALER_AgeCommitmentHash *ach,
+  const struct TALER_AgeCommitmentHashP *ach,
   const struct TALER_CoinPubHashP *c_hash,
   const struct TALER_ExchangeWithdrawValues *alg_values,
   struct TALER_FreshCoin *coin)
@@ -412,7 +412,7 @@ TALER_refresh_get_commitment (struct TALER_RefreshCommitmentP *rc,
 
 void
 TALER_coin_pub_hash (const struct TALER_CoinSpendPublicKeyP *coin_pub,
-                     const struct TALER_AgeCommitmentHash *ach,
+                     const struct TALER_AgeCommitmentHashP *ach,
                      struct TALER_CoinPubHashP *coin_h)
 {
   if (TALER_AgeCommitmentHash_isNullOrZero (ach))
@@ -427,7 +427,7 @@ TALER_coin_pub_hash (const struct TALER_CoinSpendPublicKeyP *coin_pub,
     /* Coin comes with age commitment.  Take the hash of the age commitment
      * into account */
     const size_t key_s = sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey);
-    const size_t age_s = sizeof(struct TALER_AgeCommitmentHash);
+    const size_t age_s = sizeof(struct TALER_AgeCommitmentHashP);
     char data[key_s + age_s];
 
     GNUNET_memcpy (&data[0],

src/util/denom.c

@@ -299,7 +299,7 @@ enum GNUNET_GenericReturnValue
 TALER_denom_blind (
   const struct TALER_DenominationPublicKey *dk,
   const union TALER_DenominationBlindingKeyP *coin_bks,
-  const struct TALER_AgeCommitmentHash *ach,
+  const struct TALER_AgeCommitmentHashP *ach,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_ExchangeWithdrawValues *alg_values,
   struct TALER_CoinPubHashP *c_hash,

src/util/exchange_signatures.c

@@ -359,7 +359,61 @@ TALER_exchange_online_melt_confirmation_verify (
 }
 
 
-/* TODO:oec: add signature for age-withdraw and reveal */
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * @brief Format of the block signed by the Exchange in response to a
+ * successful "/reserves/$RESERVE_PUB/age-withdraw" request.  Hereby the
+ * exchange affirms that the commitment along with the maximum age group and
+ * the amount were accepted.  This also commits the exchange to a particular
+ * index to not be revealed during the reveal.
+ */
+struct TALER_AgeWithdrawConfirmationPS
+{
+  /**
+   * Purpose is #TALER_SIGNATURE_EXCHANGE_CONFIRM_AGE_WITHDRAW.   Signed by a
+   * `struct TALER_ExchangePublicKeyP` using EdDSA.
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Commitment made in the /reserves/$RESERVE_PUB/age-withdraw.
+   */
+  struct TALER_AgeWithdrawCommitmentHashP h_commitment GNUNET_PACKED;
+
+  /**
+   * Index that the client will not have to reveal, in NBO.
+   * Must be smaller than #TALER_CNC_KAPPA.
+   */
+  uint32_t noreveal_index GNUNET_PACKED;
+
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+enum TALER_ErrorCode
+TALER_exchange_online_age_withdraw_confirmation_sign (
+  TALER_ExchangeSignCallback scb,
+  const struct TALER_AgeWithdrawCommitmentHashP *h_commitment,
+  uint32_t noreveal_index,
+  struct TALER_ExchangePublicKeyP *pub,
+  struct TALER_ExchangeSignatureP *sig)
+{
+
+  struct TALER_AgeWithdrawConfirmationPS confirm = {
+    .purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_CONFIRM_AGE_WITHDRAW),
+    .purpose.size = htonl (sizeof (confirm)),
+    .h_commitment = *h_commitment,
+    .noreveal_index = htonl (noreveal_index)
+  };
+
+  return scb (&confirm.purpose,
+              pub,
+              sig);
+}
+
+
+/* TODO:oec: add signature for age-withdraw, age-reveal */
 
 GNUNET_NETWORK_STRUCT_BEGIN
 

src/util/test_crypto.c

@@ -124,12 +124,12 @@ test_planchets_rsa (uint8_t age)
   struct TALER_BlindedDenominationSignature blind_sig;
   struct TALER_FreshCoin coin;
   struct TALER_CoinPubHashP c_hash;
-  struct TALER_AgeCommitmentHash *ach = NULL;
+  struct TALER_AgeCommitmentHashP *ach = NULL;
 
   if (0 < age)
   {
     struct TALER_AgeCommitmentProof acp;
-    struct TALER_AgeCommitmentHash ah = {0};
+    struct TALER_AgeCommitmentHashP ah = {0};
     struct GNUNET_HashCode seed;
 
     GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
@@ -256,11 +256,11 @@ test_planchets_cs (uint8_t age)
   struct TALER_BlindedDenominationSignature blind_sig;
   struct TALER_FreshCoin coin;
   struct TALER_ExchangeWithdrawValues alg_values;
-  struct TALER_AgeCommitmentHash *ach = NULL;
+  struct TALER_AgeCommitmentHashP *ach = NULL;
 
   if (0 < age)
   {
-    struct TALER_AgeCommitmentHash ah = {0};
+    struct TALER_AgeCommitmentHashP ah = {0};
     struct TALER_AgeCommitmentProof acp;
     struct GNUNET_HashCode seed;
 

src/util/test_helper_rsa.c

@@ -269,7 +269,7 @@ test_signing (struct TALER_CRYPTO_RsaDenominationHelper *dh)
   bool success = false;
   struct TALER_PlanchetMasterSecretP ps;
   struct TALER_ExchangeWithdrawValues alg_values;
-  struct TALER_AgeCommitmentHash ach;
+  struct TALER_AgeCommitmentHashP ach;
   struct TALER_CoinPubHashP c_hash;
   struct TALER_CoinSpendPrivateKeyP coin_priv;
   union TALER_DenominationBlindingKeyP bks;
@@ -458,7 +458,7 @@ test_batch_signing (struct TALER_CRYPTO_RsaDenominationHelper *dh,
   bool success = false;
   struct TALER_PlanchetMasterSecretP ps[batch_size];
   struct TALER_ExchangeWithdrawValues alg_values[batch_size];
-  struct TALER_AgeCommitmentHash ach[batch_size];
+  struct TALER_AgeCommitmentHashP ach[batch_size];
   struct TALER_CoinPubHashP c_hash[batch_size];
   struct TALER_CoinSpendPrivateKeyP coin_priv[batch_size];
   union TALER_DenominationBlindingKeyP bks[batch_size];
@@ -672,7 +672,7 @@ perf_signing (struct TALER_CRYPTO_RsaDenominationHelper *dh,
   struct GNUNET_TIME_Relative duration;
   struct TALER_PlanchetMasterSecretP ps;
   struct TALER_CoinSpendPrivateKeyP coin_priv;
-  struct TALER_AgeCommitmentHash ach;
+  struct TALER_AgeCommitmentHashP ach;
   union TALER_DenominationBlindingKeyP bks;
   struct TALER_ExchangeWithdrawValues alg_values;
 

src/util/tv_age_restriction.c

@@ -83,7 +83,7 @@ cp_to_j (
   json_t *j_proof;
   json_t *j_pubs;
   json_t *j_privs;
-  struct TALER_AgeCommitmentHash hac = {0};
+  struct TALER_AgeCommitmentHashP hac = {0};
   char buf[256] = {0};
 
   TALER_age_commitment_hash (&acp->commitment, &hac);

src/util/wallet_signatures.c

@@ -46,7 +46,7 @@ struct TALER_DepositRequestPS
    * Hash over the age commitment that went into the coin. Maybe all zero, if
    * age commitment isn't applicable to the denomination.
    */
-  struct TALER_AgeCommitmentHash h_age_commitment GNUNET_PACKED;
+  struct TALER_AgeCommitmentHashP h_age_commitment GNUNET_PACKED;
 
   /**
    * Hash over optional policy extension attributes shared with the exchange.
@@ -119,7 +119,7 @@ TALER_wallet_deposit_sign (
   const struct TALER_Amount *deposit_fee,
   const struct TALER_MerchantWireHashP *h_wire,
   const struct TALER_PrivateContractHashP *h_contract_terms,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_ExtensionPolicyHashP *h_policy,
   const struct TALER_DenominationHashP *h_denom_pub,
   const struct GNUNET_TIME_Timestamp wallet_timestamp,
@@ -159,7 +159,7 @@ TALER_wallet_deposit_verify (
   const struct TALER_Amount *deposit_fee,
   const struct TALER_MerchantWireHashP *h_wire,
   const struct TALER_PrivateContractHashP *h_contract_terms,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_ExtensionPolicyHashP *h_policy,
   const struct TALER_DenominationHashP *h_denom_pub,
   struct GNUNET_TIME_Timestamp wallet_timestamp,
@@ -230,7 +230,7 @@ struct TALER_LinkDataPS
   /**
    * Hash of the age commitment, if applicable.  Can be all zero
    */
-  struct TALER_AgeCommitmentHash h_age_commitment;
+  struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * Hash of the blinded new coin.
@@ -426,7 +426,7 @@ struct TALER_RefreshMeltCoinAffirmationPS
    * the hash of the age commitment vector.  It must be all zeroes if no age
    * commitment was provided.
    */
-  struct TALER_AgeCommitmentHash h_age_commitment GNUNET_PACKED;
+  struct TALER_AgeCommitmentHashP h_age_commitment GNUNET_PACKED;
 
   /**
    * How much of the value of the coin should be melted?  This amount
@@ -458,7 +458,7 @@ TALER_wallet_melt_sign (
   const struct TALER_Amount *melt_fee,
   const struct TALER_RefreshCommitmentP *rc,
   const struct TALER_DenominationHashP *h_denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPrivateKeyP *coin_priv,
   struct TALER_CoinSpendSignatureP *coin_sig)
 {
@@ -490,7 +490,7 @@ TALER_wallet_melt_verify (
   const struct TALER_Amount *melt_fee,
   const struct TALER_RefreshCommitmentP *rc,
   const struct TALER_DenominationHashP *h_denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_CoinSpendSignatureP *coin_sig)
 {
@@ -604,6 +604,92 @@ TALER_wallet_withdraw_verify (
 }
 
 
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * @brief Format used for to generate the signature on a request to
+ * age-withdraw from a reserve.
+ */
+struct TALER_AgeWithdrawRequestPS
+{
+
+  /**
+   * Purpose must be #TALER_SIGNATURE_WALLET_RESERVE_WITHDRAW.
+   * Used with an EdDSA signature of a `struct TALER_ReservePublicKeyP`.
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Hash of the commitment of n*kappa coins
+   */
+  struct TALER_AgeWithdrawCommitmentHashP h_commitment GNUNET_PACKED;
+
+  /**
+   * Value of the coin being exchanged (matching the denomination key)
+   * plus the transaction fee.  We include this in what is being
+   * signed so that we can verify a reserve's remaining total balance
+   * without needing to access the respective denomination key
+   * information each time.
+   */
+  struct TALER_AmountNBO amount_with_fee;
+
+  /**
+   * Maximum age group that the coins are going to be restricted to.
+   */
+  uint32_t max_age_group;
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+void
+TALER_wallet_age_withdraw_sign (
+  const struct TALER_AgeWithdrawCommitmentHashP *h_commitment,
+  const struct TALER_Amount *amount_with_fee,
+  uint32_t max_age_group,
+  const struct TALER_ReservePrivateKeyP *reserve_priv,
+  struct TALER_ReserveSignatureP *reserve_sig)
+{
+  struct TALER_AgeWithdrawRequestPS req = {
+    .purpose.size = htonl (sizeof (req)),
+    .purpose.purpose = htonl (TALER_SIGNATURE_WALLET_RESERVE_AGE_WITHDRAW),
+    .h_commitment = *h_commitment,
+    .max_age_group = max_age_group
+  };
+
+  TALER_amount_hton (&req.amount_with_fee,
+                     amount_with_fee);
+  GNUNET_CRYPTO_eddsa_sign (&reserve_priv->eddsa_priv,
+                            &req,
+                            &reserve_sig->eddsa_signature);
+}
+
+
+enum GNUNET_GenericReturnValue
+TALER_wallet_age_withdraw_verify (
+  const struct TALER_AgeWithdrawCommitmentHashP *h_commitment,
+  const struct TALER_Amount *amount_with_fee,
+  uint32_t max_age_group,
+  const struct TALER_ReservePublicKeyP *reserve_pub,
+  const struct TALER_ReserveSignatureP *reserve_sig)
+{
+  struct TALER_AgeWithdrawRequestPS awsrd = {
+    .purpose.size = htonl (sizeof (awsrd)),
+    .purpose.purpose = htonl (TALER_SIGNATURE_WALLET_RESERVE_AGE_WITHDRAW),
+    .h_commitment = *h_commitment,
+    .max_age_group = max_age_group
+  };
+
+  TALER_amount_hton (&awsrd.amount_with_fee,
+                     amount_with_fee);
+  return GNUNET_CRYPTO_eddsa_verify (
+    TALER_SIGNATURE_WALLET_RESERVE_AGE_WITHDRAW,
+    &awsrd,
+    &reserve_sig->eddsa_signature,
+    &reserve_pub->eddsa_pub);
+}
+
+
 GNUNET_NETWORK_STRUCT_BEGIN
 
 
@@ -1021,7 +1107,7 @@ struct TALER_PurseDepositPS
    * Hash over the age commitment that went into the coin. Maybe all zero, if
    * age commitment isn't applicable to the denomination.
    */
-  struct TALER_AgeCommitmentHash h_age_commitment GNUNET_PACKED;
+  struct TALER_AgeCommitmentHashP h_age_commitment GNUNET_PACKED;
 
   /**
    * Purse to deposit funds into.
@@ -1043,7 +1129,7 @@ TALER_wallet_purse_deposit_sign (
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   const struct TALER_Amount *amount,
   const struct TALER_DenominationHashP *h_denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPrivateKeyP *coin_priv,
   struct TALER_CoinSpendSignatureP *coin_sig)
 {
@@ -1072,7 +1158,7 @@ TALER_wallet_purse_deposit_verify (
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   const struct TALER_Amount *amount,
   const struct TALER_DenominationHashP *h_denom_pub,
-  const struct TALER_AgeCommitmentHash *h_age_commitment,
+  const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_CoinSpendSignatureP *coin_sig)
 {