exchange

exchange_api_post-purses-PURSE_PUB-create.c (22824B)

---

 /*
    This file is part of TALER
    Copyright (C) 2022-2026 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 lib/exchange_api_post-purses-PURSE_PUB-create.c
  * @brief Implementation of the client to create a purse with
  *        an initial set of deposits (and a contract)
  * @author Christian Grothoff
  */
 #include <jansson.h>
 #include <microhttpd.h> /* just for HTTP status codes */
 #include <gnunet/gnunet_util_lib.h>
 #include <gnunet/gnunet_json_lib.h>
 #include <gnunet/gnunet_curl_lib.h>
 #include "taler/taler_json_lib.h"
 #include "exchange_api_handle.h"
 #include "exchange_api_common.h"
 #include "taler/taler_signatures.h"
 #include "exchange_api_curl_defaults.h"
 
 
 /**
  * Information we track per deposited coin.
  */
 struct Deposit
 {
   /**
    * Coin's public key.
    */
   struct TALER_CoinSpendPublicKeyP coin_pub;
 
   /**
    * Signature made with the coin.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
   /**
    * Coin's denomination.
    */
   struct TALER_DenominationHashP h_denom_pub;
 
   /**
    * Signature proving the validity of the coin.
    */
   struct TALER_DenominationSignature denom_sig;
 
   /**
    * Age restriction hash for the coin.
    */
   struct TALER_AgeCommitmentHashP ahac;
 
   /**
    * How much did we say the coin contributed.
    */
   struct TALER_Amount contribution;
 
   /**
    * Age attestation for this coin. Valid if @e have_age.
    */
   struct TALER_AgeAttestationP attest;
 
   /**
    * True if this coin uses age attestation.
    */
   bool have_age;
 
 };
 
 
 /**
  * @brief A purse create with deposit handle
  */
 struct TALER_EXCHANGE_PostPursesCreateHandle
 {
 
   /**
    * The curl context for this request.
    */
   struct GNUNET_CURL_Context *ctx;
 
   /**
    * The base URL of the exchange.
    */
   char *base_url;
 
   /**
    * The keys of the exchange this request handle will use
    */
   struct TALER_EXCHANGE_Keys *keys;
 
   /**
    * The url for this request, set during _start.
    */
   char *url;
 
   /**
    * Context for #TEH_curl_easy_post(). Keeps the data that must
    * persist for Curl to make the upload.
    */
   struct TALER_CURL_PostContext post_ctx;
 
   /**
    * Handle for the request.
    */
   struct GNUNET_CURL_Job *job;
 
   /**
    * Function to call with the result.
    */
   TALER_EXCHANGE_PostPursesCreateCallback cb;
 
   /**
    * Closure for @a cb.
    */
   TALER_EXCHANGE_POST_PURSES_CREATE_RESULT_CLOSURE *cb_cls;
 
   /**
    * Expected value in the purse after fees.
    */
   struct TALER_Amount purse_value_after_fees;
 
   /**
    * Our encrypted contract (if we had any).
    */
   struct TALER_EncryptedContract econtract;
 
   /**
    * Public key of the merge capability.
    */
   struct TALER_PurseMergePublicKeyP merge_pub;
 
   /**
    * Private key of the purse which we are creating.
    */
   struct TALER_PurseContractPrivateKeyP purse_priv;
 
   /**
    * Private key for the merge operation.
    */
   struct TALER_PurseMergePrivateKeyP merge_priv;
 
   /**
    * Private key to decrypt the contract.
    */
   struct TALER_ContractDiffiePrivateP contract_priv;
 
   /**
    * Contract terms for the payment.
    */
   json_t *contract_terms;
 
   /**
    * Minimum age, as per @e contract_terms.
    */
   uint32_t min_age;
 
   /**
    * Public key of the purse.
    */
   struct TALER_PurseContractPublicKeyP purse_pub;
 
   /**
    * Signature for purse creation.
    */
   struct TALER_PurseContractSignatureP purse_sig;
 
   /**
    * Hash over the purse's contract terms.
    */
   struct TALER_PrivateContractHashP h_contract_terms;
 
   /**
    * When does the purse expire.
    */
   struct GNUNET_TIME_Timestamp purse_expiration;
 
   /**
    * Array of @e num_deposit deposits.
    */
   struct Deposit *deposits;
 
   /**
    * How many deposits did we make?
    */
   unsigned int num_deposits;
 
   struct
   {
 
     /**
      * Whether we are uploading a contract.
      */
     bool upload_contract;
 
   } options;
 
 };
 
 
 /**
  * Function called when we're done processing the
  * HTTP /purses/$PID/create request.
  *
  * @param cls the `struct TALER_EXCHANGE_PostPursesCreateHandle`
  * @param response_code HTTP response code, 0 on error
  * @param response parsed JSON result, NULL on error
  */
 static void
 handle_purse_create_deposit_finished (void *cls,
                                       long response_code,
                                       const void *response)
 {
   struct TALER_EXCHANGE_PostPursesCreateHandle *pch = cls;
   const json_t *j = response;
   struct TALER_EXCHANGE_PostPursesCreateResponse dr = {
     .hr.reply = j,
     .hr.http_status = (unsigned int) response_code
   };
   const struct TALER_EXCHANGE_Keys *keys = pch->keys;
 
   pch->job = NULL;
   switch (response_code)
   {
   case 0:
     dr.hr.ec = TALER_EC_GENERIC_INVALID_RESPONSE;
     break;
   case MHD_HTTP_OK:
     {
       struct GNUNET_JSON_Specification spec[] = {
         GNUNET_JSON_spec_fixed_auto ("exchange_sig",
                                      &dr.details.ok.exchange_sig),
         GNUNET_JSON_spec_fixed_auto ("exchange_pub",
                                      &dr.details.ok.exchange_pub),
         GNUNET_JSON_spec_timestamp ("exchange_timestamp",
                                     &dr.details.ok.exchange_timestamp),
         TALER_JSON_spec_amount ("total_deposited",
                                 pch->purse_value_after_fees.currency,
                                 &dr.details.ok.total_deposited),
         GNUNET_JSON_spec_end ()
       };
 
       if (GNUNET_OK !=
           GNUNET_JSON_parse (j,
                              spec,
                              NULL, NULL))
       {
         GNUNET_break_op (0);
         dr.hr.http_status = 0;
         dr.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
         break;
       }
       if (GNUNET_OK !=
           TALER_EXCHANGE_test_signing_key (keys,
                                            &dr.details.ok.exchange_pub))
       {
         GNUNET_break_op (0);
         dr.hr.http_status = 0;
         dr.hr.ec = TALER_EC_EXCHANGE_PURSE_CREATE_EXCHANGE_SIGNATURE_INVALID;
         break;
       }
       if (GNUNET_OK !=
           TALER_exchange_online_purse_created_verify (
             dr.details.ok.exchange_timestamp,
             pch->purse_expiration,
             &pch->purse_value_after_fees,
             &dr.details.ok.total_deposited,
             &pch->purse_pub,
             &pch->h_contract_terms,
             &dr.details.ok.exchange_pub,
             &dr.details.ok.exchange_sig))
       {
         GNUNET_break_op (0);
         dr.hr.http_status = 0;
         dr.hr.ec = TALER_EC_EXCHANGE_PURSE_CREATE_EXCHANGE_SIGNATURE_INVALID;
         break;
       }
     }
     break;
   case MHD_HTTP_BAD_REQUEST:
     /* This should never happen, either us or the exchange is buggy
        (or API version conflict); just pass JSON reply to the application */
     dr.hr.ec = TALER_JSON_get_error_code (j);
     dr.hr.hint = TALER_JSON_get_error_hint (j);
     break;
   case MHD_HTTP_FORBIDDEN:
     dr.hr.ec = TALER_JSON_get_error_code (j);
     dr.hr.hint = TALER_JSON_get_error_hint (j);
     /* Nothing really to verify, exchange says one of the signatures is
        invalid; as we checked them, this should never happen, we
        should pass the JSON reply to the application */
     break;
   case MHD_HTTP_NOT_FOUND:
     dr.hr.ec = TALER_JSON_get_error_code (j);
     dr.hr.hint = TALER_JSON_get_error_hint (j);
     /* Nothing really to verify, this should never
        happen, we should pass the JSON reply to the application */
     break;
   case MHD_HTTP_CONFLICT:
     {
       dr.hr.ec = TALER_JSON_get_error_code (j);
       switch (dr.hr.ec)
       {
       case TALER_EC_EXCHANGE_PURSE_CREATE_CONFLICTING_META_DATA:
         if (GNUNET_OK !=
             TALER_EXCHANGE_check_purse_create_conflict_ (
               &pch->purse_sig,
               &pch->purse_pub,
               j))
         {
           GNUNET_break_op (0);
           dr.hr.http_status = 0;
           dr.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
           break;
         }
         break;
       case TALER_EC_EXCHANGE_GENERIC_INSUFFICIENT_FUNDS:
         /* Nothing to check anymore here, proof needs to be
            checked in the GET /coins/$COIN_PUB handler */
         break;
       case TALER_EC_EXCHANGE_GENERIC_COIN_CONFLICTING_DENOMINATION_KEY:
         // FIXME #7267: write check (add to exchange_api_common!) */
         break;
       case TALER_EC_EXCHANGE_PURSE_DEPOSIT_CONFLICTING_META_DATA:
         {
           struct TALER_CoinSpendPublicKeyP coin_pub;
           struct TALER_CoinSpendSignatureP coin_sig;
           struct TALER_DenominationHashP h_denom_pub;
           struct TALER_AgeCommitmentHashP phac;
           bool found = false;
 
           if (GNUNET_OK !=
               TALER_EXCHANGE_check_purse_coin_conflict_ (
                 &pch->purse_pub,
                 pch->base_url,
                 j,
                 &h_denom_pub,
                 &phac,
                 &coin_pub,
                 &coin_sig))
           {
             GNUNET_break_op (0);
             dr.hr.http_status = 0;
             dr.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
             break;
           }
           for (unsigned int i = 0; i<pch->num_deposits; i++)
           {
             struct Deposit *deposit = &pch->deposits[i];
 
             if (0 !=
                 GNUNET_memcmp (&coin_pub,
                                &deposit->coin_pub))
               continue;
             if (0 !=
                 GNUNET_memcmp (&deposit->h_denom_pub,
                                &h_denom_pub))
             {
               found = true;
               break;
             }
             if (0 !=
                 GNUNET_memcmp (&deposit->ahac,
                                &phac))
             {
               found = true;
               break;
             }
             if (0 ==
                 GNUNET_memcmp (&coin_sig,
                                &deposit->coin_sig))
             {
               GNUNET_break_op (0);
               continue;
             }
             found = true;
             break;
           }
           if (! found)
           {
             /* conflict is for a different coin! */
             GNUNET_break_op (0);
             dr.hr.http_status = 0;
             dr.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
             break;
           }
         }
         break;
       case TALER_EC_EXCHANGE_PURSE_ECONTRACT_CONFLICTING_META_DATA:
         if (GNUNET_OK !=
             TALER_EXCHANGE_check_purse_econtract_conflict_ (
               &pch->econtract.econtract_sig,
               &pch->purse_pub,
               j))
         {
           GNUNET_break_op (0);
           dr.hr.http_status = 0;
           dr.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
           break;
         }
         break;
       default:
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     "Unexpected error code %d for conflicting deposit\n",
                     dr.hr.ec);
         GNUNET_break_op (0);
         dr.hr.http_status = 0;
         dr.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
       } /* switch on (ec) */
     }
     break;
   case MHD_HTTP_GONE:
     /* could happen if denomination was revoked */
     /* Note: one might want to check /keys for revocation
        signature here, alas tricky in case our /keys
        is outdated => left to clients */
     dr.hr.ec = TALER_JSON_get_error_code (j);
     dr.hr.hint = TALER_JSON_get_error_hint (j);
     break;
   case MHD_HTTP_INTERNAL_SERVER_ERROR:
     dr.hr.ec = TALER_JSON_get_error_code (j);
     dr.hr.hint = TALER_JSON_get_error_hint (j);
     /* Server had an internal issue; we should retry, but this API
        leaves this to the application */
     break;
   default:
     /* unexpected response code */
     dr.hr.ec = TALER_JSON_get_error_code (j);
     dr.hr.hint = TALER_JSON_get_error_hint (j);
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unexpected response code %u/%d for exchange deposit\n",
                 (unsigned int) response_code,
                 dr.hr.ec);
     GNUNET_break_op (0);
     break;
   }
   if (NULL != pch->cb)
   {
     pch->cb (pch->cb_cls,
              &dr);
     pch->cb = NULL;
   }
   TALER_EXCHANGE_post_purses_create_cancel (pch);
 }
 
 
 struct TALER_EXCHANGE_PostPursesCreateHandle *
 TALER_EXCHANGE_post_purses_create_create (
   struct GNUNET_CURL_Context *ctx,
   const char *url,
   struct TALER_EXCHANGE_Keys *keys,
   const struct TALER_PurseContractPrivateKeyP *purse_priv,
   const struct TALER_PurseMergePrivateKeyP *merge_priv,
   const struct TALER_ContractDiffiePrivateP *contract_priv,
   const json_t *contract_terms,
   unsigned int num_deposits,
   const struct TALER_EXCHANGE_PurseDeposit deposits[static num_deposits])
 {
   struct TALER_EXCHANGE_PostPursesCreateHandle *pch;
 
   pch = GNUNET_new (struct TALER_EXCHANGE_PostPursesCreateHandle);
   pch->ctx = ctx;
   pch->base_url = GNUNET_strdup (url);
   pch->purse_priv = *purse_priv;
   pch->merge_priv = *merge_priv;
   pch->contract_priv = *contract_priv;
   pch->contract_terms = json_incref ((json_t *) contract_terms);
   {
     struct GNUNET_JSON_Specification spec[] = {
       GNUNET_JSON_spec_timestamp ("pay_deadline",
                                   &pch->purse_expiration),
       TALER_JSON_spec_amount_any ("amount",
                                   &pch->purse_value_after_fees),
       GNUNET_JSON_spec_mark_optional (
         GNUNET_JSON_spec_uint32 ("minimum_age",
                                  &pch->min_age),
         NULL),
       GNUNET_JSON_spec_end ()
     };
 
     if (GNUNET_OK !=
         GNUNET_JSON_parse (contract_terms,
                            spec,
                            NULL, NULL))
     {
       GNUNET_break (0);
       GNUNET_free (pch->base_url);
       GNUNET_free (pch);
       return NULL;
     }
   }
   if (GNUNET_OK !=
       TALER_JSON_contract_hash (contract_terms,
                                 &pch->h_contract_terms))
   {
     GNUNET_break (0);
     GNUNET_free (pch->base_url);
     GNUNET_free (pch);
     return NULL;
   }
   GNUNET_CRYPTO_eddsa_key_get_public (&purse_priv->eddsa_priv,
                                       &pch->purse_pub.eddsa_pub);
   GNUNET_CRYPTO_eddsa_key_get_public (&merge_priv->eddsa_priv,
                                       &pch->merge_pub.eddsa_pub);
   pch->num_deposits = num_deposits;
   pch->deposits = GNUNET_new_array (num_deposits,
                                     struct Deposit);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Signing with URL `%s'\n",
               url);
   for (unsigned int i = 0; i<num_deposits; i++)
   {
     const struct TALER_EXCHANGE_PurseDeposit *deposit = &deposits[i];
     const struct TALER_AgeCommitmentProof *acp = deposit->age_commitment_proof;
     struct Deposit *d = &pch->deposits[i];
 
     if (NULL != acp)
     {
       TALER_age_commitment_hash (&acp->commitment,
                                  &d->ahac);
       d->have_age = true;
       if (GNUNET_OK !=
           TALER_age_commitment_attest (acp,
                                        pch->min_age,
                                        &d->attest))
       {
         GNUNET_break (0);
         GNUNET_array_grow (pch->deposits,
                            pch->num_deposits,
                            0);
         GNUNET_free (pch->base_url);
         GNUNET_free (pch);
         return NULL;
       }
     }
     d->contribution = deposit->amount;
     d->h_denom_pub = deposit->h_denom_pub;
     TALER_denom_sig_copy (&d->denom_sig,
                           &deposit->denom_sig);
     GNUNET_CRYPTO_eddsa_key_get_public (&deposit->coin_priv.eddsa_priv,
                                         &d->coin_pub.eddsa_pub);
     TALER_wallet_purse_deposit_sign (
       url,
       &pch->purse_pub,
       &deposit->amount,
       &d->h_denom_pub,
       &d->ahac,
       &deposit->coin_priv,
       &d->coin_sig);
   }
   pch->keys = TALER_EXCHANGE_keys_incref (keys);
   return pch;
 }
 
 
 enum GNUNET_GenericReturnValue
 TALER_EXCHANGE_post_purses_create_set_options_ (
   struct TALER_EXCHANGE_PostPursesCreateHandle *ppch,
   unsigned int num_options,
   const struct TALER_EXCHANGE_PostPursesCreateOptionValue options[])
 {
   for (unsigned int i = 0; i < num_options; i++)
   {
     const struct TALER_EXCHANGE_PostPursesCreateOptionValue *opt = &options[i];
 
     switch (opt->option)
     {
     case TALER_EXCHANGE_POST_PURSES_CREATE_OPTION_END:
       return GNUNET_OK;
     case TALER_EXCHANGE_POST_PURSES_CREATE_OPTION_UPLOAD_CONTRACT:
       ppch->options.upload_contract = true;
       break;
     }
   }
   return GNUNET_OK;
 }
 
 
 enum TALER_ErrorCode
 TALER_EXCHANGE_post_purses_create_start (
   struct TALER_EXCHANGE_PostPursesCreateHandle *pch,
   TALER_EXCHANGE_PostPursesCreateCallback cb,
   TALER_EXCHANGE_POST_PURSES_CREATE_RESULT_CLOSURE *cb_cls)
 {
   char arg_str[sizeof (pch->purse_pub) * 2 + 32];
   CURL *eh;
   json_t *deposit_arr;
   json_t *body;
 
   pch->cb = cb;
   pch->cb_cls = cb_cls;
   deposit_arr = json_array ();
   GNUNET_assert (NULL != deposit_arr);
 
   for (unsigned int i = 0; i<pch->num_deposits; i++)
   {
     struct Deposit *d = &pch->deposits[i];
     struct TALER_AgeCommitmentHashP *aghp = NULL;
     struct TALER_AgeAttestationP *attestp = NULL;
     json_t *jdeposit;
 
     if (d->have_age)
     {
       aghp = &d->ahac;
       attestp = &d->attest;
     }
     jdeposit = GNUNET_JSON_PACK (
       GNUNET_JSON_pack_allow_null (
         GNUNET_JSON_pack_data_auto ("h_age_commitment",
                                     aghp)),
       GNUNET_JSON_pack_allow_null (
         GNUNET_JSON_pack_data_auto ("age_attestation",
                                     attestp)),
       TALER_JSON_pack_amount ("amount",
                               &d->contribution),
       GNUNET_JSON_pack_data_auto ("denom_pub_hash",
                                   &d->h_denom_pub),
       TALER_JSON_pack_denom_sig ("ub_sig",
                                  &d->denom_sig),
       GNUNET_JSON_pack_data_auto ("coin_sig",
                                   &d->coin_sig),
       GNUNET_JSON_pack_data_auto ("coin_pub",
                                   &d->coin_pub));
     GNUNET_assert (0 ==
                    json_array_append_new (deposit_arr,
                                           jdeposit));
 
   }
 
   if (pch->options.upload_contract)
   {
     TALER_CRYPTO_contract_encrypt_for_merge (
       &pch->purse_pub,
       &pch->contract_priv,
       &pch->merge_priv,
       pch->contract_terms,
       &pch->econtract.econtract,
       &pch->econtract.econtract_size);
     GNUNET_CRYPTO_ecdhe_key_get_public (
       &pch->contract_priv.ecdhe_priv,
       &pch->econtract.contract_pub.ecdhe_pub);
     TALER_wallet_econtract_upload_sign (
       pch->econtract.econtract,
       pch->econtract.econtract_size,
       &pch->econtract.contract_pub,
       &pch->purse_priv,
       &pch->econtract.econtract_sig);
   }
   TALER_wallet_purse_create_sign (pch->purse_expiration,
                                   &pch->h_contract_terms,
                                   &pch->merge_pub,
                                   pch->min_age,
                                   &pch->purse_value_after_fees,
                                   &pch->purse_priv,
                                   &pch->purse_sig);
 
   body = GNUNET_JSON_PACK (
     TALER_JSON_pack_amount ("amount",
                             &pch->purse_value_after_fees),
     GNUNET_JSON_pack_uint64 ("min_age",
                              pch->min_age),
     GNUNET_JSON_pack_allow_null (
       TALER_JSON_pack_econtract ("econtract",
                                  pch->options.upload_contract
                                  ? &pch->econtract
                                  : NULL)),
     GNUNET_JSON_pack_data_auto ("purse_sig",
                                 &pch->purse_sig),
     GNUNET_JSON_pack_data_auto ("merge_pub",
                                 &pch->merge_pub),
     GNUNET_JSON_pack_data_auto ("h_contract_terms",
                                 &pch->h_contract_terms),
     GNUNET_JSON_pack_timestamp ("purse_expiration",
                                 pch->purse_expiration),
     GNUNET_JSON_pack_array_steal ("deposits",
                                   deposit_arr));
   if (NULL == body)
   {
     GNUNET_break (0);
     return TALER_EC_GENERIC_CURL_ALLOCATION_FAILURE;
   }
 
   {
     char pub_str[sizeof (pch->purse_pub) * 2];
     char *end;
 
     end = GNUNET_STRINGS_data_to_string (
       &pch->purse_pub,
       sizeof (pch->purse_pub),
       pub_str,
       sizeof (pub_str));
     *end = '\0';
     GNUNET_snprintf (arg_str,
                      sizeof (arg_str),
                      "purses/%s/create",
                      pub_str);
   }
   pch->url = TALER_url_join (pch->base_url,
                              arg_str,
                              NULL);
   if (NULL == pch->url)
   {
     GNUNET_break (0);
     return TALER_EC_GENERIC_CONFIGURATION_INVALID;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "URL for purse create with deposit: `%s'\n",
               pch->url);
   eh = TALER_EXCHANGE_curl_easy_get_ (pch->url);
   if ( (NULL == eh) ||
        (GNUNET_OK !=
         TALER_curl_easy_post (&pch->post_ctx,
                               eh,
                               body)) )
   {
     GNUNET_break (0);
     if (NULL != eh)
       curl_easy_cleanup (eh);
     json_decref (body);
     return TALER_EC_GENERIC_CURL_ALLOCATION_FAILURE;
   }
   json_decref (body);
   pch->job = GNUNET_CURL_job_add2 (pch->ctx,
                                    eh,
                                    pch->post_ctx.headers,
                                    &handle_purse_create_deposit_finished,
                                    pch);
   if (NULL == pch->job)
     return TALER_EC_GENERIC_INTERNAL_INVARIANT_FAILURE;
   return TALER_EC_NONE;
 }
 
 
 void
 TALER_EXCHANGE_post_purses_create_cancel (
   struct TALER_EXCHANGE_PostPursesCreateHandle *pch)
 {
   if (NULL != pch->job)
   {
     GNUNET_CURL_job_cancel (pch->job);
     pch->job = NULL;
   }
   json_decref (pch->contract_terms);
   GNUNET_free (pch->econtract.econtract);
   GNUNET_free (pch->base_url);
   GNUNET_free (pch->url);
 
   for (unsigned int i = 0; i<pch->num_deposits; i++)
   {
     struct Deposit *d = &pch->deposits[i];
 
     TALER_denom_sig_free (&d->denom_sig);
   }
   GNUNET_array_grow (pch->deposits,
                      pch->num_deposits,
                      0);
   TALER_EXCHANGE_keys_decref (pch->keys);
   TALER_curl_easy_post_finished (&pch->post_ctx);
   GNUNET_free (pch);
 }
 
 
 /* end of exchange_api_post-purses-PURSE_PUB-create.c */