2015-03-20 23:51:28 +01:00
|
|
|
/*
|
|
|
|
This file is part of TALER
|
2017-03-05 17:36:58 +01:00
|
|
|
Copyright (C) 2014-2017 GNUnet e.V.
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
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
|
2016-07-07 17:55:25 +02:00
|
|
|
TALER; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* @file include/taler_exchangedb_plugin.h
|
|
|
|
* @brief Low-level (statement-level) database access for the exchange
|
2015-03-20 23:51:28 +01:00
|
|
|
* @author Florian Dold
|
|
|
|
* @author Christian Grothoff
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
#ifndef TALER_EXCHANGEDB_PLUGIN_H
|
|
|
|
#define TALER_EXCHANGEDB_PLUGIN_H
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2016-03-19 15:23:11 +01:00
|
|
|
#include <jansson.h>
|
2015-03-20 23:51:28 +01:00
|
|
|
#include <gnunet/gnunet_util_lib.h>
|
2017-06-11 01:59:09 +02:00
|
|
|
#include <gnunet/gnunet_db_lib.h>
|
2016-03-01 15:35:04 +01:00
|
|
|
#include "taler_exchangedb_lib.h"
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2017-04-18 21:05:27 +02:00
|
|
|
* @brief Information we keep on bank transfer(s) that established a reserve.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_BankTransfer
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
2017-04-18 21:05:27 +02:00
|
|
|
* Public key of the reserve that was filled.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2015-03-27 19:58:40 +01:00
|
|
|
struct TALER_ReservePublicKeyP reserve_pub;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* Amount that was transferred to the exchange.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
|
|
|
struct TALER_Amount amount;
|
|
|
|
|
2015-06-11 13:38:47 +02:00
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* When did the exchange receive the incoming transaction?
|
|
|
|
* (This is the execution date of the exchange's database,
|
2015-06-11 13:38:47 +02:00
|
|
|
* the execution date of the bank should be in @e wire).
|
|
|
|
*/
|
|
|
|
struct GNUNET_TIME_Absolute execution_date;
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
2017-04-18 21:05:27 +02:00
|
|
|
* Detailed wire information about the sending account.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-05-26 16:38:59 +02:00
|
|
|
json_t *sender_account_details;
|
|
|
|
|
2017-05-05 13:41:32 +02:00
|
|
|
/**
|
|
|
|
* Data uniquely identifying the wire transfer (wire transfer-type specific)
|
|
|
|
*/
|
|
|
|
void *wire_reference;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Number of bytes in @e wire_reference.
|
|
|
|
*/
|
|
|
|
size_t wire_reference_size;
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2017-04-18 21:05:27 +02:00
|
|
|
/**
|
2017-05-05 13:41:32 +02:00
|
|
|
* @brief Information we keep on bank transfer(s) that
|
2017-04-18 21:05:27 +02:00
|
|
|
* closed a reserve.
|
|
|
|
*/
|
|
|
|
struct TALER_EXCHANGEDB_ClosingTransfer
|
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Public key of the reserve that was depleted.
|
|
|
|
*/
|
|
|
|
struct TALER_ReservePublicKeyP reserve_pub;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Amount that was transferred to the exchange.
|
|
|
|
*/
|
|
|
|
struct TALER_Amount amount;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Amount that was charged by the exchange.
|
|
|
|
*/
|
|
|
|
struct TALER_Amount closing_fee;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* When did the exchange execute the transaction?
|
|
|
|
*/
|
|
|
|
struct GNUNET_TIME_Absolute execution_date;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Detailed wire information about the receiving account.
|
|
|
|
*/
|
|
|
|
json_t *receiver_account_details;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Detailed wire transfer information that uniquely identifies the
|
|
|
|
* wire transfer.
|
|
|
|
*/
|
2017-05-08 12:44:40 +02:00
|
|
|
struct TALER_WireTransferIdentifierRawP wtid;
|
2017-05-05 13:41:32 +02:00
|
|
|
|
2017-04-18 21:05:27 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
2015-03-28 15:53:53 +01:00
|
|
|
* @brief A summary of a Reserve
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Reserve
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
/**
|
|
|
|
* The reserve's public key. This uniquely identifies the reserve
|
|
|
|
*/
|
2015-03-27 19:58:40 +01:00
|
|
|
struct TALER_ReservePublicKeyP pub;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The balance amount existing in the reserve
|
|
|
|
*/
|
|
|
|
struct TALER_Amount balance;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The expiration date of this reserve
|
|
|
|
*/
|
|
|
|
struct GNUNET_TIME_Absolute expiry;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-03-28 15:53:53 +01:00
|
|
|
* @brief Information we keep for a withdrawn coin to reproduce
|
2015-03-20 23:51:28 +01:00
|
|
|
* the /withdraw operation if needed, and to have proof
|
|
|
|
* that a reserve was drained by this amount.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_CollectableBlindcoin
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Our signature over the (blinded) coin.
|
|
|
|
*/
|
2015-03-22 22:14:30 +01:00
|
|
|
struct TALER_DenominationSignature sig;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Denomination key (which coin was generated).
|
|
|
|
*/
|
2015-03-22 22:14:30 +01:00
|
|
|
struct TALER_DenominationPublicKey denom_pub;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2015-03-28 16:51:54 +01:00
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* Value of the coin being exchangeed (matching the denomination key)
|
2015-03-28 16:51:54 +01:00
|
|
|
* plus the transaction fee. We include this in what is being
|
|
|
|
* signed so that we can verify a reserve's remaining total balance
|
|
|
|
* without needing to access the respective denomination key
|
|
|
|
* information each time.
|
|
|
|
*/
|
|
|
|
struct TALER_Amount amount_with_fee;
|
|
|
|
|
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* Withdrawl fee charged by the exchange. This must match the Exchange's
|
2015-03-28 16:51:54 +01:00
|
|
|
* denomination key's withdrawl fee. If the client puts in an
|
|
|
|
* invalid withdrawl fee (too high or too low) that does not match
|
2016-03-01 15:35:04 +01:00
|
|
|
* the Exchange's denomination key, the withdraw operation is invalid
|
|
|
|
* and will be rejected by the exchange. The @e amount_with_fee minus
|
2015-03-28 16:51:54 +01:00
|
|
|
* the @e withdraw_fee is must match the value of the generated
|
|
|
|
* coin. We include this in what is being signed so that we can
|
2016-03-01 15:35:04 +01:00
|
|
|
* verify a exchange's accounting without needing to access the
|
2015-03-28 16:51:54 +01:00
|
|
|
* respective denomination key information each time.
|
|
|
|
*/
|
|
|
|
struct TALER_Amount withdraw_fee;
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
|
|
|
* Public key of the reserve that was drained.
|
|
|
|
*/
|
2015-03-27 19:58:40 +01:00
|
|
|
struct TALER_ReservePublicKeyP reserve_pub;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Hash over the blinded message, needed to verify
|
|
|
|
* the @e reserve_sig.
|
|
|
|
*/
|
|
|
|
struct GNUNET_HashCode h_coin_envelope;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Signature confirming the withdrawl, matching @e reserve_pub,
|
|
|
|
* @e denom_pub and @e h_coin_envelope.
|
|
|
|
*/
|
2015-03-27 19:58:40 +01:00
|
|
|
struct TALER_ReserveSignatureP reserve_sig;
|
2015-03-20 23:51:28 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2017-04-01 23:43:55 +02:00
|
|
|
/**
|
|
|
|
* Information the exchange records about a /payback request.
|
|
|
|
*/
|
|
|
|
struct TALER_EXCHANGEDB_Payback
|
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
2017-04-04 16:27:27 +02:00
|
|
|
* Information about the coin that was paid back.
|
2017-04-01 23:43:55 +02:00
|
|
|
*/
|
2017-04-04 16:27:27 +02:00
|
|
|
struct TALER_CoinPublicInfo coin;
|
2017-04-01 23:43:55 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Blinding factor supplied to prove to the exchange that
|
|
|
|
* the coin came from this reserve.
|
|
|
|
*/
|
|
|
|
struct TALER_DenominationBlindingKeyP coin_blind;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Signature of the coin of type
|
|
|
|
* #TALER_SIGNATURE_WALLET_COIN_PAYBACK.
|
|
|
|
*/
|
|
|
|
struct TALER_CoinSpendSignatureP coin_sig;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Public key of the reserve the coin was paid back into.
|
|
|
|
*/
|
|
|
|
struct TALER_ReservePublicKeyP reserve_pub;
|
|
|
|
|
2017-04-02 18:02:07 +02:00
|
|
|
/**
|
|
|
|
* How much was the coin still worth at this time?
|
|
|
|
*/
|
|
|
|
struct TALER_Amount value;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* When did the /payback operation happen?
|
|
|
|
*/
|
|
|
|
struct GNUNET_TIME_Absolute timestamp;
|
|
|
|
|
2017-04-01 23:43:55 +02:00
|
|
|
};
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
2017-04-01 23:43:55 +02:00
|
|
|
* @brief Types of operations on a reserve.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
enum TALER_EXCHANGEDB_ReserveOperation
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
/**
|
|
|
|
* Money was deposited into the reserve via a bank transfer.
|
2017-04-01 23:43:55 +02:00
|
|
|
* This is how customers establish a reserve at the exchange.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
TALER_EXCHANGEDB_RO_BANK_TO_EXCHANGE = 0,
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* A Coin was withdrawn from the reserve using /withdraw.
|
|
|
|
*/
|
2017-04-01 23:43:55 +02:00
|
|
|
TALER_EXCHANGEDB_RO_WITHDRAW_COIN = 1,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A coin was returned to the reserve using /payback.
|
|
|
|
*/
|
|
|
|
TALER_EXCHANGEDB_RO_PAYBACK_COIN = 2,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The exchange send inactive funds back from the reserve to the
|
|
|
|
* customer's bank account. This happens when the exchange
|
|
|
|
* closes a reserve with a non-zero amount left in it.
|
|
|
|
*/
|
|
|
|
TALER_EXCHANGEDB_RO_EXCHANGE_TO_BANK = 3
|
2015-03-20 23:51:28 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-03-28 15:53:53 +01:00
|
|
|
* @brief Reserve history as a linked list. Lists all of the transactions
|
2015-03-20 23:51:28 +01:00
|
|
|
* associated with this reserve (such as the bank transfers that
|
|
|
|
* established the reserve and all /withdraw operations we have done
|
|
|
|
* since).
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_ReserveHistory
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Next entry in the reserve history.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_ReserveHistory *next;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Type of the event, determins @e details.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
enum TALER_EXCHANGEDB_ReserveOperation type;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Details of the operation, depending on @e type.
|
|
|
|
*/
|
|
|
|
union
|
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
2017-04-01 23:43:55 +02:00
|
|
|
* Details about a bank transfer to the exchange (reserve
|
2017-04-18 21:05:27 +02:00
|
|
|
* was established).
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_BankTransfer *bank;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Details about a /withdraw operation.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_CollectableBlindcoin *withdraw;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2017-04-01 23:43:55 +02:00
|
|
|
/**
|
|
|
|
* Details about a /payback operation.
|
|
|
|
*/
|
|
|
|
struct TALER_EXCHANGEDB_Payback *payback;
|
|
|
|
|
2017-04-18 21:05:27 +02:00
|
|
|
/**
|
|
|
|
* Details about a bank transfer from the exchange (reserve
|
|
|
|
* was closed).
|
|
|
|
*/
|
|
|
|
struct TALER_EXCHANGEDB_ClosingTransfer *closing;
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
} details;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-06-05 15:26:41 +02:00
|
|
|
* @brief Specification for a /deposit operation. The combination of
|
|
|
|
* the coin's public key, the merchant's public key and the
|
|
|
|
* transaction ID must be unique. While a coin can (theoretically) be
|
|
|
|
* deposited at the same merchant twice (with partial spending), the
|
|
|
|
* merchant must either use a different public key or a different
|
|
|
|
* transaction ID for the two transactions. The same coin must not
|
|
|
|
* be used twice at the same merchant for the same transaction
|
2016-05-02 05:17:42 +02:00
|
|
|
* (as determined by transaction ID).
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Deposit
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
/**
|
|
|
|
* Information about the coin that is being deposited.
|
|
|
|
*/
|
|
|
|
struct TALER_CoinPublicInfo coin;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ECDSA signature affirming that the customer intends
|
|
|
|
* this coin to be deposited at the merchant identified
|
2017-02-06 15:41:39 +01:00
|
|
|
* by @e h_wire in relation to the proposal data identified
|
2017-05-29 01:15:41 +02:00
|
|
|
* by @e h_contract_terms.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2015-03-28 14:22:21 +01:00
|
|
|
struct TALER_CoinSpendSignatureP csig;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Public key of the merchant. Enables later identification
|
|
|
|
* of the merchant in case of a need to rollback transactions.
|
|
|
|
*/
|
2015-03-27 19:58:40 +01:00
|
|
|
struct TALER_MerchantPublicKeyP merchant_pub;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
2017-02-06 15:41:39 +01:00
|
|
|
* Hash over the proposa data between merchant and customer
|
2016-03-01 15:35:04 +01:00
|
|
|
* (remains unknown to the Exchange).
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2017-05-29 01:15:41 +02:00
|
|
|
struct GNUNET_HashCode h_contract_terms;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Hash of the (canonical) representation of @e wire, used
|
|
|
|
* to check the signature on the request. Generated by
|
2016-03-01 15:35:04 +01:00
|
|
|
* the exchange from the detailed wire data provided by the
|
2015-03-20 23:51:28 +01:00
|
|
|
* merchant.
|
|
|
|
*/
|
|
|
|
struct GNUNET_HashCode h_wire;
|
|
|
|
|
|
|
|
/**
|
2016-05-26 16:38:59 +02:00
|
|
|
* Detailed information about the receiver for executing the transaction.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-05-26 16:38:59 +02:00
|
|
|
json_t *receiver_wire_account;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2015-03-28 17:10:39 +01:00
|
|
|
/**
|
|
|
|
* Time when this request was generated. Used, for example, to
|
|
|
|
* assess when (roughly) the income was achieved for tax purposes.
|
2016-03-01 15:35:04 +01:00
|
|
|
* Note that the Exchange will only check that the timestamp is not "too
|
2015-03-28 17:10:39 +01:00
|
|
|
* far" into the future (i.e. several days). The fact that the
|
|
|
|
* timestamp falls within the validity period of the coin's
|
|
|
|
* denomination key is irrelevant for the validity of the deposit
|
|
|
|
* request, as obviously the customer and merchant could conspire to
|
2016-03-01 15:35:04 +01:00
|
|
|
* set any timestamp. Also, the Exchange must accept very old deposit
|
2015-03-28 17:10:39 +01:00
|
|
|
* requests, as the merchant might have been unable to transmit the
|
|
|
|
* deposit request in a timely fashion (so back-dating is not
|
|
|
|
* prevented).
|
|
|
|
*/
|
|
|
|
struct GNUNET_TIME_Absolute timestamp;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* How much time does the merchant have to issue a refund request?
|
|
|
|
* Zero if refunds are not allowed. After this time, the coin
|
|
|
|
* cannot be refunded.
|
|
|
|
*/
|
|
|
|
struct GNUNET_TIME_Absolute refund_deadline;
|
|
|
|
|
2015-10-28 21:06:23 +01:00
|
|
|
/**
|
|
|
|
* How much time does the merchant have to execute the wire transfer?
|
|
|
|
* This time is advisory for aggregating transactions, not a hard
|
|
|
|
* constraint (as the merchant can theoretically pick any time,
|
|
|
|
* including one in the past).
|
|
|
|
*/
|
|
|
|
struct GNUNET_TIME_Absolute wire_deadline;
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
2015-03-22 16:09:01 +01:00
|
|
|
* Fraction of the coin's remaining value to be deposited, including
|
|
|
|
* depositing fee (if any). The coin is identified by @e coin_pub.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2015-03-22 16:09:01 +01:00
|
|
|
struct TALER_Amount amount_with_fee;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2015-03-28 14:39:31 +01:00
|
|
|
/**
|
|
|
|
* Depositing fee.
|
|
|
|
*/
|
|
|
|
struct TALER_Amount deposit_fee;
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2016-04-20 02:50:52 +02:00
|
|
|
/**
|
|
|
|
* @brief Specification for a /refund operation. The combination of
|
|
|
|
* the coin's public key, the merchant's public key and the
|
|
|
|
* transaction ID must be unique. While a coin can (theoretically) be
|
|
|
|
* deposited at the same merchant twice (with partial spending), the
|
|
|
|
* merchant must either use a different public key or a different
|
|
|
|
* transaction ID for the two transactions. The same goes for
|
|
|
|
* refunds, hence we also have a "rtransaction" ID which is disjoint
|
|
|
|
* from the transaction ID. The same coin must not be used twice at
|
|
|
|
* the same merchant for the same transaction or rtransaction ID.
|
|
|
|
*/
|
|
|
|
struct TALER_EXCHANGEDB_Refund
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* Information about the coin that is being refunded.
|
|
|
|
*/
|
|
|
|
struct TALER_CoinPublicInfo coin;
|
|
|
|
|
|
|
|
/**
|
2016-05-02 05:17:42 +02:00
|
|
|
* Public key of the merchant.
|
2016-04-20 02:50:52 +02:00
|
|
|
*/
|
|
|
|
struct TALER_MerchantPublicKeyP merchant_pub;
|
2016-05-02 05:17:42 +02:00
|
|
|
|
2016-04-20 02:50:52 +02:00
|
|
|
/**
|
2016-05-02 05:17:42 +02:00
|
|
|
* Signature from the merchant affirming the refund.
|
2016-04-20 02:50:52 +02:00
|
|
|
*/
|
|
|
|
struct TALER_MerchantSignatureP merchant_sig;
|
|
|
|
|
|
|
|
/**
|
2017-02-06 15:41:39 +01:00
|
|
|
* Hash over the proposal data between merchant and customer
|
2016-04-20 02:50:52 +02:00
|
|
|
* (remains unknown to the Exchange).
|
|
|
|
*/
|
2017-05-29 01:15:41 +02:00
|
|
|
struct GNUNET_HashCode h_contract_terms;
|
2016-04-20 02:50:52 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Merchant-generated REFUND transaction ID to detect duplicate
|
|
|
|
* refunds.
|
|
|
|
*/
|
|
|
|
uint64_t rtransaction_id;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Fraction of the original deposit's value to be refunded, including
|
|
|
|
* refund fee (if any). The coin is identified by @e coin_pub.
|
|
|
|
*/
|
|
|
|
struct TALER_Amount refund_amount;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Refund fee to be covered by the customer.
|
|
|
|
*/
|
|
|
|
struct TALER_Amount refund_fee;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
2015-03-28 15:53:53 +01:00
|
|
|
* @brief Specification for coin in a /refresh/melt operation.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_RefreshMelt
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
/**
|
|
|
|
* Information about the coin that is being melted.
|
|
|
|
*/
|
|
|
|
struct TALER_CoinPublicInfo coin;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Signature over the melting operation.
|
|
|
|
*/
|
2015-03-28 14:22:21 +01:00
|
|
|
struct TALER_CoinSpendSignatureP coin_sig;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
2015-03-24 16:56:06 +01:00
|
|
|
* Hash of the refresh session this coin is melted into.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2015-03-24 16:56:06 +01:00
|
|
|
struct GNUNET_HashCode session_hash;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
2015-03-22 16:09:01 +01:00
|
|
|
* How much value is being melted? This amount includes the fees,
|
|
|
|
* so the final amount contributed to the melt is this value minus
|
|
|
|
* the fee for melting the coin. We include the fee in what is
|
|
|
|
* being signed so that we can verify a reserve's remaining total
|
|
|
|
* balance without needing to access the respective denomination key
|
|
|
|
* information each time.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2015-03-22 16:09:01 +01:00
|
|
|
struct TALER_Amount amount_with_fee;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2015-06-11 13:52:45 +02:00
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* Melting fee charged by the exchange. This must match the Exchange's
|
2015-03-28 17:27:08 +01:00
|
|
|
* denomination key's melting fee. If the client puts in an invalid
|
2016-03-01 15:35:04 +01:00
|
|
|
* melting fee (too high or too low) that does not match the Exchange's
|
2015-03-28 17:27:08 +01:00
|
|
|
* denomination key, the melting operation is invalid and will be
|
2016-03-01 15:35:04 +01:00
|
|
|
* rejected by the exchange. The @e amount_with_fee minus the @e
|
2015-03-28 17:27:08 +01:00
|
|
|
* melt_fee is the amount that will be credited to the melting
|
|
|
|
* session.
|
|
|
|
*/
|
|
|
|
struct TALER_Amount melt_fee;
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2016-05-16 11:55:47 +02:00
|
|
|
/**
|
|
|
|
* @brief Global information for a refreshing session. Includes
|
|
|
|
* dimensions of the operation, security parameters and
|
|
|
|
* client signatures from "/refresh/melt" and "/refresh/commit".
|
|
|
|
*/
|
|
|
|
struct TALER_EXCHANGEDB_RefreshSession
|
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Melt operation details.
|
|
|
|
*/
|
|
|
|
struct TALER_EXCHANGEDB_RefreshMelt melt;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Number of new coins we are creating.
|
|
|
|
*/
|
|
|
|
uint16_t num_newcoins;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Index (smaller #TALER_CNC_KAPPA) which the exchange has chosen to not
|
|
|
|
* have revealed during cut and choose.
|
|
|
|
*/
|
|
|
|
uint16_t noreveal_index;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* @brief We have as many `struct TALER_EXCHANGEDB_RefreshCommitCoin` as there are new
|
2015-03-27 19:58:40 +01:00
|
|
|
* coins being created by the refresh (for each of the #TALER_CNC_KAPPA
|
2016-03-01 15:35:04 +01:00
|
|
|
* sets). These are the coins we ask the exchange to sign if the
|
2015-03-20 23:51:28 +01:00
|
|
|
* respective set is selected.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_RefreshCommitCoin
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Blinded message to be signed (in envelope), with @e coin_env_size bytes.
|
|
|
|
*/
|
|
|
|
char *coin_ev;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Number of bytes in @e coin_ev.
|
|
|
|
*/
|
|
|
|
size_t coin_ev_size;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-03-28 15:53:53 +01:00
|
|
|
* @brief Linked list of refresh information linked to a coin.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_LinkDataList
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
/**
|
|
|
|
* Information is stored in a NULL-terminated linked list.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_LinkDataList *next;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Denomination public key, determines the value of the coin.
|
|
|
|
*/
|
2015-03-22 22:14:30 +01:00
|
|
|
struct TALER_DenominationPublicKey denom_pub;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Signature over the blinded envelope.
|
|
|
|
*/
|
2015-03-22 22:14:30 +01:00
|
|
|
struct TALER_DenominationSignature ev_sig;
|
2015-03-20 23:51:28 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-03-28 15:53:53 +01:00
|
|
|
* @brief Enumeration to classify the different types of transactions
|
2015-03-20 23:51:28 +01:00
|
|
|
* that can be done with a coin.
|
|
|
|
*/
|
2017-04-03 22:45:48 +02:00
|
|
|
enum TALER_EXCHANGEDB_TransactionType {
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
|
|
|
* /deposit operation.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
TALER_EXCHANGEDB_TT_DEPOSIT = 0,
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* /refresh/melt operation.
|
|
|
|
*/
|
2016-05-05 22:57:55 +02:00
|
|
|
TALER_EXCHANGEDB_TT_REFRESH_MELT = 1,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* /refund operation.
|
|
|
|
*/
|
2017-04-01 23:43:55 +02:00
|
|
|
TALER_EXCHANGEDB_TT_REFUND = 2,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* /payback operation.
|
|
|
|
*/
|
|
|
|
TALER_EXCHANGEDB_TT_PAYBACK = 3
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-03-28 15:53:53 +01:00
|
|
|
* @brief List of transactions we performed for a particular coin.
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_TransactionList
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Next pointer in the NULL-terminated linked list.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_TransactionList *next;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Type of the transaction, determines what is stored in @e details.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
enum TALER_EXCHANGEDB_TransactionType type;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Details about the transaction, depending on @e type.
|
|
|
|
*/
|
|
|
|
union
|
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Details if transaction was a /deposit operation.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Deposit *deposit;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Details if transaction was a /refresh/melt operation.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_RefreshMelt *melt;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2016-05-05 22:57:55 +02:00
|
|
|
/**
|
|
|
|
* Details if transaction was a /refund operation.
|
|
|
|
*/
|
|
|
|
struct TALER_EXCHANGEDB_Refund *refund;
|
|
|
|
|
2017-04-01 23:43:55 +02:00
|
|
|
/**
|
|
|
|
* Details if transaction was a /payback operation.
|
|
|
|
*/
|
|
|
|
struct TALER_EXCHANGEDB_Payback *payback;
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
} details;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-03-28 15:53:53 +01:00
|
|
|
* @brief Handle for a database session (per-thread, for transactions).
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session;
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
2015-09-19 20:02:21 +02:00
|
|
|
/**
|
2016-10-09 00:57:31 +02:00
|
|
|
* Function called with details about deposits that have been made,
|
|
|
|
* with the goal of executing the corresponding wire transaction.
|
2015-09-19 20:02:21 +02:00
|
|
|
*
|
|
|
|
* @param cls closure
|
2016-01-27 16:42:24 +01:00
|
|
|
* @param rowid unique ID for the deposit in our DB, used for marking
|
|
|
|
* it as 'tiny' or 'done'
|
|
|
|
* @param merchant_pub public key of the merchant
|
|
|
|
* @param coin_pub public key of the coin
|
2015-09-19 20:02:21 +02:00
|
|
|
* @param amount_with_fee amount that was deposited including fee
|
2016-03-01 15:35:04 +01:00
|
|
|
* @param deposit_fee amount the exchange gets to keep as transaction fees
|
2017-05-29 01:15:41 +02:00
|
|
|
* @param h_contract_terms hash of the proposal data known to merchant and customer
|
2015-10-28 21:06:23 +01:00
|
|
|
* @param wire_deadline by which the merchant adviced that he would like the
|
|
|
|
* wire transfer to be executed
|
2016-05-26 16:38:59 +02:00
|
|
|
* @param receiver_wire_account wire details for the merchant, NULL from iterate_matching_deposits()
|
2015-09-19 20:02:21 +02:00
|
|
|
* @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
|
|
|
|
*/
|
|
|
|
typedef int
|
2016-03-01 15:35:04 +01:00
|
|
|
(*TALER_EXCHANGEDB_DepositIterator)(void *cls,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid,
|
2016-03-30 22:56:17 +02:00
|
|
|
const struct TALER_MerchantPublicKeyP *merchant_pub,
|
|
|
|
const struct TALER_CoinSpendPublicKeyP *coin_pub,
|
|
|
|
const struct TALER_Amount *amount_with_fee,
|
|
|
|
const struct TALER_Amount *deposit_fee,
|
2017-05-29 01:15:41 +02:00
|
|
|
const struct GNUNET_HashCode *h_contract_terms,
|
2016-03-30 22:56:17 +02:00
|
|
|
struct GNUNET_TIME_Absolute wire_deadline,
|
2016-05-26 16:38:59 +02:00
|
|
|
const json_t *receiver_wire_account);
|
2015-09-19 20:02:21 +02:00
|
|
|
|
|
|
|
|
2016-10-09 00:57:31 +02:00
|
|
|
/**
|
|
|
|
* Callback with data about a prepared wire transfer.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid row identifier used to mark prepared transaction as done
|
|
|
|
* @param wire_method which wire method is this preparation data for
|
|
|
|
* @param buf transaction data that was persisted, NULL on error
|
|
|
|
* @param buf_size number of bytes in @a buf, 0 on error
|
|
|
|
*/
|
|
|
|
typedef void
|
|
|
|
(*TALER_EXCHANGEDB_WirePreparationIterator) (void *cls,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid,
|
2016-10-09 00:57:31 +02:00
|
|
|
const char *wire_method,
|
|
|
|
const char *buf,
|
|
|
|
size_t buf_size);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called with details about deposits that have been made,
|
|
|
|
* with the goal of auditing the deposit's execution.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid unique serial ID for the deposit in our DB
|
2017-03-17 14:09:58 +01:00
|
|
|
* @param timestamp when did the deposit happen
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param merchant_pub public key of the merchant
|
2017-03-19 01:55:37 +01:00
|
|
|
* @param denom_pub denomination public key of @a coin_pub
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param coin_pub public key of the coin
|
|
|
|
* @param coin_sig signature from the coin
|
|
|
|
* @param amount_with_fee amount that was deposited including fee
|
2017-05-29 01:15:41 +02:00
|
|
|
* @param h_contract_terms hash of the proposal data known to merchant and customer
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param refund_deadline by which the merchant adviced that he might want
|
|
|
|
* to get a refund
|
|
|
|
* @param wire_deadline by which the merchant adviced that he would like the
|
|
|
|
* wire transfer to be executed
|
|
|
|
* @param receiver_wire_account wire details for the merchant, NULL from iterate_matching_deposits()
|
|
|
|
* @param done flag set if the deposit was already executed (or not)
|
|
|
|
* @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
|
|
|
|
*/
|
|
|
|
typedef int
|
|
|
|
(*TALER_EXCHANGEDB_DepositCallback)(void *cls,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid,
|
2017-03-17 14:09:58 +01:00
|
|
|
struct GNUNET_TIME_Absolute timestamp,
|
2016-10-09 00:57:31 +02:00
|
|
|
const struct TALER_MerchantPublicKeyP *merchant_pub,
|
2017-03-19 01:55:37 +01:00
|
|
|
const struct TALER_DenominationPublicKey *denom_pub,
|
2016-10-09 00:57:31 +02:00
|
|
|
const struct TALER_CoinSpendPublicKeyP *coin_pub,
|
|
|
|
const struct TALER_CoinSpendSignatureP *coin_sig,
|
|
|
|
const struct TALER_Amount *amount_with_fee,
|
2017-05-29 01:15:41 +02:00
|
|
|
const struct GNUNET_HashCode *h_contract_terms,
|
2016-10-09 00:57:31 +02:00
|
|
|
struct GNUNET_TIME_Absolute refund_deadline,
|
|
|
|
struct GNUNET_TIME_Absolute wire_deadline,
|
|
|
|
const json_t *receiver_wire_account,
|
|
|
|
int done);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called with details about coins that were melted,
|
|
|
|
* with the goal of auditing the refresh's execution.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid unique serial ID for the refresh session in our DB
|
2017-03-19 01:55:37 +01:00
|
|
|
* @param denom_pub denomination public key of @a coin_pub
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param coin_pub public key of the coin
|
|
|
|
* @param coin_sig signature from the coin
|
|
|
|
* @param amount_with_fee amount that was deposited including fee
|
2017-03-15 19:28:05 +01:00
|
|
|
* @param num_newcoins how many coins were issued
|
|
|
|
* @param noreveal_index which index was picked by the exchange in cut-and-choose
|
|
|
|
* @param session_hash what is the session hash
|
2016-10-09 00:57:31 +02:00
|
|
|
* @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
|
|
|
|
*/
|
|
|
|
typedef int
|
|
|
|
(*TALER_EXCHANGEDB_RefreshSessionCallback)(void *cls,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid,
|
2017-03-19 01:55:37 +01:00
|
|
|
const struct TALER_DenominationPublicKey *denom_pub,
|
2016-10-09 00:57:31 +02:00
|
|
|
const struct TALER_CoinSpendPublicKeyP *coin_pub,
|
|
|
|
const struct TALER_CoinSpendSignatureP *coin_sig,
|
|
|
|
const struct TALER_Amount *amount_with_fee,
|
|
|
|
uint16_t num_newcoins,
|
2017-03-15 19:28:05 +01:00
|
|
|
uint16_t noreveal_index,
|
|
|
|
const struct GNUNET_HashCode *session_hash);
|
2016-10-09 00:57:31 +02:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called with details about coins that were refunding,
|
|
|
|
* with the goal of auditing the refund's execution.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid unique serial ID for the refund in our DB
|
2017-03-19 01:55:37 +01:00
|
|
|
* @param denom_pub denomination public key of @a coin_pub
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param coin_pub public key of the coin
|
|
|
|
* @param merchant_pub public key of the merchant
|
|
|
|
* @param merchant_sig signature of the merchant
|
2017-05-29 01:15:41 +02:00
|
|
|
* @param h_contract_terms hash of the proposal data known to merchant and customer
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param rtransaction_id refund transaction ID chosen by the merchant
|
|
|
|
* @param amount_with_fee amount that was deposited including fee
|
|
|
|
* @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
|
|
|
|
*/
|
|
|
|
typedef int
|
|
|
|
(*TALER_EXCHANGEDB_RefundCallback)(void *cls,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid,
|
2017-03-19 01:55:37 +01:00
|
|
|
const struct TALER_DenominationPublicKey *denom_pub,
|
2016-10-09 00:57:31 +02:00
|
|
|
const struct TALER_CoinSpendPublicKeyP *coin_pub,
|
|
|
|
const struct TALER_MerchantPublicKeyP *merchant_pub,
|
|
|
|
const struct TALER_MerchantSignatureP *merchant_sig,
|
2017-05-29 01:15:41 +02:00
|
|
|
const struct GNUNET_HashCode *h_contract_terms,
|
2016-10-09 00:57:31 +02:00
|
|
|
uint64_t rtransaction_id,
|
|
|
|
const struct TALER_Amount *amount_with_fee);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called with details about incoming wire transfers.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid unique serial ID for the refresh session in our DB
|
|
|
|
* @param reserve_pub public key of the reserve (also the WTID)
|
|
|
|
* @param credit amount that was received
|
|
|
|
* @param sender_account_details information about the sender's bank account
|
2017-05-05 13:41:32 +02:00
|
|
|
* @param wire_reference unique identifier for the wire transfer (plugin-specific format)
|
|
|
|
* @param wire_reference_size number of bytes in @a wire_reference
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param execution_date when did we receive the funds
|
|
|
|
* @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
|
|
|
|
*/
|
|
|
|
typedef int
|
|
|
|
(*TALER_EXCHANGEDB_ReserveInCallback)(void *cls,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid,
|
2016-10-09 00:57:31 +02:00
|
|
|
const struct TALER_ReservePublicKeyP *reserve_pub,
|
|
|
|
const struct TALER_Amount *credit,
|
|
|
|
const json_t *sender_account_details,
|
2017-05-05 13:41:32 +02:00
|
|
|
const void *wire_reference,
|
|
|
|
size_t wire_reference_size,
|
2016-10-09 00:57:31 +02:00
|
|
|
struct GNUNET_TIME_Absolute execution_date);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called with details about withdraw operations.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid unique serial ID for the refresh session in our DB
|
|
|
|
* @param h_blind_ev blinded hash of the coin's public key
|
|
|
|
* @param denom_pub public denomination key of the deposited coin
|
|
|
|
* @param denom_sig signature over the deposited coin
|
|
|
|
* @param reserve_pub public key of the reserve
|
|
|
|
* @param reserve_sig signature over the withdraw operation
|
|
|
|
* @param execution_date when did the wallet withdraw the coin
|
|
|
|
* @param amount_with_fee amount that was withdrawn
|
|
|
|
* @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
|
|
|
|
*/
|
|
|
|
typedef int
|
|
|
|
(*TALER_EXCHANGEDB_WithdrawCallback)(void *cls,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid,
|
2016-10-09 00:57:31 +02:00
|
|
|
const struct GNUNET_HashCode *h_blind_ev,
|
|
|
|
const struct TALER_DenominationPublicKey *denom_pub,
|
|
|
|
const struct TALER_DenominationSignature *denom_sig,
|
|
|
|
const struct TALER_ReservePublicKeyP *reserve_pub,
|
|
|
|
const struct TALER_ReserveSignatureP *reserve_sig,
|
|
|
|
struct GNUNET_TIME_Absolute execution_date,
|
|
|
|
const struct TALER_Amount *amount_with_fee);
|
|
|
|
|
|
|
|
|
2015-06-15 14:18:37 +02:00
|
|
|
/**
|
|
|
|
* Function called with the session hashes and transfer secret
|
|
|
|
* information for a given coin.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session_hash a session the coin was melted in
|
|
|
|
* @param transfer_pub public transfer key for the session
|
|
|
|
* @param shared_secret_enc set to shared secret for the session
|
|
|
|
*/
|
|
|
|
typedef void
|
2016-03-01 15:35:04 +01:00
|
|
|
(*TALER_EXCHANGEDB_TransferDataCallback)(void *cls,
|
2016-03-30 22:56:17 +02:00
|
|
|
const struct GNUNET_HashCode *session_hash,
|
2016-08-05 16:08:19 +02:00
|
|
|
const struct TALER_TransferPublicKeyP *transfer_pub);
|
2015-06-15 14:18:37 +02:00
|
|
|
|
|
|
|
|
2015-12-09 15:36:34 +01:00
|
|
|
/**
|
|
|
|
* Function called with the results of the lookup of the
|
2016-01-21 12:09:17 +01:00
|
|
|
* wire transfer identifier information. Only called if
|
|
|
|
* we are at least aware of the transaction existing.
|
2016-01-17 18:19:09 +01:00
|
|
|
*
|
2015-12-09 15:36:34 +01:00
|
|
|
* @param cls closure
|
2016-01-20 18:50:19 +01:00
|
|
|
* @param wtid wire transfer identifier, NULL
|
2015-12-09 15:36:34 +01:00
|
|
|
* if the transaction was not yet done
|
2016-01-20 18:50:19 +01:00
|
|
|
* @param coin_contribution how much did the coin we asked about
|
2016-01-21 12:09:17 +01:00
|
|
|
* contribute to the total transfer value? (deposit value including fee)
|
2016-03-01 15:35:04 +01:00
|
|
|
* @param coin_fee how much did the exchange charge for the deposit fee
|
2015-12-09 15:36:34 +01:00
|
|
|
* @param execution_time when was the transaction done, or
|
2016-01-21 12:09:17 +01:00
|
|
|
* when we expect it to be done (if @a wtid was NULL)
|
2015-12-09 15:36:34 +01:00
|
|
|
*/
|
|
|
|
typedef void
|
2016-06-09 19:18:13 +02:00
|
|
|
(*TALER_EXCHANGEDB_TrackTransactionCallback)(void *cls,
|
2016-09-26 14:50:49 +02:00
|
|
|
const struct TALER_WireTransferIdentifierRawP *wtid,
|
|
|
|
const struct TALER_Amount *coin_contribution,
|
|
|
|
const struct TALER_Amount *coin_fee,
|
|
|
|
struct GNUNET_TIME_Absolute execution_time);
|
2015-12-09 15:36:34 +01:00
|
|
|
|
2016-01-17 18:19:09 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called with the results of the lookup of the
|
|
|
|
* transaction data associated with a wire transfer identifier.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
2017-03-18 17:47:44 +01:00
|
|
|
* @param rowid which row in the table is the information from (for diagnostics)
|
2016-01-17 18:19:09 +01:00
|
|
|
* @param merchant_pub public key of the merchant (should be same for all callbacks with the same @e cls)
|
2017-03-04 16:49:33 +01:00
|
|
|
* @param wire_method which wire plugin was used for the transfer?
|
2016-01-17 18:19:09 +01:00
|
|
|
* @param h_wire hash of wire transfer details of the merchant (should be same for all callbacks with the same @e cls)
|
2016-09-26 14:50:49 +02:00
|
|
|
* @param exec_time execution time of the wire transfer (should be same for all callbacks with the same @e cls)
|
2017-05-29 01:15:41 +02:00
|
|
|
* @param h_contract_terms which proposal was this payment about
|
2016-01-17 18:19:09 +01:00
|
|
|
* @param coin_pub which public key was this payment about
|
2016-01-21 12:09:17 +01:00
|
|
|
* @param coin_value amount contributed by this coin in total (with fee)
|
|
|
|
* @param coin_fee applicable fee for this coin
|
2016-01-17 18:19:09 +01:00
|
|
|
*/
|
|
|
|
typedef void
|
2016-03-01 15:35:04 +01:00
|
|
|
(*TALER_EXCHANGEDB_WireTransferDataCallback)(void *cls,
|
2017-03-18 17:47:44 +01:00
|
|
|
uint64_t rowid,
|
2016-03-30 22:56:17 +02:00
|
|
|
const struct TALER_MerchantPublicKeyP *merchant_pub,
|
2017-03-04 16:49:33 +01:00
|
|
|
const char *wire_method,
|
2016-03-30 22:56:17 +02:00
|
|
|
const struct GNUNET_HashCode *h_wire,
|
2016-09-26 14:50:49 +02:00
|
|
|
struct GNUNET_TIME_Absolute exec_time,
|
2017-05-29 01:15:41 +02:00
|
|
|
const struct GNUNET_HashCode *h_contract_terms,
|
2016-03-30 22:56:17 +02:00
|
|
|
const struct TALER_CoinSpendPublicKeyP *coin_pub,
|
|
|
|
const struct TALER_Amount *coin_value,
|
|
|
|
const struct TALER_Amount *coin_fee);
|
2016-01-17 18:19:09 +01:00
|
|
|
|
|
|
|
|
2017-03-18 02:40:27 +01:00
|
|
|
/**
|
|
|
|
* Function called with the results of the lookup of the
|
|
|
|
* wire transfer data of the exchange.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid identifier of the respective row in the database
|
|
|
|
* @param date timestamp of the wire transfer (roughly)
|
|
|
|
* @param wtid wire transfer subject
|
|
|
|
* @param wire wire transfer details of the receiver
|
|
|
|
* @param amount amount that was wired
|
2017-04-04 15:38:58 +02:00
|
|
|
* @return #GNUNET_OK to continue, #GNUNET_SYSERR to stop iteration
|
2017-03-18 02:40:27 +01:00
|
|
|
*/
|
2017-04-04 15:38:58 +02:00
|
|
|
typedef int
|
2017-03-18 02:40:27 +01:00
|
|
|
(*TALER_EXCHANGEDB_WireTransferOutCallback)(void *cls,
|
|
|
|
uint64_t rowid,
|
|
|
|
struct GNUNET_TIME_Absolute date,
|
|
|
|
const struct TALER_WireTransferIdentifierRawP *wtid,
|
|
|
|
const json_t *wire,
|
|
|
|
const struct TALER_Amount *amount);
|
|
|
|
|
|
|
|
|
2016-01-25 15:08:29 +01:00
|
|
|
/**
|
2016-10-09 00:57:31 +02:00
|
|
|
* Callback with data about a prepared wire transfer.
|
2016-01-25 15:08:29 +01:00
|
|
|
*
|
|
|
|
* @param cls closure
|
2016-01-27 17:09:08 +01:00
|
|
|
* @param rowid row identifier used to mark prepared transaction as done
|
2016-05-03 07:57:49 +02:00
|
|
|
* @param wire_method which wire method is this preparation data for
|
2016-01-25 15:08:29 +01:00
|
|
|
* @param buf transaction data that was persisted, NULL on error
|
|
|
|
* @param buf_size number of bytes in @a buf, 0 on error
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param finished did we complete the transfer yet?
|
2017-04-04 15:38:58 +02:00
|
|
|
* @return #GNUNET_OK to continue, #GNUNET_SYSERR to stop iteration
|
2016-01-25 15:08:29 +01:00
|
|
|
*/
|
2017-04-04 15:38:58 +02:00
|
|
|
typedef int
|
2017-03-19 08:38:48 +01:00
|
|
|
(*TALER_EXCHANGEDB_WirePreparationCallback)(void *cls,
|
|
|
|
uint64_t rowid,
|
|
|
|
const char *wire_method,
|
|
|
|
const char *buf,
|
|
|
|
size_t buf_size,
|
|
|
|
int finished);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called about paybacks the exchange has to perform.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid row identifier used to uniquely identify the payback operation
|
2017-04-04 15:38:58 +02:00
|
|
|
* @param timestamp when did we receive the payback request
|
|
|
|
* @param amount how much should be added back to the reserve
|
|
|
|
* @param reserve_pub public key of the reserve
|
2017-04-04 16:27:27 +02:00
|
|
|
* @param coin public information about the coin
|
2017-04-04 15:38:58 +02:00
|
|
|
* @param coin_sig signature with @e coin_pub of type #TALER_SIGNATURE_WALLET_COIN_PAYBACK
|
|
|
|
* @param coin_blind blinding factor used to blind the coin
|
|
|
|
* @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
|
2017-03-19 08:38:48 +01:00
|
|
|
*/
|
2017-04-04 15:38:58 +02:00
|
|
|
typedef int
|
2017-03-19 08:38:48 +01:00
|
|
|
(*TALER_EXCHANGEDB_PaybackCallback)(void *cls,
|
|
|
|
uint64_t rowid,
|
2017-04-04 15:38:58 +02:00
|
|
|
struct GNUNET_TIME_Absolute timestamp,
|
2017-03-19 08:38:48 +01:00
|
|
|
const struct TALER_Amount *amount,
|
2017-04-04 15:38:58 +02:00
|
|
|
const struct TALER_ReservePublicKeyP *reserve_pub,
|
2017-04-04 16:27:27 +02:00
|
|
|
const struct TALER_CoinPublicInfo *coin,
|
2017-04-04 15:38:58 +02:00
|
|
|
const struct TALER_CoinSpendSignatureP *coin_sig,
|
|
|
|
const struct TALER_DenominationBlindingKeyP *coin_blind);
|
2017-03-19 08:38:48 +01:00
|
|
|
|
|
|
|
|
2017-04-19 21:28:47 +02:00
|
|
|
/**
|
|
|
|
* Function called about reserve closing operations
|
|
|
|
* the aggregator triggered.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid row identifier used to uniquely identify the reserve closing operation
|
|
|
|
* @param execution_date when did we execute the close operation
|
|
|
|
* @param amount_with_fee how much did we debit the reserve
|
|
|
|
* @param closing_fee how much did we charge for closing the reserve
|
|
|
|
* @param reserve_pub public key of the reserve
|
|
|
|
* @param receiver_account where did we send the funds
|
2017-05-08 12:44:40 +02:00
|
|
|
* @param wtid identifier used for the wire transfer
|
2017-04-19 21:28:47 +02:00
|
|
|
* @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
|
|
|
|
*/
|
|
|
|
typedef int
|
|
|
|
(*TALER_EXCHANGEDB_ReserveClosedCallback)(void *cls,
|
|
|
|
uint64_t rowid,
|
|
|
|
struct GNUNET_TIME_Absolute execution_date,
|
|
|
|
const struct TALER_Amount *amount_with_fee,
|
|
|
|
const struct TALER_Amount *closing_fee,
|
|
|
|
const struct TALER_ReservePublicKeyP *reserve_pub,
|
|
|
|
const json_t *receiver_account,
|
2017-05-08 12:44:40 +02:00
|
|
|
const struct TALER_WireTransferIdentifierRawP *wtid);
|
2017-04-20 21:38:02 +02:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called with details about expired reserves.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param reserve_pub public key of the reserve
|
|
|
|
* @param left amount left in the reserve
|
|
|
|
* @param account_details information about the reserve's bank account
|
|
|
|
* @param expiration_date when did the reserve expire
|
|
|
|
* @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
|
|
|
|
*/
|
|
|
|
typedef int
|
|
|
|
(*TALER_EXCHANGEDB_ReserveExpiredCallback)(void *cls,
|
|
|
|
const struct TALER_ReservePublicKeyP *reserve_pub,
|
|
|
|
const struct TALER_Amount *left,
|
|
|
|
const json_t *account_details,
|
|
|
|
struct GNUNET_TIME_Absolute expiration_date);
|
2017-04-19 21:28:47 +02:00
|
|
|
|
|
|
|
|
2017-03-19 08:38:48 +01:00
|
|
|
/**
|
|
|
|
* Function called with information justifying an aggregate payback.
|
|
|
|
* (usually implemented by the auditor when verifying losses from paybacks).
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param rowid row identifier used to uniquely identify the payback operation
|
|
|
|
* @param coin information about the coin
|
|
|
|
* @param coin_sig signature of the coin of type #TALER_SIGNATURE_WALLET_COIN_PAYBACK
|
|
|
|
* @param coin_blind blinding key of the coin
|
|
|
|
* @param h_blind_ev blinded envelope, as calculated by the exchange
|
|
|
|
* @param amount total amount to be paid back
|
|
|
|
*/
|
|
|
|
typedef void
|
|
|
|
(*TALER_EXCHANGEDB_PaybackJustificationCallback)(void *cls,
|
|
|
|
uint64_t rowid,
|
|
|
|
const struct TALER_CoinPublicInfo *coin,
|
|
|
|
const struct TALER_CoinSpendSignatureP *coin_sig,
|
|
|
|
const struct TALER_DenominationBlindingKeyP *coin_blind,
|
|
|
|
const struct GNUNET_HashCode *h_blinded_ev,
|
|
|
|
const struct TALER_Amount *amount);
|
2016-01-25 15:08:29 +01:00
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
2015-03-28 15:53:53 +01:00
|
|
|
* @brief The plugin API, returned from the plugin's "init" function.
|
2015-03-20 23:51:28 +01:00
|
|
|
* The argument given to "init" is simply a configuration handle.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Plugin
|
2015-03-20 23:51:28 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Closure for all callbacks.
|
|
|
|
*/
|
|
|
|
void *cls;
|
|
|
|
|
2015-03-26 18:06:37 +01:00
|
|
|
/**
|
2015-03-28 11:06:00 +01:00
|
|
|
* Name of the library which generated this plugin. Set by the
|
|
|
|
* plugin loader.
|
2015-03-26 18:06:37 +01:00
|
|
|
*/
|
2015-03-28 11:06:00 +01:00
|
|
|
char *library_name;
|
2015-03-26 18:06:37 +01:00
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
|
|
|
* Get the thread-local database-handle.
|
|
|
|
* Connect to the db if the connection does not exist yet.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param the database connection, or NULL on error
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *
|
2016-05-02 06:36:58 +02:00
|
|
|
(*get_session) (void *cls);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2016-05-02 06:36:58 +02:00
|
|
|
* Drop the Taler tables. This should only be used in testcases.
|
2015-03-20 23:51:28 +01:00
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @return #GNUNET_OK upon success; #GNUNET_SYSERR upon failure
|
|
|
|
*/
|
|
|
|
int
|
2016-05-18 17:19:32 +02:00
|
|
|
(*drop_tables) (void *cls);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create the necessary tables if they are not present
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @return #GNUNET_OK upon success; #GNUNET_SYSERR upon failure
|
|
|
|
*/
|
|
|
|
int
|
2016-05-02 06:36:58 +02:00
|
|
|
(*create_tables) (void *cls);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Start a transaction.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-07-05 13:35:47 +02:00
|
|
|
* @param session connection to use
|
2015-03-20 23:51:28 +01:00
|
|
|
* @return #GNUNET_OK on success
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*start) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Commit a transaction.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session connection to use
|
2015-09-21 14:36:18 +02:00
|
|
|
* @return #GNUNET_OK on success, #GNUNET_NO if the transaction
|
|
|
|
* can be retried, #GNUNET_SYSERR on hard failures
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2017-06-11 01:59:09 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2015-03-20 23:51:28 +01:00
|
|
|
(*commit) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Abort/rollback a transaction.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session connection to use
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
(*rollback) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2015-06-03 11:43:57 +02:00
|
|
|
|
2015-04-12 16:37:38 +02:00
|
|
|
/**
|
2015-06-12 10:28:17 +02:00
|
|
|
* Insert information about a denomination key and in particular
|
|
|
|
* the properties (value, fees, expiration times) the coins signed
|
|
|
|
* with this key have.
|
2015-04-12 16:37:38 +02:00
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session connection to use
|
2015-06-11 14:58:23 +02:00
|
|
|
* @param denom_pub the public key used for signing coins of this denomination
|
2016-10-08 23:37:55 +02:00
|
|
|
* @param issue issuing information with value, fees and other info about the denomination
|
2017-06-15 22:10:12 +02:00
|
|
|
* @return status of the query
|
2015-04-12 16:37:38 +02:00
|
|
|
*/
|
2017-06-15 22:10:12 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2015-06-12 10:28:17 +02:00
|
|
|
(*insert_denomination_info) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-06-12 10:28:17 +02:00
|
|
|
const struct TALER_DenominationPublicKey *denom_pub,
|
2016-03-01 15:35:04 +01:00
|
|
|
const struct TALER_EXCHANGEDB_DenominationKeyInformationP *issue);
|
2015-06-12 10:28:17 +02:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Fetch information about a denomination key.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session connection to use
|
2015-06-12 10:28:17 +02:00
|
|
|
* @param denom_pub the public key used for signing coins of this denomination
|
2015-06-12 10:46:42 +02:00
|
|
|
* @param[out] issue set to issue information with value, fees and other info about the coin, can be NULL
|
2015-06-12 10:28:17 +02:00
|
|
|
* @return #GNUNET_OK on success; #GNUNET_NO if no record was found, #GNUNET_SYSERR on failure
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*get_denomination_info) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-06-12 10:28:17 +02:00
|
|
|
const struct TALER_DenominationPublicKey *denom_pub,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_DenominationKeyInformationP *issue);
|
2015-06-03 11:43:57 +02:00
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
|
|
|
* Get the summary of a reserve.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param db the database connection handle
|
2015-06-04 10:35:37 +02:00
|
|
|
* @param[in,out] reserve the reserve data. The public key of the reserve should be set
|
2015-03-20 23:51:28 +01:00
|
|
|
* in this structure; it is used to query the database. The balance
|
|
|
|
* and expiration are then filled accordingly.
|
2017-06-11 02:12:56 +02:00
|
|
|
* @return transaction status
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2017-06-11 02:12:56 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2015-03-20 23:51:28 +01:00
|
|
|
(*reserve_get) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *db,
|
|
|
|
struct TALER_EXCHANGEDB_Reserve *reserve);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-05-13 15:57:35 +02:00
|
|
|
* Insert a incoming transaction into reserves. New reserves are
|
2015-05-15 17:24:27 +02:00
|
|
|
* also created through this function. Note that this API call
|
|
|
|
* starts (and stops) its own transaction scope (so the application
|
|
|
|
* must not do so).
|
2015-03-20 23:51:28 +01:00
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param db the database connection handle
|
2015-05-13 15:57:35 +02:00
|
|
|
* @param reserve_pub public key of the reserve
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param balance the amount that has to be added to the reserve
|
2015-07-01 00:01:21 +02:00
|
|
|
* @param execution_time when was the amount added
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param sender_account_details information about the sender's bank account
|
2017-05-05 13:41:32 +02:00
|
|
|
* @param wire_reference unique reference identifying the wire transfer (binary blob)
|
|
|
|
* @param wire_reference_size number of bytes in @a wire_reference
|
2015-05-13 15:57:35 +02:00
|
|
|
* @return #GNUNET_OK upon success; #GNUNET_NO if the given
|
|
|
|
* @a details are already known for this @a reserve_pub,
|
|
|
|
* #GNUNET_SYSERR upon failures (DB error, incompatible currency)
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*reserves_in_insert) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *db,
|
2015-05-13 15:57:35 +02:00
|
|
|
const struct TALER_ReservePublicKeyP *reserve_pub,
|
2015-03-20 23:51:28 +01:00
|
|
|
const struct TALER_Amount *balance,
|
2015-07-01 00:01:21 +02:00
|
|
|
struct GNUNET_TIME_Absolute execution_time,
|
2016-05-26 16:38:59 +02:00
|
|
|
const json_t *sender_account_details,
|
2017-05-05 13:41:32 +02:00
|
|
|
const void *wire_reference,
|
2017-05-08 13:18:36 +02:00
|
|
|
size_t wire_reference_size);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
2017-05-08 13:31:28 +02:00
|
|
|
/**
|
|
|
|
* Obtain the most recent @a wire_reference that was inserted via @e reserves_in_insert.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param db the database connection handle
|
|
|
|
* @param[out] wire_reference set to unique reference identifying the wire transfer (binary blob)
|
|
|
|
* @param[out] wire_reference_size set to number of bytes in @a wire_reference
|
|
|
|
* @return #GNUNET_OK upon success; #GNUNET_NO if we never got any incoming transfers
|
|
|
|
* #GNUNET_SYSERR upon failures (DB error)
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*get_latest_reserve_in_reference)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *db,
|
|
|
|
void **wire_reference,
|
|
|
|
size_t *wire_reference_size);
|
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
|
|
|
* Locate the response for a /withdraw request under the
|
|
|
|
* key of the hash of the blinded message.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection to use
|
2015-06-11 13:46:27 +02:00
|
|
|
* @param h_blind hash of the blinded coin to be signed (will match
|
|
|
|
* `h_coin_envelope` in the @a collectable to be returned)
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param collectable corresponding collectable coin (blind signature)
|
|
|
|
* if a coin is found
|
2017-06-19 00:00:21 +02:00
|
|
|
* @return statement execution status
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2017-06-19 00:00:21 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2015-06-11 12:30:14 +02:00
|
|
|
(*get_withdraw_info) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-06-11 13:02:57 +02:00
|
|
|
const struct GNUNET_HashCode *h_blind,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_CollectableBlindcoin *collectable);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Store collectable bit coin under the corresponding
|
|
|
|
* hash of the blinded message.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection to use
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param collectable corresponding collectable coin (blind signature)
|
|
|
|
* if a coin is found
|
2017-06-19 00:00:21 +02:00
|
|
|
* @return statement execution status
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2017-06-19 00:00:21 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2015-06-11 12:30:14 +02:00
|
|
|
(*insert_withdraw_info) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct TALER_EXCHANGEDB_CollectableBlindcoin *collectable);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get all of the transaction history associated with the specified
|
|
|
|
* reserve.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session connection to use
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param reserve_pub public key of the reserve
|
2017-06-18 22:48:54 +02:00
|
|
|
* @param[out] rhp set to known transaction history (NULL if reserve is unknown)
|
|
|
|
* @return transaction status
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2017-06-18 22:48:54 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2015-03-20 23:51:28 +01:00
|
|
|
(*get_reserve_history) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2017-06-18 22:48:54 +02:00
|
|
|
const struct TALER_ReservePublicKeyP *reserve_pub,
|
|
|
|
struct TALER_EXCHANGEDB_ReserveHistory **rhp);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
2015-03-22 13:02:11 +01:00
|
|
|
/**
|
|
|
|
* Free memory associated with the given reserve history.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param rh history to free.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
(*free_reserve_history) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_ReserveHistory *rh);
|
2015-03-22 13:02:11 +01:00
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
|
|
|
* Check if we have the specified deposit already in the database.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param deposit deposit to search for
|
2017-06-18 21:47:05 +02:00
|
|
|
* @return 1 if we know this operation,
|
|
|
|
* 0 if this exact deposit is unknown to us,
|
|
|
|
* otherwise transaction error status
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2017-06-18 21:47:05 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2015-03-20 23:51:28 +01:00
|
|
|
(*have_deposit) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct TALER_EXCHANGEDB_Deposit *deposit);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-09-19 20:02:21 +02:00
|
|
|
* Insert information about deposited coin into the database.
|
2015-03-20 23:51:28 +01:00
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session connection to the database
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param deposit deposit information to store
|
2017-06-18 15:13:13 +02:00
|
|
|
* @return query result status
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2017-06-18 15:13:13 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2015-03-20 23:51:28 +01:00
|
|
|
(*insert_deposit) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct TALER_EXCHANGEDB_Deposit *deposit);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
2016-05-05 22:57:55 +02:00
|
|
|
/**
|
|
|
|
* Insert information about refunded coin into the database.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param session connection to the database
|
|
|
|
* @param refund refund information to store
|
2017-06-18 21:47:05 +02:00
|
|
|
* @return query result status
|
2016-05-05 22:57:55 +02:00
|
|
|
*/
|
2017-06-18 21:47:05 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2016-05-05 22:57:55 +02:00
|
|
|
(*insert_refund) (void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct TALER_EXCHANGEDB_Refund *refund);
|
|
|
|
|
|
|
|
|
2016-01-25 15:18:31 +01:00
|
|
|
/**
|
|
|
|
* Mark a deposit as tiny, thereby declaring that it cannot be
|
|
|
|
* executed by itself and should no longer be returned by
|
|
|
|
* @e iterate_ready_deposits()
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param session connection to the database
|
|
|
|
* @param deposit_rowid identifies the deposit row to modify
|
2017-06-18 15:02:35 +02:00
|
|
|
* @return query result status
|
2016-01-25 15:18:31 +01:00
|
|
|
*/
|
2017-06-18 15:02:35 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2016-01-25 15:18:31 +01:00
|
|
|
(*mark_deposit_tiny) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid);
|
2016-01-25 15:18:31 +01:00
|
|
|
|
|
|
|
|
2016-05-05 22:57:55 +02:00
|
|
|
/**
|
2017-06-19 16:07:34 +02:00
|
|
|
* Test if a deposit was marked as done, thereby declaring that it
|
|
|
|
* cannot be refunded anymore.
|
2016-05-05 22:57:55 +02:00
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param session connection to the database
|
|
|
|
* @param deposit the deposit to check
|
2017-06-19 16:07:34 +02:00
|
|
|
* @return #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT if is is marked done,
|
|
|
|
* #GNUNET_DB_STATUS_SUCCESS_NO_RESULTS if not,
|
|
|
|
* otherwise transaction error status (incl. deposit unknown)
|
2016-05-05 22:57:55 +02:00
|
|
|
*/
|
2017-06-19 16:07:34 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2016-05-05 22:57:55 +02:00
|
|
|
(*test_deposit_done) (void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct TALER_EXCHANGEDB_Deposit *deposit);
|
|
|
|
|
|
|
|
|
2016-01-25 15:18:31 +01:00
|
|
|
/**
|
|
|
|
* Mark a deposit as done, thereby declaring that it cannot be
|
|
|
|
* executed at all anymore, and should no longer be returned by
|
|
|
|
* @e iterate_ready_deposits() or @e iterate_matching_deposits().
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param session connection to the database
|
|
|
|
* @param deposit_rowid identifies the deposit row to modify
|
2017-06-18 15:13:13 +02:00
|
|
|
* @return query result status
|
2016-01-25 15:18:31 +01:00
|
|
|
*/
|
2017-06-18 15:13:13 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2016-01-25 15:18:31 +01:00
|
|
|
(*mark_deposit_done) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid);
|
2016-01-25 15:18:31 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtain information about deposits that are ready to be executed.
|
|
|
|
* Such deposits must not be marked as "tiny" or "done", and the
|
2016-05-20 15:52:40 +02:00
|
|
|
* execution time and refund deadlines must both be in the past.
|
2016-01-25 15:18:31 +01:00
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param session connection to the database
|
|
|
|
* @param deposit_cb function to call for ONE such deposit
|
|
|
|
* @param deposit_cb_cls closure for @a deposit_cb
|
|
|
|
* @return number of rows processed, 0 if none exist,
|
|
|
|
* #GNUNET_SYSERR on error
|
|
|
|
*/
|
|
|
|
int
|
2016-01-27 16:42:24 +01:00
|
|
|
(*get_ready_deposit) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
TALER_EXCHANGEDB_DepositIterator deposit_cb,
|
2016-01-27 16:42:24 +01:00
|
|
|
void *deposit_cb_cls);
|
2016-01-25 15:18:31 +01:00
|
|
|
|
|
|
|
|
2016-04-06 10:22:09 +02:00
|
|
|
/**
|
|
|
|
* Maximum number of results we return from iterate_matching_deposits().
|
|
|
|
*
|
|
|
|
* Limit on the number of transactions we aggregate at once. Note
|
|
|
|
* that the limit must be big enough to ensure that when transactions
|
|
|
|
* of the smallest possible unit are aggregated, they do surpass the
|
|
|
|
* "tiny" threshold beyond which we never trigger a wire transaction!
|
|
|
|
*/
|
|
|
|
#define TALER_EXCHANGEDB_MATCHING_DEPOSITS_LIMIT 10000
|
|
|
|
#define TALER_EXCHANGEDB_MATCHING_DEPOSITS_LIMIT_STR "10000"
|
|
|
|
|
2016-01-25 15:18:31 +01:00
|
|
|
/**
|
|
|
|
* Obtain information about other pending deposits for the same
|
|
|
|
* destination. Those deposits must not already be "done".
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param session connection to the database
|
|
|
|
* @param h_wire destination of the wire transfer
|
2016-01-27 16:42:24 +01:00
|
|
|
* @param merchant_pub public key of the merchant
|
2016-01-25 15:18:31 +01:00
|
|
|
* @param deposit_cb function to call for each deposit
|
|
|
|
* @param deposit_cb_cls closure for @a deposit_cb
|
2016-04-06 10:22:09 +02:00
|
|
|
* @param limit maximum number of matching deposits to return; should
|
|
|
|
* be #TALER_EXCHANGEDB_MATCHING_DEPOSITS_LIMIT, larger values
|
|
|
|
* are not supported, smaller values would be inefficient.
|
2016-01-25 15:18:31 +01:00
|
|
|
* @return number of rows processed, 0 if none exist,
|
|
|
|
* #GNUNET_SYSERR on error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*iterate_matching_deposits) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2016-01-25 15:18:31 +01:00
|
|
|
const struct GNUNET_HashCode *h_wire,
|
2016-01-27 16:42:24 +01:00
|
|
|
const struct TALER_MerchantPublicKeyP *merchant_pub,
|
2016-03-01 15:35:04 +01:00
|
|
|
TALER_EXCHANGEDB_DepositIterator deposit_cb,
|
2016-01-27 16:42:24 +01:00
|
|
|
void *deposit_cb_cls,
|
|
|
|
uint32_t limit);
|
2015-09-19 20:02:21 +02:00
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
2015-03-24 16:56:06 +01:00
|
|
|
* Lookup refresh session data under the given @a session_hash.
|
2015-03-20 23:51:28 +01:00
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database handle to use
|
2015-03-24 16:56:06 +01:00
|
|
|
* @param session_hash hash over the melt to use for the lookup
|
2015-03-28 15:42:07 +01:00
|
|
|
* @param[out] refresh_session where to store the result
|
2015-03-20 23:51:28 +01:00
|
|
|
* @return #GNUNET_YES on success,
|
|
|
|
* #GNUNET_NO if not found,
|
|
|
|
* #GNUNET_SYSERR on DB failure
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*get_refresh_session) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-03-24 16:56:06 +01:00
|
|
|
const struct GNUNET_HashCode *session_hash,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_RefreshSession *refresh_session);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-03-24 16:56:06 +01:00
|
|
|
* Store new refresh session data under the given @a session_hash.
|
2015-03-20 23:51:28 +01:00
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database handle to use
|
2015-03-24 16:56:06 +01:00
|
|
|
* @param session_hash hash over the melt to use to locate the session
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param refresh_session session data to store
|
|
|
|
* @return #GNUNET_YES on success,
|
2017-05-25 02:06:03 +02:00
|
|
|
* #GNUNET_NO on transient error
|
2015-03-20 23:51:28 +01:00
|
|
|
* #GNUNET_SYSERR on DB failure
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*create_refresh_session) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-03-24 16:56:06 +01:00
|
|
|
const struct GNUNET_HashCode *session_hash,
|
2016-03-01 15:35:04 +01:00
|
|
|
const struct TALER_EXCHANGEDB_RefreshSession *refresh_session);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Store in the database which coin(s) we want to create
|
|
|
|
* in a given refresh operation.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection
|
2015-03-24 16:56:06 +01:00
|
|
|
* @param session_hash hash to identify refresh session
|
2015-03-22 14:21:16 +01:00
|
|
|
* @param num_newcoins number of coins to generate, size of the @a denom_pubs array
|
|
|
|
* @param denom_pubs array denominations of the coins to create
|
2015-03-20 23:51:28 +01:00
|
|
|
* @return #GNUNET_OK on success
|
2017-05-25 19:38:34 +02:00
|
|
|
* #GNUNET_NO on transient error
|
2015-03-20 23:51:28 +01:00
|
|
|
* #GNUNET_SYSERR on internal error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*insert_refresh_order) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-03-24 16:56:06 +01:00
|
|
|
const struct GNUNET_HashCode *session_hash,
|
2015-03-22 14:21:16 +01:00
|
|
|
uint16_t num_newcoins,
|
2015-03-22 22:14:30 +01:00
|
|
|
const struct TALER_DenominationPublicKey *denom_pubs);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-03-22 14:21:16 +01:00
|
|
|
* Lookup in the database for the @a num_newcoins coins that we want to
|
2015-03-20 23:51:28 +01:00
|
|
|
* create in the given refresh operation.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection
|
2015-03-24 16:56:06 +01:00
|
|
|
* @param session_hash hash to identify refresh session
|
2015-03-22 14:21:16 +01:00
|
|
|
* @param num_newcoins size of the @a denom_pubs array
|
2015-03-28 15:42:07 +01:00
|
|
|
* @param[out] denom_pubs where to write @a num_newcoins denomination keys
|
2015-03-22 14:21:16 +01:00
|
|
|
* @return #GNUNET_OK on success
|
|
|
|
* #GNUNET_SYSERR on internal error
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2015-03-22 14:21:16 +01:00
|
|
|
int
|
2015-03-20 23:51:28 +01:00
|
|
|
(*get_refresh_order) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-03-24 16:56:06 +01:00
|
|
|
const struct GNUNET_HashCode *session_hash,
|
2015-03-22 14:21:16 +01:00
|
|
|
uint16_t num_newcoins,
|
2015-03-22 22:14:30 +01:00
|
|
|
struct TALER_DenominationPublicKey *denom_pubs);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-03-22 14:21:16 +01:00
|
|
|
* Store information about the commitments of the given index @a i
|
|
|
|
* for the given refresh session in the database.
|
2015-03-20 23:51:28 +01:00
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection to use
|
2015-03-24 16:56:06 +01:00
|
|
|
* @param session_hash hash to identify refresh session
|
2015-03-22 14:21:16 +01:00
|
|
|
* @param num_newcoins coin index size of the @a commit_coins array
|
|
|
|
* @param commit_coin array of coin commitments to store
|
2015-03-20 23:51:28 +01:00
|
|
|
* @return #GNUNET_OK on success
|
2017-05-25 19:38:34 +02:00
|
|
|
* #GNUNET_NO on transient error
|
2015-03-20 23:51:28 +01:00
|
|
|
* #GNUNET_SYSERR on error
|
|
|
|
*/
|
|
|
|
int
|
2015-03-22 14:21:16 +01:00
|
|
|
(*insert_refresh_commit_coins) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-03-24 16:56:06 +01:00
|
|
|
const struct GNUNET_HashCode *session_hash,
|
2015-06-11 12:08:15 +02:00
|
|
|
uint16_t num_newcoins,
|
2016-03-01 15:35:04 +01:00
|
|
|
const struct TALER_EXCHANGEDB_RefreshCommitCoin *commit_coins);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtain information about the commitment of the
|
|
|
|
* given coin of the given refresh session from the database.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection to use
|
2015-03-24 16:56:06 +01:00
|
|
|
* @param session_hash hash to identify refresh session
|
2015-03-22 22:14:30 +01:00
|
|
|
* @param num_coins size of the @a commit_coins array
|
2015-06-11 14:40:07 +02:00
|
|
|
* @param[out] commit_coins array of coin commitments to return
|
2015-03-20 23:51:28 +01:00
|
|
|
* @return #GNUNET_OK on success
|
|
|
|
* #GNUNET_NO if not found
|
|
|
|
* #GNUNET_SYSERR on error
|
|
|
|
*/
|
|
|
|
int
|
2015-03-22 14:21:16 +01:00
|
|
|
(*get_refresh_commit_coins) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-03-24 16:56:06 +01:00
|
|
|
const struct GNUNET_HashCode *session_hash,
|
2015-06-11 12:08:15 +02:00
|
|
|
uint16_t num_coins,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_RefreshCommitCoin *commit_coins);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2016-05-19 18:37:31 +02:00
|
|
|
/**
|
|
|
|
* Free refresh @a commit_coins data obtained via @e get_refresh_commit_coins.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param num_coins size of the @a commit_coins array
|
|
|
|
* @param commit_coins array of coin commitments to free
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
(*free_refresh_commit_coins) (void *cls,
|
|
|
|
unsigned int num_coins,
|
|
|
|
struct TALER_EXCHANGEDB_RefreshCommitCoin *commit_coins);
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Store the commitment to the given (encrypted) refresh link data
|
|
|
|
* for the given refresh session.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection to use
|
2015-03-24 16:56:06 +01:00
|
|
|
* @param session_hash hash to identify refresh session
|
2016-08-05 16:08:19 +02:00
|
|
|
* @param tp public key to store
|
2017-05-25 02:06:03 +02:00
|
|
|
* @return #GNUNET_SYSERR on internal error
|
|
|
|
* #GNUNET_NO on transient errors
|
|
|
|
* #GNUNET_OK on success
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
|
|
|
int
|
2016-08-05 16:08:19 +02:00
|
|
|
(*insert_refresh_transfer_public_key) (void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct GNUNET_HashCode *session_hash,
|
|
|
|
const struct TALER_TransferPublicKeyP *tp);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtain the commited (encrypted) refresh link data
|
|
|
|
* for the given refresh session.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection to use
|
2015-03-24 16:56:06 +01:00
|
|
|
* @param session_hash hash to identify refresh session
|
2016-08-05 16:08:19 +02:00
|
|
|
* @param[out] tp information to return
|
2015-03-20 23:51:28 +01:00
|
|
|
* @return #GNUNET_SYSERR on internal error,
|
|
|
|
* #GNUNET_NO if commitment was not found
|
|
|
|
* #GNUNET_OK on success
|
|
|
|
*/
|
|
|
|
int
|
2016-08-05 16:08:19 +02:00
|
|
|
(*get_refresh_transfer_public_key) (void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct GNUNET_HashCode *session_hash,
|
|
|
|
struct TALER_TransferPublicKeyP *tp);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
2016-11-17 16:37:40 +01:00
|
|
|
/**
|
|
|
|
* Get signature of a new coin generated during refresh into
|
|
|
|
* the database indexed by the refresh session and the index
|
|
|
|
* of the coin.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param session database connection
|
|
|
|
* @param session_hash hash to identify refresh session
|
|
|
|
* @param newcoin_index coin index
|
|
|
|
* @param[out] ev_sig coin signature
|
|
|
|
* @return #GNUNET_OK on success, #GNUNET_NO if we have no such entry,
|
|
|
|
* #GNUNET_SYSERR on error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*get_refresh_out) (void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct GNUNET_HashCode *session_hash,
|
|
|
|
uint16_t newcoin_index,
|
|
|
|
struct TALER_DenominationSignature *ev_sig);
|
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
/**
|
|
|
|
* Insert signature of a new coin generated during refresh into
|
|
|
|
* the database indexed by the refresh session and the index
|
|
|
|
* of the coin. This data is later used should an old coin
|
|
|
|
* be used to try to obtain the private keys during "/refresh/link".
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection
|
2015-03-24 16:56:06 +01:00
|
|
|
* @param session_hash hash to identify refresh session
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param newcoin_index coin index
|
|
|
|
* @param ev_sig coin signature
|
|
|
|
* @return #GNUNET_OK on success
|
2016-11-17 16:37:40 +01:00
|
|
|
* #GNUNET_SYSERR on error
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
|
|
|
int
|
2015-06-11 12:30:14 +02:00
|
|
|
(*insert_refresh_out) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2016-01-25 14:57:32 +01:00
|
|
|
const struct GNUNET_HashCode *session_hash,
|
|
|
|
uint16_t newcoin_index,
|
|
|
|
const struct TALER_DenominationSignature *ev_sig);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtain the link data of a coin, that is the encrypted link
|
|
|
|
* information, the denomination keys and the signatures.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection
|
2015-06-15 14:18:37 +02:00
|
|
|
* @param session_hash session to get linkage data for
|
|
|
|
* @return all known link data for the session
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_LinkDataList *
|
2015-03-22 13:02:11 +01:00
|
|
|
(*get_link_data_list) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-06-15 14:18:37 +02:00
|
|
|
const struct GNUNET_HashCode *session_hash);
|
2015-03-22 13:02:11 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Free memory of the link data list.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param ldl link data list to release
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
(*free_link_data_list) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_LinkDataList *ldl);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtain shared secret and transfer public key from the public key of
|
|
|
|
* the coin. This information and the link information returned by
|
2015-05-16 18:26:34 +02:00
|
|
|
* @e get_link_data_list() enable the owner of an old coin to determine
|
2015-03-20 23:51:28 +01:00
|
|
|
* the private keys of the new coins after the melt.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param coin_pub public key of the coin
|
2015-06-15 14:18:37 +02:00
|
|
|
* @param tdc function to call for each session the coin was melted into
|
|
|
|
* @param tdc_cls closure for @a tdc
|
2015-03-20 23:51:28 +01:00
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_NO on failure (not found)
|
|
|
|
* #GNUNET_SYSERR on internal failure (database issue)
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*get_transfer) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2015-05-16 14:15:34 +02:00
|
|
|
const struct TALER_CoinSpendPublicKeyP *coin_pub,
|
2016-03-01 15:35:04 +01:00
|
|
|
TALER_EXCHANGEDB_TransferDataCallback tdc,
|
2015-06-15 14:18:37 +02:00
|
|
|
void *tdc_cls);
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Compile a list of all (historic) transactions performed
|
|
|
|
* with the given coin (/refresh/melt and /deposit operations).
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2015-09-19 20:28:37 +02:00
|
|
|
* @param session database connection
|
2015-03-20 23:51:28 +01:00
|
|
|
* @param coin_pub coin to investigate
|
2017-06-19 16:07:34 +02:00
|
|
|
* @param[out] tlp set to list of transactions, NULL if coin is fresh
|
|
|
|
* @return database transaction status
|
2015-03-20 23:51:28 +01:00
|
|
|
*/
|
2017-06-19 16:07:34 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2015-03-20 23:51:28 +01:00
|
|
|
(*get_coin_transactions) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2017-06-19 16:07:34 +02:00
|
|
|
const struct TALER_CoinSpendPublicKeyP *coin_pub,
|
|
|
|
struct TALER_EXCHANGEDB_TransactionList **tlp);
|
2015-03-20 23:51:28 +01:00
|
|
|
|
2015-03-22 13:02:11 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Free linked list of transactions.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param list list to free
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
(*free_coin_transaction_list) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_TransactionList *list);
|
2015-03-22 13:02:11 +01:00
|
|
|
|
|
|
|
|
2016-01-17 18:19:09 +01:00
|
|
|
/**
|
|
|
|
* Lookup the list of Taler transactions that was aggregated
|
|
|
|
* into a wire transfer by the respective @a raw_wtid.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
2016-01-21 11:24:18 +01:00
|
|
|
* @param session database connection
|
2016-01-20 18:50:19 +01:00
|
|
|
* @param wtid the raw wire transfer identifier we used
|
2016-01-17 18:19:09 +01:00
|
|
|
* @param cb function to call on each transaction found
|
|
|
|
* @param cb_cls closure for @a cb
|
2016-01-21 12:09:17 +01:00
|
|
|
* @return #GNUNET_OK on success, #GNUNET_SYSERR on database errors,
|
|
|
|
* #GNUNET_NO if we found no results
|
2016-01-17 18:19:09 +01:00
|
|
|
*/
|
|
|
|
int
|
2016-01-21 12:09:17 +01:00
|
|
|
(*lookup_wire_transfer) (void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2016-01-21 12:09:17 +01:00
|
|
|
const struct TALER_WireTransferIdentifierRawP *wtid,
|
2016-03-01 15:35:04 +01:00
|
|
|
TALER_EXCHANGEDB_WireTransferDataCallback cb,
|
2016-01-21 12:09:17 +01:00
|
|
|
void *cb_cls);
|
2016-01-17 18:19:09 +01:00
|
|
|
|
|
|
|
|
2015-12-09 15:36:34 +01:00
|
|
|
/**
|
|
|
|
* Try to find the wire transfer details for a deposit operation.
|
|
|
|
* If we did not execute the deposit yet, return when it is supposed
|
|
|
|
* to be executed.
|
2016-01-17 18:19:09 +01:00
|
|
|
*
|
2015-12-09 15:36:34 +01:00
|
|
|
* @param cls closure
|
2016-01-21 11:24:18 +01:00
|
|
|
* @param session database connection
|
2017-05-29 01:15:41 +02:00
|
|
|
* @param h_contract_terms hash of the proposal data
|
2015-12-09 15:36:34 +01:00
|
|
|
* @param h_wire hash of merchant wire details
|
|
|
|
* @param coin_pub public key of deposited coin
|
|
|
|
* @param merchant_pub merchant public key
|
|
|
|
* @param cb function to call with the result
|
|
|
|
* @param cb_cls closure to pass to @a cb
|
2016-01-21 12:09:17 +01:00
|
|
|
* @return #GNUNET_OK on success, #GNUNET_SYSERR on DB errors,
|
|
|
|
* #GNUNET_NO if nothing was found
|
2015-12-09 15:36:34 +01:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*wire_lookup_deposit_wtid)(void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2017-05-29 01:15:41 +02:00
|
|
|
const struct GNUNET_HashCode *h_contract_terms,
|
2015-12-09 15:36:34 +01:00
|
|
|
const struct GNUNET_HashCode *h_wire,
|
|
|
|
const struct TALER_CoinSpendPublicKeyP *coin_pub,
|
|
|
|
const struct TALER_MerchantPublicKeyP *merchant_pub,
|
2016-06-09 19:18:13 +02:00
|
|
|
TALER_EXCHANGEDB_TrackTransactionCallback cb,
|
2015-12-09 15:36:34 +01:00
|
|
|
void *cb_cls);
|
|
|
|
|
2016-01-21 08:44:45 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called to insert aggregation information into the DB.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
2016-01-21 11:24:18 +01:00
|
|
|
* @param session database connection
|
2016-01-21 08:44:45 +01:00
|
|
|
* @param wtid the raw wire transfer identifier we used
|
2016-05-27 15:34:24 +02:00
|
|
|
* @param deposit_serial_id row in the deposits table for which this is aggregation data
|
2017-05-25 02:06:03 +02:00
|
|
|
* @return #GNUNET_OK on success
|
|
|
|
* #GNUNET_NO on transient errors
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
2016-01-21 08:44:45 +01:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*insert_aggregation_tracking)(void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2016-01-21 08:44:45 +01:00
|
|
|
const struct TALER_WireTransferIdentifierRawP *wtid,
|
2017-03-19 01:36:15 +01:00
|
|
|
unsigned long long deposit_serial_id);
|
2016-01-21 08:44:45 +01:00
|
|
|
|
|
|
|
|
2017-03-04 16:49:33 +01:00
|
|
|
/**
|
|
|
|
* Insert wire transfer fee into database.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param wire_method which wire method is the fee about?
|
|
|
|
* @param start_date when does the fee go into effect
|
|
|
|
* @param end_date when does the fee end being valid
|
|
|
|
* @param wire_fee how high is the wire transfer fee
|
|
|
|
* @param master_sig signature over the above by the exchange master key
|
2017-05-25 02:06:03 +02:00
|
|
|
* @return #GNUNET_OK on success or if the record exists,
|
|
|
|
* #GNUNET_NO on transient errors,
|
2017-03-04 16:49:33 +01:00
|
|
|
* #GNUNET_SYSERR on failure
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*insert_wire_fee)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const char *wire_method,
|
|
|
|
struct GNUNET_TIME_Absolute start_date,
|
|
|
|
struct GNUNET_TIME_Absolute end_date,
|
|
|
|
const struct TALER_Amount *wire_fee,
|
|
|
|
const struct TALER_MasterSignatureP *master_sig);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtain wire fee from database.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param type type of wire transfer the fee applies for
|
|
|
|
* @param date for which date do we want the fee?
|
|
|
|
* @param[out] start_date when does the fee go into effect
|
|
|
|
* @param[out] end_date when does the fee end being valid
|
|
|
|
* @param[out] wire_fee how high is the wire transfer fee
|
|
|
|
* @param[out] master_sig signature over the above by the exchange master key
|
|
|
|
* @return #GNUNET_OK on success, #GNUNET_NO if no fee is known
|
|
|
|
* #GNUNET_SYSERR on failure
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*get_wire_fee) (void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const char *type,
|
|
|
|
struct GNUNET_TIME_Absolute date,
|
|
|
|
struct GNUNET_TIME_Absolute *start_date,
|
|
|
|
struct GNUNET_TIME_Absolute *end_date,
|
|
|
|
struct TALER_Amount *wire_fee,
|
|
|
|
struct TALER_MasterSignatureP *master_sig);
|
|
|
|
|
|
|
|
|
2017-04-20 21:38:02 +02:00
|
|
|
/**
|
|
|
|
* Obtain information about expired reserves and their
|
|
|
|
* remaining balances.
|
|
|
|
*
|
|
|
|
* @param cls closure of the plugin
|
|
|
|
* @param session database connection
|
|
|
|
* @param now timestamp based on which we decide expiration
|
|
|
|
* @param rec function to call on expired reserves
|
|
|
|
* @param rec_cls closure for @a rec
|
|
|
|
* @return #GNUNET_SYSERR on database error
|
|
|
|
* #GNUNET_NO if there are no expired non-empty reserves
|
|
|
|
* #GNUNET_OK on success
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*get_expired_reserves)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
struct GNUNET_TIME_Absolute now,
|
|
|
|
TALER_EXCHANGEDB_ReserveExpiredCallback rec,
|
|
|
|
void *rec_cls);
|
|
|
|
|
2017-05-05 13:41:32 +02:00
|
|
|
|
2017-04-19 18:44:14 +02:00
|
|
|
/**
|
|
|
|
* Insert reserve close operation into database.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param reserve_pub which reserve is this about?
|
|
|
|
* @param execution_date when did we perform the transfer?
|
|
|
|
* @param receiver_account to which account do we transfer?
|
2017-05-08 12:44:40 +02:00
|
|
|
* @param wtid identifier for the wire transfer
|
2017-04-19 18:44:14 +02:00
|
|
|
* @param amount_with_fee amount we charged to the reserve
|
|
|
|
* @param closing_fee how high is the closing fee
|
|
|
|
* @return #GNUNET_OK on success, #GNUNET_NO if the record exists,
|
|
|
|
* #GNUNET_SYSERR on failure
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*insert_reserve_closed)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2017-04-20 21:38:02 +02:00
|
|
|
const struct TALER_ReservePublicKeyP *reserve_pub,
|
2017-04-19 18:44:14 +02:00
|
|
|
struct GNUNET_TIME_Absolute execution_date,
|
|
|
|
const json_t *receiver_account,
|
2017-05-08 12:44:40 +02:00
|
|
|
const struct TALER_WireTransferIdentifierRawP *wtid,
|
2017-04-19 18:44:14 +02:00
|
|
|
const struct TALER_Amount *amount_with_fee,
|
|
|
|
const struct TALER_Amount *closing_fee);
|
|
|
|
|
|
|
|
|
2016-01-25 15:08:29 +01:00
|
|
|
/**
|
|
|
|
* Function called to insert wire transfer commit data into the DB.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
2016-01-27 18:28:52 +01:00
|
|
|
* @param type type of the wire transfer (i.e. "sepa")
|
2016-01-25 15:08:29 +01:00
|
|
|
* @param buf buffer with wire transfer preparation data
|
|
|
|
* @param buf_size number of bytes in @a buf
|
|
|
|
* @return #GNUNET_OK on success, #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*wire_prepare_data_insert)(void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2016-01-25 15:08:29 +01:00
|
|
|
const char *type,
|
|
|
|
const char *buf,
|
|
|
|
size_t buf_size);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called to mark wire transfer commit data as finished.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
2016-01-27 18:28:52 +01:00
|
|
|
* @param rowid which entry to mark as finished
|
2016-01-25 15:08:29 +01:00
|
|
|
* @return #GNUNET_OK on success, #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*wire_prepare_data_mark_finished)(void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2016-11-17 14:31:44 +01:00
|
|
|
uint64_t rowid);
|
2016-01-25 15:08:29 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2016-01-27 18:28:52 +01:00
|
|
|
* Function called to get an unfinished wire transfer
|
2016-01-25 15:08:29 +01:00
|
|
|
* preparation data. Fetches at most one item.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param cb function to call for ONE unfinished item
|
|
|
|
* @param cb_cls closure for @a cb
|
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_NO if there are no entries,
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
2016-01-27 18:28:52 +01:00
|
|
|
(*wire_prepare_data_get)(void *cls,
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2016-10-09 00:57:31 +02:00
|
|
|
TALER_EXCHANGEDB_WirePreparationIterator cb,
|
2016-01-27 18:28:52 +01:00
|
|
|
void *cb_cls);
|
2016-01-25 15:08:29 +01:00
|
|
|
|
|
|
|
|
2017-03-18 03:44:59 +01:00
|
|
|
/**
|
|
|
|
* Start a transaction where we transiently violate the foreign
|
|
|
|
* constraints on the "wire_out" table as we insert aggregations
|
|
|
|
* and only add the wire transfer out at the end.
|
|
|
|
*
|
|
|
|
* @param cls the @e cls of this struct with the plugin-specific state
|
|
|
|
* @param session connection to use
|
|
|
|
* @return #GNUNET_OK on success
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*start_deferred_wire_out) (void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session);
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-03-18 02:40:27 +01:00
|
|
|
/**
|
|
|
|
* Store information about an outgoing wire transfer that was executed.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param date time of the wire transfer
|
|
|
|
* @param wtid subject of the wire transfer
|
2017-05-08 13:18:36 +02:00
|
|
|
* @param wire_account details about the receiver account of the wire transfer
|
2017-03-18 02:40:27 +01:00
|
|
|
* @param amount amount that was transmitted
|
|
|
|
* @return #GNUNET_OK on success
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*store_wire_transfer_out)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
struct GNUNET_TIME_Absolute date,
|
|
|
|
const struct TALER_WireTransferIdentifierRawP *wtid,
|
2017-05-08 13:18:36 +02:00
|
|
|
const json_t *wire_account,
|
2017-03-18 02:40:27 +01:00
|
|
|
const struct TALER_Amount *amount);
|
|
|
|
|
|
|
|
|
2016-05-31 09:13:03 +02:00
|
|
|
/**
|
|
|
|
* Function called to perform "garbage collection" on the
|
|
|
|
* database, expiring records we no longer require.
|
|
|
|
*
|
2016-10-09 00:57:31 +02:00
|
|
|
* FIXME: we probably need to consider here which entries the
|
|
|
|
* auditor still needs to check, at least with respect to GC of the
|
|
|
|
* prewire table (for denominations, we can assume that the auditor
|
|
|
|
* runs long before the DK expire_legal time is hit). Thus, this
|
|
|
|
* function probably should take the "last_prewire_serial_id"
|
|
|
|
* from the "auditor_progress" table as an extra argument (which
|
|
|
|
* the user would then have to manually specify).
|
|
|
|
*
|
2016-05-31 09:13:03 +02:00
|
|
|
* @param cls closure
|
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*gc) (void *cls);
|
|
|
|
|
2016-10-09 00:57:31 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Select deposits above @a serial_id in monotonically increasing
|
|
|
|
* order.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param serial_id highest serial ID to exclude (select strictly larger)
|
|
|
|
* @param cb function to call on each result
|
|
|
|
* @param cb_cls closure for @a cb
|
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*select_deposits_above_serial_id)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
uint64_t serial_id,
|
|
|
|
TALER_EXCHANGEDB_DepositCallback cb,
|
|
|
|
void *cb_cls);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Select refresh sessions above @a serial_id in monotonically increasing
|
|
|
|
* order.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param serial_id highest serial ID to exclude (select strictly larger)
|
|
|
|
* @param cb function to call on each result
|
|
|
|
* @param cb_cls closure for @a cb
|
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*select_refreshs_above_serial_id)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
uint64_t serial_id,
|
|
|
|
TALER_EXCHANGEDB_RefreshSessionCallback cb,
|
|
|
|
void *cb_cls);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Select refunds above @a serial_id in monotonically increasing
|
|
|
|
* order.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param serial_id highest serial ID to exclude (select strictly larger)
|
|
|
|
* @param cb function to call on each result
|
|
|
|
* @param cb_cls closure for @a cb
|
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*select_refunds_above_serial_id)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
uint64_t serial_id,
|
|
|
|
TALER_EXCHANGEDB_RefundCallback cb,
|
|
|
|
void *cb_cls);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Select inbound wire transfers into reserves_in above @a serial_id
|
|
|
|
* in monotonically increasing order.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param serial_id highest serial ID to exclude (select strictly larger)
|
|
|
|
* @param cb function to call on each result
|
|
|
|
* @param cb_cls closure for @a cb
|
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*select_reserves_in_above_serial_id)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
uint64_t serial_id,
|
|
|
|
TALER_EXCHANGEDB_ReserveInCallback cb,
|
|
|
|
void *cb_cls);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Select withdraw operations from reserves_out above @a serial_id
|
|
|
|
* in monotonically increasing order.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param serial_id highest serial ID to exclude (select strictly larger)
|
|
|
|
* @param cb function to call on each result
|
|
|
|
* @param cb_cls closure for @a cb
|
|
|
|
* @return #GNUNET_OK on success,
|
2017-03-19 13:53:50 +01:00
|
|
|
* #GNUNET_NO if no records were found
|
2016-10-09 00:57:31 +02:00
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*select_reserves_out_above_serial_id)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
uint64_t serial_id,
|
|
|
|
TALER_EXCHANGEDB_WithdrawCallback cb,
|
|
|
|
void *cb_cls);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2017-03-18 02:40:27 +01:00
|
|
|
* Function called to select outgoing wire transfers the exchange
|
|
|
|
* executed, ordered by serial ID (monotonically increasing).
|
2016-10-09 00:57:31 +02:00
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
2017-03-18 02:40:27 +01:00
|
|
|
* @param serial_id lowest serial ID to include (select larger or equal)
|
2016-10-09 00:57:31 +02:00
|
|
|
* @param cb function to call for ONE unfinished item
|
|
|
|
* @param cb_cls closure for @a cb
|
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_NO if there are no entries,
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
2017-03-18 02:40:27 +01:00
|
|
|
(*select_wire_out_above_serial_id)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
uint64_t serial_id,
|
|
|
|
TALER_EXCHANGEDB_WireTransferOutCallback cb,
|
|
|
|
void *cb_cls);
|
2016-10-09 00:57:31 +02:00
|
|
|
|
2017-03-19 08:38:48 +01:00
|
|
|
|
2017-04-04 15:38:58 +02:00
|
|
|
/**
|
|
|
|
* Function called to select payback requests the exchange
|
|
|
|
* received, ordered by serial ID (monotonically increasing).
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param serial_id lowest serial ID to include (select larger or equal)
|
|
|
|
* @param cb function to call for ONE unfinished item
|
|
|
|
* @param cb_cls closure for @a cb
|
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_NO if there are no entries,
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*select_payback_above_serial_id)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
uint64_t serial_id,
|
|
|
|
TALER_EXCHANGEDB_PaybackCallback cb,
|
|
|
|
void *cb_cls);
|
|
|
|
|
|
|
|
|
2017-04-19 21:28:47 +02:00
|
|
|
/**
|
|
|
|
* Function called to select reserve close operations the aggregator
|
|
|
|
* triggered, ordered by serial ID (monotonically increasing).
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
|
|
|
* @param serial_id lowest serial ID to include (select larger or equal)
|
2017-05-05 13:41:32 +02:00
|
|
|
* @param cb function to call
|
2017-04-19 21:28:47 +02:00
|
|
|
* @param cb_cls closure for @a cb
|
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_NO if there are no entries,
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*select_reserve_closed_above_serial_id)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
uint64_t serial_id,
|
|
|
|
TALER_EXCHANGEDB_ReserveClosedCallback cb,
|
|
|
|
void *cb_cls);
|
|
|
|
|
|
|
|
|
2017-03-19 08:38:48 +01:00
|
|
|
/**
|
2017-04-01 23:43:55 +02:00
|
|
|
* Function called to add a request for an emergency payback for a
|
|
|
|
* coin. The funds are to be added back to the reserve. The
|
|
|
|
* function should return the @a deadline by which the exchange will
|
|
|
|
* trigger a wire transfer back to the customer's account for the
|
|
|
|
* reserve.
|
2017-03-19 08:38:48 +01:00
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session database connection
|
2017-04-01 23:43:55 +02:00
|
|
|
* @param reserve_pub public key of the reserve that is being refunded
|
2017-04-04 16:27:27 +02:00
|
|
|
* @param coin public information about a coin
|
2017-03-19 08:38:48 +01:00
|
|
|
* @param coin_sig signature of the coin of type #TALER_SIGNATURE_WALLET_COIN_PAYBACK
|
|
|
|
* @param coin_blind blinding key of the coin
|
|
|
|
* @param h_blind_ev blinded envelope, as calculated by the exchange
|
|
|
|
* @param amount total amount to be paid back
|
2017-04-01 23:43:55 +02:00
|
|
|
* @param receiver_account_details who should receive the funds
|
2017-04-20 07:49:56 +02:00
|
|
|
* @param h_blind_ev hash of the blinded coin's envelope (must match reserves_out entry)
|
2017-04-03 16:40:31 +02:00
|
|
|
* @param now timestamp to store
|
2017-06-19 17:53:42 +02:00
|
|
|
* @return transaction result status
|
2017-03-19 08:38:48 +01:00
|
|
|
*/
|
2017-06-19 17:53:42 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2017-03-19 08:38:48 +01:00
|
|
|
(*insert_payback_request)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
2017-04-01 23:43:55 +02:00
|
|
|
const struct TALER_ReservePublicKeyP *reserve_pub,
|
2017-04-04 16:27:27 +02:00
|
|
|
const struct TALER_CoinPublicInfo *coin,
|
2017-03-19 08:38:48 +01:00
|
|
|
const struct TALER_CoinSpendSignatureP *coin_sig,
|
|
|
|
const struct TALER_DenominationBlindingKeyP *coin_blind,
|
|
|
|
const struct TALER_Amount *amount,
|
2017-04-02 18:02:07 +02:00
|
|
|
const struct GNUNET_HashCode *h_blind_ev,
|
2017-04-03 16:40:31 +02:00
|
|
|
struct GNUNET_TIME_Absolute timestamp);
|
2017-03-19 08:38:48 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2017-04-01 23:43:55 +02:00
|
|
|
* Obtain information about which reserve a coin was generated
|
|
|
|
* from given the hash of the blinded coin.
|
2017-03-19 08:38:48 +01:00
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session a session
|
2017-04-01 23:43:55 +02:00
|
|
|
* @param h_blind_ev hash of the blinded coin
|
|
|
|
* @param[out] reserve_pub set to information about the reserve (on success only)
|
2017-06-19 17:53:42 +02:00
|
|
|
* @return transaction status code
|
2017-03-19 08:38:48 +01:00
|
|
|
*/
|
2017-06-19 17:53:42 +02:00
|
|
|
enum GNUNET_DB_QueryStatus
|
2017-04-01 23:43:55 +02:00
|
|
|
(*get_reserve_by_h_blind)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct GNUNET_HashCode *h_blind_ev,
|
|
|
|
struct TALER_ReservePublicKeyP *reserve_pub);
|
2017-03-19 08:38:48 +01:00
|
|
|
|
2017-04-08 22:01:13 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Store information that a denomination key was revoked
|
|
|
|
* in the database.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session a session
|
|
|
|
* @param denom_pub_hash hash of the revoked denomination key
|
|
|
|
* @param master_sig signature affirming the revocation
|
|
|
|
* @return #GNUNET_OK on success,
|
2017-04-09 21:28:45 +02:00
|
|
|
* #GNUNET_NO if the entry already exists (transaction must be rolled back!)
|
2017-04-08 22:01:13 +02:00
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*insert_denomination_revocation)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct GNUNET_HashCode *denom_pub_hash,
|
|
|
|
const struct TALER_MasterSignatureP *master_sig);
|
2017-04-08 22:52:32 +02:00
|
|
|
|
|
|
|
|
2017-04-08 22:01:13 +02:00
|
|
|
/**
|
|
|
|
* Obtain information about a denomination key's revocation from
|
|
|
|
* the database.
|
|
|
|
*
|
|
|
|
* @param cls closure
|
|
|
|
* @param session a session
|
|
|
|
* @param denom_pub_hash hash of the revoked denomination key
|
|
|
|
* @param[out] master_sig signature affirming the revocation
|
2017-04-16 17:21:26 +02:00
|
|
|
* @param[out] rowid row where the information is stored
|
2017-04-08 22:01:13 +02:00
|
|
|
* @return #GNUNET_OK on success,
|
|
|
|
* #GNUNET_NO no such entry exists
|
|
|
|
* #GNUNET_SYSERR on DB errors
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
(*get_denomination_revocation)(void *cls,
|
|
|
|
struct TALER_EXCHANGEDB_Session *session,
|
|
|
|
const struct GNUNET_HashCode *denom_pub_hash,
|
2017-04-16 17:21:26 +02:00
|
|
|
struct TALER_MasterSignatureP *master_sig,
|
|
|
|
uint64_t *rowid);
|
2017-04-08 22:01:13 +02:00
|
|
|
|
|
|
|
|
2015-03-20 23:51:28 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2016-03-01 15:35:04 +01:00
|
|
|
#endif /* _TALER_EXCHANGE_DB_H */
|