Peerplays_Blockchain/peerplays_migrated
1
0
Fork 0
Code Issues 35 Pull requests 4 Projects Releases 20 Packages Wiki Activity Actions

sign transaction in peeerplays

Browse source
This commit is contained in:
Pavel Baykov 2022-06-09 05:19:14 -03:00
parent 02f40093d0
commit 9334080df5
11 changed files with 490 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
libraries/plugins/peerplays_sidechain/CMakeLists.txt
View file

@ -22,6 +22,8 @@ add_library( peerplays_sidechain
hive/operations.cpp
hive/transaction.cpp
hive/types.cpp
ethereum/transaction.cpp
ethereum/types.cpp
)
if (ENABLE_DEV_FEATURES)

57
libraries/plugins/peerplays_sidechain/ethereum/transaction.cpp Normal file
View file

@ -0,0 +1,57 @@
#include <graphene/peerplays_sidechain/ethereum/transaction.hpp>
#include <boost/algorithm/hex.hpp>
#include <fc/bitutil.hpp>
#include <fc/io/raw.hpp>
namespace graphene { namespace peerplays_sidechain { namespace ethereum {
digest_type transaction::digest() const {
digest_type::encoder enc;
fc::raw::pack(enc, *this);
return enc.result();
}
transaction_id_type transaction::id() const {
auto h = digest();
transaction_id_type result;
memcpy(result._hash, h._hash, std::min(sizeof(result), sizeof(h)));
return result;
}
digest_type transaction::sig_digest(const chain_id_type &chain_id) const {
digest_type::encoder enc;
fc::raw::pack(enc, chain_id);
fc::raw::pack(enc, *this);
return enc.result();
}
void transaction::set_expiration(fc::time_point_sec expiration_time) {
expiration = expiration_time;
}
void transaction::set_reference_block(const block_id_type &reference_block) {
ref_block_num = fc::endian_reverse_u32(reference_block._hash[0]);
ref_block_prefix = reference_block._hash[1];
}
void signed_transaction::clear() {
operations.clear();
signatures.clear();
}
const signature_type &signed_transaction::sign(const ethereum::private_key_type &key, const ethereum::chain_id_type &chain_id) {
digest_type h = sig_digest(chain_id);
signatures.push_back(key.sign_compact(h, true));
return signatures.back();
}
signature_type signed_transaction::sign(const ethereum::private_key_type &key, const ethereum::chain_id_type &chain_id) const {
digest_type::encoder enc;
fc::raw::pack(enc, chain_id);
fc::raw::pack(enc, *this);
return key.sign_compact(enc.result(), true);
}
}}} // namespace graphene::peerplays_sidechain::ethereum

73
libraries/plugins/peerplays_sidechain/ethereum/types.cpp Normal file
View file

@ -0,0 +1,73 @@
#include <graphene/peerplays_sidechain/ethereum/types.hpp>
#include <fc/crypto/base58.hpp>
#include <fc/crypto/ripemd160.hpp>
#include <fc/exception/exception.hpp>
#include <fc/io/raw.hpp>
namespace graphene { namespace peerplays_sidechain { namespace ethereum {
std::string public_key_type::prefix = KEY_PREFIX_STM;
public_key_type::public_key_type() :
key_data(){};
public_key_type::public_key_type(const fc::ecc::public_key_data &data) :
key_data(data){};
public_key_type::public_key_type(const fc::ecc::public_key &pubkey) :
key_data(pubkey){};
public_key_type::public_key_type(const std::string &base58str) {
const size_t prefix_len = prefix.size();
FC_ASSERT(base58str.size() > prefix_len);
FC_ASSERT(base58str.substr(0, prefix_len) == prefix, "", ("base58str", base58str));
auto bin = fc::from_base58(base58str.substr(prefix_len));
auto bin_key = fc::raw::unpack<binary_key>(bin);
key_data = bin_key.data;
FC_ASSERT(fc::ripemd160::hash(key_data.data, key_data.size())._hash[0] == bin_key.check);
};
public_key_type::operator fc::ecc::public_key_data() const {
return key_data;
};
public_key_type::operator fc::ecc::public_key() const {
return fc::ecc::public_key(key_data);
};
public_key_type::operator std::string() const {
binary_key k;
k.data = key_data;
k.check = fc::ripemd160::hash(k.data.data, k.data.size())._hash[0];
auto data = fc::raw::pack(k);
return prefix + fc::to_base58(data.data(), data.size());
}
bool operator==(const public_key_type &p1, const fc::ecc::public_key &p2) {
return p1.key_data == p2.serialize();
}
bool operator==(const public_key_type &p1, const public_key_type &p2) {
return p1.key_data == p2.key_data;
}
bool operator!=(const public_key_type &p1, const public_key_type &p2) {
return p1.key_data != p2.key_data;
}
}}} // namespace graphene::peerplays_sidechain::ethereum
namespace fc {
using namespace std;
void to_variant(const graphene::peerplays_sidechain::ethereum::public_key_type &var, fc::variant &vo, uint32_t max_depth) {
vo = std::string(var);
}
void from_variant(const fc::variant &var, graphene::peerplays_sidechain::ethereum::public_key_type &vo, uint32_t max_depth) {
vo = graphene::peerplays_sidechain::ethereum::public_key_type(var.as_string());
}
} // namespace fc

41
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/asset.hpp Normal file
View file

@ -0,0 +1,41 @@
#pragma once
#include <graphene/peerplays_sidechain/ethereum/types.hpp>
namespace graphene { namespace peerplays_sidechain { namespace ethereum {
#define HBD_NAI "@@000000013"
#define HBD_PRECISION 3
#define HBD_SYMBOL_U64 (uint64_t('S') | (uint64_t('B') << 8) | (uint64_t('D') << 16))
#define HBD_SYMBOL_SER (uint64_t(3) | (HBD_SYMBOL_U64 << 8))
#define HIVE_NAI "@@000000021"
#define HIVE_PRECISION 3
#define HIVE_SYMBOL_U64 (uint64_t('S') | (uint64_t('T') << 8) | (uint64_t('E') << 16) | (uint64_t('E') << 24) | (uint64_t('M') << 32))
#define HIVE_SYMBOL_SER (uint64_t(3) | (HIVE_SYMBOL_U64 << 8))
#define TBD_NAI "@@000000013"
#define TBD_PRECISION 3
#define TBD_SYMBOL_U64 (uint64_t('T') | (uint64_t('B') << 8) | (uint64_t('D') << 16))
#define TBD_SYMBOL_SER (uint64_t(3) | (TBD_SYMBOL_U64 << 8))
#define TESTS_NAI "@@000000021"
#define TESTS_PRECISION 3
#define TESTS_SYMBOL_U64 (uint64_t('T') | (uint64_t('E') << 8) | (uint64_t('S') << 16) | (uint64_t('T') << 24) | (uint64_t('S') << 32))
#define TESTS_SYMBOL_SER (uint64_t(3) | (TESTS_SYMBOL_U64 << 8))
struct asset {
static uint64_t hbd_symbol_ser;
static uint64_t ethereum_symbol_ser;
share_type amount;
uint64_t symbol;
};
}}} // namespace graphene::peerplays_sidechain::ethereum
namespace fc {
void to_variant(const graphene::peerplays_sidechain::ethereum::asset &var, fc::variant &vo, uint32_t max_depth);
void from_variant(const fc::variant &var, graphene::peerplays_sidechain::ethereum::asset &vo, uint32_t max_depth);
} // namespace fc
FC_REFLECT(graphene::peerplays_sidechain::ethereum::asset, (amount)(symbol))

33
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/authority.hpp Normal file
View file

@ -0,0 +1,33 @@
#pragma once
#include <cstdint>
#include <fc/container/flat_fwd.hpp>
#include <graphene/peerplays_sidechain/ethereum/types.hpp>
namespace graphene { namespace peerplays_sidechain { namespace ethereum {
struct authority {
authority() {
}
enum classification {
owner = 0,
active = 1,
key = 2,
posting = 3
};
uint32_t weight_threshold = 0;
fc::flat_map<ethereum::account_name_type, uint16_t> account_auths;
fc::flat_map<ethereum::public_key_type, uint16_t> key_auths;
};
}}} // namespace graphene::peerplays_sidechain::ethereum
FC_REFLECT_ENUM(graphene::peerplays_sidechain::ethereum::authority::classification,
(owner)(active)(key)(posting))
FC_REFLECT(graphene::peerplays_sidechain::ethereum::authority,
(weight_threshold)(account_auths)(key_auths))

123
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/ethereum_operations.hpp Normal file
View file

@ -0,0 +1,123 @@
#pragma once
#include <cstdint>
#include <vector>
#include <fc/optional.hpp>
#include <graphene/chain/protocol/types.hpp>
#include <graphene/peerplays_sidechain/ethereum/asset.hpp>
#include <graphene/peerplays_sidechain/ethereum/authority.hpp>
#include <graphene/peerplays_sidechain/ethereum/types.hpp>
namespace graphene { namespace peerplays_sidechain { namespace ethereum {
struct vote_operation {};
struct comment_operation {};
struct transfer_operation {
ethereum::account_name_type from;
ethereum::account_name_type to;
ethereum::asset amount;
std::string memo;
};
struct transfer_to_vesting_operation {};
struct withdraw_vesting_operation {};
struct limit_order_create_operation {};
struct limit_order_cancel_operation {};
struct feed_publish_operation {};
struct convert_operation {};
struct account_create_operation {};
struct account_update_operation {
ethereum::account_name_type account;
fc::optional<authority> owner;
fc::optional<authority> active;
fc::optional<authority> posting;
ethereum::public_key_type memo_key;
std::string json_metadata;
};
struct witness_update_operation {};
struct account_witness_vote_operation {};
struct account_witness_proxy_operation {};
struct pow_operation {};
struct custom_operation {};
struct report_over_production_operation {};
struct delete_comment_operation {};
struct custom_json_operation {};
struct comment_options_operation {};
struct set_withdraw_vesting_route_operation {};
struct limit_order_create2_operation {};
struct claim_account_operation {};
struct create_claimed_account_operation {};
struct request_account_recovery_operation {};
struct recover_account_operation {};
struct change_recovery_account_operation {};
struct escrow_transfer_operation {};
struct escrow_dispute_operation {};
struct escrow_release_operation {};
struct pow2_operation {};
struct escrow_approve_operation {};
struct transfer_to_savings_operation {};
struct transfer_from_savings_operation {};
struct cancel_transfer_from_savings_operation {};
struct custom_binary_operation {};
struct decline_voting_rights_operation {};
struct reset_account_operation {};
struct set_reset_account_operation {};
struct claim_reward_balance_operation {};
struct delegate_vesting_shares_operation {
ethereum::account_name_type delegator;
ethereum::account_name_type delegatee;
ethereum::asset vesting_shares;
};
}}} // namespace graphene::peerplays_sidechain::ethereum
FC_REFLECT(graphene::peerplays_sidechain::ethereum::vote_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::comment_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::transfer_operation,
(from)(to)(amount)(memo))
FC_REFLECT(graphene::peerplays_sidechain::ethereum::transfer_to_vesting_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::withdraw_vesting_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::limit_order_create_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::limit_order_cancel_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::feed_publish_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::convert_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::account_create_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::account_update_operation,
(account)(owner)(active)(posting)(memo_key)(json_metadata))
FC_REFLECT(graphene::peerplays_sidechain::ethereum::witness_update_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::account_witness_vote_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::account_witness_proxy_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::pow_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::custom_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::report_over_production_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::delete_comment_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::custom_json_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::comment_options_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::set_withdraw_vesting_route_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::limit_order_create2_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::claim_account_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::create_claimed_account_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::request_account_recovery_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::recover_account_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::change_recovery_account_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::escrow_transfer_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::escrow_dispute_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::escrow_release_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::pow2_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::escrow_approve_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::transfer_to_savings_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::transfer_from_savings_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::cancel_transfer_from_savings_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::custom_binary_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::decline_voting_rights_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::reset_account_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::set_reset_account_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::claim_reward_balance_operation, )
FC_REFLECT(graphene::peerplays_sidechain::ethereum::delegate_vesting_shares_operation,
(delegator)(delegatee)(vesting_shares))

69
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/operations.hpp Normal file
View file

@ -0,0 +1,69 @@
#pragma once
#include <graphene/peerplays_sidechain/ethereum/ethereum_operations.hpp>
namespace graphene { namespace peerplays_sidechain { namespace ethereum {
typedef fc::static_variant<
vote_operation,
comment_operation,
transfer_operation,
transfer_to_vesting_operation,
withdraw_vesting_operation,
limit_order_create_operation,
limit_order_cancel_operation,
feed_publish_operation,
convert_operation,
account_create_operation,
account_update_operation,
witness_update_operation,
account_witness_vote_operation,
account_witness_proxy_operation,
pow_operation,
custom_operation,
report_over_production_operation,
delete_comment_operation,
custom_json_operation,
comment_options_operation,
set_withdraw_vesting_route_operation,
limit_order_create2_operation,
claim_account_operation,
create_claimed_account_operation,
request_account_recovery_operation,
recover_account_operation,
change_recovery_account_operation,
escrow_transfer_operation,
escrow_dispute_operation,
escrow_release_operation,
pow2_operation,
escrow_approve_operation,
transfer_to_savings_operation,
transfer_from_savings_operation,
cancel_transfer_from_savings_operation,
custom_binary_operation,
decline_voting_rights_operation,
reset_account_operation,
set_reset_account_operation,
claim_reward_balance_operation,
delegate_vesting_shares_operation>
ethereum_operation;
}}} // namespace graphene::peerplays_sidechain::hive
namespace fc {
void to_variant(const graphene::peerplays_sidechain::ethereum::ethereum_operation &var, fc::variant &vo, uint32_t max_depth = 5);
void from_variant(const fc::variant &var, graphene::peerplays_sidechain::ethereum::ethereum_operation &vo, uint32_t max_depth = 5);
} // namespace fc
FC_REFLECT_TYPENAME(graphene::peerplays_sidechain::ethereum::ethereum_operation)

12
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/transaction.hpp
View file

@ -3,17 +3,23 @@
#include <cstdint>
#include <vector>
#include <fc/crypto/elliptic.hpp>
#include <fc/crypto/ripemd160.hpp>
#include <fc/container/flat_fwd.hpp>
#include <fc/time.hpp>
#include <graphene/peerplays_sidechain/ethereum/operations.hpp>
namespace graphene { namespace peerplays_sidechain { namespace ethereum {
typedef fc::ecc::private_key private_key_type;
typedef fc::sha256 chain_id_type;
class transaction {
public:
uint16_t ref_block_num = 0;
uint32_t ref_block_prefix = 0;
fc::time_point_sec expiration;
std::vector<hive_operation> operations;
std::vector<ethereum_operation> operations;
extensions_type extensions;
digest_type digest() const;
@ -23,6 +29,7 @@ class transaction {
void set_expiration(fc::time_point_sec expiration_time);
void set_reference_block(const block_id_type &reference_block);
/*
/// Serialises this transaction to an RLPStream.
/// @throws TransactionIsUnsigned if including signature was requested but it was not initialized
void streamRLP(RLPStream& _s, IncludeSignature _sig = WithSignature, bool _forEip155hash = false) const;
@ -57,6 +64,7 @@ protected:
mutable h256 m_hashWith; ///< Cached hash of transaction with signature.
mutable boost::optional<Address> m_sender; ///< Cached sender, determined from signature.
*/
};
class signed_transaction : public transaction {

72
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/types.hpp Normal file
View file

@ -0,0 +1,72 @@
#pragma once
#include <fc/crypto/elliptic.hpp>
#include <fc/crypto/ripemd160.hpp>
namespace graphene { namespace peerplays_sidechain { namespace ethereum {
#define KEY_PREFIX_STM "STM"
#define KEY_PREFIX_TST "TST"
enum network {
mainnet,
testnet
};
struct void_t {};
typedef fc::static_variant<void_t> future_extensions;
typedef fc::flat_set<future_extensions> extensions_type;
typedef fc::ecc::private_key private_key_type;
typedef fc::sha256 chain_id_type;
typedef std::string account_name_type;
typedef fc::ripemd160 block_id_type;
//typedef fc::ripemd160 checksum_type;
typedef fc::ripemd160 transaction_id_type;
typedef fc::sha256 digest_type;
typedef fc::ecc::compact_signature signature_type;
typedef fc::safe<int64_t> share_type;
//typedef safe<uint64_t> ushare_type;
//typedef uint16_t weight_type;
//typedef uint32_t contribution_id_type;
//typedef fixed_string<32> custom_id_type;
struct public_key_type {
static std::string prefix;
struct binary_key {
binary_key() {
}
uint32_t check = 0;
fc::ecc::public_key_data data;
};
fc::ecc::public_key_data key_data;
public_key_type();
public_key_type(const fc::ecc::public_key_data &data);
public_key_type(const fc::ecc::public_key &pubkey);
explicit public_key_type(const std::string &base58str);
operator fc::ecc::public_key_data() const;
operator fc::ecc::public_key() const;
explicit operator std::string() const;
friend bool operator==(const public_key_type &p1, const fc::ecc::public_key &p2);
friend bool operator==(const public_key_type &p1, const public_key_type &p2);
friend bool operator<(const public_key_type &p1, const public_key_type &p2) {
return p1.key_data < p2.key_data;
}
friend bool operator!=(const public_key_type &p1, const public_key_type &p2);
};
}}} // namespace graphene::peerplays_sidechain::ethereum
namespace fc {
void to_variant(const graphene::peerplays_sidechain::ethereum::public_key_type &var, fc::variant &vo, uint32_t max_depth = 2);
void from_variant(const fc::variant &var, graphene::peerplays_sidechain::ethereum::public_key_type &vo, uint32_t max_depth = 2);
} // namespace fc
FC_REFLECT(graphene::peerplays_sidechain::ethereum::public_key_type, (key_data))
FC_REFLECT(graphene::peerplays_sidechain::ethereum::public_key_type::binary_key, (data)(check))
FC_REFLECT(graphene::peerplays_sidechain::ethereum::void_t, )
FC_REFLECT_TYPENAME(graphene::peerplays_sidechain::ethereum::future_extensions)

2
libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler_eth.hpp
View file

@ -119,6 +119,7 @@ public:
std::string walletprocesspsbt(std::string const &tx_psbt);
bool walletpassphrase(const std::string &passphrase, uint32_t timeout = 60);
std::string chain_id;//256 bit value
private:
class ethereum_function_call_encoder {
public:
@ -140,7 +141,6 @@ private:
std::vector<std::string> owners;
uint32_t threshold;
std::unordered_map<uint64_t, req_t> m_requests;
std::string chain_id;//256 bit value
std::string balance;
std::string code;

15
libraries/plugins/peerplays_sidechain/sidechain_net_handler_eth.cpp
View file

@ -18,6 +18,7 @@
#include <graphene/chain/son_info.hpp>
#include <graphene/chain/son_wallet_object.hpp>
#include <graphene/utilities/key_conversion.hpp>
#include <graphene/peerplays_sidechain/ethereum/transaction.hpp>
#include <fc/io/json.hpp>
extern "C" {
@ -291,6 +292,8 @@ uint64_t eth_rpc_client::add_owner(const std::string& addr ) {
uint64_t id = eth_sign(account_address, message);
m_requests[t_id] = req_t::ADD_OWNER;
return 0;
}
uint64_t eth_rpc_client::remove_owner(const std::string& addr, uint32_t threshold) {
@ -318,6 +321,8 @@ uint64_t eth_rpc_client::remove_owner(const std::string& addr, uint32_t threshol
std::string refundReceiver = "0000000000000000000000000000000000000000";
m_requests[t_id] = req_t::REMOVE_OWNER;
return 0;
}
std::string eth_rpc_client::addmultisigaddress(const uint32_t nrequired, const std::vector<std::string> public_keys) {
@ -1032,13 +1037,12 @@ std::string sidechain_net_handler_eth::create_transaction() {
}
std::string sidechain_net_handler_eth::sign_transaction(const sidechain_transaction_object &sto) {
/*
std::stringstream ss_trx(boost::algorithm::unhex(sto.transaction));
hive::signed_transaction htrx;
ethereum::signed_transaction htrx;
fc::raw::unpack(ss_trx, htrx, 1000);
std::string chain_id_str = node_rpc_client->get_chain_id();
const hive::chain_id_type chain_id(chain_id_str);
std::string chain_id_str = eth_client->chain_id;//eth_rpc_client->get_chain_id();
const ethereum::chain_id_type chain_id(chain_id_str);
fc::optional<fc::ecc::private_key> privkey = graphene::utilities::wif_to_key(get_private_key(plugin.get_current_son_object().sidechain_public_keys.at(sidechain)));
signature_type st = htrx.sign(*privkey, chain_id);
@ -1046,8 +1050,7 @@ std::string sidechain_net_handler_eth::sign_transaction(const sidechain_transact
std::stringstream ss_st;
fc::raw::pack(ss_st, st, 1000);
std::string st_str = boost::algorithm::hex(ss_st.str());
*/
return "";//st_str;
return st_str;
}