summaryrefslogtreecommitdiff
path: root/src/mint/mint_db.h
blob: 4f47aac1c271930516a46f57f0180fe6cebd9f68 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
/*
  This file is part of TALER
  (C) 2014 Christian Grothoff (and other contributing authors)

  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, If not, see <http://www.gnu.org/licenses/>
*/

/**
 * @file mint/mint_db.h
 * @brief Mint-specific database access
 * @author Florian Dold
 */

#ifndef _NEURO_MINT_DB_H
#define _NEURO_MINT_DB_H

#include <libpq-fe.h>
#include <gnunet/gnunet_util_lib.h>
#include "taler_util.h"
#include "taler_types.h"
#include "taler_rsa.h"


/**
 * Reserve row.  Corresponds to table 'reserves' in
 * the mint's database.
 */
struct Reserve
{
  /**
   * Signature over the purse.
   * Only valid if (blind_session_missing==GNUNET_YES).
   */
  struct GNUNET_CRYPTO_EddsaSignature status_sig;
  /**
   * Signature with purpose TALER_SIGNATURE_PURSE.
   * Only valid if (blind_session_missing==GNUNET_YES).
   */
  struct GNUNET_CRYPTO_EccSignaturePurpose status_sig_purpose;
  /**
   * Signing key used to sign the purse.
   * Only valid if (blind_session_missing==GNUNET_YES).
   */
  struct GNUNET_CRYPTO_EddsaPublicKey status_sign_pub;
  /**
   * Withdraw public key, identifies the purse.
   * Only the customer knows the corresponding private key.
   */
  struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
  /**
   * Remaining balance in the purse.
   */
  struct TALER_AmountNBO balance;

  /**
   * Expiration date for the purse.
   */
  struct GNUNET_TIME_AbsoluteNBO expiration;
};


struct CollectableBlindcoin
{
  struct TALER_RSA_BlindedSignaturePurpose ev;
  struct TALER_RSA_Signature ev_sig;
  struct TALER_RSA_PublicKeyBinaryEncoded denom_pub;
  struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
  struct GNUNET_CRYPTO_EddsaSignature reserve_sig;
};


struct RefreshSession
{
  int has_commit_sig;
  struct GNUNET_CRYPTO_EddsaSignature commit_sig;
  struct GNUNET_CRYPTO_EddsaPublicKey session_pub;
  uint16_t num_oldcoins;
  uint16_t num_newcoins;
  uint16_t kappa;
  uint16_t noreveal_index;
  uint8_t reveal_ok;
};


#define TALER_REFRESH_SHARED_SECRET_LENGTH (sizeof (struct GNUNET_HashCode))
#define TALER_REFRESH_LINK_LENGTH (sizeof (struct LinkData))

struct RefreshCommitLink
{
  struct GNUNET_CRYPTO_EddsaPublicKey session_pub;
  struct GNUNET_CRYPTO_EcdsaPublicKey transfer_pub;
  uint16_t cnc_index;
  uint16_t oldcoin_index;
  char shared_secret_enc[sizeof (struct GNUNET_HashCode)];
};

struct LinkData
{
  struct GNUNET_CRYPTO_EcdsaPrivateKey coin_priv;
  struct TALER_RSA_BlindingKeyBinaryEncoded bkey_enc;
};


GNUNET_NETWORK_STRUCT_BEGIN

struct SharedSecretEnc
{
  char data[TALER_REFRESH_SHARED_SECRET_LENGTH];
};


struct LinkDataEnc
{
  char data[sizeof (struct LinkData)];
};

GNUNET_NETWORK_STRUCT_END

struct RefreshCommitCoin
{
  struct GNUNET_CRYPTO_EddsaPublicKey session_pub;
  struct TALER_RSA_BlindedSignaturePurpose coin_ev;
  uint16_t cnc_index;
  uint16_t newcoin_index;
  char link_enc[sizeof (struct LinkData)];
};


struct KnownCoin
{
  struct TALER_CoinPublicInfo public_info;
  struct TALER_Amount expended_balance;
  int is_refreshed;
  /**
   * Refreshing session, only valid if
   * is_refreshed==1.
   */
  struct GNUNET_CRYPTO_EddsaPublicKey refresh_session_pub;
};

GNUNET_NETWORK_STRUCT_BEGIN

struct Deposit
{
  /* FIXME: should be TALER_CoinPublicInfo */
  struct GNUNET_CRYPTO_EddsaPublicKey coin_pub;
  struct TALER_RSA_PublicKeyBinaryEncoded denom_pub;
  struct TALER_RSA_Signature coin_sig;
  struct TALER_RSA_SignaturePurpose purpose;
  uint64_t transaction_id;
  struct TALER_AmountNBO amount;
  struct GNUNET_CRYPTO_EddsaPublicKey merchant_pub;
  struct GNUNET_HashCode h_contract;
  struct GNUNET_HashCode h_wire;
  /* TODO: uint16_t wire_size */
  char wire[];                  /* string encoded wire JSON object */
};

GNUNET_NETWORK_STRUCT_END

int
TALER_MINT_DB_prepare (PGconn *db_conn);

int
TALER_MINT_DB_get_collectable_blindcoin (PGconn *db_conn,
                                         struct TALER_RSA_BlindedSignaturePurpose *blind_ev,
                                         struct CollectableBlindcoin *collectable);

int
TALER_MINT_DB_insert_collectable_blindcoin (PGconn *db_conn,
                                            const struct CollectableBlindcoin *collectable);


int
TALER_MINT_DB_rollback (PGconn *db_conn);


int
TALER_MINT_DB_transaction (PGconn *db_conn);


int
TALER_MINT_DB_commit (PGconn *db_conn);


int
TALER_MINT_DB_get_reserve (PGconn *db_conn,
                           const struct GNUNET_CRYPTO_EddsaPublicKey *reserve_pub,
                           struct Reserve *reserve_res);

int
TALER_MINT_DB_update_reserve (PGconn *db_conn,
                              const struct Reserve *reserve,
                              int fresh);


int
TALER_MINT_DB_insert_refresh_order (PGconn *db_conn,
                                    uint16_t newcoin_index,
                                    const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
                                    const struct TALER_RSA_PublicKeyBinaryEncoded *denom_pub);

int
TALER_MINT_DB_get_refresh_session (PGconn *db_conn,
                                   const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
                                   struct RefreshSession *r_session);


int
TALER_MINT_DB_get_known_coin (PGconn *db_conn, struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
                              struct KnownCoin *known_coin);


int
TALER_MINT_DB_upsert_known_coin (PGconn *db_conn, struct KnownCoin *known_coin);


int
TALER_MINT_DB_insert_refresh_commit_link (PGconn *db_conn, struct RefreshCommitLink *commit_link);

int
TALER_MINT_DB_insert_refresh_commit_coin (PGconn *db_conn, struct RefreshCommitCoin *commit_coin);


int
TALER_MINT_DB_get_refresh_commit_link (PGconn *db_conn,
                                       const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
                                       int i, int j,
                                       struct RefreshCommitLink *commit_link);


int
TALER_MINT_DB_get_refresh_commit_coin (PGconn *db_conn,
                                       const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
                                       int i, int j,
                                       struct RefreshCommitCoin *commit_coin);


int
TALER_MINT_DB_create_refresh_session (PGconn *db_conn,
                                      const struct GNUNET_CRYPTO_EddsaPublicKey
                                      *session_pub);


int
TALER_MINT_DB_get_refresh_order (PGconn *db_conn,
                                 uint16_t newcoin_index,
                                 const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
                                 struct TALER_RSA_PublicKeyBinaryEncoded *denom_pub);


int
TALER_MINT_DB_insert_refresh_collectable (PGconn *db_conn,
                                          uint16_t newcoin_index,
                                          const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
                                          const struct TALER_RSA_Signature *ev_sig);
int
TALER_MINT_DB_get_refresh_collectable (PGconn *db_conn,
                                       uint16_t newcoin_index,
                                       const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
                                       struct TALER_RSA_Signature *ev_sig);
int
TALER_MINT_DB_set_reveal_ok (PGconn *db_conn,
                             const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub);

int
TALER_MINT_DB_insert_refresh_melt (PGconn *db_conn,
                                    const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
                                    uint16_t oldcoin_index,
                                    const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
                                    const struct TALER_RSA_PublicKeyBinaryEncoded *denom_pub);


int
TALER_MINT_DB_get_refresh_melt (PGconn *db_conn,
                                const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
                                uint16_t oldcoin_index,
                                struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub);


typedef
int (*LinkIterator) (void *cls,
                     const struct LinkDataEnc *link_data_enc,
                     const struct TALER_RSA_PublicKeyBinaryEncoded *denom_pub,
                     const struct TALER_RSA_Signature *ev_sig);

int
TALER_db_get_link (PGconn *db_conn,
                   const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
                   LinkIterator link_iter,
                   void *cls);


int
TALER_db_get_transfer (PGconn *db_conn,
                       const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
                       struct GNUNET_CRYPTO_EcdsaPublicKey *transfer_pub,
                       struct SharedSecretEnc *shared_secret_enc);

int
TALER_MINT_DB_init_deposits (PGconn *db_conn, int temporary);

int
TALER_MINT_DB_prepare_deposits (PGconn *db_conn);

int
TALER_MINT_DB_insert_deposit (PGconn *db_conn,
                              const struct Deposit *deposit);

int
TALER_MINT_DB_get_deposit (PGconn *db_conn,
                           const struct GNUNET_CRYPTO_EddsaPublicKey *coin_pub,
                           struct Deposit **r_deposit);
int
TALER_MINT_DB_insert_known_coin (PGconn *db_conn,
                                 const struct KnownCoin *known_coin);



/**
 * Get the thread-local database-handle.
 * Connect to the db if the connection does not exist yet.
 *
 * @param the database connection, or NULL on error
 */
PGconn *
TALER_MINT_DB_get_connection (void);


int
TALER_MINT_DB_init (const char *connection_cfg);



#endif /* _NEURO_MINT_DB_H */