mirror of
https://git.wownero.com/wownero/wownero.git
synced 2024-08-15 01:03:23 +00:00
support old BP
This commit is contained in:
parent
952b0492d9
commit
e1ff02c1c5
14 changed files with 1567 additions and 49 deletions
|
@ -305,7 +305,7 @@ namespace boost
|
||||||
a & x.type;
|
a & x.type;
|
||||||
if (x.type == rct::RCTTypeNull)
|
if (x.type == rct::RCTTypeNull)
|
||||||
return;
|
return;
|
||||||
if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2 && x.type != rct::RCTTypeCLSAG)
|
if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2 && x.type != rct::RCTTypeFullBulletproof && x.type != rct::RCTTypeSimpleBulletproof && x.type != rct::RCTTypeCLSAG)
|
||||||
throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
|
throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
|
||||||
// a & x.message; message is not serialized, as it can be reconstructed from the tx data
|
// a & x.message; message is not serialized, as it can be reconstructed from the tx data
|
||||||
// a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
|
// a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
|
||||||
|
@ -335,7 +335,7 @@ namespace boost
|
||||||
a & x.type;
|
a & x.type;
|
||||||
if (x.type == rct::RCTTypeNull)
|
if (x.type == rct::RCTTypeNull)
|
||||||
return;
|
return;
|
||||||
if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2 && x.type != rct::RCTTypeCLSAG)
|
if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2 && x.type != rct::RCTTypeFullBulletproof && x.type != rct::RCTTypeSimpleBulletproof && x.type != rct::RCTTypeCLSAG)
|
||||||
throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
|
throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
|
||||||
// a & x.message; message is not serialized, as it can be reconstructed from the tx data
|
// a & x.message; message is not serialized, as it can be reconstructed from the tx data
|
||||||
// a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
|
// a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
|
||||||
|
@ -351,7 +351,7 @@ namespace boost
|
||||||
a & x.p.MGs;
|
a & x.p.MGs;
|
||||||
if (ver >= 1u)
|
if (ver >= 1u)
|
||||||
a & x.p.CLSAGs;
|
a & x.p.CLSAGs;
|
||||||
if (x.type == rct::RCTTypeBulletproof || x.type == rct::RCTTypeBulletproof2 || x.type == rct::RCTTypeCLSAG)
|
if (x.type == rct::RCTTypeBulletproof || x.type == rct::RCTTypeBulletproof2 || x.type == rct::RCTTypeSimpleBulletproof || x.type == rct::RCTTypeCLSAG)
|
||||||
a & x.p.pseudoOuts;
|
a & x.p.pseudoOuts;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -164,7 +164,7 @@ namespace cryptonote
|
||||||
if (!base_only)
|
if (!base_only)
|
||||||
{
|
{
|
||||||
const bool bulletproof = rct::is_rct_bulletproof(rv.type);
|
const bool bulletproof = rct::is_rct_bulletproof(rv.type);
|
||||||
if (bulletproof)
|
if (rct::is_rct_new_bulletproof(rv.type))
|
||||||
{
|
{
|
||||||
if (rv.p.bulletproofs.size() != 1)
|
if (rv.p.bulletproofs.size() != 1)
|
||||||
{
|
{
|
||||||
|
@ -177,7 +177,7 @@ namespace cryptonote
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
const size_t max_outputs = 1 << (rv.p.bulletproofs[0].L.size() - 6);
|
const size_t max_outputs = 1 << (rv.p.bulletproofs[0].L.size() - 6);
|
||||||
if (max_outputs < tx.vout.size())
|
if (max_outputs < tx.vout.size() && rv.type == rct::RCTTypeBulletproof)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs max outputs in tx " << get_transaction_hash(tx));
|
LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs max outputs in tx " << get_transaction_hash(tx));
|
||||||
return false;
|
return false;
|
||||||
|
@ -188,6 +188,26 @@ namespace cryptonote
|
||||||
for (size_t i = 0; i < n_amounts; ++i)
|
for (size_t i = 0; i < n_amounts; ++i)
|
||||||
rv.p.bulletproofs[0].V[i] = rct::scalarmultKey(rv.outPk[i].mask, rct::INV_EIGHT);
|
rv.p.bulletproofs[0].V[i] = rct::scalarmultKey(rv.outPk[i].mask, rct::INV_EIGHT);
|
||||||
}
|
}
|
||||||
|
else if (bulletproof)
|
||||||
|
{
|
||||||
|
if (rct::n_bulletproof_v1_amounts(rv.p.bulletproofs) != tx.vout.size())
|
||||||
|
{
|
||||||
|
LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs size in tx " << get_transaction_hash(tx));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
size_t idx = 0;
|
||||||
|
for (size_t n = 0; n < rv.outPk.size(); ++n)
|
||||||
|
{
|
||||||
|
//rv.p.bulletproofs[n].V.resize(1);
|
||||||
|
//rv.p.bulletproofs[n].V[0] = rv.outPk[n].mask;
|
||||||
|
CHECK_AND_ASSERT_MES(rv.p.bulletproofs[n].L.size() >= 6, false, "Bad bulletproofs L size"); // at least 64 bits
|
||||||
|
const size_t n_amounts = rct::n_bulletproof_v1_amounts(rv.p.bulletproofs[n]);
|
||||||
|
CHECK_AND_ASSERT_MES(idx + n_amounts <= rv.outPk.size(), false, "Internal error filling out V");
|
||||||
|
rv.p.bulletproofs[n].V.resize(n_amounts);
|
||||||
|
for (size_t i = 0; i < n_amounts; ++i)
|
||||||
|
rv.p.bulletproofs[n].V[i] = rv.outPk[idx++].mask;
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return true;
|
return true;
|
||||||
|
@ -410,6 +430,12 @@ namespace cryptonote
|
||||||
const rct::rctSig &rv = tx.rct_signatures;
|
const rct::rctSig &rv = tx.rct_signatures;
|
||||||
if (!rct::is_rct_bulletproof(rv.type))
|
if (!rct::is_rct_bulletproof(rv.type))
|
||||||
return blob_size;
|
return blob_size;
|
||||||
|
const size_t n_outputs = tx.vout.size();
|
||||||
|
if (n_outputs <= 2)
|
||||||
|
return blob_size;
|
||||||
|
if (rct::is_rct_old_bulletproof(rv.type))
|
||||||
|
return blob_size;
|
||||||
|
const uint64_t bp_base = 368;
|
||||||
const size_t n_padded_outputs = rct::n_bulletproof_max_amounts(rv.p.bulletproofs);
|
const size_t n_padded_outputs = rct::n_bulletproof_max_amounts(rv.p.bulletproofs);
|
||||||
uint64_t bp_clawback = get_transaction_weight_clawback(tx, n_padded_outputs);
|
uint64_t bp_clawback = get_transaction_weight_clawback(tx, n_padded_outputs);
|
||||||
CHECK_AND_ASSERT_THROW_MES_L1(bp_clawback <= std::numeric_limits<uint64_t>::max() - blob_size, "Weight overflow");
|
CHECK_AND_ASSERT_THROW_MES_L1(bp_clawback <= std::numeric_limits<uint64_t>::max() - blob_size, "Weight overflow");
|
||||||
|
|
|
@ -3092,13 +3092,13 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// from v11, allow bulletproofs
|
// from v8, allow bulletproofs
|
||||||
if (hf_version < 11) {
|
if (hf_version < 8) {
|
||||||
if (tx.version >= 2) {
|
if (tx.version >= 2) {
|
||||||
const bool bulletproof = rct::is_rct_bulletproof(tx.rct_signatures.type);
|
const bool bulletproof = rct::is_rct_bulletproof(tx.rct_signatures.type);
|
||||||
if (bulletproof || !tx.rct_signatures.p.bulletproofs.empty())
|
if (bulletproof || !tx.rct_signatures.p.bulletproofs.empty())
|
||||||
{
|
{
|
||||||
MERROR_VER("New Bulletproofs are not allowed before v11");
|
MERROR_VER("Bulletproofs are not allowed before v8");
|
||||||
tvc.m_invalid_output = true;
|
tvc.m_invalid_output = true;
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
@ -3118,7 +3118,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// from v10, allow bulletproofs v2
|
// from v13, allow bulletproofs v2
|
||||||
if (hf_version < HF_VERSION_SMALLER_BP) {
|
if (hf_version < HF_VERSION_SMALLER_BP) {
|
||||||
if (tx.version >= 2) {
|
if (tx.version >= 2) {
|
||||||
if (tx.rct_signatures.type == rct::RCTTypeBulletproof2)
|
if (tx.rct_signatures.type == rct::RCTTypeBulletproof2)
|
||||||
|
@ -3130,7 +3130,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// from v11, allow only bulletproofs v2
|
// from v14, allow only bulletproofs v2
|
||||||
if (hf_version > HF_VERSION_SMALLER_BP) {
|
if (hf_version > HF_VERSION_SMALLER_BP) {
|
||||||
if (tx.version >= 2) {
|
if (tx.version >= 2) {
|
||||||
if (tx.rct_signatures.type == rct::RCTTypeBulletproof)
|
if (tx.rct_signatures.type == rct::RCTTypeBulletproof)
|
||||||
|
@ -3142,7 +3142,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// from v13, allow CLSAGs
|
// from v16, allow CLSAGs
|
||||||
if (hf_version < HF_VERSION_CLSAG) {
|
if (hf_version < HF_VERSION_CLSAG) {
|
||||||
if (tx.version >= 2) {
|
if (tx.version >= 2) {
|
||||||
if (tx.rct_signatures.type == rct::RCTTypeCLSAG)
|
if (tx.rct_signatures.type == rct::RCTTypeCLSAG)
|
||||||
|
@ -3154,7 +3154,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// from v14, allow only CLSAGs
|
// from v17, allow only CLSAGs
|
||||||
if (hf_version > HF_VERSION_CLSAG) {
|
if (hf_version > HF_VERSION_CLSAG) {
|
||||||
if (tx.version >= 2) {
|
if (tx.version >= 2) {
|
||||||
if (tx.rct_signatures.type <= rct::RCTTypeBulletproof2)
|
if (tx.rct_signatures.type <= rct::RCTTypeBulletproof2)
|
||||||
|
@ -3178,6 +3178,19 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// from v12, forbid old bulletproofs
|
||||||
|
if (hf_version > 11) {
|
||||||
|
if (tx.version >= 2) {
|
||||||
|
const bool old_bulletproof = rct::is_rct_old_bulletproof(tx.rct_signatures.type);
|
||||||
|
if (old_bulletproof)
|
||||||
|
{
|
||||||
|
MERROR_VER("Old Bulletproofs are not allowed after v11");
|
||||||
|
tvc.m_invalid_output = true;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
//------------------------------------------------------------------
|
//------------------------------------------------------------------
|
||||||
|
@ -3203,7 +3216,7 @@ bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_pr
|
||||||
rv.message = rct::hash2rct(tx_prefix_hash);
|
rv.message = rct::hash2rct(tx_prefix_hash);
|
||||||
|
|
||||||
// mixRing - full and simple store it in opposite ways
|
// mixRing - full and simple store it in opposite ways
|
||||||
if (rv.type == rct::RCTTypeFull)
|
if (rv.type == rct::RCTTypeFull || rv.type == rct::RCTTypeFullBulletproof)
|
||||||
{
|
{
|
||||||
CHECK_AND_ASSERT_MES(!pubkeys.empty() && !pubkeys[0].empty(), false, "empty pubkeys");
|
CHECK_AND_ASSERT_MES(!pubkeys.empty() && !pubkeys[0].empty(), false, "empty pubkeys");
|
||||||
rv.mixRing.resize(pubkeys[0].size());
|
rv.mixRing.resize(pubkeys[0].size());
|
||||||
|
@ -3218,7 +3231,7 @@ bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_pr
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (rv.type == rct::RCTTypeSimple || rv.type == rct::RCTTypeBulletproof || rv.type == rct::RCTTypeBulletproof2 || rv.type == rct::RCTTypeCLSAG)
|
else if (rv.type == rct::RCTTypeSimple || rv.type == rct::RCTTypeBulletproof || rv.type == rct::RCTTypeBulletproof2 || rv.type == rct::RCTTypeSimpleBulletproof || rv.type == rct::RCTTypeCLSAG)
|
||||||
{
|
{
|
||||||
CHECK_AND_ASSERT_MES(!pubkeys.empty() && !pubkeys[0].empty(), false, "empty pubkeys");
|
CHECK_AND_ASSERT_MES(!pubkeys.empty() && !pubkeys[0].empty(), false, "empty pubkeys");
|
||||||
rv.mixRing.resize(pubkeys.size());
|
rv.mixRing.resize(pubkeys.size());
|
||||||
|
@ -3245,7 +3258,7 @@ bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_pr
|
||||||
}
|
}
|
||||||
|
|
||||||
// II
|
// II
|
||||||
if (rv.type == rct::RCTTypeFull)
|
if (rv.type == rct::RCTTypeFull || rv.type == rct::RCTTypeFullBulletproof)
|
||||||
{
|
{
|
||||||
if (!tx.pruned)
|
if (!tx.pruned)
|
||||||
{
|
{
|
||||||
|
@ -3255,7 +3268,7 @@ bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_pr
|
||||||
rv.p.MGs[0].II[n] = rct::ki2rct(boost::get<txin_to_key>(tx.vin[n]).k_image);
|
rv.p.MGs[0].II[n] = rct::ki2rct(boost::get<txin_to_key>(tx.vin[n]).k_image);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (rv.type == rct::RCTTypeSimple || rv.type == rct::RCTTypeBulletproof || rv.type == rct::RCTTypeBulletproof2)
|
else if (rv.type == rct::RCTTypeSimple || rv.type == rct::RCTTypeBulletproof || rv.type == rct::RCTTypeBulletproof2 || rv.type == rct::RCTTypeSimpleBulletproof)
|
||||||
{
|
{
|
||||||
if (!tx.pruned)
|
if (!tx.pruned)
|
||||||
{
|
{
|
||||||
|
@ -3557,6 +3570,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
case rct::RCTTypeSimple:
|
case rct::RCTTypeSimple:
|
||||||
|
case rct::RCTTypeSimpleBulletproof:
|
||||||
case rct::RCTTypeBulletproof:
|
case rct::RCTTypeBulletproof:
|
||||||
case rct::RCTTypeBulletproof2:
|
case rct::RCTTypeBulletproof2:
|
||||||
case rct::RCTTypeCLSAG:
|
case rct::RCTTypeCLSAG:
|
||||||
|
@ -3623,6 +3637,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case rct::RCTTypeFull:
|
case rct::RCTTypeFull:
|
||||||
|
case rct::RCTTypeFullBulletproof:
|
||||||
{
|
{
|
||||||
// check all this, either reconstructed (so should really pass), or not
|
// check all this, either reconstructed (so should really pass), or not
|
||||||
{
|
{
|
||||||
|
@ -3689,13 +3704,13 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
|
||||||
// for bulletproofs, check they're only multi-output after v8
|
// for bulletproofs, check they're only multi-output after v8
|
||||||
if (rct::is_rct_bulletproof(rv.type))
|
if (rct::is_rct_bulletproof(rv.type))
|
||||||
{
|
{
|
||||||
if (hf_version < 11)
|
if (hf_version < 8)
|
||||||
{
|
{
|
||||||
for (const rct::Bulletproof &proof: rv.p.bulletproofs)
|
for (const rct::Bulletproof &proof: rv.p.bulletproofs)
|
||||||
{
|
{
|
||||||
if (proof.V.size() > 1)
|
if (proof.V.size() > 1)
|
||||||
{
|
{
|
||||||
MERROR_VER("Multi output bulletproofs are invalid before v11");
|
MERROR_VER("Multi output bulletproofs are invalid before v8");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -849,6 +849,44 @@ namespace cryptonote
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// resolve outPk references in rct txes
|
||||||
|
// outPk aren't the only thing that need resolving for a fully resolved tx,
|
||||||
|
// but outPk (1) are needed now to check range proof semantics, and
|
||||||
|
// (2) do not need access to the blockchain to find data
|
||||||
|
if (tx.version >= 2)
|
||||||
|
{
|
||||||
|
rct::rctSig &rv = tx.rct_signatures;
|
||||||
|
if (!rct::is_rct_new_bulletproof(rv.type)){
|
||||||
|
if (rv.outPk.size() != tx.vout.size())
|
||||||
|
{
|
||||||
|
LOG_PRINT_L1("WRONG TRANSACTION BLOB, Bad outPk size in tx " << tx_hash << ", rejected");
|
||||||
|
tvc.m_verifivation_failed = true;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
for (size_t n = 0; n < tx.rct_signatures.outPk.size(); ++n)
|
||||||
|
rv.outPk[n].dest = rct::pk2rct(boost::get<txout_to_key>(tx.vout[n].target).key);
|
||||||
|
const bool bulletproof = rct::is_rct_bulletproof(rv.type);
|
||||||
|
if (bulletproof)
|
||||||
|
{
|
||||||
|
if (rct::n_bulletproof_v1_amounts(rv.p.bulletproofs) != tx.vout.size())
|
||||||
|
{
|
||||||
|
LOG_PRINT_L1("WRONG TRANSACTION BLOB, Bad bulletproofs size in tx " << tx_hash << ", rejected");
|
||||||
|
tvc.m_verifivation_failed = true;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
size_t idx = 0;
|
||||||
|
for (size_t n = 0; n < rv.p.bulletproofs.size(); ++n)
|
||||||
|
{
|
||||||
|
CHECK_AND_ASSERT_MES(rv.p.bulletproofs[n].L.size() >= 6, false, "Bad bulletproofs L size"); // at least 64 bits
|
||||||
|
const size_t n_amounts = rct::n_bulletproof_v1_amounts(rv.p.bulletproofs[n]);
|
||||||
|
CHECK_AND_ASSERT_MES(idx + n_amounts <= rv.outPk.size(), false, "Internal error filling out V");
|
||||||
|
rv.p.bulletproofs[n].V.clear();
|
||||||
|
for (size_t i = 0; i < n_amounts; ++i)
|
||||||
|
rv.p.bulletproofs[n].V.push_back(rv.outPk[idx++].mask);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
//-----------------------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------------------
|
||||||
|
@ -907,6 +945,7 @@ namespace cryptonote
|
||||||
tx_info[n].result = false;
|
tx_info[n].result = false;
|
||||||
break;
|
break;
|
||||||
case rct::RCTTypeSimple:
|
case rct::RCTTypeSimple:
|
||||||
|
case rct::RCTTypeSimpleBulletproof:
|
||||||
if (!rct::verRctSemanticsSimple(rv))
|
if (!rct::verRctSemanticsSimple(rv))
|
||||||
{
|
{
|
||||||
MERROR_VER("rct signature semantics check failed");
|
MERROR_VER("rct signature semantics check failed");
|
||||||
|
@ -917,6 +956,7 @@ namespace cryptonote
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
case rct::RCTTypeFull:
|
case rct::RCTTypeFull:
|
||||||
|
case rct::RCTTypeFullBulletproof:
|
||||||
if (!rct::verRct(rv, true))
|
if (!rct::verRct(rv, true))
|
||||||
{
|
{
|
||||||
MERROR_VER("rct signature semantics check failed");
|
MERROR_VER("rct signature semantics check failed");
|
||||||
|
|
|
@ -602,7 +602,9 @@ namespace cryptonote
|
||||||
crypto::hash tx_prefix_hash;
|
crypto::hash tx_prefix_hash;
|
||||||
get_transaction_prefix_hash(tx, tx_prefix_hash, hwdev);
|
get_transaction_prefix_hash(tx, tx_prefix_hash, hwdev);
|
||||||
rct::ctkeyV outSk;
|
rct::ctkeyV outSk;
|
||||||
if (use_simple_rct)
|
if (rct_config.range_proof_type != rct::RangeProofPaddedBulletproof && use_simple_rct)
|
||||||
|
tx.rct_signatures = rct::genRctSimple_old(rct::hash2rct(tx_prefix_hash), inSk, destinations, inamounts, outamounts, amount_in - amount_out, mixRing, amount_keys, msout ? &kLRki : NULL, msout, index, outSk, rct_config, hwdev);
|
||||||
|
else if (use_simple_rct && rct_config.range_proof_type == rct::RangeProofPaddedBulletproof)
|
||||||
tx.rct_signatures = rct::genRctSimple(rct::hash2rct(tx_prefix_hash), inSk, destinations, inamounts, outamounts, amount_in - amount_out, mixRing, amount_keys, msout ? &kLRki : NULL, msout, index, outSk, rct_config, hwdev);
|
tx.rct_signatures = rct::genRctSimple(rct::hash2rct(tx_prefix_hash), inSk, destinations, inamounts, outamounts, amount_in - amount_out, mixRing, amount_keys, msout ? &kLRki : NULL, msout, index, outSk, rct_config, hwdev);
|
||||||
else
|
else
|
||||||
tx.rct_signatures = rct::genRct(rct::hash2rct(tx_prefix_hash), inSk, destinations, outamounts, mixRing, amount_keys, msout ? &kLRki[0] : NULL, msout, sources[0].real_output, outSk, rct_config, hwdev); // same index assumption
|
tx.rct_signatures = rct::genRct(rct::hash2rct(tx_prefix_hash), inSk, destinations, outamounts, mixRing, amount_keys, msout ? &kLRki[0] : NULL, msout, sources[0].real_output, outSk, rct_config, hwdev); // same index assumption
|
||||||
|
|
|
@ -112,8 +112,8 @@ namespace cryptonote
|
||||||
|
|
||||||
uint64_t get_transaction_weight_limit(uint8_t version)
|
uint64_t get_transaction_weight_limit(uint8_t version)
|
||||||
{
|
{
|
||||||
// from v8, limit a tx to 50% of the minimum block weight
|
// from v12, limit a tx to 50% of the minimum block weight
|
||||||
if (version >= 8)
|
if (version >= 12)
|
||||||
return get_min_block_weight(version) / 2 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
|
return get_min_block_weight(version) / 2 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
|
||||||
else
|
else
|
||||||
return get_min_block_weight(version) - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
|
return get_min_block_weight(version) - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
|
||||||
|
|
|
@ -31,7 +31,8 @@ set(ringct_basic_sources
|
||||||
rctTypes.cpp
|
rctTypes.cpp
|
||||||
rctCryptoOps.c
|
rctCryptoOps.c
|
||||||
multiexp.cc
|
multiexp.cc
|
||||||
bulletproofs.cc)
|
bulletproofs.cc
|
||||||
|
bulletproofs2.cc)
|
||||||
|
|
||||||
set(ringct_basic_private_headers
|
set(ringct_basic_private_headers
|
||||||
rctOps.h
|
rctOps.h
|
||||||
|
|
|
@ -42,9 +42,16 @@ Bulletproof bulletproof_PROVE(const rct::key &v, const rct::key &gamma);
|
||||||
Bulletproof bulletproof_PROVE(uint64_t v, const rct::key &gamma);
|
Bulletproof bulletproof_PROVE(uint64_t v, const rct::key &gamma);
|
||||||
Bulletproof bulletproof_PROVE(const rct::keyV &v, const rct::keyV &gamma);
|
Bulletproof bulletproof_PROVE(const rct::keyV &v, const rct::keyV &gamma);
|
||||||
Bulletproof bulletproof_PROVE(const std::vector<uint64_t> &v, const rct::keyV &gamma);
|
Bulletproof bulletproof_PROVE(const std::vector<uint64_t> &v, const rct::keyV &gamma);
|
||||||
|
Bulletproof bulletproof_PROVE_old(const rct::key &v, const rct::key &gamma);
|
||||||
|
Bulletproof bulletproof_PROVE_old(uint64_t v, const rct::key &gamma);
|
||||||
|
Bulletproof bulletproof_PROVE_old(const rct::keyV &v, const rct::keyV &gamma);
|
||||||
|
Bulletproof bulletproof_PROVE_old(const std::vector<uint64_t> &v, const rct::keyV &gamma);
|
||||||
bool bulletproof_VERIFY(const Bulletproof &proof);
|
bool bulletproof_VERIFY(const Bulletproof &proof);
|
||||||
bool bulletproof_VERIFY(const std::vector<const Bulletproof*> &proofs);
|
bool bulletproof_VERIFY(const std::vector<const Bulletproof*> &proofs);
|
||||||
bool bulletproof_VERIFY(const std::vector<Bulletproof> &proofs);
|
bool bulletproof_VERIFY(const std::vector<Bulletproof> &proofs);
|
||||||
|
bool bulletproof_VERIFY_old(const Bulletproof &proof);
|
||||||
|
bool bulletproof_VERIFY_old(const std::vector<const Bulletproof*> &proofs);
|
||||||
|
bool bulletproof_VERIFY_old(const std::vector<Bulletproof> &proofs);
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
1165
src/ringct/bulletproofs2.cc
Normal file
1165
src/ringct/bulletproofs2.cc
Normal file
File diff suppressed because it is too large
Load diff
|
@ -93,6 +93,24 @@ namespace rct {
|
||||||
return proof;
|
return proof;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Bulletproof proveRangeBulletproof_old(key &C, key &mask, uint64_t amount)
|
||||||
|
{
|
||||||
|
mask = rct::skGen();
|
||||||
|
Bulletproof proof = bulletproof_PROVE_old(amount, mask);
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(proof.V.size() == 1, "V has not exactly one element");
|
||||||
|
C = proof.V[0];
|
||||||
|
return proof;
|
||||||
|
}
|
||||||
|
|
||||||
|
Bulletproof proveRangeBulletproof_old(keyV &C, keyV &masks, const std::vector<uint64_t> &amounts)
|
||||||
|
{
|
||||||
|
masks = rct::skvGen(amounts.size());
|
||||||
|
Bulletproof proof = bulletproof_PROVE_old(amounts, masks);
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(proof.V.size() == amounts.size(), "V does not have the expected size");
|
||||||
|
C = proof.V;
|
||||||
|
return proof;
|
||||||
|
}
|
||||||
|
|
||||||
bool verBulletproof(const Bulletproof &proof)
|
bool verBulletproof(const Bulletproof &proof)
|
||||||
{
|
{
|
||||||
try { return bulletproof_VERIFY(proof); }
|
try { return bulletproof_VERIFY(proof); }
|
||||||
|
@ -107,6 +125,20 @@ namespace rct {
|
||||||
catch (...) { return false; }
|
catch (...) { return false; }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
bool verBulletproof_old(const Bulletproof &proof)
|
||||||
|
{
|
||||||
|
try { return bulletproof_VERIFY_old(proof); }
|
||||||
|
// we can get deep throws from ge_frombytes_vartime if input isn't valid
|
||||||
|
catch (...) { return false; }
|
||||||
|
}
|
||||||
|
|
||||||
|
bool verBulletproof_old(const std::vector<const Bulletproof*> &proofs)
|
||||||
|
{
|
||||||
|
try { return bulletproof_VERIFY_old(proofs); }
|
||||||
|
// we can get deep throws from ge_frombytes_vartime if input isn't valid
|
||||||
|
catch (...) { return false; }
|
||||||
|
}
|
||||||
|
|
||||||
//Borromean (c.f. gmax/andytoshi's paper)
|
//Borromean (c.f. gmax/andytoshi's paper)
|
||||||
boroSig genBorromean(const key64 x, const key64 P1, const key64 P2, const bits indices) {
|
boroSig genBorromean(const key64 x, const key64 P1, const key64 P2, const bits indices) {
|
||||||
key64 L[2], alpha;
|
key64 L[2], alpha;
|
||||||
|
@ -589,7 +621,7 @@ namespace rct {
|
||||||
hashes.push_back(hash2rct(h));
|
hashes.push_back(hash2rct(h));
|
||||||
|
|
||||||
keyV kv;
|
keyV kv;
|
||||||
if (rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeCLSAG)
|
if (rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeSimpleBulletproof || rv.type == RCTTypeFullBulletproof || rv.type == RCTTypeCLSAG)
|
||||||
{
|
{
|
||||||
kv.reserve((6*2+9) * rv.p.bulletproofs.size());
|
kv.reserve((6*2+9) * rv.p.bulletproofs.size());
|
||||||
for (const auto &p: rv.p.bulletproofs)
|
for (const auto &p: rv.p.bulletproofs)
|
||||||
|
@ -1003,6 +1035,7 @@ namespace rct {
|
||||||
// Note: For txn fees, the last index in the amounts vector should contain that
|
// Note: For txn fees, the last index in the amounts vector should contain that
|
||||||
// Thus the amounts vector will be "one" longer than the destinations vectort
|
// Thus the amounts vector will be "one" longer than the destinations vectort
|
||||||
rctSig genRct(const key &message, const ctkeyV & inSk, const keyV & destinations, const vector<xmr_amount> & amounts, const ctkeyM &mixRing, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, unsigned int index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev) {
|
rctSig genRct(const key &message, const ctkeyV & inSk, const keyV & destinations, const vector<xmr_amount> & amounts, const ctkeyM &mixRing, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, unsigned int index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev) {
|
||||||
|
const bool bulletproof = rct_config.range_proof_type != RangeProofBorromean;
|
||||||
CHECK_AND_ASSERT_THROW_MES(amounts.size() == destinations.size() || amounts.size() == destinations.size() + 1, "Different number of amounts/destinations");
|
CHECK_AND_ASSERT_THROW_MES(amounts.size() == destinations.size() || amounts.size() == destinations.size() + 1, "Different number of amounts/destinations");
|
||||||
CHECK_AND_ASSERT_THROW_MES(amount_keys.size() == destinations.size(), "Different number of amount_keys/destinations");
|
CHECK_AND_ASSERT_THROW_MES(amount_keys.size() == destinations.size(), "Different number of amount_keys/destinations");
|
||||||
CHECK_AND_ASSERT_THROW_MES(index < mixRing.size(), "Bad index into mixRing");
|
CHECK_AND_ASSERT_THROW_MES(index < mixRing.size(), "Bad index into mixRing");
|
||||||
|
@ -1013,9 +1046,10 @@ namespace rct {
|
||||||
CHECK_AND_ASSERT_THROW_MES(inSk.size() < 2, "genRct is not suitable for 2+ rings");
|
CHECK_AND_ASSERT_THROW_MES(inSk.size() < 2, "genRct is not suitable for 2+ rings");
|
||||||
|
|
||||||
rctSig rv;
|
rctSig rv;
|
||||||
rv.type = RCTTypeFull;
|
rv.type = bulletproof ? RCTTypeFullBulletproof : RCTTypeFull;
|
||||||
rv.message = message;
|
rv.message = message;
|
||||||
rv.outPk.resize(destinations.size());
|
rv.outPk.resize(destinations.size());
|
||||||
|
if (!bulletproof)
|
||||||
rv.p.rangeSigs.resize(destinations.size());
|
rv.p.rangeSigs.resize(destinations.size());
|
||||||
rv.ecdhInfo.resize(destinations.size());
|
rv.ecdhInfo.resize(destinations.size());
|
||||||
|
|
||||||
|
@ -1026,10 +1060,45 @@ namespace rct {
|
||||||
//add destination to sig
|
//add destination to sig
|
||||||
rv.outPk[i].dest = copy(destinations[i]);
|
rv.outPk[i].dest = copy(destinations[i]);
|
||||||
//compute range proof
|
//compute range proof
|
||||||
|
if (!bulletproof)
|
||||||
|
{
|
||||||
rv.p.rangeSigs[i] = proveRange(rv.outPk[i].mask, outSk[i].mask, amounts[i]);
|
rv.p.rangeSigs[i] = proveRange(rv.outPk[i].mask, outSk[i].mask, amounts[i]);
|
||||||
|
|
||||||
#ifdef DBG
|
#ifdef DBG
|
||||||
CHECK_AND_ASSERT_THROW_MES(verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]), "verRange failed on newly created proof");
|
CHECK_AND_ASSERT_THROW_MES(verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]), "verRange failed on newly created proof");
|
||||||
#endif
|
#endif
|
||||||
|
}
|
||||||
|
}
|
||||||
|
rv.p.bulletproofs.clear();
|
||||||
|
if (bulletproof)
|
||||||
|
{
|
||||||
|
std::vector<uint64_t> proof_amounts;
|
||||||
|
size_t amounts_proved = 0;
|
||||||
|
while (amounts_proved < amounts.size())
|
||||||
|
{
|
||||||
|
size_t batch_size = 1;
|
||||||
|
if (rct_config.range_proof_type == RangeProofMultiOutputBulletproof)
|
||||||
|
while (batch_size * 2 + amounts_proved <= amounts.size())
|
||||||
|
batch_size *= 2;
|
||||||
|
rct::keyV C, masks;
|
||||||
|
std::vector<uint64_t> batch_amounts(batch_size);
|
||||||
|
for (i = 0; i < batch_size; ++i)
|
||||||
|
batch_amounts[i] = amounts[i + amounts_proved];
|
||||||
|
rv.p.bulletproofs.push_back(proveRangeBulletproof_old(C, masks, batch_amounts));
|
||||||
|
#ifdef DBG
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(verBulletproof_old(rv.p.bulletproofs.back()), "verBulletproof failed on newly created proof");
|
||||||
|
#endif
|
||||||
|
for (i = 0; i < batch_size; ++i)
|
||||||
|
{
|
||||||
|
rv.outPk[i + amounts_proved].mask = C[i];
|
||||||
|
outSk[i + amounts_proved].mask = masks[i];
|
||||||
|
}
|
||||||
|
amounts_proved += batch_size;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < outSk.size(); ++i)
|
||||||
|
{
|
||||||
//mask amount and mask
|
//mask amount and mask
|
||||||
rv.ecdhInfo[i].mask = copy(outSk[i].mask);
|
rv.ecdhInfo[i].mask = copy(outSk[i].mask);
|
||||||
rv.ecdhInfo[i].amount = d2h(amounts[i]);
|
rv.ecdhInfo[i].amount = d2h(amounts[i]);
|
||||||
|
@ -1249,6 +1318,104 @@ namespace rct {
|
||||||
return genRctSimple(message, inSk, destinations, inamounts, outamounts, txnFee, mixRing, amount_keys, kLRki, msout, index, outSk, rct_config, hwdev);
|
return genRctSimple(message, inSk, destinations, inamounts, outamounts, txnFee, mixRing, amount_keys, kLRki, msout, index, outSk, rct_config, hwdev);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
//RCT simple
|
||||||
|
//for post-rct only
|
||||||
|
rctSig genRctSimple_old(const key &message, const ctkeyV & inSk, const keyV & destinations, const vector<xmr_amount> &inamounts, const vector<xmr_amount> &outamounts, xmr_amount txnFee, const ctkeyM & mixRing, const keyV &amount_keys, const std::vector<multisig_kLRki> *kLRki, multisig_out *msout, const std::vector<unsigned int> & index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev) {
|
||||||
|
const bool bulletproof = rct_config.range_proof_type != RangeProofBorromean;
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(inamounts.size() > 0, "Empty inamounts");
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(inamounts.size() == inSk.size(), "Different number of inamounts/inSk");
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(outamounts.size() == destinations.size(), "Different number of amounts/destinations");
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(amount_keys.size() == destinations.size(), "Different number of amount_keys/destinations");
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(index.size() == inSk.size(), "Different number of index/inSk");
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(mixRing.size() == inSk.size(), "Different number of mixRing/inSk");
|
||||||
|
for (size_t n = 0; n < mixRing.size(); ++n) {
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(index[n] < mixRing[n].size(), "Bad index into mixRing");
|
||||||
|
}
|
||||||
|
CHECK_AND_ASSERT_THROW_MES((kLRki && msout) || (!kLRki && !msout), "Only one of kLRki/msout is present");
|
||||||
|
if (kLRki && msout) {
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(kLRki->size() == inamounts.size(), "Mismatched kLRki/inamounts sizes");
|
||||||
|
}
|
||||||
|
|
||||||
|
rctSig rv;
|
||||||
|
rv.type = bulletproof ? RCTTypeSimpleBulletproof : RCTTypeSimple;
|
||||||
|
rv.message = message;
|
||||||
|
rv.outPk.resize(destinations.size());
|
||||||
|
if (bulletproof)
|
||||||
|
rv.p.bulletproofs.resize(destinations.size());
|
||||||
|
else
|
||||||
|
rv.p.rangeSigs.resize(destinations.size());
|
||||||
|
rv.ecdhInfo.resize(destinations.size());
|
||||||
|
|
||||||
|
size_t i;
|
||||||
|
keyV masks(destinations.size()); //sk mask..
|
||||||
|
outSk.resize(destinations.size());
|
||||||
|
key sumout = zero();
|
||||||
|
for (i = 0; i < destinations.size(); i++) {
|
||||||
|
|
||||||
|
//add destination to sig
|
||||||
|
rv.outPk[i].dest = copy(destinations[i]);
|
||||||
|
//compute range proof
|
||||||
|
if (bulletproof)
|
||||||
|
rv.p.bulletproofs[i] = proveRangeBulletproof_old(rv.outPk[i].mask, outSk[i].mask, outamounts[i]);
|
||||||
|
else
|
||||||
|
rv.p.rangeSigs[i] = proveRange(rv.outPk[i].mask, outSk[i].mask, outamounts[i]);
|
||||||
|
#ifdef DBG
|
||||||
|
if (bulletproof)
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(verBulletproof_old(rv.p.bulletproofs[i]), "verBulletproof failed on newly created proof");
|
||||||
|
else
|
||||||
|
CHECK_AND_ASSERT_THROW_MES(verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]), "verRange failed on newly created proof");
|
||||||
|
#endif
|
||||||
|
|
||||||
|
sc_add(sumout.bytes, outSk[i].mask.bytes, sumout.bytes);
|
||||||
|
|
||||||
|
//mask amount and mask
|
||||||
|
rv.ecdhInfo[i].mask = copy(outSk[i].mask);
|
||||||
|
rv.ecdhInfo[i].amount = d2h(outamounts[i]);
|
||||||
|
hwdev.ecdhEncode(rv.ecdhInfo[i], amount_keys[i], rv.type == RCTTypeSimpleBulletproof);
|
||||||
|
}
|
||||||
|
|
||||||
|
//set txn fee
|
||||||
|
rv.txnFee = txnFee;
|
||||||
|
// TODO: unused ??
|
||||||
|
// key txnFeeKey = scalarmultH(d2h(rv.txnFee));
|
||||||
|
rv.mixRing = mixRing;
|
||||||
|
keyV &pseudoOuts = bulletproof ? rv.p.pseudoOuts : rv.pseudoOuts;
|
||||||
|
pseudoOuts.resize(inamounts.size());
|
||||||
|
rv.p.MGs.resize(inamounts.size());
|
||||||
|
key sumpouts = zero(); //sum pseudoOut masks
|
||||||
|
keyV a(inamounts.size());
|
||||||
|
for (i = 0 ; i < inamounts.size() - 1; i++) {
|
||||||
|
skGen(a[i]);
|
||||||
|
sc_add(sumpouts.bytes, a[i].bytes, sumpouts.bytes);
|
||||||
|
genC(pseudoOuts[i], a[i], inamounts[i]);
|
||||||
|
}
|
||||||
|
rv.mixRing = mixRing;
|
||||||
|
sc_sub(a[i].bytes, sumout.bytes, sumpouts.bytes);
|
||||||
|
genC(pseudoOuts[i], a[i], inamounts[i]);
|
||||||
|
DP(pseudoOuts[i]);
|
||||||
|
|
||||||
|
key full_message = get_pre_mlsag_hash(rv,hwdev);
|
||||||
|
if (msout)
|
||||||
|
msout->c.resize(inamounts.size());
|
||||||
|
for (i = 0 ; i < inamounts.size(); i++) {
|
||||||
|
rv.p.MGs[i] = proveRctMGSimple(full_message, rv.mixRing[i], inSk[i], a[i], pseudoOuts[i], kLRki ? &(*kLRki)[i]: NULL, msout ? &msout->c[i] : NULL, index[i], hwdev);
|
||||||
|
}
|
||||||
|
return rv;
|
||||||
|
}
|
||||||
|
|
||||||
|
rctSig genRctSimple_old(const key &message, const ctkeyV & inSk, const ctkeyV & inPk, const keyV & destinations, const vector<xmr_amount> &inamounts, const vector<xmr_amount> &outamounts, const keyV &amount_keys, const std::vector<multisig_kLRki> *kLRki, multisig_out *msout, xmr_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev) {
|
||||||
|
std::vector<unsigned int> index;
|
||||||
|
index.resize(inPk.size());
|
||||||
|
ctkeyM mixRing;
|
||||||
|
ctkeyV outSk;
|
||||||
|
mixRing.resize(inPk.size());
|
||||||
|
for (size_t i = 0; i < inPk.size(); ++i) {
|
||||||
|
mixRing[i].resize(mixin+1);
|
||||||
|
index[i] = populateFromBlockchainSimple(mixRing[i], inPk[i], mixin);
|
||||||
|
}
|
||||||
|
return genRctSimple_old(message, inSk, destinations, inamounts, outamounts, txnFee, mixRing, amount_keys, kLRki, msout, index, outSk, rct_config, hwdev);
|
||||||
|
}
|
||||||
|
|
||||||
//RingCT protocol
|
//RingCT protocol
|
||||||
//genRct:
|
//genRct:
|
||||||
// creates an rctSig with all data necessary to verify the rangeProofs and that the signer owns one of the
|
// creates an rctSig with all data necessary to verify the rangeProofs and that the signer owns one of the
|
||||||
|
@ -1261,10 +1428,13 @@ namespace rct {
|
||||||
// must know the destination private key to find the correct amount, else will return a random number
|
// must know the destination private key to find the correct amount, else will return a random number
|
||||||
bool verRct(const rctSig & rv, bool semantics) {
|
bool verRct(const rctSig & rv, bool semantics) {
|
||||||
PERF_TIMER(verRct);
|
PERF_TIMER(verRct);
|
||||||
CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull, false, "verRct called on non-full rctSig");
|
const bool bulletproof = is_rct_bulletproof(rv.type);
|
||||||
|
CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull || rv.type == RCTTypeFullBulletproof, false, "verRct called on non-full rctSig");
|
||||||
if (semantics)
|
if (semantics)
|
||||||
{
|
{
|
||||||
|
if (rv.type == RCTTypeBulletproof)
|
||||||
CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.p.rangeSigs.size(), false, "Mismatched sizes of outPk and rv.p.rangeSigs");
|
CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.p.rangeSigs.size(), false, "Mismatched sizes of outPk and rv.p.rangeSigs");
|
||||||
|
else
|
||||||
CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.ecdhInfo.size(), false, "Mismatched sizes of outPk and rv.ecdhInfo");
|
CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.ecdhInfo.size(), false, "Mismatched sizes of outPk and rv.ecdhInfo");
|
||||||
CHECK_AND_ASSERT_MES(rv.p.MGs.size() == 1, false, "full rctSig has not one MG");
|
CHECK_AND_ASSERT_MES(rv.p.MGs.size() == 1, false, "full rctSig has not one MG");
|
||||||
}
|
}
|
||||||
|
@ -1279,10 +1449,23 @@ namespace rct {
|
||||||
if (semantics) {
|
if (semantics) {
|
||||||
tools::threadpool& tpool = tools::threadpool::getInstance();
|
tools::threadpool& tpool = tools::threadpool::getInstance();
|
||||||
tools::threadpool::waiter waiter(tpool);
|
tools::threadpool::waiter waiter(tpool);
|
||||||
std::deque<bool> results(rv.outPk.size(), false);
|
std::deque<bool> results(bulletproof ? rv.p.bulletproofs.size() : rv.outPk.size(), false);
|
||||||
DP("range proofs verified?");
|
DP("range proofs verified?");
|
||||||
|
if (rct::is_rct_new_bulletproof(rv.type))
|
||||||
|
{
|
||||||
|
for (size_t i = 0; i < rv.p.bulletproofs.size(); i++)
|
||||||
|
tpool.submit(&waiter, [&, i] { results[i] = verBulletproof(rv.p.bulletproofs[i]); });
|
||||||
|
}
|
||||||
|
else if (bulletproof)
|
||||||
|
{
|
||||||
|
for (size_t i = 0; i < rv.p.bulletproofs.size(); i++)
|
||||||
|
tpool.submit(&waiter, [&, i] { results[i] = verBulletproof_old(rv.p.bulletproofs[i]); });
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
for (size_t i = 0; i < rv.outPk.size(); i++)
|
for (size_t i = 0; i < rv.outPk.size(); i++)
|
||||||
tpool.submit(&waiter, [&, i] { results[i] = verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]); });
|
tpool.submit(&waiter, [&, i] { results[i] = verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]); });
|
||||||
|
}
|
||||||
if (!waiter.wait())
|
if (!waiter.wait())
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
|
@ -1337,7 +1520,7 @@ namespace rct {
|
||||||
{
|
{
|
||||||
CHECK_AND_ASSERT_MES(rvp, false, "rctSig pointer is NULL");
|
CHECK_AND_ASSERT_MES(rvp, false, "rctSig pointer is NULL");
|
||||||
const rctSig &rv = *rvp;
|
const rctSig &rv = *rvp;
|
||||||
CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeCLSAG,
|
CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeSimpleBulletproof || rv.type == RCTTypeCLSAG,
|
||||||
false, "verRctSemanticsSimple called on non simple rctSig");
|
false, "verRctSemanticsSimple called on non simple rctSig");
|
||||||
const bool bulletproof = is_rct_bulletproof(rv.type);
|
const bool bulletproof = is_rct_bulletproof(rv.type);
|
||||||
if (bulletproof)
|
if (bulletproof)
|
||||||
|
@ -1405,12 +1588,23 @@ namespace rct {
|
||||||
offset += rv.p.rangeSigs.size();
|
offset += rv.p.rangeSigs.size();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
for (const rctSig *rvp: rvv)
|
||||||
|
{
|
||||||
|
const rctSig &rv = *rvp;
|
||||||
|
if (!rct::is_rct_new_bulletproof(rv.type)){
|
||||||
|
if (!proofs.empty() && !verBulletproof_old(proofs))
|
||||||
|
{
|
||||||
|
LOG_PRINT_L1("Aggregate range proof verified failed");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
if (!proofs.empty() && !verBulletproof(proofs))
|
if (!proofs.empty() && !verBulletproof(proofs))
|
||||||
{
|
{
|
||||||
LOG_PRINT_L1("Aggregate range proof verified failed");
|
LOG_PRINT_L1("Aggregate range proof verified failed");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
if (!waiter.wait())
|
if (!waiter.wait())
|
||||||
return false;
|
return false;
|
||||||
for (size_t i = 0; i < results.size(); ++i) {
|
for (size_t i = 0; i < results.size(); ++i) {
|
||||||
|
@ -1447,7 +1641,7 @@ namespace rct {
|
||||||
{
|
{
|
||||||
PERF_TIMER(verRctNonSemanticsSimple);
|
PERF_TIMER(verRctNonSemanticsSimple);
|
||||||
|
|
||||||
CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeCLSAG,
|
CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeSimpleBulletproof || rv.type == RCTTypeCLSAG,
|
||||||
false, "verRctNonSemanticsSimple called on non simple rctSig");
|
false, "verRctNonSemanticsSimple called on non simple rctSig");
|
||||||
const bool bulletproof = is_rct_bulletproof(rv.type);
|
const bool bulletproof = is_rct_bulletproof(rv.type);
|
||||||
// semantics check is early, and mixRing/MGs aren't resolved yet
|
// semantics check is early, and mixRing/MGs aren't resolved yet
|
||||||
|
@ -1514,7 +1708,7 @@ namespace rct {
|
||||||
// uses the attached ecdh info to find the amounts represented by each output commitment
|
// uses the attached ecdh info to find the amounts represented by each output commitment
|
||||||
// must know the destination private key to find the correct amount, else will return a random number
|
// must know the destination private key to find the correct amount, else will return a random number
|
||||||
xmr_amount decodeRct(const rctSig & rv, const key & sk, unsigned int i, key & mask, hw::device &hwdev) {
|
xmr_amount decodeRct(const rctSig & rv, const key & sk, unsigned int i, key & mask, hw::device &hwdev) {
|
||||||
CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull, false, "decodeRct called on non-full rctSig");
|
CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull || rv.type == RCTTypeFullBulletproof, false, "decodeRct called on non-full rctSig");
|
||||||
CHECK_AND_ASSERT_THROW_MES(i < rv.ecdhInfo.size(), "Bad index");
|
CHECK_AND_ASSERT_THROW_MES(i < rv.ecdhInfo.size(), "Bad index");
|
||||||
CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.ecdhInfo.size(), "Mismatched sizes of rv.outPk and rv.ecdhInfo");
|
CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.ecdhInfo.size(), "Mismatched sizes of rv.outPk and rv.ecdhInfo");
|
||||||
|
|
||||||
|
@ -1544,7 +1738,7 @@ namespace rct {
|
||||||
}
|
}
|
||||||
|
|
||||||
xmr_amount decodeRctSimple(const rctSig & rv, const key & sk, unsigned int i, key &mask, hw::device &hwdev) {
|
xmr_amount decodeRctSimple(const rctSig & rv, const key & sk, unsigned int i, key &mask, hw::device &hwdev) {
|
||||||
CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeCLSAG, false, "decodeRct called on non simple rctSig");
|
CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeSimpleBulletproof || rv.type == RCTTypeCLSAG, false, "decodeRct called on non simple rctSig");
|
||||||
CHECK_AND_ASSERT_THROW_MES(i < rv.ecdhInfo.size(), "Bad index");
|
CHECK_AND_ASSERT_THROW_MES(i < rv.ecdhInfo.size(), "Bad index");
|
||||||
CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.ecdhInfo.size(), "Mismatched sizes of rv.outPk and rv.ecdhInfo");
|
CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.ecdhInfo.size(), "Mismatched sizes of rv.outPk and rv.ecdhInfo");
|
||||||
|
|
||||||
|
@ -1574,13 +1768,13 @@ namespace rct {
|
||||||
}
|
}
|
||||||
|
|
||||||
bool signMultisigMLSAG(rctSig &rv, const std::vector<unsigned int> &indices, const keyV &k, const multisig_out &msout, const key &secret_key) {
|
bool signMultisigMLSAG(rctSig &rv, const std::vector<unsigned int> &indices, const keyV &k, const multisig_out &msout, const key &secret_key) {
|
||||||
CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull || rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2,
|
CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull || rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeFullBulletproof || rv.type == RCTTypeSimpleBulletproof,
|
||||||
false, "unsupported rct type");
|
false, "unsupported rct type");
|
||||||
CHECK_AND_ASSERT_MES(indices.size() == k.size(), false, "Mismatched k/indices sizes");
|
CHECK_AND_ASSERT_MES(indices.size() == k.size(), false, "Mismatched k/indices sizes");
|
||||||
CHECK_AND_ASSERT_MES(k.size() == rv.p.MGs.size(), false, "Mismatched k/MGs size");
|
CHECK_AND_ASSERT_MES(k.size() == rv.p.MGs.size(), false, "Mismatched k/MGs size");
|
||||||
CHECK_AND_ASSERT_MES(k.size() == msout.c.size(), false, "Mismatched k/msout.c size");
|
CHECK_AND_ASSERT_MES(k.size() == msout.c.size(), false, "Mismatched k/msout.c size");
|
||||||
CHECK_AND_ASSERT_MES(rv.p.CLSAGs.empty(), false, "CLSAGs not empty for MLSAGs");
|
CHECK_AND_ASSERT_MES(rv.p.CLSAGs.empty(), false, "CLSAGs not empty for MLSAGs");
|
||||||
if (rv.type == RCTTypeFull)
|
if (rv.type == RCTTypeFull || rv.type == RCTTypeFullBulletproof)
|
||||||
{
|
{
|
||||||
CHECK_AND_ASSERT_MES(rv.p.MGs.size() == 1, false, "MGs not a single element");
|
CHECK_AND_ASSERT_MES(rv.p.MGs.size() == 1, false, "MGs not a single element");
|
||||||
}
|
}
|
||||||
|
|
|
@ -127,6 +127,8 @@ namespace rct {
|
||||||
rctSig genRct(const key &message, const ctkeyV & inSk, const ctkeyV & inPk, const keyV & destinations, const std::vector<xmr_amount> & amounts, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, const int mixin, const RCTConfig &rct_config, hw::device &hwdev);
|
rctSig genRct(const key &message, const ctkeyV & inSk, const ctkeyV & inPk, const keyV & destinations, const std::vector<xmr_amount> & amounts, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, const int mixin, const RCTConfig &rct_config, hw::device &hwdev);
|
||||||
rctSig genRctSimple(const key & message, const ctkeyV & inSk, const ctkeyV & inPk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, const keyV &amount_keys, const std::vector<multisig_kLRki> *kLRki, multisig_out *msout, xmr_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev);
|
rctSig genRctSimple(const key & message, const ctkeyV & inSk, const ctkeyV & inPk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, const keyV &amount_keys, const std::vector<multisig_kLRki> *kLRki, multisig_out *msout, xmr_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev);
|
||||||
rctSig genRctSimple(const key & message, const ctkeyV & inSk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, xmr_amount txnFee, const ctkeyM & mixRing, const keyV &amount_keys, const std::vector<multisig_kLRki> *kLRki, multisig_out *msout, const std::vector<unsigned int> & index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev);
|
rctSig genRctSimple(const key & message, const ctkeyV & inSk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, xmr_amount txnFee, const ctkeyM & mixRing, const keyV &amount_keys, const std::vector<multisig_kLRki> *kLRki, multisig_out *msout, const std::vector<unsigned int> & index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev);
|
||||||
|
rctSig genRctSimple_old(const key & message, const ctkeyV & inSk, const ctkeyV & inPk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, const keyV &amount_keys, const std::vector<multisig_kLRki> *kLRki, multisig_out *msout, xmr_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev);
|
||||||
|
rctSig genRctSimple_old(const key & message, const ctkeyV & inSk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, xmr_amount txnFee, const ctkeyM & mixRing, const keyV &amount_keys, const std::vector<multisig_kLRki> *kLRki, multisig_out *msout, const std::vector<unsigned int> & index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev);
|
||||||
bool verRct(const rctSig & rv, bool semantics);
|
bool verRct(const rctSig & rv, bool semantics);
|
||||||
static inline bool verRct(const rctSig & rv) { return verRct(rv, true) && verRct(rv, false); }
|
static inline bool verRct(const rctSig & rv) { return verRct(rv, true) && verRct(rv, false); }
|
||||||
bool verRctSemanticsSimple(const rctSig & rv);
|
bool verRctSemanticsSimple(const rctSig & rv);
|
||||||
|
|
|
@ -193,6 +193,7 @@ namespace rct {
|
||||||
switch (type)
|
switch (type)
|
||||||
{
|
{
|
||||||
case RCTTypeSimple:
|
case RCTTypeSimple:
|
||||||
|
case RCTTypeSimpleBulletproof:
|
||||||
case RCTTypeBulletproof:
|
case RCTTypeBulletproof:
|
||||||
case RCTTypeBulletproof2:
|
case RCTTypeBulletproof2:
|
||||||
case RCTTypeCLSAG:
|
case RCTTypeCLSAG:
|
||||||
|
@ -206,6 +207,8 @@ namespace rct {
|
||||||
{
|
{
|
||||||
switch (type)
|
switch (type)
|
||||||
{
|
{
|
||||||
|
case RCTTypeSimpleBulletproof:
|
||||||
|
case RCTTypeFullBulletproof:
|
||||||
case RCTTypeBulletproof:
|
case RCTTypeBulletproof:
|
||||||
case RCTTypeBulletproof2:
|
case RCTTypeBulletproof2:
|
||||||
case RCTTypeCLSAG:
|
case RCTTypeCLSAG:
|
||||||
|
@ -215,6 +218,23 @@ namespace rct {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
bool is_rct_old_bulletproof(int type)
|
||||||
|
{
|
||||||
|
switch (type)
|
||||||
|
{
|
||||||
|
case RCTTypeSimpleBulletproof:
|
||||||
|
case RCTTypeFullBulletproof:
|
||||||
|
return true;
|
||||||
|
default:
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool is_rct_new_bulletproof(int type)
|
||||||
|
{
|
||||||
|
return is_rct_bulletproof(type) && !is_rct_old_bulletproof(type);
|
||||||
|
}
|
||||||
|
|
||||||
bool is_rct_borromean(int type)
|
bool is_rct_borromean(int type)
|
||||||
{
|
{
|
||||||
switch (type)
|
switch (type)
|
||||||
|
@ -227,6 +247,25 @@ namespace rct {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
size_t n_bulletproof_v1_amounts(const Bulletproof &proof)
|
||||||
|
{
|
||||||
|
CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
|
||||||
|
CHECK_AND_ASSERT_MES(proof.L.size() <= 31, 0, "Insane bulletproof L size");
|
||||||
|
return 1 << (proof.L.size() - 6);
|
||||||
|
}
|
||||||
|
size_t n_bulletproof_v1_amounts(const std::vector<Bulletproof> &proofs)
|
||||||
|
{
|
||||||
|
size_t n = 0;
|
||||||
|
for (const Bulletproof &proof: proofs)
|
||||||
|
{
|
||||||
|
size_t n2 = n_bulletproof_v1_amounts(proof);
|
||||||
|
CHECK_AND_ASSERT_MES(n2 < std::numeric_limits<uint32_t>::max() - n, 0, "Invalid number of bulletproofs");
|
||||||
|
if (n2 == 0)
|
||||||
|
return 0;
|
||||||
|
n += n2;
|
||||||
|
}
|
||||||
|
return n;
|
||||||
|
}
|
||||||
size_t n_bulletproof_amounts(const Bulletproof &proof)
|
size_t n_bulletproof_amounts(const Bulletproof &proof)
|
||||||
{
|
{
|
||||||
CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
|
CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
|
||||||
|
|
|
@ -239,8 +239,10 @@ namespace rct {
|
||||||
};
|
};
|
||||||
|
|
||||||
size_t n_bulletproof_amounts(const Bulletproof &proof);
|
size_t n_bulletproof_amounts(const Bulletproof &proof);
|
||||||
|
size_t n_bulletproof_v1_amounts(const Bulletproof &proof);
|
||||||
size_t n_bulletproof_max_amounts(const Bulletproof &proof);
|
size_t n_bulletproof_max_amounts(const Bulletproof &proof);
|
||||||
size_t n_bulletproof_amounts(const std::vector<Bulletproof> &proofs);
|
size_t n_bulletproof_amounts(const std::vector<Bulletproof> &proofs);
|
||||||
|
size_t n_bulletproof_v1_amounts(const std::vector<Bulletproof> &proofs);
|
||||||
size_t n_bulletproof_max_amounts(const std::vector<Bulletproof> &proofs);
|
size_t n_bulletproof_max_amounts(const std::vector<Bulletproof> &proofs);
|
||||||
|
|
||||||
//A container to hold all signatures necessary for RingCT
|
//A container to hold all signatures necessary for RingCT
|
||||||
|
@ -254,9 +256,11 @@ namespace rct {
|
||||||
RCTTypeNull = 0,
|
RCTTypeNull = 0,
|
||||||
RCTTypeFull = 1,
|
RCTTypeFull = 1,
|
||||||
RCTTypeSimple = 2,
|
RCTTypeSimple = 2,
|
||||||
RCTTypeBulletproof = 3,
|
RCTTypeFullBulletproof = 3,
|
||||||
RCTTypeBulletproof2 = 4,
|
RCTTypeSimpleBulletproof = 4,
|
||||||
RCTTypeCLSAG = 5,
|
RCTTypeBulletproof = 5,
|
||||||
|
RCTTypeBulletproof2 = 6,
|
||||||
|
RCTTypeCLSAG = 7,
|
||||||
};
|
};
|
||||||
enum RangeProofType { RangeProofBorromean, RangeProofBulletproof, RangeProofMultiOutputBulletproof, RangeProofPaddedBulletproof };
|
enum RangeProofType { RangeProofBorromean, RangeProofBulletproof, RangeProofMultiOutputBulletproof, RangeProofPaddedBulletproof };
|
||||||
struct RCTConfig {
|
struct RCTConfig {
|
||||||
|
@ -285,7 +289,7 @@ namespace rct {
|
||||||
FIELD(type)
|
FIELD(type)
|
||||||
if (type == RCTTypeNull)
|
if (type == RCTTypeNull)
|
||||||
return ar.stream().good();
|
return ar.stream().good();
|
||||||
if (type != RCTTypeFull && type != RCTTypeSimple && type != RCTTypeBulletproof && type != RCTTypeBulletproof2 && type != RCTTypeCLSAG)
|
if (type != RCTTypeFull && type != RCTTypeSimple && type != RCTTypeBulletproof && type != RCTTypeBulletproof2 && type != RCTTypeFullBulletproof && type != RCTTypeSimpleBulletproof && type != RCTTypeCLSAG)
|
||||||
return false;
|
return false;
|
||||||
VARINT_FIELD(txnFee)
|
VARINT_FIELD(txnFee)
|
||||||
// inputs/outputs not saved, only here for serialization help
|
// inputs/outputs not saved, only here for serialization help
|
||||||
|
@ -376,9 +380,24 @@ namespace rct {
|
||||||
return false;
|
return false;
|
||||||
if (type == RCTTypeNull)
|
if (type == RCTTypeNull)
|
||||||
return ar.stream().good();
|
return ar.stream().good();
|
||||||
if (type != RCTTypeFull && type != RCTTypeSimple && type != RCTTypeBulletproof && type != RCTTypeBulletproof2 && type != RCTTypeCLSAG)
|
if (type != RCTTypeFull && type != RCTTypeSimple && type != RCTTypeBulletproof && type != RCTTypeBulletproof2 && type != RCTTypeFullBulletproof && type != RCTTypeSimpleBulletproof && type != RCTTypeCLSAG)
|
||||||
return false;
|
return false;
|
||||||
if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG)
|
if (type == RCTTypeSimpleBulletproof || type == RCTTypeFullBulletproof)
|
||||||
|
{
|
||||||
|
ar.tag("bp");
|
||||||
|
ar.begin_array();
|
||||||
|
PREPARE_CUSTOM_VECTOR_SERIALIZATION(outputs, bulletproofs);
|
||||||
|
if (bulletproofs.size() != outputs)
|
||||||
|
return false;
|
||||||
|
for (size_t i = 0; i < outputs; ++i)
|
||||||
|
{
|
||||||
|
FIELDS(bulletproofs[i])
|
||||||
|
if (outputs - i > 1)
|
||||||
|
ar.delimit_array();
|
||||||
|
}
|
||||||
|
ar.end_array();
|
||||||
|
}
|
||||||
|
else if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG)
|
||||||
{
|
{
|
||||||
uint32_t nbp = bulletproofs.size();
|
uint32_t nbp = bulletproofs.size();
|
||||||
if (type == RCTTypeBulletproof2 || type == RCTTypeCLSAG)
|
if (type == RCTTypeBulletproof2 || type == RCTTypeCLSAG)
|
||||||
|
@ -462,7 +481,7 @@ namespace rct {
|
||||||
ar.begin_array();
|
ar.begin_array();
|
||||||
// we keep a byte for size of MGs, because we don't know whether this is
|
// we keep a byte for size of MGs, because we don't know whether this is
|
||||||
// a simple or full rct signature, and it's starting to annoy the hell out of me
|
// a simple or full rct signature, and it's starting to annoy the hell out of me
|
||||||
size_t mg_elements = (type == RCTTypeSimple || type == RCTTypeBulletproof || type == RCTTypeBulletproof2) ? inputs : 1;
|
size_t mg_elements = (type == RCTTypeSimple || type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeSimpleBulletproof) ? inputs : 1;
|
||||||
PREPARE_CUSTOM_VECTOR_SERIALIZATION(mg_elements, MGs);
|
PREPARE_CUSTOM_VECTOR_SERIALIZATION(mg_elements, MGs);
|
||||||
if (MGs.size() != mg_elements)
|
if (MGs.size() != mg_elements)
|
||||||
return false;
|
return false;
|
||||||
|
@ -480,7 +499,7 @@ namespace rct {
|
||||||
for (size_t j = 0; j < mixin + 1; ++j)
|
for (size_t j = 0; j < mixin + 1; ++j)
|
||||||
{
|
{
|
||||||
ar.begin_array();
|
ar.begin_array();
|
||||||
size_t mg_ss2_elements = ((type == RCTTypeSimple || type == RCTTypeBulletproof || type == RCTTypeBulletproof2) ? 1 : inputs) + 1;
|
size_t mg_ss2_elements = ((type == RCTTypeSimple || type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeSimpleBulletproof) ? 1 : inputs) + 1;
|
||||||
PREPARE_CUSTOM_VECTOR_SERIALIZATION(mg_ss2_elements, MGs[i].ss[j]);
|
PREPARE_CUSTOM_VECTOR_SERIALIZATION(mg_ss2_elements, MGs[i].ss[j]);
|
||||||
if (MGs[i].ss[j].size() != mg_ss2_elements)
|
if (MGs[i].ss[j].size() != mg_ss2_elements)
|
||||||
return false;
|
return false;
|
||||||
|
@ -507,7 +526,7 @@ namespace rct {
|
||||||
}
|
}
|
||||||
ar.end_array();
|
ar.end_array();
|
||||||
}
|
}
|
||||||
if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG)
|
if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeSimpleBulletproof || type == RCTTypeCLSAG)
|
||||||
{
|
{
|
||||||
ar.tag("pseudoOuts");
|
ar.tag("pseudoOuts");
|
||||||
ar.begin_array();
|
ar.begin_array();
|
||||||
|
@ -538,12 +557,16 @@ namespace rct {
|
||||||
|
|
||||||
keyV& get_pseudo_outs()
|
keyV& get_pseudo_outs()
|
||||||
{
|
{
|
||||||
|
if (type == RCTTypeBulletproof)
|
||||||
return type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG ? p.pseudoOuts : pseudoOuts;
|
return type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG ? p.pseudoOuts : pseudoOuts;
|
||||||
|
return type == RCTTypeSimpleBulletproof ? p.pseudoOuts : pseudoOuts;
|
||||||
}
|
}
|
||||||
|
|
||||||
keyV const& get_pseudo_outs() const
|
keyV const& get_pseudo_outs() const
|
||||||
{
|
{
|
||||||
|
if (type == RCTTypeBulletproof)
|
||||||
return type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG ? p.pseudoOuts : pseudoOuts;
|
return type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG ? p.pseudoOuts : pseudoOuts;
|
||||||
|
return type == RCTTypeSimpleBulletproof ? p.pseudoOuts : pseudoOuts;
|
||||||
}
|
}
|
||||||
|
|
||||||
BEGIN_SERIALIZE_OBJECT()
|
BEGIN_SERIALIZE_OBJECT()
|
||||||
|
@ -655,6 +678,8 @@ namespace rct {
|
||||||
|
|
||||||
bool is_rct_simple(int type);
|
bool is_rct_simple(int type);
|
||||||
bool is_rct_bulletproof(int type);
|
bool is_rct_bulletproof(int type);
|
||||||
|
bool is_rct_old_bulletproof(int type);
|
||||||
|
bool is_rct_new_bulletproof(int type);
|
||||||
bool is_rct_borromean(int type);
|
bool is_rct_borromean(int type);
|
||||||
|
|
||||||
static inline const rct::key &pk2rct(const crypto::public_key &pk) { return (const rct::key&)pk; }
|
static inline const rct::key &pk2rct(const crypto::public_key &pk) { return (const rct::key&)pk; }
|
||||||
|
|
|
@ -898,7 +898,7 @@ uint64_t estimate_tx_weight(bool use_rct, int n_inputs, int mixin, int n_outputs
|
||||||
|
|
||||||
uint8_t get_bulletproof_fork()
|
uint8_t get_bulletproof_fork()
|
||||||
{
|
{
|
||||||
return 8;
|
return 11;
|
||||||
}
|
}
|
||||||
|
|
||||||
uint8_t get_clsag_fork()
|
uint8_t get_clsag_fork()
|
||||||
|
@ -1812,11 +1812,13 @@ static uint64_t decodeRct(const rct::rctSig & rv, const crypto::key_derivation &
|
||||||
switch (rv.type)
|
switch (rv.type)
|
||||||
{
|
{
|
||||||
case rct::RCTTypeSimple:
|
case rct::RCTTypeSimple:
|
||||||
|
case rct::RCTTypeSimpleBulletproof:
|
||||||
case rct::RCTTypeBulletproof:
|
case rct::RCTTypeBulletproof:
|
||||||
case rct::RCTTypeBulletproof2:
|
case rct::RCTTypeBulletproof2:
|
||||||
case rct::RCTTypeCLSAG:
|
case rct::RCTTypeCLSAG:
|
||||||
return rct::decodeRctSimple(rv, rct::sk2rct(scalar1), i, mask, hwdev);
|
return rct::decodeRctSimple(rv, rct::sk2rct(scalar1), i, mask, hwdev);
|
||||||
case rct::RCTTypeFull:
|
case rct::RCTTypeFull:
|
||||||
|
case rct::RCTTypeFullBulletproof:
|
||||||
return rct::decodeRct(rv, rct::sk2rct(scalar1), i, mask, hwdev);
|
return rct::decodeRct(rv, rct::sk2rct(scalar1), i, mask, hwdev);
|
||||||
default:
|
default:
|
||||||
LOG_ERROR("Unsupported rct type: " << rv.type);
|
LOG_ERROR("Unsupported rct type: " << rv.type);
|
||||||
|
|
Loading…
Reference in a new issue