aboutsummaryrefslogtreecommitdiff
path: root/src/exchangedb/perf_taler_exchangedb_init.c
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2016-03-01 15:35:04 +0100
committerChristian Grothoff <christian@grothoff.org>2016-03-01 15:35:04 +0100
commitb5cba3251053c22bf1df46282f1dd0a4c46f6a38 (patch)
treeb7495c3e47c40c57ff81045a4e43aa07a3b6c7b1 /src/exchangedb/perf_taler_exchangedb_init.c
parente406833eab7ca0835f9779abebada94592a85a7e (diff)
renaming mint->exchange
Diffstat (limited to 'src/exchangedb/perf_taler_exchangedb_init.c')
-rw-r--r--src/exchangedb/perf_taler_exchangedb_init.c622
1 files changed, 622 insertions, 0 deletions
diff --git a/src/exchangedb/perf_taler_exchangedb_init.c b/src/exchangedb/perf_taler_exchangedb_init.c
new file mode 100644
index 000000000..2e613b3cf
--- /dev/null
+++ b/src/exchangedb/perf_taler_exchangedb_init.c
@@ -0,0 +1,622 @@
+/*
+ This file is part of TALER
+ Copyright (C) 2014, 2015 GNUnet e.V.
+
+ TALER is free software; you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation; either version 3, or (at your option) any later version.
+
+ TALER is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ TALER; see the file COPYING. If not, If not, see <http://www.gnu.org/licenses/>
+ */
+/**
+ * @file exchangedb/perf_taler_exchangedb_init.c
+ * @brief Interpreter library for exchange database performance analysis
+ * @author Nicolas Fournier
+ */
+#include "platform.h"
+#include "perf_taler_exchangedb_init.h"
+#include <gnunet/gnunet_signatures.h>
+#include "taler_signatures.h"
+#include "taler_amount_lib.h"
+
+
+#define CURRENCY "EUR"
+#define PERF_TALER_EXCHANGEDB_RSA_SIZE 512
+
+
+/**
+ * Generate a dummy DenominationKeyInformation for testing purposes
+ * @return a dummy denomination key
+ */
+struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *
+PERF_TALER_EXCHANGEDB_denomination_init ()
+{
+ struct GNUNET_CRYPTO_EddsaPrivateKey *master_prvt;
+ struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *dki;
+ struct TALER_DenominationPrivateKey denom_priv;
+ struct TALER_DenominationPublicKey denom_pub;
+ struct TALER_EXCHANGEDB_DenominationKeyInformationP issue;
+
+ master_prvt = GNUNET_CRYPTO_eddsa_key_create();
+
+ dki = GNUNET_new (struct TALER_EXCHANGEDB_DenominationKeyIssueInformation);
+ GNUNET_assert (NULL != dki);
+ denom_priv.rsa_private_key
+ = GNUNET_CRYPTO_rsa_private_key_create (PERF_TALER_EXCHANGEDB_RSA_SIZE);
+ GNUNET_assert (NULL != denom_priv.rsa_private_key);
+ denom_pub.rsa_public_key =
+ GNUNET_CRYPTO_rsa_private_key_get_public (denom_priv.rsa_private_key);
+ GNUNET_assert (NULL != denom_pub.rsa_public_key);
+ {/* issue */
+ struct TALER_MasterSignatureP signature;
+ struct TALER_DenominationKeyValidityPS properties;
+
+ {/* properties */
+ struct TALER_Amount amount;
+
+ properties.purpose.purpose = htonl (TALER_SIGNATURE_MASTER_SIGNING_KEY_VALIDITY);
+ properties.purpose.size = htonl (sizeof (struct TALER_DenominationKeyValidityPS));
+ GNUNET_CRYPTO_eddsa_key_get_public (master_prvt,
+ &properties.master.eddsa_pub);
+ properties.start = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get());
+ properties.expire_withdraw = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_forever_());
+ properties.expire_spend = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_forever_());
+ properties.expire_legal = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_forever_());
+ GNUNET_assert (GNUNET_OK ==
+ TALER_string_to_amount (CURRENCY ":1.1", &amount));
+ TALER_amount_hton (&properties.value, &amount);
+ GNUNET_assert (GNUNET_OK ==
+ TALER_string_to_amount (CURRENCY ":0.1", &amount));
+ TALER_amount_hton (&properties.fee_withdraw, &amount);
+ TALER_amount_hton (&properties.fee_deposit, &amount);
+ TALER_amount_hton (&properties.fee_refresh, &amount);
+ GNUNET_CRYPTO_rsa_public_key_hash (denom_pub.rsa_public_key,
+ &properties.denom_hash);
+ issue.properties = properties;
+ }
+ {/* signature */
+ GNUNET_CRYPTO_eddsa_sign (master_prvt,
+ &properties.purpose,
+ &signature.eddsa_signature);
+ issue.signature = signature;
+ }
+ }
+ dki->denom_priv = denom_priv;
+ dki->denom_pub = denom_pub;
+ dki->issue = issue;
+ GNUNET_free (master_prvt);
+ return dki;
+}
+
+
+/**
+ * Copies the given denomination
+ * @param reserve the deposit copy
+ * @return a copy of @a deposit; NULL if error
+ */
+struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *
+PERF_TALER_EXCHANGEDB_denomination_copy (const struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *dki)
+{
+ struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *copy;
+
+ GNUNET_assert (NULL !=
+ (copy = GNUNET_new (struct TALER_EXCHANGEDB_DenominationKeyIssueInformation)));
+ {/* denom_priv */
+ copy->denom_priv.rsa_private_key =
+ GNUNET_CRYPTO_rsa_private_key_dup ( dki->denom_priv.rsa_private_key);
+ }
+ {/* denom_pub */
+ copy->denom_pub.rsa_public_key =
+ GNUNET_CRYPTO_rsa_public_key_dup (dki->denom_pub.rsa_public_key);
+ }
+ {/* issue */
+ copy->issue.properties = dki->issue.properties;
+ copy->issue.signature = dki->issue.signature;
+ }
+ return copy;
+}
+
+
+/**
+ * Free memory of a DenominationKeyIssueInformation
+ * @param dki pointer to the struct to free
+ */
+int
+PERF_TALER_EXCHANGEDB_denomination_free (struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *dki)
+{
+ if (NULL == dki)
+ return GNUNET_OK;
+ GNUNET_CRYPTO_rsa_private_key_free (dki->denom_priv.rsa_private_key);
+ GNUNET_CRYPTO_rsa_public_key_free (dki->denom_pub.rsa_public_key);
+
+ GNUNET_free (dki);
+ return GNUNET_OK;
+}
+
+
+/**
+ * Generate a dummy reserve for testing
+ * @return a reserve with 1000 EUR in it
+ */
+struct PERF_TALER_EXCHANGEDB_Reserve *
+PERF_TALER_EXCHANGEDB_reserve_init ()
+{
+ struct PERF_TALER_EXCHANGEDB_Reserve *reserve;
+
+ GNUNET_assert (NULL !=
+ (reserve = GNUNET_new (struct PERF_TALER_EXCHANGEDB_Reserve)));
+ {/* private */
+ struct GNUNET_CRYPTO_EddsaPrivateKey *private;
+ private = GNUNET_CRYPTO_eddsa_key_create ();
+ GNUNET_assert (NULL != private);
+ reserve->private = *private;
+ GNUNET_free (private);
+ }
+
+ GNUNET_CRYPTO_eddsa_key_get_public (&reserve->private,
+ &reserve->reserve.pub.eddsa_pub);
+ GNUNET_assert (GNUNET_OK ==
+ TALER_string_to_amount (CURRENCY ":1000", &reserve->reserve.balance));
+ reserve->reserve.expiry = GNUNET_TIME_absolute_get_forever_ ();
+ return reserve;
+}
+
+
+/**
+ * Copies the given reserve
+ * @param reserve the reserve to copy
+ * @return a copy of @a reserve; NULL if error
+ */
+struct PERF_TALER_EXCHANGEDB_Reserve *
+PERF_TALER_EXCHANGEDB_reserve_copy (const struct PERF_TALER_EXCHANGEDB_Reserve *reserve)
+{
+ struct PERF_TALER_EXCHANGEDB_Reserve *copy;
+ GNUNET_assert (NULL !=
+ (copy = GNUNET_new (struct PERF_TALER_EXCHANGEDB_Reserve)));
+ *copy = *reserve;
+ return copy;
+}
+
+
+/**
+ * Free memory of a reserve
+ * @param reserve pointer to the structure to be freed
+ */
+int
+PERF_TALER_EXCHANGEDB_reserve_free (struct PERF_TALER_EXCHANGEDB_Reserve *reserve)
+{
+ if (NULL == reserve)
+ return GNUNET_OK;
+ GNUNET_free (reserve);
+ return GNUNET_OK;
+}
+
+
+/**
+ * Generate a dummy deposit for testing purposes
+ * @param dki the denomination key used to sign the key
+ */
+struct TALER_EXCHANGEDB_Deposit *
+PERF_TALER_EXCHANGEDB_deposit_init (const struct PERF_TALER_EXCHANGEDB_Coin *coin)
+{
+ struct TALER_EXCHANGEDB_Deposit *deposit;
+ struct TALER_CoinSpendSignatureP csig;
+ struct TALER_MerchantPublicKeyP merchant_pub;
+ struct GNUNET_HashCode h_contract;
+ struct GNUNET_HashCode h_wire;
+ const char wire[] = "{"
+ "\"type\":\"SEPA\","
+ "\"IBAN\":\"DE67830654080004822650\","
+ "\"NAME\":\"GNUNET E.\","
+ "\"BIC\":\"GENODEF1SRL\""
+ "}";
+ static uint64_t transaction_id = 0;
+ struct GNUNET_TIME_Absolute timestamp;
+ struct GNUNET_TIME_Absolute refund_deadline;
+ struct TALER_Amount amount_with_fee;
+ struct TALER_Amount deposit_fee;
+
+ GNUNET_assert (NULL !=
+ (deposit = GNUNET_malloc (sizeof (struct TALER_EXCHANGEDB_Deposit) + sizeof (wire))));
+ GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK,
+ &h_contract);
+ GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK,
+ &h_wire);
+ { //csig
+ struct u32_presign
+ {
+ struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+ struct GNUNET_HashCode h_wire;
+ struct GNUNET_HashCode h_contract;
+ } unsigned_data;
+
+ unsigned_data.h_contract = h_contract;
+ unsigned_data.h_wire = h_wire;
+ unsigned_data.purpose.size = htonl (sizeof (struct u32_presign));
+ unsigned_data.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CRYPTO_eddsa_sign (&coin->priv,
+ &unsigned_data.purpose,
+ &csig.eddsa_signature));
+ }
+ { //merchant_pub
+ struct GNUNET_CRYPTO_EddsaPrivateKey *eddsa_prv;
+
+ eddsa_prv = GNUNET_CRYPTO_eddsa_key_create ();
+ GNUNET_assert(NULL != eddsa_prv);
+ GNUNET_CRYPTO_eddsa_key_get_public (
+ eddsa_prv,
+ &merchant_pub.eddsa_pub);
+ GNUNET_free (eddsa_prv);
+ }
+ timestamp = GNUNET_TIME_absolute_get ();
+ refund_deadline = GNUNET_TIME_absolute_get ();
+ GNUNET_assert (GNUNET_OK ==
+ TALER_string_to_amount (CURRENCY ":1.1",
+ &amount_with_fee));
+ GNUNET_assert (GNUNET_OK ==
+ TALER_string_to_amount (CURRENCY ":0.1",
+ &deposit_fee));
+ {
+ deposit->coin.coin_pub = coin->public_info.coin_pub;
+ deposit->coin.denom_pub.rsa_public_key = GNUNET_CRYPTO_rsa_public_key_dup (
+ coin->public_info.denom_pub.rsa_public_key);
+ GNUNET_assert (NULL != coin->public_info.denom_pub.rsa_public_key);
+ deposit->coin.denom_sig.rsa_signature = GNUNET_CRYPTO_rsa_signature_dup (
+ coin->public_info.denom_sig.rsa_signature);
+ GNUNET_assert (NULL != coin->public_info.denom_sig.rsa_signature);
+ }
+ deposit->csig = csig;
+ deposit->h_contract = h_contract;
+ deposit->h_wire = h_wire;
+ deposit->wire = json_loads (wire, 0, NULL);
+ deposit->transaction_id = transaction_id++;
+ deposit->timestamp = timestamp;
+ deposit->refund_deadline = refund_deadline;
+ deposit->amount_with_fee = amount_with_fee;
+ deposit->deposit_fee = deposit_fee;
+ return deposit;
+}
+
+
+/**
+ * Copies the given deposit
+ * @param reserve the deposit copy
+ * @return a copy of @a deposit; NULL if error
+ */
+struct TALER_EXCHANGEDB_Deposit *
+PERF_TALER_EXCHANGEDB_deposit_copy (const struct TALER_EXCHANGEDB_Deposit *deposit)
+{
+ struct TALER_EXCHANGEDB_Deposit *copy;
+
+ copy = GNUNET_new (struct TALER_EXCHANGEDB_Deposit);
+ *copy = *deposit;
+ json_incref (copy->wire);
+ copy->coin.denom_pub.rsa_public_key =
+ GNUNET_CRYPTO_rsa_public_key_dup (deposit->coin.denom_pub.rsa_public_key);
+ copy->coin.denom_sig.rsa_signature =
+ GNUNET_CRYPTO_rsa_signature_dup (deposit->coin.denom_sig.rsa_signature);
+ return copy;
+}
+
+
+/**
+ * Free memory of a deposit
+ * @param deposit pointer to the structure to free
+ */
+int
+PERF_TALER_EXCHANGEDB_deposit_free (struct TALER_EXCHANGEDB_Deposit *deposit)
+{
+ if (NULL == deposit)
+ return GNUNET_OK;
+ GNUNET_CRYPTO_rsa_public_key_free (deposit->coin.denom_pub.rsa_public_key);
+ GNUNET_CRYPTO_rsa_signature_free (deposit->coin.denom_sig.rsa_signature);
+ json_decref (deposit->wire);
+ GNUNET_free (deposit);
+ return GNUNET_OK;
+}
+
+
+/**
+ * Generate a CollectableBlindcoin for testing purpuses
+ * @param dki denomination key used to sign the coin
+ * @param reserve reserve providing the money for the coin
+ * @return a randomly generated CollectableBlindcoin
+ */
+struct PERF_TALER_EXCHANGEDB_Coin *
+PERF_TALER_EXCHANGEDB_coin_init (
+ const struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *dki,
+ const struct PERF_TALER_EXCHANGEDB_Reserve *reserve)
+{
+ struct PERF_TALER_EXCHANGEDB_Coin *coin;
+ struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
+
+ coin = GNUNET_new (struct PERF_TALER_EXCHANGEDB_Coin);
+ GNUNET_assert (NULL != coin);
+ /* priv */
+
+ priv = GNUNET_CRYPTO_eddsa_key_create();
+ GNUNET_assert (NULL != priv);
+ coin->priv = *priv;
+ GNUNET_free (priv);
+
+ /* public_info */
+ GNUNET_CRYPTO_eddsa_key_get_public (&coin->priv,
+ &coin->public_info.coin_pub.eddsa_pub);
+ coin->public_info.denom_pub.rsa_public_key =
+ GNUNET_CRYPTO_rsa_public_key_dup (dki->denom_pub.rsa_public_key);
+ coin->public_info.denom_sig.rsa_signature =
+ GNUNET_CRYPTO_rsa_sign (dki->denom_priv.rsa_private_key,
+ &coin->public_info.coin_pub,
+ sizeof (struct TALER_CoinSpendPublicKeyP));
+ GNUNET_assert (NULL != coin->public_info.denom_pub.rsa_public_key);
+ GNUNET_assert (NULL != coin->public_info.denom_sig.rsa_signature);
+
+ /* blind */
+ coin->blind.sig.rsa_signature =
+ GNUNET_CRYPTO_rsa_signature_dup (coin->public_info.denom_sig.rsa_signature);
+ coin->blind.denom_pub.rsa_public_key =
+ GNUNET_CRYPTO_rsa_public_key_dup (dki->denom_pub.rsa_public_key);
+ GNUNET_assert (NULL != coin->blind.sig.rsa_signature);
+ GNUNET_assert (NULL != coin->blind.denom_pub.rsa_public_key);
+ TALER_amount_ntoh (&coin->blind.amount_with_fee,
+ &dki->issue.properties.value);
+ TALER_amount_ntoh (&coin->blind.withdraw_fee,
+ &dki->issue.properties.fee_withdraw);
+ coin->blind.reserve_pub = reserve->reserve.pub;
+ GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK,
+ &coin->blind.h_coin_envelope);
+
+ return coin;
+}
+
+
+/**
+ * Copies the given coin
+ *
+ * @param coin the coin to copy
+ * @return a copy of coin; NULL if error
+ */
+struct PERF_TALER_EXCHANGEDB_Coin *
+PERF_TALER_EXCHANGEDB_coin_copy (const struct PERF_TALER_EXCHANGEDB_Coin *coin)
+{
+ struct PERF_TALER_EXCHANGEDB_Coin *copy;
+
+ copy = GNUNET_new (struct PERF_TALER_EXCHANGEDB_Coin);
+ /* priv */
+ copy->priv = coin->priv;
+ /* public_info */
+ copy->public_info.coin_pub = coin->public_info.coin_pub;
+ copy->public_info.denom_pub.rsa_public_key =
+ GNUNET_CRYPTO_rsa_public_key_dup (coin->public_info.denom_pub.rsa_public_key);
+ copy->public_info.denom_sig.rsa_signature =
+ GNUNET_CRYPTO_rsa_signature_dup (coin->public_info.denom_sig.rsa_signature);
+
+ /* blind */
+ copy->blind.sig.rsa_signature =
+ GNUNET_CRYPTO_rsa_signature_dup (coin->blind.sig.rsa_signature);
+ copy->blind.denom_pub.rsa_public_key =
+ GNUNET_CRYPTO_rsa_public_key_dup (coin->blind.denom_pub.rsa_public_key);
+ copy->blind.amount_with_fee = coin->blind.amount_with_fee;
+ copy->blind.withdraw_fee = coin->blind.withdraw_fee;
+ copy->blind.reserve_pub = coin->blind.reserve_pub;
+ copy->blind.h_coin_envelope = coin->blind.h_coin_envelope;
+ copy->blind.reserve_sig = coin->blind.reserve_sig;
+
+ return copy;
+}
+
+
+/**
+ * Free memory of @a coin
+ *
+ * @param coin pointer to the structure to free
+ */
+int
+PERF_TALER_EXCHANGEDB_coin_free (struct PERF_TALER_EXCHANGEDB_Coin *coin)
+{
+ if (NULL == coin)
+ return GNUNET_OK;
+ GNUNET_CRYPTO_rsa_public_key_free (coin->public_info.denom_pub.rsa_public_key);
+ GNUNET_CRYPTO_rsa_signature_free (coin->public_info.denom_sig.rsa_signature);
+ GNUNET_CRYPTO_rsa_signature_free (coin->blind.sig.rsa_signature);
+ GNUNET_CRYPTO_rsa_public_key_free (coin->blind.denom_pub.rsa_public_key);
+ GNUNET_free (coin);
+ return GNUNET_OK;
+}
+
+
+/**
+ * @return a randomly generated refresh session
+ */
+struct TALER_EXCHANGEDB_RefreshSession *
+PERF_TALER_EXCHANGEDB_refresh_session_init ()
+{
+ struct TALER_EXCHANGEDB_RefreshSession *refresh_session;
+
+ GNUNET_assert (NULL !=
+ (refresh_session = GNUNET_new (struct TALER_EXCHANGEDB_RefreshSession)));
+ refresh_session->noreveal_index = 1;
+ refresh_session->num_oldcoins = 1;
+ refresh_session->num_newcoins = 1;
+
+ return refresh_session;
+}
+
+
+/**
+ * @return #GNUNET_OK if the copy was successful, #GNUNET_SYSERR if it wasn't
+ */
+int
+PERF_TALER_EXCHANGEDB_refresh_session_copy (struct TALER_EXCHANGEDB_RefreshSession *session,
+ struct TALER_EXCHANGEDB_RefreshSession *copy)
+{
+ *copy = *session;
+ return GNUNET_OK;
+}
+
+
+/**
+ * Free a refresh session
+ */
+int
+PERF_TALER_EXCHANGEDB_refresh_session_free (struct TALER_EXCHANGEDB_RefreshSession *refresh_session)
+{
+ if (NULL == refresh_session)
+ return GNUNET_OK;
+ GNUNET_free (refresh_session);
+ return GNUNET_OK;
+}
+
+
+/**
+ * Create a melt operation
+ *
+ * @param session the refresh session
+ * @param dki the denomination the melted coin uses
+ * @return a pointer to a #TALER_EXCHANGEDB_RefreshMelt
+ */
+struct TALER_EXCHANGEDB_RefreshMelt *
+PERF_TALER_EXCHANGEDB_refresh_melt_init (struct GNUNET_HashCode *session,
+ struct PERF_TALER_EXCHANGEDB_Coin *coin)
+{
+ struct TALER_EXCHANGEDB_RefreshMelt *melt;
+ struct TALER_CoinSpendSignatureP coin_sig;
+ struct TALER_Amount amount;
+ struct TALER_Amount amount_with_fee;
+
+ {
+ struct
+ {
+ struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+ struct GNUNET_HashCode session;
+ } to_sign;
+
+ to_sign.purpose.purpose = GNUNET_SIGNATURE_PURPOSE_TEST;
+ to_sign.purpose.size = htonl (sizeof (to_sign));
+ to_sign.session = *session;
+ GNUNET_CRYPTO_eddsa_sign (&coin->priv,
+ &to_sign.purpose,
+ &coin_sig.eddsa_signature);
+ }
+ GNUNET_assert (GNUNET_OK ==
+ TALER_string_to_amount (CURRENCY ":1.1",
+ &amount));
+ GNUNET_assert (GNUNET_OK ==
+ TALER_string_to_amount (CURRENCY ":0.1",
+ &amount_with_fee));
+ melt = GNUNET_new (struct TALER_EXCHANGEDB_RefreshMelt);
+ melt->coin.coin_pub = coin->public_info.coin_pub;
+ melt->coin.denom_sig.rsa_signature =
+ GNUNET_CRYPTO_rsa_signature_dup (coin->public_info.denom_sig.rsa_signature);
+ melt->coin.denom_pub.rsa_public_key =
+ GNUNET_CRYPTO_rsa_public_key_dup (coin->public_info.denom_pub.rsa_public_key);
+ GNUNET_assert (NULL != melt->coin.denom_pub.rsa_public_key);
+ GNUNET_assert (NULL != melt->coin.denom_sig.rsa_signature);
+ melt->coin_sig = coin_sig;
+ melt->session_hash = *session;
+ melt->amount_with_fee = amount;
+ melt->melt_fee = amount_with_fee;
+ return melt;
+}
+
+
+/**
+ * Copies the internals of a #TALER_EXCHANGEDB_RefreshMelt
+ *
+ * @param melt the refresh melt to copy
+ * @return an copy of @ melt
+ */
+struct TALER_EXCHANGEDB_RefreshMelt *
+PERF_TALER_EXCHANGEDB_refresh_melt_copy (const struct TALER_EXCHANGEDB_RefreshMelt *melt)
+{
+ struct TALER_EXCHANGEDB_RefreshMelt *copy;
+
+ copy = GNUNET_new (struct TALER_EXCHANGEDB_RefreshMelt);
+ *copy = *melt;
+ copy->coin.denom_sig.rsa_signature =
+ GNUNET_CRYPTO_rsa_signature_dup (melt->coin.denom_sig.rsa_signature);
+ GNUNET_assert (NULL != copy->coin.denom_sig.rsa_signature);
+
+ return copy;
+}
+
+
+/**
+ * Free the internal memory of a #TALER_EXCHANGEDB_RefreshMelt
+ *
+ * @param melt the #TALER_EXCHANGEDB_RefreshMelt to free
+ * @return #GNUNET_OK if the operation was successful, #GNUNET_SYSERROR
+ */
+int
+PERF_TALER_EXCHANGEDB_refresh_melt_free (struct TALER_EXCHANGEDB_RefreshMelt *melt)
+{
+ GNUNET_CRYPTO_rsa_signature_free (melt->coin.denom_sig.rsa_signature);
+ GNUNET_free (melt);
+ return GNUNET_OK;
+}
+
+
+/**
+ * Create a #TALER_EXCHANGEDB_RefreshCommitCoin
+ */
+struct TALER_EXCHANGEDB_RefreshCommitCoin *
+PERF_TALER_EXCHANGEDB_refresh_commit_coin_init ()
+{
+ struct TALER_EXCHANGEDB_RefreshCommitCoin *commit_coin;
+ struct TALER_RefreshLinkEncrypted refresh_link;
+
+ commit_coin = GNUNET_new (struct TALER_EXCHANGEDB_RefreshCommitCoin);
+ GNUNET_assert (NULL != commit_coin);
+ {/* refresh_link */
+ refresh_link = (struct TALER_RefreshLinkEncrypted)
+ {
+ .blinding_key_enc = "blinding_key",
+ .blinding_key_enc_size = 13
+ };
+ GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+ &refresh_link.coin_priv_enc,
+ sizeof(struct TALER_CoinSpendPrivateKeyP));
+ }
+ commit_coin->coin_ev = "coin_ev";
+ commit_coin->coin_ev_size = 8;
+ commit_coin->refresh_link = GNUNET_new (struct TALER_RefreshLinkEncrypted);
+ *commit_coin->refresh_link = refresh_link;
+ return commit_coin;
+}
+
+
+/**
+ * Copies a #TALER_EXCHANGEDB_RefreshCommitCoin
+ *
+ * @param commit_coin the commit to copy
+ * @return a copy of @a commit_coin
+ */
+struct TALER_EXCHANGEDB_RefreshCommitCoin *
+PERF_TALER_EXCHANGEDB_refresh_commit_coin_copy (struct TALER_EXCHANGEDB_RefreshCommitCoin *commit_coin)
+{
+ struct TALER_EXCHANGEDB_RefreshCommitCoin *copy;
+
+ copy = GNUNET_new (struct TALER_EXCHANGEDB_RefreshCommitCoin);
+ copy->refresh_link = GNUNET_new (struct TALER_RefreshLinkEncrypted);
+ *copy->refresh_link = *commit_coin->refresh_link;
+ return copy;
+}
+
+
+/**
+ * Free a #TALER_EXCHANGEDB_RefreshCommitCoin
+ *
+ * @param commit_coin the coin to free
+ */
+void
+PERF_TALER_EXCHANGEDB_refresh_commit_coin_free (struct TALER_EXCHANGEDB_RefreshCommitCoin *commit_coin)
+{
+ GNUNET_free (commit_coin->refresh_link);
+ GNUNET_free (commit_coin);
+}