Charon/blockchain
1
0
Fork 0
forked from lthn/blockchain
Code Pull requests Activity

chaingen: pos_block_builder: WIP

Browse source
This commit is contained in:
sowle 2022-11-03 01:25:44 +01:00
parent ca4c9d4bad
commit fe0042df6a
No known key found for this signature in database
GPG key ID: C07A24B2D89D49FC
7 changed files with 26 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
src/currency_core/currency_format_utils.cpp
View file

@ -2487,18 +2487,18 @@ namespace currency
return res;
}
//---------------------------------------------------------------
bool is_out_to_acc(const account_keys& acc, const txout_to_key& out_key, const crypto::key_derivation& derivation, size_t output_index)
bool is_out_to_acc(const account_public_address& addr, const txout_to_key& out_key, const crypto::key_derivation& derivation, size_t output_index)
{
crypto::public_key pk;
if (!derive_public_key(derivation, output_index, acc.account_address.spend_public_key, pk))
if (!derive_public_key(derivation, output_index, addr.spend_public_key, pk))
return false;
return pk == out_key.key;
}
//---------------------------------------------------------------
bool is_out_to_acc(const account_keys& acc, const txout_multisig& out_multisig, const crypto::key_derivation& derivation, size_t output_index)
bool is_out_to_acc(const account_public_address& addr, const txout_multisig& out_multisig, const crypto::key_derivation& derivation, size_t output_index)
{
crypto::public_key pk;
if (!derive_public_key(derivation, output_index, acc.account_address.spend_public_key, pk))
if (!derive_public_key(derivation, output_index, addr.spend_public_key, pk))
return false;
auto it = std::find(out_multisig.keys.begin(), out_multisig.keys.end(), pk);
if (out_multisig.keys.end() == it)
@ -2506,16 +2506,16 @@ namespace currency
return true;
}
bool is_out_to_acc(const account_keys& acc, const tx_out_zarcanum& zo, const crypto::key_derivation& derivation, size_t output_index, uint64_t& decoded_amount, crypto::scalar_t& blinding_mask)
bool is_out_to_acc(const account_public_address& addr, const tx_out_zarcanum& zo, const crypto::key_derivation& derivation, size_t output_index, uint64_t& decoded_amount, crypto::scalar_t& blinding_mask)
{
crypto::scalar_t h; // = crypto::hash_helper_t::hs(reinterpret_cast<const crypto::public_key&>(derivation), output_index); // h = Hs(8 * r * V, i)
crypto::derivation_to_scalar(derivation, output_index, h.as_secret_key()); // h = Hs(8 * r * V, i)
crypto::point_t P_prime = h * crypto::c_point_G + crypto::point_t(acc.account_address.spend_public_key); // P =? Hs(8rV, i) * G + S
crypto::point_t P_prime = h * crypto::c_point_G + crypto::point_t(addr.spend_public_key); // P =? Hs(8rV, i) * G + S
if (P_prime.to_public_key() != zo.stealth_address)
return false;
crypto::point_t Q_prime = crypto::hash_helper_t::hs(CRYPTO_HDS_OUT_CONCEALING_POINT, h) * 8 * crypto::point_t(acc.account_address.view_public_key); // Q' * 8 =? Hs(domain_sep, Hs(8 * r * V, i) ) * 8 * V
crypto::point_t Q_prime = crypto::hash_helper_t::hs(CRYPTO_HDS_OUT_CONCEALING_POINT, h) * 8 * crypto::point_t(addr.view_public_key); // Q' * 8 =? Hs(domain_sep, Hs(8 * r * V, i) ) * 8 * V
if (Q_prime != crypto::point_t(zo.concealing_point).modify_mul8())
return false;
@ -2579,7 +2579,7 @@ namespace currency
const tx_out_bare& o = boost::get<tx_out_bare>(ov);
CHECK_AND_ASSERT_MES(o.target.type() == typeid(txout_to_key), false, "condition failed: o.target.type() == typeid(txout_to_key)");
if (is_out_to_acc(acc, boost::get<txout_to_key>(o.target), derivation, offset))
if (is_out_to_acc(acc.account_address, boost::get<txout_to_key>(o.target), derivation, offset))
{
outs.emplace_back(offset, o.amount);
money_transfered += o.amount;
@ -2616,25 +2616,25 @@ namespace currency
{
VARIANT_SWITCH_BEGIN(o.target);
VARIANT_CASE_CONST(txout_to_key, t)
if (is_out_to_acc(acc, t, derivation, output_index))
if (is_out_to_acc(acc.account_address, t, derivation, output_index))
{
outs.emplace_back(output_index, o.amount);
money_transfered += o.amount;
}
VARIANT_CASE_CONST(txout_multisig, t)
if (is_out_to_acc(acc, t, derivation, output_index))
if (is_out_to_acc(acc.account_address, t, derivation, output_index))
{
outs.emplace_back(output_index, o.amount); // TODO: @#@# consider this
//don't cout this money
}
VARIANT_CASE_CONST(txout_htlc, htlc)
htlc_info hi = AUTO_VAL_INIT(hi);
if (is_out_to_acc(acc, htlc.pkey_redeem, derivation, output_index))
if (is_out_to_acc(acc.account_address, htlc.pkey_redeem, derivation, output_index))
{
hi.hltc_our_out_is_before_expiration = true;
htlc_info_list.push_back(hi);
}
else if (is_out_to_acc(acc, htlc.pkey_refund, derivation, output_index))
else if (is_out_to_acc(acc.account_address, htlc.pkey_refund, derivation, output_index))
{
hi.hltc_our_out_is_before_expiration = false;
htlc_info_list.push_back(hi);
@ -2648,7 +2648,7 @@ namespace currency
VARIANT_CASE_CONST(tx_out_zarcanum, zo)
uint64_t amount = 0;
crypto::scalar_t blinding_mask = 0;
if (is_out_to_acc(acc, zo, derivation, output_index, amount, blinding_mask))
if (is_out_to_acc(acc.account_address, zo, derivation, output_index, amount, blinding_mask))
{
outs.emplace_back(output_index, amount, blinding_mask);
open_asset_id v = AUTO_VAL_INIT(v);

6
src/currency_core/currency_format_utils.h
View file

@ -307,9 +307,9 @@ namespace currency
bool add_tx_extra_userdata(transaction& tx, const blobdata& extra_nonce);
crypto::hash get_multisig_out_id(const transaction& tx, size_t n);
bool is_out_to_acc(const account_keys& acc, const txout_to_key& out_key, const crypto::key_derivation& derivation, size_t output_index);
bool is_out_to_acc(const account_keys& acc, const txout_multisig& out_multisig, const crypto::key_derivation& derivation, size_t output_index);
bool is_out_to_acc(const account_keys& acc, const tx_out_zarcanum& zo, const crypto::key_derivation& derivation, size_t output_index, uint64_t& decoded_amount, crypto::scalar_t& blinding_mask);
bool is_out_to_acc(const account_public_address& addr, const txout_to_key& out_key, const crypto::key_derivation& derivation, size_t output_index);
bool is_out_to_acc(const account_public_address& addr, const txout_multisig& out_multisig, const crypto::key_derivation& derivation, size_t output_index);
bool is_out_to_acc(const account_public_address& addr, const tx_out_zarcanum& zo, const crypto::key_derivation& derivation, size_t output_index, uint64_t& decoded_amount, crypto::scalar_t& blinding_mask);
bool lookup_acc_outs(const account_keys& acc, const transaction& tx, const crypto::public_key& tx_pub_key, std::vector<wallet_out_info>& outs, uint64_t& money_transfered, crypto::key_derivation& derivation);
bool lookup_acc_outs(const account_keys& acc, const transaction& tx, const crypto::public_key& tx_pub_key, std::vector<wallet_out_info>& outs, uint64_t& money_transfered, crypto::key_derivation& derivation, std::list<htlc_info>& htlc_info_list);
bool lookup_acc_outs(const account_keys& acc, const transaction& tx, std::vector<wallet_out_info>& outs, uint64_t& money_transfered, crypto::key_derivation& derivation);

4
tests/core_tests/chaingen.cpp
View file

@ -1026,7 +1026,7 @@ bool init_output_indices(map_output_idx_t& outs, map_output_t& outs_mine, const
oi.idx = out_global_idx;
outs_vec.emplace_back(std::move(oi));
// Is out to me?
if (is_out_to_acc(acc_keys, boost::get<txout_to_key>(out.target), derivation, j))
if (is_out_to_acc(acc_keys.account_address, boost::get<txout_to_key>(out.target), derivation, j))
outs_mine[out.amount].push_back(out_global_idx);
}
VARIANT_CASE_CONST(tx_out_zarcanum, out)
@ -1040,7 +1040,7 @@ bool init_output_indices(map_output_idx_t& outs, map_output_t& outs_mine, const
uint64_t decoded_amount = 0;
crypto::scalar_t decoded_blinding_mask{};
if (is_out_to_acc(acc_keys, out, derivation, j, decoded_amount, decoded_blinding_mask))
if (is_out_to_acc(acc_keys.account_address, out, derivation, j, decoded_amount, decoded_blinding_mask))
{
outs_vec.back().amount = decoded_amount;
outs_vec.back().blinding_mask = decoded_blinding_mask;

2
tests/core_tests/multisig_wallet_tests.cpp
View file

@ -1373,7 +1373,7 @@ bool multisig_and_coinbase::generate(std::vector<test_event_entry>& events) cons
pb.step2_set_txs(std::vector<transaction>());
pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(prev_block), miner_acc.get_public_address(),
blobdata(), CURRENCY_MINER_TX_MAX_OUTS, extra_alias_entry(), tx_key);
blobdata(), CURRENCY_MINER_TX_MAX_OUTS, tx_key);
// The builder creates PoS miner tx with normal outputs.
// Replace all miner_tx outputs with one multisig output and re-sign it.

4
tests/core_tests/pos_block_builder.cpp
View file

@ -146,10 +146,9 @@ void pos_block_builder::step4_generate_coinbase_tx(size_t median_size,
const account_public_address &reward_and_stake_receiver_address,
const blobdata& extra_nonce,
size_t max_outs,
const extra_alias_entry& alias,
keypair tx_one_time_key)
{
step4_generate_coinbase_tx(median_size, already_generated_coins, reward_and_stake_receiver_address, reward_and_stake_receiver_address, extra_nonce, max_outs, alias, tx_one_time_key);
step4_generate_coinbase_tx(median_size, already_generated_coins, reward_and_stake_receiver_address, reward_and_stake_receiver_address, extra_nonce, max_outs, tx_one_time_key);
}
@ -159,7 +158,6 @@ void pos_block_builder::step4_generate_coinbase_tx(size_t median_size,
const account_public_address &stakeholder_address,
const blobdata& extra_nonce,
size_t max_outs,
const extra_alias_entry& alias,
keypair tx_one_time_key)
{
CHECK_AND_ASSERT_THROW_MES(m_step == 3, "pos_block_builder: incorrect step sequence");

2
tests/core_tests/pos_block_builder.h
View file

@ -54,7 +54,6 @@ struct pos_block_builder
const currency::account_public_address &stakeholder_address,
const currency::blobdata& extra_nonce = currency::blobdata(),
size_t max_outs = CURRENCY_MINER_TX_MAX_OUTS,
const currency::extra_alias_entry& alias = currency::extra_alias_entry(),
currency::keypair tx_one_time_key = currency::keypair::generate());
void step4_generate_coinbase_tx(size_t median_size,
@ -62,7 +61,6 @@ struct pos_block_builder
const currency::account_public_address &reward_and_stake_receiver_address,
const currency::blobdata& extra_nonce = currency::blobdata(),
size_t max_outs = CURRENCY_MINER_TX_MAX_OUTS,
const currency::extra_alias_entry& alias = currency::extra_alias_entry(),
currency::keypair tx_one_time_key = currency::keypair::generate());
void step5_sign(const crypto::public_key& stake_tx_pub_key, size_t stake_tx_out_index, const crypto::public_key& stake_tx_out_pub_key, const currency::account_base& stakeholder_account);

12
tests/core_tests/pos_validation.cpp
View file

@ -252,12 +252,12 @@ bool gen_pos_extra_nonce::generate(std::vector<test_event_entry>& events) const
pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, blk_0r.timestamp);
// use biggest possible extra nonce (255 bytes) + largest alias
currency::blobdata extra_none(255, 'x');
currency::extra_alias_entry alias = AUTO_VAL_INIT(alias);
alias.m_alias = std::string(255, 'a');
alias.m_address = miner.get_keys().account_address;
alias.m_text_comment = std::string(255, 'y');
pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(blk_0r), alice.get_public_address(), extra_none, CURRENCY_MINER_TX_MAX_OUTS, alias);
currency::blobdata extra_nonce(255, 'x');
//currency::extra_alias_entry alias = AUTO_VAL_INIT(alias); // TODO: this alias entry was ignored for a long time, now I commented it out, make sure it's okay -- sowle
//alias.m_alias = std::string(255, 'a');
//alias.m_address = miner.get_keys().account_address;
//alias.m_text_comment = std::string(255, 'y');
pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(blk_0r), alice.get_public_address(), extra_nonce, CURRENCY_MINER_TX_MAX_OUTS);
pb.step5_sign(stake_tx_pub_key, stake_output_idx, stake_output_pubkey, miner);
block blk_1 = pb.m_block;