exchange

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

test_known_coins.c (31007B)


      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 exchangedb/test_known_coins.c
     18  * @brief tests for the exchangedb functions whose primary table is
     19  *        `known_coins`
     20  * @author Christian Grothoff
     21  *
     22  * Covers #TALER_EXCHANGEDB_do_insert_known_coins(),
     23  * #TALER_EXCHANGEDB_get_known_coin(),
     24  * #TALER_EXCHANGEDB_get_coin_denomination(),
     25  * #TALER_EXCHANGEDB_get_signature_for_known_coin(),
     26  * #TALER_EXCHANGEDB_get_denomination_proof_for_known_coin() and
     27  * #TALER_EXCHANGEDB_get_count_known_coins().
     28  *
     29  * `known_coins` references `denominations`, so a denomination is created
     30  * first with TDB_denom().  do_insert_known_coins() is the interesting one:
     31  * it is idempotent, but only for a coin that comes back with the *same*
     32  * denomination and age commitment -- the conflicting cases are what its
     33  * negative per-coin status codes are for.  It takes a whole batch of
     34  * coins in one round trip, so the last check mixes all cases in one call
     35  * and verifies that every coin is reported at its own position.
     36  */
     37 #include "test_common.h"
     38 #include "exchange-database/do_insert_known_coins.h"
     39 #include "exchange-database/get_known_coin.h"
     40 #include "exchange-database/get_coin_denomination.h"
     41 #include "exchange-database/get_signature_for_known_coin.h"
     42 #include "exchange-database/get_denomination_proof_for_known_coin.h"
     43 #include "exchange-database/get_count_known_coins.h"
     44 #include "exchange-database/start.h"
     45 #include "exchange-database/rollback.h"
     46 
     47 
     48 /**
     49  * Make a single @a coin known via the batch function.
     50  *
     51  * @param pg the database context
     52  * @param coin the coin to make known
     53  * @param[out] res outcome for the coin
     54  * @return database status, #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT on success
     55  */
     56 static enum GNUNET_DB_QueryStatus
     57 insert_one (struct TALER_EXCHANGEDB_PostgresContext *pg,
     58             const struct TALER_CoinPublicInfo *coin,
     59             struct TALER_EXCHANGEDB_CoinKnownResult *res)
     60 {
     61   const struct TALER_CoinPublicInfo *coins[1] = { coin };
     62 
     63   return TALER_EXCHANGEDB_do_insert_known_coins (pg,
     64                                                  1,
     65                                                  coins,
     66                                                  res);
     67 }
     68 
     69 
     70 /**
     71  * Nothing is known about a coin that was never inserted.
     72  *
     73  * @param pg the database context
     74  * @return 0 on success
     75  */
     76 static int
     77 check_empty (struct TALER_EXCHANGEDB_PostgresContext *pg)
     78 {
     79   struct TALER_CoinSpendPublicKeyP coin_pub;
     80   struct TALER_CoinPublicInfo info;
     81   struct TALER_DenominationHashP h_denom_pub;
     82   struct TALER_DenominationPublicKey denom_pub = { 0 };
     83   struct TALER_DenominationSignature denom_sig = { 0 };
     84   struct TALER_AgeCommitmentHashP h_age_commitment;
     85   bool no_age_commitment;
     86   uint64_t known_coin_id;
     87 
     88   TDB_FILL (coin_pub,
     89             1);
     90   TDB_FILL (h_denom_pub,
     91             1);
     92   FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
     93           TALER_EXCHANGEDB_get_known_coin (pg,
     94                                            &coin_pub,
     95                                            &info));
     96   FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
     97           TALER_EXCHANGEDB_get_coin_denomination (pg,
     98                                                   &coin_pub,
     99                                                   &known_coin_id,
    100                                                   &h_denom_pub));
    101   FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
    102           TALER_EXCHANGEDB_get_signature_for_known_coin (pg,
    103                                                          &coin_pub,
    104                                                          &denom_pub,
    105                                                          &denom_sig));
    106   FAILIF (NULL != denom_pub.bsign_pub_key);
    107   FAILIF (NULL != denom_sig.unblinded_sig);
    108   FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
    109           TALER_EXCHANGEDB_get_denomination_proof_for_known_coin (
    110             pg,
    111             &coin_pub,
    112             &denom_pub,
    113             &denom_sig,
    114             &h_age_commitment,
    115             &no_age_commitment));
    116   FAILIF (NULL != denom_pub.bsign_pub_key);
    117   FAILIF (NULL != denom_sig.unblinded_sig);
    118   /* a denomination that does not exist has no coins */
    119   FAILIF (0 != TALER_EXCHANGEDB_get_count_known_coins (pg,
    120                                                        &h_denom_pub));
    121   return 0;
    122 }
    123 
    124 
    125 /**
    126  * A coin of an unknown denomination cannot be made known.
    127  *
    128  * @param pg the database context
    129  * @return 0 on success
    130  */
    131 static int
    132 check_unknown_denomination (struct TALER_EXCHANGEDB_PostgresContext *pg)
    133 {
    134   struct TALER_CoinPublicInfo coin;
    135   struct TALER_EXCHANGEDB_CoinKnownResult res;
    136 
    137   memset (&coin,
    138           0,
    139           sizeof (coin));
    140   TDB_FILL (coin.coin_pub,
    141             2);
    142   TDB_FILL (coin.denom_pub_hash,
    143             2);
    144   coin.no_age_commitment = true;
    145   TDB_denom_sig (2,
    146                  &coin.denom_sig);
    147   /* no denomination row, so nothing is inserted and no coin is found
    148      either: the row for the coin has no known_coin_id, a hard error */
    149   FAILIF_C (GNUNET_DB_STATUS_HARD_ERROR !=
    150             insert_one (pg,
    151                         &coin,
    152                         &res),
    153             TALER_denom_sig_free (&coin.denom_sig));
    154   TALER_denom_sig_free (&coin.denom_sig);
    155   FAILIF (0 != TDB_count (pg,
    156                           "FROM known_coins"));
    157   return 0;
    158 }
    159 
    160 
    161 /**
    162  * Making a coin known stores it, and every lookup finds it.
    163  *
    164  * @param pg the database context
    165  * @return 0 on success
    166  */
    167 static int
    168 check_insert_and_lookup (struct TALER_EXCHANGEDB_PostgresContext *pg)
    169 {
    170   struct TDB_Denom denom;
    171   struct TALER_CoinPublicInfo coin;
    172   struct TALER_CoinPublicInfo got;
    173   struct TALER_DenominationHashP h_denom_pub;
    174   struct TALER_DenominationPublicKey denom_pub = { 0 };
    175   struct TALER_DenominationSignature denom_sig = { 0 };
    176   struct TALER_AgeCommitmentHashP h_age_commitment;
    177   bool no_age_commitment = false;
    178   uint64_t known_coin_id = 0;
    179   uint64_t id2 = 0;
    180 
    181   TDB_denom (pg,
    182              10,
    183              "5",
    184              "0.1",
    185              &denom);
    186   TDB_coin (pg,
    187             &denom,
    188             20,
    189             &coin,
    190             &known_coin_id);
    191   FAILIF_C (0 == known_coin_id,
    192             TDB_coin_free (&coin); TDB_denom_free (&denom));
    193 
    194   memset (&got,
    195           0,
    196           sizeof (got));
    197   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    198             TALER_EXCHANGEDB_get_known_coin (pg,
    199                                              &coin.coin_pub,
    200                                              &got),
    201             TDB_coin_free (&coin); TDB_denom_free (&denom));
    202   FAILIF_C (0 != GNUNET_memcmp (&got.denom_pub_hash,
    203                                 &denom.h_denom_pub),
    204             TALER_denom_sig_free (&got.denom_sig);
    205             TDB_coin_free (&coin); TDB_denom_free (&denom));
    206   FAILIF_C (! got.no_age_commitment,
    207             TALER_denom_sig_free (&got.denom_sig);
    208             TDB_coin_free (&coin); TDB_denom_free (&denom));
    209   FAILIF_C (0 != TALER_denom_sig_cmp (&got.denom_sig,
    210                                       &coin.denom_sig),
    211             TALER_denom_sig_free (&got.denom_sig);
    212             TDB_coin_free (&coin); TDB_denom_free (&denom));
    213   TALER_denom_sig_free (&got.denom_sig);
    214 
    215   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    216             TALER_EXCHANGEDB_get_coin_denomination (pg,
    217                                                     &coin.coin_pub,
    218                                                     &id2,
    219                                                     &h_denom_pub),
    220             TDB_coin_free (&coin); TDB_denom_free (&denom));
    221   FAILIF_C (id2 != known_coin_id,
    222             TDB_coin_free (&coin); TDB_denom_free (&denom));
    223   FAILIF_C (0 != GNUNET_memcmp (&h_denom_pub,
    224                                 &denom.h_denom_pub),
    225             TDB_coin_free (&coin); TDB_denom_free (&denom));
    226 
    227   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    228             TALER_EXCHANGEDB_get_signature_for_known_coin (pg,
    229                                                            &coin.coin_pub,
    230                                                            &denom_pub,
    231                                                            &denom_sig),
    232             TDB_coin_free (&coin); TDB_denom_free (&denom));
    233   FAILIF_C (0 != TALER_denom_pub_cmp (&denom_pub,
    234                                       &denom.pub),
    235             TALER_denom_pub_free (&denom_pub);
    236             TALER_denom_sig_free (&denom_sig);
    237             TDB_coin_free (&coin); TDB_denom_free (&denom));
    238   FAILIF_C (0 != TALER_denom_sig_cmp (&denom_sig,
    239                                       &coin.denom_sig),
    240             TALER_denom_pub_free (&denom_pub);
    241             TALER_denom_sig_free (&denom_sig);
    242             TDB_coin_free (&coin); TDB_denom_free (&denom));
    243   TALER_denom_pub_free (&denom_pub);
    244   TALER_denom_sig_free (&denom_sig);
    245 
    246   /* the same in one lookup, together with the (absent) age commitment */
    247   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    248             TALER_EXCHANGEDB_get_denomination_proof_for_known_coin (
    249               pg,
    250               &coin.coin_pub,
    251               &denom_pub,
    252               &denom_sig,
    253               &h_age_commitment,
    254               &no_age_commitment),
    255             TDB_coin_free (&coin); TDB_denom_free (&denom));
    256   FAILIF_C ( (0 != TALER_denom_pub_cmp (&denom_pub,
    257                                         &denom.pub)) ||
    258              (0 != TALER_denom_sig_cmp (&denom_sig,
    259                                         &coin.denom_sig)) ||
    260              (! no_age_commitment),
    261              TALER_denom_pub_free (&denom_pub);
    262              TALER_denom_sig_free (&denom_sig);
    263              TDB_coin_free (&coin); TDB_denom_free (&denom));
    264   TALER_denom_pub_free (&denom_pub);
    265   TALER_denom_sig_free (&denom_sig);
    266 
    267   FAILIF_C (1 != TALER_EXCHANGEDB_get_count_known_coins (pg,
    268                                                          &denom.h_denom_pub),
    269             TDB_coin_free (&coin); TDB_denom_free (&denom));
    270   TDB_coin_free (&coin);
    271   TDB_denom_free (&denom);
    272   return 0;
    273 }
    274 
    275 
    276 /**
    277  * Re-inserting the same coin is a no-op; re-inserting it under a different
    278  * denomination or with an age commitment is a conflict.
    279  *
    280  * @param pg the database context
    281  * @return 0 on success
    282  */
    283 static int
    284 check_conflicts (struct TALER_EXCHANGEDB_PostgresContext *pg)
    285 {
    286   struct TDB_Denom denom;
    287   struct TDB_Denom other;
    288   struct TALER_CoinPublicInfo coin;
    289   struct TALER_EXCHANGEDB_CoinKnownResult res;
    290 
    291   TDB_denom (pg,
    292              10,
    293              "5",
    294              "0.1",
    295              &denom);
    296   TDB_denom (pg,
    297              11,
    298              "5",
    299              "0.1",
    300              &other);
    301   memset (&coin,
    302           0,
    303           sizeof (coin));
    304   TDB_FILL (coin.coin_pub,
    305             20);
    306   coin.denom_pub_hash = denom.h_denom_pub;
    307   coin.no_age_commitment = true;
    308   TDB_denom_sig (20,
    309                  &coin.denom_sig);
    310 
    311   /* the coin from the previous check: already present, no conflict */
    312   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    313             insert_one (pg,
    314                         &coin,
    315                         &res),
    316             TALER_denom_sig_free (&coin.denom_sig);
    317             TDB_denom_free (&denom); TDB_denom_free (&other));
    318   FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res.status,
    319             TALER_denom_sig_free (&coin.denom_sig);
    320             TDB_denom_free (&denom); TDB_denom_free (&other));
    321   FAILIF_C (0 == res.known_coin_id,
    322             TALER_denom_sig_free (&coin.denom_sig);
    323             TDB_denom_free (&denom); TDB_denom_free (&other));
    324   FAILIF_C (! res.no_age_commitment,
    325             TALER_denom_sig_free (&coin.denom_sig);
    326             TDB_denom_free (&denom); TDB_denom_free (&other));
    327 
    328   /* same coin key, different denomination: conflict, and the stored
    329      denomination is handed back so the caller can report it */
    330   coin.denom_pub_hash = other.h_denom_pub;
    331   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    332             insert_one (pg,
    333                         &coin,
    334                         &res),
    335             TALER_denom_sig_free (&coin.denom_sig);
    336             TDB_denom_free (&denom); TDB_denom_free (&other));
    337   FAILIF_C (TALER_EXCHANGEDB_CKS_DENOM_CONFLICT != res.status,
    338             TALER_denom_sig_free (&coin.denom_sig);
    339             TDB_denom_free (&denom); TDB_denom_free (&other));
    340   FAILIF_C (0 != GNUNET_memcmp (&res.h_denom_pub,
    341                                 &denom.h_denom_pub),
    342             TALER_denom_sig_free (&coin.denom_sig);
    343             TDB_denom_free (&denom); TDB_denom_free (&other));
    344 
    345   /* same coin key and denomination, but now with an age commitment where
    346      the stored row has none: the caller should have passed none */
    347   coin.denom_pub_hash = denom.h_denom_pub;
    348   coin.no_age_commitment = false;
    349   TDB_FILL (coin.h_age_commitment,
    350             21);
    351   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    352             insert_one (pg,
    353                         &coin,
    354                         &res),
    355             TALER_denom_sig_free (&coin.denom_sig);
    356             TDB_denom_free (&denom); TDB_denom_free (&other));
    357   FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_EXPECTED_NULL != res.status,
    358             TALER_denom_sig_free (&coin.denom_sig);
    359             TDB_denom_free (&denom); TDB_denom_free (&other));
    360   TALER_denom_sig_free (&coin.denom_sig);
    361 
    362   /* the conflicting attempts did not add anything */
    363   FAILIF_C (1 != TALER_EXCHANGEDB_get_count_known_coins (pg,
    364                                                          &denom.h_denom_pub),
    365             TDB_denom_free (&denom); TDB_denom_free (&other));
    366   FAILIF_C (0 != TALER_EXCHANGEDB_get_count_known_coins (pg,
    367                                                          &other.h_denom_pub),
    368             TDB_denom_free (&denom); TDB_denom_free (&other));
    369   TDB_denom_free (&denom);
    370   TDB_denom_free (&other);
    371   return 0;
    372 }
    373 
    374 
    375 /**
    376  * A coin with an age commitment round-trips, and the mirror-image
    377  * conflict is reported.
    378  *
    379  * @param pg the database context
    380  * @return 0 on success
    381  */
    382 static int
    383 check_age_commitment (struct TALER_EXCHANGEDB_PostgresContext *pg)
    384 {
    385   struct TDB_Denom denom;
    386   struct TALER_CoinPublicInfo coin;
    387   struct TALER_CoinPublicInfo got;
    388   struct TALER_EXCHANGEDB_CoinKnownResult res;
    389   struct TALER_DenominationPublicKey denom_pub = { 0 };
    390   struct TALER_DenominationSignature denom_sig = { 0 };
    391   struct TALER_AgeCommitmentHashP h_age_commitment;
    392   bool no_age_commitment = true;
    393 
    394   TDB_denom (pg,
    395              10,
    396              "5",
    397              "0.1",
    398              &denom);
    399   memset (&coin,
    400           0,
    401           sizeof (coin));
    402   TDB_FILL (coin.coin_pub,
    403             30);
    404   coin.denom_pub_hash = denom.h_denom_pub;
    405   coin.no_age_commitment = false;
    406   TDB_FILL (coin.h_age_commitment,
    407             31);
    408   TDB_denom_sig (30,
    409                  &coin.denom_sig);
    410   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    411             insert_one (pg,
    412                         &coin,
    413                         &res),
    414             TALER_denom_sig_free (&coin.denom_sig);
    415             TDB_denom_free (&denom));
    416   FAILIF_C (TALER_EXCHANGEDB_CKS_ADDED != res.status,
    417             TALER_denom_sig_free (&coin.denom_sig);
    418             TDB_denom_free (&denom));
    419   FAILIF_C (0 == res.known_coin_id,
    420             TALER_denom_sig_free (&coin.denom_sig);
    421             TDB_denom_free (&denom));
    422   memset (&got,
    423           0,
    424           sizeof (got));
    425   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    426             TALER_EXCHANGEDB_get_known_coin (pg,
    427                                              &coin.coin_pub,
    428                                              &got),
    429             TALER_denom_sig_free (&coin.denom_sig);
    430             TDB_denom_free (&denom));
    431   FAILIF_C (got.no_age_commitment,
    432             TALER_denom_sig_free (&got.denom_sig);
    433             TALER_denom_sig_free (&coin.denom_sig);
    434             TDB_denom_free (&denom));
    435   FAILIF_C (0 != GNUNET_memcmp (&got.h_age_commitment,
    436                                 &coin.h_age_commitment),
    437             TALER_denom_sig_free (&got.denom_sig);
    438             TALER_denom_sig_free (&coin.denom_sig);
    439             TDB_denom_free (&denom));
    440   TALER_denom_sig_free (&got.denom_sig);
    441   /* the age commitment hash is part of the proof of the denomination */
    442   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    443             TALER_EXCHANGEDB_get_denomination_proof_for_known_coin (
    444               pg,
    445               &coin.coin_pub,
    446               &denom_pub,
    447               &denom_sig,
    448               &h_age_commitment,
    449               &no_age_commitment),
    450             TALER_denom_sig_free (&coin.denom_sig);
    451             TDB_denom_free (&denom));
    452   TALER_denom_pub_free (&denom_pub);
    453   TALER_denom_sig_free (&denom_sig);
    454   FAILIF_C ( (no_age_commitment) ||
    455              (0 != GNUNET_memcmp (&h_age_commitment,
    456                                   &coin.h_age_commitment)),
    457              TALER_denom_sig_free (&coin.denom_sig);
    458              TDB_denom_free (&denom));
    459 
    460   /* a different age commitment for the same coin is a conflict... */
    461   TDB_FILL (coin.h_age_commitment,
    462             32);
    463   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    464             insert_one (pg,
    465                         &coin,
    466                         &res),
    467             TALER_denom_sig_free (&coin.denom_sig);
    468             TDB_denom_free (&denom));
    469   FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_VALUE_DIFFERS != res.status,
    470             TALER_denom_sig_free (&coin.denom_sig);
    471             TDB_denom_free (&denom));
    472   /* the stored age commitment is handed back for the error report */
    473   FAILIF_C (res.no_age_commitment,
    474             TALER_denom_sig_free (&coin.denom_sig);
    475             TDB_denom_free (&denom));
    476   FAILIF_C (0 != GNUNET_memcmp (&res.h_age_commitment,
    477                                 &got.h_age_commitment),
    478             TALER_denom_sig_free (&coin.denom_sig);
    479             TDB_denom_free (&denom));
    480   /* ...and so is no age commitment at all, where one is on file */
    481   coin.no_age_commitment = true;
    482   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    483             insert_one (pg,
    484                         &coin,
    485                         &res),
    486             TALER_denom_sig_free (&coin.denom_sig);
    487             TDB_denom_free (&denom));
    488   FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_EXPECTED_NON_NULL != res.status,
    489             TALER_denom_sig_free (&coin.denom_sig);
    490             TDB_denom_free (&denom));
    491   TALER_denom_sig_free (&coin.denom_sig);
    492 
    493   /* two coins of this denomination by now */
    494   FAILIF_C (2 != TALER_EXCHANGEDB_get_count_known_coins (pg,
    495                                                          &denom.h_denom_pub),
    496             TDB_denom_free (&denom));
    497   TDB_denom_free (&denom);
    498   return 0;
    499 }
    500 
    501 
    502 /**
    503  * One call with a mixed batch: two new coins (one with an age
    504  * commitment), one already known, one with a conflicting denomination
    505  * and one with a conflicting age commitment.  Every coin must be
    506  * reported at its own position, the new ones must be inserted, and a
    507  * batch with a repeated coin or an unknown denomination is refused
    508  * without inserting anything.
    509  *
    510  * @param pg the database context
    511  * @return 0 on success
    512  */
    513 static int
    514 check_batch (struct TALER_EXCHANGEDB_PostgresContext *pg)
    515 {
    516   struct TDB_Denom denom;
    517   struct TDB_Denom other;
    518   struct TALER_CoinPublicInfo coins[5];
    519   const struct TALER_CoinPublicInfo *pcoins[5];
    520   struct TALER_EXCHANGEDB_CoinKnownResult res[5];
    521   struct TALER_DenominationHashP dh;
    522   uint64_t id;
    523   uint64_t count_before;
    524   int ret = 1;
    525 
    526   TDB_denom (pg,
    527              10,
    528              "5",
    529              "0.1",
    530              &denom);
    531   TDB_denom (pg,
    532              11,
    533              "5",
    534              "0.1",
    535              &other);
    536   memset (coins,
    537           0,
    538           sizeof (coins));
    539   for (unsigned int i = 0; i < 5; i++)
    540   {
    541     coins[i].no_age_commitment = true;
    542     coins[i].denom_pub_hash = denom.h_denom_pub;
    543     pcoins[i] = &coins[i];
    544   }
    545   /* [0]: new, no age commitment */
    546   TDB_FILL (coins[0].coin_pub,
    547             40);
    548   TDB_denom_sig (40,
    549                  &coins[0].denom_sig);
    550   /* [1]: new, with age commitment */
    551   TDB_FILL (coins[1].coin_pub,
    552             41);
    553   coins[1].no_age_commitment = false;
    554   TDB_FILL (coins[1].h_age_commitment,
    555             410);
    556   TDB_denom_sig (41,
    557                  &coins[1].denom_sig);
    558   /* [2]: known from check_insert_and_lookup (seed 20), same data */
    559   TDB_FILL (coins[2].coin_pub,
    560             20);
    561   TDB_denom_sig (20,
    562                  &coins[2].denom_sig);
    563   /* [3]: known (seed 20 again, different key below), other denomination */
    564   TDB_FILL (coins[3].coin_pub,
    565             20);
    566   coins[3].denom_pub_hash = other.h_denom_pub;
    567   TDB_denom_sig (20,
    568                  &coins[3].denom_sig);
    569   /* [4]: known from check_age_commitment (seed 30), wrong age commitment */
    570   TDB_FILL (coins[4].coin_pub,
    571             30);
    572   coins[4].no_age_commitment = false;
    573   TDB_FILL (coins[4].h_age_commitment,
    574             33);
    575   TDB_denom_sig (30,
    576                  &coins[4].denom_sig);
    577 
    578   count_before = TDB_count (pg,
    579                             "FROM known_coins");
    580 
    581   /* [2] and [3] share a key: refused, nothing inserted */
    582   FAILIF_C (GNUNET_DB_STATUS_HARD_ERROR !=
    583             TALER_EXCHANGEDB_do_insert_known_coins (pg,
    584                                                     5,
    585                                                     pcoins,
    586                                                     res),
    587             goto cleanup);
    588   FAILIF_C (count_before != TDB_count (pg,
    589                                        "FROM known_coins"),
    590             goto cleanup);
    591 
    592   /* give [3] its own key: a coin known under the other denomination */
    593   {
    594     struct TALER_EXCHANGEDB_CoinKnownResult r1;
    595     struct TALER_CoinPublicInfo tmp = coins[3];
    596 
    597     TDB_FILL (tmp.coin_pub,
    598               43);
    599     FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    600               insert_one (pg,
    601                           &tmp,
    602                           &r1),
    603               goto cleanup);
    604     FAILIF_C (TALER_EXCHANGEDB_CKS_ADDED != r1.status,
    605               goto cleanup);
    606     count_before++;
    607     TDB_FILL (coins[3].coin_pub,
    608               43);
    609     coins[3].denom_pub_hash = denom.h_denom_pub;
    610   }
    611 
    612   /* a new coin of an unknown denomination anywhere in the batch: the
    613      batch is refused.  The INSERT itself is one statement, so this is
    614      done inside a transaction as the callers do it, and the rollback
    615      removes the other new coin again. */
    616   TDB_FILL (coins[0].denom_pub_hash,
    617             44);
    618   FAILIF_C (GNUNET_OK !=
    619             TALER_EXCHANGEDB_start (pg,
    620                                     "test unknown denomination"),
    621             goto cleanup);
    622   FAILIF_C (GNUNET_DB_STATUS_HARD_ERROR !=
    623             TALER_EXCHANGEDB_do_insert_known_coins (pg,
    624                                                     5,
    625                                                     pcoins,
    626                                                     res),
    627             TALER_EXCHANGEDB_rollback (pg); goto cleanup);
    628   TALER_EXCHANGEDB_rollback (pg);
    629   FAILIF_C (count_before != TDB_count (pg,
    630                                        "FROM known_coins"),
    631             goto cleanup);
    632   coins[0].denom_pub_hash = denom.h_denom_pub;
    633 
    634   /* now the mixed batch goes through, with one row per coin */
    635   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    636             TALER_EXCHANGEDB_do_insert_known_coins (pg,
    637                                                     5,
    638                                                     pcoins,
    639                                                     res),
    640             goto cleanup);
    641   FAILIF_C (TALER_EXCHANGEDB_CKS_ADDED != res[0].status,
    642             goto cleanup);
    643   FAILIF_C (0 == res[0].known_coin_id,
    644             goto cleanup);
    645   FAILIF_C (TALER_EXCHANGEDB_CKS_ADDED != res[1].status,
    646             goto cleanup);
    647   FAILIF_C (0 == res[1].known_coin_id,
    648             goto cleanup);
    649   /* for added coins, the result reflects what was stored */
    650   FAILIF_C (! res[0].no_age_commitment,
    651             goto cleanup);
    652   FAILIF_C (0 != GNUNET_memcmp (&res[0].h_denom_pub,
    653                                 &denom.h_denom_pub),
    654             goto cleanup);
    655   FAILIF_C (res[1].no_age_commitment,
    656             goto cleanup);
    657   FAILIF_C (0 != GNUNET_memcmp (&res[1].h_age_commitment,
    658                                 &coins[1].h_age_commitment),
    659             goto cleanup);
    660   FAILIF_C (res[0].known_coin_id == res[1].known_coin_id,
    661             goto cleanup);
    662   FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res[2].status,
    663             goto cleanup);
    664   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    665             TALER_EXCHANGEDB_get_coin_denomination (pg,
    666                                                     &coins[2].coin_pub,
    667                                                     &id,
    668                                                     &dh),
    669             goto cleanup);
    670   FAILIF_C (id != res[2].known_coin_id,
    671             goto cleanup);
    672   FAILIF_C (TALER_EXCHANGEDB_CKS_DENOM_CONFLICT != res[3].status,
    673             goto cleanup);
    674   FAILIF_C (0 != GNUNET_memcmp (&res[3].h_denom_pub,
    675                                 &other.h_denom_pub),
    676             goto cleanup);
    677   FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_VALUE_DIFFERS != res[4].status,
    678             goto cleanup);
    679   FAILIF_C (res[4].no_age_commitment,
    680             goto cleanup);
    681   FAILIF_C (0 == GNUNET_memcmp (&res[4].h_age_commitment,
    682                                 &coins[4].h_age_commitment),
    683             goto cleanup);
    684   /* exactly the two new coins were added */
    685   FAILIF_C (count_before + 2 != TDB_count (pg,
    686                                            "FROM known_coins"),
    687             goto cleanup);
    688   {
    689     struct TALER_CoinPublicInfo got;
    690 
    691     memset (&got,
    692             0,
    693             sizeof (got));
    694     FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    695               TALER_EXCHANGEDB_get_known_coin (pg,
    696                                                &coins[1].coin_pub,
    697                                                &got),
    698               goto cleanup);
    699     FAILIF_C (got.no_age_commitment,
    700               TALER_denom_sig_free (&got.denom_sig); goto cleanup);
    701     FAILIF_C (0 != GNUNET_memcmp (&got.h_age_commitment,
    702                                   &coins[1].h_age_commitment),
    703               TALER_denom_sig_free (&got.denom_sig); goto cleanup);
    704     FAILIF_C (0 != TALER_denom_sig_cmp (&got.denom_sig,
    705                                         &coins[1].denom_sig),
    706               TALER_denom_sig_free (&got.denom_sig); goto cleanup);
    707     TALER_denom_sig_free (&got.denom_sig);
    708   }
    709 
    710   /* running the same batch again changes nothing: the new coins are
    711      now merely present, the conflicts are reported as before */
    712   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    713             TALER_EXCHANGEDB_do_insert_known_coins (pg,
    714                                                     5,
    715                                                     pcoins,
    716                                                     res),
    717             goto cleanup);
    718   FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res[0].status,
    719             goto cleanup);
    720   FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res[1].status,
    721             goto cleanup);
    722   FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res[2].status,
    723             goto cleanup);
    724   FAILIF_C (TALER_EXCHANGEDB_CKS_DENOM_CONFLICT != res[3].status,
    725             goto cleanup);
    726   FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_VALUE_DIFFERS != res[4].status,
    727             goto cleanup);
    728   FAILIF_C (count_before + 2 != TDB_count (pg,
    729                                            "FROM known_coins"),
    730             goto cleanup);
    731   ret = 0;
    732 cleanup:
    733   for (unsigned int i = 0; i < 5; i++)
    734     TALER_denom_sig_free (&coins[i].denom_sig);
    735   TDB_denom_free (&denom);
    736   TDB_denom_free (&other);
    737   return ret;
    738 }
    739 
    740 
    741 /**
    742  * Both ways out of do_insert_known_coins() release the closures its
    743  * query parameters allocate.  Nothing to assert here: the leak shows up
    744  * when the test runs under valgrind (meson test --setup=valgrind).
    745  *
    746  * @param pg the database context
    747  * @return 0 on success
    748  */
    749 static int
    750 check_no_leak (struct TALER_EXCHANGEDB_PostgresContext *pg)
    751 {
    752   struct TDB_Denom denom;
    753   struct TALER_CoinPublicInfo coins[2];
    754   const struct TALER_CoinPublicInfo *pcoins[2];
    755   const struct TALER_CoinPublicInfo *dups[2];
    756   struct TALER_EXCHANGEDB_CoinKnownResult res[2];
    757   int ret = 1;
    758 
    759   TDB_denom (pg,
    760              10,
    761              "5",
    762              "0.1",
    763              &denom);
    764   memset (coins,
    765           0,
    766           sizeof (coins));
    767   for (unsigned int i = 0; i < 2; i++)
    768   {
    769     coins[i].no_age_commitment = true;
    770     coins[i].denom_pub_hash = denom.h_denom_pub;
    771     TDB_FILL (coins[i].coin_pub,
    772               50 + i);
    773     TDB_denom_sig (50 + i,
    774                    &coins[i].denom_sig);
    775     pcoins[i] = &coins[i];
    776     dups[i] = &coins[0];
    777   }
    778   /* the batch goes through: first inserted, then found */
    779   for (unsigned int i = 0; i < 2; i++)
    780   {
    781     FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
    782               TALER_EXCHANGEDB_do_insert_known_coins (pg,
    783                                                       2,
    784                                                       pcoins,
    785                                                       res),
    786               goto cleanup);
    787     FAILIF_C ( (i == 0)
    788                ? (TALER_EXCHANGEDB_CKS_ADDED != res[1].status)
    789                : (TALER_EXCHANGEDB_CKS_PRESENT != res[1].status),
    790                goto cleanup);
    791   }
    792   /* the batch is refused before the query for repeating a coin */
    793   FAILIF_C (GNUNET_DB_STATUS_HARD_ERROR !=
    794             TALER_EXCHANGEDB_do_insert_known_coins (pg,
    795                                                     2,
    796                                                     dups,
    797                                                     res),
    798             goto cleanup);
    799   ret = 0;
    800 cleanup:
    801   for (unsigned int i = 0; i < 2; i++)
    802     TALER_denom_sig_free (&coins[i].denom_sig);
    803   TDB_denom_free (&denom);
    804   return ret;
    805 }
    806 
    807 
    808 /**
    809  * The checks to run, in order.
    810  */
    811 static const struct TDB_Test tests[] = {
    812   { "known-coins-empty",
    813     &check_empty },
    814   { "known-coins-unknown-denomination",
    815     &check_unknown_denomination },
    816   { "known-coins-insert-and-lookup",
    817     &check_insert_and_lookup },
    818   { "known-coins-conflicts",
    819     &check_conflicts },
    820   { "known-coins-age-commitment",
    821     &check_age_commitment },
    822   { "known-coins-batch",
    823     &check_batch },
    824   { "known-coins-no-leak",
    825     &check_no_leak },
    826   { NULL, NULL }
    827 };
    828 
    829 
    830 int
    831 main (int argc,
    832       char *const *argv)
    833 {
    834   return TDB_main (argc,
    835                    argv,
    836                    "test-known-coins",
    837                    "Tests for the exchangedb `known_coins' table",
    838                    tests);
    839 }
    840 
    841 
    842 /* end of test_known_coins.c */