Withdraw and deposit works with age restriction

The following tests work:

- Withdraw coins with age (13) from age restricted denominations
- Deposit that coin (purchase)

Now to do:
- refresh
- link
- refund

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

@@ -1617,6 +1617,7 @@ deposit_cb (void *cls,
     struct TALER_MerchantWireHash h_wire;
     struct TALER_DenominationHash h_denom_pub;
     struct TALER_Amount deposit_fee;
+    struct TALER_AgeCommitmentHash *h_age_commitment = NULL; /* FIXME-oec */
 
     TALER_denom_pub_hash (denom_pub,
                           &h_denom_pub);
@@ -1633,6 +1634,7 @@ deposit_cb (void *cls,
                                      &deposit_fee,
                                      &h_wire,
                                      &deposit->h_contract_terms,
+                                     h_age_commitment, /* FIXME-oec */
                                      NULL /* h_extensions! */,
                                      &h_denom_pub,
                                      deposit->timestamp,

src/exchange/taler-exchange-httpd_deposit.c

@@ -239,6 +239,9 @@ TEH_handler_deposit (struct MHD_Connection *connection,
                                  &deposit.merchant_pub),
     GNUNET_JSON_spec_fixed_auto ("h_contract_terms",
                                  &deposit.h_contract_terms),
+    GNUNET_JSON_spec_mark_optional (
+      GNUNET_JSON_spec_fixed_auto ("h_age_commitment",
+                                   &deposit.coin.age_commitment_hash)),
     GNUNET_JSON_spec_fixed_auto ("coin_sig",
                                  &deposit.csig),
     GNUNET_JSON_spec_timestamp ("timestamp",
@@ -387,6 +390,7 @@ TEH_handler_deposit (struct MHD_Connection *connection,
                                    &deposit.deposit_fee,
                                    &h_wire,
                                    &deposit.h_contract_terms,
+                                   &deposit.coin.age_commitment_hash,
                                    NULL /* h_extensions! */,
                                    &deposit.coin.denom_pub_hash,
                                    deposit.timestamp,

src/exchange/taler-exchange-httpd_responses.c

@@ -73,6 +73,7 @@ TEH_RESPONSE_compile_transaction_history (
                                          &deposit->deposit_fee,
                                          &h_wire,
                                          &deposit->h_contract_terms,
+                                         NULL, /* h_age_commitment, FIXME-oec */
                                          NULL /* h_extensions! */,
                                          &deposit->h_denom_pub,
                                          deposit->timestamp,

src/exchangedb/plugin_exchangedb_postgres.c

@@ -5764,6 +5764,8 @@ postgres_ensure_coin_known (void *cls,
   struct PostgresClosure *pg = cls;
   enum GNUNET_DB_QueryStatus qs;
   bool existed;
+  bool is_denom_pub_hash_null = false;
+  bool is_age_hash_null = false;
   struct GNUNET_PQ_QueryParam params[] = {
     GNUNET_PQ_query_param_auto_from_type (&coin->coin_pub),
     GNUNET_PQ_query_param_auto_from_type (&coin->denom_pub_hash),
@@ -5771,24 +5773,22 @@ postgres_ensure_coin_known (void *cls,
     TALER_PQ_query_param_denom_sig (&coin->denom_sig),
     GNUNET_PQ_query_param_end
   };
-  bool is_null = false;
   struct GNUNET_PQ_ResultSpec rs[] = {
     GNUNET_PQ_result_spec_bool ("existed",
                                 &existed),
     GNUNET_PQ_result_spec_uint64 ("known_coin_id",
                                   known_coin_id),
-    GNUNET_PQ_result_spec_allow_null (
-      GNUNET_PQ_result_spec_auto_from_type ("age_hash",
-                                            age_hash),
-      &is_null),
     GNUNET_PQ_result_spec_allow_null (
       GNUNET_PQ_result_spec_auto_from_type ("denom_pub_hash",
                                             denom_hash),
-      &is_null),
+      &is_denom_pub_hash_null),
+    GNUNET_PQ_result_spec_allow_null (
+      GNUNET_PQ_result_spec_auto_from_type ("age_hash",
+                                            age_hash),
+      &is_age_hash_null),
     GNUNET_PQ_result_spec_end
   };
 
-  GNUNET_break (GNUNET_is_zero (&coin->age_commitment_hash)); // FIXME-OEC
   qs = GNUNET_PQ_eval_prepared_singleton_select (pg->conn,
                                                  "insert_known_coin",
                                                  params,
@@ -5808,21 +5808,24 @@ postgres_ensure_coin_known (void *cls,
       return TALER_EXCHANGEDB_CKS_ADDED;
     break; /* continued below */
   }
-  if ( (! is_null) &&
-       (0 != GNUNET_memcmp (age_hash,
-                            &coin->age_commitment_hash)) )
-  {
-    GNUNET_break (GNUNET_is_zero (age_hash)); // FIXME-OEC
-    GNUNET_break_op (0);
-    return TALER_EXCHANGEDB_CKS_AGE_CONFLICT;
-  }
-  if ( (! is_null) &&
-       (0 != GNUNET_memcmp (denom_hash,
-                            &coin->denom_pub_hash)) )
+
+  if ( (! is_denom_pub_hash_null) &&
+       (0 != GNUNET_memcmp (&denom_hash->hash,
+                            &coin->denom_pub_hash.hash)) )
   {
     GNUNET_break_op (0);
     return TALER_EXCHANGEDB_CKS_DENOM_CONFLICT;
   }
+
+  if ( (! is_age_hash_null) &&
+       (0 != GNUNET_memcmp (age_hash,
+                            &coin->age_commitment_hash)) )
+  {
+    GNUNET_break (GNUNET_is_zero (age_hash));
+    GNUNET_break_op (0);
+    return TALER_EXCHANGEDB_CKS_AGE_CONFLICT;
+  }
+
   return TALER_EXCHANGEDB_CKS_PRESENT;
 }
 

src/include/taler_crypto_lib.h

@@ -1720,6 +1720,7 @@ TALER_exchange_deposit_confirm_verify (
  * @param deposit_fee the deposit fee we expect to pay
  * @param h_wire hash of the merchant’s account details
  * @param h_contract_terms hash of the contact of the merchant with the customer (further details are never disclosed to the exchange)
+ * @param h_age_commitment hash over the age commitment, if applicable to the denomination (maybe NULL)
  * @param h_extensions hash over the extensions
  * @param h_denom_pub hash of the coin denomination's public key
  * @param coin_priv coin’s private key
@@ -1734,6 +1735,7 @@ TALER_wallet_deposit_sign (
   const struct TALER_Amount *deposit_fee,
   const struct TALER_MerchantWireHash *h_wire,
   const struct TALER_PrivateContractHash *h_contract_terms,
+  const struct TALER_AgeCommitmentHash *h_age_commitment,
   const struct TALER_ExtensionContractHash *h_extensions,
   const struct TALER_DenominationHash *h_denom_pub,
   struct GNUNET_TIME_Timestamp wallet_timestamp,
@@ -1750,6 +1752,7 @@ TALER_wallet_deposit_sign (
  * @param deposit_fee the deposit fee we expect to pay
  * @param h_wire hash of the merchant’s account details
  * @param h_contract_terms hash of the contact of the merchant with the customer (further details are never disclosed to the exchange)
+ * @param h_age_commitment hash over the age commitment (maybe all zeroes, if not applicable to the denomination)
  * @param h_extensions hash over the extensions
  * @param h_denom_pub hash of the coin denomination's public key
  * @param wallet_timestamp timestamp when the contract was finalized, must not be too far in the future
@@ -1765,6 +1768,7 @@ TALER_wallet_deposit_verify (
   const struct TALER_Amount *deposit_fee,
   const struct TALER_MerchantWireHash *h_wire,
   const struct TALER_PrivateContractHash *h_contract_terms,
+  const struct TALER_AgeCommitmentHash *h_commitment_hash,
   const struct TALER_ExtensionContractHash *h_extensions,
   const struct TALER_DenominationHash *h_denom_pub,
   struct GNUNET_TIME_Timestamp wallet_timestamp,

src/include/taler_exchange_service.h

@@ -780,6 +780,7 @@ TALER_EXCHANGE_wire_cancel (struct TALER_EXCHANGE_WireHandle *wh);
  * @param h_extensions hash over the extensions
  * @param h_denom_pub hash of the coin denomination's public key
  * @param coin_priv coin’s private key
+ * @param age_commitment age commitment that went into the making of the coin, might be NULL
  * @param wallet_timestamp timestamp when the contract was finalized, must not be too far in the future
  * @param merchant_pub the public key of the merchant (used to identify the merchant for refund requests)
  * @param refund_deadline date until which the merchant can issue a refund to the customer via the exchange (can be zero if refunds are not allowed); must not be after the @a wire_deadline
@@ -794,6 +795,7 @@ TALER_EXCHANGE_deposit_permission_sign (
   const struct TALER_ExtensionContractHash *h_extensions,
   const struct TALER_DenominationHash *h_denom_pub,
   const struct TALER_CoinSpendPrivateKeyP *coin_priv,
+  const struct TALER_AgeCommitment *age_commitment,
   struct GNUNET_TIME_Timestamp wallet_timestamp,
   const struct TALER_MerchantPublicKeyP *merchant_pub,
   struct GNUNET_TIME_Timestamp refund_deadline,
@@ -919,6 +921,7 @@ TALER_EXCHANGE_deposit (
   const char *merchant_payto_uri,
   const struct TALER_WireSalt *wire_salt,
   const struct TALER_PrivateContractHash *h_contract_terms,
+  const struct TALER_AgeCommitmentHash *h_age_commitment,
   const json_t *extension_details,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_DenominationSignature *denom_sig,

src/include/taler_signatures.h

@@ -483,6 +483,12 @@ struct TALER_DepositRequestPS
    */
   struct TALER_PrivateContractHash h_contract_terms GNUNET_PACKED;
 
+  /**
+   * 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;
+
   /**
    * Hash over extension attributes shared with the exchange.
    */

src/include/taler_testing_lib.h

@@ -2501,6 +2501,8 @@ TALER_TESTING_get_trait (const struct TALER_TESTING_Trait *traits,
 #define TALER_TESTING_INDEXED_TRAITS(op)                               \
   op (denom_pub, const struct TALER_EXCHANGE_DenomPublicKey)           \
   op (denom_sig, const struct TALER_DenominationSignature)             \
+  op (age_commitment, struct TALER_AgeCommitment)                      \
+  op (h_age_commitment, struct TALER_AgeCommitmentHash)                \
   op (coin_priv, const struct TALER_CoinSpendPrivateKeyP)              \
   op (coin_pub, const struct TALER_CoinSpendPublicKeyP)                \
   op (absolute_time, const struct GNUNET_TIME_Absolute)                \

src/lib/exchange_api_common.c

@@ -482,6 +482,7 @@ TALER_EXCHANGE_verify_coin_history (
       struct TALER_MerchantPublicKeyP merchant_pub;
       struct GNUNET_TIME_Timestamp refund_deadline = {0};
       struct TALER_CoinSpendSignatureP sig;
+      struct TALER_AgeCommitmentHash *hac = NULL;
       struct GNUNET_JSON_Specification spec[] = {
         GNUNET_JSON_spec_fixed_auto ("coin_sig",
                                      &sig),
@@ -516,6 +517,7 @@ TALER_EXCHANGE_verify_coin_history (
                                        &fee,
                                        &h_wire,
                                        &h_contract_terms,
+                                       hac,
                                        NULL /* h_extensions! */,
                                        h_denom_pub,
                                        wallet_timestamp,

src/lib/exchange_api_deposit.c

@@ -462,6 +462,7 @@ handle_deposit_finished (void *cls,
  * @param h_wire hash of the merchant’s account details
  * @param h_contract_terms hash of the contact of the merchant with the customer (further details are never disclosed to the exchange)
  * @param coin_pub coin’s public key
+ * @param h_age_commitment coin’s hash of age commitment, might be NULL
  * @param denom_sig exchange’s unblinded signature of the coin
  * @param denom_pub denomination key with which the coin is signed
  * @param denom_pub_hash hash of @a denom_pub
@@ -478,6 +479,7 @@ verify_signatures (const struct TALER_EXCHANGE_DenomPublicKey *dki,
                    const struct TALER_PrivateContractHash *h_contract_terms,
                    const struct TALER_ExtensionContractHash *ech,
                    const struct TALER_CoinSpendPublicKeyP *coin_pub,
+                   const struct TALER_AgeCommitmentHash *h_age_commitment,
                    const struct TALER_DenominationSignature *denom_sig,
                    const struct TALER_DenominationPublicKey *denom_pub,
                    const struct TALER_DenominationHash *denom_pub_hash,
@@ -491,6 +493,7 @@ verify_signatures (const struct TALER_EXCHANGE_DenomPublicKey *dki,
                                    &dki->fee_deposit,
                                    h_wire,
                                    h_contract_terms,
+                                   h_age_commitment,
                                    ech,
                                    denom_pub_hash,
                                    timestamp,
@@ -514,8 +517,12 @@ verify_signatures (const struct TALER_EXCHANGE_DenomPublicKey *dki,
       .coin_pub = *coin_pub,
       .denom_pub_hash = *denom_pub_hash,
       .denom_sig = *denom_sig,
-      .age_commitment_hash = {{{0}}} /* FIXME-Oec */
+      .age_commitment_hash = {{{0}}}
     };
+    if (NULL != h_age_commitment)
+    {
+      coin_info.age_commitment_hash = *h_age_commitment;
+    }
 
     if (GNUNET_YES !=
         TALER_test_coin_valid (&coin_info,
@@ -547,6 +554,7 @@ TALER_EXCHANGE_deposit (
   const char *merchant_payto_uri,
   const struct TALER_WireSalt *wire_salt,
   const struct TALER_PrivateContractHash *h_contract_terms,
+  const struct TALER_AgeCommitmentHash *h_age_commitment,
   const json_t *extension_details,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_DenominationSignature *denom_sig,
@@ -599,11 +607,14 @@ TALER_EXCHANGE_deposit (
   }
   GNUNET_assert (GNUNET_YES ==
                  TEAH_handle_is_ready (exchange));
+
   /* initialize h_wire */
   TALER_merchant_wire_signature_hash (merchant_payto_uri,
                                       wire_salt,
                                       &h_wire);
+
   key_state = TALER_EXCHANGE_get_keys (exchange);
+
   dki = TALER_EXCHANGE_get_denomination_key (key_state,
                                              denom_pub);
   if (NULL == dki)
@@ -612,6 +623,7 @@ TALER_EXCHANGE_deposit (
     GNUNET_break_op (0);
     return NULL;
   }
+
   if (0 >
       TALER_amount_subtract (&amount_without_fee,
                              amount,
@@ -621,17 +633,18 @@ TALER_EXCHANGE_deposit (
     GNUNET_break_op (0);
     return NULL;
   }
+
   TALER_denom_pub_hash (denom_pub,
                         &denom_pub_hash);
+
   if (GNUNET_OK !=
       verify_signatures (dki,
                          amount,
                          &h_wire,
                          h_contract_terms,
-                         (NULL != extension_details)
-                         ? &ech
-                         : NULL,
+                         (NULL != extension_details) ? &ech : NULL,
                          coin_pub,
+                         h_age_commitment,
                          denom_sig,
                          denom_pub,
                          &denom_pub_hash,
@@ -654,6 +667,9 @@ TALER_EXCHANGE_deposit (
                                 wire_salt),
     GNUNET_JSON_pack_data_auto ("h_contract_terms",
                                 h_contract_terms),
+    GNUNET_JSON_pack_allow_null (
+      GNUNET_JSON_pack_data_auto ("h_age_commitment",
+                                  h_age_commitment)),
     GNUNET_JSON_pack_data_auto ("denom_pub_hash",
                                 &denom_pub_hash),
     TALER_JSON_pack_denom_sig ("ub_sig",

src/lib/exchange_api_refund.c

@@ -203,6 +203,7 @@ verify_conflict_history_ok (struct TALER_EXCHANGE_RefundHandle *rh,
       struct TALER_Amount deposit_fee;
       struct TALER_MerchantWireHash h_wire;
       struct TALER_PrivateContractHash h_contract_terms;
+      struct TALER_AgeCommitmentHash h_age_commitment = {{{0}}};
       // struct TALER_ExtensionContractHash h_extensions; // FIXME!
       struct TALER_DenominationHash h_denom_pub;
       struct GNUNET_TIME_Timestamp wallet_timestamp;
@@ -218,6 +219,9 @@ verify_conflict_history_ok (struct TALER_EXCHANGE_RefundHandle *rh,
                                      &h_wire),
         GNUNET_JSON_spec_fixed_auto ("h_denom_pub",
                                      &h_denom_pub),
+        GNUNET_JSON_spec_mark_optional (
+          GNUNET_JSON_spec_fixed_auto ("h_age_commitment",
+                                       &h_age_commitment)),
         GNUNET_JSON_spec_timestamp ("timestamp",
                                     &wallet_timestamp),
         GNUNET_JSON_spec_timestamp ("refund_deadline",
@@ -243,6 +247,7 @@ verify_conflict_history_ok (struct TALER_EXCHANGE_RefundHandle *rh,
                                        &deposit_fee,
                                        &h_wire,
                                        &h_contract_terms,
+                                       &h_age_commitment,
                                        NULL /* h_extensions! */,
                                        &h_denom_pub,
                                        wallet_timestamp,

src/lib/exchange_api_withdraw.c

@@ -194,8 +194,7 @@ TALER_EXCHANGE_withdraw (
   wh->ps = *ps;
   wh->ach = ach;
 
-  GNUNET_assert ( (age_restricted && (NULL != ach)) ||
-                  (! age_restricted && (NULL == ach)));
+  GNUNET_assert (age_restricted == (NULL != ach));
 
   if (GNUNET_OK !=
       TALER_planchet_prepare (&pk->key,

src/testing/test_exchange_api.c

@@ -169,42 +169,6 @@ run (void *cls,
     TALER_TESTING_cmd_end ()
   };
 
-  /**
-   * Test withdrawal with age restriction.  Success is expected, so it MUST be
-   * called _after_ TALER_TESTING_cmd_exec_offline_sign_extensions is called,
-   * i. e. age restriction is activated in the exchange!
-   *
-   * TODO: create a test that tries to withdraw coins with age restriction but
-   * (expectedly) fails because the exchange doesn't support age restriction
-   * yet.
-   */
-  struct TALER_TESTING_Command withdraw_age[] = {
-    /**
-     * Move money to the exchange's bank account.
-     */
-    CMD_TRANSFER_TO_EXCHANGE ("create-reserve-age",
-                              "EUR:6.02"),
-    TALER_TESTING_cmd_check_bank_admin_transfer ("check-create-reserve-age",
-                                                 "EUR:6.02",
-                                                 bc.user42_payto,
-                                                 bc.exchange_payto,
-                                                 "create-reserve-age"),
-    /**
-     * Make a reserve exist, according to the previous
-     * transfer.
-     */
-    CMD_EXEC_WIREWATCH ("wirewatch-age"),
-    /**
-     * Withdraw EUR:5.
-     */
-    TALER_TESTING_cmd_withdraw_amount ("withdraw-coin-age",
-                                       "create-reserve-age",
-                                       "EUR:5",
-                                       13,
-                                       MHD_HTTP_OK),
-    TALER_TESTING_cmd_end ()
-  };
-
   struct TALER_TESTING_Command spend[] = {
     /**
      * Spend the coin.
@@ -371,6 +335,61 @@ run (void *cls,
     TALER_TESTING_cmd_end ()
   };
 
+  /**
+   * Test withdrawal with age restriction.  Success is expected, so it MUST be
+   * called _after_ TALER_TESTING_cmd_exec_offline_sign_extensions is called,
+   * i. e. age restriction is activated in the exchange!
+   *
+   * TODO: create a test that tries to withdraw coins with age restriction but
+   * (expectedly) fails because the exchange doesn't support age restriction
+   * yet.
+   */
+  struct TALER_TESTING_Command withdraw_age[] = {
+    /**
+     * Move money to the exchange's bank account.
+     */
+    CMD_TRANSFER_TO_EXCHANGE ("create-reserve-age",
+                              "EUR:5.02"),
+    TALER_TESTING_cmd_check_bank_admin_transfer ("check-create-reserve-age",
+                                                 "EUR:5.02",
+                                                 bc.user42_payto,
+                                                 bc.exchange_payto,
+                                                 "create-reserve-age"),
+    /**
+     * Make a reserve exist, according to the previous
+     * transfer.
+     */
+    CMD_EXEC_WIREWATCH ("wirewatch-age"),
+    /**
+     * Withdraw EUR:5.
+     */
+    TALER_TESTING_cmd_withdraw_amount ("withdraw-coin-age-1",
+                                       "create-reserve-age",
+                                       "EUR:5",
+                                       13,
+                                       MHD_HTTP_OK),
+
+    TALER_TESTING_cmd_end ()
+  };
+
+  struct TALER_TESTING_Command spend_age[] = {
+    /**
+     * Spend the coin.
+     */
+    TALER_TESTING_cmd_deposit ("deposit-simple-age",
+                               "withdraw-coin-age-1",
+                               0,
+                               bc.user42_payto,
+                               "{\"items\":[{\"name\":\"ice cream\",\"value\":1}]}",
+                               GNUNET_TIME_UNIT_ZERO,
+                               "EUR:5",
+                               MHD_HTTP_OK),
+    TALER_TESTING_cmd_deposit_replay ("deposit-simple-replay-age",
+                                      "deposit-simple-age",
+                                      MHD_HTTP_OK),
+    TALER_TESTING_cmd_end ()
+  };
+
   struct TALER_TESTING_Command track[] = {
     /* Try resolving a deposit's WTID, as we never triggered
      * execution of transactions, the answer should be that
@@ -413,6 +432,11 @@ run (void *cls,
                                            "EUR:4.98",
                                            bc.exchange_payto,
                                            bc.user42_payto),
+    TALER_TESTING_cmd_check_bank_transfer ("check_bank_transfer-499c2",
+                                           ec.exchange_url,
+                                           "EUR:4.98",
+                                           bc.exchange_payto,
+                                           bc.user42_payto),
     TALER_TESTING_cmd_check_bank_transfer ("check_bank_transfer-99c1",
                                            ec.exchange_url,
                                            "EUR:0.98",
@@ -1002,12 +1026,14 @@ run (void *cls,
                                wire),
       TALER_TESTING_cmd_batch ("withdraw",
                                withdraw),
-      TALER_TESTING_cmd_batch ("withdraw-age",
-                               withdraw_age),
       TALER_TESTING_cmd_batch ("spend",
                                spend),
       TALER_TESTING_cmd_batch ("refresh",
                                refresh),
+      TALER_TESTING_cmd_batch ("withdraw-age",
+                               withdraw_age),
+      TALER_TESTING_cmd_batch ("spend-age",
+                               spend_age),
       TALER_TESTING_cmd_batch ("track",
                                track),
       TALER_TESTING_cmd_batch ("unaggregation",

src/testing/testing_api_cmd_deposit.c

@@ -287,6 +287,8 @@ deposit_run (void *cls,
   const struct TALER_TESTING_Command *coin_cmd;
   const struct TALER_CoinSpendPrivateKeyP *coin_priv;
   struct TALER_CoinSpendPublicKeyP coin_pub;
+  struct TALER_AgeCommitment *age_commitment = NULL;
+  struct TALER_AgeCommitmentHash h_age_commitment = {0};
   const struct TALER_EXCHANGE_DenomPublicKey *denom_pub;
   const struct TALER_DenominationSignature *denom_pub_sig;
   struct TALER_CoinSpendSignatureP coin_sig;
@@ -382,6 +384,10 @@ deposit_run (void *cls,
         TALER_TESTING_get_trait_coin_priv (coin_cmd,
                                            ds->coin_index,
                                            &coin_priv)) ||
+       (GNUNET_OK !=
+        TALER_TESTING_get_trait_age_commitment (coin_cmd,
+                                                ds->coin_index,
+                                                &age_commitment)) ||
        (GNUNET_OK !=
         TALER_TESTING_get_trait_denom_pub (coin_cmd,
                                            ds->coin_index,
@@ -398,6 +404,12 @@ deposit_run (void *cls,
     TALER_TESTING_interpreter_fail (is);
     return;
   }
+
+  if (NULL != age_commitment)
+  {
+    TALER_age_commitment_hash (age_commitment, &h_age_commitment);
+  }
+
   ds->deposit_fee = denom_pub->fee_deposit;
   GNUNET_CRYPTO_eddsa_key_get_public (&coin_priv->eddsa_priv,
                                       &coin_pub.eddsa_pub);
@@ -431,7 +443,8 @@ deposit_run (void *cls,
                                &denom_pub->fee_deposit,
                                &h_wire,
                                &h_contract_terms,
-                               NULL, /* FIXME: extension hash! */
+                               &h_age_commitment,
+                               NULL, /* FIXME: add hash of extensions */
                                &denom_pub->h_key,
                                ds->wallet_timestamp,
                                &merchant_pub,
@@ -445,7 +458,8 @@ deposit_run (void *cls,
                                    payto_uri,
                                    &wire_salt,
                                    &h_contract_terms,
-                                   NULL, /* FIXME: extension object */
+                                   &h_age_commitment,
+                                   NULL, /* FIXME: add hash of extensions */
                                    &coin_pub,
                                    denom_pub_sig,
                                    &denom_pub->key,
@@ -520,6 +534,7 @@ deposit_traits (void *cls,
   const struct TALER_TESTING_Command *coin_cmd;
   /* Will point to coin cmd internals. */
   const struct TALER_CoinSpendPrivateKeyP *coin_spent_priv;
+  struct TALER_AgeCommitment *age_commitment;
 
   if (GNUNET_YES != ds->command_initialized)
   {
@@ -540,7 +555,11 @@ deposit_traits (void *cls,
   if (GNUNET_OK !=
       TALER_TESTING_get_trait_coin_priv (coin_cmd,
                                          ds->coin_index,
-                                         &coin_spent_priv))
+                                         &coin_spent_priv) ||
+      (GNUNET_OK !=
+       TALER_TESTING_get_trait_age_commitment (coin_cmd,
+                                               ds->coin_index,
+                                               &age_commitment)))
   {
     GNUNET_break (0);
     TALER_TESTING_interpreter_fail (ds->is);
@@ -555,6 +574,8 @@ deposit_traits (void *cls,
       /* These traits are always available */
       TALER_TESTING_make_trait_coin_priv (0,
                                           coin_spent_priv),
+      TALER_TESTING_make_trait_age_commitment (0,
+                                               age_commitment),
       TALER_TESTING_make_trait_wire_details (ds->wire_details),
       TALER_TESTING_make_trait_contract_terms (ds->contract_terms),
       TALER_TESTING_make_trait_merchant_priv (&ds->merchant_priv),

src/testing/testing_api_cmd_refresh.c

@@ -70,6 +70,11 @@ struct TALER_TESTING_FreshCoinData
    */
   struct TALER_CoinSpendPrivateKeyP coin_priv;
 
+  /*
+   * Age commitment for the coin, NULL if not applicable.
+   */
+  struct TALER_AgeCommitment *age_commitment;
+
   /**
    * The blinding key (needed for recoup operations).
    */
@@ -124,7 +129,7 @@ struct RefreshMeltState
   /*
    * Age commitment for the coin, NULL if not applicable.
    */
-  const struct TALER_AgeCommitment *age_commitment;
+  struct TALER_AgeCommitment *age_commitment;
 
   /**
    * Task scheduled to try later.
@@ -1018,6 +1023,16 @@ melt_run (void *cls,
       return;
     }
 
+    if (GNUNET_OK !=
+        TALER_TESTING_get_trait_age_commitment (coin_command,
+                                                0,
+                                                &rms->age_commitment))
+    {
+      GNUNET_break (0);
+      TALER_TESTING_interpreter_fail (rms->is);
+      return;
+    }
+
     if (GNUNET_OK !=
         TALER_TESTING_get_trait_denom_sig (coin_command,
                                            0,
@@ -1198,6 +1213,8 @@ melt_traits (void *cls,
                                           &rms->fresh_pks[index]),
       TALER_TESTING_make_trait_coin_priv (0,
                                           rms->melt_priv),
+      TALER_TESTING_make_trait_age_commitment (index,
+                                               rms->age_commitment),
       TALER_TESTING_trait_end ()
     };
 
@@ -1356,6 +1373,9 @@ refresh_reveal_traits (void *cls,
       TALER_TESTING_make_trait_coin_priv (
         index,
         &rrs->fresh_coins[index].coin_priv),
+      TALER_TESTING_make_trait_age_commitment (
+        index,
+        rrs->fresh_coins[index].age_commitment),
       TALER_TESTING_make_trait_denom_pub (
         index,
         rrs->fresh_coins[index].pk),

src/testing/testing_api_cmd_withdraw.c

@@ -27,6 +27,7 @@
 #include <microhttpd.h>
 #include <gnunet/gnunet_curl_lib.h>
 #include "taler_signatures.h"
+#include "taler_extensions.h"
 #include "taler_testing_lib.h"
 #include "backoff.h"
 
@@ -452,31 +453,6 @@ withdraw_run (void *cls,
     ws->amount = ws->pk->value;
   }
 
-  if (ws->age > 0)
-  {
-    uint32_t seed;
-    struct TALER_AgeCommitment *ac;
-
-    ac = GNUNET_malloc (sizeof(struct TALER_AgeCommitment));
-    seed = GNUNET_CRYPTO_random_u32 (
-      GNUNET_CRYPTO_QUALITY_WEAK,
-      UINT32_MAX);
-
-    GNUNET_assert (GNUNET_OK ==
-                   TALER_age_restriction_commit (
-                     &ws->pk->key.age_mask,
-                     ws->age,
-                     seed,
-                     ac));
-
-    ws->age_commitment = ac;
-    ws->h_age_commitment = GNUNET_malloc (sizeof(struct
-                                                 TALER_AgeCommitmentHash));
-    TALER_age_commitment_hash (
-      ac,
-      ws->h_age_commitment);
-  }
-
   ws->reserve_history.type = TALER_EXCHANGE_RTT_WITHDRAWAL;
   GNUNET_assert (0 <=
                  TALER_amount_add (&ws->reserve_history.amount,
@@ -535,6 +511,16 @@ withdraw_cleanup (void *cls,
     TALER_EXCHANGE_destroy_denomination_key (ws->pk);
     ws->pk = NULL;
   }
+  if (NULL != ws->age_commitment)
+  {
+    GNUNET_free (ws->age_commitment);
+    ws->age_commitment = NULL;
+  }
+  if (NULL != ws->h_age_commitment)
+  {
+    GNUNET_free (ws->h_age_commitment);
+    ws->h_age_commitment = NULL;
+  }
   GNUNET_free (ws->exchange_url);
   GNUNET_free (ws->reserve_payto_uri);
   GNUNET_free (ws);
@@ -561,13 +547,13 @@ withdraw_traits (void *cls,
   struct TALER_TESTING_Trait traits[] = {
     /* history entry MUST be first due to response code logic below! */
     TALER_TESTING_make_trait_reserve_history (&ws->reserve_history),
-    TALER_TESTING_make_trait_coin_priv (0 /* only one coin */,
+    TALER_TESTING_make_trait_coin_priv (index /* only one coin */,
                                         &ws->ps.coin_priv),
-    TALER_TESTING_make_trait_blinding_key (0 /* only one coin */,
+    TALER_TESTING_make_trait_blinding_key (index /* only one coin */,
                                            &ws->ps.blinding_key),
-    TALER_TESTING_make_trait_denom_pub (0 /* only one coin */,
+    TALER_TESTING_make_trait_denom_pub (index /* only one coin */,
                                         ws->pk),
-    TALER_TESTING_make_trait_denom_sig (0 /* only one coin */,
+    TALER_TESTING_make_trait_denom_sig (index /* only one coin */,
                                         &ws->sig),
     TALER_TESTING_make_trait_reserve_priv (&ws->reserve_priv),
     TALER_TESTING_make_trait_reserve_pub (&ws->reserve_pub),
@@ -577,6 +563,8 @@ withdraw_traits (void *cls,
       (const char **) &ws->reserve_payto_uri),
     TALER_TESTING_make_trait_exchange_url (
       (const char **) &ws->exchange_url),
+    TALER_TESTING_make_trait_age_commitment (index, ws->age_commitment),
+    TALER_TESTING_make_trait_h_age_commitment (index, ws->h_age_commitment),
     TALER_TESTING_trait_end ()
   };
 
@@ -611,7 +599,39 @@ TALER_TESTING_cmd_withdraw_amount (const char *label,
   struct WithdrawState *ws;
 
   ws = GNUNET_new (struct WithdrawState);
+
   ws->age = age;
+  if (0 < age)
+  {
+    struct TALER_AgeCommitment *ac;
+    struct TALER_AgeCommitmentHash *hac;
+    uint32_t seed;
+    struct TALER_AgeMask mask;
+
+    ac = GNUNET_new (struct TALER_AgeCommitment);
+    hac = GNUNET_new (struct TALER_AgeCommitmentHash);
+    seed = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
+    mask = TALER_extensions_age_restriction_ageMask ();
+
+    if (GNUNET_OK !=
+        TALER_age_restriction_commit (
+          &mask,
+          age,
+          seed,
+          ac))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Failed to generate age commitment for age %d at %s\n",
+                  age,
+                  label);
+      GNUNET_assert (0);
+    }
+
+    TALER_age_commitment_hash (ac,hac);
+    ws->age_commitment = ac;
+    ws->h_age_commitment = hac;
+  }
+
   ws->reserve_reference = reserve_reference;
   if (GNUNET_OK !=
       TALER_string_to_amount (amount,

src/testing/testing_api_helpers_exchange.c

@@ -313,6 +313,9 @@ sign_keys_for_exchange (void *cls,
   char *exchange_master_pub;
   int ret;
 
+  /* Load the age restriction mask from the configuration */
+  TALER_extensions_load_taler_config (cfg);
+
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg,
                                              "exchange",

src/util/crypto.c

@@ -88,17 +88,10 @@ TALER_test_coin_valid (const struct TALER_CoinPublicInfo *coin_public_info,
                  GNUNET_memcmp (&d_hash,
                                 &coin_public_info->denom_pub_hash));
 #endif
-  {
-    const struct TALER_AgeCommitmentHash *pahc =
-      &coin_public_info->age_commitment_hash;
-
-    if (TALER_AgeCommitmentHash_isNullOrZero (pahc))
-      pahc = NULL;
 
   TALER_coin_pub_hash (&coin_public_info->coin_pub,
-                         pahc,
+                       &coin_public_info->age_commitment_hash,
                        &c_hash);
-  }
 
   if (GNUNET_OK !=
       TALER_denom_pub_verify (denom_pub,

src/util/wallet_signatures.c

@@ -29,6 +29,7 @@ TALER_wallet_deposit_sign (
   const struct TALER_Amount *deposit_fee,
   const struct TALER_MerchantWireHash *h_wire,
   const struct TALER_PrivateContractHash *h_contract_terms,
+  const struct TALER_AgeCommitmentHash *h_age_commitment,
   const struct TALER_ExtensionContractHash *h_extensions,
   const struct TALER_DenominationHash *h_denom_pub,
   struct GNUNET_TIME_Timestamp wallet_timestamp,
@@ -48,8 +49,12 @@ TALER_wallet_deposit_sign (
     .merchant = *merchant_pub
   };
 
+  if (NULL != h_age_commitment)
+    dr.h_age_commitment = *h_age_commitment;
+
   if (NULL != h_extensions)
     dr.h_extensions = *h_extensions;
+
   TALER_amount_hton (&dr.amount_with_fee,
                      amount);
   TALER_amount_hton (&dr.deposit_fee,
@@ -66,6 +71,7 @@ TALER_wallet_deposit_verify (
   const struct TALER_Amount *deposit_fee,
   const struct TALER_MerchantWireHash *h_wire,
   const struct TALER_PrivateContractHash *h_contract_terms,
+  const struct TALER_AgeCommitmentHash *h_age_commitment,
   const struct TALER_ExtensionContractHash *h_extensions,
   const struct TALER_DenominationHash *h_denom_pub,
   struct GNUNET_TIME_Timestamp wallet_timestamp,
@@ -82,11 +88,21 @@ TALER_wallet_deposit_verify (
     .h_denom_pub = *h_denom_pub,
     .wallet_timestamp = GNUNET_TIME_timestamp_hton (wallet_timestamp),
     .refund_deadline = GNUNET_TIME_timestamp_hton (refund_deadline),
-    .merchant = *merchant_pub
+    .merchant = *merchant_pub,
+    .h_age_commitment = {{{0}}},
+    .h_extensions = {{{0}}}
   };
 
+  if (NULL != h_age_commitment)
+  {
+    dr.h_age_commitment = *h_age_commitment;
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "VFVFVFVF got NON-NULL h_age_commitment\n");
+  }
+
   if (NULL != h_extensions)
     dr.h_extensions = *h_extensions;
+
   TALER_amount_hton (&dr.amount_with_fee,
                      amount);
   TALER_amount_hton (&dr.deposit_fee,
@@ -143,14 +159,11 @@ TALER_wallet_link_verify (
     .purpose.purpose = htonl (TALER_SIGNATURE_WALLET_COIN_LINK),
     .h_denom_pub = *h_denom_pub,
     .transfer_pub = *transfer_pub,
-    .coin_envelope_hash = *h_coin_ev
+    .coin_envelope_hash = *h_coin_ev,
+    .h_age_commitment = {{{0}}}
   };
 
-  if (NULL == h_age_commitment)
-    memset (&ldp.h_age_commitment,
-            0,
-            sizeof(*h_age_commitment));
-  else
+  if (NULL != h_age_commitment)
     ldp.h_age_commitment = *h_age_commitment;
 
   return
@@ -284,9 +297,9 @@ TALER_wallet_melt_verify (
     .purpose.purpose = htonl (TALER_SIGNATURE_WALLET_COIN_MELT),
     .rc = *rc,
     .h_denom_pub = *h_denom_pub,
+    .h_age_commitment = {{{0}}},
   };
 
-  memset (&melt.h_age_commitment, 0, sizeof(struct TALER_AgeCommitmentHash));
   if (NULL != h_age_commitment)
     melt.h_age_commitment = *h_age_commitment;