exchange

taler_exchangedb_plugin.h (270004B)

---

 /*
   This file is part of TALER
   Copyright (C) 2014-2024 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 /**
  * @file include/taler/taler_exchangedb_plugin.h
  * @brief Low-level (statement-level) database access for the exchange
  * @author Florian Dold
  * @author Christian Grothoff
  * @author Özgür Kesim
  */
 #ifndef TALER_EXCHANGEDB_PLUGIN_H
 #define TALER_EXCHANGEDB_PLUGIN_H
 #include <jansson.h>
 #include <gnunet/gnunet_util_lib.h>
 #include <gnunet/gnunet_db_lib.h>
 #include <taler/taler_util.h>
 #include <taler/taler_signatures.h>
 #include <taler/taler_extensions_policy.h>
 
 /**
  * The conflict that can occur for the age restriction
  */
 enum TALER_EXCHANGEDB_AgeCommitmentHash_Conflict
 {
   /**
    * Value OK, no conflict
    */
   TALER_AgeCommitmentHashP_NoConflict    = 0,
 
   /**
    * Given hash had a value, but NULL (or zero) was expected
    */
   TALER_AgeCommitmentHashP_NullExpected  = 1,
 
   /**
    * Given hash was NULL, but value was expected
    */
   TALER_AgeCommitmentHashP_ValueExpected = 2,
 
   /**
    * Given hash differs from value in the known coin
    */
   TALER_AgeCommitmentHashP_ValueDiffers  = 3,
 };
 
 /**
  * Per-coin information returned when doing a batch insert.
  */
 struct TALER_EXCHANGEDB_CoinInfo
 {
   /**
    * Row of the coin in the known_coins table.
    */
   uint64_t known_coin_id;
 
   /**
    * Hash of the denomination, relevant on @e denom_conflict.
    */
   struct TALER_DenominationHashP denom_hash;
 
   /**
    * Hash of the age commitment, relevant on @e age_conflict.
    */
   struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * True if the coin was known previously.
    */
   bool existed;
 
   /**
    * True if the known coin has a different denomination;
    * application will find denomination of the already
    * known coin in @e denom_hash.
    */
   bool denom_conflict;
 
   /**
    * Indicates if and what kind of conflict with the age
    * restriction of the known coin was present;
    * application will find age commitment of the already
    * known coin in @e h_age_commitment.
    */
   enum TALER_EXCHANGEDB_AgeCommitmentHash_Conflict age_conflict;
 };
 
 
 /**
  * Information about a denomination key.
  */
 struct TALER_EXCHANGEDB_DenominationKeyInformation
 {
 
   /**
    * Signature over this struct to affirm the validity of the key.
    */
   struct TALER_MasterSignatureP signature;
 
   /**
    * Start time of the validity period for this key.
    */
   struct GNUNET_TIME_Timestamp start;
 
   /**
    * The exchange will sign fresh coins between @e start and this time.
    * @e expire_withdraw will be somewhat larger than @e start to
    * ensure a sufficiently large anonymity set, while also allowing
    * the Exchange to limit the financial damage in case of a key being
    * compromised.  Thus, exchanges with low volume are expected to have a
    * longer withdraw period (@e expire_withdraw - @e start) than exchanges
    * with high transaction volume.  The period may also differ between
    * types of coins.  A exchange may also have a few denomination keys
    * with the same value with overlapping validity periods, to address
    * issues such as clock skew.
    */
   struct GNUNET_TIME_Timestamp expire_withdraw;
 
   /**
    * Coins signed with the denomination key must be spent or refreshed
    * between @e start and this expiration time.  After this time, the
    * exchange will refuse transactions involving this key as it will
    * "drop" the table with double-spending information (shortly after)
    * this time.  Note that wallets should refresh coins significantly
    * before this time to be on the safe side.  @e expire_deposit must be
    * significantly larger than @e expire_withdraw (by months or even
    * years).
    */
   struct GNUNET_TIME_Timestamp expire_deposit;
 
   /**
    * When do signatures with this denomination key become invalid?
    * After this point, these signatures cannot be used in (legal)
    * disputes anymore, as the Exchange is then allowed to destroy its side
    * of the evidence.  @e expire_legal is expected to be significantly
    * larger than @e expire_deposit (by a year or more).
    */
   struct GNUNET_TIME_Timestamp expire_legal;
 
   /**
    * The value of the coins signed with this denomination key.
    */
   struct TALER_Amount value;
 
   /**
    * Fees for the coin.
    */
   struct TALER_DenomFeeSet fees;
 
   /**
    * Hash code of the denomination public key. (Used to avoid having
    * the variable-size RSA key in this struct.)
    */
   struct TALER_DenominationHashP denom_hash;
 
   /**
    * If denomination was setup for age restriction, non-zero age mask.
    * Note that the mask is not part of the signature.
    */
   struct TALER_AgeMask age_mask;
 };
 
 
 GNUNET_NETWORK_STRUCT_BEGIN
 
 /**
  * Events signalling that a coin deposit status
  * changed.
  */
 struct TALER_CoinDepositEventP
 {
   /**
    * Of type #TALER_DBEVENT_EXCHANGE_DEPOSIT_STATUS_CHANGED.
    */
   struct GNUNET_DB_EventHeaderP header;
 
   /**
    * Public key of the merchant.
    */
   struct TALER_MerchantPublicKeyP merchant_pub;
 
 };
 
 /**
  * Events signalling a reserve got funding.
  */
 struct TALER_ReserveEventP
 {
   /**
    * Of type #TALER_DBEVENT_EXCHANGE_RESERVE_INCOMING.
    */
   struct GNUNET_DB_EventHeaderP header;
 
   /**
    * Public key of the reserve the event is about.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 };
 
 
 /**
  * Signature of events signalling a purse changed its status.
  */
 struct TALER_PurseEventP
 {
   /**
    * Of type #TALER_DBEVENT_EXCHANGE_PURSE_MERGED or
    * #TALER_DBEVENT_EXCHANGE_PURSE_DEPOSITED.
    */
   struct GNUNET_DB_EventHeaderP header;
 
   /**
    * Public key of the purse the event is about.
    */
   struct TALER_PurseContractPublicKeyP purse_pub;
 };
 
 
 /**
  * Signature of events signalling a KYC process was completed.
  */
 struct TALER_KycCompletedEventP
 {
   /**
    * Of type #TALER_DBEVENT_EXCHANGE_KYC_COMPLETED.
    */
   struct GNUNET_DB_EventHeaderP header;
 
   /**
    * Hash of payto://-URI for which the KYC state changed.
    */
   struct TALER_NormalizedPaytoHashP h_payto;
 };
 
 
 GNUNET_NETWORK_STRUCT_END
 
 /**
  * Meta data about an exchange online signing key.
  */
 struct TALER_EXCHANGEDB_SignkeyMetaData
 {
   /**
    * Start time of the validity period for this key.
    */
   struct GNUNET_TIME_Timestamp start;
 
   /**
    * The exchange will sign messages with this key between @e start and this time.
    */
   struct GNUNET_TIME_Timestamp expire_sign;
 
   /**
    * When do signatures with this sign key become invalid?
    * After this point, these signatures cannot be used in (legal)
    * disputes anymore, as the Exchange is then allowed to destroy its side
    * of the evidence.  @e expire_legal is expected to be significantly
    * larger than @e expire_sign (by a year or more).
    */
   struct GNUNET_TIME_Timestamp expire_legal;
 
 };
 
 
 /**
  * Enumeration of all of the tables replicated by exchange-auditor
  * database replication.
  *
  * Note: wire_accounts is not replicated. So far not needed by the auditor.
  */
 enum TALER_EXCHANGEDB_ReplicatedTable
 {
   TALER_EXCHANGEDB_RT_DENOMINATIONS,
   TALER_EXCHANGEDB_RT_DENOMINATION_REVOCATIONS,
   TALER_EXCHANGEDB_RT_KYC_TARGETS,
   TALER_EXCHANGEDB_RT_WIRE_TARGETS,
   TALER_EXCHANGEDB_RT_RESERVES,
   TALER_EXCHANGEDB_RT_RESERVES_IN,
   TALER_EXCHANGEDB_RT_RESERVES_CLOSE,
   TALER_EXCHANGEDB_RT_RESERVES_OPEN_REQUESTS,
   TALER_EXCHANGEDB_RT_RESERVES_OPEN_DEPOSITS,
   TALER_EXCHANGEDB_RT_AUDITORS,
   TALER_EXCHANGEDB_RT_AUDITOR_DENOM_SIGS,
   TALER_EXCHANGEDB_RT_EXCHANGE_SIGN_KEYS,
   TALER_EXCHANGEDB_RT_SIGNKEY_REVOCATIONS,
   TALER_EXCHANGEDB_RT_KNOWN_COINS,
   TALER_EXCHANGEDB_RT_REFRESH,
   TALER_EXCHANGEDB_RT_BATCH_DEPOSITS,
   TALER_EXCHANGEDB_RT_COIN_DEPOSITS,
   TALER_EXCHANGEDB_RT_REFUNDS,
   TALER_EXCHANGEDB_RT_WIRE_OUT,
   TALER_EXCHANGEDB_RT_AGGREGATION_TRACKING,
   TALER_EXCHANGEDB_RT_WIRE_FEE,
   TALER_EXCHANGEDB_RT_GLOBAL_FEE,
   TALER_EXCHANGEDB_RT_RECOUP,
   TALER_EXCHANGEDB_RT_RECOUP_REFRESH,
   TALER_EXCHANGEDB_RT_EXTENSIONS,
   TALER_EXCHANGEDB_RT_POLICY_DETAILS,
   TALER_EXCHANGEDB_RT_POLICY_FULFILLMENTS,
   TALER_EXCHANGEDB_RT_PURSE_REQUESTS,
   TALER_EXCHANGEDB_RT_PURSE_DECISION,
   TALER_EXCHANGEDB_RT_PURSE_MERGES,
   TALER_EXCHANGEDB_RT_PURSE_DEPOSITS,
   TALER_EXCHANGEDB_RT_ACCOUNT_MERGES,
   TALER_EXCHANGEDB_RT_HISTORY_REQUESTS,
   TALER_EXCHANGEDB_RT_CLOSE_REQUESTS,
   TALER_EXCHANGEDB_RT_WADS_OUT,
   TALER_EXCHANGEDB_RT_WADS_OUT_ENTRIES,
   TALER_EXCHANGEDB_RT_WADS_IN,
   TALER_EXCHANGEDB_RT_WADS_IN_ENTRIES,
   TALER_EXCHANGEDB_RT_PROFIT_DRAINS,
   TALER_EXCHANGEDB_RT_AML_STAFF,
   TALER_EXCHANGEDB_RT_PURSE_DELETION,
   TALER_EXCHANGEDB_RT_WITHDRAW,
   TALER_EXCHANGEDB_RT_LEGITIMIZATION_MEASURES,
   TALER_EXCHANGEDB_RT_LEGITIMIZATION_OUTCOMES,
   TALER_EXCHANGEDB_RT_LEGITIMIZATION_PROCESSES,
   TALER_EXCHANGEDB_RT_KYC_ATTRIBUTES,
   TALER_EXCHANGEDB_RT_AML_HISTORY,
   TALER_EXCHANGEDB_RT_KYC_EVENTS,
   TALER_EXCHANGEDB_RT_KYCAUTHS_IN
 };
 
 
 /**
  * Record of a single entry in a replicated table.
  */
 struct TALER_EXCHANGEDB_TableData
 {
   /**
    * Data of which table is returned here?
    */
   enum TALER_EXCHANGEDB_ReplicatedTable table;
 
   /**
    * Serial number of the record.
    */
   uint64_t serial;
 
   /**
    * Table-specific details.
    */
   union
   {
 
     /**
      * Details from the 'denominations' table.
      */
     struct
     {
       uint32_t denom_type;
       uint32_t age_mask;
       struct TALER_DenominationPublicKey denom_pub;
       struct TALER_MasterSignatureP master_sig;
       struct GNUNET_TIME_Timestamp valid_from;
       struct GNUNET_TIME_Timestamp expire_withdraw;
       struct GNUNET_TIME_Timestamp expire_deposit;
       struct GNUNET_TIME_Timestamp expire_legal;
       struct TALER_Amount coin;
       struct TALER_DenomFeeSet fees;
     } denominations;
 
     struct
     {
       struct TALER_MasterSignatureP master_sig;
       uint64_t denominations_serial;
     } denomination_revocations;
 
     struct
     {
       struct TALER_FullPayto full_payto_uri;
     } wire_targets;
 
     struct
     {
       struct TALER_NormalizedPaytoHashP h_normalized_payto;
       struct TALER_AccountAccessTokenP access_token;
       union TALER_AccountPublicKeyP target_pub;
       bool no_account;
       bool is_wallet;
     } kyc_targets;
 
     struct
     {
       struct TALER_AccountAccessTokenP target_token;
       struct GNUNET_TIME_Timestamp start_time;
       json_t *measures;
       uint32_t display_priority;
     } legitimization_measures;
 
     struct
     {
       struct TALER_NormalizedPaytoHashP h_payto;
       struct GNUNET_TIME_Timestamp decision_time;
       struct GNUNET_TIME_Timestamp expiration_time;
       json_t *properties;
       bool to_investigate;
       json_t *new_rules;
     } legitimization_outcomes;
 
     struct
     {
       struct TALER_NormalizedPaytoHashP h_payto;
       struct GNUNET_TIME_Timestamp start_time;
       struct GNUNET_TIME_Timestamp expiration_time;
       uint64_t legitimization_measure_serial_id;
       uint32_t measure_index;
       char *provider_name;
       char *provider_user_id;
       char *provider_legitimization_id;
       char *redirect_url;
     } legitimization_processes;
 
     struct
     {
       struct TALER_NormalizedPaytoHashP h_payto;
       uint64_t legitimization_serial;
       struct GNUNET_TIME_Timestamp collection_time;
       struct GNUNET_TIME_Timestamp expiration_time;
       uint64_t trigger_outcome_serial;
       void *encrypted_attributes;
       size_t encrypted_attributes_size;
     } kyc_attributes;
 
     struct
     {
       struct TALER_NormalizedPaytoHashP h_payto;
       uint64_t outcome_serial_id;
       char *justification;
       struct TALER_AmlOfficerPublicKeyP decider_pub;
       struct TALER_AmlOfficerSignatureP decider_sig;
     } aml_history;
 
     struct
     {
       struct GNUNET_TIME_Timestamp event_timestamp;
       char *event_type;
     } kyc_events;
 
     struct
     {
       struct TALER_AmlOfficerPublicKeyP decider_pub;
       struct TALER_MasterSignatureP master_sig;
       char *decider_name;
       bool is_active;
       bool read_only;
       struct GNUNET_TIME_Timestamp last_change;
     } aml_staff;
 
     struct
     {
       struct TALER_ReservePublicKeyP reserve_pub;
       struct GNUNET_TIME_Timestamp expiration_date;
       struct GNUNET_TIME_Timestamp gc_date;
     } reserves;
 
     struct
     {
       uint64_t wire_reference;
       struct TALER_Amount credit;
       struct TALER_FullPaytoHashP sender_account_h_payto;
       char *exchange_account_section;
       struct GNUNET_TIME_Timestamp execution_date;
       struct TALER_ReservePublicKeyP reserve_pub;
     } reserves_in;
 
     struct
     {
       uint64_t wire_reference;
       struct TALER_Amount credit;
       struct TALER_FullPaytoHashP sender_account_h_payto;
       char *exchange_account_section;
       struct GNUNET_TIME_Timestamp execution_date;
       union TALER_AccountPublicKeyP account_pub;
     } kycauth_in;
 
     struct
     {
       struct TALER_ReservePublicKeyP reserve_pub;
       struct GNUNET_TIME_Timestamp request_timestamp;
       struct GNUNET_TIME_Timestamp expiration_date;
       struct TALER_ReserveSignatureP reserve_sig;
       struct TALER_Amount reserve_payment;
       uint32_t requested_purse_limit;
     } reserves_open_requests;
 
     struct
     {
       struct TALER_ReservePublicKeyP reserve_pub;
       struct TALER_CoinSpendPublicKeyP coin_pub;
       struct TALER_CoinSpendSignatureP coin_sig;
       struct TALER_ReserveSignatureP reserve_sig;
       struct TALER_Amount contribution;
     } reserves_open_deposits;
 
     struct
     {
       struct TALER_ReservePublicKeyP reserve_pub;
       struct GNUNET_TIME_Timestamp execution_date;
       struct TALER_WireTransferIdentifierRawP wtid;
       struct TALER_FullPaytoHashP sender_account_h_payto;
       struct TALER_Amount amount;
       struct TALER_Amount closing_fee;
     } reserves_close;
 
     struct
     {
       struct TALER_AuditorPublicKeyP auditor_pub;
       char *auditor_url;
       char *auditor_name;
       bool is_active;
       struct GNUNET_TIME_Timestamp last_change;
     } auditors;
 
     struct
     {
       uint64_t auditor_uuid;
       uint64_t denominations_serial;
       struct TALER_AuditorSignatureP auditor_sig;
     } auditor_denom_sigs;
 
     struct
     {
       struct TALER_ExchangePublicKeyP exchange_pub;
       struct TALER_MasterSignatureP master_sig;
       struct TALER_EXCHANGEDB_SignkeyMetaData meta;
     } exchange_sign_keys;
 
     struct
     {
       uint64_t esk_serial;
       struct TALER_MasterSignatureP master_sig;
     } signkey_revocations;
 
     struct
     {
       struct TALER_CoinSpendPublicKeyP coin_pub;
       struct TALER_AgeCommitmentHashP age_hash;
       uint64_t denominations_serial;
       struct TALER_DenominationSignature denom_sig;
     } known_coins;
 
     struct
     {
       struct TALER_RefreshCommitmentP rc;
       struct GNUNET_TIME_Timestamp execution_date;
       struct TALER_Amount amount_with_fee;
       struct TALER_CoinSpendPublicKeyP old_coin_pub;
       struct TALER_CoinSpendSignatureP old_coin_sig;
       struct TALER_PublicRefreshMasterSeedP refresh_seed;
       uint32_t noreveal_index;
       struct TALER_HashBlindedPlanchetsP planchets_h;
       struct TALER_HashBlindedPlanchetsP selected_h;
       bool no_blinding_seed;
       struct TALER_BlindingMasterSeedP blinding_seed;
       size_t num_cs_r_values;
       struct GNUNET_CRYPTO_CSPublicRPairP *cs_r_values;
       uint64_t cs_r_choices;
       size_t num_coins;
       uint64_t *denom_serials;
       struct TALER_BlindedDenominationSignature *denom_sigs;
     } refresh;
 
     struct
     {
       uint64_t shard;
       struct TALER_MerchantPublicKeyP merchant_pub;
       struct GNUNET_TIME_Timestamp wallet_timestamp;
       struct GNUNET_TIME_Timestamp exchange_timestamp;
       struct GNUNET_TIME_Timestamp refund_deadline;
       struct GNUNET_TIME_Timestamp wire_deadline;
       struct TALER_PrivateContractHashP h_contract_terms;
       bool no_wallet_data_hash;
       struct GNUNET_HashCode wallet_data_hash;
       struct TALER_WireSaltP wire_salt;
       struct TALER_FullPaytoHashP wire_target_h_payto;
       bool no_policy_details;
       uint64_t policy_details_serial_id;
       bool policy_blocked;
       struct TALER_Amount total_amount;
       struct TALER_Amount total_without_fee;
       struct TALER_MerchantSignatureP merchant_sig;
       bool done;
     } batch_deposits;
 
     struct
     {
       uint64_t batch_deposit_serial_id;
       struct TALER_CoinSpendPublicKeyP coin_pub;
       struct TALER_CoinSpendSignatureP coin_sig;
       struct TALER_Amount amount_with_fee;
     } coin_deposits;
 
     struct
     {
       struct TALER_CoinSpendPublicKeyP coin_pub;
       uint64_t batch_deposit_serial_id;
       struct TALER_MerchantSignatureP merchant_sig;
       uint64_t rtransaction_id;
       struct TALER_Amount amount_with_fee;
     } refunds;
 
     struct
     {
       struct GNUNET_TIME_Timestamp execution_date;
       struct TALER_WireTransferIdentifierRawP wtid_raw;
       struct TALER_FullPaytoHashP wire_target_h_payto;
       char *exchange_account_section;
       struct TALER_Amount amount;
     } wire_out;
 
     struct
     {
       uint64_t batch_deposit_serial_id;
       struct TALER_WireTransferIdentifierRawP wtid_raw;
     } aggregation_tracking;
 
     struct
     {
       char *wire_method;
       struct GNUNET_TIME_Timestamp start_date;
       struct GNUNET_TIME_Timestamp end_date;
       struct TALER_WireFeeSet fees;
       struct TALER_MasterSignatureP master_sig;
     } wire_fee;
 
     struct
     {
       struct GNUNET_TIME_Timestamp start_date;
       struct GNUNET_TIME_Timestamp end_date;
       struct TALER_GlobalFeeSet fees;
       struct GNUNET_TIME_Relative purse_timeout;
       struct GNUNET_TIME_Relative history_expiration;
       uint32_t purse_account_limit;
       struct TALER_MasterSignatureP master_sig;
     } global_fee;
 
     struct
     {
       struct TALER_CoinSpendPublicKeyP coin_pub;
       struct TALER_CoinSpendSignatureP coin_sig;
       union GNUNET_CRYPTO_BlindingSecretP coin_blind;
       struct TALER_Amount amount;
       struct GNUNET_TIME_Timestamp timestamp;
       uint64_t withdraw_serial_id;
     } recoup;
 
     struct
     {
       uint64_t known_coin_id;
       struct TALER_CoinSpendPublicKeyP coin_pub;
       struct TALER_CoinSpendSignatureP coin_sig;
       union GNUNET_CRYPTO_BlindingSecretP coin_blind;
       struct TALER_Amount amount;
       struct GNUNET_TIME_Timestamp timestamp;
       uint64_t rrc_serial;
     } recoup_refresh;
 
     struct
     {
       char *name;
       char *manifest;
     } extensions;
 
     struct
     {
       struct GNUNET_HashCode hash_code;
       json_t *policy_json;
       bool no_policy_json;
       struct GNUNET_TIME_Timestamp deadline;
       struct TALER_Amount commitment;
       struct TALER_Amount accumulated_total;
       struct TALER_Amount fee;
       struct TALER_Amount transferable;
       uint16_t fulfillment_state; /* will also be recomputed */
       uint64_t fulfillment_id;
       bool no_fulfillment_id;
     } policy_details;
 
     struct
     {
       struct GNUNET_TIME_Timestamp fulfillment_timestamp;
       char *fulfillment_proof;
       struct GNUNET_HashCode h_fulfillment_proof;
       struct GNUNET_HashCode *policy_hash_codes;
       size_t policy_hash_codes_count;
     } policy_fulfillments;
 
     struct
     {
       struct TALER_PurseContractPublicKeyP purse_pub;
       struct TALER_PurseMergePublicKeyP merge_pub;
       struct GNUNET_TIME_Timestamp purse_creation;
       struct GNUNET_TIME_Timestamp purse_expiration;
       struct TALER_PrivateContractHashP h_contract_terms;
       uint32_t age_limit;
       uint32_t flags;
       struct TALER_Amount amount_with_fee;
       struct TALER_Amount purse_fee;
       struct TALER_PurseContractSignatureP purse_sig;
     } purse_requests;
 
     struct
     {
       struct TALER_PurseContractPublicKeyP purse_pub;
       struct GNUNET_TIME_Timestamp action_timestamp;
       bool refunded;
     } purse_decision;
 
     struct
     {
       uint64_t partner_serial_id;
       struct TALER_ReservePublicKeyP reserve_pub;
       struct TALER_PurseContractPublicKeyP purse_pub;
       struct TALER_PurseMergeSignatureP merge_sig;
       struct GNUNET_TIME_Timestamp merge_timestamp;
     } purse_merges;
 
     struct
     {
       uint64_t partner_serial_id;
       struct TALER_PurseContractPublicKeyP purse_pub;
       struct TALER_CoinSpendPublicKeyP coin_pub;
       struct TALER_Amount amount_with_fee;
       struct TALER_CoinSpendSignatureP coin_sig;
     } purse_deposits;
 
     struct
     {
       struct TALER_ReservePublicKeyP reserve_pub;
       struct TALER_ReserveSignatureP reserve_sig;
       struct TALER_PurseContractPublicKeyP purse_pub;
       struct TALER_NormalizedPaytoHashP wallet_h_payto;
     } account_merges;
 
     struct
     {
       struct TALER_ReservePublicKeyP reserve_pub;
       struct TALER_ReserveSignatureP reserve_sig;
       struct GNUNET_TIME_Timestamp request_timestamp;
       struct TALER_Amount history_fee;
     } history_requests;
 
     struct
     {
       struct TALER_ReservePublicKeyP reserve_pub;
       struct GNUNET_TIME_Timestamp close_timestamp;
       struct TALER_ReserveSignatureP reserve_sig;
       struct TALER_Amount close;
       struct TALER_Amount close_fee;
       struct TALER_FullPayto payto_uri;
     } close_requests;
 
     struct
     {
       struct TALER_WadIdentifierP wad_id;
       uint64_t partner_serial_id;
       struct TALER_Amount amount;
       struct GNUNET_TIME_Timestamp execution_time;
     } wads_out;
 
     struct
     {
       uint64_t wad_out_serial_id;
       struct TALER_ReservePublicKeyP reserve_pub;
       struct TALER_PurseContractPublicKeyP purse_pub;
       struct TALER_PrivateContractHashP h_contract;
       struct GNUNET_TIME_Timestamp purse_expiration;
       struct GNUNET_TIME_Timestamp merge_timestamp;
       struct TALER_Amount amount_with_fee;
       struct TALER_Amount wad_fee;
       struct TALER_Amount deposit_fees;
       struct TALER_ReserveSignatureP reserve_sig;
       struct TALER_PurseContractSignatureP purse_sig;
     } wads_out_entries;
 
     struct
     {
       struct TALER_WadIdentifierP wad_id;
       char *origin_exchange_url;
       struct TALER_Amount amount;
       struct GNUNET_TIME_Timestamp arrival_time;
     } wads_in;
 
     struct
     {
       uint64_t wad_in_serial_id;
       struct TALER_ReservePublicKeyP reserve_pub;
       struct TALER_PurseContractPublicKeyP purse_pub;
       struct TALER_PrivateContractHashP h_contract;
       struct GNUNET_TIME_Timestamp purse_expiration;
       struct GNUNET_TIME_Timestamp merge_timestamp;
       struct TALER_Amount amount_with_fee;
       struct TALER_Amount wad_fee;
       struct TALER_Amount deposit_fees;
       struct TALER_ReserveSignatureP reserve_sig;
       struct TALER_PurseContractSignatureP purse_sig;
     } wads_in_entries;
 
     struct
     {
       struct TALER_WireTransferIdentifierRawP wtid;
       char *account_section;
       struct TALER_FullPayto payto_uri;
       struct GNUNET_TIME_Timestamp trigger_date;
       struct TALER_Amount amount;
       struct TALER_MasterSignatureP master_sig;
     } profit_drains;
 
     struct
     {
       struct TALER_PurseContractPublicKeyP purse_pub;
       struct TALER_PurseContractSignatureP purse_sig;
     } purse_deletion;
 
     struct
     {
       struct TALER_HashBlindedPlanchetsP planchets_h;
       struct GNUNET_TIME_Timestamp execution_date;
       struct TALER_Amount amount_with_fee;
       struct TALER_ReservePublicKeyP reserve_pub;
       struct TALER_ReserveSignatureP reserve_sig;
       bool age_proof_required;
       uint16_t max_age;
       uint16_t noreveal_index;
       struct TALER_HashBlindedPlanchetsP selected_h;
       bool no_blinding_seed;
       struct TALER_BlindingMasterSeedP blinding_seed;
       size_t num_cs_r_values;
       struct GNUNET_CRYPTO_CSPublicRPairP *cs_r_values;
       uint64_t cs_r_choices;
       size_t num_coins;
       uint64_t *denom_serials;
       struct TALER_BlindedDenominationSignature *denom_sigs;
     } withdraw;
 
   } details;
 
 };
 
 
 /**
  * Function called on data to replicate in the auditor's database.
  *
  * @param cls closure
  * @param td record from an exchange table
  * @return #GNUNET_OK to continue to iterate,
  *         #GNUNET_SYSERR to fail with an error
  */
 typedef int
 (*TALER_EXCHANGEDB_ReplicationCallback)(
   void *cls,
   const struct TALER_EXCHANGEDB_TableData *td);
 
 
 /**
  * @brief All information about a denomination key (which is used to
  * sign coins into existence).
  */
 struct TALER_EXCHANGEDB_DenominationKey
 {
   /**
    * The private key of the denomination.  Will be NULL if the private
    * key is not available (this is the case after the key has expired
    * for signing coins, but is still valid for depositing coins).
    */
   struct TALER_DenominationPrivateKey denom_priv;
 
   /**
    * Decoded denomination public key (the hash of it is in
    * @e issue, but we sometimes need the full public key as well).
    */
   struct TALER_DenominationPublicKey denom_pub;
 
   /**
    * Signed public information about a denomination key.
    */
   struct TALER_EXCHANGEDB_DenominationKeyInformation issue;
 };
 
 
 /**
  * @brief Information we keep on bank transfer(s) that established a reserve.
  */
 struct TALER_EXCHANGEDB_BankTransfer
 {
 
   /**
    * Public key of the reserve that was filled.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * Amount that was transferred to the exchange.
    */
   struct TALER_Amount amount;
 
   /**
    * When did the exchange receive the incoming transaction?
    * (This is the execution date of the exchange's database,
    * the execution date of the bank should be in @e wire).
    */
   struct GNUNET_TIME_Timestamp execution_date;
 
   /**
    * Detailed wire information about the sending account
    * in "payto://" format.
    */
   struct TALER_FullPayto sender_account_details;
 
   /**
    * Data uniquely identifying the wire transfer (wire transfer-type specific)
    */
   uint64_t wire_reference;
 
 };
 
 
 /**
  * @brief Information we keep on bank transfer(s) that
  * closed a reserve.
  */
 struct TALER_EXCHANGEDB_ClosingTransfer
 {
 
   /**
    * Public key of the reserve that was depleted.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * Amount that was transferred from 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_Timestamp execution_date;
 
   /**
    * Detailed wire information about the receiving account
    * in payto://-format.
    */
   struct TALER_FullPayto receiver_account_details;
 
   /**
    * Detailed wire transfer information that uniquely identifies the
    * wire transfer.
    */
   struct TALER_WireTransferIdentifierRawP wtid;
 
 };
 
 
 /**
  * @brief A summary of a Reserve
  */
 struct TALER_EXCHANGEDB_Reserve
 {
   /**
    * The reserve's public key.  This uniquely identifies the reserve
    */
   struct TALER_ReservePublicKeyP pub;
 
   /**
    * The balance amount existing in the reserve
    */
   struct TALER_Amount balance;
 
   /**
    * The expiration date of this reserve; funds will be wired back
    * at this time.
    */
   struct GNUNET_TIME_Timestamp expiry;
 
   /**
    * The legal expiration date of this reserve; we will forget about
    * it at this time.
    */
   struct GNUNET_TIME_Timestamp gc;
 };
 
 
 /**
  * Meta data about a denomination public key.
  * If this is changed, you must also adjust
  * taler-exchange-httpd-post-management-keys.c::denomination_meta_cmp().
  */
 struct TALER_EXCHANGEDB_DenominationKeyMetaData
 {
   /**
    * Serial of the denomination key as in the DB.
    * Can be used calls to stored procedures in order to spare
    * additional lookups.
    */
   uint64_t serial;
 
   /**
    * Start time of the validity period for this key.
    */
   struct GNUNET_TIME_Timestamp start;
 
   /**
    * The exchange will sign fresh coins between @e start and this time.
    * @e expire_withdraw will be somewhat larger than @e start to
    * ensure a sufficiently large anonymity set, while also allowing
    * the Exchange to limit the financial damage in case of a key being
    * compromised.  Thus, exchanges with low volume are expected to have a
    * longer withdraw period (@e expire_withdraw - @e start) than exchanges
    * with high transaction volume.  The period may also differ between
    * types of coins.  A exchange may also have a few denomination keys
    * with the same value with overlapping validity periods, to address
    * issues such as clock skew.
    */
   struct GNUNET_TIME_Timestamp expire_withdraw;
 
   /**
    * Coins signed with the denomination key must be spent or refreshed
    * between @e start and this expiration time.  After this time, the
    * exchange will refuse transactions involving this key as it will
    * "drop" the table with double-spending information (shortly after)
    * this time.  Note that wallets should refresh coins significantly
    * before this time to be on the safe side.  @e expire_deposit must be
    * significantly larger than @e expire_withdraw (by months or even
    * years).
    */
   struct GNUNET_TIME_Timestamp expire_deposit;
 
   /**
    * When do signatures with this denomination key become invalid?
    * After this point, these signatures cannot be used in (legal)
    * disputes anymore, as the Exchange is then allowed to destroy its side
    * of the evidence.  @e expire_legal is expected to be significantly
    * larger than @e expire_deposit (by a year or more).
    */
   struct GNUNET_TIME_Timestamp expire_legal;
 
   /**
    * The value of the coins signed with this denomination key.
    */
   struct TALER_Amount value;
 
   /**
    * The fees the exchange charges for operations with
    * coins of this denomination.
    */
   struct TALER_DenomFeeSet fees;
 
   /**
    * Age restriction for the denomination. (can be zero). If not zero, the bits
    * set in the mask mark the edges at the beginning of a next age group.  F.e.
    * for the age groups
    *     0-7, 8-9, 10-11, 12-14, 14-15, 16-17, 18-21, 21-*
    * the following bits are set:
    *
    *   31     24        16        8         0
    *   |      |         |         |         |
    *   oooooooo  oo1oo1o1  o1o1o1o1  ooooooo1
    *
    * A value of 0 means that the denomination does not support the extension for
    * age-restriction.
    */
   struct TALER_AgeMask age_mask;
 };
 
 
 /**
  * Signature of a function called with information about the exchange's
  * denomination keys.
  *
  * @param cls closure with a `struct TEH_KeyStateHandle *`
  * @param denom_pub public key of the denomination
  * @param h_denom_pub hash of @a denom_pub
  * @param meta meta data information about the denomination type (value, expirations, fees)
  * @param master_sig master signature affirming the validity of this denomination
  * @param recoup_possible true if the key was revoked and clients can currently recoup
  *        coins of this denomination
  */
 typedef void
 (*TALER_EXCHANGEDB_DenominationsCallback)(
   void *cls,
   const struct TALER_DenominationPublicKey *denom_pub,
   const struct TALER_DenominationHashP *h_denom_pub,
   const struct TALER_EXCHANGEDB_DenominationKeyMetaData *meta,
   const struct TALER_MasterSignatureP *master_sig,
   bool recoup_possible);
 
 
 /**
  * Signature of a function called with information about the exchange's
  * online signing keys.
  *
  * @param cls closure with a `struct TEH_KeyStateHandle *`
  * @param exchange_pub public key of the exchange
  * @param meta meta data information about the signing type (expirations)
  * @param master_sig master signature affirming the validity of this denomination
  */
 typedef void
 (*TALER_EXCHANGEDB_ActiveSignkeysCallback)(
   void *cls,
   const struct TALER_ExchangePublicKeyP *exchange_pub,
   const struct TALER_EXCHANGEDB_SignkeyMetaData *meta,
   const struct TALER_MasterSignatureP *master_sig);
 
 
 /**
  * Function called on all legitimization operations
  * we have performed for the given account so far
  * (and that have not yet expired).
  *
  * @param cls closure
  * @param kyc_provider_name name of the provider
  *        of the respective KYC process
  * @param provider_user_id UID at a provider (can be NULL)
  * @param legi_id legitimization process ID (can be NULL)
  */
 typedef void
 (*TALER_EXCHANGEDB_LegitimizationProcessCallback)(
   void *cls,
   const char *kyc_provider_name,
   const char *provider_user_id,
   const char *legi_id);
 
 
 /**
  * Function called with information about the exchange's auditors.
  *
  * @param cls closure with a `struct TEH_KeyStateHandle *`
  * @param auditor_pub the public key of the auditor
  * @param auditor_url URL of the REST API of the auditor
  * @param auditor_name human readable official name of the auditor
  */
 typedef void
 (*TALER_EXCHANGEDB_AuditorsCallback)(
   void *cls,
   const struct TALER_AuditorPublicKeyP *auditor_pub,
   const char *auditor_url,
   const char *auditor_name);
 
 
 /**
  * Function called with information about the denominations
  * audited by the exchange's auditors.
  *
  * @param cls closure with a `struct TEH_KeyStateHandle *`
  * @param auditor_pub the public key of an auditor
  * @param h_denom_pub hash of a denomination key audited by this auditor
  * @param auditor_sig signature from the auditor affirming this
  */
 typedef void
 (*TALER_EXCHANGEDB_AuditorDenominationsCallback)(
   void *cls,
   const struct TALER_AuditorPublicKeyP *auditor_pub,
   const struct TALER_DenominationHashP *h_denom_pub,
   const struct TALER_AuditorSignatureP *auditor_sig);
 
 
 /**
  * @brief Information we keep for a withdrawn coin to reproduce
  * the /batch-withdraw operation if needed, and to have proof
  * that a reserve was drained by this amount.
  *
  * @note This structure will be removed at some point after v24 of the protocol
  * FIXME: to be deleted.
  */
 struct TALER_EXCHANGEDB_CollectableBlindcoin
 {
 
   /**
    * Our (blinded) signature over the (blinded) coin.
    */
   struct TALER_BlindedDenominationSignature sig;
 
   /**
    * Hash of the denomination key (which coin was generated).
    */
   struct TALER_DenominationHashP denom_pub_hash;
 
   /**
    * Value of the coin being exchangeed (matching the denomination key)
    * 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;
 
   /**
    * Withdrawal fee charged by the exchange.  This must match the Exchange's
    * denomination key's withdrawal fee.  If the client puts in an
    * invalid withdrawal fee (too high or too low) that does not match
    * the Exchange's denomination key, the withdraw operation is invalid
    * and will be rejected by the exchange.  The @e amount_with_fee minus
    * 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
    * verify a exchange's accounting without needing to access the
    * respective denomination key information each time.
    */
   struct TALER_Amount withdraw_fee;
 
   /**
    * Public key of the reserve that was drained.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * Hash over the blinded message, needed to verify
    * the @e reserve_sig.
    */
   struct TALER_BlindedCoinHashP h_coin_envelope;
 
   /**
    * Signature confirming the withdrawal, matching @e reserve_pub,
    * @e denom_pub and @e h_coin_envelope.
    */
   struct TALER_ReserveSignatureP reserve_sig;
 };
 
 /**
  * @brief Information we keep for a withdraw request
  * to reproduce the /withdraw operation if needed, and to have proof
  * that a reserve was drained by this amount.
  */
 struct TALER_EXCHANGEDB_Withdraw
 {
   /**
    * Total amount (with fee) committed to withdraw
    */
   struct TALER_Amount amount_with_fee;
 
   /**
    * true, if a proof of age was required following this withdraw,
    * in a subsequent call to /reveal-withdraw.
    * In this case, @e max_age, @e h_commitment and
    * @e noreveal_index are to be taken into account
    */
   bool age_proof_required;
 
   /**
    * Maximum age (in years) that the coins are restricted to,
    * if ``age_proof_required`` is true.
    */
   uint16_t max_age;
 
   /**
    * If ``age_proof_required`` is true, index (smaller #TALER_CNC_KAPPA)
    * which the exchange has chosen to keep unrevealed
    * during the next cut and choose (aka /reveal-age) step.
    * This value applies to all n coins in the commitment.
    */
   uint16_t noreveal_index;
 
   /**
    * If @e age_proof_required is true, the running hash over all blinded coin
    * envelope's TALER_BlindedCoinHashP values.
    * It runs over ``kappa*num_coins``, starting with the hashes for the coins
    * for kappa index=0, then index=1 etc.,
    * i.e. h[0][0]...h[0][n-1]h[1][0]...h[1][n-1]...h[κ-1][0]...h[κ-1][n-1]
    */
   struct TALER_HashBlindedPlanchetsP planchets_h;
 
   /**
    * Public key of the reserve that was drained.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * Signature confirming the withdrawal commitment
    */
   struct TALER_ReserveSignatureP reserve_sig;
 
   /**
    * Number of coins to be withdrawn.
    */
   size_t num_coins;
 
   /**
    * The hash of the blinded coin envelopes which are signed by the exchange.
    * In case of @e age_proof_required = true, this is the hash over the chosen coins'
    * envelopes (according to @e noreveal_index) from the request, which contained
    * kappa*num_coins blinded coins envelopes.
    */
   struct TALER_HashBlindedPlanchetsP selected_h;
 
   /**
    * Array of @a num_coins denomination signatures of the blinded coins @a
    * h_coin_evs.
    */
   struct TALER_BlindedDenominationSignature *denom_sigs;
 
   /**
    * Array of @a num_coins serial id's of the denominations, corresponding to
    * the coins in @a h_coin_evs.
    * If @e age_proof_required is true, the denominations MUST support age restriction.
    */
   uint64_t *denom_serials;
 
   /**
    * If true, no @e blinding_seed is set and @e num_cs_r_values is 0.
    */
   bool no_blinding_seed;
 
   /**
    * If @e no_blinding_seed is false, the blinding seed for the nonces needed for
    * blind CS signatures.
    */
   struct TALER_BlindingMasterSeedP blinding_seed;
 
   /**
    * Number of elements in @e cs_r_values.
    * Only non-zero IF @e  age_proof_required is true AND any of the denomination
    * has a cipher of type CS.
    */
   size_t num_cs_r_values;
 
   /**
    * Array @e num_r_pubs of public R-value pairs for CS that were generated from the
    * @e blinding_seed, a coin's index and the denomination's private key during the
    * the /withdraw request, to ensure idempotency in case of expiration of a denomination.
    * NULL if @e num_r_pub is 0 (or @e age_proof_required is false).
    */
   struct GNUNET_CRYPTO_CSPublicRPairP *cs_r_values;
 
   /**
    * The bitvector encoding the choices per coin, made by the exchange,
    * for the R-values in @e cs_r_values.  The value is encoded in NBO
    * and the lowest bit corresponds to the pair at index 0 in @e  cs_r_values.
    */
   uint64_t cs_r_choices;
 
   /**
    * [out]-Array of @a num_coins hashes of the public keys of the denominations
    * identified by @e denom_serials.  This field is only set when calling
    * get_reserve_history().
    */
   struct TALER_DenominationHashP *denom_pub_hashes;
 };
 
 
 /**
  * Information the exchange records about a recoup request
  * in a reserve history.
  */
 struct TALER_EXCHANGEDB_Recoup
 {
 
   /**
    * Information about the coin that was paid back.
    */
   struct TALER_CoinPublicInfo coin;
 
   /**
    * Blinding factor supplied to prove to the exchange that
    * the coin came from this reserve.
    */
   union GNUNET_CRYPTO_BlindingSecretP coin_blind;
 
   /**
    * Signature of the coin of type
    * #TALER_SIGNATURE_WALLET_COIN_RECOUP.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
   /**
    * Public key of the reserve the coin was paid back into.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * How much was the coin still worth at this time?
    */
   struct TALER_Amount value;
 
   /**
    * When did the recoup operation happen?
    */
   struct GNUNET_TIME_Timestamp timestamp;
 
 };
 
 
 /**
  * Public key to which a nonce is locked.
  */
 union TALER_EXCHANGEDB_NonceLockTargetP
 {
   /**
    * Nonce is locked to this coin key.
    */
   struct TALER_CoinSpendPublicKeyP coin;
 
   /**
    * Nonce is locked to this reserve key.
    */
   struct TALER_ReservePublicKeyP reserve;
 };
 
 
 /**
  * Information the exchange records about a recoup request
  * in a coin history.
  */
 struct TALER_EXCHANGEDB_RecoupListEntry
 {
 
   /**
    * Blinding factor supplied to prove to the exchange that
    * the coin came from this reserve.
    */
   union GNUNET_CRYPTO_BlindingSecretP coin_blind;
 
   /**
    * Signature of the coin of type
    * #TALER_SIGNATURE_WALLET_COIN_RECOUP.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
   /**
    * Hash of the public denomination key used to sign the coin.
    */
   struct TALER_DenominationHashP h_denom_pub;
 
   /**
    * Public key of the reserve the coin was paid back into.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * How much was the coin still worth at this time?
    */
   struct TALER_Amount value;
 
   /**
    * When did the /recoup operation happen?
    */
   struct GNUNET_TIME_Timestamp timestamp;
 
 };
 
 
 /**
  * Information the exchange records about a recoup-refresh request in
  * a coin transaction history.
  */
 struct TALER_EXCHANGEDB_RecoupRefreshListEntry
 {
 
   /**
    * Information about the coin that was paid back
    * (NOT the coin we are considering the history of!)
    */
   struct TALER_CoinPublicInfo coin;
 
   /**
    * Blinding factor supplied to prove to the exchange that
    * the coin came from this @e old_coin_pub.
    */
   union GNUNET_CRYPTO_BlindingSecretP coin_blind;
 
   /**
    * Signature of the coin of type
    * #TALER_SIGNATURE_WALLET_COIN_RECOUP.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
   /**
    * Public key of the old coin that the refreshed coin was paid back to.
    */
   struct TALER_CoinSpendPublicKeyP old_coin_pub;
 
   /**
    * How much was the coin still worth at this time?
    */
   struct TALER_Amount value;
 
   /**
    * When did the recoup operation happen?
    */
   struct GNUNET_TIME_Timestamp timestamp;
 
 };
 
 
 /**
  * Details about a purse merge operation.
  */
 struct TALER_EXCHANGEDB_PurseMerge
 {
 
   /**
    * Public key of the reserve the coin was merged into.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * Amount in the purse, with fees.
    */
   struct TALER_Amount amount_with_fee;
 
   /**
    * Fee paid for the purse.
    */
   struct TALER_Amount purse_fee;
 
   /**
    * Hash over the contract.
    */
   struct TALER_PrivateContractHashP h_contract_terms;
 
   /**
    * Merge capability key.
    */
   struct TALER_PurseMergePublicKeyP merge_pub;
 
   /**
    * Purse public key.
    */
   struct TALER_PurseContractPublicKeyP purse_pub;
 
   /**
    * Signature by the reserve approving the merge.
    */
   struct TALER_ReserveSignatureP reserve_sig;
 
   /**
    * When was the merge made.
    */
   struct GNUNET_TIME_Timestamp merge_timestamp;
 
   /**
    * When was the purse set to expire.
    */
   struct GNUNET_TIME_Timestamp purse_expiration;
 
   /**
    * Minimum age required for depositing into the purse.
    */
   uint32_t min_age;
 
   /**
    * Flags of the purse.
    */
   enum TALER_WalletAccountMergeFlags flags;
 
   /**
    * true if the purse was actually successfully merged,
    * false if the @e purse_fee was charged but the
    * @e amount was not credited to the reserve.
    */
   bool merged;
 };
 
 
 /**
  * Details about a (paid for) reserve history request.
  */
 struct TALER_EXCHANGEDB_HistoryRequest
 {
   /**
    * Public key of the reserve the history request was for.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * Fee paid for the request.
    */
   struct TALER_Amount history_fee;
 
   /**
    * When was the request made.
    */
   struct GNUNET_TIME_Timestamp request_timestamp;
 
   /**
    * Signature by the reserve approving the history request.
    */
   struct TALER_ReserveSignatureP reserve_sig;
 };
 
 
 /**
  * Details about a (paid for) reserve open request.
  */
 struct TALER_EXCHANGEDB_OpenRequest
 {
   /**
    * Public key of the reserve the open request was for.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * Fee paid for the request from the reserve.
    */
   struct TALER_Amount open_fee;
 
   /**
    * When was the request made.
    */
   struct GNUNET_TIME_Timestamp request_timestamp;
 
   /**
    * How long was the reserve supposed to be open.
    */
   struct GNUNET_TIME_Timestamp reserve_expiration;
 
   /**
    * Signature by the reserve approving the open request,
    * with purpose #TALER_SIGNATURE_WALLET_RESERVE_OPEN.
    */
   struct TALER_ReserveSignatureP reserve_sig;
 
   /**
    * How many open purses should be included with the
    * open reserve?
    */
   uint32_t purse_limit;
 
 };
 
 
 /**
  * Details about an (explicit) reserve close request.
  */
 struct TALER_EXCHANGEDB_CloseRequest
 {
   /**
    * Public key of the reserve the history request was for.
    */
   struct TALER_ReservePublicKeyP reserve_pub;
 
   /**
    * When was the request made.
    */
   struct GNUNET_TIME_Timestamp request_timestamp;
 
   /**
    * Hash of the payto://-URI of the target account
    * for the closure, or all zeros for the reserve
    * origin account.
    */
   struct TALER_FullPaytoHashP target_account_h_payto;
 
   /**
    * Signature by the reserve approving the history request.
    */
   struct TALER_ReserveSignatureP reserve_sig;
 
 };
 
 
 /**
  * @brief Types of operations on a reserve.
  */
 enum TALER_EXCHANGEDB_ReserveOperation
 {
   /**
    * Money was deposited into the reserve via a bank transfer.
    * This is how customers establish a reserve at the exchange.
    */
   TALER_EXCHANGEDB_RO_BANK_TO_EXCHANGE = 0,
 
   /**
    * A batch of coins was withdrawn from the reserve using /withdraw.
    */
   TALER_EXCHANGEDB_RO_WITHDRAW_COINS = 1,
 
   /**
    * A coin was returned to the reserve using /recoup.
    */
   TALER_EXCHANGEDB_RO_RECOUP_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,
 
   /**
    * Event where a purse was merged into a reserve.
    */
   TALER_EXCHANGEDB_RO_PURSE_MERGE = 4,
 
   /**
    * Event where a wallet paid for a full reserve history.
    */
   TALER_EXCHANGEDB_RO_HISTORY_REQUEST = 5,
 
   /**
    * Event where a wallet paid to open a reserve for longer.
    */
   TALER_EXCHANGEDB_RO_OPEN_REQUEST = 6,
 
   /**
    * Event where a wallet requested a reserve to be closed.
    */
   TALER_EXCHANGEDB_RO_CLOSE_REQUEST = 7,
 
 };
 
 
 /**
  * @brief Reserve history as a linked list.  Lists all of the transactions
  * associated with this reserve (such as the bank transfers that
  * established the reserve and all /withdraw operations we have done
  * since).
  */
 struct TALER_EXCHANGEDB_ReserveHistory
 {
 
   /**
    * Next entry in the reserve history.
    */
   struct TALER_EXCHANGEDB_ReserveHistory *next;
 
   /**
    * Offset of this entry in the reserve history.
    * Corresponds to the reserve_history_serial_id in the database.
    */
   uint64_t history_offset;
 
   /**
    * Type of the event, determines @e details.
    */
   enum TALER_EXCHANGEDB_ReserveOperation type;
 
   /**
    * Details of the operation, depending on @e type.
    */
   union
   {
 
     /**
      * Details about a bank transfer to the exchange (reserve
      * was established).
      */
     struct TALER_EXCHANGEDB_BankTransfer *bank;
 
     /**
      * Details about a /withdraw operation.
      */
     struct TALER_EXCHANGEDB_Withdraw *withdraw;
 
     /**
      * Details about a /recoup operation.
      */
     struct TALER_EXCHANGEDB_Recoup *recoup;
 
     /**
      * Details about a bank transfer from the exchange (reserve
      * was closed).
      */
     struct TALER_EXCHANGEDB_ClosingTransfer *closing;
 
     /**
      * Details about a purse merge operation.
      */
     struct TALER_EXCHANGEDB_PurseMerge *merge;
 
     /**
      * Details about a (paid for) reserve history request.
      */
     struct TALER_EXCHANGEDB_HistoryRequest *history;
 
     /**
      * Details about a (paid for) open reserve request.
      */
     struct TALER_EXCHANGEDB_OpenRequest *open_request;
 
     /**
      * Details about an (explicit) reserve close request.
      */
     struct TALER_EXCHANGEDB_CloseRequest *close_request;
 
   } details;
 
 };
 
 
 /**
  * @brief Data about a coin for a deposit operation.
  */
 struct TALER_EXCHANGEDB_CoinDepositInformation
 {
   /**
    * 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
    * by @e h_wire in relation to the proposal data identified
    * by @e h_contract_terms.
    */
   struct TALER_CoinSpendSignatureP csig;
 
   /**
    * Fraction of the coin's remaining value to be deposited, including
    * depositing fee (if any).  The coin is identified by @e coin_pub.
    */
   struct TALER_Amount amount_with_fee;
 
 };
 
 
 /**
  * @brief Data from a batch deposit operation.
  */
 struct TALER_EXCHANGEDB_BatchDeposit
 {
 
   /**
    * Public key of the merchant.  Enables later identification
    * of the merchant in case of a need to rollback transactions.
    */
   struct TALER_MerchantPublicKeyP merchant_pub;
 
   /**
    * Signature of the merchant over the contract, of purpose
    * #TALER_SIGNATURE_MERCHANT_CONTRACT.
    */
   struct TALER_MerchantSignatureP merchant_sig;
 
   /**
    * Hash over the proposal data between merchant and customer
    * (remains unknown to the Exchange).
    */
   struct TALER_PrivateContractHashP h_contract_terms;
 
   /**
    * Hash over additional inputs by the wallet.
    */
   struct GNUNET_HashCode wallet_data_hash;
 
   /**
    * Unsalted hash over @e receiver_wire_account.
    */
   struct TALER_FullPaytoHashP wire_target_h_payto;
 
   /**
    * Salt used by the merchant to compute "h_wire".
    */
   struct TALER_WireSaltP wire_salt;
 
   /**
    * Time when this request was generated.  Used, for example, to
    * assess when (roughly) the income was achieved for tax purposes.
    * Note that the Exchange will only check that the timestamp is not "too
    * 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
    * set any timestamp.  Also, the Exchange must accept very old deposit
    * 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_Timestamp wallet_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_Timestamp refund_deadline;
 
   /**
    * 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_Timestamp wire_deadline;
 
   /**
    * Row ID of the policy details; 0 if no policy applies.
    */
   uint64_t policy_details_serial_id;
 
   /**
    * Information about the receiver for executing the transaction.  URI in
    * payto://-format.
    */
   struct TALER_FullPayto receiver_wire_account;
 
   /**
    * Optional extra information to include in the wire transfer
    * subject.
    */
   const char *extra_wire_subject_metadata;
 
   /**
    * Array about the coins that are being deposited.
    */
   const struct TALER_EXCHANGEDB_CoinDepositInformation *cdis;
 
   /**
    * Length of the @e cdis array.
    */
   unsigned int num_cdis;
 
   /**
    * False if @e wallet_data_hash was provided
    */
   bool no_wallet_data_hash;
 
   /**
    * True if further processing is blocked by policy.
    */
   bool policy_blocked;
 
 };
 
 
 /**
  * @brief Data from 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
  * (as determined by transaction ID).
  */
 struct TALER_EXCHANGEDB_Deposit
 {
   /**
    * 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
    * by @e h_wire in relation to the proposal data identified
    * by @e h_contract_terms.
    */
   struct TALER_CoinSpendSignatureP csig;
 
   /**
    * Public key of the merchant.  Enables later identification
    * of the merchant in case of a need to rollback transactions.
    */
   struct TALER_MerchantPublicKeyP merchant_pub;
 
   /**
    * Hash over the proposal data between merchant and customer
    * (remains unknown to the Exchange).
    */
   struct TALER_PrivateContractHashP h_contract_terms;
 
   /**
    * Salt used by the merchant to compute "h_wire".
    */
   struct TALER_WireSaltP wire_salt;
 
   /**
    * Hash over inputs from the wallet to customize the contract.
    */
   struct GNUNET_HashCode wallet_data_hash;
 
   /**
    * Hash over the policy data for this deposit (remains unknown to the
    * Exchange).  Needed for the verification of the deposit's signature
    */
   struct TALER_ExtensionPolicyHashP h_policy;
 
   /**
    * Time when this request was generated.  Used, for example, to
    * assess when (roughly) the income was achieved for tax purposes.
    * Note that the Exchange will only check that the timestamp is not "too
    * 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
    * set any timestamp.  Also, the Exchange must accept very old deposit
    * 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_Timestamp 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_Timestamp refund_deadline;
 
   /**
    * 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_Timestamp wire_deadline;
 
   /**
    * Fraction of the coin's remaining value to be deposited, including
    * depositing fee (if any).  The coin is identified by @e coin_pub.
    */
   struct TALER_Amount amount_with_fee;
 
   /**
    * Depositing fee.
    */
   struct TALER_Amount deposit_fee;
 
   /**
    * Information about the receiver for executing the transaction.  URI in
    * payto://-format.
    */
   struct TALER_FullPayto receiver_wire_account;
 
   /**
    * True if @e policy_json was provided
    */
   bool has_policy;
 
   /**
    * True if @e wallet_data_hash is not in use.
    */
   bool no_wallet_data_hash;
 
 };
 
 
 /**
  * @brief Specification for a deposit operation in the
  * `struct TALER_EXCHANGEDB_TransactionList`.
  */
 struct TALER_EXCHANGEDB_DepositListEntry
 {
 
   /**
    * ECDSA signature affirming that the customer intends
    * this coin to be deposited at the merchant identified
    * by @e h_wire in relation to the proposal data identified
    * by @e h_contract_terms.
    */
   struct TALER_CoinSpendSignatureP csig;
 
   /**
    * Public key of the merchant.  Enables later identification
    * of the merchant in case of a need to rollback transactions.
    */
   struct TALER_MerchantPublicKeyP merchant_pub;
 
   /**
    * Hash over the proposa data between merchant and customer
    * (remains unknown to the Exchange).
    */
   struct TALER_PrivateContractHashP h_contract_terms;
 
   /**
    * Hash over inputs from the wallet to customize the contract.
    */
   struct GNUNET_HashCode wallet_data_hash;
 
   /**
    * Hash of the public denomination key used to sign the coin.
    */
   struct TALER_DenominationHashP h_denom_pub;
 
   /**
    * Age commitment hash, if applicable to the denomination.  Should be all
    * zeroes if age commitment is not applicable to the denonimation.
    */
   struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * Salt used to compute h_wire from the @e receiver_wire_account.
    */
   struct TALER_WireSaltP wire_salt;
 
   /**
    * Hash over the policy data for this deposit (remains unknown to the
    * Exchange).  Needed for the verification of the deposit's signature
    */
   struct TALER_ExtensionPolicyHashP h_policy;
 
   /**
    * Fraction of the coin's remaining value to be deposited, including
    * depositing fee (if any).  The coin is identified by @e coin_pub.
    */
   struct TALER_Amount amount_with_fee;
 
   /**
    * Depositing fee.
    */
   struct TALER_Amount deposit_fee;
 
   /**
    * Time when this request was generated.  Used, for example, to
    * assess when (roughly) the income was achieved for tax purposes.
    * Note that the Exchange will only check that the timestamp is not "too
    * 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
    * set any timestamp.  Also, the Exchange must accept very old deposit
    * 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_Timestamp 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_Timestamp refund_deadline;
 
   /**
    * 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_Timestamp wire_deadline;
 
   /**
    * Detailed information about the receiver for executing the transaction.
    * URL in payto://-format.
    */
   struct TALER_FullPayto receiver_wire_account;
 
   /**
    * true, if age commitment is not applicable
    */
   bool no_age_commitment;
 
   /**
    * true, if wallet data hash is not present
    */
   bool no_wallet_data_hash;
 
   /**
    * True if a policy was provided with the deposit request
    */
   bool has_policy;
 
   /**
    * Has the deposit been wired?
    */
   bool done;
 
 };
 
 
 /**
  * @brief Specification for a refund operation in a coin's transaction list.
  */
 struct TALER_EXCHANGEDB_RefundListEntry
 {
 
   /**
    * Public key of the merchant.
    */
   struct TALER_MerchantPublicKeyP merchant_pub;
 
   /**
    * Signature from the merchant affirming the refund.
    */
   struct TALER_MerchantSignatureP merchant_sig;
 
   /**
    * Hash over the proposal data between merchant and customer
    * (remains unknown to the Exchange).
    */
   struct TALER_PrivateContractHashP h_contract_terms;
 
   /**
    * 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;
 
 };
 
 
 /**
  * @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;
 
   /**
    * Details about the refund.
    */
   struct TALER_EXCHANGEDB_RefundListEntry details;
 
 };
 
 
 /**
  * @brief Specification for coin in a melt operation.
  */
 struct TALER_EXCHANGEDB_Refresh
 {
   /**
    * Information about the coin that is being melted.
    */
   struct TALER_CoinPublicInfo coin;
 
   /**
    * Signature over the melting operation.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
   /**
    * Refresh commitment this coin is melted into.
    */
   struct TALER_RefreshCommitmentP rc;
 
   /**
    * 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.
    */
   struct TALER_Amount amount_with_fee;
 
   /**
    * Index (smaller #TALER_CNC_KAPPA) which the exchange has chosen to not
    * have revealed during cut and choose.
    */
   uint32_t noreveal_index;
 
 };
 
 
 /**
  * Information about a /coins/$COIN_PUB/melt operation in a coin transaction history.
  */
 struct TALER_EXCHANGEDB_MeltListEntry
 {
 
   /**
    * Signature over the melting operation.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
   /**
    * Refresh commitment this coin is melted into.
    */
   struct TALER_RefreshCommitmentP rc;
 
   /**
    * Hash of the public denomination key used to sign the coin.
    */
   struct TALER_DenominationHashP h_denom_pub;
 
   /**
    * Hash of the age commitment used to sign the coin, if age restriction was
    * applicable to the denomination.  May be all zeroes if no age restriction
    * applies.
    */
   struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * true, if no @e h_age_commitment is applicable
    */
   bool no_age_commitment;
 
   /**
    * 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.
    */
   struct TALER_Amount amount_with_fee;
 
   /**
    * Melt fee the exchange charged.
    */
   struct TALER_Amount melt_fee;
 
   /**
    * Index (smaller #TALER_CNC_KAPPA) which the exchange has chosen to not
    * have revealed during cut and choose.
    */
   uint32_t noreveal_index;
 
   /**
    * The refresh seed that was used for the melt operation
    */
   struct TALER_PublicRefreshMasterSeedP refresh_seed;
 
   /**
    * If false, @e blinding_seed is present
    */
   bool no_blinding_seed;
 
   /**
    * If @e no_blinding_seed it false, the blinding seed that was used
    * for the melt operation, in case of CS denominations.
    */
   struct TALER_BlindingMasterSeedP blinding_seed;
 
 };
 
 
 /**
  * Information about a /purses/$PID/deposit operation in a coin transaction history.
  */
 struct TALER_EXCHANGEDB_PurseDepositListEntry
 {
 
   /**
    * Exchange hosting the purse, NULL for this exchange.
    */
   char *exchange_base_url;
 
   /**
    * Public key of the purse.
    */
   struct TALER_PurseContractPublicKeyP purse_pub;
 
   /**
    * Contribution of the coin to the purse, including
    * deposit fee.
    */
   struct TALER_Amount amount;
 
   /**
    * Depositing fee.
    */
   struct TALER_Amount deposit_fee;
 
   /**
    * Signature by the coin affirming the deposit.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
   /**
    * Hash of the age commitment used to sign the coin, if age restriction was
    * applicable to the denomination.
    */
   struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * Hash of the public denomination key used to sign the coin.
    */
   struct TALER_DenominationHashP h_denom_pub;
 
   /**
    * Set to true if the coin was refunded.
    */
   bool refunded;
 
   /**
    * Set to true if there was no age commitment.
    */
   bool no_age_commitment;
 
 };
 
 
 /**
  * @brief Specification for a purse refund operation in a coin's transaction list.
  */
 struct TALER_EXCHANGEDB_PurseRefundListEntry
 {
 
   /**
    * Public key of the purse.
    */
   struct TALER_PurseContractPublicKeyP purse_pub;
 
   /**
    * 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;
 
 };
 
 
 /**
  * Information about a /reserves/$RID/open operation in a coin transaction history.
  */
 struct TALER_EXCHANGEDB_ReserveOpenListEntry
 {
 
   /**
    * Signature of the reserve.
    */
   struct TALER_ReserveSignatureP reserve_sig;
 
   /**
    * Contribution of the coin to the open fee, including
    * deposit fee.
    */
   struct TALER_Amount coin_contribution;
 
   /**
    * Signature by the coin affirming the open deposit.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
 };
 
 
 /**
  * Information about a /purses/$PID/deposit operation.
  */
 struct TALER_EXCHANGEDB_PurseDeposit
 {
 
   /**
    * Exchange hosting the purse, NULL for this exchange.
    */
   char *exchange_base_url;
 
   /**
    * Public key of the purse.
    */
   struct TALER_PurseContractPublicKeyP purse_pub;
 
   /**
    * Contribution of the coin to the purse, including
    * deposit fee.
    */
   struct TALER_Amount amount;
 
   /**
    * Depositing fee.
    */
   struct TALER_Amount deposit_fee;
 
   /**
    * Signature by the coin affirming the deposit.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
   /**
    * Public key of the coin.
    */
   struct TALER_CoinSpendPublicKeyP coin_pub;
 
   /**
    * Hash of the age commitment used to sign the coin, if age restriction was
    * applicable to the denomination.  May be all zeroes if no age restriction
    * applies.
    */
   struct TALER_AgeCommitmentHashP h_age_commitment;
 
   /**
    * Set to true if @e h_age_commitment is not available.
    */
   bool no_age_commitment;
 
 };
 
 /**
  * Information about a melt operation.
  */
 struct TALER_EXCHANGEDB_Melt
 {
 
   /**
    * Overall session data.
    */
   struct TALER_EXCHANGEDB_Refresh session;
 
   /**
    * Melt fee the exchange charged.
    */
   struct TALER_Amount melt_fee;
 
 };
 
 
 /**
  * Information about a melt operation since vDOLDPLUS of the protocol.
  * This also includes the information for the reveal phase.
  */
 struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS
 {
   /**
    * Information about the coin that is being melted.
    */
   struct TALER_CoinPublicInfo coin;
 
   /**
    * Signature over the melting operation.
    */
   struct TALER_CoinSpendSignatureP coin_sig;
 
   /**
    * Refresh commitment this coin is melted into.
    */
   struct TALER_RefreshCommitmentP rc;
 
   /**
    * True if the client has successfully performed the reveal part
    * of the refresh protocol, after the melt.
    */
   bool is_revealed;
 
   /**
    * @since vDOLDPLUS
    * Mark if we have a v27 Refresh object.
    * That is, the @a refresh_seed refers to the vDOLDPLUS master_refresh_seed
    * from the original request, AND the client has provided transfer public keys,
    * see below, @a transfer_public_keys
    */
   bool is_v27_refresh;
 
   /**
    * Public seed from which the refresh nonces (v27) or transfer secrets (vDOLDPLUS)
    * per coin candidate were derived from.
    */
   struct TALER_PublicRefreshMasterSeedP refresh_seed;
 
   /**
    * 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.
    */
   struct TALER_Amount amount_with_fee;
 
   /**
    * Number of coins to be refreshed into
    */
   size_t num_coins;
 
   /**
    * The running hash over all  kappa * @a num_coins blinded coin envelopes, provided by
    * the client.
    */
   struct TALER_HashBlindedPlanchetsP planchets_h;
 
   /**
    * The running hash over all chosen (noreveal_index) @a num_coins blinded coin envelopes.
    */
   struct TALER_HashBlindedPlanchetsP selected_h;
 
   /**
    * Array of @a num_coins denomination signatures of the blinded coins.
    */
   struct TALER_BlindedDenominationSignature *denom_sigs;
 
   /**
    * If @a is_v27_refresh is false, the client performed a vDOLDPLUS refresh,
    * and has provided @a num_coins * kappa transfer public keys.
    * This is the chosen (at index @a noreveal_index) array of @a num_coins transfer public keys.
    */
   struct TALER_TransferPublicKeyP *transfer_pubs;
 
   /**
    * Array of @a num_coins serial id's of the denominations.
    * If @e coin.no_age_commitment is false, the denominations
    * MUST support age restriction.
    */
   uint64_t *denom_serials;
 
   /**
    * Index (smaller #TALER_CNC_KAPPA) which the exchange chose to not
    * to be revealed during cut and choose.
    */
   uint32_t noreveal_index;
 
   /**
    * True, if the client has successfully performed the reveal step
    */
   bool revealed;
 
   /**
    * If true, no @e blinding_seed is set and @e num_cs_r_values is 0.
    */
   bool no_blinding_seed;
 
   /**
    * If @e no_blinding_seed is false, the blinding seed for the nonces needed for
    * blind CS signatures.
    */
   struct TALER_BlindingMasterSeedP blinding_seed;
 
   /**
    * Number of elements in @e cs_r_values.
    */
   size_t num_cs_r_values;
 
   /**
    * Array @e num_cs_r_values of public R-values for CS that were generated from the
    * @e blinding_seed, a coin's index and the denomination's private key during the
    * the /melt request, to ensure idempotency in case of expiration of a denomination.
    * NULL if @e num_cs_r_values is 0.
    */
   struct GNUNET_CRYPTO_CSPublicRPairP *cs_r_values;
 
   /**
    * If @e num_cs_r_values is not 0, the bitvector of choices for the pairs
    * in @e cs_r_values that was made by the exchange.  The vector is in NBO
    * and the lowest bit represents the choice for the pair at index 0 into @e cs_r_values;
    */
   uint64_t cs_r_choices;
 
   /**
    * [out]-Array of @a num_coins hashes of the public keys of the denominations
    * identified by @e denom_serials.  This field is set when calling
    * get_refresh
    */
   struct TALER_DenominationHashP *denom_pub_hashes;
 };
 
 
 /**
  * @brief Linked list of refresh information linked to a coin.
  */
 struct TALER_EXCHANGEDB_LinkList
 {
   /**
    * Information is stored in a NULL-terminated linked list.
    */
   struct TALER_EXCHANGEDB_LinkList *next;
 
   /**
    * Denomination public key, determines the value of the coin.
    */
   struct TALER_DenominationPublicKey denom_pub;
 
   /**
    * Signature over the blinded envelope.
    */
   struct TALER_BlindedDenominationSignature ev_sig;
 
   /**
    * Exchange-provided values during the coin generation.
    */
   struct TALER_ExchangeBlindingValues alg_values;
 
   /**
    * Signature of the original coin being refreshed over the
    * link data, of type #TALER_SIGNATURE_WALLET_COIN_LINK
    */
   struct TALER_CoinSpendSignatureP orig_coin_link_sig;
 
   /**
    * Session nonce, if cipher has one.
    */
   union GNUNET_CRYPTO_BlindSessionNonce nonce;
 
   /**
    * Offset that generated this coin in the refresh
    * operation.
    */
   uint32_t coin_refresh_offset;
 
   /**
    * Set to true if @e nonce was initialized.
    */
   bool have_nonce;
 };
 
 
 /**
  * @brief Enumeration to classify the different types of transactions
  * that can be done with a coin.
  */
 enum TALER_EXCHANGEDB_TransactionType
 {
 
   /**
    * Deposit operation.
    */
   TALER_EXCHANGEDB_TT_DEPOSIT = 0,
 
   /**
    * Melt operation.
    */
   TALER_EXCHANGEDB_TT_MELT = 1,
 
   /**
    * Refund operation.
    */
   TALER_EXCHANGEDB_TT_REFUND = 2,
 
   /**
    * Recoup-refresh operation (on the old coin, adding to the old coin's value)
    */
   TALER_EXCHANGEDB_TT_RECOUP_REFRESH_RECEIVER = 3,
 
   /**
    * Recoup operation.
    */
   TALER_EXCHANGEDB_TT_RECOUP_WITHDRAW = 4,
 
   /**
    * Recoup-refresh operation (on the new coin, eliminating its value)
    */
   TALER_EXCHANGEDB_TT_RECOUP_REFRESH = 5,
 
   /**
    * Purse deposit operation.
    */
   TALER_EXCHANGEDB_TT_PURSE_DEPOSIT = 6,
 
   /**
    * Purse deposit operation.
    */
   TALER_EXCHANGEDB_TT_PURSE_REFUND = 7,
 
   /**
    * Reserve open deposit operation.
    */
   TALER_EXCHANGEDB_TT_RESERVE_OPEN = 8
 
 };
 
 
 /**
  * @brief List of transactions we performed for a particular coin.
  */
 struct TALER_EXCHANGEDB_TransactionList
 {
 
   /**
    * Next pointer in the NULL-terminated linked list.
    */
   struct TALER_EXCHANGEDB_TransactionList *next;
 
   /**
    * Type of the transaction, determines what is stored in @e details.
    */
   enum TALER_EXCHANGEDB_TransactionType type;
 
   /**
    * Serial ID of this entry in the @e type-specific table.
    */
   uint64_t serial_id;
 
   /**
    * Serial ID of this entry in the coin history table.
    */
   uint64_t coin_history_id;
 
   /**
    * Details about the transaction, depending on @e type.
    */
   union
   {
 
     /**
      * Details if transaction was a deposit operation.
      * (#TALER_EXCHANGEDB_TT_DEPOSIT)
      */
     struct TALER_EXCHANGEDB_DepositListEntry *deposit;
 
     /**
      * Details if transaction was a melt operation.
      * (#TALER_EXCHANGEDB_TT_MELT)
      */
     struct TALER_EXCHANGEDB_MeltListEntry *melt;
 
     /**
      * Details if transaction was a refund operation.
      * (#TALER_EXCHANGEDB_TT_REFUND)
      */
     struct TALER_EXCHANGEDB_RefundListEntry *refund;
 
     /**
      * Details if transaction was a recoup-refund operation where
      * this coin was the OLD coin.
      * (#TALER_EXCHANGEDB_TT_RECOUP_REFRESH_RECEIVER).
      */
     struct TALER_EXCHANGEDB_RecoupRefreshListEntry *old_coin_recoup;
 
     /**
      * Details if transaction was a recoup operation.
      * (#TALER_EXCHANGEDB_TT_RECOUP_WITHDRAW)
      */
     struct TALER_EXCHANGEDB_RecoupListEntry *recoup;
 
     /**
      * Details if transaction was a recoup-refund operation where
      * this coin was the REFRESHED coin.
      * (#TALER_EXCHANGEDB_TT_RECOUP_REFRESH)
      */
     struct TALER_EXCHANGEDB_RecoupRefreshListEntry *recoup_refresh;
 
     /**
      * Coin was deposited into a purse.
      * (#TALER_EXCHANGEDB_TT_PURSE_DEPOSIT)
      */
     struct TALER_EXCHANGEDB_PurseDepositListEntry *purse_deposit;
 
     /**
      * Coin was refunded upon purse expiration
      * (#TALER_EXCHANGEDB_TT_PURSE_REFUND)
      */
     struct TALER_EXCHANGEDB_PurseRefundListEntry *purse_refund;
 
     /**
      * Coin was used to pay to open a reserve.
      * (#TALER_EXCHANGEDB_TT_RESERVE_OPEN)
      */
     struct TALER_EXCHANGEDB_ReserveOpenListEntry *reserve_open;
 
   } details;
 
 };
 
 
 /**
  * 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,
                                              uint64_t rowid,
                                              const char *wire_method,
                                              const char *buf,
                                              size_t buf_size);
 
 
 /**
  * Callback with KYC attributes about a particular user.
  *
  * @param cls closure
  * @param h_payto account for which the attribute data is stored
  * @param provider_name provider that must be checked
  * @param collection_time when was the data collected
  * @param expiration_time when does the data expire
  * @param enc_attributes_size number of bytes in @a enc_attributes
  * @param enc_attributes encrypted attribute data
  */
 typedef void
 (*TALER_EXCHANGEDB_AttributeCallback)(
   void *cls,
   const struct TALER_NormalizedPaytoHashP *h_payto,
   const char *provider_name,
   struct GNUNET_TIME_Timestamp collection_time,
   struct GNUNET_TIME_Timestamp expiration_time,
   size_t enc_attributes_size,
   const void *enc_attributes);
 
 
 /**
  * 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
  * @param exchange_timestamp when did the deposit happen
  * @param deposit deposit details
  * @param denom_pub denomination public key of @a coin_pub
  * @param done flag set if the deposit was already executed (or not)
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_DepositCallback)(
   void *cls,
   uint64_t rowid,
   struct GNUNET_TIME_Timestamp exchange_timestamp,
   const struct TALER_EXCHANGEDB_Deposit *deposit,
   const struct TALER_DenominationPublicKey *denom_pub,
   bool done);
 
 
 /**
  * Function called with details about purse 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
  * @param deposit deposit details
  * @param reserve_pub which reserve is the purse merged into, NULL if unknown
  * @param flags purse flags
  * @param auditor_balance purse balance (according to the
  *          auditor during auditing)
  * @param purse_total target amount the purse should reach
  * @param denom_pub denomination public key of @a coin_pub
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_PurseDepositCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_EXCHANGEDB_PurseDeposit *deposit,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   enum TALER_WalletAccountMergeFlags flags,
   const struct TALER_Amount *auditor_balance,
   const struct TALER_Amount *purse_total,
   const struct TALER_DenominationPublicKey *denom_pub);
 
 
 /**
  * Function called with details about
  * account merge requests that have been made, with
  * the goal of auditing the account merge execution.
  *
  * @param cls closure
  * @param rowid unique serial ID for the deposit in our DB
  * @param reserve_pub reserve affected by the merge
  * @param purse_pub purse being merged
  * @param h_contract_terms hash over contract of the purse
  * @param purse_expiration when would the purse expire
  * @param amount total amount in the purse
  * @param min_age minimum age of all coins deposited into the purse
  * @param flags how was the purse created
  * @param purse_fee if a purse fee was paid, how high is it
  * @param merge_timestamp when was the merge approved
  * @param reserve_sig signature by reserve approving the merge
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_AccountMergeCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   const struct TALER_PrivateContractHashP *h_contract_terms,
   struct GNUNET_TIME_Timestamp purse_expiration,
   const struct TALER_Amount *amount,
   uint32_t min_age,
   enum TALER_WalletAccountMergeFlags flags,
   const struct TALER_Amount *purse_fee,
   struct GNUNET_TIME_Timestamp merge_timestamp,
   const struct TALER_ReserveSignatureP *reserve_sig);
 
 
 /**
  * Function called with details about purse
  * merges that have been made, with
  * the goal of auditing the purse merge execution.
  *
  * @param cls closure
  * @param rowid unique serial ID for the deposit in our DB
  * @param partner_base_url where is the reserve, NULL for this exchange
  * @param amount total amount expected in the purse
  * @param balance current balance in the purse (according to the auditor)
  * @param flags purse flags
  * @param merge_pub merge capability key
  * @param reserve_pub reserve the merge affects
  * @param merge_sig signature affirming the merge
  * @param purse_pub purse key
  * @param merge_timestamp when did the merge happen
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_PurseMergeCallback)(
   void *cls,
   uint64_t rowid,
   const char *partner_base_url,
   const struct TALER_Amount *amount,
   const struct TALER_Amount *balance,
   enum TALER_WalletAccountMergeFlags flags,
   const struct TALER_PurseMergePublicKeyP *merge_pub,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_PurseMergeSignatureP *merge_sig,
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   struct GNUNET_TIME_Timestamp merge_timestamp);
 
 
 /**
  * Function called with details about purse decisions that have been made, with
  * the goal of auditing the purse's execution.
  *
  * @param cls closure
  * @param rowid unique serial ID for the deposit in our DB
  * @param purse_pub public key of the purse
  * @param reserve_pub public key of the target reserve, NULL if not known / refunded
  * @param purse_value what is the (target) value of the purse
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_PurseDecisionCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_Amount *purse_value);
 
 
 /**
  * Function called with details about purse decisions that have been made, with
  * the goal of auditing the purse's execution.
  *
  * @param cls closure
  * @param rowid unique serial ID for the deposit in our DB
  * @param purse_pub public key of the purse
  * @param refunded true if decision was to refund
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_AllPurseDecisionCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   bool refunded);
 
 
 /**
  * Function called with details about purse deletions that have been made, with
  * the goal of auditing the purse's execution.
  *
  * @param cls closure
  * @param rowid unique serial ID for the deposit in our DB
  * @param purse_pub public key of the purse
  * @param purse_sig signature affirming deletion of the purse
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_AllPurseDeletionsCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   const struct TALER_PurseContractSignatureP *purse_sig);
 
 
 /**
  * Function called with details about purse refunds that have been made, with
  * the goal of auditing the purse refund's execution.
  *
  * @param cls closure
  * @param rowid row of the refund event
  * @param amount_with_fee amount of the deposit into the purse
  * @param coin_pub coin that is to be refunded the @a given amount_with_fee
  * @param denom_pub denomination of @a coin_pub
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_PurseRefundCoinCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_Amount *amount_with_fee,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_DenominationPublicKey *denom_pub);
 
 
 /**
  * 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
  * @param old_denom_pub denomination public key of @a coin_pub
  * @param coin_pub public key of the coin
  * @param coin_sig signature from the coin
  * @param h_age_commitment hash of the age commitment for the coin
  * @param amount_with_fee amount that was deposited including fee
  * @param num_nds length of the @a new_denom_serials array
  * @param new_denom_serials array of denomination serials of fresh coins
  * @param rc what the refresh commitment
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_RefreshesCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_DenominationPublicKey *old_denom_pub,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_CoinSpendSignatureP *coin_sig,
   const struct TALER_AgeCommitmentHashP *h_age_commitment,
   const struct TALER_Amount *amount_with_fee,
   size_t num_nds,
   uint64_t new_denom_serials[static num_nds],
   const struct TALER_RefreshCommitmentP *rc);
 
 
 /**
  * Callback invoked with information about refunds applicable
  * to a particular coin and contract.
  *
  * @param cls closure
  * @param amount_with_fee amount being refunded
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_RefundCoinCallback)(
   void *cls,
   const struct TALER_Amount *amount_with_fee);
 
 
 /**
  * Information per Clause-Schnorr (CS) fresh coin to
  * be persisted for idempotency during refreshes-reveal.
  */
 struct TALER_EXCHANGEDB_CsRevealFreshCoinData
 {
   /**
    * Denomination of the fresh coin.
    */
   struct TALER_DenominationHashP new_denom_pub_hash;
 
   /**
    * Blind signature of the fresh coin (possibly updated
    * in case if a replay!).
    */
   struct TALER_BlindedDenominationSignature bsig;
 
   /**
    * Offset of the fresh coin in the reveal operation.
    * (May not match the array offset as we may have
    * a mixture of RSA and CS coins being created, and
    * this request is only made for the CS subset).
    */
   uint32_t coin_off;
 };
 
 
 /**
  * Generic KYC status for some operation.
  */
 struct TALER_EXCHANGEDB_KycStatus
 {
 
   /**
    * Account public key that is currently associated
    * with the account. Only set if @e have_account_pub
    * is true.
    */
   union TALER_AccountPublicKeyP account_pub;
 
   /**
    * Number that identifies the KYC requirement the operation
    * was about.
    */
   uint64_t requirement_row;
 
   /**
    * True if @e account_pub is set.
    */
   bool have_account_pub;
 
   /**
    * True if the KYC status is "satisfied".
    */
   bool ok;
 
 };
 
 
 struct TALER_EXCHANGEDB_ReserveInInfo
 {
   const struct TALER_ReservePublicKeyP *reserve_pub;
   const struct TALER_Amount *balance;
   struct GNUNET_TIME_Timestamp execution_time;
   struct TALER_FullPayto sender_account_details;
   const char *exchange_account_name;
   uint64_t wire_reference;
 };
 
 
 /**
  * Function called on each @a amount that was found to
  * be relevant for a KYC check.
  *
  * @param cls closure to allow the KYC module to
  *        total up amounts and evaluate rules
  * @param amount encountered transaction amount
  * @param date when was the amount encountered
  * @return #GNUNET_OK to continue to iterate,
  *         #GNUNET_NO to abort iteration
  *         #GNUNET_SYSERR on internal error (also abort itaration)
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_KycAmountCallback)(
   void *cls,
   const struct TALER_Amount *amount,
   struct GNUNET_TIME_Absolute date);
 
 
 /**
  * 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
  * @param denom_pub denomination public key of @a coin_pub
  * @param coin_pub public key of the coin
  * @param merchant_pub public key of the merchant
  * @param merchant_sig signature of the merchant
  * @param h_contract_terms hash of the proposal data known to merchant and customer
  * @param rtransaction_id refund transaction ID chosen by the merchant
  * @param full_refund true if the refunds total up to the entire value of the deposit
  * @param amount_with_fee amount that was deposited including fee
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_RefundCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_DenominationPublicKey *denom_pub,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_MerchantPublicKeyP *merchant_pub,
   const struct TALER_MerchantSignatureP *merchant_sig,
   const struct TALER_PrivateContractHashP *h_contract_terms,
   uint64_t rtransaction_id,
   bool full_refund,
   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 wire subject)
  * @param credit amount that was received
  * @param sender_account_details information about the sender's bank account, in payto://-format
  * @param wire_reference unique identifier for the wire transfer
  * @param execution_date when did we receive the funds
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_ReserveInCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_Amount *credit,
   const struct TALER_FullPayto sender_account_details,
   uint64_t wire_reference,
   struct GNUNET_TIME_Timestamp execution_date);
 
 
 /**
  * Provide information about a wire account.
  *
  * @param cls closure
  * @param payto_uri the exchange bank account URI
  * @param conversion_url URL of a conversion service, NULL if there is no conversion
  * @param open_banking_gateway open banking gateway service, NULL if unavailable
  * @param wire_transfer_gateway wire transfer gateway service, NULL if unavailable
  * @param debit_restrictions JSON array with debit restrictions on the account
  * @param credit_restrictions JSON array with credit restrictions on the account
  * @param master_sig master key signature affirming that this is a bank
  *                   account of the exchange (of purpose #TALER_SIGNATURE_MASTER_WIRE_DETAILS)
  * @param bank_label label the wallet should use to display the account, can be NULL
  * @param priority priority for ordering bank account labels
  */
 typedef void
 (*TALER_EXCHANGEDB_WireAccountCallback)(
   void *cls,
   const struct TALER_FullPayto payto_uri,
   const char *conversion_url,
   const char *open_banking_gateway,
   const char *wire_transfer_gateway,
   const json_t *debit_restrictions,
   const json_t *credit_restrictions,
   const struct TALER_MasterSignatureP *master_sig,
   const char *bank_label,
   int64_t priority);
 
 
 /**
  * Function called with historic AML events of an
  * account.
  *
  * @param cls closure
  * @param outcome_serial_id row ID of the decision
  * @param decision_time when was the decision taken
  * @param justification what was the given justification
  * @param decider_pub which key signed the decision
  * @param jproperties what are the new account properties
  * @param jnew_rules what are the new account rules
  * @param to_investigate should AML staff investigate
  *          after the decision
  * @param is_active is this the active decision
  */
 typedef void
 (*TALER_EXCHANGEDB_AmlHistoryCallback) (
   void *cls,
   uint64_t outcome_serial_id,
   struct GNUNET_TIME_Timestamp decision_time,
   const char *justification,
   const struct TALER_AmlOfficerPublicKeyP *decider_pub,
   const json_t *jproperties,
   const json_t *jnew_rules,
   bool to_investigate,
   bool is_active);
 
 
 /**
  * Function called with historic KYC events of an
  * account.
  *
  * @param cls closure
  * @param provider_name name of the KYC provider
  * @param finished did the KYC process finish
  * @param error_code error code from the KYC process
  * @param error_message error message from the KYC process,
  *    or NULL for none
  * @param provider_user_id user ID at the provider
  *    or NULL for none
  * @param provider_legitimization_id legitimization process ID at the provider
  *    or NULL for none
  * @param collection_time when was the data collected
  * @param expiration_time when does the collected data expire
  * @param encrypted_attributes_len number of bytes in @a encrypted_attributes
  * @param encrypted_attributes encrypted KYC attributes
  */
 typedef void
 (*TALER_EXCHANGEDB_KycHistoryCallback) (
   void *cls,
   const char *provider_name,
   bool finished,
   enum TALER_ErrorCode error_code,
   const char *error_message,
   const char *provider_user_id,
   const char *provider_legitimization_id,
   struct GNUNET_TIME_Timestamp collection_time,
   struct GNUNET_TIME_Absolute expiration_time,
   size_t encrypted_attributes_len,
   const void *encrypted_attributes);
 
 
 /**
  * Function called with legitimization measures.
  *
  * @param cls closure
  * @param h_payto hash of account the measure applies to
  * @param start_time when was the process started
  * @param jmeasures object of type ``LegitimizationMeasures``
  * @param is_finished true if the measure was finished
  * @param measure_serial_id row ID of the measure in the exchange table
  */
 typedef void
 (*TALER_EXCHANGEDB_LegitimizationMeasureCallback) (
   void *cls,
   struct TALER_NormalizedPaytoHashP *h_payto,
   struct GNUNET_TIME_Absolute start_time,
   const json_t *jmeasures,
   bool is_finished,
   uint64_t measure_serial_id);
 
 
 /**
  * Provide information about wire fees.
  *
  * @param cls closure
  * @param fees the wire fees we charge
  * @param start_date from when are these fees valid (start date)
  * @param end_date until when are these fees valid (end date, exclusive)
  * @param master_sig master key signature affirming that this is the correct
  *                   fee (of purpose #TALER_SIGNATURE_MASTER_WIRE_FEES)
  */
 typedef void
 (*TALER_EXCHANGEDB_WireFeeCallback)(
   void *cls,
   const struct TALER_WireFeeSet *fees,
   struct GNUNET_TIME_Timestamp start_date,
   struct GNUNET_TIME_Timestamp end_date,
   const struct TALER_MasterSignatureP *master_sig);
 
 
 /**
  * Provide information about global fees.
  *
  * @param cls closure
  * @param fees the global fees we charge
  * @param purse_timeout when do purses time out
  * @param history_expiration how long are account histories preserved
  * @param purse_account_limit how many purses are free per account
  * @param start_date from when are these fees valid (start date)
  * @param end_date until when are these fees valid (end date, exclusive)
  * @param master_sig master key signature affirming that this is the correct
  *                   fee (of purpose #TALER_SIGNATURE_MASTER_GLOBAL_FEES)
  */
 typedef void
 (*TALER_EXCHANGEDB_GlobalFeeCallback)(
   void *cls,
   const struct TALER_GlobalFeeSet *fees,
   struct GNUNET_TIME_Relative purse_timeout,
   struct GNUNET_TIME_Relative history_expiration,
   uint32_t purse_account_limit,
   struct GNUNET_TIME_Timestamp start_date,
   struct GNUNET_TIME_Timestamp end_date,
   const struct TALER_MasterSignatureP *master_sig);
 
 
 /**
  * Function called with details about withdraw operations.
  *
  * @param cls closure
  * @param rowid unique serial ID for the refresh session in our DB
  * @param num_denom_serials number of elements in @e denom_serials array
  * @param denom_serials array with length @e num_denom_serials of serial ID's of denominations in our DB
  * @param selected_h hash over the gamma-selected planchets
  * @param h_planchets running hash over all hashes of blinded planchets in the original withdraw request
  * @param blinding_seed the blinding seed for CS denominations that was provided during withdraw; might be NULL
  * @param age_proof_required true if the withdraw request required an age proof.
  * @param max_age if @e age_proof_required is true, the maximum age that was set on the coins.
  * @param noreveal_index if @e age_proof_required is true, the index that was returned by the exchange for the reveal phase.
  * @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 enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_WithdrawCallback)(
   void *cls,
   uint64_t rowid,
   size_t num_denom_serials,
   const uint64_t *denom_serials,
   const struct TALER_HashBlindedPlanchetsP *selected_h,
   const struct TALER_HashBlindedPlanchetsP *h_planchets,
   const struct TALER_BlindingMasterSeedP *blinding_seed,
   bool age_proof_required,
   uint8_t max_age,
   uint8_t noreveal_index,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_ReserveSignatureP *reserve_sig,
   struct GNUNET_TIME_Timestamp execution_date,
   const struct TALER_Amount *amount_with_fee);
 
 
 /**
  * Function called with the session hashes and transfer secret
  * information for a given coin.
  *
  * @param cls closure
  * @param transfer_pub public transfer key for the session
  * @param ldl link data for @a transfer_pub
  */
 typedef void
 (*TALER_EXCHANGEDB_LinkCallback)(
   void *cls,
   const struct TALER_TransferPublicKeyP *transfer_pub,
   const struct TALER_EXCHANGEDB_LinkList *ldl);
 
 
 /**
  * Function called with the results of the lookup of the
  * transaction data associated with a wire transfer identifier.
  *
  * @param cls closure
  * @param rowid which row in the table is the information from (for diagnostics)
  * @param merchant_pub public key of the merchant (should be same for all callbacks with the same @e cls)
  * @param account_payto_uri which account did the transfer go to?
  * @param h_payto hash over @a account_payto_uri as it is in the DB
  * @param exec_time execution time of the wire transfer (should be same for all callbacks with the same @e cls)
  * @param h_contract_terms which proposal was this payment about
  * @param denom_pub denomination of @a coin_pub
  * @param coin_pub which public key was this payment about
  * @param coin_value amount contributed by this coin in total (with fee)
  * @param coin_fee applicable fee for this coin
  */
 typedef void
 (*TALER_EXCHANGEDB_AggregationDataCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_MerchantPublicKeyP *merchant_pub,
   const struct TALER_FullPayto account_payto_uri,
   const struct TALER_FullPaytoHashP *h_payto,
   struct GNUNET_TIME_Timestamp exec_time,
   const struct TALER_PrivateContractHashP *h_contract_terms,
   const struct TALER_DenominationPublicKey *denom_pub,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_Amount *coin_value,
   const struct TALER_Amount *coin_fee);
 
 
 /**
  * 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 payto_uri details of the receiver, URI in payto://-format
  * @param amount amount that was wired
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to stop iteration
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_WireTransferOutCallback)(
   void *cls,
   uint64_t rowid,
   struct GNUNET_TIME_Timestamp date,
   const struct TALER_WireTransferIdentifierRawP *wtid,
   const struct TALER_FullPayto payto_uri,
   const struct TALER_Amount *amount);
 
 
 /**
  * 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
  * @param finished did we complete the transfer yet?
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to stop iteration
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_WirePreparationCallback)(
   void *cls,
   uint64_t rowid,
   const char *wire_method,
   const char *buf,
   size_t buf_size,
   int finished);
 
 
 /**
  * Function called about recoups the exchange has to perform.
  *
  * @param cls closure
  * @param rowid row identifier used to uniquely identify the recoup operation
  * @param timestamp when did we receive the recoup request
  * @param amount how much should be added back to the reserve
  * @param reserve_pub public key of the reserve
  * @param coin public information about the coin
  * @param denom_pub denomination key of @a coin
  * @param coin_sig signature with @e coin_pub of type #TALER_SIGNATURE_WALLET_COIN_RECOUP
  * @param coin_blind blinding factor used to blind the coin
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_RecoupCallback)(
   void *cls,
   uint64_t rowid,
   struct GNUNET_TIME_Timestamp timestamp,
   const struct TALER_Amount *amount,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_CoinPublicInfo *coin,
   const struct TALER_DenominationPublicKey *denom_pub,
   const struct TALER_CoinSpendSignatureP *coin_sig,
   const union GNUNET_CRYPTO_BlindingSecretP *coin_blind);
 
 
 /**
  * Function called about recoups on refreshed coins the exchange has to
  * perform.
  *
  * @param cls closure
  * @param rowid row identifier used to uniquely identify the recoup operation
  * @param timestamp when did we receive the recoup request
  * @param amount how much should be added back to the old coin
  * @param old_coin_pub original coin that was refreshed to create @a coin
  * @param old_denom_pub_hash hash of public key of @a old_coin_pub
  * @param coin public information about the fresh coin
  * @param denom_pub denomination key of @a coin
  * @param coin_sig signature with @e coin_pub of type #TALER_SIGNATURE_WALLET_COIN_RECOUP
  * @param coin_blind blinding factor used to blind the coin
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_RecoupRefreshCallback)(
   void *cls,
   uint64_t rowid,
   struct GNUNET_TIME_Timestamp timestamp,
   const struct TALER_Amount *amount,
   const struct TALER_CoinSpendPublicKeyP *old_coin_pub,
   const struct TALER_DenominationHashP *old_denom_pub_hash,
   const struct TALER_CoinPublicInfo *coin,
   const struct TALER_DenominationPublicKey *denom_pub,
   const struct TALER_CoinSpendSignatureP *coin_sig,
   const union GNUNET_CRYPTO_BlindingSecretP *coin_blind);
 
 
 /**
  * Function called about reserve opening operations.
  *
  * @param cls closure
  * @param rowid row identifier used to uniquely identify the reserve closing operation
  * @param reserve_payment how much to pay from the
  *        reserve's own balance for opening the reserve
  * @param request_timestamp when was the request created
  * @param reserve_expiration desired expiration time for the reserve
  * @param purse_limit minimum number of purses the client
  *       wants to have concurrently open for this reserve
  * @param reserve_pub public key of the reserve
  * @param reserve_sig signature affirming the operation
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_ReserveOpenCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_Amount *reserve_payment,
   struct GNUNET_TIME_Timestamp request_timestamp,
   struct GNUNET_TIME_Timestamp reserve_expiration,
   uint32_t purse_limit,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_ReserveSignatureP *reserve_sig);
 
 
 /**
  * Function called with AML statistics (counters).
  *
  * @param cls closure
  * @param name name of the counter
  * @param cnt number of events for @a name in the query range
  */
 typedef void
 (*TALER_EXCHANGEDB_AmlStatisticsCallback)(
   void *cls,
   const char *name,
   uint64_t cnt);
 
 
 /**
  * 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, in payto://-format
  * @param wtid identifier used for the wire transfer
  * @param close_request_row row with the responsible close
  *            request, 0 if regular expiration triggered close
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_ReserveClosedCallback)(
   void *cls,
   uint64_t rowid,
   struct GNUNET_TIME_Timestamp execution_date,
   const struct TALER_Amount *amount_with_fee,
   const struct TALER_Amount *closing_fee,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_FullPayto receiver_account,
   const struct TALER_WireTransferIdentifierRawP *wtid,
   uint64_t close_request_row);
 
 
 /**
  * Function called with the amounts historically
  * withdrawn from the same origin account.
  *
  * @param cls closure
  * @param val one of the withdrawn amounts
  */
 typedef void
 (*TALER_EXCHANGEDB_WithdrawHistoryCallback)(
   void *cls,
   const struct TALER_Amount *val);
 
 /**
  * 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, in payto://-format
  * @param expiration_date when did the reserve expire
  * @param close_request_row row that caused the reserve
  *        to be closed, 0 if it expired without request
  * @return #GNUNET_OK on success,
  *         #GNUNET_NO to retry
  *         #GNUNET_SYSERR on hard failures (exit)
  */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_ReserveExpiredCallback)(
   void *cls,
   const struct TALER_ReservePublicKeyP *reserve_pub,
   const struct TALER_Amount *left,
   const struct TALER_FullPayto account_details,
   struct GNUNET_TIME_Timestamp expiration_date,
   uint64_t close_request_row);
 
 
 /**
  * Function called with information justifying an aggregate recoup.
  * (usually implemented by the auditor when verifying losses from recoups).
  *
  * @param cls closure
  * @param rowid row identifier used to uniquely identify the recoup operation
  * @param coin information about the coin
  * @param coin_sig signature of the coin of type #TALER_SIGNATURE_WALLET_COIN_RECOUP
  * @param coin_blind blinding key of the coin
  * @param h_blinded_ev blinded envelope, as calculated by the exchange
  * @param amount total amount to be paid back
  */
 typedef void
 (*TALER_EXCHANGEDB_RecoupJustificationCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_CoinPublicInfo *coin,
   const struct TALER_CoinSpendSignatureP *coin_sig,
   const union GNUNET_CRYPTO_BlindingSecretP *coin_blind,
   const struct TALER_BlindedCoinHashP *h_blinded_ev,
   const struct TALER_Amount *amount);
 
 
 /**
  * Function called on (batch) deposits will need a wire
  * transfer.
  *
  * @param cls closure
  * @param batch_deposit_serial_id where in the table are we
  * @param total_amount value of all missing deposits, including fees
  * @param wire_target_h_payto hash of the recipient account's payto URI
  * @param deadline what was the earliest requested wire transfer deadline
  */
 typedef void
 (*TALER_EXCHANGEDB_WireMissingCallback)(
   void *cls,
   uint64_t batch_deposit_serial_id,
   const struct TALER_Amount *total_amount,
   const struct TALER_FullPaytoHashP *wire_target_h_payto,
   struct GNUNET_TIME_Timestamp deadline);
 
 
 /**
  * Function called on aggregations that were done for
  * a (batch) deposit.
  *
  * @param cls closure
  * @param amount affected amount
  * @param tracking_serial_id where in the table are we
  * @param batch_deposit_serial_id which batch deposit was aggregated
  */
 typedef void
 (*TALER_EXCHANGEDB_AggregationCallback)(
   void *cls,
   const struct TALER_Amount *amount,
   uint64_t tracking_serial_id,
   uint64_t batch_deposit_serial_id);
 
 
 /**
  * Function called on purse requests.
  *
  * @param cls closure
  * @param rowid purse request table row of the purse
  * @param purse_pub public key of the purse
  * @param merge_pub public key representing the merge capability
  * @param purse_creation when was the purse created?
  * @param purse_expiration when would an unmerged purse expire
  * @param h_contract_terms contract associated with the purse
  * @param age_limit the age limit for deposits into the purse
  * @param target_amount amount to be put into the purse
  * @param purse_sig signature of the purse over the initialization data
  * @return #GNUNET_OK to continue to iterate
    */
 typedef enum GNUNET_GenericReturnValue
 (*TALER_EXCHANGEDB_PurseRequestCallback)(
   void *cls,
   uint64_t rowid,
   const struct TALER_PurseContractPublicKeyP *purse_pub,
   const struct TALER_PurseMergePublicKeyP *merge_pub,
   struct GNUNET_TIME_Timestamp purse_creation,
   struct GNUNET_TIME_Timestamp purse_expiration,
   const struct TALER_PrivateContractHashP *h_contract_terms,
   uint32_t age_limit,
   const struct TALER_Amount *target_amount,
   const struct TALER_PurseContractSignatureP *purse_sig);
 
 
 /**
  * Function called with information about the exchange's denomination keys.
  * Note that the 'master' field in @a issue will not yet be initialized when
  * this function is called!
  *
  * @param cls closure
  * @param denom_serial table row of the denomination
  * @param denom_pub public key of the denomination
  * @param issue detailed information about the denomination (value, expiration times, fees);
  */
 typedef void
 (*TALER_EXCHANGEDB_DenominationCallback)(
   void *cls,
   uint64_t denom_serial,
   const struct TALER_DenominationPublicKey *denom_pub,
   const struct TALER_EXCHANGEDB_DenominationKeyInformation *issue);
 
 
 /**
  * Return AML decision information.
  *
  * @param cls closure
  * @param row_id current row in legitimization outcomes table
  * @param justification human-readable reason for the decision, NULL if none is available
  * @param h_payto account for which the attribute data is stored
  * @param decision_time when was the decision taken
  * @param expiration_time when will the rules expire
  * @param jproperties properties set for the account,
  *    NULL if no properties were set
  * @param to_investigate true if AML staff should look at the account
  * @param is_active true if this is the currently active decision about the account
  * @param is_wallet true if the @a h_payto is for a Taler wallet
  * @param payto payto URI of the account the decision is about
  * @param account_rules current active rules for the account
  */
 typedef void
 (*TALER_EXCHANGEDB_AmlDecisionCallback)(
   void *cls,
   uint64_t row_id,
   const char *justification,
   const struct TALER_NormalizedPaytoHashP *h_payto,
   struct GNUNET_TIME_Timestamp decision_time,
   struct GNUNET_TIME_Absolute expiration_time,
   const json_t *jproperties,
   bool to_investigate,
   bool is_active,
   bool is_wallet,
   struct TALER_FullPayto payto,
   const json_t *account_rules);
 
 
 /**
  * Return account summary information.
  *
  * @param cls closure
  * @param row_id current row in AML status table
  * @param h_payto account for which the attribute data is stored
  * @param open_time when was the account opened formally,
  *          GNUNET_TIME_UNIT_FOREVER_TS if it was never opened
  * @param close_time when was the account formally closed,
  *          GNUNET_TIME_UNIT_ZERO_TS if it was never closed
  * @param comments comments on the account
  * @param high_risk is this a high-risk business relationship
  * @param to_investigate TRUE if this account should be investigated
  * @param payto the payto URI of the account
  */
 typedef void
 (*TALER_EXCHANGEDB_AmlAccountListCallback)(
   void *cls,
   uint64_t row_id,
   const struct TALER_NormalizedPaytoHashP *h_payto,
   struct GNUNET_TIME_Timestamp open_time,
   struct GNUNET_TIME_Timestamp close_time,
   const char *comments,
   bool high_risk,
   bool to_investigate,
   struct TALER_FullPayto payto);
 
 
 /**
  * Return AML attribute information.
  *
  * @param cls closure
  * @param row_id current row in kyc_attributes table
  * @param collection_time when were the attributes collected
  * @param by_aml_officer true if the data was filed by an AML officer
  * @param officer_name name of the officer, NULL if not @a by_aml_officer
  * @param enc_attributes_size size of @a enc_attributes
  * @param enc_attributes the encrypted collected attributes
  */
 typedef void
 (*TALER_EXCHANGEDB_AmlAttributeCallback)(
   void *cls,
   uint64_t row_id,
   struct GNUNET_TIME_Timestamp collection_time,
   bool by_aml_officer,
   const char *officer_name,
   size_t enc_attributes_size,
   const void *enc_attributes);
 
 
 /**
  * Return KYC attribute information.
  *
  * @param cls closure
  * @param row_id current row in kyc_attributes table
  * @param h_payto account the attributes are about
  * @param provider_name name of the provider that collected the attributes
  * @param collection_time when were the attributes collected
  * @param expiration_time when does the data expire
  * @param properties properties that were set for @a h_payto
  * @param enc_attributes_size size of @a enc_attributes
  * @param enc_attributes the encrypted collected attributes
  * @return true to continue to iterate
  */
 typedef bool
 (*TALER_EXCHANGEDB_AllAttributesCallback)(
   void *cls,
   uint64_t row_id,
   const struct TALER_NormalizedPaytoHashP *h_payto,
   const char *provider_name,
   struct GNUNET_TIME_Timestamp collection_time,
   struct GNUNET_TIME_Timestamp expiration_time,
   const json_t *properties,
   size_t enc_attributes_size,
   const void *enc_attributes);
 
 
 /**
  * Callback that is given AML-relevant transfer data.
  *
  * @param cls closure
  * @param row_id current row in AML status table
  * @param payto_uri account involved with the wire transfer
  * @param execution_time when was the transfer made
  * @param amount wire amount of the transfer
  */
 typedef void
 (*TALER_EXCHANGEDB_AmlTransferCallback)(
   void *cls,
   uint64_t row_id,
   const char *payto_uri,
   struct GNUNET_TIME_Absolute execution_time,
   const struct TALER_Amount *amount);
 
 
 /**
  * @brief The plugin API, returned from the plugin's "init" function.
  * The argument given to "init" is simply a configuration handle.
  */
 struct TALER_EXCHANGEDB_Plugin
 {
 
   /**
    * Closure for all callbacks.
    */
   void *cls;
 
   /**
    * Name of the library which generated this plugin.  Set by the
    * plugin loader.
    */
   char *library_name;
 
   /**
    * How long are AML programs allowed to run?
    */
   struct GNUNET_TIME_Relative max_aml_program_runtime;
 
   /**
    * Drop the Taler tables.  This should only be used in testcases.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @return #GNUNET_OK upon success; #GNUNET_SYSERR upon failure
    */
   enum GNUNET_GenericReturnValue
   (*drop_tables)(void *cls);
 
   /**
    * Create the necessary tables if they are not present
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param support_partitions true to enable partitioning support (disables foreign key constraints)
    * @param num_partitions number of partitions to create,
    *     (0 to not actually use partitions, 1 to only
    *      setup a default partition, >1 for real partitions)
    * @return #GNUNET_OK upon success; #GNUNET_SYSERR upon failure
    */
   enum GNUNET_GenericReturnValue
   (*create_tables)(void *cls,
                    bool support_partitions,
                    uint32_t num_partitions);
 
 
   /**
    * Start a transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param name unique name identifying the transaction (for debugging),
    *             must point to a constant
    * @return #GNUNET_OK on success
    */
   enum GNUNET_GenericReturnValue
   (*start)(void *cls,
            const char *name);
 
 
   /**
    * Start a READ COMMITTED transaction.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param name unique name identifying the transaction (for debugging)
    *             must point to a constant
    * @return #GNUNET_OK on success
    */
   enum GNUNET_GenericReturnValue
   (*start_read_committed)(void *cls,
                           const char *name);
 
   /**
    * Start a READ ONLY serializable transaction.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param name unique name identifying the transaction (for debugging)
    *             must point to a constant
    * @return #GNUNET_OK on success
    */
   enum GNUNET_GenericReturnValue
   (*start_read_only)(void *cls,
                      const char *name);
 
 
   /**
    * Commit a transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*commit)(void *cls);
 
 
   /**
    * Do a pre-flight check that we are not in an uncommitted transaction.
    * If we are, try to commit the previous transaction and output a warning.
    * Does not return anything, as we will continue regardless of the outcome.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @return #GNUNET_OK if everything is fine
    *         #GNUNET_NO if a transaction was rolled back
    *         #GNUNET_SYSERR on hard errors
    */
   enum GNUNET_GenericReturnValue
   (*preflight)(void *cls);
 
 
   /**
    * Abort/rollback a transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    */
   void
   (*rollback) (void *cls);
 
 
   /**
    * Register callback to be invoked on events of type @a es.
    *
    * @param cls database context to use
    * @param timeout how long to wait at most
    * @param es specification of the event to listen for
    * @param cb function to call when the event happens, possibly
    *         multiple times (until cancel is invoked)
    * @param cb_cls closure for @a cb
    * @return handle useful to cancel the listener
    */
   struct GNUNET_DB_EventHandler *
   (*event_listen)(void *cls,
                   struct GNUNET_TIME_Relative timeout,
                   const struct GNUNET_DB_EventHeaderP *es,
                   GNUNET_DB_EventCallback cb,
                   void *cb_cls);
 
   /**
    * Stop notifications.
    *
    * @param cls database context to use
    * @param eh handle to unregister.
    */
   void
   (*event_listen_cancel)(void *cls,
                          struct GNUNET_DB_EventHandler *eh);
 
 
   /**
    * Notify all that listen on @a es of an event.
    *
    * @param cls database context to use
    * @param es specification of the event to generate
    * @param extra additional event data provided
    * @param extra_size number of bytes in @a extra
    */
   void
   (*event_notify)(void *cls,
                   const struct GNUNET_DB_EventHeaderP *es,
                   const void *extra,
                   size_t extra_size);
 
 
   /**
    * Insert information about a denomination key and in particular
    * the properties (value, fees, expiration times) the coins signed
    * with this key have.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param denom_pub the public key used for signing coins of this denomination
    * @param issue issuing information with value, fees and other info about the denomination
    * @return status of the query
    */
   enum GNUNET_DB_QueryStatus
   (*insert_denomination_info)(
     void *cls,
     const struct TALER_DenominationPublicKey *denom_pub,
     const struct TALER_EXCHANGEDB_DenominationKeyInformation *issue);
 
 
   /**
    * Fetch information about a denomination key.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param denom_pub_hash hash of the public key used for signing coins of this denomination
    * @param[out] denom_serial row in the denomination table, might be NULL
    * @param[out] issue set to issue information with value, fees and other info about the coin
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_denomination_info)(
     void *cls,
     const struct TALER_DenominationHashP *denom_pub_hash,
     uint64_t *denom_serial,
     struct TALER_EXCHANGEDB_DenominationKeyInformation *issue);
 
   /**
    * Fetch information about a denomination by a given serial id.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param denom_serial row in the denomination table
    * @param[out] issue set to issue information with value, fees and other info about the coin
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_denomination_by_serial)(
     void *cls,
     uint64_t denom_serial,
     struct TALER_EXCHANGEDB_DenominationKeyInformation *issue);
 
 
   /**
    * Function called on every known denomination key.  Runs in its
    * own read-only transaction (hence no session provided).  Note that
    * the "master" field in the callback's 'issue' argument will NOT
    * be initialized yet.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param cb function to call on each denomination key
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*iterate_denomination_info)(void *cls,
                                TALER_EXCHANGEDB_DenominationCallback cb,
                                void *cb_cls);
 
 
   /**
    * Function called to invoke @a cb on every known denomination key (revoked
    * and non-revoked) that has been signed by the master key. Runs in its own
    * read-only transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param cb function to call on each denomination key
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*iterate_denominations)(void *cls,
                            TALER_EXCHANGEDB_DenominationsCallback cb,
                            void *cb_cls);
 
   /**
    * Function called to invoke @a cb on every non-revoked exchange signing key
    * that has been signed by the master key.  Revoked and (for signing!)
    * expired keys are skipped. Runs in its own read-only transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param cb function to call on each signing key
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*iterate_active_signkeys)(void *cls,
                              TALER_EXCHANGEDB_ActiveSignkeysCallback cb,
                              void *cb_cls);
 
 
   /**
    * Function called to invoke @a cb on every active auditor. Disabled
    * auditors are skipped. Runs in its own read-only transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param cb function to call on each active auditor
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*iterate_active_auditors)(void *cls,
                              TALER_EXCHANGEDB_AuditorsCallback cb,
                              void *cb_cls);
 
 
   /**
    * Function called to invoke @a cb on every denomination with an active
    * auditor. Disabled auditors and denominations without auditor are
    * skipped. Runs in its own read-only transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param cb function to call on each active auditor-denomination pair
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*iterate_auditor_denominations)(
     void *cls,
     TALER_EXCHANGEDB_AuditorDenominationsCallback cb,
     void *cb_cls);
 
 
   /**
    * Get the summary of a reserve.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param[in,out] reserve the reserve data.  The public key of the reserve should be set
    *          in this structure; it is used to query the database.  The balance
    *          and expiration are then filled accordingly.
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*reserves_get)(void *cls,
                   struct TALER_EXCHANGEDB_Reserve *reserve);
 
 
   /**
    * Get the origin of funds of a reserve.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param reserve_pub public key of the reserve
    * @param[out] h_payto set to hash of the wire source payto://-URI
    * @param[out] payto_uri set to the wire source payto://-URI
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*reserves_get_origin)(
     void *cls,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     struct TALER_FullPaytoHashP *h_payto,
     struct TALER_FullPayto *payto_uri);
 
 
   /**
    * Extract next KYC alert.  Deletes the alert.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param trigger_type which type of alert to drain
    * @param[out] h_payto set to hash of payto-URI where KYC status changed
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*drain_kyc_alert)(void *cls,
                      uint32_t trigger_type,
                      struct TALER_NormalizedPaytoHashP *h_payto);
 
 
   /**
    * Insert a batch of incoming transaction into reserves.  New reserves are
    * also created through this function.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param reserves
    * @param reserves_length length of the @a reserves array
    * @param[out] results array of transaction status codes of length @a reserves_length,
    *             set to the status of the
    */
   enum GNUNET_DB_QueryStatus
   (*reserves_in_insert)(
     void *cls,
     const struct TALER_EXCHANGEDB_ReserveInInfo *reserves,
     unsigned int reserves_length,
     enum GNUNET_DB_QueryStatus *results);
 
 
   /**
    * Insert an incoming KCYAUTH wire transfer into
    * the database and update the authentication key
    * for the origin account.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param account_pub public key of the account
    * @param credit_amount amount we were credited
    * @param execution_date when was the transfer made
    * @param debit_account_uri URI of the debit account
    * @param section_name section of the exchange bank account that received the transfer
    * @param serial_id bank-specific row identifying the transfer
    */
   enum GNUNET_DB_QueryStatus
   (*kycauth_in_insert)(
     void *cls,
     const union TALER_AccountPublicKeyP *account_pub,
     const struct TALER_Amount *credit_amount,
     struct GNUNET_TIME_Timestamp execution_date,
     const struct TALER_FullPayto debit_account_uri,
     const char *section_name,
     uint64_t serial_id);
 
 
   /**
    * Insert an incoming WAD wire transfer into the database.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param wad_id WAD identifier
    * @param origin_exchange_url exchange base URL originating the transfer
    * @param amount the amount that was transferred
    * @param execution_date when was the transfer made
    * @param debit_account_uri URI of the debit account
    * @param section_name section of the exchange bank account that received the transfer
    * @param serial_id bank-specific row identifying the transfer
    */
   enum GNUNET_DB_QueryStatus
   (*wad_in_insert)(
     void *cls,
     const struct TALER_WadIdentifierP *wad_id,
     const char *origin_exchange_url,
     const struct TALER_Amount *amount,
     struct GNUNET_TIME_Timestamp execution_date,
     const struct TALER_FullPayto debit_account_uri,
     const char *section_name,
     uint64_t serial_id);
 
 
   /**
    * Locate a nonce for use with a particular public key.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param nonce the nonce to be locked
    * @param denom_pub_hash hash of the public key of the denomination
    * @param target public key the nonce is to be locked to
    * @return statement execution status
    */
   enum GNUNET_DB_QueryStatus
   (*lock_nonce)(void *cls,
                 const struct GNUNET_CRYPTO_CsSessionNonce *nonce,
                 const struct TALER_DenominationHashP *denom_pub_hash,
                 const union TALER_EXCHANGEDB_NonceLockTargetP *target);
 
   /**
    * Locate the response for a withdraw request under a hash of the
    * commitment that uniquely identifies the withdraw operation.
    * Used to ensure idempotency of the request.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_planchets hash that uniquely identifies the withdraw operation
    * @param[out] wr corresponding details of the previous withdraw request if an entry was found
    * @return statement execution status
    */
   enum GNUNET_DB_QueryStatus
   (*get_withdraw)(
     void *cls,
     const struct TALER_HashBlindedPlanchetsP *h_planchets,
     struct TALER_EXCHANGEDB_Withdraw *wr);
 
   /**
    * Perform an withdraw operation, checking for sufficient balance and
    * fulfillment of age requirements and possibly persisting the withdrawal
    * details.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param withdraw the withdraw data
    * @param[out] balance_ok set to true if the balance was sufficient
    * @param[out] reserve_balance set to original balance of the reserve
    * @param[out] age_ok set to true if age requirements were met
    * @param[out] allowed_maximum_age if @e age_ok is FALSE, this is set to the allowed maximum age
    * @param[out] reserve_birthday if @e age_ok is FALSE, this is set to the reserve's birthday
    * @param[out] idempotent set to true if an entry already exists for the given h_planchets and reserve_pub
    * @param[out] noreveal_index if @e idempotent is true, set to the existing noreveal_index
    * @param[out] nonce_resue set to true if the blinding_seed has been found in the table for a different withdraw
    * @return 0 if no reserve was found, 1 if a reserve was found, else the query execution status
    */
   enum GNUNET_DB_QueryStatus
   (*do_withdraw)(
     void *cls,
     const struct TALER_EXCHANGEDB_Withdraw *withdraw,
     const struct GNUNET_TIME_Timestamp *now,
     bool *balance_ok,
     struct TALER_Amount *reserve_balance,
     bool *age_ok,
     uint16_t *allowed_maximum_age,
     uint32_t *reserve_birthday,
     bool *idempotent,
     uint16_t *noreveal_index,
     bool *nonce_reuse);
 
   /**
    * Retrieve the details to a policy given by its hash_code
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param hc Hash code that identifies the policy
    * @param[out] detail retrieved policy details
    * @return query execution status
    */
   enum GNUNET_DB_QueryStatus
   (*get_policy_details)(
     void *cls,
     const struct GNUNET_HashCode *hc,
     struct TALER_PolicyDetails *detail);
 
   /**
    * Persist the policy details that extends a deposit.  The particular policy
    * - referenced by details->hash_code - might already exist in the table, in
    * which case the call will update the contents of the record with @e details
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param details The parsed `struct TALER_PolicyDetails` according to the responsible policy extension.
    * @param[out] policy_details_serial_id The ID of the entry in the policy_details table
    * @param[out] accumulated_total The total amount accumulated in that policy
    * @param[out] fulfillment_state The state of policy.  If the state was Insufficient prior to the call and the provided deposit raises the accumulated_total above the commitment, it will be set to Ready.
    * @return query execution status
    */
   enum GNUNET_DB_QueryStatus
   (*persist_policy_details)(
     void *cls,
     const struct TALER_PolicyDetails *details,
     uint64_t *policy_details_serial_id,
     struct TALER_Amount *accumulated_total,
     enum TALER_PolicyFulfillmentState *fulfillment_state);
 
 
   /**
    * Perform deposit operation, checking for sufficient balance
    * of the coin and possibly persisting the deposit details.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param bd batch deposit operation details
    * @param deposit_fees array of "bd->num_cids" deposit fees
    *        of the respective coins
    * @param[in,out] exchange_timestamp time to use for the deposit (possibly updated)
    * @param[out] accumulated_total_without_fee set to the sum of all deposits
    *   made for this merchant and contract (minus deposit fees)
    * @param[out] balance_ok set to true if the balance was sufficient
    * @param[out] bad_balance_index set to the first index of a coin for which the balance was insufficient,
    *             only used if @a balance_ok is set to false.
    * @param[out] ctr_conflict set to true if the same contract terms hash was previously submitted with other meta data (deadlines, wallet_data_hash, wire data etc.)
    * @return query execution status
    */
   enum GNUNET_DB_QueryStatus
   (*do_deposit)(
     void *cls,
     const struct TALER_EXCHANGEDB_BatchDeposit *bd,
     const struct TALER_Amount deposit_fees[],
     struct GNUNET_TIME_Timestamp *exchange_timestamp,
     struct TALER_Amount *accumulated_total_without_fee,
     bool *balance_ok,
     uint32_t *bad_balance_index,
     bool *ctr_conflict);
 
 
   /**
    * Check ifdeposit operation is idempotent to existing one.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param bd batch deposit operation details
    * @param[in,out] exchange_timestamp time to use for the deposit (possibly updated)
    * @param[out] is_idempotent set to true if the request is idempotent
    * @return query execution status
    */
   enum GNUNET_DB_QueryStatus
   (*do_check_deposit_idempotent)(
     void *cls,
     const struct TALER_EXCHANGEDB_BatchDeposit *bd,
     struct GNUNET_TIME_Timestamp *exchange_timestamp,
     bool *is_idempotent);
 
   /**
    * Perform refresh operation--introduced with v27 of the API--,
    * checking for sufficient balance of the coin and possibly persisting the melt/refresh details.
    *
    * @param cls the plugin-specific state
    * @param[in,out] refresh refresh operation details; the noreveal_index
    *                is set in case the coin was already melted before
    * @param timestamp the timestamp of this melt operation, helpful for the coin history.
    * @param[in,out] zombie_required true if the melt must only succeed
    *			if the coin is a zombie, set to false if the requirement was satisfied
    * @param[out] found set to true if there exists already an entry in the database for
    *			the calculated commitment hash.
    * @param[out] noreveal_index if @e found ist true, the existing value of the noreveal_index.
    * @param[out] nonce_reuse set to true if the blinding seed for CS was re-used.
    * @param[out] balance_ok set to true if the balance was sufficient
    * @param[out] insufficient_funds if balance_ok is false, set to the remaining value of the coin
    * @return query execution status, NO_RESULTS in case of an unknown coin.
    */
   enum GNUNET_DB_QueryStatus
   (*do_refresh)(
     void *cls,
     struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS *refresh,
     const struct GNUNET_TIME_Timestamp *timestamp,
     bool *found,
     uint32_t *noreveal_index,
     bool *zombie_required,
     bool *nonce_reuse,
     bool *balance_ok,
     struct TALER_Amount *coin_balance);
 
 
   /**
    * Lookup refresh data under the given @a rc, starting with protocol version v27
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param rc commitment to use for the lookup
    * @param[out] refresh where to store the result; note that
    *             refresh->coin.denom_sig will be set to NULL
    *             and is not fetched by this routine (as it is not needed by the client)
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*get_refresh)(void *cls,
                  const struct TALER_RefreshCommitmentP *rc,
                  struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS *refresh);
 
   /**
    * @since vDOLDPLUS
    *
    * Mark the successful reveal for a refresh in the database.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param rc commitment to use for the lookup
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*mark_refresh_reveal_success)(
     void *cls,
     const struct TALER_RefreshCommitmentP *rc);
 
   /**
    * Add a proof of fulfillment of an policy
    *
    * @param cls the plugin-specific state
    * @param[in,out] fulfillment The proof of fulfillment and serial_ids of the policy_details along with their new state and potential new amounts.
    * @return query execution status
    */
   enum GNUNET_DB_QueryStatus
   (*add_policy_fulfillment_proof)(
     void *cls,
     struct TALER_PolicyFulfillmentTransactionData *fulfillment);
 
 
   /**
    * Perform refund operation, checking for sufficient deposits
    * of the coin and possibly persisting the refund details.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param refund refund operation details
    * @param deposit_fee deposit fee applicable for the coin, possibly refunded
    * @param known_coin_id row of the coin in the known_coins table
    * @param[out] not_found set if the deposit was not found
    * @param[out] refund_ok  set if the refund succeeded (below deposit amount)
    * @param[out] gone if the merchant was already paid
    * @param[out] conflict set if the refund ID was reused
    * @return query execution status
    */
   enum GNUNET_DB_QueryStatus
   (*do_refund)(
     void *cls,
     const struct TALER_EXCHANGEDB_Refund *refund,
     const struct TALER_Amount *deposit_fee,
     uint64_t known_coin_id,
     bool *not_found,
     bool *refund_ok,
     bool *gone,
     bool *conflict);
 
 
   /**
    * Perform recoup operation, checking for sufficient deposits
    * of the coin and possibly persisting the recoup details.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param reserve_pub public key of the reserve to credit
    * @param withdraw_serial_id row in the withdraw table justifying the recoup
    * @param coin_bks coin blinding key secret to persist
    * @param coin_pub public key of the coin being recouped
    * @param known_coin_id row of the @a coin_pub in the known_coins table
    * @param coin_sig signature of the coin requesting the recoup
    * @param[in,out] recoup_timestamp recoup timestamp, set if recoup existed
    * @param[out] recoup_ok  set if the recoup succeeded (balance ok)
    * @param[out] internal_failure set on internal failures
    * @return query execution status
    */
   enum GNUNET_DB_QueryStatus
   (*do_recoup)(
     void *cls,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     uint64_t withdraw_serial_id,
     const union GNUNET_CRYPTO_BlindingSecretP *coin_bks,
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     uint64_t known_coin_id,
     const struct TALER_CoinSpendSignatureP *coin_sig,
     struct GNUNET_TIME_Timestamp *recoup_timestamp,
     bool *recoup_ok,
     bool *internal_failure);
 
 
   /**
    * Perform recoup-refresh operation, checking for sufficient deposits of the
    * coin and possibly persisting the recoup-refresh details.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param old_coin_pub public key of the old coin to credit
    * @param rrc_serial row in the refresh_revealed_coins table justifying the recoup-refresh
    * @param coin_bks coin blinding key secret to persist
    * @param coin_pub public key of the coin being recouped
    * @param known_coin_id row of the @a coin_pub in the known_coins table
    * @param coin_sig signature of the coin requesting the recoup
    * @param[in,out] recoup_timestamp recoup timestamp, set if recoup existed
    * @param[out] recoup_ok  set if the recoup-refresh succeeded (balance ok)
    * @param[out] internal_failure set on internal failures
    * @return query execution status
    */
   enum GNUNET_DB_QueryStatus
   (*do_recoup_refresh)(
     void *cls,
     const struct TALER_CoinSpendPublicKeyP *old_coin_pub,
     uint64_t rrc_serial,
     const union GNUNET_CRYPTO_BlindingSecretP *coin_bks,
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     uint64_t known_coin_id,
     const struct TALER_CoinSpendSignatureP *coin_sig,
     struct GNUNET_TIME_Timestamp *recoup_timestamp,
     bool *recoup_ok,
     bool *internal_failure);
 
 
   /**
    * Compile a list of (historic) transactions performed with the given reserve
    * (withdraw, incoming wire, open, close operations).  Should return 0 if the @a
    * reserve_pub is unknown, otherwise determine @a etag_out and if it is past @a
    * etag_in return the history after @a start_off. @a etag_out should be set
    * to the last row ID of the given @a reserve_pub in the reserve history table.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param reserve_pub public key of the reserve
    * @param start_off maximum starting offset in history to exclude from returning
    * @param etag_in up to this offset the client already has a response, do not
    *                   return anything unless @a etag_out will be larger
    * @param[out] etag_out set to the latest history offset known for this @a coin_pub
    * @param[out] balance set to the reserve balance
    * @param[out] rhp set to known transaction history (NULL if reserve is unknown)
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*get_reserve_history)(
     void *cls,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     uint64_t start_off,
     uint64_t etag_in,
     uint64_t *etag_out,
     struct TALER_Amount *balance,
     struct TALER_EXCHANGEDB_ReserveHistory **rhp);
 
 
   /**
    * The current reserve balance of the specified reserve.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param reserve_pub public key of the reserve
    * @param[out] balance set to the reserve balance
    * @param[out] origin_account set to URI of the origin account, NULL
    *     if we have no origin account (reserve created by P2P merge)
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*get_reserve_balance)(
     void *cls,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     struct TALER_Amount *balance,
     struct TALER_FullPayto *origin_account);
 
 
   /**
    * 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,
     struct TALER_EXCHANGEDB_ReserveHistory *rh);
 
 
   /**
    * Count the number of known coins by denomination.
    *
    * @param cls database connection plugin state
    * @param denom_pub_hash denomination to count by
    * @return number of coins if non-negative, otherwise an `enum GNUNET_DB_QueryStatus`
    */
   long long
   (*count_known_coins) (void *cls,
                         const struct TALER_DenominationHashP *denom_pub_hash);
 
 
   /**
    * Make sure the given @a coin is known to the database.
    *
    * @param cls database connection plugin state
    * @param coin the coin that must be made known
    * @param[out] known_coin_id set to the unique row of the coin
    * @param[out] denom_pub_hash set to the conflicting denomination hash on conflict
    * @param[out] age_hash set to the conflicting age hash on conflict
    * @return database transaction status, non-negative on success
    */
   enum TALER_EXCHANGEDB_CoinKnownStatus
   {
     /**
      * The coin was successfully added.
      */
     TALER_EXCHANGEDB_CKS_ADDED = 1,
 
     /**
      * The coin was already present.
      */
     TALER_EXCHANGEDB_CKS_PRESENT = 0,
 
     /**
      * Serialization failure.
      */
     TALER_EXCHANGEDB_CKS_SOFT_FAIL = -1,
 
     /**
      * Hard database failure.
      */
     TALER_EXCHANGEDB_CKS_HARD_FAIL = -2,
 
     /**
      * Conflicting coin (different denomination key) already in database.
      */
     TALER_EXCHANGEDB_CKS_DENOM_CONFLICT = -3,
 
     /**
      * Conflicting coin (expected NULL age hash) already in database.
      */
     TALER_EXCHANGEDB_CKS_AGE_CONFLICT_EXPECTED_NULL = -4,
 
     /**
      * Conflicting coin (unexpected NULL age hash) already in database.
      */
     TALER_EXCHANGEDB_CKS_AGE_CONFLICT_EXPECTED_NON_NULL = -5,
 
     /**
      * Conflicting coin (different age hash) already in database.
      */
     TALER_EXCHANGEDB_CKS_AGE_CONFLICT_VALUE_DIFFERS = -6,
 
   }
   (*ensure_coin_known)(void *cls,
                        const struct TALER_CoinPublicInfo *coin,
                        uint64_t *known_coin_id,
                        struct TALER_DenominationHashP *denom_pub_hash,
                        struct TALER_AgeCommitmentHashP *age_hash);
 
 
   /**
    * Make sure the array of given @a coin is known to the database.
    *
    * @param cls database connection plugin state
    * @param coin array of coins that must be made known
    * @param[out] result array where to store information about each coin
    * @param coin_length length of the @a coin and @a result arraysf
    * @param batch_size desired (maximum) batch size
    * @return database transaction status, non-negative on success
    */
   enum GNUNET_DB_QueryStatus
   (*batch_ensure_coin_known)(
     void *cls,
     const struct TALER_CoinPublicInfo *coin,
     struct TALER_EXCHANGEDB_CoinInfo *result,
     unsigned int coin_length,
     unsigned int batch_size);
 
 
   /**
    * Retrieve information about the given @a coin from the database.
    *
    * @param cls database connection plugin state
    * @param coin_pub the coin that must be made known
    * @param[out] coin_info detailed information about the coin
    * @return database transaction status, non-negative on success
    */
   enum GNUNET_DB_QueryStatus
   (*get_known_coin)(void *cls,
                     const struct TALER_CoinSpendPublicKeyP *coin_pub,
                     struct TALER_CoinPublicInfo *coin_info);
 
   /**
    * Retrieve the signature and corresponding denomination for a given @a coin
    * from the database
    *
    * @param cls database connection plugin state
    * @param coin_pub the public key of the coin we search for
    * @param[out] denom_pub the public key of the denomination that the coin was signed with
    * @param[out] denom_sig the signature with the denomination's private key over the coin_pub
    */
   enum GNUNET_DB_QueryStatus
   (*get_signature_for_known_coin)(
     void *cls,
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     struct TALER_DenominationPublicKey *denom_pub,
     struct TALER_DenominationSignature *denom_sig);
 
   /**
    * Retrieve the denomination of a known coin.
    *
    * @param cls the plugin closure
    * @param coin_pub the public key of the coin to search for
    * @param[out] known_coin_id set to the ID of the coin in the known_coins table
    * @param[out] denom_hash where to store the hash of the coins denomination
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_coin_denomination)(void *cls,
                            const struct TALER_CoinSpendPublicKeyP *coin_pub,
                            uint64_t *known_coin_id,
                            struct TALER_DenominationHashP *denom_hash);
 
 
   /**
    * Try to retrieve the salted hash of the merchant's bank account to a
    * deposit contract. Used in case of conflicts for a given (merchant_pub,
    * h_contract_terms) to provide the client the necessary input to retrieve
    * more details about the conflict.
    *
    * @param cls the plugin closure
    * @param merchant_pub public key of the merchant
    * @param h_contract_terms contract to check for
    * @param[out] h_wire hash of the wire details
    */
   enum GNUNET_DB_QueryStatus
   (*get_wire_hash_for_contract)(
     void *cls,
     const struct TALER_MerchantPublicKeyP *merchant_pub,
     const struct TALER_PrivateContractHashP *h_contract_terms,
     struct TALER_MerchantWireHashP *h_wire);
 
 
   /**
    * Check if we have the specified deposit already in the database.
    *
    * @param cls the `struct PostgresClosure` with the plugin-specific state
    * @param h_contract_terms contract to check for
    * @param h_wire wire hash to check for
    * @param coin_pub public key of the coin to check for
    * @param merchant merchant public key to check for
    * @param refund_deadline expected refund deadline
    * @param[out] deposit_fee set to the deposit fee the exchange charged
    * @param[out] exchange_timestamp set to the time when the exchange received the deposit
    * @return 1 if we know this operation,
    *         0 if this exact deposit is unknown to us,
    *         otherwise transaction error status
    */
   // FIXME: rename!
   enum GNUNET_DB_QueryStatus
   (*have_deposit2)(
     void *cls,
     const struct TALER_PrivateContractHashP *h_contract_terms,
     const struct TALER_MerchantWireHashP *h_wire,
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     const struct TALER_MerchantPublicKeyP *merchant,
     struct GNUNET_TIME_Timestamp refund_deadline,
     struct TALER_Amount *deposit_fee,
     struct GNUNET_TIME_Timestamp *exchange_timestamp);
 
 
   /**
    * Insert information about refunded coin into the database.
    * Used in tests and for benchmarking.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param refund refund information to store
    * @return query result status
    */
   enum GNUNET_DB_QueryStatus
   (*insert_refund)(void *cls,
                    const struct TALER_EXCHANGEDB_Refund *refund);
 
 
   /**
    * Select refunds by @a coin_pub, @a merchant_pub and @a h_contract.
    *
    * @param cls closure of plugin
    * @param coin_pub coin to get refunds for
    * @param merchant_pub merchant to get refunds for
    * @param h_contract_pub contract (hash) to get refunds for
    * @param cb function to call for each refund found
    * @param cb_cls closure for @a cb
    * @return query result status
    */
   enum GNUNET_DB_QueryStatus
   (*select_refunds_by_coin)(
     void *cls,
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     const struct TALER_MerchantPublicKeyP *merchant_pub,
     const struct TALER_PrivateContractHashP *h_contract,
     TALER_EXCHANGEDB_RefundCoinCallback cb,
     void *cb_cls);
 
 
   /**
    * Obtain information about deposits that are ready to be executed.
    * Such deposits must not be marked as "done", and the
    * execution time, the refund deadlines must both be in the past and
    * the KYC status must be 'ok'.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param start_shard_row minimum shard row to select
    * @param end_shard_row maximum shard row to select (inclusive)
    * @param[out] merchant_pub set to the public key of a merchant with a ready deposit
    * @param[out] payto_uri set to the account of the merchant, to be freed by caller
    * @param[out] extra_wire_subject_metadata set to additional metadata to include in the wire subject, or NULL for none
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_ready_deposit)(void *cls,
                        uint64_t start_shard_row,
                        uint64_t end_shard_row,
                        struct TALER_MerchantPublicKeyP *merchant_pub,
                        struct TALER_FullPayto *payto_uri,
                        char **extra_wire_subject_metadata);
 
 
   /**
    * Aggregate all matching deposits for @a h_payto and
    * @a merchant_pub, returning the total amounts.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto destination of the wire transfer
    * @param merchant_pub public key of the merchant
    * @param wtid wire transfer ID to set for the aggregate
    * @param[out] total set to the sum of the total deposits minus applicable deposit fees and refunds
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*aggregate)(
     void *cls,
     const struct TALER_FullPaytoHashP *h_payto,
     const struct TALER_MerchantPublicKeyP *merchant_pub,
     const struct TALER_WireTransferIdentifierRawP *wtid,
     struct TALER_Amount *total);
 
 
   /**
    * Create a new entry in the transient aggregation table.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto destination of the wire transfer
    * @param exchange_account_section exchange account to use
    * @param merchant_pub public key of the merchant
    * @param wtid the raw wire transfer identifier to be used
    * @param kyc_requirement_row row in legitimization_requirements that need to be satisfied to continue, or 0 for none
    * @param total amount to be wired in the future
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*create_aggregation_transient)(
     void *cls,
     const struct TALER_FullPaytoHashP *h_payto,
     const char *exchange_account_section,
     const struct TALER_MerchantPublicKeyP *merchant_pub,
     const struct TALER_WireTransferIdentifierRawP *wtid,
     uint64_t kyc_requirement_row,
     const struct TALER_Amount *total);
 
 
   /**
    * Select existing entry in the transient aggregation table.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto destination of the wire transfer
    * @param merchant_pub public key of the merchant
    * @param exchange_account_section exchange account to use
    * @param[out] wtid set to the raw wire transfer identifier to be used
    * @param[out] total existing amount to be wired in the future
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_aggregation_transient)(
     void *cls,
     const struct TALER_FullPaytoHashP *h_payto,
     const struct TALER_MerchantPublicKeyP *merchant_pub,
     const char *exchange_account_section,
     struct TALER_WireTransferIdentifierRawP *wtid,
     struct TALER_Amount *total);
 
 
   /**
    * Find existing entry in the transient aggregation table.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto destination of the wire transfer
    * @param[out] payto_uri corresponding payto URI, to be freed by caller
    * @param[out] wtid wire transfer identifier of transient aggregation
    * @param[out] merchant_pub public key of the merchant
    * @param[out] total amount aggregated so far
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*find_aggregation_transient)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     struct TALER_FullPayto *payto_uri,
     struct TALER_WireTransferIdentifierRawP *wtid,
     struct TALER_MerchantPublicKeyP *merchant_pub,
     struct TALER_Amount *total);
 
 
   /**
    * Update existing entry in the transient aggregation table.
    * @a h_payto is only needed for query performance.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto destination of the wire transfer
    * @param wtid the raw wire transfer identifier to update
    * @param kyc_requirement_row row in legitimization_requirements that need to be satisfied to continue, or 0 for none
    * @param total new total amount to be wired in the future
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*update_aggregation_transient)(
     void *cls,
     const struct TALER_FullPaytoHashP *h_payto,
     const struct TALER_WireTransferIdentifierRawP *wtid,
     uint64_t kyc_requirement_row,
     const struct TALER_Amount *total);
 
 
   /**
    * Delete existing entry in the transient aggregation table.
    * @a h_payto is only needed for query performance.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto destination of the wire transfer
    * @param wtid the raw wire transfer identifier to update
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*delete_aggregation_transient)(
     void *cls,
     const struct TALER_FullPaytoHashP *h_payto,
     const struct TALER_WireTransferIdentifierRawP *wtid);
 
   /**
    * Compile a list of (historic) transactions performed with the given coin
    * (melt, refund, recoup and deposit operations).  Should return 0 if the @a
    * coin_pub is unknown, otherwise determine @a etag_out and if it is past @a
    * etag_in return the history after @a start_off. @a etag_out should be set
    * to the last row ID of the given @a coin_pub in the coin history table.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param begin_transaction true to run this in its own transaction(s)
    * @param coin_pub coin to investigate
    * @param start_off starting offset from which on to return entries
    * @param etag_in up to this offset the client already has a response, do not
    *                   return anything unless @a etag_out will be larger
    * @param[out] etag_out set to the latest history offset known for this @a coin_pub
    * @param[out] balance set to current balance of the coin
    * @param[out] h_denom_pub set to denomination public key of the coin
    * @param[out] tlp set to list of transactions, set to NULL if coin has no
    *             transaction history past @a start_off or if @a etag_in is equal
    *             to the value written to @a etag_out.
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*get_coin_transactions)(
     void *cls,
     bool begin_transaction,
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     uint64_t start_off,
     uint64_t etag_in,
     uint64_t *etag_out,
     struct TALER_Amount *balance,
     struct TALER_DenominationHashP *h_denom_pub,
     struct TALER_EXCHANGEDB_TransactionList **tlp);
 
 
   /**
    * 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,
     struct TALER_EXCHANGEDB_TransactionList *list);
 
 
   /**
    * 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
    * @param wtid the raw wire transfer identifier we used
    * @param cb function to call on each transaction found
    * @param cb_cls closure for @a cb
    * @return query status of the transaction
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_wire_transfer)(
     void *cls,
     const struct TALER_WireTransferIdentifierRawP *wtid,
     TALER_EXCHANGEDB_AggregationDataCallback cb,
     void *cb_cls);
 
 
   /**
    * 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.
    *
    * @param cls closure
    * @param h_contract_terms hash of the proposal data
    * @param h_wire hash of merchant wire details
    * @param coin_pub public key of deposited coin
    * @param merchant_pub merchant public key
    * @param[out] pending set to true if the transaction is still pending
    * @param[out] wtid wire transfer identifier, only set if @a pending is false
    * @param[out] coin_contribution how much did the coin we asked about
    *        contribute to the total transfer value? (deposit value including fee)
    * @param[out] coin_fee how much did the exchange charge for the deposit fee
    * @param[out] execution_time when was the transaction done, or
    *         when we expect it to be done (if @a pending is false)
    * @param[out] kyc set to the kyc status of the receiver (if @a pending)
    * @param[out] account_pub set to public key that is authorized to start the KYC process; unchanged if no such key is known
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_transfer_by_deposit)(
     void *cls,
     const struct TALER_PrivateContractHashP *h_contract_terms,
     const struct TALER_MerchantWireHashP *h_wire,
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     const struct TALER_MerchantPublicKeyP *merchant_pub,
     bool *pending,
     struct TALER_WireTransferIdentifierRawP *wtid,
     struct GNUNET_TIME_Timestamp *exec_time,
     struct TALER_Amount *amount_with_fee,
     struct TALER_Amount *deposit_fee,
     struct TALER_EXCHANGEDB_KycStatus *kyc,
     union TALER_AccountPublicKeyP *account_pub);
 
 
   /**
    * Insert wire transfer fee into database.
    *
    * @param cls closure
    * @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 fees how high is are the wire fees
    * @param master_sig signature over the above by the exchange master key
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_wire_fee)(
     void *cls,
     const char *wire_method,
     struct GNUNET_TIME_Timestamp start_date,
     struct GNUNET_TIME_Timestamp end_date,
     const struct TALER_WireFeeSet *fees,
     const struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Insert global fee set into database.
    *
    * @param cls closure
    * @param start_date when does the fees go into effect
    * @param end_date when does the fees end being valid
    * @param fees how high is are the global fees
    * @param purse_timeout when do purses time out
    * @param history_expiration how long are account histories preserved
    * @param purse_account_limit how many purses are free per account
    * @param master_sig signature over the above by the exchange master key
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_global_fee)(
     void *cls,
     struct GNUNET_TIME_Timestamp start_date,
     struct GNUNET_TIME_Timestamp end_date,
     const struct TALER_GlobalFeeSet *fees,
     struct GNUNET_TIME_Relative purse_timeout,
     struct GNUNET_TIME_Relative history_expiration,
     uint32_t purse_account_limit,
     const struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Obtain wire fee from database.
    *
    * @param cls closure
    * @param type type of wire transfer the fee applies for
    * @param date for which date do we want the fee?
    * @param[out] rowid set to row in the database with the wire 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] fees how high are the wire fees
    * @param[out] master_sig signature over the above by the exchange master key
    * @return query status of the transaction
    */
   enum GNUNET_DB_QueryStatus
   (*get_wire_fee)(
     void *cls,
     const char *type,
     struct GNUNET_TIME_Timestamp date,
     uint64_t *rowid,
     struct GNUNET_TIME_Timestamp *start_date,
     struct GNUNET_TIME_Timestamp *end_date,
     struct TALER_WireFeeSet *fees,
     struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Obtain global fees from database.
    *
    * @param cls closure
    * @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] fees how high are the global fees
    * @param[out] purse_timeout when do purses time out
    * @param[out] history_expiration how long are account histories preserved
    * @param[out] purse_account_limit how many purses are free per account
    * @param[out] master_sig signature over the above by the exchange master key
    * @return query status of the transaction
    */
   enum GNUNET_DB_QueryStatus
   (*get_global_fee)(
     void *cls,
     struct GNUNET_TIME_Timestamp date,
     struct GNUNET_TIME_Timestamp *start_date,
     struct GNUNET_TIME_Timestamp *end_date,
     struct TALER_GlobalFeeSet *fees,
     struct GNUNET_TIME_Relative *purse_timeout,
     struct GNUNET_TIME_Relative *history_expiration,
     uint32_t *purse_account_limit,
     struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Obtain information about expired reserves and their
    * remaining balances.
    *
    * @param cls closure of the plugin
    * @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 transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*get_expired_reserves)(
     void *cls,
     struct GNUNET_TIME_Timestamp now,
     TALER_EXCHANGEDB_ReserveExpiredCallback rec,
     void *rec_cls);
 
 
   /**
    * Obtain information about force-closed reserves
    * where the close was not yet done (and their remaining
    * balances).  Updates the returned reserve's close
    * status to "done".
    *
    * @param cls closure of the plugin
    * @param rec function to call on (to be) closed reserves
    * @param rec_cls closure for @a rec
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*get_unfinished_close_requests)(
     void *cls,
     TALER_EXCHANGEDB_ReserveExpiredCallback rec,
     void *rec_cls);
 
 
   /**
    * Insert reserve open coin deposit data into database.
    * Subtracts the @a coin_total from the coin's balance.
    *
    * @param cls closure
    * @param cpi public information about the coin
    * @param coin_sig signature with @e coin_pub of type #TALER_SIGNATURE_WALLET_RESERVE_OPEN_DEPOSIT
    * @param known_coin_id ID of the coin in the known_coins table
    * @param coin_total amount to be spent of the coin (including deposit fee)
    * @param reserve_sig signature by the reserve affirming the open operation
    * @param reserve_pub public key of the reserve being opened
    * @param[out] insufficient_funds set to true if the coin's balance is insufficient, otherwise to false
    * @return transaction status code, 0 if operation is already in the DB
    */
   enum GNUNET_DB_QueryStatus
   (*insert_reserve_open_deposit)(
     void *cls,
     const struct TALER_CoinPublicInfo *cpi,
     const struct TALER_CoinSpendSignatureP *coin_sig,
     uint64_t known_coin_id,
     const struct TALER_Amount *coin_total,
     const struct TALER_ReserveSignatureP *reserve_sig,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     bool *insufficient_funds);
 
 
   /**
    * Insert reserve close operation into database.
    *
    * @param cls closure
    * @param reserve_pub which reserve is this about?
    * @param total_paid total amount paid (coins and reserve)
    * @param reserve_payment amount to be paid from the reserve
    * @param min_purse_limit minimum number of purses we should be able to open
    * @param reserve_sig signature by the reserve for the operation
    * @param desired_expiration when should the reserve expire (earliest time)
    * @param now when did we the client initiate the action
    * @param open_fee annual fee to be charged for the open operation by the exchange
    * @param[out] no_funds set to true if reserve balance is insufficient
    * @param[out] reserve_balance set to original balance of the reserve
    * @param[out] open_cost set to the actual cost
    * @param[out] final_expiration when will the reserve expire now
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*do_reserve_open)(
     void *cls,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     const struct TALER_Amount *total_paid,
     const struct TALER_Amount *reserve_payment,
     uint32_t min_purse_limit,
     const struct TALER_ReserveSignatureP *reserve_sig,
     struct GNUNET_TIME_Timestamp desired_expiration,
     struct GNUNET_TIME_Timestamp now,
     const struct TALER_Amount *open_fee,
     bool *no_funds,
     struct TALER_Amount *reserve_balance,
     struct TALER_Amount *open_cost,
     struct GNUNET_TIME_Timestamp *final_expiration);
 
 
   /**
    * Select information needed to see if we can close
    * a reserve.
    *
    * @param cls closure
    * @param reserve_pub which reserve is this about?
    * @param[out] balance current reserve balance
    * @param[out] payto_uri set to URL of account that
    *             originally funded the reserve;
    *             could be set to NULL if not known
    * @return transaction status code, 0 if reserve unknown
    */
   enum GNUNET_DB_QueryStatus
   (*select_reserve_close_info)(
     void *cls,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     struct TALER_Amount *balance,
     struct TALER_FullPayto *payto_uri);
 
 
   /**
    * Select information about reserve close requests.
    *
    * @param cls closure
    * @param reserve_pub which reserve is this about?
    * @param rowid row ID of the close request
    * @param[out] reserve_sig reserve signature affirming
    * @param[out] request_timestamp when was the request made
    * @param[out] close_balance reserve balance at close time
    * @param[out] close_fee closing fee to be charged
    * @param[out] payto_uri set to URL of account that
    *             should receive the money;
    *             could be set to NULL for origin
    * @return transaction status code, 0 if reserve unknown
    */
   enum GNUNET_DB_QueryStatus
   (*select_reserve_close_request_info)(
     void *cls,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     uint64_t rowid,
     struct TALER_ReserveSignatureP *reserve_sig,
     struct GNUNET_TIME_Timestamp *request_timestamp,
     struct TALER_Amount *close_balance,
     struct TALER_Amount *close_fee,
     struct TALER_FullPayto *payto_uri);
 
 
   /**
    * Select information needed for KYC checks on reserve close: historic
    * reserve closures going to the same account.
    *
    * @param cls closure
    * @param h_payto which target account is this about?
    * @param time_limit oldest transaction that could be relevant
    * @param kac function to call for each applicable amount, in reverse chronological order (or until @a kac aborts by returning anything except #GNUNET_OK).
    * @param kac_cls closure for @a kac
    * @return transaction status code, @a kac aborting with #GNUNET_NO is not an error
    */
   enum GNUNET_DB_QueryStatus
   (*iterate_reserve_close_info)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     struct GNUNET_TIME_Absolute time_limit,
     TALER_EXCHANGEDB_KycAmountCallback kac,
     void *kac_cls);
 
 
   /**
    * Insert reserve close operation into database.
    *
    * @param cls closure
    * @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, in payto://-format
    * @param wtid identifier for the wire transfer
    * @param amount_with_fee amount we charged to the reserve
    * @param closing_fee how high is the closing fee
    * @param close_request_row identifies explicit close request, 0 for none
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_reserve_closed)(
     void *cls,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     struct GNUNET_TIME_Timestamp execution_date,
     const struct TALER_FullPayto receiver_account,
     const struct TALER_WireTransferIdentifierRawP *wtid,
     const struct TALER_Amount *amount_with_fee,
     const struct TALER_Amount *closing_fee,
     uint64_t close_request_row);
 
 
   /**
    * Function called to insert wire transfer commit data into the DB.
    *
    * @param cls closure
    * @param type type of the wire transfer (i.e. "iban")
    * @param buf buffer with wire transfer preparation data
    * @param buf_size number of bytes in @a buf
    * @return query status code
    */
   enum GNUNET_DB_QueryStatus
   (*wire_prepare_data_insert)(void *cls,
                               const char *type,
                               const char *buf,
                               size_t buf_size);
 
 
   /**
    * Function called to mark wire transfer commit data as finished.
    *
    * @param cls closure
    * @param rowid which entry to mark as finished
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*wire_prepare_data_mark_finished)(void *cls,
                                      uint64_t rowid);
 
 
   /**
    * Function called to mark wire transfer as failed.
    *
    * @param cls closure
    * @param rowid which entry to mark as failed
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*wire_prepare_data_mark_failed)(void *cls,
                                    uint64_t rowid);
 
 
   /**
    * Function called to get an unfinished wire transfer
    * preparation data.
    *
    * @param cls closure
    * @param start_row offset to query table at
    * @param limit maximum number of results to return
    * @param cb function to call for unfinished work
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*wire_prepare_data_get)(
     void *cls,
     uint64_t start_row,
     uint64_t limit,
     TALER_EXCHANGEDB_WirePreparationIterator cb,
     void *cb_cls);
 
 
   /**
    * Starts a READ COMMITTED 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
    * @return #GNUNET_OK on success
    */
   enum GNUNET_GenericReturnValue
   (*start_deferred_wire_out)(void *cls);
 
 
   /**
    * Store information about an outgoing wire transfer that was executed.
    *
    * @param cls closure
    * @param date time of the wire transfer
    * @param h_payto identifies the receiver account of the wire transfer
    * @param wire_account details about the receiver account of the wire transfer,
    *        including 'url' in payto://-format
    * @param amount amount that was transmitted
    * @param exchange_account_section configuration section of the exchange specifying the
    *        exchange's bank account being used
    * @param extra_wire_subject_metadata additional meta data for the wire transfer subject, can be NULL
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*store_wire_transfer_out)(
     void *cls,
     struct GNUNET_TIME_Timestamp date,
     const struct TALER_WireTransferIdentifierRawP *wtid,
     const struct TALER_FullPaytoHashP *h_payto,
     const char *exchange_account_section,
     const struct TALER_Amount *amount,
     const char *extra_wire_subject_metadata);
 
 
   /**
    * Function called to perform "garbage collection" on the
    * database, expiring records we no longer require.
    *
    * @param cls closure
    * @return #GNUNET_OK on success,
    *         #GNUNET_SYSERR on DB errors
    */
   enum GNUNET_GenericReturnValue
   (*gc)(void *cls);
 
 
   /**
    * Select deposits above @a serial_id in monotonically increasing
    * order.
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_coin_deposits_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_DepositCallback cb,
     void *cb_cls);
 
 
   /**
    * Function called to return meta data about a purses
    * above a certain serial ID.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param serial_id number to select requests by
    * @param cb function to call on each request
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_purse_requests_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_PurseRequestCallback cb,
     void *cb_cls);
 
 
   /**
    * Select purse deposits above @a serial_id in monotonically increasing
    * order.
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_purse_deposits_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_PurseDepositCallback cb,
     void *cb_cls);
 
 
   /**
    * Select account merges above @a serial_id in monotonically increasing
    * order.
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_account_merges_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_AccountMergeCallback cb,
     void *cb_cls);
 
 
   /**
    * Select purse merges deposits above @a serial_id in monotonically increasing
    * order.
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_purse_merges_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_PurseMergeCallback cb,
     void *cb_cls);
 
 
   /**
    * Select purse refunds above @a serial_id in monotonically increasing
    * order.
    *
    * @param cls closure
    * @param serial_id highest serial ID to exclude (select strictly larger)
    * @param refunded which refund status to select for
    * @param cb function to call on each result
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_purse_decisions_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     bool refunded,
     TALER_EXCHANGEDB_PurseDecisionCallback cb,
     void *cb_cls);
 
 
   /**
    * Select all purse decisions above @a serial_id in monotonically increasing
    * order.
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_all_purse_decisions_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_AllPurseDecisionCallback cb,
     void *cb_cls);
 
 
   /**
    * Select all purse deletions above @a serial_id in monotonically increasing
    * order.
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_all_purse_deletions_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_AllPurseDeletionsCallback cb,
     void *cb_cls);
 
 
   /**
    * Select coins deposited into a purse.
    *
    * @param cls closure
    * @param purse_pub public key of the purse
    * @param cb function to call on each result
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_purse_deposits_by_purse)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     TALER_EXCHANGEDB_PurseRefundCoinCallback cb,
     void *cb_cls);
 
 
   /**
    * Select refresh sessions above @a serial_id in monotonically increasing
    * order.
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_refreshes_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_RefreshesCallback cb,
     void *cb_cls);
 
 
   /**
    * Select refunds above @a serial_id in monotonically increasing
    * order.
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_refunds_above_serial_id)(
     void *cls,
     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 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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_reserves_in_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_ReserveInCallback cb,
     void *cb_cls);
 
 
   /**
    * Select inbound wire transfers into reserves_in above @a serial_id
    * in monotonically increasing order by @a account_name.
    *
    * @param cls closure
    * @param account_name name of the account for which we do the selection
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_reserves_in_above_serial_id_by_account)(
     void *cls,
     const char *account_name,
     uint64_t serial_id,
     TALER_EXCHANGEDB_ReserveInCallback cb,
     void *cb_cls);
 
 
   /**
    * Select withdraw operations from withdraw table above @a serial_id
    * in monotonically increasing order.
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_withdrawals_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_WithdrawCallback cb,
     void *cb_cls);
 
 
   /**
    * Function called to select outgoing wire transfers the exchange
    * executed, ordered by serial ID (monotonically increasing).
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_wire_out_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_WireTransferOutCallback cb,
     void *cb_cls);
 
   /**
    * Function called to select outgoing wire transfers the exchange
    * executed, ordered by serial ID (monotonically increasing).
    *
    * @param cls closure
    * @param account_name name to select by
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_wire_out_above_serial_id_by_account)(
     void *cls,
     const char *account_name,
     uint64_t serial_id,
     TALER_EXCHANGEDB_WireTransferOutCallback cb,
     void *cb_cls);
 
 
   /**
    * Function called to select recoup requests the exchange
    * received, ordered by serial ID (monotonically increasing).
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_recoup_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_RecoupCallback cb,
     void *cb_cls);
 
 
   /**
    * Function called to select recoup requests the exchange received for
    * refreshed coins, ordered by serial ID (monotonically increasing).
    *
    * @param cls closure
    * @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 transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_recoup_refresh_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_RecoupRefreshCallback cb,
     void *cb_cls);
 
 
   /**
    * Function called to select reserve open operations, ordered by serial ID
    * (monotonically increasing).
    *
    * @param cls closure
    * @param serial_id lowest serial ID to include (select larger or equal)
    * @param cb function to call
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_reserve_open_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_ReserveOpenCallback cb,
     void *cb_cls);
 
 
   /**
  * Function called to select reserve close operations the aggregator
  * triggered, ordered by serial ID (monotonically increasing).
  *
  * @param cls closure
  * @param serial_id lowest serial ID to include (select larger or equal)
  * @param cb function to call
  * @param cb_cls closure for @a cb
  * @return transaction status code
  */
   enum GNUNET_DB_QueryStatus
   (*select_reserve_closed_above_serial_id)(
     void *cls,
     uint64_t serial_id,
     TALER_EXCHANGEDB_ReserveClosedCallback cb,
     void *cb_cls);
 
 
   /**
    * Obtain information about which reserve was involved in a
    * withdraw protocol, given the commitment.
    *
    * @param cls closure
    * @param h_planchets hash of the planchets, identifying the withdraw operation
    * @param[out] reserve_pub set to information about the reserve (on success only)
    * @param[out] withdraw_serial_id set to row of the @a h_planchet in withdraw
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_reserve_by_h_planchets)(
     void *cls,
     const struct TALER_HashBlindedPlanchetsP *h_planchets,
     struct TALER_ReservePublicKeyP *reserve_pub,
     uint64_t *withdraw_serial_id);
 
 
   /**
    * Obtain information about which old coin a coin was refreshed
    * given the hash of the blinded (fresh) coin.
    *
    * @param cls closure
    * @param h_blind_ev hash of the blinded coin
    * @param[out] old_coin_pub set to information about the old coin (on success only)
    * @param[out] rrc_serial set to the row of the @a h_blind_ev in the refresh_revealed_coins table
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_old_coin_by_h_blind)(
     void *cls,
     const struct TALER_BlindedCoinHashP *h_blind_ev,
     struct TALER_CoinSpendPublicKeyP *old_coin_pub,
     uint64_t *rrc_serial);
 
 
   /**
    * Store information that a denomination key was revoked
    * in the database.
    *
    * @param cls closure
    * @param denom_pub_hash hash of the revoked denomination key
    * @param master_sig signature affirming the revocation
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_denomination_revocation)(
     void *cls,
     const struct TALER_DenominationHashP *denom_pub_hash,
     const struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Obtain information about a denomination key's revocation from
    * the database.
    *
    * @param cls closure
    * @param denom_pub_hash hash of the revoked denomination key
    * @param[out] master_sig signature affirming the revocation
    * @param[out] rowid row where the information is stored
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_denomination_revocation)(
     void *cls,
     const struct TALER_DenominationHashP *denom_pub_hash,
     struct TALER_MasterSignatureP *master_sig,
     uint64_t *rowid);
 
 
   /**
    * Select all (batch) deposits in the database
    * above a given @a min_batch_deposit_serial_id.
    *
    * @param cls closure
    * @param min_batch_deposit_serial_id only return entries strictly above this row (and in order)
    * @param cb function to call on all such deposits
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_batch_deposits_missing_wire)(
     void *cls,
     uint64_t min_batch_deposit_serial_id,
     TALER_EXCHANGEDB_WireMissingCallback cb,
     void *cb_cls);
 
 
   /**
    * Select all aggregation tracking IDs in the database
    * above a given @a min_tracking_serial_id.
    *
    * @param cls closure
    * @param min_tracking_serial_id only return entries strictly above this row (and in order)
    * @param cb function to call on all such aggregations
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_aggregations_above_serial)(
     void *cls,
     uint64_t min_tracking_serial_id,
     TALER_EXCHANGEDB_AggregationCallback cb,
     void *cb_cls);
 
 
   /**
    * Return any applicable justification as to why a wire transfer might have
    * been held.  Used by the auditor to determine if a wire transfer is
    * legitimately stalled.
    *
    * @param cls closure
    * @param wire_target_h_payto effected target account
    * @param[out] payto_uri target account URI, set to NULL if unknown
    * @param[out] jproperties account properties
    * @param[out] jrules applicable KYC rules
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_justification_for_missing_wire)(
     void *cls,
     const struct TALER_FullPaytoHashP *wire_target_h_payto,
     struct TALER_FullPayto *payto_uri,
     json_t **jproperties,
     json_t **jrules);
 
 
   /**
    * Check the last date an auditor was modified.
    *
    * @param cls closure
    * @param auditor_pub key to look up information for
    * @param[out] last_date last modification date to auditor status
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_auditor_timestamp)(
     void *cls,
     const struct TALER_AuditorPublicKeyP *auditor_pub,
     struct GNUNET_TIME_Timestamp *last_date);
 
 
   /**
    * Lookup current state of an auditor.
    *
    * @param cls closure
    * @param auditor_pub key to look up information for
    * @param[out] auditor_url set to the base URL of the auditor's REST API; memory to be
    *            released by the caller!
    * @param[out] enabled set if the auditor is currently in use
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_auditor_status)(
     void *cls,
     const struct TALER_AuditorPublicKeyP *auditor_pub,
     char **auditor_url,
     bool *enabled);
 
 
   /**
    * Insert information about an auditor that will audit this exchange.
    *
    * @param cls closure
    * @param auditor_pub key of the auditor
    * @param auditor_url base URL of the auditor's REST service
    * @param auditor_name name of the auditor (for humans)
    * @param start_date date when the auditor was added by the offline system
    *                      (only to be used for replay detection)
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_auditor)(
     void *cls,
     const struct TALER_AuditorPublicKeyP *auditor_pub,
     const char *auditor_url,
     const char *auditor_name,
     struct GNUNET_TIME_Timestamp start_date);
 
 
   /**
    * Update information about an auditor that will audit this exchange.
    *
    * @param cls closure
    * @param auditor_pub key of the auditor (primary key for the existing record)
    * @param auditor_url base URL of the auditor's REST service, to be updated
    * @param auditor_name name of the auditor (for humans)
    * @param change_date date when the auditor status was last changed
    *                      (only to be used for replay detection)
    * @param enabled true to enable, false to disable
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*update_auditor)(
     void *cls,
     const struct TALER_AuditorPublicKeyP *auditor_pub,
     const char *auditor_url,
     const char *auditor_name,
     struct GNUNET_TIME_Timestamp change_date,
     bool enabled);
 
 
   /**
    * Check the last date an exchange wire account was modified.
    *
    * @param cls closure
    * @param payto_uri key to look up information for
    * @param[out] last_date last modification date to auditor status
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_wire_timestamp)(void *cls,
                            const struct TALER_FullPayto payto_uri,
                            struct GNUNET_TIME_Timestamp *last_date);
 
 
   /**
    * Insert information about an wire account used by this exchange.
    *
    * @param cls closure
    * @param payto_uri wire account of the exchange
    * @param conversion_url URL of a conversion service, NULL if there is no conversion
    * @param open_banking_gateway open banking gateway service, NULL if unavailable
    * @param wire_transfer_gateway wire transfer gateway service, NULL if unavailable
    * @param debit_restrictions JSON array with debit restrictions on the account
    * @param credit_restrictions JSON array with credit restrictions on the account
    * @param start_date date when the account was added by the offline system
    *                      (only to be used for replay detection)
    * @param master_sig public signature affirming the existence of the account,
    *         must be of purpose #TALER_SIGNATURE_MASTER_WIRE_DETAILS
    * @param bank_label label to show this entry under in the UI, can be NULL
    * @param priority determines order in which entries are shown in the UI
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_wire)(void *cls,
                  const struct TALER_FullPayto payto_uri,
                  const char *conversion_url,
                  const char *open_banking_gateway,
                  const char *wire_transfer_gateway,
                  const json_t *debit_restrictions,
                  const json_t *credit_restrictions,
                  struct GNUNET_TIME_Timestamp start_date,
                  const struct TALER_MasterSignatureP *master_sig,
                  const char *bank_label,
                  int64_t priority);
 
 
   /**
    * Update information about a wire account of the exchange.
    *
    * @param cls closure
    * @param payto_uri account the update is about
    * @param conversion_url URL of a conversion service, NULL if there is no conversion
    * @param open_banking_gateway open banking gateway service, NULL if unavailable
    * @param wire_transfer_gateway wire transfer gateway service, NULL if unavailable
    * @param debit_restrictions JSON array with debit restrictions on the account; NULL allowed if not @a enabled
    * @param credit_restrictions JSON array with credit restrictions on the account; NULL allowed if not @a enabled
    * @param change_date date when the account status was last changed
    *                      (only to be used for replay detection)
    * @param master_sig master signature to store, can be NULL (if @a enabled is false)
    * @param bank_label label to show this entry under in the UI, can be NULL
    * @param priority determines order in which entries are shown in the UI
    * @param enabled true to enable, false to disable (the actual change)
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*update_wire)(void *cls,
                  const struct TALER_FullPayto payto_uri,
                  const char *conversion_url,
                  const char *open_banking_gateway,
                  const char *wire_transfer_gateway,
                  const json_t *debit_restrictions,
                  const json_t *credit_restrictions,
                  struct GNUNET_TIME_Timestamp change_date,
                  const struct TALER_MasterSignatureP *master_sig,
                  const char *bank_label,
                  int64_t priority,
                  bool enabled);
 
 
   /**
    * Obtain information about the enabled wire accounts of the exchange.
    *
    * @param cls closure
    * @param cb function to call on each account
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_wire_accounts)(void *cls,
                        TALER_EXCHANGEDB_WireAccountCallback cb,
                        void *cb_cls);
 
 
   /**
    * Obtain information about the fee structure of the exchange for
    * a given @a wire_method
    *
    * @param cls closure
    * @param wire_method which wire method to obtain fees for
    * @param cb function to call on each account
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_wire_fees)(void *cls,
                    const char *wire_method,
                    TALER_EXCHANGEDB_WireFeeCallback cb,
                    void *cb_cls);
 
 
   /**
    * Obtain information about the global fee structure of the exchange.
    *
    * @param cls closure
    * @param cb function to call on each fee entry
    * @param cb_cls closure for @a cb
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_global_fees)(void *cls,
                      TALER_EXCHANGEDB_GlobalFeeCallback cb,
                      void *cb_cls);
 
 
   /**
    * Store information about a revoked online signing key.
    *
    * @param cls closure
    * @param exchange_pub exchange online signing key that was revoked
    * @param master_sig signature affirming the revocation
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_signkey_revocation)(
     void *cls,
     const struct TALER_ExchangePublicKeyP *exchange_pub,
     const struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Obtain information about a revoked online signing key.
    *
    * @param cls closure
    * @param exchange_pub exchange online signing key that was revoked
    * @param[out] master_sig signature affirming the revocation
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_signkey_revocation)(
     void *cls,
     const struct TALER_ExchangePublicKeyP *exchange_pub,
     struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Lookup information about current denomination key.
    *
    * @param cls closure
    * @param h_denom_pub hash of the denomination public key
    * @param[out] meta set to various meta data about the key
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_denomination_key)(
     void *cls,
     const struct TALER_DenominationHashP *h_denom_pub,
     struct TALER_EXCHANGEDB_DenominationKeyMetaData *meta);
 
 
   /**
    * Add denomination key.
    *
    * @param cls closure
    * @param h_denom_pub hash of the denomination public key
    * @param denom_pub the denomination public key
    * @param meta meta data about the denomination
    * @param master_sig master signature to add
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*add_denomination_key)(
     void *cls,
     const struct TALER_DenominationHashP *h_denom_pub,
     const struct TALER_DenominationPublicKey *denom_pub,
     const struct TALER_EXCHANGEDB_DenominationKeyMetaData *meta,
     const struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Activate future signing key, turning it into a "current" or "valid"
    * denomination key by adding the master signature.
    *
    * @param cls closure
    * @param exchange_pub the exchange online signing public key
    * @param meta meta data about @a exchange_pub
    * @param master_sig master signature to add
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*activate_signing_key)(
     void *cls,
     const struct TALER_ExchangePublicKeyP *exchange_pub,
     const struct TALER_EXCHANGEDB_SignkeyMetaData *meta,
     const struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Lookup signing key meta data.
    *
    * @param cls closure
    * @param exchange_pub the exchange online signing public key
    * @param[out] meta meta data about @a exchange_pub
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_signing_key)(
     void *cls,
     const struct TALER_ExchangePublicKeyP *exchange_pub,
     struct TALER_EXCHANGEDB_SignkeyMetaData *meta);
 
 
   /**
    * Insert information about an auditor auditing a denomination key.
    *
    * @param cls closure
    * @param h_denom_pub the audited denomination
    * @param auditor_pub the auditor's key
    * @param auditor_sig signature affirming the auditor's audit activity
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_auditor_denom_sig)(
     void *cls,
     const struct TALER_DenominationHashP *h_denom_pub,
     const struct TALER_AuditorPublicKeyP *auditor_pub,
     const struct TALER_AuditorSignatureP *auditor_sig);
 
 
   /**
    * Obtain information about an auditor auditing a denomination key.
    *
    * @param cls closure
    * @param h_denom_pub the audited denomination
    * @param auditor_pub the auditor's key
    * @param[out] auditor_sig set to signature affirming the auditor's audit activity
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_auditor_denom_sig)(
     void *cls,
     const struct TALER_DenominationHashP *h_denom_pub,
     const struct TALER_AuditorPublicKeyP *auditor_pub,
     struct TALER_AuditorSignatureP *auditor_sig);
 
 
   /**
    * Lookup information about known wire fees.
    *
    * @param cls closure
    * @param wire_method the wire method to lookup fees for
    * @param start_time starting time of fee
    * @param end_time end time of fee
    * @param[out] fees set to wire fees for that time period; if
    *             different wire fee exists within this time
    *             period, an 'invalid' amount is returned.
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_wire_fee_by_time)(
     void *cls,
     const char *wire_method,
     struct GNUNET_TIME_Timestamp start_time,
     struct GNUNET_TIME_Timestamp end_time,
     struct TALER_WireFeeSet *fees);
 
 
   /**
    * Lookup information about known global fees.
    *
    * @param cls closure
    * @param start_time starting time of fee
    * @param end_time end time of fee
    * @param[out] fees set to wire fees for that time period; if
    *             different global fee exists within this time
    *             period, an 'invalid' amount is returned.
    * @param[out] purse_timeout set to when unmerged purses expire
    * @param[out] history_expiration set to when we expire reserve histories
    * @param[out] purse_account_limit set to number of free purses
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_global_fee_by_time)(
     void *cls,
     struct GNUNET_TIME_Timestamp start_time,
     struct GNUNET_TIME_Timestamp end_time,
     struct TALER_GlobalFeeSet *fees,
     struct GNUNET_TIME_Relative *purse_timeout,
     struct GNUNET_TIME_Relative *history_expiration,
     uint32_t *purse_account_limit);
 
 
   /**
    * Lookup the latest serial number of @a table.  Used in
    * exchange-auditor database replication.
    *
    * @param cls closure
    * @param table table for which we should return the serial
    * @param[out] latest serial number in use
    * @return transaction status code, #GNUNET_DB_STATUS_HARD_ERROR if
    *         @a table does not have a serial number
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_serial_by_table)(void *cls,
                             enum TALER_EXCHANGEDB_ReplicatedTable table,
                             uint64_t *serial);
 
   /**
    * Lookup records above @a serial number in @a table. Used in
    * exchange-auditor database replication.
    *
    * @param cls closure
    * @param table table for which we should return the serial
    * @param serial largest serial number to exclude
    * @param cb function to call on the records
    * @param cb_cls closure for @a cb
    * @return transaction status code, GNUNET_DB_STATUS_HARD_ERROR if
    *         @a table does not have a serial number
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_records_by_table)(void *cls,
                              enum TALER_EXCHANGEDB_ReplicatedTable table,
                              uint64_t serial,
                              TALER_EXCHANGEDB_ReplicationCallback cb,
                              void *cb_cls);
 
 
   /**
    * Insert record set into @a table.  Used in exchange-auditor database
    * replication.
    *
   memset (&awc, 0, sizeof (awc));
    * @param cls closure
    * @param tb table data to insert
    * @return transaction status code, #GNUNET_DB_STATUS_HARD_ERROR if
    *         @a table does not have a serial number
    */
   enum GNUNET_DB_QueryStatus
   (*insert_records_by_table)(void *cls,
                              const struct TALER_EXCHANGEDB_TableData *td);
 
 
   /**
    * Function called to grab a work shard on an operation @a op. Runs in its
    * own transaction.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param job_name name of the operation to grab a word shard for
    * @param delay minimum age of a shard to grab
    * @param size desired shard size
    * @param[out] start_row inclusive start row of the shard (returned)
    * @param[out] end_row exclusive end row of the shard (returned)
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*begin_shard)(void *cls,
                  const char *job_name,
                  struct GNUNET_TIME_Relative delay,
                  uint64_t shard_size,
                  uint64_t *start_row,
                  uint64_t *end_row);
 
   /**
    * Function called to abort work on a shard.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param job_name name of the operation to abort a word shard for
    * @param start_row inclusive start row of the shard
    * @param end_row exclusive end row of the shard
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*abort_shard)(void *cls,
                  const char *job_name,
                  uint64_t start_row,
                  uint64_t end_row);
 
   /**
    * Function called to persist that work on a shard was completed.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param job_name name of the operation to grab a word shard for
    * @param start_row inclusive start row of the shard
    * @param end_row exclusive end row of the shard
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*complete_shard)(void *cls,
                     const char *job_name,
                     uint64_t start_row,
                     uint64_t end_row);
 
 
   /**
    * Function called to grab a revolving work shard on an operation @a op. Runs
    * in its own transaction. Returns the oldest inactive shard.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param job_name name of the operation to grab a revolving shard for
    * @param shard_size desired shard size
    * @param shard_limit exclusive end of the shard range
    * @param[out] start_row inclusive start row of the shard (returned)
    * @param[out] end_row inclusive end row of the shard (returned)
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*begin_revolving_shard)(void *cls,
                            const char *job_name,
                            uint32_t shard_size,
                            uint32_t shard_limit,
                            uint32_t *start_row,
                            uint32_t *end_row);
 
 
   /**
    * Function called to release a revolving shard back into the work pool.
    * Clears the "completed" flag.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param job_name name of the operation to grab a word shard for
    * @param start_row inclusive start row of the shard
    * @param end_row inclusive end row of the shard
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*release_revolving_shard)(void *cls,
                              const char *job_name,
                              uint32_t start_row,
                              uint32_t end_row);
 
 
   /**
    * Function called to delete all revolving shards.
    * To be used after a crash or when the shard size is
    * changed.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @return #GNUNET_OK on success
    *         #GNUNET_SYSERR on failure
    */
   enum GNUNET_GenericReturnValue
   (*delete_shard_locks)(void *cls);
 
 
   /**
    * Function called to save the manifest of an extension
    * (age-restriction, policy-extension, ...)
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param extension_name the name of the extension
    * @param manifest JSON object of the Manifest as string, maybe NULL (== disabled extension)
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*set_extension_manifest)(void *cls,
                             const char *extension_name,
                             const char *manifest);
 
 
   /**
    * Function called to retrieve the manifest of an extension
    * (age-restriction, policy-extension, ...)
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param extension_name the name of the extension
    * @param[out] manifest Manifest of the extension in JSON encoding, maybe NULL (== disabled extension)
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_extension_manifest)(void *cls,
                             const char *extension_name,
                             char **manifest);
 
 
   /**
    * Function called to store configuration data about a partner
    * exchange that we are federated with.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param master_pub public offline signing key of the partner exchange
    * @param start_date when does the following data start to be valid
    * @param end_date when does the validity end (exclusive)
    * @param wad_frequency how often do we do exchange-to-exchange settlements?
    * @param wad_fee how much do we charge for transfers to the partner
    * @param partner_base_url base URL of the partner exchange
    * @param master_sig signature with our offline signing key affirming the above
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_partner)(void *cls,
                     const struct TALER_MasterPublicKeyP *master_pub,
                     struct GNUNET_TIME_Timestamp start_date,
                     struct GNUNET_TIME_Timestamp end_date,
                     struct GNUNET_TIME_Relative wad_frequency,
                     const struct TALER_Amount *wad_fee,
                     const char *partner_base_url,
                     const struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Function called to persist an encrypted contract associated with a reserve.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param econtract the encrypted contract
    * @param[out] econtract_sig set to the signature over the encrypted contract
    * @param[out] in_conflict set to true if @a econtract
    *             conflicts with an existing contract;
    *             in this case, the return value will be
    *             #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT despite the failure
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_contract)(void *cls,
                      const struct TALER_PurseContractPublicKeyP *purse_pub,
                      const struct TALER_EncryptedContract *econtract,
                      bool *in_conflict);
 
 
   /**
    * Function called to retrieve an encrypted contract.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param pub_ckey set to the ephemeral DH used to encrypt the contract, key used to lookup the contract by
    * @param[out] purse_pub public key of the purse of the contract
    * @param[out] econtract_sig set to the signature over the encrypted contract
    * @param[out] econtract_size set to the number of bytes in @a econtract
    * @param[out] econtract set to the encrypted contract on success, to be freed by the caller
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_contract)(
     void *cls,
     const struct TALER_ContractDiffiePublicP *pub_ckey,
     struct TALER_PurseContractPublicKeyP *purse_pub,
     struct TALER_PurseContractSignatureP *econtract_sig,
     size_t *econtract_size,
     void **econtract);
 
 
   /**
    * Function called to retrieve an encrypted contract.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub key to lookup the contract by
    * @param[out] econtract set to the encrypted contract on success, to be freed by the caller
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_contract_by_purse)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     struct TALER_EncryptedContract *econtract);
 
 
   /**
    * Function called to create a new purse with certain meta data.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub public key of the new purse
    * @param merge_pub public key providing the merge capability
    * @param purse_expiration time when the purse will expire
    * @param h_contract_terms hash of the contract for the purse
    * @param age_limit age limit to enforce for payments into the purse
    * @param flags flags for the operation
    * @param purse_fee fee we are allowed to charge to the reserve (depending on @a flags)
    * @param amount target amount (with fees) to be put into the purse
    * @param purse_sig signature with @a purse_pub's private key affirming the above
    * @param[out] in_conflict set to true if the meta data
    *             conflicts with an existing purse;
    *             in this case, the return value will be
    *             #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT despite the failure
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_purse_request)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     const struct TALER_PurseMergePublicKeyP *merge_pub,
     struct GNUNET_TIME_Timestamp purse_expiration,
     const struct TALER_PrivateContractHashP *h_contract_terms,
     uint32_t age_limit,
     enum TALER_WalletAccountMergeFlags flags,
     const struct TALER_Amount *purse_fee,
     const struct TALER_Amount *amount,
     const struct TALER_PurseContractSignatureP *purse_sig,
     bool *in_conflict);
 
 
   /**
    * Function called to clean up one expired purse.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param start_time select purse expired after this time
    * @param end_time select purse expired before this time
    * @return transaction status code (#GNUNET_DB_STATUS_SUCCESS_NO_RESULTS if no purse expired in the given time interval).
    */
   enum GNUNET_DB_QueryStatus
   (*expire_purse)(
     void *cls,
     struct GNUNET_TIME_Absolute start_time,
     struct GNUNET_TIME_Absolute end_time);
 
 
   /**
    * Function called to obtain information about a purse.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub public key of the new purse
    * @param[out] purse_creation set to time when the purse was created
    * @param[out] purse_expiration set to time when the purse will expire
    * @param[out] amount set to target amount (with fees) to be put into the purse
    * @param[out] deposited set to actual amount put into the purse so far
    * @param[out] h_contract_terms set to hash of the contract for the purse
    * @param[out] merge_timestamp set to time when the purse was merged, or NEVER if not
    * @param[out] purse_deleted set to true if purse was deleted
    * @param[out] purse_refunded set to true if purse was refunded (after expiration)
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_purse)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     struct GNUNET_TIME_Timestamp *purse_creation,
     struct GNUNET_TIME_Timestamp *purse_expiration,
     struct TALER_Amount *amount,
     struct TALER_Amount *deposited,
     struct TALER_PrivateContractHashP *h_contract_terms,
     struct GNUNET_TIME_Timestamp *merge_timestamp,
     bool *purse_deleted,
     bool *purse_refunded);
 
 
   /**
    * Function called to return meta data about a purse by the
    * purse public key.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub public key of the purse
    * @param[out] merge_pub public key representing the merge capability
    * @param[out] purse_expiration when would an unmerged purse expire
    * @param[out] h_contract_terms contract associated with the purse
    * @param[out] age_limit the age limit for deposits into the purse
    * @param[out] target_amount amount to be put into the purse
    * @param[out] balance amount put so far into the purse
    * @param[out] purse_sig signature of the purse over the initialization data
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_purse_request)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     struct TALER_PurseMergePublicKeyP *merge_pub,
     struct GNUNET_TIME_Timestamp *purse_expiration,
     struct TALER_PrivateContractHashP *h_contract_terms,
     uint32_t *age_limit,
     struct TALER_Amount *target_amount,
     struct TALER_Amount *balance,
     struct TALER_PurseContractSignatureP *purse_sig);
 
 
   /**
    * Function called to return meta data about a purse by the
    * merge capability key.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param merge_pub public key representing the merge capability
    * @param[out] purse_pub public key of the purse
    * @param[out] purse_expiration when would an unmerged purse expire
    * @param[out] h_contract_terms contract associated with the purse
    * @param[out] age_limit the age limit for deposits into the purse
    * @param[out] target_amount amount to be put into the purse
    * @param[out] balance amount put so far into the purse
    * @param[out] purse_sig signature of the purse over the initialization data
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_purse_by_merge_pub)(
     void *cls,
     const struct TALER_PurseMergePublicKeyP *merge_pub,
     struct TALER_PurseContractPublicKeyP *purse_pub,
     struct GNUNET_TIME_Timestamp *purse_expiration,
     struct TALER_PrivateContractHashP *h_contract_terms,
     uint32_t *age_limit,
     struct TALER_Amount *target_amount,
     struct TALER_Amount *balance,
     struct TALER_PurseContractSignatureP *purse_sig);
 
 
   /**
    * Function called to execute a transaction crediting
    * a purse with @a amount from @a coin_pub. Reduces the
    * value of @a coin_pub and increase the balance of
    * the @a purse_pub purse. If the balance reaches the
    * target amount and the purse has been merged, triggers
    * the updates of the reserve/account balance.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub purse to credit
    * @param coin_pub coin to deposit (debit)
    * @param amount fraction of the coin's value to deposit
    * @param coin_sig signature affirming the operation
    * @param amount_minus_fee amount to add to the purse
    * @param[out] balance_ok set to false if the coin's
    *        remaining balance is below @a amount;
    *             in this case, the return value will be
    *             #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT despite the failure
    * @param[out] too_late it is too late to deposit into this purse
    * @param[out] conflict the same coin was deposited into
    *        this purse with a different amount already
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*do_purse_deposit)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     const struct TALER_Amount *amount,
     const struct TALER_CoinSpendSignatureP *coin_sig,
     const struct TALER_Amount *amount_minus_fee,
     bool *balance_ok,
     bool *too_late,
     bool *conflict);
 
 
   /**
    * Function called to explicitly delete a purse.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub purse to delete
    * @param purse_sig signature affirming the deletion
    * @param[out] decided set to true if the purse was
    *        already decided and thus could not be deleted
    * @param[out] found set to true if the purse was found
    *        (if false, purse could not be deleted)
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*do_purse_delete)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     const struct TALER_PurseContractSignatureP *purse_sig,
     bool *decided,
     bool *found);
 
 
   /**
    * Set the current @a balance in the purse
    * identified by @a purse_pub. Used by the auditor
    * to update the balance as calculated by the auditor.
    *
    * @param cls closure
    * @param purse_pub public key of a purse
    * @param balance new balance to store under the purse
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*set_purse_balance)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     const struct TALER_Amount *balance);
 
 
   /**
    * Function called to obtain a coin deposit data from
    * depositing the coin into a purse.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub purse to credit
    * @param coin_pub coin to deposit (debit)
    * @param[out] amount set fraction of the coin's value that was deposited (with fee)
    * @param[out] h_denom_pub set to hash of denomination of the coin
    * @param[out] phac set to hash of age restriction on the coin
    * @param[out] coin_sig set to signature affirming the operation
    * @param[out] partner_url set to the URL of the partner exchange, or NULL for ourselves, must be freed by caller
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_purse_deposit)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     const struct TALER_CoinSpendPublicKeyP *coin_pub,
     struct TALER_Amount *amount,
     struct TALER_DenominationHashP *h_denom_pub,
     struct TALER_AgeCommitmentHashP *phac,
     struct TALER_CoinSpendSignatureP *coin_sig,
     char **partner_url);
 
 
   /**
    * Function called to approve merging a purse into a
    * reserve by the respective purse merge key. The purse
    * must not have been merged into a different reserve.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub purse to merge
    * @param merge_sig signature affirming the merge
    * @param merge_timestamp time of the merge
    * @param reserve_sig signature of the reserve affirming the merge
    * @param partner_url URL of the partner exchange, can be NULL if the reserves lives with us
    * @param reserve_pub public key of the reserve to credit
    * @param[out] no_partner set to true if @a partner_url is unknown
    * @param[out] no_balance set to true if the @a purse_pub is not paid up yet
    * @param[out] no_reserve set to true if the @a reserve_pub is not known
    * @param[out] in_conflict set to true if @a purse_pub was merged into a different reserve already
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*do_purse_merge)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     const struct TALER_PurseMergeSignatureP *merge_sig,
     const struct GNUNET_TIME_Timestamp merge_timestamp,
     const struct TALER_ReserveSignatureP *reserve_sig,
     const char *partner_url,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     bool *no_partner,
     bool *no_balance,
     bool *in_conflict);
 
 
   /**
    * Function called insert request to merge a purse into a reserve by the
    * respective purse merge key. The purse must not have been merged into a
    * different reserve.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub purse to merge
    * @param merge_sig signature affirming the merge
    * @param merge_timestamp time of the merge
    * @param reserve_sig signature of the reserve affirming the merge
    * @param purse_fee amount to charge the reserve for the purse creation, NULL to use the quota
    * @param reserve_pub public key of the reserve to credit
    * @param[out] in_conflict set to true if @a purse_pub was merged into a different reserve already
    * @param[out] no_reserve set to true if @a reserve_pub is not a known reserve
    * @param[out] insufficient_funds set to true if @a reserve_pub has insufficient capacity to create another purse
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*do_reserve_purse)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     const struct TALER_PurseMergeSignatureP *merge_sig,
     const struct GNUNET_TIME_Timestamp merge_timestamp,
     const struct TALER_ReserveSignatureP *reserve_sig,
     const struct TALER_Amount *purse_fee,
     const struct TALER_ReservePublicKeyP *reserve_pub,
     bool *in_conflict,
     bool *no_reserve,
     bool *insufficient_funds);
 
 
   /**
    * Function called to approve merging of a purse with
    * an account, made by the receiving account.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param purse_pub public key of the purse
    * @param[out] merge_sig set to the signature confirming the merge
    * @param[out] merge_timestamp set to the time of the merge
    * @param[out] partner_url set to the URL of the target exchange, or NULL if the target exchange is us. To be freed by the caller.
    * @param[out] reserve_pub set to the public key of the reserve/account being credited
    * @param[out] refunded set to true if purse was refunded
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*select_purse_merge)(
     void *cls,
     const struct TALER_PurseContractPublicKeyP *purse_pub,
     struct TALER_PurseMergeSignatureP *merge_sig,
     struct GNUNET_TIME_Timestamp *merge_timestamp,
     char **partner_url,
     struct TALER_ReservePublicKeyP *reserve_pub,
     bool *refunded);
 
 
   /**
    * Function called to initiate closure of an account.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param reserve_pub public key of the account to close
    * @param payto_uri where to wire the funds
    * @param reserve_sig signature affiming that the account is to be closed
    * @param request_timestamp timestamp of the close request
    * @param balance balance at the time of closing
    * @param closing_fee closing fee to charge
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_close_request)(void *cls,
                           const struct TALER_ReservePublicKeyP *reserve_pub,
                           const struct TALER_FullPayto payto_uri,
                           const struct TALER_ReserveSignatureP *reserve_sig,
                           struct GNUNET_TIME_Timestamp request_timestamp,
                           const struct TALER_Amount *balance,
                           const struct TALER_Amount *closing_fee);
 
 
   /**
    * Function called to persist a request to drain profits.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param wtid wire transfer ID to use
    * @param account_section account to drain
    * @param payto_uri account to wire funds to
    * @param request_timestamp time of the signature
    * @param amount amount to wire
    * @param master_sig signature affirming the operation
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*insert_drain_profit)(void *cls,
                          const struct TALER_WireTransferIdentifierRawP *wtid,
                          const char *account_section,
                          const struct TALER_FullPayto payto_uri,
                          struct GNUNET_TIME_Timestamp request_timestamp,
                          const struct TALER_Amount *amount,
                          const struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Function called to get information about a profit drain event.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param wtid wire transfer ID to look up drain event for
    * @param[out] serial set to serial ID of the entry
    * @param[out] account_section set to account to drain
    * @param[out] payto_uri set to account to wire funds to
    * @param[out] request_timestamp set to time of the signature
    * @param[out] amount set to amount to wire
    * @param[out] master_sig set to signature affirming the operation
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_drain_profit)(void *cls,
                       const struct TALER_WireTransferIdentifierRawP *wtid,
                       uint64_t *serial,
                       char **account_section,
                       struct TALER_FullPayto *payto_uri,
                       struct GNUNET_TIME_Timestamp *request_timestamp,
                       struct TALER_Amount *amount,
                       struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Get profit drain operation ready to execute.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param[out] serial set to serial ID of the entry
    * @param[out] wtid set set to wire transfer ID to use
    * @param[out] account_section set to  account to drain
    * @param[out] payto_uri set to account to wire funds to
    * @param[out] request_timestamp set to time of the signature
    * @param[out] amount set to amount to wire
    * @param[out] master_sig set to signature affirming the operation
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*profit_drains_get_pending)(
     void *cls,
     uint64_t *serial,
     struct TALER_WireTransferIdentifierRawP *wtid,
     char **account_section,
     struct TALER_FullPayto *payto_uri,
     struct GNUNET_TIME_Timestamp *request_timestamp,
     struct TALER_Amount *amount,
     struct TALER_MasterSignatureP *master_sig);
 
 
   /**
    * Set profit drain operation to finished.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param serial serial ID of the entry to mark finished
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*profit_drains_set_finished)(
     void *cls,
     uint64_t serial);
 
 
   /**
    * Insert KYC requirement for @a h_payto account into table.
    *
    * @param cls closure
    * @param payto_uri account that must be KYC'ed,
    *    can be NULL if @a h_payto is already
    *    guaranteed to be in wire_targets
    * @param h_payto hash of @a payto_uri
    * @param set_account_pub public key to enable for the
    *    KYC authorization, NULL if not known
    * @param check_merchant_pub public key that must already
    *    be enabled for a KYC authorzation for it to be
    *   valid, NULL if not known
    * @param jmeasures serialized MeasureSet to put in place
    * @param display_priority priority of the rule
    * @param[out] requirement_row set to legitimization requirement row for this check
    * @param[out] bad_kyc_auth set if @a check_account_pub
    *     did not match the existing KYC auth
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*trigger_kyc_rule_for_account)(
     void *cls,
     const struct TALER_FullPayto payto_uri,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     const union TALER_AccountPublicKeyP *set_account_pub,
     const struct TALER_MerchantPublicKeyP *check_merchant_pub,
     const json_t *jmeasures,
     uint32_t display_priority,
     uint64_t *requirement_row,
     bool *bad_kyc_auth);
 
 
   /**
    * Begin KYC requirement process.
    *
    * @param cls closure
    * @param h_payto account that must be KYC'ed
    * @param measure_index which of the measures in
    *    jmeasures does this KYC process relate to
    * @param legitimization_measure_serial_id which
    *    legitimization measure set does this KYC process
    *    relate to (uniquely identifies jmeasures)
    * @param provider_name provider that must be checked
    * @param provider_account_id provider account ID
    * @param provider_legitimization_id provider legitimization ID
    * @param[out] process_row row the process is stored under
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*insert_kyc_requirement_process)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     uint32_t measure_index,
     uint64_t legitimization_measure_serial_id,
     const char *provider_name,
     const char *provider_account_id,
     const char *provider_legitimization_id,
     uint64_t *process_row);
 
 
   /**
    * Fetch information about pending KYC requirement process.
    *
    * @param cls closure
    * @param h_payto account that must be KYC'ed
    * @param provider_name provider that must be checked
    * @param[out] redirect_url set to redirect URL for the process
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*get_pending_kyc_requirement_process)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     const char *provider_name,
     char **redirect_url);
 
 
   /**
    * Update KYC process with updated provider-linkage and/or
    * expiration data.
    *
    * @param cls closure
    * @param process_row row to select by
    * @param provider_name provider that must be checked (technically redundant)
    * @param h_payto account that must be KYC'ed (helps access by shard, otherwise also redundant)
    * @param provider_account_id provider account ID
    * @param provider_legitimization_id provider legitimization ID
    * @param redirect_url where the user should be redirected to start the KYC process
    * @param expiration how long is this KYC check set to be valid (in the past if invalid)
    * @param ec error code, #TALER_EC_NONE on success
    * @param error_message_hint human-readable error message details (in addition to @a ec, NULL on success)
    * @param finished true to mark the process as done
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*update_kyc_process_by_row)(
     void *cls,
     uint64_t process_row,
     const char *provider_name,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     const char *provider_account_id,
     const char *provider_legitimization_id,
     const char *redirect_url,
     struct GNUNET_TIME_Absolute expiration,
     enum TALER_ErrorCode ec,
     const char *error_message_hint,
     bool finished);
 
 
   /**
    * Lookup KYC requirement.
    *
    * @param cls closure
    * @param h_payto identifies account to look up requirement for
    * @param account_pub set to public key of the account
    *    needed to authorize access
    * @param[out] is_wallet set to #GNUNET_YES if the account is
    *    that of a wallet (#GNUNET_SYSERR is used if unknown)
    * @param[out] access_token set to the access token to begin
    *    work on KYC processes for this account
    * @param[out] rule_gen row ID of the last decision this
    *    response is based on (for long-polling by clients)
    * @param[out] jrules set to active ``LegitimizationRuleSet``
    *    of the account impacted by the requirement
    * @param[out] aml_review set to true if the account is under
    *    active review by AML staff
    * @param[out] kyc_required set to true if the user must pass
    *    some KYC check before some previous operation may continue
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_kyc_requirement_by_row)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     const union TALER_AccountPublicKeyP *account_pub,
     enum GNUNET_GenericReturnValue *is_wallet,
     struct TALER_AccountAccessTokenP *access_token,
     uint64_t *rule_gen,
     json_t **jrules,
     bool *aml_review,
     bool *kyc_required);
 
 
   /**
    * Lookup KYC status by account access token.
    *
    * @param cls closure
    * @param access_token key to look under
    * @param[out] row set to requirement row that matches
    * @param[out] jmeasures set to the LegitimizationMeasures for the @a access_token; must be freed by caller!
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_kyc_status_by_token)(
     void *cls,
     const struct TALER_AccountAccessTokenP *access_token,
     uint64_t *row,
     json_t **jmeasures);
 
 
   /**
    * Lookup KYC rules by account access token.
    *
    * @param cls closure
    * @param h_payto account payto hash to look under
    * @param[out] jnew_rules set to active LegitimizationRuleSet
    * @param[out] rowid row of the last legitimization outcome
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_rules_by_access_token)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     json_t **jnew_rules,
     uint64_t *rowid);
 
 
   /**
    * Lookup KYC process meta data.
    *
    * @param cls closure
    * @param provider_name provider that must be checked
    * @param h_payto account that must be KYC'ed
    * @param[out] process_row set to row with the legitimization data
    * @param[out] expiration how long is this KYC check set to be valid (in the past if invalid)
    * @param[out] provider_account_id provider account ID
    * @param[out] provider_legitimization_id provider legitimization ID
    * @param[out] is_wallet set to true if @a h_payto is for a wallet
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_kyc_process_by_account)(
     void *cls,
     const char *provider_name,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     uint64_t *process_row,
     struct GNUNET_TIME_Absolute *expiration,
     char **provider_account_id,
     char **provider_legitimization_id,
     bool *is_wallet);
 
 
   /**
    * Lookup an @a h_payto by @a provider_legitimization_id.
    *
    * @param cls closure
    * @param provider_name
    * @param provider_legitimization_id legi to look up
    * @param[out] h_payto where to write the result
    * @param[out] is_wallet set to true if @a h_payto is for a wallet
    * @param[out] process_row identifies the legitimization process on our end
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*kyc_provider_account_lookup)(
     void *cls,
     const char *provider_name,
     const char *provider_legitimization_id,
     struct TALER_NormalizedPaytoHashP *h_payto,
     bool *is_wallet,
     uint64_t *process_row);
 
 
   /**
    * Return KYC rules that apply to the given account.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto account identifier
    * @param merchant_pub merchant public key used by the client, or NULL
    *   if not available; if multiple @a reserve_pub values could be returned,
    *   we should use this one
    * @param[out] no_account_pub set to true if no @a account_pub is available
    * @param[out] account_pub set to account public key the rules
    *   apply to (because this key was used in KYC auth)
    * @param[out] no_reserve_pub set to true if no @a reserve_pub is available
    * @param[out] reserve_pub set to last incoming reserve public key
    *   of a wire transfer to the exchange from the given @a h_payto
    *   apply to (because this key was used in KYC auth)
    * @param[out] jrules set to the active KYC rules for the
    *    given account, set to NULL if no custom rules are active
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_kyc_rules)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     const struct TALER_MerchantPublicKeyP *merchant_pub,
     bool *no_account_pub,
     union TALER_AccountPublicKeyP *account_pub,
     bool *no_reserve_pub,
     struct TALER_ReservePublicKeyP *reserve_pub,
     json_t **jrules);
 
 
   /**
    * Return just the KYC rules that apply to the given account.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto account identifier
    * @param[out] jrules set to the active KYC rules for the
    *    given account, set to NULL if no custom rules are active
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*get_kyc_rules2)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     json_t **jrules);
 
 
   /**
    * Call us on KYC legitimization processes satisfied and not expired for the
    * given account.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto account identifier
    * @param lpc function to call for each satisfied KYC legitimization process
    * @param lpc_cls closure for @a lpc
    * @return transaction status code
    */
   enum GNUNET_DB_QueryStatus
   (*iterate_kyc_reference)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     TALER_EXCHANGEDB_LegitimizationProcessCallback lpc,
     void *lpc_cls);
 
 
   /**
    * Call @a kac on withdrawn amounts after @a time_limit which are relevant
    * for a KYC trigger for a the (debited) account identified by @a h_payto.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto account identifier
    * @param time_limit oldest transaction that could be relevant
    * @param kac function to call for each applicable amount, in reverse chronological order (or until @a kac aborts by returning anything except #GNUNET_OK).
    * @param kac_cls closure for @a kac
    * @return transaction status code, @a kac aborting with #GNUNET_NO is not an error
    */
   enum GNUNET_DB_QueryStatus
   (*select_withdraw_amounts_for_kyc_check)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     struct GNUNET_TIME_Absolute time_limit,
     TALER_EXCHANGEDB_KycAmountCallback kac,
     void *kac_cls);
 
 
   /**
    * Call @a kac on aggregated amounts after @a time_limit which are relevant for a
    * KYC trigger for a the (credited) account identified by @a h_payto.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto account identifier
    * @param time_limit oldest transaction that could be relevant
    * @param kac function to call for each applicable amount, in reverse chronological order (or until @a kac aborts by returning anything except #GNUNET_OK).
    * @param kac_cls closure for @a kac
    * @return transaction status code, @a kac aborting with #GNUNET_NO is not an error
    */
   enum GNUNET_DB_QueryStatus
   (*select_aggregation_amounts_for_kyc_check)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     struct GNUNET_TIME_Absolute time_limit,
     TALER_EXCHANGEDB_KycAmountCallback kac,
     void *kac_cls);
 
 
   /**
    * Call @a kac on merged reserve amounts after @a time_limit which are relevant for a
    * KYC trigger for a the wallet identified by @a h_payto.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto account identifier
    * @param time_limit oldest transaction that could be relevant
    * @param kac function to call for each applicable amount, in reverse chronological order (or until @a kac aborts by returning anything except #GNUNET_OK).
    * @param kac_cls closure for @a kac
    * @return transaction status code, @a kac aborting with #GNUNET_NO is not an error
    */
   enum GNUNET_DB_QueryStatus
   (*select_merge_amounts_for_kyc_check)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     struct GNUNET_TIME_Absolute time_limit,
     TALER_EXCHANGEDB_KycAmountCallback kac,
     void *kac_cls);
 
 
   /**
    * Call @a kac on deposited amounts after @a time_limit which are relevant for a
    * KYC trigger for a merchant identified by @a h_payto.
    *
    * @param cls the @e cls of this struct with the plugin-specific state
    * @param h_payto account identifier
    * @param time_limit oldest transaction that could be relevant
    * @param kac function to call for each applicable amount,
    *    in reverse chronological order (or until @a kac aborts
    *    by returning anything except #GNUNET_OK).
    * @param kac_cls closure for @a kac
    * @return transaction status code, @a kac aborting with #GNUNET_NO is not an error
    */
   enum GNUNET_DB_QueryStatus
   (*select_deposit_amounts_for_kyc_check)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     struct GNUNET_TIME_Absolute time_limit,
     TALER_EXCHANGEDB_KycAmountCallback kac,
     void *kac_cls);
 
 
   /**
    * Update sanction list hit status of the given account.
    *
    * @param cls closure
    * @param h_payto account for which the hit is to be stored
    * @param to_investigate true to flag account for investigation,
    *        false to **preserve** existing status
    * @param new_rules new KYC rules to apply to the account, NULL to preserve
    *        existing rules
    * @param account_properties new account properties
    * @param num_events length of the @a events array
    * @param events array of KYC events to trigger
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*insert_sanction_list_hit)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     bool to_investigate,
     const json_t *new_rules,
     const json_t *account_properties,
     unsigned int num_events,
     const char **events);
 
 
   /**
    * Update AML program status to finished (and failed).
    *
    * @param cls closure
    * @param process_row KYC process row to update
    * @param h_payto account for which the attribute data is stored
    * @param error_message details about what went wrong
    * @param ec error code about the failure
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*insert_aml_program_failure) (
     void *cls,
     uint64_t process_row,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     const char *error_message,
     enum TALER_ErrorCode ec);
 
 
   /**
    * Revert account back to default rules and insert successor measure.
    */
   enum GNUNET_DB_QueryStatus
   (*insert_successor_measure)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     struct GNUNET_TIME_Timestamp decision_time,
     const char *new_measure_name,
     const json_t *jmeasures,
     bool *unknown_account,
     struct GNUNET_TIME_Timestamp *last_date);
 
 
   /**
    * Lookup KYC attribute data for a specific account.
    *
    * @param cls closure
    * @param h_payto account for which the attribute data is stored
    * @param cb callback to invoke on each match
    * @param cb_cls closure for @a cb
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_kyc_attributes)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     TALER_EXCHANGEDB_AttributeCallback cb,
     void *cb_cls);
 
 
   /**
    * Lookup all KYC attributes above @a min_row_id.
    *
    * @param cls closure
    * @param min_row_id minimum row ID to return (exclusive)
    * @param cb callback to invoke on each match
    * @param cb_cls closure for @a cb
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_all_kyc_attributes)(
     void *cls,
     uint64_t min_row_id,
     TALER_EXCHANGEDB_AllAttributesCallback cb,
     void *cb_cls);
 
 
   /**
    * Lookup legitimization measures.
    *
    * @param cls closure
    * @param h_payto account for which the attribute data is stored,
    *                NULL to select for all accounts
    * @param finished_only select only measures that are finished
    * @param offset row offset to select from
    * @param limit number of results to return, negative to
    *               return in descending order from @a offset
    * @param cb callback to invoke on each match
    * @param cb_cls closure for @a cb
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_aml_measures)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     enum TALER_EXCHANGE_YesNoAll active_only,
     uint64_t offset,
     int64_t limit,
     TALER_EXCHANGEDB_LegitimizationMeasureCallback cb,
     void *cb_cls);
 
 
   /**
    * Insert AML staff record.
    *
    * @param cls closure
    * @param decider_pub public key of the staff member
    * @param master_sig offline signature affirming the AML officer
    * @param decider_name full name of the staff member
    * @param is_active true to enable, false to set as inactive
    * @param read_only true to set read-only access
    * @param last_change when was the change made effective
    * @param[out] previous_change when was the previous change made
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*insert_aml_officer)(
     void *cls,
     const struct TALER_AmlOfficerPublicKeyP *decider_pub,
     const struct TALER_MasterSignatureP *master_sig,
     const char *decider_name,
     bool is_active,
     bool read_only,
     struct GNUNET_TIME_Timestamp last_change,
     struct GNUNET_TIME_Timestamp *previous_change);
 
 
   /**
    * Test if the given AML staff member is active
    * (at least read-only).
    *
    * @param cls closure
    * @param decider_pub public key of the staff member
    * @param[out] read_only set to true if the member is read-only
    * @return database transaction status, if member is unknown or not active, 1 if member is active
    */
   enum GNUNET_DB_QueryStatus
   (*test_aml_officer)(
     void *cls,
     const struct TALER_AmlOfficerPublicKeyP *decider_pub,
     bool *read_only);
 
 
   /**
    * Fetch AML staff record.
    *
    * @param cls closure
    * @param decider_pub public key of the staff member
    * @param[out] master_sig offline signature affirming the AML officer
    * @param[out] decider_name full name of the staff member
    * @param[out] is_active true to enable, false to set as inactive
    * @param[out] read_only true to set read-only access
    * @param[out] last_change when was the change made effective
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_aml_officer)(
     void *cls,
     const struct TALER_AmlOfficerPublicKeyP *decider_pub,
     struct TALER_MasterSignatureP *master_sig,
     char **decider_name,
     bool *is_active,
     bool *read_only,
     struct GNUNET_TIME_Absolute *last_change);
 
 
   /**
    * Obtain the AML statistics for a given set of @a names and
    * timeframe.
    *
    * @param cls closure
    * @param num_names length of the @e names array
    * @param names array of names of the statistics to fetch
    * @param start_date start of time range
    * @param end_date end of time range
    * @param cb function to call on each statistic
    * @param cb_cls closure for @a cb
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_aml_statistics)(
     void *cls,
     size_t num_names,
     const char *names[static num_names],
     struct GNUNET_TIME_Timestamp start_date,
     struct GNUNET_TIME_Timestamp end_date,
     TALER_EXCHANGEDB_AmlStatisticsCallback cb,
     void *cb_cls);
 
 
   /**
    * Lookup AML decisions that have a particular state.
    *
    * @param cls closure
    * @param h_payto which account should we return the AML decision history for, NULL to return all accounts
    * @param investigation_only filter by investigation state
    * @param active_only filter for only active states
    * @param offset row to start from
    * @param limit how many records to return (negative
    *        to go back in time, positive to go forward)
    * @param cb callback to invoke on each match
    * @param cb_cls closure for @a cb
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_aml_decisions)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     enum TALER_EXCHANGE_YesNoAll investigation_only,
     enum TALER_EXCHANGE_YesNoAll active_only,
     uint64_t offset,
     int64_t limit,
     TALER_EXCHANGEDB_AmlDecisionCallback cb,
     void *cb_cls);
 
 
   /**
    * List accounts managed by the exchange (for AML/KYC).
    *
    * @param cls closure
    * @param investigation_only filter by investigation state
    * @param open_only filter for only open accounts
    * @param high_risk_only filter for only high-risk accounts
    * @param offset row to start from
    * @param limit how many records to return (negative
    *        to go back in time, positive to go forward)
    * @param cb callback to invoke on each match
    * @param cb_cls closure for @a cb
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_kyc_accounts)(
     void *cls,
     enum TALER_EXCHANGE_YesNoAll investigation_only,
     enum TALER_EXCHANGE_YesNoAll open_only,
     enum TALER_EXCHANGE_YesNoAll high_risk_only,
     uint64_t offset,
     int64_t limit,
     TALER_EXCHANGEDB_AmlAccountListCallback cb,
     void *cb_cls);
 
 
   /**
    * Lookup AML attributes of a particular account.
    *
    * @param cls closure
    * @param h_payto which account should we return attributes for
    * @param offset row to start from
    * @param limit how many records to return (negative
    *        to go back in time, positive to go forward)
    * @param cb callback to invoke on each match
    * @param cb_cls closure for @a cb
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_aml_attributes)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     uint64_t offset,
     int64_t limit,
     TALER_EXCHANGEDB_AmlAttributeCallback cb,
     void *cb_cls);
 
 
   /**
    * Lookup @a h_payto based on an @a access_token.
    *
    * @param cls closure
    * @param access_token
    *    set to token for access control
    * @param[out] h_payto set to the the hash of the
    *    payto URI of the account (if found)
    * @param[out] is_wallet set to true if @a h_payto
    *    is for a wallet
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_h_payto_by_access_token)(
     void *cls,
     const struct TALER_AccountAccessTokenP *access_token,
     struct TALER_NormalizedPaytoHashP *h_payto,
     bool *is_wallet);
 
 
   /**
    * Lookup measure data for a legitimization process.
    *
    * @param cls closure
    * @param legitimization_measure_serial_id
    *    row in legitimization_measures table to access
    * @param[out] access_token
    *    set to token for access control that must match
    * @param[out] h_payto set to the the hash of the
    *    payto URI of the account undergoing legitimization
    * @param[out] jmeasures set to the legitimization
    *    measures that were put on the account
    * @param[out] is_finished set to true if the legitimization was
    *    already finished
    * @param[out] is_wallet set to true if @a h_payto is for a wallet
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_pending_legitimization)(
     void *cls,
     uint64_t legitimization_measure_serial_id,
     struct TALER_AccountAccessTokenP *access_token,
     struct TALER_NormalizedPaytoHashP *h_payto,
     json_t **jmeasures,
     bool *is_finished,
     bool *is_wallet);
 
 
   /**
    * Lookup measure data for a legitimization process.
    *
    * @param cls closure
    * @param legitimization_measure_serial_id
    *    row in legitimization_measures table to access
    * @param measure_index index of the measure to return
    *    attribute data for
    * @param[out] access_token
    *    set to token for access control that must match
    * @param[out] h_payto set to the the hash of the
    *    payto URI of the account undergoing legitimization
    * @param[out] is_wallet set to true if @a h_payto is for a wallet
    * @param[out] jmeasures set to the legitimization
    *    measures that were put on the account
    * @param[out] is_finished set to true if the legitimization was
    *    already finished
    * @param[out] encrypted_attributes_len set to length of
    *    @a encrypted_attributes
    * @param[out] encrypted_attributes set to the attributes
    *    obtained for the legitimization process, if it
    *    succeeded, otherwise set to NULL
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_completed_legitimization)(
     void *cls,
     uint64_t legitimization_measure_serial_id,
     uint32_t measure_index,
     struct TALER_AccountAccessTokenP *access_token,
     struct TALER_NormalizedPaytoHashP *h_payto,
     bool *is_wallet,
     json_t **jmeasures,
     bool *is_finished,
     size_t *encrypted_attributes_len,
     void **encrypted_attributes);
 
 
   /**
    * Lookup AML history for an account identified via
    * @a h_payto.
    *
    * @param cls closure
    * @param h_payto hash of account to lookup history for
    * @param offset row ID to start returning results from
    * @param limit how many results to return, negative for descending order
    * @param cb function to call on results
    * @param cb_cls closure for @a cb
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_aml_history)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     uint64_t offset,
     int64_t limit,
     TALER_EXCHANGEDB_AmlHistoryCallback cb,
     void *cb_cls);
 
 
   /**
    * Lookup AML history for an account identified via
    * @a h_payto.
    *
    * @param cls closure
    * @param h_payto hash of account to lookup history for
    * @param cb function to call on results
    * @param cb_cls closure for @a cb
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_kyc_history)(
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     TALER_EXCHANGEDB_KycHistoryCallback cb,
     void *cb_cls);
 
 
   /**
    * Lookup measure data for an active legitimization process.
    *
    * @param cls closure
    * @param legitimization_process_serial_id
    *    row in legitimization_processes table to access
    * @param[out] measure_index set to the measure the
    *    process is trying to satisfy
    * @param[out] jmeasures set to the legitimization
    *    measures that were put on the account
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_active_legitimization) (
     void *cls,
     uint64_t legitimization_process_serial_id,
     uint32_t *measure_index,
     json_t **jmeasures);
 
 
   /**
    * Create new active legitimization measure.
    *
    *
    * @param cls closure
    * @param access_token access token that identifies the
    *   account the legitimization measures apply to
    * @param jmeasures new legitimization measures
    * @param[out] legitimization_measure_serial_id
    *    set to new row in legitimization_measures table
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*insert_active_legitimization_measure) (
     void *cls,
     const struct TALER_AccountAccessTokenP *access_token,
     const json_t *jmeasures,
     uint64_t *legitimization_measure_serial_id);
 
 
   /**
    * Insert an AML decision. Inserts into AML history and insert or updates AML
    * status.
    *
    * @param cls closure
    * @param payto_uri full URI of the account, optional,
    *    can be NULL if the backend already knows the account
    * @param h_payto account for which the attribute data is stored
    * @param decision_time when was the decision made
    * @param expiration_time when does the decision expire
    * @param properties JSON object with properties to set for the account
    * @param new_rules JSON array with new AML/KYC rules
    * @param to_investigate true if AML staff should look more into this account
    * @param new_measure_name name of the @a jmeasures measure that was triggered, or NULL for none
    * @param jmeasures a JSON with LegitimizationMeasures to apply to the
    *    account, or NULL to not apply any measure right now
    * @param justification human-readable text justifying the decision
    * @param decider_pub public key of the staff member
    * @param decider_sig signature of the staff member
    * @param num_events length of the @a events array
    * @param events array of events to trigger
    * @param form_name name of the form from which @a enc_attributes originate, can be NULL
    * @param enc_attributes_size number of bytes in @a enc_attributes
    * @param enc_attributes encrypted attribute data
    * @param attributes_hash hash of the unencrypted attribute data
    * @param attributes_expiration_time when does the attribute data expire
    * @param[out] invalid_officer set to TRUE if @a decider_pub is not allowed to make decisions right now
    * @param[out] unknown_account set to TRUE if @a h_payto does not refer to a known account and @a jmeasures was given
    * @param[out] last_date set to the previous decision time;
    *   the INSERT is not performed if @a last_date is not before @a decision_time
    * @param[out] legitimization_measure_serial_id serial ID of the legitimization measures
    *   of the decision
    * @param[out] is_wallet set to true if @a h_payto is for a wallet
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*insert_aml_decision)(
     void *cls,
     const struct TALER_FullPayto payto_uri,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     struct GNUNET_TIME_Timestamp decision_time,
     struct GNUNET_TIME_Timestamp expiration_time,
     const json_t *properties,
     const json_t *new_rules,
     bool to_investigate,
     const char *new_measure_name,
     const json_t *jmeasures,
     const char *justification,
     const struct TALER_AmlOfficerPublicKeyP *decider_pub,
     const struct TALER_AmlOfficerSignatureP *decider_sig,
     size_t num_events,
     const char *events[static num_events],
     const char *form_name,
     size_t enc_attributes_size,
     const void *enc_attributes,
     struct GNUNET_HashCode *attributes_hash,
     struct GNUNET_TIME_Timestamp attributes_expiration_time,
     bool *invalid_officer,
     bool *unknown_account,
     struct GNUNET_TIME_Timestamp *last_date,
     uint64_t *legitimization_measure_serial_id,
     bool *is_wallet);
 
 
   /**
    * Store KYC attribute data.
    *
    * @param cls closure
    * @param process_row KYC process row to update
    * @param h_payto account for which the attribute data is stored
    * @param provider_name name of the provider that provided the attributes
    * @param provider_account_id provider account ID
    * @param provider_legitimization_id provider legitimization ID
    * @param birthday birthdate of user, in days after 1990, or 0 if unknown or definitively adult
    * @param expiration_time when does the data expire
    * @param form_name name of the form from which the @a enc_attributes originate, can be NULL
    * @param enc_attributes_size number of bytes in @a enc_attributes
    * @param enc_attributes encrypted attribute data
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*persist_kyc_attributes) (
     void *cls,
     uint64_t process_row,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     const char *provider_name,
     const char *provider_account_id,
     const char *provider_legitimization_id,
     uint32_t birthday,
     struct GNUNET_TIME_Absolute expiration_time,
     const char *form_name,
     size_t enc_attributes_size,
     const void *enc_attributes);
 
 
   /**
    * Update KYC process status to finished (and failed).
    *
    * @param cls closure
    * @param process_row KYC process row to update
    * @param h_payto account for which the attribute data is stored
    * @param provider_name provider that must be checked
    * @param provider_account_id provider account ID
    * @param provider_legitimization_id provider legitimization ID
    * @param error_message details about what went wrong
    * @param ec error code about the failure
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*insert_kyc_failure)(
     void *cls,
     uint64_t process_row,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     const char *provider_name,
     const char *provider_account_id,
     const char *provider_legitimization_id,
     const char *error_message,
     enum TALER_ErrorCode ec);
 
   /**
    * Function called to inject auditor triggers into the
    * database, triggering the real-time auditor upon
    * relevant INSERTs.
    *
    * @param cls closure
    * @return #GNUNET_OK on success,
    *         #GNUNET_SYSERR on DB errors
    */
   enum GNUNET_GenericReturnValue
   (*inject_auditor_triggers)(void *cls);
 
 
   /**
    * Set a lock for @a lock_duration on running AML programs for the @a h_payto
    * account. If a lock already exists, returns the timeout of the
    * @a existing_lock.  Returns 0 if @a h_payto is not known.
    *
    * @param cls closure
    * @param h_payto account to lock
    * @param lock_duration how long to lock the account
    * @param[out] existing_lock set to timeout of existing lock, or
    *         to zero if there is no existing lock
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*set_aml_lock) (
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     struct GNUNET_TIME_Relative lock_duration,
     struct GNUNET_TIME_Absolute *existing_lock);
 
 
   /**
    * Clear a lock on running AML programs for the @a h_payto
    * account. Returns 0 if @a h_payto is not known; does not
    * actually care if there was a lock. Also does not by
    * itself notify clients waiting for the lock, that
    * notification the caller must do separately after finishing
    * the database update.
    *
    * @param cls closure
    * @param h_payto account to clear the lock for
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*clear_aml_lock) (
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto);
 
 
   /**
    * Return AML-relevant wire transfer credit data.
    *
    * @param cls closure
    * @param threshold minimum wire amount to return data for
    * @param offset offset in table to filter by
    * @param limit maximum number of entries to return, negative for descending
    * @param h_payto account to filter transfer data by
    * @param cb function to call on each result
    * @param cb_cls closure to pass to @a cb
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_exchange_credit_transfers) (
     void *cls,
     const struct TALER_Amount *threshold,
     uint64_t offset,
     int64_t limit,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     TALER_EXCHANGEDB_AmlTransferCallback cb,
     void *cb_cls);
 
 
   /**
    * Return AML-relevant wire transfer debit data.
    *
    * @param cls closure
    * @param threshold minimum wire amount to return data for
    * @param offset offset in table to filter by
    * @param limit maximum number of entries to return, negative for descending
    * @param h_payto account to filter transfer data by
    * @param cb function to call on each result
    * @param cb_cls closure to pass to @a cb
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_exchange_debit_transfers) (
     void *cls,
     const struct TALER_Amount *threshold,
     uint64_t offset,
     int64_t limit,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     TALER_EXCHANGEDB_AmlTransferCallback cb,
     void *cb_cls);
 
 
   /**
    * Return wire transfer kycauth data.
    *
    * @param cls closure
    * @param threshold minimum wire amount to return data for
    * @param offset offset in table to filter by
    * @param limit maximum number of entries to return, negative for descending
    * @param h_payto account to filter transfer data by
    * @param cb function to call on each result
    * @param cb_cls closure to pass to @a cb
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*select_exchange_kycauth_transfers) (
     void *cls,
     const struct TALER_Amount *threshold,
     uint64_t offset,
     int64_t limit,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     TALER_EXCHANGEDB_AmlTransferCallback cb,
     void *cb_cls);
 
 
   /**
    * Disable (delete/drop) customization rule schema from a deployment.
    *
    * @param cls closure
    * @param schema name of the schema with customization rules to remove
    * @return transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*disable_rules)(
     void *cls,
     const char *schema);
 
   /**
    * Enable (create/insert) customization rule schema from a deployment.
    *
    * @param cls closure
    * @param schema name of the schema with customization rules to remove
    * @return transaction status
    */
   enum GNUNET_GenericReturnValue
   (*enable_rules)(
     void *cls,
     const char *schema);
 
   /**
    * Lookup AML file number by the payto address.
    *
    * @param cls closure
    * @param h_payto account for which to find the row ID
    * @param[out] kyw_target_row set to row in the kyc_targets table for @a h_payto
    * @param[out] is_wallet set to true if this account is for a wallet
    * @return database transaction status
    */
   enum GNUNET_DB_QueryStatus
   (*lookup_aml_file_number) (
     void *cls,
     const struct TALER_NormalizedPaytoHashP *h_payto,
     uint64_t *kyc_target_row,
     bool *is_wallet);
 
 };
 
 #endif /* _TALER_EXCHANGE_DB_H */