exchange

Base system with REST service to issue digital coins, run by the payment service provider
Log | Files | Refs | Submodules | README | LICENSE

test_purse_refund_history.c (7953B)


      1 /*
      2   This file is part of TALER
      3   Copyright (C) 2026 Taler Systems SA
      4 
      5   TALER is free software; you can redistribute it and/or modify it under the
      6   terms of the GNU General Public License as published by the Free Software
      7   Foundation; either version 3, or (at your option) any later version.
      8 
      9   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
     10   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
     11   A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
     12 
     13   You should have received a copy of the GNU General Public License along with
     14   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
     15 */
     16 /**
     17  * @file lib/test_purse_refund_history.c
     18  * @brief Verify current and legacy signed purse refunds.
     19  */
     20 #include "platform.h"
     21 #include "taler/taler_json_lib.h"
     22 #include "taler/exchange/get-coins-COIN_PUB-history.h"
     23 #include "taler/exchange/get-keys.h"
     24 
     25 static struct TALER_ExchangePrivateKeyP exchange_priv;
     26 
     27 
     28 static enum TALER_ErrorCode
     29 sign_confirmation (const struct GNUNET_CRYPTO_SignaturePurpose *purpose,
     30                    struct TALER_ExchangePublicKeyP *pub,
     31                    struct TALER_ExchangeSignatureP *sig)
     32 {
     33   GNUNET_CRYPTO_eddsa_key_get_public (&exchange_priv.eddsa_priv,
     34                                       &pub->eddsa_pub);
     35   GNUNET_assert (GNUNET_OK ==
     36                  GNUNET_CRYPTO_eddsa_sign_ (&exchange_priv.eddsa_priv,
     37                                             purpose,
     38                                             &sig->eddsa_signature));
     39   return TALER_EC_NONE;
     40 }
     41 
     42 
     43 static json_t *
     44 refund_entry (const struct TALER_CoinSpendPublicKeyP *coin_pub,
     45               const struct TALER_PurseContractPublicKeyP *purse,
     46               const struct TALER_Amount *amount,
     47               const struct TALER_Amount *fee,
     48               uint64_t offset)
     49 {
     50   struct TALER_ExchangePublicKeyP pub;
     51   struct TALER_ExchangeSignatureP sig;
     52 
     53   GNUNET_assert (TALER_EC_NONE ==
     54                  TALER_exchange_online_purse_refund_sign (&sign_confirmation,
     55                                                           amount, fee,
     56                                                           coin_pub, purse,
     57                                                           &pub, &sig));
     58   return GNUNET_JSON_PACK (
     59     GNUNET_JSON_pack_string ("type", "PURSE-REFUND"),
     60     GNUNET_JSON_pack_uint64 ("history_offset", offset),
     61     GNUNET_JSON_pack_data_auto ("purse_pub", purse),
     62     GNUNET_JSON_pack_data_auto ("exchange_pub", &pub),
     63     GNUNET_JSON_pack_data_auto ("exchange_sig", &sig),
     64     TALER_JSON_pack_amount ("amount", amount),
     65     TALER_JSON_pack_amount ("refund_fee", fee));
     66 }
     67 
     68 
     69 static enum GNUNET_GenericReturnValue
     70 parse_history (const struct TALER_EXCHANGE_Keys *keys,
     71                const struct TALER_EXCHANGE_DenomPublicKey *dk,
     72                const struct TALER_CoinSpendPublicKeyP *coin_pub,
     73                const json_t *history)
     74 {
     75   const unsigned int len = json_array_size (history);
     76   struct TALER_EXCHANGE_CoinHistoryEntry entries[len];
     77   struct TALER_Amount in;
     78   struct TALER_Amount out;
     79   enum GNUNET_GenericReturnValue ret;
     80 
     81   ret = TALER_EXCHANGE_parse_coin_history (keys, dk, history, coin_pub,
     82                                            &in, &out, len, entries);
     83   if (GNUNET_OK == ret)
     84   {
     85     struct TALER_Amount balance;
     86 
     87     GNUNET_assert (0 <= TALER_amount_subtract (&balance, &in, &out));
     88     GNUNET_assert (0 == TALER_amount_cmp (&dk->value, &balance));
     89     TALER_EXCHANGE_free_coin_history (len, entries);
     90   }
     91   return ret;
     92 }
     93 
     94 
     95 int
     96 main (void)
     97 {
     98   struct TALER_EXCHANGE_SigningPublicKey sign_key = {
     99     .valid_until = GNUNET_TIME_UNIT_FOREVER_TS
    100   };
    101   const struct TALER_EXCHANGE_Keys keys = {
    102     .sign_keys = &sign_key,
    103     .num_sign_keys = 1
    104   };
    105   struct TALER_EXCHANGE_DenomPublicKey dk = {0};
    106   struct TALER_CoinSpendPrivateKeyP coin_priv;
    107   struct TALER_CoinSpendPublicKeyP coin_pub;
    108   struct TALER_PurseContractPublicKeyP purses[2];
    109   const char *url = "https://exchange.example/";
    110   const struct {
    111     const char *amount;
    112     const char *fee;
    113     enum GNUNET_GenericReturnValue expected;
    114   } cases[] = {
    115     { "TEST:3", "TEST:0", GNUNET_OK },
    116     { "TEST:2.98", "TEST:0.02", GNUNET_OK },
    117     { "TEST:2.98", "TEST:0", GNUNET_SYSERR },
    118     { "TEST:2.99", "TEST:0.01", GNUNET_SYSERR },
    119     { "TEST:3", "EUR:0", GNUNET_SYSERR },
    120   };
    121   struct TALER_Amount deposit;
    122   struct TALER_Amount zero_fee;
    123   json_t *deposits[2];
    124   json_t *history;
    125 
    126   GNUNET_CRYPTO_eddsa_key_create (&exchange_priv.eddsa_priv);
    127   GNUNET_CRYPTO_eddsa_key_get_public (&exchange_priv.eddsa_priv,
    128                                       &sign_key.key.eddsa_pub);
    129   GNUNET_CRYPTO_eddsa_key_create (&coin_priv.eddsa_priv);
    130   GNUNET_CRYPTO_eddsa_key_get_public (&coin_priv.eddsa_priv,
    131                                       &coin_pub.eddsa_pub);
    132   GNUNET_assert (GNUNET_OK == TALER_string_to_amount ("TEST:8", &dk.value));
    133   GNUNET_assert (GNUNET_OK == TALER_string_to_amount ("TEST:3", &deposit));
    134   GNUNET_assert (GNUNET_OK ==
    135                  TALER_string_to_amount ("TEST:0.1", &dk.fees.deposit));
    136   GNUNET_assert (GNUNET_OK ==
    137                  TALER_string_to_amount ("TEST:0.02", &dk.fees.refund));
    138   GNUNET_assert (GNUNET_OK == TALER_amount_set_zero ("TEST", &zero_fee));
    139   for (unsigned int i = 0; i < 2; i++)
    140   {
    141     struct TALER_PurseContractPrivateKeyP priv;
    142     struct TALER_CoinSpendSignatureP coin_sig;
    143 
    144     GNUNET_CRYPTO_eddsa_key_create (&priv.eddsa_priv);
    145     GNUNET_CRYPTO_eddsa_key_get_public (&priv.eddsa_priv,
    146                                         &purses[i].eddsa_pub);
    147     TALER_wallet_purse_deposit_sign (url, &purses[i], &deposit, &dk.h_key,
    148                                      NULL, &coin_priv, &coin_sig);
    149     deposits[i] = GNUNET_JSON_PACK (
    150       GNUNET_JSON_pack_string ("type", "PURSE-DEPOSIT"),
    151       GNUNET_JSON_pack_uint64 ("history_offset", i + 1),
    152       GNUNET_JSON_pack_string ("exchange_base_url", url),
    153       GNUNET_JSON_pack_data_auto ("purse_pub", &purses[i]),
    154       GNUNET_JSON_pack_data_auto ("coin_sig", &coin_sig),
    155       GNUNET_JSON_pack_bool ("refunded", true),
    156       TALER_JSON_pack_amount ("amount", &deposit));
    157   }
    158   for (unsigned int i = 0; i < sizeof (cases) / sizeof (cases[0]); i++)
    159   {
    160     struct TALER_Amount amount;
    161     struct TALER_Amount fee;
    162 
    163     GNUNET_assert (GNUNET_OK == TALER_string_to_amount (cases[i].amount, &amount));
    164     GNUNET_assert (GNUNET_OK == TALER_string_to_amount (cases[i].fee, &fee));
    165     history = json_pack ("[O,o]", deposits[0],
    166                          refund_entry (&coin_pub, &purses[0], &amount, &fee, 2));
    167     GNUNET_assert (cases[i].expected ==
    168                    parse_history (&keys, &dk, &coin_pub, history));
    169     json_decref (history);
    170   }
    171 
    172   /* Only the first purse received a deposit. The second has a signed refund. */
    173   history = json_pack ("[O,o]", deposits[0],
    174                        refund_entry (&coin_pub, &purses[1],
    175                                      &deposit, &zero_fee, 3));
    176   GNUNET_assert (GNUNET_SYSERR ==
    177                  parse_history (&keys, &dk, &coin_pub, history));
    178 
    179   /* Two equal deposits, each refunded once. */
    180   GNUNET_assert (0 == json_array_insert (history, 1, deposits[1]));
    181   GNUNET_assert (0 == json_array_append_new (
    182                    history,
    183                    refund_entry (&coin_pub, &purses[0], &deposit, &zero_fee, 4)));
    184   GNUNET_assert (GNUNET_OK ==
    185                  parse_history (&keys, &dk, &coin_pub, history));
    186 
    187   /* Repeating the second purse's refund at a fresh offset preserves the
    188      entry count and total value. Each deposit still needs its own refund. */
    189   GNUNET_assert (0 == json_array_set_new (
    190                    history, 3,
    191                    refund_entry (&coin_pub, &purses[1], &deposit, &zero_fee, 4)));
    192   GNUNET_assert (GNUNET_SYSERR ==
    193                  parse_history (&keys, &dk, &coin_pub, history));
    194 
    195   json_decref (history);
    196   json_decref (deposits[0]);
    197   json_decref (deposits[1]);
    198   return 0;
    199 }