Line data Source code
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_coin_history.c
18 : * @brief tests for the exchangedb functions whose primary table is
19 : * `coin_history`
20 : * @author Christian Grothoff
21 : *
22 : * Covers #TALER_EXCHANGEDB_get_coin_transactions().
23 : *
24 : * Nothing writes to `coin_history` directly: every table that can spend or
25 : * credit a coin has an INSERT trigger that appends a row naming itself and
26 : * its own serial. get_coin_transactions() walks those rows and looks each
27 : * one up in the table it names. So the interesting part of this test is
28 : * spending one coin in as many different ways as possible and then checking
29 : * that every one of them comes back with the right type and amount.
30 : */
31 : #include "test_common.h"
32 : #include "exchange-database/do_purse_deposit.h"
33 : #include "exchange-database/rollback.h"
34 : #include "exchange-database/start.h"
35 : #include "exchange-database/do_recoup.h"
36 : #include "exchange-database/do_recoup_refresh.h"
37 : #include "exchange-database/do_refresh.h"
38 : #include "exchange-database/do_refund.h"
39 : #include "exchange-database/get_coin_transactions.h"
40 : #include "exchange-database/insert_reserve_open_deposit.h"
41 : #include "exchange-database/update_to_refresh_revealed.h"
42 :
43 : /**
44 : * Number of fresh coins of the melt in check_other_spends().
45 : */
46 : #define NUM_FRESH_COINS 3
47 :
48 :
49 : /**
50 : * Account the checks fund their reserves from.
51 : */
52 : static struct TDB_Account account;
53 :
54 :
55 : /**
56 : * Denomination the checks use.
57 : */
58 : static struct TDB_Denom denom;
59 :
60 :
61 : /**
62 : * A different denomination used among the refresh outputs.
63 : */
64 : static struct TDB_Denom fresh_denom;
65 :
66 :
67 : /**
68 : * The coin whose history we build up.
69 : */
70 : static struct TALER_CoinPublicInfo coin;
71 :
72 :
73 : /**
74 : * Row of @e coin in `known_coins`.
75 : */
76 : static uint64_t known_coin_id;
77 :
78 :
79 : /**
80 : * Reserve @e coin was withdrawn from.
81 : */
82 : static struct TALER_ReservePublicKeyP reserve_pub;
83 :
84 :
85 : /**
86 : * Row of the withdraw that created @e coin.
87 : */
88 : static uint64_t withdraw_id;
89 :
90 :
91 : /**
92 : * The deposit we later refund.
93 : */
94 : static struct TDB_Deposit deposit;
95 :
96 :
97 : /**
98 : * ETag of the history right after the deposit was refunded.
99 : */
100 : static uint64_t etag_after_refund;
101 :
102 :
103 : /**
104 : * Count the entries of @a tl and remember which types occurred.
105 : *
106 : * @param tl transaction list to walk
107 : * @param[out] types set to the bitmask of the types seen
108 : * @return number of entries in @a tl
109 : */
110 : static unsigned int
111 7 : summarize (const struct TALER_EXCHANGEDB_TransactionList *tl,
112 : unsigned int *types)
113 : {
114 7 : unsigned int cnt = 0;
115 :
116 7 : *types = 0;
117 7 : for (const struct TALER_EXCHANGEDB_TransactionList *pos = tl;
118 35 : NULL != pos;
119 28 : pos = pos->next)
120 : {
121 28 : cnt++;
122 28 : *types |= 1U << pos->type;
123 : }
124 7 : return cnt;
125 : }
126 :
127 :
128 : /**
129 : * Ask for the full history of @e coin.
130 : *
131 : * @param pg the database context
132 : * @param start_off offset to start from
133 : * @param etag_in ETag the caller already has
134 : * @param[out] etag_out set to the current ETag
135 : * @param[out] tlp set to the history
136 : * @return transaction status
137 : */
138 : static enum GNUNET_DB_QueryStatus
139 8 : history (struct TALER_EXCHANGEDB_PostgresContext *pg,
140 : uint64_t start_off,
141 : uint64_t etag_in,
142 : uint64_t *etag_out,
143 : struct TALER_EXCHANGEDB_TransactionList **tlp)
144 : {
145 : struct TALER_Amount balance;
146 : struct TALER_DenominationHashP h_denom_pub;
147 :
148 8 : return TALER_EXCHANGEDB_get_coin_transactions (pg,
149 : true,
150 : &coin.coin_pub,
151 : start_off,
152 : etag_in,
153 : etag_out,
154 : &balance,
155 : &h_denom_pub,
156 : tlp);
157 : }
158 :
159 :
160 : /**
161 : * A coin the exchange never saw has no history.
162 : *
163 : * @param pg the database context
164 : * @return 0 on success
165 : */
166 : static int
167 1 : check_unknown_coin (struct TALER_EXCHANGEDB_PostgresContext *pg)
168 : {
169 1 : struct TALER_EXCHANGEDB_TransactionList *tl = (void *) 1;
170 : struct TALER_CoinSpendPublicKeyP unknown;
171 : struct TALER_Amount balance;
172 : struct TALER_DenominationHashP h_denom_pub;
173 1 : uint64_t etag = 42;
174 :
175 1 : TDB_account (pg,
176 : 10,
177 : &account);
178 1 : TDB_denom (pg,
179 : 10,
180 : "5",
181 : "0.1",
182 : &denom);
183 1 : TDB_FILL (unknown,
184 : 99);
185 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
186 : TALER_EXCHANGEDB_get_coin_transactions (pg,
187 : true,
188 : &unknown,
189 : 0,
190 : 0,
191 : &etag,
192 : &balance,
193 : &h_denom_pub,
194 : &tl));
195 1 : FAILIF (NULL != tl);
196 1 : return 0;
197 : }
198 :
199 :
200 : /**
201 : * A coin that was withdrawn but never spent has no history either: the
202 : * `withdraw` table has no coin history trigger.
203 : *
204 : * @param pg the database context
205 : * @return 0 on success
206 : */
207 : static int
208 1 : check_fresh_coin (struct TALER_EXCHANGEDB_PostgresContext *pg)
209 : {
210 1 : struct TALER_EXCHANGEDB_TransactionList *tl = (void *) 1;
211 1 : uint64_t etag = 42;
212 :
213 1 : TDB_reserve_in (pg,
214 : &account,
215 : 11,
216 : "10",
217 : &reserve_pub);
218 1 : withdraw_id = TDB_withdraw (pg,
219 : &denom,
220 : &reserve_pub,
221 : 11,
222 : "5");
223 1 : TDB_coin (pg,
224 : &denom,
225 : 20,
226 : &coin,
227 : &known_coin_id);
228 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
229 : history (pg,
230 : 0,
231 : 0,
232 : &etag,
233 : &tl));
234 1 : FAILIF (NULL != tl);
235 1 : FAILIF (0 != TDB_count (pg,
236 : "FROM coin_history"));
237 1 : return 0;
238 : }
239 :
240 :
241 : /**
242 : * A deposit and its refund show up as two entries.
243 : *
244 : * @param pg the database context
245 : * @return 0 on success
246 : */
247 : static int
248 1 : check_deposit_and_refund (struct TALER_EXCHANGEDB_PostgresContext *pg)
249 : {
250 1 : struct TALER_EXCHANGEDB_TransactionList *tl = NULL;
251 : struct TALER_EXCHANGEDB_Refund refund;
252 1 : struct TALER_Amount deposit_fee = TDB_amount ("0.1");
253 : struct TALER_Amount balance;
254 1 : struct TALER_Amount expect = TDB_amount ("4.5");
255 : struct TALER_DenominationHashP h_denom_pub;
256 : unsigned int types;
257 1 : uint64_t etag = 0;
258 : bool not_found;
259 : bool refund_ok;
260 : bool gone;
261 : bool conflict;
262 :
263 1 : TDB_deposit (pg,
264 : &account,
265 : &coin,
266 : 30,
267 : "1",
268 : "0.1",
269 : GNUNET_TIME_relative_to_timestamp (GNUNET_TIME_UNIT_HOURS),
270 : GNUNET_TIME_relative_to_timestamp (GNUNET_TIME_UNIT_HOURS),
271 : &deposit);
272 1 : FAILIF (1 != TDB_count (pg,
273 : "FROM coin_history"));
274 :
275 1 : memset (&refund,
276 : 0,
277 : sizeof (refund));
278 1 : refund.coin = coin;
279 1 : refund.details.merchant_pub = deposit.merchant_pub;
280 1 : TDB_FILL (refund.details.merchant_sig,
281 : 31);
282 1 : refund.details.h_contract_terms = deposit.h_contract_terms;
283 1 : refund.details.rtransaction_id = 1;
284 1 : refund.details.refund_amount = TDB_amount ("0.5");
285 1 : refund.details.refund_fee = TDB_amount ("0");
286 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
287 : TALER_EXCHANGEDB_do_refund (pg,
288 : &refund,
289 : &deposit_fee,
290 : 0,
291 : ¬_found,
292 : &refund_ok,
293 : &gone,
294 : &conflict));
295 1 : FAILIF (not_found);
296 1 : FAILIF (! refund_ok);
297 1 : FAILIF (2 != TDB_count (pg,
298 : "FROM coin_history"));
299 :
300 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
301 : TALER_EXCHANGEDB_get_coin_transactions (pg,
302 : true,
303 : &coin.coin_pub,
304 : 0,
305 : 0,
306 : &etag,
307 : &balance,
308 : &h_denom_pub,
309 : &tl));
310 1 : FAILIF_C (2 != summarize (tl,
311 : &types),
312 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
313 1 : FAILIF_C (0 == (types & (1U << TALER_EXCHANGEDB_TT_DEPOSIT)),
314 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
315 1 : FAILIF_C (0 == (types & (1U << TALER_EXCHANGEDB_TT_REFUND)),
316 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
317 : /* 5 - 1 + 0.5 */
318 1 : FAILIF_C (0 != TALER_amount_cmp (&balance,
319 : &expect),
320 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
321 1 : FAILIF_C (0 != GNUNET_memcmp (&h_denom_pub,
322 : &denom.h_denom_pub),
323 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
324 1 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
325 1 : FAILIF (0 == etag);
326 1 : etag_after_refund = etag;
327 1 : return 0;
328 : }
329 :
330 :
331 : /**
332 : * A caller that is already up to date gets no list back, and the
333 : * transaction the lookup opened is not left dangling.
334 : *
335 : * @param pg the database context
336 : * @return 0 on success
337 : */
338 : static int
339 1 : check_etag (struct TALER_EXCHANGEDB_PostgresContext *pg)
340 : {
341 1 : struct TALER_EXCHANGEDB_TransactionList *tl = (void *) 1;
342 1 : uint64_t etag = 0;
343 :
344 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
345 : history (pg,
346 : 0,
347 : etag_after_refund,
348 : &etag,
349 : &tl));
350 1 : FAILIF (NULL != tl);
351 1 : FAILIF (etag != etag_after_refund);
352 : /* the lookup must not leave a transaction open (it starts one of its
353 : own when begin_transaction is true) */
354 1 : FAILIF (NULL != pg->transaction_name);
355 :
356 : /* an ETag that is not the current one still returns the history */
357 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
358 : history (pg,
359 : 0,
360 : etag_after_refund - 1,
361 : &etag,
362 : &tl));
363 1 : FAILIF (NULL == tl);
364 1 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
365 1 : FAILIF (NULL != pg->transaction_name);
366 1 : return 0;
367 : }
368 :
369 :
370 : /**
371 : * The offset skips everything up to and including it.
372 : *
373 : * @param pg the database context
374 : * @return 0 on success
375 : */
376 : static int
377 1 : check_offset (struct TALER_EXCHANGEDB_PostgresContext *pg)
378 : {
379 1 : struct TALER_EXCHANGEDB_TransactionList *tl = NULL;
380 : unsigned int types;
381 1 : uint64_t etag = 0;
382 :
383 : /* everything after the deposit: only the refund is left */
384 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
385 : history (pg,
386 : etag_after_refund - 1,
387 : 0,
388 : &etag,
389 : &tl));
390 1 : FAILIF_C (1 != summarize (tl,
391 : &types),
392 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
393 1 : FAILIF_C (0 == (types & (1U << TALER_EXCHANGEDB_TT_REFUND)),
394 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
395 1 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
396 :
397 : /* everything after the last entry: nothing, but the ETag is still
398 : reported */
399 1 : tl = (void *) 1;
400 1 : etag = 0;
401 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
402 : history (pg,
403 : etag_after_refund,
404 : 0,
405 : &etag,
406 : &tl));
407 1 : FAILIF (NULL != tl);
408 1 : FAILIF (etag != etag_after_refund);
409 1 : return 0;
410 : }
411 :
412 :
413 : /**
414 : * Spending the coin into a purse, on a reserve and in a melt adds one
415 : * entry each.
416 : *
417 : * @param pg the database context
418 : * @return 0 on success
419 : */
420 : static int
421 1 : check_other_spends (struct TALER_EXCHANGEDB_PostgresContext *pg)
422 : {
423 1 : struct TALER_EXCHANGEDB_TransactionList *tl = NULL;
424 : struct TDB_Purse purse;
425 : struct TALER_CoinSpendSignatureP coin_sig;
426 : struct TALER_ReserveSignatureP reserve_sig;
427 1 : struct TALER_Amount one = TDB_amount ("1");
428 1 : struct TALER_Amount zero = TDB_amount ("0");
429 : unsigned int types;
430 1 : uint64_t etag = 0;
431 : bool balance_ok;
432 : bool too_late;
433 : bool conflict;
434 : bool insufficient_funds;
435 :
436 : /* into a purse */
437 1 : TDB_purse (pg,
438 : 40,
439 : "1",
440 : GNUNET_TIME_relative_to_timestamp (GNUNET_TIME_UNIT_HOURS),
441 : &purse);
442 1 : TDB_FILL (coin_sig,
443 : 41);
444 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
445 : TALER_EXCHANGEDB_do_purse_deposit (pg,
446 : &purse.purse_pub,
447 : &coin.coin_pub,
448 : &one,
449 : &coin_sig,
450 : &one,
451 : &balance_ok,
452 : &too_late,
453 : &conflict));
454 1 : FAILIF (! balance_ok);
455 1 : FAILIF (conflict);
456 :
457 : /* to keep a reserve open */
458 1 : TDB_FILL (coin_sig,
459 : 42);
460 1 : TDB_FILL (reserve_sig,
461 : 42);
462 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
463 : TALER_EXCHANGEDB_insert_reserve_open_deposit (pg,
464 : &coin,
465 : &coin_sig,
466 : known_coin_id,
467 : &one,
468 : &reserve_sig,
469 : &reserve_pub,
470 : &insufficient_funds));
471 1 : FAILIF (insufficient_funds);
472 :
473 : /* and into a melt */
474 : {
475 : struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS rf;
476 1 : struct GNUNET_TIME_Timestamp now = GNUNET_TIME_timestamp_get ();
477 : struct TALER_Amount coin_balance;
478 : bool found;
479 1 : bool zombie_required = false;
480 : bool nonce_reuse;
481 : bool melt_balance_ok;
482 : uint32_t noreveal_index;
483 : struct TALER_TransferPublicKeyP transfer_pubs[NUM_FRESH_COINS];
484 : enum GNUNET_DB_QueryStatus qs;
485 :
486 1 : memset (&rf,
487 : 0,
488 : sizeof (rf));
489 1 : rf.coin.coin_pub = coin.coin_pub;
490 1 : rf.coin.denom_pub_hash = coin.denom_pub_hash;
491 1 : rf.coin.no_age_commitment = coin.no_age_commitment;
492 1 : TDB_FILL (rf.coin_sig,
493 : 43);
494 1 : TDB_FILL (rf.rc,
495 : 43);
496 1 : TDB_FILL (rf.refresh_seed,
497 : 43);
498 1 : TDB_FILL (rf.planchets_h,
499 : 43);
500 1 : TDB_FILL (rf.selected_h,
501 : 44);
502 1 : rf.amount_with_fee = one;
503 1 : TDB_denom (pg,
504 : 11,
505 : "0.1",
506 : "0.01",
507 : &fresh_denom);
508 1 : rf.num_coins = NUM_FRESH_COINS;
509 1 : rf.denom_serials = GNUNET_new_array (rf.num_coins,
510 : uint64_t);
511 : /* Deliberately neither sorted nor distinct. */
512 1 : rf.denom_serials[0] = fresh_denom.serial;
513 1 : rf.denom_serials[1] = denom.serial;
514 1 : rf.denom_serials[2] = fresh_denom.serial;
515 1 : rf.denom_sigs = GNUNET_new_array (
516 : rf.num_coins,
517 : struct TALER_BlindedDenominationSignature);
518 4 : for (unsigned int i = 0; i < rf.num_coins; i++)
519 3 : TDB_blinded_denom_sig (43 + i,
520 3 : &rf.denom_sigs[i]);
521 4 : for (unsigned int i = 0; i < rf.num_coins; i++)
522 3 : TDB_FILL (transfer_pubs[i],
523 : 50 + i);
524 1 : rf.transfer_pubs = transfer_pubs;
525 1 : rf.noreveal_index = 1;
526 1 : rf.rc_version = TALER_REFRESH_COMMITMENT_VERSION_CURRENT;
527 1 : rf.no_blinding_seed = true;
528 1 : qs = TALER_EXCHANGEDB_do_refresh (pg,
529 : &rf,
530 : &now,
531 : &found,
532 : &noreveal_index,
533 : &zombie_required,
534 : &nonce_reuse,
535 : &melt_balance_ok,
536 : &coin_balance);
537 4 : for (unsigned int i = 0; i < rf.num_coins; i++)
538 3 : TALER_blinded_denom_sig_free (&rf.denom_sigs[i]);
539 1 : GNUNET_free (rf.denom_sigs);
540 1 : GNUNET_free (rf.denom_serials);
541 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs);
542 1 : FAILIF (! melt_balance_ok);
543 :
544 : /* The melt entry is the same before and after the reveal. */
545 3 : for (unsigned int revealed = 0; revealed < 2; revealed++)
546 : {
547 2 : bool found_melt = false;
548 :
549 2 : if (revealed)
550 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
551 : TALER_EXCHANGEDB_update_to_refresh_revealed (pg,
552 : &rf.rc));
553 2 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
554 : history (pg,
555 : 0,
556 : 0,
557 : &etag,
558 : &tl));
559 2 : for (const struct TALER_EXCHANGEDB_TransactionList *pos = tl;
560 12 : NULL != pos;
561 10 : pos = pos->next)
562 : {
563 : const struct TALER_EXCHANGEDB_MeltListEntry *melt;
564 :
565 10 : if (TALER_EXCHANGEDB_TT_MELT != pos->type)
566 8 : continue;
567 2 : found_melt = true;
568 2 : melt = pos->details.melt;
569 2 : FAILIF_C (NUM_FRESH_COINS != melt->num_coins,
570 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
571 2 : FAILIF_C (0 != GNUNET_memcmp (&melt->denom_pub_hashes[0],
572 : &fresh_denom.h_denom_pub),
573 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
574 2 : FAILIF_C (0 != GNUNET_memcmp (&melt->denom_pub_hashes[1],
575 : &denom.h_denom_pub),
576 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
577 2 : FAILIF_C (0 != GNUNET_memcmp (&melt->denom_pub_hashes[2],
578 : &fresh_denom.h_denom_pub),
579 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
580 2 : FAILIF_C (noreveal_index != melt->noreveal_index,
581 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
582 2 : FAILIF_C ( (NULL == melt->transfer_pubs) ||
583 : (0 != memcmp (melt->transfer_pubs,
584 : transfer_pubs,
585 : sizeof (transfer_pubs))),
586 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
587 : }
588 2 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
589 2 : tl = NULL;
590 2 : FAILIF (! found_melt);
591 : }
592 : }
593 :
594 1 : FAILIF (5 != TDB_count (pg,
595 : "FROM coin_history"));
596 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
597 : history (pg,
598 : 0,
599 : 0,
600 : &etag,
601 : &tl));
602 1 : FAILIF_C (5 != summarize (tl,
603 : &types),
604 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
605 1 : FAILIF_C (0 == (types & (1U << TALER_EXCHANGEDB_TT_PURSE_DEPOSIT)),
606 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
607 1 : FAILIF_C (0 == (types & (1U << TALER_EXCHANGEDB_TT_RESERVE_OPEN)),
608 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
609 1 : FAILIF_C (0 == (types & (1U << TALER_EXCHANGEDB_TT_MELT)),
610 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
611 :
612 : /* the ETag is the highest coin history row of the list */
613 : {
614 1 : uint64_t max = 0;
615 :
616 1 : for (const struct TALER_EXCHANGEDB_TransactionList *pos = tl;
617 6 : NULL != pos;
618 5 : pos = pos->next)
619 5 : max = GNUNET_MAX (max,
620 : pos->coin_history_id);
621 1 : FAILIF_C (etag != max,
622 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
623 : }
624 :
625 : /* the spends add up to what the coin no longer has */
626 : {
627 : struct TALER_Amount total;
628 1 : struct TALER_Amount expect = TDB_amount ("3.5");
629 :
630 1 : FAILIF_C (GNUNET_OK !=
631 : TALER_EXCHANGEDB_calculate_transaction_list_totals (tl,
632 : &zero,
633 : &total),
634 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
635 1 : FAILIF_C (0 != TALER_amount_cmp (&total,
636 : &expect),
637 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
638 : }
639 1 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
640 1 : return 0;
641 : }
642 :
643 :
644 : /**
645 : * Recouping the coin adds the last entry and empties it.
646 : *
647 : * @param pg the database context
648 : * @return 0 on success
649 : */
650 : static int
651 1 : check_recoup (struct TALER_EXCHANGEDB_PostgresContext *pg)
652 : {
653 1 : struct TALER_EXCHANGEDB_TransactionList *tl = NULL;
654 : struct TALER_CoinSpendSignatureP coin_sig;
655 : union GNUNET_CRYPTO_BlindingSecretP coin_bks;
656 : struct GNUNET_TIME_Timestamp recoup_timestamp;
657 : struct TALER_Amount recoup_amount;
658 : struct TALER_Amount balance;
659 1 : struct TALER_Amount zero = TDB_amount ("0");
660 : struct TALER_DenominationHashP h_denom_pub;
661 : unsigned int types;
662 1 : uint64_t etag = 0;
663 : bool recoup_ok;
664 : bool internal_failure;
665 :
666 1 : TDB_FILL (coin_sig,
667 : 50);
668 1 : TDB_FILL (coin_bks,
669 : 50);
670 : /* in/out: the caller picks the time, the callee only overwrites it if
671 : the coin was recouped before */
672 1 : recoup_timestamp = GNUNET_TIME_timestamp_get ();
673 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
674 : TALER_EXCHANGEDB_do_recoup (pg,
675 : &reserve_pub,
676 : withdraw_id,
677 : 3,
678 : &coin_bks,
679 : &coin.coin_pub,
680 : known_coin_id,
681 : &coin_sig,
682 : &recoup_timestamp,
683 : &recoup_amount,
684 : &recoup_ok,
685 : &internal_failure));
686 1 : FAILIF (internal_failure);
687 1 : FAILIF (! recoup_ok);
688 1 : FAILIF (6 != TDB_count (pg,
689 : "FROM coin_history"));
690 :
691 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
692 : TALER_EXCHANGEDB_get_coin_transactions (pg,
693 : true,
694 : &coin.coin_pub,
695 : 0,
696 : 0,
697 : &etag,
698 : &balance,
699 : &h_denom_pub,
700 : &tl));
701 1 : FAILIF_C (6 != summarize (tl,
702 : &types),
703 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
704 1 : FAILIF_C (0 == (types & (1U << TALER_EXCHANGEDB_TT_RECOUP_WITHDRAW)),
705 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
706 : /* the entry names the withdraw operation (by its commitment, seeded
707 : like the withdraw in check_fresh_coin()) and the coin's position */
708 : {
709 1 : const struct TALER_EXCHANGEDB_RecoupListEntry *recoup = NULL;
710 : struct TALER_HashBlindedPlanchetsP planchets_h;
711 :
712 1 : TDB_FILL (planchets_h,
713 : 11);
714 1 : for (const struct TALER_EXCHANGEDB_TransactionList *pos = tl;
715 7 : NULL != pos;
716 6 : pos = pos->next)
717 6 : if (TALER_EXCHANGEDB_TT_RECOUP_WITHDRAW == pos->type)
718 1 : recoup = pos->details.recoup;
719 1 : FAILIF_C (NULL == recoup,
720 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
721 1 : FAILIF_C (3 != recoup->coin_index,
722 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
723 1 : FAILIF_C (0 != GNUNET_memcmp (&recoup->planchets_h,
724 : &planchets_h),
725 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
726 1 : FAILIF_C (0 != GNUNET_memcmp (&recoup->reserve_pub,
727 : &reserve_pub),
728 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
729 1 : FAILIF_C (0 != GNUNET_memcmp (&recoup->coin_sig,
730 : &coin_sig),
731 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
732 1 : FAILIF_C (0 != GNUNET_memcmp (&recoup->coin_blind,
733 : &coin_bks),
734 : TALER_EXCHANGEDB_free_coin_transaction_list (tl));
735 : }
736 1 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
737 1 : FAILIF (0 != TALER_amount_cmp (&balance,
738 : &zero));
739 1 : return 0;
740 : }
741 :
742 :
743 : /**
744 : * With begin_transaction false the caller's transaction is used and left
745 : * open.
746 : *
747 : * @param pg the database context
748 : * @return 0 on success
749 : */
750 : static int
751 1 : check_in_transaction (struct TALER_EXCHANGEDB_PostgresContext *pg)
752 : {
753 1 : struct TALER_EXCHANGEDB_TransactionList *tl = NULL;
754 : struct TALER_Amount balance;
755 : struct TALER_DenominationHashP h_denom_pub;
756 : unsigned int types;
757 1 : uint64_t etag = 0;
758 :
759 1 : FAILIF (GNUNET_OK !=
760 : TALER_EXCHANGEDB_start (pg,
761 : "coin-history"));
762 1 : FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
763 : TALER_EXCHANGEDB_get_coin_transactions (pg,
764 : false,
765 : &coin.coin_pub,
766 : 0,
767 : 0,
768 : &etag,
769 : &balance,
770 : &h_denom_pub,
771 : &tl),
772 : TALER_EXCHANGEDB_rollback (pg));
773 1 : FAILIF_C (6 != summarize (tl,
774 : &types),
775 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
776 : TALER_EXCHANGEDB_rollback (pg));
777 1 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
778 1 : FAILIF_C (NULL == pg->transaction_name,
779 : TALER_EXCHANGEDB_rollback (pg));
780 1 : TALER_EXCHANGEDB_rollback (pg);
781 1 : return 0;
782 : }
783 :
784 :
785 : /**
786 : * Recouping a coin that was refreshed from @e coin credits @e coin and adds
787 : * a RECOUP-REFRESH-RECEIVER entry to its history that names the refresh
788 : * operation (by its commitment, seeded like the melt in
789 : * check_other_spends()), the recouped coin and its position in the batch.
790 : * The recouped coin's own history gets the matching RECOUP-REFRESH entry.
791 : *
792 : * @param pg the database context
793 : * @return 0 on success
794 : */
795 : static int
796 1 : check_recoup_refresh (struct TALER_EXCHANGEDB_PostgresContext *pg)
797 : {
798 1 : struct TALER_EXCHANGEDB_TransactionList *tl = NULL;
799 1 : const struct TALER_EXCHANGEDB_RecoupRefreshListEntry *rr = NULL;
800 : struct TALER_CoinPublicInfo fresh_coin;
801 : struct TALER_RefreshCommitmentP rc;
802 : struct TALER_CoinSpendSignatureP coin_sig;
803 : union GNUNET_CRYPTO_BlindingSecretP coin_bks;
804 : struct GNUNET_TIME_Timestamp recoup_timestamp;
805 : struct TALER_Amount recoup_amount;
806 : struct TALER_Amount balance;
807 1 : struct TALER_Amount zero = TDB_amount ("0");
808 1 : struct TALER_Amount credited = TDB_amount ("0.1");
809 : struct TALER_DenominationHashP h_denom_pub;
810 : uint64_t fresh_known_coin_id;
811 : uint64_t refresh_id;
812 1 : uint64_t etag = 0;
813 : unsigned int types;
814 : bool recoup_ok;
815 : bool internal_failure;
816 :
817 1 : TDB_FILL (rc,
818 : 43);
819 : /* row of the melt made in check_other_spends() */
820 : {
821 1 : struct GNUNET_PQ_QueryParam params[] = {
822 1 : GNUNET_PQ_query_param_auto_from_type (&rc),
823 : GNUNET_PQ_query_param_end
824 : };
825 1 : struct GNUNET_PQ_ResultSpec rs[] = {
826 1 : GNUNET_PQ_result_spec_uint64 ("refresh_id",
827 : &refresh_id),
828 : GNUNET_PQ_result_spec_end
829 : };
830 :
831 1 : FAILIF (GNUNET_OK !=
832 : GNUNET_PQ_prepare_anon (pg->conn,
833 : "SELECT refresh_id"
834 : " FROM refresh"
835 : " WHERE rc=$1;"));
836 1 : FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
837 : GNUNET_PQ_eval_prepared_singleton_select (pg->conn,
838 : "",
839 : params,
840 : rs));
841 : }
842 1 : TDB_coin (pg,
843 : &fresh_denom,
844 : 60,
845 : &fresh_coin,
846 : &fresh_known_coin_id);
847 1 : TDB_FILL (coin_sig,
848 : 60);
849 1 : TDB_FILL (coin_bks,
850 : 60);
851 1 : recoup_timestamp = GNUNET_TIME_timestamp_get ();
852 1 : FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
853 : TALER_EXCHANGEDB_do_recoup_refresh (pg,
854 : &coin.coin_pub,
855 : refresh_id,
856 : 2,
857 : &coin_bks,
858 : &fresh_coin.coin_pub,
859 : fresh_known_coin_id,
860 : &coin_sig,
861 : &recoup_timestamp,
862 : &recoup_amount,
863 : &recoup_ok,
864 : &internal_failure),
865 : TDB_coin_free (&fresh_coin));
866 1 : FAILIF_C (internal_failure || ! recoup_ok,
867 : TDB_coin_free (&fresh_coin));
868 1 : FAILIF_C (0 != TALER_amount_cmp (&recoup_amount,
869 : &credited),
870 : TDB_coin_free (&fresh_coin));
871 :
872 : /* the old coin is credited and sees the receiver entry */
873 1 : FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
874 : TALER_EXCHANGEDB_get_coin_transactions (pg,
875 : true,
876 : &coin.coin_pub,
877 : 0,
878 : 0,
879 : &etag,
880 : &balance,
881 : &h_denom_pub,
882 : &tl),
883 : TDB_coin_free (&fresh_coin));
884 1 : FAILIF_C (7 != summarize (tl,
885 : &types),
886 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
887 : TDB_coin_free (&fresh_coin));
888 1 : for (const struct TALER_EXCHANGEDB_TransactionList *pos = tl;
889 8 : NULL != pos;
890 7 : pos = pos->next)
891 7 : if (TALER_EXCHANGEDB_TT_RECOUP_REFRESH_RECEIVER == pos->type)
892 1 : rr = pos->details.old_coin_recoup;
893 1 : FAILIF_C (NULL == rr,
894 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
895 : TDB_coin_free (&fresh_coin));
896 1 : FAILIF_C (2 != rr->coin_index,
897 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
898 : TDB_coin_free (&fresh_coin));
899 1 : FAILIF_C (0 != GNUNET_memcmp (&rr->rc,
900 : &rc),
901 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
902 : TDB_coin_free (&fresh_coin));
903 1 : FAILIF_C (0 != GNUNET_memcmp (&rr->coin.coin_pub,
904 : &fresh_coin.coin_pub),
905 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
906 : TDB_coin_free (&fresh_coin));
907 1 : FAILIF_C (0 != GNUNET_memcmp (&rr->old_coin_pub,
908 : &coin.coin_pub),
909 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
910 : TDB_coin_free (&fresh_coin));
911 1 : FAILIF_C (0 != TALER_amount_cmp (&rr->value,
912 : &credited),
913 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
914 : TDB_coin_free (&fresh_coin));
915 1 : FAILIF_C (0 != TALER_amount_cmp (&balance,
916 : &credited),
917 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
918 : TDB_coin_free (&fresh_coin));
919 1 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
920 1 : tl = NULL;
921 :
922 : /* the recouped coin is emptied and sees the debit entry */
923 1 : etag = 0;
924 1 : FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
925 : TALER_EXCHANGEDB_get_coin_transactions (pg,
926 : true,
927 : &fresh_coin.coin_pub,
928 : 0,
929 : 0,
930 : &etag,
931 : &balance,
932 : &h_denom_pub,
933 : &tl),
934 : TDB_coin_free (&fresh_coin));
935 1 : FAILIF_C (1 != summarize (tl,
936 : &types),
937 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
938 : TDB_coin_free (&fresh_coin));
939 1 : FAILIF_C (TALER_EXCHANGEDB_TT_RECOUP_REFRESH != tl->type,
940 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
941 : TDB_coin_free (&fresh_coin));
942 1 : rr = tl->details.recoup_refresh;
943 1 : FAILIF_C (2 != rr->coin_index,
944 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
945 : TDB_coin_free (&fresh_coin));
946 1 : FAILIF_C (0 != GNUNET_memcmp (&rr->rc,
947 : &rc),
948 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
949 : TDB_coin_free (&fresh_coin));
950 1 : FAILIF_C (0 != GNUNET_memcmp (&rr->old_coin_pub,
951 : &coin.coin_pub),
952 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
953 : TDB_coin_free (&fresh_coin));
954 1 : FAILIF_C (0 != GNUNET_memcmp (&rr->coin_sig,
955 : &coin_sig),
956 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
957 : TDB_coin_free (&fresh_coin));
958 1 : FAILIF_C (0 != TALER_amount_cmp (&balance,
959 : &zero),
960 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
961 : TDB_coin_free (&fresh_coin));
962 1 : TALER_EXCHANGEDB_free_coin_transaction_list (tl);
963 1 : TDB_coin_free (&fresh_coin);
964 1 : return 0;
965 : }
966 :
967 :
968 : /**
969 : * The checks to run, in order.
970 : */
971 : static const struct TDB_Test tests[] = {
972 : { "coin-history-unknown-coin",
973 : &check_unknown_coin },
974 : { "coin-history-fresh-coin",
975 : &check_fresh_coin },
976 : { "coin-history-deposit-and-refund",
977 : &check_deposit_and_refund },
978 : { "coin-history-etag",
979 : &check_etag },
980 : { "coin-history-offset",
981 : &check_offset },
982 : { "coin-history-other-spends",
983 : &check_other_spends },
984 : { "coin-history-recoup",
985 : &check_recoup },
986 : { "coin-history-in-transaction",
987 : &check_in_transaction },
988 : { "coin-history-recoup-refresh",
989 : &check_recoup_refresh },
990 : { NULL, NULL }
991 : };
992 :
993 :
994 : int
995 1 : main (int argc,
996 : char *const *argv)
997 : {
998 : int ret;
999 :
1000 1 : ret = TDB_main (argc,
1001 : argv,
1002 : "test-coin-history",
1003 : "Tests for the exchangedb `coin_history' table",
1004 : tests);
1005 1 : TDB_coin_free (&coin);
1006 1 : TDB_denom_free (&denom);
1007 1 : TDB_denom_free (&fresh_denom);
1008 1 : TDB_account_free (&account);
1009 1 : return ret;
1010 : }
1011 :
1012 :
1013 : /* end of test_coin_history.c */
|