先基本记录下，稍后整理，测试，总结
1. How can I generate random numbers inside a smart contract?
if( !is_zero(prev_reveal.reveal) ) {
checksum256 result;
sha256( (char *)&game_itr->player1, sizeof(player)*2, &result);
auto prev_revealer_offer = idx.find( offer::get_commitment(prev_reveal.commitment) );
int winner = result.hash[1] < result.hash[0] ? 0 : 1;
if( winner ) {
pay_and_clean(*game_itr, *curr_revealer_offer, *prev_revealer_offer);
} else {
pay_and_clean(*game_itr, *prev_revealer_offer, *curr_revealer_offer);
}
}2. EOSDACRandom
#include "eosdacrandom.hpp"
#include <eosiolib/system.h>
#include <eosiolib/stdlib.hpp>
#include <eosiolib/action.hpp>
#include <eosiolib/symbol.hpp>
#include "../eosdactoken/eosdactoken.hpp"
using namespace eosio;
eosdacrandom::eosdacrandom(account_name name)
: contract(name),
_seeds(_self, name),
_geters(_self, name)
{
}
eosdacrandom::~eosdacrandom()
{
}
void eosdacrandom::setsize(uint64_t size)
{
require_auth(_self);
seedconfig_table config(_self, _self);
auto existing = config.find(_self);
if (existing != config.end()) {
if (existing->hash_count == existing->target_size) {
if (existing->hash_count != existing->seed_match) {
eosio_assert(false, "do not set size during sendseed period");
}
}
config.modify(existing, _self, [&](auto& c){
c.target_size = size;
});
} else {
config.emplace(_self, [&](auto& c){
c.owner = _self;
c.target_size = size;
});
}
}
void eosdacrandom::sendseed(name owner, int64_t seed, string sym)
{
eosio_assert(is_account(owner), "Invalid account");
symbol_type symbol(string_to_symbol(4, sym.c_str()));
eosio::asset fromBalance = eosdactoken(N(eosdactoken)).get_balance(owner, symbol.name());
eosio_assert(fromBalance.amount > 0, "account has not enough OCT to do it");
eosio::asset selfBalance = eosdactoken(N(eosdactoken)).get_balance(_self, symbol.name());
eosio_assert(selfBalance.amount > 0, "contract account has not enough OCT to do it");
require_auth(owner);
seedconfig_table config(_self, _self);
auto existing = config.find(_self);
eosio_assert(existing != config.end(), "target size must set first");
const auto& cfg = *existing;
const auto& sd = _seeds.find(owner);
if (cfg.hash_count < cfg.target_size) {
if (sd != _seeds.end()) {
_seeds.erase(sd);
config.modify(cfg, _self, [&](auto& c){
c.hash_count --;
});
}
eosio_assert(false, "hash size not fulled");
}
string h = cal_sha256_str(seed);
eosio_assert(sd->seed != seed, "you have already send seed");
if (sd->hash != h) {
//SEND_INLINE_ACTION( eosdacvote, vote, {_self,N(active)}, {_self, owner, selfBalance, false} );
for (auto itr = _seeds.cbegin(); itr != _seeds.cend(); ) {
itr = _seeds.erase(itr);
}
config.modify(cfg, _self, [&](auto& c){
c.hash_count = 0;
});
return;
}
_seeds.modify(sd, _self, [&](auto& a){
a.seed = seed;
});
config.modify(cfg, _self, [&](auto& c){
c.seed_match = c.seed_match + 1;
print(c.seed_match);
});
// if all seeds match
if (seedsmatch()) {
dispatch_request(owner);
}
}
void eosdacrandom::sendhash(name owner, string hash, string sym)
{
eosio_assert(is_account(owner), "Invalid account");
seedconfig_table config(_self, _self);
auto existing = config.find(_self);
eosio_assert(existing != config.end(), "target size must set first");
const auto& cfg = *existing;
eosio_assert(cfg.hash_count < cfg.target_size, "seeds is full");
symbol_type symbol(string_to_symbol(4, sym.c_str()));
eosio::asset fromBalance = eosdactoken(N(eosdactoken)).get_balance(owner, symbol.name());
eosio_assert(fromBalance.amount > 0, "account has not enough OCT to do it");
require_auth(owner);
auto s = _seeds.find(owner);
if (s == _seeds.end()) {
_seeds.emplace(_self, [&](auto& a){
a.owner = owner;
a.hash = hash;
});
config.modify(cfg, _self, [&](auto& c){
c.hash_count++;
});
} else {
_seeds.modify(s, _self, [&](auto& a){
a.hash = hash;
});
}
}
void eosdacrandom::regrequest(name owner, uint64_t index)
{
eosio_assert(is_account(owner), "Invalid account");
uint64_t cur = current_time();
auto it = _geters.find(owner);
request_info req {index, cur};
if (it == _geters.end()) {
_geters.emplace(_self, [&](auto& a){
a.owner = owner;
a.requestinfo.push_back(req);
});
} else {
_geters.modify(it, _self, [&](auto& a){
bool same_idx = false;
for (auto ri = a.requestinfo.begin(); ri != a.requestinfo.end(); ++ri) {
if (ri->index == index) { // if index equals former index.
*ri = req;
same_idx = true;
break;
}
}
if (!same_idx) {
a.requestinfo.push_back(req);
}
});
}
}
int64_t eosdacrandom::random()
{
// use _seeds to generate random number
seedconfig_table config(_self, _self);
auto existing = config.find(_self);
eosio_assert(existing != config.end(), "target size must set first");
eosio_assert(existing->hash_count == existing->target_size, "seed is not full");
// how to generate random number?
int64_t seed = 0;
for (auto it = _seeds.cbegin(); it != _seeds.cend();) {
seed += it->seed;
it = _seeds.erase(it);
}
config.modify(existing, _self, [&](auto& c){
c.hash_count = 0;
c.seed_match = 0;
});
checksum256 cs = cal_sha256(seed);
return (((int64_t)cs.hash[0] << 56 ) & 0xFF00000000000000U)
| (((int64_t)cs.hash[1] << 48 ) & 0x00FF000000000000U)
| (((int64_t)cs.hash[2] << 40 ) & 0x0000FF0000000000U)
| (((int64_t)cs.hash[3] << 32 ) & 0x000000FF00000000U)
| ((cs.hash[4] << 24 ) & 0x00000000FF000000U)
| ((cs.hash[5] << 16 ) & 0x0000000000FF0000U)
| ((cs.hash[6] << 8 ) & 0x000000000000FF00U)
| (cs.hash[7] & 0x00000000000000FFU);
}
bool eosdacrandom::seedsmatch()
{
seedconfig_table config(_self, _self);
auto existing = config.find(_self);
eosio_assert(existing != config.end(), "target size must set first");
const auto& cfg = *existing;
if (cfg.hash_count != cfg.target_size) {
return false;
}
if (cfg.hash_count == cfg.seed_match) {
return true;
}
return false;
}
checksum256 eosdacrandom::cal_sha256(int64_t word)
{
checksum256 cs = { 0 };
char d[255] = { 0 };
snprintf(d, sizeof(d) - 1, "%lld", word);
sha256(d, strlen(d), &cs);
return cs;
}
string eosdacrandom::cal_sha256_str(int64_t word)
{
string h;
checksum256 cs = cal_sha256(word);
for (int i = 0; i < sizeof(cs.hash); ++i) {
char hex[3] = { 0 };
snprintf(hex, sizeof(hex), "%02x", static_cast<unsigned char>(cs.hash[i]));
h += hex;
}
return h;
}
void eosdacrandom::dispatch_request(name owner)
{
print("all seeds matched.");
uint64_t cur = current_time();
int64_t num = random();
static int expiraion = 3000; // ms
std::vector<std::vector<request_info>> reqs;
for (auto i = _geters.cbegin(); i != _geters.cend();) {
std:vector<request_info> tmp(i->requestinfo);
for (auto j = tmp.begin(); j != tmp.end();) {
if (cur - j->timestamp >= expiraion) {
dispatch_inline(i->owner, string_to_name("getrandom"),
{permission_level(_self, N(active))},
std::make_tuple(j->index, num));
j = tmp.erase(j);
} else {
++j;
}
}
if (tmp.size()) {
reqs.push_back(tmp);
}
i = _geters.erase(i);
}
if (reqs.size()) {
for (auto r = reqs.cbegin(); r != reqs.cend(); ++r) {
_geters.emplace(_self, [&](auto& a){
a.owner = owner;
a.requestinfo = *r;
});
}
}
}
EOSIO_ABI( eosdacrandom, (setsize) (sendseed) (sendhash) (regrequest) )3. eoscraper
#include "scraper.hpp"
#include <set>
#include <map>
#include <vector>
#include "Proof.hh"
#include "Ecc.hh"
//count of participants for random generation (min 4)
constexpr static uint8_t participant_cnt = 10;
static const UInt256 seed_for_g = fromString("21343453542133456453212");
static const UInt256 seed_for_m = fromString("56987654354236234435425");
static const Point base_point { Secp256k1, Secp256k1.G.x, Secp256k1.G.y };
static const Point gen_g = base_point.scalarMult(seed_for_g);
static const Point gen_m = base_point.scalarMult(seed_for_m);
struct binuint256_t {
checksum256 data;
};
struct binpoint {
binuint256_t x, y;
};
struct binproof {
binpoint g,m,h,z,a,b;
binuint256_t c, r;
};
UInt256 fromBin(binuint256_t const & data) {
UInt256 x;
memcpy(x.data, data.data.hash, sizeof(data.data));
return std::move(x);
}
Point fromBin(binpoint const &data) {
Point point {Secp256k1, fromBin(data.x), fromBin(data.y)};
eosio_assert(point.isOnCurve(), "Point not in curve");
return std::move(point);
}
Proof fromBin(binproof const &data) {
return {
fromBin(data.g), fromBin(data.m),
fromBin(data.h), fromBin(data.z),
fromBin(data.a), fromBin(data.b),
fromBin(data.c), fromBin(data.r)
};
}
// @abi table
struct encshare {
uint64_t id;
account_name from;
account_name to;
binpoint data;
binpoint commitment;
binproof proof;
uint64_t dec_id;
auto primary_key() const { return id; }
EOSLIB_SERIALIZE(encshare, (id)(from)(to)(data)(commitment)(proof)(dec_id));
};
// @abi table
struct decshare {
uint64_t id;
binpoint s;
binproof proof;
auto primary_key() const { return id; }
EOSLIB_SERIALIZE(decshare, (id)(s)(proof));
};
// @abi table
struct random {
enum state : uint8_t {
wait_joins = 0,
wait_enc_shares,
wait_dec_shares,
done,
error,
};
uint64_t id;
uint8_t state;
uint8_t joined_cnt;
std::vector<account_name> participants;
uint32_t pushed_cnt;
std::vector<uint64_t> enc_ids;
std::vector<uint8_t> dec_cnts;
auto primary_key()const { return id; }
EOSLIB_SERIALIZE(random, (id)(state)(participants)(enc_ids)(dec_cnts));
};
// @abi table
struct account {
account_name owner;
binpoint pubkey;
auto primary_key()const { return owner; }
EOSLIB_SERIALIZE(account, (owner)(pubkey));
};
class scraper : public eosio::contract {
public:
scraper( account_name self ) :
contract(self),
_accounts(_self, _self),
_randoms( _self, _self),
_encshares(_self, _self),
_decshares(_self, _self)
{ }
// @abi action
void bindkey(account_name sender, binpoint pubkey) {
require_auth(sender);
auto acc = _accounts.find(sender);
if (acc != _accounts.end())
_accounts.modify(acc, sender, [&] (auto & acc) {
acc.pubkey = pubkey;
});
else
_accounts.emplace(sender, [&](auto & acc) {
acc.owner = sender;
acc.pubkey = pubkey;
});
}
// @abi action
void initrand(account_name sender) {
require_auth(sender);
auto acc = _accounts.find(sender);
eosio_assert(acc != _accounts.end(), "Need to bind public key");
_randoms.emplace(sender, [&](auto & rand) {
rand.id = _randoms.available_primary_key();
rand.state = random::state::wait_joins;
rand.participants.reserve(participant_cnt);
rand.enc_ids.reserve(participant_cnt*participant_cnt);
rand.dec_cnts.reserve(participant_cnt);
rand.participants[0] = sender;
rand.joined_cnt = 1;
rand.pushed_cnt = 0;
for(auto k = 0; k < participant_cnt * participant_cnt; ++k)
rand.enc_ids[k] = -1;
});
}
// @abi action
void joinrand(uint64_t rand_id, account_name sender) {
require_auth(sender);
auto acc = _accounts.find(sender);
eosio_assert(acc != _accounts.end(), "Need to bind public key");
auto rand_it = _randoms.find(rand_id);
eosio_assert(rand_it != _randoms.end(), "Rand not found");
eosio_assert(participantId(*rand_it, sender) != -1, "Already joinded");
eosio_assert(rand_it->state == random::state::wait_joins, "Invalid state");
_randoms.modify(rand_it, sender, [&](auto & rand) {
rand.participants[rand.joined_cnt++] = sender;
if (rand.joined_cnt == participant_cnt)
rand.state = random::state::wait_enc_shares;
});
}
// @abi action
void pushencshare(uint64_t rand_id, account_name sender, account_name receiver,
binpoint data, binpoint commitment, binproof proof)
{
require_auth(sender);
auto senderAccIt = _accounts.find(sender);
eosio_assert(senderAccIt != _accounts.end(), "Sender not found");
auto receiverAccIt = _accounts.find(receiver);
eosio_assert(receiverAccIt != _accounts.end(), "Receiver not found");
auto rand_it = _randoms.find(rand_id);
eosio_assert(rand_it != _randoms.end(), "Rand not found");
auto senderPartId = participantId(*rand_it, sender);
eosio_assert(senderPartId != -1, "Sender is not participant");
auto receiverPartId = participantId(*rand_it, receiver);
eosio_assert(receiverPartId != -1, "Receiver is not participant");
eosio_assert(rand_it->enc_ids[(uint32_t)senderPartId * participant_cnt + receiverPartId] == -1, "share already pushed");
auto pk = fromBin(receiverAccIt->pubkey);
auto pr = fromBin(proof);
eosio_assert(gen_g == pr.g, "Invalid proof (gen_g != g)");
eosio_assert(pk == pr.m, "Invalid proof (pk != m)");
eosio_assert(pr.verify(), "Proof validate failed");
uint64_t new_share_id;
_encshares.emplace(sender, [&](auto & share) {
new_share_id = _encshares.available_primary_key();
share.id = new_share_id;
share.from = sender;
share.to = receiver;
share.data = data;
share.commitment = commitment;
share.proof = proof;
share.dec_id = (uint64_t)-1;
});
_randoms.modify(rand_it, sender, [&](auto & rand) {
rand.enc_ids[(uint32_t)senderPartId * participant_cnt + receiverPartId] = new_share_id;
rand.pushed_cnt++;
if (rand.pushed_cnt == (uint32_t)participant_cnt * participant_cnt)
rand.state = random::state::wait_dec_shares;
});
}
// @abi action
void pushdecshare(uint64_t rand_id, account_name sender, account_name from,
binpoint s, binproof proof)
{
require_auth(sender);
auto senderAccIt = _accounts.find(sender);
eosio_assert(senderAccIt != _accounts.end(), "Sender not found");
auto fromAccIt = _accounts.find(from);
eosio_assert(fromAccIt != _accounts.end(), "From not found");
auto rand_it = _randoms.find(rand_id);
eosio_assert(rand_it != _randoms.end(), "Rand not found");
eosio_assert(rand_it->state == random::state::wait_dec_shares, "Invalid state");
auto senderPartId = participantId(*rand_it, from);
eosio_assert(senderPartId != -1, "Sender is not participant");
auto receiverPartId = participantId(*rand_it, sender);
eosio_assert(receiverPartId != -1, "Receiver is not participant");
auto enc_id = rand_it->enc_ids[(uint32_t)senderPartId * participant_cnt + receiverPartId];
auto encshare_it = _encshares.find(enc_id);
eosio_assert(encshare_it != _encshares.end(), "Share not found");
eosio_assert(encshare_it->dec_id == -1, "Already pushed");
auto encdata = fromBin(encshare_it->data);
auto pk = fromBin(senderAccIt->pubkey);
auto ss = fromBin(s);
auto pr = fromBin(proof);
eosio_assert(gen_g == pr.g, "Invalid proof (gen_g != g)");
eosio_assert(encdata == pr.z, "Invalid proof (encdata != g)");
eosio_assert(ss == pr.m, "Invalid proof (m != s)");
eosio_assert(pk == pr.h, "Invalid proof (pk != h)");
eosio_assert(pr.verify(), "Proof validate failed");
uint64_t new_dec_id;
_decshares.emplace(sender, [&](auto & obj) {
new_dec_id = _decshares.available_primary_key();
obj.id = new_dec_id;
obj.s = s;
obj.proof = proof;
});
_encshares.modify(encshare_it, sender, [&](auto & obj) {
obj.dec_id = new_dec_id;
});
_randoms.modify(rand_it, sender, [&](auto & rand) {
rand.dec_cnts[from]++;
});
}
private:
eosio::multi_index<N(accounts), account> _accounts;
eosio::multi_index<N(randoms), random> _randoms;
eosio::multi_index<N(encshare), encshare> _encshares;
eosio::multi_index<N(decshare), decshare> _decshares;
private:
uint8_t participantId(random const & obj, account_name acc) {
for (uint8_t i = 0; i < participant_cnt; ++i)
if (obj.participants[i] == acc)
return i;
return -1;
}
};
EOSIO_ABI( scraper, (bindkey)(initrand)(joinrand)(pushencshare)(pushdecshare))