Skip to content

add public getters for unpermissioned statistics #16

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
brenzi merged 4 commits into from
Jun 23, 2020
Merged

add public getters for unpermissioned statistics #16

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
c779b08
fixes #7
Jun 23, 2020
2459279
add total-issuance to client CLI
Jun 23, 2020
3b4c38c
bump version to 0.6.7
Jun 23, 2020
90b36a7
document new function in script
Jun 23, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Next Next commit
fixes #7
  • Loading branch information
Alain Brenzikofer committed Jun 23, 2020
commit c779b0883cef43987b192331c58f01f261c70a47
12 changes: 6 additions & 6 deletions client/src/main.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -67,7 +67,7 @@ use encointer_currencies::{CurrencyIdentifier, CurrencyPropertiesType, Location,

use substratee_stf::{
cli::get_identifiers, ShardIdentifier, TrustedCallSigned, TrustedGetterSigned,
TrustedOperationSigned,
TrustedOperation, Getter
};
use substratee_worker_api::Api as WorkerApi;

Expand Down Expand Up @@ -521,18 +521,18 @@ fn get_worker_api(matches: &ArgMatches<'_>) -> WorkerApi {

fn perform_trusted_operation(
matches: &ArgMatches<'_>,
top: &TrustedOperationSigned,
top: &TrustedOperation,
) -> Option<Vec<u8>> {
match top {
TrustedOperationSigned::call(call) => send_request(matches, call.clone()),
TrustedOperationSigned::get(getter) => get_state(matches, getter.clone()),
TrustedOperation::call(call) => send_request(matches, call.clone()),
TrustedOperation::get(getter) => get_state(matches, getter.clone()),
}
}

fn get_state(matches: &ArgMatches<'_>, getter: TrustedGetterSigned) -> Option<Vec<u8>> {
fn get_state(matches: &ArgMatches<'_>, getter: Getter) -> Option<Vec<u8>> {
let worker_api = get_worker_api(matches);
let (_mrenclave, shard) = get_identifiers(matches);
debug!("calling workerapi to get state value, {:?}", getter.getter);
debug!("calling workerapi to get state value, {:?}", getter);
let ret = worker_api
.get_stf_state(getter, &shard)
.expect("getting value failed");
Expand Down
24 changes: 14 additions & 10 deletions enclave/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,7 @@ use sgx_types::{sgx_epid_group_id_t, sgx_status_t, sgx_target_info_t, size_t, Sg
use substrate_api_client::{compose_extrinsic_offline, utils::storage_key};
use substratee_node_primitives::CallWorkerFn;
use substratee_stf::{
ShardIdentifier, Stf, TrustedCallSigned, TrustedGetterSigned,
ShardIdentifier, Stf, TrustedCallSigned, Getter,
};

use codec::{Decode, Encode};
Expand Down Expand Up @@ -210,12 +210,14 @@ pub unsafe extern "C" fn get_state(
let shard = ShardIdentifier::from_slice(slice::from_raw_parts(shard, shard_size as usize));
let mut trusted_op_slice = slice::from_raw_parts(trusted_op, trusted_op_size as usize);
let value_slice = slice::from_raw_parts_mut(value, value_size as usize);
let tusted_getter_signed = TrustedGetterSigned::decode(&mut trusted_op_slice).unwrap();

debug!("verifying signature of TrustedCallSigned");
if let false = tusted_getter_signed.verify_signature() {
error!("bad signature");
return sgx_status_t::SGX_ERROR_UNEXPECTED;
let getter = Getter::decode(&mut trusted_op_slice).unwrap();

if let Getter::trusted(trusted_getter_signed) = getter.clone() {
debug!("verifying signature of TrustedGetterSigned");
if let false = trusted_getter_signed.verify_signature() {
error!("bad signature");
return sgx_status_t::SGX_ERROR_UNEXPECTED;
}
}

if !state::exists(&shard) {
Expand All @@ -237,9 +239,11 @@ pub unsafe extern "C" fn get_state(

let latest_header = validator.latest_header(validator.num_relays).unwrap();

// FIXME: not sure we will ever need this as we are querying trusted state, not onchain state
// i.e. demurrage could be correctly applied with this, but the client could do that too.
debug!("Update STF storage!");
let requests: Vec<WorkerRequest> =
Stf::get_storage_hashes_to_update_for_getter(&tusted_getter_signed)
Stf::get_storage_hashes_to_update_for_getter(&getter)
.into_iter()
.map(|key| WorkerRequest::ChainStorage(key, Some(latest_header.hash())))
.collect();
Expand All @@ -259,7 +263,7 @@ pub unsafe extern "C" fn get_state(
}

debug!("calling into STF to get state");
let value_opt = Stf::get_state(&mut state, tusted_getter_signed.getter);
let value_opt = Stf::get_state(&mut state, getter);

debug!("returning getter result");
write_slice_and_whitespace_pad(value_slice, value_opt.encode());
Expand Down Expand Up @@ -356,7 +360,7 @@ pub unsafe extern "C" fn sync_chain_relay(
}

if update_states(signed_block.block.header.clone()).is_err() {
error!("Error performing state updates upon block import")
error!("Error performing state updates upon block import");
return sgx_status_t::SGX_ERROR_UNEXPECTED;
}

Expand Down
115 changes: 54 additions & 61 deletions stf/src/cli.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,7 @@

*/

use crate::{AccountId, ShardIdentifier, TrustedCall, TrustedGetter, TrustedOperationSigned, Attestation};
use crate::{AccountId, ShardIdentifier, TrustedCall, TrustedGetter, PublicGetter, TrustedOperation, Attestation};
use base58::{FromBase58, ToBase58};
use clap::{Arg, ArgMatches};
use clap_nested::{Command, Commander, MultiCommand};
Expand All @@ -38,7 +38,7 @@ type Moment = u64;
const KEYSTORE_PATH: &str = "my_trusted_keystore";

pub fn cmd<'a>(
perform_operation: &'a dyn Fn(&ArgMatches<'_>, &TrustedOperationSigned) -> Option<Vec<u8>>,
perform_operation: &'a dyn Fn(&ArgMatches<'_>, &TrustedOperation) -> Option<Vec<u8>>,
) -> MultiCommand<'a, str, str> {
Commander::new()
.options(|app| {
Expand Down Expand Up @@ -146,24 +146,22 @@ pub fn cmd<'a>(
info!("from ss58 is {}", from.public().to_ss58check());
info!("to ss58 is {}", to.to_ss58check());

let (mrenclave, shard) = get_identifiers(matches);

let tcall = TrustedCall::balance_transfer(
sr25519_core::Public::from(from.public()),
to,
shard, // for encointer we assume that every currency has its own shard. so shard == cid
BalanceType::from_num(amount),
);
let nonce = 0; // FIXME: hard coded for now
let tscall =
tcall.sign(&sr25519_core::Pair::from(from), nonce, &mrenclave, &shard);
println!(
"send trusted call transfer from {} to {}: {}",
tscall.call.account(),
from.public(),
to,
amount
);
let _ = perform_operation(matches, &TrustedOperationSigned::call(tscall));
let (mrenclave, shard) = get_identifiers(matches);
let nonce = 0; // FIXME: hard coded for now
let top: TrustedOperation = TrustedCall::balance_transfer(
sr25519_core::Public::from(from.public()),
to,
shard, // for encointer we assume that every currency has its own shard. so shard == cid
BalanceType::from_num(amount))
.sign(&sr25519_core::Pair::from(from), nonce, &mrenclave, &shard)
.into();
let _ = perform_operation(matches, &top);
Ok(())
}),
)
Expand All @@ -184,10 +182,10 @@ pub fn cmd<'a>(
println!("arg_who = {:?}", arg_who);
let who = get_pair_from_str(matches, arg_who);
let (_mrenclave, shard) = get_identifiers(matches);
let tgetter =
TrustedGetter::balance(sr25519_core::Public::from(who.public()), shard);
let tsgetter = tgetter.sign(&sr25519_core::Pair::from(who));
let res = perform_operation(matches, &TrustedOperationSigned::get(tsgetter));
let top: TrustedOperation = TrustedGetter::balance(sr25519_core::Public::from(who.public()), shard)
.sign(&sr25519_core::Pair::from(who))
.into();
let res = perform_operation(matches, &top);
let bal = if let Some(v) = res {
if let Ok(vd) = <BalanceType>::decode(&mut v.as_slice()) {
vd
Expand Down Expand Up @@ -218,19 +216,18 @@ pub fn cmd<'a>(
let arg_who = matches.value_of("accountid").unwrap();
let who = get_pair_from_str(matches, arg_who);
let (mrenclave, shard) = get_identifiers(matches);
let tcall = TrustedCall::ceremonies_register_participant(
sr25519_core::Public::from(who.public()),
shard, // for encointer we assume that every currency has its own shard. so shard == cid
None
);
let nonce = 0; // FIXME: hard coded for now
let tscall =
tcall.sign(&sr25519_core::Pair::from(who), nonce, &mrenclave, &shard);
println!(
"send TrustedCall::register_participant for {}",
tscall.call.account(),
who.public(),
);
perform_operation(matches, &TrustedOperationSigned::call(tscall));
let top: TrustedOperation = TrustedCall::ceremonies_register_participant(
sr25519_core::Public::from(who.public()),
shard, // for encointer we assume that every currency has its own shard. so shard == cid
None)
.sign(&sr25519_core::Pair::from(who), nonce, &mrenclave, &shard)
.into();
perform_operation(matches, &top);
Ok(())
}),
)
Expand All @@ -250,18 +247,17 @@ pub fn cmd<'a>(
let arg_who = matches.value_of("accountid").unwrap();
let who = get_pair_from_str(matches, arg_who);
let (_mrenclave, shard) = get_identifiers(matches);
let tgetter = TrustedGetter::registration(
sr25519_core::Public::from(who.public()),
shard, // for encointer we assume that every currency has its own shard. so shard == cid
);
let tsgetter =
tgetter.sign(&sr25519_core::Pair::from(who));
println!(
"send TrustedGetter::get_registration for {}",
tsgetter.getter.account(),
who.public()
);

let part = perform_operation(matches, &TrustedOperationSigned::get(tsgetter)).unwrap();
let top: TrustedOperation = TrustedGetter::registration(
sr25519_core::Public::from(who.public()),
shard, // for encointer we assume that every currency has its own shard. so shard == cid
)
.sign(&sr25519_core::Pair::from(who))
.into();
let part = perform_operation(matches, &top).unwrap();
let participant: ParticipantIndexType = Decode::decode(&mut part.as_slice()).unwrap();
println!("Participant index: {:?}", participant);
Ok(())
Expand Down Expand Up @@ -290,26 +286,24 @@ pub fn cmd<'a>(
let arg_who = matches.value_of("accountid").unwrap();
let who = get_pair_from_str(matches, arg_who);
let (mrenclave, shard) = get_identifiers(matches);

let nonce = 0; // FIXME: hard coded for now
let attestation_args: Vec<_> = matches.values_of("attestations").unwrap().collect();
let mut attestations: Vec<Attestation<MultiSignature, AccountId32, Moment>> = vec![];
for arg in attestation_args.iter() {
let w = Attestation::decode(&mut &hex::decode(arg).unwrap()[..]).unwrap();
attestations.push(w);
}

let tcall = TrustedCall::ceremonies_register_attestations(
sr25519_core::Public::from(who.public()),
attestations
);
let nonce = 0; // FIXME: hard coded for now
let tscall =
tcall.sign(&sr25519_core::Pair::from(who), nonce, &mrenclave, &shard);
println!(
"send TrustedCall::register_attestations for {}",
tscall.call.account(),
who.public()
);
perform_operation(matches, &TrustedOperationSigned::call(tscall));
let top: TrustedOperation = TrustedCall::ceremonies_register_attestations(
sr25519_core::Public::from(who.public()),
attestations
)
.sign(&sr25519_core::Pair::from(who), nonce, &mrenclave, &shard)
.into();
perform_operation(matches, &top);
Ok(())
}),
)
Expand All @@ -329,18 +323,17 @@ pub fn cmd<'a>(
let arg_who = matches.value_of("accountid").unwrap();
let who = get_pair_from_str(matches, arg_who);
let (_mrenclave, shard) = get_identifiers(matches);
let tgetter = TrustedGetter::attestations(
sr25519_core::Public::from(who.public()),
shard, // for encointer we assume that every currency has its own shard. so shard == cid
);
let tsgetter =
tgetter.sign(&sr25519_core::Pair::from(who));
println!(
"send TrustedGetter::get_attestations for {}",
tsgetter.getter.account(),
who.public(),
);

let attestations = perform_operation(matches, &TrustedOperationSigned::get(tsgetter)).unwrap();
let top: TrustedOperation = TrustedGetter::attestations(
sr25519_core::Public::from(who.public()),
shard, // for encointer we assume that every currency has its own shard. so shard == cid
)
.sign(&sr25519_core::Pair::from(who))
.into();
let attestations = perform_operation(matches, &top).unwrap();
println!("Attestations: {:?}", hex::encode(attestations));
Ok(())
}),
Expand Down Expand Up @@ -374,11 +367,11 @@ pub fn cmd<'a>(
.unwrap();

let (_mrenclave, shard) = get_identifiers(matches);
let top: TrustedOperation = TrustedGetter::meetup_index_time_and_location(who.public().into(), shard)
.sign(&sr25519_core::Pair::from(who.clone()))
.into();

let tgetter = TrustedGetter::meetup_index_time_and_location(who.public().into(), shard);
let tsgetter = tgetter.sign(&sr25519_core::Pair::from(who.clone()));

let res = perform_operation(matches, &TrustedOperationSigned::get(tsgetter)).unwrap();
let res = perform_operation(matches, &top).unwrap();
let (mindex, mlocation, mtime): (MeetupIndexType, Option<Location>, Option<Moment>) = Decode::decode(&mut res.as_slice()).unwrap();
info!("got mindex: {:?}", mindex);
info!("got time: {:?}", mtime);
Expand Down
57 changes: 54 additions & 3 deletions stf/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -63,9 +63,60 @@ pub type State = sp_io::SgxExternalities;

#[derive(Encode, Decode, Clone)]
#[allow(non_camel_case_types)]
pub enum TrustedOperationSigned {
pub enum TrustedOperation {
call(TrustedCallSigned),
get(TrustedGetterSigned),
get(Getter),
}

impl From<TrustedCallSigned> for TrustedOperation {
fn from(item: TrustedCallSigned) -> Self {
TrustedOperation::call(item)
}
}

impl From<Getter> for TrustedOperation {
fn from(item: Getter) -> Self {
TrustedOperation::get(item)
}
}

impl From<TrustedGetterSigned> for TrustedOperation {
fn from(item: TrustedGetterSigned) -> Self {
TrustedOperation::get(item.into())
}
}

impl From<PublicGetter> for TrustedOperation {
fn from(item: PublicGetter) -> Self {
TrustedOperation::get(item.into())
}
}



#[derive(Encode, Decode, Clone, Debug)]
#[allow(non_camel_case_types)]
pub enum Getter {
public(PublicGetter),
trusted(TrustedGetterSigned)
}

impl From<PublicGetter> for Getter {
fn from(item: PublicGetter) -> Self {
Getter::public(item)
}
}

impl From<TrustedGetterSigned> for Getter {
fn from(item: TrustedGetterSigned) -> Self {
Getter::trusted(item)
}
}

#[derive(Encode, Decode, Clone, Debug)]
#[allow(non_camel_case_types)]
pub enum PublicGetter {
total_issuance(CurrencyIdentifier),
}

#[derive(Encode, Decode, Clone, Debug)]
Expand Down Expand Up @@ -113,7 +164,7 @@ pub enum TrustedGetter {
balance(AccountId, CurrencyIdentifier),
registration(AccountId, CurrencyIdentifier),
meetup_index_time_and_location(AccountId, CurrencyIdentifier),
attestations(AccountId, CurrencyIdentifier)
attestations(AccountId, CurrencyIdentifier),
}

impl TrustedGetter {
Expand Down
Loading